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 2E20DCD4F3D for ; Wed, 20 May 2026 15:39:15 +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:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=RTV0TVjeQ+ciItGxGGI4k4WpC8y4/gRc7XDc982kZ9U=; b=ooxlDvz7mMj5Zh WWH3ITw1NS7J6iKIhIM255cBEipaItczpK2Xf/q2ydk1kaghk7Xu5xCBXIOZ8MpgFknFaooXKgQS0 +87FG6FAQj5q1t9VC2VOyhcEMUPvdl940rS8yqC9KN/tVeyRvRVo5i4NaiNqqBJcLo2MgMGJuvof/ fjo00YtBns4TGSHVWiIkmEJTwjkCXBRQaH0Ho45m8CFcuKvoDGg0yOZHdBdbqxwvILT7+twxH5QKS sCy8KWjPh2mDixCQLHMsW7NfJ/RgBwnHCFhYkyu7D3g4K2cvdi1Kn8eIeCRGhUblpIfjn/akKBAaP XqLGI30pkQopABbGMZTA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wPj0m-000000052JW-44lq; Wed, 20 May 2026 15:39:08 +0000 Received: from sender4-pp-f112.zoho.com ([136.143.188.112]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wPj0j-000000052IZ-0xex; Wed, 20 May 2026 15:39:08 +0000 ARC-Seal: i=1; a=rsa-sha256; t=1779291529; cv=none; d=zohomail.com; s=zohoarc; b=QXzTTY8XLE2auMgRO6+JIJ6sNAEG5Cqne5meClPMm2TeipsjAVnEeDmEChFCpAkcZMs+xbYHAZ14CRGGhPuXJL95N3YaloIqtXldg6hM8Kt3zxg9xJ17UuYOOWGw5l73O92RpnPgWT0raWw8gpX6ipGHIdRltXfieCjiUbc5cOM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1779291529; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=Xm9nnVCBYy+blSkynAKkLYL8et0xsHtZkmtd1aUF37I=; b=Dr5rl2tPqE8mgAfPvblU00j3AH9g2IQlQNB3QIX+1nXT/IQ2Zd+b66v7vrltLgZMVdvdTiryLha47SFdcyPoJeGj3K/1/sZdWC1ip07eSZzqen8pCCSnCN2NZ3kBwSV6VqASl3jbnzWKkgHcSjnR97z4ur0p0gvS4T0BQ+K3ljE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=nicolas.frattaroli@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1779291529; s=zohomail; d=collabora.com; i=nicolas.frattaroli@collabora.com; h=From:From:To:To:Cc:Cc:Subject:Subject:Date:Date:Message-ID:In-Reply-To:References:MIME-Version:Content-Transfer-Encoding:Content-Type:Message-Id:Reply-To; bh=Xm9nnVCBYy+blSkynAKkLYL8et0xsHtZkmtd1aUF37I=; b=Puq+tOIKnsNrVbqKBhyw9fQN41vpdVnwKr0g3zS8WtZwwLfUMcmo9LGkbPMN+ORi v1pRPz91WgLw0CYnmmC1B94nctZSaOa25D63TFqEjUZz+XhXPK1keY/42fq1EO2Jt+r wWLB4fM2I2l7AyLhgU4eDBdJnA/Fta1Qdgm6gq9k= Received: by mx.zohomail.com with SMTPS id 1779291527165842.2027965159605; Wed, 20 May 2026 08:38:47 -0700 (PDT) From: Nicolas Frattaroli To: Lee Jones Cc: Uwe =?UTF-8?B?S2xlaW5lLUvDtm5pZw==?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Heiko Stuebner , William Breathitt Gray , Damon Ding , kernel@collabora.com, Jonas Karlman , Alexey Charkov , linux-rockchip@lists.infradead.org, linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org Subject: Re: [PATCH v5 2/6] mfd: Add Rockchip mfpwm driver Date: Wed, 20 May 2026 17:38:41 +0200 Message-ID: In-Reply-To: <20260514114104.GK305027@google.com> References: <20260420-rk3576-pwm-v5-0-ae7cfbbe5427@collabora.com> <20260420-rk3576-pwm-v5-2-ae7cfbbe5427@collabora.com> <20260514114104.GK305027@google.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260520_083905_369957_E8D160B1 X-CRM114-Status: GOOD ( 67.24 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org SGkgTGVlLAoKSSdsbCByZXNwb25kIHRvIHNvbWUgcG9pbnRzIHJhaXNlZCBpbi1saW5lLiBJZiBJ IGRvbid0IHJlc3BvbmQgdG8Kc29tZXRoaW5nLCB5b3UgY2FuIGFzc3VtZSB0aGF0IEkgYWdyZWUg d2l0aCB0aGUgcG9pbnQgd2l0aCBubyBmdXJ0aGVyCmNvbW1lbnRzLCBhbmQgd2lsbCByZWN0aWZ5 IGluIHRoZSBuZXh0IHJldmlzaW9uLgoKT24gVGh1cnNkYXksIDE0IE1heSAyMDI2IDEzOjQxOjA0 IENlbnRyYWwgRXVyb3BlYW4gU3VtbWVyIFRpbWUgTGVlIEpvbmVzIHdyb3RlOgo+IE9uIE1vbiwg MjAgQXByIDIwMjYsIE5pY29sYXMgRnJhdHRhcm9saSB3cm90ZToKPiAKPiA+IFdpdGggdGhlIFJv Y2tjaGlwIFJLMzU3NiwgdGhlIFBXTSBJUCB1c2VkIGJ5IFJvY2tjaGlwIGhhcyBjaGFuZ2VkCj4g PiBzdWJzdGFudGlhbGx5LiBMb29raW5nIGF0IGJvdGggdGhlIGRvd25zdHJlYW0gcHdtLXJvY2tj aGlwIGRyaXZlciBhcwo+ID4gd2VsbCBhcyB0aGUgbWFpbmxpbmUgcHdtLXJvY2tjaGlwIGRyaXZl ciBtYWRlIGl0IGNsZWFyIHRoYXQgd2l0aCBhbGwgaXRzCj4gPiBhZGRpdGlvbmFsIGZlYXR1cmVz IGFuZCBpdHMgZGlmZmVyZW5jZXMgZnJvbSBwcmV2aW91cyBJUCByZXZpc2lvbnMsIGl0Cj4gPiBp cyBiZXN0IHN1cHBvcnRlZCBpbiBhIG5ldyBkcml2ZXIuCj4gPiAKPiA+IFRoaXMgYnJpbmdzIHVz IHRvIHRoZSBxdWVzdGlvbiBhcyB0byB3aGF0IHN1Y2ggYSBuZXcgZHJpdmVyIHNob3VsZCBiZS4K PiA+IFRvIG1lLCBpdCBzb29uIGJlY2FtZSBjbGVhciB0aGF0IGl0IHNob3VsZCBhY3R1YWxseSBi ZSBzZXZlcmFsIG5ldwo+ID4gZHJpdmVycywgbW9zdCBwcm9taW5lbnRseSB3aGVuIFV3ZSBLbGVp bmUtS8O2bmlnIGxldCBtZSBrbm93IHRoYXQgSQo+ID4gc2hvdWxkIG5vdCBpbXBsZW1lbnQgdGhl IHB3bSBzdWJzeXN0ZW0ncyBjYXB0dXJlIGNhbGxiYWNrLCBidXQgaW5zdGVhZAo+ID4gd3JpdGUg YSBjb3VudGVyIGRyaXZlciBmb3IgdGhpcyBmdW5jdGlvbmFsaXR5Lgo+ID4gCj4gPiBDb21iaW5l ZCB3aXRoIHRoZSBvdGhlciBhcy1vZi15ZXQgdW5pbXBsZW1lbnRlZCBmdW5jdGlvbmFsaXR5IG9m IHRoaXMKPiA+IG5ldyBJUCwgaXQgYmVjYW1lIGFwcGFyZW50IHRoYXQgaXQgbmVlZHMgdG8gYmUg c3ByZWFkIGFjcm9zcyBzZXZlcmFsCj4gPiBzdWJzeXN0ZW1zLgo+ID4gCj4gPiBGb3IgdGhpcyBy ZWFzb24sIHdlIGFkZCBhIG5ldyBNRkQgY29yZSBkcml2ZXIsIGNhbGxlZCBtZnB3bSAoc2hvcnQg Zm9yCj4gPiAiTXVsdGktZnVuY3Rpb24gUFdNIikuIFRoaXMgInBhcmVudCIgZHJpdmVyIG1ha2Vz IHN1cmUgdGhhdCBvbmx5IG9uZQo+ID4gZGV2aWNlIGZ1bmN0aW9uIGRyaXZlciBpcyB1c2luZyB0 aGUgZGV2aWNlIGF0IGEgdGltZSwgYW5kIGlzIGluIGNoYXJnZQo+ID4gb2YgcmVnaXN0ZXJpbmcg dGhlIE1GRCBjZWxsIGRldmljZXMgZm9yIHRoZSBpbmRpdmlkdWFsIGRldmljZSBmdW5jdGlvbnMK PiA+IG9mZmVyZWQgYnkgdGhlIGRldmljZS4KPiA+IAo+ID4gQW4gYWNxdWlyZS9yZWxlYXNlIHBh dHRlcm4gaXMgdXNlZCB0byBndWFyYW50ZWUgdGhhdCBkZXZpY2UgZnVuY3Rpb24KPiA+IGRyaXZl cnMgZG9uJ3Qgc3RlcCBvbiBlYWNoIG90aGVyJ3MgdG9lcy4KPiAKPiBUaGUgd2h5cywgd2hvcyBh bmQgd2hlcmVmb3JzIHNob3VsZCBub3QgYmUgaW5jbHVkZWQgaW4gdGhlIGNvbW1pdAo+IG1lc3Nh Z2UuICBXZSB3YW50IHRvIGtub3cgd2hhdCB5b3UncmUgdHJ5aW5nIHRvIGFjaGlldmUsIHdoeSB5 b3UncmUKPiB0cnlpbmcgdG8gYWNoaWV2ZSBpdCBhbmQgaG93IHlvdSdyZSBnb2luZyBhYm91dCBp dC4gIFRoaXMgc2hvdWxkIGJlCj4gcHVyZWx5IHRlY2huaWNhbC4gIExlYXZlIGFsbCBvZiB0aGUg Y29udmVyc2F0aW9uIGhpc3Rvcnkgb3V0IG9mIGl0Lgo+IAo+IEknbGwgYmUgaG9uZXN0LiAgQWxs IG9mIHRoaXMgYmVzcG9rZSBhY3F1aXNpdGlvbiBoYW5kbGluZyBpcyBmcmVha2luZyBtZQo+IG91 dC4gIEl0J3MgYWxtb3N0IGNlcnRhaW5seSBub3QgZ29pbmcgdG8gYWNjZXB0ZWQgbGlrZSB0aGlz LCBidXQgaW4KPiBvcmRlciB0byBoZWxwIHN1Z2dlc3QgYW4gYWx0ZXJuYXRpdmUgSSBuZWVkIHRv IHVuZGVyc3RhbmQgZXhhY3RseSB3aGF0Cj4gdGhlIHNwZWNpZmljYXRpb25zIGFyZS4KClRoZSBo YXJkd2FyZSBkb2N1bWVudGF0aW9uIGlzIGF2YWlsYWJsZSBpbiBjaGFwdGVyIDMxIG9mCmh0dHBz Oi8vb3BlbnNvdXJjZS5yb2NrLWNoaXBzLmNvbS9pbWFnZXMvMy8zNi9Sb2NrY2hpcF9SSzM1MDZf VFJNX1BhcnRfMV9WMS4yLTIwMjUwODExLnBkZgp3aGljaCBpcyBhbHNvIGxpbmtlZCB0byBpbiB0 aGUgUFdNIG91dHB1dCBkcml2ZXIuCgpUaGUgaGFyZHdhcmUgaXRzZWxmIHNoYXJlcyBhIGZldyBy ZXNvdXJjZXMgYW1vbmcgZGV2aWNlIGZ1bmN0aW9ucwp0aGF0IHJlcXVpcmUgdXMgdG8gZ3VhcmFu dGVlIG11dHVhbCBleGNsdXNpdml0eSBmb3Igc2V2ZXJhbCBvcGVyYXRpb25zLgoKVGhlIHJlc291 cmNlcyBpbiBxdWVzdGlvbnMgYXJlIHRoZSBjdXJyZW50IG9wZXJhdGluZyBtb2RlIChpbmNsdWRp bmcgdGhlCmVuYWJsZSByZWdpc3RlciksIGFuZCB0aGUgUFdNIGNsb2NrJ3MgcmF0ZS4gQWRkaXRp b25hbGx5LCBhbgptZnB3bV9hY3F1aXJlL3JlbGVhc2Ugd2lsbCBhbHNvIHRha2UgY2FyZSBvZiB0 aGUgYnVzIGNsb2NrLCB3aGljaCBuZWVkcwp0byBiZSBvbiBmb3IgcmVnaXN0ZXIgYWNjZXNzLCBh bmQgaGF2ZSBpdHMgZW5hYmxlcy9kaXNhYmxlcyBiYWxhbmNlZC4KClRoZSBhY3F1aXJlL3JlbGVh c2UgcGF0dGVybiBndWFyYW50ZWVzIG11dHVhbCBleGNsdXNpdml0eSBmb3IgdGhlc2UKcmVzb3Vy Y2VzIHdpdGggcmVlbnRyYW5jeS4gVGhpcyBtZWFucyBhbiBpbmRpdmlkdWFsIFBXTSBmdW5jdGlv biBkcml2ZXIKaW5zdGFuY2UgbWF5IHJlLWFjcXVpcmUgbWZwd20gZXZlbiB3aGlsZSBpdCdzIGFs cmVhZHkgaG9sZGluZyBpdCwgYnV0Cml0IGhhcyB0byByZWxlYXNlIGl0IHRoZSBzYW1lIG51bWJl ciBvZiB0aW1lcy4gVGhpcyBwcmV2ZW50cyBhbnkgcmFjZXkKImFtIEkgYWxyZWFkeSBob2xkaW5n IHRoaXM/IiBjaGVja3MsIGJlY2F1c2UgZXZlcnkgZW50cnkgcG9pbnQgY2FuIGp1c3QKYWNxdWly ZSB3aXRob3V0IHdvcnJ5aW5nIGFib3V0IHdoZXRoZXIgdGhlIHJlc291cmNlIGlzIGFscmVhZHkg aGVsZCBieQphbm90aGVyIHBhcnQgb2YgdGhlIHNhbWUgZHJpdmVyIGluc3RhbmNlLCBhcyBsb25n IGFzIGl0IGJhbGFuY2VzIHRoZQpjYWxscy4KCkknbSBub3Qgc3VyZSB3aGljaCBhbHJlYWR5IGV4 aXN0aW5nIGtlcm5lbCBjb25jdXJyZW5jeSBtZWNoYW5pc20gd291bGQKYmUgc3VpdGFibGUgZm9y IHJlcGxhY2luZyB0aGlzLiBTZW1hcGhvcmVzIGRvbid0IHRyYWNrIHRoZSBvd25lciwKbXV0ZXhl cyBhcmUgbm9uLXJlZW50cmFudCBhbmQgYWxzbyBkb24ndCB0cmFjayB0aGUgb3duZXIsIGFuZCB3 aGlsZSB0aGUKd3dfbXV0ZXggY291bGQgcG90ZW50aWFsbHkgYmUgdXNlZCBmb3IgdGhpcywgdGhl IGJhY2tvZmYgbWVjaGFuaXNtIHNlZW1zCmEgYml0IG92ZXJibG93biBmb3Igd2hhdCB3ZSdyZSB0 cnlpbmcgdG8gYWNoaWV2ZSBoZXJlLgoKPiAKPiA+IFNpZ25lZC1vZmYtYnk6IE5pY29sYXMgRnJh dHRhcm9saSA8bmljb2xhcy5mcmF0dGFyb2xpQGNvbGxhYm9yYS5jb20+Cj4gPiAtLS0KPiA+ICBN QUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyICsKPiA+ICBkcml2ZXJzL21m ZC9LY29uZmlnICAgICAgICAgICAgICAgIHwgIDE2ICsrCj4gPiAgZHJpdmVycy9tZmQvTWFrZWZp bGUgICAgICAgICAgICAgICB8ICAgMSArCj4gPiAgZHJpdmVycy9tZmQvcm9ja2NoaXAtbWZwd20u YyAgICAgICB8IDM1NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gPiAgaW5jbHVkZS9s aW51eC9tZmQvcm9ja2NoaXAtbWZwd20uaCB8IDQ3MCArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrCj4gPiAgNSBmaWxlcyBjaGFuZ2VkLCA4NDYgaW5zZXJ0aW9ucygrKQo+ID4g Cj4gPiBkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwo+ID4gaW5kZXggODZm MjBjYjU2M2M2Li5kNTI3MzEyNDJhMzMgMTAwNjQ0Cj4gPiAtLS0gYS9NQUlOVEFJTkVSUwo+ID4g KysrIGIvTUFJTlRBSU5FUlMKPiA+IEBAIC0yMzE3OCw2ICsyMzE3OCw4IEBAIEw6CWxpbnV4LXJv Y2tjaGlwQGxpc3RzLmluZnJhZGVhZC5vcmcKPiA+ICBMOglsaW51eC1wd21Admdlci5rZXJuZWwu b3JnCj4gPiAgUzoJTWFpbnRhaW5lZAo+ID4gIEY6CURvY3VtZW50YXRpb24vZGV2aWNldHJlZS9i aW5kaW5ncy9wd20vcm9ja2NoaXAscmszNTc2LXB3bS55YW1sCj4gPiArRjoJZHJpdmVycy9tZmQv cm9ja2NoaXAtbWZwd20uYwo+ID4gK0Y6CWluY2x1ZGUvbGludXgvbWZkL3JvY2tjaGlwLW1mcHdt LmgKPiA+ICAKPiA+ICBST0NLQ0hJUCBSSzM1NjggUkFORE9NIE5VTUJFUiBHRU5FUkFUT1IgU1VQ UE9SVAo+ID4gIE06CURhbmllbCBHb2xsZSA8ZGFuaWVsQG1ha3JvdG9waWEub3JnPgo+ID4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbWZkL0tjb25maWcgYi9kcml2ZXJzL21mZC9LY29uZmlnCj4gPiBp bmRleCA3MTkyYzlkMWQyNjguLjgwYjRlODJjNDkzNyAxMDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMv bWZkL0tjb25maWcKPiA+ICsrKyBiL2RyaXZlcnMvbWZkL0tjb25maWcKPiA+IEBAIC0xMzc4LDYg KzEzNzgsMjIgQEAgY29uZmlnIE1GRF9SQzVUNTgzCj4gPiAgCSAgQWRkaXRpb25hbCBkcml2ZXJz IG11c3QgYmUgZW5hYmxlZCBpbiBvcmRlciB0byB1c2UgdGhlCj4gPiAgCSAgZGlmZmVyZW50IGZ1 bmN0aW9uYWxpdHkgb2YgdGhlIGRldmljZS4KPiA+ICAKPiA+ICtjb25maWcgTUZEX1JPQ0tDSElQ X01GUFdNCj4gPiArCXRyaXN0YXRlICJSb2NrY2hpcCBtdWx0aS1mdW5jdGlvbiBQV00gY29udHJv bGxlciIKPiA+ICsJZGVwZW5kcyBvbiBBUkNIX1JPQ0tDSElQIHx8IENPTVBJTEVfVEVTVAo+ID4g KwlkZXBlbmRzIG9uIE9GCj4gPiArCWRlcGVuZHMgb24gSEFTX0lPTUVNCj4gPiArCWRlcGVuZHMg b24gQ09NTU9OX0NMSwo+ID4gKwlzZWxlY3QgTUZEX0NPUkUKPiA+ICsJaGVscAo+ID4gKwkgIFNv bWUgUm9ja2NoaXAgU29Dcywgc3VjaCBhcyB0aGUgUkszNTc2LCB1c2UgYSBQV00gY29udHJvbGxl ciB0aGF0IGhhcwo+ID4gKwkgIHNldmVyYWwgZGlmZmVyZW50IGZ1bmN0aW9ucywgc3VjaCBhcyBn ZW5lcmF0aW5nIFBXTSB3YXZlZm9ybXMgYnV0IGFsc28KPiA+ICsJICBjb3VudGluZyB3YXZlZm9y bXMuCj4gPiArCj4gPiArCSAgVGhpcyBkcml2ZXIgbWFuYWdlcyB0aGUgb3ZlcmFsbCBkZXZpY2Us IGFuZCBzZWxlY3RzIGJldHdlZW4gZGlmZmVyZW50Cj4gPiArCSAgZnVuY3Rpb25hbGl0aWVzIGF0 IHJ1bnRpbWUgYXMgbmVlZGVkLiBEcml2ZXJzIGZvciB0aGVtIGFyZSBpbXBsZW1lbnRlZAo+ID4g KwkgIGluIHRoZWlyIHJlc3BlY3RpdmUgc3Vic3lzdGVtcy4KPiA+ICsKPiA+ICBjb25maWcgTUZE X1JLOFhYCj4gPiAgCXRyaXN0YXRlCj4gPiAgCXNlbGVjdCBNRkRfQ09SRQo+ID4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWZkL01ha2VmaWxlIGIvZHJpdmVycy9tZmQvTWFrZWZpbGUKPiA+IGluZGV4 IGU3NWU4MDQ1YzI4YS4uZWJhZGJhZWE5ZTRhIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9tZmQv TWFrZWZpbGUKPiA+ICsrKyBiL2RyaXZlcnMvbWZkL01ha2VmaWxlCj4gPiBAQCAtMjMxLDYgKzIz MSw3IEBAIG9iai0kKENPTkZJR19NRkRfUEFMTUFTKQkrPSBwYWxtYXMubwo+ID4gIG9iai0kKENP TkZJR19NRkRfVklQRVJCT0FSRCkgICAgKz0gdmlwZXJib2FyZC5vCj4gPiAgb2JqLSQoQ09ORklH X01GRF9OVFhFQykJCSs9IG50eGVjLm8KPiA+ICBvYmotJChDT05GSUdfTUZEX1JDNVQ1ODMpCSs9 IHJjNXQ1ODMubyByYzV0NTgzLWlycS5vCj4gPiArb2JqLSQoQ09ORklHX01GRF9ST0NLQ0hJUF9N RlBXTSkJKz0gcm9ja2NoaXAtbWZwd20ubwo+ID4gIG9iai0kKENPTkZJR19NRkRfUks4WFgpCQkr PSByazh4eC1jb3JlLm8KPiA+ICBvYmotJChDT05GSUdfTUZEX1JLOFhYX0kyQykJKz0gcms4eHgt aTJjLm8KPiA+ICBvYmotJChDT05GSUdfTUZEX1JLOFhYX1NQSSkJKz0gcms4eHgtc3BpLm8KPiA+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9yb2NrY2hpcC1tZnB3bS5jIGIvZHJpdmVycy9tZmQv cm9ja2NoaXAtbWZwd20uYwo+ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAw MDAwMDAwMC4uNzJkMDQ5ODJiOTYxCj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9kcml2ZXJz L21mZC9yb2NrY2hpcC1tZnB3bS5jCj4gPiBAQCAtMCwwICsxLDM1NyBAQAo+ID4gKy8vIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9yLWxhdGVyCj4gPiArLyoKPiA+ICsgKiBDb3B5 cmlnaHQgKGMpIDIwMjUgQ29sbGFib3JhIEx0ZC4KPiA+ICsgKgo+ID4gKyAqIEEgZHJpdmVyIHRv IG1hbmFnZSBhbGwgdGhlIGRpZmZlcmVudCBmdW5jdGlvbmFsaXRpZXMgZXhwb3NlZCBieSBSb2Nr Y2hpcCdzCj4gPiArICogUFdNdjQgaGFyZHdhcmUuCj4gPiArICoKPiA+ICsgKiBUaGlzIGRyaXZl ciBpcyBjaGllZmx5IGZvY3VzZWQgb24gZ3VhcmFudGVlaW5nIG5vbi1jb25jdXJyZW50IG9wZXJh dGlvbgo+ID4gKyAqIGJldHdlZW4gdGhlIGRpZmZlcmVudCBkZXZpY2UgZnVuY3Rpb25zLCBhcyB3 ZWxsIGFzIHNldHRpbmcgdGhlIGNsb2Nrcy4KPiA+ICsgKiBJdCByZWdpc3RlcnMgdGhlIGRldmlj ZSBmdW5jdGlvbiBwbGF0Zm9ybSBkZXZpY2VzLCBlLmcuIFBXTSBvdXRwdXQgb3IKPiA+ICsgKiBQ V00gY2FwdHVyZS4KPiA+ICsgKgo+ID4gKyAqIEF1dGhvcnM6Cj4gPiArICogICAgIE5pY29sYXMg RnJhdHRhcm9saSA8bmljb2xhcy5mcmF0dGFyb2xpQGNvbGxhYm9yYS5jb20+Cj4gPiArICovCj4g PiArCj4gPiArI2luY2x1ZGUgPGxpbnV4L2FycmF5X3NpemUuaD4KPiA+ICsjaW5jbHVkZSA8bGlu dXgvY2xrLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L2Nsay1wcm92aWRlci5oPgo+ID4gKyNpbmNs dWRlIDxsaW51eC9tZmQvY29yZS5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9tZmQvcm9ja2NoaXAt bWZwd20uaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gPiArI2luY2x1ZGUgPGxp bnV4L29mLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L292ZXJmbG93Lmg+Cj4gPiArI2luY2x1ZGUg PGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5o Pgo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIHN0cnVjdCByb2NrY2hpcF9tZnB3bSAtIHByaXZhdGUg bWZwd20gZHJpdmVyIGluc3RhbmNlIHN0YXRlIHN0cnVjdAo+ID4gKyAqIEBwZGV2OiBwb2ludGVy IHRvIHRoaXMgaW5zdGFuY2UncyAmc3RydWN0IHBsYXRmb3JtX2RldmljZQo+ID4gKyAqIEBiYXNl OiBwb2ludGVyIHRvIHRoZSBtZW1vcnkgbWFwcGVkIHJlZ2lzdGVycyBvZiB0aGlzIGRldmljZQo+ ID4gKyAqIEBwd21fY2xrOiBwb2ludGVyIHRvIHRoZSBQTEwgY2xvY2sgdGhlIFBXTSBzaWduYWwg bWF5IGJlIGRlcml2ZWQgZnJvbQo+ID4gKyAqIEBvc2NfY2xrOiBwb2ludGVyIHRvIHRoZSBmaXhl ZCBjcnlzdGFsIHRoZSBQV00gc2lnbmFsIG1heSBiZSBkZXJpdmVkIGZyb20KPiA+ICsgKiBAcmNf Y2xrOiBwb2ludGVyIHRvIHRoZSBSQyBvc2NpbGxhdG9yIHRoZSBQV00gc2lnbmFsIG1heSBiZSBk ZXJpdmVkIGZyb20KPiA+ICsgKiBAY2hvc2VuX2NsazogYSBjbGstbXV4IG9mIHB3bV9jbGssIG9z Y19jbGsgYW5kIHJjX2Nsawo+ID4gKyAqIEBwY2xrOiBwb2ludGVyIHRvIHRoZSBBUEIgYnVzIGNs b2NrIG5lZWRlZCBmb3IgbW1pbyByZWdpc3RlciBhY2Nlc3MKPiA+ICsgKiBAYWN0aXZlX2Z1bmM6 IHBvaW50ZXIgdG8gdGhlIGN1cnJlbnRseSBhY3RpdmUgZGV2aWNlIGZ1bmN0aW9uLCBvciAlTlVM TCBpZiBubwo+ID4gKyAqICAgICAgICAgICAgICAgZGV2aWNlIGZ1bmN0aW9uIGlzIGN1cnJlbnRs eSBhY3RpdmVseSB1c2luZyBhbnkgb2YgdGhlIHNoYXJlZAo+ID4gKyAqICAgICAgICAgICAgICAg cmVzb3VyY2VzLiBNYXkgb25seSBiZSBjaGVja2VkL21vZGlmaWVkIHdpdGggQHN0YXRlX2xvY2sg aGVsZC4KPiA+ICsgKiBAYWNxdWlyZV9jbnQ6IG51bWJlciBvZiB0aW1lcyBAYWN0aXZlX2Z1bmMg aGFzIGN1cnJlbnRseSBtZnB3bV9hY3F1aXJlKCknZAo+ID4gKyAqICAgICAgICAgICAgICAgaXQu IE11c3Qgb25seSBiZSBjaGVja2VkIG9yIG1vZGlmaWVkIHdoaWxlIGhvbGRpbmcgQHN0YXRlX2xv Y2suCj4gPiArICogQHN0YXRlX2xvY2s6IHRoaXMgbG9jayBpcyBoZWxkIHdoaWxlIGVpdGhlciB0 aGUgYWN0aXZlIGRldmljZSBmdW5jdGlvbiwgdGhlCj4gPiArICogICAgICAgICAgICAgIGVuYWJs ZSByZWdpc3Rlciwgb3IgdGhlIGNob3NlbiBjbG9jayBpcyBiZWluZyBjaGFuZ2VkLgo+ID4gKyAq IEBpcnE6IHRoZSBJUlEgbnVtYmVyIG9mIHRoaXMgZGV2aWNlCj4gPiArICovCj4gPiArc3RydWN0 IHJvY2tjaGlwX21mcHdtIHsKPiA+ICsJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldjsKPiAK PiBJdCdzIG1vcmUgY29tbW9uIHRvIHN0b3JlICdzdHJ1Y3QgZGV2aWNlIConLgoKWWVhaCwgSSBk b24ndCBrbm93IHdoYXQgSSB3YXMgdGhpbmtpbmcuIExvb2tpbmcgdGhyb3VnaCB0aGUgcGxhY2Vz IHdoZXJlCnRoZSBwZGV2IG1lbWJlciBpcyB1c2VkLCBpdCBwcmV0dHkgbXVjaCBhbHdheXMganVz dCBnb2VzIGZvciBwZGV2LT5kZXYuCgo+IAo+ID4gKwl2b2lkIF9faW9tZW0gKmJhc2U7Cj4gPiAr CXN0cnVjdCBjbGsgKnB3bV9jbGs7Cj4gPiArCXN0cnVjdCBjbGsgKm9zY19jbGs7Cj4gPiArCXN0 cnVjdCBjbGsgKnJjX2NsazsKPiA+ICsJc3RydWN0IGNsayAqY2hvc2VuX2NsazsKPiA+ICsJc3Ry dWN0IGNsayAqcGNsazsKPiA+ICsJc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKmFjdGl2ZV9m dW5jOwo+ID4gKwl1bnNpZ25lZCBpbnQgYWNxdWlyZV9jbnQ7Cj4gPiArCXNwaW5sb2NrX3Qgc3Rh dGVfbG9jazsKPiA+ICsJaW50IGlycTsKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBhdG9taWNf dCBzdWJkZXZfaWQgPSBBVE9NSUNfSU5JVCgwKTsKPiA+ICsKPiA+ICtzdGF0aWMgaW5saW5lIHN0 cnVjdCByb2NrY2hpcF9tZnB3bSAqdG9fcm9ja2NoaXBfbWZwd20oc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKPiA+ICt7Cj4gPiArCXJldHVybiBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2 KTsKPiA+ICt9Cj4gCj4gTm8gcG9pbnRsZXNzIGFic3RyYWN0aW9ucyBwbGVhc2UuICBKdXN0IHVz ZSB0aGUgY2FsbCBkaXJlY3RseS4KPiAKPiA+ICsKPiA+ICtzdGF0aWMgaW50IG1mcHdtX2NoZWNr X3B3bWYoY29uc3Qgc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKnB3bWYsCj4gPiArCQkJICAg IGNvbnN0IGNoYXIgKmZuYW1lKQo+ID4gK3sKPiA+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnB3 bWYtPnBhcmVudC0+cGRldi0+ZGV2Owo+ID4gKwo+ID4gKwlpZiAoSVNfRVJSX09SX05VTEwocHdt ZikpIHsKPiA+ICsJCWRldl93YXJuKGRldiwgImNhbGxlZCAlcyB3aXRoIGFuIGVycm9uZW91cyBo YW5kbGUsIG5vIGVmZmVjdFxuIiwKPiA+ICsJCQkgZm5hbWUpOwo+IAo+IAo+IAo+ID4gKwkJcmV0 dXJuIC1FSU5WQUw7Cj4gPiArCX0KPiA+ICsKPiA+ICsJaWYgKElTX0VSUl9PUl9OVUxMKHB3bWYt PnBhcmVudCkpIHsKPiA+ICsJCWRldl93YXJuKGRldiwgImNhbGxlZCAlcyB3aXRoIGFuIGVycm9u ZW91cyBtZnB3bV9mdW5jIHBhcmVudCwgbm8gZWZmZWN0XG4iLAo+ID4gKwkJCSBmbmFtZSk7Cj4g PiArCQlyZXR1cm4gLUVJTlZBTDsKPiA+ICsJfQo+ID4gKwo+ID4gKwlyZXR1cm4gMDsKPiA+ICt9 Cj4gPiArCj4gPiArX19hdHRyaWJ1dGVfXygobm9ubnVsbCkpCj4gPiArc3RhdGljIGludCBtZnB3 bV9kb19hY3F1aXJlKHN0cnVjdCByb2NrY2hpcF9tZnB3bV9mdW5jICpwd21mKQo+ID4gK3sKPiA+ ICsJc3RydWN0IHJvY2tjaGlwX21mcHdtICptZnB3bSA9IHB3bWYtPnBhcmVudDsKPiA+ICsJdW5z aWduZWQgaW50IGNudDsKPiA+ICsKPiA+ICsJaWYgKG1mcHdtLT5hY3RpdmVfZnVuYyAmJiBwd21m LT5pZCAhPSBtZnB3bS0+YWN0aXZlX2Z1bmMtPmlkKQo+IAo+IENvbW1lbnRzIHRocm91Z2hvdXQg cGxlYXNlLgo+IAo+ID4gKwkJcmV0dXJuIC1FQlVTWTsKPiA+ICsKPiA+ICsJaWYgKCFtZnB3bS0+ YWN0aXZlX2Z1bmMpCj4gPiArCQltZnB3bS0+YWN0aXZlX2Z1bmMgPSBwd21mOwo+ID4gKwo+ID4g KwlpZiAoIWNoZWNrX2FkZF9vdmVyZmxvdyhtZnB3bS0+YWNxdWlyZV9jbnQsIDEsICZjbnQpKSB7 Cj4gPiArCQltZnB3bS0+YWNxdWlyZV9jbnQgPSBjbnQ7Cj4gPiArCX0gZWxzZSB7Cj4gPiArCQlk ZXZfd2FybigmbWZwd20tPnBkZXYtPmRldiwgInByZXZlbnRlZCBhY3F1aXJlIGNvdW50ZXIgb3Zl cmZsb3cgaW4gJXNcbiIsCj4gPiArCQkJIF9fZnVuY19fKTsKPiAKPiBfX2Z1bmNfX3MgYXJlIG5v dCB1c2VyIGZyaWVuZGx5LiAgVGhlIHVzZXIgZG9lcyBub3QgY2FyZSBhYm91dCBpbnRlcm5hbHMu Cj4gCj4gS2VlcCB0aGVtIGluIHlvdXIgbG9jYWwgQlNQIGlmIHlvdSBuZWVkIHRoZW0uCgpUaGVy ZSdzIG5vIGxvY2FsIEJTUCwgdGhpcyBpcyBhIGZyb20tc2NyYXRjaCBtYWlubGluZSBkcml2ZXIg YW5kIEkgYW0KYWx3YXlzIHJ1bm5pbmcgbWFpbmxpbmUuCgo+IAo+ID4gKwkJcmV0dXJuIC1FT1ZF UkZMT1c7Cj4gCj4gSG93IG1hbnkgYXJlIHlvdSBwbGFubmluZyB0byBhbGxvdz8KCkkgd2FudCB0 byBlbnN1cmUgdGhhdCBldmVuIGlmIHRoZXJlIGlzIGEgcmVzb3VyY2UgbGVha2FnZSBidWcsIGl0 CmNhbid0IGJlIGFidXNlZCBpbiBzb21lIHdheS4KCj4gCj4gPiArCX0KPiA+ICsKPiA+ICsJZGV2 X2RiZygmbWZwd20tPnBkZXYtPmRldiwgIiVkIGFjcXVpcmVkIG1mcHdtLCBhY3F1aXJlcyBub3cg YXQgJXVcbiIsCj4gPiArCQlwd21mLT5pZCwgbWZwd20tPmFjcXVpcmVfY250KTsKPiAKPiBEcm9w IHRoZSBkZWJ1ZyBwcmludHMgd2hlbiB1cHN0cmVhbWluZy4KCkFnYWluLCBuZXcgZHJpdmVyIGp1 c3QgZm9yIHVwc3RyZWFtLCBzbyBpdCB3YXMgYSBkZWxpYmVyYXRlIGNob2ljZSBieQptZSB0byBp bXBsZW1lbnQgdGhlc2UgdG8gYWlkIGluIGRlYnVnZ2luZyBuZXcgZHJpdmVycyBmb3IgdGhlIHZh cmlvdXMKb3RoZXIgZnVuY3Rpb25zIG9mIHRoaXMgaGFyZHdhcmUuIEknbGwgcmVtb3ZlIHRoZW0g dGhvdWdoIGlmIHRoaXMgaXMgYQpyZXF1aXJlbWVudC4KCj4gCj4gPiArCj4gPiArCXJldHVybiBj bGtfZW5hYmxlKG1mcHdtLT5wY2xrKTsKPiA+ICt9Cj4gPiArCj4gPiAraW50IG1mcHdtX2FjcXVp cmUoc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKnB3bWYpCj4gPiArewo+ID4gKwlzdHJ1Y3Qg cm9ja2NoaXBfbWZwd20gKm1mcHdtOwo+ID4gKwl1bnNpZ25lZCBsb25nIGZsYWdzOwo+ID4gKwlp bnQgcmV0ID0gMDsKPiA+ICsKPiA+ICsJcmV0ID0gbWZwd21fY2hlY2tfcHdtZihwd21mLCAibWZw d21fYWNxdWlyZSIpOwo+ID4gKwlpZiAocmV0KQo+ID4gKwkJcmV0dXJuIHJldDsKPiA+ICsKPiA+ ICsJbWZwd20gPSBwd21mLT5wYXJlbnQ7Cj4gPiArCWRldl9kYmcoJm1mcHdtLT5wZGV2LT5kZXYs ICIlZCBpcyBhdHRlbXB0aW5nIHRvIGFjcXVpcmVcbiIsIHB3bWYtPmlkKTsKPiA+ICsKPiA+ICsJ aWYgKCFzcGluX3RyeWxvY2tfaXJxc2F2ZSgmbWZwd20tPnN0YXRlX2xvY2ssIGZsYWdzKSkKPiA+ ICsJCXJldHVybiAtRUJVU1k7Cj4gPiArCj4gPiArCXJldCA9IG1mcHdtX2RvX2FjcXVpcmUocHdt Zik7Cj4gPiArCj4gPiArCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm1mcHdtLT5zdGF0ZV9sb2Nr LCBmbGFncyk7Cj4gPiArCj4gPiArCXJldHVybiByZXQ7Cj4gPiArfQo+ID4gK0VYUE9SVF9TWU1C T0xfTlNfR1BMKG1mcHdtX2FjcXVpcmUsICJST0NLQ0hJUF9NRlBXTSIpOwo+ID4gKwo+ID4gK19f YXR0cmlidXRlX18oKG5vbm51bGwpKQo+ID4gK3N0YXRpYyB2b2lkIG1mcHdtX2RvX3JlbGVhc2Uo Y29uc3Qgc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKnB3bWYpCj4gPiArewo+ID4gKwlzdHJ1 Y3Qgcm9ja2NoaXBfbWZwd20gKm1mcHdtID0gcHdtZi0+cGFyZW50Owo+ID4gKwo+ID4gKwlpZiAo IW1mcHdtLT5hY3RpdmVfZnVuYykKPiA+ICsJCXJldHVybjsKPiA+ICsKPiA+ICsJaWYgKG1mcHdt LT5hY3RpdmVfZnVuYy0+aWQgIT0gcHdtZi0+aWQpCj4gPiArCQlyZXR1cm47Cj4gPiArCj4gPiAr CS8qCj4gPiArCSAqIE5vIG5lZWQgdG8gY2hlY2tfc3ViX292ZXJmbG93IGhlcmUsICFtZnB3bS0+ YWN0aXZlX2Z1bmMgYWJvdmUgY2F0Y2hlcwo+ID4gKwkgKiB0aGlzIHR5cGUgb2YgcHJvYmxlbSBh bHJlYWR5Lgo+ID4gKwkgKi8KPiA+ICsJbWZwd20tPmFjcXVpcmVfY250LS07Cj4gPiArCj4gPiAr CWlmICghbWZwd20tPmFjcXVpcmVfY250KQo+ID4gKwkJbWZwd20tPmFjdGl2ZV9mdW5jID0gTlVM TDsKPiA+ICsKPiA+ICsJY2xrX2Rpc2FibGUobWZwd20tPnBjbGspOwo+ID4gK30KPiA+ICsKPiA+ ICt2b2lkIG1mcHdtX3JlbGVhc2UoY29uc3Qgc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKnB3 bWYpCj4gPiArewo+ID4gKwlzdHJ1Y3Qgcm9ja2NoaXBfbWZwd20gKm1mcHdtOwo+ID4gKwl1bnNp Z25lZCBsb25nIGZsYWdzOwo+ID4gKwo+ID4gKwlpZiAobWZwd21fY2hlY2tfcHdtZihwd21mLCAi bWZwd21fcmVsZWFzZSIpKQo+ID4gKwkJcmV0dXJuOwo+ID4gKwo+ID4gKwltZnB3bSA9IHB3bWYt PnBhcmVudDsKPiA+ICsKPiA+ICsJc3Bpbl9sb2NrX2lycXNhdmUoJm1mcHdtLT5zdGF0ZV9sb2Nr LCBmbGFncyk7Cj4gPiArCW1mcHdtX2RvX3JlbGVhc2UocHdtZik7Cj4gPiArCWRldl9kYmcoJm1m cHdtLT5wZGV2LT5kZXYsICIlZCByZWxlYXNlZCBtZnB3bSwgYWNxdWlyZXMgbm93IGF0ICV1XG4i LAo+ID4gKwkJcHdtZi0+aWQsIG1mcHdtLT5hY3F1aXJlX2NudCk7Cj4gPiArCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJm1mcHdtLT5zdGF0ZV9sb2NrLCBmbGFncyk7Cj4gPiArfQo+ID4gK0VYUE9S VF9TWU1CT0xfTlNfR1BMKG1mcHdtX3JlbGVhc2UsICJST0NLQ0hJUF9NRlBXTSIpOwo+ID4gKwo+ ID4gK2ludCBtZnB3bV9nZXRfbW9kZShjb25zdCBzdHJ1Y3Qgcm9ja2NoaXBfbWZwd21fZnVuYyAq cHdtZikKPiA+ICt7Cj4gPiArCXN0cnVjdCByb2NrY2hpcF9tZnB3bSAqbWZwd207Cj4gPiArCWlu dCByZXQ7Cj4gPiArCj4gPiArCXJldCA9IG1mcHdtX2NoZWNrX3B3bWYocHdtZiwgIm1mcHdtX2Fj cXVpcmUiKTsKPiA+ICsJaWYgKHJldCkKPiA+ICsJCXJldHVybiByZXQ7Cj4gPiArCj4gPiArCW1m cHdtID0gcHdtZi0+cGFyZW50Owo+ID4gKwo+ID4gKwlndWFyZChzcGlubG9ja19pcnFzYXZlKSgm bWZwd20tPnN0YXRlX2xvY2spOwo+ID4gKwo+ID4gKwlpZiAoIXJvY2tjaGlwX3B3bV92NF9pc19l bmFibGVkKG1mcHdtX3JlZ19yZWFkKG1mcHdtLT5iYXNlLCBQV01WNF9SRUdfRU5BQkxFKSkpCj4g Cj4gRG9uJ3QgZW1iZWQgZnVuY3Rpb24gbmFtZXMgbGlrZSB0aGlzLgoKSSBkb24ndCB1bmRlcnN0 YW5kIHRoaXMgcmV2aWV3LiBJcyB0aGUgbmFtZSAicm9ja2NoaXBfcHdtX3Y0X2lzX2VuYWJsZWQi Cm5vdCBva2F5PyBJcyBjaGFpbmluZyB0d28gZnVuY3Rpb25zIHRvZ2V0aGVyIGxpa2UgdGhpcyBu b3Qgb2theT8KCj4gCj4gPiArCQlyZXR1cm4gLTE7Cj4gCj4gLTEgaXMgbm90IGEgcmVhbCBlcnJv ciBjb2RlLgo+IAo+ID4gKwo+ID4gKwlyZXR1cm4gbWZwd21fcmVnX3JlYWQobWZwd20tPmJhc2Us IFBXTVY0X1JFR19DVFJMKSAmIFBXTVY0X01PREVfTUFTSzsKPiA+ICt9Cj4gPiArRVhQT1JUX1NZ TUJPTF9OU19HUEwobWZwd21fZ2V0X21vZGUsICJST0NLQ0hJUF9NRlBXTSIpOwo+ID4gKwo+ID4g Ky8qKgo+ID4gKyAqIG1mcHdtX3JlZ2lzdGVyX3N1YmRldiAtIHJlZ2lzdGVyIGEgc2luZ2xlIG1m cHdtX2Z1bmMKPiA+ICsgKiBAbWZwd206IHBvaW50ZXIgdG8gdGhlIHBhcmVudCAmc3RydWN0IHJv Y2tjaGlwX21mcHdtCj4gPiArICogQG5hbWU6IHN1Yi1kZXZpY2UgbmFtZSBzdHJpbmcKPiA+ICsg Kgo+ID4gKyAqIEFsbG9jYXRlIGEgc2luZ2xlICZzdHJ1Y3QgbWZwd21fZnVuYywgZmlsbCBpdHMg bWVtYmVycyB3aXRoIGFwcHJvcHJpYXRlIGRhdGEsCj4gPiArICogYW5kIHJlZ2lzdGVyIGEgbmV3 IG1mZCBjZWxsLgo+ID4gKyAqCj4gPiArICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCBuZWdhdGl2 ZSBlcnJubyBvbiBlcnJvcgo+ID4gKyAqLwo+ID4gK3N0YXRpYyBpbnQgbWZwd21fcmVnaXN0ZXJf c3ViZGV2KHN0cnVjdCByb2NrY2hpcF9tZnB3bSAqbWZwd20sCj4gPiArCQkJCSBjb25zdCBjaGFy ICpuYW1lKQo+ID4gK3sKPiA+ICsJc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKmZ1bmM7Cj4g PiArCXN0cnVjdCBtZmRfY2VsbCBjZWxsID0ge307Cj4gPiArCj4gPiArCWZ1bmMgPSBkZXZtX2t6 YWxsb2MoJm1mcHdtLT5wZGV2LT5kZXYsIHNpemVvZigqZnVuYyksIEdGUF9LRVJORUwpOwo+ID4g KwlpZiAoSVNfRVJSKGZ1bmMpKQo+ID4gKwkJcmV0dXJuIFBUUl9FUlIoZnVuYyk7Cj4gPiArCWZ1 bmMtPmlycSA9IG1mcHdtLT5pcnE7Cj4gPiArCWZ1bmMtPnBhcmVudCA9IG1mcHdtOwo+IAo+IFN1 Z2dlc3QgeW91IHVzZSB0aGUgJ3N0cnVjdCBkZXZpY2UnIGhpZXJhcmNoeSBpbnN0ZWFkIG9mIGhh bmQgcm9sbGluZwo+IHlvdXIgb3duLgo+IAo+ID4gKwlmdW5jLT5pZCA9IGF0b21pY19pbmNfcmV0 dXJuKCZzdWJkZXZfaWQpOwo+IAo+IFdoeSBkb3Nlbid0IFBMQVRGT1JNX0RFVklEX0FVVE8gd29y ayBmb3IgeW91PwoKSXQgcHJvYmFibHkgd2lsbCwgSSBqdXN0IGRpZG4ndCBrbm93IGFib3V0IGl0 LgoKPiA+ICsJZnVuYy0+YmFzZSA9IG1mcHdtLT5iYXNlOwo+ID4gKwlmdW5jLT5jb3JlID0gbWZw d20tPmNob3Nlbl9jbGs7Cj4gPiArCWNlbGwubmFtZSA9IG5hbWU7Cj4gPiArCWNlbGwucGxhdGZv cm1fZGF0YSA9IGZ1bmM7Cj4gPiArCWNlbGwucGRhdGFfc2l6ZSA9IHNpemVvZigqZnVuYyk7Cj4g PiArCj4gPiArCXJldHVybiBkZXZtX21mZF9hZGRfZGV2aWNlcygmbWZwd20tPnBkZXYtPmRldiwg ZnVuYy0+aWQsICZjZWxsLCAxLCBOVUxMLAo+ID4gKwkJCQkgICAgMCwgTlVMTCk7Cj4gPiArfQo+ ID4gKwo+ID4gK3N0YXRpYyBpbnQgbWZwd21fcmVnaXN0ZXJfc3ViZGV2cyhzdHJ1Y3Qgcm9ja2No aXBfbWZwd20gKm1mcHdtKQo+ID4gK3sKPiA+ICsJaW50IHJldDsKPiA+ICsKPiA+ICsJcmV0ID0g bWZwd21fcmVnaXN0ZXJfc3ViZGV2KG1mcHdtLCAicm9ja2NoaXAtcHdtLXY0Iik7Cj4gPiArCWlm IChyZXQpCj4gPiArCQlyZXR1cm4gcmV0Owo+ID4gKwo+ID4gKwlyZXQgPSBtZnB3bV9yZWdpc3Rl cl9zdWJkZXYobWZwd20sICJyb2NrY2hpcC1wd20tY2FwdHVyZSIpOwo+ID4gKwlpZiAocmV0KQo+ ID4gKwkJcmV0dXJuIHJldDsKPiA+ICsKPiA+ICsJcmV0dXJuIDA7Cj4gPiArfQo+IAo+IFBsYWNl IGFsbCBvZiB5b3VyIGRldmljZXMgaW4gc3RhdGljIChjb25zdCBpZiB0aGV5IGFyZSBpbW11dGFi bGUpCj4gc3RydWN0cy4gIExpdGVyYWxseSBubyBvbmUgZWxzZSBkb2VzIE1GRCByZWdpc3RyYXRp b24gbGlrZSB0aGlzIC0gZG8gbm90Cj4gcmVpbnZlbnQgdGhlIHdoZWVsLgo+IAo+ID4gK3N0YXRp YyBpbnQgcm9ja2NoaXBfbWZwd21fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK PiA+ICt7Cj4gPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4gPiArCXN0cnVj dCByb2NrY2hpcF9tZnB3bSAqbWZwd207Cj4gCj4gQ291bGQgd2UgdXNlICdkZGF0YScgZm9yIHRo ZSB2YXJpYWJsZSBpbnN0YW5jZSBuYW1lIGluc3RlYWQgb2YgJ21mcHdtJwo+IHRvIGZvbGxvdyBz dGFuZGFyZCBuYW1pbmcgY29udmVudGlvbnMgZm9yIHByaXZhdGUgZGF0YSBzdHJ1Y3R1cmVzPwo+ IAo+ID4gKwljaGFyICpjbGtfbXV4X25hbWU7Cj4gPiArCWNvbnN0IGNoYXIgKm11eF9wX25hbWVz WzNdOwo+ID4gKwlpbnQgcmV0ID0gMDsKPiA+ICsKPiA+ICsJbWZwd20gPSBkZXZtX2t6YWxsb2Mo JnBkZXYtPmRldiwgc2l6ZW9mKCptZnB3bSksIEdGUF9LRVJORUwpOwo+ID4gKwlpZiAoSVNfRVJS KG1mcHdtKSkKPiA+ICsJCXJldHVybiBQVFJfRVJSKG1mcHdtKTsKPiA+ICsKPiA+ICsJbWZwd20t PnBkZXYgPSBwZGV2Owo+ID4gKwo+ID4gKwlzcGluX2xvY2tfaW5pdCgmbWZwd20tPnN0YXRlX2xv Y2spOwo+ID4gKwo+ID4gKwltZnB3bS0+YmFzZSA9IGRldm1fcGxhdGZvcm1faW9yZW1hcF9yZXNv dXJjZShwZGV2LCAwKTsKPiA+ICsJaWYgKElTX0VSUihtZnB3bS0+YmFzZSkpCj4gPiArCQlyZXR1 cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIobWZwd20tPmJhc2UpLAo+ID4gKwkJCQkgICAg ICJmYWlsZWQgdG8gaW9yZW1hcCBhZGRyZXNzXG4iKTsKPiAKPiBEb2Vzbid0IGRldm1fcGxhdGZv cm1faW9yZW1hcF9yZXNvdXJjZSgpIGFscmVhZHkgaGF2ZSBpdHMgb3duIGVycm9yIG1lc3NhZ2Vz Pwo+IAo+ID4gKwo+ID4gKwltZnB3bS0+cGNsayA9IGRldm1fY2xrX2dldF9wcmVwYXJlZChkZXYs ICJwY2xrIik7Cj4gPiArCWlmIChJU19FUlIobWZwd20tPnBjbGspKQo+ID4gKwkJcmV0dXJuIGRl dl9lcnJfcHJvYmUoZGV2LCBQVFJfRVJSKG1mcHdtLT5wY2xrKSwKPiA+ICsJCQkJICAgICAiY291 bGRuJ3QgZ2V0IGFuZCBwcmVwYXJlICdwY2xrJyBjbG9ja1xuIik7Cj4gPiArCj4gPiArCW1mcHdt LT5pcnEgPSBwbGF0Zm9ybV9nZXRfaXJxKHBkZXYsIDApOwo+ID4gKwlpZiAobWZwd20tPmlycSA8 IDApCj4gPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIG1mcHdtLT5pcnEsICJjb3VsZG4n dCBnZXQgaXJxIDBcbiIpOwo+ID4gKwo+ID4gKwltZnB3bS0+cHdtX2NsayA9IGRldm1fY2xrX2dl dF9wcmVwYXJlZChkZXYsICJwd20iKTsKPiA+ICsJaWYgKElTX0VSUihtZnB3bS0+cHdtX2Nsaykp Cj4gPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIobWZwd20tPnB3bV9jbGsp LAo+ID4gKwkJCQkgICAgICJjb3VsZG4ndCBnZXQgYW5kIHByZXBhcmUgJ3B3bScgY2xvY2tcbiIp Owo+ID4gKwo+ID4gKwltZnB3bS0+b3NjX2NsayA9IGRldm1fY2xrX2dldF9wcmVwYXJlZChkZXYs ICJvc2MiKTsKPiA+ICsJaWYgKElTX0VSUihtZnB3bS0+b3NjX2NsaykpCj4gPiArCQlyZXR1cm4g ZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIobWZwd20tPm9zY19jbGspLAo+ID4gKwkJCQkgICAg ICJjb3VsZG4ndCBnZXQgYW5kIHByZXBhcmUgJ29zYycgY2xvY2tcbiIpOwo+ID4gKwo+ID4gKwlt ZnB3bS0+cmNfY2xrID0gZGV2bV9jbGtfZ2V0X3ByZXBhcmVkKGRldiwgInJjIik7Cj4gPiArCWlm IChJU19FUlIobWZwd20tPnJjX2NsaykpCj4gPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYs IFBUUl9FUlIobWZwd20tPnJjX2NsayksCj4gPiArCQkJCSAgICAgImNvdWxkbid0IGdldCBhbmQg cHJlcGFyZSAncmMnIGNsb2NrXG4iKTsKPiA+ICsKPiAKPiBJJ2QgZG8gdGhlc2UgaW4gYSBsb29w Lgo+IAo+ID4gKwljbGtfbXV4X25hbWUgPSBkZXZtX2thc3ByaW50ZihkZXYsIEdGUF9LRVJORUws ICIlc19jaG9zZW4iLCBkZXZfbmFtZShkZXYpKTsKPiA+ICsJaWYgKCFjbGtfbXV4X25hbWUpCj4g PiArCQlyZXR1cm4gLUVOT01FTTsKPiA+ICsKPiA+ICsJbXV4X3BfbmFtZXNbMF0gPSBfX2Nsa19n ZXRfbmFtZShtZnB3bS0+cHdtX2Nsayk7Cj4gPiArCW11eF9wX25hbWVzWzFdID0gX19jbGtfZ2V0 X25hbWUobWZwd20tPm9zY19jbGspOwo+ID4gKwltdXhfcF9uYW1lc1syXSA9IF9fY2xrX2dldF9u YW1lKG1mcHdtLT5yY19jbGspOwo+IAo+IERpZG4ndCB5b3UgYWxyZWFkeSByZXF1ZXN0IHRoZXNl IGJ5IG5hbWU/CgpJIHJlcXVlc3RlZCB0aGVtIGJhc2VkIG9uIHRoZSBuYW1lIHRoZXkgaGF2ZSBp biB0aGlzIGRldmljZSdzIGRldmljZSB0cmVlCm5vZGUncyBjbG9jay1uYW1lcyBwcm9wZXJ0eSwg d2hpY2ggaXMgbm90IHRoZSBzYW1lIGFzIHRoZSBjb21tb24gY2xvY2sKZnJhbWV3b3JrJ3MgZ2xv YmFsIG5hbWUgZm9yIHRoaXMgcGFydGljdWxhciBjbG9jay4KCj4gCj4gPiArCW1mcHdtLT5jaG9z ZW5fY2xrID0gY2xrX3JlZ2lzdGVyX211eChkZXYsIGNsa19tdXhfbmFtZSwgbXV4X3BfbmFtZXMs Cj4gCj4gZGV2bV9jbGtfaHdfcmVnaXN0ZXJfbXV4KCk/CgpJJ2xsIG5lZWQgdG8gZG91YmxlLWNo ZWNrIHdoZXRoZXIgdXNpbmcgYSBjbGtfaHctPmNsayBoYXMgdGhlIHNhbWUKc2VtYW50aWNzIGhl cmUsIGJ1dCBJIGFncmVlIHRoYXQgdGhpcyBzaG91bGQgdXNlIGEgZGV2cmVzIGhlbHBlci4KCj4g Cj4gPiArCQkJCQkgICAgIEFSUkFZX1NJWkUobXV4X3BfbmFtZXMpLAo+ID4gKwkJCQkJICAgICBD TEtfU0VUX1JBVEVfUEFSRU5ULAo+ID4gKwkJCQkJICAgICBtZnB3bS0+YmFzZSArIFBXTVY0X1JF R19DTEtfQ1RSTCwKPiA+ICsJCQkJCSAgICAgUFdNVjRfQ0xLX1NSQ19TSElGVCwgUFdNVjRfQ0xL X1NSQ19XSURUSCwKPiA+ICsJCQkJCSAgICAgQ0xLX01VWF9ISVdPUkRfTUFTSywgTlVMTCk7Cj4g PiArCXJldCA9IGNsa19wcmVwYXJlKG1mcHdtLT5jaG9zZW5fY2xrKTsKPiA+ICsJaWYgKHJldCkg ewo+ID4gKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gcHJlcGFyZSBQV00gY2xvY2sgbXV4OiAl cGVcbiIsCj4gPiArCQkJRVJSX1BUUihyZXQpKTsKPiAKPiBkZXZfZXJyX3Byb2JlKCkKPiAKPiA+ ICsJCXJldHVybiByZXQ7Cj4gPiArCX0KPiA+ICsKPiA+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEo cGRldiwgbWZwd20pOwo+ID4gKwo+ID4gKwlyZXQgPSBtZnB3bV9yZWdpc3Rlcl9zdWJkZXZzKG1m cHdtKTsKPiA+ICsJaWYgKHJldCkgewo+ID4gKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gcmVn aXN0ZXIgc3ViLWRldmljZXM6ICVwZVxuIiwKPiA+ICsJCQlFUlJfUFRSKHJldCkpOwo+IAo+ICog U2hvdWxkIHdlIHVzZSAnZGV2X2Vycl9wcm9iZSgpJyBmb3IgdGhpcyBlcnJvciBwYXRoIGFzIHdl bGwgdG8gY29ycmVjdGx5Cj4gaGFuZGxlIGRlZmVycmVkIHByb2Jpbmc/Cj4gCj4gPiArCQlyZXR1 cm4gcmV0Owo+ID4gKwl9Cj4gPiArCj4gPiArCXJldHVybiByZXQ7Cj4gPiArfQo+ID4gKwo+ID4g K3N0YXRpYyB2b2lkIHJvY2tjaGlwX21mcHdtX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQo+ID4gK3sKPiA+ICsJc3RydWN0IHJvY2tjaGlwX21mcHdtICptZnB3bSA9IHRvX3Jv Y2tjaGlwX21mcHdtKHBkZXYpOwo+ID4gKwl1bnNpZ25lZCBsb25nIGZsYWdzOwo+ID4gKwo+ID4g KwlzcGluX2xvY2tfaXJxc2F2ZSgmbWZwd20tPnN0YXRlX2xvY2ssIGZsYWdzKTsKPiA+ICsKPiA+ ICsJaWYgKG1mcHdtLT5jaG9zZW5fY2xrKSB7Cj4gPiArCQljbGtfdW5wcmVwYXJlKG1mcHdtLT5j aG9zZW5fY2xrKTsKPiAKPiBObyBkZXZtXyogdmVyc2lvbiBhdmFpbGFibGU/CgpUaGUgY29tbW9u IGNsb2NrIGZyYW1ld29yayBkb2VzIG5vdCBoYXZlIGRldnJlcyBoZWxwZXJzIGZvciBwcmVwYXJl CmFuZCB1bnByZXBhcmUgKG9yIGVuYWJsZSBhbmQgZGlzYWJsZSwgZm9yIHRoYXQgbWF0dGVyKS4g QnV0IEknZCBsaWtlCnRvIGF2b2lkIGFub3RoZXIgc2lkZXF1ZXN0IHRvIGltcGxlbWVudCB0aG9z ZSBhZnRlciBJJ3ZlIGFscmVhZHkgYmVlbgpvbiBhIHNpZGVxdWVzdCBzcGF3bmVkIGJ5IHRoaXMg c2VyaWVzIHRvIGFkZCBiaXRmaWVsZF9ody5oLgoKPiAKPiA+ICsJCWNsa191bnJlZ2lzdGVyX211 eChtZnB3bS0+Y2hvc2VuX2Nsayk7Cj4gPiArCX0KPiA+ICsKPiA+ICsJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmbWZwd20tPnN0YXRlX2xvY2ssIGZsYWdzKTsKPiA+ICt9Cj4gPiArCj4gPiArc3Rh dGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgcm9ja2NoaXBfbWZwd21fb2ZfbWF0Y2hbXSA9 IHsKPiA+ICsJewo+ID4gKwkJLmNvbXBhdGlibGUgPSAicm9ja2NoaXAscmszNTc2LXB3bSIsCj4g PiArCX0sCj4gCj4gU2luZ2xlIGxpbmUuCj4gCj4gPiArCXsgLyogc2VudGluZWwgKi8gfQo+ID4g K307Cj4gPiArTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgcm9ja2NoaXBfbWZwd21fb2ZfbWF0Y2gp Owo+ID4gKwo+ID4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHJvY2tjaGlwX21mcHdt X2RyaXZlciA9IHsKPiA+ICsJLmRyaXZlciA9IHsKPiA+ICsJCS5uYW1lID0gS0JVSUxEX01PRE5B TUUsCj4gCj4gVXNlIHRoZSByYXcgc3RyaW5nIGluc3RlYWQgLSB0aGlzIG1ha2VzIGRlYnVnZ2lu ZyBjaGFsbGVuZ2luZy4KPiAKPiA+ICsJCS5vZl9tYXRjaF90YWJsZSA9IHJvY2tjaGlwX21mcHdt X29mX21hdGNoLAo+ID4gKwl9LAo+ID4gKwkucHJvYmUgPSByb2NrY2hpcF9tZnB3bV9wcm9iZSwK PiA+ICsJLnJlbW92ZSA9IHJvY2tjaGlwX21mcHdtX3JlbW92ZSwKPiA+ICt9Owo+ID4gK21vZHVs ZV9wbGF0Zm9ybV9kcml2ZXIocm9ja2NoaXBfbWZwd21fZHJpdmVyKTsKPiA+ICsKPiA+ICtNT0RV TEVfQVVUSE9SKCJOaWNvbGFzIEZyYXR0YXJvbGkgPG5pY29sYXMuZnJhdHRhcm9saUBjb2xsYWJv cmEuY29tPiIpOwo+ID4gK01PRFVMRV9ERVNDUklQVElPTigiUm9ja2NoaXAgTUZQV00gRHJpdmVy Iik7Cj4gCj4gRldJVywgSSBkb24ndCBsaWtlIHRoZSBuYW1lLgoKVGhhdCdzIHRoZSBuYW1lIG15 IHBhcmVudHMgZ2F2ZSBtZSwgSSBjYW4ndCBoZWxwIGl0LiA6KAoKPiAKPiA+ICtNT0RVTEVfTElD RU5TRSgiR1BMIik7Cj4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tZmQvcm9ja2NoaXAt bWZwd20uaCBiL2luY2x1ZGUvbGludXgvbWZkL3JvY2tjaGlwLW1mcHdtLmgKPiAKPiBIb3cgbXVj aCBvZiB0aGlzIGZpbGUgaXMgYXBwbGljYWJsZSB0byB0aGUgY29yZSBkcml2ZXI/CgpKdXN0IFJF R19FTkFCTEUvUkVHX0NUUkwgYW5kIHJvY2tjaGlwX21mcHdtX2Z1bmMuIFRoZSByZWdpc3Rlcgpk ZWZpbml0aW9ucyBkbyBuZWVkIHRvIGxpdmUgc29tZXdoZXJlIHNoYXJlZCB0aG91Z2guIElzIHRo ZXJlIGEKcHJvYmxlbSB3aXRoIG1ha2luZyBpdCBwYXJ0IG9mIHRoZSByb2NrY2hpcC1tZnB3bS5o IGhlYWRlcj8gSWYgc28sCndoYXQgd291bGQgYSBtb3JlIGFwcHJvcHJpYXRlIHBsYWNlIGJlLCBp ZiBJIHdhbnQgdG8gbWFrZSBhbGwgMwpkcml2ZXJzIHVzZSB0aGUgc2FtZSBoZWFkZXIgZmlsZSBm b3IgaXQ/Cgo+IAo+ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAwMDAw MC4uZGJmMTU4OGE0MzgyCj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9pbmNsdWRlL2xpbnV4 L21mZC9yb2NrY2hpcC1tZnB3bS5oCj4gPiBAQCAtMCwwICsxLDQ3MCBAQAo+ID4gKy8qIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9yLWxhdGVyICovCj4gPiArLyoKPiA+ICsgKiBD b3B5cmlnaHQgKGMpIDIwMjUgQ29sbGFib3JhIEx0ZC4KPiA+ICsgKgo+ID4gKyAqIENvbW1vbiBo ZWFkZXIgZmlsZSBmb3IgYWxsIHRoZSBSb2NrY2hpcCBNdWx0aS1mdW5jdGlvbiBQV00gY29udHJv bGxlcgo+ID4gKyAqIGRyaXZlcnMgdGhhdCBhcmUgc3ByZWFkIGFjcm9zcyBzdWJzeXN0ZW1zLgo+ ID4gKyAqCj4gPiArICogQXV0aG9yczoKPiA+ICsgKiAgICAgTmljb2xhcyBGcmF0dGFyb2xpIDxu aWNvbGFzLmZyYXR0YXJvbGlAY29sbGFib3JhLmNvbT4KPiA+ICsgKi8KPiA+ICsKPiA+ICsjaWZu ZGVmIF9fU09DX1JPQ0tDSElQX01GUFdNX0hfXwo+ID4gKyNkZWZpbmUgX19TT0NfUk9DS0NISVBf TUZQV01fSF9fCj4gPiArCj4gPiArI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KPiA+ICsjaW5jbHVk ZSA8bGludXgvY2xrLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L2h3X2JpdGZpZWxkLmg+Cj4gPiAr I2luY2x1ZGUgPGxpbnV4L2lvLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+Cj4g PiArCj4gPiArc3RydWN0IHJvY2tjaGlwX21mcHdtOwo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIHN0 cnVjdCByb2NrY2hpcF9tZnB3bV9mdW5jIC0gc3RydWN0IHJlcHJlc2VudGluZyBhIHNpbmdsZSBm dW5jdGlvbiBkcml2ZXIKPiA+ICsgKgo+ID4gKyAqIEBpZDogdW5pcXVlIGlkIGZvciB0aGlzIGZ1 bmN0aW9uIGRyaXZlciBpbnN0YW5jZQo+ID4gKyAqIEBiYXNlOiBwb2ludGVyIHRvIHN0YXJ0IG9m IE1NSU8gcmVnaXN0ZXJzCj4gPiArICogQHBhcmVudDogYSBwb2ludGVyIHRvIHRoZSBwYXJlbnQg bWZwd20gc3RydWN0Cj4gPiArICogQGlycTogdGhlIHNoYXJlZCBJUlEgZ290dGVuIGZyb20gdGhl IHBhcmVudCBtZnB3bSBkZXZpY2UKPiA+ICsgKiBAY29yZTogYSBwb2ludGVyIHRvIHRoZSBjbGsg bXV4IHRoYXQgZHJpdmVzIHRoaXMgY2hhbm5lbCdzIFBXTQo+ID4gKyAqLwo+ID4gK3N0cnVjdCBy b2NrY2hpcF9tZnB3bV9mdW5jIHsKPiA+ICsJaW50IGlkOwo+ID4gKwl2b2lkIF9faW9tZW0gKmJh c2U7Cj4gPiArCXN0cnVjdCByb2NrY2hpcF9tZnB3bSAqcGFyZW50Owo+ID4gKwlpbnQgaXJxOwo+ ID4gKwlzdHJ1Y3QgY2xrICpjb3JlOwo+ID4gK307Cj4gPiArCj4gPiArLyoKPiA+ICsgKiBQV01W NCBSZWdpc3RlciBEZWZpbml0aW9ucwo+ID4gKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Cj4gPiArICoKPiA+ICsgKiBBdHRyaWJ1dGVzOgo+ID4gKyAqICBSVyAgLSBSZWFkLVdyaXRlCj4g PiArICogIFJPICAtIFJlYWQtT25seQo+ID4gKyAqICBXTyAgLSBXcml0ZS1Pbmx5Cj4gPiArICog IFcxVCAtIFdyaXRlIGhpZ2gsIFNlbGYtY2xlYXJpbmcKPiA+ICsgKiAgVzFDIC0gV3JpdGUgaGln aCB0byBjbGVhciBpbnRlcnJ1cHQKPiA+ICsgKgo+ID4gKyAqIEJpdCByYW5nZXMgdG8gYmUgdW5k ZXJzdG9vZCB3aXRoIFZlcmlsb2ctbGlrZSBzZW1hbnRpY3MsCj4gPiArICogZS5nLiBbMDM6MDBd IGlzIDQgYml0czogMCwgMSwgMiBhbmQgMy4KPiA+ICsgKgo+ID4gKyAqIEFsbCByZWdpc3RlcnMg bXVzdCBiZSBhY2Nlc3NlZCB3aXRoIDMyLWJpdCB3aWR0aCBhY2Nlc3NlcyBvbmx5Cj4gPiArICov Cj4gPiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfVkVSU0lPTgkJMHgwMDAKPiA+ICsvKgo+ID4g KyAqIFZFUlNJT04gUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MjRdIFJPICB8IEhh cmR3YXJlIE1ham9yIFZlcnNpb24KPiA+ICsgKiBbMjM6MTZdIFJPICB8IEhhcmR3YXJlIE1pbm9y IFZlcnNpb24KPiA+ICsgKiBbMTU6MTVdIFJPICB8IFJlc2VydmVkCj4gPiArICogWzE0OjE0XSBS TyAgfCBIYXJkd2FyZSBzdXBwb3J0cyBiaXBoYXNpYyBjb3VudGVycwo+ID4gKyAqIFsxMzoxM10g Uk8gIHwgSGFyZHdhcmUgc3VwcG9ydHMgZmlsdGVycwo+ID4gKyAqIFsxMjoxMl0gUk8gIHwgSGFy ZHdhcmUgc3VwcG9ydHMgd2F2ZWZvcm0gZ2VuZXJhdGlvbgo+ID4gKyAqIFsxMToxMV0gUk8gIHwg SGFyZHdhcmUgc3VwcG9ydHMgY291bnRlcgo+ID4gKyAqIFsxMDoxMF0gUk8gIHwgSGFyZHdhcmUg c3VwcG9ydHMgZnJlcXVlbmN5IG1ldGVyaW5nCj4gPiArICogWzA5OjA5XSBSTyAgfCBIYXJkd2Fy ZSBzdXBwb3J0cyBwb3dlciBrZXkgZnVuY3Rpb25hbGl0eQo+ID4gKyAqIFswODowOF0gUk8gIHwg SGFyZHdhcmUgc3VwcG9ydHMgaW5mcmFyZWQgdHJhbnNtaXNzaW9ucwo+ID4gKyAqIFswNzowNF0g Uk8gIHwgQ2hhbm5lbCBpbmRleCBvZiB0aGlzIGluc3RhbmNlCj4gPiArICogWzAzOjAwXSBSTyAg fCBOdW1iZXIgb2YgY2hhbm5lbHMgdGhlIGJhc2UgaW5zdGFuY2Ugc3VwcG9ydHMKPiA+ICsgKi8K PiA+ICsKPiA+ICsjZGVmaW5lIFBXTVY0X1JFR19FTkFCTEUJCTB4MDA0Cj4gPiArLyoKPiA+ICsg KiBFTkFCTEUgUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MTZdIFdPICB8IFdyaXRl IEVuYWJsZSBNYXNrIGZvciB0aGUgbG93ZXIgaGFsZiBvZiB0aGUgcmVnaXN0ZXIKPiA+ICsgKiAg ICAgICAgICAgICAgIFNldCBiaXQgYG5gIGhlcmUgdG8gMSBpZiB5b3Ugd2lzaCB0byBtb2RpZnkg Yml0IGBuID4+IDE2YCBpbgo+ID4gKyAqICAgICAgICAgICAgICAgdGhlIHNhbWUgd3JpdGUgb3Bl cmF0aW9uCj4gPiArICogWzE1OjA2XSBSTyAgfCBSZXNlcnZlZAo+ID4gKyAqIFswNTowNV0gUlcg IHwgUFdNIENoYW5uZWwgQ291bnRlciBSZWFkIEVuYWJsZSwgMSA9IGVuYWJsZWQKPiA+ICsgKi8K PiA+ICsjZGVmaW5lIFBXTVY0X0NITl9DTlRfUkRfRU4odikJCUZJRUxEX1BSRVBfV00xNihCSVQo NSksICh2KSkKPiA+ICsvKgo+ID4gKyAqIFswNDowNF0gVzFUIHwgUFdNIEdsb2JhbGx5IEpvaW5l ZCBDb250cm9sIEVuYWJsZQo+ID4gKyAqICAgICAgICAgICAgICAgMSA9IHRoaXMgUFdNIGNoYW5u ZWwgd2lsbCBiZSBlbmFibGVkIGJ5IGEgZ2xvYmFsIHB3bSBlbmFibGUKPiA+ICsgKiAgICAgICAg ICAgICAgIGJpdCBpbnN0ZWFkIG9mIHRoZSBQV00gRW5hYmxlIGJpdC4KPiA+ICsgKi8KPiA+ICsj ZGVmaW5lIFBXTVY0X0dMT0JBTF9DVFJMX0VOKHYpCQlGSUVMRF9QUkVQX1dNMTYoQklUKDQpLCAo dikpCj4gPiArLyoKPiA+ICsgKiBbMDM6MDNdIFJXICB8IEZvcmNlIENsb2NrIEVuYWJsZQo+ID4g KyAqICAgICAgICAgICAgICAgMCA9IGRpc2FibGVkLCBpZiB0aGUgUFdNIGNoYW5uZWwgaXMgaW5h Y3RpdmUgdGhlbiBzbyBpcyB0aGUKPiA+ICsgKiAgICAgICAgICAgICAgIGNsb2NrIHByZXNjYWxl IG1vZHVsZQo+ID4gKyAqLwo+ID4gKyNkZWZpbmUgUFdNVjRfRk9SQ0VfQ0xLX0VOKHYpCQlGSUVM RF9QUkVQX1dNMTYoQklUKDMpLCAodikpCj4gPiArLyoKPiA+ICsgKiBbMDI6MDJdIFcxVCB8IFBX TSBDb250cm9sIFVwZGF0ZSBFbmFibGUKPiA+ICsgKiAgICAgICAgICAgICAgIDEgPSBlbmFibGVk LCBjb21taXRzIG1vZGlmaWNhdGlvbnMgb2YgX0NUUkwsIF9QRVJJT0QsIF9EVVRZIGFuZAo+ID4g KyAqICAgICAgICAgICAgICAgX09GRlNFVCByZWdpc3RlcnMgb25jZSAxIGlzIHdyaXR0ZW4gdG8g aXQKPiA+ICsgKi8KPiA+ICsjZGVmaW5lIFBXTVY0X0NUUkxfVVBEQVRFX0VOCQlGSUVMRF9QUkVQ X1dNMTZfQ09OU1QoQklUKDIpLCAxKQo+ID4gKy8qCj4gPiArICogWzAxOjAxXSBSVyAgfCBQV00g RW5hYmxlLCAxID0gZW5hYmxlZAo+ID4gKyAqICAgICAgICAgICAgICAgSWYgaW4gb25lLXNob3Qg bW9kZSwgY2xlYXJzIGFmdGVyIGVuZCBvZiBvcGVyYXRpb24KPiA+ICsgKi8KPiA+ICsjZGVmaW5l IFBXTVY0X0VOX01BU0sJCQlCSVQoMSkKPiA+ICsjZGVmaW5lIFBXTVY0X0VOKHYpCQkJRklFTERf UFJFUF9XTTE2KFBXTVY0X0VOX01BU0ssIFwKPiA+ICsJCQkJCQkJKCh2KSA/IDEgOiAwKSkKPiA+ ICsvKgo+ID4gKyAqIFswMDowMF0gUlcgIHwgUFdNIENsb2NrIEVuYWJsZSwgMSA9IGVuYWJsZWQK PiA+ICsgKiAgICAgICAgICAgICAgIElmIGluIG9uZS1zaG90IG1vZGUsIGNsZWFycyBhZnRlciBl bmQgb2Ygb3BlcmF0aW9uCj4gPiArICovCj4gPiArI2RlZmluZSBQV01WNF9DTEtfRU5fTUFTSwkJ QklUKDApCj4gPiArI2RlZmluZSBQV01WNF9DTEtfRU4odikJCQlGSUVMRF9QUkVQX1dNMTYoUFdN VjRfQ0xLX0VOX01BU0ssIFwKPiA+ICsJCQkJCQkJKCh2KSA/IDEgOiAwKSkKPiA+ICsjZGVmaW5l IFBXTVY0X0VOX0JPVEhfTUFTSwkJKFBXTVY0X0VOX01BU0sgfCBQV01WNF9DTEtfRU5fTUFTSykK PiA+ICtzdGF0aWMgaW5saW5lIF9fcHVyZSBib29sIHJvY2tjaGlwX3B3bV92NF9pc19lbmFibGVk KHVuc2lnbmVkIGludCB2YWwpCj4gPiArewo+ID4gKwlyZXR1cm4gKHZhbCAmIFBXTVY0X0VOX0JP VEhfTUFTSyk7Cj4gPiArfQo+ID4gKwo+ID4gKyNkZWZpbmUgUFdNVjRfUkVHX0NMS19DVFJMCQkw eDAwOAo+ID4gKy8qCj4gPiArICogQ0xLX0NUUkwgUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsg KiBbMzE6MTZdIFdPICB8IFdyaXRlIEVuYWJsZSBNYXNrIGZvciB0aGUgbG93ZXIgaGFsZiBvZiB0 aGUgcmVnaXN0ZXIKPiA+ICsgKiAgICAgICAgICAgICAgIFNldCBiaXQgYG5gIGhlcmUgdG8gMSBp ZiB5b3Ugd2lzaCB0byBtb2RpZnkgYml0IGBuID4+IDE2YCBpbgo+ID4gKyAqICAgICAgICAgICAg ICAgdGhlIHNhbWUgd3JpdGUgb3BlcmF0aW9uCj4gPiArICogWzE1OjE1XSBSVyAgfCBDbG9jayBH bG9iYWwgU2VsZWN0aW9uCj4gPiArICogICAgICAgICAgICAgICAwID0gY3VycmVudCBjaGFubmVs IHNjYWxlIGNsb2NrCj4gPiArICogICAgICAgICAgICAgICAxID0gZ2xvYmFsIGNoYW5uZWwgc2Nh bGUgY2xvY2sKPiA+ICsgKi8KPiA+ICsjZGVmaW5lIFBXTVY0X0NMS19HTE9CQUwodikJCUZJRUxE X1BSRVBfV00xNihCSVQoMTUpLCAodikpCj4gPiArLyoKPiA+ICsgKiBbMTQ6MTNdIFJXICB8IENs b2NrIFNvdXJjZSBTZWxlY3Rpb24KPiA+ICsgKiAgICAgICAgICAgICAgIDAgPSBDbG9jayBmcm9t IFBMTCwgZnJlcXVlbmN5IGNhbiBiZSBjb25maWd1cmVkCj4gPiArICogICAgICAgICAgICAgICAx ID0gQ2xvY2sgZnJvbSBjcnlzdGFsIG9zY2lsbGF0b3IsIGZyZXF1ZW5jeSBpcyBmaXhlZAo+ID4g KyAqICAgICAgICAgICAgICAgMiA9IENsb2NrIGZyb20gUkMgb3NjaWxsYXRvciwgZnJlcXVlbmN5 IGlzIGZpeGVkCj4gPiArICogICAgICAgICAgICAgICAzID0gUmVzZXJ2ZWQKPiA+ICsgKiAgICAg ICAgICAgICAgIE5PVEU6IFRoZSBwdXJwb3NlIGZvciB0aGlzIGNsb2NrLW11eC1vdXRzaWRlLUNS VSBjb25zdHJ1Y3QgaXMKPiA+ICsgKiAgICAgICAgICAgICAgICAgICAgIHRvIGxldCB0aGUgU29D IGdvIGludG8gYSBzbGVlcCBzdGF0ZSB3aXRoIHRoZSBQV00KPiA+ICsgKiAgICAgICAgICAgICAg ICAgICAgIGhhcmR3YXJlIHN0aWxsIGhhdmluZyBhIGNsb2NrIHNpZ25hbCBmb3IgSVIgaW5wdXQs IHdoaWNoCj4gPiArICogICAgICAgICAgICAgICAgICAgICBjYW4gdGhlbiB3YWtlIHVwIHRoZSBT b0MuCj4gPiArICovCj4gPiArI2RlZmluZSBQV01WNF9DTEtfU1JDX1BMTAkJMHgwVQo+ID4gKyNk ZWZpbmUgUFdNVjRfQ0xLX1NSQ19DUllTVEFMCQkweDFVCj4gPiArI2RlZmluZSBQV01WNF9DTEtf U1JDX1JDCQkweDJVCj4gPiArI2RlZmluZSBQV01WNF9DTEtfU1JDX1NISUZUCQkxMwo+ID4gKyNk ZWZpbmUgUFdNVjRfQ0xLX1NSQ19XSURUSAkJMgo+ID4gKy8qCj4gPiArICogWzEyOjA0XSBSVyAg fCBTY2FsZSBGYWN0b3IgdG8gYXBwbHkgdG8gcHJlLXNjYWxlZCBjbG9jawo+ID4gKyAqICAgICAg ICAgICAgICAgMSA8PSB2IDw9IDI1NiwgdiBtZWFucyBjbG9jayBkaXZpZGVkIGJ5IDIqdgo+ID4g KyAqLwo+ID4gKyNkZWZpbmUgUFdNVjRfQ0xLX1NDQUxFX0YodikJCUZJRUxEX1BSRVBfV00xNihH RU5NQVNLKDEyLCA0KSwgKHYpKQo+ID4gKy8qCj4gPiArICogWzAzOjAzXSBSTyAgfCBSZXNlcnZl ZAo+ID4gKyAqIFswMjowMF0gUlcgIHwgUHJlc2NhbGUgRmFjdG9yCj4gPiArICogICAgICAgICAg ICAgICB2IGhlcmUgbWVhbnMgdGhlIGlucHV0IGNsb2NrIGlzIGRpdmlkZWQgYnkgcG93KDIsIHYp Cj4gPiArICovCj4gPiArI2RlZmluZSBQV01WNF9DTEtfUFJFU0NBTEVfRih2KQkJRklFTERfUFJF UF9XTTE2KEdFTk1BU0soMiwgMCksICh2KSkKPiA+ICsKPiA+ICsjZGVmaW5lIFBXTVY0X1JFR19D VFJMCQkJMHgwMEMKPiA+ICsvKgo+ID4gKyAqIENUUkwgUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ ICsgKiBbMzE6MTZdIFdPICB8IFdyaXRlIEVuYWJsZSBNYXNrIGZvciB0aGUgbG93ZXIgaGFsZiBv ZiB0aGUgcmVnaXN0ZXIKPiA+ICsgKiAgICAgICAgICAgICAgIFNldCBiaXQgYG5gIGhlcmUgdG8g MSBpZiB5b3Ugd2lzaCB0byBtb2RpZnkgYml0IGBuID4+IDE2YCBpbgo+ID4gKyAqICAgICAgICAg ICAgICAgdGhlIHNhbWUgd3JpdGUgb3BlcmF0aW9uCj4gPiArICogWzE1OjA5XSBSTyAgfCBSZXNl cnZlZAo+ID4gKyAqIFswODowNl0gUlcgIHwgUFdNIElucHV0IENoYW5uZWwgU2VsZWN0aW9uCj4g PiArICogICAgICAgICAgICAgICBCeSBkZWZhdWx0LCB0aGUgY2hhbm5lbCBzZWxlY3RzIGl0cyBv d24gaW5wdXQsIGJ1dCB3cml0aW5nIHYKPiA+ICsgKiAgICAgICAgICAgICAgIGhlcmUgc2VsZWN0 cyBQV00gaW5wdXQgZnJvbSBjaGFubmVsIHYgaW5zdGVhZC4KPiA+ICsgKi8KPiA+ICsjZGVmaW5l IFBXTVY0X0NUUkxfSU5fU0VMKHYpCQlGSUVMRF9QUkVQX1dNMTYoR0VOTUFTSyg4LCA2KSwgKHYp KQo+ID4gKy8qIFswNTowNV0gUlcgIHwgQWxpZ25lZCBNb2RlLCAwID0gVmFsaWQsIDEgPSBJbnZh bGlkICovCj4gPiArI2RlZmluZSBQV01WNF9DVFJMX1VOQUxJR05FRCh2KQkJRklFTERfUFJFUF9X TTE2KEJJVCg1KSwgKHYpKQo+ID4gKy8qIFswNDowNF0gUlcgIHwgT3V0cHV0IE1vZGUsIDAgPSBM ZWZ0IEFsaWduZWQsIDEgPSBDZW50cmUgQWxpZ25lZCAqLwo+ID4gKyNkZWZpbmUgUFdNVjRfTEVG VF9BTElHTkVECQkweDBVCj4gPiArI2RlZmluZSBQV01WNF9DRU5UUkVfQUxJR05FRAkJMHgxVQo+ ID4gKyNkZWZpbmUgUFdNVjRfQ1RSTF9PVVRfTU9ERSh2KQkJRklFTERfUFJFUF9XTTE2KEJJVCg0 KSwgKHYpKQo+ID4gKy8qCj4gPiArICogWzAzOjAzXSBSVyAgfCBJbmFjdGl2ZSBQb2xhcml0eSBm b3Igd2hlbiB0aGUgY2hhbm5lbCBpcyBlaXRoZXIgZGlzYWJsZWQgb3IKPiA+ICsgKiAgICAgICAg ICAgICAgIGhhcyBjb21wbGV0ZWQgb3V0cHV0dGluZyB0aGUgZW50aXJlIHdhdmVmb3JtIGluIG9u ZS1zaG90IG1vZGUuCj4gPiArICogICAgICAgICAgICAgICAwID0gTmVnYXRpdmUsIDEgPSBQb3Np dGl2ZQo+ID4gKyAqLwo+ID4gKyNkZWZpbmUgUFdNVjRfUE9MQVJJVFlfTgkJMHgwVQo+ID4gKyNk ZWZpbmUgUFdNVjRfUE9MQVJJVFlfUAkJMHgxVQo+ID4gKyNkZWZpbmUgUFdNVjRfSU5BQ1RJVkVf UE9MKHYpCQlGSUVMRF9QUkVQX1dNMTYoQklUKDMpLCAodikpCj4gPiArLyoKPiA+ICsgKiBbMDI6 MDJdIFJXICB8IER1dHkgQ3ljbGUgUG9sYXJpdHkgdG8gdXNlIGF0IHRoZSBzdGFydCBvZiB0aGUg d2F2ZWZvcm0uCj4gPiArICogICAgICAgICAgICAgICAwID0gTmVnYXRpdmUsIDEgPSBQb3NpdGl2 ZQo+ID4gKyAqLwo+ID4gKyNkZWZpbmUgUFdNVjRfRFVUWV9QT0xfU0hJRlQJCTIKPiA+ICsjZGVm aW5lIFBXTVY0X0RVVFlfUE9MX01BU0sJCUJJVChQV01WNF9EVVRZX1BPTF9TSElGVCkKPiA+ICsj ZGVmaW5lIFBXTVY0X0RVVFlfUE9MKHYpCQlGSUVMRF9QUkVQX1dNMTYoUFdNVjRfRFVUWV9QT0xf TUFTSywgXAo+ID4gKwkJCQkJCQkodikpCj4gPiArLyoKPiA+ICsgKiBbMDE6MDBdIFJXICB8IFBX TSBNb2RlCj4gPiArICogICAgICAgICAgICAgICAwID0gT25lLXNob3QgbW9kZSwgUFdNIGdlbmVy YXRlcyB3YXZlZm9ybSBSUFQgdGltZXMKPiA+ICsgKiAgICAgICAgICAgICAgIDEgPSBDb250aW51 b3VzIG1vZGUKPiA+ICsgKiAgICAgICAgICAgICAgIDIgPSBDYXB0dXJlIG1vZGUsIFBXTSBtZWFz dXJlcyBjeWNsZXMgb2YgaW5wdXQgd2F2ZWZvcm0KPiA+ICsgKiAgICAgICAgICAgICAgIDMgPSBS ZXNlcnZlZAo+ID4gKyAqLwo+ID4gKyNkZWZpbmUgUFdNVjRfTU9ERV9PTkVTSE9UCQkweDBVCj4g PiArI2RlZmluZSBQV01WNF9NT0RFX0NPTlQJCQkweDFVCj4gPiArI2RlZmluZSBQV01WNF9NT0RF X0NBUFRVUkUJCTB4MlUKPiA+ICsjZGVmaW5lIFBXTVY0X01PREVfTUFTSwkJCUdFTk1BU0soMSwg MCkKPiA+ICsjZGVmaW5lIFBXTVY0X01PREUodikJCQlGSUVMRF9QUkVQX1dNMTYoUFdNVjRfTU9E RV9NQVNLLCAodikpCj4gPiArI2RlZmluZSBQV01WNF9DVFJMX0NPTV9GTEFHUwkoUFdNVjRfSU5B Q1RJVkVfUE9MKFBXTVY0X1BPTEFSSVRZX04pIHwgXAo+ID4gKwkJCQkgUFdNVjRfRFVUWV9QT0wo UFdNVjRfUE9MQVJJVFlfUCkgfCBcCj4gPiArCQkJCSBQV01WNF9DVFJMX09VVF9NT0RFKFBXTVY0 X0xFRlRfQUxJR05FRCkgfCBcCj4gPiArCQkJCSBQV01WNF9DVFJMX1VOQUxJR05FRCh0cnVlKSkK PiA+ICsjZGVmaW5lIFBXTVY0X0NUUkxfQ09OVF9GTEFHUwkoUFdNVjRfTU9ERShQV01WNF9NT0RF X0NPTlQpIHwgXAo+ID4gKwkJCQkgUFdNVjRfQ1RSTF9DT01fRkxBR1MpCj4gPiArI2RlZmluZSBQ V01WNF9DVFJMX0NBUF9GTEFHUwkoUFdNVjRfTU9ERShQV01WNF9NT0RFX0NBUFRVUkUpIHwgXAo+ ID4gKwkJCQkgUFdNVjRfQ1RSTF9DT01fRkxBR1MpCj4gPiArCj4gPiArI2RlZmluZSBQV01WNF9S RUdfUEVSSU9ECQkweDAxMAo+ID4gKy8qCj4gPiArICogUEVSSU9EIFJlZ2lzdGVyIERlc2NyaXB0 aW9uCj4gPiArICogWzMxOjAwXSBSVyAgfCBQZXJpb2Qgb2YgdGhlIG91dHB1dCB3YXZlZm9ybQo+ ID4gKyAqICAgICAgICAgICAgICAgQ29uc3RyYWludHM6IHNob3VsZCBiZSBldmVuIGlmIENUUkxf T1VUX01PREUgaXMgQ0VOVFJFX0FMSUdORUQKPiA+ICsgKi8KPiA+ICsKPiA+ICsjZGVmaW5lIFBX TVY0X1JFR19EVVRZCQkJMHgwMTQKPiA+ICsvKgo+ID4gKyAqIERVVFkgUmVnaXN0ZXIgRGVzY3Jp cHRpb24KPiA+ICsgKiBbMzE6MDBdIFJXICB8IER1dHkgY3ljbGUgb2YgdGhlIG91dHB1dCB3YXZl Zm9ybQo+ID4gKyAqICAgICAgICAgICAgICAgQ29uc3RyYWludHM6IHNob3VsZCBiZSBldmVuIGlm IENUUkxfT1VUX01PREUgaXMgQ0VOVFJFX0FMSUdORUQKPiA+ICsgKi8KPiA+ICsKPiA+ICsjZGVm aW5lIFBXTVY0X1JFR19PRkZTRVQJCTB4MDE4Cj4gPiArLyoKPiA+ICsgKiBPRkZTRVQgUmVnaXN0 ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MDBdIFJXICB8IE9mZnNldCBvZiB0aGUgb3V0cHV0 IHdhdmVmb3JtLCBiYXNlZCBvbiB0aGUgUFdNIGNsb2NrCj4gPiArICogICAgICAgICAgICAgICBD b25zdHJhaW50czogMCA8PSB2IDw9IChQRVJJT0QgLSBEVVRZKQo+ID4gKyAqLwo+ID4gKwo+ID4g KyNkZWZpbmUgUFdNVjRfUkVHX1JQVAkJCTB4MDFDCj4gPiArLyoKPiA+ICsgKiBSUFQgUmVnaXN0 ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MTZdIFJXICB8IFNlY29uZCBkaW1lbnNpb25hbCBv ZiB0aGUgZWZmZWN0aXZlIG51bWJlciBvZiB3YXZlZm9ybQo+ID4gKyAqICAgICAgICAgICAgICAg cmVwZXRpdGlvbnMuIEluY3JlYXNlcyBieSBvbmUgZXZlcnkgZmlyc3QgZGltZW5zaW9uYWwgdGlt ZXMuCj4gPiArICogICAgICAgICAgICAgICBWYWx1ZSBgbmAgbWVhbnMgYG4gKyAxYCByZXBldGl0 aW9ucy4gVGhlIGZpbmFsIG51bWJlciBvZgo+ID4gKyAqICAgICAgICAgICAgICAgcmVwZXRpdGlv bnMgb2YgdGhlIHdhdmVmb3JtIGluIG9uZS1zaG90IG1vZGUgaXM6Cj4gPiArICogICAgICAgICAg ICAgICBgKGZpcnN0X2RpbWVuc2lvbmFsICsgMSkgKiAoc2Vjb25kX2RpbWVuc2lvbmFsICsgMSlg Cj4gPiArICogWzE1OjAwXSBSVyAgfCBGaXJzdCBkaW1lbnNpb25hbCBvZiB0aGUgZWZmZWN0aXZl IG51bWJlciBvZiB3YXZlZm9ybQo+ID4gKyAqICAgICAgICAgICAgICAgcmVwZXRpdGlvbnMuIFZh bHVlIGBuYCBtZWFucyBgbiArIDFgIHJlcGV0aXRpb25zLgo+ID4gKyAqLwo+ID4gKwo+ID4gKyNk ZWZpbmUgUFdNVjRfUkVHX0ZJTFRFUl9DVFJMCQkweDAyMAo+ID4gKy8qCj4gPiArICogRklMVEVS X0NUUkwgUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MTZdIFdPICB8IFdyaXRlIEVu YWJsZSBNYXNrIGZvciB0aGUgbG93ZXIgaGFsZiBvZiB0aGUgcmVnaXN0ZXIKPiA+ICsgKiAgICAg ICAgICAgICAgIFNldCBiaXQgYG5gIGhlcmUgdG8gMSBpZiB5b3Ugd2lzaCB0byBtb2RpZnkgYml0 IGBuID4+IDE2YCBpbgo+ID4gKyAqICAgICAgICAgICAgICAgdGhlIHNhbWUgd3JpdGUgb3BlcmF0 aW9uCj4gPiArICogWzE1OjEwXSBSTyAgfCBSZXNlcnZlZAo+ID4gKyAqIFswOTowNF0gUlcgIHwg RmlsdGVyIHdpbmRvdyBudW1iZXIKPiA+ICsgKiBbMDM6MDFdIFJPICB8IFJlc2VydmVkCj4gPiAr ICogWzAwOjAwXSBSVyAgfCBGaWx0ZXIgRW5hYmxlLCAwID0gZGlzYWJsZWQsIDEgPSBlbmFibGVk Cj4gPiArICovCj4gPiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfQ05UCQkJMHgwMjQKPiA+ICsv Kgo+ID4gKyAqIENOVCBSZWdpc3RlciBEZXNjcmlwdGlvbgo+ID4gKyAqIFszMTowMF0gUk8gIHwg Q3VycmVudCB2YWx1ZSBvZiB0aGUgUFdNIENoYW5uZWwgMCBjb3VudGVyIGluIHB3bSBjbG9jayBj eWNsZXMsCj4gPiArICogICAgICAgICAgICAgICAwIDw9IHYgPD0gMl4zMi0xCj4gPiArICovCj4g PiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfRU5BQkxFX0RFTEFZCQkweDAyOAo+ID4gKy8qCj4g PiArICogRU5BQkxFX0RFTEFZIFJlZ2lzdGVyIERlc2NyaXB0aW9uCj4gPiArICogWzMxOjE2XSBS TyAgfCBSZXNlcnZlZAo+ID4gKyAqIFsxNTowMF0gUlcgIHwgUFdNIGVuYWJsZSBkZWxheSwgaW4g YW4gdW5rbm93biB1bml0IGJ1dCBwcm9iYWJseSBjeWNsZXMKPiA+ICsgKi8KPiA+ICsKPiA+ICsj ZGVmaW5lIFBXTVY0X1JFR19IUEMJCQkweDAyQwo+ID4gKy8qCj4gPiArICogSFBDIFJlZ2lzdGVy IERlc2NyaXB0aW9uCj4gPiArICogWzMxOjAwXSBSVyAgfCBOdW1iZXIgb2YgZWZmZWN0aXZlIGhp Z2ggcG9sYXJpdHkgY3ljbGVzIG9mIHRoZSBpbnB1dCB3YXZlZm9ybQo+ID4gKyAqICAgICAgICAg ICAgICAgaW4gY2FwdHVyZSBtb2RlLiBCYXNlZCBvbiB0aGUgUFdNIGNsb2NrLiAwIDw9IHYgPD0g Ml4zMi0xCj4gPiArICovCj4gPiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfTFBDCQkJMHgwMzAK PiA+ICsvKgo+ID4gKyAqIExQQyBSZWdpc3RlciBEZXNjcmlwdGlvbgo+ID4gKyAqIFszMTowMF0g UlcgIHwgTnVtYmVyIG9mIGVmZmVjdGl2ZSBsb3cgcG9sYXJpdHkgY3ljbGVzIG9mIHRoZSBpbnB1 dCB3YXZlZm9ybQo+ID4gKyAqICAgICAgICAgICAgICAgaW4gY2FwdHVyZSBtb2RlLiBCYXNlZCBv biB0aGUgUFdNIGNsb2NrLiAwIDw9IHYgPD0gMl4zMi0xCj4gPiArICovCj4gPiArCj4gPiArI2Rl ZmluZSBQV01WNF9SRUdfQklQSEFTSUNfQ05UX0NUUkwwCTB4MDQwCj4gPiArLyoKPiA+ICsgKiBC SVBIQVNJQ19DTlRfQ1RSTDAgUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MTZdIFdP ICB8IFdyaXRlIEVuYWJsZSBNYXNrIGZvciB0aGUgbG93ZXIgaGFsZiBvZiB0aGUgcmVnaXN0ZXIK PiA+ICsgKiAgICAgICAgICAgICAgIFNldCBiaXQgYG5gIGhlcmUgdG8gMSBpZiB5b3Ugd2lzaCB0 byBtb2RpZnkgYml0IGBuID4+IDE2YCBpbgo+ID4gKyAqICAgICAgICAgICAgICAgdGhlIHNhbWUg d3JpdGUgb3BlcmF0aW9uCj4gPiArICogWzE1OjEwXSBSTyAgfCBSZXNlcnZlZAo+ID4gKyAqIFsw OTowOV0gUlcgIHwgQmlwaGFzaWMgQ291bnRlciBQaGFzZSBFZGdlIFNlbGVjdGlvbiBmb3IgbW9k ZSAwLAo+ID4gKyAqICAgICAgICAgICAgICAgMCA9IHJpc2luZyBlZGdlIChwb3NlZGdlKSwgMSA9 IGZhbGxpbmcgZWRnZSAobmVnZWRnZSkKPiA+ICsgKiBbMDg6MDhdIFJXICB8IEJpcGhhc2ljIENv dW50ZXIgQ2xvY2sgZm9yY2UgZW5hYmxlLCAxID0gZm9yY2UgZW5hYmxlCj4gPiArICogWzA3OjA3 XSBXMVQgfCBTeW5jaHJvbm91cyBFbmFibGUKPiA+ICsgKiBbMDY6MDZdIFcxVCB8IE1vZGUgU3dp dGNoCj4gPiArICogICAgICAgICAgICAgICAwID0gTm9ybWFsIE1vZGUsIDEgPSBTd2l0Y2ggdGlt ZXIgY2xvY2sgYW5kIG1lYXN1cmVkIGNsb2NrCj4gPiArICogICAgICAgICAgICAgICBDb25zdHJh aW50czogIkJpcGhhc2ljIENvdW50ZXIgTW9kZSIgbXVzdCBiZSAwIGlmIHRoaXMgaXMgMQo+ID4g KyAqIFswNTowM10gUlcgIHwgQmlwaGFzaWMgQ291bnRlciBNb2RlCj4gPiArICogICAgICAgICAg ICAgICAweDAgPSBNb2RlIDAsIDB4MSA9IE1vZGUgMSwgMHgyID0gTW9kZSAyLCAweDMgPSBNb2Rl IDMsCj4gPiArICogICAgICAgICAgICAgICAweDQgPSBNb2RlIDQsIDB4NSA9IFJlc2VydmVkCj4g PiArICogWzAyOjAyXSBSVyAgfCBCaXBoYXNpYyBDb3VudGVyIENsb2NrIFNlbGVjdGlvbgo+ID4g KyAqICAgICAgICAgICAgICAgMCA9IGNsb2NrIGlzIGZyb20gUExMIGFuZCBmcmVxdWVuY3kgY2Fu IGJlIGNvbmZpZ3VyZWQKPiA+ICsgKiAgICAgICAgICAgICAgIDEgPSBjbG9jayBpcyBmcm9tIGNy eXN0YWwgb3NjaWxsYXRvciBhbmQgZnJlcXVlbmN5IGlzIGZpeGVkCj4gPiArICogWzAxOjAxXSBS VyAgfCBCaXBoYXNpYyBDb3VudGVyIENvbnRpbnVvdXMgTW9kZQo+ID4gKyAqIFswMDowMF0gVzFU IHwgQmlwaGFzaWMgQ291bnRlciBFbmFibGUKPiA+ICsgKi8KPiA+ICsKPiA+ICsjZGVmaW5lIFBX TVY0X1JFR19CSVBIQVNJQ19DTlRfQ1RSTDEJMHgwNDQKPiA+ICsvKgo+ID4gKyAqIEJJUEhBU0lD X0NOVF9DVFJMMSBSZWdpc3RlciBEZXNjcmlwdGlvbgo+ID4gKyAqIFszMToxNl0gV08gIHwgV3Jp dGUgRW5hYmxlIE1hc2sgZm9yIHRoZSBsb3dlciBoYWxmIG9mIHRoZSByZWdpc3Rlcgo+ID4gKyAq ICAgICAgICAgICAgICAgU2V0IGJpdCBgbmAgaGVyZSB0byAxIGlmIHlvdSB3aXNoIHRvIG1vZGlm eSBiaXQgYG4gPj4gMTZgIGluCj4gPiArICogICAgICAgICAgICAgICB0aGUgc2FtZSB3cml0ZSBv cGVyYXRpb24KPiA+ICsgKiBbMTU6MTFdIFJPICB8IFJlc2VydmVkCj4gPiArICogWzEwOjA0XSBS VyAgfCBCaXBoYXNpYyBDb3VudGVyIEZpbHRlciBXaW5kb3cgTnVtYmVyCj4gPiArICogWzAzOjAx XSBSTyAgfCBSZXNlcnZlZAo+ID4gKyAqIFswMDowMF0gUlcgIHwgQmlwaGFzaWMgQ291bnRlciBG aWx0ZXIgRW5hYmxlCj4gPiArICovCj4gPiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfQklQSEFT SUNfQ05UX1RJTUVSCTB4MDQ4Cj4gPiArLyoKPiA+ICsgKiBCSVBIQVNJQ19DTlRfVElNRVIgUmVn aXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MDBdIFJXICB8IEJpcGhhc2ljIENvdW50ZXIg VGltZXIgVmFsdWUsIGluIG51bWJlciBvZiBiaXBoYXNpYyBjb3VudGVyCj4gPiArICogICAgICAg ICAgICAgICB0aW1lciBjbG9jayBjeWNsZXMKPiA+ICsgKi8KPiA+ICsKPiA+ICsjZGVmaW5lIFBX TVY0X1JFR19CSVBIQVNJQ19DTlRfUkVTCTB4MDRDCj4gPiArLyoKPiA+ICsgKiBCSVBIQVNJQ19D TlRfUkVTIFJlZ2lzdGVyIERlc2NyaXB0aW9uCj4gPiArICogWzMxOjAwXSBSTyAgfCBCaXBoYXNp YyBDb3VudGVyIFJlc3VsdCBWYWx1ZQo+ID4gKyAqICAgICAgICAgICAgICAgQ29uc3RyYWludHM6 IENhbiBvbmx5IGJlIHJlYWQgYWZ0ZXIgSU5UU1RTWzldIGlzIGFzc2VydGVkCj4gPiArICovCj4g PiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfQklQSEFTSUNfQ05UX1JFU19TCTB4MDUwCj4gPiAr LyoKPiA+ICsgKiBCSVBIQVNJQ19DTlRfUkVTX1MgUmVnaXN0ZXIgRGVzY3JpcHRpb24KPiA+ICsg KiBbMzE6MDBdIFJPICB8IEJpcGhhc2ljIENvdW50ZXIgUmVzdWx0IFZhbHVlIHdpdGggc3luY2hy b25pc2VkIHByb2Nlc3NpbmcKPiA+ICsgKiAgICAgICAgICAgICAgIENhbiBiZSByZWFkIGluIHJl YWwtdGltZSBpZiBCSVBIQVNJQ19DTlRfQ1RSTDBbN10gd2FzIHNldCB0byAxCj4gPiArICovCj4g PiArCj4gPiArI2RlZmluZSBQV01WNF9SRUdfSU5UU1RTCQkweDA3MAo+ID4gKy8qCj4gPiArICog SU5UU1RTIFJlZ2lzdGVyIERlc2NyaXB0aW9uCj4gPiArICogWzMxOjEwXSBSTyAgfCBSZXNlcnZl ZAo+ID4gKyAqIFswOTowOV0gVzFDIHwgQmlwaGFzaWMgQ291bnRlciBJbnRlcnJ1cHQgU3RhdHVz LCAxID0gaW50ZXJydXB0IGFzc2VydGVkCj4gPiArICogWzA4OjA4XSBXMUMgfCBXYXZlZm9ybSBN aWRkbGUgSW50ZXJydXB0IFN0YXR1cywgMSA9IGludGVycnVwdCBhc3NlcnRlZAo+ID4gKyAqIFsw NzowN10gVzFDIHwgV2F2ZWZvcm0gTWF4IEludGVycnVwdCBTdGF0dXMsIDEgPSBpbnRlcnJ1cHQg YXNzZXJ0ZWQKPiA+ICsgKiBbMDY6MDZdIFcxQyB8IElSIFRyYW5zbWlzc2lvbiBFbmQgSW50ZXJy dXB0IFN0YXR1cywgMSA9IGludGVycnVwdCBhc3NlcnRlZAo+ID4gKyAqIFswNTowNV0gVzFDIHwg UG93ZXIgS2V5IE1hdGNoIEludGVycnVwdCBTdGF0dXMsIDEgPSBpbnRlcnJ1cHQgYXNzZXJ0ZWQK PiA+ICsgKiBbMDQ6MDRdIFcxQyB8IEZyZXF1ZW5jeSBNZXRlciBJbnRlcnJ1cHQgU3RhdHVzLCAx ID0gaW50ZXJydXB0IGFzc2VydGVkCj4gPiArICogWzAzOjAzXSBXMUMgfCBSZWxvYWQgSW50ZXJy dXB0IFN0YXR1cywgMSA9IGludGVycnVwdCBhc3NlcnRlZAo+ID4gKyAqIFswMjowMl0gVzFDIHwg T25lc2hvdCBFbmQgSW50ZXJydXB0IFN0YXR1cywgMSA9IGludGVycnVwdCBhc3NlcnRlZAo+ID4g KyAqIFswMTowMV0gVzFDIHwgSFBDIENhcHR1cmUgSW50ZXJydXB0IFN0YXR1cywgMSA9IGludGVy cnVwdCBhc3NlcnRlZAo+ID4gKyAqIFswMDowMF0gVzFDIHwgTFBDIENhcHR1cmUgSW50ZXJydXB0 IFN0YXR1cywgMSA9IGludGVycnVwdCBhc3NlcnRlZAo+ID4gKyAqLwo+ID4gKyNkZWZpbmUgUFdN VjRfSU5UX0xQQwkJCUJJVCgwKQo+ID4gKyNkZWZpbmUgUFdNVjRfSU5UX0hQQwkJCUJJVCgxKQo+ ID4gKyNkZWZpbmUgUFdNVjRfSU5UX0xQQ19XKHYpCQlGSUVMRF9QUkVQX1dNMTYoUFdNVjRfSU5U X0xQQywgXAo+ID4gKwkJCQkJCQkoKHYpID8gMSA6IDApKQo+ID4gKyNkZWZpbmUgUFdNVjRfSU5U X0hQQ19XKHYpCQlGSUVMRF9QUkVQX1dNMTYoUFdNVjRfSU5UX0hQQywgXAo+ID4gKwkJCQkJCQko KHYpID8gMSA6IDApKQo+ID4gKwo+ID4gKyNkZWZpbmUgUFdNVjRfUkVHX0lOVF9FTgkJMHgwNzQK PiA+ICsvKgo+ID4gKyAqIElOVF9FTiBSZWdpc3RlciBEZXNjcmlwdGlvbgo+ID4gKyAqIFszMTox Nl0gV08gIHwgV3JpdGUgRW5hYmxlIE1hc2sgZm9yIHRoZSBsb3dlciBoYWxmIG9mIHRoZSByZWdp c3Rlcgo+ID4gKyAqICAgICAgICAgICAgICAgU2V0IGJpdCBgbmAgaGVyZSB0byAxIGlmIHlvdSB3 aXNoIHRvIG1vZGlmeSBiaXQgYG4gPj4gMTZgIGluCj4gPiArICogICAgICAgICAgICAgICB0aGUg c2FtZSB3cml0ZSBvcGVyYXRpb24KPiA+ICsgKiBbMTU6MTBdIFJPICB8IFJlc2VydmVkCj4gPiAr ICogWzA5OjA5XSBSVyAgfCBCaXBoYXNpYyBDb3VudGVyIEludGVycnVwdCBFbmFibGUsIDEgPSBl bmFibGVkCj4gPiArICogWzA4OjA4XSBXMUMgfCBXYXZlZm9ybSBNaWRkbGUgSW50ZXJydXB0IEVu YWJsZSwgMSA9IGVuYWJsZWQKPiA+ICsgKiBbMDc6MDddIFcxQyB8IFdhdmVmb3JtIE1heCBJbnRl cnJ1cHQgRW5hYmxlLCAxID0gZW5hYmxlZAo+ID4gKyAqIFswNjowNl0gVzFDIHwgSVIgVHJhbnNt aXNzaW9uIEVuZCBJbnRlcnJ1cHQgRW5hYmxlLCAxID0gZW5hYmxlZAo+ID4gKyAqIFswNTowNV0g VzFDIHwgUG93ZXIgS2V5IE1hdGNoIEludGVycnVwdCBFbmFibGUsIDEgPSBlbmFibGVkCj4gPiAr ICogWzA0OjA0XSBXMUMgfCBGcmVxdWVuY3kgTWV0ZXIgSW50ZXJydXB0IEVuYWJsZSwgMSA9IGVu YWJsZWQKPiA+ICsgKiBbMDM6MDNdIFcxQyB8IFJlbG9hZCBJbnRlcnJ1cHQgRW5hYmxlLCAxID0g ZW5hYmxlZAo+ID4gKyAqIFswMjowMl0gVzFDIHwgT25lc2hvdCBFbmQgSW50ZXJydXB0IEVuYWJs ZSwgMSA9IGVuYWJsZWQKPiA+ICsgKiBbMDE6MDFdIFcxQyB8IEhQQyBDYXB0dXJlIEludGVycnVw dCBFbmFibGUsIDEgPSBlbmFibGVkCj4gPiArICogWzAwOjAwXSBXMUMgfCBMUEMgQ2FwdHVyZSBJ bnRlcnJ1cHQgRW5hYmxlLCAxID0gZW5hYmxlZAo+ID4gKyAqLwo+ID4gKwo+ID4gKyNkZWZpbmUg UFdNVjRfUkVHX0lOVF9NQVNLCQkweDA3OAo+ID4gKy8qCj4gPiArICogSU5UX01BU0sgUmVnaXN0 ZXIgRGVzY3JpcHRpb24KPiA+ICsgKiBbMzE6MTZdIFdPICB8IFdyaXRlIEVuYWJsZSBNYXNrIGZv ciB0aGUgbG93ZXIgaGFsZiBvZiB0aGUgcmVnaXN0ZXIKPiA+ICsgKiAgICAgICAgICAgICAgIFNl dCBiaXQgYG5gIGhlcmUgdG8gMSBpZiB5b3Ugd2lzaCB0byBtb2RpZnkgYml0IGBuID4+IDE2YCBp bgo+ID4gKyAqICAgICAgICAgICAgICAgdGhlIHNhbWUgd3JpdGUgb3BlcmF0aW9uCj4gPiArICog WzE1OjEwXSBSTyAgfCBSZXNlcnZlZAo+ID4gKyAqIFswOTowOV0gUlcgIHwgQmlwaGFzaWMgQ291 bnRlciBJbnRlcnJ1cHQgTWFza2VkLCAxID0gbWFza2VkCj4gPiArICogWzA4OjA4XSBXMUMgfCBX YXZlZm9ybSBNaWRkbGUgSW50ZXJydXB0IE1hc2tlZCwgMSA9IG1hc2tlZAo+ID4gKyAqIFswNzow N10gVzFDIHwgV2F2ZWZvcm0gTWF4IEludGVycnVwdCBNYXNrZWQsIDEgPSBtYXNrZWQKPiA+ICsg KiBbMDY6MDZdIFcxQyB8IElSIFRyYW5zbWlzc2lvbiBFbmQgSW50ZXJydXB0IE1hc2tlZCwgMSA9 IG1hc2tlZAo+ID4gKyAqIFswNTowNV0gVzFDIHwgUG93ZXIgS2V5IE1hdGNoIEludGVycnVwdCBN YXNrZWQsIDEgPSBtYXNrZWQKPiA+ICsgKiBbMDQ6MDRdIFcxQyB8IEZyZXF1ZW5jeSBNZXRlciBJ bnRlcnJ1cHQgTWFza2VkLCAxID0gbWFza2VkCj4gPiArICogWzAzOjAzXSBXMUMgfCBSZWxvYWQg SW50ZXJydXB0IE1hc2tlZCwgMSA9IG1hc2tlZAo+ID4gKyAqIFswMjowMl0gVzFDIHwgT25lc2hv dCBFbmQgSW50ZXJydXB0IE1hc2tlZCwgMSA9IG1hc2tlZAo+ID4gKyAqIFswMTowMV0gVzFDIHwg SFBDIENhcHR1cmUgSW50ZXJydXB0IE1hc2tlZCwgMSA9IG1hc2tlZAo+ID4gKyAqIFswMDowMF0g VzFDIHwgTFBDIENhcHR1cmUgSW50ZXJydXB0IE1hc2tlZCwgMSA9IG1hc2tlZAo+ID4gKyAqLwo+ ID4gKwo+ID4gK3N0YXRpYyBpbmxpbmUgdTMyIG1mcHdtX3JlZ19yZWFkKHZvaWQgX19pb21lbSAq YmFzZSwgdTMyIHJlZykKPiA+ICt7Cj4gPiArCXJldHVybiByZWFkbChiYXNlICsgcmVnKTsKPiA+ ICt9Cj4gPiArCj4gPiArc3RhdGljIGlubGluZSB2b2lkIG1mcHdtX3JlZ193cml0ZSh2b2lkIF9f aW9tZW0gKmJhc2UsIHUzMiByZWcsIHUzMiB2YWwpCj4gPiArewo+ID4gKwl3cml0ZWwodmFsLCBi YXNlICsgcmVnKTsKPiA+ICt9Cj4gCj4gYSkgUGxlYXNlIGRvIG5vdCBhYnN0cmFjdCBmb3IgdGhl IHNha2Ugb2YgaXQuCj4gYikgUGxlYXNlIHVzZSBSZWdtYXAgaW5zdGVhZC4KCkkgYWdyZWUgYnV0 IGEpIGlzIGEgdXNlbGVzcyBhYnN0cmFjdGlvbiwgYnV0IEkgZG9uJ3QgdGhpbmsgYikgaXMKYW55 IGJldHRlciBpbiB0aGlzIGNhc2UgZWl0aGVyLiBUaGlzIGlzIGFuIG1taW8gZGV2aWNlLCBhbmQg bW1pbwpyZWdtYXBzIGFyZSBhbiBhYnN0cmFjdGlvbiB0aGF0IHByb3ZpZGUgemVybyBiZW5lZml0 IGZvciB0aGlzIGRldmljZQppbiBteSBvcGluaW9uLiBObyBjYWNoZSBpcyBuZWVkZWQgaGVyZSwg YW5kIG5vIHJlZ2lzdGVyIHNwaW5sb2NrIGlzCm5lZWRlZCBlaXRoZXIgYXMgdGhlIHJlZ2lzdGVy cyB1c2UgdGhlIFdNMTYgbWVjaGFuaXNtLiBJbiBmYWN0LCB0aGUKcmVnaXN0ZXIgc3BpbmxvY2sg d291bGQgc2xhcCBhIG1vcmUgY29hcnNlLWdyYWluZWQgbG9jayBvbiB0b3Agb2YKdGhlIGZpbmUt Z3JhaW5lZCB3YWl0LWZyZWUgYXRvbWljaXR5IHRoYXQgdGhlIGhhcmR3YXJlIGdpdmVzIHVzLgoK V2hhdCB0aGV5IGRvIG5lY2Vzc2l0YXRlIHRob3VnaCBpcyB0aGF0IGFsbCByZWFkcyBhcmUgZG9u ZSBpbnRvIGFuCm91dHB1dCBwb2ludGVyIGluc3RlYWQgb2YgYSByZXR1cm4gdmFsdWUsIGJlY2F1 c2UgdGhlIHJldHVybiB2YWx1ZQppcyB1c2VkIGZvciBjb21tdW5pY2F0aW5nIGFuIGVycm9yIGNv ZGUuIElmIEkgZGlkbid0IGlnbm9yZSB0aGUgZXJyb3IKcmV0dXJuIHZhbHVlIChJJ20gcHJldHR5 IHN1cmUgaXQncyB1c2VsZXNzIGZvciBtbWlvIHJlZ21hcHMpIHRoZW4gSQp3aWxsIGFsc28gYmUg ZG9pbmcgdW5wbGVhc2FudCBlcnJvciB1bndpbmRzIGluIGV2ZXJ5IGZ1bmN0aW9uIHRoYXQKYWNj ZXNzZXMgcmVnaXN0ZXJzLiBBbmQsIHdoZW5ldmVyIEkgd2FudCB0byBkbwoKICAgIGlmIChjb250 ZW50c19vZl9yZWdpc3RlciA9PSBmb28pCgpJIGNhbid0IGp1c3QgZG8gdGhlIHJlYWQgdGhlcmUs IEkgbmVlZCB0byByZWFkIGl0IGludG8gYSBsb2NhbCBmaXJzdApvdXRzaWRlIG9mIHRoZSBpZiBz dGF0ZW1lbnQsIGV2ZW4gaWYgSSBqdXN0IHVzZSBpdCBvbmNlLgoKSSBoYXZlLCB3aGlsZSBkZXZl bG9waW5nIHRoaXMgZHJpdmVyLCB1c2VkIHJlZ21hcHMgYmVmb3JlLCBhbmQgZGVjaWRlZAp0aGF0 IHRoZXkganVzdCBtYWtlIHRoZSBjb2RlIHdvcnNlLgoKSSBkbyBhZ3JlZSB0aG91Z2ggdGhhdCBt ZnB3bV9yZWdfcmVhZC9tZnB3bV9yZWdfd3JpdGUgc2VlbSBwb2ludGxlc3MsCkkgdGhpbmsgSSB3 YW50ZWQgaXQgdG8gdGFrZSBhbiBtZnB3bSBvbmNlIGJ1dCB0aGVuIG1hZGUgbWZwd20gcHJpdmF0 ZS4KCkknbGwgcmVmYWN0b3Igc3R1ZmYgdG8gZ2V0IHJpZCBvZiB0aGVzZSwgYnV0IEkgd29uJ3Qg dXNlIHJlZ21hcHMuCgpLaW5kIHJlZ2FyZHMsCk5pY29sYXMgRnJhdHRhcm9saQoKPiAKPiA+ICsK PiA+ICsvKioKPiA+ICsgKiBtZnB3bV9hY3F1aXJlIC0gdHJ5IGJlY29taW5nIHRoZSBhY3RpdmUg bWZwd20gZnVuY3Rpb24gZGV2aWNlCj4gPiArICogQHB3bWY6IHBvaW50ZXIgdG8gdGhlIGNhbGxp bmcgZHJpdmVyIGluc3RhbmNlJ3MgJnN0cnVjdCByb2NrY2hpcF9tZnB3bV9mdW5jCj4gPiArICoK PiA+ICsgKiBtZnB3bSBkZXZpY2UgImZ1bmN0aW9uIiBkcml2ZXJzIG11c3QgY2FsbCB0aGlzIGZ1 bmN0aW9uIGJlZm9yZSBkb2luZyBhbnl0aGluZwo+ID4gKyAqIHRoYXQgZWl0aGVyIG1vZGlmaWVz IG9yIHJlbGllcyBvbiB0aGUgcGFyZW50IGRldmljZSdzIHN0YXRlLCBzdWNoIGFzIGNsb2NrcywK PiA+ICsgKiBlbmFibGluZy9kaXNhYmxpbmcgb3V0cHV0cywgbW9kaWZ5aW5nIHNoYXJlZCByZWdz IGV0Yy4KPiA+ICsgKgo+ID4gKyAqIFRoZSByZXR1cm4gc3RhdHVlcyBzaG91bGQgYWx3YXlzIGJl IGNoZWNrZWQuCj4gPiArICoKPiA+ICsgKiBBbGwgbWZwd21fYWNxdWlyZSgpIGNhbGxzIG11c3Qg YmUgYmFsYW5jZWQgd2l0aCBjb3JyZXNwb25kaW5nIG1mcHdtX3JlbGVhc2UoKQo+ID4gKyAqIGNh bGxzIG9uY2UgdGhlIGRldmljZSBpcyBubyBsb25nZXIgbWFraW5nIGNoYW5nZXMgdGhhdCBhZmZl Y3Qgb3RoZXIgZGV2aWNlcywKPiA+ICsgKiBvciBzdG9wcyBwcm9kdWNpbmcgdXNlci12aXNpYmxl IGVmZmVjdHMgdGhhdCBkZXBlbmQgb24gdGhlIGN1cnJlbnQgZGV2aWNlCj4gPiArICogc3RhdGUg YmVpbmcga2VwdCBhcy1pcy4gKGUuZy4gYWZ0ZXIgdGhlIFBXTSBvdXRwdXQgc2lnbmFsIGlzIHN0 b3BwZWQpCj4gPiArICoKPiA+ICsgKiBUaGUgc2FtZSBkZXZpY2UgZnVuY3Rpb24gbWF5IG1mcHdt X2FjcXVpcmUoKSBtdWx0aXBsZSB0aW1lcyB3aGlsZSBpdCBhbHJlYWR5Cj4gPiArICogaXMgYWN0 aXZlLCBpLmUuIGl0IGlzIHJlLWVudHJhbnQsIHRob3VnaCBpdCBuZWVkcyB0byBiYWxhbmNlIHRo aXMgd2l0aCB0aGUKPiA+ICsgKiBzYW1lIG51bWJlciBvZiBtZnB3bV9yZWxlYXNlKCkgY2FsbHMu Cj4gPiArICoKPiA+ICsgKiBDb250ZXh0OiBUaGlzIGZ1bmN0aW9uIGRvZXMgbm90IHNsZWVwLgo+ ID4gKyAqCj4gPiArICogUmV0dXJuOgo+ID4gKyAqICogJTAgICAgICAgICAgICAgICAgIC0gc3Vj Y2Vzcwo+ID4gKyAqICogJS1FQlVTWSAgICAgICAgICAgIC0gYSBkaWZmZXJlbnQgZGV2aWNlIGZ1 bmN0aW9uIGlzIGFjdGl2ZQo+ID4gKyAqICogJS1FT1ZFUkZMT1cgICAgICAgIC0gdGhlIGFjcXVp cmUgY291bnRlciBpcyBhdCBpdHMgbWF4aW11bQo+ID4gKyAqLwo+ID4gK2V4dGVybiBpbnQgX19t dXN0X2NoZWNrIG1mcHdtX2FjcXVpcmUoc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKnB3bWYp Owo+ID4gKwo+ID4gKy8qKgo+ID4gKyAqIG1mcHdtX3JlbGVhc2UgLSBkcm9wIHVzYWdlIG9mIGFj dGl2ZSBtZnB3bSBkZXZpY2UgZnVuY3Rpb24gYnkgMQo+ID4gKyAqIEBwd21mOiBwb2ludGVyIHRv IHRoZSBjYWxsaW5nIGRyaXZlciBpbnN0YW5jZSdzICZzdHJ1Y3Qgcm9ja2NoaXBfbWZwd21fZnVu Ywo+ID4gKyAqCj4gPiArICogVGhpcyBpcyB0aGUgYmFsYW5jaW5nIGNhbGwgdG8gbWZwd21fYWNx dWlyZSgpLiBJZiBubyB1c2VycyBvZiB0aGUgZGV2aWNlCj4gPiArICogZnVuY3Rpb24gcmVtYWlu LCBzZXQgdGhlIG1mcHdtIGRldmljZSB0byBoYXZlIG5vIGFjdGl2ZSBkZXZpY2UgZnVuY3Rpb24s Cj4gPiArICogYWxsb3dpbmcgb3RoZXIgZGV2aWNlIGZ1bmN0aW9ucyB0byBjbGFpbSBpdC4KPiA+ ICsgKi8KPiA+ICtleHRlcm4gdm9pZCBtZnB3bV9yZWxlYXNlKGNvbnN0IHN0cnVjdCByb2NrY2hp cF9tZnB3bV9mdW5jICpwd21mKTsKPiA+ICsKPiA+ICsvKioKPiA+ICsgKiBtZnB3bV9nZXRfbW9k ZSAtIGdldCB0aGUgY3VycmVudCBtb2RlIHRoZSBoYXJkd2FyZSBpcyBpbgo+ID4gKyAqIEBwd21m OiBwb2ludGVyIHRvIGEgJnN0cnVjdCByb2NrY2hpcF9tZnB3bV9mdW5jCj4gPiArICoKPiA+ICsg KiBDaGVjayB0aGUgaGFyZHdhcmUgcmVnaXN0ZXJzIG9mIHRoZSBQV00gaGFyZHdhcmUgdG8gZGV0 ZXJtaW5lIHdoaWNoIG1vZGUgaXQKPiA+ICsgKiBpcyBjdXJyZW50bHkgb3BlcmF0aW5nIGluLCBp ZiBhbnkuCj4gPiArICoKPiA+ICsgKiBSZXR1cm5zOgo+ID4gKyAqICAgLSAlLUVJTlZBTCBpZiBA cHdtZiBpcyAlTlVMTCBvciBhbiBlcnJvciBwb2ludGVyCj4gPiArICogICAtICUtMSBpZiB0aGUg UFdNIGhhcmR3YXJlIGlzIG9mZiwgcmVnYXJkbGVzcyBvZiBvcGVyYXRpbmcgbW9kZQo+ID4gKyAq ICAgLSAlUFdNVjRfTU9ERV9PTkVTSE9UIGlmIFBXTSBoYXJkd2FyZSBpcyBpbiBvbmUtc2hvdCBv dXRwdXQgbW9kZQo+ID4gKyAqICAgLSAlUFdNVjRfTU9ERV9DT05UIGlmIFBXTSBoYXJkd2FyZSBp cyBpbiBjb250aW51b3VzIG91dHB1dCBtb2RlCj4gPiArICogICAtICVQV01WNF9NT0RFX0NBUFRV UkUgaWYgUFdNIGhhcmR3YXJlIGlzIGluIGNhcHR1cmUgbW9kZQo+ID4gKyAqLwo+ID4gK2V4dGVy biBpbnQgbWZwd21fZ2V0X21vZGUoY29uc3Qgc3RydWN0IHJvY2tjaGlwX21mcHdtX2Z1bmMgKnB3 bWYpOwo+ID4gKwo+ID4gKyNlbmRpZiAvKiBfX1NPQ19ST0NLQ0hJUF9NRlBXTV9IX18gKi8KPiA+ IAo+IAo+IAoKCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCkxpbnV4LXJvY2tjaGlwIG1haWxpbmcgbGlzdApMaW51eC1yb2NrY2hpcEBsaXN0cy5pbmZy YWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGlu dXgtcm9ja2NoaXAK From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from sender4-pp-f112.zoho.com (sender4-pp-f112.zoho.com [136.143.188.112]) (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 4E808285072; Wed, 20 May 2026 15:39:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=136.143.188.112 ARC-Seal:i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779291565; cv=pass; b=tSnFAryDt45Zk0P9alvLwEz4y3szrH6qmOp+bwBsNIjtRXMB9FebdBPbbYix/k+XrykkQSVSmM10o6WKRoQ86rQCXc/QsuK9BgojfBcBNXwytG+PfxyntGYmfanwYRLmzDjH3VFffyvVwHcHRkZ5p4gbNwwmD9VjHEeQp6J5ePc= ARC-Message-Signature:i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779291565; c=relaxed/simple; bh=veEWfkG+DPHwWG+PByD2mdmc16XE+niN3Jq2GQPP064=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=maKktZlu2Sp6zAvBuuZQL120CUNpba/GN6d2ruxCmqK9z9zK+CbKfksuH2RayVgsuO9HeHzKMM37YJD72rKNcvKwnpHE+3oIXG4D4RAz38fn+YeLI/bXYYEPBONfPUs9n4WZE7ws+J7oUprjXh0aj3wHxj4Kk6ZCC+HT8IBWa3M= ARC-Authentication-Results:i=2; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com; spf=pass smtp.mailfrom=collabora.com; dkim=pass (1024-bit key) header.d=collabora.com header.i=nicolas.frattaroli@collabora.com header.b=Puq+tOIK; arc=pass smtp.client-ip=136.143.188.112 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=collabora.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=collabora.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=collabora.com header.i=nicolas.frattaroli@collabora.com header.b="Puq+tOIK" ARC-Seal: i=1; a=rsa-sha256; t=1779291529; cv=none; d=zohomail.com; s=zohoarc; b=QXzTTY8XLE2auMgRO6+JIJ6sNAEG5Cqne5meClPMm2TeipsjAVnEeDmEChFCpAkcZMs+xbYHAZ14CRGGhPuXJL95N3YaloIqtXldg6hM8Kt3zxg9xJ17UuYOOWGw5l73O92RpnPgWT0raWw8gpX6ipGHIdRltXfieCjiUbc5cOM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1779291529; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:MIME-Version:Message-ID:References:Subject:Subject:To:To:Message-Id:Reply-To; bh=Xm9nnVCBYy+blSkynAKkLYL8et0xsHtZkmtd1aUF37I=; b=Dr5rl2tPqE8mgAfPvblU00j3AH9g2IQlQNB3QIX+1nXT/IQ2Zd+b66v7vrltLgZMVdvdTiryLha47SFdcyPoJeGj3K/1/sZdWC1ip07eSZzqen8pCCSnCN2NZ3kBwSV6VqASl3jbnzWKkgHcSjnR97z4ur0p0gvS4T0BQ+K3ljE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass header.i=collabora.com; spf=pass smtp.mailfrom=nicolas.frattaroli@collabora.com; dmarc=pass header.from= DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1779291529; s=zohomail; d=collabora.com; i=nicolas.frattaroli@collabora.com; h=From:From:To:To:Cc:Cc:Subject:Subject:Date:Date:Message-ID:In-Reply-To:References:MIME-Version:Content-Transfer-Encoding:Content-Type:Message-Id:Reply-To; bh=Xm9nnVCBYy+blSkynAKkLYL8et0xsHtZkmtd1aUF37I=; b=Puq+tOIKnsNrVbqKBhyw9fQN41vpdVnwKr0g3zS8WtZwwLfUMcmo9LGkbPMN+ORi v1pRPz91WgLw0CYnmmC1B94nctZSaOa25D63TFqEjUZz+XhXPK1keY/42fq1EO2Jt+r wWLB4fM2I2l7AyLhgU4eDBdJnA/Fta1Qdgm6gq9k= Received: by mx.zohomail.com with SMTPS id 1779291527165842.2027965159605; Wed, 20 May 2026 08:38:47 -0700 (PDT) From: Nicolas Frattaroli To: Lee Jones Cc: Uwe =?UTF-8?B?S2xlaW5lLUvDtm5pZw==?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Heiko Stuebner , William Breathitt Gray , Damon Ding , kernel@collabora.com, Jonas Karlman , Alexey Charkov , linux-rockchip@lists.infradead.org, linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org Subject: Re: [PATCH v5 2/6] mfd: Add Rockchip mfpwm driver Date: Wed, 20 May 2026 17:38:41 +0200 Message-ID: In-Reply-To: <20260514114104.GK305027@google.com> References: <20260420-rk3576-pwm-v5-0-ae7cfbbe5427@collabora.com> <20260420-rk3576-pwm-v5-2-ae7cfbbe5427@collabora.com> <20260514114104.GK305027@google.com> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Hi Lee, I'll respond to some points raised in-line. If I don't respond to something, you can assume that I agree with the point with no further comments, and will rectify in the next revision. On Thursday, 14 May 2026 13:41:04 Central European Summer Time Lee Jones wr= ote: > On Mon, 20 Apr 2026, Nicolas Frattaroli wrote: >=20 > > With the Rockchip RK3576, the PWM IP used by Rockchip has changed > > substantially. Looking at both the downstream pwm-rockchip driver as > > well as the mainline pwm-rockchip driver made it clear that with all its > > additional features and its differences from previous IP revisions, it > > is best supported in a new driver. > >=20 > > This brings us to the question as to what such a new driver should be. > > To me, it soon became clear that it should actually be several new > > drivers, most prominently when Uwe Kleine-K=C3=B6nig let me know that I > > should not implement the pwm subsystem's capture callback, but instead > > write a counter driver for this functionality. > >=20 > > Combined with the other as-of-yet unimplemented functionality of this > > new IP, it became apparent that it needs to be spread across several > > subsystems. > >=20 > > For this reason, we add a new MFD core driver, called mfpwm (short for > > "Multi-function PWM"). This "parent" driver makes sure that only one > > device function driver is using the device at a time, and is in charge > > of registering the MFD cell devices for the individual device functions > > offered by the device. > >=20 > > An acquire/release pattern is used to guarantee that device function > > drivers don't step on each other's toes. >=20 > The whys, whos and wherefors should not be included in the commit > message. We want to know what you're trying to achieve, why you're > trying to achieve it and how you're going about it. This should be > purely technical. Leave all of the conversation history out of it. >=20 > I'll be honest. All of this bespoke acquisition handling is freaking me > out. It's almost certainly not going to accepted like this, but in > order to help suggest an alternative I need to understand exactly what > the specifications are. The hardware documentation is available in chapter 31 of https://opensource.rock-chips.com/images/3/36/Rockchip_RK3506_TRM_Part_1_V1= =2E2-20250811.pdf which is also linked to in the PWM output driver. The hardware itself shares a few resources among device functions that require us to guarantee mutual exclusivity for several operations. The resources in questions are the current operating mode (including the enable register), and the PWM clock's rate. Additionally, an mfpwm_acquire/release will also take care of the bus clock, which needs to be on for register access, and have its enables/disables balanced. The acquire/release pattern guarantees mutual exclusivity for these resources with reentrancy. This means an individual PWM function driver instance may re-acquire mfpwm even while it's already holding it, but it has to release it the same number of times. This prevents any racey "am I already holding this?" checks, because every entry point can just acquire without worrying about whether the resource is already held by another part of the same driver instance, as long as it balances the calls. I'm not sure which already existing kernel concurrency mechanism would be suitable for replacing this. Semaphores don't track the owner, mutexes are non-reentrant and also don't track the owner, and while the ww_mutex could potentially be used for this, the backoff mechanism seems a bit overblown for what we're trying to achieve here. >=20 > > Signed-off-by: Nicolas Frattaroli > > --- > > MAINTAINERS | 2 + > > drivers/mfd/Kconfig | 16 ++ > > drivers/mfd/Makefile | 1 + > > drivers/mfd/rockchip-mfpwm.c | 357 ++++++++++++++++++++++++++++ > > include/linux/mfd/rockchip-mfpwm.h | 470 +++++++++++++++++++++++++++++= ++++++++ > > 5 files changed, 846 insertions(+) > >=20 > > diff --git a/MAINTAINERS b/MAINTAINERS > > index 86f20cb563c6..d52731242a33 100644 > > --- a/MAINTAINERS > > +++ b/MAINTAINERS > > @@ -23178,6 +23178,8 @@ L: linux-rockchip@lists.infradead.org > > L: linux-pwm@vger.kernel.org > > S: Maintained > > F: Documentation/devicetree/bindings/pwm/rockchip,rk3576-pwm.yaml > > +F: drivers/mfd/rockchip-mfpwm.c > > +F: include/linux/mfd/rockchip-mfpwm.h > > =20 > > ROCKCHIP RK3568 RANDOM NUMBER GENERATOR SUPPORT > > M: Daniel Golle > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > > index 7192c9d1d268..80b4e82c4937 100644 > > --- a/drivers/mfd/Kconfig > > +++ b/drivers/mfd/Kconfig > > @@ -1378,6 +1378,22 @@ config MFD_RC5T583 > > Additional drivers must be enabled in order to use the > > different functionality of the device. > > =20 > > +config MFD_ROCKCHIP_MFPWM > > + tristate "Rockchip multi-function PWM controller" > > + depends on ARCH_ROCKCHIP || COMPILE_TEST > > + depends on OF > > + depends on HAS_IOMEM > > + depends on COMMON_CLK > > + select MFD_CORE > > + help > > + Some Rockchip SoCs, such as the RK3576, use a PWM controller that h= as > > + several different functions, such as generating PWM waveforms but a= lso > > + counting waveforms. > > + > > + This driver manages the overall device, and selects between differe= nt > > + functionalities at runtime as needed. Drivers for them are implemen= ted > > + in their respective subsystems. > > + > > config MFD_RK8XX > > tristate > > select MFD_CORE > > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > > index e75e8045c28a..ebadbaea9e4a 100644 > > --- a/drivers/mfd/Makefile > > +++ b/drivers/mfd/Makefile > > @@ -231,6 +231,7 @@ obj-$(CONFIG_MFD_PALMAS) +=3D palmas.o > > obj-$(CONFIG_MFD_VIPERBOARD) +=3D viperboard.o > > obj-$(CONFIG_MFD_NTXEC) +=3D ntxec.o > > obj-$(CONFIG_MFD_RC5T583) +=3D rc5t583.o rc5t583-irq.o > > +obj-$(CONFIG_MFD_ROCKCHIP_MFPWM) +=3D rockchip-mfpwm.o > > obj-$(CONFIG_MFD_RK8XX) +=3D rk8xx-core.o > > obj-$(CONFIG_MFD_RK8XX_I2C) +=3D rk8xx-i2c.o > > obj-$(CONFIG_MFD_RK8XX_SPI) +=3D rk8xx-spi.o > > diff --git a/drivers/mfd/rockchip-mfpwm.c b/drivers/mfd/rockchip-mfpwm.c > > new file mode 100644 > > index 000000000000..72d04982b961 > > --- /dev/null > > +++ b/drivers/mfd/rockchip-mfpwm.c > > @@ -0,0 +1,357 @@ > > +// SPDX-License-Identifier: GPL-2.0-or-later > > +/* > > + * Copyright (c) 2025 Collabora Ltd. > > + * > > + * A driver to manage all the different functionalities exposed by Roc= kchip's > > + * PWMv4 hardware. > > + * > > + * This driver is chiefly focused on guaranteeing non-concurrent opera= tion > > + * between the different device functions, as well as setting the cloc= ks. > > + * It registers the device function platform devices, e.g. PWM output = or > > + * PWM capture. > > + * > > + * Authors: > > + * Nicolas Frattaroli > > + */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +/** > > + * struct rockchip_mfpwm - private mfpwm driver instance state struct > > + * @pdev: pointer to this instance's &struct platform_device > > + * @base: pointer to the memory mapped registers of this device > > + * @pwm_clk: pointer to the PLL clock the PWM signal may be derived fr= om > > + * @osc_clk: pointer to the fixed crystal the PWM signal may be derive= d from > > + * @rc_clk: pointer to the RC oscillator the PWM signal may be derived= from > > + * @chosen_clk: a clk-mux of pwm_clk, osc_clk and rc_clk > > + * @pclk: pointer to the APB bus clock needed for mmio register access > > + * @active_func: pointer to the currently active device function, or %= NULL if no > > + * device function is currently actively using any of th= e shared > > + * resources. May only be checked/modified with @state_l= ock held. > > + * @acquire_cnt: number of times @active_func has currently mfpwm_acqu= ire()'d > > + * it. Must only be checked or modified while holding @s= tate_lock. > > + * @state_lock: this lock is held while either the active device funct= ion, the > > + * enable register, or the chosen clock is being changed. > > + * @irq: the IRQ number of this device > > + */ > > +struct rockchip_mfpwm { > > + struct platform_device *pdev; >=20 > It's more common to store 'struct device *'. Yeah, I don't know what I was thinking. Looking through the places where the pdev member is used, it pretty much always just goes for pdev->dev. >=20 > > + void __iomem *base; > > + struct clk *pwm_clk; > > + struct clk *osc_clk; > > + struct clk *rc_clk; > > + struct clk *chosen_clk; > > + struct clk *pclk; > > + struct rockchip_mfpwm_func *active_func; > > + unsigned int acquire_cnt; > > + spinlock_t state_lock; > > + int irq; > > +}; > > + > > +static atomic_t subdev_id =3D ATOMIC_INIT(0); > > + > > +static inline struct rockchip_mfpwm *to_rockchip_mfpwm(struct platform= _device *pdev) > > +{ > > + return platform_get_drvdata(pdev); > > +} >=20 > No pointless abstractions please. Just use the call directly. >=20 > > + > > +static int mfpwm_check_pwmf(const struct rockchip_mfpwm_func *pwmf, > > + const char *fname) > > +{ > > + struct device *dev =3D &pwmf->parent->pdev->dev; > > + > > + if (IS_ERR_OR_NULL(pwmf)) { > > + dev_warn(dev, "called %s with an erroneous handle, no effect\n", > > + fname); >=20 >=20 >=20 > > + return -EINVAL; > > + } > > + > > + if (IS_ERR_OR_NULL(pwmf->parent)) { > > + dev_warn(dev, "called %s with an erroneous mfpwm_func parent, no eff= ect\n", > > + fname); > > + return -EINVAL; > > + } > > + > > + return 0; > > +} > > + > > +__attribute__((nonnull)) > > +static int mfpwm_do_acquire(struct rockchip_mfpwm_func *pwmf) > > +{ > > + struct rockchip_mfpwm *mfpwm =3D pwmf->parent; > > + unsigned int cnt; > > + > > + if (mfpwm->active_func && pwmf->id !=3D mfpwm->active_func->id) >=20 > Comments throughout please. >=20 > > + return -EBUSY; > > + > > + if (!mfpwm->active_func) > > + mfpwm->active_func =3D pwmf; > > + > > + if (!check_add_overflow(mfpwm->acquire_cnt, 1, &cnt)) { > > + mfpwm->acquire_cnt =3D cnt; > > + } else { > > + dev_warn(&mfpwm->pdev->dev, "prevented acquire counter overflow in %= s\n", > > + __func__); >=20 > __func__s are not user friendly. The user does not care about internals. >=20 > Keep them in your local BSP if you need them. There's no local BSP, this is a from-scratch mainline driver and I am always running mainline. >=20 > > + return -EOVERFLOW; >=20 > How many are you planning to allow? I want to ensure that even if there is a resource leakage bug, it can't be abused in some way. >=20 > > + } > > + > > + dev_dbg(&mfpwm->pdev->dev, "%d acquired mfpwm, acquires now at %u\n", > > + pwmf->id, mfpwm->acquire_cnt); >=20 > Drop the debug prints when upstreaming. Again, new driver just for upstream, so it was a deliberate choice by me to implement these to aid in debugging new drivers for the various other functions of this hardware. I'll remove them though if this is a requirement. >=20 > > + > > + return clk_enable(mfpwm->pclk); > > +} > > + > > +int mfpwm_acquire(struct rockchip_mfpwm_func *pwmf) > > +{ > > + struct rockchip_mfpwm *mfpwm; > > + unsigned long flags; > > + int ret =3D 0; > > + > > + ret =3D mfpwm_check_pwmf(pwmf, "mfpwm_acquire"); > > + if (ret) > > + return ret; > > + > > + mfpwm =3D pwmf->parent; > > + dev_dbg(&mfpwm->pdev->dev, "%d is attempting to acquire\n", pwmf->id); > > + > > + if (!spin_trylock_irqsave(&mfpwm->state_lock, flags)) > > + return -EBUSY; > > + > > + ret =3D mfpwm_do_acquire(pwmf); > > + > > + spin_unlock_irqrestore(&mfpwm->state_lock, flags); > > + > > + return ret; > > +} > > +EXPORT_SYMBOL_NS_GPL(mfpwm_acquire, "ROCKCHIP_MFPWM"); > > + > > +__attribute__((nonnull)) > > +static void mfpwm_do_release(const struct rockchip_mfpwm_func *pwmf) > > +{ > > + struct rockchip_mfpwm *mfpwm =3D pwmf->parent; > > + > > + if (!mfpwm->active_func) > > + return; > > + > > + if (mfpwm->active_func->id !=3D pwmf->id) > > + return; > > + > > + /* > > + * No need to check_sub_overflow here, !mfpwm->active_func above catc= hes > > + * this type of problem already. > > + */ > > + mfpwm->acquire_cnt--; > > + > > + if (!mfpwm->acquire_cnt) > > + mfpwm->active_func =3D NULL; > > + > > + clk_disable(mfpwm->pclk); > > +} > > + > > +void mfpwm_release(const struct rockchip_mfpwm_func *pwmf) > > +{ > > + struct rockchip_mfpwm *mfpwm; > > + unsigned long flags; > > + > > + if (mfpwm_check_pwmf(pwmf, "mfpwm_release")) > > + return; > > + > > + mfpwm =3D pwmf->parent; > > + > > + spin_lock_irqsave(&mfpwm->state_lock, flags); > > + mfpwm_do_release(pwmf); > > + dev_dbg(&mfpwm->pdev->dev, "%d released mfpwm, acquires now at %u\n", > > + pwmf->id, mfpwm->acquire_cnt); > > + spin_unlock_irqrestore(&mfpwm->state_lock, flags); > > +} > > +EXPORT_SYMBOL_NS_GPL(mfpwm_release, "ROCKCHIP_MFPWM"); > > + > > +int mfpwm_get_mode(const struct rockchip_mfpwm_func *pwmf) > > +{ > > + struct rockchip_mfpwm *mfpwm; > > + int ret; > > + > > + ret =3D mfpwm_check_pwmf(pwmf, "mfpwm_acquire"); > > + if (ret) > > + return ret; > > + > > + mfpwm =3D pwmf->parent; > > + > > + guard(spinlock_irqsave)(&mfpwm->state_lock); > > + > > + if (!rockchip_pwm_v4_is_enabled(mfpwm_reg_read(mfpwm->base, PWMV4_REG= _ENABLE))) >=20 > Don't embed function names like this. I don't understand this review. Is the name "rockchip_pwm_v4_is_enabled" not okay? Is chaining two functions together like this not okay? >=20 > > + return -1; >=20 > -1 is not a real error code. >=20 > > + > > + return mfpwm_reg_read(mfpwm->base, PWMV4_REG_CTRL) & PWMV4_MODE_MASK; > > +} > > +EXPORT_SYMBOL_NS_GPL(mfpwm_get_mode, "ROCKCHIP_MFPWM"); > > + > > +/** > > + * mfpwm_register_subdev - register a single mfpwm_func > > + * @mfpwm: pointer to the parent &struct rockchip_mfpwm > > + * @name: sub-device name string > > + * > > + * Allocate a single &struct mfpwm_func, fill its members with appropr= iate data, > > + * and register a new mfd cell. > > + * > > + * Returns: 0 on success, negative errno on error > > + */ > > +static int mfpwm_register_subdev(struct rockchip_mfpwm *mfpwm, > > + const char *name) > > +{ > > + struct rockchip_mfpwm_func *func; > > + struct mfd_cell cell =3D {}; > > + > > + func =3D devm_kzalloc(&mfpwm->pdev->dev, sizeof(*func), GFP_KERNEL); > > + if (IS_ERR(func)) > > + return PTR_ERR(func); > > + func->irq =3D mfpwm->irq; > > + func->parent =3D mfpwm; >=20 > Suggest you use the 'struct device' hierarchy instead of hand rolling > your own. >=20 > > + func->id =3D atomic_inc_return(&subdev_id); >=20 > Why dosen't PLATFORM_DEVID_AUTO work for you? It probably will, I just didn't know about it. > > + func->base =3D mfpwm->base; > > + func->core =3D mfpwm->chosen_clk; > > + cell.name =3D name; > > + cell.platform_data =3D func; > > + cell.pdata_size =3D sizeof(*func); > > + > > + return devm_mfd_add_devices(&mfpwm->pdev->dev, func->id, &cell, 1, NU= LL, > > + 0, NULL); > > +} > > + > > +static int mfpwm_register_subdevs(struct rockchip_mfpwm *mfpwm) > > +{ > > + int ret; > > + > > + ret =3D mfpwm_register_subdev(mfpwm, "rockchip-pwm-v4"); > > + if (ret) > > + return ret; > > + > > + ret =3D mfpwm_register_subdev(mfpwm, "rockchip-pwm-capture"); > > + if (ret) > > + return ret; > > + > > + return 0; > > +} >=20 > Place all of your devices in static (const if they are immutable) > structs. Literally no one else does MFD registration like this - do not > reinvent the wheel. >=20 > > +static int rockchip_mfpwm_probe(struct platform_device *pdev) > > +{ > > + struct device *dev =3D &pdev->dev; > > + struct rockchip_mfpwm *mfpwm; >=20 > Could we use 'ddata' for the variable instance name instead of 'mfpwm' > to follow standard naming conventions for private data structures? >=20 > > + char *clk_mux_name; > > + const char *mux_p_names[3]; > > + int ret =3D 0; > > + > > + mfpwm =3D devm_kzalloc(&pdev->dev, sizeof(*mfpwm), GFP_KERNEL); > > + if (IS_ERR(mfpwm)) > > + return PTR_ERR(mfpwm); > > + > > + mfpwm->pdev =3D pdev; > > + > > + spin_lock_init(&mfpwm->state_lock); > > + > > + mfpwm->base =3D devm_platform_ioremap_resource(pdev, 0); > > + if (IS_ERR(mfpwm->base)) > > + return dev_err_probe(dev, PTR_ERR(mfpwm->base), > > + "failed to ioremap address\n"); >=20 > Doesn't devm_platform_ioremap_resource() already have its own error messa= ges? >=20 > > + > > + mfpwm->pclk =3D devm_clk_get_prepared(dev, "pclk"); > > + if (IS_ERR(mfpwm->pclk)) > > + return dev_err_probe(dev, PTR_ERR(mfpwm->pclk), > > + "couldn't get and prepare 'pclk' clock\n"); > > + > > + mfpwm->irq =3D platform_get_irq(pdev, 0); > > + if (mfpwm->irq < 0) > > + return dev_err_probe(dev, mfpwm->irq, "couldn't get irq 0\n"); > > + > > + mfpwm->pwm_clk =3D devm_clk_get_prepared(dev, "pwm"); > > + if (IS_ERR(mfpwm->pwm_clk)) > > + return dev_err_probe(dev, PTR_ERR(mfpwm->pwm_clk), > > + "couldn't get and prepare 'pwm' clock\n"); > > + > > + mfpwm->osc_clk =3D devm_clk_get_prepared(dev, "osc"); > > + if (IS_ERR(mfpwm->osc_clk)) > > + return dev_err_probe(dev, PTR_ERR(mfpwm->osc_clk), > > + "couldn't get and prepare 'osc' clock\n"); > > + > > + mfpwm->rc_clk =3D devm_clk_get_prepared(dev, "rc"); > > + if (IS_ERR(mfpwm->rc_clk)) > > + return dev_err_probe(dev, PTR_ERR(mfpwm->rc_clk), > > + "couldn't get and prepare 'rc' clock\n"); > > + >=20 > I'd do these in a loop. >=20 > > + clk_mux_name =3D devm_kasprintf(dev, GFP_KERNEL, "%s_chosen", dev_nam= e(dev)); > > + if (!clk_mux_name) > > + return -ENOMEM; > > + > > + mux_p_names[0] =3D __clk_get_name(mfpwm->pwm_clk); > > + mux_p_names[1] =3D __clk_get_name(mfpwm->osc_clk); > > + mux_p_names[2] =3D __clk_get_name(mfpwm->rc_clk); >=20 > Didn't you already request these by name? I requested them based on the name they have in this device's device tree node's clock-names property, which is not the same as the common clock framework's global name for this particular clock. >=20 > > + mfpwm->chosen_clk =3D clk_register_mux(dev, clk_mux_name, mux_p_names, >=20 > devm_clk_hw_register_mux()? I'll need to double-check whether using a clk_hw->clk has the same semantics here, but I agree that this should use a devres helper. >=20 > > + ARRAY_SIZE(mux_p_names), > > + CLK_SET_RATE_PARENT, > > + mfpwm->base + PWMV4_REG_CLK_CTRL, > > + PWMV4_CLK_SRC_SHIFT, PWMV4_CLK_SRC_WIDTH, > > + CLK_MUX_HIWORD_MASK, NULL); > > + ret =3D clk_prepare(mfpwm->chosen_clk); > > + if (ret) { > > + dev_err(dev, "failed to prepare PWM clock mux: %pe\n", > > + ERR_PTR(ret)); >=20 > dev_err_probe() >=20 > > + return ret; > > + } > > + > > + platform_set_drvdata(pdev, mfpwm); > > + > > + ret =3D mfpwm_register_subdevs(mfpwm); > > + if (ret) { > > + dev_err(dev, "failed to register sub-devices: %pe\n", > > + ERR_PTR(ret)); >=20 > * Should we use 'dev_err_probe()' for this error path as well to correctly > handle deferred probing? >=20 > > + return ret; > > + } > > + > > + return ret; > > +} > > + > > +static void rockchip_mfpwm_remove(struct platform_device *pdev) > > +{ > > + struct rockchip_mfpwm *mfpwm =3D to_rockchip_mfpwm(pdev); > > + unsigned long flags; > > + > > + spin_lock_irqsave(&mfpwm->state_lock, flags); > > + > > + if (mfpwm->chosen_clk) { > > + clk_unprepare(mfpwm->chosen_clk); >=20 > No devm_* version available? The common clock framework does not have devres helpers for prepare and unprepare (or enable and disable, for that matter). But I'd like to avoid another sidequest to implement those after I've already been on a sidequest spawned by this series to add bitfield_hw.h. >=20 > > + clk_unregister_mux(mfpwm->chosen_clk); > > + } > > + > > + spin_unlock_irqrestore(&mfpwm->state_lock, flags); > > +} > > + > > +static const struct of_device_id rockchip_mfpwm_of_match[] =3D { > > + { > > + .compatible =3D "rockchip,rk3576-pwm", > > + }, >=20 > Single line. >=20 > > + { /* sentinel */ } > > +}; > > +MODULE_DEVICE_TABLE(of, rockchip_mfpwm_of_match); > > + > > +static struct platform_driver rockchip_mfpwm_driver =3D { > > + .driver =3D { > > + .name =3D KBUILD_MODNAME, >=20 > Use the raw string instead - this makes debugging challenging. >=20 > > + .of_match_table =3D rockchip_mfpwm_of_match, > > + }, > > + .probe =3D rockchip_mfpwm_probe, > > + .remove =3D rockchip_mfpwm_remove, > > +}; > > +module_platform_driver(rockchip_mfpwm_driver); > > + > > +MODULE_AUTHOR("Nicolas Frattaroli "); > > +MODULE_DESCRIPTION("Rockchip MFPWM Driver"); >=20 > FWIW, I don't like the name. That's the name my parents gave me, I can't help it. :( >=20 > > +MODULE_LICENSE("GPL"); > > diff --git a/include/linux/mfd/rockchip-mfpwm.h b/include/linux/mfd/roc= kchip-mfpwm.h >=20 > How much of this file is applicable to the core driver? Just REG_ENABLE/REG_CTRL and rockchip_mfpwm_func. The register definitions do need to live somewhere shared though. Is there a problem with making it part of the rockchip-mfpwm.h header? If so, what would a more appropriate place be, if I want to make all 3 drivers use the same header file for it? >=20 > > new file mode 100644 > > index 000000000000..dbf1588a4382 > > --- /dev/null > > +++ b/include/linux/mfd/rockchip-mfpwm.h > > @@ -0,0 +1,470 @@ > > +/* SPDX-License-Identifier: GPL-2.0-or-later */ > > +/* > > + * Copyright (c) 2025 Collabora Ltd. > > + * > > + * Common header file for all the Rockchip Multi-function PWM controll= er > > + * drivers that are spread across subsystems. > > + * > > + * Authors: > > + * Nicolas Frattaroli > > + */ > > + > > +#ifndef __SOC_ROCKCHIP_MFPWM_H__ > > +#define __SOC_ROCKCHIP_MFPWM_H__ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +struct rockchip_mfpwm; > > + > > +/** > > + * struct rockchip_mfpwm_func - struct representing a single function = driver > > + * > > + * @id: unique id for this function driver instance > > + * @base: pointer to start of MMIO registers > > + * @parent: a pointer to the parent mfpwm struct > > + * @irq: the shared IRQ gotten from the parent mfpwm device > > + * @core: a pointer to the clk mux that drives this channel's PWM > > + */ > > +struct rockchip_mfpwm_func { > > + int id; > > + void __iomem *base; > > + struct rockchip_mfpwm *parent; > > + int irq; > > + struct clk *core; > > +}; > > + > > +/* > > + * PWMV4 Register Definitions > > + * -------------------------- > > + * > > + * Attributes: > > + * RW - Read-Write > > + * RO - Read-Only > > + * WO - Write-Only > > + * W1T - Write high, Self-clearing > > + * W1C - Write high to clear interrupt > > + * > > + * Bit ranges to be understood with Verilog-like semantics, > > + * e.g. [03:00] is 4 bits: 0, 1, 2 and 3. > > + * > > + * All registers must be accessed with 32-bit width accesses only > > + */ > > + > > +#define PWMV4_REG_VERSION 0x000 > > +/* > > + * VERSION Register Description > > + * [31:24] RO | Hardware Major Version > > + * [23:16] RO | Hardware Minor Version > > + * [15:15] RO | Reserved > > + * [14:14] RO | Hardware supports biphasic counters > > + * [13:13] RO | Hardware supports filters > > + * [12:12] RO | Hardware supports waveform generation > > + * [11:11] RO | Hardware supports counter > > + * [10:10] RO | Hardware supports frequency metering > > + * [09:09] RO | Hardware supports power key functionality > > + * [08:08] RO | Hardware supports infrared transmissions > > + * [07:04] RO | Channel index of this instance > > + * [03:00] RO | Number of channels the base instance supports > > + */ > > + > > +#define PWMV4_REG_ENABLE 0x004 > > +/* > > + * ENABLE Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:06] RO | Reserved > > + * [05:05] RW | PWM Channel Counter Read Enable, 1 =3D enabled > > + */ > > +#define PWMV4_CHN_CNT_RD_EN(v) FIELD_PREP_WM16(BIT(5), (v)) > > +/* > > + * [04:04] W1T | PWM Globally Joined Control Enable > > + * 1 =3D this PWM channel will be enabled by a global pw= m enable > > + * bit instead of the PWM Enable bit. > > + */ > > +#define PWMV4_GLOBAL_CTRL_EN(v) FIELD_PREP_WM16(BIT(4), (v)) > > +/* > > + * [03:03] RW | Force Clock Enable > > + * 0 =3D disabled, if the PWM channel is inactive then s= o is the > > + * clock prescale module > > + */ > > +#define PWMV4_FORCE_CLK_EN(v) FIELD_PREP_WM16(BIT(3), (v)) > > +/* > > + * [02:02] W1T | PWM Control Update Enable > > + * 1 =3D enabled, commits modifications of _CTRL, _PERIO= D, _DUTY and > > + * _OFFSET registers once 1 is written to it > > + */ > > +#define PWMV4_CTRL_UPDATE_EN FIELD_PREP_WM16_CONST(BIT(2), 1) > > +/* > > + * [01:01] RW | PWM Enable, 1 =3D enabled > > + * If in one-shot mode, clears after end of operation > > + */ > > +#define PWMV4_EN_MASK BIT(1) > > +#define PWMV4_EN(v) FIELD_PREP_WM16(PWMV4_EN_MASK, \ > > + ((v) ? 1 : 0)) > > +/* > > + * [00:00] RW | PWM Clock Enable, 1 =3D enabled > > + * If in one-shot mode, clears after end of operation > > + */ > > +#define PWMV4_CLK_EN_MASK BIT(0) > > +#define PWMV4_CLK_EN(v) FIELD_PREP_WM16(PWMV4_CLK_EN_MASK, \ > > + ((v) ? 1 : 0)) > > +#define PWMV4_EN_BOTH_MASK (PWMV4_EN_MASK | PWMV4_CLK_EN_MASK) > > +static inline __pure bool rockchip_pwm_v4_is_enabled(unsigned int val) > > +{ > > + return (val & PWMV4_EN_BOTH_MASK); > > +} > > + > > +#define PWMV4_REG_CLK_CTRL 0x008 > > +/* > > + * CLK_CTRL Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:15] RW | Clock Global Selection > > + * 0 =3D current channel scale clock > > + * 1 =3D global channel scale clock > > + */ > > +#define PWMV4_CLK_GLOBAL(v) FIELD_PREP_WM16(BIT(15), (v)) > > +/* > > + * [14:13] RW | Clock Source Selection > > + * 0 =3D Clock from PLL, frequency can be configured > > + * 1 =3D Clock from crystal oscillator, frequency is fix= ed > > + * 2 =3D Clock from RC oscillator, frequency is fixed > > + * 3 =3D Reserved > > + * NOTE: The purpose for this clock-mux-outside-CRU cons= truct is > > + * to let the SoC go into a sleep state with the P= WM > > + * hardware still having a clock signal for IR inp= ut, which > > + * can then wake up the SoC. > > + */ > > +#define PWMV4_CLK_SRC_PLL 0x0U > > +#define PWMV4_CLK_SRC_CRYSTAL 0x1U > > +#define PWMV4_CLK_SRC_RC 0x2U > > +#define PWMV4_CLK_SRC_SHIFT 13 > > +#define PWMV4_CLK_SRC_WIDTH 2 > > +/* > > + * [12:04] RW | Scale Factor to apply to pre-scaled clock > > + * 1 <=3D v <=3D 256, v means clock divided by 2*v > > + */ > > +#define PWMV4_CLK_SCALE_F(v) FIELD_PREP_WM16(GENMASK(12, 4), (v)) > > +/* > > + * [03:03] RO | Reserved > > + * [02:00] RW | Prescale Factor > > + * v here means the input clock is divided by pow(2, v) > > + */ > > +#define PWMV4_CLK_PRESCALE_F(v) FIELD_PREP_WM16(GENMASK(2, 0), (v)) > > + > > +#define PWMV4_REG_CTRL 0x00C > > +/* > > + * CTRL Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:09] RO | Reserved > > + * [08:06] RW | PWM Input Channel Selection > > + * By default, the channel selects its own input, but wr= iting v > > + * here selects PWM input from channel v instead. > > + */ > > +#define PWMV4_CTRL_IN_SEL(v) FIELD_PREP_WM16(GENMASK(8, 6), (v)) > > +/* [05:05] RW | Aligned Mode, 0 =3D Valid, 1 =3D Invalid */ > > +#define PWMV4_CTRL_UNALIGNED(v) FIELD_PREP_WM16(BIT(5), (v)) > > +/* [04:04] RW | Output Mode, 0 =3D Left Aligned, 1 =3D Centre Aligned= */ > > +#define PWMV4_LEFT_ALIGNED 0x0U > > +#define PWMV4_CENTRE_ALIGNED 0x1U > > +#define PWMV4_CTRL_OUT_MODE(v) FIELD_PREP_WM16(BIT(4), (v)) > > +/* > > + * [03:03] RW | Inactive Polarity for when the channel is either disa= bled or > > + * has completed outputting the entire waveform in one-s= hot mode. > > + * 0 =3D Negative, 1 =3D Positive > > + */ > > +#define PWMV4_POLARITY_N 0x0U > > +#define PWMV4_POLARITY_P 0x1U > > +#define PWMV4_INACTIVE_POL(v) FIELD_PREP_WM16(BIT(3), (v)) > > +/* > > + * [02:02] RW | Duty Cycle Polarity to use at the start of the wavefo= rm. > > + * 0 =3D Negative, 1 =3D Positive > > + */ > > +#define PWMV4_DUTY_POL_SHIFT 2 > > +#define PWMV4_DUTY_POL_MASK BIT(PWMV4_DUTY_POL_SHIFT) > > +#define PWMV4_DUTY_POL(v) FIELD_PREP_WM16(PWMV4_DUTY_POL_MASK, \ > > + (v)) > > +/* > > + * [01:00] RW | PWM Mode > > + * 0 =3D One-shot mode, PWM generates waveform RPT times > > + * 1 =3D Continuous mode > > + * 2 =3D Capture mode, PWM measures cycles of input wave= form > > + * 3 =3D Reserved > > + */ > > +#define PWMV4_MODE_ONESHOT 0x0U > > +#define PWMV4_MODE_CONT 0x1U > > +#define PWMV4_MODE_CAPTURE 0x2U > > +#define PWMV4_MODE_MASK GENMASK(1, 0) > > +#define PWMV4_MODE(v) FIELD_PREP_WM16(PWMV4_MODE_MASK, (v)) > > +#define PWMV4_CTRL_COM_FLAGS (PWMV4_INACTIVE_POL(PWMV4_POLARITY_N) | \ > > + PWMV4_DUTY_POL(PWMV4_POLARITY_P) | \ > > + PWMV4_CTRL_OUT_MODE(PWMV4_LEFT_ALIGNED) | \ > > + PWMV4_CTRL_UNALIGNED(true)) > > +#define PWMV4_CTRL_CONT_FLAGS (PWMV4_MODE(PWMV4_MODE_CONT) | \ > > + PWMV4_CTRL_COM_FLAGS) > > +#define PWMV4_CTRL_CAP_FLAGS (PWMV4_MODE(PWMV4_MODE_CAPTURE) | \ > > + PWMV4_CTRL_COM_FLAGS) > > + > > +#define PWMV4_REG_PERIOD 0x010 > > +/* > > + * PERIOD Register Description > > + * [31:00] RW | Period of the output waveform > > + * Constraints: should be even if CTRL_OUT_MODE is CENTR= E_ALIGNED > > + */ > > + > > +#define PWMV4_REG_DUTY 0x014 > > +/* > > + * DUTY Register Description > > + * [31:00] RW | Duty cycle of the output waveform > > + * Constraints: should be even if CTRL_OUT_MODE is CENTR= E_ALIGNED > > + */ > > + > > +#define PWMV4_REG_OFFSET 0x018 > > +/* > > + * OFFSET Register Description > > + * [31:00] RW | Offset of the output waveform, based on the PWM clock > > + * Constraints: 0 <=3D v <=3D (PERIOD - DUTY) > > + */ > > + > > +#define PWMV4_REG_RPT 0x01C > > +/* > > + * RPT Register Description > > + * [31:16] RW | Second dimensional of the effective number of waveform > > + * repetitions. Increases by one every first dimensional= times. > > + * Value `n` means `n + 1` repetitions. The final number= of > > + * repetitions of the waveform in one-shot mode is: > > + * `(first_dimensional + 1) * (second_dimensional + 1)` > > + * [15:00] RW | First dimensional of the effective number of waveform > > + * repetitions. Value `n` means `n + 1` repetitions. > > + */ > > + > > +#define PWMV4_REG_FILTER_CTRL 0x020 > > +/* > > + * FILTER_CTRL Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:10] RO | Reserved > > + * [09:04] RW | Filter window number > > + * [03:01] RO | Reserved > > + * [00:00] RW | Filter Enable, 0 =3D disabled, 1 =3D enabled > > + */ > > + > > +#define PWMV4_REG_CNT 0x024 > > +/* > > + * CNT Register Description > > + * [31:00] RO | Current value of the PWM Channel 0 counter in pwm clo= ck cycles, > > + * 0 <=3D v <=3D 2^32-1 > > + */ > > + > > +#define PWMV4_REG_ENABLE_DELAY 0x028 > > +/* > > + * ENABLE_DELAY Register Description > > + * [31:16] RO | Reserved > > + * [15:00] RW | PWM enable delay, in an unknown unit but probably cyc= les > > + */ > > + > > +#define PWMV4_REG_HPC 0x02C > > +/* > > + * HPC Register Description > > + * [31:00] RW | Number of effective high polarity cycles of the input= waveform > > + * in capture mode. Based on the PWM clock. 0 <=3D v <= =3D 2^32-1 > > + */ > > + > > +#define PWMV4_REG_LPC 0x030 > > +/* > > + * LPC Register Description > > + * [31:00] RW | Number of effective low polarity cycles of the input = waveform > > + * in capture mode. Based on the PWM clock. 0 <=3D v <= =3D 2^32-1 > > + */ > > + > > +#define PWMV4_REG_BIPHASIC_CNT_CTRL0 0x040 > > +/* > > + * BIPHASIC_CNT_CTRL0 Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:10] RO | Reserved > > + * [09:09] RW | Biphasic Counter Phase Edge Selection for mode 0, > > + * 0 =3D rising edge (posedge), 1 =3D falling edge (nege= dge) > > + * [08:08] RW | Biphasic Counter Clock force enable, 1 =3D force enab= le > > + * [07:07] W1T | Synchronous Enable > > + * [06:06] W1T | Mode Switch > > + * 0 =3D Normal Mode, 1 =3D Switch timer clock and measu= red clock > > + * Constraints: "Biphasic Counter Mode" must be 0 if thi= s is 1 > > + * [05:03] RW | Biphasic Counter Mode > > + * 0x0 =3D Mode 0, 0x1 =3D Mode 1, 0x2 =3D Mode 2, 0x3 = =3D Mode 3, > > + * 0x4 =3D Mode 4, 0x5 =3D Reserved > > + * [02:02] RW | Biphasic Counter Clock Selection > > + * 0 =3D clock is from PLL and frequency can be configur= ed > > + * 1 =3D clock is from crystal oscillator and frequency = is fixed > > + * [01:01] RW | Biphasic Counter Continuous Mode > > + * [00:00] W1T | Biphasic Counter Enable > > + */ > > + > > +#define PWMV4_REG_BIPHASIC_CNT_CTRL1 0x044 > > +/* > > + * BIPHASIC_CNT_CTRL1 Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:11] RO | Reserved > > + * [10:04] RW | Biphasic Counter Filter Window Number > > + * [03:01] RO | Reserved > > + * [00:00] RW | Biphasic Counter Filter Enable > > + */ > > + > > +#define PWMV4_REG_BIPHASIC_CNT_TIMER 0x048 > > +/* > > + * BIPHASIC_CNT_TIMER Register Description > > + * [31:00] RW | Biphasic Counter Timer Value, in number of biphasic c= ounter > > + * timer clock cycles > > + */ > > + > > +#define PWMV4_REG_BIPHASIC_CNT_RES 0x04C > > +/* > > + * BIPHASIC_CNT_RES Register Description > > + * [31:00] RO | Biphasic Counter Result Value > > + * Constraints: Can only be read after INTSTS[9] is asse= rted > > + */ > > + > > +#define PWMV4_REG_BIPHASIC_CNT_RES_S 0x050 > > +/* > > + * BIPHASIC_CNT_RES_S Register Description > > + * [31:00] RO | Biphasic Counter Result Value with synchronised proce= ssing > > + * Can be read in real-time if BIPHASIC_CNT_CTRL0[7] was= set to 1 > > + */ > > + > > +#define PWMV4_REG_INTSTS 0x070 > > +/* > > + * INTSTS Register Description > > + * [31:10] RO | Reserved > > + * [09:09] W1C | Biphasic Counter Interrupt Status, 1 =3D interrupt as= serted > > + * [08:08] W1C | Waveform Middle Interrupt Status, 1 =3D interrupt ass= erted > > + * [07:07] W1C | Waveform Max Interrupt Status, 1 =3D interrupt assert= ed > > + * [06:06] W1C | IR Transmission End Interrupt Status, 1 =3D interrupt= asserted > > + * [05:05] W1C | Power Key Match Interrupt Status, 1 =3D interrupt ass= erted > > + * [04:04] W1C | Frequency Meter Interrupt Status, 1 =3D interrupt ass= erted > > + * [03:03] W1C | Reload Interrupt Status, 1 =3D interrupt asserted > > + * [02:02] W1C | Oneshot End Interrupt Status, 1 =3D interrupt asserted > > + * [01:01] W1C | HPC Capture Interrupt Status, 1 =3D interrupt asserted > > + * [00:00] W1C | LPC Capture Interrupt Status, 1 =3D interrupt asserted > > + */ > > +#define PWMV4_INT_LPC BIT(0) > > +#define PWMV4_INT_HPC BIT(1) > > +#define PWMV4_INT_LPC_W(v) FIELD_PREP_WM16(PWMV4_INT_LPC, \ > > + ((v) ? 1 : 0)) > > +#define PWMV4_INT_HPC_W(v) FIELD_PREP_WM16(PWMV4_INT_HPC, \ > > + ((v) ? 1 : 0)) > > + > > +#define PWMV4_REG_INT_EN 0x074 > > +/* > > + * INT_EN Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:10] RO | Reserved > > + * [09:09] RW | Biphasic Counter Interrupt Enable, 1 =3D enabled > > + * [08:08] W1C | Waveform Middle Interrupt Enable, 1 =3D enabled > > + * [07:07] W1C | Waveform Max Interrupt Enable, 1 =3D enabled > > + * [06:06] W1C | IR Transmission End Interrupt Enable, 1 =3D enabled > > + * [05:05] W1C | Power Key Match Interrupt Enable, 1 =3D enabled > > + * [04:04] W1C | Frequency Meter Interrupt Enable, 1 =3D enabled > > + * [03:03] W1C | Reload Interrupt Enable, 1 =3D enabled > > + * [02:02] W1C | Oneshot End Interrupt Enable, 1 =3D enabled > > + * [01:01] W1C | HPC Capture Interrupt Enable, 1 =3D enabled > > + * [00:00] W1C | LPC Capture Interrupt Enable, 1 =3D enabled > > + */ > > + > > +#define PWMV4_REG_INT_MASK 0x078 > > +/* > > + * INT_MASK Register Description > > + * [31:16] WO | Write Enable Mask for the lower half of the register > > + * Set bit `n` here to 1 if you wish to modify bit `n >>= 16` in > > + * the same write operation > > + * [15:10] RO | Reserved > > + * [09:09] RW | Biphasic Counter Interrupt Masked, 1 =3D masked > > + * [08:08] W1C | Waveform Middle Interrupt Masked, 1 =3D masked > > + * [07:07] W1C | Waveform Max Interrupt Masked, 1 =3D masked > > + * [06:06] W1C | IR Transmission End Interrupt Masked, 1 =3D masked > > + * [05:05] W1C | Power Key Match Interrupt Masked, 1 =3D masked > > + * [04:04] W1C | Frequency Meter Interrupt Masked, 1 =3D masked > > + * [03:03] W1C | Reload Interrupt Masked, 1 =3D masked > > + * [02:02] W1C | Oneshot End Interrupt Masked, 1 =3D masked > > + * [01:01] W1C | HPC Capture Interrupt Masked, 1 =3D masked > > + * [00:00] W1C | LPC Capture Interrupt Masked, 1 =3D masked > > + */ > > + > > +static inline u32 mfpwm_reg_read(void __iomem *base, u32 reg) > > +{ > > + return readl(base + reg); > > +} > > + > > +static inline void mfpwm_reg_write(void __iomem *base, u32 reg, u32 va= l) > > +{ > > + writel(val, base + reg); > > +} >=20 > a) Please do not abstract for the sake of it. > b) Please use Regmap instead. I agree but a) is a useless abstraction, but I don't think b) is any better in this case either. This is an mmio device, and mmio regmaps are an abstraction that provide zero benefit for this device in my opinion. No cache is needed here, and no register spinlock is needed either as the registers use the WM16 mechanism. In fact, the register spinlock would slap a more coarse-grained lock on top of the fine-grained wait-free atomicity that the hardware gives us. What they do necessitate though is that all reads are done into an output pointer instead of a return value, because the return value is used for communicating an error code. If I didn't ignore the error return value (I'm pretty sure it's useless for mmio regmaps) then I will also be doing unpleasant error unwinds in every function that accesses registers. And, whenever I want to do if (contents_of_register =3D=3D foo) I can't just do the read there, I need to read it into a local first outside of the if statement, even if I just use it once. I have, while developing this driver, used regmaps before, and decided that they just make the code worse. I do agree though that mfpwm_reg_read/mfpwm_reg_write seem pointless, I think I wanted it to take an mfpwm once but then made mfpwm private. I'll refactor stuff to get rid of these, but I won't use regmaps. Kind regards, Nicolas Frattaroli >=20 > > + > > +/** > > + * mfpwm_acquire - try becoming the active mfpwm function device > > + * @pwmf: pointer to the calling driver instance's &struct rockchip_mf= pwm_func > > + * > > + * mfpwm device "function" drivers must call this function before doin= g anything > > + * that either modifies or relies on the parent device's state, such a= s clocks, > > + * enabling/disabling outputs, modifying shared regs etc. > > + * > > + * The return statues should always be checked. > > + * > > + * All mfpwm_acquire() calls must be balanced with corresponding mfpwm= _release() > > + * calls once the device is no longer making changes that affect other= devices, > > + * or stops producing user-visible effects that depend on the current = device > > + * state being kept as-is. (e.g. after the PWM output signal is stoppe= d) > > + * > > + * The same device function may mfpwm_acquire() multiple times while i= t already > > + * is active, i.e. it is re-entrant, though it needs to balance this w= ith the > > + * same number of mfpwm_release() calls. > > + * > > + * Context: This function does not sleep. > > + * > > + * Return: > > + * * %0 - success > > + * * %-EBUSY - a different device function is active > > + * * %-EOVERFLOW - the acquire counter is at its maximum > > + */ > > +extern int __must_check mfpwm_acquire(struct rockchip_mfpwm_func *pwmf= ); > > + > > +/** > > + * mfpwm_release - drop usage of active mfpwm device function by 1 > > + * @pwmf: pointer to the calling driver instance's &struct rockchip_mf= pwm_func > > + * > > + * This is the balancing call to mfpwm_acquire(). If no users of the d= evice > > + * function remain, set the mfpwm device to have no active device func= tion, > > + * allowing other device functions to claim it. > > + */ > > +extern void mfpwm_release(const struct rockchip_mfpwm_func *pwmf); > > + > > +/** > > + * mfpwm_get_mode - get the current mode the hardware is in > > + * @pwmf: pointer to a &struct rockchip_mfpwm_func > > + * > > + * Check the hardware registers of the PWM hardware to determine which= mode it > > + * is currently operating in, if any. > > + * > > + * Returns: > > + * - %-EINVAL if @pwmf is %NULL or an error pointer > > + * - %-1 if the PWM hardware is off, regardless of operating mode > > + * - %PWMV4_MODE_ONESHOT if PWM hardware is in one-shot output mode > > + * - %PWMV4_MODE_CONT if PWM hardware is in continuous output mode > > + * - %PWMV4_MODE_CAPTURE if PWM hardware is in capture mode > > + */ > > +extern int mfpwm_get_mode(const struct rockchip_mfpwm_func *pwmf); > > + > > +#endif /* __SOC_ROCKCHIP_MFPWM_H__ */ > >=20 >=20 >=20