I2C用户态驱动设计

2022-03-07 07:17:02

一、用户态驱动模型

I2C用户态驱动设计



1.1 I2C通用驱动代码

i2c_dev_init:

  1. static int __init i2c_dev_init(void)
  2. {
  3. int res;
  4. printk(KERN_INFO "i2c /dev entries driver\n");
  5. res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);                                        //早期注册字符设备
  6. if (res)
  7. goto out;
  8. i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");                                         //生成自动创建字符设备文件
  9. if (IS_ERR(i2c_dev_class)) {
  10. res = PTR_ERR(i2c_dev_class);
  11. goto out_unreg_chrdev;
  12. }
  13. res = i2c_add_driver(&i2cdev_driver);                                                          //注册一个I2C的设备驱动
  14. if (res)
  15. goto out_unreg_class;
  16. return 0;
  17. out_unreg_class:
  18. class_destroy(i2c_dev_class);
  19. out_unreg_chrdev:
  20. unregister_chrdev(I2C_MAJOR, "i2c");
  21. out:
  22. printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
  23. return res;
  24. }

i2cdev_fops:

  1. static const struct file_operations i2cdev_fops = {
  2. .owner        = THIS_MODULE,
  3. .llseek        = no_llseek,
  4. .read        = i2cdev_read,
  5. .write        = i2cdev_write,
  6. .unlocked_ioctl    = i2cdev_ioctl,
  7. .open        = i2cdev_open,
  8. .release    = i2cdev_release,
  9. };

i2cdev_ioctl:

  1. static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  2. {
  3. struct i2c_client *client = (struct i2c_client *)file->private_data;
  4. unsigned long funcs;
  5. dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
  6. cmd, arg);
  7. switch ( cmd ) {
  8. case I2C_SLAVE:
  9. case I2C_SLAVE_FORCE:
  10. /* NOTE: devices set up to work with "new style" drivers
  11. * can't use I2C_SLAVE, even when the device node is not
  12. * bound to a driver. Only I2C_SLAVE_FORCE will work.
  13. *
  14. * Setting the PEC flag here won't affect kernel drivers,
  15. * which will be using the i2c_client node registered with
  16. * the driver model core. Likewise, when that client has
  17. * the PEC flag already set, the i2c-dev driver won't see
  18. * (or use) this setting.
  19. */
  20. if ((arg > 0x3ff) ||
  21. (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
  22. return -EINVAL;
  23. if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
  24. return -EBUSY;
  25. /* REVISIT: address could become busy later */
  26. client->addr = arg;
  27. return 0;
  28. case I2C_TENBIT:
  29. if (arg)
  30. client->flags |= I2C_M_TEN;
  31. else
  32. client->flags &= ~I2C_M_TEN;
  33. return 0;
  34. case I2C_PEC:
  35. if (arg)
  36. client->flags |= I2C_CLIENT_PEC;
  37. else
  38. client->flags &= ~I2C_CLIENT_PEC;
  39. return 0;
  40. case I2C_FUNCS:
  41. funcs = i2c_get_functionality(client->adapter);
  42. return put_user(funcs, (unsigned long __user *)arg);
  43. case I2C_RDWR:                                                                             //这里是读写命令
  44. return i2cdev_ioctl_rdrw(client, arg);
  45. case I2C_SMBUS:
  46. return i2cdev_ioctl_smbus(client, arg);
  47. case I2C_RETRIES:
  48. client->adapter->retries = arg;
  49. break;
  50. case I2C_TIMEOUT:
  51. /* For historical reasons, user-space sets the timeout
  52. * value in units of 10 ms.
  53. */
  54. client->adapter->timeout = msecs_to_jiffies(arg * 10);
  55. break;
  56. default:
  57. /* NOTE: returning a fault code here could cause trouble
  58. * in buggy userspace code. Some old kernel bugs returned
  59. * zero in this case, and userspace code might accidentally
  60. * have depended on that bug.
  61. */
  62. return -ENOTTY;
  63. }
  64. return 0;
  65. }

i2cdev_ioctl_rdrw:

  1. static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
  2. unsigned long arg)
  3. {
  4. struct i2c_rdwr_ioctl_data rdwr_arg;
  5. struct i2c_msg *rdwr_pa;
  6. u8 __user **data_ptrs;
  7. int i, res;
  8. if (copy_from_user(&rdwr_arg,
  9. (struct i2c_rdwr_ioctl_data __user *)arg,                        //传给ioctl的arg值，强制转换成i2c_rdwr_ioctl_data
  10. sizeof(rdwr_arg)))
  11. return -EFAULT;
  12. /* Put an arbitrary limit on the number of messages that can
  13. * be sent at once */
  14. if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
  15. return -EINVAL;
  16. rdwr_pa = (struct i2c_msg *)
  17. kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
  18. GFP_KERNEL);
  19. if (!rdwr_pa)
  20. return -ENOMEM;
  21. if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
  22. rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
  23. kfree(rdwr_pa);
  24. return -EFAULT;
  25. }
  26. data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
  27. if (data_ptrs == NULL) {
  28. kfree(rdwr_pa);
  29. return -ENOMEM;
  30. }
  31. res = 0;
  32. for (i = 0; i < rdwr_arg.nmsgs; i++) {
  33. /* Limit the size of the message to a sane amount;
  34. * and don't let length change either. */
  35. if ((rdwr_pa[i].len > 8192) ||
  36. (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
  37. res = -EINVAL;
  38. break;
  39. }
  40. data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
  41. rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
  42. if (rdwr_pa[i].buf == NULL) {
  43. res = -ENOMEM;
  44. break;
  45. }
  46. if (copy_from_user(rdwr_pa[i].buf, data_ptrs[i],
  47. rdwr_pa[i].len)) {
  48. ++i; /* Needs to be kfreed too */
  49. res = -EFAULT;
  50. break;
  51. }
  52. }
  53. if (res < 0) {
  54. int j;
  55. for (j = 0; j < i; ++j)
  56. kfree(rdwr_pa[j].buf);
  57. kfree(data_ptrs);
  58. kfree(rdwr_pa);
  59. return res;
  60. }
  61. res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);                           //发送数据来源于i2c核心
  62. while (i-- > 0) {
  63. if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {
  64. if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf,
  65. rdwr_pa[i].len))
  66. res = -EFAULT;
  67. }
  68. kfree(rdwr_pa[i].buf);
  69. }
  70. kfree(data_ptrs);
  71. kfree(rdwr_pa);
  72. return res;
  73. }

i2c_rdwr_ioctl_data:

  1. struct i2c_rdwr_ioctl_data {
  2. struct i2c_msg __user *msgs;    /* pointers to i2c_msgs */                    消息指针
  3. __u32 nmsgs;            /* number of i2c_msgs */                              有多少条消息
  4. };

一条消息（一个读操作和写操作）：

I2C用户态驱动设计

  1. struct i2c_msg {
  2. __u16 addr;    /* slave address            */                                //从设备地址
  3. __u16 flags;                                                                 //读还是写
  4. #define I2C_M_TEN        0x0010    /* this is a ten bit chip address */
  5. #define I2C_M_RD        0x0001    /* read data, from slave to master */
  6. #define I2C_M_NOSTART        0x4000    /* if I2C_FUNC_PROTOCOL_MANGLING */
  7. #define I2C_M_REV_DIR_ADDR    0x2000    /* if I2C_FUNC_PROTOCOL_MANGLING */
  8. #define I2C_M_IGNORE_NAK    0x1000    /* if I2C_FUNC_PROTOCOL_MANGLING */
  9. #define I2C_M_NO_RD_ACK        0x0800    /* if I2C_FUNC_PROTOCOL_MANGLING */
  10. #define I2C_M_RECV_LEN        0x0400    /* length will be first received byte */
  11. __u16 len;        /* msg length                */                             //消息里面有多少字节
  12. __u8 *buf;        /* pointer to msg data            */                        //消息里面的数据
  13. };

