cubieboard的uboot的GPIO的驱动详解

毅哥

转发自我的博客：http://blog.sina.com.cn/s/blog_b5020b670101ft49.html

uboot的GPIO相当简单，其就是三层结构。分别为： 1、顶层接口层，其只定义了通用的接口，并不负责实现，实现是我们具体根据具体的芯片来实现的。
2、中间接口实现层，用具体的板子的GPIO来实现顶层的接口
3、 底层具体芯片GPIO的实现层 。

现在具体分析：
顶层接口层

int gpio_request(unsigned gpio, const char *label); //申请GPIO资源
int gpio_free(unsigned gpio); //释放申请的GPIO资源
int gpio_direction_input(unsigned gpio); //设置GPIO为输入模式
int gpio_direction_output(unsigned gpio, int value); //设置GPIO为输出模式
int gpio_get_value(unsigned gpio); //得到GPIO的值
int gpio_set_value(unsigned gpio, int value);//设置GPIO的值
说明：unsigned gpio为逻辑号，虽然和实际的物理GPIO地址有一定的关系，但并不是实际的物理GPIO地址。

中间接口实现层：
用具体的芯片的GPIO来实现其顶层接口

int gpio_request(unsigned gpio, const char *label)
{
return 0;
}

int gpio_free(unsigned gpio)
{
return 0;
}

int gpio_direction_input(unsigned gpio)
{
sunxi_gpio_set_cfgpin(gpio, SUNXI_GPIO_INPUT);

return sunxi_gpio_input(gpio);
}

int gpio_direction_output(unsigned gpio, int value)
{
sunxi_gpio_set_cfgpin(gpio, SUNXI_GPIO_OUTPUT);

return sunxi_gpio_output(gpio, value);
}

int gpio_get_value(unsigned gpio)
{
return sunxi_gpio_input(gpio);
}

int gpio_set_value(unsigned gpio, int value)
{
return sunxi_gpio_output(gpio, value);
}

底层具体芯片GPIO的实现层：
在实现的时候，其用了一个小技巧，其目的是把GPIO的物理寄存器放到结构体里面来，从而把物理的地址操作转换为数据结构的操作。
其实现如下：
把SUNXI_PIO_BASE 强制转换为sunxi_gpio_reg *指针来实现。
#define SUNXI_PIO_BASE 0x01c20800



struct sunxi_gpio {
u32 cfg[4];
u32 dat;
u32 drv[2];
u32 pull[2];
};


struct sunxi_gpio_int {
u32 cfg[3];
u32 ctl;
u32 sta;
u32 deb;
};

struct sunxi_gpio_reg {
struct sunxi_gpio gpio_bank[9];
u8 res[0xbc];
struct sunxi_gpio_int gpio_int;
};


我们实现具体的芯片的GPIO的操作的思想是：
使用逻辑符号unsigned gpio，通过SUNXI_PIO_BASE 强制转换为sunxi_gpio_reg *指针的指针来操作相关寄存器。

但是逻辑符号unsigned gpio要通过SUNXI_PIO_BASE 强制转换为sunxi_gpio_reg *指针的指针来操作相关寄存器，必须要解决一个问题，即如何在众多的寄存器的中，找到指定的那个寄存器，并且在该寄存器上找到指定的那些相关位。
即gpio---->bank------>bank中的offset

这个映射关系和具体的芯片有关。
这里只讨论全志的a10芯片。




后面的写不了了，想看完整版的请看我的博客：http://blog.sina.com.cn/s/blog_b5020b670101ft49.html

醉月

LZ你好！我今天也在看全志A20 的gpio驱动。
【linux-3.4-cb2】
目录： driver/gpio/gpio-sunxi.c

------------------------
在这个驱动中，我看它使用的是platform平台设备相关编程。
-------------------------
由于是新手，其中有个疑点，还希望LZ能帮忙解答下。
--------------------------
首先，贴下代码：

1. static int __init sunxi_gpio_init(void)
   
2. {
   
3.         int err = 0;
   
4.         err = platform_device_register(&sunxi_gpio_device);
   
5.         if (err)
   
6.                 goto exit;
   
7. 
   
8.         return platform_driver_register(&sunxi_gpio_driver);
   
9. 
   
10. exit:
    
11.         return err;
    
12. }
    
