Linux驅動學習day20(pinctrl子系統驅動大全)

一、Pinctrl作用

Pinctrl(Pin Controller)：控制引腳

引腳的枚舉與命名、引腳復用、引腳配置。Pinctrl驅動一般由芯片原廠的BSP工程師來寫，一般驅動工程師只需要在設備樹中指明使用哪個引腳，復用為哪個功能、配置為哪些狀態。

二、Pin Controller重要結構體

由于面向對象的思想，在Linux系統中使用pinctrl_desc和?pinctrl_dev描述pinController。

左邊是controller(抽象出pinctrl_dev結構體)部分，右邊是設備(抽象出device結構體，該結構體含有.pinctrl會和左邊pinctrl_dev掛鉤)部分。

2.1 pinctrl_dev結構體?

我們并不需要自己構建pinctrl_dev，只需要描述它，提供一個pinctrl_desc結構體使用pinctrl_register(函數原型如下)可以構建。

struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,struct device *dev, void *driver_data)
{struct pinctrl_dev *pctldev;int error;pctldev = pinctrl_init_controller(pctldesc, dev, driver_data);if (IS_ERR(pctldev))return pctldev;error = pinctrl_enable(pctldev);if (error)return ERR_PTR(error);return pctldev;}

當設備樹中的pinctrl節點compatible屬性和驅動中的compatible匹配上之后，會調用驅動程序的probe函數。在probe函數中，會分配設置pinctrl_desc結構體，并且使用這個結構體來注冊pinctrl_dev。使用pinctrl_desc中的pins 和 npins來描述一個引腳，使用pctlops結構體來描述一組引腳。

在pctlops結構體中必須要構造下面這些函數：

2.2?client(dev_pin_info)

設備樹上的設備節點不一定都會被構建成dev下的設備，比如I2C的設備節點，會被構建成I2C_client，但是不論構建成哪一個，結構體中都會含有dev結構體。每個device結構體里面都有一個?dev_pin_info結構體，用來保存設備的pinctrl信息。內核已經給出了幾個默認的狀態，每種狀態對應的信息會被保存到對應的pinctrl_state結構體中，也可以自己指定，但是自己指定的狀態會被保存到pinctrl指針的list鏈表中。

在pinctrl這個大節點下面會有很多節點，節點會對應某個狀態，在pinctrl的驅動程序中會使用pinctrl_ops的dt_node_to_map函數，這個函數會把每個子節點轉換成一系列的pinctrl_map，pinctrl_map又會被轉換成一系列的pinctrl_setting，這些pinctrl_setting會被存放在某一個pinctrl.state.settings鏈表里面。

三、設備樹解析流程

在rk3568.dtsi文件中存在pinctrl這個節點，該節點會被轉化成一個dev，當dev的compatible屬性和驅動程序中的?compatible匹配，驅動程序中的probe會被調用，我們根據相關的關系可以找到rk3568的pinctrl的驅動代碼。

dd@dd-NP3020M3:~/RK3568/SDK/linux/rk3568_linux_sdk/kernel/drivers$ grep "rockchip,rk3568-pinctrl" -nr
Binary file pinctrl/pinctrl-rockchip.o matches
pinctrl/pinctrl-rockchip.c:4120:	{ .compatible = "rockchip,rk3568-pinctrl",

作用1. 描述獲得引腳，解析設備樹

1. 單個引腳

可以在開發板上查看

/sys/kernel/debug/pinctrl/pinctrl-rockchip-pinctrl

關于rk3568，下圖是其打印信息

2. 引腳組信息

cat /sys/kernel/debug/pinctrl/pinctrl-rockchip-pinctrl/pingroups

?3. 引腳組功能

3.2 client節點的pinctrl構造過程

3.2.1 設備樹轉換成pinctrl_map?

設備節點和驅動匹配之后調用really_probe，really_probe給每個dev設置綁定pins，并將設備樹信息轉化成pinctrl_map。（pinctrl_bind_pins() 是在 really_probe() 里 且在 probe 之前調用的，這就是內核的 pinctrl 綁定機制。）借用chatgpt回答：

__device_attach_driver()└─ really_probe(dev, drv)└─ dev->driver = drv;└─ pinctrl_bind_pins(dev);  ← 設置 pins└─ drv->probe(dev);         ← 調用你的驅動 probe

四、編寫虛擬的pinctrl驅動程序

首先先來回顧一下pinctrl子系統的三大左右：引腳枚舉與命名、引腳復用、引腳配置。

pinctrl驅動的核心是分配設置構造一個pinctrl_desc結構體

?需要做的事情1、創建設備樹pinctrller節點，編寫驅動程序 2、創建client節點，編寫驅動程序

4.1 設備樹節點?

/{virtual_pincontroller {compatible = "xupt,virtual_pinctrl";i2cgrp{pins{functions = "i2c","i2c";groups = "pin0" , "pin1";configs = <0x11224455 0x8746446>;}}}
}virtual_i2c{compatible = "xupt,virtual_i2c";pinctrl_name = "default";pinctrl_0 = <&i2cgrp>;
}

4.2?virtual_pinctrl_client_drv.c

#include <linux/err.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/mfd/syscon.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_address.h>
#include <linux/pinctrl/machine.h>
#include <linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/slab.h>
#include <linux/regmap.h>static const struct of_device_id virtual_client_of_match[] = {{ .compatible = "xupt,virtual_i2c", },{ },
};static int virtual_client_probe(struct platform_device *pdev)
{printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);return 0;
}
static int virtual_client_remove(struct platform_device *pdev)
{printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);return 0;
}static struct platform_driver virtual_client_driver = {.probe		= virtual_client_probe,.remove		= virtual_client_remove,.driver		= {.name	= "xupt,virtual_i2c",.of_match_table = of_match_ptr(virtual_client_of_match),}
};/* 1. 入口函數 */
static int __init virtual_client_init(void)
{	printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);/* 1.1 注冊一個platform_driver */return platform_driver_register(&virtual_client_driver);
}/* 2. 出口函數 */
static void __exit virtual_client_exit(void)
{printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);/* 2.1 反注冊platform_driver */platform_driver_unregister(&virtual_client_driver);
}module_init(virtual_client_init);
module_exit(virtual_client_exit);MODULE_LICENSE("GPL");

