diff for duplicates of <5370821.92701344319056619.JavaMail.weblogic@epml13> diff --git a/a/1.txt b/N1/1.txt index b999c82..8ba3128 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,203 +1,363 @@ -PiBGcm9tOiBhbmlzaCBrdW1hciA8YW5pc2gxOTg1MTk4NTE5ODVAZ21haWwuY29tPg0KPiANCj4g -RXh0ZXJuYWwgY29ubmVjdG9yIGRldmljZXMgdGhhdCBkZWNpZGVzIGNvbm5lY3Rpb24gaW5mb3Jt -YXRpb24gYmFzZWQgb24NCj4gQURDIHZhbHVlcyBtYXkgdXNlIGFkYy1qYWNrIGRldmljZSBkcml2 -ZXIuIFRoZSB1c2VyIHNpbXBseSBuZWVkcyB0bw0KPiBwcm92aWRlIGEgdGFibGUgb2YgYWRjIHJh -bmdlIGFuZCBjb25uZWN0aW9uIHN0YXRlcy4gVGhlbiwgZXh0Y29uDQo+IGZyYW1ld29yayB3aWxs -IGF1dG9tYXRpY2FsbHkgbm90aWZ5IG90aGVycy4NCj4gDQo+IENoYW5nZXMgaW4gdGhpcyB2ZXJz -aW9uOg0KPiBhZGRlZCBMYXJzLVBldGVyIENsYXVzZW4gc3VnZ2VzdGVkIGNoYW5nZXM6DQo+IFVz -aW5nIG1hY3JvcyB0byBnZXQgcmlkIG9mIGJvaWxlciBwbGF0ZSBjb2RlIHN1Y2ggYXMgZGV2bV9r -emFsbG9jDQo+IGFuZCBtb2R1bGVfcGxhdGZvcm1fZHJpdmVyLk90aGVyIGNoYW5nZXMgc3VnZ2Vz -dGVkIGFyZSByZWxhdGVkIHRvDQo+IGNvZGluZyBndWlkZWxpbmVzLg0KPiANCj4gU2lnbmVkLW9m -Zi1ieTogYW5pc2gga3VtYXIgPGFuaXNoLnNpbmdoQHNhbXN1bmcuY29tPg0KPiBTaWduZWQtb2Zm -LWJ5OiBNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBzYW1zdW5nLmNvbT4NCg0KSGVsbG8sDQoN -Cg0KT25lIGxpdHRsZSB0aGluZyB0aGF0IEkndmUgbWlzc2VkIGJlZm9yZToNCg0KQ291bGQgeW91 -IHBsZWFzZSByZW5hbWUgdGhlIGZpbGU/DQoNClRob3VnaCB0aGUgaW5pdGlhbCBmaWxlcyAoY2xh -c3MgYW5kIGdwaW8pIGRpZG4ndCBkbyBpdCwNCmxpa2Ugb3RoZXIgcmVjZW50IG9uZXMsIGxldCdz -IHVzZSAnLScgaW5zdGVhZCBvZiAnXycuDQpCZXNpZGVzLCBjb3VsZCB5b3UgcGxlYXNlIHVzZSAi -ZXh0Y29uIiBwcmVmaXggZm9yIHRoZSBmaWxlbmFtZT8NCg0KVGh1cywgImFkY19qYWNrLmMvaCIg -LS0+ICJleHRjb24tYWRjLWphY2suYy9oIg0KDQoNCkNoZWVycw0KTXl1bmdKb28NCg0KPiAtLS0N -Cj4gIGRyaXZlcnMvZXh0Y29uL0tjb25maWcgICAgICAgICAgfCAgICA1ICsNCj4gIGRyaXZlcnMv -ZXh0Y29uL01ha2VmaWxlICAgICAgICAgfCAgICAxICsNCj4gIGRyaXZlcnMvZXh0Y29uL2FkY19q -YWNrLmMgICAgICAgfCAgMTkzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr -Kw0KPiAgaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaCB8ICAgNzcgKysrKysrKysrKysr -KysrKw0KPiAgNCBmaWxlcyBjaGFuZ2VkLCAyNzYgaW5zZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMo -LSkNCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2V4dGNvbi9hZGNfamFjay5jDQo+ICBj -cmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaA0KPiANCj4g -ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZXh0Y29uL0tjb25maWcgYi9kcml2ZXJzL2V4dGNvbi9LY29u -ZmlnDQo+IGluZGV4IGUxNzVjOGUuLjU5NmUyNzcgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvZXh0 -Y29uL0tjb25maWcNCj4gKysrIGIvZHJpdmVycy9leHRjb24vS2NvbmZpZw0KPiBAQCAtMjEsNiAr -MjEsMTEgQEAgY29uZmlnIEVYVENPTl9HUElPDQo+ICAJICBTYXkgWSBoZXJlIHRvIGVuYWJsZSBH -UElPIGJhc2VkIGV4dGNvbiBzdXBwb3J0LiBOb3RlIHRoYXQgR1BJTw0KPiAgCSAgZXh0Y29uIHN1 -cHBvcnRzIHNpbmdsZSBzdGF0ZSBwZXIgZXh0Y29uIGluc3RhbmNlLg0KPiAgDQo+ICtjb25maWcg -RVhUQ09OX0FEQ19KQUNLDQo+ICsgICAgICAgIHRyaXN0YXRlICJBREMgSmFjayBleHRjb24gc3Vw -cG9ydCINCj4gKyAgICAgICAgaGVscA0KPiArICAgICAgICAgIFNheSBZIGhlcmUgdG8gZW5hYmxl -IGV4dGNvbiBkZXZpY2UgZHJpdmVyIGJhc2VkIG9uIEFEQyB2YWx1ZXMuDQo+ICsNCj4gIGNvbmZp -ZyBFWFRDT05fTUFYNzc2OTMNCj4gIAl0cmlzdGF0ZSAiTUFYNzc2OTMgRVhUQ09OIFN1cHBvcnQi -DQo+ICAJZGVwZW5kcyBvbiBNRkRfTUFYNzc2OTMNCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZXh0 -Y29uL01ha2VmaWxlIGIvZHJpdmVycy9leHRjb24vTWFrZWZpbGUNCj4gaW5kZXggODg5NjFiMy4u -ZDk1YzVlYSAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9leHRjb24vTWFrZWZpbGUNCj4gKysrIGIv -ZHJpdmVycy9leHRjb24vTWFrZWZpbGUNCj4gQEAgLTQsNiArNCw3IEBADQo+ICANCj4gIG9iai0k -KENPTkZJR19FWFRDT04pCQkrPSBleHRjb25fY2xhc3Mubw0KPiAgb2JqLSQoQ09ORklHX0VYVENP -Tl9HUElPKQkrPSBleHRjb25fZ3Bpby5vDQo+ICtvYmotJChDT05GSUdfRVhUQ09OX0FEQ19KQUNL -KSAgICs9IGFkY19qYWNrLm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fTUFYNzc2OTMpCSs9IGV4 -dGNvbi1tYXg3NzY5My5vDQo+ICBvYmotJChDT05GSUdfRVhUQ09OX01BWDg5OTcpCSs9IGV4dGNv -bi1tYXg4OTk3Lm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fQVJJWk9OQSkJKz0gZXh0Y29uLWFy -aXpvbmEubw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9leHRjb24vYWRjX2phY2suYyBiL2RyaXZl -cnMvZXh0Y29uL2FkY19qYWNrLmMNCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gaW5kZXggMDAw -MDAwMC4uOGI4MGFmMA0KPiAtLS0gL2Rldi9udWxsDQo+ICsrKyBiL2RyaXZlcnMvZXh0Y29uL2Fk -Y19qYWNrLmMNCj4gQEAgLTAsMCArMSwxOTMgQEANCj4gKy8qDQo+ICsgKiBkcml2ZXJzL2V4dGNv -bi9hZGNfamFjay5jDQo+ICsgKg0KPiArICogQW5hbG9nIEphY2sgZXh0Y29uIGRyaXZlciB3aXRo -IEFEQy1iYXNlZCBkZXRlY3Rpb24gY2FwYWJpbGl0eS4NCj4gKyAqDQo+ICsgKiBDb3B5cmlnaHQg -KEMpIDIwMTIgU2Ftc3VuZyBFbGVjdHJvbmljcw0KPiArICogTXl1bmdKb28gSGFtIDxteXVuZ2pv -by5oYW1Ac2Ftc3VuZy5jb20+DQo+ICsgKg0KPiArICogTW9kaWZpZWQgZm9yIGNhbGxpbmcgdG8g -SUlPIHRvIGdldCBhZGMgYnkgPGFuaXNoLnNpbmdoQHNhbXN1bmcuY29tPg0KPiArICoNCj4gKyAq -IFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh -bmQvb3IgbW9kaWZ5DQo+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFs -IFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcw0KPiArICogcHVibGlzaGVkIGJ5IHRoZSBGcmVl -IFNvZnR3YXJlIEZvdW5kYXRpb24uDQo+ICsgKg0KPiArICovDQo+ICsNCj4gKyNpbmNsdWRlIDxs -aW51eC9zbGFiLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+DQo+ICsjaW5jbHVkZSA8 -bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+ -DQo+ICsjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaWlv -L2NvbnN1bWVyLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvZXh0Y29uL2FkY19qYWNrLmg+DQo+ICsj -aW5jbHVkZSA8bGludXgvZXh0Y29uLmg+DQo+ICsNCj4gKy8qKg0KPiArICogc3RydWN0IGFkY19q -YWNrX2RhdGEgLSBpbnRlcm5hbCBkYXRhIGZvciBhZGNfamFjayBkZXZpY2UgZHJpdmVyDQo+ICsg -KiBAZWRldiAgICAgICAgLSBleHRjb24gZGV2aWNlLg0KPiArICogQGNhYmxlX25hbWVzIC0gbGlz -dCBvZiBzdXBwb3J0ZWQgY2FibGVzLg0KPiArICogQG51bV9jYWJsZXMgIC0gc2l6ZSBvZiBjYWJs -ZV9uYW1lcy4NCj4gKyAqIEBhZGNfY29uZGl0aW9uICAgICAgIC0gbGlzdCBvZiBhZGMgdmFsdWUg -Y29uZGl0aW9ucy4NCj4gKyAqIEBudW1fY29uZGl0aW9uICAgICAgIC0gc2l6ZSBvZiBhZGNfY29u -ZGl0aW9uLg0KPiArICogQGlycSAgICAgICAgIC0gaXJxIG51bWJlciBvZiBhdHRhY2gvZGV0YWNo -IGV2ZW50ICgwIGlmIG5vdCBleGlzdCkuDQo+ICsgKiBAaGFuZGxpbmdfZGVsYXkgICAgICAtIGlu -dGVycnVwdCBoYW5kbGVyIHdpbGwgc2NoZWR1bGUgZXh0Y29uIGV2ZW50DQo+ICsgKiAgICAgICAg -ICAgICAgICAgICAgICBoYW5kbGluZyBhdCBoYW5kbGluZ19kZWxheSBqaWZmaWVzLg0KPiArICog -QGhhbmRsZXIgICAgIC0gZXh0Y29uIGV2ZW50IGhhbmRsZXIgY2FsbGVkIGJ5IGludGVycnVwdCBo -YW5kbGVyLg0KPiArICogQGdldF9hZGMgICAgIC0gYSBjYWxsYmFjayB0byBnZXQgQURDIHZhbHVl -IHRvIGlkZW50aWZ5IHN0YXRlLg0KPiArICovDQo+ICtzdHJ1Y3QgYWRjX2phY2tfZGF0YSB7DQo+ -ICsJc3RydWN0IGV4dGNvbl9kZXYgZWRldjsNCj4gKw0KPiArCWNvbnN0IGNoYXIgKipjYWJsZV9u -YW1lczsNCj4gKwlpbnQgbnVtX2NhYmxlczsNCj4gKwlzdHJ1Y3QgYWRjX2phY2tfY29uZCAqYWRj -X2NvbmRpdGlvbjsNCj4gKwlpbnQgbnVtX2NvbmRpdGlvbnM7DQo+ICsNCj4gKwlpbnQgaXJxOw0K -PiArCXVuc2lnbmVkIGxvbmcgaGFuZGxpbmdfZGVsYXk7IC8qIGluIGppZmZpZXMgKi8NCj4gKwlz -dHJ1Y3QgZGVsYXllZF93b3JrIGhhbmRsZXI7DQo+ICsNCj4gKwlzdHJ1Y3QgaWlvX2NoYW5uZWwg -KmNoYW47DQo+ICt9Ow0KPiArDQo+ICtzdGF0aWMgdm9pZCBhZGNfamFja19oYW5kbGVyKHN0cnVj -dCB3b3JrX3N0cnVjdCAqd29yaykNCj4gK3sNCj4gKwlzdHJ1Y3QgYWRjX2phY2tfZGF0YSAqZGF0 -YSA9IGNvbnRhaW5lcl9vZih0b19kZWxheWVkX3dvcmsod29yayksDQo+ICsJCQkJCQkgIHN0cnVj -dCBhZGNfamFja19kYXRhLA0KPiArCQkJCQkJICBoYW5kbGVyKTsNCj4gKwl1MzIgc3RhdGUgPSAw -Ow0KPiArCWludCByZXQsIGFkY192YWw7DQo+ICsJaW50IGk7DQo+ICsNCj4gKwlyZXQgPSBpaW9f -cmVhZF9jaGFubmVsX3JhdyhkYXRhLT5jaGFuLCAmYWRjX3ZhbCk7DQo+ICsJaWYgKHJldCA8IDAp -IHsNCj4gKwkJZGV2X2VycihkYXRhLT5lZGV2LmRldiwgInJlYWQgY2hhbm5lbCgpIGVycm9yOiAl -ZFxuIiwgcmV0KTsNCj4gKwkJcmV0dXJuOw0KPiArCX0NCj4gKw0KPiArCS8qIEdldCBzdGF0ZSBm -cm9tIGFkYyB2YWx1ZSB3aXRoIGFkY19jb25kaXRpb24gKi8NCj4gKwlmb3IgKGkgPSAwOyBpIDwg -ZGF0YS0+bnVtX2NvbmRpdGlvbnM7IGkrKykgew0KPiArCQlzdHJ1Y3QgYWRjX2phY2tfY29uZCAq -ZGVmID0gJmRhdGEtPmFkY19jb25kaXRpb25baV07DQo+ICsJCWlmICghZGVmLT5zdGF0ZSkNCj4g -KwkJCWJyZWFrOw0KPiArCQlpZiAoZGVmLT5taW5fYWRjIDw9IGFkY192YWwgJiYgZGVmLT5tYXhf -YWRjID49IGFkY192YWwpIHsNCj4gKwkJCXN0YXRlID0gZGVmLT5zdGF0ZTsNCj4gKwkJCWJyZWFr -Ow0KPiArCQl9DQo+ICsJfQ0KPiArCS8qIGlmIG5vIGRlZiBoYXMgbWV0LCBpdCBtZWFucyBzdGF0 -ZSA9IDAgKG5vIGNhYmxlcyBhdHRhY2hlZCkgKi8NCj4gKw0KPiArCWV4dGNvbl9zZXRfc3RhdGUo -JmRhdGEtPmVkZXYsIHN0YXRlKTsNCj4gK30NCj4gKw0KPiArc3RhdGljIGlycXJldHVybl90IGFk -Y19qYWNrX2lycV90aHJlYWQoaW50IGlycSwgdm9pZCAqX2RhdGEpDQo+ICt7DQo+ICsJc3RydWN0 -IGFkY19qYWNrX2RhdGEgKmRhdGEgPSBfZGF0YTsNCj4gKw0KPiArCXNjaGVkdWxlX2RlbGF5ZWRf -d29yaygmZGF0YS0+aGFuZGxlciwgZGF0YS0+aGFuZGxpbmdfZGVsYXkpOw0KPiArCXJldHVybiBJ -UlFfSEFORExFRDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBhZGNfamFja19wcm9iZShzdHJ1 -Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRh -ICpkYXRhOw0KPiArCXN0cnVjdCBhZGNfamFja19wZGF0YSAqcGRhdGEgPSBwZGV2LT5kZXYucGxh -dGZvcm1fZGF0YTsNCj4gKwlpbnQgaSwgZXJyID0gMDsNCj4gKw0KPiArCWRhdGEgPSBkZXZtX2t6 -YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpkYXRhKSwgR0ZQX0tFUk5FTCk7DQo+ICsJaWYgKCFk -YXRhKQ0KPiArCQlyZXR1cm4gLUVOT01FTTsNCj4gKw0KPiArCWRhdGEtPmVkZXYubmFtZSA9IHBk -YXRhLT5uYW1lOw0KPiArDQo+ICsJaWYgKHBkYXRhLT5jYWJsZV9uYW1lcykNCj4gKwkJZGF0YS0+ -ZWRldi5zdXBwb3J0ZWRfY2FibGUgPSBwZGF0YS0+Y2FibGVfbmFtZXM7DQo+ICsJZWxzZQ0KPiAr -CQlkYXRhLT5lZGV2LnN1cHBvcnRlZF9jYWJsZSA9IGV4dGNvbl9jYWJsZV9uYW1lOw0KPiArDQo+ -ICsJLyogQ2hlY2sgdGhlIGxlbmd0aCBvZiBhcnJheSBhbmQgc2V0IG51bV9jYWJsZXMgKi8NCj4g -Kwlmb3IgKGkgPSAwOyBkYXRhLT5lZGV2LnN1cHBvcnRlZF9jYWJsZVtpXTsgaSsrKQ0KPiArCQk7 -DQo+ICsJaWYgKGkgPT0gMCB8fCBpID4gU1VQUE9SVEVEX0NBQkxFX01BWCkgew0KPiArCQllcnIg -PSAtRUlOVkFMOw0KPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJlcnJvcjogcGRhdGEtPmNhYmxl -X25hbWVzIHNpemUgPSAlZFxuIiwNCj4gKwkJCWkgLSAxKTsNCj4gKwkJZ290byBlcnJfYWxsb2M7 -DQo+ICsJfQ0KPiArCWRhdGEtPm51bV9jYWJsZXMgPSBpOw0KPiArDQo+ICsJaWYgKCFwZGF0YS0+ -YWRjX2NvbmRpdGlvbiB8fA0KPiArCSAgICAhcGRhdGEtPmFkY19jb25kaXRpb25bMF0uc3RhdGUp -IHsNCj4gKwkJZXJyID0gLUVJTlZBTDsNCj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZXJyb3I6 -IGFkY19jb25kaXRpb24gbm90IGRlZmluZWQuXG4iKTsNCj4gKwkJZ290byBlcnJfYWxsb2M7DQo+ -ICsJfQ0KPiArCWRhdGEtPmFkY19jb25kaXRpb24gPSBwZGF0YS0+YWRjX2NvbmRpdGlvbjsNCj4g -Kw0KPiArCS8qIENoZWNrIHRoZSBsZW5ndGggb2YgYXJyYXkgYW5kIHNldCBudW1fY29uZGl0aW9u -cyAqLw0KPiArCWZvciAoaSA9IDA7IGRhdGEtPmFkY19jb25kaXRpb25baV0uc3RhdGU7IGkrKykN -Cj4gKwkJOw0KPiArCWRhdGEtPm51bV9jb25kaXRpb25zID0gaTsNCj4gKw0KPiArCWRhdGEtPmNo -YW4gPSBpaW9fY2hhbm5lbF9nZXQoZGV2X25hbWUoJnBkZXYtPmRldiksDQo+ICsJCQkJCQlwZGF0 -YS0+Y29uc3VtZXJfY2hhbm5lbCk7DQo+ICsJaWYgKElTX0VSUihkYXRhLT5jaGFuKSkgew0KPiAr -CQllcnIgPSBQVFJfRVJSKGRhdGEtPmNoYW4pOw0KPiArCQlnb3RvIGVycl9hbGxvYzsNCj4gKwl9 -DQo+ICsNCj4gKwlkYXRhLT5oYW5kbGluZ19kZWxheSA9IG1zZWNzX3RvX2ppZmZpZXMocGRhdGEt -PmhhbmRsaW5nX2RlbGF5X21zKTsNCj4gKw0KPiArCUlOSVRfREVMQVlFRF9XT1JLX0RFRkVSUkFC -TEUoJmRhdGEtPmhhbmRsZXIsIGFkY19qYWNrX2hhbmRsZXIpOw0KPiArDQo+ICsJcGxhdGZvcm1f -c2V0X2RydmRhdGEocGRldiwgZGF0YSk7DQo+ICsNCj4gKwllcnIgPSBleHRjb25fZGV2X3JlZ2lz -dGVyKCZkYXRhLT5lZGV2LCAmcGRldi0+ZGV2KTsNCj4gKwlpZiAoZXJyKQ0KPiArCQlnb3RvIGVy -cl9pbml0d29yazsNCj4gKw0KPiArCWRhdGEtPmlycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwg -MCk7DQo+ICsNCj4gKwllcnIgPSByZXF1ZXN0X2FueV9jb250ZXh0X2lycShkYXRhLT5pcnEsIGFk -Y19qYWNrX2lycV90aHJlYWQsDQo+ICsJCQkJcGRhdGEtPmlycV9mbGFncywgcGRhdGEtPm5hbWUs -IGRhdGEpOw0KPiArDQo+ICsJaWYgKGVycikgew0KPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJl -cnJvcjogaXJxICVkXG4iLCBkYXRhLT5pcnEpOw0KPiArCQllcnIgPSAtRUlOVkFMOw0KPiArCQln -b3RvIGVycl9pcnE7DQo+ICsJfQ0KPiArDQo+ICsJZ290byBvdXQ7DQo+ICsNCj4gK2Vycl9pcnE6 -DQo+ICsJZXh0Y29uX2Rldl91bnJlZ2lzdGVyKCZkYXRhLT5lZGV2KTsNCj4gK2Vycl9pbml0d29y -azoNCj4gKwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmRhdGEtPmhhbmRsZXIpOw0KPiArZXJy -X2FsbG9jOg0KPiArCWtmcmVlKGRhdGEpOw0KPiArb3V0Og0KPiArCXJldHVybiBlcnI7DQo+ICt9 -DQo+ICsNCj4gK3N0YXRpYyBpbnQgX19kZXZleGl0IGFkY19qYWNrX3JlbW92ZShzdHJ1Y3QgcGxh -dGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRhICpkYXRh -ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7DQo+ICsNCj4gKwlleHRjb25fZGV2X3VucmVn -aXN0ZXIoJmRhdGEtPmVkZXYpOw0KPiArCWlmIChkYXRhLT5pcnEpDQo+ICsJCWZyZWVfaXJxKGRh -dGEtPmlycSwgZGF0YSk7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGlj -IHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYWRjX2phY2tfZHJpdmVyID0gew0KPiArCS5wcm9iZQkJ -PSBhZGNfamFja19wcm9iZSwNCj4gKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKGFkY19qYWNrX3Jl -bW92ZSksDQo+ICsJLmRyaXZlcgkJPSB7DQo+ICsJCS5uYW1lCT0gImFkYy1qYWNrIiwNCj4gKwkJ -Lm93bmVyCT0gVEhJU19NT0RVTEUsDQo+ICsJfSwNCj4gK307DQo+ICsNCj4gK21vZHVsZV9wbGF0 -Zm9ybV9kcml2ZXIoYWRjX2phY2tfZHJpdmVyKTsNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu -dXgvZXh0Y29uL2FkY19qYWNrLmggYi9pbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5oDQo+ -IG5ldyBmaWxlIG1vZGUgMTAwNjQ0DQo+IGluZGV4IDAwMDAwMDAuLmNhNGQxY2QNCj4gLS0tIC9k -ZXYvbnVsbA0KPiArKysgYi9pbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5oDQo+IEBAIC0w -LDAgKzEsNzcgQEANCj4gKy8qDQo+ICsgKiBpbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5o -DQo+ICsgKg0KPiArICogQW5hbG9nIEphY2sgZXh0Y29uIGRyaXZlciB3aXRoIEFEQy1iYXNlZCBk -ZXRlY3Rpb24gY2FwYWJpbGl0eS4NCj4gKyAqDQo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTIgU2Ft -c3VuZyBFbGVjdHJvbmljcw0KPiArICogTXl1bmdKb28gSGFtIDxteXVuZ2pvby5oYW1Ac2Ftc3Vu -Zy5jb20+DQo+ICsgKg0KPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj -YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkNCj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJt -cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzDQo+ICsgKiBw -dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCj4gKyAqDQo+ICsgKi8N -Cj4gKw0KPiArI2lmbmRlZiBfRVhUQ09OX0FEQ19KQUNLX0hfDQo+ICsjZGVmaW5lIF9FWFRDT05f -QURDX0pBQ0tfSF8gX19GSUxFX18NCj4gKw0KPiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPg0K -PiArI2luY2x1ZGUgPGxpbnV4L2V4dGNvbi5oPg0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVjdCBh -ZGNfamFja19jb25kIC0gY29uZGl0aW9uIHRvIHVzZSBhbiBleHRjb24gc3RhdGUNCj4gKyAqIEBz -dGF0ZQktIHRoZSBjb3JyZXNwb25kaW5nIGV4dGNvbiBzdGF0ZSAoaWYgMCwgdGhpcyBzdHJ1Y3Qg -ZGVub3Rlcw0KPiArICoJCXRoZSBsYXN0IGFkY19qYWNrX2NvbmQgZWxlbWVudCBhbW9uZyB0aGUg -YXJyYXkpDQo+ICsgKiBAbWluX2FkYwktIG1pbiBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9u -DQo+ICsgKiBAbWF4X2FkYwktIG1heCBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9uDQo+ICsg -Kg0KPiArICogRm9yIGV4YW1wbGUsIGlmIHsgLnN0YXRlID0gMHgzLCAubWluX2FkYyA9IDEwMCwg -Lm1heF9hZGMgPSAyMDB9LCBpdCBtZWFucw0KPiArICogdGhhdCBpZiBBREMgdmFsdWUgaXMgYmV0 -d2VlbiAoaW5jbHVzaXZlKSAxMDAgYW5kIDIwMCwgdGhhbiB0aGUgY2FibGUgMCBhbmQNCj4gKyAq -IDEgYXJlIGF0dGFjaGVkICgxPDwwIHwgMTw8MSA9PSAweDMpDQo+ICsgKg0KPiArICogTm90ZSB0 -aGF0IHlvdSBkb24ndCBuZWVkIHRvIGRlc2NyaWJlIGNvbmRpdGlvbiBmb3IgIm5vIGNhYmxlIGF0 -dGFjaGVkIg0KPiArICogYmVjYXVzZSB3aGVuIG5vIGFkY19qYWNrX2NvbmQgaXMgbWV0LCBzdGF0 -ZSA9IDAgaXMgYXV0b21hdGljYWxseSBjaG9zZW4uDQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFj -a19jb25kIHsNCj4gKwl1MzIgc3RhdGU7IC8qIGV4dGNvbiBzdGF0ZSB2YWx1ZS4gMCBpZiBpbnZh -bGlkICovDQo+ICsJdTMyIG1pbl9hZGM7DQo+ICsJdTMyIG1heF9hZGM7DQo+ICt9Ow0KPiArDQo+ -ICsvKioNCj4gKyAqIHN0cnVjdCBhZGNfamFja19wZGF0YSAtIHBsYXRmb3JtIGRhdGEgZm9yIGFk -YyBqYWNrIGRldmljZS4NCj4gKyAqIEBuYW1lCS0gbmFtZSBvZiB0aGUgZXh0Y29uIGRldmljZS4g -SWYgbnVsbCwgImFkYy1qYWNrIiBpcyB1c2VkLg0KPiArICogQGNhYmxlX25hbWVzCS0gYXJyYXkg -b2YgY2FibGUgbmFtZXMgZW5kaW5nIHdpdGggbnVsbC4gSWYgdGhlIGFycmF5IGl0c2VsZg0KPiAr -ICoJCWlmIG51bGwsIGV4dGNvbiBzdGFuZGFyZCBjYWJsZSBuYW1lcyBhcmUgY2hvc2VuLg0KPiAr -ICogQGFkY19jb250aXRpb24JLSBhcnJheSBvZiBzdHJ1Y3QgYWRjX2phY2tfY29uZCBjb25kaXRp -b25zIGVuZGluZw0KPiArICoJCQl3aXRoIC5zdGF0ZSA9IDAgZW50cnkuIFRoaXMgZGVzY3JpYmVz -IGhvdyB0byBkZWNvZGUNCj4gKyAqCQkJYWRjIHZhbHVlcyBpbnRvIGV4dGNvbiBzdGF0ZS4NCj4g -KyAqIEBpcnEJCS0gSVJRIG51bWJlciB0aGF0IGlzIHRyaWdnZXJyZWQgYnkgY2FibGUgYXR0YWNo -L2RldGFjaA0KPiArICoJCWV2ZW50cy4gSWYgaXJxID0gMCwgdXNlIHNob3VsZCBtYW51YWxseSB1 -cGRhdGUgZXh0Y29uIHN0YXRlDQo+ICsgKgkJd2l0aCBleHRjb24gQVBJcy4NCj4gKyAqIEBpcnFf -ZmxhZ3MJLSBpcnEgZmxhZ3MgdXNlZCBmb3IgdGhlIEBpcnENCj4gKyAqIEBoYW5kbGluZ19kZWxh -eV9tcwktIGluIHNvbWUgZGV2aWNlcywgd2UgbmVlZCB0byByZWFkIEFEQyB2YWx1ZSBzb21lDQo+ -ICsgKgkJCW1pbGxpLXNlY29uZHMgYWZ0ZXIgdGhlIGludGVycnVwdCBvY2N1cnMuIFlvdSBtYXkN -Cj4gKyAqCQkJZGVzY3JpYmUgc3VjaCBkZWxheXMgd2l0aCBAaGFuZGxpbmdfZGVsYXlfbXMsIHdo -aWNoDQo+ICsgKgkJCWlzIHJvdW5kZWQtb2ZmIGJ5IGppZmZpZXMuDQo+ICsgKiBAZ2V0X2FkYwkt -IHRoZSBjYWxsYmFjayB0byByZWFkIEFEQyB2YWx1ZSB0byBpZGVudGlmeSBjYWJsZSBzdGF0ZXMu -DQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFja19wZGF0YSB7DQo+ICsJY29uc3QgY2hhciAqbmFt -ZTsNCj4gKwljb25zdCBjaGFyICpjb25zdW1lcl9jaGFubmVsOw0KPiArCS8qDQo+ICsJICogTlVM -TCBpZiBzdGFuZGFyZCBleHRjb24gbmFtZXMgYXJlIHVzZWQuDQo+ICsJICogVGhlIGxhc3QgZW50 -cnkgc2hvdWxkIGJlIE5VTEwNCj4gKwkgKi8NCj4gKwljb25zdCBjaGFyICoqY2FibGVfbmFtZXM7 -DQo+ICsJLyogVGhlIGxhc3QgZW50cnkncyBzdGF0ZSBzaG91bGQgYmUgMCAqLw0KPiArCXN0cnVj -dCBhZGNfamFja19jb25kICphZGNfY29uZGl0aW9uOw0KPiArDQo+ICsJdW5zaWduZWQgbG9uZyBp -cnFfZmxhZ3M7DQo+ICsJdW5zaWduZWQgbG9uZyBoYW5kbGluZ19kZWxheV9tczsgLyogaW4gbXMg -Ki8NCj4gKw0KPiArCS8qIFdoZW4gd2UgaGF2ZSBBREMgc3Vic3lzdGVtLCB0aGlzIGNhbiBiZSBn -ZW5lcmFsaXplZC4gKi8NCj4gKwlpbnQgKCpnZXRfYWRjKSh1MzIgKnZhbHVlKTsNCj4gK307DQo+ -ICsNCj4gKyNlbmRpZiAvKiBfRVhUQ09OX0FEQ19KQUNLX0ggKi8NCj4gLS0gDQo+IDEuNy4xDQo+ -IA0KPiANCj4gDQo+IA0KPiAgICAgICAgDQo+ICAgDQo+ICAgICAgICAgIA0KPiANCg== +> From: anish kumar <anish198519851985@gmail.com> +> +> 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. +> +> Changes in this version: +> 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. +> +> Signed-off-by: anish kumar <anish.singh@samsung.com> +> Signed-off-by: MyungJoo Ham <myungjoo.ham@samsung.com> + +Hello, + + +One little thing that I've missed before: + +Could you please rename the file? + +Though the initial files (class and gpio) didn't do it, +like other recent ones, let's use '-' instead of '_'. +Besides, could you please use "extcon" prefix for the filename? + +Thus, "adc_jack.c/h" --> "extcon-adc-jack.c/h" + + +Cheers +MyungJoo + +> --- +> drivers/extcon/Kconfig | 5 + +> drivers/extcon/Makefile | 1 + +> drivers/extcon/adc_jack.c | 193 +++++++++++++++++++++++++++++++++++++++ +> include/linux/extcon/adc_jack.h | 77 ++++++++++++++++ +> 4 files changed, 276 insertions(+), 0 deletions(-) +> create mode 100644 drivers/extcon/adc_jack.c +> create mode 100644 include/linux/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..d95c5ea 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) += 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/adc_jack.c b/drivers/extcon/adc_jack.c +> new file mode 100644 +> index 0000000..8b80af0 +> --- /dev/null +> +++ b/drivers/extcon/adc_jack.c +> @@ -0,0 +1,193 @@ +> +/* +> + * drivers/extcon/adc_jack.c +> + * +> + * Analog Jack extcon driver with ADC-based detection capability. +> + * +> + * Copyright (C) 2012 Samsung Electronics +> + * MyungJoo Ham <myungjoo.ham@samsung.com> +> + * +> + * Modified for calling to IIO to get adc by <anish.singh@samsung.com> +> + * +> + * 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 <linux/slab.h> +> +#include <linux/device.h> +> +#include <linux/platform_device.h> +> +#include <linux/interrupt.h> +> +#include <linux/workqueue.h> +> +#include <linux/iio/consumer.h> +> +#include <linux/extcon/adc_jack.h> +> +#include <linux/extcon.h> +> + +> +/** +> + * 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. +> + * @get_adc - a callback to get ADC value to identify state. +> + */ +> +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 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 err_alloc; +> + } +> + 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 err_alloc; +> + } +> + 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 err_alloc; +> + } +> + +> + 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 err_initwork; +> + +> + data->irq = platform_get_irq(pdev, 0); +> + +> + 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); +> +err_initwork: +> + cancel_delayed_work_sync(&data->handler); +> +err_alloc: +> + kfree(data); +> +out: +> + return err; +> +} +> + +> +static int __devexit adc_jack_remove(struct platform_device *pdev) +> +{ +> + struct adc_jack_data *data = platform_get_drvdata(pdev); +> + +> + extcon_dev_unregister(&data->edev); +> + if (data->irq) +> + free_irq(data->irq, data); +> + +> + 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/adc_jack.h b/include/linux/extcon/adc_jack.h +> new file mode 100644 +> index 0000000..ca4d1cd +> --- /dev/null +> +++ b/include/linux/extcon/adc_jack.h +> @@ -0,0 +1,77 @@ +> +/* +> + * include/linux/extcon/adc_jack.h +> + * +> + * Analog Jack extcon driver with ADC-based detection capability. +> + * +> + * Copyright (C) 2012 Samsung Electronics +> + * MyungJoo Ham <myungjoo.ham@samsung.com> +> + * +> + * 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 <linux/module.h> +> +#include <linux/extcon.h> +> + +> +/** +> + * 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. +> + * @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 - IRQ number that is triggerred by cable attach/detach +> + * events. If irq = 0, use should manually update extcon state +> + * with extcon APIs. +> + * @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. +> + * @get_adc - the callback to read ADC value to identify cable states. +> + */ +> +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 */ +> + +> + /* When we have ADC subsystem, this can be generalized. */ +> + int (*get_adc)(u32 *value); +> +}; +> + +> +#endif /* _EXTCON_ADC_JACK_H */ +> -- +> 1.7.1 +> +> +> +> +> +> +> +> +ÿôèº{.nÇ+‰·Ÿ®‰†+%ŠËÿ±éݶ\x17¥Šwÿº{.nÇ+‰·¥Š{±þG«éÿŠ{ayº\x1dʇڙë,j\a¢f£¢·hšïêÿ‘êçz_è®\x03(階ŠÝ¢j"ú\x1a¶^[m§ÿÿ¾\a«þG«éÿ¢¸?™¨èÚ&£ø§~á¶iO•æ¬z·švØ^\x14\x04\x1a¶^[m§ÿÿÃ\fÿ¶ìÿ¢¸?–I¥ diff --git a/a/content_digest b/N1/content_digest index 1ea04c9..43e1002 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -1,6 +1,6 @@ "From\0MyungJoo Ham <myungjoo.ham@samsung.com>\0" "Subject\0Re: Re: [PATCH V1]Extcon: adc_jack: adc-jack driver to support 3.5 pi or simliar devices\0" - "Date\0Tue, 07 Aug 2012 05:57:37 +0000 (GMT)\0" + "Date\0Tue, 07 Aug 2012 05:57:38 +0000 (GMT)\0" "To\0anish kumar <anish198519851985@gmail.com>" " Lars-Peter Clausen <lars@metafoo.de>\0" "Cc\0jic23@cam.ac.uk <jic23@cam.ac.uk>" @@ -10,208 +10,368 @@ " \354\265\234\354\260\254\354\232\260 <cw00.choi@samsung.com>\0" "\00:1\0" "b\0" - "PiBGcm9tOiBhbmlzaCBrdW1hciA8YW5pc2gxOTg1MTk4NTE5ODVAZ21haWwuY29tPg0KPiANCj4g\n" - "RXh0ZXJuYWwgY29ubmVjdG9yIGRldmljZXMgdGhhdCBkZWNpZGVzIGNvbm5lY3Rpb24gaW5mb3Jt\n" - "YXRpb24gYmFzZWQgb24NCj4gQURDIHZhbHVlcyBtYXkgdXNlIGFkYy1qYWNrIGRldmljZSBkcml2\n" - "ZXIuIFRoZSB1c2VyIHNpbXBseSBuZWVkcyB0bw0KPiBwcm92aWRlIGEgdGFibGUgb2YgYWRjIHJh\n" - "bmdlIGFuZCBjb25uZWN0aW9uIHN0YXRlcy4gVGhlbiwgZXh0Y29uDQo+IGZyYW1ld29yayB3aWxs\n" - "IGF1dG9tYXRpY2FsbHkgbm90aWZ5IG90aGVycy4NCj4gDQo+IENoYW5nZXMgaW4gdGhpcyB2ZXJz\n" - "aW9uOg0KPiBhZGRlZCBMYXJzLVBldGVyIENsYXVzZW4gc3VnZ2VzdGVkIGNoYW5nZXM6DQo+IFVz\n" - "aW5nIG1hY3JvcyB0byBnZXQgcmlkIG9mIGJvaWxlciBwbGF0ZSBjb2RlIHN1Y2ggYXMgZGV2bV9r\n" - "emFsbG9jDQo+IGFuZCBtb2R1bGVfcGxhdGZvcm1fZHJpdmVyLk90aGVyIGNoYW5nZXMgc3VnZ2Vz\n" - "dGVkIGFyZSByZWxhdGVkIHRvDQo+IGNvZGluZyBndWlkZWxpbmVzLg0KPiANCj4gU2lnbmVkLW9m\n" - "Zi1ieTogYW5pc2gga3VtYXIgPGFuaXNoLnNpbmdoQHNhbXN1bmcuY29tPg0KPiBTaWduZWQtb2Zm\n" - "LWJ5OiBNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBzYW1zdW5nLmNvbT4NCg0KSGVsbG8sDQoN\n" - "Cg0KT25lIGxpdHRsZSB0aGluZyB0aGF0IEkndmUgbWlzc2VkIGJlZm9yZToNCg0KQ291bGQgeW91\n" - "IHBsZWFzZSByZW5hbWUgdGhlIGZpbGU/DQoNClRob3VnaCB0aGUgaW5pdGlhbCBmaWxlcyAoY2xh\n" - "c3MgYW5kIGdwaW8pIGRpZG4ndCBkbyBpdCwNCmxpa2Ugb3RoZXIgcmVjZW50IG9uZXMsIGxldCdz\n" - "IHVzZSAnLScgaW5zdGVhZCBvZiAnXycuDQpCZXNpZGVzLCBjb3VsZCB5b3UgcGxlYXNlIHVzZSAi\n" - "ZXh0Y29uIiBwcmVmaXggZm9yIHRoZSBmaWxlbmFtZT8NCg0KVGh1cywgImFkY19qYWNrLmMvaCIg\n" - "LS0+ICJleHRjb24tYWRjLWphY2suYy9oIg0KDQoNCkNoZWVycw0KTXl1bmdKb28NCg0KPiAtLS0N\n" - "Cj4gIGRyaXZlcnMvZXh0Y29uL0tjb25maWcgICAgICAgICAgfCAgICA1ICsNCj4gIGRyaXZlcnMv\n" - "ZXh0Y29uL01ha2VmaWxlICAgICAgICAgfCAgICAxICsNCj4gIGRyaXZlcnMvZXh0Y29uL2FkY19q\n" - "YWNrLmMgICAgICAgfCAgMTkzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr\n" - "Kw0KPiAgaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaCB8ICAgNzcgKysrKysrKysrKysr\n" - "KysrKw0KPiAgNCBmaWxlcyBjaGFuZ2VkLCAyNzYgaW5zZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMo\n" - "LSkNCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2V4dGNvbi9hZGNfamFjay5jDQo+ICBj\n" - "cmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaA0KPiANCj4g\n" - "ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZXh0Y29uL0tjb25maWcgYi9kcml2ZXJzL2V4dGNvbi9LY29u\n" - "ZmlnDQo+IGluZGV4IGUxNzVjOGUuLjU5NmUyNzcgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvZXh0\n" - "Y29uL0tjb25maWcNCj4gKysrIGIvZHJpdmVycy9leHRjb24vS2NvbmZpZw0KPiBAQCAtMjEsNiAr\n" - "MjEsMTEgQEAgY29uZmlnIEVYVENPTl9HUElPDQo+ICAJICBTYXkgWSBoZXJlIHRvIGVuYWJsZSBH\n" - "UElPIGJhc2VkIGV4dGNvbiBzdXBwb3J0LiBOb3RlIHRoYXQgR1BJTw0KPiAgCSAgZXh0Y29uIHN1\n" - "cHBvcnRzIHNpbmdsZSBzdGF0ZSBwZXIgZXh0Y29uIGluc3RhbmNlLg0KPiAgDQo+ICtjb25maWcg\n" - "RVhUQ09OX0FEQ19KQUNLDQo+ICsgICAgICAgIHRyaXN0YXRlICJBREMgSmFjayBleHRjb24gc3Vw\n" - "cG9ydCINCj4gKyAgICAgICAgaGVscA0KPiArICAgICAgICAgIFNheSBZIGhlcmUgdG8gZW5hYmxl\n" - "IGV4dGNvbiBkZXZpY2UgZHJpdmVyIGJhc2VkIG9uIEFEQyB2YWx1ZXMuDQo+ICsNCj4gIGNvbmZp\n" - "ZyBFWFRDT05fTUFYNzc2OTMNCj4gIAl0cmlzdGF0ZSAiTUFYNzc2OTMgRVhUQ09OIFN1cHBvcnQi\n" - "DQo+ICAJZGVwZW5kcyBvbiBNRkRfTUFYNzc2OTMNCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZXh0\n" - "Y29uL01ha2VmaWxlIGIvZHJpdmVycy9leHRjb24vTWFrZWZpbGUNCj4gaW5kZXggODg5NjFiMy4u\n" - "ZDk1YzVlYSAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9leHRjb24vTWFrZWZpbGUNCj4gKysrIGIv\n" - "ZHJpdmVycy9leHRjb24vTWFrZWZpbGUNCj4gQEAgLTQsNiArNCw3IEBADQo+ICANCj4gIG9iai0k\n" - "KENPTkZJR19FWFRDT04pCQkrPSBleHRjb25fY2xhc3Mubw0KPiAgb2JqLSQoQ09ORklHX0VYVENP\n" - "Tl9HUElPKQkrPSBleHRjb25fZ3Bpby5vDQo+ICtvYmotJChDT05GSUdfRVhUQ09OX0FEQ19KQUNL\n" - "KSAgICs9IGFkY19qYWNrLm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fTUFYNzc2OTMpCSs9IGV4\n" - "dGNvbi1tYXg3NzY5My5vDQo+ICBvYmotJChDT05GSUdfRVhUQ09OX01BWDg5OTcpCSs9IGV4dGNv\n" - "bi1tYXg4OTk3Lm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fQVJJWk9OQSkJKz0gZXh0Y29uLWFy\n" - "aXpvbmEubw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9leHRjb24vYWRjX2phY2suYyBiL2RyaXZl\n" - "cnMvZXh0Y29uL2FkY19qYWNrLmMNCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gaW5kZXggMDAw\n" - "MDAwMC4uOGI4MGFmMA0KPiAtLS0gL2Rldi9udWxsDQo+ICsrKyBiL2RyaXZlcnMvZXh0Y29uL2Fk\n" - "Y19qYWNrLmMNCj4gQEAgLTAsMCArMSwxOTMgQEANCj4gKy8qDQo+ICsgKiBkcml2ZXJzL2V4dGNv\n" - "bi9hZGNfamFjay5jDQo+ICsgKg0KPiArICogQW5hbG9nIEphY2sgZXh0Y29uIGRyaXZlciB3aXRo\n" - "IEFEQy1iYXNlZCBkZXRlY3Rpb24gY2FwYWJpbGl0eS4NCj4gKyAqDQo+ICsgKiBDb3B5cmlnaHQg\n" - "KEMpIDIwMTIgU2Ftc3VuZyBFbGVjdHJvbmljcw0KPiArICogTXl1bmdKb28gSGFtIDxteXVuZ2pv\n" - "by5oYW1Ac2Ftc3VuZy5jb20+DQo+ICsgKg0KPiArICogTW9kaWZpZWQgZm9yIGNhbGxpbmcgdG8g\n" - "SUlPIHRvIGdldCBhZGMgYnkgPGFuaXNoLnNpbmdoQHNhbXN1bmcuY29tPg0KPiArICoNCj4gKyAq\n" - "IFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh\n" - "bmQvb3IgbW9kaWZ5DQo+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFs\n" - "IFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcw0KPiArICogcHVibGlzaGVkIGJ5IHRoZSBGcmVl\n" - "IFNvZnR3YXJlIEZvdW5kYXRpb24uDQo+ICsgKg0KPiArICovDQo+ICsNCj4gKyNpbmNsdWRlIDxs\n" - "aW51eC9zbGFiLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+DQo+ICsjaW5jbHVkZSA8\n" - "bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+\n" - "DQo+ICsjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaWlv\n" - "L2NvbnN1bWVyLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvZXh0Y29uL2FkY19qYWNrLmg+DQo+ICsj\n" - "aW5jbHVkZSA8bGludXgvZXh0Y29uLmg+DQo+ICsNCj4gKy8qKg0KPiArICogc3RydWN0IGFkY19q\n" - "YWNrX2RhdGEgLSBpbnRlcm5hbCBkYXRhIGZvciBhZGNfamFjayBkZXZpY2UgZHJpdmVyDQo+ICsg\n" - "KiBAZWRldiAgICAgICAgLSBleHRjb24gZGV2aWNlLg0KPiArICogQGNhYmxlX25hbWVzIC0gbGlz\n" - "dCBvZiBzdXBwb3J0ZWQgY2FibGVzLg0KPiArICogQG51bV9jYWJsZXMgIC0gc2l6ZSBvZiBjYWJs\n" - "ZV9uYW1lcy4NCj4gKyAqIEBhZGNfY29uZGl0aW9uICAgICAgIC0gbGlzdCBvZiBhZGMgdmFsdWUg\n" - "Y29uZGl0aW9ucy4NCj4gKyAqIEBudW1fY29uZGl0aW9uICAgICAgIC0gc2l6ZSBvZiBhZGNfY29u\n" - "ZGl0aW9uLg0KPiArICogQGlycSAgICAgICAgIC0gaXJxIG51bWJlciBvZiBhdHRhY2gvZGV0YWNo\n" - "IGV2ZW50ICgwIGlmIG5vdCBleGlzdCkuDQo+ICsgKiBAaGFuZGxpbmdfZGVsYXkgICAgICAtIGlu\n" - "dGVycnVwdCBoYW5kbGVyIHdpbGwgc2NoZWR1bGUgZXh0Y29uIGV2ZW50DQo+ICsgKiAgICAgICAg\n" - "ICAgICAgICAgICAgICBoYW5kbGluZyBhdCBoYW5kbGluZ19kZWxheSBqaWZmaWVzLg0KPiArICog\n" - "QGhhbmRsZXIgICAgIC0gZXh0Y29uIGV2ZW50IGhhbmRsZXIgY2FsbGVkIGJ5IGludGVycnVwdCBo\n" - "YW5kbGVyLg0KPiArICogQGdldF9hZGMgICAgIC0gYSBjYWxsYmFjayB0byBnZXQgQURDIHZhbHVl\n" - "IHRvIGlkZW50aWZ5IHN0YXRlLg0KPiArICovDQo+ICtzdHJ1Y3QgYWRjX2phY2tfZGF0YSB7DQo+\n" - "ICsJc3RydWN0IGV4dGNvbl9kZXYgZWRldjsNCj4gKw0KPiArCWNvbnN0IGNoYXIgKipjYWJsZV9u\n" - "YW1lczsNCj4gKwlpbnQgbnVtX2NhYmxlczsNCj4gKwlzdHJ1Y3QgYWRjX2phY2tfY29uZCAqYWRj\n" - "X2NvbmRpdGlvbjsNCj4gKwlpbnQgbnVtX2NvbmRpdGlvbnM7DQo+ICsNCj4gKwlpbnQgaXJxOw0K\n" - "PiArCXVuc2lnbmVkIGxvbmcgaGFuZGxpbmdfZGVsYXk7IC8qIGluIGppZmZpZXMgKi8NCj4gKwlz\n" - "dHJ1Y3QgZGVsYXllZF93b3JrIGhhbmRsZXI7DQo+ICsNCj4gKwlzdHJ1Y3QgaWlvX2NoYW5uZWwg\n" - "KmNoYW47DQo+ICt9Ow0KPiArDQo+ICtzdGF0aWMgdm9pZCBhZGNfamFja19oYW5kbGVyKHN0cnVj\n" - "dCB3b3JrX3N0cnVjdCAqd29yaykNCj4gK3sNCj4gKwlzdHJ1Y3QgYWRjX2phY2tfZGF0YSAqZGF0\n" - "YSA9IGNvbnRhaW5lcl9vZih0b19kZWxheWVkX3dvcmsod29yayksDQo+ICsJCQkJCQkgIHN0cnVj\n" - "dCBhZGNfamFja19kYXRhLA0KPiArCQkJCQkJICBoYW5kbGVyKTsNCj4gKwl1MzIgc3RhdGUgPSAw\n" - "Ow0KPiArCWludCByZXQsIGFkY192YWw7DQo+ICsJaW50IGk7DQo+ICsNCj4gKwlyZXQgPSBpaW9f\n" - "cmVhZF9jaGFubmVsX3JhdyhkYXRhLT5jaGFuLCAmYWRjX3ZhbCk7DQo+ICsJaWYgKHJldCA8IDAp\n" - "IHsNCj4gKwkJZGV2X2VycihkYXRhLT5lZGV2LmRldiwgInJlYWQgY2hhbm5lbCgpIGVycm9yOiAl\n" - "ZFxuIiwgcmV0KTsNCj4gKwkJcmV0dXJuOw0KPiArCX0NCj4gKw0KPiArCS8qIEdldCBzdGF0ZSBm\n" - "cm9tIGFkYyB2YWx1ZSB3aXRoIGFkY19jb25kaXRpb24gKi8NCj4gKwlmb3IgKGkgPSAwOyBpIDwg\n" - "ZGF0YS0+bnVtX2NvbmRpdGlvbnM7IGkrKykgew0KPiArCQlzdHJ1Y3QgYWRjX2phY2tfY29uZCAq\n" - "ZGVmID0gJmRhdGEtPmFkY19jb25kaXRpb25baV07DQo+ICsJCWlmICghZGVmLT5zdGF0ZSkNCj4g\n" - "KwkJCWJyZWFrOw0KPiArCQlpZiAoZGVmLT5taW5fYWRjIDw9IGFkY192YWwgJiYgZGVmLT5tYXhf\n" - "YWRjID49IGFkY192YWwpIHsNCj4gKwkJCXN0YXRlID0gZGVmLT5zdGF0ZTsNCj4gKwkJCWJyZWFr\n" - "Ow0KPiArCQl9DQo+ICsJfQ0KPiArCS8qIGlmIG5vIGRlZiBoYXMgbWV0LCBpdCBtZWFucyBzdGF0\n" - "ZSA9IDAgKG5vIGNhYmxlcyBhdHRhY2hlZCkgKi8NCj4gKw0KPiArCWV4dGNvbl9zZXRfc3RhdGUo\n" - "JmRhdGEtPmVkZXYsIHN0YXRlKTsNCj4gK30NCj4gKw0KPiArc3RhdGljIGlycXJldHVybl90IGFk\n" - "Y19qYWNrX2lycV90aHJlYWQoaW50IGlycSwgdm9pZCAqX2RhdGEpDQo+ICt7DQo+ICsJc3RydWN0\n" - "IGFkY19qYWNrX2RhdGEgKmRhdGEgPSBfZGF0YTsNCj4gKw0KPiArCXNjaGVkdWxlX2RlbGF5ZWRf\n" - "d29yaygmZGF0YS0+aGFuZGxlciwgZGF0YS0+aGFuZGxpbmdfZGVsYXkpOw0KPiArCXJldHVybiBJ\n" - "UlFfSEFORExFRDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBhZGNfamFja19wcm9iZShzdHJ1\n" - "Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRh\n" - "ICpkYXRhOw0KPiArCXN0cnVjdCBhZGNfamFja19wZGF0YSAqcGRhdGEgPSBwZGV2LT5kZXYucGxh\n" - "dGZvcm1fZGF0YTsNCj4gKwlpbnQgaSwgZXJyID0gMDsNCj4gKw0KPiArCWRhdGEgPSBkZXZtX2t6\n" - "YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpkYXRhKSwgR0ZQX0tFUk5FTCk7DQo+ICsJaWYgKCFk\n" - "YXRhKQ0KPiArCQlyZXR1cm4gLUVOT01FTTsNCj4gKw0KPiArCWRhdGEtPmVkZXYubmFtZSA9IHBk\n" - "YXRhLT5uYW1lOw0KPiArDQo+ICsJaWYgKHBkYXRhLT5jYWJsZV9uYW1lcykNCj4gKwkJZGF0YS0+\n" - "ZWRldi5zdXBwb3J0ZWRfY2FibGUgPSBwZGF0YS0+Y2FibGVfbmFtZXM7DQo+ICsJZWxzZQ0KPiAr\n" - "CQlkYXRhLT5lZGV2LnN1cHBvcnRlZF9jYWJsZSA9IGV4dGNvbl9jYWJsZV9uYW1lOw0KPiArDQo+\n" - "ICsJLyogQ2hlY2sgdGhlIGxlbmd0aCBvZiBhcnJheSBhbmQgc2V0IG51bV9jYWJsZXMgKi8NCj4g\n" - "Kwlmb3IgKGkgPSAwOyBkYXRhLT5lZGV2LnN1cHBvcnRlZF9jYWJsZVtpXTsgaSsrKQ0KPiArCQk7\n" - "DQo+ICsJaWYgKGkgPT0gMCB8fCBpID4gU1VQUE9SVEVEX0NBQkxFX01BWCkgew0KPiArCQllcnIg\n" - "PSAtRUlOVkFMOw0KPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJlcnJvcjogcGRhdGEtPmNhYmxl\n" - "X25hbWVzIHNpemUgPSAlZFxuIiwNCj4gKwkJCWkgLSAxKTsNCj4gKwkJZ290byBlcnJfYWxsb2M7\n" - "DQo+ICsJfQ0KPiArCWRhdGEtPm51bV9jYWJsZXMgPSBpOw0KPiArDQo+ICsJaWYgKCFwZGF0YS0+\n" - "YWRjX2NvbmRpdGlvbiB8fA0KPiArCSAgICAhcGRhdGEtPmFkY19jb25kaXRpb25bMF0uc3RhdGUp\n" - "IHsNCj4gKwkJZXJyID0gLUVJTlZBTDsNCj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZXJyb3I6\n" - "IGFkY19jb25kaXRpb24gbm90IGRlZmluZWQuXG4iKTsNCj4gKwkJZ290byBlcnJfYWxsb2M7DQo+\n" - "ICsJfQ0KPiArCWRhdGEtPmFkY19jb25kaXRpb24gPSBwZGF0YS0+YWRjX2NvbmRpdGlvbjsNCj4g\n" - "Kw0KPiArCS8qIENoZWNrIHRoZSBsZW5ndGggb2YgYXJyYXkgYW5kIHNldCBudW1fY29uZGl0aW9u\n" - "cyAqLw0KPiArCWZvciAoaSA9IDA7IGRhdGEtPmFkY19jb25kaXRpb25baV0uc3RhdGU7IGkrKykN\n" - "Cj4gKwkJOw0KPiArCWRhdGEtPm51bV9jb25kaXRpb25zID0gaTsNCj4gKw0KPiArCWRhdGEtPmNo\n" - "YW4gPSBpaW9fY2hhbm5lbF9nZXQoZGV2X25hbWUoJnBkZXYtPmRldiksDQo+ICsJCQkJCQlwZGF0\n" - "YS0+Y29uc3VtZXJfY2hhbm5lbCk7DQo+ICsJaWYgKElTX0VSUihkYXRhLT5jaGFuKSkgew0KPiAr\n" - "CQllcnIgPSBQVFJfRVJSKGRhdGEtPmNoYW4pOw0KPiArCQlnb3RvIGVycl9hbGxvYzsNCj4gKwl9\n" - "DQo+ICsNCj4gKwlkYXRhLT5oYW5kbGluZ19kZWxheSA9IG1zZWNzX3RvX2ppZmZpZXMocGRhdGEt\n" - "PmhhbmRsaW5nX2RlbGF5X21zKTsNCj4gKw0KPiArCUlOSVRfREVMQVlFRF9XT1JLX0RFRkVSUkFC\n" - "TEUoJmRhdGEtPmhhbmRsZXIsIGFkY19qYWNrX2hhbmRsZXIpOw0KPiArDQo+ICsJcGxhdGZvcm1f\n" - "c2V0X2RydmRhdGEocGRldiwgZGF0YSk7DQo+ICsNCj4gKwllcnIgPSBleHRjb25fZGV2X3JlZ2lz\n" - "dGVyKCZkYXRhLT5lZGV2LCAmcGRldi0+ZGV2KTsNCj4gKwlpZiAoZXJyKQ0KPiArCQlnb3RvIGVy\n" - "cl9pbml0d29yazsNCj4gKw0KPiArCWRhdGEtPmlycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwg\n" - "MCk7DQo+ICsNCj4gKwllcnIgPSByZXF1ZXN0X2FueV9jb250ZXh0X2lycShkYXRhLT5pcnEsIGFk\n" - "Y19qYWNrX2lycV90aHJlYWQsDQo+ICsJCQkJcGRhdGEtPmlycV9mbGFncywgcGRhdGEtPm5hbWUs\n" - "IGRhdGEpOw0KPiArDQo+ICsJaWYgKGVycikgew0KPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJl\n" - "cnJvcjogaXJxICVkXG4iLCBkYXRhLT5pcnEpOw0KPiArCQllcnIgPSAtRUlOVkFMOw0KPiArCQln\n" - "b3RvIGVycl9pcnE7DQo+ICsJfQ0KPiArDQo+ICsJZ290byBvdXQ7DQo+ICsNCj4gK2Vycl9pcnE6\n" - "DQo+ICsJZXh0Y29uX2Rldl91bnJlZ2lzdGVyKCZkYXRhLT5lZGV2KTsNCj4gK2Vycl9pbml0d29y\n" - "azoNCj4gKwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmRhdGEtPmhhbmRsZXIpOw0KPiArZXJy\n" - "X2FsbG9jOg0KPiArCWtmcmVlKGRhdGEpOw0KPiArb3V0Og0KPiArCXJldHVybiBlcnI7DQo+ICt9\n" - "DQo+ICsNCj4gK3N0YXRpYyBpbnQgX19kZXZleGl0IGFkY19qYWNrX3JlbW92ZShzdHJ1Y3QgcGxh\n" - "dGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRhICpkYXRh\n" - "ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7DQo+ICsNCj4gKwlleHRjb25fZGV2X3VucmVn\n" - "aXN0ZXIoJmRhdGEtPmVkZXYpOw0KPiArCWlmIChkYXRhLT5pcnEpDQo+ICsJCWZyZWVfaXJxKGRh\n" - "dGEtPmlycSwgZGF0YSk7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGlj\n" - "IHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYWRjX2phY2tfZHJpdmVyID0gew0KPiArCS5wcm9iZQkJ\n" - "PSBhZGNfamFja19wcm9iZSwNCj4gKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKGFkY19qYWNrX3Jl\n" - "bW92ZSksDQo+ICsJLmRyaXZlcgkJPSB7DQo+ICsJCS5uYW1lCT0gImFkYy1qYWNrIiwNCj4gKwkJ\n" - "Lm93bmVyCT0gVEhJU19NT0RVTEUsDQo+ICsJfSwNCj4gK307DQo+ICsNCj4gK21vZHVsZV9wbGF0\n" - "Zm9ybV9kcml2ZXIoYWRjX2phY2tfZHJpdmVyKTsNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu\n" - "dXgvZXh0Y29uL2FkY19qYWNrLmggYi9pbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5oDQo+\n" - "IG5ldyBmaWxlIG1vZGUgMTAwNjQ0DQo+IGluZGV4IDAwMDAwMDAuLmNhNGQxY2QNCj4gLS0tIC9k\n" - "ZXYvbnVsbA0KPiArKysgYi9pbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5oDQo+IEBAIC0w\n" - "LDAgKzEsNzcgQEANCj4gKy8qDQo+ICsgKiBpbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5o\n" - "DQo+ICsgKg0KPiArICogQW5hbG9nIEphY2sgZXh0Y29uIGRyaXZlciB3aXRoIEFEQy1iYXNlZCBk\n" - "ZXRlY3Rpb24gY2FwYWJpbGl0eS4NCj4gKyAqDQo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTIgU2Ft\n" - "c3VuZyBFbGVjdHJvbmljcw0KPiArICogTXl1bmdKb28gSGFtIDxteXVuZ2pvby5oYW1Ac2Ftc3Vu\n" - "Zy5jb20+DQo+ICsgKg0KPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj\n" - "YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkNCj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJt\n" - "cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzDQo+ICsgKiBw\n" - "dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCj4gKyAqDQo+ICsgKi8N\n" - "Cj4gKw0KPiArI2lmbmRlZiBfRVhUQ09OX0FEQ19KQUNLX0hfDQo+ICsjZGVmaW5lIF9FWFRDT05f\n" - "QURDX0pBQ0tfSF8gX19GSUxFX18NCj4gKw0KPiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPg0K\n" - "PiArI2luY2x1ZGUgPGxpbnV4L2V4dGNvbi5oPg0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVjdCBh\n" - "ZGNfamFja19jb25kIC0gY29uZGl0aW9uIHRvIHVzZSBhbiBleHRjb24gc3RhdGUNCj4gKyAqIEBz\n" - "dGF0ZQktIHRoZSBjb3JyZXNwb25kaW5nIGV4dGNvbiBzdGF0ZSAoaWYgMCwgdGhpcyBzdHJ1Y3Qg\n" - "ZGVub3Rlcw0KPiArICoJCXRoZSBsYXN0IGFkY19qYWNrX2NvbmQgZWxlbWVudCBhbW9uZyB0aGUg\n" - "YXJyYXkpDQo+ICsgKiBAbWluX2FkYwktIG1pbiBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9u\n" - "DQo+ICsgKiBAbWF4X2FkYwktIG1heCBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9uDQo+ICsg\n" - "Kg0KPiArICogRm9yIGV4YW1wbGUsIGlmIHsgLnN0YXRlID0gMHgzLCAubWluX2FkYyA9IDEwMCwg\n" - "Lm1heF9hZGMgPSAyMDB9LCBpdCBtZWFucw0KPiArICogdGhhdCBpZiBBREMgdmFsdWUgaXMgYmV0\n" - "d2VlbiAoaW5jbHVzaXZlKSAxMDAgYW5kIDIwMCwgdGhhbiB0aGUgY2FibGUgMCBhbmQNCj4gKyAq\n" - "IDEgYXJlIGF0dGFjaGVkICgxPDwwIHwgMTw8MSA9PSAweDMpDQo+ICsgKg0KPiArICogTm90ZSB0\n" - "aGF0IHlvdSBkb24ndCBuZWVkIHRvIGRlc2NyaWJlIGNvbmRpdGlvbiBmb3IgIm5vIGNhYmxlIGF0\n" - "dGFjaGVkIg0KPiArICogYmVjYXVzZSB3aGVuIG5vIGFkY19qYWNrX2NvbmQgaXMgbWV0LCBzdGF0\n" - "ZSA9IDAgaXMgYXV0b21hdGljYWxseSBjaG9zZW4uDQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFj\n" - "a19jb25kIHsNCj4gKwl1MzIgc3RhdGU7IC8qIGV4dGNvbiBzdGF0ZSB2YWx1ZS4gMCBpZiBpbnZh\n" - "bGlkICovDQo+ICsJdTMyIG1pbl9hZGM7DQo+ICsJdTMyIG1heF9hZGM7DQo+ICt9Ow0KPiArDQo+\n" - "ICsvKioNCj4gKyAqIHN0cnVjdCBhZGNfamFja19wZGF0YSAtIHBsYXRmb3JtIGRhdGEgZm9yIGFk\n" - "YyBqYWNrIGRldmljZS4NCj4gKyAqIEBuYW1lCS0gbmFtZSBvZiB0aGUgZXh0Y29uIGRldmljZS4g\n" - "SWYgbnVsbCwgImFkYy1qYWNrIiBpcyB1c2VkLg0KPiArICogQGNhYmxlX25hbWVzCS0gYXJyYXkg\n" - "b2YgY2FibGUgbmFtZXMgZW5kaW5nIHdpdGggbnVsbC4gSWYgdGhlIGFycmF5IGl0c2VsZg0KPiAr\n" - "ICoJCWlmIG51bGwsIGV4dGNvbiBzdGFuZGFyZCBjYWJsZSBuYW1lcyBhcmUgY2hvc2VuLg0KPiAr\n" - "ICogQGFkY19jb250aXRpb24JLSBhcnJheSBvZiBzdHJ1Y3QgYWRjX2phY2tfY29uZCBjb25kaXRp\n" - "b25zIGVuZGluZw0KPiArICoJCQl3aXRoIC5zdGF0ZSA9IDAgZW50cnkuIFRoaXMgZGVzY3JpYmVz\n" - "IGhvdyB0byBkZWNvZGUNCj4gKyAqCQkJYWRjIHZhbHVlcyBpbnRvIGV4dGNvbiBzdGF0ZS4NCj4g\n" - "KyAqIEBpcnEJCS0gSVJRIG51bWJlciB0aGF0IGlzIHRyaWdnZXJyZWQgYnkgY2FibGUgYXR0YWNo\n" - "L2RldGFjaA0KPiArICoJCWV2ZW50cy4gSWYgaXJxID0gMCwgdXNlIHNob3VsZCBtYW51YWxseSB1\n" - "cGRhdGUgZXh0Y29uIHN0YXRlDQo+ICsgKgkJd2l0aCBleHRjb24gQVBJcy4NCj4gKyAqIEBpcnFf\n" - "ZmxhZ3MJLSBpcnEgZmxhZ3MgdXNlZCBmb3IgdGhlIEBpcnENCj4gKyAqIEBoYW5kbGluZ19kZWxh\n" - "eV9tcwktIGluIHNvbWUgZGV2aWNlcywgd2UgbmVlZCB0byByZWFkIEFEQyB2YWx1ZSBzb21lDQo+\n" - "ICsgKgkJCW1pbGxpLXNlY29uZHMgYWZ0ZXIgdGhlIGludGVycnVwdCBvY2N1cnMuIFlvdSBtYXkN\n" - "Cj4gKyAqCQkJZGVzY3JpYmUgc3VjaCBkZWxheXMgd2l0aCBAaGFuZGxpbmdfZGVsYXlfbXMsIHdo\n" - "aWNoDQo+ICsgKgkJCWlzIHJvdW5kZWQtb2ZmIGJ5IGppZmZpZXMuDQo+ICsgKiBAZ2V0X2FkYwkt\n" - "IHRoZSBjYWxsYmFjayB0byByZWFkIEFEQyB2YWx1ZSB0byBpZGVudGlmeSBjYWJsZSBzdGF0ZXMu\n" - "DQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFja19wZGF0YSB7DQo+ICsJY29uc3QgY2hhciAqbmFt\n" - "ZTsNCj4gKwljb25zdCBjaGFyICpjb25zdW1lcl9jaGFubmVsOw0KPiArCS8qDQo+ICsJICogTlVM\n" - "TCBpZiBzdGFuZGFyZCBleHRjb24gbmFtZXMgYXJlIHVzZWQuDQo+ICsJICogVGhlIGxhc3QgZW50\n" - "cnkgc2hvdWxkIGJlIE5VTEwNCj4gKwkgKi8NCj4gKwljb25zdCBjaGFyICoqY2FibGVfbmFtZXM7\n" - "DQo+ICsJLyogVGhlIGxhc3QgZW50cnkncyBzdGF0ZSBzaG91bGQgYmUgMCAqLw0KPiArCXN0cnVj\n" - "dCBhZGNfamFja19jb25kICphZGNfY29uZGl0aW9uOw0KPiArDQo+ICsJdW5zaWduZWQgbG9uZyBp\n" - "cnFfZmxhZ3M7DQo+ICsJdW5zaWduZWQgbG9uZyBoYW5kbGluZ19kZWxheV9tczsgLyogaW4gbXMg\n" - "Ki8NCj4gKw0KPiArCS8qIFdoZW4gd2UgaGF2ZSBBREMgc3Vic3lzdGVtLCB0aGlzIGNhbiBiZSBn\n" - "ZW5lcmFsaXplZC4gKi8NCj4gKwlpbnQgKCpnZXRfYWRjKSh1MzIgKnZhbHVlKTsNCj4gK307DQo+\n" - "ICsNCj4gKyNlbmRpZiAvKiBfRVhUQ09OX0FEQ19KQUNLX0ggKi8NCj4gLS0gDQo+IDEuNy4xDQo+\n" - IA0KPiANCj4gDQo+IA0KPiAgICAgICAgDQo+ICAgDQo+ICAgICAgICAgIA0KPiANCg== + "> From: anish kumar <anish198519851985@gmail.com>\n" + "> \n" + "> External connector devices that decides connection information based on\n" + "> ADC values may use adc-jack device driver. The user simply needs to\n" + "> provide a table of adc range and connection states. Then, extcon\n" + "> framework will automatically notify others.\n" + "> \n" + "> Changes in this version:\n" + "> added Lars-Peter Clausen suggested changes:\n" + "> Using macros to get rid of boiler plate code such as devm_kzalloc\n" + "> and module_platform_driver.Other changes suggested are related to\n" + "> coding guidelines.\n" + "> \n" + "> Signed-off-by: anish kumar <anish.singh@samsung.com>\n" + "> Signed-off-by: MyungJoo Ham <myungjoo.ham@samsung.com>\n" + "\n" + "Hello,\n" + "\n" + "\n" + "One little thing that I've missed before:\n" + "\n" + "Could you please rename the file?\n" + "\n" + "Though the initial files (class and gpio) didn't do it,\n" + "like other recent ones, let's use '-' instead of '_'.\n" + "Besides, could you please use \"extcon\" prefix for the filename?\n" + "\n" + "Thus, \"adc_jack.c/h\" --> \"extcon-adc-jack.c/h\"\n" + "\n" + "\n" + "Cheers\n" + "MyungJoo\n" + "\n" + "> ---\n" + "> drivers/extcon/Kconfig | 5 +\n" + "> drivers/extcon/Makefile | 1 +\n" + "> drivers/extcon/adc_jack.c | 193 +++++++++++++++++++++++++++++++++++++++\n" + "> include/linux/extcon/adc_jack.h | 77 ++++++++++++++++\n" + "> 4 files changed, 276 insertions(+), 0 deletions(-)\n" + "> create mode 100644 drivers/extcon/adc_jack.c\n" + "> create mode 100644 include/linux/extcon/adc_jack.h\n" + "> \n" + "> diff --git a/drivers/extcon/Kconfig b/drivers/extcon/Kconfig\n" + "> index e175c8e..596e277 100644\n" + "> --- a/drivers/extcon/Kconfig\n" + "> +++ b/drivers/extcon/Kconfig\n" + "> @@ -21,6 +21,11 @@ config EXTCON_GPIO\n" + "> \t Say Y here to enable GPIO based extcon support. Note that GPIO\n" + "> \t extcon supports single state per extcon instance.\n" + "> \n" + "> +config EXTCON_ADC_JACK\n" + "> + tristate \"ADC Jack extcon support\"\n" + "> + help\n" + "> + Say Y here to enable extcon device driver based on ADC values.\n" + "> +\n" + "> config EXTCON_MAX77693\n" + "> \ttristate \"MAX77693 EXTCON Support\"\n" + "> \tdepends on MFD_MAX77693\n" + "> diff --git a/drivers/extcon/Makefile b/drivers/extcon/Makefile\n" + "> index 88961b3..d95c5ea 100644\n" + "> --- a/drivers/extcon/Makefile\n" + "> +++ b/drivers/extcon/Makefile\n" + "> @@ -4,6 +4,7 @@\n" + "> \n" + "> obj-$(CONFIG_EXTCON)\t\t+= extcon_class.o\n" + "> obj-$(CONFIG_EXTCON_GPIO)\t+= extcon_gpio.o\n" + "> +obj-$(CONFIG_EXTCON_ADC_JACK) += adc_jack.o\n" + "> obj-$(CONFIG_EXTCON_MAX77693)\t+= extcon-max77693.o\n" + "> obj-$(CONFIG_EXTCON_MAX8997)\t+= extcon-max8997.o\n" + "> obj-$(CONFIG_EXTCON_ARIZONA)\t+= extcon-arizona.o\n" + "> diff --git a/drivers/extcon/adc_jack.c b/drivers/extcon/adc_jack.c\n" + "> new file mode 100644\n" + "> index 0000000..8b80af0\n" + "> --- /dev/null\n" + "> +++ b/drivers/extcon/adc_jack.c\n" + "> @@ -0,0 +1,193 @@\n" + "> +/*\n" + "> + * drivers/extcon/adc_jack.c\n" + "> + *\n" + "> + * Analog Jack extcon driver with ADC-based detection capability.\n" + "> + *\n" + "> + * Copyright (C) 2012 Samsung Electronics\n" + "> + * MyungJoo Ham <myungjoo.ham@samsung.com>\n" + "> + *\n" + "> + * Modified for calling to IIO to get adc by <anish.singh@samsung.com>\n" + "> + *\n" + "> + * This program is free software; you can redistribute it and/or modify\n" + "> + * it under the terms of the GNU General Public License version 2 as\n" + "> + * published by the Free Software Foundation.\n" + "> + *\n" + "> + */\n" + "> +\n" + "> +#include <linux/slab.h>\n" + "> +#include <linux/device.h>\n" + "> +#include <linux/platform_device.h>\n" + "> +#include <linux/interrupt.h>\n" + "> +#include <linux/workqueue.h>\n" + "> +#include <linux/iio/consumer.h>\n" + "> +#include <linux/extcon/adc_jack.h>\n" + "> +#include <linux/extcon.h>\n" + "> +\n" + "> +/**\n" + "> + * struct adc_jack_data - internal data for adc_jack device driver\n" + "> + * @edev - extcon device.\n" + "> + * @cable_names - list of supported cables.\n" + "> + * @num_cables - size of cable_names.\n" + "> + * @adc_condition - list of adc value conditions.\n" + "> + * @num_condition - size of adc_condition.\n" + "> + * @irq - irq number of attach/detach event (0 if not exist).\n" + "> + * @handling_delay - interrupt handler will schedule extcon event\n" + "> + * handling at handling_delay jiffies.\n" + "> + * @handler - extcon event handler called by interrupt handler.\n" + "> + * @get_adc - a callback to get ADC value to identify state.\n" + "> + */\n" + "> +struct adc_jack_data {\n" + "> +\tstruct extcon_dev edev;\n" + "> +\n" + "> +\tconst char **cable_names;\n" + "> +\tint num_cables;\n" + "> +\tstruct adc_jack_cond *adc_condition;\n" + "> +\tint num_conditions;\n" + "> +\n" + "> +\tint irq;\n" + "> +\tunsigned long handling_delay; /* in jiffies */\n" + "> +\tstruct delayed_work handler;\n" + "> +\n" + "> +\tstruct iio_channel *chan;\n" + "> +};\n" + "> +\n" + "> +static void adc_jack_handler(struct work_struct *work)\n" + "> +{\n" + "> +\tstruct adc_jack_data *data = container_of(to_delayed_work(work),\n" + "> +\t\t\t\t\t\t struct adc_jack_data,\n" + "> +\t\t\t\t\t\t handler);\n" + "> +\tu32 state = 0;\n" + "> +\tint ret, adc_val;\n" + "> +\tint i;\n" + "> +\n" + "> +\tret = iio_read_channel_raw(data->chan, &adc_val);\n" + "> +\tif (ret < 0) {\n" + "> +\t\tdev_err(data->edev.dev, \"read channel() error: %d\\n\", ret);\n" + "> +\t\treturn;\n" + "> +\t}\n" + "> +\n" + "> +\t/* Get state from adc value with adc_condition */\n" + "> +\tfor (i = 0; i < data->num_conditions; i++) {\n" + "> +\t\tstruct adc_jack_cond *def = &data->adc_condition[i];\n" + "> +\t\tif (!def->state)\n" + "> +\t\t\tbreak;\n" + "> +\t\tif (def->min_adc <= adc_val && def->max_adc >= adc_val) {\n" + "> +\t\t\tstate = def->state;\n" + "> +\t\t\tbreak;\n" + "> +\t\t}\n" + "> +\t}\n" + "> +\t/* if no def has met, it means state = 0 (no cables attached) */\n" + "> +\n" + "> +\textcon_set_state(&data->edev, state);\n" + "> +}\n" + "> +\n" + "> +static irqreturn_t adc_jack_irq_thread(int irq, void *_data)\n" + "> +{\n" + "> +\tstruct adc_jack_data *data = _data;\n" + "> +\n" + "> +\tschedule_delayed_work(&data->handler, data->handling_delay);\n" + "> +\treturn IRQ_HANDLED;\n" + "> +}\n" + "> +\n" + "> +static int adc_jack_probe(struct platform_device *pdev)\n" + "> +{\n" + "> +\tstruct adc_jack_data *data;\n" + "> +\tstruct adc_jack_pdata *pdata = pdev->dev.platform_data;\n" + "> +\tint i, err = 0;\n" + "> +\n" + "> +\tdata = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);\n" + "> +\tif (!data)\n" + "> +\t\treturn -ENOMEM;\n" + "> +\n" + "> +\tdata->edev.name = pdata->name;\n" + "> +\n" + "> +\tif (pdata->cable_names)\n" + "> +\t\tdata->edev.supported_cable = pdata->cable_names;\n" + "> +\telse\n" + "> +\t\tdata->edev.supported_cable = extcon_cable_name;\n" + "> +\n" + "> +\t/* Check the length of array and set num_cables */\n" + "> +\tfor (i = 0; data->edev.supported_cable[i]; i++)\n" + "> +\t\t;\n" + "> +\tif (i == 0 || i > SUPPORTED_CABLE_MAX) {\n" + "> +\t\terr = -EINVAL;\n" + "> +\t\tdev_err(&pdev->dev, \"error: pdata->cable_names size = %d\\n\",\n" + "> +\t\t\ti - 1);\n" + "> +\t\tgoto err_alloc;\n" + "> +\t}\n" + "> +\tdata->num_cables = i;\n" + "> +\n" + "> +\tif (!pdata->adc_condition ||\n" + "> +\t !pdata->adc_condition[0].state) {\n" + "> +\t\terr = -EINVAL;\n" + "> +\t\tdev_err(&pdev->dev, \"error: adc_condition not defined.\\n\");\n" + "> +\t\tgoto err_alloc;\n" + "> +\t}\n" + "> +\tdata->adc_condition = pdata->adc_condition;\n" + "> +\n" + "> +\t/* Check the length of array and set num_conditions */\n" + "> +\tfor (i = 0; data->adc_condition[i].state; i++)\n" + "> +\t\t;\n" + "> +\tdata->num_conditions = i;\n" + "> +\n" + "> +\tdata->chan = iio_channel_get(dev_name(&pdev->dev),\n" + "> +\t\t\t\t\t\tpdata->consumer_channel);\n" + "> +\tif (IS_ERR(data->chan)) {\n" + "> +\t\terr = PTR_ERR(data->chan);\n" + "> +\t\tgoto err_alloc;\n" + "> +\t}\n" + "> +\n" + "> +\tdata->handling_delay = msecs_to_jiffies(pdata->handling_delay_ms);\n" + "> +\n" + "> +\tINIT_DELAYED_WORK_DEFERRABLE(&data->handler, adc_jack_handler);\n" + "> +\n" + "> +\tplatform_set_drvdata(pdev, data);\n" + "> +\n" + "> +\terr = extcon_dev_register(&data->edev, &pdev->dev);\n" + "> +\tif (err)\n" + "> +\t\tgoto err_initwork;\n" + "> +\n" + "> +\tdata->irq = platform_get_irq(pdev, 0);\n" + "> +\n" + "> +\terr = request_any_context_irq(data->irq, adc_jack_irq_thread,\n" + "> +\t\t\t\tpdata->irq_flags, pdata->name, data);\n" + "> +\n" + "> +\tif (err) {\n" + "> +\t\tdev_err(&pdev->dev, \"error: irq %d\\n\", data->irq);\n" + "> +\t\terr = -EINVAL;\n" + "> +\t\tgoto err_irq;\n" + "> +\t}\n" + "> +\n" + "> +\tgoto out;\n" + "> +\n" + "> +err_irq:\n" + "> +\textcon_dev_unregister(&data->edev);\n" + "> +err_initwork:\n" + "> +\tcancel_delayed_work_sync(&data->handler);\n" + "> +err_alloc:\n" + "> +\tkfree(data);\n" + "> +out:\n" + "> +\treturn err;\n" + "> +}\n" + "> +\n" + "> +static int __devexit adc_jack_remove(struct platform_device *pdev)\n" + "> +{\n" + "> +\tstruct adc_jack_data *data = platform_get_drvdata(pdev);\n" + "> +\n" + "> +\textcon_dev_unregister(&data->edev);\n" + "> +\tif (data->irq)\n" + "> +\t\tfree_irq(data->irq, data);\n" + "> +\n" + "> +\treturn 0;\n" + "> +}\n" + "> +\n" + "> +static struct platform_driver adc_jack_driver = {\n" + "> +\t.probe\t\t= adc_jack_probe,\n" + "> +\t.remove\t\t= __devexit_p(adc_jack_remove),\n" + "> +\t.driver\t\t= {\n" + "> +\t\t.name\t= \"adc-jack\",\n" + "> +\t\t.owner\t= THIS_MODULE,\n" + "> +\t},\n" + "> +};\n" + "> +\n" + "> +module_platform_driver(adc_jack_driver);\n" + "> diff --git a/include/linux/extcon/adc_jack.h b/include/linux/extcon/adc_jack.h\n" + "> new file mode 100644\n" + "> index 0000000..ca4d1cd\n" + "> --- /dev/null\n" + "> +++ b/include/linux/extcon/adc_jack.h\n" + "> @@ -0,0 +1,77 @@\n" + "> +/*\n" + "> + * include/linux/extcon/adc_jack.h\n" + "> + *\n" + "> + * Analog Jack extcon driver with ADC-based detection capability.\n" + "> + *\n" + "> + * Copyright (C) 2012 Samsung Electronics\n" + "> + * MyungJoo Ham <myungjoo.ham@samsung.com>\n" + "> + *\n" + "> + * This program is free software; you can redistribute it and/or modify\n" + "> + * it under the terms of the GNU General Public License version 2 as\n" + "> + * published by the Free Software Foundation.\n" + "> + *\n" + "> + */\n" + "> +\n" + "> +#ifndef _EXTCON_ADC_JACK_H_\n" + "> +#define _EXTCON_ADC_JACK_H_ __FILE__\n" + "> +\n" + "> +#include <linux/module.h>\n" + "> +#include <linux/extcon.h>\n" + "> +\n" + "> +/**\n" + "> + * struct adc_jack_cond - condition to use an extcon state\n" + "> + * @state\t- the corresponding extcon state (if 0, this struct denotes\n" + "> + *\t\tthe last adc_jack_cond element among the array)\n" + "> + * @min_adc\t- min adc value for this condition\n" + "> + * @max_adc\t- max adc value for this condition\n" + "> + *\n" + "> + * For example, if { .state = 0x3, .min_adc = 100, .max_adc = 200}, it means\n" + "> + * that if ADC value is between (inclusive) 100 and 200, than the cable 0 and\n" + "> + * 1 are attached (1<<0 | 1<<1 == 0x3)\n" + "> + *\n" + "> + * Note that you don't need to describe condition for \"no cable attached\"\n" + "> + * because when no adc_jack_cond is met, state = 0 is automatically chosen.\n" + "> + */\n" + "> +struct adc_jack_cond {\n" + "> +\tu32 state; /* extcon state value. 0 if invalid */\n" + "> +\tu32 min_adc;\n" + "> +\tu32 max_adc;\n" + "> +};\n" + "> +\n" + "> +/**\n" + "> + * struct adc_jack_pdata - platform data for adc jack device.\n" + "> + * @name\t- name of the extcon device. If null, \"adc-jack\" is used.\n" + "> + * @cable_names\t- array of cable names ending with null. If the array itself\n" + "> + *\t\tif null, extcon standard cable names are chosen.\n" + "> + * @adc_contition\t- array of struct adc_jack_cond conditions ending\n" + "> + *\t\t\twith .state = 0 entry. This describes how to decode\n" + "> + *\t\t\tadc values into extcon state.\n" + "> + * @irq\t\t- IRQ number that is triggerred by cable attach/detach\n" + "> + *\t\tevents. If irq = 0, use should manually update extcon state\n" + "> + *\t\twith extcon APIs.\n" + "> + * @irq_flags\t- irq flags used for the @irq\n" + "> + * @handling_delay_ms\t- in some devices, we need to read ADC value some\n" + "> + *\t\t\tmilli-seconds after the interrupt occurs. You may\n" + "> + *\t\t\tdescribe such delays with @handling_delay_ms, which\n" + "> + *\t\t\tis rounded-off by jiffies.\n" + "> + * @get_adc\t- the callback to read ADC value to identify cable states.\n" + "> + */\n" + "> +struct adc_jack_pdata {\n" + "> +\tconst char *name;\n" + "> +\tconst char *consumer_channel;\n" + "> +\t/*\n" + "> +\t * NULL if standard extcon names are used.\n" + "> +\t * The last entry should be NULL\n" + "> +\t */\n" + "> +\tconst char **cable_names;\n" + "> +\t/* The last entry's state should be 0 */\n" + "> +\tstruct adc_jack_cond *adc_condition;\n" + "> +\n" + "> +\tunsigned long irq_flags;\n" + "> +\tunsigned long handling_delay_ms; /* in ms */\n" + "> +\n" + "> +\t/* When we have ADC subsystem, this can be generalized. */\n" + "> +\tint (*get_adc)(u32 *value);\n" + "> +};\n" + "> +\n" + "> +#endif /* _EXTCON_ADC_JACK_H */\n" + "> -- \n" + "> 1.7.1\n" + "> \n" + "> \n" + "> \n" + "> \n" + "> \n" + "> \n" + "> \n" + "> \n" + "\303\277\303\264\303\250\302\272{.n\303\207+\302\211\302\267\302\237\302\256\302\211\302\255\302\206+%\302\212\303\213\303\277\302\261\303\251\303\235\302\266\027\302\245\302\212w\303\277\302\272{.n\303\207+\302\211\302\267\302\245\302\212{\302\261\303\276G\302\253\302\235\303\251\303\277\302\212{ay\302\272\035\303\212\302\207\303\232\302\231\303\253,j\a\302\255\302\242f\302\243\302\242\302\267h\302\232\302\217\303\257\302\201\303\252\303\277\302\221\303\252\303\247z_\303\250\302\256\003(\302\255\303\251\302\232\302\216\302\212\303\235\302\242j\"\302\235\303\272\032\302\266\033m\302\247\303\277\303\277\302\276\a\302\253\303\276G\302\253\302\235\303\251\303\277\302\242\302\270?\302\231\302\250\303\250\302\255\303\232&\302\243\303\270\302\247~\302\217\303\241\302\266iO\302\225\303\246\302\254z\302\267\302\232v\303\230^\024\004\032\302\266\033m\302\247\303\277\303\277\303\203\f\303\277\302\266\303\254\303\277\302\242\302\270?\302\226I\302\245" -b7b8af8acdbe63dff0f8a34b9e3d576f28e5fa90394cafb8bf3d61e24f4aa3c8 +1a6b71f41a429556563a8056e2b1b3bd9feaa0520a7c8383e172da0e0c50abd5
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.