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,2/4] usb: chipidea: imx: add HSIC support From: Peter Chen Message-Id: <20181211020624.9433-3-peter.chen@nxp.com> Date: Tue, 11 Dec 2018 02:08:57 +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 IHNldHRpbmcgaXMgbmVlZGVkCgpSZXZpZXdlZC1ieTogRnJpZWRlciBTY2hyZW1wZiA8ZnJpZWRl ci5zY2hyZW1wZkBrb250cm9uLmRlPgpUZXN0ZWQtYnk6IEZyaWVkZXIgU2NocmVtcGYgPGZyaWVk ZXIuc2NocmVtcGZAa29udHJvbi5kZT4KU2lnbmVkLW9mZi1ieTogUGV0ZXIgQ2hlbiA8cGV0ZXIu Y2hlbkBueHAuY29tPgotLS0KIGRyaXZlcnMvdXNiL2NoaXBpZGVhL2NpX2hkcmNfaW14LmMgfCAx NDAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLQogZHJpdmVycy91c2IvY2hp cGlkZWEvY2lfaGRyY19pbXguaCB8ICAgOSArKy0KIGRyaXZlcnMvdXNiL2NoaXBpZGVhL3VzYm1p c2NfaW14LmMgfCAxNDAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBm aWxlcyBjaGFuZ2VkLCAyNzAgaW5zZXJ0aW9ucygrKSwgMTkgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguYyBiL2RyaXZlcnMvdXNiL2No aXBpZGVhL2NpX2hkcmNfaW14LmMKaW5kZXggMDliMzdjMGQwNzVkLi41Njc4MWMzMjlkYjAgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NoaXBpZGVhL2NpX2hkcmNfaW14LmMKKysrIGIvZHJpdmVy cy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguYwpAQCAtMTQsNiArMTQsNyBAQAogI2luY2x1ZGUg PGxpbnV4L3VzYi9jaGlwaWRlYS5oPgogI2luY2x1ZGUgPGxpbnV4L3VzYi9vZi5oPgogI2luY2x1 ZGUgPGxpbnV4L2Nsay5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvY29uc3VtZXIuaD4KIAog I2luY2x1ZGUgImNpLmgiCiAjaW5jbHVkZSAiY2lfaGRyY19pbXguaCIKQEAgLTg1LDYgKzg2LDkg QEAgc3RydWN0IGNpX2hkcmNfaW14X2RhdGEgewogCWJvb2wgc3VwcG9ydHNfcnVudGltZV9wbTsK IAlib29sIG92ZXJyaWRlX3BoeV9jb250cm9sOwogCWJvb2wgaW5fbHBtOworCXN0cnVjdCBwaW5j dHJsICpwaW5jdHJsOworCXN0cnVjdCBwaW5jdHJsX3N0YXRlICpwaW5jdHJsX2hzaWNfYWN0aXZl OworCXN0cnVjdCByZWd1bGF0b3IgKmhzaWNfcGFkX3JlZ3VsYXRvcjsKIAkvKiBTb0MgYmVmb3Jl IGkubXg2IChleGNlcHQgaW14MjMvaW14MjgpIG5lZWRzIHRocmVlIGNsa3MgKi8KIAlib29sIG5l ZWRfdGhyZWVfY2xrczsKIAlzdHJ1Y3QgY2xrICpjbGtfaXBnOwpAQCAtMjQ1LDE5ICsyNDksNDkg QEAgc3RhdGljIHZvaWQgaW14X2Rpc2FibGVfdW5wcmVwYXJlX2Nsa3Moc3RydWN0IGRldmljZSAq ZGV2KQogCX0KIH0KIAorc3RhdGljIGludCBjaV9oZHJjX2lteF9ub3RpZnlfZXZlbnQoc3RydWN0 IGNpX2hkcmMgKmNpLCB1bnNpZ25lZCBpbnQgZXZlbnQpCit7CisJc3RydWN0IGRldmljZSAqZGV2 ID0gY2ktPmRldi0+cGFyZW50OworCXN0cnVjdCBjaV9oZHJjX2lteF9kYXRhICpkYXRhID0gZGV2 X2dldF9kcnZkYXRhKGRldik7CisJaW50IHJldCA9IDA7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJ Y2FzZSBDSV9IRFJDX0lNWF9IU0lDX0FDVElWRV9FVkVOVDoKKwkJcmV0ID0gcGluY3RybF9zZWxl Y3Rfc3RhdGUoZGF0YS0+cGluY3RybCwKKwkJCQlkYXRhLT5waW5jdHJsX2hzaWNfYWN0aXZlKTsK KwkJaWYgKHJldCkKKwkJCWRldl9lcnIoZGV2LCAiaHNpY19hY3RpdmUgc2VsZWN0IGZhaWxlZCwg ZXJyPSVkXG4iLAorCQkJCXJldCk7CisJCWJyZWFrOworCWNhc2UgQ0lfSERSQ19JTVhfSFNJQ19T VVNQRU5EX0VWRU5UOgorCQlyZXQgPSBpbXhfdXNibWlzY19oc2ljX3NldF9jb25uZWN0KGRhdGEt PnVzYm1pc2NfZGF0YSk7CisJCWlmIChyZXQpCisJCQlkZXZfZXJyKGRldiwKKwkJCQkiaHNpY19z ZXRfY29ubmVjdCBmYWlsZWQsIGVycj0lZFxuIiwgcmV0KTsKKwkJYnJlYWs7CisJZGVmYXVsdDoK KwkJYnJlYWs7CisJfQorCisJcmV0dXJuIHJldDsKK30KKwogc3RhdGljIGludCBjaV9oZHJjX2lt eF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBjaV9oZHJj X2lteF9kYXRhICpkYXRhOwogCXN0cnVjdCBjaV9oZHJjX3BsYXRmb3JtX2RhdGEgcGRhdGEgPSB7 CiAJCS5uYW1lCQk9IGRldl9uYW1lKCZwZGV2LT5kZXYpLAogCQkuY2Fwb2Zmc2V0CT0gREVGX0NB UE9GRlNFVCwKKwkJLm5vdGlmeV9ldmVudAk9IGNpX2hkcmNfaW14X25vdGlmeV9ldmVudCwKIAl9 OwogCWludCByZXQ7CiAJY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCAqb2ZfaWQ7CiAJY29uc3Qg c3RydWN0IGNpX2hkcmNfaW14X3BsYXRmb3JtX2ZsYWcgKmlteF9wbGF0Zm9ybV9mbGFnOwogCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBwZGV2LT5kZXYub2Zfbm9kZTsKKwlzdHJ1Y3QgZGV2aWNl ICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCBwaW5jdHJsX3N0YXRlICpwaW5jdHJsX2hzaWNf aWRsZTsKIAotCW9mX2lkID0gb2ZfbWF0Y2hfZGV2aWNlKGNpX2hkcmNfaW14X2R0X2lkcywgJnBk ZXYtPmRldik7CisJb2ZfaWQgPSBvZl9tYXRjaF9kZXZpY2UoY2lfaGRyY19pbXhfZHRfaWRzLCBk ZXYpOwogCWlmICghb2ZfaWQpCiAJCXJldHVybiAtRU5PREVWOwogCkBAIC0yNjgsMTkgKzMwMiw3 MyBAQCBzdGF0aWMgaW50IGNpX2hkcmNfaW14X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBkZXYpCiAJCXJldHVybiAtRU5PTUVNOwogCiAJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwg ZGF0YSk7Ci0JZGF0YS0+dXNibWlzY19kYXRhID0gdXNibWlzY19nZXRfaW5pdF9kYXRhKCZwZGV2 LT5kZXYpOworCWRhdGEtPnVzYm1pc2NfZGF0YSA9IHVzYm1pc2NfZ2V0X2luaXRfZGF0YShkZXYp OwogCWlmIChJU19FUlIoZGF0YS0+dXNibWlzY19kYXRhKSkKIAkJcmV0dXJuIFBUUl9FUlIoZGF0 YS0+dXNibWlzY19kYXRhKTsKIAotCXJldCA9IGlteF9nZXRfY2xrcygmcGRldi0+ZGV2KTsKKwlp ZiAob2ZfdXNiX2dldF9waHlfbW9kZShkZXYtPm9mX25vZGUpID09IFVTQlBIWV9JTlRFUkZBQ0Vf TU9ERV9IU0lDKSB7CisJCXBkYXRhLmZsYWdzIHw9IENJX0hEUkNfSU1YX0lTX0hTSUM7CisJCWRh dGEtPnVzYm1pc2NfZGF0YS0+aHNpYyA9IDE7CisJCWRhdGEtPnBpbmN0cmwgPSBkZXZtX3BpbmN0 cmxfZ2V0KGRldik7CisJCWlmIChJU19FUlIoZGF0YS0+cGluY3RybCkpIHsKKwkJCWRldl9lcnIo ZGV2LCAicGluY3RybCBnZXQgZmFpbGVkLCBlcnI9JWxkXG4iLAorCQkJCQlQVFJfRVJSKGRhdGEt PnBpbmN0cmwpKTsKKwkJCXJldHVybiBQVFJfRVJSKGRhdGEtPnBpbmN0cmwpOworCQl9CisKKwkJ cGluY3RybF9oc2ljX2lkbGUgPSBwaW5jdHJsX2xvb2t1cF9zdGF0ZShkYXRhLT5waW5jdHJsLCAi aWRsZSIpOworCQlpZiAoSVNfRVJSKHBpbmN0cmxfaHNpY19pZGxlKSkgeworCQkJZGV2X2Vycihk ZXYsCisJCQkJInBpbmN0cmxfaHNpY19pZGxlIGxvb2t1cCBmYWlsZWQsIGVycj0lbGRcbiIsCisJ CQkJCVBUUl9FUlIocGluY3RybF9oc2ljX2lkbGUpKTsKKwkJCXJldHVybiBQVFJfRVJSKHBpbmN0 cmxfaHNpY19pZGxlKTsKKwkJfQorCisJCXJldCA9IHBpbmN0cmxfc2VsZWN0X3N0YXRlKGRhdGEt PnBpbmN0cmwsIHBpbmN0cmxfaHNpY19pZGxlKTsKKwkJaWYgKHJldCkgeworCQkJZGV2X2Vycihk ZXYsICJoc2ljX2lkbGUgc2VsZWN0IGZhaWxlZCwgZXJyPSVkXG4iLCByZXQpOworCQkJcmV0dXJu IHJldDsKKwkJfQorCisJCWRhdGEtPnBpbmN0cmxfaHNpY19hY3RpdmUgPSBwaW5jdHJsX2xvb2t1 cF9zdGF0ZShkYXRhLT5waW5jdHJsLAorCQkJCQkJCQkiYWN0aXZlIik7CisJCWlmIChJU19FUlIo ZGF0YS0+cGluY3RybF9oc2ljX2FjdGl2ZSkpIHsKKwkJCWRldl9lcnIoZGV2LAorCQkJCSJwaW5j dHJsX2hzaWNfYWN0aXZlIGxvb2t1cCBmYWlsZWQsIGVycj0lbGRcbiIsCisJCQkJCVBUUl9FUlIo ZGF0YS0+cGluY3RybF9oc2ljX2FjdGl2ZSkpOworCQkJcmV0dXJuIFBUUl9FUlIoZGF0YS0+cGlu Y3RybF9oc2ljX2FjdGl2ZSk7CisJCX0KKworCQlkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IgPSBk ZXZtX3JlZ3VsYXRvcl9nZXQoZGV2LCAiaHNpYyIpOworCQlpZiAoUFRSX0VSUihkYXRhLT5oc2lj X3BhZF9yZWd1bGF0b3IpID09IC1FUFJPQkVfREVGRVIpIHsKKwkJCXJldHVybiAtRVBST0JFX0RF RkVSOworCQl9IGVsc2UgaWYgKFBUUl9FUlIoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKSA9PSAt RU5PREVWKSB7CisJCQkvKiBubyBwYWQgcmVndWFsYXRvciBpcyBuZWVkZWQgKi8KKwkJCWRhdGEt PmhzaWNfcGFkX3JlZ3VsYXRvciA9IE5VTEw7CisJCX0gZWxzZSBpZiAoSVNfRVJSKGRhdGEtPmhz aWNfcGFkX3JlZ3VsYXRvcikpIHsKKwkJCWRldl9lcnIoZGV2LCAiR2V0IEhTSUMgcGFkIHJlZ3Vs YXRvciBlcnJvcjogJWxkXG4iLAorCQkJCQlQVFJfRVJSKGRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRv cikpOworCQkJcmV0dXJuIFBUUl9FUlIoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKTsKKwkJfQor CisJCWlmIChkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpIHsKKwkJCXJldCA9IHJlZ3VsYXRvcl9l bmFibGUoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKTsKKwkJCWlmIChyZXQpIHsKKwkJCQlkZXZf ZXJyKGRldiwKKwkJCQkJIkZhaWxlZCB0byBlbmFibGUgSFNJQyBwYWQgcmVndWxhdG9yXG4iKTsK KwkJCQlyZXR1cm4gcmV0OworCQkJfQorCQl9CisJfQorCXJldCA9IGlteF9nZXRfY2xrcyhkZXYp OwogCWlmIChyZXQpCi0JCXJldHVybiByZXQ7CisJCWdvdG8gZGlzYWJsZV9oc2ljX3JlZ3VsYXRv cjsKIAotCXJldCA9IGlteF9wcmVwYXJlX2VuYWJsZV9jbGtzKCZwZGV2LT5kZXYpOworCXJldCA9 IGlteF9wcmVwYXJlX2VuYWJsZV9jbGtzKGRldik7CiAJaWYgKHJldCkKLQkJcmV0dXJuIHJldDsK KwkJZ290byBkaXNhYmxlX2hzaWNfcmVndWxhdG9yOwogCi0JZGF0YS0+cGh5ID0gZGV2bV91c2Jf Z2V0X3BoeV9ieV9waGFuZGxlKCZwZGV2LT5kZXYsICJmc2wsdXNicGh5IiwgMCk7CisJZGF0YS0+ cGh5ID0gZGV2bV91c2JfZ2V0X3BoeV9ieV9waGFuZGxlKGRldiwgImZzbCx1c2JwaHkiLCAwKTsK IAlpZiAoSVNfRVJSKGRhdGEtPnBoeSkpIHsKIAkJcmV0ID0gUFRSX0VSUihkYXRhLT5waHkpOwog CQkvKiBSZXR1cm4gLUVJTlZBTCBpZiBubyB1c2JwaHkgaXMgYXZhaWxhYmxlICovCkBAIC0zMDUs NDAgKzM5Myw0MyBAQCBzdGF0aWMgaW50IGNpX2hkcmNfaW14X3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCiAKIAlyZXQgPSBpbXhfdXNibWlzY19pbml0KGRhdGEtPnVzYm1pc2Nf ZGF0YSk7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJ1c2JtaXNjIGluaXQg ZmFpbGVkLCByZXQ9JWRcbiIsIHJldCk7CisJCWRldl9lcnIoZGV2LCAidXNibWlzYyBpbml0IGZh aWxlZCwgcmV0PSVkXG4iLCByZXQpOwogCQlnb3RvIGVycl9jbGs7CiAJfQogCi0JZGF0YS0+Y2lf cGRldiA9IGNpX2hkcmNfYWRkX2RldmljZSgmcGRldi0+ZGV2LAorCWRhdGEtPmNpX3BkZXYgPSBj aV9oZHJjX2FkZF9kZXZpY2UoZGV2LAogCQkJCXBkZXYtPnJlc291cmNlLCBwZGV2LT5udW1fcmVz b3VyY2VzLAogCQkJCSZwZGF0YSk7CiAJaWYgKElTX0VSUihkYXRhLT5jaV9wZGV2KSkgewogCQly ZXQgPSBQVFJfRVJSKGRhdGEtPmNpX3BkZXYpOwogCQlpZiAocmV0ICE9IC1FUFJPQkVfREVGRVIp Ci0JCQlkZXZfZXJyKCZwZGV2LT5kZXYsCi0JCQkJImNpX2hkcmNfYWRkX2RldmljZSBmYWlsZWQs IGVycj0lZFxuIiwgcmV0KTsKKwkJCWRldl9lcnIoZGV2LCAiY2lfaGRyY19hZGRfZGV2aWNlIGZh aWxlZCwgZXJyPSVkXG4iLAorCQkJCQlyZXQpOwogCQlnb3RvIGVycl9jbGs7CiAJfQogCiAJcmV0 ID0gaW14X3VzYm1pc2NfaW5pdF9wb3N0KGRhdGEtPnVzYm1pc2NfZGF0YSk7CiAJaWYgKHJldCkg ewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJ1c2JtaXNjIHBvc3QgZmFpbGVkLCByZXQ9JWRcbiIs IHJldCk7CisJCWRldl9lcnIoZGV2LCAidXNibWlzYyBwb3N0IGZhaWxlZCwgcmV0PSVkXG4iLCBy ZXQpOwogCQlnb3RvIGRpc2FibGVfZGV2aWNlOwogCX0KIAogCWlmIChkYXRhLT5zdXBwb3J0c19y dW50aW1lX3BtKSB7Ci0JCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZSgmcGRldi0+ZGV2KTsKLQkJcG1f cnVudGltZV9lbmFibGUoJnBkZXYtPmRldik7CisJCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZShkZXYp OworCQlwbV9ydW50aW1lX2VuYWJsZShkZXYpOwogCX0KIAotCWRldmljZV9zZXRfd2FrZXVwX2Nh cGFibGUoJnBkZXYtPmRldiwgdHJ1ZSk7CisJZGV2aWNlX3NldF93YWtldXBfY2FwYWJsZShkZXYs IHRydWUpOwogCiAJcmV0dXJuIDA7CiAKIGRpc2FibGVfZGV2aWNlOgogCWNpX2hkcmNfcmVtb3Zl X2RldmljZShkYXRhLT5jaV9wZGV2KTsKIGVycl9jbGs6Ci0JaW14X2Rpc2FibGVfdW5wcmVwYXJl X2Nsa3MoJnBkZXYtPmRldik7CisJaW14X2Rpc2FibGVfdW5wcmVwYXJlX2Nsa3MoZGV2KTsKK2Rp c2FibGVfaHNpY19yZWd1bGF0b3I6CisJaWYgKGRhdGEtPmhzaWNfcGFkX3JlZ3VsYXRvcikKKwkJ cmV0ID0gcmVndWxhdG9yX2Rpc2FibGUoZGF0YS0+aHNpY19wYWRfcmVndWxhdG9yKTsKIAlyZXR1 cm4gcmV0OwogfQogCkBAIC0zNTUsNiArNDQ2LDggQEAgc3RhdGljIGludCBjaV9oZHJjX2lteF9y ZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlpZiAoZGF0YS0+b3ZlcnJpZGVf cGh5X2NvbnRyb2wpCiAJCXVzYl9waHlfc2h1dGRvd24oZGF0YS0+cGh5KTsKIAlpbXhfZGlzYWJs ZV91bnByZXBhcmVfY2xrcygmcGRldi0+ZGV2KTsKKwlpZiAoZGF0YS0+aHNpY19wYWRfcmVndWxh dG9yKQorCQlyZWd1bGF0b3JfZGlzYWJsZShkYXRhLT5oc2ljX3BhZF9yZWd1bGF0b3IpOwogCiAJ cmV0dXJuIDA7CiB9CkBAIC0zNjcsOSArNDYwLDE2IEBAIHN0YXRpYyB2b2lkIGNpX2hkcmNfaW14 X3NodXRkb3duKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiBzdGF0aWMgaW50IF9fbWF5 YmVfdW51c2VkIGlteF9jb250cm9sbGVyX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQogewog CXN0cnVjdCBjaV9oZHJjX2lteF9kYXRhICpkYXRhID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisJ aW50IHJldCA9IDA7CiAKIAlkZXZfZGJnKGRldiwgImF0ICVzXG4iLCBfX2Z1bmNfXyk7CiAKKwly ZXQgPSBpbXhfdXNibWlzY19oc2ljX3NldF9jbGsoZGF0YS0+dXNibWlzY19kYXRhLCBmYWxzZSk7 CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgInVzYm1pc2MgaHNpY19zZXRfY2xrIGZhaWxl ZCwgcmV0PSVkXG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKwogCWlteF9kaXNhYmxlX3Vu cHJlcGFyZV9jbGtzKGRldik7CiAJZGF0YS0+aW5fbHBtID0gdHJ1ZTsKIApAQCAtNDAwLDggKzUw MCwxNiBAQCBzdGF0aWMgaW50IF9fbWF5YmVfdW51c2VkIGlteF9jb250cm9sbGVyX3Jlc3VtZShz dHJ1Y3QgZGV2aWNlICpkZXYpCiAJCWdvdG8gY2xrX2Rpc2FibGU7CiAJfQogCisJcmV0ID0gaW14 X3VzYm1pc2NfaHNpY19zZXRfY2xrKGRhdGEtPnVzYm1pc2NfZGF0YSwgdHJ1ZSk7CisJaWYgKHJl dCkgeworCQlkZXZfZXJyKGRldiwgInVzYm1pc2MgaHNpY19zZXRfY2xrIGZhaWxlZCwgcmV0PSVk XG4iLCByZXQpOworCQlnb3RvIGhzaWNfc2V0X2Nsa19mYWlsOworCX0KKwogCXJldHVybiAwOwog Citoc2ljX3NldF9jbGtfZmFpbDoKKwlpbXhfdXNibWlzY19zZXRfd2FrZXVwKGRhdGEtPnVzYm1p c2NfZGF0YSwgdHJ1ZSk7CiBjbGtfZGlzYWJsZToKIAlpbXhfZGlzYWJsZV91bnByZXBhcmVfY2xr cyhkZXYpOwogCXJldHVybiByZXQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jaGlwaWRlYS9j aV9oZHJjX2lteC5oIGIvZHJpdmVycy91c2IvY2hpcGlkZWEvY2lfaGRyY19pbXguaAppbmRleCAy MDQyNzVmNDc1NzMuLmZjZWNhYjQ3ODkzNCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY2hpcGlk ZWEvY2lfaGRyY19pbXguaAorKysgYi9kcml2ZXJzL3VzYi9jaGlwaWRlYS9jaV9oZHJjX2lteC5o CkBAIC0xNCwxMCArMTQsMTMgQEAgc3RydWN0IGlteF91c2JtaXNjX2RhdGEgewogCXVuc2lnbmVk IGludCBvY19wb2xhcml0eToxOyAvKiBvdmVyIGN1cnJlbnQgcG9sYXJpdHkgaWYgb2MgZW5hYmxl ZCAqLwogCXVuc2lnbmVkIGludCBldmRvOjE7IC8qIHNldCBleHRlcm5hbCB2YnVzIGRpdmlkZXIg b3B0aW9uICovCiAJdW5zaWduZWQgaW50IHVscGk6MTsgLyogY29ubmVjdGVkIHRvIGFuIFVMUEkg cGh5ICovCisJdW5zaWduZWQgaW50IGhzaWM6MTsgLyogSFNJQyBjb250cm9sbGxlciAqLwogfTsK IAotaW50IGlteF91c2JtaXNjX2luaXQoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKik7Ci1pbnQg aW14X3VzYm1pc2NfaW5pdF9wb3N0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICopOwotaW50IGlt eF91c2JtaXNjX3NldF93YWtldXAoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKiwgYm9vbCk7Citp bnQgaW14X3VzYm1pc2NfaW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSk7CitpbnQg aW14X3VzYm1pc2NfaW5pdF9wb3N0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKTsKK2lu dCBpbXhfdXNibWlzY19zZXRfd2FrZXVwKHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhLCBi b29sIGVuYWJsZWQpOworaW50IGlteF91c2JtaXNjX2hzaWNfc2V0X2Nvbm5lY3Qoc3RydWN0IGlt eF91c2JtaXNjX2RhdGEgKmRhdGEpOworaW50IGlteF91c2JtaXNjX2hzaWNfc2V0X2NsayhzdHJ1 Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSwgYm9vbCBvbik7CiAKICNlbmRpZiAvKiBfX0RSSVZF Ul9VU0JfQ0hJUElERUFfQ0lfSERSQ19JTVhfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Iv Y2hpcGlkZWEvdXNibWlzY19pbXguYyBiL2RyaXZlcnMvdXNiL2NoaXBpZGVhL3VzYm1pc2NfaW14 LmMKaW5kZXggZGVmODBmZjU0N2U0Li40M2ExNWE2ZTg2ZjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv dXNiL2NoaXBpZGVhL3VzYm1pc2NfaW14LmMKKysrIGIvZHJpdmVycy91c2IvY2hpcGlkZWEvdXNi bWlzY19pbXguYwpAQCAtNjQsMTAgKzY0LDIyIEBACiAjZGVmaW5lIE1YNl9CTV9PVkVSX0NVUl9E SVMJCUJJVCg3KQogI2RlZmluZSBNWDZfQk1fT1ZFUl9DVVJfUE9MQVJJVFkJQklUKDgpCiAjZGVm aW5lIE1YNl9CTV9XQUtFVVBfRU5BQkxFCQlCSVQoMTApCisjZGVmaW5lIE1YNl9CTV9VVE1JX09O X0NMT0NLCQlCSVQoMTMpCiAjZGVmaW5lIE1YNl9CTV9JRF9XQUtFVVAJCUJJVCgxNikKICNkZWZp bmUgTVg2X0JNX1ZCVVNfV0FLRVVQCQlCSVQoMTcpCiAjZGVmaW5lIE1YNlNYX0JNX0RQRE1fV0FL RVVQX0VOCQlCSVQoMjkpCiAjZGVmaW5lIE1YNl9CTV9XQUtFVVBfSU5UUgkJQklUKDMxKQorCisj ZGVmaW5lIE1YNl9VU0JfSFNJQ19DVFJMX09GRlNFVAkweDEwCisvKiBTZW5kIHJlc3VtZSBzaWdu YWwgd2l0aG91dCA0ODBNaHogUEhZIGNsb2NrICovCisjZGVmaW5lIE1YNlNYX0JNX0hTSUNfQVVU T19SRVNVTUUJQklUKDIzKQorLyogc2V0IGJlZm9yZSBwb3J0c2Muc3VzcGVuZE0gPSAxICovCisj ZGVmaW5lIE1YNl9CTV9IU0lDX0RFVl9DT05OCQlCSVQoMjEpCisvKiBIU0lDIGVuYWJsZSAqLwor I2RlZmluZSBNWDZfQk1fSFNJQ19FTgkJCUJJVCgxMikKKy8qIEZvcmNlIEhTSUMgbW9kdWxlIDQ4 ME0gY2xvY2sgb24sIGV2ZW4gd2hlbiBpbiBIb3N0IGlzIGluIHN1c3BlbmQgbW9kZSAqLworI2Rl ZmluZSBNWDZfQk1fSFNJQ19DTEtfT04JCUJJVCgxMSkKKwogI2RlZmluZSBNWDZfVVNCX09URzFf UEhZX0NUUkwJCTB4MTgKIC8qIEZvciBpbXg2ZHFsLCBpdCBpcyBob3N0LW9ubHkgY29udHJvbGxl ciwgZm9yIGxhdGVyIGlteDYsIGl0IGlzIG90ZydzICovCiAjZGVmaW5lIE1YNl9VU0JfT1RHMl9Q SFlfQ1RSTAkJMHgxYwpAQCAtOTQsNiArMTA2LDEwIEBAIHN0cnVjdCB1c2JtaXNjX29wcyB7CiAJ aW50ICgqcG9zdCkoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpOwogCS8qIEl0J3MgY2Fs bGVkIHdoZW4gd2UgbmVlZCB0byBlbmFibGUvZGlzYWJsZSB1c2Igd2FrZXVwICovCiAJaW50ICgq c2V0X3dha2V1cCkoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgZW5hYmxlZCk7 CisJLyogSXQncyBjYWxsZWQgYmVmb3JlIHNldHRpbmcgcG9ydHNjLnN1c3BlbmRNICovCisJaW50 ICgqaHNpY19zZXRfY29ubmVjdCkoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpOworCS8q IEl0J3MgY2FsbGVkIGR1cmluZyBzdXNwZW5kL3Jlc3VtZSAqLworCWludCAoKmhzaWNfc2V0X2Ns aykoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgZW5hYmxlZCk7CiB9OwogCiBz dHJ1Y3QgaW14X3VzYm1pc2MgewpAQCAtMzUzLDYgKzM2OSwxOCBAQCBzdGF0aWMgaW50IHVzYm1p c2NfaW14NnFfaW5pdChzdHJ1Y3QgaW14X3VzYm1pc2NfZGF0YSAqZGF0YSkKIAl3cml0ZWwocmVn IHwgTVg2X0JNX05PTl9CVVJTVF9TRVRUSU5HLAogCQkJdXNibWlzYy0+YmFzZSArIGRhdGEtPmlu ZGV4ICogNCk7CiAKKwkvKiBGb3IgSFNJQyBjb250cm9sbGVyICovCisJaWYgKGRhdGEtPmhzaWMp IHsKKwkJcmVnID0gcmVhZGwodXNibWlzYy0+YmFzZSArIGRhdGEtPmluZGV4ICogNCk7CisJCXdy aXRlbChyZWcgfCBNWDZfQk1fVVRNSV9PTl9DTE9DSywKKwkJCXVzYm1pc2MtPmJhc2UgKyBkYXRh LT5pbmRleCAqIDQpOworCQlyZWcgPSByZWFkbCh1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lD X0NUUkxfT0ZGU0VUCisJCQkrIChkYXRhLT5pbmRleCAtIDIpICogNCk7CisJCXJlZyB8PSBNWDZf Qk1fSFNJQ19FTiB8IE1YNl9CTV9IU0lDX0NMS19PTjsKKwkJd3JpdGVsKHJlZywgdXNibWlzYy0+ YmFzZSArIE1YNl9VU0JfSFNJQ19DVFJMX09GRlNFVAorCQkJKyAoZGF0YS0+aW5kZXggLSAyKSAq IDQpOworCX0KKwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdz KTsKIAogCXVzYm1pc2NfaW14NnFfc2V0X3dha2V1cChkYXRhLCBmYWxzZSk7CkBAIC0zNjAsNiAr Mzg4LDc5IEBAIHN0YXRpYyBpbnQgdXNibWlzY19pbXg2cV9pbml0KHN0cnVjdCBpbXhfdXNibWlz Y19kYXRhICpkYXRhKQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IHVzYm1pc2NfaW14Nl9o c2ljX2dldF9yZWdfb2Zmc2V0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQoreworCWlu dCBvZmZzZXQsIHJldCA9IDA7CisKKwlpZiAoZGF0YS0+aW5kZXggPT0gMiB8fCBkYXRhLT5pbmRl eCA9PSAzKSB7CisJCW9mZnNldCA9IChkYXRhLT5pbmRleCAtIDIpICogNDsKKwl9IGVsc2UgaWYg KGRhdGEtPmluZGV4ID09IDApIHsKKwkJLyoKKwkJICogRm9yIFNvQ3MgbGlrZSBpLk1YN0QgYW5k IGxhdGVyLCBlYWNoIFVTQiBjb250cm9sbGVyIGhhcworCQkgKiBpdHMgb3duIG5vbi1jb3JlIHJl Z2lzdGVyIHJlZ2lvbi4gRm9yIFNvQ3MgYmVmb3JlIGkuTVg3RCwKKwkJICogdGhlIGZpcnN0IHR3 byBVU0IgY29udHJvbGxlcnMgYXJlIG5vbi1IU0lDIGNvbnRyb2xsZXJzLgorCQkgKi8KKwkJb2Zm c2V0ID0gMDsKKwl9IGVsc2UgeworCQlkZXZfZXJyKGRhdGEtPmRldiwgImluZGV4IGlzIGVycm9y IGZvciB1c2JtaXNjXG4iKTsKKwkJcmV0ID0gLUVJTlZBTDsKKwl9CisKKwlyZXR1cm4gcmV0ID8g cmV0IDogb2Zmc2V0OworfQorCitzdGF0aWMgaW50IHVzYm1pc2NfaW14Nl9oc2ljX3NldF9jb25u ZWN0KHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQoreworCXVuc2lnbmVkIGxvbmcgZmxh Z3M7CisJdTMyIHZhbDsKKwlzdHJ1Y3QgaW14X3VzYm1pc2MgKnVzYm1pc2MgPSBkZXZfZ2V0X2Ry dmRhdGEoZGF0YS0+ZGV2KTsKKwlpbnQgb2Zmc2V0OworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnVz Ym1pc2MtPmxvY2ssIGZsYWdzKTsKKwlvZmZzZXQgPSB1c2JtaXNjX2lteDZfaHNpY19nZXRfcmVn X29mZnNldChkYXRhKTsKKwlpZiAob2Zmc2V0IDwgMCkgeworCQlzcGluX3VubG9ja19pcnFyZXN0 b3JlKCZ1c2JtaXNjLT5sb2NrLCBmbGFncyk7CisJCXJldHVybiBvZmZzZXQ7CisJfQorCisJdmFs ID0gcmVhZGwodXNibWlzYy0+YmFzZSArIE1YNl9VU0JfSFNJQ19DVFJMX09GRlNFVCArIG9mZnNl dCk7CisJaWYgKCEodmFsICYgTVg2X0JNX0hTSUNfREVWX0NPTk4pKQorCQl3cml0ZWwodmFsIHwg TVg2X0JNX0hTSUNfREVWX0NPTk4sCisJCQl1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lDX0NU UkxfT0ZGU0VUICsgb2Zmc2V0KTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnVzYm1pc2Mt PmxvY2ssIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHVzYm1pc2NfaW14 Nl9oc2ljX3NldF9jbGsoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEsIGJvb2wgb24pCit7 CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgdmFsOworCXN0cnVjdCBpbXhfdXNibWlzYyAq dXNibWlzYyA9IGRldl9nZXRfZHJ2ZGF0YShkYXRhLT5kZXYpOworCWludCBvZmZzZXQ7CisKKwlz cGluX2xvY2tfaXJxc2F2ZSgmdXNibWlzYy0+bG9jaywgZmxhZ3MpOworCW9mZnNldCA9IHVzYm1p c2NfaW14Nl9oc2ljX2dldF9yZWdfb2Zmc2V0KGRhdGEpOworCWlmIChvZmZzZXQgPCAwKSB7CisJ CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsKKwkJcmV0dXJu IG9mZnNldDsKKwl9CisKKwl2YWwgPSByZWFkbCh1c2JtaXNjLT5iYXNlICsgTVg2X1VTQl9IU0lD X0NUUkxfT0ZGU0VUICsgb2Zmc2V0KTsKKwl2YWwgfD0gTVg2X0JNX0hTSUNfRU4gfCBNWDZfQk1f SFNJQ19DTEtfT047CisJaWYgKG9uKQorCQl2YWwgfD0gTVg2X0JNX0hTSUNfQ0xLX09OOworCWVs c2UKKwkJdmFsICY9IH5NWDZfQk1fSFNJQ19DTEtfT047CisKKwl3cml0ZWwodmFsLCB1c2JtaXNj LT5iYXNlICsgTVg2X1VTQl9IU0lDX0NUUkxfT0ZGU0VUICsgb2Zmc2V0KTsKKwlzcGluX3VubG9j a19pcnFyZXN0b3JlKCZ1c2JtaXNjLT5sb2NrLCBmbGFncyk7CisKKwlyZXR1cm4gMDsKK30KKwor CiBzdGF0aWMgaW50IHVzYm1pc2NfaW14NnN4X2luaXQoc3RydWN0IGlteF91c2JtaXNjX2RhdGEg KmRhdGEpCiB7CiAJdm9pZCBfX2lvbWVtICpyZWcgPSBOVUxMOwpAQCAtMzg1LDYgKzQ4NiwxMyBA QCBzdGF0aWMgaW50IHVzYm1pc2NfaW14NnN4X2luaXQoc3RydWN0IGlteF91c2JtaXNjX2RhdGEg KmRhdGEpCiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnVzYm1pc2MtPmxvY2ssIGZsYWdzKTsK IAl9CiAKKwkvKiBGb3IgSFNJQyBjb250cm9sbGVyICovCisJaWYgKGRhdGEtPmhzaWMpIHsKKwkJ dmFsID0gcmVhZGwodXNibWlzYy0+YmFzZSArIE1YNl9VU0JfSFNJQ19DVFJMX09GRlNFVCk7CisJ CXZhbCB8PSBNWDZTWF9CTV9IU0lDX0FVVE9fUkVTVU1FOworCQl3cml0ZWwodmFsLCB1c2JtaXNj LT5iYXNlICsgTVg2X1VTQl9IU0lDX0NUUkxfT0ZGU0VUKTsKKwl9CisKIAlyZXR1cm4gMDsKIH0K IApAQCAtNDU0LDYgKzU2Miw3IEBAIHN0YXRpYyBpbnQgdXNibWlzY19pbXg3ZF9pbml0KHN0cnVj dCBpbXhfdXNibWlzY19kYXRhICpkYXRhKQogCXJlZyAmPSB+TVg3RF9VU0JfVkJVU19XQUtFVVBf U09VUkNFX01BU0s7CiAJd3JpdGVsKHJlZyB8IE1YN0RfVVNCX1ZCVVNfV0FLRVVQX1NPVVJDRV9C VkFMSUQsCiAJCSB1c2JtaXNjLT5iYXNlICsgTVg3RF9VU0JOQ19VU0JfQ1RSTDIpOworCiAJc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmdXNibWlzYy0+bG9jaywgZmxhZ3MpOwogCiAJdXNibWlzY19p bXg3ZF9zZXRfd2FrZXVwKGRhdGEsIGZhbHNlKTsKQEAgLTQ4MSw2ICs1OTAsOCBAQCBzdGF0aWMg Y29uc3Qgc3RydWN0IHVzYm1pc2Nfb3BzIGlteDUzX3VzYm1pc2Nfb3BzID0gewogc3RhdGljIGNv bnN0IHN0cnVjdCB1c2JtaXNjX29wcyBpbXg2cV91c2JtaXNjX29wcyA9IHsKIAkuc2V0X3dha2V1 cCA9IHVzYm1pc2NfaW14NnFfc2V0X3dha2V1cCwKIAkuaW5pdCA9IHVzYm1pc2NfaW14NnFfaW5p dCwKKwkuaHNpY19zZXRfY29ubmVjdCA9IHVzYm1pc2NfaW14Nl9oc2ljX3NldF9jb25uZWN0LAor CS5oc2ljX3NldF9jbGsgICA9IHVzYm1pc2NfaW14Nl9oc2ljX3NldF9jbGssCiB9OwogCiBzdGF0 aWMgY29uc3Qgc3RydWN0IHVzYm1pc2Nfb3BzIHZmNjEwX3VzYm1pc2Nfb3BzID0gewpAQCAtNDkw LDYgKzYwMSw4IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNibWlzY19vcHMgdmY2MTBfdXNibWlz Y19vcHMgPSB7CiBzdGF0aWMgY29uc3Qgc3RydWN0IHVzYm1pc2Nfb3BzIGlteDZzeF91c2JtaXNj X29wcyA9IHsKIAkuc2V0X3dha2V1cCA9IHVzYm1pc2NfaW14NnFfc2V0X3dha2V1cCwKIAkuaW5p dCA9IHVzYm1pc2NfaW14NnN4X2luaXQsCisJLmhzaWNfc2V0X2Nvbm5lY3QgPSB1c2JtaXNjX2lt eDZfaHNpY19zZXRfY29ubmVjdCwKKwkuaHNpY19zZXRfY2xrID0gdXNibWlzY19pbXg2X2hzaWNf c2V0X2NsaywKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNibWlzY19vcHMgaW14N2RfdXNi bWlzY19vcHMgPSB7CkBAIC01NDYsNiArNjU5LDMzIEBAIGludCBpbXhfdXNibWlzY19zZXRfd2Fr ZXVwKHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhLCBib29sIGVuYWJsZWQpCiB9CiBFWFBP UlRfU1lNQk9MX0dQTChpbXhfdXNibWlzY19zZXRfd2FrZXVwKTsKIAoraW50IGlteF91c2JtaXNj X2hzaWNfc2V0X2Nvbm5lY3Qoc3RydWN0IGlteF91c2JtaXNjX2RhdGEgKmRhdGEpCit7CisJc3Ry dWN0IGlteF91c2JtaXNjICp1c2JtaXNjOworCisJaWYgKCFkYXRhKQorCQlyZXR1cm4gMDsKKwor CXVzYm1pc2MgPSBkZXZfZ2V0X2RydmRhdGEoZGF0YS0+ZGV2KTsKKwlpZiAoIXVzYm1pc2MtPm9w cy0+aHNpY19zZXRfY29ubmVjdCB8fCAhZGF0YS0+aHNpYykKKwkJcmV0dXJuIDA7CisJcmV0dXJu IHVzYm1pc2MtPm9wcy0+aHNpY19zZXRfY29ubmVjdChkYXRhKTsKK30KK0VYUE9SVF9TWU1CT0xf R1BMKGlteF91c2JtaXNjX2hzaWNfc2V0X2Nvbm5lY3QpOworCitpbnQgaW14X3VzYm1pc2NfaHNp Y19zZXRfY2xrKHN0cnVjdCBpbXhfdXNibWlzY19kYXRhICpkYXRhLCBib29sIG9uKQoreworCXN0 cnVjdCBpbXhfdXNibWlzYyAqdXNibWlzYzsKKworCWlmICghZGF0YSkKKwkJcmV0dXJuIDA7CisK Kwl1c2JtaXNjID0gZGV2X2dldF9kcnZkYXRhKGRhdGEtPmRldik7CisJaWYgKCF1c2JtaXNjLT5v cHMtPmhzaWNfc2V0X2NsayB8fCAhZGF0YS0+aHNpYykKKwkJcmV0dXJuIDA7CisJcmV0dXJuIHVz Ym1pc2MtPm9wcy0+aHNpY19zZXRfY2xrKGRhdGEsIG9uKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BM KGlteF91c2JtaXNjX2hzaWNfc2V0X2Nsayk7CiBzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rldmlj ZV9pZCB1c2JtaXNjX2lteF9kdF9pZHNbXSA9IHsKIAl7CiAJCS5jb21wYXRpYmxlID0gImZzbCxp bXgyNS11c2JtaXNjIiwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-eopbgr00074.outbound.protection.outlook.com ([40.107.0.74]:49632 "EHLO EUR02-AM5-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1729474AbeLKCJC (ORCPT ); Mon, 10 Dec 2018 21:09:02 -0500 From: Peter Chen Subject: [PATCH v5 2/4] usb: chipidea: imx: add HSIC support Date: Tue, 11 Dec 2018 02:08:57 +0000 Message-ID: <20181211020624.9433-3-peter.chen@nxp.com> References: <20181211020624.9433-1-peter.chen@nxp.com> In-Reply-To: <20181211020624.9433-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 Reviewed-by: Frieder Schrempf Tested-by: Frieder Schrempf 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