设为首页CubieBoard博客-HomeCubieTech公司网站收藏本站
切换到宽版

CubieBoard中文论坛

 找回密码
 立即注册
搜索
热搜: unable
CubieBoard中文论坛»论坛 › 学习开发 › 驱动程序开发 › 五种方法点亮LED，入门驱动程序，更新完毕 ...
12下一页
返回列表 发新帖
查看: 18621|回复: 16

五种方法点亮LED，入门驱动程序，更新完毕

[复制链接]
简单侶途　
发表于 2015-11-9 11:57:11 | 显示全部楼层 |阅读模式
本帖最后由 简单侶途　 于 2015-11-13 15:35 编辑

首先介绍我用到的硬件平台和内核版本：Linux cubietruck 3.4.79内核版本，硬件为cubietruck开发板
学习点亮LED入门参考资料，先可以看看下面3份简单的介绍，程序将要用到的，不做其他简单解释咯。



1.必备搭建的工具
实现操作必备的命令：
安装工具
#apt-get install gcc git build-essential libusb-dev pkg-config libusb-1.0
#git clone https://github.com/linux-sunxi/sunxi-tools
#cd sunxi-tools
#make
#cp bin2fex fex2bin fexc /bin
操作script.fex
#vi script.fex

提示：如何找到script.fex进行修改 (以下对于cubietruck卡系统启动)
# mount /dev/mmcblk0p1 /mnt/
#cd /mnt
#ls                                                        
lost+found  pulse-PKdhtXMmr18n  script.bin  script.fex  uEnv.txt  uImage  


2.修改配置文件，#后面的是注释，请忽略添加在script.fex文件下，script.fex文件修改以下部分，来实现控制4个led
#-----------------------------------------------------------------------------表情那里是PH20，不知道为何是表情
[gpio_para]
gpio_used = 1   #1为使能，0为失能
gpio_num = 4    #4为应用4个引脚配置
gpio_pin_1 = portH20<1><default><default><1>  #num = 1
gpio_pin_2 = portH21<1><default><default><1>  #num = 2
gpio_pin_3 = portH11<1><default><default><1>  #num = 3
gpio_pin_4 = portH7<1><default><default><1>   #num = 4

[leds_para]
leds_used = 0   #失能led系统配置，这些引脚被我引用为4个led控制引脚了
leds_num = 4

3.修改完后，记得执行
root@cubietruck:/mnt# fex2bin script.fex script.bin
#reboot

4.开始我们的第一门入门学习了，刚开始学的时候可以参考韦东山视频教程的点亮LED，不过平台不一样，大体框架还算类似
  1. #include<linux/fs.h>
  2. #include<linux/module.h>
  3. #include<linux/errno.h>
  4. #include<linux/kernel.h>
  5. #include<linux/init.h>
  6. #include<linux/cdev.h>
  7. #include<linux/uaccess.h>
  8. #include<linux/device.h>
  9. #include<linux/types.h>
  10. #include <asm/gpio.h>
  11. #include <linux/gpio.h>
  12. #include <plat/sys_config.h>

  14. #include <linux/delay.h>
  15. #include <asm/irq.h>
  16. #include <asm/io.h>

  18. //设备类
  19. static struct class *leddrv_class;
  20. //分配 cdev
  21. static struct class_device *leddrv_class_dev;
  22. //主设备号
  23. static int major;

  25. static int status;//表示灯的状态

  27. static int led_open(struct inode *inode, struct file *file)
  28. {
  29.         return 0;
  30. }


  33. static ssize_t led_read (struct file *file,char __user *buf,
  34.                                                  size_t count,loff_t *f_pos)
  35. {
  36.         copy_to_user(buf,&status,4);
  37.         return count;
  38. }

  40. static ssize_t led_write (struct file *file,char __user *buf,
  41.                                                   size_t count,loff_t *f_pos)
  42. {
  43.         int val;
  44.         /*1.从用户空间读取数据到内核空间*/
  45.         copy_from_user(&val,buf,4);

  47.         /*2.判断传入值val，进行GPIO电平控制*/
  48.         if(val == 1){
  49.                 gpio_set_value(1,1);
  50.                 gpio_set_value(2,1);
  51.                 gpio_set_value(3,1);
  52.                 gpio_set_value(4,1);
  53.         }
  54.         else{
  55.                 gpio_set_value(1,0);
  56.                 gpio_set_value(2,0);
  57.                 gpio_set_value(3,0);
  58.                 gpio_set_value(4,0);
  59.         }
  60.         return 0;
  61. }

  63. //分配驱动操作
  64. static struct file_operations leddrv_fops = {

  66.         .owner   =    THIS_MODULE,
  67.         .open         =    led_open,
  68.         .read    =    led_read,
  69.         .write   =    led_write,
  70. };

  72. static int  led_init(void)
  73. {
  74.         
  75.          major = register_chrdev(0, "led", &leddrv_fops);
  76.         leddrv_class = class_create(THIS_MODULE, "led");
  77.         leddrv_class_dev = device_create(leddrv_class, NULL, MKDEV(major, 0), NULL, "ledwht"); /* /dev/ledwht */


  80.         /*申请GPIO资源*/
  81.       if(gpio_request(1,"gpio")){
  82.                       printk("request gpio1 error\n");
  83.       }
  84.       if(gpio_request(2,"gpio")){
  85.                       printk("request gpio2 error\n");
  86.           }
  87.           if(gpio_request(3,"gpio")){
  88.                     printk("request gpio3 error\n");
  89.           }
  90.           if(gpio_request(4,"gpio")){
  91.                    printk("request gpio4 error\n");
  92.           }           
  93.         
  94.       /*配置为输出引脚*/
  95.       gpio_direction_output(1,0);
  96.           gpio_direction_output(2,0);
  97.           gpio_direction_output(3,0);
  98.           gpio_direction_output(4,0);

  100.         return 0;
  101. }

  103. static void led_exit(void)
  104. {
  105.         /*1.释放 GPIO 资源*/
  106.         gpio_free(1);
  107.         gpio_free(2);
  108.         gpio_free(3);
  109.         gpio_free(4);
  110.         unregister_chrdev(major, "led");
  111.         /*2.删除设备节点*/
  112.         device_destroy(leddrv_class, MKDEV(major, 0));
  113.         class_destroy(leddrv_class);
  114. }

  116. module_init(led_init);
  117. module_exit(led_exit);
  118. MODULE_LICENSE("GPL");
