From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v4,5/6] usb:cdns3 Add Cadence USB3 DRD Driver From: Greg Kroah-Hartman Message-Id: <20190219132403.GC20719@kroah.com> Date: Tue, 19 Feb 2019 14:24:03 +0100 To: Pawel Laszczak Cc: devicetree@vger.kernel.org, felipe.balbi@linux.intel.com, mark.rutland@arm.com, linux-usb@vger.kernel.org, hdegoede@redhat.com, heikki.krogerus@linux.intel.com, andy.shevchenko@gmail.com, robh+dt@kernel.org, rogerq@ti.com, linux-kernel@vger.kernel.org, jbergsagel@ti.com, nsekhar@ti.com, nm@ti.com, sureshp@cadence.com, peter.chen@nxp.com, kurahul@cadence.com List-ID: T24gVGh1LCBGZWIgMTQsIDIwMTkgYXQgMDc6NDU6MTNQTSArMDAwMCwgUGF3ZWwgTGFzemN6YWsg d3JvdGU6Cj4gVGhpcyBwYXRjaCBpbnRyb2R1Y2UgbmV3IENhZGVuY2UgVVNCU1MgRFJEIGRyaXZl ciB0byBsaW51eCBrZXJuZWwuCgpOaXQsICJMaW51eCIgOikKCj4gVGhlIENhZGVuY2UgVVNCU1Mg RFJEIERyaXZlciBpcyBhIGhpZ2hseSBjb25maWd1cmFibGUgSVAgQ29yZSB3aGljaGkKCiJ3aGlj aGkiPwoKPiBjYW4gYmUgaW5zdGFudGlhdGVkIGFzIER1YWwtUm9sZSBEZXZpY2UgKERSRCksIFBl cmlwaGVyYWwgT25seSBhbmQKPiBIb3N0IE9ubHkgKFhIQ0kpY29uZmlndXJhdGlvbnMuCj4gCj4g VGhlIGN1cnJlbnQgZHJpdmVyIGhhcyBiZWVuIHZhbGlkYXRlZCB3aXRoIEZQR0EgYnVybmVkLiBX ZSBoYXZlIHN1cHBvcnQKCkkgY2FuIG5vdCBwYXJzZSB0aGF0IHNlbnRhbmNlLCBzb3JyeS4gIHdo YXQgZG9lcyAid2l0aCBGUEdBIGJ1cm5lZCIKbWVhbj8KCj4gZm9yIFBDSWUgYnVzLCB3aGljaCBp cyB1c2VkIG9uIEZQR0EgcHJvdG90eXBpbmcuCj4gCj4gVGhlIGhvc3Qgc2lkZSBvZiBVU0JTUy1E UkQgY29udHJvbGxlciBpcyBjb21wbGlhbmNlIHdpdGggWEhDSQoKImNvbXBsaWFudCIKCj4gc3Bl Y2lmaWNhdGlvbiwgc28gaXQgd29ya3Mgd2l0aCBzdGFuZGFyZCBYSENJIGxpbnV4IGRyaXZlci4K CiJMaW51eCIKCj4gCj4gU2lnbmVkLW9mZi1ieTogUGF3ZWwgTGFzemN6YWsgPHBhd2VsbEBjYWRl bmNlLmNvbT4KPiAtLS0KPiAgZHJpdmVycy91c2IvS2NvbmZpZyAgICAgICAgICAgICAgICB8ICAg IDIgKwo+ICBkcml2ZXJzL3VzYi9NYWtlZmlsZSAgICAgICAgICAgICAgIHwgICAgMiArCj4gIGRy aXZlcnMvdXNiL2NkbnMzL0tjb25maWcgICAgICAgICAgfCAgIDQ0ICsKPiAgZHJpdmVycy91c2Iv Y2RuczMvTWFrZWZpbGUgICAgICAgICB8ICAgMTQgKwo+ICBkcml2ZXJzL3VzYi9jZG5zMy9jZG5z My1wY2ktd3JhcC5jIHwgIDE1NSArKysKPiAgZHJpdmVycy91c2IvY2RuczMvY29yZS5jICAgICAg ICAgICB8ICA0MDMgKysrKysrCj4gIGRyaXZlcnMvdXNiL2NkbnMzL2NvcmUuaCAgICAgICAgICAg fCAgMTE2ICsrCj4gIGRyaXZlcnMvdXNiL2NkbnMzL2RlYnVnLmggICAgICAgICAgfCAgMTY4ICsr Kwo+ICBkcml2ZXJzL3VzYi9jZG5zMy9kZWJ1Z2ZzLmMgICAgICAgIHwgIDE2NCArKysKPiAgZHJp dmVycy91c2IvY2RuczMvZHJkLmMgICAgICAgICAgICB8ICAzNjUgKysrKysKPiAgZHJpdmVycy91 c2IvY2RuczMvZHJkLmggICAgICAgICAgICB8ICAxNjIgKysrCj4gIGRyaXZlcnMvdXNiL2NkbnMz L2VwMC5jICAgICAgICAgICAgfCAgOTA3ICsrKysrKysrKysrKysKPiAgZHJpdmVycy91c2IvY2Ru czMvZ2FkZ2V0LWV4cG9ydC5oICB8ICAgMjggKwo+ICBkcml2ZXJzL3VzYi9jZG5zMy9nYWRnZXQu YyAgICAgICAgIHwgMjAwMyArKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMv dXNiL2NkbnMzL2dhZGdldC5oICAgICAgICAgfCAxMjA3ICsrKysrKysrKysrKysrKysrCj4gIGRy aXZlcnMvdXNiL2NkbnMzL2hvc3QtZXhwb3J0LmggICAgfCAgIDI4ICsKPiAgZHJpdmVycy91c2Iv Y2RuczMvaG9zdC5jICAgICAgICAgICB8ICAgNzIgKwo+ICBkcml2ZXJzL3VzYi9jZG5zMy90cmFj ZS5jICAgICAgICAgIHwgICAyMyArCj4gIGRyaXZlcnMvdXNiL2NkbnMzL3RyYWNlLmggICAgICAg ICAgfCAgNDA0ICsrKysrKwo+ICAxOSBmaWxlcyBjaGFuZ2VkLCA2MjY3IGluc2VydGlvbnMoKykK PiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvdXNiL2NkbnMzL0tjb25maWcKPiAgY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvdXNiL2NkbnMzL01ha2VmaWxlCj4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL3VzYi9jZG5zMy9jZG5zMy1wY2ktd3JhcC5jCj4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvdXNiL2NkbnMzL2NvcmUuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2Ru czMvZGVidWcuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2RuczMvZGVidWdm cy5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3VzYi9jZG5zMy9kcmQuYwo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2RuczMvZHJkLmgKPiAgY3JlYXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvdXNiL2NkbnMzL2VwMC5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L3VzYi9jZG5zMy9nYWRnZXQtZXhwb3J0LmgKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv dXNiL2NkbnMzL2dhZGdldC5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3VzYi9jZG5z My9nYWRnZXQuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2RuczMvaG9zdC1l eHBvcnQuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2RuczMvaG9zdC5jCj4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3VzYi9jZG5zMy90cmFjZS5jCj4gIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL3VzYi9jZG5zMy90cmFjZS5oCj4gCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvdXNiL0tjb25maWcgYi9kcml2ZXJzL3VzYi9LY29uZmlnCj4gaW5kZXggOTg3ZmM1YmE2 MzIxLi41ZjkzMzQwMTlkMDQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvS2NvbmZpZwo+ICsr KyBiL2RyaXZlcnMvdXNiL0tjb25maWcKPiBAQCAtMTEyLDYgKzExMiw4IEBAIHNvdXJjZSAiZHJp dmVycy91c2IvdXNiaXAvS2NvbmZpZyIKPiAgCj4gIGVuZGlmCj4gIAo+ICtzb3VyY2UgImRyaXZl cnMvdXNiL2NkbnMzL0tjb25maWciCj4gKwo+ICBzb3VyY2UgImRyaXZlcnMvdXNiL210dTMvS2Nv bmZpZyIKPiAgCj4gIHNvdXJjZSAiZHJpdmVycy91c2IvbXVzYi9LY29uZmlnIgo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL3VzYi9NYWtlZmlsZSBiL2RyaXZlcnMvdXNiL01ha2VmaWxlCj4gaW5kZXgg N2QxYjhjODJiMjA4Li5hYjEyNWI5NjZjYWMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvTWFr ZWZpbGUKPiArKysgYi9kcml2ZXJzL3VzYi9NYWtlZmlsZQo+IEBAIC0xMiw2ICsxMiw4IEBAIG9i ai0kKENPTkZJR19VU0JfRFdDMykJCSs9IGR3YzMvCj4gIG9iai0kKENPTkZJR19VU0JfRFdDMikJ CSs9IGR3YzIvCj4gIG9iai0kKENPTkZJR19VU0JfSVNQMTc2MCkJKz0gaXNwMTc2MC8KPiAgCj4g K29iai0kKENPTkZJR19VU0JfQ0ROUzMpCQkrPSBjZG5zMy8KPiArCj4gIG9iai0kKENPTkZJR19V U0JfTU9OKQkJKz0gbW9uLwo+ICBvYmotJChDT05GSUdfVVNCX01UVTMpCQkrPSBtdHUzLwo+ICAK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMvS2NvbmZpZyBiL2RyaXZlcnMvdXNiL2Nk bnMzL0tjb25maWcKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4u MjdjYjNkOGRiZTNkCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvdXNiL2NkbnMzL0tj b25maWcKPiBAQCAtMCwwICsxLDQ0IEBACj4gK2NvbmZpZyBVU0JfQ0ROUzMKPiArCXRyaXN0YXRl ICJDYWRlbmNlIFVTQjMgRHVhbC1Sb2xlIENvbnRyb2xsZXIiCj4gKwlkZXBlbmRzIG9uIFVTQl9T VVBQT1JUICYmIChVU0IgfHwgVVNCX0dBREdFVCkgJiYgSEFTX0RNQQo+ICsJaGVscAo+ICsJICBT YXkgWSBoZXJlIGlmIHlvdXIgc3lzdGVtIGhhcyBhIGNhZGVuY2UgVVNCMyBkdWFsLXJvbGUgY29u dHJvbGxlci4KPiArCSAgSXQgc3VwcG9ydHM6IGR1YWwtcm9sZSBzd2l0Y2gsIEhvc3Qtb25seSwg YW5kIFBlcmlwaGVyYWwtb25seS4KPiArCj4gKwkgIElmIHlvdSBjaG9vc2UgdG8gYnVpbGQgdGhp cyBkcml2ZXIgaXMgYSBkeW5hbWljYWxseSBsaW5rZWQKPiArCSAgYXMgbW9kdWxlLCB0aGUgbW9k dWxlIHdpbGwgYmUgY2FsbGVkIGNkbnMzLmtvLgo+ICsKPiAraWYgVVNCX0NETlMzCj4gKwo+ICtj b25maWcgVVNCX0NETlMzX0dBREdFVAo+ICsgICAgICAgIGJvb2wgIkNhZGVuY2UgVVNCMyBkZXZp Y2UgY29udHJvbGxlciIKPiArICAgICAgICBkZXBlbmRzIG9uIFVTQl9HQURHRVQKPiArICAgICAg ICBoZWxwCj4gKyAgICAgICAgICBTYXkgWSBoZXJlIHRvIGVuYWJsZSBkZXZpY2UgY29udHJvbGxl ciBmdW5jdGlvbmFsaXR5IG9mIHRoZQo+ICsgICAgICAgICAgY2FkZW5jZSBVU0JTUy1ERVYgZHJp dmVyLgo+ICsKPiArICAgICAgICAgIFRoaXMgY29udHJvbGxlciBzdXBwb3J0cyBGRiwgSFMgYW5k IFNTIG1vZGUuIEl0IGRvZXNuJ3Qgc3VwcG9ydAo+ICsgICAgICAgICAgTFMgYW5kIFNTUCBtb2Rl Lgo+ICsKPiArY29uZmlnIFVTQl9DRE5TM19IT1NUCj4gKyAgICAgICAgYm9vbCAiQ2FkZW5jZSBV U0IzIGhvc3QgY29udHJvbGxlciIKPiArICAgICAgICBkZXBlbmRzIG9uIFVTQl9YSENJX0hDRAo+ ICsgICAgICAgIGhlbHAKPiArICAgICAgICAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIGhvc3QgY29u dHJvbGxlciBmdW5jdGlvbmFsaXR5IG9mIHRoZQo+ICsgICAgICAgICAgY2FkZW5jZSBkcml2ZXIu Cj4gKwo+ICsgICAgICAgICAgSG9zdCBjb250cm9sbGVyIGlzIGNvbXBsaWFudCB3aXRoIFhIQ0kg c28gaXQgd2lsbCB1c2UKPiArICAgICAgICAgIHN0YW5kYXJkIFhIQ0kgZHJpdmVyLgo+ICsKPiAr Y29uZmlnIFVTQl9DRE5TM19QQ0lfV1JBUAo+ICsJdHJpc3RhdGUgIkNhZGVuY2UgVVNCMyBzdXBw b3J0IG9uIFBDSWUtYmFzZWQgcGxhdGZvcm1zIgo+ICsJZGVwZW5kcyBvbiBVU0JfUENJICYmIEFD UEkKPiArCWRlZmF1bHQgVVNCX0NETlMzCj4gKwloZWxwCj4gKwkgIElmIHlvdSdyZSB1c2luZyB0 aGUgVVNCU1MgQ29yZSBJUCB3aXRoIGEgUENJZSwgcGxlYXNlIHNheQo+ICsJICAnWScgb3IgJ00n IGhlcmUuCj4gKwo+ICsJICBJZiB5b3UgY2hvb3NlIHRvIGJ1aWxkIHRoaXMgZHJpdmVyIGFzIG1v ZHVsZSBpdCB3aWxsCj4gKwkgIGJlIGR5bmFtaWNhbGx5IGxpbmtlZCBhbmQgbW9kdWxlIHdpbGwg YmUgY2FsbGVkIGNkbnMzLXBjaS5rbwoKWW91IHVzZSB0YWJzIGhlcmUsIGJ1dCBub3QgdGFicyBp biB0aGUgb3RoZXIgb3B0aW9ucy4gIFBsZWFzZSBiZQp1bmlmb3JtLgoKCj4gKwo+ICtlbmRpZgo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jZG5zMy9NYWtlZmlsZSBiL2RyaXZlcnMvdXNiL2Nk bnMzL01ha2VmaWxlCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAu LjhmOTQzODU5MzM3NQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9N YWtlZmlsZQo+IEBAIC0wLDAgKzEsMTQgQEAKPiArIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMAo+ICsjIGRlZmluZV90cmFjZS5oIG5lZWRzIHRvIGtub3cgaG93IHRvIGZpbmQgb3Vy IGhlYWRlcgo+ICtDRkxBR1NfdHJhY2UubwkJCQk6PSAtSSQoc3JjKQo+ICsKPiArY2RuczMteQkJ CQkJOj0gY29yZS5vIGRyZC5vIHRyYWNlLm8KPiArCj4gK29iai0kKENPTkZJR19VU0JfQ0ROUzMp CQkJKz0gY2RuczMubwo+ICtpZm5lcSAoJChDT05GSUdfREVCVUdfRlMpLCkKPiArCWNkbnMzLXkJ CQkJKz0gZGVidWdmcy5vCj4gK2VuZGlmCj4gKwo+ICtjZG5zMy0kKENPTkZJR19VU0JfQ0ROUzNf R0FER0VUKQkrPSBnYWRnZXQubyBlcDAubwo+ICtjZG5zMy0kKENPTkZJR19VU0JfQ0ROUzNfSE9T VCkJCSs9IGhvc3Qubwo+ICtvYmotJChDT05GSUdfVVNCX0NETlMzX1BDSV9XUkFQKQkrPSBjZG5z My1wY2ktd3JhcC5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NkbnMzL2NkbnMzLXBjaS13 cmFwLmMgYi9kcml2ZXJzL3VzYi9jZG5zMy9jZG5zMy1wY2ktd3JhcC5jCj4gbmV3IGZpbGUgbW9k ZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmQwYjJkM2Q5Yjk4Mwo+IC0tLSAvZGV2L251 bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9jZG5zMy1wY2ktd3JhcC5jCj4gQEAgLTAsMCAr MSwxNTUgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiAr ICogQ2FkZW5jZSBVU0JTUyBQQ0kgR2x1ZSBkcml2ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChD KSAyMDE4IENhZGVuY2UuCj4gKyAqCj4gKyAqIEF1dGhvcjogUGF3ZWwgTGFzemN6YWsgPHBhd2Vs bEBjYWRlbmNlLmNvbT4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgo+ICsj aW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9kbWEt bWFwcGluZy5oPgo+ICsjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ICsKPiArc3RydWN0IGNkbnMz X3dyYXAgewo+ICsJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGxhdF9kZXY7Cj4gKwlzdHJ1Y3Qg cGNpX2RldiAqaGdfZGV2Owo+ICsJc3RydWN0IHJlc291cmNlIGRldl9yZXNbNF07Cj4gK307Cj4g Kwo+ICtzdHJ1Y3QgY2RuczNfd3JhcCB3cmFwOwo+ICsKPiArI2RlZmluZSBSRVNfSVJRX0lECQkw Cj4gKyNkZWZpbmUgUkVTX0hPU1RfSUQJCTEKPiArI2RlZmluZSBSRVNfREVWX0lECQkyCj4gKyNk ZWZpbmUgUkVTX0RSRF9JRAkJMwo+ICsKPiArI2RlZmluZSBQQ0lfQkFSX0hPU1QJCTAKPiArI2Rl ZmluZSBQQ0lfQkFSX0RFVgkJMgo+ICsjZGVmaW5lIFBDSV9CQVJfT1RHCQk0Cj4gKwo+ICsjZGVm aW5lIFBDSV9ERVZfRk5fSE9TVF9ERVZJQ0UJMAo+ICsjZGVmaW5lIFBDSV9ERVZfRk5fT1RHCQkx Cj4gKwo+ICsjZGVmaW5lIFBDSV9EUklWRVJfTkFNRQkJImNkbnMzLXBjaS11c2JzcyIKPiArI2Rl ZmluZSBQTEFUX0RSSVZFUl9OQU1FCSJjZG5zLXVzYjMiCj4gKwo+ICsjZGVmaW5lIENETlNfVkVO RE9SX0lEIDB4MTdjZAoKUENJX1ZFTkRPUl9JRF9DRE5TIGlzIGFscmVhZHkgaW4gcGNpX2lkcy5o LCBubyBuZWVkIHRvIGRlZmluZSBpdCBhZ2FpbgpoZXJlLgoKPiArI2RlZmluZSBDRE5TX0RFVklD RV9JRCAweDAxMDAKCk5vIHRhYnM/Cgo+ICsKPiArLyoqCgprZXJuZWxkb2MgaXMgZ3JlYXQsIGJ1 dCBmb3Igc3RhdGljIGZ1bmN0aW9ucz8gIFdobyBpcyBwdWxsaW5nIHRoZXNlIGludG8KZG9jdW1l bnRhdGlvbj8KCklmIG5vdCwgdGhlbiBubyBuZWVkIGZvciB0aGF0IGZvcm1hdCBhdCBhbGwuCgo+ ICsgKiBjZG5zM19wY2lfcHJvYmUgLSBQcm9iZSBmdW5jdGlvbiBmb3IgQ2FkZW5jZSBVU0Igd3Jh cHBlciBkcml2ZXIKPiArICogQHBkZXY6IHBsYXRmb3JtIGRldmljZSBvYmplY3QKPiArICogQGlk OiBwY2kgZGV2aWNlIGlkCj4gKyAqCj4gKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzIG90aGVyd2lz ZSBuZWdhdGl2ZSBlcnJubwo+ICsgKi8KPiArc3RhdGljIGludCBjZG5zM19wY2lfcHJvYmUoc3Ry dWN0IHBjaV9kZXYgKnBkZXYsCj4gKwkJCSAgIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICpp ZCkKPiArewo+ICsJc3RydWN0IHBsYXRmb3JtX2RldmljZV9pbmZvIHBsYXRfaW5mbzsKPiArCXN0 cnVjdCBjZG5zM193cmFwICp3cmFwOwo+ICsJc3RydWN0IHJlc291cmNlICpyZXM7Cj4gKwlpbnQg ZXJyOwo+ICsKPiArCS8qCj4gKwkgKiBmb3IgR0FER0VUL0hPU1QgUENJIChkZXZmbikgZnVuY3Rp b24gbnVtYmVyIGlzIDAsCj4gKwkgKiBmb3IgT1RHIFBDSSAoZGV2Zm4pIGZ1bmN0aW9uIG51bWJl ciBpcyAxCj4gKwkgKi8KPiArCWlmICghaWQgfHwgcGRldi0+ZGV2Zm4gIT0gUENJX0RFVl9GTl9I T1NUX0RFVklDRSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwllcnIgPSBwY2ltX2VuYWJs ZV9kZXZpY2UocGRldik7Cj4gKwlpZiAoZXJyKSB7Cj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAi RW5hYmxpbmcgUENJIGRldmljZSBoYXMgZmFpbGVkICVkXG4iLCBlcnIpOwo+ICsJCXJldHVybiBl cnI7Cj4gKwl9Cj4gKwo+ICsJcGNpX3NldF9tYXN0ZXIocGRldik7Cj4gKwl3cmFwID0gZGV2bV9r emFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqd3JhcCksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCF3 cmFwKSB7Cj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9y eVxuIik7CgpObyBuZWVkIHRvIHByaW50IGFuIGVycm9yIGFnYWluIGFmdGVyIGt6YWxsb2MgYWxy ZWFkeSBwcmludGVkIGFuIGVycm9yLgoKPiArCQlyZXR1cm4gLUVOT01FTTsKCkRpZCB5b3UgZm9y Z2V0IHRvIGRpc2FibGUgdGhlIHBjaSBkZXZpY2U/Cgo+ICsJfQo+ICsKPiArCS8qIGZ1bmN0aW9u IDA6IGhvc3QoQkFSXzApICsgZGV2aWNlKEJBUl8xKSArIG90ZyhCQVJfMikpLiAqLwo+ICsJbWVt c2V0KHdyYXAtPmRldl9yZXMsIDB4MDAsCj4gKwkgICAgICAgc2l6ZW9mKHN0cnVjdCByZXNvdXJj ZSkgKiBBUlJBWV9TSVpFKHdyYXAtPmRldl9yZXMpKTsKPiArCWRldl9kYmcoJnBkZXYtPmRldiwg IkluaXRpYWxpemUgRGV2aWNlIHJlc291cmNlc1xuIik7Cj4gKwlyZXMgPSB3cmFwLT5kZXZfcmVz Owo+ICsKPiArCXJlc1tSRVNfREVWX0lEXS5zdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydChwZGV2 LCBQQ0lfQkFSX0RFVik7Cj4gKwlyZXNbUkVTX0RFVl9JRF0uZW5kID0gICBwY2lfcmVzb3VyY2Vf ZW5kKHBkZXYsIFBDSV9CQVJfREVWKTsKPiArCXJlc1tSRVNfREVWX0lEXS5uYW1lID0gImRldiI7 Cj4gKwlyZXNbUkVTX0RFVl9JRF0uZmxhZ3MgPSBJT1JFU09VUkNFX01FTTsKPiArCWRldl9kYmco JnBkZXYtPmRldiwgIlVTQlNTLURFViBwaHlzaWNhbCBiYXNlIGFkZHI6ICVwYVxuIiwKPiArCQkm cmVzW1JFU19ERVZfSURdLnN0YXJ0KTsKPiArCj4gKwlyZXNbUkVTX0hPU1RfSURdLnN0YXJ0ID0g cGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIFBDSV9CQVJfSE9TVCk7Cj4gKwlyZXNbUkVTX0hPU1Rf SURdLmVuZCA9IHBjaV9yZXNvdXJjZV9lbmQocGRldiwgUENJX0JBUl9IT1NUKTsKPiArCXJlc1tS RVNfSE9TVF9JRF0ubmFtZSA9ICJ4aGNpIjsKPiArCXJlc1tSRVNfSE9TVF9JRF0uZmxhZ3MgPSBJ T1JFU09VUkNFX01FTTsKPiArCWRldl9kYmcoJnBkZXYtPmRldiwgIlVTQlNTLVhIQ0kgcGh5c2lj YWwgYmFzZSBhZGRyOiAlcGFcbiIsCj4gKwkJJnJlc1tSRVNfSE9TVF9JRF0uc3RhcnQpOwo+ICsK PiArCXJlc1tSRVNfRFJEX0lEXS5zdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCBQQ0lf QkFSX09URyk7Cj4gKwlyZXNbUkVTX0RSRF9JRF0uZW5kID0gICBwY2lfcmVzb3VyY2VfZW5kKHBk ZXYsIFBDSV9CQVJfT1RHKTsKPiArCXJlc1tSRVNfRFJEX0lEXS5uYW1lID0gIm90ZyI7Cj4gKwly ZXNbUkVTX0RSRF9JRF0uZmxhZ3MgPSBJT1JFU09VUkNFX01FTTsKPiArCWRldl9kYmcoJnBkZXYt PmRldiwgIlVTQlNTLURSRCBwaHlzaWNhbCBiYXNlIGFkZHI6ICVwYVxuIiwKPiArCQkmcmVzW1JF U19EUkRfSURdLnN0YXJ0KTsKPiArCj4gKwkvKiBJbnRlcnJ1cHQgY29tbW9uIGZvciBib3RoIGRl dmljZSBhbmQgWEhDSSAqLwo+ICsJd3JhcC0+ZGV2X3Jlc1tSRVNfSVJRX0lEXS5zdGFydCA9IHBk ZXYtPmlycTsKPiArCXdyYXAtPmRldl9yZXNbUkVTX0lSUV9JRF0ubmFtZSA9ICJjZG5zMy1pcnEi Owo+ICsJd3JhcC0+ZGV2X3Jlc1tSRVNfSVJRX0lEXS5mbGFncyA9IElPUkVTT1VSQ0VfSVJROwo+ ICsKPiArCS8qIHNldCB1cCBwbGF0Zm9ybSBkZXZpY2UgaW5mbyAqLwo+ICsJbWVtc2V0KCZwbGF0 X2luZm8sIDAsIHNpemVvZihwbGF0X2luZm8pKTsKPiArCXBsYXRfaW5mby5wYXJlbnQgPSAmcGRl di0+ZGV2Owo+ICsJcGxhdF9pbmZvLmZ3bm9kZSA9IHBkZXYtPmRldi5md25vZGU7Cj4gKwlwbGF0 X2luZm8ubmFtZSA9IFBMQVRfRFJJVkVSX05BTUU7Cj4gKwlwbGF0X2luZm8uaWQgPSBwZGV2LT5k ZXZmbjsKPiArCXBsYXRfaW5mby5yZXMgPSB3cmFwLT5kZXZfcmVzOwo+ICsJcGxhdF9pbmZvLm51 bV9yZXMgPSBBUlJBWV9TSVpFKHdyYXAtPmRldl9yZXMpOwo+ICsJcGxhdF9pbmZvLmRtYV9tYXNr ID0gcGRldi0+ZG1hX21hc2s7Cj4gKwo+ICsJLyogcmVnaXN0ZXIgcGxhdGZvcm0gZGV2aWNlICov Cj4gKwl3cmFwLT5wbGF0X2RldiA9IHBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcl9mdWxsKCZwbGF0 X2luZm8pOwo+ICsJaWYgKElTX0VSUih3cmFwLT5wbGF0X2RldikpCj4gKwkJcmV0dXJuIFBUUl9F UlIod3JhcC0+cGxhdF9kZXYpOwoKTm8gZGlzYWJsaW5nIG9mIHRoZSBkZXZpY2U/CgpBbnl3YXks IHdoeSBhcmUgeW91IGNyZWF0aW5nIGEgcGxhdGZvcm0gZGV2aWNlIHdoZW4geW91IGhhdmUgYSBy ZWFsIFBDSQpkZXZpY2U/ICBUaGF0IHNlZW1zIG9kZCwgYW5kIGFuIGFidXNlIG9mIHRoZSBwbGF0 Zm9ybSBjb2RlLiAgV2hhdCdzCndyb25nIHdpdGggeW91ciByZWFsIFBDSSBkZXZpY2UgaGVyZT8K Cgo+ICsKPiArCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCB3cmFwKTsKPiArCj4gKwlyZXR1cm4gZXJy Owo+ICt9Cj4gKwo+ICt2b2lkIGNkbnMzX3BjaV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYp Cj4gK3sKPiArCXN0cnVjdCBjZG5zM193cmFwICp3cmFwID0gKHN0cnVjdCBjZG5zM193cmFwICop cGNpX2dldF9kcnZkYXRhKHBkZXYpOwo+ICsKPiArCXBsYXRmb3JtX2RldmljZV91bnJlZ2lzdGVy KHdyYXAtPnBsYXRfZGV2KTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBwY2lfZGV2 aWNlX2lkIGNkbnMzX3BjaV9pZHNbXSA9IHsKPiArCXsgUENJX0RFVklDRShDRE5TX1ZFTkRPUl9J RCwgQ0ROU19ERVZJQ0VfSUQpLCB9LAo+ICsJeyAwLCB9Cj4gK307Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IHBjaV9kcml2ZXIgY2RuczNfcGNpX2RyaXZlciA9IHsKPiArCS5uYW1lID0gUENJX0RSSVZF Ul9OQU1FLAo+ICsJLmlkX3RhYmxlID0gY2RuczNfcGNpX2lkcywKPiArCS5wcm9iZSA9IGNkbnMz X3BjaV9wcm9iZSwKPiArCS5yZW1vdmUgPSBjZG5zM19wY2lfcmVtb3ZlLAo+ICt9Owo+ICsKPiAr bW9kdWxlX3BjaV9kcml2ZXIoY2RuczNfcGNpX2RyaXZlcik7Cj4gK01PRFVMRV9ERVZJQ0VfVEFC TEUocGNpLCBjZG5zM19wY2lfaWRzKTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIlBhd2VsIExhc3pj emFrIDxwYXdlbGxAY2FkZW5jZS5jb20+Iik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsK PiArTU9EVUxFX0RFU0NSSVBUSU9OKCJDYWRlbmNlIFVTQlNTIFBDSSB3cmFwcGVyciIpOwo+ICsK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMvY29yZS5jIGIvZHJpdmVycy91c2IvY2Ru czMvY29yZS5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmFh MmY2MzI0MWRhYgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9jb3Jl LmMKPiBAQCAtMCwwICsxLDQwMyBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMAo+ICsvKgo+ICsgKiBDYWRlbmNlIFVTQlNTIERSRCBEcml2ZXIuCj4gKyAqCj4gKyAqIENv cHlyaWdodCAoQykgMjAxOCBDYWRlbmNlLgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTctMjAxOCBO WFAKPiArICoKPiArICogQXV0aG9yOiBQZXRlciBDaGVuIDxwZXRlci5jaGVuQG54cC5jb20+Cj4g KyAqICAgICAgICAgUGF3ZWwgTGFzemN6YWsgPHBhd2VsbEBjYWRlbmNlLmNvbT4KPiArICovCj4g Kwo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwu aD4KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvaW50ZXJydXB0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pby5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvcG1fcnVudGltZS5oPgo+ICsKPiArI2luY2x1ZGUgImdhZGdldC5oIgo+ICsjaW5jbHVkZSAi Y29yZS5oIgo+ICsjaW5jbHVkZSAiaG9zdC1leHBvcnQuaCIKPiArI2luY2x1ZGUgImdhZGdldC1l eHBvcnQuaCIKPiArI2luY2x1ZGUgImRyZC5oIgo+ICsjaW5jbHVkZSAiZGVidWcuaCIKPiArCj4g K3N0YXRpYyBpbmxpbmUKPiArc3RydWN0IGNkbnMzX3JvbGVfZHJpdmVyICpjZG5zM19nZXRfY3Vy cmVudF9yb2xlX2RyaXZlcihzdHJ1Y3QgY2RuczMgKmNkbnMpCj4gK3sKPiArCVdBUk5fT04oY2Ru cy0+cm9sZSA+PSBDRE5TM19ST0xFX0VORCB8fCAhY2Rucy0+cm9sZXNbY2Rucy0+cm9sZV0pOwoK V2hhdCBpcyBzb21lb25lIHN1cHBvc2VkIHRvIGRvIHdpdGggdGhpcz8KCj4gKwlyZXR1cm4gY2Ru cy0+cm9sZXNbY2Rucy0+cm9sZV07Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY2RuczNfcm9sZV9z dGFydChzdHJ1Y3QgY2RuczMgKmNkbnMsIGVudW0gY2RuczNfcm9sZXMgcm9sZSkKPiArewo+ICsJ aW50IHJldDsKPiArCj4gKwlpZiAoV0FSTl9PTihyb2xlID49IENETlMzX1JPTEVfRU5EKSkKClNh bWUgaGVyZSwgaG93IGNhbiB0aGlzIGhhcHBlbj8gIFdoYXQgY2FuIEkgZG8gaWYgaXQgZG9lcz8K Cj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJaWYgKCFjZG5zLT5yb2xlc1tyb2xlXSkKPiArCQlyZXR1 cm4gLUVOWElPOwo+ICsKPiArCWlmIChjZG5zLT5yb2xlc1tyb2xlXS0+c3RhdGUgPT0gQ0ROUzNf Uk9MRV9TVEFURV9BQ1RJVkUpCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmY2Ru cy0+bXV0ZXgpOwo+ICsJY2Rucy0+cm9sZSA9IHJvbGU7Cj4gKwlyZXQgPSBjZG5zLT5yb2xlc1ty b2xlXS0+c3RhcnQoY2Rucyk7Cj4gKwlpZiAoIXJldCkKPiArCQljZG5zLT5yb2xlc1tyb2xlXS0+ c3RhdGUgPSBDRE5TM19ST0xFX1NUQVRFX0FDVElWRTsKPiArCW11dGV4X3VubG9jaygmY2Rucy0+ bXV0ZXgpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArdm9pZCBjZG5zM19yb2xlX3N0b3Ao c3RydWN0IGNkbnMzICpjZG5zKQo+ICt7Cj4gKwllbnVtIGNkbnMzX3JvbGVzIHJvbGUgPSBjZG5z LT5yb2xlOwo+ICsKPiArCWlmIChyb2xlID49IENETlMzX1JPTEVfRU5EKSB7Cj4gKwkJV0FSTl9P Tihyb2xlID4gQ0ROUzNfUk9MRV9FTkQpOwoKQWdhaW4sIHdoeT8KCj4gKwkJcmV0dXJuOwo+ICsJ fQo+ICsKPiArCWlmIChjZG5zLT5yb2xlc1tyb2xlXS0+c3RhdGUgPT0gQ0ROUzNfUk9MRV9TVEFU RV9JTkFDVElWRSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJbXV0ZXhfbG9jaygmY2Rucy0+bXV0ZXgp Owo+ICsJY2Rucy0+cm9sZXNbcm9sZV0tPnN0b3AoY2Rucyk7Cj4gKwljZG5zLT5yb2xlc1tyb2xl XS0+c3RhdGUgPSBDRE5TM19ST0xFX1NUQVRFX0lOQUNUSVZFOwo+ICsJbXV0ZXhfdW5sb2NrKCZj ZG5zLT5tdXRleCk7Cj4gK30KPiArCj4gKy8qCj4gKyAqIGNkbnMtPnJvbGUgZ2V0cyBmcm9tIGNk bnMzX2dldF9pbml0aWFsX3JvbGUsIGFuZCB0aGlzIEFQSSB0ZWxscyByb2xlIGF0IHRoZQo+ICsg KiBydW50aW1lLgo+ICsgKiBJZiBib3RoIHJvbGVzIGFyZSBzdXBwb3J0ZWQsIHRoZSByb2xlIGlz IHNlbGVjdGVkIGJhc2VkIG9uIHZidXMvaWQuCj4gKyAqIEl0IGNvdWxkIGJlIHJlYWQgZnJvbSBP VEcgcmVnaXN0ZXIgb3IgZXh0ZXJuYWwgY29ubmVjdG9yLgo+ICsgKiBJZiBvbmx5IHNpbmdsZSBy b2xlIGlzIHN1cHBvcnRlZCwgb25seSBvbmUgcm9sZSBzdHJ1Y3R1cmUKPiArICogaXMgYWxsb2Nh dGVkLCBjZG5zLT5yb2xlc1tDRE5TM19ST0xFX0hPU1RdIG9yIGNkbnMtPnJvbGVzW0NETlMzX1JP TEVfR0FER0VUXS4KPiArICovCj4gK3N0YXRpYyBlbnVtIGNkbnMzX3JvbGVzIGNkbnMzX2dldF9p bml0aWFsX3JvbGUoc3RydWN0IGNkbnMzICpjZG5zKQo+ICt7Cj4gKwlpZiAoY2Rucy0+cm9sZXNb Q0ROUzNfUk9MRV9IT1NUXSAmJiBjZG5zLT5yb2xlc1tDRE5TM19ST0xFX0dBREdFVF0pIHsKPiAr CQlpZiAoY2RuczNfaXNfaG9zdChjZG5zKSkKPiArCQkJcmV0dXJuIENETlMzX1JPTEVfSE9TVDsK PiArCQlpZiAoY2RuczNfaXNfZGV2aWNlKGNkbnMpKQo+ICsJCQlyZXR1cm4gQ0ROUzNfUk9MRV9H QURHRVQ7Cj4gKwl9Cj4gKwlyZXR1cm4gY2Rucy0+cm9sZXNbQ0ROUzNfUk9MRV9IT1NUXQo+ICsJ CT8gQ0ROUzNfUk9MRV9IT1NUCj4gKwkJOiBDRE5TM19ST0xFX0dBREdFVDsKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgY2RuczNfZXhpdF9yb2xlcyhzdHJ1Y3QgY2RuczMgKmNkbnMpCj4gK3sKPiAr CWNkbnMzX3JvbGVfc3RvcChjZG5zKTsKPiArCWNkbnMzX2RyZF9leGl0KGNkbnMpOwo+ICt9Cj4g Kwo+ICsvKioKPiArICogY2RuczNfY29yZV9pbml0X3JvbGUgLSBpbml0aWFsaXplIHJvbGUgb2Yg b3BlcmF0aW9uCj4gKyAqIEBjZG5zOiBQb2ludGVyIHRvIGNkbnMzIHN0cnVjdHVyZQo+ICsgKgo+ ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvdGhlcndpc2UgbmVnYXRpdmUgZXJybm8KPiArICov Cj4gK3N0YXRpYyBpbnQgY2RuczNfY29yZV9pbml0X3JvbGUoc3RydWN0IGNkbnMzICpjZG5zKQo+ ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjZG5zLT5kZXY7Cj4gKwllbnVtIHVzYl9kcl9t b2RlIGJlc3RfZHJfbW9kZTsKPiArCWVudW0gdXNiX2RyX21vZGUgZHJfbW9kZTsKPiArCWludCBy ZXQgPSAwOwo+ICsKPiArCWRyX21vZGUgPSB1c2JfZ2V0X2RyX21vZGUoZGV2KTsKPiArCWNkbnMt PnJvbGUgPSBDRE5TM19ST0xFX0VORDsKPiArCj4gKwkvKgo+ICsJICogSWYgZHJpdmVyIGNhbid0 IHJlYWQgbW9kZSBieSBtZWFucyBvZiB1c2JfZ2V0X2RyX21kb2UgZnVuY3Rpb24gdGhlbgo+ICsJ ICogY2hvb3NlcyBtb2RlIGFjY29yZGluZyB3aXRoIEtlcm5lbCBjb25maWd1cmF0aW9uLiBUaGlz IHNldHRpbmcKPiArCSAqIGNhbiBiZSByZXN0cmljdGVkIGxhdGVyIGRlcGVuZGluZyBvbiBzdHJh cCBwaW4gY29uZmlndXJhdGlvbi4KPiArCSAqLwo+ICsJaWYgKGRyX21vZGUgPT0gVVNCX0RSX01P REVfVU5LTk9XTikgewo+ICsJCWlmIChJU19FTkFCTEVEKENPTkZJR19VU0JfQ0ROUzNfSE9TVCkg JiYKPiArCQkgICAgSVNfRU5BQkxFRChDT05GSUdfVVNCX0NETlMzX0dBREdFVCkpCj4gKwkJCWRy X21vZGUgPSBVU0JfRFJfTU9ERV9PVEc7Cj4gKwkJZWxzZSBpZiAoSVNfRU5BQkxFRChDT05GSUdf VVNCX0NETlMzX0hPU1QpKQo+ICsJCQlkcl9tb2RlID0gVVNCX0RSX01PREVfSE9TVDsKPiArCQll bHNlIGlmIChJU19FTkFCTEVEKENPTkZJR19VU0JfQ0ROUzNfR0FER0VUKSkKPiArCQkJZHJfbW9k ZSA9IFVTQl9EUl9NT0RFX1BFUklQSEVSQUw7Cj4gKwl9Cj4gKwo+ICsJYmVzdF9kcl9tb2RlID0g VVNCX0RSX01PREVfT1RHOwo+ICsKPiArCWlmIChkcl9tb2RlID09IFVTQl9EUl9NT0RFX09URykg ewo+ICsJCWJlc3RfZHJfbW9kZSA9IGNkbnMtPmRyX21vZGU7Cj4gKwl9IGVsc2UgaWYgKGNkbnMt PmRyX21vZGUgPT0gVVNCX0RSX01PREVfT1RHKSB7Cj4gKwkJYmVzdF9kcl9tb2RlID0gZHJfbW9k ZTsKPiArCX0gZWxzZSBpZiAoY2Rucy0+ZHJfbW9kZSAhPSBkcl9tb2RlKSB7Cj4gKwkJZGV2X2Vy cihkZXYsICJJbmNvcnJlY3QgRFJEIGNvbmZpZ3VyYXRpb25cbiIpOwo+ICsJCXJldHVybiAtRUlO VkFMOwo+ICsJfQo+ICsKPiArCWRyX21vZGUgPSBiZXN0X2RyX21vZGU7Cj4gKwo+ICsJaWYgKGRy X21vZGUgPT0gVVNCX0RSX01PREVfT1RHIHx8IGRyX21vZGUgPT0gVVNCX0RSX01PREVfSE9TVCkg ewo+ICsJCXJldCA9IGNkbnMzX2hvc3RfaW5pdChjZG5zKTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJ CWRldl9lcnIoZGV2LCAiSG9zdCBpbml0aWFsaXphdGlvbiBmYWlsZWQgd2l0aCAlZFxuIiwKPiAr CQkJCXJldCk7Cj4gKwkJCWdvdG8gZXJyOwo+ICsJCX0KPiArCX0KPiArCj4gKwlpZiAoZHJfbW9k ZSA9PSBVU0JfRFJfTU9ERV9PVEcgfHwgZHJfbW9kZSA9PSBVU0JfRFJfTU9ERV9QRVJJUEhFUkFM KSB7Cj4gKwkJcmV0ID0gY2RuczNfZ2FkZ2V0X2luaXQoY2Rucyk7Cj4gKwkJaWYgKHJldCkgewo+ ICsJCQlkZXZfZXJyKGRldiwgIkRldmljZSBpbml0aWFsaXphdGlvbiBmYWlsZWQgd2l0aCAlZFxu IiwKPiArCQkJCXJldCk7Cj4gKwkJCWdvdG8gZXJyOwoKRG8geW91IGNsZWFuIHVwIGZyb20gdGhl IGhvc3QgaW5pdCBoZXJlIHByb3Blcmx5PyAgIEl0J3MgaGFyZCB0byB0ZWxsLgoKPiArCQl9Cj4g Kwl9Cj4gKwo+ICsJY2Rucy0+ZGVzaXJlZF9kcl9tb2RlID0gZHJfbW9kZTsKPiArCWNkbnMtPmRy X21vZGUgPSBkcl9tb2RlOwo+ICsJLyoKPiArCSAqIGRyX21vZGUgY291bGQgYmUgY2hhbmdlIHNv IERSRCBtdXN0IHVwZGF0ZSBjb250cm9sbGVyCj4gKwkgKiBjb25maWd1cmF0aW9uCj4gKwkgKi8K PiArCXJldCA9IGNkbnMzX2RyZF91cGRhdGVfbW9kZShjZG5zKTsKPiArCWlmIChyZXQpCj4gKwkJ Z290byBlcnI7Cj4gKwo+ICsJY2Rucy0+cm9sZSA9IGNkbnMzX2dldF9pbml0aWFsX3JvbGUoY2Ru cyk7Cj4gKwo+ICsJcmV0ID0gY2RuczNfcm9sZV9zdGFydChjZG5zLCBjZG5zLT5yb2xlKTsKPiAr CWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgImNhbid0IHN0YXJ0ICVzIHJvbGVcbiIsCj4g KwkJCWNkbnMzX2dldF9jdXJyZW50X3JvbGVfZHJpdmVyKGNkbnMpLT5uYW1lKTsKPiArCQlnb3Rv IGVycjsKPiArCX0KPiArCj4gKwlyZXR1cm4gcmV0Owo+ICtlcnI6Cj4gKwljZG5zM19leGl0X3Jv bGVzKGNkbnMpOwo+ICsJcmV0dXJuIHJldDsKPiArfQoKdGhhbmtzLAoKZ3JlZyBrLWgK From mboxrd@z Thu Jan 1 00:00:00 1970 From: Greg KH Subject: Re: [PATCH v4 5/6] usb:cdns3 Add Cadence USB3 DRD Driver Date: Tue, 19 Feb 2019 14:24:03 +0100 Message-ID: <20190219132403.GC20719@kroah.com> References: <1550173514-23573-1-git-send-email-pawell@cadence.com> <1550173514-23573-6-git-send-email-pawell@cadence.com> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Return-path: Content-Disposition: inline In-Reply-To: <1550173514-23573-6-git-send-email-pawell@cadence.com> Sender: linux-kernel-owner@vger.kernel.org To: Pawel Laszczak Cc: devicetree@vger.kernel.org, felipe.balbi@linux.intel.com, mark.rutland@arm.com, linux-usb@vger.kernel.org, hdegoede@redhat.com, heikki.krogerus@linux.intel.com, andy.shevchenko@gmail.com, robh+dt@kernel.org, rogerq@ti.com, linux-kernel@vger.kernel.org, jbergsagel@ti.com, nsekhar@ti.com, nm@ti.com, sureshp@cadence.com, peter.chen@nxp.com, kurahul@cadence.com List-Id: devicetree@vger.kernel.org On Thu, Feb 14, 2019 at 07:45:13PM +0000, Pawel Laszczak wrote: > This patch introduce new Cadence USBSS DRD driver to linux kernel. Nit, "Linux" :) > The Cadence USBSS DRD Driver is a highly configurable IP Core whichi "whichi"? > can be instantiated as Dual-Role Device (DRD), Peripheral Only and > Host Only (XHCI)configurations. > > The current driver has been validated with FPGA burned. We have support I can not parse that sentance, sorry. what does "with FPGA burned" mean? > for PCIe bus, which is used on FPGA prototyping. > > The host side of USBSS-DRD controller is compliance with XHCI "compliant" > specification, so it works with standard XHCI linux driver. "Linux" > > Signed-off-by: Pawel Laszczak > --- > drivers/usb/Kconfig | 2 + > drivers/usb/Makefile | 2 + > drivers/usb/cdns3/Kconfig | 44 + > drivers/usb/cdns3/Makefile | 14 + > drivers/usb/cdns3/cdns3-pci-wrap.c | 155 +++ > drivers/usb/cdns3/core.c | 403 ++++++ > drivers/usb/cdns3/core.h | 116 ++ > drivers/usb/cdns3/debug.h | 168 +++ > drivers/usb/cdns3/debugfs.c | 164 +++ > drivers/usb/cdns3/drd.c | 365 +++++ > drivers/usb/cdns3/drd.h | 162 +++ > drivers/usb/cdns3/ep0.c | 907 +++++++++++++ > drivers/usb/cdns3/gadget-export.h | 28 + > drivers/usb/cdns3/gadget.c | 2003 ++++++++++++++++++++++++++++ > drivers/usb/cdns3/gadget.h | 1207 +++++++++++++++++ > drivers/usb/cdns3/host-export.h | 28 + > drivers/usb/cdns3/host.c | 72 + > drivers/usb/cdns3/trace.c | 23 + > drivers/usb/cdns3/trace.h | 404 ++++++ > 19 files changed, 6267 insertions(+) > create mode 100644 drivers/usb/cdns3/Kconfig > create mode 100644 drivers/usb/cdns3/Makefile > create mode 100644 drivers/usb/cdns3/cdns3-pci-wrap.c > create mode 100644 drivers/usb/cdns3/core.c > create mode 100644 drivers/usb/cdns3/core.h > create mode 100644 drivers/usb/cdns3/debug.h > create mode 100644 drivers/usb/cdns3/debugfs.c > create mode 100644 drivers/usb/cdns3/drd.c > create mode 100644 drivers/usb/cdns3/drd.h > create mode 100644 drivers/usb/cdns3/ep0.c > create mode 100644 drivers/usb/cdns3/gadget-export.h > create mode 100644 drivers/usb/cdns3/gadget.c > create mode 100644 drivers/usb/cdns3/gadget.h > create mode 100644 drivers/usb/cdns3/host-export.h > create mode 100644 drivers/usb/cdns3/host.c > create mode 100644 drivers/usb/cdns3/trace.c > create mode 100644 drivers/usb/cdns3/trace.h > > diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig > index 987fc5ba6321..5f9334019d04 100644 > --- a/drivers/usb/Kconfig > +++ b/drivers/usb/Kconfig > @@ -112,6 +112,8 @@ source "drivers/usb/usbip/Kconfig" > > endif > > +source "drivers/usb/cdns3/Kconfig" > + > source "drivers/usb/mtu3/Kconfig" > > source "drivers/usb/musb/Kconfig" > diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile > index 7d1b8c82b208..ab125b966cac 100644 > --- a/drivers/usb/Makefile > +++ b/drivers/usb/Makefile > @@ -12,6 +12,8 @@ obj-$(CONFIG_USB_DWC3) += dwc3/ > obj-$(CONFIG_USB_DWC2) += dwc2/ > obj-$(CONFIG_USB_ISP1760) += isp1760/ > > +obj-$(CONFIG_USB_CDNS3) += cdns3/ > + > obj-$(CONFIG_USB_MON) += mon/ > obj-$(CONFIG_USB_MTU3) += mtu3/ > > diff --git a/drivers/usb/cdns3/Kconfig b/drivers/usb/cdns3/Kconfig > new file mode 100644 > index 000000000000..27cb3d8dbe3d > --- /dev/null > +++ b/drivers/usb/cdns3/Kconfig > @@ -0,0 +1,44 @@ > +config USB_CDNS3 > + tristate "Cadence USB3 Dual-Role Controller" > + depends on USB_SUPPORT && (USB || USB_GADGET) && HAS_DMA > + help > + Say Y here if your system has a cadence USB3 dual-role controller. > + It supports: dual-role switch, Host-only, and Peripheral-only. > + > + If you choose to build this driver is a dynamically linked > + as module, the module will be called cdns3.ko. > + > +if USB_CDNS3 > + > +config USB_CDNS3_GADGET > + bool "Cadence USB3 device controller" > + depends on USB_GADGET > + help > + Say Y here to enable device controller functionality of the > + cadence USBSS-DEV driver. > + > + This controller supports FF, HS and SS mode. It doesn't support > + LS and SSP mode. > + > +config USB_CDNS3_HOST > + bool "Cadence USB3 host controller" > + depends on USB_XHCI_HCD > + help > + Say Y here to enable host controller functionality of the > + cadence driver. > + > + Host controller is compliant with XHCI so it will use > + standard XHCI driver. > + > +config USB_CDNS3_PCI_WRAP > + tristate "Cadence USB3 support on PCIe-based platforms" > + depends on USB_PCI && ACPI > + default USB_CDNS3 > + help > + If you're using the USBSS Core IP with a PCIe, please say > + 'Y' or 'M' here. > + > + If you choose to build this driver as module it will > + be dynamically linked and module will be called cdns3-pci.ko You use tabs here, but not tabs in the other options. Please be uniform. > + > +endif > diff --git a/drivers/usb/cdns3/Makefile b/drivers/usb/cdns3/Makefile > new file mode 100644 > index 000000000000..8f9438593375 > --- /dev/null > +++ b/drivers/usb/cdns3/Makefile > @@ -0,0 +1,14 @@ > +# SPDX-License-Identifier: GPL-2.0 > +# define_trace.h needs to know how to find our header > +CFLAGS_trace.o := -I$(src) > + > +cdns3-y := core.o drd.o trace.o > + > +obj-$(CONFIG_USB_CDNS3) += cdns3.o > +ifneq ($(CONFIG_DEBUG_FS),) > + cdns3-y += debugfs.o > +endif > + > +cdns3-$(CONFIG_USB_CDNS3_GADGET) += gadget.o ep0.o > +cdns3-$(CONFIG_USB_CDNS3_HOST) += host.o > +obj-$(CONFIG_USB_CDNS3_PCI_WRAP) += cdns3-pci-wrap.o > diff --git a/drivers/usb/cdns3/cdns3-pci-wrap.c b/drivers/usb/cdns3/cdns3-pci-wrap.c > new file mode 100644 > index 000000000000..d0b2d3d9b983 > --- /dev/null > +++ b/drivers/usb/cdns3/cdns3-pci-wrap.c > @@ -0,0 +1,155 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Cadence USBSS PCI Glue driver > + * > + * Copyright (C) 2018 Cadence. > + * > + * Author: Pawel Laszczak > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +struct cdns3_wrap { > + struct platform_device *plat_dev; > + struct pci_dev *hg_dev; > + struct resource dev_res[4]; > +}; > + > +struct cdns3_wrap wrap; > + > +#define RES_IRQ_ID 0 > +#define RES_HOST_ID 1 > +#define RES_DEV_ID 2 > +#define RES_DRD_ID 3 > + > +#define PCI_BAR_HOST 0 > +#define PCI_BAR_DEV 2 > +#define PCI_BAR_OTG 4 > + > +#define PCI_DEV_FN_HOST_DEVICE 0 > +#define PCI_DEV_FN_OTG 1 > + > +#define PCI_DRIVER_NAME "cdns3-pci-usbss" > +#define PLAT_DRIVER_NAME "cdns-usb3" > + > +#define CDNS_VENDOR_ID 0x17cd PCI_VENDOR_ID_CDNS is already in pci_ids.h, no need to define it again here. > +#define CDNS_DEVICE_ID 0x0100 No tabs? > + > +/** kerneldoc is great, but for static functions? Who is pulling these into documentation? If not, then no need for that format at all. > + * cdns3_pci_probe - Probe function for Cadence USB wrapper driver > + * @pdev: platform device object > + * @id: pci device id > + * > + * Returns 0 on success otherwise negative errno > + */ > +static int cdns3_pci_probe(struct pci_dev *pdev, > + const struct pci_device_id *id) > +{ > + struct platform_device_info plat_info; > + struct cdns3_wrap *wrap; > + struct resource *res; > + int err; > + > + /* > + * for GADGET/HOST PCI (devfn) function number is 0, > + * for OTG PCI (devfn) function number is 1 > + */ > + if (!id || pdev->devfn != PCI_DEV_FN_HOST_DEVICE) > + return -EINVAL; > + > + err = pcim_enable_device(pdev); > + if (err) { > + dev_err(&pdev->dev, "Enabling PCI device has failed %d\n", err); > + return err; > + } > + > + pci_set_master(pdev); > + wrap = devm_kzalloc(&pdev->dev, sizeof(*wrap), GFP_KERNEL); > + if (!wrap) { > + dev_err(&pdev->dev, "Failed to allocate memory\n"); No need to print an error again after kzalloc already printed an error. > + return -ENOMEM; Did you forget to disable the pci device? > + } > + > + /* function 0: host(BAR_0) + device(BAR_1) + otg(BAR_2)). */ > + memset(wrap->dev_res, 0x00, > + sizeof(struct resource) * ARRAY_SIZE(wrap->dev_res)); > + dev_dbg(&pdev->dev, "Initialize Device resources\n"); > + res = wrap->dev_res; > + > + res[RES_DEV_ID].start = pci_resource_start(pdev, PCI_BAR_DEV); > + res[RES_DEV_ID].end = pci_resource_end(pdev, PCI_BAR_DEV); > + res[RES_DEV_ID].name = "dev"; > + res[RES_DEV_ID].flags = IORESOURCE_MEM; > + dev_dbg(&pdev->dev, "USBSS-DEV physical base addr: %pa\n", > + &res[RES_DEV_ID].start); > + > + res[RES_HOST_ID].start = pci_resource_start(pdev, PCI_BAR_HOST); > + res[RES_HOST_ID].end = pci_resource_end(pdev, PCI_BAR_HOST); > + res[RES_HOST_ID].name = "xhci"; > + res[RES_HOST_ID].flags = IORESOURCE_MEM; > + dev_dbg(&pdev->dev, "USBSS-XHCI physical base addr: %pa\n", > + &res[RES_HOST_ID].start); > + > + res[RES_DRD_ID].start = pci_resource_start(pdev, PCI_BAR_OTG); > + res[RES_DRD_ID].end = pci_resource_end(pdev, PCI_BAR_OTG); > + res[RES_DRD_ID].name = "otg"; > + res[RES_DRD_ID].flags = IORESOURCE_MEM; > + dev_dbg(&pdev->dev, "USBSS-DRD physical base addr: %pa\n", > + &res[RES_DRD_ID].start); > + > + /* Interrupt common for both device and XHCI */ > + wrap->dev_res[RES_IRQ_ID].start = pdev->irq; > + wrap->dev_res[RES_IRQ_ID].name = "cdns3-irq"; > + wrap->dev_res[RES_IRQ_ID].flags = IORESOURCE_IRQ; > + > + /* set up platform device info */ > + memset(&plat_info, 0, sizeof(plat_info)); > + plat_info.parent = &pdev->dev; > + plat_info.fwnode = pdev->dev.fwnode; > + plat_info.name = PLAT_DRIVER_NAME; > + plat_info.id = pdev->devfn; > + plat_info.res = wrap->dev_res; > + plat_info.num_res = ARRAY_SIZE(wrap->dev_res); > + plat_info.dma_mask = pdev->dma_mask; > + > + /* register platform device */ > + wrap->plat_dev = platform_device_register_full(&plat_info); > + if (IS_ERR(wrap->plat_dev)) > + return PTR_ERR(wrap->plat_dev); No disabling of the device? Anyway, why are you creating a platform device when you have a real PCI device? That seems odd, and an abuse of the platform code. What's wrong with your real PCI device here? > + > + pci_set_drvdata(pdev, wrap); > + > + return err; > +} > + > +void cdns3_pci_remove(struct pci_dev *pdev) > +{ > + struct cdns3_wrap *wrap = (struct cdns3_wrap *)pci_get_drvdata(pdev); > + > + platform_device_unregister(wrap->plat_dev); > +} > + > +static const struct pci_device_id cdns3_pci_ids[] = { > + { PCI_DEVICE(CDNS_VENDOR_ID, CDNS_DEVICE_ID), }, > + { 0, } > +}; > + > +static struct pci_driver cdns3_pci_driver = { > + .name = PCI_DRIVER_NAME, > + .id_table = cdns3_pci_ids, > + .probe = cdns3_pci_probe, > + .remove = cdns3_pci_remove, > +}; > + > +module_pci_driver(cdns3_pci_driver); > +MODULE_DEVICE_TABLE(pci, cdns3_pci_ids); > + > +MODULE_AUTHOR("Pawel Laszczak "); > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("Cadence USBSS PCI wrapperr"); > + > diff --git a/drivers/usb/cdns3/core.c b/drivers/usb/cdns3/core.c > new file mode 100644 > index 000000000000..aa2f63241dab > --- /dev/null > +++ b/drivers/usb/cdns3/core.c > @@ -0,0 +1,403 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Cadence USBSS DRD Driver. > + * > + * Copyright (C) 2018 Cadence. > + * Copyright (C) 2017-2018 NXP > + * > + * Author: Peter Chen > + * Pawel Laszczak > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "gadget.h" > +#include "core.h" > +#include "host-export.h" > +#include "gadget-export.h" > +#include "drd.h" > +#include "debug.h" > + > +static inline > +struct cdns3_role_driver *cdns3_get_current_role_driver(struct cdns3 *cdns) > +{ > + WARN_ON(cdns->role >= CDNS3_ROLE_END || !cdns->roles[cdns->role]); What is someone supposed to do with this? > + return cdns->roles[cdns->role]; > +} > + > +static int cdns3_role_start(struct cdns3 *cdns, enum cdns3_roles role) > +{ > + int ret; > + > + if (WARN_ON(role >= CDNS3_ROLE_END)) Same here, how can this happen? What can I do if it does? > + return 0; > + > + if (!cdns->roles[role]) > + return -ENXIO; > + > + if (cdns->roles[role]->state == CDNS3_ROLE_STATE_ACTIVE) > + return 0; > + > + mutex_lock(&cdns->mutex); > + cdns->role = role; > + ret = cdns->roles[role]->start(cdns); > + if (!ret) > + cdns->roles[role]->state = CDNS3_ROLE_STATE_ACTIVE; > + mutex_unlock(&cdns->mutex); > + return ret; > +} > + > +void cdns3_role_stop(struct cdns3 *cdns) > +{ > + enum cdns3_roles role = cdns->role; > + > + if (role >= CDNS3_ROLE_END) { > + WARN_ON(role > CDNS3_ROLE_END); Again, why? > + return; > + } > + > + if (cdns->roles[role]->state == CDNS3_ROLE_STATE_INACTIVE) > + return; > + > + mutex_lock(&cdns->mutex); > + cdns->roles[role]->stop(cdns); > + cdns->roles[role]->state = CDNS3_ROLE_STATE_INACTIVE; > + mutex_unlock(&cdns->mutex); > +} > + > +/* > + * cdns->role gets from cdns3_get_initial_role, and this API tells role at the > + * runtime. > + * If both roles are supported, the role is selected based on vbus/id. > + * It could be read from OTG register or external connector. > + * If only single role is supported, only one role structure > + * is allocated, cdns->roles[CDNS3_ROLE_HOST] or cdns->roles[CDNS3_ROLE_GADGET]. > + */ > +static enum cdns3_roles cdns3_get_initial_role(struct cdns3 *cdns) > +{ > + if (cdns->roles[CDNS3_ROLE_HOST] && cdns->roles[CDNS3_ROLE_GADGET]) { > + if (cdns3_is_host(cdns)) > + return CDNS3_ROLE_HOST; > + if (cdns3_is_device(cdns)) > + return CDNS3_ROLE_GADGET; > + } > + return cdns->roles[CDNS3_ROLE_HOST] > + ? CDNS3_ROLE_HOST > + : CDNS3_ROLE_GADGET; > +} > + > +static void cdns3_exit_roles(struct cdns3 *cdns) > +{ > + cdns3_role_stop(cdns); > + cdns3_drd_exit(cdns); > +} > + > +/** > + * cdns3_core_init_role - initialize role of operation > + * @cdns: Pointer to cdns3 structure > + * > + * Returns 0 on success otherwise negative errno > + */ > +static int cdns3_core_init_role(struct cdns3 *cdns) > +{ > + struct device *dev = cdns->dev; > + enum usb_dr_mode best_dr_mode; > + enum usb_dr_mode dr_mode; > + int ret = 0; > + > + dr_mode = usb_get_dr_mode(dev); > + cdns->role = CDNS3_ROLE_END; > + > + /* > + * If driver can't read mode by means of usb_get_dr_mdoe function then > + * chooses mode according with Kernel configuration. This setting > + * can be restricted later depending on strap pin configuration. > + */ > + if (dr_mode == USB_DR_MODE_UNKNOWN) { > + if (IS_ENABLED(CONFIG_USB_CDNS3_HOST) && > + IS_ENABLED(CONFIG_USB_CDNS3_GADGET)) > + dr_mode = USB_DR_MODE_OTG; > + else if (IS_ENABLED(CONFIG_USB_CDNS3_HOST)) > + dr_mode = USB_DR_MODE_HOST; > + else if (IS_ENABLED(CONFIG_USB_CDNS3_GADGET)) > + dr_mode = USB_DR_MODE_PERIPHERAL; > + } > + > + best_dr_mode = USB_DR_MODE_OTG; > + > + if (dr_mode == USB_DR_MODE_OTG) { > + best_dr_mode = cdns->dr_mode; > + } else if (cdns->dr_mode == USB_DR_MODE_OTG) { > + best_dr_mode = dr_mode; > + } else if (cdns->dr_mode != dr_mode) { > + dev_err(dev, "Incorrect DRD configuration\n"); > + return -EINVAL; > + } > + > + dr_mode = best_dr_mode; > + > + if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) { > + ret = cdns3_host_init(cdns); > + if (ret) { > + dev_err(dev, "Host initialization failed with %d\n", > + ret); > + goto err; > + } > + } > + > + if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_PERIPHERAL) { > + ret = cdns3_gadget_init(cdns); > + if (ret) { > + dev_err(dev, "Device initialization failed with %d\n", > + ret); > + goto err; Do you clean up from the host init here properly? It's hard to tell. > + } > + } > + > + cdns->desired_dr_mode = dr_mode; > + cdns->dr_mode = dr_mode; > + /* > + * dr_mode could be change so DRD must update controller > + * configuration > + */ > + ret = cdns3_drd_update_mode(cdns); > + if (ret) > + goto err; > + > + cdns->role = cdns3_get_initial_role(cdns); > + > + ret = cdns3_role_start(cdns, cdns->role); > + if (ret) { > + dev_err(dev, "can't start %s role\n", > + cdns3_get_current_role_driver(cdns)->name); > + goto err; > + } > + > + return ret; > +err: > + cdns3_exit_roles(cdns); > + return ret; > +} thanks, greg k-h