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: [v3,2/4] usb: chipidea: imx: add HSIC support From: Peter Chen Message-Id: <20181127092824.22756-3-peter.chen@nxp.com> Date: Tue, 27 Nov 2018 09:30:56 +0000 To: "linux-usb@vger.kernel.org" Cc: dl-linux-imx , "robh+dt@kernel.org" , "devicetree@vger.kernel.org" , "frieder.schrempf@exceet.de" , "festevam@gmail.com" , PETER CHEN List-ID: VG8gc3VwcG9ydCBpbXggSFNJQywgdGhlcmUgYXJlIHNvbWUgc3BlY2lhbCByZXF1aXJlbWVudDoK LSBUaGUgSFNJQyBwYWQgaXMgMS4ydiwgaXQgbWF5IG5lZWQgdG8gc3VwcGx5IGZyb20gZXh0ZXJu YWwKLSBUaGUgZGF0YS9zdHJvYmUgcGluIG5lZWRzIHRvIGJlIHB1bGxlZCBkb3duIGZpcnN0LCBh bmQgYWZ0ZXIKICBob3N0IG1vZGUgaXMgaW5pdGlhbGl6ZWQsIHRoZSBzdHJvYmUgcGluIG5lZWRz IHRvIGJlIHB1bGxlZCB1cAotIER1cmluZyB0aGUgVVNCIHN1c3BlbmQvcmVzdW1lLCBzcGVjaWFs IHNldHRpbmcgaXMgbmVlZGVkCgpTaWduZWQtb2ZmLWJ5OiBQZXRlciBDaGVuIDxwZXRlci5jaGVu QG54cC5jb20+Ci0tLQogZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguYyB8IDE0MCAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tCiBkcml2ZXJzL3VzYi9jaGlwaWRl YS9jaV9oZHJjX2lteC5oIHwgICA5ICsrLQogZHJpdmVycy91c2IvY2hpcGlkZWEvdXNibWlzY19p bXguYyB8IDE0MCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVz IGNoYW5nZWQsIDI3MCBpbnNlcnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9kcml2ZXJzL3VzYi9jaGlwaWRlYS9jaV9oZHJjX2lteC5jIGIvZHJpdmVycy91c2IvY2hpcGlk ZWEvY2lfaGRyY19pbXguYwppbmRleCAwOWIzN2MwZDA3NWQuLjU2NzgxYzMyOWRiMCAxMDA2NDQK LS0tIGEvZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguYworKysgYi9kcml2ZXJzL3Vz Yi9jaGlwaWRlYS9jaV9oZHJjX2lteC5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSA8bGlu dXgvdXNiL2NoaXBpZGVhLmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL29mLmg+CiAjaW5jbHVkZSA8 bGludXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgvcGluY3RybC9jb25zdW1lci5oPgogCiAjaW5j bHVkZSAiY2kuaCIKICNpbmNsdWRlICJjaV9oZHJjX2lteC5oIgpAQCAtODUsNiArODYsOSBAQCBz dHJ1Y3QgY2lfaGRyY19pbXhfZGF0YSB7CiAJYm9vbCBzdXBwb3J0c19ydW50aW1lX3BtOwogCWJv b2wgb3ZlcnJpZGVfcGh5X2NvbnRyb2w7CiAJYm9vbCBpbl9scG07CisJc3RydWN0IHBpbmN0cmwg KnBpbmN0cmw7CisJc3RydWN0IHBpbmN0cmxfc3RhdGUgKnBpbmN0cmxfaHNpY19hY3RpdmU7CisJ c3RydWN0IHJlZ3VsYXRvciAqaHNpY19wYWRfcmVndWxhdG9yOwogCS8qIFNvQyBiZWZvcmUgaS5t eDYgKGV4Y2VwdCBpbXgyMy9pbXgyOCkgbmVlZHMgdGhyZWUgY2xrcyAqLwogCWJvb2wgbmVlZF90 aHJlZV9jbGtzOwogCXN0cnVjdCBjbGsgKmNsa19pcGc7CkBAIC0yNDUsMTkgKzI0OSw0OSBAQCBz dGF0aWMgdm9pZCBpbXhfZGlzYWJsZV91bnByZXBhcmVfY2xrcyhzdHJ1Y3QgZGV2aWNlICpkZXYp CiAJfQogfQogCitzdGF0aWMgaW50IGNpX2hkcmNfaW14X25vdGlmeV9ldmVudChzdHJ1Y3QgY2lf aGRyYyAqY2ksIHVuc2lnbmVkIGludCBldmVudCkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBj aS0+ZGV2LT5wYXJlbnQ7CisJc3RydWN0IGNpX2hkcmNfaW14X2RhdGEgKmRhdGEgPSBkZXZfZ2V0 X2RydmRhdGEoZGV2KTsKKwlpbnQgcmV0ID0gMDsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNl IENJX0hEUkNfSU1YX0hTSUNfQUNUSVZFX0VWRU5UOgorCQlyZXQgPSBwaW5jdHJsX3NlbGVjdF9z dGF0ZShkYXRhLT5waW5jdHJsLAorCQkJCWRhdGEtPnBpbmN0cmxfaHNpY19hY3RpdmUpOworCQlp ZiAocmV0KQorCQkJZGV2X2VycihkZXYsICJoc2ljX2FjdGl2ZSBzZWxlY3QgZmFpbGVkLCBlcnI9 JWRcbiIsCisJCQkJcmV0KTsKKwkJYnJlYWs7CisJY2FzZSBDSV9IRFJDX0lNWF9IU0lDX1NVU1BF TkRfRVZFTlQ6CisJCXJldCA9IGlteF91c2JtaXNjX2hzaWNfc2V0X2Nvbm5lY3QoZGF0YS0+dXNi bWlzY19kYXRhKTsKKwkJaWYgKHJldCkKKwkJCWRldl9lcnIoZGV2LAorCQkJCSJoc2ljX3NldF9j b25uZWN0IGZhaWxlZCwgZXJyPSVkXG4iLCByZXQpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQli cmVhazsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCiBzdGF0aWMgaW50IGNpX2hkcmNfaW14X3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IGNpX2hkcmNfaW14 X2RhdGEgKmRhdGE7CiAJc3RydWN0IGNpX2hkcmNfcGxhdGZvcm1fZGF0YSBwZGF0YSA9IHsKIAkJ Lm5hbWUJCT0gZGV2X25hbWUoJnBkZXYtPmRldiksCiAJCS5jYXBvZmZzZXQJPSBERUZfQ0FQT0ZG U0VULAorCQkubm90aWZ5X2V2ZW50CT0gY2lfaGRyY19pbXhfbm90aWZ5X2V2ZW50LAogCX07CiAJ aW50IHJldDsKIAljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICpvZl9pZDsKIAljb25zdCBzdHJ1 Y3QgY2lfaGRyY19pbXhfcGxhdGZvcm1fZmxhZyAqaW14X3BsYXRmb3JtX2ZsYWc7CiAJc3RydWN0 IGRldmljZV9ub2RlICpucCA9IHBkZXYtPmRldi5vZl9ub2RlOworCXN0cnVjdCBkZXZpY2UgKmRl diA9ICZwZGV2LT5kZXY7CisJc3RydWN0IHBpbmN0cmxfc3RhdGUgKnBpbmN0cmxfaHNpY19pZGxl OwogCi0Jb2ZfaWQgPSBvZl9tYXRjaF9kZXZpY2UoY2lfaGRyY19pbXhfZHRfaWRzLCAmcGRldi0+ ZGV2KTsKKwlvZl9pZCA9IG9mX21hdGNoX2RldmljZShjaV9oZHJjX2lteF9kdF9pZHMsIGRldik7 CiAJaWYgKCFvZl9pZCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKQEAgLTI2OCwxOSArMzAyLDczIEBA IHN0YXRpYyBpbnQgY2lfaGRyY19pbXhfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRl dikKIAkJcmV0dXJuIC1FTk9NRU07CiAKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYXRh KTsKLQlkYXRhLT51c2JtaXNjX2RhdGEgPSB1c2JtaXNjX2dldF9pbml0X2RhdGEoJnBkZXYtPmRl dik7CisJZGF0YS0+dXNibWlzY19kYXRhID0gdXNibWlzY19nZXRfaW5pdF9kYXRhKGRldik7CiAJ aWYgKElTX0VSUihkYXRhLT51c2JtaXNjX2RhdGEpKQogCQlyZXR1cm4gUFRSX0VSUihkYXRhLT51 c2JtaXNjX2RhdGEpOwogCi0JcmV0ID0gaW14X2dldF9jbGtzKCZwZGV2LT5kZXYpOworCWlmIChv Zl91c2JfZ2V0X3BoeV9tb2RlKGRldi0+b2Zfbm9kZSkgPT0gVVNCUEhZX0lOVEVSRkFDRV9NT0RF X0hTSUMpIHsKKwkJcGRhdGEuZmxhZ3MgfD0gQ0lfSERSQ19JTVhfSVNfSFNJQzsKKwkJZGF0YS0+ dXNibWlzY19kYXRhLT5oc2ljID0gMTsKKwkJZGF0YS0+cGluY3RybCA9IGRldm1fcGluY3RybF9n ZXQoZGV2KTsKKwkJaWYgKElTX0VSUihkYXRhLT5waW5jdHJsKSkgeworCQkJZGV2X2VycihkZXYs ICJwaW5jdHJsIGdldCBmYWlsZWQsIGVycj0lbGRcbiIsCisJCQkJCVBUUl9FUlIoZGF0YS0+cGlu Y3RybCkpOworCQkJcmV0dXJuIFBUUl9FUlIoZGF0YS0+cGluY3RybCk7CisJCX0KKworCQlwaW5j dHJsX2hzaWNfaWRsZSA9IHBpbmN0cmxfbG9va3VwX3N0YXRlKGRhdGEtPnBpbmN0cmwsICJpZGxl Iik7CisJCWlmIChJU19FUlIocGluY3RybF9oc2ljX2lkbGUpKSB7CisJCQlkZXZfZXJyKGRldiwK KwkJCQkicGluY3RybF9oc2ljX2lkbGUgbG9va3VwIGZhaWxlZCwgZXJyPSVsZFxuIiwKKwkJCQkJ UFRSX0VSUihwaW5jdHJsX2hzaWNfaWRsZSkpOworCQkJcmV0dXJuIFBUUl9FUlIocGluY3RybF9o c2ljX2lkbGUpOworCQl9CisKKwkJcmV0ID0gcGluY3RybF9zZWxlY3Rfc3RhdGUoZGF0YS0+cGlu Y3RybCwgcGluY3RybF9oc2ljX2lkbGUpOworCQlpZiAocmV0KSB7CisJCQlkZXZfZXJyKGRldiwg ImhzaWNfaWRsZSBzZWxlY3QgZmFpbGVkLCBlcnI9JWRcbiIsIHJldCk7CisJCQlyZXR1cm4gcmV0 OworCQl9CisKKwkJZGF0YS0+cGluY3RybF9oc2ljX2FjdGl2ZSA9IHBpbmN0cmxfbG9va3VwX3N0 YXRlKGRhdGEtPnBpbmN0cmwsCisJCQkJCQkJCSJhY3RpdmUiKTsKKwkJaWYgKElTX0VSUihkYXRh LT5waW5jdHJsX2hzaWNfYWN0aXZlKSkgeworCQkJZGV2X2VycihkZXYsCisJCQkJInBpbmN0cmxf aHNpY19hY3RpdmUgbG9va3VwIGZhaWxlZCwgZXJyPSVsZFxuIiwKKwkJCQkJUFRSX0VSUihkYXRh LT5waW5jdHJsX2hzaWNfYWN0aXZlKSk7CisJCQlyZXR1cm4gUFRSX0VSUihkYXRhLT5waW5jdHJs X2hzaWNfYWN0aXZlKTsKKwkJfQorCisJCWRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvciA9IGRldm1f cmVndWxhdG9yX2dldChkZXYsICJoc2ljIik7CisJCWlmIChQVFJfRVJSKGRhdGEtPmhzaWNfcGFk X3JlZ3VsYXRvcikgPT0gLUVQUk9CRV9ERUZFUikgeworCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7 CisJCX0gZWxzZSBpZiAoUFRSX0VSUihkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpID09IC1FTk9E RVYpIHsKKwkJCS8qIG5vIHBhZCByZWd1YWxhdG9yIGlzIG5lZWRlZCAqLworCQkJZGF0YS0+aHNp Y19wYWRfcmVndWxhdG9yID0gTlVMTDsKKwkJfSBlbHNlIGlmIChJU19FUlIoZGF0YS0+aHNpY19w YWRfcmVndWxhdG9yKSkgeworCQkJZGV2X2VycihkZXYsICJHZXQgSFNJQyBwYWQgcmVndWxhdG9y IGVycm9yOiAlbGRcbiIsCisJCQkJCVBUUl9FUlIoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKSk7 CisJCQlyZXR1cm4gUFRSX0VSUihkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOworCQl9CisKKwkJ aWYgKGRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvcikgeworCQkJcmV0ID0gcmVndWxhdG9yX2VuYWJs ZShkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOworCQkJaWYgKHJldCkgeworCQkJCWRldl9lcnIo ZGV2LAorCQkJCQkiRmFpbGVkIHRvIGVuYWJsZSBIU0lDIHBhZCByZWd1bGF0b3JcbiIpOworCQkJ CXJldHVybiByZXQ7CisJCQl9CisJCX0KKwl9CisJcmV0ID0gaW14X2dldF9jbGtzKGRldik7CiAJ aWYgKHJldCkKLQkJcmV0dXJuIHJldDsKKwkJZ290byBkaXNhYmxlX2hzaWNfcmVndWxhdG9yOwog Ci0JcmV0ID0gaW14X3ByZXBhcmVfZW5hYmxlX2Nsa3MoJnBkZXYtPmRldik7CisJcmV0ID0gaW14 X3ByZXBhcmVfZW5hYmxlX2Nsa3MoZGV2KTsKIAlpZiAocmV0KQotCQlyZXR1cm4gcmV0OworCQln b3RvIGRpc2FibGVfaHNpY19yZWd1bGF0b3I7CiAKLQlkYXRhLT5waHkgPSBkZXZtX3VzYl9nZXRf cGh5X2J5X3BoYW5kbGUoJnBkZXYtPmRldiwgImZzbCx1c2JwaHkiLCAwKTsKKwlkYXRhLT5waHkg PSBkZXZtX3VzYl9nZXRfcGh5X2J5X3BoYW5kbGUoZGV2LCAiZnNsLHVzYnBoeSIsIDApOwogCWlm IChJU19FUlIoZGF0YS0+cGh5KSkgewogCQlyZXQgPSBQVFJfRVJSKGRhdGEtPnBoeSk7CiAJCS8q IFJldHVybiAtRUlOVkFMIGlmIG5vIHVzYnBoeSBpcyBhdmFpbGFibGUgKi8KQEAgLTMwNSw0MCAr MzkzLDQzIEBAIHN0YXRpYyBpbnQgY2lfaGRyY19pbXhfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKIAogCXJldCA9IGlteF91c2JtaXNjX2luaXQoZGF0YS0+dXNibWlzY19kYXRh KTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgInVzYm1pc2MgaW5pdCBmYWls ZWQsIHJldD0lZFxuIiwgcmV0KTsKKwkJZGV2X2VycihkZXYsICJ1c2JtaXNjIGluaXQgZmFpbGVk LCByZXQ9JWRcbiIsIHJldCk7CiAJCWdvdG8gZXJyX2NsazsKIAl9CiAKLQlkYXRhLT5jaV9wZGV2 ID0gY2lfaGRyY19hZGRfZGV2aWNlKCZwZGV2LT5kZXYsCisJZGF0YS0+Y2lfcGRldiA9IGNpX2hk cmNfYWRkX2RldmljZShkZXYsCiAJCQkJcGRldi0+cmVzb3VyY2UsIHBkZXYtPm51bV9yZXNvdXJj ZXMsCiAJCQkJJnBkYXRhKTsKIAlpZiAoSVNfRVJSKGRhdGEtPmNpX3BkZXYpKSB7CiAJCXJldCA9 IFBUUl9FUlIoZGF0YS0+Y2lfcGRldik7CiAJCWlmIChyZXQgIT0gLUVQUk9CRV9ERUZFUikKLQkJ CWRldl9lcnIoJnBkZXYtPmRldiwKLQkJCQkiY2lfaGRyY19hZGRfZGV2aWNlIGZhaWxlZCwgZXJy PSVkXG4iLCByZXQpOworCQkJZGV2X2VycihkZXYsICJjaV9oZHJjX2FkZF9kZXZpY2UgZmFpbGVk LCBlcnI9JWRcbiIsCisJCQkJCXJldCk7CiAJCWdvdG8gZXJyX2NsazsKIAl9CiAKIAlyZXQgPSBp bXhfdXNibWlzY19pbml0X3Bvc3QoZGF0YS0+dXNibWlzY19kYXRhKTsKIAlpZiAocmV0KSB7Ci0J CWRldl9lcnIoJnBkZXYtPmRldiwgInVzYm1pc2MgcG9zdCBmYWlsZWQsIHJldD0lZFxuIiwgcmV0 KTsKKwkJZGV2X2VycihkZXYsICJ1c2JtaXNjIHBvc3QgZmFpbGVkLCByZXQ9JWRcbiIsIHJldCk7 CiAJCWdvdG8gZGlzYWJsZV9kZXZpY2U7CiAJfQogCiAJaWYgKGRhdGEtPnN1cHBvcnRzX3J1bnRp bWVfcG0pIHsKLQkJcG1fcnVudGltZV9zZXRfYWN0aXZlKCZwZGV2LT5kZXYpOwotCQlwbV9ydW50 aW1lX2VuYWJsZSgmcGRldi0+ZGV2KTsKKwkJcG1fcnVudGltZV9zZXRfYWN0aXZlKGRldik7CisJ CXBtX3J1bnRpbWVfZW5hYmxlKGRldik7CiAJfQogCi0JZGV2aWNlX3NldF93YWtldXBfY2FwYWJs ZSgmcGRldi0+ZGV2LCB0cnVlKTsKKwlkZXZpY2Vfc2V0X3dha2V1cF9jYXBhYmxlKGRldiwgdHJ1 ZSk7CiAKIAlyZXR1cm4gMDsKIAogZGlzYWJsZV9kZXZpY2U6CiAJY2lfaGRyY19yZW1vdmVfZGV2 aWNlKGRhdGEtPmNpX3BkZXYpOwogZXJyX2NsazoKLQlpbXhfZGlzYWJsZV91bnByZXBhcmVfY2xr cygmcGRldi0+ZGV2KTsKKwlpbXhfZGlzYWJsZV91bnByZXBhcmVfY2xrcyhkZXYpOworZGlzYWJs ZV9oc2ljX3JlZ3VsYXRvcjoKKwlpZiAoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKQorCQlyZXQg PSByZWd1bGF0b3JfZGlzYWJsZShkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOwogCXJldHVybiBy ZXQ7CiB9CiAKQEAgLTM1NSw2ICs0NDYsOCBAQCBzdGF0aWMgaW50IGNpX2hkcmNfaW14X3JlbW92 ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChkYXRhLT5vdmVycmlkZV9waHlf Y29udHJvbCkKIAkJdXNiX3BoeV9zaHV0ZG93bihkYXRhLT5waHkpOwogCWlteF9kaXNhYmxlX3Vu cHJlcGFyZV9jbGtzKCZwZGV2LT5kZXYpOworCWlmIChkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3Ip CisJCXJlZ3VsYXRvcl9kaXNhYmxlKGRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvcik7CiAKIAlyZXR1 cm4gMDsKIH0KQEAgLTM2Nyw5ICs0NjAsMTYgQEAgc3RhdGljIHZvaWQgY2lfaGRyY19pbXhfc2h1 dGRvd24oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHN0YXRpYyBpbnQgX19tYXliZV91 bnVzZWQgaW14X2NvbnRyb2xsZXJfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3Ry dWN0IGNpX2hkcmNfaW14X2RhdGEgKmRhdGEgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKKwlpbnQg cmV0ID0gMDsKIAogCWRldl9kYmcoZGV2LCAiYXQgJXNcbiIsIF9fZnVuY19fKTsKIAorCXJldCA9 IGlteF91c2JtaXNjX2hzaWNfc2V0X2NsayhkYXRhLT51c2JtaXNjX2RhdGEsIGZhbHNlKTsKKwlp ZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAidXNibWlzYyBoc2ljX3NldF9jbGsgZmFpbGVkLCBy ZXQ9JWRcbiIsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCiAJaW14X2Rpc2FibGVfdW5wcmVw YXJlX2Nsa3MoZGV2KTsKIAlkYXRhLT5pbl9scG0gPSB0cnVlOwogCkBAIC00MDAsOCArNTAwLDE2 IEBAIHN0YXRpYyBpbnQgX19tYXliZV91bnVzZWQgaW14X2NvbnRyb2xsZXJfcmVzdW1lKHN0cnVj dCBkZXZpY2UgKmRldikKIAkJZ290byBjbGtfZGlzYWJsZTsKIAl9CiAKKwlyZXQgPSBpbXhfdXNi bWlzY19oc2ljX3NldF9jbGsoZGF0YS0+dXNibWlzY19kYXRhLCB0cnVlKTsKKwlpZiAocmV0KSB7 CisJCWRldl9lcnIoZGV2LCAidXNibWlzYyBoc2ljX3NldF9jbGsgZmFpbGVkLCByZXQ9JWRcbiIs IHJldCk7CisJCWdvdG8gaHNpY19zZXRfY2xrX2ZhaWw7CisJfQorCiAJcmV0dXJuIDA7CiAKK2hz aWNfc2V0X2Nsa19mYWlsOgorCWlteF91c2JtaXNjX3NldF93YWtldXAoZGF0YS0+dXNibWlzY19k YXRhLCB0cnVlKTsKIGNsa19kaXNhYmxlOgogCWlteF9kaXNhYmxlX3VucHJlcGFyZV9jbGtzKGRl dik7CiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NoaXBpZGVhL2NpX2hk cmNfaW14LmggYi9kcml2ZXJzL3VzYi9jaGlwaWRlYS9jaV9oZHJjX2lteC5oCmluZGV4IDIwNDI3 NWY0NzU3My4uZmNlY2FiNDc4OTM0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jaGlwaWRlYS9j aV9oZHJjX2lteC5oCisrKyBiL2RyaXZlcnMvdXNiL2NoaXBpZGVhL2NpX2hkcmNfaW14LmgKQEAg LTE0LDEwICsxNCwxMyBAQCBzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSB7CiAJdW5zaWduZWQgaW50 IG9jX3BvbGFyaXR5OjE7IC8qIG92ZXIgY3VycmVudCBwb2xhcml0eSBpZiBvYyBlbmFibGVkICov CiAJdW5zaWduZWQgaW50IGV2ZG86MTsgLyogc2V0IGV4dGVybmFsIHZidXMgZGl2aWRlciBvcHRp b24gKi8KIAl1bnNpZ25lZCBpbnQgdWxwaToxOyAvKiBjb25uZWN0ZWQgdG8gYW4gVUxQSSBwaHkg Ki8KKwl1bnNpZ25lZCBpbnQgaHNpYzoxOyAvKiBIU0lDIGNvbnRyb2xsbGVyICovCiB9OwogCi1p bnQgaW14X3VzYm1pc2NfaW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqKTsKLWludCBpbXhf dXNibWlzY19pbml0X3Bvc3Qoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKik7Ci1pbnQgaW14X3Vz Ym1pc2Nfc2V0X3dha2V1cChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqLCBib29sKTsKK2ludCBp bXhfdXNibWlzY19pbml0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKTsKK2ludCBpbXhf dXNibWlzY19pbml0X3Bvc3Qoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpOworaW50IGlt eF91c2JtaXNjX3NldF93YWtldXAoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wg ZW5hYmxlZCk7CitpbnQgaW14X3VzYm1pc2NfaHNpY19zZXRfY29ubmVjdChzdHJ1Y3QgaW14X3Vz Ym1pc2NfZGF0YSAqZGF0YSk7CitpbnQgaW14X3VzYm1pc2NfaHNpY19zZXRfY2xrKHN0cnVjdCBp bXhfdXNibWlzY19kYXRhICpkYXRhLCBib29sIG9uKTsKIAogI2VuZGlmIC8qIF9fRFJJVkVSX1VT Ql9DSElQSURFQV9DSV9IRFJDX0lNWF9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jaGlw aWRlYS91c2JtaXNjX2lteC5jIGIvZHJpdmVycy91c2IvY2hpcGlkZWEvdXNibWlzY19pbXguYwpp bmRleCBkZWY4MGZmNTQ3ZTQuLjQzYTE1YTZlODZmNSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Iv Y2hpcGlkZWEvdXNibWlzY19pbXguYworKysgYi9kcml2ZXJzL3VzYi9jaGlwaWRlYS91c2JtaXNj X2lteC5jCkBAIC02NCwxMCArNjQsMjIgQEAKICNkZWZpbmUgTVg2X0JNX09WRVJfQ1VSX0RJUwkJ QklUKDcpCiAjZGVmaW5lIE1YNl9CTV9PVkVSX0NVUl9QT0xBUklUWQlCSVQoOCkKICNkZWZpbmUg TVg2X0JNX1dBS0VVUF9FTkFCTEUJCUJJVCgxMCkKKyNkZWZpbmUgTVg2X0JNX1VUTUlfT05fQ0xP Q0sJCUJJVCgxMykKICNkZWZpbmUgTVg2X0JNX0lEX1dBS0VVUAkJQklUKDE2KQogI2RlZmluZSBN WDZfQk1fVkJVU19XQUtFVVAJCUJJVCgxNykKICNkZWZpbmUgTVg2U1hfQk1fRFBETV9XQUtFVVBf RU4JCUJJVCgyOSkKICNkZWZpbmUgTVg2X0JNX1dBS0VVUF9JTlRSCQlCSVQoMzEpCisKKyNkZWZp bmUgTVg2X1VTQl9IU0lDX0NUUkxfT0ZGU0VUCTB4MTAKKy8qIFNlbmQgcmVzdW1lIHNpZ25hbCB3 aXRob3V0IDQ4ME1oeiBQSFkgY2xvY2sgKi8KKyNkZWZpbmUgTVg2U1hfQk1fSFNJQ19BVVRPX1JF U1VNRQlCSVQoMjMpCisvKiBzZXQgYmVmb3JlIHBvcnRzYy5zdXNwZW5kTSA9IDEgKi8KKyNkZWZp bmUgTVg2X0JNX0hTSUNfREVWX0NPTk4JCUJJVCgyMSkKKy8qIEhTSUMgZW5hYmxlICovCisjZGVm aW5lIE1YNl9CTV9IU0lDX0VOCQkJQklUKDEyKQorLyogRm9yY2UgSFNJQyBtb2R1bGUgNDgwTSBj bG9jayBvbiwgZXZlbiB3aGVuIGluIEhvc3QgaXMgaW4gc3VzcGVuZCBtb2RlICovCisjZGVmaW5l IE1YNl9CTV9IU0lDX0NMS19PTgkJQklUKDExKQorCiAjZGVmaW5lIE1YNl9VU0JfT1RHMV9QSFlf Q1RSTAkJMHgxOAogLyogRm9yIGlteDZkcWwsIGl0IGlzIGhvc3Qtb25seSBjb250cm9sbGVyLCBm b3IgbGF0ZXIgaW14NiwgaXQgaXMgb3RnJ3MgKi8KICNkZWZpbmUgTVg2X1VTQl9PVEcyX1BIWV9D VFJMCQkweDFjCkBAIC05NCw2ICsxMDYsMTAgQEAgc3RydWN0IHVzYm1pc2Nfb3BzIHsKIAlpbnQg KCpwb3N0KShzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSk7CiAJLyogSXQncyBjYWxsZWQg d2hlbiB3ZSBuZWVkIHRvIGVuYWJsZS9kaXNhYmxlIHVzYiB3YWtldXAgKi8KIAlpbnQgKCpzZXRf d2FrZXVwKShzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSwgYm9vbCBlbmFibGVkKTsKKwkv KiBJdCdzIGNhbGxlZCBiZWZvcmUgc2V0dGluZyBwb3J0c2Muc3VzcGVuZE0gKi8KKwlpbnQgKCpo c2ljX3NldF9jb25uZWN0KShzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSk7CisJLyogSXQn cyBjYWxsZWQgZHVyaW5nIHN1c3BlbmQvcmVzdW1lICovCisJaW50ICgqaHNpY19zZXRfY2xrKShz dHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSwgYm9vbCBlbmFibGVkKTsKIH07CiAKIHN0cnVj dCBpbXhfdXNibWlzYyB7CkBAIC0zNTMsNiArMzY5LDE4IEBAIHN0YXRpYyBpbnQgdXNibWlzY19p bXg2cV9pbml0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQogCXdyaXRlbChyZWcgfCBN WDZfQk1fTk9OX0JVUlNUX1NFVFRJTkcsCiAJCQl1c2JtaXNjLT5iYXNlICsgZGF0YS0+aW5kZXgg KiA0KTsKIAorCS8qIEZvciBIU0lDIGNvbnRyb2xsZXIgKi8KKwlpZiAoZGF0YS0+aHNpYykgewor CQlyZWcgPSByZWFkbCh1c2JtaXNjLT5iYXNlICsgZGF0YS0+aW5kZXggKiA0KTsKKwkJd3JpdGVs KHJlZyB8IE1YNl9CTV9VVE1JX09OX0NMT0NLLAorCQkJdXNibWlzYy0+YmFzZSArIGRhdGEtPmlu ZGV4ICogNCk7CisJCXJlZyA9IHJlYWRsKHVzYm1pc2MtPmJhc2UgKyBNWDZfVVNCX0hTSUNfQ1RS TF9PRkZTRVQKKwkJCSsgKGRhdGEtPmluZGV4IC0gMikgKiA0KTsKKwkJcmVnIHw9IE1YNl9CTV9I U0lDX0VOIHwgTVg2X0JNX0hTSUNfQ0xLX09OOworCQl3cml0ZWwocmVnLCB1c2JtaXNjLT5iYXNl ICsgTVg2X1VTQl9IU0lDX0NUUkxfT0ZGU0VUCisJCQkrIChkYXRhLT5pbmRleCAtIDIpICogNCk7 CisJfQorCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdXNibWlzYy0+bG9jaywgZmxhZ3MpOwog CiAJdXNibWlzY19pbXg2cV9zZXRfd2FrZXVwKGRhdGEsIGZhbHNlKTsKQEAgLTM2MCw2ICszODgs NzkgQEAgc3RhdGljIGludCB1c2JtaXNjX2lteDZxX2luaXQoc3RydWN0IGlteF91c2JtaXNjX2Rh dGEgKmRhdGEpCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbnQgdXNibWlzY19pbXg2X2hzaWNf Z2V0X3JlZ19vZmZzZXQoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpCit7CisJaW50IG9m ZnNldCwgcmV0ID0gMDsKKworCWlmIChkYXRhLT5pbmRleCA9PSAyIHx8IGRhdGEtPmluZGV4ID09 IDMpIHsKKwkJb2Zmc2V0ID0gKGRhdGEtPmluZGV4IC0gMikgKiA0OworCX0gZWxzZSBpZiAoZGF0 YS0+aW5kZXggPT0gMCkgeworCQkvKgorCQkgKiBGb3IgU29DcyBsaWtlIGkuTVg3RCBhbmQgbGF0 ZXIsIGVhY2ggVVNCIGNvbnRyb2xsZXIgaGFzCisJCSAqIGl0cyBvd24gbm9uLWNvcmUgcmVnaXN0 ZXIgcmVnaW9uLiBGb3IgU29DcyBiZWZvcmUgaS5NWDdELAorCQkgKiB0aGUgZmlyc3QgdHdvIFVT QiBjb250cm9sbGVycyBhcmUgbm9uLUhTSUMgY29udHJvbGxlcnMuCisJCSAqLworCQlvZmZzZXQg PSAwOworCX0gZWxzZSB7CisJCWRldl9lcnIoZGF0YS0+ZGV2LCAiaW5kZXggaXMgZXJyb3IgZm9y IHVzYm1pc2NcbiIpOworCQlyZXQgPSAtRUlOVkFMOworCX0KKworCXJldHVybiByZXQgPyByZXQg OiBvZmZzZXQ7Cit9CisKK3N0YXRpYyBpbnQgdXNibWlzY19pbXg2X2hzaWNfc2V0X2Nvbm5lY3Qo c3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsK Kwl1MzIgdmFsOworCXN0cnVjdCBpbXhfdXNibWlzYyAqdXNibWlzYyA9IGRldl9nZXRfZHJ2ZGF0 YShkYXRhLT5kZXYpOworCWludCBvZmZzZXQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmdXNibWlz Yy0+bG9jaywgZmxhZ3MpOworCW9mZnNldCA9IHVzYm1pc2NfaW14Nl9oc2ljX2dldF9yZWdfb2Zm c2V0KGRhdGEpOworCWlmIChvZmZzZXQgPCAwKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUo JnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsKKwkJcmV0dXJuIG9mZnNldDsKKwl9CisKKwl2YWwgPSBy ZWFkbCh1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lDX0NUUkxfT0ZGU0VUICsgb2Zmc2V0KTsK KwlpZiAoISh2YWwgJiBNWDZfQk1fSFNJQ19ERVZfQ09OTikpCisJCXdyaXRlbCh2YWwgfCBNWDZf Qk1fSFNJQ19ERVZfQ09OTiwKKwkJCXVzYm1pc2MtPmJhc2UgKyBNWDZfVVNCX0hTSUNfQ1RSTF9P RkZTRVQgKyBvZmZzZXQpOworCisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdXNibWlzYy0+bG9j aywgZmxhZ3MpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdXNibWlzY19pbXg2X2hz aWNfc2V0X2NsayhzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSwgYm9vbCBvbikKK3sKKwl1 bnNpZ25lZCBsb25nIGZsYWdzOworCXUzMiB2YWw7CisJc3RydWN0IGlteF91c2JtaXNjICp1c2Jt aXNjID0gZGV2X2dldF9kcnZkYXRhKGRhdGEtPmRldik7CisJaW50IG9mZnNldDsKKworCXNwaW5f bG9ja19pcnFzYXZlKCZ1c2JtaXNjLT5sb2NrLCBmbGFncyk7CisJb2Zmc2V0ID0gdXNibWlzY19p bXg2X2hzaWNfZ2V0X3JlZ19vZmZzZXQoZGF0YSk7CisJaWYgKG9mZnNldCA8IDApIHsKKwkJc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmdXNibWlzYy0+bG9jaywgZmxhZ3MpOworCQlyZXR1cm4gb2Zm c2V0OworCX0KKworCXZhbCA9IHJlYWRsKHVzYm1pc2MtPmJhc2UgKyBNWDZfVVNCX0hTSUNfQ1RS TF9PRkZTRVQgKyBvZmZzZXQpOworCXZhbCB8PSBNWDZfQk1fSFNJQ19FTiB8IE1YNl9CTV9IU0lD X0NMS19PTjsKKwlpZiAob24pCisJCXZhbCB8PSBNWDZfQk1fSFNJQ19DTEtfT047CisJZWxzZQor CQl2YWwgJj0gfk1YNl9CTV9IU0lDX0NMS19PTjsKKworCXdyaXRlbCh2YWwsIHVzYm1pc2MtPmJh c2UgKyBNWDZfVVNCX0hTSUNfQ1RSTF9PRkZTRVQgKyBvZmZzZXQpOworCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCisKIHN0 YXRpYyBpbnQgdXNibWlzY19pbXg2c3hfaW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0 YSkKIHsKIAl2b2lkIF9faW9tZW0gKnJlZyA9IE5VTEw7CkBAIC0zODUsNiArNDg2LDEzIEBAIHN0 YXRpYyBpbnQgdXNibWlzY19pbXg2c3hfaW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0 YSkKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdXNibWlzYy0+bG9jaywgZmxhZ3MpOwogCX0K IAorCS8qIEZvciBIU0lDIGNvbnRyb2xsZXIgKi8KKwlpZiAoZGF0YS0+aHNpYykgeworCQl2YWwg PSByZWFkbCh1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lDX0NUUkxfT0ZGU0VUKTsKKwkJdmFs IHw9IE1YNlNYX0JNX0hTSUNfQVVUT19SRVNVTUU7CisJCXdyaXRlbCh2YWwsIHVzYm1pc2MtPmJh c2UgKyBNWDZfVVNCX0hTSUNfQ1RSTF9PRkZTRVQpOworCX0KKwogCXJldHVybiAwOwogfQogCkBA IC00NTQsNiArNTYyLDcgQEAgc3RhdGljIGludCB1c2JtaXNjX2lteDdkX2luaXQoc3RydWN0IGlt eF91c2JtaXNjX2RhdGEgKmRhdGEpCiAJcmVnICY9IH5NWDdEX1VTQl9WQlVTX1dBS0VVUF9TT1VS Q0VfTUFTSzsKIAl3cml0ZWwocmVnIHwgTVg3RF9VU0JfVkJVU19XQUtFVVBfU09VUkNFX0JWQUxJ RCwKIAkJIHVzYm1pc2MtPmJhc2UgKyBNWDdEX1VTQk5DX1VTQl9DVFJMMik7CisKIAlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZ1c2JtaXNjLT5sb2NrLCBmbGFncyk7CiAKIAl1c2JtaXNjX2lteDdk X3NldF93YWtldXAoZGF0YSwgZmFsc2UpOwpAQCAtNDgxLDYgKzU5MCw4IEBAIHN0YXRpYyBjb25z dCBzdHJ1Y3QgdXNibWlzY19vcHMgaW14NTNfdXNibWlzY19vcHMgPSB7CiBzdGF0aWMgY29uc3Qg c3RydWN0IHVzYm1pc2Nfb3BzIGlteDZxX3VzYm1pc2Nfb3BzID0gewogCS5zZXRfd2FrZXVwID0g dXNibWlzY19pbXg2cV9zZXRfd2FrZXVwLAogCS5pbml0ID0gdXNibWlzY19pbXg2cV9pbml0LAor CS5oc2ljX3NldF9jb25uZWN0ID0gdXNibWlzY19pbXg2X2hzaWNfc2V0X2Nvbm5lY3QsCisJLmhz aWNfc2V0X2NsayAgID0gdXNibWlzY19pbXg2X2hzaWNfc2V0X2NsaywKIH07CiAKIHN0YXRpYyBj b25zdCBzdHJ1Y3QgdXNibWlzY19vcHMgdmY2MTBfdXNibWlzY19vcHMgPSB7CkBAIC00OTAsNiAr NjAxLDggQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JtaXNjX29wcyB2ZjYxMF91c2JtaXNjX29w cyA9IHsKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNibWlzY19vcHMgaW14NnN4X3VzYm1pc2Nfb3Bz ID0gewogCS5zZXRfd2FrZXVwID0gdXNibWlzY19pbXg2cV9zZXRfd2FrZXVwLAogCS5pbml0ID0g dXNibWlzY19pbXg2c3hfaW5pdCwKKwkuaHNpY19zZXRfY29ubmVjdCA9IHVzYm1pc2NfaW14Nl9o c2ljX3NldF9jb25uZWN0LAorCS5oc2ljX3NldF9jbGsgPSB1c2JtaXNjX2lteDZfaHNpY19zZXRf Y2xrLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JtaXNjX29wcyBpbXg3ZF91c2JtaXNj X29wcyA9IHsKQEAgLTU0Niw2ICs2NTksMzMgQEAgaW50IGlteF91c2JtaXNjX3NldF93YWtldXAo c3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgZW5hYmxlZCkKIH0KIEVYUE9SVF9T WU1CT0xfR1BMKGlteF91c2JtaXNjX3NldF93YWtldXApOwogCitpbnQgaW14X3VzYm1pc2NfaHNp Y19zZXRfY29ubmVjdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSkKK3sKKwlzdHJ1Y3Qg aW14X3VzYm1pc2MgKnVzYm1pc2M7CisKKwlpZiAoIWRhdGEpCisJCXJldHVybiAwOworCisJdXNi bWlzYyA9IGRldl9nZXRfZHJ2ZGF0YShkYXRhLT5kZXYpOworCWlmICghdXNibWlzYy0+b3BzLT5o c2ljX3NldF9jb25uZWN0IHx8ICFkYXRhLT5oc2ljKQorCQlyZXR1cm4gMDsKKwlyZXR1cm4gdXNi bWlzYy0+b3BzLT5oc2ljX3NldF9jb25uZWN0KGRhdGEpOworfQorRVhQT1JUX1NZTUJPTF9HUEwo aW14X3VzYm1pc2NfaHNpY19zZXRfY29ubmVjdCk7CisKK2ludCBpbXhfdXNibWlzY19oc2ljX3Nl dF9jbGsoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgb24pCit7CisJc3RydWN0 IGlteF91c2JtaXNjICp1c2JtaXNjOworCisJaWYgKCFkYXRhKQorCQlyZXR1cm4gMDsKKworCXVz Ym1pc2MgPSBkZXZfZ2V0X2RydmRhdGEoZGF0YS0+ZGV2KTsKKwlpZiAoIXVzYm1pc2MtPm9wcy0+ aHNpY19zZXRfY2xrIHx8ICFkYXRhLT5oc2ljKQorCQlyZXR1cm4gMDsKKwlyZXR1cm4gdXNibWlz Yy0+b3BzLT5oc2ljX3NldF9jbGsoZGF0YSwgb24pOworfQorRVhQT1JUX1NZTUJPTF9HUEwoaW14 X3VzYm1pc2NfaHNpY19zZXRfY2xrKTsKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lk IHVzYm1pc2NfaW14X2R0X2lkc1tdID0gewogCXsKIAkJLmNvbXBhdGlibGUgPSAiZnNsLGlteDI1 LXVzYm1pc2MiLAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-eopbgr60054.outbound.protection.outlook.com ([40.107.6.54]:26834 "EHLO EUR04-DB3-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1728512AbeK0U2T (ORCPT ); Tue, 27 Nov 2018 15:28:19 -0500 From: PETER CHEN Subject: [PATCH v3 2/4] usb: chipidea: imx: add HSIC support Date: Tue, 27 Nov 2018 09:30:56 +0000 Message-ID: <20181127092824.22756-3-peter.chen@nxp.com> References: <20181127092824.22756-1-peter.chen@nxp.com> In-Reply-To: <20181127092824.22756-1-peter.chen@nxp.com> Content-Language: en-US Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org To: "linux-usb@vger.kernel.org" Cc: dl-linux-imx , "robh+dt@kernel.org" , "devicetree@vger.kernel.org" , "frieder.schrempf@exceet.de" , "festevam@gmail.com" , PETER CHEN List-ID: To support imx HSIC, there are some special requirement: - The HSIC pad is 1.2v, it may need to supply from external - The data/strobe pin needs to be pulled down first, and after host mode is initialized, the strobe pin needs to be pulled up - During the USB suspend/resume, special setting is needed Signed-off-by: Peter Chen --- drivers/usb/chipidea/ci_hdrc_imx.c | 140 ++++++++++++++++++++++++++++++++-= ---- drivers/usb/chipidea/ci_hdrc_imx.h | 9 ++- drivers/usb/chipidea/usbmisc_imx.c | 140 +++++++++++++++++++++++++++++++++= ++++ 3 files changed, 270 insertions(+), 19 deletions(-) diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_h= drc_imx.c index 09b37c0d075d..56781c329db0 100644 --- a/drivers/usb/chipidea/ci_hdrc_imx.c +++ b/drivers/usb/chipidea/ci_hdrc_imx.c @@ -14,6 +14,7 @@ #include #include #include +#include =20 #include "ci.h" #include "ci_hdrc_imx.h" @@ -85,6 +86,9 @@ struct ci_hdrc_imx_data { bool supports_runtime_pm; bool override_phy_control; bool in_lpm; + struct pinctrl *pinctrl; + struct pinctrl_state *pinctrl_hsic_active; + struct regulator *hsic_pad_regulator; /* SoC before i.mx6 (except imx23/imx28) needs three clks */ bool need_three_clks; struct clk *clk_ipg; @@ -245,19 +249,49 @@ static void imx_disable_unprepare_clks(struct device = *dev) } } =20 +static int ci_hdrc_imx_notify_event(struct ci_hdrc *ci, unsigned int event= ) +{ + struct device *dev =3D ci->dev->parent; + struct ci_hdrc_imx_data *data =3D dev_get_drvdata(dev); + int ret =3D 0; + + switch (event) { + case CI_HDRC_IMX_HSIC_ACTIVE_EVENT: + ret =3D pinctrl_select_state(data->pinctrl, + data->pinctrl_hsic_active); + if (ret) + dev_err(dev, "hsic_active select failed, err=3D%d\n", + ret); + break; + case CI_HDRC_IMX_HSIC_SUSPEND_EVENT: + ret =3D imx_usbmisc_hsic_set_connect(data->usbmisc_data); + if (ret) + dev_err(dev, + "hsic_set_connect failed, err=3D%d\n", ret); + break; + default: + break; + } + + return ret; +} + static int ci_hdrc_imx_probe(struct platform_device *pdev) { struct ci_hdrc_imx_data *data; struct ci_hdrc_platform_data pdata =3D { .name =3D dev_name(&pdev->dev), .capoffset =3D DEF_CAPOFFSET, + .notify_event =3D ci_hdrc_imx_notify_event, }; int ret; const struct of_device_id *of_id; const struct ci_hdrc_imx_platform_flag *imx_platform_flag; struct device_node *np =3D pdev->dev.of_node; + struct device *dev =3D &pdev->dev; + struct pinctrl_state *pinctrl_hsic_idle; =20 - of_id =3D of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev); + of_id =3D of_match_device(ci_hdrc_imx_dt_ids, dev); if (!of_id) return -ENODEV; =20 @@ -268,19 +302,73 @@ static int ci_hdrc_imx_probe(struct platform_device *= pdev) return -ENOMEM; =20 platform_set_drvdata(pdev, data); - data->usbmisc_data =3D usbmisc_get_init_data(&pdev->dev); + data->usbmisc_data =3D usbmisc_get_init_data(dev); if (IS_ERR(data->usbmisc_data)) return PTR_ERR(data->usbmisc_data); =20 - ret =3D imx_get_clks(&pdev->dev); + if (of_usb_get_phy_mode(dev->of_node) =3D=3D USBPHY_INTERFACE_MODE_HSIC) = { + pdata.flags |=3D CI_HDRC_IMX_IS_HSIC; + data->usbmisc_data->hsic =3D 1; + data->pinctrl =3D devm_pinctrl_get(dev); + if (IS_ERR(data->pinctrl)) { + dev_err(dev, "pinctrl get failed, err=3D%ld\n", + PTR_ERR(data->pinctrl)); + return PTR_ERR(data->pinctrl); + } + + pinctrl_hsic_idle =3D pinctrl_lookup_state(data->pinctrl, "idle"); + if (IS_ERR(pinctrl_hsic_idle)) { + dev_err(dev, + "pinctrl_hsic_idle lookup failed, err=3D%ld\n", + PTR_ERR(pinctrl_hsic_idle)); + return PTR_ERR(pinctrl_hsic_idle); + } + + ret =3D pinctrl_select_state(data->pinctrl, pinctrl_hsic_idle); + if (ret) { + dev_err(dev, "hsic_idle select failed, err=3D%d\n", ret); + return ret; + } + + data->pinctrl_hsic_active =3D pinctrl_lookup_state(data->pinctrl, + "active"); + if (IS_ERR(data->pinctrl_hsic_active)) { + dev_err(dev, + "pinctrl_hsic_active lookup failed, err=3D%ld\n", + PTR_ERR(data->pinctrl_hsic_active)); + return PTR_ERR(data->pinctrl_hsic_active); + } + + data->hsic_pad_regulator =3D devm_regulator_get(dev, "hsic"); + if (PTR_ERR(data->hsic_pad_regulator) =3D=3D -EPROBE_DEFER) { + return -EPROBE_DEFER; + } else if (PTR_ERR(data->hsic_pad_regulator) =3D=3D -ENODEV) { + /* no pad regualator is needed */ + data->hsic_pad_regulator =3D NULL; + } else if (IS_ERR(data->hsic_pad_regulator)) { + dev_err(dev, "Get HSIC pad regulator error: %ld\n", + PTR_ERR(data->hsic_pad_regulator)); + return PTR_ERR(data->hsic_pad_regulator); + } + + if (data->hsic_pad_regulator) { + ret =3D regulator_enable(data->hsic_pad_regulator); + if (ret) { + dev_err(dev, + "Failed to enable HSIC pad regulator\n"); + return ret; + } + } + } + ret =3D imx_get_clks(dev); if (ret) - return ret; + goto disable_hsic_regulator; =20 - ret =3D imx_prepare_enable_clks(&pdev->dev); + ret =3D imx_prepare_enable_clks(dev); if (ret) - return ret; + goto disable_hsic_regulator; =20 - data->phy =3D devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0); + data->phy =3D devm_usb_get_phy_by_phandle(dev, "fsl,usbphy", 0); if (IS_ERR(data->phy)) { ret =3D PTR_ERR(data->phy); /* Return -EINVAL if no usbphy is available */ @@ -305,40 +393,43 @@ static int ci_hdrc_imx_probe(struct platform_device *= pdev) =20 ret =3D imx_usbmisc_init(data->usbmisc_data); if (ret) { - dev_err(&pdev->dev, "usbmisc init failed, ret=3D%d\n", ret); + dev_err(dev, "usbmisc init failed, ret=3D%d\n", ret); goto err_clk; } =20 - data->ci_pdev =3D ci_hdrc_add_device(&pdev->dev, + data->ci_pdev =3D ci_hdrc_add_device(dev, pdev->resource, pdev->num_resources, &pdata); if (IS_ERR(data->ci_pdev)) { ret =3D PTR_ERR(data->ci_pdev); if (ret !=3D -EPROBE_DEFER) - dev_err(&pdev->dev, - "ci_hdrc_add_device failed, err=3D%d\n", ret); + dev_err(dev, "ci_hdrc_add_device failed, err=3D%d\n", + ret); goto err_clk; } =20 ret =3D imx_usbmisc_init_post(data->usbmisc_data); if (ret) { - dev_err(&pdev->dev, "usbmisc post failed, ret=3D%d\n", ret); + dev_err(dev, "usbmisc post failed, ret=3D%d\n", ret); goto disable_device; } =20 if (data->supports_runtime_pm) { - pm_runtime_set_active(&pdev->dev); - pm_runtime_enable(&pdev->dev); + pm_runtime_set_active(dev); + pm_runtime_enable(dev); } =20 - device_set_wakeup_capable(&pdev->dev, true); + device_set_wakeup_capable(dev, true); =20 return 0; =20 disable_device: ci_hdrc_remove_device(data->ci_pdev); err_clk: - imx_disable_unprepare_clks(&pdev->dev); + imx_disable_unprepare_clks(dev); +disable_hsic_regulator: + if (data->hsic_pad_regulator) + ret =3D regulator_disable(data->hsic_pad_regulator); return ret; } =20 @@ -355,6 +446,8 @@ static int ci_hdrc_imx_remove(struct platform_device *p= dev) if (data->override_phy_control) usb_phy_shutdown(data->phy); imx_disable_unprepare_clks(&pdev->dev); + if (data->hsic_pad_regulator) + regulator_disable(data->hsic_pad_regulator); =20 return 0; } @@ -367,9 +460,16 @@ static void ci_hdrc_imx_shutdown(struct platform_devic= e *pdev) static int __maybe_unused imx_controller_suspend(struct device *dev) { struct ci_hdrc_imx_data *data =3D dev_get_drvdata(dev); + int ret =3D 0; =20 dev_dbg(dev, "at %s\n", __func__); =20 + ret =3D imx_usbmisc_hsic_set_clk(data->usbmisc_data, false); + if (ret) { + dev_err(dev, "usbmisc hsic_set_clk failed, ret=3D%d\n", ret); + return ret; + } + imx_disable_unprepare_clks(dev); data->in_lpm =3D true; =20 @@ -400,8 +500,16 @@ static int __maybe_unused imx_controller_resume(struct= device *dev) goto clk_disable; } =20 + ret =3D imx_usbmisc_hsic_set_clk(data->usbmisc_data, true); + if (ret) { + dev_err(dev, "usbmisc hsic_set_clk failed, ret=3D%d\n", ret); + goto hsic_set_clk_fail; + } + return 0; =20 +hsic_set_clk_fail: + imx_usbmisc_set_wakeup(data->usbmisc_data, true); clk_disable: imx_disable_unprepare_clks(dev); return ret; diff --git a/drivers/usb/chipidea/ci_hdrc_imx.h b/drivers/usb/chipidea/ci_h= drc_imx.h index 204275f47573..fcecab478934 100644 --- a/drivers/usb/chipidea/ci_hdrc_imx.h +++ b/drivers/usb/chipidea/ci_hdrc_imx.h @@ -14,10 +14,13 @@ struct imx_usbmisc_data { unsigned int oc_polarity:1; /* over current polarity if oc enabled */ unsigned int evdo:1; /* set external vbus divider option */ unsigned int ulpi:1; /* connected to an ULPI phy */ + unsigned int hsic:1; /* HSIC controlller */ }; =20 -int imx_usbmisc_init(struct imx_usbmisc_data *); -int imx_usbmisc_init_post(struct imx_usbmisc_data *); -int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *, bool); +int imx_usbmisc_init(struct imx_usbmisc_data *data); +int imx_usbmisc_init_post(struct imx_usbmisc_data *data); +int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *data, bool enabled); +int imx_usbmisc_hsic_set_connect(struct imx_usbmisc_data *data); +int imx_usbmisc_hsic_set_clk(struct imx_usbmisc_data *data, bool on); =20 #endif /* __DRIVER_USB_CHIPIDEA_CI_HDRC_IMX_H */ diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbm= isc_imx.c index def80ff547e4..43a15a6e86f5 100644 --- a/drivers/usb/chipidea/usbmisc_imx.c +++ b/drivers/usb/chipidea/usbmisc_imx.c @@ -64,10 +64,22 @@ #define MX6_BM_OVER_CUR_DIS BIT(7) #define MX6_BM_OVER_CUR_POLARITY BIT(8) #define MX6_BM_WAKEUP_ENABLE BIT(10) +#define MX6_BM_UTMI_ON_CLOCK BIT(13) #define MX6_BM_ID_WAKEUP BIT(16) #define MX6_BM_VBUS_WAKEUP BIT(17) #define MX6SX_BM_DPDM_WAKEUP_EN BIT(29) #define MX6_BM_WAKEUP_INTR BIT(31) + +#define MX6_USB_HSIC_CTRL_OFFSET 0x10 +/* Send resume signal without 480Mhz PHY clock */ +#define MX6SX_BM_HSIC_AUTO_RESUME BIT(23) +/* set before portsc.suspendM =3D 1 */ +#define MX6_BM_HSIC_DEV_CONN BIT(21) +/* HSIC enable */ +#define MX6_BM_HSIC_EN BIT(12) +/* Force HSIC module 480M clock on, even when in Host is in suspend mode *= / +#define MX6_BM_HSIC_CLK_ON BIT(11) + #define MX6_USB_OTG1_PHY_CTRL 0x18 /* For imx6dql, it is host-only controller, for later imx6, it is otg's */ #define MX6_USB_OTG2_PHY_CTRL 0x1c @@ -94,6 +106,10 @@ struct usbmisc_ops { int (*post)(struct imx_usbmisc_data *data); /* It's called when we need to enable/disable usb wakeup */ int (*set_wakeup)(struct imx_usbmisc_data *data, bool enabled); + /* It's called before setting portsc.suspendM */ + int (*hsic_set_connect)(struct imx_usbmisc_data *data); + /* It's called during suspend/resume */ + int (*hsic_set_clk)(struct imx_usbmisc_data *data, bool enabled); }; =20 struct imx_usbmisc { @@ -353,6 +369,18 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data = *data) writel(reg | MX6_BM_NON_BURST_SETTING, usbmisc->base + data->index * 4); =20 + /* For HSIC controller */ + if (data->hsic) { + reg =3D readl(usbmisc->base + data->index * 4); + writel(reg | MX6_BM_UTMI_ON_CLOCK, + usbmisc->base + data->index * 4); + reg =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + + (data->index - 2) * 4); + reg |=3D MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON; + writel(reg, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + + (data->index - 2) * 4); + } + spin_unlock_irqrestore(&usbmisc->lock, flags); =20 usbmisc_imx6q_set_wakeup(data, false); @@ -360,6 +388,79 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data = *data) return 0; } =20 +static int usbmisc_imx6_hsic_get_reg_offset(struct imx_usbmisc_data *data) +{ + int offset, ret =3D 0; + + if (data->index =3D=3D 2 || data->index =3D=3D 3) { + offset =3D (data->index - 2) * 4; + } else if (data->index =3D=3D 0) { + /* + * For SoCs like i.MX7D and later, each USB controller has + * its own non-core register region. For SoCs before i.MX7D, + * the first two USB controllers are non-HSIC controllers. + */ + offset =3D 0; + } else { + dev_err(data->dev, "index is error for usbmisc\n"); + ret =3D -EINVAL; + } + + return ret ? ret : offset; +} + +static int usbmisc_imx6_hsic_set_connect(struct imx_usbmisc_data *data) +{ + unsigned long flags; + u32 val; + struct imx_usbmisc *usbmisc =3D dev_get_drvdata(data->dev); + int offset; + + spin_lock_irqsave(&usbmisc->lock, flags); + offset =3D usbmisc_imx6_hsic_get_reg_offset(data); + if (offset < 0) { + spin_unlock_irqrestore(&usbmisc->lock, flags); + return offset; + } + + val =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + if (!(val & MX6_BM_HSIC_DEV_CONN)) + writel(val | MX6_BM_HSIC_DEV_CONN, + usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + + spin_unlock_irqrestore(&usbmisc->lock, flags); + + return 0; +} + +static int usbmisc_imx6_hsic_set_clk(struct imx_usbmisc_data *data, bool o= n) +{ + unsigned long flags; + u32 val; + struct imx_usbmisc *usbmisc =3D dev_get_drvdata(data->dev); + int offset; + + spin_lock_irqsave(&usbmisc->lock, flags); + offset =3D usbmisc_imx6_hsic_get_reg_offset(data); + if (offset < 0) { + spin_unlock_irqrestore(&usbmisc->lock, flags); + return offset; + } + + val =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + val |=3D MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON; + if (on) + val |=3D MX6_BM_HSIC_CLK_ON; + else + val &=3D ~MX6_BM_HSIC_CLK_ON; + + writel(val, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset); + spin_unlock_irqrestore(&usbmisc->lock, flags); + + return 0; +} + + static int usbmisc_imx6sx_init(struct imx_usbmisc_data *data) { void __iomem *reg =3D NULL; @@ -385,6 +486,13 @@ static int usbmisc_imx6sx_init(struct imx_usbmisc_data= *data) spin_unlock_irqrestore(&usbmisc->lock, flags); } =20 + /* For HSIC controller */ + if (data->hsic) { + val =3D readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET); + val |=3D MX6SX_BM_HSIC_AUTO_RESUME; + writel(val, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET); + } + return 0; } =20 @@ -454,6 +562,7 @@ static int usbmisc_imx7d_init(struct imx_usbmisc_data *= data) reg &=3D ~MX7D_USB_VBUS_WAKEUP_SOURCE_MASK; writel(reg | MX7D_USB_VBUS_WAKEUP_SOURCE_BVALID, usbmisc->base + MX7D_USBNC_USB_CTRL2); + spin_unlock_irqrestore(&usbmisc->lock, flags); =20 usbmisc_imx7d_set_wakeup(data, false); @@ -481,6 +590,8 @@ static const struct usbmisc_ops imx53_usbmisc_ops =3D { static const struct usbmisc_ops imx6q_usbmisc_ops =3D { .set_wakeup =3D usbmisc_imx6q_set_wakeup, .init =3D usbmisc_imx6q_init, + .hsic_set_connect =3D usbmisc_imx6_hsic_set_connect, + .hsic_set_clk =3D usbmisc_imx6_hsic_set_clk, }; =20 static const struct usbmisc_ops vf610_usbmisc_ops =3D { @@ -490,6 +601,8 @@ static const struct usbmisc_ops vf610_usbmisc_ops =3D { static const struct usbmisc_ops imx6sx_usbmisc_ops =3D { .set_wakeup =3D usbmisc_imx6q_set_wakeup, .init =3D usbmisc_imx6sx_init, + .hsic_set_connect =3D usbmisc_imx6_hsic_set_connect, + .hsic_set_clk =3D usbmisc_imx6_hsic_set_clk, }; =20 static const struct usbmisc_ops imx7d_usbmisc_ops =3D { @@ -546,6 +659,33 @@ int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *da= ta, bool enabled) } EXPORT_SYMBOL_GPL(imx_usbmisc_set_wakeup); =20 +int imx_usbmisc_hsic_set_connect(struct imx_usbmisc_data *data) +{ + struct imx_usbmisc *usbmisc; + + if (!data) + return 0; + + usbmisc =3D dev_get_drvdata(data->dev); + if (!usbmisc->ops->hsic_set_connect || !data->hsic) + return 0; + return usbmisc->ops->hsic_set_connect(data); +} +EXPORT_SYMBOL_GPL(imx_usbmisc_hsic_set_connect); + +int imx_usbmisc_hsic_set_clk(struct imx_usbmisc_data *data, bool on) +{ + struct imx_usbmisc *usbmisc; + + if (!data) + return 0; + + usbmisc =3D dev_get_drvdata(data->dev); + if (!usbmisc->ops->hsic_set_clk || !data->hsic) + return 0; + return usbmisc->ops->hsic_set_clk(data, on); +} +EXPORT_SYMBOL_GPL(imx_usbmisc_hsic_set_clk); static const struct of_device_id usbmisc_imx_dt_ids[] =3D { { .compatible =3D "fsl,imx25-usbmisc", --=20 2.14.1