GPIO驱动模型

1. 一、概述
   
2. GPIO是嵌入式系统最简单、最常用的资源了，比如点亮LED，控制蜂鸣器，输出高低电平，检测按键，等等。GPIO分输入和输出，在davinci linux中，有关GPIO的最底层的寄存器驱动，\arch\arm\mach-davinci目录下的gpio.c，这个是寄存器级的驱动，搞过单片机MCU的朋友应该比较熟悉寄存器级的驱动。
   
3. 
   
4. GPIO的驱动主要就是读取GPIO口的状态，或者设置GPIO口的状态。就是这么简单，但是为了能够写好的这个驱动，在LINUX上作了一些软件上的分层。为了让其它驱动可以方便的操作到GPIO，在LINUX里实现了对GPIO操作的统一接口，这个接口实则上就是GPIO驱动的框架，具体的实现文件为gpiolib.c在配置内核的时候，我们必须使用CONFIG_GENERIC_GPIO这个宏来支持GPIO驱动。
   
5. 
   
6. GPIO是与硬件体系密切相关的，linux提供一个模型来让驱动统一处理GPIO，即各个板卡都有实现自己的gpio_chip控制模块：request, free, input,output, get,set,irq...然后把控制模块注册到内核中，这时会改变全局gpio数组：gpio_desc[]. 当用户请求gpio时，就会到这个数组中找到，并调用这个GPIO对应的gpio_chip的处理函数。gpio实现为一组可用的 gpio_chip, 由驱动传入对应 gpio的全局序号去 request, dataout ,datain, free. 这时会调用gpio_chip中具体的实现。
   
7. gpio是一组可控件的脚，由多个寄存器同时控制。通过设置对应的寄存器可以达到设置GPIO口对应状态与功能。数据状态，输入输出方向，清零，中断（那个边沿触发）， 一般是一组（bank）一组的。
   
8. 寄存器读写函数: __raw_writel() __raw_writeb() __raw_readl() __raw_readb()
   
9. 
   
10. 二、linux 中GPIO模型的结构
    
11. //表示一个gpio口，含对应的gpio_chip.
    
12. //对于每一个gpio，都有一个gpio描述符，这个描述符包含了这个gpio所属的控制器即chip和一些标志，label等
    
13. struct gpio_desc {
    
14.     struct gpio_chip    *chip;
    
15.     unsigned long    flags;
    
16.     /* flag symbols are bit numbers */
    
17.     #define FLAG_REQUESTED 0
    
18.     #define FLAG_IS_OUT 1
    
19.     #define FLAG_RESERVED 2
    
20.     #define FLAG_EXPORT 3 /* protected by sysfs_lock */
    
21.     #define FLAG_SYSFS 4 /* exported via /sys/class/gpio/control */
    
22.     #define FLAG_TRIG_FALL 5 /* trigger on falling edge */
    
23.     #define FLAG_TRIG_RISE 6 /* trigger on rising edge */
    
24.     #define FLAG_ACTIVE_LOW 7 /* sysfs value has active low */
    
25.     #define FLAG_OPEN_DRAIN 8 /* Gpio is open drain type */
    
26.     #define FLAG_OPEN_SOURCE 9 /* Gpio is open source type */
    
27.     
    
28.     #define ID_SHIFT 16 /* add new flags before this one */ 
    
29.     #define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
    
30.     #define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
    
31.  
    
32. #ifdef CONFIG_DEBUG_FS
    
33.     const char    *label;
    
34. #endif
    
35. };
    
36. //采用了一个具有ARCH_NR_GPIOS大小的gpio描述符数组。这个描述符数组便代表了系统所有的gpio。
    
37. static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];//ARCH_NR_GPIOS=144,即系统现在有144个GPIO口
    
38. 
    
39. //static struct davinci_gpio_controller chips[DIV_ROUND_UP(DAVINCI_N_GPIO, 32)];//将144个GPIO分成每32个一组
    
40. //一组GPIO控制器结构，例如GPIO0和GPIO1是一组(共32个GPIO口)，共用一组寄存器，所以GPIO0和GPIO1荷载一起用chips[0]来控制
    
41. ///共有144个GPIO，分为4组（GPIO0~GPIO8），每组有2个banks(即GPIO0和GPIO1为1组)，每组最多可以有32个GPIO，每组的控制寄存器空间有10个。
    
