亚洲av成人无遮挡网站在线观看,少妇性bbb搡bbb爽爽爽,亚洲av日韩精品久久久久久,兔费看少妇性l交大片免费,无码少妇一区二区三区

<ruby id="we6fu"><menuitem id="we6fu"></menuitem></ruby>

<style id="we6fu"></style>

Chinaunix

標(biāo)題: 今天小心奕奕的把代碼拷出來，是個(gè)按鍵驅(qū)動(dòng)，大家?guī)兔�看一�?[打印本頁]

---

作者: 0vk0    時(shí)間: 2011-03-04 19:46
標(biāo)題: 今天小心奕奕的把代碼拷出來，是個(gè)按鍵驅(qū)動(dòng)，大家?guī)兔�看一�?br />

是個(gè)按鍵驅(qū)動(dòng)，大家?guī)兔�看一下，現(xiàn)在按鍵抬起可以檢測到，但再按別的



我測試時(shí)老是出現(xiàn)：
     
      當(dāng)換一個(gè)按鍵時(shí)，會(huì)出現(xiàn)前一個(gè)按鍵，比如我按1時(shí)，按下會(huì)打印1，抬起會(huì)打印1，當(dāng)我換按2時(shí)，第一遍按下會(huì)打印1，抬起會(huì)打印2，再第二遍的時(shí)候就不會(huì)了


      當(dāng)我換按5時(shí)，第一遍按下會(huì)打印2，抬起會(huì)打印5，再第二遍的時(shí)候也不會(huì)了，請幫幫忙看下程序，謝謝了，第二個(gè)是應(yīng)該層的測試程序

1. #include <asm/gpio.h>
   
2. #include <asm/jzsoc.h>
   
3. ……
   
4. 
   
5. #define DEVICE_NAME "keypad"
   
6. #define    MAX_KEY_COUNT  32                                    
   
7. 
   
8. #define HC164_CP       89     //kb2
   
9. #define HC164_DS       88     //kb1
   
10. #define INT_KEY1       93     //kb3
    
11. #define INT_KEY2       91     //kb4
    
12. 
    
13. #define KEY1_IRQ       (IRQ_GPIO_0 + INT_KEY1)
    
14. #define KEY2_IRQ       (IRQ_GPIO_0 + INT_KEY2)
    
15. typedef struct
    
16. {
    
17.     unsigned long jiffy[MAX_KEY_COUNT];  
    
18.     unsigned char buf[MAX_KEY_COUNT];   
    
19.     unsigned int head,tail;                 
    
20. }KEY_BUFFER;
    
21. 
    
22. static KEY_BUFFER g_keyBuffer;   
    
23. static spinlock_t buffer_lock;
    
24. 
    
25. static int   Keypad_major = 255;
    
26. 
    
27. int a=200,b=201;
    
28. 
    
29. /*
    
30. */
    
31. static unsigned long GetTickCount(void)
    
32. {
    
33.     struct timeval currTick;
    
34.     unsigned long ulRet;
    
35. 
    
36.     do_gettimeofday(&currTick);
    
37.     ulRet = currTick.tv_sec;
    
38.     ulRet *= 1000;
    
39.     ulRet += (currTick.tv_usec + 500) / 1000;
    
40.     return ulRet;
    
41. }
    
42. 
    
43. /*
    
44. */
    
45. static void init_keybuffer(void)
    
46. {
    
47.     int i;
    
48.     spin_lock_irq(&buffer_lock);
    
49.     g_keyBuffer.head = 0;
    
50.     g_keyBuffer.tail = 0;
    
51.     for(i = 0; i < MAX_KEY_COUNT; i++)
    
52.     {
    
53.         g_keyBuffer.buf[i] = 0;
    
54.         g_keyBuffer.jiffy[i] = 0;
    
55.     }
    
56.     spin_unlock_irq(&buffer_lock);
    
57. }
    
58. 
    
59. /*
    
60. */
    
61. static void remove_timeoutkey(void)
    
