Chinaunix首页 | 论坛 | 博客

wenshan

首页　| 　博文目录　| 　关于我

文山科技

  • 博客访问： 64677
  • 博文数量： 14
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 10
  • 用 户 组： 普通用户
  • 注册时间： 2016-12-09 09:36
个人简介

人生最精彩的不是实现梦想的瞬间，而是坚持梦想的过程！

文章分类

全部博文（14）

文章存档

2018年（4）

2017年（7）

2016年（3）

我的朋友
最近访客
推荐博文
相关博文
Linux GPIO内核驱动框架

分类： LINUX

2017-05-26 17:29:00

原文地址：Linux GPIO内核驱动框架 作者：芸锺鹤

    GPIO开发是Linux开发不可或缺的重要部分，它是ARM开发中最普遍也是最基础的知识。
    在ARM开发过程中,引脚复用严重,导致问题的原因软硬件并存，因此在实际的开发中常常需要使用GPIO来探测所配置的路径或设备是否畅通，可用，以此来判定是设备的问题，还是驱动的问题或是程序的问题。
    在Linux内核中提供一个标准的GPIO LIB框架，它位于：
    --<*>Device Drivers
        --<*>GPIO Support
            --
    GPIO Support选项的选入，内核会将标准GPIO库进行编译。标准GPIO库的源码位于内核中的如下位置:
    /driver/gpio/gpiolib.c

    在该文件中，提供如下的接口函数用于配置和操作GPIO：
    int gpio_request(unsigned gpio, const char *label); //获取GPIO Pin的使用权，并为该Pin命名为label。

    void gpio_free(unsigned gpio)；                     //释放GPIO Pin的使用权。

    int gpio_direction_input(unsigned gpio);            //设置GPIO Pin为输入模式。

    int gpio_direction_output(unsigned gpio, int value);//设置GPIO Pin为输出模式，并指定输出值value。

    int gpio_get_value(unsigned gpio);                  //获得 GPIO Pin 上的电平。

    void gpio_set_value(unsigned gpio, int value);      //设置 GPIO Pin 上的电平。

    int gpio_to_irq(unsigned gpio);                     //通过获得GPIO Pin 对应的 irq number。


    对于上述函数的gpio参数的计算方式为: GPIOx_n-->gpio=x*32+n。

上面主要是对接口的介绍，下面我们来对源码进行分析，分析源码从什么地方开始呢?就从第一个调用的函数开始吧！
Function1：int gpio_request(unsigned gpio,const char *label):
Note: 该函数调用可能会失败，因此必须检测其返回值。

点击(此处)折叠或打开

  1. int gpio_request(unsigned gpio, const char *label)
  2. {
  3.     struct gpio_desc    *desc;       //gpio pin结构体指针，参见下面相关数据结构描述。
  4.     struct gpio_chip    *chip;       //gpio pin controler结构体指针，参见下面相关数据结构描述
  5.     int   status = -EINVAL;
  6.     unsigned long        flags;

  8.     spin_lock_irqsave(&gpio_lock, flags);

  10.     if (!gpio_is_valid(gpio))            //检测argument gpio的合法性。
  11.         goto done;
  12.     desc = &gpio_desc[gpio];             //从gpio数组gpio_desc从获取对应的Pin结构体。
  13.     chip = desc->chip;                   //获取gpio pin的控制器
  14.     if (chip == NULL)
  15.         goto done;

  17.     if (!try_module_get(chip->owner))
  18.         goto done;

  20.     /* NOTE: gpio_request() can be called in early boot,
  21.      * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
  22.      */

  24.     if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
  25.         desc_set_label(desc, label ? : "?");
  26.         status = 0;
  27.     } else {
  28.         status = -EBUSY;
  29.         module_put(chip->owner);
  30.         goto done;
  31.     }

  33.     if (chip->request) {
  34.         /* chip->request may sleep */
  35.         spin_unlock_irqrestore(&gpio_lock, flags);
  36.         status = chip->request(chip, gpio - chip->base);
  37.         spin_lock_irqsave(&gpio_lock, flags);

  39.         if (status < 0) {
  40.             desc_set_label(desc, NULL);
  41.             module_put(chip->owner);
  42.             clear_bit(FLAG_REQUESTED, &desc->flags);
  43.         }
  44.     }

  46. done:
  47.     if (status)
  48.         pr_debug("gpio_request: gpio-%d (%s) status %d\n",gpio, label ? : "?", status);
  49.     spin_unlock_irqrestore(&gpio_lock, flags);
  50.     return status;
  51. }
  52. EXPORT_SYMBOL_GPL(gpio_request);
Function1相关数据结构：
struct gpio_desc    *desc (driver/gpio/gpiolib.c)        每一个GPIO Pin对应一个gpio_desc.

