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: [1/2] firmware: add more flexible request_firmware_async function From: Sebastian Reichel Message-Id: <20180622144951.17464-2-sebastian.reichel@collabora.co.uk> Date: Fri, 22 Jun 2018 16:49:50 +0200 To: "Luis R. Rodriguez" , Greg Kroah-Hartman , Dan Williams , Vinod Koul Cc: dmaengine@vger.kernel.org, linux-kernel@vger.kernel.org, =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= , Sebastian Reichel List-ID: RnJvbTogUmFmYcWCIE1pxYJlY2tpIDxyYWZhbEBtaWxlY2tpLnBsPgoKU28gZmFyIHdlIGdvdCBv bmx5IG9uZSBmdW5jdGlvbiBmb3IgbG9hZGluZyBmaXJtd2FyZSBhc3luY2hyb25vdXNseToKcmVx dWVzdF9maXJtd2FyZV9ub3dhaXQuIEl0IGRpZG4ndCBhbGxvdyBtdWNoIGN1c3RvbWl6YXRpb24g b2YgZmlybXdhcmUKbG9hZGluZyBwcm9jZXNzIC0gdGhlcmUgaXMgb25seSBvbmUgYm9vbCB1ZXZl bnQgYXJndW1lbnQuIE1vcmVvdmVyIHRoaXMKYm9vbCBhbHNvIGNvbnRyb2xzIHVzZXIgaGVscGVy IGluIGFuIHVuY2xlYXIgd2F5LgoKU29tZSBkcml2ZXJzIG5lZWQgbW9yZSBmbGV4aWJsZSBoZWxw ZXIgcHJvdmlkaW5nIG1vcmUgb3B0aW9ucy4gVGhpcwppbmNsdWRlcyBjb250cm9sIG92ZXIgdWV2 ZW50IG9yIHdhcm5pbmcgZm9yIHRoZSBtaXNzaW5nIGZpcm13YXJlLiBPZgpjb3Vyc2UgdGhpcyBs aXN0IG1heSBncm93IHVwIGluIHRoZSBmdXR1cmUuCgpUbyBoYW5kbGUgdGhpcyBlYXNpbHkgdGhp cyBwYXRjaCBhZGRzIGEgZ2VuZXJpYyByZXF1ZXN0X2Zpcm13YXJlX2FzeW5jCmZ1bmN0aW9uLiBJ dCB0YWtlcyBzdHJ1Y3Qgd2l0aCBvcHRpb25zIGFzIGFuIGFyZ3VtZW50IHdoaWNoIHdpbGwgYWxs b3cKZXh0ZW5kaW5nIGl0IGluIHRoZSBmdXR1cmUgd2l0aG91dCBtYXNzaXZlIGNoYW5nZXMuCgpU aGlzIGlzIGEgcmVhbGx5IGNoZWFwIGNoYW5nZSAobm8gbmV3IGluZGVwZW5kZW50IEFQSSkgd2hp Y2ggd29ya3MKbmljZWx5IHdpdGggdGhlIGV4aXN0aW5nIGNvZGUuIFRoZSBvbGQgcmVxdWVzdF9m aXJtd2FyZV9ub3dhaXQgaXMga2VwdAphcyBhIHNpbXBsZSBoZWxwZXIgY2FsbGluZyBuZXcgaGVs cGVyLgoKU2lnbmVkLW9mZi1ieTogUmFmYcWCIE1pxYJlY2tpIDxyYWZhbEBtaWxlY2tpLnBsPgpb cmViYXNlZCB0byB2NC4xOC1yYzFdClNpZ25lZC1vZmYtYnk6IFNlYmFzdGlhbiBSZWljaGVsIDxz ZWJhc3RpYW4ucmVpY2hlbEBjb2xsYWJvcmEuY28udWs+Ci0tLQogZHJpdmVycy9iYXNlL2Zpcm13 YXJlX2xvYWRlci9tYWluLmMgfCA0MSArKysrKysrKysrKysrKysrKysrKysrKystLS0tLQogaW5j bHVkZS9saW51eC9maXJtd2FyZS5oICAgICAgICAgICAgfCAyMCArKysrKysrKysrKysrKwogMiBm aWxlcyBjaGFuZ2VkLCA1NCBpbnNlcnRpb25zKCspLCA3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvYmFzZS9maXJtd2FyZV9sb2FkZXIvbWFpbi5jIGIvZHJpdmVycy9iYXNlL2Zp cm13YXJlX2xvYWRlci9tYWluLmMKaW5kZXggMDk0M2U3MDY1ZTBlLi5lMWQyYmE1NzBlYTMgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvYmFzZS9maXJtd2FyZV9sb2FkZXIvbWFpbi5jCisrKyBiL2RyaXZl cnMvYmFzZS9maXJtd2FyZV9sb2FkZXIvbWFpbi5jCkBAIC03NzQsNyArNzc0LDcgQEAgc3RhdGlj IHZvaWQgcmVxdWVzdF9maXJtd2FyZV93b3JrX2Z1bmMoc3RydWN0IHdvcmtfc3RydWN0ICp3b3Jr KQogCV9yZXF1ZXN0X2Zpcm13YXJlKCZmdywgZndfd29yay0+bmFtZSwgZndfd29yay0+ZGV2aWNl LCBOVUxMLCAwLAogCQkJICBmd193b3JrLT5vcHRfZmxhZ3MpOwogCWZ3X3dvcmstPmNvbnQoZncs IGZ3X3dvcmstPmNvbnRleHQpOwotCXB1dF9kZXZpY2UoZndfd29yay0+ZGV2aWNlKTsgLyogdGFr ZW4gaW4gcmVxdWVzdF9maXJtd2FyZV9ub3dhaXQoKSAqLworCXB1dF9kZXZpY2UoZndfd29yay0+ ZGV2aWNlKTsgLyogdGFrZW4gaW4gX19yZXF1ZXN0X2Zpcm13YXJlX25vd2FpdCgpICovCiAKIAlt b2R1bGVfcHV0KGZ3X3dvcmstPm1vZHVsZSk7CiAJa2ZyZWVfY29uc3QoZndfd29yay0+bmFtZSk7 CkBAIC03ODIsOCArNzgyLDkgQEAgc3RhdGljIHZvaWQgcmVxdWVzdF9maXJtd2FyZV93b3JrX2Z1 bmMoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogfQogCiAvKioKLSAqIHJlcXVlc3RfZmlybXdh cmVfbm93YWl0KCkgLSBhc3luY2hyb25vdXMgdmVyc2lvbiBvZiByZXF1ZXN0X2Zpcm13YXJlCisg KiBfX3JlcXVlc3RfZmlybXdhcmVfbm93YWl0KCkgLSBhc3luY2hyb25vdXMgdmVyc2lvbiBvZiBy ZXF1ZXN0X2Zpcm13YXJlCiAgKiBAbW9kdWxlOiBtb2R1bGUgcmVxdWVzdGluZyB0aGUgZmlybXdh cmUKKyAqIEBvcHRfZmxhZ3M6IGZsYWdzIHRoYXQgY29udHJvbCBmaXJtd2FyZSBsb2FkaW5nIHBy b2Nlc3MsIHNlZSBGV19PUFRfKgogICogQHVldmVudDogc2VuZHMgdWV2ZW50IHRvIGNvcHkgdGhl IGZpcm13YXJlIGltYWdlIGlmIHRoaXMgZmxhZwogICoJaXMgbm9uLXplcm8gZWxzZSB0aGUgZmly bXdhcmUgY29weSBtdXN0IGJlIGRvbmUgbWFudWFsbHkuCiAgKiBAbmFtZTogbmFtZSBvZiBmaXJt d2FyZSBmaWxlCkBAIC04MDQsMTMgKzgwNSwxNCBAQCBzdGF0aWMgdm9pZCByZXF1ZXN0X2Zpcm13 YXJlX3dvcmtfZnVuYyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAgKgogICoJCS0gY2FuJ3Qg c2xlZXAgYXQgYWxsIGlmIEBnZnAgaXMgR0ZQX0FUT01JQy4KICAqKi8KLWludAotcmVxdWVzdF9m aXJtd2FyZV9ub3dhaXQoCi0Jc3RydWN0IG1vZHVsZSAqbW9kdWxlLCBib29sIHVldmVudCwKK3N0 YXRpYyBpbnQKK19fcmVxdWVzdF9maXJtd2FyZV9ub3dhaXQoCisJc3RydWN0IG1vZHVsZSAqbW9k dWxlLCB1bnNpZ25lZCBpbnQgb3B0X2ZsYWdzLAogCWNvbnN0IGNoYXIgKm5hbWUsIHN0cnVjdCBk ZXZpY2UgKmRldmljZSwgZ2ZwX3QgZ2ZwLCB2b2lkICpjb250ZXh0LAogCXZvaWQgKCpjb250KShj b25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3LCB2b2lkICpjb250ZXh0KSkKIHsKIAlzdHJ1Y3QgZmly bXdhcmVfd29yayAqZndfd29yazsKKwlib29sIHVldmVudCA9ICEhKG9wdF9mbGFncyAmIEZXX09Q VF9VRVZFTlQpOwogCiAJZndfd29yayA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBmaXJtd2FyZV93 b3JrKSwgZ2ZwKTsKIAlpZiAoIWZ3X3dvcmspCkBAIC04MjUsOCArODI3LDcgQEAgcmVxdWVzdF9m aXJtd2FyZV9ub3dhaXQoCiAJZndfd29yay0+ZGV2aWNlID0gZGV2aWNlOwogCWZ3X3dvcmstPmNv bnRleHQgPSBjb250ZXh0OwogCWZ3X3dvcmstPmNvbnQgPSBjb250OwotCWZ3X3dvcmstPm9wdF9m bGFncyA9IEZXX09QVF9OT1dBSVQgfAotCQkodWV2ZW50ID8gRldfT1BUX1VFVkVOVCA6IEZXX09Q VF9VU0VSSEVMUEVSKTsKKwlmd193b3JrLT5vcHRfZmxhZ3MgPSBGV19PUFRfTk9XQUlUIHwgb3B0 X2ZsYWdzOwogCiAJaWYgKCF1ZXZlbnQgJiYgZndfY2FjaGVfaXNfc2V0dXAoZGV2aWNlLCBuYW1l KSkgewogCQlrZnJlZV9jb25zdChmd193b3JrLT5uYW1lKTsKQEAgLTg0NSw4ICs4NDYsMzQgQEAg cmVxdWVzdF9maXJtd2FyZV9ub3dhaXQoCiAJc2NoZWR1bGVfd29yaygmZndfd29yay0+d29yayk7 CiAJcmV0dXJuIDA7CiB9CisKK2ludCByZXF1ZXN0X2Zpcm13YXJlX25vd2FpdChzdHJ1Y3QgbW9k dWxlICptb2R1bGUsIGJvb2wgdWV2ZW50LAorCQkJICAgIGNvbnN0IGNoYXIgKm5hbWUsIHN0cnVj dCBkZXZpY2UgKmRldmljZSwgZ2ZwX3QgZ2ZwLAorCQkJICAgIHZvaWQgKmNvbnRleHQsCisJCQkg ICAgdm9pZCAoKmNvbnQpKGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncsIHZvaWQgKmNvbnRleHQp KQoreworCXVuc2lnbmVkIGludCBvcHRfZmxhZ3MgPSAodWV2ZW50ID8gRldfT1BUX1VFVkVOVCA6 IEZXX09QVF9VU0VSSEVMUEVSKTsKKworCXJldHVybiBfX3JlcXVlc3RfZmlybXdhcmVfbm93YWl0 KG1vZHVsZSwgb3B0X2ZsYWdzLCBuYW1lLCBkZXZpY2UsIGdmcCwKKwkJCQkJIGNvbnRleHQsIGNv bnQpOworfQogRVhQT1JUX1NZTUJPTChyZXF1ZXN0X2Zpcm13YXJlX25vd2FpdCk7CiAKK2ludCBf X3JlcXVlc3RfZmlybXdhcmVfYXN5bmMoc3RydWN0IG1vZHVsZSAqbW9kdWxlLCBjb25zdCBjaGFy ICpuYW1lLAorCQkJICAgICBzdHJ1Y3QgZmlybXdhcmVfb3B0cyAqZndfb3B0cywgc3RydWN0IGRl dmljZSAqZGV2LAorCQkJICAgICB2b2lkICpjb250ZXh0LAorCQkJICAgICB2b2lkICgqY29udCko Y29uc3Qgc3RydWN0IGZpcm13YXJlICpmdywgdm9pZCAqY29udGV4dCkpCit7CisJdW5zaWduZWQg aW50IG9wdF9mbGFncyA9IEZXX09QVF9VRVZFTlQ7CisKKwlpZiAoZndfb3B0cy0+b3B0aW9uYWwp CisJCW9wdF9mbGFncyB8PSBGV19PUFRfTk9fV0FSTjsKKworCXJldHVybiBfX3JlcXVlc3RfZmly bXdhcmVfbm93YWl0KG1vZHVsZSwgb3B0X2ZsYWdzLCBuYW1lLCBkZXYsCisJCQkJCSBHRlBfS0VS TkVMLCBjb250ZXh0LCBjb250KTsKK30KK0VYUE9SVF9TWU1CT0woX19yZXF1ZXN0X2Zpcm13YXJl X2FzeW5jKTsKKwogI2lmZGVmIENPTkZJR19QTV9TTEVFUAogc3RhdGljIEFTWU5DX0RPTUFJTl9F WENMVVNJVkUoZndfY2FjaGVfZG9tYWluKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9m aXJtd2FyZS5oIGIvaW5jbHVkZS9saW51eC9maXJtd2FyZS5oCmluZGV4IDJkZDU2NmM5MWQ0NC4u YWQyZmM2ZTdmZWU3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Zpcm13YXJlLmgKKysrIGIv aW5jbHVkZS9saW51eC9maXJtd2FyZS5oCkBAIC0yNyw2ICsyNywxMCBAQCBzdHJ1Y3QgYnVpbHRp bl9mdyB7CiAJdW5zaWduZWQgbG9uZyBzaXplOwogfTsKIAorc3RydWN0IGZpcm13YXJlX29wdHMg eworCWJvb2wgb3B0aW9uYWw7Cit9OworCiAvKiBXZSBoYXZlIHRvIHBsYXkgdHJpY2tzIGhlcmUg bXVjaCBsaWtlIHN0cmluZ2lmeSgpIHRvIGdldCB0aGUKICAgIF9fQ09VTlRFUl9fIG1hY3JvIHRv IGJlIGV4cGFuZGVkIGFzIHdlIHdhbnQgaXQgKi8KICNkZWZpbmUgX19md19jb25jYXQxKHgsIHkp IHgjI3kKQEAgLTUyLDYgKzU2LDEwIEBAIGludCByZXF1ZXN0X2Zpcm13YXJlX2RpcmVjdChjb25z dCBzdHJ1Y3QgZmlybXdhcmUgKipmdywgY29uc3QgY2hhciAqbmFtZSwKIAkJCSAgICBzdHJ1Y3Qg ZGV2aWNlICpkZXZpY2UpOwogaW50IHJlcXVlc3RfZmlybXdhcmVfaW50b19idWYoY29uc3Qgc3Ry dWN0IGZpcm13YXJlICoqZmlybXdhcmVfcCwKIAljb25zdCBjaGFyICpuYW1lLCBzdHJ1Y3QgZGV2 aWNlICpkZXZpY2UsIHZvaWQgKmJ1Ziwgc2l6ZV90IHNpemUpOworaW50IF9fcmVxdWVzdF9maXJt d2FyZV9hc3luYyhzdHJ1Y3QgbW9kdWxlICptb2R1bGUsIGNvbnN0IGNoYXIgKm5hbWUsCisJCQkg ICAgIHN0cnVjdCBmaXJtd2FyZV9vcHRzICpmd19vcHRzLCBzdHJ1Y3QgZGV2aWNlICpkZXYsCisJ CQkgICAgIHZvaWQgKmNvbnRleHQsCisJCQkgICAgIHZvaWQgKCpjb250KShjb25zdCBzdHJ1Y3Qg ZmlybXdhcmUgKmZ3LCB2b2lkICpjb250ZXh0KSk7CiAKIHZvaWQgcmVsZWFzZV9maXJtd2FyZShj b25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3KTsKICNlbHNlCkBAIC05NCw4ICsxMDIsMjAgQEAgc3Rh dGljIGlubGluZSBpbnQgcmVxdWVzdF9maXJtd2FyZV9pbnRvX2J1Zihjb25zdCBzdHJ1Y3QgZmly bXdhcmUgKipmaXJtd2FyZV9wLAogCXJldHVybiAtRUlOVkFMOwogfQogCitpbnQgX19yZXF1ZXN0 X2Zpcm13YXJlX2FzeW5jKHN0cnVjdCBtb2R1bGUgKm1vZHVsZSwgY29uc3QgY2hhciAqbmFtZSwK KwkJCSAgICAgc3RydWN0IGZpcm13YXJlX29wdHMgKmZ3X29wdHMsIHN0cnVjdCBkZXZpY2UgKmRl diwKKwkJCSAgICAgdm9pZCAqY29udGV4dCwKKwkJCSAgICAgdm9pZCAoKmNvbnQpKGNvbnN0IHN0 cnVjdCBmaXJtd2FyZSAqZncsIHZvaWQgKmNvbnRleHQpKQoreworCXJldHVybiAtRUlOVkFMOwor fQorCiAjZW5kaWYKIAogaW50IGZpcm13YXJlX3JlcXVlc3RfY2FjaGUoc3RydWN0IGRldmljZSAq ZGV2aWNlLCBjb25zdCBjaGFyICpuYW1lKTsKIAorI2RlZmluZSByZXF1ZXN0X2Zpcm13YXJlX2Fz eW5jKG5hbWUsIGZ3X29wdHMsIGRldiwgY29udGV4dCwgY29udCkJXAorCV9fcmVxdWVzdF9maXJt d2FyZV9hc3luYyhUSElTX01PRFVMRSwgbmFtZSwgZndfb3B0cywgZGV2LAlcCisJCQkJIGNvbnRl eHQsIGNvbnQpCisKICNlbmRpZgo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_PASS,UNPARSEABLE_RELAY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 159DFC43142 for ; Fri, 22 Jun 2018 14:50:07 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id CA14C243FB for ; Fri, 22 Jun 2018 14:50:06 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CA14C243FB Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=collabora.co.uk Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933678AbeFVOuD (ORCPT ); Fri, 22 Jun 2018 10:50:03 -0400 Received: from bhuna.collabora.co.uk ([46.235.227.227]:54326 "EHLO bhuna.collabora.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932264AbeFVOuA (ORCPT ); Fri, 22 Jun 2018 10:50:00 -0400 Received: from [127.0.0.1] (localhost [127.0.0.1]) (Authenticated sender: sre) with ESMTPSA id D8D09288FB4 From: Sebastian Reichel To: "Luis R. Rodriguez" , Greg Kroah-Hartman , Dan Williams , Vinod Koul Cc: dmaengine@vger.kernel.org, linux-kernel@vger.kernel.org, =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= , Sebastian Reichel Subject: [PATCH 1/2] firmware: add more flexible request_firmware_async function Date: Fri, 22 Jun 2018 16:49:50 +0200 Message-Id: <20180622144951.17464-2-sebastian.reichel@collabora.co.uk> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180622144951.17464-1-sebastian.reichel@collabora.co.uk> References: <20180622144951.17464-1-sebastian.reichel@collabora.co.uk> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Rafał Miłecki So far we got only one function for loading firmware asynchronously: request_firmware_nowait. It didn't allow much customization of firmware loading process - there is only one bool uevent argument. Moreover this bool also controls user helper in an unclear way. Some drivers need more flexible helper providing more options. This includes control over uevent or warning for the missing firmware. Of course this list may grow up in the future. To handle this easily this patch adds a generic request_firmware_async function. It takes struct with options as an argument which will allow extending it in the future without massive changes. This is a really cheap change (no new independent API) which works nicely with the existing code. The old request_firmware_nowait is kept as a simple helper calling new helper. Signed-off-by: Rafał Miłecki [rebased to v4.18-rc1] Signed-off-by: Sebastian Reichel --- drivers/base/firmware_loader/main.c | 41 ++++++++++++++++++++++++----- include/linux/firmware.h | 20 ++++++++++++++ 2 files changed, 54 insertions(+), 7 deletions(-) diff --git a/drivers/base/firmware_loader/main.c b/drivers/base/firmware_loader/main.c index 0943e7065e0e..e1d2ba570ea3 100644 --- a/drivers/base/firmware_loader/main.c +++ b/drivers/base/firmware_loader/main.c @@ -774,7 +774,7 @@ static void request_firmware_work_func(struct work_struct *work) _request_firmware(&fw, fw_work->name, fw_work->device, NULL, 0, fw_work->opt_flags); fw_work->cont(fw, fw_work->context); - put_device(fw_work->device); /* taken in request_firmware_nowait() */ + put_device(fw_work->device); /* taken in __request_firmware_nowait() */ module_put(fw_work->module); kfree_const(fw_work->name); @@ -782,8 +782,9 @@ static void request_firmware_work_func(struct work_struct *work) } /** - * request_firmware_nowait() - asynchronous version of request_firmware + * __request_firmware_nowait() - asynchronous version of request_firmware * @module: module requesting the firmware + * @opt_flags: flags that control firmware loading process, see FW_OPT_* * @uevent: sends uevent to copy the firmware image if this flag * is non-zero else the firmware copy must be done manually. * @name: name of firmware file @@ -804,13 +805,14 @@ static void request_firmware_work_func(struct work_struct *work) * * - can't sleep at all if @gfp is GFP_ATOMIC. **/ -int -request_firmware_nowait( - struct module *module, bool uevent, +static int +__request_firmware_nowait( + struct module *module, unsigned int opt_flags, const char *name, struct device *device, gfp_t gfp, void *context, void (*cont)(const struct firmware *fw, void *context)) { struct firmware_work *fw_work; + bool uevent = !!(opt_flags & FW_OPT_UEVENT); fw_work = kzalloc(sizeof(struct firmware_work), gfp); if (!fw_work) @@ -825,8 +827,7 @@ request_firmware_nowait( fw_work->device = device; fw_work->context = context; fw_work->cont = cont; - fw_work->opt_flags = FW_OPT_NOWAIT | - (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER); + fw_work->opt_flags = FW_OPT_NOWAIT | opt_flags; if (!uevent && fw_cache_is_setup(device, name)) { kfree_const(fw_work->name); @@ -845,8 +846,34 @@ request_firmware_nowait( schedule_work(&fw_work->work); return 0; } + +int request_firmware_nowait(struct module *module, bool uevent, + const char *name, struct device *device, gfp_t gfp, + void *context, + void (*cont)(const struct firmware *fw, void *context)) +{ + unsigned int opt_flags = (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER); + + return __request_firmware_nowait(module, opt_flags, name, device, gfp, + context, cont); +} EXPORT_SYMBOL(request_firmware_nowait); +int __request_firmware_async(struct module *module, const char *name, + struct firmware_opts *fw_opts, struct device *dev, + void *context, + void (*cont)(const struct firmware *fw, void *context)) +{ + unsigned int opt_flags = FW_OPT_UEVENT; + + if (fw_opts->optional) + opt_flags |= FW_OPT_NO_WARN; + + return __request_firmware_nowait(module, opt_flags, name, dev, + GFP_KERNEL, context, cont); +} +EXPORT_SYMBOL(__request_firmware_async); + #ifdef CONFIG_PM_SLEEP static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain); diff --git a/include/linux/firmware.h b/include/linux/firmware.h index 2dd566c91d44..ad2fc6e7fee7 100644 --- a/include/linux/firmware.h +++ b/include/linux/firmware.h @@ -27,6 +27,10 @@ struct builtin_fw { unsigned long size; }; +struct firmware_opts { + bool optional; +}; + /* We have to play tricks here much like stringify() to get the __COUNTER__ macro to be expanded as we want it */ #define __fw_concat1(x, y) x##y @@ -52,6 +56,10 @@ int request_firmware_direct(const struct firmware **fw, const char *name, struct device *device); int request_firmware_into_buf(const struct firmware **firmware_p, const char *name, struct device *device, void *buf, size_t size); +int __request_firmware_async(struct module *module, const char *name, + struct firmware_opts *fw_opts, struct device *dev, + void *context, + void (*cont)(const struct firmware *fw, void *context)); void release_firmware(const struct firmware *fw); #else @@ -94,8 +102,20 @@ static inline int request_firmware_into_buf(const struct firmware **firmware_p, return -EINVAL; } +int __request_firmware_async(struct module *module, const char *name, + struct firmware_opts *fw_opts, struct device *dev, + void *context, + void (*cont)(const struct firmware *fw, void *context)) +{ + return -EINVAL; +} + #endif int firmware_request_cache(struct device *device, const char *name); +#define request_firmware_async(name, fw_opts, dev, context, cont) \ + __request_firmware_async(THIS_MODULE, name, fw_opts, dev, \ + context, cont) + #endif -- 2.17.1