62. {
    
63.     unsigned long ulTick;
    
64. 
    
65.     spin_lock_irq(&buffer_lock);
    
66.     while(g_keyBuffer.head != g_keyBuffer.tail)
    
67.     {
    
68.         ulTick = GetTickCount() - g_keyBuffer.jiffy[g_keyBuffer.head];
    
69.         if (ulTick  < 5000)   
    
70.             break;
    
71.         g_keyBuffer.buf[g_keyBuffer.head] = 0;
    
72.         g_keyBuffer.jiffy[g_keyBuffer.head] = 0;
    
73.         g_keyBuffer.head ++;
    
74.         g_keyBuffer.head &= (MAX_KEY_COUNT -1);
    
75.     }
    
76.     spin_unlock_irq(&buffer_lock);
    
77. }
    
78. /*
    
79. */
    
80. void _74HC164Send(unsigned char d)
    
81. {
    
82.         int j;
    
83. 
    
84.         for(j=0;j<8;j++)
    
85.         {
    
86.                 if (d&1)
    
87.                         __gpio_set_pin(HC164_DS);
    
88.                 else
    
89.                         __gpio_clear_pin(HC164_DS);
    
90. 
    
91.                 mdelay(1);
    
92.                 __gpio_set_pin(HC164_CP);
    
93.                 mdelay(1);
    
94.                 __gpio_clear_pin(HC164_CP);
    
95. 
    
96.                  d >>= 1;
    
97.         }
    
98. }
    
99. 
    
100. /*
     
101. */
     
102. static void init_gpio(void)
     
103. {
     
104.           __gpio_as_input(INT_KEY1);
     
105.         __gpio_as_input(INT_KEY2);
     
106.   
     
107.         __gpio_as_output(HC164_CP);
     
108.         __gpio_as_output(HC164_DS);
     
109.    
     
110.         __gpio_clear_pin(HC164_CP);
     
111.         __gpio_clear_pin(HC164_DS);
     
112. 
     
113.          _74HC164Send(0);
     
114. }
     
115. 
     
116. /*
     
117. */
     
118. static __inline void enable_irqs(void)
     
119. {
     
120.         unsigned long flags;
     
121. 
     
122.         spin_lock_irqsave(buffer_lock, flags);
     
123.         __gpio_unmask_irq(INT_KEY1);
     
124.         __gpio_unmask_irq(INT_KEY2);
     
125.         spin_unlock_irqrestore(buffer_lock, flags);
     
126. 
     
127. }
     
128. 
     
129. /*
     
130. */
     
131. static __inline void disable_irqs(void)
     
132. {
     
133.         unsigned long flags;
     
134. 
     
135.         spin_lock_irqsave(buffer_lock, flags);
     
136.         __gpio_mask_irq(INT_KEY1);
     
137.         __gpio_mask_irq(INT_KEY2);
     
138.         spin_unlock_irqrestore(buffer_lock, flags);
     
139. }
     
140. 
     
141. /*
     
142. */
     
143. static unsigned char num = 0;
     
144. static __inline unsigned char button_scan(int irq)
     
145. {
     
146.      unsigned char ret=0xff;
     
147.      unsigned char i;
     
148. 
     
149.     if(!(__gpio_get_pin(INT_KEY1)))
     
150.     {
     
151.      for(i=1;i<9;i++)
     
152.      {
     
153.          printk("i=%d\n",i);
     
154.          __gpio_set_pin(HC164_DS);
     
155.          mdelay(1);
     
156.          __gpio_set_pin(HC164_CP);
     
157.          mdelay(1);
     
158.          __gpio_clear_pin(HC164_CP);
     
159.          if(__gpio_get_pin(INT_KEY1))
     
160.          {
     
161.                         num=i;            //此處改動(dòng)過
     
162.                         return i;
     
163.          }
     
164.      }
     
165.     }
     
166.     else
     
167.     {
     
168.        if(!(__gpio_get_pin(INT_KEY2)))
     
169.        {
     
170.           for(i=1;i<9;i++)
     
171.           {
     
172.          printk("key2 i=%d\n",i);
     
173.             __gpio_set_pin(HC164_DS);
     
174.             mdelay(1);
     
175.             __gpio_set_pin(HC164_CP);
     
176.             mdelay(1);
     
177.             __gpio_clear_pin(HC164_CP);
     
178.             if(__gpio_get_pin(INT_KEY2))
     
179.             {
     
180.                num=i+8;             //此處改動(dòng)
     
181.                return i;            
     
182.             }
     
183.           }
     
184.        }
     
185.     }
     
186.     return ret ;
     
187. }
     
188. 
     
189. /*
     
190. *
     
191. */
     
192. static irqreturn_t button_down_irq(int irq, void *dev_id)
     
193. {
     
194.     unsigned char ucKey;
     
195.   disable_irqs();
     
196.   udelay(1000);
     
197.     ucKey = button_scan(irq);      
     
198.    
     
199.     if ((ucKey >= 1) && (ucKey <= 16))
     
200.     {
     
201.         if (((g_keyBuffer.head + 1) & (MAX_KEY_COUNT - 1)) != g_keyBuffer.tail)
     
202.         {
     
203.             spin_lock_irq(&buffer_lock);
     
204.             g_keyBuffer.buf[g_keyBuffer.tail] = ucKey;
     
205.             g_keyBuffer.jiffy[g_keyBuffer.tail] = GetTickCount();
     
206.             g_keyBuffer.tail ++;
     
207.             g_keyBuffer.tail &= (MAX_KEY_COUNT - 1);
     
208.             spin_unlock_irq(&buffer_lock);
     
209.         }
     
210.     }
     
211.    
     
212.     _74HC164Send(0);
     
213.     __gpio_ack_irq(INT_KEY1); // clear status
     
214.     __gpio_ack_irq(INT_KEY2); // clear status
     
215.     enable_irqs();
     
216. 
     
217.     return IRQ_HANDLED;
     
218. }
     
219. 
     
220. static irqreturn_t button_rise_irq(int irq, void *dev_id)
     
221. {
     
222.     unsigned char ucKey;
     
223.     disable_irqs();
     
224.     udelay(1000);
     
225.     ucKey = num;
     
226.     // *****************************
     
227.     buttonup_scan();
     
228.    
     
229.     if ((ucKey >= 1) && (ucKey <= 16))
     
230.     {
     
231.         if (((g_keyBuffer.head + 1) & (MAX_KEY_COUNT - 1)) != g_keyBuffer.tail)
     
232.         {
     
233.             spin_lock_irq(&buffer_lock);
     
234.             g_keyBuffer.buf[g_keyBuffer.tail] = ucKey;
     
235.             g_keyBuffer.jiffy[g_keyBuffer.tail] = GetTickCount();
     
236.             g_keyBuffer.tail ++;
     
237.             g_keyBuffer.tail &= (MAX_KEY_COUNT - 1);
     
238.             spin_unlock_irq(&buffer_lock);
     
239.         }
     
240.     }
     
241.    
     
242.     _74HC164Send(0);
     
243.     __gpio_ack_irq(INT_KEY1); // clear status
     
244.     __gpio_ack_irq(INT_KEY2); // clear status
     
245.     enable_irqs();
     
246. 
     
247.     return IRQ_HANDLED;
     
248. }
     
249. 
     
250. /*
     
251. *
     
252. */
     
253. static int request_irqs(void)
     
254. {
     
255.    __gpio_as_irq_fall_edge(INT_KEY1);         //下降沿發(fā)生中斷
     
256.    __gpio_as_irq_fall_edge(INT_KEY2);
     
257.   
     
258.    __gpio_as_irq_rise_edge(INT_KEY1);           //上升沿發(fā)生中斷
     
259.    __gpio_as_irq_rise_edge(INT_KEY2);
     
260. 
     
261.               if(request_irq(KEY1_IRQ, button_rise_irq, IRQF_DISABLED | IRQF_SHARED, DEVICE_NAME, &a)){
     
262.                 printk("Could not allocate key1 IRQ:%d\n",KEY1_IRQ);
     
263.                 return -EINVAL;
     
264.    }
     
265.    if(request_irq(KEY2_IRQ, button_rise_irq,  IRQF_DISABLED | IRQF_SHARED, DEVICE_NAME, &a)){
     
266.                 free_irq(KEY1_IRQ, &a);
     
267.                 printk("Could not allocate key2 IRQ:%d\n",KEY2_IRQ);
     
268.                 return -EINVAL;
     
269.                 }
     
270.                
     
271.                    if(request_irq(KEY1_IRQ, button_down_irq,  IRQF_DISABLED | IRQF_SHARED, DEVICE_NAME, &b)){
     
272.                 printk("Could not allocate key1 IRQ:%d\n",KEY1_IRQ);
     
273.                 return -EINVAL;
     
274.    }
     
275.    if(request_irq(KEY2_IRQ, button_down_irq,  IRQF_DISABLED | IRQF_SHARED, DEVICE_NAME, &b)){
     
276.                 free_irq(KEY1_IRQ, &b);
     
277.                 printk("Could not allocate key2 IRQ:%d\n",KEY2_IRQ);
     
278.                 return -EINVAL;
     
279.                 }
     
280.                         
     
281.    __gpio_ack_irq(INT_KEY1); // clear status
     
282.    __gpio_ack_irq(INT_KEY2); // clear status
     
283.     return 0;
     
284. }
     
285. 
     
286. /*
     
287. *
     
288. */
     
289. static __inline void free_irqs(void)
     
290. {
     
291.     free_irq(KEY1_IRQ, &a);
     
292.     free_irq(KEY1_IRQ, &b);
     
293.     free_irq(KEY2_IRQ, &a);
     
294.     free_irq(KEY2_IRQ, &b);
     
295. }
     
296. /*
     
297. *
     
298. */
     
299. static int keypad_open(struct inode *inode,struct file *filp)
     
300. {
     
301.     int ret = nonseekable_open(inode, filp);
     
302.     if (ret >= 0)
     
303.     {
     
304.     printk("keypad opened ret>0.\n");
     
305.         init_keybuffer();
     
306.         enable_irqs();
     
307.     }
     
308.     printk("keypad opened.\n");
     
309.     return ret;
     
310. }
     
311. 
     
312. /*
     
313. *
     
314. */
     
315. static int keypad_release(struct inode *inode,struct file *filp)
     
316. {
     
317.     disable_irqs();
     
318.     printk("keypad release.\n");
     
319.     return 0;
     
320. }
     
321. 
     
322. /*
     
323. *
     
324. */
     
325. static ssize_t keypad_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
     
326. {
     
327.     ssize_t ret = 0;
     
328. 
     
329.     remove_timeoutkey();
     
330.     spin_lock_irq(&buffer_lock);
     
331.     while((g_keyBuffer.head != g_keyBuffer.tail) && (((size_t)ret) < count) )
     
332.     {
     
333.         buffer[ret] = (char)(g_keyBuffer.buf[g_keyBuffer.head]);
     
334.         g_keyBuffer.buf[g_keyBuffer.head] = 0;
     
335.         g_keyBuffer.jiffy[g_keyBuffer.head] = 0;
     
336.         g_keyBuffer.head ++;
     
337.         g_keyBuffer.head &= (MAX_KEY_COUNT - 1);
     
338.         ret ++;
     
339.     }
     
340.     spin_unlock_irq(&buffer_lock);
     
341.     return ret;
     
342. }
     
343. 
     
344. /*
     
345. *
     
346. */
     
347. static int keypad_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
     
348. {
     
349.     init_keybuffer();
     
350.     return 1;
     
351. }
     
352. 
     
353. /*
     
354. */
     
355. static void led_setup_cdev(struct cdev *dev,int minor,struct file_operations *fops)
     
356. {
     
357.     int err;
     
358.     int devno=MKDEV(Keypad_major,minor);
     
359.     cdev_init(dev,fops);
     
360.     dev->owner=THIS_MODULE;
     
361.     dev->ops=fops;
     
362.     err=cdev_add(dev,devno,1);
     
363.     if(err)
     
364.     printk(KERN_INFO"Error %d adding button %d\n",err,minor);
     
365. }
     
366. /*
     
367. */
     
368. static struct file_operations keypad_fops =
     
369. {
     
370.     .owner = THIS_MODULE,
     
371.     .ioctl = keypad_ioctl,
     
372.     .open = keypad_open,
     
373.     .read = keypad_read,
     
374.     .release = keypad_release,
     
375. };
     
376. 
     
377. static struct cdev SimpleDevs;  
     
378. 
     
379. /*
     
380. *
     
381. */
     
382. 
     
383. static int  KeyPad_Init(void)
     
