Chinaunix首页 | 论坛 | 博客

zhanghaoran的ChinaUnix博客

首页　| 　博文目录　| 　关于我

haoran9175

  • 博客访问： 134404
  • 博文数量： 14
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 633
  • 用 户 组： 普通用户
  • 注册时间： 2013-09-05 11:44
文章分类

全部博文（14）

文章存档

2014年（14）

我的朋友
最近访客
推荐博文
相关博文
8X8键盘驱动

分类： LINUX

2014-06-25 17:01:26

s3c6410提供了一个8X8的键盘接口，使用的GPIO复用，提供了去抖过滤器。

s3c6410的键盘驱动是基于平台的驱动
一、定义的使用平台的资源

点击(此处)折叠或打开

  1. //资源定义
  2. static struct resource samsung_keypad_resources[] = {
  3.     [0] = {
  4.         .start    = SAMSUNG_PA_KEYPAD,//资源的开始位置
  5.         .end    = SAMSUNG_PA_KEYPAD + 0x20 - 1,//资源的结束位置
  6.         .flags    = IORESOURCE_MEM,//资源类型
  7.     },
  8.     [1] = {
  9.         .start    = IRQ_KEYPAD,
  10.         .end    = IRQ_KEYPAD,
  11.         .flags    = IORESOURCE_IRQ,
  12.     },
  13. };
  14. //定义的平台设备
  15. struct platform_device samsung_device_keypad = {
  16.     .name        = "s3c-keypad",//设备名
  17.     .id        = -1,//设备ID
  18.     .num_resources    = ARRAY_SIZE(samsung_keypad_resources),//使用资源的大小
  19.     .resource    = samsung_keypad_resources,//资源定义
  20. };
二、定义的平台驱动结构

点击(此处)折叠或打开

  1. static struct platform_driver s3c_keypad_driver = {
  2.     .probe        = s3c_keypad_probe,//探测方法
  3.     .remove        = s3c_keypad_remove,//移除方法
  4.     .suspend    = s3c_keypad_suspend,//挂起方法
  5.     .resume        = s3c_keypad_resume,//恢复方法
  6.     .driver        = {
  7.         .owner    = THIS_MODULE,
  8.         .name    = "s3c-keypad",//驱动名
  9.     },
  10. };
三、驱动的注册和注销

点击(此处)折叠或打开

  1. //驱动加载函数
  2. static int __init s3c_keypad_init(void)
  3. {
  4.     int ret;
  5.     //注册平台设备驱动
  6.     ret = platform_driver_register(&s3c_keypad_driver);
  7.     
  8.     if(!ret)
  9.      printk(KERN_INFO "S3C Keypad Driver\n");

  11.     return ret;
  12. }
  13. //驱动的卸载
  14. static void __exit s3c_keypad_exit(void)
  15. {
  16.     //注销平台设备驱动
  17.     platform_driver_unregister(&s3c_keypad_driver);
  18. }
四、探测方法

