[笔记分享] [GPIO] MSM8x39 GPIO 软件部分小结

平台： MSM8X39
OS: Android4.4
Kernel: 3.10.28

GPIO SW：

Overview:

在之前的msm8926平台以及以前的平台，GPIO 作为一个整体存在，也就是说是一个GPIO子系统，不区分是控制什么功能。而在未来的msm8939/msm8994平台，GPIO模块引起了kernel支持的pinctrl系统。

出现pinctrl系统的原因应该是开发者想把GPIO里的内部功能给区分开来。
从硬件上来说，原有GPIO模块的功能可分为三大类：
1. 和IO端口本身的功能设定有关，称作pin controller. 通过设定它可以实现：
a. 引脚功能配置。如是普通GPIO还是特殊功能pin。
b. 引脚特性配置。如pull up/down, driver-strength设定。
2. 如果被配置成特殊功能如I2C，那么pin就被连接到I2C controller。如果被配置成 GPIO, 那么被连接到GPIO controller。在此情况下，可以配置GPIO controller:
a. 配置GPIO方向。
b. 如果是输出，可以配置高低电平。
c. 如果是输入，可获取GPIO电平状态。
3. 如果GPIO具有中断功能，那就可以被连接到interrupt controller block. 在此情况下可以配置：
a. 中断使能
b. 触发方式

因此，从SW层面上来说，GPIO模块就被划分成了pinctrl subsystem, gpio subsystem以及interrupt subsystem.另外，pinctrl subsystem 的存在也是为了将一些common的内容给抽象出来。

按照上述的理论，在我们脑中的框图应该是这样子：

GPIO和其他的复用功能并列存在，然后通过multiplexer来选择其中一个，pinctrl HW block单独控制pull up/down以及driver-strength.
事实上，在看过code之后，你会发现并非你想得那么理想，真实框图是这样：

也就是说GPIO的控制要经过pinctrl模块。具体的接口后面再描述。
基于此原因，gpio/pinctrl的初始化也是同时进行的了，gpio subsystem有兴趣可自行研究，后面描述此模块时只说到注册为止。

Pinctrl subsystem:

Overview:

再细分pinctrl主要完成的功能：
1. 管理系统中所有pins，后面会讲述系统如何初始化。
2. 管理pin的复用。
3. 配置pin的driver-strength , pull up/down.

由于pin相关的初始化定义/配置/状态都从 board-xxx-gpiomux.c中挪到Device
Tree，所以在看下面章节内容的前提是你知道device tree的语法。

device tree:

控制gpio的DT文件是msm8939-pinctrl.dtsi，主要包含三部分内容：
1. Pinctrl 自身配置。
2. 各个controller设置。
3. 各个controller下面的pin设置。

Pinctrl配置：

Compatible用于和driver匹配。 Reg和interrupts就是之前.c文件中的
IORESOURCE_MEM和 IORESOURCE_IRQ 这两个资源。表示memory是起始地址范围以及IRQ号。

各个controller设置：
Msm8939上有三个相关controller:
主要定义了pin的 type, nums, cells, gpio controller还定义了interrupt相关的内容。
 GPIO controller:

 SDC controller:

 QDSD controller: (trace)

Pin配置：
相关的配置是： gpio number, 用的是哪个function, active/sleep状态及对应的Pull up/down, drive-strength.

初始化:

可以想到，pinctrl subsystem 的一个主要任务就是将前面的msm8939-pinctrl.dtsi里的内容全部解析出来，以备后面使用。
另外一部分内容就是，初始化一些pinctrl接口供其他driver调用(系统其实是通过GPIO接口来设置pin)。
之前说过，由于GPIO通过pinctrl调用实现，所以这里也会提到gpio的枚举以及初始化相关接口。
我们就带着这些猜测直接看source code吧！

Note: 一般描述source code基本上会讲一些关键结构，然后再跟source code，鄙人觉得有利也有弊，弊处是：当第一次看到这些描述时，听得让人云里雾里。
所以本次想反其道而行之，先看source code，之后再回过来看下这些关键结构，就会让你觉得just so so…

根据设备匹配模型以及DT的compatible property 找到对应使用的文件入口是pinctrl-msm-tlmm-v4.c。
msm_tlmm_v4_probe():