复制代码
5.测试驱动程序
1.insmod led_drv1.ko //加载驱动
2../led_app                  //同时点亮4个led
end--firstdriver---------------------------------------------------------------------------------------------------------------------------

6.对比一下两个文件可以看出，就寄存器部分不一样而已
  1. #include<linux/fs.h>
  2. #include<linux/module.h>
  3. #include<linux/errno.h>
  4. #include<linux/kernel.h>
  5. #include<linux/init.h>
  6. #include<linux/cdev.h>
  7. #include<linux/uaccess.h>
  8. #include<linux/device.h>
  9. #include<linux/types.h>
  10. #include <asm/gpio.h>
  11. #include <linux/gpio.h>
  12. #include <plat/sys_config.h>
  13. #include <linux/delay.h>
  14. #include <asm/irq.h>
  15. #include <asm/io.h>

  17. #include <linux/moduleparam.h>
  18. #include <linux/poll.h>
  19. #include <linux/sched.h>
  20. #include <linux/spinlock.h>
  21. #include <linux/slab.h>
  22. #include <linux/ipmi.h>
  23. #include <linux/mutex.h>
  24. #include <linux/compat.h>


  27. /*两种方法寻找GPIO寄存器地址*/
  28. //#define PIO_BASE   0x01C20800
  29. #define PH_BASE   (PIO_BASE + 7*0x24)

  31. #define PH_CFG2   (PH_BASE + 0x08)
  32. #define PH_DAT    (PH_BASE + 0x10)

  34. //#define PH_BASE  (PIO_BASE + 0xFC)
  35. //#define PH_CFG2  (PIO_BASE + 0x104)
  36. //#define PH_DAT   (PIO_BASE + 0X10C)

  38. static volatile unsigned int *ph_cfg2;
  39. static volatile unsigned int *ph_dat;

  41. //设备类
  42. static struct class *leddrv_class;
  43. //分配 cdev
  44. static struct class_device *leddrv_class_dev;
  45. //主设备号
  46. static int major;

  48. static int led_open(struct inode *inode, struct file *file)
  49. {
  50.         /*bit20[18:16],bit21[22:20]
  51.          *open the roange_led and blue_led GPIO output
  52.          *Output is 001
  53.          */
  54.         *ph_cfg2 &= ~((7<<16) | (7<<20));//清零000,这个步骤很重要，注释掉可以看下效果如何blue_led不能控制了
  55.         *ph_cfg2 |= ((1<<16) | (1<<20));//设置001
  56.         return 0;
  57. }


  60. static ssize_t led_write (struct file *file,char __user *buf,
  61.                                                   size_t count,loff_t *f_pos)
  62. {
  63.         int val;
  64.         /*1.从用户空间读取数据到内核空间*/
  65.         copy_from_user(&val,buf,4);

  67.         /*2.判断传入值val，进行GPIO电平控制*/
  68.         if(val == 1){
  69.                 *ph_dat |= ((1<<20) | (1<<21));               

  71.         }else{
  72.                 *ph_dat &= ~((1<<20) | (1<<21));
  73.         }
  74.         return 0;
  75. }

  77. //分配驱动操作
  78. static struct file_operations leddrv_fops = {

  80.         .owner   =    THIS_MODULE,
  81.         .open         =    led_open,
  82.         .write   =    led_write,
  83. };

  85. static int  led_init(void)
  86. {
  87.         ph_cfg2 = ioremap(PH_CFG2, 4);
  88.         ph_dat  = ioremap(PH_DAT, 4);
  89.         
  90.          major = register_chrdev(0, "led", &leddrv_fops);
  91.         leddrv_class = class_create(THIS_MODULE, "led");
  92.         leddrv_class_dev = device_create(leddrv_class, NULL, MKDEV(major, 0), NULL, "ledwht"); /* /dev/ledwht */

  94.         return 0;
  95. }

  97. static void led_exit(void)
  98. {

  100.         unregister_chrdev(major, "led");
  101.         /*2.删除设备节点*/
  102.         device_destroy(leddrv_class, MKDEV(major, 0));
  103.         class_destroy(leddrv_class);

  105.         iounmap(ph_cfg2);
  106.         iounmap(ph_dat);
  107. }

  109. module_init(led_init);
  110. module_exit(led_exit);
  111. MODULE_LICENSE("GPL");
