From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heiko =?ISO-8859-1?Q?St=FCbner?= Subject: [PATCH] soc/rockchip: add handler for usb-uart functionality Date: Wed, 08 Jul 2015 21:00:06 +0200 Message-ID: <1574322.mYky5df1dK@diego> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+glpar-linux-rockchip=m.gmane.org-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org To: linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, Kevin Hilman Cc: Olof Johansson , linux-rockchip-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, Yunzhi Li , dianders-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, amstan-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org List-Id: linux-rockchip.vger.kernel.org TW9zdCBuZXdlciBSb2NrY2hpcCBTb0NzIHByb3ZpZGUgdGhlIHBvc3NpYmlsaXR5IHRvIHVzZSBh IHVzYi1waHkKYXMgcGFzc3Rocm91Z2ggZm9yIHRoZSBkZWJ1ZyB1YXJ0ICh1YXJ0MiksIG1ha2lu ZyBpdCBwb3NzaWJsZSB0bwpnZXQgY29uc29sZSBvdXRwdXQgd2l0aG91dCBuZWVkaW5nIHRvIG9w ZW4gdGhlIGRldmljZS4KClRoaXMgcGF0Y2ggYWRkcyBhbiBlYXJseV9pbml0Y2FsbCB0byBlbmFi bGUgdGhpcyBmdW5jdGlvbmFsaXR5CmNvbmRpdGlvbmFsbHkgdmlhIHRoZSBjb21tYW5kbGluZSBh bmQgYWxzbyBkaXNhYmxlcyB0aGUgY29ycmVzcG9uZGluZwp1c2IgY29udHJvbGxlciBpbiB0aGUg ZGV2aWNldHJlZS4KCkN1cnJlbnRseSBvbmx5IGRhdGEgZm9yIHRoZSByazMyODggaXMgcHJvdmlk ZWQsIGJ1dCBhdCBsZWFzdCB0aGUKcmszMTg4IGFuZCBhcm02NCByazMzNjggYWxzbyBwcm92aWRl IHRoaXMgZnVuY3Rpb25hbGl0eSBhbmQgd2lsbCBiZQplbmFibGVkIGxhdGVyLgoKT24gYSBzcGxp Y2VkIHVzYiBjYWJsZSB0aGUgc2lnbmFscyBhcmUgdHggb24gd2hpdGUgd2lyZShEKykgYW5kCnJ4 IG9uIGdyZWVuIHdpcmUoRC0pLgoKU2lnbmVkLW9mZi1ieTogSGVpa28gU3R1ZWJuZXIgPGhlaWtv QHNudGVjaC5kZT4KLS0tCmNoYW5nZXMgZnJvbSB0aGUgdmVyc2lvbiBpbiBjaHJvbWl1bS1yZXZp ZXc6Ci0gZW5hYmxlIHNpZGRxIChwcm9iYWJseSBzYXZlcyBhIGxpdHRsZSBwb3dlciB0byBwb3dl ciBkb3duIHBsbHMpCi0gY29zbWV0aWNzIHRvIG1ha2UgY2hlY2twYXRjaCBoYXBweQoKWXVuemhp IExpIGFscmVhZHkgZ2F2ZSBhIENvZGUtUmV2aWV3KzEgaW4gdGhlIGNocm9taXVtIGdlcnJpdApi dXQgSSdkIGd1ZXNzIGEgcHVibGljIFJldmlld2VkLWJ5IHdvdWxkIGJlIGJldHRlciA7LSkKCgog RG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVycy50eHQgICAgICB8ICAgNiArCiBkcml2ZXJz L3NvYy9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvc29jL01h a2VmaWxlICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9zb2Mvcm9ja2NoaXAv S2NvbmZpZyAgICAgICAgICAgICB8ICAxMyArKwogZHJpdmVycy9zb2Mvcm9ja2NoaXAvTWFrZWZp bGUgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3NvYy9yb2NrY2hpcC9yb2NrY2hpcF91c2Jf dWFydC5jIHwgMjI2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDYgZmlsZXMgY2hh bmdlZCwgMjQ4IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3NvYy9y b2NrY2hpcC9LY29uZmlnCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9zb2Mvcm9ja2NoaXAv TWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3NvYy9yb2NrY2hpcC9yb2NrY2hp cF91c2JfdWFydC5jCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9rZXJuZWwtcGFyYW1ldGVy cy50eHQgYi9Eb2N1bWVudGF0aW9uL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dAppbmRleCAxZDZmMDQ1 Li4xNTY5MTFiIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2tlcm5lbC1wYXJhbWV0ZXJzLnR4 dAorKysgYi9Eb2N1bWVudGF0aW9uL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dApAQCAtMzMzOSw2ICsz MzM5LDEyIEBAIGJ5dGVzIHJlc3BlY3RpdmVseS4gU3VjaCBsZXR0ZXIgc3VmZml4ZXMgY2FuIGFs c28gYmUgZW50aXJlbHkgb21pdHRlZC4KIAogCXJvCQlbS05MXSBNb3VudCByb290IGRldmljZSBy ZWFkLW9ubHkgb24gYm9vdAogCisJcm9ja2NoaXAudXNiX3VhcnQKKwkJCUVuYWJsZSB0aGUgdWFy dCBwYXNzdGhyb3VnaCBvbiB0aGUgZGVzaWduYXRlZCB1c2IgcG9ydAorCQkJb24gUm9ja2NoaXAg U29Dcy4gV2hlbiBhY3RpdmUsIHRoZSBzaWduYWxzIG9mIHRoZQorCQkJZGVidWctdWFydCBnZXQg cm91dGVkIHRvIHRoZSBEKyBhbmQgRC0gcGlucyBvZiB0aGUgdXNiCisJCQlwb3J0IGFuZCB0aGUg cmVndWxhciB1c2IgY29udHJvbGxlciBnZXRzIGRpc2FibGVkLgorCiAJcm9vdD0JCVtLTkxdIFJv b3QgZmlsZXN5c3RlbQogCQkJU2VlIG5hbWVfdG9fZGV2X3QgY29tbWVudCBpbiBpbml0L2RvX21v dW50cy5jLgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NvYy9LY29uZmlnIGIvZHJpdmVycy9zb2Mv S2NvbmZpZwppbmRleCA5NmRkZWNiLi5lY2IxYTZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3NvYy9L Y29uZmlnCisrKyBiL2RyaXZlcnMvc29jL0tjb25maWcKQEAgLTIsNiArMiw3IEBAIG1lbnUgIlNP QyAoU3lzdGVtIE9uIENoaXApIHNwZWNpZmljIERyaXZlcnMiCiAKIHNvdXJjZSAiZHJpdmVycy9z b2MvbWVkaWF0ZWsvS2NvbmZpZyIKIHNvdXJjZSAiZHJpdmVycy9zb2MvcWNvbS9LY29uZmlnIgor c291cmNlICJkcml2ZXJzL3NvYy9yb2NrY2hpcC9LY29uZmlnIgogc291cmNlICJkcml2ZXJzL3Nv Yy9zdW54aS9LY29uZmlnIgogc291cmNlICJkcml2ZXJzL3NvYy90aS9LY29uZmlnIgogc291cmNl ICJkcml2ZXJzL3NvYy92ZXJzYXRpbGUvS2NvbmZpZyIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29j L01ha2VmaWxlIGIvZHJpdmVycy9zb2MvTWFrZWZpbGUKaW5kZXggN2RjN2MwZC4uNmMwYjY3NyAx MDA2NDQKLS0tIGEvZHJpdmVycy9zb2MvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9zb2MvTWFrZWZp bGUKQEAgLTQsNiArNCw3IEBACiAKIG9iai0kKENPTkZJR19BUkNIX01FRElBVEVLKQkrPSBtZWRp YXRlay8KIG9iai0kKENPTkZJR19BUkNIX1FDT00pCQkrPSBxY29tLworb2JqLSQoQ09ORklHX0FS Q0hfUk9DS0NISVApCSs9IHJvY2tjaGlwLwogb2JqLSQoQ09ORklHX0FSQ0hfU1VOWEkpCSs9IHN1 bnhpLwogb2JqLSQoQ09ORklHX0FSQ0hfVEVHUkEpCSs9IHRlZ3JhLwogb2JqLSQoQ09ORklHX1NP Q19USSkJCSs9IHRpLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zb2Mvcm9ja2NoaXAvS2NvbmZpZyBi L2RyaXZlcnMvc29jL3JvY2tjaGlwL0tjb25maWcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uMjRkNGUwNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc29jL3JvY2tjaGlw L0tjb25maWcKQEAgLTAsMCArMSwxMyBAQAorIworIyBSb2NrY2hpcCBTb2MgZHJpdmVycworIwor Y29uZmlnIFJPQ0tDSElQX1VTQl9VQVJUCisJYm9vbCAiUm9ja2NoaXAgdXNiLXVhcnQgb3ZlcnJp ZGUiCisJZGVwZW5kcyBvbiBBUkNIX1JPQ0tDSElQCisJc2VsZWN0IE1GRF9TWVNDT04KKwloZWxw CisJICBTYXkgeSBoZXJlIHRvIGVuYWJsZSB1c2ItdWFydCBmdW5jdGlvbmFsaXR5LiBOZXdlciBS b2NrY2hpcCBTb0NzCisJICBwcm92aWRlIG1lYW5zIHRvIHJlcHVycG9zZSBvbmUgdXNiIHBoeSBh cyB1YXJ0MiBvdXRwdXQsIG1ha2luZyBpdAorCSAgcG9zc2libGUgdG8gZ2V0IGRlYnVnIG91dHB1 dCB3aXRob3V0IG5lZWRpbmcgdG8gb3BlbiBhIGRldmljZS4KKwkgIFRvIGVuYWJsZSB0aGlzIGZ1 bmN0aW9uIG9uIGJvb3QsIGFkZCBhIHJvY2tjaGlwLnVzYl91YXJ0IG9wdGlvbgorCSAgdG8gdGhl IGtlcm5lbCBjb21tYW5kbGluZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29jL3JvY2tjaGlwL01h a2VmaWxlIGIvZHJpdmVycy9zb2Mvcm9ja2NoaXAvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uYjVkZDZmOAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc29j L3JvY2tjaGlwL01ha2VmaWxlCkBAIC0wLDAgKzEgQEAKK29iai0kKENPTkZJR19ST0NLQ0hJUF9V U0JfVUFSVCkJCSs9CXJvY2tjaGlwX3VzYl91YXJ0Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29j L3JvY2tjaGlwL3JvY2tjaGlwX3VzYl91YXJ0LmMgYi9kcml2ZXJzL3NvYy9yb2NrY2hpcC9yb2Nr Y2hpcF91c2JfdWFydC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhlOTZk NDYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3NvYy9yb2NrY2hpcC9yb2NrY2hpcF91c2Jf dWFydC5jCkBAIC0wLDAgKzEsMjI2IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDE1IEhlaWtv IFN0dWVibmVyIDxoZWlrb0BzbnRlY2guZGU+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJu ZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvZXJybm8uaD4K KyNpbmNsdWRlIDxsaW51eC9tZmQvc3lzY29uLmg+CisjaW5jbHVkZSA8bGludXgvb2ZfYWRkcmVz cy5oPgorI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3JtLmg+CisjaW5jbHVkZSA8bGludXgvcmVn bWFwLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorCisjZGVmaW5lIEhJV09SRF9VUERBVEUo dmFsLCBtYXNrKSBcCisJCSgodmFsKSB8IChtYXNrKSA8PCAxNikKKworc3RydWN0IHJvY2tjaGlw X3VhcnRfZGF0YSB7CisJY29uc3QgY2hhciAqZ3JmX2NvbXBhdGlibGU7CisJY29uc3QgY2hhciAq dXNiX2NvbXBhdGlibGU7CisJcGh5c19hZGRyX3QgdXNiX3BoeXNfYWRkcjsKKwlpbnQgKCppbml0 X3VhcnQpKGNvbnN0IHN0cnVjdCByb2NrY2hpcF91YXJ0X2RhdGEgKmRhdGEsCisJCQkgc3RydWN0 IHJlZ21hcCAqZ3JmKTsKK307CisKK3N0YXRpYyBpbnQgZW5hYmxlX3VzYl91YXJ0OworCisjZGVm aW5lIFJLMzI4OF9VT0MwX0NPTjAJCQkJMHgzMjAKKyNkZWZpbmUgUkszMjg4X1VPQzBfQ09OMF9D T01NT05fT05fTgkJCUJJVCgwKQorI2RlZmluZSBSSzMyODhfVU9DMF9DT04wX0RJU0FCTEUJCQlC SVQoNCkKKyNkZWZpbmUgUkszMjg4X1VPQzBfQ09OMF9TSUREUQkJCQlCSVQoMTMpCisKKyNkZWZp bmUgUkszMjg4X1VPQzBfQ09OMgkJCQkweDMyOAorI2RlZmluZSBSSzMyODhfVU9DMF9DT04yX1NP RlRfQ09OX1NFTAkJCUJJVCgyKQorCisjZGVmaW5lIFJLMzI4OF9VT0MwX0NPTjMJCQkJMHgzMmMK KyNkZWZpbmUgUkszMjg4X1VPQzBfQ09OM19VVE1JX1NVU1BFTkROCQkJQklUKDApCisjZGVmaW5l IFJLMzI4OF9VT0MwX0NPTjNfVVRNSV9PUE1PREVfTk9EUklWSU5HCQkoMSA8PCAxKQorI2RlZmlu ZSBSSzMyODhfVU9DMF9DT04zX1VUTUlfT1BNT0RFX01BU0sJCSgzIDw8IDEpCisjZGVmaW5lIFJL MzI4OF9VT0MwX0NPTjNfVVRNSV9YQ1ZSU0VFTENUX0ZTVFJBTlNDCSgxIDw8IDMpCisjZGVmaW5l IFJLMzI4OF9VT0MwX0NPTjNfVVRNSV9YQ1ZSU0VFTENUX01BU0sJCSgzIDw8IDMpCisjZGVmaW5l IFJLMzI4OF9VT0MwX0NPTjNfVVRNSV9URVJNU0VMX0ZVTExTUEVFRAkJQklUKDUpCisjZGVmaW5l IFJLMzI4OF9VT0MwX0NPTjNfQllQQVNTRE1FTgkJCUJJVCg2KQorI2RlZmluZSBSSzMyODhfVU9D MF9DT04zX0JZUEFTU1NFTAkJCUJJVCg3KQorCisvKgorICogRW5hYmxlIHRoZSBieXBhc3Mgb2Yg dWFydDIgZGF0YSB0aHJvdWdoIHRoZSBvdGcgdXNiIHBoeS4KKyAqIE9yaWdpbmFsIGRlc2NyaXB0 aW9uIGluIHRoZSBUUk0uCisgKiAxLiBEaXNhYmxlIHRoZSBPVEcgYmxvY2sgYnkgc2V0dGluZyBP VEdESVNBQkxFMCB0byAx4oCZYjEuCisgKiAyLiBEaXNhYmxlIHRoZSBwdWxsLXVwIHJlc2lzdGFu Y2Ugb24gdGhlIEQrIGxpbmUgYnkgc2V0dGluZworICogICAgT1BNT0RFMFsxOjBdIHRvIDLigJli MDEuCisgKiAzLiBUbyBlbnN1cmUgdGhhdCB0aGUgWE8sIEJpYXMsIGFuZCBQTEwgYmxvY2tzIGFy ZSBwb3dlcmVkIGRvd24gaW4gU3VzcGVuZAorICogICAgbW9kZSwgc2V0IENPTU1PTk9OTiB0byAx 4oCZYjEuCisgKiA0LiBQbGFjZSB0aGUgVVNCIFBIWSBpbiBTdXNwZW5kIG1vZGUgYnkgc2V0dGlu ZyBTVVNQRU5ETTAgdG8gMeKAmWIwLgorICogNS4gU2V0IEJZUEFTU1NFTDAgdG8gMeKAmWIxLgor ICogNi4gVG8gdHJhbnNtaXQgZGF0YSwgY29udHJvbHMgQllQQVNTRE1FTjAsIGFuZCBCWVBBU1NE TURBVEEwLgorICogVG8gcmVjZWl2ZSBkYXRhLCBtb25pdG9yIEZTVlBMVVMwLgorICoKKyAqIFRo ZSBhY3R1YWwgY29kZSBpbiB0aGUgdmVuZG9yIGtlcm5lbCBkb2VzIHNvbWUgdGhpbmdzIGRpZmZl cmVudGx5LgorICovCitzdGF0aWMgaW50IF9faW5pdCByazMyODhfaW5pdF91c2JfdWFydChjb25z dCBzdHJ1Y3Qgcm9ja2NoaXBfdWFydF9kYXRhICpkYXRhLAorCQkJCSAgICAgICBzdHJ1Y3QgcmVn bWFwICpncmYpCit7CisJdTMyIHZhbDsKKwlpbnQgcmV0OworCisJLyoKKwkgKiBDT01NT05fT04g YW5kIERJU0FCTEUgc2V0dGluZ3MgYXJlIGRlc2NyaWJlZCBpbiB0aGUgVFJNLAorCSAqIGJ1dCB3 ZXJlIG5vdCBwcmVzZW50IGluIHRoZSBvcmlnaW5hbCBjb2RlLgorCSAqIEFsc28gZGlzYWJsZSB0 aGUgYW5hbG9nIHBoeSBjb21wb25lbnRzIHRvIHNhdmUgcG93ZXIuCisJICovCisJdmFsID0gSElX T1JEX1VQREFURShSSzMyODhfVU9DMF9DT04wX0NPTU1PTl9PTl9OCisJCQkJfCBSSzMyODhfVU9D MF9DT04wX0RJU0FCTEUKKwkJCQl8IFJLMzI4OF9VT0MwX0NPTjBfU0lERFEsCisJCQkgICAgUksz Mjg4X1VPQzBfQ09OMF9DT01NT05fT05fTgorCQkJCXwgUkszMjg4X1VPQzBfQ09OMF9ESVNBQkxF CisJCQkJfCBSSzMyODhfVU9DMF9DT04wX1NJRERRKTsKKwlyZXQgPSByZWdtYXBfd3JpdGUoZ3Jm LCBSSzMyODhfVU9DMF9DT04wLCB2YWwpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwl2 YWwgPSBISVdPUkRfVVBEQVRFKFJLMzI4OF9VT0MwX0NPTjJfU09GVF9DT05fU0VMLAorCQkJICAg IFJLMzI4OF9VT0MwX0NPTjJfU09GVF9DT05fU0VMKTsKKwlyZXQgPSByZWdtYXBfd3JpdGUoZ3Jm LCBSSzMyODhfVU9DMF9DT04yLCB2YWwpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwl2 YWwgPSBISVdPUkRfVVBEQVRFKFJLMzI4OF9VT0MwX0NPTjNfVVRNSV9PUE1PREVfTk9EUklWSU5H CisJCQkJfCBSSzMyODhfVU9DMF9DT04zX1VUTUlfWENWUlNFRUxDVF9GU1RSQU5TQworCQkJCXwg UkszMjg4X1VPQzBfQ09OM19VVE1JX1RFUk1TRUxfRlVMTFNQRUVELAorCQkJICAgIFJLMzI4OF9V T0MwX0NPTjNfVVRNSV9TVVNQRU5ETgorCQkJCXwgUkszMjg4X1VPQzBfQ09OM19VVE1JX09QTU9E RV9NQVNLCisJCQkJfCBSSzMyODhfVU9DMF9DT04zX1VUTUlfWENWUlNFRUxDVF9NQVNLCisJCQkJ fCBSSzMyODhfVU9DMF9DT04zX1VUTUlfVEVSTVNFTF9GVUxMU1BFRUQpOworCXJldCA9IHJlZ21h cF93cml0ZShncmYsIFJLMzI4OF9VT0MwX0NPTjMsIHZhbCk7CisJaWYgKHJldCkKKwkJcmV0dXJu IHJldDsKKworCXZhbCA9IEhJV09SRF9VUERBVEUoUkszMjg4X1VPQzBfQ09OM19CWVBBU1NTRUwK KwkJCQl8IFJLMzI4OF9VT0MwX0NPTjNfQllQQVNTRE1FTiwKKwkJCSAgICBSSzMyODhfVU9DMF9D T04zX0JZUEFTU1NFTAorCQkJCXwgUkszMjg4X1VPQzBfQ09OM19CWVBBU1NETUVOKTsKKwlyZXQg PSByZWdtYXBfd3JpdGUoZ3JmLCBSSzMyODhfVU9DMF9DT04zLCB2YWwpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCByb2Nr Y2hpcF91YXJ0X2RhdGEgcmszMjg4X3VhcnRfZGF0YSBfX2luaXRjb25zdCA9IHsKKwkuZ3JmX2Nv bXBhdGlibGUgPSAicm9ja2NoaXAscmszMjg4LWdyZiIsCisJLnVzYl9jb21wYXRpYmxlID0gInJv Y2tjaGlwLHJrMzI4OC11c2IiLAorCS51c2JfcGh5c19hZGRyID0gMHhmZjU4MDAwMCwKKwkuaW5p dF91YXJ0ID0gcmszMjg4X2luaXRfdXNiX3VhcnQsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0 IG9mX2RldmljZV9pZCByb2NrY2hpcF91c2JfdWFydF9pZHNbXSBfX2luaXRjb25zdCA9IHsKKwl7 IC5jb21wYXRpYmxlID0gInJvY2tjaGlwLHJrMzI4OCIsIC5kYXRhID0gJnJrMzI4OF91YXJ0X2Rh dGEgfSwKKwl7IH0KK307CisKKy8qCisgKiBGaW5kIHRoZSB1c2IgY29udHJvbGxlciB1c2luZyB0 aGUgc2hhcmVkIHVzYi11YXJ0LXBoeSBpbiB0aGUgZHRzIGFuZAorICogZGlzYWJsZSBpdC4KKyAq Lworc3RhdGljIGludCBfX2luaXQKK3JvY2tjaGlwX2Rpc2FibGVfdXNiX2NvbnRyb2xsZXIoY29u c3Qgc3RydWN0IHJvY2tjaGlwX3VhcnRfZGF0YSAqZGF0YSkKK3sKKwlzdHJ1Y3QgZGV2aWNlX25v ZGUgKm5wOworCisJZm9yX2VhY2hfY29tcGF0aWJsZV9ub2RlKG5wLCBOVUxMLCBkYXRhLT51c2Jf Y29tcGF0aWJsZSkgeworCQlzdHJ1Y3QgcHJvcGVydHkgKm5ld19zdGF0dXM7CisJCXN0cnVjdCBy ZXNvdXJjZSByZXM7CisJCWludCByZXQ7CisKKwkJcmV0ID0gb2ZfYWRkcmVzc190b19yZXNvdXJj ZShucCwgMCwgJnJlcyk7CisJCWlmIChyZXQpIHsKKwkJCXByX2VycigiJXM6IGNvdWxkIG5vdCBn ZXQgYWRkcmVzcyBvZiB1c2IgY29udHJvbGxlciAlc1xuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywg bnAtPmZ1bGxfbmFtZSk7CisJCQljb250aW51ZTsKKwkJfQorCisJCS8qIG5vdCB0aGUgY29udHJv bGxlciB3ZSdyZSBsb29raW5nIGZvciAqLworCQlpZiAocmVzLnN0YXJ0ICE9IGRhdGEtPnVzYl9w aHlzX2FkZHIpCisJCQljb250aW51ZTsKKworCQlwcl9kZWJ1ZygiJXM6IGRpc2FibGluZyB1c2Ig Y29udHJvbGxlciAlc1xuIiwKKwkJCSBfX2Z1bmNfXywgbnAtPmZ1bGxfbmFtZSk7CisKKwkJbmV3 X3N0YXR1cyA9IGt6YWxsb2Moc2l6ZW9mKCpuZXdfc3RhdHVzKSwgR0ZQX0tFUk5FTCk7CisJCWlm ICghbmV3X3N0YXR1cykKKwkJCXJldHVybiAtRU5PTUVNOworCisJCW5ld19zdGF0dXMtPm5hbWUg PSBrc3RyZHVwKCJzdGF0dXMiLCBHRlBfS0VSTkVMKTsKKwkJbmV3X3N0YXR1cy0+bGVuZ3RoID0g c2l6ZW9mKCJkaXNhYmxlZCIpOworCQluZXdfc3RhdHVzLT52YWx1ZSA9IGtzdHJkdXAoImRpc2Fi bGVkIiwgR0ZQX0tFUk5FTCk7CisKKwkJcmV0dXJuIG9mX3VwZGF0ZV9wcm9wZXJ0eShucCwgbmV3 X3N0YXR1cyk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2Zf ZGV2aWNlX2lkIF9faW5pdCAqcm9ja2NoaXBfdXNiX3VhcnRfZGF0YV9sb29rdXAodm9pZCkKK3sK KwlzdHJ1Y3QgZGV2aWNlX25vZGUgKnJvb3Q7CisJY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCAq aWQ7CisKKwlyb290ID0gb2ZfZmluZF9ub2RlX2J5X3BhdGgoIi8iKTsKKwlpZiAoIXJvb3QpCisJ CXJldHVybiBOVUxMOworCisJaWQgPSBvZl9tYXRjaF9ub2RlKHJvY2tjaGlwX3VzYl91YXJ0X2lk cywgcm9vdCk7CisJb2Zfbm9kZV9wdXQocm9vdCk7CisKKwlyZXR1cm4gaWQ7Cit9CisKK3N0YXRp YyBpbnQgX19pbml0IHJvY2tjaGlwX2luaXRfdXNiX3VhcnQodm9pZCkKK3sKKwljb25zdCBzdHJ1 Y3Qgb2ZfZGV2aWNlX2lkICptYXRjaDsKKwljb25zdCBzdHJ1Y3Qgcm9ja2NoaXBfdWFydF9kYXRh ICpkYXRhOworCXN0cnVjdCByZWdtYXAgKmdyZjsKKwlpbnQgcmV0OworCisJaWYgKCFlbmFibGVf dXNiX3VhcnQpCisJCXJldHVybiAwOworCisJbWF0Y2ggPSByb2NrY2hpcF91c2JfdWFydF9kYXRh X2xvb2t1cCgpOworCWlmICghbWF0Y2gpCisJCXJldHVybiAtRU5PVFNVUFA7CisKKwlwcl9kZWJ1 ZygiJXM6IHVzaW5nIHNldHRpbmdzIGZvciAlc1xuIiwgX19mdW5jX18sIG1hdGNoLT5jb21wYXRp YmxlKTsKKwlkYXRhID0gbWF0Y2gtPmRhdGE7CisKKwlncmYgPSBzeXNjb25fcmVnbWFwX2xvb2t1 cF9ieV9jb21wYXRpYmxlKGRhdGEtPmdyZl9jb21wYXRpYmxlKTsKKwlpZiAoSVNfRVJSKGdyZikp IHsKKwkJcHJfZXJyKCIlczogY291bGQgbm90IGZpbmQgR1JGIHN5c2NvblxuIiwgX19mdW5jX18p OworCQlyZXR1cm4gUFRSX0VSUihncmYpOworCX0KKworCXJldCA9IGRhdGEtPmluaXRfdWFydChk YXRhLCBncmYpOworCWlmIChyZXQpIHsKKwkJcHJfZXJyKCIlczogY291bGQgbm90IGluaXQgdXNi X3VhcnRcbiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gcm9ja2No aXBfZGlzYWJsZV91c2JfY29udHJvbGxlcihkYXRhKTsKK30KK2Vhcmx5X2luaXRjYWxsKHJvY2tj aGlwX2luaXRfdXNiX3VhcnQpOworCitzdGF0aWMgaW50IF9faW5pdCByb2NrY2hpcF91c2JfdWFy dChjaGFyICpidWYpCit7CisJZW5hYmxlX3VzYl91YXJ0ID0gdHJ1ZTsKKwlyZXR1cm4gMDsKK30K K2Vhcmx5X3BhcmFtKCJyb2NrY2hpcC51c2JfdWFydCIsIHJvY2tjaGlwX3VzYl91YXJ0KTsKLS0g CjIuMS40CgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkxpbnV4LXJvY2tjaGlwIG1haWxpbmcgbGlzdApMaW51eC1yb2NrY2hpcEBsaXN0cy5pbmZyYWRl YWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgt cm9ja2NoaXAK From mboxrd@z Thu Jan 1 00:00:00 1970 From: heiko@sntech.de (Heiko =?ISO-8859-1?Q?St=FCbner?=) Date: Wed, 08 Jul 2015 21:00:06 +0200 Subject: [PATCH] soc/rockchip: add handler for usb-uart functionality Message-ID: <1574322.mYky5df1dK@diego> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Most newer Rockchip SoCs provide the possibility to use a usb-phy as passthrough for the debug uart (uart2), making it possible to get console output without needing to open the device. This patch adds an early_initcall to enable this functionality conditionally via the commandline and also disables the corresponding usb controller in the devicetree. Currently only data for the rk3288 is provided, but at least the rk3188 and arm64 rk3368 also provide this functionality and will be enabled later. On a spliced usb cable the signals are tx on white wire(D+) and rx on green wire(D-). Signed-off-by: Heiko Stuebner --- changes from the version in chromium-review: - enable siddq (probably saves a little power to power down plls) - cosmetics to make checkpatch happy Yunzhi Li already gave a Code-Review+1 in the chromium gerrit but I'd guess a public Reviewed-by would be better ;-) Documentation/kernel-parameters.txt | 6 + drivers/soc/Kconfig | 1 + drivers/soc/Makefile | 1 + drivers/soc/rockchip/Kconfig | 13 ++ drivers/soc/rockchip/Makefile | 1 + drivers/soc/rockchip/rockchip_usb_uart.c | 226 +++++++++++++++++++++++++++++++ 6 files changed, 248 insertions(+) create mode 100644 drivers/soc/rockchip/Kconfig create mode 100644 drivers/soc/rockchip/Makefile create mode 100644 drivers/soc/rockchip/rockchip_usb_uart.c diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt index 1d6f045..156911b 100644 --- a/Documentation/kernel-parameters.txt +++ b/Documentation/kernel-parameters.txt @@ -3339,6 +3339,12 @@ bytes respectively. Such letter suffixes can also be entirely omitted. ro [KNL] Mount root device read-only on boot + rockchip.usb_uart + Enable the uart passthrough on the designated usb port + on Rockchip SoCs. When active, the signals of the + debug-uart get routed to the D+ and D- pins of the usb + port and the regular usb controller gets disabled. + root= [KNL] Root filesystem See name_to_dev_t comment in init/do_mounts.c. diff --git a/drivers/soc/Kconfig b/drivers/soc/Kconfig index 96ddecb..ecb1a6c 100644 --- a/drivers/soc/Kconfig +++ b/drivers/soc/Kconfig @@ -2,6 +2,7 @@ menu "SOC (System On Chip) specific Drivers" source "drivers/soc/mediatek/Kconfig" source "drivers/soc/qcom/Kconfig" +source "drivers/soc/rockchip/Kconfig" source "drivers/soc/sunxi/Kconfig" source "drivers/soc/ti/Kconfig" source "drivers/soc/versatile/Kconfig" diff --git a/drivers/soc/Makefile b/drivers/soc/Makefile index 7dc7c0d..6c0b677 100644 --- a/drivers/soc/Makefile +++ b/drivers/soc/Makefile @@ -4,6 +4,7 @@ obj-$(CONFIG_ARCH_MEDIATEK) += mediatek/ obj-$(CONFIG_ARCH_QCOM) += qcom/ +obj-$(CONFIG_ARCH_ROCKCHIP) += rockchip/ obj-$(CONFIG_ARCH_SUNXI) += sunxi/ obj-$(CONFIG_ARCH_TEGRA) += tegra/ obj-$(CONFIG_SOC_TI) += ti/ diff --git a/drivers/soc/rockchip/Kconfig b/drivers/soc/rockchip/Kconfig new file mode 100644 index 0000000..24d4e05 --- /dev/null +++ b/drivers/soc/rockchip/Kconfig @@ -0,0 +1,13 @@ +# +# Rockchip Soc drivers +# +config ROCKCHIP_USB_UART + bool "Rockchip usb-uart override" + depends on ARCH_ROCKCHIP + select MFD_SYSCON + help + Say y here to enable usb-uart functionality. Newer Rockchip SoCs + provide means to repurpose one usb phy as uart2 output, making it + possible to get debug output without needing to open a device. + To enable this function on boot, add a rockchip.usb_uart option + to the kernel commandline. diff --git a/drivers/soc/rockchip/Makefile b/drivers/soc/rockchip/Makefile new file mode 100644 index 0000000..b5dd6f8 --- /dev/null +++ b/drivers/soc/rockchip/Makefile @@ -0,0 +1 @@ +obj-$(CONFIG_ROCKCHIP_USB_UART) += rockchip_usb_uart.o diff --git a/drivers/soc/rockchip/rockchip_usb_uart.c b/drivers/soc/rockchip/rockchip_usb_uart.c new file mode 100644 index 0000000..8e96d46 --- /dev/null +++ b/drivers/soc/rockchip/rockchip_usb_uart.c @@ -0,0 +1,226 @@ +/* + * Copyright (c) 2015 Heiko Stuebner + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define HIWORD_UPDATE(val, mask) \ + ((val) | (mask) << 16) + +struct rockchip_uart_data { + const char *grf_compatible; + const char *usb_compatible; + phys_addr_t usb_phys_addr; + int (*init_uart)(const struct rockchip_uart_data *data, + struct regmap *grf); +}; + +static int enable_usb_uart; + +#define RK3288_UOC0_CON0 0x320 +#define RK3288_UOC0_CON0_COMMON_ON_N BIT(0) +#define RK3288_UOC0_CON0_DISABLE BIT(4) +#define RK3288_UOC0_CON0_SIDDQ BIT(13) + +#define RK3288_UOC0_CON2 0x328 +#define RK3288_UOC0_CON2_SOFT_CON_SEL BIT(2) + +#define RK3288_UOC0_CON3 0x32c +#define RK3288_UOC0_CON3_UTMI_SUSPENDN BIT(0) +#define RK3288_UOC0_CON3_UTMI_OPMODE_NODRIVING (1 << 1) +#define RK3288_UOC0_CON3_UTMI_OPMODE_MASK (3 << 1) +#define RK3288_UOC0_CON3_UTMI_XCVRSEELCT_FSTRANSC (1 << 3) +#define RK3288_UOC0_CON3_UTMI_XCVRSEELCT_MASK (3 << 3) +#define RK3288_UOC0_CON3_UTMI_TERMSEL_FULLSPEED BIT(5) +#define RK3288_UOC0_CON3_BYPASSDMEN BIT(6) +#define RK3288_UOC0_CON3_BYPASSSEL BIT(7) + +/* + * Enable the bypass of uart2 data through the otg usb phy. + * Original description in the TRM. + * 1. Disable the OTG block by setting OTGDISABLE0 to 1?b1. + * 2. Disable the pull-up resistance on the D+ line by setting + * OPMODE0[1:0] to 2?b01. + * 3. To ensure that the XO, Bias, and PLL blocks are powered down in Suspend + * mode, set COMMONONN to 1?b1. + * 4. Place the USB PHY in Suspend mode by setting SUSPENDM0 to 1?b0. + * 5. Set BYPASSSEL0 to 1?b1. + * 6. To transmit data, controls BYPASSDMEN0, and BYPASSDMDATA0. + * To receive data, monitor FSVPLUS0. + * + * The actual code in the vendor kernel does some things differently. + */ +static int __init rk3288_init_usb_uart(const struct rockchip_uart_data *data, + struct regmap *grf) +{ + u32 val; + int ret; + + /* + * COMMON_ON and DISABLE settings are described in the TRM, + * but were not present in the original code. + * Also disable the analog phy components to save power. + */ + val = HIWORD_UPDATE(RK3288_UOC0_CON0_COMMON_ON_N + | RK3288_UOC0_CON0_DISABLE + | RK3288_UOC0_CON0_SIDDQ, + RK3288_UOC0_CON0_COMMON_ON_N + | RK3288_UOC0_CON0_DISABLE + | RK3288_UOC0_CON0_SIDDQ); + ret = regmap_write(grf, RK3288_UOC0_CON0, val); + if (ret) + return ret; + + val = HIWORD_UPDATE(RK3288_UOC0_CON2_SOFT_CON_SEL, + RK3288_UOC0_CON2_SOFT_CON_SEL); + ret = regmap_write(grf, RK3288_UOC0_CON2, val); + if (ret) + return ret; + + val = HIWORD_UPDATE(RK3288_UOC0_CON3_UTMI_OPMODE_NODRIVING + | RK3288_UOC0_CON3_UTMI_XCVRSEELCT_FSTRANSC + | RK3288_UOC0_CON3_UTMI_TERMSEL_FULLSPEED, + RK3288_UOC0_CON3_UTMI_SUSPENDN + | RK3288_UOC0_CON3_UTMI_OPMODE_MASK + | RK3288_UOC0_CON3_UTMI_XCVRSEELCT_MASK + | RK3288_UOC0_CON3_UTMI_TERMSEL_FULLSPEED); + ret = regmap_write(grf, RK3288_UOC0_CON3, val); + if (ret) + return ret; + + val = HIWORD_UPDATE(RK3288_UOC0_CON3_BYPASSSEL + | RK3288_UOC0_CON3_BYPASSDMEN, + RK3288_UOC0_CON3_BYPASSSEL + | RK3288_UOC0_CON3_BYPASSDMEN); + ret = regmap_write(grf, RK3288_UOC0_CON3, val); + if (ret) + return ret; + + return 0; +} + +static const struct rockchip_uart_data rk3288_uart_data __initconst = { + .grf_compatible = "rockchip,rk3288-grf", + .usb_compatible = "rockchip,rk3288-usb", + .usb_phys_addr = 0xff580000, + .init_uart = rk3288_init_usb_uart, +}; + +static const struct of_device_id rockchip_usb_uart_ids[] __initconst = { + { .compatible = "rockchip,rk3288", .data = &rk3288_uart_data }, + { } +}; + +/* + * Find the usb controller using the shared usb-uart-phy in the dts and + * disable it. + */ +static int __init +rockchip_disable_usb_controller(const struct rockchip_uart_data *data) +{ + struct device_node *np; + + for_each_compatible_node(np, NULL, data->usb_compatible) { + struct property *new_status; + struct resource res; + int ret; + + ret = of_address_to_resource(np, 0, &res); + if (ret) { + pr_err("%s: could not get address of usb controller %s\n", + __func__, np->full_name); + continue; + } + + /* not the controller we're looking for */ + if (res.start != data->usb_phys_addr) + continue; + + pr_debug("%s: disabling usb controller %s\n", + __func__, np->full_name); + + new_status = kzalloc(sizeof(*new_status), GFP_KERNEL); + if (!new_status) + return -ENOMEM; + + new_status->name = kstrdup("status", GFP_KERNEL); + new_status->length = sizeof("disabled"); + new_status->value = kstrdup("disabled", GFP_KERNEL); + + return of_update_property(np, new_status); + } + + return 0; +} + +static const struct of_device_id __init *rockchip_usb_uart_data_lookup(void) +{ + struct device_node *root; + const struct of_device_id *id; + + root = of_find_node_by_path("/"); + if (!root) + return NULL; + + id = of_match_node(rockchip_usb_uart_ids, root); + of_node_put(root); + + return id; +} + +static int __init rockchip_init_usb_uart(void) +{ + const struct of_device_id *match; + const struct rockchip_uart_data *data; + struct regmap *grf; + int ret; + + if (!enable_usb_uart) + return 0; + + match = rockchip_usb_uart_data_lookup(); + if (!match) + return -ENOTSUPP; + + pr_debug("%s: using settings for %s\n", __func__, match->compatible); + data = match->data; + + grf = syscon_regmap_lookup_by_compatible(data->grf_compatible); + if (IS_ERR(grf)) { + pr_err("%s: could not find GRF syscon\n", __func__); + return PTR_ERR(grf); + } + + ret = data->init_uart(data, grf); + if (ret) { + pr_err("%s: could not init usb_uart\n", __func__); + return ret; + } + + return rockchip_disable_usb_controller(data); +} +early_initcall(rockchip_init_usb_uart); + +static int __init rockchip_usb_uart(char *buf) +{ + enable_usb_uart = true; + return 0; +} +early_param("rockchip.usb_uart", rockchip_usb_uart); -- 2.1.4