点击(此处)折叠或打开

  1. struct gpio_desc {
  2.     struct gpio_chip    *chip;     //控制器指针
  3.     unsigned long        flags;
  4. /* flag symbols are bit numbers */
  5. #define FLAG_REQUESTED    0
  6. #define FLAG_IS_OUT       1
  7. #define FLAG_RESERVED     2
  8. #define FLAG_EXPORT       3    /* protected by sysfs_lock */
  9. #define FLAG_SYSFS        4    /* exported via /sys/class/gpio/control */
  10. #define FLAG_TRIG_FALL    5    /* trigger on falling edge */
  11. #define FLAG_TRIG_RISE    6    /* trigger on rising edge */
  12. #define FLAG_ACTIVE_LOW   7    /* sysfs value has active low */

  14. #define ID_SHIFT         16    /* add new flags before this one */

  16. #define GPIO_FLAGS_MASK      ((1 << ID_SHIFT) - 1)
  17. #define GPIO_TRIGGER_MASK    (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))

  19. #ifdef CONFIG_DEBUG_FS
  20.     const char        *label;
  21. #endif
  22. };

  24. static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];       
  25. /*gpio pin数组，包含控制器所有的gpio pin,ARCH_NR_GPIOS通常定义在板级文件中(可能需要自己根据板子进行修改):
  26.  *  arch/arm/mach-***/include/**/gpio.h
  27.  *或
  28.  *  arch/arm/plat-**/include/**/gpio.h
  29.  * 若没有定义系统则会使用定义在include/asm-generic/gpio.h中的默认值：
  30.  *  #ifndef ARCH_NR_GPIOS
  31.  *  #define ARCH_NR_GPIOS        256
  32.  *  #endif
  33.  */
     
     
 struct gpio_chip    *chip(include/linux/gpio.h----->CONFIG_GENERIC_GPIO---->include/asm-generic/gpio.h)    gpio_chip代表GPIO控制器。

点击(此处)折叠或打开

  1. /*
  2.  * struct gpio_chip - abstract a GPIO controller
  3.  * A gpio_chip can help platforms abstract various sources of GPIOs so they can all be accessed through a common programing
  4.  * interface.Example sources would be SOC controllers, FPGAs, multifunctio chips, dedicated GPIO expanders, and so on.
  5.  *
  6.  * Each chip controls a number of signals, identified in method calls by "offset" values in the range 0..(@ngpio - 1). When
  7.  * those signals are referenced through calls like gpio_get_value(gpio), the offset is calculated by subtracting @base from
  8.  * the gpio number.
  9.  */
  10. struct gpio_chip {
  11.     const char        *label;                  //@label: for diagnostics
  12.     struct device     *dev;                    //@dev: optional device providing the GPIOs
  13.     struct module     *owner;                  //@owner: helps prevent removal of modules exporting active GPIOs

  15.    //@request: optional hook for chip-specific activation, such as enabling module power and clock; may sleep
  16.     int   (*request)(struct gpio_chip *chip, unsigned offset); 
  17.    
  18.     //@free: optional hook for chip-specific deactivation, such as  disabling module power and clock; may sleep
  19.     void  (*free)(struct gpio_chip *chip, unsigned offset);    

  21.     //@direction_input: configures signal "offset" as input, or returns error
  22.     int   (*direction_input)(struct gpio_chip *chip, unsigned offset); 

  24.     //@get: returns value for signal "offset"; for output signals this returns either the value actually sensed, or zero
  25.     int   (*get)(struct gpio_chip *chip, unsigned offset);   
  26.    
  27.     //@direction_output: configures signal "offset" as output, or returns error
  28.     int   (*direction_output)(struct gpio_chip *chip, unsigned offset, int value);

  30.     int   (*set_debounce)(struct gpio_chip *chip, unsigned offset, unsigned debounce);
  31.    
  32.     //@set: assigns output value for signal "offset"
  33.     void  (*set)(struct gpio_chip *chip, unsigned offset, int value);

  35.     // @to_irq: optional hook supporting non-static gpio_to_irq() mappings;implementation may not sleep
  36.     int   (*to_irq)(struct gpio_chip *chip,unsigned offset);

  38.     //@dbg_show: optional routine to show contents in debugfs; default code will be used when this is omitted, but custom code can
  39.     //           show extra state (such as pullup/pulldown configuration).
  40.     void  (*dbg_show)(struct seq_file *s,struct gpio_chip *chip);
  41.    
  42.     //@base: identifies the first GPIO number handled by this chip; or, if negative during registration, requests dynamic ID allocation.
  43.     int    base;
  44.     
  45.     //@ngpio: the number of GPIOs handled by this controller; the last GPIO handled is (base + ngpio - 1).
  46.     u16    ngpio;

  48.     //@names: if set, must be an array of strings to use as alternative names for the GPIOs in this chip. Any entry in the array may be
  49.     //        NULL if there is no alias for the GPIO, however the array must be @ngpio entries long. A name can include a single printk
  50.     //        format specifier for an unsigned int. It is substituted by the actual number of the gpio.
  51.     const char *const *names;
  52.    
  53.     //@can_sleep: flag must be set iff get()/set() methods sleep, as they must while accessing GPIO expander chips over I2C or SPI
  54.     unsigned      can_sleep:1;
  55.     unsigned      exported:1;

  57. #if defined(CONFIG_OF_GPIO)
  58.     /*
  59.      * If CONFIG_OF is enabled, then all GPIO controllers described in the
  60.      * device tree automatically may have an OF translation
  61.      */
  62.     struct device_node *of_node;
  63.     int of_gpio_n_cells;
  64.     int (*of_xlate)(struct gpio_chip *gc, struct device_node *np,
  65.     const void *gpio_spec, u32 *flags);
  66. #endif
  67. };

 上述探讨的过程中一直存在一个问题，那就是开发板上的gpio是如何通过gpio框架注册到内核中，供驱动调用的呢？
 一般在内核的板级目录中存在对应的gpio.c文件，里面完成了将板级gpio设备到内核的映射的初始化工作，对应文件位置通常如下：
