diff for duplicates of <1543490289.11186.22.camel@analog.com> diff --git a/a/1.txt b/N1/1.txt index fe32ebf..201ecf6 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,127 +1,220 @@ -T24gTWksIDIwMTgtMTEtMjggYXQgMTY6MTUgLTAyMDAsIEdpdWxpYW5vIEJlbGluYXNzaSB3cm90 -ZToNCj4gUHJldmlvdXNseSwgdGhlIEFENzc4MCBkcml2ZXIgb25seSBzdXBwb3J0ZWQgZ3BpbyBm -b3IgdGhlICdwb3dlcmRvd24nDQo+IHBpbi4gVGhpcyBjb21taXQgYWRkcyBzdXBwcG9ydCBmb3Ig -dGhlICdnYWluJyBhbmQgJ2ZpbHRlcicgcGluLg0KPiANCj4gU2lnbmVkLW9mZi1ieTogR2l1bGlh -bm8gQmVsaW5hc3NpIDxnaXVsaWFuby5iZWxpbmFzc2lAdXNwLmJyPg0KPiAtLS0NCj4gQ2hhbmdl -cyBpbiB2MjoNCj4gwqDCoMKgwqAtIE5vdyB0aGlzIHBhdGNoIGlzIHBhcnQgb2YgdGhlIHBhdGNo -c2V0IHRoYXQgYWltcyB0byByZW1vdmUgYWQ3NzgwDQo+IG91dCBvZiBzdGFnaW5nLiBodHRwczov -L21hcmMuaW5mby8/bD1saW51eC1paW8mbT0xNTQyODIzNDk4MDg4OTAmdz0yDQo+IMKgwqDCoMKg -LSBBbHNvLCBub3cgaXQgcmVhZHMgdm9sdGFnZSBhbmQgZmlsdGVyIHZhbHVlcyBmcm9tIHRoZSB1 -c2Vyc3BhY2UNCj4gaW5zdGVhZCBvZiBncGlvIHBpbiBzdGF0ZXMuDQoNCkhlbGxvLA0KUGxlYXNl -IHNlZSBiZWxsb3cuDQoNCj4gDQo+IMKgZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmPC -oMKgwqDCoMKgwqDCoHwgNzggKysrKysrKysrKysrKysrKysrKysrKysrLS0NCj4gwqBpbmNsdWRl -L2xpbnV4L2lpby9hZGMvYWRfc2lnbWFfZGVsdGEuaCB8wqDCoDUgKysNCj4gwqAyIGZpbGVzIGNo -YW5nZWQsIDc5IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pDQo+IA0KPiBkaWZmIC0tZ2l0 -IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmMNCj4gYi9kcml2ZXJzL3N0YWdpbmcv -aWlvL2FkYy9hZDc3ODAuYw0KPiBpbmRleCBjNGE4NTc4OWMyZGIuLjA1OTc5YTc5ZmRhMyAxMDA2 -NDQNCj4gLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmMNCj4gKysrIGIvZHJp -dmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmMNCj4gQEAgLTM5LDYgKzM5LDEyIEBADQo+IMKg -I2RlZmluZSBBRDcxNzBfUEFUVEVSTgkJKEFENzc4MF9QQVQwIHwgQUQ3MTcwX1BBVDIpDQo+IMKg -I2RlZmluZSBBRDcxNzBfUEFUVEVSTl9NQVNLCShBRDc3ODBfUEFUMCB8IEFENzc4MF9QQVQxIHwN -Cj4gQUQ3MTcwX1BBVDIpDQo+IMKgDQo+ICsjZGVmaW5lIEFENzc4MF9HQUlOX0dQSU8JMA0KPiAr -I2RlZmluZSBBRDc3ODBfRklMVEVSX0dQSU8JMQ0KPiArDQo+ICsjZGVmaW5lIEFENzc4MF9HQUlO -X01JRFBPSU5UCTY0DQo+ICsjZGVmaW5lIEFENzc4MF9GSUxURVJfTUlEUE9JTlQJMTMzNTANCj4g -Kw0KPiDCoHN0cnVjdCBhZDc3ODBfY2hpcF9pbmZvIHsNCj4gwqAJc3RydWN0IGlpb19jaGFuX3Nw -ZWMJY2hhbm5lbDsNCj4gwqAJdW5zaWduZWQgaW50CQlwYXR0ZXJuX21hc2s7DQo+IEBAIC01MCw2 -ICs1Niw4IEBAIHN0cnVjdCBhZDc3ODBfc3RhdGUgew0KPiDCoAljb25zdCBzdHJ1Y3QgYWQ3Nzgw -X2NoaXBfaW5mbwkqY2hpcF9pbmZvOw0KPiDCoAlzdHJ1Y3QgcmVndWxhdG9yCQkqcmVnOw0KPiDC -oAlzdHJ1Y3QgZ3Bpb19kZXNjCQkqcG93ZXJkb3duX2dwaW87DQo+ICsJc3RydWN0IGdwaW9fZGVz -YwkJKmdhaW5fZ3BpbzsNCj4gKwlzdHJ1Y3QgZ3Bpb19kZXNjCQkqZmlsdGVyX2dwaW87DQo+IMKg -CXVuc2lnbmVkIGludAlnYWluOw0KPiDCoA0KPiDCoAlzdHJ1Y3QgYWRfc2lnbWFfZGVsdGEgc2Q7 -DQo+IEBAIC0xMTUsMTggKzEyMyw2NSBAQCBzdGF0aWMgaW50IGFkNzc4MF9yZWFkX3JhdyhzdHJ1 -Y3QgaWlvX2Rldg0KPiAqaW5kaW9fZGV2LA0KPiDCoAlyZXR1cm4gLUVJTlZBTDsNCj4gwqB9DQo+ -IMKgDQo+ICtzdGF0aWMgaW50IGFkNzc4MF93cml0ZV9yYXcoc3RydWN0IGlpb19kZXYgKmluZGlv -X2RldiwNCj4gKwkJCcKgwqDCoMKgc3RydWN0IGlpb19jaGFuX3NwZWMgY29uc3QgKmNoYW4sDQo+ -ICsJCQnCoMKgwqDCoGludCB2YWwsDQo+ICsJCQnCoMKgwqDCoGludCB2YWwyLA0KPiArCQkJwqDC -oMKgwqBsb25nIG0pDQo+ICt7DQo+ICsJc3RydWN0IGFkNzc4MF9zdGF0ZSAqc3QgPSBpaW9fcHJp -dihpbmRpb19kZXYpOw0KPiArCWNvbnN0IHN0cnVjdCBhZDc3ODBfY2hpcF9pbmZvICpjaGlwX2lu -Zm8gPSBzdC0+Y2hpcF9pbmZvOw0KPiArCWludCB1dnJlZiwgZ2FpbjsNCj4gKwl1bnNpZ25lZCBp -bnQgZnVsbF9zY2FsZTsNCj4gKw0KPiArCWlmICghY2hpcF9pbmZvLT5pc19hZDc3OHgpDQo+ICsJ -CXJldHVybiAwOw0KPiArDQo+ICsJc3dpdGNoIChtKSB7DQo+ICsJY2FzZSBJSU9fQ0hBTl9JTkZP -X1NDQUxFOg0KPiArCQlpZiAodmFsICE9IDApDQo+ICsJCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0K -PiArCQl1dnJlZiA9IHJlZ3VsYXRvcl9nZXRfdm9sdGFnZShzdC0+cmVnKTsNCg0KcmVndWxhdG9y -X2dldF92b2x0YWdlKCkgaGFzIGFscmVhZHkgYmVlbiBjYWxsZWQgaW4gdGhlIHByb2JlIGZ1bmN0 -aW9uIGFuZA0KdGhlIHJlc3VsdCBpcyBzdG9yZWQgaW7CoHN0LT5pbnRfdnJlZl9tdi4NCk15IHN1 -Z2dlc3Rpb24gd291bGQgYmUgdG8gdXNlIGEgbG9jYWwgdnJlZiB2YXJpYWJsZSBkZWNsYXJlZCBh -cyB1bnNpZ25lZA0KaW50LiBJdCBpcyBteSBmYXVsdCB0aGF0IEkgaGF2ZW4ndCBleHBsYWluZWQg -Y29ycmVjdGx5IGluIHRoZSBwcmV2aW91cw0KZW1haWwsIGJ1dCB5b3UgbmVlZCB0byBtdWx0aXBs -eSB2cmVmX212IHdpdGjCoDEwMDAwMDBMTCBpbiBvcmRlciB0byBnZXQgdGhlDQpyaWdodCBwcmVj -aXNpb246IHZyZWYgPSBzdC0+aW50X3ZyZWZfbXYgKiAxMDAwMDAwTEwuIEFmdGVyd2FyZHMgeW91 -IHdpbGwgYmUNCmFibGUgdG8gcGVyZm9ybSB0aGUgZGl2aXNpb25zLg0KPiArDQo+ICsJCWlmICh1 -dnJlZiA8IDApDQo+ICsJCQlyZXR1cm4gdXZyZWY7DQo+ICsNCj4gKwkJZnVsbF9zY2FsZSA9IDEg -PDwgKGNoaXBfaW5mby0+Y2hhbm5lbC5zY2FuX3R5cGUucmVhbGJpdHMgDQo+IC0gMSk7DQo+ICsJ -CWdhaW4gPSBESVZfUk9VTkRfQ0xPU0VTVCh1dnJlZiwgZnVsbF9zY2FsZSk7DQo+ICsJCWdhaW4g -PSBESVZfUk9VTkRfQ0xPU0VTVChnYWluLCB2YWwyKTsNCj4gKw0KPiArCQlncGlvZF9zZXRfdmFs -dWUoc3QtPmdhaW5fZ3BpbywgZ2FpbiA8DQo+IEFENzc4MF9HQUlOX01JRFBPSU5UID8gMCA6IDEp -Ow0KDQpPbmNlIHRoZSBnYWluIGlzIHNldCwgeW91IGNhbiBzdG9yZSBpdCBpbiBzdC0+Z2FpbiB2 -YXJpYWJsZS4NCg0KPiArCWNhc2UgSUlPX0NIQU5fSU5GT19TQU1QX0ZSRVE6DQo+ICsJCWlmICh2 -YWwyICE9IDApDQo+ICsJCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0KPiArCQlncGlvZF9zZXRfdmFs -dWUoc3QtPmZpbHRlcl9ncGlvLCB2YWwgPA0KPiBBRDc3ODBfRklMVEVSX01JRFBPSU5UID8gMCA6 -IDEpOw0KDQpUaGlzIGlzIHByb2JhYmx5IGZpbmUsIGFsdGhvdWdoIEkgYW0gbm90IGEgYmlnIGZh -biBvZiB0aGUgdGVybmFyeSBvcGVyYXRvci4NCkEgc2ltcGxlIGlmIGVsc2Ugc3RhdGVtZW50IHdv -dWxkIGRvLiBIb3dldmVyLCBJIGRvbid0IGZlZWwgc3Ryb25nbHkgYWJvdXQNCml0LCBzbyBmZWVs -IGZyZWUgdG8gZGlzYWdyZWUuwqANCg0KPiArCWJyZWFrOw0KPiArCX0NCj4gKw0KPiArCXJldHVy -biAwOw0KPiArfQ0KPiArDQo+IMKgc3RhdGljIGludCBhZDc3ODBfcG9zdHByb2Nlc3Nfc2FtcGxl -KHN0cnVjdCBhZF9zaWdtYV9kZWx0YSAqc2lnbWFfZGVsdGEsDQo+IMKgCQkJCcKgwqDCoMKgwqB1 -bnNpZ25lZCBpbnQgcmF3X3NhbXBsZSkNCj4gwqB7DQo+IMKgCXN0cnVjdCBhZDc3ODBfc3RhdGUg -KnN0ID0gYWRfc2lnbWFfZGVsdGFfdG9fYWQ3NzgwKHNpZ21hX2RlbHRhKTsNCj4gwqAJY29uc3Qg -c3RydWN0IGFkNzc4MF9jaGlwX2luZm8gKmNoaXBfaW5mbyA9IHN0LT5jaGlwX2luZm87DQo+ICsJ -aW50IHZhbDsNCj4gwqANCj4gwqAJaWYgKChyYXdfc2FtcGxlICYgQUQ3NzgwX0VSUikgfHwNCj4g -wqAJwqDCoMKgwqAoKHJhd19zYW1wbGUgJiBjaGlwX2luZm8tPnBhdHRlcm5fbWFzaykgIT0gY2hp -cF9pbmZvLQ0KPiA+cGF0dGVybikpDQo+IMKgCQlyZXR1cm4gLUVJTzsNCj4gwqANCj4gwqAJaWYg -KGNoaXBfaW5mby0+aXNfYWQ3Nzh4KSB7DQo+IC0JCWlmIChyYXdfc2FtcGxlICYgQUQ3NzgwX0dB -SU4pDQo+ICsJCXZhbCA9IHJhd19zYW1wbGUgJiBBRDc3ODBfR0FJTjsNCj4gKw0KPiArCQlpZiAo -dmFsICE9IGdwaW9kX2dldF92YWx1ZShzdC0+Z2Fpbl9ncGlvKSkNCj4gKwkJCXJldHVybiAtRUlP -Ow0KDQpJdCBpcyBub3Qgb2J2aW91cyB0byBtZSB3aGF0IGlzIHRoZSBwb2ludCBvZiB0aGlzIGNo -ZWNrLiBNYXliZSB5b3UgY2FuIGFkZA0KYSBjb21tZW50Pw0KDQo+ICsNCj4gKwkJaWYgKHZhbCkN -Cj4gwqAJCQlzdC0+Z2FpbiA9IDE7DQo+IMKgCQllbHNlDQo+IMKgCQkJc3QtPmdhaW4gPSAxMjg7 -DQoNCkRvIHdlIHN0aWxsIG5lZWQgdGhpcz8gSSBhbSBub3QgY29udmluY2VkLsKgDQoNCj4gQEAg -LTE0MSwxOCArMTk2LDIwIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWRfc2lnbWFfZGVsdGFfaW5m -bw0KPiBhZDc3ODBfc2lnbWFfZGVsdGFfaW5mbyA9IHsNCj4gwqAJLmhhc19yZWdpc3RlcnMgPSBm -YWxzZSwNCj4gwqB9Ow0KPiDCoA0KPiAtI2RlZmluZSBBRDc3ODBfQ0hBTk5FTChiaXRzLCB3b3Jk -c2l6ZSkgXA0KPiArI2RlZmluZSBBRDcxNzBfQ0hBTk5FTChiaXRzLCB3b3Jkc2l6ZSkgXA0KPiDC -oAlBRF9TRF9DSEFOTkVMX05PX1NBTVBfRlJFUSgxLCAwLCAwLCBiaXRzLCAzMiwgd29yZHNpemUg -LSBiaXRzKQ0KPiArI2RlZmluZSBBRDc3ODBfQ0hBTk5FTChiaXRzLCB3b3Jkc2l6ZSkgXA0KPiAr -CUFEX1NEX0NIQU5ORUxfR0FJTl9GSUxURVIoMSwgMCwgMCwgYml0cywgMzIsIHdvcmRzaXplIC0g -Yml0cykNCj4gwqANCj4gwqBzdGF0aWMgY29uc3Qgc3RydWN0IGFkNzc4MF9jaGlwX2luZm8gYWQ3 -NzgwX2NoaXBfaW5mb190YmxbXSA9IHsNCj4gwqAJW0lEX0FENzE3MF0gPSB7DQo+IC0JCS5jaGFu -bmVsID0gQUQ3NzgwX0NIQU5ORUwoMTIsIDI0KSwNCj4gKwkJLmNoYW5uZWwgPSBBRDcxNzBfQ0hB -Tk5FTCgxMiwgMjQpLA0KPiDCoAkJLnBhdHRlcm4gPSBBRDcxNzBfUEFUVEVSTiwNCj4gwqAJCS5w -YXR0ZXJuX21hc2sgPSBBRDcxNzBfUEFUVEVSTl9NQVNLLA0KPiDCoAkJLmlzX2FkNzc4eCA9IGZh -bHNlLA0KPiDCoAl9LA0KPiDCoAlbSURfQUQ3MTcxXSA9IHsNCj4gLQkJLmNoYW5uZWwgPSBBRDc3 -ODBfQ0hBTk5FTCgxNiwgMjQpLA0KPiArCQkuY2hhbm5lbCA9IEFENzE3MF9DSEFOTkVMKDE2LCAy -NCksDQo+IMKgCQkucGF0dGVybiA9IEFENzE3MF9QQVRURVJOLA0KPiDCoAkJLnBhdHRlcm5fbWFz -ayA9IEFENzE3MF9QQVRURVJOX01BU0ssDQo+IMKgCQkuaXNfYWQ3Nzh4ID0gZmFsc2UsDQo+IEBA -IC0xNzMsNiArMjMwLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBhZDc3ODBfY2hpcF9pbmZvDQo+ -IGFkNzc4MF9jaGlwX2luZm9fdGJsW10gPSB7DQo+IMKgDQo+IMKgc3RhdGljIGNvbnN0IHN0cnVj -dCBpaW9faW5mbyBhZDc3ODBfaW5mbyA9IHsNCj4gwqAJLnJlYWRfcmF3ID0gYWQ3NzgwX3JlYWRf -cmF3LA0KPiArCS53cml0ZV9yYXcgPSBhZDc3ODBfd3JpdGVfcmF3LA0KPiDCoH07DQo+IMKgDQo+ -IMKgc3RhdGljIGludCBhZDc3ODBfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkNCj4gQEAg -LTIyMiw2ICsyODAsMTggQEAgc3RhdGljIGludCBhZDc3ODBfcHJvYmUoc3RydWN0IHNwaV9kZXZp -Y2UgKnNwaSkNCj4gwqAJCWdvdG8gZXJyb3JfZGlzYWJsZV9yZWc7DQo+IMKgCX0NCj4gwqANCj4g -KwlpZiAoc3QtPmNoaXBfaW5mby0+aXNfYWQ3Nzh4KSB7DQo+ICsJCXN0LT5nYWluX2dwaW8gPSBk -ZXZtX2dwaW9kX2dldF9vcHRpb25hbCgmc3BpLT5kZXYsDQo+ICsJCQkJCQkJImdhaW4iLA0KPiAr -CQkJCQkJCUdQSU9EX09VVF9ISUdIKTsNCj4gKwkJaWYgKElTX0VSUihzdC0+Z2Fpbl9ncGlvKSkg -ew0KDQppZiB0aGUgR1BJTyBpcyBvcHRpb25hbCwgdGhlbiB3ZSBzaG91bGQgY29udGludWUgaW4g -Y2FzZSBvZsKgLUVOT0RFVi4NCg0KU2hvdWxkbid0IHdlIGhhdmUgYcKgZGV2bV9ncGlvZF9nZXRf -b3B0aW9uYWwoKSBjYWxsIGFsc28gZm9yIGZpbHRlcl9ncGlvPw0KDQo+ICsJCQlyZXQgPSBQVFJf -RVJSKHN0LT5nYWluX2dwaW8pOw0KPiArCQkJZGV2X2Vycigmc3BpLT5kZXYsICJGYWlsZWQgdG8g -cmVxdWVzdCBnYWluIEdQSU86DQo+ICVkXG4iLA0KPiArCQkJCXJldCk7DQo+ICsJCQlnb3RvIGVy -cm9yX2Rpc2FibGVfcmVnOw0KPiArCQl9DQo+ICsJfQ0KPiArDQo+IMKgCXJldCA9IGFkX3NkX3Nl -dHVwX2J1ZmZlcl9hbmRfdHJpZ2dlcihpbmRpb19kZXYpOw0KPiDCoAlpZiAocmV0KQ0KPiDCoAkJ -Z290byBlcnJvcl9kaXNhYmxlX3JlZzsNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaWlv -L2FkYy9hZF9zaWdtYV9kZWx0YS5oDQo+IGIvaW5jbHVkZS9saW51eC9paW8vYWRjL2FkX3NpZ21h -X2RlbHRhLmgNCj4gaW5kZXggNzMwZWFkMWE0NmRmLi42Y2FkYWI2ZmQ1ZmQgMTAwNjQ0DQo+IC0t -LSBhL2luY2x1ZGUvbGludXgvaWlvL2FkYy9hZF9zaWdtYV9kZWx0YS5oDQo+ICsrKyBiL2luY2x1 -ZGUvbGludXgvaWlvL2FkYy9hZF9zaWdtYV9kZWx0YS5oDQo+IEBAIC0xNzMsNiArMTczLDExIEBA -IGludCBhZF9zZF92YWxpZGF0ZV90cmlnZ2VyKHN0cnVjdCBpaW9fZGV2DQo+ICppbmRpb19kZXYs -IHN0cnVjdCBpaW9fdHJpZ2dlciAqdHJpZyk7DQo+IMKgCV9fQURfU0RfQ0hBTk5FTChfc2ksIF9j -aGFubmVsLCAtMSwgX2FkZHJlc3MsIF9iaXRzLCBcDQo+IMKgCQlfc3RvcmFnZWJpdHMsIF9zaGlm -dCwgTlVMTCwgSUlPX1ZPTFRBR0UsIDApDQo+IMKgDQo+ICsjZGVmaW5lIEFEX1NEX0NIQU5ORUxf -R0FJTl9GSUxURVIoX3NpLCBfY2hhbm5lbCwgX2FkZHJlc3MsIF9iaXRzLCBcDQo+ICsJX3N0b3Jh -Z2ViaXRzLCBfc2hpZnQpIFwNCj4gKwlfX0FEX1NEX0NIQU5ORUwoX3NpLCBfY2hhbm5lbCwgLTEs -IF9hZGRyZXNzLCBfYml0cywgXA0KPiArCQlfc3RvcmFnZWJpdHMsIF9zaGlmdCwgTlVMTCwgSUlP -X1ZPTFRBR0UsDQo+IEJJVChJSU9fQ0hBTl9JTkZPX1JBVykpDQo+ICsNCj4gwqAjZGVmaW5lIEFE -X1NEX1RFTVBfQ0hBTk5FTChfc2ksIF9hZGRyZXNzLCBfYml0cywgX3N0b3JhZ2ViaXRzLCBfc2hp -ZnQpIFwNCj4gwqAJX19BRF9TRF9DSEFOTkVMKF9zaSwgMCwgLTEsIF9hZGRyZXNzLCBfYml0cywg -XA0KPiDCoAkJX3N0b3JhZ2ViaXRzLCBfc2hpZnQsIE5VTEwsIElJT19URU1QLCBc +On Mi, 2018-11-28 at 16:15 -0200, Giuliano Belinassi wrote: +> Previously, the AD7780 driver only supported gpio for the 'powerdown' +> pin. This commit adds suppport for the 'gain' and 'filter' pin. +> +> Signed-off-by: Giuliano Belinassi <giuliano.belinassi@usp.br> +> --- +> Changes in v2: +> - Now this patch is part of the patchset that aims to remove ad7780 +> out of staging. https://marc.info/?l=linux-iio&m=154282349808890&w=2 +> - Also, now it reads voltage and filter values from the userspace +> instead of gpio pin states. + +Hello, +Please see bellow. + +> +> drivers/staging/iio/adc/ad7780.c | 78 ++++++++++++++++++++++++-- +> include/linux/iio/adc/ad_sigma_delta.h | 5 ++ +> 2 files changed, 79 insertions(+), 4 deletions(-) +> +> diff --git a/drivers/staging/iio/adc/ad7780.c +> b/drivers/staging/iio/adc/ad7780.c +> index c4a85789c2db..05979a79fda3 100644 +> --- a/drivers/staging/iio/adc/ad7780.c +> +++ b/drivers/staging/iio/adc/ad7780.c +> @@ -39,6 +39,12 @@ +> #define AD7170_PATTERN (AD7780_PAT0 | AD7170_PAT2) +> #define AD7170_PATTERN_MASK (AD7780_PAT0 | AD7780_PAT1 | +> AD7170_PAT2) +> +> +#define AD7780_GAIN_GPIO 0 +> +#define AD7780_FILTER_GPIO 1 +> + +> +#define AD7780_GAIN_MIDPOINT 64 +> +#define AD7780_FILTER_MIDPOINT 13350 +> + +> struct ad7780_chip_info { +> struct iio_chan_spec channel; +> unsigned int pattern_mask; +> @@ -50,6 +56,8 @@ struct ad7780_state { +> const struct ad7780_chip_info *chip_info; +> struct regulator *reg; +> struct gpio_desc *powerdown_gpio; +> + struct gpio_desc *gain_gpio; +> + struct gpio_desc *filter_gpio; +> unsigned int gain; +> +> struct ad_sigma_delta sd; +> @@ -115,18 +123,65 @@ static int ad7780_read_raw(struct iio_dev +> *indio_dev, +> return -EINVAL; +> } +> +> +static int ad7780_write_raw(struct iio_dev *indio_dev, +> + struct iio_chan_spec const *chan, +> + int val, +> + int val2, +> + long m) +> +{ +> + struct ad7780_state *st = iio_priv(indio_dev); +> + const struct ad7780_chip_info *chip_info = st->chip_info; +> + int uvref, gain; +> + unsigned int full_scale; +> + +> + if (!chip_info->is_ad778x) +> + return 0; +> + +> + switch (m) { +> + case IIO_CHAN_INFO_SCALE: +> + if (val != 0) +> + return -EINVAL; +> + +> + uvref = regulator_get_voltage(st->reg); + +regulator_get_voltage() has already been called in the probe function and +the result is stored in st->int_vref_mv. +My suggestion would be to use a local vref variable declared as unsigned +int. It is my fault that I haven't explained correctly in the previous +email, but you need to multiply vref_mv with 1000000LL in order to get the +right precision: vref = st->int_vref_mv * 1000000LL. Afterwards you will be +able to perform the divisions. +> + +> + if (uvref < 0) +> + return uvref; +> + +> + full_scale = 1 << (chip_info->channel.scan_type.realbits +> - 1); +> + gain = DIV_ROUND_CLOSEST(uvref, full_scale); +> + gain = DIV_ROUND_CLOSEST(gain, val2); +> + +> + gpiod_set_value(st->gain_gpio, gain < +> AD7780_GAIN_MIDPOINT ? 0 : 1); + +Once the gain is set, you can store it in st->gain variable. + +> + case IIO_CHAN_INFO_SAMP_FREQ: +> + if (val2 != 0) +> + return -EINVAL; +> + +> + gpiod_set_value(st->filter_gpio, val < +> AD7780_FILTER_MIDPOINT ? 0 : 1); + +This is probably fine, although I am not a big fan of the ternary operator. +A simple if else statement would do. However, I don't feel strongly about +it, so feel free to disagree. + +> + break; +> + } +> + +> + return 0; +> +} +> + +> static int ad7780_postprocess_sample(struct ad_sigma_delta *sigma_delta, +> unsigned int raw_sample) +> { +> struct ad7780_state *st = ad_sigma_delta_to_ad7780(sigma_delta); +> const struct ad7780_chip_info *chip_info = st->chip_info; +> + int val; +> +> if ((raw_sample & AD7780_ERR) || +> ((raw_sample & chip_info->pattern_mask) != chip_info- +> >pattern)) +> return -EIO; +> +> if (chip_info->is_ad778x) { +> - if (raw_sample & AD7780_GAIN) +> + val = raw_sample & AD7780_GAIN; +> + +> + if (val != gpiod_get_value(st->gain_gpio)) +> + return -EIO; + +It is not obvious to me what is the point of this check. Maybe you can add +a comment? + +> + +> + if (val) +> st->gain = 1; +> else +> st->gain = 128; + +Do we still need this? I am not convinced. + +> @@ -141,18 +196,20 @@ static const struct ad_sigma_delta_info +> ad7780_sigma_delta_info = { +> .has_registers = false, +> }; +> +> -#define AD7780_CHANNEL(bits, wordsize) \ +> +#define AD7170_CHANNEL(bits, wordsize) \ +> AD_SD_CHANNEL_NO_SAMP_FREQ(1, 0, 0, bits, 32, wordsize - bits) +> +#define AD7780_CHANNEL(bits, wordsize) \ +> + AD_SD_CHANNEL_GAIN_FILTER(1, 0, 0, bits, 32, wordsize - bits) +> +> static const struct ad7780_chip_info ad7780_chip_info_tbl[] = { +> [ID_AD7170] = { +> - .channel = AD7780_CHANNEL(12, 24), +> + .channel = AD7170_CHANNEL(12, 24), +> .pattern = AD7170_PATTERN, +> .pattern_mask = AD7170_PATTERN_MASK, +> .is_ad778x = false, +> }, +> [ID_AD7171] = { +> - .channel = AD7780_CHANNEL(16, 24), +> + .channel = AD7170_CHANNEL(16, 24), +> .pattern = AD7170_PATTERN, +> .pattern_mask = AD7170_PATTERN_MASK, +> .is_ad778x = false, +> @@ -173,6 +230,7 @@ static const struct ad7780_chip_info +> ad7780_chip_info_tbl[] = { +> +> static const struct iio_info ad7780_info = { +> .read_raw = ad7780_read_raw, +> + .write_raw = ad7780_write_raw, +> }; +> +> static int ad7780_probe(struct spi_device *spi) +> @@ -222,6 +280,18 @@ static int ad7780_probe(struct spi_device *spi) +> goto error_disable_reg; +> } +> +> + if (st->chip_info->is_ad778x) { +> + st->gain_gpio = devm_gpiod_get_optional(&spi->dev, +> + "gain", +> + GPIOD_OUT_HIGH); +> + if (IS_ERR(st->gain_gpio)) { + +if the GPIO is optional, then we should continue in case of -ENODEV. + +Shouldn't we have a devm_gpiod_get_optional() call also for filter_gpio? + +> + ret = PTR_ERR(st->gain_gpio); +> + dev_err(&spi->dev, "Failed to request gain GPIO: +> %d\n", +> + ret); +> + goto error_disable_reg; +> + } +> + } +> + +> ret = ad_sd_setup_buffer_and_trigger(indio_dev); +> if (ret) +> goto error_disable_reg; +> diff --git a/include/linux/iio/adc/ad_sigma_delta.h +> b/include/linux/iio/adc/ad_sigma_delta.h +> index 730ead1a46df..6cadab6fd5fd 100644 +> --- a/include/linux/iio/adc/ad_sigma_delta.h +> +++ b/include/linux/iio/adc/ad_sigma_delta.h +> @@ -173,6 +173,11 @@ int ad_sd_validate_trigger(struct iio_dev +> *indio_dev, struct iio_trigger *trig); +> __AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \ +> _storagebits, _shift, NULL, IIO_VOLTAGE, 0) +> +> +#define AD_SD_CHANNEL_GAIN_FILTER(_si, _channel, _address, _bits, \ +> + _storagebits, _shift) \ +> + __AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \ +> + _storagebits, _shift, NULL, IIO_VOLTAGE, +> BIT(IIO_CHAN_INFO_RAW)) +> + +> #define AD_SD_TEMP_CHANNEL(_si, _address, _bits, _storagebits, _shift) \ +> __AD_SD_CHANNEL(_si, 0, -1, _address, _bits, \ +> _storagebits, _shift, NULL, IIO_TEMP, \ diff --git a/a/content_digest b/N1/content_digest index 48b4d67..9cf978c 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -20,132 +20,225 @@ " kernel-usp@googlegroups.com <kernel-usp@googlegroups.com>\0" "\00:1\0" "b\0" - "T24gTWksIDIwMTgtMTEtMjggYXQgMTY6MTUgLTAyMDAsIEdpdWxpYW5vIEJlbGluYXNzaSB3cm90\n" - "ZToNCj4gUHJldmlvdXNseSwgdGhlIEFENzc4MCBkcml2ZXIgb25seSBzdXBwb3J0ZWQgZ3BpbyBm\n" - "b3IgdGhlICdwb3dlcmRvd24nDQo+IHBpbi4gVGhpcyBjb21taXQgYWRkcyBzdXBwcG9ydCBmb3Ig\n" - "dGhlICdnYWluJyBhbmQgJ2ZpbHRlcicgcGluLg0KPiANCj4gU2lnbmVkLW9mZi1ieTogR2l1bGlh\n" - "bm8gQmVsaW5hc3NpIDxnaXVsaWFuby5iZWxpbmFzc2lAdXNwLmJyPg0KPiAtLS0NCj4gQ2hhbmdl\n" - "cyBpbiB2MjoNCj4gwqDCoMKgwqAtIE5vdyB0aGlzIHBhdGNoIGlzIHBhcnQgb2YgdGhlIHBhdGNo\n" - "c2V0IHRoYXQgYWltcyB0byByZW1vdmUgYWQ3NzgwDQo+IG91dCBvZiBzdGFnaW5nLiBodHRwczov\n" - "L21hcmMuaW5mby8/bD1saW51eC1paW8mbT0xNTQyODIzNDk4MDg4OTAmdz0yDQo+IMKgwqDCoMKg\n" - "LSBBbHNvLCBub3cgaXQgcmVhZHMgdm9sdGFnZSBhbmQgZmlsdGVyIHZhbHVlcyBmcm9tIHRoZSB1\n" - "c2Vyc3BhY2UNCj4gaW5zdGVhZCBvZiBncGlvIHBpbiBzdGF0ZXMuDQoNCkhlbGxvLA0KUGxlYXNl\n" - "IHNlZSBiZWxsb3cuDQoNCj4gDQo+IMKgZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmPC\n" - "oMKgwqDCoMKgwqDCoHwgNzggKysrKysrKysrKysrKysrKysrKysrKysrLS0NCj4gwqBpbmNsdWRl\n" - "L2xpbnV4L2lpby9hZGMvYWRfc2lnbWFfZGVsdGEuaCB8wqDCoDUgKysNCj4gwqAyIGZpbGVzIGNo\n" - "YW5nZWQsIDc5IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pDQo+IA0KPiBkaWZmIC0tZ2l0\n" - "IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmMNCj4gYi9kcml2ZXJzL3N0YWdpbmcv\n" - "aWlvL2FkYy9hZDc3ODAuYw0KPiBpbmRleCBjNGE4NTc4OWMyZGIuLjA1OTc5YTc5ZmRhMyAxMDA2\n" - "NDQNCj4gLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmMNCj4gKysrIGIvZHJp\n" - "dmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NzgwLmMNCj4gQEAgLTM5LDYgKzM5LDEyIEBADQo+IMKg\n" - "I2RlZmluZSBBRDcxNzBfUEFUVEVSTgkJKEFENzc4MF9QQVQwIHwgQUQ3MTcwX1BBVDIpDQo+IMKg\n" - "I2RlZmluZSBBRDcxNzBfUEFUVEVSTl9NQVNLCShBRDc3ODBfUEFUMCB8IEFENzc4MF9QQVQxIHwN\n" - "Cj4gQUQ3MTcwX1BBVDIpDQo+IMKgDQo+ICsjZGVmaW5lIEFENzc4MF9HQUlOX0dQSU8JMA0KPiAr\n" - "I2RlZmluZSBBRDc3ODBfRklMVEVSX0dQSU8JMQ0KPiArDQo+ICsjZGVmaW5lIEFENzc4MF9HQUlO\n" - "X01JRFBPSU5UCTY0DQo+ICsjZGVmaW5lIEFENzc4MF9GSUxURVJfTUlEUE9JTlQJMTMzNTANCj4g\n" - "Kw0KPiDCoHN0cnVjdCBhZDc3ODBfY2hpcF9pbmZvIHsNCj4gwqAJc3RydWN0IGlpb19jaGFuX3Nw\n" - "ZWMJY2hhbm5lbDsNCj4gwqAJdW5zaWduZWQgaW50CQlwYXR0ZXJuX21hc2s7DQo+IEBAIC01MCw2\n" - "ICs1Niw4IEBAIHN0cnVjdCBhZDc3ODBfc3RhdGUgew0KPiDCoAljb25zdCBzdHJ1Y3QgYWQ3Nzgw\n" - "X2NoaXBfaW5mbwkqY2hpcF9pbmZvOw0KPiDCoAlzdHJ1Y3QgcmVndWxhdG9yCQkqcmVnOw0KPiDC\n" - "oAlzdHJ1Y3QgZ3Bpb19kZXNjCQkqcG93ZXJkb3duX2dwaW87DQo+ICsJc3RydWN0IGdwaW9fZGVz\n" - "YwkJKmdhaW5fZ3BpbzsNCj4gKwlzdHJ1Y3QgZ3Bpb19kZXNjCQkqZmlsdGVyX2dwaW87DQo+IMKg\n" - "CXVuc2lnbmVkIGludAlnYWluOw0KPiDCoA0KPiDCoAlzdHJ1Y3QgYWRfc2lnbWFfZGVsdGEgc2Q7\n" - "DQo+IEBAIC0xMTUsMTggKzEyMyw2NSBAQCBzdGF0aWMgaW50IGFkNzc4MF9yZWFkX3JhdyhzdHJ1\n" - "Y3QgaWlvX2Rldg0KPiAqaW5kaW9fZGV2LA0KPiDCoAlyZXR1cm4gLUVJTlZBTDsNCj4gwqB9DQo+\n" - "IMKgDQo+ICtzdGF0aWMgaW50IGFkNzc4MF93cml0ZV9yYXcoc3RydWN0IGlpb19kZXYgKmluZGlv\n" - "X2RldiwNCj4gKwkJCcKgwqDCoMKgc3RydWN0IGlpb19jaGFuX3NwZWMgY29uc3QgKmNoYW4sDQo+\n" - "ICsJCQnCoMKgwqDCoGludCB2YWwsDQo+ICsJCQnCoMKgwqDCoGludCB2YWwyLA0KPiArCQkJwqDC\n" - "oMKgwqBsb25nIG0pDQo+ICt7DQo+ICsJc3RydWN0IGFkNzc4MF9zdGF0ZSAqc3QgPSBpaW9fcHJp\n" - "dihpbmRpb19kZXYpOw0KPiArCWNvbnN0IHN0cnVjdCBhZDc3ODBfY2hpcF9pbmZvICpjaGlwX2lu\n" - "Zm8gPSBzdC0+Y2hpcF9pbmZvOw0KPiArCWludCB1dnJlZiwgZ2FpbjsNCj4gKwl1bnNpZ25lZCBp\n" - "bnQgZnVsbF9zY2FsZTsNCj4gKw0KPiArCWlmICghY2hpcF9pbmZvLT5pc19hZDc3OHgpDQo+ICsJ\n" - "CXJldHVybiAwOw0KPiArDQo+ICsJc3dpdGNoIChtKSB7DQo+ICsJY2FzZSBJSU9fQ0hBTl9JTkZP\n" - "X1NDQUxFOg0KPiArCQlpZiAodmFsICE9IDApDQo+ICsJCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0K\n" - "PiArCQl1dnJlZiA9IHJlZ3VsYXRvcl9nZXRfdm9sdGFnZShzdC0+cmVnKTsNCg0KcmVndWxhdG9y\n" - "X2dldF92b2x0YWdlKCkgaGFzIGFscmVhZHkgYmVlbiBjYWxsZWQgaW4gdGhlIHByb2JlIGZ1bmN0\n" - "aW9uIGFuZA0KdGhlIHJlc3VsdCBpcyBzdG9yZWQgaW7CoHN0LT5pbnRfdnJlZl9tdi4NCk15IHN1\n" - "Z2dlc3Rpb24gd291bGQgYmUgdG8gdXNlIGEgbG9jYWwgdnJlZiB2YXJpYWJsZSBkZWNsYXJlZCBh\n" - "cyB1bnNpZ25lZA0KaW50LiBJdCBpcyBteSBmYXVsdCB0aGF0IEkgaGF2ZW4ndCBleHBsYWluZWQg\n" - "Y29ycmVjdGx5IGluIHRoZSBwcmV2aW91cw0KZW1haWwsIGJ1dCB5b3UgbmVlZCB0byBtdWx0aXBs\n" - "eSB2cmVmX212IHdpdGjCoDEwMDAwMDBMTCBpbiBvcmRlciB0byBnZXQgdGhlDQpyaWdodCBwcmVj\n" - "aXNpb246IHZyZWYgPSBzdC0+aW50X3ZyZWZfbXYgKiAxMDAwMDAwTEwuIEFmdGVyd2FyZHMgeW91\n" - "IHdpbGwgYmUNCmFibGUgdG8gcGVyZm9ybSB0aGUgZGl2aXNpb25zLg0KPiArDQo+ICsJCWlmICh1\n" - "dnJlZiA8IDApDQo+ICsJCQlyZXR1cm4gdXZyZWY7DQo+ICsNCj4gKwkJZnVsbF9zY2FsZSA9IDEg\n" - "PDwgKGNoaXBfaW5mby0+Y2hhbm5lbC5zY2FuX3R5cGUucmVhbGJpdHMgDQo+IC0gMSk7DQo+ICsJ\n" - "CWdhaW4gPSBESVZfUk9VTkRfQ0xPU0VTVCh1dnJlZiwgZnVsbF9zY2FsZSk7DQo+ICsJCWdhaW4g\n" - "PSBESVZfUk9VTkRfQ0xPU0VTVChnYWluLCB2YWwyKTsNCj4gKw0KPiArCQlncGlvZF9zZXRfdmFs\n" - "dWUoc3QtPmdhaW5fZ3BpbywgZ2FpbiA8DQo+IEFENzc4MF9HQUlOX01JRFBPSU5UID8gMCA6IDEp\n" - "Ow0KDQpPbmNlIHRoZSBnYWluIGlzIHNldCwgeW91IGNhbiBzdG9yZSBpdCBpbiBzdC0+Z2FpbiB2\n" - "YXJpYWJsZS4NCg0KPiArCWNhc2UgSUlPX0NIQU5fSU5GT19TQU1QX0ZSRVE6DQo+ICsJCWlmICh2\n" - "YWwyICE9IDApDQo+ICsJCQlyZXR1cm4gLUVJTlZBTDsNCj4gKw0KPiArCQlncGlvZF9zZXRfdmFs\n" - "dWUoc3QtPmZpbHRlcl9ncGlvLCB2YWwgPA0KPiBBRDc3ODBfRklMVEVSX01JRFBPSU5UID8gMCA6\n" - "IDEpOw0KDQpUaGlzIGlzIHByb2JhYmx5IGZpbmUsIGFsdGhvdWdoIEkgYW0gbm90IGEgYmlnIGZh\n" - "biBvZiB0aGUgdGVybmFyeSBvcGVyYXRvci4NCkEgc2ltcGxlIGlmIGVsc2Ugc3RhdGVtZW50IHdv\n" - "dWxkIGRvLiBIb3dldmVyLCBJIGRvbid0IGZlZWwgc3Ryb25nbHkgYWJvdXQNCml0LCBzbyBmZWVs\n" - "IGZyZWUgdG8gZGlzYWdyZWUuwqANCg0KPiArCWJyZWFrOw0KPiArCX0NCj4gKw0KPiArCXJldHVy\n" - "biAwOw0KPiArfQ0KPiArDQo+IMKgc3RhdGljIGludCBhZDc3ODBfcG9zdHByb2Nlc3Nfc2FtcGxl\n" - "KHN0cnVjdCBhZF9zaWdtYV9kZWx0YSAqc2lnbWFfZGVsdGEsDQo+IMKgCQkJCcKgwqDCoMKgwqB1\n" - "bnNpZ25lZCBpbnQgcmF3X3NhbXBsZSkNCj4gwqB7DQo+IMKgCXN0cnVjdCBhZDc3ODBfc3RhdGUg\n" - "KnN0ID0gYWRfc2lnbWFfZGVsdGFfdG9fYWQ3NzgwKHNpZ21hX2RlbHRhKTsNCj4gwqAJY29uc3Qg\n" - "c3RydWN0IGFkNzc4MF9jaGlwX2luZm8gKmNoaXBfaW5mbyA9IHN0LT5jaGlwX2luZm87DQo+ICsJ\n" - "aW50IHZhbDsNCj4gwqANCj4gwqAJaWYgKChyYXdfc2FtcGxlICYgQUQ3NzgwX0VSUikgfHwNCj4g\n" - "wqAJwqDCoMKgwqAoKHJhd19zYW1wbGUgJiBjaGlwX2luZm8tPnBhdHRlcm5fbWFzaykgIT0gY2hp\n" - "cF9pbmZvLQ0KPiA+cGF0dGVybikpDQo+IMKgCQlyZXR1cm4gLUVJTzsNCj4gwqANCj4gwqAJaWYg\n" - "KGNoaXBfaW5mby0+aXNfYWQ3Nzh4KSB7DQo+IC0JCWlmIChyYXdfc2FtcGxlICYgQUQ3NzgwX0dB\n" - "SU4pDQo+ICsJCXZhbCA9IHJhd19zYW1wbGUgJiBBRDc3ODBfR0FJTjsNCj4gKw0KPiArCQlpZiAo\n" - "dmFsICE9IGdwaW9kX2dldF92YWx1ZShzdC0+Z2Fpbl9ncGlvKSkNCj4gKwkJCXJldHVybiAtRUlP\n" - "Ow0KDQpJdCBpcyBub3Qgb2J2aW91cyB0byBtZSB3aGF0IGlzIHRoZSBwb2ludCBvZiB0aGlzIGNo\n" - "ZWNrLiBNYXliZSB5b3UgY2FuIGFkZA0KYSBjb21tZW50Pw0KDQo+ICsNCj4gKwkJaWYgKHZhbCkN\n" - "Cj4gwqAJCQlzdC0+Z2FpbiA9IDE7DQo+IMKgCQllbHNlDQo+IMKgCQkJc3QtPmdhaW4gPSAxMjg7\n" - "DQoNCkRvIHdlIHN0aWxsIG5lZWQgdGhpcz8gSSBhbSBub3QgY29udmluY2VkLsKgDQoNCj4gQEAg\n" - "LTE0MSwxOCArMTk2LDIwIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWRfc2lnbWFfZGVsdGFfaW5m\n" - "bw0KPiBhZDc3ODBfc2lnbWFfZGVsdGFfaW5mbyA9IHsNCj4gwqAJLmhhc19yZWdpc3RlcnMgPSBm\n" - "YWxzZSwNCj4gwqB9Ow0KPiDCoA0KPiAtI2RlZmluZSBBRDc3ODBfQ0hBTk5FTChiaXRzLCB3b3Jk\n" - "c2l6ZSkgXA0KPiArI2RlZmluZSBBRDcxNzBfQ0hBTk5FTChiaXRzLCB3b3Jkc2l6ZSkgXA0KPiDC\n" - "oAlBRF9TRF9DSEFOTkVMX05PX1NBTVBfRlJFUSgxLCAwLCAwLCBiaXRzLCAzMiwgd29yZHNpemUg\n" - "LSBiaXRzKQ0KPiArI2RlZmluZSBBRDc3ODBfQ0hBTk5FTChiaXRzLCB3b3Jkc2l6ZSkgXA0KPiAr\n" - "CUFEX1NEX0NIQU5ORUxfR0FJTl9GSUxURVIoMSwgMCwgMCwgYml0cywgMzIsIHdvcmRzaXplIC0g\n" - "Yml0cykNCj4gwqANCj4gwqBzdGF0aWMgY29uc3Qgc3RydWN0IGFkNzc4MF9jaGlwX2luZm8gYWQ3\n" - "NzgwX2NoaXBfaW5mb190YmxbXSA9IHsNCj4gwqAJW0lEX0FENzE3MF0gPSB7DQo+IC0JCS5jaGFu\n" - "bmVsID0gQUQ3NzgwX0NIQU5ORUwoMTIsIDI0KSwNCj4gKwkJLmNoYW5uZWwgPSBBRDcxNzBfQ0hB\n" - "Tk5FTCgxMiwgMjQpLA0KPiDCoAkJLnBhdHRlcm4gPSBBRDcxNzBfUEFUVEVSTiwNCj4gwqAJCS5w\n" - "YXR0ZXJuX21hc2sgPSBBRDcxNzBfUEFUVEVSTl9NQVNLLA0KPiDCoAkJLmlzX2FkNzc4eCA9IGZh\n" - "bHNlLA0KPiDCoAl9LA0KPiDCoAlbSURfQUQ3MTcxXSA9IHsNCj4gLQkJLmNoYW5uZWwgPSBBRDc3\n" - "ODBfQ0hBTk5FTCgxNiwgMjQpLA0KPiArCQkuY2hhbm5lbCA9IEFENzE3MF9DSEFOTkVMKDE2LCAy\n" - "NCksDQo+IMKgCQkucGF0dGVybiA9IEFENzE3MF9QQVRURVJOLA0KPiDCoAkJLnBhdHRlcm5fbWFz\n" - "ayA9IEFENzE3MF9QQVRURVJOX01BU0ssDQo+IMKgCQkuaXNfYWQ3Nzh4ID0gZmFsc2UsDQo+IEBA\n" - "IC0xNzMsNiArMjMwLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBhZDc3ODBfY2hpcF9pbmZvDQo+\n" - "IGFkNzc4MF9jaGlwX2luZm9fdGJsW10gPSB7DQo+IMKgDQo+IMKgc3RhdGljIGNvbnN0IHN0cnVj\n" - "dCBpaW9faW5mbyBhZDc3ODBfaW5mbyA9IHsNCj4gwqAJLnJlYWRfcmF3ID0gYWQ3NzgwX3JlYWRf\n" - "cmF3LA0KPiArCS53cml0ZV9yYXcgPSBhZDc3ODBfd3JpdGVfcmF3LA0KPiDCoH07DQo+IMKgDQo+\n" - "IMKgc3RhdGljIGludCBhZDc3ODBfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkNCj4gQEAg\n" - "LTIyMiw2ICsyODAsMTggQEAgc3RhdGljIGludCBhZDc3ODBfcHJvYmUoc3RydWN0IHNwaV9kZXZp\n" - "Y2UgKnNwaSkNCj4gwqAJCWdvdG8gZXJyb3JfZGlzYWJsZV9yZWc7DQo+IMKgCX0NCj4gwqANCj4g\n" - "KwlpZiAoc3QtPmNoaXBfaW5mby0+aXNfYWQ3Nzh4KSB7DQo+ICsJCXN0LT5nYWluX2dwaW8gPSBk\n" - "ZXZtX2dwaW9kX2dldF9vcHRpb25hbCgmc3BpLT5kZXYsDQo+ICsJCQkJCQkJImdhaW4iLA0KPiAr\n" - "CQkJCQkJCUdQSU9EX09VVF9ISUdIKTsNCj4gKwkJaWYgKElTX0VSUihzdC0+Z2Fpbl9ncGlvKSkg\n" - "ew0KDQppZiB0aGUgR1BJTyBpcyBvcHRpb25hbCwgdGhlbiB3ZSBzaG91bGQgY29udGludWUgaW4g\n" - "Y2FzZSBvZsKgLUVOT0RFVi4NCg0KU2hvdWxkbid0IHdlIGhhdmUgYcKgZGV2bV9ncGlvZF9nZXRf\n" - "b3B0aW9uYWwoKSBjYWxsIGFsc28gZm9yIGZpbHRlcl9ncGlvPw0KDQo+ICsJCQlyZXQgPSBQVFJf\n" - "RVJSKHN0LT5nYWluX2dwaW8pOw0KPiArCQkJZGV2X2Vycigmc3BpLT5kZXYsICJGYWlsZWQgdG8g\n" - "cmVxdWVzdCBnYWluIEdQSU86DQo+ICVkXG4iLA0KPiArCQkJCXJldCk7DQo+ICsJCQlnb3RvIGVy\n" - "cm9yX2Rpc2FibGVfcmVnOw0KPiArCQl9DQo+ICsJfQ0KPiArDQo+IMKgCXJldCA9IGFkX3NkX3Nl\n" - "dHVwX2J1ZmZlcl9hbmRfdHJpZ2dlcihpbmRpb19kZXYpOw0KPiDCoAlpZiAocmV0KQ0KPiDCoAkJ\n" - "Z290byBlcnJvcl9kaXNhYmxlX3JlZzsNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaWlv\n" - "L2FkYy9hZF9zaWdtYV9kZWx0YS5oDQo+IGIvaW5jbHVkZS9saW51eC9paW8vYWRjL2FkX3NpZ21h\n" - "X2RlbHRhLmgNCj4gaW5kZXggNzMwZWFkMWE0NmRmLi42Y2FkYWI2ZmQ1ZmQgMTAwNjQ0DQo+IC0t\n" - "LSBhL2luY2x1ZGUvbGludXgvaWlvL2FkYy9hZF9zaWdtYV9kZWx0YS5oDQo+ICsrKyBiL2luY2x1\n" - "ZGUvbGludXgvaWlvL2FkYy9hZF9zaWdtYV9kZWx0YS5oDQo+IEBAIC0xNzMsNiArMTczLDExIEBA\n" - "IGludCBhZF9zZF92YWxpZGF0ZV90cmlnZ2VyKHN0cnVjdCBpaW9fZGV2DQo+ICppbmRpb19kZXYs\n" - "IHN0cnVjdCBpaW9fdHJpZ2dlciAqdHJpZyk7DQo+IMKgCV9fQURfU0RfQ0hBTk5FTChfc2ksIF9j\n" - "aGFubmVsLCAtMSwgX2FkZHJlc3MsIF9iaXRzLCBcDQo+IMKgCQlfc3RvcmFnZWJpdHMsIF9zaGlm\n" - "dCwgTlVMTCwgSUlPX1ZPTFRBR0UsIDApDQo+IMKgDQo+ICsjZGVmaW5lIEFEX1NEX0NIQU5ORUxf\n" - "R0FJTl9GSUxURVIoX3NpLCBfY2hhbm5lbCwgX2FkZHJlc3MsIF9iaXRzLCBcDQo+ICsJX3N0b3Jh\n" - "Z2ViaXRzLCBfc2hpZnQpIFwNCj4gKwlfX0FEX1NEX0NIQU5ORUwoX3NpLCBfY2hhbm5lbCwgLTEs\n" - "IF9hZGRyZXNzLCBfYml0cywgXA0KPiArCQlfc3RvcmFnZWJpdHMsIF9zaGlmdCwgTlVMTCwgSUlP\n" - "X1ZPTFRBR0UsDQo+IEJJVChJSU9fQ0hBTl9JTkZPX1JBVykpDQo+ICsNCj4gwqAjZGVmaW5lIEFE\n" - "X1NEX1RFTVBfQ0hBTk5FTChfc2ksIF9hZGRyZXNzLCBfYml0cywgX3N0b3JhZ2ViaXRzLCBfc2hp\n" - "ZnQpIFwNCj4gwqAJX19BRF9TRF9DSEFOTkVMKF9zaSwgMCwgLTEsIF9hZGRyZXNzLCBfYml0cywg\n" - XA0KPiDCoAkJX3N0b3JhZ2ViaXRzLCBfc2hpZnQsIE5VTEwsIElJT19URU1QLCBc + "On Mi, 2018-11-28 at 16:15 -0200, Giuliano Belinassi wrote:\n" + "> Previously, the AD7780 driver only supported gpio for the 'powerdown'\n" + "> pin. This commit adds suppport for the 'gain' and 'filter' pin.\n" + "> \n" + "> Signed-off-by: Giuliano Belinassi <giuliano.belinassi@usp.br>\n" + "> ---\n" + "> Changes in v2:\n" + "> \302\240\302\240\302\240\302\240- Now this patch is part of the patchset that aims to remove ad7780\n" + "> out of staging. https://marc.info/?l=linux-iio&m=154282349808890&w=2\n" + "> \302\240\302\240\302\240\302\240- Also, now it reads voltage and filter values from the userspace\n" + "> instead of gpio pin states.\n" + "\n" + "Hello,\n" + "Please see bellow.\n" + "\n" + "> \n" + "> \302\240drivers/staging/iio/adc/ad7780.c\302\240\302\240\302\240\302\240\302\240\302\240\302\240| 78 ++++++++++++++++++++++++--\n" + "> \302\240include/linux/iio/adc/ad_sigma_delta.h |\302\240\302\2405 ++\n" + "> \302\2402 files changed, 79 insertions(+), 4 deletions(-)\n" + "> \n" + "> diff --git a/drivers/staging/iio/adc/ad7780.c\n" + "> b/drivers/staging/iio/adc/ad7780.c\n" + "> index c4a85789c2db..05979a79fda3 100644\n" + "> --- a/drivers/staging/iio/adc/ad7780.c\n" + "> +++ b/drivers/staging/iio/adc/ad7780.c\n" + "> @@ -39,6 +39,12 @@\n" + "> \302\240#define AD7170_PATTERN\t\t(AD7780_PAT0 | AD7170_PAT2)\n" + "> \302\240#define AD7170_PATTERN_MASK\t(AD7780_PAT0 | AD7780_PAT1 |\n" + "> AD7170_PAT2)\n" + "> \302\240\n" + "> +#define AD7780_GAIN_GPIO\t0\n" + "> +#define AD7780_FILTER_GPIO\t1\n" + "> +\n" + "> +#define AD7780_GAIN_MIDPOINT\t64\n" + "> +#define AD7780_FILTER_MIDPOINT\t13350\n" + "> +\n" + "> \302\240struct ad7780_chip_info {\n" + "> \302\240\tstruct iio_chan_spec\tchannel;\n" + "> \302\240\tunsigned int\t\tpattern_mask;\n" + "> @@ -50,6 +56,8 @@ struct ad7780_state {\n" + "> \302\240\tconst struct ad7780_chip_info\t*chip_info;\n" + "> \302\240\tstruct regulator\t\t*reg;\n" + "> \302\240\tstruct gpio_desc\t\t*powerdown_gpio;\n" + "> +\tstruct gpio_desc\t\t*gain_gpio;\n" + "> +\tstruct gpio_desc\t\t*filter_gpio;\n" + "> \302\240\tunsigned int\tgain;\n" + "> \302\240\n" + "> \302\240\tstruct ad_sigma_delta sd;\n" + "> @@ -115,18 +123,65 @@ static int ad7780_read_raw(struct iio_dev\n" + "> *indio_dev,\n" + "> \302\240\treturn -EINVAL;\n" + "> \302\240}\n" + "> \302\240\n" + "> +static int ad7780_write_raw(struct iio_dev *indio_dev,\n" + "> +\t\t\t\302\240\302\240\302\240\302\240struct iio_chan_spec const *chan,\n" + "> +\t\t\t\302\240\302\240\302\240\302\240int val,\n" + "> +\t\t\t\302\240\302\240\302\240\302\240int val2,\n" + "> +\t\t\t\302\240\302\240\302\240\302\240long m)\n" + "> +{\n" + "> +\tstruct ad7780_state *st = iio_priv(indio_dev);\n" + "> +\tconst struct ad7780_chip_info *chip_info = st->chip_info;\n" + "> +\tint uvref, gain;\n" + "> +\tunsigned int full_scale;\n" + "> +\n" + "> +\tif (!chip_info->is_ad778x)\n" + "> +\t\treturn 0;\n" + "> +\n" + "> +\tswitch (m) {\n" + "> +\tcase IIO_CHAN_INFO_SCALE:\n" + "> +\t\tif (val != 0)\n" + "> +\t\t\treturn -EINVAL;\n" + "> +\n" + "> +\t\tuvref = regulator_get_voltage(st->reg);\n" + "\n" + "regulator_get_voltage() has already been called in the probe function and\n" + "the result is stored in\302\240st->int_vref_mv.\n" + "My suggestion would be to use a local vref variable declared as unsigned\n" + "int. It is my fault that I haven't explained correctly in the previous\n" + "email, but you need to multiply vref_mv with\302\2401000000LL in order to get the\n" + "right precision: vref = st->int_vref_mv * 1000000LL. Afterwards you will be\n" + "able to perform the divisions.\n" + "> +\n" + "> +\t\tif (uvref < 0)\n" + "> +\t\t\treturn uvref;\n" + "> +\n" + "> +\t\tfull_scale = 1 << (chip_info->channel.scan_type.realbits \n" + "> - 1);\n" + "> +\t\tgain = DIV_ROUND_CLOSEST(uvref, full_scale);\n" + "> +\t\tgain = DIV_ROUND_CLOSEST(gain, val2);\n" + "> +\n" + "> +\t\tgpiod_set_value(st->gain_gpio, gain <\n" + "> AD7780_GAIN_MIDPOINT ? 0 : 1);\n" + "\n" + "Once the gain is set, you can store it in st->gain variable.\n" + "\n" + "> +\tcase IIO_CHAN_INFO_SAMP_FREQ:\n" + "> +\t\tif (val2 != 0)\n" + "> +\t\t\treturn -EINVAL;\n" + "> +\n" + "> +\t\tgpiod_set_value(st->filter_gpio, val <\n" + "> AD7780_FILTER_MIDPOINT ? 0 : 1);\n" + "\n" + "This is probably fine, although I am not a big fan of the ternary operator.\n" + "A simple if else statement would do. However, I don't feel strongly about\n" + "it, so feel free to disagree.\302\240\n" + "\n" + "> +\tbreak;\n" + "> +\t}\n" + "> +\n" + "> +\treturn 0;\n" + "> +}\n" + "> +\n" + "> \302\240static int ad7780_postprocess_sample(struct ad_sigma_delta *sigma_delta,\n" + "> \302\240\t\t\t\t\302\240\302\240\302\240\302\240\302\240unsigned int raw_sample)\n" + "> \302\240{\n" + "> \302\240\tstruct ad7780_state *st = ad_sigma_delta_to_ad7780(sigma_delta);\n" + "> \302\240\tconst struct ad7780_chip_info *chip_info = st->chip_info;\n" + "> +\tint val;\n" + "> \302\240\n" + "> \302\240\tif ((raw_sample & AD7780_ERR) ||\n" + "> \302\240\t\302\240\302\240\302\240\302\240((raw_sample & chip_info->pattern_mask) != chip_info-\n" + "> >pattern))\n" + "> \302\240\t\treturn -EIO;\n" + "> \302\240\n" + "> \302\240\tif (chip_info->is_ad778x) {\n" + "> -\t\tif (raw_sample & AD7780_GAIN)\n" + "> +\t\tval = raw_sample & AD7780_GAIN;\n" + "> +\n" + "> +\t\tif (val != gpiod_get_value(st->gain_gpio))\n" + "> +\t\t\treturn -EIO;\n" + "\n" + "It is not obvious to me what is the point of this check. Maybe you can add\n" + "a comment?\n" + "\n" + "> +\n" + "> +\t\tif (val)\n" + "> \302\240\t\t\tst->gain = 1;\n" + "> \302\240\t\telse\n" + "> \302\240\t\t\tst->gain = 128;\n" + "\n" + "Do we still need this? I am not convinced.\302\240\n" + "\n" + "> @@ -141,18 +196,20 @@ static const struct ad_sigma_delta_info\n" + "> ad7780_sigma_delta_info = {\n" + "> \302\240\t.has_registers = false,\n" + "> \302\240};\n" + "> \302\240\n" + "> -#define AD7780_CHANNEL(bits, wordsize) \\\n" + "> +#define AD7170_CHANNEL(bits, wordsize) \\\n" + "> \302\240\tAD_SD_CHANNEL_NO_SAMP_FREQ(1, 0, 0, bits, 32, wordsize - bits)\n" + "> +#define AD7780_CHANNEL(bits, wordsize) \\\n" + "> +\tAD_SD_CHANNEL_GAIN_FILTER(1, 0, 0, bits, 32, wordsize - bits)\n" + "> \302\240\n" + "> \302\240static const struct ad7780_chip_info ad7780_chip_info_tbl[] = {\n" + "> \302\240\t[ID_AD7170] = {\n" + "> -\t\t.channel = AD7780_CHANNEL(12, 24),\n" + "> +\t\t.channel = AD7170_CHANNEL(12, 24),\n" + "> \302\240\t\t.pattern = AD7170_PATTERN,\n" + "> \302\240\t\t.pattern_mask = AD7170_PATTERN_MASK,\n" + "> \302\240\t\t.is_ad778x = false,\n" + "> \302\240\t},\n" + "> \302\240\t[ID_AD7171] = {\n" + "> -\t\t.channel = AD7780_CHANNEL(16, 24),\n" + "> +\t\t.channel = AD7170_CHANNEL(16, 24),\n" + "> \302\240\t\t.pattern = AD7170_PATTERN,\n" + "> \302\240\t\t.pattern_mask = AD7170_PATTERN_MASK,\n" + "> \302\240\t\t.is_ad778x = false,\n" + "> @@ -173,6 +230,7 @@ static const struct ad7780_chip_info\n" + "> ad7780_chip_info_tbl[] = {\n" + "> \302\240\n" + "> \302\240static const struct iio_info ad7780_info = {\n" + "> \302\240\t.read_raw = ad7780_read_raw,\n" + "> +\t.write_raw = ad7780_write_raw,\n" + "> \302\240};\n" + "> \302\240\n" + "> \302\240static int ad7780_probe(struct spi_device *spi)\n" + "> @@ -222,6 +280,18 @@ static int ad7780_probe(struct spi_device *spi)\n" + "> \302\240\t\tgoto error_disable_reg;\n" + "> \302\240\t}\n" + "> \302\240\n" + "> +\tif (st->chip_info->is_ad778x) {\n" + "> +\t\tst->gain_gpio = devm_gpiod_get_optional(&spi->dev,\n" + "> +\t\t\t\t\t\t\t\"gain\",\n" + "> +\t\t\t\t\t\t\tGPIOD_OUT_HIGH);\n" + "> +\t\tif (IS_ERR(st->gain_gpio)) {\n" + "\n" + "if the GPIO is optional, then we should continue in case of\302\240-ENODEV.\n" + "\n" + "Shouldn't we have a\302\240devm_gpiod_get_optional() call also for filter_gpio?\n" + "\n" + "> +\t\t\tret = PTR_ERR(st->gain_gpio);\n" + "> +\t\t\tdev_err(&spi->dev, \"Failed to request gain GPIO:\n" + "> %d\\n\",\n" + "> +\t\t\t\tret);\n" + "> +\t\t\tgoto error_disable_reg;\n" + "> +\t\t}\n" + "> +\t}\n" + "> +\n" + "> \302\240\tret = ad_sd_setup_buffer_and_trigger(indio_dev);\n" + "> \302\240\tif (ret)\n" + "> \302\240\t\tgoto error_disable_reg;\n" + "> diff --git a/include/linux/iio/adc/ad_sigma_delta.h\n" + "> b/include/linux/iio/adc/ad_sigma_delta.h\n" + "> index 730ead1a46df..6cadab6fd5fd 100644\n" + "> --- a/include/linux/iio/adc/ad_sigma_delta.h\n" + "> +++ b/include/linux/iio/adc/ad_sigma_delta.h\n" + "> @@ -173,6 +173,11 @@ int ad_sd_validate_trigger(struct iio_dev\n" + "> *indio_dev, struct iio_trigger *trig);\n" + "> \302\240\t__AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \\\n" + "> \302\240\t\t_storagebits, _shift, NULL, IIO_VOLTAGE, 0)\n" + "> \302\240\n" + "> +#define AD_SD_CHANNEL_GAIN_FILTER(_si, _channel, _address, _bits, \\\n" + "> +\t_storagebits, _shift) \\\n" + "> +\t__AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \\\n" + "> +\t\t_storagebits, _shift, NULL, IIO_VOLTAGE,\n" + "> BIT(IIO_CHAN_INFO_RAW))\n" + "> +\n" + "> \302\240#define AD_SD_TEMP_CHANNEL(_si, _address, _bits, _storagebits, _shift) \\\n" + "> \302\240\t__AD_SD_CHANNEL(_si, 0, -1, _address, _bits, \\\n" + "> \302\240\t\t_storagebits, _shift, NULL, IIO_TEMP, \\" -d51b2d86ac76dc342392bad5cdca07ab4e94bbdb134e5f0f0d6bb2e975f38075 +78cd68a95cbf3dd57bacba9e9a6a8968421b7d22bead642ae2236c037c8c95cd
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.