i2c_transfer:

  1. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
  2. {
  3. int ret;
  4. if (adap->algo->master_xfer) {
  5. #ifdef DEBUG
  6. for (ret = 0; ret < num; ret++) {
  7. dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
  8. "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
  9. ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
  10. (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
  11. }
  12. #endif
  13. if (in_atomic() || irqs_disabled()) {
  14. ret = mutex_trylock(&adap->bus_lock);
  15. if (!ret)
  16. /* I2C activity is ongoing. */
  17. return -EAGAIN;
  18. } else {
  19. mutex_lock_nested(&adap->bus_lock, adap->level);
  20. }
  21. ret = adap->algo->master_xfer(adap,msgs,num);                               //找到adapter（控制器）->algo(算法）->master_xfer（发送）
  22. mutex_unlock(&adap->bus_lock);
  23. return ret;
  24. } else {
  25. dev_dbg(&adap->dev, "I2C level transfers not supported\n");
  26. return -EOPNOTSUPP;
  27. }
  28. }

二、EEPROM用户态驱动编写

i2c-app-drv.c:

  1. #include <sys/stat.h>
  2. #include <fcntl.h>
  3. #include <stdio.h>
  4. #include <unistd.h>
  5. #include <linux/types.h>
  6. #define I2C_RDWR 0x0707
  7. struct i2c_msg {
  8. unsigned short addr;    /* slave address            */
  9. unsigned short flags;
  10. unsigned short len;        /* msg length                */
  11. unsigned char *buf;        /* pointer to msg data            */
  12. };
  13. struct i2c_rdwr_ioctl_data {
  14. struct i2c_msg *msgs;    /* pointers to i2c_msgs */
  15. unsigned int nmsgs;            /* number of i2c_msgs */
  16. };
  17. int main()
  18. {
  19. int fd;
  20. struct i2c_rdwr_ioctl_data e2prom_data;
  21. //1.打开通用设备文件
  22. fd = open("/dev/i2c-0", O_RDWR);
  23. e2prom_data.msgs = (struct i2c_msg *)malloc(2*sizeof(struct i2c_msg));
  24. //2.构造写数据到eeprom的消息
  25. e2prom_data.nmsgs = 1;
  26. (e2prom_data.msgs[0]).len = 2;
  27. (e2prom_data.msgs[0]).addr = 0x50;
  28. (e2prom_data.msgs[0]).flags = 0;
  29. (e2prom_data.msgs[0]).buf = (unsigned char *)malloc(2);
  30. (e2prom_data.msgs[0]).buf[0] = 0x10;
  31. (e2prom_data.msgs[0]).buf[1] = 0xF0;
  32. //3.利用ioctl写入数据
  33. ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);
  34. //4.构造从eeprom读书据的消息
  35. e2prom_data.nmsgs = 2;
  36. (e2prom_data.msgs[0]).len = 1;
  37. (e2prom_data.msgs[0]).addr = 0x50;
  38. (e2prom_data.msgs[0]).flags = 0;
  39. (e2prom_data.msgs[0]).buf[0] = 0x10;
  40. (e2prom_data.msgs[1]).len = 1;
  41. (e2prom_data.msgs[1]).addr = 0x50;
  42. (e2prom_data.msgs[1]).flags = 1;
  43. (e2prom_data.msgs[1]).buf = (unsigned char *)malloc(2);
  44. (e2prom_data.msgs[1]).buf[0] = 0;
  45. //5.使用ioctl读出数据
  46. ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);
  47. printf("buf[0]=%x\n",(e2prom_data.msgs[1]).buf[0]);
  48. //6.关闭设备
  49. close(fd);
  50. }

遇到的问题：

  1. # ./i2c-app-drv
  2. s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
  3. s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
  4. s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
  5. s3c2440-i2c s3c2440-i2c: cannot get bus (error -110)
  6. buf[0]=0

内核中的i2c和视频模块冲突了。所以要在内核中去掉视频模块：

Device Drivers>>Multimedia devices>>Video For Linux



结果：

  1. # ./i2c-app-drv
  2. buf[0]=f0
上一篇：网络流（四）dinic算法


下一篇：ASPOSE.Cells & ASPOSE.Words 操纵Excel和Word文档的 .NET Core 实例