单片机论坛

 找回密码
 立即注册

QQ登录

只需一步快速开始

搜索
查看: 487|回复: 0
打印 上一主题 下一主题
收起左侧

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. #include "tpd_custom_fts.h"
  17. #include "focaltech_ctl.h"
  18. #include "focaltech_ex_fun.h"
  19. #include <linux/netdevice.h>


  20. extern u8 *I2CDMABuf_va ;
  21. extern volatile u32 I2CDMABuf_pa;


  22. static int ft_rw_iic_drv_major = FT_RW_IIC_DRV_MAJOR;
  23. struct ft_rw_i2c_dev
  24. {
  25.     struct cdev cdev;
  26.     struct semaphore ft_rw_i2c_sem;
  27.     struct i2c_client *client;
  28. };
  29. struct ft_rw_i2c_dev *ft_rw_i2c_dev_tt;
  30. static struct class *fts_class;

  31. static int ft_rw_iic_drv_myread(struct i2c_client *client, u8 *buf, int length)
  32. {
  33.     int ret = 0;   
  34.     ret = fts_i2c_Read(client, NULL, 0, buf, length);

  35.     if(ret<0)
  36.         dev_err(&client->dev, "%s:IIC Read failed\n",
  37.                 __func__);
  38.     return ret;
  39. }

  40. static int ft_rw_iic_drv_mywrite(struct i2c_client *client, u8 *buf, int length)
  41. {
  42.     int ret = 0;
  43.     ret = fts_i2c_Write(client, buf, length);
  44.     if(ret<0)
  45.         dev_err(&client->dev, "%s:IIC Write failed\n",
  46.                 __func__);
  47.     return ret;
  48. }

  49. static int ft_rw_iic_drv_RDWR(struct i2c_client *client, unsigned long arg)
  50. {
  51.     struct ft_rw_i2c_queue i2c_rw_queue;
  52.     u8 __user **data_ptrs;
  53.     struct ft_rw_i2c * i2c_rw_msg;
  54.     int ret = 0;
  55.     int i;

  56.     if (!access_ok(VERIFY_READ, (struct ft_rw_i2c_queue *)arg, sizeof(struct ft_rw_i2c_queue)))
  57.         return -EFAULT;

  58.     if (copy_from_user(&i2c_rw_queue,
  59.         (struct ft_rw_i2c_queue *)arg,
  60.         sizeof(struct ft_rw_i2c_queue)))
  61.         return -EFAULT;

  62.     if (i2c_rw_queue.queuenum > FT_I2C_RDWR_MAX_QUEUE)
  63.         return -EINVAL;


  64.     i2c_rw_msg = (struct ft_rw_i2c*)
  65.         kmalloc(i2c_rw_queue.queuenum *sizeof(struct ft_rw_i2c),
  66.         GFP_KERNEL);
  67.     if (!i2c_rw_msg)
  68.         return -ENOMEM;

  69.     if (copy_from_user(i2c_rw_msg, i2c_rw_queue.i2c_queue,
  70.             i2c_rw_queue.queuenum*sizeof(struct ft_rw_i2c))) {
  71.         kfree(i2c_rw_msg);
  72.         return -EFAULT;
  73.     }

  74.     data_ptrs = kmalloc(i2c_rw_queue.queuenum * sizeof(u8 __user *), GFP_KERNEL);
  75.     if (data_ptrs == NULL) {
  76.         kfree(i2c_rw_msg);
  77.         return -ENOMEM;
  78.     }
  79.    
  80.     ret = 0;
  81.     for (i=0; i< i2c_rw_queue.queuenum; i++) {
  82.         if ((i2c_rw_msg[i].length > 8192)||
  83.             (i2c_rw_msg[i].flag & I2C_M_RECV_LEN)) {
  84.             ret = -EINVAL;
  85.             break;
  86.         }
  87.         data_ptrs[i] = (u8 __user *)i2c_rw_msg[i].buf;
  88.         i2c_rw_msg[i].buf = kmalloc(i2c_rw_msg[i].length, GFP_KERNEL);
  89.         if (i2c_rw_msg[i].buf == NULL) {
  90.             ret = -ENOMEM;
  91.             break;
  92.         }

  93.         if (copy_from_user(i2c_rw_msg[i].buf, data_ptrs[i], i2c_rw_msg[i].length)) {
  94.             ++i;
  95.             ret = -EFAULT;
  96.             break;
  97.         }
  98.     }
  99. //printk("ft_rw_iic_drv_RDWR 6  %d %x  %x\n",ret,data_ptrs,i2c_rw_msg);
  100.     if (ret < 0) {
  101.         int j;
  102.         for (j=0; j<i; ++j)
  103.             kfree(i2c_rw_msg[j].buf);
  104.         kfree(data_ptrs);
  105.         kfree(i2c_rw_msg);
  106.         return ret;
  107.     }
  108. //printk("ft_rw_iic_drv_RDWR 7\n");
  109.     for (i=0; i< i2c_rw_queue.queuenum; i++) {
  110.         //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);
  111.         if (i2c_rw_msg[i].flag) {
  112.             ret = ft_rw_iic_drv_myread(client,
  113.                     i2c_rw_msg[i].buf, i2c_rw_msg[i].length);
  114.             if (ret>=0)
  115.                 ret = copy_to_user(data_ptrs[i], i2c_rw_msg[i].buf, i2c_rw_msg[i].length);
  116.         }
  117.         else
  118.             ret = ft_rw_iic_drv_mywrite(client,
  119.                     i2c_rw_msg[i].buf, i2c_rw_msg[i].length);
  120.     }
  121. //printk("ft_rw_iic_drv_RDWR 10\n");
  122.     return ret;
  123.    
  124. }

  125. /*
  126. *char device open function interface
  127. */
  128. static int ft_rw_iic_drv_open(struct inode *inode, struct file *filp)
  129. {
  130.     filp->private_data = ft_rw_i2c_dev_tt;
  131.     return 0;
  132. }

  133. /*
  134. *char device close function interface
  135. */
  136. static int ft_rw_iic_drv_release(struct inode *inode, struct file *filp)
  137. {

  138.     return 0;
  139. }

  140. static int ft_rw_iic_drv_ioctl(struct file *filp, unsigned
  141.   int cmd, unsigned long arg)
  142. {
  143.     int ret = 0;
  144.     struct ft_rw_i2c_dev *ftdev = filp->private_data;
  145.     ftdev = filp->private_data;
  146.     //printk("ft_rw_iic_drv_ioctl\n");
  147. //  down(&ft_rw_i2c_dev_tt->ft_rw_i2c_sem);
  148.     //printk("====ft_rw_iic_drv_ioctl: client = %x\n",ftdev->client);
  149.     switch (cmd)
  150.     {
  151.     case FT_I2C_RW:
  152.         ret = ft_rw_iic_drv_RDWR(ftdev->client, arg);   
  153.         break;
  154.     default:
  155.         ret =  -ENOTTY;
  156.         break;
  157.     }
  158. //  up(&ft_rw_i2c_dev_tt->ft_rw_i2c_sem);
  159.     //printk("++++ft_rw_iic_drv_ioctl\n");
  160.     return ret;
  161. }


  162. /*   
  163. *char device file operation which will be put to register the char device
  164. */
  165. static const struct file_operations ft_rw_iic_drv_fops = {
  166.     .owner          = THIS_MODULE,
  167.     .open           = ft_rw_iic_drv_open,
  168.     .release        = ft_rw_iic_drv_release,
  169.     .unlocked_ioctl = ft_rw_iic_drv_ioctl,
  170. };


  171. static void ft_rw_iic_drv_setup_cdev(struct ft_rw_i2c_dev *dev, int index)
  172. {
  173.     int err, devno = MKDEV(ft_rw_iic_drv_major, index);

  174.     cdev_init(&dev->cdev, &ft_rw_iic_drv_fops);
  175.     dev->cdev.owner = THIS_MODULE;
  176.     dev->cdev.ops = &ft_rw_iic_drv_fops;
  177.     dev->client = ft_rw_i2c_dev_tt->client;
  178.     printk("%s: 2.client=%x  \n",__func__,dev->client);
  179.     err = cdev_add(&dev->cdev, devno, 1);
  180.     if (err)
  181.         printk(KERN_NOTICE "Error %d adding LED%d", err, index);
  182. }

  183. static int ft_rw_iic_drv_myinitdev(struct i2c_client *client)
  184. {
  185.     int err = 0;
  186.     dev_t devno = MKDEV(ft_rw_iic_drv_major, 0);

  187.     if (ft_rw_iic_drv_major)
  188.         err = register_chrdev_region(devno, 1, FT_RW_IIC_DRV);
  189.     else {
  190.         err = alloc_chrdev_region(&devno, 0, 1, FT_RW_IIC_DRV);
  191.         ft_rw_iic_drv_major = MAJOR(devno);
  192.     }
  193.     if (err < 0) {
  194.         dev_err(&client->dev, "%s:ft_rw_iic_drv failed  error code=%d---\n",
  195.                 __func__, err);
  196.         return err;
  197.     }

  198.     ft_rw_i2c_dev_tt = kmalloc(sizeof(struct ft_rw_i2c_dev), GFP_KERNEL);
  199.     if (!ft_rw_i2c_dev_tt){
  200.         err = -ENOMEM;
  201.         unregister_chrdev_region(devno, 1);
  202.         dev_err(&client->dev, "%s:ft_rw_iic_drv failed\n",
  203.                 __func__);
  204.         return err;
  205.     }
  206.    
  207.     ft_rw_i2c_dev_tt->client = client;
  208.     printk("ft_rw_iic_drv_myinitdev: client=%x \n",ft_rw_i2c_dev_tt->client);
  209.     mutex_init(&ft_rw_i2c_dev_tt->ft_rw_i2c_sem);

  210.     cdev_init(&ft_rw_i2c_dev_tt->cdev, &ft_rw_iic_drv_fops);
  211.     ft_rw_i2c_dev_tt->client = client;
  212.     ft_rw_i2c_dev_tt->cdev.owner = THIS_MODULE;
  213.     ft_rw_i2c_dev_tt->cdev.ops = &ft_rw_iic_drv_fops;
  214.      printk("%s: 2.client=%x  \n",__func__,ft_rw_i2c_dev_tt->client);
  215.     err = cdev_add(&ft_rw_i2c_dev_tt->cdev, devno, 1);
  216.     printk("%s: client=%x  \n",__func__,ft_rw_i2c_dev_tt->client);
  217.     if (err)
  218.         printk(KERN_NOTICE "Error %d adding LED", err);
  219.    
  220.    
  221.     //ft_rw_iic_drv_setup_cdev(ft_rw_i2c_dev_tt, 0);
  222.     //printk("===ft_rw_iic_drv_myinitdev: client=%x \n",ft_rw_i2c_dev_tt->client);

  223.     fts_class = class_create(THIS_MODULE, "fts_class");
  224.     if (IS_ERR(fts_class)) {
  225.         dev_dbg(&client->dev, "%s:failed in creating class.\n",
  226.                 __func__);
  227.         return -1;
  228.     }
  229.     /*create device node*/
  230.     device_create(fts_class, NULL, MKDEV(ft_rw_iic_drv_major, 0),
  231.             NULL, FT_RW_IIC_DRV);

  232.    
  233.     return 0;
  234. }

  235. int ft_rw_iic_drv_init(struct i2c_client *client)
  236. {
  237.     dev_dbg(&client->dev, "[FTS]----ft_rw_iic_drv init ---\n");
  238.         return ft_rw_iic_drv_myinitdev(client);
  239. }

  240. void  ft_rw_iic_drv_exit(void)
  241. {
  242.         device_destroy(fts_class, MKDEV(ft_rw_iic_drv_major, 0));
  243.         /*delete class created by us*/
  244.         class_destroy(fts_class);
  245.         /*delet the cdev*/
  246.         cdev_del(&ft_rw_i2c_dev_tt->cdev);
  247.         kfree(ft_rw_i2c_dev_tt);
  248.         unregister_chrdev_region(MKDEV(ft_rw_iic_drv_major, 0), 1);
  249. }
复制代码
全部资料51hei下载地址
Android下MTK平台驱动FT6336U(1).zip (35.05 KB, 下载问: 5)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 转播转播 分享分享 分享淘帖 顶 踩
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51Hei单片机16群 联系QQ:125739409;技术交流QQ群7344883

Powered by 单片机教程网

快速回复 返回顶部 返回列表
ձһhƬձƵ ձƵɫwww ձƵ:ɫ