IOCTL命令字符设备驱动

820阅读　0评论2014-11-05　644924073
分类：数据库开发技术

  1. #ifndef _MEMDEV_H_
  2. #define _MEMDEV_H_

  4. #include <linux/ioctl.h>

  6. #ifndef MEMDEV_MAJOR
  7. #define MEMDEV_MAJOR 0 /*预设的mem的主设备号*/
  8. #endif

  10. #ifndef MEMDEV_NR_DEVS
  11. #define MEMDEV_NR_DEVS 2 /*设备数*/
  12. #endif

  14. #ifndef MEMDEV_SIZE
  15. #define MEMDEV_SIZE 4096
  16. #endif

  18. /*mem设备描述结构体*/
  19. struct mem_dev
  20. {
  21.   char *data;
  22.   unsigned long size;
  23. };

  25. /* 定义幻数 */
  26. #define MEMDEV_IOC_MAGIC 'k'

  28. /* 定义命令 */
  29. #define MEMDEV_IOCPRINT _IO(MEMDEV_IOC_MAGIC, 1)
  30. #define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)
  31. #define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)

  33. #define MEMDEV_IOC_MAXNR 3

  35. #endif /* _MEMDEV_H_ */
  1. #include <linux/module.h>
  2. #include <linux/types.h>
  3. #include <linux/fs.h>
  4. #include <linux/errno.h>
  5. #include <linux/mm.h>
  6. #include <linux/sched.h>
  7. #include <linux/init.h>
  8. #include <linux/cdev.h>
  9. #include <asm/io.h>
  10. #include <asm/system.h>
  11. #include <asm/uaccess.h>

  13. #include "memdev.h"

  15. static int mem_major = MEMDEV_MAJOR;

  17. module_param(mem_major, int, S_IRUGO);

  19. struct mem_dev *mem_devp; /*设备结构体指针*/

  21. struct cdev cdev;

  23. /*文件打开函数*/
  24. int mem_open(struct inode *inode, struct file *filp)
  25. {
  26.     struct mem_dev *dev;
  27.     
  28.     /*获取次设备号*/
  29.     int num = MINOR(inode->i_rdev);

  31.     if (num >= MEMDEV_NR_DEVS)
  32.             return -ENODEV;
  33.     dev = &mem_devp[num];
  34.     
  35.     /*将设备描述结构指针赋值给文件私有数据指针*/
  36.     filp->private_data = dev;
  37.     
  38.     return 0;
  39. }

  41. /*文件释放函数*/
  42. int mem_release(struct inode *inode, struct file *filp)
  43. {
  44.   return 0;
  45. }

  47. /*IO操作*/
  48. int memdev_ioctl(struct inode *inode, struct file *filp,
  49.                  unsigned int cmd, unsigned long arg)
  50. {

  52.     int err = 0;
  53.     int ret = 0;
  54.     int ioarg = 0;
  55.     
  56.     /* 检测命令的有效性 */
  57.     if (_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC)
  58.         return -EINVAL;
  59.     if (_IOC_NR(cmd) > MEMDEV_IOC_MAXNR)
  60.         return -EINVAL;

  62.     /* 根据命令类型，检测参数空间是否可以访问 */
  63.     if (_IOC_DIR(cmd) & _IOC_READ)
  64.         err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
  65.     else if (_IOC_DIR(cmd) & _IOC_WRITE)
  66.         err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
  67.     if (err)
  68.         return -EFAULT;

  70.     /* 根据命令，执行相应的操作 */
  71.     switch(cmd) {

  73.       /* 打印当前设备信息 */
  74.       case MEMDEV_IOCPRINT:
  75.           printk("<--- CMD MEMDEV_IOCPRINT Done--->\n\n");
  76.         break;
  77.       
  78.       /* 获取参数 */
  79.       case MEMDEV_IOCGETDATA:
  80.         ioarg = 1101;
  81.         ret = __put_user(ioarg, (int *)arg);
  82.         break;
  83.       
  84.       /* 设置参数 */
  85.       case MEMDEV_IOCSETDATA:
  86.         ret = __get_user(ioarg, (int *)arg);
  87.         printk("<--- In Kernel MEMDEV_IOCSETDATA ioarg = %d --->\n\n",ioarg);
  88.         break;

  90.       default:
  91.         return -EINVAL;
  92.     }
  93.     return ret;

  95. }

  97. /*文件操作结构体*/
  98. static const struct file_operations mem_fops =
  99. {
  100.   .owner = THIS_MODULE,
  101.   .open = mem_open,
  102.   .release = mem_release,
  103.   .ioctl = memdev_ioctl,
  104. };

  106. /*设备驱动模块加载函数*/
  107. static int memdev_init(void)
  108. {
  109.   int result;
  110.   int i;

  112.   dev_t devno = MKDEV(mem_major, 0);

  114.   /* 静态申请设备号*/
  115.   if (mem_major)
  116.     result = register_chrdev_region(devno, 2, "memdev");
  117.   else /* 动态分配设备号 */
  118.   {
  119.     result = alloc_chrdev_region(&devno, 0, 2, "memdev");
  120.     mem_major = MAJOR(devno);
  121.   }
  122.   
  123.   if (result < 0)
  124.     return result;

  126.   /*初始化cdev结构*/
  127.   cdev_init(&cdev, &mem_fops);
  128.   cdev.owner = THIS_MODULE;
  129.   cdev.ops = &mem_fops;
  130.   
  131.   /* 注册字符设备 */
  132.   cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
  133.    
  134.   /* 为设备描述结构分配内存*/
  135.   mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
  136.   if (!mem_devp) /*申请失败*/
  137.   {
  138.     result = - ENOMEM;
  139.     goto fail_malloc;
  140.   }
  141.   memset(mem_devp, 0, sizeof(struct mem_dev));
  142.   
  143.   /*为设备分配内存*/
  144.   for (i=0; i < MEMDEV_NR_DEVS; i++)
  145.   {
  146.         mem_devp[i].size = MEMDEV_SIZE;
  147.         mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
  148.         memset(mem_devp[i].data, 0, MEMDEV_SIZE);
  149.   }
  150.     
  151.   return 0;

  153.   fail_malloc:
  154.   unregister_chrdev_region(devno, 1);
  155.   
  156.   return result;
  157. }

  159. /*模块卸载函数*/
  160. static void memdev_exit(void)
  161. {
  162.   cdev_del(&cdev); /*注销设备*/
  163.   kfree(mem_devp); /*释放设备结构体内存*/
  164.   unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
  165. }

  167. MODULE_AUTHOR("David Xie");
  168. MODULE_LICENSE("GPL");

  170. module_init(memdev_init);
  171. module_exit(memdev_exit);
  1. #include <stdio.h>
  2. #include<sys/types.h>
  3. #include<sys/stat.h>
  4. #include<fcntl.h>

  6. #include "memdev.h" /* 包含命令定义 */

  8. int main()
  9. {
  10.     int fd = 0;
  11.     int cmd;
  12.     int arg = 0;
  13.     char Buf[4096];
  14.     
  15.     
  16.     /*打开设备文件*/
  17.     fd = open("/dev/memdev0",O_RDWR);
  18.     if (fd < 0)
  19.     {
  20.         printf("Open Dev Mem0 Error!\n");
  21.         return -1;
  22.     }
  23.     
  24.     /* 调用命令MEMDEV_IOCPRINT */
  25.     printf("<--- Call MEMDEV_IOCPRINT --->\n");
  26.     cmd = MEMDEV_IOCPRINT;
  27.     if (ioctl(fd, cmd, &arg) < 0)
  28.         {
  29.             printf("Call cmd MEMDEV_IOCPRINT fail\n");
  30.             return -1;
  31.     }
  32.     
  33.     
  34.     /* 调用命令MEMDEV_IOCSETDATA */
  35.     printf("<--- Call MEMDEV_IOCSETDATA --->\n");
  36.     cmd = MEMDEV_IOCSETDATA;
  37.     arg = 2007;
  38.     if (ioctl(fd, cmd, &arg) < 0)
  39.         {
  40.             printf("Call cmd MEMDEV_IOCSETDATA fail\n");
  41.             return -1;
  42.     }

  44.     
  45.     /* 调用命令MEMDEV_IOCGETDATA */
  46.     printf("<--- Call MEMDEV_IOCGETDATA --->\n");
  47.     cmd = MEMDEV_IOCGETDATA;
  48.     if (ioctl(fd, cmd, &arg) < 0)
  49.         {
  50.             printf("Call cmd MEMDEV_IOCGETDATA fail\n");
  51.             return -1;
  52.     }
  53.     printf("<--- In User Space MEMDEV_IOCGETDATA Get Data is %d --->\n\n",arg);    
  54.     
  55.     close(fd);
  56.     return 0;    
  57. }
上一篇：字符驱动之八IO访问(硬件操作)
下一篇：USB 鼠标驱动