创客神器NanoPi
直播中

左宗棠

8年用户 31经验值
擅长:可编程逻辑
私信 关注
[经验]

【NanoPi M2试用体验】字符类GPIO的驱动源码

作为初学者，笔者尝试了“hello world”——点灯。然而鉴于william hill官网 和百度中许多大神用了杂项设备的方法，笔者自己尝试了下字符型设备，编译方法就略过了，以下是源码：
char_driver_leds.h
  1. #ifndef _CHAR_DRIVER_LEDS_H_
  2. #define _CHAR_DRIVER_LEDS_H_

  4. #ifndef DEVICE_NAME
  5. #define DEVICE_NAME "charGPIO"
  6. #endif

  8. #ifndef DEVICE_MINOR_NUM
  9. #define DEVICE_MINOR_NUM 2
  10. #endif

  12. #ifndef DEV_MAJOR
  13. #define DEV_MAJOR 0
  14. #endif

  16. #ifndef DEV_MINOR
  17. #define DEV_MINOR 0
  18. #endif

  20. #ifndef REGDEV_SIZE
  21. #define REGDEV_SIZE 3000
  22. #endif

  24. struct reg_dev
  25. {
  26.         char *data;
  27.         struct cdev cdev;
  28. };
  29. #endif
char_driver_leds.c
  1. /*包含初始化宏定义的头文件,代码中的module_init和module_exit在此文件中*/
  2. #include
  3. /*包含初始化加载模块的头文件,代码中的MODULE_LICENSE在此头文件中*/
  4. #include
  5. /*定义module_param module_param_array的头文件*/
  6. #include
  7. /*定义module_param module_param_array中perm的头文件*/
  8. #include
  9. /*三个字符设备函数*/
  10. #include
  11. /*MKDEV转换设备号数据类型的宏定义*/
  12. #include
  13. /*定义字符设备的结构体*/
  14. #include
  15. /*分配内存空间函数头文件*/
  16. #include
  17. /*包含函数device_create 结构体class等头文件*/
  18. #include

  20. #include
  21. #include //包含prink等函数
  22. #include //与c++相关的东西
  23. #include //Linux中申请GPIO的头文件
  24. /*自定义头文件*/
  25. #include "char_driver_leds.h"

  27. #include //不同平台使用的文件
  28. #include


  31. MODULE_LICENSE("Dual BSD/GPL");
  32. /*声明是开源的，没有内核版本限制*/
  33. MODULE_AUTHOR("XIE_dz");
  34. /*声明作者*/

  36. static int led_gpios[] = {
  37.         PAD_GPIO_C + 11,PAD_GPIO_C + 10,
  38. };
  39. #define LED_NUM                ARRAY_SIZE(led_gpios)


  42. int numdev_major = DEV_MAJOR;
  43. int numdev_minor = DEV_MINOR;

  45. /*输入主设备号*/
  46. module_param(numdev_major,int,S_IRUSR);
  47. /*输入次设备号*/
  48. module_param(numdev_minor,int,S_IRUSR);

  50. static struct class *myclass;
  51. struct reg_dev *my_devices;

  53. /*打开操作*/
  54. static int chardevnode_open(struct inode *inode, struct file *file){
  55.         printk(KERN_EMERG "chardevnode_open is success!n");
  56.        
  57.         return 0;
  58. }
  59. /*关闭操作*/
  60. static int chardevnode_release(struct inode *inode, struct file *file){
  61.         printk(KERN_EMERG "chardevnode_release is success!n");
  62.        
  63.         return 0;
  64. }
  65. /*IO操作*/
  66. static long chardevnode_ioctl(struct file *file, unsigned int cmd, unsigned long arg){
  67.        
  68.         switch(cmd)
  69.         {
  70.                 case 0:
  71.                 case 1:
  72.                         if (arg > LED_NUM) {
  73.                                 return -EINVAL;
  74.                         }

  76.                         gpio_set_value(led_gpios[arg], cmd);
  77.                         break;

  79.                 default:
  80.                         return -EINVAL;
  81.         }
  82.        
  83.         printk(KERN_EMERG "chardevnode_ioctl is success! cmd is %d,arg is %d n",cmd,arg);
  84.        
  85.         return 0;
  86. }

  88. ssize_t chardevnode_read(struct file *file, char __user *buf, size_t count, loff_t *f_ops){
  89.         return 0;
  90. }

  92. ssize_t chardevnode_write(struct file *file, const char __user *buf, size_t count, loff_t *f_ops){
  93.         return 0;
  94. }

  96. loff_t chardevnode_llseek(struct file *file, loff_t offset, int ence){
  97.         return 0;
  98. }
  99. struct file_operations my_fops = {
  100.         .owner = THIS_MODULE,
  101.         .open = chardevnode_open,
  102.         .release = chardevnode_release,
  103.         .unlocked_ioctl = chardevnode_ioctl,
  104.         .read = chardevnode_read,
  105.         .write = chardevnode_write,
  106.         .llseek = chardevnode_llseek,
  107. };


  110. /*设备注册到系统*/
  111. static void reg_init_cdev(struct reg_dev *dev,int index){
  112.         int err;
  113.         int devno = MKDEV(numdev_major,numdev_minor+index);

  115.         /*数据初始化*/
  116.         cdev_init(&dev->cdev,&my_fops);
  117.         dev->cdev.owner = THIS_MODULE;
  118.        
  119.        
  120.         /*注册到系统*/
  121.         err = cdev_add(&dev->cdev,devno,1);
  122.         if(err){
  123.                 printk(KERN_EMERG "cdev_add %d is fail! %dn",index,err);
  124.         }
  125.         else{
  126.                 printk(KERN_EMERG "cdev_add %d is success!n",numdev_minor+index);
  127.         }
  128. }

  130. static int gpio_init(void){
  131.         int i=0,ret;
  132.        
  133.         for(i=0;i
  134.                 ret = gpio_request(led_gpios[i], "LED");
  135.                 if (ret) {
  136.                         printk("%s: request GPIO %d for LED failed, ret = %dn", DEVICE_NAME,i,ret);
  137.                         return -1;
  138.                 }
  139.                 else{
  140.                         gpio_direction_output(led_gpios[i], 1);
  141.                         //gpio_set_value(led_gpios[i], 1);                       
  142.                 }
  143.         }
  144.        
  145.         return 0;
  146. }


  149. static int scdev_init(void)
  150. {
  151.         int ret = 0,i;
  152.         dev_t num_dev;
  153.        
  154.        
  155.         printk(KERN_EMERG "numdev_major is %d!n",numdev_major);//主设备号
  156.         printk(KERN_EMERG "numdev_minor is %d!n",numdev_minor);//次设备号
  157.        
  158.         if(numdev_major){
  159.                 num_dev = MKDEV(numdev_major,numdev_minor);//生成设备号
  160.                 ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NAME);//向系统申请设备号（已知设备号）
  161.         }
  162.         else{
  163.                 /*动态注册设备号*/
  164.                 ret = alloc_chrdev_region(&num_dev,numdev_minor,DEVICE_MINOR_NUM,DEVICE_NAME);//向系统申请设备号（动态申请）
  165.                 /*获得主设备号*/
  166.                 numdev_major = MAJOR(num_dev);
  167.                 printk(KERN_EMERG "adev_region req %d !n",numdev_major);
  168.         }
  169.         if(ret<0){
  170.                 printk(KERN_EMERG "register_chrdev_region req %d is failed!n",numdev_major);               
  171.         }
  172.         myclass = class_create(THIS_MODULE,DEVICE_NAME);//创建设备类别文件
  173.        
  174.        
  175.         my_devices = kmalloc(DEVICE_MINOR_NUM * sizeof(struct reg_dev),GFP_KERNEL);//分配内存
  176.         if(!my_devices){
  177.                 ret = -ENOMEM;
  178.                 goto fail;
  179.         }
  180.         memset(my_devices,0,DEVICE_MINOR_NUM * sizeof(struct reg_dev));//将s中前n个字节用 ch 替换并返回 s 。
  181.        
  182.         /*设备初始化*/
  183.         for(i=0;i
  184.                 my_devices[i].data = kmalloc(REGDEV_SIZE,GFP_KERNEL);//GFP_KERNEL是一个宏，分配内核空间
  185.                 memset(my_devices[i].data,0,REGDEV_SIZE);
  186.                 /*设备注册到系统*/
  187.                 reg_init_cdev(&my_devices[i],i);
  188.                
  189.                 /*创建设备节点*/
  190.                 device_create(myclass,NULL,MKDEV(numdev_major,numdev_minor+i),NULL,DEVICE_NAME"%d",i);
  191.         }
  192.        
  193.         ret = gpio_init();
  194.         if(ret){
  195.                 printk(KERN_EMERG "gpio_init failed!n");
  196.         }       
  197.                
  198.         printk(KERN_EMERG "scdev_init!n");
  199.         /*打印信息，KERN_EMERG表示紧急信息*/
  200.         return 0;

  202. fail:
  203.         /*注销设备号*/
  204.         unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
  205.         printk(KERN_EMERG "kmalloc is fail!n");
  206.        
  207.         return ret;
  208. }

  210. static void scdev_exit(void)
  211. {
  212.         int i;
  213.         printk(KERN_EMERG "scdev_exit!n");
  214.        
  215.         /*除去字符设备*/
  216.         for(i=0;i
  217.                 cdev_del(&(my_devices[i].cdev));//这个函数会干掉cdev_map 散列表及dev本身
  218.                 /*摧毁设备节点函数d*/
  219.                 device_destroy(myclass,MKDEV(numdev_major,numdev_minor+i));
  220.         }
  221.         /*释放设备class*/
  222.         class_destroy(myclass);
  223.         /*释放内存*/
  224.         kfree(my_devices);
  225.        
  226.         /*释放GPIO*/
  227.         for(i=0;i
  228.                 gpio_free(led_gpios[i]);
  229.         }
  230.         //释放设备号       
  231.         unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);
  232. }


  235. module_init(scdev_init);
  236. /*初始化函数*/
  237. module_exit(scdev_exit);
  238. /*卸载函数*/
