zoukankan      html  css  js  c++  java

  • 转：全志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. ");  
    31.         return -1;  
    32.     }  
    33.     printf("%s opend. ", 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. ", 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. ", 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. ");  
    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. ");  
    67.         return -1;  
    68.     }  
    69.     printf("read: count = %d, data = %d. ", read_gpio.count, read_gpio.data);  
    70.   
    71.     /*close*/  
    72.     close(gpio_fd);  
    73.     printf("%s close. ", 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. ");  
    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. ");  
    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. ");  
    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. ", 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. ");   
    115.     }  
    116.     if ((write_count < 0) || (write_count >19)) {  
    117.         dprintk("[gpio][write][error]: write_count does not exit. ");     
    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. ");  
    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. ");  
    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. ", 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. ", 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. ", 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. ", 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. ", ioctl_gpio.count, ioctl_gpio.data);  
    191.   
    192.   
    193.     switch(cmd) {  
    194.     case GPIO_SET:  
    195.         dprintk("[gpio]: ioctl cmd = GPIO_SET. ");  
    196.         pin_count = ioctl_gpio.count;  
    197.         dprintk("[gpio]: pin_count = %d. ", pin_count);  
    198.         if ((pin_count > 19)|| (pin_count < 0)) {  
    199.             dprintk("[gpio][error]: gpio_cdev_ioctl: pin_count invalide. ");   
    200.         }  
    201.         break;  
    202.   
    203.   
    204.     case GPIO_GET:  
    205.         dprintk("[gpio]: ioctl cmd = GPIO_SET. ");  
    206.         break;  
    207.   
    208.   
    209.     default:  
    210.         dprintk("[gpio]: ioctl cmd = default. ");  
    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. ");  
    240.   
    241.   
    242.     dprintk("[gpio]: gpio_cnt=%d. ", cnt);  
    243.   
    244.   
    245.     dprintk("-------------------- ");  
    246.     for(i=0; i< cnt; i++) {  
    247.         //format sprintf  
    248.         sprintf(buffer, "gpio_pin_%d", i);  
    249.         dprintk("[gpio]: buffer=%s. ", 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. ");  
    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. ", info.pin[i].gpio_cnt);  
    264.             dprintk("-------------------- ");  
    265.         }  
    266.   
    267.   
    268.     }   
    269.   
    270.   
    271.     dprintk("[gpio]: success to gpio_fetch_config. ");  
    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. ");  
    285.   
    286.   
    287.     ret = alloc_chrdev_region(&(info.devid), 0, 20, DEVICE_NAME);  
    288.     if ( ret ) {  
    289.         dprintk("[gpio]: fail to alloc_chrdev_region. ");  
    290.         return -1;  
    291.     }  
    292.     dprintk("[gpio]: devid major=%d, minor=%d. ", 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. ");  
    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. ");  
    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. ");  
    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. ");   
    320.         return -1;  
    321.     }  
    322.     if (!val.val) {  
    323.         dprintk("[gpio]: gpio is not used. ");  
    324.         return -1;  
    325.     }  
    326.     dprintk("[gpio]: gpio is used. ");  
    327.       
    328.     //  
    329.     cnt = script_get_pio_list("gpio_para", &gpio_list);  
    330.     dprintk("[gpio]: cnt = %d. ", cnt);  
    331.     info.gpio_cnt = cnt;  
    332.     if (cnt == 0) {  
    333.         dprintk("[gpio]: fail to script_get_pio_list. ");  
    334.         return -1;  
    335.     }  
    336.     else {  
    337.         dprintk("[gpio]: requeset gpio(s). ");   
    338.         for (i=0; i < cnt; i++) {  
    339.             dprintk("[gpio]: requeset gpio No.%d. ", i+1);   
    340.             if (0 != gpio_request(gpio_list[i].gpio.gpio, NULL))   
    341.                 dprintk("[gpio]: i = %d; fail to gpio_request. ", i);   
    342.         }  
    343.       
    344.     }  
    345.     //dprintk("[gpio]: 1. ");   
    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. ");  
    351.         return -1;   
    352.     }  
    353.   
    354.   
    355.     //dprintk("[gpio]: 2. ");   
    356.     /*************************************************************/  
    357.     gpio_fetch_config();  
    358.     //dprintk("[gpio]: 3. ");   
    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. ");   
    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. ");  
    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");  

     
  • 相关阅读:
    delphi之动态库调用和串口通讯
    git如何使用 svn如何使用
    delphi学习笔记1
    sql
    linux连接与传输等命令
    jdbc
    list/tstringlist/tobjectlist
    SQL GRANT
    Invalidate介绍
    FORM 的创建
  • 原文地址：https://www.cnblogs.com/yfz0/p/5790076.html
Copyright © 2011-2022 走看看