device tree 内 default pinctrl 和 probe的先后顺序

一，注册 driver时，default pinctrl是在 driver probe之前。

二，简略调用流程

platform_driver_register(drv)
	__platform_driver_register(struct platform_driver *drv, struct module *owner)
		driver_register(struct device_driver *drv)
			bus_add_driver(struct device_driver *drv)
				driver_attach(struct device_driver *drv)
					__driver_attach(struct device *dev, void *data)
						driver_probe_device(struct device_driver *drv, struct device *dev)
							really_probe(struct device *dev, struct device_driver *drv)
								pinctrl_bind_pins(struct device *dev)
									pinctrl_lookup_state(dev->pins->p,PINCTRL_STATE_DEFAULT)
									pinctrl_select_state()//先设置pinctrl default
								ret = dev->bus->probe(dev)
								ret = drv->probe(dev); //然后probe完成

二，完整调用流程：

1，xref: /kernel-3.18/include/linux/platform_device.h
191#define platform_driver_register(drv) \
192 __platform_driver_register(drv, THIS_MODULE)


2，xref: /kernel-3.18/drivers/base/platform.c 
578int __platform_driver_register(struct platform_driver *drv,
579 struct module *owner)
580{
581 drv->driver.owner = owner;
582 drv->driver.bus = &platform_bus_type;
583 if (drv->probe)
584 drv->driver.probe = platform_drv_probe;
585 if (drv->remove)
586 drv->driver.remove = platform_drv_remove;
587 if (drv->shutdown)
588 drv->driver.shutdown = platform_drv_shutdown;
589
590 return driver_register(&drv->driver);
591}


3，xref: /kernel-3.18/drivers/base/driver.c
147int driver_register(struct device_driver *drv)
148{
149 int ret;
150 struct device_driver *other;
151
152 BUG_ON(!drv->bus->p);
153
154 if ((drv->bus->probe && drv->probe) ||
155    (drv->bus->remove && drv->remove) ||
156    (drv->bus->shutdown && drv->shutdown))
157 printk(KERN_WARNING "Driver '%s' needs updating - please use "
158 "bus_type methods\n", drv->name);
159
160 other = driver_find(drv->name, drv->bus);
161 if (other) {
162 printk(KERN_ERR "Error: Driver '%s' is already registered, "
163 "aborting...\n", drv->name);
164 return -EBUSY;
165 }
166
167 ret = bus_add_driver(drv);
168 if (ret)
169 return ret;
170 ret = driver_add_groups(drv, drv->groups);
171 if (ret) {
172 bus_remove_driver(drv);
173 return ret;
174 }
175 kobject_uevent(&drv->p->kobj, KOBJ_ADD);
176
177 return ret;
178}


4，xref: /kernel-3.18/drivers/base/bus.c
666int bus_add_driver(struct device_driver *drv)
667{
668 struct bus_type *bus;
669 struct driver_private *priv;
670 int error = 0;
671
672 bus = bus_get(drv->bus);
673 if (!bus)
674 return -EINVAL;
675
676 pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
677
678 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
679 if (!priv) {
680 error = -ENOMEM;
681 goto out_put_bus;
682 }
683 klist_init(&priv->klist_devices, NULL, NULL);
684 priv->driver = drv;
685 drv->p = priv;
686 priv->kobj.kset = bus->p->drivers_kset;
687 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
688     "%s", drv->name);
689 if (error)
690 goto out_unregister;
691
692 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
693 if (drv->bus->p->drivers_autoprobe) {
694 error = driver_attach(drv);
695 if (error)
696 goto out_unregister;
697 }
698 module_add_driver(drv->owner, drv);
699
700 error = driver_create_file(drv, &driver_attr_uevent);
701 if (error) {
702 printk(KERN_ERR "%s: uevent attr (%s) failed\n",
703 __func__, drv->name);
704 }
705 error = driver_add_groups(drv, bus->drv_groups);
706 if (error) {
707 /* How the hell do we get out of this pickle? Give up */
708 printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",
709 __func__, drv->name);
710 }
711
712 if (!drv->suppress_bind_attrs) {
713 error = add_bind_files(drv);
714 if (error) {
715 /* Ditto */
716 printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
717 __func__, drv->name);
718 }
719 }
720
721 return 0;
722
723out_unregister:
724 kobject_put(&priv->kobj);
725 kfree(drv->p);
726 drv->p = NULL;
727out_put_bus:
728 bus_put(bus);
729 return error;
730}


5，xref: /kernel-3.18/drivers/base/dd.c
511int driver_attach(struct device_driver *drv)
512{
513 return bus_for_each_dev(drv->bus, NULL, drv,__driver_attach);
514}


6，xref: /kernel-3.18/drivers/base/dd.c
473static int __driver_attach(struct device *dev, void *data)
474{
475 struct device_driver *drv = data;
476
477 /*
478 * Lock device and try to bind to it. We drop the error
479 * here and always return 0, because we need to keep trying
480 * to bind to devices and some drivers will return an error
481 * simply if it didn't support the device.
482 *
483 * driver_probe_device() will spit a warning if there
484 * is an error.
485 */
486
487 if (!driver_match_device(drv, dev))
488 return 0;
489
490 if (dev->parent)/* Needed for USB */
491 device_lock(dev->parent);
492 device_lock(dev);
493 if (!dev->driver)
494 driver_probe_device(drv, dev);
495 device_unlock(dev);
496 if (dev->parent)
497 device_unlock(dev->parent);
498
499 return 0;
500}


7，xref: /kernel-3.18/drivers/base/dd.c
405int driver_probe_device(struct device_driver *drv, struct device *dev)
406{
407 int ret = 0;
408
409 if (!device_is_registered(dev))
410 return -ENODEV;
411
412 pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
413 drv->bus->name, __func__, dev_name(dev), drv->name);
414
415 pm_runtime_barrier(dev);
416 ret = really_probe(dev, drv);
417 pm_request_idle(dev);
418
419 return ret;
420}


8，xref: /kernel-3.18/drivers/base/dd.c
286static int really_probe(struct device *dev, struct device_driver *drv)
287{
288 int ret = 0;
289 int local_trigger_count = atomic_read(&deferred_trigger_count);
290#ifdef CONFIG_MTPROF
291 unsigned long long ts = 0;
292#endif
293
294 atomic_inc(&probe_count);
295 pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
296 drv->bus->name, __func__, drv->name, dev_name(dev));
297 WARN_ON(!list_empty(&dev->devres_head));
298
299 dev->driver = drv;
300
301 /* If using pinctrl, bind pins now before probing */
302 ret = pinctrl_bind_pins(dev);
303 if (ret)
304 goto probe_failed;
305
306 if (driver_sysfs_add(dev)) {
307 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
308 __func__, dev_name(dev));
309 goto probe_failed;
310 }
311
312 if (dev->bus->probe) {
313 TIME_LOG_START();
314 ret = dev->bus->probe(dev);
315 TIME_LOG_END();
316 bootprof_probe(ts, dev, drv, (unsigned long)dev->bus->probe);
317 if (ret)
318 goto probe_failed;
319 } else if (drv->probe) {
320 TIME_LOG_START();
321 ret = drv->probe(dev);
322 TIME_LOG_END();
323 bootprof_probe(ts, dev, drv, (unsigned long)drv->probe);
324 if (ret)
325 goto probe_failed;
326 }
327
328 driver_bound(dev);
329 ret = 1;
330 pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
331 drv->bus->name, __func__, dev_name(dev), drv->name);
332 goto done;
333
334probe_failed:
335 devres_release_all(dev);
336 driver_sysfs_remove(dev);
337 dev->driver = NULL;
338 dev_set_drvdata(dev, NULL);
339
340 if (ret == -EPROBE_DEFER) {
341 /* Driver requested deferred probing */
342 dev_info(dev, "Driver %s requests probe deferral\n", drv->name);
343 driver_deferred_probe_add(dev);
344 /* Did a trigger occur while probing? Need to re-trigger if yes */
345 if (local_trigger_count != atomic_read(&deferred_trigger_count))
346 driver_deferred_probe_trigger();
347 } else if (ret != -ENODEV && ret != -ENXIO) {
348 /* driver matched but the probe failed */
349 printk(KERN_WARNING
350       "%s: probe of %s failed with error %d\n",
351       drv->name, dev_name(dev), ret);
352 } else {
353 pr_debug("%s: probe of %s rejects match %d\n",
354       drv->name, dev_name(dev), ret);
355 }
356 /*
357 * Ignore errors returned by ->probe so that the next driver can try
358 * its luck.
359 */
360 ret = 0;
361done:
362 atomic_dec(&probe_count);
363 wake_up(&probe_waitqueue);
364 return ret;
365}


9，xref: /kernel-3.18/drivers/base/pinctrl.c
22int pinctrl_bind_pins(struct device *dev)
23{
24 int ret;
25
26 dev->pins = devm_kzalloc(dev, sizeof(*(dev->pins)), GFP_KERNEL);
27 if (!dev->pins)
28 return -ENOMEM;
29
30 dev->pins->p = devm_pinctrl_get(dev);
31 if (IS_ERR(dev->pins->p)) {
32 dev_dbg(dev, "no pinctrl handle\n");
33 ret = PTR_ERR(dev->pins->p);
34 goto cleanup_alloc;
35 }
36
37 dev->pins->default_state = pinctrl_lookup_state(dev->pins->p,
38 PINCTRL_STATE_DEFAULT);
39 if (IS_ERR(dev->pins->default_state)) {
40 dev_dbg(dev, "no default pinctrl state\n");
41 ret = 0;
42 goto cleanup_get;
43 }
44
45 ret = pinctrl_select_state(dev->pins->p, dev->pins->default_state);
  //在这里真正设置pinctrl default


46 if (ret) {
47 dev_dbg(dev, "failed to activate default pinctrl state\n");
48 goto cleanup_get;
49 }
50
51#ifdef CONFIG_PM
52 /*
53 * If power management is enabled, we also look for the optional
54 * sleep and idle pin states, with semantics as defined in
55 * <linux/pinctrl/pinctrl-state.h>
56 */
57 dev->pins->sleep_state = pinctrl_lookup_state(dev->pins->p,
58 PINCTRL_STATE_SLEEP);
59 if (IS_ERR(dev->pins->sleep_state))
60 /* Not supplying this state is perfectly legal */
61 dev_dbg(dev, "no sleep pinctrl state\n");
62
63 dev->pins->idle_state = pinctrl_lookup_state(dev->pins->p,
64 PINCTRL_STATE_IDLE);
65 if (IS_ERR(dev->pins->idle_state))
66 /* Not supplying this state is perfectly legal */
67 dev_dbg(dev, "no idle pinctrl state\n");
68#endif
69
70 return 0;
71
72 /*
73 * If no pinctrl handle or default state was found for this device,
74 * let's explicitly free the pin container in the device, there is
75 * no point in keeping it around.
76 */
77cleanup_get:
78 devm_pinctrl_put(dev->pins->p);
79cleanup_alloc:
80 devm_kfree(dev, dev->pins);
81 dev->pins = NULL;
82
83 /* Only return deferrals */
84 if (ret != -EPROBE_DEFER)
85 ret = 0;
86
87 return ret;
88}


10，xref: /kernel-3.18/include/linux/pinctrl/pinctrl-state.h
22#define PINCTRL_STATE_DEFAULT "default"
此处的“default”和 dts、dtsi里的pinctrl-names = "default"    pinctrl-0 = <&nfc_default>;  相对应。
某个project的DTS:
731&nfc {
732 pinctrl-names = "default", "ven_high", "ven_low", "rst_high", "rst_low", "eint_high", "eint_low", "irq_init";
733 pinctrl-0 = <&nfc_default>;