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: [v4,6/6] usb: mtu3: register a USB Role Switch for dual role mode From: Chunfeng Yun Message-Id: <1556261237-13823-7-git-send-email-chunfeng.yun@mediatek.com> Date: Fri, 26 Apr 2019 14:47:17 +0800 To: Rob Herring , Greg Kroah-Hartman , Heikki Krogerus Cc: Mark Rutland , Chunfeng Yun , Matthias Brugger , Adam Thomson , Li Jun , Badhri Jagan Sridharan , Hans de Goede , Andy Shevchenko , Min Guo , devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mediatek@lists.infradead.org, Biju Das , Linus Walleij List-ID: QmVjYXVzZSBleHRjb24gaXMgbm90IGFsbG93ZWQgZm9yIG5ldyBiaW5kaW5ncywgYW5kIHRoZQpk dWFsIHJvbGUgc3dpdGNoIGlzIHN1cHBvcnRlZCBieSBVU0IgUm9sZSBTd2l0Y2gsCmVzcGVjaWFs bHkgZm9yIFR5cGUtQyBkcml2ZXJzLCBzbyByZWdpc3RlciBhIFVTQiBSb2xlClN3aXRjaCB0byBz dXBwb3J0IHRoZSBuZXcgd2F5CgpTaWduZWQtb2ZmLWJ5OiBDaHVuZmVuZyBZdW4gPGNodW5mZW5n Lnl1bkBtZWRpYXRlay5jb20+Ci0tLQp2NCBjaGFuZ2VzOgogIDEuIGFzc2lnbiBmd25vZGUgbWVt YmVyIG9mIHVzYl9yb2xlX3N3aXRjaCBzdHJ1Y3Qgc3VnZ2VzdGVkIGJ5IEhlaWtraQoKdjMgY2hh bmdlczoKICAxLiBzZWxlY3QgVVNCX1JPTEVfU1dJVENIIGluIEtjb25maWcgc3VnZ2VzdGVkIGJ5 IEhlaWtraQogIDIuIHJlbmFtZSBzc3VzYl9tb2RlX21hbnVhbF9zd2l0Y2goKSB0byBzc3VzYl9t b2RlX3N3aXRjaCgpCgp2MiBubyBjaGFuZ2UKLS0tCiBkcml2ZXJzL3VzYi9tdHUzL0tjb25maWcg ICAgICAgIHwgIDEgKwogZHJpdmVycy91c2IvbXR1My9tdHUzLmggICAgICAgICB8ICA1ICsrKysK IGRyaXZlcnMvdXNiL210dTMvbXR1M19kZWJ1Z2ZzLmMgfCAgNCArLS0KIGRyaXZlcnMvdXNiL210 dTMvbXR1M19kci5jICAgICAgfCA0OCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0K IGRyaXZlcnMvdXNiL210dTMvbXR1M19kci5oICAgICAgfCAgNiArKy0tLQogZHJpdmVycy91c2Iv bXR1My9tdHUzX3BsYXQuYyAgICB8ICAzICsrLQogNiBmaWxlcyBjaGFuZ2VkLCA2MCBpbnNlcnRp b25zKCspLCA3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL210dTMvS2Nv bmZpZyBiL2RyaXZlcnMvdXNiL210dTMvS2NvbmZpZwppbmRleCBiY2MyMzQ4NmM0ZWQuLjg4ZTNk YjdiMzAxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvbXR1My9LY29uZmlnCisrKyBiL2RyaXZl cnMvdXNiL210dTMvS2NvbmZpZwpAQCAtNDMsNiArNDMsNyBAQCBjb25maWcgVVNCX01UVTNfRFVB TF9ST0xFCiAJYm9vbCAiRHVhbCBSb2xlIG1vZGUiCiAJZGVwZW5kcyBvbiAoKFVTQj15IHx8IFVT Qj1VU0JfTVRVMykgJiYgKFVTQl9HQURHRVQ9eSB8fCBVU0JfR0FER0VUPVVTQl9NVFUzKSkKIAlk ZXBlbmRzIG9uIChFWFRDT049eSB8fCBFWFRDT049VVNCX01UVTMpCisJc2VsZWN0IFVTQl9ST0xF X1NXSVRDSAogCWhlbHAKIAkgIFRoaXMgaXMgdGhlIGRlZmF1bHQgbW9kZSBvZiB3b3JraW5nIG9m IE1UVTMgY29udHJvbGxlciB3aGVyZQogCSAgYm90aCBob3N0IGFuZCBnYWRnZXQgZmVhdHVyZXMg YXJlIGVuYWJsZWQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9tdHUzL210dTMuaCBiL2RyaXZl cnMvdXNiL210dTMvbXR1My5oCmluZGV4IDc2ZWNmMTJmZGY2Mi4uNjA4N2JlMjM2YTM1IDEwMDY0 NAotLS0gYS9kcml2ZXJzL3VzYi9tdHUzL210dTMuaAorKysgYi9kcml2ZXJzL3VzYi9tdHUzL210 dTMuaApAQCAtMTk5LDYgKzE5OSw5IEBAIHN0cnVjdCBtdHUzX2dwZF9yaW5nIHsKICogQGlkX25i IDogbm90aWZpZXIgZm9yIGlkZGlnKGlkcGluKSBkZXRlY3Rpb24KICogQGlkX3dvcmsgOiB3b3Jr IG9mIGlkZGlnIGRldGVjdGlvbiBub3RpZmllcgogKiBAaWRfZXZlbnQgOiBldmVudCBvZiBpZGRp ZyBkZXRlY2lvbiBub3RpZmllcgorKiBAcm9sZV9zdyA6IHVzZSBVU0IgUm9sZSBTd2l0Y2ggdG8g c3VwcG9ydCBkdWFsLXJvbGUgc3dpdGNoLCBjYW4ndCB1c2UKKyoJCWV4dGNvbiBhdCB0aGUgc2Ft ZSB0aW1lLCBhbmQgZXh0Y29uIGlzIGRlcHJlY2F0ZWQuCisqIEByb2xlX3N3X3VzZWQgOiB0cnVl IHdoZW4gdGhlIFVTQiBSb2xlIFN3aXRjaCBpcyB1c2VkLgogKiBAaXNfdTNfZHJkOiB3aGV0aGVy IHBvcnQwIHN1cHBvcnRzIHVzYjMuMCBkdWFsLXJvbGUgZGV2aWNlIG9yIG5vdAogKiBAbWFudWFs X2RyZF9lbmFibGVkOiBpdCdzIHRydWUgd2hlbiBzdXBwb3J0cyBkdWFsLXJvbGUgZGV2aWNlIGJ5 IGRlYnVnZnMKICoJCXRvIHN3aXRjaCBob3N0L2RldmljZSBtb2RlcyBkZXBlbmRpbmcgb24gdXNl ciBpbnB1dC4KQEAgLTIxMiw2ICsyMTUsOCBAQCBzdHJ1Y3Qgb3RnX3N3aXRjaF9tdGsgewogCXN0 cnVjdCBub3RpZmllcl9ibG9jayBpZF9uYjsKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3QgaWRfd29yazsK IAl1bnNpZ25lZCBsb25nIGlkX2V2ZW50OworCXN0cnVjdCB1c2Jfcm9sZV9zd2l0Y2ggKnJvbGVf c3c7CisJYm9vbCByb2xlX3N3X3VzZWQ7CiAJYm9vbCBpc191M19kcmQ7CiAJYm9vbCBtYW51YWxf ZHJkX2VuYWJsZWQ7CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvbXR1My9tdHUzX2RlYnVn ZnMuYyBiL2RyaXZlcnMvdXNiL210dTMvbXR1M19kZWJ1Z2ZzLmMKaW5kZXggNjJjNTdkZGM1NTRl Li5jOTZlNWRhYjBhNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL210dTMvbXR1M19kZWJ1Z2Zz LmMKKysrIGIvZHJpdmVycy91c2IvbXR1My9tdHUzX2RlYnVnZnMuYwpAQCAtNDUzLDkgKzQ1Myw5 IEBAIHN0YXRpYyBzc2l6ZV90IHNzdXNiX21vZGVfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNv bnN0IGNoYXIgX191c2VyICp1YnVmLAogCQlyZXR1cm4gLUVGQVVMVDsKIAogCWlmICghc3RybmNt cChidWYsICJob3N0IiwgNCkgJiYgIXNzdXNiLT5pc19ob3N0KSB7Ci0JCXNzdXNiX21vZGVfbWFu dWFsX3N3aXRjaChzc3VzYiwgMSk7CisJCXNzdXNiX21vZGVfc3dpdGNoKHNzdXNiLCAxKTsKIAl9 IGVsc2UgaWYgKCFzdHJuY21wKGJ1ZiwgImRldmljZSIsIDYpICYmIHNzdXNiLT5pc19ob3N0KSB7 Ci0JCXNzdXNiX21vZGVfbWFudWFsX3N3aXRjaChzc3VzYiwgMCk7CisJCXNzdXNiX21vZGVfc3dp dGNoKHNzdXNiLCAwKTsKIAl9IGVsc2UgewogCQlkZXZfZXJyKHNzdXNiLT5kZXYsICJ3cm9uZyBv ciBkdXBsaWNhdGVkIHNldHRpbmdcbiIpOwogCQlyZXR1cm4gLUVJTlZBTDsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvdXNiL210dTMvbXR1M19kci5jIGIvZHJpdmVycy91c2IvbXR1My9tdHUzX2RyLmMK aW5kZXggNWZjYjcxYWY4NzVhLi4wOGUxODQ0OGU4YjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNi L210dTMvbXR1M19kci5jCisrKyBiL2RyaXZlcnMvdXNiL210dTMvbXR1M19kci5jCkBAIC03LDYg KzcsOCBAQAogICogQXV0aG9yOiBDaHVuZmVuZyBZdW4gPGNodW5mZW5nLnl1bkBtZWRpYXRlay5j b20+CiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3VzYi9yb2xlLmg+CisKICNpbmNsdWRlICJtdHUz LmgiCiAjaW5jbHVkZSAibXR1M19kci5oIgogI2luY2x1ZGUgIm10dTNfZGVidWcuaCIKQEAgLTI4 MCw3ICsyODIsNyBAQCBzdGF0aWMgaW50IHNzdXNiX2V4dGNvbl9yZWdpc3RlcihzdHJ1Y3Qgb3Rn X3N3aXRjaF9tdGsgKm90Z19zeCkKICAqIFRoaXMgaXMgdXNlZnVsIGluIHNwZWNpYWwgY2FzZXMs IHN1Y2ggYXMgdXNlcyBUWVBFLUEgcmVjZXB0YWNsZSBidXQgYWxzbwogICogd2FudHMgdG8gc3Vw cG9ydCBkdWFsLXJvbGUgbW9kZS4KICAqLwotdm9pZCBzc3VzYl9tb2RlX21hbnVhbF9zd2l0Y2go c3RydWN0IHNzdXNiX210ayAqc3N1c2IsIGludCB0b19ob3N0KQordm9pZCBzc3VzYl9tb2RlX3N3 aXRjaChzdHJ1Y3Qgc3N1c2JfbXRrICpzc3VzYiwgaW50IHRvX2hvc3QpCiB7CiAJc3RydWN0IG90 Z19zd2l0Y2hfbXRrICpvdGdfc3ggPSAmc3N1c2ItPm90Z19zd2l0Y2g7CiAKQEAgLTMxOCw2ICsz MjAsNDcgQEAgdm9pZCBzc3VzYl9zZXRfZm9yY2VfbW9kZShzdHJ1Y3Qgc3N1c2JfbXRrICpzc3Vz YiwKIAltdHUzX3dyaXRlbChzc3VzYi0+aXBwY19iYXNlLCBTU1VTQl9VMl9DVFJMKDApLCB2YWx1 ZSk7CiB9CiAKK3N0YXRpYyBpbnQgc3N1c2Jfcm9sZV9zd19zZXQoc3RydWN0IGRldmljZSAqZGV2 LCBlbnVtIHVzYl9yb2xlIHJvbGUpCit7CisJc3RydWN0IHNzdXNiX210ayAqc3N1c2IgPSBkZXZf Z2V0X2RydmRhdGEoZGV2KTsKKwlib29sIHRvX2hvc3QgPSBmYWxzZTsKKworCWlmIChyb2xlID09 IFVTQl9ST0xFX0hPU1QpCisJCXRvX2hvc3QgPSB0cnVlOworCisJaWYgKHRvX2hvc3QgXiBzc3Vz Yi0+aXNfaG9zdCkKKwkJc3N1c2JfbW9kZV9zd2l0Y2goc3N1c2IsIHRvX2hvc3QpOworCisJcmV0 dXJuIDA7Cit9CisKK3N0YXRpYyBlbnVtIHVzYl9yb2xlIHNzdXNiX3JvbGVfc3dfZ2V0KHN0cnVj dCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3N1c2JfbXRrICpzc3VzYiA9IGRldl9nZXRfZHJ2 ZGF0YShkZXYpOworCWVudW0gdXNiX3JvbGUgcm9sZTsKKworCXJvbGUgPSBzc3VzYi0+aXNfaG9z dCA/IFVTQl9ST0xFX0hPU1QgOiBVU0JfUk9MRV9ERVZJQ0U7CisKKwlyZXR1cm4gcm9sZTsKK30K Kworc3RhdGljIGludCBzc3VzYl9yb2xlX3N3X3JlZ2lzdGVyKHN0cnVjdCBvdGdfc3dpdGNoX210 ayAqb3RnX3N4KQoreworCXN0cnVjdCB1c2Jfcm9sZV9zd2l0Y2hfZGVzYyByb2xlX3N4X2Rlc2Mg PSB7IDAgfTsKKwlzdHJ1Y3Qgc3N1c2JfbXRrICpzc3VzYiA9CisJCWNvbnRhaW5lcl9vZihvdGdf c3gsIHN0cnVjdCBzc3VzYl9tdGssIG90Z19zd2l0Y2gpOworCisJaWYgKCFvdGdfc3gtPnJvbGVf c3dfdXNlZCkKKwkJcmV0dXJuIDA7CisKKwlyb2xlX3N4X2Rlc2Muc2V0ID0gc3N1c2Jfcm9sZV9z d19zZXQ7CisJcm9sZV9zeF9kZXNjLmdldCA9IHNzdXNiX3JvbGVfc3dfZ2V0OworCXJvbGVfc3hf ZGVzYy5md25vZGUgPSBkZXZfZndub2RlKHNzdXNiLT5kZXYpOworCW90Z19zeC0+cm9sZV9zdyA9 IHVzYl9yb2xlX3N3aXRjaF9yZWdpc3Rlcihzc3VzYi0+ZGV2LCAmcm9sZV9zeF9kZXNjKTsKKwor CXJldHVybiBQVFJfRVJSX09SX1pFUk8ob3RnX3N4LT5yb2xlX3N3KTsKK30KKwogaW50IHNzdXNi X290Z19zd2l0Y2hfaW5pdChzdHJ1Y3Qgc3N1c2JfbXRrICpzc3VzYikKIHsKIAlzdHJ1Y3Qgb3Rn X3N3aXRjaF9tdGsgKm90Z19zeCA9ICZzc3VzYi0+b3RnX3N3aXRjaDsKQEAgLTMyOCw2ICszNzEs OCBAQCBpbnQgc3N1c2Jfb3RnX3N3aXRjaF9pbml0KHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNiKQog CiAJaWYgKG90Z19zeC0+bWFudWFsX2RyZF9lbmFibGVkKQogCQlzc3VzYl9kcl9kZWJ1Z2ZzX2lu aXQoc3N1c2IpOworCWVsc2UgaWYgKG90Z19zeC0+cm9sZV9zd191c2VkKQorCQlyZXQgPSBzc3Vz Yl9yb2xlX3N3X3JlZ2lzdGVyKG90Z19zeCk7CiAJZWxzZQogCQlyZXQgPSBzc3VzYl9leHRjb25f cmVnaXN0ZXIob3RnX3N4KTsKIApAQCAtMzQwLDQgKzM4NSw1IEBAIHZvaWQgc3N1c2Jfb3RnX3N3 aXRjaF9leGl0KHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNiKQogCiAJY2FuY2VsX3dvcmtfc3luYygm b3RnX3N4LT5pZF93b3JrKTsKIAljYW5jZWxfd29ya19zeW5jKCZvdGdfc3gtPnZidXNfd29yayk7 CisJdXNiX3JvbGVfc3dpdGNoX3VucmVnaXN0ZXIob3RnX3N4LT5yb2xlX3N3KTsKIH0KZGlmZiAt LWdpdCBhL2RyaXZlcnMvdXNiL210dTMvbXR1M19kci5oIGIvZHJpdmVycy91c2IvbXR1My9tdHUz X2RyLmgKaW5kZXggYmE2ZmUzNTdjZTI5Li41ZTU4YzRkYmQ1NGEgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvdXNiL210dTMvbXR1M19kci5oCisrKyBiL2RyaXZlcnMvdXNiL210dTMvbXR1M19kci5oCkBA IC03MSw3ICs3MSw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBzc3VzYl9nYWRnZXRfZXhpdChzdHJ1 Y3Qgc3N1c2JfbXRrICpzc3VzYikKICNpZiBJU19FTkFCTEVEKENPTkZJR19VU0JfTVRVM19EVUFM X1JPTEUpCiBpbnQgc3N1c2Jfb3RnX3N3aXRjaF9pbml0KHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNi KTsKIHZvaWQgc3N1c2Jfb3RnX3N3aXRjaF9leGl0KHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNiKTsK LXZvaWQgc3N1c2JfbW9kZV9tYW51YWxfc3dpdGNoKHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNiLCBp bnQgdG9faG9zdCk7Cit2b2lkIHNzdXNiX21vZGVfc3dpdGNoKHN0cnVjdCBzc3VzYl9tdGsgKnNz dXNiLCBpbnQgdG9faG9zdCk7CiBpbnQgc3N1c2Jfc2V0X3ZidXMoc3RydWN0IG90Z19zd2l0Y2hf bXRrICpvdGdfc3gsIGludCBpc19vbik7CiB2b2lkIHNzdXNiX3NldF9mb3JjZV9tb2RlKHN0cnVj dCBzc3VzYl9tdGsgKnNzdXNiLAogCQkJICBlbnVtIG10dTNfZHJfZm9yY2VfbW9kZSBtb2RlKTsK QEAgLTg2LDggKzg2LDggQEAgc3RhdGljIGlubGluZSBpbnQgc3N1c2Jfb3RnX3N3aXRjaF9pbml0 KHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNiKQogc3RhdGljIGlubGluZSB2b2lkIHNzdXNiX290Z19z d2l0Y2hfZXhpdChzdHJ1Y3Qgc3N1c2JfbXRrICpzc3VzYikKIHt9CiAKLXN0YXRpYyBpbmxpbmUg dm9pZAotc3N1c2JfbW9kZV9tYW51YWxfc3dpdGNoKHN0cnVjdCBzc3VzYl9tdGsgKnNzdXNiLCBp bnQgdG9faG9zdCkge30KK3N0YXRpYyBpbmxpbmUgdm9pZCBzc3VzYl9tb2RlX3N3aXRjaChzdHJ1 Y3Qgc3N1c2JfbXRrICpzc3VzYiwgaW50IHRvX2hvc3QpCit7fQogCiBzdGF0aWMgaW5saW5lIGlu dCBzc3VzYl9zZXRfdmJ1cyhzdHJ1Y3Qgb3RnX3N3aXRjaF9tdGsgKm90Z19zeCwgaW50IGlzX29u KQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvbXR1My9tdHUzX3BsYXQuYyBiL2RyaXZlcnMv dXNiL210dTMvbXR1M19wbGF0LmMKaW5kZXggZmQwZjZjNWRmYmMxLi45YzI1NmVhM2NkZjUgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL210dTMvbXR1M19wbGF0LmMKKysrIGIvZHJpdmVycy91c2Iv bXR1My9tdHUzX3BsYXQuYwpAQCAtMjk5LDggKzI5OSw5IEBAIHN0YXRpYyBpbnQgZ2V0X3NzdXNi X3JzY3Moc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwgc3RydWN0IHNzdXNiX210ayAqc3N1 c2IpCiAJb3RnX3N4LT5pc191M19kcmQgPSBvZl9wcm9wZXJ0eV9yZWFkX2Jvb2wobm9kZSwgIm1l ZGlhdGVrLHVzYjMtZHJkIik7CiAJb3RnX3N4LT5tYW51YWxfZHJkX2VuYWJsZWQgPQogCQlvZl9w cm9wZXJ0eV9yZWFkX2Jvb2wobm9kZSwgImVuYWJsZS1tYW51YWwtZHJkIik7CisJb3RnX3N4LT5y b2xlX3N3X3VzZWQgPSBvZl9wcm9wZXJ0eV9yZWFkX2Jvb2wobm9kZSwgInVzYi1yb2xlLXN3aXRj aCIpOwogCi0JaWYgKG9mX3Byb3BlcnR5X3JlYWRfYm9vbChub2RlLCAiZXh0Y29uIikpIHsKKwlp ZiAoIW90Z19zeC0+cm9sZV9zd191c2VkICYmIG9mX3Byb3BlcnR5X3JlYWRfYm9vbChub2RlLCAi ZXh0Y29uIikpIHsKIAkJb3RnX3N4LT5lZGV2ID0gZXh0Y29uX2dldF9lZGV2X2J5X3BoYW5kbGUo c3N1c2ItPmRldiwgMCk7CiAJCWlmIChJU19FUlIob3RnX3N4LT5lZGV2KSkgewogCQkJZGV2X2Vy cihzc3VzYi0+ZGV2LCAiY291bGRuJ3QgZ2V0IGV4dGNvbiBkZXZpY2VcbiIpOwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.9 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 156A1C43218 for ; Fri, 26 Apr 2019 06:47:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id DB467206DD for ; Fri, 26 Apr 2019 06:47:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726403AbfDZGr4 (ORCPT ); Fri, 26 Apr 2019 02:47:56 -0400 Received: from Mailgw01.mediatek.com ([1.203.163.78]:17039 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726120AbfDZGrw (ORCPT ); Fri, 26 Apr 2019 02:47:52 -0400 X-UUID: e7c87a58c5e84f89a9c42ed545c932ed-20190426 X-UUID: e7c87a58c5e84f89a9c42ed545c932ed-20190426 Received: from mtkcas36.mediatek.inc [(172.27.4.253)] by mailgw01.mediatek.com (envelope-from ) (mailgw01.mediatek.com ESMTP with TLS) with ESMTP id 1437078695; Fri, 26 Apr 2019 14:47:43 +0800 Received: from mtkcas07.mediatek.inc (172.21.101.84) by MTKMBS31N1.mediatek.inc (172.27.4.69) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Fri, 26 Apr 2019 14:47:42 +0800 Received: from localhost.localdomain (10.17.3.153) by mtkcas07.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Fri, 26 Apr 2019 14:47:40 +0800 From: Chunfeng Yun To: Rob Herring , Greg Kroah-Hartman , Heikki Krogerus CC: Mark Rutland , Chunfeng Yun , Matthias Brugger , Adam Thomson , Li Jun , Badhri Jagan Sridharan , Hans de Goede , Andy Shevchenko , Min Guo , , , , , , Biju Das , Linus Walleij Subject: [PATCH v4 6/6] usb: mtu3: register a USB Role Switch for dual role mode Date: Fri, 26 Apr 2019 14:47:17 +0800 Message-ID: <1556261237-13823-7-git-send-email-chunfeng.yun@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1556261237-13823-1-git-send-email-chunfeng.yun@mediatek.com> References: <1556261237-13823-1-git-send-email-chunfeng.yun@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" X-MTK: N Sender: linux-usb-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-usb@vger.kernel.org Message-ID: <20190426064717.gy1Pqsh3Rr9kundOiawhrpEBU7N0WaSfoET_n2NMT0U@z> Because extcon is not allowed for new bindings, and the dual role switch is supported by USB Role Switch, especially for Type-C drivers, so register a USB Role Switch to support the new way Signed-off-by: Chunfeng Yun --- v4 changes: 1. assign fwnode member of usb_role_switch struct suggested by Heikki v3 changes: 1. select USB_ROLE_SWITCH in Kconfig suggested by Heikki 2. rename ssusb_mode_manual_switch() to ssusb_mode_switch() v2 no change --- drivers/usb/mtu3/Kconfig | 1 + drivers/usb/mtu3/mtu3.h | 5 ++++ drivers/usb/mtu3/mtu3_debugfs.c | 4 +-- drivers/usb/mtu3/mtu3_dr.c | 48 ++++++++++++++++++++++++++++++++- drivers/usb/mtu3/mtu3_dr.h | 6 ++--- drivers/usb/mtu3/mtu3_plat.c | 3 ++- 6 files changed, 60 insertions(+), 7 deletions(-) diff --git a/drivers/usb/mtu3/Kconfig b/drivers/usb/mtu3/Kconfig index bcc23486c4ed..88e3db7b3016 100644 --- a/drivers/usb/mtu3/Kconfig +++ b/drivers/usb/mtu3/Kconfig @@ -43,6 +43,7 @@ config USB_MTU3_DUAL_ROLE bool "Dual Role mode" depends on ((USB=y || USB=USB_MTU3) && (USB_GADGET=y || USB_GADGET=USB_MTU3)) depends on (EXTCON=y || EXTCON=USB_MTU3) + select USB_ROLE_SWITCH help This is the default mode of working of MTU3 controller where both host and gadget features are enabled. diff --git a/drivers/usb/mtu3/mtu3.h b/drivers/usb/mtu3/mtu3.h index 76ecf12fdf62..6087be236a35 100644 --- a/drivers/usb/mtu3/mtu3.h +++ b/drivers/usb/mtu3/mtu3.h @@ -199,6 +199,9 @@ struct mtu3_gpd_ring { * @id_nb : notifier for iddig(idpin) detection * @id_work : work of iddig detection notifier * @id_event : event of iddig detecion notifier +* @role_sw : use USB Role Switch to support dual-role switch, can't use +* extcon at the same time, and extcon is deprecated. +* @role_sw_used : true when the USB Role Switch is used. * @is_u3_drd: whether port0 supports usb3.0 dual-role device or not * @manual_drd_enabled: it's true when supports dual-role device by debugfs * to switch host/device modes depending on user input. @@ -212,6 +215,8 @@ struct otg_switch_mtk { struct notifier_block id_nb; struct work_struct id_work; unsigned long id_event; + struct usb_role_switch *role_sw; + bool role_sw_used; bool is_u3_drd; bool manual_drd_enabled; }; diff --git a/drivers/usb/mtu3/mtu3_debugfs.c b/drivers/usb/mtu3/mtu3_debugfs.c index 62c57ddc554e..c96e5dab0a48 100644 --- a/drivers/usb/mtu3/mtu3_debugfs.c +++ b/drivers/usb/mtu3/mtu3_debugfs.c @@ -453,9 +453,9 @@ static ssize_t ssusb_mode_write(struct file *file, const char __user *ubuf, return -EFAULT; if (!strncmp(buf, "host", 4) && !ssusb->is_host) { - ssusb_mode_manual_switch(ssusb, 1); + ssusb_mode_switch(ssusb, 1); } else if (!strncmp(buf, "device", 6) && ssusb->is_host) { - ssusb_mode_manual_switch(ssusb, 0); + ssusb_mode_switch(ssusb, 0); } else { dev_err(ssusb->dev, "wrong or duplicated setting\n"); return -EINVAL; diff --git a/drivers/usb/mtu3/mtu3_dr.c b/drivers/usb/mtu3/mtu3_dr.c index 5fcb71af875a..08e18448e8b8 100644 --- a/drivers/usb/mtu3/mtu3_dr.c +++ b/drivers/usb/mtu3/mtu3_dr.c @@ -7,6 +7,8 @@ * Author: Chunfeng Yun */ +#include + #include "mtu3.h" #include "mtu3_dr.h" #include "mtu3_debug.h" @@ -280,7 +282,7 @@ static int ssusb_extcon_register(struct otg_switch_mtk *otg_sx) * This is useful in special cases, such as uses TYPE-A receptacle but also * wants to support dual-role mode. */ -void ssusb_mode_manual_switch(struct ssusb_mtk *ssusb, int to_host) +void ssusb_mode_switch(struct ssusb_mtk *ssusb, int to_host) { struct otg_switch_mtk *otg_sx = &ssusb->otg_switch; @@ -318,6 +320,47 @@ void ssusb_set_force_mode(struct ssusb_mtk *ssusb, mtu3_writel(ssusb->ippc_base, SSUSB_U2_CTRL(0), value); } +static int ssusb_role_sw_set(struct device *dev, enum usb_role role) +{ + struct ssusb_mtk *ssusb = dev_get_drvdata(dev); + bool to_host = false; + + if (role == USB_ROLE_HOST) + to_host = true; + + if (to_host ^ ssusb->is_host) + ssusb_mode_switch(ssusb, to_host); + + return 0; +} + +static enum usb_role ssusb_role_sw_get(struct device *dev) +{ + struct ssusb_mtk *ssusb = dev_get_drvdata(dev); + enum usb_role role; + + role = ssusb->is_host ? USB_ROLE_HOST : USB_ROLE_DEVICE; + + return role; +} + +static int ssusb_role_sw_register(struct otg_switch_mtk *otg_sx) +{ + struct usb_role_switch_desc role_sx_desc = { 0 }; + struct ssusb_mtk *ssusb = + container_of(otg_sx, struct ssusb_mtk, otg_switch); + + if (!otg_sx->role_sw_used) + return 0; + + role_sx_desc.set = ssusb_role_sw_set; + role_sx_desc.get = ssusb_role_sw_get; + role_sx_desc.fwnode = dev_fwnode(ssusb->dev); + otg_sx->role_sw = usb_role_switch_register(ssusb->dev, &role_sx_desc); + + return PTR_ERR_OR_ZERO(otg_sx->role_sw); +} + int ssusb_otg_switch_init(struct ssusb_mtk *ssusb) { struct otg_switch_mtk *otg_sx = &ssusb->otg_switch; @@ -328,6 +371,8 @@ int ssusb_otg_switch_init(struct ssusb_mtk *ssusb) if (otg_sx->manual_drd_enabled) ssusb_dr_debugfs_init(ssusb); + else if (otg_sx->role_sw_used) + ret = ssusb_role_sw_register(otg_sx); else ret = ssusb_extcon_register(otg_sx); @@ -340,4 +385,5 @@ void ssusb_otg_switch_exit(struct ssusb_mtk *ssusb) cancel_work_sync(&otg_sx->id_work); cancel_work_sync(&otg_sx->vbus_work); + usb_role_switch_unregister(otg_sx->role_sw); } diff --git a/drivers/usb/mtu3/mtu3_dr.h b/drivers/usb/mtu3/mtu3_dr.h index ba6fe357ce29..5e58c4dbd54a 100644 --- a/drivers/usb/mtu3/mtu3_dr.h +++ b/drivers/usb/mtu3/mtu3_dr.h @@ -71,7 +71,7 @@ static inline void ssusb_gadget_exit(struct ssusb_mtk *ssusb) #if IS_ENABLED(CONFIG_USB_MTU3_DUAL_ROLE) int ssusb_otg_switch_init(struct ssusb_mtk *ssusb); void ssusb_otg_switch_exit(struct ssusb_mtk *ssusb); -void ssusb_mode_manual_switch(struct ssusb_mtk *ssusb, int to_host); +void ssusb_mode_switch(struct ssusb_mtk *ssusb, int to_host); int ssusb_set_vbus(struct otg_switch_mtk *otg_sx, int is_on); void ssusb_set_force_mode(struct ssusb_mtk *ssusb, enum mtu3_dr_force_mode mode); @@ -86,8 +86,8 @@ static inline int ssusb_otg_switch_init(struct ssusb_mtk *ssusb) static inline void ssusb_otg_switch_exit(struct ssusb_mtk *ssusb) {} -static inline void -ssusb_mode_manual_switch(struct ssusb_mtk *ssusb, int to_host) {} +static inline void ssusb_mode_switch(struct ssusb_mtk *ssusb, int to_host) +{} static inline int ssusb_set_vbus(struct otg_switch_mtk *otg_sx, int is_on) { diff --git a/drivers/usb/mtu3/mtu3_plat.c b/drivers/usb/mtu3/mtu3_plat.c index fd0f6c5dfbc1..9c256ea3cdf5 100644 --- a/drivers/usb/mtu3/mtu3_plat.c +++ b/drivers/usb/mtu3/mtu3_plat.c @@ -299,8 +299,9 @@ static int get_ssusb_rscs(struct platform_device *pdev, struct ssusb_mtk *ssusb) otg_sx->is_u3_drd = of_property_read_bool(node, "mediatek,usb3-drd"); otg_sx->manual_drd_enabled = of_property_read_bool(node, "enable-manual-drd"); + otg_sx->role_sw_used = of_property_read_bool(node, "usb-role-switch"); - if (of_property_read_bool(node, "extcon")) { + if (!otg_sx->role_sw_used && of_property_read_bool(node, "extcon")) { otg_sx->edev = extcon_get_edev_by_phandle(ssusb->dev, 0); if (IS_ERR(otg_sx->edev)) { dev_err(ssusb->dev, "couldn't get extcon device\n"); -- 2.21.0