42. struct davinci_gpio_controller {
    
43.     struct gpio_chip    chip;//每组对应的gpio_chip
    
44.     int            irq_base;//每组对应的中断
    
45.     spinlock_t        lock;//自旋锁
    
46.     void __iomem        *regs;//每组的寄存器地址
    
47.     void __iomem        *set_data;//设置数据寄存器地址
    
48.     void __iomem        *clr_data;//清除数据寄存器地址
    
49.     void __iomem        *in_data;//输入数据寄存器地址
    
50. }; 
    
51. 
    
52. //每一个davinci_gpio_controller结构都对应于一个gpio_chip结构，gpio_chip既可看成是davinci_gpio_controller结构的补充
    
53. //表示一个gpio controller.通过这个结构抽象化所有的GPIO源，而让板上其它的模块可以用相同的接口调用使用这些GPIO。
    
54. struct gpio_chip {
    
55.     const char    *label;
    
56.     struct device    *dev;
    
57.     struct module    *owner; 
    
58.     int    (*request)(struct gpio_chip *chip,unsigned offset);//请求gpio
    
59.     void    *free)(struct gpio_chip *chip,unsigned offset);//释放gpio
    
60.     int    (*get_direction)(struct gpio_chip *chip,unsigned offset);
    
61.     int    (*direction_input)(struct gpio_chip *chip,unsigned offset);//配置gpio为输入，返回当前gpio状态
    
62.     int    (*get)(struct gpio_chip *chip,unsigned offset);//获取gpio的状态
    
63.     int    (*direction_output)(struct gpio_chip *chip,unsigned offset, int value);//配置gpio为输出，并设置为value
    
64.     int    (*set_debounce)(struct gpio_chip *chip,unsigned offset, unsigned debounce);//设置消抖动时间，尤其是gpio按键时有用
    
65.     void    (*set)(struct gpio_chip *chip,unsigned offset, int value);//设置gpio为value值
    
66.     int    (*to_irq)(struct gpio_chip *chip,unsigned offset);//把gpio号转换为中断号
    
67.     void    (*dbg_show)(struct seq_file *s,struct gpio_chip *chip);
    
68.     int    base;// 这个gpio控制器的gpio开始编号
    
69.     u16    ngpio;//这个gpio控制器说控制的gpio数
    
70.     const char    *const *names;
    
71.     unsigned    can_sleep:1;
    
72.     unsigned    exported:1;
    
73.  
    
74. #if defined(CONFIG_OF_GPIO)
    
75.     struct device_node *of_node;
    
76.     int of_gpio_n_cells;
    
77.     int (*of_xlate)(struct gpio_chip *gc,const struct of_phandle_args *gpiospec, u32 *flags);
    
78. #endif
    
79. #ifdef CONFIG_PINCTRL
    
80.     struct list_head pin_ranges;
    
81. #endif
    
82. };
    
83. 
    
84. //GPIO寄存器结构
    
85. struct davinci_gpio_regs {
    
86.     u32 dir; // gpio方向设置寄存器 
    
87.     u32 out_data; // gpio设置为输出时，表示输出状态(0或1) 
    
88.     u32 set_data; // gpio设置为输出时，用于输出高电平 
    
89.     u32 clr_data; // gpio设置为输出时，用于输出低电平 
    
90.     u32 in_data; // gpio设置为输入时，用于读取输入值 
    
91.     u32 set_rising; // gpio中断上升沿触发设置 
    
92.     u32 clr_rising; // gpio中断上升沿触发清除 
    
93.     u32 set_falling; // gpio中断下降沿触发设置 
    
94.     u32 clr_falling; // gpio中断下降沿触发清除 
    
95.     u32 intstat; // gpio中断状态位，由硬件设置，可读取，写1时清除。 
    
96. };
    
97. 
    
98. struct gpio {
    
99.     unsigned gpio;//gpio号
    
100.     unsigned long flags;//gpio标志
     
101.     const char *label;//gpio名
     
102. };
     
103. 
     
104. 三、GPIO的初始化
     
105. 1.首先设置GPIO的管脚复用寄存器
     
106. static __init void da850_evm_init(void)
     
107. {
     
108.     //.......
     
109.     ret = davinci_cfg_reg_list(da850_gpio_test_pins);
     
110.     if (ret) 
     
111.         pr_warning("da850_evm_init: gpio test ping mux setup failed: %d\n", ret);
     
112.     //.......
     
113. }
     
114. 
     
115. 2.根据板级结构的资源初始化chips数组，此函数在系统初始化时自动调用
     
