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,v2,06/15] usb:cdns3: Adds Host support From: Roger Quadros Message-Id: <5BF80D44.2050600@ti.com> Date: Fri, 23 Nov 2018 16:23:00 +0200 To: Pawel Laszczak , devicetree@vger.kernel.org Cc: gregkh@linuxfoundation.org, linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, adouglas@cadence.com, jbergsagel@ti.com, nsekhar@ti.com, nm@ti.com, sureshp@cadence.com, peter.chen@nxp.com, pjez@cadence.com, kurahul@cadence.com List-ID: T24gMTgvMTEvMTggMTI6MDksIFBhd2VsIExhc3pjemFrIHdyb3RlOgo+IFBhdGNoIGFkZHMgaG9z dC1leHBvcnQuaCBhbmQgaG9zdC5jIGZpbGUgYW5kIG1wbGVtZW50cyBmdW5jdGlvbnMgdGhhdAo+ IGFsbG93IHRvIGluaXRpYWxpemUsIHN0YXJ0IGFuZCBzdG9wIFhIQ0kgaG9zdCBkcml2ZXIuCj4g Cj4gU2lnbmVkLW9mZi1ieTogUGF3ZWwgTGFzemN6YWsgPHBhd2VsbEBjYWRlbmNlLmNvbT4KPiAt LS0KPiAgZHJpdmVycy91c2IvY2RuczMvS2NvbmZpZyAgICAgICB8ICAxMCArKwo+ICBkcml2ZXJz L3VzYi9jZG5zMy9NYWtlZmlsZSAgICAgIHwgICAxICsKPiAgZHJpdmVycy91c2IvY2RuczMvY29y ZS5jICAgICAgICB8ICAgNyArLQo+ICBkcml2ZXJzL3VzYi9jZG5zMy9ob3N0LWV4cG9ydC5oIHwg IDMwICsrKysKPiAgZHJpdmVycy91c2IvY2RuczMvaG9zdC5jICAgICAgICB8IDI1NiArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwo+ICA1IGZpbGVzIGNoYW5nZWQsIDMwMiBpbnNlcnRp b25zKCspLCAyIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2Iv Y2RuczMvaG9zdC1leHBvcnQuaAo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy91c2IvY2Ru czMvaG9zdC5jCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NkbnMzL0tjb25maWcgYi9k cml2ZXJzL3VzYi9jZG5zMy9LY29uZmlnCj4gaW5kZXggZWIyMmE4NjkyOTkxLi5kOTJiYzNkNjhl YjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy91c2IvY2RuczMvS2NvbmZpZwo+ICsrKyBiL2RyaXZl cnMvdXNiL2NkbnMzL0tjb25maWcKPiBAQCAtMTAsNiArMTAsMTYgQEAgY29uZmlnIFVTQl9DRE5T Mwo+ICAKPiAgaWYgVVNCX0NETlMzCj4gIAo+ICtjb25maWcgVVNCX0NETlMzX0hPU1QKPiArICAg ICAgICBib29sICJDYWRlbmNlIFVTQjMgaG9zdCBjb250cm9sbGVyIgo+ICsgICAgICAgIGRlcGVu ZHMgb24gVVNCX1hIQ0lfSENECj4gKyAgICAgICAgaGVscAo+ICsgICAgICAgICAgU2F5IFkgaGVy ZSB0byBlbmFibGUgaG9zdCBjb250cm9sbGVyIGZ1bmN0aW9uYWxpdHkgb2YgdGhlCj4gKyAgICAg ICAgICBjYWRlbmNlIGRyaXZlci4KPiArCj4gKyAgICAgICAgICBIb3N0IGNvbnRyb2xsZXIgaXMg Y29tcGxpYW5jZSB3aXRoIFhIQ0kgc28gaXQgd2lsbCB1c2UKPiArICAgICAgICAgIHN0YW5kYXJk IFhIQ0kgZHJpdmVyLgo+ICsKPiAgY29uZmlnIFVTQl9DRE5TM19QQ0lfV1JBUAo+ICAJdHJpc3Rh dGUgIlBDSWUtYmFzZWQgUGxhdGZvcm1zIgo+ICAJZGVwZW5kcyBvbiBVU0JfUENJICYmIEFDUEkK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMvTWFrZWZpbGUgYi9kcml2ZXJzL3VzYi9j ZG5zMy9NYWtlZmlsZQo+IGluZGV4IGU3NzliMmEyZjhlYi4uOTc2MTE3YmE2N2ZmIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvdXNiL2NkbnMzL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy91c2IvY2Ru czMvTWFrZWZpbGUKPiBAQCAtMiw0ICsyLDUgQEAgb2JqLSQoQ09ORklHX1VTQl9DRE5TMykJCQkr PSBjZG5zMy5vCj4gIG9iai0kKENPTkZJR19VU0JfQ0ROUzNfUENJX1dSQVApCSs9IGNkbnMzLXBj aS5vCj4gIAo+ICBjZG5zMy15CQkJCQk6PSBjb3JlLm8gZHJkLm8KPiArY2RuczMtJChDT05GSUdf VVNCX0NETlMzX0hPU1QpICAgICAgICAgICs9IGhvc3Qubwo+ICBjZG5zMy1wY2kteQkJIAkJOj0g Y2RuczMtcGNpLXdyYXAubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmMg Yi9kcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmMKPiBpbmRleCBkYmVlNDMyNWRhN2YuLjRjYjgyMGJl OWZmMyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmMKPiArKysgYi9kcml2 ZXJzL3VzYi9jZG5zMy9jb3JlLmMKPiBAQCAtMTcsNiArMTcsNyBAQAo+ICAKPiAgI2luY2x1ZGUg ImdhZGdldC5oIgo+ICAjaW5jbHVkZSAiY29yZS5oIgo+ICsjaW5jbHVkZSAiaG9zdC1leHBvcnQu aCIKPiAgI2luY2x1ZGUgImRyZC5oIgo+ICAKPiAgc3RhdGljIGlubGluZSBzdHJ1Y3QgY2RuczNf cm9sZV9kcml2ZXIgKmNkbnMzX2dldF9jdXJyZW50X3JvbGVfZHJpdmVyKHN0cnVjdCBjZG5zMyAq Y2RucykKPiBAQCAtOTgsNyArOTksOCBAQCBzdGF0aWMgaW50IGNkbnMzX2NvcmVfaW5pdF9yb2xl KHN0cnVjdCBjZG5zMyAqY2RucykKPiAgCX0KPiAgCj4gIAlpZiAoZHJfbW9kZSA9PSBVU0JfRFJf TU9ERV9PVEcgfHwgZHJfbW9kZSA9PSBVU0JfRFJfTU9ERV9IT1NUKSB7Cj4gLQkJLy9UT0RPOiBp bXBsZW1lbnRzIGhvc3QgaW5pdGlhbGl6YXRpb24KPiArCQlpZiAoY2RuczNfaG9zdF9pbml0KGNk bnMpKQo+ICsJCQlkZXZfaW5mbyhkZXYsICJkb2Vzbid0IHN1cHBvcnQgaG9zdFxuIik7CgpkZXZf ZXJyKCkKCkFuZCB5b3UgbmVlZCB0byBlcnJvciBvdXQgd2l0aCBlcnJvciBjb2RlLgoKPiAgCX0K PiAgCj4gIAlpZiAoZHJfbW9kZSA9PSBVU0JfRFJfTU9ERV9PVEcgfHwgZHJfbW9kZSA9PSBVU0Jf RFJfTU9ERV9QRVJJUEhFUkFMKSB7Cj4gQEAgLTE0Miw3ICsxNDQsNyBAQCBzdGF0aWMgaXJxcmV0 dXJuX3QgY2RuczNfaXJxKGludCBpcnEsIHZvaWQgKmRhdGEpCj4gIAo+ICBzdGF0aWMgdm9pZCBj ZG5zM19yZW1vdmVfcm9sZXMoc3RydWN0IGNkbnMzICpjZG5zKQo+ICB7Cj4gLQkvL1RPRE86IGlt cGxlbWVudHMgdGhpcyBmdW5jdGlvbgoKaWYgKGRyX21vZGUgPT0gVVNCX0RSX01PREVfT1RHIHx8 IGRyX21vZGUgPT0gVVNCX0RSX01PREVfSE9TVCkKCj4gKwljZG5zM19ob3N0X3JlbW92ZShjZG5z KTsKCkhvdyBhYm91dCBjYWxsaW5nIGl0IGNkbnMzX2hvc3RfZXhpdCgpIHRvIGNvbXBsZW1lbnQg Y2RuczNfaG9zdF9pbml0KCkuCgo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50IGNkbnMzX2RvX3JvbGVf c3dpdGNoKHN0cnVjdCBjZG5zMyAqY2RucywgZW51bSBjZG5zM19yb2xlcyByb2xlKQo+IEBAIC00 MTAsNiArNDEyLDcgQEAgc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgY2RuczNfZHJpdmVy ID0gewo+ICAKPiAgc3RhdGljIGludCBfX2luaXQgY2RuczNfZHJpdmVyX3BsYXRmb3JtX3JlZ2lz dGVyKHZvaWQpCj4gIHsKPiArCWNkbnMzX2hvc3RfZHJpdmVyX2luaXQoKTsKPiAgCXJldHVybiBw bGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmNkbnMzX2RyaXZlcik7Cj4gIH0KPiAgbW9kdWxlX2lu aXQoY2RuczNfZHJpdmVyX3BsYXRmb3JtX3JlZ2lzdGVyKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy91c2IvY2RuczMvaG9zdC1leHBvcnQuaCBiL2RyaXZlcnMvdXNiL2NkbnMzL2hvc3QtZXhwb3J0 LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uZjhmM2IyMzBi NDcyCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvdXNiL2NkbnMzL2hvc3QtZXhwb3J0 LmgKPiBAQCAtMCwwICsxLDMwIEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwt Mi4wICovCj4gKy8qCj4gKyAqIENhZGVuY2UgVVNCU1MgRFJEIERyaXZlciAtSG9zdCBFeHBvcnQg QVBJcwo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTcgTlhQCj4gKyAqCj4gKyAqIEF1dGhv cnM6IFBldGVyIENoZW4gPHBldGVyLmNoZW5AbnhwLmNvbT4KPiArICovCj4gKyNpZm5kZWYgX19M SU5VWF9DRE5TM19IT1NUX0VYUE9SVAo+ICsjZGVmaW5lIF9fTElOVVhfQ0ROUzNfSE9TVF9FWFBP UlQKPiArCj4gKyNpZmRlZiBDT05GSUdfVVNCX0NETlMzX0hPU1QKPiArCj4gK2ludCBjZG5zM19o b3N0X2luaXQoc3RydWN0IGNkbnMzICpjZG5zKTsKPiArdm9pZCBjZG5zM19ob3N0X3JlbW92ZShz dHJ1Y3QgY2RuczMgKmNkbnMpOwo+ICt2b2lkIGNkbnMzX2hvc3RfZHJpdmVyX2luaXQodm9pZCk7 Cj4gKwo+ICsjZWxzZQo+ICsKPiArc3RhdGljIGlubGluZSBpbnQgY2RuczNfaG9zdF9pbml0KHN0 cnVjdCBjZG5zMyAqY2RucykKPiArewo+ICsJcmV0dXJuIC1FTlhJTzsKPiArfQo+ICsKPiArc3Rh dGljIGlubGluZSB2b2lkIGNkbnMzX2hvc3RfcmVtb3ZlKHN0cnVjdCBjZG5zMyAqY2RucykgeyB9 Cj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBjZG5zM19ob3N0X2RyaXZlcl9pbml0KHZvaWQpIHt9Cj4g Kwo+ICsjZW5kaWYgLyogQ09ORklHX1VTQl9DRE5TM19IT1NUICovCj4gKwo+ICsjZW5kaWYgLyog X19MSU5VWF9DRE5TM19IT1NUX0VYUE9SVCAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9j ZG5zMy9ob3N0LmMgYi9kcml2ZXJzL3VzYi9jZG5zMy9ob3N0LmMKPiBuZXcgZmlsZSBtb2RlIDEw MDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uMGRkNDc5NzZjYjI4Cj4gLS0tIC9kZXYvbnVsbAo+ ICsrKyBiL2RyaXZlcnMvdXNiL2NkbnMzL2hvc3QuYwo+IEBAIC0wLDAgKzEsMjU2IEBACj4gKy8v IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAqIENhZGVuY2UgVVNC U1MgRFJEIERyaXZlciAtIGhvc3Qgc2lkZQo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTgg Q2FkZW5jZSBEZXNpZ24gU3lzdGVtcy4KPiArICogQ29weXJpZ2h0IChDKSAyMDE4IE5YUAo+ICsg Kgo+ICsgKiBBdXRob3JzOiBQZXRlciBDaGVuIDxwZXRlci5jaGVuQG54cC5jb20+Cj4gKyAqCSAg ICBQYXdlbCBMYXN6Y3phayA8cGF3ZWxsQGNhZGVuY2UuY29tPgo+ICsgKi8KPiArCj4gKyNpbmNs dWRlIDxsaW51eC9rZXJuZWwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgo+ICsjaW5j bHVkZSA8bGludXgvaW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiArI2luY2x1ZGUg PGxpbnV4L2RtYS1tYXBwaW5nLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC91c2IuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L3VzYi9oY2QuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L3VzYi9vZi5oPgo+ICsKPiArI2luY2x1ZGUgIi4uL2hvc3QveGhjaS5o Igo+ICsjaW5jbHVkZSAiY29yZS5oIgo+ICsjaW5jbHVkZSAiaG9zdC1leHBvcnQuaCIKPiArCj4g K3N0YXRpYyBzdHJ1Y3QgaGNfZHJpdmVyIF9fcmVhZF9tb3N0bHkgeGhjaV9jZG5zM19oY19kcml2 ZXI7Cj4gKwo+ICtzdGF0aWMgdm9pZCB4aGNpX2NkbnMzX3F1aXJrcyhzdHJ1Y3QgZGV2aWNlICpk ZXYsIHN0cnVjdCB4aGNpX2hjZCAqeGhjaSkKPiArewo+ICsJLyoKPiArCSAqIEFzIG9mIG5vdyBw bGF0Zm9ybSBkcml2ZXJzIGRvbid0IHByb3ZpZGUgTVNJIHN1cHBvcnQgc28gd2UgZW5zdXJlCj4g KwkgKiBoZXJlIHRoYXQgdGhlIGdlbmVyaWMgY29kZSBkb2VzIG5vdCB0cnkgdG8gbWFrZSBhIHBj aV9kZXYgZnJvbSBvdXIKPiArCSAqIGRldiBzdHJ1Y3QgaW4gb3JkZXIgdG8gc2V0dXAgTVNJCj4g KwkgKi8KPiArCXhoY2ktPnF1aXJrcyB8PSBYSENJX1BMQVQ7Cj4gK30KPiArCj4gK3N0YXRpYyBp bnQgeGhjaV9jZG5zM19zZXR1cChzdHJ1Y3QgdXNiX2hjZCAqaGNkKQo+ICt7Cj4gKwlzdHJ1Y3Qg eGhjaV9oY2QJKnhoY2kgPSBoY2RfdG9feGhjaShoY2QpOwo+ICsJdTMyIGNvbW1hbmQ7Cj4gKwlp bnQgcmV0Owo+ICsKPiArCXJldCA9IHhoY2lfZ2VuX3NldHVwKGhjZCwgeGhjaV9jZG5zM19xdWly a3MpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCS8qIHNldCB1c2JjbWQu RVUzUyAqLwo+ICsJY29tbWFuZCA9IHJlYWRsKCZ4aGNpLT5vcF9yZWdzLT5jb21tYW5kKTsKPiAr CWNvbW1hbmQgfD0gQ01EX1BNX0lOREVYOwo+ICsJd3JpdGVsKGNvbW1hbmQsICZ4aGNpLT5vcF9y ZWdzLT5jb21tYW5kKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0 IHN0cnVjdCB4aGNpX2RyaXZlcl9vdmVycmlkZXMgeGhjaV9jZG5zM19vdmVycmlkZXMgX19pbml0 Y29uc3QgPSB7Cj4gKwkuZXh0cmFfcHJpdl9zaXplID0gc2l6ZW9mKHN0cnVjdCB4aGNpX2hjZCks Cj4gKwkucmVzZXQgPSB4aGNpX2NkbnMzX3NldHVwLAo+ICt9Owo+ICsKPiArc3RydWN0IGNkbnMz X2hvc3Qgewo+ICsJc3RydWN0IGRldmljZSBkZXY7Cj4gKwlzdHJ1Y3QgdXNiX2hjZCAqaGNkOwo+ ICt9Owo+ICsKPiArc3RhdGljIGlycXJldHVybl90IGNkbnMzX2hvc3RfaXJxKHN0cnVjdCBjZG5z MyAqY2RucykKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gY2Rucy0+aG9zdF9kZXY7Cj4g KwlzdHJ1Y3QgdXNiX2hjZAkqaGNkOwo+ICsKPiArCWlmIChkZXYpCj4gKwkJaGNkID0gZGV2X2dl dF9kcnZkYXRhKGRldik7Cj4gKwllbHNlCj4gKwkJcmV0dXJuIElSUV9OT05FOwo+ICsKPiArCWlm IChoY2QpCj4gKwkJcmV0dXJuIHVzYl9oY2RfaXJxKGNkbnMtPmlycSwgaGNkKTsKPiArCWVsc2UK PiArCQlyZXR1cm4gSVJRX05PTkU7CgpXaHkgY2FuJ3QgeW91IGp1c3QgcmV1c2UgdGhlIHhoY2kt cGxhdGZvcm0gZHJpdmVyIGFuZCBsZXQgaXQgbWFuYWdlIHRoZSBJUlE/ClNpbmNlIGl0IGlzIGEg c2hhcmVkIElSUSwgZGlmZmVyZW50IGRyaXZlcnMgY2FuIHJlcXVlc3QgdGhlIHNhbWUgSVJRIGFu ZCByZXR1cm4gSVJRX05PTkUKaWYgdGhlIElSUSB3YXNuJ3QgZnJvbSB0aGVpciBkZXZpY2UuCgo+ ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBjZG5zM19ob3N0X3JlbGVhc2Uoc3RydWN0IGRldmljZSAq ZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuczNfaG9zdCAqaG9zdCA9IGNvbnRhaW5lcl9vZihkZXYs IHN0cnVjdCBjZG5zM19ob3N0LCBkZXYpOwo+ICsKPiArCWtmcmVlKGhvc3QpOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IGNkbnMzX2hvc3Rfc3RhcnQoc3RydWN0IGNkbnMzICpjZG5zKQo+ICt7Cj4g KwlzdHJ1Y3QgY2RuczNfaG9zdCAqaG9zdDsKPiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPiArCXN0 cnVjdCBkZXZpY2UgKnN5c2RldjsKPiArCXN0cnVjdCB4aGNpX2hjZAkqeGhjaTsKPiArCWludCBy ZXQ7Cj4gKwo+ICsJaG9zdCA9IGt6YWxsb2Moc2l6ZW9mKCpob3N0KSwgR0ZQX0tFUk5FTCk7Cj4g KwlpZiAoIWhvc3QpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJZGV2ID0gJmhvc3QtPmRl djsKPiArCWRldi0+cmVsZWFzZSA9IGNkbnMzX2hvc3RfcmVsZWFzZTsKPiArCWRldi0+cGFyZW50 ID0gY2Rucy0+ZGV2Owo+ICsJZGV2X3NldF9uYW1lKGRldiwgInhoY2ktY2RuczMiKTsKPiArCWNk bnMtPmhvc3RfZGV2ID0gZGV2Owo+ICsJcmV0ID0gZGV2aWNlX3JlZ2lzdGVyKGRldik7Cj4gKwlp ZiAocmV0KQo+ICsJCWdvdG8gZXJyMTsKPiArCj4gKwlzeXNkZXYgPSBjZG5zLT5kZXY7Cj4gKwkv KiBUcnkgdG8gc2V0IDY0LWJpdCBETUEgZmlyc3QgKi8KPiArCWlmIChXQVJOX09OKCFzeXNkZXYt PmRtYV9tYXNrKSkKPiArCQkvKiBQbGF0Zm9ybSBkaWQgbm90IGluaXRpYWxpemUgZG1hX21hc2sg Ki8KPiArCQlyZXQgPSBkbWFfY29lcmNlX21hc2tfYW5kX2NvaGVyZW50KHN5c2RldiwKPiArCQkJ CQkJICAgRE1BX0JJVF9NQVNLKDY0KSk7Cj4gKwllbHNlCj4gKwkJcmV0ID0gZG1hX3NldF9tYXNr X2FuZF9jb2hlcmVudChzeXNkZXYsIERNQV9CSVRfTUFTSyg2NCkpOwo+ICsKPiArCS8qIElmIHNl dHRpbmcgNjQtYml0IERNQSBtYXNrIGZhaWxzLCBmYWxsIGJhY2sgdG8gMzItYml0IERNQSBtYXNr ICovCj4gKwlpZiAocmV0KSB7Cj4gKwkJcmV0ID0gZG1hX3NldF9tYXNrX2FuZF9jb2hlcmVudChz eXNkZXYsIERNQV9CSVRfTUFTSygzMikpOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7 Cj4gKwl9Cj4gKwo+ICsJcG1fcnVudGltZV9zZXRfYWN0aXZlKGRldik7Cj4gKwlwbV9ydW50aW1l X25vX2NhbGxiYWNrcyhkZXYpOwo+ICsJcG1fcnVudGltZV9lbmFibGUoZGV2KTsKPiArCWhvc3Qt PmhjZCA9IF9fdXNiX2NyZWF0ZV9oY2QoJnhoY2lfY2RuczNfaGNfZHJpdmVyLCBzeXNkZXYsIGRl diwKPiArCQkJCSAgICAgZGV2X25hbWUoZGV2KSwgTlVMTCk7Cj4gKwlpZiAoIWhvc3QtPmhjZCkg ewo+ICsJCXJldCA9IC1FTk9NRU07Cj4gKwkJZ290byBlcnIyOwo+ICsJfQo+ICsKPiArCWhvc3Qt PmhjZC0+cmVncyA9IGNkbnMtPnhoY2lfcmVnczsKPiArCWhvc3QtPmhjZC0+cnNyY19zdGFydCA9 IGNkbnMtPnhoY2lfcmVzLT5zdGFydDsKPiArCWhvc3QtPmhjZC0+cnNyY19sZW4gPSByZXNvdXJj ZV9zaXplKGNkbnMtPnhoY2lfcmVzKTsKPiArCj4gKwlkZXZpY2Vfd2FrZXVwX2VuYWJsZShob3N0 LT5oY2QtPnNlbGYuY29udHJvbGxlcik7Cj4gKwl4aGNpID0gaGNkX3RvX3hoY2koaG9zdC0+aGNk KTsKPiArCj4gKwl4aGNpLT5tYWluX2hjZCA9IGhvc3QtPmhjZDsKPiArCXhoY2ktPnNoYXJlZF9o Y2QgPSBfX3VzYl9jcmVhdGVfaGNkKCZ4aGNpX2NkbnMzX2hjX2RyaXZlciwgc3lzZGV2LCBkZXYs Cj4gKwkJCQkJICAgIGRldl9uYW1lKGRldiksIGhvc3QtPmhjZCk7Cj4gKwlpZiAoIXhoY2ktPnNo YXJlZF9oY2QpIHsKPiArCQlyZXQgPSAtRU5PTUVNOwo+ICsJCWdvdG8gZXJyMzsKPiArCX0KPiAr Cj4gKwlob3N0LT5oY2QtPnRwbF9zdXBwb3J0ID0gb2ZfdXNiX2hvc3RfdHBsX3N1cHBvcnQoc3lz ZGV2LT5vZl9ub2RlKTsKPiArCXhoY2ktPnNoYXJlZF9oY2QtPnRwbF9zdXBwb3J0ID0gaG9zdC0+ aGNkLT50cGxfc3VwcG9ydDsKPiArCXJldCA9IHVzYl9hZGRfaGNkKGhvc3QtPmhjZCwgMCwgSVJR Rl9TSEFSRUQpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycjQ7Cj4gKwo+ICsJcmV0ID0gdXNi X2FkZF9oY2QoeGhjaS0+c2hhcmVkX2hjZCwgMCwgSVJRRl9TSEFSRUQpOwo+ICsJaWYgKHJldCkK PiArCQlnb3RvIGVycjU7Cj4gKwo+ICsJZGV2aWNlX3NldF93YWtldXBfY2FwYWJsZShkZXYsIHRy dWUpOwoKQWxsIHRoaXMgaXMgYmVpbmcgZG9uZSBieSB0aGUgeGhjaS1wbGF0LmMKCllvdSBjYW4g bWFrZSB1c2Ugb2YgaXQgYnkganVzdCBjcmVhdGluZyBhIHhoY2ktaGNkIHBsYXRmb3JtIGRldmlj ZS4KCmUuZy4KcGxhdGZvcm1fZGV2aWNlX2FsbG9jKCJ4aGNpLWhjZCIsIFBMQVRGT1JNX0RFVklE X0FVVE8pOwpwbGF0Zm9ybV9kZXZpY2VfYWRkX3Jlc291cmNlcygpIHRvIGFkZCBJUlEgYW5kIG1l bW9yeSByZXNvdXJjZS4KcGxhdGZvcm1fZGV2aWNlX2FkZF9wcm9wZXJ0aWVzKCkgdG8gYWRkIGFu eSBxdWlya3MuCnBsYXRmb3JtX2RldmljZV9hZGQoKQoKCj4gKwo+ICsJcmV0dXJuIDA7Cj4gKwo+ ICtlcnI1Ogo+ICsJdXNiX3JlbW92ZV9oY2QoaG9zdC0+aGNkKTsKPiArZXJyNDoKPiArCXVzYl9w dXRfaGNkKHhoY2ktPnNoYXJlZF9oY2QpOwo+ICtlcnIzOgo+ICsJdXNiX3B1dF9oY2QoaG9zdC0+ aGNkKTsKPiArZXJyMjoKPiArCWRldmljZV9kZWwoZGV2KTsKPiArZXJyMToKPiArCXB1dF9kZXZp Y2UoZGV2KTsKPiArCWNkbnMtPmhvc3RfZGV2ID0gTlVMTDsKPiArCXJldHVybiByZXQ7Cj4gK30K PiArCj4gK3N0YXRpYyB2b2lkIGNkbnMzX2hvc3Rfc3RvcChzdHJ1Y3QgY2RuczMgKmNkbnMpCj4g K3sKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNkbnMtPmhvc3RfZGV2Owo+ICsJc3RydWN0IHho Y2lfaGNkCSp4aGNpOwo+ICsJc3RydWN0IHVzYl9oY2QJKmhjZDsKPiArCj4gKwlpZiAoZGV2KSB7 Cj4gKwkJaGNkID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwkJeGhjaSA9IGhjZF90b194aGNp KGhjZCk7Cj4gKwkJdXNiX3JlbW92ZV9oY2QoeGhjaS0+c2hhcmVkX2hjZCk7Cj4gKwkJdXNiX3Jl bW92ZV9oY2QoaGNkKTsKPiArCQlzeW5jaHJvbml6ZV9pcnEoY2Rucy0+aXJxKTsKPiArCQl1c2Jf cHV0X2hjZCh4aGNpLT5zaGFyZWRfaGNkKTsKPiArCQl1c2JfcHV0X2hjZChoY2QpOwo+ICsJCWNk bnMtPmhvc3RfZGV2ID0gTlVMTDsKPiArCQlwbV9ydW50aW1lX3NldF9zdXNwZW5kZWQoZGV2KTsK PiArCQlwbV9ydW50aW1lX2Rpc2FibGUoZGV2KTsKPiArCQlkZXZpY2VfZGVsKGRldik7Cj4gKwkJ cHV0X2RldmljZShkZXYpOwo+ICsJfQoKWW91IGNhbiByZXBsYWNlIHRoaXMgd2l0aCBqdXN0Cglw bGF0Zm9ybV9kZXZpY2VfdW5yZWdpc3Rlcih4aGNpX2Rldik7Cgo+ICt9Cj4gKwo+ICsjaWYgQ09O RklHX1BNCj4gK3N0YXRpYyBpbnQgY2RuczNfaG9zdF9zdXNwZW5kKHN0cnVjdCBjZG5zMyAqY2Ru cywgYm9vbCBkb193YWtldXApCj4gK3sKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNkbnMtPmhv c3RfZGV2Owo+ICsJc3RydWN0IHhoY2lfaGNkCSp4aGNpOwo+ICsKPiArCWlmICghZGV2KQo+ICsJ CXJldHVybiAwOwo+ICsKPiArCXhoY2kgPSBoY2RfdG9feGhjaShkZXZfZ2V0X2RydmRhdGEoZGV2 KSk7Cj4gKwlyZXR1cm4geGhjaV9zdXNwZW5kKHhoY2ksIGRvX3dha2V1cCk7Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgY2RuczNfaG9zdF9yZXN1bWUoc3RydWN0IGNkbnMzICpjZG5zLCBib29sIGhp YmVybmF0ZWQpCj4gK3sKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNkbnMtPmhvc3RfZGV2Owo+ ICsJc3RydWN0IHhoY2lfaGNkCSp4aGNpOwo+ICsKPiArCWlmICghZGV2KQo+ICsJCXJldHVybiAw Owo+ICsKPiArCXhoY2kgPSBoY2RfdG9feGhjaShkZXZfZ2V0X2RydmRhdGEoZGV2KSk7Cj4gKwly ZXR1cm4geGhjaV9yZXN1bWUoeGhjaSwgaGliZXJuYXRlZCk7Cj4gK30KClRoZXNlIHdvbid0IGJl IHJlcXVpcmVkIGFueSBtb3JlIGFzIHhoY2ktcGxhdCBpcyBkb2luZyB0aGlzLgoKPiArI2VuZGlm IC8qIENPTkZJR19QTSAqLwo+ICsKPiAraW50IGNkbnMzX2hvc3RfaW5pdChzdHJ1Y3QgY2RuczMg KmNkbnMpCj4gK3sKPiArCXN0cnVjdCBjZG5zM19yb2xlX2RyaXZlciAqcmRydjsKPiArCj4gKwly ZHJ2ID0gZGV2bV9remFsbG9jKGNkbnMtPmRldiwgc2l6ZW9mKCpyZHJ2KSwgR0ZQX0tFUk5FTCk7 Cj4gKwlpZiAoIXJkcnYpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJcmRydi0+c3RhcnQJ PSBjZG5zM19ob3N0X3N0YXJ0Owo+ICsJcmRydi0+c3RvcAk9IGNkbnMzX2hvc3Rfc3RvcDsKPiAr CXJkcnYtPmlycQk9IGNkbnMzX2hvc3RfaXJxOwo+ICsjaWYgQ09ORklHX1BNCj4gKwlyZHJ2LT5z dXNwZW5kCT0gY2RuczNfaG9zdF9zdXNwZW5kOwo+ICsJcmRydi0+cmVzdW1lCT0gY2RuczNfaG9z dF9yZXN1bWU7Cj4gKyNlbmRpZiAvKiBDT05GSUdfUE0gKi8KPiArCXJkcnYtPm5hbWUJPSAiaG9z dCI7Cj4gKwljZG5zLT5yb2xlc1tDRE5TM19ST0xFX0hPU1RdID0gcmRydjsKPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiArdm9pZCBjZG5zM19ob3N0X3JlbW92ZShzdHJ1Y3QgY2RuczMgKmNk bnMpCj4gK3sKPiArCWNkbnMzX2hvc3Rfc3RvcChjZG5zKTsKCmNhbGxpbmcgY2RuczNfaG9zdF9z dG9wKCkgaGVyZSBjYW4gbGVhZCB0byBwcm9ibGVtcyBhcyBDb250cm9sbGVyIG1pZ2h0IGJlIGlu CnBlcmlwaGVyYWwgbW9kZSBhdCB0aGlzIHBvaW50LiBUaGUgY29yZSBkcml2ZXIgbmVlZHMgdG8g ZW5zdXJlIHRoYXQgcmVsZXZhbnQgcm9sZQppcyBzdG9wcGVkIGJlZm9yZSBjYWxsaW5nIGNkbnMz X2hvc3RfcmVtb3ZlKCkuCgpIZXJlIHlvdSBuZWVkIHRvIHVucmVnaXN0ZXIgdGhlIHJvbGUgZHJp dmVyIHRob3VnaC4KCmNkbnMtPnJvbGVzW0NETlMzX1JPTEVfSE9TVF0gPSBOVUxMOwoKPiArfQo+ ICsKPiArdm9pZCBfX2luaXQgY2RuczNfaG9zdF9kcml2ZXJfaW5pdCh2b2lkKQo+ICt7Cj4gKwl4 aGNpX2luaXRfZHJpdmVyKCZ4aGNpX2NkbnMzX2hjX2RyaXZlciwgJnhoY2lfY2RuczNfb3ZlcnJp ZGVzKTsKPiArfQo+IAoKY2hlZXJzLAotcm9nZXIK From mboxrd@z Thu Jan 1 00:00:00 1970 From: Roger Quadros Subject: Re: [RFC PATCH v2 06/15] usb:cdns3: Adds Host support Date: Fri, 23 Nov 2018 16:23:00 +0200 Message-ID: <5BF80D44.2050600@ti.com> References: <1542535751-16079-1-git-send-email-pawell@cadence.com> <1542535751-16079-7-git-send-email-pawell@cadence.com> Mime-Version: 1.0 Content-Type: text/plain; charset="windows-1252" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: <1542535751-16079-7-git-send-email-pawell@cadence.com> Sender: linux-kernel-owner@vger.kernel.org To: Pawel Laszczak , devicetree@vger.kernel.org Cc: gregkh@linuxfoundation.org, linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, adouglas@cadence.com, jbergsagel@ti.com, nsekhar@ti.com, nm@ti.com, sureshp@cadence.com, peter.chen@nxp.com, pjez@cadence.com, kurahul@cadence.com List-Id: devicetree@vger.kernel.org On 18/11/18 12:09, Pawel Laszczak wrote: > Patch adds host-export.h and host.c file and mplements functions that > allow to initialize, start and stop XHCI host driver. > > Signed-off-by: Pawel Laszczak > --- > drivers/usb/cdns3/Kconfig | 10 ++ > drivers/usb/cdns3/Makefile | 1 + > drivers/usb/cdns3/core.c | 7 +- > drivers/usb/cdns3/host-export.h | 30 ++++ > drivers/usb/cdns3/host.c | 256 ++++++++++++++++++++++++++++++++ > 5 files changed, 302 insertions(+), 2 deletions(-) > 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 eb22a8692991..d92bc3d68eb0 100644 > --- a/drivers/usb/cdns3/Kconfig > +++ b/drivers/usb/cdns3/Kconfig > @@ -10,6 +10,16 @@ config USB_CDNS3 > > if USB_CDNS3 > > +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. > + > 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 e779b2a2f8eb..976117ba67ff 100644 > --- a/drivers/usb/cdns3/Makefile > +++ b/drivers/usb/cdns3/Makefile > @@ -2,4 +2,5 @@ obj-$(CONFIG_USB_CDNS3) += cdns3.o > obj-$(CONFIG_USB_CDNS3_PCI_WRAP) += cdns3-pci.o > > cdns3-y := core.o drd.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 > index dbee4325da7f..4cb820be9ff3 100644 > --- a/drivers/usb/cdns3/core.c > +++ b/drivers/usb/cdns3/core.c > @@ -17,6 +17,7 @@ > > #include "gadget.h" > #include "core.h" > +#include "host-export.h" > #include "drd.h" > > static inline struct cdns3_role_driver *cdns3_get_current_role_driver(struct cdns3 *cdns) > @@ -98,7 +99,8 @@ static int cdns3_core_init_role(struct cdns3 *cdns) > } > > if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) { > - //TODO: implements host initialization > + if (cdns3_host_init(cdns)) > + dev_info(dev, "doesn't support host\n"); dev_err() And you need to error out with error code. > } > > if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_PERIPHERAL) { > @@ -142,7 +144,7 @@ static irqreturn_t cdns3_irq(int irq, void *data) > > static void cdns3_remove_roles(struct cdns3 *cdns) > { > - //TODO: implements this function if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) > + cdns3_host_remove(cdns); How about calling it cdns3_host_exit() to complement cdns3_host_init(). > } > > static int cdns3_do_role_switch(struct cdns3 *cdns, enum cdns3_roles role) > @@ -410,6 +412,7 @@ static struct platform_driver cdns3_driver = { > > static int __init cdns3_driver_platform_register(void) > { > + cdns3_host_driver_init(); > return platform_driver_register(&cdns3_driver); > } > module_init(cdns3_driver_platform_register); > 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); > + > +#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..0dd47976cb28 > --- /dev/null > +++ b/drivers/usb/cdns3/host.c > @@ -0,0 +1,256 @@ > +// 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 > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "../host/xhci.h" > +#include "core.h" > +#include "host-export.h" > + > +static struct hc_driver __read_mostly xhci_cdns3_hc_driver; > + > +static void xhci_cdns3_quirks(struct device *dev, struct xhci_hcd *xhci) > +{ > + /* > + * As of now platform drivers don't provide MSI support so we ensure > + * here that the generic code does not try to make a pci_dev from our > + * dev struct in order to setup MSI > + */ > + xhci->quirks |= XHCI_PLAT; > +} > + > +static int xhci_cdns3_setup(struct usb_hcd *hcd) > +{ > + struct xhci_hcd *xhci = hcd_to_xhci(hcd); > + u32 command; > + int ret; > + > + ret = xhci_gen_setup(hcd, xhci_cdns3_quirks); > + if (ret) > + return ret; > + > + /* set usbcmd.EU3S */ > + command = readl(&xhci->op_regs->command); > + command |= CMD_PM_INDEX; > + writel(command, &xhci->op_regs->command); > + > + return 0; > +} > + > +static const struct xhci_driver_overrides xhci_cdns3_overrides __initconst = { > + .extra_priv_size = sizeof(struct xhci_hcd), > + .reset = xhci_cdns3_setup, > +}; > + > +struct cdns3_host { > + struct device dev; > + struct usb_hcd *hcd; > +}; > + > +static irqreturn_t cdns3_host_irq(struct cdns3 *cdns) > +{ > + struct device *dev = cdns->host_dev; > + struct usb_hcd *hcd; > + > + if (dev) > + hcd = dev_get_drvdata(dev); > + else > + return IRQ_NONE; > + > + if (hcd) > + return usb_hcd_irq(cdns->irq, hcd); > + else > + return IRQ_NONE; Why can't you just reuse the xhci-platform driver and let it manage the IRQ? Since it is a shared IRQ, different drivers can request the same IRQ and return IRQ_NONE if the IRQ wasn't from their device. > +} > + > +static void cdns3_host_release(struct device *dev) > +{ > + struct cdns3_host *host = container_of(dev, struct cdns3_host, dev); > + > + kfree(host); > +} > + > +static int cdns3_host_start(struct cdns3 *cdns) > +{ > + struct cdns3_host *host; > + struct device *dev; > + struct device *sysdev; > + struct xhci_hcd *xhci; > + int ret; > + > + host = kzalloc(sizeof(*host), GFP_KERNEL); > + if (!host) > + return -ENOMEM; > + > + dev = &host->dev; > + dev->release = cdns3_host_release; > + dev->parent = cdns->dev; > + dev_set_name(dev, "xhci-cdns3"); > + cdns->host_dev = dev; > + ret = device_register(dev); > + if (ret) > + goto err1; > + > + sysdev = cdns->dev; > + /* Try to set 64-bit DMA first */ > + if (WARN_ON(!sysdev->dma_mask)) > + /* Platform did not initialize dma_mask */ > + ret = dma_coerce_mask_and_coherent(sysdev, > + DMA_BIT_MASK(64)); > + else > + ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64)); > + > + /* If setting 64-bit DMA mask fails, fall back to 32-bit DMA mask */ > + if (ret) { > + ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32)); > + if (ret) > + return ret; > + } > + > + pm_runtime_set_active(dev); > + pm_runtime_no_callbacks(dev); > + pm_runtime_enable(dev); > + host->hcd = __usb_create_hcd(&xhci_cdns3_hc_driver, sysdev, dev, > + dev_name(dev), NULL); > + if (!host->hcd) { > + ret = -ENOMEM; > + goto err2; > + } > + > + host->hcd->regs = cdns->xhci_regs; > + host->hcd->rsrc_start = cdns->xhci_res->start; > + host->hcd->rsrc_len = resource_size(cdns->xhci_res); > + > + device_wakeup_enable(host->hcd->self.controller); > + xhci = hcd_to_xhci(host->hcd); > + > + xhci->main_hcd = host->hcd; > + xhci->shared_hcd = __usb_create_hcd(&xhci_cdns3_hc_driver, sysdev, dev, > + dev_name(dev), host->hcd); > + if (!xhci->shared_hcd) { > + ret = -ENOMEM; > + goto err3; > + } > + > + host->hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node); > + xhci->shared_hcd->tpl_support = host->hcd->tpl_support; > + ret = usb_add_hcd(host->hcd, 0, IRQF_SHARED); > + if (ret) > + goto err4; > + > + ret = usb_add_hcd(xhci->shared_hcd, 0, IRQF_SHARED); > + if (ret) > + goto err5; > + > + device_set_wakeup_capable(dev, true); All this is being done by the xhci-plat.c You can make use of it by just creating a xhci-hcd platform device. e.g. platform_device_alloc("xhci-hcd", PLATFORM_DEVID_AUTO); platform_device_add_resources() to add IRQ and memory resource. platform_device_add_properties() to add any quirks. platform_device_add() > + > + return 0; > + > +err5: > + usb_remove_hcd(host->hcd); > +err4: > + usb_put_hcd(xhci->shared_hcd); > +err3: > + usb_put_hcd(host->hcd); > +err2: > + device_del(dev); > +err1: > + put_device(dev); > + cdns->host_dev = NULL; > + return ret; > +} > + > +static void cdns3_host_stop(struct cdns3 *cdns) > +{ > + struct device *dev = cdns->host_dev; > + struct xhci_hcd *xhci; > + struct usb_hcd *hcd; > + > + if (dev) { > + hcd = dev_get_drvdata(dev); > + xhci = hcd_to_xhci(hcd); > + usb_remove_hcd(xhci->shared_hcd); > + usb_remove_hcd(hcd); > + synchronize_irq(cdns->irq); > + usb_put_hcd(xhci->shared_hcd); > + usb_put_hcd(hcd); > + cdns->host_dev = NULL; > + pm_runtime_set_suspended(dev); > + pm_runtime_disable(dev); > + device_del(dev); > + put_device(dev); > + } You can replace this with just platform_device_unregister(xhci_dev); > +} > + > +#if CONFIG_PM > +static int cdns3_host_suspend(struct cdns3 *cdns, bool do_wakeup) > +{ > + struct device *dev = cdns->host_dev; > + struct xhci_hcd *xhci; > + > + if (!dev) > + return 0; > + > + xhci = hcd_to_xhci(dev_get_drvdata(dev)); > + return xhci_suspend(xhci, do_wakeup); > +} > + > +static int cdns3_host_resume(struct cdns3 *cdns, bool hibernated) > +{ > + struct device *dev = cdns->host_dev; > + struct xhci_hcd *xhci; > + > + if (!dev) > + return 0; > + > + xhci = hcd_to_xhci(dev_get_drvdata(dev)); > + return xhci_resume(xhci, hibernated); > +} These won't be required any more as xhci-plat is doing this. > +#endif /* CONFIG_PM */ > + > +int cdns3_host_init(struct cdns3 *cdns) > +{ > + struct cdns3_role_driver *rdrv; > + > + rdrv = devm_kzalloc(cdns->dev, sizeof(*rdrv), GFP_KERNEL); > + if (!rdrv) > + return -ENOMEM; > + > + rdrv->start = cdns3_host_start; > + rdrv->stop = cdns3_host_stop; > + rdrv->irq = cdns3_host_irq; > +#if CONFIG_PM > + rdrv->suspend = cdns3_host_suspend; > + rdrv->resume = cdns3_host_resume; > +#endif /* CONFIG_PM */ > + rdrv->name = "host"; > + cdns->roles[CDNS3_ROLE_HOST] = rdrv; > + > + return 0; > +} > + > +void cdns3_host_remove(struct cdns3 *cdns) > +{ > + cdns3_host_stop(cdns); calling cdns3_host_stop() here can lead to problems as Controller might be in peripheral mode at this point. The core driver needs to ensure that relevant role is stopped before calling cdns3_host_remove(). Here you need to unregister the role driver though. cdns->roles[CDNS3_ROLE_HOST] = NULL; > +} > + > +void __init cdns3_host_driver_init(void) > +{ > + xhci_init_driver(&xhci_cdns3_hc_driver, &xhci_cdns3_overrides); > +} > cheers, -roger -- Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki. Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki 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 87FB3C43441 for ; Fri, 23 Nov 2018 14:23:14 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 39D5D20664 for ; Fri, 23 Nov 2018 14:23:14 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 39D5D20664 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 S2390958AbeKXBHf (ORCPT ); Fri, 23 Nov 2018 20:07:35 -0500 Received: from fllv0016.ext.ti.com ([198.47.19.142]:37006 "EHLO fllv0016.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729105AbeKXBHf (ORCPT ); Fri, 23 Nov 2018 20:07:35 -0500 Received: from lelv0266.itg.ti.com ([10.180.67.225]) by fllv0016.ext.ti.com (8.15.2/8.15.2) with ESMTP id wANEN5gn113106; Fri, 23 Nov 2018 08:23:05 -0600 Received: from DFLE103.ent.ti.com (dfle103.ent.ti.com [10.64.6.24]) by lelv0266.itg.ti.com (8.15.2/8.15.2) with ESMTPS id wANEN46Q014889 (version=TLSv1.2 cipher=AES256-GCM-SHA384 bits=256 verify=FAIL); Fri, 23 Nov 2018 08:23:04 -0600 Received: from DFLE110.ent.ti.com (10.64.6.31) by DFLE103.ent.ti.com (10.64.6.24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1591.10; Fri, 23 Nov 2018 08:23:04 -0600 Received: from dflp33.itg.ti.com (10.64.6.16) by DFLE110.ent.ti.com (10.64.6.31) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1591.10 via Frontend Transport; Fri, 23 Nov 2018 08:23:04 -0600 Received: from [192.168.2.6] (ileax41-snat.itg.ti.com [10.172.224.153]) by dflp33.itg.ti.com (8.14.3/8.13.8) with ESMTP id wANEN15G023770; Fri, 23 Nov 2018 08:23:01 -0600 Subject: Re: [RFC PATCH v2 06/15] usb:cdns3: Adds Host support To: Pawel Laszczak , References: <1542535751-16079-1-git-send-email-pawell@cadence.com> <1542535751-16079-7-git-send-email-pawell@cadence.com> CC: , , , , , , , , , , From: Roger Quadros Message-ID: <5BF80D44.2050600@ti.com> Date: Fri, 23 Nov 2018 16:23:00 +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: <1542535751-16079-7-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 18/11/18 12:09, Pawel Laszczak wrote: > Patch adds host-export.h and host.c file and mplements functions that > allow to initialize, start and stop XHCI host driver. > > Signed-off-by: Pawel Laszczak > --- > drivers/usb/cdns3/Kconfig | 10 ++ > drivers/usb/cdns3/Makefile | 1 + > drivers/usb/cdns3/core.c | 7 +- > drivers/usb/cdns3/host-export.h | 30 ++++ > drivers/usb/cdns3/host.c | 256 ++++++++++++++++++++++++++++++++ > 5 files changed, 302 insertions(+), 2 deletions(-) > 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 eb22a8692991..d92bc3d68eb0 100644 > --- a/drivers/usb/cdns3/Kconfig > +++ b/drivers/usb/cdns3/Kconfig > @@ -10,6 +10,16 @@ config USB_CDNS3 > > if USB_CDNS3 > > +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. > + > 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 e779b2a2f8eb..976117ba67ff 100644 > --- a/drivers/usb/cdns3/Makefile > +++ b/drivers/usb/cdns3/Makefile > @@ -2,4 +2,5 @@ obj-$(CONFIG_USB_CDNS3) += cdns3.o > obj-$(CONFIG_USB_CDNS3_PCI_WRAP) += cdns3-pci.o > > cdns3-y := core.o drd.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 > index dbee4325da7f..4cb820be9ff3 100644 > --- a/drivers/usb/cdns3/core.c > +++ b/drivers/usb/cdns3/core.c > @@ -17,6 +17,7 @@ > > #include "gadget.h" > #include "core.h" > +#include "host-export.h" > #include "drd.h" > > static inline struct cdns3_role_driver *cdns3_get_current_role_driver(struct cdns3 *cdns) > @@ -98,7 +99,8 @@ static int cdns3_core_init_role(struct cdns3 *cdns) > } > > if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) { > - //TODO: implements host initialization > + if (cdns3_host_init(cdns)) > + dev_info(dev, "doesn't support host\n"); dev_err() And you need to error out with error code. > } > > if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_PERIPHERAL) { > @@ -142,7 +144,7 @@ static irqreturn_t cdns3_irq(int irq, void *data) > > static void cdns3_remove_roles(struct cdns3 *cdns) > { > - //TODO: implements this function if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) > + cdns3_host_remove(cdns); How about calling it cdns3_host_exit() to complement cdns3_host_init(). > } > > static int cdns3_do_role_switch(struct cdns3 *cdns, enum cdns3_roles role) > @@ -410,6 +412,7 @@ static struct platform_driver cdns3_driver = { > > static int __init cdns3_driver_platform_register(void) > { > + cdns3_host_driver_init(); > return platform_driver_register(&cdns3_driver); > } > module_init(cdns3_driver_platform_register); > 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); > + > +#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..0dd47976cb28 > --- /dev/null > +++ b/drivers/usb/cdns3/host.c > @@ -0,0 +1,256 @@ > +// 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 > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "../host/xhci.h" > +#include "core.h" > +#include "host-export.h" > + > +static struct hc_driver __read_mostly xhci_cdns3_hc_driver; > + > +static void xhci_cdns3_quirks(struct device *dev, struct xhci_hcd *xhci) > +{ > + /* > + * As of now platform drivers don't provide MSI support so we ensure > + * here that the generic code does not try to make a pci_dev from our > + * dev struct in order to setup MSI > + */ > + xhci->quirks |= XHCI_PLAT; > +} > + > +static int xhci_cdns3_setup(struct usb_hcd *hcd) > +{ > + struct xhci_hcd *xhci = hcd_to_xhci(hcd); > + u32 command; > + int ret; > + > + ret = xhci_gen_setup(hcd, xhci_cdns3_quirks); > + if (ret) > + return ret; > + > + /* set usbcmd.EU3S */ > + command = readl(&xhci->op_regs->command); > + command |= CMD_PM_INDEX; > + writel(command, &xhci->op_regs->command); > + > + return 0; > +} > + > +static const struct xhci_driver_overrides xhci_cdns3_overrides __initconst = { > + .extra_priv_size = sizeof(struct xhci_hcd), > + .reset = xhci_cdns3_setup, > +}; > + > +struct cdns3_host { > + struct device dev; > + struct usb_hcd *hcd; > +}; > + > +static irqreturn_t cdns3_host_irq(struct cdns3 *cdns) > +{ > + struct device *dev = cdns->host_dev; > + struct usb_hcd *hcd; > + > + if (dev) > + hcd = dev_get_drvdata(dev); > + else > + return IRQ_NONE; > + > + if (hcd) > + return usb_hcd_irq(cdns->irq, hcd); > + else > + return IRQ_NONE; Why can't you just reuse the xhci-platform driver and let it manage the IRQ? Since it is a shared IRQ, different drivers can request the same IRQ and return IRQ_NONE if the IRQ wasn't from their device. > +} > + > +static void cdns3_host_release(struct device *dev) > +{ > + struct cdns3_host *host = container_of(dev, struct cdns3_host, dev); > + > + kfree(host); > +} > + > +static int cdns3_host_start(struct cdns3 *cdns) > +{ > + struct cdns3_host *host; > + struct device *dev; > + struct device *sysdev; > + struct xhci_hcd *xhci; > + int ret; > + > + host = kzalloc(sizeof(*host), GFP_KERNEL); > + if (!host) > + return -ENOMEM; > + > + dev = &host->dev; > + dev->release = cdns3_host_release; > + dev->parent = cdns->dev; > + dev_set_name(dev, "xhci-cdns3"); > + cdns->host_dev = dev; > + ret = device_register(dev); > + if (ret) > + goto err1; > + > + sysdev = cdns->dev; > + /* Try to set 64-bit DMA first */ > + if (WARN_ON(!sysdev->dma_mask)) > + /* Platform did not initialize dma_mask */ > + ret = dma_coerce_mask_and_coherent(sysdev, > + DMA_BIT_MASK(64)); > + else > + ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64)); > + > + /* If setting 64-bit DMA mask fails, fall back to 32-bit DMA mask */ > + if (ret) { > + ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32)); > + if (ret) > + return ret; > + } > + > + pm_runtime_set_active(dev); > + pm_runtime_no_callbacks(dev); > + pm_runtime_enable(dev); > + host->hcd = __usb_create_hcd(&xhci_cdns3_hc_driver, sysdev, dev, > + dev_name(dev), NULL); > + if (!host->hcd) { > + ret = -ENOMEM; > + goto err2; > + } > + > + host->hcd->regs = cdns->xhci_regs; > + host->hcd->rsrc_start = cdns->xhci_res->start; > + host->hcd->rsrc_len = resource_size(cdns->xhci_res); > + > + device_wakeup_enable(host->hcd->self.controller); > + xhci = hcd_to_xhci(host->hcd); > + > + xhci->main_hcd = host->hcd; > + xhci->shared_hcd = __usb_create_hcd(&xhci_cdns3_hc_driver, sysdev, dev, > + dev_name(dev), host->hcd); > + if (!xhci->shared_hcd) { > + ret = -ENOMEM; > + goto err3; > + } > + > + host->hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node); > + xhci->shared_hcd->tpl_support = host->hcd->tpl_support; > + ret = usb_add_hcd(host->hcd, 0, IRQF_SHARED); > + if (ret) > + goto err4; > + > + ret = usb_add_hcd(xhci->shared_hcd, 0, IRQF_SHARED); > + if (ret) > + goto err5; > + > + device_set_wakeup_capable(dev, true); All this is being done by the xhci-plat.c You can make use of it by just creating a xhci-hcd platform device. e.g. platform_device_alloc("xhci-hcd", PLATFORM_DEVID_AUTO); platform_device_add_resources() to add IRQ and memory resource. platform_device_add_properties() to add any quirks. platform_device_add() > + > + return 0; > + > +err5: > + usb_remove_hcd(host->hcd); > +err4: > + usb_put_hcd(xhci->shared_hcd); > +err3: > + usb_put_hcd(host->hcd); > +err2: > + device_del(dev); > +err1: > + put_device(dev); > + cdns->host_dev = NULL; > + return ret; > +} > + > +static void cdns3_host_stop(struct cdns3 *cdns) > +{ > + struct device *dev = cdns->host_dev; > + struct xhci_hcd *xhci; > + struct usb_hcd *hcd; > + > + if (dev) { > + hcd = dev_get_drvdata(dev); > + xhci = hcd_to_xhci(hcd); > + usb_remove_hcd(xhci->shared_hcd); > + usb_remove_hcd(hcd); > + synchronize_irq(cdns->irq); > + usb_put_hcd(xhci->shared_hcd); > + usb_put_hcd(hcd); > + cdns->host_dev = NULL; > + pm_runtime_set_suspended(dev); > + pm_runtime_disable(dev); > + device_del(dev); > + put_device(dev); > + } You can replace this with just platform_device_unregister(xhci_dev); > +} > + > +#if CONFIG_PM > +static int cdns3_host_suspend(struct cdns3 *cdns, bool do_wakeup) > +{ > + struct device *dev = cdns->host_dev; > + struct xhci_hcd *xhci; > + > + if (!dev) > + return 0; > + > + xhci = hcd_to_xhci(dev_get_drvdata(dev)); > + return xhci_suspend(xhci, do_wakeup); > +} > + > +static int cdns3_host_resume(struct cdns3 *cdns, bool hibernated) > +{ > + struct device *dev = cdns->host_dev; > + struct xhci_hcd *xhci; > + > + if (!dev) > + return 0; > + > + xhci = hcd_to_xhci(dev_get_drvdata(dev)); > + return xhci_resume(xhci, hibernated); > +} These won't be required any more as xhci-plat is doing this. > +#endif /* CONFIG_PM */ > + > +int cdns3_host_init(struct cdns3 *cdns) > +{ > + struct cdns3_role_driver *rdrv; > + > + rdrv = devm_kzalloc(cdns->dev, sizeof(*rdrv), GFP_KERNEL); > + if (!rdrv) > + return -ENOMEM; > + > + rdrv->start = cdns3_host_start; > + rdrv->stop = cdns3_host_stop; > + rdrv->irq = cdns3_host_irq; > +#if CONFIG_PM > + rdrv->suspend = cdns3_host_suspend; > + rdrv->resume = cdns3_host_resume; > +#endif /* CONFIG_PM */ > + rdrv->name = "host"; > + cdns->roles[CDNS3_ROLE_HOST] = rdrv; > + > + return 0; > +} > + > +void cdns3_host_remove(struct cdns3 *cdns) > +{ > + cdns3_host_stop(cdns); calling cdns3_host_stop() here can lead to problems as Controller might be in peripheral mode at this point. The core driver needs to ensure that relevant role is stopped before calling cdns3_host_remove(). Here you need to unregister the role driver though. cdns->roles[CDNS3_ROLE_HOST] = NULL; > +} > + > +void __init cdns3_host_driver_init(void) > +{ > + xhci_init_driver(&xhci_cdns3_hc_driver, &xhci_cdns3_overrides); > +} > cheers, -roger -- Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki. Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki