触摸按键Android的驱动解析

最新推荐文章于 2024-07-24 08:56:18 发布
最新推荐文章于 2024-07-24 08:56:18 发布
阅读量5.3k 收藏 3
点赞数
分类专栏： Android 文章标签： android struct timer input callback button
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Baiduluckyboy/article/details/6616533
版权
 

/*---------------------------------------------------------------------------------------------------------
 * driver/input/touchscreen/goodix_touch.c
 *
 * Copyright(c) 2010 Goodix Technology Corp.    
 * Author: Eltonny
 * Date: 2010.11.11                                   
 *                                                                                                        
 *---------------------------------------------------------------------------------------------------------*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/time.h>
#include <linux/delay.h>
#define DEBUG 1
#include <linux/device.h>
#include <linux/earlysuspend.h>
#include <linux/platform_device.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>
#include <linux/gpio.h>
#include <linux/ioc4.h>
#include <linux/io.h>
#include <mach/ut210_gpio_reg.h>
#include "goodix_touch.h"
#include "goodix_queue.h"

#ifndef GUITAR_GT80X
#error The code does not match the hardware version.
#endif

#define GOODIX_DEBUG_F
#ifdef GOODIX_DEBUG_F
#define GOODIXTS_DEBUG(fmt,args...)  printk(  "[goodix_ts]: " fmt, ## args) //printk( KERN_DEBUG "[egalax_i2c]: " fmt, ## args)
#define DBG() printk("[%s]:%d => \n",__FUNCTION__,__LINE__)
#else
#define GOODIXTS_DEBUG(fmt,args...)  do{ }while(0)
#define DBG() do{ }while(0)
#endif

#ifdef utv210
static volatile  VIC_REG *VICREG;                

static volatile UT210_GPIO_REG *UT210_GPIOREG;    //denis_wei add 2010-12-08
#define TIMER     //采用的是定时器扫描的方式

#ifdef  EINT29     //如果是定义EINT29表示采用的是中断的方式    是对中断的定义 
#define EINT_KEY      (IRQ_RTC_TIC)//按键中断
#define KEY_EINT_EN  do { VICREG->VICINTENABLE  |= (0x1<<29); \
 VICREG->VICINTENCLEAR &= (~(0x1<<29));}while(0)
#define KEY_EINT_DIS  do {VICREG->VICINTENABLE  &= (~(0x1<<29));\
 VICREG->VICINTENCLEAR |= (0x1<<29); } while(0) 
static void goodix_key_callback(struct work_struct *work);
static DECLARE_WORK(key_work, goodix_key_callback);
static struct input_dev * s_input_dev = NULL;
#endif

/***wangyulu******/
#define MAX_BUTTON_CNT 3
static int goodix_scancode[MAX_BUTTON_CNT] = {0x1A,0x1B,0x1C};
static int goodix_keycode[MAX_BUTTON_CNT] = {KEY_BACK, KEY_HOME,KEY_MENU};
static int goodix_scancode_history[MAX_BUTTON_CNT] = {0,0,0,0};