复制代码
7.第二个应用操作寄存器方法控制LED点亮led_orange,led_blue
现在就可以直接打开script.fex修改回原来到配置了
[gpio_para]
gpio_used = 1   #1为使能，0为失能
gpio_num = 4    #4为应用4个引脚配置
gpio_pin_1 = portH10<1><default><default><1>  #num = 1//随便乱搞可以了，因为你可以直接操作地址来控制它
gpio_pin_2 = portH11<1><default><default><1>  #num = 2
gpio_pin_3 = portH11<1><default><default><1>  #num = 3
gpio_pin_4 = portH7<1><default><default><1>   #num = 4
[leds_para]
leds_used = 0  #失能led系统配置，不失能也可以，但是LED在你打开./led_app后会被系统改变状态
leds_num = 4

驱动程序
1.insmod led_drvreg.ko //加载驱动
2../led_app            //同时点亮2个led

在注册设备和卸载驱动解释它的思想：
A. led_init编写顺序：
(1)映设虚拟地址,ioremap
(2)注册结构体，告诉内核leddrv_fops
(3)申请设备类class_create
(4)生成设备节点device_create /dev/ledwht    #ls /dev/ledwht确实在加载驱动时候生成
B. led_exit编写顺序：
(1)卸载结构体unregister_chrdev
(2)删除设备节点device_destroy
(3)删除设备类class_destroy
(4)释放虚拟地址,ioremap

这个顺序就好比如你开电脑之前必须
1.开电源
2.按下电脑开机按钮
3.打开应用程序
-----------------
关闭电脑的顺序是
1.关闭应用程序
2.找到关机界面，确定关机
3.最后才是关闭电源。
是不是很有道理呢！！！







本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x

本帖被以下淘专辑推荐:

  • · 驱动|主题: 1, 订阅: 0
回复

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-13 16:07:16 | 显示全部楼层
本帖最后由 简单侶途　 于 2015-11-13 16:12 编辑

第五个程序目的是控制不同的LED实现方法是利用程序里面申请主设备号：
major = register_chrdev(0, "led", &leddrv_fops);
利用自动分配申请的major主设备号，接着利用major下自我分配利用的次设备号实现匹配同一类的不同minor，系统自动分配完major后，默认分配次设备号minor = 0，接着我们就在minor那里作文章了，minor使用范围是0～255
这个minor就可以让我们识别同一类设备类下的不同led设备节点
下图所示：242为major,242后面的0，1，2就是minor了

