PIO

Pacer

要实现一个LED的状态显示灯(显示系统状态的),文档上是对PIOA进行操作,但是目前不知道如何在C中实现它,读源代一点头续都没有,可以说是看不明白或者找不着在什么地方有相关的操作,请帮忙指点一下.

jarodwang

楼主给的信息量太少了啊，说说PIOA是什么啊，寄存器名吗？有代码的话贴上来给大家看看啊。

crazyCat

1.   //*****************************************************   
   
2. //编译进内核的程序，实现驱动程序的注册和对数码管的控制  //*****************************************************   
   
3. #include <linux/types.h>  
   
4. #include <linux/errno.h>  
   
5. #include <linux/miscdevice.h>  
   
6. #include <linux/slab.h>  
   
7. #include <linux/ioport.h>  
   
8. #include <linux/fcntl.h>  
   
9. #include <linux/mc146818rtc.h>  
   
10. #include <linux/netdevice.h>  
    
11. #include <linux/sched.h>   
    
12. #include <asm/io.h>  
    
13. #include <asm/uaccess.h>  
    
14. #include <asm/system.h>  
    
15. #include <linux/delay.h>   
    
16. /*定义External I/O control register*/  
    
17. #define EXT1CON                 0XFFF0101C    /*定义External I/O基地址*/  
    
18. #define EXT1BANK                0XC6040000   
    
19. void sleep(int i);   
    
20. /*实现LED设备的写操作*/  static int  led_write(struct inode *inode,struct file *file,int n);   
    
21. /*实现LED设备的打开操作*/  static int  led_open(struct inode *inode,struct file *file );   
    
22. /*标志着LED设备是否打开，默认为打开*/  
    
23. static int led_opened = 1;   
    
24. /*定义数码管上显示0到9时对应的向External I/O写入的数据*/  
    
25. #define DIGIT_9         0x90   
    
26. #define DIGIT_8         0x80   
    
27. #define DIGIT_7         0xF8  
    
28. #define DIGIT_6         0X82   
    
29. #define DIGIT_5         0X92   
    
30. #define DIGIT_4         0X99   
    
31. #define DIGIT_3         0XB0   
    
32. #define DIGIT_2         0XA4   
    
33. #define DIGIT_1         0XF9   
    
34. #define DIGIT_0         0XC0      
    
35. /*将对低层的操作映射为对文件的操作*/  
    
36. static struct file_operations led_fops = {      
    
37. open:                 led_open,         
    
38. write:            led_write,   };            
    
39. /*完成对LED驱动设备的注册*/  
    
40. int led_init(void)   {  
    
41. int result;         
    
42. result=register_chrdev(253, "myled", &led_fops);        
    
43. return(result);  
    
44. }   
    
45. void sleep(int i)  {            
    
46. int b;                    
    
47. for( b = 0 ; b <1000000*i ; b++ )            
    
48. ( )        ;  
    
49. }   
    
50. /*打开设备为I/O寄存器符赋值*/  
    
51. static int  led_open(struct inode *inode,struct file *file)  {           
    
52. * ((volatile unsigned int *)EXT1CON) = 0x8C087FFE;      
    
53. if(!led_opened)       {         
    
54. return -ENXIO;      
    
55. }else{
    
56. return 0;        
    
57. }   
    
58. }   
    
59. /*为External I/O赋值，实现LED设备的写操作*/  
    
60. static int  led_write(struct inode *inode,struct file *file,int n)  {        
    
61. unsigned int tmp ,i;               
    
62. unsigned int ctrl [] = { DIGIT_0, DIGIT_1, DIGIT_2, DIGIT_3, DIGIT_4, DIGIT_5, DIGIT_6, DIGIT_7, DIGIT_8, DIGIT_9};                                       
    
63. if( (n>=0) && (n<(sizeof(ctrl)/sizeof(unsigned char))) )          {            
    
64. tmp = 0;              
    
65. for(i = 0;i<4;i++)              {                   
    
66. tmp <<= 8;                  
    
67. tmp += ctrl[n];                             
    
68. }
    
69. *((volatile unsigned int *)EXT1BANK )= tmp;                 
    
70. }  
    
71. }   
    

复制代码

[ 本帖最后由 crazyCat 于 2006-12-6 13:17 编辑 ]

Pacer

