嵌入式Linux驱动笔记(二十一)------GPIO和Pinctrl子系统的思考

版权声明：本文为 风筝 博主原创文章，未经博主允许不得转载！！！！！！谢谢合作 https://blog.csdn.net/Guet_Kite/article/details/82263003

你好！这里是风筝的博客，

欢迎和我一起交流。

---

好久都没有写东西了，最近来广州某公司实习，顺便记录下吧。
吐槽下，因为是二级保密单位，公司里电脑不给联网，贼难受。。。。。。

不过第一次接触真正的产品开发，正式的工程项目，还是有很多值得我学习的地方的。
公司用的是联芯的一套方案，分配电脑后，师傅给了我一个简单的任务：给一台手机（Android6.0）移植光线&距离传感器驱动和充电呼吸灯芯片的驱动。
因为是移植，所以，，，，，，，，我觉得我可以叫设备树工程师………..
任务很简单，但是我却对代码陷入了沉思。

当我拿到一份代码方案时，最简单的，操作GPIO。
当我最初学习的时候，用的是S3C2440，从网上很多资料还是知道GPIO的宏，如：S3C2410_GPF(4)

在我使用全志 H3的芯片，大部分我都是直接操作寄存器了，而且网上也有资料可循。
现在我在公司接触的这块芯片，网上根本没有资料，资料就是厂家提供的说明文档，那以操作GPIO为例，我该怎么操作一个GPIO呢？

其实有经验的人都知道：模仿！
看工程下别人写的代码就知道了，这算是一种取巧捷径，那我们现在是思考，该怎么做呢？
因为公司是完全要求保密的，代码我也拷不出来，我就以我手上的sun8i-h3代码分析吧：
首先，打开手册，查找芯片手册里关于GPIO的章节：

这里我们可以看出GPIO的基地址是：0x01C20800
像我公司里用的芯片，是普通GPIO有一个基地址，可复用的GPIO又是另一个基地址，所以有gpio节点和pinctrl节点。
但是现在我们sun8i-h3都放在一个基地址了，所以gpio、pinctrl描述的是同一个节点。
我们去内核搜索一下，grep一下0x01C20800这个地址即可：

接着我们可以去找下他的compatible属性，搜索一下 “&pio”很快就找到：

compatible属性是：”allwinner,sun8i-h3-pinctrl”
那么可以安心去找他的代码了：

static const struct sunxi_pinctrl_desc sun8i_h3_pinctrl_data = {
    .pins = sun8i_h3_pins,//数组内容放在pins字段
    .npins = ARRAY_SIZE(sun8i_h3_pins),
    .irq_banks = 2,
    .irq_read_needs_mux = true
};

static int sun8i_h3_pinctrl_probe(struct platform_device *pdev)
{
    return sunxi_pinctrl_init(pdev,
                  &sun8i_h3_pinctrl_data);
}

static const struct of_device_id sun8i_h3_pinctrl_match[] = {
    { .compatible = "allwinner,sun8i-h3-pinctrl", },
    {}
};

static struct platform_driver sun8i_h3_pinctrl_driver = {
    .probe  = sun8i_h3_pinctrl_probe,
    .driver = {
        .name       = "sun8i-h3-pinctrl",
        .of_match_table = sun8i_h3_pinctrl_match,
    },
};

这里面有个数组需要注意一下，那就是：sun8i_h3_pins

