Linux下I2C接口触摸屏驱动分析

最新推荐文章于 2024-06-08 08:15:41 发布
最新推荐文章于 2024-06-08 08:15:41 发布
阅读量2.9k 收藏 13
点赞数 3
分类专栏： 移动开发

Linux下I2C接口触摸屏驱动分析 

分类： LINUX

linux下触摸屏驱动的移植主要包括这几个步骤：

    (1)确定触摸屏IC接口，了解对应接口的API函数，注册设备并加入到相应总线上

    (2)关联设备与驱动，并编写具体的驱动代码

    (3)熟悉linux 输入设备驱动，在驱动代码中分配一个输入设备并初始化相应数据结构，在驱动实现中引用

    这里对应上面几部分，分析I2C接口下触摸屏驱动的实现。先介绍linux下I2C接口与输入子系统架构，然后基于FT5x0x源码逐层展开整个移植过程的实现。

一、I2C驱动架构

linux I2C驱动架构

    具体的实现可分为四个层次：

    1、提供adapter的硬件驱动，探测、初始化i2c adapter（如申请i2c的io地址和中断号），驱动soc控制的i2c adapter在硬件上产生信号（start、stop、ack）以及处理i2c中断。覆盖图中的硬件实现层。主要数据结构struct i2c_adapter

 

查看文本copy to clipboard打印?

  1. struct i2c_adapter {    
  2.     struct module *owner;    
  3.     unsigned int id;    
  4.     unsigned int class;    
  5.     struct i2c_algorithm *algo;/* the algorithm to access the bus   */    
  6.     void *algo_data;    
  7.     
  8.     /* --- administration stuff. */    
  9.     int (*client_register)(struct i2c_client *);    
  10.     int (*client_unregister)(struct i2c_client *);    
  11.     
  12.     /* data fields that are valid for all devices   */    
  13.     struct mutex bus_lock;    
  14.     struct mutex clist_lock;    
  15.     
  16.     int timeout;    
  17.     int retries;    
  18.     struct device dev;      /* the adapter device */    
  19.     struct class_device class_dev;  /* the class device */    
  20.     
  21.     int nr;    
  22.     struct list_head clients;    
  23.     struct list_head list;    
  24.     char name[I2C_NAME_SIZE];    
  25.     struct completion dev_released;    
  26.     struct completion class_dev_released;    
  27. };  


    这个结构体对应一个控制器。其中包含了控制器名称，algorithm数据，控制器设备等。

 

    2、提供adapter的algorithm，用具体适配器的xxx_xferf()函数来填充i2c_algorithm的master_xfer函数指针，并把赋值后的i2c_algorithm再赋值给i2c_adapter的algo指针。覆盖图中的访问抽象层、i2c核心层。主要数据结构struct i2c_algorithm

 

查看文本copy to clipboard打印?

  1. struct i2c_algorithm {    
  2.     int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,     
  3.                        int num);    
  4.     int (*slave_send)(struct i2c_adapter *,char*,int);    
  5.     int (*slave_recv)(struct i2c_adapter *,char*,int);    
  6.     u32 (*functionality) (struct i2c_adapter *);    
  7. };   

    这个结构体中定义了一套控制器使用的通信方法。其中关键函数是master_xfer()。实际工作中很重要一点就是要实现这个函数。
 

 

    3、实现i2c设备驱动中的i2c_driver接口，由结构i2c_client中的数据填充，覆盖图中的driver驱动层。主要数据结构

 

查看文本copy to clipboard打印?

  1. struct i2c_client {    
  2.     unsigned int flags;     /* div., see below      */    
  3.     unsigned short addr;        /* chip address - NOTE: 7bit    */    
  4.                     /* addresses are stored in the  */    
  5.                     /* _LOWER_ 7 bits       */    
  6.     struct i2c_adapter *adapter;    /* the adapter we sit on    */    
  7.     struct i2c_driver *driver;  /* and our access routines  */    
  8.     int usage_count;        /* How many accesses currently  */    
  9.                     /* to the client        */    
  10.     struct device dev;      /* the device structure     */    
  11.     struct list_head list;    
  12.     char name[I2C_NAME_SIZE];    
  13.     struct completion released;    
  14. };  

    这个结构体中的内容是描述设备的。包含了芯片地址，设备名称，设备使用的中断号，设备所依附的控制器，设备所依附的驱动等内容。

 

    4、实现i2c设备所对应的具体device的驱动。覆盖图中的driver驱动层。主要数据结构struct i2c_driver 

