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: <5BFBC201.4000000@ti.com> Date: Mon, 26 Nov 2018 11:50:57 +0200 To: Pawel Laszczak , "devicetree@vger.kernel.org" Cc: "gregkh@linuxfoundation.org" , "linux-usb@vger.kernel.org" , "linux-kernel@vger.kernel.org" , Alan Douglas , "jbergsagel@ti.com" , "nsekhar@ti.com" , "nm@ti.com" , Suresh Punnoose , "peter.chen@nxp.com" , Pawel Jez , Rahul Kumar List-ID: SGksCgpPbiAyNi8xMS8xOCAxMDoyNCwgUGF3ZWwgTGFzemN6YWsgd3JvdGU6Cj4+IEVYVEVSTkFM IE1BSUwKPj4KPj4KPj4gT24gMTgvMTEvMTggMTI6MDksIFBhd2VsIExhc3pjemFrIHdyb3RlOgo+ Pj4gUGF0Y2ggYWRkcyBob3N0LWV4cG9ydC5oIGFuZCBob3N0LmMgZmlsZSBhbmQgbXBsZW1lbnRz IGZ1bmN0aW9ucyB0aGF0Cj4+PiBhbGxvdyB0byBpbml0aWFsaXplLCBzdGFydCBhbmQgc3RvcCBY SENJIGhvc3QgZHJpdmVyLgo+Pj4KPj4+IFNpZ25lZC1vZmYtYnk6IFBhd2VsIExhc3pjemFrIDxw YXdlbGxAY2FkZW5jZS5jb20+Cj4+PiAtLS0KPj4+ICBkcml2ZXJzL3VzYi9jZG5zMy9LY29uZmln ICAgICAgIHwgIDEwICsrCj4+PiAgZHJpdmVycy91c2IvY2RuczMvTWFrZWZpbGUgICAgICB8ICAg MSArCj4+PiAgZHJpdmVycy91c2IvY2RuczMvY29yZS5jICAgICAgICB8ICAgNyArLQo+Pj4gIGRy aXZlcnMvdXNiL2NkbnMzL2hvc3QtZXhwb3J0LmggfCAgMzAgKysrKwo+Pj4gIGRyaXZlcnMvdXNi L2NkbnMzL2hvc3QuYyAgICAgICAgfCAyNTYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKPj4+ICA1IGZpbGVzIGNoYW5nZWQsIDMwMiBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygt KQo+Pj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3VzYi9jZG5zMy9ob3N0LWV4cG9ydC5o Cj4+PiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvdXNiL2NkbnMzL2hvc3QuYwo+Pj4KPj4+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jZG5zMy9LY29uZmlnIGIvZHJpdmVycy91c2IvY2Ru czMvS2NvbmZpZwo+Pj4gaW5kZXggZWIyMmE4NjkyOTkxLi5kOTJiYzNkNjhlYjAgMTAwNjQ0Cj4+ PiAtLS0gYS9kcml2ZXJzL3VzYi9jZG5zMy9LY29uZmlnCj4+PiArKysgYi9kcml2ZXJzL3VzYi9j ZG5zMy9LY29uZmlnCj4+PiBAQCAtMTAsNiArMTAsMTYgQEAgY29uZmlnIFVTQl9DRE5TMwo+Pj4K Pj4+ICBpZiBVU0JfQ0ROUzMKPj4+Cj4+PiArY29uZmlnIFVTQl9DRE5TM19IT1NUCj4+PiArICAg ICAgICBib29sICJDYWRlbmNlIFVTQjMgaG9zdCBjb250cm9sbGVyIgo+Pj4gKyAgICAgICAgZGVw ZW5kcyBvbiBVU0JfWEhDSV9IQ0QKPj4+ICsgICAgICAgIGhlbHAKPj4+ICsgICAgICAgICAgU2F5 IFkgaGVyZSB0byBlbmFibGUgaG9zdCBjb250cm9sbGVyIGZ1bmN0aW9uYWxpdHkgb2YgdGhlCj4+ PiArICAgICAgICAgIGNhZGVuY2UgZHJpdmVyLgo+Pj4gKwo+Pj4gKyAgICAgICAgICBIb3N0IGNv bnRyb2xsZXIgaXMgY29tcGxpYW5jZSB3aXRoIFhIQ0kgc28gaXQgd2lsbCB1c2UKPj4+ICsgICAg ICAgICAgc3RhbmRhcmQgWEhDSSBkcml2ZXIuCj4+PiArCj4+PiAgY29uZmlnIFVTQl9DRE5TM19Q Q0lfV1JBUAo+Pj4gIAl0cmlzdGF0ZSAiUENJZS1iYXNlZCBQbGF0Zm9ybXMiCj4+PiAgCWRlcGVu ZHMgb24gVVNCX1BDSSAmJiBBQ1BJCj4+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMv TWFrZWZpbGUgYi9kcml2ZXJzL3VzYi9jZG5zMy9NYWtlZmlsZQo+Pj4gaW5kZXggZTc3OWIyYTJm OGViLi45NzYxMTdiYTY3ZmYgMTAwNjQ0Cj4+PiAtLS0gYS9kcml2ZXJzL3VzYi9jZG5zMy9NYWtl ZmlsZQo+Pj4gKysrIGIvZHJpdmVycy91c2IvY2RuczMvTWFrZWZpbGUKPj4+IEBAIC0yLDQgKzIs NSBAQCBvYmotJChDT05GSUdfVVNCX0NETlMzKQkJCSs9IGNkbnMzLm8KPj4+ICBvYmotJChDT05G SUdfVVNCX0NETlMzX1BDSV9XUkFQKQkrPSBjZG5zMy1wY2kubwo+Pj4KPj4+ICBjZG5zMy15CQkJ CQk6PSBjb3JlLm8gZHJkLm8KPj4+ICtjZG5zMy0kKENPTkZJR19VU0JfQ0ROUzNfSE9TVCkgICAg ICAgICAgKz0gaG9zdC5vCj4+PiAgY2RuczMtcGNpLXkJCSAJCTo9IGNkbnMzLXBjaS13cmFwLm8K Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jZG5zMy9jb3JlLmMgYi9kcml2ZXJzL3VzYi9j ZG5zMy9jb3JlLmMKPj4+IGluZGV4IGRiZWU0MzI1ZGE3Zi4uNGNiODIwYmU5ZmYzIDEwMDY0NAo+ Pj4gLS0tIGEvZHJpdmVycy91c2IvY2RuczMvY29yZS5jCj4+PiArKysgYi9kcml2ZXJzL3VzYi9j ZG5zMy9jb3JlLmMKPj4+IEBAIC0xNyw2ICsxNyw3IEBACj4+Pgo+Pj4gICNpbmNsdWRlICJnYWRn ZXQuaCIKPj4+ICAjaW5jbHVkZSAiY29yZS5oIgo+Pj4gKyNpbmNsdWRlICJob3N0LWV4cG9ydC5o Igo+Pj4gICNpbmNsdWRlICJkcmQuaCIKPj4+Cj4+PiAgc3RhdGljIGlubGluZSBzdHJ1Y3QgY2Ru czNfcm9sZV9kcml2ZXIgKmNkbnMzX2dldF9jdXJyZW50X3JvbGVfZHJpdmVyKHN0cnVjdCBjZG5z MyAqY2RucykKPj4+IEBAIC05OCw3ICs5OSw4IEBAIHN0YXRpYyBpbnQgY2RuczNfY29yZV9pbml0 X3JvbGUoc3RydWN0IGNkbnMzICpjZG5zKQo+Pj4gIAl9Cj4+Pgo+Pj4gIAlpZiAoZHJfbW9kZSA9 PSBVU0JfRFJfTU9ERV9PVEcgfHwgZHJfbW9kZSA9PSBVU0JfRFJfTU9ERV9IT1NUKSB7Cj4+PiAt CQkvL1RPRE86IGltcGxlbWVudHMgaG9zdCBpbml0aWFsaXphdGlvbgo+Pj4gKwkJaWYgKGNkbnMz X2hvc3RfaW5pdChjZG5zKSkKPj4+ICsJCQlkZXZfaW5mbyhkZXYsICJkb2Vzbid0IHN1cHBvcnQg aG9zdFxuIik7Cj4+Cj4+IGRldl9lcnIoKQo+Pgo+PiBBbmQgeW91IG5lZWQgdG8gZXJyb3Igb3V0 IHdpdGggZXJyb3IgY29kZS4KPiAKPiBvaywgYnV0IEkgYXNzdW1lIHRoYXQgZXZlbiBpZiBob3N0 IHJldHVybnMgZXJyb3IgdGhlbiB3ZSBjYW4gdXNlIAo+IG9ubHkgZGV2aWNlIHJvbGUuIE9ubHkg d2hlbiBib3RoIGZ1bmN0aW9ucyByZXR1cm4gZXJyb3JzLCB0aGVuIGl0J3MgIGEgY3JpdGljYWwg ZXJyb3IgCj4gYW5kIGZ1bmN0aW9uIHJldHVybiBlcnJvciBjb2RlLiAKCkJ1dCBhdCB0aGlzIHBv aW50IHdlIGFyZSBpbiBPVEcgb3IgSE9TVCBkcl9tb2RlIGFuZCB3aXRob3V0IGhvc3QgZnVuY3Rp b25hbApib3RoIHdpbGwgbm90IGZ1bmN0aW9uIGNvcnJlY3RseS4gU28gd2UgbXVzdCBlcnJvciBv dXQgc28gdXNlciBjYW4gZGVidWcuCgo+Pgo+Pj4gIAl9Cj4+Pgo+Pj4gIAlpZiAoZHJfbW9kZSA9 PSBVU0JfRFJfTU9ERV9PVEcgfHwgZHJfbW9kZSA9PSBVU0JfRFJfTU9ERV9QRVJJUEhFUkFMKSB7 Cj4+PiBAQCAtMTQyLDcgKzE0NCw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBjZG5zM19pcnEoaW50 IGlycSwgdm9pZCAqZGF0YSkKPj4+Cj4+PiAgc3RhdGljIHZvaWQgY2RuczNfcmVtb3ZlX3JvbGVz KHN0cnVjdCBjZG5zMyAqY2RucykKPj4+ICB7Cj4+PiAtCS8vVE9ETzogaW1wbGVtZW50cyB0aGlz IGZ1bmN0aW9uCj4+Cj4+IGlmIChkcl9tb2RlID09IFVTQl9EUl9NT0RFX09URyB8fCBkcl9tb2Rl ID09IFVTQl9EUl9NT0RFX0hPU1QpCj4+Cj4+PiArCWNkbnMzX2hvc3RfcmVtb3ZlKGNkbnMpOwo+ Pgo+PiBIb3cgYWJvdXQgY2FsbGluZyBpdCBjZG5zM19ob3N0X2V4aXQoKSB0byBjb21wbGVtZW50 IGNkbnMzX2hvc3RfaW5pdCgpLgo+Pgo+Pj4gIH0KPj4+Cj4+PiAgc3RhdGljIGludCBjZG5zM19k b19yb2xlX3N3aXRjaChzdHJ1Y3QgY2RuczMgKmNkbnMsIGVudW0gY2RuczNfcm9sZXMgcm9sZSkK Pj4+IEBAIC00MTAsNiArNDEyLDcgQEAgc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgY2Ru czNfZHJpdmVyID0gewo+Pj4KPj4+ICBzdGF0aWMgaW50IF9faW5pdCBjZG5zM19kcml2ZXJfcGxh dGZvcm1fcmVnaXN0ZXIodm9pZCkKPj4+ICB7Cj4+PiArCWNkbnMzX2hvc3RfZHJpdmVyX2luaXQo KTsKPj4+ICAJcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmY2RuczNfZHJpdmVyKTsK Pj4+ICB9Cj4+PiAgbW9kdWxlX2luaXQoY2RuczNfZHJpdmVyX3BsYXRmb3JtX3JlZ2lzdGVyKTsK Pj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jZG5zMy9ob3N0LWV4cG9ydC5oIGIvZHJpdmVy cy91c2IvY2RuczMvaG9zdC1leHBvcnQuaAo+Pj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4+IGlu ZGV4IDAwMDAwMDAwMDAwMC4uZjhmM2IyMzBiNDcyCj4+PiAtLS0gL2Rldi9udWxsCj4+PiArKysg Yi9kcml2ZXJzL3VzYi9jZG5zMy9ob3N0LWV4cG9ydC5oCj4+PiBAQCAtMCwwICsxLDMwIEBACj4+ PiArLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KPj4+ICsvKgo+Pj4gKyAq IENhZGVuY2UgVVNCU1MgRFJEIERyaXZlciAtSG9zdCBFeHBvcnQgQVBJcwo+Pj4gKyAqCj4+PiAr ICogQ29weXJpZ2h0IChDKSAyMDE3IE5YUAo+Pj4gKyAqCj4+PiArICogQXV0aG9yczogUGV0ZXIg Q2hlbiA8cGV0ZXIuY2hlbkBueHAuY29tPgo+Pj4gKyAqLwo+Pj4gKyNpZm5kZWYgX19MSU5VWF9D RE5TM19IT1NUX0VYUE9SVAo+Pj4gKyNkZWZpbmUgX19MSU5VWF9DRE5TM19IT1NUX0VYUE9SVAo+ Pj4gKwo+Pj4gKyNpZmRlZiBDT05GSUdfVVNCX0NETlMzX0hPU1QKPj4+ICsKPj4+ICtpbnQgY2Ru czNfaG9zdF9pbml0KHN0cnVjdCBjZG5zMyAqY2Rucyk7Cj4+PiArdm9pZCBjZG5zM19ob3N0X3Jl bW92ZShzdHJ1Y3QgY2RuczMgKmNkbnMpOwo+Pj4gK3ZvaWQgY2RuczNfaG9zdF9kcml2ZXJfaW5p dCh2b2lkKTsKPj4+ICsKPj4+ICsjZWxzZQo+Pj4gKwo+Pj4gK3N0YXRpYyBpbmxpbmUgaW50IGNk bnMzX2hvc3RfaW5pdChzdHJ1Y3QgY2RuczMgKmNkbnMpCj4+PiArewo+Pj4gKwlyZXR1cm4gLUVO WElPOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgaW5saW5lIHZvaWQgY2RuczNfaG9zdF9yZW1v dmUoc3RydWN0IGNkbnMzICpjZG5zKSB7IH0KPj4+ICtzdGF0aWMgaW5saW5lIHZvaWQgY2RuczNf aG9zdF9kcml2ZXJfaW5pdCh2b2lkKSB7fQo+Pj4gKwo+Pj4gKyNlbmRpZiAvKiBDT05GSUdfVVNC X0NETlMzX0hPU1QgKi8KPj4+ICsKPj4+ICsjZW5kaWYgLyogX19MSU5VWF9DRE5TM19IT1NUX0VY UE9SVCAqLwo+Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NkbnMzL2hvc3QuYyBiL2RyaXZl cnMvdXNiL2NkbnMzL2hvc3QuYwo+Pj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4+IGluZGV4IDAw MDAwMDAwMDAwMC4uMGRkNDc5NzZjYjI4Cj4+PiAtLS0gL2Rldi9udWxsCj4+PiArKysgYi9kcml2 ZXJzL3VzYi9jZG5zMy9ob3N0LmMKPj4+IEBAIC0wLDAgKzEsMjU2IEBACj4+PiArLy8gU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPj4+ICsvKgo+Pj4gKyAqIENhZGVuY2UgVVNCU1Mg RFJEIERyaXZlciAtIGhvc3Qgc2lkZQo+Pj4gKyAqCj4+PiArICogQ29weXJpZ2h0IChDKSAyMDE4 IENhZGVuY2UgRGVzaWduIFN5c3RlbXMuCj4+PiArICogQ29weXJpZ2h0IChDKSAyMDE4IE5YUAo+ Pj4gKyAqCj4+PiArICogQXV0aG9yczogUGV0ZXIgQ2hlbiA8cGV0ZXIuY2hlbkBueHAuY29tPgo+ Pj4gKyAqCSAgICBQYXdlbCBMYXN6Y3phayA8cGF3ZWxsQGNhZGVuY2UuY29tPgo+Pj4gKyAqLwo+ Pj4gKwo+Pj4gKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPj4+ICsjaW5jbHVkZSA8bGludXgv ZGV2aWNlLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L2lvLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4 L3NsYWIuaD4KPj4+ICsjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KPj4+ICsjaW5jbHVk ZSA8bGludXgvdXNiLmg+Cj4+PiArI2luY2x1ZGUgPGxpbnV4L3VzYi9oY2QuaD4KPj4+ICsjaW5j bHVkZSA8bGludXgvcG1fcnVudGltZS5oPgo+Pj4gKyNpbmNsdWRlIDxsaW51eC91c2Ivb2YuaD4K Pj4+ICsKPj4+ICsjaW5jbHVkZSAiLi4vaG9zdC94aGNpLmgiCj4+PiArI2luY2x1ZGUgImNvcmUu aCIKPj4+ICsjaW5jbHVkZSAiaG9zdC1leHBvcnQuaCIKPj4+ICsKPj4+ICtzdGF0aWMgc3RydWN0 IGhjX2RyaXZlciBfX3JlYWRfbW9zdGx5IHhoY2lfY2RuczNfaGNfZHJpdmVyOwo+Pj4gKwo+Pj4g K3N0YXRpYyB2b2lkIHhoY2lfY2RuczNfcXVpcmtzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0 IHhoY2lfaGNkICp4aGNpKQo+Pj4gK3sKPj4+ICsJLyoKPj4+ICsJICogQXMgb2Ygbm93IHBsYXRm b3JtIGRyaXZlcnMgZG9uJ3QgcHJvdmlkZSBNU0kgc3VwcG9ydCBzbyB3ZSBlbnN1cmUKPj4+ICsJ ICogaGVyZSB0aGF0IHRoZSBnZW5lcmljIGNvZGUgZG9lcyBub3QgdHJ5IHRvIG1ha2UgYSBwY2lf ZGV2IGZyb20gb3VyCj4+PiArCSAqIGRldiBzdHJ1Y3QgaW4gb3JkZXIgdG8gc2V0dXAgTVNJCj4+ PiArCSAqLwo+Pj4gKwl4aGNpLT5xdWlya3MgfD0gWEhDSV9QTEFUOwo+Pj4gK30KPj4+ICsKPj4+ ICtzdGF0aWMgaW50IHhoY2lfY2RuczNfc2V0dXAoc3RydWN0IHVzYl9oY2QgKmhjZCkKPj4+ICt7 Cj4+PiArCXN0cnVjdCB4aGNpX2hjZAkqeGhjaSA9IGhjZF90b194aGNpKGhjZCk7Cj4+PiArCXUz MiBjb21tYW5kOwo+Pj4gKwlpbnQgcmV0Owo+Pj4gKwo+Pj4gKwlyZXQgPSB4aGNpX2dlbl9zZXR1 cChoY2QsIHhoY2lfY2RuczNfcXVpcmtzKTsKPj4+ICsJaWYgKHJldCkKPj4+ICsJCXJldHVybiBy ZXQ7Cj4+PiArCj4+PiArCS8qIHNldCB1c2JjbWQuRVUzUyAqLwo+Pj4gKwljb21tYW5kID0gcmVh ZGwoJnhoY2ktPm9wX3JlZ3MtPmNvbW1hbmQpOwo+Pj4gKwljb21tYW5kIHw9IENNRF9QTV9JTkRF WDsKPj4+ICsJd3JpdGVsKGNvbW1hbmQsICZ4aGNpLT5vcF9yZWdzLT5jb21tYW5kKTsKPj4+ICsK Pj4+ICsJcmV0dXJuIDA7Cj4+PiArfQo+Pj4gKwo+Pj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGhj aV9kcml2ZXJfb3ZlcnJpZGVzIHhoY2lfY2RuczNfb3ZlcnJpZGVzIF9faW5pdGNvbnN0ID0gewo+ Pj4gKwkuZXh0cmFfcHJpdl9zaXplID0gc2l6ZW9mKHN0cnVjdCB4aGNpX2hjZCksCj4+PiArCS5y ZXNldCA9IHhoY2lfY2RuczNfc2V0dXAsCj4+PiArfTsKPj4+ICsKPj4+ICtzdHJ1Y3QgY2RuczNf aG9zdCB7Cj4+PiArCXN0cnVjdCBkZXZpY2UgZGV2Owo+Pj4gKwlzdHJ1Y3QgdXNiX2hjZCAqaGNk Owo+Pj4gK307Cj4+PiArCj4+PiArc3RhdGljIGlycXJldHVybl90IGNkbnMzX2hvc3RfaXJxKHN0 cnVjdCBjZG5zMyAqY2RucykKPj4+ICt7Cj4+PiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNkbnMt Pmhvc3RfZGV2Owo+Pj4gKwlzdHJ1Y3QgdXNiX2hjZAkqaGNkOwo+Pj4gKwo+Pj4gKwlpZiAoZGV2 KQo+Pj4gKwkJaGNkID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+PiArCWVsc2UKPj4+ICsJCXJl dHVybiBJUlFfTk9ORTsKPj4+ICsKPj4+ICsJaWYgKGhjZCkKPj4+ICsJCXJldHVybiB1c2JfaGNk X2lycShjZG5zLT5pcnEsIGhjZCk7Cj4+PiArCWVsc2UKPj4+ICsJCXJldHVybiBJUlFfTk9ORTsK Pj4KPj4gV2h5IGNhbid0IHlvdSBqdXN0IHJldXNlIHRoZSB4aGNpLXBsYXRmb3JtIGRyaXZlciBh bmQgbGV0IGl0IG1hbmFnZSB0aGUgSVJRPwo+PiBTaW5jZSBpdCBpcyBhIHNoYXJlZCBJUlEsIGRp ZmZlcmVudCBkcml2ZXJzIGNhbiByZXF1ZXN0IHRoZSBzYW1lIElSUSBhbmQgcmV0dXJuIElSUV9O T05FCj4+IGlmIHRoZSBJUlEgd2Fzbid0IGZyb20gdGhlaXIgZGV2aWNlLgo+IAo+IEluIGRldmlj ZSByb2xlIHRoZSBob3N0IHBhcnQgb2YgY29udHJvbGxlciBpcyBrZXB0IGluIHJlc2V0LCBzbyBk cml2ZXIgY2FuJ3QgcmVhZCB0aGUgaG9zdCByZWdpc3Rlci4gCj4gU3VjaCBzb2x1dGlvbiBhbGxv d3MgZHJpdmVyIHRvIGNvbnRyb2wgYWNjZXNzIHRvIGhvc3QgcmVnaXN0ZXIuIAo+IFNvIGlmIGRy aXZlciBoYXMgc2hhcmVkIHNlcGFyYXRlIGludGVycnVwdCBmb3IgaG9zdCByb2xlIHRoZW4gaXQg aGFzIHRvIGNoZWNrIGlmIGNvbnRyb2xsZXIgd29yayBpbiAKPiBIb3N0IHJvbGUuICAKCkkgdW5k ZXJzdGFuZCB3aGF0IHlvdSBtZWFuLiBJIHRoaW5rIHRoZSBpc3N1ZSBoZXJlIGlzIHRoYXQgeW91 IGFyZSBoYXZpbmcgdGhlIGhvc3QgSVNSIGFjdGl2ZQpldmVuIHdoZW4gaG9zdCByb2xlIGlzIHN0 b3BwZWQuIFRoaXMgaXMgdGhlIHJvb3QgY2F1c2Ugb2YgdGhlIHByb2JsZW0uCgpXaGVuIHlvdSBz dG9wIGhvc3Qgcm9sZSwgdGhlIGhvc3QgZHJpdmVyICptdXN0KiB1bnJlZ2lzdGVyIHRoZSBJU1IK YW5kIHRoZW4gcGxhY2UgdGhlIGhvc3QgaW4gcmVzZXQuCgpUaGlzIHdpbGwgaGFwcGVuIGNvcnJl Y3RseSBpZiB5b3UgdXNlIHBsYXRmb3JtX3VucmVnaXN0ZXJfZGV2aWNlKCkgdG8gdW5yZWdpc3Rl ciB0aGUKWEhDSSBkZXZpY2UgaW4gY2RuczNfaG9zdF9zdG9wKCkuCgo+IAo+Pj4gK30KPj4+ICsK Pj4+ICtzdGF0aWMgdm9pZCBjZG5zM19ob3N0X3JlbGVhc2Uoc3RydWN0IGRldmljZSAqZGV2KQo+ Pj4gK3sKPj4+ICsJc3RydWN0IGNkbnMzX2hvc3QgKmhvc3QgPSBjb250YWluZXJfb2YoZGV2LCBz dHJ1Y3QgY2RuczNfaG9zdCwgZGV2KTsKPj4+ICsKPj4+ICsJa2ZyZWUoaG9zdCk7Cj4+PiArfQo+ Pj4gKwo+Pj4gK3N0YXRpYyBpbnQgY2RuczNfaG9zdF9zdGFydChzdHJ1Y3QgY2RuczMgKmNkbnMp Cj4+PiArewo+Pj4gKwlzdHJ1Y3QgY2RuczNfaG9zdCAqaG9zdDsKPj4+ICsJc3RydWN0IGRldmlj ZSAqZGV2Owo+Pj4gKwlzdHJ1Y3QgZGV2aWNlICpzeXNkZXY7Cj4+PiArCXN0cnVjdCB4aGNpX2hj ZAkqeGhjaTsKPj4+ICsJaW50IHJldDsKPj4+ICsKPj4+ICsJaG9zdCA9IGt6YWxsb2Moc2l6ZW9m KCpob3N0KSwgR0ZQX0tFUk5FTCk7Cj4+PiArCWlmICghaG9zdCkKPj4+ICsJCXJldHVybiAtRU5P TUVNOwo+Pj4gKwo+Pj4gKwlkZXYgPSAmaG9zdC0+ZGV2Owo+Pj4gKwlkZXYtPnJlbGVhc2UgPSBj ZG5zM19ob3N0X3JlbGVhc2U7Cj4+PiArCWRldi0+cGFyZW50ID0gY2Rucy0+ZGV2Owo+Pj4gKwlk ZXZfc2V0X25hbWUoZGV2LCAieGhjaS1jZG5zMyIpOwo+Pj4gKwljZG5zLT5ob3N0X2RldiA9IGRl djsKPj4+ICsJcmV0ID0gZGV2aWNlX3JlZ2lzdGVyKGRldik7Cj4+PiArCWlmIChyZXQpCj4+PiAr CQlnb3RvIGVycjE7Cj4+PiArCj4+PiArCXN5c2RldiA9IGNkbnMtPmRldjsKPj4+ICsJLyogVHJ5 IHRvIHNldCA2NC1iaXQgRE1BIGZpcnN0ICovCj4+PiArCWlmIChXQVJOX09OKCFzeXNkZXYtPmRt YV9tYXNrKSkKPj4+ICsJCS8qIFBsYXRmb3JtIGRpZCBub3QgaW5pdGlhbGl6ZSBkbWFfbWFzayAq Lwo+Pj4gKwkJcmV0ID0gZG1hX2NvZXJjZV9tYXNrX2FuZF9jb2hlcmVudChzeXNkZXYsCj4+PiAr CQkJCQkJICAgRE1BX0JJVF9NQVNLKDY0KSk7Cj4+PiArCWVsc2UKPj4+ICsJCXJldCA9IGRtYV9z ZXRfbWFza19hbmRfY29oZXJlbnQoc3lzZGV2LCBETUFfQklUX01BU0soNjQpKTsKPj4+ICsKPj4+ ICsJLyogSWYgc2V0dGluZyA2NC1iaXQgRE1BIG1hc2sgZmFpbHMsIGZhbGwgYmFjayB0byAzMi1i aXQgRE1BIG1hc2sgKi8KPj4+ICsJaWYgKHJldCkgewo+Pj4gKwkJcmV0ID0gZG1hX3NldF9tYXNr X2FuZF9jb2hlcmVudChzeXNkZXYsIERNQV9CSVRfTUFTSygzMikpOwo+Pj4gKwkJaWYgKHJldCkK Pj4+ICsJCQlyZXR1cm4gcmV0Owo+Pj4gKwl9Cj4+PiArCj4+PiArCXBtX3J1bnRpbWVfc2V0X2Fj dGl2ZShkZXYpOwo+Pj4gKwlwbV9ydW50aW1lX25vX2NhbGxiYWNrcyhkZXYpOwo+Pj4gKwlwbV9y dW50aW1lX2VuYWJsZShkZXYpOwo+Pj4gKwlob3N0LT5oY2QgPSBfX3VzYl9jcmVhdGVfaGNkKCZ4 aGNpX2NkbnMzX2hjX2RyaXZlciwgc3lzZGV2LCBkZXYsCj4+PiArCQkJCSAgICAgZGV2X25hbWUo ZGV2KSwgTlVMTCk7Cj4+PiArCWlmICghaG9zdC0+aGNkKSB7Cj4+PiArCQlyZXQgPSAtRU5PTUVN Owo+Pj4gKwkJZ290byBlcnIyOwo+Pj4gKwl9Cj4+PiArCj4+PiArCWhvc3QtPmhjZC0+cmVncyA9 IGNkbnMtPnhoY2lfcmVnczsKPj4+ICsJaG9zdC0+aGNkLT5yc3JjX3N0YXJ0ID0gY2Rucy0+eGhj aV9yZXMtPnN0YXJ0Owo+Pj4gKwlob3N0LT5oY2QtPnJzcmNfbGVuID0gcmVzb3VyY2Vfc2l6ZShj ZG5zLT54aGNpX3Jlcyk7Cj4+PiArCj4+PiArCWRldmljZV93YWtldXBfZW5hYmxlKGhvc3QtPmhj ZC0+c2VsZi5jb250cm9sbGVyKTsKPj4+ICsJeGhjaSA9IGhjZF90b194aGNpKGhvc3QtPmhjZCk7 Cj4+PiArCj4+PiArCXhoY2ktPm1haW5faGNkID0gaG9zdC0+aGNkOwo+Pj4gKwl4aGNpLT5zaGFy ZWRfaGNkID0gX191c2JfY3JlYXRlX2hjZCgmeGhjaV9jZG5zM19oY19kcml2ZXIsIHN5c2Rldiwg ZGV2LAo+Pj4gKwkJCQkJICAgIGRldl9uYW1lKGRldiksIGhvc3QtPmhjZCk7Cj4+PiArCWlmICgh eGhjaS0+c2hhcmVkX2hjZCkgewo+Pj4gKwkJcmV0ID0gLUVOT01FTTsKPj4+ICsJCWdvdG8gZXJy MzsKPj4+ICsJfQo+Pj4gKwo+Pj4gKwlob3N0LT5oY2QtPnRwbF9zdXBwb3J0ID0gb2ZfdXNiX2hv c3RfdHBsX3N1cHBvcnQoc3lzZGV2LT5vZl9ub2RlKTsKPj4+ICsJeGhjaS0+c2hhcmVkX2hjZC0+ dHBsX3N1cHBvcnQgPSBob3N0LT5oY2QtPnRwbF9zdXBwb3J0Owo+Pj4gKwlyZXQgPSB1c2JfYWRk X2hjZChob3N0LT5oY2QsIDAsIElSUUZfU0hBUkVEKTsKPj4+ICsJaWYgKHJldCkKPj4+ICsJCWdv dG8gZXJyNDsKPj4+ICsKPj4+ICsJcmV0ID0gdXNiX2FkZF9oY2QoeGhjaS0+c2hhcmVkX2hjZCwg MCwgSVJRRl9TSEFSRUQpOwo+Pj4gKwlpZiAocmV0KQo+Pj4gKwkJZ290byBlcnI1Owo+Pj4gKwo+ Pj4gKwlkZXZpY2Vfc2V0X3dha2V1cF9jYXBhYmxlKGRldiwgdHJ1ZSk7Cj4+Cj4+IEFsbCB0aGlz IGlzIGJlaW5nIGRvbmUgYnkgdGhlIHhoY2ktcGxhdC5jCj4+Cj4+IFlvdSBjYW4gbWFrZSB1c2Ug b2YgaXQgYnkganVzdCBjcmVhdGluZyBhIHhoY2ktaGNkIHBsYXRmb3JtIGRldmljZS4KPj4KPj4g ZS5nLgo+PiBwbGF0Zm9ybV9kZXZpY2VfYWxsb2MoInhoY2ktaGNkIiwgUExBVEZPUk1fREVWSURf QVVUTyk7Cj4+IHBsYXRmb3JtX2RldmljZV9hZGRfcmVzb3VyY2VzKCkgdG8gYWRkIElSUSBhbmQg bWVtb3J5IHJlc291cmNlLgo+PiBwbGF0Zm9ybV9kZXZpY2VfYWRkX3Byb3BlcnRpZXMoKSB0byBh ZGQgYW55IHF1aXJrcy4KPj4gcGxhdGZvcm1fZGV2aWNlX2FkZCgpCj4+Cj4gCj4gSWYgd2UgZG8g dGhpcyBpbiB0aGlzIHdheSBkcml2ZXIgd2lsbCBub3QgY29udHJvbCB0aGUgaW50ZXJydXB0LiAK CldoeSBzaG91bGQgdGhpcyBkcml2ZXIgY29udHJvbCBob3N0IGludGVycnVwdCB3aGVuIGl0IGRv ZXNuJ3QKaGF2ZSBhY2Nlc3MgdG8gSE9TVCByZWdpc3RlcnMuCgo+IFRoaXMgY29kZSAgaGFzIHdy aXR0ZW4gYnkgUGV0ZXIgQ2hhbiBhbmQgSSBhbSBjb252aW5jZWQgCj4gdGhhdCB0aGlzIGNvbmNl cHQgaXMgb25seSBjb3JyZWN0IG9uZS4KPiAKPj4+ICsKPj4+ICsJcmV0dXJuIDA7Cj4+PiArCj4+ PiArZXJyNToKPj4+ICsJdXNiX3JlbW92ZV9oY2QoaG9zdC0+aGNkKTsKPj4+ICtlcnI0Ogo+Pj4g Kwl1c2JfcHV0X2hjZCh4aGNpLT5zaGFyZWRfaGNkKTsKPj4+ICtlcnIzOgo+Pj4gKwl1c2JfcHV0 X2hjZChob3N0LT5oY2QpOwo+Pj4gK2VycjI6Cj4+PiArCWRldmljZV9kZWwoZGV2KTsKPj4+ICtl cnIxOgo+Pj4gKwlwdXRfZGV2aWNlKGRldik7Cj4+PiArCWNkbnMtPmhvc3RfZGV2ID0gTlVMTDsK Pj4+ICsJcmV0dXJuIHJldDsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIHZvaWQgY2RuczNfaG9z dF9zdG9wKHN0cnVjdCBjZG5zMyAqY2RucykKPj4+ICt7Cj4+PiArCXN0cnVjdCBkZXZpY2UgKmRl diA9IGNkbnMtPmhvc3RfZGV2Owo+Pj4gKwlzdHJ1Y3QgeGhjaV9oY2QJKnhoY2k7Cj4+PiArCXN0 cnVjdCB1c2JfaGNkCSpoY2Q7Cj4+PiArCj4+PiArCWlmIChkZXYpIHsKPj4+ICsJCWhjZCA9IGRl dl9nZXRfZHJ2ZGF0YShkZXYpOwo+Pj4gKwkJeGhjaSA9IGhjZF90b194aGNpKGhjZCk7Cj4+PiAr CQl1c2JfcmVtb3ZlX2hjZCh4aGNpLT5zaGFyZWRfaGNkKTsKPj4+ICsJCXVzYl9yZW1vdmVfaGNk KGhjZCk7Cj4+PiArCQlzeW5jaHJvbml6ZV9pcnEoY2Rucy0+aXJxKTsKPj4+ICsJCXVzYl9wdXRf aGNkKHhoY2ktPnNoYXJlZF9oY2QpOwo+Pj4gKwkJdXNiX3B1dF9oY2QoaGNkKTsKPj4+ICsJCWNk bnMtPmhvc3RfZGV2ID0gTlVMTDsKPj4+ICsJCXBtX3J1bnRpbWVfc2V0X3N1c3BlbmRlZChkZXYp Owo+Pj4gKwkJcG1fcnVudGltZV9kaXNhYmxlKGRldik7Cj4+PiArCQlkZXZpY2VfZGVsKGRldik7 Cj4+PiArCQlwdXRfZGV2aWNlKGRldik7Cj4+PiArCX0KPj4KPj4gWW91IGNhbiByZXBsYWNlIHRo aXMgd2l0aCBqdXN0Cj4+IAlwbGF0Zm9ybV9kZXZpY2VfdW5yZWdpc3Rlcih4aGNpX2Rldik7Cj4+ Cj4+PiArfQo+Pj4gKwo+Pj4gKyNpZiBDT05GSUdfUE0KPj4+ICtzdGF0aWMgaW50IGNkbnMzX2hv c3Rfc3VzcGVuZChzdHJ1Y3QgY2RuczMgKmNkbnMsIGJvb2wgZG9fd2FrZXVwKQo+Pj4gK3sKPj4+ ICsJc3RydWN0IGRldmljZSAqZGV2ID0gY2Rucy0+aG9zdF9kZXY7Cj4+PiArCXN0cnVjdCB4aGNp X2hjZAkqeGhjaTsKPj4+ICsKPj4+ICsJaWYgKCFkZXYpCj4+PiArCQlyZXR1cm4gMDsKPj4+ICsK Pj4+ICsJeGhjaSA9IGhjZF90b194aGNpKGRldl9nZXRfZHJ2ZGF0YShkZXYpKTsKPj4+ICsJcmV0 dXJuIHhoY2lfc3VzcGVuZCh4aGNpLCBkb193YWtldXApOwo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0 aWMgaW50IGNkbnMzX2hvc3RfcmVzdW1lKHN0cnVjdCBjZG5zMyAqY2RucywgYm9vbCBoaWJlcm5h dGVkKQo+Pj4gK3sKPj4+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gY2Rucy0+aG9zdF9kZXY7Cj4+ PiArCXN0cnVjdCB4aGNpX2hjZAkqeGhjaTsKPj4+ICsKPj4+ICsJaWYgKCFkZXYpCj4+PiArCQly ZXR1cm4gMDsKPj4+ICsKPj4+ICsJeGhjaSA9IGhjZF90b194aGNpKGRldl9nZXRfZHJ2ZGF0YShk ZXYpKTsKPj4+ICsJcmV0dXJuIHhoY2lfcmVzdW1lKHhoY2ksIGhpYmVybmF0ZWQpOwo+Pj4gK30K Pj4KPj4gVGhlc2Ugd29uJ3QgYmUgcmVxdWlyZWQgYW55IG1vcmUgYXMgeGhjaS1wbGF0IGlzIGRv aW5nIHRoaXMuCj4+Cj4+PiArI2VuZGlmIC8qIENPTkZJR19QTSAqLwo+Pj4gKwo+Pj4gK2ludCBj ZG5zM19ob3N0X2luaXQoc3RydWN0IGNkbnMzICpjZG5zKQo+Pj4gK3sKPj4+ICsJc3RydWN0IGNk bnMzX3JvbGVfZHJpdmVyICpyZHJ2Owo+Pj4gKwo+Pj4gKwlyZHJ2ID0gZGV2bV9remFsbG9jKGNk bnMtPmRldiwgc2l6ZW9mKCpyZHJ2KSwgR0ZQX0tFUk5FTCk7Cj4+PiArCWlmICghcmRydikKPj4+ ICsJCXJldHVybiAtRU5PTUVNOwo+Pj4gKwo+Pj4gKwlyZHJ2LT5zdGFydAk9IGNkbnMzX2hvc3Rf c3RhcnQ7Cj4+PiArCXJkcnYtPnN0b3AJPSBjZG5zM19ob3N0X3N0b3A7Cj4+PiArCXJkcnYtPmly cQk9IGNkbnMzX2hvc3RfaXJxOwo+Pj4gKyNpZiBDT05GSUdfUE0KPj4+ICsJcmRydi0+c3VzcGVu ZAk9IGNkbnMzX2hvc3Rfc3VzcGVuZDsKPj4+ICsJcmRydi0+cmVzdW1lCT0gY2RuczNfaG9zdF9y ZXN1bWU7Cj4+PiArI2VuZGlmIC8qIENPTkZJR19QTSAqLwo+Pj4gKwlyZHJ2LT5uYW1lCT0gImhv c3QiOwo+Pj4gKwljZG5zLT5yb2xlc1tDRE5TM19ST0xFX0hPU1RdID0gcmRydjsKPj4+ICsKPj4+ ICsJcmV0dXJuIDA7Cj4+PiArfQo+Pj4gKwo+Pj4gK3ZvaWQgY2RuczNfaG9zdF9yZW1vdmUoc3Ry dWN0IGNkbnMzICpjZG5zKQo+Pj4gK3sKPj4+ICsJY2RuczNfaG9zdF9zdG9wKGNkbnMpOwo+Pgo+ PiBjYWxsaW5nIGNkbnMzX2hvc3Rfc3RvcCgpIGhlcmUgY2FuIGxlYWQgdG8gcHJvYmxlbXMgYXMg Q29udHJvbGxlciBtaWdodCBiZSBpbgo+PiBwZXJpcGhlcmFsIG1vZGUgYXQgdGhpcyBwb2ludC4g VGhlIGNvcmUgZHJpdmVyIG5lZWRzIHRvIGVuc3VyZSB0aGF0IHJlbGV2YW50IHJvbGUKPj4gaXMg c3RvcHBlZCBiZWZvcmUgY2FsbGluZyBjZG5zM19ob3N0X3JlbW92ZSgpLgo+Pgo+PiBIZXJlIHlv dSBuZWVkIHRvIHVucmVnaXN0ZXIgdGhlIHJvbGUgZHJpdmVyIHRob3VnaC4KPj4KPj4gY2Rucy0+ cm9sZXNbQ0ROUzNfUk9MRV9IT1NUXSA9IE5VTEw7Cj4+Cj4gVGhpcyBmdW5jdGlvbiBjYW4gYmUg Y2FsbGVkIG9ubHkgaW4gaG9zdCBtb2RlL3JvbGUuIEl0IG9wZXJhdGUgb24gaG9zdCByZWdpc3Rl cnMuIAo+IFRoaXMgY2hlY2tpbmcgaXMgcHJvdmlkZWQgaW4gY29yZS5jIGZpbGUuIAo+Pj4gK30K Pj4+ICsKPj4+ICt2b2lkIF9faW5pdCBjZG5zM19ob3N0X2RyaXZlcl9pbml0KHZvaWQpCj4+PiAr ewo+Pj4gKwl4aGNpX2luaXRfZHJpdmVyKCZ4aGNpX2NkbnMzX2hjX2RyaXZlciwgJnhoY2lfY2Ru czNfb3ZlcnJpZGVzKTsKPj4+ICt9Cj4+Pgo+PgoKY2hlZXJzLAotcm9nZXIK 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: Mon, 26 Nov 2018 11:50:57 +0200 Message-ID: <5BFBC201.4000000@ti.com> References: <1542535751-16079-1-git-send-email-pawell@cadence.com> <1542535751-16079-7-git-send-email-pawell@cadence.com> <5BF80D44.2050600@ti.com> Mime-Version: 1.0 Content-Type: text/plain; charset="windows-1252" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: 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" , Alan Douglas , "jbergsagel@ti.com" , "nsekhar@ti.com" , "nm@ti.com" , Suresh Punnoose , "peter.chen@nxp.com" , Pawel Jez , Rahul Kumar List-Id: devicetree@vger.kernel.org Hi, On 26/11/18 10:24, Pawel Laszczak wrote: >> EXTERNAL MAIL >> >> >> 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. > > ok, but I assume that even if host returns error then we can use > only device role. Only when both functions return errors, then it's a critical error > and function return error code. But at this point we are in OTG or HOST dr_mode and without host functional both will not function correctly. So we must error out so user can debug. >> >>> } >>> >>> 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. > > In device role the host part of controller is kept in reset, so driver can't read the host register. > Such solution allows driver to control access to host register. > So if driver has shared separate interrupt for host role then it has to check if controller work in > Host role. I understand what you mean. I think the issue here is that you are having the host ISR active even when host role is stopped. This is the root cause of the problem. When you stop host role, the host driver *must* unregister the ISR and then place the host in reset. This will happen correctly if you use platform_unregister_device() to unregister the XHCI device in cdns3_host_stop(). > >>> +} >>> + >>> +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() >> > > If we do this in this way driver will not control the interrupt. Why should this driver control host interrupt when it doesn't have access to HOST registers. > This code has written by Peter Chan and I am convinced > that this concept is only correct one. > >>> + >>> + 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; >> > This function can be called only in host mode/role. It operate on host registers. > This checking is provided in core.c file. >>> +} >>> + >>> +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