static const struct sunxi_desc_pin sun8i_h3_pins[] = {
    SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 0),
          SUNXI_FUNCTION(0x0, "gpio_in"),
          SUNXI_FUNCTION(0x1, "gpio_out"),
          SUNXI_FUNCTION(0x2, "uart2"),     /* TX */
          SUNXI_FUNCTION(0x3, "jtag"),      /* MS */
          SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 0)),  /* PA_EINT0 */
    SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 1),
          SUNXI_FUNCTION(0x0, "gpio_in"),
          SUNXI_FUNCTION(0x1, "gpio_out"),
          SUNXI_FUNCTION(0x2, "uart2"),     /* RX */
          SUNXI_FUNCTION(0x3, "jtag"),      /* CK */
          SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 1)),  /* PA_EINT1 */
    SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 2),
          SUNXI_FUNCTION(0x0, "gpio_in"),
          SUNXI_FUNCTION(0x1, "gpio_out"),
          SUNXI_FUNCTION(0x2, "uart2"),     /* RTS */
          SUNXI_FUNCTION(0x3, "jtag"),      /* DO */
          SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 2)),  /* PA_EINT2 */
    SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 3),
          SUNXI_FUNCTION(0x0, "gpio_in"),
          SUNXI_FUNCTION(0x1, "gpio_out"),
          SUNXI_FUNCTION(0x2, "uart2"),     /* CTS */
          SUNXI_FUNCTION(0x3, "jtag"),      /* DI */
          SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 3)),  /* PA_EINT3 */
    SUNXI_PIN(SUNXI_PINCTRL_PIN(A, 4),
          SUNXI_FUNCTION(0x0, "gpio_in"),
          SUNXI_FUNCTION(0x1, "gpio_out"),
          SUNXI_FUNCTION(0x2, "uart0"),     /* TX */
          SUNXI_FUNCTION_IRQ_BANK(0x6, 0, 4)),  /* PA_EINT4 */
    //......          
}

看到那些”管脚映射结构体”数组里的参数，A0、A1……是不是觉得有有那么一丝丝熟悉？
里面的参数可以解读为：以A6为例
配置0x0为输入，0x1为输出，0x2为复用为串口，0x6为中断线配置，和芯片手册上是完全对应的！
进入probe函数看，挑一些重点的来写吧：

int sunxi_pinctrl_init_with_variant(struct platform_device *pdev,
                    const struct sunxi_pinctrl_desc *desc,
                    unsigned long variant)
{
    pctl = devm_kzalloc(&pdev->dev, sizeof(*pctl), GFP_KERNEL);
    //......
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    pctl->membase = devm_ioremap_resource(&pdev->dev, res);//基地址，也就是0x01C20800 
    pctl->dev = &pdev->dev;
    pctl->desc = desc;
    pctl->variant = variant;
    //......
    ret = sunxi_pinctrl_build_state(pdev);//重要！和pinctrl子系统有关，懒得分析了，后面给链接，讲得挺好的
    //......
    for (i = 0, pin_idx = 0; i < pctl->desc->npins; i++) {//取出数组内容
        const struct sunxi_desc_pin *pin = pctl->desc->pins + i;//数组内容
        if (pin->variant && !(pctl->variant & pin->variant))
            continue;

        pins[pin_idx++] = pin->pin;
    }
    //......
    pctrl_desc->name = dev_name(&pdev->dev);
    pctrl_desc->owner = THIS_MODULE;
    pctrl_desc->pins = pins;//里面就是之前数组里的内容
    pctrl_desc->npins = pctl->ngroups;
    pctrl_desc->confops = &sunxi_pconf_ops;//和pinctrl里pinctrl_select_state函数使用有关，即（pinctrl_select_state）
    pctrl_desc->pctlops = &sunxi_pctrl_ops;//和pinctrl里pinctrl_select_state函数使用有关
    pctrl_desc->pmxops =  &sunxi_pmx_ops;//和pinctrl里pinctrl_select_state函数使用有关

    pctl->pctl_dev = devm_pinctrl_register(&pdev->dev, pctrl_desc, pctl);//和pinctrl有关,注册
    //......
    last_pin = pctl->desc->pins[pctl->desc->npins - 1].pin.number;
    pctl->chip->owner = THIS_MODULE;
    pctl->chip->request = gpiochip_generic_request,
    pctl->chip->free = gpiochip_generic_free,
    pctl->chip->direction_input = sunxi_pinctrl_gpio_direction_input,
    pctl->chip->direction_output = sunxi_pinctrl_gpio_direction_output,
    pctl->chip->get = sunxi_pinctrl_gpio_get,
    pctl->chip->set = sunxi_pinctrl_gpio_set,
    pctl->chip->of_xlate = sunxi_pinctrl_gpio_of_xlate,
    pctl->chip->to_irq = sunxi_pinctrl_gpio_to_irq,
    pctl->chip->of_gpio_n_cells = 3,//cells参数个数
    pctl->chip->can_sleep = false,
    pctl->chip->ngpio = round_up(last_pin, PINS_PER_BANK) -
                pctl->desc->pin_base;
    pctl->chip->label = dev_name(&pdev->dev);
    pctl->chip->parent = &pdev->dev;
    pctl->chip->base = pctl->desc->pin_base;

    ret = gpiochip_add_data(pctl->chip, pctl);

    for (i = 0; i < pctl->desc->npins; i++) {
        const struct sunxi_desc_pin *pin = pctl->desc->pins + i;

        ret = gpiochip_add_pin_range(pctl->chip, dev_name(&pdev->dev),
                         pin->pin.number - pctl->desc->pin_base,
                         pin->pin.number, 1);//建立动态链表chip->pin_ranges，node为gpio_pin_range，其成员range包含pin脚基地址。
        if (ret)
            goto gpiochip_error;
    }
    //后面就是一些和irq相关的东西了
}