116. static struct davinci_gpio_controller chips[DIV_ROUND_UP(DAVINCI_N_GPIO, 32)];//将144个GPIO分成每32个一组
     
117. static int __init davinci_gpio_setup(void)
     
118. {
     
119.     int i, base;
     
120.     unsigned ngpio;
     
121.     struct davinci_soc_info *soc_info = &davinci_soc_info;//板级资源结构
     
122.     struct davinci_gpio_regs *regs;
     
123. 
     
124.     if (soc_info->gpio_type != GPIO_TYPE_DAVINCI)//判断GPIO类型
     
125.         return 0;
     
126. 
     
127.     ngpio = soc_info->gpio_num;//GPIO数量144
     
128.     if (ngpio == 0) {
     
129.         pr_err("GPIO setup: how many GPIOs?\n");
     
130.         return -EINVAL;
     
131.     }
     
132. 
     
133.     if (WARN_ON(DAVINCI_N_GPIO < ngpio))//DAVINCI_N_GPIO=144
     
134.         ngpio = DAVINCI_N_GPIO;
     
135. 
     
136.     gpio_base = ioremap(soc_info->gpio_base, SZ_4K);//将GPIO的寄存器物理基地址（#define DA8XX_GPIO_BASE        0x01e26000）映射到内存中
     
137.     if (WARN_ON(!gpio_base))
     
138.         return -ENOMEM;
     
139.     
     
140.     //共有144个GPIO，分为4组（GPIO0~GPIO8），每组有2个banks(即GPIO0和GPIO1为1组)，每组最多可以有32个GPIO，每组的控制寄存器空间有10个。
     
141.     //chips[0]--chips[4],base值为0,32,64,96,128,ngpio分别为：32,32,32,32,16
     
142.     for (i = 0, base = 0; base < ngpio; i++, base += 32) {
     
143.         chips[i].chip.label = "DaVinci";
     
144.         //设置操作函数
     
145.         chips[i].chip.direction_input = davinci_direction_in;
     
146.         chips[i].chip.get = davinci_gpio_get;
     
147.         chips[i].chip.direction_output = davinci_direction_out;
     
148.         chips[i].chip.set = davinci_gpio_set;
     
149. 
     
150.         chips[i].chip.base = base;//每一组开始的GPIO号
     
151.         //每组控制的GPIO个数，一般为32个
     
152.         chips[i].chip.ngpio = ngpio - base;
     
153.         if (chips[i].chip.ngpio > 32)
     
154.             chips[i].chip.ngpio = 32;
     
155. 
     
156.         spin_lock_init(&chips[i].lock);
     
157.         //找到这组GPIO的寄存器地址，初始化chips结构
     
158.         regs = gpio2regs(base);
     
159.         chips[i].regs = regs;//设置每组的寄存器
     
160.         chips[i].set_data = ?s->set_data;
     
161.         chips[i].clr_data = ?s->clr_data;
     
162.         chips[i].in_data = ?s->in_data;
     
163.         
     
164.         gpiochip_add(&chips[i].chip);//注册gpio_chip
     
165.     }
     
166.     //chips数组添加到板级资源中
     
167.     soc_info->gpio_ctlrs = chips;
     
168.     soc_info->gpio_ctlrs_num = DIV_ROUND_UP(ngpio, 32);
     
169. 
     
170.     davinci_gpio_irq_setup();//设置GPIO中断
     
171.     return 0;
     
172. }
     
173. pure_initcall(davinci_gpio_setup);//linux初始化时会自动调用
     
174. 
     
175. static struct davinci_gpio_regs __iomem __init *gpio2regs(unsigned gpio)
     
176. {
     
177.     void __iomem *ptr;
     
178.     
     
179.     //根据GPIO的基地址累加，其中基地址(gpio_base+0)是REVID(Revision ID Register)寄存器
     
180.     //(gpio_base+8)是BINTEN (GPIO Interrupt Per-Bank Enable Register)寄存器
     
181.     //所以第一组寄存器从基地址+0x10开始
     
182.     if (gpio < 32 * 1)
     
183.         ptr = gpio_base + 0x10;
     
184.     else if (gpio < 32 * 2)
     
185.         ptr = gpio_base + 0x38;
     
186.     else if (gpio < 32 * 3)
     
187.         ptr = gpio_base + 0x60;
     
188.     else if (gpio < 32 * 4)
     
189.         ptr = gpio_base + 0x88;
     
190.     else if (gpio < 32 * 5)
     
191.         ptr = gpio_base + 0xb0;
     
192.     else
     
193.         ptr = NULL;
     
194.     return ptr;
     
195. }
     