///wangyulu lock_key time
#ifdef TIMER    //对定时器的定义
#define KEY_DETECT_INTERVAL      (msecs_to_jiffies(60))//定时60ms
static struct timer_list key_timer;
static void lockkey_timer_callback(struct work_struct *work);
static DECLARE_WORK(lock_work, lockkey_timer_callback);
static struct input_dev * s_input_dev = NULL;
static void goodix_key_timer_handler(unsigned long data);
#endif
#endif
#define MID706_SP  
static struct point_queue  finger_list; //record the fingers list
/*************************************************/
static struct i2c_client * i2c_connect_client = NULL;
#ifdef CONFIG_HAS_EARLYSUSPEND
static void goodix_ts_early_suspend(struct early_suspend *h);
static void goodix_ts_late_resume(struct early_suspend *h);
#endif
#define GOODIX_KEY_I2C (0xC4>>1)//触摸按键芯片的设备地址
/*Function as i2c_master_send */
static int i2c_write_key(struct i2c_client *client,uint8_t *data,int len)
{
 struct i2c_msg msg;
 int ret=-1;
 //发送设备地址
 msg.flags=!I2C_M_RD;//写消息
 msg.addr=GOODIX_KEY_I2C;
 msg.len=len;
 msg.buf=data;  
 ret=i2c_transfer(i2c_get_adapter(1),&msg,1);
 return ret;
}
//************ urbetter+ ******************
static int goodix_i2c_rxdata(char *rxdata, int length)
{
 int ret;
 struct i2c_msg msgs[] = {
  {
   .addr = GOODIX_KEY_I2C,
   .flags = 0,
   .len = 1,
   .buf = rxdata,
  },
  {
   .addr = GOODIX_KEY_I2C,
   .flags = I2C_M_RD,
   .len = length,
   .buf = rxdata,
  },
 };
 ret = i2c_transfer(i2c_get_adapter(1), msgs, 2);//i2c_get_adapter(1)选着iic 1
 if (ret < 0)
  pr_err("msg %s i2c read error: %d\n", __func__, ret);
 
 return ret;
}
#ifdef TIMER
轮询处理函数wangyulu
static void goodix_key_timer_handler(unsigned long data)
{
 //ceshi
 schedule_work(&lock_work);
 mod_timer(&key_timer,jiffies + KEY_DETECT_INTERVAL);
}
/lock_key的处理函数 key_703 wangyulu
static void lockkey_timer_callback(struct work_struct *work)
{
     int i;
 int boy_flag = 0;
 unsigned char buf[2];
 buf[0] = 0xc5;
 goodix_i2c_rxdata(buf, 1);
 //printk("key_TIMER=0x%02X\n", buf[0]); //没有按下是0xff  boy
 for(i = 0; i < MAX_BUTTON_CNT; i++)
 {  
      if((buf[0] == goodix_scancode_history[i]) || (buf[0] == goodix_scancode[i]))
      {
            printk("key_TIMER=0x%02X\n", buf[0]); //没有按下是0xff  boy
            goodix_scancode_history[i]= buf[0];
        input_report_key(s_input_dev, goodix_keycode[i], 1);
     }
      if(buf[0] == 0xFF)
      {
        input_report_key(s_input_dev, goodix_keycode[i], 0);
      }
 }
}

#endif
static int goodix_key_input_init(struct goodix_ts_data *ts)
{
 int i;
 s_input_dev = ts->input_dev;
 set_bit(EV_KEY, ts->input_dev->evbit);
 for(i = 0; i < MAX_BUTTON_CNT; i++)
  set_bit(goodix_keycode[i], ts->input_dev->keybit);
         /******wangyulu********添加time*****/
#ifdef TIMER
          init_timer(&key_timer);
      key_timer.function = goodix_key_timer_handler;
      key_timer.expires = jiffies + KEY_DETECT_INTERVAL;
      add_timer(&key_timer);
#endif
}
static int goodix_init_key(struct goodix_ts_data *ts)
{
 int ret=-1;
#ifdef EINT29
 //KEY_EINT_NUM INT11 wangyulu
 gpio_request(S5PV210_GPH3(5), "goodix_key_int");
 s3c_gpio_cfgpin(S5PV210_GPH3(5), 0xf<<20);
 s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_DOWN);
 set_irq_type(EINT_KEY, IRQ_TYPE_EDGE_RISING);
 gpio_free(S5PV210_GPH3(5));
 KEY_EINT_EN;
#else
 if(ts->use_irq)
  enable_irq(ts->client->irq);
#endif
 uint8_t config_info[]={
          0x88,0x08,0x90,0x90,0x90,0x90,0x50,0x58,0x55,0x56,
       0x0e,0x00,0x00,0x00,0x09,0x04,0x00,0x00,0x00,
       0x00,0x05,0x06,0x07,0x00,0xc8};