查看文本copy to clipboard打印?

  1. struct i2c_driver {    
  2.     int id;    
  3.     unsigned int class;    
  4.     
  5.     int (*attach_adapter)(struct i2c_adapter *);    
  6.     int (*detach_adapter)(struct i2c_adapter *);    
  7.     
  8.     int (*detach_client)(struct i2c_client *);    
  9.     
  10.     int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);    
  11.     struct device_driver driver;    
  12.     struct list_head list;    
  13. };  


    这个结构体对应了驱动方法，重要成员函数有probe，remove，suspend，resume与中断处理函数，也是我们需要是实现的函数。另外包括一个重要的数据结构: struct i2c_device_id *id_table; 如果驱动可以支持好几个设备，那么这里面就要包含这些设备的ID。

 

    第一层和第二层是i2c总线驱动，属于芯片内部的驱动，在linux驱动架构中已经实现，不需要我们编写或更改。第三第四属于i2c设备驱动，需要我们根据内核提供的接口去完成具体的代码。

    另外就是i2c_core层，起到了承上启下的作用。源代码位于drivers/i2c/i2c-core.c中。在这里可以看到几个重要的函数。

    (1)增加/删除i2c控制器的函数

 

查看文本copy to clipboard打印?

  1. int i2c_add_adapter(struct i2c_adapter *adapter)    
  2. int i2c_del_adapter(struct i2c_adapter *adap)      

 

    (2)增加/删除i2c设备的函数

 

查看文本copy to clipboard打印?

  1. struct i2c_client *i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);    
  2. void i2c_unregister_device(struct i2c_client *client)  

 

    (3)增加/删除设备驱动的函数

 

查看文本copy to clipboard打印?

  1. int i2c_register_driver(struct module *owner, struct i2c_driver *driver)    
  2. void i2c_del_driver(struct i2c_driver *driver)   

 

    (4)I2C传输、发送和接收函数

 

查看文本copy to clipboard打印?

  1. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);    
  2. int i2c_master_send(struct i2c_client *client,const char *buf ,int count);    
  3. int i2c_master_recv(struct i2c_client *client, char *buf ,int count);  

 

    send和receive分别都调用了transfer函数，而transfer也不是直接和硬件交互，而是调用algorithm中的master_xfer()函数。

二、linux input输入子系统架构

 

linux输入系统框架

    linux输入子系统（linux input subsystem）从上到下由三层实现，分别为：输入子系统事件处理层（Event Handler）、输入子系统核心层（Input Core）和输入子系统设备驱动层。这些层次里的具体机制我们先不涉及，而我们要知道输入子系统里有事件处理层，我们完成驱动时很主要的一点就是为输入设备定义一个符合要求的事件集合。另外，在图中可以看出输入设备不止包括触摸屏，还有很多其他种类的输入设备，如键盘，鼠标等等，所以linux内核已经把各式各样的输入设备进行了抽象，提供了统一的接口，让我们把设备接入到系统中。而我们要做的工作就是申请一个输入设备结构体对象，并填充其里面的数据。

    把设备注册进输入子系统里一般要经过以下步骤：

    1、申请一个输入设备，定义事件集合。关于输入事件的介绍可以看这里：Linux 内核点触摸接口协议

    2、上报从设备中读到的数据。可使用函数

 

查看文本copy to clipboard打印?

  1. void input_report_key(struct input_dev *dev, unsigned int code, int value);      //上报按键事件  
  2. void input_report_rel(struct input_dev *dev, unsigned int code, int value);       //上报相对坐标事件  
  3. void input_report_abs(struct input_dev *dev, unsigned int code, int value);       //上报绝对坐标事件  

 

 

三、基于OMAP FT5x0x驱动源码分析

1、板级初始化代码

    板级初始化代码与具体的平台有关，负责相应平台的初始化工作，这里使用的pandaboard平台的代码，在目录arch/arm/mach-omap2/board-omap4panda.c中。触摸屏设备当然需要在这里先声明并注册进系统。具体代码如下：

 

查看文本copy to clipboard打印?

  1. static struct i2c_board_info __initdata panda_i2c2_boardinfo[] = {  
  2. {  
  3.     I2C_BOARD_INFO("ft5x06_ts", 0x38),  
  4.     .irq = OMAP_GPIO_IRQ(34),  
  5. },  
  6. };  
  7. omap_register_i2c_bus(2, 100, panda_i2c2_boardinfo,ARRAY_SIZE(panda_i2c2_boardinfo));  

     声明一个i2c_board_info结构的数组，这个数组包含pandaboard板上i2c接口的信息。先使用宏I2C_BOARD_INFO宏声明设备名为ft5x06_ts，地址为0x38。要说明的是这里的地址并不是指处理器中i2c寄存器的硬件地址，而是在系统加载后，位于/sys/bus/i2c/devices下的设备名。再申请这个i2c接口的中断口为GPIO34，这从板的硬件连接图可以看出。

 

    然后把这个结构体注册进i2c总线，使用omap_register_i2c_bus函数注册。

2、设备与驱动绑定

     设备与驱动绑定的代码位于目录drivers/input/touchscreen/ft5x0x.c中，这个文件包含了i2c设备的具体代码，以模块的形式编译进内核。

 

查看文本copy to clipboard打印?

  1. static const struct i2c_device_id ft5x0x_ts_id[] =  
  2. {  
  3.     { FT5X0X_NAME, 0 },{ }  
  4. };  
  5. MODULE_DEVICE_TABLE(i2c, ft5x0x_ts_id);  
  6.   
  7. static struct i2c_driver ft5x0x_ts_driver =  
  8. {  
  9.     .probe      = ft5x0x_ts_probe,  
  10.     .remove     = __devexit_p(ft5x0x_ts_remove),  
  11.     .id_table   = ft5x0x_ts_id,  
  12.     .driver =  
  13.     {  
  14.         .name   = FT5X0X_NAME,  
  15.         .owner  = THIS_MODULE,  
  16.     },  
  17. };  
  18.   
  19. static int __init ft5x0x_ts_init(void)  
  20. {  
  21.     return i2c_add_driver(&ft5x0x_ts_driver);  
  22. }  
  23.   
  24. static void __exit ft5x0x_ts_exit(void)  
  25. {  
  26.     i2c_del_driver(&ft5x0x_ts_driver);  
  27. }  
  28.   
  29. module_init(ft5x0x_ts_init);  
  30. module_exit(ft5x0x_ts_exit);  
  31.   
  32. MODULE_AUTHOR("");  
  33. MODULE_DESCRIPTION("FocalTech ft5x0x TouchScreen driver");  
  34. MODULE_LICENSE("GPL");  

    首先建立设备与驱动的映射表ft5x0x_ts_id，通过宏MODULE_DEVICE_TABLE关联起来，MODULE_DEVICE_TABLE第一个参数表示这个设备id是i2c总线上了，第二个参数是指设备，当系统找到这个设备时，就会通过FT5X0X_NAME把设备与这个模块关联起来。
     这是个i2c驱动模块，当然需要定义一个i2c_driver结构体来标识这个驱动，并说明实现的驱动函数有probe()和remove()函数。
     之后就是添加模块初始化和退出函数，分别是在模块初始化时调用i2c_add_driver()加入i2c驱动，在模块退出时调用i2c_del_driver删除i2c驱动。

3、设备驱动程序实现
     从上面i2c_driver结构可以看出，ft5x0x实现了驱动的两个接口函数，分别为probe()和remove()函数。
     probe()具体实现函数为ft5x0x_ts_probe(),这个函数在内核初始化时，如果设备和驱动匹配，将调用，实现i2c设备的初始化，具体实现：

 

 

查看文本copy to clipboard打印?

  1. static int ft5x0x_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)  
  2. {  
  3.     struct ft5x0x_ts_data *ft5x0x_ts;  
  4.     struct input_dev *input_dev;  
  5.     int err = 0;  
  6.     int rev_id = 0;  
  7.       
  8.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {  
  9.         err = -ENODEV;  
  10.         goto err_out;  
  11.     }  
  12.   
  13.     ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL);  
  14.     if (!ft5x0x_ts) {  
  15.         err = -ENOMEM;  
  16.         goto err_free_mem;  
  17.     }  
  18.   
  19.     this_client = client;  
  20.         i2c_set_clientdata(client, ft5x0x_ts);  
  21.   
  22.     rev_id = i2c_smbus_read_byte_data(client, FT5X0X_REG_FT5201ID);  
  23.     if (rev_id != FT5X06_ID)  
  24.     {  
  25.         err = -ENODEV;  
  26.         dev_err(&client->dev, "failed to probe FT5X0X touchscreen device\n");  
  27.         goto err_free_mem;  
  28.     }  
  29.   
  30.     INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work);  
  31.     ft5x0x_ts->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));  
  32.     if (!ft5x0x_ts->ts_workqueue)  
  33.     {  
  34.         err = -ESRCH;  
  35.         goto err_free_thread;  
  36.     }  
  37.   
  38.     err = request_irq(client->irq, ft5x0x_ts_interrupt, IRQF_DISABLED | IRQF_TRIGGER_RISING, "ft5x0x_ts", ft5x0x_ts);  
  39.     if (err < 0)  
  40.     {  
  41.         dev_err(&client->dev, "request irq failed\n");  
  42.         goto err_free_irq;  
  43.     }  
  44.   
  45.     input_dev = input_allocate_device();  
  46.     if (!input_dev)  
  47.     {  
  48.         err = -ENOMEM;  
  49.         dev_err(&client->dev, "failed to allocate input device\n");  
  50.         goto err_free_input;  
  51.     }  
  52.       
  53.     ft5x0x_ts->input_dev = input_dev;  
  54.   
  55. #ifdef CONFIG_FT5X0X_MULTITOUCH  
  56.     set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit);  
  57.     set_bit(ABS_MT_POSITION_X, input_dev->absbit);  
  58.     set_bit(ABS_MT_POSITION_Y, input_dev->absbit);  
  59.     set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);  
  60.         set_bit(ABS_PRESSURE, input_dev->absbit);  
  61.   
  62.     input_set_abs_params(input_dev,  
  63.                  ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);  
  64.     input_set_abs_params(input_dev,  
  65.                  ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);  
  66.     input_set_abs_params(input_dev,  
  67.                  ABS_MT_TOUCH_MAJOR, 0, PRESS_MAX, 0, 0);  
  68.     input_set_abs_params(input_dev,  
  69.                  ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);  
  70. #else  
  71.     set_bit(ABS_X, input_dev->absbit);  
  72.     set_bit(ABS_Y, input_dev->absbit);  
  73.     set_bit(ABS_PRESSURE, input_dev->absbit);  
  74.     set_bit(BTN_TOUCH, input_dev->keybit);  
  75.   
  76.     input_set_abs_params(input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0);  
  77.     input_set_abs_params(input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0);  
  78.     input_set_abs_params(input_dev, ABS_PRESSURE, 0, PRESS_MAX, 0 , 0);  
  79. #endif  
  80.   
  81.     set_bit(EV_ABS, input_dev->evbit);  
  82.     set_bit(EV_KEY, input_dev->evbit);  
  83.   
  84.     input_dev->name  = FT5X0X_NAME;  
  85.     err = input_register_device(input_dev);  
  86.     if (err)  
  87.     {  
  88.         dev_err(&client->dev, "failed to register input device: %s\n",  
  89.         dev_name(&client->dev));  
  90.         goto err_free_input;  
  91.     }  
  92.   
  93. #ifdef CONFIG_HAS_EARLYSUSPEND  
  94.     ft5x0x_ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;  
  95.     ft5x0x_ts->early_suspend.suspend = ft5x0x_ts_suspend;  
  96.     ft5x0x_ts->early_suspend.resume  = ft5x0x_ts_resume;  
  97.     register_early_suspend(&ft5x0x_ts->early_suspend);  
  98. #endif  
  99.   
  100.     return 0;  
  101.   
  102. err_free_input:  
  103.     input_free_device(input_dev);  
  104. err_free_irq:  
  105.     free_irq(client->irq, ft5x0x_ts);  
  106. err_free_thread:  
  107.     cancel_work_sync(&ft5x0x_ts->pen_event_work);  
  108.     destroy_workqueue(ft5x0x_ts->ts_workqueue);  
  109.     i2c_set_clientdata(client, NULL);  
  110. err_free_mem:  
  111.     kfree(ft5x0x_ts);  
  112. err_out:  
  113.     return err;  
  114. }  

    这个函数代码比较长，但是可以分部分去看，每一部分对应不同的初始化工作.大概可以分为这几个部分：

    (1)检测适配器是否支持I2C_FUNC_I2C的通信方式 ：i2c_check_functionality(client->adapter, I2C_FUNC_I2C)

    (2)申请内存存储驱动的数据：ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL)；并把驱动数据赋值给系统传过来的i2c_client数据：this_client = client; i2c_set_clientdata(client, ft5x0x_ts);

    (3)验证将要通信的设备ID：rev_id = i2c_smbus_read_byte_data(client, FT5X0X_REG_FT5201ID);

    (4)创建触摸事件的工作队列并初始化工作队列的处理函数：INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work); ft5x0x_ts->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));

    (5)申请系统中断并声明中断处理函数；request_irq(client->irq, ft5x0x_ts_interrupt, IRQF_DISABLED | IRQF_TRIGGER_RISING, "ft5x0x_ts", ft5x0x_ts);

    (6)分配一个输入设备实例，初始化数据并注册进系统：input_dev = input_allocate_device(); input_register_device(input_dev);

    (7)如果定义了earlysuspend，声明其处理函数。earlysuspend用于对触摸屏类设备的电源管理，降低功耗。

    (8)最后对执行过程中可能出现的错误进行处理。

    当有触摸动作时，触摸屏将会执行(5)中声明的中断处理函数ft5x0x_ts_interrupt，具体实现：

 

 

查看文本copy to clipboard打印?

  1. static irqreturn_t ft5x0x_ts_interrupt(int irq, void *dev_id)  
  2. {  
  3.     struct ft5x0x_ts_data *ft5x0x_ts = dev_id;  
  4.   
  5.     if (!work_pending(&ft5x0x_ts->pen_event_work))  
  6.         queue_work(ft5x0x_ts->ts_workqueue, &ft5x0x_ts->pen_event_work);  
  7.   
  8.     return IRQ_HANDLED;  
  9. }  

    可以看到，中断处理就是在判断工作队列在没有被挂起的情况下在触摸时间加入到工作队列中去，等待工作队列处理函数ft5x0x_ts_pen_irq_work()的处理。ft5x0x_ts_pen_irq_work()的实现：

查看文本copy to clipboard打印?

  1. static void ft5x0x_ts_pen_irq_work(struct work_struct *work)  
  2. {  
  3.     int ret = -1;  
  4.   
  5.     ret = ft5x0x_read_data();     
  6.   
  7.     if (ret == 0)  
  8.         ft5x0x_report_value();  
  9. }  

    概括来说这里只做了两件事：从设备中读取数据 ；把数据上报到输入子系统中。

    (1)从设备中读取数据由函数ft5x0x_read_data()实现

查看文本copy to clipboard打印?

  1. static int ft5x0x_read_data(void)  
  2. {  
  3.     struct ft5x0x_ts_data *data = i2c_get_clientdata(this_client);  
  4.     struct ts_event *event = &data->event;  
  5.     u8 buf[32] = {0};  
  6.     int ret = -1;  
  7.     int status = 0;  
  8.   
  9. #ifdef CONFIG_FT5X0X_MULTITOUCH  
  10.     ret = ft5x0x_i2c_rxdata(buf, 31);  
  11. #else  
  12.     ret = ft5x0x_i2c_rxdata(buf, 7);  
  13. #endif  
  14.     if (ret < 0)  
  15.     {  
  16.         printk("%s read_data i2c_rxdata failed: %d\n", __func__, ret);  
  17.         return ret;  
  18.     }  
  19.   
  20.     memset(event, 0, sizeof(struct ts_event));  
  21.     event->touch_point = buf[2] & 0x07;  
  22.   
  23.     if (event->touch_point == 0)  
  24.     {  
  25.         ft5x0x_ts_inactivate();  
  26.         return 1;   
  27.     }  
  28.   
  29. #ifdef CONFIG_FT5X0X_MULTITOUCH  
  30.     switch (event->touch_point)  
  31.     {  
  32.         case 5:  
  33.             event->x5 = (s16)(buf[0x1b] & 0x0F)<<8 | (s16)buf[0x1c];  
  34.             event->y5 = (s16)(buf[0x1d] & 0x0F)<<8 | (s16)buf[0x1e];  
  35.             status = (s16)((buf[0x1b] & 0xc0) >> 6);  
  36.             event->touch_ID5=(s16)(buf[0x1D] & 0xF0)>>4;  
  37.             if (status == 1) ft5x0x_ts_release();  
  38.   
  39.         case 4:  
  40.             event->x4 = (s16)(buf[0x15] & 0x0F)<<8 | (s16)buf[0x16];  
  41.             event->y4 = (s16)(buf[0x17] & 0x0F)<<8 | (s16)buf[0x18];  
  42.             status = (s16)((buf[0x15] & 0xc0) >> 6);  
  43.             event->touch_ID4=(s16)(buf[0x17] & 0xF0)>>4;  
  44.             if (status == 1) ft5x0x_ts_release();  
  45.   
  46.         case 3:  
  47.             event->x3 = (s16)(buf[0x0f] & 0x0F)<<8 | (s16)buf[0x10];  
  48.             event->y3 = (s16)(buf[0x11] & 0x0F)<<8 | (s16)buf[0x12];  
  49.             status = (s16)((buf[0x0f] & 0xc0) >> 6);  
  50.             event->touch_ID3=(s16)(buf[0x11] & 0xF0)>>4;  
  51.             if (status == 1) ft5x0x_ts_release();  
  52.   
  53.         case 2:  
  54.             event->x2 = (s16)(buf[9] & 0x0F)<<8 | (s16)buf[10];  
  55.             event->y2 = (s16)(buf[11] & 0x0F)<<8 | (s16)buf[12];  
  56.             status = (s16)((buf[0x9] & 0xc0) >> 6);  
  57.             event->touch_ID2=(s16)(buf[0x0b] & 0xF0)>>4;  
  58.             if (status == 1) ft5x0x_ts_release();  
  59.   
  60.         case 1:  
  61.             event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];  
  62.             event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];  
  63.             status = (s16)((buf[0x3] & 0xc0) >> 6);  
  64.             event->touch_ID1=(s16)(buf[0x05] & 0xF0)>>4;  
  65.             if (status == 1) ft5x0x_ts_release();  
  66.                     break;  
  67.   
  68.         default:  
  69.             return -1;  
  70.     }  
  71. #else  
  72.     if (event->touch_point == 1)  
  73.     {  
  74.         event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];  
  75.         event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];  
  76.     }  
  77. #endif  
  78.     event->pressure = 200;  
  79.   
  80.     dev_dbg(&this_client->dev, "%s: 1:%d %d 2:%d %d \n", __func__,  
  81.         event->x1, event->y1, event->x2, event->y2);  
  82.   
  83.     return 0;  
  84. }  

    从设备中读取数据使用ft5x0x_i2c_rxdata()函数:

查看文本copy to clipboard打印?

  1. static int ft5x0x_i2c_rxdata(char *rxdata, int length)  
  2. {  
  3.     int ret;  
  4.   
  5.     struct i2c_msg msgs[] =  
  6.     {  
  7.         {  
  8.             .addr   = this_client->addr,  
  9.             .flags  = 0,  
  10.             .len    = 1,  
  11.             .buf    = rxdata,  
  12.         },  
  13.         {  
  14.             .addr   = this_client->addr,  
  15.             .flags  = I2C_M_RD,  
  16.             .len    = length,  
  17.             .buf    = rxdata,  
  18.         },  
  19.     };  
  20.   
  21.     ret = i2c_transfer(this_client->adapter, msgs, 2);  
  22.     if (ret < 0)  
  23.         pr_err("msg %s i2c read error: %d\n", __func__, ret);  
  24.       
  25.     return ret;  
  26. }  

    这个函数里面会构建一个i2c_msg msg结构去调用i2c_transfer()函数读取数据，在前面已经说过，i2c_transfer()函数最终调用的就是i2c_algorithm中master_xfer()函数进行实际的数据传输，这个函数在adapter驱动中实现。
    对读取到的数据处理涉及到IC里面的数据格式，查找芯片的数据手册可以看到寄存器的数据分步。

 



ft5x0x寄存器映射表

    这里为缩小篇幅，只截取一部分寄存器，其余寄存器格式可参照既给出的寄存器信息。 结合图片可以看出，代码先根据是否多点触摸，从寄存器读取数据长度，若是只需要单点触摸就读取7个字节信息，若是多点触摸，就读取31个字节的信息，从代码可以看出最多支持五点触摸。读出信息的第三个字节的低4位为触摸点数，所以event->touch_point = buf[2] & 0x07;判断触摸点数之后便分别计算触摸点的坐标，这里以第一个点为例，其余点可以依此类推。第一个点的坐标信息包含在地址03h～06h中，坐标信息由12bit组成，分布在两个字节中，另外还包含flag标志信息，用于表示触摸点的状态，还包含触摸点的ID识别。

    (2)把数据上报到输入子系统中由函数ft5x0x_report_value()实现

 

查看文本copy to clipboard打印?

  1. static void ft5x0x_report_value(void)  
  2. {  
  3.     struct ft5x0x_ts_data *data = i2c_get_clientdata(this_client);  
  4.     struct ts_event *event = &data->event;  
  5.   
  6. #ifdef CONFIG_FT5X0X_MULTITOUCH  
  7.     switch(event->touch_point)  
  8.     {  
  9.         case 5:  
  10.             input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID5);  
  11.             input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);  
  12.             input_report_abs(data->input_dev, ABS_MT_POSITION_X, SCREEN_MAX_X - event->x5);  
  13.             input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y5);  
  14.             input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);  
  15.             input_mt_sync(data->input_dev);  
  16.         case 4:  
  17.             input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID4);  
  18.             input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);  
  19.             input_report_abs(data->input_dev, ABS_MT_POSITION_X, SCREEN_MAX_X - event->x4);  
  20.             input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y4);  
  21.             input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);  
  22.             input_mt_sync(data->input_dev);  
  23.         case 3:  
  24.             input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID3);  
  25.             input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);  
  26.             input_report_abs(data->input_dev, ABS_MT_POSITION_X, SCREEN_MAX_X - event->x3);  
  27.             input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y3);  
  28.             input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);  
  29.             input_mt_sync(data->input_dev);  
  30.         case 2:  
  31.             input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID2);  
  32.             input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);  
  33.             input_report_abs(data->input_dev, ABS_MT_POSITION_X, SCREEN_MAX_X - event->x2);  
  34.             input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y2);  
  35.             input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);  
  36.             input_mt_sync(data->input_dev);  
  37.         case 1:  
  38.             input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID1);  
  39.             input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);  
  40.             input_report_abs(data->input_dev, ABS_MT_POSITION_X, SCREEN_MAX_X - event->x1);  
  41.             input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y1);  
  42.             input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);  
  43.             input_mt_sync(data->input_dev);  
  44.         default:  
  45.             break;  
  46.     }  
  47. #else   /* CONFIG_FT5X0X_MULTITOUCH*/  
  48.     if (event->touch_point == 1)  
  49.     {  
  50.         input_report_abs(data->input_dev, ABS_X, SCREEN_MAX_X - event->x1);  
  51.         input_report_abs(data->input_dev, ABS_Y, event->y1);  
  52.         input_report_abs(data->input_dev, ABS_PRESSURE, event->pressure);  
  53.     }  
  54.     input_report_key(data->input_dev, BTN_TOUCH, 1);  
  55. #endif  /* CONFIG_FT5X0X_MULTITOUCH*/  
  56.     input_sync(data->input_dev);  
  57.   
  58.     dev_dbg(&this_client->dev, "%s: 1:%d %d 2:%d %d \n", __func__,  
  59.         event->x1, event->y1, event->x2, event->y2);  
  60. }  

    因为触摸屏使用的是绝对坐标系，上报数据使用input_report_abs()函数，参数要注意选择合适的事件集。上报玩数据要记得同步，使用input_mt_sync()表示单个手指信息结束，使用input_sync()表示整个触摸动作的结束。

    remove()函数的具体实现是ft5x0x_ts_remove(),做与probe()相反的工作，释放内存。

查看文本copy to clipboard打印?

  1. static int __devexit ft5x0x_ts_remove(struct i2c_client *client)  
  2. {  
  3.     struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);  
  4.   
  5.     unregister_early_suspend(&ft5x0x_ts->early_suspend);  
  6.     free_irq(client->irq, ft5x0x_ts);  
  7.     input_unregister_device(ft5x0x_ts->input_dev);  
  8.     kfree(ft5x0x_ts);  
  9.     cancel_work_sync(&ft5x0x_ts->pen_event_work);  
  10.     destroy_workqueue(ft5x0x_ts->ts_workqueue);  
  11.     i2c_set_clientdata(client, NULL);  
  12.   
  13.     return 0;  
  14. }  

    至此，我们从i2c接口及输入子系统的接口清楚了整个触摸屏驱动的结构，并详细分析了触摸屏驱动中的具体实现。

bobuddy
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 在自己的模块中使用i2c_client
08-04
获得系统已经有的i2c_adapter创建自己的i2c_client，i2c-dev中给出的实现方式不够灵活
i2c_set_clientdata函数【转】
weixin_34255055的博客
12-21 417
本文转载自‘:http://blog.csdn.net/jk198310/article/details/43738367 在i2c驱动中有很多函数和数据结构，很多一时难以理解，所以写下本文共同学习。 一、i2c_set_clientdata函数         在probe方式的I2C驱动中的probe函数中经常出现i2c_set_clientdata函数，一直很不解这个函数什么意思，后来...
8、关闭“触摸I2C”
最新发布
wsen2012的博客
06-08 360
触摸I2C接口在开发板上带着，并没有配备触摸模块，为了解放它所占用的接口和IO所以要关闭它。
I2C总线驱动框架详解
u014426028的博客
03-12 1507
一、I2C子系统总体架构 1、三大组成部分 (1)I2C核心(i2c-core)：I2C核心提供了I2C总线驱动（适配器）和设备驱动的注册、注销方法，I2C通信方法(”algorithm”)上层的，与具体硬件无关的代码以及探测设备 检测设备地址的上层代码等。。 (2)I2C总线驱动(I2Cadapter)：I2C总线驱动是I2C适配器的软件实现，提供I2C适配器与从设备间完成数...
i2c_set_clientdata/i2c_get_clientdata函数
jiuguaqiao6494的博客
08-07 2367
i2c_set_clientdata/i2c_get_clientdata函数描述定义补充 描述 driver_data - private pointer for driver specific info driver_data是驱动特殊信息的私有指针，i2c_set_clientdata(client, dev)就是将自定义的设备结构dev赋给设备驱动client的私有指针 定义 static inline void i2c_set_clientdata(struct i2c_client *dev,
2023-07-20 linux platform_set_drvdata、platform_get_drvdata和i2c_set_clientdata i2c_get_clientdata 学习
海月汐辰
07-20 1023
3.4 再来看看platform_get_drvdata 和 platform_set_drvdata 的代码，里面会调用dev_get_drvdata(dev)，有时候再驱动里面也可以直接用。4.3 看看 i2c_set_clientdata i2c_get_clientdata 里面 会调用dev_set_drvdata dev_get_drvdata。3.3 看上面会用到to_platform_device ，其实是调用container_of 获取device 指针。
Linux下I2C接口触摸屏驱动分析 - CSDN博客1
08-04
【Linux下I2C接口触摸屏驱动分析】 在Linux操作系统中，I2C（Inter-Integrated Circuit）是一种常用于连接微控制器和各种外围设备的低速串行通信协议。对于触摸屏驱动，尤其是在嵌入式系统如Android Linux平台中，...
ili2511 Linux I2C驱动
11-24
在Linux系统中，I2C（Inter-Integrated Circuit）总线是一种用于微控制器与外部设备之间通信的简单、低速的两线接口。本文将详细探讨如何为奕力（Ilitek）触控芯片 ili2511 编写和移植Linux I2C驱动，并在Ubuntu操作...
基于ARM处理器S3C2440和Linux系统的I2C触摸屏设计
08-13
本文主要探讨了在基于ARM处理器的S3C2440平台上，如何设计和实现一个适用于Linux系统的I2C触摸屏驱动。S3C2440是一款广泛应用于嵌入式系统的微处理器，而I2C触摸屏则是人机交互的重要组成部分，特别是在移动设备和...
i.MX6ULL驱动触摸屏【Linux C驱动】.zip
02-21
综上所述，开发i.MX6ULL的Linux C驱动程序，尤其是触摸屏驱动，需要综合运用Linux内核驱动编程技术、中断处理机制、设备树配置以及对特定硬件（如触摸屏）的理解。提供的项目代码应该包含了这些功能的实现，通过学习...
嵌入式Linux触摸屏I2C驱动
10-19
在本主题中，我们主要关注的是基于全志系列芯片的嵌入式Linux系统中，如何实现触摸屏的I2C驱动。I2C（Inter-Integrated Circuit）是一种串行通信协议，适用于连接低速外围设备，如触摸控制器到主处理器，具有节省...
i2c_set_clientdata
王牧天的博客
10-11 4880
分析ak4951_amb.c驱动程序，在probe函数中遇到i2c_set_clientdata函数，一开始我只是根据函数名去 理解该函数的意义，即设置i2c客户端的私有数据。其实从函数名这么理解我至少认为是理解正确的，我现在 在这里深入研究一下，是否根据函数名理解的该函数正确？还有就是搞清楚函数内部是怎样实现的 static inline void i2c_set_clientdata(s
linux I2C驱动 i2c_set_clientdata函数和i2c_get_clientdata函数
MMPnoname的博客
01-19 7340
最近在研究I2C驱动，碰到了一对函数不知道什么意思，也看了网上的好多帖子，结合自己的分析来说一说它们的作用吧。这两个函数的作用起始就是方便我们通过client来找到设备。比如我们自定义了一个结构体用来保存数据struct my_I2C_data {    struct i2c_client *client;    struct input_dev    *input_dev;    struct
i2c bus
hushup的专栏
07-02 1136
转自：http://lhsblog01.blog.163.com/blog/static/1020045192010221103944423/ i2c bus    2010-03-21 22:39:44|  分类： linux 驱动 |  标签： |举报 |字号大中小 订阅 // /* i2c总线使用 platform＿device实现, 总线驱动用p
[实用代码] 基于CH554电容触摸屏IIC转USB转IIC方案代码分享
骑猪看夕阳~的博客
03-30 8331
为迎合之前手机和平板电脑的应用，现在市面上的大多电容屏触控芯片的接口都是IIC，使用这些电容屏的时候，需要预先在Windows/Android/Linux等系统中置入IIC的驱动程序，然后才能使用触控屏，对于现在标准化生产的windows或安卓主板而言，使用起来很不方便。 所以设计工程师们都希望将自己手中的IIC接口触控屏升级为USB接口触控屏，因为USB接口触控屏在Windows/Andr...
Linux驱动：I2C驱动看这一篇就够了
让技术没有门槛
06-15 3233
I2C协议是在开发中使用非常频繁的一种协议，相信大家在学习单片机的时候经常会用到支持I2C协议的模块，I2C 总线仅仅使用 SCL、SDA 这两根信号线就实现了设备之间的数据交互，极大地简化了对硬件资源和 PCB 板布线空间的占用。因此，I2C 总线被非常广泛地应用在 EEPROM、实时钟、小型 LCD 等设备与 CPU 的接口中。但是与裸机开发不同的是在 Linux 系统中，I2C 驱动由 3 部分组成，即I2C 核心I2C 总线驱动和I2C 设备驱动。
I2C总线adapter驱动及设备client驱动分析总结
pangyinglong的博客
06-13 1469
设备驱动层：专门针对连接在芯片外部硬件设备而写的代码，IIC总线上可以连接多个硬件设备，与设备驱动一一对应。在应用程序中打开设备驱动程序，就可以操作相关的硬件设备。所以对硬件设备的操作的功能（算法）在这里实现，比如对AT24C08这个EEPROM设备进行所需要的读写方式实现。 实现I2C设备client的两种方法（我认为第二种比较好，因为client在加载驱动时自动生成，减少了在attach_a...
I2C客户端驱动程序
Icewaver的专栏
04-11 421
使用了DT后，需要增加一个struct of_device_id{}数组。{}// 用于检测到设备时自动加载模块},.id_table = foo_id, // 在4.10以前的内核中，必须存在id_table成员。/*设备树相关代码*/} else {...
OMAP3630 Linux I2C总线驱动分析(1)
weed_hz的专栏
05-19 899
1 Linux I2C驱动架构 Linux下I2C驱动的架构图如下：   图1.1 Linux下I2C驱动架构     如上图所示，每条I2C总线会对应一个adapter，而每条I2C总线上则可以有多个 client，在linux kernel中，通过I2C core层将I2C client与I2C adapter关联起来，Linux 中I2C驱动代码位于drivers/i2c目录
Linux下I2C接口触摸屏驱动分析及移植探索
在Linux下移植I2C接口触摸屏驱动的过程可以分为三个主要步骤。首先，需要确定触摸屏IC接口，了解对应接口的API函数，并注册设备并将其加入到相应的总线上。接着，需要关联设备与驱动，并撰写具体的驱动代码。最后，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值