From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Shevchenko, Andriy" Subject: Re: [PATCH 1/3 v2] GPIO: gpio-dwapb: Enable platform driver binding to MFD driver Date: Fri, 5 Sep 2014 09:21:57 +0000 Message-ID: <1409908917.30155.84.camel@intel.com> References: <1409928798-31895-1-git-send-email-alvin.chen@intel.com> <1409928798-31895-2-git-send-email-alvin.chen@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1409928798-31895-2-git-send-email-alvin.chen@intel.com> Content-Language: en-US Content-ID: Sender: linux-kernel-owner@vger.kernel.org To: "Chen, Alvin" Cc: "linux-kernel@vger.kernel.org" , "robh+dt@kernel.org" , "Kweh, Hock Leong" , "sebastian@breakpoint.cc" , "devicetree@vger.kernel.org" , "Ong, Boon Leong" , "gnurou@gmail.com" , "linus.walleij@linaro.org" , "linux-gpio@vger.kernel.org" , "grant.likely@linaro.org" , "Westerberg, Mika" , "dvhart@linux.intel.com" , "atull@opensource.altera.com" List-Id: linux-gpio@vger.kernel.org T24gRnJpLCAyMDE0LTA5LTA1IGF0IDA3OjUzIC0wNzAwLCBXZWlrZSBDaGVuIHdyb3RlOg0KPiBU aGUgU3lub3BzeXMgRGVzaWduV2FyZSBBUEIgR1BJTyBkcml2ZXIgb25seSBzdXBwb3J0cyBvcGVu IGZpcm13YXJlIGRldmljZXMuDQo+IEJ1dCwgbGlrZSBJbnRlbCBRdWFyayBYMTAwMCBTT0MsIHdo aWNoIGhhcyBhIHNpbmdsZSBQQ0kgZnVuY3Rpb24gZXhwb3J0aW5nDQo+IGEgR1BJTyBhbmQgYW4g STJDIGNvbnRyb2xsZXIsIGl0IGlzIGEgTXVsdGlmdW5jdGlvbiBkZXZpY2UuIFRoaXMgcGF0Y2gg aXMNCj4gdG8gZW5hYmxlIHRoZSBjdXJyZW50IFN5bm9wc3lzIERlc2lnbldhcmUgQVBCIEdQSU8g ZHJpdmVyIHRvIHN1cHBvcnQgdGhlDQo+IE11bHRpZnVuY3Rpb24gZGV2aWNlIHdoaWNoIGV4cG9y dHMgdGhlIGRlc2lnbndhcmUgR1BJTyBjb250cm9sbGVyLg0KDQpGZXcgY29tbWVudHMgYmVsb3cu DQoNCj4gDQo+IFJldmlld2VkLWJ5OiBIb2NrIExlb25nIEt3ZWggPGhvY2subGVvbmcua3dlaEBp bnRlbC5jb20+DQo+IFJldmlld2VkLWJ5OiBTaGV2Y2hlbmtvLCBBbmRyaXkgPGFuZHJpeS5zaGV2 Y2hlbmtvQGludGVsLmNvbT4NCj4gU2lnbmVkLW9mZi1ieTogV2Vpa2UgQ2hlbiA8YWx2aW4uY2hl bkBpbnRlbC5jb20+DQo+IC0tLQ0KPiAgZHJpdmVycy9ncGlvL0tjb25maWcgICAgICAgICAgICAg ICAgICAgICB8ICAgIDEgLQ0KPiAgZHJpdmVycy9ncGlvL2dwaW8tZHdhcGIuYyAgICAgICAgICAg ICAgICB8ICAyMzMgKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tDQo+ICBpbmNsdWRlL2xp bnV4L3BsYXRmb3JtX2RhdGEvZ3Bpby1kd2FwYi5oIHwgICAzMiArKysrDQo+ICAzIGZpbGVzIGNo YW5nZWQsIDIxMSBpbnNlcnRpb25zKCspLCA1NSBkZWxldGlvbnMoLSkNCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBpbmNsdWRlL2xpbnV4L3BsYXRmb3JtX2RhdGEvZ3Bpby1kd2FwYi5oDQo+IA0KPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL0tjb25maWcgYi9kcml2ZXJzL2dwaW8vS2NvbmZpZw0K PiBpbmRleCA5ZGUxNTE1Li44MjUwYTQ0IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL2dwaW8vS2Nv bmZpZw0KPiArKysgYi9kcml2ZXJzL2dwaW8vS2NvbmZpZw0KPiBAQCAtMTM2LDcgKzEzNiw2IEBA IGNvbmZpZyBHUElPX0RXQVBCDQo+ICAJdHJpc3RhdGUgIlN5bm9wc3lzIERlc2lnbldhcmUgQVBC IEdQSU8gZHJpdmVyIg0KPiAgCXNlbGVjdCBHUElPX0dFTkVSSUMNCj4gIAlzZWxlY3QgR0VORVJJ Q19JUlFfQ0hJUA0KPiAtCWRlcGVuZHMgb24gT0ZfR1BJTw0KPiAgCWhlbHANCj4gIAkgIFNheSBZ IG9yIE0gaGVyZSB0byBidWlsZCBzdXBwb3J0IGZvciB0aGUgU3lub3BzeXMgRGVzaWduV2FyZSBB UEINCj4gIAkgIEdQSU8gYmxvY2suDQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vZ3Bpby1k d2FwYi5jIGIvZHJpdmVycy9ncGlvL2dwaW8tZHdhcGIuYw0KPiBpbmRleCBkNjYxOGE2Li5mMjI2 NGEyIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1kd2FwYi5jDQo+ICsrKyBiL2Ry aXZlcnMvZ3Bpby9ncGlvLWR3YXBiLmMNCj4gQEAgLTIxLDYgKzIxLDcgQEANCj4gICNpbmNsdWRl IDxsaW51eC9vZl9pcnEuaD4NCj4gICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4N Cj4gICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRm b3JtX2RhdGEvZ3Bpby1kd2FwYi5oPg0KPiAgDQo+ICAjZGVmaW5lIEdQSU9fU1dQT1JUQV9EUgkJ MHgwMA0KPiAgI2RlZmluZSBHUElPX1NXUE9SVEFfRERSCTB4MDQNCj4gQEAgLTg0LDExICs4NSwx MCBAQCBzdGF0aWMgdm9pZCBkd2FwYl90b2dnbGVfdHJpZ2dlcihzdHJ1Y3QgZHdhcGJfZ3BpbyAq Z3BpbywgdW5zaWduZWQgaW50IG9mZnMpDQo+ICAJd3JpdGVsKHYsIGdwaW8tPnJlZ3MgKyBHUElP X0lOVF9QT0xBUklUWSk7DQo+ICB9DQo+ICANCj4gLXN0YXRpYyB2b2lkIGR3YXBiX2lycV9oYW5k bGVyKHUzMiBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykNCj4gK3N0YXRpYyB1MzIgX2R3YXBi X2lycV9oYW5kbGVyKHN0cnVjdCBkd2FwYl9ncGlvICpncGlvKQ0KDQpXaGF0IGFib3V0IGR3YXBi X2RvX2lycSgpID8NCg0KDQo+ICB7DQo+IC0Jc3RydWN0IGR3YXBiX2dwaW8gKmdwaW8gPSBpcnFf Z2V0X2hhbmRsZXJfZGF0YShpcnEpOw0KPiAtCXN0cnVjdCBpcnFfY2hpcCAqY2hpcCA9IGlycV9k ZXNjX2dldF9jaGlwKGRlc2MpOw0KPiAgCXUzMiBpcnFfc3RhdHVzID0gcmVhZGxfcmVsYXhlZChn cGlvLT5yZWdzICsgR1BJT19JTlRTVEFUVVMpOw0KPiArCXUzMiByZXQgPSBpcnFfc3RhdHVzOw0K PiAgDQo+ICAJd2hpbGUgKGlycV9zdGF0dXMpIHsNCj4gIAkJaW50IGh3aXJxID0gZmxzKGlycV9z dGF0dXMpIC0gMTsNCj4gQEAgLTEwMiw2ICsxMDIsMTYgQEAgc3RhdGljIHZvaWQgZHdhcGJfaXJx X2hhbmRsZXIodTMyIGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQ0KPiAgCQkJZHdhcGJfdG9n Z2xlX3RyaWdnZXIoZ3BpbywgaHdpcnEpOw0KPiAgCX0NCj4gIA0KPiArCXJldHVybiByZXQ7DQo+ ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIGR3YXBiX2lycV9oYW5kbGVyKHUzMiBpcnEsIHN0cnVj dCBpcnFfZGVzYyAqZGVzYykNCj4gK3sNCj4gKwlzdHJ1Y3QgZHdhcGJfZ3BpbyAqZ3BpbyA9IGly cV9nZXRfaGFuZGxlcl9kYXRhKGlycSk7DQo+ICsJc3RydWN0IGlycV9jaGlwICpjaGlwID0gaXJx X2Rlc2NfZ2V0X2NoaXAoZGVzYyk7DQo+ICsNCj4gKwlfZHdhcGJfaXJxX2hhbmRsZXIoZ3Bpbyk7 DQo+ICsNCj4gIAlpZiAoY2hpcC0+aXJxX2VvaSkNCj4gIAkJY2hpcC0+aXJxX2VvaShpcnFfZGVz Y19nZXRfaXJxX2RhdGEoZGVzYykpOw0KPiAgfQ0KPiBAQCAtMjA3LDIyICsyMTcsMjYgQEAgc3Rh dGljIGludCBkd2FwYl9pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1MzIgdHlwZSkN Cj4gIAlyZXR1cm4gMDsNCj4gIH0NCj4gIA0KPiArc3RhdGljIGlycXJldHVybl90IGR3YXBiX2ly cV9oYW5kbGVyX21mZChpbnQgaXJxLCB2b2lkICpkZXZfaWQpDQo+ICt7DQo+ICsJdTMyIHdvcmtl ZDsNCj4gKwlzdHJ1Y3QgZHdhcGJfZ3BpbyAqZ3BpbyA9IChzdHJ1Y3QgZHdhcGJfZ3BpbyAqKWRl dl9pZDsNCg0KTm8gbmVlZCB0byBjYXN0IGV4cGxpY2l0bHkgZnJvbSB2b2lkICouDQoNCj4gKw0K PiArCXdvcmtlZCA9IF9kd2FwYl9pcnFfaGFuZGxlcihncGlvKTsNCj4gKw0KPiArCXJldHVybiB3 b3JrZWQgPyBJUlFfSEFORExFRCA6IElSUV9OT05FOw0KPiArfQ0KPiArDQo+ICBzdGF0aWMgdm9p ZCBkd2FwYl9jb25maWd1cmVfaXJxcyhzdHJ1Y3QgZHdhcGJfZ3BpbyAqZ3BpbywNCj4gLQkJCQkg c3RydWN0IGR3YXBiX2dwaW9fcG9ydCAqcG9ydCkNCj4gKwkJCQkgc3RydWN0IGR3YXBiX2dwaW9f cG9ydCAqcG9ydCwNCj4gKwkJCQkgc3RydWN0IGR3YXBiX3BvcnRfcHJvcGVydHkgKnBwKQ0KPiAg ew0KPiAgCXN0cnVjdCBncGlvX2NoaXAgKmdjID0gJnBvcnQtPmJnYy5nYzsNCj4gLQlzdHJ1Y3Qg ZGV2aWNlX25vZGUgKm5vZGUgPSAgZ2MtPm9mX25vZGU7DQo+IC0Jc3RydWN0IGlycV9jaGlwX2dl bmVyaWMJKmlycV9nYzsNCj4gKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUgPSBwcC0+bm9kZTsN Cj4gKwlzdHJ1Y3QgaXJxX2NoaXBfZ2VuZXJpYwkqaXJxX2djID0gTlVMTDsNCj4gIAl1bnNpZ25l ZCBpbnQgaHdpcnEsIG5ncGlvID0gZ2MtPm5ncGlvOw0KPiAgCXN0cnVjdCBpcnFfY2hpcF90eXBl ICpjdDsNCj4gLQlpbnQgZXJyLCBpcnEsIGk7DQo+IC0NCj4gLQlpcnEgPSBpcnFfb2ZfcGFyc2Vf YW5kX21hcChub2RlLCAwKTsNCj4gLQlpZiAoIWlycSkgew0KPiAtCQlkZXZfd2FybihncGlvLT5k ZXYsICJubyBpcnEgZm9yIGJhbmsgJXNcbiIsDQo+IC0JCQlwb3J0LT5iZ2MuZ2Mub2Zfbm9kZS0+ ZnVsbF9uYW1lKTsNCj4gLQkJcmV0dXJuOw0KPiAtCX0NCj4gKwlpbnQgZXJyLCBpOw0KPiAgDQo+ ICAJZ3Bpby0+ZG9tYWluID0gaXJxX2RvbWFpbl9hZGRfbGluZWFyKG5vZGUsIG5ncGlvLA0KPiAg CQkJCQkgICAgICZpcnFfZ2VuZXJpY19jaGlwX29wcywgZ3Bpbyk7DQo+IEBAIC0yNjksOCArMjgz LDI0IEBAIHN0YXRpYyB2b2lkIGR3YXBiX2NvbmZpZ3VyZV9pcnFzKHN0cnVjdCBkd2FwYl9ncGlv ICpncGlvLA0KPiAgCWlycV9nYy0+Y2hpcF90eXBlc1sxXS50eXBlID0gSVJRX1RZUEVfRURHRV9C T1RIOw0KPiAgCWlycV9nYy0+Y2hpcF90eXBlc1sxXS5oYW5kbGVyID0gaGFuZGxlX2VkZ2VfaXJx Ow0KPiAgDQo+IC0JaXJxX3NldF9jaGFpbmVkX2hhbmRsZXIoaXJxLCBkd2FwYl9pcnFfaGFuZGxl cik7DQo+IC0JaXJxX3NldF9oYW5kbGVyX2RhdGEoaXJxLCBncGlvKTsNCj4gKwlpZiAoIXBwLT5p cnFfc2hhcmVkKSB7DQo+ICsJCWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyKHBwLT5pcnEsIGR3YXBi X2lycV9oYW5kbGVyKTsNCj4gKwkJaXJxX3NldF9oYW5kbGVyX2RhdGEocHAtPmlycSwgZ3Bpbyk7 DQo+ICsJfSBlbHNlIHsNCj4gKwkJLyoNCj4gKwkJICogUmVxdWVzdCBhIHNoYXJlZCBJUlEgc2lu Y2Ugd2hlcmUgTUZEIHdvdWxkIGhhdmUgZGV2aWNlcw0KPiArCQkgKiB1c2luZyB0aGUgc2FtZSBp cnEgcGluDQo+ICsJCSAqLw0KPiArCQllcnIgPSBkZXZtX3JlcXVlc3RfaXJxKGdwaW8tPmRldiwg cHAtPmlycSwNCj4gKwkJCQkgICAgICAgZHdhcGJfaXJxX2hhbmRsZXJfbWZkLA0KPiArCQkJCSAg ICAgICBJUlFGX1NIQVJFRCwgImdwaW8tZHdhcGItbWZkIiwgZ3Bpbyk7DQo+ICsJCWlmIChlcnIp IHsNCj4gKwkJCWRldl9lcnIoZ3Bpby0+ZGV2LCAiZXJyb3IgcmVxdWVzdGluZyBJUlFcbiIpOw0K PiArCQkJaXJxX2RvbWFpbl9yZW1vdmUoZ3Bpby0+ZG9tYWluKTsNCj4gKwkJCWdwaW8tPmRvbWFp biA9IE5VTEw7DQo+ICsJCQlyZXR1cm47DQo+ICsJCX0NCj4gKwl9DQo+ICANCj4gIAlmb3IgKGh3 aXJxID0gMCA7IGh3aXJxIDwgbmdwaW8gOyBod2lycSsrKQ0KPiAgCQlpcnFfY3JlYXRlX21hcHBp bmcoZ3Bpby0+ZG9tYWluLCBod2lycSk7DQo+IEBAIC0yOTYsNTcgKzMyNiw0MiBAQCBzdGF0aWMg dm9pZCBkd2FwYl9pcnFfdGVhcmRvd24oc3RydWN0IGR3YXBiX2dwaW8gKmdwaW8pDQo+ICB9DQo+ ICANCj4gIHN0YXRpYyBpbnQgZHdhcGJfZ3Bpb19hZGRfcG9ydChzdHJ1Y3QgZHdhcGJfZ3BpbyAq Z3BpbywNCj4gLQkJCSAgICAgICBzdHJ1Y3QgZGV2aWNlX25vZGUgKnBvcnRfbnAsDQo+ICsJCQkg ICAgICAgc3RydWN0IGR3YXBiX3BvcnRfcHJvcGVydHkgKnBwLA0KPiAgCQkJICAgICAgIHVuc2ln bmVkIGludCBvZmZzKQ0KPiAgew0KPiAgCXN0cnVjdCBkd2FwYl9ncGlvX3BvcnQgKnBvcnQ7DQo+ IC0JdTMyIHBvcnRfaWR4LCBuZ3BpbzsNCj4gIAl2b2lkIF9faW9tZW0gKmRhdCwgKnNldCwgKmRp cm91dDsNCj4gIAlpbnQgZXJyOw0KPiAgDQo+IC0JaWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyKHBv cnRfbnAsICJyZWciLCAmcG9ydF9pZHgpIHx8DQo+IC0JCXBvcnRfaWR4ID49IERXQVBCX01BWF9Q T1JUUykgew0KPiAtCQlkZXZfZXJyKGdwaW8tPmRldiwgIm1pc3NpbmcvaW52YWxpZCBwb3J0IGlu ZGV4IGZvciAlc1xuIiwNCj4gLQkJCXBvcnRfbnAtPmZ1bGxfbmFtZSk7DQo+IC0JCXJldHVybiAt RUlOVkFMOw0KPiAtCX0NCj4gLQ0KPiAgCXBvcnQgPSAmZ3Bpby0+cG9ydHNbb2Zmc107DQo+ICAJ cG9ydC0+Z3BpbyA9IGdwaW87DQo+ICANCj4gLQlpZiAob2ZfcHJvcGVydHlfcmVhZF91MzIocG9y dF9ucCwgInNucHMsbnItZ3Bpb3MiLCAmbmdwaW8pKSB7DQo+IC0JCWRldl9pbmZvKGdwaW8tPmRl diwgImZhaWxlZCB0byBnZXQgbnVtYmVyIG9mIGdwaW9zIGZvciAlc1xuIiwNCj4gLQkJCSBwb3J0 X25wLT5mdWxsX25hbWUpOw0KPiAtCQluZ3BpbyA9IDMyOw0KPiAtCX0NCj4gLQ0KPiAtCWRhdCA9 IGdwaW8tPnJlZ3MgKyBHUElPX0VYVF9QT1JUQSArIChwb3J0X2lkeCAqIEdQSU9fRVhUX1BPUlRf U0laRSk7DQo+IC0Jc2V0ID0gZ3Bpby0+cmVncyArIEdQSU9fU1dQT1JUQV9EUiArIChwb3J0X2lk eCAqIEdQSU9fU1dQT1JUX0RSX1NJWkUpOw0KPiArCWRhdCA9IGdwaW8tPnJlZ3MgKyBHUElPX0VY VF9QT1JUQSArIChwcC0+aWR4ICogR1BJT19FWFRfUE9SVF9TSVpFKTsNCj4gKwlzZXQgPSBncGlv LT5yZWdzICsgR1BJT19TV1BPUlRBX0RSICsgKHBwLT5pZHggKiBHUElPX1NXUE9SVF9EUl9TSVpF KTsNCj4gIAlkaXJvdXQgPSBncGlvLT5yZWdzICsgR1BJT19TV1BPUlRBX0REUiArDQo+IC0JCShw b3J0X2lkeCAqIEdQSU9fU1dQT1JUX0REUl9TSVpFKTsNCj4gKwkJKHBwLT5pZHggKiBHUElPX1NX UE9SVF9ERFJfU0laRSk7DQo+ICANCj4gIAllcnIgPSBiZ3Bpb19pbml0KCZwb3J0LT5iZ2MsIGdw aW8tPmRldiwgNCwgZGF0LCBzZXQsIE5VTEwsIGRpcm91dCwNCj4gIAkJCSBOVUxMLCBmYWxzZSk7 DQo+ICAJaWYgKGVycikgew0KPiAgCQlkZXZfZXJyKGdwaW8tPmRldiwgImZhaWxlZCB0byBpbml0 IGdwaW8gY2hpcCBmb3IgJXNcbiIsDQo+IC0JCQlwb3J0X25wLT5mdWxsX25hbWUpOw0KPiArCQkJ cHAtPm5hbWUpOw0KPiAgCQlyZXR1cm4gZXJyOw0KPiAgCX0NCj4gIA0KPiAtCXBvcnQtPmJnYy5n Yy5uZ3BpbyA9IG5ncGlvOw0KPiAtCXBvcnQtPmJnYy5nYy5vZl9ub2RlID0gcG9ydF9ucDsNCj4g KyNpZmRlZiBDT05GSUdfT0ZfR1BJTw0KDQpEbyB3ZSByZWFsbHkgbmVlZCB0aGlzICNpZmRlZiA/ DQpvZl9ub2RlIHdpbGwgYmUgTlVMTCBhbnl3YXksIG9yIEkgbWlzc2VkIHNvbWV0aGluZz8NCg0K PiArCXBvcnQtPmJnYy5nYy5vZl9ub2RlID0gcHAtPm5vZGU7DQo+ICsjZW5kaWYNCj4gKwlwb3J0 LT5iZ2MuZ2MubmdwaW8gPSBwcC0+bmdwaW87DQo+ICsJcG9ydC0+YmdjLmdjLmJhc2UgPSBwcC0+ Z3Bpb19iYXNlOw0KPiAgDQo+IC0JLyoNCj4gLQkgKiBPbmx5IHBvcnQgQSBjYW4gcHJvdmlkZSBp bnRlcnJ1cHRzIGluIGFsbCBjb25maWd1cmF0aW9ucyBvZiB0aGUgSVAuDQo+IC0JICovDQo+IC0J aWYgKHBvcnRfaWR4ID09IDAgJiYNCj4gLQkgICAgb2ZfcHJvcGVydHlfcmVhZF9ib29sKHBvcnRf bnAsICJpbnRlcnJ1cHQtY29udHJvbGxlciIpKQ0KPiAtCQlkd2FwYl9jb25maWd1cmVfaXJxcyhn cGlvLCBwb3J0KTsNCj4gKwlpZiAocHAtPmlycSkNCg0KaXJxID09IDAgaXMgYSB2YWxpZCBod2ly cSAoaGFyZHdhcmUgaXJxKSBudW1iZXIuIFllcywgdGhlcmUgaXMgdW5saWtlbHkNCndlIGhhdmUg aXQgc29tZXdoZXJlLCBidXQgc3RpbGwgaXQncyBwb3NzaWJsZS4gQW5kIHllcywgSVJRIGZyYW1l d29yaw0KZG9lc24ndCB3b3JrIHdpdGggdmlycSA9PSAwICgqdmlydHVhbCogaXJxKSwgYnV0IGFj Y2VwdHMgaHdpcnEgPT0gMC4gSQ0KcmVjb21tZW5kIHRvIHVzZSBpbnQgdHlwZSBmb3IgaXJxIGxp bmUgbnVtYmVyLCBhbmQgcmVjb2duaXplIG5lZ2F0aXZlDQp2YWx1ZSAodXN1YWxseSAtMSkgYXMg bm8gaXJxIG5lZWRlZCAvIGZvdW5kLg0KDQo+ICsJCWR3YXBiX2NvbmZpZ3VyZV9pcnFzKGdwaW8s IHBvcnQsIHBwKTsNCj4gIA0KPiAgCWVyciA9IGdwaW9jaGlwX2FkZCgmcG9ydC0+YmdjLmdjKTsN Cj4gIAlpZiAoZXJyKQ0KPiAgCQlkZXZfZXJyKGdwaW8tPmRldiwgImZhaWxlZCB0byByZWdpc3Rl ciBncGlvY2hpcCBmb3IgJXNcbiIsDQo+IC0JCQlwb3J0X25wLT5mdWxsX25hbWUpOw0KPiArCQkJ cHAtPm5hbWUpOw0KPiAgCWVsc2UNCj4gIAkJcG9ydC0+aXNfcmVnaXN0ZXJlZCA9IHRydWU7DQo+ ICANCj4gQEAgLTM2MiwyNSArMzc3LDEzMCBAQCBzdGF0aWMgdm9pZCBkd2FwYl9ncGlvX3VucmVn aXN0ZXIoc3RydWN0IGR3YXBiX2dwaW8gKmdwaW8pDQo+ICAJCQlncGlvY2hpcF9yZW1vdmUoJmdw aW8tPnBvcnRzW21dLmJnYy5nYyk7DQo+ICB9DQo+ICANCj4gKyNpZmRlZiBDT05GSUdfT0ZfR1BJ Tw0KPiArDQo+ICtzdGF0aWMgc3RydWN0IGR3YXBiX3BsYXRmb3JtX2RhdGEgKg0KPiArZHdhcGJf Z3Bpb19nZXRfcGRhdGFfb2Yoc3RydWN0IGRldmljZSAqZGV2KQ0KPiArew0KPiArCXN0cnVjdCBk ZXZpY2Vfbm9kZSAqbm9kZSwgKnBvcnRfbnA7DQo+ICsJc3RydWN0IGR3YXBiX3BsYXRmb3JtX2Rh dGEgKnBkYXRhOw0KPiArCXN0cnVjdCBkd2FwYl9wb3J0X3Byb3BlcnR5ICpwcDsNCj4gKwlpbnQg bnBvcnRzOw0KPiArCWludCBpOw0KPiArDQo+ICsJbm9kZSA9IGRldi0+b2Zfbm9kZTsNCj4gKwlp ZiAoIW5vZGUpDQo+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOw0KPiArDQo+ICsJbnBvcnRz ID0gb2ZfZ2V0X2NoaWxkX2NvdW50KG5vZGUpOw0KPiArCWlmIChucG9ydHMgPT0gMCkNCj4gKwkJ cmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7DQo+ICsNCj4gKwlwZGF0YSA9IGRldm1fa3phbGxvYyhk ZXYsIHNpemVvZigqcGRhdGEpLCBHRlBfS0VSTkVMKTsNCj4gKwlpZiAoIXBkYXRhKQ0KPiArCQly ZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsNCj4gKw0KPiArCXBkYXRhLT5wcm9wZXJ0aWVzID0gZGV2 bV9rY2FsbG9jKGRldiwgbnBvcnRzLCBzaXplb2YoKnBwKSwgR0ZQX0tFUk5FTCk7DQo+ICsJaWYg KCFwZGF0YS0+cHJvcGVydGllcykNCj4gKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7DQo+ICsN Cj4gKwlwZGF0YS0+bnBvcnRzID0gbnBvcnRzOw0KPiArDQo+ICsJaSA9IDA7DQo+ICsJZm9yX2Vh Y2hfY2hpbGRfb2Zfbm9kZShub2RlLCBwb3J0X25wKSB7DQo+ICsJCXBwID0gJnBkYXRhLT5wcm9w ZXJ0aWVzW2krK107DQo+ICsJCXBwLT5ub2RlID0gcG9ydF9ucDsNCj4gKw0KPiArCQlpZiAob2Zf cHJvcGVydHlfcmVhZF91MzIocG9ydF9ucCwgInJlZyIsICZwcC0+aWR4KSB8fA0KPiArCQkgICAg cHAtPmlkeCA+PSBEV0FQQl9NQVhfUE9SVFMpIHsNCj4gKwkJCWRldl9lcnIoZGV2LCAibWlzc2lu Zy9pbnZhbGlkIHBvcnQgaW5kZXggZm9yICVzXG4iLA0KPiArCQkJCXBvcnRfbnAtPmZ1bGxfbmFt ZSk7DQo+ICsJCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsNCj4gKwkJfQ0KPiArDQo+ICsJCWlm IChvZl9wcm9wZXJ0eV9yZWFkX3UzMihwb3J0X25wLCAic25wcyxuci1ncGlvcyIsDQo+ICsJCQkJ CSAmcHAtPm5ncGlvKSkgew0KPiArCQkJZGV2X2luZm8oZGV2LCAiZmFpbGVkIHRvIGdldCBudW1i ZXIgb2YgZ3Bpb3MgZm9yICVzXG4iLA0KPiArCQkJCSBwb3J0X25wLT5mdWxsX25hbWUpOw0KPiAr CQkJcHAtPm5ncGlvID0gMzI7DQo+ICsJCX0NCj4gKw0KPiArCQkvKg0KPiArCQkgKiBPbmx5IHBv cnQgQSBjYW4gcHJvdmlkZSBpbnRlcnJ1cHRzIGluIGFsbCBjb25maWd1cmF0aW9ucyBvZg0KPiAr CQkgKiB0aGUgSVAuDQo+ICsJCSAqLw0KPiArCQlpZiAocHAtPmlkeCA9PSAwICYmDQo+ICsJCSAg ICBvZl9wcm9wZXJ0eV9yZWFkX2Jvb2wocG9ydF9ucCwgImludGVycnVwdC1jb250cm9sbGVyIikp IHsNCj4gKwkJCXBwLT5pcnEgPSBpcnFfb2ZfcGFyc2VfYW5kX21hcChwb3J0X25wLCAwKTsNCj4g KwkJCWlmICghcHAtPmlycSkgew0KPiArCQkJCWRldl93YXJuKGRldiwgIm5vIGlycSBmb3IgYmFu ayAlc1xuIiwNCj4gKwkJCQkJIHBvcnRfbnAtPmZ1bGxfbmFtZSk7DQo+ICsJCQl9DQo+ICsJCX0g ZWxzZSB7DQo+ICsJCQlwcC0+aXJxCT0gMDsNCj4gKwkJfQ0KPiArDQo+ICsJCXBwLT5pcnFfc2hh cmVkCT0gZmFsc2U7DQo+ICsJCXBwLT5ncGlvX2Jhc2UJPSAtMTsNCj4gKwkJcHAtPm5hbWUJPSBw b3J0X25wLT5mdWxsX25hbWU7DQo+ICsJfQ0KPiArDQo+ICsJcmV0dXJuIHBkYXRhOw0KPiArfQ0K PiArDQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgZHdhcGJfZnJlZV9wZGF0YV9vZihzdHJ1Y3QgZGV2 aWNlICpkZXYsDQo+ICsJCQkJICAgICAgIHN0cnVjdCBkd2FwYl9wbGF0Zm9ybV9kYXRhICpwZGF0 YSkNCj4gK3sNCj4gKwlpZiAoIXBkYXRhKQ0KPiArCQlyZXR1cm47DQo+ICsJaWYgKHBkYXRhLT5w cm9wZXJ0aWVzKQ0KPiArCQlkZXZtX2tmcmVlKGRldiwgcGRhdGEtPnByb3BlcnRpZXMpOw0KPiAr CWRldm1fa2ZyZWUoZGV2LCBwZGF0YSk7DQo+ICt9DQo+ICsNCj4gKyNlbHNlDQo+ICsNCj4gK3N0 YXRpYyBpbmxpbmUgc3RydWN0IGR3YXBiX3BsYXRmb3JtX2RhdGEgKg0KPiArZHdhcGJfZ3Bpb19n ZXRfcGRhdGFfb2Yoc3RydWN0IGRldmljZSAqZGV2KQ0KPiArew0KPiArCXJldHVybiBFUlJfUFRS KC1FTk9ERVYpOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgZHdhcGJfZnJlZV9w ZGF0YV9vZihzdHJ1Y3QgZGV2aWNlICpkZXYsDQo+ICsJCQkJICAgICAgIHN0cnVjdCBkd2FwYl9w bGF0Zm9ybV9kYXRhICpwZGF0YSkNCj4gK3sNCj4gK30NCj4gKw0KPiArI2VuZGlmDQo+ICsNCj4g IHN0YXRpYyBpbnQgZHdhcGJfZ3Bpb19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 KQ0KPiAgew0KPiArCWludCBpOw0KPiArCWJvb2wgaXNfb2Y7DQoNCmlzX3BkYXRhX2FsbG9jIChp dCBtaWdodCBiZSBub3Qgb25seSBPRiBjYXNlIGluIGZ1dHVyZSkuDQoNCg0KDQo+ICAJc3RydWN0 IHJlc291cmNlICpyZXM7DQo+ICAJc3RydWN0IGR3YXBiX2dwaW8gKmdwaW87DQo+IC0Jc3RydWN0 IGRldmljZV9ub2RlICpucDsNCj4gIAlpbnQgZXJyOw0KPiAtCXVuc2lnbmVkIGludCBvZmZzID0g MDsNCj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2Ow0KPiArCXN0cnVjdCBkd2Fw Yl9wbGF0Zm9ybV9kYXRhICpwZGF0YSA9IGRldl9nZXRfcGxhdGRhdGEoZGV2KTsNCj4gKw0KPiAr CWlmICghcGRhdGEpIHsNCg0KKCopDQoNCj4gKwkJcGRhdGEgPSBkd2FwYl9ncGlvX2dldF9wZGF0 YV9vZihkZXYpOw0KPiArCQlpZiAoSVNfRVJSKHBkYXRhKSkNCj4gKwkJCXJldHVybiBQVFJfRVJS KHBkYXRhKTsNCg0KPiArCQlpc19vZiA9IHRydWU7DQo+ICsJfSBlbHNlIHsNCj4gKwkJaXNfb2Yg PSBmYWxzZTsNCg0KSW5zdGVhZCBvZiBhYm92ZSB0aHJlZSBsaW5lcywgaG93IGFib3V0DQpib29s IGlzX3BkYXRhX2FsbG9jID0gIXBkYXRhOw0KDQpBbmQgKCopIGlmIChpc19wZGF0YV9hbGxvYykg Li4uDQoNCg0KPiArCX0NCj4gKwlpZiAoIXBkYXRhLT5ucG9ydHMpDQo+ICsJCXJldHVybiAtRU5P REVWOw0KPiAgDQo+ICAJZ3BpbyA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmdw aW8pLCBHRlBfS0VSTkVMKTsNCj4gIAlpZiAoIWdwaW8pDQo+ICAJCXJldHVybiAtRU5PTUVNOw0K PiAgCWdwaW8tPmRldiA9ICZwZGV2LT5kZXY7DQo+ICsJZ3Bpby0+bnJfcG9ydHMgPSBwZGF0YS0+ bnBvcnRzOw0KPiAgDQo+IC0JZ3Bpby0+bnJfcG9ydHMgPSBvZl9nZXRfY2hpbGRfY291bnQocGRl di0+ZGV2Lm9mX25vZGUpOw0KPiAtCWlmICghZ3Bpby0+bnJfcG9ydHMpIHsNCj4gLQkJZXJyID0g LUVJTlZBTDsNCj4gLQkJZ290byBvdXRfZXJyOw0KPiAtCX0NCj4gLQlncGlvLT5wb3J0cyA9IGRl dm1fa3phbGxvYygmcGRldi0+ZGV2LCBncGlvLT5ucl9wb3J0cyAqDQo+ICsJZ3Bpby0+cG9ydHMg PSBkZXZtX2tjYWxsb2MoJnBkZXYtPmRldiwgZ3Bpby0+bnJfcG9ydHMsDQo+ICAJCQkJICAgc2l6 ZW9mKCpncGlvLT5wb3J0cyksIEdGUF9LRVJORUwpOw0KPiAgCWlmICghZ3Bpby0+cG9ydHMpIHsN Cj4gIAkJZXJyID0gLUVOT01FTTsNCj4gQEAgLTM5NCwxMyArNTE0LDE4IEBAIHN0YXRpYyBpbnQg ZHdhcGJfZ3Bpb19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiAgCQlnb3Rv IG91dF9lcnI7DQo+ICAJfQ0KPiAgDQo+IC0JZm9yX2VhY2hfY2hpbGRfb2Zfbm9kZShwZGV2LT5k ZXYub2Zfbm9kZSwgbnApIHsNCj4gLQkJZXJyID0gZHdhcGJfZ3Bpb19hZGRfcG9ydChncGlvLCBu cCwgb2ZmcysrKTsNCj4gKwlmb3IgKGkgPSAwOyBpIDwgZ3Bpby0+bnJfcG9ydHM7IGkrKykgew0K PiArCQllcnIgPSBkd2FwYl9ncGlvX2FkZF9wb3J0KGdwaW8sICZwZGF0YS0+cHJvcGVydGllc1tp XSwgaSk7DQo+ICAJCWlmIChlcnIpDQo+ICAJCQlnb3RvIG91dF91bnJlZ2lzdGVyOw0KPiAgCX0N Cj4gIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBncGlvKTsNCj4gIA0KPiArCWlmIChpc19v Zikgew0KPiArCQlkd2FwYl9mcmVlX3BkYXRhX29mKGRldiwgcGRhdGEpOw0KPiArCQlwZGF0YSA9 IE5VTEw7DQoNCkJlc2lkZXMgdGhhdCBwZGF0YSBhc3NpZ25tZW50IGlzIHByb2JhYmx5IHJlZHVu ZGFudCwgeW91IG1heSB1c2UgcGxhaW4NCmttYWxsb2Mva2ZyZWUgYW5kIGF2b2lkIHVubmVjZXNz YXJ5IGRldm1fKiBjYWxscy4NCg0KPiArCX0NCj4gKw0KPiAgCXJldHVybiAwOw0KPiAgDQo+ICBv dXRfdW5yZWdpc3RlcjoNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGxhdGZvcm1fZGF0 YS9ncGlvLWR3YXBiLmggYi9pbmNsdWRlL2xpbnV4L3BsYXRmb3JtX2RhdGEvZ3Bpby1kd2FwYi5o DQo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0DQo+IGluZGV4IDAwMDAwMDAuLjI4NzAyYzgNCj4gLS0t IC9kZXYvbnVsbA0KPiArKysgYi9pbmNsdWRlL2xpbnV4L3BsYXRmb3JtX2RhdGEvZ3Bpby1kd2Fw Yi5oDQo+IEBAIC0wLDAgKzEsMzIgQEANCj4gKy8qDQo+ICsgKiBDb3B5cmlnaHQoYykgMjAxNCBJ bnRlbCBDb3Jwb3JhdGlvbi4NCj4gKyAqDQo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdA0KPiArICogdW5k ZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSwNCj4gKyAqIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24uDQo+ICsgKg0KPiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVA0KPiArICogQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZ IG9yDQo+ICsgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yDQo+ICsgKiBtb3JlIGRldGFpbHMuDQo+ICsgKi8N Cj4gKw0KPiArI2lmbmRlZiBHUElPX0RXX0FQQl9IDQo+ICsjZGVmaW5lIEdQSU9fRFdfQVBCX0gN Cj4gKw0KPiArc3RydWN0IGR3YXBiX3BvcnRfcHJvcGVydHkgew0KPiArCXN0cnVjdCBkZXZpY2Vf bm9kZSAqbm9kZTsNCj4gKwljb25zdCBjaGFyCSpuYW1lOw0KPiArCXVuc2lnbmVkIGludAlpZHg7 DQo+ICsJdW5zaWduZWQgaW50CW5ncGlvOw0KPiArCXVuc2lnbmVkIGludAlncGlvX2Jhc2U7DQo+ ICsJdW5zaWduZWQgaW50CWlycTsNCj4gKwlib29sCQlpcnFfc2hhcmVkOw0KPiArfTsNCj4gKw0K PiArc3RydWN0IGR3YXBiX3BsYXRmb3JtX2RhdGEgew0KPiArCXN0cnVjdCBkd2FwYl9wb3J0X3By b3BlcnR5ICpwcm9wZXJ0aWVzOw0KPiArCXVuc2lnbmVkIGludCBucG9ydHM7DQo+ICt9Ow0KPiAr DQo+ICsjZW5kaWYNCg0KDQotLSANCkFuZHkgU2hldmNoZW5rbyA8YW5kcml5LnNoZXZjaGVua29A aW50ZWwuY29tPg0KSW50ZWwgRmlubGFuZCBPeQ0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkludGVsIEZpbmxhbmQg T3kKUmVnaXN0ZXJlZCBBZGRyZXNzOiBQTCAyODEsIDAwMTgxIEhlbHNpbmtpIApCdXNpbmVzcyBJ ZGVudGl0eSBDb2RlOiAwMzU3NjA2IC0gNCAKRG9taWNpbGVkIGluIEhlbHNpbmtpIAoKVGhpcyBl LW1haWwgYW5kIGFueSBhdHRhY2htZW50cyBtYXkgY29udGFpbiBjb25maWRlbnRpYWwgbWF0ZXJp YWwgZm9yCnRoZSBzb2xlIHVzZSBvZiB0aGUgaW50ZW5kZWQgcmVjaXBpZW50KHMpLiBBbnkgcmV2 aWV3IG9yIGRpc3RyaWJ1dGlvbgpieSBvdGhlcnMgaXMgc3RyaWN0bHkgcHJvaGliaXRlZC4gSWYg eW91IGFyZSBub3QgdGhlIGludGVuZGVkCnJlY2lwaWVudCwgcGxlYXNlIGNvbnRhY3QgdGhlIHNl bmRlciBhbmQgZGVsZXRlIGFsbCBjb3BpZXMuCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756273AbaIEJWW (ORCPT ); Fri, 5 Sep 2014 05:22:22 -0400 Received: from mga02.intel.com ([134.134.136.20]:3066 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751999AbaIEJWT (ORCPT ); Fri, 5 Sep 2014 05:22:19 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.04,471,1406617200"; d="scan'208";a="598416487" From: "Shevchenko, Andriy" To: "Chen, Alvin" CC: "linux-kernel@vger.kernel.org" , "robh+dt@kernel.org" , "Kweh, Hock Leong" , "sebastian@breakpoint.cc" , "devicetree@vger.kernel.org" , "Ong, Boon Leong" , "gnurou@gmail.com" , "linus.walleij@linaro.org" , "linux-gpio@vger.kernel.org" , "grant.likely@linaro.org" , "Westerberg, Mika" , "dvhart@linux.intel.com" , "atull@opensource.altera.com" Subject: Re: [PATCH 1/3 v2] GPIO: gpio-dwapb: Enable platform driver binding to MFD driver Thread-Topic: [PATCH 1/3 v2] GPIO: gpio-dwapb: Enable platform driver binding to MFD driver Thread-Index: AQHPyNc/kBMLSfD+Nk6gyOY6CiHQz5vyMzuA Date: Fri, 5 Sep 2014 09:21:57 +0000 Message-ID: <1409908917.30155.84.camel@intel.com> References: <1409928798-31895-1-git-send-email-alvin.chen@intel.com> <1409928798-31895-2-git-send-email-alvin.chen@intel.com> In-Reply-To: <1409928798-31895-2-git-send-email-alvin.chen@intel.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.237.72.168] Content-Type: text/plain; charset="utf-8" Content-ID: MIME-Version: 1.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id s859MYee015964 On Fri, 2014-09-05 at 07:53 -0700, Weike Chen wrote: > The Synopsys DesignWare APB GPIO driver only supports open firmware devices. > But, like Intel Quark X1000 SOC, which has a single PCI function exporting > a GPIO and an I2C controller, it is a Multifunction device. This patch is > to enable the current Synopsys DesignWare APB GPIO driver to support the > Multifunction device which exports the designware GPIO controller. Few comments below. > > Reviewed-by: Hock Leong Kweh > Reviewed-by: Shevchenko, Andriy > Signed-off-by: Weike Chen > --- > drivers/gpio/Kconfig | 1 - > drivers/gpio/gpio-dwapb.c | 233 +++++++++++++++++++++++------- > include/linux/platform_data/gpio-dwapb.h | 32 ++++ > 3 files changed, 211 insertions(+), 55 deletions(-) > create mode 100644 include/linux/platform_data/gpio-dwapb.h > > diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig > index 9de1515..8250a44 100644 > --- a/drivers/gpio/Kconfig > +++ b/drivers/gpio/Kconfig > @@ -136,7 +136,6 @@ config GPIO_DWAPB > tristate "Synopsys DesignWare APB GPIO driver" > select GPIO_GENERIC > select GENERIC_IRQ_CHIP > - depends on OF_GPIO > help > Say Y or M here to build support for the Synopsys DesignWare APB > GPIO block. > diff --git a/drivers/gpio/gpio-dwapb.c b/drivers/gpio/gpio-dwapb.c > index d6618a6..f2264a2 100644 > --- a/drivers/gpio/gpio-dwapb.c > +++ b/drivers/gpio/gpio-dwapb.c > @@ -21,6 +21,7 @@ > #include > #include > #include > +#include > > #define GPIO_SWPORTA_DR 0x00 > #define GPIO_SWPORTA_DDR 0x04 > @@ -84,11 +85,10 @@ static void dwapb_toggle_trigger(struct dwapb_gpio *gpio, unsigned int offs) > writel(v, gpio->regs + GPIO_INT_POLARITY); > } > > -static void dwapb_irq_handler(u32 irq, struct irq_desc *desc) > +static u32 _dwapb_irq_handler(struct dwapb_gpio *gpio) What about dwapb_do_irq() ? > { > - struct dwapb_gpio *gpio = irq_get_handler_data(irq); > - struct irq_chip *chip = irq_desc_get_chip(desc); > u32 irq_status = readl_relaxed(gpio->regs + GPIO_INTSTATUS); > + u32 ret = irq_status; > > while (irq_status) { > int hwirq = fls(irq_status) - 1; > @@ -102,6 +102,16 @@ static void dwapb_irq_handler(u32 irq, struct irq_desc *desc) > dwapb_toggle_trigger(gpio, hwirq); > } > > + return ret; > +} > + > +static void dwapb_irq_handler(u32 irq, struct irq_desc *desc) > +{ > + struct dwapb_gpio *gpio = irq_get_handler_data(irq); > + struct irq_chip *chip = irq_desc_get_chip(desc); > + > + _dwapb_irq_handler(gpio); > + > if (chip->irq_eoi) > chip->irq_eoi(irq_desc_get_irq_data(desc)); > } > @@ -207,22 +217,26 @@ static int dwapb_irq_set_type(struct irq_data *d, u32 type) > return 0; > } > > +static irqreturn_t dwapb_irq_handler_mfd(int irq, void *dev_id) > +{ > + u32 worked; > + struct dwapb_gpio *gpio = (struct dwapb_gpio *)dev_id; No need to cast explicitly from void *. > + > + worked = _dwapb_irq_handler(gpio); > + > + return worked ? IRQ_HANDLED : IRQ_NONE; > +} > + > static void dwapb_configure_irqs(struct dwapb_gpio *gpio, > - struct dwapb_gpio_port *port) > + struct dwapb_gpio_port *port, > + struct dwapb_port_property *pp) > { > struct gpio_chip *gc = &port->bgc.gc; > - struct device_node *node = gc->of_node; > - struct irq_chip_generic *irq_gc; > + struct device_node *node = pp->node; > + struct irq_chip_generic *irq_gc = NULL; > unsigned int hwirq, ngpio = gc->ngpio; > struct irq_chip_type *ct; > - int err, irq, i; > - > - irq = irq_of_parse_and_map(node, 0); > - if (!irq) { > - dev_warn(gpio->dev, "no irq for bank %s\n", > - port->bgc.gc.of_node->full_name); > - return; > - } > + int err, i; > > gpio->domain = irq_domain_add_linear(node, ngpio, > &irq_generic_chip_ops, gpio); > @@ -269,8 +283,24 @@ static void dwapb_configure_irqs(struct dwapb_gpio *gpio, > irq_gc->chip_types[1].type = IRQ_TYPE_EDGE_BOTH; > irq_gc->chip_types[1].handler = handle_edge_irq; > > - irq_set_chained_handler(irq, dwapb_irq_handler); > - irq_set_handler_data(irq, gpio); > + if (!pp->irq_shared) { > + irq_set_chained_handler(pp->irq, dwapb_irq_handler); > + irq_set_handler_data(pp->irq, gpio); > + } else { > + /* > + * Request a shared IRQ since where MFD would have devices > + * using the same irq pin > + */ > + err = devm_request_irq(gpio->dev, pp->irq, > + dwapb_irq_handler_mfd, > + IRQF_SHARED, "gpio-dwapb-mfd", gpio); > + if (err) { > + dev_err(gpio->dev, "error requesting IRQ\n"); > + irq_domain_remove(gpio->domain); > + gpio->domain = NULL; > + return; > + } > + } > > for (hwirq = 0 ; hwirq < ngpio ; hwirq++) > irq_create_mapping(gpio->domain, hwirq); > @@ -296,57 +326,42 @@ static void dwapb_irq_teardown(struct dwapb_gpio *gpio) > } > > static int dwapb_gpio_add_port(struct dwapb_gpio *gpio, > - struct device_node *port_np, > + struct dwapb_port_property *pp, > unsigned int offs) > { > struct dwapb_gpio_port *port; > - u32 port_idx, ngpio; > void __iomem *dat, *set, *dirout; > int err; > > - if (of_property_read_u32(port_np, "reg", &port_idx) || > - port_idx >= DWAPB_MAX_PORTS) { > - dev_err(gpio->dev, "missing/invalid port index for %s\n", > - port_np->full_name); > - return -EINVAL; > - } > - > port = &gpio->ports[offs]; > port->gpio = gpio; > > - if (of_property_read_u32(port_np, "snps,nr-gpios", &ngpio)) { > - dev_info(gpio->dev, "failed to get number of gpios for %s\n", > - port_np->full_name); > - ngpio = 32; > - } > - > - dat = gpio->regs + GPIO_EXT_PORTA + (port_idx * GPIO_EXT_PORT_SIZE); > - set = gpio->regs + GPIO_SWPORTA_DR + (port_idx * GPIO_SWPORT_DR_SIZE); > + dat = gpio->regs + GPIO_EXT_PORTA + (pp->idx * GPIO_EXT_PORT_SIZE); > + set = gpio->regs + GPIO_SWPORTA_DR + (pp->idx * GPIO_SWPORT_DR_SIZE); > dirout = gpio->regs + GPIO_SWPORTA_DDR + > - (port_idx * GPIO_SWPORT_DDR_SIZE); > + (pp->idx * GPIO_SWPORT_DDR_SIZE); > > err = bgpio_init(&port->bgc, gpio->dev, 4, dat, set, NULL, dirout, > NULL, false); > if (err) { > dev_err(gpio->dev, "failed to init gpio chip for %s\n", > - port_np->full_name); > + pp->name); > return err; > } > > - port->bgc.gc.ngpio = ngpio; > - port->bgc.gc.of_node = port_np; > +#ifdef CONFIG_OF_GPIO Do we really need this #ifdef ? of_node will be NULL anyway, or I missed something? > + port->bgc.gc.of_node = pp->node; > +#endif > + port->bgc.gc.ngpio = pp->ngpio; > + port->bgc.gc.base = pp->gpio_base; > > - /* > - * Only port A can provide interrupts in all configurations of the IP. > - */ > - if (port_idx == 0 && > - of_property_read_bool(port_np, "interrupt-controller")) > - dwapb_configure_irqs(gpio, port); > + if (pp->irq) irq == 0 is a valid hwirq (hardware irq) number. Yes, there is unlikely we have it somewhere, but still it's possible. And yes, IRQ framework doesn't work with virq == 0 (*virtual* irq), but accepts hwirq == 0. I recommend to use int type for irq line number, and recognize negative value (usually -1) as no irq needed / found. > + dwapb_configure_irqs(gpio, port, pp); > > err = gpiochip_add(&port->bgc.gc); > if (err) > dev_err(gpio->dev, "failed to register gpiochip for %s\n", > - port_np->full_name); > + pp->name); > else > port->is_registered = true; > > @@ -362,25 +377,130 @@ static void dwapb_gpio_unregister(struct dwapb_gpio *gpio) > gpiochip_remove(&gpio->ports[m].bgc.gc); > } > > +#ifdef CONFIG_OF_GPIO > + > +static struct dwapb_platform_data * > +dwapb_gpio_get_pdata_of(struct device *dev) > +{ > + struct device_node *node, *port_np; > + struct dwapb_platform_data *pdata; > + struct dwapb_port_property *pp; > + int nports; > + int i; > + > + node = dev->of_node; > + if (!node) > + return ERR_PTR(-ENODEV); > + > + nports = of_get_child_count(node); > + if (nports == 0) > + return ERR_PTR(-ENODEV); > + > + pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); > + if (!pdata) > + return ERR_PTR(-ENOMEM); > + > + pdata->properties = devm_kcalloc(dev, nports, sizeof(*pp), GFP_KERNEL); > + if (!pdata->properties) > + return ERR_PTR(-ENOMEM); > + > + pdata->nports = nports; > + > + i = 0; > + for_each_child_of_node(node, port_np) { > + pp = &pdata->properties[i++]; > + pp->node = port_np; > + > + if (of_property_read_u32(port_np, "reg", &pp->idx) || > + pp->idx >= DWAPB_MAX_PORTS) { > + dev_err(dev, "missing/invalid port index for %s\n", > + port_np->full_name); > + return ERR_PTR(-EINVAL); > + } > + > + if (of_property_read_u32(port_np, "snps,nr-gpios", > + &pp->ngpio)) { > + dev_info(dev, "failed to get number of gpios for %s\n", > + port_np->full_name); > + pp->ngpio = 32; > + } > + > + /* > + * Only port A can provide interrupts in all configurations of > + * the IP. > + */ > + if (pp->idx == 0 && > + of_property_read_bool(port_np, "interrupt-controller")) { > + pp->irq = irq_of_parse_and_map(port_np, 0); > + if (!pp->irq) { > + dev_warn(dev, "no irq for bank %s\n", > + port_np->full_name); > + } > + } else { > + pp->irq = 0; > + } > + > + pp->irq_shared = false; > + pp->gpio_base = -1; > + pp->name = port_np->full_name; > + } > + > + return pdata; > +} > + > +static inline void dwapb_free_pdata_of(struct device *dev, > + struct dwapb_platform_data *pdata) > +{ > + if (!pdata) > + return; > + if (pdata->properties) > + devm_kfree(dev, pdata->properties); > + devm_kfree(dev, pdata); > +} > + > +#else > + > +static inline struct dwapb_platform_data * > +dwapb_gpio_get_pdata_of(struct device *dev) > +{ > + return ERR_PTR(-ENODEV); > +} > + > +static inline void dwapb_free_pdata_of(struct device *dev, > + struct dwapb_platform_data *pdata) > +{ > +} > + > +#endif > + > static int dwapb_gpio_probe(struct platform_device *pdev) > { > + int i; > + bool is_of; is_pdata_alloc (it might be not only OF case in future). > struct resource *res; > struct dwapb_gpio *gpio; > - struct device_node *np; > int err; > - unsigned int offs = 0; > + struct device *dev = &pdev->dev; > + struct dwapb_platform_data *pdata = dev_get_platdata(dev); > + > + if (!pdata) { (*) > + pdata = dwapb_gpio_get_pdata_of(dev); > + if (IS_ERR(pdata)) > + return PTR_ERR(pdata); > + is_of = true; > + } else { > + is_of = false; Instead of above three lines, how about bool is_pdata_alloc = !pdata; And (*) if (is_pdata_alloc) ... > + } > + if (!pdata->nports) > + return -ENODEV; > > gpio = devm_kzalloc(&pdev->dev, sizeof(*gpio), GFP_KERNEL); > if (!gpio) > return -ENOMEM; > gpio->dev = &pdev->dev; > + gpio->nr_ports = pdata->nports; > > - gpio->nr_ports = of_get_child_count(pdev->dev.of_node); > - if (!gpio->nr_ports) { > - err = -EINVAL; > - goto out_err; > - } > - gpio->ports = devm_kzalloc(&pdev->dev, gpio->nr_ports * > + gpio->ports = devm_kcalloc(&pdev->dev, gpio->nr_ports, > sizeof(*gpio->ports), GFP_KERNEL); > if (!gpio->ports) { > err = -ENOMEM; > @@ -394,13 +514,18 @@ static int dwapb_gpio_probe(struct platform_device *pdev) > goto out_err; > } > > - for_each_child_of_node(pdev->dev.of_node, np) { > - err = dwapb_gpio_add_port(gpio, np, offs++); > + for (i = 0; i < gpio->nr_ports; i++) { > + err = dwapb_gpio_add_port(gpio, &pdata->properties[i], i); > if (err) > goto out_unregister; > } > platform_set_drvdata(pdev, gpio); > > + if (is_of) { > + dwapb_free_pdata_of(dev, pdata); > + pdata = NULL; Besides that pdata assignment is probably redundant, you may use plain kmalloc/kfree and avoid unnecessary devm_* calls. > + } > + > return 0; > > out_unregister: > diff --git a/include/linux/platform_data/gpio-dwapb.h b/include/linux/platform_data/gpio-dwapb.h > new file mode 100644 > index 0000000..28702c8 > --- /dev/null > +++ b/include/linux/platform_data/gpio-dwapb.h > @@ -0,0 +1,32 @@ > +/* > + * Copyright(c) 2014 Intel Corporation. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope it will be useful, but WITHOUT > + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or > + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for > + * more details. > + */ > + > +#ifndef GPIO_DW_APB_H > +#define GPIO_DW_APB_H > + > +struct dwapb_port_property { > + struct device_node *node; > + const char *name; > + unsigned int idx; > + unsigned int ngpio; > + unsigned int gpio_base; > + unsigned int irq; > + bool irq_shared; > +}; > + > +struct dwapb_platform_data { > + struct dwapb_port_property *properties; > + unsigned int nports; > +}; > + > +#endif -- Andy Shevchenko Intel Finland Oy --------------------------------------------------------------------- Intel Finland Oy Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies. {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I