转：全志A20 GPIO 总结文档

链接：

http://blog.csdn.net/chwenj/article/details/42190745

1. /*
2. * author:          chwenj@gmail.com.
3. * Agreement:       GPL.
4. */
5. #include <stdio.h>
6. #include <stdlib.h>
7. #include <sys/types.h>
8. #include <sys/stat.h>
9. #include <fcntl.h>
10. #define GPIO_SET      0xAC
11. #define GPIO_GET      0xAB
12. #define DEVICE_FILE "/dev/gpio_cdev"
13. typedef struct {
14. unsigned char count;  //GPIO序列
15. unsigned char data;   //GPIO电平状态
16. } gpio_userspace_t;
17. /*main*/
18. int main(/* int argc, char **argv */)
19. {
20. /*open*/
21. int gpio_fd, ret;
22. gpio_fd = open(DEVICE_FILE, O_RDWR);    //读写权限打开文件
23. if (gpio_fd < 0) {
24. printf("gpio device fail to open.\n");
25. return -1;
26. }
27. printf("%s opend.\n", DEVICE_FILE);
28. #if 1
29. /*write*/
30. gpio_userspace_t write_gpio;
31. write_gpio.count = 5;   //GPIO序列号
32. write_gpio.data = 1;    //GPIO电平值
33. printf("write: count = %d , data = %d.\n", write_gpio.count, write_gpio.data);
34. ret = write(gpio_fd, &write_gpio, sizeof(gpio_userspace_t));
35. if (ret < 0) {
36. printf("%s fail to write.\n", DEVICE_FILE);
37. return -1;
38. }
39. #endif
40. /*ioctl*/
41. gpio_userspace_t ioctl_gpio;
42. ioctl_gpio.data = 0xff;     //level:0xff
43. ioctl_gpio.count = 5;       //pin:4
44. ret = ioctl(gpio_fd, GPIO_SET, &ioctl_gpio);
45. if (ret < 0) {
46. printf("ioctl: ioctl fail.\n");
47. return -1;
48. }
49. /*read*/
50. gpio_userspace_t read_gpio;
51. ret = read(gpio_fd, &read_gpio, sizeof(gpio_userspace_t));
52. if (ret < 0) {
53. printf("read: fail to read.\n");
54. return -1;
55. }
56. printf("read: count = %d, data = %d.\n", read_gpio.count, read_gpio.data);
57. /*close*/
58. close(gpio_fd);
59. printf("%s close.\n", DEVICE_FILE);
60. return 0;
61. }