13. subsys_initcall(sunxi_gpio_init);

复制代码

------------------------

1. static int __devinit sunxi_gpio_probe(struct platform_device *pdev)
   
2. {
   
3.         int i;
   
4.         int err = 0;
   
5.         int names_size = 0;
   
6.         int gpio_used = 0;
   
7.         int gpio_num = 0;
   
8.         struct sunxi_gpio_data *gpio_i = NULL;
   
9.         struct sunxi_gpio_data *gpio_data = NULL;
   
10.         struct sunxi_gpio_chip *sunxi_chip = NULL;
    
11.         char **pnames = NULL;
    
12. 
    
13.         /* parse script.bin for [gpio_para] section
    
14.            gpio_used/gpio_num/gpio_pin_x */
    
15. 
    
16.         pr_info("sunxi_gpio driver init ver %s\n", SUNXI_GPIO_VER);
    
17. 
    
18.        
    
19.         err = script_parser_fetch("gpio_para", "gpio_used", &gpio_used,
    
20.                                         sizeof(gpio_used)/sizeof(int));
    
21. 
    
22.         if (err) {
    
23.                 /* Not error - just info */
    
24.                 pr_info("%s can't find script.bin '[gpio_para]' 'gpio_used'\n",
    
25.                         __func__);
    
26.                 return err;
    
27.         }
    
28. 
    
29. 
    
30. 
    
31.         if (!gpio_used) {
    
32.                 pr_info("%s gpio_used is false. Skip gpio initialization\n",
    
33.                         __func__);
    
34.                 err = 0;
    
35.                 return err;
    
36.         }
    
37. 
    
38. 
    
39.         err = script_parser_fetch("gpio_para", "gpio_num", &gpio_num,
    
40.                                         sizeof(gpio_num)/sizeof(int));
    
41.         if (err) {
    
42.                 pr_err("%s script_parser_fetch '[gpio_para]' 'gpio_num' err\n",
    
43.                         __func__);
    
44.                 return err;
    
45.         }
    
46. 
    
47.         if (!gpio_num) {
    
48.                 pr_info("%s gpio_num is none. Skip gpio initialization\n",
    
49.                         __func__);
    
50.                 err = 0;
    
51.                 return err;
    
52.         }
    
53. 
    
54.        
    
55. 
    
56.         /* Allocate memory for sunxi_gpio_chip + data/names array */
    
57.         sunxi_chip = kzalloc(sizeof(struct sunxi_gpio_chip) +
    
58.                                 sizeof(struct sunxi_gpio_data) * gpio_num,
    
59.                                 GFP_KERNEL);
    
60. 
    
61.        
    
62.         gpio_data = (void *)sunxi_chip + sizeof(struct sunxi_gpio_chip);
    
63. 
    
64.        
    
65. 
    
66.         /* Allocate memory for variable array of fixed size strings */
    
67.         /* in one chunk. This is to avoid 1+gpio_num kzalloc calls */
    
68.         names_size = sizeof(*pnames) * gpio_num +
    
69.                      sizeof(char) * MAX_GPIO_NAMELEN * gpio_num;
    
70. 
    
71. 
    
72.         pnames = kzalloc(names_size, GFP_KERNEL);
    
73. 
    
74.        
    
75.         for (i = 0; i < gpio_num; i++) {
    
76.                 pnames[i] = (void *)pnames + sizeof(*pnames) * gpio_num +
    
77.                                 i * MAX_GPIO_NAMELEN;
    
78.         }
    
79. 
    
80.         if ((!pnames) || (!sunxi_chip)) {
    
81.                 pr_err("%s kzalloc failed\n", __func__);
    
82.                 err = -ENOMEM;
    
83.                 goto exit;
    
84.         }
    
85. 
    
86.         /* Parse gpio_para/pin script data */
    
87.         gpio_i = gpio_data;
    
88.        
    
89.         for (i = 0; i < gpio_num; i++) {
    
90. 
    
91.                 sprintf(gpio_i->pin_name, "gpio_pin_%d", i+1);
    
92.                 err = script_parser_fetch("gpio_para", gpio_i->pin_name,
    
93.                                         (int *)&gpio_i->info,
    
94.                                         sizeof(script_gpio_set_t));
    
95. 
    
96.                 if (err) {
    
97.                         pr_err("%s script_parser_fetch '[gpio_para]' '%s' err\n",
    
98.                                 __func__, gpio_i->pin_name);
    
99.                         break;
    
100.                 }
     
101. 
     
102.                 gpio_i++;
     
103.         }
     
104.        
     
105. /*   i/o的物理地址映射到核心虚拟地址空间内 */
     
106.         sunxi_chip->gaddr = ioremap(PIO_BASE_ADDRESS, PIO_RANGE_SIZE);
     
107. 
     
108.        
     
109.         if (!sunxi_chip->gaddr) {
     
110.                 pr_err("Can't request gpio registers memory\n");
     
111.                 err = -EIO;
     
112.                 goto unmap;
     
113.         }
     
114. 
     
115.         sunxi_chip->dev                = &pdev->dev;
     
116.         sunxi_chip->data        = gpio_data;
     
117.         sunxi_chip->chip        = template_chip;
     
118.         sunxi_chip->chip.ngpio        = gpio_num;
     
119.         sunxi_chip->chip.dev        = &pdev->dev;
     
120.         sunxi_chip->chip.label        = "A1X_GPIO";
     
121.         sunxi_chip->chip.base        = 1;
     
122.         sunxi_chip->chip.names        = (const char *const *)pnames;
     
123.         sunxi_chip->irq_base        = -1;
     
124. 
     
125.         /* configure EINTs for the detected SoC */
     
126.         sunxi_gpio_eint_probe();
     
127. 
     
128.         /* This needs additional system irq numbers (NR_IRQ=NR_IRQ+EINT_NUM) */
     
129.         if (EINT_NUM > 0) {
     
130.                 sunxi_chip->irq_base = irq_alloc_descs(-1, 0, EINT_NUM, 0);
     
131.                 if (sunxi_chip->irq_base < 0) {
     
132.                         pr_err("Couldn't allocate virq numbers. GPIO irq support disabled\n");
     
133.                         err = sunxi_chip->irq_base;
     
134.                 }
     
135.         } else
     
136.                 pr_info("GPIO irq support disabled in this platform\n");
     
137. 
     
138. /*自旋锁初始化*/
     
139.         spin_lock_init(&sunxi_chip->irq_lock);
     
140. 
     
141. /*irq init*/
     
142.         sunxi_gpio_irq_init(sunxi_chip);
     
143. 
     
144. /*request irq*/
     
145.         if (sunxi_chip->irq_base >= 0) {
     
146.                 err = request_irq(GPIO_IRQ_NO, sunxi_gpio_irq_handler,
     
147.                                   IRQF_SHARED, "sunxi-gpio", sunxi_chip);
     
148.                 if (err) {
     
149.                         pr_err("Can't request irq %d\n", GPIO_IRQ_NO);
     
150.                         goto irqchip;
     
151.                 }
     
152.         }
     
153. 
     
154. /* register a gpio_chip*/
     
155.         err = gpiochip_add(&sunxi_chip->chip);
     
156. 
     
157.         if (err < 0)
     
158.                 goto irqhdl;
     
159. /*save gpio  private data,we cat get these data like this : platform_get_drvdata()*/
     
160.         platform_set_drvdata(pdev, sunxi_chip);
     
161.         return 0;
     
162. 
     
163. irqhdl:
     
164.         if (sunxi_chip->irq_base >= 0)
     
165.                 free_irq(GPIO_IRQ_NO, sunxi_chip);
     
166. irqchip:
     
167.         sunxi_gpio_irq_remove(sunxi_chip);
     
168.         if (sunxi_chip->irq_base >= 0)
     
169.                 irq_free_descs(sunxi_chip->irq_base, EINT_NUM);
     
170. unmap:
     
171.         iounmap(sunxi_chip->gaddr);
     
172. exit:
     
173.         kfree(sunxi_chip);
     
174.         kfree(pnames);
     
175. 
     
176.         return err;
     
177. }
     

复制代码

在这里，我只是追到了一些资源的申请和注册，在  /sys/class/gpio-sw/  目录下可以使用open()  wrte() read() ioctl() 这些函数来读取和操作GPIO的数据，但是，我在该驱动中并没发现这些函数的底层实现，这是个什么缘由呢？

谢谢！