From mboxrd@z Thu Jan 1 00:00:00 1970 From: Konrad Rzeszutek Wilk Subject: Re: [RFC v2] dma-mapping: Use unsigned long for dma_attrs Date: Tue, 31 May 2016 14:15:33 -0400 Message-ID: <20160531181533.GD11300@char.us.oracle.com> References: <1464609246-6948-1-git-send-email-k.kozlowski@samsung.com> <1464609246-6948-2-git-send-email-k.kozlowski@samsung.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1464609246-6948-2-git-send-email-k.kozlowski@samsung.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Krzysztof Kozlowski Cc: Michal Hocko , Arnd Bergmann , linux-doc@vger.kernel.org, Catalin Marinas , Bartlomiej Zolnierkiewicz , Will Deacon , Russell King , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, hch@infradead.org, iommu@lists.linux-foundation.org, linux-samsung-soc@vger.kernel.org, sstabellini@kernel.org, Andy Lutomirski , xen-devel@lists.xenproject.org, Andrew Morton , Mel Gorman , linux-arm-kernel@lists.infradead.org, Marek Szyprowski List-Id: iommu@lists.linux-foundation.org T24gTW9uLCBNYXkgMzAsIDIwMTYgYXQgMDE6NTQ6MDZQTSArMDIwMCwgS3J6eXN6dG9mIEtvemxv d3NraSB3cm90ZToKPiBUaGUgZG1hLW1hcHBpbmcgY29yZSBhbmQgdGhlIGltcGxlbWVudGF0aW9u cyBkbyBub3QgY2hhbmdlIHRoZQo+IERNQSBhdHRyaWJ1dGVzIHBhc3NlZCBieSBwb2ludGVyLiAg VGh1cyB0aGUgcG9pbnRlciBjYW4gcG9pbnQgdG8gY29uc3QKPiBkYXRhLiAgSG93ZXZlciB0aGUg YXR0cmlidXRlcyBkbyBub3QgaGF2ZSB0byBiZSBhIGJpdGZpZWxkLiBJbnN0ZWFkCj4gdW5zaWdu ZWQgbG9uZyB3aWxsIGRvIGZpbmU6Cj4gCj4gMS4gVGhpcyBpcyBqdXN0IHNpbXBsZXIuICBCb3Ro IGluIHRlcm1zIG9mIHJlYWRpbmcgdGhlIGNvZGUgYW5kIHNldHRpbmcKPiAgICBhdHRyaWJ1dGVz LiAgSW5zdGVhZCBvZiBpbml0aWFsaXppbmcgbG9jYWwgYXR0cmlidXRlcyBvbiB0aGUgc3RhY2sg YW5kCj4gICAgcGFzc2luZyBwb2ludGVyIHRvIGl0IHRvIGRtYV9zZXRfYXR0cigpLCBqdXN0IHNl dCB0aGUgYml0cy4KPiAKPiAyLiBJdCBicmluZ3Mgc2FmZW5lc3MgYW5kIGNoZWNraW5nIGZvciBj b25zdCBjb3JyZWN0bmVzcyBiZWNhdXNlIHRoZQo+ICAgIGF0dHJpYnV0ZXMgYXJlIHBhc3NlZCBi eSB2YWx1ZS4KCgouLiB3aHkgbm90IGdvIHRoZSBuZXh0IHN0ZXAgYSBkbyBhbiBlbnVtPyBQZXJo YXBzIHRoYXQgc2hvdWxkIGJlIG1lbnRpb25lZAphcyBwYXJ0IG9mIHRoZSBkZXNjcmlwdGlvbj8K ClRoYW5rcy4KPiAKPiBQbGVhc2UgaGF2ZSBpbiBtaW5kIHRoYXQgdGhpcyBpcyBSRkMsIG5vdCBm aW5pc2hlZCB5ZXQuICBPbmx5IEFSTSBhbmQKPiBBUk02NCBhcmUgZml4ZWQgKGFuZCBub3QgZXZl cnl3aGVyZSkuCj4gSG93ZXZlciBvdGhlciBBUEkgdXNlcnMgYWxzbyBoYXZlIHRvIGJlIGNvbnZl cnRlZCB3aGljaCBpcyBxdWl0ZQo+IGludHJ1c2l2ZS4gIEkgd291bGQgcmF0aGVyIGF2b2lkIGl0 IHVudGlsIHRoZSBvdmVyYWxsIGFwcHJvYWNoIGlzCj4gYWNjZXB0ZWQuCj4gCj4gU2lnbmVkLW9m Zi1ieTogS3J6eXN6dG9mIEtvemxvd3NraSA8ay5rb3psb3dza2lAc2Ftc3VuZy5jb20+Cj4gLS0t Cj4gIERvY3VtZW50YXRpb24vRE1BLUFQSS50eHQgICAgICAgICAgICAgICAgIHwgICAyICstCj4g IERvY3VtZW50YXRpb24vRE1BLWF0dHJpYnV0ZXMudHh0ICAgICAgICAgIHwgICAyICstCj4gIGFy Y2gvYXJtL2luY2x1ZGUvYXNtL2RtYS1tYXBwaW5nLmggICAgICAgIHwgIDEzICsrLS0KPiAgYXJj aC9hcm0vaW5jbHVkZS9hc20veGVuL3BhZ2UtY29oZXJlbnQuaCAgfCAgMTYgKystLS0KPiAgYXJj aC9hcm0vbW0vZG1hLW1hcHBpbmcuYyAgICAgICAgICAgICAgICAgfCAgODIgKysrKysrKysrKyst LS0tLS0tLS0tLS0KPiAgYXJjaC9hcm0veGVuL21tLmMgICAgICAgICAgICAgICAgICAgICAgICAg fCAgIDQgKy0KPiAgYXJjaC9hcm02NC9tbS9kbWEtbWFwcGluZy5jICAgICAgICAgICAgICAgfCAg NTcgKysrKysrKystLS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1f ZmJkZXYuYyB8ICAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZzJk LmMgICB8ICAgMSAtCj4gIGRyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2RybV9nZW0uYyAg IHwgIDIwICsrKy0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZ2VtLmgg ICB8ICAgMiArLQo+ICBkcml2ZXJzL2lvbW11L2RtYS1pb21tdS5jICAgICAgICAgICAgICAgICB8 ICAgNiArLQo+ICBkcml2ZXJzL3hlbi9zd2lvdGxiLXhlbi5jICAgICAgICAgICAgICAgICB8ICAx NCArKy0tCj4gIGluY2x1ZGUvbGludXgvZG1hLWF0dHJzLmggICAgICAgICAgICAgICAgIHwgIDcx IC0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gIGluY2x1ZGUvbGludXgvZG1hLWlvbW11LmggICAgICAg ICAgICAgICAgIHwgICA2ICstCj4gIGluY2x1ZGUvbGludXgvZG1hLW1hcHBpbmcuaCAgICAgICAg ICAgICAgIHwgMTA1ICsrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLQo+ICBpbmNsdWRlL2xp bnV4L3N3aW90bGIuaCAgICAgICAgICAgICAgICAgICB8ICAxMCArLS0KPiAgaW5jbHVkZS94ZW4v c3dpb3RsYi14ZW4uaCAgICAgICAgICAgICAgICAgfCAgMTIgKystLQo+ICBsaWIvZG1hLW5vb3Au YyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgOSArLS0KPiAgbGliL3N3aW90bGIuYyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTMgKystLQo+ICAyMCBmaWxlcyBjaGFuZ2Vk LCAxOTUgaW5zZXJ0aW9ucygrKSwgMjUyIGRlbGV0aW9ucygtKQo+ICBkZWxldGUgbW9kZSAxMDA2 NDQgaW5jbHVkZS9saW51eC9kbWEtYXR0cnMuaAo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0 aW9uL0RNQS1BUEkudHh0IGIvRG9jdW1lbnRhdGlvbi9ETUEtQVBJLnR4dAo+IGluZGV4IDQ1ZWYz ZjI3OWMzYi4uMGI1NWNiN2M1YWFhIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vRE1BLUFQ SS50eHQKPiArKysgYi9Eb2N1bWVudGF0aW9uL0RNQS1BUEkudHh0Cj4gQEAgLTM5MSw3ICszOTEs NyBAQCB3aXRob3V0IHRoZSBfYXR0cnMgc3VmZml4ZXMsIGV4Y2VwdCB0aGF0IHRoZXkgcGFzcyBh biBvcHRpb25hbAo+ICBzdHJ1Y3QgZG1hX2F0dHJzKi4KPiAgCj4gIHN0cnVjdCBkbWFfYXR0cnMg ZW5jYXBzdWxhdGVzIGEgc2V0IG9mICJETUEgYXR0cmlidXRlcyIuIEZvciB0aGUKPiAtZGVmaW5p dGlvbiBvZiBzdHJ1Y3QgZG1hX2F0dHJzIHNlZSBsaW51eC9kbWEtYXR0cnMuaC4KPiArZGVmaW5p dGlvbiBvZiBzdHJ1Y3QgZG1hX2F0dHJzIHNlZSBsaW51eC9kbWEtbWFwcGluZy5oLgo+ICAKPiAg VGhlIGludGVycHJldGF0aW9uIG9mIERNQSBhdHRyaWJ1dGVzIGlzIGFyY2hpdGVjdHVyZS1zcGVj aWZpYywgYW5kCj4gIGVhY2ggYXR0cmlidXRlIHNob3VsZCBiZSBkb2N1bWVudGVkIGluIERvY3Vt ZW50YXRpb24vRE1BLWF0dHJpYnV0ZXMudHh0Lgo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9u L0RNQS1hdHRyaWJ1dGVzLnR4dCBiL0RvY3VtZW50YXRpb24vRE1BLWF0dHJpYnV0ZXMudHh0Cj4g aW5kZXggZThjZjljZjg3M2IzLi4yZDQ1NWE1Y2Y2NzEgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRh dGlvbi9ETUEtYXR0cmlidXRlcy50eHQKPiArKysgYi9Eb2N1bWVudGF0aW9uL0RNQS1hdHRyaWJ1 dGVzLnR4dAo+IEBAIC0yLDcgKzIsNyBAQAo+ICAJCQk9PT09PT09PT09PT09PQo+ICAKPiAgVGhp cyBkb2N1bWVudCBkZXNjcmliZXMgdGhlIHNlbWFudGljcyBvZiB0aGUgRE1BIGF0dHJpYnV0ZXMg dGhhdCBhcmUKPiAtZGVmaW5lZCBpbiBsaW51eC9kbWEtYXR0cnMuaC4KPiArZGVmaW5lZCBpbiBs aW51eC9kbWEtbWFwcGluZy5oLgo+ICAKPiAgRE1BX0FUVFJfV1JJVEVfQkFSUklFUgo+ICAtLS0t LS0tLS0tLS0tLS0tLS0tLS0tCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2Rt YS1tYXBwaW5nLmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9kbWEtbWFwcGluZy5oCj4gaW5kZXgg YTgzNTcwZjEwMTI0Li5kMDA5Zjc5MTFmZmMgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0vaW5jbHVk ZS9hc20vZG1hLW1hcHBpbmcuaAo+ICsrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2RtYS1tYXBw aW5nLmgKPiBAQCAtNSw3ICs1LDYgQEAKPiAgCj4gICNpbmNsdWRlIDxsaW51eC9tbV90eXBlcy5o Pgo+ICAjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KPiAtI2luY2x1ZGUgPGxpbnV4L2Rt YS1hdHRycy5oPgo+ICAjaW5jbHVkZSA8bGludXgvZG1hLWRlYnVnLmg+Cj4gIAo+ICAjaW5jbHVk ZSA8YXNtL21lbW9yeS5oPgo+IEBAIC0xNzQsNyArMTczLDcgQEAgc3RhdGljIGlubGluZSB2b2lk IGRtYV9tYXJrX2NsZWFuKHZvaWQgKmFkZHIsIHNpemVfdCBzaXplKSB7IH0KPiAgICogdG8gYmUg dGhlIGRldmljZS12aWV3ZWQgYWRkcmVzcy4KPiAgICovCj4gIGV4dGVybiB2b2lkICphcm1fZG1h X2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIGRtYV9hZGRyX3QgKmhhbmRs ZSwKPiAtCQkJICAgZ2ZwX3QgZ2ZwLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwkJCSAg IGdmcF90IGdmcCwgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICAvKioKPiAgICogYXJtX2Rt YV9mcmVlIC0gZnJlZSBtZW1vcnkgYWxsb2NhdGVkIGJ5IGFybV9kbWFfYWxsb2MKPiBAQCAtMTkx LDcgKzE5MCw3IEBAIGV4dGVybiB2b2lkICphcm1fZG1hX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRl diwgc2l6ZV90IHNpemUsIGRtYV9hZGRyX3QgKmhhbmRsZSwKPiAgICogZHVyaW5nIGFuZCBhZnRl ciB0aGlzIGNhbGwgZXhlY3V0aW5nIGFyZSBpbGxlZ2FsLgo+ICAgKi8KPiAgZXh0ZXJuIHZvaWQg YXJtX2RtYV9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIHZvaWQgKmNwdV9h ZGRyLAo+IC0JCQkgZG1hX2FkZHJfdCBoYW5kbGUsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsK PiArCQkJIGRtYV9hZGRyX3QgaGFuZGxlLCB1bnNpZ25lZCBsb25nIGF0dHJzKTsKPiAgCj4gIC8q Kgo+ICAgKiBhcm1fZG1hX21tYXAgLSBtYXAgYSBjb2hlcmVudCBETUEgYWxsb2NhdGlvbiBpbnRv IHVzZXIgc3BhY2UKPiBAQCAtMjA4LDcgKzIwNyw3IEBAIGV4dGVybiB2b2lkIGFybV9kbWFfZnJl ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLCB2b2lkICpjcHVfYWRkciwKPiAgICov Cj4gIGV4dGVybiBpbnQgYXJtX2RtYV9tbWFwKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHZt X2FyZWFfc3RydWN0ICp2bWEsCj4gIAkJCXZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90IGRtYV9h ZGRyLCBzaXplX3Qgc2l6ZSwKPiAtCQkJc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpOwo+ICsJCQl1 bnNpZ25lZCBsb25nIGF0dHJzKTsKPiAgCj4gIC8qCj4gICAqIFRoaXMgY2FuIGJlIGNhbGxlZCBk dXJpbmcgZWFybHkgYm9vdCB0byBpbmNyZWFzZSB0aGUgc2l6ZSBvZiB0aGUgYXRvbWljCj4gQEAg LTI2MiwxNiArMjYxLDE2IEBAIGV4dGVybiB2b2lkIGRtYWJvdW5jZV91bnJlZ2lzdGVyX2Rldihz dHJ1Y3QgZGV2aWNlICopOwo+ICAgKiBUaGUgc2NhdHRlciBsaXN0IHZlcnNpb25zIG9mIHRoZSBh Ym92ZSBtZXRob2RzLgo+ICAgKi8KPiAgZXh0ZXJuIGludCBhcm1fZG1hX21hcF9zZyhzdHJ1Y3Qg ZGV2aWNlICosIHN0cnVjdCBzY2F0dGVybGlzdCAqLCBpbnQsCj4gLQkJZW51bSBkbWFfZGF0YV9k aXJlY3Rpb24sIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiArCQllbnVtIGRtYV9kYXRhX2Rp cmVjdGlvbiwgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIGV4dGVybiB2b2lkIGFybV9kbWFfdW5t YXBfc2coc3RydWN0IGRldmljZSAqLCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKiwgaW50LAo+IC0JCWVu dW0gZG1hX2RhdGFfZGlyZWN0aW9uLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwkJZW51 bSBkbWFfZGF0YV9kaXJlY3Rpb24sIHVuc2lnbmVkIGxvbmcgYXR0cnMpOwo+ICBleHRlcm4gdm9p ZCBhcm1fZG1hX3N5bmNfc2dfZm9yX2NwdShzdHJ1Y3QgZGV2aWNlICosIHN0cnVjdCBzY2F0dGVy bGlzdCAqLCBpbnQsCj4gIAkJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24pOwo+ICBleHRlcm4gdm9p ZCBhcm1fZG1hX3N5bmNfc2dfZm9yX2RldmljZShzdHJ1Y3QgZGV2aWNlICosIHN0cnVjdCBzY2F0 dGVybGlzdCAqLCBpbnQsCj4gIAkJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24pOwo+ICBleHRlcm4g aW50IGFybV9kbWFfZ2V0X3NndGFibGUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2dfdGFi bGUgKnNndCwKPiAgCQl2b2lkICpjcHVfYWRkciwgZG1hX2FkZHJfdCBkbWFfYWRkciwgc2l6ZV90 IHNpemUsCj4gLQkJc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpOwo+ICsJCXVuc2lnbmVkIGxvbmcg YXR0cnMpOwo+ICAKPiAgI2VuZGlmIC8qIF9fS0VSTkVMX18gKi8KPiAgI2VuZGlmCj4gZGlmZiAt LWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3hlbi9wYWdlLWNvaGVyZW50LmggYi9hcmNoL2Fy bS9pbmNsdWRlL2FzbS94ZW4vcGFnZS1jb2hlcmVudC5oCj4gaW5kZXggOTQwOGE5OTRjYzkxLi45 NWNlNmFjM2E5NzEgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0vaW5jbHVkZS9hc20veGVuL3BhZ2Ut Y29oZXJlbnQuaAo+ICsrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3hlbi9wYWdlLWNvaGVyZW50 LmgKPiBAQCAtMiwxNSArMiwxNCBAQAo+ICAjZGVmaW5lIF9BU01fQVJNX1hFTl9QQUdFX0NPSEVS RU5UX0gKPiAgCj4gICNpbmNsdWRlIDxhc20vcGFnZS5oPgo+IC0jaW5jbHVkZSA8bGludXgvZG1h LWF0dHJzLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgo+ICAKPiAgdm9pZCBf X3hlbl9kbWFfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqaHdkZXYsIHN0cnVjdCBwYWdlICpwYWdl LAo+ICAJICAgICBkbWFfYWRkcl90IGRldl9hZGRyLCB1bnNpZ25lZCBsb25nIG9mZnNldCwgc2l6 ZV90IHNpemUsCj4gLQkgICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgc3RydWN0IGRt YV9hdHRycyAqYXR0cnMpOwo+ICsJICAgICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHVu c2lnbmVkIGxvbmcgYXR0cnMpOwo+ICB2b2lkIF9feGVuX2RtYV91bm1hcF9wYWdlKHN0cnVjdCBk ZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGhhbmRsZSwKPiAgCQlzaXplX3Qgc2l6ZSwgZW51bSBk bWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCXN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiAr CQl1bnNpZ25lZCBsb25nIGF0dHJzKTsKPiAgdm9pZCBfX3hlbl9kbWFfc3luY19zaW5nbGVfZm9y X2NwdShzdHJ1Y3QgZGV2aWNlICpod2RldiwKPiAgCQlkbWFfYWRkcl90IGhhbmRsZSwgc2l6ZV90 IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcik7Cj4gIAo+IEBAIC0xOCwyMiArMTcs MjAgQEAgdm9pZCBfX3hlbl9kbWFfc3luY19zaW5nbGVfZm9yX2RldmljZShzdHJ1Y3QgZGV2aWNl ICpod2RldiwKPiAgCQlkbWFfYWRkcl90IGhhbmRsZSwgc2l6ZV90IHNpemUsIGVudW0gZG1hX2Rh dGFfZGlyZWN0aW9uIGRpcik7Cj4gIAo+ICBzdGF0aWMgaW5saW5lIHZvaWQgKnhlbl9hbGxvY19j b2hlcmVudF9wYWdlcyhzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc2l6ZV90IHNpemUsCj4gLQkJZG1h X2FkZHJfdCAqZG1hX2hhbmRsZSwgZ2ZwX3QgZmxhZ3MsCj4gLQkJc3RydWN0IGRtYV9hdHRycyAq YXR0cnMpCj4gKwkJZG1hX2FkZHJfdCAqZG1hX2hhbmRsZSwgZ2ZwX3QgZmxhZ3MsIHVuc2lnbmVk IGxvbmcgYXR0cnMpCj4gIHsKPiAgCXJldHVybiBfX2dlbmVyaWNfZG1hX29wcyhod2RldiktPmFs bG9jKGh3ZGV2LCBzaXplLCBkbWFfaGFuZGxlLCBmbGFncywgYXR0cnMpOwo+ICB9Cj4gIAo+ICBz dGF0aWMgaW5saW5lIHZvaWQgeGVuX2ZyZWVfY29oZXJlbnRfcGFnZXMoc3RydWN0IGRldmljZSAq aHdkZXYsIHNpemVfdCBzaXplLAo+IC0JCXZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90IGRtYV9o YW5kbGUsCj4gLQkJc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJdm9pZCAqY3B1X2FkZHIs IGRtYV9hZGRyX3QgZG1hX2hhbmRsZSwgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJX19n ZW5lcmljX2RtYV9vcHMoaHdkZXYpLT5mcmVlKGh3ZGV2LCBzaXplLCBjcHVfYWRkciwgZG1hX2hh bmRsZSwgYXR0cnMpOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW5saW5lIHZvaWQgeGVuX2RtYV9tYXBf cGFnZShzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAkgICAgIGRt YV9hZGRyX3QgZGV2X2FkZHIsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCBzaXplX3Qgc2l6ZSwKPiAt CSAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRy cykKPiArCSAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLCB1bnNpZ25lZCBsb25nIGF0 dHJzKQo+ICB7Cj4gIAl1bnNpZ25lZCBsb25nIHBhZ2VfcGZuID0gcGFnZV90b194ZW5fcGZuKHBh Z2UpOwo+ICAJdW5zaWduZWQgbG9uZyBkZXZfcGZuID0gWEVOX1BGTl9ET1dOKGRldl9hZGRyKTsK PiBAQCAtNTgsOCArNTUsNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgeGVuX2RtYV9tYXBfcGFnZShz dHJ1Y3QgZGV2aWNlICpod2Rldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIH0KPiAgCj4gIHN0YXRp YyBpbmxpbmUgdm9pZCB4ZW5fZG1hX3VubWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqaHdkZXYsIGRt YV9hZGRyX3QgaGFuZGxlLAo+IC0JCXNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlv biBkaXIsCj4gLQkJc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJc2l6ZV90IHNpemUsIGVu dW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJ dW5zaWduZWQgbG9uZyBwZm4gPSBQRk5fRE9XTihoYW5kbGUpOwo+ICAJLyoKPiBkaWZmIC0tZ2l0 IGEvYXJjaC9hcm0vbW0vZG1hLW1hcHBpbmcuYyBiL2FyY2gvYXJtL21tL2RtYS1tYXBwaW5nLmMK PiBpbmRleCBmZjdlZDU2OTdkM2UuLmZlMzFmYmZkOTI2ZCAxMDA2NDQKPiAtLS0gYS9hcmNoL2Fy bS9tbS9kbWEtbWFwcGluZy5jCj4gKysrIGIvYXJjaC9hcm0vbW0vZG1hLW1hcHBpbmcuYwo+IEBA IC0xMjQsNyArMTI0LDcgQEAgc3RhdGljIHZvaWQgX19kbWFfcGFnZV9kZXZfdG9fY3B1KHN0cnVj dCBwYWdlICosIHVuc2lnbmVkIGxvbmcsCj4gICAqLwo+ICBzdGF0aWMgZG1hX2FkZHJfdCBhcm1f ZG1hX21hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAkg ICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJl Y3Rpb24gZGlyLAo+IC0JICAgICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCSAgICAgdW5z aWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJaWYgKCFkbWFfZ2V0X2F0dHIoRE1BX0FUVFJfU0tJ UF9DUFVfU1lOQywgYXR0cnMpKQo+ICAJCV9fZG1hX3BhZ2VfY3B1X3RvX2RldihwYWdlLCBvZmZz ZXQsIHNpemUsIGRpcik7Cj4gQEAgLTEzMyw3ICsxMzMsNyBAQCBzdGF0aWMgZG1hX2FkZHJfdCBh cm1fZG1hX21hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4g IAo+ICBzdGF0aWMgZG1hX2FkZHJfdCBhcm1fY29oZXJlbnRfZG1hX21hcF9wYWdlKHN0cnVjdCBk ZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAkgICAgIHVuc2lnbmVkIGxvbmcgb2Zm c2V0LCBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JICAgICBz dHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCSAgICAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAg ewo+ICAJcmV0dXJuIHBmbl90b19kbWEoZGV2LCBwYWdlX3RvX3BmbihwYWdlKSkgKyBvZmZzZXQ7 Cj4gIH0KPiBAQCAtMTUzLDggKzE1Myw3IEBAIHN0YXRpYyBkbWFfYWRkcl90IGFybV9jb2hlcmVu dF9kbWFfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnCj4gICAq IHdoYXRldmVyIHRoZSBkZXZpY2Ugd3JvdGUgdGhlcmUuCj4gICAqLwo+ICBzdGF0aWMgdm9pZCBh cm1fZG1hX3VubWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGhhbmRsZSwK PiAtCQlzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCXN0cnVj dCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCXNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVj dGlvbiBkaXIsIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCWlmICghZG1hX2dldF9hdHRy KERNQV9BVFRSX1NLSVBfQ1BVX1NZTkMsIGF0dHJzKSkKPiAgCQlfX2RtYV9wYWdlX2Rldl90b19j cHUocGZuX3RvX3BhZ2UoZG1hX3RvX3BmbihkZXYsIGhhbmRsZSkpLAo+IEBAIC0xOTQsMTIgKzE5 MywxMiBAQCBzdHJ1Y3QgZG1hX21hcF9vcHMgYXJtX2RtYV9vcHMgPSB7Cj4gIEVYUE9SVF9TWU1C T0woYXJtX2RtYV9vcHMpOwo+ICAKPiAgc3RhdGljIHZvaWQgKmFybV9jb2hlcmVudF9kbWFfYWxs b2Moc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPiAtCWRtYV9hZGRyX3QgKmhhbmRs ZSwgZ2ZwX3QgZ2ZwLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwlkbWFfYWRkcl90ICpo YW5kbGUsIGdmcF90IGdmcCwgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIHN0YXRpYyB2b2lkIGFy bV9jb2hlcmVudF9kbWFfZnJlZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLCB2b2lk ICpjcHVfYWRkciwKPiAtCQkJCSAgZG1hX2FkZHJfdCBoYW5kbGUsIHN0cnVjdCBkbWFfYXR0cnMg KmF0dHJzKTsKPiArCQkJCSAgZG1hX2FkZHJfdCBoYW5kbGUsIHVuc2lnbmVkIGxvbmcgYXR0cnMp Owo+ICBzdGF0aWMgaW50IGFybV9jb2hlcmVudF9kbWFfbW1hcChzdHJ1Y3QgZGV2aWNlICpkZXYs IHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+ICAJCSB2b2lkICpjcHVfYWRkciwgZG1hX2Fk ZHJfdCBkbWFfYWRkciwgc2l6ZV90IHNpemUsCj4gLQkJIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJz KTsKPiArCQkgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICBzdHJ1Y3QgZG1hX21hcF9vcHMg YXJtX2NvaGVyZW50X2RtYV9vcHMgPSB7Cj4gIAkuYWxsb2MJCQk9IGFybV9jb2hlcmVudF9kbWFf YWxsb2MsCj4gQEAgLTYyMSw3ICs2MjAsNyBAQCBzdGF0aWMgdm9pZCBfX2ZyZWVfZnJvbV9jb250 aWd1b3VzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAlkbWFfcmVs ZWFzZV9mcm9tX2NvbnRpZ3VvdXMoZGV2LCBwYWdlLCBzaXplID4+IFBBR0VfU0hJRlQpOwo+ICB9 Cj4gIAo+IC1zdGF0aWMgaW5saW5lIHBncHJvdF90IF9fZ2V0X2RtYV9wZ3Byb3Qoc3RydWN0IGRt YV9hdHRycyAqYXR0cnMsIHBncHJvdF90IHByb3QpCj4gK3N0YXRpYyBpbmxpbmUgcGdwcm90X3Qg X19nZXRfZG1hX3BncHJvdCh1bnNpZ25lZCBsb25nIGF0dHJzLCBwZ3Byb3RfdCBwcm90KQo+ICB7 Cj4gIAlwcm90ID0gZG1hX2dldF9hdHRyKERNQV9BVFRSX1dSSVRFX0NPTUJJTkUsIGF0dHJzKSA/ Cj4gIAkJCSAgICBwZ3Byb3Rfd3JpdGVjb21iaW5lKHByb3QpIDoKPiBAQCAtNzMyLDcgKzczMSw3 IEBAIHN0YXRpYyBzdHJ1Y3QgYXJtX2RtYV9hbGxvY2F0b3IgcmVtYXBfYWxsb2NhdG9yID0gewo+ ICAKPiAgc3RhdGljIHZvaWQgKl9fZG1hX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90 IHNpemUsIGRtYV9hZGRyX3QgKmhhbmRsZSwKPiAgCQkJIGdmcF90IGdmcCwgcGdwcm90X3QgcHJv dCwgYm9vbCBpc19jb2hlcmVudCwKPiAtCQkJIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzLCBjb25z dCB2b2lkICpjYWxsZXIpCj4gKwkJCSB1bnNpZ25lZCBsb25nIGF0dHJzLCBjb25zdCB2b2lkICpj YWxsZXIpCj4gIHsKPiAgCXU2NCBtYXNrID0gZ2V0X2NvaGVyZW50X2RtYV9tYXNrKGRldik7Cj4g IAlzdHJ1Y3QgcGFnZSAqcGFnZSA9IE5VTEw7Cj4gQEAgLTgxNCw3ICs4MTMsNyBAQCBzdGF0aWMg dm9pZCAqX19kbWFfYWxsb2Moc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwgZG1hX2Fk ZHJfdCAqaGFuZGxlLAo+ICAgKiB2aXJ0dWFsIGFuZCBidXMgYWRkcmVzcyBmb3IgdGhhdCBzcGFj ZS4KPiAgICovCj4gIHZvaWQgKmFybV9kbWFfYWxsb2Moc3RydWN0IGRldmljZSAqZGV2LCBzaXpl X3Qgc2l6ZSwgZG1hX2FkZHJfdCAqaGFuZGxlLAo+IC0JCSAgICBnZnBfdCBnZnAsIHN0cnVjdCBk bWFfYXR0cnMgKmF0dHJzKQo+ICsJCSAgICBnZnBfdCBnZnAsIHVuc2lnbmVkIGxvbmcgYXR0cnMp Cj4gIHsKPiAgCXBncHJvdF90IHByb3QgPSBfX2dldF9kbWFfcGdwcm90KGF0dHJzLCBQQUdFX0tF Uk5FTCk7Cj4gIAo+IEBAIC04MjMsNyArODIyLDcgQEAgdm9pZCAqYXJtX2RtYV9hbGxvYyhzdHJ1 Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLCBkbWFfYWRkcl90ICpoYW5kbGUsCj4gIH0KPiAg Cj4gIHN0YXRpYyB2b2lkICphcm1fY29oZXJlbnRfZG1hX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRl diwgc2l6ZV90IHNpemUsCj4gLQlkbWFfYWRkcl90ICpoYW5kbGUsIGdmcF90IGdmcCwgc3RydWN0 IGRtYV9hdHRycyAqYXR0cnMpCj4gKwlkbWFfYWRkcl90ICpoYW5kbGUsIGdmcF90IGdmcCwgdW5z aWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJcmV0dXJuIF9fZG1hX2FsbG9jKGRldiwgc2l6ZSwg aGFuZGxlLCBnZnAsIFBBR0VfS0VSTkVMLCB0cnVlLAo+ICAJCQkgICBhdHRycywgX19idWlsdGlu X3JldHVybl9hZGRyZXNzKDApKTsKPiBAQCAtODMxLDcgKzgzMCw3IEBAIHN0YXRpYyB2b2lkICph cm1fY29oZXJlbnRfZG1hX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4g IAo+ICBzdGF0aWMgaW50IF9fYXJtX2RtYV9tbWFwKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0 IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gIAkJIHZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90IGRt YV9hZGRyLCBzaXplX3Qgc2l6ZSwKPiAtCQkgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJ IHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCWludCByZXQgPSAtRU5YSU87Cj4gICNpZmRl ZiBDT05GSUdfTU1VCj4gQEAgLTg1OSwxNCArODU4LDE0IEBAIHN0YXRpYyBpbnQgX19hcm1fZG1h X21tYXAoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKPiAg ICovCj4gIHN0YXRpYyBpbnQgYXJtX2NvaGVyZW50X2RtYV9tbWFwKHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gIAkJIHZvaWQgKmNwdV9hZGRyLCBkbWFf YWRkcl90IGRtYV9hZGRyLCBzaXplX3Qgc2l6ZSwKPiAtCQkgc3RydWN0IGRtYV9hdHRycyAqYXR0 cnMpCj4gKwkJIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXJldHVybiBfX2FybV9kbWFf bW1hcChkZXYsIHZtYSwgY3B1X2FkZHIsIGRtYV9hZGRyLCBzaXplLCBhdHRycyk7Cj4gIH0KPiAg Cj4gIGludCBhcm1fZG1hX21tYXAoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgdm1fYXJlYV9z dHJ1Y3QgKnZtYSwKPiAgCQkgdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsIHNp emVfdCBzaXplLAo+IC0JCSBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkgdW5zaWduZWQg bG9uZyBhdHRycykKPiAgewo+ICAjaWZkZWYgQ09ORklHX01NVQo+ICAJdm1hLT52bV9wYWdlX3By b3QgPSBfX2dldF9kbWFfcGdwcm90KGF0dHJzLCB2bWEtPnZtX3BhZ2VfcHJvdCk7Cj4gQEAgLTg3 OCw3ICs4NzcsNyBAQCBpbnQgYXJtX2RtYV9tbWFwKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0 IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gICAqIEZyZWUgYSBidWZmZXIgYXMgZGVmaW5lZCBieSB0 aGUgYWJvdmUgbWFwcGluZy4KPiAgICovCj4gIHN0YXRpYyB2b2lkIF9fYXJtX2RtYV9mcmVlKHN0 cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIHZvaWQgKmNwdV9hZGRyLAo+IC0JCQkgICBk bWFfYWRkcl90IGhhbmRsZSwgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMsCj4gKwkJCSAgIGRtYV9h ZGRyX3QgaGFuZGxlLCB1bnNpZ25lZCBsb25nIGF0dHJzLAo+ICAJCQkgICBib29sIGlzX2NvaGVy ZW50KQo+ICB7Cj4gIAlzdHJ1Y3QgcGFnZSAqcGFnZSA9IHBmbl90b19wYWdlKGRtYV90b19wZm4o ZGV2LCBoYW5kbGUpKTsKPiBAQCAtOTAwLDIwICs4OTksMjAgQEAgc3RhdGljIHZvaWQgX19hcm1f ZG1hX2ZyZWUoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwgdm9pZCAqY3B1X2FkZHIs Cj4gIH0KPiAgCj4gIHZvaWQgYXJtX2RtYV9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90 IHNpemUsIHZvaWQgKmNwdV9hZGRyLAo+IC0JCSAgZG1hX2FkZHJfdCBoYW5kbGUsIHN0cnVjdCBk bWFfYXR0cnMgKmF0dHJzKQo+ICsJCSAgZG1hX2FkZHJfdCBoYW5kbGUsIHVuc2lnbmVkIGxvbmcg YXR0cnMpCj4gIHsKPiAgCV9fYXJtX2RtYV9mcmVlKGRldiwgc2l6ZSwgY3B1X2FkZHIsIGhhbmRs ZSwgYXR0cnMsIGZhbHNlKTsKPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQgYXJtX2NvaGVyZW50X2Rt YV9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIHZvaWQgKmNwdV9hZGRyLAo+ IC0JCQkJICBkbWFfYWRkcl90IGhhbmRsZSwgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJ CQkgIGRtYV9hZGRyX3QgaGFuZGxlLCB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlfX2Fy bV9kbWFfZnJlZShkZXYsIHNpemUsIGNwdV9hZGRyLCBoYW5kbGUsIGF0dHJzLCB0cnVlKTsKPiAg fQo+ICAKPiAgaW50IGFybV9kbWFfZ2V0X3NndGFibGUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1 Y3Qgc2dfdGFibGUgKnNndCwKPiAgCQkgdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3QgaGFuZGxl LCBzaXplX3Qgc2l6ZSwKPiAtCQkgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJIHVuc2ln bmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCBwYWdlICpwYWdlID0gcGZuX3RvX3BhZ2Uo ZG1hX3RvX3BmbihkZXYsIGhhbmRsZSkpOwo+ICAJaW50IHJldDsKPiBAQCAtMTA0Niw3ICsxMDQ1 LDcgQEAgc3RhdGljIHZvaWQgX19kbWFfcGFnZV9kZXZfdG9fY3B1KHN0cnVjdCBwYWdlICpwYWdl LCB1bnNpZ25lZCBsb25nIG9mZiwKPiAgICogaGVyZS4KPiAgICovCj4gIGludCBhcm1fZG1hX21h cF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csIGludCBuZW50 cywKPiAtCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0 dHJzKQo+ICsJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRy cykKPiAgewo+ICAJc3RydWN0IGRtYV9tYXBfb3BzICpvcHMgPSBnZXRfZG1hX29wcyhkZXYpOwo+ ICAJc3RydWN0IHNjYXR0ZXJsaXN0ICpzOwo+IEBAIC0xMDgwLDcgKzEwNzksNyBAQCBpbnQgYXJt X2RtYV9tYXBfc2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCBp bnQgbmVudHMsCj4gICAqIHJ1bGVzIGNvbmNlcm5pbmcgY2FsbHMgaGVyZSBhcmUgdGhlIHNhbWUg YXMgZm9yIGRtYV91bm1hcF9zaW5nbGUoKS4KPiAgICovCj4gIHZvaWQgYXJtX2RtYV91bm1hcF9z ZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csIGludCBuZW50cywK PiAtCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJz KQo+ICsJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRycykK PiAgewo+ICAJc3RydWN0IGRtYV9tYXBfb3BzICpvcHMgPSBnZXRfZG1hX29wcyhkZXYpOwo+ICAJ c3RydWN0IHNjYXR0ZXJsaXN0ICpzOwo+IEBAIC0xMjUzLDcgKzEyNTIsNyBAQCBzdGF0aWMgaW5s aW5lIHZvaWQgX19mcmVlX2lvdmEoc3RydWN0IGRtYV9pb21tdV9tYXBwaW5nICptYXBwaW5nLAo+ ICBzdGF0aWMgY29uc3QgaW50IGlvbW11X29yZGVyX2FycmF5W10gPSB7IDksIDgsIDQsIDAgfTsK PiAgCj4gIHN0YXRpYyBzdHJ1Y3QgcGFnZSAqKl9faW9tbXVfYWxsb2NfYnVmZmVyKHN0cnVjdCBk ZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gLQkJCQkJICBnZnBfdCBnZnAsIHN0cnVjdCBkbWFf YXR0cnMgKmF0dHJzKQo+ICsJCQkJCSAgZ2ZwX3QgZ2ZwLCB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ ICB7Cj4gIAlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOwo+ICAJaW50IGNvdW50ID0gc2l6ZSA+PiBQQUdF X1NISUZUOwo+IEBAIC0xMzQyLDcgKzEzNDEsNyBAQCBlcnJvcjoKPiAgfQo+ICAKPiAgc3RhdGlj IGludCBfX2lvbW11X2ZyZWVfYnVmZmVyKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2Ug KipwYWdlcywKPiAtCQkJICAgICAgIHNpemVfdCBzaXplLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRy cykKPiArCQkJICAgICAgIHNpemVfdCBzaXplLCB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4g IAlpbnQgY291bnQgPSBzaXplID4+IFBBR0VfU0hJRlQ7Cj4gIAlpbnQgaTsKPiBAQCAtMTQzOSw3 ICsxNDM4LDcgQEAgc3RhdGljIHN0cnVjdCBwYWdlICoqX19hdG9taWNfZ2V0X3BhZ2VzKHZvaWQg KmFkZHIpCj4gIAlyZXR1cm4gKHN0cnVjdCBwYWdlICoqKXBhZ2U7Cj4gIH0KPiAgCj4gLXN0YXRp YyBzdHJ1Y3QgcGFnZSAqKl9faW9tbXVfZ2V0X3BhZ2VzKHZvaWQgKmNwdV9hZGRyLCBzdHJ1Y3Qg ZG1hX2F0dHJzICphdHRycykKPiArc3RhdGljIHN0cnVjdCBwYWdlICoqX19pb21tdV9nZXRfcGFn ZXModm9pZCAqY3B1X2FkZHIsIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCB2 bV9zdHJ1Y3QgKmFyZWE7Cj4gIAo+IEBAIC0xNDg0LDcgKzE0ODMsNyBAQCBzdGF0aWMgdm9pZCBf X2lvbW11X2ZyZWVfYXRvbWljKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqY3B1X2FkZHIsCj4g IH0KPiAgCj4gIHN0YXRpYyB2b2lkICphcm1faW9tbXVfYWxsb2NfYXR0cnMoc3RydWN0IGRldmlj ZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPiAtCSAgICBkbWFfYWRkcl90ICpoYW5kbGUsIGdmcF90IGdm cCwgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkgICAgZG1hX2FkZHJfdCAqaGFuZGxlLCBn ZnBfdCBnZnAsIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXBncHJvdF90IHByb3QgPSBf X2dldF9kbWFfcGdwcm90KGF0dHJzLCBQQUdFX0tFUk5FTCk7Cj4gIAlzdHJ1Y3QgcGFnZSAqKnBh Z2VzOwo+IEBAIC0xNTMyLDcgKzE1MzEsNyBAQCBlcnJfYnVmZmVyOgo+ICAKPiAgc3RhdGljIGlu dCBhcm1faW9tbXVfbW1hcF9hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB2bV9hcmVh X3N0cnVjdCAqdm1hLAo+ICAJCSAgICB2b2lkICpjcHVfYWRkciwgZG1hX2FkZHJfdCBkbWFfYWRk ciwgc2l6ZV90IHNpemUsCj4gLQkJICAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCSAg ICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAl1bnNpZ25lZCBsb25nIHVhZGRyID0gdm1h LT52bV9zdGFydDsKPiAgCXVuc2lnbmVkIGxvbmcgdXNpemUgPSB2bWEtPnZtX2VuZCAtIHZtYS0+ dm1fc3RhcnQ7Cj4gQEAgLTE1NjgsNyArMTU2Nyw3IEBAIHN0YXRpYyBpbnQgYXJtX2lvbW11X21t YXBfYXR0cnMoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwK PiAgICogTXVzdCBub3QgYmUgY2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZC4KPiAgICovCj4gIHZv aWQgYXJtX2lvbW11X2ZyZWVfYXR0cnMoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwg dm9pZCAqY3B1X2FkZHIsCj4gLQkJCSAgZG1hX2FkZHJfdCBoYW5kbGUsIHN0cnVjdCBkbWFfYXR0 cnMgKmF0dHJzKQo+ICsJCQkgIGRtYV9hZGRyX3QgaGFuZGxlLCB1bnNpZ25lZCBsb25nIGF0dHJz KQo+ICB7Cj4gIAlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOwo+ICAJc2l6ZSA9IFBBR0VfQUxJR04oc2l6 ZSk7Cj4gQEAgLTE1OTUsNyArMTU5NCw3IEBAIHZvaWQgYXJtX2lvbW11X2ZyZWVfYXR0cnMoc3Ry dWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwgdm9pZCAqY3B1X2FkZHIsCj4gIAo+ICBzdGF0 aWMgaW50IGFybV9pb21tdV9nZXRfc2d0YWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBz Z190YWJsZSAqc2d0LAo+ICAJCQkJIHZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90IGRtYV9hZGRy LAo+IC0JCQkJIHNpemVfdCBzaXplLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkJCSBz aXplX3Qgc2l6ZSwgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJdW5zaWduZWQgaW50IGNv dW50ID0gUEFHRV9BTElHTihzaXplKSA+PiBQQUdFX1NISUZUOwo+ICAJc3RydWN0IHBhZ2UgKipw YWdlcyA9IF9faW9tbXVfZ2V0X3BhZ2VzKGNwdV9hZGRyLCBhdHRycyk7Cj4gQEAgLTE2MzMsNyAr MTYzMiw3IEBAIHN0YXRpYyBpbnQgX19kbWFfZGlyZWN0aW9uX3RvX3Byb3QoZW51bSBkbWFfZGF0 YV9kaXJlY3Rpb24gZGlyKQo+ICAgKi8KPiAgc3RhdGljIGludCBfX21hcF9zZ19jaHVuayhzdHJ1 Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCj4gIAkJCSAgc2l6ZV90IHNp emUsIGRtYV9hZGRyX3QgKmhhbmRsZSwKPiAtCQkJICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBk aXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzLAo+ICsJCQkgIGVudW0gZG1hX2RhdGFfZGlyZWN0 aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRycywKPiAgCQkJICBib29sIGlzX2NvaGVyZW50KQo+ ICB7Cj4gIAlzdHJ1Y3QgZG1hX2lvbW11X21hcHBpbmcgKm1hcHBpbmcgPSB0b19kbWFfaW9tbXVf bWFwcGluZyhkZXYpOwo+IEBAIC0xNjc2LDcgKzE2NzUsNyBAQCBmYWlsOgo+ICB9Cj4gIAo+ICBz dGF0aWMgaW50IF9faW9tbXVfbWFwX3NnKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0 ZXJsaXN0ICpzZywgaW50IG5lbnRzLAo+IC0JCSAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24g ZGlyLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycywKPiArCQkgICAgIGVudW0gZG1hX2RhdGFfZGly ZWN0aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRycywKPiAgCQkgICAgIGJvb2wgaXNfY29oZXJl bnQpCj4gIHsKPiAgCXN0cnVjdCBzY2F0dGVybGlzdCAqcyA9IHNnLCAqZG1hID0gc2csICpzdGFy dCA9IHNnOwo+IEBAIC0xNzM0LDcgKzE3MzMsNyBAQCBiYWRfbWFwcGluZzoKPiAgICogb2J0YWlu ZWQgdmlhIHNnX2RtYV97YWRkcmVzcyxsZW5ndGh9Lgo+ICAgKi8KPiAgaW50IGFybV9jb2hlcmVu dF9pb21tdV9tYXBfc2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNn LAo+IC0JCWludCBuZW50cywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLCBzdHJ1Y3QgZG1h X2F0dHJzICphdHRycykKPiArCQlpbnQgbmVudHMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp ciwgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJcmV0dXJuIF9faW9tbXVfbWFwX3NnKGRl diwgc2csIG5lbnRzLCBkaXIsIGF0dHJzLCB0cnVlKTsKPiAgfQo+IEBAIC0xNzUyLDE0ICsxNzUx LDE0IEBAIGludCBhcm1fY29oZXJlbnRfaW9tbXVfbWFwX3NnKHN0cnVjdCBkZXZpY2UgKmRldiwg c3RydWN0IHNjYXR0ZXJsaXN0ICpzZywKPiAgICogc2dfZG1hX3thZGRyZXNzLGxlbmd0aH0uCj4g ICAqLwo+ICBpbnQgYXJtX2lvbW11X21hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBz Y2F0dGVybGlzdCAqc2csCj4gLQkJaW50IG5lbnRzLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBk aXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCWludCBuZW50cywgZW51bSBkbWFfZGF0 YV9kaXJlY3Rpb24gZGlyLCB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlyZXR1cm4gX19p b21tdV9tYXBfc2coZGV2LCBzZywgbmVudHMsIGRpciwgYXR0cnMsIGZhbHNlKTsKPiAgfQo+ICAK PiAgc3RhdGljIHZvaWQgX19pb21tdV91bm1hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCBzY2F0dGVybGlzdCAqc2csCj4gLQkJaW50IG5lbnRzLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlv biBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzLAo+IC0JCWJvb2wgaXNfY29oZXJlbnQpCj4g KwkJaW50IG5lbnRzLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gKwkJdW5zaWduZWQg bG9uZyBhdHRycywgYm9vbCBpc19jb2hlcmVudCkKPiAgewo+ICAJc3RydWN0IHNjYXR0ZXJsaXN0 ICpzOwo+ICAJaW50IGk7Cj4gQEAgLTE3ODYsNyArMTc4NSw4IEBAIHN0YXRpYyB2b2lkIF9faW9t bXVfdW5tYXBfc2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAo+ ICAgKiBydWxlcyBjb25jZXJuaW5nIGNhbGxzIGhlcmUgYXJlIHRoZSBzYW1lIGFzIGZvciBkbWFf dW5tYXBfc2luZ2xlKCkuCj4gICAqLwo+ICB2b2lkIGFybV9jb2hlcmVudF9pb21tdV91bm1hcF9z ZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCj4gLQkJaW50IG5l bnRzLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJz KQo+ICsJCWludCBuZW50cywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+ICsJCXVuc2ln bmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCV9faW9tbXVfdW5tYXBfc2coZGV2LCBzZywgbmVudHMs IGRpciwgYXR0cnMsIHRydWUpOwo+ICB9Cj4gQEAgLTE4MDIsNyArMTgwMiw4IEBAIHZvaWQgYXJt X2NvaGVyZW50X2lvbW11X3VubWFwX3NnKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0 ZXJsaXN0ICpzZywKPiAgICogcnVsZXMgY29uY2VybmluZyBjYWxscyBoZXJlIGFyZSB0aGUgc2Ft ZSBhcyBmb3IgZG1hX3VubWFwX3NpbmdsZSgpLgo+ICAgKi8KPiAgdm9pZCBhcm1faW9tbXVfdW5t YXBfc2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCBpbnQgbmVu dHMsCj4gLQkJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgc3RydWN0IGRtYV9hdHRycyAq YXR0cnMpCj4gKwkJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiArCQkJdW5zaWduZWQg bG9uZyBhdHRycykKPiAgewo+ICAJX19pb21tdV91bm1hcF9zZyhkZXYsIHNnLCBuZW50cywgZGly LCBhdHRycywgZmFsc2UpOwo+ICB9Cj4gQEAgLTE4NTUsNyArMTg1Niw3IEBAIHZvaWQgYXJtX2lv bW11X3N5bmNfc2dfZm9yX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVy bGlzdCAqc2csCj4gICAqLwo+ICBzdGF0aWMgZG1hX2FkZHJfdCBhcm1fY29oZXJlbnRfaW9tbXVf bWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgCSAgICAg dW5zaWduZWQgbG9uZyBvZmZzZXQsIHNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlv biBkaXIsCj4gLQkgICAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJICAgICB1bnNpZ25l ZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlzdHJ1Y3QgZG1hX2lvbW11X21hcHBpbmcgKm1hcHBpbmcg PSB0b19kbWFfaW9tbXVfbWFwcGluZyhkZXYpOwo+ICAJZG1hX2FkZHJfdCBkbWFfYWRkcjsKPiBA QCAtMTg4OSw3ICsxODkwLDcgQEAgZmFpbDoKPiAgICovCj4gIHN0YXRpYyBkbWFfYWRkcl90IGFy bV9pb21tdV9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAo+ ICAJICAgICB1bnNpZ25lZCBsb25nIG9mZnNldCwgc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFf ZGlyZWN0aW9uIGRpciwKPiAtCSAgICAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkgICAg IHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCWlmICghZG1hX2dldF9hdHRyKERNQV9BVFRS X1NLSVBfQ1BVX1NZTkMsIGF0dHJzKSkKPiAgCQlfX2RtYV9wYWdlX2NwdV90b19kZXYocGFnZSwg b2Zmc2V0LCBzaXplLCBkaXIpOwo+IEBAIC0xOTA3LDggKzE5MDgsNyBAQCBzdGF0aWMgZG1hX2Fk ZHJfdCBhcm1faW9tbXVfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAq cGFnZSwKPiAgICogQ29oZXJlbnQgSU9NTVUgYXdhcmUgdmVyc2lvbiBvZiBhcm1fZG1hX3VubWFw X3BhZ2UoKQo+ICAgKi8KPiAgc3RhdGljIHZvaWQgYXJtX2NvaGVyZW50X2lvbW11X3VubWFwX3Bh Z2Uoc3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGhhbmRsZSwKPiAtCQlzaXplX3Qgc2l6 ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCXN0cnVjdCBkbWFfYXR0cnMgKmF0 dHJzKQo+ICsJCXNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHVuc2ln bmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCBkbWFfaW9tbXVfbWFwcGluZyAqbWFwcGlu ZyA9IHRvX2RtYV9pb21tdV9tYXBwaW5nKGRldik7Cj4gIAlkbWFfYWRkcl90IGlvdmEgPSBoYW5k bGUgJiBQQUdFX01BU0s7Cj4gQEAgLTE5MzIsOCArMTkzMiw3IEBAIHN0YXRpYyB2b2lkIGFybV9j b2hlcmVudF9pb21tdV91bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgZG1hX2FkZHJfdCBo YW5kbGUsCj4gICAqIElPTU1VIGF3YXJlIHZlcnNpb24gb2YgYXJtX2RtYV91bm1hcF9wYWdlKCkK PiAgICovCj4gIHN0YXRpYyB2b2lkIGFybV9pb21tdV91bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2Ug KmRldiwgZG1hX2FkZHJfdCBoYW5kbGUsCj4gLQkJc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFf ZGlyZWN0aW9uIGRpciwKPiAtCQlzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQlzaXplX3Qg c2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLCB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ ICB7Cj4gIAlzdHJ1Y3QgZG1hX2lvbW11X21hcHBpbmcgKm1hcHBpbmcgPSB0b19kbWFfaW9tbXVf bWFwcGluZyhkZXYpOwo+ICAJZG1hX2FkZHJfdCBpb3ZhID0gaGFuZGxlICYgUEFHRV9NQVNLOwo+ IEBAIC0xOTQ0LDYgKzE5NDMsNyBAQCBzdGF0aWMgdm9pZCBhcm1faW9tbXVfdW5tYXBfcGFnZShz dHJ1Y3QgZGV2aWNlICpkZXYsIGRtYV9hZGRyX3QgaGFuZGxlLAo+ICAJaWYgKCFpb3ZhKQo+ICAJ CXJldHVybjsKPiAgCj4gKwkvLyBGSVhNRTogcmVwbGFjZSBnZXQgd2l0aCBzaW1wbGUgY2hlY2sK PiAgCWlmICghZG1hX2dldF9hdHRyKERNQV9BVFRSX1NLSVBfQ1BVX1NZTkMsIGF0dHJzKSkKPiAg CQlfX2RtYV9wYWdlX2Rldl90b19jcHUocGFnZSwgb2Zmc2V0LCBzaXplLCBkaXIpOwo+ICAKPiBk aWZmIC0tZ2l0IGEvYXJjaC9hcm0veGVuL21tLmMgYi9hcmNoL2FybS94ZW4vbW0uYwo+IGluZGV4 IGM1ZjlhOWUzZDFmMy4uZmM2N2VkMjM2YTEwIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtL3hlbi9t bS5jCj4gKysrIGIvYXJjaC9hcm0veGVuL21tLmMKPiBAQCAtOTgsNyArOTgsNyBAQCBzdGF0aWMg dm9pZCBfX3hlbl9kbWFfcGFnZV9jcHVfdG9fZGV2KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBkbWFf YWRkcl90IGhhbmRsZSwKPiAgCj4gIHZvaWQgX194ZW5fZG1hX21hcF9wYWdlKHN0cnVjdCBkZXZp Y2UgKmh3ZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgCSAgICAgZG1hX2FkZHJfdCBkZXZfYWRk ciwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHNpemVfdCBzaXplLAo+IC0JICAgICBlbnVtIGRtYV9k YXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJICAgICBlbnVt IGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCWlm IChpc19kZXZpY2VfZG1hX2NvaGVyZW50KGh3ZGV2KSkKPiAgCQlyZXR1cm47Cj4gQEAgLTExMCw3 ICsxMTAsNyBAQCB2b2lkIF9feGVuX2RtYV9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpod2Rldiwg c3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAo+ICB2b2lkIF9feGVuX2RtYV91bm1hcF9wYWdlKHN0cnVj dCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGhhbmRsZSwKPiAgCQlzaXplX3Qgc2l6ZSwgZW51 bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCXN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ ICsJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIAo+ICB7Cj4gIAlpZiAoaXNfZGV2aWNlX2RtYV9j b2hlcmVudChod2RldikpCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvbW0vZG1hLW1hcHBpbmcu YyBiL2FyY2gvYXJtNjQvbW0vZG1hLW1hcHBpbmcuYwo+IGluZGV4IGM1NjZlYzgzNzE5Zi4uYTc2 ODYwMjhkZmViIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvbW0vZG1hLW1hcHBpbmcuYwo+ICsr KyBiL2FyY2gvYXJtNjQvbW0vZG1hLW1hcHBpbmcuYwo+IEBAIC0yOSw3ICsyOSw3IEBACj4gIAo+ ICAjaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KPiAgCj4gLXN0YXRpYyBwZ3Byb3RfdCBfX2dl dF9kbWFfcGdwcm90KHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzLCBwZ3Byb3RfdCBwcm90LAo+ICtz dGF0aWMgcGdwcm90X3QgX19nZXRfZG1hX3BncHJvdCh1bnNpZ25lZCBsb25nIGF0dHJzLCBwZ3By b3RfdCBwcm90LAo+ICAJCQkJIGJvb2wgY29oZXJlbnQpCj4gIHsKPiAgCWlmICghY29oZXJlbnQg fHwgZG1hX2dldF9hdHRyKERNQV9BVFRSX1dSSVRFX0NPTUJJTkUsIGF0dHJzKSkKPiBAQCAtODgs NyArODgsNyBAQCBzdGF0aWMgaW50IF9fZnJlZV9mcm9tX3Bvb2wodm9pZCAqc3RhcnQsIHNpemVf dCBzaXplKQo+ICAKPiAgc3RhdGljIHZvaWQgKl9fZG1hX2FsbG9jX2NvaGVyZW50KHN0cnVjdCBk ZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCQkgIGRtYV9hZGRyX3QgKmRtYV9oYW5kbGUs IGdmcF90IGZsYWdzLAo+IC0JCQkJICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkJCSAg dW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJaWYgKGRldiA9PSBOVUxMKSB7Cj4gIAkJV0FS Tl9PTkNFKDEsICJVc2UgYW4gYWN0dWFsIGRldmljZSBzdHJ1Y3R1cmUgZm9yIERNQSBhbGxvY2F0 aW9uXG4iKTsKPiBAQCAtMTE4LDcgKzExOCw3IEBAIHN0YXRpYyB2b2lkICpfX2RtYV9hbGxvY19j b2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICAKPiAgc3RhdGljIHZv aWQgX19kbWFfZnJlZV9jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ ICAJCQkJdm9pZCAqdmFkZHIsIGRtYV9hZGRyX3QgZG1hX2hhbmRsZSwKPiAtCQkJCXN0cnVjdCBk bWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJYm9v bCBmcmVlZDsKPiAgCXBoeXNfYWRkcl90IHBhZGRyID0gZG1hX3RvX3BoeXMoZGV2LCBkbWFfaGFu ZGxlKTsKPiBAQCAtMTM3LDcgKzEzNyw3IEBAIHN0YXRpYyB2b2lkIF9fZG1hX2ZyZWVfY29oZXJl bnQoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPiAgCj4gIHN0YXRpYyB2b2lkICpf X2RtYV9hbGxvYyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICAJCQkgZG1hX2Fk ZHJfdCAqZG1hX2hhbmRsZSwgZ2ZwX3QgZmxhZ3MsCj4gLQkJCSBzdHJ1Y3QgZG1hX2F0dHJzICph dHRycykKPiArCQkJIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCBwYWdlICpw YWdlOwo+ICAJdm9pZCAqcHRyLCAqY29oZXJlbnRfcHRyOwo+IEBAIC0xODUsNyArMTg1LDcgQEAg bm9fbWVtOgo+ICAKPiAgc3RhdGljIHZvaWQgX19kbWFfZnJlZShzdHJ1Y3QgZGV2aWNlICpkZXYs IHNpemVfdCBzaXplLAo+ICAJCSAgICAgICB2b2lkICp2YWRkciwgZG1hX2FkZHJfdCBkbWFfaGFu ZGxlLAo+IC0JCSAgICAgICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkgICAgICAgdW5z aWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJdm9pZCAqc3dpb3RsYl9hZGRyID0gcGh5c190b192 aXJ0KGRtYV90b19waHlzKGRldiwgZG1hX2hhbmRsZSkpOwo+ICAKPiBAQCAtMjAyLDcgKzIwMiw3 IEBAIHN0YXRpYyB2b2lkIF9fZG1hX2ZyZWUoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6 ZSwKPiAgc3RhdGljIGRtYV9hZGRyX3QgX19zd2lvdGxiX21hcF9wYWdlKHN0cnVjdCBkZXZpY2Ug KmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAkJCQkgICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0 LCBzaXplX3Qgc2l6ZSwKPiAgCQkJCSAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+ IC0JCQkJICAgICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkJCSAgICAgdW5zaWduZWQg bG9uZyBhdHRycykKPiAgewo+ICAJZG1hX2FkZHJfdCBkZXZfYWRkcjsKPiAgCj4gQEAgLTIxNiw3 ICsyMTYsNyBAQCBzdGF0aWMgZG1hX2FkZHJfdCBfX3N3aW90bGJfbWFwX3BhZ2Uoc3RydWN0IGRl dmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgCj4gIHN0YXRpYyB2b2lkIF9fc3dpb3Rs Yl91bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKPiAg CQkJCSBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkJIHN0 cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsK PiAgCWlmICghaXNfZGV2aWNlX2RtYV9jb2hlcmVudChkZXYpKQo+ICAJCV9fZG1hX3VubWFwX2Fy ZWEocGh5c190b192aXJ0KGRtYV90b19waHlzKGRldiwgZGV2X2FkZHIpKSwgc2l6ZSwgZGlyKTsK PiBAQCAtMjI1LDcgKzIyNSw3IEBAIHN0YXRpYyB2b2lkIF9fc3dpb3RsYl91bm1hcF9wYWdlKHN0 cnVjdCBkZXZpY2UgKmRldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKPiAgCj4gIHN0YXRpYyBpbnQg X19zd2lvdGxiX21hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVy bGlzdCAqc2dsLAo+ICAJCQkJICBpbnQgbmVsZW1zLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBk aXIsCj4gLQkJCQkgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJICB1bnNpZ25lZCBs b25nIGF0dHJzKQo+ICB7Cj4gIAlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOwo+ICAJaW50IGksIHJl dDsKPiBAQCAtMjQyLDcgKzI0Miw3IEBAIHN0YXRpYyBpbnQgX19zd2lvdGxiX21hcF9zZ19hdHRy cyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLAo+ICBzdGF0aWMg dm9pZCBfX3N3aW90bGJfdW5tYXBfc2dfYXR0cnMoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJCQkJ ICAgICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwgaW50IG5lbGVtcywKPiAgCQkJCSAgICAgZW51 bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkJICAgICBzdHJ1Y3QgZG1hX2F0dHJzICph dHRycykKPiArCQkJCSAgICAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJc3RydWN0IHNj YXR0ZXJsaXN0ICpzZzsKPiAgCWludCBpOwo+IEBAIC0zMDMsNyArMzAzLDcgQEAgc3RhdGljIHZv aWQgX19zd2lvdGxiX3N5bmNfc2dfZm9yX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIHN0 YXRpYyBpbnQgX19zd2lvdGxiX21tYXAoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJCQkgIHN0cnVj dCB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+ICAJCQkgIHZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90 IGRtYV9hZGRyLCBzaXplX3Qgc2l6ZSwKPiAtCQkJICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykK PiArCQkJICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlpbnQgcmV0ID0gLUVOWElPOwo+ ICAJdW5zaWduZWQgbG9uZyBucl92bWFfcGFnZXMgPSAodm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0 YXJ0KSA+Pgo+IEBAIC0zMzAsNyArMzMwLDcgQEAgc3RhdGljIGludCBfX3N3aW90bGJfbW1hcChz dHJ1Y3QgZGV2aWNlICpkZXYsCj4gIAo+ICBzdGF0aWMgaW50IF9fc3dpb3RsYl9nZXRfc2d0YWJs ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzZ190YWJsZSAqc2d0LAo+ICAJCQkJIHZvaWQg KmNwdV9hZGRyLCBkbWFfYWRkcl90IGhhbmRsZSwgc2l6ZV90IHNpemUsCj4gLQkJCQkgc3RydWN0 IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJCQkgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJ aW50IHJldCA9IHNnX2FsbG9jX3RhYmxlKHNndCwgMSwgR0ZQX0tFUk5FTCk7Cj4gIAo+IEBAIC00 MjUsMjEgKzQyNSwyMSBAQCBvdXQ6Cj4gIAo+ICBzdGF0aWMgdm9pZCAqX19kdW1teV9hbGxvYyhz dHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICAJCQkgICBkbWFfYWRkcl90ICpkbWFf aGFuZGxlLCBnZnBfdCBmbGFncywKPiAtCQkJICAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4g KwkJCSAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXJldHVybiBOVUxMOwo+ICB9Cj4g IAo+ICBzdGF0aWMgdm9pZCBfX2R1bW15X2ZyZWUoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qg c2l6ZSwKPiAgCQkJIHZvaWQgKnZhZGRyLCBkbWFfYWRkcl90IGRtYV9oYW5kbGUsCj4gLQkJCSBz dHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkJIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsK PiAgfQo+ICAKPiAgc3RhdGljIGludCBfX2R1bW15X21tYXAoc3RydWN0IGRldmljZSAqZGV2LAo+ ICAJCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKPiAgCQkJdm9pZCAqY3B1X2FkZHIsIGRt YV9hZGRyX3QgZG1hX2FkZHIsIHNpemVfdCBzaXplLAo+IC0JCQlzdHJ1Y3QgZG1hX2F0dHJzICph dHRycykKPiArCQkJdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJcmV0dXJuIC1FTlhJTzsK PiAgfQo+IEBAIC00NDcsMjAgKzQ0NywyMCBAQCBzdGF0aWMgaW50IF9fZHVtbXlfbW1hcChzdHJ1 Y3QgZGV2aWNlICpkZXYsCj4gIHN0YXRpYyBkbWFfYWRkcl90IF9fZHVtbXlfbWFwX3BhZ2Uoc3Ry dWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgCQkJCSAgIHVuc2lnbmVkIGxv bmcgb2Zmc2V0LCBzaXplX3Qgc2l6ZSwKPiAgCQkJCSAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9u IGRpciwKPiAtCQkJCSAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJICAgdW5zaWdu ZWQgbG9uZyBhdHRycykKPiAgewo+ICAJcmV0dXJuIERNQV9FUlJPUl9DT0RFOwo+ICB9Cj4gIAo+ ICBzdGF0aWMgdm9pZCBfX2R1bW15X3VubWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBkbWFf YWRkcl90IGRldl9hZGRyLAo+ICAJCQkgICAgICAgc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFf ZGlyZWN0aW9uIGRpciwKPiAtCQkJICAgICAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJ CQkgICAgICAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50 IF9fZHVtbXlfbWFwX3NnKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpz Z2wsCj4gIAkJCSAgaW50IG5lbGVtcywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0J CQkgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkgIHVuc2lnbmVkIGxvbmcgYXR0cnMp Cj4gIHsKPiAgCXJldHVybiAwOwo+ICB9Cj4gQEAgLTQ2OCw3ICs0NjgsNyBAQCBzdGF0aWMgaW50 IF9fZHVtbXlfbWFwX3NnKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpz Z2wsCj4gIHN0YXRpYyB2b2lkIF9fZHVtbXlfdW5tYXBfc2coc3RydWN0IGRldmljZSAqZGV2LAo+ ICAJCQkgICAgIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLCBpbnQgbmVsZW1zLAo+ICAJCQkgICAg IGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJICAgICBzdHJ1Y3QgZG1hX2F0dHJz ICphdHRycykKPiArCQkJICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIH0KPiAgCj4g QEAgLTU0MCw3ICs1NDAsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9wYWdlKHN0cnVjdCBkZXZpY2Ug KmRldiwgY29uc3Qgdm9pZCAqdmlydCwgcGh5c19hZGRyX3QgcGh5cykKPiAgCj4gIHN0YXRpYyB2 b2lkICpfX2lvbW11X2FsbG9jX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUs Cj4gIAkJCQkgZG1hX2FkZHJfdCAqaGFuZGxlLCBnZnBfdCBnZnAsCj4gLQkJCQkgc3RydWN0IGRt YV9hdHRycyAqYXR0cnMpCj4gKwkJCQkgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJYm9v bCBjb2hlcmVudCA9IGlzX2RldmljZV9kbWFfY29oZXJlbnQoZGV2KTsKPiAgCWludCBpb3Byb3Qg PSBkbWFfZGlyZWN0aW9uX3RvX3Byb3QoRE1BX0JJRElSRUNUSU9OQUwsIGNvaGVyZW50KTsKPiBA QCAtNjAwLDcgKzYwMCw4IEBAIHN0YXRpYyB2b2lkICpfX2lvbW11X2FsbG9jX2F0dHJzKHN0cnVj dCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIH0KPiAgCj4gIHN0YXRpYyB2b2lkIF9faW9t bXVfZnJlZV9hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLCB2b2lkICpjcHVf YWRkciwKPiAtCQkJICAgICAgIGRtYV9hZGRyX3QgaGFuZGxlLCBzdHJ1Y3QgZG1hX2F0dHJzICph dHRycykKPiArCQkJICAgICAgIGRtYV9hZGRyX3QgaGFuZGxlLAo+ICsJCQkgICAgICAgdW5zaWdu ZWQgbG9uZyBhdHRycykKPiAgewo+ICAJc2l6ZV90IGlvc2l6ZSA9IHNpemU7Cj4gIAo+IEBAIC02 MTYsNyArNjE3LDcgQEAgc3RhdGljIHZvaWQgX19pb21tdV9mcmVlX2F0dHJzKHN0cnVjdCBkZXZp Y2UgKmRldiwgc2l6ZV90IHNpemUsIHZvaWQgKmNwdV9hZGRyLAo+ICAJICogSGVuY2UgaG93IGRv ZGd5IHRoZSBiZWxvdyBsb2dpYyBsb29rcy4uLgo+ICAJICovCj4gIAlpZiAoX19pbl9hdG9taWNf cG9vbChjcHVfYWRkciwgc2l6ZSkpIHsKPiAtCQlpb21tdV9kbWFfdW5tYXBfcGFnZShkZXYsIGhh bmRsZSwgaW9zaXplLCAwLCBOVUxMKTsKPiArCQlpb21tdV9kbWFfdW5tYXBfcGFnZShkZXYsIGhh bmRsZSwgaW9zaXplLCAwLCAwKTsKPiAgCQlfX2ZyZWVfZnJvbV9wb29sKGNwdV9hZGRyLCBzaXpl KTsKPiAgCX0gZWxzZSBpZiAoaXNfdm1hbGxvY19hZGRyKGNwdV9hZGRyKSl7Cj4gIAkJc3RydWN0 IHZtX3N0cnVjdCAqYXJlYSA9IGZpbmRfdm1fYXJlYShjcHVfYWRkcik7Cj4gQEAgLTYyNiwxNCAr NjI3LDE0IEBAIHN0YXRpYyB2b2lkIF9faW9tbXVfZnJlZV9hdHRycyhzdHJ1Y3QgZGV2aWNlICpk ZXYsIHNpemVfdCBzaXplLCB2b2lkICpjcHVfYWRkciwKPiAgCQlpb21tdV9kbWFfZnJlZShkZXYs IGFyZWEtPnBhZ2VzLCBpb3NpemUsICZoYW5kbGUpOwo+ICAJCWRtYV9jb21tb25fZnJlZV9yZW1h cChjcHVfYWRkciwgc2l6ZSwgVk1fVVNFUk1BUCk7Cj4gIAl9IGVsc2Ugewo+IC0JCWlvbW11X2Rt YV91bm1hcF9wYWdlKGRldiwgaGFuZGxlLCBpb3NpemUsIDAsIE5VTEwpOwo+ICsJCWlvbW11X2Rt YV91bm1hcF9wYWdlKGRldiwgaGFuZGxlLCBpb3NpemUsIDAsIDApOwo+ICAJCV9fZnJlZV9wYWdl cyh2aXJ0X3RvX3BhZ2UoY3B1X2FkZHIpLCBnZXRfb3JkZXIoc2l6ZSkpOwo+ICAJfQo+ICB9Cj4g IAo+ICBzdGF0aWMgaW50IF9faW9tbXVfbW1hcF9hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0 cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+ICAJCQkgICAgICB2b2lkICpjcHVfYWRkciwgZG1h X2FkZHJfdCBkbWFfYWRkciwgc2l6ZV90IHNpemUsCj4gLQkJCSAgICAgIHN0cnVjdCBkbWFfYXR0 cnMgKmF0dHJzKQo+ICsJCQkgICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlzdHJ1 Y3Qgdm1fc3RydWN0ICphcmVhOwo+ICAJaW50IHJldDsKPiBAQCAtNjUzLDcgKzY1NCw3IEBAIHN0 YXRpYyBpbnQgX19pb21tdV9tbWFwX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHZt X2FyZWFfc3RydWN0ICp2bWEsCj4gIAo+ICBzdGF0aWMgaW50IF9faW9tbXVfZ2V0X3NndGFibGUo c3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCwKPiAgCQkJICAgICAgIHZv aWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90IGRtYV9hZGRyLAo+IC0JCQkgICAgICAgc2l6ZV90IHNp emUsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkgICAgICAgc2l6ZV90IHNpemUsIHVu c2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXVuc2lnbmVkIGludCBjb3VudCA9IFBBR0VfQUxJ R04oc2l6ZSkgPj4gUEFHRV9TSElGVDsKPiAgCXN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWEgPSBmaW5k X3ZtX2FyZWEoY3B1X2FkZHIpOwo+IEBAIC02OTQsNyArNjk1LDcgQEAgc3RhdGljIHZvaWQgX19p b21tdV9zeW5jX3NpbmdsZV9mb3JfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldiwKPiAgc3RhdGlj IGRtYV9hZGRyX3QgX19pb21tdV9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBw YWdlICpwYWdlLAo+ICAJCQkJICAgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHNpemVfdCBzaXplLAo+ ICAJCQkJICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkJICAgc3RydWN0IGRt YV9hdHRycyAqYXR0cnMpCj4gKwkJCQkgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAli b29sIGNvaGVyZW50ID0gaXNfZGV2aWNlX2RtYV9jb2hlcmVudChkZXYpOwo+ICAJaW50IHByb3Qg PSBkbWFfZGlyZWN0aW9uX3RvX3Byb3QoZGlyLCBjb2hlcmVudCk7Cj4gQEAgLTcwOSw3ICs3MTAs NyBAQCBzdGF0aWMgZG1hX2FkZHJfdCBfX2lvbW11X21hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAo+ICBzdGF0aWMgdm9pZCBfX2lvbW11X3VubWFwX3Bh Z2Uoc3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGRldl9hZGRyLAo+ICAJCQkgICAgICAg c2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJICAgICAgIHN0 cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkgICAgICAgdW5zaWduZWQgbG9uZyBhdHRycykK PiAgewo+ICAJaWYgKCFkbWFfZ2V0X2F0dHIoRE1BX0FUVFJfU0tJUF9DUFVfU1lOQywgYXR0cnMp KQo+ICAJCV9faW9tbXVfc3luY19zaW5nbGVfZm9yX2NwdShkZXYsIGRldl9hZGRyLCBzaXplLCBk aXIpOwo+IEBAIC03NDcsNyArNzQ4LDcgQEAgc3RhdGljIHZvaWQgX19pb21tdV9zeW5jX3NnX2Zv cl9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2LAo+ICAKPiAgc3RhdGljIGludCBfX2lvbW11X21h cF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLAo+ ICAJCQkJaW50IG5lbGVtcywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkJc3Ry dWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJCQl1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4g IAlib29sIGNvaGVyZW50ID0gaXNfZGV2aWNlX2RtYV9jb2hlcmVudChkZXYpOwo+ICAKPiBAQCAt NzYxLDcgKzc2Miw3IEBAIHN0YXRpYyBpbnQgX19pb21tdV9tYXBfc2dfYXR0cnMoc3RydWN0IGRl dmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwKPiAgc3RhdGljIHZvaWQgX19pb21t dV91bm1hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIAkJCQkgICBzdHJ1Y3Qgc2Nh dHRlcmxpc3QgKnNnbCwgaW50IG5lbGVtcywKPiAgCQkJCSAgIGVudW0gZG1hX2RhdGFfZGlyZWN0 aW9uIGRpciwKPiAtCQkJCSAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJICAgdW5z aWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJaWYgKCFkbWFfZ2V0X2F0dHIoRE1BX0FUVFJfU0tJ UF9DUFVfU1lOQywgYXR0cnMpKQo+ICAJCV9faW9tbXVfc3luY19zZ19mb3JfY3B1KGRldiwgc2ds LCBuZWxlbXMsIGRpcik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5 bm9zX2RybV9mYmRldi5jIGIvZHJpdmVycy9ncHUvZHJtL2V4eW5vcy9leHlub3NfZHJtX2ZiZGV2 LmMKPiBpbmRleCA2N2RjZDY4MzEyOTEuLmRkMDkxMTc1ZmMyZCAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZmJkZXYuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9leHlub3MvZXh5bm9zX2RybV9mYmRldi5jCj4gQEAgLTUyLDcgKzUyLDcgQEAgc3RhdGlj IGludCBleHlub3NfZHJtX2ZiX21tYXAoc3RydWN0IGZiX2luZm8gKmluZm8sCj4gIAo+ICAJcmV0 ID0gZG1hX21tYXBfYXR0cnModG9fZG1hX2RldihoZWxwZXItPmRldiksIHZtYSwgZXh5bm9zX2dl bS0+Y29va2llLAo+ICAJCQkgICAgIGV4eW5vc19nZW0tPmRtYV9hZGRyLCBleHlub3NfZ2VtLT5z aXplLAo+IC0JCQkgICAgICZleHlub3NfZ2VtLT5kbWFfYXR0cnMpOwo+ICsJCQkgICAgIGV4eW5v c19nZW0tPmRtYV9hdHRycyk7Cj4gIAlpZiAocmV0IDwgMCkgewo+ICAJCURSTV9FUlJPUigiZmFp bGVkIHRvIG1tYXAuXG4iKTsKPiAgCQlyZXR1cm4gcmV0Owo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZzJkLmMgYi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9z L2V4eW5vc19kcm1fZzJkLmMKPiBpbmRleCA0OTM1NTIzNjgyOTUuLmY2NWU2YjdlZjkzYiAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZzJkLmMKPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZzJkLmMKPiBAQCAtMTcsNyArMTcs NiBAQAo+ICAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ICAjaW5jbHVkZSA8bGludXgvd29ya3F1 ZXVlLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgo+IC0jaW5jbHVkZSA8bGlu dXgvZG1hLWF0dHJzLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9vZi5oPgo+ICAKPiAgI2luY2x1ZGUg PGRybS9kcm1QLmg+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9z X2RybV9nZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2RybV9nZW0uYwo+IGlu ZGV4IGNkZjlmMWFmNDM0Ny4uZjJhZTcyYmE3ZDVhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9leHlub3MvZXh5bm9zX2RybV9nZW0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9leHlu b3MvZXh5bm9zX2RybV9nZW0uYwo+IEBAIC0yNCw3ICsyNCw3IEBACj4gIHN0YXRpYyBpbnQgZXh5 bm9zX2RybV9hbGxvY19idWYoc3RydWN0IGV4eW5vc19kcm1fZ2VtICpleHlub3NfZ2VtKQo+ICB7 Cj4gIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZXh5bm9zX2dlbS0+YmFzZS5kZXY7Cj4gLQll bnVtIGRtYV9hdHRyIGF0dHI7Cj4gKwl1bnNpZ25lZCBsb25nIGF0dHI7Cj4gIAl1bnNpZ25lZCBp bnQgbnJfcGFnZXM7Cj4gIAlzdHJ1Y3Qgc2dfdGFibGUgc2d0Owo+ICAJaW50IHJldCA9IC1FTk9N RU07Cj4gQEAgLTM0LDcgKzM0LDcgQEAgc3RhdGljIGludCBleHlub3NfZHJtX2FsbG9jX2J1Zihz dHJ1Y3QgZXh5bm9zX2RybV9nZW0gKmV4eW5vc19nZW0pCj4gIAkJcmV0dXJuIDA7Cj4gIAl9Cj4g IAo+IC0JaW5pdF9kbWFfYXR0cnMoJmV4eW5vc19nZW0tPmRtYV9hdHRycyk7Cj4gKwlleHlub3Nf Z2VtLT5kbWFfYXR0cnMgPSAwOwo+ICAKPiAgCS8qCj4gIAkgKiBpZiBFWFlOT1NfQk9fQ09OVElH LCBmdWxseSBwaHlzaWNhbGx5IGNvbnRpZ3VvdXMgbWVtb3J5Cj4gQEAgLTQyLDcgKzQyLDcgQEAg c3RhdGljIGludCBleHlub3NfZHJtX2FsbG9jX2J1ZihzdHJ1Y3QgZXh5bm9zX2RybV9nZW0gKmV4 eW5vc19nZW0pCj4gIAkgKiBhcyBwb3NzaWJsZS4KPiAgCSAqLwo+ICAJaWYgKCEoZXh5bm9zX2dl bS0+ZmxhZ3MgJiBFWFlOT1NfQk9fTk9OQ09OVElHKSkKPiAtCQlkbWFfc2V0X2F0dHIoRE1BX0FU VFJfRk9SQ0VfQ09OVElHVU9VUywgJmV4eW5vc19nZW0tPmRtYV9hdHRycyk7Cj4gKwkJZXh5bm9z X2dlbS0+ZG1hX2F0dHJzIHw9IERNQV9BVFRSX0ZPUkNFX0NPTlRJR1VPVVM7Cj4gIAo+ICAJLyoK PiAgCSAqIGlmIEVYWU5PU19CT19XQyBvciBFWFlOT1NfQk9fTk9OQ0FDSEFCTEUsIHdyaXRlY29t YmluZSBtYXBwaW5nCj4gQEAgLTU0LDggKzU0LDggQEAgc3RhdGljIGludCBleHlub3NfZHJtX2Fs bG9jX2J1ZihzdHJ1Y3QgZXh5bm9zX2RybV9nZW0gKmV4eW5vc19nZW0pCj4gIAllbHNlCj4gIAkJ YXR0ciA9IERNQV9BVFRSX05PTl9DT05TSVNURU5UOwo+ICAKPiAtCWRtYV9zZXRfYXR0cihhdHRy LCAmZXh5bm9zX2dlbS0+ZG1hX2F0dHJzKTsKPiAtCWRtYV9zZXRfYXR0cihETUFfQVRUUl9OT19L RVJORUxfTUFQUElORywgJmV4eW5vc19nZW0tPmRtYV9hdHRycyk7Cj4gKwlleHlub3NfZ2VtLT5k bWFfYXR0cnMgfD0gYXR0cjsKPiArCWV4eW5vc19nZW0tPmRtYV9hdHRycyB8PSBETUFfQVRUUl9O T19LRVJORUxfTUFQUElORzsKPiAgCj4gIAlucl9wYWdlcyA9IGV4eW5vc19nZW0tPnNpemUgPj4g UEFHRV9TSElGVDsKPiAgCj4gQEAgLTY3LDcgKzY3LDcgQEAgc3RhdGljIGludCBleHlub3NfZHJt X2FsbG9jX2J1ZihzdHJ1Y3QgZXh5bm9zX2RybV9nZW0gKmV4eW5vc19nZW0pCj4gIAo+ICAJZXh5 bm9zX2dlbS0+Y29va2llID0gZG1hX2FsbG9jX2F0dHJzKHRvX2RtYV9kZXYoZGV2KSwgZXh5bm9z X2dlbS0+c2l6ZSwKPiAgCQkJCQkgICAgICZleHlub3NfZ2VtLT5kbWFfYWRkciwgR0ZQX0tFUk5F TCwKPiAtCQkJCQkgICAgICZleHlub3NfZ2VtLT5kbWFfYXR0cnMpOwo+ICsJCQkJCSAgICAgZXh5 bm9zX2dlbS0+ZG1hX2F0dHJzKTsKPiAgCWlmICghZXh5bm9zX2dlbS0+Y29va2llKSB7Cj4gIAkJ RFJNX0VSUk9SKCJmYWlsZWQgdG8gYWxsb2NhdGUgYnVmZmVyLlxuIik7Cj4gIAkJZ290byBlcnJf ZnJlZTsKPiBAQCAtNzUsNyArNzUsNyBAQCBzdGF0aWMgaW50IGV4eW5vc19kcm1fYWxsb2NfYnVm KHN0cnVjdCBleHlub3NfZHJtX2dlbSAqZXh5bm9zX2dlbSkKPiAgCj4gIAlyZXQgPSBkbWFfZ2V0 X3NndGFibGVfYXR0cnModG9fZG1hX2RldihkZXYpLCAmc2d0LCBleHlub3NfZ2VtLT5jb29raWUs Cj4gIAkJCQkgICAgZXh5bm9zX2dlbS0+ZG1hX2FkZHIsIGV4eW5vc19nZW0tPnNpemUsCj4gLQkJ CQkgICAgJmV4eW5vc19nZW0tPmRtYV9hdHRycyk7Cj4gKwkJCQkgICAgZXh5bm9zX2dlbS0+ZG1h X2F0dHJzKTsKPiAgCWlmIChyZXQgPCAwKSB7Cj4gIAkJRFJNX0VSUk9SKCJmYWlsZWQgdG8gZ2V0 IHNndGFibGUuXG4iKTsKPiAgCQlnb3RvIGVycl9kbWFfZnJlZTsKPiBAQCAtOTksNyArOTksNyBA QCBlcnJfc2d0X2ZyZWU6Cj4gIAlzZ19mcmVlX3RhYmxlKCZzZ3QpOwo+ICBlcnJfZG1hX2ZyZWU6 Cj4gIAlkbWFfZnJlZV9hdHRycyh0b19kbWFfZGV2KGRldiksIGV4eW5vc19nZW0tPnNpemUsIGV4 eW5vc19nZW0tPmNvb2tpZSwKPiAtCQkgICAgICAgZXh5bm9zX2dlbS0+ZG1hX2FkZHIsICZleHlu b3NfZ2VtLT5kbWFfYXR0cnMpOwo+ICsJCSAgICAgICBleHlub3NfZ2VtLT5kbWFfYWRkciwgZXh5 bm9zX2dlbS0+ZG1hX2F0dHJzKTsKPiAgZXJyX2ZyZWU6Cj4gIAlkcm1fZnJlZV9sYXJnZShleHlu b3NfZ2VtLT5wYWdlcyk7Cj4gIAo+IEBAIC0xMjAsNyArMTIwLDcgQEAgc3RhdGljIHZvaWQgZXh5 bm9zX2RybV9mcmVlX2J1ZihzdHJ1Y3QgZXh5bm9zX2RybV9nZW0gKmV4eW5vc19nZW0pCj4gIAo+ ICAJZG1hX2ZyZWVfYXR0cnModG9fZG1hX2RldihkZXYpLCBleHlub3NfZ2VtLT5zaXplLCBleHlu b3NfZ2VtLT5jb29raWUsCj4gIAkJCShkbWFfYWRkcl90KWV4eW5vc19nZW0tPmRtYV9hZGRyLAo+ IC0JCQkmZXh5bm9zX2dlbS0+ZG1hX2F0dHJzKTsKPiArCQkJZXh5bm9zX2dlbS0+ZG1hX2F0dHJz KTsKPiAgCj4gIAlkcm1fZnJlZV9sYXJnZShleHlub3NfZ2VtLT5wYWdlcyk7Cj4gIH0KPiBAQCAt MzQ2LDcgKzM0Niw3IEBAIHN0YXRpYyBpbnQgZXh5bm9zX2RybV9nZW1fbW1hcF9idWZmZXIoc3Ry dWN0IGV4eW5vc19kcm1fZ2VtICpleHlub3NfZ2VtLAo+ICAKPiAgCXJldCA9IGRtYV9tbWFwX2F0 dHJzKHRvX2RtYV9kZXYoZHJtX2RldiksIHZtYSwgZXh5bm9zX2dlbS0+Y29va2llLAo+ICAJCQkg ICAgIGV4eW5vc19nZW0tPmRtYV9hZGRyLCBleHlub3NfZ2VtLT5zaXplLAo+IC0JCQkgICAgICZl eHlub3NfZ2VtLT5kbWFfYXR0cnMpOwo+ICsJCQkgICAgIGV4eW5vc19nZW0tPmRtYV9hdHRycyk7 Cj4gIAlpZiAocmV0IDwgMCkgewo+ICAJCURSTV9FUlJPUigiZmFpbGVkIHRvIG1tYXAuXG4iKTsK PiAgCQlyZXR1cm4gcmV0Owo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4 eW5vc19kcm1fZ2VtLmggYi9kcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZ2VtLmgK PiBpbmRleCA3ODEwMDc0MjI4MWQuLmRmN2M1NDNkNjU1OCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcm1fZ2VtLmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v ZXh5bm9zL2V4eW5vc19kcm1fZ2VtLmgKPiBAQCAtNTAsNyArNTAsNyBAQCBzdHJ1Y3QgZXh5bm9z X2RybV9nZW0gewo+ICAJdm9pZAkJCSpjb29raWU7Cj4gIAl2b2lkIF9faW9tZW0JCSprdmFkZHI7 Cj4gIAlkbWFfYWRkcl90CQlkbWFfYWRkcjsKPiAtCXN0cnVjdCBkbWFfYXR0cnMJZG1hX2F0dHJz Owo+ICsJdW5zaWduZWQgbG9uZwkJZG1hX2F0dHJzOwo+ICAJc3RydWN0IHBhZ2UJCSoqcGFnZXM7 Cj4gIAlzdHJ1Y3Qgc2dfdGFibGUJCSpzZ3Q7Cj4gIH07Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv aW9tbXUvZG1hLWlvbW11LmMgYi9kcml2ZXJzL2lvbW11L2RtYS1pb21tdS5jCj4gaW5kZXggZWE1 YTllYmYwZjc4Li42YzFiZGE1MDRmYjEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9pb21tdS9kbWEt aW9tbXUuYwo+ICsrKyBiL2RyaXZlcnMvaW9tbXUvZG1hLWlvbW11LmMKPiBAQCAtMjg2LDcgKzI4 Niw3IEBAIHZvaWQgaW9tbXVfZG1hX2ZyZWUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFn ZSAqKnBhZ2VzLCBzaXplX3Qgc2l6ZSwKPiAgICoJICAgb3IgTlVMTCBvbiBmYWlsdXJlLgo+ICAg Ki8KPiAgc3RydWN0IHBhZ2UgKippb21tdV9kbWFfYWxsb2Moc3RydWN0IGRldmljZSAqZGV2LCBz aXplX3Qgc2l6ZSwgZ2ZwX3QgZ2ZwLAo+IC0JCXN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzLCBpbnQg cHJvdCwgZG1hX2FkZHJfdCAqaGFuZGxlLAo+ICsJCXVuc2lnbmVkIGxvbmcgYXR0cnMsIGludCBw cm90LCBkbWFfYWRkcl90ICpoYW5kbGUsCj4gIAkJdm9pZCAoKmZsdXNoX3BhZ2UpKHN0cnVjdCBk ZXZpY2UgKiwgY29uc3Qgdm9pZCAqLCBwaHlzX2FkZHJfdCkpCj4gIHsKPiAgCXN0cnVjdCBpb21t dV9kb21haW4gKmRvbWFpbiA9IGlvbW11X2dldF9kb21haW5fZm9yX2RldihkZXYpOwo+IEBAIC00 MDAsNyArNDAwLDcgQEAgZG1hX2FkZHJfdCBpb21tdV9kbWFfbWFwX3BhZ2Uoc3RydWN0IGRldmlj ZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgfQo+ICAKPiAgdm9pZCBpb21tdV9kbWFfdW5t YXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIGRtYV9hZGRyX3QgaGFuZGxlLCBzaXplX3Qgc2l6 ZSwKPiAtCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0 dHJzKQo+ICsJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRy cykKPiAgewo+ICAJX19pb21tdV9kbWFfdW5tYXAoaW9tbXVfZ2V0X2RvbWFpbl9mb3JfZGV2KGRl diksIGhhbmRsZSk7Cj4gIH0KPiBAQCAtNTYwLDcgKzU2MCw3IEBAIG91dF9yZXN0b3JlX3NnOgo+ ICB9Cj4gIAo+ICB2b2lkIGlvbW11X2RtYV91bm1hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0 cnVjdCBzY2F0dGVybGlzdCAqc2csIGludCBuZW50cywKPiAtCQllbnVtIGRtYV9kYXRhX2RpcmVj dGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCWVudW0gZG1hX2RhdGFfZGly ZWN0aW9uIGRpciwgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJLyoKPiAgCSAqIFRoZSBz Y2F0dGVybGlzdCBzZWdtZW50cyBhcmUgbWFwcGVkIGludG8gYSBzaW5nbGUKPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4vc3dpb3RsYi14ZW4uYyBiL2RyaXZlcnMveGVuL3N3aW90bGIteGVuLmMK PiBpbmRleCA3Mzk5NzgyYzA5OTguLjg3ZTYwMzVjOWU4MSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L3hlbi9zd2lvdGxiLXhlbi5jCj4gKysrIGIvZHJpdmVycy94ZW4vc3dpb3RsYi14ZW4uYwo+IEBA IC0yOTQsNyArMjk0LDcgQEAgZXJyb3I6Cj4gIHZvaWQgKgo+ICB4ZW5fc3dpb3RsYl9hbGxvY19j b2hlcmVudChzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc2l6ZV90IHNpemUsCj4gIAkJCSAgIGRtYV9h ZGRyX3QgKmRtYV9oYW5kbGUsIGdmcF90IGZsYWdzLAo+IC0JCQkgICBzdHJ1Y3QgZG1hX2F0dHJz ICphdHRycykKPiArCQkJICAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJdm9pZCAqcmV0 Owo+ICAJaW50IG9yZGVyID0gZ2V0X29yZGVyKHNpemUpOwo+IEBAIC0zNDYsNyArMzQ2LDcgQEAg RVhQT1JUX1NZTUJPTF9HUEwoeGVuX3N3aW90bGJfYWxsb2NfY29oZXJlbnQpOwo+ICAKPiAgdm9p ZAo+ICB4ZW5fc3dpb3RsYl9mcmVlX2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzaXpl X3Qgc2l6ZSwgdm9pZCAqdmFkZHIsCj4gLQkJCSAgZG1hX2FkZHJfdCBkZXZfYWRkciwgc3RydWN0 IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJCSAgZG1hX2FkZHJfdCBkZXZfYWRkciwgdW5zaWduZWQg bG9uZyBhdHRycykKPiAgewo+ICAJaW50IG9yZGVyID0gZ2V0X29yZGVyKHNpemUpOwo+ICAJcGh5 c19hZGRyX3QgcGh5czsKPiBAQCAtMzc4LDcgKzM3OCw3IEBAIEVYUE9SVF9TWU1CT0xfR1BMKHhl bl9zd2lvdGxiX2ZyZWVfY29oZXJlbnQpOwo+ICBkbWFfYWRkcl90IHhlbl9zd2lvdGxiX21hcF9w YWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAkJCQl1bnNpZ25l ZCBsb25nIG9mZnNldCwgc2l6ZV90IHNpemUsCj4gIAkJCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlv biBkaXIsCj4gLQkJCQlzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkJCXVuc2lnbmVkIGxv bmcgYXR0cnMpCj4gIHsKPiAgCXBoeXNfYWRkcl90IG1hcCwgcGh5cyA9IHBhZ2VfdG9fcGh5cyhw YWdlKSArIG9mZnNldDsKPiAgCWRtYV9hZGRyX3QgZGV2X2FkZHIgPSB4ZW5fcGh5c190b19idXMo cGh5cyk7Cj4gQEAgLTQzNCw3ICs0MzQsNyBAQCBFWFBPUlRfU1lNQk9MX0dQTCh4ZW5fc3dpb3Rs Yl9tYXBfcGFnZSk7Cj4gICAqLwo+ICBzdGF0aWMgdm9pZCB4ZW5fdW5tYXBfc2luZ2xlKHN0cnVj dCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGRldl9hZGRyLAo+ICAJCQkgICAgIHNpemVfdCBz aXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gLQkJCQkgc3RydWN0IGRtYV9hdHRy cyAqYXR0cnMpCj4gKwkJCSAgICAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJcGh5c19h ZGRyX3QgcGFkZHIgPSB4ZW5fYnVzX3RvX3BoeXMoZGV2X2FkZHIpOwo+ICAKPiBAQCAtNDYyLDcg KzQ2Miw3IEBAIHN0YXRpYyB2b2lkIHhlbl91bm1hcF9zaW5nbGUoc3RydWN0IGRldmljZSAqaHdk ZXYsIGRtYV9hZGRyX3QgZGV2X2FkZHIsCj4gIAo+ICB2b2lkIHhlbl9zd2lvdGxiX3VubWFwX3Bh Z2Uoc3RydWN0IGRldmljZSAqaHdkZXYsIGRtYV9hZGRyX3QgZGV2X2FkZHIsCj4gIAkJCSAgICBz aXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkgICAgc3RydWN0 IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJCSAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4g IAl4ZW5fdW5tYXBfc2luZ2xlKGh3ZGV2LCBkZXZfYWRkciwgc2l6ZSwgZGlyLCBhdHRycyk7Cj4g IH0KPiBAQCAtNTM4LDcgKzUzOCw3IEBAIEVYUE9SVF9TWU1CT0xfR1BMKHhlbl9zd2lvdGxiX3N5 bmNfc2luZ2xlX2Zvcl9kZXZpY2UpOwo+ICBpbnQKPiAgeGVuX3N3aW90bGJfbWFwX3NnX2F0dHJz KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwKPiAgCQkJIGlu dCBuZWxlbXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJIHN0cnVjdCBkbWFf YXR0cnMgKmF0dHJzKQo+ICsJCQkgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJc3RydWN0 IHNjYXR0ZXJsaXN0ICpzZzsKPiAgCWludCBpOwo+IEBAIC01OTksNyArNTk5LDcgQEAgRVhQT1JU X1NZTUJPTF9HUEwoeGVuX3N3aW90bGJfbWFwX3NnX2F0dHJzKTsKPiAgdm9pZAo+ICB4ZW5fc3dp b3RsYl91bm1hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc3RydWN0IHNjYXR0ZXJs aXN0ICpzZ2wsCj4gIAkJCSAgIGludCBuZWxlbXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp ciwKPiAtCQkJICAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJCSAgIHVuc2lnbmVkIGxv bmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7Cj4gIAlpbnQgaTsKPiBk aWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWEtYXR0cnMuaCBiL2luY2x1ZGUvbGludXgvZG1h LWF0dHJzLmgKPiBkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCA1MjQ2MjM5YTQ5NTMu LjAwMDAwMDAwMDAwMAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWF0dHJzLmgKPiArKysgL2Rl di9udWxsCj4gQEAgLTEsNzEgKzAsMCBAQAo+IC0jaWZuZGVmIF9ETUFfQVRUUl9ICj4gLSNkZWZp bmUgX0RNQV9BVFRSX0gKPiAtCj4gLSNpbmNsdWRlIDxsaW51eC9iaXRtYXAuaD4KPiAtI2luY2x1 ZGUgPGxpbnV4L2JpdG9wcy5oPgo+IC0jaW5jbHVkZSA8bGludXgvYnVnLmg+Cj4gLQo+IC0vKioK PiAtICogYW4gZW51bSBkbWFfYXR0ciByZXByZXNlbnRzIGFuIGF0dHJpYnV0ZSBhc3NvY2lhdGVk IHdpdGggYSBETUEKPiAtICogbWFwcGluZy4gVGhlIHNlbWFudGljcyBvZiBlYWNoIGF0dHJpYnV0 ZSBzaG91bGQgYmUgZGVmaW5lZCBpbgo+IC0gKiBEb2N1bWVudGF0aW9uL0RNQS1hdHRyaWJ1dGVz LnR4dC4KPiAtICovCj4gLWVudW0gZG1hX2F0dHIgewo+IC0JRE1BX0FUVFJfV1JJVEVfQkFSUklF UiwKPiAtCURNQV9BVFRSX1dFQUtfT1JERVJJTkcsCj4gLQlETUFfQVRUUl9XUklURV9DT01CSU5F LAo+IC0JRE1BX0FUVFJfTk9OX0NPTlNJU1RFTlQsCj4gLQlETUFfQVRUUl9OT19LRVJORUxfTUFQ UElORywKPiAtCURNQV9BVFRSX1NLSVBfQ1BVX1NZTkMsCj4gLQlETUFfQVRUUl9GT1JDRV9DT05U SUdVT1VTLAo+IC0JRE1BX0FUVFJfQUxMT0NfU0lOR0xFX1BBR0VTLAo+IC0JRE1BX0FUVFJfTUFY LAo+IC19Owo+IC0KPiAtI2RlZmluZSBfX0RNQV9BVFRSU19MT05HUyBCSVRTX1RPX0xPTkdTKERN QV9BVFRSX01BWCkKPiAtCj4gLS8qKgo+IC0gKiBzdHJ1Y3QgZG1hX2F0dHJzIC0gYW4gb3BhcXVl IGNvbnRhaW5lciBmb3IgRE1BIGF0dHJpYnV0ZXMKPiAtICogQGZsYWdzIC0gYml0bWFzayByZXBy ZXNlbnRpbmcgYSBjb2xsZWN0aW9uIG9mIGVudW0gZG1hX2F0dHIKPiAtICovCj4gLXN0cnVjdCBk bWFfYXR0cnMgewo+IC0JdW5zaWduZWQgbG9uZyBmbGFnc1tfX0RNQV9BVFRSU19MT05HU107Cj4g LX07Cj4gLQo+IC0jZGVmaW5lIERFRklORV9ETUFfQVRUUlMoeCkgCQkJCQlcCj4gLQlzdHJ1Y3Qg ZG1hX2F0dHJzIHggPSB7CQkJCQlcCj4gLQkJLmZsYWdzID0geyBbMCAuLi4gX19ETUFfQVRUUlNf TE9OR1MtMV0gPSAwIH0sCVwKPiAtCX0KPiAtCj4gLXN0YXRpYyBpbmxpbmUgdm9pZCBpbml0X2Rt YV9hdHRycyhzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiAtewo+IC0JYml0bWFwX3plcm8oYXR0 cnMtPmZsYWdzLCBfX0RNQV9BVFRSU19MT05HUyk7Cj4gLX0KPiAtCj4gLS8qKgo+IC0gKiBkbWFf c2V0X2F0dHIgLSBzZXQgYSBzcGVjaWZpYyBhdHRyaWJ1dGUKPiAtICogQGF0dHI6IGF0dHJpYnV0 ZSB0byBzZXQKPiAtICogQGF0dHJzOiBzdHJ1Y3QgZG1hX2F0dHJzIChtYXkgYmUgTlVMTCkKPiAt ICovCj4gLXN0YXRpYyBpbmxpbmUgdm9pZCBkbWFfc2V0X2F0dHIoZW51bSBkbWFfYXR0ciBhdHRy LCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiAtewo+IC0JaWYgKGF0dHJzID09IE5VTEwpCj4g LQkJcmV0dXJuOwo+IC0JQlVHX09OKGF0dHIgPj0gRE1BX0FUVFJfTUFYKTsKPiAtCV9fc2V0X2Jp dChhdHRyLCBhdHRycy0+ZmxhZ3MpOwo+IC19Cj4gLQo+IC0vKioKPiAtICogZG1hX2dldF9hdHRy IC0gY2hlY2sgZm9yIGEgc3BlY2lmaWMgYXR0cmlidXRlCj4gLSAqIEBhdHRyOiBhdHRyaWJ1dGUg dG8gc2V0Cj4gLSAqIEBhdHRyczogc3RydWN0IGRtYV9hdHRycyAobWF5IGJlIE5VTEwpCj4gLSAq Lwo+IC1zdGF0aWMgaW5saW5lIGludCBkbWFfZ2V0X2F0dHIoZW51bSBkbWFfYXR0ciBhdHRyLCBz dHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiAtewo+IC0JaWYgKGF0dHJzID09IE5VTEwpCj4gLQkJ cmV0dXJuIDA7Cj4gLQlCVUdfT04oYXR0ciA+PSBETUFfQVRUUl9NQVgpOwo+IC0JcmV0dXJuIHRl c3RfYml0KGF0dHIsIGF0dHJzLT5mbGFncyk7Cj4gLX0KPiAtCj4gLSNlbmRpZiAvKiBfRE1BX0FU VFJfSCAqLwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2RtYS1pb21tdS5oIGIvaW5jbHVk ZS9saW51eC9kbWEtaW9tbXUuaAo+IGluZGV4IDg0NDNiYmI1YzA3MS4uODFjNWM4ZDE2N2FkIDEw MDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWlvbW11LmgKPiArKysgYi9pbmNsdWRlL2xp bnV4L2RtYS1pb21tdS5oCj4gQEAgLTM5LDcgKzM5LDcgQEAgaW50IGRtYV9kaXJlY3Rpb25fdG9f cHJvdChlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIGJvb2wgY29oZXJlbnQpOwo+ICAgKiB0 aGUgYXJjaCBjb2RlIHRvIHRha2UgY2FyZSBvZiBhdHRyaWJ1dGVzIGFuZCBjYWNoZSBtYWludGVu YW5jZQo+ICAgKi8KPiAgc3RydWN0IHBhZ2UgKippb21tdV9kbWFfYWxsb2Moc3RydWN0IGRldmlj ZSAqZGV2LCBzaXplX3Qgc2l6ZSwgZ2ZwX3QgZ2ZwLAo+IC0JCXN0cnVjdCBkbWFfYXR0cnMgKmF0 dHJzLCBpbnQgcHJvdCwgZG1hX2FkZHJfdCAqaGFuZGxlLAo+ICsJCXVuc2lnbmVkIGxvbmcgYXR0 cnMsIGludCBwcm90LCBkbWFfYWRkcl90ICpoYW5kbGUsCj4gIAkJdm9pZCAoKmZsdXNoX3BhZ2Up KHN0cnVjdCBkZXZpY2UgKiwgY29uc3Qgdm9pZCAqLCBwaHlzX2FkZHJfdCkpOwo+ICB2b2lkIGlv bW11X2RtYV9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKipwYWdlcywgc2l6 ZV90IHNpemUsCj4gIAkJZG1hX2FkZHJfdCAqaGFuZGxlKTsKPiBAQCAtNTYsOSArNTYsOSBAQCBp bnQgaW9tbXVfZG1hX21hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlz dCAqc2csCj4gICAqIGRpcmVjdGx5IGFzIERNQSBtYXBwaW5nIGNhbGxiYWNrcyBmb3Igc2ltcGxp Y2l0eQo+ICAgKi8KPiAgdm9pZCBpb21tdV9kbWFfdW5tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpk ZXYsIGRtYV9hZGRyX3QgaGFuZGxlLCBzaXplX3Qgc2l6ZSwKPiAtCQllbnVtIGRtYV9kYXRhX2Rp cmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiArCQllbnVtIGRtYV9kYXRh X2RpcmVjdGlvbiBkaXIsIHVuc2lnbmVkIGxvbmcgYXR0cnMpOwo+ICB2b2lkIGlvbW11X2RtYV91 bm1hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csIGludCBu ZW50cywKPiAtCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMg KmF0dHJzKTsKPiArCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHVuc2lnbmVkIGxvbmcg YXR0cnMpOwo+ICBpbnQgaW9tbXVfZG1hX3N1cHBvcnRlZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHU2 NCBtYXNrKTsKPiAgaW50IGlvbW11X2RtYV9tYXBwaW5nX2Vycm9yKHN0cnVjdCBkZXZpY2UgKmRl diwgZG1hX2FkZHJfdCBkbWFfYWRkcik7Cj4gIAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4 L2RtYS1tYXBwaW5nLmggYi9pbmNsdWRlL2xpbnV4L2RtYS1tYXBwaW5nLmgKPiBpbmRleCA3MWMx YjIxNWVmNjYuLjE5ZTU4MWQ1ZjhiNCAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1t YXBwaW5nLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L2RtYS1tYXBwaW5nLmgKPiBAQCAtNSwxMyAr NSwyNSBAQAo+ICAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9k ZXZpY2UuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgo+IC0jaW5jbHVkZSA8bGludXgvZG1h LWF0dHJzLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9kbWEtZGVidWcuaD4KPiAgI2luY2x1ZGUgPGxp bnV4L2RtYS1kaXJlY3Rpb24uaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+Cj4g ICNpbmNsdWRlIDxsaW51eC9rbWVtY2hlY2suaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2J1Zy5oPgo+ ICAKPiArLyoqCj4gKyAqIExpc3Qgb2YgcG9zc2libGUgYXR0cmlidXRlcyBhc3NvY2lhdGVkIHdp dGggYSBETUEgbWFwcGluZy4gVGhlIHNlbWFudGljcwo+ICsgKiBvZiBlYWNoIGF0dHJpYnV0ZSBz aG91bGQgYmUgZGVmaW5lZCBpbiBEb2N1bWVudGF0aW9uL0RNQS1hdHRyaWJ1dGVzLnR4dC4KPiAr ICovCj4gKyNkZWZpbmUgRE1BX0FUVFJfV1JJVEVfQkFSUklFUgkJQklUKDEpCj4gKyNkZWZpbmUg RE1BX0FUVFJfV0VBS19PUkRFUklORwkJQklUKDIpCj4gKyNkZWZpbmUgRE1BX0FUVFJfV1JJVEVf Q09NQklORQkJQklUKDMpCj4gKyNkZWZpbmUgRE1BX0FUVFJfTk9OX0NPTlNJU1RFTlQJCUJJVCg0 KQo+ICsjZGVmaW5lIERNQV9BVFRSX05PX0tFUk5FTF9NQVBQSU5HCUJJVCg1KQo+ICsjZGVmaW5l IERNQV9BVFRSX1NLSVBfQ1BVX1NZTkMJCUJJVCg2KQo+ICsjZGVmaW5lIERNQV9BVFRSX0ZPUkNF X0NPTlRJR1VPVVMJQklUKDcpCj4gKyNkZWZpbmUgRE1BX0FUVFJfQUxMT0NfU0lOR0xFX1BBR0VT CUJJVCg4KQo+ICsKPiAgLyoKPiAgICogQSBkbWFfYWRkcl90IGNhbiBob2xkIGFueSB2YWxpZCBE TUEgb3IgYnVzIGFkZHJlc3MgZm9yIHRoZSBwbGF0Zm9ybS4KPiAgICogSXQgY2FuIGJlIGdpdmVu IHRvIGEgZGV2aWNlIHRvIHVzZSBhcyBhIERNQSBzb3VyY2Ugb3IgdGFyZ2V0LiAgQSBDUFUgY2Fu bm90Cj4gQEAgLTIxLDM0ICszMywzNSBAQAo+ICBzdHJ1Y3QgZG1hX21hcF9vcHMgewo+ICAJdm9p ZCogKCphbGxvYykoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPiAgCQkJCWRtYV9h ZGRyX3QgKmRtYV9oYW5kbGUsIGdmcF90IGdmcCwKPiAtCQkJCXN0cnVjdCBkbWFfYXR0cnMgKmF0 dHJzKTsKPiArCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpOwo+ICAJdm9pZCAoKmZyZWUpKHN0cnVj dCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCSAgICAgIHZvaWQgKnZhZGRyLCBkbWFf YWRkcl90IGRtYV9oYW5kbGUsCj4gLQkJCSAgICAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsK PiArCQkJICAgICAgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAlpbnQgKCptbWFwKShzdHJ1Y3Qg ZGV2aWNlICosIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqLAo+IC0JCQkgIHZvaWQgKiwgZG1hX2Fk ZHJfdCwgc2l6ZV90LCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwkJCSAgdm9pZCAqLCBk bWFfYWRkcl90LCBzaXplX3QsCj4gKwkJCSAgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICAJ aW50ICgqZ2V0X3NndGFibGUpKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNnX3RhYmxlICpz Z3QsIHZvaWQgKiwKPiAtCQkJICAgZG1hX2FkZHJfdCwgc2l6ZV90LCBzdHJ1Y3QgZG1hX2F0dHJz ICphdHRycyk7Cj4gKwkJCSAgIGRtYV9hZGRyX3QsIHNpemVfdCwgdW5zaWduZWQgbG9uZyBhdHRy cyk7Cj4gIAo+ICAJZG1hX2FkZHJfdCAoKm1hcF9wYWdlKShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0 cnVjdCBwYWdlICpwYWdlLAo+ICAJCQkgICAgICAgdW5zaWduZWQgbG9uZyBvZmZzZXQsIHNpemVf dCBzaXplLAo+ICAJCQkgICAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkg ICAgICAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpOwo+ICsJCQkgICAgICAgdW5zaWduZWQgbG9u ZyBhdHRycyk7Cj4gIAl2b2lkICgqdW5tYXBfcGFnZSkoc3RydWN0IGRldmljZSAqZGV2LCBkbWFf YWRkcl90IGRtYV9oYW5kbGUsCj4gIAkJCSAgIHNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2Rp cmVjdGlvbiBkaXIsCj4gLQkJCSAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiArCQkJICAg dW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAkvKgo+ICAJICogbWFwX3NnIHJldHVybnMgMCBvbiBl cnJvciBhbmQgYSB2YWx1ZSA+IDAgb24gc3VjY2Vzcy4KPiAgCSAqIEl0IHNob3VsZCBuZXZlciBy ZXR1cm4gYSB2YWx1ZSA8IDAuCj4gIAkgKi8KPiAgCWludCAoKm1hcF9zZykoc3RydWN0IGRldmlj ZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAo+ICAJCSAgICAgIGludCBuZW50cywgZW51 bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCSAgICAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0 dHJzKTsKPiArCQkgICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKTsKPiAgCXZvaWQgKCp1bm1hcF9z Zykoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJCQkgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZywgaW50 IG5lbnRzLAo+ICAJCQkgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkgc3RydWN0 IGRtYV9hdHRycyAqYXR0cnMpOwo+ICsJCQkgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAl2b2lk ICgqc3luY19zaW5nbGVfZm9yX2NwdSkoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJCQkJICAgIGRt YV9hZGRyX3QgZG1hX2hhbmRsZSwgc2l6ZV90IHNpemUsCj4gIAkJCQkgICAgZW51bSBkbWFfZGF0 YV9kaXJlY3Rpb24gZGlyKTsKPiBAQCAtODgsNiArMTAxLDE2IEBAIHN0YXRpYyBpbmxpbmUgaW50 IGlzX2RldmljZV9kbWFfY2FwYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gIAlyZXR1cm4gZGV2 LT5kbWFfbWFzayAhPSBOVUxMICYmICpkZXYtPmRtYV9tYXNrICE9IERNQV9NQVNLX05PTkU7Cj4g IH0KPiAgCj4gKy8qKgo+ICsgKiBkbWFfZ2V0X2F0dHIgLSBjaGVjayBmb3IgYSBzcGVjaWZpYyBh dHRyaWJ1dGUKPiArICogQGF0dHI6IGF0dHJpYnV0ZSB0byBsb29rIGZvcgo+ICsgKiBAYXR0cnM6 IGF0dHJpYnV0ZXMgdG8gY2hlY2sgd2l0aGluCj4gKyAqLwo+ICtzdGF0aWMgaW5saW5lIGJvb2wg ZG1hX2dldF9hdHRyKHVuc2lnbmVkIGxvbmcgYXR0ciwgdW5zaWduZWQgbG9uZyBhdHRycykKPiAr ewo+ICsJcmV0dXJuICEhKGF0dHIgJiBhdHRycyk7Cj4gK30KPiArCj4gICNpZmRlZiBDT05GSUdf SEFWRV9HRU5FUklDX0RNQV9DT0hFUkVOVAo+ICAvKgo+ICAgKiBUaGVzZSB0aHJlZSBmdW5jdGlv bnMgYXJlIG9ubHkgZm9yIGRtYSBhbGxvY2F0b3IuCj4gQEAgLTEyMyw3ICsxNDYsNyBAQCBzdGF0 aWMgaW5saW5lIHN0cnVjdCBkbWFfbWFwX29wcyAqZ2V0X2RtYV9vcHMoc3RydWN0IGRldmljZSAq ZGV2KQo+ICBzdGF0aWMgaW5saW5lIGRtYV9hZGRyX3QgZG1hX21hcF9zaW5nbGVfYXR0cnMoc3Ry dWN0IGRldmljZSAqZGV2LCB2b2lkICpwdHIsCj4gIAkJCQkJICAgICAgc2l6ZV90IHNpemUsCj4g IAkJCQkJICAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkJCSAgICAgIHN0 cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMp Cj4gIHsKPiAgCXN0cnVjdCBkbWFfbWFwX29wcyAqb3BzID0gZ2V0X2RtYV9vcHMoZGV2KTsKPiAg CWRtYV9hZGRyX3QgYWRkcjsKPiBAQCAtMTQyLDcgKzE2NSw3IEBAIHN0YXRpYyBpbmxpbmUgZG1h X2FkZHJfdCBkbWFfbWFwX3NpbmdsZV9hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKnB0 ciwKPiAgc3RhdGljIGlubGluZSB2b2lkIGRtYV91bm1hcF9zaW5nbGVfYXR0cnMoc3RydWN0IGRl dmljZSAqZGV2LCBkbWFfYWRkcl90IGFkZHIsCj4gIAkJCQkJICBzaXplX3Qgc2l6ZSwKPiAgCQkJ CQkgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJCQkgIHN0cnVjdCBkbWFfYXR0 cnMgKmF0dHJzKQo+ICsJCQkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJc3RydWN0 IGRtYV9tYXBfb3BzICpvcHMgPSBnZXRfZG1hX29wcyhkZXYpOwo+ICAKPiBAQCAtMTU4LDcgKzE4 MSw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBkbWFfdW5tYXBfc2luZ2xlX2F0dHJzKHN0cnVjdCBk ZXZpY2UgKmRldiwgZG1hX2FkZHJfdCBhZGRyLAo+ICAgKi8KPiAgc3RhdGljIGlubGluZSBpbnQg ZG1hX21hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAq c2csCj4gIAkJCQkgICBpbnQgbmVudHMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAt CQkJCSAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkJICAgdW5zaWduZWQgbG9uZyBh dHRycykKPiAgewo+ICAJc3RydWN0IGRtYV9tYXBfb3BzICpvcHMgPSBnZXRfZG1hX29wcyhkZXYp Owo+ICAJaW50IGksIGVudHM7Cj4gQEAgLTE3Niw3ICsxOTksNyBAQCBzdGF0aWMgaW5saW5lIGlu dCBkbWFfbWFwX3NnX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0ZXJsaXN0 ICpzZywKPiAgCj4gIHN0YXRpYyBpbmxpbmUgdm9pZCBkbWFfdW5tYXBfc2dfYXR0cnMoc3RydWN0 IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAo+ICAJCQkJICAgICAgaW50IG5l bnRzLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gLQkJCQkgICAgICBzdHJ1Y3QgZG1h X2F0dHJzICphdHRycykKPiArCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAg CXN0cnVjdCBkbWFfbWFwX29wcyAqb3BzID0gZ2V0X2RtYV9vcHMoZGV2KTsKPiAgCj4gQEAgLTE5 NSw3ICsyMTgsNyBAQCBzdGF0aWMgaW5saW5lIGRtYV9hZGRyX3QgZG1hX21hcF9wYWdlKHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAo+ICAJa21lbWNoZWNrX21hcmtf aW5pdGlhbGl6ZWQocGFnZV9hZGRyZXNzKHBhZ2UpICsgb2Zmc2V0LCBzaXplKTsKPiAgCUJVR19P TighdmFsaWRfZG1hX2RpcmVjdGlvbihkaXIpKTsKPiAtCWFkZHIgPSBvcHMtPm1hcF9wYWdlKGRl diwgcGFnZSwgb2Zmc2V0LCBzaXplLCBkaXIsIE5VTEwpOwo+ICsJYWRkciA9IG9wcy0+bWFwX3Bh Z2UoZGV2LCBwYWdlLCBvZmZzZXQsIHNpemUsIGRpciwgMCk7Cj4gIAlkZWJ1Z19kbWFfbWFwX3Bh Z2UoZGV2LCBwYWdlLCBvZmZzZXQsIHNpemUsIGRpciwgYWRkciwgZmFsc2UpOwo+ICAKPiAgCXJl dHVybiBhZGRyOwo+IEBAIC0yMDgsNyArMjMxLDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGRtYV91 bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgZG1hX2FkZHJfdCBhZGRyLAo+ICAKPiAgCUJV R19PTighdmFsaWRfZG1hX2RpcmVjdGlvbihkaXIpKTsKPiAgCWlmIChvcHMtPnVubWFwX3BhZ2Up Cj4gLQkJb3BzLT51bm1hcF9wYWdlKGRldiwgYWRkciwgc2l6ZSwgZGlyLCBOVUxMKTsKPiArCQlv cHMtPnVubWFwX3BhZ2UoZGV2LCBhZGRyLCBzaXplLCBkaXIsIDApOwo+ICAJZGVidWdfZG1hX3Vu bWFwX3BhZ2UoZGV2LCBhZGRyLCBzaXplLCBkaXIsIGZhbHNlKTsKPiAgfQo+ICAKPiBAQCAtMjg5 LDEwICszMTIsMTAgQEAgZG1hX3N5bmNfc2dfZm9yX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYs IHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCj4gIAo+ICB9Cj4gIAo+IC0jZGVmaW5lIGRtYV9tYXBf c2luZ2xlKGQsIGEsIHMsIHIpIGRtYV9tYXBfc2luZ2xlX2F0dHJzKGQsIGEsIHMsIHIsIE5VTEwp Cj4gLSNkZWZpbmUgZG1hX3VubWFwX3NpbmdsZShkLCBhLCBzLCByKSBkbWFfdW5tYXBfc2luZ2xl X2F0dHJzKGQsIGEsIHMsIHIsIE5VTEwpCj4gLSNkZWZpbmUgZG1hX21hcF9zZyhkLCBzLCBuLCBy KSBkbWFfbWFwX3NnX2F0dHJzKGQsIHMsIG4sIHIsIE5VTEwpCj4gLSNkZWZpbmUgZG1hX3VubWFw X3NnKGQsIHMsIG4sIHIpIGRtYV91bm1hcF9zZ19hdHRycyhkLCBzLCBuLCByLCBOVUxMKQo+ICsj ZGVmaW5lIGRtYV9tYXBfc2luZ2xlKGQsIGEsIHMsIHIpIGRtYV9tYXBfc2luZ2xlX2F0dHJzKGQs IGEsIHMsIHIsIDApCj4gKyNkZWZpbmUgZG1hX3VubWFwX3NpbmdsZShkLCBhLCBzLCByKSBkbWFf dW5tYXBfc2luZ2xlX2F0dHJzKGQsIGEsIHMsIHIsIDApCj4gKyNkZWZpbmUgZG1hX21hcF9zZyhk LCBzLCBuLCByKSBkbWFfbWFwX3NnX2F0dHJzKGQsIHMsIG4sIHIsIDApCj4gKyNkZWZpbmUgZG1h X3VubWFwX3NnKGQsIHMsIG4sIHIpIGRtYV91bm1hcF9zZ19hdHRycyhkLCBzLCBuLCByLCAwKQo+ ICAKPiAgZXh0ZXJuIGludCBkbWFfY29tbW9uX21tYXAoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1 Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKPiAgCQkJICAgdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRy X3QgZG1hX2FkZHIsIHNpemVfdCBzaXplKTsKPiBAQCAtMzIxLDcgKzM0NCw3IEBAIHZvaWQgZG1h X2NvbW1vbl9mcmVlX3JlbWFwKHZvaWQgKmNwdV9hZGRyLCBzaXplX3Qgc2l6ZSwgdW5zaWduZWQg bG9uZyB2bV9mbGFncyk7Cj4gICAqLwo+ICBzdGF0aWMgaW5saW5lIGludAo+ICBkbWFfbW1hcF9h dHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCB2b2lk ICpjcHVfYWRkciwKPiAtCSAgICAgICBkbWFfYWRkcl90IGRtYV9hZGRyLCBzaXplX3Qgc2l6ZSwg c3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkgICAgICAgZG1hX2FkZHJfdCBkbWFfYWRkciwg c2l6ZV90IHNpemUsIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCBkbWFfbWFw X29wcyAqb3BzID0gZ2V0X2RtYV9vcHMoZGV2KTsKPiAgCUJVR19PTighb3BzKTsKPiBAQCAtMzMw LDcgKzM1Myw3IEBAIGRtYV9tbWFwX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHZt X2FyZWFfc3RydWN0ICp2bWEsIHZvaWQgKmNwdV9hZGRyLAo+ICAJcmV0dXJuIGRtYV9jb21tb25f bW1hcChkZXYsIHZtYSwgY3B1X2FkZHIsIGRtYV9hZGRyLCBzaXplKTsKPiAgfQo+ICAKPiAtI2Rl ZmluZSBkbWFfbW1hcF9jb2hlcmVudChkLCB2LCBjLCBoLCBzKSBkbWFfbW1hcF9hdHRycyhkLCB2 LCBjLCBoLCBzLCBOVUxMKQo+ICsjZGVmaW5lIGRtYV9tbWFwX2NvaGVyZW50KGQsIHYsIGMsIGgs IHMpIGRtYV9tbWFwX2F0dHJzKGQsIHYsIGMsIGgsIHMsIDApCj4gIAo+ICBpbnQKPiAgZG1hX2Nv bW1vbl9nZXRfc2d0YWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzZ190YWJsZSAqc2d0 LAo+IEBAIC0zMzgsNyArMzYxLDggQEAgZG1hX2NvbW1vbl9nZXRfc2d0YWJsZShzdHJ1Y3QgZGV2 aWNlICpkZXYsIHN0cnVjdCBzZ190YWJsZSAqc2d0LAo+ICAKPiAgc3RhdGljIGlubGluZSBpbnQK PiAgZG1hX2dldF9zZ3RhYmxlX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNnX3Rh YmxlICpzZ3QsIHZvaWQgKmNwdV9hZGRyLAo+IC0JCSAgICAgIGRtYV9hZGRyX3QgZG1hX2FkZHIs IHNpemVfdCBzaXplLCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKPiArCQkgICAgICBkbWFfYWRk cl90IGRtYV9hZGRyLCBzaXplX3Qgc2l6ZSwKPiArCQkgICAgICB1bnNpZ25lZCBsb25nIGF0dHJz KQo+ICB7Cj4gIAlzdHJ1Y3QgZG1hX21hcF9vcHMgKm9wcyA9IGdldF9kbWFfb3BzKGRldik7Cj4g IAlCVUdfT04oIW9wcyk7Cj4gQEAgLTM0OCw3ICszNzIsNyBAQCBkbWFfZ2V0X3NndGFibGVfYXR0 cnMoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCwgdm9pZCAqY3B1X2Fk ZHIsCj4gIAlyZXR1cm4gZG1hX2NvbW1vbl9nZXRfc2d0YWJsZShkZXYsIHNndCwgY3B1X2FkZHIs IGRtYV9hZGRyLCBzaXplKTsKPiAgfQo+ICAKPiAtI2RlZmluZSBkbWFfZ2V0X3NndGFibGUoZCwg dCwgdiwgaCwgcykgZG1hX2dldF9zZ3RhYmxlX2F0dHJzKGQsIHQsIHYsIGgsIHMsIE5VTEwpCj4g KyNkZWZpbmUgZG1hX2dldF9zZ3RhYmxlKGQsIHQsIHYsIGgsIHMpIGRtYV9nZXRfc2d0YWJsZV9h dHRycyhkLCB0LCB2LCBoLCBzLCAwKQo+ICAKPiAgI2lmbmRlZiBhcmNoX2RtYV9hbGxvY19hdHRy cwo+ICAjZGVmaW5lIGFyY2hfZG1hX2FsbG9jX2F0dHJzKGRldiwgZmxhZykJKHRydWUpCj4gQEAg LTM1Niw3ICszODAsNyBAQCBkbWFfZ2V0X3NndGFibGVfYXR0cnMoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCwgdm9pZCAqY3B1X2FkZHIsCj4gIAo+ICBzdGF0aWMgaW5s aW5lIHZvaWQgKmRtYV9hbGxvY19hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXpl LAo+ICAJCQkJICAgICAgIGRtYV9hZGRyX3QgKmRtYV9oYW5kbGUsIGdmcF90IGZsYWcsCj4gLQkJ CQkgICAgICAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJCQkgICAgICAgdW5zaWduZWQg bG9uZyBhdHRycykKPiAgewo+ICAJc3RydWN0IGRtYV9tYXBfb3BzICpvcHMgPSBnZXRfZG1hX29w cyhkZXYpOwo+ICAJdm9pZCAqY3B1X2FkZHI7Cj4gQEAgLTM3OCw3ICs0MDIsNyBAQCBzdGF0aWMg aW5saW5lIHZvaWQgKmRtYV9hbGxvY19hdHRycyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBz aXplLAo+ICAKPiAgc3RhdGljIGlubGluZSB2b2lkIGRtYV9mcmVlX2F0dHJzKHN0cnVjdCBkZXZp Y2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCQkgICAgIHZvaWQgKmNwdV9hZGRyLCBkbWFfYWRk cl90IGRtYV9oYW5kbGUsCj4gLQkJCQkgICAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJ CQkJICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlzdHJ1Y3QgZG1hX21hcF9vcHMg Km9wcyA9IGdldF9kbWFfb3BzKGRldik7Cj4gIAo+IEBAIC0zOTgsMzEgKzQyMiwyNyBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgZG1hX2ZyZWVfYXR0cnMoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qg c2l6ZSwKPiAgc3RhdGljIGlubGluZSB2b2lkICpkbWFfYWxsb2NfY29oZXJlbnQoc3RydWN0IGRl dmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPiAgCQlkbWFfYWRkcl90ICpkbWFfaGFuZGxlLCBnZnBf dCBmbGFnKQo+ICB7Cj4gLQlyZXR1cm4gZG1hX2FsbG9jX2F0dHJzKGRldiwgc2l6ZSwgZG1hX2hh bmRsZSwgZmxhZywgTlVMTCk7Cj4gKwlyZXR1cm4gZG1hX2FsbG9jX2F0dHJzKGRldiwgc2l6ZSwg ZG1hX2hhbmRsZSwgZmxhZywgMCk7Cj4gIH0KPiAgCj4gIHN0YXRpYyBpbmxpbmUgdm9pZCBkbWFf ZnJlZV9jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICAJCXZvaWQg KmNwdV9hZGRyLCBkbWFfYWRkcl90IGRtYV9oYW5kbGUpCj4gIHsKPiAtCXJldHVybiBkbWFfZnJl ZV9hdHRycyhkZXYsIHNpemUsIGNwdV9hZGRyLCBkbWFfaGFuZGxlLCBOVUxMKTsKPiArCXJldHVy biBkbWFfZnJlZV9hdHRycyhkZXYsIHNpemUsIGNwdV9hZGRyLCBkbWFfaGFuZGxlLCAwKTsKPiAg fQo+ICAKPiAgc3RhdGljIGlubGluZSB2b2lkICpkbWFfYWxsb2Nfbm9uY29oZXJlbnQoc3RydWN0 IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPiAgCQlkbWFfYWRkcl90ICpkbWFfaGFuZGxlLCBn ZnBfdCBnZnApCj4gIHsKPiAtCURFRklORV9ETUFfQVRUUlMoYXR0cnMpOwo+IC0KPiAtCWRtYV9z ZXRfYXR0cihETUFfQVRUUl9OT05fQ09OU0lTVEVOVCwgJmF0dHJzKTsKPiAtCXJldHVybiBkbWFf YWxsb2NfYXR0cnMoZGV2LCBzaXplLCBkbWFfaGFuZGxlLCBnZnAsICZhdHRycyk7Cj4gKwlyZXR1 cm4gZG1hX2FsbG9jX2F0dHJzKGRldiwgc2l6ZSwgZG1hX2hhbmRsZSwgZ2ZwLAo+ICsJCQkgICAg ICAgRE1BX0FUVFJfTk9OX0NPTlNJU1RFTlQpOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW5saW5lIHZv aWQgZG1hX2ZyZWVfbm9uY29oZXJlbnQoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwK PiAgCQl2b2lkICpjcHVfYWRkciwgZG1hX2FkZHJfdCBkbWFfaGFuZGxlKQo+ICB7Cj4gLQlERUZJ TkVfRE1BX0FUVFJTKGF0dHJzKTsKPiAtCj4gLQlkbWFfc2V0X2F0dHIoRE1BX0FUVFJfTk9OX0NP TlNJU1RFTlQsICZhdHRycyk7Cj4gLQlkbWFfZnJlZV9hdHRycyhkZXYsIHNpemUsIGNwdV9hZGRy LCBkbWFfaGFuZGxlLCAmYXR0cnMpOwo+ICsJZG1hX2ZyZWVfYXR0cnMoZGV2LCBzaXplLCBjcHVf YWRkciwgZG1hX2hhbmRsZSwKPiArCQkgICAgICAgRE1BX0FUVFJfTk9OX0NPTlNJU1RFTlQpOwo+ ICB9Cj4gIAo+ICBzdGF0aWMgaW5saW5lIGludCBkbWFfbWFwcGluZ19lcnJvcihzdHJ1Y3QgZGV2 aWNlICpkZXYsIGRtYV9hZGRyX3QgZG1hX2FkZHIpCj4gQEAgLTY0Niw5ICs2NjYsOCBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgZG1hbV9yZWxlYXNlX2RlY2xhcmVkX21lbW9yeShzdHJ1Y3QgZGV2aWNl ICpkZXYpCj4gIHN0YXRpYyBpbmxpbmUgdm9pZCAqZG1hX2FsbG9jX3djKHN0cnVjdCBkZXZpY2Ug KmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCQkgZG1hX2FkZHJfdCAqZG1hX2FkZHIsIGdmcF90IGdm cCkKPiAgewo+IC0JREVGSU5FX0RNQV9BVFRSUyhhdHRycyk7Cj4gLQlkbWFfc2V0X2F0dHIoRE1B X0FUVFJfV1JJVEVfQ09NQklORSwgJmF0dHJzKTsKPiAtCXJldHVybiBkbWFfYWxsb2NfYXR0cnMo ZGV2LCBzaXplLCBkbWFfYWRkciwgZ2ZwLCAmYXR0cnMpOwo+ICsJcmV0dXJuIGRtYV9hbGxvY19h dHRycyhkZXYsIHNpemUsIGRtYV9hZGRyLCBnZnAsCj4gKwkJCSAgICAgICBETUFfQVRUUl9XUklU RV9DT01CSU5FKTsKPiAgfQo+ICAjaWZuZGVmIGRtYV9hbGxvY193cml0ZWNvbWJpbmUKPiAgI2Rl ZmluZSBkbWFfYWxsb2Nfd3JpdGVjb21iaW5lIGRtYV9hbGxvY193Ywo+IEBAIC02NTcsOSArNjc2 LDggQEAgc3RhdGljIGlubGluZSB2b2lkICpkbWFfYWxsb2Nfd2Moc3RydWN0IGRldmljZSAqZGV2 LCBzaXplX3Qgc2l6ZSwKPiAgc3RhdGljIGlubGluZSB2b2lkIGRtYV9mcmVlX3djKHN0cnVjdCBk ZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCSAgICAgICB2b2lkICpjcHVfYWRkciwgZG1h X2FkZHJfdCBkbWFfYWRkcikKPiAgewo+IC0JREVGSU5FX0RNQV9BVFRSUyhhdHRycyk7Cj4gLQlk bWFfc2V0X2F0dHIoRE1BX0FUVFJfV1JJVEVfQ09NQklORSwgJmF0dHJzKTsKPiAtCXJldHVybiBk bWFfZnJlZV9hdHRycyhkZXYsIHNpemUsIGNwdV9hZGRyLCBkbWFfYWRkciwgJmF0dHJzKTsKPiAr CXJldHVybiBkbWFfZnJlZV9hdHRycyhkZXYsIHNpemUsIGNwdV9hZGRyLCBkbWFfYWRkciwKPiAr CQkJICAgICAgRE1BX0FUVFJfV1JJVEVfQ09NQklORSk7Cj4gIH0KPiAgI2lmbmRlZiBkbWFfZnJl ZV93cml0ZWNvbWJpbmUKPiAgI2RlZmluZSBkbWFfZnJlZV93cml0ZWNvbWJpbmUgZG1hX2ZyZWVf d2MKPiBAQCAtNjcwLDkgKzY4OCw4IEBAIHN0YXRpYyBpbmxpbmUgaW50IGRtYV9tbWFwX3djKHN0 cnVjdCBkZXZpY2UgKmRldiwKPiAgCQkJICAgICAgdm9pZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3Qg ZG1hX2FkZHIsCj4gIAkJCSAgICAgIHNpemVfdCBzaXplKQo+ICB7Cj4gLQlERUZJTkVfRE1BX0FU VFJTKGF0dHJzKTsKPiAtCWRtYV9zZXRfYXR0cihETUFfQVRUUl9XUklURV9DT01CSU5FLCAmYXR0 cnMpOwo+IC0JcmV0dXJuIGRtYV9tbWFwX2F0dHJzKGRldiwgdm1hLCBjcHVfYWRkciwgZG1hX2Fk ZHIsIHNpemUsICZhdHRycyk7Cj4gKwlyZXR1cm4gZG1hX21tYXBfYXR0cnMoZGV2LCB2bWEsIGNw dV9hZGRyLCBkbWFfYWRkciwgc2l6ZSwKPiArCQkJICAgICAgRE1BX0FUVFJfV1JJVEVfQ09NQklO RSk7Cj4gIH0KPiAgI2lmbmRlZiBkbWFfbW1hcF93cml0ZWNvbWJpbmUKPiAgI2RlZmluZSBkbWFf bW1hcF93cml0ZWNvbWJpbmUgZG1hX21tYXBfd2MKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9zd2lvdGxiLmggYi9pbmNsdWRlL2xpbnV4L3N3aW90bGIuaAo+IGluZGV4IDAxN2ZjZWQ2MDI0 Mi4uNWY4MWY4YTE4N2YyIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvc3dpb3RsYi5oCj4g KysrIGIvaW5jbHVkZS9saW51eC9zd2lvdGxiLmgKPiBAQCAtNiw3ICs2LDYgQEAKPiAgI2luY2x1 ZGUgPGxpbnV4L3R5cGVzLmg+Cj4gIAo+ICBzdHJ1Y3QgZGV2aWNlOwo+IC1zdHJ1Y3QgZG1hX2F0 dHJzOwo+ICBzdHJ1Y3QgcGFnZTsKPiAgc3RydWN0IHNjYXR0ZXJsaXN0Owo+ICAKPiBAQCAtNjgs MTAgKzY3LDEwIEBAIHN3aW90bGJfZnJlZV9jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpod2Rldiwg c2l6ZV90IHNpemUsCj4gIGV4dGVybiBkbWFfYWRkcl90IHN3aW90bGJfbWFwX3BhZ2Uoc3RydWN0 IGRldmljZSAqZGV2LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgCQkJCSAgIHVuc2lnbmVkIGxvbmcg b2Zmc2V0LCBzaXplX3Qgc2l6ZSwKPiAgCQkJCSAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp ciwKPiAtCQkJCSAgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiArCQkJCSAgIHVuc2lnbmVk IGxvbmcgYXR0cnMpOwo+ICBleHRlcm4gdm9pZCBzd2lvdGxiX3VubWFwX3BhZ2Uoc3RydWN0IGRl dmljZSAqaHdkZXYsIGRtYV9hZGRyX3QgZGV2X2FkZHIsCj4gIAkJCSAgICAgICBzaXplX3Qgc2l6 ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCQkgICAgICAgc3RydWN0IGRtYV9h dHRycyAqYXR0cnMpOwo+ICsJCQkgICAgICAgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICBl eHRlcm4gaW50Cj4gIHN3aW90bGJfbWFwX3NnKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qg c2NhdHRlcmxpc3QgKnNnLCBpbnQgbmVudHMsCj4gQEAgLTgzLDEyICs4MiwxMyBAQCBzd2lvdGxi X3VubWFwX3NnKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCBp bnQgbmVudHMsCj4gIAo+ICBleHRlcm4gaW50Cj4gIHN3aW90bGJfbWFwX3NnX2F0dHJzKHN0cnVj dCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwgaW50IG5lbGVtcywKPiAt CQkgICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwgc3RydWN0IGRtYV9hdHRycyAqYXR0 cnMpOwo+ICsJCSAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+ICsJCSAgICAgdW5z aWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICBleHRlcm4gdm9pZAo+ICBzd2lvdGxiX3VubWFwX3Nn X2F0dHJzKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwKPiAg CQkgICAgICAgaW50IG5lbGVtcywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+IC0JCSAg ICAgICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwkJICAgICAgIHVuc2lnbmVkIGxvbmcg YXR0cnMpOwo+ICAKPiAgZXh0ZXJuIHZvaWQKPiAgc3dpb3RsYl9zeW5jX3NpbmdsZV9mb3JfY3B1 KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGRldl9hZGRyLAo+IGRpZmYgLS1naXQg YS9pbmNsdWRlL3hlbi9zd2lvdGxiLXhlbi5oIGIvaW5jbHVkZS94ZW4vc3dpb3RsYi14ZW4uaAo+ IGluZGV4IDhiMmViOTNhZThiYS4uN2MzNWUyNzlkMWUzIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUv eGVuL3N3aW90bGIteGVuLmgKPiArKysgYi9pbmNsdWRlL3hlbi9zd2lvdGxiLXhlbi5oCj4gQEAg LTksMzAgKzksMzAgQEAgZXh0ZXJuIGludCB4ZW5fc3dpb3RsYl9pbml0KGludCB2ZXJib3NlLCBi b29sIGVhcmx5KTsKPiAgZXh0ZXJuIHZvaWQKPiAgKnhlbl9zd2lvdGxiX2FsbG9jX2NvaGVyZW50 KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzaXplX3Qgc2l6ZSwKPiAgCQkJICAgIGRtYV9hZGRyX3Qg KmRtYV9oYW5kbGUsIGdmcF90IGZsYWdzLAo+IC0JCQkgICAgc3RydWN0IGRtYV9hdHRycyAqYXR0 cnMpOwo+ICsJCQkgICAgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICBleHRlcm4gdm9pZAo+ ICB4ZW5fc3dpb3RsYl9mcmVlX2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzaXplX3Qg c2l6ZSwKPiAgCQkJICB2b2lkICp2YWRkciwgZG1hX2FkZHJfdCBkbWFfaGFuZGxlLAo+IC0JCQkg IHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiArCQkJICB1bnNpZ25lZCBsb25nIGF0dHJzKTsK PiAgCj4gIGV4dGVybiBkbWFfYWRkcl90IHhlbl9zd2lvdGxiX21hcF9wYWdlKHN0cnVjdCBkZXZp Y2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gIAkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBv ZmZzZXQsIHNpemVfdCBzaXplLAo+ICAJCQkJICAgICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9u IGRpciwKPiAtCQkJCSAgICAgICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwkJCQkgICAg ICAgdW5zaWduZWQgbG9uZyBhdHRycyk7Cj4gIAo+ICBleHRlcm4gdm9pZCB4ZW5fc3dpb3RsYl91 bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBkbWFfYWRkcl90IGRldl9hZGRyLAo+ICAJ CQkJICAgc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJCSAg IHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKTsKPiArCQkJCSAgIHVuc2lnbmVkIGxvbmcgYXR0cnMp Owo+ICBleHRlcm4gaW50Cj4gIHhlbl9zd2lvdGxiX21hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNl ICpod2Rldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ2wsCj4gIAkJCSBpbnQgbmVsZW1zLCBlbnVt IGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gLQkJCSBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7 Cj4gKwkJCSB1bnNpZ25lZCBsb25nIGF0dHJzKTsKPiAgCj4gIGV4dGVybiB2b2lkCj4gIHhlbl9z d2lvdGxiX3VubWFwX3NnX2F0dHJzKHN0cnVjdCBkZXZpY2UgKmh3ZGV2LCBzdHJ1Y3Qgc2NhdHRl cmxpc3QgKnNnbCwKPiAgCQkJICAgaW50IG5lbGVtcywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24g ZGlyLAo+IC0JCQkgICBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycyk7Cj4gKwkJCSAgIHVuc2lnbmVk IGxvbmcgYXR0cnMpOwo+ICAKPiAgZXh0ZXJuIHZvaWQKPiAgeGVuX3N3aW90bGJfc3luY19zaW5n bGVfZm9yX2NwdShzdHJ1Y3QgZGV2aWNlICpod2RldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKPiBk aWZmIC0tZ2l0IGEvbGliL2RtYS1ub29wLmMgYi9saWIvZG1hLW5vb3AuYwo+IGluZGV4IDcyMTQ1 NjQ2ODU3ZS4uM2Q3NjZlNzhmYmUyIDEwMDY0NAo+IC0tLSBhL2xpYi9kbWEtbm9vcC5jCj4gKysr IGIvbGliL2RtYS1ub29wLmMKPiBAQCAtMTAsNyArMTAsNyBAQAo+ICAKPiAgc3RhdGljIHZvaWQg KmRtYV9ub29wX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCSAg ICBkbWFfYWRkcl90ICpkbWFfaGFuZGxlLCBnZnBfdCBnZnAsCj4gLQkJCSAgICBzdHJ1Y3QgZG1h X2F0dHJzICphdHRycykKPiArCQkJICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXZv aWQgKnJldDsKPiAgCj4gQEAgLTIyLDcgKzIyLDcgQEAgc3RhdGljIHZvaWQgKmRtYV9ub29wX2Fs bG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAo+ICBzdGF0aWMgdm9pZCBk bWFfbm9vcF9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gIAkJCSAgdm9p ZCAqY3B1X2FkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsCj4gLQkJCSAgc3RydWN0IGRtYV9hdHRy cyAqYXR0cnMpCj4gKwkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJZnJlZV9wYWdl cygodW5zaWduZWQgbG9uZyljcHVfYWRkciwgZ2V0X29yZGVyKHNpemUpKTsKPiAgfQo+IEBAIC0z MCwxMyArMzAsMTQgQEAgc3RhdGljIHZvaWQgZG1hX25vb3BfZnJlZShzdHJ1Y3QgZGV2aWNlICpk ZXYsIHNpemVfdCBzaXplLAo+ICBzdGF0aWMgZG1hX2FkZHJfdCBkbWFfbm9vcF9tYXBfcGFnZShz dHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAo+ICAJCQkJICAgICAgdW5zaWdu ZWQgbG9uZyBvZmZzZXQsIHNpemVfdCBzaXplLAo+ICAJCQkJICAgICAgZW51bSBkbWFfZGF0YV9k aXJlY3Rpb24gZGlyLAo+IC0JCQkJICAgICAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCj4gKwkJ CQkgICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlyZXR1cm4gcGFnZV90b19waHlz KHBhZ2UpICsgb2Zmc2V0Owo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50IGRtYV9ub29wX21hcF9zZyhz dHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLCBpbnQgbmVudHMsCj4g LQkJCSAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLCBzdHJ1Y3QgZG1hX2F0dHJzICph dHRycykKPiArCQkJICAgICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gKwkJCSAgICAg dW5zaWduZWQgbG9uZyBhdHRycykKPiAgewo+ICAJaW50IGk7Cj4gIAlzdHJ1Y3Qgc2NhdHRlcmxp c3QgKnNnOwo+IGRpZmYgLS1naXQgYS9saWIvc3dpb3RsYi5jIGIvbGliL3N3aW90bGIuYwo+IGlu ZGV4IDc2ZjI5ZWNiYThmNC4uMjJlMTNhMGUxOWQ3IDEwMDY0NAo+IC0tLSBhL2xpYi9zd2lvdGxi LmMKPiArKysgYi9saWIvc3dpb3RsYi5jCj4gQEAgLTczOCw3ICs3MzgsNyBAQCBzd2lvdGxiX2Z1 bGwoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rp b24gZGlyLAo+ICBkbWFfYWRkcl90IHN3aW90bGJfbWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgCQkJICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCBzaXpl X3Qgc2l6ZSwKPiAgCQkJICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJICAg IHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCQkgICAgdW5zaWduZWQgbG9uZyBhdHRycykK PiAgewo+ICAJcGh5c19hZGRyX3QgbWFwLCBwaHlzID0gcGFnZV90b19waHlzKHBhZ2UpICsgb2Zm c2V0Owo+ICAJZG1hX2FkZHJfdCBkZXZfYWRkciA9IHBoeXNfdG9fZG1hKGRldiwgcGh5cyk7Cj4g QEAgLTgwNyw3ICs4MDcsNyBAQCBzdGF0aWMgdm9pZCB1bm1hcF9zaW5nbGUoc3RydWN0IGRldmlj ZSAqaHdkZXYsIGRtYV9hZGRyX3QgZGV2X2FkZHIsCj4gIAo+ICB2b2lkIHN3aW90bGJfdW5tYXBf cGFnZShzdHJ1Y3QgZGV2aWNlICpod2RldiwgZG1hX2FkZHJfdCBkZXZfYWRkciwKPiAgCQkJc2l6 ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiAtCQkJc3RydWN0IGRtYV9h dHRycyAqYXR0cnMpCj4gKwkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXVubWFwX3Np bmdsZShod2RldiwgZGV2X2FkZHIsIHNpemUsIGRpcik7Cj4gIH0KPiBAQCAtODc3LDcgKzg3Nyw3 IEBAIEVYUE9SVF9TWU1CT0woc3dpb3RsYl9zeW5jX3NpbmdsZV9mb3JfZGV2aWNlKTsKPiAgICov Cj4gIGludAo+ICBzd2lvdGxiX21hcF9zZ19hdHRycyhzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc3Ry dWN0IHNjYXR0ZXJsaXN0ICpzZ2wsIGludCBuZWxlbXMsCj4gLQkJICAgICBlbnVtIGRtYV9kYXRh X2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJCSAgICAgZW51bSBk bWFfZGF0YV9kaXJlY3Rpb24gZGlyLCB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICB7Cj4gIAlzdHJ1 Y3Qgc2NhdHRlcmxpc3QgKnNnOwo+ICAJaW50IGk7Cj4gQEAgLTkxNCw3ICs5MTQsNyBAQCBpbnQK PiAgc3dpb3RsYl9tYXBfc2coc3RydWN0IGRldmljZSAqaHdkZXYsIHN0cnVjdCBzY2F0dGVybGlz dCAqc2dsLCBpbnQgbmVsZW1zLAo+ICAJICAgICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp cikKPiAgewo+IC0JcmV0dXJuIHN3aW90bGJfbWFwX3NnX2F0dHJzKGh3ZGV2LCBzZ2wsIG5lbGVt cywgZGlyLCBOVUxMKTsKPiArCXJldHVybiBzd2lvdGxiX21hcF9zZ19hdHRycyhod2Rldiwgc2ds LCBuZWxlbXMsIGRpciwgMCk7Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChzd2lvdGxiX21hcF9zZyk7 Cj4gIAo+IEBAIC05MjQsNyArOTI0LDggQEAgRVhQT1JUX1NZTUJPTChzd2lvdGxiX21hcF9zZyk7 Cj4gICAqLwo+ICB2b2lkCj4gIHN3aW90bGJfdW5tYXBfc2dfYXR0cnMoc3RydWN0IGRldmljZSAq aHdkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLAo+IC0JCSAgICAgICBpbnQgbmVsZW1zLCBl bnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQo+ICsJ CSAgICAgICBpbnQgbmVsZW1zLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gKwkJICAg ICAgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gIHsKPiAgCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7 Cj4gIAlpbnQgaTsKPiBAQCAtOTQxLDcgKzk0Miw3IEBAIHZvaWQKPiAgc3dpb3RsYl91bm1hcF9z ZyhzdHJ1Y3QgZGV2aWNlICpod2Rldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ2wsIGludCBuZWxl bXMsCj4gIAkJIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKPiAgewo+IC0JcmV0dXJuIHN3 aW90bGJfdW5tYXBfc2dfYXR0cnMoaHdkZXYsIHNnbCwgbmVsZW1zLCBkaXIsIE5VTEwpOwo+ICsJ cmV0dXJuIHN3aW90bGJfdW5tYXBfc2dfYXR0cnMoaHdkZXYsIHNnbCwgbmVsZW1zLCBkaXIsIDAp Owo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woc3dpb3RsYl91bm1hcF9zZyk7Cj4gIAo+IC0tIAo+IDEu OS4xCj4gCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K PiBpb21tdSBtYWlsaW5nIGxpc3QKPiBpb21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwo+ IGh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2lvbW11 Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZl bCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: konrad.wilk@oracle.com (Konrad Rzeszutek Wilk) Date: Tue, 31 May 2016 14:15:33 -0400 Subject: [RFC v2] dma-mapping: Use unsigned long for dma_attrs In-Reply-To: <1464609246-6948-2-git-send-email-k.kozlowski@samsung.com> References: <1464609246-6948-1-git-send-email-k.kozlowski@samsung.com> <1464609246-6948-2-git-send-email-k.kozlowski@samsung.com> Message-ID: <20160531181533.GD11300@char.us.oracle.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Mon, May 30, 2016 at 01:54:06PM +0200, Krzysztof Kozlowski wrote: > The dma-mapping core and the implementations do not change the > DMA attributes passed by pointer. Thus the pointer can point to const > data. However the attributes do not have to be a bitfield. Instead > unsigned long will do fine: > > 1. This is just simpler. Both in terms of reading the code and setting > attributes. Instead of initializing local attributes on the stack and > passing pointer to it to dma_set_attr(), just set the bits. > > 2. It brings safeness and checking for const correctness because the > attributes are passed by value. .. why not go the next step a do an enum? Perhaps that should be mentioned as part of the description? Thanks. > > Please have in mind that this is RFC, not finished yet. Only ARM and > ARM64 are fixed (and not everywhere). > However other API users also have to be converted which is quite > intrusive. I would rather avoid it until the overall approach is > accepted. > > Signed-off-by: Krzysztof Kozlowski > --- > Documentation/DMA-API.txt | 2 +- > Documentation/DMA-attributes.txt | 2 +- > arch/arm/include/asm/dma-mapping.h | 13 ++-- > arch/arm/include/asm/xen/page-coherent.h | 16 ++--- > arch/arm/mm/dma-mapping.c | 82 +++++++++++------------ > arch/arm/xen/mm.c | 4 +- > arch/arm64/mm/dma-mapping.c | 57 ++++++++-------- > drivers/gpu/drm/exynos/exynos_drm_fbdev.c | 2 +- > drivers/gpu/drm/exynos/exynos_drm_g2d.c | 1 - > drivers/gpu/drm/exynos/exynos_drm_gem.c | 20 +++--- > drivers/gpu/drm/exynos/exynos_drm_gem.h | 2 +- > drivers/iommu/dma-iommu.c | 6 +- > drivers/xen/swiotlb-xen.c | 14 ++-- > include/linux/dma-attrs.h | 71 -------------------- > include/linux/dma-iommu.h | 6 +- > include/linux/dma-mapping.h | 105 +++++++++++++++++------------- > include/linux/swiotlb.h | 10 +-- > include/xen/swiotlb-xen.h | 12 ++-- > lib/dma-noop.c | 9 +-- > lib/swiotlb.c | 13 ++-- > 20 files changed, 195 insertions(+), 252 deletions(-) > delete mode 100644 include/linux/dma-attrs.h > > diff --git a/Documentation/DMA-API.txt b/Documentation/DMA-API.txt > index 45ef3f279c3b..0b55cb7c5aaa 100644 > --- a/Documentation/DMA-API.txt > +++ b/Documentation/DMA-API.txt > @@ -391,7 +391,7 @@ without the _attrs suffixes, except that they pass an optional > struct dma_attrs*. > > struct dma_attrs encapsulates a set of "DMA attributes". For the > -definition of struct dma_attrs see linux/dma-attrs.h. > +definition of struct dma_attrs see linux/dma-mapping.h. > > The interpretation of DMA attributes is architecture-specific, and > each attribute should be documented in Documentation/DMA-attributes.txt. > diff --git a/Documentation/DMA-attributes.txt b/Documentation/DMA-attributes.txt > index e8cf9cf873b3..2d455a5cf671 100644 > --- a/Documentation/DMA-attributes.txt > +++ b/Documentation/DMA-attributes.txt > @@ -2,7 +2,7 @@ > ============== > > This document describes the semantics of the DMA attributes that are > -defined in linux/dma-attrs.h. > +defined in linux/dma-mapping.h. > > DMA_ATTR_WRITE_BARRIER > ---------------------- > diff --git a/arch/arm/include/asm/dma-mapping.h b/arch/arm/include/asm/dma-mapping.h > index a83570f10124..d009f7911ffc 100644 > --- a/arch/arm/include/asm/dma-mapping.h > +++ b/arch/arm/include/asm/dma-mapping.h > @@ -5,7 +5,6 @@ > > #include > #include > -#include > #include > > #include > @@ -174,7 +173,7 @@ static inline void dma_mark_clean(void *addr, size_t size) { } > * to be the device-viewed address. > */ > extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > - gfp_t gfp, struct dma_attrs *attrs); > + gfp_t gfp, unsigned long attrs); > > /** > * arm_dma_free - free memory allocated by arm_dma_alloc > @@ -191,7 +190,7 @@ extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > * during and after this call executing are illegal. > */ > extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs); > + dma_addr_t handle, unsigned long attrs); > > /** > * arm_dma_mmap - map a coherent DMA allocation into user space > @@ -208,7 +207,7 @@ extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > */ > extern int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs); > + unsigned long attrs); > > /* > * This can be called during early boot to increase the size of the atomic > @@ -262,16 +261,16 @@ extern void dmabounce_unregister_dev(struct device *); > * The scatter list versions of the above methods. > */ > extern int arm_dma_map_sg(struct device *, struct scatterlist *, int, > - enum dma_data_direction, struct dma_attrs *attrs); > + enum dma_data_direction, unsigned long attrs); > extern void arm_dma_unmap_sg(struct device *, struct scatterlist *, int, > - enum dma_data_direction, struct dma_attrs *attrs); > + enum dma_data_direction, unsigned long attrs); > extern void arm_dma_sync_sg_for_cpu(struct device *, struct scatterlist *, int, > enum dma_data_direction); > extern void arm_dma_sync_sg_for_device(struct device *, struct scatterlist *, int, > enum dma_data_direction); > extern int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs); > + unsigned long attrs); > > #endif /* __KERNEL__ */ > #endif > diff --git a/arch/arm/include/asm/xen/page-coherent.h b/arch/arm/include/asm/xen/page-coherent.h > index 9408a994cc91..95ce6ac3a971 100644 > --- a/arch/arm/include/asm/xen/page-coherent.h > +++ b/arch/arm/include/asm/xen/page-coherent.h > @@ -2,15 +2,14 @@ > #define _ASM_ARM_XEN_PAGE_COHERENT_H > > #include > -#include > #include > > void __xen_dma_map_page(struct device *hwdev, struct page *page, > dma_addr_t dev_addr, unsigned long offset, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, unsigned long attrs); > void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void __xen_dma_sync_single_for_cpu(struct device *hwdev, > dma_addr_t handle, size_t size, enum dma_data_direction dir); > > @@ -18,22 +17,20 @@ void __xen_dma_sync_single_for_device(struct device *hwdev, > dma_addr_t handle, size_t size, enum dma_data_direction dir); > > static inline void *xen_alloc_coherent_pages(struct device *hwdev, size_t size, > - dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) > { > return __generic_dma_ops(hwdev)->alloc(hwdev, size, dma_handle, flags, attrs); > } > > static inline void xen_free_coherent_pages(struct device *hwdev, size_t size, > - void *cpu_addr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + void *cpu_addr, dma_addr_t dma_handle, unsigned long attrs) > { > __generic_dma_ops(hwdev)->free(hwdev, size, cpu_addr, dma_handle, attrs); > } > > static inline void xen_dma_map_page(struct device *hwdev, struct page *page, > dma_addr_t dev_addr, unsigned long offset, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > unsigned long page_pfn = page_to_xen_pfn(page); > unsigned long dev_pfn = XEN_PFN_DOWN(dev_addr); > @@ -58,8 +55,7 @@ static inline void xen_dma_map_page(struct device *hwdev, struct page *page, > } > > static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > unsigned long pfn = PFN_DOWN(handle); > /* > diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c > index ff7ed5697d3e..fe31fbfd926d 100644 > --- a/arch/arm/mm/dma-mapping.c > +++ b/arch/arm/mm/dma-mapping.c > @@ -124,7 +124,7 @@ static void __dma_page_dev_to_cpu(struct page *, unsigned long, > */ > static dma_addr_t arm_dma_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_cpu_to_dev(page, offset, size, dir); > @@ -133,7 +133,7 @@ static dma_addr_t arm_dma_map_page(struct device *dev, struct page *page, > > static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return pfn_to_dma(dev, page_to_pfn(page)) + offset; > } > @@ -153,8 +153,7 @@ static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *pag > * whatever the device wrote there. > */ > static void arm_dma_unmap_page(struct device *dev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)), > @@ -194,12 +193,12 @@ struct dma_map_ops arm_dma_ops = { > EXPORT_SYMBOL(arm_dma_ops); > > static void *arm_coherent_dma_alloc(struct device *dev, size_t size, > - dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs); > + dma_addr_t *handle, gfp_t gfp, unsigned long attrs); > static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs); > + dma_addr_t handle, unsigned long attrs); > static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs); > + unsigned long attrs); > > struct dma_map_ops arm_coherent_dma_ops = { > .alloc = arm_coherent_dma_alloc, > @@ -621,7 +620,7 @@ static void __free_from_contiguous(struct device *dev, struct page *page, > dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT); > } > > -static inline pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot) > +static inline pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot) > { > prot = dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs) ? > pgprot_writecombine(prot) : > @@ -732,7 +731,7 @@ static struct arm_dma_allocator remap_allocator = { > > static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > gfp_t gfp, pgprot_t prot, bool is_coherent, > - struct dma_attrs *attrs, const void *caller) > + unsigned long attrs, const void *caller) > { > u64 mask = get_coherent_dma_mask(dev); > struct page *page = NULL; > @@ -814,7 +813,7 @@ static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > * virtual and bus address for that space. > */ > void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > - gfp_t gfp, struct dma_attrs *attrs) > + gfp_t gfp, unsigned long attrs) > { > pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL); > > @@ -823,7 +822,7 @@ void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > } > > static void *arm_coherent_dma_alloc(struct device *dev, size_t size, > - dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs) > + dma_addr_t *handle, gfp_t gfp, unsigned long attrs) > { > return __dma_alloc(dev, size, handle, gfp, PAGE_KERNEL, true, > attrs, __builtin_return_address(0)); > @@ -831,7 +830,7 @@ static void *arm_coherent_dma_alloc(struct device *dev, size_t size, > > static int __arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > int ret = -ENXIO; > #ifdef CONFIG_MMU > @@ -859,14 +858,14 @@ static int __arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > */ > static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return __arm_dma_mmap(dev, vma, cpu_addr, dma_addr, size, attrs); > } > > int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > #ifdef CONFIG_MMU > vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot); > @@ -878,7 +877,7 @@ int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > * Free a buffer as defined by the above mapping. > */ > static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs, > + dma_addr_t handle, unsigned long attrs, > bool is_coherent) > { > struct page *page = pfn_to_page(dma_to_pfn(dev, handle)); > @@ -900,20 +899,20 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > } > > void arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, unsigned long attrs) > { > __arm_dma_free(dev, size, cpu_addr, handle, attrs, false); > } > > static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, unsigned long attrs) > { > __arm_dma_free(dev, size, cpu_addr, handle, attrs, true); > } > > int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t handle, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct page *page = pfn_to_page(dma_to_pfn(dev, handle)); > int ret; > @@ -1046,7 +1045,7 @@ static void __dma_page_dev_to_cpu(struct page *page, unsigned long off, > * here. > */ > int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > struct scatterlist *s; > @@ -1080,7 +1079,7 @@ int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, > * rules concerning calls here are the same as for dma_unmap_single(). > */ > void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > struct scatterlist *s; > @@ -1253,7 +1252,7 @@ static inline void __free_iova(struct dma_iommu_mapping *mapping, > static const int iommu_order_array[] = { 9, 8, 4, 0 }; > > static struct page **__iommu_alloc_buffer(struct device *dev, size_t size, > - gfp_t gfp, struct dma_attrs *attrs) > + gfp_t gfp, unsigned long attrs) > { > struct page **pages; > int count = size >> PAGE_SHIFT; > @@ -1342,7 +1341,7 @@ error: > } > > static int __iommu_free_buffer(struct device *dev, struct page **pages, > - size_t size, struct dma_attrs *attrs) > + size_t size, unsigned long attrs) > { > int count = size >> PAGE_SHIFT; > int i; > @@ -1439,7 +1438,7 @@ static struct page **__atomic_get_pages(void *addr) > return (struct page **)page; > } > > -static struct page **__iommu_get_pages(void *cpu_addr, struct dma_attrs *attrs) > +static struct page **__iommu_get_pages(void *cpu_addr, unsigned long attrs) > { > struct vm_struct *area; > > @@ -1484,7 +1483,7 @@ static void __iommu_free_atomic(struct device *dev, void *cpu_addr, > } > > static void *arm_iommu_alloc_attrs(struct device *dev, size_t size, > - dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs) > + dma_addr_t *handle, gfp_t gfp, unsigned long attrs) > { > pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL); > struct page **pages; > @@ -1532,7 +1531,7 @@ err_buffer: > > static int arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > unsigned long uaddr = vma->vm_start; > unsigned long usize = vma->vm_end - vma->vm_start; > @@ -1568,7 +1567,7 @@ static int arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > * Must not be called with IRQs disabled. > */ > void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, unsigned long attrs) > { > struct page **pages; > size = PAGE_ALIGN(size); > @@ -1595,7 +1594,7 @@ void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > > static int arm_iommu_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t dma_addr, > - size_t size, struct dma_attrs *attrs) > + size_t size, unsigned long attrs) > { > unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; > struct page **pages = __iommu_get_pages(cpu_addr, attrs); > @@ -1633,7 +1632,7 @@ static int __dma_direction_to_prot(enum dma_data_direction dir) > */ > static int __map_sg_chunk(struct device *dev, struct scatterlist *sg, > size_t size, dma_addr_t *handle, > - enum dma_data_direction dir, struct dma_attrs *attrs, > + enum dma_data_direction dir, unsigned long attrs, > bool is_coherent) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > @@ -1676,7 +1675,7 @@ fail: > } > > static int __iommu_map_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs, > + enum dma_data_direction dir, unsigned long attrs, > bool is_coherent) > { > struct scatterlist *s = sg, *dma = sg, *start = sg; > @@ -1734,7 +1733,7 @@ bad_mapping: > * obtained via sg_dma_{address,length}. > */ > int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nents, enum dma_data_direction dir, unsigned long attrs) > { > return __iommu_map_sg(dev, sg, nents, dir, attrs, true); > } > @@ -1752,14 +1751,14 @@ int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg, > * sg_dma_{address,length}. > */ > int arm_iommu_map_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nents, enum dma_data_direction dir, unsigned long attrs) > { > return __iommu_map_sg(dev, sg, nents, dir, attrs, false); > } > > static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs, > - bool is_coherent) > + int nents, enum dma_data_direction dir, > + unsigned long attrs, bool is_coherent) > { > struct scatterlist *s; > int i; > @@ -1786,7 +1785,8 @@ static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > * rules concerning calls here are the same as for dma_unmap_single(). > */ > void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nents, enum dma_data_direction dir, > + unsigned long attrs) > { > __iommu_unmap_sg(dev, sg, nents, dir, attrs, true); > } > @@ -1802,7 +1802,8 @@ void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > * rules concerning calls here are the same as for dma_unmap_single(). > */ > void arm_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, > + unsigned long attrs) > { > __iommu_unmap_sg(dev, sg, nents, dir, attrs, false); > } > @@ -1855,7 +1856,7 @@ void arm_iommu_sync_sg_for_device(struct device *dev, struct scatterlist *sg, > */ > static dma_addr_t arm_coherent_iommu_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > dma_addr_t dma_addr; > @@ -1889,7 +1890,7 @@ fail: > */ > static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_cpu_to_dev(page, offset, size, dir); > @@ -1907,8 +1908,7 @@ static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page, > * Coherent IOMMU aware version of arm_dma_unmap_page() > */ > static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > dma_addr_t iova = handle & PAGE_MASK; > @@ -1932,8 +1932,7 @@ static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle, > * IOMMU aware version of arm_dma_unmap_page() > */ > static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > dma_addr_t iova = handle & PAGE_MASK; > @@ -1944,6 +1943,7 @@ static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle, > if (!iova) > return; > > + // FIXME: replace get with simple check > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_dev_to_cpu(page, offset, size, dir); > > diff --git a/arch/arm/xen/mm.c b/arch/arm/xen/mm.c > index c5f9a9e3d1f3..fc67ed236a10 100644 > --- a/arch/arm/xen/mm.c > +++ b/arch/arm/xen/mm.c > @@ -98,7 +98,7 @@ static void __xen_dma_page_cpu_to_dev(struct device *hwdev, dma_addr_t handle, > > void __xen_dma_map_page(struct device *hwdev, struct page *page, > dma_addr_t dev_addr, unsigned long offset, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > if (is_device_dma_coherent(hwdev)) > return; > @@ -110,7 +110,7 @@ void __xen_dma_map_page(struct device *hwdev, struct page *page, > > void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > > { > if (is_device_dma_coherent(hwdev)) > diff --git a/arch/arm64/mm/dma-mapping.c b/arch/arm64/mm/dma-mapping.c > index c566ec83719f..a7686028dfeb 100644 > --- a/arch/arm64/mm/dma-mapping.c > +++ b/arch/arm64/mm/dma-mapping.c > @@ -29,7 +29,7 @@ > > #include > > -static pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot, > +static pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot, > bool coherent) > { > if (!coherent || dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs)) > @@ -88,7 +88,7 @@ static int __free_from_pool(void *start, size_t size) > > static void *__dma_alloc_coherent(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (dev == NULL) { > WARN_ONCE(1, "Use an actual device structure for DMA allocation\n"); > @@ -118,7 +118,7 @@ static void *__dma_alloc_coherent(struct device *dev, size_t size, > > static void __dma_free_coherent(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool freed; > phys_addr_t paddr = dma_to_phys(dev, dma_handle); > @@ -137,7 +137,7 @@ static void __dma_free_coherent(struct device *dev, size_t size, > > static void *__dma_alloc(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct page *page; > void *ptr, *coherent_ptr; > @@ -185,7 +185,7 @@ no_mem: > > static void __dma_free(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > void *swiotlb_addr = phys_to_virt(dma_to_phys(dev, dma_handle)); > > @@ -202,7 +202,7 @@ static void __dma_free(struct device *dev, size_t size, > static dma_addr_t __swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > dma_addr_t dev_addr; > > @@ -216,7 +216,7 @@ static dma_addr_t __swiotlb_map_page(struct device *dev, struct page *page, > > static void __swiotlb_unmap_page(struct device *dev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!is_device_dma_coherent(dev)) > __dma_unmap_area(phys_to_virt(dma_to_phys(dev, dev_addr)), size, dir); > @@ -225,7 +225,7 @@ static void __swiotlb_unmap_page(struct device *dev, dma_addr_t dev_addr, > > static int __swiotlb_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i, ret; > @@ -242,7 +242,7 @@ static int __swiotlb_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > static void __swiotlb_unmap_sg_attrs(struct device *dev, > struct scatterlist *sgl, int nelems, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -303,7 +303,7 @@ static void __swiotlb_sync_sg_for_device(struct device *dev, > static int __swiotlb_mmap(struct device *dev, > struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > int ret = -ENXIO; > unsigned long nr_vma_pages = (vma->vm_end - vma->vm_start) >> > @@ -330,7 +330,7 @@ static int __swiotlb_mmap(struct device *dev, > > static int __swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t handle, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > int ret = sg_alloc_table(sgt, 1, GFP_KERNEL); > > @@ -425,21 +425,21 @@ out: > > static void *__dummy_alloc(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return NULL; > } > > static void __dummy_free(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > } > > static int __dummy_mmap(struct device *dev, > struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return -ENXIO; > } > @@ -447,20 +447,20 @@ static int __dummy_mmap(struct device *dev, > static dma_addr_t __dummy_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return DMA_ERROR_CODE; > } > > static void __dummy_unmap_page(struct device *dev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > } > > static int __dummy_map_sg(struct device *dev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return 0; > } > @@ -468,7 +468,7 @@ static int __dummy_map_sg(struct device *dev, struct scatterlist *sgl, > static void __dummy_unmap_sg(struct device *dev, > struct scatterlist *sgl, int nelems, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > } > > @@ -540,7 +540,7 @@ static void flush_page(struct device *dev, const void *virt, phys_addr_t phys) > > static void *__iommu_alloc_attrs(struct device *dev, size_t size, > dma_addr_t *handle, gfp_t gfp, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool coherent = is_device_dma_coherent(dev); > int ioprot = dma_direction_to_prot(DMA_BIDIRECTIONAL, coherent); > @@ -600,7 +600,8 @@ static void *__iommu_alloc_attrs(struct device *dev, size_t size, > } > > static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, > + unsigned long attrs) > { > size_t iosize = size; > > @@ -616,7 +617,7 @@ static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > * Hence how dodgy the below logic looks... > */ > if (__in_atomic_pool(cpu_addr, size)) { > - iommu_dma_unmap_page(dev, handle, iosize, 0, NULL); > + iommu_dma_unmap_page(dev, handle, iosize, 0, 0); > __free_from_pool(cpu_addr, size); > } else if (is_vmalloc_addr(cpu_addr)){ > struct vm_struct *area = find_vm_area(cpu_addr); > @@ -626,14 +627,14 @@ static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > iommu_dma_free(dev, area->pages, iosize, &handle); > dma_common_free_remap(cpu_addr, size, VM_USERMAP); > } else { > - iommu_dma_unmap_page(dev, handle, iosize, 0, NULL); > + iommu_dma_unmap_page(dev, handle, iosize, 0, 0); > __free_pages(virt_to_page(cpu_addr), get_order(size)); > } > } > > static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct vm_struct *area; > int ret; > @@ -653,7 +654,7 @@ static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > > static int __iommu_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t dma_addr, > - size_t size, struct dma_attrs *attrs) > + size_t size, unsigned long attrs) > { > unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; > struct vm_struct *area = find_vm_area(cpu_addr); > @@ -694,7 +695,7 @@ static void __iommu_sync_single_for_device(struct device *dev, > static dma_addr_t __iommu_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool coherent = is_device_dma_coherent(dev); > int prot = dma_direction_to_prot(dir, coherent); > @@ -709,7 +710,7 @@ static dma_addr_t __iommu_map_page(struct device *dev, struct page *page, > > static void __iommu_unmap_page(struct device *dev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __iommu_sync_single_for_cpu(dev, dev_addr, size, dir); > @@ -747,7 +748,7 @@ static void __iommu_sync_sg_for_device(struct device *dev, > > static int __iommu_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool coherent = is_device_dma_coherent(dev); > > @@ -761,7 +762,7 @@ static int __iommu_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > static void __iommu_unmap_sg_attrs(struct device *dev, > struct scatterlist *sgl, int nelems, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __iommu_sync_sg_for_cpu(dev, sgl, nelems, dir); > diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c > index 67dcd6831291..dd091175fc2d 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c > @@ -52,7 +52,7 @@ static int exynos_drm_fb_mmap(struct fb_info *info, > > ret = dma_mmap_attrs(to_dma_dev(helper->dev), vma, exynos_gem->cookie, > exynos_gem->dma_addr, exynos_gem->size, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (ret < 0) { > DRM_ERROR("failed to mmap.\n"); > return ret; > diff --git a/drivers/gpu/drm/exynos/exynos_drm_g2d.c b/drivers/gpu/drm/exynos/exynos_drm_g2d.c > index 493552368295..f65e6b7ef93b 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_g2d.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_g2d.c > @@ -17,7 +17,6 @@ > #include > #include > #include > -#include > #include > > #include > diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.c b/drivers/gpu/drm/exynos/exynos_drm_gem.c > index cdf9f1af4347..f2ae72ba7d5a 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_gem.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_gem.c > @@ -24,7 +24,7 @@ > static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > { > struct drm_device *dev = exynos_gem->base.dev; > - enum dma_attr attr; > + unsigned long attr; > unsigned int nr_pages; > struct sg_table sgt; > int ret = -ENOMEM; > @@ -34,7 +34,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > return 0; > } > > - init_dma_attrs(&exynos_gem->dma_attrs); > + exynos_gem->dma_attrs = 0; > > /* > * if EXYNOS_BO_CONTIG, fully physically contiguous memory > @@ -42,7 +42,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > * as possible. > */ > if (!(exynos_gem->flags & EXYNOS_BO_NONCONTIG)) > - dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs |= DMA_ATTR_FORCE_CONTIGUOUS; > > /* > * if EXYNOS_BO_WC or EXYNOS_BO_NONCACHABLE, writecombine mapping > @@ -54,8 +54,8 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > else > attr = DMA_ATTR_NON_CONSISTENT; > > - dma_set_attr(attr, &exynos_gem->dma_attrs); > - dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs |= attr; > + exynos_gem->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING; > > nr_pages = exynos_gem->size >> PAGE_SHIFT; > > @@ -67,7 +67,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > > exynos_gem->cookie = dma_alloc_attrs(to_dma_dev(dev), exynos_gem->size, > &exynos_gem->dma_addr, GFP_KERNEL, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (!exynos_gem->cookie) { > DRM_ERROR("failed to allocate buffer.\n"); > goto err_free; > @@ -75,7 +75,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > > ret = dma_get_sgtable_attrs(to_dma_dev(dev), &sgt, exynos_gem->cookie, > exynos_gem->dma_addr, exynos_gem->size, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (ret < 0) { > DRM_ERROR("failed to get sgtable.\n"); > goto err_dma_free; > @@ -99,7 +99,7 @@ err_sgt_free: > sg_free_table(&sgt); > err_dma_free: > dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie, > - exynos_gem->dma_addr, &exynos_gem->dma_attrs); > + exynos_gem->dma_addr, exynos_gem->dma_attrs); > err_free: > drm_free_large(exynos_gem->pages); > > @@ -120,7 +120,7 @@ static void exynos_drm_free_buf(struct exynos_drm_gem *exynos_gem) > > dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie, > (dma_addr_t)exynos_gem->dma_addr, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > > drm_free_large(exynos_gem->pages); > } > @@ -346,7 +346,7 @@ static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem *exynos_gem, > > ret = dma_mmap_attrs(to_dma_dev(drm_dev), vma, exynos_gem->cookie, > exynos_gem->dma_addr, exynos_gem->size, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (ret < 0) { > DRM_ERROR("failed to mmap.\n"); > return ret; > diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.h b/drivers/gpu/drm/exynos/exynos_drm_gem.h > index 78100742281d..df7c543d6558 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_gem.h > +++ b/drivers/gpu/drm/exynos/exynos_drm_gem.h > @@ -50,7 +50,7 @@ struct exynos_drm_gem { > void *cookie; > void __iomem *kvaddr; > dma_addr_t dma_addr; > - struct dma_attrs dma_attrs; > + unsigned long dma_attrs; > struct page **pages; > struct sg_table *sgt; > }; > diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c > index ea5a9ebf0f78..6c1bda504fb1 100644 > --- a/drivers/iommu/dma-iommu.c > +++ b/drivers/iommu/dma-iommu.c > @@ -286,7 +286,7 @@ void iommu_dma_free(struct device *dev, struct page **pages, size_t size, > * or NULL on failure. > */ > struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp, > - struct dma_attrs *attrs, int prot, dma_addr_t *handle, > + unsigned long attrs, int prot, dma_addr_t *handle, > void (*flush_page)(struct device *, const void *, phys_addr_t)) > { > struct iommu_domain *domain = iommu_get_domain_for_dev(dev); > @@ -400,7 +400,7 @@ dma_addr_t iommu_dma_map_page(struct device *dev, struct page *page, > } > > void iommu_dma_unmap_page(struct device *dev, dma_addr_t handle, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > __iommu_dma_unmap(iommu_get_domain_for_dev(dev), handle); > } > @@ -560,7 +560,7 @@ out_restore_sg: > } > > void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > /* > * The scatterlist segments are mapped into a single > diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c > index 7399782c0998..87e6035c9e81 100644 > --- a/drivers/xen/swiotlb-xen.c > +++ b/drivers/xen/swiotlb-xen.c > @@ -294,7 +294,7 @@ error: > void * > xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > void *ret; > int order = get_order(size); > @@ -346,7 +346,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent); > > void > xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, > - dma_addr_t dev_addr, struct dma_attrs *attrs) > + dma_addr_t dev_addr, unsigned long attrs) > { > int order = get_order(size); > phys_addr_t phys; > @@ -378,7 +378,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); > dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > phys_addr_t map, phys = page_to_phys(page) + offset; > dma_addr_t dev_addr = xen_phys_to_bus(phys); > @@ -434,7 +434,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_page); > */ > static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > phys_addr_t paddr = xen_bus_to_phys(dev_addr); > > @@ -462,7 +462,7 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, > > void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > xen_unmap_single(hwdev, dev_addr, size, dir, attrs); > } > @@ -538,7 +538,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); > int > xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -599,7 +599,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs); > void > xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > diff --git a/include/linux/dma-attrs.h b/include/linux/dma-attrs.h > deleted file mode 100644 > index 5246239a4953..000000000000 > --- a/include/linux/dma-attrs.h > +++ /dev/null > @@ -1,71 +0,0 @@ > -#ifndef _DMA_ATTR_H > -#define _DMA_ATTR_H > - > -#include > -#include > -#include > - > -/** > - * an enum dma_attr represents an attribute associated with a DMA > - * mapping. The semantics of each attribute should be defined in > - * Documentation/DMA-attributes.txt. > - */ > -enum dma_attr { > - DMA_ATTR_WRITE_BARRIER, > - DMA_ATTR_WEAK_ORDERING, > - DMA_ATTR_WRITE_COMBINE, > - DMA_ATTR_NON_CONSISTENT, > - DMA_ATTR_NO_KERNEL_MAPPING, > - DMA_ATTR_SKIP_CPU_SYNC, > - DMA_ATTR_FORCE_CONTIGUOUS, > - DMA_ATTR_ALLOC_SINGLE_PAGES, > - DMA_ATTR_MAX, > -}; > - > -#define __DMA_ATTRS_LONGS BITS_TO_LONGS(DMA_ATTR_MAX) > - > -/** > - * struct dma_attrs - an opaque container for DMA attributes > - * @flags - bitmask representing a collection of enum dma_attr > - */ > -struct dma_attrs { > - unsigned long flags[__DMA_ATTRS_LONGS]; > -}; > - > -#define DEFINE_DMA_ATTRS(x) \ > - struct dma_attrs x = { \ > - .flags = { [0 ... __DMA_ATTRS_LONGS-1] = 0 }, \ > - } > - > -static inline void init_dma_attrs(struct dma_attrs *attrs) > -{ > - bitmap_zero(attrs->flags, __DMA_ATTRS_LONGS); > -} > - > -/** > - * dma_set_attr - set a specific attribute > - * @attr: attribute to set > - * @attrs: struct dma_attrs (may be NULL) > - */ > -static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs) > -{ > - if (attrs == NULL) > - return; > - BUG_ON(attr >= DMA_ATTR_MAX); > - __set_bit(attr, attrs->flags); > -} > - > -/** > - * dma_get_attr - check for a specific attribute > - * @attr: attribute to set > - * @attrs: struct dma_attrs (may be NULL) > - */ > -static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs) > -{ > - if (attrs == NULL) > - return 0; > - BUG_ON(attr >= DMA_ATTR_MAX); > - return test_bit(attr, attrs->flags); > -} > - > -#endif /* _DMA_ATTR_H */ > diff --git a/include/linux/dma-iommu.h b/include/linux/dma-iommu.h > index 8443bbb5c071..81c5c8d167ad 100644 > --- a/include/linux/dma-iommu.h > +++ b/include/linux/dma-iommu.h > @@ -39,7 +39,7 @@ int dma_direction_to_prot(enum dma_data_direction dir, bool coherent); > * the arch code to take care of attributes and cache maintenance > */ > struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp, > - struct dma_attrs *attrs, int prot, dma_addr_t *handle, > + unsigned long attrs, int prot, dma_addr_t *handle, > void (*flush_page)(struct device *, const void *, phys_addr_t)); > void iommu_dma_free(struct device *dev, struct page **pages, size_t size, > dma_addr_t *handle); > @@ -56,9 +56,9 @@ int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg, > * directly as DMA mapping callbacks for simplicity > */ > void iommu_dma_unmap_page(struct device *dev, dma_addr_t handle, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, unsigned long attrs); > void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, unsigned long attrs); > int iommu_dma_supported(struct device *dev, u64 mask); > int iommu_dma_mapping_error(struct device *dev, dma_addr_t dma_addr); > > diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h > index 71c1b215ef66..19e581d5f8b4 100644 > --- a/include/linux/dma-mapping.h > +++ b/include/linux/dma-mapping.h > @@ -5,13 +5,25 @@ > #include > #include > #include > -#include > #include > #include > #include > #include > #include > > +/** > + * List of possible attributes associated with a DMA mapping. The semantics > + * of each attribute should be defined in Documentation/DMA-attributes.txt. > + */ > +#define DMA_ATTR_WRITE_BARRIER BIT(1) > +#define DMA_ATTR_WEAK_ORDERING BIT(2) > +#define DMA_ATTR_WRITE_COMBINE BIT(3) > +#define DMA_ATTR_NON_CONSISTENT BIT(4) > +#define DMA_ATTR_NO_KERNEL_MAPPING BIT(5) > +#define DMA_ATTR_SKIP_CPU_SYNC BIT(6) > +#define DMA_ATTR_FORCE_CONTIGUOUS BIT(7) > +#define DMA_ATTR_ALLOC_SINGLE_PAGES BIT(8) > + > /* > * A dma_addr_t can hold any valid DMA or bus address for the platform. > * It can be given to a device to use as a DMA source or target. A CPU cannot > @@ -21,34 +33,35 @@ > struct dma_map_ops { > void* (*alloc)(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t gfp, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*free)(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs); > + unsigned long attrs); > int (*mmap)(struct device *, struct vm_area_struct *, > - void *, dma_addr_t, size_t, struct dma_attrs *attrs); > + void *, dma_addr_t, size_t, > + unsigned long attrs); > > int (*get_sgtable)(struct device *dev, struct sg_table *sgt, void *, > - dma_addr_t, size_t, struct dma_attrs *attrs); > + dma_addr_t, size_t, unsigned long attrs); > > dma_addr_t (*map_page)(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*unmap_page)(struct device *dev, dma_addr_t dma_handle, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > /* > * map_sg returns 0 on error and a value > 0 on success. > * It should never return a value < 0. > */ > int (*map_sg)(struct device *dev, struct scatterlist *sg, > int nents, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*unmap_sg)(struct device *dev, > struct scatterlist *sg, int nents, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*sync_single_for_cpu)(struct device *dev, > dma_addr_t dma_handle, size_t size, > enum dma_data_direction dir); > @@ -88,6 +101,16 @@ static inline int is_device_dma_capable(struct device *dev) > return dev->dma_mask != NULL && *dev->dma_mask != DMA_MASK_NONE; > } > > +/** > + * dma_get_attr - check for a specific attribute > + * @attr: attribute to look for > + * @attrs: attributes to check within > + */ > +static inline bool dma_get_attr(unsigned long attr, unsigned long attrs) > +{ > + return !!(attr & attrs); > +} > + > #ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT > /* > * These three functions are only for dma allocator. > @@ -123,7 +146,7 @@ static inline struct dma_map_ops *get_dma_ops(struct device *dev) > static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr, > size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > dma_addr_t addr; > @@ -142,7 +165,7 @@ static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr, > static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, > size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > > @@ -158,7 +181,7 @@ static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, > */ > static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, > int nents, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > int i, ents; > @@ -176,7 +199,7 @@ static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, > > static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg, > int nents, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > > @@ -195,7 +218,7 @@ static inline dma_addr_t dma_map_page(struct device *dev, struct page *page, > > kmemcheck_mark_initialized(page_address(page) + offset, size); > BUG_ON(!valid_dma_direction(dir)); > - addr = ops->map_page(dev, page, offset, size, dir, NULL); > + addr = ops->map_page(dev, page, offset, size, dir, 0); > debug_dma_map_page(dev, page, offset, size, dir, addr, false); > > return addr; > @@ -208,7 +231,7 @@ static inline void dma_unmap_page(struct device *dev, dma_addr_t addr, > > BUG_ON(!valid_dma_direction(dir)); > if (ops->unmap_page) > - ops->unmap_page(dev, addr, size, dir, NULL); > + ops->unmap_page(dev, addr, size, dir, 0); > debug_dma_unmap_page(dev, addr, size, dir, false); > } > > @@ -289,10 +312,10 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, > > } > > -#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL) > -#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL) > -#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL) > -#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL) > +#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0) > +#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0) > +#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0) > +#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0) > > extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size); > @@ -321,7 +344,7 @@ void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags); > */ > static inline int > dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, > - dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs) > + dma_addr_t dma_addr, size_t size, unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > BUG_ON(!ops); > @@ -330,7 +353,7 @@ dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, > return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size); > } > > -#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL) > +#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0) > > int > dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, > @@ -338,7 +361,8 @@ dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, > > static inline int > dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, > - dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs) > + dma_addr_t dma_addr, size_t size, > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > BUG_ON(!ops); > @@ -348,7 +372,7 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, > return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size); > } > > -#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL) > +#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0) > > #ifndef arch_dma_alloc_attrs > #define arch_dma_alloc_attrs(dev, flag) (true) > @@ -356,7 +380,7 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, > > static inline void *dma_alloc_attrs(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flag, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > void *cpu_addr; > @@ -378,7 +402,7 @@ static inline void *dma_alloc_attrs(struct device *dev, size_t size, > > static inline void dma_free_attrs(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > > @@ -398,31 +422,27 @@ static inline void dma_free_attrs(struct device *dev, size_t size, > static inline void *dma_alloc_coherent(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flag) > { > - return dma_alloc_attrs(dev, size, dma_handle, flag, NULL); > + return dma_alloc_attrs(dev, size, dma_handle, flag, 0); > } > > static inline void dma_free_coherent(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_handle) > { > - return dma_free_attrs(dev, size, cpu_addr, dma_handle, NULL); > + return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0); > } > > static inline void *dma_alloc_noncoherent(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t gfp) > { > - DEFINE_DMA_ATTRS(attrs); > - > - dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs); > - return dma_alloc_attrs(dev, size, dma_handle, gfp, &attrs); > + return dma_alloc_attrs(dev, size, dma_handle, gfp, > + DMA_ATTR_NON_CONSISTENT); > } > > static inline void dma_free_noncoherent(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_handle) > { > - DEFINE_DMA_ATTRS(attrs); > - > - dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs); > - dma_free_attrs(dev, size, cpu_addr, dma_handle, &attrs); > + dma_free_attrs(dev, size, cpu_addr, dma_handle, > + DMA_ATTR_NON_CONSISTENT); > } > > static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) > @@ -646,9 +666,8 @@ static inline void dmam_release_declared_memory(struct device *dev) > static inline void *dma_alloc_wc(struct device *dev, size_t size, > dma_addr_t *dma_addr, gfp_t gfp) > { > - DEFINE_DMA_ATTRS(attrs); > - dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); > - return dma_alloc_attrs(dev, size, dma_addr, gfp, &attrs); > + return dma_alloc_attrs(dev, size, dma_addr, gfp, > + DMA_ATTR_WRITE_COMBINE); > } > #ifndef dma_alloc_writecombine > #define dma_alloc_writecombine dma_alloc_wc > @@ -657,9 +676,8 @@ static inline void *dma_alloc_wc(struct device *dev, size_t size, > static inline void dma_free_wc(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_addr) > { > - DEFINE_DMA_ATTRS(attrs); > - dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); > - return dma_free_attrs(dev, size, cpu_addr, dma_addr, &attrs); > + return dma_free_attrs(dev, size, cpu_addr, dma_addr, > + DMA_ATTR_WRITE_COMBINE); > } > #ifndef dma_free_writecombine > #define dma_free_writecombine dma_free_wc > @@ -670,9 +688,8 @@ static inline int dma_mmap_wc(struct device *dev, > void *cpu_addr, dma_addr_t dma_addr, > size_t size) > { > - DEFINE_DMA_ATTRS(attrs); > - dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); > - return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs); > + return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, > + DMA_ATTR_WRITE_COMBINE); > } > #ifndef dma_mmap_writecombine > #define dma_mmap_writecombine dma_mmap_wc > diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h > index 017fced60242..5f81f8a187f2 100644 > --- a/include/linux/swiotlb.h > +++ b/include/linux/swiotlb.h > @@ -6,7 +6,6 @@ > #include > > struct device; > -struct dma_attrs; > struct page; > struct scatterlist; > > @@ -68,10 +67,10 @@ swiotlb_free_coherent(struct device *hwdev, size_t size, > extern dma_addr_t swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > extern void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern int > swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents, > @@ -83,12 +82,13 @@ swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents, > > extern int > swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, > + unsigned long attrs); > > extern void > swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, > diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h > index 8b2eb93ae8ba..7c35e279d1e3 100644 > --- a/include/xen/swiotlb-xen.h > +++ b/include/xen/swiotlb-xen.h > @@ -9,30 +9,30 @@ extern int xen_swiotlb_init(int verbose, bool early); > extern void > *xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > xen_swiotlb_free_coherent(struct device *hwdev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > extern int > xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, > diff --git a/lib/dma-noop.c b/lib/dma-noop.c > index 72145646857e..3d766e78fbe2 100644 > --- a/lib/dma-noop.c > +++ b/lib/dma-noop.c > @@ -10,7 +10,7 @@ > > static void *dma_noop_alloc(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t gfp, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > void *ret; > > @@ -22,7 +22,7 @@ static void *dma_noop_alloc(struct device *dev, size_t size, > > static void dma_noop_free(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_addr, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > free_pages((unsigned long)cpu_addr, get_order(size)); > } > @@ -30,13 +30,14 @@ static void dma_noop_free(struct device *dev, size_t size, > static dma_addr_t dma_noop_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return page_to_phys(page) + offset; > } > > static int dma_noop_map_sg(struct device *dev, struct scatterlist *sgl, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, > + unsigned long attrs) > { > int i; > struct scatterlist *sg; > diff --git a/lib/swiotlb.c b/lib/swiotlb.c > index 76f29ecba8f4..22e13a0e19d7 100644 > --- a/lib/swiotlb.c > +++ b/lib/swiotlb.c > @@ -738,7 +738,7 @@ swiotlb_full(struct device *dev, size_t size, enum dma_data_direction dir, > dma_addr_t swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > phys_addr_t map, phys = page_to_phys(page) + offset; > dma_addr_t dev_addr = phys_to_dma(dev, phys); > @@ -807,7 +807,7 @@ static void unmap_single(struct device *hwdev, dma_addr_t dev_addr, > > void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > unmap_single(hwdev, dev_addr, size, dir); > } > @@ -877,7 +877,7 @@ EXPORT_SYMBOL(swiotlb_sync_single_for_device); > */ > int > swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -914,7 +914,7 @@ int > swiotlb_map_sg(struct device *hwdev, struct scatterlist *sgl, int nelems, > enum dma_data_direction dir) > { > - return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, NULL); > + return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, 0); > } > EXPORT_SYMBOL(swiotlb_map_sg); > > @@ -924,7 +924,8 @@ EXPORT_SYMBOL(swiotlb_map_sg); > */ > void > swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > - int nelems, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nelems, enum dma_data_direction dir, > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -941,7 +942,7 @@ void > swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems, > enum dma_data_direction dir) > { > - return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, NULL); > + return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, 0); > } > EXPORT_SYMBOL(swiotlb_unmap_sg); > > -- > 1.9.1 > > _______________________________________________ > iommu mailing list > iommu at lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932174AbcEaSSe (ORCPT ); Tue, 31 May 2016 14:18:34 -0400 Received: from userp1040.oracle.com ([156.151.31.81]:32900 "EHLO userp1040.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755845AbcEaSSb (ORCPT ); Tue, 31 May 2016 14:18:31 -0400 Date: Tue, 31 May 2016 14:15:33 -0400 From: Konrad Rzeszutek Wilk To: Krzysztof Kozlowski Cc: Russell King , Catalin Marinas , Will Deacon , Joerg Roedel , Andrew Morton , Marek Szyprowski , Michal Hocko , Mel Gorman , Arnd Bergmann , Andy Lutomirski , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, xen-devel@lists.xenproject.org, dri-devel@lists.freedesktop.org, linux-samsung-soc@vger.kernel.org, iommu@lists.linux-foundation.org, hch@infradead.org, sstabellini@kernel.org, Bartlomiej Zolnierkiewicz Subject: Re: [RFC v2] dma-mapping: Use unsigned long for dma_attrs Message-ID: <20160531181533.GD11300@char.us.oracle.com> References: <1464609246-6948-1-git-send-email-k.kozlowski@samsung.com> <1464609246-6948-2-git-send-email-k.kozlowski@samsung.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1464609246-6948-2-git-send-email-k.kozlowski@samsung.com> User-Agent: Mutt/1.5.24 (2015-08-30) X-Source-IP: userv0022.oracle.com [156.151.31.74] Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, May 30, 2016 at 01:54:06PM +0200, Krzysztof Kozlowski wrote: > The dma-mapping core and the implementations do not change the > DMA attributes passed by pointer. Thus the pointer can point to const > data. However the attributes do not have to be a bitfield. Instead > unsigned long will do fine: > > 1. This is just simpler. Both in terms of reading the code and setting > attributes. Instead of initializing local attributes on the stack and > passing pointer to it to dma_set_attr(), just set the bits. > > 2. It brings safeness and checking for const correctness because the > attributes are passed by value. .. why not go the next step a do an enum? Perhaps that should be mentioned as part of the description? Thanks. > > Please have in mind that this is RFC, not finished yet. Only ARM and > ARM64 are fixed (and not everywhere). > However other API users also have to be converted which is quite > intrusive. I would rather avoid it until the overall approach is > accepted. > > Signed-off-by: Krzysztof Kozlowski > --- > Documentation/DMA-API.txt | 2 +- > Documentation/DMA-attributes.txt | 2 +- > arch/arm/include/asm/dma-mapping.h | 13 ++-- > arch/arm/include/asm/xen/page-coherent.h | 16 ++--- > arch/arm/mm/dma-mapping.c | 82 +++++++++++------------ > arch/arm/xen/mm.c | 4 +- > arch/arm64/mm/dma-mapping.c | 57 ++++++++-------- > drivers/gpu/drm/exynos/exynos_drm_fbdev.c | 2 +- > drivers/gpu/drm/exynos/exynos_drm_g2d.c | 1 - > drivers/gpu/drm/exynos/exynos_drm_gem.c | 20 +++--- > drivers/gpu/drm/exynos/exynos_drm_gem.h | 2 +- > drivers/iommu/dma-iommu.c | 6 +- > drivers/xen/swiotlb-xen.c | 14 ++-- > include/linux/dma-attrs.h | 71 -------------------- > include/linux/dma-iommu.h | 6 +- > include/linux/dma-mapping.h | 105 +++++++++++++++++------------- > include/linux/swiotlb.h | 10 +-- > include/xen/swiotlb-xen.h | 12 ++-- > lib/dma-noop.c | 9 +-- > lib/swiotlb.c | 13 ++-- > 20 files changed, 195 insertions(+), 252 deletions(-) > delete mode 100644 include/linux/dma-attrs.h > > diff --git a/Documentation/DMA-API.txt b/Documentation/DMA-API.txt > index 45ef3f279c3b..0b55cb7c5aaa 100644 > --- a/Documentation/DMA-API.txt > +++ b/Documentation/DMA-API.txt > @@ -391,7 +391,7 @@ without the _attrs suffixes, except that they pass an optional > struct dma_attrs*. > > struct dma_attrs encapsulates a set of "DMA attributes". For the > -definition of struct dma_attrs see linux/dma-attrs.h. > +definition of struct dma_attrs see linux/dma-mapping.h. > > The interpretation of DMA attributes is architecture-specific, and > each attribute should be documented in Documentation/DMA-attributes.txt. > diff --git a/Documentation/DMA-attributes.txt b/Documentation/DMA-attributes.txt > index e8cf9cf873b3..2d455a5cf671 100644 > --- a/Documentation/DMA-attributes.txt > +++ b/Documentation/DMA-attributes.txt > @@ -2,7 +2,7 @@ > ============== > > This document describes the semantics of the DMA attributes that are > -defined in linux/dma-attrs.h. > +defined in linux/dma-mapping.h. > > DMA_ATTR_WRITE_BARRIER > ---------------------- > diff --git a/arch/arm/include/asm/dma-mapping.h b/arch/arm/include/asm/dma-mapping.h > index a83570f10124..d009f7911ffc 100644 > --- a/arch/arm/include/asm/dma-mapping.h > +++ b/arch/arm/include/asm/dma-mapping.h > @@ -5,7 +5,6 @@ > > #include > #include > -#include > #include > > #include > @@ -174,7 +173,7 @@ static inline void dma_mark_clean(void *addr, size_t size) { } > * to be the device-viewed address. > */ > extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > - gfp_t gfp, struct dma_attrs *attrs); > + gfp_t gfp, unsigned long attrs); > > /** > * arm_dma_free - free memory allocated by arm_dma_alloc > @@ -191,7 +190,7 @@ extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > * during and after this call executing are illegal. > */ > extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs); > + dma_addr_t handle, unsigned long attrs); > > /** > * arm_dma_mmap - map a coherent DMA allocation into user space > @@ -208,7 +207,7 @@ extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > */ > extern int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs); > + unsigned long attrs); > > /* > * This can be called during early boot to increase the size of the atomic > @@ -262,16 +261,16 @@ extern void dmabounce_unregister_dev(struct device *); > * The scatter list versions of the above methods. > */ > extern int arm_dma_map_sg(struct device *, struct scatterlist *, int, > - enum dma_data_direction, struct dma_attrs *attrs); > + enum dma_data_direction, unsigned long attrs); > extern void arm_dma_unmap_sg(struct device *, struct scatterlist *, int, > - enum dma_data_direction, struct dma_attrs *attrs); > + enum dma_data_direction, unsigned long attrs); > extern void arm_dma_sync_sg_for_cpu(struct device *, struct scatterlist *, int, > enum dma_data_direction); > extern void arm_dma_sync_sg_for_device(struct device *, struct scatterlist *, int, > enum dma_data_direction); > extern int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs); > + unsigned long attrs); > > #endif /* __KERNEL__ */ > #endif > diff --git a/arch/arm/include/asm/xen/page-coherent.h b/arch/arm/include/asm/xen/page-coherent.h > index 9408a994cc91..95ce6ac3a971 100644 > --- a/arch/arm/include/asm/xen/page-coherent.h > +++ b/arch/arm/include/asm/xen/page-coherent.h > @@ -2,15 +2,14 @@ > #define _ASM_ARM_XEN_PAGE_COHERENT_H > > #include > -#include > #include > > void __xen_dma_map_page(struct device *hwdev, struct page *page, > dma_addr_t dev_addr, unsigned long offset, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, unsigned long attrs); > void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void __xen_dma_sync_single_for_cpu(struct device *hwdev, > dma_addr_t handle, size_t size, enum dma_data_direction dir); > > @@ -18,22 +17,20 @@ void __xen_dma_sync_single_for_device(struct device *hwdev, > dma_addr_t handle, size_t size, enum dma_data_direction dir); > > static inline void *xen_alloc_coherent_pages(struct device *hwdev, size_t size, > - dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs) > { > return __generic_dma_ops(hwdev)->alloc(hwdev, size, dma_handle, flags, attrs); > } > > static inline void xen_free_coherent_pages(struct device *hwdev, size_t size, > - void *cpu_addr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + void *cpu_addr, dma_addr_t dma_handle, unsigned long attrs) > { > __generic_dma_ops(hwdev)->free(hwdev, size, cpu_addr, dma_handle, attrs); > } > > static inline void xen_dma_map_page(struct device *hwdev, struct page *page, > dma_addr_t dev_addr, unsigned long offset, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > unsigned long page_pfn = page_to_xen_pfn(page); > unsigned long dev_pfn = XEN_PFN_DOWN(dev_addr); > @@ -58,8 +55,7 @@ static inline void xen_dma_map_page(struct device *hwdev, struct page *page, > } > > static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > unsigned long pfn = PFN_DOWN(handle); > /* > diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c > index ff7ed5697d3e..fe31fbfd926d 100644 > --- a/arch/arm/mm/dma-mapping.c > +++ b/arch/arm/mm/dma-mapping.c > @@ -124,7 +124,7 @@ static void __dma_page_dev_to_cpu(struct page *, unsigned long, > */ > static dma_addr_t arm_dma_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_cpu_to_dev(page, offset, size, dir); > @@ -133,7 +133,7 @@ static dma_addr_t arm_dma_map_page(struct device *dev, struct page *page, > > static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return pfn_to_dma(dev, page_to_pfn(page)) + offset; > } > @@ -153,8 +153,7 @@ static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *pag > * whatever the device wrote there. > */ > static void arm_dma_unmap_page(struct device *dev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)), > @@ -194,12 +193,12 @@ struct dma_map_ops arm_dma_ops = { > EXPORT_SYMBOL(arm_dma_ops); > > static void *arm_coherent_dma_alloc(struct device *dev, size_t size, > - dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs); > + dma_addr_t *handle, gfp_t gfp, unsigned long attrs); > static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs); > + dma_addr_t handle, unsigned long attrs); > static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs); > + unsigned long attrs); > > struct dma_map_ops arm_coherent_dma_ops = { > .alloc = arm_coherent_dma_alloc, > @@ -621,7 +620,7 @@ static void __free_from_contiguous(struct device *dev, struct page *page, > dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT); > } > > -static inline pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot) > +static inline pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot) > { > prot = dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs) ? > pgprot_writecombine(prot) : > @@ -732,7 +731,7 @@ static struct arm_dma_allocator remap_allocator = { > > static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > gfp_t gfp, pgprot_t prot, bool is_coherent, > - struct dma_attrs *attrs, const void *caller) > + unsigned long attrs, const void *caller) > { > u64 mask = get_coherent_dma_mask(dev); > struct page *page = NULL; > @@ -814,7 +813,7 @@ static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > * virtual and bus address for that space. > */ > void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > - gfp_t gfp, struct dma_attrs *attrs) > + gfp_t gfp, unsigned long attrs) > { > pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL); > > @@ -823,7 +822,7 @@ void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, > } > > static void *arm_coherent_dma_alloc(struct device *dev, size_t size, > - dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs) > + dma_addr_t *handle, gfp_t gfp, unsigned long attrs) > { > return __dma_alloc(dev, size, handle, gfp, PAGE_KERNEL, true, > attrs, __builtin_return_address(0)); > @@ -831,7 +830,7 @@ static void *arm_coherent_dma_alloc(struct device *dev, size_t size, > > static int __arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > int ret = -ENXIO; > #ifdef CONFIG_MMU > @@ -859,14 +858,14 @@ static int __arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > */ > static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return __arm_dma_mmap(dev, vma, cpu_addr, dma_addr, size, attrs); > } > > int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > #ifdef CONFIG_MMU > vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot); > @@ -878,7 +877,7 @@ int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma, > * Free a buffer as defined by the above mapping. > */ > static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs, > + dma_addr_t handle, unsigned long attrs, > bool is_coherent) > { > struct page *page = pfn_to_page(dma_to_pfn(dev, handle)); > @@ -900,20 +899,20 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > } > > void arm_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, unsigned long attrs) > { > __arm_dma_free(dev, size, cpu_addr, handle, attrs, false); > } > > static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, unsigned long attrs) > { > __arm_dma_free(dev, size, cpu_addr, handle, attrs, true); > } > > int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t handle, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct page *page = pfn_to_page(dma_to_pfn(dev, handle)); > int ret; > @@ -1046,7 +1045,7 @@ static void __dma_page_dev_to_cpu(struct page *page, unsigned long off, > * here. > */ > int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > struct scatterlist *s; > @@ -1080,7 +1079,7 @@ int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, > * rules concerning calls here are the same as for dma_unmap_single(). > */ > void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > struct scatterlist *s; > @@ -1253,7 +1252,7 @@ static inline void __free_iova(struct dma_iommu_mapping *mapping, > static const int iommu_order_array[] = { 9, 8, 4, 0 }; > > static struct page **__iommu_alloc_buffer(struct device *dev, size_t size, > - gfp_t gfp, struct dma_attrs *attrs) > + gfp_t gfp, unsigned long attrs) > { > struct page **pages; > int count = size >> PAGE_SHIFT; > @@ -1342,7 +1341,7 @@ error: > } > > static int __iommu_free_buffer(struct device *dev, struct page **pages, > - size_t size, struct dma_attrs *attrs) > + size_t size, unsigned long attrs) > { > int count = size >> PAGE_SHIFT; > int i; > @@ -1439,7 +1438,7 @@ static struct page **__atomic_get_pages(void *addr) > return (struct page **)page; > } > > -static struct page **__iommu_get_pages(void *cpu_addr, struct dma_attrs *attrs) > +static struct page **__iommu_get_pages(void *cpu_addr, unsigned long attrs) > { > struct vm_struct *area; > > @@ -1484,7 +1483,7 @@ static void __iommu_free_atomic(struct device *dev, void *cpu_addr, > } > > static void *arm_iommu_alloc_attrs(struct device *dev, size_t size, > - dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs) > + dma_addr_t *handle, gfp_t gfp, unsigned long attrs) > { > pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL); > struct page **pages; > @@ -1532,7 +1531,7 @@ err_buffer: > > static int arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > unsigned long uaddr = vma->vm_start; > unsigned long usize = vma->vm_end - vma->vm_start; > @@ -1568,7 +1567,7 @@ static int arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > * Must not be called with IRQs disabled. > */ > void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, unsigned long attrs) > { > struct page **pages; > size = PAGE_ALIGN(size); > @@ -1595,7 +1594,7 @@ void arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > > static int arm_iommu_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t dma_addr, > - size_t size, struct dma_attrs *attrs) > + size_t size, unsigned long attrs) > { > unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; > struct page **pages = __iommu_get_pages(cpu_addr, attrs); > @@ -1633,7 +1632,7 @@ static int __dma_direction_to_prot(enum dma_data_direction dir) > */ > static int __map_sg_chunk(struct device *dev, struct scatterlist *sg, > size_t size, dma_addr_t *handle, > - enum dma_data_direction dir, struct dma_attrs *attrs, > + enum dma_data_direction dir, unsigned long attrs, > bool is_coherent) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > @@ -1676,7 +1675,7 @@ fail: > } > > static int __iommu_map_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs, > + enum dma_data_direction dir, unsigned long attrs, > bool is_coherent) > { > struct scatterlist *s = sg, *dma = sg, *start = sg; > @@ -1734,7 +1733,7 @@ bad_mapping: > * obtained via sg_dma_{address,length}. > */ > int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nents, enum dma_data_direction dir, unsigned long attrs) > { > return __iommu_map_sg(dev, sg, nents, dir, attrs, true); > } > @@ -1752,14 +1751,14 @@ int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg, > * sg_dma_{address,length}. > */ > int arm_iommu_map_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nents, enum dma_data_direction dir, unsigned long attrs) > { > return __iommu_map_sg(dev, sg, nents, dir, attrs, false); > } > > static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs, > - bool is_coherent) > + int nents, enum dma_data_direction dir, > + unsigned long attrs, bool is_coherent) > { > struct scatterlist *s; > int i; > @@ -1786,7 +1785,8 @@ static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > * rules concerning calls here are the same as for dma_unmap_single(). > */ > void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > - int nents, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nents, enum dma_data_direction dir, > + unsigned long attrs) > { > __iommu_unmap_sg(dev, sg, nents, dir, attrs, true); > } > @@ -1802,7 +1802,8 @@ void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, > * rules concerning calls here are the same as for dma_unmap_single(). > */ > void arm_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, > + unsigned long attrs) > { > __iommu_unmap_sg(dev, sg, nents, dir, attrs, false); > } > @@ -1855,7 +1856,7 @@ void arm_iommu_sync_sg_for_device(struct device *dev, struct scatterlist *sg, > */ > static dma_addr_t arm_coherent_iommu_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > dma_addr_t dma_addr; > @@ -1889,7 +1890,7 @@ fail: > */ > static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_cpu_to_dev(page, offset, size, dir); > @@ -1907,8 +1908,7 @@ static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page, > * Coherent IOMMU aware version of arm_dma_unmap_page() > */ > static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > dma_addr_t iova = handle & PAGE_MASK; > @@ -1932,8 +1932,7 @@ static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle, > * IOMMU aware version of arm_dma_unmap_page() > */ > static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle, > - size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + size_t size, enum dma_data_direction dir, unsigned long attrs) > { > struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev); > dma_addr_t iova = handle & PAGE_MASK; > @@ -1944,6 +1943,7 @@ static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle, > if (!iova) > return; > > + // FIXME: replace get with simple check > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __dma_page_dev_to_cpu(page, offset, size, dir); > > diff --git a/arch/arm/xen/mm.c b/arch/arm/xen/mm.c > index c5f9a9e3d1f3..fc67ed236a10 100644 > --- a/arch/arm/xen/mm.c > +++ b/arch/arm/xen/mm.c > @@ -98,7 +98,7 @@ static void __xen_dma_page_cpu_to_dev(struct device *hwdev, dma_addr_t handle, > > void __xen_dma_map_page(struct device *hwdev, struct page *page, > dma_addr_t dev_addr, unsigned long offset, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > if (is_device_dma_coherent(hwdev)) > return; > @@ -110,7 +110,7 @@ void __xen_dma_map_page(struct device *hwdev, struct page *page, > > void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > > { > if (is_device_dma_coherent(hwdev)) > diff --git a/arch/arm64/mm/dma-mapping.c b/arch/arm64/mm/dma-mapping.c > index c566ec83719f..a7686028dfeb 100644 > --- a/arch/arm64/mm/dma-mapping.c > +++ b/arch/arm64/mm/dma-mapping.c > @@ -29,7 +29,7 @@ > > #include > > -static pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot, > +static pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot, > bool coherent) > { > if (!coherent || dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs)) > @@ -88,7 +88,7 @@ static int __free_from_pool(void *start, size_t size) > > static void *__dma_alloc_coherent(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (dev == NULL) { > WARN_ONCE(1, "Use an actual device structure for DMA allocation\n"); > @@ -118,7 +118,7 @@ static void *__dma_alloc_coherent(struct device *dev, size_t size, > > static void __dma_free_coherent(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool freed; > phys_addr_t paddr = dma_to_phys(dev, dma_handle); > @@ -137,7 +137,7 @@ static void __dma_free_coherent(struct device *dev, size_t size, > > static void *__dma_alloc(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct page *page; > void *ptr, *coherent_ptr; > @@ -185,7 +185,7 @@ no_mem: > > static void __dma_free(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > void *swiotlb_addr = phys_to_virt(dma_to_phys(dev, dma_handle)); > > @@ -202,7 +202,7 @@ static void __dma_free(struct device *dev, size_t size, > static dma_addr_t __swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > dma_addr_t dev_addr; > > @@ -216,7 +216,7 @@ static dma_addr_t __swiotlb_map_page(struct device *dev, struct page *page, > > static void __swiotlb_unmap_page(struct device *dev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!is_device_dma_coherent(dev)) > __dma_unmap_area(phys_to_virt(dma_to_phys(dev, dev_addr)), size, dir); > @@ -225,7 +225,7 @@ static void __swiotlb_unmap_page(struct device *dev, dma_addr_t dev_addr, > > static int __swiotlb_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i, ret; > @@ -242,7 +242,7 @@ static int __swiotlb_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > static void __swiotlb_unmap_sg_attrs(struct device *dev, > struct scatterlist *sgl, int nelems, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -303,7 +303,7 @@ static void __swiotlb_sync_sg_for_device(struct device *dev, > static int __swiotlb_mmap(struct device *dev, > struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > int ret = -ENXIO; > unsigned long nr_vma_pages = (vma->vm_end - vma->vm_start) >> > @@ -330,7 +330,7 @@ static int __swiotlb_mmap(struct device *dev, > > static int __swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t handle, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > int ret = sg_alloc_table(sgt, 1, GFP_KERNEL); > > @@ -425,21 +425,21 @@ out: > > static void *__dummy_alloc(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return NULL; > } > > static void __dummy_free(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > } > > static int __dummy_mmap(struct device *dev, > struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return -ENXIO; > } > @@ -447,20 +447,20 @@ static int __dummy_mmap(struct device *dev, > static dma_addr_t __dummy_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return DMA_ERROR_CODE; > } > > static void __dummy_unmap_page(struct device *dev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > } > > static int __dummy_map_sg(struct device *dev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return 0; > } > @@ -468,7 +468,7 @@ static int __dummy_map_sg(struct device *dev, struct scatterlist *sgl, > static void __dummy_unmap_sg(struct device *dev, > struct scatterlist *sgl, int nelems, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > } > > @@ -540,7 +540,7 @@ static void flush_page(struct device *dev, const void *virt, phys_addr_t phys) > > static void *__iommu_alloc_attrs(struct device *dev, size_t size, > dma_addr_t *handle, gfp_t gfp, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool coherent = is_device_dma_coherent(dev); > int ioprot = dma_direction_to_prot(DMA_BIDIRECTIONAL, coherent); > @@ -600,7 +600,8 @@ static void *__iommu_alloc_attrs(struct device *dev, size_t size, > } > > static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > - dma_addr_t handle, struct dma_attrs *attrs) > + dma_addr_t handle, > + unsigned long attrs) > { > size_t iosize = size; > > @@ -616,7 +617,7 @@ static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > * Hence how dodgy the below logic looks... > */ > if (__in_atomic_pool(cpu_addr, size)) { > - iommu_dma_unmap_page(dev, handle, iosize, 0, NULL); > + iommu_dma_unmap_page(dev, handle, iosize, 0, 0); > __free_from_pool(cpu_addr, size); > } else if (is_vmalloc_addr(cpu_addr)){ > struct vm_struct *area = find_vm_area(cpu_addr); > @@ -626,14 +627,14 @@ static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr, > iommu_dma_free(dev, area->pages, iosize, &handle); > dma_common_free_remap(cpu_addr, size, VM_USERMAP); > } else { > - iommu_dma_unmap_page(dev, handle, iosize, 0, NULL); > + iommu_dma_unmap_page(dev, handle, iosize, 0, 0); > __free_pages(virt_to_page(cpu_addr), get_order(size)); > } > } > > static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct vm_struct *area; > int ret; > @@ -653,7 +654,7 @@ static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma, > > static int __iommu_get_sgtable(struct device *dev, struct sg_table *sgt, > void *cpu_addr, dma_addr_t dma_addr, > - size_t size, struct dma_attrs *attrs) > + size_t size, unsigned long attrs) > { > unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; > struct vm_struct *area = find_vm_area(cpu_addr); > @@ -694,7 +695,7 @@ static void __iommu_sync_single_for_device(struct device *dev, > static dma_addr_t __iommu_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool coherent = is_device_dma_coherent(dev); > int prot = dma_direction_to_prot(dir, coherent); > @@ -709,7 +710,7 @@ static dma_addr_t __iommu_map_page(struct device *dev, struct page *page, > > static void __iommu_unmap_page(struct device *dev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __iommu_sync_single_for_cpu(dev, dev_addr, size, dir); > @@ -747,7 +748,7 @@ static void __iommu_sync_sg_for_device(struct device *dev, > > static int __iommu_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > bool coherent = is_device_dma_coherent(dev); > > @@ -761,7 +762,7 @@ static int __iommu_map_sg_attrs(struct device *dev, struct scatterlist *sgl, > static void __iommu_unmap_sg_attrs(struct device *dev, > struct scatterlist *sgl, int nelems, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs)) > __iommu_sync_sg_for_cpu(dev, sgl, nelems, dir); > diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c > index 67dcd6831291..dd091175fc2d 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c > @@ -52,7 +52,7 @@ static int exynos_drm_fb_mmap(struct fb_info *info, > > ret = dma_mmap_attrs(to_dma_dev(helper->dev), vma, exynos_gem->cookie, > exynos_gem->dma_addr, exynos_gem->size, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (ret < 0) { > DRM_ERROR("failed to mmap.\n"); > return ret; > diff --git a/drivers/gpu/drm/exynos/exynos_drm_g2d.c b/drivers/gpu/drm/exynos/exynos_drm_g2d.c > index 493552368295..f65e6b7ef93b 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_g2d.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_g2d.c > @@ -17,7 +17,6 @@ > #include > #include > #include > -#include > #include > > #include > diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.c b/drivers/gpu/drm/exynos/exynos_drm_gem.c > index cdf9f1af4347..f2ae72ba7d5a 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_gem.c > +++ b/drivers/gpu/drm/exynos/exynos_drm_gem.c > @@ -24,7 +24,7 @@ > static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > { > struct drm_device *dev = exynos_gem->base.dev; > - enum dma_attr attr; > + unsigned long attr; > unsigned int nr_pages; > struct sg_table sgt; > int ret = -ENOMEM; > @@ -34,7 +34,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > return 0; > } > > - init_dma_attrs(&exynos_gem->dma_attrs); > + exynos_gem->dma_attrs = 0; > > /* > * if EXYNOS_BO_CONTIG, fully physically contiguous memory > @@ -42,7 +42,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > * as possible. > */ > if (!(exynos_gem->flags & EXYNOS_BO_NONCONTIG)) > - dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs |= DMA_ATTR_FORCE_CONTIGUOUS; > > /* > * if EXYNOS_BO_WC or EXYNOS_BO_NONCACHABLE, writecombine mapping > @@ -54,8 +54,8 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > else > attr = DMA_ATTR_NON_CONSISTENT; > > - dma_set_attr(attr, &exynos_gem->dma_attrs); > - dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs |= attr; > + exynos_gem->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING; > > nr_pages = exynos_gem->size >> PAGE_SHIFT; > > @@ -67,7 +67,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > > exynos_gem->cookie = dma_alloc_attrs(to_dma_dev(dev), exynos_gem->size, > &exynos_gem->dma_addr, GFP_KERNEL, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (!exynos_gem->cookie) { > DRM_ERROR("failed to allocate buffer.\n"); > goto err_free; > @@ -75,7 +75,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem) > > ret = dma_get_sgtable_attrs(to_dma_dev(dev), &sgt, exynos_gem->cookie, > exynos_gem->dma_addr, exynos_gem->size, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (ret < 0) { > DRM_ERROR("failed to get sgtable.\n"); > goto err_dma_free; > @@ -99,7 +99,7 @@ err_sgt_free: > sg_free_table(&sgt); > err_dma_free: > dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie, > - exynos_gem->dma_addr, &exynos_gem->dma_attrs); > + exynos_gem->dma_addr, exynos_gem->dma_attrs); > err_free: > drm_free_large(exynos_gem->pages); > > @@ -120,7 +120,7 @@ static void exynos_drm_free_buf(struct exynos_drm_gem *exynos_gem) > > dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie, > (dma_addr_t)exynos_gem->dma_addr, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > > drm_free_large(exynos_gem->pages); > } > @@ -346,7 +346,7 @@ static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem *exynos_gem, > > ret = dma_mmap_attrs(to_dma_dev(drm_dev), vma, exynos_gem->cookie, > exynos_gem->dma_addr, exynos_gem->size, > - &exynos_gem->dma_attrs); > + exynos_gem->dma_attrs); > if (ret < 0) { > DRM_ERROR("failed to mmap.\n"); > return ret; > diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.h b/drivers/gpu/drm/exynos/exynos_drm_gem.h > index 78100742281d..df7c543d6558 100644 > --- a/drivers/gpu/drm/exynos/exynos_drm_gem.h > +++ b/drivers/gpu/drm/exynos/exynos_drm_gem.h > @@ -50,7 +50,7 @@ struct exynos_drm_gem { > void *cookie; > void __iomem *kvaddr; > dma_addr_t dma_addr; > - struct dma_attrs dma_attrs; > + unsigned long dma_attrs; > struct page **pages; > struct sg_table *sgt; > }; > diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c > index ea5a9ebf0f78..6c1bda504fb1 100644 > --- a/drivers/iommu/dma-iommu.c > +++ b/drivers/iommu/dma-iommu.c > @@ -286,7 +286,7 @@ void iommu_dma_free(struct device *dev, struct page **pages, size_t size, > * or NULL on failure. > */ > struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp, > - struct dma_attrs *attrs, int prot, dma_addr_t *handle, > + unsigned long attrs, int prot, dma_addr_t *handle, > void (*flush_page)(struct device *, const void *, phys_addr_t)) > { > struct iommu_domain *domain = iommu_get_domain_for_dev(dev); > @@ -400,7 +400,7 @@ dma_addr_t iommu_dma_map_page(struct device *dev, struct page *page, > } > > void iommu_dma_unmap_page(struct device *dev, dma_addr_t handle, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > __iommu_dma_unmap(iommu_get_domain_for_dev(dev), handle); > } > @@ -560,7 +560,7 @@ out_restore_sg: > } > > void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > /* > * The scatterlist segments are mapped into a single > diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c > index 7399782c0998..87e6035c9e81 100644 > --- a/drivers/xen/swiotlb-xen.c > +++ b/drivers/xen/swiotlb-xen.c > @@ -294,7 +294,7 @@ error: > void * > xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > void *ret; > int order = get_order(size); > @@ -346,7 +346,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent); > > void > xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr, > - dma_addr_t dev_addr, struct dma_attrs *attrs) > + dma_addr_t dev_addr, unsigned long attrs) > { > int order = get_order(size); > phys_addr_t phys; > @@ -378,7 +378,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent); > dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > phys_addr_t map, phys = page_to_phys(page) + offset; > dma_addr_t dev_addr = xen_phys_to_bus(phys); > @@ -434,7 +434,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_page); > */ > static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > phys_addr_t paddr = xen_bus_to_phys(dev_addr); > > @@ -462,7 +462,7 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr, > > void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > xen_unmap_single(hwdev, dev_addr, size, dir, attrs); > } > @@ -538,7 +538,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device); > int > xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -599,7 +599,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs); > void > xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > diff --git a/include/linux/dma-attrs.h b/include/linux/dma-attrs.h > deleted file mode 100644 > index 5246239a4953..000000000000 > --- a/include/linux/dma-attrs.h > +++ /dev/null > @@ -1,71 +0,0 @@ > -#ifndef _DMA_ATTR_H > -#define _DMA_ATTR_H > - > -#include > -#include > -#include > - > -/** > - * an enum dma_attr represents an attribute associated with a DMA > - * mapping. The semantics of each attribute should be defined in > - * Documentation/DMA-attributes.txt. > - */ > -enum dma_attr { > - DMA_ATTR_WRITE_BARRIER, > - DMA_ATTR_WEAK_ORDERING, > - DMA_ATTR_WRITE_COMBINE, > - DMA_ATTR_NON_CONSISTENT, > - DMA_ATTR_NO_KERNEL_MAPPING, > - DMA_ATTR_SKIP_CPU_SYNC, > - DMA_ATTR_FORCE_CONTIGUOUS, > - DMA_ATTR_ALLOC_SINGLE_PAGES, > - DMA_ATTR_MAX, > -}; > - > -#define __DMA_ATTRS_LONGS BITS_TO_LONGS(DMA_ATTR_MAX) > - > -/** > - * struct dma_attrs - an opaque container for DMA attributes > - * @flags - bitmask representing a collection of enum dma_attr > - */ > -struct dma_attrs { > - unsigned long flags[__DMA_ATTRS_LONGS]; > -}; > - > -#define DEFINE_DMA_ATTRS(x) \ > - struct dma_attrs x = { \ > - .flags = { [0 ... __DMA_ATTRS_LONGS-1] = 0 }, \ > - } > - > -static inline void init_dma_attrs(struct dma_attrs *attrs) > -{ > - bitmap_zero(attrs->flags, __DMA_ATTRS_LONGS); > -} > - > -/** > - * dma_set_attr - set a specific attribute > - * @attr: attribute to set > - * @attrs: struct dma_attrs (may be NULL) > - */ > -static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs) > -{ > - if (attrs == NULL) > - return; > - BUG_ON(attr >= DMA_ATTR_MAX); > - __set_bit(attr, attrs->flags); > -} > - > -/** > - * dma_get_attr - check for a specific attribute > - * @attr: attribute to set > - * @attrs: struct dma_attrs (may be NULL) > - */ > -static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs) > -{ > - if (attrs == NULL) > - return 0; > - BUG_ON(attr >= DMA_ATTR_MAX); > - return test_bit(attr, attrs->flags); > -} > - > -#endif /* _DMA_ATTR_H */ > diff --git a/include/linux/dma-iommu.h b/include/linux/dma-iommu.h > index 8443bbb5c071..81c5c8d167ad 100644 > --- a/include/linux/dma-iommu.h > +++ b/include/linux/dma-iommu.h > @@ -39,7 +39,7 @@ int dma_direction_to_prot(enum dma_data_direction dir, bool coherent); > * the arch code to take care of attributes and cache maintenance > */ > struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp, > - struct dma_attrs *attrs, int prot, dma_addr_t *handle, > + unsigned long attrs, int prot, dma_addr_t *handle, > void (*flush_page)(struct device *, const void *, phys_addr_t)); > void iommu_dma_free(struct device *dev, struct page **pages, size_t size, > dma_addr_t *handle); > @@ -56,9 +56,9 @@ int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg, > * directly as DMA mapping callbacks for simplicity > */ > void iommu_dma_unmap_page(struct device *dev, dma_addr_t handle, size_t size, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, unsigned long attrs); > void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, unsigned long attrs); > int iommu_dma_supported(struct device *dev, u64 mask); > int iommu_dma_mapping_error(struct device *dev, dma_addr_t dma_addr); > > diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h > index 71c1b215ef66..19e581d5f8b4 100644 > --- a/include/linux/dma-mapping.h > +++ b/include/linux/dma-mapping.h > @@ -5,13 +5,25 @@ > #include > #include > #include > -#include > #include > #include > #include > #include > #include > > +/** > + * List of possible attributes associated with a DMA mapping. The semantics > + * of each attribute should be defined in Documentation/DMA-attributes.txt. > + */ > +#define DMA_ATTR_WRITE_BARRIER BIT(1) > +#define DMA_ATTR_WEAK_ORDERING BIT(2) > +#define DMA_ATTR_WRITE_COMBINE BIT(3) > +#define DMA_ATTR_NON_CONSISTENT BIT(4) > +#define DMA_ATTR_NO_KERNEL_MAPPING BIT(5) > +#define DMA_ATTR_SKIP_CPU_SYNC BIT(6) > +#define DMA_ATTR_FORCE_CONTIGUOUS BIT(7) > +#define DMA_ATTR_ALLOC_SINGLE_PAGES BIT(8) > + > /* > * A dma_addr_t can hold any valid DMA or bus address for the platform. > * It can be given to a device to use as a DMA source or target. A CPU cannot > @@ -21,34 +33,35 @@ > struct dma_map_ops { > void* (*alloc)(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t gfp, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*free)(struct device *dev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs); > + unsigned long attrs); > int (*mmap)(struct device *, struct vm_area_struct *, > - void *, dma_addr_t, size_t, struct dma_attrs *attrs); > + void *, dma_addr_t, size_t, > + unsigned long attrs); > > int (*get_sgtable)(struct device *dev, struct sg_table *sgt, void *, > - dma_addr_t, size_t, struct dma_attrs *attrs); > + dma_addr_t, size_t, unsigned long attrs); > > dma_addr_t (*map_page)(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*unmap_page)(struct device *dev, dma_addr_t dma_handle, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > /* > * map_sg returns 0 on error and a value > 0 on success. > * It should never return a value < 0. > */ > int (*map_sg)(struct device *dev, struct scatterlist *sg, > int nents, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*unmap_sg)(struct device *dev, > struct scatterlist *sg, int nents, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > void (*sync_single_for_cpu)(struct device *dev, > dma_addr_t dma_handle, size_t size, > enum dma_data_direction dir); > @@ -88,6 +101,16 @@ static inline int is_device_dma_capable(struct device *dev) > return dev->dma_mask != NULL && *dev->dma_mask != DMA_MASK_NONE; > } > > +/** > + * dma_get_attr - check for a specific attribute > + * @attr: attribute to look for > + * @attrs: attributes to check within > + */ > +static inline bool dma_get_attr(unsigned long attr, unsigned long attrs) > +{ > + return !!(attr & attrs); > +} > + > #ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT > /* > * These three functions are only for dma allocator. > @@ -123,7 +146,7 @@ static inline struct dma_map_ops *get_dma_ops(struct device *dev) > static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr, > size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > dma_addr_t addr; > @@ -142,7 +165,7 @@ static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr, > static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, > size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > > @@ -158,7 +181,7 @@ static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr, > */ > static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, > int nents, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > int i, ents; > @@ -176,7 +199,7 @@ static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, > > static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg, > int nents, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > > @@ -195,7 +218,7 @@ static inline dma_addr_t dma_map_page(struct device *dev, struct page *page, > > kmemcheck_mark_initialized(page_address(page) + offset, size); > BUG_ON(!valid_dma_direction(dir)); > - addr = ops->map_page(dev, page, offset, size, dir, NULL); > + addr = ops->map_page(dev, page, offset, size, dir, 0); > debug_dma_map_page(dev, page, offset, size, dir, addr, false); > > return addr; > @@ -208,7 +231,7 @@ static inline void dma_unmap_page(struct device *dev, dma_addr_t addr, > > BUG_ON(!valid_dma_direction(dir)); > if (ops->unmap_page) > - ops->unmap_page(dev, addr, size, dir, NULL); > + ops->unmap_page(dev, addr, size, dir, 0); > debug_dma_unmap_page(dev, addr, size, dir, false); > } > > @@ -289,10 +312,10 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, > > } > > -#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL) > -#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL) > -#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL) > -#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL) > +#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0) > +#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0) > +#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0) > +#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0) > > extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma, > void *cpu_addr, dma_addr_t dma_addr, size_t size); > @@ -321,7 +344,7 @@ void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags); > */ > static inline int > dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, > - dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs) > + dma_addr_t dma_addr, size_t size, unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > BUG_ON(!ops); > @@ -330,7 +353,7 @@ dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr, > return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size); > } > > -#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL) > +#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0) > > int > dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, > @@ -338,7 +361,8 @@ dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, > > static inline int > dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, > - dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs) > + dma_addr_t dma_addr, size_t size, > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > BUG_ON(!ops); > @@ -348,7 +372,7 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, > return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size); > } > > -#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL) > +#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0) > > #ifndef arch_dma_alloc_attrs > #define arch_dma_alloc_attrs(dev, flag) (true) > @@ -356,7 +380,7 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, > > static inline void *dma_alloc_attrs(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flag, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > void *cpu_addr; > @@ -378,7 +402,7 @@ static inline void *dma_alloc_attrs(struct device *dev, size_t size, > > static inline void dma_free_attrs(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_handle, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > struct dma_map_ops *ops = get_dma_ops(dev); > > @@ -398,31 +422,27 @@ static inline void dma_free_attrs(struct device *dev, size_t size, > static inline void *dma_alloc_coherent(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t flag) > { > - return dma_alloc_attrs(dev, size, dma_handle, flag, NULL); > + return dma_alloc_attrs(dev, size, dma_handle, flag, 0); > } > > static inline void dma_free_coherent(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_handle) > { > - return dma_free_attrs(dev, size, cpu_addr, dma_handle, NULL); > + return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0); > } > > static inline void *dma_alloc_noncoherent(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t gfp) > { > - DEFINE_DMA_ATTRS(attrs); > - > - dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs); > - return dma_alloc_attrs(dev, size, dma_handle, gfp, &attrs); > + return dma_alloc_attrs(dev, size, dma_handle, gfp, > + DMA_ATTR_NON_CONSISTENT); > } > > static inline void dma_free_noncoherent(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_handle) > { > - DEFINE_DMA_ATTRS(attrs); > - > - dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs); > - dma_free_attrs(dev, size, cpu_addr, dma_handle, &attrs); > + dma_free_attrs(dev, size, cpu_addr, dma_handle, > + DMA_ATTR_NON_CONSISTENT); > } > > static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr) > @@ -646,9 +666,8 @@ static inline void dmam_release_declared_memory(struct device *dev) > static inline void *dma_alloc_wc(struct device *dev, size_t size, > dma_addr_t *dma_addr, gfp_t gfp) > { > - DEFINE_DMA_ATTRS(attrs); > - dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); > - return dma_alloc_attrs(dev, size, dma_addr, gfp, &attrs); > + return dma_alloc_attrs(dev, size, dma_addr, gfp, > + DMA_ATTR_WRITE_COMBINE); > } > #ifndef dma_alloc_writecombine > #define dma_alloc_writecombine dma_alloc_wc > @@ -657,9 +676,8 @@ static inline void *dma_alloc_wc(struct device *dev, size_t size, > static inline void dma_free_wc(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_addr) > { > - DEFINE_DMA_ATTRS(attrs); > - dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); > - return dma_free_attrs(dev, size, cpu_addr, dma_addr, &attrs); > + return dma_free_attrs(dev, size, cpu_addr, dma_addr, > + DMA_ATTR_WRITE_COMBINE); > } > #ifndef dma_free_writecombine > #define dma_free_writecombine dma_free_wc > @@ -670,9 +688,8 @@ static inline int dma_mmap_wc(struct device *dev, > void *cpu_addr, dma_addr_t dma_addr, > size_t size) > { > - DEFINE_DMA_ATTRS(attrs); > - dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs); > - return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs); > + return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, > + DMA_ATTR_WRITE_COMBINE); > } > #ifndef dma_mmap_writecombine > #define dma_mmap_writecombine dma_mmap_wc > diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h > index 017fced60242..5f81f8a187f2 100644 > --- a/include/linux/swiotlb.h > +++ b/include/linux/swiotlb.h > @@ -6,7 +6,6 @@ > #include > > struct device; > -struct dma_attrs; > struct page; > struct scatterlist; > > @@ -68,10 +67,10 @@ swiotlb_free_coherent(struct device *hwdev, size_t size, > extern dma_addr_t swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > extern void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern int > swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents, > @@ -83,12 +82,13 @@ swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents, > > extern int > swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, > - enum dma_data_direction dir, struct dma_attrs *attrs); > + enum dma_data_direction dir, > + unsigned long attrs); > > extern void > swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, > diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h > index 8b2eb93ae8ba..7c35e279d1e3 100644 > --- a/include/xen/swiotlb-xen.h > +++ b/include/xen/swiotlb-xen.h > @@ -9,30 +9,30 @@ extern int xen_swiotlb_init(int verbose, bool early); > extern void > *xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size, > dma_addr_t *dma_handle, gfp_t flags, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > xen_swiotlb_free_coherent(struct device *hwdev, size_t size, > void *vaddr, dma_addr_t dma_handle, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > extern int > xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > int nelems, enum dma_data_direction dir, > - struct dma_attrs *attrs); > + unsigned long attrs); > > extern void > xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr, > diff --git a/lib/dma-noop.c b/lib/dma-noop.c > index 72145646857e..3d766e78fbe2 100644 > --- a/lib/dma-noop.c > +++ b/lib/dma-noop.c > @@ -10,7 +10,7 @@ > > static void *dma_noop_alloc(struct device *dev, size_t size, > dma_addr_t *dma_handle, gfp_t gfp, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > void *ret; > > @@ -22,7 +22,7 @@ static void *dma_noop_alloc(struct device *dev, size_t size, > > static void dma_noop_free(struct device *dev, size_t size, > void *cpu_addr, dma_addr_t dma_addr, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > free_pages((unsigned long)cpu_addr, get_order(size)); > } > @@ -30,13 +30,14 @@ static void dma_noop_free(struct device *dev, size_t size, > static dma_addr_t dma_noop_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > return page_to_phys(page) + offset; > } > > static int dma_noop_map_sg(struct device *dev, struct scatterlist *sgl, int nents, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, > + unsigned long attrs) > { > int i; > struct scatterlist *sg; > diff --git a/lib/swiotlb.c b/lib/swiotlb.c > index 76f29ecba8f4..22e13a0e19d7 100644 > --- a/lib/swiotlb.c > +++ b/lib/swiotlb.c > @@ -738,7 +738,7 @@ swiotlb_full(struct device *dev, size_t size, enum dma_data_direction dir, > dma_addr_t swiotlb_map_page(struct device *dev, struct page *page, > unsigned long offset, size_t size, > enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > phys_addr_t map, phys = page_to_phys(page) + offset; > dma_addr_t dev_addr = phys_to_dma(dev, phys); > @@ -807,7 +807,7 @@ static void unmap_single(struct device *hwdev, dma_addr_t dev_addr, > > void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr, > size_t size, enum dma_data_direction dir, > - struct dma_attrs *attrs) > + unsigned long attrs) > { > unmap_single(hwdev, dev_addr, size, dir); > } > @@ -877,7 +877,7 @@ EXPORT_SYMBOL(swiotlb_sync_single_for_device); > */ > int > swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems, > - enum dma_data_direction dir, struct dma_attrs *attrs) > + enum dma_data_direction dir, unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -914,7 +914,7 @@ int > swiotlb_map_sg(struct device *hwdev, struct scatterlist *sgl, int nelems, > enum dma_data_direction dir) > { > - return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, NULL); > + return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, 0); > } > EXPORT_SYMBOL(swiotlb_map_sg); > > @@ -924,7 +924,8 @@ EXPORT_SYMBOL(swiotlb_map_sg); > */ > void > swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl, > - int nelems, enum dma_data_direction dir, struct dma_attrs *attrs) > + int nelems, enum dma_data_direction dir, > + unsigned long attrs) > { > struct scatterlist *sg; > int i; > @@ -941,7 +942,7 @@ void > swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems, > enum dma_data_direction dir) > { > - return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, NULL); > + return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, 0); > } > EXPORT_SYMBOL(swiotlb_unmap_sg); > > -- > 1.9.1 > > _______________________________________________ > iommu mailing list > iommu@lists.linux-foundation.org > https://lists.linuxfoundation.org/mailman/listinfo/iommu