pinctrl_desc函数操作集实现

pinctrl_desc函数操作集实现

---

---

groups和function

imx6ul有iomuxc如下节点：

iomuxc: iomuxc@020e0000 {
                compatible = "fsl,imx6ul-iomuxc";
                reg = <0x020e0000 0x4000>;
            };
            
&iomuxc {
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_hog_1>;
    imx6ul-evk {
         pinctrl_flexcan1: flexcan1grp{
            fsl,pins = <
                MX6UL_PAD_UART3_RTS_B__FLEXCAN1_RX  0x1b020
                MX6UL_PAD_UART3_CTS_B__FLEXCAN1_TX  0x1b020
            >;
        };

        pinctrl_flexcan2: flexcan2grp{
            fsl,pins = <
                MX6UL_PAD_UART2_RTS_B__FLEXCAN2_RX  0x1b020
                MX6UL_PAD_UART2_CTS_B__FLEXCAN2_TX  0x1b020
            >;
        };
    };
};

function表示功能，groups表示功能的引脚

can0为function，groups表示引脚，上面实现can0可以使用两组引脚。

初始化 imx_pinctrl_desc时得知函数操作集为imx_pctrl_ops，imx_pmx_ops，imx_pinconf_ops

  // 初始化 imx_pinctrl_desc
    imx_pinctrl_desc->name = dev_name(&pdev->dev);
    imx_pinctrl_desc->pins = info->pins;
    imx_pinctrl_desc->npins = info->npins;
    imx_pinctrl_desc->pctlops = &imx_pctrl_ops;
    imx_pinctrl_desc->pmxops = &imx_pmx_ops;
    imx_pinctrl_desc->confops = &imx_pinconf_ops;
    imx_pinctrl_desc->owner = THIS_MODULE;

imx_pctrl_ops

static const struct pinctrl_ops imx_pctrl_ops = {
    .get_groups_count = imx_get_groups_count; // 获取组数
    .get_group_name = imx_get_group_name; // 获取组名
    .get_group_pins = imx_get_group_pins; // 获取组中的引脚
    .pin_dbg_show = imx_pin_dbg_show; // 显示引脚调试信息
    .dt_node_to_map = imx_dt_node_to_map; // 将设备树节点转换为映射
    .dt_free_map = imx_dt_free_map; // 释放映射
};

imx_get_groups_count

static int imx_get_groups_count(struct pinctrl_dev *pctldev)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;

    // 返回组数
    return info->ngroups;

}

这是一个名为 imx_get_groups_count 的函数，用于获取组的数量。
以下是该函数的详细分析：
函数接受一个参数 pctldev，它是引脚控制器设备结构体指针。
函数通过调用 pinctrl_dev_get_drvdata 获取引脚控制器设备结构体中的私有数据，即 imx_pinctrl 结构体指针 ipctl。
通过 ipctl 获取 imx_pinctrl_soc_info 结构体指针 info，该结构体包含组信息。
函数返回组的数量，即 info->ngroups。
综上所述，imx_get_groups_count 函数用于获取引脚控制器设备中的组数量。它通过访问 imx_pinctrl 结构体和 imx_pinctrl_soc_info 结构体来获取组的相关信息，并返回组的数量。

imx_get_group_name

static const char *imx_get_group_name(struct pinctrl_dev *pctldev,
                       unsigned selector)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;

    // 返回选择器对应组的名称
    return info->groups[selector].name;
}

这是一个名为 imx_get_group_name 的函数，用于获取给定选择器对应的组名称。
以下是该函数的详细分析：
函数接受两个参数：pctldev 是引脚控制器设备结构体指针，selector 是选择器索引。
函数通过调用 pinctrl_dev_get_drvdata 获取引脚控制器设备结构体中的私有数据，即 imx_pinctrl 结构体指针 ipctl。
通过 ipctl 获取 imx_pinctrl_soc_info 结构体指针 info，该结构体包含组信息。
函数返回给定选择器对应的组的名称，即 info->groups[selector].name。
综上所述，imx_get_group_name 函数用于根据给定选择器获取对应组的名称。它通过访问 imx_pinctrl 结构体和 imx_pinctrl_soc_info 结构体来获取相关信息，并返回选择器对应组的名称。

