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: staging: typec: handle vendor defined part and modify drp toggling flow From: Guenter Roeck Message-Id: <20180221221514.GA31916@roeck-us.net> Date: Wed, 21 Feb 2018 14:15:14 -0800 To: ShuFanLee Cc: heikki.krogerus@linux.intel.com, greg@kroah.com, shufan_lee@richtek.com, cy_huang@richtek.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-ID: T24gV2VkLCBGZWIgMjEsIDIwMTggYXQgMTE6MDI6MjNQTSArMDgwMCwgU2h1RmFuTGVlIHdyb3Rl Ogo+IEZyb206IFNodUZhbkxlZSA8c2h1ZmFuX2xlZUByaWNodGVrLmNvbT4KPiAKPiBIYW5kbGUg dmVuZG9yIGRlZmluZWQgYmVoYXZpb3IgaW4gdGNwY2lfaW5pdCwgdGNwY2lfc2V0X3Zjb25uIGFu ZCBleHBvcnQgdGNwY2lfaXJxLgo+IE1vcmUgb3BlcmF0aW9ucyBjYW4gYmUgZXh0ZW5kZWQgaW4g dGNwY2lfZGF0YSBpZiBuZWVkZWQuCj4gQWNjb3JkaW5nIHRvIFRDUENJIHNwZWNpZmljYXRpb24s IDQuNC41LjIgUk9MRV9DT05UUk9MLAo+IFRDUEMgc2hhbGwgbm90IHN0YXJ0IERSUCB0b2dnbGlu ZyB1bnRpbCBzdWJzZXF1ZW50bHkgdGhlIFRDUE0KPiB3cml0ZXMgdG8gdGhlIENPTU1BTkQgcmVn aXN0ZXIgdG8gc3RhcnQgRFJQIHRvZ2dsaW5nLgo+IERSUCB0b2dnbGluZyBmbG93IGlzIGNoYWdu ZWQgYXMgZm9sbG93aW5nOgo+ICAgLSBXcml0ZSBEUlAgPSAwICYgUmQvUmQKPiAgIC0gV3JpdGUg RFJQID0gMQo+ICAgLSBTZXQgTE9PSzRDT05ORUNUSU9OIGNvbW1hbmQKPiAKPiBTaWduZWQtb2Zm LWJ5OiBTaHVGYW5MZWUgPHNodWZhbl9sZWVAcmljaHRlay5jb20+CgpNb3N0bHkgbG9vb2tzIGdv b2QgdG8gbWUuIENvdXBsZSBvZiBuaXRwaWNrcyBiZWxvdy4KCkd1ZW50ZXIKCj4gLS0tCj4gIGRy aXZlcnMvc3RhZ2luZy90eXBlYy90Y3BjaS5jIHwgMTI4ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKy0tLS0tLS0tLQo+ICBkcml2ZXJzL3N0YWdpbmcvdHlwZWMvdGNwY2kuaCB8ICAx MyArKysrKwo+ICAyIGZpbGVzIGNoYW5nZWQsIDExNSBpbnNlcnRpb25zKCspLCAyNiBkZWxldGlv bnMoLSkKPiAKPiAgcGF0Y2ggY2hhbmdlbG9ncyBiZXR3ZWVuIHYxICYgdjIKPiAgLSBSZW1vdmUg dW5uZWNlc3NhcnkgaTJjX2NsaWVudCBpbiB0aGUgc3RydWN0dXJlIG9mIHRjcGNpCj4gIC0gUmVu YW1lIHN0cnVjdHVyZSBvZiB0Y3BjaV92ZW5kb3JfZGF0YSB0byB0Y3BjaV9kYXRhCj4gIC0gTm90 IGV4cG9ydGluZyB0Y3BjaSByZWFkL3dyaXRlIHdyYXBwZXJzIGJ1dCByZWdpc3RlciBpMmMgcmVn bWFwIGluIGdsdWUgZHJpdmVyCj4gIC0gQWRkIHNldF92Y29ubiBvcHMgaW4gdGNwY2lfZGF0YQo+ ICAgIChJdCBpcyBuZWNlc3NhcnkgZm9yIFJUMTcxMUggdG8gZW5hYmxlL2Rpc2FibGUgaWRsZSBt b2RlIGJlZm9yZSBkaXNhYmxpbmcvZW5hYmxpbmcgdmNvbm4pCj4gIC0gRXhwb3J0IHRjcGNpX2ly cSBzbyB0aGF0IHZlbmRvciBjYW4gY2FsbCBpdCBpbiB0aGVpciBvd24gSVJRIGhhbmRsZXIKPiAK PiAgcGF0Y2ggY2hhbmdlbG9ncyBiZXR3ZWVuIHYyICYgdjMKPiAgLSBDaGFuZ2UgdGhlIHJldHVy biB0eXBlIG9mIHRjcGNpX2lycSBmcm9tIGludCB0byBpcnFyZXR1cm5fdAo+IAo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL3N0YWdpbmcvdHlwZWMvdGNwY2kuYyBiL2RyaXZlcnMvc3RhZ2luZy90eXBl Yy90Y3BjaS5jCj4gaW5kZXggOWJkNDQxMi4uNDk1OWM2OSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L3N0YWdpbmcvdHlwZWMvdGNwY2kuYwo+ICsrKyBiL2RyaXZlcnMvc3RhZ2luZy90eXBlYy90Y3Bj aS5jCj4gQEAgLTIxLDcgKzIxLDYgQEAKPiAgCj4gIHN0cnVjdCB0Y3BjaSB7Cj4gIAlzdHJ1Y3Qg ZGV2aWNlICpkZXY7Cj4gLQlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50Owo+ICAKPiAgCXN0cnVj dCB0Y3BtX3BvcnQgKnBvcnQ7Cj4gIAo+IEBAIC0zMCw2ICsyOSwxMiBAQCBzdHJ1Y3QgdGNwY2kg ewo+ICAJYm9vbCBjb250cm9sc192YnVzOwo+ICAKPiAgCXN0cnVjdCB0Y3BjX2RldiB0Y3BjOwo+ ICsJc3RydWN0IHRjcGNpX2RhdGEgKmRhdGE7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdGNwY2lfY2hp cCB7Cj4gKwlzdHJ1Y3QgdGNwY2kgKnRjcGNpOwo+ICsJc3RydWN0IHRjcGNpX2RhdGEgZGF0YTsK PiAgfTsKPiAgCj4gIHN0YXRpYyBpbmxpbmUgc3RydWN0IHRjcGNpICp0Y3BjX3RvX3RjcGNpKHN0 cnVjdCB0Y3BjX2RldiAqdGNwYykKPiBAQCAtMzcsOCArNDIsNyBAQCBzdGF0aWMgaW5saW5lIHN0 cnVjdCB0Y3BjaSAqdGNwY190b190Y3BjaShzdHJ1Y3QgdGNwY19kZXYgKnRjcGMpCj4gIAlyZXR1 cm4gY29udGFpbmVyX29mKHRjcGMsIHN0cnVjdCB0Y3BjaSwgdGNwYyk7Cj4gIH0KPiAgCj4gLXN0 YXRpYyBpbnQgdGNwY2lfcmVhZDE2KHN0cnVjdCB0Y3BjaSAqdGNwY2ksIHVuc2lnbmVkIGludCBy ZWcsCj4gLQkJCXUxNiAqdmFsKQo+ICtzdGF0aWMgaW50IHRjcGNpX3JlYWQxNihzdHJ1Y3QgdGNw Y2kgKnRjcGNpLCB1bnNpZ25lZCBpbnQgcmVnLCB1MTYgKnZhbCkKPiAgewo+ICAJcmV0dXJuIHJl Z21hcF9yYXdfcmVhZCh0Y3BjaS0+cmVnbWFwLCByZWcsIHZhbCwgc2l6ZW9mKHUxNikpOwo+ICB9 Cj4gQEAgLTk4LDggKzEwMiwxMCBAQCBzdGF0aWMgaW50IHRjcGNpX3NldF9jYyhzdHJ1Y3QgdGNw Y19kZXYgKnRjcGMsIGVudW0gdHlwZWNfY2Nfc3RhdHVzIGNjKQo+ICBzdGF0aWMgaW50IHRjcGNp X3N0YXJ0X2RycF90b2dnbGluZyhzdHJ1Y3QgdGNwY19kZXYgKnRjcGMsCj4gIAkJCQkgICAgZW51 bSB0eXBlY19jY19zdGF0dXMgY2MpCj4gIHsKPiArCWludCByZXQ7Cj4gIAlzdHJ1Y3QgdGNwY2kg KnRjcGNpID0gdGNwY190b190Y3BjaSh0Y3BjKTsKPiAtCXVuc2lnbmVkIGludCByZWcgPSBUQ1BD X1JPTEVfQ1RSTF9EUlA7Cj4gKwl1bnNpZ25lZCBpbnQgcmVnID0gKFRDUENfUk9MRV9DVFJMX0ND X1JEIDw8IFRDUENfUk9MRV9DVFJMX0NDMV9TSElGVCkgfAo+ICsJCQkgICAoVENQQ19ST0xFX0NU UkxfQ0NfUkQgPDwgVENQQ19ST0xFX0NUUkxfQ0MyX1NISUZUKTsKPiAgCj4gIAlzd2l0Y2ggKGNj KSB7Cj4gIAlkZWZhdWx0Ogo+IEBAIC0xMTcsNyArMTIzLDE5IEBAIHN0YXRpYyBpbnQgdGNwY2lf c3RhcnRfZHJwX3RvZ2dsaW5nKHN0cnVjdCB0Y3BjX2RldiAqdGNwYywKPiAgCQlicmVhazsKPiAg CX0KPiAgCj4gLQlyZXR1cm4gcmVnbWFwX3dyaXRlKHRjcGNpLT5yZWdtYXAsIFRDUENfUk9MRV9D VFJMLCByZWcpOwo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlKHRjcGNpLT5yZWdtYXAsIFRDUENfUk9M RV9DVFJMLCByZWcpOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCXVzbGVl cF9yYW5nZSg1MDAsIDEwMDApOwo+ICsJcmVnIHw9IFRDUENfUk9MRV9DVFJMX0RSUDsKPiArCXJl dCA9IHJlZ21hcF93cml0ZSh0Y3BjaS0+cmVnbWFwLCBUQ1BDX1JPTEVfQ1RSTCwgcmVnKTsKPiAr CWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwlyZXQgPSByZWdtYXBfd3JpdGUodGNw Y2ktPnJlZ21hcCwgVENQQ19DT01NQU5ELAo+ICsJCQkgICBUQ1BDX0NNRF9MT09LNENPTk5FQ1RJ T04pOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCXJldHVybiAwOwoKcmVn bWFwX3dyaXRlIHJldHVybnMgYSBuZWdhdGl2ZSByZXR1cm4gY29kZSBvciAwLCB0aHVzIHRoaXMg Y2FuIGJlCnNpbXBsaWZpZWQgdG8KCXJldHVybiByZWdtYXBfd3JpdGUoLi4uKTsKCj4gIH0KPiAg Cj4gIHN0YXRpYyBlbnVtIHR5cGVjX2NjX3N0YXR1cyB0Y3BjaV90b190eXBlY19jYyh1bnNpZ25l ZCBpbnQgY2MsIGJvb2wgc2luaykKPiBAQCAtMTc4LDYgKzE5NiwxNiBAQCBzdGF0aWMgaW50IHRj cGNpX3NldF92Y29ubihzdHJ1Y3QgdGNwY19kZXYgKnRjcGMsIGJvb2wgZW5hYmxlKQo+ICAJc3Ry dWN0IHRjcGNpICp0Y3BjaSA9IHRjcGNfdG9fdGNwY2kodGNwYyk7Cj4gIAlpbnQgcmV0Owo+ICAK PiArCS8qIEhhbmRsZSB2ZW5kb3Igc2V0IHZjb25uICovCj4gKwlpZiAodGNwY2ktPmRhdGEpIHsK PiArCQlpZiAodGNwY2ktPmRhdGEtPnNldF92Y29ubikgewo+ICsJCQlyZXQgPSB0Y3BjaS0+ZGF0 YS0+c2V0X3Zjb25uKHRjcGNpLCB0Y3BjaS0+ZGF0YSwKPiArCQkJCQkJICAgICBlbmFibGUpOwo+ ICsJCQlpZiAocmV0IDwgMCkKPiArCQkJCXJldHVybiByZXQ7Cj4gKwkJfQo+ICsJfQo+ICsKPiAg CXJldCA9IHJlZ21hcF93cml0ZSh0Y3BjaS0+cmVnbWFwLCBUQ1BDX1BPV0VSX0NUUkwsCj4gIAkJ CSAgIGVuYWJsZSA/IFRDUENfUE9XRVJfQ1RSTF9WQ09OTl9FTkFCTEUgOiAwKTsKPiAgCWlmIChy ZXQgPCAwKQo+IEBAIC0zMjMsNiArMzUxLDE1IEBAIHN0YXRpYyBpbnQgdGNwY2lfaW5pdChzdHJ1 Y3QgdGNwY19kZXYgKnRjcGMpCj4gIAlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0KSkK PiAgCQlyZXR1cm4gLUVUSU1FRE9VVDsKPiAgCj4gKwkvKiBIYW5kbGUgdmVuZG9yIGluaXQgKi8K PiArCWlmICh0Y3BjaS0+ZGF0YSkgewo+ICsJCWlmICh0Y3BjaS0+ZGF0YS0+aW5pdCkgewo+ICsJ CQlyZXQgPSB0Y3BjaS0+ZGF0YS0+aW5pdCh0Y3BjaSwgdGNwY2ktPmRhdGEpOwo+ICsJCQlpZiAo cmV0IDwgMCkKPiArCQkJCXJldHVybiByZXQ7Cj4gKwkJfQo+ICsJfQo+ICsKPiAgCS8qIENsZWFy IGFsbCBldmVudHMgKi8KPiAgCXJldCA9IHRjcGNpX3dyaXRlMTYodGNwY2ksIFRDUENfQUxFUlQs IDB4ZmZmZik7Cj4gIAlpZiAocmV0IDwgMCkKPiBAQCAtMzQ0LDkgKzM4MSwxNSBAQCBzdGF0aWMg aW50IHRjcGNpX2luaXQoc3RydWN0IHRjcGNfZGV2ICp0Y3BjKQo+ICAJcmV0dXJuIHRjcGNpX3dy aXRlMTYodGNwY2ksIFRDUENfQUxFUlRfTUFTSywgcmVnKTsKPiAgfQo+ICAKPiAtc3RhdGljIGly cXJldHVybl90IHRjcGNpX2lycShpbnQgaXJxLCB2b2lkICpkZXZfaWQpCj4gK3N0YXRpYyBpcnFy ZXR1cm5fdCBfdGNwY2lfaXJxKGludCBpcnEsIHZvaWQgKmRldl9pZCkKPiAgewo+ICAJc3RydWN0 IHRjcGNpICp0Y3BjaSA9IGRldl9pZDsKPiArCj4gKwlyZXR1cm4gdGNwY2lfaXJxKHRjcGNpKTsK PiArfQoKSG1tLCBub3JtYWxseSBJJ2QgZXhwZWN0IHRoaXMgZnVuY3Rpb24gX2FmdGVyXyB0aGUg ZnVuY3Rpb24gaXQgY2FsbHMuCkd1ZXNzIHRoYXQgZG9lc24ndCBtYXR0ZXIgbXVjaCBoZXJlLCBz byBJIGFtIGZpbmUgd2l0aCBpdCBhcyBsb25nCmFzIEdyZWcgaXMgb2sgd2l0aCBpdCBhcyB3ZWxs LgoKPiArCj4gK2lycXJldHVybl90IHRjcGNpX2lycShzdHJ1Y3QgdGNwY2kgKnRjcGNpKQo+ICt7 Cj4gIAl1MTYgc3RhdHVzOwo+ICAKPiAgCXRjcGNpX3JlYWQxNih0Y3BjaSwgVENQQ19BTEVSVCwg JnN0YXR1cyk7Cj4gQEAgLTQxMiw2ICs0NTUsNyBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgdGNwY2lf aXJxKGludCBpcnEsIHZvaWQgKmRldl9pZCkKPiAgCj4gIAlyZXR1cm4gSVJRX0hBTkRMRUQ7Cj4g IH0KPiArRVhQT1JUX1NZTUJPTF9HUEwodGNwY2lfaXJxKTsKPiAgCj4gIHN0YXRpYyBjb25zdCBz dHJ1Y3QgcmVnbWFwX2NvbmZpZyB0Y3BjaV9yZWdtYXBfY29uZmlnID0gewo+ICAJLnJlZ19iaXRz ID0gOCwKPiBAQCAtNDM1LDIyICs0NzksMTggQEAgc3RhdGljIGludCB0Y3BjaV9wYXJzZV9jb25m aWcoc3RydWN0IHRjcGNpICp0Y3BjaSkKPiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+IC1zdGF0aWMg aW50IHRjcGNpX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gLQkJICAgICAgIGNv bnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppMmNfaWQpCj4gK3N0cnVjdCB0Y3BjaSAqdGNwY2lf cmVnaXN0ZXJfcG9ydChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB0Y3BjaV9kYXRhICpkYXRh KQo+ICB7Cj4gIAlzdHJ1Y3QgdGNwY2kgKnRjcGNpOwo+ICAJaW50IGVycjsKPiAgCj4gLQl0Y3Bj aSA9IGRldm1fa3phbGxvYygmY2xpZW50LT5kZXYsIHNpemVvZigqdGNwY2kpLCBHRlBfS0VSTkVM KTsKPiArCXRjcGNpID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCp0Y3BjaSksIEdGUF9LRVJO RUwpOwo+ICAJaWYgKCF0Y3BjaSkKPiAtCQlyZXR1cm4gLUVOT01FTTsKPiArCQlyZXR1cm4gRVJS X1BUUigtRU5PTUVNKTsKPiAgCj4gLQl0Y3BjaS0+Y2xpZW50ID0gY2xpZW50Owo+IC0JdGNwY2kt PmRldiA9ICZjbGllbnQtPmRldjsKPiAtCWkyY19zZXRfY2xpZW50ZGF0YShjbGllbnQsIHRjcGNp KTsKPiAtCXRjcGNpLT5yZWdtYXAgPSBkZXZtX3JlZ21hcF9pbml0X2kyYyhjbGllbnQsICZ0Y3Bj aV9yZWdtYXBfY29uZmlnKTsKPiAtCWlmIChJU19FUlIodGNwY2ktPnJlZ21hcCkpCj4gLQkJcmV0 dXJuIFBUUl9FUlIodGNwY2ktPnJlZ21hcCk7Cj4gKwl0Y3BjaS0+ZGV2ID0gZGV2Owo+ICsJdGNw Y2ktPmRhdGEgPSBkYXRhOwo+ICsJdGNwY2ktPnJlZ21hcCA9IGRhdGEtPnJlZ21hcDsKPiAgCj4g IAl0Y3BjaS0+dGNwYy5pbml0ID0gdGNwY2lfaW5pdDsKPiAgCXRjcGNpLT50Y3BjLmdldF92YnVz ID0gdGNwY2lfZ2V0X3ZidXM7Cj4gQEAgLTQ2NywyNyArNTA3LDYzIEBAIHN0YXRpYyBpbnQgdGNw Y2lfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiAgCj4gIAllcnIgPSB0Y3BjaV9w YXJzZV9jb25maWcodGNwY2kpOwo+ICAJaWYgKGVyciA8IDApCj4gLQkJcmV0dXJuIGVycjsKPiAr CQlyZXR1cm4gRVJSX1BUUihlcnIpOwo+ICsKPiArCXRjcGNpLT5wb3J0ID0gdGNwbV9yZWdpc3Rl cl9wb3J0KHRjcGNpLT5kZXYsICZ0Y3BjaS0+dGNwYyk7Cj4gKwlpZiAoUFRSX0VSUl9PUl9aRVJP KHRjcGNpLT5wb3J0KSkKPiArCQlyZXR1cm4gRVJSX0NBU1QodGNwY2ktPnBvcnQpOwo+ICAKPiAt CS8qIERpc2FibGUgY2hpcCBpbnRlcnJ1cHRzICovCj4gLQl0Y3BjaV93cml0ZTE2KHRjcGNpLCBU Q1BDX0FMRVJUX01BU0ssIDApOwo+ICsJcmV0dXJuIHRjcGNpOwo+ICt9Cj4gK0VYUE9SVF9TWU1C T0xfR1BMKHRjcGNpX3JlZ2lzdGVyX3BvcnQpOwo+ICsKPiArdm9pZCB0Y3BjaV91bnJlZ2lzdGVy X3BvcnQoc3RydWN0IHRjcGNpICp0Y3BjaSkKPiArewo+ICsJdGNwbV91bnJlZ2lzdGVyX3BvcnQo dGNwY2ktPnBvcnQpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHRjcGNpX3VucmVnaXN0ZXJf cG9ydCk7Cj4gIAo+IC0JZXJyID0gZGV2bV9yZXF1ZXN0X3RocmVhZGVkX2lycSh0Y3BjaS0+ZGV2 LCBjbGllbnQtPmlycSwgTlVMTCwKPiAtCQkJCQl0Y3BjaV9pcnEsCj4gK3N0YXRpYyBpbnQgdGNw Y2lfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiArCQkgICAgICAgY29uc3Qgc3Ry dWN0IGkyY19kZXZpY2VfaWQgKmkyY19pZCkKPiArewo+ICsJc3RydWN0IHRjcGNpX2NoaXAgKmNo aXA7Cj4gKwlpbnQgZXJyOwo+ICsJdTE2IHZhbCA9IDA7Cj4gKwo+ICsJY2hpcCA9IGRldm1fa3ph bGxvYygmY2xpZW50LT5kZXYsIHNpemVvZigqY2hpcCksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFj aGlwKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWNoaXAtPmRhdGEucmVnbWFwID0gZGV2 bV9yZWdtYXBfaW5pdF9pMmMoY2xpZW50LCAmdGNwY2lfcmVnbWFwX2NvbmZpZyk7Cj4gKwlpZiAo SVNfRVJSKGNoaXAtPmRhdGEucmVnbWFwKSkKPiArCQlyZXR1cm4gUFRSX0VSUihjaGlwLT5kYXRh LnJlZ21hcCk7Cj4gKwo+ICsJLyogRGlzYWJsZSBjaGlwIGludGVycnVwdHMgYmVmb3JlIHJlcXVl c3RpbmcgaXJxICovCj4gKwllcnIgPSByZWdtYXBfcmF3X3dyaXRlKGNoaXAtPmRhdGEucmVnbWFw LCBUQ1BDX0FMRVJUX01BU0ssICZ2YWwsCj4gKwkJCSAgICAgICBzaXplb2YodTE2KSk7Cj4gKwlp ZiAoZXJyIDwgMCkKPiArCQlyZXR1cm4gZXJyOwo+ICsKPiArCWVyciA9IGRldm1fcmVxdWVzdF90 aHJlYWRlZF9pcnEoJmNsaWVudC0+ZGV2LCBjbGllbnQtPmlycSwgTlVMTCwKPiArCQkJCQlfdGNw Y2lfaXJxLAo+ICAJCQkJCUlSUUZfT05FU0hPVCB8IElSUUZfVFJJR0dFUl9MT1csCj4gLQkJCQkJ ZGV2X25hbWUodGNwY2ktPmRldiksIHRjcGNpKTsKPiArCQkJCQlkZXZfbmFtZSgmY2xpZW50LT5k ZXYpLCBjaGlwKTsKPiAgCWlmIChlcnIgPCAwKQo+ICAJCXJldHVybiBlcnI7Cj4gIAo+IC0JdGNw Y2ktPnBvcnQgPSB0Y3BtX3JlZ2lzdGVyX3BvcnQodGNwY2ktPmRldiwgJnRjcGNpLT50Y3BjKTsK PiAtCXJldHVybiBQVFJfRVJSX09SX1pFUk8odGNwY2ktPnBvcnQpOwo+ICsJY2hpcC0+dGNwY2kg PSB0Y3BjaV9yZWdpc3Rlcl9wb3J0KCZjbGllbnQtPmRldiwgJmNoaXAtPmRhdGEpOwo+ICsJaWYg KFBUUl9FUlJfT1JfWkVSTyhjaGlwLT50Y3BjaSkpCj4gKwkJcmV0dXJuIFBUUl9FUlIoY2hpcC0+ dGNwY2kpOwo+ICsKPiArCWkyY19zZXRfY2xpZW50ZGF0YShjbGllbnQsIGNoaXApOwo+ICsJcmV0 dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyBpbnQgdGNwY2lfcmVtb3ZlKHN0cnVjdCBpMmNfY2xp ZW50ICpjbGllbnQpCj4gIHsKPiAtCXN0cnVjdCB0Y3BjaSAqdGNwY2kgPSBpMmNfZ2V0X2NsaWVu dGRhdGEoY2xpZW50KTsKPiArCXN0cnVjdCB0Y3BjaV9jaGlwICpjaGlwID0gaTJjX2dldF9jbGll bnRkYXRhKGNsaWVudCk7Cj4gIAo+IC0JdGNwbV91bnJlZ2lzdGVyX3BvcnQodGNwY2ktPnBvcnQp Owo+ICsJdGNwY2lfdW5yZWdpc3Rlcl9wb3J0KGNoaXAtPnRjcGNpKTsKPiAgCj4gIAlyZXR1cm4g MDsKPiAgfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdHlwZWMvdGNwY2kuaCBiL2Ry aXZlcnMvc3RhZ2luZy90eXBlYy90Y3BjaS5oCj4gaW5kZXggZmRmYjA2Yy4uNDAwMjViMiAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL3N0YWdpbmcvdHlwZWMvdGNwY2kuaAo+ICsrKyBiL2RyaXZlcnMv c3RhZ2luZy90eXBlYy90Y3BjaS5oCj4gQEAgLTU5LDYgKzU5LDcgQEAKPiAgI2RlZmluZSBUQ1BD X1BPV0VSX0NUUkxfVkNPTk5fRU5BQkxFCUJJVCgwKQo+ICAKPiAgI2RlZmluZSBUQ1BDX0NDX1NU QVRVUwkJCTB4MWQKPiArI2RlZmluZSBUQ1BDX0NDX1NUQVRVU19EUlBSU1QJCUJJVCg1KQo+ICAj ZGVmaW5lIFRDUENfQ0NfU1RBVFVTX1RFUk0JCUJJVCg0KQo+ICAjZGVmaW5lIFRDUENfQ0NfU1RB VFVTX0NDMl9TSElGVAkyCj4gICNkZWZpbmUgVENQQ19DQ19TVEFUVVNfQ0MyX01BU0sJCTB4Mwo+ IEBAIC0xMjEsNCArMTIyLDE2IEBACj4gICNkZWZpbmUgVENQQ19WQlVTX1ZPTFRBR0VfQUxBUk1f SElfQ0ZHCQkweDc2Cj4gICNkZWZpbmUgVENQQ19WQlVTX1ZPTFRBR0VfQUxBUk1fTE9fQ0ZHCQkw eDc4Cj4gIAo+ICtzdHJ1Y3QgdGNwY2k7Cj4gK3N0cnVjdCB0Y3BjaV9kYXRhIHsKPiArCXN0cnVj dCByZWdtYXAgKnJlZ21hcDsKPiArCWludCAoKmluaXQpKHN0cnVjdCB0Y3BjaSAqdGNwY2ksIHN0 cnVjdCB0Y3BjaV9kYXRhICpkYXRhKTsKPiArCWludCAoKnNldF92Y29ubikoc3RydWN0IHRjcGNp ICp0Y3BjaSwgc3RydWN0IHRjcGNpX2RhdGEgKmRhdGEsCj4gKwkJCSBib29sIGVuYWJsZSk7Cj4g K307Cj4gKwo+ICtzdHJ1Y3QgdGNwY2kgKnRjcGNpX3JlZ2lzdGVyX3BvcnQoc3RydWN0IGRldmlj ZSAqZGV2LCBzdHJ1Y3QgdGNwY2lfZGF0YSAqZGF0YSk7Cj4gK3ZvaWQgdGNwY2lfdW5yZWdpc3Rl cl9wb3J0KHN0cnVjdCB0Y3BjaSAqdGNwY2kpOwo+ICtpcnFyZXR1cm5fdCB0Y3BjaV9pcnEoc3Ry dWN0IHRjcGNpICp0Y3BjaSk7Cj4gKwo+ICAjZW5kaWYgLyogX19MSU5VWF9VU0JfVENQQ0lfSCAq Lwo+IC0tIAo+IDEuOS4xCj4KLS0tClRvIHVuc3Vic2NyaWJlIGZyb20gdGhpcyBsaXN0OiBzZW5k IHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC11c2IiIGluCnRoZSBib2R5IG9mIGEgbWVzc2Fn ZSB0byBtYWpvcmRvbW9Admdlci5rZXJuZWwub3JnCk1vcmUgbWFqb3Jkb21vIGluZm8gYXQgIGh0 dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWluZm8uaHRtbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-2591080-1519251323-2-8375489199776415288 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, FREEMAIL_ENVFROM_END_DIGIT 0.25, FREEMAIL_FORGED_FROMDOMAIN 0.195, FREEMAIL_FROM 0.001, HEADER_FROM_DIFFERENT_DOMAINS 0.001, RCVD_IN_DNSWL_NONE -0.0001, RCVD_IN_MSPIKE_H3 -0.01, RCVD_IN_MSPIKE_WL -0.01, SPF_PASS -0.001, LANGUAGES ro, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='74.125.83.66', Host='mail-pg0-f66.google.com', Country='US', FromHeader='net', MailFrom='com' X-Spam-charsets: plain='us-ascii' X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: groeck7@gmail.com ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=arctest; t=1519251322; b=GH55uTNfvy+ydLq+wZiOdev93Jiw91jDm5CW+1PwpzHC20C rxbNjA2G/JQ+hnx6C7V1ArU5U39LpU1D3zWkwHQ0cV4SI+z2rxQjfJDw8XHllliP n+Jn5ZZIKabhZ9hA0CaU2yrRo0fKPuucUiXBOY8LwGNcnBLYhu6TTOALqP3xt8OY MVctZ4Eq/lHE1i6fxMW2aXd7Vj7wXsQdA3rHOaTPKp1+jSFKqQsobjVbMBl5tXGR c/vZRTpEpWR+OpVgxpBDzJE+YwUqGDk37noIok+rfffe9KHRqbf1bm4knXvp/6Pa iemcQQDCT81I/et7+DA0dNkgQkX3PhiZK9+qupQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=sender:date:from:to:cc:subject:message-id :references:mime-version:content-type:in-reply-to; s=arctest; t= 1519251322; bh=zpg4o6v4zyQVPRK9XeEbPMbb80rNZIiI2a84VHgjuZQ=; b=h ald8RTwt9O5VVSP7j084J/2KhBB5uYJGKiX5Wbu1zkO2degKE2WeY7YM61nLRX7Y PG1doX7b2LVJn3wJKr2aEe3tZkpPAu+8fUmjh3q697WIfVqbCkwyxgyyPpcf9/S+ JK0yd9H8SruslIElf5HovHxFlz6zY+OH5g2ZYBUXvrAPmD4ZVjxOVII4KdIZ6a67 i8WNOUauKIi7Ob7UfQEc9XSLMr/v9eaWKGfCQduFIJdLqK7uzRnx2sdPkvxKLbs7 pdK80Dfo2cosZQ8M4HvWZp6VCS51DiMHA33lVaf1vRuYmBw7ubtKoe8B+zYBE+Ts +Z5cQnZfO0Tn4TS6t637A== ARC-Authentication-Results: i=1; mx4.messagingengine.com; arc=none (no signatures found); dkim=pass (2048-bit rsa key sha256) header.d=gmail.com header.i=@gmail.com header.b=IniMLkR/ x-bits=2048 x-keytype=rsa x-algorithm=sha256 x-selector=20161025; dmarc=none (p=none,d=none) header.from=roeck-us.net; iprev=pass policy.iprev=74.125.83.66 (mail-pg0-f66.google.com); spf=pass smtp.mailfrom=groeck7@gmail.com smtp.helo=mail-pg0-f66.google.com; x-aligned-from=fail; x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=EA/pt0P5; x-ptr=pass x-ptr-helo=mail-pg0-f66.google.com x-ptr-lookup=mail-pg0-f66.google.com; x-return-mx=pass smtp.domain=gmail.com smtp.result=pass smtp_is_org_domain=yes header.domain=roeck-us.net header.result=pass header_is_org_domain=yes; x-tls=pass version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128 Authentication-Results: mx4.messagingengine.com; arc=none (no signatures found); dkim=pass (2048-bit rsa key sha256) header.d=gmail.com header.i=@gmail.com header.b=IniMLkR/ x-bits=2048 x-keytype=rsa x-algorithm=sha256 x-selector=20161025; dmarc=none (p=none,d=none) header.from=roeck-us.net; iprev=pass policy.iprev=74.125.83.66 (mail-pg0-f66.google.com); spf=pass smtp.mailfrom=groeck7@gmail.com smtp.helo=mail-pg0-f66.google.com; x-aligned-from=fail; x-google-dkim=pass (2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=EA/pt0P5; x-ptr=pass x-ptr-helo=mail-pg0-f66.google.com x-ptr-lookup=mail-pg0-f66.google.com; x-return-mx=pass smtp.domain=gmail.com smtp.result=pass smtp_is_org_domain=yes header.domain=roeck-us.net header.result=pass header_is_org_domain=yes; x-tls=pass version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128 X-Google-Smtp-Source: AH8x224pkPyEwE3dj5DU7BJgIFOG8wTYlfwPB+eeg/2/kiI1OSIjobTFB+UablvqG+XFrzb1NRyYLw== Sender: Guenter Roeck Date: Wed, 21 Feb 2018 14:15:14 -0800 From: Guenter Roeck To: ShuFanLee Cc: heikki.krogerus@linux.intel.com, greg@kroah.com, shufan_lee@richtek.com, cy_huang@richtek.com, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org Subject: Re: [PATCH] staging: typec: handle vendor defined part and modify drp toggling flow Message-ID: <20180221221514.GA31916@roeck-us.net> References: <1519225343-2929-1-git-send-email-leechu729@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1519225343-2929-1-git-send-email-leechu729@gmail.com> User-Agent: Mutt/1.5.24 (2015-08-30) X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: On Wed, Feb 21, 2018 at 11:02:23PM +0800, ShuFanLee wrote: > From: ShuFanLee > > Handle vendor defined behavior in tcpci_init, tcpci_set_vconn and export tcpci_irq. > More operations can be extended in tcpci_data if needed. > According to TCPCI specification, 4.4.5.2 ROLE_CONTROL, > TCPC shall not start DRP toggling until subsequently the TCPM > writes to the COMMAND register to start DRP toggling. > DRP toggling flow is chagned as following: > - Write DRP = 0 & Rd/Rd > - Write DRP = 1 > - Set LOOK4CONNECTION command > > Signed-off-by: ShuFanLee Mostly loooks good to me. Couple of nitpicks below. Guenter > --- > drivers/staging/typec/tcpci.c | 128 +++++++++++++++++++++++++++++++++--------- > drivers/staging/typec/tcpci.h | 13 +++++ > 2 files changed, 115 insertions(+), 26 deletions(-) > > patch changelogs between v1 & v2 > - Remove unnecessary i2c_client in the structure of tcpci > - Rename structure of tcpci_vendor_data to tcpci_data > - Not exporting tcpci read/write wrappers but register i2c regmap in glue driver > - Add set_vconn ops in tcpci_data > (It is necessary for RT1711H to enable/disable idle mode before disabling/enabling vconn) > - Export tcpci_irq so that vendor can call it in their own IRQ handler > > patch changelogs between v2 & v3 > - Change the return type of tcpci_irq from int to irqreturn_t > > diff --git a/drivers/staging/typec/tcpci.c b/drivers/staging/typec/tcpci.c > index 9bd4412..4959c69 100644 > --- a/drivers/staging/typec/tcpci.c > +++ b/drivers/staging/typec/tcpci.c > @@ -21,7 +21,6 @@ > > struct tcpci { > struct device *dev; > - struct i2c_client *client; > > struct tcpm_port *port; > > @@ -30,6 +29,12 @@ struct tcpci { > bool controls_vbus; > > struct tcpc_dev tcpc; > + struct tcpci_data *data; > +}; > + > +struct tcpci_chip { > + struct tcpci *tcpci; > + struct tcpci_data data; > }; > > static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc) > @@ -37,8 +42,7 @@ static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc) > return container_of(tcpc, struct tcpci, tcpc); > } > > -static int tcpci_read16(struct tcpci *tcpci, unsigned int reg, > - u16 *val) > +static int tcpci_read16(struct tcpci *tcpci, unsigned int reg, u16 *val) > { > return regmap_raw_read(tcpci->regmap, reg, val, sizeof(u16)); > } > @@ -98,8 +102,10 @@ static int tcpci_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc) > static int tcpci_start_drp_toggling(struct tcpc_dev *tcpc, > enum typec_cc_status cc) > { > + int ret; > struct tcpci *tcpci = tcpc_to_tcpci(tcpc); > - unsigned int reg = TCPC_ROLE_CTRL_DRP; > + unsigned int reg = (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC1_SHIFT) | > + (TCPC_ROLE_CTRL_CC_RD << TCPC_ROLE_CTRL_CC2_SHIFT); > > switch (cc) { > default: > @@ -117,7 +123,19 @@ static int tcpci_start_drp_toggling(struct tcpc_dev *tcpc, > break; > } > > - return regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); > + ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); > + if (ret < 0) > + return ret; > + usleep_range(500, 1000); > + reg |= TCPC_ROLE_CTRL_DRP; > + ret = regmap_write(tcpci->regmap, TCPC_ROLE_CTRL, reg); > + if (ret < 0) > + return ret; > + ret = regmap_write(tcpci->regmap, TCPC_COMMAND, > + TCPC_CMD_LOOK4CONNECTION); > + if (ret < 0) > + return ret; > + return 0; regmap_write returns a negative return code or 0, thus this can be simplified to return regmap_write(...); > } > > static enum typec_cc_status tcpci_to_typec_cc(unsigned int cc, bool sink) > @@ -178,6 +196,16 @@ static int tcpci_set_vconn(struct tcpc_dev *tcpc, bool enable) > struct tcpci *tcpci = tcpc_to_tcpci(tcpc); > int ret; > > + /* Handle vendor set vconn */ > + if (tcpci->data) { > + if (tcpci->data->set_vconn) { > + ret = tcpci->data->set_vconn(tcpci, tcpci->data, > + enable); > + if (ret < 0) > + return ret; > + } > + } > + > ret = regmap_write(tcpci->regmap, TCPC_POWER_CTRL, > enable ? TCPC_POWER_CTRL_VCONN_ENABLE : 0); > if (ret < 0) > @@ -323,6 +351,15 @@ static int tcpci_init(struct tcpc_dev *tcpc) > if (time_after(jiffies, timeout)) > return -ETIMEDOUT; > > + /* Handle vendor init */ > + if (tcpci->data) { > + if (tcpci->data->init) { > + ret = tcpci->data->init(tcpci, tcpci->data); > + if (ret < 0) > + return ret; > + } > + } > + > /* Clear all events */ > ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff); > if (ret < 0) > @@ -344,9 +381,15 @@ static int tcpci_init(struct tcpc_dev *tcpc) > return tcpci_write16(tcpci, TCPC_ALERT_MASK, reg); > } > > -static irqreturn_t tcpci_irq(int irq, void *dev_id) > +static irqreturn_t _tcpci_irq(int irq, void *dev_id) > { > struct tcpci *tcpci = dev_id; > + > + return tcpci_irq(tcpci); > +} Hmm, normally I'd expect this function _after_ the function it calls. Guess that doesn't matter much here, so I am fine with it as long as Greg is ok with it as well. > + > +irqreturn_t tcpci_irq(struct tcpci *tcpci) > +{ > u16 status; > > tcpci_read16(tcpci, TCPC_ALERT, &status); > @@ -412,6 +455,7 @@ static irqreturn_t tcpci_irq(int irq, void *dev_id) > > return IRQ_HANDLED; > } > +EXPORT_SYMBOL_GPL(tcpci_irq); > > static const struct regmap_config tcpci_regmap_config = { > .reg_bits = 8, > @@ -435,22 +479,18 @@ static int tcpci_parse_config(struct tcpci *tcpci) > return 0; > } > > -static int tcpci_probe(struct i2c_client *client, > - const struct i2c_device_id *i2c_id) > +struct tcpci *tcpci_register_port(struct device *dev, struct tcpci_data *data) > { > struct tcpci *tcpci; > int err; > > - tcpci = devm_kzalloc(&client->dev, sizeof(*tcpci), GFP_KERNEL); > + tcpci = devm_kzalloc(dev, sizeof(*tcpci), GFP_KERNEL); > if (!tcpci) > - return -ENOMEM; > + return ERR_PTR(-ENOMEM); > > - tcpci->client = client; > - tcpci->dev = &client->dev; > - i2c_set_clientdata(client, tcpci); > - tcpci->regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config); > - if (IS_ERR(tcpci->regmap)) > - return PTR_ERR(tcpci->regmap); > + tcpci->dev = dev; > + tcpci->data = data; > + tcpci->regmap = data->regmap; > > tcpci->tcpc.init = tcpci_init; > tcpci->tcpc.get_vbus = tcpci_get_vbus; > @@ -467,27 +507,63 @@ static int tcpci_probe(struct i2c_client *client, > > err = tcpci_parse_config(tcpci); > if (err < 0) > - return err; > + return ERR_PTR(err); > + > + tcpci->port = tcpm_register_port(tcpci->dev, &tcpci->tcpc); > + if (PTR_ERR_OR_ZERO(tcpci->port)) > + return ERR_CAST(tcpci->port); > > - /* Disable chip interrupts */ > - tcpci_write16(tcpci, TCPC_ALERT_MASK, 0); > + return tcpci; > +} > +EXPORT_SYMBOL_GPL(tcpci_register_port); > + > +void tcpci_unregister_port(struct tcpci *tcpci) > +{ > + tcpm_unregister_port(tcpci->port); > +} > +EXPORT_SYMBOL_GPL(tcpci_unregister_port); > > - err = devm_request_threaded_irq(tcpci->dev, client->irq, NULL, > - tcpci_irq, > +static int tcpci_probe(struct i2c_client *client, > + const struct i2c_device_id *i2c_id) > +{ > + struct tcpci_chip *chip; > + int err; > + u16 val = 0; > + > + chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); > + if (!chip) > + return -ENOMEM; > + > + chip->data.regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config); > + if (IS_ERR(chip->data.regmap)) > + return PTR_ERR(chip->data.regmap); > + > + /* Disable chip interrupts before requesting irq */ > + err = regmap_raw_write(chip->data.regmap, TCPC_ALERT_MASK, &val, > + sizeof(u16)); > + if (err < 0) > + return err; > + > + err = devm_request_threaded_irq(&client->dev, client->irq, NULL, > + _tcpci_irq, > IRQF_ONESHOT | IRQF_TRIGGER_LOW, > - dev_name(tcpci->dev), tcpci); > + dev_name(&client->dev), chip); > if (err < 0) > return err; > > - tcpci->port = tcpm_register_port(tcpci->dev, &tcpci->tcpc); > - return PTR_ERR_OR_ZERO(tcpci->port); > + chip->tcpci = tcpci_register_port(&client->dev, &chip->data); > + if (PTR_ERR_OR_ZERO(chip->tcpci)) > + return PTR_ERR(chip->tcpci); > + > + i2c_set_clientdata(client, chip); > + return 0; > } > > static int tcpci_remove(struct i2c_client *client) > { > - struct tcpci *tcpci = i2c_get_clientdata(client); > + struct tcpci_chip *chip = i2c_get_clientdata(client); > > - tcpm_unregister_port(tcpci->port); > + tcpci_unregister_port(chip->tcpci); > > return 0; > } > diff --git a/drivers/staging/typec/tcpci.h b/drivers/staging/typec/tcpci.h > index fdfb06c..40025b2 100644 > --- a/drivers/staging/typec/tcpci.h > +++ b/drivers/staging/typec/tcpci.h > @@ -59,6 +59,7 @@ > #define TCPC_POWER_CTRL_VCONN_ENABLE BIT(0) > > #define TCPC_CC_STATUS 0x1d > +#define TCPC_CC_STATUS_DRPRST BIT(5) > #define TCPC_CC_STATUS_TERM BIT(4) > #define TCPC_CC_STATUS_CC2_SHIFT 2 > #define TCPC_CC_STATUS_CC2_MASK 0x3 > @@ -121,4 +122,16 @@ > #define TCPC_VBUS_VOLTAGE_ALARM_HI_CFG 0x76 > #define TCPC_VBUS_VOLTAGE_ALARM_LO_CFG 0x78 > > +struct tcpci; > +struct tcpci_data { > + struct regmap *regmap; > + int (*init)(struct tcpci *tcpci, struct tcpci_data *data); > + int (*set_vconn)(struct tcpci *tcpci, struct tcpci_data *data, > + bool enable); > +}; > + > +struct tcpci *tcpci_register_port(struct device *dev, struct tcpci_data *data); > +void tcpci_unregister_port(struct tcpci *tcpci); > +irqreturn_t tcpci_irq(struct tcpci *tcpci); > + > #endif /* __LINUX_USB_TCPCI_H */ > -- > 1.9.1 >