196. 
     
197. int gpiochip_add(struct gpio_chip *chip)
     
198. {
     
199.     unsigned long    flags;
     
200.     int        status = 0;
     
201.     unsigned    id;
     
202.     int        base = chip->base;
     
203.     
     
204.     //检测gpio的有效性，判断这组GPIO的起始号是否在有效范围内
     
205.     if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))&& base >= 0) {
     
206.         status = -EINVAL;
     
207.         goto fail;
     
208.     }
     
209. 
     
210.     spin_lock_irqsave(&gpio_lock, flags);
     
211.     
     
212.     //如果这组GPIO的起始号小于0，则动态的分配gpio的开始索引。
     
213.     if (base < 0) {
     
214.         base = gpiochip_find_base(chip->ngpio);//这个函数在gpiolib.c中，在gpio_desc[]中分配chip->ngpio个空间(从最后往前分配)，返回第一个index
     
215.         if (base < 0) {
     
216.             status = base;
     
217.             goto unlock;
     
218.         }
     
219.         chip->base = base;
     
220.     }
     
221. 
     
222.     //确保这些分配的gpio号没有被其他chip占用
     
223.     for (id = base; id < base + chip->ngpio; id++) {
     
224.         if (gpio_desc[id].chip != NULL) {
     
225.             status = -EBUSY;
     
226.             break;
     
227.         }
     
228.     }
     
229.     //填充gpio_desc，将该组内的每个GPIO口的gpio_desc结构和该组的控制结构chip联系起来
     
230.     if (status == 0) {
     
231.         for (id = base; id < base + chip->ngpio; id++) {
     
232.             gpio_desc[id].chip = chip;
     
233.             gpio_desc[id].flags = !chip->direction_input? (1 << FLAG_IS_OUT): 0;//设置GPIO口标志
     
234.         }
     
235.     }
     
236.     of_gpiochip_add(chip);
     
237. 
     
238. unlock:
     
239.     spin_unlock_irqrestore(&gpio_lock, flags);
     
240. 
     
241.     if (status)
     
242.         goto fail;
     
243. 
     
244.     status = gpiochip_export(chip);//与sysfs文件系统有关，这里不关心
     
245.     if (status)
     
246.         goto fail;
     
247. 
     
248.     return 0;
     
249. fail:
     
250.     /* failures here can mean systems won't boot... */
     
251.     pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",chip->base, chip->base + chip->ngpio - 1,chip->label ? : "generic");
     
252.     return status;
     
253. }
     
254. 
     
255. 四.gpio的申请
     
256. //所谓申请就是检测GPIO描述符desc->flags的FLAG_REQUESTED标志，已申请的话该标志是1，否则是0
     
257. //往往多个gpio作为一个数组来进行申请
     
258. int gpio_request_array(struct gpio *array, size_t num)
     
259. {
     
260.     int i, err;
     
261. 
     
262.     for (i = 0; i < num; i++, array++) {//遍历数组中的每一个GPIO，gpio是GPIO号，flags是输入输出标志等，label是其取一个名字
     
263.         err = gpio_request_one(array->gpio, array->flags, array->label);
     
264.         if (err)
     
265.             goto err_free;
     
266.     }
     
267.     return 0;
     
268. 
     
269. err_free:
     
270.     while (i--)
     
271.         gpio_free((--array)->gpio);
     
272.     return err;
     
273. }
     
274. 
     
275. int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
     
276. {
     
277.     int err;
     
278.     
     
279.     //gpio则为你要申请的哪一个管脚，label则是为其取一个名字。
     
280.     err = gpio_request(gpio, label);
     
281.     if (err)
     
282.         return err;
     
283. 
     
284.     if (flags & GPIOF_DIR_IN)//GPIO标志是输入
     
285.         err = gpio_direction_input(gpio);//设置管脚为输入
     
286.     else//GPIO标志是输出
     
287.         err = gpio_direction_output(gpio,(flags & GPIOF_INIT_HIGH) ? 1 : 0);//根据标志确定输出1还是0
     
288. 
     
289.     if (err)
     
290.         gpio_free(gpio);
     
291. 
     
292.     return err;
     
293. }
     
294. 
     
295. int gpio_request(unsigned gpio, const char *label)
     