imx_get_group_pins

static int imx_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector,
                   const unsigned **pins,
                   unsigned *npins)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;

    // 如果选择器超出组数范围，则返回错误码
    if (selector >= info->ngroups)
        return -EINVAL;

    // 将组的引脚 ID 和引脚数量赋值给传入的指针
    *pins = info->groups[selector].pin_ids;
    *npins = info->groups[selector].npins;

    return 0;
}

这是一个名为 imx_get_group_pins 的函数，用于获取特定功能组中的引脚列表。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
检查选择器 selector 是否超出了组数范围，如果超出范围，则返回错误码 -EINVAL。
将特定功能组中的引脚 ID 数组和引脚数量赋值给传入的指针 pins 和 npins。
返回 0，表示成功获取引脚列表。

综上所述，imx_get_group_pins 函数用于根据选择器获取特定功能组中的引脚列表。它通过指针参数返回引脚 ID 数组和引脚数量，供调用者使用。

imx_pin_dbg_show

static void imx_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
           unsigned offset)
{
    seq_printf(s, "%s", dev_name(pctldev->dev)); // 打印设备名称
}

imx_dt_node_to_map
static int imx_dt_node_to_map(struct pinctrl_dev *pctldev,
            struct device_node *np,
            struct pinctrl_map **map, unsigned *num_maps)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;
    // 定义 imx_pin_group 结构体指针
    const struct imx_pin_group *grp;
    // 定义 pinctrl_map 结构体指针
    struct pinctrl_map *new_map;
    // 定义父节点指针
    struct device_node *parent;
    // 定义映射数量
    int map_num = 1;
    int i, j;

    /*
     * 首先找到该节点所属的组，并检查是否需要为引脚创建配置映射
     */
    grp = imx_pinctrl_find_group_by_name(info, np->name);
    if (!grp) {
        // 如果找不到组，则打印错误信息并返回错误码
        dev_err(info->dev, "无法找到节点 %s 的组\n",
            np->name);
        return -EINVAL;
    }

    for (i = 0; i < grp->npins; i++) {
        // 如果引脚的配置不是 IMX_NO_PAD_CTL，则增加映射数量
        if (!(grp->pins[i].config & IMX_NO_PAD_CTL))
            map_num++;
    }

    // 分配内存空间用于存储映射
    new_map = kmalloc(sizeof(struct pinctrl_map) * map_num, GFP_KERNEL);
    if (!new_map)
        return -ENOMEM;

    *map = new_map;
    *num_maps = map_num;

    /* 创建复用映射 */
    parent = of_get_parent(np);
    if (!parent) {
        kfree(new_map);
        return -EINVAL;
    }
    new_map[0].type = PIN_MAP_TYPE_MUX_GROUP;
    new_map[0].data.mux.function = parent->name;
    new_map[0].data.mux.group = np->name;
    of_node_put(parent);

    /* 创建配置映射 */
    new_map++;
    for (i = j = 0; i < grp->npins; i++) {
        if (!(grp->pins[i].config & IMX_NO_PAD_CTL)) {
            new_map[j].type = PIN_MAP_TYPE_CONFIGS_PIN;
            new_map[j].data.configs.group_or_pin =
                    pin_get_name(pctldev, grp->pins[i].pin);
            new_map[j].data.configs.configs = &grp->pins[i].config;
            new_map[j].data.configs.num_configs = 1;
            j++;
        }
    }

    dev_dbg(pctldev->dev, "maps: function %s group %s num %d\n",
        (*map)->data.mux.function, (*map)->data.mux.group, map_num);

    return 0;
}