我是个新手,这几天在接手移植一块板子,这是我参照的一个板子,对GPIO的操作,不过我有些看不明白,即使参照它的手册也是不明白,我想在这里找一些线索,不过没有头绪啊.感觉笨得要死.新板子上的灯是对四个PIO引进行操作.

1. 
   
2. 
   
3. #define AT91_PIOA       0x400
   
4. #define AT91_PIOB       0x600
   
5. #define AT91_PIOC       0x800
   
6. 
   
7. static const u32 pio_controller_offset[4] = {
   
8.         AT91_PIOA,   
   
9.         AT91_PIOB,
   
10.         AT91_PIOC,
    
11. };
    
12. 
    
13. 
    
14. /*--------------------------------------------------------------------------*/
    
15. 
    
16. /* Not all hardware capabilities are exposed through these calls; they
    
17. * only encapsulate the most common features and modes.  (So if you
    
18. * want to change signals in groups, do it directly.)
    
19. *
    
20. * Bootloaders will usually handle some of the pin multiplexing setup.
    
21. * The intent is certainly that by the time Linux is fully booted, all
    
22. * pins should have been fully initialized.  These setup calls should
    
23. * only be used by board setup routines, or possibly in driver probe().
    
24. *
    
25. * For bootloaders doing all that setup, these calls could be inlined
    
26. * as NOPs so Linux won't duplicate any setup code
    
27. */
    
28. 
    
29. 
    
30. /*
    
31. * mux the pin to the corresponding internal peripheral role.
    
32. */
    
33. 
    
34. 
    
35. void at91_gpio_periph_enable (unsigned int pio_va_base,
    
36.                               unsigned char pin,
    
37.                               unsigned char peripheral,
    
38.                               unsigned char use_pullup,
    
39.                               unsigned char use_filter)
    
40. {
    
41.         unsigned int mask = pin_to_mask(pin);
    
42. 
    
43.         writel(mask, (pio_va_base + PIO_IDR));       
    
44. 
    
45.         if(use_pullup)
    
46.                 writel(mask, (pio_va_base + PIO_PPUER));
    
47.         else
    
48.                 writel(mask, (pio_va_base + PIO_PPUDR));
    
49. 
    
50.         switch (peripheral)
    
51.         {
    
52.                 case 1:
    
53.                         writel(mask, (pio_va_base + PIO_BSR));
    
54.                 break;
    
55.                 case 0:
    
56.                 default:
    
57.                         writel(mask, (pio_va_base + PIO_ASR));
    
58.                 break;
    
59.         }
    
60. 
    
61.         /* The Peripheral controls the pin (pio disabled) */
    
62.         writel(mask, (pio_va_base + PIO_PDR));
    
63. }
    
64. 
    
65. 
    
66. EXPORT_SYMBOL(at91_gpio_periph_enable);
    
67. 
    
68. void at91_gpio_configure (unsigned int pio_va_base,
    
69.                           unsigned char pin,
    
70.                           unsigned char in_out,
    
71.                           unsigned char use_pullup,
    
72.                           unsigned char use_filter)
    
73. {
    
74.         unsigned int mask = pin_to_mask(pin);
    
75.        
    
76.         /* The PIO controls the pin (periph disabled) */
    
77.         writel(mask, (pio_va_base + PIO_PER));
    
78. 
    
79.         if(in_out) { /* the pin is an input */
    
80.                 writel(mask, (pio_va_base + PIO_ODR));
    
81.         }
    
82.         else {       /* the pin is an output */
    
83.                 writel(mask, (pio_va_base + PIO_OER));
    
84.         }
    
85. 
    
86.         if(use_pullup)
    
87.                 writel(mask, (pio_va_base + PIO_PPUER));
    
88.         else
    
89.                 writel(mask, (pio_va_base + PIO_PPUDR));
    
90. }
    
91. 
    
92. 
    
93. EXPORT_SYMBOL(at91_gpio_configure);
    
94. 
    
95. void at91_gpio_set_level (unsigned int pio_va_base, unsigned int pin, unsigned int level)
    
96. {
    
97.         unsigned int mask = pin_to_mask(pin);
    
98. 
    
99.         // This is just a sanity action to force a pin
    
100.         // to output before driving it.
     
101.         writel(mask, pio_va_base + PIO_PER);
     
102.         writel(mask, pio_va_base + PIO_OER);
     
103.        
     
104.         if (level)
     
105.           writel(mask, pio_va_base + PIO_SODR);
     
106.         else // pin should be cleared
     
107.           writel(mask, pio_va_base + PIO_CODR);
     
108. 
     
109. }
     