#endif

 ret=i2c_write_key(ts->client,config_info,sizeof(config_info));

 if(ret > 0)
  ret = 0;
     goodix_key_input_init(ts); //urbetter+ boy
 return ret;
}
#ifdef EINT29
///add wangyulu 按键中断处理函数
static irqreturn_t goodix_key_irq_handler(int irq, void *dev_id)
{
 struct goodix_ts_data *ts = dev_id;
     printk("goodix_key_irq_handler\n"); //没有按下是0xff  boy
 KEY_EINT_DIS;
 schedule_work(&key_work);
 return IRQ_HANDLED;
}
static void goodix_key_callback(struct work_struct *work)/adb wangyulu interrupter
{

     int i;
 int boy_flag = 0;
 unsigned char buf[2];
 buf[0] = 0xc5;
 goodix_i2c_rxdata(buf, 1);
 printk("key_EINT29=0x%02X\n", buf[0]); //没有按下是0xff  boy
 for(i = 0; i < MAX_BUTTON_CNT; i++)
 {  
      if((buf[0] == goodix_scancode_history[i]) || (buf[0] == goodix_scancode[i]))
      {
           goodix_scancode_history[i]= buf[0];
          input_report_key(s_input_dev, goodix_keycode[i], 1);
     }
      if(buf[0] == 0xFF)
      {
         input_report_key(s_input_dev, goodix_keycode[i], 0);
      }
 }
     KEY_EINT_EN;
}
#endif

static void utv210_gpio_init(void)
{
     int ret = 0;
     VICREG = ioremap(0xf2000000, sizeof(VIC_REG));                   
     UT210_GPIOREG  = ioremap(0xe0200000, sizeof(UT210_GPIO_REG)); 
     //wangyulu key
#ifdef EINT29
 set_irq_type(EINT_KEY, IRQ_TYPE_EDGE_RISING);
     ret = gpio_request(S5PV210_GPH3(5), "goodix_key_int");
 if (ret < 0) {
    gpio_free(S5PV210_GPH3(5));  // now bug; TODO
 }
 ret = gpio_request(S5PV210_GPH3(5), "goodix_key_int");
 s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_DOWN);
     gpio_free(S5PV210_GPH3(5));
     //denis_wei add 2010-12-10 for touch interrupt detect
     UT210_GPIOREG->GPH1.GP_CON &= ~((0xf<<20) );//gph13 as input port
 UT210_GPIOREG->GPH1.GP_CON |= ((0xf<<20));//gph13 interrupt port
     UT210_GPIOREG->GPH1.GP_DAT &= ~((0x1<<20) );//gph13. output 1 
 UT210_GPIOREG->GPH1.GP_PUD &= ~((0x3<<20) );//gph13 pull disable
 UT210_GPIOREG->GPH1.GP_PUD |= ((0x2<<20));//gph13 pull-up enable
#endif
#ifdef TIMER
     s3c_gpio_cfgpin(S5PV210_GPH3(5), 0x0<<20);
 gpio_direction_output(S5PV210_GPH3(5), 1);
 s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_DOWN);
#endif   
}
/******************************************************* 
功能：
 触摸屏探测函数
 在注册驱动时调用（要求存在对应的client）；
 用于IO,中断等资源申请；设备注册；触摸屏初始化等工作
参数：
 client：待驱动的设备结构体
 id：设备ID
return：
 执行结果码，0表示正常执行
********************************************************/
static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
 struct goodix_ts_data *ts;
 int ret = 0;
 int retry=0;
 int count=0;

 u8 testbuf[6] = {0, 0, 0, 0, 0};
 struct goodix_i2c_rmi_platform_data *pdata;
 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 {
  dev_err(&client->dev, "System need I2C function.\n");
  ret = -ENODEV;
  goto err_check_functionality_failed;
 }
 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 if (ts == NULL) {
  ret = -ENOMEM;
  goto err_alloc_data_failed;
 }
 //utv210_gpio_init(); 
 /***wangyulu****/
 ts->client = client;
 i2c_set_clientdata(client, ts);
 pdata = client->dev.platform_data; 
 ts->input_dev = input_allocate_device();
 if (ts->input_dev == NULL) {
  ret = -ENOMEM;
  dev_dbg(&client->dev,"Failed to allocate input device\n");
  goto err_input_dev_alloc_failed;
 }
 ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);

     ret = input_register_device(ts->input_dev);
 if (ret) {
  dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);
   goto  err_input_register_device_failed;
 }
 utv210_gpio_init(); 
 goodix_init_key(ts);
#ifdef EINT29
///wangyulu 按键中断申请
 ret = request_irq(EINT_KEY, goodix_key_irq_handler,   IRQ_TYPE_EDGE_RISING, client->name, ts);
 if( ret )
 {
  printk("Can't allocate touchscreen's interrupt\n");
  dev_err(&client->dev,"Can't allocate touchscreen's interrupt!ERRNO:%d\n", ret);
  goto Fail_utv210_int;
 }
 ts->use_irq = 1;
 KEY_EINT_DIS;
#endif
 printk("#############line =%d\n", __LINE__);
err_input_register_device_failed:
 input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
  i2c_set_clientdata(client, NULL);
Fail_utv210_int:
err_alloc_data_failed:
err_check_functionality_failed:
 return ret;
}
/******************************************************* 
功能：
 驱动资源释放
参数：
 client：设备结构体
return：
 执行结果码，0表示正常执行
********************************************************/
static int goodix_ts_remove(struct i2c_client *client)
{
 struct goodix_ts_data *ts = i2c_get_clientdata(client);
 unregister_early_suspend(&ts->early_suspend);
 dev_notice(&client->dev,"The driver is removing...\n");
 i2c_set_clientdata(client, NULL);
 input_unregister_device(ts->input_dev);
#ifdef EINT29 
  free_irq(EINT_KEY, ts);
#endif
 if(ts->input_dev)
  kfree(ts->input_dev);
 kfree(ts);
 return 0;
}
//停用设备
static int goodix_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
 int ret;
 struct goodix_ts_data *ts = i2c_get_clientdata(client);

 if(ts->bad_data)
     return 0;
 }