这是一个名为 imx_dt_node_to_map 的函数，用于将设备树中的节点映射为引脚控制器的配置映射。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
函数查找节点 np 所属的引脚组，通过调用 imx_pinctrl_find_group_by_name 函数来查找。如果找不到组，则会打印错误信息并返回错误码 -EINVAL。
函数计算需要创建的配置映射的数量。对于引脚组中的每个引脚，如果其配置不是 IMX_NO_PAD_CTL，则增加映射数量。
分配内存空间来存储映射，通过调用 kmalloc 函数分配大小为 sizeof(struct pinctrl_map) * map_num 的内存空间。如果分配失败，则返回错误码 -ENOMEM。
设置输出参数 map 和 num_maps，将分配的内存空间指针和映射数量赋值给它们。
创建复用映射。首先，通过调用 of_get_parent 函数获取父节点的指针 parent。然后，将复用映射的类型设置为 PIN_MAP_TYPE_MUX_GROUP，函数名和组名分别设置为父节点和当前节点的名称。最后，调用 of_node_put 函数释放父节点的引用。
创建配置映射。使用 new_map 指针偏移一个位置，遍历引脚组中的每个引脚。对于每个具有配置的引脚，将配置映射的类型设置为 PIN_MAP_TYPE_CONFIGS_PIN，引脚名设置为引脚的名称，配置数组设置为引脚的配置，配置数量设置为 1。
打印调试信息，表示成功创建了映射。

返回 0，表示成功将节点映射为引脚控制器的配置映射。

综上所述，imx_dt_node_to_map 函数用于根据设备树中的节点创建引脚控制器的配置映射。它会查找节点所属的引脚组，并根据组中的引脚和配置信息创建映射。最后，它将映射存储在内存中，并返回相应的信息。

imx_dt_free_map

static void imx_dt_free_map(struct pinctrl_dev *pctldev,
                struct pinctrl_map *map, unsigned num_maps)
{
    kfree(map); // 释放映射内存
}

这是一个名为 imx_dt_free_map 的函数，用于释放由 imx_dt_node_to_map 函数分配的映射内存。
以下是该函数的详细分析：
函数接受三个参数：pctldev 是引脚控制器设备结构体指针，map 是指向分配的映射内存的指针，num_maps 是映射的数量。
函数调用 kfree(map) 来释放映射内存，将其返回给系统内存池。
综上所述，imx_dt_free_map 函数用于释放由 imx_dt_node_to_map 函数分配的映射内存。它通过调用 kfree 函数来释放存储映射的内存。

imx_pmx_ops

static const struct pinmux_ops imx_pmx_ops = {
    .get_functions_count = imx_pmx_get_funcs_count, // 获取功能数量的回调函数
    .get_function_name = imx_pmx_get_func_name, // 获取功能名称的回调函数
    .get_function_groups = imx_pmx_get_groups, // 获取功能组的回调函数
    .set_mux = imx_pmx_set, // 设置复用功能的回调函数
    .gpio_request_enable = imx_pmx_gpio_request_enable, // 请求并使能 GPIO 的回调函数
    .gpio_set_direction = imx_pmx_gpio_set_direction, // 设置 GPIO 方向的回调函数
};

imx_pmx_set

