Chinaunix首页 | 论坛 | 博客

...transistor.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

transistor0

  • 博客访问： 1576661
  • 博文数量： 239
  • 博客积分： 1760
  • 博客等级： 上尉
  • 技术积分： 1595
  • 用 户 组： 普通用户
  • 注册时间： 2011-01-08 23:53
文章分类

全部博文（239）

文章存档

2016年（1）

2015年（28）

2014年（53）

2013年（42）

2012年（50）

2011年（65）

我的朋友
最近访客
推荐博文
相关博文
linux input子系统键盘驱动实现

分类： LINUX

2012-04-02 02:28:40

问: 为何要基于input子系统??
答: 因为linux下所有GUI都可以接收input子系统的消息。写基于GUI的程序时可以用GUI实现的按键机制,而不是单片机的思维，一个死循环来处理用户输入。

不扯淡了，一切尽在源码中！

硬件平台: s3c2440
软件平台: linux-3.1.6 + qt-4.7.4

此驱动源码以GPL协议开放.

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/interrupt.h>
  4. #include <linux/platform_device.h>
  5. #include <linux/input.h>
  6. #include <linux/slab.h>

  8. #include <mach/regs-gpio.h>
  9. #include <linux/gpio.h>
  10. #include <linux/irq.h>


  13. #define DHOLE2440_KBD "dhole2440kbd"
  14. #define DHOLE2440_KBD_IRQ_NUM (6)
  15. #define KBD_NONE (0xff)

  17. #define KBD_UP (0)
  18. #define KBD_DOWN (1)

  20. typedef struct _dhole2440_key{
  21.     unsigned int gpio;/*对应gpio口*/
  22.     unsigned int irq;/*对应中断*/
  23.     int n_key;/*键值*/
  24. }dhole2440_key;

  26. struct dhole2440_kbd{
  27.     dhole2440_key keys[DHOLE2440_KBD_IRQ_NUM];
  28.     struct timer_list key_timer; /*按键去抖定时器*/
  29.     unsigned int key_status; /*按键状态*/
  30.     struct input_dev *input;
  31. };

  33. struct dhole2440_kbd *p_dhole2440_kbd;


  36. struct dhole2440_kbd *get_kbd(void)
  37. {
  38.     printk("get_kbd p_dhole2440_kbd=%x\n", (unsigned int)p_dhole2440_kbd);
  39.     return p_dhole2440_kbd;
  40. }

  42. void set_kbd(struct dhole2440_kbd *p_kbd)
  43. {
  44.     p_dhole2440_kbd = p_kbd;

  46.     printk("set_kbd p_kbd=%x, p_dhole2440_kbd=%x\n",
  47.         (unsigned int)p_kbd, (unsigned int)p_dhole2440_kbd);
  48. }

  50. static irqreturn_t dhole2440_kbd_handler(int irq, void *p_date)
  51. {
  52.     unsigned int n_key = 0;
  53.     struct dhole2440_kbd *p_kbd = p_date;
  54.     unsigned int key_state = 0;
  55.     int i;

  57.     for(i = 0; i < DHOLE2440_KBD_IRQ_NUM; i++)
  58.     {
  59.         if( irq == p_kbd->keys[i].irq )
  60.         {
  61.             key_state = s3c2410_gpio_getpin(p_kbd->keys[i].gpio);
  62.             n_key = p_kbd->keys[i].n_key;
  63.             break;
  64.         }
  65.     }

  67.     printk("dhole2440_kbd_handler n_key=%d, key_state=%d\n", n_key, key_state);

  69.     input_report_key(p_kbd->input, n_key, !key_state);/*1表示按下*/
  70.     input_sync(p_kbd->input);

  72.     return IRQ_HANDLED;
  73. }


  76. static void kbd_free_irqs(void)
  77. {
  78.     struct dhole2440_kbd *p_kbd = get_kbd();
  79.     int i;

  81.     printk("kbd_free_irqs p_kbd=%x\n", (unsigned int)p_kbd);
  82.    
  83.     for(i = 0; i < DHOLE2440_KBD_IRQ_NUM; i++)
  84.         free_irq(p_kbd->keys[i].irq, p_kbd);
  85. }

  87. static int kbd_req_irqs(void)
  88. {
  89.     int n_ret;
  90.     int i;
  91.     struct dhole2440_kbd *p_kbd = get_kbd();

  93.     printk("kbd_req_irqs p_kbd=%x\n", (unsigned int)p_kbd);

  95.     for(i = 0; i < DHOLE2440_KBD_IRQ_NUM; i++)
  96.     {
  97.         n_ret = request_irq(p_kbd->keys[i].irq, dhole2440_kbd_handler, IRQ_TYPE_EDGE_BOTH, DHOLE2440_KBD, p_kbd);
  98.         if(n_ret)
  99.         {
  100.             printk("%d: could not register interrupt\n", p_kbd->keys[i].irq);
  101.             goto fail;
  102.         }
  103.     }

  105.     return n_ret;

  107. fail:
  108.     /*因为上面申请失败的那个没有成功,所以也不要释放*/
  109.     for(i--; i >= 0; i--)
  110.     {
  111.         disable_irq(p_kbd->keys[i].irq);
  112.         free_irq(p_kbd->keys[i].irq, p_kbd);
  113.     }

  115.     return n_ret;
  116. }

  118. static void dhole2440_init_kbd_data(struct dhole2440_kbd *p_kbd)
  119. {
  120.     printk("dhole2440_init_kbd_data p_kbd=%x\n", (unsigned int)p_kbd);

  122.     p_kbd->keys[0].gpio = S3C2410_GPG(11);
  123.     p_kbd->keys[1].gpio = S3C2410_GPG(7);
  124.     p_kbd->keys[2].gpio = S3C2410_GPG(6);
  125.     p_kbd->keys[3].gpio = S3C2410_GPG(5);
  126.     p_kbd->keys[4].gpio = S3C2410_GPG(3);
  127.     p_kbd->keys[5].gpio = S3C2410_GPG(0);

  129.     p_kbd->keys[0].irq = IRQ_EINT19;
  130.     p_kbd->keys[1].irq = IRQ_EINT15;
  131.     p_kbd->keys[2].irq = IRQ_EINT14;
  132.     p_kbd->keys[3].irq = IRQ_EINT13;
  133.     p_kbd->keys[4].irq = IRQ_EINT11;
  134.     p_kbd->keys[5].irq = IRQ_EINT8;

  136.     p_kbd->keys[0].n_key = KEY_0;
  137.     p_kbd->keys[1].n_key = KEY_1;
  138.     p_kbd->keys[2].n_key = KEY_2;
  139.     p_kbd->keys[3].n_key = KEY_3;
  140.     p_kbd->keys[4].n_key = KEY_ESC;
  141.     p_kbd->keys[5].n_key = KEY_ENTER;
  142. }

  144. static int __devinit dhole2440_keys_probe(struct platform_device *pdev)
  145. {
  146.     int err = -ENOMEM;
  147.     struct dhole2440_kbd *p_dhole2440_keys = NULL;
  148.     struct input_dev *input_dev = NULL;

  150.     printk("dhole2440_keys_probe entry!\n");

  152.     p_dhole2440_keys = kmalloc(sizeof(struct dhole2440_kbd), GFP_KERNEL);
  153.     if( !p_dhole2440_keys )
  154.     {
  155.         printk("dhole2440_keys_probe kmalloc error!\n");
  156.         return err;
  157.     }
  158.     printk("dhole2440_keys_probe p_dhole2440_keys=%x\n", (unsigned int)p_dhole2440_keys);

  160.     dhole2440_init_kbd_data(p_dhole2440_keys);

  162.     input_dev = input_allocate_device();
  163.     if (!input_dev)
  164.     {
  165.         printk("dhole2440_keys_probe input_allocate_device error!\n");
  166.         goto fail;
  167.     }

  169.     p_dhole2440_keys->input = input_dev;

  171.     platform_set_drvdata(pdev, p_dhole2440_keys);
  172.     input_dev->name = pdev->name;
  173.     input_dev->phys = DHOLE2440_KBD"/input0";
  174.     input_dev->id.bustype = BUS_HOST;
  175.     input_dev->dev.parent = &pdev->dev;
  176.     input_dev->id.vendor = 0x0001;
  177.     input_dev->id.product = 0x0001;
  178.     input_dev->id.version = 0x0100;

  180.     __set_bit(EV_KEY, input_dev->evbit);
  181.     __set_bit(KEY_0, input_dev->keybit);
  182.     __set_bit(KEY_1, input_dev->keybit);
  183.     __set_bit(KEY_2, input_dev->keybit);
  184.     __set_bit(KEY_3, input_dev->keybit);
  185.     __set_bit(KEY_ESC, input_dev->keybit);
  186.     __set_bit(KEY_ENTER, input_dev->keybit);
  187.     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);

  189.     err = input_register_device(input_dev);
  190.     if( err )
  191.     {
  192.         printk("dhole2440_keys_probe input_register_device error!\n");
  193.         goto fail_allocate;
  194.     }

  196.     set_kbd(p_dhole2440_keys);

  198.     err = kbd_req_irqs();
  199.     if( err )
  200.     {
  201.         printk("dhole2440_keys_probe kbd_req_irqs error!\n");
  202.         goto fail_register;
  203.     }

  205.     printk("dhole2440_keys_probe sucess!\n");

  207.     return 0;

  209. fail_register:
  210.     input_unregister_device(input_dev);
  211.     goto fail;
  212. fail_allocate:
  213.     input_free_device(input_dev);
  214. fail:
  215.     kfree(p_dhole2440_keys);

  217.     return err;
  218. }

  220. static int __devexit dhole2440_keys_remove(struct platform_device *pdev)
  221. {
  222.     struct dhole2440_kbd *p_dhole2440_keys = platform_get_drvdata(pdev);

  224.     printk("dhole2440_keys_remove entry!\n");

  226.     kbd_free_irqs();

  228.     input_unregister_device(p_dhole2440_keys->input);
  229.     kfree(p_dhole2440_keys);

  231.     printk("dhole2440_keys_remove sucess!\n");

  233.     return 0;
  234. }

  236. static void dhole2440_keys_release(struct device *dev)
  237. {
  238.     dev = dev;
  239. }


  242. static struct platform_driver dhole2440_keys_device_driver = {
  243.     .probe = dhole2440_keys_probe,
  244.     .remove = __devexit_p(dhole2440_keys_remove),
  245.     .driver = {
  246.         .name = DHOLE2440_KBD,
  247.         .owner = THIS_MODULE,
  248.     }
  249. };

  251. static struct platform_device dhole2440_device_kbd = {
  252.     .name = DHOLE2440_KBD,
  253.     .id = -1,
  254.     .dev = {
  255.         .release = dhole2440_keys_release,
  256.     }
  257. };

  259. static int __init dhole2440_keys_init(void)
  260. {
  261.     int n_ret;
  262.     n_ret = platform_driver_register(&dhole2440_keys_device_driver);

  264.     printk("dhole2440_keys_init 1 n_ret=%d jiffies=%lu,HZ=%d\n", n_ret, jiffies, HZ);
  265.     if( n_ret )
  266.         return n_ret;

  268.     n_ret = platform_device_register(&dhole2440_device_kbd);

  270.     printk("dhole2440_keys_init 2 n_ret=%d\n", n_ret);
  271.     if( n_ret )
  272.         goto fail;

  274.     return n_ret;

  276. fail:
  277.     platform_driver_unregister(&dhole2440_keys_device_driver);

  279.     return n_ret;
  280. }

  282. static void __exit dhole2440_keys_exit(void)
  283. {
  284.     printk("dhole2440_keys_exit\n");

  286.     platform_device_unregister(&dhole2440_device_kbd);

  288.     platform_driver_unregister(&dhole2440_keys_device_driver);
  289. }

  291. module_init(dhole2440_keys_init);
  292. module_exit(dhole2440_keys_exit);

  294. MODULE_DESCRIPTION("dhole2440 keyboard input events driver");
  295. MODULE_AUTHOR("liuzhiping ");
  296. MODULE_LICENSE("GPL");
  297. MODULE_ALIAS("platform:dhole2440 keyboard driver");

qt环境变量配置
export set QWS_KEYBOARD="LinuxInput:/dev/input/event1"
"event1"可能是event0,因驱动加载的先后顺序而不同。

以上驱动在给出的软硬件平台达到预期效果->"把键盘融入整个linux生态系统".
代码没整理，而且没实现去抖动。各位就将就这看。
期间参考了很多网上大牛的博客，在此一并感谢！！
又一个小土丘被我征服了，很有成就感，该执行下一步计划了！
但是还得先睡觉。
阅读(8160) | 评论(0) | 转发(1) |
0

上一篇：linux驱动,中断中关闭中断

下一篇：交叉编译Makefile文件

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

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

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

16024965号-6