[msm8939-pinctrl.dtsi]tlmm_pinmux: pinctrl@1000000 {compatible = "qcom,msm-tlmm-v4";reg = <0x1000000 0x300000>;interrupts = <0 208 0>;
…
};

[pinctrl-msm-tlmm-v4.c]

static struct platform_driver msm_tlmm_v4_drv = {.probe      = msm_tlmm_v4_probe,.driver = {/* 通过此元素来匹配*/.name   = "msm-tlmmv4-pinctrl",.owner  = THIS_MODULE,.of_match_table = of_match_ptr(msm_tlmm_v4_dt_match),},
};struct msm_tlmm_pintype tlmm_v4_pintypes = {.num_entries = ARRAY_SIZE(tlmm_v4_pininfo),.pintype_info = tlmm_v4_pininfo,
};static const struct of_device_id msm_tlmm_v4_dt_match[] = {{ .compatible = "qcom,msm-tlmm-v4",.data = &tlmm_v4_pintypes, },{},
};

匹配成功调用后msm_tlmm_v4_probe()：

static int msm_tlmm_v4_probe(struct platform_device *pdev)
{const struct of_device_id *match;const struct msm_tlmm_pintype *pinfo;struct msm_tlmm_desc *tlmm_desc;int irq, ret;struct resource *res;struct device_node *node = pdev->dev.of_node;/*取出msm_tlmm_v4_dt_match，主要是里面的data。 */match = of_match_node(msm_tlmm_v4_dt_match, node);if (IS_ERR(match))return PTR_ERR(match);pinfo = match->data;tlmm_desc = devm_kzalloc(&pdev->dev, sizeof(*tlmm_desc), GFP_KERNEL);if (!tlmm_desc) {dev_err(&pdev->dev, "Alloction failed for tlmm desc\n");return -ENOMEM;}/*获取IORESOURCE_MEM ，也就是dtsi中的interrupts = <0 208 0>; */res = platform_get_resource(pdev, IORESOURCE_MEM, 0);if (!res) {dev_err(&pdev->dev, "cannot find IO resource\n");return -ENOENT;}tlmm_desc->base = devm_ioremap(&pdev->dev, res->start,resource_size(res));if (IS_ERR(tlmm_desc->base))return PTR_ERR(tlmm_desc->base);tlmm_desc->irq = -EINVAL;
/*获取IORESOURCE_IRQ ，也就是dtsi中的reg = <0x1000000 0x300000>;*/res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);if (res) {irq = res->start;ret = devm_request_irq(&pdev->dev, irq, msm_tlmm_v4_handle_irq,IRQF_TRIGGER_HIGH,dev_name(&pdev->dev),tlmm_desc);if (ret) {dev_err(&pdev->dev, "register for irq failed\n");return ret;}tlmm_desc->irq = irq;}/*和dtsi中的一致，有三个controller info, gpio/sdc/qdsd.
pintype_info 就是下面的tlmm_v4_pininfo。
这里获取了三个controller 信息以及数量。 */tlmm_desc->pintypes = pinfo->pintype_info;tlmm_desc->num_pintypes = pinfo->num_entries;/*pinctrl probe滴干活！*/return msm_pinctrl_probe(pdev, tlmm_desc);
}

static struct msm_pintype_info tlmm_v4_pininfo[] = {{.prg_cfg = msm_tlmm_v4_gp_cfg,.prg_func = msm_tlmm_v4_gp_fn,.set_reg_base = msm_tlmm_v4_gp_set_reg_base,.reg_base = NULL,.prop_name = "qcom,pin-type-gp",.name = "gp",.gc = {.label        = "msm_tlmm_v4_gpio",.direction_input  = msm_tlmm_v4_gp_dir_in,.direction_output = msm_tlmm_v4_gp_dir_out,.get              = msm_tlmm_v4_gp_get,.set              = msm_tlmm_v4_gp_set,.to_irq           = msm_tlmm_v4_gp_to_irq,},.init_irq = msm_tlmm_v4_gp_irq_init,.irq_chip = &msm_tlmm_v4_gp_irq,},{.prg_cfg = msm_tlmm_v4_sdc_cfg,.set_reg_base = msm_tlmm_v4_sdc_set_reg_base,.reg_base = NULL,.prop_name = "qcom,pin-type-sdc",.name = "sdc",},{.prg_cfg = msm_tlmm_v4_qdsd_cfg,.set_reg_base = msm_tlmm_v4_qdsd_set_reg_base,.reg_base = NULL,.prop_name = "qcom,pin-type-qdsd",.name = "qdsd",}
};