296. {
     
297.     struct gpio_desc    *desc;
     
298.     struct gpio_chip    *chip;
     
299.     int            status = -EINVAL;
     
300.     unsigned long        flags;
     
301.     //屏蔽中断
     
302.     spin_lock_irqsave(&gpio_lock, flags);
     
303. 
     
304.     if (!gpio_is_valid(gpio))//判断是否有效，也就是参数的取值范围判断
     
305.         goto done;
     
306.         
     
307.     //根据GPIO号找到对应的GPIO描述符结构
     
308.     desc = &gpio_desc[gpio];
     
309.     chip = desc->chip;//找到该GPIO所在的组控制器
     
310.     if (chip == NULL)
     
311.         goto done;
     
312.         
     
313.     //计数加1
     
314.     if (!try_module_get(chip->owner))
     
315.         goto done;
     
316. 
     
317.     //这里测试并设置flags的第FLAG_REQUESTED位，如果没有被申请就返回该位的原值0
     
318.     if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
     
319.         desc_set_label(desc, label ? : "?");//设置GPIO描述符结构desc的label字段
     
320.         status = 0;
     
321.     } else {
     
322.         status = -EBUSY;
     
323.         module_put(chip->owner);
     
324.         goto done;
     
325.     }
     
326. 
     
327.     if (chip->request) {/* chip->request may sleep */
     
328.         spin_unlock_irqrestore(&gpio_lock, flags);
     
329.         status = chip->request(chip, gpio - chip->base);
     
330.         spin_lock_irqsave(&gpio_lock, flags);
     
331. 
     
332.         if (status < 0) {
     
333.             desc_set_label(desc, NULL);
     
334.             module_put(chip->owner);
     
335.             clear_bit(FLAG_REQUESTED, &desc->flags);
     
336.         }
     
337.     }
     
338. 
     
339. done:
     
340.     if (status)
     
341.         pr_debug("gpio_request: gpio-%d (%s) status %d\n",gpio, label ? : "?", status);
     
342.     spin_unlock_irqrestore(&gpio_lock, flags);
     
343.     return status;
     
344. }
     
345. 
     
346. 五.GPIO的操作
     
347. 1.设置GPIO为输出或输入
     
348. int gpio_direction_input(unsigned gpio)
     
349. {
     
350.     unsigned long        flags;
     
351.     struct gpio_chip    *chip;
     
352.     struct gpio_desc    *desc = &gpio_desc[gpio];
     
353.     int            status = -EINVAL;
     
354. 
     
355.     spin_lock_irqsave(&gpio_lock, flags);
     
356.     
     
357.     //判断GPIO号是否有效
     
358.     if (!gpio_is_valid(gpio))
     
359.         goto fail;
     
360.     //找到GPIO对应的gpio_chip结构
     
361.     chip = desc->chip;
     
362.     if (!chip || !chip->get || !chip->direction_input)
     
363.         goto fail;
     
364.     
     
365.     //确保此GPIO是在此组内，chip->base是此组GPIO的起始号，chip->ngpio是此组GPIO的个数
     
366.     gpio -= chip->base;
     
367.     if (gpio >= chip->ngpio)
     
368.         goto fail;
     
369.         
     
370.     //确保GPIO已申请
     
371.     status = gpio_ensure_requested(desc, gpio);
     
372.     if (status < 0)
     
373.         goto fail;
     
374. 
     
375.     //到这里可以确保GPIO是有效的
     
376.     spin_unlock_irqrestore(&gpio_lock, flags);
     
377. 
     
378.     might_sleep_if(chip->can_sleep);
     
379.     //status=0
     
380.     if (status) {
     
381.         status = chip->request(chip, gpio);
     
382.         if (status < 0) {
     
383.             pr_debug("GPIO-%d: chip request fail, %d\n",chip->base + gpio, status);
     
384.             goto lose;
     
385.         }
     
386.     }
     
387.     //调用底层的已经设置过的操作，这里即davinci_direction_in
     
388.     status = chip->direction_input(chip, gpio);
     
389.     if (status == 0)//返回成功
     
390.         clear_bit(FLAG_IS_OUT, &desc->flags);//清除输出标志
     
391. lose:
     
392.     return status;
     
393. fail:
     
394.     spin_unlock_irqrestore(&gpio_lock, flags);
     
395.     if (status)
     
396.         pr_debug("%s: gpio-%d status %d\n",__func__, gpio, status);
     
397.     return status;
     
398. }
     
399. 
     
400. int gpio_direction_output(unsigned gpio, int value)
     