还有调用该驱动的文件invoke_char_gpios.c
  1. #include
  2. //#include //根据环境变化的长度，各种_t
  3. //#include //获取文件属性函数，各种_t
  4. #include
  5. #include //各种系统api如read，write
  6. #include

  8. /*argv[1] is cmd , argv[2] is io_arg*/
  9. int main()
  10. {
  11.         int fd,i;
  12.         char *lednode = "/dev/charGPIO0";

  14.         /*O_RDWR只读打开,O_NDELAY非阻塞方式*/       
  15.         if((fd = open(lednode,O_RDWR|O_NDELAY))<0){
  16.                 printf("APP open %s failed!n",lednode);
  17.         }
  18.         else{
  19.                 printf("APP open %s success!n",lednode);
  20.                 //ioctl(fd,atoi(argv[1]),atoi(argv[2]));
  21.                 //printf("APP ioctl %s ,cmd is %s! io_arg is %s!n",lednode,argv[1],argv[2]);
  22.                 for(i=0;i<10;i++){
  23.                 ioctl(fd, 1, 0);
  24.                 ioctl(fd, 1, 1);
  25.                 sleep(1);

  27.                 ioctl(fd, 0, 0);
  28.                 ioctl(fd, 0, 1);
  29.                 sleep(1);
  30.             }
  31.         }
  32.        
  33.         close(fd);
  34.         return 0;
  35. }
以上就是全部的源码了，望各位大神指教咯。



回帖（1）

电子工程师2014

2016-9-3 22:06:30
这个好学吗
举报

更多回帖

1 0 1

相关帖子

发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分