/arch/arm/mach-***/gpio.c

这里以TI的am33xx系列的板子为例进行探究：

/arch/arm/mach-omap2/gpio.c

点击(此处)折叠或打开

  1. static int omap2_gpio_dev_init(struct omap_hwmod *oh, void *unused)
  2. {
  3.     struct platform_device *pdev;
  4.     struct omap_gpio_platform_data *pdata;
  5.     struct omap_gpio_dev_attr *dev_attr;
  6.     char *name = "omap_gpio";
  7.     int id;

  9.     /*
  10.      * extract the device id from name field available in the hwmod database and use the same for constructing ids for gpio devices.
  11.      * CAUTION: Make sure the name in the hwmod database does not change. If changed, make corresponding change here or make use of
  12.      * static variable mechanism to handle this.
  13.      */
  14.     sscanf(oh->name, "gpio%d", &id);

  16.     pdata = kzalloc(sizeof(struct omap_gpio_platform_data), GFP_KERNEL);
  17.     if (!pdata) {
  18.         pr_err("gpio%d: Memory allocation failed\n", id);
  19.         return -ENOMEM;
  20.     }

  22.     dev_attr = (struct omap_gpio_dev_attr *)oh->dev_attr;
  23.     pdata->bank_width = dev_attr->bank_width;
  24.     pdata->dbck_flag = dev_attr->dbck_flag;
  25.     pdata->virtual_irq_start = IH_GPIO_BASE + 32 * (id - 1);

  27.     pdata->regs = kzalloc(sizeof(struct omap_gpio_reg_offs), GFP_KERNEL);
  28.     if (!pdata) {
  29.         pr_err("gpio%d: Memory allocation failed\n", id);
  30.         return -ENOMEM;
  31.     }

  33.     switch (oh->class->rev) {
  34.     case 0:
  35.     case 1:
  36.         pdata->bank_type = METHOD_GPIO_24XX;
  37.         pdata->regs->revision = OMAP24XX_GPIO_REVISION;
  38.         pdata->regs->direction = OMAP24XX_GPIO_OE;
  39.         pdata->regs->datain = OMAP24XX_GPIO_DATAIN;
  40.         pdata->regs->dataout = OMAP24XX_GPIO_DATAOUT;
  41.         pdata->regs->set_dataout = OMAP24XX_GPIO_SETDATAOUT;
  42.         pdata->regs->clr_dataout = OMAP24XX_GPIO_CLEARDATAOUT;
  43.         pdata->regs->irqstatus = OMAP24XX_GPIO_IRQSTATUS1;
  44.         pdata->regs->irqstatus2 = OMAP24XX_GPIO_IRQSTATUS2;
  45.         pdata->regs->irqenable = OMAP24XX_GPIO_IRQENABLE1;
  46.         pdata->regs->set_irqenable = OMAP24XX_GPIO_SETIRQENABLE1;
  47.         pdata->regs->clr_irqenable = OMAP24XX_GPIO_CLEARIRQENABLE1;
  48.         pdata->regs->debounce = OMAP24XX_GPIO_DEBOUNCE_VAL;
  49.         pdata->regs->debounce_en = OMAP24XX_GPIO_DEBOUNCE_EN;
  50.         break;
  51.     case 2:
  52.         pdata->bank_type = METHOD_GPIO_44XX;
  53.         pdata->regs->revision = OMAP4_GPIO_REVISION;
  54.         pdata->regs->direction = OMAP4_GPIO_OE;
  55.         pdata->regs->datain = OMAP4_GPIO_DATAIN;
  56.         pdata->regs->dataout = OMAP4_GPIO_DATAOUT;
  57.         pdata->regs->set_dataout = OMAP4_GPIO_SETDATAOUT;
  58.         pdata->regs->clr_dataout = OMAP4_GPIO_CLEARDATAOUT;
  59.         pdata->regs->irqstatus = OMAP4_GPIO_IRQSTATUS0;
  60.         pdata->regs->irqstatus2 = OMAP4_GPIO_IRQSTATUS1;
  61.         pdata->regs->irqenable = OMAP4_GPIO_IRQSTATUSSET0;
  62.         pdata->regs->set_irqenable = OMAP4_GPIO_IRQSTATUSSET0;
  63.         pdata->regs->clr_irqenable = OMAP4_GPIO_IRQSTATUSCLR0;
  64.         pdata->regs->debounce = OMAP4_GPIO_DEBOUNCINGTIME;
  65.         pdata->regs->debounce_en = OMAP4_GPIO_DEBOUNCENABLE;
  66.         break;
  67.     default:
  68.         WARN(1, "Invalid gpio bank_type\n");
  69.         kfree(pdata);
  70.         return -EINVAL;
  71.     }

  73.     pdev = omap_device_build(name, id - 1, oh, pdata,
  74.                 sizeof(*pdata),    NULL, 0, false);
  75.     kfree(pdata);

  77.     if (IS_ERR(pdev)) {
  78.         WARN(1, "Can't build omap_device for %s:%s.\n",
  79.                     name, oh->name);
  80.         return PTR_ERR(pdev);
  81.     }

  83.     omap_device_disable_idle_on_suspend(pdev);

  85.     gpio_bank_count++;
  86.     return 0;
  87. }

  89. /*
  90.  * gpio_init needs to be done before
  91.  * machine_init functions access gpio APIs.
  92.  * Hence gpio_init is a postcore_initcall.
  93.  */
  94. static int __init omap2_gpio_init(void)
  95. {
  96.     return omap_hwmod_for_each_by_class("gpio", omap2_gpio_dev_init,NULL);
  97. }
  98. postcore_initcall(omap2_gpio_init);