static int imx_pmx_set(struct pinctrl_dev *pctldev, unsigned selector,
               unsigned group)
{
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); // 获取 pinctrl_dev 结构体中的私有数据
    const struct imx_pinctrl_soc_info *info = ipctl->info; // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pin_reg *pin_reg; // 获取 pin_reg 结构体指针
    unsigned int npins, pin_id; // 定义变量
    int i;
    struct imx_pin_group *grp; // 定义 imx_pin_group 结构体指针

    /*
     * 为特定功能配置组中每个引脚的复用模式
     */
    grp = &info->groups[group]; // 获取组指针
    npins = grp->npins; // 获取组中引脚的数量

    dev_dbg(ipctl->dev, "enable function %s group %s\n",
        info->functions[selector].name, grp->name); // 打印调试信息

    for (i = 0; i < npins; i++) {
        struct imx_pin *pin = &grp->pins[i]; // 获取引脚指针
        pin_id = pin->pin; // 获取引脚编号
        pin_reg = &info->pin_regs[pin_id]; // 获取引脚寄存器

        if (pin_reg->mux_reg == -1) { // 检查引脚是否支持复用功能
            dev_err(ipctl->dev, "引脚(%s)不支持复用功能\n",
                info->pins[pin_id].name); // 打印错误信息并返回错误码
            return -EINVAL;
        }

        if (info->flags & SHARE_MUX_CONF_REG) { // 检查是否共享复用/配置寄存器
            u32 reg;
            reg = readl(ipctl->base + pin_reg->mux_reg); // 读取寄存器值
            reg &= ~(0x7 << 20); // 清除复用模式位
            reg |= (pin->mux_mode << 20); // 设置复用模式
            writel(reg, ipctl->base + pin_reg->mux_reg); // 写入寄存器
        } else {
            writel(pin->mux_mode, ipctl->base + pin_reg->mux_reg); // 写入寄存器
        }
        dev_dbg(ipctl->dev, "write: offset 0x%x val 0x%x\n",
            pin_reg->mux_reg, pin->mux_mode); // 打印调试信息

        /*
         * 如果选择输入值以 0xff 开头，则它是一个特殊的选择输入，
         * 值应按以下方式解释。
         *     31     23      15      7        0
         *     | 0xff | shift | width | select |
         * 它用于解决某些引脚的选择输入未在选择输入寄存器中实现，
         * 而是在某些通用寄存器中实现的问题。
         * 我们将选择输入值、宽度和位字段的偏移编码到设备树中引脚功能 ID 的 input_val 单元中，
         * 然后在此处解码它们以设置通用寄存器中的选择输入位。
         */
        if (pin->input_val >> 24 == 0xff) {
            u32 val = pin->input_val;
            u8 select = val & 0xff;
            u8 width = (val >> 8) & 0xff;
            u8 shift = (val >> 16) & 0xff;
            u32 mask = ((1 << width) - 1) << shift;
            /*
             * The input_reg[i] here is actually some IOMUXC general
             * purpose register, not regular select input register.
             */
            val = readl(ipctl->base + pin->input_reg);
            val &= ~mask;
            val |= select << shift;
            writel(val, ipctl->base + pin->input_reg);
        } else if (pin->input_reg) {
            /*
             * Regular select input register can never be at offset
             * 0, and we only print register value for regular case.
             */
            if (ipctl->input_sel_base)
                writel(pin->input_val, ipctl->input_sel_base +
                        pin->input_reg);
            else
                writel(pin->input_val, ipctl->base +
                        pin->input_reg);
            dev_dbg(ipctl->dev,
                "==>select_input: offset 0x%x val 0x%x\n",
                pin->input_reg, pin->input_val);
        }
    }

    return 0;
}

这是一个名为 imx_pmx_set 的函数，用于配置特定功能的引脚复用模式。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
函数根据选择器 selector 和组索引 group，获取对应的引脚组指针 grp。
获取引脚组中引脚的数量 npins。
打印调试信息，输出所配置的功能和组。

遍历引脚组中的每个引脚：
a. 获取引脚的编号 pin_id 和对应的寄存器信息 pin_reg。
b. 检查引脚是否支持复用功能，如果不支持，则打印错误信息并返回错误码 -EINVAL。
c. 如果引脚控制器支持共享的复用/配置寄存器，则读取寄存器的值，并根据引脚的复用模式设置寄存器的相应位。
d. 如果引脚控制器不支持共享的复用/配置寄存器，则直接将引脚的复用模式写入寄存器。
e. 打印调试信息，输出寄存器的偏移和设置的复用模式。
f. 如果引脚的输入寄存器不为零：
如果存在 ipctl->input_sel_base，则将引脚的输入值写入 ipctl->input_sel_base + pin->input_reg 处的寄存器。
否则，将引脚的输入值写入 ipctl->base + pin->input_reg 处的寄存器。
打印调试信息，输出选择输入寄存器的偏移和设置的输入值。
返回 0，表示成功配置引脚的复用模式。

综上所述，imx_pmx_set 函数用于配置特定功能的引脚复用模式。它遍历引脚组中的每个引脚，根据引脚的复用模式设置相应的寄存器位，并可选地设置选择输入寄存器的输入值。

imx_pmx_get_funcs_count

static int imx_pmx_get_funcs_count(struct pinctrl_dev *pctldev)
{
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); // 获取 pinctrl_dev 结构体中的私有数据
    const struct imx_pinctrl_soc_info *info = ipctl->info; // 获取 imx_pinctrl_soc_info 结构体指针

    return info->nfunctions; // 返回 info 结构体中的 nfunctions 成员
}

这是一个名为 imx_pmx_get_funcs_count 的函数，用于获取引脚控制器设备支持的功能数量。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
返回 info->nfunctions，即引脚控制器设备支持的功能数量。
综上所述，imx_pmx_get_funcs_count 函数用于获取引脚控制器设备支持的功能数量。它通过访问 imx_pinctrl_soc_info 结构体中的 nfunctions 成员，返回该数量。

imx_pmx_get_func_name

static const char *imx_pmx_get_func_name(struct pinctrl_dev *pctldev,
                      unsigned selector)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;

    return info->functions[selector].name; // 返回指定选择器对应的功能名称
}

这是一个名为 imx_pmx_get_func_name 的函数，用于获取特定功能选择器（selector）对应的功能名称。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
根据传入的选择器编号 selector，通过 info->functions[selector] 访问特定功能的信息结构体。
返回特定功能信息结构体中的功能名称（name）。

综上所述，imx_pmx_get_func_name 函数用于获取特定功能选择器对应的功能名称。它通过访问 imx_pinctrl_soc_info 结构体中特定功能的信息，返回该功能的名称。

imx_pmx_get_groups

static int imx_pmx_get_groups(struct pinctrl_dev *pctldev, unsigned selector,
                   const char * const **groups,
                   unsigned * const num_groups)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;

    // 将函数的组和组数赋值给传入的参数
    *groups = info->functions[selector].groups;
    *num_groups = info->functions[selector].num_groups;

    return 0;
}

这是一个名为 imx_pmx_get_groups 的函数，用于获取特定功能选择器（selector）所属的组（groups）和组数（num_groups）。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
根据传入的选择器编号 selector，通过 info->functions[selector] 访问特定功能的信息结构体。
将特定功能的组信息（groups）和组数（num_groups）赋值给传入的参数 groups 和 num_groups。
返回成功的状态码 0。

综上所述，imx_pmx_get_groups 函数用于获取特定功能选择器所属的组以及组的数量。它通过访问 imx_pinctrl_soc_info 结构体中特定功能的信息，将组信息和组数赋值给传入的参数。

imx_pmx_gpio_request_enable

static int imx_pmx_gpio_request_enable(struct pinctrl_dev *pctldev,
            struct pinctrl_gpio_range *range, unsigned offset)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;
    // 获取 pin_reg 结构体指针
    const struct imx_pin_reg *pin_reg;
    // 定义变量
    struct imx_pin_group *grp;
    struct imx_pin *imx_pin;
    unsigned int pin, group;
    u32 reg;

    /* 当前实现仅适用于共享的 mux/conf 寄存器 */
    if (!(info->flags & SHARE_MUX_CONF_REG))
        return -EINVAL;

    // 获取 pin_reg 结构体指针
    pin_reg = &info->pin_regs[offset];
    if (pin_reg->mux_reg == -1)
        return -EINVAL;

    /* 查找具有 GPIO mux 模式的请求引脚的 pinctrl 配置 */
    for (group = 0; group < info->ngroups; group++) {
        grp = &info->groups[group];
        for (pin = 0; pin < grp->npins; pin++) {
            imx_pin = &grp->pins[pin];
            if (imx_pin->pin == offset && !imx_pin->mux_mode)
                goto mux_pin;
        }
    }

    return -EINVAL;

mux_pin:
    reg = readl(ipctl->base + pin_reg->mux_reg);
    reg &= ~(0x7 << 20);
    reg |= imx_pin->config;
    writel(reg, ipctl->base + pin_reg->mux_reg);

    return 0;
}

这是一个名为 imx_pmx_gpio_request_enable 的函数，用于请求并使能 GPIO。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
函数检查引脚控制器是否支持共享的 mux/conf 寄存器。如果不支持，则返回错误码 -EINVAL。

函数根据偏移量 offset 获取引脚的寄存器信息，通过查找 info 中的 pin_regs 数组。
如果引脚的 mux_reg 为 -1，表示该引脚没有有效的寄存器配置，返回错误码 -EINVAL。

函数遍历引脚控制器中的组和引脚，查找具有 GPIO mux 模式的请求引脚的 pinctrl 配置。