msm_pinctrl_probe():
[pinctrl-msm.c]

int msm_pinctrl_probe(struct platform_device *pdev,struct msm_tlmm_desc *tlmm_info)
{struct msm_pinctrl_dd *dd;struct device *dev = &pdev->dev;int ret;/*分配struct msm_pinctrl_dd */dd = devm_kzalloc(dev, sizeof(*dd), GFP_KERNEL);if (!dd) {dev_err(dev, "Alloction failed for driver data\n");return -ENOMEM;}dd->dev = dev;/*tlmm_info的信息再传递给dd.*/dd->msm_pintype = tlmm_info->pintypes;dd->base = tlmm_info->base;dd->irq = tlmm_info->irq;dd->num_pintypes = tlmm_info->num_pintypes;/*这里去解析DT里的内容了。下面会详细分析。*/ret = msm_pinctrl_get_drvdata(dd, pdev);if (ret) {dev_err(&pdev->dev, "driver data not available\n");return ret;}/*注册gpio chip，跟进去就是gpio subsystem的范畴了。*/msm_register_gpiochip(dd);/*注册pintrl */ret = msm_register_pinctrl(dd);if (ret) {msm_pinctrl_cleanup_dd(dd);return ret;}/*注册irq chip*/msm_register_irqchip(dd);platform_set_drvdata(pdev, dd);return 0;
}

msm_pinctrl_get_drvdata():

static int msm_pinctrl_get_drvdata(struct msm_pinctrl_dd *dd,struct platform_device *pdev)
{int ret;struct device_node *node = pdev->dev.of_node;/*解析各个controller信息。*/ret = msm_pinctrl_dt_parse_pintype(node, dd);if (ret)goto out;/*获取各个pins的信息*/ret = msm_pinctrl_dt_parse_pins(node, dd);if (ret)msm_pinctrl_cleanup_dd(dd);
out:return ret;
}

msm_pinctrl_dt_parse_pintype():

static int msm_pinctrl_dt_parse_pintype(struct device_node *dev_node,struct msm_pinctrl_dd *dd)
{struct device_node *pt_node;struct msm_pindesc *msm_pindesc;struct msm_pintype_info *pintype, *pinfo;void __iomem **ptype_base;u32 num_pins, pinfo_entries, curr_pins;int i, ret;uint total_pins = 0;pinfo = dd->msm_pintype;pinfo_entries = dd->num_pintypes;curr_pins = 0;/*一次遍历解析每个controller.*/for_each_child_of_node(dev_node, pt_node) {for (i = 0; i < pinfo_entries; i++) {pintype = &pinfo[i];/* Check if node is pintype node *//*只有prop_name的值存在才能继续下一步。
可以看到pintype的值其实是和DT中的值是一致的，
三个都有：qcom,pin-type-gp ， qcom,pin-type-sdc ，
qcom,pin-type-qdsd */if (!of_find_property(pt_node, pintype->prop_name,NULL))continue;/*取出DT 中的controller node.*/of_node_get(pt_node);pintype->node = pt_node;/* determine number of pins of given pin type *//*获取当前controller能控制的pin number.*/ret = of_property_read_u32(pt_node, "qcom,num-pins",&num_pins);if (ret) {dev_err(dd->dev, "num pins not specified\n");return ret;}/* determine pin number range for given pin type *//*将pin number更新到pintype中。*/pintype->num_pins = num_pins;/*可以看出controller的end和下个controller的start的pin value是紧挨着的。*/pintype->pin_start = curr_pins;pintype->pin_end = curr_pins + num_pins;ptype_base = &pintype->reg_base;/*调用各个controller的set_reg_base， 例如gpio controller对应的是
msm_tlmm_v4_gp_set_reg_base()，将dd->base的值给pintype->reg_base.
前面有：dd->base = tlmm_info->base; */pintype->set_reg_base(ptype_base, dd->base);total_pins += num_pins;curr_pins += num_pins;}}/*又分配一个struct, 它保存了什么信息呢?
你看它分配了total_pins个！ 说明肯定用来保存
所有pin的信息了. 可以带着疑问往下看！*/dd->msm_pindesc = devm_kzalloc(dd->dev,sizeof(struct msm_pindesc) *total_pins, GFP_KERNEL);if (!dd->msm_pindesc) {dev_err(dd->dev, "Unable to allocate msm pindesc");goto alloc_fail;}/*所有controller的pin number之和。*/dd->num_pins = total_pins;msm_pindesc = dd->msm_pindesc;/** Populate pin descriptor based on each pin type present in Device* tree and supported by the driver*//*又遍历一遍controller，看它这次需要什么内容.*/for (i = 0; i < pinfo_entries; i++) {pintype = &pinfo[i];/* If entry not in device tree, skip */if (!pintype->node)continue;/*关键的是这一句，看来需要跟进去看看！*/msm_populate_pindesc(pintype, msm_pindesc);}return 0;
alloc_fail:for (i = 0; i < pinfo_entries; i++) {pintype = &pinfo[i];if (pintype->node)of_node_put(pintype->node);}return -ENOMEM;
}