110. 
     
111. 
     
112. EXPORT_SYMBOL(at91_gpio_set_level);
     
113. 
     
114. unsigned int at91_gpio_get_level (unsigned int pio_va_base, unsigned int pin)
     
115. {
     
116.         unsigned int mask = pin_to_mask(pin);
     
117. 
     
118. 
     
119.         // This is just a sanity action to force a pin
     
120.         // to input before reading it.
     
121.         writel(mask, pio_va_base + PIO_PER);
     
122.         writel(mask, pio_va_base + PIO_ODR);
     
123. 
     
124.         return (readl(pio_va_base + PIO_PDSR) & mask);
     
125. }
     
126. 
     
127. 
     
128. EXPORT_SYMBOL(at91_gpio_get_level);
     
129. 
     
130. 
     
131. int at91_device_pio_setup (struct at91_pioline *pPin) {
     
132. 
     
133.         if(!pPin) {
     
134.                 printk(KERN_ERR "Define the PIO muxing of this device first !!\n");
     
135.                 return -ENODEV;
     
136.         }
     
137. 
     
138.         /* Sets all the pio muxing of the corresponding device as defined in its platform_data struct */
     
139.         while (pPin->pin_name)
     
140.         {
     
141.                 if ((pPin->pio_ctrl_id != AT91C_ID_PIOA) &&
     
142.                     (pPin->pio_ctrl_id != AT91C_ID_PIOB) &&
     
143.                     (pPin->pio_ctrl_id != AT91C_ID_PIOC)) {
     
144.                         printk(KERN_ERR "Bad PIO controler ID %u, correct values are {%u, %u ,%u}\n",
     
145.                                pPin->pio_ctrl_id, AT91C_ID_PIOA, AT91C_ID_PIOB, AT91C_ID_PIOC);
     
146.                         return -ENODEV;
     
147.                 }
     
148.                 if (pPin->type == TYPE_PERIPH) // PIN is in PERIPH mode
     
149.                         at91_gpio_periph_enable(pPin->pio_ctrl_va_base, pPin->pin_num, pPin->direction, pPin->use_pullup, pPin->use_filter);
     
150.                 else // PIN is in PIO mode
     
151.                         at91_gpio_configure(pPin->pio_ctrl_va_base, pPin->pin_num, pPin->direction, pPin->use_pullup, pPin->use_filter);
     
152.                 pPin++;
     
153.         }
     
154. 
     
155.         return 0;
     
156. }
     
157. 
     
158. EXPORT_SYMBOL(at91_device_pio_setup);
     
159. 
     
160. static inline void __iomem *pin_to_controller(unsigned pin)
     
161. {
     
162.         void __iomem *sys_base = (void __iomem *) AT91C_VA_BASE_SYS;
     
163. 
     
164.         pin -= PIN_BASE;
     
165.         pin /= 32;
     
166.         return sys_base + pio_controller_offset[pin];
     
167. 
     
168.         return NULL;
     
169. }
     
170. 
     
171. static inline unsigned pin_to_mask_o(unsigned pin)
     
172. {
     
173.         pin -= PIN_BASE;
     
174.         return 1 << (pin % 32);
     
175. }
     
176. 
     
177. /*
     
178. * read the pin's value (works even if it's not muxed as a gpio).
     
179. */
     
180. int at91_get_gpio_value(unsigned pin)
     
181. {
     
182.         void __iomem    *pio = pin_to_controller(pin);
     
183.         unsigned        mask = pin_to_mask_o(pin);
     
184.         u32             pdsr;
     
185. 
     
186.         if (!pio)
     
187.                 return -EINVAL;
     
188.         pdsr = __raw_readl(pio + PIO_PDSR);
     
189.         return (pdsr & mask) != 0;
     
190. }
     
191. EXPORT_SYMBOL(at91_get_gpio_value);
     
192. 
     
193. /*--------------------------------------------------------------------------*/
     
194. 
     
195. 
     
196. /* Several AIC controller irqs are dispatched through this GPIO handler.
     
197. * To use any AT91_PIN_* as an externally triggered IRQ, first call
     
198. * at91_set_gpio_input() then maybe enable its glitch filter.
     
199. * Then just request_irq() with the pin ID; it works like any ARM IRQ
     
200. * handler, though it always triggers on rising and falling edges.
     
201. *
     
202. * Alternatively, certain pins may be used directly as IRQ0..IRQ6 after
     
203. * configuring them with at91_set_a_periph() or at91_set_b_periph().
     
204. * IRQ0..IRQ6 should be configurable, e.g. level vs edge triggering.
     
205. */
     
