简介

IOCTL被称为输入和输出控制，用于与设备驱动程序进行通信。该系统调用在大多数驱动程序类别中可用。此功能的主要用途是处理默认情况下内核没有系统调用的设备的某些特定操作。这个函数在设备驱动里面用的很多。
IOCTL的一些实时应用程序是从“ cd”驱动器中弹出媒体，以更改串行端口的波特率，调整音量，读取或写入设备寄存器等。我们已经在设备中具有写入和读取功能驱动。但这还不足以适用于所有情况。

IOCTL涉及到的一步骤

  1. 在驱动程序创建IOCTL命令
  2. 在驱动程序编写IOCTL函数
  3. 应用程序创建IOCTL命令
  4. 应用程序使用IOCTL调用

    在驱动程序创建IOCTL命令

    ```c

    define “ioctl name” __IOX(“magic number”,”command number”,”argument type”)

  • IOX 可以是下面几种值 “IO“: an ioctl with no parameters “IOW“: an ioctl with write parameters (copy_from_user) “IOR“: an ioctl with read parameters (copy_to_user) “IOWR“: an ioctl with both write and read parameters

“Magic Number” 是唯一的数字或字符，将区分我们从其他ioctl调用ioctl（）调用的集合。有时在这里使用设备的主要号码。 “command number” 是分配给ioctl的编号。这用于区分命令 “argument type” 是数据类型

  2. - 下面是使用例子
  3. ```c
  4. #include <linux/ioctl.h>
  6. #define WR_VALUE _IOW('a','a',int32_t*)
  7. #define RD_VALUE _IOR('a','b',int32_t*)

Write IOCTL function in the driver

上面我们创建了IOCTL命令。下面我们来实现ioctl驱动函数

  1. inioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg)
  2. <inode>   : is the inode number of the file being worked on.
  3. <file>   : is the file pointer to the file that was passed by the application.
  4. <cmd> : is the ioctl command that was called from the userspace.
  5. <arg>   : are the arguments passed from the userspace.

在函数“ ioctl”中，我们需要实现上面（WR_VALUE，RD_VALUE）定义的所有命令。
然后，我们需要通知内核ioctl调用是在函数“ etx_ioctl” 中实现的。

  1. static long etx_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  2. {
  3.          switch(cmd) {
  4.                 case WR_VALUE:
  5.                         copy_from_user(&value ,(int32_t*) arg, sizeof(value));
  6.                         printk(KERN_INFO "Value = %d\n", value);
  7.                         break;
  8.                 case RD_VALUE:
  9.                         copy_to_user((int32_t*) arg, &value, sizeof(value));
  10.                         break;
  11.         }
  12.         return 0;
  13. }
  16. static struct file_operations fops =
  17. {
  18.  .owner = THIS_MODULE,
  19.  .read = etx_read,
  20.  .write = etx_write,
  21.  .open = etx_open,
  22.  .unlocked_ioctl = etx_ioctl,
  23.  .release = etx_release,
  24. };


代码

