Android 架构解析及驱动键盘篇

小鱼儿 2022-07-16 14:46 226阅读 0赞

# Android 架构解析及驱动 键盘篇  #

学习网站：http://blog.csdn.net/sfrysh/archive/2010/07/28/5772158.aspx 里面有很多好用的东东 参考下

\--  作者：老树  
\--  发布时间：2010-6-2 15:01:19  
 **--  Android 架构解析及驱动 键盘篇**

**一、用户空间      **

[ADROID 2.1 架构解析 7 键盘 ][ADROID 2.1 _ 7 _]

以上链接，详细介绍了Android用户空间按键的操作，最终通过不断轮询所有设备，直到读取有POLLIN事件产生的设备状态：if(mFDs\[i\].revents & POLLIN) \{  res = read(mFDs\[i\].fd, &iev, sizeof(iev));......

二、底层驱动

1.设备注册  
 static struct resource s3c\_keypad\_resource\[\] = \{  
\[0\] = \{  
   .start = S3C64XX\_PA\_KEYPAD,  
   .end = S3C64XX\_PA\_KEYPAD+S3C64XX\_SZ\_KEYPAD-1,  
   .flags = IORESOURCE\_MEM,  
\},  
\[1\] = \{  
   .start = IRQ\_KEYPAD,  
   .end = IRQ\_KEYPAD,  
   .flags = IORESOURCE\_IRQ,  
\}  
   \};

struct platform\_device s3c\_device\_keypad = \{  
   .name = "s3c-keypad",  
   .id = -1,  
   .num\_resource =ARRAY\_SIZE(s3c\_keypad\_resource ),  
   .resource = s3c\_keypad\_resource,  
   \};  
   EXPORT\_SYMBOL(s3c\_device\_keypad);

static struct platform\_device \*smdk6410\_devices\[\] \_\_initdata = \{  
     ...  
    &s3c\_device\_keypad ,  
   \}

static void \_\_init smdk6410\_machine\_init (void)  
\{  
    ...  
    platform\_add\_devices (smdk6410\_devices,ARRAY\_SIZE(smdk6410\_devices));  
    ...  
\}

int platform\_add\_devices (struct platform\_device \*\*devs, int num)  
\{  
int i,ret = 0;  
for(i=0;i<num;i++)\{  
   ret = platform\_device\_register(devs\[i\]);  
   if(ret)\{  
      while(--i >= 0)  
   platform\_device\_unregister(devs\[i\]);  
      break;  
   \}  
\}  
return ret;  
   \}

2.驱动注册与注销  
    module\_init(s3c\_keypad\_init);  
   module\_exit(s3c\_keypad\_exit);

static int \_\_init s3c\_keypad\_init (void)  
\{  
   int ret;  
  
   ret = platform\_driver\_register(&s3c\_keypad\_driver);  
   if(!ret)  
      printk(KERN\_INFO"S3C Keypad Driver//n");

return ret;  
\}

static void \_\_exit s3c\_keypad\_exit (void)  
\{  
   platform\_driver\_unregister(&s3c\_keypad\_driver );  
\}

platform\_driver结构体：  
static struct platform\_driver s3c\_keypad\_driver = \{  
   .probe =s3c\_keypad\_probe,  
   .remove =s3c\_keypad\_remove,  
   .suspend =s3c\_keypad\_suspend,  
   .resume =s3c\_keypad\_resume,  
   .driver = \{  
    .owner = THIS\_MODULE,  
      .name = "s3c-keypad",  
    \},  
\};

3.设备探测  
static int \_\_init s3c\_keypad\_probe (struct platform\_device \*pdev)  
\{  
struct resource \*res, \*keypad\_mem, \*keypad\_irq = NULL;  
struct input\_dev \*input\_dev;

int ret, size;  
int key, code;  
struct s3c\_keypad\_extra    \*extra = NULL;  
struct s3c\_keypad\_gpio\_key \*gpio\_key;  
int i;  
char \* input\_dev\_name;

res = platform\_get\_resource(pdev, IORESOURCE\_MEM, 0);  //获取设备内存信息  
 if (res == NULL) \{  
   dev\_err(&pdev->dev,"no memory resource specified//n");  
   return -ENOENT;  
\}

size = (res->end - res->start) + 1;

keypad\_mem = request\_mem\_region(res->start, size, pdev->name);  
if (keypad\_mem == NULL) \{  
   dev\_err(&pdev->dev, "failed to get memory region//n");  
   ret = -ENOENT;  
   goto err\_req;  
\}

key\_base = ioremap(res->start, size);    //IO空间映射  
if (key\_base == NULL) \{  
   printk(KERN\_ERR "Failed to remap register block//n");  
   ret = -ENOMEM;  
   goto err\_map;  
\}

keypad\_clock = clk\_get(&pdev->dev, "keypad");      //获取keypad对应的时钟  
 if (IS\_ERR(keypad\_clock)) \{  
   dev\_err(&pdev->dev, "failed to find keypad clock source//n");  
   ret = PTR\_ERR(keypad\_clock);  
   goto err\_clk;  
\}

clk\_enable(keypad\_clock);    //使能keypad模块的时钟

s3c\_keypad\_data = kzalloc(sizeof(struct s3c\_keypad), GFP\_KERNEL);

input\_dev = input\_allocate\_device(); //申请一个input\_dev设备  
input\_dev\_name = (char \*)kmalloc(sizeof("s3c-keypad-revxxxx "), GFP\_KERNEL); //这里就是用户空间提到的键值配置表

if (!s3c\_keypad\_data || !input\_dev) \{  
   ret = -ENOMEM;  
   goto err\_alloc;  
\}

platform\_set\_drvdata(pdev, s3c\_keypad\_data);  
  
for (i=0; i<sizeof(s3c\_keypad\_extra)/sizeof(struct s3c\_keypad\_extra); i++)  
\{  
   if (s3c\_keypad\_extra\[i\].board\_num == system\_rev) \{  
    extra = &s3c\_keypad\_extra\[i\];  
    sprintf(input\_dev\_name, "%s%s%04x", DEVICE\_NAME, "-rev", system\_rev);  
    DPRINTK(": board rev 0x%04x is detected!//n", s3c\_keypad\_extra\[i\].board\_num);  
    break;  
   \}  
\}

if(!extra) \{  
   extra = &s3c\_keypad\_extra\[0\];  
   sprintf(input\_dev\_name, "%s%s", DEVICE\_NAME, "-rev0000");     //default revison  
   DPRINTK(": failed to detect board rev. set default rev00//n");  
\}  
DPRINTK(": input device name: %s.//n", input\_dev\_name);

s3c\_keypad\_data->dev = input\_dev;  
s3c\_keypad\_data->extra = extra;  
gpio\_key = extra->gpio\_key;

/\* create and register the input driver \*/  
set\_bit(EV\_KEY, input\_dev->evbit);  
set\_bit(EV\_REP, input\_dev->evbit);  
s3c\_keypad\_data->nr\_rows = KEYPAD\_ROWS;  
s3c\_keypad\_data->no\_cols = KEYPAD\_COLUMNS;

for(key = 0; key < 32; key++)\{  
   code = s3c\_keypad\_data->keycodes\[key\] = keypad\_keycode\[key\];  
   if(code<=0)  
    continue;  
   set\_bit(code & KEY\_MAX, input\_dev->keybit);  
\}  
for (i=0; i<extra->gpio\_key\_num; i++ )\{  
        input\_set\_capability(input\_dev, EV\_KEY, (gpio\_key+i)->keycode);  
\}

input\_dev->name = DEVICE\_NAME;  
input\_dev->phys = "s3c-keypad/input0";

input\_dev->id.bustype = BUS\_HOST;  
input\_dev->id.vendor = 0x0001;  
input\_dev->id.product = 0x0001;  
input\_dev->id.version = 0x0001;

input\_dev->keycode = keypad\_keycode;

/\* init\_timer(&keypad\_timer); \*/  
keypad\_timer.function = keypad\_timer\_handler;  
keypad\_timer.data = (unsigned long)s3c\_keypad\_data;

for (i=0; i<extra->gpio\_key\_num; i++, gpio\_key+=1)  
\{  
   s3c\_gpio\_cfgpin(gpio\_key->gpio, S3C\_GPIO\_SFN(gpio\_key->gpio\_af));  
   s3c\_gpio\_setpull(gpio\_key->gpio, S3C\_GPIO\_PULL\_NONE);

set\_irq\_type(gpio\_key->eint, IRQ\_TYPE\_EDGE\_BOTH);

ret = request\_irq(gpio\_key->eint, gpio\_int\_handler , IRQF\_DISABLED,  
       "s3c\_keypad gpio key", (void \*)s3c\_keypad\_data);   //中断注册  
   if (ret) \{  
    printk(KERN\_ERR "request\_irq(%d) failed (IRQ for GPIO KEY) !!!//n", gpio\_key->eint);  
    ret = -EIO;  
    goto err\_irq;  
   \}  
\}

ret = input\_register\_device(input\_dev);   //向输入子系统注册此设备  
if (ret) \{  
   printk("Unable to register s3c-keypad input device!!!//n");  
   goto out;  
\}

return 0;

out:  
   input\_free\_device(input\_dev);  
   kfree(s3c\_keypad\_data);

err\_irq:  
   free\_irq(keypad\_irq->start, input\_dev);  
   free\_irq(keypad\_irq->end, input\_dev);

gpio\_key = extra->gpio\_key;  
   for (i=0; i<extra->gpio\_key\_num; i++, gpio\_key+=1)  
     free\_irq(gpio\_key->eint, s3c\_keypad\_data);  
  
err\_alloc:  
   clk\_disable(keypad\_clock);  
   clk\_put(keypad\_clock);

err\_clk:  
   iounmap(key\_base);

err\_map:  
   release\_resource(keypad\_mem);  
   kfree(keypad\_mem);

err\_req:  
   return ret;  
\}  
4.按键出发中断，中断处理与数据上传  
static irqreturn\_t gpio\_int\_handler (int irq, void \*dev\_id)  
\{  
struct input\_dev           \*dev = s3c\_keypad\_data->dev;  
struct s3c\_keypad\_extra    \*extra = s3c\_keypad\_data->extra;  
struct s3c\_keypad\_gpio\_key \*gpio\_key = extra->gpio\_key;  
int i,state;

for (i=0; i<extra->gpio\_key\_num; i++)  
\{  
   if (gpio\_key\[i\].eint == irq)  
   \{  
    gpio\_key = &gpio\_key\[i\];  
    break;  
   \}  
\}

if (gpio\_key != NULL)  
\{  
   state = gpio\_get\_value(gpio\_key->gpio);  
   state ^= gpio\_key->state\_upset;

if(state) \{  
            input\_report\_key(dev, gpio\_key->keycode, 1);  
        \}  
       else \{  
    input\_report\_key(dev, gpio\_key->keycode, 0);  
   \}  
\}  
return IRQ\_HANDLED;  
\}  
数 据上传input\_report\_key-》input\_event-》input\_handle\_event-》input\_pass\_event-》 handle->handler->event(对应函数：evdev\_event)-》数据暂存event（input\_event结构 体），以供用户空间读写操作。

5.input事件在传输过程中的一些函数  
void input\_event (struct input\_dev \*dev,unsigned int type, unsigned int code, int value)  
\{  
    unsigned long flags;

if (is\_event\_supported(type, dev->evbit, EV\_MAX)) \{  
        spin\_lock\_irqsave(&dev->event\_lock, flags);  
        add\_input\_randomness(type, code, value);//因为按键的存在随机性,所以按键是给系统提供墒随机数的好来源.  
        input\_handle\_event(dev, type, code, value);  
        spin\_unlock\_irqrestore(&dev->event\_lock, flags);  
    \}  
\}

static void input\_handle\_event (struct input\_dev \*dev,unsigned int type, unsigned int code, int value)  
\{  
        ...  
        case EV\_KEY:  
        if (is\_event\_supported(code, dev->keybit, KEY\_MAX) &&  
            !!test\_bit(code, dev->key) != value) \{//这次来的是否为新的键值

if (value != 2) \{  
                \_\_change\_bit(code, dev->key);// 通过异或^操作,反转code对应的bitmap,如果value等于2,那么将忽略该按键  
                if (value)  
                    input\_start\_autorepeat(dev, code); //键盘按下,那么开启定时检测,这样可以出现连续输入的效果  
             \}

disposition = INPUT\_PASS\_TO\_HANDLERS;  
        \}  
        break;  
    ...  
\}

static void input\_start\_autorepeat (struct input\_dev \*dev, int code)  
\{  
    if (test\_bit(EV\_REP, dev->evbit) &&  
     dev->rep\[REP\_PERIOD\] && dev->rep\[REP\_DELAY\] &&  
     dev->timer.data) \{  
        dev->repeat\_key = code;  
        mod\_timer(&dev->timer, //重新启动定时器input\_repeat\_key,时间间隔msecs\_to\_jiffies(dev->rep\[REP\_DELAY\])  
              jiffies + msecs\_to\_jiffies(dev->rep\[REP\_DELAY\]));  
    \}  
\}

static void input\_repeat\_key (unsigned long data)  
\{  
    struct input\_dev \*dev = (void \*) data;  
    unsigned long flags;

spin\_lock\_irqsave(&dev->event\_lock, flags);

if (test\_bit(dev->repeat\_key, dev->key) &&  
     is\_event\_supported(dev->repeat\_key, dev->keybit, KEY\_MAX)) \{

input\_pass\_event(dev, EV\_KEY, dev->repeat\_key, 2);//交给处理按键函数

if (dev->sync) \{  
            /\*  
             \* Only send SYN\_REPORT if we are not in a middle  
             \* of driver parsing a new hardware packet.  
             \* Otherwise assume that the driver will send  
             \* SYN\_REPORT once it/'s done.  
             \*/  
            input\_pass\_event(dev, EV\_SYN, SYN\_REPORT, 1);  
        \}

if (dev->rep\[REP\_PERIOD\])  
            mod\_timer(&dev->timer, jiffies +  
                    msecs\_to\_jiffies(dev->rep\[REP\_PERIOD\]));  
    \}

spin\_unlock\_irqrestore(&dev->event\_lock, flags);  
\}

以上驱动是input方式完成的，不清楚的可查阅Linux input输入子设备。

[ADROID 2.1 _ 7 _]: http://blog.csdn.net/skdev/archive/2010/03/08/5355542.aspx