From mboxrd@z Thu Jan 1 00:00:00 1970 From: robh@kernel.org (Rob Herring) Date: Tue, 1 May 2018 16:31:14 -0500 Subject: [RFC PATCH] driver core: make deferring probe forever optional Message-ID: <20180501213114.20183-1-robh@kernel.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Deferred probe will currently wait forever on dependent devices to probe, but sometimes a driver will never exist. It's also not always critical for a driver to exist. Platforms can rely on default configuration from the bootloader or reset defaults for things such as pinctrl and power domains. This is often the case with initial platform support until various drivers get enabled. There's at least 2 scenarios where deferred probe can render a platform broken. Both involve using a DT which has more devices and dependencies than the kernel supports. The 1st case is a driver may be disabled in the kernel config. The 2nd case is the kernel version may simply not have the dependent driver. This can happen if using a newer DT (provided by firmware perhaps) with a stable kernel version. Unfortunately, this change breaks with modules as we have no way of knowing when modules are done loading. One possibility is to make this opt in or out based on compatible strings rather than at a subsystem level. Ideally this information could be extracted automatically somehow. OTOH, maybe the lists are pretty small. There's only a handful of subsystems that can be optional, and then only so many drivers in those that can be modules (at least for pinctrl, many drivers are built-in only). Cc: Alexander Graf Signed-off-by: Rob Herring --- This patch came out of a discussion on the ARM boot-architecture list[1] about DT forwards and backwards compatibility issues. There are issues with newer DTs breaking on older, stable kernels. Some of these are difficult to solve, but cases of optional devices not having kernel support should be solvable. I tested this on a RPi3 B with the pinctrl driver forced off. With this change, the MMC/SD and UART drivers can function without the pinctrl driver. Rob [1] https://lists.linaro.org/pipermail/boot-architecture/2018-April/000466.html drivers/base/dd.c | 16 ++++++++++++++++ drivers/pinctrl/devicetree.c | 2 +- include/linux/device.h | 2 ++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/drivers/base/dd.c b/drivers/base/dd.c index c9f54089429b..5848808b9d7a 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -226,6 +226,15 @@ void device_unblock_probing(void) driver_deferred_probe_trigger(); } + +int driver_deferred_probe_optional(void) +{ + if (initcalls_done) + return -ENODEV; + + return -EPROBE_DEFER; +} + /** * deferred_probe_initcall() - Enable probing of deferred devices * @@ -240,6 +249,13 @@ static int deferred_probe_initcall(void) /* Sort as many dependencies as possible before exiting initcalls */ flush_work(&deferred_probe_work); initcalls_done = true; + + /* + * Trigger deferred probe again, this time we won't defer anything + * that is optional + */ + driver_deferred_probe_trigger(); + flush_work(&deferred_probe_work); return 0; } late_initcall(deferred_probe_initcall); diff --git a/drivers/pinctrl/devicetree.c b/drivers/pinctrl/devicetree.c index b601039d6c69..096e52a5c506 100644 --- a/drivers/pinctrl/devicetree.c +++ b/drivers/pinctrl/devicetree.c @@ -120,7 +120,7 @@ static int dt_to_map_one_config(struct pinctrl *p, np_config); of_node_put(np_pctldev); /* OK let's just assume this will appear later then */ - return -EPROBE_DEFER; + return driver_deferred_probe_optional(); } /* If we're creating a hog we can use the passed pctldev */ if (pctldev && (np_pctldev == p->dev->of_node)) diff --git a/include/linux/device.h b/include/linux/device.h index 0059b99e1f25..8de920442bc1 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -332,6 +332,8 @@ struct device *driver_find_device(struct device_driver *drv, struct device *start, void *data, int (*match)(struct device *dev, void *data)); +int driver_deferred_probe_optional(void); + /** * struct subsys_interface - interfaces to device functions * @name: name of the device function -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Rob Herring Subject: [RFC PATCH] driver core: make deferring probe forever optional Date: Tue, 1 May 2018 16:31:14 -0500 Message-ID: <20180501213114.20183-1-robh@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: boot-architecture-bounces-cunTk1MwBs8s++Sfvej+rw@public.gmane.org Sender: "boot-architecture" To: linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org Cc: boot-architecture-cunTk1MwBs8s++Sfvej+rw@public.gmane.org, Stephen Boyd , Greg Kroah-Hartman , Linus Walleij , Alexander Graf , Grant Likely , Mark Brown , linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org List-Id: devicetree@vger.kernel.org RGVmZXJyZWQgcHJvYmUgd2lsbCBjdXJyZW50bHkgd2FpdCBmb3JldmVyIG9uIGRlcGVuZGVudCBk ZXZpY2VzIHRvIHByb2JlLApidXQgc29tZXRpbWVzIGEgZHJpdmVyIHdpbGwgbmV2ZXIgZXhpc3Qu IEl0J3MgYWxzbyBub3QgYWx3YXlzIGNyaXRpY2FsIGZvcgphIGRyaXZlciB0byBleGlzdC4gUGxh dGZvcm1zIGNhbiByZWx5IG9uIGRlZmF1bHQgY29uZmlndXJhdGlvbiBmcm9tIHRoZQpib290bG9h ZGVyIG9yIHJlc2V0IGRlZmF1bHRzIGZvciB0aGluZ3Mgc3VjaCBhcyBwaW5jdHJsIGFuZCBwb3dl ciBkb21haW5zLgpUaGlzIGlzIG9mdGVuIHRoZSBjYXNlIHdpdGggaW5pdGlhbCBwbGF0Zm9ybSBz dXBwb3J0IHVudGlsIHZhcmlvdXMgZHJpdmVycwpnZXQgZW5hYmxlZC4gVGhlcmUncyBhdCBsZWFz dCAyIHNjZW5hcmlvcyB3aGVyZSBkZWZlcnJlZCBwcm9iZSBjYW4gcmVuZGVyCmEgcGxhdGZvcm0g YnJva2VuLiBCb3RoIGludm9sdmUgdXNpbmcgYSBEVCB3aGljaCBoYXMgbW9yZSBkZXZpY2VzIGFu ZApkZXBlbmRlbmNpZXMgdGhhbiB0aGUga2VybmVsIHN1cHBvcnRzLiBUaGUgMXN0IGNhc2UgaXMg YSBkcml2ZXIgbWF5IGJlCmRpc2FibGVkIGluIHRoZSBrZXJuZWwgY29uZmlnLiBUaGUgMm5kIGNh c2UgaXMgdGhlIGtlcm5lbCB2ZXJzaW9uIG1heQpzaW1wbHkgbm90IGhhdmUgdGhlIGRlcGVuZGVu dCBkcml2ZXIuIFRoaXMgY2FuIGhhcHBlbiBpZiB1c2luZyBhIG5ld2VyIERUCihwcm92aWRlZCBi eSBmaXJtd2FyZSBwZXJoYXBzKSB3aXRoIGEgc3RhYmxlIGtlcm5lbCB2ZXJzaW9uLgoKVW5mb3J0 dW5hdGVseSwgdGhpcyBjaGFuZ2UgYnJlYWtzIHdpdGggbW9kdWxlcyBhcyB3ZSBoYXZlIG5vIHdh eSBvZgprbm93aW5nIHdoZW4gbW9kdWxlcyBhcmUgZG9uZSBsb2FkaW5nLiBPbmUgcG9zc2liaWxp dHkgaXMgdG8gbWFrZSB0aGlzCm9wdCBpbiBvciBvdXQgYmFzZWQgb24gY29tcGF0aWJsZSBzdHJp bmdzIHJhdGhlciB0aGFuIGF0IGEgc3Vic3lzdGVtIGxldmVsLgpJZGVhbGx5IHRoaXMgaW5mb3Jt YXRpb24gY291bGQgYmUgZXh0cmFjdGVkIGF1dG9tYXRpY2FsbHkgc29tZWhvdy4gT1RPSCwKbWF5 YmUgdGhlIGxpc3RzIGFyZSBwcmV0dHkgc21hbGwuIFRoZXJlJ3Mgb25seSBhIGhhbmRmdWwgb2Yg c3Vic3lzdGVtcwp0aGF0IGNhbiBiZSBvcHRpb25hbCwgYW5kIHRoZW4gb25seSBzbyBtYW55IGRy aXZlcnMgaW4gdGhvc2UgdGhhdCBjYW4gYmUKbW9kdWxlcyAoYXQgbGVhc3QgZm9yIHBpbmN0cmws IG1hbnkgZHJpdmVycyBhcmUgYnVpbHQtaW4gb25seSkuCgpDYzogQWxleGFuZGVyIEdyYWYgPGFn cmFmQHN1c2UuZGU+ClNpZ25lZC1vZmYtYnk6IFJvYiBIZXJyaW5nIDxyb2JoQGtlcm5lbC5vcmc+ Ci0tLQpUaGlzIHBhdGNoIGNhbWUgb3V0IG9mIGEgZGlzY3Vzc2lvbiBvbiB0aGUgQVJNIGJvb3Qt YXJjaGl0ZWN0dXJlIApsaXN0WzFdIGFib3V0IERUIGZvcndhcmRzIGFuZCBiYWNrd2FyZHMgY29t cGF0aWJpbGl0eSBpc3N1ZXMuIFRoZXJlIGFyZSAKaXNzdWVzIHdpdGggbmV3ZXIgRFRzIGJyZWFr aW5nIG9uIG9sZGVyLCBzdGFibGUga2VybmVscy4gU29tZSBvZiB0aGVzZSAKYXJlIGRpZmZpY3Vs dCB0byBzb2x2ZSwgYnV0IGNhc2VzIG9mIG9wdGlvbmFsIGRldmljZXMgbm90IGhhdmluZyAKa2Vy bmVsIHN1cHBvcnQgc2hvdWxkIGJlIHNvbHZhYmxlLgoKSSB0ZXN0ZWQgdGhpcyBvbiBhIFJQaTMg QiB3aXRoIHRoZSBwaW5jdHJsIGRyaXZlciBmb3JjZWQgb2ZmLiBXaXRoIHRoaXMgCmNoYW5nZSwg dGhlIE1NQy9TRCBhbmQgVUFSVCBkcml2ZXJzIGNhbiBmdW5jdGlvbiB3aXRob3V0IHRoZSBwaW5j dHJsIApkcml2ZXIuCgpSb2IKClsxXSBodHRwczovL2xpc3RzLmxpbmFyby5vcmcvcGlwZXJtYWls L2Jvb3QtYXJjaGl0ZWN0dXJlLzIwMTgtQXByaWwvMDAwNDY2Lmh0bWwKCiBkcml2ZXJzL2Jhc2Uv ZGQuYyAgICAgICAgICAgIHwgMTYgKysrKysrKysrKysrKysrKwogZHJpdmVycy9waW5jdHJsL2Rl dmljZXRyZWUuYyB8ICAyICstCiBpbmNsdWRlL2xpbnV4L2RldmljZS5oICAgICAgIHwgIDIgKysK IDMgZmlsZXMgY2hhbmdlZCwgMTkgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvYmFzZS9kZC5jIGIvZHJpdmVycy9iYXNlL2RkLmMKaW5kZXggYzlmNTQw ODk0MjliLi41ODQ4ODA4YjlkN2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmFzZS9kZC5jCisrKyBi L2RyaXZlcnMvYmFzZS9kZC5jCkBAIC0yMjYsNiArMjI2LDE1IEBAIHZvaWQgZGV2aWNlX3VuYmxv Y2tfcHJvYmluZyh2b2lkKQogCWRyaXZlcl9kZWZlcnJlZF9wcm9iZV90cmlnZ2VyKCk7CiB9CiAK KworaW50IGRyaXZlcl9kZWZlcnJlZF9wcm9iZV9vcHRpb25hbCh2b2lkKQoreworCWlmIChpbml0 Y2FsbHNfZG9uZSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlyZXR1cm4gLUVQUk9CRV9ERUZFUjsK K30KKwogLyoqCiAgKiBkZWZlcnJlZF9wcm9iZV9pbml0Y2FsbCgpIC0gRW5hYmxlIHByb2Jpbmcg b2YgZGVmZXJyZWQgZGV2aWNlcwogICoKQEAgLTI0MCw2ICsyNDksMTMgQEAgc3RhdGljIGludCBk ZWZlcnJlZF9wcm9iZV9pbml0Y2FsbCh2b2lkKQogCS8qIFNvcnQgYXMgbWFueSBkZXBlbmRlbmNp ZXMgYXMgcG9zc2libGUgYmVmb3JlIGV4aXRpbmcgaW5pdGNhbGxzICovCiAJZmx1c2hfd29yaygm ZGVmZXJyZWRfcHJvYmVfd29yayk7CiAJaW5pdGNhbGxzX2RvbmUgPSB0cnVlOworCisJLyoKKwkg KiBUcmlnZ2VyIGRlZmVycmVkIHByb2JlIGFnYWluLCB0aGlzIHRpbWUgd2Ugd29uJ3QgZGVmZXIg YW55dGhpbmcKKwkgKiB0aGF0IGlzIG9wdGlvbmFsCisJICovCisJZHJpdmVyX2RlZmVycmVkX3By b2JlX3RyaWdnZXIoKTsKKwlmbHVzaF93b3JrKCZkZWZlcnJlZF9wcm9iZV93b3JrKTsKIAlyZXR1 cm4gMDsKIH0KIGxhdGVfaW5pdGNhbGwoZGVmZXJyZWRfcHJvYmVfaW5pdGNhbGwpOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9waW5jdHJsL2RldmljZXRyZWUuYyBiL2RyaXZlcnMvcGluY3RybC9kZXZp Y2V0cmVlLmMKaW5kZXggYjYwMTAzOWQ2YzY5Li4wOTZlNTJhNWM1MDYgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvcGluY3RybC9kZXZpY2V0cmVlLmMKKysrIGIvZHJpdmVycy9waW5jdHJsL2RldmljZXRy ZWUuYwpAQCAtMTIwLDcgKzEyMCw3IEBAIHN0YXRpYyBpbnQgZHRfdG9fbWFwX29uZV9jb25maWco c3RydWN0IHBpbmN0cmwgKnAsCiAJCQkJbnBfY29uZmlnKTsKIAkJCW9mX25vZGVfcHV0KG5wX3Bj dGxkZXYpOwogCQkJLyogT0sgbGV0J3MganVzdCBhc3N1bWUgdGhpcyB3aWxsIGFwcGVhciBsYXRl ciB0aGVuICovCi0JCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKKwkJCXJldHVybiBkcml2ZXJfZGVm ZXJyZWRfcHJvYmVfb3B0aW9uYWwoKTsKIAkJfQogCQkvKiBJZiB3ZSdyZSBjcmVhdGluZyBhIGhv ZyB3ZSBjYW4gdXNlIHRoZSBwYXNzZWQgcGN0bGRldiAqLwogCQlpZiAocGN0bGRldiAmJiAobnBf cGN0bGRldiA9PSBwLT5kZXYtPm9mX25vZGUpKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9k ZXZpY2UuaCBiL2luY2x1ZGUvbGludXgvZGV2aWNlLmgKaW5kZXggMDA1OWI5OWUxZjI1Li44ZGU5 MjA0NDJiYzEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZGV2aWNlLmgKKysrIGIvaW5jbHVk ZS9saW51eC9kZXZpY2UuaApAQCAtMzMyLDYgKzMzMiw4IEBAIHN0cnVjdCBkZXZpY2UgKmRyaXZl cl9maW5kX2RldmljZShzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2LAogCQkJCSAgc3RydWN0IGRl dmljZSAqc3RhcnQsIHZvaWQgKmRhdGEsCiAJCQkJICBpbnQgKCptYXRjaCkoc3RydWN0IGRldmlj ZSAqZGV2LCB2b2lkICpkYXRhKSk7CiAKK2ludCBkcml2ZXJfZGVmZXJyZWRfcHJvYmVfb3B0aW9u YWwodm9pZCk7CisKIC8qKgogICogc3RydWN0IHN1YnN5c19pbnRlcmZhY2UgLSBpbnRlcmZhY2Vz IHRvIGRldmljZSBmdW5jdGlvbnMKICAqIEBuYW1lOiAgICAgICBuYW1lIG9mIHRoZSBkZXZpY2Ug ZnVuY3Rpb24KLS0gCjIuMTcuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KYm9vdC1hcmNoaXRlY3R1cmUgbWFpbGluZyBsaXN0CmJvb3QtYXJjaGl0ZWN0 dXJlQGxpc3RzLmxpbmFyby5vcmcKaHR0cHM6Ly9saXN0cy5saW5hcm8ub3JnL21haWxtYW4vbGlz dGluZm8vYm9vdC1hcmNoaXRlY3R1cmUK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: ARC-Seal: i=1; a=rsa-sha256; t=1525210277; cv=none; d=google.com; s=arc-20160816; b=RkwzQO33jR+REfU49b+xuGL0moiAWe7kpyfzys/BjZaE2iHJpFt2s2lPqTQee+3M37 q9ByAXXQi1LDUEaahwSg5Hxu4EEpxhx1hqyro/mf/5ytumZy1D/UBpaviQPX/hVFAGAX yu/Gwzg4vQBPQF2EUMivOVdOpnVXDwAA6k0Tdf1mBzXjo8utAFg/8IpS580s1ahiW12R OWgx5xi9WRXlw8rVMvOM3IVMl9cdCqlxX+8FtpP22tXkxorfe17cMbzQX6yLjhwdFhdt dmVZdhJSiohQYwL/Pkz/hlM1Y9XLqE3ZMjw/uxkNAGM8nUsNCkEWFTuNx1u0gh+W/V1O xLwQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=message-id:date:subject:cc:to:from:arc-authentication-results; bh=3cYFgsswRS+nQtL2/pArPQ1MvoY0ti57mnwCmOACsCY=; b=QsZk9onYSsjeO8U3IzAU+QbkNk/nq9/gJbq7Pcphg+IL6ojbn8uS9rPyW60hsdc2bT smtLtnJsBY3yM5wlj8zyYqVPK4zJE8BtyIKOP4zTAKZ5bodLM+2UwcDqHXSK7RM2ltzP hAnoYm8ba1N0psr8vyZUxYrO9HTOnJy7HhSjg/d49ZWMozKJaKIjxMxp5/XXwhUAst3Q 7RckRdop1sDwHozZhJCOg4sl4o7k1D66qf16FNo3a1cIthQ9rI03Wp4jbHDQ88YDHjTK Qz72aVLy4kHfOybSt5JcSr/PVmi4IRkfKZQTKsXQ68Rf8kJ6WYRU1zBxrJpQTyqg3PVC 7jug== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of robherring2@gmail.com designates 209.85.220.65 as permitted sender) smtp.mailfrom=robherring2@gmail.com Authentication-Results: mx.google.com; spf=pass (google.com: domain of robherring2@gmail.com designates 209.85.220.65 as permitted sender) smtp.mailfrom=robherring2@gmail.com X-Google-Smtp-Source: AB8JxZovskANJQnQLUUqoUbkp/zbZK+NEoAGuxo0yUVOHBFtDRWWwFLA9XgbZsaJ0wWX//DXk6Wkww== From: Rob Herring To: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org Cc: Greg Kroah-Hartman , Grant Likely , Linus Walleij , Mark Brown , Stephen Boyd , boot-architecture@lists.linaro.org, linux-arm-kernel@lists.infradead.org, Alexander Graf Subject: [RFC PATCH] driver core: make deferring probe forever optional Date: Tue, 1 May 2018 16:31:14 -0500 Message-Id: <20180501213114.20183-1-robh@kernel.org> X-Mailer: git-send-email 2.17.0 X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: =?utf-8?q?1599298891509345819?= X-GMAIL-MSGID: =?utf-8?q?1599298891509345819?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: Deferred probe will currently wait forever on dependent devices to probe, but sometimes a driver will never exist. It's also not always critical for a driver to exist. Platforms can rely on default configuration from the bootloader or reset defaults for things such as pinctrl and power domains. This is often the case with initial platform support until various drivers get enabled. There's at least 2 scenarios where deferred probe can render a platform broken. Both involve using a DT which has more devices and dependencies than the kernel supports. The 1st case is a driver may be disabled in the kernel config. The 2nd case is the kernel version may simply not have the dependent driver. This can happen if using a newer DT (provided by firmware perhaps) with a stable kernel version. Unfortunately, this change breaks with modules as we have no way of knowing when modules are done loading. One possibility is to make this opt in or out based on compatible strings rather than at a subsystem level. Ideally this information could be extracted automatically somehow. OTOH, maybe the lists are pretty small. There's only a handful of subsystems that can be optional, and then only so many drivers in those that can be modules (at least for pinctrl, many drivers are built-in only). Cc: Alexander Graf Signed-off-by: Rob Herring --- This patch came out of a discussion on the ARM boot-architecture list[1] about DT forwards and backwards compatibility issues. There are issues with newer DTs breaking on older, stable kernels. Some of these are difficult to solve, but cases of optional devices not having kernel support should be solvable. I tested this on a RPi3 B with the pinctrl driver forced off. With this change, the MMC/SD and UART drivers can function without the pinctrl driver. Rob [1] https://lists.linaro.org/pipermail/boot-architecture/2018-April/000466.html drivers/base/dd.c | 16 ++++++++++++++++ drivers/pinctrl/devicetree.c | 2 +- include/linux/device.h | 2 ++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/drivers/base/dd.c b/drivers/base/dd.c index c9f54089429b..5848808b9d7a 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -226,6 +226,15 @@ void device_unblock_probing(void) driver_deferred_probe_trigger(); } + +int driver_deferred_probe_optional(void) +{ + if (initcalls_done) + return -ENODEV; + + return -EPROBE_DEFER; +} + /** * deferred_probe_initcall() - Enable probing of deferred devices * @@ -240,6 +249,13 @@ static int deferred_probe_initcall(void) /* Sort as many dependencies as possible before exiting initcalls */ flush_work(&deferred_probe_work); initcalls_done = true; + + /* + * Trigger deferred probe again, this time we won't defer anything + * that is optional + */ + driver_deferred_probe_trigger(); + flush_work(&deferred_probe_work); return 0; } late_initcall(deferred_probe_initcall); diff --git a/drivers/pinctrl/devicetree.c b/drivers/pinctrl/devicetree.c index b601039d6c69..096e52a5c506 100644 --- a/drivers/pinctrl/devicetree.c +++ b/drivers/pinctrl/devicetree.c @@ -120,7 +120,7 @@ static int dt_to_map_one_config(struct pinctrl *p, np_config); of_node_put(np_pctldev); /* OK let's just assume this will appear later then */ - return -EPROBE_DEFER; + return driver_deferred_probe_optional(); } /* If we're creating a hog we can use the passed pctldev */ if (pctldev && (np_pctldev == p->dev->of_node)) diff --git a/include/linux/device.h b/include/linux/device.h index 0059b99e1f25..8de920442bc1 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -332,6 +332,8 @@ struct device *driver_find_device(struct device_driver *drv, struct device *start, void *data, int (*match)(struct device *dev, void *data)); +int driver_deferred_probe_optional(void); + /** * struct subsys_interface - interfaces to device functions * @name: name of the device function -- 2.17.0