From mboxrd@z Thu Jan 1 00:00:00 1970 From: robh@kernel.org (Rob Herring) Date: Thu, 24 May 2018 12:50:17 -0500 Subject: [PATCH v2 1/8] driver core: make deferring probe after init optional In-Reply-To: <20180524175024.19874-1-robh@kernel.org> References: <20180524175024.19874-1-robh@kernel.org> Message-ID: <20180524175024.19874-2-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. Subsystems or drivers may opt-in to this behavior by calling driver_deferred_probe_check_init_done() instead of just returning -EPROBE_DEFER. They may use additional information from DT or kernel's config to decide whether to continue to defer probe or not. Cc: Alexander Graf Signed-off-by: Rob Herring --- drivers/base/dd.c | 17 +++++++++++++++++ include/linux/device.h | 2 ++ 2 files changed, 19 insertions(+) diff --git a/drivers/base/dd.c b/drivers/base/dd.c index c9f54089429b..d6034718da6f 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -226,6 +226,16 @@ void device_unblock_probing(void) driver_deferred_probe_trigger(); } +int driver_deferred_probe_check_init_done(struct device *dev, bool optional) +{ + if (optional && initcalls_done) { + dev_WARN(dev, "ignoring dependency for device, assuming no driver"); + return -ENODEV; + } + + return -EPROBE_DEFER; +} + /** * deferred_probe_initcall() - Enable probing of deferred devices * @@ -240,6 +250,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/include/linux/device.h b/include/linux/device.h index 477956990f5e..f3dafd44c285 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -334,6 +334,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_check_init_done(struct device *dev, bool optional); + /** * 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: [PATCH v2 1/8] driver core: make deferring probe after init optional Date: Thu, 24 May 2018 12:50:17 -0500 Message-ID: <20180524175024.19874-2-robh@kernel.org> References: <20180524175024.19874-1-robh@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180524175024.19874-1-robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org> 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: Greg Kroah-Hartman , Linus Walleij , Alexander Graf , Bjorn Andersson , "Rafael J. Wysocki" , Kevin Hilman , Ulf Hansson , Joerg Roedel , Robin Murphy , Mark Brown , Frank Rowand Cc: devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, boot-architecture-cunTk1MwBs8s++Sfvej+rw@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, 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 eSBmaXJtd2FyZSBwZXJoYXBzKSB3aXRoIGEgc3RhYmxlIGtlcm5lbCB2ZXJzaW9uLgoKU3Vic3lz dGVtcyBvciBkcml2ZXJzIG1heSBvcHQtaW4gdG8gdGhpcyBiZWhhdmlvciBieSBjYWxsaW5nCmRy aXZlcl9kZWZlcnJlZF9wcm9iZV9jaGVja19pbml0X2RvbmUoKSBpbnN0ZWFkIG9mIGp1c3QgcmV0 dXJuaW5nCi1FUFJPQkVfREVGRVIuIFRoZXkgbWF5IHVzZSBhZGRpdGlvbmFsIGluZm9ybWF0aW9u IGZyb20gRFQgb3Iga2VybmVsJ3MKY29uZmlnIHRvIGRlY2lkZSB3aGV0aGVyIHRvIGNvbnRpbnVl IHRvIGRlZmVyIHByb2JlIG9yIG5vdC4KCkNjOiBBbGV4YW5kZXIgR3JhZiA8YWdyYWZAc3VzZS5k ZT4KU2lnbmVkLW9mZi1ieTogUm9iIEhlcnJpbmcgPHJvYmhAa2VybmVsLm9yZz4KLS0tCiBkcml2 ZXJzL2Jhc2UvZGQuYyAgICAgIHwgMTcgKysrKysrKysrKysrKysrKysKIGluY2x1ZGUvbGludXgv ZGV2aWNlLmggfCAgMiArKwogMiBmaWxlcyBjaGFuZ2VkLCAxOSBpbnNlcnRpb25zKCspCgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9iYXNlL2RkLmMgYi9kcml2ZXJzL2Jhc2UvZGQuYwppbmRleCBjOWY1 NDA4OTQyOWIuLmQ2MDM0NzE4ZGE2ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL2RkLmMKKysr IGIvZHJpdmVycy9iYXNlL2RkLmMKQEAgLTIyNiw2ICsyMjYsMTYgQEAgdm9pZCBkZXZpY2VfdW5i bG9ja19wcm9iaW5nKHZvaWQpCiAJZHJpdmVyX2RlZmVycmVkX3Byb2JlX3RyaWdnZXIoKTsKIH0K IAoraW50IGRyaXZlcl9kZWZlcnJlZF9wcm9iZV9jaGVja19pbml0X2RvbmUoc3RydWN0IGRldmlj ZSAqZGV2LCBib29sIG9wdGlvbmFsKQoreworCWlmIChvcHRpb25hbCAmJiBpbml0Y2FsbHNfZG9u ZSkgeworCQlkZXZfV0FSTihkZXYsICJpZ25vcmluZyBkZXBlbmRlbmN5IGZvciBkZXZpY2UsIGFz c3VtaW5nIG5vIGRyaXZlciIpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlyZXR1cm4gLUVQ Uk9CRV9ERUZFUjsKK30KKwogLyoqCiAgKiBkZWZlcnJlZF9wcm9iZV9pbml0Y2FsbCgpIC0gRW5h YmxlIHByb2Jpbmcgb2YgZGVmZXJyZWQgZGV2aWNlcwogICoKQEAgLTI0MCw2ICsyNTAsMTMgQEAg c3RhdGljIGludCBkZWZlcnJlZF9wcm9iZV9pbml0Y2FsbCh2b2lkKQogCS8qIFNvcnQgYXMgbWFu eSBkZXBlbmRlbmNpZXMgYXMgcG9zc2libGUgYmVmb3JlIGV4aXRpbmcgaW5pdGNhbGxzICovCiAJ Zmx1c2hfd29yaygmZGVmZXJyZWRfcHJvYmVfd29yayk7CiAJaW5pdGNhbGxzX2RvbmUgPSB0cnVl OworCisJLyoKKwkgKiBUcmlnZ2VyIGRlZmVycmVkIHByb2JlIGFnYWluLCB0aGlzIHRpbWUgd2Ug d29uJ3QgZGVmZXIgYW55dGhpbmcKKwkgKiB0aGF0IGlzIG9wdGlvbmFsCisJICovCisJZHJpdmVy X2RlZmVycmVkX3Byb2JlX3RyaWdnZXIoKTsKKwlmbHVzaF93b3JrKCZkZWZlcnJlZF9wcm9iZV93 b3JrKTsKIAlyZXR1cm4gMDsKIH0KIGxhdGVfaW5pdGNhbGwoZGVmZXJyZWRfcHJvYmVfaW5pdGNh bGwpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kZXZpY2UuaCBiL2luY2x1ZGUvbGludXgv ZGV2aWNlLmgKaW5kZXggNDc3OTU2OTkwZjVlLi5mM2RhZmQ0NGMyODUgMTAwNjQ0Ci0tLSBhL2lu Y2x1ZGUvbGludXgvZGV2aWNlLmgKKysrIGIvaW5jbHVkZS9saW51eC9kZXZpY2UuaApAQCAtMzM0 LDYgKzMzNCw4IEBAIHN0cnVjdCBkZXZpY2UgKmRyaXZlcl9maW5kX2RldmljZShzdHJ1Y3QgZGV2 aWNlX2RyaXZlciAqZHJ2LAogCQkJCSAgc3RydWN0IGRldmljZSAqc3RhcnQsIHZvaWQgKmRhdGEs CiAJCQkJICBpbnQgKCptYXRjaCkoc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpkYXRhKSk7CiAK K2ludCBkcml2ZXJfZGVmZXJyZWRfcHJvYmVfY2hlY2tfaW5pdF9kb25lKHN0cnVjdCBkZXZpY2Ug KmRldiwgYm9vbCBvcHRpb25hbCk7CisKIC8qKgogICogc3RydWN0IHN1YnN5c19pbnRlcmZhY2Ug LSBpbnRlcmZhY2VzIHRvIGRldmljZSBmdW5jdGlvbnMKICAqIEBuYW1lOiAgICAgICBuYW1lIG9m IHRoZSBkZXZpY2UgZnVuY3Rpb24KLS0gCjIuMTcuMAoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KYm9vdC1hcmNoaXRlY3R1cmUgbWFpbGluZyBsaXN0CmJv b3QtYXJjaGl0ZWN0dXJlQGxpc3RzLmxpbmFyby5vcmcKaHR0cHM6Ly9saXN0cy5saW5hcm8ub3Jn L21haWxtYW4vbGlzdGluZm8vYm9vdC1hcmNoaXRlY3R1cmUK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1032108AbeEXRw3 (ORCPT ); Thu, 24 May 2018 13:52:29 -0400 Received: from mail-yw0-f193.google.com ([209.85.161.193]:45527 "EHLO mail-yw0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1031090AbeEXRuc (ORCPT ); Thu, 24 May 2018 13:50:32 -0400 X-Google-Smtp-Source: AB8JxZrZ41eIsbztBjdsY2RQepep8ldqIBSgjJxurE4ch/uJWZpIxU0ff8eIk3/uqiRfUdotjvfKww== From: Rob Herring To: Greg Kroah-Hartman , Linus Walleij , Alexander Graf , Bjorn Andersson , "Rafael J. Wysocki" , Kevin Hilman , Ulf Hansson , Joerg Roedel , Robin Murphy , Mark Brown , Frank Rowand Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, boot-architecture@lists.linaro.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 1/8] driver core: make deferring probe after init optional Date: Thu, 24 May 2018 12:50:17 -0500 Message-Id: <20180524175024.19874-2-robh@kernel.org> X-Mailer: git-send-email 2.17.0 In-Reply-To: <20180524175024.19874-1-robh@kernel.org> References: <20180524175024.19874-1-robh@kernel.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.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. Subsystems or drivers may opt-in to this behavior by calling driver_deferred_probe_check_init_done() instead of just returning -EPROBE_DEFER. They may use additional information from DT or kernel's config to decide whether to continue to defer probe or not. Cc: Alexander Graf Signed-off-by: Rob Herring --- drivers/base/dd.c | 17 +++++++++++++++++ include/linux/device.h | 2 ++ 2 files changed, 19 insertions(+) diff --git a/drivers/base/dd.c b/drivers/base/dd.c index c9f54089429b..d6034718da6f 100644 --- a/drivers/base/dd.c +++ b/drivers/base/dd.c @@ -226,6 +226,16 @@ void device_unblock_probing(void) driver_deferred_probe_trigger(); } +int driver_deferred_probe_check_init_done(struct device *dev, bool optional) +{ + if (optional && initcalls_done) { + dev_WARN(dev, "ignoring dependency for device, assuming no driver"); + return -ENODEV; + } + + return -EPROBE_DEFER; +} + /** * deferred_probe_initcall() - Enable probing of deferred devices * @@ -240,6 +250,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/include/linux/device.h b/include/linux/device.h index 477956990f5e..f3dafd44c285 100644 --- a/include/linux/device.h +++ b/include/linux/device.h @@ -334,6 +334,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_check_init_done(struct device *dev, bool optional); + /** * struct subsys_interface - interfaces to device functions * @name: name of the device function -- 2.17.0