如果找到了请求引脚的配置（即 imx_pin->pin == offset 并且 imx_pin->mux_mode 为 0），跳转到标签 mux_pin。
读取 ipctl->base 地址偏移 pin_reg->mux_reg 处的寄存器值。
将寄存器的第 20、21 和 22 位清零，然后根据 imx_pin->config 的值设置相应的位。
将修改后的寄存器值写回 ipctl->base 地址偏移 pin_reg->mux_reg 处。
返回 0，表示成功请求并使能 GPIO。

综上所述，imx_pmx_gpio_request_enable 函数用于请求并使能 GPIO。它通过查找引脚的寄存器配置，找到具有 GPIO mux 模式的请求引脚的 pinctrl 配置。然后，它将修改寄存器的特定位，以使能 GPIO。

imx_pmx_gpio_set_direction

static int imx_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
       struct pinctrl_gpio_range *range, unsigned offset, bool input)
{
    // 获取 imx_pinctrl 结构体指针
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;
    // 获取 pin_reg 结构体指针
    const struct imx_pin_reg *pin_reg;
    // 定义变量
    u32 reg;

    /*
     * 只有 Vybrid 才有输入/输出缓冲区使能标志 (IBE/OBE)
     * 它们是共享的 mux/conf 寄存器的一部分。
     */
    if (!(info->flags & SHARE_MUX_CONF_REG))
        return -EINVAL;

    // 获取 pin_reg 结构体指针
    pin_reg = &info->pin_regs[offset];
    if (pin_reg->mux_reg == -1)
        return -EINVAL;

    /* IBE 总是被启用，允许我们读取 "on the wire" 的值 */
    reg = readl(ipctl->base + pin_reg->mux_reg);
    if (input)
        reg &= ~0x2;
    else
        reg |= 0x2;
    writel(reg, ipctl->base + pin_reg->mux_reg);

    return 0;
}

这是一个名为 imx_pmx_gpio_set_direction 的函数，用于设置 GPIO 的输入/输出方向。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
函数检查引脚控制器是否支持共享的 mux/conf 寄存器。如果不支持，则返回错误码 -EINVAL。

函数根据偏移量 offset 获取引脚的寄存器信息，通过查找 info 中的 pin_regs 数组。
如果引脚的 mux_reg 为 -1，表示该引脚没有有效的寄存器配置，返回错误码 -EINVAL。

读取 ipctl->base 地址偏移 pin_reg->mux_reg 处的寄存器值。
根据输入参数 input 的值，设置寄存器中的相应位。如果 input 为 true，将寄存器的第 2 位（IBE）清零；否则，将寄存器的第 2 位（IBE）设置为 1。
将修改后的寄存器值写回 ipctl->base 地址偏移 pin_reg->mux_reg 处。
返回 0，表示成功设置 GPIO 的输入/输出方向。

综上所述，imx_pmx_gpio_set_direction 函数用于根据给定的偏移量设置 GPIO 的输入/输出方向。它通过查找引脚的寄存器配置，并根据输入参数设置相应的位。最后，它将修改后的寄存器值写回相应的寄存器地址，完成 GPIO 方向的设置。

imx_pinconf_ops

// 定义 imx_pinconf_ops 结构体，用于配置引脚
static const struct pinconf_ops imx_pinconf_ops = {
    .pin_config_get = imx_pinconf_get, // 获取引脚配置的回调函数
    .pin_config_set = imx_pinconf_set, // 设置引脚配置的回调函数
    .pin_config_dbg_show = imx_pinconf_dbg_show, // 打印引脚配置的回调函数
    .pin_config_group_dbg_show = imx_pinconf_group_dbg_show, // 打印引脚组配置的回调函数
};

imx_pinconf_get

static int imx_pinconf_get(struct pinctrl_dev *pctldev,
                 unsigned pin_id, unsigned long *config)
{
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); // 获取 pinctrl_dev 结构体中的私有数据
    const struct imx_pinctrl_soc_info *info = ipctl->info; // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pin_reg *pin_reg = &info->pin_regs[pin_id]; // 获取 pin_reg 结构体指针

    if (pin_reg->conf_reg == -1) { // 检查是否支持配置功能
        dev_err(info->dev, "Pin(%s) does not support config function\n", // 打印错误信息
            info->pins[pin_id].name);
        return -EINVAL; // 返回错误码
    }

    *config = readl(ipctl->base + pin_reg->conf_reg); // 读取配置寄存器的值

    if (info->flags & SHARE_MUX_CONF_REG) // 检查是否共享复用/配置寄存器
        *config &= 0xffff; // 如果共享，则只保留低16位的值

    return 0; // 返回成功
}