static int goodix_ts_resume(struct i2c_client *client)
{
 int ret;
 struct goodix_ts_data *ts = i2c_get_clientdata(client);

 if(ts->bad_data)
  return 0;
#ifdef EINT29
     KEY_EINT_EN;
#else
 if (ts->use_irq) {
  enable_irq(client->irq);
 }
#endif
  return 0;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void goodix_ts_early_suspend(struct early_suspend *h)
{
   
 struct goodix_ts_data *ts;
 ts = container_of(h, struct goodix_ts_data, early_suspend);
 goodix_ts_suspend(ts->client, PMSG_SUSPEND);
}

static void goodix_ts_late_resume(struct early_suspend *h)
{
 struct goodix_ts_data *ts;
 ts = container_of(h, struct goodix_ts_data, early_suspend);
 goodix_ts_resume(ts->client);
 
}
#endif
#undef GOODIX_I2C_NAME
#define GOODIX_I2C_NAME "Goodix-key-703" //boy
static const struct i2c_device_id goodix_ts_id[] = {
 { GOODIX_I2C_NAME, 0 },
 { }
};
//设备驱动结构体
struct i2c_driver goodix_ts_driver = {
 .probe  = goodix_ts_probe,
 .remove  = goodix_ts_remove,
#ifndef CONFIG_HAS_EARLYSUSPEND
 .suspend = goodix_ts_suspend,
 .resume  = goodix_ts_resume,
#endif
 .id_table = goodix_ts_id,
 .driver = {
  .name = GOODIX_I2C_NAME,
  .owner = THIS_MODULE,
 },
};
/******************************************************* 
功能：
 驱动加载函数
return：
 执行结果码，0表示正常执行
********************************************************/
 static int __devinit goodix_ts_init(void)
 {
  int ret;
   ret=i2c_add_driver(&goodix_ts_driver);
  return ret;
 }
/******************************************************* 
功能：
 驱动卸载函数
参数：
 client：设备结构体
********************************************************/
 static void __exit goodix_ts_exit(void)
 {
   i2c_del_driver(&goodix_ts_driver);
 }

late_initcall(goodix_ts_init);
module_exit(goodix_ts_exit);

MODULE_DESCRIPTION("Goodix Touchscreen Driver");
MODULE_LICENSE("GPL");
希望能够和大家分享，如有疑问可以给我留言，谢谢

丰满
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
Android 虚拟按键驱动
qq_34694875的博客
10-24 338
android 添加虚拟按键驱动，添加新的按键
android4.0触摸屏(touchscreen)以及屏幕按键驱动解析
My_way_的专栏
02-19 2432
转自：http://www.xuebuyuan.com/1364968.html       本人用的触摸屏IC是FocalTech公司的ft5306，是一款i2c的电容屏多点触控芯片。对于它的整体驱动官方已经给了，我们就触摸屏和按键部分的代码做相关说明。说明其中应该注意的地方。 对于所有的input设备，报告input事件时候都分这么几部分，首先在probe文件中设置设备发送的
S5PV210 Android 触摸按键驱动解析
铁甲 - 环形电子
09-04 2856
/*--------------------------------------------------------------------------------------------------------- * driver/input/touchscreen/goodix_touch.c * * Copyright(c) 2010 Goodix Technology Corp.
android uinput 按键_Android 触摸屏Event上报操作
weixin_39622225的博客
12-22 851
手机设备上常用触摸屏进行用户操作，非常方便快捷，而且正好有个项目上用到这个设备，所以就花时间研究了一下。好了，还是老规则：大体了解概念先，细节线索找代码：InputReader.cpp 中有针对单点触摸SingleTouchInputMapper及多点触摸MultiTouchInputMapper的处理代码，这两个类都继承自TouchInputMapper，由syncTouch处理最终的触摸屏动作...
android 电容触摸屏,剖析触摸屏上的电容按键
weixin_39796855的博客
05-26 504
硬件设计当前，移动终端上的按键大部分都是电容按键。电容按键的基本原理跟电容触摸屏是一样的，都是感知被触摸时，电极之间电容值的变化，来判断当前是否有触摸动作。抛开触摸屏，市面上大部分独立电容按键的设计，都是RC串联电路(如图1)，VCC一端不断发出扫描脉冲，使电路中电容C1重复充放电，从而在A点引起电压变化。由于有触摸时，会引起电容值增加，从而引起充放电周期变长。若把有触摸时，电容C1充放电周期为T...
Android TP驱动模型框架分析
qq_33782617的博客
12-18 2013
介绍tp驱动的大致移植内容
Android TP驱动分析
Mr.How的专栏
02-26 5124
文章目录一、TP的硬件接口二、代码路径三、TP代码分析1、硬件参数设置2、TP设备驱动3、TP模组驱动 一、TP的硬件接口 引脚 名称及作用 VDD TP供电 RESET 复位引脚 EINT 中断引脚 SCL、SDA I2C接口 ​ TP的工作方式比较简单： 上电后通过RESET脚控制TP芯片复位； 通过I2C接口给TP设置参数或读取TP数据； TP有触摸操作时通过EINT脚通知主控； 二、代码路径 描述 路径 文件 系统设置 device\top\t
锤子t1android驱动,锤子坚果R1驱动
weixin_35203943的博客
05-28 1149
软件标签：锤子坚果R1手机驱动是锤子手机官方针对该型号手机推出的驱动程序，安装驱动后，手机就可以被电脑识别了，同时可以帮助用户解决锤子坚果R1手机与电脑连接异常等问题，连接之后就可以进行刷机root、文件互传、手机管理等功能了，小编提供了驱动下载，需要的朋友不要错过哦!锤子坚果R1驱动安装说明1、在51驱动网下载‘锤子坚果R1’手机驱动程序，解压后，双击运行‘HandShaker_Win7_Web...
Android输入系统解析及Native层模拟按键方案
KarlMarxs的博客
03-27 2008
Android输入系统解析及Native层模拟按键方案 目录 1 Android输入系统 1.1 Android Input核心交互 1.1.1 文件节点读写 1.1.2 Framework层抓取事件 1.1.2 节点传输协议 1.2模拟按键方式 1.2.1 Java层方案 1.2.2 C层方案 2 Amlogic模拟按键实践 2.1基于鼠标的本地模拟 2.2 Frame...
android驱动之虚拟按键
04-27
### Android驱动之虚拟按键：深入理解与实现 在Android设备中，虚拟按键作为一种常见的交互设计，为用户提供了直观且便捷的操作体验。它们替代了物理按键的功能，尤其在全面屏手机中，虚拟按键的设计成为了标准配置...
android 按键驱动
05-26
标题："Android按键驱动" 描述："Android按键驱动Mini2440所用到的按键资源" 在深入探讨Android按键驱动在Mini2440平台上的应用之前，我们首先需要理解几个核心概念：按键驱动、Mini2440以及它们在Android系统中的...
基于Android的触摸屏驱动开发.pdf
09-21
开发过程中，开发者需要编写适配特定触摸屏硬件的驱动程序，确保驱动程序能够正确解析硬件发送的触摸事件，并将其转换为Android系统能理解的格式。驱动程序还需要支持电源管理功能，例如在无触摸活动时降低屏幕亮度...
Android s3c2440 触摸屏驱动
10-08
接下来，我们将详细解析s3c2440触摸屏驱动的工作原理及其关键组件。 ### 驱动结构概述 s3c2440触摸屏驱动采用的是字符设备加平台设备的驱动模型，主要包括四个核心函数：`probe`、`remove`、`resume`和`suspend`。...
安卓Android源码——按键的处理.zip
10-12
- **Input子系统**：Android的Input子系统负责收集来自各种输入设备（包括硬件按键和触摸屏）的事件，通过`InputReader`读取，然后由`InputDispatcher`分发到相应应用程序或系统服务。 - **Keycode映射**：不同的...
Android Kotlin：协程
qq_40853919的博客
07-23 660
1）协程是什么？2）协程和线程的关系？3）协程如何使用？切线程是什么4）挂起函数是什么？5）withContext和lanuch的区别在哪里？6）Defualt、IO和Main的区别。
Android 自定义系统版本号
码点
07-22 379
通过查看编译完成后的文件 out/target/product/generic_x86_64/system/build.prop 确认是否修改完成。重新编译,可以直接make，无需清理out文件夹重新花费大量时间全部编译。framework开发，实现自定义系统版本号。
uniapp安卓通过绝对路径获取文件
qq_61950936的博客
07-23 381
请确保你的uniapp应用具有读取存储的权限，并且该文件确实存在于指定的路径。此外，你的应用可能需要运行在Android 4.4及以上版本的设备上，因为plus.io API是基于HTML5 Plus的，而这个特性需要设备的Android版本和浏览器支持。在uniapp中，如果你想要访问安卓设备上的文件，你需要使用uniapp提供的plus.io API。这个API允许你在应用内访问设备的文件系统。
Android SurfaceFlinger——GraphicBuffer内存申请（三十）
最新发布
小旭的专栏
07-24 1170
在Android的图形子系统中，GraphicBufferAllocator 和 GraphicBufferMapper 是处理图形缓冲区的核心组件。这两个类分别负责缓冲区的分配和映射，是 GraphicBuffer 类的基础，GraphicBuffer 用于封装和管理图形数据。
Linux电容触摸屏驱动与多点触摸解析
"电容触摸屏Linux驱动技术讲解，包括硬件原理、Linux内核输入子系统、用户空间编程接口及坐标校正等内容。" 在嵌入式系统中，触摸屏是人机交互的关键组件，尤其在Android等移动操作系统上。本文主要关注电容触摸屏...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值