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: [v5,12/12] extcon: axp288: Set USB role where necessary From: Chanwoo Choi Message-Id: <5A989D2B.8090903@samsung.com> Date: Fri, 02 Mar 2018 09:39:07 +0900 To: Hans de Goede , Darren Hart , Andy Shevchenko , MyungJoo Ham , Mathias Nyman , Heikki Krogerus , Greg Kroah-Hartman , Guenter Roeck Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-ID: SGksCgpCYXNpY2FsbHksIEkgaGF2ZSBubyBvYmplY3Rpb24uIEJ1dCBJJ2xsIHJlcGx5IHRoZSBt eSBhY2sgdGFnIAphZnRlciBmaW5pc2hpbmcgdGhlIHJldmlldyBvZiAnZGV2Y29uIGFuZCB1c2Jf cm9sZV9zd2l0Y2gnIGZyb20gVVNCIG1haW50YWluZXIuCgpBbmQgSSBoYXZlIGEgcXVlc3Rpb24u CkJlZm9yZSB0aGlzIHBhdGNoLCBleHRjb24tYXhwMjg4IGlzIHVzZWQgdG8gZGV0ZWN0IGNoYXJn ZXIgY29ubmVjdG9yCmFuZCBleHRjb24taW50ZWwtaW50MzQ5NiBpcyB1c2VkIHRvIGRldGVjdCB0 aGUgVVNCX0hPU1QgY29ubmVjdG9yCm9uIG9uZSBoL3cgZGV2aWNlPwoKQmVzdCBSZWdhcmRzLApD aGFud29vIENob2kKU2Ftc3VuZyBFbGVjdHJvbmljcwoKT24gMjAxOOuFhCAwM+yblCAwMeydvCAw MDowNywgSGFucyBkZSBHb2VkZSB3cm90ZToKPiBUaGUgQVhQMjg4IEJDMS4yIGNoYXJnZXIgZGV0 ZWN0aW9uIC8gZXh0Y29uIGNvZGUgbWF5IHNlZW0gbGlrZSBhIHN0cmFuZ2UKPiBwbGFjZSB0byBh ZGQgY29kZSB0byBjb250cm9sIHRoZSBVU0Igcm9sZS1zd2l0Y2ggb24gZGV2aWNlcyB3aXRoIGFu IEFYUDI4OCwKPiBidXQgdGhlcmUgYXJlIDIgcmVhc29ucyB0byBkbyB0aGlzIGluc2lkZSB0aGUg YXhwMjg4IGV4dGNvbiBjb2RlOgo+IAo+IDEpIE9uIG1hbnkgZGV2aWNlcyB0aGUgVVNCIHJvbGUg aXMgY29udHJvbGxlZCBieSBBQ1BJIEFNTCBjb2RlLCBidXQgdGhlIEFNTAo+ICAgIGNvZGUgb25s eSBzd2l0Y2hlcyBiZXR3ZWVuIHRoZSBob3N0IGFuZCBub25lIHJvbGVzLCBiZWNhdXNlIG9mIFdp bmRvd3MKPiAgICBub3QgcmVhbGx5IHVzaW5nIGRldmljZSBtb2RlLiBUbyBtYWtlIGRldmljZSBt b2RlIHdvcmsgd2UgbmVlZCB0byB0b2dnbGUKPiAgICBiZXR3ZWVuIHRoZSBub25lL2RldmljZSBy b2xlcyBiYXNlZCBvbiBWYnVzIHByZXNlbmNlLCBhbmQgdGhlIGF4cDI4OAo+ICAgIGV4dGNvbiBn ZXRzIGludGVycnVwdHMgb24gVmJ1cyBpbnNlcnRpb24gLyByZW1vdmFsLgo+IAo+IDIpIEluIG9y ZGVyIGZvciBvdXIgQkMxLjIgY2hhcmdlciBkZXRlY3Rpb24gdG8gd29yayBwcm9wZXJseSB0aGUg cm9sZQo+ICAgIG11eCBtdXN0IGJlIHByb3Blcmx5IHNldCB0byBkZXZpY2UgbW9kZSBiZWZvcmUg d2UgZG8gdGhlIGRldGVjdGlvbi4KPiAKPiBBbHNvIG5vdGUgdGhlIEtjb25maWcgaGVscC10ZXh0 IC8gb2Jzb2xldGUgZGVwZW5kcyBvbiBVU0JfUEhZIHdoaWNoIGFyZQo+IHJlbW5hbnRzIGZyb20g b2xkZXIgbmV2ZXIgdXBzdHJlYW1lZCBjb2RlIGFsc28gY29udHJvbGxpbmcgdGhlIG11eCBmcm9t Cj4gdGhlIGF4cDI4OCBleHRjb24gY29kZS4KPiAKPiBUaGlzIGNvbW1pdCBhbHNvIGFkZHMgY29k ZSB0byBnZXQgbm90aWZpY2F0aW9ucyBmcm9tIHRoZSBJTlQzNDk2IGV4dGNvbgo+IGRldmljZSwg d2hpY2ggaXMgdXNlZCBvbiBzb21lIGRldmljZXMgdG8gbm90aWZ5IHRoZSBrZXJuZWwgYWJvdXQg aWQtcGluCj4gY2hhbmdlcyBpbnN0ZWFkIG9mIHRoZW0gYmVpbmcgaGFuZGxlZCB0aHJvdWdoIEFN TCBjb2RlLgo+IAo+IFRoaXMgZml4ZXM6Cj4gLURldmljZSBtb2RlIG5vdCB3b3JraW5nIG9uIG1v c3QgQ0hUIGRldmljZXMgd2l0aCBhbiBBWFAyODgKPiAtSG9zdCBtb2RlIG5vdCB3b3JraW5nIG9u IGRldmljZXMgd2l0aCBhbiBJTlQzNDk2IEFDUEkgZGV2aWNlCj4gLUNoYXJnZXItdHlwZSBtaXNk ZXRlY3Rpb24gKGFsd2F5cyBTRFApIG9uIGRldmljZXMgd2l0aCBhbiBJTlQzNDk2IHdoZW4gdGhl Cj4gIFVTQiByb2xlIChhbHdheXMpIGdldHMgaW5pdGlhbGl6ZWQgYXMgaG9zdAo+IAo+IFJldmll d2VkLWJ5OiBIZWlra2kgS3JvZ2VydXMgPGhlaWtraS5rcm9nZXJ1c0BsaW51eC5pbnRlbC5jb20+ Cj4gUmV2aWV3ZWQtYnk6IEFuZHkgU2hldmNoZW5rbyA8YW5keS5zaGV2Y2hlbmtvQGdtYWlsLmNv bT4KPiBTaWduZWQtb2ZmLWJ5OiBIYW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgo+ IC0tLQo+IENoYW5nZXMgaW4gdjQ6Cj4gLUFkZCBBbmR5J3MgUmV2aWV3ZWQtYnkKPiAKPiBDaGFu Z2VzIGluIHYyOgo+IC1BZGQgZGVwZW5kcyBvbiBYODYgdG8gS2NvbmZpZyAodGhlIEFYUDI4OCBQ TUlDIGlzIG9ubHkgdXNlZCBvbiBYODYpCj4gLVVzZSBuZXcgYWNwaV9kZXZfZ2V0X2ZpcnN0X21h dGNoX25hbWUoKSBoZWxwZXIgdG8gZ2V0IHRoZSBJTlQzNDk2IGRldmljZS1uYW1lCj4gLUFkZCBI ZWlra2kncyBSZXZpZXdlZC1ieQo+IC0tLQo+ICBkcml2ZXJzL2V4dGNvbi9LY29uZmlnICAgICAg ICAgfCAgIDMgKy0KPiAgZHJpdmVycy9leHRjb24vZXh0Y29uLWF4cDI4OC5jIHwgMTc3ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCj4gIDIgZmlsZXMgY2hhbmdlZCwg MTcxIGluc2VydGlvbnMoKyksIDkgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZXh0Y29uL0tjb25maWcgYi9kcml2ZXJzL2V4dGNvbi9LY29uZmlnCj4gaW5kZXggYTdiY2E0 MjA3ZjQ0Li5kZTE1YmY1NTg5NWIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9leHRjb24vS2NvbmZp Zwo+ICsrKyBiL2RyaXZlcnMvZXh0Y29uL0tjb25maWcKPiBAQCAtMzAsNyArMzAsOCBAQCBjb25m aWcgRVhUQ09OX0FSSVpPTkEKPiAgCj4gIGNvbmZpZyBFWFRDT05fQVhQMjg4Cj4gIAl0cmlzdGF0 ZSAiWC1Qb3dlciBBWFAyODggRVhUQ09OIHN1cHBvcnQiCj4gLQlkZXBlbmRzIG9uIE1GRF9BWFAy MFggJiYgVVNCX1BIWQo+ICsJZGVwZW5kcyBvbiBNRkRfQVhQMjBYICYmIFVTQl9TVVBQT1JUICYm IFg4Ngo+ICsJc2VsZWN0IFVTQl9ST0xFX1NXSVRDSAo+ICAJaGVscAo+ICAJICBTYXkgWSBoZXJl IHRvIGVuYWJsZSBzdXBwb3J0IGZvciBVU0IgcGVyaXBoZXJhbCBkZXRlY3Rpb24KPiAgCSAgYW5k IFVTQiBNVVggc3dpdGNoaW5nIGJ5IFgtUG93ZXIgQVhQMjg4IFBNSUMuCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZXh0Y29uL2V4dGNvbi1heHAyODguYyBiL2RyaXZlcnMvZXh0Y29uL2V4dGNvbi1h eHAyODguYwo+IGluZGV4IDNlYzRjNzE1ZTI0MC4uNTFlNzdjN2EzMmMyIDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvZXh0Y29uL2V4dGNvbi1heHAyODguYwo+ICsrKyBiL2RyaXZlcnMvZXh0Y29uL2V4 dGNvbi1heHAyODguYwo+IEBAIC0xLDYgKzEsNyBAQAo+ICAvKgo+ICAgKiBleHRjb24tYXhwMjg4 LmMgLSBYLVBvd2VyIEFYUDI4OCBQTUlDIGV4dGNvbiBjYWJsZSBkZXRlY3Rpb24gZHJpdmVyCj4g ICAqCj4gKyAqIENvcHlyaWdodCAoYykgMjAxNy0yMDE4IEhhbnMgZGUgR29lZGUgPGhkZWdvZWRl QHJlZGhhdC5jb20+Cj4gICAqIENvcHlyaWdodCAoQykgMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbgo+ ICAgKiBBdXRob3I6IFJhbWFrcmlzaG5hIFBhbGxhbGEgPHJhbWFrcmlzaG5hLnBhbGxhbGFAaW50 ZWwuY29tPgo+ICAgKgo+IEBAIC0xNCw2ICsxNSw4IEBACj4gICAqIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gICAqLwo+ICAKPiArI2luY2x1ZGUgPGxpbnV4 L2FjcGkuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2Nvbm5lY3Rpb24uaD4KPiAgI2luY2x1ZGUgPGxp bnV4L21vZHVsZS5oPgo+ICAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+Cj4gICNpbmNsdWRlIDxs aW51eC9pby5oPgo+IEBAIC0yNSw2ICsyOCwxMSBAQAo+ICAjaW5jbHVkZSA8bGludXgvZXh0Y29u LXByb3ZpZGVyLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiAgI2luY2x1ZGUgPGxp bnV4L21mZC9heHAyMHguaD4KPiArI2luY2x1ZGUgPGxpbnV4L3VzYi9yb2xlLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC93b3JrcXVldWUuaD4KPiArCj4gKyNpbmNsdWRlIDxhc20vY3B1X2RldmljZV9p ZC5oPgo+ICsjaW5jbHVkZSA8YXNtL2ludGVsLWZhbWlseS5oPgo+ICAKPiAgLyogUG93ZXIgc291 cmNlIHN0YXR1cyByZWdpc3RlciAqLwo+ICAjZGVmaW5lIFBTX1NUQVRfVkJVU19UUklHR0VSCQlC SVQoMCkKPiBAQCAtOTcsOSArMTA1LDE5IEBAIHN0cnVjdCBheHAyODhfZXh0Y29uX2luZm8gewo+ ICAJc3RydWN0IGRldmljZSAqZGV2Owo+ICAJc3RydWN0IHJlZ21hcCAqcmVnbWFwOwo+ICAJc3Ry dWN0IHJlZ21hcF9pcnFfY2hpcF9kYXRhICpyZWdtYXBfaXJxYzsKPiArCXN0cnVjdCB1c2Jfcm9s ZV9zd2l0Y2ggKnJvbGVfc3c7Cj4gKwlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgcm9sZV93b3JrOwo+ICAJ aW50IGlycVtFWFRDT05fSVJRX0VORF07Cj4gIAlzdHJ1Y3QgZXh0Y29uX2RldiAqZWRldjsKPiAr CXN0cnVjdCBleHRjb25fZGV2ICppZF9leHRjb247Cj4gKwlzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sg aWRfbmI7Cj4gIAl1bnNpZ25lZCBpbnQgcHJldmlvdXNfY2FibGU7Cj4gKwlib29sIHZidXNfYXR0 YWNoOwo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCB4ODZfY3B1X2lkIGNoZXJyeV90 cmFpbF9jcHVfaWRzW10gPSB7Cj4gKwl7IFg4Nl9WRU5ET1JfSU5URUwsIDYsIElOVEVMX0ZBTTZf QVRPTV9BSVJNT05ULCBYODZfRkVBVFVSRV9BTlkgfSwKPiArCXt9Cj4gIH07Cj4gIAo+ICAvKiBQ b3dlciB1cC9kb3duIHJlYXNvbiBzdHJpbmcgYXJyYXkgKi8KPiBAQCAtMTM3LDIwICsxNTUsNzQg QEAgc3RhdGljIHZvaWQgYXhwMjg4X2V4dGNvbl9sb2dfcnNpKHN0cnVjdCBheHAyODhfZXh0Y29u X2luZm8gKmluZm8pCj4gIAlyZWdtYXBfd3JpdGUoaW5mby0+cmVnbWFwLCBBWFAyODhfUFNfQk9P VF9SRUFTT05fUkVHLCBjbGVhcl9tYXNrKTsKPiAgfQo+ICAKPiAtc3RhdGljIGludCBheHAyODhf aGFuZGxlX2NocmdfZGV0X2V2ZW50KHN0cnVjdCBheHAyODhfZXh0Y29uX2luZm8gKmluZm8pCj4g Ky8qCj4gKyAqIFRoZSBiZWxvdyBjb2RlIHRvIGNvbnRyb2wgdGhlIFVTQiByb2xlLXN3aXRjaCBv biBkZXZpY2VzIHdpdGggYW4gQVhQMjg4Cj4gKyAqIG1heSBzZWVtIG91dCBvZiBwbGFjZSwgYnV0 IHRoZXJlIGFyZSAyIHJlYXNvbnMgd2h5IHRoaXMgaXMgdGhlIGJlc3QgcGxhY2UKPiArICogdG8g Y29udHJvbCB0aGUgVVNCIHJvbGUtc3dpdGNoIG9uIHN1Y2ggZGV2aWNlczoKPiArICogMSkgT24g bWFueSBkZXZpY2VzIHRoZSBVU0Igcm9sZSBpcyBjb250cm9sbGVkIGJ5IEFNTCBjb2RlLCBidXQg dGhlIEFNTCBjb2RlCj4gKyAqICAgIG9ubHkgc3dpdGNoZXMgYmV0d2VlbiB0aGUgaG9zdCBhbmQg bm9uZSByb2xlcywgYmVjYXVzZSBvZiBXaW5kb3dzIG5vdAo+ICsgKiAgICByZWFsbHkgdXNpbmcg ZGV2aWNlIG1vZGUuIFRvIG1ha2UgZGV2aWNlIG1vZGUgd29yayB3ZSBuZWVkIHRvIHRvZ2dsZQo+ ICsgKiAgICBiZXR3ZWVuIHRoZSBub25lL2RldmljZSByb2xlcyBiYXNlZCBvbiBWYnVzIHByZXNl bmNlLCBhbmQgdGhpcyBkcml2ZXIKPiArICogICAgZ2V0cyBpbnRlcnJ1cHRzIG9uIFZidXMgaW5z ZXJ0aW9uIC8gcmVtb3ZhbC4KPiArICogMikgSW4gb3JkZXIgZm9yIG91ciBCQzEuMiBjaGFyZ2Vy IGRldGVjdGlvbiB0byB3b3JrIHByb3Blcmx5IHRoZSByb2xlCj4gKyAqICAgIG11eCBtdXN0IGJl IHByb3Blcmx5IHNldCB0byBkZXZpY2UgbW9kZSBiZWZvcmUgd2UgZG8gdGhlIGRldGVjdGlvbi4K PiArICovCj4gKwo+ICsvKiBSZXR1cm5zIHRoZSBpZC1waW4gdmFsdWUsIG5vdGUgcHVsbGVkIGxv dyAvIGZhbHNlID09IGhvc3QtbW9kZSAqLwo+ICtzdGF0aWMgYm9vbCBheHAyODhfZ2V0X2lkX3Bp bihzdHJ1Y3QgYXhwMjg4X2V4dGNvbl9pbmZvICppbmZvKQo+ICB7Cj4gLQlpbnQgcmV0LCBzdGF0 LCBjZmcsIHB3cl9zdGF0Owo+IC0JdTggY2hyZ190eXBlOwo+IC0JdW5zaWduZWQgaW50IGNhYmxl ID0gaW5mby0+cHJldmlvdXNfY2FibGU7Cj4gLQlib29sIHZidXNfYXR0YWNoID0gZmFsc2U7Cj4g KwllbnVtIHVzYl9yb2xlIHJvbGU7Cj4gKwo+ICsJaWYgKGluZm8tPmlkX2V4dGNvbikKPiArCQly ZXR1cm4gZXh0Y29uX2dldF9zdGF0ZShpbmZvLT5pZF9leHRjb24sIEVYVENPTl9VU0JfSE9TVCkg PD0gMDsKPiArCj4gKwkvKiBXZSBjYW5ub3QgYWNjZXNzIHRoZSBpZC1waW4sIHNlZSB3aGF0IG1v ZGUgdGhlIEFNTCBjb2RlIGhhcyBzZXQgKi8KPiArCXJvbGUgPSB1c2Jfcm9sZV9zd2l0Y2hfZ2V0 X3JvbGUoaW5mby0+cm9sZV9zdyk7Cj4gKwlyZXR1cm4gcm9sZSAhPSBVU0JfUk9MRV9IT1NUOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBheHAyODhfdXNiX3JvbGVfd29yayhzdHJ1Y3Qgd29ya19z dHJ1Y3QgKndvcmspCj4gK3sKPiArCXN0cnVjdCBheHAyODhfZXh0Y29uX2luZm8gKmluZm8gPQo+ ICsJCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgYXhwMjg4X2V4dGNvbl9pbmZvLCByb2xlX3dv cmspOwo+ICsJZW51bSB1c2Jfcm9sZSByb2xlOwo+ICsJYm9vbCBpZF9waW47Cj4gKwlpbnQgcmV0 Owo+ICsKPiArCWlkX3BpbiA9IGF4cDI4OF9nZXRfaWRfcGluKGluZm8pOwo+ICsJaWYgKCFpZF9w aW4pCj4gKwkJcm9sZSA9IFVTQl9ST0xFX0hPU1Q7Cj4gKwllbHNlIGlmIChpbmZvLT52YnVzX2F0 dGFjaCkKPiArCQlyb2xlID0gVVNCX1JPTEVfREVWSUNFOwo+ICsJZWxzZQo+ICsJCXJvbGUgPSBV U0JfUk9MRV9OT05FOwo+ICsKPiArCXJldCA9IHVzYl9yb2xlX3N3aXRjaF9zZXRfcm9sZShpbmZv LT5yb2xlX3N3LCByb2xlKTsKPiArCWlmIChyZXQpCj4gKwkJZGV2X2VycihpbmZvLT5kZXYsICJm YWlsZWQgdG8gc2V0IHJvbGU6ICVkXG4iLCByZXQpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCBh eHAyODhfZ2V0X3ZidXNfYXR0YWNoKHN0cnVjdCBheHAyODhfZXh0Y29uX2luZm8gKmluZm8pCj4g K3sKPiArCWludCByZXQsIHB3cl9zdGF0Owo+ICAKPiAgCXJldCA9IHJlZ21hcF9yZWFkKGluZm8t PnJlZ21hcCwgQVhQMjg4X1BTX1NUQVRfUkVHLCAmcHdyX3N0YXQpOwo+ICAJaWYgKHJldCA8IDAp IHsKPiAgCQlkZXZfZXJyKGluZm8tPmRldiwgImZhaWxlZCB0byByZWFkIHZidXMgc3RhdHVzXG4i KTsKPiAtCQlyZXR1cm4gcmV0Owo+ICsJCXJldHVybiBmYWxzZTsKPiAgCX0KPiAgCj4gLQl2YnVz X2F0dGFjaCA9IChwd3Jfc3RhdCAmIFBTX1NUQVRfVkJVU19WQUxJRCk7Cj4gKwlyZXR1cm4gISEo cHdyX3N0YXQgJiBQU19TVEFUX1ZCVVNfVkFMSUQpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGF4 cDI4OF9oYW5kbGVfY2hyZ19kZXRfZXZlbnQoc3RydWN0IGF4cDI4OF9leHRjb25faW5mbyAqaW5m bykKPiArewo+ICsJaW50IHJldCwgc3RhdCwgY2ZnOwo+ICsJdTggY2hyZ190eXBlOwo+ICsJdW5z aWduZWQgaW50IGNhYmxlID0gaW5mby0+cHJldmlvdXNfY2FibGU7Cj4gKwlib29sIHZidXNfYXR0 YWNoID0gZmFsc2U7Cj4gKwo+ICsJdmJ1c19hdHRhY2ggPSBheHAyODhfZ2V0X3ZidXNfYXR0YWNo KGluZm8pOwo+ICAJaWYgKCF2YnVzX2F0dGFjaCkKPiAgCQlnb3RvIG5vX3ZidXM7Cj4gIAo+IEBA IC0yMDEsNiArMjczLDEyIEBAIHN0YXRpYyBpbnQgYXhwMjg4X2hhbmRsZV9jaHJnX2RldF9ldmVu dChzdHJ1Y3QgYXhwMjg4X2V4dGNvbl9pbmZvICppbmZvKQo+ICAJCWluZm8tPnByZXZpb3VzX2Nh YmxlID0gY2FibGU7Cj4gIAl9Cj4gIAo+ICsJaWYgKGluZm8tPnJvbGVfc3cgJiYgaW5mby0+dmJ1 c19hdHRhY2ggIT0gdmJ1c19hdHRhY2gpIHsKPiArCQlpbmZvLT52YnVzX2F0dGFjaCA9IHZidXNf YXR0YWNoOwo+ICsJCS8qIFNldHRpbmcgdGhlIHJvbGUgY2FuIHRha2UgYSB3aGlsZSAqLwo+ICsJ CXF1ZXVlX3dvcmsoc3lzdGVtX2xvbmdfd3EsICZpbmZvLT5yb2xlX3dvcmspOwo+ICsJfQo+ICsK PiAgCXJldHVybiAwOwo+ICAKPiAgZGV2X2RldF9yZXQ6Cj4gQEAgLTIxMCw2ICsyODgsMTggQEAg c3RhdGljIGludCBheHAyODhfaGFuZGxlX2NocmdfZGV0X2V2ZW50KHN0cnVjdCBheHAyODhfZXh0 Y29uX2luZm8gKmluZm8pCj4gIAlyZXR1cm4gcmV0Owo+ICB9Cj4gIAo+ICtzdGF0aWMgaW50IGF4 cDI4OF9leHRjb25faWRfZXZ0KHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIsCj4gKwkJCQl1bnNp Z25lZCBsb25nIGV2ZW50LCB2b2lkICpwYXJhbSkKPiArewo+ICsJc3RydWN0IGF4cDI4OF9leHRj b25faW5mbyAqaW5mbyA9Cj4gKwkJY29udGFpbmVyX29mKG5iLCBzdHJ1Y3QgYXhwMjg4X2V4dGNv bl9pbmZvLCBpZF9uYik7Cj4gKwo+ICsJLyogV2UgbWF5IG5vdCBzbGVlcCBhbmQgc2V0dGluZyB0 aGUgcm9sZSBjYW4gdGFrZSBhIHdoaWxlICovCj4gKwlxdWV1ZV93b3JrKHN5c3RlbV9sb25nX3dx LCAmaW5mby0+cm9sZV93b3JrKTsKPiArCj4gKwlyZXR1cm4gTk9USUZZX09LOwo+ICt9Cj4gKwo+ ICBzdGF0aWMgaXJxcmV0dXJuX3QgYXhwMjg4X2V4dGNvbl9pc3IoaW50IGlycSwgdm9pZCAqZGF0 YSkKPiAgewo+ICAJc3RydWN0IGF4cDI4OF9leHRjb25faW5mbyAqaW5mbyA9IGRhdGE7Cj4gQEAg LTIzMSwxMCArMzIxLDIwIEBAIHN0YXRpYyB2b2lkIGF4cDI4OF9leHRjb25fZW5hYmxlKHN0cnVj dCBheHAyODhfZXh0Y29uX2luZm8gKmluZm8pCj4gIAkJCQkJQkNfR0xPQkFMX1JVTiwgQkNfR0xP QkFMX1JVTik7Cj4gIH0KPiAgCj4gK3N0YXRpYyB2b2lkIGF4cDI4OF9wdXRfcm9sZV9zdyh2b2lk ICpkYXRhKQo+ICt7Cj4gKwlzdHJ1Y3QgYXhwMjg4X2V4dGNvbl9pbmZvICppbmZvID0gZGF0YTsK PiArCj4gKwljYW5jZWxfd29ya19zeW5jKCZpbmZvLT5yb2xlX3dvcmspOwo+ICsJdXNiX3JvbGVf c3dpdGNoX3B1dChpbmZvLT5yb2xlX3N3KTsKPiArfQo+ICsKPiAgc3RhdGljIGludCBheHAyODhf ZXh0Y29uX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gIHsKPiAgCXN0cnVj dCBheHAyODhfZXh0Y29uX2luZm8gKmluZm87Cj4gIAlzdHJ1Y3QgYXhwMjB4X2RldiAqYXhwMjB4 ID0gZGV2X2dldF9kcnZkYXRhKHBkZXYtPmRldi5wYXJlbnQpOwo+ICsJc3RydWN0IGRldmljZSAq ZGV2ID0gJnBkZXYtPmRldjsKPiArCWNvbnN0IGNoYXIgKm5hbWU7Cj4gIAlpbnQgcmV0LCBpLCBw aXJxOwo+ICAKPiAgCWluZm8gPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCppbmZv KSwgR0ZQX0tFUk5FTCk7Cj4gQEAgLTI0NSw5ICszNDUsMzMgQEAgc3RhdGljIGludCBheHAyODhf ZXh0Y29uX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gIAlpbmZvLT5yZWdt YXAgPSBheHAyMHgtPnJlZ21hcDsKPiAgCWluZm8tPnJlZ21hcF9pcnFjID0gYXhwMjB4LT5yZWdt YXBfaXJxYzsKPiAgCWluZm8tPnByZXZpb3VzX2NhYmxlID0gRVhUQ09OX05PTkU7Cj4gKwlJTklU X1dPUksoJmluZm8tPnJvbGVfd29yaywgYXhwMjg4X3VzYl9yb2xlX3dvcmspOwo+ICsJaW5mby0+ aWRfbmIubm90aWZpZXJfY2FsbCA9IGF4cDI4OF9leHRjb25faWRfZXZ0Owo+ICAKPiAgCXBsYXRm b3JtX3NldF9kcnZkYXRhKHBkZXYsIGluZm8pOwo+ICAKPiArCWluZm8tPnJvbGVfc3cgPSB1c2Jf cm9sZV9zd2l0Y2hfZ2V0KGRldik7Cj4gKwlpZiAoSVNfRVJSKGluZm8tPnJvbGVfc3cpKQo+ICsJ CXJldHVybiBQVFJfRVJSKGluZm8tPnJvbGVfc3cpOwo+ICsJaWYgKGluZm8tPnJvbGVfc3cpIHsK PiArCQlyZXQgPSBkZXZtX2FkZF9hY3Rpb25fb3JfcmVzZXQoZGV2LCBheHAyODhfcHV0X3JvbGVf c3csIGluZm8pOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7Cj4gKwo+ICsJCW5hbWUg PSBhY3BpX2Rldl9nZXRfZmlyc3RfbWF0Y2hfbmFtZSgiSU5UMzQ5NiIsIE5VTEwsIC0xKTsKPiAr CQlpZiAobmFtZSkgewo+ICsJCQlpbmZvLT5pZF9leHRjb24gPSBleHRjb25fZ2V0X2V4dGNvbl9k ZXYobmFtZSk7Cj4gKwkJCWlmICghaW5mby0+aWRfZXh0Y29uKQo+ICsJCQkJcmV0dXJuIC1FUFJP QkVfREVGRVI7Cj4gKwo+ICsJCQlkZXZfaW5mbyhkZXYsICJjb250cm9sbGluZyBVU0Igcm9sZVxu Iik7Cj4gKwkJfSBlbHNlIHsKPiArCQkJZGV2X2luZm8oZGV2LCAiY29udHJvbGxpbmcgVVNCIHJv bGUgYmFzZWQgb24gVmJ1cyBwcmVzZW5jZVxuIik7Cj4gKwkJfQo+ICsJfQo+ICsKPiArCWluZm8t PnZidXNfYXR0YWNoID0gYXhwMjg4X2dldF92YnVzX2F0dGFjaChpbmZvKTsKPiArCj4gIAlheHAy ODhfZXh0Y29uX2xvZ19yc2koaW5mbyk7Cj4gIAo+ICAJLyogSW5pdGlhbGl6ZSBleHRjb24gZGV2 aWNlICovCj4gQEAgLTI4OSw2ICs0MTMsMTkgQEAgc3RhdGljIGludCBheHAyODhfZXh0Y29uX3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gIAkJfQo+ICAJfQo+ICAKPiArCWlm IChpbmZvLT5pZF9leHRjb24pIHsKPiArCQlyZXQgPSBkZXZtX2V4dGNvbl9yZWdpc3Rlcl9ub3Rp Zmllcl9hbGwoZGV2LCBpbmZvLT5pZF9leHRjb24sCj4gKwkJCQkJCQkmaW5mby0+aWRfbmIpOwo+ ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJLyogTWFrZSBzdXJl IHRoZSByb2xlLXN3IGlzIHNldCBjb3JyZWN0bHkgYmVmb3JlIGRvaW5nIEJDIGRldGVjdGlvbiAq Lwo+ICsJaWYgKGluZm8tPnJvbGVfc3cpIHsKPiArCQlxdWV1ZV93b3JrKHN5c3RlbV9sb25nX3dx LCAmaW5mby0+cm9sZV93b3JrKTsKPiArCQlmbHVzaF93b3JrKCZpbmZvLT5yb2xlX3dvcmspOwo+ ICsJfQo+ICsKPiAgCS8qIFN0YXJ0IGNoYXJnZXIgY2FibGUgdHlwZSBkZXRlY3Rpb24gKi8KPiAg CWF4cDI4OF9leHRjb25fZW5hYmxlKGluZm8pOwo+ICAKPiBAQCAtMzA4LDggKzQ0NSwzMiBAQCBz dGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBheHAyODhfZXh0Y29uX2RyaXZlciA9IHsKPiAg CQkubmFtZSA9ICJheHAyODhfZXh0Y29uIiwKPiAgCX0sCj4gIH07Cj4gLW1vZHVsZV9wbGF0Zm9y bV9kcml2ZXIoYXhwMjg4X2V4dGNvbl9kcml2ZXIpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBkZXZj b24gYXhwMjg4X2V4dGNvbl9yb2xlX3N3X2Nvbm4gPSB7Cj4gKwkuZW5kcG9pbnRbMF0gPSAiYXhw Mjg4X2V4dGNvbiIsCj4gKwkuZW5kcG9pbnRbMV0gPSAiaW50ZWxfeGhjaV91c2Jfc3ctcm9sZS1z d2l0Y2giLAo+ICsJLmlkID0gInVzYi1yb2xlLXN3aXRjaCIsCj4gK307Cj4gKwo+ICtzdGF0aWMg aW50IF9faW5pdCBheHAyODhfZXh0Y29uX2luaXQodm9pZCkKPiArewo+ICsJaWYgKHg4Nl9tYXRj aF9jcHUoY2hlcnJ5X3RyYWlsX2NwdV9pZHMpKQo+ICsJCWFkZF9kZXZpY2VfY29ubmVjdGlvbigm YXhwMjg4X2V4dGNvbl9yb2xlX3N3X2Nvbm4pOwo+ICsKPiArCXJldHVybiBwbGF0Zm9ybV9kcml2 ZXJfcmVnaXN0ZXIoJmF4cDI4OF9leHRjb25fZHJpdmVyKTsKPiArfQo+ICttb2R1bGVfaW5pdChh eHAyODhfZXh0Y29uX2luaXQpOwo+ICsKPiArc3RhdGljIHZvaWQgX19leGl0IGF4cDI4OF9leHRj b25fZXhpdCh2b2lkKQo+ICt7Cj4gKwlpZiAoeDg2X21hdGNoX2NwdShjaGVycnlfdHJhaWxfY3B1 X2lkcykpCj4gKwkJcmVtb3ZlX2RldmljZV9jb25uZWN0aW9uKCZheHAyODhfZXh0Y29uX3JvbGVf c3dfY29ubik7Cj4gKwo+ICsJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmF4cDI4OF9leHRj b25fZHJpdmVyKTsKPiArfQo+ICttb2R1bGVfZXhpdChheHAyODhfZXh0Y29uX2V4aXQpOwo+ICAK PiAgTU9EVUxFX0FVVEhPUigiUmFtYWtyaXNobmEgUGFsbGFsYSA8cmFtYWtyaXNobmEucGFsbGFs YUBpbnRlbC5jb20+Iik7Cj4gK01PRFVMRV9BVVRIT1IoIkhhbnMgZGUgR29lZGUgPGhkZWdvZWRl QHJlZGhhdC5jb20+Iik7Cj4gIE1PRFVMRV9ERVNDUklQVElPTigiWC1Qb3dlcnMgQVhQMjg4IGV4 dGNvbiBkcml2ZXIiKTsKPiAgTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo+Ci0tLQpUbyB1bnN1 YnNjcmliZSBmcm9tIHRoaXMgbGlzdDogc2VuZCB0aGUgbGluZSAidW5zdWJzY3JpYmUgbGludXgt dXNiIiBpbgp0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9y ZwpNb3JlIG1ham9yZG9tbyBpbmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9t by1pbmZvLmh0bWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: Chanwoo Choi Subject: Re: [PATCH v5 12/12] extcon: axp288: Set USB role where necessary Date: Fri, 02 Mar 2018 09:39:07 +0900 Message-ID: <5A989D2B.8090903@samsung.com> References: <20180228150749.26831-1-hdegoede@redhat.com> <20180228150749.26831-13-hdegoede@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8BIT Return-path: In-reply-to: <20180228150749.26831-13-hdegoede@redhat.com> Sender: linux-kernel-owner@vger.kernel.org To: Hans de Goede , Darren Hart , Andy Shevchenko , MyungJoo Ham , Mathias Nyman , Heikki Krogerus , Greg Kroah-Hartman , Guenter Roeck Cc: platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-Id: platform-driver-x86.vger.kernel.org Hi, Basically, I have no objection. But I'll reply the my ack tag after finishing the review of 'devcon and usb_role_switch' from USB maintainer. And I have a question. Before this patch, extcon-axp288 is used to detect charger connector and extcon-intel-int3496 is used to detect the USB_HOST connector on one h/w device? Best Regards, Chanwoo Choi Samsung Electronics On 2018년 03월 01일 00:07, Hans de Goede wrote: > The AXP288 BC1.2 charger detection / extcon code may seem like a strange > place to add code to control the USB role-switch on devices with an AXP288, > but there are 2 reasons to do this inside the axp288 extcon code: > > 1) On many devices the USB role is controlled by ACPI AML code, but the AML > code only switches between the host and none roles, because of Windows > not really using device mode. To make device mode work we need to toggle > between the none/device roles based on Vbus presence, and the axp288 > extcon gets interrupts on Vbus insertion / removal. > > 2) In order for our BC1.2 charger detection to work properly the role > mux must be properly set to device mode before we do the detection. > > Also note the Kconfig help-text / obsolete depends on USB_PHY which are > remnants from older never upstreamed code also controlling the mux from > the axp288 extcon code. > > This commit also adds code to get notifications from the INT3496 extcon > device, which is used on some devices to notify the kernel about id-pin > changes instead of them being handled through AML code. > > This fixes: > -Device mode not working on most CHT devices with an AXP288 > -Host mode not working on devices with an INT3496 ACPI device > -Charger-type misdetection (always SDP) on devices with an INT3496 when the > USB role (always) gets initialized as host > > Reviewed-by: Heikki Krogerus > Reviewed-by: Andy Shevchenko > Signed-off-by: Hans de Goede > --- > Changes in v4: > -Add Andy's Reviewed-by > > Changes in v2: > -Add depends on X86 to Kconfig (the AXP288 PMIC is only used on X86) > -Use new acpi_dev_get_first_match_name() helper to get the INT3496 device-name > -Add Heikki's Reviewed-by > --- > drivers/extcon/Kconfig | 3 +- > drivers/extcon/extcon-axp288.c | 177 +++++++++++++++++++++++++++++++++++++++-- > 2 files changed, 171 insertions(+), 9 deletions(-) > > diff --git a/drivers/extcon/Kconfig b/drivers/extcon/Kconfig > index a7bca4207f44..de15bf55895b 100644 > --- a/drivers/extcon/Kconfig > +++ b/drivers/extcon/Kconfig > @@ -30,7 +30,8 @@ config EXTCON_ARIZONA > > config EXTCON_AXP288 > tristate "X-Power AXP288 EXTCON support" > - depends on MFD_AXP20X && USB_PHY > + depends on MFD_AXP20X && USB_SUPPORT && X86 > + select USB_ROLE_SWITCH > help > Say Y here to enable support for USB peripheral detection > and USB MUX switching by X-Power AXP288 PMIC. > diff --git a/drivers/extcon/extcon-axp288.c b/drivers/extcon/extcon-axp288.c > index 3ec4c715e240..51e77c7a32c2 100644 > --- a/drivers/extcon/extcon-axp288.c > +++ b/drivers/extcon/extcon-axp288.c > @@ -1,6 +1,7 @@ > /* > * extcon-axp288.c - X-Power AXP288 PMIC extcon cable detection driver > * > + * Copyright (c) 2017-2018 Hans de Goede > * Copyright (C) 2015 Intel Corporation > * Author: Ramakrishna Pallala > * > @@ -14,6 +15,8 @@ > * GNU General Public License for more details. > */ > > +#include > +#include > #include > #include > #include > @@ -25,6 +28,11 @@ > #include > #include > #include > +#include > +#include > + > +#include > +#include > > /* Power source status register */ > #define PS_STAT_VBUS_TRIGGER BIT(0) > @@ -97,9 +105,19 @@ struct axp288_extcon_info { > struct device *dev; > struct regmap *regmap; > struct regmap_irq_chip_data *regmap_irqc; > + struct usb_role_switch *role_sw; > + struct work_struct role_work; > int irq[EXTCON_IRQ_END]; > struct extcon_dev *edev; > + struct extcon_dev *id_extcon; > + struct notifier_block id_nb; > unsigned int previous_cable; > + bool vbus_attach; > +}; > + > +static const struct x86_cpu_id cherry_trail_cpu_ids[] = { > + { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_AIRMONT, X86_FEATURE_ANY }, > + {} > }; > > /* Power up/down reason string array */ > @@ -137,20 +155,74 @@ static void axp288_extcon_log_rsi(struct axp288_extcon_info *info) > regmap_write(info->regmap, AXP288_PS_BOOT_REASON_REG, clear_mask); > } > > -static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info) > +/* > + * The below code to control the USB role-switch on devices with an AXP288 > + * may seem out of place, but there are 2 reasons why this is the best place > + * to control the USB role-switch on such devices: > + * 1) On many devices the USB role is controlled by AML code, but the AML code > + * only switches between the host and none roles, because of Windows not > + * really using device mode. To make device mode work we need to toggle > + * between the none/device roles based on Vbus presence, and this driver > + * gets interrupts on Vbus insertion / removal. > + * 2) In order for our BC1.2 charger detection to work properly the role > + * mux must be properly set to device mode before we do the detection. > + */ > + > +/* Returns the id-pin value, note pulled low / false == host-mode */ > +static bool axp288_get_id_pin(struct axp288_extcon_info *info) > { > - int ret, stat, cfg, pwr_stat; > - u8 chrg_type; > - unsigned int cable = info->previous_cable; > - bool vbus_attach = false; > + enum usb_role role; > + > + if (info->id_extcon) > + return extcon_get_state(info->id_extcon, EXTCON_USB_HOST) <= 0; > + > + /* We cannot access the id-pin, see what mode the AML code has set */ > + role = usb_role_switch_get_role(info->role_sw); > + return role != USB_ROLE_HOST; > +} > + > +static void axp288_usb_role_work(struct work_struct *work) > +{ > + struct axp288_extcon_info *info = > + container_of(work, struct axp288_extcon_info, role_work); > + enum usb_role role; > + bool id_pin; > + int ret; > + > + id_pin = axp288_get_id_pin(info); > + if (!id_pin) > + role = USB_ROLE_HOST; > + else if (info->vbus_attach) > + role = USB_ROLE_DEVICE; > + else > + role = USB_ROLE_NONE; > + > + ret = usb_role_switch_set_role(info->role_sw, role); > + if (ret) > + dev_err(info->dev, "failed to set role: %d\n", ret); > +} > + > +static bool axp288_get_vbus_attach(struct axp288_extcon_info *info) > +{ > + int ret, pwr_stat; > > ret = regmap_read(info->regmap, AXP288_PS_STAT_REG, &pwr_stat); > if (ret < 0) { > dev_err(info->dev, "failed to read vbus status\n"); > - return ret; > + return false; > } > > - vbus_attach = (pwr_stat & PS_STAT_VBUS_VALID); > + return !!(pwr_stat & PS_STAT_VBUS_VALID); > +} > + > +static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info) > +{ > + int ret, stat, cfg; > + u8 chrg_type; > + unsigned int cable = info->previous_cable; > + bool vbus_attach = false; > + > + vbus_attach = axp288_get_vbus_attach(info); > if (!vbus_attach) > goto no_vbus; > > @@ -201,6 +273,12 @@ static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info) > info->previous_cable = cable; > } > > + if (info->role_sw && info->vbus_attach != vbus_attach) { > + info->vbus_attach = vbus_attach; > + /* Setting the role can take a while */ > + queue_work(system_long_wq, &info->role_work); > + } > + > return 0; > > dev_det_ret: > @@ -210,6 +288,18 @@ static int axp288_handle_chrg_det_event(struct axp288_extcon_info *info) > return ret; > } > > +static int axp288_extcon_id_evt(struct notifier_block *nb, > + unsigned long event, void *param) > +{ > + struct axp288_extcon_info *info = > + container_of(nb, struct axp288_extcon_info, id_nb); > + > + /* We may not sleep and setting the role can take a while */ > + queue_work(system_long_wq, &info->role_work); > + > + return NOTIFY_OK; > +} > + > static irqreturn_t axp288_extcon_isr(int irq, void *data) > { > struct axp288_extcon_info *info = data; > @@ -231,10 +321,20 @@ static void axp288_extcon_enable(struct axp288_extcon_info *info) > BC_GLOBAL_RUN, BC_GLOBAL_RUN); > } > > +static void axp288_put_role_sw(void *data) > +{ > + struct axp288_extcon_info *info = data; > + > + cancel_work_sync(&info->role_work); > + usb_role_switch_put(info->role_sw); > +} > + > static int axp288_extcon_probe(struct platform_device *pdev) > { > struct axp288_extcon_info *info; > struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent); > + struct device *dev = &pdev->dev; > + const char *name; > int ret, i, pirq; > > info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); > @@ -245,9 +345,33 @@ static int axp288_extcon_probe(struct platform_device *pdev) > info->regmap = axp20x->regmap; > info->regmap_irqc = axp20x->regmap_irqc; > info->previous_cable = EXTCON_NONE; > + INIT_WORK(&info->role_work, axp288_usb_role_work); > + info->id_nb.notifier_call = axp288_extcon_id_evt; > > platform_set_drvdata(pdev, info); > > + info->role_sw = usb_role_switch_get(dev); > + if (IS_ERR(info->role_sw)) > + return PTR_ERR(info->role_sw); > + if (info->role_sw) { > + ret = devm_add_action_or_reset(dev, axp288_put_role_sw, info); > + if (ret) > + return ret; > + > + name = acpi_dev_get_first_match_name("INT3496", NULL, -1); > + if (name) { > + info->id_extcon = extcon_get_extcon_dev(name); > + if (!info->id_extcon) > + return -EPROBE_DEFER; > + > + dev_info(dev, "controlling USB role\n"); > + } else { > + dev_info(dev, "controlling USB role based on Vbus presence\n"); > + } > + } > + > + info->vbus_attach = axp288_get_vbus_attach(info); > + > axp288_extcon_log_rsi(info); > > /* Initialize extcon device */ > @@ -289,6 +413,19 @@ static int axp288_extcon_probe(struct platform_device *pdev) > } > } > > + if (info->id_extcon) { > + ret = devm_extcon_register_notifier_all(dev, info->id_extcon, > + &info->id_nb); > + if (ret) > + return ret; > + } > + > + /* Make sure the role-sw is set correctly before doing BC detection */ > + if (info->role_sw) { > + queue_work(system_long_wq, &info->role_work); > + flush_work(&info->role_work); > + } > + > /* Start charger cable type detection */ > axp288_extcon_enable(info); > > @@ -308,8 +445,32 @@ static struct platform_driver axp288_extcon_driver = { > .name = "axp288_extcon", > }, > }; > -module_platform_driver(axp288_extcon_driver); > + > +static struct devcon axp288_extcon_role_sw_conn = { > + .endpoint[0] = "axp288_extcon", > + .endpoint[1] = "intel_xhci_usb_sw-role-switch", > + .id = "usb-role-switch", > +}; > + > +static int __init axp288_extcon_init(void) > +{ > + if (x86_match_cpu(cherry_trail_cpu_ids)) > + add_device_connection(&axp288_extcon_role_sw_conn); > + > + return platform_driver_register(&axp288_extcon_driver); > +} > +module_init(axp288_extcon_init); > + > +static void __exit axp288_extcon_exit(void) > +{ > + if (x86_match_cpu(cherry_trail_cpu_ids)) > + remove_device_connection(&axp288_extcon_role_sw_conn); > + > + platform_driver_unregister(&axp288_extcon_driver); > +} > +module_exit(axp288_extcon_exit); > > MODULE_AUTHOR("Ramakrishna Pallala "); > +MODULE_AUTHOR("Hans de Goede "); > MODULE_DESCRIPTION("X-Powers AXP288 extcon driver"); > MODULE_LICENSE("GPL v2"); >