驱动

  1. #include <linux/kernel.h>
  2. #include <linux/init.h>
  3. #include <linux/module.h>
  4. #include <linux/kdev_t.h>
  5. #include <linux/fs.h>
  6. #include <linux/cdev.h>
  7. #include <linux/device.h>
  8. #include <linux/slab.h>    //kmalloc()
  9. #include <linux/uaccess.h> //copy_to/from_user()
  10. #include <linux/ioctl.h>
  12. #define WR_VALUE _IOW('a', 'a', int32_t *)
  13. #define RD_VALUE _IOR('a', 'b', int32_t *)
  14. #define NONE_Op _IO('a', 'c')
  15. #define READWRIE_VALUE _IOWR('a', 'd', int32_t *)
  17. int32_t value = 0;
  19. dev_t dev = 0;
  20. static struct class *dev_class;
  21. static struct cdev etx_cdev;
  23. static int __init etx_driver_init(void);
  24. static void __exit etx_driver_exit(void);
  25. static int etx_open(struct inode *inode, struct file *file);
  26. static int etx_release(struct inode *inode, struct file *file);
  27. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off);
  28. static ssize_t etx_write(struct file *filp, const char *buf, size_t len, loff_t *off);
  29. static long etx_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  31. static struct file_operations fops =
  32.     {
  33.         .owner = THIS_MODULE,
  34.         .read = etx_read,
  35.         .write = etx_write,
  36.         .open = etx_open,
  37.         .unlocked_ioctl = etx_ioctl,
  38.         .release = etx_release,
  39. };
  41. static int etx_open(struct inode *inode, struct file *file)
  42. {
  43.         printk(KERN_INFO "Device File Opened...!!!\n");
  44.         return 0;
  45. }
  47. static int etx_release(struct inode *inode, struct file *file)
  48. {
  49.         printk(KERN_INFO "Device File Closed...!!!\n");
  50.         return 0;
  51. }
  53. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
  54. {
  55.         printk(KERN_INFO "Read Function\n");
  56.         return 0;
  57. }
  58. static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
  59. {
  60.         printk(KERN_INFO "Write function\n");
  61.         return 0;
  62. }
  64. static long etx_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  65. {
  66.         int ret = 0x00;
  67.         switch (cmd)
  68.         {
  69.         case WR_VALUE:
  70.                 ret = copy_from_user(&value, (int32_t *)arg, sizeof(value));
  71.                 printk(KERN_INFO "Value = %d\n", value);
  72.                 break;
  73.         case RD_VALUE:
  74.                 ret = copy_to_user((int32_t *)arg, &value, sizeof(value));
  75.                 break;
  76.         case NONE_Op:
  77.                 printk("Nonr Argc\n");
  78.                 break;
  79.         case READWRIE_VALUE:
  80.                 ret = copy_from_user(&value, (int32_t *)arg, sizeof(value));
  81.                 value = value + 1;
  82.                 ret = copy_to_user((int32_t *)arg, &value, sizeof(value));
  83.                 break;
  84.         }
  85.         (void)ret;
  86.         return 0;
  87. }
  89. static int __init etx_driver_init(void)
  90. {
  91.         /*Allocating Major number*/
  92.         if ((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) < 0)
  93.         {
  94.                 printk(KERN_INFO "Cannot allocate major number\n");
  95.                 return -1;
  96.         }
  97.         printk(KERN_INFO "Major = %d Minor = %d \n", MAJOR(dev), MINOR(dev));
  99.         /*Creating cdev structure*/
  100.         cdev_init(&etx_cdev, &fops);
  102.         /*Adding character device to the system*/
  103.         if ((cdev_add(&etx_cdev, dev, 1)) < 0)
  104.         {
  105.                 printk(KERN_INFO "Cannot add the device to the system\n");
  106.                 goto r_class;
  107.         }
  109.         /*Creating struct class*/
  110.         if ((dev_class = class_create(THIS_MODULE, "etx_class")) == NULL)
  111.         {
  112.                 printk(KERN_INFO "Cannot create the struct class\n");
  113.                 goto r_class;
  114.         }
  116.         /*Creating device*/
  117.         if ((device_create(dev_class, NULL, dev, NULL, "etx_device")) == NULL)
  118.         {
  119.                 printk(KERN_INFO "Cannot create the Device 1\n");
  120.                 goto r_device;
  121.         }
  122.         printk(KERN_INFO "Device Driver Insert...Done!!!\n");
  123.         return 0;
  125. r_device:
  126.         class_destroy(dev_class);
  127. r_class:
  128.         unregister_chrdev_region(dev, 1);
  129.         return -1;
  130. }
  132. void __exit etx_driver_exit(void)
  133. {
  134.         device_destroy(dev_class, dev);
  135.         class_destroy(dev_class);
  136.         cdev_del(&etx_cdev);
  137.         unregister_chrdev_region(dev, 1);
  138.         printk(KERN_INFO "Device Driver Remove...Done!!!\n");
  139. }
  141. module_init(etx_driver_init);
  142. module_exit(etx_driver_exit);
  144. MODULE_LICENSE("GPL");
  145. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  146. MODULE_DESCRIPTION("A Sample ioctl module demo");
  147. MODULE_VERSION("2:1.0");

应用

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <unistd.h>
  8. #include <sys/ioctl.h>
  10. #define WR_VALUE _IOW('a', 'a', int32_t *)
  11. #define RD_VALUE _IOR('a', 'b', int32_t *)
  12. #define NONE_Op _IO('a', 'c')
  13. #define READWRIE_VALUE _IOWR('a', 'd', int32_t *)
  16. int main()
  17. {
  18.     int fd;
  19.     int32_t value, number;
  20.     printf("*********************************\n");
  21.     printf("*******WWW.EmbeTronicX.com*******\n");
  23.     printf("\nOpening Driver\n");
  24.     fd = open("/dev/etx_device", O_RDWR);
  25.     if (fd < 0)
  26.     {
  27.         printf("Cannot open device file...\n");
  28.         return 0;
  29.     }
  31.     printf("Enter the Value to send\n");
  32.     scanf("%d", &number);
  33.     printf("Writing Value to Driver\n");
  34.     ioctl(fd, WR_VALUE, (int32_t *)&number);
  36.     printf("Reading Value from Driver\n");
  37.     ioctl(fd, RD_VALUE, (int32_t *)&value);
  38.     printf("Value is %d\n", value);
  40.     printf("None Value from Driver\n");
  41.     ioctl(fd, NONE_Op);
  43.     scanf("%d", &number);
  44.     printf("Write Value is 0x%x\n", number);
  45.     ioctl(fd, READWRIE_VALUE, (int32_t *)&number);
  46.     printf("Write Bakc Value is 0x%x\n", number);
  47.     printf("Closing Driver\n");
  48.     close(fd);
  49. }

参考资料

IOCTL Tutorial in Linux