206. 
     
207. static void gpio_irq_mask(unsigned pin)
     
208. {
     
209.         void __iomem    *pio = pin_to_controller(pin);
     
210.         unsigned        mask = pin_to_mask_o(pin);
     
211. 
     
212.         if (pio)
     
213.                 __raw_writel(mask, pio + PIO_IDR);
     
214. }
     
215. 
     
216. static void gpio_irq_unmask(unsigned pin)
     
217. {
     
218.         void __iomem    *pio = pin_to_controller(pin);
     
219.         unsigned        mask = pin_to_mask_o(pin);
     
220. 
     
221.         printk("gpio_irq_unmask %d %x\n", (int) pin, (int) pio);
     
222.         if (pio)
     
223.                 __raw_writel(mask, pio + PIO_IER);
     
224. }
     
225. 
     
226. static int gpio_irq_type(unsigned pin, unsigned type)
     
227. {
     
228.         return (type == IRQT_BOTHEDGE) ? 0 : -EINVAL;
     
229. }
     
230. 
     
231. static struct irqchip gpio_irqchip = {
     
232.         .mask           = gpio_irq_mask,
     
233.         .unmask         = gpio_irq_unmask,
     
234.         .set_type       = gpio_irq_type,
     
235. };
     
236. 
     
237. static void gpio_irq_handler(unsigned irq, struct irqdesc *desc, struct pt_regs *regs)
     
238. {
     
239.         unsigned        pin;
     
240.         struct irqdesc  *gpio;
     
241.         void __iomem    *pio;
     
242.         u32             isr;
     
243. 
     
244.         pio = (void __force __iomem *) desc->chipdata;
     
245. 
     
246.         /* temporarily mask (level sensitive) parent IRQ */
     
247.         desc->chip->ack(irq);
     
248.         for (;;) {
     
249.                 isr = __raw_readl(pio + PIO_ISR) & __raw_readl(pio + PIO_IMR);
     
250.                 if (!isr)
     
251.                         break;
     
252. 
     
253.                 pin = (unsigned) desc->data;
     
254.                 gpio = &irq_desc[pin];
     
255. 
     
256.                 while (isr) {
     
257.                         if (isr & 1)
     
258.                                 gpio->handle(pin, gpio, regs);
     
259.                         pin++;
     
260.                         gpio++;
     
261.                         isr >>= 1;
     
262.                 }
     
263.         }
     
264.         desc->chip->unmask(irq);
     
265.         /* now it may re-trigger */
     
266. }
     
267. 
     
268. /* call this from board-specific init_irq */
     
269. void __init at91_gpio_irq_setup(unsigned banks)
     
270. {
     
271.         unsigned        pioc, pin, id;
     
272. 
     
273.         if (banks > 4)
     
274.                 banks = 4;
     
275.         for (pioc = 0, pin = PIN_BASE, id = AT91_ID_PIOA;
     
276.                         pioc < banks;
     
277.                         pioc++, id++) {
     
278.                 void __iomem    *controller;
     
279.                 unsigned        i;
     
280. 
     
281.                 controller = (void __iomem *) AT91C_VA_BASE_SYS + pio_controller_offset[pioc];
     
282.                 __raw_writel(~0, controller + PIO_IDR);
     
283. 
     
284.                 set_irq_data(id, (void *) pin);
     
285.                 set_irq_chipdata(id, (void __force *) controller);
     
286. 
     
287.                 for (i = 0; i < 32; i++, pin++) {
     
288.                         set_irq_chip(pin, &gpio_irqchip);
     
289.                         set_irq_handler(pin, do_simple_IRQ);
     
290.                         set_irq_flags(pin, IRQF_VALID);
     
291.                 }
     
292. 
     
293.                 set_irq_chained_handler(id, gpio_irq_handler);
     
294.                 printk("set_irq_chained_handler %d\n", id);
     
295. 
     
296.                 /* enable the PIO peripheral clock */
     
297.                 at91_enable_periph_clock(id);
     
298.                 //at91_sys_write(AT91_PMC_PCER, 1 << id);
     
299.         }
     
300.         pr_info("AT91: %d gpio irqs in %d banks\n", pin - PIN_BASE, banks);
     
301. }
     

复制代码