继续追踪代码：
arch/arm/mach-omap2/omap_hwmod.c

点击(此处)折叠或打开

  1. /**
  2.  * omap_hwmod_for_each_by_class - call @fn for each hwmod of class @classname
  3.  * @classname: struct omap_hwmod_class name to search for
  4.  * @fn: callback function pointer to call for each hwmod in class @classname
  5.  * @user: arbitrary context data to pass to the callback function
  6.  *
  7.  * For each omap_hwmod of class @classname, call @fn.
  8.  * If the callback function returns something other than
  9.  * zero, the iterator is terminated, and the callback function's return
  10.  * value is passed back to the caller. Returns 0 upon success, -EINVAL
  11.  * if @classname or @fn are NULL, or passes back the error code from @fn.
  12.  */
  13. int omap_hwmod_for_each_by_class(const char *classname,int (*fn)(struct omap_hwmod *oh,void *user), void *user)
  14. {
  15.     struct omap_hwmod *temp_oh;
  16.     int ret = 0;

  18.     if (!classname || !fn)
  19.         return -EINVAL;

  21.     pr_debug("omap_hwmod: %s: looking for modules of class %s\n",
  22.          __func__, classname);

  24.     list_for_each_entry(temp_oh, &omap_hwmod_list, node) {
  25.         if (!strcmp(temp_oh->class->name, classname)) {
  26.             pr_debug("omap_hwmod: %s: %s: calling callback fn\n",
  27.                  __func__, temp_oh->name);
  28.             ret = (*fn)(temp_oh, user);
  29.             if (ret)
  30.                 break;
  31.         }
  32.     }

  34.     if (ret)
  35.         pr_debug("omap_hwmod: %s: iterator terminated early: %d\n",
  36.              __func__, ret);

  38.     return ret;
  39. }
上面最终回归到对链表进行操作，那么链表上的这些节点又定义在哪里？链表又是何时建立的呢？
在板级目录下，还存在一个omap_hwmod_33xx_data.c文件，里面定义了该系列开发板的各个模块。
                                                                                                                             *****未完待续















阅读(2398) | 评论(0) | 转发(0) |
0

上一篇：Makefile中使用$$的使用

下一篇：GPIO的驱动模型

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6