可以看出，这个函数，一开始
a）把GPIO的基地址取出来，放到pctl->membase里。

b）sunxi_pinctrl_build_state函数，这是和pinctrl子系统有关的，里面差不多是：将pctl->desc的子项数据(即sunxi_pinctrl_desc数据)复制到pctl相应子项（sunxi_pinctrl结构），文章末尾我会放一篇文章链接，讲的还不错，看那个即可。

c）把之前描述GPIO的数组放到pctrl_desc结构体中，以及填充confops、pctlops和pmxops三个字段，这三个字段就厉害了，当我们使用pinctrl_select_state（pinctrl的API）函数时就是调用的这些！

d）填充pctl->chip里面的各个字段，其中字段：direction_input、direction_output和get、set字段是我们所熟悉的，当我们使用GPIO的函数，如：GPIO_SET_VALUE或者GPIO_GET_VALUE时就是调用到里面的回调函数！还有注意of_xlate这个字段，我们在获取设备树节点时也要用到！而且其中of_gpio_n_cells字段也让我们知道，设备树里描述GPIO的属性是三个参数。

e）调用gpiochip_add_data，其实如果我们不是从设备树里通过compatible属性来反推代码的话，也可以直接搜索这个函数，因为每个平台都会调用这个函数来添加GPIO，这里就是GPIO驱动将通过chip来与pinctrl联系

举个例子，当我们要从设备树获取GPIO时，API为：
of_get_named_gpio_flags函数

int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
                int index, enum of_gpio_flags *flags)
{
    struct gpio_desc *desc;

    desc = of_get_named_gpiod_flags(np, list_name, index, flags);//获取描述

    if (IS_ERR(desc))
        return PTR_ERR(desc);
    else
        return desc_to_gpio(desc);//这里才是通过描述得到具体的GPIO
}

其中

struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
             const char *propname, int index, enum of_gpio_flags *flags)
{
    ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
                     &gpiospec);//获取参数，存放在gpiospec里
    chip = of_find_gpiochip_by_xlate(&gpiospec);
    desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
    return desc;
}

重点就在of_xlate_and_get_gpiod_flags函数里：

static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
                    struct of_phandle_args *gpiospec,
                    enum of_gpio_flags *flags)
{
    int ret;

    if (chip->of_gpio_n_cells != gpiospec->args_count)
        return ERR_PTR(-EINVAL);

    ret = chip->of_xlate(chip, gpiospec, flags);
    if (ret < 0)
        return ERR_PTR(ret);

    return gpiochip_get_desc(chip, ret);
}

可以看到，这里就是会调用到我们之前说的of_xlate回调函数了，即sunxi_pinctrl_gpio_of_xlate函数：

static int sunxi_pinctrl_gpio_of_xlate(struct gpio_chip *gc,
                const struct of_phandle_args *gpiospec,
                u32 *flags)
{
    int pin, base;

    base = PINS_PER_BANK * gpiospec->args[0];
    pin = base + gpiospec->args[1];

    if (pin > gc->ngpio)
        return -EINVAL;

    if (flags)
        *flags = gpiospec->args[2];

    return pin;
}

可以简单看出，我们的设备树里GPIO的属性有三个参数，第一个是base，第二个是pin引脚，第三个是flag标志了。
看了下设备树，也确实是这样写的：