401. {
     
402.     //.........GPIO的检查，同上函数
     
403.     
     
404.     //调用底层的已经设置过的操作，这里即davinci_direction_out
     
405.     status = chip->direction_output(chip, gpio, value);
     
406.     if (status == 0)//返回成功
     
407.         set_bit(FLAG_IS_OUT, &desc->flags);//设置输出标志
     
408. lose:
     
409.     return status;
     
410. fail:
     
411.     spin_unlock_irqrestore(&gpio_lock, flags);
     
412.     if (status)
     
413.         pr_debug("%s: gpio-%d status %d\n",__func__, gpio, status);
     
414.     return status;
     
415. }
     
416. 
     
417. //根据前边对gpio_chip结构的初始化，会调用\arch\arm\mach-davinci\gpio.c里的函数
     
418. static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
     
419. {
     
420.     return __davinci_direction(chip, offset, false, 0);
     
421. }
     
422. 
     
423. static int davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
     
424. {
     
425.     return __davinci_direction(chip, offset, true, value);
     
426. }
     
427. 
     
428. static inline int __davinci_direction(struct gpio_chip *chip,unsigned offset, bool out, int value)
     
429. {
     
430.     struct davinci_gpio_controller *d = chip2controller(chip);
     
431.     struct davinci_gpio_regs __iomem *g = d->regs;//找到此组GPIO的控制寄存器地址
     
432.     unsigned long flags;
     
433.     u32 temp;
     
434.     u32 mask = 1 << offset;
     
435. 
     
436.     spin_lock_irqsave(&d->lock, flags);
     
437.     temp = __raw_readl(&g->dir);//读出当前寄存器的输入输出方向
     
438.     
     
439.     if (out) {//为1设置输出
     
440.         temp &= ~mask;
     
441.         __raw_writel(mask, value ? &g->set_data : &g->clr_data);//确定是用于输出高电平还是输出低电平
     
442.     } 
     
443.     else {//为0设置为输入
     
444.         temp |= mask;
     
445.     }
     
446.     __raw_writel(temp, &g->dir);//写入方向寄存器
     
447.     spin_unlock_irqrestore(&d->lock, flags);
     
448. 
     
449.     return 0;
     
450. }
     
451. 
     
452. 2.获取gpio的状态
     
453. int __gpio_get_value(unsigned gpio)
     
454. {
     
455.     struct gpio_chip    *chip;
     
456. 
     
457.     chip = gpio_to_chip(gpio);
     
458.     WARN_ON(chip->can_sleep);
     
459.     return chip->get ? chip->get(chip, gpio - chip->base) : 0;//调用davinci_gpio_get
     
460. }
     
461. 
     
462. static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
     
463. {
     
464.     struct davinci_gpio_controller *d = chip2controller(chip);
     
465.     struct davinci_gpio_regs __iomem *g = d->regs;
     
466. 
     
467.     return (1 << offset) & __raw_readl(&g->in_data);
     
468. }
     
469. 
     
470. 3.设置GPIO的值
     
471. void __gpio_set_value(unsigned gpio, int value)
     
472. {
     
473.     struct gpio_chip    *chip;
     
474. 
     
475.     chip = gpio_to_chip(gpio);
     
476.     WARN_ON(chip->can_sleep);
     
477.     chip->set(chip, gpio - chip->base, value);//调用davinci_gpio_set
     
478. }
     
479. 
     
480. static void davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
     
481. {
     
482.     struct davinci_gpio_controller *d = chip2controller(chip);
     
483.     struct davinci_gpio_regs __iomem *g = d->regs;
     
484. 
     
485.     __raw_writel((1 << offset), value ? &g->set_data : &g->clr_data);
     
486. }
     
487. 
     
488. 六、GPIO驱动编写
     
489. 1.首先要申请GPIO口
     
490. 2.注册设备
     
491. 3.创建GPIO的sysfs相关文件
     
492. #define GPIO_MAJOR 199         // major device NO.
     
493. #define GPIO_MINOR 0         // minor device NO.
     
494. #define DEVICE_NAME "omapl138_gpios" /*定义设备驱动的名字，或设备节点名称*/
     
495. 
     
496. #define SET_OUTPUT_LOW 0
     
497. #define SET_OUTPUT_HIGH 1
     
498. #define GET_VALUE 2
     
499. #define SET_INPUT 3
     
500. 
     
501. static struct class *gpio_class;
     
502. static struct gpio gpio_array[] =
     
