diff for duplicates of <10387090.59171344230163413.JavaMail.weblogic@epml13> diff --git a/a/1.txt b/N1/1.txt index e0a2650..ce89c26 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,201 +1,362 @@ -PiBGcm9tOiBhbmlzaCBrdW1hciA8YW5pc2gxOTg1MTk4NTE5ODVAZ21haWwuY29tPg0KPiANCj4g -RXh0ZXJuYWwgY29ubmVjdG9yIGRldmljZXMgdGhhdCBkZWNpZGVzIGNvbm5lY3Rpb24gaW5mb3Jt -YXRpb24gYmFzZWQgb24NCj4gQURDIHZhbHVlcyBtYXkgdXNlIGFkYy1qYWNrIGRldmljZSBkcml2 -ZXIuIFRoZSB1c2VyIHNpbXBseSBuZWVkcyB0bw0KPiBwcm92aWRlIGEgdGFibGUgb2YgYWRjIHJh -bmdlIGFuZCBjb25uZWN0aW9uIHN0YXRlcy4gVGhlbiwgZXh0Y29uDQo+IGZyYW1ld29yayB3aWxs -IGF1dG9tYXRpY2FsbHkgbm90aWZ5IG90aGVycy4NCj4gDQo+IFNpZ25lZC1vZmYtYnk6IGFuaXNo -IGt1bWFyIDxhbmlzaC5zaW5naEBzYW1zdW5nLmNvbT4NCg0KU2lnbmVkLW9mZi1ieTogTXl1bmdK -b28gSGFtIDxteXVuZ2pvby5oYW1Ac2Ftc3VuZy5jb20+DQoNCj4gLS0tDQo+ICBkcml2ZXJzL2V4 -dGNvbi9LY29uZmlnICAgICAgICAgIHwgICAgNSArDQo+ICBkcml2ZXJzL2V4dGNvbi9NYWtlZmls -ZSAgICAgICAgIHwgICAgMSArDQo+ICBkcml2ZXJzL2V4dGNvbi9hZGNfamFjay5jICAgICAgIHwg -IDE4MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysNCj4gIGluY2x1ZGUv -bGludXgvZXh0Y29uL2FkY19qYWNrLmggfCAgMTA4ICsrKysrKysrKysrKysrKysrKysrKysrDQo+ -ICA0IGZpbGVzIGNoYW5nZWQsIDI5NyBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQ0KPiAg -Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZXh0Y29uL2FkY19qYWNrLmMNCj4gIGNyZWF0ZSBt -b2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5oDQo+IA0KPiBkaWZmIC0t -Z2l0IGEvZHJpdmVycy9leHRjb24vS2NvbmZpZyBiL2RyaXZlcnMvZXh0Y29uL0tjb25maWcNCj4g -aW5kZXggZTE3NWM4ZS4uNTk2ZTI3NyAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9leHRjb24vS2Nv -bmZpZw0KPiArKysgYi9kcml2ZXJzL2V4dGNvbi9LY29uZmlnDQo+IEBAIC0yMSw2ICsyMSwxMSBA -QCBjb25maWcgRVhUQ09OX0dQSU8NCj4gIAkgIFNheSBZIGhlcmUgdG8gZW5hYmxlIEdQSU8gYmFz -ZWQgZXh0Y29uIHN1cHBvcnQuIE5vdGUgdGhhdCBHUElPDQo+ICAJICBleHRjb24gc3VwcG9ydHMg -c2luZ2xlIHN0YXRlIHBlciBleHRjb24gaW5zdGFuY2UuDQo+ICANCj4gK2NvbmZpZyBFWFRDT05f -QURDX0pBQ0sNCj4gKyAgICAgICAgdHJpc3RhdGUgIkFEQyBKYWNrIGV4dGNvbiBzdXBwb3J0Ig0K -PiArICAgICAgICBoZWxwDQo+ICsgICAgICAgICAgU2F5IFkgaGVyZSB0byBlbmFibGUgZXh0Y29u -IGRldmljZSBkcml2ZXIgYmFzZWQgb24gQURDIHZhbHVlcy4NCj4gKw0KPiAgY29uZmlnIEVYVENP -Tl9NQVg3NzY5Mw0KPiAgCXRyaXN0YXRlICJNQVg3NzY5MyBFWFRDT04gU3VwcG9ydCINCj4gIAlk -ZXBlbmRzIG9uIE1GRF9NQVg3NzY5Mw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9leHRjb24vTWFr -ZWZpbGUgYi9kcml2ZXJzL2V4dGNvbi9NYWtlZmlsZQ0KPiBpbmRleCA4ODk2MWIzLi5kOTVjNWVh -IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL2V4dGNvbi9NYWtlZmlsZQ0KPiArKysgYi9kcml2ZXJz -L2V4dGNvbi9NYWtlZmlsZQ0KPiBAQCAtNCw2ICs0LDcgQEANCj4gIA0KPiAgb2JqLSQoQ09ORklH -X0VYVENPTikJCSs9IGV4dGNvbl9jbGFzcy5vDQo+ICBvYmotJChDT05GSUdfRVhUQ09OX0dQSU8p -CSs9IGV4dGNvbl9ncGlvLm8NCj4gK29iai0kKENPTkZJR19FWFRDT05fQURDX0pBQ0spICAgKz0g -YWRjX2phY2subw0KPiAgb2JqLSQoQ09ORklHX0VYVENPTl9NQVg3NzY5MykJKz0gZXh0Y29uLW1h -eDc3NjkzLm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fTUFYODk5NykJKz0gZXh0Y29uLW1heDg5 -OTcubw0KPiAgb2JqLSQoQ09ORklHX0VYVENPTl9BUklaT05BKQkrPSBleHRjb24tYXJpem9uYS5v -DQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2V4dGNvbi9hZGNfamFjay5jIGIvZHJpdmVycy9leHRj -b24vYWRjX2phY2suYw0KPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi5m -ZWY4MzM0DQo+IC0tLSAvZGV2L251bGwNCj4gKysrIGIvZHJpdmVycy9leHRjb24vYWRjX2phY2su -Yw0KPiBAQCAtMCwwICsxLDE4MyBAQA0KPiArLyoNCj4gKyAqIGRyaXZlcnMvZXh0Y29uL2FkY19q -YWNrLmMNCj4gKyAqDQo+ICsgKiBBbmFsb2cgSmFjayBleHRjb24gZHJpdmVyIHdpdGggQURDLWJh -c2VkIGRldGVjdGlvbiBjYXBhYmlsaXR5Lg0KPiArICoNCj4gKyAqIENvcHlyaWdodCAoQykgMjAx -MiBTYW1zdW5nIEVsZWN0cm9uaWNzDQo+ICsgKiBNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBz -YW1zdW5nLmNvbT4NCj4gKyAqDQo+ICsgKiBNb2RpZmllZCBmb3IgY2FsbGluZyB0byBJSU8gdG8g -Z2V0IGFkYyBieSA8YW5pc2guc2luZ2hAc2Ftc3VuZy5jb20+DQo+ICsgKg0KPiArICogVGhpcyBw -cm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBt -b2RpZnkNCj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGlj -IExpY2Vuc2UgdmVyc2lvbiAyIGFzDQo+ICsgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh -cmUgRm91bmRhdGlvbi4NCj4gKyAqDQo+ICsgKi8NCj4gKw0KPiArI2luY2x1ZGUgPGxpbnV4L3Ns -YWIuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9w -bGF0Zm9ybV9kZXZpY2UuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4NCj4gKyNp -bmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9paW8vY29uc3Vt -ZXIuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9leHRjb24vYWRjX2phY2suaD4NCj4gKyNpbmNsdWRl -IDxsaW51eC9leHRjb24uaD4NCj4gKw0KPiArc3RhdGljIHZvaWQgYWRjX2phY2tfaGFuZGxlcihz -dHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspDQo+ICt7DQo+ICsJc3RydWN0IGFkY19qYWNrX2RhdGEg -KmRhdGEgPSBjb250YWluZXJfb2YodG9fZGVsYXllZF93b3JrKHdvcmspLA0KPiArCQkJCQkJICBz -dHJ1Y3QgYWRjX2phY2tfZGF0YSwNCj4gKwkJCQkJCSAgaGFuZGxlcik7DQo+ICsJdTMyIHN0YXRl -ID0gMDsNCj4gKwlpbnQgcmV0LCBhZGNfdmFsOw0KPiArCWludCBpOw0KPiArDQo+ICsJaWYgKCFk -YXRhLT5yZWFkeSkNCj4gKwkJcmV0dXJuOw0KPiArDQo+ICsJcmV0ID0gaWlvX3JlYWRfY2hhbm5l -bF9yYXcoZGF0YS0+Y2hhbiwgJmFkY192YWwpOw0KPiArCWlmIChyZXQgPCAwKSB7DQo+ICsJCWRl -dl9lcnIoZGF0YS0+ZWRldi5kZXYsICJyZWFkIGNoYW5uZWwoKSBlcnJvcjogJWRcbiIsIHJldCk7 -DQo+ICsJCXJldHVybjsNCj4gKwl9DQo+ICsNCj4gKwkvKiBHZXQgc3RhdGUgZnJvbSBhZGMgdmFs -dWUgd2l0aCBhZGNfY29uZGl0aW9uICovDQo+ICsJZm9yIChpID0gMDsgaSA8IGRhdGEtPm51bV9j -b25kaXRpb25zOyBpKyspIHsNCj4gKwkJc3RydWN0IGFkY19qYWNrX2NvbmQgKmRlZiA9ICZkYXRh -LT5hZGNfY29uZGl0aW9uW2ldOw0KPiArCQlpZiAoIWRlZi0+c3RhdGUpDQo+ICsJCQlicmVhazsN -Cj4gKwkJaWYgKGRlZi0+bWluX2FkYyA8PSBhZGNfdmFsICYmIGRlZi0+bWF4X2FkYyA+PSBhZGNf -dmFsKSB7DQo+ICsJCQlzdGF0ZSA9IGRlZi0+c3RhdGU7DQo+ICsJCQlicmVhazsNCj4gKwkJfQ0K -PiArCX0NCj4gKwkvKiBpZiBubyBkZWYgaGFzIG1ldCwgaXQgbWVhbnMgc3RhdGUgPSAwIChubyBj -YWJsZXMgYXR0YWNoZWQpICovDQo+ICsNCj4gKwlleHRjb25fc2V0X3N0YXRlKCZkYXRhLT5lZGV2 -LCBzdGF0ZSk7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpcnFyZXR1cm5fdCBhZGNfamFja19pcnFf -dGhyZWFkKGludCBpcnEsIHZvaWQgKl9kYXRhKQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19k -YXRhICpkYXRhID0gX2RhdGE7DQo+ICsNCj4gKwlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmRhdGEt -PmhhbmRsZXIsIGRhdGEtPmhhbmRsaW5nX2RlbGF5KTsNCj4gKw0KPiArCXJldHVybiBJUlFfSEFO -RExFRDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBhZGNfamFja19wcm9iZShzdHJ1Y3QgcGxh -dGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRhICpkYXRh -Ow0KPiArCXN0cnVjdCBhZGNfamFja19wZGF0YSAqcGRhdGEgPSBwZGV2LT5kZXYucGxhdGZvcm1f -ZGF0YTsNCj4gKwlpbnQgaSwgZXJyID0gMDsNCj4gKw0KPiArCWRhdGEgPSBremFsbG9jKHNpemVv -ZihzdHJ1Y3QgYWRjX2phY2tfZGF0YSksIEdGUF9LRVJORUwpOw0KPiArCWlmICghZGF0YSkNCj4g -KwkJcmV0dXJuIC1FTk9NRU07DQo+ICsNCj4gKwlkYXRhLT5lZGV2Lm5hbWUgPSBwZGF0YS0+bmFt -ZTsNCj4gKw0KPiArCWlmIChwZGF0YS0+Y2FibGVfbmFtZXMpDQo+ICsJCWRhdGEtPmVkZXYuc3Vw -cG9ydGVkX2NhYmxlID0gcGRhdGEtPmNhYmxlX25hbWVzOw0KPiArCWVsc2UNCj4gKwkJZGF0YS0+ -ZWRldi5zdXBwb3J0ZWRfY2FibGUgPSBleHRjb25fY2FibGVfbmFtZTsNCj4gKw0KPiArCS8qIENo -ZWNrIHRoZSBsZW5ndGggb2YgYXJyYXkgYW5kIHNldCBudW1fY2FibGVzICovDQo+ICsJZm9yIChp -ID0gMDsgZGF0YS0+ZWRldi5zdXBwb3J0ZWRfY2FibGVbaV07IGkrKykNCj4gKwkJOw0KPiArCWlm -IChpID09IDAgfHwgaSA+IFNVUFBPUlRFRF9DQUJMRV9NQVgpIHsNCj4gKwkJZXJyID0gLUVJTlZB -TDsNCj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZXJyb3I6IHBkYXRhLT5jYWJsZV9uYW1lcyBz -aXplID0gJWRcbiIsDQo+ICsJCQlpIC0gMSk7DQo+ICsJCWdvdG8gZXJyX2FsbG9jOw0KPiArCX0N -Cj4gKwlkYXRhLT5udW1fY2FibGVzID0gaTsNCj4gKw0KPiArCWlmICghcGRhdGEtPmFkY19jb25k -aXRpb24gfHwNCj4gKwkgICAgIXBkYXRhLT5hZGNfY29uZGl0aW9uWzBdLnN0YXRlKSB7DQo+ICsJ -CWVyciA9IC1FSU5WQUw7DQo+ICsJCWRldl9lcnIoJnBkZXYtPmRldiwgImVycm9yOiBhZGNfY29u -ZGl0aW9uIG5vdCBkZWZpbmVkLlxuIik7DQo+ICsJCWdvdG8gZXJyX2FsbG9jOw0KPiArCX0NCj4g -KwlkYXRhLT5hZGNfY29uZGl0aW9uID0gcGRhdGEtPmFkY19jb25kaXRpb247DQo+ICsNCj4gKwkv -KiBDaGVjayB0aGUgbGVuZ3RoIG9mIGFycmF5IGFuZCBzZXQgbnVtX2NvbmRpdGlvbnMgKi8NCj4g -Kwlmb3IgKGkgPSAwOyBkYXRhLT5hZGNfY29uZGl0aW9uW2ldLnN0YXRlOyBpKyspDQo+ICsJCTsN -Cj4gKwlkYXRhLT5udW1fY29uZGl0aW9ucyA9IGk7DQo+ICsNCj4gKwlkYXRhLT5jaGFuID0gaWlv -X2NoYW5uZWxfZ2V0KGRldl9uYW1lKCZwZGV2LT5kZXYpLA0KPiArCQkJCQkJcGRhdGEtPmNvbnN1 -bWVyX2NoYW5uZWwpOw0KPiArCWRhdGEtPmhhbmRsaW5nX2RlbGF5ID0gbXNlY3NfdG9famlmZmll -cyhwZGF0YS0+aGFuZGxpbmdfZGVsYXlfbXMpOw0KPiArDQo+ICsJSU5JVF9ERUxBWUVEX1dPUktf -REVGRVJSQUJMRSgmZGF0YS0+aGFuZGxlciwgYWRjX2phY2tfaGFuZGxlcik7DQo+ICsNCj4gKwlw -bGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYXRhKTsNCj4gKw0KPiArCWlmIChwZGF0YS0+aXJx -KSB7DQo+ICsJCWRhdGEtPmlycSA9IHBkYXRhLT5pcnE7DQo+ICsNCj4gKwkJZXJyID0gcmVxdWVz -dF90aHJlYWRlZF9pcnEoZGF0YS0+aXJxLCBOVUxMLA0KPiArCQkJCQkgICBhZGNfamFja19pcnFf -dGhyZWFkLA0KPiArCQkJCQkgICBwZGF0YS0+aXJxX2ZsYWdzLCBwZGF0YS0+bmFtZSwNCj4gKwkJ -CQkJICAgZGF0YSk7DQo+ICsNCj4gKwkJaWYgKGVycikgew0KPiArCQkJZGV2X2VycigmcGRldi0+ -ZGV2LCAiZXJyb3I6IGlycSAlZFxuIiwgZGF0YS0+aXJxKTsNCj4gKwkJCWVyciA9IC1FSU5WQUw7 -DQo+ICsJCQlnb3RvIGVycl9pbml0d29yazsNCj4gKwkJfQ0KPiArCX0NCj4gKwllcnIgPSBleHRj -b25fZGV2X3JlZ2lzdGVyKCZkYXRhLT5lZGV2LCAmcGRldi0+ZGV2KTsNCj4gKwlpZiAoZXJyKQ0K -PiArCQlnb3RvIGVycl9pcnE7DQo+ICsNCj4gKwlkYXRhLT5yZWFkeSA9IHRydWU7DQo+ICsNCj4g -Kwlnb3RvIG91dDsNCj4gKw0KPiArZXJyX2lycToNCj4gKwlpZiAoZGF0YS0+aXJxKQ0KPiArCQlm -cmVlX2lycShkYXRhLT5pcnEsIGRhdGEpOw0KPiArZXJyX2luaXR3b3JrOg0KPiArCWNhbmNlbF9k -ZWxheWVkX3dvcmtfc3luYygmZGF0YS0+aGFuZGxlcik7DQo+ICtlcnJfYWxsb2M6DQo+ICsJa2Zy -ZWUoZGF0YSk7DQo+ICtvdXQ6DQo+ICsJcmV0dXJuIGVycjsNCj4gK30NCj4gKw0KPiArc3RhdGlj -IGludCBfX2RldmV4aXQgYWRjX2phY2tfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk -ZXYpDQo+ICt7DQo+ICsJc3RydWN0IGFkY19qYWNrX2RhdGEgKmRhdGEgPSBwbGF0Zm9ybV9nZXRf -ZHJ2ZGF0YShwZGV2KTsNCj4gKw0KPiArCWV4dGNvbl9kZXZfdW5yZWdpc3RlcigmZGF0YS0+ZWRl -dik7DQo+ICsJaWYgKGRhdGEtPmlycSkNCj4gKwkJZnJlZV9pcnEoZGF0YS0+aXJxLCBkYXRhKTsN -Cj4gKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsNCj4gKwlrZnJlZShkYXRhKTsN -Cj4gKw0KPiArCXJldHVybiAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3Jt -X2RyaXZlciBhZGNfamFja19kcml2ZXIgPSB7DQo+ICsJLnByb2JlCQk9IGFkY19qYWNrX3Byb2Jl -LA0KPiArCS5yZW1vdmUJCT0gX19kZXZleGl0X3AoYWRjX2phY2tfcmVtb3ZlKSwNCj4gKwkuZHJp -dmVyCQk9IHsNCj4gKwkJLm5hbWUJPSAiYWRjLWphY2siLA0KPiArCQkub3duZXIJPSBUSElTX01P -RFVMRSwNCj4gKwl9LA0KPiArfTsNCj4gKw0KPiArc3RhdGljIGludCBfX2luaXQgYWRjX2phY2tf -aW5pdCh2b2lkKQ0KPiArew0KPiArCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmFk -Y19qYWNrX2RyaXZlcik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIF9fZXhpdCBhZGNfamFj -a19leGl0KHZvaWQpDQo+ICt7DQo+ICsJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmFkY19q -YWNrX2RyaXZlcik7DQo+ICt9DQo+ICsNCj4gK21vZHVsZV9pbml0KGFkY19qYWNrX2luaXQpOw0K -PiArbW9kdWxlX2V4aXQoYWRjX2phY2tfZXhpdCk7DQo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xp -bnV4L2V4dGNvbi9hZGNfamFjay5oIGIvaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaA0K -PiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi40ZDZhMWY3DQo+IC0tLSAv -ZGV2L251bGwNCj4gKysrIGIvaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaA0KPiBAQCAt -MCwwICsxLDEwOCBAQA0KPiArLyoNCj4gKyAqIGluY2x1ZGUvbGludXgvZXh0Y29uL2FkY19qYWNr -LmgNCj4gKyAqDQo+ICsgKiBBbmFsb2cgSmFjayBleHRjb24gZHJpdmVyIHdpdGggQURDLWJhc2Vk -IGRldGVjdGlvbiBjYXBhYmlsaXR5Lg0KPiArICoNCj4gKyAqIENvcHlyaWdodCAoQykgMjAxMiBT -YW1zdW5nIEVsZWN0cm9uaWNzDQo+ICsgKiBNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBzYW1z -dW5nLmNvbT4NCj4gKyAqDQo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91 -IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQ0KPiArICogaXQgdW5kZXIgdGhlIHRl -cm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMNCj4gKyAq -IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLg0KPiArICoNCj4gKyAq -Lw0KPiArDQo+ICsjaWZuZGVmIF9FWFRDT05fQURDX0pBQ0tfSF8NCj4gKyNkZWZpbmUgX0VYVENP -Tl9BRENfSkFDS19IXyBfX0ZJTEVfXw0KPiArDQo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ -DQo+ICsjaW5jbHVkZSA8bGludXgvZXh0Y29uLmg+DQo+ICsNCj4gKy8qKg0KPiArICogc3RydWN0 -IGFkY19qYWNrX2RhdGEgLSBpbnRlcm5hbCBkYXRhIGZvciBhZGNfamFjayBkZXZpY2UgZHJpdmVy -DQo+ICsgKiBAZWRldgktIGV4dGNvbiBkZXZpY2UuDQo+ICsgKiBAY2FibGVfbmFtZXMJLSBsaXN0 -IG9mIHN1cHBvcnRlZCBjYWJsZXMuDQo+ICsgKiBAbnVtX2NhYmxlcwktIHNpemUgb2YgY2FibGVf -bmFtZXMuDQo+ICsgKiBAYWRjX2NvbmRpdGlvbgktIGxpc3Qgb2YgYWRjIHZhbHVlIGNvbmRpdGlv -bnMuDQo+ICsgKiBAbnVtX2NvbmRpdGlvbgktIHNpemUgb2YgYWRjX2NvbmRpdGlvbi4NCj4gKyAq -IEBpcnEJCS0gaXJxIG51bWJlciBvZiBhdHRhY2gvZGV0YWNoIGV2ZW50ICgwIGlmIG5vdCBleGlz -dCkuDQo+ICsgKiBAaGFuZGxpbmdfZGVsYXkJLSBpbnRlcnJ1cHQgaGFuZGxlciB3aWxsIHNjaGVk -dWxlIGV4dGNvbiBldmVudA0KPiArICoJCQloYW5kbGluZyBhdCBoYW5kbGluZ19kZWxheSBqaWZm -aWVzLg0KPiArICogQGhhbmRsZXIJLSBleHRjb24gZXZlbnQgaGFuZGxlciBjYWxsZWQgYnkgaW50 -ZXJydXB0IGhhbmRsZXIuDQo+ICsgKiBAY2hhbgktIGlpbyBjaGFubmVsIGJlaW5nIHF1ZXJpZWQu -DQo+ICsgKiBAcmVhZHkJLSB0cnVlIGlmIGl0IGlzIHNhZmUgdG8gcnVuIGhhbmRsZXIuDQo+ICsg -Ki8NCj4gK3N0cnVjdCBhZGNfamFja19kYXRhIHsNCj4gKwlzdHJ1Y3QgZXh0Y29uX2RldiBlZGV2 -Ow0KPiArDQo+ICsJY29uc3QgY2hhciAqKmNhYmxlX25hbWVzOw0KPiArCWludCBudW1fY2FibGVz -Ow0KPiArCXN0cnVjdCBhZGNfamFja19jb25kICphZGNfY29uZGl0aW9uOw0KPiArCWludCBudW1f -Y29uZGl0aW9uczsNCj4gKw0KPiArCWludCBpcnE7DQo+ICsJdW5zaWduZWQgbG9uZyBoYW5kbGlu -Z19kZWxheTsgLyogaW4gamlmZmllcyAqLw0KPiArCXN0cnVjdCBkZWxheWVkX3dvcmsgaGFuZGxl -cjsNCj4gKw0KPiArCXN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbjsNCj4gKw0KPiArCWJvb2wgcmVh -ZHk7DQo+ICt9Ow0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVjdCBhZGNfamFja19jb25kIC0gY29u -ZGl0aW9uIHRvIHVzZSBhbiBleHRjb24gc3RhdGUNCj4gKyAqIEBzdGF0ZQktIHRoZSBjb3JyZXNw -b25kaW5nIGV4dGNvbiBzdGF0ZSAoaWYgMCwgdGhpcyBzdHJ1Y3QgZGVub3Rlcw0KPiArICoJCXRo -ZSBsYXN0IGFkY19qYWNrX2NvbmQgZWxlbWVudCBhbW9uZyB0aGUgYXJyYXkpDQo+ICsgKiBAbWlu -X2FkYwktIG1pbiBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9uDQo+ICsgKiBAbWF4X2FkYwkt -IG1heCBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9uDQo+ICsgKg0KPiArICogRm9yIGV4YW1w -bGUsIGlmIHsgLnN0YXRlID0gMHgzLCAubWluX2FkYyA9IDEwMCwgLm1heF9hZGMgPSAyMDB9LCBp -dCBtZWFucw0KPiArICogdGhhdCBpZiBBREMgdmFsdWUgaXMgYmV0d2VlbiAoaW5jbHVzaXZlKSAx -MDAgYW5kIDIwMCwgdGhhbiB0aGUgY2FibGUgMCBhbmQNCj4gKyAqIDEgYXJlIGF0dGFjaGVkICgx -PDwwIHwgMTw8MSA9PSAweDMpDQo+ICsgKg0KPiArICogTm90ZSB0aGF0IHlvdSBkb24ndCBuZWVk -IHRvIGRlc2NyaWJlIGNvbmRpdGlvbiBmb3IgIm5vIGNhYmxlIGF0dGFjaGVkIg0KPiArICogYmVj -YXVzZSB3aGVuIG5vIGFkY19qYWNrX2NvbmQgaXMgbWV0LCBzdGF0ZSA9IDAgaXMgYXV0b21hdGlj -YWxseSBjaG9zZW4uDQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFja19jb25kIHsNCj4gKwl1MzIg -c3RhdGU7IC8qIGV4dGNvbiBzdGF0ZSB2YWx1ZS4gMCBpZiBpbnZhbGlkICovDQo+ICsJdTMyIG1p -bl9hZGM7DQo+ICsJdTMyIG1heF9hZGM7DQo+ICt9Ow0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVj -dCBhZGNfamFja19wZGF0YSAtIHBsYXRmb3JtIGRhdGEgZm9yIGFkYyBqYWNrIGRldmljZS4NCj4g -KyAqIEBuYW1lCS0gbmFtZSBvZiB0aGUgZXh0Y29uIGRldmljZS4gSWYgbnVsbCwgImFkYy1qYWNr -IiBpcyB1c2VkLg0KPiArICogQGNvbnN1bWVyX2NoYW5uZWwgLSBVbmlxdWUgbmFtZSB0byBpZGVu -dGlmeSB0aGUgY2hhbm5lbCBvbiB0aGUgY29uc3VtZXINCj4gKyAqICAgICAgICAgICAgICAgICAg -IHNpZGUuIFRoaXMgdHlwaWNhbGx5IGRlc2NyaWJlcyB0aGUgY2hhbm5lbHMgdXNlIHdpdGhpbg0K -PiArICogICAgICAgICAgICAgICAgICAgdGhlIGNvbnN1bWVyLiBFLmcuICdiYXR0ZXJ5X3ZvbHRh -Z2UnDQo+ICsgKiBAY2FibGVfbmFtZXMJLSBhcnJheSBvZiBjYWJsZSBuYW1lcyBlbmRpbmcgd2l0 -aCBudWxsLiBJZiB0aGUgYXJyYXkgaXRzZWxmDQo+ICsgKgkJaWYgbnVsbCwgZXh0Y29uIHN0YW5k -YXJkIGNhYmxlIG5hbWVzIGFyZSBjaG9zZW4uDQo+ICsgKiBAYWRjX2NvbnRpdGlvbgktIGFycmF5 -IG9mIHN0cnVjdCBhZGNfamFja19jb25kIGNvbmRpdGlvbnMgZW5kaW5nDQo+ICsgKgkJCXdpdGgg -LnN0YXRlID0gMCBlbnRyeS4gVGhpcyBkZXNjcmliZXMgaG93IHRvIGRlY29kZQ0KPiArICoJCQlh -ZGMgdmFsdWVzIGludG8gZXh0Y29uIHN0YXRlLg0KPiArICogQGlycQkJLSBJUlEgbnVtYmVyIHRo -YXQgaXMgdHJpZ2dlcnJlZCBieSBjYWJsZSBhdHRhY2gvZGV0YWNoDQo+ICsgKgkJZXZlbnRzLiBJ -ZiBpcnEgPSAwLCB1c2Ugc2hvdWxkIG1hbnVhbGx5IHVwZGF0ZSBleHRjb24gc3RhdGUNCj4gKyAq -CQl3aXRoIGV4dGNvbiBBUElzLg0KPiArICogQGlycV9mbGFncwktIGlycSBmbGFncyB1c2VkIGZv -ciB0aGUgQGlycQ0KPiArICogQGhhbmRsaW5nX2RlbGF5X21zCS0gaW4gc29tZSBkZXZpY2VzLCB3 -ZSBuZWVkIHRvIHJlYWQgQURDIHZhbHVlIHNvbWUNCj4gKyAqCQkJbWlsbGktc2Vjb25kcyBhZnRl -ciB0aGUgaW50ZXJydXB0IG9jY3Vycy4gWW91IG1heQ0KPiArICoJCQlkZXNjcmliZSBzdWNoIGRl -bGF5cyB3aXRoIEBoYW5kbGluZ19kZWxheV9tcywgd2hpY2gNCj4gKyAqCQkJaXMgcm91bmRlZC1v -ZmYgYnkgamlmZmllcy4NCj4gKyAqLw0KPiArc3RydWN0IGFkY19qYWNrX3BkYXRhIHsNCj4gKwlj -b25zdCBjaGFyICpuYW1lOw0KPiArCWNvbnN0IGNoYXIgKmNvbnN1bWVyX2NoYW5uZWw7DQo+ICsJ -LyoNCj4gKwkgKiBOVUxMIGlmIHN0YW5kYXJkIGV4dGNvbiBuYW1lcyBhcmUgdXNlZC4NCj4gKwkg -KiBUaGUgbGFzdCBlbnRyeSBzaG91bGQgYmUgTlVMTA0KPiArCSAqLw0KPiArCWNvbnN0IGNoYXIg -KipjYWJsZV9uYW1lczsNCj4gKwkvKiBUaGUgbGFzdCBlbnRyeSdzIHN0YXRlIHNob3VsZCBiZSAw -ICovDQo+ICsJc3RydWN0IGFkY19qYWNrX2NvbmQgKmFkY19jb25kaXRpb247DQo+ICsNCj4gKwlp -bnQgaXJxOyAvKiBKYWNrIGluc2VydGlvbi9yZW1vdmFsIGludGVycnVwdCAqLw0KPiArCXVuc2ln -bmVkIGxvbmcgaXJxX2ZsYWdzOw0KPiArCXVuc2lnbmVkIGxvbmcgaGFuZGxpbmdfZGVsYXlfbXM7 -IC8qIGluIG1zICovDQo+ICt9Ow0KPiArDQo+ICsjZW5kaWYgLyogX0VYVENPTl9BRENfSkFDS19I -ICovDQo+IC0tIA0KPiAxLjcuMQ0KPiANCj4gDQo+IA0KPiANCj4gICAgICAgIA0KPiAgIA0KPiAg -ICAgICAgICANCj4gDQo= +> 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. +> +> Signed-off-by: anish kumar <anish.singh@samsung.com> + +Signed-off-by: MyungJoo Ham <myungjoo.ham@samsung.com> + +> --- +> drivers/extcon/Kconfig | 5 + +> drivers/extcon/Makefile | 1 + +> drivers/extcon/adc_jack.c | 183 +++++++++++++++++++++++++++++++++++++++ +> include/linux/extcon/adc_jack.h | 108 +++++++++++++++++++++++ +> 4 files changed, 297 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..fef8334 +> --- /dev/null +> +++ b/drivers/extcon/adc_jack.c +> @@ -0,0 +1,183 @@ +> +/* +> + * 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> +> + +> +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; +> + +> + if (!data->ready) +> + return; +> + +> + 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 = kzalloc(sizeof(struct adc_jack_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); +> + data->handling_delay = msecs_to_jiffies(pdata->handling_delay_ms); +> + +> + INIT_DELAYED_WORK_DEFERRABLE(&data->handler, adc_jack_handler); +> + +> + platform_set_drvdata(pdev, data); +> + +> + if (pdata->irq) { +> + data->irq = pdata->irq; +> + +> + err = request_threaded_irq(data->irq, NULL, +> + 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_initwork; +> + } +> + } +> + err = extcon_dev_register(&data->edev, &pdev->dev); +> + if (err) +> + goto err_irq; +> + +> + data->ready = true; +> + +> + goto out; +> + +> +err_irq: +> + if (data->irq) +> + free_irq(data->irq, data); +> +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); +> + platform_set_drvdata(pdev, NULL); +> + kfree(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, +> + }, +> +}; +> + +> +static int __init adc_jack_init(void) +> +{ +> + return platform_driver_register(&adc_jack_driver); +> +} +> + +> +static void __exit adc_jack_exit(void) +> +{ +> + platform_driver_unregister(&adc_jack_driver); +> +} +> + +> +module_init(adc_jack_init); +> +module_exit(adc_jack_exit); +> diff --git a/include/linux/extcon/adc_jack.h b/include/linux/extcon/adc_jack.h +> new file mode 100644 +> index 0000000..4d6a1f7 +> --- /dev/null +> +++ b/include/linux/extcon/adc_jack.h +> @@ -0,0 +1,108 @@ +> +/* +> + * 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_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. +> + * @ready - true if it is safe to run handler. +> + */ +> +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; +> + +> + bool ready; +> +}; +> + +> +/** +> + * 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 - 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. +> + */ +> +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; +> + +> + int irq; /* Jack insertion/removal interrupt */ +> + unsigned long irq_flags; +> + unsigned long handling_delay_ms; /* in ms */ +> +}; +> + +> +#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 6057661..05546be 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -9,206 +9,367 @@ " ANISH KUMAR <anish.singh@samsung.com>\0" "\00:1\0" "b\0" - "PiBGcm9tOiBhbmlzaCBrdW1hciA8YW5pc2gxOTg1MTk4NTE5ODVAZ21haWwuY29tPg0KPiANCj4g\n" - "RXh0ZXJuYWwgY29ubmVjdG9yIGRldmljZXMgdGhhdCBkZWNpZGVzIGNvbm5lY3Rpb24gaW5mb3Jt\n" - "YXRpb24gYmFzZWQgb24NCj4gQURDIHZhbHVlcyBtYXkgdXNlIGFkYy1qYWNrIGRldmljZSBkcml2\n" - "ZXIuIFRoZSB1c2VyIHNpbXBseSBuZWVkcyB0bw0KPiBwcm92aWRlIGEgdGFibGUgb2YgYWRjIHJh\n" - "bmdlIGFuZCBjb25uZWN0aW9uIHN0YXRlcy4gVGhlbiwgZXh0Y29uDQo+IGZyYW1ld29yayB3aWxs\n" - "IGF1dG9tYXRpY2FsbHkgbm90aWZ5IG90aGVycy4NCj4gDQo+IFNpZ25lZC1vZmYtYnk6IGFuaXNo\n" - "IGt1bWFyIDxhbmlzaC5zaW5naEBzYW1zdW5nLmNvbT4NCg0KU2lnbmVkLW9mZi1ieTogTXl1bmdK\n" - "b28gSGFtIDxteXVuZ2pvby5oYW1Ac2Ftc3VuZy5jb20+DQoNCj4gLS0tDQo+ICBkcml2ZXJzL2V4\n" - "dGNvbi9LY29uZmlnICAgICAgICAgIHwgICAgNSArDQo+ICBkcml2ZXJzL2V4dGNvbi9NYWtlZmls\n" - "ZSAgICAgICAgIHwgICAgMSArDQo+ICBkcml2ZXJzL2V4dGNvbi9hZGNfamFjay5jICAgICAgIHwg\n" - "IDE4MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysNCj4gIGluY2x1ZGUv\n" - "bGludXgvZXh0Y29uL2FkY19qYWNrLmggfCAgMTA4ICsrKysrKysrKysrKysrKysrKysrKysrDQo+\n" - "ICA0IGZpbGVzIGNoYW5nZWQsIDI5NyBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQ0KPiAg\n" - "Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZXh0Y29uL2FkY19qYWNrLmMNCj4gIGNyZWF0ZSBt\n" - "b2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L2V4dGNvbi9hZGNfamFjay5oDQo+IA0KPiBkaWZmIC0t\n" - "Z2l0IGEvZHJpdmVycy9leHRjb24vS2NvbmZpZyBiL2RyaXZlcnMvZXh0Y29uL0tjb25maWcNCj4g\n" - "aW5kZXggZTE3NWM4ZS4uNTk2ZTI3NyAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9leHRjb24vS2Nv\n" - "bmZpZw0KPiArKysgYi9kcml2ZXJzL2V4dGNvbi9LY29uZmlnDQo+IEBAIC0yMSw2ICsyMSwxMSBA\n" - "QCBjb25maWcgRVhUQ09OX0dQSU8NCj4gIAkgIFNheSBZIGhlcmUgdG8gZW5hYmxlIEdQSU8gYmFz\n" - "ZWQgZXh0Y29uIHN1cHBvcnQuIE5vdGUgdGhhdCBHUElPDQo+ICAJICBleHRjb24gc3VwcG9ydHMg\n" - "c2luZ2xlIHN0YXRlIHBlciBleHRjb24gaW5zdGFuY2UuDQo+ICANCj4gK2NvbmZpZyBFWFRDT05f\n" - "QURDX0pBQ0sNCj4gKyAgICAgICAgdHJpc3RhdGUgIkFEQyBKYWNrIGV4dGNvbiBzdXBwb3J0Ig0K\n" - "PiArICAgICAgICBoZWxwDQo+ICsgICAgICAgICAgU2F5IFkgaGVyZSB0byBlbmFibGUgZXh0Y29u\n" - "IGRldmljZSBkcml2ZXIgYmFzZWQgb24gQURDIHZhbHVlcy4NCj4gKw0KPiAgY29uZmlnIEVYVENP\n" - "Tl9NQVg3NzY5Mw0KPiAgCXRyaXN0YXRlICJNQVg3NzY5MyBFWFRDT04gU3VwcG9ydCINCj4gIAlk\n" - "ZXBlbmRzIG9uIE1GRF9NQVg3NzY5Mw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9leHRjb24vTWFr\n" - "ZWZpbGUgYi9kcml2ZXJzL2V4dGNvbi9NYWtlZmlsZQ0KPiBpbmRleCA4ODk2MWIzLi5kOTVjNWVh\n" - "IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL2V4dGNvbi9NYWtlZmlsZQ0KPiArKysgYi9kcml2ZXJz\n" - "L2V4dGNvbi9NYWtlZmlsZQ0KPiBAQCAtNCw2ICs0LDcgQEANCj4gIA0KPiAgb2JqLSQoQ09ORklH\n" - "X0VYVENPTikJCSs9IGV4dGNvbl9jbGFzcy5vDQo+ICBvYmotJChDT05GSUdfRVhUQ09OX0dQSU8p\n" - "CSs9IGV4dGNvbl9ncGlvLm8NCj4gK29iai0kKENPTkZJR19FWFRDT05fQURDX0pBQ0spICAgKz0g\n" - "YWRjX2phY2subw0KPiAgb2JqLSQoQ09ORklHX0VYVENPTl9NQVg3NzY5MykJKz0gZXh0Y29uLW1h\n" - "eDc3NjkzLm8NCj4gIG9iai0kKENPTkZJR19FWFRDT05fTUFYODk5NykJKz0gZXh0Y29uLW1heDg5\n" - "OTcubw0KPiAgb2JqLSQoQ09ORklHX0VYVENPTl9BUklaT05BKQkrPSBleHRjb24tYXJpem9uYS5v\n" - "DQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2V4dGNvbi9hZGNfamFjay5jIGIvZHJpdmVycy9leHRj\n" - "b24vYWRjX2phY2suYw0KPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi5m\n" - "ZWY4MzM0DQo+IC0tLSAvZGV2L251bGwNCj4gKysrIGIvZHJpdmVycy9leHRjb24vYWRjX2phY2su\n" - "Yw0KPiBAQCAtMCwwICsxLDE4MyBAQA0KPiArLyoNCj4gKyAqIGRyaXZlcnMvZXh0Y29uL2FkY19q\n" - "YWNrLmMNCj4gKyAqDQo+ICsgKiBBbmFsb2cgSmFjayBleHRjb24gZHJpdmVyIHdpdGggQURDLWJh\n" - "c2VkIGRldGVjdGlvbiBjYXBhYmlsaXR5Lg0KPiArICoNCj4gKyAqIENvcHlyaWdodCAoQykgMjAx\n" - "MiBTYW1zdW5nIEVsZWN0cm9uaWNzDQo+ICsgKiBNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBz\n" - "YW1zdW5nLmNvbT4NCj4gKyAqDQo+ICsgKiBNb2RpZmllZCBmb3IgY2FsbGluZyB0byBJSU8gdG8g\n" - "Z2V0IGFkYyBieSA8YW5pc2guc2luZ2hAc2Ftc3VuZy5jb20+DQo+ICsgKg0KPiArICogVGhpcyBw\n" - "cm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBt\n" - "b2RpZnkNCj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGlj\n" - "IExpY2Vuc2UgdmVyc2lvbiAyIGFzDQo+ICsgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh\n" - "cmUgRm91bmRhdGlvbi4NCj4gKyAqDQo+ICsgKi8NCj4gKw0KPiArI2luY2x1ZGUgPGxpbnV4L3Ns\n" - "YWIuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9w\n" - "bGF0Zm9ybV9kZXZpY2UuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4NCj4gKyNp\n" - "bmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9paW8vY29uc3Vt\n" - "ZXIuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9leHRjb24vYWRjX2phY2suaD4NCj4gKyNpbmNsdWRl\n" - "IDxsaW51eC9leHRjb24uaD4NCj4gKw0KPiArc3RhdGljIHZvaWQgYWRjX2phY2tfaGFuZGxlcihz\n" - "dHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspDQo+ICt7DQo+ICsJc3RydWN0IGFkY19qYWNrX2RhdGEg\n" - "KmRhdGEgPSBjb250YWluZXJfb2YodG9fZGVsYXllZF93b3JrKHdvcmspLA0KPiArCQkJCQkJICBz\n" - "dHJ1Y3QgYWRjX2phY2tfZGF0YSwNCj4gKwkJCQkJCSAgaGFuZGxlcik7DQo+ICsJdTMyIHN0YXRl\n" - "ID0gMDsNCj4gKwlpbnQgcmV0LCBhZGNfdmFsOw0KPiArCWludCBpOw0KPiArDQo+ICsJaWYgKCFk\n" - "YXRhLT5yZWFkeSkNCj4gKwkJcmV0dXJuOw0KPiArDQo+ICsJcmV0ID0gaWlvX3JlYWRfY2hhbm5l\n" - "bF9yYXcoZGF0YS0+Y2hhbiwgJmFkY192YWwpOw0KPiArCWlmIChyZXQgPCAwKSB7DQo+ICsJCWRl\n" - "dl9lcnIoZGF0YS0+ZWRldi5kZXYsICJyZWFkIGNoYW5uZWwoKSBlcnJvcjogJWRcbiIsIHJldCk7\n" - "DQo+ICsJCXJldHVybjsNCj4gKwl9DQo+ICsNCj4gKwkvKiBHZXQgc3RhdGUgZnJvbSBhZGMgdmFs\n" - "dWUgd2l0aCBhZGNfY29uZGl0aW9uICovDQo+ICsJZm9yIChpID0gMDsgaSA8IGRhdGEtPm51bV9j\n" - "b25kaXRpb25zOyBpKyspIHsNCj4gKwkJc3RydWN0IGFkY19qYWNrX2NvbmQgKmRlZiA9ICZkYXRh\n" - "LT5hZGNfY29uZGl0aW9uW2ldOw0KPiArCQlpZiAoIWRlZi0+c3RhdGUpDQo+ICsJCQlicmVhazsN\n" - "Cj4gKwkJaWYgKGRlZi0+bWluX2FkYyA8PSBhZGNfdmFsICYmIGRlZi0+bWF4X2FkYyA+PSBhZGNf\n" - "dmFsKSB7DQo+ICsJCQlzdGF0ZSA9IGRlZi0+c3RhdGU7DQo+ICsJCQlicmVhazsNCj4gKwkJfQ0K\n" - "PiArCX0NCj4gKwkvKiBpZiBubyBkZWYgaGFzIG1ldCwgaXQgbWVhbnMgc3RhdGUgPSAwIChubyBj\n" - "YWJsZXMgYXR0YWNoZWQpICovDQo+ICsNCj4gKwlleHRjb25fc2V0X3N0YXRlKCZkYXRhLT5lZGV2\n" - "LCBzdGF0ZSk7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpcnFyZXR1cm5fdCBhZGNfamFja19pcnFf\n" - "dGhyZWFkKGludCBpcnEsIHZvaWQgKl9kYXRhKQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19k\n" - "YXRhICpkYXRhID0gX2RhdGE7DQo+ICsNCj4gKwlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmRhdGEt\n" - "PmhhbmRsZXIsIGRhdGEtPmhhbmRsaW5nX2RlbGF5KTsNCj4gKw0KPiArCXJldHVybiBJUlFfSEFO\n" - "RExFRDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBhZGNfamFja19wcm9iZShzdHJ1Y3QgcGxh\n" - "dGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBhZGNfamFja19kYXRhICpkYXRh\n" - "Ow0KPiArCXN0cnVjdCBhZGNfamFja19wZGF0YSAqcGRhdGEgPSBwZGV2LT5kZXYucGxhdGZvcm1f\n" - "ZGF0YTsNCj4gKwlpbnQgaSwgZXJyID0gMDsNCj4gKw0KPiArCWRhdGEgPSBremFsbG9jKHNpemVv\n" - "ZihzdHJ1Y3QgYWRjX2phY2tfZGF0YSksIEdGUF9LRVJORUwpOw0KPiArCWlmICghZGF0YSkNCj4g\n" - "KwkJcmV0dXJuIC1FTk9NRU07DQo+ICsNCj4gKwlkYXRhLT5lZGV2Lm5hbWUgPSBwZGF0YS0+bmFt\n" - "ZTsNCj4gKw0KPiArCWlmIChwZGF0YS0+Y2FibGVfbmFtZXMpDQo+ICsJCWRhdGEtPmVkZXYuc3Vw\n" - "cG9ydGVkX2NhYmxlID0gcGRhdGEtPmNhYmxlX25hbWVzOw0KPiArCWVsc2UNCj4gKwkJZGF0YS0+\n" - "ZWRldi5zdXBwb3J0ZWRfY2FibGUgPSBleHRjb25fY2FibGVfbmFtZTsNCj4gKw0KPiArCS8qIENo\n" - "ZWNrIHRoZSBsZW5ndGggb2YgYXJyYXkgYW5kIHNldCBudW1fY2FibGVzICovDQo+ICsJZm9yIChp\n" - "ID0gMDsgZGF0YS0+ZWRldi5zdXBwb3J0ZWRfY2FibGVbaV07IGkrKykNCj4gKwkJOw0KPiArCWlm\n" - "IChpID09IDAgfHwgaSA+IFNVUFBPUlRFRF9DQUJMRV9NQVgpIHsNCj4gKwkJZXJyID0gLUVJTlZB\n" - "TDsNCj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZXJyb3I6IHBkYXRhLT5jYWJsZV9uYW1lcyBz\n" - "aXplID0gJWRcbiIsDQo+ICsJCQlpIC0gMSk7DQo+ICsJCWdvdG8gZXJyX2FsbG9jOw0KPiArCX0N\n" - "Cj4gKwlkYXRhLT5udW1fY2FibGVzID0gaTsNCj4gKw0KPiArCWlmICghcGRhdGEtPmFkY19jb25k\n" - "aXRpb24gfHwNCj4gKwkgICAgIXBkYXRhLT5hZGNfY29uZGl0aW9uWzBdLnN0YXRlKSB7DQo+ICsJ\n" - "CWVyciA9IC1FSU5WQUw7DQo+ICsJCWRldl9lcnIoJnBkZXYtPmRldiwgImVycm9yOiBhZGNfY29u\n" - "ZGl0aW9uIG5vdCBkZWZpbmVkLlxuIik7DQo+ICsJCWdvdG8gZXJyX2FsbG9jOw0KPiArCX0NCj4g\n" - "KwlkYXRhLT5hZGNfY29uZGl0aW9uID0gcGRhdGEtPmFkY19jb25kaXRpb247DQo+ICsNCj4gKwkv\n" - "KiBDaGVjayB0aGUgbGVuZ3RoIG9mIGFycmF5IGFuZCBzZXQgbnVtX2NvbmRpdGlvbnMgKi8NCj4g\n" - "Kwlmb3IgKGkgPSAwOyBkYXRhLT5hZGNfY29uZGl0aW9uW2ldLnN0YXRlOyBpKyspDQo+ICsJCTsN\n" - "Cj4gKwlkYXRhLT5udW1fY29uZGl0aW9ucyA9IGk7DQo+ICsNCj4gKwlkYXRhLT5jaGFuID0gaWlv\n" - "X2NoYW5uZWxfZ2V0KGRldl9uYW1lKCZwZGV2LT5kZXYpLA0KPiArCQkJCQkJcGRhdGEtPmNvbnN1\n" - "bWVyX2NoYW5uZWwpOw0KPiArCWRhdGEtPmhhbmRsaW5nX2RlbGF5ID0gbXNlY3NfdG9famlmZmll\n" - "cyhwZGF0YS0+aGFuZGxpbmdfZGVsYXlfbXMpOw0KPiArDQo+ICsJSU5JVF9ERUxBWUVEX1dPUktf\n" - "REVGRVJSQUJMRSgmZGF0YS0+aGFuZGxlciwgYWRjX2phY2tfaGFuZGxlcik7DQo+ICsNCj4gKwlw\n" - "bGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYXRhKTsNCj4gKw0KPiArCWlmIChwZGF0YS0+aXJx\n" - "KSB7DQo+ICsJCWRhdGEtPmlycSA9IHBkYXRhLT5pcnE7DQo+ICsNCj4gKwkJZXJyID0gcmVxdWVz\n" - "dF90aHJlYWRlZF9pcnEoZGF0YS0+aXJxLCBOVUxMLA0KPiArCQkJCQkgICBhZGNfamFja19pcnFf\n" - "dGhyZWFkLA0KPiArCQkJCQkgICBwZGF0YS0+aXJxX2ZsYWdzLCBwZGF0YS0+bmFtZSwNCj4gKwkJ\n" - "CQkJICAgZGF0YSk7DQo+ICsNCj4gKwkJaWYgKGVycikgew0KPiArCQkJZGV2X2VycigmcGRldi0+\n" - "ZGV2LCAiZXJyb3I6IGlycSAlZFxuIiwgZGF0YS0+aXJxKTsNCj4gKwkJCWVyciA9IC1FSU5WQUw7\n" - "DQo+ICsJCQlnb3RvIGVycl9pbml0d29yazsNCj4gKwkJfQ0KPiArCX0NCj4gKwllcnIgPSBleHRj\n" - "b25fZGV2X3JlZ2lzdGVyKCZkYXRhLT5lZGV2LCAmcGRldi0+ZGV2KTsNCj4gKwlpZiAoZXJyKQ0K\n" - "PiArCQlnb3RvIGVycl9pcnE7DQo+ICsNCj4gKwlkYXRhLT5yZWFkeSA9IHRydWU7DQo+ICsNCj4g\n" - "Kwlnb3RvIG91dDsNCj4gKw0KPiArZXJyX2lycToNCj4gKwlpZiAoZGF0YS0+aXJxKQ0KPiArCQlm\n" - "cmVlX2lycShkYXRhLT5pcnEsIGRhdGEpOw0KPiArZXJyX2luaXR3b3JrOg0KPiArCWNhbmNlbF9k\n" - "ZWxheWVkX3dvcmtfc3luYygmZGF0YS0+aGFuZGxlcik7DQo+ICtlcnJfYWxsb2M6DQo+ICsJa2Zy\n" - "ZWUoZGF0YSk7DQo+ICtvdXQ6DQo+ICsJcmV0dXJuIGVycjsNCj4gK30NCj4gKw0KPiArc3RhdGlj\n" - "IGludCBfX2RldmV4aXQgYWRjX2phY2tfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk\n" - "ZXYpDQo+ICt7DQo+ICsJc3RydWN0IGFkY19qYWNrX2RhdGEgKmRhdGEgPSBwbGF0Zm9ybV9nZXRf\n" - "ZHJ2ZGF0YShwZGV2KTsNCj4gKw0KPiArCWV4dGNvbl9kZXZfdW5yZWdpc3RlcigmZGF0YS0+ZWRl\n" - "dik7DQo+ICsJaWYgKGRhdGEtPmlycSkNCj4gKwkJZnJlZV9pcnEoZGF0YS0+aXJxLCBkYXRhKTsN\n" - "Cj4gKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsNCj4gKwlrZnJlZShkYXRhKTsN\n" - "Cj4gKw0KPiArCXJldHVybiAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3Jt\n" - "X2RyaXZlciBhZGNfamFja19kcml2ZXIgPSB7DQo+ICsJLnByb2JlCQk9IGFkY19qYWNrX3Byb2Jl\n" - "LA0KPiArCS5yZW1vdmUJCT0gX19kZXZleGl0X3AoYWRjX2phY2tfcmVtb3ZlKSwNCj4gKwkuZHJp\n" - "dmVyCQk9IHsNCj4gKwkJLm5hbWUJPSAiYWRjLWphY2siLA0KPiArCQkub3duZXIJPSBUSElTX01P\n" - "RFVMRSwNCj4gKwl9LA0KPiArfTsNCj4gKw0KPiArc3RhdGljIGludCBfX2luaXQgYWRjX2phY2tf\n" - "aW5pdCh2b2lkKQ0KPiArew0KPiArCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmFk\n" - "Y19qYWNrX2RyaXZlcik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIF9fZXhpdCBhZGNfamFj\n" - "a19leGl0KHZvaWQpDQo+ICt7DQo+ICsJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmFkY19q\n" - "YWNrX2RyaXZlcik7DQo+ICt9DQo+ICsNCj4gK21vZHVsZV9pbml0KGFkY19qYWNrX2luaXQpOw0K\n" - "PiArbW9kdWxlX2V4aXQoYWRjX2phY2tfZXhpdCk7DQo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xp\n" - "bnV4L2V4dGNvbi9hZGNfamFjay5oIGIvaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaA0K\n" - "PiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi40ZDZhMWY3DQo+IC0tLSAv\n" - "ZGV2L251bGwNCj4gKysrIGIvaW5jbHVkZS9saW51eC9leHRjb24vYWRjX2phY2suaA0KPiBAQCAt\n" - "MCwwICsxLDEwOCBAQA0KPiArLyoNCj4gKyAqIGluY2x1ZGUvbGludXgvZXh0Y29uL2FkY19qYWNr\n" - "LmgNCj4gKyAqDQo+ICsgKiBBbmFsb2cgSmFjayBleHRjb24gZHJpdmVyIHdpdGggQURDLWJhc2Vk\n" - "IGRldGVjdGlvbiBjYXBhYmlsaXR5Lg0KPiArICoNCj4gKyAqIENvcHlyaWdodCAoQykgMjAxMiBT\n" - "YW1zdW5nIEVsZWN0cm9uaWNzDQo+ICsgKiBNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBzYW1z\n" - "dW5nLmNvbT4NCj4gKyAqDQo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91\n" - "IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQ0KPiArICogaXQgdW5kZXIgdGhlIHRl\n" - "cm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMNCj4gKyAq\n" - "IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLg0KPiArICoNCj4gKyAq\n" - "Lw0KPiArDQo+ICsjaWZuZGVmIF9FWFRDT05fQURDX0pBQ0tfSF8NCj4gKyNkZWZpbmUgX0VYVENP\n" - "Tl9BRENfSkFDS19IXyBfX0ZJTEVfXw0KPiArDQo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+\n" - "DQo+ICsjaW5jbHVkZSA8bGludXgvZXh0Y29uLmg+DQo+ICsNCj4gKy8qKg0KPiArICogc3RydWN0\n" - "IGFkY19qYWNrX2RhdGEgLSBpbnRlcm5hbCBkYXRhIGZvciBhZGNfamFjayBkZXZpY2UgZHJpdmVy\n" - "DQo+ICsgKiBAZWRldgktIGV4dGNvbiBkZXZpY2UuDQo+ICsgKiBAY2FibGVfbmFtZXMJLSBsaXN0\n" - "IG9mIHN1cHBvcnRlZCBjYWJsZXMuDQo+ICsgKiBAbnVtX2NhYmxlcwktIHNpemUgb2YgY2FibGVf\n" - "bmFtZXMuDQo+ICsgKiBAYWRjX2NvbmRpdGlvbgktIGxpc3Qgb2YgYWRjIHZhbHVlIGNvbmRpdGlv\n" - "bnMuDQo+ICsgKiBAbnVtX2NvbmRpdGlvbgktIHNpemUgb2YgYWRjX2NvbmRpdGlvbi4NCj4gKyAq\n" - "IEBpcnEJCS0gaXJxIG51bWJlciBvZiBhdHRhY2gvZGV0YWNoIGV2ZW50ICgwIGlmIG5vdCBleGlz\n" - "dCkuDQo+ICsgKiBAaGFuZGxpbmdfZGVsYXkJLSBpbnRlcnJ1cHQgaGFuZGxlciB3aWxsIHNjaGVk\n" - "dWxlIGV4dGNvbiBldmVudA0KPiArICoJCQloYW5kbGluZyBhdCBoYW5kbGluZ19kZWxheSBqaWZm\n" - "aWVzLg0KPiArICogQGhhbmRsZXIJLSBleHRjb24gZXZlbnQgaGFuZGxlciBjYWxsZWQgYnkgaW50\n" - "ZXJydXB0IGhhbmRsZXIuDQo+ICsgKiBAY2hhbgktIGlpbyBjaGFubmVsIGJlaW5nIHF1ZXJpZWQu\n" - "DQo+ICsgKiBAcmVhZHkJLSB0cnVlIGlmIGl0IGlzIHNhZmUgdG8gcnVuIGhhbmRsZXIuDQo+ICsg\n" - "Ki8NCj4gK3N0cnVjdCBhZGNfamFja19kYXRhIHsNCj4gKwlzdHJ1Y3QgZXh0Y29uX2RldiBlZGV2\n" - "Ow0KPiArDQo+ICsJY29uc3QgY2hhciAqKmNhYmxlX25hbWVzOw0KPiArCWludCBudW1fY2FibGVz\n" - "Ow0KPiArCXN0cnVjdCBhZGNfamFja19jb25kICphZGNfY29uZGl0aW9uOw0KPiArCWludCBudW1f\n" - "Y29uZGl0aW9uczsNCj4gKw0KPiArCWludCBpcnE7DQo+ICsJdW5zaWduZWQgbG9uZyBoYW5kbGlu\n" - "Z19kZWxheTsgLyogaW4gamlmZmllcyAqLw0KPiArCXN0cnVjdCBkZWxheWVkX3dvcmsgaGFuZGxl\n" - "cjsNCj4gKw0KPiArCXN0cnVjdCBpaW9fY2hhbm5lbCAqY2hhbjsNCj4gKw0KPiArCWJvb2wgcmVh\n" - "ZHk7DQo+ICt9Ow0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVjdCBhZGNfamFja19jb25kIC0gY29u\n" - "ZGl0aW9uIHRvIHVzZSBhbiBleHRjb24gc3RhdGUNCj4gKyAqIEBzdGF0ZQktIHRoZSBjb3JyZXNw\n" - "b25kaW5nIGV4dGNvbiBzdGF0ZSAoaWYgMCwgdGhpcyBzdHJ1Y3QgZGVub3Rlcw0KPiArICoJCXRo\n" - "ZSBsYXN0IGFkY19qYWNrX2NvbmQgZWxlbWVudCBhbW9uZyB0aGUgYXJyYXkpDQo+ICsgKiBAbWlu\n" - "X2FkYwktIG1pbiBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9uDQo+ICsgKiBAbWF4X2FkYwkt\n" - "IG1heCBhZGMgdmFsdWUgZm9yIHRoaXMgY29uZGl0aW9uDQo+ICsgKg0KPiArICogRm9yIGV4YW1w\n" - "bGUsIGlmIHsgLnN0YXRlID0gMHgzLCAubWluX2FkYyA9IDEwMCwgLm1heF9hZGMgPSAyMDB9LCBp\n" - "dCBtZWFucw0KPiArICogdGhhdCBpZiBBREMgdmFsdWUgaXMgYmV0d2VlbiAoaW5jbHVzaXZlKSAx\n" - "MDAgYW5kIDIwMCwgdGhhbiB0aGUgY2FibGUgMCBhbmQNCj4gKyAqIDEgYXJlIGF0dGFjaGVkICgx\n" - "PDwwIHwgMTw8MSA9PSAweDMpDQo+ICsgKg0KPiArICogTm90ZSB0aGF0IHlvdSBkb24ndCBuZWVk\n" - "IHRvIGRlc2NyaWJlIGNvbmRpdGlvbiBmb3IgIm5vIGNhYmxlIGF0dGFjaGVkIg0KPiArICogYmVj\n" - "YXVzZSB3aGVuIG5vIGFkY19qYWNrX2NvbmQgaXMgbWV0LCBzdGF0ZSA9IDAgaXMgYXV0b21hdGlj\n" - "YWxseSBjaG9zZW4uDQo+ICsgKi8NCj4gK3N0cnVjdCBhZGNfamFja19jb25kIHsNCj4gKwl1MzIg\n" - "c3RhdGU7IC8qIGV4dGNvbiBzdGF0ZSB2YWx1ZS4gMCBpZiBpbnZhbGlkICovDQo+ICsJdTMyIG1p\n" - "bl9hZGM7DQo+ICsJdTMyIG1heF9hZGM7DQo+ICt9Ow0KPiArDQo+ICsvKioNCj4gKyAqIHN0cnVj\n" - "dCBhZGNfamFja19wZGF0YSAtIHBsYXRmb3JtIGRhdGEgZm9yIGFkYyBqYWNrIGRldmljZS4NCj4g\n" - "KyAqIEBuYW1lCS0gbmFtZSBvZiB0aGUgZXh0Y29uIGRldmljZS4gSWYgbnVsbCwgImFkYy1qYWNr\n" - "IiBpcyB1c2VkLg0KPiArICogQGNvbnN1bWVyX2NoYW5uZWwgLSBVbmlxdWUgbmFtZSB0byBpZGVu\n" - "dGlmeSB0aGUgY2hhbm5lbCBvbiB0aGUgY29uc3VtZXINCj4gKyAqICAgICAgICAgICAgICAgICAg\n" - "IHNpZGUuIFRoaXMgdHlwaWNhbGx5IGRlc2NyaWJlcyB0aGUgY2hhbm5lbHMgdXNlIHdpdGhpbg0K\n" - "PiArICogICAgICAgICAgICAgICAgICAgdGhlIGNvbnN1bWVyLiBFLmcuICdiYXR0ZXJ5X3ZvbHRh\n" - "Z2UnDQo+ICsgKiBAY2FibGVfbmFtZXMJLSBhcnJheSBvZiBjYWJsZSBuYW1lcyBlbmRpbmcgd2l0\n" - "aCBudWxsLiBJZiB0aGUgYXJyYXkgaXRzZWxmDQo+ICsgKgkJaWYgbnVsbCwgZXh0Y29uIHN0YW5k\n" - "YXJkIGNhYmxlIG5hbWVzIGFyZSBjaG9zZW4uDQo+ICsgKiBAYWRjX2NvbnRpdGlvbgktIGFycmF5\n" - "IG9mIHN0cnVjdCBhZGNfamFja19jb25kIGNvbmRpdGlvbnMgZW5kaW5nDQo+ICsgKgkJCXdpdGgg\n" - "LnN0YXRlID0gMCBlbnRyeS4gVGhpcyBkZXNjcmliZXMgaG93IHRvIGRlY29kZQ0KPiArICoJCQlh\n" - "ZGMgdmFsdWVzIGludG8gZXh0Y29uIHN0YXRlLg0KPiArICogQGlycQkJLSBJUlEgbnVtYmVyIHRo\n" - "YXQgaXMgdHJpZ2dlcnJlZCBieSBjYWJsZSBhdHRhY2gvZGV0YWNoDQo+ICsgKgkJZXZlbnRzLiBJ\n" - "ZiBpcnEgPSAwLCB1c2Ugc2hvdWxkIG1hbnVhbGx5IHVwZGF0ZSBleHRjb24gc3RhdGUNCj4gKyAq\n" - "CQl3aXRoIGV4dGNvbiBBUElzLg0KPiArICogQGlycV9mbGFncwktIGlycSBmbGFncyB1c2VkIGZv\n" - "ciB0aGUgQGlycQ0KPiArICogQGhhbmRsaW5nX2RlbGF5X21zCS0gaW4gc29tZSBkZXZpY2VzLCB3\n" - "ZSBuZWVkIHRvIHJlYWQgQURDIHZhbHVlIHNvbWUNCj4gKyAqCQkJbWlsbGktc2Vjb25kcyBhZnRl\n" - "ciB0aGUgaW50ZXJydXB0IG9jY3Vycy4gWW91IG1heQ0KPiArICoJCQlkZXNjcmliZSBzdWNoIGRl\n" - "bGF5cyB3aXRoIEBoYW5kbGluZ19kZWxheV9tcywgd2hpY2gNCj4gKyAqCQkJaXMgcm91bmRlZC1v\n" - "ZmYgYnkgamlmZmllcy4NCj4gKyAqLw0KPiArc3RydWN0IGFkY19qYWNrX3BkYXRhIHsNCj4gKwlj\n" - "b25zdCBjaGFyICpuYW1lOw0KPiArCWNvbnN0IGNoYXIgKmNvbnN1bWVyX2NoYW5uZWw7DQo+ICsJ\n" - "LyoNCj4gKwkgKiBOVUxMIGlmIHN0YW5kYXJkIGV4dGNvbiBuYW1lcyBhcmUgdXNlZC4NCj4gKwkg\n" - "KiBUaGUgbGFzdCBlbnRyeSBzaG91bGQgYmUgTlVMTA0KPiArCSAqLw0KPiArCWNvbnN0IGNoYXIg\n" - "KipjYWJsZV9uYW1lczsNCj4gKwkvKiBUaGUgbGFzdCBlbnRyeSdzIHN0YXRlIHNob3VsZCBiZSAw\n" - "ICovDQo+ICsJc3RydWN0IGFkY19qYWNrX2NvbmQgKmFkY19jb25kaXRpb247DQo+ICsNCj4gKwlp\n" - "bnQgaXJxOyAvKiBKYWNrIGluc2VydGlvbi9yZW1vdmFsIGludGVycnVwdCAqLw0KPiArCXVuc2ln\n" - "bmVkIGxvbmcgaXJxX2ZsYWdzOw0KPiArCXVuc2lnbmVkIGxvbmcgaGFuZGxpbmdfZGVsYXlfbXM7\n" - "IC8qIGluIG1zICovDQo+ICt9Ow0KPiArDQo+ICsjZW5kaWYgLyogX0VYVENPTl9BRENfSkFDS19I\n" - "ICovDQo+IC0tIA0KPiAxLjcuMQ0KPiANCj4gDQo+IA0KPiANCj4gICAgICAgIA0KPiAgIA0KPiAg\n" - ICAgICAgICANCj4gDQo= + "> 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" + "> Signed-off-by: anish kumar <anish.singh@samsung.com>\n" + "\n" + "Signed-off-by: MyungJoo Ham <myungjoo.ham@samsung.com>\n" + "\n" + "> ---\n" + "> drivers/extcon/Kconfig | 5 +\n" + "> drivers/extcon/Makefile | 1 +\n" + "> drivers/extcon/adc_jack.c | 183 +++++++++++++++++++++++++++++++++++++++\n" + "> include/linux/extcon/adc_jack.h | 108 +++++++++++++++++++++++\n" + "> 4 files changed, 297 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..fef8334\n" + "> --- /dev/null\n" + "> +++ b/drivers/extcon/adc_jack.c\n" + "> @@ -0,0 +1,183 @@\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" + "> +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" + "> +\tif (!data->ready)\n" + "> +\t\treturn;\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" + "> +\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 = kzalloc(sizeof(struct adc_jack_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" + "> +\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" + "> +\tif (pdata->irq) {\n" + "> +\t\tdata->irq = pdata->irq;\n" + "> +\n" + "> +\t\terr = request_threaded_irq(data->irq, NULL,\n" + "> +\t\t\t\t\t adc_jack_irq_thread,\n" + "> +\t\t\t\t\t pdata->irq_flags, pdata->name,\n" + "> +\t\t\t\t\t data);\n" + "> +\n" + "> +\t\tif (err) {\n" + "> +\t\t\tdev_err(&pdev->dev, \"error: irq %d\\n\", data->irq);\n" + "> +\t\t\terr = -EINVAL;\n" + "> +\t\t\tgoto err_initwork;\n" + "> +\t\t}\n" + "> +\t}\n" + "> +\terr = extcon_dev_register(&data->edev, &pdev->dev);\n" + "> +\tif (err)\n" + "> +\t\tgoto err_irq;\n" + "> +\n" + "> +\tdata->ready = true;\n" + "> +\n" + "> +\tgoto out;\n" + "> +\n" + "> +err_irq:\n" + "> +\tif (data->irq)\n" + "> +\t\tfree_irq(data->irq, data);\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" + "> +\tplatform_set_drvdata(pdev, NULL);\n" + "> +\tkfree(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" + "> +static int __init adc_jack_init(void)\n" + "> +{\n" + "> +\treturn platform_driver_register(&adc_jack_driver);\n" + "> +}\n" + "> +\n" + "> +static void __exit adc_jack_exit(void)\n" + "> +{\n" + "> +\tplatform_driver_unregister(&adc_jack_driver);\n" + "> +}\n" + "> +\n" + "> +module_init(adc_jack_init);\n" + "> +module_exit(adc_jack_exit);\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..4d6a1f7\n" + "> --- /dev/null\n" + "> +++ b/include/linux/extcon/adc_jack.h\n" + "> @@ -0,0 +1,108 @@\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_data - internal data for adc_jack device driver\n" + "> + * @edev\t- extcon device.\n" + "> + * @cable_names\t- list of supported cables.\n" + "> + * @num_cables\t- size of cable_names.\n" + "> + * @adc_condition\t- list of adc value conditions.\n" + "> + * @num_condition\t- size of adc_condition.\n" + "> + * @irq\t\t- irq number of attach/detach event (0 if not exist).\n" + "> + * @handling_delay\t- interrupt handler will schedule extcon event\n" + "> + *\t\t\thandling at handling_delay jiffies.\n" + "> + * @handler\t- extcon event handler called by interrupt handler.\n" + "> + * @chan\t- iio channel being queried.\n" + "> + * @ready\t- true if it is safe to run handler.\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" + "> +\tbool ready;\n" + "> +};\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" + "> + * @consumer_channel - Unique name to identify the channel on the consumer\n" + "> + * side. This typically describes the channels use within\n" + "> + * the consumer. E.g. 'battery_voltage'\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" + "> + */\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" + "> +\tint irq; /* Jack insertion/removal interrupt */\n" + "> +\tunsigned long irq_flags;\n" + "> +\tunsigned long handling_delay_ms; /* in ms */\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" -00b173ae5cae6b18c0f3750d9584b176de4877a872f0aa83ed2073405ec65fd5 +39b01ac1dcd1a583240604f2cf062a3001e82c5f47f735858051c42e2aaa126f
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.