这是一个名为 imx_pinconf_get 的函数，用于获取引脚的配置信息。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
根据引脚 ID pin_id，从 info->pin_regs 数组中获取对应引脚的寄存器配置信息，存储在 pin_reg 结构体指针中。
检查引脚是否支持配置功能，如果不支持，则打印错误信息并返回错误码 -EINVAL。
从配置寄存器中读取配置信息的值，存储在传入的 config 指针所指向的变量中。
如果共享复用/配置寄存器（info->flags & SHARE_MUX_CONF_REG 为真），则仅保留配置值的低16位。
返回 0，表示成功获取引脚的配置信息。

综上所述，imx_pinconf_get 函数用于获取引脚的配置信息。它通过传入的引脚 ID，在 imx_pinctrl_soc_info 结构体中查找对应的寄存器配置信息，并将配置值存储在传入的 config 变量中。

imx_pinconf_set

static int imx_pinconf_set(struct pinctrl_dev *pctldev,
                 unsigned pin_id, unsigned long *configs,
                 unsigned num_configs)
{
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); // 获取 pinctrl_dev 结构体中的私有数据
    const struct imx_pinctrl_soc_info *info = ipctl->info; // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pin_reg *pin_reg = &info->pin_regs[pin_id]; // 获取 pin_reg 结构体指针
    int i;

    if (pin_reg->conf_reg == -1) { // 检查是否支持配置功能
        dev_err(info->dev, "Pin(%s) does not support config function\n", // 打印错误信息
            info->pins[pin_id].name);
        return -EINVAL; // 返回错误码
    }

    dev_dbg(ipctl->dev, "pinconf set pin %s\n", // 打印调试信息
        info->pins[pin_id].name);

    for (i = 0; i < num_configs; i++) { // 遍历每个配置
        if (info->flags & SHARE_MUX_CONF_REG) { // 检查是否共享复用/配置寄存器
            u32 reg;
            reg = readl(ipctl->base + pin_reg->conf_reg); // 读取配置寄存器的值
            reg &= ~0xffff; // 清除低16位的值
            reg |= configs[i]; // 将配置值写入低16位
            writel(reg, ipctl->base + pin_reg->conf_reg); // 写入配置寄存器
        } else {
            writel(configs[i], ipctl->base + pin_reg->conf_reg); // 写入配置寄存器
        }
        dev_dbg(ipctl->dev, "write: offset 0x%x val 0x%lx\n", // 打印调试信息
            pin_reg->conf_reg, configs[i]);
    } /* for each config */

    return 0; // 返回成功
}

这是一个名为 imx_pinconf_set 的函数，用于设置引脚的配置信息。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
根据引脚 ID pin_id，从 info->pin_regs 数组中获取对应引脚的寄存器配置信息，存储在 pin_reg 结构体指针中。
检查引脚是否支持配置功能，如果不支持，则打印错误信息并返回错误码 -EINVAL。
打印调试信息，表示要设置引脚的配置信息。
遍历传入的配置数组 configs，对每个配置进行处理。
如果共享复用/配置寄存器（info->flags & SHARE_MUX_CONF_REG 为真），则先读取配置寄存器的值，然后清除低16位的值，并将配置值写入低16位，最后将修改后的值写入配置寄存器。
如果不共享复用/配置寄存器，则直接将配置值写入配置寄存器。
打印调试信息，表示成功设置引脚的配置值。

返回 0，表示成功设置引脚的配置信息。

综上所述，imx_pinconf_set 函数用于设置引脚的配置信息。它通过传入的引脚 ID，在 imx_pinctrl_soc_info 结构体中查找对应的寄存器配置信息，并将传入的配置值写入配置寄存器。如果共享复用/配置寄存器，则先读取寄存器的值并进行修改。最后，函数返回成功状态。

imx_pinconf_dbg_show