503. {
     
504.     /*{ GPIO_TO_PIN(0, 0), GPIOF_OUT_INIT_LOW,     "RTU_WDI_SIGNAL" },will request fail*/
     
505.     { GPIO_TO_PIN(0, 1), GPIOF_OUT_INIT_HIGH, "RTU_PLC_BAK_IO1"}, 
     
506.     { GPIO_TO_PIN(0, 2), GPIOF_OUT_INIT_LOW,     "RTU_CHG_EN" }, 
     
507.     { GPIO_TO_PIN(0, 3), GPIOF_IN,         "RTU_CHG_PG" }, 
     
508.     { GPIO_TO_PIN(0, 5), GPIOF_IN,         "RTU_USB_OC_OUT" }, 
     
509.     { GPIO_TO_PIN(0, 6), GPIOF_OUT_INIT_LOW,     "RTU_RUN_IND_LED" },
     
510.     { GPIO_TO_PIN(1, 10), GPIOF_IN,         "RTU_TSC_BUSY"},
     
511.     { GPIO_TO_PIN(1, 11), GPIOF_IN,        "RTU_PENIRQn" },
     
512.     { GPIO_TO_PIN(1, 12), GPIOF_OUT_INIT_LOW, "RTU_uP_Q26x_RESET" }, 
     
513.     { GPIO_TO_PIN(1, 13), GPIOF_OUT_INIT_HIGH, "RTU_uP_GPRS_PWR_EN" },
     
514.     { GPIO_TO_PIN(1, 14), GPIOF_OUT_INIT_HIGH, "RTU_uP_Q26x_ON/OFF" }, 
     
515.     { GPIO_TO_PIN(2, 1), GPIOF_OUT_INIT_LOW, "RTU_PLC_Reset" },
     
516.     { GPIO_TO_PIN(2, 2), GPIOF_OUT_INIT_LOW, "RTU_PLC_T_Reg" }, 
     
517.     { GPIO_TO_PIN(2, 4), GPIOF_OUT_INIT_LOW, "RTU_PLC_BAK_IO2" },
     
518.     { GPIO_TO_PIN(2, 5), GPIOF_OUT_INIT_LOW, "RTU_RS485_RE" }, 
     
519.     { GPIO_TO_PIN(2, 15), GPIOF_OUT_INIT_HIGH, "RTU_CHPWR_CS" },
     
520.     { GPIO_TO_PIN(3, 9), GPIOF_OUT_INIT_HIGH, "RTU_RS485_DE" }, 
     
521.     { GPIO_TO_PIN(6, 1), GPIOF_OUT_INIT_HIGH, "RTU_uP_VPIF_CLKO3" },
     
522.     { GPIO_TO_PIN(6, 9), GPIOF_IN,         "RTU_KEY_IN2" },
     
523.     { GPIO_TO_PIN(6, 11), GPIOF_IN,        "RTU_ALARM_IN5" },
     
524.     { GPIO_TO_PIN(6, 15), GPIOF_OUT_INIT_HIGH,"RTU_uP_RESETOUTn" },
     
525. };
     
526. 
     
527. static int gpio_open(struct inode *inode,struct file *file)
     
528. {
     
529.     printk(KERN_WARNING"gpio open success!\n");
     
530.     return 0;
     
531. }
     
532. 
     
533. static int gpio_release(struct inode *inode, struct file *filp)
     
534. {
     
535.   printk (KERN_ALERT "Device gpio released\n");
     
536.   return 0;
     
537. }
     
538. 
     
539. static int gpio_read(struct file*f,char *dst,size_t size,loff_t*offset)
     
540. {
     
541.     unsigned char num;
     
542.     __copy_to_user(&num,dst,1);
     
543. #ifdef DEBUG
     
544.      printk("__copy_to_user:%d\n",num);
     
545. #endif
     
546. 
     
547.     return 0;
     
548. }
     
549. 
     
550. static int gpio_write(struct file*f,const char *src,size_t size,loff_t *offset)
     
551. {
     
552.      unsigned char num;
     
553.      __copy_from_user(&num,src,1);
     
554. #ifdef DEBUG
     
555.      printk("__copy_from_user:%d\n",num);
     
556. #endif
     
557.      return 0;
     
558. 
     
559. }
     
560. 
     
561. static long gpio_ioctl(struct file *file,unsigned int cmd,unsigned long gpio)
     