msm_populate_pindesc():

static void msm_populate_pindesc(struct msm_pintype_info *pinfo,struct msm_pindesc *msm_pindesc)
{int i;struct msm_pindesc *pindesc;for (i = 0; i < pinfo->num_pins; i++) {/*根据pin_start来获取，前面知道,pin_start是按照pin number的数量计算的，
并且controller之前连续。*/pindesc = &msm_pindesc[i + pinfo->pin_start];/*保存自己所属的pinfo，也就是对应的controller.*/pindesc->pin_info = pinfo;/*保存controller的name，并且后面后面-x来表示当前Pin的index, 注意这里的
i不一定正好是GPIO对应的number号。
到这里pindesc的用处验证了我们之前的猜测。*/snprintf(pindesc->name, sizeof(pindesc->name),"%s-%d", pinfo->name, i);}
}

到这里，各个controller的信息，如base, pin number这些已经有了。
现在应该需要知道各个pin group内部的信息了吧!?
返回上一层到msm_pinctrl_dt_parse_pins().
msm_pinctrl_dt_parse_pins():

static int msm_pinctrl_dt_parse_pins(struct device_node *dev_node,struct msm_pinctrl_dd *dd)
{struct device *dev;struct device_node *pgrp_np;struct msm_pin_grps *pin_grps, *curr_grp;struct msm_pmx_funcs *pmx_funcs, *curr_func;char *func_name;const char *grp_name;int ret, i, grp_index = 0, func_index = 0;uint pin = 0, *pins, num_grps = 0, num_pins = 0, len = 0;uint num_funcs = 0;u32 func = 0;dev = dd->dev;/*遍历msm8939-pinctrl.dtsi中的各个node.*/for_each_child_of_node(dev_node, pgrp_np) {/*如果有qcom,pins定义，才表明是一个pin group.*/if (!of_find_property(pgrp_np, "qcom,pins", NULL))continue;/*有功能复用的话就加1，像sdc controller就没有这个property.*/if (of_find_property(pgrp_np, "qcom,pin-func", NULL))num_funcs++;num_grps++;}/*根据num_grps来分配，所以此struct应该是存pin group的信息了.*/pin_grps = (struct msm_pin_grps *)devm_kzalloc(dd->dev,sizeof(*pin_grps) * num_grps,GFP_KERNEL);if (!pin_grps) {dev_err(dev, "Failed to allocate grp desc\n");return -ENOMEM;}/*根据num_funs分配，所以应该是保存功能复现相关信息了。*/pmx_funcs = (struct msm_pmx_funcs *)devm_kzalloc(dd->dev,sizeof(*pmx_funcs) * num_funcs,GFP_KERNEL);if (!pmx_funcs) {dev_err(dev, "Failed to allocate grp desc\n");return -ENOMEM;}/** Iterate over all child nodes, and for nodes containing pin lists* populate corresponding pin group, and if provided, corresponding* function*//*遍历所有node*/for_each_child_of_node(dev_node, pgrp_np) {/*和之前一样，只遍历pin group node.*/if (!of_find_property(pgrp_np, "qcom,pins", NULL))continue;/*取出一个新的struct.*/curr_grp = pin_grps + grp_index;/* Get group name from label*//*获取pin group对应的label name.*/ret = of_property_read_string(pgrp_np, "label", &grp_name);if (ret) {dev_err(dev, "Unable to allocate group name\n");return ret;}/*此值表示当前pin group要用到几个pin管脚。*/ret = of_property_read_u32(pgrp_np, "qcom,num-grp-pins",&num_pins);if (ret) {dev_err(dev, "pin count not specified for groups %s\n",grp_name);return ret;}/*我去，又分配了一个struct, 有num_pins，看来准备存
Pin group 中若干个 pin的信息了.*/pins = devm_kzalloc(dd->dev, sizeof(unsigned int) * num_pins,GFP_KERNEL);if (!pins) {dev_err(dev, "Unable to allocte pins for %s\n",grp_name);return -ENOMEM;}/*遍历当前controller所有的pins.*/for (i = 0; i < num_pins; i++) {/*当前猜测它是读取pin group里的内容，带着疑问一会儿
分析此函数是不是我们想的那样?*/ret = msm_of_get_pin(pgrp_np, i, dd, &pin);if (ret) {dev_err(dev, "Pin grp %s does not have pins\n",grp_name);return ret;}pins[i] = pin;}/*每个pin group中对应的pin信息保存起来。*/curr_grp->pins = pins;curr_grp->num_pins = num_pins;curr_grp->name = grp_name;grp_index++;/* Check if func specified *//*如果没有复用功能，那就没必要执行下面的code了。*/if (!of_find_property(pgrp_np, "qcom,pin-func", NULL))continue;curr_func = pmx_funcs + func_index;len = strlen(grp_name) + strlen("-func") + 1;func_name = devm_kzalloc(dev, len, GFP_KERNEL);if (!func_name) {dev_err(dev, "Cannot allocate func name for grp %s",grp_name);return -ENOMEM;}snprintf(func_name, len, "%s%s", grp_name, "-func");/*以grp_name – func的形式保存复用名字*/curr_func->name = func_name;curr_func->gps = devm_kzalloc(dev, sizeof(char *), GFP_KERNEL);if (!curr_func->gps) {dev_err(dev, "failed to alloc memory for group list ");return -ENOMEM;}/*读取具体复用值，可从gpio复用列表中查询值对应的具体功能。*/of_property_read_u32(pgrp_np, "qcom,pin-func", &func);curr_grp->func = func;curr_func->gps[0] = grp_name;curr_func->num_grps = 1;func_index++;}/*把前面得到的信息都放到dd中管理。*/dd->pin_grps = pin_grps;dd->num_grps = num_grps;dd->pmx_funcs = pmx_funcs;dd->num_funcs = num_funcs;return 0;
}

