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: [v6] USB: serial: ftdi_sio: implement GPIO support for FT-X devices From: Johan Hovold Message-Id: <20180925100635.GC3332@localhost> Date: Tue, 25 Sep 2018 12:06:35 +0200 To: Karoly Pados Cc: Johan Hovold , Greg Kroah-Hartman , linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, Loic Poulain List-ID: T24gTW9uLCBTZXAgMjQsIDIwMTggYXQgMDQ6MzE6NTFQTSArMDIwMCwgS2Fyb2x5IFBhZG9zIHdy b3RlOgo+IFRoaXMgcGF0Y2ggYWxsb3dzIHVzaW5nIHRoZSBDQlVTIHBpbnMgb2YgRlQtWCBkZXZp Y2VzIGFzIEdQSU8gaW4gQ0JVUwo+IGJpdGJhbmdpbmcgbW9kZS4gVGhlcmUgaXMgbm8gY29uZmxp Y3QgYmV0d2VlbiB0aGUgR1BJTyBhbmQgVkNQCj4gZnVuY3Rpb25hbGl0eSBpbiB0aGlzIG1vZGUu IFRlc3RlZCBvbiBGVDIzMFggYW5kIEZUMjMxWC4KPiAKPiBBcyB0aGVyZSBpcyBubyB3YXkgdG8g cmVxdWVzdCB0aGUgY3VycmVudCBDQlVTIHJlZ2lzdGVyIGNvbmZpZ3VyYXRpb24KPiBmcm9tIHRo ZSBkZXZpY2UsIGFsbCBDQlVTIHBpbnMgYXJlIHNldCB0byBhIGtub3duIHN0YXRlIHdoZW4gdGhl IGZpcnN0Cj4gR1BJTyBpcyByZXF1ZXN0ZWQuIFRoaXMgYWxsb3dzIHVzaW5nIGxpYmZ0ZGkgdG8g c2V0IHRoZSBHUElPIHBpbnMKPiBiZWZvcmUgbG9hZGluZyB0aGlzIG1vZHVsZSBmb3IgVUFSVCBm dW5jdGlvbmFsaXR5LCBhIGJlaGF2aW9yIHRoYXQKPiBleGlzdGluZyBhcHBsaWNhdGlvbnMgbWln aHQgYmUgcmVseWluZyB1cG9uICh0aG91Z2ggbm8gc3BlY2lmaWMgY2FzZQo+IGlzIGtub3duIHRv IHRoZSBhdXRob3JzIG9mIHRoaXMgcGF0Y2gpLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEthcm9seSBQ YWRvcyA8cGFkb3NAcGFkb3MuaHU+Cj4gLS0tCj4gQ2hhbmdlbG9nOgo+IC0gdjI6IEZpeCBjb21w aWxlIGVycm9yIHdoZW4gQ09ORklHX0dQSU9MSUIgaXMgbm90IGRlZmluZWQuCj4gLSB2MzogSW5j b3Jwb3JhdGUgcmV2aWV3IGZlZWRiYWNrLgo+IC0gdjQ6IEluY2x1ZGUgbGludXgvZ3Bpby9kcml2 ZXIuaCB1bmNvbmRpdGlvbmFsbHkuCj4gICAgICAgUmVwbGFjZSBhbmQgaW52ZXJ0IGdwaW9faW5w dXQgd2l0aCBncGlvX291dHB1dC4KPiAgICAgICBNYWtlIGZ0ZGlfZ3Bpb19kaXJlY3Rpb25fZ2V0 IHJldHVybiAwLzEuCj4gICAgICAgQ2hhbmdlIGRldl9lcnIgbXNnIGluIGZ0ZGlfc2V0X2JpdG1v ZGVfcmVxLgo+ICAgICAgIENoYW5nZSBmb3JtYXR0aW5nIG9mIGVycm9yIGNoZWNraW5nIGluIGZ0 ZGlfZ3Bpb19nZXQuCj4gICAgICAgRHJvcCBkZXZfZXJyIGluIGZ0ZGlfZ3Bpb19zZXQuCj4gICAg ICAgUmVtb3ZlIHNvbWUgbGluZSBicmVha3MgYW5kIGVtcHR5IGxpbmVzLgo+ICAgICAgIENoYW5n ZSBlcnJvciBoYW5kbGluZyBpbiBmdGRpX3JlYWRfZWVwcm9tIChhbmQgYWRqdXN0IGNhbGxlciku Cj4gICAgICAgUmVwbGFjZSBTSU8tPkZUWCBpbiBGVERJX1NJT19DQlVTX01VWF9HUElPIG1hY3Jv IG5hbWUuCj4gLSB2NTogUmVzZW50IHY0IHdpdGggbm8gY2hhbmdlcyBieSBtaXN0YWtlLiBQbGVh c2UgaWdub3JlLgo+IC0gdjY6IFJlYWQgb25seSA0IGJ5dGVzIGZyb20gZWVwcm9tIGluIGZ0eF9n cGlvY29uZl9pbml0Lgo+ICAgICAgIENvbXBhcmUgZnRkaV9yZWFkX2VlcHJvbSByZXN1bHQgd2l0 aCAwIGluc3RlYWQgb2YgZXEuIGNlaGNrLgo+ICAgICAgIFJlc2VydmUgNCBHUElPcyBldmVuIGZv ciBGVDIzNFguCj4gICAgICAgUmVsZWFzZSBDQlVTIGFmdGVyIGdwaW9jaGlwIGRlcmVnaXN0ZXIg dG8gYXZvaWQgcG9zc2libGUgcmFjZS4KPiAgICAgICBBZGp1c3QgY29tbWVudCBvbiBGVERJX1NJ T19TRVRfQklUTU9ERSBtYWNyby4KPiAgICAgICBQcm90ZWN0IEdQSU8gdmFsdWUvZGlyIHNldHRp bmcgd2l0aCBtdXRleC4KPiAgICAgICBBZGQgc3VwcG9ydCBmb3IgZ3Bpb2NoaXAuZ2V0X211bHRp cGxlIGFuZCBzZXRfbXVsdGlwbGUuCj4gICAgICAgQWRkIG5hbWVzIHRvIEdQSU8gbGluZXMuCj4K PiBnZXRfbXVsdGlwbGUgLyBzZXRfbXVsdGlwbGUgbWV0aG9kcyBoYXZlIGJlZW4gYWRkZWQgaW4g YWRkaXRpb24gdG8gZWFybGllcgo+IHJldmlldyBjb21tZW50cy4KCkFkZGluZyBuZXcgZmVhdHVy ZXMgbGlrZSB0aGlzIGxhdGUgaW4gYSByZXZpZXcgY3ljbGUgcmlza3MgYWRkaW5nIG5ldwpidWdz IGFuZCBjcmVhdGVzIG1vcmUgd29yayBmb3IgZXZlcnlvbmUgaW52b2x2ZWQuCgpJbiB0aGlzIGNh c2UsIHRoZXJlJ3MgYSBidWcgaW4geW91ciBzZXRfbXVsdGlwbGUoKSBpbXBsZW1lbnRhdGlvbiB0 aGF0CndpbGwgbmVlZCB0byBiZSBhZGRyZXNzZWQgaW4gYSB2Nywgc28gSSdsbCBjb21tZW50IG9u IHNvbWUgc3R5bGUgaXNzdWVzCmFzIHdlbGwgd2hpbGUgYXQgaXQuCgo+ICBkcml2ZXJzL3VzYi9z ZXJpYWwvZnRkaV9zaW8uYyB8IDM2OSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKyst Cj4gIGRyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5oIHwgIDI3ICsrLQo+ICAyIGZpbGVzIGNo YW5nZWQsIDM5NCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL3VzYi9zZXJpYWwvZnRkaV9zaW8uYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRp X3Npby5jCj4gaW5kZXggYjVjZWYzMjI4MjZmLi41NjYyODRlMmMzMTYgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy91c2Ivc2VyaWFsL2Z0ZGlfc2lvLmMKPiArKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwv ZnRkaV9zaW8uYwo+IEBAIC00MCw2ICs0MCw3IEBACj4gICNpbmNsdWRlIDxsaW51eC91c2IuaD4K PiAgI2luY2x1ZGUgPGxpbnV4L3NlcmlhbC5oPgo+ICAjaW5jbHVkZSA8bGludXgvdXNiL3Nlcmlh bC5oPgo+ICsjaW5jbHVkZSA8bGludXgvZ3Bpby9kcml2ZXIuaD4KCk5pdDogcGxhY2UgdGhpcyBh Ym92ZSBsaW51eC91c2Ivc2VyaWFsLmggdG8ga2VlcCBhdCBsZWFzdCB0aG9zZSBpbmNsdWRlcwpz b3J0ZWQuCgo+ICAjaW5jbHVkZSAiZnRkaV9zaW8uaCIKPiAgI2luY2x1ZGUgImZ0ZGlfc2lvX2lk cy5oIgo+ICAKPiBAQCAtNzIsOCArNzMsMjMgQEAgc3RydWN0IGZ0ZGlfcHJpdmF0ZSB7Cj4gIAl1 bnNpZ25lZCBpbnQgbGF0ZW5jeTsJCS8qIGxhdGVuY3kgc2V0dGluZyBpbiB1c2UgKi8KPiAgCXVu c2lnbmVkIHNob3J0IG1heF9wYWNrZXRfc2l6ZTsKPiAgCXN0cnVjdCBtdXRleCBjZmdfbG9jazsg LyogQXZvaWQgbWVzcyBieSBwYXJhbGxlbCBjYWxscyBvZiBjb25maWcgaW9jdGwoKSBhbmQgY2hh bmdlX3NwZWVkKCkgKi8KPiArI2lmIGRlZmluZWQoQ09ORklHX0dQSU9MSUIpCgpVc2UgI2lmZGVm IGhlcmUgYW5kIGVsc2V3aGVyZSAoZGVmaW5lZCgpIGNhbiBiZSB1c2VkIGluIGFjdHVhbCBjb2Rl KS4KCj4gKwlzdHJ1Y3QgZ3Bpb19jaGlwIGdjOwo+ICsJc3RydWN0IG11dGV4ICBncGlvX2xvY2s7 ICAvKiBQcm90ZWN0IEdQSU8gc3RhdGUgYWdhaW5zdCBwYXJhbGxlbCBjYWxscyAqLwoKSnVzdCAi cHJvdGVjdHMgZ3BpbyBzdGF0ZSIsIGlmIGFueXRoaW5nLgoKPiArCWJvb2wJZ3Bpb19yZWdpc3Rl cmVkOyAgLyogaXMgdGhlIGdwaW9jaGlwIGluIGtlcm5lbCByZWdpc3RlcmVkICovCj4gKwlib29s CWdwaW9fdXNlZDsJICAvKiB0cnVlIGlmIHRoZSB1c2VyIHJlcXVlc3RlZCBhIGdwaW8gKi8KPiAr CXU4CWdwaW9fYWx0ZnVuYzsJICAvKiB3aGljaCBwaW5zIGFyZSBpbiBncGlvIG1vZGUgKi8KPiAr CXU4CWdwaW9fb3V0cHV0OwkgIC8qIHBpbiBkaXJlY3Rpb25zIGNhY2hlICovCj4gKwl1OAlncGlv X3ZhbHVlOwkgIC8qIHBpbiB2YWx1ZSBmb3Igb3V0cHV0cyAqLwoKWW91ciBtaXhpbmcgdGFicyBh bmQgc3BhY2VzIGhlYXZpbHkgYWJvdmUuIEp1c3Qgc3RpY2sgdG8gdGhlIGN1cnJlbnQKc3R5bGUg YW5kIGRyb3AgdGhlIHZhcmlhYmxlIG5hbWUgYWxpZ25tZW50LCByZW1vdmUgc3VwZXJmbHVvdXMg c3BhY2VzLAphbmQgdXNlIHRhYnMgb25seSBmb3IgaW5kZW50YXRpb24uCgo+ICsjZW5kaWYKPiAg fTsKPiAgCj4gKyNpZiBkZWZpbmVkKENPTkZJR19HUElPTElCKQo+ICtzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IGZ0ZGlfZnR4X2dwaW9fbmFtZXNbXSA9IHsKPiArCSJDQlVTMCIsICJDQlVTMSIs ICJDQlVTMiIsICJDQlVTMyIKPiArfTsKPiArI2VuZGlmCgpXZSB3YW50IHRvIGtlZXAgdGhlIGlm ZGVmZmVyeSB0byBhIG1pbmltdW0sIHNvIG1vdmUgdGhpcyBpbnNpZGUgdGhlCmdwaW9saWIgaWZk ZWYgYmVsb3cgKGFuZCBwb3NzaWJseSBldmVuIGludG8gdGhlIGZ1bmN0aW9uIHdoZXJlIGl0IGlz CnVzZWQpLgoKQWxzbyBub3RlIHRoYXQgdGhlc2UgbmFtZXMgYXJlIHNoYXJlZCB3aXRoIEZUMjMy UiwgYnV0IG5vdCB3aXRoIEZUMjMySC4KCj4gKwo+ICAvKiBzdHJ1Y3QgZnRkaV9zaW9fcXVpcmsg aXMgdXNlZCBieSBkZXZpY2VzIHJlcXVpcmluZyBzcGVjaWFsIGF0dGVudGlvbi4gKi8KPiAgc3Ry dWN0IGZ0ZGlfc2lvX3F1aXJrIHsKPiAgCWludCAoKnByb2JlKShzdHJ1Y3QgdXNiX3NlcmlhbCAq KTsKPiBAQCAtMTc2Niw2ICsxNzgyLDM0NyBAQCBzdGF0aWMgdm9pZCByZW1vdmVfc3lzZnNfYXR0 cnMoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCkKPiAgCj4gIH0KPiAgCj4gKyNpZiBkZWZp bmVkKENPTkZJR19HUElPTElCKQo+ICsKPiArc3RhdGljIGludCBmdGRpX3NldF9iaXRtb2RlX3Jl cShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCB1OCBtb2RlKQoKTml0OiBwbGVhc2UgZHJv cCB0aGUgX3JlcSBzdWZmaXggaGVyZS4KCj4gK3sKPiArCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnBy aXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Cj4gKwlzdHJ1Y3QgdXNiX3Nlcmlh bCAqc2VyaWFsID0gcG9ydC0+c2VyaWFsOwo+ICsJaW50IHJlc3VsdDsKPiArCXUxNiB2YWw7Cj4g Kwo+ICsJdmFsID0gKG1vZGUgPDwgOCkgfCAocHJpdi0+Z3Bpb19vdXRwdXQgPDwgNCkgfCBwcml2 LT5ncGlvX3ZhbHVlOwo+ICsJcmVzdWx0ID0gdXNiX2NvbnRyb2xfbXNnKHNlcmlhbC0+ZGV2LAo+ ICsJCQkJIHVzYl9zbmRjdHJscGlwZShzZXJpYWwtPmRldiwgMCksCj4gKwkJCQkgRlRESV9TSU9f U0VUX0JJVE1PREVfUkVRVUVTVCwKPiArCQkJCSBGVERJX1NJT19TRVRfQklUTU9ERV9SRVFVRVNU X1RZUEUsIHZhbCwKPiArCQkJCSBwcml2LT5pbnRlcmZhY2UsIE5VTEwsIDAsIFdEUl9USU1FT1VU KTsKPiArCWlmIChyZXN1bHQgPCAwKSB7Cj4gKwkJZGV2X2Vycigmc2VyaWFsLT5pbnRlcmZhY2Ut PmRldiwKPiArCQkJImJpdG1vZGUgcmVxdWVzdCBmYWlsZWQgZm9yIHZhbHVlIDB4JTA0eDogJWRc biIsCj4gKwkJCXZhbCwgcmVzdWx0KTsKPiArCX0KPiArCj4gKwlyZXR1cm4gcmVzdWx0Owo+ICt9 Cgo+ICtzdGF0aWMgaW50IGZ0ZGlfcmVhZF9jYnVzX3BpbnMoc3RydWN0IHVzYl9zZXJpYWxfcG9y dCAqcG9ydCkKPiArewo+ICsJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2Vy aWFsX3BvcnRfZGF0YShwb3J0KTsKPiArCXN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwgPSBwb3J0 LT5zZXJpYWw7Cj4gKwl1bnNpZ25lZCBjaGFyICpyY3ZidWY7CgpOaXQ6IFBsZWFzZSByZW5hbWUg c2ltcGx5IGJ1Ziwgd2hpY2ggaXMgbW9yZSBjb21tb24gYW5kIGltcHJvdmVzCnJlYWRhYmlsaXR5 IGJ5IGJlaW5nIGVhc2llciB0byB0ZWxsIGFwYXJ0IGZyb20gcmVzdWx0LgoKPiArCWludCByZXN1 bHQ7Cj4gKwo+ICsJcmN2YnVmID0ga21hbGxvYygxLCBHRlBfS0VSTkVMKTsKPiArCWlmICghcmN2 YnVmKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCXJlc3VsdCA9IHVzYl9jb250cm9sX21z ZyhzZXJpYWwtPmRldiwKPiArCQkJCSB1c2JfcmN2Y3RybHBpcGUoc2VyaWFsLT5kZXYsIDApLAo+ ICsJCQkJIEZURElfU0lPX1JFQURfUElOU19SRVFVRVNULAo+ICsJCQkJIEZURElfU0lPX1JFQURf UElOU19SRVFVRVNUX1RZUEUsIDAsCj4gKwkJCQkgcHJpdi0+aW50ZXJmYWNlLCByY3ZidWYsIDEs IFdEUl9USU1FT1VUKTsKPiArCWlmIChyZXN1bHQgPCAxKSB7Cj4gKwkJaWYgKHJlc3VsdCA+PSAw KQo+ICsJCQlyZXN1bHQgPSAtRUlPOwo+ICsJfSBlbHNlIHsKPiArCQlyZXN1bHQgPSByY3ZidWZb MF07Cj4gKwl9Cj4gKwo+ICsJa2ZyZWUocmN2YnVmKTsKPiArCj4gKwlyZXR1cm4gcmVzdWx0Owo+ ICt9Cgo+ICtzdGF0aWMgdm9pZCBmdGRpX2dwaW9fc2V0X211bHRpcGxlKHN0cnVjdCBncGlvX2No aXAgKmdjLAo+ICsJCQkJICAgdW5zaWduZWQgbG9uZyAqbWFzaywgdW5zaWduZWQgbG9uZyAqYml0 cykKPiArewo+ICsJc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCA9IGdwaW9jaGlwX2dldF9k YXRhKGdjKTsKPiArCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9w b3J0X2RhdGEocG9ydCk7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmcHJpdi0+Z3Bpb19sb2NrKTsKPiAr Cj4gKwlwcml2LT5ncGlvX3ZhbHVlICY9IH4oKm1hc2spOwo+ICsJcHJpdi0+Z3Bpb192YWx1ZSB8 PSAqYml0czsKCmdwaW9saWIgZG9lc24ndCBjbGVhciBiaXRzIG5vdCBpbiBtYXNrIGZvciB5b3Us IHNvIHlvdSBuZWVkIHRvIE9SIHdpdGgKKm1hc2sgaGVyZSB0byBhdm9pZCBzZXR0aW5nIHJhbmRv bSBvdGhlciBiaXRzLgoKPiArCWZ0ZGlfc2V0X2NidXNfcGlucyhwb3J0KTsKPiArCj4gKwltdXRl eF91bmxvY2soJnByaXYtPmdwaW9fbG9jayk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgZnRkaV9n cGlvX2RpcmVjdGlvbl9nZXQoc3RydWN0IGdwaW9fY2hpcCAqZ2MsIHVuc2lnbmVkIGludCBncGlv KQo+ICt7Cj4gKwlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gZ3Bpb2NoaXBfZ2V0X2Rh dGEoZ2MpOwo+ICsJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3Bv cnRfZGF0YShwb3J0KTsKPiArCj4gKwlpZiAocHJpdi0+Z3Bpb19vdXRwdXQgJiBCSVQoZ3Bpbykp Cj4gKwkJcmV0dXJuIDA7Cj4gKwllbHNlCj4gKwkJcmV0dXJuIDE7CgpUaGlzIGNvdWxkIGp1c3Qg c2ltcGxpZmllZCB1c2luZyBuZWdhdGlvbiAoISksIGJ1dCBwZXJoYXBzIHRoaXMgaXMKZWFzaWVy IHRvIHBhcnNlIGFzIGl0IHN0YW5kcy4KCj4gK30KCj4gK3N0YXRpYyBpbnQgZnRkaV9ncGlvX2lu aXQoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCkKPiArewo+ICsJc3RydWN0IGZ0ZGlfcHJp dmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKPiArCXN0cnVjdCB1 c2Jfc2VyaWFsICpzZXJpYWwgPSBwb3J0LT5zZXJpYWw7Cj4gKwlpbnQgcmVzdWx0Owo+ICsKPiAr CS8qIERldmljZS1zcGVjaWZpYyBpbml0aWFsaXphdGlvbnMgKi8KPiArCXN3aXRjaCAocHJpdi0+ Y2hpcF90eXBlKSB7Cj4gKwljYXNlIEZUWDoKPiArCQlyZXN1bHQgPSBmdHhfZ3Bpb2NvbmZfaW5p dChwb3J0KTsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJcmV0dXJuIDA7Cj4gKwl9Cj4g Kwo+ICsJaWYgKHJlc3VsdCA8IDApCj4gKwkJcmV0dXJuIHJlc3VsdDsKPiArCj4gKwltdXRleF9p bml0KCZwcml2LT5ncGlvX2xvY2spOwo+ICsKPiArCS8qIFJlZ2lzdGVyIEdQSU8gY2hpcCB0byBr ZXJuZWwgKi8KPiArCXByaXYtPmdjLmxhYmVsID0gImZ0ZGktY2J1cyI7Cj4gKwlwcml2LT5nYy5y ZXF1ZXN0ID0gZnRkaV9ncGlvX3JlcXVlc3Q7Cj4gKwlwcml2LT5nYy5nZXRfZGlyZWN0aW9uID0g ZnRkaV9ncGlvX2RpcmVjdGlvbl9nZXQ7Cj4gKwlwcml2LT5nYy5kaXJlY3Rpb25faW5wdXQgPSBm dGRpX2dwaW9fZGlyZWN0aW9uX2lucHV0Owo+ICsJcHJpdi0+Z2MuZGlyZWN0aW9uX291dHB1dCA9 IGZ0ZGlfZ3Bpb19kaXJlY3Rpb25fb3V0cHV0Owo+ICsJcHJpdi0+Z2MuZ2V0ID0gZnRkaV9ncGlv X2dldDsKPiArCXByaXYtPmdjLnNldCA9IGZ0ZGlfZ3Bpb19zZXQ7Cj4gKwlwcml2LT5nYy5nZXRf bXVsdGlwbGUgPSBmdGRpX2dwaW9fZ2V0X211bHRpcGxlOwo+ICsJcHJpdi0+Z2Muc2V0X211bHRp cGxlID0gZnRkaV9ncGlvX3NldF9tdWx0aXBsZTsKPiArCXByaXYtPmdjLm93bmVyID0gVEhJU19N T0RVTEU7Cj4gKwlwcml2LT5nYy5wYXJlbnQgPSAmc2VyaWFsLT5pbnRlcmZhY2UtPmRldjsKPiAr CXByaXYtPmdjLmJhc2UgPSAtMTsKPiArCXByaXYtPmdjLmNhbl9zbGVlcCA9IHRydWU7Cj4gKwlw cml2LT5nYy5uYW1lcyA9IGZ0ZGlfZnR4X2dwaW9fbmFtZXM7CgpBcyBub3RlZCBhYm92ZSwgdGhl c2UgbmFtZXMgYXJlIHNoYXJlZCB3aXRoIGZ0MjMyciBidXQgbm90IHdpdGggZnQyMzJoLAphbmQg dGhpcyBuZWVkcyB0byBiZSBzZXQgaW4gdGhlIGRldmljZSBzcGVjaWZpYyBpbml0IGZ1bmN0aW9u LApzcGVjaWZpY2FsbHksIGFzIHRoZSBhcnJheSBzaXplIG11c3QgYWx3YXlzIG1hdGNoIChvciBh dCBsZWFzdCBiZSBhcwpsYXJnZSBhcykgbmdwaW8uCgo+ICsKPiArCXJlc3VsdCA9IGdwaW9jaGlw X2FkZF9kYXRhKCZwcml2LT5nYywgcG9ydCk7Cj4gKwlpZiAoIXJlc3VsdCkKPiArCQlwcml2LT5n cGlvX3JlZ2lzdGVyZWQgPSB0cnVlOwo+ICsKPiArCXJldHVybiByZXN1bHQ7Cj4gK30KCkpvaGFu Cg== 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.4 required=3.0 tests=DKIM_SIGNED,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,T_DKIM_INVALID,URIBL_BLOCKED, USER_AGENT_MUTT autolearn=ham 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 89A6EC43382 for ; Tue, 25 Sep 2018 10:06:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1955E20842 for ; Tue, 25 Sep 2018 10:06:42 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="KrXJJt0z" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1955E20842 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727613AbeIYQN2 (ORCPT ); Tue, 25 Sep 2018 12:13:28 -0400 Received: from mail-lf1-f68.google.com ([209.85.167.68]:35375 "EHLO mail-lf1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726059AbeIYQN1 (ORCPT ); Tue, 25 Sep 2018 12:13:27 -0400 Received: by mail-lf1-f68.google.com with SMTP id r191-v6so6928737lff.2; Tue, 25 Sep 2018 03:06:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to:user-agent; bh=9iCj/OR5WWhxMBVtao8yNe4JPF8lrAh5TbLarWk9SIw=; b=KrXJJt0zMsCPWg1K3GR7LwUnFv6hnxEwrSrBVEZ2/6wQldaNJ3KBI03EUcfuLWTf2C aGHCD4TGF6M4FZlXvjky3RdMj9mS6Coahk2sj8ZHLNJ4lm4/h/vJ4g6TeZmMgPAx5mL/ 8fWFfQa3j5UEhX9GBCwUhEABbBAqY6Qmj/i6eJVUvEZ0qT84SDZNxhuFH19prBQCCWE7 3odxWXqgbFkdMUaoHtl5SDE4mm3MjOfnOc/CT9fqFDAOwny5NDSpEo/8bEBswtbRLatJ M7VPrusNkIyJiDjcYhVlYSQJnna/nk5BKRf7AKRz1thYP6UGE/IhCuqyExMLAeKvxnwa rRQw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:from:to:cc:subject:message-id :references:mime-version:content-disposition:in-reply-to:user-agent; bh=9iCj/OR5WWhxMBVtao8yNe4JPF8lrAh5TbLarWk9SIw=; b=E//GUC05DiHW4Ijb8cml4pTIiTTALIQ5KsKRTsqQyo2Js38lJiIz6oAhBpC5KTVH0Y R/yWhyPCtR+igZPvEsS01ILg+cAdLjHpB3dG8z2BljpmSUhrf92kNPAPjWeY6mjAc8mw 04LksXnSrb+1x0BbgpOutcCjHBOiabhGvJ54A8YreAUuYMpgXK4l9NCTNDA0h3Z4opqZ QnixlV8yjIojYIknQHtVqaOyMSoZlPnB3vnAnzfGt5G6XS1Tstmpt4fy7h1A23gYqsQD epgbIZIDxq/A7RRTQvqpxKImwr2jtEFvckj4iLXoyjElA+2cMuw8CFb/SpWmi1FCfMTu Axng== X-Gm-Message-State: ABuFfoiBUQyI6DKPaCBbjz8l6izjuZnX/46QQmnAojmwGj8rCgSDEOh2 pSyeXb1R8fjX8Oi1MJXTmDs= X-Google-Smtp-Source: ACcGV63/CAHs3u38p4mOb42QHvyyGmB+Sfcu4uWVdYJYTl45AGXL1FDKeHe9bDQsx2sCbGA1UMjIOw== X-Received: by 2002:a19:a545:: with SMTP id o66-v6mr252541lfe.94.1537869997126; Tue, 25 Sep 2018 03:06:37 -0700 (PDT) Received: from xi.terra (c-74bee655.07-184-6d6c6d4.bbcust.telenor.se. [85.230.190.116]) by smtp.gmail.com with ESMTPSA id t15-v6sm319978ljh.21.2018.09.25.03.06.35 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 25 Sep 2018 03:06:35 -0700 (PDT) Received: from johan by xi.terra with local (Exim 4.91) (envelope-from ) id 1g4kEl-0005cL-E0; Tue, 25 Sep 2018 12:06:35 +0200 Date: Tue, 25 Sep 2018 12:06:35 +0200 From: Johan Hovold To: Karoly Pados Cc: Johan Hovold , Greg Kroah-Hartman , linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org, Loic Poulain Subject: Re: [PATCH v6] USB: serial: ftdi_sio: implement GPIO support for FT-X devices Message-ID: <20180925100635.GC3332@localhost> References: <20180924143151.2273-1-pados@pados.hu> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20180924143151.2273-1-pados@pados.hu> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, Sep 24, 2018 at 04:31:51PM +0200, Karoly Pados wrote: > This patch allows using the CBUS pins of FT-X devices as GPIO in CBUS > bitbanging mode. There is no conflict between the GPIO and VCP > functionality in this mode. Tested on FT230X and FT231X. > > As there is no way to request the current CBUS register configuration > from the device, all CBUS pins are set to a known state when the first > GPIO is requested. This allows using libftdi to set the GPIO pins > before loading this module for UART functionality, a behavior that > existing applications might be relying upon (though no specific case > is known to the authors of this patch). > > Signed-off-by: Karoly Pados > --- > Changelog: > - v2: Fix compile error when CONFIG_GPIOLIB is not defined. > - v3: Incorporate review feedback. > - v4: Include linux/gpio/driver.h unconditionally. > Replace and invert gpio_input with gpio_output. > Make ftdi_gpio_direction_get return 0/1. > Change dev_err msg in ftdi_set_bitmode_req. > Change formatting of error checking in ftdi_gpio_get. > Drop dev_err in ftdi_gpio_set. > Remove some line breaks and empty lines. > Change error handling in ftdi_read_eeprom (and adjust caller). > Replace SIO->FTX in FTDI_SIO_CBUS_MUX_GPIO macro name. > - v5: Resent v4 with no changes by mistake. Please ignore. > - v6: Read only 4 bytes from eeprom in ftx_gpioconf_init. > Compare ftdi_read_eeprom result with 0 instead of eq. cehck. > Reserve 4 GPIOs even for FT234X. > Release CBUS after gpiochip deregister to avoid possible race. > Adjust comment on FTDI_SIO_SET_BITMODE macro. > Protect GPIO value/dir setting with mutex. > Add support for gpiochip.get_multiple and set_multiple. > Add names to GPIO lines. > > get_multiple / set_multiple methods have been added in addition to earlier > review comments. Adding new features like this late in a review cycle risks adding new bugs and creates more work for everyone involved. In this case, there's a bug in your set_multiple() implementation that will need to be addressed in a v7, so I'll comment on some style issues as well while at it. > drivers/usb/serial/ftdi_sio.c | 369 +++++++++++++++++++++++++++++++++- > drivers/usb/serial/ftdi_sio.h | 27 ++- > 2 files changed, 394 insertions(+), 2 deletions(-) > > diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c > index b5cef322826f..566284e2c316 100644 > --- a/drivers/usb/serial/ftdi_sio.c > +++ b/drivers/usb/serial/ftdi_sio.c > @@ -40,6 +40,7 @@ > #include > #include > #include > +#include Nit: place this above linux/usb/serial.h to keep at least those includes sorted. > #include "ftdi_sio.h" > #include "ftdi_sio_ids.h" > > @@ -72,8 +73,23 @@ struct ftdi_private { > unsigned int latency; /* latency setting in use */ > unsigned short max_packet_size; > struct mutex cfg_lock; /* Avoid mess by parallel calls of config ioctl() and change_speed() */ > +#if defined(CONFIG_GPIOLIB) Use #ifdef here and elsewhere (defined() can be used in actual code). > + struct gpio_chip gc; > + struct mutex gpio_lock; /* Protect GPIO state against parallel calls */ Just "protects gpio state", if anything. > + bool gpio_registered; /* is the gpiochip in kernel registered */ > + bool gpio_used; /* true if the user requested a gpio */ > + u8 gpio_altfunc; /* which pins are in gpio mode */ > + u8 gpio_output; /* pin directions cache */ > + u8 gpio_value; /* pin value for outputs */ Your mixing tabs and spaces heavily above. Just stick to the current style and drop the variable name alignment, remove superfluous spaces, and use tabs only for indentation. > +#endif > }; > > +#if defined(CONFIG_GPIOLIB) > +static const char * const ftdi_ftx_gpio_names[] = { > + "CBUS0", "CBUS1", "CBUS2", "CBUS3" > +}; > +#endif We want to keep the ifdeffery to a minimum, so move this inside the gpiolib ifdef below (and possibly even into the function where it is used). Also note that these names are shared with FT232R, but not with FT232H. > + > /* struct ftdi_sio_quirk is used by devices requiring special attention. */ > struct ftdi_sio_quirk { > int (*probe)(struct usb_serial *); > @@ -1766,6 +1782,347 @@ static void remove_sysfs_attrs(struct usb_serial_port *port) > > } > > +#if defined(CONFIG_GPIOLIB) > + > +static int ftdi_set_bitmode_req(struct usb_serial_port *port, u8 mode) Nit: please drop the _req suffix here. > +{ > + struct ftdi_private *priv = usb_get_serial_port_data(port); > + struct usb_serial *serial = port->serial; > + int result; > + u16 val; > + > + val = (mode << 8) | (priv->gpio_output << 4) | priv->gpio_value; > + result = usb_control_msg(serial->dev, > + usb_sndctrlpipe(serial->dev, 0), > + FTDI_SIO_SET_BITMODE_REQUEST, > + FTDI_SIO_SET_BITMODE_REQUEST_TYPE, val, > + priv->interface, NULL, 0, WDR_TIMEOUT); > + if (result < 0) { > + dev_err(&serial->interface->dev, > + "bitmode request failed for value 0x%04x: %d\n", > + val, result); > + } > + > + return result; > +} > +static int ftdi_read_cbus_pins(struct usb_serial_port *port) > +{ > + struct ftdi_private *priv = usb_get_serial_port_data(port); > + struct usb_serial *serial = port->serial; > + unsigned char *rcvbuf; Nit: Please rename simply buf, which is more common and improves readability by being easier to tell apart from result. > + int result; > + > + rcvbuf = kmalloc(1, GFP_KERNEL); > + if (!rcvbuf) > + return -ENOMEM; > + > + result = usb_control_msg(serial->dev, > + usb_rcvctrlpipe(serial->dev, 0), > + FTDI_SIO_READ_PINS_REQUEST, > + FTDI_SIO_READ_PINS_REQUEST_TYPE, 0, > + priv->interface, rcvbuf, 1, WDR_TIMEOUT); > + if (result < 1) { > + if (result >= 0) > + result = -EIO; > + } else { > + result = rcvbuf[0]; > + } > + > + kfree(rcvbuf); > + > + return result; > +} > +static void ftdi_gpio_set_multiple(struct gpio_chip *gc, > + unsigned long *mask, unsigned long *bits) > +{ > + struct usb_serial_port *port = gpiochip_get_data(gc); > + struct ftdi_private *priv = usb_get_serial_port_data(port); > + > + mutex_lock(&priv->gpio_lock); > + > + priv->gpio_value &= ~(*mask); > + priv->gpio_value |= *bits; gpiolib doesn't clear bits not in mask for you, so you need to OR with *mask here to avoid setting random other bits. > + ftdi_set_cbus_pins(port); > + > + mutex_unlock(&priv->gpio_lock); > +} > + > +static int ftdi_gpio_direction_get(struct gpio_chip *gc, unsigned int gpio) > +{ > + struct usb_serial_port *port = gpiochip_get_data(gc); > + struct ftdi_private *priv = usb_get_serial_port_data(port); > + > + if (priv->gpio_output & BIT(gpio)) > + return 0; > + else > + return 1; This could just simplified using negation (!), but perhaps this is easier to parse as it stands. > +} > +static int ftdi_gpio_init(struct usb_serial_port *port) > +{ > + struct ftdi_private *priv = usb_get_serial_port_data(port); > + struct usb_serial *serial = port->serial; > + int result; > + > + /* Device-specific initializations */ > + switch (priv->chip_type) { > + case FTX: > + result = ftx_gpioconf_init(port); > + break; > + default: > + return 0; > + } > + > + if (result < 0) > + return result; > + > + mutex_init(&priv->gpio_lock); > + > + /* Register GPIO chip to kernel */ > + priv->gc.label = "ftdi-cbus"; > + priv->gc.request = ftdi_gpio_request; > + priv->gc.get_direction = ftdi_gpio_direction_get; > + priv->gc.direction_input = ftdi_gpio_direction_input; > + priv->gc.direction_output = ftdi_gpio_direction_output; > + priv->gc.get = ftdi_gpio_get; > + priv->gc.set = ftdi_gpio_set; > + priv->gc.get_multiple = ftdi_gpio_get_multiple; > + priv->gc.set_multiple = ftdi_gpio_set_multiple; > + priv->gc.owner = THIS_MODULE; > + priv->gc.parent = &serial->interface->dev; > + priv->gc.base = -1; > + priv->gc.can_sleep = true; > + priv->gc.names = ftdi_ftx_gpio_names; As noted above, these names are shared with ft232r but not with ft232h, and this needs to be set in the device specific init function, specifically, as the array size must always match (or at least be as large as) ngpio. > + > + result = gpiochip_add_data(&priv->gc, port); > + if (!result) > + priv->gpio_registered = true; > + > + return result; > +} Johan