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: [RFC,v1,03/14] usb:cdns3: Driver initialization code. From: Roger Quadros Message-Id: <5BE1A2C4.7030802@ti.com> Date: Tue, 6 Nov 2018 16:18:44 +0200 To: Pawel Laszczak , gregkh@linuxfoundation.org Cc: linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, adouglas@cadence.com, jbergsagel@ti.com, peter.chen@nxp.com, pjez@cadence.com, kurahul@cadence.com List-ID: T24gMDMvMTEvMTggMTk6NTEsIFBhd2VsIExhc3pjemFrIHdyb3RlOgo+IFBhdGNoIGFkZHMgY29y ZS5jIGFuZCBjb3JlLmggZmlsZSB0aGF0IGltcGxlbWVudHMgaW5pdGlhbGl6YXRpb24KPiBvZiBw bGF0Zm9ybSBkcml2ZXIgYW5kIGFkZHMgZnVuY3Rpb24gcmVzcG9uc2libGUgZm9yIHNlbGVjdGlu ZywKPiBzd2l0Y2hpbmcgYW5kIHJ1bm5pbmcgYXBwcm9wcmlhdGUgRGV2aWNlL0hvc3QgbW9kZS4K PiAKPiBQYXRjaCBhbHNvIGFkZHMgZ2FkZ2V0LmMsIGhvc3QuYywgZ2FkZ2V0LWV4cG9ydC5oLCBo b3N0LWV4cG9ydC5oLgo+IFRoZXNlIGZpbGVzIGNvbnRhaW5zIHRlbXBsYXRlcyBmdW5jdGlvbnMg dXNlZCBkdXJpbmcgaW5pdGlhbGl6YXRpb24uCj4gVGhlIGltcGxlbWVudGF0aW9uIHdpbGwgYmUg YWRkZWQgaW4gbmV4dCBwYXRjaGVzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IFBhd2VsIExhc3pjemFr IDxwYXdlbGxAY2FkZW5jZS5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvdXNiL2NkbnMzL0tjb25maWcg ICAgICAgICB8ICAyMCArKwo+ICBkcml2ZXJzL3VzYi9jZG5zMy9NYWtlZmlsZSAgICAgICAgfCAg IDQgKwo+ICBkcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmMgICAgICAgICAgfCAzNzMgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMvdXNiL2NkbnMzL2NvcmUuaCAgICAgICAg ICB8ICA4OCArKysrKysrCj4gIGRyaXZlcnMvdXNiL2NkbnMzL2dhZGdldC1leHBvcnQuaCB8ICAy NyArKysKPiAgZHJpdmVycy91c2IvY2RuczMvZ2FkZ2V0LmMgICAgICAgIHwgIDM2ICsrKwo+ICBk cml2ZXJzL3VzYi9jZG5zMy9ob3N0LWV4cG9ydC5oICAgfCAgMzAgKysrCj4gIGRyaXZlcnMvdXNi L2NkbnMzL2hvc3QuYyAgICAgICAgICB8ICAyOCArKysKPiAgOCBmaWxlcyBjaGFuZ2VkLCA2MDYg aW5zZXJ0aW9ucygrKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2RuczMvY29y ZS5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmgKPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvdXNiL2NkbnMzL2dhZGdldC1leHBvcnQuaAo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2RuczMvZ2FkZ2V0LmMKPiAgY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvdXNiL2NkbnMzL2hvc3QtZXhwb3J0LmgKPiAgY3JlYXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvdXNiL2NkbnMzL2hvc3QuYwo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3Vz Yi9jZG5zMy9LY29uZmlnIGIvZHJpdmVycy91c2IvY2RuczMvS2NvbmZpZwo+IGluZGV4IDg4ODQ1 ODM3MmFkYi4uNWY4OGE0OTMyZTU4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdXNiL2NkbnMzL0tj b25maWcKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9LY29uZmlnCj4gQEAgLTEwLDYgKzEwLDI2 IEBAIGNvbmZpZyBVU0JfQ0ROUzMKPiAgCj4gIGlmIFVTQl9DRE5TMwo+ICAKPiArY29uZmlnIFVT Ql9DRE5TM19HQURHRVQKPiArCWJvb2wgIkNhZGVuY2UgVVNCMyBkZXZpY2UgY29udHJvbGxlciIK PiArCWRlcGVuZHMgb24gVVNCX0dBREdFVAo+ICsJaGVscAo+ICsJICBTYXkgWSBoZXJlIHRvIGVu YWJsZSBkZXZpY2UgY29udHJvbGxlciBmdW5jdGlvbmFsaXR5IG9mIHRoZQo+ICsJICBjYWRlbmNl IFVTQlNTLURFViBkcml2ZXIuCj4gKwo+ICsJICBUaGlzIGNvbnRyb2xsZXIgc3VwcG9ydCBGRiwg SFMgYW5kIFNTIG1vZGUuIEl0IGRvZWFzbid0IHN1cHBvcnQKPiArCSAgTFMgYW5kIFNTUCBtb2Rl Cj4gKwo+ICtjb25maWcgVVNCX0NETlMzX0hPU1QKPiArCWJvb2wgIkNhZGVuY2UgVVNCMyBob3N0 IGNvbnRyb2xsZXIiCj4gKwlkZXBlbmRzIG9uIFVTQl9YSENJX0hDRAo+ICsJaGVscAo+ICsJICBT YXkgWSBoZXJlIHRvIGVuYWJsZSBob3N0IGNvbnRyb2xsZXIgZnVuY3Rpb25hbGl0eSBvZiB0aGUK PiArCSAgY2FkZW5jZSBkcml2ZXIuCj4gKwo+ICsJICBIb3N0IGNvbnRyb2xsZXIgaXMgY29tcGxp YW5jZSB3aXRoIFhIQ0kgc28gaXQgd2lsbCB1c2UKPiArCSAgc3RhbmRhcmQgWEhDSSBkcml2ZXIu Cj4gKwoKSXMgaXQgYmV0dGVyIHRvIHNwbGl0IHRoaXMgcGF0Y2ggaW50byAzIHBhcnRzPwoxKSBo b3N0IHN1cHBvcnQKMikgZ2FkZ2V0IHN1cHBvcnQKMykgRFJEIHN1cHBvcnQgKGFsb25nIHdpdGgg cGF0Y2ggNCkKCj4gIGNvbmZpZyBVU0JfQ0ROUzNfUENJX1dSQVAKPiAgCXRyaXN0YXRlICJQQ0ll LWJhc2VkIFBsYXRmb3JtcyIKPiAgCWRlcGVuZHMgb24gVVNCX1BDSSAmJiBBQ1BJCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvdXNiL2NkbnMzL01ha2VmaWxlIGIvZHJpdmVycy91c2IvY2RuczMvTWFr ZWZpbGUKPiBpbmRleCBkY2RkNjIwMDNjNmEuLjA4MzY3NmM3NzQ4ZiAxMDA2NDQKPiAtLS0gYS9k cml2ZXJzL3VzYi9jZG5zMy9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvdXNiL2NkbnMzL01ha2Vm aWxlCj4gQEAgLTEsMyArMSw3IEBACj4gK29iai0kKENPTkZJR19VU0JfQ0ROUzMpCQkJKz0gY2Ru czMubwo+ICBvYmotJChDT05GSUdfVVNCX0NETlMzX1BDSV9XUkFQKQkrPSBjZG5zMy1wY2kubwo+ ICAKPiArY2RuczMteQkJCQkJOj0gY29yZS5vCj4gK2NkbnMzLSQoQ09ORklHX1VTQl9DRE5TM19H QURHRVQpCSs9IGdhZGdldC5vCj4gK2NkbnMzLSQoQ09ORklHX1VTQl9DRE5TM19IT1NUKQkJKz0g aG9zdC5vCj4gIGNkbnMzLXBjaS15CQkgCQk6PSBjZG5zMy1wY2ktd3JhcC5vCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvdXNiL2NkbnMzL2NvcmUuYyBiL2RyaXZlcnMvdXNiL2NkbnMzL2NvcmUuYwo+ IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi43MjcxMzYyMzU5NTcK PiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvY2RuczMvY29yZS5jCj4gQEAgLTAs MCArMSwzNzMgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoK PiArICogQ2FkZW5jZSBVU0JTUyBEUkQgRHJpdmVyLgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMp IDIwMTggQ2FkZW5jZS4KPiArICoKPiArICogQXV0aG9yOiBQZXRlciBDaGVuIDxwZXRlci5jaGVu QG54cC5jb20+Cj4gKyAqICAgICAgICAgUGF3ZWwgTGFzemN6YWsgPHBhd2VsbEBjYWRlbmNlLmNv bT4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9rZXJuZWwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ICsj aW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pby5oPgo+ICsK PiArI2luY2x1ZGUgImdhZGdldC5oIgo+ICsjaW5jbHVkZSAiY29yZS5oIgo+ICsjaW5jbHVkZSAi aG9zdC1leHBvcnQuaCIKPiArI2luY2x1ZGUgImdhZGdldC1leHBvcnQuaCIKPiArCj4gK3N0YXRp YyBpbmxpbmUgc3RydWN0IGNkbnMzX3JvbGVfZHJpdmVyICpjZG5zM19yb2xlKHN0cnVjdCBjZG5z MyAqY2RucykKCmhvdyBhYm91dCBuYW1pbmcgdGhpcyB0byBjbmRzM19nZXRfY3VycmVudF9yb2xl X2RyaXZlcigpID8KCj4gK3sKPiArCVdBUk5fT04oY2Rucy0+cm9sZSA+PSBDRE5TM19ST0xFX0VO RCB8fCAhY2Rucy0+cm9sZXNbY2Rucy0+cm9sZV0pOwo+ICsJcmV0dXJuIGNkbnMtPnJvbGVzW2Nk bnMtPnJvbGVdOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCBjZG5zM19yb2xlX3N0YXJ0 KHN0cnVjdCBjZG5zMyAqY2RucywgZW51bSBjZG5zM19yb2xlcyByb2xlKQo+ICt7Cj4gKwlpbnQg cmV0Owo+ICsKPiArCWlmIChyb2xlID49IENETlMzX1JPTEVfRU5EKQo+ICsJCXJldHVybiAwOwo+ ICsKPiArCWlmICghY2Rucy0+cm9sZXNbcm9sZV0pCj4gKwkJcmV0dXJuIC1FTlhJTzsKPiArCj4g KwltdXRleF9sb2NrKCZjZG5zLT5tdXRleCk7Cj4gKwljZG5zLT5yb2xlID0gcm9sZTsKCllvdSBh cmUgY2hhbmdpbmcgdGhlIHJvbGUgaGVyZS4gU2hvdWxkbid0IGl0IGp1c3Qgc3RhcnQgd2hhdGV2 ZXIgcm9sZSBpcyBhbHJlYWR5IGluIGNkbnMtPnJvbGU/CkFuZCB5b3UgaGF2ZSBhIGNuZHMzX3Nl dF9yb2xlKCkgZnVuY3Rpb24gdG8gc2V0IHJvbGUuCgo+ICsJcmV0ID0gY2Rucy0+cm9sZXNbcm9s ZV0tPnN0YXJ0KGNkbnMpOwo+ICsJbXV0ZXhfdW5sb2NrKCZjZG5zLT5tdXRleCk7Cj4gKwlyZXR1 cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHZvaWQgY2RuczNfcm9sZV9zdG9wKHN0 cnVjdCBjZG5zMyAqY2RucykKPiArewo+ICsJZW51bSBjZG5zM19yb2xlcyByb2xlID0gY2Rucy0+ cm9sZTsKPiArCj4gKwlpZiAocm9sZSA9PSBDRE5TM19ST0xFX0VORCkKPiArCQlyZXR1cm47Cj4g Kwo+ICsJbXV0ZXhfbG9jaygmY2Rucy0+bXV0ZXgpOwo+ICsJY2Rucy0+cm9sZXNbcm9sZV0tPnN0 b3AoY2Rucyk7Cj4gKwljZG5zLT5yb2xlID0gQ0ROUzNfUk9MRV9FTkQ7Cj4gKwltdXRleF91bmxv Y2soJmNkbnMtPm11dGV4KTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgY2RuczNfc2V0X3JvbGUo c3RydWN0IGNkbnMzICpjZG5zLCBlbnVtIGNkbnMzX3JvbGVzIHJvbGUpCj4gK3sKPiArCWlmIChy b2xlID09IENETlMzX1JPTEVfRU5EKQo+ICsJCXJldHVybjsKPiArCj4gKwlpZiAocm9sZSA9PSBD RE5TM19ST0xFX0hPU1QpIHsKPiArCQkvL1RPRE86IHNldCBob3N0IHJvbGUKPiArCX0gZWxzZSB7 IC8qIGdhZGdldCBtb2RlICovCj4gKwkJLy9UT0RPOiBzZXQgZGV2aWNlIHJvbGUKPiArCX0KPiAr fQo+ICsKPiArc3RhdGljIGVudW0gY2RuczNfcm9sZXMgY2RuczNfZ2V0X3JvbGUoc3RydWN0IGNk bnMzICpjZG5zKQo+ICt7Cj4gKwlpZiAoY2Rucy0+cm9sZXNbQ0ROUzNfUk9MRV9IT1NUXSAmJiBj ZG5zLT5yb2xlc1tDRE5TM19ST0xFX0dBREdFVF0pIHsKPiArCQkvL1RPRE86IGltcGxlbWVudHMg c2VsZWN0aW5nIGRldmljZS9ob3N0IG1vZGUKPiArCQlyZXR1cm4gQ0ROUzNfUk9MRV9IT1NUOwo+ ICsJfQo+ICsJcmV0dXJuIGNkbnMtPnJvbGVzW0NETlMzX1JPTEVfSE9TVF0KPiArCQk/IENETlMz X1JPTEVfSE9TVAo+ICsJCTogQ0ROUzNfUk9MRV9HQURHRVQ7Cj4gK30KPiArCj4gKy8qKgo+ICsg KiBjZG5zM19jb3JlX2luaXRfcm9sZSAtIGluaXRpYWxpemUgcm9sZSBvZiBvcGVyYXRpb24KPiAr ICogQGNkbnM6IFBvaW50ZXIgdG8gY2RuczMgc3RydWN0dXJlCj4gKyAqCj4gKyAqIFJldHVybnMg MCBvbiBzdWNjZXNzIG90aGVyd2lzZSBuZWdhdGl2ZSBlcnJubwo+ICsgKi8KPiArc3RhdGljIGlu dCBjZG5zM19jb3JlX2luaXRfcm9sZShzdHJ1Y3QgY2RuczMgKmNkbnMpCj4gK3sKPiArCXN0cnVj dCBkZXZpY2UgKmRldiA9IGNkbnMtPmRldjsKPiArCWVudW0gdXNiX2RyX21vZGUgZHJfbW9kZTsK PiArCj4gKwlkcl9tb2RlID0gdXNiX2dldF9kcl9tb2RlKGRldik7Cj4gKwljZG5zLT5yb2xlID0g Q0ROUzNfUk9MRV9FTkQ7Cj4gKwo+ICsJaWYgKGRyX21vZGUgPT0gVVNCX0RSX01PREVfVU5LTk9X Tikgewo+ICsJCWlmIChJU19FTkFCTEVEKENPTkZJR19VU0JfQ0ROUzNfSE9TVCkgJiYKPiArCQkg ICAgSVNfRU5BQkxFRChDT05GSUdfVVNCX0NETlMzX0dBREdFVCkpCj4gKwkJCWRyX21vZGUgPSBV U0JfRFJfTU9ERV9PVEc7Cj4gKwkJZWxzZSBpZiAoSVNfRU5BQkxFRChDT05GSUdfVVNCX0NETlMz X0hPU1QpKQo+ICsJCQlkcl9tb2RlID0gVVNCX0RSX01PREVfSE9TVDsKPiArCQllbHNlIGlmIChJ U19FTkFCTEVEKENPTkZJR19VU0JfQ0ROUzNfREVWSUNFKSkKPiArCQkJZHJfbW9kZSA9IFVTQl9E Ul9NT0RFX1BFUklQSEVSQUw7Cj4gKwl9Cj4gKwo+ICsJaWYgKGRyX21vZGUgPT0gVVNCX0RSX01P REVfT1RHIHx8IGRyX21vZGUgPT0gVVNCX0RSX01PREVfSE9TVCkgewo+ICsJCWlmIChjZG5zM19o b3N0X2luaXQoY2RucykpCj4gKwkJCWRldl9pbmZvKGRldiwgImRvZXNuJ3Qgc3VwcG9ydCBob3N0 XG4iKTsKPiArCX0KPiArCj4gKwlpZiAoZHJfbW9kZSA9PSBVU0JfRFJfTU9ERV9PVEcgfHwgZHJf bW9kZSA9PSBVU0JfRFJfTU9ERV9QRVJJUEhFUkFMKSB7Cj4gKwkJaWYgKGNkbnMzX2dhZGdldF9p bml0KGNkbnMpKQo+ICsJCQlkZXZfaW5mbyhkZXYsICJkb2Vzbid0IHN1cHBvcnQgZ2FkZ2V0XG4i KTsKPiArCX0KPiArCj4gKwlpZiAoIWNkbnMtPnJvbGVzW0NETlMzX1JPTEVfSE9TVF0gJiYgIWNk bnMtPnJvbGVzW0NETlMzX1JPTEVfR0FER0VUXSkgewo+ICsJCWRldl9lcnIoZGV2LCAibm8gc3Vw cG9ydGVkIHJvbGVzXG4iKTsKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCX0KPiArCj4gKwljZG5z LT5kcl9tb2RlID0gZHJfbW9kZTsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICsvKioKPiArICog Y2RuczNfaXJxIC0gaW50ZXJydXB0IGhhbmRsZXIgZm9yIGNkbnMzIGNvcmUgZGV2aWNlCj4gKyAq Cj4gKyAqIEBpcnE6IGlycSBudW1iZXIgZm9yIGNkbnMzIGNvcmUgZGV2aWNlCj4gKyAqIEBkYXRh OiBzdHJ1Y3R1cmUgb2YgY2RuczMKPiArICoKPiArICogUmV0dXJucyBJUlFfSEFORExFRCBvciBJ UlFfTk9ORQo+ICsgKi8KPiArc3RhdGljIGlycXJldHVybl90IGNkbnMzX2lycShpbnQgaXJxLCB2 b2lkICpkYXRhKQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuczMgKmNkbnMgPSBkYXRhOwo+ICsJaXJxcmV0 dXJuX3QgcmV0ID0gSVJRX05PTkU7Cj4gKwo+ICsJaWYgKGNkbnMtPmluX2xwbSkgewo+ICsJCWRp c2FibGVfaXJxX25vc3luYyhjZG5zLT5pcnEpOwo+ICsJCWNkbnMtPndha2V1cF9pbnQgPSB0cnVl Owo+ICsJCXBtX3J1bnRpbWVfZ2V0KGNkbnMtPmRldik7Cgp3aGVyZSBpcyB0aGUgYmFsYW5jaW5n IHBtX3J1bnRpbWVfcHV0KCkgZm9yIHRoaXM/Cgo+ICsJCXJldHVybiBJUlFfSEFORExFRDsKPiAr CX0KPiArCj4gKwkvKiBIYW5kbGUgZGV2aWNlL2hvc3QgaW50ZXJydXB0ICovCj4gKwlpZiAoY2Ru cy0+cm9sZSAhPSBDRE5TM19ST0xFX0VORCkKPiArCQlyZXQgPSBjZG5zM19yb2xlKGNkbnMpLT5p cnEoY2Rucyk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgY2Ru czNfcmVtb3ZlX3JvbGVzKHN0cnVjdCBjZG5zMyAqY2RucykKPiArewo+ICsJY2RuczNfZ2FkZ2V0 X3JlbW92ZShjZG5zKTsKPiArCWNkbnMzX2hvc3RfcmVtb3ZlKGNkbnMpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgaW50IGNkbnMzX2RvX3JvbGVfc3dpdGNoKHN0cnVjdCBjZG5zMyAqY2RucywgZW51bSBj ZG5zM19yb2xlcyByb2xlKQo+ICt7Cj4gKwllbnVtIGNkbnMzX3JvbGVzIGN1cnJlbnRfcm9sZTsK PiArCWludCByZXQgPSAwOwo+ICsKPiArCWlmIChjZG5zLT5yb2xlID09IHJvbGUpCj4gKwkJcmV0 dXJuIDA7Cj4gKwo+ICsJcG1fcnVudGltZV9nZXRfc3luYyhjZG5zLT5kZXYpOwo+ICsJY3VycmVu dF9yb2xlID0gY2Rucy0+cm9sZTsKPiArCWNkbnMzX3JvbGVfc3RvcChjZG5zKTsKPiArCj4gKwlp ZiAocm9sZSA9PSBDRE5TM19ST0xFX0VORCkgewo+ICsJCXBtX3J1bnRpbWVfcHV0X3N5bmMoY2Ru cy0+ZGV2KTsKPiArCQlyZXR1cm4gMDsKPiArCX0KPiArCj4gKwlkZXZfZGJnKGNkbnMtPmRldiwg IlN3aXRjaGluZyByb2xlIik7Cj4gKwo+ICsJY2RuczNfc2V0X3JvbGUoY2Rucywgcm9sZSk7Cj4g KwlyZXQgPSBjZG5zM19yb2xlX3N0YXJ0KGNkbnMsIHJvbGUpOwo+ICsJaWYgKHJldCkgewo+ICsJ CS8qIEJhY2sgdG8gY3VycmVudCByb2xlICovCj4gKwkJZGV2X2VycihjZG5zLT5kZXYsICJzZXQg JWQgaGFzIGZhaWxlZCwgYmFjayB0byAlZFxuIiwKPiArCQkJcm9sZSwgY3VycmVudF9yb2xlKTsK PiArCQljZG5zM19zZXRfcm9sZShjZG5zLCBjdXJyZW50X3JvbGUpOwo+ICsJCXJldCA9IGNkbnMz X3JvbGVfc3RhcnQoY2RucywgY3VycmVudF9yb2xlKTsKPiArCX0KPiArCj4gKwlwbV9ydW50aW1l X3B1dF9zeW5jKGNkbnMtPmRldik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICsvKioKPiAr ICogY2RuczNfcm9sZV9zd2l0Y2ggLSB3b3JrIHF1ZXVlIGhhbmRsZXIgZm9yIHJvbGUgc3dpdGNo Cj4gKyAqCj4gKyAqIEB3b3JrOiB3b3JrIHF1ZXVlIGl0ZW0gc3RydWN0dXJlCj4gKyAqCj4gKyAq IEhhbmRsZXMgYmVsb3cgZXZlbnRzOgo+ICsgKiAtIFJvbGUgc3dpdGNoIGZvciBkdWFsLXJvbGUg ZGV2aWNlcwo+ICsgKiAtIENETlMzX1JPTEVfR0FER0VUIDwtLT4gQ0ROUzNfUk9MRV9FTkQgZm9y IHBlcmlwaGVyYWwtb25seSBkZXZpY2VzCj4gKyAqLwo+ICtzdGF0aWMgdm9pZCBjZG5zM19yb2xl X3N3aXRjaChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4gK3sKPiArCXN0cnVjdCBjZG5zMyAq Y2RuczsKPiArCWJvb2wgZGV2aWNlLCBob3N0Owo+ICsKPiArCWNkbnMgPSBjb250YWluZXJfb2Yo d29yaywgc3RydWN0IGNkbnMzLCByb2xlX3N3aXRjaF93cSk7Cj4gKwo+ICsJLy9UT0RPOiBpbXBs ZW1lbnRzIHRoaXMgZnVuY3Rpb25zLgo+ICsJLy9ob3N0ID0gY2RuczNfaXNfaG9zdChjZG5zKTsK PiArCS8vZGV2aWNlID0gY2RuczNfaXNfZGV2aWNlKGNkbnMpOwo+ICsJaG9zdCA9IDE7Cj4gKwlk ZXZpY2UgPSAwOwo+ICsKPiArCWlmIChob3N0KSB7Cj4gKwkJaWYgKGNkbnMtPnJvbGVzW0NETlMz X1JPTEVfSE9TVF0pCj4gKwkJCWNkbnMzX2RvX3JvbGVfc3dpdGNoKGNkbnMsIENETlMzX1JPTEVf SE9TVCk7Cj4gKwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCWlmIChkZXZpY2UpCj4gKwkJY2RuczNf ZG9fcm9sZV9zd2l0Y2goY2RucywgQ0ROUzNfUk9MRV9HQURHRVQpOwo+ICsJZWxzZQo+ICsJCWNk bnMzX2RvX3JvbGVfc3dpdGNoKGNkbnMsIENETlMzX1JPTEVfRU5EKTsKPiArfQoKQWxsIHJvbGUg c3dpdGNoaW5nIGNvZGUgY2FuIGNvbWUgYXMgcGFydCBvZiBEUkQgZHJpdmVyLgoKPiArCj4gKy8q Kgo+ICsgKiBjZG5zM19wcm9iZSAtIHByb2JlIGZvciBjZG5zMyBjb3JlIGRldmljZQo+ICsgKiBA cGRldjogUG9pbnRlciB0byBjZG5zMyBjb3JlIHBsYXRmb3JtIGRldmljZQo+ICsgKgo+ICsgKiBS ZXR1cm5zIDAgb24gc3VjY2VzcyBvdGhlcndpc2UgbmVnYXRpdmUgZXJybm8KPiArICovCj4gK3N0 YXRpYyBpbnQgY2RuczNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiArCXN0cnVjdCByZXNvdXJjZQkq cmVzOwo+ICsJc3RydWN0IGNkbnMzICpjZG5zOwo+ICsJdm9pZCBfX2lvbWVtICpyZWdzOwo+ICsJ aW50IHJldDsKPiArCj4gKwljZG5zID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpjZG5zKSwg R0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIWNkbnMpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJ Y2Rucy0+ZGV2ID0gZGV2Owo+ICsKPiArCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGNkbnMp Owo+ICsKPiArCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX0lS USwgMCk7Cj4gKwlpZiAoIXJlcykgewo+ICsJCWRldl9lcnIoZGV2LCAibWlzc2luZyBJUlFcbiIp Owo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsJY2Rucy0+aXJxID0gcmVzLT5zdGFydDsK PiArCj4gKwkvKgo+ICsJICogUmVxdWVzdCBtZW1vcnkgcmVnaW9uCj4gKwkgKiByZWdpb24tMDog eEhDSQo+ICsJICogcmVnaW9uLTE6IFBlcmlwaGVyYWwKPiArCSAqIHJlZ2lvbi0yOiBPVEcgcmVn aXN0ZXJzCj4gKwkgKi8KCkhlcmUgeW91IGFyZSBub3QgY2hlY2tpbmcgZm9yIEtjb25maWcgb3B0 aW9ucyBiZWZvcmUgZ2V0dGluZyByZXNvdXJjZXMgd2hpY2ggaXMgdGhlIHJpZ2h0IHRoaW5nLgpI b3dldmVyIHRoaXMgd2lsbCBiZSBicm9rZW4gaWYgeW91IGRvbid0IGdldCByaWQgb2YgdGhlIEtj b25maWcgY2hlY2tzIHdoZW4geW91IHBvcHVsYXRlIHRoZQpyZXNvdXJjZXMgaW4gcGF0Y2ggMS4K Cj4gKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDAp Owo+ICsJcmVncyA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7Cj4gKwo+ICsJaWYg KElTX0VSUihyZWdzKSkKPiArCQlyZXR1cm4gUFRSX0VSUihyZWdzKTsKPiArCWNkbnMtPnhoY2lf cmVncyA9IHJlZ3M7Cj4gKwljZG5zLT54aGNpX3JlcyA9IHJlczsKPiArCj4gKwlyZXMgPSBwbGF0 Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDEpOwo+ICsJcmVncyA9IGRl dm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7Cj4gKwlpZiAoSVNfRVJSKHJlZ3MpKQo+ICsJ CXJldHVybiBQVFJfRVJSKHJlZ3MpOwo+ICsJY2Rucy0+ZGV2X3JlZ3MJPSByZWdzOwo+ICsKPiAr CXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMik7Cj4g KwlyZWdzID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKGRldiwgcmVzKTsKPiArCWlmIChJU19FUlIo cmVncykpCj4gKwkJcmV0dXJuIFBUUl9FUlIocmVncyk7Cj4gKwljZG5zLT5vdGdfcmVncyA9IHJl Z3M7Cj4gKwo+ICsJbXV0ZXhfaW5pdCgmY2Rucy0+bXV0ZXgpOwo+ICsKPiArCXJldCA9IGNkbnMz X2NvcmVfaW5pdF9yb2xlKGNkbnMpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycjI7Cj4gKwo+ ICsJSU5JVF9XT1JLKCZjZG5zLT5yb2xlX3N3aXRjaF93cSwgY2RuczNfcm9sZV9zd2l0Y2gpOwo+ ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycjM7Cj4gKwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVy cjM7Cj4gKwo+ICsJY2Rucy0+cm9sZSA9IGNkbnMzX2dldF9yb2xlKGNkbnMpOwo+ICsJY2RuczNf c2V0X3JvbGUoY2RucywgY2Rucy0+cm9sZSk7Cj4gKwlyZXQgPSBjZG5zM19yb2xlX3N0YXJ0KGNk bnMsIGNkbnMtPnJvbGUpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LCAiY2FuJ3Qg c3RhcnQgJXMgcm9sZVxuIiwgY2RuczNfcm9sZShjZG5zKS0+bmFtZSk7Cj4gKwkJZ290byBlcnIz Owo+ICsJfQoKV2hhdCBleGFjdGx5IGRvZXMgcm9sZV9zdGFydCBoYXZlIHRvIGRvPwoKQ2FuIHlv dSBzdGFydCB0aGUgcm9sZSBiZWZvcmUgcmVxdWVzdGluZyBpcnE/Cgo+ICsKPiArCXJldCA9IGRl dm1fcmVxdWVzdF9pcnEoZGV2LCBjZG5zLT5pcnEsIGNkbnMzX2lycSwgSVJRRl9TSEFSRUQsCj4g KwkJCSAgICAgICBkZXZfbmFtZShkZXYpLCBjZG5zKTsKPiArCj4gKwlpZiAocmV0KQo+ICsJCWdv dG8gZXJyNDsKPiArCj4gKwlkZXZpY2Vfc2V0X3dha2V1cF9jYXBhYmxlKGRldiwgdHJ1ZSk7Cj4g KwlwbV9ydW50aW1lX3NldF9hY3RpdmUoZGV2KTsKPiArCXBtX3J1bnRpbWVfZW5hYmxlKGRldik7 Cj4gKwo+ICsJLyoKPiArCSAqIFRoZSBjb250cm9sbGVyIG5lZWRzIGxlc3MgdGltZSBiZXR3ZWVu IGJ1cyBhbmQgY29udHJvbGxlciBzdXNwZW5kLAo+ICsJICogYW5kIHdlIGFsc28gbmVlZHMgYSBz bWFsbCBkZWxheSB0byBhdm9pZCBmcmVxdWVudGx5IGVudGVyaW5nIGxvdwo+ICsJICogcG93ZXIg bW9kZS4KPiArCSAqLwo+ICsJcG1fcnVudGltZV9zZXRfYXV0b3N1c3BlbmRfZGVsYXkoZGV2LCAy MCk7Cj4gKwlwbV9ydW50aW1lX21hcmtfbGFzdF9idXN5KGRldik7Cj4gKwlwbV9ydW50aW1lX3Vz ZV9hdXRvc3VzcGVuZChkZXYpOwo+ICsJZGV2X2RiZyhkZXYsICJDYWRlbmNlIFVTQjMgY29yZTog cHJvYmUgc3VjY2VlZFxuIik7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtlcnI0Ogo+ICsJY2Ru czNfcm9sZV9zdG9wKGNkbnMpOwo+ICtlcnIzOgo+ICsJY2RuczNfcmVtb3ZlX3JvbGVzKGNkbnMp Owo+ICtlcnIyOgo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArLyoqCj4gKyAqIGNkbnMzX3Jl bW92ZSAtIHVuYmluZCBkcmQgZHJpdmVyIGFuZCBjbGVhbiB1cAo+ICsgKiBAcGRldjogUG9pbnRl ciB0byBMaW51eCBwbGF0Zm9ybSBkZXZpY2UKPiArICoKPiArICogUmV0dXJucyAwIG9uIHN1Y2Nl c3Mgb3RoZXJ3aXNlIG5lZ2F0aXZlIGVycm5vCj4gKyAqLwo+ICtzdGF0aWMgaW50IGNkbnMzX3Jl bW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuczMg KmNkbnMgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKPiArCj4gKwlwbV9ydW50aW1lX2dl dF9zeW5jKCZwZGV2LT5kZXYpOwo+ICsJcG1fcnVudGltZV9kaXNhYmxlKCZwZGV2LT5kZXYpOwo+ ICsJcG1fcnVudGltZV9wdXRfbm9pZGxlKCZwZGV2LT5kZXYpOwo+ICsJY2RuczNfcmVtb3ZlX3Jv bGVzKGNkbnMpOwoKU2hvdWxkbid0IHRoZSBvcmRlciBiZQoKcG1fcnVudGltZV9nZXRfc3luYygp OwpjZG5zM19yZW1vdmVfcm9sZXMoKTsKcG1fcnVudGltZV9wdXRfbm9pZGxlKCk7CnBtX3J1bnRp bWVfZGlzYWJsZSgpOwoKPiArCXVzYl9waHlfc2h1dGRvd24oY2Rucy0+dXNicGh5KTsKCnlvdSBk aWRuJ3QgY2FsbCB1c2JfcGh5X2luaXQoKSBhbnl3aGVyZS4KCj4gKwo+ICsJcmV0dXJuIDA7Cj4g K30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGNkbnMzX2RyaXZlciA9IHsK PiArCS5wcm9iZQkJPSBjZG5zM19wcm9iZSwKPiArCS5yZW1vdmUJCT0gY2RuczNfcmVtb3ZlLAo+ ICsJLmRyaXZlcgkJPSB7Cj4gKwkJLm5hbWUJPSAiY2Rucy11c2IzIiwKPiArCX0sCj4gK307Cj4g Kwo+ICtzdGF0aWMgaW50IF9faW5pdCBjZG5zM19kcml2ZXJfcGxhdGZvcm1fcmVnaXN0ZXIodm9p ZCkKPiArewo+ICsJY2RuczNfaG9zdF9kcml2ZXJfaW5pdCgpOwoKV2h5IGlzIGEgY2FsbCB0byBo b3N0X2RyaXZlcl9pbml0KCkgcmVxdWlyZWQ/Cgo+ICsJcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9y ZWdpc3RlcigmY2RuczNfZHJpdmVyKTsKPiArfQo+ICttb2R1bGVfaW5pdChjZG5zM19kcml2ZXJf cGxhdGZvcm1fcmVnaXN0ZXIpOwo+ICsKPiArc3RhdGljIHZvaWQgX19leGl0IGNkbnMzX2RyaXZl cl9wbGF0Zm9ybV91bnJlZ2lzdGVyKHZvaWQpCj4gK3sKPiArCXBsYXRmb3JtX2RyaXZlcl91bnJl Z2lzdGVyKCZjZG5zM19kcml2ZXIpOwo+ICt9Cj4gK21vZHVsZV9leGl0KGNkbnMzX2RyaXZlcl9w bGF0Zm9ybV91bnJlZ2lzdGVyKTsKPiArCj4gK01PRFVMRV9BTElBUygicGxhdGZvcm06Y2RuczMi KTsKPiArTU9EVUxFX0FVVEhPUigiUGF3ZWwgTGFzemN6YWsgPHBhd2VsbEBjYWRlbmNlLmNvbT4i KTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIkNh ZGVuY2UgVVNCMyBEUkQgQ29udHJvbGxlciBEcml2ZXIiKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy91c2IvY2RuczMvY29yZS5oIGIvZHJpdmVycy91c2IvY2RuczMvY29yZS5oCj4gbmV3IGZpbGUg bW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmU3MTU5YzQ3NDMwOAo+IC0tLSAvZGV2 L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmgKPiBAQCAtMCwwICsxLDg4IEBA Cj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCj4gKy8qCj4gKyAqIENh ZGVuY2UgVVNCU1MgRFJEIERyaXZlci4KPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE3IE5Y UAo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTggQ2FkZW5jZS4KPiArICoKPiArICogQXV0aG9yczog UGV0ZXIgQ2hlbiA8cGV0ZXIuY2hlbkBueHAuY29tPgo+ICsgKiAgICAgICAgICBQYXdlbCBMYXN6 Y3phayA8cGF3ZWxsQGNhZGVuY2UuY29tPgo+ICsgKi8KPiArI2luY2x1ZGUgPGxpbnV4L3VzYi9v dGcuaD4KPiArCj4gKyNpZm5kZWYgX19MSU5VWF9DRE5TM19DT1JFX0gKPiArI2RlZmluZSBfX0xJ TlVYX0NETlMzX0NPUkVfSAo+ICsKPiArc3RydWN0IGNkbnMzOwo+ICtlbnVtIGNkbnMzX3JvbGVz IHsKPiArCUNETlMzX1JPTEVfSE9TVCA9IDAsCj4gKwlDRE5TM19ST0xFX0dBREdFVCwKPiArCUNE TlMzX1JPTEVfRU5ELAo+ICsJQ0ROUzNfUk9MRV9PVEcsCgpXaHkgaXMgT1RHIGFmdGVyIEVORD8K RG9lcyBPVEcgaGF2ZSBhIHJvbGUgZHJpdmVyIGFzIHdlbGw/IElmIG5vdCBpdCBtdXN0IG5vdCBj b21lIGhlcmUuIEl0IGlzIGEgbW9kZSwgbm90IGEgcm9sZS4KCj4gK307Cj4gKwo+ICsvKioKPiAr ICogc3RydWN0IGNkbnMzX3JvbGVfZHJpdmVyIC0gaG9zdC9nYWRnZXQgcm9sZSBkcml2ZXIKPiAr ICogQHN0YXJ0OiBzdGFydCB0aGlzIHJvbGUKPiArICogQHN0b3A6IHN0b3AgdGhpcyByb2xlCj4g KyAqIEBzdXNwZW5kOiBzdXNwZW5kIGNhbGxiYWNrIGZvciB0aGlzIHJvbGUKPiArICogQHJlc3Vt ZTogcmVzdW1lIGNhbGxiYWNrIGZvciB0aGlzIHJvbGUKPiArICogQGlycTogaXJxIGhhbmRsZXIg Zm9yIHRoaXMgcm9sZQo+ICsgKiBAbmFtZTogcm9sZSBuYW1lIHN0cmluZyAoaG9zdC9nYWRnZXQp Cj4gKyAqLwo+ICtzdHJ1Y3QgY2RuczNfcm9sZV9kcml2ZXIgewo+ICsJaW50ICgqc3RhcnQpKHN0 cnVjdCBjZG5zMyAqY2Rucyk7Cj4gKwl2b2lkICgqc3RvcCkoc3RydWN0IGNkbnMzICpjZG5zKTsK PiArCWludCAoKnN1c3BlbmQpKHN0cnVjdCBjZG5zMyAqY2RucywgYm9vbCBkb193YWtldXApOwo+ ICsJaW50ICgqcmVzdW1lKShzdHJ1Y3QgY2RuczMgKmNkbnMsIGJvb2wgaGliZXJuYXRlZCk7Cj4g KwlpcnFyZXR1cm5fdCAoKmlycSkoc3RydWN0IGNkbnMzICpjZG5zKTsKPiArCWNvbnN0IGNoYXIg Km5hbWU7Cj4gK307Cj4gKwo+ICsjZGVmaW5lIENETlMzX05VTV9PRl9DTEtTCTUKPiArLyoqCj4g KyAqIHN0cnVjdCBjZG5zMyAtIFJlcHJlc2VudGF0aW9uIG9mIENhZGVuY2UgVVNCMyBEUkQgY29u dHJvbGxlci4KPiArICogQGRldjogcG9pbnRlciB0byBDYWRlbmNlIGRldmljZSBzdHJ1Y3QKPiAr ICogQHhoY2lfcmVnczogcG9pbnRlciB0byBiYXNlIG9mIHhoY2kgcmVnaXN0ZXJzCj4gKyAqIEB4 aGNpX3JlczogdGhlIHJlc291cmNlIGZvciB4aGNpCj4gKyAqIEBkZXZfcmVnczogcG9pbnRlciB0 byBiYXNlIG9mIGRldiByZWdpc3RlcnMKPiArICogQG90Z19yZWdzOiBwb2ludGVyIHRvIGJhc2Ug b2Ygb3RnIHJlZ2lzdGVycwo+ICsgKiBAaXJxOiBpcnEgbnVtYmVyIGZvciBjb250cm9sbGVyCj4g KyAqIEByb2xlczogYXJyYXkgb2Ygc3VwcG9ydGVkIHJvbGVzIGZvciB0aGlzIGNvbnRyb2xsZXIK PiArICogQHJvbGU6IGN1cnJlbnQgcm9sZQo+ICsgKiBAaG9zdF9kZXY6IHRoZSBjaGlsZCBob3N0 IGRldmljZSBwb2ludGVyIGZvciBjZG5zMyBjb3JlCj4gKyAqIEBnYWRnZXRfZGV2OiB0aGUgY2hp bGQgZ2FkZ2V0IGRldmljZSBwb2ludGVyIGZvciBjZG5zMyBjb3JlCj4gKyAqIEB1c2JwaHk6IHVz YnBoeSBmb3IgdGhpcyBjb250cm9sbGVyCj4gKyAqIEByb2xlX3N3aXRjaF93cTogd29yayBxdWV1 ZSBpdGVtIGZvciByb2xlIHN3aXRjaAo+ICsgKiBAaW5fbHBtOiB0aGUgY29udHJvbGxlciBpbiBs b3cgcG93ZXIgbW9kZQo+ICsgKiBAd2FrZXVwX2ludDogdGhlIHdha2V1cCBpbnRlcnJ1cHQKPiAr ICogQG11dGV4OiB0aGUgbXV0ZXggZm9yIGNvbmN1cnJlbnQgY29kZSBhdCBkcml2ZXIKPiArICog QGRyX21vZGU6IHJlcXVlc3RlZCBtb2RlIG9mIG9wZXJhdGlvbgo+ICsgKiBAY3VycmVudF9kcl9y b2xlOiBjdXJyZW50IHJvbGUgb2Ygb3BlcmF0aW9uIHdoZW4gaW4gZHVhbC1yb2xlIG1vZGUKPiAr ICogQGRlc2lyZWRfZHJfcm9sZTogZGVzaXJlZCByb2xlIG9mIG9wZXJhdGlvbiB3aGVuIGluIGR1 YWwtcm9sZSBtb2RlCj4gKyAqIEByb290OiBkZWJ1Z2ZzIHJvb3QgZm9sZGVyIHBvaW50ZXIKPiAr ICovCj4gK3N0cnVjdCBjZG5zMyB7Cj4gKwlzdHJ1Y3QgZGV2aWNlCQkJKmRldjsKPiArCXZvaWQg X19pb21lbQkJCSp4aGNpX3JlZ3M7Cj4gKwlzdHJ1Y3QgcmVzb3VyY2UJCQkqeGhjaV9yZXM7Cj4g KwlzdHJ1Y3QgY2RuczNfdXNiX3JlZ3MgX19pb21lbQkqZGV2X3JlZ3M7Cj4gKwlzdHJ1Y3QgY2Ru czNfb3RnX3JlZ3MJCSpvdGdfcmVnczsKPiArCWludCBpcnE7Cj4gKwlzdHJ1Y3QgY2RuczNfcm9s ZV9kcml2ZXIJKnJvbGVzW0NETlMzX1JPTEVfRU5EXTsKPiArCWVudW0gY2RuczNfcm9sZXMJCXJv bGU7Cj4gKwlzdHJ1Y3QgZGV2aWNlCQkJKmhvc3RfZGV2Owo+ICsJc3RydWN0IGRldmljZQkJCSpn YWRnZXRfZGV2Owo+ICsJc3RydWN0IHVzYl9waHkJCQkqdXNicGh5Owo+ICsJc3RydWN0IHdvcmtf c3RydWN0CQlyb2xlX3N3aXRjaF93cTsKPiArCWludAkJCQlpbl9scG06MTsKPiArCWludAkJCQl3 YWtldXBfaW50OjE7Cj4gKwkvKiBtdXRleHQgdXNlZCBpbiB3b3JrcXVldWUqLwo+ICsJc3RydWN0 IG11dGV4CQkJbXV0ZXg7Cj4gKwllbnVtIHVzYl9kcl9tb2RlCQlkcl9tb2RlOwo+ICsJZW51bSB1 c2JfZHJfbW9kZQkJY3VycmVudF9kcl9tb2RlOwo+ICsJZW51bSB1c2JfZHJfbW9kZQkJZGVzaXJl ZF9yb2xlOwo+ICsJc3RydWN0IGRlbnRyeQkJCSpyb290Owo+ICt9Owo+ICsKPiArI2VuZGlmIC8q IF9fTElOVVhfQ0ROUzNfQ09SRV9IICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NkbnMz L2dhZGdldC1leHBvcnQuaCBiL2RyaXZlcnMvdXNiL2NkbnMzL2dhZGdldC1leHBvcnQuaAo+IG5l dyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi4yNTdlNWUwZWVmMzEKPiAt LS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvY2RuczMvZ2FkZ2V0LWV4cG9ydC5oCj4g QEAgLTAsMCArMSwyNyBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAq Lwo+ICsvKgo+ICsgKiBDYWRlbmNlIFVTQlNTIERSRCBEcml2ZXIgLUdhZGdldCBFeHBvcnQgQVBJ cwo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTcgTlhQCj4gKyAqCj4gKyAqIEF1dGhvcnM6 IFBldGVyIENoZW4gPHBldGVyLmNoZW5AbnhwLmNvbT4KPiArICovCj4gKyNpZm5kZWYgX19MSU5V WF9DRE5TM19HQURHRVRfRVhQT1JUCj4gKyNkZWZpbmUgX19MSU5VWF9DRE5TM19HQURHRVRfRVhQ T1JUCj4gKwo+ICsjaWZkZWYgQ09ORklHX1VTQl9DRE5TM19HQURHRVQKPiArCj4gK2ludCBjZG5z M19nYWRnZXRfaW5pdChzdHJ1Y3QgY2RuczMgKmNkbnMpOwo+ICt2b2lkIGNkbnMzX2dhZGdldF9y ZW1vdmUoc3RydWN0IGNkbnMzICpjZG5zKTsKPiArI2Vsc2UKPiArCj4gK3N0YXRpYyBpbmxpbmUg aW50IGNkbnMzX2dhZGdldF9pbml0KHN0cnVjdCBjZG5zMyAqY2RucykKPiArewo+ICsJcmV0dXJu IC1FTlhJTzsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIGNkbnMzX2dhZGdldF9yZW1v dmUoc3RydWN0IGNkbnMzICpjZG5zKSB7IH0KPiArCj4gKyNlbmRpZgo+ICsKPiArI2VuZGlmIC8q IF9fTElOVVhfQ0ROUzNfR0FER0VUX0VYUE9SVCAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3Vz Yi9jZG5zMy9nYWRnZXQuYyBiL2RyaXZlcnMvdXNiL2NkbnMzL2dhZGdldC5jCj4gbmV3IGZpbGUg bW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjQxY2U2OTY3MTlkNwo+IC0tLSAvZGV2 L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5zMy9nYWRnZXQuYwo+IEBAIC0wLDAgKzEsMzYg QEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICogQ2Fk ZW5jZSBVU0JTUyBEUkQgRHJpdmVyIC0gZ2FkZ2V0IHNpZGUuCj4gKyAqCj4gKyAqIENvcHlyaWdo dCAoQykgMjAxOCBDYWRlbmNlIERlc2lnbiBTeXN0ZW1zLgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIw MTcgTlhQCj4gKyAqCj4gKyAqIEF1dGhvcnM6IFBhd2VsIEpleiA8cGplekBjYWRlbmNlLmNvbT4s Cj4gKyAqICAgICAgICAgIFBhd2VsIExhc3pjemFrIDxwYXdlbGxAY2FkZW5jZS5jb20+Cj4gKyAq CSAgICBQZXRlciBDaGVuIDxwZXRlci5jaGVuQG54cC5jb20+Cj4gKyAqLwo+ICsKPiArI2luY2x1 ZGUgImNvcmUuaCIKPiArCj4gKy8qKgo+ICsgKiBjZG5zM19nYWRnZXRfcmVtb3ZlOiBwYXJlbnQg bXVzdCBjYWxsIHRoaXMgdG8gcmVtb3ZlIFVEQwo+ICsgKgo+ICsgKiBjZG5zOiBjZG5zMyBpbnN0 YW5jZQo+ICsgKi8KPiArdm9pZCBjZG5zM19nYWRnZXRfcmVtb3ZlKHN0cnVjdCBjZG5zMyAqY2Ru cykKPiArewo+ICsJLy9UT0RPOiBpbXBsZW1lbnRzIHRoaXMgZnVuY3Rpb24KPiArfQo+ICsKPiAr LyoqCj4gKyAqIGNkbnMzX2dhZGdldF9pbml0IC0gaW5pdGlhbGl6ZSBkZXZpY2Ugc3RydWN0dXJl Cj4gKyAqCj4gKyAqIGNkbnM6IGNkbnMzIGluc3RhbmNlCj4gKyAqCj4gKyAqIFRoaXMgZnVuY3Rp b24gaW5pdGlhbGl6ZXMgdGhlIGdhZGdldC4KPiArICovCj4gK2ludCBjZG5zM19nYWRnZXRfaW5p dChzdHJ1Y3QgY2RuczMgKmNkbnMpCj4gK3sKPiArCS8vVE9ETzogaW1wbGVtZW50cyB0aGlzIGZ1 bmN0aW9uCj4gKwlyZXR1cm4gMDsKPiArfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jZG5z My9ob3N0LWV4cG9ydC5oIGIvZHJpdmVycy91c2IvY2RuczMvaG9zdC1leHBvcnQuaAo+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi5mOGYzYjIzMGI0NzIKPiAtLS0g L2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvY2RuczMvaG9zdC1leHBvcnQuaAo+IEBAIC0w LDAgKzEsMzAgQEAKPiArLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KPiAr LyoKPiArICogQ2FkZW5jZSBVU0JTUyBEUkQgRHJpdmVyIC1Ib3N0IEV4cG9ydCBBUElzCj4gKyAq Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxNyBOWFAKPiArICoKPiArICogQXV0aG9yczogUGV0ZXIg Q2hlbiA8cGV0ZXIuY2hlbkBueHAuY29tPgo+ICsgKi8KPiArI2lmbmRlZiBfX0xJTlVYX0NETlMz X0hPU1RfRVhQT1JUCj4gKyNkZWZpbmUgX19MSU5VWF9DRE5TM19IT1NUX0VYUE9SVAo+ICsKPiAr I2lmZGVmIENPTkZJR19VU0JfQ0ROUzNfSE9TVAo+ICsKPiAraW50IGNkbnMzX2hvc3RfaW5pdChz dHJ1Y3QgY2RuczMgKmNkbnMpOwo+ICt2b2lkIGNkbnMzX2hvc3RfcmVtb3ZlKHN0cnVjdCBjZG5z MyAqY2Rucyk7Cj4gK3ZvaWQgY2RuczNfaG9zdF9kcml2ZXJfaW5pdCh2b2lkKTsKCndoeSBpcyBj ZG5zM19ob3N0X2RyaXZlcl9pbml0KCkgcmVxdWlyZWQ/Cgo+ICsKPiArI2Vsc2UKPiArCj4gK3N0 YXRpYyBpbmxpbmUgaW50IGNkbnMzX2hvc3RfaW5pdChzdHJ1Y3QgY2RuczMgKmNkbnMpCj4gK3sK PiArCXJldHVybiAtRU5YSU87Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBjZG5zM19o b3N0X3JlbW92ZShzdHJ1Y3QgY2RuczMgKmNkbnMpIHsgfQo+ICtzdGF0aWMgaW5saW5lIHZvaWQg Y2RuczNfaG9zdF9kcml2ZXJfaW5pdCh2b2lkKSB7fQo+ICsKPiArI2VuZGlmIC8qIENPTkZJR19V U0JfQ0ROUzNfSE9TVCAqLwo+ICsKPiArI2VuZGlmIC8qIF9fTElOVVhfQ0ROUzNfSE9TVF9FWFBP UlQgKi8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMvaG9zdC5jIGIvZHJpdmVycy91 c2IvY2RuczMvaG9zdC5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAw MDAuLjM3MzAwOTg1ZTJkNgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3VzYi9jZG5z My9ob3N0LmMKPiBAQCAtMCwwICsxLDI4IEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wCj4gKy8qCj4gKyAqIENhZGVuY2UgVVNCU1MgRFJEIERyaXZlciAtIGhvc3Qgc2lk ZQo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTggQ2FkZW5jZSBEZXNpZ24gU3lzdGVtcy4K PiArICogQ29weXJpZ2h0IChDKSAyMDE4IE5YUAo+ICsgKgo+ICsgKiBBdXRob3JzOiBQZXRlciBD aGVuIDxwZXRlci5jaGVuQG54cC5jb20+Cj4gKyAqCSAgICBQYXdlbCBMYXN6Y3phayA8cGF3ZWxs QGNhZGVuY2UuY29tPgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlICJjb3JlLmgiCj4gKwo+ICtpbnQg Y2RuczNfaG9zdF9pbml0KHN0cnVjdCBjZG5zMyAqY2RucykKPiArewo+ICsJLy9UT0RPOiBpbXBs ZW1lbnRzIHRoaXMgZnVuY3Rpb24KPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICt2b2lkIGNkbnMz X2hvc3RfcmVtb3ZlKHN0cnVjdCBjZG5zMyAqY2RucykKPiArewo+ICsgIC8vVE9ETzogaW1wbGVt ZW50cyB0aGlzIGZ1bmN0aW9uCj4gK30KPiArCj4gK3ZvaWQgX19pbml0IGNkbnMzX2hvc3RfZHJp dmVyX2luaXQodm9pZCkKPiArewo+ICsJLy9UT0RPOiBpbXBsZW1lbnRzIHRoaXMgZnVuY3Rpb24K PiArfQo+IAoKY2hlZXJzLAotcm9nZXIK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1706DC32789 for ; Tue, 6 Nov 2018 14:19:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A25FA20685 for ; Tue, 6 Nov 2018 14:19:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A25FA20685 Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=ti.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388642AbeKFXo0 (ORCPT ); Tue, 6 Nov 2018 18:44:26 -0500 Received: from lelv0143.ext.ti.com ([198.47.23.248]:57182 "EHLO lelv0143.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729642AbeKFXo0 (ORCPT ); Tue, 6 Nov 2018 18:44:26 -0500 Received: from lelv0266.itg.ti.com ([10.180.67.225]) by lelv0143.ext.ti.com (8.15.2/8.15.2) with ESMTP id wA6EImAP014382; Tue, 6 Nov 2018 08:18:48 -0600 Received: from DFLE102.ent.ti.com (dfle102.ent.ti.com [10.64.6.23]) by lelv0266.itg.ti.com (8.15.2/8.15.2) with ESMTPS id wA6EIm65071540 (version=TLSv1.2 cipher=AES256-GCM-SHA384 bits=256 verify=FAIL); Tue, 6 Nov 2018 08:18:48 -0600 Received: from DFLE103.ent.ti.com (10.64.6.24) by DFLE102.ent.ti.com (10.64.6.23) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1466.3; Tue, 6 Nov 2018 08:18:48 -0600 Received: from dlep33.itg.ti.com (157.170.170.75) by DFLE103.ent.ti.com (10.64.6.24) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1466.3 via Frontend Transport; Tue, 6 Nov 2018 08:18:47 -0600 Received: from [192.168.2.6] (ileax41-snat.itg.ti.com [10.172.224.153]) by dlep33.itg.ti.com (8.14.3/8.13.8) with ESMTP id wA6EIjlv009441; Tue, 6 Nov 2018 08:18:45 -0600 Subject: Re: [RFC PATCH v1 03/14] usb:cdns3: Driver initialization code. To: Pawel Laszczak , References: <1541267487-3664-1-git-send-email-pawell@cadence.com> <1541267487-3664-4-git-send-email-pawell@cadence.com> CC: , , , , , , From: Roger Quadros Message-ID: <5BE1A2C4.7030802@ti.com> Date: Tue, 6 Nov 2018 16:18:44 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.6.0 MIME-Version: 1.0 In-Reply-To: <1541267487-3664-4-git-send-email-pawell@cadence.com> Content-Type: text/plain; charset="windows-1252" Content-Transfer-Encoding: 7bit X-EXCLAIMER-MD-CONFIG: e1e8a2fd-e40a-4ac6-ac9b-f7e9cc9ee180 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 03/11/18 19:51, Pawel Laszczak wrote: > Patch adds core.c and core.h file that implements initialization > of platform driver and adds function responsible for selecting, > switching and running appropriate Device/Host mode. > > Patch also adds gadget.c, host.c, gadget-export.h, host-export.h. > These files contains templates functions used during initialization. > The implementation will be added in next patches. > > Signed-off-by: Pawel Laszczak > --- > drivers/usb/cdns3/Kconfig | 20 ++ > drivers/usb/cdns3/Makefile | 4 + > drivers/usb/cdns3/core.c | 373 ++++++++++++++++++++++++++++++ > drivers/usb/cdns3/core.h | 88 +++++++ > drivers/usb/cdns3/gadget-export.h | 27 +++ > drivers/usb/cdns3/gadget.c | 36 +++ > drivers/usb/cdns3/host-export.h | 30 +++ > drivers/usb/cdns3/host.c | 28 +++ > 8 files changed, 606 insertions(+) > create mode 100644 drivers/usb/cdns3/core.c > create mode 100644 drivers/usb/cdns3/core.h > create mode 100644 drivers/usb/cdns3/gadget-export.h > create mode 100644 drivers/usb/cdns3/gadget.c > create mode 100644 drivers/usb/cdns3/host-export.h > create mode 100644 drivers/usb/cdns3/host.c > > diff --git a/drivers/usb/cdns3/Kconfig b/drivers/usb/cdns3/Kconfig > index 888458372adb..5f88a4932e58 100644 > --- a/drivers/usb/cdns3/Kconfig > +++ b/drivers/usb/cdns3/Kconfig > @@ -10,6 +10,26 @@ config USB_CDNS3 > > 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 support FF, HS and SS mode. It doeasn'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 compliance with XHCI so it will use > + standard XHCI driver. > + Is it better to split this patch into 3 parts? 1) host support 2) gadget support 3) DRD support (along with patch 4) > config USB_CDNS3_PCI_WRAP > tristate "PCIe-based Platforms" > depends on USB_PCI && ACPI > diff --git a/drivers/usb/cdns3/Makefile b/drivers/usb/cdns3/Makefile > index dcdd62003c6a..083676c7748f 100644 > --- a/drivers/usb/cdns3/Makefile > +++ b/drivers/usb/cdns3/Makefile > @@ -1,3 +1,7 @@ > +obj-$(CONFIG_USB_CDNS3) += cdns3.o > obj-$(CONFIG_USB_CDNS3_PCI_WRAP) += cdns3-pci.o > > +cdns3-y := core.o > +cdns3-$(CONFIG_USB_CDNS3_GADGET) += gadget.o > +cdns3-$(CONFIG_USB_CDNS3_HOST) += host.o > cdns3-pci-y := cdns3-pci-wrap.o > diff --git a/drivers/usb/cdns3/core.c b/drivers/usb/cdns3/core.c > new file mode 100644 > index 000000000000..727136235957 > --- /dev/null > +++ b/drivers/usb/cdns3/core.c > @@ -0,0 +1,373 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Cadence USBSS DRD Driver. > + * > + * Copyright (C) 2018 Cadence. > + * > + * Author: Peter Chen > + * Pawel Laszczak > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include "gadget.h" > +#include "core.h" > +#include "host-export.h" > +#include "gadget-export.h" > + > +static inline struct cdns3_role_driver *cdns3_role(struct cdns3 *cdns) how about naming this to cnds3_get_current_role_driver() ? > +{ > + WARN_ON(cdns->role >= CDNS3_ROLE_END || !cdns->roles[cdns->role]); > + return cdns->roles[cdns->role]; > +} > + > +static inline int cdns3_role_start(struct cdns3 *cdns, enum cdns3_roles role) > +{ > + int ret; > + > + if (role >= CDNS3_ROLE_END) > + return 0; > + > + if (!cdns->roles[role]) > + return -ENXIO; > + > + mutex_lock(&cdns->mutex); > + cdns->role = role; You are changing the role here. Shouldn't it just start whatever role is already in cdns->role? And you have a cnds3_set_role() function to set role. > + ret = cdns->roles[role]->start(cdns); > + mutex_unlock(&cdns->mutex); > + return ret; > +} > + > +static inline void cdns3_role_stop(struct cdns3 *cdns) > +{ > + enum cdns3_roles role = cdns->role; > + > + if (role == CDNS3_ROLE_END) > + return; > + > + mutex_lock(&cdns->mutex); > + cdns->roles[role]->stop(cdns); > + cdns->role = CDNS3_ROLE_END; > + mutex_unlock(&cdns->mutex); > +} > + > +static void cdns3_set_role(struct cdns3 *cdns, enum cdns3_roles role) > +{ > + if (role == CDNS3_ROLE_END) > + return; > + > + if (role == CDNS3_ROLE_HOST) { > + //TODO: set host role > + } else { /* gadget mode */ > + //TODO: set device role > + } > +} > + > +static enum cdns3_roles cdns3_get_role(struct cdns3 *cdns) > +{ > + if (cdns->roles[CDNS3_ROLE_HOST] && cdns->roles[CDNS3_ROLE_GADGET]) { > + //TODO: implements selecting device/host mode > + return CDNS3_ROLE_HOST; > + } > + return cdns->roles[CDNS3_ROLE_HOST] > + ? CDNS3_ROLE_HOST > + : CDNS3_ROLE_GADGET; > +} > + > +/** > + * 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 dr_mode; > + > + dr_mode = usb_get_dr_mode(dev); > + cdns->role = CDNS3_ROLE_END; > + > + 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_DEVICE)) > + dr_mode = USB_DR_MODE_PERIPHERAL; > + } > + > + if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) { > + if (cdns3_host_init(cdns)) > + dev_info(dev, "doesn't support host\n"); > + } > + > + if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_PERIPHERAL) { > + if (cdns3_gadget_init(cdns)) > + dev_info(dev, "doesn't support gadget\n"); > + } > + > + if (!cdns->roles[CDNS3_ROLE_HOST] && !cdns->roles[CDNS3_ROLE_GADGET]) { > + dev_err(dev, "no supported roles\n"); > + return -ENODEV; > + } > + > + cdns->dr_mode = dr_mode; > + return 0; > +} > + > +/** > + * cdns3_irq - interrupt handler for cdns3 core device > + * > + * @irq: irq number for cdns3 core device > + * @data: structure of cdns3 > + * > + * Returns IRQ_HANDLED or IRQ_NONE > + */ > +static irqreturn_t cdns3_irq(int irq, void *data) > +{ > + struct cdns3 *cdns = data; > + irqreturn_t ret = IRQ_NONE; > + > + if (cdns->in_lpm) { > + disable_irq_nosync(cdns->irq); > + cdns->wakeup_int = true; > + pm_runtime_get(cdns->dev); where is the balancing pm_runtime_put() for this? > + return IRQ_HANDLED; > + } > + > + /* Handle device/host interrupt */ > + if (cdns->role != CDNS3_ROLE_END) > + ret = cdns3_role(cdns)->irq(cdns); > + > + return ret; > +} > + > +static void cdns3_remove_roles(struct cdns3 *cdns) > +{ > + cdns3_gadget_remove(cdns); > + cdns3_host_remove(cdns); > +} > + > +static int cdns3_do_role_switch(struct cdns3 *cdns, enum cdns3_roles role) > +{ > + enum cdns3_roles current_role; > + int ret = 0; > + > + if (cdns->role == role) > + return 0; > + > + pm_runtime_get_sync(cdns->dev); > + current_role = cdns->role; > + cdns3_role_stop(cdns); > + > + if (role == CDNS3_ROLE_END) { > + pm_runtime_put_sync(cdns->dev); > + return 0; > + } > + > + dev_dbg(cdns->dev, "Switching role"); > + > + cdns3_set_role(cdns, role); > + ret = cdns3_role_start(cdns, role); > + if (ret) { > + /* Back to current role */ > + dev_err(cdns->dev, "set %d has failed, back to %d\n", > + role, current_role); > + cdns3_set_role(cdns, current_role); > + ret = cdns3_role_start(cdns, current_role); > + } > + > + pm_runtime_put_sync(cdns->dev); > + return ret; > +} > + > +/** > + * cdns3_role_switch - work queue handler for role switch > + * > + * @work: work queue item structure > + * > + * Handles below events: > + * - Role switch for dual-role devices > + * - CDNS3_ROLE_GADGET <--> CDNS3_ROLE_END for peripheral-only devices > + */ > +static void cdns3_role_switch(struct work_struct *work) > +{ > + struct cdns3 *cdns; > + bool device, host; > + > + cdns = container_of(work, struct cdns3, role_switch_wq); > + > + //TODO: implements this functions. > + //host = cdns3_is_host(cdns); > + //device = cdns3_is_device(cdns); > + host = 1; > + device = 0; > + > + if (host) { > + if (cdns->roles[CDNS3_ROLE_HOST]) > + cdns3_do_role_switch(cdns, CDNS3_ROLE_HOST); > + return; > + } > + > + if (device) > + cdns3_do_role_switch(cdns, CDNS3_ROLE_GADGET); > + else > + cdns3_do_role_switch(cdns, CDNS3_ROLE_END); > +} All role switching code can come as part of DRD driver. > + > +/** > + * cdns3_probe - probe for cdns3 core device > + * @pdev: Pointer to cdns3 core platform device > + * > + * Returns 0 on success otherwise negative errno > + */ > +static int cdns3_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct resource *res; > + struct cdns3 *cdns; > + void __iomem *regs; > + int ret; > + > + cdns = devm_kzalloc(dev, sizeof(*cdns), GFP_KERNEL); > + if (!cdns) > + return -ENOMEM; > + > + cdns->dev = dev; > + > + platform_set_drvdata(pdev, cdns); > + > + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); > + if (!res) { > + dev_err(dev, "missing IRQ\n"); > + return -ENODEV; > + } > + cdns->irq = res->start; > + > + /* > + * Request memory region > + * region-0: xHCI > + * region-1: Peripheral > + * region-2: OTG registers > + */ Here you are not checking for Kconfig options before getting resources which is the right thing. However this will be broken if you don't get rid of the Kconfig checks when you populate the resources in patch 1. > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + regs = devm_ioremap_resource(dev, res); > + > + if (IS_ERR(regs)) > + return PTR_ERR(regs); > + cdns->xhci_regs = regs; > + cdns->xhci_res = res; > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); > + regs = devm_ioremap_resource(dev, res); > + if (IS_ERR(regs)) > + return PTR_ERR(regs); > + cdns->dev_regs = regs; > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 2); > + regs = devm_ioremap_resource(dev, res); > + if (IS_ERR(regs)) > + return PTR_ERR(regs); > + cdns->otg_regs = regs; > + > + mutex_init(&cdns->mutex); > + > + ret = cdns3_core_init_role(cdns); > + if (ret) > + goto err2; > + > + INIT_WORK(&cdns->role_switch_wq, cdns3_role_switch); > + if (ret) > + goto err3; > + > + if (ret) > + goto err3; > + > + cdns->role = cdns3_get_role(cdns); > + cdns3_set_role(cdns, cdns->role); > + ret = cdns3_role_start(cdns, cdns->role); > + if (ret) { > + dev_err(dev, "can't start %s role\n", cdns3_role(cdns)->name); > + goto err3; > + } What exactly does role_start have to do? Can you start the role before requesting irq? > + > + ret = devm_request_irq(dev, cdns->irq, cdns3_irq, IRQF_SHARED, > + dev_name(dev), cdns); > + > + if (ret) > + goto err4; > + > + device_set_wakeup_capable(dev, true); > + pm_runtime_set_active(dev); > + pm_runtime_enable(dev); > + > + /* > + * The controller needs less time between bus and controller suspend, > + * and we also needs a small delay to avoid frequently entering low > + * power mode. > + */ > + pm_runtime_set_autosuspend_delay(dev, 20); > + pm_runtime_mark_last_busy(dev); > + pm_runtime_use_autosuspend(dev); > + dev_dbg(dev, "Cadence USB3 core: probe succeed\n"); > + > + return 0; > + > +err4: > + cdns3_role_stop(cdns); > +err3: > + cdns3_remove_roles(cdns); > +err2: > + return ret; > +} > + > +/** > + * cdns3_remove - unbind drd driver and clean up > + * @pdev: Pointer to Linux platform device > + * > + * Returns 0 on success otherwise negative errno > + */ > +static int cdns3_remove(struct platform_device *pdev) > +{ > + struct cdns3 *cdns = platform_get_drvdata(pdev); > + > + pm_runtime_get_sync(&pdev->dev); > + pm_runtime_disable(&pdev->dev); > + pm_runtime_put_noidle(&pdev->dev); > + cdns3_remove_roles(cdns); Shouldn't the order be pm_runtime_get_sync(); cdns3_remove_roles(); pm_runtime_put_noidle(); pm_runtime_disable(); > + usb_phy_shutdown(cdns->usbphy); you didn't call usb_phy_init() anywhere. > + > + return 0; > +} > + > +static struct platform_driver cdns3_driver = { > + .probe = cdns3_probe, > + .remove = cdns3_remove, > + .driver = { > + .name = "cdns-usb3", > + }, > +}; > + > +static int __init cdns3_driver_platform_register(void) > +{ > + cdns3_host_driver_init(); Why is a call to host_driver_init() required? > + return platform_driver_register(&cdns3_driver); > +} > +module_init(cdns3_driver_platform_register); > + > +static void __exit cdns3_driver_platform_unregister(void) > +{ > + platform_driver_unregister(&cdns3_driver); > +} > +module_exit(cdns3_driver_platform_unregister); > + > +MODULE_ALIAS("platform:cdns3"); > +MODULE_AUTHOR("Pawel Laszczak "); > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("Cadence USB3 DRD Controller Driver"); > diff --git a/drivers/usb/cdns3/core.h b/drivers/usb/cdns3/core.h > new file mode 100644 > index 000000000000..e7159c474308 > --- /dev/null > +++ b/drivers/usb/cdns3/core.h > @@ -0,0 +1,88 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * Cadence USBSS DRD Driver. > + * > + * Copyright (C) 2017 NXP > + * Copyright (C) 2018 Cadence. > + * > + * Authors: Peter Chen > + * Pawel Laszczak > + */ > +#include > + > +#ifndef __LINUX_CDNS3_CORE_H > +#define __LINUX_CDNS3_CORE_H > + > +struct cdns3; > +enum cdns3_roles { > + CDNS3_ROLE_HOST = 0, > + CDNS3_ROLE_GADGET, > + CDNS3_ROLE_END, > + CDNS3_ROLE_OTG, Why is OTG after END? Does OTG have a role driver as well? If not it must not come here. It is a mode, not a role. > +}; > + > +/** > + * struct cdns3_role_driver - host/gadget role driver > + * @start: start this role > + * @stop: stop this role > + * @suspend: suspend callback for this role > + * @resume: resume callback for this role > + * @irq: irq handler for this role > + * @name: role name string (host/gadget) > + */ > +struct cdns3_role_driver { > + int (*start)(struct cdns3 *cdns); > + void (*stop)(struct cdns3 *cdns); > + int (*suspend)(struct cdns3 *cdns, bool do_wakeup); > + int (*resume)(struct cdns3 *cdns, bool hibernated); > + irqreturn_t (*irq)(struct cdns3 *cdns); > + const char *name; > +}; > + > +#define CDNS3_NUM_OF_CLKS 5 > +/** > + * struct cdns3 - Representation of Cadence USB3 DRD controller. > + * @dev: pointer to Cadence device struct > + * @xhci_regs: pointer to base of xhci registers > + * @xhci_res: the resource for xhci > + * @dev_regs: pointer to base of dev registers > + * @otg_regs: pointer to base of otg registers > + * @irq: irq number for controller > + * @roles: array of supported roles for this controller > + * @role: current role > + * @host_dev: the child host device pointer for cdns3 core > + * @gadget_dev: the child gadget device pointer for cdns3 core > + * @usbphy: usbphy for this controller > + * @role_switch_wq: work queue item for role switch > + * @in_lpm: the controller in low power mode > + * @wakeup_int: the wakeup interrupt > + * @mutex: the mutex for concurrent code at driver > + * @dr_mode: requested mode of operation > + * @current_dr_role: current role of operation when in dual-role mode > + * @desired_dr_role: desired role of operation when in dual-role mode > + * @root: debugfs root folder pointer > + */ > +struct cdns3 { > + struct device *dev; > + void __iomem *xhci_regs; > + struct resource *xhci_res; > + struct cdns3_usb_regs __iomem *dev_regs; > + struct cdns3_otg_regs *otg_regs; > + int irq; > + struct cdns3_role_driver *roles[CDNS3_ROLE_END]; > + enum cdns3_roles role; > + struct device *host_dev; > + struct device *gadget_dev; > + struct usb_phy *usbphy; > + struct work_struct role_switch_wq; > + int in_lpm:1; > + int wakeup_int:1; > + /* mutext used in workqueue*/ > + struct mutex mutex; > + enum usb_dr_mode dr_mode; > + enum usb_dr_mode current_dr_mode; > + enum usb_dr_mode desired_role; > + struct dentry *root; > +}; > + > +#endif /* __LINUX_CDNS3_CORE_H */ > diff --git a/drivers/usb/cdns3/gadget-export.h b/drivers/usb/cdns3/gadget-export.h > new file mode 100644 > index 000000000000..257e5e0eef31 > --- /dev/null > +++ b/drivers/usb/cdns3/gadget-export.h > @@ -0,0 +1,27 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * Cadence USBSS DRD Driver -Gadget Export APIs > + * > + * Copyright (C) 2017 NXP > + * > + * Authors: Peter Chen > + */ > +#ifndef __LINUX_CDNS3_GADGET_EXPORT > +#define __LINUX_CDNS3_GADGET_EXPORT > + > +#ifdef CONFIG_USB_CDNS3_GADGET > + > +int cdns3_gadget_init(struct cdns3 *cdns); > +void cdns3_gadget_remove(struct cdns3 *cdns); > +#else > + > +static inline int cdns3_gadget_init(struct cdns3 *cdns) > +{ > + return -ENXIO; > +} > + > +static inline void cdns3_gadget_remove(struct cdns3 *cdns) { } > + > +#endif > + > +#endif /* __LINUX_CDNS3_GADGET_EXPORT */ > diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c > new file mode 100644 > index 000000000000..41ce696719d7 > --- /dev/null > +++ b/drivers/usb/cdns3/gadget.c > @@ -0,0 +1,36 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Cadence USBSS DRD Driver - gadget side. > + * > + * Copyright (C) 2018 Cadence Design Systems. > + * Copyright (C) 2017 NXP > + * > + * Authors: Pawel Jez , > + * Pawel Laszczak > + * Peter Chen > + */ > + > +#include "core.h" > + > +/** > + * cdns3_gadget_remove: parent must call this to remove UDC > + * > + * cdns: cdns3 instance > + */ > +void cdns3_gadget_remove(struct cdns3 *cdns) > +{ > + //TODO: implements this function > +} > + > +/** > + * cdns3_gadget_init - initialize device structure > + * > + * cdns: cdns3 instance > + * > + * This function initializes the gadget. > + */ > +int cdns3_gadget_init(struct cdns3 *cdns) > +{ > + //TODO: implements this function > + return 0; > +} > diff --git a/drivers/usb/cdns3/host-export.h b/drivers/usb/cdns3/host-export.h > new file mode 100644 > index 000000000000..f8f3b230b472 > --- /dev/null > +++ b/drivers/usb/cdns3/host-export.h > @@ -0,0 +1,30 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * Cadence USBSS DRD Driver -Host Export APIs > + * > + * Copyright (C) 2017 NXP > + * > + * Authors: Peter Chen > + */ > +#ifndef __LINUX_CDNS3_HOST_EXPORT > +#define __LINUX_CDNS3_HOST_EXPORT > + > +#ifdef CONFIG_USB_CDNS3_HOST > + > +int cdns3_host_init(struct cdns3 *cdns); > +void cdns3_host_remove(struct cdns3 *cdns); > +void cdns3_host_driver_init(void); why is cdns3_host_driver_init() required? > + > +#else > + > +static inline int cdns3_host_init(struct cdns3 *cdns) > +{ > + return -ENXIO; > +} > + > +static inline void cdns3_host_remove(struct cdns3 *cdns) { } > +static inline void cdns3_host_driver_init(void) {} > + > +#endif /* CONFIG_USB_CDNS3_HOST */ > + > +#endif /* __LINUX_CDNS3_HOST_EXPORT */ > diff --git a/drivers/usb/cdns3/host.c b/drivers/usb/cdns3/host.c > new file mode 100644 > index 000000000000..37300985e2d6 > --- /dev/null > +++ b/drivers/usb/cdns3/host.c > @@ -0,0 +1,28 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Cadence USBSS DRD Driver - host side > + * > + * Copyright (C) 2018 Cadence Design Systems. > + * Copyright (C) 2018 NXP > + * > + * Authors: Peter Chen > + * Pawel Laszczak > + */ > + > +#include "core.h" > + > +int cdns3_host_init(struct cdns3 *cdns) > +{ > + //TODO: implements this function > + return 0; > +} > + > +void cdns3_host_remove(struct cdns3 *cdns) > +{ > + //TODO: implements this function > +} > + > +void __init cdns3_host_driver_init(void) > +{ > + //TODO: implements this function > +} > cheers, -roger -- Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki. Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki