Android下MTK平台驱动FT6336U电容触摸屏驱动程序代码

Android下MTK平台驱动（FT6X36_MTK6571 沃特沃德已调试通过），仅供参考。


源程序如下:

1. #include <linux/slab.h>
   
2. #include <linux/i2c.h>
   
3. #include <linux/types.h>
   
4. #include <linux/sched.h>
   
5. #include <linux/kthread.h>
   
6. #include <linux/kernel.h>
   
7. #include <linux/semaphore.h>
   
8. #include <linux/proc_fs.h>
   
9. #include <asm/uaccess.h>
   
10. #include <linux/delay.h>
    
11. #include <linux/module.h>
    
12. #include <linux/init.h>
    
13. #include <linux/fs.h>
    
14. #include <linux/cdev.h>
    
15. #include <linux/device.h>
    
16. 
    
17. #include "tpd_custom_fts.h"
    
18. #include "focaltech_ctl.h"
    
19. #include "focaltech_ex_fun.h"
    
20. #include <linux/netdevice.h>
    
21. 
    
22. 
    
23. extern u8 *I2CDMABuf_va ;
    
24. extern volatile u32 I2CDMABuf_pa;
    
25. 
    
26. 
    
27. static int ft_rw_iic_drv_major = FT_RW_IIC_DRV_MAJOR;
    
28. struct ft_rw_i2c_dev
    
29. {
    
30.     struct cdev cdev;
    
31.     struct semaphore ft_rw_i2c_sem;
    
32.     struct i2c_client *client;
    
33. };
    
34. struct ft_rw_i2c_dev *ft_rw_i2c_dev_tt;
    
35. static struct class *fts_class;
    
36. 
    
37. static int ft_rw_iic_drv_myread(struct i2c_client *client, u8 *buf, int length)
    
38. {
    
39.     int ret = 0;   
    
40.     ret = fts_i2c_Read(client, NULL, 0, buf, length);
    
41. 
    
42.     if(ret<0)
    
43.         dev_err(&client->dev, "%s:IIC Read failed\n",
    
44.                 __func__);
    
45.     return ret;
    
46. }
    
47. 
    
48. static int ft_rw_iic_drv_mywrite(struct i2c_client *client, u8 *buf, int length)
    
49. {
    
50.     int ret = 0;
    
51.     ret = fts_i2c_Write(client, buf, length);
    
52.     if(ret<0)
    
53.         dev_err(&client->dev, "%s:IIC Write failed\n",
    
54.                 __func__);
    
55.     return ret;
    
56. }
    
57. 
    
58. static int ft_rw_iic_drv_RDWR(struct i2c_client *client, unsigned long arg)
    
59. {
    
60.     struct ft_rw_i2c_queue i2c_rw_queue;
    
61.     u8 __user **data_ptrs;
    
62.     struct ft_rw_i2c * i2c_rw_msg;
    
63.     int ret = 0;
    
64.     int i;
    
65. 
    
66.     if (!access_ok(VERIFY_READ, (struct ft_rw_i2c_queue *)arg, sizeof(struct ft_rw_i2c_queue)))
    
67.         return -EFAULT;
    
68. 
    
69.     if (copy_from_user(&i2c_rw_queue,
    
70.         (struct ft_rw_i2c_queue *)arg,
    
71.         sizeof(struct ft_rw_i2c_queue)))
    
72.         return -EFAULT;
    
73. 
    
74.     if (i2c_rw_queue.queuenum > FT_I2C_RDWR_MAX_QUEUE)
    
75.         return -EINVAL;
    
76. 
    
77. 
    
78.     i2c_rw_msg = (struct ft_rw_i2c*)
    
79.         kmalloc(i2c_rw_queue.queuenum *sizeof(struct ft_rw_i2c),
    
80.         GFP_KERNEL);
    
81.     if (!i2c_rw_msg)
    
82.         return -ENOMEM;
    
83. 
    
84.     if (copy_from_user(i2c_rw_msg, i2c_rw_queue.i2c_queue,
    
85.             i2c_rw_queue.queuenum*sizeof(struct ft_rw_i2c))) {
    
86.         kfree(i2c_rw_msg);
    
87.         return -EFAULT;
    
88.     }
    
89. 
    
90.     data_ptrs = kmalloc(i2c_rw_queue.queuenum * sizeof(u8 __user *), GFP_KERNEL);
    
91.     if (data_ptrs == NULL) {
    
92.         kfree(i2c_rw_msg);
    
93.         return -ENOMEM;
    
94.     }
    
95.    
    
96.     ret = 0;
    
97.     for (i=0; i< i2c_rw_queue.queuenum; i++) {
    
98.         if ((i2c_rw_msg[i].length > 8192)||
    
99.             (i2c_rw_msg[i].flag & I2C_M_RECV_LEN)) {
    
100.             ret = -EINVAL;
     
101.             break;
     
102.         }
     
103.         data_ptrs[i] = (u8 __user *)i2c_rw_msg[i].buf;
     
104.         i2c_rw_msg[i].buf = kmalloc(i2c_rw_msg[i].length, GFP_KERNEL);
     
105.         if (i2c_rw_msg[i].buf == NULL) {
     
106.             ret = -ENOMEM;
     
107.             break;
     
108.         }
     
109. 
     
110.         if (copy_from_user(i2c_rw_msg[i].buf, data_ptrs[i], i2c_rw_msg[i].length)) {
     
111.             ++i;
     
112.             ret = -EFAULT;
     
113.             break;
     
114.         }
     
115.     }
     
116. //printk("ft_rw_iic_drv_RDWR 6  %d %x  %x\n",ret,data_ptrs,i2c_rw_msg);
     
117.     if (ret < 0) {
     
118.         int j;
     
119.         for (j=0; j<i; ++j)
     
120.             kfree(i2c_rw_msg[j].buf);
     
121.         kfree(data_ptrs);
     
122.         kfree(i2c_rw_msg);
     
123.         return ret;
     
124.     }
     
125. //printk("ft_rw_iic_drv_RDWR 7\n");
     
126.     for (i=0; i< i2c_rw_queue.queuenum; i++) {
     
127.         //printk("ft_rw_iic_drv_RDWR 8  %d  %x  %x  %d\n",i2c_rw_msg[i].flag,i2c_rw_msg[i].buf,data_ptrs[i],i2c_rw_msg[i].length);
     
128.         if (i2c_rw_msg[i].flag) {
     
129.             ret = ft_rw_iic_drv_myread(client,
     
130.                     i2c_rw_msg[i].buf, i2c_rw_msg[i].length);
     
131.             if (ret>=0)
     
132.                 ret = copy_to_user(data_ptrs[i], i2c_rw_msg[i].buf, i2c_rw_msg[i].length);
     
133.         }
     
134.         else
     
135.             ret = ft_rw_iic_drv_mywrite(client,
     
136.                     i2c_rw_msg[i].buf, i2c_rw_msg[i].length);
     
137.     }
     
138. //printk("ft_rw_iic_drv_RDWR 10\n");
     
139.     return ret;
     
140.    
     
141. }
     
142. 
     
143. /*
     
144. *char device open function interface
     
145. */
     
146. static int ft_rw_iic_drv_open(struct inode *inode, struct file *filp)
     
147. {
     
148.     filp->private_data = ft_rw_i2c_dev_tt;
     
149.     return 0;
     
150. }
     
151. 
     
152. /*
     
153. *char device close function interface
     
154. */
     
155. static int ft_rw_iic_drv_release(struct inode *inode, struct file *filp)
     
156. {
     
157. 
     
158.     return 0;
     
159. }
     
160. 
     
161. static int ft_rw_iic_drv_ioctl(struct file *filp, unsigned
     
162.   int cmd, unsigned long arg)
     
163. {
     
164.     int ret = 0;
     
165.     struct ft_rw_i2c_dev *ftdev = filp->private_data;
     
166.     ftdev = filp->private_data;
     
167.     //printk("ft_rw_iic_drv_ioctl\n");
     
168. //  down(&ft_rw_i2c_dev_tt->ft_rw_i2c_sem);
     
169.     //printk("====ft_rw_iic_drv_ioctl: client = %x\n",ftdev->client);
     
170.     switch (cmd)
     
171.     {
     
172.     case FT_I2C_RW:
     
173.         ret = ft_rw_iic_drv_RDWR(ftdev->client, arg);   
     
174.         break;
     
175.     default:
     
176.         ret =  -ENOTTY;
     
177.         break;
     
178.     }
     
179. //  up(&ft_rw_i2c_dev_tt->ft_rw_i2c_sem);
     
180.     //printk("++++ft_rw_iic_drv_ioctl\n");
     
181.     return ret;
     
182. }
     
183. 
     
184. 
     
185. /*   
     
186. *char device file operation which will be put to register the char device
     
187. */
     
188. static const struct file_operations ft_rw_iic_drv_fops = {
     
189.     .owner          = THIS_MODULE,
     
190.     .open           = ft_rw_iic_drv_open,
     
191.     .release        = ft_rw_iic_drv_release,
     
192.     .unlocked_ioctl = ft_rw_iic_drv_ioctl,
     
193. };
     
194. 
     
195. 
     
196. static void ft_rw_iic_drv_setup_cdev(struct ft_rw_i2c_dev *dev, int index)
     
197. {
     
198.     int err, devno = MKDEV(ft_rw_iic_drv_major, index);
     
199. 
     
200.     cdev_init(&dev->cdev, &ft_rw_iic_drv_fops);
     
201.     dev->cdev.owner = THIS_MODULE;
     
202.     dev->cdev.ops = &ft_rw_iic_drv_fops;
     
203.     dev->client = ft_rw_i2c_dev_tt->client;
     
204.     printk("%s: 2.client=%x  \n",__func__,dev->client);
     
205.     err = cdev_add(&dev->cdev, devno, 1);
     
206.     if (err)
     
207.         printk(KERN_NOTICE "Error %d adding LED%d", err, index);
     
208. }
     
209. 
     
210. static int ft_rw_iic_drv_myinitdev(struct i2c_client *client)
     
211. {
     
212.     int err = 0;
     
213.     dev_t devno = MKDEV(ft_rw_iic_drv_major, 0);
     
214. 
     
215.     if (ft_rw_iic_drv_major)
     
216.         err = register_chrdev_region(devno, 1, FT_RW_IIC_DRV);
     
217.     else {
     
218.         err = alloc_chrdev_region(&devno, 0, 1, FT_RW_IIC_DRV);
     
219.         ft_rw_iic_drv_major = MAJOR(devno);
     
220.     }
     
221.     if (err < 0) {
     
222.         dev_err(&client->dev, "%s:ft_rw_iic_drv failed  error code=%d---\n",
     
223.                 __func__, err);
     
224.         return err;
     
225.     }
     
226. 
     
227.     ft_rw_i2c_dev_tt = kmalloc(sizeof(struct ft_rw_i2c_dev), GFP_KERNEL);
     
228.     if (!ft_rw_i2c_dev_tt){
     
229.         err = -ENOMEM;
     
230.         unregister_chrdev_region(devno, 1);
     
231.         dev_err(&client->dev, "%s:ft_rw_iic_drv failed\n",
     
232.                 __func__);
     
233.         return err;
     
234.     }
     
235.    
     
236.     ft_rw_i2c_dev_tt->client = client;
     
237.     printk("ft_rw_iic_drv_myinitdev: client=%x \n",ft_rw_i2c_dev_tt->client);
     
238.     mutex_init(&ft_rw_i2c_dev_tt->ft_rw_i2c_sem);
     
239. 
     
240.     cdev_init(&ft_rw_i2c_dev_tt->cdev, &ft_rw_iic_drv_fops);
     
241.     ft_rw_i2c_dev_tt->client = client;
     
242.     ft_rw_i2c_dev_tt->cdev.owner = THIS_MODULE;
     
243.     ft_rw_i2c_dev_tt->cdev.ops = &ft_rw_iic_drv_fops;
     
244.      printk("%s: 2.client=%x  \n",__func__,ft_rw_i2c_dev_tt->client);
     
245.     err = cdev_add(&ft_rw_i2c_dev_tt->cdev, devno, 1);
     
246.     printk("%s: client=%x  \n",__func__,ft_rw_i2c_dev_tt->client);
     
247.     if (err)
     
248.         printk(KERN_NOTICE "Error %d adding LED", err);
     
249.    
     
250.    
     
251.     //ft_rw_iic_drv_setup_cdev(ft_rw_i2c_dev_tt, 0);
     
252.     //printk("===ft_rw_iic_drv_myinitdev: client=%x \n",ft_rw_i2c_dev_tt->client);
     
253. 
     
254.     fts_class = class_create(THIS_MODULE, "fts_class");
     
255.     if (IS_ERR(fts_class)) {
     
256.         dev_dbg(&client->dev, "%s:failed in creating class.\n",
     
257.                 __func__);
     
258.         return -1;
     
259.     }
     
260.     /*create device node*/
     
261.     device_create(fts_class, NULL, MKDEV(ft_rw_iic_drv_major, 0),
     
262.             NULL, FT_RW_IIC_DRV);
     
263. 
     
264.    
     
265.     return 0;
     
266. }
     
267. 
     
268. int ft_rw_iic_drv_init(struct i2c_client *client)
     
269. {
     
270.     dev_dbg(&client->dev, "[FTS]----ft_rw_iic_drv init ---\n");
     
271.         return ft_rw_iic_drv_myinitdev(client);
     
272. }
     
273. 
     
274. void  ft_rw_iic_drv_exit(void)
     
275. {
     
276.         device_destroy(fts_class, MKDEV(ft_rw_iic_drv_major, 0));
     
277.         /*delete class created by us*/
     
278.         class_destroy(fts_class);
     
279.         /*delet the cdev*/
     
280.         cdev_del(&ft_rw_i2c_dev_tt->cdev);
     
281.         kfree(ft_rw_i2c_dev_tt);
     
282.         unregister_chrdev_region(MKDEV(ft_rw_iic_drv_major, 0), 1);
     
283. }
     

复制代码

全部资料51hei下载地址：
Android下MTK平台驱动FT6336U(1).zip (35.05 KB, 下载次数: 37)

2019-7-1 15:25 上传

点击文件名下载附件
下载积分: 黑币 -5

谢谢楼主分享，最近在用这颗触摸ic，总感觉反应很迟钝，不知道是不是软件的问题