From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Williams, Dan J" Subject: Re: [PATCH v5 02/21] libnvdimm, nfit: initial libnvdimm infrastructure and NFIT support Date: Wed, 3 Jun 2015 19:24:34 +0000 Message-ID: <1433359473.21035.27.camel@intel.com> References: <20150602001134.4506.45867.stgit@dwillia2-desk3.amr.corp.intel.com> <20150602001419.4506.41953.stgit@dwillia2-desk3.amr.corp.intel.com> <20150603145704.GA22311@lst.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20150603145704.GA22311-jcswGhMUV9g@public.gmane.org> Content-Language: en-US Content-ID: <1330DB59B70A7047AD4818F14B893C18-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org> Sender: linux-api-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: "hch-jcswGhMUV9g@public.gmane.org" Cc: "linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "mingo-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org" , "neilb-l3A5Bk7waGM@public.gmane.org" , "jmoyer-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org" , "linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "axboe-tSWWG44O7X1aa/9Udqfwiw@public.gmane.org" , "akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org" , "sfr-3FnU+UHB4dNDw9hX6IcOSA@public.gmane.org" , "linux-nvdimm-hn68Rpc1hR1g9hUCZPvPmw@public.gmane.org" , "gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r@public.gmane.org" , "rafael-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org" , "linux-acpi-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" List-Id: linux-api@vger.kernel.org T24gV2VkLCAyMDE1LTA2LTAzIGF0IDE2OjU3ICswMjAwLCBDaHJpc3RvcGggSGVsbHdpZyB3cm90 ZToNCj4gT24gTW9uLCBKdW4gMDEsIDIwMTUgYXQgMDg6MTQ6MTlQTSAtMDQwMCwgRGFuIFdpbGxp YW1zIHdyb3RlOg0KPiA+IEEgbGlibnZkaW1tIGJ1cyBpcyB0aGUgYW5jaG9yIGRldmljZSBmb3Ig cmVnaXN0ZXJpbmcgbnZkaW1tIHJlc291cmNlcyBhbmQNCj4gPiBpbnRlcmZhY2VzLCBmb3IgZXhh bXBsZSwgYSBjaGFyYWN0ZXIgY29udHJvbCBkZXZpY2UsIG52ZGltbSBkZXZpY2VzLA0KPiA+IGFu ZCBJL08gcmVnaW9uIGRldmljZXMuICBUaGUgQUNQSSBORklUIChOVkRJTU0gRmlybXdhcmUgSW50 ZXJmYWNlIFRhYmxlKQ0KPiA+IGlzIG9uZSBwb3NzaWJsZSBwbGF0Zm9ybSBkZXNjcmlwdGlvbiBm b3Igc3VjaCBub24tdm9sYXRpbGUgbWVtb3J5DQo+ID4gcmVzb3VyY2VzIGluIGEgc3lzdGVtLiAg VGhlIG5maXQua28gZHJpdmVyIGF0dGFjaGVzIHRvIHRoZSAiQUNQSTAwMTIiDQo+ID4gZGV2aWNl IHRoYXQgaW5kaWNhdGVzIHRoZSBwcmVzZW5jZSBvZiB0aGUgTkZJVCBhbmQgcGFyc2VzIHRoZSB0 YWJsZSB0bw0KPiA+IHJlZ2lzdGVyIGEgbGlibnZkaW1tIGJ1cyBpbnN0YW5jZS4NCj4gDQo+IEhh dmluIGxpYiBpbiBhIG5hbWUgb2YgYSBidXMgc2VlbXMgb2RkLiAgV2h5IG5vdCBzaW1wbHkgdGhl IG52ZGltbSBidXM/DQoNClNvcnJ5LCB0aGF0IGlzIGEgdHlwbyB0aGUgYnVzIGlzIGluZGVlZCBh biBzdHJ1Y3QgbnZkaW1tX2J1cyBpbnN0YW5jZS4NCg0KPiBBbHNvIHRoaXMgc2VlbXMgdG8gYm90 aCBoYXZlIHRoZSBnZW5lcmljIG52ZGltbSBpbmZyYXN0cnVjdHVyZSBhcyB3ZWxsDQo+IGFzIHRo ZSBhY3BpIHdpcmluZy4gIE1pZ2h0IG1ha2Ugc2Vuc2UgdG8gc3BsaXQgdGhpcyBpbnRvIHR3byBw YXRjaGVzPw0KDQpJIGxpa2UgdG8gc2hvdyBhbiBpbml0aWFsIGluZnJhc3RydWN0dXJlIGNvbnN1 bWVyIHdpdGggdGhlIGluaXRpYWwNCmltcGxlbWVudGF0aW9uIGluIG9uZSBwYXRjaC4gICBNYWtl cyBpdCBlYXNpZXIgdG8gY2F0Y2ggcHJlbWF0dXJlDQppbXBsZW1lbnRhdGlvbiBvZiBmZWF0dXJl cy4NCg0KPiANCj4gPiArY29uZmlnIEFDUElfTkZJVA0KPiA+ICsJdHJpc3RhdGUgIkFDUEkgTlZE SU1NIEZpcm13YXJlIEludGVyZmFjZSBUYWJsZSAoTkZJVCkiDQo+ID4gKwlkZXBlbmRzIG9uIFBI WVNfQUREUl9UXzY0QklUDQo+ID4gKwlkZXBlbmRzIG9uIEJMS19ERVYNCj4gPiArCXNlbGVjdCBO VkRJTU1fREVWSUNFUw0KPiA+ICsJc2VsZWN0IExJQk5WRElNTQ0KPiANCj4gSXMgdGhpcyB0aGUg cmlnaHQgd2F5IGZvciB0aGUgdXNlciB0byBjaG9zZSBpdD8gIEl0IHNlZW1zIGxpa2UgZW5hYmxp bmcNCj4gdGhlIE5WTURJTU0gc3Vic3lzdGVtIHdvdWxkIGJlIHRoZSBvYnZpb3VzIGNob2ljZSwg YW5kIEFDUEkgd291bGQNCj4gc2ltcGx5IGVuYWJsZSB0aGUgdGFibGUgcGFyc2luZyBpbiB0aGF0 IGNhc2UuDQoNClRoZSBOVkRJTU0gc3ViLXN5c3RlbSBpcyBlbmFibGVkIGJ5IGFuIGV4dGVybmFs IHByb3ZpZGVyLiAgV2UgaGF2ZSB0aGUNCmU4MjAgdHlwZS0xMiBwcm92aWRlciBhbmQgdGhlIE5G SVQgcHJvdmlkZXIgdGhhdCBzZWxlY3QgTElCTlZESU1NLg0KDQo+ID4gK3N0YXRpYyB1OCBuZml0 X3V1aWRbTkZJVF9VVUlEX01BWF1bMTZdOw0KPiANCj4gU2hvdWxkIHRoaXMgdXNlIHRoZSB1dWlk X2xlIHR5cGU/DQo+IA0KDQpUaGF0IHdvdWxkIGRlcGVuZCBvbiBSYWZhZWwgYmVpbmcgb3BlbiB0 byBjaGFuZ2luZyB0aGUNCmFjcGlfc3RyX3RvX3V1aWQoKSBwcm90b3R5cGUgdG8gdGFrZSBhbiB1 dWlkX2xlLg0KDQo+ID4gK3N0YXRpYyBjb25zdCBjaGFyICpzcGFfdHlwZV9uYW1lKHUxNiB0eXBl KQ0KPiA+ICt7DQo+ID4gKwlzd2l0Y2ggKHR5cGUpIHsNCj4gPiArCWNhc2UgTkZJVF9TUEFfVk9M QVRJTEU6IHJldHVybiAidm9sYXRpbGUiOw0KPiA+ICsJY2FzZSBORklUX1NQQV9QTTogcmV0dXJu ICJwbWVtIjsNCj4gPiArCWNhc2UgTkZJVF9TUEFfRENSOiByZXR1cm4gImRpbW0tY29udHJvbC1y ZWdpb24iOw0KPiA+ICsJY2FzZSBORklUX1NQQV9CRFc6IHJldHVybiAiYmxvY2stZGF0YS13aW5k b3ciOw0KPiA+ICsJZGVmYXVsdDogcmV0dXJuICJ1bmtub3duIjsNCj4gDQo+IFBsZWFzZSBuZXZl ciBwdXQgY29kZSBvbiB0aGUgc2FtZSBsaW5lIGFzIGEgc3dpdGNoIChvciBnb3RvKSBsYWJlbC4N Cg0KT2ssIGZpeGVkLg0KDQo+IA0KPiA+ICtzdGF0aWMgdm9pZCAqYWRkX3RhYmxlKHN0cnVjdCBh Y3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLCB2b2lkICp0YWJsZSwgY29uc3Qgdm9pZCAqZW5kKQ0K PiA+ICt7DQo+ID4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBhY3BpX2Rlc2MtPmRldjsNCj4gPiAr CXN0cnVjdCBhY3BpX25maXRfaGVhZGVyICpoZHI7DQo+ID4gKwl2b2lkICplcnIgPSBFUlJfUFRS KC1FTk9NRU0pOw0KPiA+ICsNCj4gPiArCWlmICh0YWJsZSA+PSBlbmQpDQo+ID4gKwkJcmV0dXJu IE5VTEw7DQo+ID4gKw0KPiA+ICsJaGRyID0gKHN0cnVjdCBhY3BpX25maXRfaGVhZGVyICopIHRh YmxlOw0KPiANCj4gTm8gbmVlZCB0byBjYXNlIGZyb20gdm9pZCAqIHRvIGFub3RoZXIgcG9pbnRl ciB0eXBlLg0KDQpXaG9vcHMsIGZpeGVkLg0KDQo+IA0KPiA+ICsJc3dpdGNoIChoZHItPnR5cGUp IHsNCj4gPiArCWNhc2UgQUNQSV9ORklUX1RZUEVfU1lTVEVNX0FERFJFU1M6IHsNCj4gPiArCQlz dHJ1Y3QgbmZpdF9zcGEgKm5maXRfc3BhID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpuZml0 X3NwYSksDQo+ID4gKwkJCQlHRlBfS0VSTkVMKTsNCj4gPiArCQlzdHJ1Y3QgYWNwaV9uZml0X3N5 c3RlbV9hZGRyZXNzICpzcGEgPSB0YWJsZTsNCj4gPiArDQo+ID4gKwkJaWYgKCFuZml0X3NwYSkN Cj4gPiArCQkJcmV0dXJuIGVycjsNCj4gPiArCQlJTklUX0xJU1RfSEVBRCgmbmZpdF9zcGEtPmxp c3QpOw0KPiA+ICsJCW5maXRfc3BhLT5zcGEgPSBzcGE7DQo+ID4gKwkJbGlzdF9hZGRfdGFpbCgm bmZpdF9zcGEtPmxpc3QsICZhY3BpX2Rlc2MtPnNwYXMpOw0KPiA+ICsJCWRldl9kYmcoZGV2LCAi JXM6IHNwYSBpbmRleDogJWQgdHlwZTogJXNcbiIsIF9fZnVuY19fLA0KPiA+ICsJCQkJc3BhLT5y YW5nZV9pbmRleCwNCj4gPiArCQkJCXNwYV90eXBlX25hbWUobmZpdF9zcGFfdHlwZShzcGEpKSk7 DQo+IA0KPiBJZiB5b3UgbmVlZCBsb2NhbCB2YXJpYWJsZXMgaW5zaWRlIGEgc3dpdGNoIHN0YXRl bWVudCB5b3UgcHJvYmFibHkNCj4gd2FudCB0byBzcGxpdCBlYWNoIGNhc2UgaW50byBhIHNlcGFy YXRlIGhlbHBlciBmdW5jdGlvbi4NCg0KWWVhaCwgcHJvYmFibHkgYmV0dGVyIHRoYXQgd2F5LiBE b25lLg0KDQo+IA0KPiA+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBhY3BpX25maXRfbWVtb3J5X21h cCAqX190b19uZml0X21lbWRldihzdHJ1Y3QgbmZpdF9tZW0gKm5maXRfbWVtKQ0KPiANCj4gVGhp cyBsaW5lIGlzIG92ZXIgODAgY2hhcmFjdGVycy4NCg0KSSBnZW5lcmFsbHkgZG9uJ3Qgc2VlIHRo ZSBwb2ludCBvZiBmaXhpbmcgdXAgb2NjYXNpb25hbCBzbWFsbCBpbmN1cnNpb25zDQpvdmVyIDgw IGNoYXJhY3RlcnMgaWYgaXQgbWFrZXMgdGhlIGNvZGUgbW9yZSBhbWVuYWJsZSB0byBncmVwLg0K DQo+IEFsc28gd2h5IHRoZSBvZGQgX18tcHJlZml4Pw0KDQpMYXRlciBvbiB0aGUgc2VyaWVzIHRo ZXJlJ3MgYSB0b19uZml0X21lbWRldigpIHRoYXQgdGFrZXMgYSBzdHJ1Y3QNCmRldmljZSAqLCBh bmQgdGhpcyBvbmUgaXMgYW4gaW50ZXJuYWwgaGVscGVyLg0KDQo+IA0KPiA+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0DQo+ID4gaW5kZXggMDAwMDAwMDAwMDAwLi4yNGI1MWRiYzgyMTUNCj4gPiAtLS0g L2Rldi9udWxsDQo+ID4gKysrIGIvZHJpdmVycy9udmRpbW0vS2NvbmZpZw0KPiA+IEBAIC0wLDAg KzEsMjAgQEANCj4gPiArbWVudWNvbmZpZyBOVkRJTU1fREVWSUNFUw0KPiA+ICsJYm9vbCAiTlZE SU1NIChOb24tVm9sYXRpbGUgTWVtb3J5IERldmljZSkgU3VwcG9ydCINCj4gPiArCWhlbHANCj4g PiArCSAgR2VuZXJpYyBzdXBwb3J0IGZvciBub24tdm9sYXRpbGUgbWVtb3J5IGRldmljZXMgaW5j bHVkaW5nDQo+ID4gKwkgIEFDUEktNi1ORklUIGRlZmluZWQgcmVzb3VyY2VzLiAgT24gcGxhdGZv cm1zIHRoYXQgZGVmaW5lIGFuDQo+ID4gKwkgIE5GSVQsIG9yIG90aGVyd2lzZSBjYW4gZGlzY292 ZXIgTlZESU1NIHJlc291cmNlcywgYSBsaWJudmRpbW0NCj4gPiArCSAgYnVzIGlzIHJlZ2lzdGVy ZWQgdG8gYWR2ZXJ0aXNlIFBNRU0gKHBlcnNpc3RlbnQgbWVtb3J5KQ0KPiA+ICsJICBuYW1lc3Bh Y2VzICgvZGV2L3BtZW1YKSBhbmQgQkxLIChzbGlkaW5nIG1taW8gd2luZG93KHMpKQ0KPiA+ICsJ ICBuYW1lc3BhY2VzICgvZGV2L25kWCkuIEEgUE1FTSBuYW1lc3BhY2UgcmVmZXJzIHRvIGEgbWVt b3J5DQo+ID4gKwkgIHJlc291cmNlIHRoYXQgbWF5IHNwYW4gbXVsdGlwbGUgRElNTXMgYW5kIHN1 cHBvcnQgREFYIChzZWUNCj4gPiArCSAgQ09ORklHX0RBWCkuICBBIEJMSyBuYW1lc3BhY2UgcmVm ZXJzIHRvIGFuIE5WRElNTSBjb250cm9sDQo+ID4gKwkgIHJlZ2lvbiB3aGljaCBleHBvc2VzIGFu IG1taW8gcmVnaXN0ZXIgc2V0IGZvciB3aW5kb3dlZA0KPiA+ICsJICBhY2Nlc3MgbW9kZSB0byBu b24tdm9sYXRpbGUgbWVtb3J5Lg0KPiA+ICsNCj4gPiAraWYgTlZESU1NX0RFVklDRVMNCj4gPiAr DQo+ID4gK2NvbmZpZyBMSUJOVkRJTU0NCj4gPiArCXRyaXN0YXRlDQo+ID4gKw0KPiA+ICtlbmRp Zg0KPiANCj4gV2hhdCBkaWZmZXJlbnQgbWVhbmluZ3Mgd2lsbCBDT05GSUdfTlZESU1NX0RFVklD RVMgYW5kIENPTkZJR19MSUJOVkRJTU0NCj4gaGF2ZT8NCg0KSG1tLCBub3RoaW5nIHdvcnRod2hp bGUuICBJJ2xsIG1lcmdlIHRoZW0gaW50byBvbmUgbWVudWNvbmZpZw0KQ09ORklHX0xJQk5WRElN TSB0cmlzdGF0ZS4NCg0KPiANCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9udmRpbW0vbmQtcHJp dmF0ZS5oIGIvZHJpdmVycy9udmRpbW0vbmQtcHJpdmF0ZS5oDQo+ID4gbmV3IGZpbGUgbW9kZSAx MDA2NDQNCj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLmU3YzRlOTlhMjJhNA0KPiA+IC0tLSAvZGV2 L251bGwNCj4gPiArKysgYi9kcml2ZXJzL252ZGltbS9uZC1wcml2YXRlLmgNCj4gDQo+IE5vIG5l ZWQgZm9yIC1wcml2YXRlIGlmIHlvdSdyZSBhbHJlYWR5IHVuZGVyIGRyaXZlcnMvbnZkaW1tLi4N Cg0KVGhpcyBpcyB0aGUgcHJpdmF0ZSBwcml2YXRlLWhlYWRlciBpbiB0aGUgc2Vuc2UgdGhhdCBp dCBkZWZpbmVzDQppbmZyYXN0cnVjdHVyZSB0aGF0IGlzIG9ubHkgbWVhbnQgZm9yIHRoZSBjb3Jl LiAgRHJpdmVycyAoYnR0LCBwbWVtLA0KYmxrLCBldGMpIG11c3Qgbm90IGluY2x1ZGUgbmQtcHJp dmF0ZS5oLiAgSSdsbCByZW5hbWUgaXQgIm5kLWNvcmUuaCIgdG8NCm1ha2UgdGhpcyBtb3JlIGNs ZWFyLg0KDQo+ID4gKyNpZm5kZWYgX19ORF9QUklWQVRFX0hfXw0KPiA+ICsjZGVmaW5lIF9fTkRf UFJJVkFURV9IX18NCj4gPiArI2luY2x1ZGUgPGxpbnV4L2xpYm52ZGltbS5oPg0KPiA+ICsjaW5j bHVkZSA8bGludXgvZGV2aWNlLmg+DQo+ID4gKw0KPiA+ICtzdHJ1Y3QgbnZkaW1tX2J1cyB7DQo+ ID4gKwlzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9yICpuZF9kZXNjOw0KPiA+ICsJc3RydWN0 IGRldmljZSBkZXY7DQo+ID4gKwlpbnQgaWQ7DQo+ID4gK307DQo+ID4gKyNlbmRpZiAvKiBfX05E X1BSSVZBVEVfSF9fICovDQo+IA0KPiBBdCBsZWFzdCBzbyBmYXIgdGhpcyBoZWFkZXIgZG9lc24n dCBuZWVkIGxpYm52ZGltbS5oDQoNCnN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3IgaXMgZGVm aW5lZCB0aGVyZSBhbmQgYSBmb3J3YXJkIGRlY2xhcmF0aW9uDQpkb2VzIG5vdCBtYWtlIHNlbnNl IHNpbmNlIHdlJ2xsIG5lZWQgdGhlIHJlc3Qgb2YgdGhlIGhlYWRlciBsYXRlciBpbiB0aGUNCnNl cmllcy4NCg0KPiANCj4gPiArI2lmbmRlZiBfX0xJQk5WRElNTV9IX18NCj4gPiArI2RlZmluZSBf X0xJQk5WRElNTV9IX18NCj4gPiArc3RydWN0IG52ZGltbTsNCj4gPiArc3RydWN0IG52ZGltbV9i dXNfZGVzY3JpcHRvcjsNCj4gPiArdHlwZWRlZiBpbnQgKCpuZGN0bF9mbikoc3RydWN0IG52ZGlt bV9idXNfZGVzY3JpcHRvciAqbmRfZGVzYywNCj4gPiArCQlzdHJ1Y3QgbnZkaW1tICpudmRpbW0s IHVuc2lnbmVkIGludCBjbWQsIHZvaWQgKmJ1ZiwNCj4gPiArCQl1bnNpZ25lZCBpbnQgYnVmX2xl bik7DQo+ID4gKw0KPiA+ICtzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9yIHsNCj4gPiArCXVu c2lnbmVkIGxvbmcgZHNtX21hc2s7DQo+ID4gKwljaGFyICpwcm92aWRlcl9uYW1lOw0KPiA+ICsJ bmRjdGxfZm4gbmRjdGw7DQo+ID4gK307DQo+IA0KPiBQbGVhc2UgcHJvdmlkZSBwcm9wZXIgbWV0 aG9kcyB0aGF0IGRvIG9uZSB0aGluZyBwcm9wZXJseSBpbnN0ZWFkIG9mDQo+IGlvY3RsLWxpa2Ug bXVsdGlwbGV4ZXJzLg0KDQpUaGlzICppcyogdGhlIGlvY3RsIG11bHRpcGxleGVyLiAgVGhlIGdl bmVyaWMgaW9jdGwgaW1wbGVtZW50YXRpb24gaW4NCmxpYm52ZGltbSB1c2VzIHRoZSBuZGN0bF9m biB0byBjYWxsIGJhY2sgb3V0IHRvIHRoZSBwcm92aWRlciB0byBwcm9jZXNzDQp0aGUgY29tbWFu ZC4gIEluIHRoZSBjYXNlIG9mIEFDUEkgdGhpcyBtYXBzIHRvIGEgX0RTTSAoZGV2aWNlIHNwZWNp ZmljDQptZXRob2QpLCBmb3IgbmZpdF90ZXN0IGl0J3MgYSBlbXVsYXRlZCBpbXBsZW1lbnRhdGlv biwgYW5kIGZvcg0KZTgyMC10eXBlLTEyIHRoaXMgaXMgb2J2aW91c2x5IG5vdCBpbXBsZW1lbnRl ZC4NCg0KDQpSZWZsb3dlZCBwYXRjaCB3aXRoIHRoZXNlIGZpeGVzIGZvbGxvd3MuLi4NCg0KDQo4 PC0tLS0tDQpTdWJqZWN0OiBsaWJudmRpbW0sIG5maXQ6IGluaXRpYWwgbGlibnZkaW1tIGluZnJh c3RydWN0dXJlIGFuZCBORklUIHN1cHBvcnQNCg0KRnJvbTogRGFuIFdpbGxpYW1zIDxkYW4uai53 aWxsaWFtc0BpbnRlbC5jb20+DQoNCkEgbGlibnZkaW1tIGJ1cyBpcyB0aGUgYW5jaG9yIGRldmlj ZSBmb3IgcmVnaXN0ZXJpbmcgbnZkaW1tIHJlc291cmNlcyBhbmQNCmludGVyZmFjZXMsIGZvciBl eGFtcGxlLCBhIGNoYXJhY3RlciBjb250cm9sIGRldmljZSwgbnZkaW1tIGRldmljZXMsDQphbmQg SS9PIHJlZ2lvbiBkZXZpY2VzLiAgVGhlIEFDUEkgTkZJVCAoTlZESU1NIEZpcm13YXJlIEludGVy ZmFjZSBUYWJsZSkNCmlzIG9uZSBwb3NzaWJsZSBwbGF0Zm9ybSBkZXNjcmlwdGlvbiBmb3Igc3Vj aCBub24tdm9sYXRpbGUgbWVtb3J5DQpyZXNvdXJjZXMgaW4gYSBzeXN0ZW0uICBUaGUgbmZpdC5r byBkcml2ZXIgYXR0YWNoZXMgdG8gdGhlICJBQ1BJMDAxMiINCmRldmljZSB0aGF0IGluZGljYXRl cyB0aGUgcHJlc2VuY2Ugb2YgdGhlIE5GSVQgYW5kIHBhcnNlcyB0aGUgdGFibGUgdG8NCnJlZ2lz dGVyIGEgc3RydWN0IG52ZGltbV9idXMgaW5zdGFuY2UuDQoNCkNjOiA8bGludXgtYWNwaUB2Z2Vy Lmtlcm5lbC5vcmc+DQpDYzogTHYgWmhlbmcgPGx2LnpoZW5nQGludGVsLmNvbT4NCkNjOiBSb2Jl cnQgTW9vcmUgPHJvYmVydC5tb29yZUBpbnRlbC5jb20+DQpDYzogUmFmYWVsIEouIFd5c29ja2kg PHJhZmFlbC5qLnd5c29ja2lAaW50ZWwuY29tPg0KQWNrZWQtYnk6IEplZmYgTW95ZXIgPGptb3ll ckByZWRoYXQuY29tPg0KU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFt c0BpbnRlbC5jb20+DQotLS0NCiBkcml2ZXJzL0tjb25maWcgICAgICAgICAgIHwgICAgMiANCiBk cml2ZXJzL01ha2VmaWxlICAgICAgICAgIHwgICAgMSANCiBkcml2ZXJzL2FjcGkvS2NvbmZpZyAg ICAgIHwgICAxNCArDQogZHJpdmVycy9hY3BpL01ha2VmaWxlICAgICB8ICAgIDEgDQogZHJpdmVy cy9hY3BpL25maXQuYyAgICAgICB8ICA0ODEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrDQogZHJpdmVycy9hY3BpL25maXQuaCAgICAgICB8ICAgODkgKysrKysr KysNCiBkcml2ZXJzL252ZGltbS9LY29uZmlnICAgIHwgICAxMyArDQogZHJpdmVycy9udmRpbW0v TWFrZWZpbGUgICB8ICAgIDMgDQogZHJpdmVycy9udmRpbW0vY29yZS5jICAgICB8ICAgNjcgKysr KysrDQogZHJpdmVycy9udmRpbW0vbmQtY29yZS5oICB8ICAgMjMgKysNCiBpbmNsdWRlL2xpbnV4 L2xpYm52ZGltbS5oIHwgICAzNCArKysNCiAxMSBmaWxlcyBjaGFuZ2VkLCA3MjggaW5zZXJ0aW9u cygrKQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2FjcGkvbmZpdC5jDQogY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvYWNwaS9uZml0LmgNCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9udmRpbW0vS2NvbmZpZw0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL252ZGltbS9NYWtl ZmlsZQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL252ZGltbS9jb3JlLmMNCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9udmRpbW0vbmQtY29yZS5oDQogY3JlYXRlIG1vZGUgMTAwNjQ0 IGluY2x1ZGUvbGludXgvbGlibnZkaW1tLmgNCg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvS2NvbmZp ZyBiL2RyaXZlcnMvS2NvbmZpZw0KaW5kZXggYzBjYzk2YmFiOWU3Li42ZTk3M2I4ZTNhM2IgMTAw NjQ0DQotLS0gYS9kcml2ZXJzL0tjb25maWcNCisrKyBiL2RyaXZlcnMvS2NvbmZpZw0KQEAgLTE4 Miw0ICsxODIsNiBAQCBzb3VyY2UgImRyaXZlcnMvdGh1bmRlcmJvbHQvS2NvbmZpZyINCiANCiBz b3VyY2UgImRyaXZlcnMvYW5kcm9pZC9LY29uZmlnIg0KIA0KK3NvdXJjZSAiZHJpdmVycy9udmRp bW0vS2NvbmZpZyINCisNCiBlbmRtZW51DQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9NYWtlZmlsZSBi L2RyaXZlcnMvTWFrZWZpbGUNCmluZGV4IDQ2ZDI1NTRiZTQwNC4uNjkyYWRmNjU5MDI4IDEwMDY0 NA0KLS0tIGEvZHJpdmVycy9NYWtlZmlsZQ0KKysrIGIvZHJpdmVycy9NYWtlZmlsZQ0KQEAgLTY0 LDYgKzY0LDcgQEAgb2JqLSQoQ09ORklHX0ZCX0lOVEVMKSAgICAgICAgICArPSB2aWRlby9mYmRl di9pbnRlbGZiLw0KIA0KIG9iai0kKENPTkZJR19QQVJQT1JUKQkJKz0gcGFycG9ydC8NCiBvYmot eQkJCQkrPSBiYXNlLyBibG9jay8gbWlzYy8gbWZkLyBuZmMvDQorb2JqLSQoQ09ORklHX0xJQk5W RElNTSkJCSs9IG52ZGltbS8NCiBvYmotJChDT05GSUdfRE1BX1NIQVJFRF9CVUZGRVIpICs9IGRt YS1idWYvDQogb2JqLSQoQ09ORklHX05VQlVTKQkJKz0gbnVidXMvDQogb2JqLXkJCQkJKz0gbWFj aW50b3NoLw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9LY29uZmlnIGIvZHJpdmVycy9hY3Bp L0tjb25maWcNCmluZGV4IGFiMmNiYjUxYzZhYS4uMzAwYjRlZjM3MTJiIDEwMDY0NA0KLS0tIGEv ZHJpdmVycy9hY3BpL0tjb25maWcNCisrKyBiL2RyaXZlcnMvYWNwaS9LY29uZmlnDQpAQCAtMzgz LDYgKzM4MywyMCBAQCBjb25maWcgQUNQSV9SRURVQ0VEX0hBUkRXQVJFX09OTFkNCiANCiAJICBJ ZiB5b3UgYXJlIHVuc3VyZSB3aGF0IHRvIGRvLCBkbyBub3QgZW5hYmxlIHRoaXMgb3B0aW9uLg0K IA0KK2NvbmZpZyBBQ1BJX05GSVQNCisJdHJpc3RhdGUgIkFDUEkgTlZESU1NIEZpcm13YXJlIElu dGVyZmFjZSBUYWJsZSAoTkZJVCkiDQorCWRlcGVuZHMgb24gUEhZU19BRERSX1RfNjRCSVQNCisJ ZGVwZW5kcyBvbiBCTEtfREVWDQorCXNlbGVjdCBMSUJOVkRJTU0NCisJaGVscA0KKwkgIEluZnJh c3RydWN0dXJlIHRvIHByb2JlIEFDUEkgNiBjb21wbGlhbnQgcGxhdGZvcm1zIGZvcg0KKwkgIE5W RElNTXMgKE5GSVQpIGFuZCByZWdpc3RlciBhIGxpYm52ZGltbSBkZXZpY2UgdHJlZS4gIEluDQor CSAgYWRkaXRpb24gdG8gc3RvcmFnZSBkZXZpY2VzIHRoaXMgYWxzbyBlbmFibGVzIGxpYm52ZGlt bSB0byBwYXNzDQorCSAgQUNQSS5fRFNNIG1lc3NhZ2VzIGZvciBwbGF0Zm9ybS9kaW1tIGNvbmZp Z3VyYXRpb24uDQorDQorCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hv b3NlIE0gaGVyZToNCisJICB0aGUgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIG5maXQuDQorDQogc291 cmNlICJkcml2ZXJzL2FjcGkvYXBlaS9LY29uZmlnIg0KIA0KIGNvbmZpZyBBQ1BJX0VYVExPRw0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9NYWtlZmlsZSBiL2RyaXZlcnMvYWNwaS9NYWtlZmls ZQ0KaW5kZXggOGEwNjNlMjc2NTMwLi5mN2U5YzkyY2NkY2IgMTAwNjQ0DQotLS0gYS9kcml2ZXJz L2FjcGkvTWFrZWZpbGUNCisrKyBiL2RyaXZlcnMvYWNwaS9NYWtlZmlsZQ0KQEAgLTcxLDYgKzcx LDcgQEAgb2JqLSQoQ09ORklHX0FDUElfUENJX1NMT1QpCSs9IHBjaV9zbG90Lm8NCiBvYmotJChD T05GSUdfQUNQSV9QUk9DRVNTT1IpCSs9IHByb2Nlc3Nvci5vDQogb2JqLXkJCQkJKz0gY29udGFp bmVyLm8NCiBvYmotJChDT05GSUdfQUNQSV9USEVSTUFMKQkrPSB0aGVybWFsLm8NCitvYmotJChD T05GSUdfQUNQSV9ORklUKQkJKz0gbmZpdC5vDQogb2JqLXkJCQkJKz0gYWNwaV9tZW1ob3RwbHVn Lm8NCiBvYmotJChDT05GSUdfQUNQSV9IT1RQTFVHX0lPQVBJQykgKz0gaW9hcGljLm8NCiBvYmot JChDT05GSUdfQUNQSV9CQVRURVJZKQkrPSBiYXR0ZXJ5Lm8NCmRpZmYgLS1naXQgYS9kcml2ZXJz L2FjcGkvbmZpdC5jIGIvZHJpdmVycy9hY3BpL25maXQuYw0KbmV3IGZpbGUgbW9kZSAxMDA2NDQN CmluZGV4IDAwMDAwMDAwMDAwMC4uYzQwMGQ2MDAxOGE1DQotLS0gL2Rldi9udWxsDQorKysgYi9k cml2ZXJzL2FjcGkvbmZpdC5jDQpAQCAtMCwwICsxLDQ4MSBAQA0KKy8qDQorICogQ29weXJpZ2h0 KGMpIDIwMTMtMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCisg Kg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IgbW9kaWZ5DQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHZlcnNpb24gMiBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMNCisgKiBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQNCisgKiBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mDQor ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUNCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu DQorICovDQorI2luY2x1ZGUgPGxpbnV4L2xpc3Rfc29ydC5oPg0KKyNpbmNsdWRlIDxsaW51eC9s aWJudmRpbW0uaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4 L2xpc3QuaD4NCisjaW5jbHVkZSA8bGludXgvYWNwaS5oPg0KKyNpbmNsdWRlICJuZml0LmgiDQor DQorc3RhdGljIHU4IG5maXRfdXVpZFtORklUX1VVSURfTUFYXVsxNl07DQorDQorc3RhdGljIGNv bnN0IHU4ICp0b19uZml0X3V1aWQoZW51bSBuZml0X3V1aWRzIGlkKQ0KK3sNCisJcmV0dXJuIG5m aXRfdXVpZFtpZF07DQorfQ0KKw0KK3N0YXRpYyBpbnQgYWNwaV9uZml0X2N0bChzdHJ1Y3QgbnZk aW1tX2J1c19kZXNjcmlwdG9yICpuZF9kZXNjLA0KKwkJc3RydWN0IG52ZGltbSAqbnZkaW1tLCB1 bnNpZ25lZCBpbnQgY21kLCB2b2lkICpidWYsDQorCQl1bnNpZ25lZCBpbnQgYnVmX2xlbikNCit7 DQorCXJldHVybiAtRU5PVFRZOw0KK30NCisNCitzdGF0aWMgY29uc3QgY2hhciAqc3BhX3R5cGVf bmFtZSh1MTYgdHlwZSkNCit7DQorCXN0YXRpYyBjb25zdCBjaGFyICp0b19uYW1lW10gPSB7DQor CQlbTkZJVF9TUEFfVk9MQVRJTEVdID0gInZvbGF0aWxlIiwNCisJCVtORklUX1NQQV9QTV0gPSAi cG1lbSIsDQorCQlbTkZJVF9TUEFfRENSXSA9ICJkaW1tLWNvbnRyb2wtcmVnaW9uIiwNCisJCVtO RklUX1NQQV9CRFddID0gImJsb2NrLWRhdGEtd2luZG93IiwNCisJCVtORklUX1NQQV9WRElTS10g PSAidm9sYXRpbGUtZGlzayIsDQorCQlbTkZJVF9TUEFfVkNEXSA9ICJ2b2xhdGlsZS1jZCIsDQor CQlbTkZJVF9TUEFfUERJU0tdID0gInBlcnNpc3RlbnQtZGlzayIsDQorCQlbTkZJVF9TUEFfUENE XSA9ICJwZXJzaXN0ZW50LWNkIiwNCisNCisJfTsNCisNCisJaWYgKHR5cGUgPiBORklUX1NQQV9Q Q0QpDQorCQlyZXR1cm4gInVua25vd24iOw0KKw0KKwlyZXR1cm4gdG9fbmFtZVt0eXBlXTsNCit9 DQorDQorc3RhdGljIGludCBuZml0X3NwYV90eXBlKHN0cnVjdCBhY3BpX25maXRfc3lzdGVtX2Fk ZHJlc3MgKnNwYSkNCit7DQorCWludCBpOw0KKw0KKwlmb3IgKGkgPSAwOyBpIDwgTkZJVF9VVUlE X01BWDsgaSsrKQ0KKwkJaWYgKG1lbWNtcCh0b19uZml0X3V1aWQoaSksIHNwYS0+cmFuZ2VfZ3Vp ZCwgMTYpID09IDApDQorCQkJcmV0dXJuIGk7DQorCXJldHVybiAtMTsNCit9DQorDQorc3RhdGlj IGJvb2wgYWRkX3NwYShzdHJ1Y3QgYWNwaV9uZml0X2Rlc2MgKmFjcGlfZGVzYywNCisJCXN0cnVj dCBhY3BpX25maXRfc3lzdGVtX2FkZHJlc3MgKnNwYSkNCit7DQorCXN0cnVjdCBkZXZpY2UgKmRl diA9IGFjcGlfZGVzYy0+ZGV2Ow0KKwlzdHJ1Y3QgbmZpdF9zcGEgKm5maXRfc3BhID0gZGV2bV9r emFsbG9jKGRldiwgc2l6ZW9mKCpuZml0X3NwYSksDQorCQkJR0ZQX0tFUk5FTCk7DQorDQorCWlm ICghbmZpdF9zcGEpDQorCQlyZXR1cm4gZmFsc2U7DQorCUlOSVRfTElTVF9IRUFEKCZuZml0X3Nw YS0+bGlzdCk7DQorCW5maXRfc3BhLT5zcGEgPSBzcGE7DQorCWxpc3RfYWRkX3RhaWwoJm5maXRf c3BhLT5saXN0LCAmYWNwaV9kZXNjLT5zcGFzKTsNCisJZGV2X2RiZyhkZXYsICIlczogc3BhIGlu ZGV4OiAlZCB0eXBlOiAlc1xuIiwgX19mdW5jX18sDQorCQkJc3BhLT5yYW5nZV9pbmRleCwNCisJ CQlzcGFfdHlwZV9uYW1lKG5maXRfc3BhX3R5cGUoc3BhKSkpOw0KKwlyZXR1cm4gdHJ1ZTsNCit9 DQorDQorc3RhdGljIGJvb2wgYWRkX21lbWRldihzdHJ1Y3QgYWNwaV9uZml0X2Rlc2MgKmFjcGlf ZGVzYywNCisJCXN0cnVjdCBhY3BpX25maXRfbWVtb3J5X21hcCAqbWVtZGV2KQ0KK3sNCisJc3Ry dWN0IGRldmljZSAqZGV2ID0gYWNwaV9kZXNjLT5kZXY7DQorCXN0cnVjdCBuZml0X21lbWRldiAq bmZpdF9tZW1kZXYgPSBkZXZtX2t6YWxsb2MoZGV2LA0KKwkJCXNpemVvZigqbmZpdF9tZW1kZXYp LCBHRlBfS0VSTkVMKTsNCisNCisJaWYgKCFuZml0X21lbWRldikNCisJCXJldHVybiBmYWxzZTsN CisJSU5JVF9MSVNUX0hFQUQoJm5maXRfbWVtZGV2LT5saXN0KTsNCisJbmZpdF9tZW1kZXYtPm1l bWRldiA9IG1lbWRldjsNCisJbGlzdF9hZGRfdGFpbCgmbmZpdF9tZW1kZXYtPmxpc3QsICZhY3Bp X2Rlc2MtPm1lbWRldnMpOw0KKwlkZXZfZGJnKGRldiwgIiVzOiBtZW1kZXYgaGFuZGxlOiAlI3gg c3BhOiAlZCBkY3I6ICVkXG4iLA0KKwkJCV9fZnVuY19fLCBtZW1kZXYtPmRldmljZV9oYW5kbGUs IG1lbWRldi0+cmFuZ2VfaW5kZXgsDQorCQkJbWVtZGV2LT5yZWdpb25faW5kZXgpOw0KKwlyZXR1 cm4gdHJ1ZTsNCit9DQorDQorc3RhdGljIGJvb2wgYWRkX2RjcihzdHJ1Y3QgYWNwaV9uZml0X2Rl c2MgKmFjcGlfZGVzYywNCisJCXN0cnVjdCBhY3BpX25maXRfY29udHJvbF9yZWdpb24gKmRjcikN Cit7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9IGFjcGlfZGVzYy0+ZGV2Ow0KKwlzdHJ1Y3QgbmZp dF9kY3IgKm5maXRfZGNyID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpuZml0X2RjciksDQor CQkJR0ZQX0tFUk5FTCk7DQorDQorCWlmICghbmZpdF9kY3IpDQorCQlyZXR1cm4gZmFsc2U7DQor CUlOSVRfTElTVF9IRUFEKCZuZml0X2Rjci0+bGlzdCk7DQorCW5maXRfZGNyLT5kY3IgPSBkY3I7 DQorCWxpc3RfYWRkX3RhaWwoJm5maXRfZGNyLT5saXN0LCAmYWNwaV9kZXNjLT5kY3JzKTsNCisJ ZGV2X2RiZyhkZXYsICIlczogZGNyIGluZGV4OiAlZCB3aW5kb3dzOiAlZFxuIiwgX19mdW5jX18s DQorCQkJZGNyLT5yZWdpb25faW5kZXgsIGRjci0+d2luZG93cyk7DQorCXJldHVybiB0cnVlOw0K K30NCisNCitzdGF0aWMgYm9vbCBhZGRfYmR3KHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9k ZXNjLA0KKwkJc3RydWN0IGFjcGlfbmZpdF9kYXRhX3JlZ2lvbiAqYmR3KQ0KK3sNCisJc3RydWN0 IGRldmljZSAqZGV2ID0gYWNwaV9kZXNjLT5kZXY7DQorCXN0cnVjdCBuZml0X2JkdyAqbmZpdF9i ZHcgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKm5maXRfYmR3KSwNCisJCQlHRlBfS0VSTkVM KTsNCisNCisJaWYgKCFuZml0X2JkdykNCisJCXJldHVybiBmYWxzZTsNCisJSU5JVF9MSVNUX0hF QUQoJm5maXRfYmR3LT5saXN0KTsNCisJbmZpdF9iZHctPmJkdyA9IGJkdzsNCisJbGlzdF9hZGRf dGFpbCgmbmZpdF9iZHctPmxpc3QsICZhY3BpX2Rlc2MtPmJkd3MpOw0KKwlkZXZfZGJnKGRldiwg IiVzOiBiZHcgZGNyOiAlZCB3aW5kb3dzOiAlZFxuIiwgX19mdW5jX18sDQorCQkJYmR3LT5yZWdp b25faW5kZXgsIGJkdy0+d2luZG93cyk7DQorCXJldHVybiB0cnVlOw0KK30NCisNCitzdGF0aWMg dm9pZCAqYWRkX3RhYmxlKHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLCB2b2lkICp0 YWJsZSwgY29uc3Qgdm9pZCAqZW5kKQ0KK3sNCisJc3RydWN0IGRldmljZSAqZGV2ID0gYWNwaV9k ZXNjLT5kZXY7DQorCXN0cnVjdCBhY3BpX25maXRfaGVhZGVyICpoZHI7DQorCXZvaWQgKmVyciA9 IEVSUl9QVFIoLUVOT01FTSk7DQorDQorCWlmICh0YWJsZSA+PSBlbmQpDQorCQlyZXR1cm4gTlVM TDsNCisNCisJaGRyID0gdGFibGU7DQorCXN3aXRjaCAoaGRyLT50eXBlKSB7DQorCWNhc2UgQUNQ SV9ORklUX1RZUEVfU1lTVEVNX0FERFJFU1M6DQorCQlpZiAoIWFkZF9zcGEoYWNwaV9kZXNjLCB0 YWJsZSkpDQorCQkJcmV0dXJuIGVycjsNCisJCWJyZWFrOw0KKwljYXNlIEFDUElfTkZJVF9UWVBF X01FTU9SWV9NQVA6DQorCQlpZiAoIWFkZF9tZW1kZXYoYWNwaV9kZXNjLCB0YWJsZSkpDQorCQkJ cmV0dXJuIGVycjsNCisJCWJyZWFrOw0KKwljYXNlIEFDUElfTkZJVF9UWVBFX0NPTlRST0xfUkVH SU9OOg0KKwkJaWYgKCFhZGRfZGNyKGFjcGlfZGVzYywgdGFibGUpKQ0KKwkJCXJldHVybiBlcnI7 DQorCQlicmVhazsNCisJY2FzZSBBQ1BJX05GSVRfVFlQRV9EQVRBX1JFR0lPTjoNCisJCWlmICgh YWRkX2JkdyhhY3BpX2Rlc2MsIHRhYmxlKSkNCisJCQlyZXR1cm4gZXJyOw0KKwkJYnJlYWs7DQor CS8qIFRPRE8gKi8NCisJY2FzZSBBQ1BJX05GSVRfVFlQRV9JTlRFUkxFQVZFOg0KKwkJZGV2X2Ri ZyhkZXYsICIlczogaWR0XG4iLCBfX2Z1bmNfXyk7DQorCQlicmVhazsNCisJY2FzZSBBQ1BJX05G SVRfVFlQRV9GTFVTSF9BRERSRVNTOg0KKwkJZGV2X2RiZyhkZXYsICIlczogZmx1c2hcbiIsIF9f ZnVuY19fKTsNCisJCWJyZWFrOw0KKwljYXNlIEFDUElfTkZJVF9UWVBFX1NNQklPUzoNCisJCWRl dl9kYmcoZGV2LCAiJXM6IHNtYmlvc1xuIiwgX19mdW5jX18pOw0KKwkJYnJlYWs7DQorCWRlZmF1 bHQ6DQorCQlkZXZfZXJyKGRldiwgInVua25vd24gdGFibGUgJyVkJyBwYXJzaW5nIG5maXRcbiIs IGhkci0+dHlwZSk7DQorCQlicmVhazsNCisJfQ0KKw0KKwlyZXR1cm4gdGFibGUgKyBoZHItPmxl bmd0aDsNCit9DQorDQorc3RhdGljIHZvaWQgbmZpdF9tZW1fZmluZF9zcGFfYmR3KHN0cnVjdCBh Y3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLA0KKwkJc3RydWN0IG5maXRfbWVtICpuZml0X21lbSkN Cit7DQorCXUzMiBkZXZpY2VfaGFuZGxlID0gX190b19uZml0X21lbWRldihuZml0X21lbSktPmRl dmljZV9oYW5kbGU7DQorCXUxNiBkY3JfaW5kZXggPSBuZml0X21lbS0+ZGNyLT5yZWdpb25faW5k ZXg7DQorCXN0cnVjdCBuZml0X3NwYSAqbmZpdF9zcGE7DQorDQorCWxpc3RfZm9yX2VhY2hfZW50 cnkobmZpdF9zcGEsICZhY3BpX2Rlc2MtPnNwYXMsIGxpc3QpIHsNCisJCXUxNiByYW5nZV9pbmRl eCA9IG5maXRfc3BhLT5zcGEtPnJhbmdlX2luZGV4Ow0KKwkJaW50IHR5cGUgPSBuZml0X3NwYV90 eXBlKG5maXRfc3BhLT5zcGEpOw0KKwkJc3RydWN0IG5maXRfbWVtZGV2ICpuZml0X21lbWRldjsN CisNCisJCWlmICh0eXBlICE9IE5GSVRfU1BBX0JEVykNCisJCQljb250aW51ZTsNCisNCisJCWxp c3RfZm9yX2VhY2hfZW50cnkobmZpdF9tZW1kZXYsICZhY3BpX2Rlc2MtPm1lbWRldnMsIGxpc3Qp IHsNCisJCQlpZiAobmZpdF9tZW1kZXYtPm1lbWRldi0+cmFuZ2VfaW5kZXggIT0gcmFuZ2VfaW5k ZXgpDQorCQkJCWNvbnRpbnVlOw0KKwkJCWlmIChuZml0X21lbWRldi0+bWVtZGV2LT5kZXZpY2Vf aGFuZGxlICE9IGRldmljZV9oYW5kbGUpDQorCQkJCWNvbnRpbnVlOw0KKwkJCWlmIChuZml0X21l bWRldi0+bWVtZGV2LT5yZWdpb25faW5kZXggIT0gZGNyX2luZGV4KQ0KKwkJCQljb250aW51ZTsN CisNCisJCQluZml0X21lbS0+c3BhX2JkdyA9IG5maXRfc3BhLT5zcGE7DQorCQkJcmV0dXJuOw0K KwkJfQ0KKwl9DQorDQorCWRldl9kYmcoYWNwaV9kZXNjLT5kZXYsICJTUEEtQkRXIG5vdCBmb3Vu ZCBmb3IgU1BBLURDUiAlZFxuIiwNCisJCQluZml0X21lbS0+c3BhX2Rjci0+cmFuZ2VfaW5kZXgp Ow0KKwluZml0X21lbS0+YmR3ID0gTlVMTDsNCit9DQorDQorc3RhdGljIGludCBuZml0X21lbV9h ZGQoc3RydWN0IGFjcGlfbmZpdF9kZXNjICphY3BpX2Rlc2MsDQorCQlzdHJ1Y3QgbmZpdF9tZW0g Km5maXRfbWVtLCBzdHJ1Y3QgYWNwaV9uZml0X3N5c3RlbV9hZGRyZXNzICpzcGEpDQorew0KKwl1 MTYgZGNyX2luZGV4ID0gX190b19uZml0X21lbWRldihuZml0X21lbSktPnJlZ2lvbl9pbmRleDsN CisJc3RydWN0IG5maXRfZGNyICpuZml0X2RjcjsNCisJc3RydWN0IG5maXRfYmR3ICpuZml0X2Jk dzsNCisNCisJbGlzdF9mb3JfZWFjaF9lbnRyeShuZml0X2RjciwgJmFjcGlfZGVzYy0+ZGNycywg bGlzdCkgew0KKwkJaWYgKG5maXRfZGNyLT5kY3ItPnJlZ2lvbl9pbmRleCAhPSBkY3JfaW5kZXgp DQorCQkJY29udGludWU7DQorCQluZml0X21lbS0+ZGNyID0gbmZpdF9kY3ItPmRjcjsNCisJCWJy ZWFrOw0KKwl9DQorDQorCWlmICghbmZpdF9tZW0tPmRjcikgew0KKwkJZGV2X2RiZyhhY3BpX2Rl c2MtPmRldiwgIlNQQSAlZCBtaXNzaW5nOiVzJXNcbiIsIHNwYS0+cmFuZ2VfaW5kZXgsDQorCQkJ CV9fdG9fbmZpdF9tZW1kZXYobmZpdF9tZW0pID8gIiIgOiAiIE1FTURFViIsDQorCQkJCW5maXRf bWVtLT5kY3IgPyAiIiA6ICIgRENSIik7DQorCQlyZXR1cm4gLUVOT0RFVjsNCisJfQ0KKw0KKwkv Kg0KKwkgKiBXZSd2ZSBmb3VuZCBlbm91Z2ggdG8gY3JlYXRlIGFuIG52ZGltbSwgb3B0aW9uYWxs eQ0KKwkgKiBmaW5kIGFuIGFzc29jaWF0ZWQgQkRXDQorCSAqLw0KKwlsaXN0X2FkZCgmbmZpdF9t ZW0tPmxpc3QsICZhY3BpX2Rlc2MtPmRpbW1zKTsNCisNCisJbGlzdF9mb3JfZWFjaF9lbnRyeShu Zml0X2JkdywgJmFjcGlfZGVzYy0+YmR3cywgbGlzdCkgew0KKwkJaWYgKG5maXRfYmR3LT5iZHct PnJlZ2lvbl9pbmRleCAhPSBkY3JfaW5kZXgpDQorCQkJY29udGludWU7DQorCQluZml0X21lbS0+ YmR3ID0gbmZpdF9iZHctPmJkdzsNCisJCWJyZWFrOw0KKwl9DQorDQorCWlmICghbmZpdF9tZW0t PmJkdykNCisJCXJldHVybiAwOw0KKw0KKwluZml0X21lbV9maW5kX3NwYV9iZHcoYWNwaV9kZXNj LCBuZml0X21lbSk7DQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50IG5maXRfbWVtX2Rj cl9pbml0KHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLA0KKwkJc3RydWN0IGFjcGlf bmZpdF9zeXN0ZW1fYWRkcmVzcyAqc3BhKQ0KK3sNCisJc3RydWN0IG5maXRfbWVtICpuZml0X21l bSwgKmZvdW5kOw0KKwlzdHJ1Y3QgbmZpdF9tZW1kZXYgKm5maXRfbWVtZGV2Ow0KKwlpbnQgdHlw ZSA9IG5maXRfc3BhX3R5cGUoc3BhKTsNCisJdTE2IGRjcl9pbmRleDsNCisNCisJc3dpdGNoICh0 eXBlKSB7DQorCWNhc2UgTkZJVF9TUEFfRENSOg0KKwljYXNlIE5GSVRfU1BBX1BNOg0KKwkJYnJl YWs7DQorCWRlZmF1bHQ6DQorCQlyZXR1cm4gMDsNCisJfQ0KKw0KKwlsaXN0X2Zvcl9lYWNoX2Vu dHJ5KG5maXRfbWVtZGV2LCAmYWNwaV9kZXNjLT5tZW1kZXZzLCBsaXN0KSB7DQorCQlpbnQgcmM7 DQorDQorCQlpZiAobmZpdF9tZW1kZXYtPm1lbWRldi0+cmFuZ2VfaW5kZXggIT0gc3BhLT5yYW5n ZV9pbmRleCkNCisJCQljb250aW51ZTsNCisJCWZvdW5kID0gTlVMTDsNCisJCWRjcl9pbmRleCA9 IG5maXRfbWVtZGV2LT5tZW1kZXYtPnJlZ2lvbl9pbmRleDsNCisJCWxpc3RfZm9yX2VhY2hfZW50 cnkobmZpdF9tZW0sICZhY3BpX2Rlc2MtPmRpbW1zLCBsaXN0KQ0KKwkJCWlmIChfX3RvX25maXRf bWVtZGV2KG5maXRfbWVtKS0+cmVnaW9uX2luZGV4ID09IGRjcl9pbmRleCkgew0KKwkJCQlmb3Vu ZCA9IG5maXRfbWVtOw0KKwkJCQlicmVhazsNCisJCQl9DQorDQorCQlpZiAoZm91bmQpDQorCQkJ bmZpdF9tZW0gPSBmb3VuZDsNCisJCWVsc2Ugew0KKwkJCW5maXRfbWVtID0gZGV2bV9remFsbG9j KGFjcGlfZGVzYy0+ZGV2LA0KKwkJCQkJc2l6ZW9mKCpuZml0X21lbSksIEdGUF9LRVJORUwpOw0K KwkJCWlmICghbmZpdF9tZW0pDQorCQkJCXJldHVybiAtRU5PTUVNOw0KKwkJCUlOSVRfTElTVF9I RUFEKCZuZml0X21lbS0+bGlzdCk7DQorCQl9DQorDQorCQlpZiAodHlwZSA9PSBORklUX1NQQV9E Q1IpIHsNCisJCQkvKiBtdWx0aXBsZSBkaW1tcyBtYXkgc2hhcmUgYSBTUEEgd2hlbiBpbnRlcmxl YXZlZCAqLw0KKwkJCW5maXRfbWVtLT5zcGFfZGNyID0gc3BhOw0KKwkJCW5maXRfbWVtLT5tZW1k ZXZfZGNyID0gbmZpdF9tZW1kZXYtPm1lbWRldjsNCisJCX0gZWxzZSB7DQorCQkJLyoNCisJCQkg KiBBIHNpbmdsZSBkaW1tIG1heSBiZWxvbmcgdG8gbXVsdGlwbGUgU1BBLVBNDQorCQkJICogcmFu Z2VzLCByZWNvcmQgYXQgbGVhc3Qgb25lIGluIGFkZGl0aW9uIHRvDQorCQkJICogYW55IFNQQS1E Q1IgcmFuZ2UuDQorCQkJICovDQorCQkJbmZpdF9tZW0tPm1lbWRldl9wbWVtID0gbmZpdF9tZW1k ZXYtPm1lbWRldjsNCisJCX0NCisNCisJCWlmIChmb3VuZCkNCisJCQljb250aW51ZTsNCisNCisJ CXJjID0gbmZpdF9tZW1fYWRkKGFjcGlfZGVzYywgbmZpdF9tZW0sIHNwYSk7DQorCQlpZiAocmMp DQorCQkJcmV0dXJuIHJjOw0KKwl9DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50 IG5maXRfbWVtX2NtcCh2b2lkICpwcml2LCBzdHJ1Y3QgbGlzdF9oZWFkICpfX2EsIHN0cnVjdCBs aXN0X2hlYWQgKl9fYikNCit7DQorCXN0cnVjdCBuZml0X21lbSAqYSA9IGNvbnRhaW5lcl9vZihf X2EsIHR5cGVvZigqYSksIGxpc3QpOw0KKwlzdHJ1Y3QgbmZpdF9tZW0gKmIgPSBjb250YWluZXJf b2YoX19iLCB0eXBlb2YoKmIpLCBsaXN0KTsNCisJdTMyIGhhbmRsZUEsIGhhbmRsZUI7DQorDQor CWhhbmRsZUEgPSBfX3RvX25maXRfbWVtZGV2KGEpLT5kZXZpY2VfaGFuZGxlOw0KKwloYW5kbGVC ID0gX190b19uZml0X21lbWRldihiKS0+ZGV2aWNlX2hhbmRsZTsNCisJaWYgKGhhbmRsZUEgPCBo YW5kbGVCKQ0KKwkJcmV0dXJuIC0xOw0KKwllbHNlIGlmIChoYW5kbGVBID4gaGFuZGxlQikNCisJ CXJldHVybiAxOw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBuZml0X21lbV9pbml0 KHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9kZXNjKQ0KK3sNCisJc3RydWN0IG5maXRfc3Bh ICpuZml0X3NwYTsNCisNCisJLyoNCisJICogRm9yIGVhY2ggU1BBLURDUiBvciBTUEEtUE1FTSBh ZGRyZXNzIHJhbmdlIGZpbmQgaXRzDQorCSAqIGNvcnJlc3BvbmRpbmcgTUVNREVWKHMpLiAgRnJv bSBlYWNoIE1FTURFViBmaW5kIHRoZQ0KKwkgKiBjb3JyZXNwb25kaW5nIERDUi4gIFRoZW4sIGlm IHdlJ3JlIG9wZXJhdGluZyBvbiBhIFNQQS1EQ1IsDQorCSAqIHRyeSB0byBmaW5kIGEgU1BBLUJE VyBhbmQgYSBjb3JyZXNwb25kaW5nIEJEVyB0aGF0IHJlZmVyZW5jZXMNCisJICogdGhlIERDUi4g IFRocm93IGl0IGFsbCBpbnRvIGFuIG5maXRfbWVtIG9iamVjdC4gIE5vdGUsIHRoYXQNCisJICog QkRXcyBhcmUgb3B0aW9uYWwuDQorCSAqLw0KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG5maXRfc3Bh LCAmYWNwaV9kZXNjLT5zcGFzLCBsaXN0KSB7DQorCQlpbnQgcmM7DQorDQorCQlyYyA9IG5maXRf bWVtX2Rjcl9pbml0KGFjcGlfZGVzYywgbmZpdF9zcGEtPnNwYSk7DQorCQlpZiAocmMpDQorCQkJ cmV0dXJuIHJjOw0KKwl9DQorDQorCWxpc3Rfc29ydChOVUxMLCAmYWNwaV9kZXNjLT5kaW1tcywg bmZpdF9tZW1fY21wKTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBpbnQgYWNwaV9u Zml0X2luaXQoc3RydWN0IGFjcGlfbmZpdF9kZXNjICphY3BpX2Rlc2MsIGFjcGlfc2l6ZSBzeikN Cit7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9IGFjcGlfZGVzYy0+ZGV2Ow0KKwljb25zdCB2b2lk ICplbmQ7DQorCXU4ICpkYXRhOw0KKw0KKwlJTklUX0xJU1RfSEVBRCgmYWNwaV9kZXNjLT5zcGFz KTsNCisJSU5JVF9MSVNUX0hFQUQoJmFjcGlfZGVzYy0+ZGNycyk7DQorCUlOSVRfTElTVF9IRUFE KCZhY3BpX2Rlc2MtPmJkd3MpOw0KKwlJTklUX0xJU1RfSEVBRCgmYWNwaV9kZXNjLT5tZW1kZXZz KTsNCisJSU5JVF9MSVNUX0hFQUQoJmFjcGlfZGVzYy0+ZGltbXMpOw0KKw0KKwlkYXRhID0gKHU4 ICopIGFjcGlfZGVzYy0+bmZpdDsNCisJZW5kID0gZGF0YSArIHN6Ow0KKwlkYXRhICs9IHNpemVv ZihzdHJ1Y3QgYWNwaV90YWJsZV9uZml0KTsNCisJd2hpbGUgKCFJU19FUlJfT1JfTlVMTChkYXRh KSkNCisJCWRhdGEgPSBhZGRfdGFibGUoYWNwaV9kZXNjLCBkYXRhLCBlbmQpOw0KKw0KKwlpZiAo SVNfRVJSKGRhdGEpKSB7DQorCQlkZXZfZGJnKGRldiwgIiVzOiBuZml0IHRhYmxlIHBhcnNpbmcg ZXJyb3I6ICVsZFxuIiwgX19mdW5jX18sDQorCQkJCVBUUl9FUlIoZGF0YSkpOw0KKwkJcmV0dXJu IFBUUl9FUlIoZGF0YSk7DQorCX0NCisNCisJaWYgKG5maXRfbWVtX2luaXQoYWNwaV9kZXNjKSAh PSAwKQ0KKwkJcmV0dXJuIC1FTk9NRU07DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMg aW50IGFjcGlfbmZpdF9hZGQoc3RydWN0IGFjcGlfZGV2aWNlICphZGV2KQ0KK3sNCisJc3RydWN0 IG52ZGltbV9idXNfZGVzY3JpcHRvciAqbmRfZGVzYzsNCisJc3RydWN0IGFjcGlfbmZpdF9kZXNj ICphY3BpX2Rlc2M7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZhZGV2LT5kZXY7DQorCXN0cnVj dCBhY3BpX3RhYmxlX2hlYWRlciAqdGJsOw0KKwlhY3BpX3N0YXR1cyBzdGF0dXMgPSBBRV9PSzsN CisJYWNwaV9zaXplIHN6Ow0KKwlpbnQgcmM7DQorDQorCXN0YXR1cyA9IGFjcGlfZ2V0X3RhYmxl X3dpdGhfc2l6ZSgiTkZJVCIsIDAsICZ0YmwsICZzeik7DQorCWlmIChBQ1BJX0ZBSUxVUkUoc3Rh dHVzKSkgew0KKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZmluZCBORklUXG4iKTsNCisJCXJl dHVybiAtRU5YSU87DQorCX0NCisNCisJYWNwaV9kZXNjID0gZGV2bV9remFsbG9jKGRldiwgc2l6 ZW9mKCphY3BpX2Rlc2MpLCBHRlBfS0VSTkVMKTsNCisJaWYgKCFhY3BpX2Rlc2MpDQorCQlyZXR1 cm4gLUVOT01FTTsNCisNCisJZGV2X3NldF9kcnZkYXRhKGRldiwgYWNwaV9kZXNjKTsNCisJYWNw aV9kZXNjLT5kZXYgPSBkZXY7DQorCWFjcGlfZGVzYy0+bmZpdCA9IChzdHJ1Y3QgYWNwaV90YWJs ZV9uZml0ICopIHRibDsNCisJbmRfZGVzYyA9ICZhY3BpX2Rlc2MtPm5kX2Rlc2M7DQorCW5kX2Rl c2MtPnByb3ZpZGVyX25hbWUgPSAiQUNQSS5ORklUIjsNCisJbmRfZGVzYy0+bmRjdGwgPSBhY3Bp X25maXRfY3RsOw0KKw0KKwlhY3BpX2Rlc2MtPm52ZGltbV9idXMgPSBudmRpbW1fYnVzX3JlZ2lz dGVyKGRldiwgbmRfZGVzYyk7DQorCWlmICghYWNwaV9kZXNjLT5udmRpbW1fYnVzKQ0KKwkJcmV0 dXJuIC1FTlhJTzsNCisNCisJcmMgPSBhY3BpX25maXRfaW5pdChhY3BpX2Rlc2MsIHN6KTsNCisJ aWYgKHJjKSB7DQorCQludmRpbW1fYnVzX3VucmVnaXN0ZXIoYWNwaV9kZXNjLT5udmRpbW1fYnVz KTsNCisJCXJldHVybiByYzsNCisJfQ0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBh Y3BpX25maXRfcmVtb3ZlKHN0cnVjdCBhY3BpX2RldmljZSAqYWRldikNCit7DQorCXN0cnVjdCBh Y3BpX25maXRfZGVzYyAqYWNwaV9kZXNjID0gZGV2X2dldF9kcnZkYXRhKCZhZGV2LT5kZXYpOw0K Kw0KKwludmRpbW1fYnVzX3VucmVnaXN0ZXIoYWNwaV9kZXNjLT5udmRpbW1fYnVzKTsNCisJcmV0 dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYWNwaV9kZXZpY2VfaWQgYWNwaV9u Zml0X2lkc1tdID0gew0KKwl7ICJBQ1BJMDAxMiIsIDAgfSwNCisJeyAiIiwgMCB9LA0KK307DQor TU9EVUxFX0RFVklDRV9UQUJMRShhY3BpLCBhY3BpX25maXRfaWRzKTsNCisNCitzdGF0aWMgc3Ry dWN0IGFjcGlfZHJpdmVyIGFjcGlfbmZpdF9kcml2ZXIgPSB7DQorCS5uYW1lID0gS0JVSUxEX01P RE5BTUUsDQorCS5pZHMgPSBhY3BpX25maXRfaWRzLA0KKwkuZmxhZ3MgPSBBQ1BJX0RSSVZFUl9B TExfTk9USUZZX0VWRU5UUywNCisJLm9wcyA9IHsNCisJCS5hZGQgPSBhY3BpX25maXRfYWRkLA0K KwkJLnJlbW92ZSA9IGFjcGlfbmZpdF9yZW1vdmUsDQorCX0sDQorfTsNCisNCitzdGF0aWMgX19p bml0IGludCBuZml0X2luaXQodm9pZCkNCit7DQorCUJVSUxEX0JVR19PTihzaXplb2Yoc3RydWN0 IGFjcGlfdGFibGVfbmZpdCkgIT0gNDApOw0KKwlCVUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCBh Y3BpX25maXRfc3lzdGVtX2FkZHJlc3MpICE9IDU2KTsNCisJQlVJTERfQlVHX09OKHNpemVvZihz dHJ1Y3QgYWNwaV9uZml0X21lbW9yeV9tYXApICE9IDQ4KTsNCisJQlVJTERfQlVHX09OKHNpemVv ZihzdHJ1Y3QgYWNwaV9uZml0X2ludGVybGVhdmUpICE9IDIwKTsNCisJQlVJTERfQlVHX09OKHNp emVvZihzdHJ1Y3QgYWNwaV9uZml0X3NtYmlvcykgIT0gOSk7DQorCUJVSUxEX0JVR19PTihzaXpl b2Yoc3RydWN0IGFjcGlfbmZpdF9jb250cm9sX3JlZ2lvbikgIT0gODApOw0KKwlCVUlMRF9CVUdf T04oc2l6ZW9mKHN0cnVjdCBhY3BpX25maXRfZGF0YV9yZWdpb24pICE9IDQwKTsNCisNCisJYWNw aV9zdHJfdG9fdXVpZChVVUlEX1ZPTEFUSUxFX01FTU9SWSwgbmZpdF91dWlkW05GSVRfU1BBX1ZP TEFUSUxFXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9QRVJTSVNURU5UX01FTU9SWSwgbmZp dF91dWlkW05GSVRfU1BBX1BNXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9DT05UUk9MX1JF R0lPTiwgbmZpdF91dWlkW05GSVRfU1BBX0RDUl0pOw0KKwlhY3BpX3N0cl90b191dWlkKFVVSURf REFUQV9SRUdJT04sIG5maXRfdXVpZFtORklUX1NQQV9CRFddKTsNCisJYWNwaV9zdHJfdG9fdXVp ZChVVUlEX1ZPTEFUSUxFX1ZJUlRVQUxfRElTSywgbmZpdF91dWlkW05GSVRfU1BBX1ZESVNLXSk7 DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9WT0xBVElMRV9WSVJUVUFMX0NELCBuZml0X3V1aWRb TkZJVF9TUEFfVkNEXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9QRVJTSVNURU5UX1ZJUlRV QUxfRElTSywgbmZpdF91dWlkW05GSVRfU1BBX1BESVNLXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQo VVVJRF9QRVJTSVNURU5UX1ZJUlRVQUxfQ0QsIG5maXRfdXVpZFtORklUX1NQQV9QQ0RdKTsNCisJ YWNwaV9zdHJfdG9fdXVpZChVVUlEX05GSVRfQlVTLCBuZml0X3V1aWRbTkZJVF9ERVZfQlVTXSk7 DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9ORklUX0RJTU0sIG5maXRfdXVpZFtORklUX0RFVl9E SU1NXSk7DQorDQorCXJldHVybiBhY3BpX2J1c19yZWdpc3Rlcl9kcml2ZXIoJmFjcGlfbmZpdF9k cml2ZXIpOw0KK30NCisNCitzdGF0aWMgX19leGl0IHZvaWQgbmZpdF9leGl0KHZvaWQpDQorew0K KwlhY3BpX2J1c191bnJlZ2lzdGVyX2RyaXZlcigmYWNwaV9uZml0X2RyaXZlcik7DQorfQ0KKw0K K21vZHVsZV9pbml0KG5maXRfaW5pdCk7DQorbW9kdWxlX2V4aXQobmZpdF9leGl0KTsNCitNT0RV TEVfTElDRU5TRSgiR1BMIHYyIik7DQorTU9EVUxFX0FVVEhPUigiSW50ZWwgQ29ycG9yYXRpb24i KTsNCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvbmZpdC5oIGIvZHJpdmVycy9hY3BpL25maXQu aA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4uMmQ5OGNjMWI3YjZj DQotLS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL2FjcGkvbmZpdC5oDQpAQCAtMCwwICsxLDg5 IEBADQorLyoNCisgKiBOVkRJTU0gRmlybXdhcmUgSW50ZXJmYWNlIFRhYmxlIC0gTkZJVA0KKyAq DQorICogQ29weXJpZ2h0KGMpIDIwMTMtMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQorICogaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMNCisgKiBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0KKyAqIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LCBidXQNCisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mDQorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUNCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuDQorICovDQorI2lmbmRlZiBfX05GSVRfSF9fDQorI2RlZmluZSBfX05G SVRfSF9fDQorI2luY2x1ZGUgPGxpbnV4L2xpYm52ZGltbS5oPg0KKyNpbmNsdWRlIDxsaW51eC90 eXBlcy5oPg0KKyNpbmNsdWRlIDxsaW51eC91dWlkLmg+DQorI2luY2x1ZGUgPGxpbnV4L2FjcGku aD4NCisjaW5jbHVkZSA8YWNwaS9hY3V1aWQuaD4NCisNCisjZGVmaW5lIFVVSURfTkZJVF9CVVMg IjJmMTBlN2E0LTllOTEtMTFlNC04OWQzLTEyM2I5M2Y3NWNiYSINCisjZGVmaW5lIFVVSURfTkZJ VF9ESU1NICI0MzA5YWMzMC0wZDExLTExZTQtOTE5MS0wODAwMjAwYzlhNjYiDQorDQorZW51bSBu Zml0X3V1aWRzIHsNCisJTkZJVF9TUEFfVk9MQVRJTEUsDQorCU5GSVRfU1BBX1BNLA0KKwlORklU X1NQQV9EQ1IsDQorCU5GSVRfU1BBX0JEVywNCisJTkZJVF9TUEFfVkRJU0ssDQorCU5GSVRfU1BB X1ZDRCwNCisJTkZJVF9TUEFfUERJU0ssDQorCU5GSVRfU1BBX1BDRCwNCisJTkZJVF9ERVZfQlVT LA0KKwlORklUX0RFVl9ESU1NLA0KKwlORklUX1VVSURfTUFYLA0KK307DQorDQorc3RydWN0IG5m aXRfc3BhIHsNCisJc3RydWN0IGFjcGlfbmZpdF9zeXN0ZW1fYWRkcmVzcyAqc3BhOw0KKwlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7DQorfTsNCisNCitzdHJ1Y3QgbmZpdF9kY3Igew0KKwlzdHJ1Y3Qg YWNwaV9uZml0X2NvbnRyb2xfcmVnaW9uICpkY3I7DQorCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsN Cit9Ow0KKw0KK3N0cnVjdCBuZml0X2JkdyB7DQorCXN0cnVjdCBhY3BpX25maXRfZGF0YV9yZWdp b24gKmJkdzsNCisJc3RydWN0IGxpc3RfaGVhZCBsaXN0Ow0KK307DQorDQorc3RydWN0IG5maXRf bWVtZGV2IHsNCisJc3RydWN0IGFjcGlfbmZpdF9tZW1vcnlfbWFwICptZW1kZXY7DQorCXN0cnVj dCBsaXN0X2hlYWQgbGlzdDsNCit9Ow0KKw0KKy8qIGFzc2VtYmxlZCB0YWJsZXMgZm9yIGEgZ2l2 ZW4gZGltbS9tZW1vcnktZGV2aWNlICovDQorc3RydWN0IG5maXRfbWVtIHsNCisJc3RydWN0IGFj cGlfbmZpdF9tZW1vcnlfbWFwICptZW1kZXZfZGNyOw0KKwlzdHJ1Y3QgYWNwaV9uZml0X21lbW9y eV9tYXAgKm1lbWRldl9wbWVtOw0KKwlzdHJ1Y3QgYWNwaV9uZml0X2NvbnRyb2xfcmVnaW9uICpk Y3I7DQorCXN0cnVjdCBhY3BpX25maXRfZGF0YV9yZWdpb24gKmJkdzsNCisJc3RydWN0IGFjcGlf bmZpdF9zeXN0ZW1fYWRkcmVzcyAqc3BhX2RjcjsNCisJc3RydWN0IGFjcGlfbmZpdF9zeXN0ZW1f YWRkcmVzcyAqc3BhX2JkdzsNCisJc3RydWN0IGxpc3RfaGVhZCBsaXN0Ow0KK307DQorDQorc3Ry dWN0IGFjcGlfbmZpdF9kZXNjIHsNCisJc3RydWN0IG52ZGltbV9idXNfZGVzY3JpcHRvciBuZF9k ZXNjOw0KKwlzdHJ1Y3QgYWNwaV90YWJsZV9uZml0ICpuZml0Ow0KKwlzdHJ1Y3QgbGlzdF9oZWFk IG1lbWRldnM7DQorCXN0cnVjdCBsaXN0X2hlYWQgZGltbXM7DQorCXN0cnVjdCBsaXN0X2hlYWQg c3BhczsNCisJc3RydWN0IGxpc3RfaGVhZCBkY3JzOw0KKwlzdHJ1Y3QgbGlzdF9oZWFkIGJkd3M7 DQorCXN0cnVjdCBudmRpbW1fYnVzICpudmRpbW1fYnVzOw0KKwlzdHJ1Y3QgZGV2aWNlICpkZXY7 DQorfTsNCisNCitzdGF0aWMgaW5saW5lIHN0cnVjdCBhY3BpX25maXRfbWVtb3J5X21hcCAqX190 b19uZml0X21lbWRldihzdHJ1Y3QgbmZpdF9tZW0gKm5maXRfbWVtKQ0KK3sNCisJaWYgKG5maXRf bWVtLT5tZW1kZXZfZGNyKQ0KKwkJcmV0dXJuIG5maXRfbWVtLT5tZW1kZXZfZGNyOw0KKwlyZXR1 cm4gbmZpdF9tZW0tPm1lbWRldl9wbWVtOw0KK30NCisjZW5kaWYgLyogX19ORklUX0hfXyAqLw0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL0tjb25maWcgYi9kcml2ZXJzL252ZGltbS9LY29u ZmlnDQpuZXcgZmlsZSBtb2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMDAwMDAwLi40ZjIyOTE5Mzhl YTANCi0tLSAvZGV2L251bGwNCisrKyBiL2RyaXZlcnMvbnZkaW1tL0tjb25maWcNCkBAIC0wLDAg KzEsMTMgQEANCitjb25maWcgTElCTlZESU1NDQorCXRyaXN0YXRlICJOVkRJTU0gKE5vbi1Wb2xh dGlsZSBNZW1vcnkgRGV2aWNlKSBTdXBwb3J0Ig0KKwloZWxwDQorCSAgR2VuZXJpYyBzdXBwb3J0 IGZvciBub24tdm9sYXRpbGUgbWVtb3J5IGRldmljZXMgaW5jbHVkaW5nDQorCSAgQUNQSS02LU5G SVQgZGVmaW5lZCByZXNvdXJjZXMuICBPbiBwbGF0Zm9ybXMgdGhhdCBkZWZpbmUgYW4NCisJICBO RklULCBvciBvdGhlcndpc2UgY2FuIGRpc2NvdmVyIE5WRElNTSByZXNvdXJjZXMsIGEgbGlibnZk aW1tDQorCSAgYnVzIGlzIHJlZ2lzdGVyZWQgdG8gYWR2ZXJ0aXNlIFBNRU0gKHBlcnNpc3RlbnQg bWVtb3J5KQ0KKwkgIG5hbWVzcGFjZXMgKC9kZXYvcG1lbVgpIGFuZCBCTEsgKHNsaWRpbmcgbW1p byB3aW5kb3cocykpDQorCSAgbmFtZXNwYWNlcyAoL2Rldi9uZFgpLiBBIFBNRU0gbmFtZXNwYWNl IHJlZmVycyB0byBhIG1lbW9yeQ0KKwkgIHJlc291cmNlIHRoYXQgbWF5IHNwYW4gbXVsdGlwbGUg RElNTXMgYW5kIHN1cHBvcnQgREFYIChzZWUNCisJICBDT05GSUdfREFYKS4gIEEgQkxLIG5hbWVz cGFjZSByZWZlcnMgdG8gYW4gTlZESU1NIGNvbnRyb2wNCisJICByZWdpb24gd2hpY2ggZXhwb3Nl cyBhbiBtbWlvIHJlZ2lzdGVyIHNldCBmb3Igd2luZG93ZWQNCisJICBhY2Nlc3MgbW9kZSB0byBu b24tdm9sYXRpbGUgbWVtb3J5Lg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL01ha2VmaWxl IGIvZHJpdmVycy9udmRpbW0vTWFrZWZpbGUNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAw MDAwMDAwMDAwMDAuLjEwYmM3YWY0Nzk5Mg0KLS0tIC9kZXYvbnVsbA0KKysrIGIvZHJpdmVycy9u dmRpbW0vTWFrZWZpbGUNCkBAIC0wLDAgKzEsMyBAQA0KK29iai0kKENPTkZJR19MSUJOVkRJTU0p ICs9IGxpYm52ZGltbS5vDQorDQorbGlibnZkaW1tLXkgOj0gY29yZS5vDQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9udmRpbW0vY29yZS5jIGIvZHJpdmVycy9udmRpbW0vY29yZS5jDQpuZXcgZmlsZSBt b2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMDAwMDAwLi41Y2NkNTAwZmZkNGYNCi0tLSAvZGV2L251 bGwNCisrKyBiL2RyaXZlcnMvbnZkaW1tL2NvcmUuYw0KQEAgLTAsMCArMSw2NyBAQA0KKy8qDQor ICogQ29weXJpZ2h0KGMpIDIwMTMtMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMNCisgKiBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0KKyAqIFRoaXMgcHJv Z3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBi dXQNCisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mDQorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUNCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuDQorICovDQorI2luY2x1ZGUgPGxpbnV4L2xpYm52ZGltbS5oPg0KKyNpbmNs dWRlIDxsaW51eC9leHBvcnQuaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1 ZGUgPGxpbnV4L2RldmljZS5oPg0KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+DQorI2luY2x1ZGUg Im5kLWNvcmUuaCINCisNCitzdGF0aWMgREVGSU5FX0lEQShuZF9pZGEpOw0KKw0KK3N0YXRpYyB2 b2lkIG52ZGltbV9idXNfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYpDQorew0KKwlzdHJ1Y3Qg bnZkaW1tX2J1cyAqbnZkaW1tX2J1cyA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBudmRpbW1f YnVzLCBkZXYpOw0KKw0KKwlpZGFfc2ltcGxlX3JlbW92ZSgmbmRfaWRhLCBudmRpbW1fYnVzLT5p ZCk7DQorCWtmcmVlKG52ZGltbV9idXMpOw0KK30NCisNCitzdHJ1Y3QgbnZkaW1tX2J1cyAqbnZk aW1tX2J1c19yZWdpc3RlcihzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsDQorCQlzdHJ1Y3QgbnZkaW1t X2J1c19kZXNjcmlwdG9yICpuZF9kZXNjKQ0KK3sNCisJc3RydWN0IG52ZGltbV9idXMgKm52ZGlt bV9idXMgPSBremFsbG9jKHNpemVvZigqbnZkaW1tX2J1cyksIEdGUF9LRVJORUwpOw0KKwlpbnQg cmM7DQorDQorCWlmICghbnZkaW1tX2J1cykNCisJCXJldHVybiBOVUxMOw0KKwludmRpbW1fYnVz LT5pZCA9IGlkYV9zaW1wbGVfZ2V0KCZuZF9pZGEsIDAsIDAsIEdGUF9LRVJORUwpOw0KKwlpZiAo bnZkaW1tX2J1cy0+aWQgPCAwKSB7DQorCQlrZnJlZShudmRpbW1fYnVzKTsNCisJCXJldHVybiBO VUxMOw0KKwl9DQorCW52ZGltbV9idXMtPm5kX2Rlc2MgPSBuZF9kZXNjOw0KKwludmRpbW1fYnVz LT5kZXYucGFyZW50ID0gcGFyZW50Ow0KKwludmRpbW1fYnVzLT5kZXYucmVsZWFzZSA9IG52ZGlt bV9idXNfcmVsZWFzZTsNCisJZGV2X3NldF9uYW1lKCZudmRpbW1fYnVzLT5kZXYsICJuZGJ1cyVk IiwgbnZkaW1tX2J1cy0+aWQpOw0KKwlyYyA9IGRldmljZV9yZWdpc3RlcigmbnZkaW1tX2J1cy0+ ZGV2KTsNCisJaWYgKHJjKSB7DQorCQlkZXZfZGJnKCZudmRpbW1fYnVzLT5kZXYsICJkZXZpY2Ug cmVnaXN0cmF0aW9uIGZhaWxlZDogJWRcbiIsIHJjKTsNCisJCXB1dF9kZXZpY2UoJm52ZGltbV9i dXMtPmRldik7DQorCQlyZXR1cm4gTlVMTDsNCisJfQ0KKw0KKwlyZXR1cm4gbnZkaW1tX2J1czsN Cit9DQorRVhQT1JUX1NZTUJPTF9HUEwobnZkaW1tX2J1c19yZWdpc3Rlcik7DQorDQordm9pZCBu dmRpbW1fYnVzX3VucmVnaXN0ZXIoc3RydWN0IG52ZGltbV9idXMgKm52ZGltbV9idXMpDQorew0K KwlpZiAoIW52ZGltbV9idXMpDQorCQlyZXR1cm47DQorCWRldmljZV91bnJlZ2lzdGVyKCZudmRp bW1fYnVzLT5kZXYpOw0KK30NCitFWFBPUlRfU1lNQk9MX0dQTChudmRpbW1fYnVzX3VucmVnaXN0 ZXIpOw0KKw0KK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsNCitNT0RVTEVfQVVUSE9SKCJJbnRl bCBDb3Jwb3JhdGlvbiIpOw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL25kLWNvcmUuaCBi L2RyaXZlcnMvbnZkaW1tL25kLWNvcmUuaA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAw MDAwMDAwMDAwMC4uZTdjNGU5OWEyMmE0DQotLS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL252 ZGltbS9uZC1jb3JlLmgNCkBAIC0wLDAgKzEsMjMgQEANCisvKg0KKyAqIENvcHlyaWdodChjKSAy MDEzLTIwMTUgSW50ZWwgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoNCisg KiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yIG1vZGlmeQ0KKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB2ZXJzaW9uIDIgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzDQorICogcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24uDQorICoNCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0DQorICogV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZg0KKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VDQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLg0KKyAq Lw0KKyNpZm5kZWYgX19ORF9QUklWQVRFX0hfXw0KKyNkZWZpbmUgX19ORF9QUklWQVRFX0hfXw0K KyNpbmNsdWRlIDxsaW51eC9saWJudmRpbW0uaD4NCisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+ DQorDQorc3RydWN0IG52ZGltbV9idXMgew0KKwlzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9y ICpuZF9kZXNjOw0KKwlzdHJ1Y3QgZGV2aWNlIGRldjsNCisJaW50IGlkOw0KK307DQorI2VuZGlm IC8qIF9fTkRfUFJJVkFURV9IX18gKi8NCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2xpYm52 ZGltbS5oIGIvaW5jbHVkZS9saW51eC9saWJudmRpbW0uaA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQN CmluZGV4IDAwMDAwMDAwMDAwMC4uMmIzYzYzOTUwYzkxDQotLS0gL2Rldi9udWxsDQorKysgYi9p bmNsdWRlL2xpbnV4L2xpYm52ZGltbS5oDQpAQCAtMCwwICsxLDM0IEBADQorLyoNCisgKiBsaWJu dmRpbW0gLSBOb24tdm9sYXRpbGUtbWVtb3J5IERldmljZXMgU3Vic3lzdGVtDQorICoNCisgKiBD b3B5cmlnaHQoYykgMjAxMy0yMDE1IEludGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLg0KKyAqDQorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkNCisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdmVy c2lvbiAyIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcw0KKyAqIHB1Ymxpc2hl ZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLg0KKyAqDQorICogVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dA0K KyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YNCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQ0KKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4NCisgKi8NCisjaWZuZGVmIF9fTElCTlZESU1NX0hfXw0KKyNkZWZpbmUgX19MSUJO VkRJTU1fSF9fDQorc3RydWN0IG52ZGltbTsNCitzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9y Ow0KK3R5cGVkZWYgaW50ICgqbmRjdGxfZm4pKHN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3Ig Km5kX2Rlc2MsDQorCQlzdHJ1Y3QgbnZkaW1tICpudmRpbW0sIHVuc2lnbmVkIGludCBjbWQsIHZv aWQgKmJ1ZiwNCisJCXVuc2lnbmVkIGludCBidWZfbGVuKTsNCisNCitzdHJ1Y3QgbnZkaW1tX2J1 c19kZXNjcmlwdG9yIHsNCisJdW5zaWduZWQgbG9uZyBkc21fbWFzazsNCisJY2hhciAqcHJvdmlk ZXJfbmFtZTsNCisJbmRjdGxfZm4gbmRjdGw7DQorfTsNCisNCitzdHJ1Y3QgZGV2aWNlOw0KK3N0 cnVjdCBudmRpbW1fYnVzOw0KK3N0cnVjdCBudmRpbW1fYnVzICpudmRpbW1fYnVzX3JlZ2lzdGVy KHN0cnVjdCBkZXZpY2UgKnBhcmVudCwNCisJCXN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3Ig Km5maXRfZGVzYyk7DQordm9pZCBudmRpbW1fYnVzX3VucmVnaXN0ZXIoc3RydWN0IG52ZGltbV9i dXMgKm52ZGltbV9idXMpOw0KKyNlbmRpZiAvKiBfX0xJQk5WRElNTV9IX18gKi8NCg0K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: "Williams, Dan J" Subject: Re: [PATCH v5 02/21] libnvdimm, nfit: initial libnvdimm infrastructure and NFIT support Date: Wed, 3 Jun 2015 19:24:34 +0000 Message-ID: <1433359473.21035.27.camel@intel.com> References: <20150602001134.4506.45867.stgit@dwillia2-desk3.amr.corp.intel.com> <20150602001419.4506.41953.stgit@dwillia2-desk3.amr.corp.intel.com> <20150603145704.GA22311@lst.de> In-Reply-To: <20150603145704.GA22311@lst.de> Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: <1330DB59B70A7047AD4818F14B893C18@intel.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 Sender: linux-kernel-owner@vger.kernel.org To: "hch@lst.de" Cc: "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "neilb@suse.de" , "jmoyer@redhat.com" , "linux-api@vger.kernel.org" , "axboe@kernel.dk" , "akpm@linux-foundation.org" , "sfr@canb.auug.org.au" , "linux-nvdimm@lists.01.org" , "gregkh@linuxfoundation.org" , "rafael@kernel.org" , "linux-acpi@vger.kernel.org" List-ID: T24gV2VkLCAyMDE1LTA2LTAzIGF0IDE2OjU3ICswMjAwLCBDaHJpc3RvcGggSGVsbHdpZyB3cm90 ZToNCj4gT24gTW9uLCBKdW4gMDEsIDIwMTUgYXQgMDg6MTQ6MTlQTSAtMDQwMCwgRGFuIFdpbGxp YW1zIHdyb3RlOg0KPiA+IEEgbGlibnZkaW1tIGJ1cyBpcyB0aGUgYW5jaG9yIGRldmljZSBmb3Ig cmVnaXN0ZXJpbmcgbnZkaW1tIHJlc291cmNlcyBhbmQNCj4gPiBpbnRlcmZhY2VzLCBmb3IgZXhh bXBsZSwgYSBjaGFyYWN0ZXIgY29udHJvbCBkZXZpY2UsIG52ZGltbSBkZXZpY2VzLA0KPiA+IGFu ZCBJL08gcmVnaW9uIGRldmljZXMuICBUaGUgQUNQSSBORklUIChOVkRJTU0gRmlybXdhcmUgSW50 ZXJmYWNlIFRhYmxlKQ0KPiA+IGlzIG9uZSBwb3NzaWJsZSBwbGF0Zm9ybSBkZXNjcmlwdGlvbiBm b3Igc3VjaCBub24tdm9sYXRpbGUgbWVtb3J5DQo+ID4gcmVzb3VyY2VzIGluIGEgc3lzdGVtLiAg VGhlIG5maXQua28gZHJpdmVyIGF0dGFjaGVzIHRvIHRoZSAiQUNQSTAwMTIiDQo+ID4gZGV2aWNl IHRoYXQgaW5kaWNhdGVzIHRoZSBwcmVzZW5jZSBvZiB0aGUgTkZJVCBhbmQgcGFyc2VzIHRoZSB0 YWJsZSB0bw0KPiA+IHJlZ2lzdGVyIGEgbGlibnZkaW1tIGJ1cyBpbnN0YW5jZS4NCj4gDQo+IEhh dmluIGxpYiBpbiBhIG5hbWUgb2YgYSBidXMgc2VlbXMgb2RkLiAgV2h5IG5vdCBzaW1wbHkgdGhl IG52ZGltbSBidXM/DQoNClNvcnJ5LCB0aGF0IGlzIGEgdHlwbyB0aGUgYnVzIGlzIGluZGVlZCBh biBzdHJ1Y3QgbnZkaW1tX2J1cyBpbnN0YW5jZS4NCg0KPiBBbHNvIHRoaXMgc2VlbXMgdG8gYm90 aCBoYXZlIHRoZSBnZW5lcmljIG52ZGltbSBpbmZyYXN0cnVjdHVyZSBhcyB3ZWxsDQo+IGFzIHRo ZSBhY3BpIHdpcmluZy4gIE1pZ2h0IG1ha2Ugc2Vuc2UgdG8gc3BsaXQgdGhpcyBpbnRvIHR3byBw YXRjaGVzPw0KDQpJIGxpa2UgdG8gc2hvdyBhbiBpbml0aWFsIGluZnJhc3RydWN0dXJlIGNvbnN1 bWVyIHdpdGggdGhlIGluaXRpYWwNCmltcGxlbWVudGF0aW9uIGluIG9uZSBwYXRjaC4gICBNYWtl cyBpdCBlYXNpZXIgdG8gY2F0Y2ggcHJlbWF0dXJlDQppbXBsZW1lbnRhdGlvbiBvZiBmZWF0dXJl cy4NCg0KPiANCj4gPiArY29uZmlnIEFDUElfTkZJVA0KPiA+ICsJdHJpc3RhdGUgIkFDUEkgTlZE SU1NIEZpcm13YXJlIEludGVyZmFjZSBUYWJsZSAoTkZJVCkiDQo+ID4gKwlkZXBlbmRzIG9uIFBI WVNfQUREUl9UXzY0QklUDQo+ID4gKwlkZXBlbmRzIG9uIEJMS19ERVYNCj4gPiArCXNlbGVjdCBO VkRJTU1fREVWSUNFUw0KPiA+ICsJc2VsZWN0IExJQk5WRElNTQ0KPiANCj4gSXMgdGhpcyB0aGUg cmlnaHQgd2F5IGZvciB0aGUgdXNlciB0byBjaG9zZSBpdD8gIEl0IHNlZW1zIGxpa2UgZW5hYmxp bmcNCj4gdGhlIE5WTURJTU0gc3Vic3lzdGVtIHdvdWxkIGJlIHRoZSBvYnZpb3VzIGNob2ljZSwg YW5kIEFDUEkgd291bGQNCj4gc2ltcGx5IGVuYWJsZSB0aGUgdGFibGUgcGFyc2luZyBpbiB0aGF0 IGNhc2UuDQoNClRoZSBOVkRJTU0gc3ViLXN5c3RlbSBpcyBlbmFibGVkIGJ5IGFuIGV4dGVybmFs IHByb3ZpZGVyLiAgV2UgaGF2ZSB0aGUNCmU4MjAgdHlwZS0xMiBwcm92aWRlciBhbmQgdGhlIE5G SVQgcHJvdmlkZXIgdGhhdCBzZWxlY3QgTElCTlZESU1NLg0KDQo+ID4gK3N0YXRpYyB1OCBuZml0 X3V1aWRbTkZJVF9VVUlEX01BWF1bMTZdOw0KPiANCj4gU2hvdWxkIHRoaXMgdXNlIHRoZSB1dWlk X2xlIHR5cGU/DQo+IA0KDQpUaGF0IHdvdWxkIGRlcGVuZCBvbiBSYWZhZWwgYmVpbmcgb3BlbiB0 byBjaGFuZ2luZyB0aGUNCmFjcGlfc3RyX3RvX3V1aWQoKSBwcm90b3R5cGUgdG8gdGFrZSBhbiB1 dWlkX2xlLg0KDQo+ID4gK3N0YXRpYyBjb25zdCBjaGFyICpzcGFfdHlwZV9uYW1lKHUxNiB0eXBl KQ0KPiA+ICt7DQo+ID4gKwlzd2l0Y2ggKHR5cGUpIHsNCj4gPiArCWNhc2UgTkZJVF9TUEFfVk9M QVRJTEU6IHJldHVybiAidm9sYXRpbGUiOw0KPiA+ICsJY2FzZSBORklUX1NQQV9QTTogcmV0dXJu ICJwbWVtIjsNCj4gPiArCWNhc2UgTkZJVF9TUEFfRENSOiByZXR1cm4gImRpbW0tY29udHJvbC1y ZWdpb24iOw0KPiA+ICsJY2FzZSBORklUX1NQQV9CRFc6IHJldHVybiAiYmxvY2stZGF0YS13aW5k b3ciOw0KPiA+ICsJZGVmYXVsdDogcmV0dXJuICJ1bmtub3duIjsNCj4gDQo+IFBsZWFzZSBuZXZl ciBwdXQgY29kZSBvbiB0aGUgc2FtZSBsaW5lIGFzIGEgc3dpdGNoIChvciBnb3RvKSBsYWJlbC4N Cg0KT2ssIGZpeGVkLg0KDQo+IA0KPiA+ICtzdGF0aWMgdm9pZCAqYWRkX3RhYmxlKHN0cnVjdCBh Y3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLCB2b2lkICp0YWJsZSwgY29uc3Qgdm9pZCAqZW5kKQ0K PiA+ICt7DQo+ID4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBhY3BpX2Rlc2MtPmRldjsNCj4gPiAr CXN0cnVjdCBhY3BpX25maXRfaGVhZGVyICpoZHI7DQo+ID4gKwl2b2lkICplcnIgPSBFUlJfUFRS KC1FTk9NRU0pOw0KPiA+ICsNCj4gPiArCWlmICh0YWJsZSA+PSBlbmQpDQo+ID4gKwkJcmV0dXJu IE5VTEw7DQo+ID4gKw0KPiA+ICsJaGRyID0gKHN0cnVjdCBhY3BpX25maXRfaGVhZGVyICopIHRh YmxlOw0KPiANCj4gTm8gbmVlZCB0byBjYXNlIGZyb20gdm9pZCAqIHRvIGFub3RoZXIgcG9pbnRl ciB0eXBlLg0KDQpXaG9vcHMsIGZpeGVkLg0KDQo+IA0KPiA+ICsJc3dpdGNoIChoZHItPnR5cGUp IHsNCj4gPiArCWNhc2UgQUNQSV9ORklUX1RZUEVfU1lTVEVNX0FERFJFU1M6IHsNCj4gPiArCQlz dHJ1Y3QgbmZpdF9zcGEgKm5maXRfc3BhID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpuZml0 X3NwYSksDQo+ID4gKwkJCQlHRlBfS0VSTkVMKTsNCj4gPiArCQlzdHJ1Y3QgYWNwaV9uZml0X3N5 c3RlbV9hZGRyZXNzICpzcGEgPSB0YWJsZTsNCj4gPiArDQo+ID4gKwkJaWYgKCFuZml0X3NwYSkN Cj4gPiArCQkJcmV0dXJuIGVycjsNCj4gPiArCQlJTklUX0xJU1RfSEVBRCgmbmZpdF9zcGEtPmxp c3QpOw0KPiA+ICsJCW5maXRfc3BhLT5zcGEgPSBzcGE7DQo+ID4gKwkJbGlzdF9hZGRfdGFpbCgm bmZpdF9zcGEtPmxpc3QsICZhY3BpX2Rlc2MtPnNwYXMpOw0KPiA+ICsJCWRldl9kYmcoZGV2LCAi JXM6IHNwYSBpbmRleDogJWQgdHlwZTogJXNcbiIsIF9fZnVuY19fLA0KPiA+ICsJCQkJc3BhLT5y YW5nZV9pbmRleCwNCj4gPiArCQkJCXNwYV90eXBlX25hbWUobmZpdF9zcGFfdHlwZShzcGEpKSk7 DQo+IA0KPiBJZiB5b3UgbmVlZCBsb2NhbCB2YXJpYWJsZXMgaW5zaWRlIGEgc3dpdGNoIHN0YXRl bWVudCB5b3UgcHJvYmFibHkNCj4gd2FudCB0byBzcGxpdCBlYWNoIGNhc2UgaW50byBhIHNlcGFy YXRlIGhlbHBlciBmdW5jdGlvbi4NCg0KWWVhaCwgcHJvYmFibHkgYmV0dGVyIHRoYXQgd2F5LiBE b25lLg0KDQo+IA0KPiA+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBhY3BpX25maXRfbWVtb3J5X21h cCAqX190b19uZml0X21lbWRldihzdHJ1Y3QgbmZpdF9tZW0gKm5maXRfbWVtKQ0KPiANCj4gVGhp cyBsaW5lIGlzIG92ZXIgODAgY2hhcmFjdGVycy4NCg0KSSBnZW5lcmFsbHkgZG9uJ3Qgc2VlIHRo ZSBwb2ludCBvZiBmaXhpbmcgdXAgb2NjYXNpb25hbCBzbWFsbCBpbmN1cnNpb25zDQpvdmVyIDgw IGNoYXJhY3RlcnMgaWYgaXQgbWFrZXMgdGhlIGNvZGUgbW9yZSBhbWVuYWJsZSB0byBncmVwLg0K DQo+IEFsc28gd2h5IHRoZSBvZGQgX18tcHJlZml4Pw0KDQpMYXRlciBvbiB0aGUgc2VyaWVzIHRo ZXJlJ3MgYSB0b19uZml0X21lbWRldigpIHRoYXQgdGFrZXMgYSBzdHJ1Y3QNCmRldmljZSAqLCBh bmQgdGhpcyBvbmUgaXMgYW4gaW50ZXJuYWwgaGVscGVyLg0KDQo+IA0KPiA+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0DQo+ID4gaW5kZXggMDAwMDAwMDAwMDAwLi4yNGI1MWRiYzgyMTUNCj4gPiAtLS0g L2Rldi9udWxsDQo+ID4gKysrIGIvZHJpdmVycy9udmRpbW0vS2NvbmZpZw0KPiA+IEBAIC0wLDAg KzEsMjAgQEANCj4gPiArbWVudWNvbmZpZyBOVkRJTU1fREVWSUNFUw0KPiA+ICsJYm9vbCAiTlZE SU1NIChOb24tVm9sYXRpbGUgTWVtb3J5IERldmljZSkgU3VwcG9ydCINCj4gPiArCWhlbHANCj4g PiArCSAgR2VuZXJpYyBzdXBwb3J0IGZvciBub24tdm9sYXRpbGUgbWVtb3J5IGRldmljZXMgaW5j bHVkaW5nDQo+ID4gKwkgIEFDUEktNi1ORklUIGRlZmluZWQgcmVzb3VyY2VzLiAgT24gcGxhdGZv cm1zIHRoYXQgZGVmaW5lIGFuDQo+ID4gKwkgIE5GSVQsIG9yIG90aGVyd2lzZSBjYW4gZGlzY292 ZXIgTlZESU1NIHJlc291cmNlcywgYSBsaWJudmRpbW0NCj4gPiArCSAgYnVzIGlzIHJlZ2lzdGVy ZWQgdG8gYWR2ZXJ0aXNlIFBNRU0gKHBlcnNpc3RlbnQgbWVtb3J5KQ0KPiA+ICsJICBuYW1lc3Bh Y2VzICgvZGV2L3BtZW1YKSBhbmQgQkxLIChzbGlkaW5nIG1taW8gd2luZG93KHMpKQ0KPiA+ICsJ ICBuYW1lc3BhY2VzICgvZGV2L25kWCkuIEEgUE1FTSBuYW1lc3BhY2UgcmVmZXJzIHRvIGEgbWVt b3J5DQo+ID4gKwkgIHJlc291cmNlIHRoYXQgbWF5IHNwYW4gbXVsdGlwbGUgRElNTXMgYW5kIHN1 cHBvcnQgREFYIChzZWUNCj4gPiArCSAgQ09ORklHX0RBWCkuICBBIEJMSyBuYW1lc3BhY2UgcmVm ZXJzIHRvIGFuIE5WRElNTSBjb250cm9sDQo+ID4gKwkgIHJlZ2lvbiB3aGljaCBleHBvc2VzIGFu IG1taW8gcmVnaXN0ZXIgc2V0IGZvciB3aW5kb3dlZA0KPiA+ICsJICBhY2Nlc3MgbW9kZSB0byBu b24tdm9sYXRpbGUgbWVtb3J5Lg0KPiA+ICsNCj4gPiAraWYgTlZESU1NX0RFVklDRVMNCj4gPiAr DQo+ID4gK2NvbmZpZyBMSUJOVkRJTU0NCj4gPiArCXRyaXN0YXRlDQo+ID4gKw0KPiA+ICtlbmRp Zg0KPiANCj4gV2hhdCBkaWZmZXJlbnQgbWVhbmluZ3Mgd2lsbCBDT05GSUdfTlZESU1NX0RFVklD RVMgYW5kIENPTkZJR19MSUJOVkRJTU0NCj4gaGF2ZT8NCg0KSG1tLCBub3RoaW5nIHdvcnRod2hp bGUuICBJJ2xsIG1lcmdlIHRoZW0gaW50byBvbmUgbWVudWNvbmZpZw0KQ09ORklHX0xJQk5WRElN TSB0cmlzdGF0ZS4NCg0KPiANCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9udmRpbW0vbmQtcHJp dmF0ZS5oIGIvZHJpdmVycy9udmRpbW0vbmQtcHJpdmF0ZS5oDQo+ID4gbmV3IGZpbGUgbW9kZSAx MDA2NDQNCj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLmU3YzRlOTlhMjJhNA0KPiA+IC0tLSAvZGV2 L251bGwNCj4gPiArKysgYi9kcml2ZXJzL252ZGltbS9uZC1wcml2YXRlLmgNCj4gDQo+IE5vIG5l ZWQgZm9yIC1wcml2YXRlIGlmIHlvdSdyZSBhbHJlYWR5IHVuZGVyIGRyaXZlcnMvbnZkaW1tLi4N Cg0KVGhpcyBpcyB0aGUgcHJpdmF0ZSBwcml2YXRlLWhlYWRlciBpbiB0aGUgc2Vuc2UgdGhhdCBp dCBkZWZpbmVzDQppbmZyYXN0cnVjdHVyZSB0aGF0IGlzIG9ubHkgbWVhbnQgZm9yIHRoZSBjb3Jl LiAgRHJpdmVycyAoYnR0LCBwbWVtLA0KYmxrLCBldGMpIG11c3Qgbm90IGluY2x1ZGUgbmQtcHJp dmF0ZS5oLiAgSSdsbCByZW5hbWUgaXQgIm5kLWNvcmUuaCIgdG8NCm1ha2UgdGhpcyBtb3JlIGNs ZWFyLg0KDQo+ID4gKyNpZm5kZWYgX19ORF9QUklWQVRFX0hfXw0KPiA+ICsjZGVmaW5lIF9fTkRf UFJJVkFURV9IX18NCj4gPiArI2luY2x1ZGUgPGxpbnV4L2xpYm52ZGltbS5oPg0KPiA+ICsjaW5j bHVkZSA8bGludXgvZGV2aWNlLmg+DQo+ID4gKw0KPiA+ICtzdHJ1Y3QgbnZkaW1tX2J1cyB7DQo+ ID4gKwlzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9yICpuZF9kZXNjOw0KPiA+ICsJc3RydWN0 IGRldmljZSBkZXY7DQo+ID4gKwlpbnQgaWQ7DQo+ID4gK307DQo+ID4gKyNlbmRpZiAvKiBfX05E X1BSSVZBVEVfSF9fICovDQo+IA0KPiBBdCBsZWFzdCBzbyBmYXIgdGhpcyBoZWFkZXIgZG9lc24n dCBuZWVkIGxpYm52ZGltbS5oDQoNCnN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3IgaXMgZGVm aW5lZCB0aGVyZSBhbmQgYSBmb3J3YXJkIGRlY2xhcmF0aW9uDQpkb2VzIG5vdCBtYWtlIHNlbnNl IHNpbmNlIHdlJ2xsIG5lZWQgdGhlIHJlc3Qgb2YgdGhlIGhlYWRlciBsYXRlciBpbiB0aGUNCnNl cmllcy4NCg0KPiANCj4gPiArI2lmbmRlZiBfX0xJQk5WRElNTV9IX18NCj4gPiArI2RlZmluZSBf X0xJQk5WRElNTV9IX18NCj4gPiArc3RydWN0IG52ZGltbTsNCj4gPiArc3RydWN0IG52ZGltbV9i dXNfZGVzY3JpcHRvcjsNCj4gPiArdHlwZWRlZiBpbnQgKCpuZGN0bF9mbikoc3RydWN0IG52ZGlt bV9idXNfZGVzY3JpcHRvciAqbmRfZGVzYywNCj4gPiArCQlzdHJ1Y3QgbnZkaW1tICpudmRpbW0s IHVuc2lnbmVkIGludCBjbWQsIHZvaWQgKmJ1ZiwNCj4gPiArCQl1bnNpZ25lZCBpbnQgYnVmX2xl bik7DQo+ID4gKw0KPiA+ICtzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9yIHsNCj4gPiArCXVu c2lnbmVkIGxvbmcgZHNtX21hc2s7DQo+ID4gKwljaGFyICpwcm92aWRlcl9uYW1lOw0KPiA+ICsJ bmRjdGxfZm4gbmRjdGw7DQo+ID4gK307DQo+IA0KPiBQbGVhc2UgcHJvdmlkZSBwcm9wZXIgbWV0 aG9kcyB0aGF0IGRvIG9uZSB0aGluZyBwcm9wZXJseSBpbnN0ZWFkIG9mDQo+IGlvY3RsLWxpa2Ug bXVsdGlwbGV4ZXJzLg0KDQpUaGlzICppcyogdGhlIGlvY3RsIG11bHRpcGxleGVyLiAgVGhlIGdl bmVyaWMgaW9jdGwgaW1wbGVtZW50YXRpb24gaW4NCmxpYm52ZGltbSB1c2VzIHRoZSBuZGN0bF9m biB0byBjYWxsIGJhY2sgb3V0IHRvIHRoZSBwcm92aWRlciB0byBwcm9jZXNzDQp0aGUgY29tbWFu ZC4gIEluIHRoZSBjYXNlIG9mIEFDUEkgdGhpcyBtYXBzIHRvIGEgX0RTTSAoZGV2aWNlIHNwZWNp ZmljDQptZXRob2QpLCBmb3IgbmZpdF90ZXN0IGl0J3MgYSBlbXVsYXRlZCBpbXBsZW1lbnRhdGlv biwgYW5kIGZvcg0KZTgyMC10eXBlLTEyIHRoaXMgaXMgb2J2aW91c2x5IG5vdCBpbXBsZW1lbnRl ZC4NCg0KDQpSZWZsb3dlZCBwYXRjaCB3aXRoIHRoZXNlIGZpeGVzIGZvbGxvd3MuLi4NCg0KDQo4 PC0tLS0tDQpTdWJqZWN0OiBsaWJudmRpbW0sIG5maXQ6IGluaXRpYWwgbGlibnZkaW1tIGluZnJh c3RydWN0dXJlIGFuZCBORklUIHN1cHBvcnQNCg0KRnJvbTogRGFuIFdpbGxpYW1zIDxkYW4uai53 aWxsaWFtc0BpbnRlbC5jb20+DQoNCkEgbGlibnZkaW1tIGJ1cyBpcyB0aGUgYW5jaG9yIGRldmlj ZSBmb3IgcmVnaXN0ZXJpbmcgbnZkaW1tIHJlc291cmNlcyBhbmQNCmludGVyZmFjZXMsIGZvciBl eGFtcGxlLCBhIGNoYXJhY3RlciBjb250cm9sIGRldmljZSwgbnZkaW1tIGRldmljZXMsDQphbmQg SS9PIHJlZ2lvbiBkZXZpY2VzLiAgVGhlIEFDUEkgTkZJVCAoTlZESU1NIEZpcm13YXJlIEludGVy ZmFjZSBUYWJsZSkNCmlzIG9uZSBwb3NzaWJsZSBwbGF0Zm9ybSBkZXNjcmlwdGlvbiBmb3Igc3Vj aCBub24tdm9sYXRpbGUgbWVtb3J5DQpyZXNvdXJjZXMgaW4gYSBzeXN0ZW0uICBUaGUgbmZpdC5r byBkcml2ZXIgYXR0YWNoZXMgdG8gdGhlICJBQ1BJMDAxMiINCmRldmljZSB0aGF0IGluZGljYXRl cyB0aGUgcHJlc2VuY2Ugb2YgdGhlIE5GSVQgYW5kIHBhcnNlcyB0aGUgdGFibGUgdG8NCnJlZ2lz dGVyIGEgc3RydWN0IG52ZGltbV9idXMgaW5zdGFuY2UuDQoNCkNjOiA8bGludXgtYWNwaUB2Z2Vy Lmtlcm5lbC5vcmc+DQpDYzogTHYgWmhlbmcgPGx2LnpoZW5nQGludGVsLmNvbT4NCkNjOiBSb2Jl cnQgTW9vcmUgPHJvYmVydC5tb29yZUBpbnRlbC5jb20+DQpDYzogUmFmYWVsIEouIFd5c29ja2kg PHJhZmFlbC5qLnd5c29ja2lAaW50ZWwuY29tPg0KQWNrZWQtYnk6IEplZmYgTW95ZXIgPGptb3ll ckByZWRoYXQuY29tPg0KU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFt c0BpbnRlbC5jb20+DQotLS0NCiBkcml2ZXJzL0tjb25maWcgICAgICAgICAgIHwgICAgMiANCiBk cml2ZXJzL01ha2VmaWxlICAgICAgICAgIHwgICAgMSANCiBkcml2ZXJzL2FjcGkvS2NvbmZpZyAg ICAgIHwgICAxNCArDQogZHJpdmVycy9hY3BpL01ha2VmaWxlICAgICB8ICAgIDEgDQogZHJpdmVy cy9hY3BpL25maXQuYyAgICAgICB8ICA0ODEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrDQogZHJpdmVycy9hY3BpL25maXQuaCAgICAgICB8ICAgODkgKysrKysr KysNCiBkcml2ZXJzL252ZGltbS9LY29uZmlnICAgIHwgICAxMyArDQogZHJpdmVycy9udmRpbW0v TWFrZWZpbGUgICB8ICAgIDMgDQogZHJpdmVycy9udmRpbW0vY29yZS5jICAgICB8ICAgNjcgKysr KysrDQogZHJpdmVycy9udmRpbW0vbmQtY29yZS5oICB8ICAgMjMgKysNCiBpbmNsdWRlL2xpbnV4 L2xpYm52ZGltbS5oIHwgICAzNCArKysNCiAxMSBmaWxlcyBjaGFuZ2VkLCA3MjggaW5zZXJ0aW9u cygrKQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2FjcGkvbmZpdC5jDQogY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvYWNwaS9uZml0LmgNCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9udmRpbW0vS2NvbmZpZw0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL252ZGltbS9NYWtl ZmlsZQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL252ZGltbS9jb3JlLmMNCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9udmRpbW0vbmQtY29yZS5oDQogY3JlYXRlIG1vZGUgMTAwNjQ0 IGluY2x1ZGUvbGludXgvbGlibnZkaW1tLmgNCg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvS2NvbmZp ZyBiL2RyaXZlcnMvS2NvbmZpZw0KaW5kZXggYzBjYzk2YmFiOWU3Li42ZTk3M2I4ZTNhM2IgMTAw NjQ0DQotLS0gYS9kcml2ZXJzL0tjb25maWcNCisrKyBiL2RyaXZlcnMvS2NvbmZpZw0KQEAgLTE4 Miw0ICsxODIsNiBAQCBzb3VyY2UgImRyaXZlcnMvdGh1bmRlcmJvbHQvS2NvbmZpZyINCiANCiBz b3VyY2UgImRyaXZlcnMvYW5kcm9pZC9LY29uZmlnIg0KIA0KK3NvdXJjZSAiZHJpdmVycy9udmRp bW0vS2NvbmZpZyINCisNCiBlbmRtZW51DQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9NYWtlZmlsZSBi L2RyaXZlcnMvTWFrZWZpbGUNCmluZGV4IDQ2ZDI1NTRiZTQwNC4uNjkyYWRmNjU5MDI4IDEwMDY0 NA0KLS0tIGEvZHJpdmVycy9NYWtlZmlsZQ0KKysrIGIvZHJpdmVycy9NYWtlZmlsZQ0KQEAgLTY0 LDYgKzY0LDcgQEAgb2JqLSQoQ09ORklHX0ZCX0lOVEVMKSAgICAgICAgICArPSB2aWRlby9mYmRl di9pbnRlbGZiLw0KIA0KIG9iai0kKENPTkZJR19QQVJQT1JUKQkJKz0gcGFycG9ydC8NCiBvYmot eQkJCQkrPSBiYXNlLyBibG9jay8gbWlzYy8gbWZkLyBuZmMvDQorb2JqLSQoQ09ORklHX0xJQk5W RElNTSkJCSs9IG52ZGltbS8NCiBvYmotJChDT05GSUdfRE1BX1NIQVJFRF9CVUZGRVIpICs9IGRt YS1idWYvDQogb2JqLSQoQ09ORklHX05VQlVTKQkJKz0gbnVidXMvDQogb2JqLXkJCQkJKz0gbWFj aW50b3NoLw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9LY29uZmlnIGIvZHJpdmVycy9hY3Bp L0tjb25maWcNCmluZGV4IGFiMmNiYjUxYzZhYS4uMzAwYjRlZjM3MTJiIDEwMDY0NA0KLS0tIGEv ZHJpdmVycy9hY3BpL0tjb25maWcNCisrKyBiL2RyaXZlcnMvYWNwaS9LY29uZmlnDQpAQCAtMzgz LDYgKzM4MywyMCBAQCBjb25maWcgQUNQSV9SRURVQ0VEX0hBUkRXQVJFX09OTFkNCiANCiAJICBJ ZiB5b3UgYXJlIHVuc3VyZSB3aGF0IHRvIGRvLCBkbyBub3QgZW5hYmxlIHRoaXMgb3B0aW9uLg0K IA0KK2NvbmZpZyBBQ1BJX05GSVQNCisJdHJpc3RhdGUgIkFDUEkgTlZESU1NIEZpcm13YXJlIElu dGVyZmFjZSBUYWJsZSAoTkZJVCkiDQorCWRlcGVuZHMgb24gUEhZU19BRERSX1RfNjRCSVQNCisJ ZGVwZW5kcyBvbiBCTEtfREVWDQorCXNlbGVjdCBMSUJOVkRJTU0NCisJaGVscA0KKwkgIEluZnJh c3RydWN0dXJlIHRvIHByb2JlIEFDUEkgNiBjb21wbGlhbnQgcGxhdGZvcm1zIGZvcg0KKwkgIE5W RElNTXMgKE5GSVQpIGFuZCByZWdpc3RlciBhIGxpYm52ZGltbSBkZXZpY2UgdHJlZS4gIEluDQor CSAgYWRkaXRpb24gdG8gc3RvcmFnZSBkZXZpY2VzIHRoaXMgYWxzbyBlbmFibGVzIGxpYm52ZGlt bSB0byBwYXNzDQorCSAgQUNQSS5fRFNNIG1lc3NhZ2VzIGZvciBwbGF0Zm9ybS9kaW1tIGNvbmZp Z3VyYXRpb24uDQorDQorCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hv b3NlIE0gaGVyZToNCisJICB0aGUgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIG5maXQuDQorDQogc291 cmNlICJkcml2ZXJzL2FjcGkvYXBlaS9LY29uZmlnIg0KIA0KIGNvbmZpZyBBQ1BJX0VYVExPRw0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9NYWtlZmlsZSBiL2RyaXZlcnMvYWNwaS9NYWtlZmls ZQ0KaW5kZXggOGEwNjNlMjc2NTMwLi5mN2U5YzkyY2NkY2IgMTAwNjQ0DQotLS0gYS9kcml2ZXJz L2FjcGkvTWFrZWZpbGUNCisrKyBiL2RyaXZlcnMvYWNwaS9NYWtlZmlsZQ0KQEAgLTcxLDYgKzcx LDcgQEAgb2JqLSQoQ09ORklHX0FDUElfUENJX1NMT1QpCSs9IHBjaV9zbG90Lm8NCiBvYmotJChD T05GSUdfQUNQSV9QUk9DRVNTT1IpCSs9IHByb2Nlc3Nvci5vDQogb2JqLXkJCQkJKz0gY29udGFp bmVyLm8NCiBvYmotJChDT05GSUdfQUNQSV9USEVSTUFMKQkrPSB0aGVybWFsLm8NCitvYmotJChD T05GSUdfQUNQSV9ORklUKQkJKz0gbmZpdC5vDQogb2JqLXkJCQkJKz0gYWNwaV9tZW1ob3RwbHVn Lm8NCiBvYmotJChDT05GSUdfQUNQSV9IT1RQTFVHX0lPQVBJQykgKz0gaW9hcGljLm8NCiBvYmot JChDT05GSUdfQUNQSV9CQVRURVJZKQkrPSBiYXR0ZXJ5Lm8NCmRpZmYgLS1naXQgYS9kcml2ZXJz L2FjcGkvbmZpdC5jIGIvZHJpdmVycy9hY3BpL25maXQuYw0KbmV3IGZpbGUgbW9kZSAxMDA2NDQN CmluZGV4IDAwMDAwMDAwMDAwMC4uYzQwMGQ2MDAxOGE1DQotLS0gL2Rldi9udWxsDQorKysgYi9k cml2ZXJzL2FjcGkvbmZpdC5jDQpAQCAtMCwwICsxLDQ4MSBAQA0KKy8qDQorICogQ29weXJpZ2h0 KGMpIDIwMTMtMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCisg Kg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IgbW9kaWZ5DQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHZlcnNpb24gMiBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMNCisgKiBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQNCisgKiBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mDQor ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUNCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu DQorICovDQorI2luY2x1ZGUgPGxpbnV4L2xpc3Rfc29ydC5oPg0KKyNpbmNsdWRlIDxsaW51eC9s aWJudmRpbW0uaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4 L2xpc3QuaD4NCisjaW5jbHVkZSA8bGludXgvYWNwaS5oPg0KKyNpbmNsdWRlICJuZml0LmgiDQor DQorc3RhdGljIHU4IG5maXRfdXVpZFtORklUX1VVSURfTUFYXVsxNl07DQorDQorc3RhdGljIGNv bnN0IHU4ICp0b19uZml0X3V1aWQoZW51bSBuZml0X3V1aWRzIGlkKQ0KK3sNCisJcmV0dXJuIG5m aXRfdXVpZFtpZF07DQorfQ0KKw0KK3N0YXRpYyBpbnQgYWNwaV9uZml0X2N0bChzdHJ1Y3QgbnZk aW1tX2J1c19kZXNjcmlwdG9yICpuZF9kZXNjLA0KKwkJc3RydWN0IG52ZGltbSAqbnZkaW1tLCB1 bnNpZ25lZCBpbnQgY21kLCB2b2lkICpidWYsDQorCQl1bnNpZ25lZCBpbnQgYnVmX2xlbikNCit7 DQorCXJldHVybiAtRU5PVFRZOw0KK30NCisNCitzdGF0aWMgY29uc3QgY2hhciAqc3BhX3R5cGVf bmFtZSh1MTYgdHlwZSkNCit7DQorCXN0YXRpYyBjb25zdCBjaGFyICp0b19uYW1lW10gPSB7DQor CQlbTkZJVF9TUEFfVk9MQVRJTEVdID0gInZvbGF0aWxlIiwNCisJCVtORklUX1NQQV9QTV0gPSAi cG1lbSIsDQorCQlbTkZJVF9TUEFfRENSXSA9ICJkaW1tLWNvbnRyb2wtcmVnaW9uIiwNCisJCVtO RklUX1NQQV9CRFddID0gImJsb2NrLWRhdGEtd2luZG93IiwNCisJCVtORklUX1NQQV9WRElTS10g PSAidm9sYXRpbGUtZGlzayIsDQorCQlbTkZJVF9TUEFfVkNEXSA9ICJ2b2xhdGlsZS1jZCIsDQor CQlbTkZJVF9TUEFfUERJU0tdID0gInBlcnNpc3RlbnQtZGlzayIsDQorCQlbTkZJVF9TUEFfUENE XSA9ICJwZXJzaXN0ZW50LWNkIiwNCisNCisJfTsNCisNCisJaWYgKHR5cGUgPiBORklUX1NQQV9Q Q0QpDQorCQlyZXR1cm4gInVua25vd24iOw0KKw0KKwlyZXR1cm4gdG9fbmFtZVt0eXBlXTsNCit9 DQorDQorc3RhdGljIGludCBuZml0X3NwYV90eXBlKHN0cnVjdCBhY3BpX25maXRfc3lzdGVtX2Fk ZHJlc3MgKnNwYSkNCit7DQorCWludCBpOw0KKw0KKwlmb3IgKGkgPSAwOyBpIDwgTkZJVF9VVUlE X01BWDsgaSsrKQ0KKwkJaWYgKG1lbWNtcCh0b19uZml0X3V1aWQoaSksIHNwYS0+cmFuZ2VfZ3Vp ZCwgMTYpID09IDApDQorCQkJcmV0dXJuIGk7DQorCXJldHVybiAtMTsNCit9DQorDQorc3RhdGlj IGJvb2wgYWRkX3NwYShzdHJ1Y3QgYWNwaV9uZml0X2Rlc2MgKmFjcGlfZGVzYywNCisJCXN0cnVj dCBhY3BpX25maXRfc3lzdGVtX2FkZHJlc3MgKnNwYSkNCit7DQorCXN0cnVjdCBkZXZpY2UgKmRl diA9IGFjcGlfZGVzYy0+ZGV2Ow0KKwlzdHJ1Y3QgbmZpdF9zcGEgKm5maXRfc3BhID0gZGV2bV9r emFsbG9jKGRldiwgc2l6ZW9mKCpuZml0X3NwYSksDQorCQkJR0ZQX0tFUk5FTCk7DQorDQorCWlm ICghbmZpdF9zcGEpDQorCQlyZXR1cm4gZmFsc2U7DQorCUlOSVRfTElTVF9IRUFEKCZuZml0X3Nw YS0+bGlzdCk7DQorCW5maXRfc3BhLT5zcGEgPSBzcGE7DQorCWxpc3RfYWRkX3RhaWwoJm5maXRf c3BhLT5saXN0LCAmYWNwaV9kZXNjLT5zcGFzKTsNCisJZGV2X2RiZyhkZXYsICIlczogc3BhIGlu ZGV4OiAlZCB0eXBlOiAlc1xuIiwgX19mdW5jX18sDQorCQkJc3BhLT5yYW5nZV9pbmRleCwNCisJ CQlzcGFfdHlwZV9uYW1lKG5maXRfc3BhX3R5cGUoc3BhKSkpOw0KKwlyZXR1cm4gdHJ1ZTsNCit9 DQorDQorc3RhdGljIGJvb2wgYWRkX21lbWRldihzdHJ1Y3QgYWNwaV9uZml0X2Rlc2MgKmFjcGlf ZGVzYywNCisJCXN0cnVjdCBhY3BpX25maXRfbWVtb3J5X21hcCAqbWVtZGV2KQ0KK3sNCisJc3Ry dWN0IGRldmljZSAqZGV2ID0gYWNwaV9kZXNjLT5kZXY7DQorCXN0cnVjdCBuZml0X21lbWRldiAq bmZpdF9tZW1kZXYgPSBkZXZtX2t6YWxsb2MoZGV2LA0KKwkJCXNpemVvZigqbmZpdF9tZW1kZXYp LCBHRlBfS0VSTkVMKTsNCisNCisJaWYgKCFuZml0X21lbWRldikNCisJCXJldHVybiBmYWxzZTsN CisJSU5JVF9MSVNUX0hFQUQoJm5maXRfbWVtZGV2LT5saXN0KTsNCisJbmZpdF9tZW1kZXYtPm1l bWRldiA9IG1lbWRldjsNCisJbGlzdF9hZGRfdGFpbCgmbmZpdF9tZW1kZXYtPmxpc3QsICZhY3Bp X2Rlc2MtPm1lbWRldnMpOw0KKwlkZXZfZGJnKGRldiwgIiVzOiBtZW1kZXYgaGFuZGxlOiAlI3gg c3BhOiAlZCBkY3I6ICVkXG4iLA0KKwkJCV9fZnVuY19fLCBtZW1kZXYtPmRldmljZV9oYW5kbGUs IG1lbWRldi0+cmFuZ2VfaW5kZXgsDQorCQkJbWVtZGV2LT5yZWdpb25faW5kZXgpOw0KKwlyZXR1 cm4gdHJ1ZTsNCit9DQorDQorc3RhdGljIGJvb2wgYWRkX2RjcihzdHJ1Y3QgYWNwaV9uZml0X2Rl c2MgKmFjcGlfZGVzYywNCisJCXN0cnVjdCBhY3BpX25maXRfY29udHJvbF9yZWdpb24gKmRjcikN Cit7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9IGFjcGlfZGVzYy0+ZGV2Ow0KKwlzdHJ1Y3QgbmZp dF9kY3IgKm5maXRfZGNyID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpuZml0X2RjciksDQor CQkJR0ZQX0tFUk5FTCk7DQorDQorCWlmICghbmZpdF9kY3IpDQorCQlyZXR1cm4gZmFsc2U7DQor CUlOSVRfTElTVF9IRUFEKCZuZml0X2Rjci0+bGlzdCk7DQorCW5maXRfZGNyLT5kY3IgPSBkY3I7 DQorCWxpc3RfYWRkX3RhaWwoJm5maXRfZGNyLT5saXN0LCAmYWNwaV9kZXNjLT5kY3JzKTsNCisJ ZGV2X2RiZyhkZXYsICIlczogZGNyIGluZGV4OiAlZCB3aW5kb3dzOiAlZFxuIiwgX19mdW5jX18s DQorCQkJZGNyLT5yZWdpb25faW5kZXgsIGRjci0+d2luZG93cyk7DQorCXJldHVybiB0cnVlOw0K K30NCisNCitzdGF0aWMgYm9vbCBhZGRfYmR3KHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9k ZXNjLA0KKwkJc3RydWN0IGFjcGlfbmZpdF9kYXRhX3JlZ2lvbiAqYmR3KQ0KK3sNCisJc3RydWN0 IGRldmljZSAqZGV2ID0gYWNwaV9kZXNjLT5kZXY7DQorCXN0cnVjdCBuZml0X2JkdyAqbmZpdF9i ZHcgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKm5maXRfYmR3KSwNCisJCQlHRlBfS0VSTkVM KTsNCisNCisJaWYgKCFuZml0X2JkdykNCisJCXJldHVybiBmYWxzZTsNCisJSU5JVF9MSVNUX0hF QUQoJm5maXRfYmR3LT5saXN0KTsNCisJbmZpdF9iZHctPmJkdyA9IGJkdzsNCisJbGlzdF9hZGRf dGFpbCgmbmZpdF9iZHctPmxpc3QsICZhY3BpX2Rlc2MtPmJkd3MpOw0KKwlkZXZfZGJnKGRldiwg IiVzOiBiZHcgZGNyOiAlZCB3aW5kb3dzOiAlZFxuIiwgX19mdW5jX18sDQorCQkJYmR3LT5yZWdp b25faW5kZXgsIGJkdy0+d2luZG93cyk7DQorCXJldHVybiB0cnVlOw0KK30NCisNCitzdGF0aWMg dm9pZCAqYWRkX3RhYmxlKHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLCB2b2lkICp0 YWJsZSwgY29uc3Qgdm9pZCAqZW5kKQ0KK3sNCisJc3RydWN0IGRldmljZSAqZGV2ID0gYWNwaV9k ZXNjLT5kZXY7DQorCXN0cnVjdCBhY3BpX25maXRfaGVhZGVyICpoZHI7DQorCXZvaWQgKmVyciA9 IEVSUl9QVFIoLUVOT01FTSk7DQorDQorCWlmICh0YWJsZSA+PSBlbmQpDQorCQlyZXR1cm4gTlVM TDsNCisNCisJaGRyID0gdGFibGU7DQorCXN3aXRjaCAoaGRyLT50eXBlKSB7DQorCWNhc2UgQUNQ SV9ORklUX1RZUEVfU1lTVEVNX0FERFJFU1M6DQorCQlpZiAoIWFkZF9zcGEoYWNwaV9kZXNjLCB0 YWJsZSkpDQorCQkJcmV0dXJuIGVycjsNCisJCWJyZWFrOw0KKwljYXNlIEFDUElfTkZJVF9UWVBF X01FTU9SWV9NQVA6DQorCQlpZiAoIWFkZF9tZW1kZXYoYWNwaV9kZXNjLCB0YWJsZSkpDQorCQkJ cmV0dXJuIGVycjsNCisJCWJyZWFrOw0KKwljYXNlIEFDUElfTkZJVF9UWVBFX0NPTlRST0xfUkVH SU9OOg0KKwkJaWYgKCFhZGRfZGNyKGFjcGlfZGVzYywgdGFibGUpKQ0KKwkJCXJldHVybiBlcnI7 DQorCQlicmVhazsNCisJY2FzZSBBQ1BJX05GSVRfVFlQRV9EQVRBX1JFR0lPTjoNCisJCWlmICgh YWRkX2JkdyhhY3BpX2Rlc2MsIHRhYmxlKSkNCisJCQlyZXR1cm4gZXJyOw0KKwkJYnJlYWs7DQor CS8qIFRPRE8gKi8NCisJY2FzZSBBQ1BJX05GSVRfVFlQRV9JTlRFUkxFQVZFOg0KKwkJZGV2X2Ri ZyhkZXYsICIlczogaWR0XG4iLCBfX2Z1bmNfXyk7DQorCQlicmVhazsNCisJY2FzZSBBQ1BJX05G SVRfVFlQRV9GTFVTSF9BRERSRVNTOg0KKwkJZGV2X2RiZyhkZXYsICIlczogZmx1c2hcbiIsIF9f ZnVuY19fKTsNCisJCWJyZWFrOw0KKwljYXNlIEFDUElfTkZJVF9UWVBFX1NNQklPUzoNCisJCWRl dl9kYmcoZGV2LCAiJXM6IHNtYmlvc1xuIiwgX19mdW5jX18pOw0KKwkJYnJlYWs7DQorCWRlZmF1 bHQ6DQorCQlkZXZfZXJyKGRldiwgInVua25vd24gdGFibGUgJyVkJyBwYXJzaW5nIG5maXRcbiIs IGhkci0+dHlwZSk7DQorCQlicmVhazsNCisJfQ0KKw0KKwlyZXR1cm4gdGFibGUgKyBoZHItPmxl bmd0aDsNCit9DQorDQorc3RhdGljIHZvaWQgbmZpdF9tZW1fZmluZF9zcGFfYmR3KHN0cnVjdCBh Y3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLA0KKwkJc3RydWN0IG5maXRfbWVtICpuZml0X21lbSkN Cit7DQorCXUzMiBkZXZpY2VfaGFuZGxlID0gX190b19uZml0X21lbWRldihuZml0X21lbSktPmRl dmljZV9oYW5kbGU7DQorCXUxNiBkY3JfaW5kZXggPSBuZml0X21lbS0+ZGNyLT5yZWdpb25faW5k ZXg7DQorCXN0cnVjdCBuZml0X3NwYSAqbmZpdF9zcGE7DQorDQorCWxpc3RfZm9yX2VhY2hfZW50 cnkobmZpdF9zcGEsICZhY3BpX2Rlc2MtPnNwYXMsIGxpc3QpIHsNCisJCXUxNiByYW5nZV9pbmRl eCA9IG5maXRfc3BhLT5zcGEtPnJhbmdlX2luZGV4Ow0KKwkJaW50IHR5cGUgPSBuZml0X3NwYV90 eXBlKG5maXRfc3BhLT5zcGEpOw0KKwkJc3RydWN0IG5maXRfbWVtZGV2ICpuZml0X21lbWRldjsN CisNCisJCWlmICh0eXBlICE9IE5GSVRfU1BBX0JEVykNCisJCQljb250aW51ZTsNCisNCisJCWxp c3RfZm9yX2VhY2hfZW50cnkobmZpdF9tZW1kZXYsICZhY3BpX2Rlc2MtPm1lbWRldnMsIGxpc3Qp IHsNCisJCQlpZiAobmZpdF9tZW1kZXYtPm1lbWRldi0+cmFuZ2VfaW5kZXggIT0gcmFuZ2VfaW5k ZXgpDQorCQkJCWNvbnRpbnVlOw0KKwkJCWlmIChuZml0X21lbWRldi0+bWVtZGV2LT5kZXZpY2Vf aGFuZGxlICE9IGRldmljZV9oYW5kbGUpDQorCQkJCWNvbnRpbnVlOw0KKwkJCWlmIChuZml0X21l bWRldi0+bWVtZGV2LT5yZWdpb25faW5kZXggIT0gZGNyX2luZGV4KQ0KKwkJCQljb250aW51ZTsN CisNCisJCQluZml0X21lbS0+c3BhX2JkdyA9IG5maXRfc3BhLT5zcGE7DQorCQkJcmV0dXJuOw0K KwkJfQ0KKwl9DQorDQorCWRldl9kYmcoYWNwaV9kZXNjLT5kZXYsICJTUEEtQkRXIG5vdCBmb3Vu ZCBmb3IgU1BBLURDUiAlZFxuIiwNCisJCQluZml0X21lbS0+c3BhX2Rjci0+cmFuZ2VfaW5kZXgp Ow0KKwluZml0X21lbS0+YmR3ID0gTlVMTDsNCit9DQorDQorc3RhdGljIGludCBuZml0X21lbV9h ZGQoc3RydWN0IGFjcGlfbmZpdF9kZXNjICphY3BpX2Rlc2MsDQorCQlzdHJ1Y3QgbmZpdF9tZW0g Km5maXRfbWVtLCBzdHJ1Y3QgYWNwaV9uZml0X3N5c3RlbV9hZGRyZXNzICpzcGEpDQorew0KKwl1 MTYgZGNyX2luZGV4ID0gX190b19uZml0X21lbWRldihuZml0X21lbSktPnJlZ2lvbl9pbmRleDsN CisJc3RydWN0IG5maXRfZGNyICpuZml0X2RjcjsNCisJc3RydWN0IG5maXRfYmR3ICpuZml0X2Jk dzsNCisNCisJbGlzdF9mb3JfZWFjaF9lbnRyeShuZml0X2RjciwgJmFjcGlfZGVzYy0+ZGNycywg bGlzdCkgew0KKwkJaWYgKG5maXRfZGNyLT5kY3ItPnJlZ2lvbl9pbmRleCAhPSBkY3JfaW5kZXgp DQorCQkJY29udGludWU7DQorCQluZml0X21lbS0+ZGNyID0gbmZpdF9kY3ItPmRjcjsNCisJCWJy ZWFrOw0KKwl9DQorDQorCWlmICghbmZpdF9tZW0tPmRjcikgew0KKwkJZGV2X2RiZyhhY3BpX2Rl c2MtPmRldiwgIlNQQSAlZCBtaXNzaW5nOiVzJXNcbiIsIHNwYS0+cmFuZ2VfaW5kZXgsDQorCQkJ CV9fdG9fbmZpdF9tZW1kZXYobmZpdF9tZW0pID8gIiIgOiAiIE1FTURFViIsDQorCQkJCW5maXRf bWVtLT5kY3IgPyAiIiA6ICIgRENSIik7DQorCQlyZXR1cm4gLUVOT0RFVjsNCisJfQ0KKw0KKwkv Kg0KKwkgKiBXZSd2ZSBmb3VuZCBlbm91Z2ggdG8gY3JlYXRlIGFuIG52ZGltbSwgb3B0aW9uYWxs eQ0KKwkgKiBmaW5kIGFuIGFzc29jaWF0ZWQgQkRXDQorCSAqLw0KKwlsaXN0X2FkZCgmbmZpdF9t ZW0tPmxpc3QsICZhY3BpX2Rlc2MtPmRpbW1zKTsNCisNCisJbGlzdF9mb3JfZWFjaF9lbnRyeShu Zml0X2JkdywgJmFjcGlfZGVzYy0+YmR3cywgbGlzdCkgew0KKwkJaWYgKG5maXRfYmR3LT5iZHct PnJlZ2lvbl9pbmRleCAhPSBkY3JfaW5kZXgpDQorCQkJY29udGludWU7DQorCQluZml0X21lbS0+ YmR3ID0gbmZpdF9iZHctPmJkdzsNCisJCWJyZWFrOw0KKwl9DQorDQorCWlmICghbmZpdF9tZW0t PmJkdykNCisJCXJldHVybiAwOw0KKw0KKwluZml0X21lbV9maW5kX3NwYV9iZHcoYWNwaV9kZXNj LCBuZml0X21lbSk7DQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50IG5maXRfbWVtX2Rj cl9pbml0KHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9kZXNjLA0KKwkJc3RydWN0IGFjcGlf bmZpdF9zeXN0ZW1fYWRkcmVzcyAqc3BhKQ0KK3sNCisJc3RydWN0IG5maXRfbWVtICpuZml0X21l bSwgKmZvdW5kOw0KKwlzdHJ1Y3QgbmZpdF9tZW1kZXYgKm5maXRfbWVtZGV2Ow0KKwlpbnQgdHlw ZSA9IG5maXRfc3BhX3R5cGUoc3BhKTsNCisJdTE2IGRjcl9pbmRleDsNCisNCisJc3dpdGNoICh0 eXBlKSB7DQorCWNhc2UgTkZJVF9TUEFfRENSOg0KKwljYXNlIE5GSVRfU1BBX1BNOg0KKwkJYnJl YWs7DQorCWRlZmF1bHQ6DQorCQlyZXR1cm4gMDsNCisJfQ0KKw0KKwlsaXN0X2Zvcl9lYWNoX2Vu dHJ5KG5maXRfbWVtZGV2LCAmYWNwaV9kZXNjLT5tZW1kZXZzLCBsaXN0KSB7DQorCQlpbnQgcmM7 DQorDQorCQlpZiAobmZpdF9tZW1kZXYtPm1lbWRldi0+cmFuZ2VfaW5kZXggIT0gc3BhLT5yYW5n ZV9pbmRleCkNCisJCQljb250aW51ZTsNCisJCWZvdW5kID0gTlVMTDsNCisJCWRjcl9pbmRleCA9 IG5maXRfbWVtZGV2LT5tZW1kZXYtPnJlZ2lvbl9pbmRleDsNCisJCWxpc3RfZm9yX2VhY2hfZW50 cnkobmZpdF9tZW0sICZhY3BpX2Rlc2MtPmRpbW1zLCBsaXN0KQ0KKwkJCWlmIChfX3RvX25maXRf bWVtZGV2KG5maXRfbWVtKS0+cmVnaW9uX2luZGV4ID09IGRjcl9pbmRleCkgew0KKwkJCQlmb3Vu ZCA9IG5maXRfbWVtOw0KKwkJCQlicmVhazsNCisJCQl9DQorDQorCQlpZiAoZm91bmQpDQorCQkJ bmZpdF9tZW0gPSBmb3VuZDsNCisJCWVsc2Ugew0KKwkJCW5maXRfbWVtID0gZGV2bV9remFsbG9j KGFjcGlfZGVzYy0+ZGV2LA0KKwkJCQkJc2l6ZW9mKCpuZml0X21lbSksIEdGUF9LRVJORUwpOw0K KwkJCWlmICghbmZpdF9tZW0pDQorCQkJCXJldHVybiAtRU5PTUVNOw0KKwkJCUlOSVRfTElTVF9I RUFEKCZuZml0X21lbS0+bGlzdCk7DQorCQl9DQorDQorCQlpZiAodHlwZSA9PSBORklUX1NQQV9E Q1IpIHsNCisJCQkvKiBtdWx0aXBsZSBkaW1tcyBtYXkgc2hhcmUgYSBTUEEgd2hlbiBpbnRlcmxl YXZlZCAqLw0KKwkJCW5maXRfbWVtLT5zcGFfZGNyID0gc3BhOw0KKwkJCW5maXRfbWVtLT5tZW1k ZXZfZGNyID0gbmZpdF9tZW1kZXYtPm1lbWRldjsNCisJCX0gZWxzZSB7DQorCQkJLyoNCisJCQkg KiBBIHNpbmdsZSBkaW1tIG1heSBiZWxvbmcgdG8gbXVsdGlwbGUgU1BBLVBNDQorCQkJICogcmFu Z2VzLCByZWNvcmQgYXQgbGVhc3Qgb25lIGluIGFkZGl0aW9uIHRvDQorCQkJICogYW55IFNQQS1E Q1IgcmFuZ2UuDQorCQkJICovDQorCQkJbmZpdF9tZW0tPm1lbWRldl9wbWVtID0gbmZpdF9tZW1k ZXYtPm1lbWRldjsNCisJCX0NCisNCisJCWlmIChmb3VuZCkNCisJCQljb250aW51ZTsNCisNCisJ CXJjID0gbmZpdF9tZW1fYWRkKGFjcGlfZGVzYywgbmZpdF9tZW0sIHNwYSk7DQorCQlpZiAocmMp DQorCQkJcmV0dXJuIHJjOw0KKwl9DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50 IG5maXRfbWVtX2NtcCh2b2lkICpwcml2LCBzdHJ1Y3QgbGlzdF9oZWFkICpfX2EsIHN0cnVjdCBs aXN0X2hlYWQgKl9fYikNCit7DQorCXN0cnVjdCBuZml0X21lbSAqYSA9IGNvbnRhaW5lcl9vZihf X2EsIHR5cGVvZigqYSksIGxpc3QpOw0KKwlzdHJ1Y3QgbmZpdF9tZW0gKmIgPSBjb250YWluZXJf b2YoX19iLCB0eXBlb2YoKmIpLCBsaXN0KTsNCisJdTMyIGhhbmRsZUEsIGhhbmRsZUI7DQorDQor CWhhbmRsZUEgPSBfX3RvX25maXRfbWVtZGV2KGEpLT5kZXZpY2VfaGFuZGxlOw0KKwloYW5kbGVC ID0gX190b19uZml0X21lbWRldihiKS0+ZGV2aWNlX2hhbmRsZTsNCisJaWYgKGhhbmRsZUEgPCBo YW5kbGVCKQ0KKwkJcmV0dXJuIC0xOw0KKwllbHNlIGlmIChoYW5kbGVBID4gaGFuZGxlQikNCisJ CXJldHVybiAxOw0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBuZml0X21lbV9pbml0 KHN0cnVjdCBhY3BpX25maXRfZGVzYyAqYWNwaV9kZXNjKQ0KK3sNCisJc3RydWN0IG5maXRfc3Bh ICpuZml0X3NwYTsNCisNCisJLyoNCisJICogRm9yIGVhY2ggU1BBLURDUiBvciBTUEEtUE1FTSBh ZGRyZXNzIHJhbmdlIGZpbmQgaXRzDQorCSAqIGNvcnJlc3BvbmRpbmcgTUVNREVWKHMpLiAgRnJv bSBlYWNoIE1FTURFViBmaW5kIHRoZQ0KKwkgKiBjb3JyZXNwb25kaW5nIERDUi4gIFRoZW4sIGlm IHdlJ3JlIG9wZXJhdGluZyBvbiBhIFNQQS1EQ1IsDQorCSAqIHRyeSB0byBmaW5kIGEgU1BBLUJE VyBhbmQgYSBjb3JyZXNwb25kaW5nIEJEVyB0aGF0IHJlZmVyZW5jZXMNCisJICogdGhlIERDUi4g IFRocm93IGl0IGFsbCBpbnRvIGFuIG5maXRfbWVtIG9iamVjdC4gIE5vdGUsIHRoYXQNCisJICog QkRXcyBhcmUgb3B0aW9uYWwuDQorCSAqLw0KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG5maXRfc3Bh LCAmYWNwaV9kZXNjLT5zcGFzLCBsaXN0KSB7DQorCQlpbnQgcmM7DQorDQorCQlyYyA9IG5maXRf bWVtX2Rjcl9pbml0KGFjcGlfZGVzYywgbmZpdF9zcGEtPnNwYSk7DQorCQlpZiAocmMpDQorCQkJ cmV0dXJuIHJjOw0KKwl9DQorDQorCWxpc3Rfc29ydChOVUxMLCAmYWNwaV9kZXNjLT5kaW1tcywg bmZpdF9tZW1fY21wKTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBpbnQgYWNwaV9u Zml0X2luaXQoc3RydWN0IGFjcGlfbmZpdF9kZXNjICphY3BpX2Rlc2MsIGFjcGlfc2l6ZSBzeikN Cit7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9IGFjcGlfZGVzYy0+ZGV2Ow0KKwljb25zdCB2b2lk ICplbmQ7DQorCXU4ICpkYXRhOw0KKw0KKwlJTklUX0xJU1RfSEVBRCgmYWNwaV9kZXNjLT5zcGFz KTsNCisJSU5JVF9MSVNUX0hFQUQoJmFjcGlfZGVzYy0+ZGNycyk7DQorCUlOSVRfTElTVF9IRUFE KCZhY3BpX2Rlc2MtPmJkd3MpOw0KKwlJTklUX0xJU1RfSEVBRCgmYWNwaV9kZXNjLT5tZW1kZXZz KTsNCisJSU5JVF9MSVNUX0hFQUQoJmFjcGlfZGVzYy0+ZGltbXMpOw0KKw0KKwlkYXRhID0gKHU4 ICopIGFjcGlfZGVzYy0+bmZpdDsNCisJZW5kID0gZGF0YSArIHN6Ow0KKwlkYXRhICs9IHNpemVv ZihzdHJ1Y3QgYWNwaV90YWJsZV9uZml0KTsNCisJd2hpbGUgKCFJU19FUlJfT1JfTlVMTChkYXRh KSkNCisJCWRhdGEgPSBhZGRfdGFibGUoYWNwaV9kZXNjLCBkYXRhLCBlbmQpOw0KKw0KKwlpZiAo SVNfRVJSKGRhdGEpKSB7DQorCQlkZXZfZGJnKGRldiwgIiVzOiBuZml0IHRhYmxlIHBhcnNpbmcg ZXJyb3I6ICVsZFxuIiwgX19mdW5jX18sDQorCQkJCVBUUl9FUlIoZGF0YSkpOw0KKwkJcmV0dXJu IFBUUl9FUlIoZGF0YSk7DQorCX0NCisNCisJaWYgKG5maXRfbWVtX2luaXQoYWNwaV9kZXNjKSAh PSAwKQ0KKwkJcmV0dXJuIC1FTk9NRU07DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMg aW50IGFjcGlfbmZpdF9hZGQoc3RydWN0IGFjcGlfZGV2aWNlICphZGV2KQ0KK3sNCisJc3RydWN0 IG52ZGltbV9idXNfZGVzY3JpcHRvciAqbmRfZGVzYzsNCisJc3RydWN0IGFjcGlfbmZpdF9kZXNj ICphY3BpX2Rlc2M7DQorCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZhZGV2LT5kZXY7DQorCXN0cnVj dCBhY3BpX3RhYmxlX2hlYWRlciAqdGJsOw0KKwlhY3BpX3N0YXR1cyBzdGF0dXMgPSBBRV9PSzsN CisJYWNwaV9zaXplIHN6Ow0KKwlpbnQgcmM7DQorDQorCXN0YXR1cyA9IGFjcGlfZ2V0X3RhYmxl X3dpdGhfc2l6ZSgiTkZJVCIsIDAsICZ0YmwsICZzeik7DQorCWlmIChBQ1BJX0ZBSUxVUkUoc3Rh dHVzKSkgew0KKwkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZmluZCBORklUXG4iKTsNCisJCXJl dHVybiAtRU5YSU87DQorCX0NCisNCisJYWNwaV9kZXNjID0gZGV2bV9remFsbG9jKGRldiwgc2l6 ZW9mKCphY3BpX2Rlc2MpLCBHRlBfS0VSTkVMKTsNCisJaWYgKCFhY3BpX2Rlc2MpDQorCQlyZXR1 cm4gLUVOT01FTTsNCisNCisJZGV2X3NldF9kcnZkYXRhKGRldiwgYWNwaV9kZXNjKTsNCisJYWNw aV9kZXNjLT5kZXYgPSBkZXY7DQorCWFjcGlfZGVzYy0+bmZpdCA9IChzdHJ1Y3QgYWNwaV90YWJs ZV9uZml0ICopIHRibDsNCisJbmRfZGVzYyA9ICZhY3BpX2Rlc2MtPm5kX2Rlc2M7DQorCW5kX2Rl c2MtPnByb3ZpZGVyX25hbWUgPSAiQUNQSS5ORklUIjsNCisJbmRfZGVzYy0+bmRjdGwgPSBhY3Bp X25maXRfY3RsOw0KKw0KKwlhY3BpX2Rlc2MtPm52ZGltbV9idXMgPSBudmRpbW1fYnVzX3JlZ2lz dGVyKGRldiwgbmRfZGVzYyk7DQorCWlmICghYWNwaV9kZXNjLT5udmRpbW1fYnVzKQ0KKwkJcmV0 dXJuIC1FTlhJTzsNCisNCisJcmMgPSBhY3BpX25maXRfaW5pdChhY3BpX2Rlc2MsIHN6KTsNCisJ aWYgKHJjKSB7DQorCQludmRpbW1fYnVzX3VucmVnaXN0ZXIoYWNwaV9kZXNjLT5udmRpbW1fYnVz KTsNCisJCXJldHVybiByYzsNCisJfQ0KKwlyZXR1cm4gMDsNCit9DQorDQorc3RhdGljIGludCBh Y3BpX25maXRfcmVtb3ZlKHN0cnVjdCBhY3BpX2RldmljZSAqYWRldikNCit7DQorCXN0cnVjdCBh Y3BpX25maXRfZGVzYyAqYWNwaV9kZXNjID0gZGV2X2dldF9kcnZkYXRhKCZhZGV2LT5kZXYpOw0K Kw0KKwludmRpbW1fYnVzX3VucmVnaXN0ZXIoYWNwaV9kZXNjLT5udmRpbW1fYnVzKTsNCisJcmV0 dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYWNwaV9kZXZpY2VfaWQgYWNwaV9u Zml0X2lkc1tdID0gew0KKwl7ICJBQ1BJMDAxMiIsIDAgfSwNCisJeyAiIiwgMCB9LA0KK307DQor TU9EVUxFX0RFVklDRV9UQUJMRShhY3BpLCBhY3BpX25maXRfaWRzKTsNCisNCitzdGF0aWMgc3Ry dWN0IGFjcGlfZHJpdmVyIGFjcGlfbmZpdF9kcml2ZXIgPSB7DQorCS5uYW1lID0gS0JVSUxEX01P RE5BTUUsDQorCS5pZHMgPSBhY3BpX25maXRfaWRzLA0KKwkuZmxhZ3MgPSBBQ1BJX0RSSVZFUl9B TExfTk9USUZZX0VWRU5UUywNCisJLm9wcyA9IHsNCisJCS5hZGQgPSBhY3BpX25maXRfYWRkLA0K KwkJLnJlbW92ZSA9IGFjcGlfbmZpdF9yZW1vdmUsDQorCX0sDQorfTsNCisNCitzdGF0aWMgX19p bml0IGludCBuZml0X2luaXQodm9pZCkNCit7DQorCUJVSUxEX0JVR19PTihzaXplb2Yoc3RydWN0 IGFjcGlfdGFibGVfbmZpdCkgIT0gNDApOw0KKwlCVUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCBh Y3BpX25maXRfc3lzdGVtX2FkZHJlc3MpICE9IDU2KTsNCisJQlVJTERfQlVHX09OKHNpemVvZihz dHJ1Y3QgYWNwaV9uZml0X21lbW9yeV9tYXApICE9IDQ4KTsNCisJQlVJTERfQlVHX09OKHNpemVv ZihzdHJ1Y3QgYWNwaV9uZml0X2ludGVybGVhdmUpICE9IDIwKTsNCisJQlVJTERfQlVHX09OKHNp emVvZihzdHJ1Y3QgYWNwaV9uZml0X3NtYmlvcykgIT0gOSk7DQorCUJVSUxEX0JVR19PTihzaXpl b2Yoc3RydWN0IGFjcGlfbmZpdF9jb250cm9sX3JlZ2lvbikgIT0gODApOw0KKwlCVUlMRF9CVUdf T04oc2l6ZW9mKHN0cnVjdCBhY3BpX25maXRfZGF0YV9yZWdpb24pICE9IDQwKTsNCisNCisJYWNw aV9zdHJfdG9fdXVpZChVVUlEX1ZPTEFUSUxFX01FTU9SWSwgbmZpdF91dWlkW05GSVRfU1BBX1ZP TEFUSUxFXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9QRVJTSVNURU5UX01FTU9SWSwgbmZp dF91dWlkW05GSVRfU1BBX1BNXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9DT05UUk9MX1JF R0lPTiwgbmZpdF91dWlkW05GSVRfU1BBX0RDUl0pOw0KKwlhY3BpX3N0cl90b191dWlkKFVVSURf REFUQV9SRUdJT04sIG5maXRfdXVpZFtORklUX1NQQV9CRFddKTsNCisJYWNwaV9zdHJfdG9fdXVp ZChVVUlEX1ZPTEFUSUxFX1ZJUlRVQUxfRElTSywgbmZpdF91dWlkW05GSVRfU1BBX1ZESVNLXSk7 DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9WT0xBVElMRV9WSVJUVUFMX0NELCBuZml0X3V1aWRb TkZJVF9TUEFfVkNEXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9QRVJTSVNURU5UX1ZJUlRV QUxfRElTSywgbmZpdF91dWlkW05GSVRfU1BBX1BESVNLXSk7DQorCWFjcGlfc3RyX3RvX3V1aWQo VVVJRF9QRVJTSVNURU5UX1ZJUlRVQUxfQ0QsIG5maXRfdXVpZFtORklUX1NQQV9QQ0RdKTsNCisJ YWNwaV9zdHJfdG9fdXVpZChVVUlEX05GSVRfQlVTLCBuZml0X3V1aWRbTkZJVF9ERVZfQlVTXSk7 DQorCWFjcGlfc3RyX3RvX3V1aWQoVVVJRF9ORklUX0RJTU0sIG5maXRfdXVpZFtORklUX0RFVl9E SU1NXSk7DQorDQorCXJldHVybiBhY3BpX2J1c19yZWdpc3Rlcl9kcml2ZXIoJmFjcGlfbmZpdF9k cml2ZXIpOw0KK30NCisNCitzdGF0aWMgX19leGl0IHZvaWQgbmZpdF9leGl0KHZvaWQpDQorew0K KwlhY3BpX2J1c191bnJlZ2lzdGVyX2RyaXZlcigmYWNwaV9uZml0X2RyaXZlcik7DQorfQ0KKw0K K21vZHVsZV9pbml0KG5maXRfaW5pdCk7DQorbW9kdWxlX2V4aXQobmZpdF9leGl0KTsNCitNT0RV TEVfTElDRU5TRSgiR1BMIHYyIik7DQorTU9EVUxFX0FVVEhPUigiSW50ZWwgQ29ycG9yYXRpb24i KTsNCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvbmZpdC5oIGIvZHJpdmVycy9hY3BpL25maXQu aA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4uMmQ5OGNjMWI3YjZj DQotLS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL2FjcGkvbmZpdC5oDQpAQCAtMCwwICsxLDg5 IEBADQorLyoNCisgKiBOVkRJTU0gRmlybXdhcmUgSW50ZXJmYWNlIFRhYmxlIC0gTkZJVA0KKyAq DQorICogQ29weXJpZ2h0KGMpIDIwMTMtMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQorICogaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMNCisgKiBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0KKyAqIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LCBidXQNCisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mDQorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUNCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuDQorICovDQorI2lmbmRlZiBfX05GSVRfSF9fDQorI2RlZmluZSBfX05G SVRfSF9fDQorI2luY2x1ZGUgPGxpbnV4L2xpYm52ZGltbS5oPg0KKyNpbmNsdWRlIDxsaW51eC90 eXBlcy5oPg0KKyNpbmNsdWRlIDxsaW51eC91dWlkLmg+DQorI2luY2x1ZGUgPGxpbnV4L2FjcGku aD4NCisjaW5jbHVkZSA8YWNwaS9hY3V1aWQuaD4NCisNCisjZGVmaW5lIFVVSURfTkZJVF9CVVMg IjJmMTBlN2E0LTllOTEtMTFlNC04OWQzLTEyM2I5M2Y3NWNiYSINCisjZGVmaW5lIFVVSURfTkZJ VF9ESU1NICI0MzA5YWMzMC0wZDExLTExZTQtOTE5MS0wODAwMjAwYzlhNjYiDQorDQorZW51bSBu Zml0X3V1aWRzIHsNCisJTkZJVF9TUEFfVk9MQVRJTEUsDQorCU5GSVRfU1BBX1BNLA0KKwlORklU X1NQQV9EQ1IsDQorCU5GSVRfU1BBX0JEVywNCisJTkZJVF9TUEFfVkRJU0ssDQorCU5GSVRfU1BB X1ZDRCwNCisJTkZJVF9TUEFfUERJU0ssDQorCU5GSVRfU1BBX1BDRCwNCisJTkZJVF9ERVZfQlVT LA0KKwlORklUX0RFVl9ESU1NLA0KKwlORklUX1VVSURfTUFYLA0KK307DQorDQorc3RydWN0IG5m aXRfc3BhIHsNCisJc3RydWN0IGFjcGlfbmZpdF9zeXN0ZW1fYWRkcmVzcyAqc3BhOw0KKwlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7DQorfTsNCisNCitzdHJ1Y3QgbmZpdF9kY3Igew0KKwlzdHJ1Y3Qg YWNwaV9uZml0X2NvbnRyb2xfcmVnaW9uICpkY3I7DQorCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsN Cit9Ow0KKw0KK3N0cnVjdCBuZml0X2JkdyB7DQorCXN0cnVjdCBhY3BpX25maXRfZGF0YV9yZWdp b24gKmJkdzsNCisJc3RydWN0IGxpc3RfaGVhZCBsaXN0Ow0KK307DQorDQorc3RydWN0IG5maXRf bWVtZGV2IHsNCisJc3RydWN0IGFjcGlfbmZpdF9tZW1vcnlfbWFwICptZW1kZXY7DQorCXN0cnVj dCBsaXN0X2hlYWQgbGlzdDsNCit9Ow0KKw0KKy8qIGFzc2VtYmxlZCB0YWJsZXMgZm9yIGEgZ2l2 ZW4gZGltbS9tZW1vcnktZGV2aWNlICovDQorc3RydWN0IG5maXRfbWVtIHsNCisJc3RydWN0IGFj cGlfbmZpdF9tZW1vcnlfbWFwICptZW1kZXZfZGNyOw0KKwlzdHJ1Y3QgYWNwaV9uZml0X21lbW9y eV9tYXAgKm1lbWRldl9wbWVtOw0KKwlzdHJ1Y3QgYWNwaV9uZml0X2NvbnRyb2xfcmVnaW9uICpk Y3I7DQorCXN0cnVjdCBhY3BpX25maXRfZGF0YV9yZWdpb24gKmJkdzsNCisJc3RydWN0IGFjcGlf bmZpdF9zeXN0ZW1fYWRkcmVzcyAqc3BhX2RjcjsNCisJc3RydWN0IGFjcGlfbmZpdF9zeXN0ZW1f YWRkcmVzcyAqc3BhX2JkdzsNCisJc3RydWN0IGxpc3RfaGVhZCBsaXN0Ow0KK307DQorDQorc3Ry dWN0IGFjcGlfbmZpdF9kZXNjIHsNCisJc3RydWN0IG52ZGltbV9idXNfZGVzY3JpcHRvciBuZF9k ZXNjOw0KKwlzdHJ1Y3QgYWNwaV90YWJsZV9uZml0ICpuZml0Ow0KKwlzdHJ1Y3QgbGlzdF9oZWFk IG1lbWRldnM7DQorCXN0cnVjdCBsaXN0X2hlYWQgZGltbXM7DQorCXN0cnVjdCBsaXN0X2hlYWQg c3BhczsNCisJc3RydWN0IGxpc3RfaGVhZCBkY3JzOw0KKwlzdHJ1Y3QgbGlzdF9oZWFkIGJkd3M7 DQorCXN0cnVjdCBudmRpbW1fYnVzICpudmRpbW1fYnVzOw0KKwlzdHJ1Y3QgZGV2aWNlICpkZXY7 DQorfTsNCisNCitzdGF0aWMgaW5saW5lIHN0cnVjdCBhY3BpX25maXRfbWVtb3J5X21hcCAqX190 b19uZml0X21lbWRldihzdHJ1Y3QgbmZpdF9tZW0gKm5maXRfbWVtKQ0KK3sNCisJaWYgKG5maXRf bWVtLT5tZW1kZXZfZGNyKQ0KKwkJcmV0dXJuIG5maXRfbWVtLT5tZW1kZXZfZGNyOw0KKwlyZXR1 cm4gbmZpdF9tZW0tPm1lbWRldl9wbWVtOw0KK30NCisjZW5kaWYgLyogX19ORklUX0hfXyAqLw0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL0tjb25maWcgYi9kcml2ZXJzL252ZGltbS9LY29u ZmlnDQpuZXcgZmlsZSBtb2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMDAwMDAwLi40ZjIyOTE5Mzhl YTANCi0tLSAvZGV2L251bGwNCisrKyBiL2RyaXZlcnMvbnZkaW1tL0tjb25maWcNCkBAIC0wLDAg KzEsMTMgQEANCitjb25maWcgTElCTlZESU1NDQorCXRyaXN0YXRlICJOVkRJTU0gKE5vbi1Wb2xh dGlsZSBNZW1vcnkgRGV2aWNlKSBTdXBwb3J0Ig0KKwloZWxwDQorCSAgR2VuZXJpYyBzdXBwb3J0 IGZvciBub24tdm9sYXRpbGUgbWVtb3J5IGRldmljZXMgaW5jbHVkaW5nDQorCSAgQUNQSS02LU5G SVQgZGVmaW5lZCByZXNvdXJjZXMuICBPbiBwbGF0Zm9ybXMgdGhhdCBkZWZpbmUgYW4NCisJICBO RklULCBvciBvdGhlcndpc2UgY2FuIGRpc2NvdmVyIE5WRElNTSByZXNvdXJjZXMsIGEgbGlibnZk aW1tDQorCSAgYnVzIGlzIHJlZ2lzdGVyZWQgdG8gYWR2ZXJ0aXNlIFBNRU0gKHBlcnNpc3RlbnQg bWVtb3J5KQ0KKwkgIG5hbWVzcGFjZXMgKC9kZXYvcG1lbVgpIGFuZCBCTEsgKHNsaWRpbmcgbW1p byB3aW5kb3cocykpDQorCSAgbmFtZXNwYWNlcyAoL2Rldi9uZFgpLiBBIFBNRU0gbmFtZXNwYWNl IHJlZmVycyB0byBhIG1lbW9yeQ0KKwkgIHJlc291cmNlIHRoYXQgbWF5IHNwYW4gbXVsdGlwbGUg RElNTXMgYW5kIHN1cHBvcnQgREFYIChzZWUNCisJICBDT05GSUdfREFYKS4gIEEgQkxLIG5hbWVz cGFjZSByZWZlcnMgdG8gYW4gTlZESU1NIGNvbnRyb2wNCisJICByZWdpb24gd2hpY2ggZXhwb3Nl cyBhbiBtbWlvIHJlZ2lzdGVyIHNldCBmb3Igd2luZG93ZWQNCisJICBhY2Nlc3MgbW9kZSB0byBu b24tdm9sYXRpbGUgbWVtb3J5Lg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL01ha2VmaWxl IGIvZHJpdmVycy9udmRpbW0vTWFrZWZpbGUNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAw MDAwMDAwMDAwMDAuLjEwYmM3YWY0Nzk5Mg0KLS0tIC9kZXYvbnVsbA0KKysrIGIvZHJpdmVycy9u dmRpbW0vTWFrZWZpbGUNCkBAIC0wLDAgKzEsMyBAQA0KK29iai0kKENPTkZJR19MSUJOVkRJTU0p ICs9IGxpYm52ZGltbS5vDQorDQorbGlibnZkaW1tLXkgOj0gY29yZS5vDQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9udmRpbW0vY29yZS5jIGIvZHJpdmVycy9udmRpbW0vY29yZS5jDQpuZXcgZmlsZSBt b2RlIDEwMDY0NA0KaW5kZXggMDAwMDAwMDAwMDAwLi41Y2NkNTAwZmZkNGYNCi0tLSAvZGV2L251 bGwNCisrKyBiL2RyaXZlcnMvbnZkaW1tL2NvcmUuYw0KQEAgLTAsMCArMSw2NyBAQA0KKy8qDQor ICogQ29weXJpZ2h0KGMpIDIwMTMtMjAxNSBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMNCisgKiBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0KKyAqIFRoaXMgcHJv Z3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBi dXQNCisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mDQorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUNCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuDQorICovDQorI2luY2x1ZGUgPGxpbnV4L2xpYm52ZGltbS5oPg0KKyNpbmNs dWRlIDxsaW51eC9leHBvcnQuaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1 ZGUgPGxpbnV4L2RldmljZS5oPg0KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+DQorI2luY2x1ZGUg Im5kLWNvcmUuaCINCisNCitzdGF0aWMgREVGSU5FX0lEQShuZF9pZGEpOw0KKw0KK3N0YXRpYyB2 b2lkIG52ZGltbV9idXNfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYpDQorew0KKwlzdHJ1Y3Qg bnZkaW1tX2J1cyAqbnZkaW1tX2J1cyA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBudmRpbW1f YnVzLCBkZXYpOw0KKw0KKwlpZGFfc2ltcGxlX3JlbW92ZSgmbmRfaWRhLCBudmRpbW1fYnVzLT5p ZCk7DQorCWtmcmVlKG52ZGltbV9idXMpOw0KK30NCisNCitzdHJ1Y3QgbnZkaW1tX2J1cyAqbnZk aW1tX2J1c19yZWdpc3RlcihzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsDQorCQlzdHJ1Y3QgbnZkaW1t X2J1c19kZXNjcmlwdG9yICpuZF9kZXNjKQ0KK3sNCisJc3RydWN0IG52ZGltbV9idXMgKm52ZGlt bV9idXMgPSBremFsbG9jKHNpemVvZigqbnZkaW1tX2J1cyksIEdGUF9LRVJORUwpOw0KKwlpbnQg cmM7DQorDQorCWlmICghbnZkaW1tX2J1cykNCisJCXJldHVybiBOVUxMOw0KKwludmRpbW1fYnVz LT5pZCA9IGlkYV9zaW1wbGVfZ2V0KCZuZF9pZGEsIDAsIDAsIEdGUF9LRVJORUwpOw0KKwlpZiAo bnZkaW1tX2J1cy0+aWQgPCAwKSB7DQorCQlrZnJlZShudmRpbW1fYnVzKTsNCisJCXJldHVybiBO VUxMOw0KKwl9DQorCW52ZGltbV9idXMtPm5kX2Rlc2MgPSBuZF9kZXNjOw0KKwludmRpbW1fYnVz LT5kZXYucGFyZW50ID0gcGFyZW50Ow0KKwludmRpbW1fYnVzLT5kZXYucmVsZWFzZSA9IG52ZGlt bV9idXNfcmVsZWFzZTsNCisJZGV2X3NldF9uYW1lKCZudmRpbW1fYnVzLT5kZXYsICJuZGJ1cyVk IiwgbnZkaW1tX2J1cy0+aWQpOw0KKwlyYyA9IGRldmljZV9yZWdpc3RlcigmbnZkaW1tX2J1cy0+ ZGV2KTsNCisJaWYgKHJjKSB7DQorCQlkZXZfZGJnKCZudmRpbW1fYnVzLT5kZXYsICJkZXZpY2Ug cmVnaXN0cmF0aW9uIGZhaWxlZDogJWRcbiIsIHJjKTsNCisJCXB1dF9kZXZpY2UoJm52ZGltbV9i dXMtPmRldik7DQorCQlyZXR1cm4gTlVMTDsNCisJfQ0KKw0KKwlyZXR1cm4gbnZkaW1tX2J1czsN Cit9DQorRVhQT1JUX1NZTUJPTF9HUEwobnZkaW1tX2J1c19yZWdpc3Rlcik7DQorDQordm9pZCBu dmRpbW1fYnVzX3VucmVnaXN0ZXIoc3RydWN0IG52ZGltbV9idXMgKm52ZGltbV9idXMpDQorew0K KwlpZiAoIW52ZGltbV9idXMpDQorCQlyZXR1cm47DQorCWRldmljZV91bnJlZ2lzdGVyKCZudmRp bW1fYnVzLT5kZXYpOw0KK30NCitFWFBPUlRfU1lNQk9MX0dQTChudmRpbW1fYnVzX3VucmVnaXN0 ZXIpOw0KKw0KK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsNCitNT0RVTEVfQVVUSE9SKCJJbnRl bCBDb3Jwb3JhdGlvbiIpOw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL25kLWNvcmUuaCBi L2RyaXZlcnMvbnZkaW1tL25kLWNvcmUuaA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAw MDAwMDAwMDAwMC4uZTdjNGU5OWEyMmE0DQotLS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL252 ZGltbS9uZC1jb3JlLmgNCkBAIC0wLDAgKzEsMjMgQEANCisvKg0KKyAqIENvcHlyaWdodChjKSAy MDEzLTIwMTUgSW50ZWwgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoNCisg KiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yIG1vZGlmeQ0KKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB2ZXJzaW9uIDIgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzDQorICogcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24uDQorICoNCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0DQorICogV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZg0KKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VDQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLg0KKyAq Lw0KKyNpZm5kZWYgX19ORF9QUklWQVRFX0hfXw0KKyNkZWZpbmUgX19ORF9QUklWQVRFX0hfXw0K KyNpbmNsdWRlIDxsaW51eC9saWJudmRpbW0uaD4NCisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+ DQorDQorc3RydWN0IG52ZGltbV9idXMgew0KKwlzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9y ICpuZF9kZXNjOw0KKwlzdHJ1Y3QgZGV2aWNlIGRldjsNCisJaW50IGlkOw0KK307DQorI2VuZGlm IC8qIF9fTkRfUFJJVkFURV9IX18gKi8NCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2xpYm52 ZGltbS5oIGIvaW5jbHVkZS9saW51eC9saWJudmRpbW0uaA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQN CmluZGV4IDAwMDAwMDAwMDAwMC4uMmIzYzYzOTUwYzkxDQotLS0gL2Rldi9udWxsDQorKysgYi9p bmNsdWRlL2xpbnV4L2xpYm52ZGltbS5oDQpAQCAtMCwwICsxLDM0IEBADQorLyoNCisgKiBsaWJu dmRpbW0gLSBOb24tdm9sYXRpbGUtbWVtb3J5IERldmljZXMgU3Vic3lzdGVtDQorICoNCisgKiBD b3B5cmlnaHQoYykgMjAxMy0yMDE1IEludGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLg0KKyAqDQorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkNCisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdmVy c2lvbiAyIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcw0KKyAqIHB1Ymxpc2hl ZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLg0KKyAqDQorICogVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dA0K KyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YNCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQ0KKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4NCisgKi8NCisjaWZuZGVmIF9fTElCTlZESU1NX0hfXw0KKyNkZWZpbmUgX19MSUJO VkRJTU1fSF9fDQorc3RydWN0IG52ZGltbTsNCitzdHJ1Y3QgbnZkaW1tX2J1c19kZXNjcmlwdG9y Ow0KK3R5cGVkZWYgaW50ICgqbmRjdGxfZm4pKHN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3Ig Km5kX2Rlc2MsDQorCQlzdHJ1Y3QgbnZkaW1tICpudmRpbW0sIHVuc2lnbmVkIGludCBjbWQsIHZv aWQgKmJ1ZiwNCisJCXVuc2lnbmVkIGludCBidWZfbGVuKTsNCisNCitzdHJ1Y3QgbnZkaW1tX2J1 c19kZXNjcmlwdG9yIHsNCisJdW5zaWduZWQgbG9uZyBkc21fbWFzazsNCisJY2hhciAqcHJvdmlk ZXJfbmFtZTsNCisJbmRjdGxfZm4gbmRjdGw7DQorfTsNCisNCitzdHJ1Y3QgZGV2aWNlOw0KK3N0 cnVjdCBudmRpbW1fYnVzOw0KK3N0cnVjdCBudmRpbW1fYnVzICpudmRpbW1fYnVzX3JlZ2lzdGVy KHN0cnVjdCBkZXZpY2UgKnBhcmVudCwNCisJCXN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3Ig Km5maXRfZGVzYyk7DQordm9pZCBudmRpbW1fYnVzX3VucmVnaXN0ZXIoc3RydWN0IG52ZGltbV9i dXMgKm52ZGltbV9idXMpOw0KKyNlbmRpZiAvKiBfX0xJQk5WRElNTV9IX18gKi8NCg0K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756960AbbFCTYv (ORCPT ); Wed, 3 Jun 2015 15:24:51 -0400 Received: from mga02.intel.com ([134.134.136.20]:12098 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753943AbbFCTYl (ORCPT ); Wed, 3 Jun 2015 15:24:41 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,548,1427785200"; d="scan'208";a="740380701" From: "Williams, Dan J" To: "hch@lst.de" CC: "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "neilb@suse.de" , "jmoyer@redhat.com" , "linux-api@vger.kernel.org" , "axboe@kernel.dk" , "akpm@linux-foundation.org" , "sfr@canb.auug.org.au" , "linux-nvdimm@lists.01.org" , "gregkh@linuxfoundation.org" , "rafael@kernel.org" , "linux-acpi@vger.kernel.org" Subject: Re: [PATCH v5 02/21] libnvdimm, nfit: initial libnvdimm infrastructure and NFIT support Thread-Topic: [PATCH v5 02/21] libnvdimm, nfit: initial libnvdimm infrastructure and NFIT support Thread-Index: AQHQnjLsRwWXcSzsj0CXZXakL+egOw== Date: Wed, 3 Jun 2015 19:24:34 +0000 Message-ID: <1433359473.21035.27.camel@intel.com> References: <20150602001134.4506.45867.stgit@dwillia2-desk3.amr.corp.intel.com> <20150602001419.4506.41953.stgit@dwillia2-desk3.amr.corp.intel.com> <20150603145704.GA22311@lst.de> In-Reply-To: <20150603145704.GA22311@lst.de> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.22.254.139] Content-Type: text/plain; charset="utf-8" Content-ID: <1330DB59B70A7047AD4818F14B893C18@intel.com> 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 nfs id t53JOu9t032473 On Wed, 2015-06-03 at 16:57 +0200, Christoph Hellwig wrote: > On Mon, Jun 01, 2015 at 08:14:19PM -0400, Dan Williams wrote: > > A libnvdimm bus is the anchor device for registering nvdimm resources and > > interfaces, for example, a character control device, nvdimm devices, > > and I/O region devices. The ACPI NFIT (NVDIMM Firmware Interface Table) > > is one possible platform description for such non-volatile memory > > resources in a system. The nfit.ko driver attaches to the "ACPI0012" > > device that indicates the presence of the NFIT and parses the table to > > register a libnvdimm bus instance. > > Havin lib in a name of a bus seems odd. Why not simply the nvdimm bus? Sorry, that is a typo the bus is indeed an struct nvdimm_bus instance. > Also this seems to both have the generic nvdimm infrastructure as well > as the acpi wiring. Might make sense to split this into two patches? I like to show an initial infrastructure consumer with the initial implementation in one patch. Makes it easier to catch premature implementation of features. > > > +config ACPI_NFIT > > + tristate "ACPI NVDIMM Firmware Interface Table (NFIT)" > > + depends on PHYS_ADDR_T_64BIT > > + depends on BLK_DEV > > + select NVDIMM_DEVICES > > + select LIBNVDIMM > > Is this the right way for the user to chose it? It seems like enabling > the NVMDIMM subsystem would be the obvious choice, and ACPI would > simply enable the table parsing in that case. The NVDIMM sub-system is enabled by an external provider. We have the e820 type-12 provider and the NFIT provider that select LIBNVDIMM. > > +static u8 nfit_uuid[NFIT_UUID_MAX][16]; > > Should this use the uuid_le type? > That would depend on Rafael being open to changing the acpi_str_to_uuid() prototype to take an uuid_le. > > +static const char *spa_type_name(u16 type) > > +{ > > + switch (type) { > > + case NFIT_SPA_VOLATILE: return "volatile"; > > + case NFIT_SPA_PM: return "pmem"; > > + case NFIT_SPA_DCR: return "dimm-control-region"; > > + case NFIT_SPA_BDW: return "block-data-window"; > > + default: return "unknown"; > > Please never put code on the same line as a switch (or goto) label. Ok, fixed. > > > +static void *add_table(struct acpi_nfit_desc *acpi_desc, void *table, const void *end) > > +{ > > + struct device *dev = acpi_desc->dev; > > + struct acpi_nfit_header *hdr; > > + void *err = ERR_PTR(-ENOMEM); > > + > > + if (table >= end) > > + return NULL; > > + > > + hdr = (struct acpi_nfit_header *) table; > > No need to case from void * to another pointer type. Whoops, fixed. > > > + switch (hdr->type) { > > + case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: { > > + struct nfit_spa *nfit_spa = devm_kzalloc(dev, sizeof(*nfit_spa), > > + GFP_KERNEL); > > + struct acpi_nfit_system_address *spa = table; > > + > > + if (!nfit_spa) > > + return err; > > + INIT_LIST_HEAD(&nfit_spa->list); > > + nfit_spa->spa = spa; > > + list_add_tail(&nfit_spa->list, &acpi_desc->spas); > > + dev_dbg(dev, "%s: spa index: %d type: %s\n", __func__, > > + spa->range_index, > > + spa_type_name(nfit_spa_type(spa))); > > If you need local variables inside a switch statement you probably > want to split each case into a separate helper function. Yeah, probably better that way. Done. > > > +static inline struct acpi_nfit_memory_map *__to_nfit_memdev(struct nfit_mem *nfit_mem) > > This line is over 80 characters. I generally don't see the point of fixing up occasional small incursions over 80 characters if it makes the code more amenable to grep. > Also why the odd __-prefix? Later on the series there's a to_nfit_memdev() that takes a struct device *, and this one is an internal helper. > > > new file mode 100644 > > index 000000000000..24b51dbc8215 > > --- /dev/null > > +++ b/drivers/nvdimm/Kconfig > > @@ -0,0 +1,20 @@ > > +menuconfig NVDIMM_DEVICES > > + bool "NVDIMM (Non-Volatile Memory Device) Support" > > + help > > + Generic support for non-volatile memory devices including > > + ACPI-6-NFIT defined resources. On platforms that define an > > + NFIT, or otherwise can discover NVDIMM resources, a libnvdimm > > + bus is registered to advertise PMEM (persistent memory) > > + namespaces (/dev/pmemX) and BLK (sliding mmio window(s)) > > + namespaces (/dev/ndX). A PMEM namespace refers to a memory > > + resource that may span multiple DIMMs and support DAX (see > > + CONFIG_DAX). A BLK namespace refers to an NVDIMM control > > + region which exposes an mmio register set for windowed > > + access mode to non-volatile memory. > > + > > +if NVDIMM_DEVICES > > + > > +config LIBNVDIMM > > + tristate > > + > > +endif > > What different meanings will CONFIG_NVDIMM_DEVICES and CONFIG_LIBNVDIMM > have? Hmm, nothing worthwhile. I'll merge them into one menuconfig CONFIG_LIBNVDIMM tristate. > > > diff --git a/drivers/nvdimm/nd-private.h b/drivers/nvdimm/nd-private.h > > new file mode 100644 > > index 000000000000..e7c4e99a22a4 > > --- /dev/null > > +++ b/drivers/nvdimm/nd-private.h > > No need for -private if you're already under drivers/nvdimm.. This is the private private-header in the sense that it defines infrastructure that is only meant for the core. Drivers (btt, pmem, blk, etc) must not include nd-private.h. I'll rename it "nd-core.h" to make this more clear. > > +#ifndef __ND_PRIVATE_H__ > > +#define __ND_PRIVATE_H__ > > +#include > > +#include > > + > > +struct nvdimm_bus { > > + struct nvdimm_bus_descriptor *nd_desc; > > + struct device dev; > > + int id; > > +}; > > +#endif /* __ND_PRIVATE_H__ */ > > At least so far this header doesn't need libnvdimm.h struct nvdimm_bus_descriptor is defined there and a forward declaration does not make sense since we'll need the rest of the header later in the series. > > > +#ifndef __LIBNVDIMM_H__ > > +#define __LIBNVDIMM_H__ > > +struct nvdimm; > > +struct nvdimm_bus_descriptor; > > +typedef int (*ndctl_fn)(struct nvdimm_bus_descriptor *nd_desc, > > + struct nvdimm *nvdimm, unsigned int cmd, void *buf, > > + unsigned int buf_len); > > + > > +struct nvdimm_bus_descriptor { > > + unsigned long dsm_mask; > > + char *provider_name; > > + ndctl_fn ndctl; > > +}; > > Please provide proper methods that do one thing properly instead of > ioctl-like multiplexers. This *is* the ioctl multiplexer. The generic ioctl implementation in libnvdimm uses the ndctl_fn to call back out to the provider to process the command. In the case of ACPI this maps to a _DSM (device specific method), for nfit_test it's a emulated implementation, and for e820-type-12 this is obviously not implemented. Reflowed patch with these fixes follows... 8<----- Subject: libnvdimm, nfit: initial libnvdimm infrastructure and NFIT support From: Dan Williams A libnvdimm bus is the anchor device for registering nvdimm resources and interfaces, for example, a character control device, nvdimm devices, and I/O region devices. The ACPI NFIT (NVDIMM Firmware Interface Table) is one possible platform description for such non-volatile memory resources in a system. The nfit.ko driver attaches to the "ACPI0012" device that indicates the presence of the NFIT and parses the table to register a struct nvdimm_bus instance. Cc: Cc: Lv Zheng Cc: Robert Moore Cc: Rafael J. Wysocki Acked-by: Jeff Moyer Signed-off-by: Dan Williams --- drivers/Kconfig | 2 drivers/Makefile | 1 drivers/acpi/Kconfig | 14 + drivers/acpi/Makefile | 1 drivers/acpi/nfit.c | 481 +++++++++++++++++++++++++++++++++++++++++++++ drivers/acpi/nfit.h | 89 ++++++++ drivers/nvdimm/Kconfig | 13 + drivers/nvdimm/Makefile | 3 drivers/nvdimm/core.c | 67 ++++++ drivers/nvdimm/nd-core.h | 23 ++ include/linux/libnvdimm.h | 34 +++ 11 files changed, 728 insertions(+) create mode 100644 drivers/acpi/nfit.c create mode 100644 drivers/acpi/nfit.h create mode 100644 drivers/nvdimm/Kconfig create mode 100644 drivers/nvdimm/Makefile create mode 100644 drivers/nvdimm/core.c create mode 100644 drivers/nvdimm/nd-core.h create mode 100644 include/linux/libnvdimm.h diff --git a/drivers/Kconfig b/drivers/Kconfig index c0cc96bab9e7..6e973b8e3a3b 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -182,4 +182,6 @@ source "drivers/thunderbolt/Kconfig" source "drivers/android/Kconfig" +source "drivers/nvdimm/Kconfig" + endmenu diff --git a/drivers/Makefile b/drivers/Makefile index 46d2554be404..692adf659028 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -64,6 +64,7 @@ obj-$(CONFIG_FB_INTEL) += video/fbdev/intelfb/ obj-$(CONFIG_PARPORT) += parport/ obj-y += base/ block/ misc/ mfd/ nfc/ +obj-$(CONFIG_LIBNVDIMM) += nvdimm/ obj-$(CONFIG_DMA_SHARED_BUFFER) += dma-buf/ obj-$(CONFIG_NUBUS) += nubus/ obj-y += macintosh/ diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig index ab2cbb51c6aa..300b4ef3712b 100644 --- a/drivers/acpi/Kconfig +++ b/drivers/acpi/Kconfig @@ -383,6 +383,20 @@ config ACPI_REDUCED_HARDWARE_ONLY If you are unsure what to do, do not enable this option. +config ACPI_NFIT + tristate "ACPI NVDIMM Firmware Interface Table (NFIT)" + depends on PHYS_ADDR_T_64BIT + depends on BLK_DEV + select LIBNVDIMM + help + Infrastructure to probe ACPI 6 compliant platforms for + NVDIMMs (NFIT) and register a libnvdimm device tree. In + addition to storage devices this also enables libnvdimm to pass + ACPI._DSM messages for platform/dimm configuration. + + To compile this driver as a module, choose M here: + the module will be called nfit. + source "drivers/acpi/apei/Kconfig" config ACPI_EXTLOG diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile index 8a063e276530..f7e9c92ccdcb 100644 --- a/drivers/acpi/Makefile +++ b/drivers/acpi/Makefile @@ -71,6 +71,7 @@ obj-$(CONFIG_ACPI_PCI_SLOT) += pci_slot.o obj-$(CONFIG_ACPI_PROCESSOR) += processor.o obj-y += container.o obj-$(CONFIG_ACPI_THERMAL) += thermal.o +obj-$(CONFIG_ACPI_NFIT) += nfit.o obj-y += acpi_memhotplug.o obj-$(CONFIG_ACPI_HOTPLUG_IOAPIC) += ioapic.o obj-$(CONFIG_ACPI_BATTERY) += battery.o diff --git a/drivers/acpi/nfit.c b/drivers/acpi/nfit.c new file mode 100644 index 000000000000..c400d60018a5 --- /dev/null +++ b/drivers/acpi/nfit.c @@ -0,0 +1,481 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that 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. + */ +#include +#include +#include +#include +#include +#include "nfit.h" + +static u8 nfit_uuid[NFIT_UUID_MAX][16]; + +static const u8 *to_nfit_uuid(enum nfit_uuids id) +{ + return nfit_uuid[id]; +} + +static int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, + struct nvdimm *nvdimm, unsigned int cmd, void *buf, + unsigned int buf_len) +{ + return -ENOTTY; +} + +static const char *spa_type_name(u16 type) +{ + static const char *to_name[] = { + [NFIT_SPA_VOLATILE] = "volatile", + [NFIT_SPA_PM] = "pmem", + [NFIT_SPA_DCR] = "dimm-control-region", + [NFIT_SPA_BDW] = "block-data-window", + [NFIT_SPA_VDISK] = "volatile-disk", + [NFIT_SPA_VCD] = "volatile-cd", + [NFIT_SPA_PDISK] = "persistent-disk", + [NFIT_SPA_PCD] = "persistent-cd", + + }; + + if (type > NFIT_SPA_PCD) + return "unknown"; + + return to_name[type]; +} + +static int nfit_spa_type(struct acpi_nfit_system_address *spa) +{ + int i; + + for (i = 0; i < NFIT_UUID_MAX; i++) + if (memcmp(to_nfit_uuid(i), spa->range_guid, 16) == 0) + return i; + return -1; +} + +static bool add_spa(struct acpi_nfit_desc *acpi_desc, + struct acpi_nfit_system_address *spa) +{ + struct device *dev = acpi_desc->dev; + struct nfit_spa *nfit_spa = devm_kzalloc(dev, sizeof(*nfit_spa), + GFP_KERNEL); + + if (!nfit_spa) + return false; + INIT_LIST_HEAD(&nfit_spa->list); + nfit_spa->spa = spa; + list_add_tail(&nfit_spa->list, &acpi_desc->spas); + dev_dbg(dev, "%s: spa index: %d type: %s\n", __func__, + spa->range_index, + spa_type_name(nfit_spa_type(spa))); + return true; +} + +static bool add_memdev(struct acpi_nfit_desc *acpi_desc, + struct acpi_nfit_memory_map *memdev) +{ + struct device *dev = acpi_desc->dev; + struct nfit_memdev *nfit_memdev = devm_kzalloc(dev, + sizeof(*nfit_memdev), GFP_KERNEL); + + if (!nfit_memdev) + return false; + INIT_LIST_HEAD(&nfit_memdev->list); + nfit_memdev->memdev = memdev; + list_add_tail(&nfit_memdev->list, &acpi_desc->memdevs); + dev_dbg(dev, "%s: memdev handle: %#x spa: %d dcr: %d\n", + __func__, memdev->device_handle, memdev->range_index, + memdev->region_index); + return true; +} + +static bool add_dcr(struct acpi_nfit_desc *acpi_desc, + struct acpi_nfit_control_region *dcr) +{ + struct device *dev = acpi_desc->dev; + struct nfit_dcr *nfit_dcr = devm_kzalloc(dev, sizeof(*nfit_dcr), + GFP_KERNEL); + + if (!nfit_dcr) + return false; + INIT_LIST_HEAD(&nfit_dcr->list); + nfit_dcr->dcr = dcr; + list_add_tail(&nfit_dcr->list, &acpi_desc->dcrs); + dev_dbg(dev, "%s: dcr index: %d windows: %d\n", __func__, + dcr->region_index, dcr->windows); + return true; +} + +static bool add_bdw(struct acpi_nfit_desc *acpi_desc, + struct acpi_nfit_data_region *bdw) +{ + struct device *dev = acpi_desc->dev; + struct nfit_bdw *nfit_bdw = devm_kzalloc(dev, sizeof(*nfit_bdw), + GFP_KERNEL); + + if (!nfit_bdw) + return false; + INIT_LIST_HEAD(&nfit_bdw->list); + nfit_bdw->bdw = bdw; + list_add_tail(&nfit_bdw->list, &acpi_desc->bdws); + dev_dbg(dev, "%s: bdw dcr: %d windows: %d\n", __func__, + bdw->region_index, bdw->windows); + return true; +} + +static void *add_table(struct acpi_nfit_desc *acpi_desc, void *table, const void *end) +{ + struct device *dev = acpi_desc->dev; + struct acpi_nfit_header *hdr; + void *err = ERR_PTR(-ENOMEM); + + if (table >= end) + return NULL; + + hdr = table; + switch (hdr->type) { + case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: + if (!add_spa(acpi_desc, table)) + return err; + break; + case ACPI_NFIT_TYPE_MEMORY_MAP: + if (!add_memdev(acpi_desc, table)) + return err; + break; + case ACPI_NFIT_TYPE_CONTROL_REGION: + if (!add_dcr(acpi_desc, table)) + return err; + break; + case ACPI_NFIT_TYPE_DATA_REGION: + if (!add_bdw(acpi_desc, table)) + return err; + break; + /* TODO */ + case ACPI_NFIT_TYPE_INTERLEAVE: + dev_dbg(dev, "%s: idt\n", __func__); + break; + case ACPI_NFIT_TYPE_FLUSH_ADDRESS: + dev_dbg(dev, "%s: flush\n", __func__); + break; + case ACPI_NFIT_TYPE_SMBIOS: + dev_dbg(dev, "%s: smbios\n", __func__); + break; + default: + dev_err(dev, "unknown table '%d' parsing nfit\n", hdr->type); + break; + } + + return table + hdr->length; +} + +static void nfit_mem_find_spa_bdw(struct acpi_nfit_desc *acpi_desc, + struct nfit_mem *nfit_mem) +{ + u32 device_handle = __to_nfit_memdev(nfit_mem)->device_handle; + u16 dcr_index = nfit_mem->dcr->region_index; + struct nfit_spa *nfit_spa; + + list_for_each_entry(nfit_spa, &acpi_desc->spas, list) { + u16 range_index = nfit_spa->spa->range_index; + int type = nfit_spa_type(nfit_spa->spa); + struct nfit_memdev *nfit_memdev; + + if (type != NFIT_SPA_BDW) + continue; + + list_for_each_entry(nfit_memdev, &acpi_desc->memdevs, list) { + if (nfit_memdev->memdev->range_index != range_index) + continue; + if (nfit_memdev->memdev->device_handle != device_handle) + continue; + if (nfit_memdev->memdev->region_index != dcr_index) + continue; + + nfit_mem->spa_bdw = nfit_spa->spa; + return; + } + } + + dev_dbg(acpi_desc->dev, "SPA-BDW not found for SPA-DCR %d\n", + nfit_mem->spa_dcr->range_index); + nfit_mem->bdw = NULL; +} + +static int nfit_mem_add(struct acpi_nfit_desc *acpi_desc, + struct nfit_mem *nfit_mem, struct acpi_nfit_system_address *spa) +{ + u16 dcr_index = __to_nfit_memdev(nfit_mem)->region_index; + struct nfit_dcr *nfit_dcr; + struct nfit_bdw *nfit_bdw; + + list_for_each_entry(nfit_dcr, &acpi_desc->dcrs, list) { + if (nfit_dcr->dcr->region_index != dcr_index) + continue; + nfit_mem->dcr = nfit_dcr->dcr; + break; + } + + if (!nfit_mem->dcr) { + dev_dbg(acpi_desc->dev, "SPA %d missing:%s%s\n", spa->range_index, + __to_nfit_memdev(nfit_mem) ? "" : " MEMDEV", + nfit_mem->dcr ? "" : " DCR"); + return -ENODEV; + } + + /* + * We've found enough to create an nvdimm, optionally + * find an associated BDW + */ + list_add(&nfit_mem->list, &acpi_desc->dimms); + + list_for_each_entry(nfit_bdw, &acpi_desc->bdws, list) { + if (nfit_bdw->bdw->region_index != dcr_index) + continue; + nfit_mem->bdw = nfit_bdw->bdw; + break; + } + + if (!nfit_mem->bdw) + return 0; + + nfit_mem_find_spa_bdw(acpi_desc, nfit_mem); + return 0; +} + +static int nfit_mem_dcr_init(struct acpi_nfit_desc *acpi_desc, + struct acpi_nfit_system_address *spa) +{ + struct nfit_mem *nfit_mem, *found; + struct nfit_memdev *nfit_memdev; + int type = nfit_spa_type(spa); + u16 dcr_index; + + switch (type) { + case NFIT_SPA_DCR: + case NFIT_SPA_PM: + break; + default: + return 0; + } + + list_for_each_entry(nfit_memdev, &acpi_desc->memdevs, list) { + int rc; + + if (nfit_memdev->memdev->range_index != spa->range_index) + continue; + found = NULL; + dcr_index = nfit_memdev->memdev->region_index; + list_for_each_entry(nfit_mem, &acpi_desc->dimms, list) + if (__to_nfit_memdev(nfit_mem)->region_index == dcr_index) { + found = nfit_mem; + break; + } + + if (found) + nfit_mem = found; + else { + nfit_mem = devm_kzalloc(acpi_desc->dev, + sizeof(*nfit_mem), GFP_KERNEL); + if (!nfit_mem) + return -ENOMEM; + INIT_LIST_HEAD(&nfit_mem->list); + } + + if (type == NFIT_SPA_DCR) { + /* multiple dimms may share a SPA when interleaved */ + nfit_mem->spa_dcr = spa; + nfit_mem->memdev_dcr = nfit_memdev->memdev; + } else { + /* + * A single dimm may belong to multiple SPA-PM + * ranges, record at least one in addition to + * any SPA-DCR range. + */ + nfit_mem->memdev_pmem = nfit_memdev->memdev; + } + + if (found) + continue; + + rc = nfit_mem_add(acpi_desc, nfit_mem, spa); + if (rc) + return rc; + } + + return 0; +} + +static int nfit_mem_cmp(void *priv, struct list_head *__a, struct list_head *__b) +{ + struct nfit_mem *a = container_of(__a, typeof(*a), list); + struct nfit_mem *b = container_of(__b, typeof(*b), list); + u32 handleA, handleB; + + handleA = __to_nfit_memdev(a)->device_handle; + handleB = __to_nfit_memdev(b)->device_handle; + if (handleA < handleB) + return -1; + else if (handleA > handleB) + return 1; + return 0; +} + +static int nfit_mem_init(struct acpi_nfit_desc *acpi_desc) +{ + struct nfit_spa *nfit_spa; + + /* + * For each SPA-DCR or SPA-PMEM address range find its + * corresponding MEMDEV(s). From each MEMDEV find the + * corresponding DCR. Then, if we're operating on a SPA-DCR, + * try to find a SPA-BDW and a corresponding BDW that references + * the DCR. Throw it all into an nfit_mem object. Note, that + * BDWs are optional. + */ + list_for_each_entry(nfit_spa, &acpi_desc->spas, list) { + int rc; + + rc = nfit_mem_dcr_init(acpi_desc, nfit_spa->spa); + if (rc) + return rc; + } + + list_sort(NULL, &acpi_desc->dimms, nfit_mem_cmp); + + return 0; +} + +static int acpi_nfit_init(struct acpi_nfit_desc *acpi_desc, acpi_size sz) +{ + struct device *dev = acpi_desc->dev; + const void *end; + u8 *data; + + INIT_LIST_HEAD(&acpi_desc->spas); + INIT_LIST_HEAD(&acpi_desc->dcrs); + INIT_LIST_HEAD(&acpi_desc->bdws); + INIT_LIST_HEAD(&acpi_desc->memdevs); + INIT_LIST_HEAD(&acpi_desc->dimms); + + data = (u8 *) acpi_desc->nfit; + end = data + sz; + data += sizeof(struct acpi_table_nfit); + while (!IS_ERR_OR_NULL(data)) + data = add_table(acpi_desc, data, end); + + if (IS_ERR(data)) { + dev_dbg(dev, "%s: nfit table parsing error: %ld\n", __func__, + PTR_ERR(data)); + return PTR_ERR(data); + } + + if (nfit_mem_init(acpi_desc) != 0) + return -ENOMEM; + + return 0; +} + +static int acpi_nfit_add(struct acpi_device *adev) +{ + struct nvdimm_bus_descriptor *nd_desc; + struct acpi_nfit_desc *acpi_desc; + struct device *dev = &adev->dev; + struct acpi_table_header *tbl; + acpi_status status = AE_OK; + acpi_size sz; + int rc; + + status = acpi_get_table_with_size("NFIT", 0, &tbl, &sz); + if (ACPI_FAILURE(status)) { + dev_err(dev, "failed to find NFIT\n"); + return -ENXIO; + } + + acpi_desc = devm_kzalloc(dev, sizeof(*acpi_desc), GFP_KERNEL); + if (!acpi_desc) + return -ENOMEM; + + dev_set_drvdata(dev, acpi_desc); + acpi_desc->dev = dev; + acpi_desc->nfit = (struct acpi_table_nfit *) tbl; + nd_desc = &acpi_desc->nd_desc; + nd_desc->provider_name = "ACPI.NFIT"; + nd_desc->ndctl = acpi_nfit_ctl; + + acpi_desc->nvdimm_bus = nvdimm_bus_register(dev, nd_desc); + if (!acpi_desc->nvdimm_bus) + return -ENXIO; + + rc = acpi_nfit_init(acpi_desc, sz); + if (rc) { + nvdimm_bus_unregister(acpi_desc->nvdimm_bus); + return rc; + } + return 0; +} + +static int acpi_nfit_remove(struct acpi_device *adev) +{ + struct acpi_nfit_desc *acpi_desc = dev_get_drvdata(&adev->dev); + + nvdimm_bus_unregister(acpi_desc->nvdimm_bus); + return 0; +} + +static const struct acpi_device_id acpi_nfit_ids[] = { + { "ACPI0012", 0 }, + { "", 0 }, +}; +MODULE_DEVICE_TABLE(acpi, acpi_nfit_ids); + +static struct acpi_driver acpi_nfit_driver = { + .name = KBUILD_MODNAME, + .ids = acpi_nfit_ids, + .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, + .ops = { + .add = acpi_nfit_add, + .remove = acpi_nfit_remove, + }, +}; + +static __init int nfit_init(void) +{ + BUILD_BUG_ON(sizeof(struct acpi_table_nfit) != 40); + BUILD_BUG_ON(sizeof(struct acpi_nfit_system_address) != 56); + BUILD_BUG_ON(sizeof(struct acpi_nfit_memory_map) != 48); + BUILD_BUG_ON(sizeof(struct acpi_nfit_interleave) != 20); + BUILD_BUG_ON(sizeof(struct acpi_nfit_smbios) != 9); + BUILD_BUG_ON(sizeof(struct acpi_nfit_control_region) != 80); + BUILD_BUG_ON(sizeof(struct acpi_nfit_data_region) != 40); + + acpi_str_to_uuid(UUID_VOLATILE_MEMORY, nfit_uuid[NFIT_SPA_VOLATILE]); + acpi_str_to_uuid(UUID_PERSISTENT_MEMORY, nfit_uuid[NFIT_SPA_PM]); + acpi_str_to_uuid(UUID_CONTROL_REGION, nfit_uuid[NFIT_SPA_DCR]); + acpi_str_to_uuid(UUID_DATA_REGION, nfit_uuid[NFIT_SPA_BDW]); + acpi_str_to_uuid(UUID_VOLATILE_VIRTUAL_DISK, nfit_uuid[NFIT_SPA_VDISK]); + acpi_str_to_uuid(UUID_VOLATILE_VIRTUAL_CD, nfit_uuid[NFIT_SPA_VCD]); + acpi_str_to_uuid(UUID_PERSISTENT_VIRTUAL_DISK, nfit_uuid[NFIT_SPA_PDISK]); + acpi_str_to_uuid(UUID_PERSISTENT_VIRTUAL_CD, nfit_uuid[NFIT_SPA_PCD]); + acpi_str_to_uuid(UUID_NFIT_BUS, nfit_uuid[NFIT_DEV_BUS]); + acpi_str_to_uuid(UUID_NFIT_DIMM, nfit_uuid[NFIT_DEV_DIMM]); + + return acpi_bus_register_driver(&acpi_nfit_driver); +} + +static __exit void nfit_exit(void) +{ + acpi_bus_unregister_driver(&acpi_nfit_driver); +} + +module_init(nfit_init); +module_exit(nfit_exit); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Intel Corporation"); diff --git a/drivers/acpi/nfit.h b/drivers/acpi/nfit.h new file mode 100644 index 000000000000..2d98cc1b7b6c --- /dev/null +++ b/drivers/acpi/nfit.h @@ -0,0 +1,89 @@ +/* + * NVDIMM Firmware Interface Table - NFIT + * + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that 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 __NFIT_H__ +#define __NFIT_H__ +#include +#include +#include +#include +#include + +#define UUID_NFIT_BUS "2f10e7a4-9e91-11e4-89d3-123b93f75cba" +#define UUID_NFIT_DIMM "4309ac30-0d11-11e4-9191-0800200c9a66" + +enum nfit_uuids { + NFIT_SPA_VOLATILE, + NFIT_SPA_PM, + NFIT_SPA_DCR, + NFIT_SPA_BDW, + NFIT_SPA_VDISK, + NFIT_SPA_VCD, + NFIT_SPA_PDISK, + NFIT_SPA_PCD, + NFIT_DEV_BUS, + NFIT_DEV_DIMM, + NFIT_UUID_MAX, +}; + +struct nfit_spa { + struct acpi_nfit_system_address *spa; + struct list_head list; +}; + +struct nfit_dcr { + struct acpi_nfit_control_region *dcr; + struct list_head list; +}; + +struct nfit_bdw { + struct acpi_nfit_data_region *bdw; + struct list_head list; +}; + +struct nfit_memdev { + struct acpi_nfit_memory_map *memdev; + struct list_head list; +}; + +/* assembled tables for a given dimm/memory-device */ +struct nfit_mem { + struct acpi_nfit_memory_map *memdev_dcr; + struct acpi_nfit_memory_map *memdev_pmem; + struct acpi_nfit_control_region *dcr; + struct acpi_nfit_data_region *bdw; + struct acpi_nfit_system_address *spa_dcr; + struct acpi_nfit_system_address *spa_bdw; + struct list_head list; +}; + +struct acpi_nfit_desc { + struct nvdimm_bus_descriptor nd_desc; + struct acpi_table_nfit *nfit; + struct list_head memdevs; + struct list_head dimms; + struct list_head spas; + struct list_head dcrs; + struct list_head bdws; + struct nvdimm_bus *nvdimm_bus; + struct device *dev; +}; + +static inline struct acpi_nfit_memory_map *__to_nfit_memdev(struct nfit_mem *nfit_mem) +{ + if (nfit_mem->memdev_dcr) + return nfit_mem->memdev_dcr; + return nfit_mem->memdev_pmem; +} +#endif /* __NFIT_H__ */ diff --git a/drivers/nvdimm/Kconfig b/drivers/nvdimm/Kconfig new file mode 100644 index 000000000000..4f2291938ea0 --- /dev/null +++ b/drivers/nvdimm/Kconfig @@ -0,0 +1,13 @@ +config LIBNVDIMM + tristate "NVDIMM (Non-Volatile Memory Device) Support" + help + Generic support for non-volatile memory devices including + ACPI-6-NFIT defined resources. On platforms that define an + NFIT, or otherwise can discover NVDIMM resources, a libnvdimm + bus is registered to advertise PMEM (persistent memory) + namespaces (/dev/pmemX) and BLK (sliding mmio window(s)) + namespaces (/dev/ndX). A PMEM namespace refers to a memory + resource that may span multiple DIMMs and support DAX (see + CONFIG_DAX). A BLK namespace refers to an NVDIMM control + region which exposes an mmio register set for windowed + access mode to non-volatile memory. diff --git a/drivers/nvdimm/Makefile b/drivers/nvdimm/Makefile new file mode 100644 index 000000000000..10bc7af47992 --- /dev/null +++ b/drivers/nvdimm/Makefile @@ -0,0 +1,3 @@ +obj-$(CONFIG_LIBNVDIMM) += libnvdimm.o + +libnvdimm-y := core.o diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c new file mode 100644 index 000000000000..5ccd500ffd4f --- /dev/null +++ b/drivers/nvdimm/core.c @@ -0,0 +1,67 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that 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. + */ +#include +#include +#include +#include +#include +#include "nd-core.h" + +static DEFINE_IDA(nd_ida); + +static void nvdimm_bus_release(struct device *dev) +{ + struct nvdimm_bus *nvdimm_bus = container_of(dev, struct nvdimm_bus, dev); + + ida_simple_remove(&nd_ida, nvdimm_bus->id); + kfree(nvdimm_bus); +} + +struct nvdimm_bus *nvdimm_bus_register(struct device *parent, + struct nvdimm_bus_descriptor *nd_desc) +{ + struct nvdimm_bus *nvdimm_bus = kzalloc(sizeof(*nvdimm_bus), GFP_KERNEL); + int rc; + + if (!nvdimm_bus) + return NULL; + nvdimm_bus->id = ida_simple_get(&nd_ida, 0, 0, GFP_KERNEL); + if (nvdimm_bus->id < 0) { + kfree(nvdimm_bus); + return NULL; + } + nvdimm_bus->nd_desc = nd_desc; + nvdimm_bus->dev.parent = parent; + nvdimm_bus->dev.release = nvdimm_bus_release; + dev_set_name(&nvdimm_bus->dev, "ndbus%d", nvdimm_bus->id); + rc = device_register(&nvdimm_bus->dev); + if (rc) { + dev_dbg(&nvdimm_bus->dev, "device registration failed: %d\n", rc); + put_device(&nvdimm_bus->dev); + return NULL; + } + + return nvdimm_bus; +} +EXPORT_SYMBOL_GPL(nvdimm_bus_register); + +void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus) +{ + if (!nvdimm_bus) + return; + device_unregister(&nvdimm_bus->dev); +} +EXPORT_SYMBOL_GPL(nvdimm_bus_unregister); + +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Intel Corporation"); diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h new file mode 100644 index 000000000000..e7c4e99a22a4 --- /dev/null +++ b/drivers/nvdimm/nd-core.h @@ -0,0 +1,23 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that 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 __ND_PRIVATE_H__ +#define __ND_PRIVATE_H__ +#include +#include + +struct nvdimm_bus { + struct nvdimm_bus_descriptor *nd_desc; + struct device dev; + int id; +}; +#endif /* __ND_PRIVATE_H__ */ diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h new file mode 100644 index 000000000000..2b3c63950c91 --- /dev/null +++ b/include/linux/libnvdimm.h @@ -0,0 +1,34 @@ +/* + * libnvdimm - Non-volatile-memory Devices Subsystem + * + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that 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 __LIBNVDIMM_H__ +#define __LIBNVDIMM_H__ +struct nvdimm; +struct nvdimm_bus_descriptor; +typedef int (*ndctl_fn)(struct nvdimm_bus_descriptor *nd_desc, + struct nvdimm *nvdimm, unsigned int cmd, void *buf, + unsigned int buf_len); + +struct nvdimm_bus_descriptor { + unsigned long dsm_mask; + char *provider_name; + ndctl_fn ndctl; +}; + +struct device; +struct nvdimm_bus; +struct nvdimm_bus *nvdimm_bus_register(struct device *parent, + struct nvdimm_bus_descriptor *nfit_desc); +void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus); +#endif /* __LIBNVDIMM_H__ */ {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I