到此，msm_pinctrl_get_drvdata()分析完了，即dts解析完毕，下一步应该是注册了，接着看
msm_register_gpiochip():

static void msm_register_gpiochip(struct msm_pinctrl_dd *dd)
{struct gpio_chip *gc;struct msm_pintype_info *pintype, *pinfo;int i, ret = 0;pinfo = dd->msm_pintype;/*遍历controller.*/for (i = 0; i < dd->num_pintypes; i++) {pintype = &pinfo[i];/*gpio 类型才可以！*/if (!msm_pintype_supports_gpio(pintype))continue;/*填充gpio对应的信息已经函数指针，可以想到，后面在调用的时候会跑到这些函数了。*/gc = &pintype->gc;gc->request = msm_pinctrl_request_gpio;gc->free = msm_pinctrl_free_gpio;gc->dev = dd->dev;gc->ngpio = pintype->num_pins;gc->base = -1;/*添加即注册一个gpio chip到系统中。*/ret = gpiochip_add(gc);if (ret) {dev_err(dd->dev, "failed to register gpio chip\n");pinfo->supports_gpio = false;}}
}

/通过DT controller node中的 gpio-controller property来判断。/

static bool msm_pintype_supports_gpio(struct msm_pintype_info *pinfo)
{struct device_node *pt_node;if (!pinfo->node)return false;for_each_child_of_node(pinfo->node, pt_node) {if (of_find_property(pt_node, "gpio-controller", NULL)) {pinfo->gc.of_node = pt_node;pinfo->supports_gpio = true;return true;}}return false;
}