点击(此处)折叠或打开

  1. //探测方法
  2. static int __init s3c_keypad_probe(struct platform_device *pdev)
  3. {
  4.     struct resource *res, *keypad_mem, *keypad_irq;
  5.     struct input_dev *input_dev;
  6.     struct s3c_keypad *s3c_keypad;
  7.     int ret, size;
  8.     int key, code;
  9.     //获取使用的IO资源
  10.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  11.     if (res == NULL) {
  12.         dev_err(&pdev->dev,"no memory resource specified\n");
  13.         return -ENOENT;
  14.     }
  15.     //计算资源大小
  16.     size = (res->end - res->start) + 1;
  17.     //申请内存空间
  18.     keypad_mem = request_mem_region(res->start, size, pdev->name);
  19.     if (keypad_mem == NULL) {
  20.         dev_err(&pdev->dev, "failed to get memory region\n");
  21.         ret = -ENOENT;
  22.         goto err_req;
  23.     }
  24.     //映射IO到内存空间
  25.     key_base = ioremap(res->start, size);
  26.     if (key_base == NULL) {
  27.         printk(KERN_ERR "Failed to remap register block\n");
  28.         ret = -ENOMEM;
  29.         goto err_map;
  30.     }
  31.     //获取时钟
  32.     keypad_clock = clk_get(&pdev->dev, "keypad");
  33.     if (IS_ERR(keypad_clock)) {
  34.         dev_err(&pdev->dev, "failed to find keypad clock source\n");
  35.         ret = PTR_ERR(keypad_clock);
  36.         goto err_clk;
  37.     }
  38.     //使能时钟
  39.     clk_enable(keypad_clock);
  40.     //分配私有数据空间
  41.     s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL);
  42.     //分配input_dev输入设备结构
  43.     input_dev = input_allocate_device();
  44.     if (!s3c_keypad || !input_dev) {
  45.         ret = -ENOMEM;
  46.         goto err_alloc;
  47.     }
  48.     //将s3c_keypad作为平台设备的私有数据保存
  49.     platform_set_drvdata(pdev, s3c_keypad);
  50.     //将input_dev赋值给s3c_keypad->dev
  51.     s3c_keypad->dev = input_dev;
  52.     
  53.     writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
  54.     writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC);

  56.     /* 设置GPIO口键盘模式、禁用上拉电阻*/
  57.     s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);

  59.     writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);

  61.     /*创建并注册输入驱动程序 */
  62.     __set_bit(EV_KEY, input_dev->evbit);
  63.     __set_bit(EV_REP, input_dev->evbit);
  64.     s3c_keypad->nr_rows = KEYPAD_ROWS;
  65.     s3c_keypad->no_cols = KEYPAD_COLUMNS;
  66.     s3c_keypad->total_keys = MAX_KEYPAD_NR;

  68.     for(key = 0; key < s3c_keypad->total_keys; key++){
  69.         code = s3c_keypad->keycodes[key] = keypad_keycode[key];
  70.         if(code<=0)
  71.             continue;
  72.         __set_bit(code & KEY_MAX, input_dev->keybit);
  73.     }
  74.     //初始化input_dev结构
  75.     input_dev->name = DEVICE_NAME;
  76.     input_dev->phys = "s3c-keypad/input0";
  77.     input_dev->open = samsung_keypad_open;//打开方法
  78.     input_dev->close = samsung_keypad_close;//关闭方法
  79.     input_dev->id.bustype = BUS_HOST;
  80.     input_dev->id.vendor = 0x0001;
  81.     input_dev->id.product = 0x0001;
  82.     input_dev->id.version = 0x0001;
  83.     //设置键编码
  84.     input_dev->keycode = keypad_keycode;

  86.     /*扫描定时器初始化*/
  87.     init_timer(&keypad_timer);
  88.     keypad_timer.function = keypad_timer_handler;
  89.     keypad_timer.data = (unsigned long)s3c_keypad;

  91.     /* 获得中断资源 */
  92.     keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
  93.     if (keypad_irq == NULL) {
  94.         dev_err(&pdev->dev, "no irq resource specified\n");
  95.         ret = -ENOENT;
  96.         goto err_irq;
  97.     }
  98.     //申请资源
  99.     ret = request_irq(keypad_irq->start, s3c_keypad_isr, IRQF_SAMPLE_RANDOM,
  100.         DEVICE_NAME, (void *) pdev);
  101.     if (ret) {
  102.         printk("request_irq failed (IRQ_KEYPAD) !!!\n");
  103.         ret = -EIO;
  104.         goto err_irq;
  105.     }
  106.     //注册输入设备
  107.     ret = input_register_device(input_dev);
  108.     if (ret) {
  109.         printk("Unable to register s3c-keypad input device!!!\n");
  110.         goto out;
  111.     }

  113.     printk( DEVICE_NAME " Initialized\n");
  114.     return 0;

  116. out:
  117.     free_irq(keypad_irq->start, input_dev);
  118.     free_irq(keypad_irq->end, input_dev);

  120. err_irq:
  121.     input_free_device(input_dev);
  122.     kfree(s3c_keypad);
  123.     
  124. err_alloc:
  125.     clk_disable(keypad_clock);
  126.     clk_put(keypad_clock);

  128. err_clk:
  129.     iounmap(key_base);

  131. err_map:
  132.     release_resource(keypad_mem);
  133.     kfree(keypad_mem);

  135. err_req:
  136.     return ret;
  137. }
