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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id BEE95C44508 for ; Wed, 15 Jul 2026 20:21:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=sUtCzd9cXcIrsEonXDKcXqm6UWM2DCZVNgJS/SXW3F8=; b=n7J960Ds8IKJEn hrIkQ/F/RiGH/YtrArJPSC7+76rtgfOUqoZ4k0efpFUbgxRW/ZAE6Uy/+XmJL6HxrutT1ysIxj6Dw KwBXvzohdUbOEcIJOH87m9+FEuQqo8HjP9jCBWgYy5FR23QoRhLusZgZdPOiirm0oEmW8waWygrl9 dkJJKrpPN0jHOymP2OsyyDXNotUHCIkmrJGaeOAlhAz7+0Fb3bohdaU8pxrRtWOl4ZXyopWvvfD2H G5EdWNsBvB6DHfhwb+4ra+BNusMNyFy9PutEbSuWgjE6Feu1Uo5h3A1RsDKsBaF4YbLjN/mk2mT15 6ZVDn7EDZzc1FnwBlxMA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wk66K-0000000Fs9P-3LX9; Wed, 15 Jul 2026 20:21:04 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wk66J-0000000Fs95-2HPT for linux-amlogic@lists.infradead.org; Wed, 15 Jul 2026 20:21:03 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id EBB77404AD; Wed, 15 Jul 2026 20:21:02 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9E1CD1F000E9; Wed, 15 Jul 2026 20:21:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784146862; bh=Vt4Ij9BkEDrjHpf2FuVRD/sTwfgT130h+QRo36efLug=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=ZlQaZeJy3R+LrHLWfKEe/sl7UWw6D8TM3Dylhl1pFU60rzt9e4QOoFq5yMwLI7NCj 1dJRim6zGSDcZLglf8qZjh/DXqQfMHvuCQCc8+WjSydAs3sGWOL/xWs2Xy34/Ubg6+ +mlUeHTQQE4csbbTI9n1IU2tuTG9zgSlEOn/9l37zt+9916G/qrBfPjg74jizYIm9G iDimc7SZ+b0Rl5jTxI45eOub6aLfelhmc04oeGOYptKDhbN93Q7ZfDmaTjzt29hyVH hUZQjVkapD0U/5UGIP6boX/tVfBBIGMdndrNhiJtxTmlicWnfg6mUyccGKo+Mvlj9T D04skVEYs60mQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 2/2] nvmem: make all reg_write callbacks take const void * To: "Link Mauve" Cc: neil.armstrong@linaro.org, Frank.Li@kernel.org, ojeda@kernel.org, linux-amlogic@lists.infradead.org, imx@lists.linux.dev In-Reply-To: <20260715195520.25410-3-linkmauve@linkmauve.fr> References: <20260715195520.25410-1-linkmauve@linkmauve.fr> <20260715195520.25410-3-linkmauve@linkmauve.fr> Date: Wed, 15 Jul 2026 20:21:01 +0000 Message-Id: <20260715202101.9E1CD1F000E9@smtp.kernel.org> X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg MTAgcG90ZW50aWFsIGlzc3VlKHMpIHRvIGNvbnNpZGVyOgoKTmV3IGlzc3VlczoKLSBbQ3JpdGlj YWxdIFRoZSBudm1lbSBjb3JlIGluY29ycmVjdGx5IGV2YWx1YXRlcyB3cml0ZSBwZXJtaXNzaW9u cywgY2F1c2luZyBhbGwgZHJpdmVycyBwcm92aWRpbmcgb25seSBgLnJlZ193cml0ZV9jb25zdGAg dG8gYmUgdW5jb25kaXRpb25hbGx5IHRyZWF0ZWQgYXMgcmVhZC1vbmx5LgoKUHJlLWV4aXN0aW5n IGlzc3VlczoKLSBbQ3JpdGljYWxdIFRoZSBTcHJlYWR0cnVtIGVGdXNlIGRyaXZlciBpbmNvcnJl Y3RseSBjYWxjdWxhdGVzIG1lbW9yeSBvZmZzZXRzIGFuZCBzaXplIGNvbnN0cmFpbnRzLCBsZWFk aW5nIHRvIG91dC1vZi1ib3VuZHMgTU1JTyB3cml0ZXMsIG1lbW9yeSBjb3JydXB0aW9uLCBhbmQg a2VybmVsIHN0YWNrIGluZm9ybWF0aW9uIGxlYWtzLgotIFtIaWdoXSBUaGUgYmNtLW9jb3RwIGRy aXZlciBmYWlscyB0byBkaXNhYmxlIHByb2dyYW1taW5nIG1vZGUgb24gdGhlIGVycm9yIHBhdGgu Ci0gW0hpZ2hdIFRoZSBzdG0zMi1ic2VjLW9wdGVlLXRhIGRyaXZlciBsZWFrcyBURUUgc2Vzc2lv bnMgd2hlbiB1bmFsaWduZWQgd3JpdGVzIGFyZSByZXF1ZXN0ZWQuCi0gW0hpZ2hdIFRoZSBpbXgt b2NvdHAtc2N1IGRyaXZlciBoYXMgYSBUaW1lLW9mLUNoZWNrIHRvIFRpbWUtb2YtVXNlIChUT0NU T1UpIHJhY2UgY29uZGl0aW9uIHdoZW4gd3JpdGluZyB0byBFQ0MgcmVnaW9ucy4KLSBbSGlnaF0g VGhlIG1lc29uLXNtIGZpcm13YXJlIGRyaXZlciBleHBvc2VzIGEgbG9ja2xlc3Mgc2hhcmVkIG1l bW9yeSByYWNlIHdoZW4gaW50ZXJhY3Rpbmcgd2l0aCBtZXNvbi1lZnVzZS4KLSBbSGlnaF0gVGhl IGxwYzE4eHgtZWVwcm9tIGRyaXZlciBsYWNrcyBzZXJpYWxpemF0aW9uLCBjYXVzaW5nIGEgcmFj ZSBjb25kaXRpb24gb24gdGhlIEVFUFJPTSBwb3dlciBzdGF0ZSB0aGF0IGNhbiBjcmFzaCB0aGUg c3lzdGVtLgotIFtIaWdoXSBUaGUgcWZwcm9tIGRyaXZlciBtb2RpZmllcyBnbG9iYWwgY2xvY2sg cmF0ZXMgYW5kIHJlZ3VsYXRvciB2b2x0YWdlcyB3aXRob3V0IHNlcmlhbGl6YXRpb24uCi0gW0hp Z2hdIFRoZSBsYW45NjYyLW90cGMgZHJpdmVyIG1vZGlmaWVzIGhhcmR3YXJlIHN0YXRlIGFuZCBy ZWdpc3RlcnMgd2l0aG91dCBsb2NraW5nLCBsZWFkaW5nIHRvIHJhY2UgY29uZGl0aW9ucyBhbmQg ZnVzZSBjb3JydXB0aW9uLgotIFtIaWdoXSBUaGUgYmNtLW9jb3RwIGRyaXZlciBtb2RpZmllcyBj b21tYW5kIGFuZCBhZGRyZXNzIHJlZ2lzdGVycyB3aXRob3V0IGxvY2tpbmcsIGxlYWRpbmcgdG8g T1RQIGZ1c2UgY29ycnVwdGlvbi4KLS0KCi0tLSBQYXRjaCBbMl06IFtQQVRDSCB2MiAyLzJdIG52 bWVtOiBtYWtlIGFsbCByZWdfd3JpdGUgY2FsbGJhY2tzIHRha2UgY29uc3Qgdm9pZCAqIC0tLQpj b21taXQgNzU3YjJmMzhhYjEwZTdlNTQxNWZiZDUyNzc5ZmExMmY5MDFjM2FjNApBdXRob3I6IExp bmsgTWF1dmUgPGxpbmttYXV2ZUBsaW5rbWF1dmUuZnI+ClN1YmplY3Q6IG52bWVtOiBtYWtlIGFs bCByZWdfd3JpdGUgY2FsbGJhY2tzIHRha2UgY29uc3Qgdm9pZCAqCgpUaGUgcHJldmlvdXMgY29t bWl0IHN3aXRjaGVkIGZyb20gYSBwb2ludGVyIHRvIG11dGFibGUgZGF0YSB0byBhIHBvaW50ZXIK dG8gaW1tdXRhYmxlIGRhdGEsIHNvIGxldOKAmXMgZml4IGFsbCB1c2VycyBvZiB0aGlzIEFQSS4K Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZtZW0vYXBwbGUtc3BtaS1udm1lbS5jIGIvZHJpdmVy cy9udm1lbS9hcHBsZS1zcG1pLW52bWVtLmMKPiAtLS0gYS9kcml2ZXJzL252bWVtL2FwcGxlLXNw bWktbnZtZW0uYwo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vYXBwbGUtc3BtaS1udm1lbS5jCj4gQEAg LTI5LDcgKzI5LDcgQEAgc3RhdGljIGludCBhcHBsZV9zcG1pX252bWVtX3Byb2JlKHN0cnVjdCBz cG1pX2RldmljZSAqc2RldikKPiAgCQkuc3RyaWRlID0gMSwKPiAgCQkuc2l6ZSA9IDB4ZmZmZiwK PiAgCQkucmVnX3JlYWQgPSAodm9pZCAqKXJlZ21hcF9idWxrX3JlYWQsCj4gLQkJLnJlZ193cml0 ZSA9ICh2b2lkICopcmVnbWFwX2J1bGtfd3JpdGUsCj4gKwkJLnJlZ193cml0ZV9jb25zdCA9ICh2 b2lkICopcmVnbWFwX2J1bGtfd3JpdGUsCgpbU2V2ZXJpdHk6IENyaXRpY2FsXQpCeSBtaWdyYXRp bmcgdG8gLnJlZ193cml0ZV9jb25zdCBhbmQgbGVhdmluZyAucmVnX3dyaXRlIGFzIE5VTEwsIGRv ZXMgdGhpcwppbmFkdmVydGVudGx5IG1ha2UgYWxsIHRoZXNlIGRldmljZXMgcmVhZC1vbmx5PwoK TG9va2luZyBhdCB0aGUgbnZtZW0gY29yZSBpbiBkcml2ZXJzL252bWVtL2NvcmUuYzoKCm52bWVt X3JlZ2lzdGVyKCkgewogICAgLi4uCiAgICBudm1lbS0+cmVhZF9vbmx5ID0gZGV2aWNlX3Byb3Bl cnR5X3ByZXNlbnQoY29uZmlnLT5kZXYsICJyZWFkLW9ubHkiKSB8fAogICAgICAgICAgICAgICAg ICAgICAgIGNvbmZpZy0+cmVhZF9vbmx5IHx8ICFudm1lbS0+cmVnX3dyaXRlIHx8CiAgICAgICAg ICAgICAgICAgICAgICAgIW52bWVtLT5yZWdfd3JpdGVfY29uc3Q7CiAgICAuLi4KfQoKYmluX2F0 dHJfbnZtZW1fd3JpdGUoKSB7CiAgICAuLi4KICAgIGlmICghbnZtZW0tPnJlZ193cml0ZSB8fCAh bnZtZW0tPnJlZ193cml0ZV9jb25zdCB8fCBudm1lbS0+cmVhZF9vbmx5KQogICAgICAgIHJldHVy biAtRVBFUk07CiAgICAuLi4KfQoKQmVjYXVzZSB0aGUgY29yZSBjaGVja3MgIW52bWVtLT5yZWdf d3JpdGUgfHwgIW52bWVtLT5yZWdfd3JpdGVfY29uc3QsCnNldHRpbmcgcmVnX3dyaXRlIHRvIE5V TEwgY2F1c2VzIHRoZSBjb3JlIHRvIHN0cmlwIHdyaXRlIHBlcm1pc3Npb25zIGFuZApyZXR1cm4g LUVQRVJNIGZvciBhbGwgc3lzZnMgd3JpdGVzLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l bS9iY20tb2NvdHAuYyBiL2RyaXZlcnMvbnZtZW0vYmNtLW9jb3RwLmMKPiAtLS0gYS9kcml2ZXJz L252bWVtL2JjbS1vY290cC5jCj4gKysrIGIvZHJpdmVycy9udm1lbS9iY20tb2NvdHAuYwo+IFsg Li4uIF0KPiBAQCAtMTc5LDExICsxNzksMTEgQEAgc3RhdGljIGludCBiY21fb3RwY19yZWFkKHZv aWQgKmNvbnRleHQsIHVuc2lnbmVkIGludCBvZmZzZXQsIHZvaWQgKnZhbCwKPiAgCXJldHVybiAw Owo+ICB9Cj4gIAo+IC1zdGF0aWMgaW50IGJjbV9vdHBjX3dyaXRlKHZvaWQgKmNvbnRleHQsIHVu c2lnbmVkIGludCBvZmZzZXQsIHZvaWQgKnZhbCwKPiArc3RhdGljIGludCBiY21fb3RwY193cml0 ZSh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LCBjb25zdCB2b2lkICp2YWwsCj4g IAlzaXplX3QgYnl0ZXMpCj4gIHsKPiAgCXN0cnVjdCBvdHBjX3ByaXYgKnByaXYgPSBjb250ZXh0 Owo+IC0JdTMyICpidWYgPSB2YWw7Cj4gKwljb25zdCB1MzIgKmJ1ZiA9IHZhbDsKCltTZXZlcml0 eTogSGlnaF0KVGhpcyBpc24ndCBhIGJ1ZyBpbnRyb2R1Y2VkIGJ5IHRoaXMgcGF0Y2gsIGJ1dCBp cyBpdCBwb3NzaWJsZSBmb3IgY29uY3VycmVudApyZWFkcyBhbmQgd3JpdGVzIHRvIGNvcnJ1cHQg aGFyZHdhcmUgc3RhdGU/CgpJbiBiY21fb3RwY193cml0ZSgpOgogICAgZm9yIChieXRlc193cml0 dGVuID0gMDsgYnl0ZXNfd3JpdHRlbiA8IGJ5dGVzOykgewogICAgICAgIHNldF9jb21tYW5kKHBy aXYtPmJhc2UsIE9UUENfQ01EX1BST0dSQU0pOwogICAgICAgIHNldF9jcHVfYWRkcmVzcyhwcml2 LT5iYXNlLCBhZGRyZXNzKyspOwoKQW5kIHNpbWlsYXJseSBpbiBiY21fb3RwY19yZWFkKCk6CiAg ICBmb3IgKGJ5dGVzX3JlYWQgPSAwOyBieXRlc19yZWFkIDwgYnl0ZXM7KSB7CiAgICAgICAgc2V0 X2NvbW1hbmQocHJpdi0+YmFzZSwgT1RQQ19DTURfUkVBRCk7CiAgICAgICAgc2V0X2NwdV9hZGRy ZXNzKHByaXYtPmJhc2UsIGFkZHJlc3MrKyk7CgpXaXRob3V0IHNlcmlhbGl6YXRpb24sIGNvbmN1 cnJlbnQgc3lzZnMgb3BlcmF0aW9ucyBjb3VsZCBjYXVzZSB0aGUgY29tbWFuZCBhbmQKYWRkcmVz cyByZWdpc3RlcnMgdG8gYmUgb3ZlcndyaXR0ZW4gbWlkLW9wZXJhdGlvbiBieSBhbm90aGVyIHRo cmVhZCwKcG90ZW50aWFsbHkgcmVkaXJlY3Rpbmcgd3JpdGVzIHRvIHVuaW50ZW5kZWQgZnVzZSBs b2NhdGlvbnMuCgpbU2V2ZXJpdHk6IEhpZ2hdClRoaXMgaXNuJ3QgYSBidWcgaW50cm9kdWNlZCBi eSB0aGlzIHBhdGNoLCBidXQgZG9lcyB0aGUgZXJyb3IgcGF0aCBpbgpiY21fb3RwY193cml0ZSgp IHBlcm1hbmVudGx5IGxlYXZlIHRoZSBoYXJkd2FyZSBpbiBwcm9ncmFtbWluZyBtb2RlPwoKICAg IHJldCA9IGVuYWJsZV9vY290cF9wcm9ncmFtKHByaXYtPmJhc2UpOwogICAgaWYgKHJldCkKICAg ICAgICByZXR1cm4gLUVJTzsKCiAgICBmb3IgKGJ5dGVzX3dyaXR0ZW4gPSAwOyBieXRlc193cml0 dGVuIDwgYnl0ZXM7KSB7CiAgICAgICAgLi4uCiAgICAgICAgcmV0ID0gcG9sbF9jcHVfc3RhdHVz KHByaXYtPmJhc2UsIE9UUENfU1RBVF9DTURfRE9ORSk7CiAgICAgICAgcmVzZXRfc3RhcnRfYml0 KHByaXYtPmJhc2UpOwogICAgICAgIGlmIChyZXQpIHsKICAgICAgICAgICAgZGV2X2Vycihwcml2 LT5kZXYsICJvdHAgd3JpdGUgZXJyb3I6IDB4JXgiLCByZXQpOwogICAgICAgICAgICByZXR1cm4g LUVJTzsKICAgICAgICB9CiAgICB9CgpJZiBwb2xsX2NwdV9zdGF0dXMoKSByZXR1cm5zIGFuIGVy cm9yLCB0aGUgZnVuY3Rpb24gcmV0dXJucyAtRUlPIGRpcmVjdGx5IGFuZApza2lwcyB0aGUgZGlz YWJsZV9vY290cF9wcm9ncmFtKHByaXYtPmJhc2UpIGNhbGwgYXQgdGhlIGVuZCBvZiB0aGUgZnVu Y3Rpb24sCnBvdGVudGlhbGx5IGxlYXZpbmcgcHJvZ3JhbW1pbmcgdm9sdGFnZXMgYXBwbGllZC4K Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZtZW0vaW14LW9jb3RwLXNjdS5jIGIvZHJpdmVycy9u dm1lbS9pbXgtb2NvdHAtc2N1LmMKPiAtLS0gYS9kcml2ZXJzL252bWVtL2lteC1vY290cC1zY3Uu Ywo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vaW14LW9jb3RwLXNjdS5jCj4gQEAgLTE3OCwxMSArMTc4 LDExIEBAIHN0YXRpYyBpbnQgaW14X3NjdV9vY290cF9yZWFkKHZvaWQgKmNvbnRleHQsIHVuc2ln bmVkIGludCBvZmZzZXQsCj4gIH0KPiAgCj4gIHN0YXRpYyBpbnQgaW14X3NjdV9vY290cF93cml0 ZSh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAo+IC0JCQkgICAgICAgdm9pZCAq dmFsLCBzaXplX3QgYnl0ZXMpCj4gKwkJCSAgICAgICBjb25zdCB2b2lkICp2YWwsIHNpemVfdCBi eXRlcykKPiAgewo+ICAJc3RydWN0IG9jb3RwX3ByaXYgKnByaXYgPSBjb250ZXh0Owo+ICAJc3Ry dWN0IGFybV9zbWNjY19yZXMgcmVzOwo+IC0JdTMyICpidWYgPSB2YWw7Cj4gKwljb25zdCB1MzIg KmJ1ZiA9IHZhbDsKCltTZXZlcml0eTogSGlnaF0KVGhpcyBpc24ndCBhIGJ1ZyBpbnRyb2R1Y2Vk IGJ5IHRoaXMgcGF0Y2gsIGJ1dCBpcyB0aGVyZSBhIHJhY2UgY29uZGl0aW9uIHdoZW4Kd3JpdGlu ZyB0byBFQ0MgcmVnaW9ucyBpbiBpbXhfc2N1X29jb3RwX3dyaXRlKCk/CgogICAgaWYgKGluX2Vj Yyhjb250ZXh0LCBpbmRleCkpIHsKICAgICAgICBwcl93YXJuKCJFQ0MgcmVnaW9uLCBvbmx5IHBy b2dyYW0gb25jZVxuIik7CiAgICAgICAgbXV0ZXhfbG9jaygmc2N1X29jb3RwX211dGV4KTsKICAg ICAgICByZXQgPSBpbXhfc2NfbWlzY19vdHBfZnVzZV9yZWFkKHByaXYtPm52bWVtX2lwYywgaW5k ZXgsICZ0bXApOwogICAgICAgIG11dGV4X3VubG9jaygmc2N1X29jb3RwX211dGV4KTsKICAgICAg ICBpZiAocmV0KQogICAgICAgICAgICByZXR1cm4gcmV0OwogICAgICAgIGlmICh0bXApIHsKICAg ICAgICAgICAgcHJfd2FybigiRUNDIHJlZ2lvbiwgYWxyZWFkeSBoYXMgdmFsdWU6ICV4XG4iLCB0 bXApOwogICAgICAgICAgICByZXR1cm4gLUVJTzsKICAgICAgICB9CiAgICB9CgogICAgbXV0ZXhf bG9jaygmc2N1X29jb3RwX211dGV4KTsKICAgIGFybV9zbWNjY19zbWMoSU1YX1NJUF9PVFBfV1JJ VEUsIGluZGV4LCAqYnVmLCAwLCAwLCAwLCAwLCAwLCAmcmVzKTsKICAgIG11dGV4X3VubG9jaygm c2N1X29jb3RwX211dGV4KTsKCkJlY2F1c2UgdGhlIGxvY2sgaXMgcmVsZWFzZWQgYWZ0ZXIgY2hl Y2tpbmcgaWYgdGhlIEVDQyByZWdpb24gaXMgcHJvZ3JhbW1lZCBhbmQKdGhlbiByZS1hY3F1aXJl ZCBmb3IgdGhlIFNNQyB3cml0ZSwgdHdvIGNvbmN1cnJlbnQgdGhyZWFkcyBjb3VsZCBib3RoIHBh c3MgdGhlCmluaXRpYWwgY2hlY2sgYW5kIHBlcmZvcm0gYSBkb3VibGUtd3JpdGUgdG8gdGhlIHdy aXRlLW9uY2UgRUNDIHJlZ2lvbi4KCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZtZW0vbGFuOTY2 Mi1vdHBjLmMgYi9kcml2ZXJzL252bWVtL2xhbjk2NjItb3RwYy5jCj4gLS0tIGEvZHJpdmVycy9u dm1lbS9sYW45NjYyLW90cGMuYwo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vbGFuOTY2Mi1vdHBjLmMK PiBAQCAtMTQwLDEwICsxNDAsMTAgQEAgc3RhdGljIGludCBsYW45NjYyX290cF9yZWFkKHZvaWQg KmNvbnRleHQsIHVuc2lnbmVkIGludCBvZmZzZXQsCj4gIH0KPiAgCj4gIHN0YXRpYyBpbnQgbGFu OTY2Ml9vdHBfd3JpdGUodm9pZCAqY29udGV4dCwgdW5zaWduZWQgaW50IG9mZnNldCwKPiAtCQkJ ICAgICB2b2lkICpfdmFsLCBzaXplX3QgYnl0ZXMpCj4gKwkJCSAgICAgY29uc3Qgdm9pZCAqX3Zh bCwgc2l6ZV90IGJ5dGVzKQo+ICB7Cj4gIAlzdHJ1Y3QgbGFuOTY2Ml9vdHAgKm90cCA9IGNvbnRl eHQ7Cj4gLQl1OCAqdmFsID0gX3ZhbDsKPiArCWNvbnN0IHU4ICp2YWwgPSBfdmFsOwoKW1NldmVy aXR5OiBIaWdoXQpUaGlzIGlzbid0IGEgYnVnIGludHJvZHVjZWQgYnkgdGhpcyBwYXRjaCwgYnV0 IGNhbiBjb25jdXJyZW50IGFjY2Vzc2VzIHRvCmxhbjk2NjJfb3RwX3dyaXRlKCkgYW5kIGxhbjk2 NjJfb3RwX3JlYWQoKSBjb3JydXB0IE9UUCBvcGVyYXRpb25zPwoKICAgIGZvciAoaSA9IDA7IGkg PCBieXRlczsgaSsrKSB7CiAgICAgICAgaWYgKHZhbFtpXSkgewogICAgICAgICAgICByYyA9IGxh bjk2NjJfb3RwX3JlYWRfYnl0ZShvdHAsIG9mZnNldCArIGksICZkYXRhKTsKICAgICAgICAgICAg aWYgKHJjIDwgMCkKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAuLi4KICAgICAg ICAgICAgcmMgPSBsYW45NjYyX290cF93cml0ZV9ieXRlKG90cCwgb2Zmc2V0ICsgaSwgbmV3ZGF0 YSk7CgpTaW5jZSB0aGVzZSBoYXJkd2FyZSByZWdpc3RlciBhY2Nlc3NlcyBhbmQgc3RhdGUgY2hh bmdlcyAoc3VjaCBhcyBwb3dlcmluZyB1cAphbmQgcG9sbGluZykgYXJlIHBlcmZvcm1lZCB3aXRo b3V0IGhvbGRpbmcgYSBsb2NhbCBsb2NrLCBjb25jdXJyZW50IHN5c2ZzCm9wZXJhdGlvbnMgbWln aHQgb3ZlcndyaXRlIGVhY2ggb3RoZXIncyBjb21tYW5kcyBpbiBmbGlnaHQsIHBvdGVudGlhbGx5 CmNvcnJ1cHRpbmcgT1RQIGRhdGEuCgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL252bWVtL2xwYzE4 eHhfZWVwcm9tLmMgYi9kcml2ZXJzL252bWVtL2xwYzE4eHhfZWVwcm9tLmMKPiAtLS0gYS9kcml2 ZXJzL252bWVtL2xwYzE4eHhfZWVwcm9tLmMKPiArKysgYi9kcml2ZXJzL252bWVtL2xwYzE4eHhf ZWVwcm9tLmMKPiBAQCAtODgsNyArODgsNyBAQCBzdGF0aWMgaW50IGxwYzE4eHhfZWVwcm9tX2J1 c3l3YWl0X3VudGlsX3Byb2coc3RydWN0IGxwYzE4eHhfZWVwcm9tX2RldiAqZWVwcm9tKQo+ICB9 Cj4gIAo+ICBzdGF0aWMgaW50IGxwYzE4eHhfZWVwcm9tX2dhdGhlcl93cml0ZSh2b2lkICpjb250 ZXh0LCB1bnNpZ25lZCBpbnQgcmVnLAo+IC0JCQkJICAgICAgIHZvaWQgKnZhbCwgc2l6ZV90IGJ5 dGVzKQo+ICsJCQkJICAgICAgIGNvbnN0IHZvaWQgKnZhbCwgc2l6ZV90IGJ5dGVzKQo+ICB7Cj4g IAlzdHJ1Y3QgbHBjMTh4eF9lZXByb21fZGV2ICplZXByb20gPSBjb250ZXh0Owo+ICAJdW5zaWdu ZWQgaW50IG9mZnNldCA9IHJlZzsKPiBAQCAtMTEwLDcgKzExMCw3IEBAIHN0YXRpYyBpbnQgbHBj MTh4eF9lZXByb21fZ2F0aGVyX3dyaXRlKHZvaWQgKmNvbnRleHQsIHVuc2lnbmVkIGludCByZWcs Cj4gIAl1c2xlZXBfcmFuZ2UoMTAwLCAyMDApOwo+ICAKPiAgCXdoaWxlIChieXRlcykgewo+IC0J CXdyaXRlbCgqKHUzMiAqKXZhbCwgZWVwcm9tLT5tZW1fYmFzZSArIG9mZnNldCk7Cj4gKwkJd3Jp dGVsKCooY29uc3QgdTMyICopdmFsLCBlZXByb20tPm1lbV9iYXNlICsgb2Zmc2V0KTsKCltTZXZl cml0eTogSGlnaF0KVGhpcyBpc24ndCBhIGJ1ZyBpbnRyb2R1Y2VkIGJ5IHRoaXMgcGF0Y2gsIGJ1 dCBkb2VzIHRoZSBsYWNrIG9mIGEgbG9jayBhcm91bmQKRUVQUk9NIHBvd2VyIG1hbmFnZW1lbnQg aW4gbHBjMTh4eF9lZXByb21fZ2F0aGVyX3dyaXRlKCkgYW5kCmxwYzE4eHhfZWVwcm9tX3JlYWQo KSByaXNrIGEgc3lzdGVtIGNyYXNoPwoKICAgIGxwYzE4eHhfZWVwcm9tX3dyaXRlbChlZXByb20s IExQQzE4WFhfRUVQUk9NX1BXUkRXTiwKICAgICAgICAgICAgICAgICAgICAgICAgICBMUEMxOFhY X0VFUFJPTV9QV1JEV05fTk8pOwogICAgdXNsZWVwX3JhbmdlKDEwMCwgMjAwKTsKICAgIC4uLgog ICAgd3JpdGVsKCooY29uc3QgdTMyICopdmFsLCBlZXByb20tPm1lbV9iYXNlICsgb2Zmc2V0KTsK CiAgICBscGMxOHh4X2VlcHJvbV93cml0ZWwoZWVwcm9tLCBMUEMxOFhYX0VFUFJPTV9QV1JEV04s CiAgICAgICAgICAgICAgICAgICAgICAgICAgTFBDMThYWF9FRVBST01fUFdSRFdOX1lFUyk7CgpJ ZiBhIHJlYWQgYW5kIHdyaXRlIG9jY3VyIGNvbmN1cnJlbnRseSwgb25lIHRocmVhZCBtaWdodCBw b3dlciBkb3duIHRoZSBFRVBST00Kd2hpbGUgdGhlIG90aGVyIGlzIHN0aWxsIGluc2lkZSBpdHMg bWVtb3J5IGFjY2VzcyBsb29wLiBBY2Nlc3NpbmcgcG93ZXJlZC1kb3duCk1NSU8gcmVnaW9ucyB0 eXBpY2FsbHkgY2F1c2VzIGEgc3luY2hyb25vdXMgZGF0YSBhYm9ydC4KCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbnZtZW0vbWVzb24tZWZ1c2UuYyBiL2RyaXZlcnMvbnZtZW0vbWVzb24tZWZ1c2Uu Ywo+IC0tLSBhL2RyaXZlcnMvbnZtZW0vbWVzb24tZWZ1c2UuYwo+ICsrKyBiL2RyaXZlcnMvbnZt ZW0vbWVzb24tZWZ1c2UuYwo+IEBAIC0yNywxMiArMjcsMTIgQEAgc3RhdGljIGludCBtZXNvbl9l ZnVzZV9yZWFkKHZvaWQgKmNvbnRleHQsIHVuc2lnbmVkIGludCBvZmZzZXQsCj4gIH0KPiAgCj4g IHN0YXRpYyBpbnQgbWVzb25fZWZ1c2Vfd3JpdGUodm9pZCAqY29udGV4dCwgdW5zaWduZWQgaW50 IG9mZnNldCwKPiAtCQkJICAgICB2b2lkICp2YWwsIHNpemVfdCBieXRlcykKPiArCQkJICAgICBj b25zdCB2b2lkICp2YWwsIHNpemVfdCBieXRlcykKPiAgewo+ICAJc3RydWN0IG1lc29uX3NtX2Zp cm13YXJlICpmdyA9IGNvbnRleHQ7Cj4gIAlpbnQgcmV0Owo+ICAKPiAtCXJldCA9IG1lc29uX3Nt X2NhbGxfd3JpdGUoZncsICh1OCAqKXZhbCwgYnl0ZXMsIFNNX0VGVVNFX1dSSVRFLCBvZmZzZXQs Cj4gKwlyZXQgPSBtZXNvbl9zbV9jYWxsX3dyaXRlKGZ3LCAodm9pZCAqKXZhbCwgYnl0ZXMsIFNN X0VGVVNFX1dSSVRFLCBvZmZzZXQsCgpbU2V2ZXJpdHk6IEhpZ2hdClRoaXMgaXNuJ3QgYSBidWcg aW50cm9kdWNlZCBieSB0aGlzIHBhdGNoLCBidXQgZG9lcyBtZXNvbl9zbV9jYWxsX3dyaXRlKCkK ZXhwb3NlIGEgbG9ja2xlc3Mgc2hhcmVkIG1lbW9yeSByYWNlPwoKSW4gZHJpdmVycy9maXJtd2Fy ZS9tZXNvbi9tZXNvbl9zbS5jOgogICAgbWVtY3B5KGZ3LT5zbV9zaG1lbV9pbl9iYXNlLCBidWZm ZXIsIHNpemUpOwogICAgaWYgKG1lc29uX3NtX2NhbGwoZncsIGNtZF9pbmRleCwgJndyaXR0ZW4s IGFyZzAsIGFyZzEsIGFyZzIsIGFyZzMsIGFyZzQpIDwgMCkKICAgICAgICByZXR1cm4gLUVJTlZB TDsKClNpbmNlIGZ3LT5zbV9zaG1lbV9pbl9iYXNlIGlzIGEgZ2xvYmFsIHNoYXJlZCBtZW1vcnkg YnVmZmVyIGFuZCB0aGVyZSBpcyBubwpsb2NraW5nLCBjb25jdXJyZW50IHdyaXRlcyBjb3VsZCBv dmVyd3JpdGUgZWFjaCBvdGhlcidzIHBheWxvYWRzIGJlZm9yZSB0aGUgU01DCmNhbGwgZXhlY3V0 ZXMsIHBvdGVudGlhbGx5IHdyaXRpbmcgY29ycnVwdGVkIG9yIGFyYml0cmFyeSBkYXRhIHRvIHRo ZQp3cml0ZS1vbmNlIGVGdXNlcy4KCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZtZW0vcWZwcm9t LmMgYi9kcml2ZXJzL252bWVtL3FmcHJvbS5jCj4gLS0tIGEvZHJpdmVycy9udm1lbS9xZnByb20u Ywo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vcWZwcm9tLmMKPiBAQCAtMjUzLDEzICsyNTMsMTMgQEAg c3RhdGljIGludCBxZnByb21fZW5hYmxlX2Z1c2VfYmxvd2luZyhjb25zdCBzdHJ1Y3QgcWZwcm9t X3ByaXYgKnByaXYsCj4gICAqCj4gICAqIFJldHVybjogMCBvciAtZXJyLgo+ICAgKi8KPiAtc3Rh dGljIGludCBxZnByb21fcmVnX3dyaXRlKHZvaWQgKmNvbnRleHQsIHVuc2lnbmVkIGludCByZWcs IHZvaWQgKl92YWwsCj4gK3N0YXRpYyBpbnQgcWZwcm9tX3JlZ193cml0ZSh2b2lkICpjb250ZXh0 LCB1bnNpZ25lZCBpbnQgcmVnLCBjb25zdCB2b2lkICpfdmFsLAo+ICAJCQkgICAgc2l6ZV90IGJ5 dGVzKQo+ICB7Cj4gIAlzdHJ1Y3QgcWZwcm9tX3ByaXYgKnByaXYgPSBjb250ZXh0Owo+ICAJc3Ry dWN0IHFmcHJvbV90b3VjaGVkX3ZhbHVlcyBvbGQ7Cj4gIAlpbnQgd29yZHMgPSBieXRlcyAvIDQ7 Cj4gLQl1MzIgKnZhbHVlID0gX3ZhbDsKPiArCWNvbnN0IHUzMiAqdmFsdWUgPSBfdmFsOwoKW1Nl dmVyaXR5OiBIaWdoXQpUaGlzIGlzbid0IGEgYnVnIGludHJvZHVjZWQgYnkgdGhpcyBwYXRjaCwg YnV0IGNhbiBjb25jdXJyZW50IGNhbGxzIHRvCnFmcHJvbV9yZWdfd3JpdGUoKSBsZWF2ZSB0aGUg c3lzdGVtIGNsb2NrIGFuZCByZWd1bGF0b3JzIHBlcm1hbmVudGx5IHVuYmFsYW5jZWQ/CgogICAg cmV0ID0gcWZwcm9tX2VuYWJsZV9mdXNlX2Jsb3dpbmcocHJpdiwgJm9sZCk7CiAgICAuLi4KICAg IHFmcHJvbV9kaXNhYmxlX2Z1c2VfYmxvd2luZyhwcml2LCAmb2xkKTsKCkluc2lkZSBxZnByb21f ZW5hYmxlX2Z1c2VfYmxvd2luZygpOgogICAgb2xkLT5jbGtfcmF0ZSA9IGNsa19nZXRfcmF0ZShw cml2LT5zZWNjbGspOwogICAgcmV0ID0gY2xrX3NldF9yYXRlKHByaXYtPnNlY2NsaywgcHJpdi0+ c29jX2RhdGEtPnFmcHJvbV9ibG93X3NldF9mcmVxKTsKCkJlY2F1c2UgdGhlIG9sZCBzdGF0ZSBp cyBzYXZlZCB0byBhIGxvY2FsIHN0YWNrIHZhcmlhYmxlIHdpdGhvdXQgYW55IG11dGV4CnNlcmlh bGl6YXRpb24sIGEgY29uY3VycmVudCB3cml0ZSBjb3VsZCBzYXZlIHRoZSBhbHJlYWR5LWVsZXZh dGVkIGNsb2NrIHJhdGUKYW5kIHJlZ3VsYXRvciB2b2x0YWdlIGFzIHRoZSAib2xkIiBzdGF0ZS4g VXBvbiBjb21wbGV0aW9uLCB0aGUgaGFyZHdhcmUgd291bGQKYmUgcmVzdG9yZWQgdG8gdGhpcyBl bGV2YXRlZCBzdGF0ZSByYXRoZXIgdGhhbiB0aGUgb3JpZ2luYWwgb25lLgoKPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9udm1lbS9zcHJkLWVmdXNlLmMgYi9kcml2ZXJzL252bWVtL3NwcmQtZWZ1c2Uu Ywo+IC0tLSBhL2RyaXZlcnMvbnZtZW0vc3ByZC1lZnVzZS5jCj4gKysrIGIvZHJpdmVycy9udm1l bS9zcHJkLWVmdXNlLmMKPiBAQCAtMTkyLDcgKzE5Miw3IEBAIHN0YXRpYyB2b2lkIHNwcmRfZWZ1 c2Vfc2V0X3Byb2dfZW4oc3RydWN0IHNwcmRfZWZ1c2UgKmVmdXNlLCBib29sIGVuKQo+ICB9Cj4g IAo+ICBzdGF0aWMgaW50IHNwcmRfZWZ1c2VfcmF3X3Byb2coc3RydWN0IHNwcmRfZWZ1c2UgKmVm dXNlLCB1MzIgYmxrLCBib29sIGRvdWIsCj4gLQkJCSAgICAgICBib29sIGxvY2ssIHUzMiAqZGF0 YSkKPiArCQkJICAgICAgIGJvb2wgbG9jaywgY29uc3QgdTMyICpkYXRhKQo+ICB7Cj4gIAl1MzIg c3RhdHVzOwo+ICAJaW50IHJldCA9IDA7Cj4gWyAuLi4gXQo+IEBAIC0zMjEsNyArMzIxLDcgQEAg c3RhdGljIGludCBzcHJkX2VmdXNlX3JlYWQodm9pZCAqY29udGV4dCwgdTMyIG9mZnNldCwgdm9p ZCAqdmFsLCBzaXplX3QgYnl0ZXMpCj4gIAlyZXR1cm4gcmV0Owo+ICB9Cj4gIAo+IC1zdGF0aWMg aW50IHNwcmRfZWZ1c2Vfd3JpdGUodm9pZCAqY29udGV4dCwgdTMyIG9mZnNldCwgdm9pZCAqdmFs LCBzaXplX3QgYnl0ZXMpCj4gK3N0YXRpYyBpbnQgc3ByZF9lZnVzZV93cml0ZSh2b2lkICpjb250 ZXh0LCB1MzIgb2Zmc2V0LCBjb25zdCB2b2lkICp2YWwsIHNpemVfdCBieXRlcykKPiAgewo+ICAJ c3RydWN0IHNwcmRfZWZ1c2UgKmVmdXNlID0gY29udGV4dDsKPiAgCWJvb2wgYmxrX2RvdWJsZSA9 IGVmdXNlLT5kYXRhLT5ibGtfZG91YmxlOwoKW1NldmVyaXR5OiBDcml0aWNhbF0KVGhpcyBpc24n dCBhIGJ1ZyBpbnRyb2R1Y2VkIGJ5IHRoaXMgcGF0Y2gsIGJ1dCBkb2VzIHRoZSBvZmZzZXQgaGFu ZGxpbmcgaW4Kc3ByZF9lZnVzZV93cml0ZSgpIGFuZCBzcHJkX2VmdXNlX3JlYWQoKSBsZWFkIHRv IG91dC1vZi1ib3VuZHMgYWNjZXNzPwoKSW4gc3ByZF9lZnVzZV93cml0ZSgpLCB0aGUgcmF3IGJ5 dGUgb2Zmc2V0IGlzIHBhc3NlZCBkaXJlY3RseSBhcyB0aGUgYmxvY2sKaW5kZXggdG8gc3ByZF9l ZnVzZV9yYXdfcHJvZygpOgoKICAgIHJldCA9IHNwcmRfZWZ1c2VfcmF3X3Byb2coZWZ1c2UsIG9m ZnNldCwgYmxrX2RvdWJsZSwgbG9jaywgdmFsKTsKClRoZW4sIGluIHNwcmRfZWZ1c2VfcmF3X3By b2coKToKCiAgICB3cml0ZWwoKmRhdGEsIGVmdXNlLT5iYXNlICsgU1BSRF9FRlVTRV9NRU0oYmxr KSk7CgpUaGUgbWFjcm8gU1BSRF9FRlVTRV9NRU0oYmxrKSBzaGlmdHMgdGhlIG9mZnNldCBieSAy IChtdWx0aXBseWluZyBieSA0KS4KQmVjYXVzZSB3b3JkX3NpemUgPSAxIGFuZCBzdHJpZGUgPSAx LCB1c2Vyc3BhY2UgY2FuIHJlcXVlc3QgYXJiaXRyYXJ5IG9mZnNldHMsCmNhdXNpbmcgdGhpcyB0 byB3cml0ZSBmYXIgb3V0c2lkZSB0aGUgaW50ZW5kZWQgZUZ1c2UgTU1JTyByZWdpb24uCgpBZGRp dGlvbmFsbHksIGluIHNwcmRfZWZ1c2VfcmVhZCgpOgoKICAgIHUzMiBkYXRhOwogICAgLi4uCiAg ICByZXQgPSBzcHJkX2VmdXNlX3Jhd19yZWFkKGVmdXNlLCBpbmRleCwgJmRhdGEsIGJsa19kb3Vi bGUpOwogICAgaWYgKCFyZXQpIHsKICAgICAgICBkYXRhID4+PSBibGtfb2Zmc2V0OwogICAgICAg IG1lbWNweSh2YWwsICZkYXRhLCBieXRlcyk7CiAgICB9CgpJZiB1c2Vyc3BhY2UgcmVxdWVzdHMg YSByZWFkIGxhcmdlciB0aGFuIDQgYnl0ZXMsIG1lbWNweSgpIHdpbGwgcmVhZCBwYXN0IHRoZQps b2NhbCBzdGFjayB2YXJpYWJsZSAnZGF0YScgYW5kIGNvcHkgdW5pbml0aWFsaXplZCBhZGphY2Vu dCBrZXJuZWwgc3RhY2sgbWVtb3J5CnRvIHVzZXJzcGFjZS4KCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvbnZtZW0vc3RtMzItYnNlYy1vcHRlZS10YS5jIGIvZHJpdmVycy9udm1lbS9zdG0zMi1ic2Vj LW9wdGVlLXRhLmMKPiAtLS0gYS9kcml2ZXJzL252bWVtL3N0bTMyLWJzZWMtb3B0ZWUtdGEuYwo+ ICsrKyBiL2RyaXZlcnMvbnZtZW0vc3RtMzItYnNlYy1vcHRlZS10YS5jCj4gQEAgLTIwMyw3ICsy MDMsNyBAQCBpbnQgc3RtMzJfYnNlY19vcHRlZV90YV9yZWFkKHN0cnVjdCB0ZWVfY29udGV4dCAq Y3R4LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAo+ICAKPiAgLyogc3RtMzJfYnNlY19vcHRlZV90YV93 cml0ZSgpIC0gbnZtZW0gd3JpdGUgYWNjZXNzIHVzaW5nIFBUQSBjbGllbnQgZHJpdmVyICovCj4g IGludCBzdG0zMl9ic2VjX29wdGVlX3RhX3dyaXRlKHN0cnVjdCB0ZWVfY29udGV4dCAqY3R4LCB1 bnNpZ25lZCBpbnQgbG93ZXIsCj4gLQkJCSAgICAgIHVuc2lnbmVkIGludCBvZmZzZXQsIHZvaWQg KmJ1Ziwgc2l6ZV90IGJ5dGVzKQo+ICsJCQkgICAgICB1bnNpZ25lZCBpbnQgb2Zmc2V0LCBjb25z dCB2b2lkICpidWYsIHNpemVfdCBieXRlcykKPiAgewlzdHJ1Y3QgdGVlX3NobSAqc2htOwoKW1Nl dmVyaXR5OiBIaWdoXQpUaGlzIGlzbid0IGEgYnVnIGludHJvZHVjZWQgYnkgdGhpcyBwYXRjaCwg YnV0IGRvZXMgYW4gdW5hbGlnbmVkIHdyaXRlIHJlcXVlc3QKbGVhayBURUUgc2Vzc2lvbnM/Cgog ICAgcmV0ID0gc3RtMzJfYnNlY190YV9vcGVuX3Nlc3Npb24oY3R4LCAmc2Vzc2lvbl9pZCk7CiAg ICBpZiAocmV0KQogICAgICAgIHJldHVybiByZXQ7CgogICAgLyogQWxsb3cgb25seSB3cml0aW5n IGNvbXBsZXRlIDMyLWJpdHMgYWxpZ25lZCB3b3JkcyAqLwogICAgaWYgKChieXRlcyAlIDQpIHx8 IChvZmZzZXQgJSA0KSkKICAgICAgICByZXR1cm4gLUVJTlZBTDsKCklmIHRoZSBvZmZzZXQgb3Ig Ynl0ZXMgYXJlIG5vdCAzMi1iaXQgYWxpZ25lZCwgdGhlIGZ1bmN0aW9uIHJldHVybnMgLUVJTlZB TApkaXJlY3RseSwgYnlwYXNzaW5nIHRoZSBjYWxsIHRvIHN0bTMyX2JzZWNfdGFfY2xvc2Vfc2Vz c2lvbihjdHgsIHNlc3Npb25faWQpLgpCZWNhdXNlIHRoZSBudm1lbSBjb3JlIGFsbG93cyB1bmFs aWduZWQgd3JpdGVzIGJ5IGRlZmF1bHQsIHRoaXMgY291bGQgYmUKdHJpZ2dlcmVkIHJlcGVhdGVk bHkgdG8gZXhoYXVzdCBhbGwgYXZhaWxhYmxlIFRFRSBzZXNzaW9ucy4KCi0tIApTYXNoaWtvIEFJ IHJldmlldyDCtyBodHRwczovL3Nhc2hpa28uZGV2LyMvcGF0Y2hzZXQvMjAyNjA3MTUxOTU1MjAu MjU0MTAtMS1saW5rbWF1dmVAbGlua21hdXZlLmZyP3BhcnQ9MgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYW1sb2dpYyBtYWlsaW5nIGxpc3QK bGludXgtYW1sb2dpY0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQu b3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYW1sb2dpYwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 245BB4C6EF2 for ; Wed, 15 Jul 2026 20:21:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784146864; cv=none; b=FHM+TUJ3QRa5k6Pp3uWocw581OMtwY88U9CGfLsehQFvuS/MHnDlXFQlA1qyuvN7WLpCSw9kvnb1rSTrvckj6vPOPZYpQigC5SqXBI+TU6EQOvARsBeEJG7d+jjWqT2OCzcJC3hqC7e+XA5r7NEq0In3crea72p/0FQK4XhMuzQ= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784146864; c=relaxed/simple; bh=7BMarNZprxTK00Ozeb2zkhqjZlUscvtGPJ0SveidKHs=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=EnEARA1YNmJodsYtWpoVytKupyKHgh2fcTenejub2ZByvD2RmECi6IT1LETGZnzB51qWS1fU0+6b1tv95fCOgfvXQfROFdT+DRCY1/KHHSJnDunYeqWXMQcpyuQ/ZSuFEvFze5mXVZOB/5DQdwyJthpq10Okjz+/2nL/AYe3IPs= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ZlQaZeJy; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ZlQaZeJy" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9E1CD1F000E9; Wed, 15 Jul 2026 20:21:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784146862; bh=Vt4Ij9BkEDrjHpf2FuVRD/sTwfgT130h+QRo36efLug=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=ZlQaZeJy3R+LrHLWfKEe/sl7UWw6D8TM3Dylhl1pFU60rzt9e4QOoFq5yMwLI7NCj 1dJRim6zGSDcZLglf8qZjh/DXqQfMHvuCQCc8+WjSydAs3sGWOL/xWs2Xy34/Ubg6+ +mlUeHTQQE4csbbTI9n1IU2tuTG9zgSlEOn/9l37zt+9916G/qrBfPjg74jizYIm9G iDimc7SZ+b0Rl5jTxI45eOub6aLfelhmc04oeGOYptKDhbN93Q7ZfDmaTjzt29hyVH hUZQjVkapD0U/5UGIP6boX/tVfBBIGMdndrNhiJtxTmlicWnfg6mUyccGKo+Mvlj9T D04skVEYs60mQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 2/2] nvmem: make all reg_write callbacks take const void * Reply-To: sashiko-reviews@lists.linux.dev To: "Link Mauve" Cc: neil.armstrong@linaro.org, Frank.Li@kernel.org, ojeda@kernel.org, linux-amlogic@lists.infradead.org, imx@lists.linux.dev In-Reply-To: <20260715195520.25410-3-linkmauve@linkmauve.fr> References: <20260715195520.25410-1-linkmauve@linkmauve.fr> <20260715195520.25410-3-linkmauve@linkmauve.fr> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Wed, 15 Jul 2026 20:21:01 +0000 Message-Id: <20260715202101.9E1CD1F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: imx@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 10 potential issue= (s) to consider: New issues: - [Critical] The nvmem core incorrectly evaluates write permissions, causin= g all drivers providing only `.reg_write_const` to be unconditionally treat= ed as read-only. Pre-existing issues: - [Critical] The Spreadtrum eFuse driver incorrectly calculates memory offs= ets and size constraints, leading to out-of-bounds MMIO writes, memory corr= uption, and kernel stack information leaks. - [High] The bcm-ocotp driver fails to disable programming mode on the erro= r path. - [High] The stm32-bsec-optee-ta driver leaks TEE sessions when unaligned w= rites are requested. - [High] The imx-ocotp-scu driver has a Time-of-Check to Time-of-Use (TOCTO= U) race condition when writing to ECC regions. - [High] The meson-sm firmware driver exposes a lockless shared memory race= when interacting with meson-efuse. - [High] The lpc18xx-eeprom driver lacks serialization, causing a race cond= ition on the EEPROM power state that can crash the system. - [High] The qfprom driver modifies global clock rates and regulator voltag= es without serialization. - [High] The lan9662-otpc driver modifies hardware state and registers with= out locking, leading to race conditions and fuse corruption. - [High] The bcm-ocotp driver modifies command and address registers withou= t locking, leading to OTP fuse corruption. -- --- Patch [2]: [PATCH v2 2/2] nvmem: make all reg_write callbacks take cons= t void * --- commit 757b2f38ab10e7e5415fbd52779fa12f901c3ac4 Author: Link Mauve Subject: nvmem: make all reg_write callbacks take const void * The previous commit switched from a pointer to mutable data to a pointer to immutable data, so let=E2=80=99s fix all users of this API. > diff --git a/drivers/nvmem/apple-spmi-nvmem.c b/drivers/nvmem/apple-spmi-= nvmem.c > --- a/drivers/nvmem/apple-spmi-nvmem.c > +++ b/drivers/nvmem/apple-spmi-nvmem.c > @@ -29,7 +29,7 @@ static int apple_spmi_nvmem_probe(struct spmi_device *s= dev) > .stride =3D 1, > .size =3D 0xffff, > .reg_read =3D (void *)regmap_bulk_read, > - .reg_write =3D (void *)regmap_bulk_write, > + .reg_write_const =3D (void *)regmap_bulk_write, [Severity: Critical] By migrating to .reg_write_const and leaving .reg_write as NULL, does this inadvertently make all these devices read-only? Looking at the nvmem core in drivers/nvmem/core.c: nvmem_register() { ... nvmem->read_only =3D device_property_present(config->dev, "read-only") = || config->read_only || !nvmem->reg_write || !nvmem->reg_write_const; ... } bin_attr_nvmem_write() { ... if (!nvmem->reg_write || !nvmem->reg_write_const || nvmem->read_only) return -EPERM; ... } Because the core checks !nvmem->reg_write || !nvmem->reg_write_const, setting reg_write to NULL causes the core to strip write permissions and return -EPERM for all sysfs writes. > diff --git a/drivers/nvmem/bcm-ocotp.c b/drivers/nvmem/bcm-ocotp.c > --- a/drivers/nvmem/bcm-ocotp.c > +++ b/drivers/nvmem/bcm-ocotp.c > [ ... ] > @@ -179,11 +179,11 @@ static int bcm_otpc_read(void *context, unsigned in= t offset, void *val, > return 0; > } > =20 > -static int bcm_otpc_write(void *context, unsigned int offset, void *val, > +static int bcm_otpc_write(void *context, unsigned int offset, const void= *val, > size_t bytes) > { > struct otpc_priv *priv =3D context; > - u32 *buf =3D val; > + const u32 *buf =3D val; [Severity: High] This isn't a bug introduced by this patch, but is it possible for concurrent reads and writes to corrupt hardware state? In bcm_otpc_write(): for (bytes_written =3D 0; bytes_written < bytes;) { set_command(priv->base, OTPC_CMD_PROGRAM); set_cpu_address(priv->base, address++); And similarly in bcm_otpc_read(): for (bytes_read =3D 0; bytes_read < bytes;) { set_command(priv->base, OTPC_CMD_READ); set_cpu_address(priv->base, address++); Without serialization, concurrent sysfs operations could cause the command = and address registers to be overwritten mid-operation by another thread, potentially redirecting writes to unintended fuse locations. [Severity: High] This isn't a bug introduced by this patch, but does the error path in bcm_otpc_write() permanently leave the hardware in programming mode? ret =3D enable_ocotp_program(priv->base); if (ret) return -EIO; for (bytes_written =3D 0; bytes_written < bytes;) { ... ret =3D poll_cpu_status(priv->base, OTPC_STAT_CMD_DONE); reset_start_bit(priv->base); if (ret) { dev_err(priv->dev, "otp write error: 0x%x", ret); return -EIO; } } If poll_cpu_status() returns an error, the function returns -EIO directly a= nd skips the disable_ocotp_program(priv->base) call at the end of the function, potentially leaving programming voltages applied. > diff --git a/drivers/nvmem/imx-ocotp-scu.c b/drivers/nvmem/imx-ocotp-scu.c > --- a/drivers/nvmem/imx-ocotp-scu.c > +++ b/drivers/nvmem/imx-ocotp-scu.c > @@ -178,11 +178,11 @@ static int imx_scu_ocotp_read(void *context, unsign= ed int offset, > } > =20 > static int imx_scu_ocotp_write(void *context, unsigned int offset, > - void *val, size_t bytes) > + const void *val, size_t bytes) > { > struct ocotp_priv *priv =3D context; > struct arm_smccc_res res; > - u32 *buf =3D val; > + const u32 *buf =3D val; [Severity: High] This isn't a bug introduced by this patch, but is there a race condition wh= en writing to ECC regions in imx_scu_ocotp_write()? if (in_ecc(context, index)) { pr_warn("ECC region, only program once\n"); mutex_lock(&scu_ocotp_mutex); ret =3D imx_sc_misc_otp_fuse_read(priv->nvmem_ipc, index, &tmp); mutex_unlock(&scu_ocotp_mutex); if (ret) return ret; if (tmp) { pr_warn("ECC region, already has value: %x\n", tmp); return -EIO; } } mutex_lock(&scu_ocotp_mutex); arm_smccc_smc(IMX_SIP_OTP_WRITE, index, *buf, 0, 0, 0, 0, 0, &res); mutex_unlock(&scu_ocotp_mutex); Because the lock is released after checking if the ECC region is programmed= and then re-acquired for the SMC write, two concurrent threads could both pass = the initial check and perform a double-write to the write-once ECC region. > diff --git a/drivers/nvmem/lan9662-otpc.c b/drivers/nvmem/lan9662-otpc.c > --- a/drivers/nvmem/lan9662-otpc.c > +++ b/drivers/nvmem/lan9662-otpc.c > @@ -140,10 +140,10 @@ static int lan9662_otp_read(void *context, unsigned= int offset, > } > =20 > static int lan9662_otp_write(void *context, unsigned int offset, > - void *_val, size_t bytes) > + const void *_val, size_t bytes) > { > struct lan9662_otp *otp =3D context; > - u8 *val =3D _val; > + const u8 *val =3D _val; [Severity: High] This isn't a bug introduced by this patch, but can concurrent accesses to lan9662_otp_write() and lan9662_otp_read() corrupt OTP operations? for (i =3D 0; i < bytes; i++) { if (val[i]) { rc =3D lan9662_otp_read_byte(otp, offset + i, &data); if (rc < 0) break; ... rc =3D lan9662_otp_write_byte(otp, offset + i, newdata); Since these hardware register accesses and state changes (such as powering = up and polling) are performed without holding a local lock, concurrent sysfs operations might overwrite each other's commands in flight, potentially corrupting OTP data. > diff --git a/drivers/nvmem/lpc18xx_eeprom.c b/drivers/nvmem/lpc18xx_eepro= m.c > --- a/drivers/nvmem/lpc18xx_eeprom.c > +++ b/drivers/nvmem/lpc18xx_eeprom.c > @@ -88,7 +88,7 @@ static int lpc18xx_eeprom_busywait_until_prog(struct lp= c18xx_eeprom_dev *eeprom) > } > =20 > static int lpc18xx_eeprom_gather_write(void *context, unsigned int reg, > - void *val, size_t bytes) > + const void *val, size_t bytes) > { > struct lpc18xx_eeprom_dev *eeprom =3D context; > unsigned int offset =3D reg; > @@ -110,7 +110,7 @@ static int lpc18xx_eeprom_gather_write(void *context,= unsigned int reg, > usleep_range(100, 200); > =20 > while (bytes) { > - writel(*(u32 *)val, eeprom->mem_base + offset); > + writel(*(const u32 *)val, eeprom->mem_base + offset); [Severity: High] This isn't a bug introduced by this patch, but does the lack of a lock arou= nd EEPROM power management in lpc18xx_eeprom_gather_write() and lpc18xx_eeprom_read() risk a system crash? lpc18xx_eeprom_writel(eeprom, LPC18XX_EEPROM_PWRDWN, LPC18XX_EEPROM_PWRDWN_NO); usleep_range(100, 200); ... writel(*(const u32 *)val, eeprom->mem_base + offset); lpc18xx_eeprom_writel(eeprom, LPC18XX_EEPROM_PWRDWN, LPC18XX_EEPROM_PWRDWN_YES); If a read and write occur concurrently, one thread might power down the EEP= ROM while the other is still inside its memory access loop. Accessing powered-d= own MMIO regions typically causes a synchronous data abort. > diff --git a/drivers/nvmem/meson-efuse.c b/drivers/nvmem/meson-efuse.c > --- a/drivers/nvmem/meson-efuse.c > +++ b/drivers/nvmem/meson-efuse.c > @@ -27,12 +27,12 @@ static int meson_efuse_read(void *context, unsigned i= nt offset, > } > =20 > static int meson_efuse_write(void *context, unsigned int offset, > - void *val, size_t bytes) > + const void *val, size_t bytes) > { > struct meson_sm_firmware *fw =3D context; > int ret; > =20 > - ret =3D meson_sm_call_write(fw, (u8 *)val, bytes, SM_EFUSE_WRITE, offse= t, > + ret =3D meson_sm_call_write(fw, (void *)val, bytes, SM_EFUSE_WRITE, off= set, [Severity: High] This isn't a bug introduced by this patch, but does meson_sm_call_write() expose a lockless shared memory race? In drivers/firmware/meson/meson_sm.c: memcpy(fw->sm_shmem_in_base, buffer, size); if (meson_sm_call(fw, cmd_index, &written, arg0, arg1, arg2, arg3, arg4= ) < 0) return -EINVAL; Since fw->sm_shmem_in_base is a global shared memory buffer and there is no locking, concurrent writes could overwrite each other's payloads before the= SMC call executes, potentially writing corrupted or arbitrary data to the write-once eFuses. > diff --git a/drivers/nvmem/qfprom.c b/drivers/nvmem/qfprom.c > --- a/drivers/nvmem/qfprom.c > +++ b/drivers/nvmem/qfprom.c > @@ -253,13 +253,13 @@ static int qfprom_enable_fuse_blowing(const struct = qfprom_priv *priv, > * > * Return: 0 or -err. > */ > -static int qfprom_reg_write(void *context, unsigned int reg, void *_val, > +static int qfprom_reg_write(void *context, unsigned int reg, const void = *_val, > size_t bytes) > { > struct qfprom_priv *priv =3D context; > struct qfprom_touched_values old; > int words =3D bytes / 4; > - u32 *value =3D _val; > + const u32 *value =3D _val; [Severity: High] This isn't a bug introduced by this patch, but can concurrent calls to qfprom_reg_write() leave the system clock and regulators permanently unbala= nced? ret =3D qfprom_enable_fuse_blowing(priv, &old); ... qfprom_disable_fuse_blowing(priv, &old); Inside qfprom_enable_fuse_blowing(): old->clk_rate =3D clk_get_rate(priv->secclk); ret =3D clk_set_rate(priv->secclk, priv->soc_data->qfprom_blow_set_freq= ); Because the old state is saved to a local stack variable without any mutex serialization, a concurrent write could save the already-elevated clock rate and regulator voltage as the "old" state. Upon completion, the hardware wou= ld be restored to this elevated state rather than the original one. > diff --git a/drivers/nvmem/sprd-efuse.c b/drivers/nvmem/sprd-efuse.c > --- a/drivers/nvmem/sprd-efuse.c > +++ b/drivers/nvmem/sprd-efuse.c > @@ -192,7 +192,7 @@ static void sprd_efuse_set_prog_en(struct sprd_efuse = *efuse, bool en) > } > =20 > static int sprd_efuse_raw_prog(struct sprd_efuse *efuse, u32 blk, bool d= oub, > - bool lock, u32 *data) > + bool lock, const u32 *data) > { > u32 status; > int ret =3D 0; > [ ... ] > @@ -321,7 +321,7 @@ static int sprd_efuse_read(void *context, u32 offset,= void *val, size_t bytes) > return ret; > } > =20 > -static int sprd_efuse_write(void *context, u32 offset, void *val, size_t= bytes) > +static int sprd_efuse_write(void *context, u32 offset, const void *val, = size_t bytes) > { > struct sprd_efuse *efuse =3D context; > bool blk_double =3D efuse->data->blk_double; [Severity: Critical] This isn't a bug introduced by this patch, but does the offset handling in sprd_efuse_write() and sprd_efuse_read() lead to out-of-bounds access? In sprd_efuse_write(), the raw byte offset is passed directly as the block index to sprd_efuse_raw_prog(): ret =3D sprd_efuse_raw_prog(efuse, offset, blk_double, lock, val); Then, in sprd_efuse_raw_prog(): writel(*data, efuse->base + SPRD_EFUSE_MEM(blk)); The macro SPRD_EFUSE_MEM(blk) shifts the offset by 2 (multiplying by 4). Because word_size =3D 1 and stride =3D 1, userspace can request arbitrary o= ffsets, causing this to write far outside the intended eFuse MMIO region. Additionally, in sprd_efuse_read(): u32 data; ... ret =3D sprd_efuse_raw_read(efuse, index, &data, blk_double); if (!ret) { data >>=3D blk_offset; memcpy(val, &data, bytes); } If userspace requests a read larger than 4 bytes, memcpy() will read past t= he local stack variable 'data' and copy uninitialized adjacent kernel stack me= mory to userspace. > diff --git a/drivers/nvmem/stm32-bsec-optee-ta.c b/drivers/nvmem/stm32-bs= ec-optee-ta.c > --- a/drivers/nvmem/stm32-bsec-optee-ta.c > +++ b/drivers/nvmem/stm32-bsec-optee-ta.c > @@ -203,7 +203,7 @@ int stm32_bsec_optee_ta_read(struct tee_context *ctx,= unsigned int offset, > =20 > /* stm32_bsec_optee_ta_write() - nvmem write access using PTA client dri= ver */ > int stm32_bsec_optee_ta_write(struct tee_context *ctx, unsigned int lowe= r, > - unsigned int offset, void *buf, size_t bytes) > + unsigned int offset, const void *buf, size_t bytes) > { struct tee_shm *shm; [Severity: High] This isn't a bug introduced by this patch, but does an unaligned write requ= est leak TEE sessions? ret =3D stm32_bsec_ta_open_session(ctx, &session_id); if (ret) return ret; /* Allow only writing complete 32-bits aligned words */ if ((bytes % 4) || (offset % 4)) return -EINVAL; If the offset or bytes are not 32-bit aligned, the function returns -EINVAL directly, bypassing the call to stm32_bsec_ta_close_session(ctx, session_id= ). Because the nvmem core allows unaligned writes by default, this could be triggered repeatedly to exhaust all available TEE sessions. --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260715195520.2541= 0-1-linkmauve@linkmauve.fr?part=3D2