Chinaunix首页 | 论坛 | 博客

无与伦比

首页　| 　博文目录　| 　关于我

yshisx

  • 博客访问： 385296
  • 博文数量： 96
  • 博客积分： 647
  • 博客等级： 上士
  • 技术积分： 490
  • 用 户 组： 普通用户
  • 注册时间： 2012-09-29 22:15
文章分类

全部博文（96）

文章存档

2015年（1）

2014年（10）

2013年（26）

2012年（59）

我的朋友
最近访客
推荐博文
相关博文
<总线设备模型>和<输入子系统>学习实践

分类： LINUX

2013-05-21 23:05:36

原文地址：<总线设备模型>和<输入子系统>学习实践 作者：gfvvz

实验平台：Tiny6410 + Linux Kernel 2.6.38

本问主要实践下总线设备驱动模型和输入子系统。功能上实现四个按键（"l"、"s"、"Enter"、"Shift"）控制下的LED等点亮和熄灭，并通过输入子系统向用户空间上报按键信息。用户空间程序打印按键信息。驱动测试可以参考USB那份总结。

点击(此处)折叠或打开

  1. //平台驱动：platform_driver

  3.   
  4. #include <linux/module.h>
  5. #include <linux/kernel.h>
  6. #include <linux/init.h>
  7. #include <linux/fs.h>
  8. #include <linux/errno.h>
  9. #include <linux/cdev.h>
  10. #include <linux/types.h>
  11. #include <linux/device.h>
  12. #include <linux/mm.h>
  13. #include <linux/slab.h>
  14. #include <linux/sched.h>
  15. #include <linux/poll.h>
  16. #include <linux/ioctl.h>
  17. #include <linux/input.h>
  18. #include <linux/semaphore.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/irq.h>
  22. #include <linux/compiler.h>
  23. #include <asm/uaccess.h>
  24. #include <asm/irq.h>
  25. #include <asm/io.h>
  26. #include <asm/system.h>
  27. #include <mach/map.h>
  28. #include <mach/regs-gpio.h>
  29. #include <mach/gpio-bank-k.h>
  30. #include <mach/gpio-bank-n.h>
  31. #include <asm-generic/errno-base.h>

  33.   
  34. static struct timer_list button_control_leds_timer;
  35. static struct input_dev *button_control_leds_dev;
  36. static int led_tmp;
  37. static int button_control_leds_open(struct input_dev *dev)
  38. {
  39.     //all the leds went out
  40.     led_tmp = readl(S3C64XX_GPKDAT);
  41.     led_tmp |= 0x000000f0;
  42.     writel(led_tmp, S3C64XX_GPKDAT);

  44.   
  45.     return 0;
  46. }
  47. static void button_control_leds_close(struct input_dev *dev)
  48. {
  49.     //all the leds went out
  50.     led_tmp = readl(S3C64XX_GPKDAT);
  51.     led_tmp |= 0x000000f0;
  52.     writel(led_tmp, S3C64XX_GPKDAT);
  53. }
  54.  

  56.  
  57. //4. 定时器中断处理函数 static void button_control_leds_timer_function(unsigned long data)
  58. {
  59.     int button_value, invalid_keys;
  60.     /* GPN[3:0] is connected to buttons */
  61.  //4.1 读取按键值并上报给用户空间
  62.     button_value = readl(S3C64XX_GPNDAT) & 0x0000000f;
  63.     switch(~button_value & 0x0000000f) {
  64.         case 0x00000001: //key "l"
  65.             input_event(button_control_leds_dev, EV_KEY, KEY_L, 1);
  66.         break;
  67.         case 0x00000002: //key "s"
  68.             input_event(button_control_leds_dev, EV_KEY, KEY_S, 1);
  69.         break;
  70.         case 0x00000004: //key "Enter"
  71.             input_event(button_control_leds_dev, EV_KEY, KEY_ENTER, 1);
  72.         break;
  73.         case 0x00000009: //key "SHIFT" + key "l"
  74.             input_event(button_control_leds_dev, EV_KEY, KEY_LEFTSHIFT, 1);
  75.             input_event(button_control_leds_dev, EV_KEY, KEY_L, 1);
  76.         break;
  77.         case 0x0000000a: //key "SHIFT" + key "s"
  78.             input_event(button_control_leds_dev, EV_KEY, KEY_LEFTSHIFT, 1);
  79.             input_event(button_control_leds_dev, EV_KEY, KEY_S, 1);
  80.         break;
  81.         case 0x00000000: //no key is pressed
  82.             input_event(button_control_leds_dev, EV_KEY, KEY_L, 0);
  83.             input_event(button_control_leds_dev, EV_KEY, KEY_S, 0);
  84.             input_event(button_control_leds_dev, EV_KEY, KEY_ENTER, 0);
  85.             input_event(button_control_leds_dev, EV_KEY, KEY_LEFTSHIFT, 0);
  86.         break;
  87.         default: //invalid keys
  88.             invalid_keys = 1;
  89.         break;
  90.     }
  91.  //如果按键有效，就上报给用户空间
  92.     if(!invalid_keys)
  93.         input_sync(button_control_leds_dev);
  94.     else
  95.         invalid_keys = 0;
  96.  

  98.  
  99.     /* GPK[7:4] is connected to LEDs */
  100. //4.2 根据按键值，点亮相应的LED灯
  101.     led_tmp = readl(S3C64XX_GPKDAT);
  102.     switch(button_value) {
  103.         case 0x0000000e: //light led1
  104.             led_tmp |= 0x000000f0;
  105.             led_tmp &= 0xffffffef;
  106.         break;
  107.         case 0x0000000d: //light led2
  108.             led_tmp |= 0x000000f0;
  109.             led_tmp &= 0xffffffdf;
  110.         break;
  111.         case 0x0000000b: //light led3
  112.             led_tmp |= 0x000000f0;
  113.             led_tmp &= 0xffffffbf;
  114.         break;
  115.         case 0x00000007: //light led4
  116.             led_tmp |= 0x000000f0;
  117.             led_tmp &= 0xffffff7f;
  118.         break;
  119.         case 0x0000000f: //all the leds went out
  120.             led_tmp |= 0x000000f0;
  121.         break;
  122.         default: //light all the leds
  123.             led_tmp &= 0xffffff0f;
  124.         break;
  125.     }
  126.     writel(led_tmp, S3C64XX_GPKDAT);
  127. }
  128.  
  129.  //3. 按键中断处理函数
  130. static irqreturn_t button_control_leds_irq(int irq, void *dev_id)
  131. {
  132.     //3.1 修改定时器，10ms延时，防止按键抖动引起的多次处理
  133. mod_timer(&button_control_leds_timer, jiffies + HZ/100);

  135.   
  136.     return IRQ_RETVAL(IRQ_HANDLED);
  137. }

  139.  
  140. //2. 当设备和驱动匹配时，probe函数会被调用 static int button_control_leds_probe(struct platform_device *pdev)
  141. {
  142.     struct resource *res;
  143.     int ret, i, j;
  144.  
  145.   //2.1 输入子系统input_dev结构体的分配、设置和注册
  146.  //2.1.1 分配一个input_dev
  147.     button_control_leds_dev = input_allocate_device();
  148.  
  149.  //2.1.2 设置input_dev参数
  150.     set_bit(EV_KEY, button_control_leds_dev->evbit); //按键类型
  151.     set_bit(EV_REP, button_control_leds_dev->evbit); //支持重复按键
  152.     set_bit(KEY_L, button_control_leds_dev->keybit); //按键“l”
  153.     set_bit(KEY_S, button_control_leds_dev->keybit); //按键“s”
  154.     set_bit(KEY_ENTER, button_control_leds_dev->keybit); //按键“Enter”
  155.     set_bit(KEY_LEFTSHIFT, button_control_leds_dev->keybit); //按键“Shift”
  156.     button_control_leds_dev->open = button_control_leds_open; //open函数
  157.     button_control_leds_dev->close = button_control_leds_close; //close函数
  158.  //2.1.3 注册一个input_dev结构体
  159.     ret = input_register_device(button_control_leds_dev);
  160.     if(unlikely(ret))
  161.         goto fail1;

  163.  
  164. //2.2 定时器初始化、设置定时器中断处理函数、添加一个定时器
  165.     init_timer(&button_control_leds_timer);
  166.     button_control_leds_timer.function = button_control_leds_timer_function;
  167.     add_timer(&button_control_leds_timer);
  168.  
  169.  //2.3 获取平台设备资源、注册按键中断
  170.     for(i = 0; i < pdev->num_resources; i++) {
  171.  //2.3.1 获取平台设备资源：中断获取
  172.         res = platform_get_resource(pdev, IORESOURCE_IRQ, i);
  173.         if(unlikely(res == NULL)) {
  174.             printk("Button %d: get platform resource failed!\n", i);
  175.             goto fail2;
  176.         }
  177.  //2.3.2 注册按键中断
  178.         ret = request_irq(res->start, button_control_leds_irq, \
  179.                 IRQ_TYPE_EDGE_BOTH, res->name, pdev);
  180.         if(unlikely(ret != 0)) {
  181.             printk("Button %d: request_irq failed\n", i);
  182.             goto fail3;
  183.         }
  184.     }
  185.     return 0;
  186. fail1:
  187.     input_unregister_device(button_control_leds_dev);
  188.     input_free_device(button_control_leds_dev);
  189.     return ret;

  191.   
  192. fail2:
  193.     del_timer(&button_control_leds_timer);
  194.     input_unregister_device(button_control_leds_dev);
  195.     input_free_device(button_control_leds_dev);
  196.     return -ENXIO;
  197.  
  198. fail3:
  199.     for(j = 0; j <= i; j++) {
  200.         res = platform_get_resource(pdev, IORESOURCE_IRQ, i);
  201.         free_irq(res->start, pdev);
  202.     }
  203.     del_timer(&button_control_leds_timer);
  204.     input_unregister_device(button_control_leds_dev);
  205.     input_free_device(button_control_leds_dev);
  206.     return ret;
  207. }
  208.  
  209. static int button_control_leds_remove(struct platform_device *pdev)
  210. {
  211.     struct resource *res;
  212.     int i;

  214.   
  215.     for(i = 0; i < pdev->num_resources; i++) {
  216.         res = platform_get_resource(pdev, IORESOURCE_IRQ, i);
  217.         free_irq(res->start, pdev);
  218.     }
  219.     del_timer(&button_control_leds_timer);
  220.     input_unregister_device(button_control_leds_dev);
  221.     input_free_device(button_control_leds_dev);
  222.  

  224.  
  225.     return 0;
  226. }
  227.  

  229.   
  230.  //1. 平台总线platform_driver结构体及其注册
  231. struct platform_driver button_control_leds_drv = {
  232.     .probe = button_control_leds_probe,
  233.     .remove = button_control_leds_remove,
  234.     .driver = {
  235.         .name = "button_control_leds",
  236.         .owner = THIS_MODULE,
  237.     }
  238. };
  239.  
  240. static int __init button_control_leds_init(void)
  241. {
  242.     platform_driver_register(&button_control_leds_drv);
  243.     return 0;
  244. }
  245.  
  246. static void __exit button_control_leds_exit(void)
  247. {
  248.     platform_driver_unregister(&button_control_leds_drv);
  249. }
  250. module_init(button_control_leds_init);
  251. module_exit(button_control_leds_exit);
  252. MODULE_AUTHOR("Jason Lu");
  253. MODULE_VERSION("0.1.0");
  254. MODULE_DESCRIPTION("Jason's blog: jason2012.blog.chinaunix.net");
  255. MODULE_LICENSE("Dual MPL/GPL");
  256. MODULE_ALIAS("Driver of button control leds");

  1. //平台设备：platform_device

  3. #include <linux/module.h>
  4. #include <linux/version.h>
  5. #include <linux/init.h>
  6. #include <linux/kernel.h>
  7. #include <linux/types.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/list.h>
  10. #include <linux/timer.h>
  11. #include <linux/serial_core.h>
  12. #include <linux/platform_device.h>
  13. #include <mach/gpio.h>
  14. #include <mach/irqs.h>

 //1. 平台设备资源
  1. static struct resource button_control_leds_resource[] = {
  2.     [0] = {
  3.         .name    = "button 1",
  4.         .start    = IRQ_EINT(0),
  5.         .end        = IRQ_EINT(0),
  6.         .flags    = IORESOURCE_IRQ,
  7.     },
  8.     [1] = {
  9.         .name    = "button 2",
  10.         .start    = IRQ_EINT(1),
  11.         .end        = IRQ_EINT(1),
  12.         .flags    = IORESOURCE_IRQ,
  13.     },
  14.     [2] = {
  15.         .name    = "button 3",
  16.         .start    = IRQ_EINT(2),
  17.         .end        = IRQ_EINT(2),
  18.         .flags    = IORESOURCE_IRQ,
  19.     },
  20.     [3] = {
  21.         .name    = "button 4",
  22.         .start    = IRQ_EINT(3),
  23.         .end        = IRQ_EINT(3),
  24.         .flags    = IORESOURCE_IRQ,
  25.     },
  26. };

  28. static void button_control_leds_release(struct device * dev)
  29. {
  30. }

 //平台设备platform_device结构体
  1. static struct platform_device button_control_leds_dev = {
  2.     .name            = "button_control_leds",
  3.     .id                = -1,
  4.     .num_resources    = ARRAY_SIZE(button_control_leds_resource),
  5.     .resource            = button_control_leds_resource,
  6.     .dev = {
  7.             .release = button_control_leds_release,
  8.     },
  9. };
 //3. 注册一个平台设备
  1. static int button_control_leds_dev_init(void)
  2. {
  3.     platform_device_register(&button_control_leds_dev);
  4.     return 0;
  5. }

  7. static void button_control_leds_dev_exit(void)
  8. {
  9.     platform_device_unregister(&button_control_leds_dev);
  10. }

  12. module_init(button_control_leds_dev_init);
  13. module_exit(button_control_leds_dev_exit);

  15. MODULE_AUTHOR("Jason Lu");
  16. MODULE_VERSION("0.1.0");
  17. MODULE_DESCRIPTION("Jason's blog: jason2012.blog.chinaunix.net");
  18. MODULE_LICENSE("Dual MPL/GPL");
  19. MODULE_ALIAS("Device of button control leds");

  1. //用户空间程序

  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <sys/ioctl.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10. #include <sys/select.h>
  11. #include <sys/time.h>
  12. #include <errno.h>
  13. #include <linux/input.h>
  14. #include <string.h>

  16. /*
  17.  * The event structure itself
  18.  * struct input_event {
  19.  *     struct timeval time;
  20.  *    __u16 type;
  21.  *    __u16 code;
  22.  *    __s32 value;
  23.  * };
  24.  *
  25. */
  26. static int shift_flag; //shift键按下标志

  28. char * button_show(int code, int value);

  30. int main(int argc, char *argv[])
  31. {
  32.     int buttons_fd;
  33.     int count, i = 0;
  34.     char *a;
     //1. 定义一个input_event结构体
  1.     struct input_event ev_key;
     //2. 打开设备节点
  1.     buttons_fd = open("/dev/input/event1", O_RDWR);
  2.     if (buttons_fd < 0) {
  3.         perror("open device buttons");
  4.         exit(1);
  5.     }

  7.     for (;;) {
  8. //3. 读取按键信息到input_event结构体
  9.         count = read(buttons_fd, &ev_key, sizeof(struct input_event));

  11.         for(i=0; i<(int)count/sizeof(struct input_event); i++)
  12.     //4. 判断是否是按键类型
  13.             if(EV_KEY == ev_key.type) {
  14. //5. 打印按键信息
  15.                 a = button_show(ev_key.code, ev_key.value);
  16.                 printf("%s", a);
  17.             }
  18.     }    

  20.     close(buttons_fd);
  21.     return 0;
  22. }

  24. char * button_show(int code, int value)
  25. {
  26.     char *a;

  28.     if(value == 1) { //1. 按键按下
  29.         switch(code) {
  30.             case KEY_L:
  31.                 if(shift_flag)
  32.                     a = "Press the button \"L\"\n";
  33.                 else
  34.                     a = "Press the button \"l\"\n";
  35.             break;
  36.             case KEY_S:
  37.                 if(shift_flag)
  38.                     a = "Press the button \"S\"\n";
  39.                 else
  40.                     a = "Press the button \"s\"\n";
  41.             break;
  42.             case KEY_ENTER:
  43.                 a = "Press the button \"Enter\"\n";
  44.             break;
  45.             case KEY_LEFTSHIFT:
  46.                 shift_flag = 1;
  47.                 a = "Press the button \"LEFTSHIFT\"\n";
  48.             break;
  49.             default:
  50.                 a = "Unable to identify the key pressed!\n";
  51.             break;
  52.         }
  53.     }
  54.     else if(value == 2) //2. 重复按键
  55.         a = "Press the button repeatedly!\n";
  56.     else { //3. 按键松开
  57.         switch(code) {
  58.             case KEY_L:
  59.                 if(shift_flag)
  60.                     a = "Release the button \"L\"\n";
  61.                 else
  62.                     a = "Release the button \"l\"\n";
  63.                 break;
  64.             case KEY_S:
  65.                 if(shift_flag)
  66.                     a = "Release the button \"S\"\n";
  67.                 else
  68.                     a = "Release the button \"s\"\n";
  69.             break;
  70.             case KEY_ENTER:
  71.                 a = "Release the button \"Enter\"\n";
  72.             break;
  73.             case KEY_LEFTSHIFT:
  74.                 shift_flag = 0;
  75.                 a = "Release the button \"LEFTSHIFT\"\n";
  76.             break;
  77.             default:
  78.                 a = "Unable to identify the key released!\n";
  79.             break;
  80.         }
  81.     }

  83.     return a;
  84. }





阅读(2079) | 评论(0) | 转发(0) |
0

上一篇：Linux内核中出现的C语言细节汇总（不断更新）

下一篇：Linux内核动态调试信息的打开pr_debug（基于按键驱动，全过程记录）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6