中断处理方法：当有按键被按下时调用，使用定时器去抖

点击(此处)折叠或打开

  1. static irqreturn_t s3c_keypad_isr(int irq, void *dev_id)
  2. {
  3.     //printk("[KEY]s3c_keypad_isr.\n");    
  4.     /*禁用键盘按键中断、调度定时器处理程序 */
  5.     writel(readl(key_base+S3C_KEYIFCON) & ~(INT_F_EN|INT_R_EN), key_base+S3C_KEYIFCON);

  7.     keypad_timer.expires = jiffies + (HZ/100);
  8.     if ( is_timer_on == FALSE) {
  9.         add_timer(&keypad_timer);//再次添加定时器。循环处理
  10.         is_timer_on = TRUE;
  11.     } else {
  12.         mod_timer(&keypad_timer,keypad_timer.expires);
  13.     }
  14.     /*清除键盘中断状态*/
  15.     writel(KEYIFSTSCLR_CLEAR, key_base+S3C_KEYIFSTSCLR);

  17.     return IRQ_HANDLED;
  18. }
定时器处理方法：当有按键事件产生时，扫描键盘接口寄存器，获得行和列的键值，得到被按下的键，并向输入子
系统核心传递事件

点击(此处)折叠或打开

  1. static void keypad_timer_handler(unsigned long data)
  2. {
  3.     u32 keymask_low = 0, keymask_high = 0;
  4.     u32 press_mask_low, press_mask_high;
  5.     u32 release_mask_low, release_mask_high;
  6.     int i;
  7.     struct s3c_keypad *pdata = (struct s3c_keypad *)data;
  8.     struct input_dev *dev = pdata->dev;
  9.     //扫描键盘接口寄存器，获得行和列的键值
  10.     keypad_scan(&keymask_low, &keymask_high);

  12.     DPRINTK("[KEY]keypad_timer_handler.kl=%x,kh=%x\n",keymask_low, keymask_high);
  13.     //得到被按下的键
  14.     if (keymask_low != prevmask_low) {
  15.         press_mask_low =
  16.             ((keymask_low ^ prevmask_low) & keymask_low);
  17.         release_mask_low =
  18.             ((keymask_low ^ prevmask_low) & prevmask_low);

  20.         i = 0;
  21.         while (press_mask_low) {
  22.             if (press_mask_low & 1) {
  23.                 //向输入子系统传递事件
  24.                 input_report_key(dev,pdata->keycodes[i],1);
  25.                 DPRINTK("low Pressed : %d\n",i);
  26.             }
  27.             press_mask_low >>= 1;
  28.             i++;
  29.         }

  31.         i = 0;
  32.         while (release_mask_low) {
  33.             if (release_mask_low & 1) {
  34.                 input_report_key(dev,pdata->keycodes[i],0);
  35.                 DPRINTK("low Released : %d\n",i);
  36.             }
  37.             release_mask_low >>= 1;
  38.             i++;
  39.         }
  40.         prevmask_low = keymask_low;
  41.     }

  43.     if (keymask_high != prevmask_high) {
  44.         press_mask_high =
  45.             ((keymask_high ^ prevmask_high) & keymask_high);
  46.         release_mask_high =
  47.             ((keymask_high ^ prevmask_high) & prevmask_high);

  49.         i = 0;
  50.         while (press_mask_high) {
  51.             if (press_mask_high & 1) {
  52.                 input_report_key(dev,pdata->keycodes[i+MAX_KEYMASK_NR],1);
  53.                 DPRINTK("high Pressed : %d %d\n",pdata->keycodes[i+MAX_KEYMASK_NR],i);
  54.             }
  55.             press_mask_high >>= 1;
  56.             i++;
  57.         }

  59.         i = 0;
  60.         while (release_mask_high) {
  61.             if (release_mask_high & 1) {
  62.                 input_report_key(dev,pdata->keycodes[i+MAX_KEYMASK_NR],0);
  63.                 DPRINTK("high Released : %d\n",pdata->keycodes[i+MAX_KEYMASK_NR]);
  64.             }
  65.             release_mask_high >>= 1;
  66.             i++;
  67.         }
  68.         prevmask_high = keymask_high;
  69.     }

  71.     if (keymask_low | keymask_high) {
  72.         mod_timer(&keypad_timer,jiffies + HZ/10);
  73.     } else {
  74.         writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
  75.         is_timer_on = FALSE;
  76.     }    
  77. }