Gpio注册完之后，后面陆续注册pinctrl和irq.

msm_register_pinctrl():

static int msm_register_pinctrl(struct msm_pinctrl_dd *dd)
{int i;struct pinctrl_pin_desc *pindesc;struct msm_pintype_info *pinfo, *pintype;struct pinctrl_desc *ctrl_desc = &dd->pctl;/*填充ctrl_desc, 主要是这些函数操作指针，设置的时候会被调用到。*/ctrl_desc->name = "msm-pinctrl";ctrl_desc->owner = THIS_MODULE;ctrl_desc->pmxops = &msm_pmxops;ctrl_desc->confops = &msm_pconfops;ctrl_desc->pctlops = &msm_pctrlops;pindesc = devm_kzalloc(dd->dev, sizeof(*pindesc) * dd->num_pins,GFP_KERNEL);if (!pindesc) {dev_err(dd->dev, "Failed to allocate pinctrl pin desc\n");return -ENOMEM;}/*保存所有pin的index, name信息。*/for (i = 0; i < dd->num_pins; i++) {pindesc[i].number = i;pindesc[i].name = dd->msm_pindesc[i].name;}ctrl_desc->pins = pindesc;ctrl_desc->npins = dd->num_pins;/*注册pinctrl. 后面有时间再分解吧！*/dd->pctl_dev = pinctrl_register(ctrl_desc, dd->dev, dd);if (!dd->pctl_dev) {dev_err(dd->dev, "could not register pinctrl driver\n");return -EINVAL;}/*把各个controller作为一个range来管理。*/pinfo = dd->msm_pintype;for (i = 0; i < dd->num_pintypes; i++) {pintype = &pinfo[i];if (!pintype->supports_gpio)continue;pintype->grange.name = pintype->name;pintype->grange.id = i;pintype->grange.pin_base = pintype->pin_start;pintype->grange.base = pintype->gc.base;pintype->grange.npins = pintype->gc.ngpio;pintype->grange.gc = &pintype->gc;/*添加到gpio range中*/pinctrl_add_gpio_range(dd->pctl_dev, &pintype->grange);}return 0;
}

接口的注册还没叙述，脑细胞死多了，伤不起.
pinctrl_register():

struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,struct device *dev, void *driver_data)
{struct pinctrl_dev *pctldev;int ret;if (!pctldesc)return NULL;if (!pctldesc->name)return NULL;pctldev = kzalloc(sizeof(*pctldev), GFP_KERNEL);if (pctldev == NULL) {dev_err(dev, "failed to alloc struct pinctrl_dev\n");return NULL;}/* Initialize pin control device struct */pctldev->owner = pctldesc->owner;pctldev->desc = pctldesc;pctldev->driver_data = driver_data;INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);INIT_LIST_HEAD(&pctldev->gpio_ranges);pctldev->dev = dev;mutex_init(&pctldev->mutex);/*一堆检查，不管。*//* check core ops for sanity */if (pinctrl_check_ops(pctldev)) {dev_err(dev, "pinctrl ops lacks necessary functions\n");goto out_err;}/* If we're implementing pinmuxing, check the ops for sanity */if (pctldesc->pmxops) {if (pinmux_check_ops(pctldev))goto out_err;}/* If we're implementing pinconfig, check the ops for sanity */if (pctldesc->confops) {if (pinconf_check_ops(pctldev))goto out_err;}/* Register all the pins */dev_dbg(dev, "try to register %d pins ...\n",  pctldesc->npins);/*将之前解析到的所有pins加到系统中去*/ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);if (ret) {dev_err(dev, "error during pin registration\n");pinctrl_free_pindescs(pctldev, pctldesc->pins,pctldesc->npins);goto out_err;}mutex_lock(&pinctrldev_list_mutex);list_add_tail(&pctldev->node, &pinctrldev_list);mutex_unlock(&pinctrldev_list_mutex);/*这个函数看似简单，其实内藏玄机，有没有发现pin group里的active/sleep
状态我们到现在还没解析到？ 这里其实就是解析state的。
不过在此流程里面，只是解析controller对应的state，DT中没用到，
所以应该查找失败会失败。 各个device的state解析会在内部driver init的
时候来解析。*/pctldev->p = pinctrl_get(pctldev->dev);if (!IS_ERR(pctldev->p)) {pctldev->hog_default =pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT);if (IS_ERR(pctldev->hog_default)) {dev_dbg(dev, "failed to lookup the default state\n");} else {if (pinctrl_select_state(pctldev->p,pctldev->hog_default))dev_err(dev,"failed to select default state\n");}pctldev->hog_sleep =pinctrl_lookup_state(pctldev->p,PINCTRL_STATE_SLEEP);if (IS_ERR(pctldev->hog_sleep))dev_dbg(dev, "failed to lookup the sleep state\n");}/*创建debugfs文件。*/pinctrl_init_device_debugfs(pctldev);return pctldev;out_err:mutex_destroy(&pctldev->mutex);kfree(pctldev);return NULL;
}

