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: Heikki Krogerus Message-Id: <20180214105641.GE1480@kuha.fi.intel.com> Date: Wed, 14 Feb 2018 12:56:41 +0200 To: ShuFanLee Cc: linux@roeck-us.net, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, cy_huang@richtek.com, shufan_lee@richtek.com List-ID: T24gV2VkLCBGZWIgMTQsIDIwMTggYXQgMDU6MjQ6MDRQTSArMDgwMCwgU2h1RmFuTGVlIHdyb3Rl Ogo+IEZyb206IFNodUZhbkxlZSA8c2h1ZmFuX2xlZUByaWNodGVrLmNvbT4KPiAKPiBIYW5kbGUg dmVuZG9yIGRlZmluZWQgYmVoYXZpb3IgaW4gdGNwY2lfaW5pdCBhbmQgdGNwY2lfaXJxLgo+IE1v cmUgb3BlcmF0aW9ucyBjYW4gYmUgZXh0ZW5kZWQgaW4gdGNwY2lfdmVuZG9yX2RhdGEgaWYgbmVl ZGVkLgo+IEFjY29yZGluZyB0byBUQ1BDSSBzcGVjaWZpY2F0aW9uLCA0LjQuNS4yIFJPTEVfQ09O VFJPTCwKPiBUQ1BDIHNoYWxsIG5vdCBzdGFydCBEUlAgdG9nZ2xpbmcgdW50aWwgc3Vic2VxdWVu dGx5IHRoZSBUQ1BNCj4gd3JpdGVzIHRvIHRoZSBDT01NQU5EIHJlZ2lzdGVyIHRvIHN0YXJ0IERS UCB0b2dnbGluZy4KPiBEUlAgdG9nZ2xpbmcgZmxvdyBpcyBjaGFnbmVkIGFzIGZvbGxvd2luZzoK PiAgIC0gV3JpdGUgRFJQID0gMCAmIFJkL1JkCj4gICAtIFdyaXRlIERSUCA9IDEKPiAgIC0gU2V0 IExPT0s0Q09OTkVDVElPTiBjb21tYW5kCj4gCj4gU2lnbmVkLW9mZi1ieTogU2h1RmFuTGVlIDxz aHVmYW5fbGVlQHJpY2h0ZWsuY29tPgo+IC0tLQo+ICBkcml2ZXJzL3N0YWdpbmcvdHlwZWMvdGNw Y2kuYyB8IDk4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0KPiAg ZHJpdmVycy9zdGFnaW5nL3R5cGVjL3RjcGNpLmggfCAxNSArKysrKysrCj4gIDIgZmlsZXMgY2hh bmdlZCwgOTcgaW5zZXJ0aW9ucygrKSwgMTYgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvc3RhZ2luZy90eXBlYy90Y3BjaS5jIGIvZHJpdmVycy9zdGFnaW5nL3R5cGVjL3Rj cGNpLmMKPiBpbmRleCA5YmQ0NDEyLi5iM2E5N2IzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvc3Rh Z2luZy90eXBlYy90Y3BjaS5jCj4gKysrIGIvZHJpdmVycy9zdGFnaW5nL3R5cGVjL3RjcGNpLmMK PiBAQCAtMzAsNiArMzAsNyBAQCBzdHJ1Y3QgdGNwY2kgewo+ICAJYm9vbCBjb250cm9sc192YnVz Owo+ICAKPiAgCXN0cnVjdCB0Y3BjX2RldiB0Y3BjOwo+ICsJc3RydWN0IHRjcGNpX3ZlbmRvcl9k YXRhICp2ZGF0YTsKPiAgfTsKPiAgCj4gIHN0YXRpYyBpbmxpbmUgc3RydWN0IHRjcGNpICp0Y3Bj X3RvX3RjcGNpKHN0cnVjdCB0Y3BjX2RldiAqdGNwYykKPiBAQCAtMzcsMTYgKzM4LDI5IEBAIHN0 YXRpYyBpbmxpbmUgc3RydWN0IHRjcGNpICp0Y3BjX3RvX3RjcGNpKHN0cnVjdCB0Y3BjX2RldiAq dGNwYykKPiAgCXJldHVybiBjb250YWluZXJfb2YodGNwYywgc3RydWN0IHRjcGNpLCB0Y3BjKTsK PiAgfQo+ICAKPiAtc3RhdGljIGludCB0Y3BjaV9yZWFkMTYoc3RydWN0IHRjcGNpICp0Y3BjaSwg dW5zaWduZWQgaW50IHJlZywKPiAtCQkJdTE2ICp2YWwpCj4gK2ludCB0Y3BjaV9yZWFkMTYoc3Ry dWN0IHRjcGNpICp0Y3BjaSwgdW5zaWduZWQgaW50IHJlZywgdTE2ICp2YWwpCj4gIHsKPiAgCXJl dHVybiByZWdtYXBfcmF3X3JlYWQodGNwY2ktPnJlZ21hcCwgcmVnLCB2YWwsIHNpemVvZih1MTYp KTsKPiAgfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh0Y3BjaV9yZWFkMTYpOwo+ICAKPiAtc3RhdGlj IGludCB0Y3BjaV93cml0ZTE2KHN0cnVjdCB0Y3BjaSAqdGNwY2ksIHVuc2lnbmVkIGludCByZWcs IHUxNiB2YWwpCj4gK2ludCB0Y3BjaV93cml0ZTE2KHN0cnVjdCB0Y3BjaSAqdGNwY2ksIHVuc2ln bmVkIGludCByZWcsIHUxNiB2YWwpCj4gIHsKPiAgCXJldHVybiByZWdtYXBfcmF3X3dyaXRlKHRj cGNpLT5yZWdtYXAsIHJlZywgJnZhbCwgc2l6ZW9mKHUxNikpOwo+ICB9Cj4gK0VYUE9SVF9TWU1C T0xfR1BMKHRjcGNpX3dyaXRlMTYpOwo+ICsKPiAraW50IHRjcGNpX3JlYWQ4KHN0cnVjdCB0Y3Bj aSAqdGNwY2ksIHVuc2lnbmVkIGludCByZWcsIHU4ICp2YWwpCj4gK3sKPiArCXJldHVybiByZWdt YXBfcmF3X3JlYWQodGNwY2ktPnJlZ21hcCwgcmVnLCB2YWwsIHNpemVvZih1OCkpOwo+ICt9Cj4g K0VYUE9SVF9TWU1CT0xfR1BMKHRjcGNpX3JlYWQ4KTsKPiArCj4gK2ludCB0Y3BjaV93cml0ZTgo c3RydWN0IHRjcGNpICp0Y3BjaSwgdW5zaWduZWQgaW50IHJlZywgdTggdmFsKQo+ICt7Cj4gKwly ZXR1cm4gcmVnbWFwX3Jhd193cml0ZSh0Y3BjaS0+cmVnbWFwLCByZWcsICZ2YWwsIHNpemVvZih1 OCkpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHRjcGNpX3dyaXRlOCk7CgpJIGRvbid0IHRo aW5rIHRoZXJlIGlzIGFueSBuZWVkIHRvIGV4cG9ydCB0aG9zZSB3cmFwcGVycy4gWW91IGNhbgph bHdheXMgZXhwZWN0IHRoZSBnbHVlIGRyaXZlciB0byBzdXBwbHkgdGhlIHJlZ21hcCBhcyBtZW1i ZXIgb2YgdGhhdApzdHJ1Y3QgdGNwY2lfdmVuZG9yX2RhdGEuIFNlZSBiZWxvdy4uCgo+ICBzdGF0 aWMgaW50IHRjcGNpX3NldF9jYyhzdHJ1Y3QgdGNwY19kZXYgKnRjcGMsIGVudW0gdHlwZWNfY2Nf c3RhdHVzIGNjKQo+ICB7Cj4gQEAgLTk4LDggKzExMiwxMCBAQCBzdGF0aWMgaW50IHRjcGNpX3Nl dF9jYyhzdHJ1Y3QgdGNwY19kZXYgKnRjcGMsIGVudW0gdHlwZWNfY2Nfc3RhdHVzIGNjKQo+ICBz dGF0aWMgaW50IHRjcGNpX3N0YXJ0X2RycF90b2dnbGluZyhzdHJ1Y3QgdGNwY19kZXYgKnRjcGMs Cj4gIAkJCQkgICAgZW51bSB0eXBlY19jY19zdGF0dXMgY2MpCj4gIHsKPiArCWludCByZXQ7Cj4g IAlzdHJ1Y3QgdGNwY2kgKnRjcGNpID0gdGNwY190b190Y3BjaSh0Y3BjKTsKPiAtCXVuc2lnbmVk IGludCByZWcgPSBUQ1BDX1JPTEVfQ1RSTF9EUlA7Cj4gKwl1bnNpZ25lZCBpbnQgcmVnID0gKFRD UENfUk9MRV9DVFJMX0NDX1JEIDw8IFRDUENfUk9MRV9DVFJMX0NDMV9TSElGVCkgfAo+ICsJCQkg ICAoVENQQ19ST0xFX0NUUkxfQ0NfUkQgPDwgVENQQ19ST0xFX0NUUkxfQ0MyX1NISUZUKTsKPiAg Cj4gIAlzd2l0Y2ggKGNjKSB7Cj4gIAlkZWZhdWx0Ogo+IEBAIC0xMTYsOCArMTMyLDE5IEBAIHN0 YXRpYyBpbnQgdGNwY2lfc3RhcnRfZHJwX3RvZ2dsaW5nKHN0cnVjdCB0Y3BjX2RldiAqdGNwYywK PiAgCQkJVENQQ19ST0xFX0NUUkxfUlBfVkFMX1NISUZUKTsKPiAgCQlicmVhazsKPiAgCX0KPiAt Cj4gLQlyZXR1cm4gcmVnbWFwX3dyaXRlKHRjcGNpLT5yZWdtYXAsIFRDUENfUk9MRV9DVFJMLCBy ZWcpOwo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlKHRjcGNpLT5yZWdtYXAsIFRDUENfUk9MRV9DVFJM LCByZWcpOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCXVzbGVlcF9yYW5n ZSg1MDAsIDEwMDApOwo+ICsJcmVnIHw9IFRDUENfUk9MRV9DVFJMX0RSUDsKPiArCXJldCA9IHJl Z21hcF93cml0ZSh0Y3BjaS0+cmVnbWFwLCBUQ1BDX1JPTEVfQ1RSTCwgcmVnKTsKPiArCWlmIChy ZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwlyZXQgPSByZWdtYXBfd3JpdGUodGNwY2ktPnJl Z21hcCwgVENQQ19DT01NQU5ELAo+ICsJCQkgICBUQ1BDX0NNRF9MT09LNENPTk5FQ1RJT04pOwo+ ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ ICBzdGF0aWMgZW51bSB0eXBlY19jY19zdGF0dXMgdGNwY2lfdG9fdHlwZWNfY2ModW5zaWduZWQg aW50IGNjLCBib29sIHNpbmspCj4gQEAgLTMyMyw2ICszNTAsMTUgQEAgc3RhdGljIGludCB0Y3Bj aV9pbml0KHN0cnVjdCB0Y3BjX2RldiAqdGNwYykKPiAgCWlmICh0aW1lX2FmdGVyKGppZmZpZXMs IHRpbWVvdXQpKQo+ICAJCXJldHVybiAtRVRJTUVET1VUOwo+ICAKPiArCS8qIEhhbmRsZSB2ZW5k b3IgaW5pdCAqLwo+ICsJaWYgKHRjcGNpLT52ZGF0YSkgewo+ICsJCWlmICh0Y3BjaS0+dmRhdGEt PmluaXQpIHsKPiArCQkJcmV0ID0gKCp0Y3BjaS0+dmRhdGEtPmluaXQpKHRjcGNpLCB0Y3BjaS0+ dmRhdGEpOwoKcmV0ID0gdGNwY2ktPnZkYXRhLT5pbml0KC4uLgoKPiArCQkJaWYgKHJldCA8IDAp Cj4gKwkJCQlyZXR1cm4gcmV0Owo+ICsJCX0KPiArCX0KPiArCj4gIAkvKiBDbGVhciBhbGwgZXZl bnRzICovCj4gIAlyZXQgPSB0Y3BjaV93cml0ZTE2KHRjcGNpLCBUQ1BDX0FMRVJULCAweGZmZmYp Owo+ICAJaWYgKHJldCA8IDApCj4gQEAgLTM1MSw2ICszODcsMTMgQEAgc3RhdGljIGlycXJldHVy bl90IHRjcGNpX2lycShpbnQgaXJxLCB2b2lkICpkZXZfaWQpCj4gIAo+ICAJdGNwY2lfcmVhZDE2 KHRjcGNpLCBUQ1BDX0FMRVJULCAmc3RhdHVzKTsKPiAgCj4gKwkvKiBIYW5kbGUgdmVuZG9yIGRl ZmluZWQgaW50ZXJydXB0ICovCj4gKwlpZiAodGNwY2ktPnZkYXRhKSB7Cj4gKwkJaWYgKHRjcGNp LT52ZGF0YS0+aXJxX2hhbmRsZXIpCj4gKwkJCSgqdGNwY2ktPnZkYXRhLT5pcnFfaGFuZGxlciko dGNwY2ksIHRjcGNpLT52ZGF0YSwKPiArCQkJCQkJICAgICAmc3RhdHVzKTsKCkRpdHRvLgoKPiAr CX0KPiArCj4gIAkvKgo+ICAJICogQ2xlYXIgYWxlcnQgc3RhdHVzIGZvciBldmVyeXRoaW5nIGV4 Y2VwdCBSWF9TVEFUVVMsIHdoaWNoIHNob3VsZG4ndAo+ICAJICogYmUgY2xlYXJlZCB1bnRpbCB3 ZSBoYXZlIHN1Y2Nlc3NmdWxseSByZXRyaWV2ZWQgbWVzc2FnZS4KPiBAQCAtNDE3LDcgKzQ2MCw3 IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCB0Y3BjaV9pcnEoaW50IGlycSwgdm9pZCAqZGV2X2lkKQo+ ICAJLnJlZ19iaXRzID0gOCwKPiAgCS52YWxfYml0cyA9IDgsCj4gIAo+IC0JLm1heF9yZWdpc3Rl ciA9IDB4N0YsIC8qIDB4ODAgLi4gMHhGRiBhcmUgdmVuZG9yIGRlZmluZWQgKi8KPiArCS5tYXhf cmVnaXN0ZXIgPSAweEZGLCAvKiAweDgwIC4uIDB4RkYgYXJlIHZlbmRvciBkZWZpbmVkICovCj4g IH07Cj4gIAo+ICBzdGF0aWMgY29uc3Qgc3RydWN0IHRjcGNfY29uZmlnIHRjcGNpX3RjcGNfY29u ZmlnID0gewo+IEBAIC00MzUsMjIgKzQ3OCwyMiBAQCBzdGF0aWMgaW50IHRjcGNpX3BhcnNlX2Nv bmZpZyhzdHJ1Y3QgdGNwY2kgKnRjcGNpKQo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gLXN0YXRp YyBpbnQgdGNwY2lfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiAtCQkgICAgICAg Y29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmkyY19pZCkKPiArc3RydWN0IHRjcGNpICp0Y3Bj aV9yZWdpc3Rlcl9wb3J0KHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gKwkJCQkgIHN0cnVj dCB0Y3BjaV92ZW5kb3JfZGF0YSAqdmRhdGEpCgpzdHJ1Y3QgdGNwY2kgKnRjcGNpX3JlZ2lzdGVy X3BvcnQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgdGNwY2lfLi4uKQp7Ci4uLgoKPiAgewo+ ICAJc3RydWN0IHRjcGNpICp0Y3BjaTsKPiAgCWludCBlcnI7Cj4gIAo+ICAJdGNwY2kgPSBkZXZt X2t6YWxsb2MoJmNsaWVudC0+ZGV2LCBzaXplb2YoKnRjcGNpKSwgR0ZQX0tFUk5FTCk7Cj4gIAlp ZiAoIXRjcGNpKQo+IC0JCXJldHVybiAtRU5PTUVNOwo+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9N RU0pOwo+ICAKPiAgCXRjcGNpLT5jbGllbnQgPSBjbGllbnQ7CgpzdHJ1Y3QgdGNwY2kgZG9lcyBu b3QgbmVlZCB0aGF0ICJjbGllbnQiIG1lbWJlci4KCj4gIAl0Y3BjaS0+ZGV2ID0gJmNsaWVudC0+ ZGV2OwoKdGNwY2ktPmRldiA9IGRldjsKCj4gLQlpMmNfc2V0X2NsaWVudGRhdGEoY2xpZW50LCB0 Y3BjaSk7Cj4gKwl0Y3BjaS0+dmRhdGEgPSB2ZGF0YTsKPiAgCXRjcGNpLT5yZWdtYXAgPSBkZXZt X3JlZ21hcF9pbml0X2kyYyhjbGllbnQsICZ0Y3BjaV9yZWdtYXBfY29uZmlnKTsKCllvdSB3b3Vs ZCBub3cgZG8gdGhhdCBpbiB5b3VyIGdsdWUgZHJpdmVyLCBhbmQgaGVyZSBqdXN0OgoKdGNwY2kt PnJlZ21hcCA9IGRhdGEtPnJlZ21hcDsKCj4gIAl0Y3BjaS0+dGNwYy5pbml0ID0gdGNwY2lfaW5p dDsKPiAgCXRjcGNpLT50Y3BjLmdldF92YnVzID0gdGNwY2lfZ2V0X3ZidXM7Cj4gQEAgLTQ2Nyw3 ICs1MTAsNyBAQCBzdGF0aWMgaW50IHRjcGNpX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGll bnQsCj4gIAo+ICAJZXJyID0gdGNwY2lfcGFyc2VfY29uZmlnKHRjcGNpKTsKPiAgCWlmIChlcnIg PCAwKQo+IC0JCXJldHVybiBlcnI7Cj4gKwkJcmV0dXJuIEVSUl9QVFIoZXJyKTsKPiAgCj4gIAkv KiBEaXNhYmxlIGNoaXAgaW50ZXJydXB0cyAqLwo+ICAJdGNwY2lfd3JpdGUxNih0Y3BjaSwgVENQ Q19BTEVSVF9NQVNLLCAwKTsKPiBAQCAtNDc3LDE3ICs1MjAsNDAgQEAgc3RhdGljIGludCB0Y3Bj aV9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAo+ICAJCQkJCUlSUUZfT05FU0hPVCB8 IElSUUZfVFJJR0dFUl9MT1csCj4gIAkJCQkJZGV2X25hbWUodGNwY2ktPmRldiksIHRjcGNpKTsK ClRoZSBpbnRlcnJ1cHQgY291bGQgYWxzbyBiZSByZXF1ZXN0ZWQgaW4gdGhlIGdsdWUgZHJpdmVy LiBUaGVuIGZyb20KdGhlIGlycSByb3V0aW5lIGluIHlvdXIgZ2x1ZSBkcml2ZXIsIHlvdSBjYWxs IHRjcGNpX2lycSgpLiBUaGF0IHdvdWxkCm1lYW4geW91IGV4cG9ydCB0Y3BjaV9pcnEoKSBvZiBj b3Vyc2UuCgo+ICAJaWYgKGVyciA8IDApCj4gLQkJcmV0dXJuIGVycjsKPiArCQlyZXR1cm4gRVJS X1BUUihlcnIpOwo+ICAKPiAgCXRjcGNpLT5wb3J0ID0gdGNwbV9yZWdpc3Rlcl9wb3J0KHRjcGNp LT5kZXYsICZ0Y3BjaS0+dGNwYyk7Cj4gLQlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKHRjcGNpLT5w b3J0KTsKPiArCWlmIChQVFJfRVJSX09SX1pFUk8odGNwY2ktPnBvcnQpKQo+ICsJCXJldHVybiBF UlJfQ0FTVCh0Y3BjaS0+cG9ydCk7Cj4gKwo+ICsJcmV0dXJuIHRjcGNpOwo+ICt9Cj4gK0VYUE9S VF9TWU1CT0xfR1BMKHRjcGNpX3JlZ2lzdGVyX3BvcnQpOwo+ICsKPiArdm9pZCB0Y3BjaV91bnJl Z2lzdGVyX3BvcnQoc3RydWN0IHRjcGNpICp0Y3BjaSkKPiArewo+ICsJdGNwbV91bnJlZ2lzdGVy X3BvcnQodGNwY2ktPnBvcnQpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHRjcGNpX3VucmVn aXN0ZXJfcG9ydCk7Cj4gKwo+ICtzdGF0aWMgaW50IHRjcGNpX3Byb2JlKHN0cnVjdCBpMmNfY2xp ZW50ICpjbGllbnQsCj4gKwkJICAgICAgIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppMmNf aWQpCj4gK3sKPiArCXN0cnVjdCB0Y3BjaSAqdGNwY2k7Cj4gKwo+ICsJdGNwY2kgPSB0Y3BjaV9y ZWdpc3Rlcl9wb3J0KGNsaWVudCwgTlVMTCk7Cj4gKwlpZiAoUFRSX0VSUl9PUl9aRVJPKHRjcGNp KSkKPiArCQlyZXR1cm4gUFRSX0VSUih0Y3BjaSk7Cj4gKwo+ICsJaTJjX3NldF9jbGllbnRkYXRh KGNsaWVudCwgdGNwY2kpOwo+ICsJcmV0dXJuIDA7Cj4gIH0KClRoYXQgd291bGQgdGhlbiBsb29r IHNvbWV0aGluZyBsaWtlIHRoaXM6CgpzdGF0aWMgaW50IHRjcGNpX3Byb2JlKHN0cnVjdCBpMmNf Y2xpZW50ICpjbGllbnQuLi4KewogICAgICAgIHN0cnVjdCB0Y3BjaV9kYXRhIGRhdGE7IC8qIHMv dGNwY2lfdmVuZG9yX2RhdGEvdGNwY2lfZGF0YS8gKi8KICAgICAgICBzdHJ1Y3QgdGNwY2kgKnRj cGNpOwoKICAgICAgICBkYXRhLnJlZ21hcCA9IGRldm1fcmVnbWFwX2luaXRfaTJjKGNsaWVudCwg JnRjcGNpX3JlZ21hcF9jb25maWcpOwogICAgICAgIGlmIChJU19FUlIodGNwY2ktPnJlZ21hcCkp CiAgICAgICAgICAgICAgICByZXR1cm4gUFRSX0VSUih0Y3BjaS0+cmVnbWFwKTsKCiAgICAgICAg LyoKICAgICAgICAgKiBOT1RFOiBldmVyeXRoaW5nIGluIHN0cnVjdCB0Y3BjaV9kYXRhIHNob3Vs ZCBiZSBjb3BpZWQgaW4KICAgICAgICAgKiB0Y3BjaV9yZWdpc3Rlcl9wb3J0KCkuCiAgICAgICAg ICovCiAgICAgICAgdGNwY2kgPSB0Y3BjaV9yZWdpc3Rlcl9wb3J0KCZjbGllbnQtPmRldiwgJmRh dGEpOwogICAgICAgIGlmIChJU19FUlIodGNwY2kpKQogICAgICAgICAgICAgICAgcmV0dXJuIFBU Ul9FUlIodGNwY2kpOwoKICAgICAgICBkZXZtX3JlcXVlc3RfdGhyZWFkZWRfaXJxKCZjbGllbnQt PmRldiwgY2xpZW50LT5pcnEsIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0Y3BjaV9pcnEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuLi4KCiAgICAg ICAgaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgdGNwY2kpOwoKICAgICAgICByZXR1cm4gMDsK fQoKCkJyLAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-2578571-1518605822-2-18142111051925147140 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, HEADER_FROM_DIFFERENT_DOMAINS 0.001, ME_NOAUTH 0.01, RCVD_IN_DNSWL_HI -5, T_RP_MATCHES_RCVD -0.01, LANGUAGES roen, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='209.132.180.67', Host='vger.kernel.org', Country='US', FromHeader='com', MailFrom='org' X-Spam-charsets: plain='us-ascii' X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: linux-usb-owner@vger.kernel.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=arctest; t=1518605821; b=pwLWZClStkIHdDWsajGvVsfpsLMtPVhQLGNsQz+0zodJUcZ orBM4vTOlDui7Zx+krQVj1T4bh9C1slDPD5F/oZh3qF+hwU78yLYmjQ0avyN/KUu htSRK19136NwnHO2b659rAP9pO7otifXNADkS7uyJsBlaJrH2DUDOVXnNYd9isBL IUXsw8Zyu3ZOGq0DxK2ZtmWvllJDHal84hSam/6dXEHaZUjqUGY7iDr1VwDllVT1 UypykPjHUETgRc2fjzp7lNjqV78IxJo4bajTZ9Je6Vbb0PpUAb8gquKplViDhrZL jeOq13Pw7h+irGMq8JNdGgyATGwat0aWr15Ti9A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=date:from:to:cc:subject:message-id :references:mime-version:content-type:in-reply-to:sender :list-id; s=arctest; t=1518605821; bh=Tz1fjeNJjRDcJFVxPWRjrjpT34 cEgs443+tB888Zyhw=; b=vmjckvhRhVzGscQ3rhJoLh4XaHuadj6zMesQIWmH8Z 5v9I/bnXYSSraXh7hwSk7E9Y04MSgLKKs5GVHPQ+MTD0tbmvDyNJyTBHUwChMkQN DU12ierwkYSXgzQwH+pJ2gYj64Olqm7T8YHFbOY50whrluerCWIMKSrI2gXz54Xx VnKCqceLw29Ms+W0YYPS6JKNSGnOL1q8qrto702RrjodrN87USISwZOmj9nCYhhj gKcgXFSd/6bqT4Nlo3VUsrO9v7SVqD4z7t6oJK7h2IucfzeH6RoW6npSChdfzp5s ytLjJ0rq8Nk26q09+9rsyoI5JkXjryj3Jok5qnoQZ0zA== ARC-Authentication-Results: i=1; mx4.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linux.intel.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linux.intel.com header.result=pass header_org.domain=intel.com header_org.result=pass header_is_org_domain=no Authentication-Results: mx4.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=none (p=none,has-list-id=yes,d=none) header.from=linux.intel.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=linux.intel.com header.result=pass header_org.domain=intel.com header_org.result=pass header_is_org_domain=no Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S967247AbeBNK4r (ORCPT ); Wed, 14 Feb 2018 05:56:47 -0500 Received: from mga02.intel.com ([134.134.136.20]:3802 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S967159AbeBNK4q (ORCPT ); Wed, 14 Feb 2018 05:56:46 -0500 X-Amp-Result: UNSCANNABLE X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.46,512,1511856000"; d="scan'208";a="30662227" Date: Wed, 14 Feb 2018 12:56:41 +0200 From: Heikki Krogerus To: ShuFanLee Cc: linux@roeck-us.net, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, cy_huang@richtek.com, shufan_lee@richtek.com Subject: Re: [PATCH] staging: typec: handle vendor defined part and modify drp toggling flow Message-ID: <20180214105641.GE1480@kuha.fi.intel.com> References: <1518600244-29949-1-git-send-email-leechu729@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1518600244-29949-1-git-send-email-leechu729@gmail.com> User-Agent: Mutt/1.9.2 (2017-12-15) Sender: linux-usb-owner@vger.kernel.org X-Mailing-List: linux-usb@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: On Wed, Feb 14, 2018 at 05:24:04PM +0800, ShuFanLee wrote: > From: ShuFanLee > > Handle vendor defined behavior in tcpci_init and tcpci_irq. > More operations can be extended in tcpci_vendor_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 > --- > drivers/staging/typec/tcpci.c | 98 ++++++++++++++++++++++++++++++++++++------- > drivers/staging/typec/tcpci.h | 15 +++++++ > 2 files changed, 97 insertions(+), 16 deletions(-) > > diff --git a/drivers/staging/typec/tcpci.c b/drivers/staging/typec/tcpci.c > index 9bd4412..b3a97b3 100644 > --- a/drivers/staging/typec/tcpci.c > +++ b/drivers/staging/typec/tcpci.c > @@ -30,6 +30,7 @@ struct tcpci { > bool controls_vbus; > > struct tcpc_dev tcpc; > + struct tcpci_vendor_data *vdata; > }; > > static inline struct tcpci *tcpc_to_tcpci(struct tcpc_dev *tcpc) > @@ -37,16 +38,29 @@ 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) > +int tcpci_read16(struct tcpci *tcpci, unsigned int reg, u16 *val) > { > return regmap_raw_read(tcpci->regmap, reg, val, sizeof(u16)); > } > +EXPORT_SYMBOL_GPL(tcpci_read16); > > -static int tcpci_write16(struct tcpci *tcpci, unsigned int reg, u16 val) > +int tcpci_write16(struct tcpci *tcpci, unsigned int reg, u16 val) > { > return regmap_raw_write(tcpci->regmap, reg, &val, sizeof(u16)); > } > +EXPORT_SYMBOL_GPL(tcpci_write16); > + > +int tcpci_read8(struct tcpci *tcpci, unsigned int reg, u8 *val) > +{ > + return regmap_raw_read(tcpci->regmap, reg, val, sizeof(u8)); > +} > +EXPORT_SYMBOL_GPL(tcpci_read8); > + > +int tcpci_write8(struct tcpci *tcpci, unsigned int reg, u8 val) > +{ > + return regmap_raw_write(tcpci->regmap, reg, &val, sizeof(u8)); > +} > +EXPORT_SYMBOL_GPL(tcpci_write8); I don't think there is any need to export those wrappers. You can always expect the glue driver to supply the regmap as member of that struct tcpci_vendor_data. See below.. > static int tcpci_set_cc(struct tcpc_dev *tcpc, enum typec_cc_status cc) > { > @@ -98,8 +112,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: > @@ -116,8 +132,19 @@ static int tcpci_start_drp_toggling(struct tcpc_dev *tcpc, > TCPC_ROLE_CTRL_RP_VAL_SHIFT); > 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; > } > > static enum typec_cc_status tcpci_to_typec_cc(unsigned int cc, bool sink) > @@ -323,6 +350,15 @@ static int tcpci_init(struct tcpc_dev *tcpc) > if (time_after(jiffies, timeout)) > return -ETIMEDOUT; > > + /* Handle vendor init */ > + if (tcpci->vdata) { > + if (tcpci->vdata->init) { > + ret = (*tcpci->vdata->init)(tcpci, tcpci->vdata); ret = tcpci->vdata->init(... > + if (ret < 0) > + return ret; > + } > + } > + > /* Clear all events */ > ret = tcpci_write16(tcpci, TCPC_ALERT, 0xffff); > if (ret < 0) > @@ -351,6 +387,13 @@ static irqreturn_t tcpci_irq(int irq, void *dev_id) > > tcpci_read16(tcpci, TCPC_ALERT, &status); > > + /* Handle vendor defined interrupt */ > + if (tcpci->vdata) { > + if (tcpci->vdata->irq_handler) > + (*tcpci->vdata->irq_handler)(tcpci, tcpci->vdata, > + &status); Ditto. > + } > + > /* > * Clear alert status for everything except RX_STATUS, which shouldn't > * be cleared until we have successfully retrieved message. > @@ -417,7 +460,7 @@ static irqreturn_t tcpci_irq(int irq, void *dev_id) > .reg_bits = 8, > .val_bits = 8, > > - .max_register = 0x7F, /* 0x80 .. 0xFF are vendor defined */ > + .max_register = 0xFF, /* 0x80 .. 0xFF are vendor defined */ > }; > > static const struct tcpc_config tcpci_tcpc_config = { > @@ -435,22 +478,22 @@ 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 i2c_client *client, > + struct tcpci_vendor_data *vdata) struct tcpci *tcpci_register_port(struct device *dev, struct tcpci_...) { ... > { > struct tcpci *tcpci; > int err; > > tcpci = devm_kzalloc(&client->dev, sizeof(*tcpci), GFP_KERNEL); > if (!tcpci) > - return -ENOMEM; > + return ERR_PTR(-ENOMEM); > > tcpci->client = client; struct tcpci does not need that "client" member. > tcpci->dev = &client->dev; tcpci->dev = dev; > - i2c_set_clientdata(client, tcpci); > + tcpci->vdata = vdata; > tcpci->regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config); You would now do that in your glue driver, and here just: tcpci->regmap = data->regmap; > tcpci->tcpc.init = tcpci_init; > tcpci->tcpc.get_vbus = tcpci_get_vbus; > @@ -467,7 +510,7 @@ static int tcpci_probe(struct i2c_client *client, > > err = tcpci_parse_config(tcpci); > if (err < 0) > - return err; > + return ERR_PTR(err); > > /* Disable chip interrupts */ > tcpci_write16(tcpci, TCPC_ALERT_MASK, 0); > @@ -477,17 +520,40 @@ static int tcpci_probe(struct i2c_client *client, > IRQF_ONESHOT | IRQF_TRIGGER_LOW, > dev_name(tcpci->dev), tcpci); The interrupt could also be requested in the glue driver. Then from the irq routine in your glue driver, you call tcpci_irq(). That would mean you export tcpci_irq() of course. > if (err < 0) > - return err; > + return ERR_PTR(err); > > tcpci->port = tcpm_register_port(tcpci->dev, &tcpci->tcpc); > - return PTR_ERR_OR_ZERO(tcpci->port); > + if (PTR_ERR_OR_ZERO(tcpci->port)) > + return ERR_CAST(tcpci->port); > + > + 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); > + > +static int tcpci_probe(struct i2c_client *client, > + const struct i2c_device_id *i2c_id) > +{ > + struct tcpci *tcpci; > + > + tcpci = tcpci_register_port(client, NULL); > + if (PTR_ERR_OR_ZERO(tcpci)) > + return PTR_ERR(tcpci); > + > + i2c_set_clientdata(client, tcpci); > + return 0; > } That would then look something like this: static int tcpci_probe(struct i2c_client *client... { struct tcpci_data data; /* s/tcpci_vendor_data/tcpci_data/ */ struct tcpci *tcpci; data.regmap = devm_regmap_init_i2c(client, &tcpci_regmap_config); if (IS_ERR(tcpci->regmap)) return PTR_ERR(tcpci->regmap); /* * NOTE: everything in struct tcpci_data should be copied in * tcpci_register_port(). */ tcpci = tcpci_register_port(&client->dev, &data); if (IS_ERR(tcpci)) return PTR_ERR(tcpci); devm_request_threaded_irq(&client->dev, client->irq, NULL, tcpci_irq, ... i2c_set_clientdata(client, tcpci); return 0; } Br, -- heikki