? 4.3?virtual_pinctrl_drv.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/bitops.h>
#include <linux/gpio.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_device.h>
#include <linux/pinctrl/machine.h>
#include <linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/clk.h>
#include <linux/regmap.h>
#include <linux/mfd/syscon.h>
#include <linux/rockchip/cpu.h>
#include <dt-bindings/pinctrl/rockchip.h>#include "core.h"static struct pinctrl_dev *g_pctldev;static const struct pinctrl_pin_desc pins[] = {{ 0 ,  "pin0" , NULL},{ 1 ,  "pin1" , NULL},{ 2 ,  "pin2" , NULL},{ 3 ,  "pin3" , NULL},
};static unsigned long g_configs[4];struct virtual_function_desc{const char *func_name;const char **groups;int num_group;
};static const char *func0_pins[] = {"pin0" , "pin1" , "pin2" , "pin3"};
static const char *func1_pins[] = {"pin0" , "pin1"};
static const char *func2_pins[] = {"pin2" , "pin3"};static struct virtual_function_desc g_func_des[] = {{"gpio" , func0_pins , 4},{"i2c" , func1_pins , 2},{"uart" , func2_pins , 2},
};static int virtual_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
{return pctldev->desc->npins;
}static const char *virtual_pinctrl_get_group_name(struct pinctrl_dev *pctldev,unsigned selector)
{return pctldev->desc->pins[selector].name;
}static int virtual_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,unsigned selector, const unsigned **pins,unsigned *npins)
{if (selector >= pctldev->desc->npins)return -EINVAL;*pins = &pctldev->desc->pins[selector].number;*npins = 1;return 0;
}/*	
i2cgrp{pins{functions = "i2c","i2c";groups = "pin0" , "pin1";driver-open-drain;}}one pin ==> two pinctrl_map (one for mux , one for config)*/static int virtual_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,struct device_node *np,struct pinctrl_map **map, unsigned *num_maps)
{/* alloc pinctrl_map and num_pin */int num_pins = 1;int i;const char *pins;const char *functions;unsigned int config;struct pinctrl_map *new_map;unsigned long *configs;while(1){if(of_property_read_string_index(np, "groups", num_pins, &pins) == 0)num_pins++;else {break;}}new_map = kmalloc( sizeof(*new_map) *num_pins* 2, GFP_KERNEL);*map = new_map;*num_maps = num_pins * 2;for(i = 0 ; i < num_pins; i++){/* get pin / function / config  (from decice tree)*/of_property_read_string_index(np, "functions", i, &pins);of_property_read_string_index(np, "functions", i, &functions);of_property_read_u32_index(np, "configs", i, &config);configs = kmalloc(sizeof(*configs) , GFP_KERNEL);/* save pinctrl_map */new_map[i*2].type = PIN_MAP_TYPE_MUX_GROUP;new_map[i*2].data.mux.function = functions;new_map[i*2].data.mux.group = pins;new_map[i*2 + 1].type = PIN_MAP_TYPE_CONFIGS_PIN;new_map[i*2 + 1].data.configs.group_or_pin = pins;configs[i] = config;new_map[i*2 + 1].data.configs.configs = configs;new_map[i*2 + 1].data.configs.num_configs = 1;}return 0;
}static void virtual_pinctrl_dt_free_map(struct pinctrl_dev *pctldev,struct pinctrl_map *map, unsigned num_maps)
{while(num_maps--){if(map->type == PIN_MAP_TYPE_MUX_GROUP){kfree(map->data.configs.configs);}kfree(map);map++;}
}static const struct pinctrl_ops virtual_pctrl_ops = {.get_groups_count	= virtual_pinctrl_get_groups_count,.get_group_name		= virtual_pinctrl_get_group_name,.get_group_pins		= virtual_pinctrl_get_group_pins,.dt_node_to_map		= virtual_pinctrl_dt_node_to_map,.dt_free_map		= virtual_pinctrl_dt_free_map,
};static int virtual_pinctrl_pmx_get_funcs_count(struct pinctrl_dev *pctldev)
{return ARRAY_SIZE(g_func_des);
}static const char *virtual_pinctrl_pmx_get_func_name(struct pinctrl_dev *pctldev,unsigned selector)
{return g_func_des[selector].func_name;
}static int virtual_pinctrl_pmx_get_groups(struct pinctrl_dev *pctldev,unsigned selector, const char * const **groups,unsigned * const num_groups)
{*groups = g_func_des[selector].groups;*num_groups = g_func_des[selector].num_group;return 0;
}static int virtual_pinctrl_pmx_set(struct pinctrl_dev *pctldev, unsigned selector,unsigned group)
{printk("virtual_pinctrl_pmx_set %s as %s\n" , pctldev->desc->pins[group].name , g_func_des[selector].func_name);return 0;
}/* 實現引腳復用功能，獲取功能數量、功能名、功能包含組，及設置復用。 */
static const struct pinmux_ops virtual_pinctrl_pmx_ops = {.get_functions_count	= virtual_pinctrl_pmx_get_funcs_count,.get_function_name	= virtual_pinctrl_pmx_get_func_name,.get_function_groups	= virtual_pinctrl_pmx_get_groups,.set_mux		= virtual_pinctrl_pmx_set,
};static int virtual_pinctrl_pinconf_get(struct pinctrl_dev *pctldev, unsigned int pin,unsigned long *config)
{*config = g_configs[pin];return 0;
}static int virtual_pinctrl_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,unsigned long *configs, unsigned num_configs)
{if(num_configs != 1)return -EINVAL;g_configs[pin] = *configs;printk("config %s as 0x%lx\n" , pctldev->desc->pins[pin].name , *configs);return 0;
}/* 實現引腳配置功能，保存引腳配置狀態并打印配置日志。 */
static const struct pinconf_ops virtual_pinctrl_pinconf_ops = {.pin_config_get			= virtual_pinctrl_pinconf_get,.pin_config_set			= virtual_pinctrl_pinconf_set,.is_generic			= true,
};static int virtual_pinctrl_probe(struct platform_device *pdev)
{/* alloc pinctrl_desc  */struct pinctrl_desc  * desc;desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL);/* setting */desc->pins = pins;desc->npins = ARRAY_SIZE(pins);desc->owner = THIS_MODULE;desc->name = "virtual-pinctrl";desc->pctlops = &virtual_pctrl_ops;desc->pmxops = &virtual_pinctrl_pmx_ops;desc->confops = &virtual_pinctrl_pinconf_ops;g_pctldev = devm_pinctrl_register(&pdev->dev, desc, NULL);return 0;
}static const struct of_device_id virtual_pinctrl_dt_match[] = {{ .compatible = "xupt,virtual_pinctrl", .data = NULL },{},
};static struct platform_driver virtual_pinctrl_driver = {.probe		= virtual_pinctrl_probe,.driver = {.name	= "vitrual-pinctrl",.of_match_table = virtual_pinctrl_dt_match,},
};static int __init virtual_pinctrl_drv_init(void)
{return platform_driver_register(&virtual_pinctrl_driver);
}static void __exit virtual_pinctrl_drv_exit(void)
{platform_driver_unregister(&virtual_pinctrl_driver);
}module_init(virtual_pinctrl_drv_init);
module_exit(virtual_pinctrl_drv_exit);
MODULE_LICENSE("GPL");

五、總結

這個子系統主要還是分配設置注冊?pinctrl_desc? 結構體，里面需要提供將設備樹信息轉換成所需要的引腳信息，復用信息，引腳配置等函數，全部加起來就是一大塊內容，涉及超級多的結構體和函數，設計這個的人一定是個大聰明，能把所有的鏈接到一塊去。太厲害了。

對于這幾天每個子系統都是很龐大的一塊知識，聽的云里霧里的。太難了。

六、問題

pinctrl是在加載pinctrl驅動時設置的引腳，還是在加載模塊時設置的引腳復用呢？還是說會
設置成倆次呢？是在加載使用這些引腳的設備驅動時設置的引腳復用。

__device_attach_driver()└─ really_probe(dev, drv)└─ dev->driver = drv;└─ pinctrl_bind_pins(dev);  ← 設置 pins└─ drv->probe(dev);         ← 調用你的驅動 probe