• GPIO子系统（三）

    1，简述

    GPIO 资源是相对来说较为简单，而且比较通用（比如 LED 灯），而 Linux 的 GPIO 驱动属于 Linux Driver 中较为容易上手的部分，但是简单归简单，在 Linux 系统中，要使用 GPIO 资源，还是需要了解一些内容。

    Linux Kernel 中对 GPIO 资源进行了抽象，抽象出一个叫做 Gpiolib 的东东，这个东东作为 GPIO 资源的管理核心存在：

    中间层是 Gpiolib，用于管理系统中的 GPIO。Gpiolib 汇总了 GPIO 的通用操作，根据 GPIO 的特性，Gpiolib 对上（其他 Drivers）提供的一套统一通用的操作 GPIO 的软件接口，屏蔽了不同芯片的具体实现。对下，Gpiolib 提供了针对不同芯片操作的一套 framework，针对不同芯片，只需要实现 Specific Chip Driver ，然后使用 Gpiolib 提供的注册函数，将其挂接到 Gpiolib 上，这样就完成了这一套东西。

    对于其他驱动来说，比如 LED 灯驱动，就需要用到通用的 Gpiolib 的函数来进行 I/O 口的操作。

    2，Gpiolib相关数据结构分析

    先分析数据结构，Gpiolib 其实就是围绕几个数据结构在做文章，数据结构以及抽象层次清楚了，代码自然很快。

    数据结构主要定义在 include/linux/gpio/driver.h 和 /drivers/gpio/gpiolib.h 中

    首先看一个数据结构，叫 struct gpio_chip （include/linux/gpio/driver.h）：

    1. struct gpio_chip {
    2.     const char        *label;
    3.     struct gpio_device    *gpiodev;
    4.     struct device        *parent;
    5.     struct module        *owner;
    6.  
    7.     int            (*request)(struct gpio_chip *gc,
    8.                         unsigned int offset);
    9.     void            (*free)(struct gpio_chip *gc,
    10.                         unsigned int offset);
    11.     int            (*get_direction)(struct gpio_chip *gc,
    12.                         unsigned int offset);
    13.     int            (*direction_input)(struct gpio_chip *gc,
    14.                         unsigned int offset);
    15.     int            (*direction_output)(struct gpio_chip *gc,
    16.                         unsigned int offset, int value);
    17.     int            (*get)(struct gpio_chip *gc,
    18.                         unsigned int offset);
    19.     int            (*get_multiple)(struct gpio_chip *gc,
    20.                         unsigned long *mask,
    21.                         unsigned long *bits);
    22.     void            (*set)(struct gpio_chip *gc,
    23.                         unsigned int offset, int value);
    24.     void            (*set_multiple)(struct gpio_chip *gc,
    25.                         unsigned long *mask,
    26.                         unsigned long *bits);
    27.     int            (*set_config)(struct gpio_chip *gc,
    28.                           unsigned int offset,
    29.                           unsigned long config);
    30.     int            (*to_irq)(struct gpio_chip *gc,
    31.                         unsigned int offset);
    32.  
    33.  
    34.     void            (*dbg_show)(struct seq_file *s,
    35.                         struct gpio_chip *gc);
    36.  
    37.     int            (*init_valid_mask)(struct gpio_chip *gc,
    38.                            unsigned long *valid_mask,
    39.                            unsigned int ngpios);
    40.  
    41.     int            (*add_pin_ranges)(struct gpio_chip *gc);
    42.  
    43.     int            base;
    44.     u16            ngpio;
    45.     const char        *const *names;
    46.     bool            can_sleep;
    47.  
    48. #if IS_ENABLED(CONFIG_GPIO_GENERIC)
    49.     unsigned long (*read_reg)(void __iomem *reg);
    50.     void (*write_reg)(void __iomem *reg, unsigned long data);
    51.     bool be_bits;
    52.     void __iomem *reg_dat;
    53.     void __iomem *reg_set;
    54.     void __iomem *reg_clr;
    55.     void __iomem *reg_dir_out;
    56.     void __iomem *reg_dir_in;
    57.     bool bgpio_dir_unreadable;
    58.     int bgpio_bits;
    59.     spinlock_t bgpio_lock;
    60.     unsigned long bgpio_data;
    61.     unsigned long bgpio_dir;
    62. #endif /* CONFIG_GPIO_GENERIC */
    63.  
    64. #ifdef CONFIG_GPIOLIB_IRQCHIP
    65.     /*
    66.      * With CONFIG_GPIOLIB_IRQCHIP we get an irqchip inside the gpiolib
    67.      * to handle IRQs for most practical cases.
    68.      */
    69.  
    70.     /**
    71.      * @irq:
    72.      *
    73.      * Integrates interrupt chip functionality with the GPIO chip. Can be
    74.      * used to handle IRQs for most practical cases.
    75.      */
    76.     struct gpio_irq_chip irq;
    77. #endif /* CONFIG_GPIOLIB_IRQCHIP */
    78.  
    79.     /**
    80.      * @valid_mask:
    81.      *
    82.      * If not %NULL holds bitmask of GPIOs which are valid to be used
    83.      * from the chip.
    84.      */
    85.     unsigned long *valid_mask;
    86.  
    87. #if defined(CONFIG_OF_GPIO)
    88.     /*
    89.      * If CONFIG_OF is enabled, then all GPIO controllers described in the
    90.      * device tree automatically may have an OF translation
    91.      */
    92.  
    93.     /**
    94.      * @of_node:
    95.      *
    96.      * Pointer to a device tree node representing this GPIO controller.
    97.      */
    98.     struct device_node *of_node;
    99.  
    100.     /**
    101.      * @of_gpio_n_cells:
    102.      *
    103.      * Number of cells used to form the GPIO specifier.
    104.      */
    105.     unsigned int of_gpio_n_cells;
    106.  
    107.     /**
    108.      * @of_xlate:
    109.      *
    110.      * Callback to translate a device tree GPIO specifier into a chip-
    111.      * relative GPIO number and flags.
    112.      */
    113.     int (*of_xlate)(struct gpio_chip *gc,
    114.             const struct of_phandle_args *gpiospec, u32 *flags);
    115. #endif /* CONFIG_OF_GPIO */
    116.  
    117.     ANDROID_KABI_RESERVE(1);
    118.     ANDROID_KABI_RESERVE(2);
    119. };

    gpio_chip 这个数据结构一看，很多函数指针结构，明眼人秒懂，此结构是为了抽象 GPIO 的所有操作，同时适配不同芯片的一个 common 的结构，所以，这个结构是要开出去给其他芯片进行特定的操作赋值的，比如你是 Qcom 的芯片，那么你需要实现你的这些 gpio_chip 的内容。

    2.1 gpio_chip 结构

    一般的，在一个芯片中，针对所有的 I/O 口都会有配置，默认状态有些是 I/O 口全部默认 GPIO 输入（稳当）。一般芯片会提供管脚复用的功能（后期的 Linux 版本中，使用 pin control 来抽象），要使用 GPIO ，则首先需要配置他为 GPIO 功能，而不是其他的复用功能。

    而针对 GPIO 呢，有一些通用的特性，比如设置 GPIO 的方向，读 GPIO 的电平（输入的时候），写 GPIO 的电平（输出的时候），GPIO 作为外部中断输入，等等。

    gpio_chip 的抽象，其实是对 GPIO 一组 Bank 的抽象，通常在硬件上，一个芯片对 IO 口来说，分为了很多个 Bank，每个 Bank 分为了 N 组 GPIO。

    比如：1 个 SoC 将 I/O 分为了 4 个 Bank：

    1. Bank 1：GPIOA ～ GPIOB
    2. Bank 2：GPIOC ～ GPIOD
    3. Bank 3：GPIOE ～ GPIOF
    4. Bank 4：GPIOG ～ GPIOH

    然鹅，每个 Bank 都有 N 组寄存器来表示 GPIO 的操作，比如：

    Bank 1 中，针对 GPIO A：

    1. GPIOA_CFG 来表示对 GPIO A 的配置
    2. GPIOA_PULL 来表示对 GPIO A 的上下拉的配置
    3. GPIOA_DIR 来表示对 GPIO A 配置成为输入或者输出
    4. GPIOA_DATA 来表示 GPIO A 设置为输出的时候设置为高低或者输入的时候读高低

    当然，Bank 1 中 针对 GPIO B，也是一样的操作：

    1. GPIOB_CFG 来表示对 GPIO B 的配置
    2. GPIOB_PULL 来表示对 GPIO B 的上下拉的配置
    3. GPIOB_DIR 来表示对 GPIO B 配置成为输入或者输出
    4. GPIOB_DATA 来表示 GPIO B 设置为输出的时候设置为高低或者输入的时候读高低

    上面说的是一个 Bank 的情况，那么芯片有好几个 Bank，所以它们都是类似的，这里不在赘述。

    所以整体结构是如下所示（这里只是打个比方，有的芯片 Bank 很多，寄存器也很多）：

    Linux Driver Gpiolib 对他们的抽象，使用 gpio_chip 对应了一组 Bank 描述，比如 Bank ·1，用一个 gpio_chip 来抽象：

    那么多个 Bank ，就用指针，或者数组来表示咯。当然这里可能说得有点不准确，gpio_chip 只是抽象了一组 Bank 的统一的接口而已。

    那么对于一颗芯片底层来说，需要根据芯片手册 Datasheet，来实现这些结构的接口。

    2.2 gpio_desc结构

    既然系统分为多个 Bank，每个 Bank 又由几组组成，那么每个 GPIO 实体就由一个 gpio_desc 来描述：

    1. struct gpio_desc {
    2.     struct gpio_device    *gdev;
    3.     unsigned long        flags;
    4. /* flag symbols are bit numbers */
    5. #define FLAG_REQUESTED    0
    6. #define FLAG_IS_OUT    1
    7. #define FLAG_EXPORT    2    /* protected by sysfs_lock */
    8. #define FLAG_SYSFS    3    /* exported via /sys/class/gpio/control */
    9. #define FLAG_ACTIVE_LOW    6    /* value has active low */
    10. #define FLAG_OPEN_DRAIN    7    /* Gpio is open drain type */
    11. #define FLAG_OPEN_SOURCE 8    /* Gpio is open source type */
    12. #define FLAG_USED_AS_IRQ 9    /* GPIO is connected to an IRQ */
    13. #define FLAG_IRQ_IS_ENABLED 10    /* GPIO is connected to an enabled IRQ */
    14. #define FLAG_IS_HOGGED    11    /* GPIO is hogged */
    15. #define FLAG_TRANSITORY 12    /* GPIO may lose value in sleep or reset */
    16. #define FLAG_PULL_UP    13    /* GPIO has pull up enabled */
    17. #define FLAG_PULL_DOWN  14    /* GPIO has pull down enabled */
    18. #define FLAG_BIAS_DISABLE    15    /* GPIO has pull disabled */
    19. #define FLAG_EDGE_RISING     16    /* GPIO CDEV detects rising edge events */
    20. #define FLAG_EDGE_FALLING    17    /* GPIO CDEV detects falling edge events */
    21.  
    22.     /* Connection label */
    23.     const char        *label;
    24.     /* Name of the GPIO */
    25.     const char        *name;
    26. #ifdef CONFIG_OF_DYNAMIC
    27.     struct device_node    *hog;
    28. #endif
    29. #ifdef CONFIG_GPIO_CDEV
    30.     /* debounce period in microseconds */
    31.     unsigned int        debounce_period_us;
    32. #endif
    33. };

    这个结构比较简单，可以看到，他包含了一个 gpio_device 的结构和 flag，以及 lable 和 name；

    gdev 指针指向了这个 gpio_desc 所属的 gpio_device（马上描述），flag 代表了这个 GPIO 的属性状态；

    看起来 gpio_chip 和 gpio_desc 应该是包含关系，但是 Kernel 中并没有直接将其两个结构联系上，而是通过另外一个结构将其联系在一起，这个结构就是 gpio_device。

    2.3 gpio_device结构

    gpio_device 应该算是大内总管了（最新的内核有，Linux 3 版本的内核没有这个），如果说 gpio_chip 是对一个 Bank 的 GPIO 的硬件的具体抽象的话，那么 gpio_device 就是软件层面上对一个 Bank 的 GPIO 进行管理的单元，它的数据结构是：

    1. struct gpio_device {
    2.     int            id;
    3.     struct device        dev;
    4.     struct cdev        chrdev;
    5.     struct device        *mockdev;
    6.     struct module        *owner;
    7.     struct gpio_chip    *chip;
    8.     struct gpio_desc    *descs;
    9.     int            base;
    10.     u16            ngpio;
    11.     const char        *label;
    12.     void            *data;
    13.     struct list_head        list;
    14.     struct blocking_notifier_head notifier;
    15.  
    16. #ifdef CONFIG_PINCTRL
    17.     /*
    18.      * If CONFIG_PINCTRL is enabled, then gpio controllers can optionally
    19.      * describe the actual pin range which they serve in an SoC. This
    20.      * information would be used by pinctrl subsystem to configure
    21.      * corresponding pins for gpio usage.
    22.      */
    23.     struct list_head pin_ranges;
    24. #endif
    25. };

    在这个 gpio_device 结构中，包含了 gpio_chip（对接芯片的操作集），gpio_desc（一些 GPIO 的描述）；这个结构贯穿了整个 Gpiolib，因为 gpio_device 代表的是一个 Bank，一般的 GPIO 有多个 Bank，所以 Kernel 中，对这 gpio_device 的组织是由一个 gpio_devices 的链表构成（此处是多个 device，所以后面加了 s），在 gpiolib.c：

    LIST_HEAD(gpio_devices);

    2.4 gpio_chip/gpio_desc/gpio_device 结构体之间的关系

    3，Gpiolib对接芯片底层

    先聊聊 Gpiolib 是怎么对接到底层实际的驱动的。在前面的 2.1 部分讲过，底层需要对接的，其实对接的部分只有那些通用的操作，其实也就是 gpio_chip 这个玩意，所以，对接底层的部分，主要关心的是这个结构体，并且对这个结构体进行赋值的过程。

    在底层对接到 Gpiolib 的时候，主要是对 gpio_chip 进行实现，然后调用 gpiochip_add 的接口，向 Gpiolib 注册你的 GPIO 。

    实现的过程，主要是根据芯片手册，实现对应的 GPIO 的操作，也就是说，把寄存器操作编程成为函数，对接到这个 gpio_chip 结构体上。

    3.1 gpio_chip具体芯片操作函数的填充 - 一个gpio controller驱动gpio-pl061.c

    代码路径：drivers/gpio/gpio-pl061.c

    寄存器手册：http://access.ee.ntu.edu.tw/course/SOC%E5%AF%A6%E9%A9%97%E6%95%99%E6%9D%90/Version%203/Lab05_External%20IO%20Control/Doc/Ref/ddi0190_gpio_trm.pdf

    pl061是通过AMBA总线连接在SOC上的片上gpio controller，arm架构的芯片经过授权之后可以直接使用。

    部分寄存器描述：

    suspend/resume操作：

    1. #ifdef CONFIG_PM
    2. //suspend函数中保存当前所有gpio pin寄存器状态
    3. static int pl061_suspend(struct device *dev)
    4. {
    5.     struct pl061 *pl061 = dev_get_drvdata(dev);
    6.     int offset;
    7.  
    8.     pl061->csave_regs.gpio_data = 0;
    9.     pl061->csave_regs.gpio_dir = readb(pl061->base + GPIODIR);
    10.     pl061->csave_regs.gpio_is = readb(pl061->base + GPIOIS);
    11.     pl061->csave_regs.gpio_ibe = readb(pl061->base + GPIOIBE);
    12.     pl061->csave_regs.gpio_iev = readb(pl061->base + GPIOIEV);
    13.     pl061->csave_regs.gpio_ie = readb(pl061->base + GPIOIE);
    14.  
    15.     for (offset = 0; offset < PL061_GPIO_NR; offset++) {
    16.         if (pl061->csave_regs.gpio_dir & (BIT(offset)))
    17.             pl061->csave_regs.gpio_data |=
    18.                 pl061_get_value(&pl061->gc, offset) << offset;
    19.     }
    20.  
    21.     return 0;
    22. }
    23.  
    24. //resume函数中将gpio pin的寄存器状态恢复
    25. static int pl061_resume(struct device *dev)
    26. {
    27.     struct pl061 *pl061 = dev_get_drvdata(dev);
    28.     int offset;
    29.  
    30.     for (offset = 0; offset < PL061_GPIO_NR; offset++) {
    31.         if (pl061->csave_regs.gpio_dir & (BIT(offset)))
    32.             pl061_direction_output(&pl061->gc, offset,
    33.                     pl061->csave_regs.gpio_data &
    34.                     (BIT(offset)));
    35.         else
    36.             pl061_direction_input(&pl061->gc, offset);
    37.     }
    38.  
    39.     writeb(pl061->csave_regs.gpio_is, pl061->base + GPIOIS);
    40.     writeb(pl061->csave_regs.gpio_ibe, pl061->base + GPIOIBE);
    41.     writeb(pl061->csave_regs.gpio_iev, pl061->base + GPIOIEV);
    42.     writeb(pl061->csave_regs.gpio_ie, pl061->base + GPIOIE);
    43.  
    44.     return 0;
    45. }

    probe函数流程：

    1. static int pl061_probe(struct amba_device *adev, const struct amba_id *id)
    2. {
    3.     struct device *dev = &adev->dev;
    4.     struct pl061 *pl061;
    5.     struct gpio_irq_chip *girq;
    6.     int ret, irq;
    7.  
    8.     pl061 = devm_kzalloc(dev, sizeof(*pl061), GFP_KERNEL);
    9.     if (pl061 == NULL)
    10.         return -ENOMEM;
    11.  
    12.     pl061->base = devm_ioremap_resource(dev, &adev->res);
    13.     if (IS_ERR(pl061->base))
    14.         return PTR_ERR(pl061->base);
    15.  
    16.     //填充gpio_chip中的回调函数
    17.     raw_spin_lock_init(&pl061->lock);
    18.     pl061->gc.request = gpiochip_generic_request;
    19.     pl061->gc.free = gpiochip_generic_free;
    20.     pl061->gc.base = -1;
    21.     pl061->gc.get_direction = pl061_get_direction;
    22.     pl061->gc.direction_input = pl061_direction_input;
    23.     pl061->gc.direction_output = pl061_direction_output;
    24.     pl061->gc.get = pl061_get_value;
    25.     pl061->gc.set = pl061_set_value;
    26.     pl061->gc.ngpio = PL061_GPIO_NR; //8
    27.     pl061->gc.label = dev_name(dev);
    28.     pl061->gc.parent = dev;
    29.     pl061->gc.owner = THIS_MODULE;
    30.  
    31.     /*
    32.      * irq_chip support
    33.      */
    34.     pl061->irq_chip.name = dev_name(dev);
    35.     pl061->irq_chip.irq_ack    = pl061_irq_ack;
    36.     pl061->irq_chip.irq_mask = pl061_irq_mask;
    37.     pl061->irq_chip.irq_unmask = pl061_irq_unmask;
    38.     pl061->irq_chip.irq_set_type = pl061_irq_type;
    39.     pl061->irq_chip.irq_set_wake = pl061_irq_set_wake;
    40.  
    41.     writeb(0, pl061->base + GPIOIE); /* disable irqs */
    42.     irq = adev->irq[0];
    43.     if (!irq)
    44.         dev_warn(&adev->dev, "IRQ support disabled\n");
    45.     pl061->parent_irq = irq;
    46.  
    47.     girq = &pl061->gc.irq;
    48.     girq->chip = &pl061->irq_chip;
    49.     girq->parent_handler = pl061_irq_handler;
    50.     girq->num_parents = 1;
    51.     girq->parents = devm_kcalloc(dev, 1, sizeof(*girq->parents),
    52.                      GFP_KERNEL);
    53.     if (!girq->parents)
    54.         return -ENOMEM;
    55.     girq->parents[0] = irq;
    56.     girq->default_type = IRQ_TYPE_NONE;
    57.     girq->handler = handle_bad_irq;
    58.  
    59.     //注册gpio资源
    60.     ret = devm_gpiochip_add_data(dev, &pl061->gc, pl061);
    61.     if (ret)
    62.         return ret;
    63.  
    64.     amba_set_drvdata(adev, pl061);
    65.     dev_info(dev, "PL061 GPIO chip registered\n");
    66.  
    67.     return 0;
    68. }

    几个gpio_chip函数的实现 - pl061_get_direction

    1. static int pl061_get_direction(struct gpio_chip *gc, unsigned offset)
    2. {
    3.     //per-instance data assigned by the driver， return gc->gpiodev->data
    4.     struct pl061 *pl061 = gpiochip_get_data(gc);
    5.  
    6.     //读取GPIODIR寄存器判断是输入或者输出并返回结果
    7.     if (readb(pl061->base + GPIODIR) & BIT(offset))
    8.         return GPIO_LINE_DIRECTION_OUT;
    9.  
    10.     return GPIO_LINE_DIRECTION_IN;
    11. }

    几个gpio_chip函数的实现 -pl061_set_value

    1. static void pl061_set_value(struct gpio_chip *gc, unsigned offset, int value)
    2. {
    3.     struct pl061 *pl061 = gpiochip_get_data(gc);
    4.  
    5.     //设置GPIODATA寄存器
    6.     writeb(!!value << offset, pl061->base + (BIT(offset + 2)));
    7. }
    3.2 gpiochip_add_data_with_key

    1）

    1. int gpiochip_add_data_with_key(struct gpio_chip *gc, void *data,
    2.                    struct lock_class_key *lock_key,
    3.                    struct lock_class_key *request_key)
    4. {
    5.     struct fwnode_handle *fwnode = gc->parent ? dev_fwnode(gc->parent) : NULL;
    6.     unsigned long    flags;
    7.     int        ret = 0;
    8.     unsigned    i;
    9.     int        base = gc->base;
    10.     struct gpio_device *gdev;
    11.     bool        block_gpio_read = false;
    12.  
    13.     /*
    14.      * First: allocate and populate the internal stat container, and
    15.      * set up the struct device.
    16.      */
    17.     gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
    18.     if (!gdev)
    19.         return -ENOMEM;
    20.     gdev->dev.bus = &gpio_bus_type;
    21.     gdev->chip = gc;
    22.     gc->gpiodev = gdev;
    23.     if (gc->parent) {
    24.         gdev->dev.parent = gc->parent;
    25.         gdev->dev.of_node = gc->parent->of_node;
    26.     }
    27.  
    28.     of_gpio_dev_init(gc, gdev);
    29.  
    30.     /*
    31.      * Assign fwnode depending on the result of the previous calls,
    32.      * if none of them succeed, assign it to the parent's one.
    33.      */
    34.     gdev->dev.fwnode = dev_fwnode(&gdev->dev) ?: fwnode;
    35.     
    36.     //给chip分配唯一的ID
    37.     gdev->id = ida_alloc(&gpio_ida, GFP_KERNEL);
    38.     if (gdev->id < 0) {
    39.         ret = gdev->id;
    40.         goto err_free_gdev;
    41.     }
    42.  
    43.     ret = dev_set_name(&gdev->dev, GPIOCHIP_NAME "%d", gdev->id);
    44.     if (ret)
    45.         goto err_free_ida;
    46.  
    47.     device_initialize(&gdev->dev);
    48.     if (gc->parent && gc->parent->driver)
    49.         gdev->owner = gc->parent->driver->owner;
    50.     else if (gc->owner)
    51.         /* TODO: remove chip->owner */
    52.         gdev->owner = gc->owner;
    53.     else
    54.         gdev->owner = THIS_MODULE;

    因为传入的结构是 gpio_chip，他代表了是一个 Bank，但是并没有 gpio_device 的结构，所以，在这个函数中，首先分配一个 gpio_device 的结构，并将其结构体成员的 chip ，等等进行赋值，建立起相关的结构联系。

    2）

    1.  gdev->descs = kcalloc(gc->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
    2.     if (!gdev->descs) {
    3.         ret = -ENOMEM;
    4.         goto err_free_dev_name;
    5.     }
    6.  
    7.     if (gc->ngpio == 0) {
    8.         chip_err(gc, "tried to insert a GPIO chip with zero lines\n");
    9.         ret = -EINVAL;
    10.         goto err_free_descs;
    11.     }
    12.  
    13.     if (gc->ngpio > FASTPATH_NGPIO)
    14.         chip_warn(gc, "line cnt %u is greater than fast path cnt %u\n",
    15.               gc->ngpio, FASTPATH_NGPIO);
    16.  
    17.     gdev->label = kstrdup_const(gc->label ?: "unknown", GFP_KERNEL);
    18.     if (!gdev->label) {
    19.         ret = -ENOMEM;
    20.         goto err_free_descs;
    21.     }
    22.  
    23.     gdev->ngpio = gc->ngpio;
    24.     gdev->data = data;

    由于 1 个 Bank不仅仅只有一个 GPIO，所以 gpio_chip->ngpio 的结构表示了这个 Bank 一共的 GPIO 个数，每一个 GPIO 使用一个 gpio_desc 表示，所以，这里分配了 ngpio 个 descs；

     3）

    1.  spin_lock_irqsave(&gpio_lock, flags);
    2.  
    3.     /*
    4.      * TODO: this allocates a Linux GPIO number base in the global
    5.      * GPIO numberspace for this chip. In the long run we want to
    6.      * get *rid* of this numberspace and use only descriptors, but
    7.      * it may be a pipe dream. It will not happen before we get rid
    8.      * of the sysfs interface anyways.
    9.      */
    10.     if (base < 0) {
    11.         base = gpiochip_find_base(gc->ngpio);
    12.         if (base < 0) {
    13.             ret = base;
    14.             spin_unlock_irqrestore(&gpio_lock, flags);
    15.             goto err_free_label;
    16.         }
    17.         /*
    18.          * TODO: it should not be necessary to reflect the assigned
    19.          * base outside of the GPIO subsystem. Go over drivers and
    20.          * see if anyone makes use of this, else drop this and assign
    21.          * a poison instead.
    22.          */
    23.         gc->base = base;
    24.     }
    25.     gdev->base = base;
    26.  
    27.     ret = gpiodev_add_to_list(gdev);
    28.     if (ret) {
    29.         spin_unlock_irqrestore(&gpio_lock, flags);
    30.         goto err_free_label;
    31.     }
    32.  
    33.     for (i = 0; i < gc->ngpio; i++)
    34.         gdev->descs[i].gdev = gdev;
    35.  
    36.     spin_unlock_irqrestore(&gpio_lock, flags);
    37.  
    38.     BLOCKING_INIT_NOTIFIER_HEAD(&gdev->notifier);
    39.  
    40. #ifdef CONFIG_PINCTRL
    41.     INIT_LIST_HEAD(&gdev->pin_ranges);
    42. #endif
    43.  
    44.     if (gc->names)
    45.         ret = gpiochip_set_desc_names(gc);
    46.     else
    47.         ret = devprop_gpiochip_set_names(gc);
    48.     if (ret)
    49.         goto err_remove_from_list;
    50.  
    51.     ret = gpiochip_alloc_valid_mask(gc);
    52.     if (ret)
    53.         goto err_remove_from_list;
    54.  
    55.     ret = of_gpiochip_add(gc);
    56.     if (ret)
    57.         goto err_free_gpiochip_mask;
    58.  
    59.     ret = gpiochip_init_valid_mask(gc);
    60.     if (ret)
    61.         goto err_remove_of_chip;
    62.  
    63.     trace_android_vh_gpio_block_read(gdev, &block_gpio_read);
    64.     if (!block_gpio_read) {
    65.         for (i = 0; i < gc->ngpio; i++) {
    66.             struct gpio_desc *desc = &gdev->descs[i];
    67.  
    68.             if (gc->get_direction && gpiochip_line_is_valid(gc, i)) {
    69.                 assign_bit(FLAG_IS_OUT,
    70.                        &desc->flags, !gc->get_direction(gc, i));
    71.             } else {
    72.                 assign_bit(FLAG_IS_OUT,
    73.                        &desc->flags, !gc->direction_input);
    74.             }
    75.         }
    76.     }
    77.  
    78.     ret = gpiochip_add_pin_ranges(gc);
    79.     if (ret)
    80.         goto err_remove_of_chip;
    81.  
    82.     acpi_gpiochip_add(gc);
    83.  
    84.     machine_gpiochip_add(gc);
    85.  
    86.     ret = gpiochip_irqchip_init_valid_mask(gc);
    87.     if (ret)
    88.         goto err_remove_acpi_chip;
    89.  
    90.     ret = gpiochip_irqchip_init_hw(gc);
    91.     if (ret)
    92.         goto err_remove_acpi_chip;
    93.  
    94.     ret = gpiochip_add_irqchip(gc, lock_key, request_key);
    95.     if (ret)
    96.         goto err_remove_irqchip_mask;
    97.  
    98.     /*
    99.      * By first adding the chardev, and then adding the device,
    100.      * we get a device node entry in sysfs under
    101.      * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
    102.      * coldplug of device nodes and other udev business.
    103.      * We can do this only if gpiolib has been initialized.
    104.      * Otherwise, defer until later.
    105.      */
    106.     if (gpiolib_initialized) {
    107.         ret = gpiochip_setup_dev(gdev);
    108.         if (ret)
    109.             goto err_remove_irqchip;
    110.     }
    111.     return 0;
    112.  
    113. err_remove_irqchip:
    114.     gpiochip_irqchip_remove(gc);
    115. err_remove_irqchip_mask:
    116.     gpiochip_irqchip_free_valid_mask(gc);
    117. err_remove_acpi_chip:
    118.     acpi_gpiochip_remove(gc);
    119. err_remove_of_chip:
    120.     gpiochip_free_hogs(gc);
    121.     of_gpiochip_remove(gc);
    122. err_free_gpiochip_mask:
    123.     gpiochip_remove_pin_ranges(gc);
    124.     gpiochip_free_valid_mask(gc);
    125. err_remove_from_list:
    126.     spin_lock_irqsave(&gpio_lock, flags);
    127.     list_del(&gdev->list);
    128.     spin_unlock_irqrestore(&gpio_lock, flags);
    129. err_free_label:
    130.     kfree_const(gdev->label);
    131. err_free_descs:
    132.     kfree(gdev->descs);
    133. err_free_dev_name:
    134.     kfree(dev_name(&gdev->dev));
    135. err_free_ida:
    136.     ida_free(&gpio_ida, gdev->id);
    137. err_free_gdev:
    138.     /* failures here can mean systems won't boot... */
    139.     pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__,
    140.            gdev->base, gdev->base + gdev->ngpio - 1,
    141.            gc->label ? : "generic", ret);
    142.     kfree(gdev);
    143.     return ret;
    144. }
    145. EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);

    base 代表了每个 Bank 的编号，将其赋值；然后通过 gpiodev_add_to_list(gdev) 将这个 gdev 挂到全局的 gpio_devices ：

    1. /*
    2. * Add a new chip to the global chips list, keeping the list of chips sorted
    3. * by range(means [base, base + ngpio - 1]) order.
    4. *
    5. * Return -EBUSY if the new chip overlaps with some other chip's integer
    6. * space.
    7. */
    8. static int gpiodev_add_to_list(struct gpio_device *gdev)
    9. {
    10.     struct gpio_device *prev, *next;
    11.  
    12.     if (list_empty(&gpio_devices)) {
    13.         /* initial entry in list */
    14.         list_add_tail(&gdev->list, &gpio_devices);
    15.         return 0;
    16.     }
    17.  
    18.     next = list_entry(gpio_devices.next, struct gpio_device, list);
    19.     if (gdev->base + gdev->ngpio <= next->base) {
    20.         /* add before first entry */
    21.         list_add(&gdev->list, &gpio_devices);
    22.         return 0;
    23.     }
    24.  
    25.     prev = list_entry(gpio_devices.prev, struct gpio_device, list);
    26.     if (prev->base + prev->ngpio <= gdev->base) {
    27.         /* add behind last entry */
    28.         list_add_tail(&gdev->list, &gpio_devices);
    29.         return 0;
    30.     }
    31.  
    32.     list_for_each_entry_safe(prev, next, &gpio_devices, list) {
    33.         /* at the end of the list */
    34.         if (&next->list == &gpio_devices)
    35.             break;
    36.  
    37.         /* add between prev and next */
    38.         if (prev->base + prev->ngpio <= gdev->base
    39.                 && gdev->base + gdev->ngpio <= next->base) {
    40.             list_add(&gdev->list, &prev->list);
    41.             return 0;
    42.         }
    43.     }
    44.  
    45.     dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
    46.     return -EBUSY;
    47. }

    接着就是设置一些 name 字段，配置中断之类的，初始化每个 desc[] 结构的 flags，最后调用：

    1.     if (gpiolib_initialized) {
    2.         ret = gpiochip_setup_dev(gdev);
    3.         if (ret)
    4.             goto err_remove_irqchip;
    5.     }

    然后，不出意外的话，返回 0；

    这里说一下 gpiochip_setup_dev 调用，这个是在 Gpiolib init 的时候调用 gpiochip_setup_devs：

    1. static int __init gpiolib_dev_init(void)
    2. {
    3.     int ret;
    4.  
    5.     /* Register GPIO sysfs bus */
    6.     ret = bus_register(&gpio_bus_type);
    7.     if (ret < 0) {
    8.         pr_err("gpiolib: could not register GPIO bus type\n");
    9.         return ret;
    10.     }
    11.  
    12.     ret = driver_register(&gpio_stub_drv);
    13.     if (ret < 0) {
    14.         pr_err("gpiolib: could not register GPIO stub driver\n");
    15.         bus_unregister(&gpio_bus_type);
    16.         return ret;
    17.     }
    18.  
    19.     ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, GPIOCHIP_NAME);
    20.     if (ret < 0) {
    21.         pr_err("gpiolib: failed to allocate char dev region\n");
    22.         driver_unregister(&gpio_stub_drv);
    23.         bus_unregister(&gpio_bus_type);
    24.         return ret;
    25.     }
    26.  
    27.     gpiolib_initialized = true;
    28.     gpiochip_setup_devs();
    29.  
    30. #if IS_ENABLED(CONFIG_OF_DYNAMIC) && IS_ENABLED(CONFIG_OF_GPIO)
    31.     WARN_ON(of_reconfig_notifier_register(&gpio_of_notifier));
    32. #endif /* CONFIG_OF_DYNAMIC && CONFIG_OF_GPIO */
    33.  
    34.     return ret;
    35. }
    36. core_initcall(gpiolib_dev_init);

    而这个 gpiochip_setup_devs 对每一个 gpio_devicecs 节点调用：gpiochip_setup_dev：

    1. static void gpiochip_setup_devs(void)
    2. {
    3.     struct gpio_device *gdev;
    4.     int ret;
    5.  
    6.     list_for_each_entry(gdev, &gpio_devices, list) {
    7.         ret = gpiochip_setup_dev(gdev);
    8.         if (ret)
    9.             dev_err(&gdev->dev,
    10.                 "Failed to initialize gpio device (%d)\n", ret);
    11.     }
    12. }

    最后到：

    1. static int gpiochip_setup_dev(struct gpio_device *gdev)
    2. {
    3.     int ret;
    4.  
    5.     ret = gcdev_register(gdev, gpio_devt);
    6.     if (ret)
    7.         return ret;
    8.  
    9.     ret = gpiochip_sysfs_register(gdev);
    10.     if (ret)
    11.         goto err_remove_device;
    12.  
    13.     /* From this point, the .release() function cleans up gpio_device */
    14.     gdev->dev.release = gpiodevice_release;
    15.     dev_dbg(&gdev->dev, "registered GPIOs %d to %d on %s\n", gdev->base,
    16.         gdev->base + gdev->ngpio - 1, gdev->chip->label ? : "generic");
    17.  
    18.     return 0;
    19.  
    20. err_remove_device:
    21.     gcdev_unregister(gdev);
    22.     return ret;
    23. }

    其实就是注册了字符设备，并且添加到了 sysfs；

    debug logs：

    1. char dev节点：/sys/bus/gpio/devices
    2. ls -l /sys/bus/gpio/devices
    3. total 0
    4. lrwxrwxrwx 1 root root 0 2023-09-21 06:52 gpiochip0 -> ../../../devices/platform/soc/f000000.pinctrl/gpiochip0
    5. lrwxrwxrwx 1 root root 0 2023-09-21 06:52 gpiochip1 -> ../../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-00/c42d000.qcom,spmi:qcom,pmk8350@0:pinctrl@b000/gpiochip1
    6. lrwxrwxrwx 1 root root 0 2023-09-21 06:52 gpiochip2 -> ../../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-02/c42d000.qcom,spmi:qcom,pm8350c@2:pinctrl@8800/gpiochip2
    7. lrwxrwxrwx 1 root root 0 2023-09-21 06:52 gpiochip3 -> ../../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-01/c42d000.qcom,spmi:qcom,pm7325@1:pinctrl@8800/gpiochip3
    8. lrwxrwxrwx 1 root root 0 2023-09-21 06:52 gpiochip4 -> ../../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-03/c42d000.qcom,spmi:qcom,pm8350b@3:pinctrl@8800/gpiochip4
    9. lrwxrwxrwx 1 root root 0 2023-09-21 06:52 gpiochip5 -> ../../../devices/platform/soc/soc:spf_core_platform/soc:spf_core_platform:lpi_pinctrl@3440000/gpiochip5
    10.  
    11. sysfs节点 /sys/class/gpio
    12. ls -l /sys/class/gpio/
    13. total 0
    14. --w------- 1 root root 4096 2023-09-21 06:53 export
    15. lrwxrwxrwx 1 root root    0 2023-09-21 06:53 gpiochip287 -> ../../devices/platform/soc/soc:spf_core_platform/soc:spf_core_platform:lpi_pinctrl@3440000/gpio/gpiochip287
    16. lrwxrwxrwx 1 root root    0 2023-09-21 06:53 gpiochip310 -> ../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-03/c42d000.qcom,spmi:qcom,pm8350b@3:pinctrl@8800/gpio/gpiochip310
    17. lrwxrwxrwx 1 root root    0 2023-09-21 06:53 gpiochip318 -> ../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-01/c42d000.qcom,spmi:qcom,pm7325@1:pinctrl@8800/gpio/gpiochip318
    18. lrwxrwxrwx 1 root root    0 2023-09-21 06:53 gpiochip328 -> ../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-02/c42d000.qcom,spmi:qcom,pm8350c@2:pinctrl@8800/gpio/gpiochip328
    19. lrwxrwxrwx 1 root root    0 2023-09-21 06:53 gpiochip337 -> ../../devices/platform/soc/c42d000.qcom,spmi/spmi-0/0-00/c42d000.qcom,spmi:qcom,pmk8350@0:pinctrl@b000/gpio/gpiochip337
    20. lrwxrwxrwx 1 root root    0 2023-09-21 06:53 gpiochip341 -> ../../devices/platform/soc/f000000.pinctrl/gpio/gpiochip341
    21. --w------- 1 root root 4096 2023-09-21 06:53 unexport
    1. dev_dbg(&gdev->dev, "registered GPIOs %d to %d on %s\n", gdev->base, gdev->base + gdev->ngpio - 1, gdev->chip->label ? : "generic");
    2.  
    3. 05-23 16:18:33.460     1     1 E gpiochip0: (f000000.pinctrl): william_gpio added GPIO chardev (254:0)
    4. 05-23 16:18:33.460     1     1 E gpiochip0: william_gpio registered GPIOs 341 to 511 on f000000.pinctrl
    5. 05-23 16:18:35.347   357   357 E gpiochip1: (c42d000.qcom,spmi:qcom,pmk8350@0:pinctrl@b000): william_gpio added GPIO chardev (254:1)
    6. 05-23 16:18:35.347   357   357 E gpiochip1: william_gpio registered GPIOs 337 to 340 on c42d000.qcom,spmi:qcom,pmk8350@0:pinctrl@b000
    7. 05-23 16:18:35.351   357   357 E gpiochip2: (c42d000.qcom,spmi:qcom,pm8350c@2:pinctrl@8800): william_gpio added GPIO chardev (254:2)
    8. 05-23 16:18:35.351   357   357 E gpiochip2: william_gpio registered GPIOs 328 to 336 on c42d000.qcom,spmi:qcom,pm8350c@2:pinctrl@8800
    9. 05-23 16:18:35.361   357   357 E gpiochip3: (c42d000.qcom,spmi:qcom,pm7325@1:pinctrl@8800): william_gpio added GPIO chardev (254:3)
    10. 05-23 16:18:35.361   357   357 E gpiochip3: william_gpio registered GPIOs 318 to 327 on c42d000.qcom,spmi:qcom,pm7325@1:pinctrl@8800
    11. 05-23 16:18:35.362   357   357 E gpiochip4: (c42d000.qcom,spmi:qcom,pm8350b@3:pinctrl@8800): william_gpio added GPIO chardev (254:4)
    12. 05-23 16:18:35.362   357   357 E gpiochip4: william_gpio registered GPIOs 310 to 317 on c42d000.qcom,spmi:qcom,pm8350b@3:pinctrl@8800
    13. 09-21 01:52:25.519   758   758 E gpiochip5: (soc:spf_core_platform:lpi_pinctrl@3440000): william_gpio added GPIO chardev (254:5)
    14. 09-21 01:52:25.519   758   758 E gpiochip5: william_gpio registered GPIOs 287 to 309 on soc:spf_core_platform:lpi_pinctrl@3440000
    17. chip       base  ngpio  gdev->chip->label
    18. gpiochip0  341   170    f000000.pinctrl
    19. gpiochip1  337   3      pmk8350@0:pinctrl@b000
    20. gpiochip2  328   8      pm8350c@2:pinctrl@8800
    21. gpiochip3  318   9      pm7325@1:pinctrl@8800
    22. gpiochip4  310   7      pm8350b@3:pinctrl@8800
    23. gpiochip5  287   22     lpi_pinctrl@3440000

    个人理解，因为不知道这个 init 和我们的对接底层的驱动的 init 谁先执行到，所以用了一个变量 gpiolib_initialized 来表示当前的 Gpiolib 是不是已经完成了相关的字符设备的注册，如果是 Gpiolib 先去 init 的话，那么 gpiolib_initialized  ture，芯片对接底层的部分错过 gpio_chip setup 的机会，所以需要重新调用这个 gpiochip_setup_dev 接口，反之 OK；

    到这里，对接底层驱动的部分基本上 OK 了，小伙伴们需要按照自己芯片的 Specific 去做自己的 gpio_chip 结构并最终通过 gpiochip_add_data 添加到 Gpiolib 子系统中；

    还有一点需要注意到的是，小伙伴们需要自行定义一些结构，来获得并表示自己 Bank 的虚拟地址等等，这样才能操作到实际的硬件寄存器；

    4，gpiolib 向上提供的操作接口

    两种不同的gpio框架:

     * descriptor-based interface: 基于描述符的接口, 新框架, 官方推荐;

     * legacy integer-based interface: 基于整数的接口;

    4.1 基于描述符的gpio在dts中使用

    参考:

    Documentation/gpio/board.txt

    1. #include 
    2.  
    3. foo_device {
    4.     compatible = "acme,foo";
    5.     ...
    6.     led-gpios = <&gpio 15 GPIO_ACTIVE_HIGH>, /* red */
    7.                 <&gpio 16 GPIO_ACTIVE_HIGH>, /* green */
    8.                 <&gpio 17 GPIO_ACTIVE_HIGH>; /* blue */
    9.  
    10.     power-gpio = <&gpio 18 GPIO_ACTIVE_LOW>;
    11. };
    12.  
    13. struct gpio_desc *red, *green, *blue, *power;
    14.  
    15. red = gpiod_get_index(dev, "led", 0);
    16. green = gpiod_get_index(dev, "led", 1);
    17. blue = gpiod_get_index(dev, "led", 2);
    18. power = gpiod_get(dev, "power");
    19.  
    20. gpiod_direction_output(red, 1);
    21. gpiod_direction_output(green, 1);
    22. gpiod_direction_output(blue, 1);
    23. gpiod_direction_output(power, 1);
    24.  
    25. gpiod_put(red);    //释放gpio口;

    dts中gpio label的写法: name-gpios, 其中name是gpiod_get*()函数里的第二个参数;

    The led GPIOs will be active-high, while the power GPIO will be active-low;

    gpiod_is_active_low(power); 为true;

    4.2 基于整数的gpio在dts中使用
    1. device_node {
    2.     ...
    3.     gpio_name = <&tlmm 99 0>;
    4.     ...
    5. }
    6.  
    7. int gpio_99 = of_get_named_gpio_flags(dev->of_node, "gpio_name", 0, NULL);
    8. gpio_request(gpio_99, "gpio_name");                //通过gpio号申请gpio
    9. gpio_direction_output(gpio_99, 1);                //设置gpio_99输出，初始值为1
    10. gpio_set_value(gpio_99, 0);                        //设置gpio_99值为0
    11. gpio_free(gpio_99);                             
    12.  
    13. gpio_get_value(gpio_99, 0);                        //获取gpio_99的值

    这种方法目前最常用;

    gpio_request()流程：

    1. gpio_request()
    2.     *desc = gpio_to_desc(gpio);
    3.     gpiod_request(desc, label);
    4.         gpiod_request_commit(desc, label);
    5.             offset = gpio_chip_hwgpio(desc);
    6.             gc->request(gc, offset);
    7.                 pl061->gc.request = gpiochip_generic_request;
    8.                     pinctrl_gpio_request(gc->gpiodev->base + offset); //drivers/pinctrl/core.c
    9.                         pin = gpio_to_pin(range, gpio);
    10.                         pinmux_request_gpio(pctldev, range, pin, gpio);
    11.                             pin_request(pctldev, pin, owner, range);
    12.                                 ops->gpio_request_enable(pctldev, gpio_range, pin);

    可以看到GPIO子系统是通过pinctrl子系统来实现的。

    gpio_direction_output()流程：

    1. gpio_direction_output()
    2.     gpiod_direction_output_raw(gpio_to_desc(gpio), value);
    3.         gpiod_direction_output_raw_commit(desc, value);
    4.             *gc = desc->gdev->chip;
    5.             gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
    6.                 pl061->gc.direction_output = pl061_direction_output;
    4.3 Device-managed variants函数

    代码路径：drivers/gpio/gpiolib-devres.c

    1. struct gpio_desc *devm_gpiod_get(struct device *dev, const char *con_id,
    2.                      enum gpiod_flags flags)
    3.  
    4. struct gpio_desc *devm_gpiod_get_index(struct device *dev,
    5.                        const char *con_id,
    6.                        unsigned int idx,
    7.                        enum gpiod_flags flags)
    8.  
    9. struct gpio_desc *devm_gpiod_get_optional(struct device *dev,
    10.                       const char *con_id,
    11.                       enum gpiod_flags flags)
    12.  
    13. struct gpio_desc * devm_gpiod_get_index_optional(struct device *dev,
    14.                         const char *con_id,
    15.                         unsigned int index,
    16.                         enum gpiod_flags flags)

    释放gpio:

    1. void gpiod_put(struct gpio_desc *desc);
    2. void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
    4.4 新旧框架的相互转换
    1. gpio与gpio_desc结构体的相互转换:
    2. static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];    //gpiolib.c
    3. gpio_to_desc(unsigned gpio)    
    4.     &gpio_desc[gpio]    //这里的gpio_desc是同名结构体的数组;
    5.     
    6. int desc_to_gpio(const struct gpio_desc *desc)    //gpiolib.c
    7.     return desc - &gpio_desc[0];

    参考链接：

    Linux GPIO 驱动 （gpiolib）_devm_gpiochip_add_data-CSDN博客

    linux gpio学习笔记(gpiolib)_devm_gpiod_get_verdicty的博客-CSDN博客

  • 相关阅读:
    js 定时器 setInterval(图片的自动变换)
    C#，数值计算——插值和外推，双线性插值（Bilin_interp）的计算方法与源程序
    短视频seo矩阵系统源码开发搭建--代用户发布视频能力
    云原生Kubernetes:K8S概述
    Immutable 插件库的使用（数据深拷贝）
    Kubernetes 介绍
    十五、修改VGG16网络来适应自己的需求
    CentOS7安装Oracle完整教程（超级详细，亲测完美）
    Codeforces Round 924 (Div. 2)----＞B. Equalize
    PostGreSQL:时间戳时区问题
  • 原文地址：https://blog.csdn.net/u011456016/article/details/133818303