From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lee Jones Subject: Re: [PATCH V2 2/2] mfd: stmpe: Extend DT support in stmpe driver Date: Thu, 22 Nov 2012 11:24:51 +0000 Message-ID: <20121122112451.GE4328@gmail.com> References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: devicetree-discuss-bounces+gldd-devicetree-discuss=m.gmane.org-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org Sender: "devicetree-discuss" To: Viresh Kumar Cc: devicetree-discuss-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org, spear-devel-nkJGhpqTU55BDgjK7y7TUQ@public.gmane.org, sameo-VuQAYsv1563Yd54FQh9/CA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org List-Id: devicetree@vger.kernel.org PiBGcm9tOiBWaXB1bCBLdW1hciBTYW1hciA8dmlwdWxrdW1hci5zYW1hckBzdC5jb20+Cj4gCj4g VGhpcyBwYXRjaCBleHRlbmRzIGV4aXN0aW5nIERUIHN1cHBvcnQgZm9yIHN0bXBlIGRldmljZXMu IEJpbmRpbmdzIGFyZSBtZW50aW9uZWQKPiBpbiBiaW5kaW5nIGRvY3VtZW50Lgo+IAo+IFNpZ25l ZC1vZmYtYnk6IFZpcHVsIEt1bWFyIFNhbWFyIDx2aXB1bGt1bWFyLnNhbWFyQHN0LmNvbT4KPiBT aWduZWQtb2ZmLWJ5OiBWaXJlc2ggS3VtYXIgPHZpcmVzaC5rdW1hckBsaW5hcm8ub3JnPgo+IC0t LQo+IFYxLT5WMjoKPiAtLS0tLS0KPiAtIFBhcnRpYWwgRFQgc3VwcG9ydCB3YXMgYWxyZWFkeSB0 aGVyZSwgd2hpY2ggaSBtaXNzZWQgZWFybGllci4KPiAtIE5vdywgdGhpcyBwYXRjaCBpcyBhbiBl bmhhbmNlbWVudCBvZiBleGlzdGluZyBEVCBzdXBwb3J0LgoKQmlnIGZhdCBOQUNLLgoKWW91J3Zl IGp1c3Qgb3ZlcndyaXR0ZW4gdGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gd2l0aCB5b3VyIG93 bi4gClBsZWFzZSB0YWtlIHRpbWUgdG8gdW5kZXJzdGFuZCB0aGUgbWVjaGFuaXNtcyBpbiBwbGFj ZSBiZWZvcmUKeW91IHN1Ym1pdCBhbnkgY2hhbmdlcyBvciBhZGRpdGlvbnMgdG8gaXQuCgo+ICBE b2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbWZkL3N0bXBlLnR4dCB8IDEyNyArKysr KysrKysrLS0KPiAgZHJpdmVycy9tZmQvc3RtcGUtaTJjLmMgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgMjMgKystCj4gIGRyaXZlcnMvbWZkL3N0bXBlLXNwaS5jICAgICAgICAgICAgICAgICAg ICAgICAgIHwgIDE1ICsrCj4gIGRyaXZlcnMvbWZkL3N0bXBlLmMgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgMjY0ICsrKysrKysrKysrKysrKysrKysrKy0tLQo+ICA0IGZpbGVzIGNoYW5n ZWQsIDM4NCBpbnNlcnRpb25zKCspLCA0NSBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL21mZC9zdG1wZS50eHQgYi9Eb2N1bWVu dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbWZkL3N0bXBlLnR4dAo+IGluZGV4IDhmMGFlZGEu LjQ0YWViZjMgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdz L21mZC9zdG1wZS50eHQKPiArKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3Mv bWZkL3N0bXBlLnR4dAo+IEBAIC0xLDI1ICsxLDEyNCBAQAo+IC0qIFNUTVBFIE11bHRpLUZ1bmN0 aW9uYWwgRGV2aWNlCj4gK1NUIE1pY3JvZWxlY3Ryb25pY3MgU1RNUEUgTXVsdGktRnVuY3Rpb25h bCBEZXZpY2UKPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQo+ICAKPiArU1RNUEUgaXMgYW4gTUZEIGRldmljZSB3aGljaCBtYXkgZXhwb3NlIGZvbGxv d2luZyBpbmJ1aWx0IGRldmljZXM6IGdwaW8sIGtleXBhZCwKPiArdG91Y2hzY3JlZW4sIGFkYywg cHdtLCByb3RhdG9yLgo+ICsKPiArc3RtcGU6Cj4gKy0tLS0tCj4gIFJlcXVpcmVkIHByb3BlcnRp ZXM6Cj4gLSAtIGNvbXBhdGlibGUgICAgICAgICAgICAgICAgICAgOiAic3Qsc3RtcGVbODExfDE2 MDF8MjQwMXwyNDAzXSIKPiAtIC0gcmVnICAgICAgICAgICAgICAgICAgICAgICAgICA6IEkyQyBh ZGRyZXNzIG9mIHRoZSBkZXZpY2UKPiArLSBjb21wYXRpYmxlOiBNdXN0IGJlIG9uZSBvZjogInN0 LHN0bXBlNjEwIiwgInN0LHN0bXBlODAxIiwgInN0LHN0bXBlODExIiwKPiArICAic3Qsc3RtcGUx NjAxIiwgInN0LHN0bXBlMjQwMSIsICJzdCxzdG1wZTI0MDMiLAoKVGhpcyBpcyBtZXNzeS4gVXNl IHRoZSBjdXJyZW50IGZvcm1hdCwganVzdCBhZGQgdGhlIG5ldyB2ZXJzaW9ucy4KCj4gKy0gaWQ6 IGRldmljZSBpZCB0byBkaXN0aW5ndWlzaCBiZXR3ZWVuIG11bHRpcGxlIFNUTVBFcyBvbiB0aGUg c2FtZSBib2FyZAo+ICstIHJlZzogSTJDL1NQSSBhZGRyZXNzIG9mIHRoZSBkZXZpY2UKCldoeSBp cyB0aGlzIGJldHRlcj8gQ2FuJ3QgeW91IGp1c3QgYWRkICIvU1BJIiB0byB0aGUgY3VycmVudCBz dHJpbmc/Cgo+ICtPcHRpb25hbCBwcm9wZXJ0aWVzOgo+ICstIGlycS10cmlnZ2VyOiBJUlEgdHJp Z2dlciB0byB1c2UgZm9yIHRoZSBpbnRlcnJ1cHQgdG8gdGhlIGhvc3QKPiArLSBpcnEtaW52ZXJ0 LXBvbGFyaXR5OiBib29sLCBJUlEgbGluZSBpcyBjb25uZWN0ZWQgd2l0aCByZXZlcnNlZCBwb2xh cml0eQoKQXJlIHRoZXNlIG5ldz8KCldoZW4gYWRkaW5nIG5ldyBiaW5kaW5ncywgYXNrIHlvdXJz ZWxmOgoKMS4gQ2FuIEkgZG8gd2l0aG91dCB0aGVtPwogICAxLjEgQ2FuIEkgZGVyaXZlIHRoZSBj b25maWd1cmF0aW9uIGZyb20gb3RoZXIgdGhpbmdzPwogICAyLjIgQXJlIHRoZXkgX3JlYWxseV8g cmVxdWlyZWQsIG9yIGFtIEkganVzdCBibGluZGx5IGNvcHlpbmcgcGxhdGZvcm0gZGF0YT8KMi4g RG9lcyBhIHNpbWlsYXIgYmluZGluZyBhbHJlYWR5IGV4aXN0PwozLiBDYW4gb3RoZXIgZHJpdmVy cyBtYWtlIHVzZSBvZiB0aGVtPwogICAzLjEgSWYgc28sIGNyZWF0ZSBhIGdlbmVyaWMgYmluZGlu ZwogICAzLjIgSWYgbm90LCBwcmVwZW5kIHRoZSBiaW5kaW5nIHdpdGggIjx2ZW5kb3I+LCIKCj4g Ky0gYXV0b3NsZWVwLXRpbWVvdXQ6IGluYWN0aXZpdHkgdGltZW91dCBpbiBtaWxsaXNlY29uZHMg Zm9yIGF1dG9zbGVlcC4gVmFsaWQKPiArICBlbnRyaWVzIChtcyk7IDQsIDE2LCAzMiwgNjQsIDEy OCwgMjU2LCA1MTIgYW5kIDEwMjQKPiArLSBpbnRlcnJ1cHRzOiBpbnRlcnJ1cHQgbnVtYmVyIG9m IHRoZSBkZXZpY2UsIGlmIGludGVycnVwdCBpcyBub3QgdmlhIGdwaW8KPiArLSBpbnRlcnJ1cHQt cGFyZW50OiBTcGVjaWZpZXMgd2hpY2ggSVJRIGNvbnRyb2xsZXIgd2UncmUgY29ubmVjdGVkIHRv Cj4gKy0gaXJxLW92ZXItZ3BpbzogYm9vbCwgdHJ1ZSBpZiBncGlvIGlzIHVzZWQgdG8gZ2V0IGly cQo+ICstIGlycS1ncGlvczogZ3BpbyBudW1iZXIgb3ZlciB3aGljaCBpcnEgd2lsbCBiZSByZXF1 ZXN0ZWQgKHNpZ25pZmljYW50IG9ubHkgaWYKCldoYXQgd2FzIHdyb25nIHdpdGggdGhlIG9sZCBm b3JtYXQgKGJlbG93KT8gTm93IGl0J3MgbWVzc3kgYW5kIGhhcmQgdG8gcmVhZC4KCk9ubHkgcHJv dmlkZSBjaGFuZ2VzIHdoaWNoIGFyZSBfYmV0dGVyXy4KCj4gKyAgaXJxLW92ZXItZ3BpbyBpcyB0 cnVlKQoKWW91IGRvbid0IG5lZWQgdGhlc2UuIFVzZSBncGlvX3RvX2lycSgpIGluc3RlYWQuCgo+ ICstIGkyYy1jbGllbnQtd2FrZTogTWFya3MgdGhlIGlucHV0IGRldmljZSBhcyB3YWthYmxlCj4g K3N0bXBlLWtleXBhZDoKPiArLS0tLS0tLS0tLS0tLS0KPiArUmVxdWlyZWQgcHJvcGVydGllcyBp biBhZGRpdGlvbiB0byB0aG9zZSBzcGVjaWZpZWQgYnkgdGhlIHNoYXJlZCBtYXRyaXgta2V5Ym9h cmQKPiArYmluZGluZ3M6Cj4gKy0gY29tcGF0aWJsZTogTXVzdCBiZSAic3RtcGUsa2V5cGFkIgoK VGhhdCdzIG5vdCBob3cgdGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gd29ya3MuCgpBbGwgeW91 IGhhdmUgdG8gZG8gaXMgYWRkIGNoaWxkIG5vZGVzIHdpdGggdGhlIG5hbWVzOgogICAgc3RtcGVf Z3BpbwogICAgc3RtcGVfa2V5cGFkCiAgICBzdG1wZV90b3VjaHNjcmVlbgogICAgc3RtcGVfYWRj Cgo+ICBPcHRpb25hbCBwcm9wZXJ0aWVzOgo+IC0gLSBpbnRlcnJ1cHRzICAgICAgICAgICAgICAg ICAgIDogVGhlIGludGVycnVwdCBvdXRwdXRzIGZyb20gdGhlIGNvbnRyb2xsZXIKPiAtIC0gaW50 ZXJydXB0LWNvbnRyb2xsZXIgICAgICAgICA6IE1hcmtzIHRoZSBkZXZpY2Ugbm9kZSBhcyBhbiBp bnRlcnJ1cHQgY29udHJvbGxlcgo+IC0gLSBpbnRlcnJ1cHQtcGFyZW50ICAgICAgICAgICAgIDog U3BlY2lmaWVzIHdoaWNoIElSUSBjb250cm9sbGVyIHdlJ3JlIGNvbm5lY3RlZCB0bwo+IC0gLSBp MmMtY2xpZW50LXdha2UgICAgICAgICAgICAgIDogTWFya3MgdGhlIGlucHV0IGRldmljZSBhcyB3 YWthYmxlCj4gLSAtIHN0LGF1dG9zbGVlcC10aW1lb3V0ICAgICAgICAgOiBWYWxpZCBlbnRyaWVz IChtcyk7IDQsIDE2LCAzMiwgNjQsIDEyOCwgMjU2LCA1MTIgYW5kIDEwMjQKCkFuZCB5b3UndmUg cmVtb3ZlZCB0aGVzZSB3aHk/Cgo+ICstIGtleXBhZCxzY2FuLWNvdW50OiBudW1iZXIgb2Yga2V5 IHNjYW5uaW5nIGN5Y2xlcyB0byBjb25maXJtIGtleSBkYXRhLiBNYXhpbXVtCj4gKyAgaXMgU1RN UEVfS0VZUEFEX01BWF9TQ0FOX0NPVU5ULgo+ICstIGtleXBhZCxkZWJvdW5jZS1tczogZGVib3Vu Y2UgaW50ZXJ2YWwsIGluIG1zLiBNYXhpbXVtIGlzCj4gKyAgU1RNUEVfS0VZUEFEX01BWF9ERUJP VU5DRS4KPiArLSBrZXlwYWQsbm8tYXV0b3JlcGVhdDogYm9vbCwgZGlzYWJsZSBrZXkgYXV0b3Jl cGVhdAoKU2VlICJXaGVuIGFkZGluZyBuZXcgYmluZGluZ3MsIGFzayB5b3Vyc2VsZiIgYWJvdmUu Cgo+ICtzdG1wZS1ncGlvOgo+ICstLS0tLS0tLS0tLQo+ICtSZXF1aXJlZCBwcm9wZXJ0aWVzOgo+ ICstIGNvbXBhdGlibGU6IE11c3QgYmUgInN0bXBlLGdwaW8iCj4gKwo+ICtPcHRpb25hbCBwcm9w ZXJ0aWVzOgo+ICstIG5vcmVxdWVzdC1tYXNrOiBiaXRtYXNrIHNwZWNpZnlpbmcgd2hpY2ggR1BJ T3Mgc2hvdWxkIF9ub3RfIGJlIHJlcXVlc3RhYmxlIGR1ZQo+ICsgIHRvIGRpZmZlcmVudCB1c2Fn ZSAoZS5nLiB0b3VjaCwga2V5cGFkKSBTVE1QRV9HUElPX05PUkVRXyogbWFjcm9zIGNhbiBiZSB1 c2VkCj4gKyAgaGVyZS4KPiArCj4gK3N0bXBlLXRzOgo+ICstLS0tLS0tLS0tLQo+ICtSZXF1aXJl ZCBwcm9wZXJ0aWVzOgo+ICstIGNvbXBhdGlibGU6IE11c3QgYmUgInN0bXBlLHRzIgo+ICsKPiAr T3B0aW9uYWwgcHJvcGVydGllczoKPiArLSBzYW1wbGUtdGltZTogQURDIGNvbnZlcnN0aW9uIHRp bWUgaW4gbnVtYmVyIG9mIGNsb2NrLiAgKDAgLT4gMzYgY2xvY2tzLCAxIC0+Cj4gKyAgNDQgY2xv Y2tzLCAyIC0+IDU2IGNsb2NrcywgMyAtPiA2NCBjbG9ja3MsIDQgLT4gODAgY2xvY2tzLCA1IC0+ IDk2IGNsb2NrcywgNgo+ICsgIC0+IDE0NCBjbG9ja3MpLCByZWNvbW1lbmRlZCBpcyA0Lgo+ICst IG1vZC0xMmI6IEFEQyBCaXQgbW9kZSAoMCAtPiAxMGJpdCBBREMsIDEgLT4gMTJiaXQgQURDKQo+ ICstIHJlZi1zZWw6IEFEQyByZWZlcmVuY2Ugc291cmNlICgwIC0+IGludGVybmFsIHJlZmVyZW5j ZSwgMSAtPiBleHRlcm5hbAo+ICsgIHJlZmVyZW5jZSkKPiArLSBhZGMtZnJlcTogQURDIENsb2Nr IHNwZWVkICgwIC0+IDEuNjI1IE1IeiwgMSAtPiAzLjI1IE1IeiwgMiB8fCAzIC0+IDYuNSBNSHop Cj4gKy0gYXZlLWN0cmw6IFNhbXBsZSBhdmVyYWdlIGNvbnRyb2wgKDAgLT4gMSBzYW1wbGUsIDEg LT4gMiBzYW1wbGVzLCAyIC0+IDQKPiArICBzYW1wbGVzLCAzIC0+IDggc2FtcGxlcykKPiArLSB0 b3VjaC1kZXQtZGVsYXk6IFRvdWNoIGRldGVjdCBpbnRlcnJ1cHQgZGVsYXkgKDAgLT4gMTAgdXMs IDEgLT4gNTAgdXMsIDIgLT4KPiArICAxMDAgdXMsIDMgLT4gNTAwIHVzLCA0LT4gMSBtcywgNSAt PiA1IG1zLCA2IC0+IDEwIG1zLCA3IC0+IDUwIG1zKSByZWNvbW1lbmRlZAo+ICsgIGlzIDMKPiAr LSBzZXR0bGluZzogUGFuZWwgZHJpdmVyIHNldHRsaW5nIHRpbWUgKDAgLT4gMTAgdXMsIDEgLT4g MTAwIHVzLCAyIC0+IDUwMCB1cywgMwo+ICsgIC0+IDEgbXMsIDQgLT4gNSBtcywgNSAtPiAxMCBt cywgNiBmb3IgNTAgbXMsIDcgLT4gMTAwIG1zKSByZWNvbW1lbmRlZCBpcyAyCj4gKy0gZnJhY3Rp b24tejogTGVuZ3RoIG9mIHRoZSBmcmFjdGlvbmFsIHBhcnQgaW4geiAoZnJhY3Rpb24teiAoWzAu LjddKSA9IENvdW50IG9mCj4gKyAgdGhlIGZyYWN0aW9uYWwgcGFydCkgcmVjb21tZW5kZWQgaXMg Nwo+ICstIGktZHJpdmU6IGN1cnJlbnQgbGltaXQgdmFsdWUgb2YgdGhlIHRvdWNoc2NyZWVuIGRy aXZlcnMgKDAgLT4gMjAgbUEgdHlwaWNhbCAzNQo+ICsgIG1BIG1heCwgMSAtPiA1MCBtQSB0eXBp Y2FsIDgwIG1BIG1heCkKClNlZSAiV2hlbiBhZGRpbmcgbmV3IGJpbmRpbmdzLCBhc2sgeW91cnNl bGYiIGFib3ZlLgoKPiArc3RtcGUtYWRjOgo+ICstLS0tLS0tLS0tLQo+ICtSZXF1aXJlZCBwcm9w ZXJ0aWVzOgo+ICstIGNvbXBhdGlibGU6IE11c3QgYmUgInN0bXBlLGFkYyIKPiArCj4gK3N0bXBl LXB3bToKPiArLS0tLS0tLS0tLS0KPiArUmVxdWlyZWQgcHJvcGVydGllczoKPiArLSBjb21wYXRp YmxlOiBNdXN0IGJlICJzdG1wZSxwd20iCj4gKwo+ICtzdG1wZS1yb3RhdG9yOgo+ICstLS0tLS0t LS0tLQo+ICtSZXF1aXJlZCBwcm9wZXJ0aWVzOgo+ICstIGNvbXBhdGlibGU6IE11c3QgYmUgInN0 bXBlLHJvdGF0b3IiCj4gIAo+ICBFeGFtcGxlOgo+ICstLS0tLS0tCj4gK3N0bXBlIGNhbiBiZSBw cmVzZW50IG92ZXIgaTJjIG9yIHNwaSBidXMsIHNvIGl0cyBub2RlIHdvdWxkIGJlIGFkZGVkIGFz IGNoaWxkCj4gK25vZGUgb2YgZWl0aGVyIG9mIHNwaSBvciBpMmMgZGV2aWNlLgo+ICsKPiArc3Rt cGUtZGV2aWNlcyBzaG91bGQgYmUgYWRkZWQgYXMgY2hpbGQgbm9kZXMgb2YgcGFyZW50IHN0bXBl IG5vZGUuCj4gIAo+ICtzcGlAZTAxMDAwMDAgewoKVGhpcyBzaG91bGRuJ3QgYmUgYSBjaGlsZCBv ZiB0aGUgU1BJIGRldmljZSBiZWN1YXNlIGl0IHVzZXMgU1BJLgoKRHJpdmVycyB1c2UgY2xvY2tz LCByZWd1bGF0b3JzLCBJUlEgY29udHJvbGxlciB0b28sIGJ1dCB0aGV5J3JlCm5vdCBjaGlsZHJl biBvZiB0aG9zZSBkZXZpY2VzLgoKPiAgCXN0bXBlMTYwMTogc3RtcGUxNjAxQDQwIHsKPiArCQlz dGF0dXMgPSAib2theSI7CgpZb3Ugb25seSBuZWVkIHRoaXMgaWYgaXQncyBiZWVuIGRpc2FibGVk IHNvbWV3aGVyZSBlbHNlLgoKPiAgCQljb21wYXRpYmxlID0gInN0LHN0bXBlMTYwMSI7Cj4gLQkJ cmVnID0gPDB4NDA+Owo+IC0JCWludGVycnVwdHMgPSA8MjYgMHg0PjsKPiAtCQlpbnRlcnJ1cHQt cGFyZW50ID0gPCZncGlvNj47Cj4gLQkJaW50ZXJydXB0LWNvbnRyb2xsZXI7CgpXaHkgYXJlIHlv dSByZW1vdmluZyB0aGVzZT8KCj4gKwkJcmVnID0gPDA+OwoKWW91IGhhdmUgcmVnIHR3aWNlIGhl cmUuIEFsc28gcmVnIHNob3VsZCBuZXZlciBiZSAnMCcuCgo+ICsJCTwuLiBzcGkgY29udHJvbGxl ciBzcGVjaWZpYyBkYXRhIC4uPgo+ICsKPiArCQlpZCA9IDwwPjsKCkRvbid0IGRvIHRoaXMuIERl dmljZSBJRHMgYXJlIExpbnV4IHNwZWNpZmljLgoKPiArCQlpcnEtb3Zlci1ncGlvOwo+ICsJCWly cS1ncGlvcyA9IDwmZ3BpbzEgNiAweDQ+Owo+ICsJCWlycS10cmlnZ2VyID0gPDB4Mj47CgpTZWUg IldoZW4gYWRkaW5nIG5ldyBiaW5kaW5ncywgYXNrIHlvdXJzZWxmIiBhYm92ZS4KCj4gLQkJaTJj LWNsaWVudC13YWtlOwo+IC0JCXN0LGF1dG9zbGVlcC10aW1lb3V0ID0gPDEwMjQ+Owo+ICsJCXN0 bXBlNjEwLXRzIHsKPiArCQkJY29tcGF0aWJsZSA9ICJzdG1wZSx0cyI7Cj4gKwkJCXRzLHNhbXBs ZS10aW1lID0gPDQ+Owo+ICsJCQl0cyxtb2QtMTJiID0gPDE+Owo+ICsJCQl0cyxyZWYtc2VsID0g PDA+Owo+ICsJCQl0cyxhZGMtZnJlcSA9IDwxPjsKPiArCQkJdHMsYXZlLWN0cmwgPSA8MT47Cj4g KwkJCXRzLHRvdWNoLWRldC1kZWxheSA9IDwyPjsKPiArCQkJdHMsc2V0dGxpbmcgPSA8Mj47Cj4g KwkJCXRzLGZyYWN0aW9uLXogPSA8Nz47Cj4gKwkJCXRzLGktZHJpdmUgPSA8MT47CgpXb3chIFNl ZSAiV2hlbiBhZGRpbmcgbmV3IGJpbmRpbmdzLCBhc2sgeW91cnNlbGYiIGFib3ZlLgoKPiArCQl9 Owo+ICAJfTsKPiArfTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvc3RtcGUtaTJjLmMgYi9k cml2ZXJzL21mZC9zdG1wZS1pMmMuYwo+IGluZGV4IDk0N2EwNmEuLmFhYTJkYTcgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9tZmQvc3RtcGUtaTJjLmMKPiArKysgYi9kcml2ZXJzL21mZC9zdG1wZS1p MmMuYwo+IEBAIC0xMyw2ICsxMyw3IEBACj4gICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4K PiAgI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+ICAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9vZi5oPgo+ICAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiAg I2luY2x1ZGUgInN0bXBlLmgiCj4gIAo+IEBAIC04MSwxMiArODIsMjggQEAgc3RhdGljIGNvbnN0 IHN0cnVjdCBpMmNfZGV2aWNlX2lkIHN0bXBlX2kyY19pZFtdID0gewo+ICB9Owo+ICBNT0RVTEVf REVWSUNFX1RBQkxFKGkyYywgc3RtcGVfaWQpOwo+ICAKPiArI2lmZGVmIENPTkZJR19PRgo+ICtz dGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBzdG1wZV9kdF9pZHNbXSA9IHsKPiArCXsg LmNvbXBhdGlibGUgPSAic3Qsc3RtcGU2MTAiLCAuZGF0YSA9ICZzdG1wZV9pMmNfaWRbMF0sIH0s Cj4gKwl7IC5jb21wYXRpYmxlID0gInN0LHN0bXBlODAxIiwgLmRhdGEgPSAmc3RtcGVfaTJjX2lk WzFdLCB9LAo+ICsJeyAuY29tcGF0aWJsZSA9ICJzdCxzdG1wZTgxMSIsIC5kYXRhID0gJnN0bXBl X2kyY19pZFsyXSwgfSwKPiArCXsgLmNvbXBhdGlibGUgPSAic3Qsc3RtcGUxNjAxIiwgLmRhdGEg PSAmc3RtcGVfaTJjX2lkWzNdLCB9LAo+ICsJeyAuY29tcGF0aWJsZSA9ICJzdCxzdG1wZTI0MDEi LCAuZGF0YSA9ICZzdG1wZV9pMmNfaWRbNF0sIH0sCj4gKwl7IC5jb21wYXRpYmxlID0gInN0LHN0 bXBlMjQwMyIsIC5kYXRhID0gJnN0bXBlX2kyY19pZFs1XSwgfSwKPiArCXsgfQo+ICt9Owo+ICtN T0RVTEVfREVWSUNFX1RBQkxFKG9mLCBzdG1wZV9kdF9pZHMpOwo+ICsjZW5kaWYKPgo+ICBzdGF0 aWMgc3RydWN0IGkyY19kcml2ZXIgc3RtcGVfaTJjX2RyaXZlciA9IHsKPiAtCS5kcml2ZXIubmFt ZQk9ICJzdG1wZS1pMmMiLAo+IC0JLmRyaXZlci5vd25lcgk9IFRISVNfTU9EVUxFLAo+ICsJLmRy aXZlciA9IHsKPiArCQkubmFtZQk9ICJzdG1wZS1pMmMiLAo+ICsJCS5vd25lcgk9IFRISVNfTU9E VUxFLAo+ICAjaWZkZWYgQ09ORklHX1BNCj4gLQkuZHJpdmVyLnBtCT0gJnN0bXBlX2Rldl9wbV9v cHMsCj4gKwkJLnBtCT0gJnN0bXBlX2Rldl9wbV9vcHMsCgpJZiB5b3Ugd2FudCB0byBjaGFuZ2Ug dGhlc2UsIHlvdSBuZWVkIHRvIHN1Ym1pdCBhIHNlcGVyYXRlIHBhdGNoLCBhcwp0aGV5IGhhdmUg bm90aGluZyB0byBkbyB3aXRoIERUOmluZyB0aGVzZSBkcml2ZXIuCgo+ICAjZW5kaWYKPiArCQku b2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaF9wdHIoc3RtcGVfZHRfaWRzKSwKPiArCX0sCj4gIAku cHJvYmUJCT0gc3RtcGVfaTJjX3Byb2JlLAo+ICAJLnJlbW92ZQkJPSBfX2RldmV4aXRfcChzdG1w ZV9pMmNfcmVtb3ZlKSwKPiAgCS5pZF90YWJsZQk9IHN0bXBlX2kyY19pZCwKPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9tZmQvc3RtcGUtc3BpLmMgYi9kcml2ZXJzL21mZC9zdG1wZS1zcGkuYwo+IGlu ZGV4IDllZGZlODYuLjFlMmJmZjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvc3RtcGUtc3Bp LmMKPiArKysgYi9kcml2ZXJzL21mZC9zdG1wZS1zcGkuYwo+IEBAIC0xMSw2ICsxMSw3IEBACj4g ICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5o Pgo+ICAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZi5oPgo+ ICAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiAgI2luY2x1ZGUgInN0bXBlLmgiCj4gIAo+IEBA IC0xMTksNiArMTIwLDE5IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgc3BpX2RldmljZV9pZCBzdG1w ZV9zcGlfaWRbXSA9IHsKPiAgfTsKPiAgTU9EVUxFX0RFVklDRV9UQUJMRShzcGksIHN0bXBlX2lk KTsKPiAgCj4gKyNpZmRlZiBDT05GSUdfT0YKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZp Y2VfaWQgc3RtcGVfZHRfaWRzW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gInN0LHN0bXBlNjEw IiwgLmRhdGEgPSAodm9pZCAqKVNUTVBFNjEwLCB9LAo+ICsJeyAuY29tcGF0aWJsZSA9ICJzdCxz dG1wZTgwMSIsIC5kYXRhID0gKHZvaWQgKilTVE1QRTgwMSwgfSwKPiArCXsgLmNvbXBhdGlibGUg PSAic3Qsc3RtcGU4MTEiLCAuZGF0YSA9ICh2b2lkICopU1RNUEU4MTEsIH0sCj4gKwl7IC5jb21w YXRpYmxlID0gInN0LHN0bXBlMTYwMSIsIC5kYXRhID0gKHZvaWQgKilTVE1QRTE2MDEsIH0sCj4g Kwl7IC5jb21wYXRpYmxlID0gInN0LHN0bXBlMjQwMSIsIC5kYXRhID0gKHZvaWQgKilTVE1QRTI0 MDEsIH0sCj4gKwl7IC5jb21wYXRpYmxlID0gInN0LHN0bXBlMjQwMyIsIC5kYXRhID0gKHZvaWQg KilTVE1QRTI0MDMsIH0sCj4gKwl7IH0KPiArfTsKPiArTU9EVUxFX0RFVklDRV9UQUJMRShvZiwg c3RtcGVfZHRfaWRzKTsKPiArI2VuZGlmCj4KPiAgc3RhdGljIHN0cnVjdCBzcGlfZHJpdmVyIHN0 bXBlX3NwaV9kcml2ZXIgPSB7Cj4gIAkuZHJpdmVyID0gewo+ICAJCS5uYW1lCT0gInN0bXBlLXNw aSIsCj4gQEAgLTEyNiw2ICsxNDAsNyBAQCBzdGF0aWMgc3RydWN0IHNwaV9kcml2ZXIgc3RtcGVf c3BpX2RyaXZlciA9IHsKPiAgI2lmZGVmIENPTkZJR19QTQo+ICAJCS5wbQk9ICZzdG1wZV9kZXZf cG1fb3BzLAo+ICAjZW5kaWYKPiArCQkub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaF9wdHIoc3Rt cGVfZHRfaWRzKSwKPiAgCX0sCj4gIAkucHJvYmUJCT0gc3RtcGVfc3BpX3Byb2JlLAo+ICAJLnJl bW92ZQkJPSBfX2RldmV4aXRfcChzdG1wZV9zcGlfcmVtb3ZlKSwKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9tZmQvc3RtcGUuYyBiL2RyaXZlcnMvbWZkL3N0bXBlLmMKPiBpbmRleCBjMGRmNGI5Li5k NjlmMjRiIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWZkL3N0bXBlLmMKPiArKysgYi9kcml2ZXJz L21mZC9zdG1wZS5jCj4gQEAgLTgsMTEgKzgsMTQgQEAKPiAgICovCj4gIAo+ICAjaW5jbHVkZSA8 bGludXgvZ3Bpby5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4gICNpbmNsdWRlIDxsaW51 eC9leHBvcnQuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+ICAjaW5jbHVkZSA8bGlu dXgvaW50ZXJydXB0Lmg+Cj4gICNpbmNsdWRlIDxsaW51eC9pcnEuaD4KPiAgI2luY2x1ZGUgPGxp bnV4L2lycWRvbWFpbi5oPgo+ICsjaW5jbHVkZSA8bGludXgvb2YuaD4KPiArI2luY2x1ZGUgPGxp bnV4L29mX2dwaW8uaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3BtLmg+Cj4gICNpbmNsdWRlIDxsaW51 eC9zbGFiLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9tZmQvY29yZS5oPgo+IEBAIC05ODEsNiArOTg0 LDIzMCBAQCBzdGF0aWMgaW50IF9fZGV2aW5pdCBzdG1wZV9hZGRfZGV2aWNlKHN0cnVjdCBzdG1w ZSAqc3RtcGUsCj4gIAkJCSAgICAgICBOVUxMLCBzdG1wZS0+aXJxX2Jhc2UsIHN0bXBlLT5kb21h aW4pOwo+ICB9Cj4gIAo+ICsjaWZkZWYgQ09ORklHX09GCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg b2ZfZGV2aWNlX2lkIHN0bXBlX2tleXBhZF9pZHNbXSA9IHsKPiArCXsgLmNvbXBhdGlibGUgPSAi c3RtcGUsa2V5cGFkIiB9LAo+ICsJe30sCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0 IG9mX2RldmljZV9pZCBzdG1wZV9ncGlvX2lkc1tdID0gewo+ICsJeyAuY29tcGF0aWJsZSA9ICJz dG1wZSxncGlvIiB9LAo+ICsJe30sCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCBzdG1wZV90c19pZHNbXSA9IHsKPiArCXsgLmNvbXBhdGlibGUgPSAic3RtcGUs dHMiIH0sCj4gKwl7fSwKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNl X2lkIHN0bXBlX2FkY19pZHNbXSA9IHsKPiArCXsgLmNvbXBhdGlibGUgPSAic3RtcGUsYWRjIiB9 LAo+ICsJe30sCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBz dG1wZV9wd21faWRzW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gInN0bXBlLHB3bSIgfSwKPiAr CXt9LAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgc3RtcGVf cm90YXRvcl9pZHNbXSA9IHsKPiArCXsgLmNvbXBhdGlibGUgPSAic3RtcGUscm90YXRvciIgfSwK PiArCXt9LAo+ICt9OwoKVGhlcmUgcmVhbGx5IGlzIG5vIG5lZWQgZm9yIGFsbCB0aGVzZS4KClBs ZWFzZSB1c2UgdGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gaW5zdGVhZC4KCj4gK3N0YXRpYyBz dHJ1Y3Qgc3RtcGVfa2V5cGFkX3BsYXRmb3JtX2RhdGEgKgo+ICtnZXRfa2V5Ym9hcmRfcGRhdGFf ZHQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wKQo+ICt7Cj4gKwlz dHJ1Y3Qgc3RtcGVfa2V5cGFkX3BsYXRmb3JtX2RhdGEgKnBkYXRhOwo+ICsJdTMyIHZhbDsKPiAr Cj4gKwlwZGF0YSA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqcGRhdGEpLCBHRlBfS0VSTkVM KTsKPiArCWlmICghcGRhdGEpIHsKPiArCQlkZXZfd2FybihkZXYsICJzdG1wZSBrZXlwYWQga3ph bGxvYyBmYWlsXG4iKTsKPiArCQlyZXR1cm4gTlVMTDsKPiArCX0KPiArCj4gKwlpZiAoIW9mX3By b3BlcnR5X3JlYWRfdTMyKG5wLCAia2V5cGFkLHNjYW4tY291bnQiLCAmdmFsKSkKPiArCQlwZGF0 YS0+c2Nhbl9jb3VudCA9IHZhbDsKPiArCWlmICghb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJr ZXlwYWQsZGVib3VuY2UtbXMiLCAmdmFsKSkKPiArCQlwZGF0YS0+ZGVib3VuY2VfbXMgPSB2YWw7 Cj4gKwlpZiAob2ZfcHJvcGVydHlfcmVhZF9ib29sKG5wLCAia2V5cGFkLG5vLWF1dG9yZXBlYXQi KSkKPiArCQlwZGF0YS0+bm9fYXV0b3JlcGVhdCA9IHRydWU7CgpXaHkgYXJlIHlvdSAocmUpYWRk aW5nIHRoZXNlIGhlcmU/IEhhdmUgeW91IGV2ZW4gbG9va2VkIGluIHRoZSBkcml2ZXI/CgpTZWU6 IGRyaXZlcnMvaW5wdXQva2V5Ym9hcmQvc3RtcGUta2V5cGFkLmMKCj4gKwlyZXR1cm4gcGRhdGE7 Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3Qgc3RtcGVfZ3Bpb19wbGF0Zm9ybV9kYXRhICpnZXRf Z3Bpb19wZGF0YV9kdChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJc3RydWN0IGRldmljZV9ub2Rl ICpucCkKPiArewo+ICsJc3RydWN0IHN0bXBlX2dwaW9fcGxhdGZvcm1fZGF0YSAqcGRhdGE7Cj4g Kwl1MzIgdmFsOwo+ICsKPiArCXBkYXRhID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpwZGF0 YSksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFwZGF0YSkgewo+ICsJCWRldl93YXJuKGRldiwgInN0 bXBlIGdwaW8ga3phbGxvYyBmYWlsXG4iKTsKPiArCQlyZXR1cm4gTlVMTDsKPiArCX0KPiArCj4g KwlpZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAiZ3Bpbyxub3JlcXVlc3QtbWFzayIsICZ2 YWwpKQo+ICsJCXBkYXRhLT5ub3JlcXVlc3RfbWFzayA9IHZhbDsKPiArCj4gKwkvKiBhc3NpZ24g Z3BpbyBudW1iZXJzIGR5bmFtaWNhbGx5ICovCj4gKwlwZGF0YS0+Z3Bpb19iYXNlID0gLTE7Cj4g Kwo+ICsJcmV0dXJuIHBkYXRhOwo+ICt9CgpJcyB0aGlzIGZ1bmN0aW9uIHJlYWxseSByZXF1aXJl ZD8gRXZlbiBpZiBpcyBpcywgc2hvdWxkIGl0IGxpdmUgaGVyZQpvciBpbiB0aGUgU1RNUEUgZHJp dmVyPwoKU2VlOiBkcml2ZXJzL2dwaW8vZ3Bpby1zdG1wZS5jCgo+ICtzdGF0aWMgc3RydWN0IHN0 bXBlX3RzX3BsYXRmb3JtX2RhdGEgKmdldF90c19wZGF0YV9kdChzdHJ1Y3QgZGV2aWNlICpkZXYs Cj4gKwkJc3RydWN0IGRldmljZV9ub2RlICpucCkKPiArewo+ICsJc3RydWN0IHN0bXBlX3RzX3Bs YXRmb3JtX2RhdGEgKnBkYXRhOwo+ICsJdTMyIHZhbDsKPiArCj4gKwlwZGF0YSA9IGRldm1fa3ph bGxvYyhkZXYsIHNpemVvZigqcGRhdGEpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghcGRhdGEpIHsK PiArCQlkZXZfd2FybihkZXYsICJzdG1wZSB0cyBremFsbG9jIGZhaWxcbiIpOwo+ICsJCXJldHVy biBOVUxMOwo+ICsJfQo+ICsKPiArCWlmICghb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJ0cyxz YW1wbGUtdGltZSIsICZ2YWwpKQo+ICsJCXBkYXRhLT5zYW1wbGVfdGltZSA9IHZhbDsKPiArCWlm ICghb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJ0cyxtb2QtMTJiIiwgJnZhbCkpCj4gKwkJcGRh dGEtPm1vZF8xMmIgPSB2YWw7Cj4gKwlpZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAidHMs cmVmLXNlbCIsICZ2YWwpKQo+ICsJCXBkYXRhLT5yZWZfc2VsID0gdmFsOwo+ICsJaWYgKCFvZl9w cm9wZXJ0eV9yZWFkX3UzMihucCwgInRzLGFkYy1mcmVxIiwgJnZhbCkpCj4gKwkJcGRhdGEtPmFk Y19mcmVxID0gdmFsOwo+ICsJaWYgKCFvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgInRzLGF2ZS1j dHJsIiwgJnZhbCkpCj4gKwkJcGRhdGEtPmF2ZV9jdHJsID0gdmFsOwo+ICsJaWYgKCFvZl9wcm9w ZXJ0eV9yZWFkX3UzMihucCwgInRzLHRvdWNoLWRldC1kZWxheSIsICZ2YWwpKQo+ICsJCXBkYXRh LT50b3VjaF9kZXRfZGVsYXkgPSB2YWw7Cj4gKwlpZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5w LCAidHMsc2V0dGxpbmciLCAmdmFsKSkKPiArCQlwZGF0YS0+c2V0dGxpbmcgPSB2YWw7Cj4gKwlp ZiAoIW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAidHMsZnJhY3Rpb24teiIsICZ2YWwpKQo+ICsJ CXBkYXRhLT5mcmFjdGlvbl96ID0gdmFsOwo+ICsJaWYgKCFvZl9wcm9wZXJ0eV9yZWFkX3UzMihu cCwgInRzLGktZHJpdmUiLCAmdmFsKSkKPiArCQlwZGF0YS0+aV9kcml2ZSA9IHZhbDsKPiArCj4g KwlyZXR1cm4gcGRhdGE7Cj4gK30KCkFzIGFib3ZlLgoKSSdtIGdvaW5nIHRvIHN0b3AgbXkgcmV2 aWV3IGhlcmUuIEkgdGhpbmsgeW91IGdldCB0aGUgaWRlYS4KCj4gK3N0YXRpYyBzdHJ1Y3Qgc3Rt cGVfdmFyaWFudF9ibG9jayAqCj4gK21hdGNoX3ZhcmlhbnRfYmxvY2soc3RydWN0IHN0bXBlX3Zh cmlhbnRfaW5mbyAqdmFyaWFudCwKPiArCQllbnVtIHN0bXBlX2Jsb2NrIGJsb2NrcykKPiArewo+ ICsJaW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IHZhcmlhbnQtPm51bV9ibG9ja3M7IGkr Kykgewo+ICsJCXN0cnVjdCBzdG1wZV92YXJpYW50X2Jsb2NrICpibG9jayA9ICZ2YXJpYW50LT5i bG9ja3NbaV07Cj4gKwo+ICsJCWlmIChibG9ja3MgJiBibG9jay0+YmxvY2spCj4gKwkJCXJldHVy biBibG9jazsKPiArCX0KPiArCXJldHVybiBOVUxMOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHN0 bXBlX3Byb2JlX2NvbmZpZ19kdChzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gKwkJc3RydWN0IHN0bXBl X3BsYXRmb3JtX2RhdGEgKnBkYXRhLCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wKQo+ICt7Cj4gKwll bnVtIG9mX2dwaW9fZmxhZ3MgZmxhZ3M7Cj4gKwo+ICsJcGRhdGEtPmlycV9iYXNlID0gaXJxX2Fs bG9jX2Rlc2NzKC0xLCAwLCBTVE1QRV9OUl9JUlFTLCAwKTsKPiArCWlmIChJU19FUlJfVkFMVUUo cGRhdGEtPmlycV9iYXNlKSkgewo+ICsJCWRldl9lcnIoZGV2LCAiJXM6IGlycSBkZXNjIGFsbG9j IGZhaWxlZFxuIiwgX19mdW5jX18pOwo+ICsJCXJldHVybiAtRU5YSU87Cj4gKwl9Cj4gKwo+ICsJ aWYgKG9mX3Byb3BlcnR5X3JlYWRfYm9vbChucCwgImlycV9vdmVyX2dwaW8iKSkgewo+ICsJCXBk YXRhLT5pcnFfb3Zlcl9ncGlvID0gdHJ1ZTsKPiArCj4gKwkJcGRhdGEtPmlycV9ncGlvID0gb2Zf Z2V0X25hbWVkX2dwaW9fZmxhZ3MobnAsICJpcnEtZ3Bpb3MiLCAwLAo+ICsJCQkJJmZsYWdzKTsK PiArCQlpZiAoIXBkYXRhLT5pcnFfZ3BpbykKPiArCQkJZGV2X2RiZyhkZXYsICJ1bmFibGUgdG8g Z2V0IGlycV9ncGlvIGZyb20gJXMuIiwKPiArCQkJCQlfX2Z1bmNfXyk7Cj4gKwl9Cj4gKwo+ICsJ aWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAiaXJxLXRyaWdnZXIiLCAmcGRhdGEtPmlycV90 cmlnZ2VyKSkKPiArCQlkZXZfZGJnKGRldiwgInVuYWJsZSB0byBnZXQgaXJxX3RyaWdnZXJcbiIp Owo+ICsKPiArCWlmIChvZl9wcm9wZXJ0eV9yZWFkX2Jvb2wobnAsICJpcnEtaW52ZXJ0LXBvbGFy aXR5IikpCj4gKwkJcGRhdGEtPmlycV9pbnZlcnRfcG9sYXJpdHkgPSB0cnVlOwo+ICsKPiArCWlm ICghb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJhdXRvc2xlZXAtdGltZW91dCIsCj4gKwkJCQkm cGRhdGEtPmF1dG9zbGVlcF90aW1lb3V0KSkKPiArCQlwZGF0YS0+YXV0b3NsZWVwID0gdHJ1ZTsK PiArCj4gKwlpZiAob2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJpZCIsICZwZGF0YS0+aWQpKQo+ ICsJCWRldl9kYmcoZGV2LCAidW5hYmxlIHRvIGdldCBpZFxuIik7Cj4gKwo+ICsJcmV0dXJuIDA7 Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgc3RtcGVfb2ZfZGV2aWNlc19pbml0KHN0cnVjdCBzdG1w ZSAqc3RtcGUpCj4gK3sKPiArCXN0cnVjdCBzdG1wZV92YXJpYW50X2luZm8gKnZhcmlhbnQgPSBz dG1wZS0+dmFyaWFudDsKPiArCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbmMsICpucCA9IHN0bXBlLT5k ZXYtPm9mX25vZGU7Cj4gKwlzdHJ1Y3Qgc3RtcGVfdmFyaWFudF9ibG9jayAqYmxvY2s7Cj4gKwll bnVtIHN0bXBlX2Jsb2NrIGJsb2NraWQ7Cj4gKwlpbnQgcmV0ID0gLUVJTlZBTDsKPiArCj4gKwlm b3JfZWFjaF9jaGlsZF9vZl9ub2RlKG5wLCBuYykgewo+ICsJCWlmIChvZl9tYXRjaF9ub2RlKHN0 bXBlX2tleXBhZF9pZHMsIG5jKSkgewo+ICsJCQlibG9ja2lkID0gU1RNUEVfQkxPQ0tfS0VZUEFE Owo+ICsJCQlzdG1wZS0+cGRhdGEtPmtleXBhZCA9IGdldF9rZXlib2FyZF9wZGF0YV9kdChzdG1w ZS0+ZGV2LAo+ICsJCQkJCW5jKTsKPiArCQkJaWYgKCFzdG1wZS0+cGRhdGEtPmtleXBhZCkKPiAr CQkJCXJldHVybiAtRU5PTUVNOwo+ICsJCX0gZWxzZSBpZiAob2ZfbWF0Y2hfbm9kZShzdG1wZV9n cGlvX2lkcywgbmMpKSB7Cj4gKwkJCWJsb2NraWQgPSBTVE1QRV9CTE9DS19HUElPOwo+ICsJCQlz dG1wZS0+cGRhdGEtPmdwaW8gPSBnZXRfZ3Bpb19wZGF0YV9kdChzdG1wZS0+ZGV2LCBuYyk7Cj4g KwkJCWlmICghc3RtcGUtPnBkYXRhLT5ncGlvKQo+ICsJCQkJcmV0dXJuIC1FTk9NRU07Cj4gKwkJ fSBlbHNlIGlmIChvZl9tYXRjaF9ub2RlKHN0bXBlX3RzX2lkcywgbmMpKSB7Cj4gKwkJCWJsb2Nr aWQgPSBTVE1QRV9CTE9DS19UT1VDSFNDUkVFTjsKPiArCQkJc3RtcGUtPnBkYXRhLT50cyA9IGdl dF90c19wZGF0YV9kdChzdG1wZS0+ZGV2LCBuYyk7Cj4gKwkJCWlmICghc3RtcGUtPnBkYXRhLT50 cykKPiArCQkJCXJldHVybiAtRU5PTUVNOwo+ICsJCX0gZWxzZSBpZiAob2ZfbWF0Y2hfbm9kZShz dG1wZV9hZGNfaWRzLCBuYykpIHsKPiArCQkJYmxvY2tpZCA9IFNUTVBFX0JMT0NLX0FEQzsKPiAr CQl9IGVsc2UgaWYgKG9mX21hdGNoX25vZGUoc3RtcGVfcHdtX2lkcywgbmMpKSB7Cj4gKwkJCWJs b2NraWQgPSBTVE1QRV9CTE9DS19QV007Cj4gKwkJfSBlbHNlIGlmIChvZl9tYXRjaF9ub2RlKHN0 bXBlX3JvdGF0b3JfaWRzLCBuYykpIHsKPiArCQkJYmxvY2tpZCA9IFNUTVBFX0JMT0NLX1JPVEFU T1I7Cj4gKwkJfSBlbHNlIHsKPiArCQkJZGV2X3dhcm4oc3RtcGUtPmRldiwgIm5vIG1hdGNoaW5n IGRldmljZSBub2RlIGZvdW5kXG4iKTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gKwkJfQo+ICsK PiArCQlibG9jayA9IG1hdGNoX3ZhcmlhbnRfYmxvY2sodmFyaWFudCwgYmxvY2tpZCk7Cj4gKwkJ aWYgKCFibG9jaykgewo+ICsJCQlkZXZfZXJyKHN0bXBlLT5kZXYsICJ2YXJpYW50IGRvZXNuJ3Qg c3VwcG9ydCBibG9ja2lkOiAlZFxuIiwKPiArCQkJCQlibG9ja2lkKTsKPiArCQkJY29udGludWU7 Cj4gKwkJfQo+ICsKPiArCQlyZXQgPSBzdG1wZV9hZGRfZGV2aWNlKHN0bXBlLCBibG9jay0+Y2Vs bCk7Cj4gKwkJaWYgKHJldCkKPiArCQkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlyZXR1cm4g cmV0Owo+ICt9Cj4gKwo+ICsjZWxzZQo+ICtzdGF0aWMgaW5saW5lIGludCBzdG1wZV9wcm9iZV9j b25maWdfZHQoc3RydWN0IHN0bXBlX3BsYXRmb3JtX2RhdGEgKnBkYXRhLAo+ICsJCXN0cnVjdCBk ZXZpY2Vfbm9kZSAqbnApCj4gK3sKPiArCXJldHVybiAtRU5PREVWOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW5saW5lIGludCBzdG1wZV9vZl9kZXZpY2VzX2luaXQoc3RydWN0IHN0bXBlICpzdG1wZSkK PiArewo+ICsJcmV0dXJuIC1FTk9ERVY7Cj4gK30KPiArI2VuZGlmCj4gKwo+ICBzdGF0aWMgaW50 IF9fZGV2aW5pdCBzdG1wZV9kZXZpY2VzX2luaXQoc3RydWN0IHN0bXBlICpzdG1wZSkKPiAgewo+ ICAJc3RydWN0IHN0bXBlX3ZhcmlhbnRfaW5mbyAqdmFyaWFudCA9IHN0bXBlLT52YXJpYW50Owo+ IEBAIC0xMDE3LDMyICsxMjQ0LDYgQEAgc3RhdGljIGludCBfX2RldmluaXQgc3RtcGVfZGV2aWNl c19pbml0KHN0cnVjdCBzdG1wZSAqc3RtcGUpCj4gIAlyZXR1cm4gcmV0Owo+ICB9Cj4gIAo+IC12 b2lkIF9fZGV2aW5pdCBzdG1wZV9vZl9wcm9iZShzdHJ1Y3Qgc3RtcGVfcGxhdGZvcm1fZGF0YSAq cGRhdGEsCj4gLQkJCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApCj4gLXsKPiAtCXN0cnVjdCBkZXZp Y2Vfbm9kZSAqY2hpbGQ7Cj4gLQo+IC0Jb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJzdCxhdXRv c2xlZXAtdGltZW91dCIsCj4gLQkJCSZwZGF0YS0+YXV0b3NsZWVwX3RpbWVvdXQpOwo+IC0KPiAt CXBkYXRhLT5hdXRvc2xlZXAgPSAocGRhdGEtPmF1dG9zbGVlcF90aW1lb3V0KSA/IHRydWUgOiBm YWxzZTsKPiAtCj4gLQlmb3JfZWFjaF9jaGlsZF9vZl9ub2RlKG5wLCBjaGlsZCkgewo+IC0JCWlm ICghc3RyY21wKGNoaWxkLT5uYW1lLCAic3RtcGVfZ3BpbyIpKSB7Cj4gLQkJCXBkYXRhLT5ibG9j a3MgfD0gU1RNUEVfQkxPQ0tfR1BJTzsKPiAtCQl9Cj4gLQkJaWYgKCFzdHJjbXAoY2hpbGQtPm5h bWUsICJzdG1wZV9rZXlwYWQiKSkgewo+IC0JCQlwZGF0YS0+YmxvY2tzIHw9IFNUTVBFX0JMT0NL X0tFWVBBRDsKPiAtCQl9Cj4gLQkJaWYgKCFzdHJjbXAoY2hpbGQtPm5hbWUsICJzdG1wZV90b3Vj aHNjcmVlbiIpKSB7Cj4gLQkJCXBkYXRhLT5ibG9ja3MgfD0gU1RNUEVfQkxPQ0tfVE9VQ0hTQ1JF RU47Cj4gLQkJfQo+IC0JCWlmICghc3RyY21wKGNoaWxkLT5uYW1lLCAic3RtcGVfYWRjIikpIHsK PiAtCQkJcGRhdGEtPmJsb2NrcyB8PSBTVE1QRV9CTE9DS19BREM7Cj4gLQkJfQo+IC0JfQo+IC19 Cj4gLQo+ICAvKiBDYWxsZWQgZnJvbSBjbGllbnQgc3BlY2lmaWMgcHJvYmUgcm91dGluZXMgKi8K PiAgaW50IF9fZGV2aW5pdCBzdG1wZV9wcm9iZShzdHJ1Y3Qgc3RtcGVfY2xpZW50X2luZm8gKmNp LCBpbnQgcGFydG51bSkKPiAgewo+IEBAIC0xMDU5LDcgKzEyNjAsMTEgQEAgaW50IF9fZGV2aW5p dCBzdG1wZV9wcm9iZShzdHJ1Y3Qgc3RtcGVfY2xpZW50X2luZm8gKmNpLCBpbnQgcGFydG51bSkK PiAgCQlpZiAoIXBkYXRhKQo+ICAJCQlyZXR1cm4gLUVOT01FTTsKPiAgCj4gLQkJc3RtcGVfb2Zf cHJvYmUocGRhdGEsIG5wKTsKPiArCQlyZXQgPSBzdG1wZV9wcm9iZV9jb25maWdfZHQoY2ktPmRl diwgcGRhdGEsIG5wKTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJCWRldl9lcnIoY2ktPmRldiwgInBy b2JlX2NvbmZpZ19kdCBmYWlsZWRcbiIpOwo+ICsJCQlyZXR1cm4gcmV0Owo+ICsJCX0KPiAgCX0K PiAgCj4gIAlzdG1wZSA9IGRldm1fa3phbGxvYyhjaS0+ZGV2LCBzaXplb2Yoc3RydWN0IHN0bXBl KSwgR0ZQX0tFUk5FTCk7Cj4gQEAgLTExMzAsNyArMTMzNSwxMCBAQCBpbnQgX19kZXZpbml0IHN0 bXBlX3Byb2JlKHN0cnVjdCBzdG1wZV9jbGllbnRfaW5mbyAqY2ksIGludCBwYXJ0bnVtKQo+ICAJ CX0KPiAgCX0KPiAgCj4gLQlyZXQgPSBzdG1wZV9kZXZpY2VzX2luaXQoc3RtcGUpOwo+ICsJaWYg KG5wKQo+ICsJCXJldCA9IHN0bXBlX29mX2RldmljZXNfaW5pdChzdG1wZSk7Cj4gKwllbHNlCj4g KwkJcmV0ID0gc3RtcGVfZGV2aWNlc19pbml0KHN0bXBlKTsKPiAgCWlmICghcmV0KQo+ICAJCXJl dHVybiAwOwo+ICAKPiAtLSAKPiAxLjcuMTIucmMyLjE4Lmc2MWI0NzJlCj4gCj4gCgotLSAKTGVl IEpvbmVzCkxpbmFybyBTVC1Fcmljc3NvbiBMYW5kaW5nIFRlYW0gTGVhZApMaW5hcm8ub3JnIOKU giBPcGVuIHNvdXJjZSBzb2Z0d2FyZSBmb3IgQVJNIFNvQ3MKRm9sbG93IExpbmFybzogRmFjZWJv b2sgfCBUd2l0dGVyIHwgQmxvZwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpkZXZpY2V0cmVlLWRpc2N1c3MgbWFpbGluZyBsaXN0CmRldmljZXRyZWUtZGlz Y3Vzc0BsaXN0cy5vemxhYnMub3JnCmh0dHBzOi8vbGlzdHMub3psYWJzLm9yZy9saXN0aW5mby9k ZXZpY2V0cmVlLWRpc2N1c3MK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753214Ab2KVScR (ORCPT ); Thu, 22 Nov 2012 13:32:17 -0500 Received: from mail-bk0-f46.google.com ([209.85.214.46]:58622 "EHLO mail-bk0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752870Ab2KVScO (ORCPT ); Thu, 22 Nov 2012 13:32:14 -0500 Date: Thu, 22 Nov 2012 11:24:51 +0000 From: Lee Jones To: Viresh Kumar Cc: sameo@linux.intel.com, devicetree-discuss@lists.ozlabs.org, linux-kernel@vger.kernel.org, spear-devel@list.st.com, Vipul Kumar Samar Subject: Re: [PATCH V2 2/2] mfd: stmpe: Extend DT support in stmpe driver Message-ID: <20121122112451.GE4328@gmail.com> References: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: User-Agent: Mutt/1.5.21 (2010-09-15) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org > From: Vipul Kumar Samar > > This patch extends existing DT support for stmpe devices. Bindings are mentioned > in binding document. > > Signed-off-by: Vipul Kumar Samar > Signed-off-by: Viresh Kumar > --- > V1->V2: > ------ > - Partial DT support was already there, which i missed earlier. > - Now, this patch is an enhancement of existing DT support. Big fat NACK. You've just overwritten the current implementation with your own. Please take time to understand the mechanisms in place before you submit any changes or additions to it. > Documentation/devicetree/bindings/mfd/stmpe.txt | 127 ++++++++++-- > drivers/mfd/stmpe-i2c.c | 23 ++- > drivers/mfd/stmpe-spi.c | 15 ++ > drivers/mfd/stmpe.c | 264 +++++++++++++++++++++--- > 4 files changed, 384 insertions(+), 45 deletions(-) > > diff --git a/Documentation/devicetree/bindings/mfd/stmpe.txt b/Documentation/devicetree/bindings/mfd/stmpe.txt > index 8f0aeda..44aebf3 100644 > --- a/Documentation/devicetree/bindings/mfd/stmpe.txt > +++ b/Documentation/devicetree/bindings/mfd/stmpe.txt > @@ -1,25 +1,124 @@ > -* STMPE Multi-Functional Device > +ST Microelectronics STMPE Multi-Functional Device > +------------------------------------------------- > > +STMPE is an MFD device which may expose following inbuilt devices: gpio, keypad, > +touchscreen, adc, pwm, rotator. > + > +stmpe: > +----- > Required properties: > - - compatible : "st,stmpe[811|1601|2401|2403]" > - - reg : I2C address of the device > +- compatible: Must be one of: "st,stmpe610", "st,stmpe801", "st,stmpe811", > + "st,stmpe1601", "st,stmpe2401", "st,stmpe2403", This is messy. Use the current format, just add the new versions. > +- id: device id to distinguish between multiple STMPEs on the same board > +- reg: I2C/SPI address of the device Why is this better? Can't you just add "/SPI" to the current string? > +Optional properties: > +- irq-trigger: IRQ trigger to use for the interrupt to the host > +- irq-invert-polarity: bool, IRQ line is connected with reversed polarity Are these new? When adding new bindings, ask yourself: 1. Can I do without them? 1.1 Can I derive the configuration from other things? 2.2 Are they _really_ required, or am I just blindly copying platform data? 2. Does a similar binding already exist? 3. Can other drivers make use of them? 3.1 If so, create a generic binding 3.2 If not, prepend the binding with "," > +- autosleep-timeout: inactivity timeout in milliseconds for autosleep. Valid > + entries (ms); 4, 16, 32, 64, 128, 256, 512 and 1024 > +- interrupts: interrupt number of the device, if interrupt is not via gpio > +- interrupt-parent: Specifies which IRQ controller we're connected to > +- irq-over-gpio: bool, true if gpio is used to get irq > +- irq-gpios: gpio number over which irq will be requested (significant only if What was wrong with the old format (below)? Now it's messy and hard to read. Only provide changes which are _better_. > + irq-over-gpio is true) You don't need these. Use gpio_to_irq() instead. > +- i2c-client-wake: Marks the input device as wakable > +stmpe-keypad: > +-------------- > +Required properties in addition to those specified by the shared matrix-keyboard > +bindings: > +- compatible: Must be "stmpe,keypad" That's not how the current implementation works. All you have to do is add child nodes with the names: stmpe_gpio stmpe_keypad stmpe_touchscreen stmpe_adc > Optional properties: > - - interrupts : The interrupt outputs from the controller > - - interrupt-controller : Marks the device node as an interrupt controller > - - interrupt-parent : Specifies which IRQ controller we're connected to > - - i2c-client-wake : Marks the input device as wakable > - - st,autosleep-timeout : Valid entries (ms); 4, 16, 32, 64, 128, 256, 512 and 1024 And you've removed these why? > +- keypad,scan-count: number of key scanning cycles to confirm key data. Maximum > + is STMPE_KEYPAD_MAX_SCAN_COUNT. > +- keypad,debounce-ms: debounce interval, in ms. Maximum is > + STMPE_KEYPAD_MAX_DEBOUNCE. > +- keypad,no-autorepeat: bool, disable key autorepeat See "When adding new bindings, ask yourself" above. > +stmpe-gpio: > +----------- > +Required properties: > +- compatible: Must be "stmpe,gpio" > + > +Optional properties: > +- norequest-mask: bitmask specifying which GPIOs should _not_ be requestable due > + to different usage (e.g. touch, keypad) STMPE_GPIO_NOREQ_* macros can be used > + here. > + > +stmpe-ts: > +----------- > +Required properties: > +- compatible: Must be "stmpe,ts" > + > +Optional properties: > +- sample-time: ADC converstion time in number of clock. (0 -> 36 clocks, 1 -> > + 44 clocks, 2 -> 56 clocks, 3 -> 64 clocks, 4 -> 80 clocks, 5 -> 96 clocks, 6 > + -> 144 clocks), recommended is 4. > +- mod-12b: ADC Bit mode (0 -> 10bit ADC, 1 -> 12bit ADC) > +- ref-sel: ADC reference source (0 -> internal reference, 1 -> external > + reference) > +- adc-freq: ADC Clock speed (0 -> 1.625 MHz, 1 -> 3.25 MHz, 2 || 3 -> 6.5 MHz) > +- ave-ctrl: Sample average control (0 -> 1 sample, 1 -> 2 samples, 2 -> 4 > + samples, 3 -> 8 samples) > +- touch-det-delay: Touch detect interrupt delay (0 -> 10 us, 1 -> 50 us, 2 -> > + 100 us, 3 -> 500 us, 4-> 1 ms, 5 -> 5 ms, 6 -> 10 ms, 7 -> 50 ms) recommended > + is 3 > +- settling: Panel driver settling time (0 -> 10 us, 1 -> 100 us, 2 -> 500 us, 3 > + -> 1 ms, 4 -> 5 ms, 5 -> 10 ms, 6 for 50 ms, 7 -> 100 ms) recommended is 2 > +- fraction-z: Length of the fractional part in z (fraction-z ([0..7]) = Count of > + the fractional part) recommended is 7 > +- i-drive: current limit value of the touchscreen drivers (0 -> 20 mA typical 35 > + mA max, 1 -> 50 mA typical 80 mA max) See "When adding new bindings, ask yourself" above. > +stmpe-adc: > +----------- > +Required properties: > +- compatible: Must be "stmpe,adc" > + > +stmpe-pwm: > +----------- > +Required properties: > +- compatible: Must be "stmpe,pwm" > + > +stmpe-rotator: > +----------- > +Required properties: > +- compatible: Must be "stmpe,rotator" > > Example: > +------- > +stmpe can be present over i2c or spi bus, so its node would be added as child > +node of either of spi or i2c device. > + > +stmpe-devices should be added as child nodes of parent stmpe node. > > +spi@e0100000 { This shouldn't be a child of the SPI device becuase it uses SPI. Drivers use clocks, regulators, IRQ controller too, but they're not children of those devices. > stmpe1601: stmpe1601@40 { > + status = "okay"; You only need this if it's been disabled somewhere else. > compatible = "st,stmpe1601"; > - reg = <0x40>; > - interrupts = <26 0x4>; > - interrupt-parent = <&gpio6>; > - interrupt-controller; Why are you removing these? > + reg = <0>; You have reg twice here. Also reg should never be '0'. > + <.. spi controller specific data ..> > + > + id = <0>; Don't do this. Device IDs are Linux specific. > + irq-over-gpio; > + irq-gpios = <&gpio1 6 0x4>; > + irq-trigger = <0x2>; See "When adding new bindings, ask yourself" above. > - i2c-client-wake; > - st,autosleep-timeout = <1024>; > + stmpe610-ts { > + compatible = "stmpe,ts"; > + ts,sample-time = <4>; > + ts,mod-12b = <1>; > + ts,ref-sel = <0>; > + ts,adc-freq = <1>; > + ts,ave-ctrl = <1>; > + ts,touch-det-delay = <2>; > + ts,settling = <2>; > + ts,fraction-z = <7>; > + ts,i-drive = <1>; Wow! See "When adding new bindings, ask yourself" above. > + }; > }; > +}; > diff --git a/drivers/mfd/stmpe-i2c.c b/drivers/mfd/stmpe-i2c.c > index 947a06a..aaa2da7 100644 > --- a/drivers/mfd/stmpe-i2c.c > +++ b/drivers/mfd/stmpe-i2c.c > @@ -13,6 +13,7 @@ > #include > #include > #include > +#include > #include > #include "stmpe.h" > > @@ -81,12 +82,28 @@ static const struct i2c_device_id stmpe_i2c_id[] = { > }; > MODULE_DEVICE_TABLE(i2c, stmpe_id); > > +#ifdef CONFIG_OF > +static const struct of_device_id stmpe_dt_ids[] = { > + { .compatible = "st,stmpe610", .data = &stmpe_i2c_id[0], }, > + { .compatible = "st,stmpe801", .data = &stmpe_i2c_id[1], }, > + { .compatible = "st,stmpe811", .data = &stmpe_i2c_id[2], }, > + { .compatible = "st,stmpe1601", .data = &stmpe_i2c_id[3], }, > + { .compatible = "st,stmpe2401", .data = &stmpe_i2c_id[4], }, > + { .compatible = "st,stmpe2403", .data = &stmpe_i2c_id[5], }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, stmpe_dt_ids); > +#endif > > static struct i2c_driver stmpe_i2c_driver = { > - .driver.name = "stmpe-i2c", > - .driver.owner = THIS_MODULE, > + .driver = { > + .name = "stmpe-i2c", > + .owner = THIS_MODULE, > #ifdef CONFIG_PM > - .driver.pm = &stmpe_dev_pm_ops, > + .pm = &stmpe_dev_pm_ops, If you want to change these, you need to submit a seperate patch, as they have nothing to do with DT:ing these driver. > #endif > + .of_match_table = of_match_ptr(stmpe_dt_ids), > + }, > .probe = stmpe_i2c_probe, > .remove = __devexit_p(stmpe_i2c_remove), > .id_table = stmpe_i2c_id, > diff --git a/drivers/mfd/stmpe-spi.c b/drivers/mfd/stmpe-spi.c > index 9edfe86..1e2bff0 100644 > --- a/drivers/mfd/stmpe-spi.c > +++ b/drivers/mfd/stmpe-spi.c > @@ -11,6 +11,7 @@ > #include > #include > #include > +#include > #include > #include "stmpe.h" > > @@ -119,6 +120,19 @@ static const struct spi_device_id stmpe_spi_id[] = { > }; > MODULE_DEVICE_TABLE(spi, stmpe_id); > > +#ifdef CONFIG_OF > +static const struct of_device_id stmpe_dt_ids[] = { > + { .compatible = "st,stmpe610", .data = (void *)STMPE610, }, > + { .compatible = "st,stmpe801", .data = (void *)STMPE801, }, > + { .compatible = "st,stmpe811", .data = (void *)STMPE811, }, > + { .compatible = "st,stmpe1601", .data = (void *)STMPE1601, }, > + { .compatible = "st,stmpe2401", .data = (void *)STMPE2401, }, > + { .compatible = "st,stmpe2403", .data = (void *)STMPE2403, }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, stmpe_dt_ids); > +#endif > > static struct spi_driver stmpe_spi_driver = { > .driver = { > .name = "stmpe-spi", > @@ -126,6 +140,7 @@ static struct spi_driver stmpe_spi_driver = { > #ifdef CONFIG_PM > .pm = &stmpe_dev_pm_ops, > #endif > + .of_match_table = of_match_ptr(stmpe_dt_ids), > }, > .probe = stmpe_spi_probe, > .remove = __devexit_p(stmpe_spi_remove), > diff --git a/drivers/mfd/stmpe.c b/drivers/mfd/stmpe.c > index c0df4b9..d69f24b 100644 > --- a/drivers/mfd/stmpe.c > +++ b/drivers/mfd/stmpe.c > @@ -8,11 +8,14 @@ > */ > > #include > +#include > #include > #include > #include > #include > #include > +#include > +#include > #include > #include > #include > @@ -981,6 +984,230 @@ static int __devinit stmpe_add_device(struct stmpe *stmpe, > NULL, stmpe->irq_base, stmpe->domain); > } > > +#ifdef CONFIG_OF > +static const struct of_device_id stmpe_keypad_ids[] = { > + { .compatible = "stmpe,keypad" }, > + {}, > +}; > + > +static const struct of_device_id stmpe_gpio_ids[] = { > + { .compatible = "stmpe,gpio" }, > + {}, > +}; > + > +static const struct of_device_id stmpe_ts_ids[] = { > + { .compatible = "stmpe,ts" }, > + {}, > +}; > + > +static const struct of_device_id stmpe_adc_ids[] = { > + { .compatible = "stmpe,adc" }, > + {}, > +}; > + > +static const struct of_device_id stmpe_pwm_ids[] = { > + { .compatible = "stmpe,pwm" }, > + {}, > +}; > + > +static const struct of_device_id stmpe_rotator_ids[] = { > + { .compatible = "stmpe,rotator" }, > + {}, > +}; There really is no need for all these. Please use the current implementation instead. > +static struct stmpe_keypad_platform_data * > +get_keyboard_pdata_dt(struct device *dev, struct device_node *np) > +{ > + struct stmpe_keypad_platform_data *pdata; > + u32 val; > + > + pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); > + if (!pdata) { > + dev_warn(dev, "stmpe keypad kzalloc fail\n"); > + return NULL; > + } > + > + if (!of_property_read_u32(np, "keypad,scan-count", &val)) > + pdata->scan_count = val; > + if (!of_property_read_u32(np, "keypad,debounce-ms", &val)) > + pdata->debounce_ms = val; > + if (of_property_read_bool(np, "keypad,no-autorepeat")) > + pdata->no_autorepeat = true; Why are you (re)adding these here? Have you even looked in the driver? See: drivers/input/keyboard/stmpe-keypad.c > + return pdata; > +} > + > +static struct stmpe_gpio_platform_data *get_gpio_pdata_dt(struct device *dev, > + struct device_node *np) > +{ > + struct stmpe_gpio_platform_data *pdata; > + u32 val; > + > + pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); > + if (!pdata) { > + dev_warn(dev, "stmpe gpio kzalloc fail\n"); > + return NULL; > + } > + > + if (!of_property_read_u32(np, "gpio,norequest-mask", &val)) > + pdata->norequest_mask = val; > + > + /* assign gpio numbers dynamically */ > + pdata->gpio_base = -1; > + > + return pdata; > +} Is this function really required? Even if is is, should it live here or in the STMPE driver? See: drivers/gpio/gpio-stmpe.c > +static struct stmpe_ts_platform_data *get_ts_pdata_dt(struct device *dev, > + struct device_node *np) > +{ > + struct stmpe_ts_platform_data *pdata; > + u32 val; > + > + pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); > + if (!pdata) { > + dev_warn(dev, "stmpe ts kzalloc fail\n"); > + return NULL; > + } > + > + if (!of_property_read_u32(np, "ts,sample-time", &val)) > + pdata->sample_time = val; > + if (!of_property_read_u32(np, "ts,mod-12b", &val)) > + pdata->mod_12b = val; > + if (!of_property_read_u32(np, "ts,ref-sel", &val)) > + pdata->ref_sel = val; > + if (!of_property_read_u32(np, "ts,adc-freq", &val)) > + pdata->adc_freq = val; > + if (!of_property_read_u32(np, "ts,ave-ctrl", &val)) > + pdata->ave_ctrl = val; > + if (!of_property_read_u32(np, "ts,touch-det-delay", &val)) > + pdata->touch_det_delay = val; > + if (!of_property_read_u32(np, "ts,settling", &val)) > + pdata->settling = val; > + if (!of_property_read_u32(np, "ts,fraction-z", &val)) > + pdata->fraction_z = val; > + if (!of_property_read_u32(np, "ts,i-drive", &val)) > + pdata->i_drive = val; > + > + return pdata; > +} As above. I'm going to stop my review here. I think you get the idea. > +static struct stmpe_variant_block * > +match_variant_block(struct stmpe_variant_info *variant, > + enum stmpe_block blocks) > +{ > + int i; > + > + for (i = 0; i < variant->num_blocks; i++) { > + struct stmpe_variant_block *block = &variant->blocks[i]; > + > + if (blocks & block->block) > + return block; > + } > + return NULL; > +} > + > +static int stmpe_probe_config_dt(struct device *dev, > + struct stmpe_platform_data *pdata, struct device_node *np) > +{ > + enum of_gpio_flags flags; > + > + pdata->irq_base = irq_alloc_descs(-1, 0, STMPE_NR_IRQS, 0); > + if (IS_ERR_VALUE(pdata->irq_base)) { > + dev_err(dev, "%s: irq desc alloc failed\n", __func__); > + return -ENXIO; > + } > + > + if (of_property_read_bool(np, "irq_over_gpio")) { > + pdata->irq_over_gpio = true; > + > + pdata->irq_gpio = of_get_named_gpio_flags(np, "irq-gpios", 0, > + &flags); > + if (!pdata->irq_gpio) > + dev_dbg(dev, "unable to get irq_gpio from %s.", > + __func__); > + } > + > + if (of_property_read_u32(np, "irq-trigger", &pdata->irq_trigger)) > + dev_dbg(dev, "unable to get irq_trigger\n"); > + > + if (of_property_read_bool(np, "irq-invert-polarity")) > + pdata->irq_invert_polarity = true; > + > + if (!of_property_read_u32(np, "autosleep-timeout", > + &pdata->autosleep_timeout)) > + pdata->autosleep = true; > + > + if (of_property_read_u32(np, "id", &pdata->id)) > + dev_dbg(dev, "unable to get id\n"); > + > + return 0; > +} > + > +static int stmpe_of_devices_init(struct stmpe *stmpe) > +{ > + struct stmpe_variant_info *variant = stmpe->variant; > + struct device_node *nc, *np = stmpe->dev->of_node; > + struct stmpe_variant_block *block; > + enum stmpe_block blockid; > + int ret = -EINVAL; > + > + for_each_child_of_node(np, nc) { > + if (of_match_node(stmpe_keypad_ids, nc)) { > + blockid = STMPE_BLOCK_KEYPAD; > + stmpe->pdata->keypad = get_keyboard_pdata_dt(stmpe->dev, > + nc); > + if (!stmpe->pdata->keypad) > + return -ENOMEM; > + } else if (of_match_node(stmpe_gpio_ids, nc)) { > + blockid = STMPE_BLOCK_GPIO; > + stmpe->pdata->gpio = get_gpio_pdata_dt(stmpe->dev, nc); > + if (!stmpe->pdata->gpio) > + return -ENOMEM; > + } else if (of_match_node(stmpe_ts_ids, nc)) { > + blockid = STMPE_BLOCK_TOUCHSCREEN; > + stmpe->pdata->ts = get_ts_pdata_dt(stmpe->dev, nc); > + if (!stmpe->pdata->ts) > + return -ENOMEM; > + } else if (of_match_node(stmpe_adc_ids, nc)) { > + blockid = STMPE_BLOCK_ADC; > + } else if (of_match_node(stmpe_pwm_ids, nc)) { > + blockid = STMPE_BLOCK_PWM; > + } else if (of_match_node(stmpe_rotator_ids, nc)) { > + blockid = STMPE_BLOCK_ROTATOR; > + } else { > + dev_warn(stmpe->dev, "no matching device node found\n"); > + return -EINVAL; > + } > + > + block = match_variant_block(variant, blockid); > + if (!block) { > + dev_err(stmpe->dev, "variant doesn't support blockid: %d\n", > + blockid); > + continue; > + } > + > + ret = stmpe_add_device(stmpe, block->cell); > + if (ret) > + return ret; > + } > + > + return ret; > +} > + > +#else > +static inline int stmpe_probe_config_dt(struct stmpe_platform_data *pdata, > + struct device_node *np) > +{ > + return -ENODEV; > +} > + > +static inline int stmpe_of_devices_init(struct stmpe *stmpe) > +{ > + return -ENODEV; > +} > +#endif > + > static int __devinit stmpe_devices_init(struct stmpe *stmpe) > { > struct stmpe_variant_info *variant = stmpe->variant; > @@ -1017,32 +1244,6 @@ static int __devinit stmpe_devices_init(struct stmpe *stmpe) > return ret; > } > > -void __devinit stmpe_of_probe(struct stmpe_platform_data *pdata, > - struct device_node *np) > -{ > - struct device_node *child; > - > - of_property_read_u32(np, "st,autosleep-timeout", > - &pdata->autosleep_timeout); > - > - pdata->autosleep = (pdata->autosleep_timeout) ? true : false; > - > - for_each_child_of_node(np, child) { > - if (!strcmp(child->name, "stmpe_gpio")) { > - pdata->blocks |= STMPE_BLOCK_GPIO; > - } > - if (!strcmp(child->name, "stmpe_keypad")) { > - pdata->blocks |= STMPE_BLOCK_KEYPAD; > - } > - if (!strcmp(child->name, "stmpe_touchscreen")) { > - pdata->blocks |= STMPE_BLOCK_TOUCHSCREEN; > - } > - if (!strcmp(child->name, "stmpe_adc")) { > - pdata->blocks |= STMPE_BLOCK_ADC; > - } > - } > -} > - > /* Called from client specific probe routines */ > int __devinit stmpe_probe(struct stmpe_client_info *ci, int partnum) > { > @@ -1059,7 +1260,11 @@ int __devinit stmpe_probe(struct stmpe_client_info *ci, int partnum) > if (!pdata) > return -ENOMEM; > > - stmpe_of_probe(pdata, np); > + ret = stmpe_probe_config_dt(ci->dev, pdata, np); > + if (ret) { > + dev_err(ci->dev, "probe_config_dt failed\n"); > + return ret; > + } > } > > stmpe = devm_kzalloc(ci->dev, sizeof(struct stmpe), GFP_KERNEL); > @@ -1130,7 +1335,10 @@ int __devinit stmpe_probe(struct stmpe_client_info *ci, int partnum) > } > } > > - ret = stmpe_devices_init(stmpe); > + if (np) > + ret = stmpe_of_devices_init(stmpe); > + else > + ret = stmpe_devices_init(stmpe); > if (!ret) > return 0; > > -- > 1.7.12.rc2.18.g61b472e > > -- Lee Jones Linaro ST-Ericsson Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog