From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?Q?C=c3=a9dric_Le_Goater?= Subject: Re: [PATCH v2 1/3] ipmi: add an Aspeed BT IPMI BMC driver Date: Mon, 19 Sep 2016 10:00:27 +0200 Message-ID: <9ce54c4c-e8ae-7ac2-de9c-71402dfa4c39@kaod.org> References: <1474022367-21029-1-git-send-email-clg@kaod.org> <1474022367-21029-2-git-send-email-clg@kaod.org> <08e9b30f-6c35-8418-a8b0-0b63639dd36d@acm.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <08e9b30f-6c35-8418-a8b0-0b63639dd36d@acm.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: minyard@acm.org, openipmi-developer@lists.sourceforge.net, Joel Stanley Cc: Mark Rutland , devicetree@vger.kernel.org, Arnd Bergmann , Alistair Popple , Russell King , Rob Herring , Jeremy Kerr , Rocky Craig , linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org T24gMDkvMTYvMjAxNiAwOTo0MSBQTSwgQ29yZXkgTWlueWFyZCB3cm90ZToKPiBPbiAwOS8xNi8y MDE2IDA1OjM5IEFNLCBDw6lkcmljIExlIEdvYXRlciB3cm90ZToKPj4gRnJvbTogQWxpc3RhaXIg UG9wcGxlIDxhbGlzdGFpckBwb3BwbGUuaWQuYXU+Cj4+Cj4+IFRoaXMgcGF0Y2ggYWRkcyBhIHNp bXBsZSBkZXZpY2UgZHJpdmVyIHRvIGV4cG9zZSB0aGUgaUJUIGludGVyZmFjZSBvbgo+PiBBc3Bl ZWQgU09DcyAoQVNUMjQwMCBhbmQgQVNUMjUwMCkgYXMgYSBjaGFyYWN0ZXIgZGV2aWNlLiBTdWNo IFNPQ3MgYXJlCj4+IGNvbW1vbmx5IHVzZWQgYXMgQk1DcyAoQmFzZUJvYXJkIE1hbmFnZW1lbnQg Q29udHJvbGxlcnMpIGFuZCB0aGlzCj4+IGRyaXZlciBpbXBsZW1lbnRzIHRoZSBCTUMgc2lkZSBv ZiB0aGUgQlQgaW50ZXJmYWNlLgo+Pgo+PiBUaGUgQlQgKEJsb2NrIFRyYW5zZmVyKSBpbnRlcmZh Y2UgaXMgdXNlZCB0byBwZXJmb3JtIGluLWJhbmQgSVBNSQo+PiBjb21tdW5pY2F0aW9uIGJldHdl ZW4gYSBob3N0IGFuZCBpdHMgQk1DLiBFbnRpcmUgbWVzc2FnZXMgYXJlIGJ1ZmZlcmVkCj4+IGJl Zm9yZSBzZW5kaW5nIGEgbm90aWZpY2F0aW9uIHRvIHRoZSBvdGhlciBlbmQsIGhvc3Qgb3IgQk1D LCB0aGF0Cj4+IHRoZXJlIGlzIGRhdGEgdG8gYmUgcmVhZC4gVXN1YWxseSwgdGhlIGhvc3QgZW1p dHMgcmVxdWVzdHMgYW5kIHRoZSBCTUMKPj4gcmVzcG9uc2VzIGJ1dCB0aGUgc3BlY2lmaWNhdGlv biBwcm92aWRlcyBhIG1lYW4gZm9yIHRoZSBCTUMgdG8gc2VuZAo+PiBTTVMgQXR0ZW50aW9uIChC TUMtdG8tSG9zdCBhdHRlbnRpb24gb3IgU3lzdGVtIE1hbmFnZW1lbnQgU29mdHdhcmUKPj4gYXR0 ZW50aW9uKSBtZXNzYWdlcy4KPj4KPj4gRm9yIHRoaXMgcHVycG9zZSwgdGhlIGRyaXZlciBpbnRy b2R1Y2VzIGEgc3BlY2lmaWMgaW9jdGwgb24gdGhlCj4+IGRldmljZTogJ0JUX0JNQ19JT0NUTF9T TVNfQVROJyB0aGF0IGNhbiBiZSB1c2VkIGJ5IHRoZSBzeXN0ZW0gcnVubmluZwo+PiBvbiB0aGUg Qk1DIHRvIHNpZ25hbCB0aGUgaG9zdCBvZiBzdWNoIGFuIGV2ZW50Lgo+Pgo+PiBUaGUgZGV2aWNl IG5hbWUgZGVmYXVsdHMgdG8gJy9kZXYvaXBtaS1idC1ob3N0Jwo+IAo+IE90aGVycyBoYXZlIHJl dmlld2VkIHRoaXMgZm9yIHN0eWxlIGFuZCBzdWNoLCBhbmQgSSBoYXZlIGxvb2tlZAo+IGF0IGl0 IGZyb20gYSBwcm90b2NvbCBwb2ludCBvZiB2aWV3LiAgaXQgbG9va3MgdG8gYmUgc291bmQgZm9y IHRoZQo+IG1vc3QgcGFydC4gIEkgaGF2ZSBzb21lIGhpZ2hlciBsZXZlbCBjb25jZXJuczoKPiAK PiBUaGVyZSBhcHBlYXJzIHRvIGJlIG5vIGhhbmRsaW5nIGZvciBtdWx0aXBsZSBzaW11bHRhbmVv dXMgdXNlcnMuCj4gVGhpcyBpbnRlcmZhY2UgY2FuIG9ubHkgYmUgdXNlZCBieSBvbmUgdGFzayBh dCBhIHRpbWUsIHNvIHlvdSBzaG91bGQKPiBwcm9iYWJseSBvbmx5IGFsbG93IG9uZSBvcGVuZXIu ICBXZWxsLCBJIGd1ZXNzIHRoZSBCTUMgY291bGQgYmUgc3BsaXQKPiBpbnRvIGEgcmVhZGVyIGFu ZCBhIHdyaXRlciB0YXNrLCBzbyBJJ20gbm90IHJlYWxseSBzdXJlIGFib3V0IHRoYXQsIGJ1dAo+ IEkgd291bGQgdGhpbmsgaW4gbW9zdCBzaXR1YXRpb25zIGhhdmluZyBtb3JlIHRoYW4gb25lIG9w ZW5lciBpcyBhCj4gYnVnLiAgWW91IGRvIGNhbGwgY2xyX2JfYnVzeSgpIG9uIG9wZW4sIGZvciBp bnN0YW5jZSwgd2hpY2ggbWlnaHQgYmUKPiBhbiBpc3N1ZSBmb3IgbXVsdGlwbGUgb3BlbmVycy4g IE1heWJlIGEgbW9kdWxlIHBhcmFtZXRlciBmb3IKPiBtYXhpbXVtIG51bWJlciBvZiBvcGVuZXJz PyBKdXN0IHdhbnQgdG8gbWFrZSBzdXJlIHRoaXMgd2FzCj4gdGhvdWdodCBhYm91dCwgYXQgbGVh c3QuCgp5ZXMgYnV0IG5vdCBpbXBsZW1lbnRlZCAuLi4gVGhlIG9wZW5fY291bnQgaW4gdGhlIGJ0 X2JtYyBzdHJ1Y3R1cmUgCmlzIHVudXNlZC4gSW4gdjMsIEkgd2lsbCByZXBsYWNlIGl0IHdpdGgg YSBnbG9iYWwgYXRvbWljX3QgdHJhY2tlZCAKaW4gdGhlIG9wZW4gYW5kIHJlbGVhc2Ugb3BlcmF0 aW9ucy4gCgo+IFRoZXJlIGlzIGFsc28gbm8gbXV0ZXggcHJvdGVjdGluZyByZWFkaW5nIG9yIHdy aXRpbmcuICBJZiBtdWx0aXBsZQo+IHRocmVhZHMgY2FsbCByZWFkIG9yIHdyaXRlIGF0IHRoZSBz YW1lIHRpbWUsIGl0IHByb2JhYmx5IHdvdWxkbid0Cj4gd29yayBjb3JyZWN0bHkuICBJIHRoaW5r IHlvdSBuZWVkIGEgcmVhZCBhbmQgYSB3cml0ZSBtdXRleCBvbiB0aGUKPiBpbnRlcmZhY2UgdG8g cHJvdGVjdCBhZ2FpbnN0IHRoaXMuCgp5ZXMuIEkgd2lsbCBhZGQgYSBtdXRleCBhbHNvIGluIHYz LgoKPiBUaGUgc3BlYyBzYXlzOgo+IAo+ICAgIFRoZSBCTUMgbXVzdCBub3QgcmV0dXJuIGEgZ2l2 ZW4gcmVzcG9uc2Ugb25jZSB0aGUgY29ycmVzcG9uZGluZwo+ICAgIFJlcXVlc3QtdG8tUmVzcG9u c2UgaW50ZXJ2YWwgaGFzIHBhc3NlZC4gVGhlIEJNQyBjYW4gZW5zdXJlIHRoaXMKPiAgICBieSBt YWludGFpbmluZyBpdHMgb3duIGludGVybmFsIGxpc3Qgb2Ygb3V0c3RhbmRpbmcgcmVxdWVzdHMg dGhyb3VnaAo+ICAgIHRoZSBpbnRlcmZhY2UuIFRoZSBCTUMgY291bGQgYWdlIGFuZCBleHBpcmUg dGhlIGVudHJpZXMgaW4gdGhlIGxpc3QKPiAgICBieSBleHBpcmluZyB0aGUgZW50cmllcyBhdCBh biBpbnRlcnZhbCB0aGF0IGlzIHNvbWV3aGF0IHNob3J0ZXIgdGhhbgo+ICAgIHRoZSBzcGVjaWZp ZWQgUmVxdWVzdC10by1SZXNwb25zZSBpbnRlcnZhbC4uLi4KClRoaXMgaXMgY2xlYXJseSBub3Qg aGFuZGxlZCBpbiB0aGUgZHJpdmVyLiAKCkZvciB0aGlzIHB1cnBvc2UsIHdlIGNvdWxkIG1haW50 YWluIGEgcmVxdWVzdCBleHBpcnkgbGlzdCB1c2luZyB0aGUgc2VxIApmaWVsZCBvZiB0aGUgQlQg bWVzc2FnZS4gVXBkYXRlIHRoZSBsaXN0IGluIHRoZSByZWFkIGFuZCB3cml0ZSBvcGVyYXRpb25z IAphbmQgYXJtIGEgdGltZXIgdG8gZ2FyYmFnZSBjb2xsZWN0IGFueSBsZWZ0IG92ZXJzLiBBcyBm b3IgdGhlIGVycm5vIGluCnRoZSB3cml0ZSB3aGVuIGEgcmVzcG9uc2UgaGFkIHRpbWVvdXQnZWQs IG1heSBiZSBFVElNRURPVVQgPyAKCkZvciBjb25maWd1cmF0aW9uIG9mIHRoZSBtYXhpbXVtIHJl c3BvbnNlIHRpbWUsIGEgc3lzZnMgZmlsZSB3b3VsZCBkbwpJIHRoaW5rLgoKRG8geW91IHdhbnQg dGhhdCBpbiB2MyBhbHNvID8gSSBoYXZlIHNvbWUgZXhwZXJpbWVudGFsIHBhdGNoZXMgZm9yIGl0 LAp0aGF0IEkgY2FuIHNlbmQgYXMgZm9sbG93IHVwcy4KClRoYW5rcywKCkMuIAoKPiBPbiB0aGUg d3JpdGUgc2lkZSwgdGhvdWdoLCB0aGVyZSBkb2Vzbid0IHNlZW0gdG8gYmUgYSB3YXkgdG8gaGFu ZGxlIGEKPiBzaXR1YXRpb24gd2hlcmUgdGhlIGhvc3Qgc2lkZSBkb2Vzbid0IHJlc3BvbmQgZm9y IGEgd2hpbGUgYW5kIHRoZQo+IHBlbmRpbmcgbWVzc2FnZSB3b3VsZCBuZWVkIHRvIGJlIGRpc2Nh cmRlZC4KPiAKPiBUaGUgc3BlYyBkb2Vzbid0IG1lbnRpb24gbXVjaCBhYm91dCBlcnJvciByZWNv dmVyeSBvbiB0aGlzIGludGVyZmFjZSwKPiBidXQgdGhlIHdheSB0aGlzIGlzIHdyaXR0ZW4gc2hv dWxkIGJlIGZpbmUsIEkgdGhpbmsuCj4gCj4gSSdtIGNvcHlpbmcgUm9ja3kgQ3JhaWcsIHdobyB3 cm90ZSB0aGUgaG9zdCBzaWRlIGRyaXZlciBmb3IgTGludXgsIGluCj4gY2FzZSBoZSB3YW50cyB0 byBjb21tZW50IG9uIHRoaXMuCj4gCj4gVGhpcyBpcyBlYXN5IHRvIHJlYWQgYW5kIHVuZGVyc3Rh bmQsIHNvIEkgdGhpbmsgdjMgc2hvdWxkIGJlIGdvb2QuCj4gCj4gVGhhbmtzLAo+IAo+IC1jb3Jl eQo+IAo+PiBTaWduZWQtb2ZmLWJ5OiBBbGlzdGFpciBQb3BwbGUgPGFsaXN0YWlyQHBvcHBsZS5p ZC5hdT4KPj4gU2lnbmVkLW9mZi1ieTogSmVyZW15IEtlcnIgPGprQG96bGFicy5vcmc+Cj4+IFNp Z25lZC1vZmYtYnk6IEpvZWwgU3RhbmxleSA8am9lbEBqbXMuaWQuYXU+Cj4+IFtjbGc6IC0gY2hl Y2twYXRjaCBmaXhlcwo+PiAgICAgICAgLSBhZGRlZCBhIGRldmljZXRyZWUgYmluZGluZyBkb2N1 bWVudGF0aW9uCj4+ICAgICAgICAtIHJlcGxhY2UgJ2J0X2hvc3QnIGJ5ICdidF9ibWMnIHRvIHJl ZmxlY3QgdGhhdCB0aGUgZHJpdmVyIGlzCj4+ICAgICAgICAgIHRoZSBCTUMgc2lkZSBvZiB0aGUg SVBNSSBCVCBpbnRlcmZhY2UKPj4gICAgICAgIC0gcmVuYW1lZCB0aGUgZGV2aWNlIHRvICdpcG1p LWJ0LWhvc3QnCj4+ICAgICAgICAtIGludHJvZHVjZWQgYSB0ZW1wb3JhcnkgYnVmZmVyIHRvIGNv cHlfe3RvLGZyb219X3VzZXIKPj4gICAgICAgIC0gdXNlZCBwbGF0Zm9ybV9nZXRfaXJxKCkKPj4g ICAgICAgIC0gbW92ZWQgdGhlIGRyaXZlciB1bmRlciBkcml2ZXJzL2NoYXIvaXBtaS8gYnV0IGtl cHQgaXQgYXMgYSBtaXNjCj4+ICAgICAgICAgIGRldmljZQo+PiAgICAgICAgLSBjaGFuZ2VkIHRo ZSBjb21wYXRpYmxlIGNlbGwgdG8gImFzcGVlZCxhc3QyNDAwLWJ0LWJtYyIKPj4gXQo+PiBTaWdu ZWQtb2ZmLWJ5OiBDw6lkcmljIExlIEdvYXRlciA8Y2xnQGthb2Qub3JnPgo+PiAtLS0KPj4KPj4g ICBDaGFuZ2VzIHNpbmNlIHYxOgo+Pgo+PiAgIC0gcmVwbGFjZSAnYnRfaG9zdCcgYnkgJ2J0X2Jt YycgdG8gcmVmbGVjdCB0aGF0IHRoZSBkcml2ZXIgaXMKPj4gICAgIHRoZSBCTUMgc2lkZSBvZiB0 aGUgSVBNSSBCVCBpbnRlcmZhY2UKPj4gICAtIHJlbmFtZWQgdGhlIGRldmljZSB0byAnaXBtaS1i dC1ob3N0Jwo+PiAgIC0gaW50cm9kdWNlZCBhIHRlbXBvcmFyeSBidWZmZXIgdG8gY29weV97dG8s ZnJvbX1fdXNlcgo+PiAgIC0gdXNlZCBwbGF0Zm9ybV9nZXRfaXJxKCkKPj4gICAtIG1vdmVkIHRo ZSBkcml2ZXIgdW5kZXIgZHJpdmVycy9jaGFyL2lwbWkvIGJ1dCBrZXB0IGl0IGFzIGEgbWlzYwo+ PiAgICAgZGV2aWNlCj4+ICAgLSBjaGFuZ2VkIHRoZSBjb21wYXRpYmxlIGNlbGwgdG8gImFzcGVl ZCxhc3QyNDAwLWJ0LWJtYyIKPj4KPj4gICAuLi4vYmluZGluZ3MvY2hhci9pcG1pL2FzcGVlZCxh c3QyNDAwLWJ0LWJtYy50eHQgICB8ICAyMyArCj4+ICAgZHJpdmVycy9NYWtlZmlsZSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKy0KPj4gICBkcml2ZXJzL2NoYXIvaXBt aS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNyArCj4+ICAgZHJpdmVycy9j aGFyL2lwbWkvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+PiAgIGRy aXZlcnMvY2hhci9pcG1pL2J0LWJtYy5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgNDg2ICsr KysrKysrKysrKysrKysrKysrKwo+PiAgIGluY2x1ZGUvdWFwaS9saW51eC9LYnVpbGQgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAxICsKPj4gICBpbmNsdWRlL3VhcGkvbGludXgvYnQtYm1j LmggICAgICAgICAgICAgICAgICAgICAgICB8ICAxOCArCj4+ICAgNyBmaWxlcyBjaGFuZ2VkLCA1 MzcgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBE b2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY2hhci9pcG1pL2FzcGVlZCxhc3QyNDAw LWJ0LWJtYy50eHQKPj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9jaGFyL2lwbWkvYnQt Ym1jLmMKPj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS91YXBpL2xpbnV4L2J0LWJtYy5o Cj4+Cj4+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY2hh ci9pcG1pL2FzcGVlZCxhc3QyNDAwLWJ0LWJtYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRy ZWUvYmluZGluZ3MvY2hhci9pcG1pL2FzcGVlZCxhc3QyNDAwLWJ0LWJtYy50eHQKPj4gbmV3IGZp bGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAwMDAwMDAwLi5mYmJhY2Q5NTgyNDAKPj4gLS0t IC9kZXYvbnVsbAo+PiArKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvY2hh ci9pcG1pL2FzcGVlZCxhc3QyNDAwLWJ0LWJtYy50eHQKPj4gQEAgLTAsMCArMSwyMyBAQAo+PiAr KiBBc3BlZWQgQlQgKEJsb2NrIFRyYW5zZmVyKSBJUE1JIGludGVyZmFjZQo+PiArCj4+ICtUaGUg QXNwZWVkIFNPQ3MgKEFTVDI0MDAgYW5kIEFTVDI1MDApIGFyZSBjb21tb25seSB1c2VkIGFzIEJN Q3MKPj4gKyhCYXNlQm9hcmQgTWFuYWdlbWVudCBDb250cm9sbGVycykgYW5kIHRoZSBCVCBpbnRl cmZhY2UgY2FuIGJlIHVzZWQgdG8KPj4gK3BlcmZvcm0gaW4tYmFuZCBJUE1JIGNvbW11bmljYXRp b24gd2l0aCB0aGVpciBob3N0Lgo+PiArCj4+ICtSZXF1aXJlZCBwcm9wZXJ0aWVzOgo+PiArCj4+ ICstIGNvbXBhdGlibGUgOiBzaG91bGQgYmUgImFzcGVlZCxhc3QyNDAwLWJ0LWJtYyIKPj4gKy0g cmVnOiBwaHlzaWNhbCBhZGRyZXNzIGFuZCBzaXplIG9mIHRoZSByZWdpc3RlcnMKPj4gKwo+PiAr T3B0aW9uYWwgcHJvcGVydGllczoKPj4gKwo+PiArLSBpbnRlcnJ1cHRzOiBpbnRlcnJ1cHQgZ2Vu ZXJhdGVkIGJ5IHRoZSBCVCBpbnRlcmZhY2UuIHdpdGhvdXQgYW4KPj4gKyAgaW50ZXJydXB0LCB0 aGUgZHJpdmVyIHdpbGwgb3BlcmF0ZSBpbiBwb2xsIG1vZGUuCj4+ICsKPj4gK0V4YW1wbGU6Cj4+ ICsKPj4gKyAgICBpYnRAMWU3ODkxNDAgewo+PiArICAgICAgICBjb21wYXRpYmxlID0gImFzcGVl ZCxhc3QyNDAwLWJ0LWJtYyI7Cj4+ICsgICAgICAgIHJlZyA9IDwweDFlNzg5MTQwIDB4MTg+Owo+ PiArICAgICAgICBpbnRlcnJ1cHRzID0gPDg+Owo+PiArICAgIH07Cj4+IGRpZmYgLS1naXQgYS9k cml2ZXJzL01ha2VmaWxlIGIvZHJpdmVycy9NYWtlZmlsZQo+PiBpbmRleCA1M2FiYjRhNWY3MzYu LjVhOWU3YjZiNzkyOCAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy9NYWtlZmlsZQo+PiArKysgYi9k cml2ZXJzL01ha2VmaWxlCj4+IEBAIC0yMSw3ICsyMSw3IEBAIG9iai15ICAgICAgICAgICAgICAg ICs9IHZpZGVvLwo+PiAgIG9iai15ICAgICAgICAgICAgICAgICs9IGlkbGUvCj4+ICAgICAjIElQ TUkgbXVzdCBjb21lIGJlZm9yZSBBQ1BJIGluIG9yZGVyIHRvIHByb3ZpZGUgSVBNSSBvcHJlZ2lv biBzdXBwb3J0Cj4+IC1vYmotJChDT05GSUdfSVBNSV9IQU5ETEVSKSAgICArPSBjaGFyL2lwbWkv Cj4+ICtvYmoteSAgICAgICAgICAgICAgICArPSBjaGFyL2lwbWkvCj4+ICAgICBvYmotJChDT05G SUdfQUNQSSkgICAgICAgICs9IGFjcGkvCj4+ICAgb2JqLSQoQ09ORklHX1NGSSkgICAgICAgICs9 IHNmaS8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9pcG1pL0tjb25maWcgYi9kcml2ZXJz L2NoYXIvaXBtaS9LY29uZmlnCj4+IGluZGV4IDVhOTM1MGIxMDY5YS4uMmMyMzRlM2U3NTEzIDEw MDY0NAo+PiAtLS0gYS9kcml2ZXJzL2NoYXIvaXBtaS9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMv Y2hhci9pcG1pL0tjb25maWcKPj4gQEAgLTc2LDMgKzc2LDEwIEBAIGNvbmZpZyBJUE1JX1BPV0VS T0ZGCj4+ICAgICAgICB0aGUgSVBNSSBtYW5hZ2VtZW50IGNvbnRyb2xsZXIgaXMgY2FwYWJsZSBv ZiB0aGlzLgo+PiAgICAgZW5kaWYgIyBJUE1JX0hBTkRMRVIKPj4gKwo+PiArY29uZmlnIEFTUEVF RF9CVF9JUE1JX0JNQwo+PiArICAgIHRyaXN0YXRlICJCVCBJUE1JIGJtYyBkcml2ZXIiCj4+ICsg ICAgaGVscAo+PiArICAgICAgUHJvdmlkZXMgYSBkcml2ZXIgZm9yIHRoZSBCVCAoQmxvY2sgVHJh bnNmZXIpIElQTUkgaW50ZXJmYWNlCj4+ICsgICAgICBmb3VuZCBvbiBBc3BlZWQgU09DcyAoQVNU MjQwMCBhbmQgQVNUMjUwMCkuIFRoZSBkcml2ZXIKPj4gKyAgICAgIGltcGxlbWVudHMgdGhlIEJN QyBzaWRlIG9mIHRoZSBCVCBpbnRlcmZhY2UuCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIv aXBtaS9NYWtlZmlsZSBiL2RyaXZlcnMvY2hhci9pcG1pL01ha2VmaWxlCj4+IGluZGV4IGYzZmZk ZTFmNWYxZi4uMGQ5OGNkOTFkZWYxIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2NoYXIvaXBtaS9N YWtlZmlsZQo+PiArKysgYi9kcml2ZXJzL2NoYXIvaXBtaS9NYWtlZmlsZQo+PiBAQCAtMTEsMyAr MTEsNCBAQCBvYmotJChDT05GSUdfSVBNSV9TU0lGKSArPSBpcG1pX3NzaWYubwo+PiAgIG9iai0k KENPTkZJR19JUE1JX1BPV0VSTlYpICs9IGlwbWlfcG93ZXJudi5vCj4+ICAgb2JqLSQoQ09ORklH X0lQTUlfV0FUQ0hET0cpICs9IGlwbWlfd2F0Y2hkb2cubwo+PiAgIG9iai0kKENPTkZJR19JUE1J X1BPV0VST0ZGKSArPSBpcG1pX3Bvd2Vyb2ZmLm8KPj4gK29iai0kKENPTkZJR19BU1BFRURfQlRf SVBNSV9CTUMpICs9IGJ0LWJtYy5vCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaXBtaS9i dC1ibWMuYyBiL2RyaXZlcnMvY2hhci9pcG1pL2J0LWJtYy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAw NjQ0Cj4+IGluZGV4IDAwMDAwMDAwMDAwMC4uYjk2Y2I0MjFlMWMyCj4+IC0tLSAvZGV2L251bGwK Pj4gKysrIGIvZHJpdmVycy9jaGFyL2lwbWkvYnQtYm1jLmMKPj4gQEAgLTAsMCArMSw0ODYgQEAK Pj4gKy8qCj4+ICsgKiBDb3B5cmlnaHQgKGMpIDIwMTUtMjAxNiwgSUJNIENvcnBvcmF0aW9uLgo+ PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKPj4gKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCj4+ICsgKiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24KPj4gKyAqIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCj4+ICsgKi8KPj4g Kwo+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVs ZXBhcmFtLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KPj4gKyNpbmNsdWRlIDxsaW51 eC9wb2xsLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KPj4gKyNpbmNsdWRlIDxsaW51 eC9zcGlubG9jay5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRlIDxs aW51eC9pbml0Lmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+Cj4+ICsjaW5jbHVkZSA8 bGludXgvb2YuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9vZl9pcnEuaD4KPj4gKyNpbmNsdWRlIDxs aW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9pby5oPgo+PiArI2lu Y2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Cj4+ ICsjaW5jbHVkZSA8bGludXgvbWlzY2RldmljZS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3RpbWVy Lmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2J0 LWJtYy5oPgo+PiArCj4+ICsvKgo+PiArICogVGhpcyBpcyBhIEJNQyBkZXZpY2UgdXNlZCB0byBj b21tdW5pY2F0ZSB0byB0aGUgaG9zdAo+PiArICovCj4+ICsjZGVmaW5lIERFVklDRV9OQU1FICAg ICJpcG1pLWJ0LWhvc3QiCj4+ICsKPj4gKyNkZWZpbmUgQlRfSU9fQkFTRSAgICAweGU0Cj4+ICsj ZGVmaW5lIEJUX0lSUSAgICAgICAgMTAKPj4gKwo+PiArI2RlZmluZSBCVF9DUjAgICAgICAgIDB4 MAo+PiArI2RlZmluZSAgIEJUX0NSMF9JT19CQVNFICAgICAgICAxNgo+PiArI2RlZmluZSAgIEJU X0NSMF9JUlEgICAgICAgICAgICAxMgo+PiArI2RlZmluZSAgIEJUX0NSMF9FTl9DTFJfU0xWX1JE UCAgICAgICAgMHg4Cj4+ICsjZGVmaW5lICAgQlRfQ1IwX0VOX0NMUl9TTFZfV1JQICAgICAgICAw eDQKPj4gKyNkZWZpbmUgICBCVF9DUjBfRU5BQkxFX0lCVCAgICAgICAgMHgxCj4+ICsjZGVmaW5l IEJUX0NSMSAgICAgICAgMHg0Cj4+ICsjZGVmaW5lICAgQlRfQ1IxX0lSUV9IMkIgICAgMHgwMQo+ PiArI2RlZmluZSAgIEJUX0NSMV9JUlFfSEJVU1kgICAgMHg0MAo+PiArI2RlZmluZSBCVF9DUjIg ICAgICAgIDB4OAo+PiArI2RlZmluZSAgIEJUX0NSMl9JUlFfSDJCICAgIDB4MDEKPj4gKyNkZWZp bmUgICBCVF9DUjJfSVJRX0hCVVNZICAgIDB4NDAKPj4gKyNkZWZpbmUgQlRfQ1IzICAgICAgICAw eGMKPj4gKyNkZWZpbmUgQlRfQ1RSTCAgICAgICAgMHgxMAo+PiArI2RlZmluZSAgIEJUX0NUUkxf Ql9CVVNZICAgICAgICAweDgwCj4+ICsjZGVmaW5lICAgQlRfQ1RSTF9IX0JVU1kgICAgICAgIDB4 NDAKPj4gKyNkZWZpbmUgICBCVF9DVFJMX09FTTAgICAgICAgICAgICAweDIwCj4+ICsjZGVmaW5l ICAgQlRfQ1RSTF9TTVNfQVROICAgICAgICAweDEwCj4+ICsjZGVmaW5lICAgQlRfQ1RSTF9CMkhf QVROICAgICAgICAweDA4Cj4+ICsjZGVmaW5lICAgQlRfQ1RSTF9IMkJfQVROICAgICAgICAweDA0 Cj4+ICsjZGVmaW5lICAgQlRfQ1RSTF9DTFJfUkRfUFRSICAgICAgICAweDAyCj4+ICsjZGVmaW5l ICAgQlRfQ1RSTF9DTFJfV1JfUFRSICAgICAgICAweDAxCj4+ICsjZGVmaW5lIEJUX0JNQzJIT1NU ICAgIDB4MTQKPj4gKyNkZWZpbmUgQlRfSU5UTUFTSyAgICAweDE4Cj4+ICsjZGVmaW5lICAgQlRf SU5UTUFTS19CMkhfSVJRRU4gICAgICAgIDB4MDEKPj4gKyNkZWZpbmUgICBCVF9JTlRNQVNLX0Iy SF9JUlEgICAgICAgIDB4MDIKPj4gKyNkZWZpbmUgICBCVF9JTlRNQVNLX0JNQ19IV1JTVCAgICAg ICAgMHg4MAo+PiArCj4+ICtzdHJ1Y3QgYnRfYm1jIHsKPj4gKyAgICBzdHJ1Y3QgZGV2aWNlICAg ICAgICBkZXY7Cj4+ICsgICAgc3RydWN0IG1pc2NkZXZpY2UgICAgbWlzY2RldjsKPj4gKyAgICB2 b2lkIF9faW9tZW0gICAgICAgICpiYXNlOwo+PiArICAgIGludCAgICAgICAgICAgIG9wZW5fY291 bnQ7Cj4+ICsgICAgaW50ICAgICAgICAgICAgaXJxOwo+PiArICAgIHdhaXRfcXVldWVfaGVhZF90 ICAgIHF1ZXVlOwo+PiArICAgIHN0cnVjdCB0aW1lcl9saXN0ICAgIHBvbGxfdGltZXI7Cj4+ICt9 Owo+PiArCj4+ICtzdGF0aWMgdTggYnRfaW5iKHN0cnVjdCBidF9ibWMgKmJ0X2JtYywgaW50IHJl ZykKPj4gK3sKPj4gKyAgICByZXR1cm4gaW9yZWFkOChidF9ibWMtPmJhc2UgKyByZWcpOwo+PiAr fQo+PiArCj4+ICtzdGF0aWMgdm9pZCBidF9vdXRiKHN0cnVjdCBidF9ibWMgKmJ0X2JtYywgdTgg ZGF0YSwgaW50IHJlZykKPj4gK3sKPj4gKyAgICBpb3dyaXRlOChkYXRhLCBidF9ibWMtPmJhc2Ug KyByZWcpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgdm9pZCBjbHJfcmRfcHRyKHN0cnVjdCBidF9i bWMgKmJ0X2JtYykKPj4gK3sKPj4gKyAgICBidF9vdXRiKGJ0X2JtYywgQlRfQ1RSTF9DTFJfUkRf UFRSLCBCVF9DVFJMKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHZvaWQgY2xyX3dyX3B0cihzdHJ1 Y3QgYnRfYm1jICpidF9ibWMpCj4+ICt7Cj4+ICsgICAgYnRfb3V0YihidF9ibWMsIEJUX0NUUkxf Q0xSX1dSX1BUUiwgQlRfQ1RSTCk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIGNscl9oMmJf YXRuKHN0cnVjdCBidF9ibWMgKmJ0X2JtYykKPj4gK3sKPj4gKyAgICBidF9vdXRiKGJ0X2JtYywg QlRfQ1RSTF9IMkJfQVROLCBCVF9DVFJMKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHZvaWQgc2V0 X2JfYnVzeShzdHJ1Y3QgYnRfYm1jICpidF9ibWMpCj4+ICt7Cj4+ICsgICAgaWYgKCEoYnRfaW5i KGJ0X2JtYywgQlRfQ1RSTCkgJiBCVF9DVFJMX0JfQlVTWSkpCj4+ICsgICAgICAgIGJ0X291dGIo YnRfYm1jLCBCVF9DVFJMX0JfQlVTWSwgQlRfQ1RSTCk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2 b2lkIGNscl9iX2J1c3koc3RydWN0IGJ0X2JtYyAqYnRfYm1jKQo+PiArewo+PiArICAgIGlmIChi dF9pbmIoYnRfYm1jLCBCVF9DVFJMKSAmIEJUX0NUUkxfQl9CVVNZKQo+PiArICAgICAgICBidF9v dXRiKGJ0X2JtYywgQlRfQ1RSTF9CX0JVU1ksIEJUX0NUUkwpOwo+PiArfQo+PiArCj4+ICtzdGF0 aWMgdm9pZCBzZXRfYjJoX2F0bihzdHJ1Y3QgYnRfYm1jICpidF9ibWMpCj4+ICt7Cj4+ICsgICAg YnRfb3V0YihidF9ibWMsIEJUX0NUUkxfQjJIX0FUTiwgQlRfQ1RSTCk7Cj4+ICt9Cj4+ICsKPj4g K3N0YXRpYyB1OCBidF9yZWFkKHN0cnVjdCBidF9ibWMgKmJ0X2JtYykKPj4gK3sKPj4gKyAgICBy ZXR1cm4gYnRfaW5iKGJ0X2JtYywgQlRfQk1DMkhPU1QpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMg c3NpemVfdCBidF9yZWFkbihzdHJ1Y3QgYnRfYm1jICpidF9ibWMsIHU4ICpidWYsIHNpemVfdCBu KQo+PiArewo+PiArICAgIGludCBpOwo+PiArCj4+ICsgICAgZm9yIChpID0gMDsgaSA8IG47IGkr KykKPj4gKyAgICAgICAgYnVmW2ldID0gYnRfcmVhZChidF9ibWMpOwo+PiArICAgIHJldHVybiBu Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgdm9pZCBidF93cml0ZShzdHJ1Y3QgYnRfYm1jICpidF9i bWMsIHU4IGMpCj4+ICt7Cj4+ICsgICAgYnRfb3V0YihidF9ibWMsIGMsIEJUX0JNQzJIT1NUKTsK Pj4gK30KPj4gKwo+PiArc3RhdGljIHNzaXplX3QgYnRfd3JpdGVuKHN0cnVjdCBidF9ibWMgKmJ0 X2JtYywgdTggKmJ1Ziwgc2l6ZV90IG4pCj4+ICt7Cj4+ICsgICAgaW50IGk7Cj4+ICsKPj4gKyAg ICBmb3IgKGkgPSAwOyBpIDwgbjsgaSsrKQo+PiArICAgICAgICBidF93cml0ZShidF9ibWMsIGJ1 ZltpXSk7Cj4+ICsgICAgcmV0dXJuIG47Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIHNldF9z bXNfYXRuKHN0cnVjdCBidF9ibWMgKmJ0X2JtYykKPj4gK3sKPj4gKyAgICBidF9vdXRiKGJ0X2Jt YywgQlRfQ1RSTF9TTVNfQVROLCBCVF9DVFJMKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHN0cnVj dCBidF9ibWMgKmZpbGVfYnRfYm1jKHN0cnVjdCBmaWxlICpmaWxlKQo+PiArewo+PiArICAgIHJl dHVybiBjb250YWluZXJfb2YoZmlsZS0+cHJpdmF0ZV9kYXRhLCBzdHJ1Y3QgYnRfYm1jLCBtaXNj ZGV2KTsKPj4gK30KPj4gKwo+PiArc3RhdGljIGludCBidF9ibWNfb3BlbihzdHJ1Y3QgaW5vZGUg Kmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKPj4gK3sKPj4gKyAgICBzdHJ1Y3QgYnRfYm1jICpi dF9ibWMgPSBmaWxlX2J0X2JtYyhmaWxlKTsKPj4gKwo+PiArICAgIGNscl9iX2J1c3koYnRfYm1j KTsKPj4gKwo+PiArICAgIHJldHVybiAwOwo+PiArfQo+PiArCj4+ICsjZGVmaW5lIEJUX0JNQ19C VUZGRVJfU0laRSAyNTYKPj4gKwo+PiArLyoKPj4gKyAqIFRoZSBCVCAoQmxvY2sgVHJhbnNmZXIp IGludGVyZmFjZSBtZWFucyB0aGF0IGVudGlyZSBtZXNzYWdlcyBhcmUKPj4gKyAqIGJ1ZmZlcmVk IGJ5IHRoZSBob3N0IGJlZm9yZSBhIG5vdGlmaWNhdGlvbiBpcyBzZW50IHRvIHRoZSBCTUMgdGhh dAo+PiArICogdGhlcmUgaXMgZGF0YSB0byBiZSByZWFkLiBUaGUgZmlyc3QgYnl0ZSBpcyB0aGUg bGVuZ3RoIGFuZCB0aGUKPj4gKyAqIG1lc3NhZ2UgZGF0YSBmb2xsb3dzLiBUaGUgcmVhZCBvcGVy YXRpb24ganVzdCB0cmllcyB0byBjYXB0dXJlIHRoZQo+PiArICogd2hvbGUgYmVmb3JlIHJldHVy bmluZyBpdCB0byB1c2Vyc3BhY2UuCj4+ICsgKi8KPj4gK3N0YXRpYyBzc2l6ZV90IGJ0X2JtY19y ZWFkKHN0cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqYnVmLAo+PiArICAgICAgICAgICAg ICAgIHNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQo+PiArewo+PiArICAgIHN0cnVjdCBidF9i bWMgKmJ0X2JtYyA9IGZpbGVfYnRfYm1jKGZpbGUpOwo+PiArICAgIHU4IGxlbjsKPj4gKyAgICBp bnQgbGVuX2J5dGUgPSAxOwo+PiArICAgIHU4IGtidWZmZXJbQlRfQk1DX0JVRkZFUl9TSVpFXTsK Pj4gKyAgICBzc2l6ZV90IHJldCA9IDA7Cj4+ICsgICAgc3NpemVfdCBucmVhZDsKPj4gKwo+PiAr ICAgIGlmICghYWNjZXNzX29rKFZFUklGWV9XUklURSwgYnVmLCBjb3VudCkpCj4+ICsgICAgICAg IHJldHVybiAtRUZBVUxUOwo+PiArCj4+ICsgICAgV0FSTl9PTigqcHBvcyk7Cj4+ICsKPj4gKyAg ICBpZiAod2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlKGJ0X2JtYy0+cXVldWUsCj4+ICsgICAgICAg ICAgICAgICAgYnRfaW5iKGJ0X2JtYywgQlRfQ1RSTCkgJiBCVF9DVFJMX0gyQl9BVE4pKQo+PiAr ICAgICAgICByZXR1cm4gLUVSRVNUQVJUU1lTOwo+PiArCj4+ICsgICAgc2V0X2JfYnVzeShidF9i bWMpOwo+PiArICAgIGNscl9oMmJfYXRuKGJ0X2JtYyk7Cj4+ICsgICAgY2xyX3JkX3B0cihidF9i bWMpOwo+PiArCj4+ICsgICAgLyoKPj4gKyAgICAgKiBUaGUgQlQgZnJhbWVzIHN0YXJ0IHdpdGgg dGhlIG1lc3NhZ2UgbGVuZ3RoLCB3aGljaCBkb2VzIG5vdAo+PiArICAgICAqIGluY2x1ZGUgdGhl IGxlbmd0aCBieXRlLgo+PiArICAgICAqLwo+PiArICAgIGtidWZmZXJbMF0gPSBidF9yZWFkKGJ0 X2JtYyk7Cj4+ICsgICAgbGVuID0ga2J1ZmZlclswXTsKPj4gKwo+PiArICAgIC8qIFdlIHBhc3Mg dGhlIGxlbmd0aCBiYWNrIHRvIHVzZXJzcGFjZSBhcyB3ZWxsICovCj4+ICsgICAgaWYgKGxlbiAr IDEgPiBjb3VudCkKPj4gKyAgICAgICAgbGVuID0gY291bnQgLSAxOwo+PiArCj4+ICsgICAgd2hp bGUgKGxlbikgewo+PiArICAgICAgICBucmVhZCA9IG1pbl90KHNzaXplX3QsIGxlbiwgc2l6ZW9m KGtidWZmZXIpIC0gbGVuX2J5dGUpOwo+PiArCj4+ICsgICAgICAgIGJ0X3JlYWRuKGJ0X2JtYywg a2J1ZmZlciArIGxlbl9ieXRlLCBucmVhZCk7Cj4+ICsKPj4gKyAgICAgICAgaWYgKGNvcHlfdG9f dXNlcihidWYsIGtidWZmZXIsIG5yZWFkICsgbGVuX2J5dGUpKSB7Cj4+ICsgICAgICAgICAgICBy ZXQgPSAtRUZBVUxUOwo+PiArICAgICAgICAgICAgYnJlYWs7Cj4+ICsgICAgICAgIH0KPj4gKyAg ICAgICAgbGVuIC09IG5yZWFkOwo+PiArICAgICAgICBidWYgKz0gbnJlYWQgKyBsZW5fYnl0ZTsK Pj4gKyAgICAgICAgcmV0ICs9IG5yZWFkICsgbGVuX2J5dGU7Cj4+ICsgICAgICAgIGxlbl9ieXRl ID0gMDsKPj4gKyAgICB9Cj4+ICsKPj4gKyAgICBjbHJfYl9idXN5KGJ0X2JtYyk7Cj4+ICsKPj4g KyAgICByZXR1cm4gcmV0Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgc3NpemVfdCBidF9ibWNfd3Jp dGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWYsCj4+ICsgICAgICAg ICAgICAgICAgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCj4+ICt7Cj4+ICsgICAgc3RydWN0 IGJ0X2JtYyAqYnRfYm1jID0gZmlsZV9idF9ibWMoZmlsZSk7Cj4+ICsgICAgdTgga2J1ZmZlcltC VF9CTUNfQlVGRkVSX1NJWkVdOwo+PiArICAgIHNzaXplX3QgcmV0ID0gMDsKPj4gKyAgICBzc2l6 ZV90IG53cml0dGVuOwo+PiArCj4+ICsgICAgaWYgKCFhY2Nlc3Nfb2soVkVSSUZZX1JFQUQsIGJ1 ZiwgY291bnQpKQo+PiArICAgICAgICByZXR1cm4gLUVGQVVMVDsKPj4gKwo+PiArICAgIFdBUk5f T04oKnBwb3MpOwo+PiArCj4+ICsgICAgLyogVGhlcmUncyBubyBpbnRlcnJ1cHQgZm9yIGNsZWFy aW5nIGJtYyBidXN5IHNvIHdlIGhhdmUgdG8KPj4gKyAgICAgKiBwb2xsCj4+ICsgICAgICovCj4+ ICsgICAgaWYgKHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShidF9ibWMtPnF1ZXVlLAo+PiArICAg ICAgICAgICAgICAgICEoYnRfaW5iKGJ0X2JtYywgQlRfQ1RSTCkgJgo+PiArICAgICAgICAgICAg ICAgICAgICAoQlRfQ1RSTF9IX0JVU1kgfCBCVF9DVFJMX0IySF9BVE4pKSkpCj4+ICsgICAgICAg IHJldHVybiAtRVJFU1RBUlRTWVM7Cj4+ICsKPj4gKyAgICBjbHJfd3JfcHRyKGJ0X2JtYyk7Cj4+ ICsKPj4gKyAgICB3aGlsZSAoY291bnQpIHsKPj4gKyAgICAgICAgbndyaXR0ZW4gPSBtaW5fdChz c2l6ZV90LCBjb3VudCwgc2l6ZW9mKGtidWZmZXIpKTsKPj4gKyAgICAgICAgaWYgKGNvcHlfZnJv bV91c2VyKCZrYnVmZmVyLCBidWYsIG53cml0dGVuKSkgewo+PiArICAgICAgICAgICAgcmV0ID0g LUVGQVVMVDsKPj4gKyAgICAgICAgICAgIGJyZWFrOwo+PiArICAgICAgICB9Cj4+ICsKPj4gKyAg ICAgICAgYnRfd3JpdGVuKGJ0X2JtYywga2J1ZmZlciwgbndyaXR0ZW4pOwo+PiArCj4+ICsgICAg ICAgIGNvdW50IC09IG53cml0dGVuOwo+PiArICAgICAgICBidWYgKz0gbndyaXR0ZW47Cj4+ICsg ICAgICAgIHJldCArPSBud3JpdHRlbjsKPj4gKyAgICB9Cj4+ICsKPj4gKyAgICBzZXRfYjJoX2F0 bihidF9ibWMpOwo+PiArCj4+ICsgICAgcmV0dXJuIHJldDsKPj4gK30KPj4gKwo+PiArc3RhdGlj IGxvbmcgYnRfYm1jX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAo+ PiArICAgICAgICB1bnNpZ25lZCBsb25nIHBhcmFtKQo+PiArewo+PiArICAgIHN0cnVjdCBidF9i bWMgKmJ0X2JtYyA9IGZpbGVfYnRfYm1jKGZpbGUpOwo+PiArCj4+ICsgICAgc3dpdGNoIChjbWQp IHsKPj4gKyAgICBjYXNlIEJUX0JNQ19JT0NUTF9TTVNfQVROOgo+PiArICAgICAgICBzZXRfc21z X2F0bihidF9ibWMpOwo+PiArICAgICAgICByZXR1cm4gMDsKPj4gKyAgICB9Cj4+ICsgICAgcmV0 dXJuIC1FSU5WQUw7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbnQgYnRfYm1jX3JlbGVhc2Uoc3Ry dWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCj4+ICt7Cj4+ICsgICAgc3RydWN0 IGJ0X2JtYyAqYnRfYm1jID0gZmlsZV9idF9ibWMoZmlsZSk7Cj4+ICsKPj4gKyAgICBzZXRfYl9i dXN5KGJ0X2JtYyk7Cj4+ICsgICAgcmV0dXJuIDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB1bnNp Z25lZCBpbnQgYnRfYm1jX3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHBvbGxfdGFibGUgKndhaXQp Cj4+ICt7Cj4+ICsgICAgc3RydWN0IGJ0X2JtYyAqYnRfYm1jID0gZmlsZV9idF9ibWMoZmlsZSk7 Cj4+ICsgICAgdW5zaWduZWQgaW50IG1hc2sgPSAwOwo+PiArICAgIHVpbnQ4X3QgY3RybDsKPj4g Kwo+PiArICAgIHBvbGxfd2FpdChmaWxlLCAmYnRfYm1jLT5xdWV1ZSwgd2FpdCk7Cj4+ICsKPj4g KyAgICBjdHJsID0gYnRfaW5iKGJ0X2JtYywgQlRfQ1RSTCk7Cj4+ICsKPj4gKyAgICBpZiAoY3Ry bCAmIEJUX0NUUkxfSDJCX0FUTikKPj4gKyAgICAgICAgbWFzayB8PSBQT0xMSU47Cj4+ICsKPj4g KyAgICBpZiAoIShjdHJsICYgKEJUX0NUUkxfSF9CVVNZIHwgQlRfQ1RSTF9CMkhfQVROKSkpCj4+ ICsgICAgICAgIG1hc2sgfD0gUE9MTE9VVDsKPj4gKwo+PiArICAgIHJldHVybiBtYXNrOwo+PiAr fQo+PiArCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBidF9ibWNfZm9w cyA9IHsKPj4gKyAgICAub3duZXIgICAgICAgID0gVEhJU19NT0RVTEUsCj4+ICsgICAgLm9wZW4g ICAgICAgID0gYnRfYm1jX29wZW4sCj4+ICsgICAgLnJlYWQgICAgICAgID0gYnRfYm1jX3JlYWQs Cj4+ICsgICAgLndyaXRlICAgICAgICA9IGJ0X2JtY193cml0ZSwKPj4gKyAgICAucmVsZWFzZSAg ICA9IGJ0X2JtY19yZWxlYXNlLAo+PiArICAgIC5wb2xsICAgICAgICA9IGJ0X2JtY19wb2xsLAo+ PiArICAgIC51bmxvY2tlZF9pb2N0bCAgICA9IGJ0X2JtY19pb2N0bCwKPj4gK307Cj4+ICsKPj4g K3N0YXRpYyB2b2lkIHBvbGxfdGltZXIodW5zaWduZWQgbG9uZyBkYXRhKQo+PiArewo+PiArICAg IHN0cnVjdCBidF9ibWMgKmJ0X2JtYyA9ICh2b2lkICopZGF0YTsKPj4gKwo+PiArICAgIGJ0X2Jt Yy0+cG9sbF90aW1lci5leHBpcmVzICs9IG1zZWNzX3RvX2ppZmZpZXMoNTAwKTsKPj4gKyAgICB3 YWtlX3VwKCZidF9ibWMtPnF1ZXVlKTsKPj4gKyAgICBhZGRfdGltZXIoJmJ0X2JtYy0+cG9sbF90 aW1lcik7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpcnFyZXR1cm5fdCBidF9ibWNfaXJxKGludCBp cnEsIHZvaWQgKmFyZykKPj4gK3sKPj4gKyAgICBzdHJ1Y3QgYnRfYm1jICpidF9ibWMgPSBhcmc7 Cj4+ICsgICAgdWludDMyX3QgcmVnOwo+PiArCj4+ICsgICAgcmVnID0gaW9yZWFkMzIoYnRfYm1j LT5iYXNlICsgQlRfQ1IyKTsKPj4gKyAgICByZWcgJj0gQlRfQ1IyX0lSUV9IMkIgfCBCVF9DUjJf SVJRX0hCVVNZOwo+PiArICAgIGlmICghcmVnKQo+PiArICAgICAgICByZXR1cm4gSVJRX05PTkU7 Cj4+ICsKPj4gKyAgICAvKiBhY2sgcGVuZGluZyBJUlFzICovCj4+ICsgICAgaW93cml0ZTMyKHJl ZywgYnRfYm1jLT5iYXNlICsgQlRfQ1IyKTsKPj4gKwo+PiArICAgIHdha2VfdXAoJmJ0X2JtYy0+ cXVldWUpOwo+PiArICAgIHJldHVybiBJUlFfSEFORExFRDsKPj4gK30KPj4gKwo+PiArc3RhdGlj IGludCBidF9ibWNfY29uZmlnX2lycShzdHJ1Y3QgYnRfYm1jICpidF9ibWMsCj4+ICsgICAgICAg IHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4+ICt7Cj4+ICsgICAgc3RydWN0IGRldmlj ZSAqZGV2ID0gJnBkZXYtPmRldjsKPj4gKyAgICB1aW50MzJfdCByZWc7Cj4+ICsgICAgaW50IHJj Owo+PiArCj4+ICsgICAgYnRfYm1jLT5pcnEgPSBwbGF0Zm9ybV9nZXRfaXJxKHBkZXYsIDApOwo+ PiArICAgIGlmICghYnRfYm1jLT5pcnEpCj4+ICsgICAgICAgIHJldHVybiAtRU5PREVWOwo+PiAr Cj4+ICsgICAgcmMgPSBkZXZtX3JlcXVlc3RfaXJxKGRldiwgYnRfYm1jLT5pcnEsIGJ0X2JtY19p cnEsIElSUUZfU0hBUkVELAo+PiArICAgICAgICAgICAgREVWSUNFX05BTUUsIGJ0X2JtYyk7Cj4+ ICsgICAgaWYgKHJjIDwgMCkgewo+PiArICAgICAgICBkZXZfd2FybihkZXYsICJVbmFibGUgdG8g cmVxdWVzdCBJUlEgJWRcbiIsIGJ0X2JtYy0+aXJxKTsKPj4gKyAgICAgICAgYnRfYm1jLT5pcnEg PSAwOwo+PiArICAgICAgICByZXR1cm4gcmM7Cj4+ICsgICAgfQo+PiArCj4+ICsgICAgLyogQ29u ZmlndXJlIElSUXMgb24gdGhlIGJtYyBjbGVhcmluZyB0aGUgSDJCIGFuZCBIQlVTWSBiaXRzOwo+ PiArICAgICAqIEgyQiB3aWxsIGJlIGFzc2VydGVkIHdoZW4gdGhlIGJtYyBoYXMgZGF0YSBmb3Ig dXM7IEhCVVNZCj4+ICsgICAgICogd2lsbCBiZSBjbGVhcmVkIChhbG9uZyB3aXRoIEIySCkgd2hl biB3ZSBjYW4gd3JpdGUgdGhlIG5leHQKPj4gKyAgICAgKiBtZXNzYWdlIHRvIHRoZSBCVCBidWZm ZXIKPj4gKyAgICAgKi8KPj4gKyAgICByZWcgPSBpb3JlYWQzMihidF9ibWMtPmJhc2UgKyBCVF9D UjEpOwo+PiArICAgIHJlZyB8PSBCVF9DUjFfSVJRX0gyQiB8IEJUX0NSMV9JUlFfSEJVU1k7Cj4+ ICsgICAgaW93cml0ZTMyKHJlZywgYnRfYm1jLT5iYXNlICsgQlRfQ1IxKTsKPj4gKwo+PiArICAg IHJldHVybiAwOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IGJ0X2JtY19wcm9iZShzdHJ1Y3Qg cGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+PiArewo+PiArICAgIHN0cnVjdCBidF9ibWMgKmJ0X2Jt YzsKPj4gKyAgICBzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4+ICsgICAgc3RydWN0IHJlc291cmNlICpy ZXM7Cj4+ICsgICAgaW50IHJjOwo+PiArCj4+ICsgICAgaWYgKCFwZGV2IHx8ICFwZGV2LT5kZXYu b2Zfbm9kZSkKPj4gKyAgICAgICAgcmV0dXJuIC1FTk9ERVY7Cj4+ICsKPj4gKyAgICBkZXYgPSAm cGRldi0+ZGV2Owo+PiArICAgIGRldl9pbmZvKGRldiwgIkZvdW5kIGJ0IGJtYyBkZXZpY2VcbiIp Owo+PiArCj4+ICsgICAgYnRfYm1jID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpidF9ibWMp LCBHRlBfS0VSTkVMKTsKPj4gKyAgICBpZiAoIWJ0X2JtYykKPj4gKyAgICAgICAgcmV0dXJuIC1F Tk9NRU07Cj4+ICsKPj4gKyAgICBkZXZfc2V0X2RydmRhdGEoJnBkZXYtPmRldiwgYnRfYm1jKTsK Pj4gKwo+PiArICAgIHJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNF X01FTSwgMCk7Cj4+ICsgICAgaWYgKCFyZXMpIHsKPj4gKyAgICAgICAgZGV2X2VycihkZXYsICJV bmFibGUgdG8gZmluZCByZXNvdXJjZXNcbiIpOwo+PiArICAgICAgICByYyA9IC1FTlhJTzsKPj4g KyAgICAgICAgZ290byBvdXRfZnJlZTsKPj4gKyAgICB9Cj4+ICsKPj4gKyAgICBidF9ibWMtPmJh c2UgPSBkZXZtX2lvcmVtYXBfcmVzb3VyY2UoJnBkZXYtPmRldiwgcmVzKTsKPj4gKyAgICBpZiAo IWJ0X2JtYy0+YmFzZSkgewo+PiArICAgICAgICByYyA9IC1FTk9NRU07Cj4+ICsgICAgICAgIGdv dG8gb3V0X2ZyZWU7Cj4+ICsgICAgfQo+PiArCj4+ICsgICAgaW5pdF93YWl0cXVldWVfaGVhZCgm YnRfYm1jLT5xdWV1ZSk7Cj4+ICsKPj4gKyAgICBidF9ibWMtPm1pc2NkZXYubWlub3IgICAgPSBN SVNDX0RZTkFNSUNfTUlOT1IsCj4+ICsgICAgYnRfYm1jLT5taXNjZGV2Lm5hbWUgICAgPSBERVZJ Q0VfTkFNRSwKPj4gKyAgICBidF9ibWMtPm1pc2NkZXYuZm9wcyAgICA9ICZidF9ibWNfZm9wcywK Pj4gKyAgICBidF9ibWMtPm1pc2NkZXYucGFyZW50ID0gZGV2Owo+PiArICAgIHJjID0gbWlzY19y ZWdpc3RlcigmYnRfYm1jLT5taXNjZGV2KTsKPj4gKyAgICBpZiAocmMpIHsKPj4gKyAgICAgICAg ZGV2X2VycihkZXYsICJVbmFibGUgdG8gcmVnaXN0ZXIgZGV2aWNlXG4iKTsKPj4gKyAgICAgICAg Z290byBvdXRfdW5tYXA7Cj4+ICsgICAgfQo+PiArCj4+ICsgICAgYnRfYm1jX2NvbmZpZ19pcnEo YnRfYm1jLCBwZGV2KTsKPj4gKwo+PiArICAgIGlmIChidF9ibWMtPmlycSkgewo+PiArICAgICAg ICBkZXZfaW5mbyhkZXYsICJVc2luZyBJUlEgJWRcbiIsIGJ0X2JtYy0+aXJxKTsKPj4gKyAgICB9 IGVsc2Ugewo+PiArICAgICAgICBkZXZfaW5mbyhkZXYsICJObyBJUlE7IHVzaW5nIHRpbWVyXG4i KTsKPj4gKyAgICAgICAgc2V0dXBfdGltZXIoJmJ0X2JtYy0+cG9sbF90aW1lciwgcG9sbF90aW1l ciwKPj4gKyAgICAgICAgICAgICAgICAodW5zaWduZWQgbG9uZylidF9ibWMpOwo+PiArICAgICAg ICBidF9ibWMtPnBvbGxfdGltZXIuZXhwaXJlcyA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVz KDEwKTsKPj4gKyAgICAgICAgYWRkX3RpbWVyKCZidF9ibWMtPnBvbGxfdGltZXIpOwo+PiArICAg IH0KPj4gKwo+PiArICAgIGlvd3JpdGUzMigoQlRfSU9fQkFTRSA8PCBCVF9DUjBfSU9fQkFTRSkg fAo+PiArICAgICAgICAgIChCVF9JUlEgPDwgQlRfQ1IwX0lSUSkgfAo+PiArICAgICAgICAgIEJU X0NSMF9FTl9DTFJfU0xWX1JEUCB8Cj4+ICsgICAgICAgICAgQlRfQ1IwX0VOX0NMUl9TTFZfV1JQ IHwKPj4gKyAgICAgICAgICBCVF9DUjBfRU5BQkxFX0lCVCwKPj4gKyAgICAgICAgICBidF9ibWMt PmJhc2UgKyBCVF9DUjApOwo+PiArCj4+ICsgICAgY2xyX2JfYnVzeShidF9ibWMpOwo+PiArCj4+ ICsgICAgcmV0dXJuIDA7Cj4+ICsKPj4gK291dF91bm1hcDoKPj4gKyAgICBkZXZtX2lvdW5tYXAo JnBkZXYtPmRldiwgYnRfYm1jLT5iYXNlKTsKPj4gKwo+PiArb3V0X2ZyZWU6Cj4+ICsgICAgZGV2 bV9rZnJlZShkZXYsIGJ0X2JtYyk7Cj4+ICsgICAgcmV0dXJuIHJjOwo+PiArCj4+ICt9Cj4+ICsK Pj4gK3N0YXRpYyBpbnQgYnRfYm1jX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 KQo+PiArewo+PiArICAgIHN0cnVjdCBidF9ibWMgKmJ0X2JtYyA9IGRldl9nZXRfZHJ2ZGF0YSgm cGRldi0+ZGV2KTsKPj4gKwo+PiArICAgIG1pc2NfZGVyZWdpc3RlcigmYnRfYm1jLT5taXNjZGV2 KTsKPj4gKyAgICBpZiAoIWJ0X2JtYy0+aXJxKQo+PiArICAgICAgICBkZWxfdGltZXJfc3luYygm YnRfYm1jLT5wb2xsX3RpbWVyKTsKPj4gKyAgICBkZXZtX2lvdW5tYXAoJnBkZXYtPmRldiwgYnRf Ym1jLT5iYXNlKTsKPj4gKyAgICBkZXZtX2tmcmVlKCZwZGV2LT5kZXYsIGJ0X2JtYyk7Cj4+ICsg ICAgYnRfYm1jID0gTlVMTDsKPj4gKwo+PiArICAgIHJldHVybiAwOwo+PiArfQo+PiArCj4+ICtz dGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBidF9ibWNfbWF0Y2hbXSA9IHsKPj4gKyAg ICB7IC5jb21wYXRpYmxlID0gImFzcGVlZCxhc3QyNDAwLWJ0LWJtYyIgfSwKPj4gKyAgICB7IH0s Cj4+ICt9Owo+PiArCj4+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBidF9ibWNfZHJp dmVyID0gewo+PiArICAgIC5kcml2ZXIgPSB7Cj4+ICsgICAgICAgIC5uYW1lICAgICAgICA9IERF VklDRV9OQU1FLAo+PiArICAgICAgICAub2ZfbWF0Y2hfdGFibGUgPSBidF9ibWNfbWF0Y2gsCj4+ ICsgICAgfSwKPj4gKyAgICAucHJvYmUgPSBidF9ibWNfcHJvYmUsCj4+ICsgICAgLnJlbW92ZSA9 IGJ0X2JtY19yZW1vdmUsCj4+ICt9Owo+PiArCj4+ICttb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGJ0 X2JtY19kcml2ZXIpOwo+PiArCj4+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBidF9ibWNfbWF0 Y2gpOwo+PiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+PiArTU9EVUxFX0FVVEhPUigiQWxpc3Rh aXIgUG9wcGxlIDxhbGlzdGFpckBwb3BwbGUuaWQuYXU+Iik7Cj4+ICtNT0RVTEVfREVTQ1JJUFRJ T04oIkxpbnV4IGRldmljZSBpbnRlcmZhY2UgdG8gdGhlIEJUIGludGVyZmFjZSIpOwo+PiBkaWZm IC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L0tidWlsZCBiL2luY2x1ZGUvdWFwaS9saW51eC9L YnVpbGQKPj4gaW5kZXggMTg1ZjhlYTI3MDJmLi4xN2IxMjk0MmM2N2QgMTAwNjQ0Cj4+IC0tLSBh L2luY2x1ZGUvdWFwaS9saW51eC9LYnVpbGQKPj4gKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L0ti dWlsZAo+PiBAQCAtNzQsNiArNzQsNyBAQCBoZWFkZXIteSArPSBicGZfY29tbW9uLmgKPj4gICBo ZWFkZXIteSArPSBicGYuaAo+PiAgIGhlYWRlci15ICs9IGJwcWV0aGVyLmgKPj4gICBoZWFkZXIt eSArPSBic2cuaAo+PiAraGVhZGVyLXkgKz0gYnQtYm1jLmgKPj4gICBoZWFkZXIteSArPSBidHJm cy5oCj4+ICAgaGVhZGVyLXkgKz0gY2FuLmgKPj4gICBoZWFkZXIteSArPSBjYXBhYmlsaXR5LmgK Pj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC9idC1ibWMuaCBiL2luY2x1ZGUvdWFw aS9saW51eC9idC1ibWMuaAo+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+PiBpbmRleCAwMDAwMDAw MDAwMDAuLmQ5ZWM3NjZhNjNkMAo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL2luY2x1ZGUvdWFw aS9saW51eC9idC1ibWMuaAo+PiBAQCAtMCwwICsxLDE4IEBACj4+ICsvKgo+PiArICogQ29weXJp Z2h0IChjKSAyMDE1LTIwMTYsIElCTSBDb3Jwb3JhdGlvbi4KPj4gKyAqCj4+ICsgKiBUaGlzIHBy b2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCj4+ ICsgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZQo+PiArICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlciB2ZXJzaW9uCj4+ICsgKiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgo+PiArICovCj4+ICsKPj4gKyNpZm5kZWYgX1VBUElf TElOVVhfQlRfQk1DX0gKPj4gKyNkZWZpbmUgX1VBUElfTElOVVhfQlRfQk1DX0gKPj4gKwo+PiAr I2luY2x1ZGUgPGxpbnV4L2lvY3RsLmg+Cj4+ICsKPj4gKyNkZWZpbmUgX19CVF9CTUNfSU9DVExf TUFHSUMgICAgMHhiMQo+PiArI2RlZmluZSBCVF9CTUNfSU9DVExfU01TX0FUTiAgICBfSU8oX19C VF9CTUNfSU9DVExfTUFHSUMsIDB4MDApCj4+ICsKPj4gKyNlbmRpZiAvKiBfVUFQSV9MSU5VWF9C VF9CTUNfSCAqLwo+IAo+IAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: clg@kaod.org (=?UTF-8?Q?C=c3=a9dric_Le_Goater?=) Date: Mon, 19 Sep 2016 10:00:27 +0200 Subject: [PATCH v2 1/3] ipmi: add an Aspeed BT IPMI BMC driver In-Reply-To: <08e9b30f-6c35-8418-a8b0-0b63639dd36d@acm.org> References: <1474022367-21029-1-git-send-email-clg@kaod.org> <1474022367-21029-2-git-send-email-clg@kaod.org> <08e9b30f-6c35-8418-a8b0-0b63639dd36d@acm.org> Message-ID: <9ce54c4c-e8ae-7ac2-de9c-71402dfa4c39@kaod.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On 09/16/2016 09:41 PM, Corey Minyard wrote: > On 09/16/2016 05:39 AM, C?dric Le Goater wrote: >> From: Alistair Popple >> >> This patch adds a simple device driver to expose the iBT interface on >> Aspeed SOCs (AST2400 and AST2500) as a character device. Such SOCs are >> commonly used as BMCs (BaseBoard Management Controllers) and this >> driver implements the BMC side of the BT interface. >> >> The BT (Block Transfer) interface is used to perform in-band IPMI >> communication between a host and its BMC. Entire messages are buffered >> before sending a notification to the other end, host or BMC, that >> there is data to be read. Usually, the host emits requests and the BMC >> responses but the specification provides a mean for the BMC to send >> SMS Attention (BMC-to-Host attention or System Management Software >> attention) messages. >> >> For this purpose, the driver introduces a specific ioctl on the >> device: 'BT_BMC_IOCTL_SMS_ATN' that can be used by the system running >> on the BMC to signal the host of such an event. >> >> The device name defaults to '/dev/ipmi-bt-host' > > Others have reviewed this for style and such, and I have looked > at it from a protocol point of view. it looks to be sound for the > most part. I have some higher level concerns: > > There appears to be no handling for multiple simultaneous users. > This interface can only be used by one task at a time, so you should > probably only allow one opener. Well, I guess the BMC could be split > into a reader and a writer task, so I'm not really sure about that, but > I would think in most situations having more than one opener is a > bug. You do call clr_b_busy() on open, for instance, which might be > an issue for multiple openers. Maybe a module parameter for > maximum number of openers? Just want to make sure this was > thought about, at least. yes but not implemented ... The open_count in the bt_bmc structure is unused. In v3, I will replace it with a global atomic_t tracked in the open and release operations. > There is also no mutex protecting reading or writing. If multiple > threads call read or write at the same time, it probably wouldn't > work correctly. I think you need a read and a write mutex on the > interface to protect against this. yes. I will add a mutex also in v3. > The spec says: > > The BMC must not return a given response once the corresponding > Request-to-Response interval has passed. The BMC can ensure this > by maintaining its own internal list of outstanding requests through > the interface. The BMC could age and expire the entries in the list > by expiring the entries at an interval that is somewhat shorter than > the specified Request-to-Response interval.... This is clearly not handled in the driver. For this purpose, we could maintain a request expiry list using the seq field of the BT message. Update the list in the read and write operations and arm a timer to garbage collect any left overs. As for the errno in the write when a response had timeout'ed, may be ETIMEDOUT ? For configuration of the maximum response time, a sysfs file would do I think. Do you want that in v3 also ? I have some experimental patches for it, that I can send as follow ups. Thanks, C. > On the write side, though, there doesn't seem to be a way to handle a > situation where the host side doesn't respond for a while and the > pending message would need to be discarded. > > The spec doesn't mention much about error recovery on this interface, > but the way this is written should be fine, I think. > > I'm copying Rocky Craig, who wrote the host side driver for Linux, in > case he wants to comment on this. > > This is easy to read and understand, so I think v3 should be good. > > Thanks, > > -corey > >> Signed-off-by: Alistair Popple >> Signed-off-by: Jeremy Kerr >> Signed-off-by: Joel Stanley >> [clg: - checkpatch fixes >> - added a devicetree binding documentation >> - replace 'bt_host' by 'bt_bmc' to reflect that the driver is >> the BMC side of the IPMI BT interface >> - renamed the device to 'ipmi-bt-host' >> - introduced a temporary buffer to copy_{to,from}_user >> - used platform_get_irq() >> - moved the driver under drivers/char/ipmi/ but kept it as a misc >> device >> - changed the compatible cell to "aspeed,ast2400-bt-bmc" >> ] >> Signed-off-by: C?dric Le Goater >> --- >> >> Changes since v1: >> >> - replace 'bt_host' by 'bt_bmc' to reflect that the driver is >> the BMC side of the IPMI BT interface >> - renamed the device to 'ipmi-bt-host' >> - introduced a temporary buffer to copy_{to,from}_user >> - used platform_get_irq() >> - moved the driver under drivers/char/ipmi/ but kept it as a misc >> device >> - changed the compatible cell to "aspeed,ast2400-bt-bmc" >> >> .../bindings/char/ipmi/aspeed,ast2400-bt-bmc.txt | 23 + >> drivers/Makefile | 2 +- >> drivers/char/ipmi/Kconfig | 7 + >> drivers/char/ipmi/Makefile | 1 + >> drivers/char/ipmi/bt-bmc.c | 486 +++++++++++++++++++++ >> include/uapi/linux/Kbuild | 1 + >> include/uapi/linux/bt-bmc.h | 18 + >> 7 files changed, 537 insertions(+), 1 deletion(-) >> create mode 100644 Documentation/devicetree/bindings/char/ipmi/aspeed,ast2400-bt-bmc.txt >> create mode 100644 drivers/char/ipmi/bt-bmc.c >> create mode 100644 include/uapi/linux/bt-bmc.h >> >> diff --git a/Documentation/devicetree/bindings/char/ipmi/aspeed,ast2400-bt-bmc.txt b/Documentation/devicetree/bindings/char/ipmi/aspeed,ast2400-bt-bmc.txt >> new file mode 100644 >> index 000000000000..fbbacd958240 >> --- /dev/null >> +++ b/Documentation/devicetree/bindings/char/ipmi/aspeed,ast2400-bt-bmc.txt >> @@ -0,0 +1,23 @@ >> +* Aspeed BT (Block Transfer) IPMI interface >> + >> +The Aspeed SOCs (AST2400 and AST2500) are commonly used as BMCs >> +(BaseBoard Management Controllers) and the BT interface can be used to >> +perform in-band IPMI communication with their host. >> + >> +Required properties: >> + >> +- compatible : should be "aspeed,ast2400-bt-bmc" >> +- reg: physical address and size of the registers >> + >> +Optional properties: >> + >> +- interrupts: interrupt generated by the BT interface. without an >> + interrupt, the driver will operate in poll mode. >> + >> +Example: >> + >> + ibt at 1e789140 { >> + compatible = "aspeed,ast2400-bt-bmc"; >> + reg = <0x1e789140 0x18>; >> + interrupts = <8>; >> + }; >> diff --git a/drivers/Makefile b/drivers/Makefile >> index 53abb4a5f736..5a9e7b6b7928 100644 >> --- a/drivers/Makefile >> +++ b/drivers/Makefile >> @@ -21,7 +21,7 @@ obj-y += video/ >> obj-y += idle/ >> # IPMI must come before ACPI in order to provide IPMI opregion support >> -obj-$(CONFIG_IPMI_HANDLER) += char/ipmi/ >> +obj-y += char/ipmi/ >> obj-$(CONFIG_ACPI) += acpi/ >> obj-$(CONFIG_SFI) += sfi/ >> diff --git a/drivers/char/ipmi/Kconfig b/drivers/char/ipmi/Kconfig >> index 5a9350b1069a..2c234e3e7513 100644 >> --- a/drivers/char/ipmi/Kconfig >> +++ b/drivers/char/ipmi/Kconfig >> @@ -76,3 +76,10 @@ config IPMI_POWEROFF >> the IPMI management controller is capable of this. >> endif # IPMI_HANDLER >> + >> +config ASPEED_BT_IPMI_BMC >> + tristate "BT IPMI bmc driver" >> + help >> + Provides a driver for the BT (Block Transfer) IPMI interface >> + found on Aspeed SOCs (AST2400 and AST2500). The driver >> + implements the BMC side of the BT interface. >> diff --git a/drivers/char/ipmi/Makefile b/drivers/char/ipmi/Makefile >> index f3ffde1f5f1f..0d98cd91def1 100644 >> --- a/drivers/char/ipmi/Makefile >> +++ b/drivers/char/ipmi/Makefile >> @@ -11,3 +11,4 @@ obj-$(CONFIG_IPMI_SSIF) += ipmi_ssif.o >> obj-$(CONFIG_IPMI_POWERNV) += ipmi_powernv.o >> obj-$(CONFIG_IPMI_WATCHDOG) += ipmi_watchdog.o >> obj-$(CONFIG_IPMI_POWEROFF) += ipmi_poweroff.o >> +obj-$(CONFIG_ASPEED_BT_IPMI_BMC) += bt-bmc.o >> diff --git a/drivers/char/ipmi/bt-bmc.c b/drivers/char/ipmi/bt-bmc.c >> new file mode 100644 >> index 000000000000..b96cb421e1c2 >> --- /dev/null >> +++ b/drivers/char/ipmi/bt-bmc.c >> @@ -0,0 +1,486 @@ >> +/* >> + * Copyright (c) 2015-2016, IBM Corporation. >> + * >> + * This program is free software; you can redistribute it and/or >> + * modify it under the terms of the GNU General Public License >> + * as published by the Free Software Foundation; either version >> + * 2 of the License, or (at your option) any later version. >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +/* >> + * This is a BMC device used to communicate to the host >> + */ >> +#define DEVICE_NAME "ipmi-bt-host" >> + >> +#define BT_IO_BASE 0xe4 >> +#define BT_IRQ 10 >> + >> +#define BT_CR0 0x0 >> +#define BT_CR0_IO_BASE 16 >> +#define BT_CR0_IRQ 12 >> +#define BT_CR0_EN_CLR_SLV_RDP 0x8 >> +#define BT_CR0_EN_CLR_SLV_WRP 0x4 >> +#define BT_CR0_ENABLE_IBT 0x1 >> +#define BT_CR1 0x4 >> +#define BT_CR1_IRQ_H2B 0x01 >> +#define BT_CR1_IRQ_HBUSY 0x40 >> +#define BT_CR2 0x8 >> +#define BT_CR2_IRQ_H2B 0x01 >> +#define BT_CR2_IRQ_HBUSY 0x40 >> +#define BT_CR3 0xc >> +#define BT_CTRL 0x10 >> +#define BT_CTRL_B_BUSY 0x80 >> +#define BT_CTRL_H_BUSY 0x40 >> +#define BT_CTRL_OEM0 0x20 >> +#define BT_CTRL_SMS_ATN 0x10 >> +#define BT_CTRL_B2H_ATN 0x08 >> +#define BT_CTRL_H2B_ATN 0x04 >> +#define BT_CTRL_CLR_RD_PTR 0x02 >> +#define BT_CTRL_CLR_WR_PTR 0x01 >> +#define BT_BMC2HOST 0x14 >> +#define BT_INTMASK 0x18 >> +#define BT_INTMASK_B2H_IRQEN 0x01 >> +#define BT_INTMASK_B2H_IRQ 0x02 >> +#define BT_INTMASK_BMC_HWRST 0x80 >> + >> +struct bt_bmc { >> + struct device dev; >> + struct miscdevice miscdev; >> + void __iomem *base; >> + int open_count; >> + int irq; >> + wait_queue_head_t queue; >> + struct timer_list poll_timer; >> +}; >> + >> +static u8 bt_inb(struct bt_bmc *bt_bmc, int reg) >> +{ >> + return ioread8(bt_bmc->base + reg); >> +} >> + >> +static void bt_outb(struct bt_bmc *bt_bmc, u8 data, int reg) >> +{ >> + iowrite8(data, bt_bmc->base + reg); >> +} >> + >> +static void clr_rd_ptr(struct bt_bmc *bt_bmc) >> +{ >> + bt_outb(bt_bmc, BT_CTRL_CLR_RD_PTR, BT_CTRL); >> +} >> + >> +static void clr_wr_ptr(struct bt_bmc *bt_bmc) >> +{ >> + bt_outb(bt_bmc, BT_CTRL_CLR_WR_PTR, BT_CTRL); >> +} >> + >> +static void clr_h2b_atn(struct bt_bmc *bt_bmc) >> +{ >> + bt_outb(bt_bmc, BT_CTRL_H2B_ATN, BT_CTRL); >> +} >> + >> +static void set_b_busy(struct bt_bmc *bt_bmc) >> +{ >> + if (!(bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_B_BUSY)) >> + bt_outb(bt_bmc, BT_CTRL_B_BUSY, BT_CTRL); >> +} >> + >> +static void clr_b_busy(struct bt_bmc *bt_bmc) >> +{ >> + if (bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_B_BUSY) >> + bt_outb(bt_bmc, BT_CTRL_B_BUSY, BT_CTRL); >> +} >> + >> +static void set_b2h_atn(struct bt_bmc *bt_bmc) >> +{ >> + bt_outb(bt_bmc, BT_CTRL_B2H_ATN, BT_CTRL); >> +} >> + >> +static u8 bt_read(struct bt_bmc *bt_bmc) >> +{ >> + return bt_inb(bt_bmc, BT_BMC2HOST); >> +} >> + >> +static ssize_t bt_readn(struct bt_bmc *bt_bmc, u8 *buf, size_t n) >> +{ >> + int i; >> + >> + for (i = 0; i < n; i++) >> + buf[i] = bt_read(bt_bmc); >> + return n; >> +} >> + >> +static void bt_write(struct bt_bmc *bt_bmc, u8 c) >> +{ >> + bt_outb(bt_bmc, c, BT_BMC2HOST); >> +} >> + >> +static ssize_t bt_writen(struct bt_bmc *bt_bmc, u8 *buf, size_t n) >> +{ >> + int i; >> + >> + for (i = 0; i < n; i++) >> + bt_write(bt_bmc, buf[i]); >> + return n; >> +} >> + >> +static void set_sms_atn(struct bt_bmc *bt_bmc) >> +{ >> + bt_outb(bt_bmc, BT_CTRL_SMS_ATN, BT_CTRL); >> +} >> + >> +static struct bt_bmc *file_bt_bmc(struct file *file) >> +{ >> + return container_of(file->private_data, struct bt_bmc, miscdev); >> +} >> + >> +static int bt_bmc_open(struct inode *inode, struct file *file) >> +{ >> + struct bt_bmc *bt_bmc = file_bt_bmc(file); >> + >> + clr_b_busy(bt_bmc); >> + >> + return 0; >> +} >> + >> +#define BT_BMC_BUFFER_SIZE 256 >> + >> +/* >> + * The BT (Block Transfer) interface means that entire messages are >> + * buffered by the host before a notification is sent to the BMC that >> + * there is data to be read. The first byte is the length and the >> + * message data follows. The read operation just tries to capture the >> + * whole before returning it to userspace. >> + */ >> +static ssize_t bt_bmc_read(struct file *file, char __user *buf, >> + size_t count, loff_t *ppos) >> +{ >> + struct bt_bmc *bt_bmc = file_bt_bmc(file); >> + u8 len; >> + int len_byte = 1; >> + u8 kbuffer[BT_BMC_BUFFER_SIZE]; >> + ssize_t ret = 0; >> + ssize_t nread; >> + >> + if (!access_ok(VERIFY_WRITE, buf, count)) >> + return -EFAULT; >> + >> + WARN_ON(*ppos); >> + >> + if (wait_event_interruptible(bt_bmc->queue, >> + bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_H2B_ATN)) >> + return -ERESTARTSYS; >> + >> + set_b_busy(bt_bmc); >> + clr_h2b_atn(bt_bmc); >> + clr_rd_ptr(bt_bmc); >> + >> + /* >> + * The BT frames start with the message length, which does not >> + * include the length byte. >> + */ >> + kbuffer[0] = bt_read(bt_bmc); >> + len = kbuffer[0]; >> + >> + /* We pass the length back to userspace as well */ >> + if (len + 1 > count) >> + len = count - 1; >> + >> + while (len) { >> + nread = min_t(ssize_t, len, sizeof(kbuffer) - len_byte); >> + >> + bt_readn(bt_bmc, kbuffer + len_byte, nread); >> + >> + if (copy_to_user(buf, kbuffer, nread + len_byte)) { >> + ret = -EFAULT; >> + break; >> + } >> + len -= nread; >> + buf += nread + len_byte; >> + ret += nread + len_byte; >> + len_byte = 0; >> + } >> + >> + clr_b_busy(bt_bmc); >> + >> + return ret; >> +} >> + >> +static ssize_t bt_bmc_write(struct file *file, const char __user *buf, >> + size_t count, loff_t *ppos) >> +{ >> + struct bt_bmc *bt_bmc = file_bt_bmc(file); >> + u8 kbuffer[BT_BMC_BUFFER_SIZE]; >> + ssize_t ret = 0; >> + ssize_t nwritten; >> + >> + if (!access_ok(VERIFY_READ, buf, count)) >> + return -EFAULT; >> + >> + WARN_ON(*ppos); >> + >> + /* There's no interrupt for clearing bmc busy so we have to >> + * poll >> + */ >> + if (wait_event_interruptible(bt_bmc->queue, >> + !(bt_inb(bt_bmc, BT_CTRL) & >> + (BT_CTRL_H_BUSY | BT_CTRL_B2H_ATN)))) >> + return -ERESTARTSYS; >> + >> + clr_wr_ptr(bt_bmc); >> + >> + while (count) { >> + nwritten = min_t(ssize_t, count, sizeof(kbuffer)); >> + if (copy_from_user(&kbuffer, buf, nwritten)) { >> + ret = -EFAULT; >> + break; >> + } >> + >> + bt_writen(bt_bmc, kbuffer, nwritten); >> + >> + count -= nwritten; >> + buf += nwritten; >> + ret += nwritten; >> + } >> + >> + set_b2h_atn(bt_bmc); >> + >> + return ret; >> +} >> + >> +static long bt_bmc_ioctl(struct file *file, unsigned int cmd, >> + unsigned long param) >> +{ >> + struct bt_bmc *bt_bmc = file_bt_bmc(file); >> + >> + switch (cmd) { >> + case BT_BMC_IOCTL_SMS_ATN: >> + set_sms_atn(bt_bmc); >> + return 0; >> + } >> + return -EINVAL; >> +} >> + >> +static int bt_bmc_release(struct inode *inode, struct file *file) >> +{ >> + struct bt_bmc *bt_bmc = file_bt_bmc(file); >> + >> + set_b_busy(bt_bmc); >> + return 0; >> +} >> + >> +static unsigned int bt_bmc_poll(struct file *file, poll_table *wait) >> +{ >> + struct bt_bmc *bt_bmc = file_bt_bmc(file); >> + unsigned int mask = 0; >> + uint8_t ctrl; >> + >> + poll_wait(file, &bt_bmc->queue, wait); >> + >> + ctrl = bt_inb(bt_bmc, BT_CTRL); >> + >> + if (ctrl & BT_CTRL_H2B_ATN) >> + mask |= POLLIN; >> + >> + if (!(ctrl & (BT_CTRL_H_BUSY | BT_CTRL_B2H_ATN))) >> + mask |= POLLOUT; >> + >> + return mask; >> +} >> + >> +static const struct file_operations bt_bmc_fops = { >> + .owner = THIS_MODULE, >> + .open = bt_bmc_open, >> + .read = bt_bmc_read, >> + .write = bt_bmc_write, >> + .release = bt_bmc_release, >> + .poll = bt_bmc_poll, >> + .unlocked_ioctl = bt_bmc_ioctl, >> +}; >> + >> +static void poll_timer(unsigned long data) >> +{ >> + struct bt_bmc *bt_bmc = (void *)data; >> + >> + bt_bmc->poll_timer.expires += msecs_to_jiffies(500); >> + wake_up(&bt_bmc->queue); >> + add_timer(&bt_bmc->poll_timer); >> +} >> + >> +static irqreturn_t bt_bmc_irq(int irq, void *arg) >> +{ >> + struct bt_bmc *bt_bmc = arg; >> + uint32_t reg; >> + >> + reg = ioread32(bt_bmc->base + BT_CR2); >> + reg &= BT_CR2_IRQ_H2B | BT_CR2_IRQ_HBUSY; >> + if (!reg) >> + return IRQ_NONE; >> + >> + /* ack pending IRQs */ >> + iowrite32(reg, bt_bmc->base + BT_CR2); >> + >> + wake_up(&bt_bmc->queue); >> + return IRQ_HANDLED; >> +} >> + >> +static int bt_bmc_config_irq(struct bt_bmc *bt_bmc, >> + struct platform_device *pdev) >> +{ >> + struct device *dev = &pdev->dev; >> + uint32_t reg; >> + int rc; >> + >> + bt_bmc->irq = platform_get_irq(pdev, 0); >> + if (!bt_bmc->irq) >> + return -ENODEV; >> + >> + rc = devm_request_irq(dev, bt_bmc->irq, bt_bmc_irq, IRQF_SHARED, >> + DEVICE_NAME, bt_bmc); >> + if (rc < 0) { >> + dev_warn(dev, "Unable to request IRQ %d\n", bt_bmc->irq); >> + bt_bmc->irq = 0; >> + return rc; >> + } >> + >> + /* Configure IRQs on the bmc clearing the H2B and HBUSY bits; >> + * H2B will be asserted when the bmc has data for us; HBUSY >> + * will be cleared (along with B2H) when we can write the next >> + * message to the BT buffer >> + */ >> + reg = ioread32(bt_bmc->base + BT_CR1); >> + reg |= BT_CR1_IRQ_H2B | BT_CR1_IRQ_HBUSY; >> + iowrite32(reg, bt_bmc->base + BT_CR1); >> + >> + return 0; >> +} >> + >> +static int bt_bmc_probe(struct platform_device *pdev) >> +{ >> + struct bt_bmc *bt_bmc; >> + struct device *dev; >> + struct resource *res; >> + int rc; >> + >> + if (!pdev || !pdev->dev.of_node) >> + return -ENODEV; >> + >> + dev = &pdev->dev; >> + dev_info(dev, "Found bt bmc device\n"); >> + >> + bt_bmc = devm_kzalloc(dev, sizeof(*bt_bmc), GFP_KERNEL); >> + if (!bt_bmc) >> + return -ENOMEM; >> + >> + dev_set_drvdata(&pdev->dev, bt_bmc); >> + >> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); >> + if (!res) { >> + dev_err(dev, "Unable to find resources\n"); >> + rc = -ENXIO; >> + goto out_free; >> + } >> + >> + bt_bmc->base = devm_ioremap_resource(&pdev->dev, res); >> + if (!bt_bmc->base) { >> + rc = -ENOMEM; >> + goto out_free; >> + } >> + >> + init_waitqueue_head(&bt_bmc->queue); >> + >> + bt_bmc->miscdev.minor = MISC_DYNAMIC_MINOR, >> + bt_bmc->miscdev.name = DEVICE_NAME, >> + bt_bmc->miscdev.fops = &bt_bmc_fops, >> + bt_bmc->miscdev.parent = dev; >> + rc = misc_register(&bt_bmc->miscdev); >> + if (rc) { >> + dev_err(dev, "Unable to register device\n"); >> + goto out_unmap; >> + } >> + >> + bt_bmc_config_irq(bt_bmc, pdev); >> + >> + if (bt_bmc->irq) { >> + dev_info(dev, "Using IRQ %d\n", bt_bmc->irq); >> + } else { >> + dev_info(dev, "No IRQ; using timer\n"); >> + setup_timer(&bt_bmc->poll_timer, poll_timer, >> + (unsigned long)bt_bmc); >> + bt_bmc->poll_timer.expires = jiffies + msecs_to_jiffies(10); >> + add_timer(&bt_bmc->poll_timer); >> + } >> + >> + iowrite32((BT_IO_BASE << BT_CR0_IO_BASE) | >> + (BT_IRQ << BT_CR0_IRQ) | >> + BT_CR0_EN_CLR_SLV_RDP | >> + BT_CR0_EN_CLR_SLV_WRP | >> + BT_CR0_ENABLE_IBT, >> + bt_bmc->base + BT_CR0); >> + >> + clr_b_busy(bt_bmc); >> + >> + return 0; >> + >> +out_unmap: >> + devm_iounmap(&pdev->dev, bt_bmc->base); >> + >> +out_free: >> + devm_kfree(dev, bt_bmc); >> + return rc; >> + >> +} >> + >> +static int bt_bmc_remove(struct platform_device *pdev) >> +{ >> + struct bt_bmc *bt_bmc = dev_get_drvdata(&pdev->dev); >> + >> + misc_deregister(&bt_bmc->miscdev); >> + if (!bt_bmc->irq) >> + del_timer_sync(&bt_bmc->poll_timer); >> + devm_iounmap(&pdev->dev, bt_bmc->base); >> + devm_kfree(&pdev->dev, bt_bmc); >> + bt_bmc = NULL; >> + >> + return 0; >> +} >> + >> +static const struct of_device_id bt_bmc_match[] = { >> + { .compatible = "aspeed,ast2400-bt-bmc" }, >> + { }, >> +}; >> + >> +static struct platform_driver bt_bmc_driver = { >> + .driver = { >> + .name = DEVICE_NAME, >> + .of_match_table = bt_bmc_match, >> + }, >> + .probe = bt_bmc_probe, >> + .remove = bt_bmc_remove, >> +}; >> + >> +module_platform_driver(bt_bmc_driver); >> + >> +MODULE_DEVICE_TABLE(of, bt_bmc_match); >> +MODULE_LICENSE("GPL"); >> +MODULE_AUTHOR("Alistair Popple "); >> +MODULE_DESCRIPTION("Linux device interface to the BT interface"); >> diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild >> index 185f8ea2702f..17b12942c67d 100644 >> --- a/include/uapi/linux/Kbuild >> +++ b/include/uapi/linux/Kbuild >> @@ -74,6 +74,7 @@ header-y += bpf_common.h >> header-y += bpf.h >> header-y += bpqether.h >> header-y += bsg.h >> +header-y += bt-bmc.h >> header-y += btrfs.h >> header-y += can.h >> header-y += capability.h >> diff --git a/include/uapi/linux/bt-bmc.h b/include/uapi/linux/bt-bmc.h >> new file mode 100644 >> index 000000000000..d9ec766a63d0 >> --- /dev/null >> +++ b/include/uapi/linux/bt-bmc.h >> @@ -0,0 +1,18 @@ >> +/* >> + * Copyright (c) 2015-2016, IBM Corporation. >> + * >> + * This program is free software; you can redistribute it and/or >> + * modify it under the terms of the GNU General Public License >> + * as published by the Free Software Foundation; either version >> + * 2 of the License, or (at your option) any later version. >> + */ >> + >> +#ifndef _UAPI_LINUX_BT_BMC_H >> +#define _UAPI_LINUX_BT_BMC_H >> + >> +#include >> + >> +#define __BT_BMC_IOCTL_MAGIC 0xb1 >> +#define BT_BMC_IOCTL_SMS_ATN _IO(__BT_BMC_IOCTL_MAGIC, 0x00) >> + >> +#endif /* _UAPI_LINUX_BT_BMC_H */ > >