扫描键盘接口寄存器，获得行和列的键值

点击(此处)折叠或打开

  1. static int keypad_scan(u32 *keymask_low, u32 *keymask_high)
  2. {
  3.     int i,j = 0;
  4.     u32 cval,rval;
  5.     //获得行和列的键值
  6.     for (i=0; i<KEYPAD_COLUMNS; i++) {
  7.         cval = readl(key_base+S3C_KEYIFCOL) | KEYCOL_DMASK;
  8.         cval &= ~(1 << i);
  9.         writel(cval, key_base+S3C_KEYIFCOL);

  11.         udelay(KEYPAD_DELAY);

  13.         rval = ~(readl(key_base+S3C_KEYIFROW)) & KEYROW_DMASK;
  14.         
  15.         //printk("[KEY]rval=%x\n",rval);
  16.         
  17.         //MAX is 64 buttons, so we can use 2 WORD to save the status of keyboards        
  18.         if ((i*KEYPAD_ROWS) < MAX_KEYMASK_NR)
  19.             *keymask_low |= (rval << (i * KEYPAD_ROWS));
  20.         else {
  21.             *keymask_high |= (rval << (j * KEYPAD_ROWS));
  22.             j = j + 1;
  23.         }
  24.     }

  26.     writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);

  28.     return 0;
  29. }
五、移除方法

点击(此处)折叠或打开

  1. static int s3c_keypad_remove(struct platform_device *pdev)
  2. {
  3.     struct input_dev *input_dev = platform_get_drvdata(pdev);
  4.     writel(KEYIFCON_CLEAR, key_base+S3C_KEYIFCON);
  5.     //关闭时钟
  6.     if(keypad_clock) {
  7.         clk_disable(keypad_clock);
  8.         clk_put(keypad_clock);
  9.         keypad_clock = NULL;
  10.     }
  11.     //注销input驱动
  12.     input_unregister_device(input_dev);
  13.     //接触IO映射
  14.     iounmap(key_base);
  15.     kfree(pdev->dev.platform_data);
  16.     //释放中断
  17.     free_irq(IRQ_KEYPAD, (void *) pdev);

  19.     del_timer(&keypad_timer);    
  20.     printk(DEVICE_NAME " Removed.\n");
  21.     return 0;
  22. }
六、总结
键盘驱动的编写方法
1、定义平台设备结构，指明使用的资源
2、定义平台设备驱动结构
3、注册平台设备
4、在探测方法中分配IO资源并映射到内存，使能时钟，申请中断，分配input_dev结构，初始化input_dev结构
注册input驱动
5、在中断方法中判断抖动
6、在定时器方法中扫描键盘的行列键值，得到按下的键对应的事件，向输入子系统核心提交事件；
7、在移除方法中关闭时钟、释放内存等操作。








阅读(2091) | 评论(0) | 转发(0) |
1

上一篇：GPIO按键驱动

下一篇：USB鼠标驱动

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

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

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

16024965号-6