562. {
     
563.     int i;
     
564.     unsigned long gpio_num = (gpio/100)*16+gpio%100;
     
565.     for (i = 0; i < ARRAY_SIZE(gpio_array); i++) {
     
566.         if(gpio_array[i].gpio == gpio_num)
     
567.             goto valid_gpio;
     
568.     }
     
569.     return -1;
     
570.         
     
571. valid_gpio:
     
572.     switch(cmd)//cmd表示应用程序传入的 GPIO 动作
     
573.     {
     
574.         case SET_OUTPUT_LOW://0
     
575.         {
     
576.             gpio_direction_output(gpio_num, 0);
     
577.             break;
     
578.         }
     
579.         case SET_OUTPUT_HIGH://1
     
580.         {
     
581.             gpio_direction_output(gpio_num, 1);
     
582.             break;
     
583.         }
     
584.         case GET_VALUE://2
     
585.         {
     
586.             return gpio_get_value(gpio_num);    
     
587.         } 
     
588.         case SET_INPUT://3
     
589.         {
     
590.             gpio_direction_input(gpio_num);
     
591.             break;
     
592.         }
     
593.         default:
     
594.         {
     
595.             printk(KERN_EMERG "GPIO command mistake!!!\n");
     
596.             break;
     
597.         }
     
598.     }
     
599.     return 0;
     
600. }
     
601.         
     
602. static const struct file_operations gpio_fops =
     
603. {
     
604.   .owner = THIS_MODULE,
     
605.   .open = gpio_open,
     
606.   .release = gpio_release,
     
607.   .read = gpio_read,
     
608.   .write = gpio_write,
     
609.   .unlocked_ioctl = gpio_ioctl,
     
610. };
     
611. 
     
612. static int __init gpio_init(void) /*内核初始化会调用该函数*/
     
613. {
     
614.     int ret;
     
615.     
     
616.     ret = gpio_request_array(gpio_array, ARRAY_SIZE(gpio_array));
     
617.     if (ret < 0) 
     
618.     {
     
619.         printk(KERN_EMERG "GPIO request failed\n");
     
620.         goto request_failed; 
     
621.     }
     
622.     
     
623.     dev_t my_dev_no;
     
624.     struct cdev *gpio_cdev;
     
625.     gpio_cdev = cdev_alloc();
     
626.     if(gpio_cdev == NULL)
     
627.     {
     
628.         printk(KERN_EMERG "Cannot alloc cdev\n");
     
629.         goto request_failed;
     
630.     }
     
631.     cdev_init(gpio_cdev,&gpio_fops);
     
632.     gpio_cdev->owner=THIS_MODULE;
     
633.     int result=alloc_chrdev_region(&my_dev_no,0,1,DEVICE_NAME); 
     
634.     if(result < 0)
     
635.     {
     
636.         printk(KERN_EMERG "alloc_chrdev_region failed\n");
     
637.         goto request_failed;
     
638.     }
     
639.     ret=cdev_add(gpio_cdev,my_dev_no,1); 
     
640.     
     
641.     
     
642.   ret = register_chrdev(GPIO_MAJOR, DEVICE_NAME, &gpio_fops);//驱动字符设备
     
643.      if(ret < 0)
     
644.      {
     
645.     printk(KERN_EMERG "GPIO register failed\n");
     
646.     goto request_failed;
     
647.      }
     
648.     
     
649.     //在sysfs文件系统下创建一个类
     
650.   gpio_class = class_create(THIS_MODULE, DEVICE_NAME);
     
651.   //device_create-->device_create_vargs-->device_register创建相应的sysfs文件(如dev文件)，用于udev根据sysfs文件系统下的dev文件创建设备节点
     
652.     device_create(gpio_class, NULL, MKDEV(GPIO_MAJOR, GPIO_MINOR), NULL, DEVICE_NAME);
     
653.     return ret;
     
654.     
     
655. request_failed:
     
656.     gpio_free_array(gpio_array, ARRAY_SIZE(gpio_array)); 
     
657.     return ret;
     
658. }
     
659. 
     
660. static void __exit gpio_exit(void)
     
661. {
     
662.     device_destroy(gpio_class, MKDEV(GPIO_MAJOR, GPIO_MINOR));
     
663.   class_unregister(gpio_class);
     
664.   class_destroy(gpio_class);
     
665.   unregister_chrdev(GPIO_MAJOR, DEVICE_NAME);
     
666. }
     
667. 
     
668. module_init(gpio_init);
     
669. module_exit(gpio_exit);
     
670. MODULE_LICENSE("GPL");
     
671. MODULE_VERSION ("v2.0");
     
672. MODULE_AUTHOR("wbl <>");
     
673. MODULE_DESCRIPTION("OMAPL138 GPIO driver");