设备树这里描述的就是A10了，从芯片文档我们可知，分为好几组IO口，第0组就是A。也就是base是0，pin是10，flags是GPIO_ACTIVE_HIGH。

再者，of_get_named_gpiod_flags函数的返回值为gpio_desc结构体，会通过调用desc_to_gpio函数通过gpio_desc得到具体的GPIO：

int desc_to_gpio(const struct gpio_desc *desc)
{
    //gdev->base在gpiochip_add_data函数填充
    return desc->gdev->base + (desc - &desc->gdev->descs[0]);
}

同理

    我们在设置某个GPIO为高时：

static inline void gpio_set_value(unsigned int gpio, int value)
{
    __gpio_set_value(gpio, value);
}

__gpio_set_value
    –>gpiod_set_raw_value
        –>_gpiod_set_raw_value
            –>chip->set(chip, gpio_chip_hwgpio(desc), value);//调用set回调函数

gpio_chip_hwgpio：获取该gpio号对应于该chip的offset，由于chip的起始号不一定就是开始与系统全局desc的起点，需要这个函数转换一下
其中set回调函数就是sunxi_pinctrl_gpio_set函数了：

static void sunxi_pinctrl_gpio_set(struct gpio_chip *chip,
                unsigned offset, int value)
{
    struct sunxi_pinctrl *pctl = gpiochip_get_data(chip);
    u32 reg = sunxi_data_reg(offset);
    u8 index = sunxi_data_offset(offset);
    unsigned long flags;
    u32 regval;

    raw_spin_lock_irqsave(&pctl->lock, flags);

    regval = readl(pctl->membase + reg);

    if (value)
        regval |= BIT(index);
    else
        regval &= ~(BIT(index));

    writel(regval, pctl->membase + reg);

    raw_spin_unlock_irqrestore(&pctl->lock, flags);
}

里面基本就是：
先读取GPIO寄存器的值
修改值
再写回去！
其中读写的地址为(pctl->membase + reg)，这里pctl->membase就是我们文章一开始分析时获取到的0x01C20800 地址了。

.

关于什么使用pinctrl，有这么几个API：

struct pinctrl *devm_pinctrl_get(struct device *dev)

pinctrl_lookup_state //寻找一个pin的配置

pinctrl_select_state // 设置选择一个pin的配置

.

---

关于pinctrl的文章，可以看看这个：
链接：
gpio子系统和pinctrl子系统（一）
gpio子系统和pinctrl子系统（二）
gpio子系统和pinctrl子系统（三）

Linux内核中提供了pinctrl子系统，目的是为了统一各SoC厂商的pin脚管理，避免各SoC厂商各自实现相同的pin脚管理子系统，减少SoC厂商系统移植工作量。
功能：
  1. 管理系统中所有可以控制的pin。在系统初始化的时候，枚举所有可以控制的pin，并标识这些pin。
  2. 管理这些pin的复用（Multiplexing）。对于SOC而言，其引脚除了配置成普通GPIO之外，若干个引脚还可以组成一个pin group，形成特定的功能。例如pin number是{ 0, 8, 16, 24 }这四个引脚组合形成一个pin group，提供SPI的功能。pin control subsystem要管理所有的pin group。
  3. 配置这些pin的特性。例如配置该引脚上的pull-up/down电阻，配置drive strength等。
  4. 与GPIO子系统的交互
  5. 实现pin中断

关于为什么引进pinctrl，看这篇文章：Pinctrl基础简介

即：Gpiolib方式的缺点在于：当同一套代码对应多个board设计时，需要在board--gpiomux.c文件中加宏进行区分。对于不同平台项目，在board-msm8974-gpiomux.c文件中添加了很多宏控。
pinctrl方式可以避免代码中的这种冗余代码，它将board--gpiomux.c文件中的配置信息移到-pinctrl.dtsi；这样，针对不同project的board设计，分别在各自project的-pinctrl.dtsi中定义各自的gpio配置信息。
.
gpio子系统让驱动工程师不用关心底层gpio chip的具体实现，让bsp工程师不用关心上层驱动工程师的使用方式。pinctrl子系统帮我们管理了pin信息，包括了pin的mux和conf，同时也透明的处理了与gpio子系统的关联以及设备模型的关联。

了解更多，请点击：蜗窝科技