linux pinctrl驱动分析 altas200模块
准备
使用的源码包为华为官方的ascend200AI加速模块的SDK，其下载地址位于：点击跳转
使用的固件与驱动版本为：1.0.9.alpha
压缩包名称为：A200-3000-sdk_20.2.0.zip
将A200-3000-sdk_20.2.0.zip解压后可以看到Ascend310-source-minirc.tar.gz压缩包，这个压缩包里有ascend200AI加速模块的linux内核源码包、设备树及驱动文件等。
设备树节点
pinctrl的设备树节点位于source/dtb/hi1910-asic-000-pinctrl.dtsi
这里以pmx_ctrl1节点和pmx_cfg1两个节点为例：
pmx_ctrl1: pinmux@110080000 {
compatible = "pinctrl-single", "pinctrl-single1";
reg = <0x1 0x10080000 0x0 0x38>;
#gpio-range-cells = <3>;
pinctrl-single,register-width = <32>;
pinctrl-single,function-mask = <7>;
gpio2_pmx_func: gpio2_pmx_func {
pinctrl-single,pins = <0x2c 0x0>;
};
gpio2_pmx_idle: gpio2_pmx_idle {
pinctrl-single,pins = <0x2c 0x0>;
};
gpio3_pmx_func: gpio3_pmx_func {
pinctrl-single,pins = <0x30 0x0>;
};
gpio3_pmx_idle: gpio3_pmx_idle {
pinctrl-single,pins = <0x30 0x0>;
};
};
pmx_cfg1: pinmux@110080800 {
compatible = "pinconf-single", "pinctrl-single1";
reg = <0x1 0x10080800 0x0 0x05c>;
pinctrl-single,register-width = <32>;
gpio6_cfg_func: gpio6_cfg_func {
pinctrl-single,pins = <0x28 0>;
pinctrl-single,bias-pulldown = <0 2 0 2>;
pinctrl-single,bias-pullup = <1 1 0 1>;
pinctrl-single,drive-strength = <0x30 0x70>;
};
gpio6_cfg_idle: gpio6_cfg_idle {
pinctrl-single,pins = <0x28 0>;
pinctrl-single,bias-pulldown = <0 2 0 2>;
pinctrl-single,bias-pullup = <1 1 0 1>;
pinctrl-single,drive-strength = <0x30 0x70>;
};
gpio2_cfg_func: gpio2_cfg_func {
pinctrl-single,pins = <0x50 0>;
pinctrl-single,bias-pulldown = <2 2 0 2>;
pinctrl-single,bias-pullup = <0 1 0 1>;
pinctrl-single,drive-strength = <0x30 0x70>;
pinctrl-single,input-schmitt-enable = <8 8 0 8>;
};
gpio2_cfg_idle: gpio2_cfg_idle {
pinctrl-single,pins = <0x50 0>;
pinctrl-single,bias-pulldown = <2 2 0 2>;
pinctrl-single,bias-pullup = <0 1 0 1>;
pinctrl-single,drive-strength = <0x30 0x70>;
pinctrl-single,input-schmitt-enable = <8 8 0 8>;
};
gpio3_cfg_func: gpio3_cfg_func {
pinctrl-single,pins = <0x54 0>;
pinctrl-single,bias-pulldown = <0 2 0 2>;
pinctrl-single,bias-pullup = <1 1 0 1>;
pinctrl-single,drive-strength = <0x30 0x70>;
pinctrl-single,input-schmitt-enable = <8 8 0 8>;
};
gpio3_cfg_idle: gpio3_cfg_idle {
pinctrl-single,pins = <0x54 0>;
pinctrl-single,bias-pulldown = <0 2 0 2>;
pinctrl-single,bias-pullup = <1 1 0 1>;
pinctrl-single,drive-strength = <0x30 0x70>;
pinctrl-single,input-schmitt-enable = <8 8 0 8>;
};
};
pinctrl驱动分析
设备树节点无论是pinconf-single还是pinctrl-single匹配到的都是source\kernel\linux-4.19\drivers\pinctrl\pinctrl-single.c
pcs_probe函数
static int pcs_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct pcs_pdata *pdata;
struct resource *res;
struct pcs_device *pcs;
const struct pcs_soc_data *soc;
int ret;
//of_device_get_match_data 判断dts中的compatible属性是否包含driver中指定的compatible，
// 实际上返回的是dev->driver->of_match_table->data。
// data是void *类型，自己如果想取到data里的值，就可以自己定义类型，里面可以放一些自己需要的参数。
//of_device_get_match_data对于pmx_ctrl1节点，它的data为空，可以不管
//而pmx_cfg1节点此时soc->flag=PCS_FEAT_PINCONF。让后给pcs分配内存
//PCS_FEAT_PINCONF (1 << 0)
soc = of_device_get_match_data(&pdev->dev);
if (WARN_ON(!soc))
return -EINVAL;
//申请pcs结构体内存，这个pdev->dev这个参数是为了绑定这片内存
//devm_kzalloc分配的内存当指定的dev驱动被注销时会自动释放
pcs = devm_kzalloc(&pdev->dev, sizeof(*pcs), GFP_KERNEL);
if (!pcs)
return -ENOMEM;
//这个np是dtb转化的device_node
pcs->dev = &pdev->dev;
pcs->np = np;
raw_spin_lock_init(&pcs->lock);
mutex_init(&pcs->mutex);
//初始化链表
INIT_LIST_HEAD(&pcs->gpiofuncs);
//pcs->flags = PCS_FEAT_PINCONF = 1
pcs->flags = soc->flags;
//之后pcs->socdata指向soc结构体
memcpy(&pcs->socdata, soc, sizeof(*soc));
//获取"pinctrl-single,register-width"属性，好像是寄存器的位宽，都是32位的
ret = of_property_read_u32(np, "pinctrl-single,register-width",
&pcs->width);
if (ret) {
dev_err(pcs->dev, "register width not specified\n");
return ret;
}
//pcs->fmask是7
ret = of_property_read_u32(np, "pinctrl-single,function-mask",
&pcs->fmask);
if (!ret) {
//存在属性，所以指向下面的代码
//__ffs 用于找到一个int或者long行最高哪位是1，例如0x8000，就会返回15.
//pcs->fshift 为2 pcs->fmax为1
pcs->fshift = __ffs(pcs->fmask);
pcs->fmax = pcs->fmask >> pcs->fshift;
} else {
/* If mask property doesn't exist, function mux is invalid. */
pcs->fmask = 0;
pcs->fshift = 0;
pcs->fmax = 0;
}
//这个属性没有
ret = of_property_read_u32(np, "pinctrl-single,function-off",
&pcs->foff);
if (ret)
pcs->foff = PCS_OFF_DISABLED;
//这个没有读到 也是0
pcs->bits_per_mux = of_property_read_bool(np,
"pinctrl-single,bit-per-mux");
//pcs->bits_per_mux ? 2 : 1 为1
//这个函数是老版的函数要找"#pinctrl-cells"属性，没有 直接返回0
ret = pcs_quirk_missing_pinctrl_cells(pcs, np,
pcs->bits_per_mux ? 2 : 1);
if (ret) {
dev_err(&pdev->dev, "unable to patch #pinctrl-cells\n");
return ret;
}
//获取IORESOURCE_MEM资源，即reg属性
//pmx_ctrl1节点reg = <0x1 0x10080000 0x0 0x38>;
//pmx_cfg1节点为reg = <0x1 0x10080800 0x0 0x05c>;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(pcs->dev, "could not get resource\n");
return -ENODEV;
}
//节点pmx_ctrl1
//res->start:268959744 ----- res->end:268959799
//resource_size:56
//节点pmx_cfg1
//res->start:268961792 ----- res->end:268961883
//resource_size:92
//devm_request_mem_region将res的物理空间iormmap映射出来，返回给pcs->res，能通过用户空间操作
pcs->res = devm_request_mem_region(pcs->dev, res->start,
resource_size(res), DRIVER_NAME);
if (!pcs->res) {
dev_err(pcs->dev, "could not get mem_region\n");
return -EBUSY;
}
//这里的pcs的size和base就是映射出来的大小和基址
pcs->size = resource_size(pcs->res);
pcs->base = devm_ioremap(pcs->dev, pcs->res->start, pcs->size);
if (!pcs->base) {
dev_err(pcs->dev, "could not ioremap\n");
return -ENODEV;
}
//pdev->device->device_data指针指向pcs，保存变量，pcs是malloc出来的内存
platform_set_drvdata(pdev, pcs);
//(pcs->width为32
switch (pcs->width) {
case 8:
pcs->read = pcs_readb;
pcs->write = pcs_writeb;
break;
case 16:
pcs->read = pcs_readw;
pcs->write = pcs_writew;
break;
case 32:
pcs->read = pcs_readl;
pcs->write = pcs_writel;
break;
default:
break;
}
//DRIVER_NAME "pinctrl-single"
//构造pinctrl_desc结构体，desc.pctlops是引脚的操作功能，desc.pmxops是引脚复用功能
//这两个函数是具体的硬件功能操作函数
pcs->desc.name = DRIVER_NAME;
pcs->desc.pctlops = &pcs_pinctrl_ops;
pcs->desc.pmxops = &pcs_pinmux_ops;
//pmx_cfg1:
//PCS_HAS_PINCONF = (pcs->flags & PCS_FEAT_PINCONF)
//PCS_FEAT_PINCONF (1 << 0)
//pcs->flag = PCS_FEAT_PINCONF (1 << 0)
//PCS_HAS_PINCONF = 1
//注意：pmx_ctrl1节点没有flag属性，所以这个为0
//pcs_pinconf_ops是配置功能，所以只有pmx_cfg1节点的desc有这个功能
if (PCS_HAS_PINCONF)
pcs->desc.confops = &pcs_pinconf_ops;
pcs->desc.owner = THIS_MODULE;
//这个函数啥也没干，只是设置pindesc等一些属性，主要是引脚树木等
ret = pcs_allocate_pin_table(pcs);
if (ret < 0)
goto free;
//pinctrl_register函数，构造pinctrl_dev结构体
//1.传入pinctrl_desc，pctldev->desc指向传入的pinctrl_desc
//2.申请pinctrl_dev结构体内存
//3.初始化了pin_desc_tree、pin_group_tree、pin_function_tree三个树
//4.检查pctldev->desc->pctlops是否有get_group_count和get_group_name函数
//5.检查pctldev->desc->pmxops是否有必要的函数
//6.检查pctldev->desc->confops是否有必要的函数
//7.指向pinctrl_register_one_pin挨个注册管脚
//8.将每个pin的pin_desc都加入到 &pcs->pctl（pinctrl_dev）管理起来
ret = pinctrl_register_and_init(&pcs->desc, pcs->dev, pcs, &pcs->pctl);
if (ret) {
dev_err(pcs->dev, "could not register single pinctrl driver\n");
goto free;
}
//去device_node找pinctrl-single,gpio-range和#pinctrl-single,gpio-range-cells，没有就直接返回了
ret = pcs_add_gpio_func(np, pcs);
if (ret < 0)
goto free;
//中断也没有，不用管
pcs->socdata.irq = irq_of_parse_and_map(np, 0);
if (pcs->socdata.irq)
pcs->flags |= PCS_FEAT_IRQ;
/* We still need auxdata for some omaps for PRM interrupts */
pdata = dev_get_platdata(&pdev->dev);
if (pdata) {
if (pdata->rearm)
pcs->socdata.rearm = pdata->rearm;
if (pdata->irq) {
pcs->socdata.irq = pdata->irq;
pcs->flags |= PCS_FEAT_IRQ;
}
}
//为0也不用管
if (PCS_HAS_IRQ) {
ret = pcs_irq_init_chained_handler(pcs, np);
if (ret < 0)
dev_warn(pcs->dev, "initialized with no interrupts\n");
}
dev_info(pcs->dev, "%i pins, size %u\n", pcs->desc.npins, pcs->size);
return pinctrl_enable(pcs->pctl);
free:
pcs_free_resources(pcs);
return ret;
}
pcs_allocate_pin_table函数
static int pcs_allocate_pin_table(struct pcs_device *pcs)
{
int mux_bytes, nr_pins, i;
int num_pins_in_register = 0;
//mux_bytes = 4
mux_bytes = pcs->width / BITS_PER_BYTE;
//pinctrl-single,bit-per-mux属性未定义
//所以bits_per_mux =0
if (pcs->bits_per_mux) {
pcs->bits_per_pin = fls(pcs->fmask);
nr_pins = (pcs->size * BITS_PER_BYTE) / pcs->bits_per_pin;
num_pins_in_register = pcs->width / pcs->bits_per_pin;
} else {
nr_pins = pcs->size / mux_bytes;
}
//pmx_ctrl1节点：
//nr_pins = 0x38/4 = 14
//pmx_cfg1节点：
//nr_pins = 0x5C/4 = 23
dev_dbg(pcs->dev, "allocating %i pins\n", nr_pins);
//这个pcs->dev就是device_node
//分配nr_pins个struct pinctrl_pin_desc *pa;的内存大小给pcs->pins.pa
pcs->pins.pa = devm_kcalloc(pcs->dev,
nr_pins, sizeof(*pcs->pins.pa),
GFP_KERNEL);
if (!pcs->pins.pa)
return -ENOMEM;
//npins表示每个控制器pin的数目
pcs->desc.pins = pcs->pins.pa;
pcs->desc.npins = nr_pins;
for (i = 0; i < pcs->desc.npins; i++) {
unsigned offset;
int res;
int byte_num;
int pin_pos = 0;
//pcs->bits_per_mux为0执行的是下面的那一句
if (pcs->bits_per_mux) {
byte_num = (pcs->bits_per_pin * i) / BITS_PER_BYTE;
offset = (byte_num / mux_bytes) * mux_bytes;
pin_pos = i % num_pins_in_register;
} else {
//每次循环offset偏移加4
offset = i * mux_bytes;
}
//传进来的pin_pos为0，这个函数貌似啥也没干，执行结束后只是pcs->pins.cur变成了14
res = pcs_add_pin(pcs, offset, pin_pos);
if (res < 0) {
dev_err(pcs->dev, "error adding pins: %i\n", res);
return res;
}
}
printk("pcs_allocate_pin_table end\n");
return 0;
}
pcs_add_pin函数
static int pcs_add_pin(struct pcs_device *pcs, unsigned offset,
unsigned pin_pos)
{
struct pcs_soc_data *pcs_soc = &pcs->socdata;
struct pinctrl_pin_desc *pin;
int i;
i = pcs->pins.cur;
if (i >= pcs->desc.npins) {
dev_err(pcs->dev, "too many pins, max %i\n",
pcs->desc.npins);
return -ENOMEM;
}
if (pcs_soc->irq_enable_mask) {
unsigned val;
val = pcs->read(pcs->base + offset);
if (val & pcs_soc->irq_enable_mask) {
dev_dbg(pcs->dev, "irq enabled at boot for pin at %lx (%x), clearing\n",
(unsigned long)pcs->res->start + offset, val);
val &= ~pcs_soc->irq_enable_mask;
pcs->write(val, pcs->base + offset);
}
}
pin = &pcs->pins.pa[i];
pin->number = i;
pcs->pins.cur++;
return i;
}
pinctrl_register_one_pin函数
static int pinctrl_register_one_pin(struct pinctrl_dev *pctldev,
const struct pinctrl_pin_desc *pin)
{
struct pin_desc *pindesc;
//查看是否已经注册这个pin
pindesc = pin_desc_get(pctldev, pin->number);
if (pindesc) {
dev_err(pctldev->dev, "pin %d already registered\n",
pin->number);
return -EINVAL;
}
//分配内存
pindesc = kzalloc(sizeof(*pindesc), GFP_KERNEL);
if (!pindesc)
return -ENOMEM;
/* Set owner */
pindesc->pctldev = pctldev;
/* Copy basic pin info */
if (pin->name) {
//如果指定了名字，则设定为默认
pindesc->name = pin->name;
} else {
//设置默认名字
pindesc->name = kasprintf(GFP_KERNEL, "PIN%u", pin->number);
if (!pindesc->name) {
kfree(pindesc);
return -ENOMEM;
}
pindesc->dynamic_name = true;
}
pindesc->drv_data = pin->drv_data;
//将该pin添加到pctldev中
radix_tree_insert(&pctldev->pin_desc_tree, pin->number, pindesc);
pr_debug("registered pin %d (%s) on %s\n",
pin->number, pindesc->name, pctldev->desc->name);
return 0;
}
pinctrl_enable函数
int pinctrl_enable(struct pinctrl_dev *pctldev)
{
int error;
error = pinctrl_claim_hogs(pctldev);
if (error) {
dev_err(pctldev->dev, "could not claim hogs: %i\n",
error);
mutex_destroy(&pctldev->mutex);
kfree(pctldev);
return error;
}
mutex_lock(&pinctrldev_list_mutex);
list_add_tail(&pctldev->node, &pinctrldev_list);
mutex_unlock(&pinctrldev_list_mutex);
pinctrl_init_device_debugfs(pctldev);
return 0;
}
pinctrl_claim_hogs函数
pinctrl_claim_hogs()
//构建pinctrl结构体
pctldev->p = create_pinctrl(pctldev->dev, pctldev);
{
//分配pin ctrl占用的内存并初始化;
p = kzalloc(sizeof(*p), GFP_KERNEL);
//解析设备树节点信息
ret = pinctrl_dt_to_map(p, pctldev);
{
for (state = 0; ; state++) {
propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
//寻找这个节点下的pinctrl-%d属性
prop = of_find_property(np, propname, &size);
//根据state找到pinctrl-names中的第几个字符串，返回给statename
ret = of_property_read_string_index(np, "pinctrl-names",
state, &statename);
for (config = 0; config < size; config++) {
phandle = be32_to_cpup(list++);
//查找整个设备树。从根节点开始，找到属性带pinctrl-%d的device_node
np_config = of_find_node_by_phandle(phandle);
//这个函数会找到pinctrl-%d属性的父节点
//调用父节点的pctldev->desc->pctlop->dt_node_to_map函数
//本驱动中dt_node_to_map会根据pinctrl-single,pins属性来设置复用寄存器的值
ret = dt_to_map_one_config(p, pctldev, statename,
np_config);
}
}
}
}
}
总结
主要结构体
pcs_device
* struct pcs_device - pinctrl device instance
* @res: resources
* @base: virtual address of the controller
* @saved_vals: saved values for the controller
* @size: size of the ioremapped area
* @dev: device entry
* @np: device tree node
* @pctl: pin controller device
* @flags: mask of PCS_FEAT_xxx values
* @missing_nr_pinctrl_cells: for legacy binding, may go away
* @socdata: soc specific data
* @lock: spinlock for register access
* @mutex: mutex protecting the lists
* @width: bits per mux register
* @fmask: function register mask
* @fshift: function register shift
* @foff: value to turn mux off
* @fmax: max number of functions in fmask
* @bits_per_mux: number of bits per mux
* @bits_per_pin: number of bits per pin
* @pins: physical pins on the SoC
* @gpiofuncs: list of gpio functions
* @irqs: list of interrupt registers
* @chip: chip container for this instance
* @domain: IRQ domain for this instance
* @desc: pin controller descriptor
* @read: register read function to use
* @write: register write function to use
struct pcs_device {
struct resource *res;
void __iomem *base;
void *saved_vals;
unsigned size;
struct device *dev;
struct device_node *np;
struct pinctrl_dev *pctl;
unsigned flags;
#define PCS_CONTEXT_LOSS_OFF (1 << 3)
#define PCS_QUIRK_SHARED_IRQ (1 << 2)
#define PCS_FEAT_IRQ (1 << 1)
#define PCS_FEAT_PINCONF (1 << 0)
struct property *missing_nr_pinctrl_cells;
struct pcs_soc_data socdata;
raw_spinlock_t lock;
struct mutex mutex;
unsigned width;
unsigned fmask;
unsigned fshift;
unsigned foff;
unsigned fmax;
bool bits_per_mux;
unsigned bits_per_pin;
struct pcs_data pins;
struct list_head gpiofuncs;
struct list_head irqs;
struct irq_chip chip;
struct irq_domain *domain;
struct pinctrl_desc desc;
unsigned (*read)(void __iomem *reg);
void (*write)(unsigned val, void __iomem *reg);
};
厂家自定义的结构体，probe函数主要是填充这个结构体，每个pinctrl控制器的节点会构造一个结构体
pinctrl_desc
/**
* struct pinctrl_desc - pin controller descriptor, register this to pin
* control subsystem
* @name: name for the pin controller
* @pins: an array of pin descriptors describing all the pins handled by
* this pin controller
* @npins: number of descriptors in the array, usually just ARRAY_SIZE()
* of the pins field above
* @pctlops: pin control operation vtable, to support global concepts like
* grouping of pins, this is optional.
* @pmxops: pinmux operations vtable, if you support pinmuxing in your driver
* @confops: pin config operations vtable, if you support pin configuration in
* your driver
* @owner: module providing the pin controller, used for refcounting
* @num_custom_params: Number of driver-specific custom parameters to be parsed
* from the hardware description
* @custom_params: List of driver_specific custom parameters to be parsed from
* the hardware description
* @custom_conf_items: Information how to print @params in debugfs, must be
* the same size as the @custom_params, i.e. @num_custom_params
*/
struct pinctrl_desc {
const char *name;
const struct pinctrl_pin_desc *pins;
unsigned int npins;
const struct pinctrl_ops *pctlops;
const struct pinmux_ops *pmxops;
const struct pinconf_ops *confops;
struct module *owner;
#ifdef CONFIG_GENERIC_PINCONF
unsigned int num_custom_params;
const struct pinconf_generic_params *custom_params;
const struct pin_config_item *custom_conf_items;
#endif
};
pinctrl_desc描述了该pinctrl设备的相关信息，引脚数量，引脚配置操作函数，硬件功能操作函数，引脚复用操作函数
struct pinctrl_ops {
//获取系统中pin groups的个数，后续的操作，将以相应的索引为单位（类似数组的下标，个数为数组的大小）
int (*get_groups_count) (struct pinctrl_dev *pctldev);
//获取指定group（由索引selector指定）的名称
const char *(*get_group_name) (struct pinctrl_dev *pctldev, unsigned selector);
//获取指定group的所有pins（由索引selector指定），结果保存在pins（指针数组）和num_pins（指针）中
int (*get_group_pins) (struct pinctrl_dev *pctldev, unsigned selector, const unsigned **pins, unsigned *num_pins);
void (*pin_dbg_show) (struct pinctrl_dev *pctldev, struct seq_file *s, unsigned offset);
//用于将device tree中的pin state信息转换为pin map
int (*dt_node_to_map) (struct pinctrl_dev *pctldev, struct device_node *np_config, struct pinctrl_map **map, unsigned *num_maps);
void (*dt_free_map) (struct pinctrl_dev *pctldev, struct pinctrl_map *map, unsigned num_maps);
};
struct pinmux_ops {
//检查某个pin是否已作它用，用于管脚复用时的互斥
int (*request) (struct pinctrl_dev *pctldev, unsigned offset);
//request的反操作
int (*free) (struct pinctrl_dev *pctldev, unsigned offset);
//获取系统中function的个数
int (*get_functions_count) (struct pinctrl_dev *pctldev);
//获取指定function的名称
const char *(*get_function_name) (struct pinctrl_dev *pctldev, unsigned selector);
//获取指定function所占用的pin group
int (*get_function_groups) (struct pinctrl_dev *pctldev, unsigned selector, const char * const **groups, unsigned *num_groups);
//将指定的pin group（group_selector）设置为指定的function（func_selector）
int (*set_mux) (struct pinctrl_dev *pctldev, unsigned func_selector, unsigned group_selector);
//以下是gpio相关的操作
int (*gpio_request_enable) (struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned offset);
void (*gpio_disable_free) (struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned offset);
int (*gpio_set_direction) (struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned offset, bool input);
//为true时，说明该pin controller不允许某个pin作为gpio和其它功能同时使用
bool strict;
};
struct pinconf_ops {
#ifdef CONFIG_GENERIC_PINCONF
bool is_generic;
#endif
//获取指定 pin 的当前配置，保存在 config 指针中
int (*pin_config_get) (struct pinctrl_dev *pctldev, unsigned pin, unsigned long *config);
//设置指定pin的配置
int (*pin_config_set) (struct pinctrl_dev *pctldev, unsigned pin, unsigned long *configs, unsigned num_configs);
//获取指定pin group的配置项
int (*pin_config_group_get) (struct pinctrl_dev *pctldev, unsigned selector, unsigned long *config);
//设置指定pin group的配置项
int (*pin_config_group_set) (struct pinctrl_dev *pctldev, unsigned selector, unsigned long *configs, unsigned num_configs);
......
pinctrl_dev
/**
* struct pinctrl_dev - pin control class device
* @node: node to include this pin controller in the global pin controller list
* @desc: the pin controller descriptor supplied when initializing this pin
* controller
* @pin_desc_tree: each pin descriptor for this pin controller is stored in
* this radix tree
* @pin_group_tree: optionally each pin group can be stored in this radix tree
* @num_groups: optionally number of groups can be kept here
* @pin_function_tree: optionally each function can be stored in this radix tree
* @num_functions: optionally number of functions can be kept here
* @gpio_ranges: a list of GPIO ranges that is handled by this pin controller,
* ranges are added to this list at runtime
* @dev: the device entry for this pin controller
* @owner: module providing the pin controller, used for refcounting
* @driver_data: driver data for drivers registering to the pin controller
* subsystem
* @p: result of pinctrl_get() for this device
* @hog_default: default state for pins hogged by this device
* @hog_sleep: sleep state for pins hogged by this device
* @mutex: mutex taken on each pin controller specific action
* @device_root: debugfs root for this device
*/
struct pinctrl_dev {
struct list_head node;
struct pinctrl_desc *desc;
struct radix_tree_root pin_desc_tree;
#ifdef CONFIG_GENERIC_PINCTRL_GROUPS
struct radix_tree_root pin_group_tree;
unsigned int num_groups;
#endif
#ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
struct radix_tree_root pin_function_tree;
unsigned int num_functions;
#endif
struct list_head gpio_ranges;
struct device *dev;
struct module *owner;
void *driver_data;
struct pinctrl *p;
struct pinctrl_state *hog_default;
struct pinctrl_state *hog_sleep;
struct mutex mutex;
#ifdef CONFIG_DEBUG_FS
struct dentry *device_root;
#endif
};
总结
probe函数填充pcs_device结构体信息，pcs_allocate_pin_table遍历出所有pin的树木和信息，设置pcs->desc.pins和pcs->desc.npins。指向pinctrl_register_and_init，主要是为了构造pinctrl_dev结构体，初始化了pin_desc_tree、pin_group_tree、pin_function_tree三个树，检查pctldev->desc->pctlops、pmxops、pmxops是否有必要的函数，让后将每个pin的pin_desc加入到pinctrl_dev的pin_desc_tree串起来。pcs_add_gpio_func去device_node找pinctrl-single,gpio-range和#pinctrl-single,gpio-range-cells，没有就直接返回了。pinctrl_enable还会解析设备树节点查找是否有设置过pinctrl-%d和pinctrl-names的信息，pinctrl-%d属性的值是要使用pinctrl的节点，调用dt_node_to_map会根据pinctrl-single,pins属性来设置复用寄存器的值。gpio的子系统底层也会调用pinctrl，以后在研究