1. #include <linux/fs.h>
2. #include <linux/types.h>
3. #include <linux/module.h>
4. #include <linux/errno.h>
5. #include <linux/kernel.h>
6. #include <linux/init.h>
7. #include <linux/cdev.h>
8. #include <linux/platform_device.h>
9. #include <linux/utsname.h>
10. #include <asm/uaccess.h>
11. #include <asm/io.h>
12. #include <mach/sys_config.h>
13. #include <mach/includes.h>
14. #include <linux/gpio.h>
15. #include <linux/delay.h>
16. /**********************************************************/
17. #define GPIO_SET      0xAC
18. #define GPIO_GET      0xAB
19. /**********************************************************/
20. script_item_u *gpio_list = NULL;
21. //gpio_userspace_t 和 gpio_pdata_t 在序列上是一一对应的关系.
22. typedef struct {
23. unsigned char count;      //IO序列：0，1，2，..., 19.
24. unsigned char data;       //IO电平.
25. } gpio_userspace_t;
26. typedef struct {
27. struct gpio_config gpio;
28. char gpio_name[32];
29. int gpio_cnt;
30. } gpio_pdata_t;
31. typedef struct {
32. //debug tag for printk
33. #define __DEBUG_TAG__
34. #ifdef __DEBUG_TAG__
35. #define dprintk(fmt, arg...) printk(fmt, ## arg)
36. #else
37. #define dprintk(fmt, arg...)
38. #endif
39. //char device name: /dev/gpio_cdev
40. #define DEVICE_NAME "gpio_cdev"
41. //multiple
42. #define MUL_SEL_INPUT   0
43. #define MUL_SEL_OUTPUT  1
44. //char device
45. struct cdev *gpio_cdev;
46. dev_t devid;
47. struct class *gpio_class;
48. //gpio count
49. int gpio_cnt;
50. //general gpio subsystem
51. gpio_pdata_t pin[20];
52. //
53. } gpio_info_t;
54. static gpio_info_t info;
55. //global gpio pin record:
56. char pin_count;
57. /**********************************************************/
58. static int gpio_cdev_open(struct inode *inode, struct file *file)
59. {
60. dprintk("[gpio]: gpio_cdev_open fn.\n");
61. <span style="white-space:pre">    </span>return 0;
62. }
63. static int gpio_cdev_release(struct inode *inode, struct file *file)
64. {
65. dprintk("[gpio]: gpio_cdev_release fn.\n");
66. <span style="white-space:pre">    </span>return 0;
67. }
68. /**********************************************************/
69. //write
70. static ssize_t gpio_cdev_write(struct file *file, const char __user *buf, \
71. size_t count, loff_t *ppos)
72. {
73. gpio_userspace_t write_gpio;
74. unsigned char write_data, write_count;
75. dprintk("[gpio]: gpio_cdev_write fn.\n");
76. copy_from_user(&write_gpio, (gpio_userspace_t *)buf, sizeof(gpio_userspace_t));
77. write_data = write_gpio.data;
78. write_count = write_gpio.count;
79. dprintk("[gpio][write]: data=%d, count=%d.\n", write_data, write_count);
80. //error correction.
81. if ((write_data != 0) && (write_data != 1)) {
82. dprintk("[gpio][write][error]: write_data invalid.\n");
83. }
84. if ((write_count < 0) || (write_count >19)) {
85. dprintk("[gpio][write][error]: write_count does not exit.\n");
86. }
87. gpio_direction_output(info.pin[write_count].gpio.gpio, write_data);
88. //mdelay(1);
89. return 0;
90. }
91. //read
92. static ssize_t gpio_cdev_read(struct file *file, char __user *buf, \
93. size_t count, loff_t *ppos)
94. {
95. int i;
96. unsigned char data;
97. unsigned int gpio;
98. gpio_userspace_t read_gpio;
99. dprintk("[gpio]: gpio_cdev_read fn.\n");
100. #if 0
101. gpio_userspace_t read_gpio[20];
102. for (i = 0; i < 20; i++) {
103. gpio = info.pin[i].gpio.gpio;
104. //调试用；不要轻易打开：
105. #if 0
106. if(0 != gpio_direction_input(gpio)) {
107. dprintk("set to input failed.\n");
108. continue;
109. }
110. #endif
111. data = __gpio_get_value(gpio);
112. read_gpio[i].count = i;
113. read_gpio[i].data = data;
114. dprintk("[gpio][read]: pin_%d = %d.\n", read_gpio[i].count, read_gpio[i].data);
115. }
116. copy_to_user(buf, read_gpio, 20*sizeof(gpio_userspace_t));
117. #else
118. i = pin_count;
119. dprintk("[gpio][read]: pin_count = %d.\n", i);
120. gpio = info.pin[i].gpio.gpio;
121. data = __gpio_get_value(gpio);
122. read_gpio.count = i;
123. read_gpio.data = data;
124. dprintk("[gpio][read]: count = %d; data = %d.\n", read_gpio.count, read_gpio.data);
125. copy_to_user(buf, &read_gpio, sizeof(gpio_userspace_t));
126. #endif
127. return 0;
128. }
129. static long gpio_cdev_ioctl(struct file *file, unsigned int cmd, \
130. unsigned long arg)
131. {
132. dprintk("[gpio]: gpio_cdev_ioctl fn;");
133. dprintk(" cmd = %d.\n", cmd);
134. void __user *uarg;
135. uarg = (void __user *)arg;
136. gpio_userspace_t ioctl_gpio;
137. copy_from_user(&ioctl_gpio, (gpio_userspace_t *)uarg, sizeof(gpio_userspace_t));
138. dprintk("[gpio]:count = %d, data = %d.\n", ioctl_gpio.count, ioctl_gpio.data);
139. switch(cmd) {
140. case GPIO_SET:
141. dprintk("[gpio]: ioctl cmd = GPIO_SET.\n");
142. pin_count = ioctl_gpio.count;
143. dprintk("[gpio]: pin_count = %d.\n", pin_count);
144. if ((pin_count > 19)|| (pin_count < 0)) {
145. dprintk("[gpio][error]: gpio_cdev_ioctl: pin_count invalide.\n");
146. }
147. break;
148. case GPIO_GET:
149. dprintk("[gpio]: ioctl cmd = GPIO_SET.\n");
150. break;
151. default:
152. dprintk("[gpio]: ioctl cmd = default.\n");
153. break;
154. }
155. return 0;
156. }
157. static const struct file_operations gpio_cdev_fops = {
158. .owner          = THIS_MODULE,
159. .open           = gpio_cdev_open,
160. .release        = gpio_cdev_release,
161. .write          = gpio_cdev_write,
162. .read           = gpio_cdev_read,
163. .unlocked_ioctl = gpio_cdev_ioctl,
164. };
165. static int gpio_fetch_config(void)
166. {
167. char buffer[32] = {};
168. int i;
169. int cnt = info.gpio_cnt;
170. script_item_value_type_e  type;
171. script_item_u   val;
172. dprintk("[gpio]: gpio_fetch_config fn.\n");
173. dprintk("[gpio]: gpio_cnt=%d.\n", cnt);
174. dprintk("--------------------\n");
175. for(i=0; i< cnt; i++) {
176. //format sprintf
177. sprintf(buffer, "gpio_pin_%d", i);
178. dprintk("[gpio]: buffer=%s.\n", buffer);
179. //fetch gpio_pin_# issue
180. type = script_get_item("gpio_para", buffer, &val);
181. if (SCIRPT_ITEM_VALUE_TYPE_PIO != type) {
182. dprintk("[gpio]: item value type INVALID.\n");
183. return -1;
184. }
185. else {
186. info.pin[i].gpio.gpio = val.gpio.gpio;
187. info.pin[i].gpio.mul_sel = val.gpio.mul_sel;
188. dprintk("[gpio][pin%d]: gpio=%d, mul_sel=%d, ", i, info.pin[i].gpio.gpio, info.pin[i].gpio.mul_sel);
189. strcpy(info.pin[i].gpio_name, buffer);
190. dprintk("name=%s, ", info.pin[i].gpio_name);
191. info.pin[i].gpio_cnt = i;
192. dprintk("gpio_cnt=%d.\n", info.pin[i].gpio_cnt);
193. dprintk("--------------------\n");
194. }
195. }
196. dprintk("[gpio]: success to gpio_fetch_config.\n");
197. return 0;
198. }
199. static int __init gpio_module_init(void)
200. {
201. int ret = 0, err;
202. int cnt = 0, i;
203. script_item_value_type_e  type;
204. script_item_u   val;
205. dprintk("[gpio]: gpio_module_init fn.\n");
206. ret = alloc_chrdev_region(&(info.devid), 0, 20, DEVICE_NAME);
207. if ( ret ) {
208. dprintk("[gpio]: fail to alloc_chrdev_region.\n");
209. return -1;
210. }
211. dprintk("[gpio]: devid major=%d, minor=%d.\n", MAJOR(info.devid), MINOR(info.devid));
212. info.gpio_cdev = cdev_alloc();
213. cdev_init(info.gpio_cdev, &gpio_cdev_fops);
214. info.gpio_cdev->owner = THIS_MODULE;
215. err = cdev_add(info.gpio_cdev, info.devid, 1);
216. if (err) {
217. dprintk("[gpio]: cdev_add fail.\n");
218. return -1;
219. }
220. info.gpio_class = class_create(THIS_MODULE, DEVICE_NAME);
221. if (IS_ERR(info.gpio_class)) {
222. dprintk("[gpio]: class_create fail.\n");
223. return -1;
224. }
225. <span style="white-space:pre">    </span>device_create(info.gpio_class, NULL, info.devid, NULL, DEVICE_NAME);
226. <span style="white-space:pre">    </span>
227. dprintk("[gpio]: success to create a gpio cdev.\n");
228. //
229. type = script_get_item("gpio_para", "gpio_used", &val);
230. if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
231. dprintk("[gpio]: type not right.\n");
232. return -1;
233. }
234. if (!val.val) {
235. dprintk("[gpio]: gpio is not used.\n");
236. return -1;
237. }
238. dprintk("[gpio]: gpio is used.\n");
239. //
240. cnt = script_get_pio_list("gpio_para", &gpio_list);
241. dprintk("[gpio]: cnt = %d.\n", cnt);
242. info.gpio_cnt = cnt;
243. if (cnt == 0) {
244. dprintk("[gpio]: fail to script_get_pio_list.\n");
245. return -1;
246. }
247. else {
248. dprintk("[gpio]: requeset gpio(s).\n");
249. for (i=0; i < cnt; i++) {
250. dprintk("[gpio]: requeset gpio No.%d.\n", i+1);
251. if (0 != gpio_request(gpio_list[i].gpio.gpio, NULL))
252. dprintk("[gpio]: i = %d; fail to gpio_request.\n", i);
253. }
254. }
255. //dprintk("[gpio]: 1.\n");
256. //config gpio.
257. if (0 != sw_gpio_setall_range(&gpio_list[0], cnt)) {
258. dprintk("[gpio]: fail to sw_gpio_setall_range.\n");
259. return -1;
260. }
261. //dprintk("[gpio]: 2.\n");
262. /*************************************************************/
263. gpio_fetch_config();
264. //dprintk("[gpio]: 3.\n");
265. #if 0
266. //test gpio.
267. gpio_direction_output(info.pin[4].gpio.gpio, 0);
268. mdelay(5);
269. gpio_direction_output(info.pin[4].gpio.gpio, 1);
270. mdelay(5);
271. #endif
272. //dprintk("[gpio]: 4.\n");
273. <span style="white-space:pre">    </span>return 0;
274. }
275. static void __exit gpio_module_exit(void)
276. {
277. dprintk("[gpio]: gpio_module_exit fn.\n");
278. <span style="white-space:pre">    </span>
279. device_destroy(info.gpio_class,  info.devid);
280. class_destroy(info.gpio_class);
281. cdev_del(info.gpio_cdev);
282. }
283. module_init(gpio_module_init);
284. module_exit(gpio_module_exit);
285. MODULE_AUTHOR("chwenj@gmail.com");
286. MODULE_DESCRIPTION("gpio driver");
287. MODULE_LICENSE("GPL");