• pinctrl子系统 - 源码解析（五）

    一，pincontroller (pinctrl server)构造

    1，pin controller driver与 device match并执行probe
    1. diwali_pinctrl_init
    2.     platform_driver_register(&diwali_pinctrl_driver); //根据match table找到device
    3.         diwali_pinctrl_probe
    4.             pinctrl_data = of_device_get_match_data(&pdev->dev);//获取msm_pinctrl_soc_data
    5.             msm_pinctrl_probe(pdev, pinctrl_data);//传递soc data
    2，probe流程
    1. int msm_pinctrl_probe(struct platform_device *pdev,
    2.               const struct msm_pinctrl_soc_data *soc_data)
    3. {
    4.     // 1）分配一个msm_pinctrl结构并初始化
    5.     msm_pinctrl_data = pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
    6.     if (!pctrl)
    7.         return -ENOMEM;
    8.  
    9.     pctrl->dev = &pdev->dev;
    10.     pctrl->soc = soc_data;
    11.     pctrl->chip = msm_gpio_template;
    12.     pctrl->intr_target_use_scm = of_device_is_compatible(
    13.                     pctrl->dev->of_node,
    14.                     "qcom,ipq8064-pinctrl");
    15.     
    16.     // 2）从pin controller device dts节点中获取设备的物理地址
    17.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    18.     if (!res)
    19.         return -ENOENT;
    20.     //将设备的物理地址转换为虚拟地址，使用该地址读写该pin controller device
    21.     pctrl->regs[0] = devm_ioremap_resource(&pdev->dev, res);
    22.     if (IS_ERR(pctrl->regs[0]))
    23.         return PTR_ERR(pctrl->regs[0]);
    24.  
    25.     pctrl->phys_base[0] = res->start;
    26.  
    27.     //3）从pin controller device dts节点中获取irq number
    28.     pctrl->irq = platform_get_irq(pdev, 0);
    29.     if (pctrl->irq < 0)
    30.         return pctrl->irq;
    31.  
    32.     //4) 构造一个pinctrl_desc
    33.     pctrl->desc.owner = THIS_MODULE;
    34.     //引脚枚举与命名
    35.     pctrl->desc.pctlops = &msm_pinctrl_ops;
    36.     //引脚复用
    37.     pctrl->desc.pmxops = &msm_pinmux_ops;
    38.     //引脚配置
    39.     pctrl->desc.confops = &msm_pinconf_ops;
    40.     pctrl->desc.name = dev_name(&pdev->dev);
    41.     //soc data提供
    42.     pctrl->desc.pins = pctrl->soc->pins;
    43.     pctrl->desc.npins = pctrl->soc->npins;
    44.     pctrl->desc.num_custom_params = ARRAY_SIZE(msm_gpio_bindings);
    45.     pctrl->desc.custom_params = msm_gpio_bindings;
    46.  
    47.     //根据pinctrl_desc信息构造一个pinctrl_dev
    48.     pctrl->pctrl = devm_pinctrl_register(&pdev->dev, &pctrl->desc, pctrl);
    49.     if (IS_ERR(pctrl->pctrl)) {
    50.         dev_err(&pdev->dev, "Couldn't register pinctrl driver\n");
    51.         return PTR_ERR(pctrl->pctrl);
    52.     }
    53.  
    54.     //5)
    55.     ret = msm_gpio_init(pctrl);
    56.     if (ret)
    57.         return ret;
    58.  
    59.     platform_set_drvdata(pdev, pctrl);
    60. }

    pin controller描述符中包括了三类操作函数：pctlops是一些全局的控制函数，pmxops是复用引脚相关的操作函数，confops操作函数是用来配置引脚的特性（例如：pull-up/down）。这些callback函数都是和具体的底层pin controller的操作相关，qcom平台pinctrl controller low level driver实现的API如下，每一个的实现请查看kernel开源代码pinctrl-msm.c：

    1）struct pinctrl_ops

    1. static const struct pinctrl_ops msm_pinctrl_ops = {
    2.     .get_groups_count    = msm_get_groups_count,
    3.     .get_group_name        = msm_get_group_name,
    4.     .get_group_pins        = msm_get_group_pins,
    5.     .dt_node_to_map        = pinconf_generic_dt_node_to_map_group,
    6.     .dt_free_map        = pinctrl_utils_free_map,
    7. };

    2）struct pinmux_ops

    1. static const struct pinmux_ops msm_pinmux_ops = {
    2.     .request        = msm_pinmux_request,
    3.     .get_functions_count    = msm_get_functions_count,
    4.     .get_function_name    = msm_get_function_name,
    5.     .get_function_groups    = msm_get_function_groups,
    6.     .gpio_request_enable    = msm_pinmux_request_gpio,
    7.     .set_mux        = msm_pinmux_set_mux,
    8. };

    3）struct pinconf_ops

    1. static const struct pinconf_ops msm_pinconf_ops = {
    2.     .is_generic        = true,
    3.     .pin_config_group_get    = msm_config_group_get,
    4.     .pin_config_group_set    = msm_config_group_set,
    5. };
    3，devm_pinctrl_register()流程
    1. pctrl->pctrl = devm_pinctrl_register(&pdev->dev, &pctrl->desc, pctrl);
    2.     pctldev = pinctrl_register(pctldesc, dev, driver_data);
    3.         pinctrl_init_controller(pctldesc, dev, driver_data);
    4.             //给pinctrl_dev分配内存
    5.             pctldev = kzalloc(sizeof(*pctldev), GFP_KERNEL);
    6.             // driver_data是msm_pinctrl
    7.             pctldev->driver_data = driver_data;
    8.             //check core ops for sanity
    9.             pinctrl_check_ops(pctldev);
    10.             //If we're implementing pinmuxing, check the ops for sanity
    11.             pinmux_check_ops(pctldev);
    12.             //If we're implementing pinconfig, check the ops for sanity
    13.             pinconf_check_ops(pctldev);
    14.             pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
    15.         pinctrl_enable(pctldev);
    16.             //将pinctrl_dev加入pinctrldev_list链表
    17.             list_add_tail(&pctldev->node, &pinctrldev_list);
    18.             //在每一个pin controller device的目录中生成pinctrl调试节点，eg：/sys/kernel/debug/pinctrl/f000000.pinctrl
    19.             pinctrl_init_device_debugfs(pctldev);
    20.                 debugfs_create_file("pins", S_IFREG | S_IRUGO, device_root, pctldev, &pinctrl_pins_fops);
    21.                 debugfs_create_file("pingroups", S_IFREG | S_IRUGO, device_root, pctldev, &pinctrl_groups_fops);
    22.                 debugfs_create_file("gpio-ranges", S_IFREG | S_IRUGO, device_root, pctldev, &pinctrl_gpioranges_fops);

    二，client端使用pinctrl的过程

    1，dev_pin_info

    设备节点要么被转换为platform_device，或者其他结构体(比如i2c_client)，但是里面都会有一个device结构体，每个device结构体里都有一个dev_pin_info结构体，用来保存设备的pinctrl信息。

    platform_device匹配driver会执行probe探测函数，执行到驱动中真正的probe函数之前，会进行pinctrl的处理，处理函数为pinctrl_bind_pins。

    1. really_probe()
    2.     pinctrl_bind_pins(dev);
    3.         devm_pinctrl_get(dev);
    4.             pinctrl_get(dev);
    5.                 create_pinctrl(dev, NULL);
    6.                     //把dts中该设备的pinctrl配置解析到pinctrl map中
    7.                     pinctrl_dt_to_map(p, pctldev);
    8.                         dt_to_map_one_config(p, pctldev, statename, np_config);
    9.                             ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
    10.                                 .dt_node_to_map        = pinconf_generic_dt_node_to_map_group,
    11.                                     pinconf_generic_dt_node_to_map
    12.                                         //pinctrl map mux
    13.                                         pinctrl_utils_add_map_mux
    14.                                         //pinctrl map configs
    15.                                         pinctrl_utils_add_map_configs
    16.                     
    17.                     //把pinctrl map 转为pinctrl setting
    18.                     add_setting(p, pctldev, map);
    19.                         pinmux_map_to_setting(map, setting);
    20.                         pinconf_map_to_setting(map, setting);
    21.                         list_add_tail(&setting->node, &state->settings);
    22.                     
    23.                     //该设备的pinctrl state holder挂到pinctrl_list链表
    24.                     list_add_tail(&p->node, &pinctrl_list);
    25.             
    26.             //解析标准的pinctrl state，PINCTRL_STATE_DEFAULT/PINCTRL_STATE_INIT/PINCTRL_STATE_SLEEP/PINCTRL_STATE_IDLE
    27.             dev->pins->default_state = pinctrl_lookup_state(dev->pins->p, PINCTRL_STATE_DEFAULT);
    28.             dev->pins->init_state = pinctrl_lookup_state(dev->pins->p, PINCTRL_STATE_INIT);
    29.             pinctrl_select_state(dev->pins->p, dev->pins->default_state);
    30.  
    31.             dev->pins->sleep_state = pinctrl_lookup_state(dev->pins->p, PINCTRL_STATE_SLEEP);
    32.             dev->pins->idle_state = pinctrl_lookup_state(dev->pins->p, PINCTRL_STATE_IDLE);
    33.  
    34. //执行device或者driver的probe函数
    35. dev->bus->probe(dev);
    36. drv->probe(dev);
    2，pinctrl debugfs
    2.1 一个pin controller device --- f000000.pinctrl
    1. ls -l /sys/kernel/debug/pinctrl/f000000.pinctrl
    2. -r--r--r-- 1 root root 0 1970-01-01 00:00 gpio-ranges
    3. -r--r--r-- 1 root root 0 1970-01-01 00:00 pinconf-groups
    4. -r--r--r-- 1 root root 0 1970-01-01 00:00 pinconf-pins
    5. -r--r--r-- 1 root root 0 1970-01-01 00:00 pingroups
    6. -r--r--r-- 1 root root 0 1970-01-01 00:00 pinmux-functions
    7. -r--r--r-- 1 root root 0 1970-01-01 00:00 pinmux-pins
    8. -r--r--r-- 1 root root 0 1970-01-01 00:00 pins

    系统中注册的所有的pinctrl controller，打印接口：

    1. static int pinctrl_devices_show(struct seq_file *s, void *what)
    2. {
    3.     struct pinctrl_dev *pctldev;
    4.  
    5.     seq_puts(s, "name [pinmux] [pinconf]\n");
    6.  
    7.     mutex_lock(&pinctrldev_list_mutex);
    8.  
    9.     list_for_each_entry(pctldev, &pinctrldev_list, node) {
    10.         seq_printf(s, "%s ", pctldev->desc->name);
    11.         if (pctldev->desc->pmxops)
    12.             seq_puts(s, "yes ");
    13.         else
    14.             seq_puts(s, "no ");
    15.         if (pctldev->desc->confops)
    16.             seq_puts(s, "yes");
    17.         else
    18.             seq_puts(s, "no");
    19.         seq_puts(s, "\n");
    20.     }
    21.  
    22.     mutex_unlock(&pinctrldev_list_mutex);
    23.  
    24.     return 0;
    25. }
    26. DEFINE_SHOW_ATTRIBUTE(pinctrl_devices);

    cat /sys/kernel/debug/pinctrl/pinctrl-devices：

    1. name [pinmux] [pinconf]
    2. f000000.pinctrl yes yes
    3. c42d000.qcom,spmi:qcom,pmk8350@0:pinctrl@b000 yes yes
    4. c42d000.qcom,spmi:qcom,pm8350c@2:pinctrl@8800 yes yes
    5. c42d000.qcom,spmi:qcom,pm7325@1:pinctrl@8800 yes yes
    6. c42d000.qcom,spmi:qcom,pm8350b@3:pinctrl@8800 yes yes
    7. soc:spf_core_platform:lpi_pinctrl@3440000 yes yes
    2.2 pinctrl maps信息打印接口
    1. static int pinctrl_maps_show(struct seq_file *s, void *what)
    2. {
    3.     struct pinctrl_maps *maps_node;
    4.     int i;
    5.     const struct pinctrl_map *map;
    6.  
    7.     seq_puts(s, "Pinctrl maps:\n");
    8.  
    9.     mutex_lock(&pinctrl_maps_mutex);
    10.     for_each_maps(maps_node, i, map) {
    11.         seq_printf(s, "device %s\nstate %s\ntype %s (%d)\n",
    12.                map->dev_name, map->name, map_type(map->type),
    13.                map->type);
    14.  
    15.         if (map->type != PIN_MAP_TYPE_DUMMY_STATE)
    16.             seq_printf(s, "controlling device %s\n",
    17.                    map->ctrl_dev_name);
    18.  
    19.         switch (map->type) {
    20.         case PIN_MAP_TYPE_MUX_GROUP:
    21.             pinmux_show_map(s, map);
    22.             break;
    23.         case PIN_MAP_TYPE_CONFIGS_PIN:
    24.         case PIN_MAP_TYPE_CONFIGS_GROUP:
    25.             pinconf_show_map(s, map);
    26.             break;
    27.         default:
    28.             break;
    29.         }
    30.  
    31.         seq_putc(s, '\n');
    32.     }
    33.     mutex_unlock(&pinctrl_maps_mutex);
    34.  
    35.     return 0;
    36. }
    37. DEFINE_SHOW_ATTRIBUTE(pinctrl_maps);

    pinctrl client 节点举例：

    1. //一个device的pinctrl state配置
    2. xxx@xx {
    3.     pinctrl-names = "pmx_ts_active", "pmx_ts_suspend", "pmx_ts_release";
    4.     pinctrl-0 = <&ts_active>;
    5.     pinctrl-1 = <&ts_int_suspend &ts_reset_suspend>;                    
    6.     pinctrl-2 = <&ts_release>;    
    7. };

    pinctrl server 端的配置见上一篇文章，解析后的pinctrl maps信息：

    cat /sys/kernel/debug/pinctrl/pinctrl-maps

    1. device spi1.0
    2. state pmx_ts_active
    3. type MUX_GROUP (2)
    4. controlling device f000000.pinctrl
    5. group gpio129
    6. function gpio
    9. device spi1.0
    10. state pmx_ts_active
    11. type MUX_GROUP (2)
    12. controlling device f000000.pinctrl
    13. group gpio51
    14. function gpio
    17. device spi1.0
    18. state pmx_ts_active
    19. type CONFIGS_GROUP (4)
    20. controlling device f000000.pinctrl
    21. group gpio129
    22. config 00000105
    23. config 00000809
    26. device spi1.0
    27. state pmx_ts_active
    28. type CONFIGS_GROUP (4)
    29. controlling device f000000.pinctrl
    30. group gpio51
    31. config 00000105
    32. config 00000809
    35. device spi1.0
    36. state pmx_ts_suspend
    37. type MUX_GROUP (2)
    38. controlling device f000000.pinctrl
    39. group gpio51
    40. function gpio
    43. device spi1.0
    44. state pmx_ts_suspend
    45. type CONFIGS_GROUP (4)
    46. controlling device f000000.pinctrl
    47. group gpio51
    48. config 00000103
    49. config 00000209
    52. device spi1.0
    53. state pmx_ts_suspend
    54. type MUX_GROUP (2)
    55. controlling device f000000.pinctrl
    56. group gpio129
    57. function gpio
    60. device spi1.0
    61. state pmx_ts_suspend
    62. type CONFIGS_GROUP (4)
    63. controlling device f000000.pinctrl
    64. group gpio129
    65. config 00000103
    66. config 00000209
    69. device spi1.0
    70. state pmx_ts_release
    71. type MUX_GROUP (2)
    72. controlling device f000000.pinctrl
    73. group gpio129
    74. function gpio
    77. device spi1.0
    78. state pmx_ts_release
    79. type MUX_GROUP (2)
    80. controlling device f000000.pinctrl
    81. group gpio51
    82. function gpio
    85. device spi1.0
    86. state pmx_ts_release
    87. type CONFIGS_GROUP (4)
    88. controlling device f000000.pinctrl
    89. group gpio129
    90. config 00000001
    91. config 00000209
    94. device spi1.0
    95. state pmx_ts_release
    96. type CONFIGS_GROUP (4)
    97. controlling device f000000.pinctrl
    98. group gpio51
    99. config 00000001
    100. config 00000209
    2.3 pinctrl setting信息打印接口
    1. static int pinctrl_show(struct seq_file *s, void *what)
    2. {
    3.     struct pinctrl *p;
    4.     struct pinctrl_state *state;
    5.     struct pinctrl_setting *setting;
    6.  
    7.     seq_puts(s, "Requested pin control handlers their pinmux maps:\n");
    8.  
    9.     mutex_lock(&pinctrl_list_mutex);
    10.  
    11.     list_for_each_entry(p, &pinctrl_list, node) {
    12.         seq_printf(s, "device: %s current state: %s\n",
    13.                dev_name(p->dev),
    14.                p->state ? p->state->name : "none");
    15.  
    16.         list_for_each_entry(state, &p->states, node) {
    17.             seq_printf(s, "  state: %s\n", state->name);
    18.  
    19.             list_for_each_entry(setting, &state->settings, node) {
    20.                 struct pinctrl_dev *pctldev = setting->pctldev;
    21.  
    22.                 seq_printf(s, "    type: %s controller %s ",
    23.                        map_type(setting->type),
    24.                        pinctrl_dev_get_name(pctldev));
    25.  
    26.                 switch (setting->type) {
    27.                 case PIN_MAP_TYPE_MUX_GROUP:
    28.                     pinmux_show_setting(s, setting);
    29.                     break;
    30.                 case PIN_MAP_TYPE_CONFIGS_PIN:
    31.                 case PIN_MAP_TYPE_CONFIGS_GROUP:
    32.                     pinconf_show_setting(s, setting);
    33.                     break;
    34.                 default:
    35.                     break;
    36.                 }
    37.             }
    38.         }
    39.     }
    40.  
    41.     mutex_unlock(&pinctrl_list_mutex);
    42.  
    43.     return 0;
    44. }
    45. DEFINE_SHOW_ATTRIBUTE(pinctrl);

    上一节pinctrl maps转成的pinctrl settings信息打印：

    cat /sys/kernel/debug/pinctrl/pinctrl-handles

    1. device: spi1.0 current state: pmx_ts_active
    2.  
    3.   state: pmx_ts_active
    4.     type: MUX_GROUP controller f000000.pinctrl group: gpio129 (129) function: gpio (0)
    5.     type: MUX_GROUP controller f000000.pinctrl group: gpio51 (51) function: gpio (0)
    6.     type: CONFIGS_GROUP controller f000000.pinctrl group gpio129 (129)config 00000105
    7. config 00000809
    8.     type: CONFIGS_GROUP controller f000000.pinctrl group gpio51 (51)config 00000105
    9. config 00000809
    11.   state: pmx_ts_suspend
    12.     type: MUX_GROUP controller f000000.pinctrl group: gpio51 (51) function: gpio (0)
    13.     type: CONFIGS_GROUP controller f000000.pinctrl group gpio51 (51)config 00000103
    14. config 00000209
    15.     type: MUX_GROUP controller f000000.pinctrl group: gpio129 (129) function: gpio (0)
    16.     type: CONFIGS_GROUP controller f000000.pinctrl group gpio129 (129)config 00000103
    17. config 00000209
    19.   state: pmx_ts_release
    20.     type: MUX_GROUP controller f000000.pinctrl group: gpio129 (129) function: gpio (0)
    21.     type: MUX_GROUP controller f000000.pinctrl group: gpio51 (51) function: gpio (0)
    22.     type: CONFIGS_GROUP controller f000000.pinctrl group gpio129 (129)config 00000001
    23. config 00000209
    24.     type: CONFIGS_GROUP controller f000000.pinctrl group gpio51 (51)config 00000001
    25. config 00000209
    3，设备树节点转换为pinctrl_map

    pinctrl_dt_to_map：

    1. int pinctrl_dt_to_map(struct pinctrl *p, struct pinctrl_dev *pctldev)
    2. {
    3.     struct device_node *np = p->dev->of_node;
    4.     int state, ret;
    5.     char *propname;
    6.     struct property *prop;
    7.     const char *statename;
    8.     const __be32 *list;
    9.     int size, config;
    10.     phandle phandle;
    11.     struct device_node *np_config;
    12.  
    13.     /* CONFIG_OF enabled, p->dev not instantiated from DT */
    14.     if (!np) {
    15.         if (of_have_populated_dt())
    16.             dev_dbg(p->dev,
    17.                 "no of_node; not parsing pinctrl DT\n");
    18.         return 0;
    19.     }
    20.  
    21.     /* We may store pointers to property names within the node */
    22.     of_node_get(np);
    23.  
    24.     /* For each defined state ID */
    25.     //遍历所有的state ID
    26.     for (state = 0; ; state++) {
    27.         /* Retrieve the pinctrl-* property */
    28.         propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
    29.         if (!propname)
    30.             return -ENOMEM;
    31.         prop = of_find_property(np, propname, &size);
    32.         kfree(propname);
    33.         if (!prop) {
    34.             if (state == 0) {
    35.                 of_node_put(np);
    36.                 return -ENODEV;
    37.             }
    38.             break;
    39.         }
    40.         list = prop->value;
    41.         //一个state对应的config的数量
    42.         size /= sizeof(*list);
    43.  
    44.         /* Determine whether pinctrl-names property names the state */
    45.         //从pinctrl-names中获取statename
    46.         ret = of_property_read_string_index(np, "pinctrl-names",
    47.                             state, &statename);
    48.         /*
    49.          * If not, statename is just the integer state ID. But rather
    50.          * than dynamically allocate it and have to free it later,
    51.          * just point part way into the property name for the string.
    52.          */
    53.         if (ret < 0)
    54.             statename = prop->name + strlen("pinctrl-");
    55.  
    56.         /* For every referenced pin configuration node in it */
    57.         //遍历每一个state下面的每一个config
    58.         for (config = 0; config < size; config++) {
    59.             phandle = be32_to_cpup(list++);
    60.  
    61.             /* Look up the pin configuration node */
    62.             np_config = of_find_node_by_phandle(phandle);
    63.             if (!np_config) {
    64.                 dev_err(p->dev,
    65.                     "prop %s index %i invalid phandle\n",
    66.                     prop->name, config);
    67.                 ret = -EINVAL;
    68.                 goto err;
    69.             }
    70.  
    71.             /* Parse the node */
    72.             //对于一个config节点的解析函数
    73.             ret = dt_to_map_one_config(p, pctldev, statename,
    74.                            np_config);
    75.             of_node_put(np_config);
    76.             if (ret < 0)
    77.                 goto err;
    78.         }
    79.  
    80.         /* No entries in DT? Generate a dummy state table entry */
    81.         if (!size) {
    82.             ret = dt_remember_dummy_state(p, statename);
    83.             if (ret < 0)
    84.                 goto err;
    85.         }
    86.     }
    87.  
    88.     return 0;
    89.  
    90. err:
    91.     pinctrl_dt_free_maps(p);
    92.     return ret;
    93. }

    dt_to_map_one_config：

    1. static int dt_to_map_one_config(struct pinctrl *p,
    2.                 struct pinctrl_dev *hog_pctldev,
    3.                 const char *statename,
    4.                 struct device_node *np_config)
    5. {
    6.     struct pinctrl_dev *pctldev = NULL;
    7.     struct device_node *np_pctldev;
    8.     const struct pinctrl_ops *ops;
    9.     int ret;
    10.     struct pinctrl_map *map;
    11.     unsigned num_maps;
    12.     bool allow_default = false;
    13.  
    14.     /* Find the pin controller containing np_config */
    15.     np_pctldev = of_node_get(np_config);
    16.     for (;;) {
    17.         //找到pctldev
    18.         pctldev = get_pinctrl_dev_from_of_node(np_pctldev);
    19.     }
    20.     of_node_put(np_pctldev);
    21.  
    22.     /*
    23.      * Call pinctrl driver to parse device tree node, and
    24.      * generate mapping table entries
    25.      */
    26.     ops = pctldev->desc->pctlops;
    27.     if (!ops->dt_node_to_map) {
    28.         dev_err(p->dev, "pctldev %s doesn't support DT\n",
    29.             dev_name(pctldev->dev));
    30.         return -ENODEV;
    31.     }
    32.  
    33.     //调用pinctrl driver中实现的dt_node_to_map
    34.     ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
    35.  
    36.     /* Stash the mapping table chunk away for later use */
    37.     //保存解析出来的pinctrl maps
    38.     return dt_remember_or_free_map(p, statename, pctldev, map, num_maps);
    39. }

    保存解析出来的pinctrl maps，pinctrldt_remember_or_free_map：

    1. dt_remember_or_free_map
    2.     list_add_tail(&dt_map->node, &p->dt_maps);
    3.     pinctrl_register_mappings(map, num_maps);
    4.         list_add_tail(&maps_node->node, &pinctrl_maps);
    4，pinctrl map to pinctrl setting流程
    1.  mutex_lock(&pinctrl_maps_mutex);
    2.     /* Iterate over the pin control maps to locate the right ones */
    3.     //取出pinctrl_maps链表中的每一个node，遍历每一个node中的&_maps_node_->maps[_i_] (指向struct pinctrl_map的map指针)
    4.     for_each_maps(maps_node, i, map) {
    5.         /* Map must be for this device */
    6.         if (strcmp(map->dev_name, devname))
    7.             continue;
    8.         /*
    9.          * If pctldev is not null, we are claiming hog for it,
    10.          * that means, setting that is served by pctldev by itself.
    11.          *
    12.          * Thus we must skip map that is for this device but is served
    13.          * by other device.
    14.          */
    15.         if (pctldev &&
    16.             strcmp(dev_name(pctldev->dev), map->ctrl_dev_name))
    17.             continue;
    18.  
    19.         //一个map转为一个setting
    20.         ret = add_setting(p, pctldev, map);
    21.         /*
    22.          * At this point the adding of a setting may:
    23.          *
    24.          * - Defer, if the pinctrl device is not yet available
    25.          * - Fail, if the pinctrl device is not yet available,
    26.          *   AND the setting is a hog. We cannot defer that, since
    27.          *   the hog will kick in immediately after the device
    28.          *   is registered.
    29.          *
    30.          * If the error returned was not -EPROBE_DEFER then we
    31.          * accumulate the errors to see if we end up with
    32.          * an -EPROBE_DEFER later, as that is the worst case.
    33.          */
    34.         if (ret == -EPROBE_DEFER) {
    35.             pinctrl_free(p, false);
    36.             mutex_unlock(&pinctrl_maps_mutex);
    37.             return ERR_PTR(ret);
    38.         }
    39.     }
    40.     mutex_unlock(&pinctrl_maps_mutex);

    add_setting：

    1. static int add_setting(struct pinctrl *p, struct pinctrl_dev *pctldev,
    2.                const struct pinctrl_map *map)
    3. {
    4.     struct pinctrl_state *state;
    5.     struct pinctrl_setting *setting;
    6.     int ret;
    7.  
    8.     //首先在struct pinctrl结构体中查找该state是否存在，list_for_each_entry(state, &p->states, node)
    9.     state = find_state(p, map->name);
    10.     if (!state)
    11.         //如果state不存在就新建一个state，list_add_tail(&state->node, &p->states);
    12.         state = create_state(p, map->name);
    13.     if (IS_ERR(state))
    14.         return PTR_ERR(state);
    15.  
    16.     if (map->type == PIN_MAP_TYPE_DUMMY_STATE)
    17.         return 0;
    18.  
    19.     //给struct pinctrl_setting分配内存空间
    20.     setting = kzalloc(sizeof(*setting), GFP_KERNEL);
    21.     if (!setting)
    22.         return -ENOMEM;
    23.     
    24.     //初始化setting结构体
    25.     setting->type = map->type;
    26.  
    27.     if (pctldev)
    28.         setting->pctldev = pctldev;
    29.     else
    30.         setting->pctldev =
    31.             get_pinctrl_dev_from_devname(map->ctrl_dev_name);
    32.     if (!setting->pctldev) {
    33.         kfree(setting);
    34.         /* Do not defer probing of hogs (circular loop) */
    35.         if (!strcmp(map->ctrl_dev_name, map->dev_name))
    36.             return -ENODEV;
    37.         /*
    38.          * OK let us guess that the driver is not there yet, and
    39.          * let's defer obtaining this pinctrl handle to later...
    40.          */
    41.         dev_info(p->dev, "unknown pinctrl device %s in map entry, deferring probe",
    42.             map->ctrl_dev_name);
    43.         return -EPROBE_DEFER;
    44.     }
    45.  
    46.     setting->dev_name = map->dev_name;
    47.  
    48.     switch (map->type) {
    49.     case PIN_MAP_TYPE_MUX_GROUP:
    50.         //pinmux map to setting
    51.         ret = pinmux_map_to_setting(map, setting);
    52.         break;
    53.     case PIN_MAP_TYPE_CONFIGS_PIN:
    54.     case PIN_MAP_TYPE_CONFIGS_GROUP:
    55.         //pin configure map to setting
    56.         ret = pinconf_map_to_setting(map, setting);
    57.         break;
    58.     default:
    59.         ret = -EINVAL;
    60.         break;
    61.     }
    62.     if (ret < 0) {
    63.         kfree(setting);
    64.         return ret;
    65.     }
    66.  
    67.     //将转化后的setting挂到state->settings链表
    68.     list_add_tail(&setting->node, &state->settings);
    69.  
    70.     return 0;
    71. }

    pinmux_map_to_setting：

    1. int pinmux_map_to_setting(const struct pinctrl_map *map,
    2.               struct pinctrl_setting *setting)
    3. {
    4.     struct pinctrl_dev *pctldev = setting->pctldev;
    5.     const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
    6.     char const * const *groups;
    7.     unsigned num_groups;
    8.     int ret;
    9.         
    10.     ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
    11.     setting->data.mux.func = ret;
    12.  
    13.     
    14.     ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
    15.                       &groups, &num_groups);
    16.     if (ret < 0) {
    17.         dev_err(pctldev->dev, "can't query groups for function %s\n",
    18.             map->data.mux.function);
    19.         return ret;
    20.     }
    21.  
    22.     ret = pinctrl_get_group_selector(pctldev, group);
    23.     if (ret < 0) {
    24.         dev_err(pctldev->dev, "invalid group %s in map table\n",
    25.             map->data.mux.group);
    26.         return ret;
    27.     }
    28.     setting->data.mux.group = ret;
    29.  
    30.     return 0;
    31. }

    map 到 setting的转化只是将字符串转为整型数表示的形式。

    5，client节点如何使用设置管脚
    1. really_probe
    2.     pinctrl_bind_pins
    3.         /* 寻找state */
    4.         pinctrl_lookup_state
    5.         /* 选择state */
    6.         pinctrl_select_state
    7.             pinctrl_commit_state
    8.                 /* 遍历settings链表 */
    9.                 list_for_each_entry(setting, &state->settings, node) {
    10.                     switch (setting->type) {
    11.                         case PIN_MAP_TYPE_MUX_GROUP:
    12.                             /* 设置复用 */
    13.                                pinmux_enable_setting(setting);
    14.                                 ops->set_mux(...);
    15.                         case PIN_MAP_TYPE_CONFIGS_PIN:
    16.                         case PIN_MAP_TYPE_CONFIGS_GROUP:
    17.                             /* 设置配置 */
    18.                             pinconf_apply_setting(setting);
    19.                                 ops->pin_config_group_set(...);
    20.                }

    参考链接：

    pinctrl 子系统介绍_pinctrl子系统_kenny_wju的博客-CSDN博客

    Linux内核中的GPIO系统之（3）：pin controller driver代码分析

  • 相关阅读:
    2419. 按位与最大的最长子数组
    DXF笔记：根据法向量，求出位置矩阵或坐标系
    回放及资料下载｜2022 智能云边开源峰会
    PAT(Advanced Level) Practice（with python）——1066 Root of AVL Tree
    CF1668A Direction Change
    软考高级系统架构设计师系列之：深入理解设计模式
    音视频开发是不是C++开发中最难的细分方向？
    java8函数式编程，常用高阶函数处理
    @Autowired和@Resource注解的区别和联系
    E. Wish I Knew How to Sort codeforces1754E
  • 原文地址：https://blog.csdn.net/u011456016/article/details/133852597