From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v3,2/5] ACPI / bus: Do not traverse through non-existed device table From: Andy Shevchenko Message-Id: <1518108802.22495.207.camel@linux.intel.com> Date: Thu, 08 Feb 2018 18:53:22 +0200 To: "Rafael J. Wysocki" Cc: dmaengine , "Rafael J . Wysocki" , ACPI Devel Maling List , Mika Westerberg , Sinan Kaya , Sakari Ailus , Vinod Koul List-ID: T24gVGh1LCAyMDE4LTAyLTA4IGF0IDE2OjU5ICswMTAwLCBSYWZhZWwgSi4gV3lzb2NraSB3cm90 ZToKPiBPbiBXZWQsIEZlYiA3LCAyMDE4IGF0IDM6NTYgUE0sIEFuZHkgU2hldmNoZW5rbwo+IDxh bmRyaXkuc2hldmNoZW5rb0BsaW51eC5pbnRlbC5jb20+IHdyb3RlOgo+ID4gCgo+IEFuZCBhcyBm YXIgYXMgSSdtIGNvbmNlcm5lZCB5b3UgY2FuIGRvOgo+IAo+IGlmICghc3RyY21wKEFDUElfRFRf TkFNRVNQQUNFX0hJRCwgaHdpZC0+aWQpCj4gICAgICAgICByZXR1cm4gKGNvbnN0IHN0cnVjdCBh Y3BpX2RldmljZV9pZAo+ICopYWNwaV9vZl9tYXRjaF9kZXZpY2UoZGV2aWNlLCBvZl9pZHMpOwo+ IAo+IGFuZCB1cGRhdGUgdGhlIGNvbW1lbnQgYWNjb3JkaW5nbHkuCgpXb3VsZCB0aGUgZm9sbG93 aW5nIHdvcmsgZm9yIHlvdT8KCi0tLSA4PCAtLS0gODwgLS0tIDg8IC0tLQpGcm9tIDAzMDEzYzBj MWU0ODdjZGE0YzBkOGRjNTA2NWVkMmYwMDMxMDk1ZGUgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAx CkZyb206IEFuZHkgU2hldmNoZW5rbyA8YW5kcml5LnNoZXZjaGVua29AbGludXguaW50ZWwuY29t PgpEYXRlOiBUaHUsIDEgRmViIDIwMTggMjE6NTI6MTQgKzAyMDAKU3ViamVjdDogW1BBVENIIDEv MV0gQUNQSSAvIGJ1czogRG8gbm90IHRyYXZlcnNlIHRocm91Z2ggbm9uLWV4aXN0ZWQKZGV2aWNl CiB0YWJsZQoKV2hlbiBfX2FjcGlfbWF0Y2hfZGV2aWNlKCkgaXMgY2FsbGVkIGl0IHdvdWxkIGJl IHBvc3NpYmxlIHRvIGhhdmUKQUNQSSBJRCB0YWJsZSBhIE1VTEwgcG9pbnRlci4gVG8gYXZvaWQg cG90ZW50aWFsIGRlcmVmZXJlbmNlLApjaGVjayBmb3IgdGhpcyBiZWZvcmUgdHJhdmVyc2UuCgpU aGlzIHBhdGNoIGltcGxpZXMgYSBiaXQgb2YgcmVmYWN0b3JpbmcgYWNwaV9vZl9tYXRjaF9kZXZp Y2UoKSB0byByZXR1cm4KcG9pbnRlciB0byBPRiBJRCB3aGVuIG1hdGNoZWQgZm9sbG93ZWQgYnkg cmVmYWN0b3JpbmcKX19hY3BpX21hdGNoX2RldmljZSgpIHRvIHJldHVybiBlaXRoZXIgQUNQSSBv ciBPRiBJRCB3aGVuIG1hdGNoZXMuCgpXaGlsZSBoZXJlLCByZW1vdmUgcmVkdW5kYW50ICdlbHNl Jy4KCkNjOiBTaW5hbiBLYXlhIDxva2F5YUBjb2RlYXVyb3JhLm9yZz4KQ2M6IFNha2FyaSBBaWx1 cyA8c2FrYXJpLmFpbHVzQGxpbnV4LmludGVsLmNvbT4KQ2M6IFZpbm9kIEtvdWwgPHZpbm9kLmtv dWxAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBBbmR5IFNoZXZjaGVua28gPGFuZHJpeS5zaGV2 Y2hlbmtvQGxpbnV4LmludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2FjcGkvYnVzLmMgfCA2NiArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0KLS0tLS0tLS0tCiAxIGZp bGUgY2hhbmdlZCwgNDEgaW5zZXJ0aW9ucygrKSwgMjUgZGVsZXRpb25zKC0pCgorCQkJCSBjb25z dCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkCipvZl9tYXRjaF90YWJsZSwKKwkJCQkgY29uc3Qgc3RydWN0 IG9mX2RldmljZV9pZCAqKm9mX2lkKQogewogCWNvbnN0IHVuaW9uIGFjcGlfb2JqZWN0ICpvZl9j b21wYXRpYmxlLCAqb2JqOwogCWludCBpLCBudmFsOwpAQCAtNjkwLDggKzY5MiwxMSBAQCBzdGF0 aWMgYm9vbCBhY3BpX29mX21hdGNoX2RldmljZShzdHJ1Y3QgYWNwaV9kZXZpY2UKKmFkZXYsCiAJ CWNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgKmlkOwogCiAJCWZvciAoaWQgPSBvZl9tYXRjaF90 YWJsZTsgaWQtPmNvbXBhdGlibGVbMF07IGlkKyspCi0JCQlpZiAoIXN0cmNhc2VjbXAob2JqLT5z dHJpbmcucG9pbnRlciwgaWQtCj5jb21wYXRpYmxlKSkKKwkJCWlmICghc3RyY2FzZWNtcChvYmot PnN0cmluZy5wb2ludGVyLCBpZC0KPmNvbXBhdGlibGUpKSB7CisJCQkJaWYgKG9mX2lkKQorCQkJ CQkqb2ZfaWQgPSBpZDsKIAkJCQlyZXR1cm4gdHJ1ZTsKKwkJCX0KIAl9CiAKIAlyZXR1cm4gZmFs c2U7CkBAIC03NjIsMTAgKzc2NywxMSBAQCBzdGF0aWMgYm9vbCBfX2FjcGlfbWF0Y2hfZGV2aWNl X2Nscyhjb25zdCBzdHJ1Y3QKYWNwaV9kZXZpY2VfaWQgKmlkLAogCXJldHVybiB0cnVlOwogfQog Ci1zdGF0aWMgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICpfX2FjcGlfbWF0Y2hfZGV2aWNl KAotCXN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLAotCWNvbnN0IHN0cnVjdCBhY3BpX2Rldmlj ZV9pZCAqaWRzLAotCWNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgKm9mX2lkcykKK3N0YXRpYyBi b29sIF9fYWNwaV9tYXRjaF9kZXZpY2Uoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UsCisJCQkJ Y29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICphY3BpX2lkcywKKwkJCQljb25zdCBzdHJ1Y3Qg b2ZfZGV2aWNlX2lkICpvZl9pZHMsCisJCQkJY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICoq YWNwaV9pZCwKKwkJCQljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICoqb2ZfaWQpCiB7CiAJY29u c3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICppZDsKIAlzdHJ1Y3QgYWNwaV9oYXJkd2FyZV9pZCAq aHdpZDsKQEAgLTc3NSwzMCArNzgxLDM1IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWNwaV9kZXZp Y2VfaWQKKl9fYWNwaV9tYXRjaF9kZXZpY2UoCiAJICogZHJpdmVyIGZvciBpdC4KIAkgKi8KIAlp ZiAoIWRldmljZSB8fCAhZGV2aWNlLT5zdGF0dXMucHJlc2VudCkKLQkJcmV0dXJuIE5VTEw7CisJ CXJldHVybiBmYWxzZTsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkoaHdpZCwgJmRldmljZS0+cG5w LmlkcywgbGlzdCkgewogCQkvKiBGaXJzdCwgY2hlY2sgdGhlIEFDUEkvUE5QIElEcyBwcm92aWRl ZCBieSB0aGUKY2FsbGVyLiAqLwotCQlmb3IgKGlkID0gaWRzOyBpZC0+aWRbMF0gfHwgaWQtPmNs czsgaWQrKykgewotCQkJaWYgKGlkLT5pZFswXSAmJiAhc3RyY21wKChjaGFyICopIGlkLT5pZCwg aHdpZC0KPmlkKSkKLQkJCQlyZXR1cm4gaWQ7Ci0JCQllbHNlIGlmIChpZC0+Y2xzICYmIF9fYWNw aV9tYXRjaF9kZXZpY2VfY2xzKGlkLApod2lkKSkKLQkJCQlyZXR1cm4gaWQ7CisJCWlmIChhY3Bp X2lkcykgeworCQkJYm9vbCBmb3VuZDsKKworCQkJZm9yIChpZCA9IGFjcGlfaWRzOyBpZC0+aWRb MF0gfHwgaWQtPmNsczsgaWQrKykKeworCQkJCWZvdW5kID0gZmFsc2U7CisJCQkJaWYgKGlkLT5p ZFswXSAmJiAhc3RyY21wKChjaGFyICopaWQtCj5pZCwgaHdpZC0+aWQpKQorCQkJCQlmb3VuZCA9 IHRydWU7CisJCQkJaWYgKGlkLT5jbHMgJiYKX19hY3BpX21hdGNoX2RldmljZV9jbHMoaWQsIGh3 aWQpKQorCQkJCQlmb3VuZCA9IHRydWU7CisJCQkJaWYgKGZvdW5kKSB7CisJCQkJCWlmIChhY3Bp X2lkKQorCQkJCQkJKmFjcGlfaWQgPSBpZDsKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJfQorCQkJ fQogCQl9CiAKIAkJLyoKIAkJICogTmV4dCwgY2hlY2sgQUNQSV9EVF9OQU1FU1BBQ0VfSElEIGFu ZCB0cnkgdG8gbWF0Y2gKdGhlCiAJCSAqICJjb21wYXRpYmxlIiBwcm9wZXJ0eSBpZiBmb3VuZC4K LQkJICoKLQkJICogVGhlIGlkIHJldHVybmVkIGJ5IHRoZSBiZWxvdyBpcyBub3QgdmFsaWQsIGJ1 dCB0aGUKb25seQotCQkgKiBjYWxsZXIgcGFzc2luZyBub24tTlVMTCBvZl9pZHMgaGVyZSBpcyBv bmx5CmludGVyZXN0ZWQgaW4KLQkJICogd2hldGhlciBvciBub3QgdGhlIHJldHVybiB2YWx1ZSBp cyBOVUxMLgogCQkgKi8KLQkJaWYgKCFzdHJjbXAoQUNQSV9EVF9OQU1FU1BBQ0VfSElELCBod2lk LT5pZCkKLQkJICAgICYmIGFjcGlfb2ZfbWF0Y2hfZGV2aWNlKGRldmljZSwgb2ZfaWRzKSkKLQkJ CXJldHVybiBpZDsKKwkJaWYgKCFzdHJjbXAoQUNQSV9EVF9OQU1FU1BBQ0VfSElELCBod2lkLT5p ZCkpCisJCQlyZXR1cm4gYWNwaV9vZl9tYXRjaF9kZXZpY2UoZGV2aWNlLCBvZl9pZHMsCm9mX2lk KTsKIAl9Ci0JcmV0dXJuIE5VTEw7CisJcmV0dXJuIGZhbHNlOwogfQogCiAvKioKQEAgLTgxNSw3 ICs4MjYsMTAgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZV9pZAoqX19hY3BpX21h dGNoX2RldmljZSgKIGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZV9pZCAqYWNwaV9tYXRjaF9kZXZp Y2UoY29uc3Qgc3RydWN0CmFjcGlfZGV2aWNlX2lkICppZHMsCiAJCQkJCSAgICAgICBjb25zdCBz dHJ1Y3QgZGV2aWNlCipkZXYpCiB7Ci0JcmV0dXJuIF9fYWNwaV9tYXRjaF9kZXZpY2UoYWNwaV9j b21wYW5pb25fbWF0Y2goZGV2KSwgaWRzLApOVUxMKTsKKwljb25zdCBzdHJ1Y3QgYWNwaV9kZXZp Y2VfaWQgKmlkID0gTlVMTDsKKworCV9fYWNwaV9tYXRjaF9kZXZpY2UoYWNwaV9jb21wYW5pb25f bWF0Y2goZGV2KSwgaWRzLCBOVUxMLCAmaWQsCk5VTEwpOworCXJldHVybiBpZDsKIH0KIEVYUE9S VF9TWU1CT0xfR1BMKGFjcGlfbWF0Y2hfZGV2aWNlKTsKIApAQCAtODQwLDcgKzg1NCw3IEBAIEVY UE9SVF9TWU1CT0xfR1BMKGFjcGlfZ2V0X21hdGNoX2RhdGEpOwogaW50IGFjcGlfbWF0Y2hfZGV2 aWNlX2lkcyhzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwKIAkJCSAgY29uc3Qgc3RydWN0IGFj cGlfZGV2aWNlX2lkICppZHMpCiB7Ci0JcmV0dXJuIF9fYWNwaV9tYXRjaF9kZXZpY2UoZGV2aWNl LCBpZHMsIE5VTEwpID8gMCA6IC1FTk9FTlQ7CisJcmV0dXJuIF9fYWNwaV9tYXRjaF9kZXZpY2Uo ZGV2aWNlLCBpZHMsIE5VTEwsIE5VTEwsIE5VTEwpID8gMCA6Ci1FTk9FTlQ7CiB9CiBFWFBPUlRf U1lNQk9MKGFjcGlfbWF0Y2hfZGV2aWNlX2lkcyk7CiAKQEAgLTg0OSwxMCArODYzLDEyIEBAIGJv b2wgYWNwaV9kcml2ZXJfbWF0Y2hfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwKIHsKIAlpZiAo IWRydi0+YWNwaV9tYXRjaF90YWJsZSkKIAkJcmV0dXJuIGFjcGlfb2ZfbWF0Y2hfZGV2aWNlKEFD UElfQ09NUEFOSU9OKGRldiksCi0JCQkJCSAgICBkcnYtPm9mX21hdGNoX3RhYmxlKTsKKwkJCQkJ ICAgIGRydi0+b2ZfbWF0Y2hfdGFibGUsCisJCQkJCSAgICBOVUxMKTsKIAotCXJldHVybiAhIV9f YWNwaV9tYXRjaF9kZXZpY2UoYWNwaV9jb21wYW5pb25fbWF0Y2goZGV2KSwKLQkJCQkgICAgIGRy di0+YWNwaV9tYXRjaF90YWJsZSwgZHJ2LQo+b2ZfbWF0Y2hfdGFibGUpOworCXJldHVybiBfX2Fj cGlfbWF0Y2hfZGV2aWNlKGFjcGlfY29tcGFuaW9uX21hdGNoKGRldiksCisJCQkJICAgZHJ2LT5h Y3BpX21hdGNoX3RhYmxlLCBkcnYtCj5vZl9tYXRjaF90YWJsZSwKKwkJCQkgICBOVUxMLCBOVUxM KTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZHJpdmVyX21hdGNoX2RldmljZSk7CgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9hY3BpL2J1cy5jIGIvZHJpdmVycy9hY3BpL2J1cy5jCmluZGV4IDY3 NmM5Nzg4ZTFjOC4uMzNjNTE2NmU2MDI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYnVzLmMK KysrIGIvZHJpdmVycy9hY3BpL2J1cy5jCkBAIC02NjAsMTMgKzY2MCwxNSBAQCBzdHJ1Y3QgYWNw aV9kZXZpY2UgKmFjcGlfY29tcGFuaW9uX21hdGNoKGNvbnN0CnN0cnVjdCBkZXZpY2UgKmRldikK ICAqIGFjcGlfb2ZfbWF0Y2hfZGV2aWNlIC0gTWF0Y2ggZGV2aWNlIG9iamVjdCB1c2luZyB0aGUg ImNvbXBhdGlibGUiCnByb3BlcnR5LgogICogQGFkZXY6IEFDUEkgZGV2aWNlIG9iamVjdCB0byBt YXRjaC4KICAqIEBvZl9tYXRjaF90YWJsZTogTGlzdCBvZiBkZXZpY2UgSURzIHRvIG1hdGNoIGFn YWluc3QuCisgKiBAb2ZfaWQ6IE9GIElEIGlmIG1hdGNoZWQKICAqCiAgKiBJZiBAZGV2IGhhcyBh biBBQ1BJIGNvbXBhbmlvbiB3aGljaCBoYXMgQUNQSV9EVF9OQU1FU1BBQ0VfSElEIGluIGl0cwps aXN0IG9mCiAgKiBpZGVudGlmaWVycyBhbmQgYSBfRFNEIG9iamVjdCB3aXRoIHRoZSAiY29tcGF0 aWJsZSIgcHJvcGVydHksIHVzZQp0aGF0CiAgKiBwcm9wZXJ0eSB0byBtYXRjaCBhZ2FpbnN0IHRo ZSBnaXZlbiBsaXN0IG9mIGlkZW50aWZpZXJzLgogICovCiBzdGF0aWMgYm9vbCBhY3BpX29mX21h dGNoX2RldmljZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsCi0JCQkJIGNvbnN0IHN0cnVjdCBv Zl9kZXZpY2VfaWQKKm9mX21hdGNoX3RhYmxlKQo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Andy Shevchenko Subject: Re: [PATCH v3 2/5] ACPI / bus: Do not traverse through non-existed device table Date: Thu, 08 Feb 2018 18:53:22 +0200 Message-ID: <1518108802.22495.207.camel@linux.intel.com> References: <20180207145610.88434-1-andriy.shevchenko@linux.intel.com> <20180207145610.88434-2-andriy.shevchenko@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 7bit Return-path: Received: from mga09.intel.com ([134.134.136.24]:21411 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752249AbeBHQx1 (ORCPT ); Thu, 8 Feb 2018 11:53:27 -0500 In-Reply-To: Sender: linux-acpi-owner@vger.kernel.org List-Id: linux-acpi@vger.kernel.org To: "Rafael J. Wysocki" Cc: dmaengine , "Rafael J . Wysocki" , ACPI Devel Maling List , Mika Westerberg , Sinan Kaya , Sakari Ailus , Vinod Koul On Thu, 2018-02-08 at 16:59 +0100, Rafael J. Wysocki wrote: > On Wed, Feb 7, 2018 at 3:56 PM, Andy Shevchenko > wrote: > > > And as far as I'm concerned you can do: > > if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id) > return (const struct acpi_device_id > *)acpi_of_match_device(device, of_ids); > > and update the comment accordingly. Would the following work for you? --- 8< --- 8< --- 8< --- >>From 03013c0c1e487cda4c0d8dc5065ed2f0031095de Mon Sep 17 00:00:00 2001 From: Andy Shevchenko Date: Thu, 1 Feb 2018 21:52:14 +0200 Subject: [PATCH 1/1] ACPI / bus: Do not traverse through non-existed device table When __acpi_match_device() is called it would be possible to have ACPI ID table a MULL pointer. To avoid potential dereference, check for this before traverse. This patch implies a bit of refactoring acpi_of_match_device() to return pointer to OF ID when matched followed by refactoring __acpi_match_device() to return either ACPI or OF ID when matches. While here, remove redundant 'else'. Cc: Sinan Kaya Cc: Sakari Ailus Cc: Vinod Koul Signed-off-by: Andy Shevchenko --- drivers/acpi/bus.c | 66 +++++++++++++++++++++++++++++++++------------ --------- 1 file changed, 41 insertions(+), 25 deletions(-) diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c index 676c9788e1c8..33c5166e6028 100644 --- a/drivers/acpi/bus.c +++ b/drivers/acpi/bus.c @@ -660,13 +660,15 @@ struct acpi_device *acpi_companion_match(const struct device *dev) * acpi_of_match_device - Match device object using the "compatible" property. * @adev: ACPI device object to match. * @of_match_table: List of device IDs to match against. + * @of_id: OF ID if matched * * If @dev has an ACPI companion which has ACPI_DT_NAMESPACE_HID in its list of * identifiers and a _DSD object with the "compatible" property, use that * property to match against the given list of identifiers. */ static bool acpi_of_match_device(struct acpi_device *adev, - const struct of_device_id *of_match_table) + const struct of_device_id *of_match_table, + const struct of_device_id **of_id) { const union acpi_object *of_compatible, *obj; int i, nval; @@ -690,8 +692,11 @@ static bool acpi_of_match_device(struct acpi_device *adev, const struct of_device_id *id; for (id = of_match_table; id->compatible[0]; id++) - if (!strcasecmp(obj->string.pointer, id- >compatible)) + if (!strcasecmp(obj->string.pointer, id- >compatible)) { + if (of_id) + *of_id = id; return true; + } } return false; @@ -762,10 +767,11 @@ static bool __acpi_match_device_cls(const struct acpi_device_id *id, return true; } -static const struct acpi_device_id *__acpi_match_device( - struct acpi_device *device, - const struct acpi_device_id *ids, - const struct of_device_id *of_ids) +static bool __acpi_match_device(struct acpi_device *device, + const struct acpi_device_id *acpi_ids, + const struct of_device_id *of_ids, + const struct acpi_device_id **acpi_id, + const struct of_device_id **of_id) { const struct acpi_device_id *id; struct acpi_hardware_id *hwid; @@ -775,30 +781,35 @@ static const struct acpi_device_id *__acpi_match_device( * driver for it. */ if (!device || !device->status.present) - return NULL; + return false; list_for_each_entry(hwid, &device->pnp.ids, list) { /* First, check the ACPI/PNP IDs provided by the caller. */ - for (id = ids; id->id[0] || id->cls; id++) { - if (id->id[0] && !strcmp((char *) id->id, hwid- >id)) - return id; - else if (id->cls && __acpi_match_device_cls(id, hwid)) - return id; + if (acpi_ids) { + bool found; + + for (id = acpi_ids; id->id[0] || id->cls; id++) { + found = false; + if (id->id[0] && !strcmp((char *)id- >id, hwid->id)) + found = true; + if (id->cls && __acpi_match_device_cls(id, hwid)) + found = true; + if (found) { + if (acpi_id) + *acpi_id = id; + return true; + } + } } /* * Next, check ACPI_DT_NAMESPACE_HID and try to match the * "compatible" property if found. - * - * The id returned by the below is not valid, but the only - * caller passing non-NULL of_ids here is only interested in - * whether or not the return value is NULL. */ - if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id) - && acpi_of_match_device(device, of_ids)) - return id; + if (!strcmp(ACPI_DT_NAMESPACE_HID, hwid->id)) + return acpi_of_match_device(device, of_ids, of_id); } - return NULL; + return false; } /** @@ -815,7 +826,10 @@ static const struct acpi_device_id *__acpi_match_device( const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids, const struct device *dev) { - return __acpi_match_device(acpi_companion_match(dev), ids, NULL); + const struct acpi_device_id *id = NULL; + + __acpi_match_device(acpi_companion_match(dev), ids, NULL, &id, NULL); + return id; } EXPORT_SYMBOL_GPL(acpi_match_device); @@ -840,7 +854,7 @@ EXPORT_SYMBOL_GPL(acpi_get_match_data); int acpi_match_device_ids(struct acpi_device *device, const struct acpi_device_id *ids) { - return __acpi_match_device(device, ids, NULL) ? 0 : -ENOENT; + return __acpi_match_device(device, ids, NULL, NULL, NULL) ? 0 : -ENOENT; } EXPORT_SYMBOL(acpi_match_device_ids); @@ -849,10 +863,12 @@ bool acpi_driver_match_device(struct device *dev, { if (!drv->acpi_match_table) return acpi_of_match_device(ACPI_COMPANION(dev), - drv->of_match_table); + drv->of_match_table, + NULL); - return !!__acpi_match_device(acpi_companion_match(dev), - drv->acpi_match_table, drv- >of_match_table); + return __acpi_match_device(acpi_companion_match(dev), + drv->acpi_match_table, drv- >of_match_table, + NULL, NULL); } EXPORT_SYMBOL_GPL(acpi_driver_match_device); -- 2.15.1 -- Andy Shevchenko Intel Finland Oy