384. {
     
385.     int ret;
     
386.     int result;
     
387.     dev_t dev;
     
388. 
     
389.     dev=MKDEV(Keypad_major,0);
     
390.     if(Keypad_major)
     
391.      result=register_chrdev_region(dev,1,DEVICE_NAME);
     
392.     else
     
393.      {
     
394.         result=alloc_chrdev_region(&dev,0,1,DEVICE_NAME);
     
395.         Keypad_major=MAJOR(dev);
     
396.      }
     
397.     if(result<0)
     
398.      {
     
399.       printk(KERN_WARNING"Keypad:unable to get major %d\n",Keypad_major);        
     
400.       return result;
     
401.      }
     
402.     if(Keypad_major==0)
     
403.     Keypad_major=result;
     
404.     led_setup_cdev(&SimpleDevs,0,&keypad_fops);
     
405.     init_gpio();
     
406.     ret = request_irqs();
     
407.     if (ret < 0)
     
408.     {
     
409.       cdev_del(&SimpleDevs);
     
410.       unregister_chrdev_region(MKDEV(Keypad_major,0),1);
     
411.       return ret;
     
412.     }
     
413.     printk(KERN_INFO"keypad register ok!!!!!!!!!!\n");
     
414.     return 0;
     
415. }
     
416. 
     
417. /*
     
418. *
     
419. */
     
420. static void __exit KeyPad_Exit(void)
     
421. {
     
422.     disable_irqs();
     
423.     free_irqs();
     
424.     cdev_del(&SimpleDevs);
     
425.     unregister_chrdev_region(MKDEV(Keypad_major,0),1);
     
426.     printk("button device uninstalled\n");
     
427. 
     
428. }
     
429. 
     
430. module_init(KeyPad_Init);
     
431. module_exit(KeyPad_Exit);
     
432. 
     
433. MODULE_AUTHOR("zhyh");
     
434. MODULE_DESCRIPTION("keypad driver");
     
435. MODULE_LICENSE("GPL");
     

復(fù)制代碼

---

作者: dreamice    時(shí)間: 2011-03-05 11:35
你這個(gè)很難說出什么問題，程序本身估計(jì)沒什么問題，與處理邏輯可能關(guān)系很大

---

作者: 0vk0    時(shí)間: 2011-03-07 19:49

你這個(gè)很難說出什么問題，程序本身估計(jì)沒什么問題，與處理邏輯可能關(guān)系很大
dreamice 發(fā)表于 2011-03-05 11:35

1. if(request_irq(KEY1_IRQ, button_rise_irq, IRQF_DISABLED | IRQF_SHARED, DEVICE_NAME, &a)){
   
2. 
   
3.                 printk("Could not allocate key1 IRQ:%d\n",KEY1_IRQ);
   
4. 
   
5.                 return -EINVAL;
   
6. 
   
7.    }
   
8. 
   

復(fù)制代碼

這里是否正確 ，我這里IRQF_DISABLED | IRQF_SHARED換成IRQF_TRIGGER_FALLING ｜ IRQF_DISABLED |和IRQF_TRIGGER_FALLING ｜IRQF_DISABLED ，就會(huì)出現(xiàn)insmod: cannot insert 'key.ko': invalid parameter ,我知道是dev_id這里錯(cuò)誤，但是我應(yīng)該怎么改，請大蝦賜教

---

作者: jn200002    時(shí)間: 2011-03-09 16:35
首先

struct button_irq_desc {
    int irq;
    int gpio;
};


static struct button_irq_desc button_irqs [] = {
    {IRQ_EINTx, GPx0(x)}, /* K1 */
    {xxxxxxxxxxxxxxxxx} , /*K2*/
    ...
};

然后把你的申請寫成個(gè)循環(huán)

其次，參數(shù)寫成  IRQF_SHARED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,

處理所謂按下抬起，在一個(gè)中斷處理里做就可以了。

最后，你去看看gpio_keys.c   

內(nèi)核是最好的老師，抄吧。不是非得寫的跟內(nèi)核不一樣才能彰顯代碼的個(gè)性……

---

歡迎光臨 Chinaunix (http://72891.cn/)

Powered by Discuz! X3.2

感谢您访问我们的网站，您可能还对以下资源感兴趣：

亚洲av成人无遮挡网站在线观看

<label id="zvola"></label>

^{<blockquote id="zvola"></blockquote>}<p id="zvola"></p>

<sub id="zvola"></sub>

<cite id="zvola"></cite>