pinctrl_desc函数操作集实现
文章目录
- pinctrl_desc函数操作集实现
- groups和function
- imx_pctrl_ops
- imx_get_groups_count
- imx_get_group_name
- imx_get_group_pins
- imx_pin_dbg_show
- imx_dt_free_map
- imx_pmx_ops
- imx_pmx_set
- imx_pmx_get_funcs_count
- imx_pmx_get_func_name
- imx_pmx_get_groups
- imx_pmx_gpio_request_enable
- imx_pmx_gpio_set_direction
- imx_pinconf_ops
- imx_pinconf_get
- imx_pinconf_set
- imx_pinconf_dbg_show
- imx_pinconf_group_dbg_show
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 函数用于在调试输出中显示引脚组的配置信息。它遍历指定引脚组中的每个引脚，获取每个引脚的名称和配置信息，并在输出序列文件中打印。