Pinctrl_get()不展开了，也是一般解析DT的方法，这里给出过程：

还剩一个irq注册没讲。
msm_register_irqchip():

static int msm_register_irqchip(struct msm_pinctrl_dd *dd)
{struct msm_pintype_info *pintype, *pinfo;int i, ret = 0;pinfo = dd->msm_pintype;for (i = 0; i < dd->num_pintypes; i++) {pintype = &pinfo[i];if (!msm_pintype_supports_irq(pintype))continue;/*调用的是gpio controller 的init_irq函数指针,即msm_tlmm_v4_gp_irq_init()*/
ret = pintype->init_irq(dd->irq, pintype, dd->dev);return ret;}return 0;
}

msm_tlmm_v4_gp_irq_init():
这个函数大家应该都能看懂了，不想码字了…

static int msm_tlmm_v4_gp_irq_init(int irq, struct msm_pintype_info *pinfo,struct device *tlmm_dev)
{int num_irqs;struct msm_tlmm_irq_chip *ic = pinfo->irq_chip;if (!ic->domain)return 0;num_irqs = ic->num_irqs;ic->enabled_irqs = devm_kzalloc(tlmm_dev, sizeof(unsigned long)* BITS_TO_LONGS(num_irqs), GFP_KERNEL);if (IS_ERR(ic->enabled_irqs)) {dev_err(tlmm_dev, "Unable to allocate enabled irqs bitmap\n");return PTR_ERR(ic->enabled_irqs);}ic->dual_edge_irqs = devm_kzalloc(tlmm_dev, sizeof(unsigned long)* BITS_TO_LONGS(num_irqs), GFP_KERNEL);if (IS_ERR(ic->dual_edge_irqs)) {dev_err(tlmm_dev, "Unable to allocate dual edge irqs bitmap\n");return PTR_ERR(ic->dual_edge_irqs);}ic->wake_irqs = devm_kzalloc(tlmm_dev, sizeof(unsigned long)* BITS_TO_LONGS(num_irqs), GFP_KERNEL);if (IS_ERR(ic->wake_irqs)) {dev_err(tlmm_dev, "Unable to allocate wake irqs bitmap\n");return PTR_ERR(ic->wake_irqs);}spin_lock_init(&ic->irq_lock);ic->chip_base = pinfo->reg_base;ic->irq = irq;ic->dev = tlmm_dev;ic->num_irqs = pinfo->num_pins;ic->pinfo = pinfo;register_syscore_ops(&msm_tlmm_v4_irq_syscore_ops);return 0;
}

虽然定义了好多的struct，不过分析完code之后，就可以很清楚的知道他们分别是用来干什么的，不像一开始上来云里雾里的。

接口使用:

Active/sleep状态设置：
对应pinctrl，重要而且常用的有如下几个接口：
 devm_pinctrl_get():
获取对应的pinctrl，你可以认为是拿到DT对应node中信息。
 pinctrl_lookup_state():
获取对应pinctrl state，其实就是获取自己在node中配置的actvie/sleep state.
 pinctrl_select_state():
根据active/sleep的信息设置为对应的state。

上面三个函数其实是取代了之前board-xxxx-gpiomux.c的设置active/sleep方法。

GPIO配置：
GPIO对外的接口基本上没变化，差异在内部通过调用pinctrl系统的API实现。
那gpio_direction_input()举例，现在的调用过程变成：

其他接口类似。

参考文档：

80-NL239-47_A_MSM8916_APSS_GPIO_Pin_Control_SW.pdf