From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Date: Fri, 10 Aug 2012 04:39:56 +0000 (GMT) From: MyungJoo Ham Subject: Re: [PATCH] [PATCH V4]Extcon: adc_jack: adc-jack driver to support 3.5 pi or simliar devices To: anish kumar , "gregkh@linuxfoundation.org" Cc: =?euc-kr?Q?=C3=D6=C2=F9=BF=EC?= , "lars@metafoo.de" , "jic23@cam.ac.uk" , "linux-kernel@vger.kernel.org" , "linux-iio@vger.kernel.org" , ANISH KUMAR Reply-to: myungjoo.ham@samsung.com MIME-version: 1.0 Content-type: text/plain; charset=euc-kr MIME-version: 1.0 Message-id: <26154270.13971344573594322.JavaMail.weblogic@epml26> List-ID: PiBGcm9tOiBhbmlzaCBrdW1hciA8YW5pc2gxOTg1MTk4NTE5ODVAZ21haWwuY29tPg0KPiANCj4g RXh0ZXJuYWwgY29ubmVjdG9yIGRldmljZXMgdGhhdCBkZWNpZGVzIGNvbm5lY3Rpb24gaW5mb3Jt YXRpb24gYmFzZWQgb24NCj4gQURDIHZhbHVlcyBtYXkgdXNlIGFkYy1qYWNrIGRldmljZSBkcml2 ZXIuIFRoZSB1c2VyIHNpbXBseSBuZWVkcyB0bw0KPiBwcm92aWRlIGEgdGFibGUgb2YgYWRjIHJh bmdlIGFuZCBjb25uZWN0aW9uIHN0YXRlcy4gVGhlbiwgZXh0Y29uDQo+IGZyYW1ld29yayB3aWxs IGF1dG9tYXRpY2FsbHkgbm90aWZ5IG90aGVycy4NCg0KMS4gTWlzc2luZyBoZWFkZXI6ICNpbmNs dWRlPGxpbnV4L2Vyci5oPg0KMi4gTWlzc2luZyBkZXBlbmRlbmN5IHRvIElJTy4gKHBsZWFzZSBh ZGQgSUlPIGRlcGVuZGVuY3kgYXQgS2NvbmZpZykNCg0KDQpDaGVlcnMhDQpNeXVuZ0pvbw0KDQo+ IA0KPiBDaGFuZ2VzIGluIFYxOg0KPiBhZGRlZCBMYXJzLVBldGVyIENsYXVzZW4gc3VnZ2VzdGVk IGNoYW5nZXM6DQo+IFVzaW5nIG1hY3JvcyB0byBnZXQgcmlkIG9mIGJvaWxlciBwbGF0ZSBjb2Rl IHN1Y2ggYXMgZGV2bV9remFsbG9jDQo+IGFuZCBtb2R1bGVfcGxhdGZvcm1fZHJpdmVyLk90aGVy IGNoYW5nZXMgc3VnZ2VzdGVkIGFyZSByZWxhdGVkIHRvDQo+IGNvZGluZyBndWlkZWxpbmVzLg0K PiANCj4gQ2hhbmdlcyBpbiBWMjoNCj4gUmVtb3ZlZCBzb21lIHVubmVjZXNzYXJ5IGNoZWNrcyBh bmQgY2hhbmdlZCB0aGUgd2F5IHdlIGFyZSB1bi1yZWdpdGVyaW5nDQo+IGV4dGNvbiBhbmQgZnJl ZWluZyB0aGUgaXJxIHdoaWxlIHJlbW92aW5nLg0KPiANCj4gQ2hhbmdlcyBpbiBWMzoNCj4gUmVu YW1lZCB0aGUgZmlsZXMgdG8gY29tcGx5IHdpdGggZXh0Y29uIG5hbWluZy4NCj4gDQo+IENoYW5n ZXMgaW4gdGhpcyB2ZXJzaW9uOg0KPiBBZGRlZCB0aGUgY2FuY2VsX3dvcmtfc3luYyBkdXJpbmcg cmVtb3Zpbmcgb2YgZHJpdmVyLg0KPiANCj4gUmV2aWV3ZWQtYnk6IExhcnMtUGV0ZXIgQ2xhdXNl biA8bGFyc0BtZXRhZm9vLmRlPg0KPiBTaWduZWQtb2ZmLWJ5OiBhbmlzaCBrdW1hciA8YW5pc2gu c2luZ2hAc2Ftc3VuZy5jb20+DQo+IFNpZ25lZC1vZmYtYnk6IE15dW5nSm9vIEhhbSA8bXl1bmdq b28uaGFtQHNhbXN1bmcuY29tPg0KPiAtLS0NCj4gIGRyaXZlcnMvZXh0Y29uL0tjb25maWcgICAg ICAgICAgICAgICAgIHwgICAgNSArDQo+ICBkcml2ZXJzL2V4dGNvbi9NYWtlZmlsZSAgICAgICAg ICAgICAgICB8ICAgIDEgKw0KPiAgZHJpdmVycy9leHRjb24vZXh0Y29uLWFkYy1qYWNrLmMgICAg ICAgfCAgMTk0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ICBpbmNsdWRlL2xp bnV4L2V4dGNvbi9leHRjb24tYWRjLWphY2suaCB8ICAgNzMgKysrKysrKysrKysrDQo+ICA0IGZp bGVzIGNoYW5nZWQsIDI3MyBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQ0KPiAgY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvZXh0Y29uL2V4dGNvbi1hZGMtamFjay5jDQo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9leHRjb24vZXh0Y29uLWFkYy1qYWNrLmgNCj4gDQo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2V4dGNvbi9LY29uZmlnIGIvZHJpdmVycy9leHRjb24vS2Nv bmZpZw0KPiBpbmRleCBlMTc1YzhlLi41OTZlMjc3IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL2V4 dGNvbi9LY29uZmlnDQo+ICsrKyBiL2RyaXZlcnMvZXh0Y29uL0tjb25maWcNCj4gQEAgLTIxLDYg KzIxLDExIEBAIGNvbmZpZyBFWFRDT05fR1BJTw0KPiAgCSAgU2F5IFkgaGVyZSB0byBlbmFibGUg R1BJTyBiYXNlZCBleHRjb24gc3VwcG9ydC4gTm90ZSB0aGF0IEdQSU8NCj4gIAkgIGV4dGNvbiBz dXBwb3J0cyBzaW5nbGUgc3RhdGUgcGVyIGV4dGNvbiBpbnN0YW5jZS4NCj4gIA0KPiArY29uZmln IEVYVENPTl9BRENfSkFDSw0KPiArICAgICAgICB0cmlzdGF0ZSAiQURDIEphY2sgZXh0Y29uIHN1 cHBvcnQiDQo+ICsgICAgICAgIGhlbHANCj4gKyAgICAgICAgICBTYXkgWSBoZXJlIHRvIGVuYWJs ZSBleHRjb24gZGV2aWNlIGRyaXZlciBiYXNlZCBvbiBBREMgdmFsdWVzLg0KPiArDQo+ICBjb25m aWcgRVhUQ09OX01BWDc3NjkzDQo+ICAJdHJpc3RhdGUgIk1BWDc3NjkzIEVYVENPTiBTdXBwb3J0 Ig0KPiAgCWRlcGVuZHMgb24gTUZEX01BWDc3NjkzDQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2V4 dGNvbi9NYWtlZmlsZSBiL2RyaXZlcnMvZXh0Y29uL01ha2VmaWxlDQo+IGluZGV4IDg4OTYxYjMu LmJjNzExMWUgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvZXh0Y29uL01ha2VmaWxlDQo+ICsrKyBi L2RyaXZlcnMvZXh0Y29uL01ha2VmaWxlDQo+IEBAIC00LDYgKzQsNyBAQA0KPiAgDQo+ICBvYmot JChDT05GSUdfRVhUQ09OKQkJKz0gZXh0Y29uX2NsYXNzLm8NCj4gIG9iai0kKENPTkZJR19FWFRD T05fR1BJTykJKz0gZXh0Y29uX2dwaW8ubw0KPiArb2JqLSQoQ09ORklHX0VYVENPTl9BRENfSkFD SykgICArPSBleHRjb24tYWRjLWphY2subw0KPiAgb2JqLSQoQ09ORklHX0VYVENPTl9NQVg3NzY5 MykJKz0gZXh0Y29uLW1heDc3NjkzLm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fTUFYODk5NykJ Kz0gZXh0Y29uLW1heDg5OTcubw0KPiAgb2JqLSQoQ09ORklHX0VYVENPTl9BUklaT05BKQkrPSBl eHRjb24tYXJpem9uYS5vDQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2V4dGNvbi9leHRjb24tYWRj LWphY2suYyBiL2RyaXZlcnMvZXh0Y29uL2V4dGNvbi1hZGMtamFjay5jDQo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0DQo+IGluZGV4IDAwMDAwMDAuLmNmYzhjNTkNCj4gLS0tIC9kZXYvbnVsbA0KPiAr KysgYi9kcml2ZXJzL2V4dGNvbi9leHRjb24tYWRjLWphY2suYw0KPiBAQCAtMCwwICsxLDE5NCBA QA0KPiArLyoNCj4gKyAqIGRyaXZlcnMvZXh0Y29uL2V4dGNvbi1hZGMtamFjay5jDQo+ICsgKg0K PiArICogQW5hbG9nIEphY2sgZXh0Y29uIGRyaXZlciB3aXRoIEFEQy1iYXNlZCBkZXRlY3Rpb24g Y2FwYWJpbGl0eS4NCj4gKyAqDQo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTIgU2Ftc3VuZyBFbGVj dHJvbmljcw0KPiArICogTXl1bmdKb28gSGFtIDxteXVuZ2pvby5oYW1Ac2Ftc3VuZy5jb20+DQo+ ICsgKg0KPiArICogTW9kaWZpZWQgZm9yIGNhbGxpbmcgdG8gSUlPIHRvIGdldCBhZGMgYnkgPGFu aXNoLnNpbmdoQHNhbXN1bmcuY29tPg0KPiArICoNCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQo+ICsgKiBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNp b24gMiBhcw0KPiArICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24u DQo+ICsgKg0KPiArICovDQo+ICsNCj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+DQo+ICsjaW5j bHVkZSA8bGludXgvZGV2aWNlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNl Lmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+DQo+ICsjaW5jbHVkZSA8bGludXgv d29ya3F1ZXVlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaWlvL2NvbnN1bWVyLmg+DQo+ICsjaW5j bHVkZSA8bGludXgvZXh0Y29uL2V4dGNvbi1hZGMtamFjay5oPg0KPiArI2luY2x1ZGUgPGxpbnV4 L2V4dGNvbi5oPg0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVjdCBhZGNfamFja19kYXRhIC0gaW50 ZXJuYWwgZGF0YSBmb3IgYWRjX2phY2sgZGV2aWNlIGRyaXZlcg0KPiArICogQGVkZXYgICAgICAg IC0gZXh0Y29uIGRldmljZS4NCj4gKyAqIEBjYWJsZV9uYW1lcyAtIGxpc3Qgb2Ygc3VwcG9ydGVk IGNhYmxlcy4NCj4gKyAqIEBudW1fY2FibGVzICAtIHNpemUgb2YgY2FibGVfbmFtZXMuDQo+ICsg KiBAYWRjX2NvbmRpdGlvbiAgICAgICAtIGxpc3Qgb2YgYWRjIHZhbHVlIGNvbmRpdGlvbnMuDQo+ ICsgKiBAbnVtX2NvbmRpdGlvbiAgICAgICAtIHNpemUgb2YgYWRjX2NvbmRpdGlvbi4NCj4gKyAq IEBpcnEgICAgICAgICAtIGlycSBudW1iZXIgb2YgYXR0YWNoL2RldGFjaCBldmVudCAoMCBpZiBu b3QgZXhpc3QpLg0KPiArICogQGhhbmRsaW5nX2RlbGF5ICAgICAgLSBpbnRlcnJ1cHQgaGFuZGxl ciB3aWxsIHNjaGVkdWxlIGV4dGNvbiBldmVudA0KPiArICogICAgICAgICAgICAgICAgICAgICAg aGFuZGxpbmcgYXQgaGFuZGxpbmdfZGVsYXkgamlmZmllcy4NCj4gKyAqIEBoYW5kbGVyICAgICAt IGV4dGNvbiBldmVudCBoYW5kbGVyIGNhbGxlZCBieSBpbnRlcnJ1cHQgaGFuZGxlci4NCj4gKyAq IEBjaGFuCS0gaWlvIGNoYW5uZWwgYmVpbmcgcXVlcmllZC4NCj4gKyAqLw0KPiArc3RydWN0IGFk Y19qYWNrX2RhdGEgew0KPiArCXN0cnVjdCBleHRjb25fZGV2IGVkZXY7DQo+ICsNCj4gKwljb25z dCBjaGFyICoqY2FibGVfbmFtZXM7DQo+ICsJaW50IG51bV9jYWJsZXM7DQo+ICsJc3RydWN0IGFk Y19qYWNrX2NvbmQgKmFkY19jb25kaXRpb247DQo+ICsJaW50IG51bV9jb25kaXRpb25zOw0KPiAr DQo+ICsJaW50IGlycTsNCj4gKwl1bnNpZ25lZCBsb25nIGhhbmRsaW5nX2RlbGF5OyAvKiBpbiBq aWZmaWVzICovDQo+ICsJc3RydWN0IGRlbGF5ZWRfd29yayBoYW5kbGVyOw0KPiArDQo+ICsJc3Ry dWN0IGlpb19jaGFubmVsICpjaGFuOw0KPiArfTsNCj4gKw0KPiArc3RhdGljIHZvaWQgYWRjX2ph Y2tfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspDQo+ICt7DQo+ICsJc3RydWN0IGFk Y19qYWNrX2RhdGEgKmRhdGEgPSBjb250YWluZXJfb2YodG9fZGVsYXllZF93b3JrKHdvcmspLA0K PiArCQkJCQkJICBzdHJ1Y3QgYWRjX2phY2tfZGF0YSwNCj4gKwkJCQkJCSAgaGFuZGxlcik7DQo+ ICsJdTMyIHN0YXRlID0gMDsNCj4gKwlpbnQgcmV0LCBhZGNfdmFsOw0KPiArCWludCBpOw0KPiAr DQo+ICsJcmV0ID0gaWlvX3JlYWRfY2hhbm5lbF9yYXcoZGF0YS0+Y2hhbiwgJmFkY192YWwpOw0K PiArCWlmIChyZXQgPCAwKSB7DQo+ICsJCWRldl9lcnIoZGF0YS0+ZWRldi5kZXYsICJyZWFkIGNo YW5uZWwoKSBlcnJvcjogJWRcbiIsIHJldCk7DQo+ICsJCXJldHVybjsNCj4gKwl9DQo+ICsNCj4g KwkvKiBHZXQgc3RhdGUgZnJvbSBhZGMgdmFsdWUgd2l0aCBhZGNfY29uZGl0aW9uICovDQo+ICsJ Zm9yIChpID0gMDsgaSA8IGRhdGEtPm51bV9jb25kaXRpb25zOyBpKyspIHsNCj4gKwkJc3RydWN0 IGFkY19qYWNrX2NvbmQgKmRlZiA9ICZkYXRhLT5hZGNfY29uZGl0aW9uW2ldOw0KPiArCQlpZiAo IWRlZi0+c3RhdGUpDQo+ICsJCQlicmVhazsNCj4gKwkJaWYgKGRlZi0+bWluX2FkYyA8PSBhZGNf dmFsICYmIGRlZi0+bWF4X2FkYyA+PSBhZGNfdmFsKSB7DQo+ICsJCQlzdGF0ZSA9IGRlZi0+c3Rh dGU7DQo+ICsJCQlicmVhazsNCj4gKwkJfQ0KPiArCX0NCj4gKwkvKiBpZiBubyBkZWYgaGFzIG1l dCwgaXQgbWVhbnMgc3RhdGUgPSAwIChubyBjYWJsZXMgYXR0YWNoZWQpICovDQo+ICsNCj4gKwll eHRjb25fc2V0X3N0YXRlKCZkYXRhLT5lZGV2LCBzdGF0ZSk7DQo+ICt9DQo+ICsNCj4gK3N0YXRp YyBpcnFyZXR1cm5fdCBhZGNfamFja19pcnFfdGhyZWFkKGludCBpcnEsIHZvaWQgKl9kYXRhKQ0K PiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRhICpkYXRhID0gX2RhdGE7DQo+ICsNCj4gKwlz Y2hlZHVsZV9kZWxheWVkX3dvcmsoJmRhdGEtPmhhbmRsZXIsIGRhdGEtPmhhbmRsaW5nX2RlbGF5 KTsNCj4gKwlyZXR1cm4gSVJRX0hBTkRMRUQ7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgX19k ZXZpbml0IGFkY19qYWNrX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+ICt7 DQo+ICsJc3RydWN0IGFkY19qYWNrX2RhdGEgKmRhdGE7DQo+ICsJc3RydWN0IGFkY19qYWNrX3Bk YXRhICpwZGF0YSA9IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOw0KPiArCWludCBpLCBlcnIgPSAw Ow0KPiArDQo+ICsJZGF0YSA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmRhdGEp LCBHRlBfS0VSTkVMKTsNCj4gKwlpZiAoIWRhdGEpDQo+ICsJCXJldHVybiAtRU5PTUVNOw0KPiAr DQo+ICsJZGF0YS0+ZWRldi5uYW1lID0gcGRhdGEtPm5hbWU7DQo+ICsNCj4gKwlpZiAocGRhdGEt PmNhYmxlX25hbWVzKQ0KPiArCQlkYXRhLT5lZGV2LnN1cHBvcnRlZF9jYWJsZSA9IHBkYXRhLT5j YWJsZV9uYW1lczsNCj4gKwllbHNlDQo+ICsJCWRhdGEtPmVkZXYuc3VwcG9ydGVkX2NhYmxlID0g ZXh0Y29uX2NhYmxlX25hbWU7DQo+ICsNCj4gKwkvKiBDaGVjayB0aGUgbGVuZ3RoIG9mIGFycmF5 IGFuZCBzZXQgbnVtX2NhYmxlcyAqLw0KPiArCWZvciAoaSA9IDA7IGRhdGEtPmVkZXYuc3VwcG9y dGVkX2NhYmxlW2ldOyBpKyspDQo+ICsJCTsNCj4gKwlpZiAoaSA9PSAwIHx8IGkgPiBTVVBQT1JU RURfQ0FCTEVfTUFYKSB7DQo+ICsJCWVyciA9IC1FSU5WQUw7DQo+ICsJCWRldl9lcnIoJnBkZXYt PmRldiwgImVycm9yOiBwZGF0YS0+Y2FibGVfbmFtZXMgc2l6ZSA9ICVkXG4iLA0KPiArCQkJaSAt IDEpOw0KPiArCQlnb3RvIG91dDsNCj4gKwl9DQo+ICsJZGF0YS0+bnVtX2NhYmxlcyA9IGk7DQo+ ICsNCj4gKwlpZiAoIXBkYXRhLT5hZGNfY29uZGl0aW9uIHx8DQo+ICsJICAgICFwZGF0YS0+YWRj X2NvbmRpdGlvblswXS5zdGF0ZSkgew0KPiArCQllcnIgPSAtRUlOVkFMOw0KPiArCQlkZXZfZXJy KCZwZGV2LT5kZXYsICJlcnJvcjogYWRjX2NvbmRpdGlvbiBub3QgZGVmaW5lZC5cbiIpOw0KPiAr CQlnb3RvIG91dDsNCj4gKwl9DQo+ICsJZGF0YS0+YWRjX2NvbmRpdGlvbiA9IHBkYXRhLT5hZGNf Y29uZGl0aW9uOw0KPiArDQo+ICsJLyogQ2hlY2sgdGhlIGxlbmd0aCBvZiBhcnJheSBhbmQgc2V0 IG51bV9jb25kaXRpb25zICovDQo+ICsJZm9yIChpID0gMDsgZGF0YS0+YWRjX2NvbmRpdGlvbltp XS5zdGF0ZTsgaSsrKQ0KPiArCQk7DQo+ICsJZGF0YS0+bnVtX2NvbmRpdGlvbnMgPSBpOw0KPiAr DQo+ICsJZGF0YS0+Y2hhbiA9IGlpb19jaGFubmVsX2dldChkZXZfbmFtZSgmcGRldi0+ZGV2KSwN Cj4gKwkJCQkJCXBkYXRhLT5jb25zdW1lcl9jaGFubmVsKTsNCj4gKwlpZiAoSVNfRVJSKGRhdGEt PmNoYW4pKSB7DQo+ICsJCWVyciA9IFBUUl9FUlIoZGF0YS0+Y2hhbik7DQo+ICsJCWdvdG8gb3V0 Ow0KPiArCX0NCj4gKw0KPiArCWRhdGEtPmhhbmRsaW5nX2RlbGF5ID0gbXNlY3NfdG9famlmZmll cyhwZGF0YS0+aGFuZGxpbmdfZGVsYXlfbXMpOw0KPiArDQo+ICsJSU5JVF9ERUxBWUVEX1dPUktf REVGRVJSQUJMRSgmZGF0YS0+aGFuZGxlciwgYWRjX2phY2tfaGFuZGxlcik7DQo+ICsNCj4gKwlw bGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYXRhKTsNCj4gKw0KPiArCWVyciA9IGV4dGNvbl9k ZXZfcmVnaXN0ZXIoJmRhdGEtPmVkZXYsICZwZGV2LT5kZXYpOw0KPiArCWlmIChlcnIpDQo+ICsJ CWdvdG8gb3V0Ow0KPiArDQo+ICsJZGF0YS0+aXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAw KTsNCj4gKwlpZiAoIWRhdGEtPmlycSkgew0KPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJwbGF0 Zm9ybV9nZXRfaXJxIGZhaWxlZFxuIik7DQo+ICsJCWVyciA9IC1FTk9ERVY7DQo+ICsJCWdvdG8g ZXJyX2lycTsNCj4gKwl9DQo+ICsNCj4gKwllcnIgPSByZXF1ZXN0X2FueV9jb250ZXh0X2lycShk YXRhLT5pcnEsIGFkY19qYWNrX2lycV90aHJlYWQsDQo+ICsJCQkJcGRhdGEtPmlycV9mbGFncywg cGRhdGEtPm5hbWUsIGRhdGEpOw0KPiArDQo+ICsJaWYgKGVycikgew0KPiArCQlkZXZfZXJyKCZw ZGV2LT5kZXYsICJlcnJvcjogaXJxICVkXG4iLCBkYXRhLT5pcnEpOw0KPiArCQllcnIgPSAtRUlO VkFMOw0KPiArCQlnb3RvIGVycl9pcnE7DQo+ICsJfQ0KPiArDQo+ICsJZ290byBvdXQ7DQo+ICsN Cj4gK2Vycl9pcnE6DQo+ICsJZXh0Y29uX2Rldl91bnJlZ2lzdGVyKCZkYXRhLT5lZGV2KTsNCj4g K291dDoNCj4gKwlyZXR1cm4gZXJyOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgaW50IF9fZGV2ZXhp dCBhZGNfamFja19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikNCj4gK3sNCj4g KwlzdHJ1Y3QgYWRjX2phY2tfZGF0YSAqZGF0YSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYp Ow0KPiArDQo+ICsJZnJlZV9pcnEoZGF0YS0+aXJxLCBkYXRhKTsNCj4gKwljYW5jZWxfd29ya19z eW5jKCZkYXRhLT5oYW5kbGVyLndvcmspOw0KPiArCWV4dGNvbl9kZXZfdW5yZWdpc3RlcigmZGF0 YS0+ZWRldik7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGljIHN0cnVj dCBwbGF0Zm9ybV9kcml2ZXIgYWRjX2phY2tfZHJpdmVyID0gew0KPiArCS5wcm9iZQkJPSBhZGNf amFja19wcm9iZSwNCj4gKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKGFkY19qYWNrX3JlbW92ZSks DQo+ICsJLmRyaXZlcgkJPSB7DQo+ICsJCS5uYW1lCT0gImFkYy1qYWNrIiwNCj4gKwkJLm93bmVy CT0gVEhJU19NT0RVTEUsDQo+ICsJfSwNCj4gK307DQo+ICsNCj4gK21vZHVsZV9wbGF0Zm9ybV9k cml2ZXIoYWRjX2phY2tfZHJpdmVyKTsNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZXh0 Y29uL2V4dGNvbi1hZGMtamFjay5oIGIvaW5jbHVkZS9saW51eC9leHRjb24vZXh0Y29uLWFkYy1q YWNrLmgNCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gaW5kZXggMDAwMDAwMC4uYzM1MDYxNQ0K PiAtLS0gL2Rldi9udWxsDQo+ICsrKyBiL2luY2x1ZGUvbGludXgvZXh0Y29uL2V4dGNvbi1hZGMt amFjay5oDQo+IEBAIC0wLDAgKzEsNzMgQEANCj4gKy8qDQo+ICsgKiBpbmNsdWRlL2xpbnV4L2V4 dGNvbi9leHRjb24tYWRjLWphY2suaA0KPiArICoNCj4gKyAqIEFuYWxvZyBKYWNrIGV4dGNvbiBk cml2ZXIgd2l0aCBBREMtYmFzZWQgZGV0ZWN0aW9uIGNhcGFiaWxpdHkuDQo+ICsgKg0KPiArICog Q29weXJpZ2h0IChDKSAyMDEyIFNhbXN1bmcgRWxlY3Ryb25pY3MNCj4gKyAqIE15dW5nSm9vIEhh bSA8bXl1bmdqb28uaGFtQHNhbXN1bmcuY29tPg0KPiArICoNCj4gKyAqIFRoaXMgcHJvZ3JhbSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQo+ ICsgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IHZlcnNpb24gMiBhcw0KPiArICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24uDQo+ICsgKg0KPiArICovDQo+ICsNCj4gKyNpZm5kZWYgX0VYVENPTl9BRENfSkFDS19I Xw0KPiArI2RlZmluZSBfRVhUQ09OX0FEQ19KQUNLX0hfIF9fRklMRV9fDQo+ICsNCj4gKyNpbmNs dWRlIDxsaW51eC9tb2R1bGUuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9leHRjb24uaD4NCj4gKw0K PiArLyoqDQo+ICsgKiBzdHJ1Y3QgYWRjX2phY2tfY29uZCAtIGNvbmRpdGlvbiB0byB1c2UgYW4g ZXh0Y29uIHN0YXRlDQo+ICsgKiBAc3RhdGUJLSB0aGUgY29ycmVzcG9uZGluZyBleHRjb24gc3Rh dGUgKGlmIDAsIHRoaXMgc3RydWN0IGRlbm90ZXMNCj4gKyAqCQl0aGUgbGFzdCBhZGNfamFja19j b25kIGVsZW1lbnQgYW1vbmcgdGhlIGFycmF5KQ0KPiArICogQG1pbl9hZGMJLSBtaW4gYWRjIHZh bHVlIGZvciB0aGlzIGNvbmRpdGlvbg0KPiArICogQG1heF9hZGMJLSBtYXggYWRjIHZhbHVlIGZv ciB0aGlzIGNvbmRpdGlvbg0KPiArICoNCj4gKyAqIEZvciBleGFtcGxlLCBpZiB7IC5zdGF0ZSA9 IDB4MywgLm1pbl9hZGMgPSAxMDAsIC5tYXhfYWRjID0gMjAwfSwgaXQgbWVhbnMNCj4gKyAqIHRo YXQgaWYgQURDIHZhbHVlIGlzIGJldHdlZW4gKGluY2x1c2l2ZSkgMTAwIGFuZCAyMDAsIHRoYW4g dGhlIGNhYmxlIDAgYW5kDQo+ICsgKiAxIGFyZSBhdHRhY2hlZCAoMTw8MCB8IDE8PDEgPT0gMHgz KQ0KPiArICoNCj4gKyAqIE5vdGUgdGhhdCB5b3UgZG9uJ3QgbmVlZCB0byBkZXNjcmliZSBjb25k aXRpb24gZm9yICJubyBjYWJsZSBhdHRhY2hlZCINCj4gKyAqIGJlY2F1c2Ugd2hlbiBubyBhZGNf amFja19jb25kIGlzIG1ldCwgc3RhdGUgPSAwIGlzIGF1dG9tYXRpY2FsbHkgY2hvc2VuLg0KPiAr ICovDQo+ICtzdHJ1Y3QgYWRjX2phY2tfY29uZCB7DQo+ICsJdTMyIHN0YXRlOyAvKiBleHRjb24g c3RhdGUgdmFsdWUuIDAgaWYgaW52YWxpZCAqLw0KPiArCXUzMiBtaW5fYWRjOw0KPiArCXUzMiBt YXhfYWRjOw0KPiArfTsNCj4gKw0KPiArLyoqDQo+ICsgKiBzdHJ1Y3QgYWRjX2phY2tfcGRhdGEg LSBwbGF0Zm9ybSBkYXRhIGZvciBhZGMgamFjayBkZXZpY2UuDQo+ICsgKiBAbmFtZQktIG5hbWUg b2YgdGhlIGV4dGNvbiBkZXZpY2UuIElmIG51bGwsICJhZGMtamFjayIgaXMgdXNlZC4NCj4gKyAq IEBjb25zdW1lcl9jaGFubmVsIC0gVW5pcXVlIG5hbWUgdG8gaWRlbnRpZnkgdGhlIGNoYW5uZWwg b24gdGhlIGNvbnN1bWVyDQo+ICsgKiAgICAgICAgICAgICAgICAgICBzaWRlLiBUaGlzIHR5cGlj YWxseSBkZXNjcmliZXMgdGhlIGNoYW5uZWxzIHVzZSB3aXRoaW4NCj4gKyAqICAgICAgICAgICAg ICAgICAgIHRoZSBjb25zdW1lci4gRS5nLiAnYmF0dGVyeV92b2x0YWdlJw0KPiArICogQGNhYmxl X25hbWVzCS0gYXJyYXkgb2YgY2FibGUgbmFtZXMgZW5kaW5nIHdpdGggbnVsbC4gSWYgdGhlIGFy cmF5IGl0c2VsZg0KPiArICoJCWlmIG51bGwsIGV4dGNvbiBzdGFuZGFyZCBjYWJsZSBuYW1lcyBh cmUgY2hvc2VuLg0KPiArICogQGFkY19jb250aXRpb24JLSBhcnJheSBvZiBzdHJ1Y3QgYWRjX2ph Y2tfY29uZCBjb25kaXRpb25zIGVuZGluZw0KPiArICoJCQl3aXRoIC5zdGF0ZSA9IDAgZW50cnku IFRoaXMgZGVzY3JpYmVzIGhvdyB0byBkZWNvZGUNCj4gKyAqCQkJYWRjIHZhbHVlcyBpbnRvIGV4 dGNvbiBzdGF0ZS4NCj4gKyAqIEBpcnFfZmxhZ3MJLSBpcnEgZmxhZ3MgdXNlZCBmb3IgdGhlIEBp cnENCj4gKyAqIEBoYW5kbGluZ19kZWxheV9tcwktIGluIHNvbWUgZGV2aWNlcywgd2UgbmVlZCB0 byByZWFkIEFEQyB2YWx1ZSBzb21lDQo+ICsgKgkJCW1pbGxpLXNlY29uZHMgYWZ0ZXIgdGhlIGlu dGVycnVwdCBvY2N1cnMuIFlvdSBtYXkNCj4gKyAqCQkJZGVzY3JpYmUgc3VjaCBkZWxheXMgd2l0 aCBAaGFuZGxpbmdfZGVsYXlfbXMsIHdoaWNoDQo+ICsgKgkJCWlzIHJvdW5kZWQtb2ZmIGJ5IGpp ZmZpZXMuDQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFja19wZGF0YSB7DQo+ICsJY29uc3QgY2hh ciAqbmFtZTsNCj4gKwljb25zdCBjaGFyICpjb25zdW1lcl9jaGFubmVsOw0KPiArCS8qDQo+ICsJ ICogTlVMTCBpZiBzdGFuZGFyZCBleHRjb24gbmFtZXMgYXJlIHVzZWQuDQo+ICsJICogVGhlIGxh c3QgZW50cnkgc2hvdWxkIGJlIE5VTEwNCj4gKwkgKi8NCj4gKwljb25zdCBjaGFyICoqY2FibGVf bmFtZXM7DQo+ICsJLyogVGhlIGxhc3QgZW50cnkncyBzdGF0ZSBzaG91bGQgYmUgMCAqLw0KPiAr CXN0cnVjdCBhZGNfamFja19jb25kICphZGNfY29uZGl0aW9uOw0KPiArDQo+ICsJdW5zaWduZWQg bG9uZyBpcnFfZmxhZ3M7DQo+ICsJdW5zaWduZWQgbG9uZyBoYW5kbGluZ19kZWxheV9tczsgLyog aW4gbXMgKi8NCj4gK307DQo+ICsNCj4gKyNlbmRpZiAvKiBfRVhUQ09OX0FEQ19KQUNLX0ggKi8N Cj4gLS0gDQo+IDEuNy4xDQo+IA0KPiANCj4gDQo+IA0KPiAgICAgICAgDQo+ICAgDQo+ICAgICAg ICAgIA0KPiANCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752688Ab2HJEkD (ORCPT ); Fri, 10 Aug 2012 00:40:03 -0400 Received: from mailout4.samsung.com ([203.254.224.34]:35461 "EHLO mailout4.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751177Ab2HJEj7 (ORCPT ); Fri, 10 Aug 2012 00:39:59 -0400 X-AuditID: cbfee60d-b7f526d000004e6b-e1-5024909c86e7 Date: Fri, 10 Aug 2012 04:39:56 +0000 (GMT) From: MyungJoo Ham Subject: Re: [PATCH] [PATCH V4]Extcon: adc_jack: adc-jack driver to support 3.5 pi or simliar devices To: anish kumar , "gregkh@linuxfoundation.org" Cc: =?euc-kr?Q?=C3=D6=C2=F9=BF=EC?= , "lars@metafoo.de" , "jic23@cam.ac.uk" , "linux-kernel@vger.kernel.org" , "linux-iio@vger.kernel.org" , ANISH KUMAR Reply-to: myungjoo.ham@samsung.com MIME-version: 1.0 X-MTR: 20120810043657810@myungjoo.ham Msgkey: 20120810043657810@myungjoo.ham X-EPLocale: ko_KR.euc-kr X-Priority: 3 X-EPWebmail-Msg-Type: personal X-EPWebmail-Reply-Demand: 0 X-EPApproval-Locale: X-EPHeader: ML X-EPTrCode: X-EPTrName: X-MLAttribute: X-RootMTR: 20120810043657810@myungjoo.ham X-ParentMTR: X-ArchiveUser: X-CPGSPASS: N Content-type: text/plain; charset=euc-kr MIME-version: 1.0 Message-id: <26154270.13971344573594322.JavaMail.weblogic@epml26> X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFrrFIsWRmVeSWpSXmKPExsVy+t/t6bpzJqgEGMy+rmFxedccNgdGj8+b 5AIYo7hsUlJzMstSi/TtErgyLn+ZzVrQU1tx5vhDxgbGN5VdjJwcQgLqEouWnGQDsSUETCQu b9jEDGGLSVy4tx4ozgVUM59R4tvhFWBFLAKqEof3rwayOTjYBPQkZn5OBjGFBVIlVt0LAqkQ EciReHV9LwtIK7PAJiaJ1avXsULsUpJYs+8VC4jNKyAocXLmExaIXaoS50+fZ4KIq0m8mHmc ESIuITFr+gVWCJtXYkb7U6h6OYlpX9dA3SktcX7WBkaYmxd/fwwV55c4dnsHE8htIL1P7gfD jNm9+QvUuwISU88cZIQo0ZL4+YQTIswnsWbhWxaYKbtOLWeGab2/ZS7YlcwCihJTuh+yQ9ha El9+7GND9xWvgKPE7sNfmSYwys1CkpqFpH0WknZkNQsYWVYxiqYWJBcUJ6WnGusVJ+YWl+al 6yXn525iBMf4M94djHMbLA4xCnAwKvHwPjBSCRBiTSwrrsw9xCjBwawkwpvyQjlAiDclsbIq tSg/vqg0J7X4EKM0B4uSOO8Xr6/+QgLpiSWp2ampBalFMFkmDk6pBkahKcFfa/fu89yib7K5 Wijh2IuYRIc0ydqF7x8J6mwJbX7y1fJgvuK6UG6r440LWwK/rayrCzr6bzrrzRMCdsWGHdpf LxSun73uv89Rk+Waqbe3PT6hdeGlUtTx1yefnppd0aPEX3Yht3qrd4WsgGJUT/gB8de/b8qy bBWc1GY2k4v5f91nU3clluKMREMt5qLiRABCP1ZW7QIAAA== X-TM-AS-MML: No Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id q7A4e998031293 > From: anish kumar > > External connector devices that decides connection information based on > ADC values may use adc-jack device driver. The user simply needs to > provide a table of adc range and connection states. Then, extcon > framework will automatically notify others. 1. Missing header: #include 2. Missing dependency to IIO. (please add IIO dependency at Kconfig) Cheers! MyungJoo > > Changes in V1: > added Lars-Peter Clausen suggested changes: > Using macros to get rid of boiler plate code such as devm_kzalloc > and module_platform_driver.Other changes suggested are related to > coding guidelines. > > Changes in V2: > Removed some unnecessary checks and changed the way we are un-regitering > extcon and freeing the irq while removing. > > Changes in V3: > Renamed the files to comply with extcon naming. > > Changes in this version: > Added the cancel_work_sync during removing of driver. > > Reviewed-by: Lars-Peter Clausen > Signed-off-by: anish kumar > Signed-off-by: MyungJoo Ham > --- > drivers/extcon/Kconfig | 5 + > drivers/extcon/Makefile | 1 + > drivers/extcon/extcon-adc-jack.c | 194 ++++++++++++++++++++++++++++++++ > include/linux/extcon/extcon-adc-jack.h | 73 ++++++++++++ > 4 files changed, 273 insertions(+), 0 deletions(-) > create mode 100644 drivers/extcon/extcon-adc-jack.c > create mode 100644 include/linux/extcon/extcon-adc-jack.h > > diff --git a/drivers/extcon/Kconfig b/drivers/extcon/Kconfig > index e175c8e..596e277 100644 > --- a/drivers/extcon/Kconfig > +++ b/drivers/extcon/Kconfig > @@ -21,6 +21,11 @@ config EXTCON_GPIO > Say Y here to enable GPIO based extcon support. Note that GPIO > extcon supports single state per extcon instance. > > +config EXTCON_ADC_JACK > + tristate "ADC Jack extcon support" > + help > + Say Y here to enable extcon device driver based on ADC values. > + > config EXTCON_MAX77693 > tristate "MAX77693 EXTCON Support" > depends on MFD_MAX77693 > diff --git a/drivers/extcon/Makefile b/drivers/extcon/Makefile > index 88961b3..bc7111e 100644 > --- a/drivers/extcon/Makefile > +++ b/drivers/extcon/Makefile > @@ -4,6 +4,7 @@ > > obj-$(CONFIG_EXTCON) += extcon_class.o > obj-$(CONFIG_EXTCON_GPIO) += extcon_gpio.o > +obj-$(CONFIG_EXTCON_ADC_JACK) += extcon-adc-jack.o > obj-$(CONFIG_EXTCON_MAX77693) += extcon-max77693.o > obj-$(CONFIG_EXTCON_MAX8997) += extcon-max8997.o > obj-$(CONFIG_EXTCON_ARIZONA) += extcon-arizona.o > diff --git a/drivers/extcon/extcon-adc-jack.c b/drivers/extcon/extcon-adc-jack.c > new file mode 100644 > index 0000000..cfc8c59 > --- /dev/null > +++ b/drivers/extcon/extcon-adc-jack.c > @@ -0,0 +1,194 @@ > +/* > + * drivers/extcon/extcon-adc-jack.c > + * > + * Analog Jack extcon driver with ADC-based detection capability. > + * > + * Copyright (C) 2012 Samsung Electronics > + * MyungJoo Ham > + * > + * Modified for calling to IIO to get adc by > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License version 2 as > + * published by the Free Software Foundation. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/** > + * struct adc_jack_data - internal data for adc_jack device driver > + * @edev - extcon device. > + * @cable_names - list of supported cables. > + * @num_cables - size of cable_names. > + * @adc_condition - list of adc value conditions. > + * @num_condition - size of adc_condition. > + * @irq - irq number of attach/detach event (0 if not exist). > + * @handling_delay - interrupt handler will schedule extcon event > + * handling at handling_delay jiffies. > + * @handler - extcon event handler called by interrupt handler. > + * @chan - iio channel being queried. > + */ > +struct adc_jack_data { > + struct extcon_dev edev; > + > + const char **cable_names; > + int num_cables; > + struct adc_jack_cond *adc_condition; > + int num_conditions; > + > + int irq; > + unsigned long handling_delay; /* in jiffies */ > + struct delayed_work handler; > + > + struct iio_channel *chan; > +}; > + > +static void adc_jack_handler(struct work_struct *work) > +{ > + struct adc_jack_data *data = container_of(to_delayed_work(work), > + struct adc_jack_data, > + handler); > + u32 state = 0; > + int ret, adc_val; > + int i; > + > + ret = iio_read_channel_raw(data->chan, &adc_val); > + if (ret < 0) { > + dev_err(data->edev.dev, "read channel() error: %d\n", ret); > + return; > + } > + > + /* Get state from adc value with adc_condition */ > + for (i = 0; i < data->num_conditions; i++) { > + struct adc_jack_cond *def = &data->adc_condition[i]; > + if (!def->state) > + break; > + if (def->min_adc <= adc_val && def->max_adc >= adc_val) { > + state = def->state; > + break; > + } > + } > + /* if no def has met, it means state = 0 (no cables attached) */ > + > + extcon_set_state(&data->edev, state); > +} > + > +static irqreturn_t adc_jack_irq_thread(int irq, void *_data) > +{ > + struct adc_jack_data *data = _data; > + > + schedule_delayed_work(&data->handler, data->handling_delay); > + return IRQ_HANDLED; > +} > + > +static int __devinit adc_jack_probe(struct platform_device *pdev) > +{ > + struct adc_jack_data *data; > + struct adc_jack_pdata *pdata = pdev->dev.platform_data; > + int i, err = 0; > + > + data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); > + if (!data) > + return -ENOMEM; > + > + data->edev.name = pdata->name; > + > + if (pdata->cable_names) > + data->edev.supported_cable = pdata->cable_names; > + else > + data->edev.supported_cable = extcon_cable_name; > + > + /* Check the length of array and set num_cables */ > + for (i = 0; data->edev.supported_cable[i]; i++) > + ; > + if (i == 0 || i > SUPPORTED_CABLE_MAX) { > + err = -EINVAL; > + dev_err(&pdev->dev, "error: pdata->cable_names size = %d\n", > + i - 1); > + goto out; > + } > + data->num_cables = i; > + > + if (!pdata->adc_condition || > + !pdata->adc_condition[0].state) { > + err = -EINVAL; > + dev_err(&pdev->dev, "error: adc_condition not defined.\n"); > + goto out; > + } > + data->adc_condition = pdata->adc_condition; > + > + /* Check the length of array and set num_conditions */ > + for (i = 0; data->adc_condition[i].state; i++) > + ; > + data->num_conditions = i; > + > + data->chan = iio_channel_get(dev_name(&pdev->dev), > + pdata->consumer_channel); > + if (IS_ERR(data->chan)) { > + err = PTR_ERR(data->chan); > + goto out; > + } > + > + data->handling_delay = msecs_to_jiffies(pdata->handling_delay_ms); > + > + INIT_DELAYED_WORK_DEFERRABLE(&data->handler, adc_jack_handler); > + > + platform_set_drvdata(pdev, data); > + > + err = extcon_dev_register(&data->edev, &pdev->dev); > + if (err) > + goto out; > + > + data->irq = platform_get_irq(pdev, 0); > + if (!data->irq) { > + dev_err(&pdev->dev, "platform_get_irq failed\n"); > + err = -ENODEV; > + goto err_irq; > + } > + > + err = request_any_context_irq(data->irq, adc_jack_irq_thread, > + pdata->irq_flags, pdata->name, data); > + > + if (err) { > + dev_err(&pdev->dev, "error: irq %d\n", data->irq); > + err = -EINVAL; > + goto err_irq; > + } > + > + goto out; > + > +err_irq: > + extcon_dev_unregister(&data->edev); > +out: > + return err; > +} > + > +static int __devexit adc_jack_remove(struct platform_device *pdev) > +{ > + struct adc_jack_data *data = platform_get_drvdata(pdev); > + > + free_irq(data->irq, data); > + cancel_work_sync(&data->handler.work); > + extcon_dev_unregister(&data->edev); > + > + return 0; > +} > + > +static struct platform_driver adc_jack_driver = { > + .probe = adc_jack_probe, > + .remove = __devexit_p(adc_jack_remove), > + .driver = { > + .name = "adc-jack", > + .owner = THIS_MODULE, > + }, > +}; > + > +module_platform_driver(adc_jack_driver); > diff --git a/include/linux/extcon/extcon-adc-jack.h b/include/linux/extcon/extcon-adc-jack.h > new file mode 100644 > index 0000000..c350615 > --- /dev/null > +++ b/include/linux/extcon/extcon-adc-jack.h > @@ -0,0 +1,73 @@ > +/* > + * include/linux/extcon/extcon-adc-jack.h > + * > + * Analog Jack extcon driver with ADC-based detection capability. > + * > + * Copyright (C) 2012 Samsung Electronics > + * MyungJoo Ham > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License version 2 as > + * published by the Free Software Foundation. > + * > + */ > + > +#ifndef _EXTCON_ADC_JACK_H_ > +#define _EXTCON_ADC_JACK_H_ __FILE__ > + > +#include > +#include > + > +/** > + * struct adc_jack_cond - condition to use an extcon state > + * @state - the corresponding extcon state (if 0, this struct denotes > + * the last adc_jack_cond element among the array) > + * @min_adc - min adc value for this condition > + * @max_adc - max adc value for this condition > + * > + * For example, if { .state = 0x3, .min_adc = 100, .max_adc = 200}, it means > + * that if ADC value is between (inclusive) 100 and 200, than the cable 0 and > + * 1 are attached (1<<0 | 1<<1 == 0x3) > + * > + * Note that you don't need to describe condition for "no cable attached" > + * because when no adc_jack_cond is met, state = 0 is automatically chosen. > + */ > +struct adc_jack_cond { > + u32 state; /* extcon state value. 0 if invalid */ > + u32 min_adc; > + u32 max_adc; > +}; > + > +/** > + * struct adc_jack_pdata - platform data for adc jack device. > + * @name - name of the extcon device. If null, "adc-jack" is used. > + * @consumer_channel - Unique name to identify the channel on the consumer > + * side. This typically describes the channels use within > + * the consumer. E.g. 'battery_voltage' > + * @cable_names - array of cable names ending with null. If the array itself > + * if null, extcon standard cable names are chosen. > + * @adc_contition - array of struct adc_jack_cond conditions ending > + * with .state = 0 entry. This describes how to decode > + * adc values into extcon state. > + * @irq_flags - irq flags used for the @irq > + * @handling_delay_ms - in some devices, we need to read ADC value some > + * milli-seconds after the interrupt occurs. You may > + * describe such delays with @handling_delay_ms, which > + * is rounded-off by jiffies. > + */ > +struct adc_jack_pdata { > + const char *name; > + const char *consumer_channel; > + /* > + * NULL if standard extcon names are used. > + * The last entry should be NULL > + */ > + const char **cable_names; > + /* The last entry's state should be 0 */ > + struct adc_jack_cond *adc_condition; > + > + unsigned long irq_flags; > + unsigned long handling_delay_ms; /* in ms */ > +}; > + > +#endif /* _EXTCON_ADC_JACK_H */ > -- > 1.7.1 > > > > > > > > {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I