static void imx_pinconf_dbg_show(struct pinctrl_dev *pctldev,
                   struct seq_file *s, unsigned pin_id)
{
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev); // 获取 pinctrl_dev 结构体中的私有数据
    const struct imx_pinctrl_soc_info *info = ipctl->info; // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pin_reg *pin_reg = &info->pin_regs[pin_id]; // 获取 pin_reg 结构体指针
    unsigned long config;

    if (!pin_reg || pin_reg->conf_reg == -1) { // 检查 pin_reg 是否为空或不支持配置功能
        seq_printf(s, "N/A"); // 打印 "N/A"
        return;
    }

    config = readl(ipctl->base + pin_reg->conf_reg); // 读取配置寄存器的值
    seq_printf(s, "0x%lx", config); // 打印配置寄存器的值
}

这是一个名为 imx_pinconf_dbg_show 的函数，用于在调试输出中显示引脚的配置信息。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
根据传入的引脚编号 pin_id，获取对应引脚的寄存器信息指针 pin_reg，即 &info->pin_regs[pin_id]。
检查 pin_reg 是否为空或不支持配置功能（pin_reg->conf_reg == -1），如果是，则在输出序列文件 s 中打印 “N/A” 表示不可用，并返回。
从引脚寄存器地址 ipctl->base + pin_reg->conf_reg 中读取配置寄存器的值，并将结果存储在 config 变量中。
在输出序列文件 s 中打印配置寄存器的值。
综上所述，imx_pinconf_dbg_show 函数用于在调试输出中显示指定引脚的配置信息。它通过读取引脚寄存器的值并在输出序列文件中打印。如果引脚的寄存器信息为空或不支持配置功能，将打印 “N/A” 表示不可用。

imx_pinconf_group_dbg_show

static void imx_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
                     struct seq_file *s, unsigned group)
{
    // 获取 pinctrl_dev 结构体中的私有数据
    struct imx_pinctrl *ipctl = pinctrl_dev_get_drvdata(pctldev);
    // 获取 imx_pinctrl_soc_info 结构体指针
    const struct imx_pinctrl_soc_info *info = ipctl->info;
    // 定义指向 imx_pin_group 结构体的指针
    struct imx_pin_group *grp;
    // 定义变量
    unsigned long config;
    // 定义指向字符常量的指针
    const char *name;
    // 定义变量
    int i, ret;

    // 检查 group 是否超出范围
    if (group > info->ngroups)
        return;

    // 打印换行符
    seq_printf(s, "\n");
    // 获取 imx_pin_group 结构体指针
    grp = &info->groups[group];
    // 遍历每个引脚
    for (i = 0; i < grp->npins; i++) {
        // 获取引脚的指针
        struct imx_pin *pin = &grp->pins[i];
        // 获取引脚的名称
        name = pin_get_name(pctldev, pin->pin);
        // 获取引脚的配置信息
        ret = imx_pinconf_get(pctldev, pin->pin, &config);
        // 检查获取配置信息是否成功
        if (ret)
            return;
        // 打印引脚的名称和配置信息
        seq_printf(s, "%s: 0x%lx", name, config);
    }
}

这是一个名为 imx_pinconf_group_dbg_show 的函数，用于在调试输出中显示引脚组的配置信息。
以下是该函数的详细分析：
首先，函数从引脚控制器设备结构体 pctldev 中获取指向 imx_pinctrl 结构体的指针 ipctl，以及指向 imx_pinctrl_soc_info 结构体的指针 info。
检查参数 group 是否超出引脚组数量的范围，如果是，则函数直接返回。
在输出序列文件 s 中打印换行符，以分隔每个引脚组的配置信息。
获取对应引脚组的指针 grp，即 info->groups[group]。
遍历引脚组中的每个引脚。
获取当前引脚的名称，使用 pin_get_name 函数从引脚控制器设备中获取。
调用 imx_pinconf_get 函数，获取当前引脚的配置信息，并将结果存储在 config 变量中。
检查获取配置信息的返回值 ret，如果出错，则函数直接返回。
在输出序列文件 s 中打印当前引脚的名称和配置信息。
综上所述，imx_pinconf_group_dbg_show 函数用于在调试输出中显示引脚组的配置信息。它遍历指定引脚组中的每个引脚，获取每个引脚的名称和配置信息，并在输出序列文件中打印。