1.驱动程序部分：
  1. #include<linux/fs.h>
  2. #include<linux/module.h>
  3. #include<linux/errno.h>
  4. #include<linux/kernel.h>
  5. #include<linux/init.h>
  6. #include<linux/cdev.h>
  7. #include<linux/uaccess.h>
  8. #include<linux/device.h>
  9. #include<linux/types.h>
  10. #include <asm/gpio.h>
  11. #include <linux/gpio.h>
  12. #include <plat/sys_config.h>
  13. #include <linux/delay.h>
  14. #include <asm/irq.h>
  15. #include <asm/io.h>

  17. #include <linux/moduleparam.h>
  18. #include <linux/poll.h>
  19. #include <linux/sched.h>
  20. #include <linux/spinlock.h>
  21. #include <linux/slab.h>
  22. #include <linux/ipmi.h>
  23. #include <linux/mutex.h>
  24. #include <linux/compat.h>


  27. /*两种方法寻找GPIO寄存器地址*/
  28. //#define PIO_BASE   0x01C20800
  29. #define PH_BASE   (PIO_BASE + 7*0x24)

  31. #define PH_CFG2   (PH_BASE + 0x08)
  32. #define PH_DAT    (PH_BASE + 0x10)

  34. //#define PH_BASE  (PIO_BASE + 0xFC)
  35. //#define PH_CFG2  (PIO_BASE + 0x104)
  36. //#define PH_DAT   (PIO_BASE + 0X10C)

  38. static volatile unsigned int *ph_cfg2;
  39. static volatile unsigned int *ph_dat;

  41. //设备类
  42. static struct class *leddrv_class;
  43. //分配 cdev
  44. static struct class_device *leddrv_class_dev[3];
  45. //主设备号
  46. static int major;

  48. static int led_open(struct inode *inode, struct file *file)
  49. {
  50.         /*bit20[18:16],bit21[22:20]
  51.          *open the roange_led and blue_led GPIO output
  52.          *Output is 001
  53.          */

  55.         *ph_cfg2 &= ~((7<<16) | (7<<20));//清零000,这个步骤很重要，注释掉可以看下效果如何blue_led不能控制了
  56.         *ph_cfg2 |= ((1<<16) | (1<<20));//设置001
  57.         return 0;
  58. }


  61. static ssize_t led_write (struct file *file,char __user *buf,
  62.                                                   size_t count,loff_t *f_pos)
  63. {
  64.         int val;
  65.         int minor = MINOR(file->f_dentry->d_inode->i_rdev);

  67.         /*1.从用户空间读取数据到内核空间*/
  68.         copy_from_user(&val,buf,4);

  70.         /*2.判断传入值val，进行GPIO电平控制*/
  71.         switch (minor){
  72.         case 0:        /*/dev/leds*/
  73.         {
  74.                 if(val == 1)
  75.                         *ph_dat |= ((1<<20) | (1<<21));               
  76.                 else
  77.                         *ph_dat &= ~((1<<20) | (1<<21));
  78.         }
  79.         break;
  80.         case 1:/*/dev/led1*/
  81.         {
  82.                 if(val == 1)
  83.             *ph_dat |= (1<<20);
  84.             else
  85.             *ph_dat &= ~(1<<20);
  86.         }
  87.         break;
  88.         case 2: /*/dev/led2*/
  89.         {
  90.                 if(val == 1)
  91.             *ph_dat |=  (1<<21);
  92.         else
  93.             *ph_dat &=  ~(1<<21);
  94.         }
  95.         break;
  96.         }
  97.         return 0;
  98. }

  100. //分配驱动操作
  101. static struct file_operations leddrv_fops = {

  103.         .owner   =    THIS_MODULE,
  104.         .open         =    led_open,
  105.         .write   =    led_write,
  106. };

  108. static int  led_init(void)
  109. {        
  110.         int minor = 0;
  111.         
  112.         ph_cfg2 = ioremap(PH_CFG2, 4);
  113.         ph_dat  = ioremap(PH_DAT, 4);
  114.         
  115.          major = register_chrdev(0, "led", &leddrv_fops);
  116.         leddrv_class = class_create(THIS_MODULE, "led");
  117.         leddrv_class_dev[0] = device_create(leddrv_class, NULL, MKDEV(major, 0), NULL, "led0"); /* /dev/ledwht */
  118.         
  119.         for(minor=1;minor<3;minor ++)
  120.                 leddrv_class_dev[minor] = device_create(leddrv_class, NULL, MKDEV(major, minor), NULL,
  121.         return 0;
  122. }

  124. static void led_exit(void)
  125. {
  126.         int minor;
  127.         
  128.         unregister_chrdev(major,"led");
  129.         /*2.删除设备节点*/
  130.         for(minor = 0; minor<3; minor++)
  131.                 device_destroy(leddrv_class, MKDEV(major, minor));
  132.         class_destroy(leddrv_class);
  133.         iounmap(ph_cfg2);
  134.         iounmap(ph_dat);
  135. }

  137. module_init(led_init);
  138. module_exit(led_exit);
  139. MODULE_LICENSE("GPL");
复制代码
2.应用程序部分：
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>

  6. /*  测试方法
  7. *  /led_test on
  8. *  /led_test off
  9. */

  11. int main(int argc, char *argv[])
  12. {
  13.         int fd;
  14.         int val = 1;
  15.         char* filename;

  17.         if (argc != 3) {
  18.         printf("usage:\n%s </dev/led?> <on|off>\n", argv[0]);
  19.         return 0;
  20.         }
  21.         filename = argv[1];

  23.         fd = open(filename, O_RDWR);
  24.         if (fd < 0) {
  25.          printf("open led failed.\n");
  26.          return 0;
  27.     }  
  28.         if (strcmp(argv[2], "on") == 0) {
  29.         //开灯
  30.                 val = 1;
  31.         }
  32.         else if (strcmp(argv[2], "off") == 0) {
  33.         //关灯
  34.                 val = 0;
  35.         }

  37.         write(fd, &val, 4);
  38.         return 0;
  39. }
复制代码
3.show图ing
操作步骤如下
LED操作显示





本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-9 12:10:34 | 显示全部楼层
本帖最后由 简单侶途　 于 2015-11-9 12:11 编辑

Makefile文件，注意自己编译路径，/work/driver_ct/evm/linux-sunxi
  1. ifneq ($(KERNELRELEASE),)
  2.         obj-m:=led_drv1.o
  3. else
  4.         KERNELDIR:=/work/driver_ct/evm/linux-sunxi
  5.         PWD:=$(shell pwd)
  6. default:
  7.         $(MAKE) ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -C $(KERNELDIR) M=$(PWD) modules
  8. clean:
  9.         rm -rf *.o *.mod.c *.mod.o *.ko .*.cmd modules.order Module.symvers .tmp_versions
  10. endif
复制代码

回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-9 12:11:23 | 显示全部楼层
简单侶途　 发表于 2015-11-9 12:10
Makefile文件，注意自己编译路径，/work/driver_ct/evm/linux-sunxi
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>

  6. /*  测试方法
  7. *  /led_test on
  8. *  /led_test off
  9. */

  11. int main(int argc, char *argv[])
  12. {
  13.         int fd;
  14.         int val = 1;
  15.         int status = 0;
  16.         fd = open("/dev/ledwht", O_RDWR);
  17.         if (fd < 0) {
  18.                 printf("open led failed.\n");
  19.                 return -1;
  20.         }

  22.         if (argc != 2) {
  23.         printf("usage:\n%s <on|off>\n", argv[0]);
  24.         return -1;
  25.         }

  27.         if (strcmp(argv[1], "on") == 0) {
  28.         //开灯
  29.                 val = 1;
  30.         }
  31.         else if (strcmp(argv[1], "off") == 0) {
  32.         //关灯
  33.                 val = 0;
  34.         }

  36.         write(fd, &val, 4);
  37.         return 0;
  38. }
复制代码

回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-9 12:12:31 | 显示全部楼层
  1. APP：
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <stdio.h>

  7. /*  测试方法
  8. *  /led_test on
  9. *  /led_test off
  10. */

  12. int main(int argc, char *argv[])
  13. {
  14.         int fd;
  15.         int val = 1;
  16.         int status = 0;
  17.         fd = open("/dev/ledwht", O_RDWR);
  18.         if (fd < 0) {
  19.                 printf("open led failed.\n");
  20.                 return -1;
  21.         }

  23.         if (argc != 2) {
  24.         printf("usage:\n%s <on|off>\n", argv[0]);
  25.         return -1;
  26.         }

  28.         if (strcmp(argv[1], "on") == 0) {
  29.         //开灯
  30.                 val = 1;
  31.         }
  32.         else if (strcmp(argv[1], "off") == 0) {
  33.         //关灯
  34.                 val = 0;
  35.         }

  37.         write(fd, &val, 4);

  39.         return 0;
  40. }
复制代码

回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-9 12:12:43 | 显示全部楼层
  1. APP：
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <stdio.h>

  7. /*  测试方法
  8. *  /led_test on
  9. *  /led_test off
  10. */

  12. int main(int argc, char *argv[])
  13. {
  14.         int fd;
  15.         int val = 1;
  16.         int status = 0;
  17.         fd = open("/dev/ledwht", O_RDWR);
  18.         if (fd < 0) {
  19.                 printf("open led failed.\n");
  20.                 return -1;
  21.         }

  23.         if (argc != 2) {
  24.         printf("usage:\n%s <on|off>\n", argv[0]);
  25.         return -1;
  26.         }

  28.         if (strcmp(argv[1], "on") == 0) {
  29.         //开灯
  30.                 val = 1;
  31.         }
  32.         else if (strcmp(argv[1], "off") == 0) {
  33.         //关灯
  34.                 val = 0;
  35.         }

  37.         write(fd, &val, 4);

  39.         return 0;
  40. }
复制代码

回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-11 11:32:28 | 显示全部楼层
接帖上的更新另外两种方法操作寄存器来实现控制GPIO
1.使用ioctl函数方便的操作GPIO
首先指出，我前面两个驱动程序只能传入一个参数值
app（val）---->   driver  (copy_from_user)
所以我们只能控制LED的亮灭，要实现先进的选择控制哪一个LED的话最好是传入2个参数值
（1）指定操作哪个LED  （2）点亮还是熄灭
2.关键部分看ioctl函数即可
  1. #include<linux/fs.h>
  2. #include<linux/module.h>
  3. #include<linux/errno.h>
  4. #include<linux/kernel.h>
  5. #include<linux/init.h>
  6. #include<linux/cdev.h>
  7. #include<linux/uaccess.h>
  8. #include<linux/device.h>
  9. #include<linux/types.h>
  10. #include <asm/gpio.h>
  11. #include <linux/gpio.h>
  12. #include <plat/sys_config.h>
  13. #include <linux/delay.h>
  14. #include <asm/irq.h>
  15. #include <asm/io.h>
  16. #include <linux/moduleparam.h>
  17. #include <linux/poll.h>
  18. #include <linux/sched.h>
  19. #include <linux/spinlock.h>
  20. #include <linux/slab.h>
  21. #include <linux/ipmi.h>
  22. #include <linux/mutex.h>
  23. #include <linux/compat.h>
  24. #define PH_BASE   (PIO_BASE + 7*0x24)
  25. #define PH_CFG2   (PH_BASE + 0x08)
  26. #define PH_DAT    (PH_BASE + 0x10)

  28. static volatile unsigned int *ph_cfg2;
  29. static volatile unsigned int *ph_dat;

  31. //设备类
  32. static struct class *leddrv_class;
  33. //分配 cdev
  34. static struct class_device *leddrv_class_dev;
  35. //主设备号
  36. static int major;

  38. static int led_open(struct inode *inode, struct file *file)
  39. {
  40.         /*bit20[18:16],bit21[22:20]
  41.      *open the roange_led and blue_led GPIO output
  42.      *Output is 001
  43.      */
  44.      *ph_cfg2 &= ~((7<<16) | (7<<20));//清零000,这个步骤很重要，注释掉可以看>    下效果如何blue_led不能控制了
  45.      *ph_cfg2 |= ((1<<16) | (1<<20));//设置001
  46.      return 0;
  47. }

  49. static long leds_ioctl(struct file *filp,
  50.                        unsigned int cmd,unsigned long arg)
  51. {
  52.   
  53.      switch(cmd){
  54.      case 1:
  55.             if(arg == 'a')
  56.               *ph_dat |= (1<<20);
  57.             else if(arg == 'b')
  58.               *ph_dat |= (1<<21);
  59.                  break;
  60.      case 0:
  61.             if(arg == 'a')
  62.               *ph_dat &= ~(1<<20);
  63.             else if(arg == 'b')
  64.               *ph_dat &= ~(1<<21);
  65.             break;
  66.      default:
  67.             break;
  68.     }
  69.     return 0;
  70. }

  72. static struct file_operations leddrv_fops = {
  73. //分配驱动操作

  75.         .owner   =    THIS_MODULE,
  76.         .open         =    led_open,
  77.         .unlocked_ioctl   =  leds_ioctl,
  78. };

  80. static int  led_init(void)
  81. {
  82.         ph_cfg2 = ioremap(PH_CFG2, 4);
  83.         ph_dat  = ioremap(PH_DAT, 4);
  84.        
  85.         major = register_chrdev(0, "led", &leddrv_fops);
  86.         leddrv_class = class_create(THIS_MODULE, "led");
  87.         leddrv_class_dev = device_create(leddrv_class, NULL, MKDEV(major, 0), NULL, "ledwht"); /* /dev/ledwht */
  88.         return 0;
  89. }

  91. static void led_exit(void)
  92. {
  93.         unregister_chrdev(major, "led");
  94.         /*2.删除设备节点*/
  95.         device_destroy(leddrv_class, MKDEV(major, 0));
  96.         class_destroy(leddrv_class);
  97.         iounmap(ph_cfg2);
  98.         iounmap(ph_dat);
  99. }
  100. module_init(led_init);
  101. module_exit(led_exit);
  102. MODULE_LICENSE("GPL");
复制代码
3.应用程序也是重点看ioctl函数
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>

  6. int main(int argc, char *argv[])
  7. {
  8.         int  fd;
  9.         unsigned int  cmd = 1;
  10.         char val = 'z';
  11.         fd = open("/dev/ledwht", O_RDWR);
  12.         if (fd < 0) {
  13.                 printf("open led failed.\n");
  14.                 return -1;
  15.         }

  17.         if (argc != 3) {
  18.         printf("usage:\n%s <led1|led2> <on|off>\n", argv[0]);
  19.         return -1;
  20.         }

  22.         if (strcmp(argv[2], "on") == 0) {
  23.         //开灯
  24.                 cmd = 1;
  25.         }
  26.         else if (strcmp(argv[2], "off") == 0) {
  27.         //关灯
  28.                 cmd = 0;
  29.         }
  30.         if(strcmp(argv[1],"led1") == 0)
  31.                 val = 'a';
  32.     else if(strcmp(argv[1],"led2") == 0)
  33.                 val = 'b';
  34.         ioctl(fd,cmd,val);
  35. //        write(fd, &val, 4);
  36.         return 0;
  37. }
复制代码

回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-11 12:07:35 | 显示全部楼层
首先指出平台总线驱动的方法和以上方法差别有点大，不过重点差别还是比较明显，如果前面看懂了，这个程序估计不难{:soso_e100:}
1.学习参考资料，可以粗略参考
http://blog.csdn.net/lwj103862095/article/details/17842437 //讲述大体驱动框架
http://bbs.ednchina.com/BLOG_ARTICLE_3008325.HTM      //platform_get_resource难点理解，很有必要看看具体细节
a.平台设备程序
  1. #include <linux/module.h>  
  2. #include <linux/version.h>      
  3. #include <linux/init.h>        
  4. #include <linux/kernel.h>  
  5. #include <linux/types.h>  
  6. #include <linux/interrupt.h>  
  7. #include <linux/list.h>  
  8. #include <linux/timer.h>  
  9. #include <linux/init.h>  
  10. #include <linux/serial_core.h>  
  11. #include <linux/platform_device.h>  

  13. #include<linux/uaccess.h>
  14. #include<linux/device.h>
  15. #include <asm/gpio.h>
  16. #include <linux/gpio.h>
  17. #include <plat/sys_config.h>
  18. #include <asm/io.h>
  19. #include <linux/moduleparam.h>
  20. #include <linux/sched.h>

  22. #define PH_BASE   (PIO_BASE + 7*0x24)
  23. #define PH_CFG2   (PH_BASE + 0x08)
  24. #define PH_DAT    (PH_BASE + 0x10)

  26.       
  27. static struct resource led_resources[] = {  
  28.         [0] = {  
  29.             .start  = PH_CFG2,              /*起始地址*/  
  30.             .end    = PH_CFG2 + 4 - 1,      
  31.             .flags  = IORESOURCE_MEM,  
  32.         },  
  33.                 [1] = {  
  34.                 .start  = 5,                        /* LED-blue*/  
  35.                 .end    = 5,  
  36.                 .flags  = IORESOURCE_IRQ,  
  37.     },  
  38. };  
  39.       
  40. static void led_release(struct device * dev)  
  41. {  
  42. }  
  43.               
  44. static struct platform_device led_device = {  
  45.         .id             =  -1,  
  46.         .name           =  "ledwht",  /* 与led_driver的name一致 */  
  47.         .resource       =  led_resources,  
  48.         .num_resources  =  ARRAY_SIZE(led_resources),  
  49.         .dev            =  {  
  50.         .release        =  led_release,  
  51.         },  
  52. };  
  53.       
  54.     /* 分配/设置/注册一个platform_device */  
  55. static int led_dev_init(void)  
  56. {  
  57.         return platform_device_register(&led_device);  
  58. }  
  59.       
  60. static void led_dev_exit(void)  
  61. {  
  62.         platform_device_unregister(&led_device);  
  63. }  
  64.       
  65. module_init(led_dev_init);  
  66. module_exit(led_dev_exit);  
  67.       
  68. MODULE_LICENSE("GPL");  
复制代码
b.平台驱动程序
  1. #include <linux/module.h>  
  2. #include <linux/init.h>  
  3. #include <linux/fs.h>  
  4. #include <linux/interrupt.h>  
  5. #include <linux/irq.h>  
  6. #include <linux/sched.h>  
  7. #include <linux/pm.h>  
  8. #include <linux/sysctl.h>  
  9. #include <linux/proc_fs.h>  
  10. #include <linux/delay.h>  
  11. #include <linux/platform_device.h>  
  12. #include <linux/input.h>  
  13. #include <linux/gpio_keys.h>  
  14. #include <asm/uaccess.h>   // copy_from_user  
  15. #include <asm/io.h>  // ioremap

  17. static struct class *leds_class;  

  19. static volatile unsigned int *ph_cfg2;
  20. static volatile unsigned int *ph_dat;
  21. static int led_pin;  //定义点亮某一个灯的引脚

  23. static int major;

  25. static int led_open(struct inode * inode, struct file * filp)
  26. {
  27.          /*bit20[18:16],bit21[22:20]
  28.           *open the roange_led and blue_led GPIO output
  29.           *Output is 001
  30.           */
  31.         //*ph_cfg2 &= ~((7<<16) | (7<<20));
  32.         *ph_cfg2 &= ~(7<<led_pin*4);//清零000,这个步骤很重要，注释掉可以看下效果如何blue_led不能控制了

  34.         *ph_cfg2 |= ((1<<led_pin*4));//设置001
  35.        
  36.         return 0;
  37. }

  39. static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
  40. {
  41.         int val;
  42.         copy_from_user(&val, buf, count);
  43.         if(val == 1)
  44.         {
  45.                 /* 点灯 */
  46.                 *ph_dat |= (1<<(led_pin+16));       
  47.         }
  48.         else
  49.         {
  50.                 /* 灭灯 */
  51.                 *ph_dat &= ~(1<<(led_pin+16));
  52.         }
  53.         return 0;
  54. }

  56. /* File operations struct for character device */
  57. static const struct file_operations led_fops = {
  58.         .owner                = THIS_MODULE,
  59.         .open                = led_open,
  60.         .write      = led_write,
  61. };

  63. static int __devinit led_probe(struct platform_device *pdev)
  64. {
  65.         struct resource *res;  
  66.       
  67.     /* 根据platform_device的资源进行ioremap */  
  68.     res     = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
  69.     ph_cfg2 = ioremap(res->start, res->end - res->start + 1);  
  70.     ph_dat  = ph_cfg2 + 2;  
  71.   
  72.         res     = platform_get_resource(pdev, IORESOURCE_IRQ, 0);  
  73.     led_pin =  res->start;
  74.        
  75.         /* 注册字符设备 */
  76.         major   = register_chrdev(0, "ledwht", &led_fops);
  77.         /*申请一个设备类*/
  78.         leds_class = class_create(THIS_MODULE,"ledwht");
  79.         /*申请设备节点*/
  80.         device_create(leds_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led*/
  81.         return 0;
  82. }
  83. static int __devexit led_remove(struct platform_device *pdev)
  84. {
  85.         /*释放设备节点，卸载类*/
  86.         device_destroy(leds_class, MKDEV(major, 0));
  87.         class_destroy(leds_class);
  88.     /*卸载字符设备*/
  89.         unregister_chrdev(major, "ledwht");
  90.         iounmap(ph_cfg2);  
  91.         return 0;
  92. }

  94. static struct platform_driver leds_driver = {
  95.         .probe                =         led_probe,
  96.         .remove                =         led_remove,
  97.         .driver                =         {
  98.         .name                =          "ledwht",
  99.         .owner                =         THIS_MODULE,
  100.         }
  101. };

  103. /* 分配/设置/注册一个platform_driver */
  104. static int led_drv_init(void)
  105. {
  106.         return platform_driver_register(&leds_driver);
  107. }

  109. static void led_drv_exit(void)
  110. {
  111.         platform_driver_unregister(&leds_driver);
  112. }

  114. module_init(led_drv_init);
  115. module_exit(led_drv_exit);

  117. MODULE_LICENSE("GPL");
  118. MODULE_AUTHOR("wht");
复制代码
c.应用程序直接可以自己写了吧，可以直接套用前两个程序的APP

2.平台总线重点讲解部分：
写代码之前，必须看清楚寄存器地址的规律，编程需要用到。



（1）首先说明平台总线目的是把控制的设备和驱动程序分离的思想，你要控制哪一个设备的时候，就可以直接修改设备总线程序的设备号就可以简单地切换到控制其他设备了。
（2） #define PH_CFG2      (PH_BASE + 0x08)
         #define PH_CFG3    (PH_BASE + 0x0C)     //解释的需要，添加的，程序里面没有
         #define PH_DAT         (PH_BASE + 0x10)

    static struct resource led_resources[] = {  
           【0] = {  
                 .start  = PH_CFG2,              /*起始地址*/  
                 .end    = PH_CFG2 + 4 - 1,         //为啥是4-1？，地址是从0开始的，0～3就为4byte   所以4-1=3
                                                   由PH_CFG3-PH_CFG2可以看出PH_CFG2占用地址范围为0x0C -0x08 = 0x04
                .flags  = IORESOURCE_MEM,//表示IO资源  
           },  
                    [1] = {  
                   .start  = 5,                        /* led-blue*/  /* 点亮led_orange的话，改为4即可*/
                    .end    = 5,  
                   .flags  = IORESOURCE_IRQ,   ///表示类似设备号吧，我觉得而已
       },  
};
(3)再看这部分，两个都是相辅相成的
static int __devinit led_probe(struct platform_device *pdev)
{
        struct resource *res;  
      
    /* 根据platform_device的资源进行ioremap */  
    res     = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
    ph_cfg2 = ioremap(res->start, res->end - res->start + 1);
                  //映射范围：start~~~~end - start+1;为啥+1，我也不太懂
    ph_dat  = ph_cfg2 + 2;  
                //这里注意了，为啥是2呢？ph_dat和ph_cfg2之间隔了一个ph_cfg3对吧？
               //那好办了，只要你懂得指针指向另外偏移地址的方法的话，你可以知道，
               ph_cfg2+1=>ph_cfg3  ph_cfg3+1=>ph_dat
  
        res     = platform_get_resource(pdev, IORESOURCE_IRQ, 0);  
    led_pin =  res->start;
       
        /* 注册字符设备 */
        major   = register_chrdev(0, "ledwht", &led_fops);
        /*申请一个设备类*/
        leds_class = class_create(THIS_MODULE,"ledwht");
        /*申请设备节点*/
        device_create(leds_class, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led*/
        return 0;
}


本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复 支持 反对

使用道具 举报

yulin
发表于 2015-11-11 12:58:58 | 显示全部楼层
韦东山的视屏能分享下么    如果不能就算了
回复 支持 反对

使用道具 举报

简单侶途　
 楼主| 发表于 2015-11-11 14:44:09 | 显示全部楼层
yulin 发表于 2015-11-11 12:58
韦东山的视屏能分享下么    如果不能就算了

可以啊，不过只能看第一期的，二三期还是要买一下吧！最后面几个视频才是开始讲驱动的
https://100ask.taobao.com/p/rd97 ... p;scene=taobao_shop
回复 支持 反对

使用道具 举报

满月
发表于 2015-11-11 20:32:23 | 显示全部楼层
666666 有深度！
回复 支持 反对

使用道具 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|粤ICP备13051116号|cubie.cc---深刻的嵌入式技术讨论社区

GMT+8, 2024-11-23 00:22 , Processed in 0.034211 second(s), 20 queries .

Powered by Discuz! X3.4

© 2001-2012 Comsenz Inc. | Style by Coxxs

返回顶部