转：全志A20 GPIO 总结文档

 链接：

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

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

 

  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.   
  18. /**********************************************************/  
  19. #define GPIO_SET      0xAC    
  20. #define GPIO_GET      0xAB   
  21.   
  22.   
  23. /**********************************************************/  
  24. script_item_u *gpio_list = NULL;  
  25.   
  26.   
  27. //gpio_userspace_t 和 gpio_pdata_t 在序列上是一一对应的关系.  
  28. typedef struct {  
  29.     unsigned char count;      //IO序列：0，1，2，..., 19.  
  30.     unsigned char data;       //IO电平.  
  31. } gpio_userspace_t;  
  32.   
  33.   
  34. typedef struct {  
  35.     struct gpio_config gpio;  
  36.     char gpio_name[32];  
  37.     int gpio_cnt;  
  38. } gpio_pdata_t;  
  39.   
  40.   
  41. typedef struct {  
  42. //debug tag for printk  
  43.     #define __DEBUG_TAG__  
  44.     #ifdef __DEBUG_TAG__  
  45.         #define dprintk(fmt, arg...) printk(fmt, ## arg)  
  46.     #else  
  47.         #define dprintk(fmt, arg...)    
  48.     #endif  
  49.   
  50.   
  51. //char device name: /dev/gpio_cdev  
  52.     #define DEVICE_NAME "gpio_cdev"  
  53.   
  54.   
  55. //multiple  
  56.     #define MUL_SEL_INPUT   0  
  57.     #define MUL_SEL_OUTPUT  1  
  58.   
  59.   
  60. //char device   
  61.     struct cdev *gpio_cdev;  
  62.     dev_t devid;  
  63.     struct class *gpio_class;  
  64. //gpio count   
  65.     int gpio_cnt;  
  66. //general gpio subsystem  
  67.     gpio_pdata_t pin[20];  
  68.   
  69.   
  70. //  
  71. } gpio_info_t;  
  72. static gpio_info_t info;  
  73.   
  74.   
  75. //global gpio pin record:  
  76. char pin_count;  
  77.   
  78.   
  79. /**********************************************************/  
  80. static int gpio_cdev_open(struct inode *inode, struct file *file)  
  81. {  
  82.     dprintk("[gpio]: gpio_cdev_open fn.\n");  
  83. <span style="white-space:pre">    </span>return 0;  
  84. }  
  85.   
  86.   
  87. static int gpio_cdev_release(struct inode *inode, struct file *file)  
  88. {  
  89.     dprintk("[gpio]: gpio_cdev_release fn.\n");  
  90. <span style="white-space:pre">    </span>return 0;  
  91. }  
  92.   
  93.   
  94. /**********************************************************/  
  95. //write  
  96. static ssize_t gpio_cdev_write(struct file *file, const char __user *buf, \  
  97.         size_t count, loff_t *ppos)  
  98. {  
  99.     gpio_userspace_t write_gpio;  
  100.     unsigned char write_data, write_count;  
  101.   
  102.   
  103.     dprintk("[gpio]: gpio_cdev_write fn.\n");  
  104.   
  105.   
  106.     copy_from_user(&write_gpio, (gpio_userspace_t *)buf, sizeof(gpio_userspace_t));  
  107.     write_data = write_gpio.data;  
  108.     write_count = write_gpio.count;  
  109.     dprintk("[gpio][write]: data=%d, count=%d.\n", write_data, write_count);  
  110.   
  111.   
  112.     //error correction.  
  113.     if ((write_data != 0) && (write_data != 1)) {  
  114.         dprintk("[gpio][write][error]: write_data invalid.\n");   
  115.     }  
  116.     if ((write_count < 0) || (write_count >19)) {  
  117.         dprintk("[gpio][write][error]: write_count does not exit.\n");     
  118.     }  
  119.   
  120.   
  121.     gpio_direction_output(info.pin[write_count].gpio.gpio, write_data);  
  122.     //mdelay(1);  
  123.   
  124.   
  125.     return 0;  
  126. }  
  127.   
  128.   
  129. //read   
  130. static ssize_t gpio_cdev_read(struct file *file, char __user *buf, \  
  131.         size_t count, loff_t *ppos)  
  132. {  
  133.     int i;  
  134.     unsigned char data;  
  135.     unsigned int gpio;  
  136.     gpio_userspace_t read_gpio;  
  137.   
  138.   
  139.     dprintk("[gpio]: gpio_cdev_read fn.\n");  
  140.   
  141.   
  142. #if 0  
  143.     gpio_userspace_t read_gpio[20];  
  144.     for (i = 0; i < 20; i++) {  
  145.         gpio = info.pin[i].gpio.gpio;  
  146.     //调试用；不要轻易打开：  
  147.     #if 0  
  148.         if(0 != gpio_direction_input(gpio)) {  
  149.             dprintk("set to input failed.\n");  
  150.             continue;  
  151.         }  
  152.     #endif  
  153.         data = __gpio_get_value(gpio);  
  154.   
  155.   
  156.         read_gpio[i].count = i;      
  157.         read_gpio[i].data = data;  
  158.         dprintk("[gpio][read]: pin_%d = %d.\n", read_gpio[i].count, read_gpio[i].data);  
  159.     }  
  160.     copy_to_user(buf, read_gpio, 20*sizeof(gpio_userspace_t));  
  161. #else  
  162.     i = pin_count;  
  163.     dprintk("[gpio][read]: pin_count = %d.\n", i);  
  164.     gpio = info.pin[i].gpio.gpio;  
  165.     data = __gpio_get_value(gpio);  
  166.   
  167.   
  168.     read_gpio.count = i;      
  169.     read_gpio.data = data;  
  170.     dprintk("[gpio][read]: count = %d; data = %d.\n", read_gpio.count, read_gpio.data);  
  171.     copy_to_user(buf, &read_gpio, sizeof(gpio_userspace_t));  
  172. #endif  
  173.   
  174.   
  175.     return 0;  
  176. }  
  177.   
  178.   
  179. static long gpio_cdev_ioctl(struct file *file, unsigned int cmd, \  
  180.         unsigned long arg)  
  181. {  
  182.     dprintk("[gpio]: gpio_cdev_ioctl fn;");  
  183.     dprintk(" cmd = %d.\n", cmd);  
  184.   
  185.   
  186.     void __user *uarg;    
  187.     uarg = (void __user *)arg;    
  188.     gpio_userspace_t ioctl_gpio;  
  189.     copy_from_user(&ioctl_gpio, (gpio_userspace_t *)uarg, sizeof(gpio_userspace_t));    
  190.     dprintk("[gpio]:count = %d, data = %d.\n", ioctl_gpio.count, ioctl_gpio.data);  
  191.   
  192.   
  193.     switch(cmd) {  
  194.     case GPIO_SET:  
  195.         dprintk("[gpio]: ioctl cmd = GPIO_SET.\n");  
  196.         pin_count = ioctl_gpio.count;  
  197.         dprintk("[gpio]: pin_count = %d.\n", pin_count);  
  198.         if ((pin_count > 19)|| (pin_count < 0)) {  
  199.             dprintk("[gpio][error]: gpio_cdev_ioctl: pin_count invalide.\n");   
  200.         }  
  201.         break;  
  202.   
  203.   
  204.     case GPIO_GET:  
  205.         dprintk("[gpio]: ioctl cmd = GPIO_SET.\n");  
  206.         break;  
  207.   
  208.   
  209.     default:  
  210.         dprintk("[gpio]: ioctl cmd = default.\n");  
  211.         break;  
  212.     }  
  213.   
  214.   
  215.     return 0;  
  216. }  
  217.   
  218.   
  219. static const struct file_operations gpio_cdev_fops = {  
  220.     .owner          = THIS_MODULE,  
  221.     .open           = gpio_cdev_open,  
  222.     .release        = gpio_cdev_release,  
  223.     .write          = gpio_cdev_write,  
  224.     .read           = gpio_cdev_read,  
  225.     .unlocked_ioctl = gpio_cdev_ioctl,  
  226. };  
  227.   
  228. static int gpio_fetch_config(void)  
  229. {  
  230.   
  231.   
  232.     char buffer[32] = {};  
  233.     int i;  
  234.     int cnt = info.gpio_cnt;  
  235.     script_item_value_type_e  type;  
  236.     script_item_u   val;  
  237.   
  238.   
  239.     dprintk("[gpio]: gpio_fetch_config fn.\n");  
  240.   
  241.   
  242.     dprintk("[gpio]: gpio_cnt=%d.\n", cnt);  
  243.   
  244.   
  245.     dprintk("--------------------\n");  
  246.     for(i=0; i< cnt; i++) {  
  247.         //format sprintf  
  248.         sprintf(buffer, "gpio_pin_%d", i);  
  249.         dprintk("[gpio]: buffer=%s.\n", buffer);  
  250.         //fetch gpio_pin_# issue  
  251.         type = script_get_item("gpio_para", buffer, &val);  
  252.         if (SCIRPT_ITEM_VALUE_TYPE_PIO != type) {  
  253.             dprintk("[gpio]: item value type INVALID.\n");  
  254.             return -1;  
  255.         }  
  256.         else {  
  257.             info.pin[i].gpio.gpio = val.gpio.gpio;  
  258.             info.pin[i].gpio.mul_sel = val.gpio.mul_sel;  
  259.             dprintk("[gpio][pin%d]: gpio=%d, mul_sel=%d, ", i, info.pin[i].gpio.gpio, info.pin[i].gpio.mul_sel);  
  260.             strcpy(info.pin[i].gpio_name, buffer);   
  261.             dprintk("name=%s, ", info.pin[i].gpio_name);  
  262.             info.pin[i].gpio_cnt = i;  
  263.             dprintk("gpio_cnt=%d.\n", info.pin[i].gpio_cnt);  
  264.             dprintk("--------------------\n");  
  265.         }  
  266.   
  267.   
  268.     }   
  269.   
  270.   
  271.     dprintk("[gpio]: success to gpio_fetch_config.\n");  
  272.     return 0;  
  273. }  
  274.   
  275.   
  276. static int __init gpio_module_init(void)  
  277. {  
  278.     int ret = 0, err;  
  279.     int cnt = 0, i;  
  280.     script_item_value_type_e  type;  
  281.     script_item_u   val;  
  282.   
  283.   
  284.     dprintk("[gpio]: gpio_module_init fn.\n");  
  285.   
  286.   
  287.     ret = alloc_chrdev_region(&(info.devid), 0, 20, DEVICE_NAME);  
  288.     if ( ret ) {  
  289.         dprintk("[gpio]: fail to alloc_chrdev_region.\n");  
  290.         return -1;  
  291.     }  
  292.     dprintk("[gpio]: devid major=%d, minor=%d.\n", MAJOR(info.devid), MINOR(info.devid));  
  293.   
  294.   
  295.     info.gpio_cdev = cdev_alloc();  
  296.     cdev_init(info.gpio_cdev, &gpio_cdev_fops);  
  297.     info.gpio_cdev->owner = THIS_MODULE;  
  298.     err = cdev_add(info.gpio_cdev, info.devid, 1);  
  299.     if (err) {  
  300.         dprintk("[gpio]: cdev_add fail.\n");  
  301.         return -1;  
  302.     }  
  303.   
  304.   
  305.     info.gpio_class = class_create(THIS_MODULE, DEVICE_NAME);  
  306.     if (IS_ERR(info.gpio_class)) {  
  307.         dprintk("[gpio]: class_create fail.\n");  
  308.         return -1;  
  309.     }  
  310.       
  311. <span style="white-space:pre">    </span>device_create(info.gpio_class, NULL, info.devid, NULL, DEVICE_NAME);  
  312. <span style="white-space:pre">    </span>  
  313.     dprintk("[gpio]: success to create a gpio cdev.\n");  
  314.   
  315.   
  316.     //  
  317.     type = script_get_item("gpio_para", "gpio_used", &val);  
  318.     if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {  
  319.         dprintk("[gpio]: type not right.\n");   
  320.         return -1;  
  321.     }  
  322.     if (!val.val) {  
  323.         dprintk("[gpio]: gpio is not used.\n");  
  324.         return -1;  
  325.     }  
  326.     dprintk("[gpio]: gpio is used.\n");  
  327.       
  328.     //  
  329.     cnt = script_get_pio_list("gpio_para", &gpio_list);  
  330.     dprintk("[gpio]: cnt = %d.\n", cnt);  
  331.     info.gpio_cnt = cnt;  
  332.     if (cnt == 0) {  
  333.         dprintk("[gpio]: fail to script_get_pio_list.\n");  
  334.         return -1;  
  335.     }  
  336.     else {  
  337.         dprintk("[gpio]: requeset gpio(s).\n");   
  338.         for (i=0; i < cnt; i++) {  
  339.             dprintk("[gpio]: requeset gpio No.%d.\n", i+1);   
  340.             if (0 != gpio_request(gpio_list[i].gpio.gpio, NULL))   
  341.                 dprintk("[gpio]: i = %d; fail to gpio_request.\n", i);   
  342.         }  
  343.       
  344.     }  
  345.     //dprintk("[gpio]: 1.\n");   
  346.   
  347.   
  348.     //config gpio.  
  349.     if (0 != sw_gpio_setall_range(&gpio_list[0], cnt)) {  
  350.         dprintk("[gpio]: fail to sw_gpio_setall_range.\n");  
  351.         return -1;   
  352.     }  
  353.   
  354.   
  355.     //dprintk("[gpio]: 2.\n");   
  356.     /*************************************************************/  
  357.     gpio_fetch_config();  
  358.     //dprintk("[gpio]: 3.\n");   
  359.   
  360.   
  361. #if 0  
  362.     //test gpio.  
  363.     gpio_direction_output(info.pin[4].gpio.gpio, 0);  
  364.     mdelay(5);  
  365.     gpio_direction_output(info.pin[4].gpio.gpio, 1);  
  366.     mdelay(5);  
  367. #endif  
  368.   
  369.   
  370.     //dprintk("[gpio]: 4.\n");   
  371. <span style="white-space:pre">    </span>return 0;  
  372. }  
  373.   
  374.   
  375. static void __exit gpio_module_exit(void)  
  376. {  
  377.     dprintk("[gpio]: gpio_module_exit fn.\n");  
  378.         <span style="white-space:pre">    </span>  
  379.     device_destroy(info.gpio_class,  info.devid);  
  380.     class_destroy(info.gpio_class);  
  381.     cdev_del(info.gpio_cdev);  
  382. }  
  383.   
  384.   
  385. module_init(gpio_module_init);  
  386. module_exit(gpio_module_exit);  
  387.   
  388.   
  389. MODULE_AUTHOR("chwenj@gmail.com");  
  390. MODULE_DESCRIPTION("gpio driver");  
  391. MODULE_LICENSE("GPL");  

 

posted on 2016-08-20 11:41  care2014  阅读(1833)  评论(0)  编辑  收藏  举报
Copyright © 2024 care2014
Powered by .NET 8.0 on Kubernetes Powered by: 博客园