From mboxrd@z Thu Jan 1 00:00:00 1970 From: leizhen Subject: Re: [PATCH 2/3] iommu/arm-smmu: Add initial driver support for ARM SMMUv3 devices Date: Wed, 13 May 2015 16:33:19 +0800 Message-ID: <55530C4F.5000605@huawei.com> References: <1431108046-9675-1-git-send-email-will.deacon@arm.com> <1431108046-9675-3-git-send-email-will.deacon@arm.com> <5551AE56.6050906@huawei.com> <20150512165500.GE2062@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20150512165500.GE2062-5wv7dgnIgG8@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Errors-To: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org To: Will Deacon Cc: "huxinwei-hv44wF8Li93QT0dZR+AlfA@public.gmane.org" , "iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org" , Sanil kumar , Gaojianbo , Dingtianhong , "linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org" List-Id: iommu@lists.linux-foundation.org T24gMjAxNS81LzEzIDA6NTUsIFdpbGwgRGVhY29uIHdyb3RlOgo+IEhpIExlaXpoZW4sCj4gCj4g VGhhbmtzIGZvciB0aGUgcmV2aWV3IQo+IAo+IE9uIFR1ZSwgTWF5IDEyLCAyMDE1IGF0IDA4OjQw OjA2QU0gKzAxMDAsIGxlaXpoZW4gd3JvdGU6Cj4+Cj4+PiArCj4+PiArc3RhdGljIGludCBxdWV1 ZV9wb2xsX2NvbnMoc3RydWN0IGFybV9zbW11X3F1ZXVlICpxLCB1MzIgdW50aWwsIGJvb2wgd2Zl KQo+Pj4gK3sKPj4+ICsgICAgIGt0aW1lX3QgdGltZW91dCA9IGt0aW1lX2FkZF91cyhrdGltZV9n ZXQoKSwgQVJNX1NNTVVfUE9MTF9USU1FT1VUX1VTKTsKPj4+ICsKPj4+ICsgICAgIHdoaWxlIChx dWV1ZV9zeW5jX2NvbnMocSksIF9fcXVldWVfY29uc19iZWZvcmUocSwgdW50aWwpKSB7Cj4+PiAr ICAgICAgICAgICAgIGlmIChrdGltZV9jb21wYXJlKGt0aW1lX2dldCgpLCB0aW1lb3V0KSA+IDAp Cj4+Cj4+IElzIGl0IGdvb2QgdG8gbGltaXQgaGFyZHdhcmUgYmVoYXZpb3I/IE1heSBiZSB3YWl0 IGZvciBldmVyIHdpbGwgYmUKPj4gYmV0dGVyLiBJZiBTTU1VIGNhbiBub3QgY29uc3VtZSBxdWV1 ZSBpdGVtcyB1bmRlciBub3JtYWwgY29uZGl0aW9uLCB0aGUKPj4gU01NVSBoYXJkd2FyZSBpcyBi cm9rZW4sIHdpbGwgbGVhZCBzb2Z0d2FyZSBzeXN0ZW0gdG8gYmUgY3Jhc2hlZCBsYXRlci4KPiAK PiBJIGRpc2FncmVlLiBIYXZpbmcgYSBicm9rZW4gU01NVSBsb2NrLXVwIHRoZSBlbnRpcmUga2Vy bmVsIGlzIGNvbnNpZGVyYWJseQo+IHdvcnNlIHRoYW4gaGF2aW5nIGUuZy4gYSBETUEgbWFzdGVy IGdldCBzdHVjay4gSWYgdGhpcyB0aW1lb3V0IGV4cGlyZXMsCj4gdGhlbiB3ZSdsbCBwcmludCBh IG1lc3NhZ2UgYW5kIGNvbnRpbnVlIHdpdGhvdXQgd2FpdGluZyBhbnkgbG9uZ2VyIGZvcgo+IGEg Q01EX1NZTkMgY29tcGxldGlvbiAoc2VlIGFybV9zbW11X2NtZHFfaXNzdWVfY21kKS4KCk9LCgo+ IAo+Pj4gKyAgICAgICAgICAgICAgICAgICAgIHJldHVybiAtRVRJTUVET1VUOwo+Pj4gKwo+Pj4g KyAgICAgICAgICAgICBpZiAod2ZlKSB7Cj4+PiArICAgICAgICAgICAgICAgICAgICAgd2ZlKCk7 Cj4+PiArICAgICAgICAgICAgIH0gZWxzZSB7Cj4+PiArICAgICAgICAgICAgICAgICAgICAgY3B1 X3JlbGF4KCk7Cj4+PiArICAgICAgICAgICAgICAgICAgICAgdWRlbGF5KDEpOwo+Pj4gKyAgICAg ICAgICAgICB9Cj4+PiArICAgICB9Cj4+PiArCj4+PiArICAgICByZXR1cm4gMDsKPj4+ICt9Cj4+ PiArCj4+PiArc3RhdGljIHZvaWQgcXVldWVfd3JpdGUoX19sZTY0ICpkc3QsIHU2NCAqc3JjLCBz aXplX3Qgbl9kd29yZHMpCj4+PiArewo+Pj4gKyAgICAgaW50IGk7Cj4+PiArCj4+PiArICAgICBm b3IgKGkgPSAwOyBpIDwgbl9kd29yZHM7ICsraSkKPj4+ICsgICAgICAgICAgICAgKmRzdCsrID0g Y3B1X3RvX2xlNjQoKnNyYysrKTsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIGludCBxdWV1ZV9p bnNlcnRfcmF3KHN0cnVjdCBhcm1fc21tdV9xdWV1ZSAqcSwgdTY0ICplbnQpCj4+PiArewo+Pj4g KyAgICAgaWYgKHF1ZXVlX2Z1bGwocSkpCj4+PiArICAgICAgICAgICAgIHJldHVybiAtRU5PU1BD Owo+Pj4gKwo+Pj4gKyAgICAgcXVldWVfd3JpdGUoUV9FTlQocSwgcS0+cHJvZCksIGVudCwgcS0+ ZW50X2R3b3Jkcyk7Cj4+Cj4+IEEgZG1iIG9yIGRzYiBtYXliZSBuZWVkZWQuIFdlIG11c3QgaW5z dXJlIGFsbCBkYXRhIHdyaXR0ZW4gYXJlIGNvbXBsZXRlZCwKPj4gdGhlbiBub3RpZnkgaGFyZHdh cmUgdG8gY29uc3VtZS4KPiAKPiBUaGUgZHNiIGlzIHBlcmZvcm1lZCB3aGVuIHdlIHVwZGF0ZSB0 aGUgcHJvZHVjZXIgcG9pbnRlciBpbiBxdWV1ZV9pbmNfcHJvZAo+IChzaW5jZSB3ZSB1c2Ugd3Jp dGVsIGFzIG9wcG9zZWQgdG8gd3JpdGVsX3JlbGF4ZWQpLgoKT0ssIEkgc2F3LgoKPiAKPj4+ICsg ICAgIHF1ZXVlX2luY19wcm9kKHEpOwo+Pj4gKyAgICAgcmV0dXJuIDA7Cj4+PiArfQo+Pj4gKwo+ Pj4gKwo+Pj4gKy8qIEhpZ2gtbGV2ZWwgcXVldWUgYWNjZXNzb3JzICovCj4+PiArc3RhdGljIGlu dCBhcm1fc21tdV9jbWRxX2J1aWxkX2NtZCh1NjQgKmNtZCwgc3RydWN0IGFybV9zbW11X2NtZHFf ZW50ICplbnQpCj4+PiArewo+Pj4gKyAgICAgbWVtc2V0KGNtZCwgMCwgQ01EUV9FTlRfRFdPUkRT IDw8IDMpOwo+Pj4gKyAgICAgY21kWzBdIHw9IChlbnQtPm9wY29kZSAmIENNRFFfMF9PUF9NQVNL KSA8PCBDTURRXzBfT1BfU0hJRlQ7Cj4+PiArCj4+PiArICAgICBzd2l0Y2ggKGVudC0+b3Bjb2Rl KSB7Cj4+PiArICAgICBjYXNlIENNRFFfT1BfVExCSV9FTDJfQUxMOgo+Pgo+Pj4gKyAgICAgY2Fz ZSBDTURRX09QX0NNRF9TWU5DOgo+Pj4gKyAgICAgICAgICAgICBjbWRbMF0gfD0gQ01EUV9TWU5D XzBfQ1NfU0VWOwo+Pgo+PiBXZSBjYW4gbm90IGFsd2F5cyBzZXQgU0lHX1NFViwgYWN0dWFsbHkg aXQgc2hvdWxkIGJhc2UgdXBvbgo+PiBTTU1VX0lEUjAuU0VWKHNtbXUtPmZlYXR1cmVzICYgQVJN X1NNTVVfRkVBVF9TRVYpCj4gCj4gSXQgZG9lc24ndCBtYXR0ZXIgZm9yIHRoZSBDTURfU1lOQyBj b21tYW5kICh3aGljaCB0cmVhdHMgU0lHX1NFViBhcwo+IFNJR19OT05FIGluIHRoaXMgY2FzZSku IFdoYXQgYWN0dWFsbHkgbWF0dGVycyBpcyB0aGF0IHdlIGRvbid0IHBlcmZvcm0KPiB3ZmUoKSB3 aGVuIHRoZSBTTU1VIGNhbid0IGlzc3VlIHRoZSBldmVudCwgYnV0IHRoYXQncyBhbHJlYWR5IHRh a2VuIGNhcmUKPiBvZiBpbiBhcm1fc21tdV9jbWRxX2lzc3VlX2NtZC4KCk9LCgo+IAo+Pj4gKyAg ICAgICAgICAgICBicmVhazsKPj4+ICsgICAgIGRlZmF1bHQ6Cj4+PiArICAgICAgICAgICAgIHJl dHVybiAtRU5PRU5UOwo+Pj4gKyAgICAgfQo+Pj4gKwo+Pj4gKyAgICAgcmV0dXJuIDA7Cj4+PiAr fQo+Pgo+Pj4gKwo+Pj4gK3N0YXRpYyBpbnQgYXJtX3NtbXVfZG9tYWluX2ZpbmFsaXNlX3MxKHN0 cnVjdCBhcm1fc21tdV9kb21haW4gKnNtbXVfZG9tYWluLAo+Pj4gKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHN0cnVjdCBpb19wZ3RhYmxlX2NmZyAqcGd0YmxfY2ZnKQo+Pj4g K3sKPj4+ICsgICAgIGludCByZXQ7Cj4+PiArICAgICB1MTYgYXNpZDsKPj4+ICsgICAgIHN0cnVj dCBhcm1fc21tdV9kZXZpY2UgKnNtbXUgPSBzbW11X2RvbWFpbi0+c21tdTsKPj4+ICsgICAgIHN0 cnVjdCBhcm1fc21tdV9zMV9jZmcgKmNmZyA9ICZzbW11X2RvbWFpbi0+czFfY2ZnOwo+Pj4gKwo+ Pj4gKyAgICAgYXNpZCA9IGFybV9zbW11X2JpdG1hcF9hbGxvYyhzbW11LT5hc2lkX21hcCwgc21t dS0+YXNpZF9iaXRzKTsKPj4+ICsgICAgIGlmIChJU19FUlJfVkFMVUUoYXNpZCkpCj4+PiArICAg ICAgICAgICAgIHJldHVybiBhc2lkOwo+Pj4gKwo+Pj4gKyAgICAgY2ZnLT5jZHB0ciA9IGRtYV96 YWxsb2NfY29oZXJlbnQoc21tdS0+ZGV2LCBDVFhERVNDX0NEX0RXT1JEUyA8PCAzLAo+Pj4gKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmNmZy0+Y2RwdHJfZG1hLCBHRlBf S0VSTkVMKTsKPj4KPj4gV2h5IHVzZSBkbWFfemFsbG9jX2NvaGVyZW50PyBpb3ZhIGlzIGNvdmVy dGVkIGZyb20gUEEgYnkgY2FsbGluZwo+PiBwaHlzX3RvX2RtYS4gSSBhZnJhaWQgUEEgYW5kIGlv dmEgbWF5YmUgbm90IGVxdWFsLiBJbiBmYWN0LCB0aGUgbWFwcGluZwo+PiBiZXR3ZWVuIGlvdmEg YW5kIFBBIGlzIHJlbHkgb24gU01NVSBkcml2ZXIgaXRzZWxmLiBXaHkgbm90IHVzZQo+PiB2aXJ0 X3RvX3BoeXMgdG8gZ2V0IFBBLCBTTU1VIGhhcmR3YXJlIGFjdHVhbGx5IHJlcXVpcmUgUEEuCj4g Cj4gVGhlIFNNTVUgc3RydWN0dXJlIHdhbGtlciBpcyBub3QgYWxsb3dlZCB0byBiZSBjaGFpbmVk IGludG8gYW5vdGhlciBTTU1VLAo+IHNvIHRoZSBwaHlzaWNhbCBhbmQgRE1BIGFkZHJlc3NlcyBh cmUgZXF1YWwgaGVyZS4gVGhhdCBzYWlkLCB0aGUgd2Fsa2VyCj4gZG9lcyBub3QgbmVlZCB0byBi ZSBjYWNoZSBjb2hlcmVudCwgc28gSSBuZWVkIHRvIHVzZSB0aGUgY29oZXJlbnQgRE1BCj4gYWxs b2NhdG9yIHRvIGdldCBtZW1vcnkgb2YgdGhlIGNvcnJlY3QgYXR0cmlidXRlcy4gSSBhbHNvIG5l ZWQgdGhlIHRhYmxlCj4gdG8gYmUgbmF0dXJhbGx5IGFsaWduZWQuCj4gCj4gQW4gYWx0ZXJuYXRp dmUgd291bGQgYmUgc29tZXRoaW5nIGxpa2UgX19nZXRfZnJlZV9wYWdlcyB3aXRoIGhvbWVicmV3 Cj4gY2FjaGUgbWFpbnRlbmFuY2UgZm9yIG5vbi1jb2hlcmVudCBTTU1VcywgYnV0IEkgZG9uJ3Qg d2FudCB0byByZS1pbnZlbnQKPiB0aGUgRE1BIG1hcHBpbmcgY29kZSBpbiB0aGUgZHJpdmVyICh3 ZSBhbHJlYWR5IGhhdmUgYSBzaW1pbGFyIG1lc3Mgd2l0aAo+IHRoZSBwYWdlIHRhYmxlcywgd2hp Y2ggSSdkIGxpa2UgdG8gc29ydCBvdXQpLgoKT0ssIEkgaGF2ZSBub3QgY29uc2lkZXJlZCBub24t Y29oZXJlbnQgU01NVSBiZWZvcmUuIEJ1dCBub24tY29oZXJlbnQgU01NVSBtYXliZSByYXJlLgoK PiAKPj4+ICtzdGF0aWMgaW50IGFybV9zbW11X2FsbG9jX2wyX3N0cnRhYihzdHJ1Y3QgYXJtX3Nt bXVfZGV2aWNlICpzbW11KQo+Pj4gK3sKPj4+ICsgICAgIGludCByZXQ7Cj4+PiArICAgICB1bnNp Z25lZCBpbnQgaTsKPj4+ICsgICAgIHN0cnVjdCBhcm1fc21tdV9zdHJ0YWJfY2ZnICpjZmcgPSAm c21tdS0+c3RydGFiX2NmZzsKPj4+ICsgICAgIHNpemVfdCBzaXplID0gc2l6ZW9mKCpjZmctPmwx X2Rlc2MpICogY2ZnLT5udW1fbDFfZGVzY3M7Cj4+PiArICAgICB2b2lkICpzdHJ0YWIgPSBzbW11 LT5zdHJ0YWJfY2ZnLnN0cnRhYjsKPj4+ICsKPj4+ICsgICAgIGNmZy0+bDFfZGVzYyA9IGRldm1f a3phbGxvYyhzbW11LT5kZXYsIHNpemUsIEdGUF9LRVJORUwpOwo+Pj4gKyAgICAgaWYgKCFjZmct PmwxX2Rlc2MpIHsKPj4+ICsgICAgICAgICAgICAgZGV2X2VycihzbW11LT5kZXYsICJmYWlsZWQg dG8gYWxsb2NhdGUgbDEgc3RyZWFtIHRhYmxlIGRlc2NcbiIpOwo+Pj4gKyAgICAgICAgICAgICBy ZXR1cm4gLUVOT01FTTsKPj4+ICsgICAgIH0KPj4+ICsKPj4+ICsgICAgIHNpemUgPSAxIDw8IChT VFJUQUJfU1BMSVQgKyBpbG9nMihTVFJUQUJfU1RFX0RXT1JEUykgKyAzKTsKPj4+ICsgICAgIGZv ciAoaSA9IDA7IGkgPCBjZmctPm51bV9sMV9kZXNjczsgKytpKSB7Cj4+PiArICAgICAgICAgICAg IHN0cnVjdCBhcm1fc21tdV9zdHJ0YWJfbDFfZGVzYyAqZGVzYyA9ICZjZmctPmwxX2Rlc2NbaV07 Cj4+PiArCj4+PiArICAgICAgICAgICAgIGRlc2MtPnNwYW4gPSBTVFJUQUJfU1BMSVQgKyAxOwo+ Pj4gKyAgICAgICAgICAgICBkZXNjLT5sMnB0ciA9IGRtYV96YWxsb2NfY29oZXJlbnQoc21tdS0+ ZGV2LCBzaXplLAo+Pj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgJmRlc2MtPmwycHRyX2RtYSwgR0ZQX0tFUk5FTCk7Cj4+Cj4+IE5vLCBubywgcGxlYXNl IGRvbid0IGFsbG9jYXRlIGFsbCBMdjIgdGFibGUgbWVtb3J5LCB3ZSBzaG91bGQgZHluYW1pYwo+ PiBhbGxvY2F0aW9uIHdoZW4gbmVlZGVkLiAgT3RoZXJ3aXNlIHdlIGNhbiBub3Qgc2F2ZSBtZW1v cnkgcmVsYXRpdmUgdG8gb25lCj4+IGxldmVsIHRhYmxlLiBBbmQgY2ZnLT5sMV9kZXNjIHNlZW1z IG5vdCBuZWNlc3NhcnkuICBCZWZvcmUgY3JlYXRlIG1hcHBpbmcKPj4gZm9yIGEgc3BlY2lmaWVk IFN0cmVhbUlELCB3ZSByZWFkIGNvcnJlc3BvbmRpbmcgTHYxIHRhYmxlIGVudHJ5LCBpZiBMMlB0 cgo+PiBpcyBOVUxMLCB0aGVuIHdlIGJ1aWxkIEx2MiB0YWJsZS4gT3RoZXJ3aXNlLCBtZWFucyB0 aGlzIEx2MiB0YWJsZSBoYXZlCj4+IGFscmVhZHkgYmVlbiBidWlsdCwgYmVjYXVzZSBhIEx2MiB0 YWJsZSBpcyBzaGFyZWQgYnkgYSBncm91cCBvZiBTdHJlYW1JRHMuCj4gCj4gVGhlIHB1cnBvc2Ug b2YgdGhlIHR3byBsZXZlbCBhcHByb2FjaCBpc24ndCB0byBzYXZlIG1lbW9yeTsgaXQncyB0byBy ZW1vdmUKPiB0aGUgbmVlZCBmb3IgYSBzaW5nbGUgKGxhcmdlKSBjb250aWd1b3VzIGJsb2NrLiBG dXJ0aGVybW9yZSwgd2UgbmVlZCBhbGwKPiBtYXN0ZXIgZGV2aWNlcyBpbiB0aGUgc3lzdGVtIHRv IGNvbWUgdXAgaW4gYSBzdGF0ZSB3aGVyZSB0aGVpciB0cmFuc2FjdGlvbnMKPiBieXBhc3MgdGhl IFNNTVUgKGkuZS4gd2UgZG9uJ3QgcmVxdWlyZSB0aGVtIHRvIHVzZSB0aGUgU01NVSBmb3IKPiB0 cmFuc2xhdGlvbikuIEFjaGlldmluZyB0aGlzIG5lY2Vzc2l0YXRlcyBhIGZ1bGx5LXBvcHVsYXRl ZCBzdHJlYW0tdGFibGUKPiBiZWZvcmUgYW55IERNQSBvY2N1cnMuCgpPSywgYnV0IGZvciBub24t cGNpIGRldmljZXMobWF5YmUgcGNpIGRldmljZXMgYWxzbyksIGluaXRpYWxpemUgYWxsIGRldmlj ZXMoU3RyZWFtSURzKSB0byBieXBhc3MKbW9kZSBtYXliZSBpbmNvcnJlY3QuIFNvbWUgZGV2aWNl cyBtYXliZSBjYXBhYmxlIGJyaW5nIGF0dHJpYnV0ZXMgYnkgaXRzZWxmLCBhbmQgYWNjZXNzIGRp ZmZlcmVudAptZW1vcnkgd2l0aCBkaWZmZXJlbnQgYXR0cmlidXRlcyhkZXZpY2UgYXR0cmlidXRl IG9yIGNhY2hlYWJsZSBhdHRyaWJ1dGUpOyBzb21lIGRldmljZXMgbWF5YmUgbm90CmNhcGFibGUg YnJpbmcgYXR0cmlidXRlcyBieSBpdHNlbGYsIGJ1dCBuZWVkIGFjY2VzcyBtZW1vcnkgd2l0aCBj YWNoZWFibGUgYXR0cmlidXRlIG9ubHksIHNvIHdlCnNob3VsZCBzZXQgU1RFLk1UQ0ZHID0gMS4g UHJvdmlkZSBkdHMgY29uZmlndXJhdGlvbiB3aWxsIGJlIGJldHRlci4KCk9oLCBJIGNhbiBkbyBp dCBhZnRlciB5b3VyIHBhdGNoZXMgdXBzdHJlYW1lZCwgYmVjYXVzZSB0aGlzIHByb2JsZW0gbWF5 YmUgb25seSBJIG1ldC4KCkZ1cnRoZXJtb3JlLCBJIGRvbid0IGFncmVlIGluaXRpYWxpemUgYWxs IGRldmljZXMgdG8gYnlwYXNzIGJ5IGRlZmF1bHQuIFN1cHBvc2UgYSBub24tcGNpIGRldmljZSdz IFN0cmVhbUlECmNhbiBiZSBkeW5hbWljIGNvbmZpZ3VyZWQuIFdlIHJlcXVpcmUgU3RyZWFtSUQt QSwgYnV0IHRoZSBkZXZpY2UgYWN0dWFsbHkgaXNzdWUgU3RyZWFtSUQtQiBiZWNhdXNlIG9mCnNv ZnR3YXJlIGNvbmZpZ3VyYXRpb24gZmF1bHQuIFdlIHJlYWxseSBob3BlIFNNTVUgY2FuIHJlcG9y dCBCYWQgU3RyZWFtSUQgZmF1bHQuCgo+IAo+IEkgc3VwcG9zZSB3ZSBjb3VsZCBsb29rIGludG8g cG9wdWxhdGluZyBpdCBiYXNlZCBvbiB0aGUgLT5hZGRfZGV2aWNlCj4gY2FsbGJhY2ssIHdoaWNo IGN1cnJlbnRseSBkb2VzIGhhdmUgc29tZSByYW5nZSBjaGVja3MKPiAoYXJtX3NtbXVfc2lkX2lu X3JhbmdlKS4gSXMgdGhhdCB3aGF0IHlvdSBoYWQgaW4gbWluZD8KClllcywgbWF5YmUgYXR0YWNo X2Rldi4gQnV0IHdlIHNob3VsZCBhbGxvY2F0ZWQgdGhlIHdob2xlIEx2MSB0YWJsZSBiYXNlIG9u IFNNTVVfSURSMS5TSURTSVpFCgo+IAo+Pj4gKyAgICAgICAgICAgICBpZiAoIWRlc2MtPmwycHRy KSB7Cj4+PiArICAgICAgICAgICAgICAgICAgICAgZGV2X2VycihzbW11LT5kZXYsCj4+PiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRvIGFsbG9jYXRlIGwyIHN0cmVhbSB0 YWJsZSAldVxuIiwgaSk7Cj4+PiArICAgICAgICAgICAgICAgICAgICAgcmV0ID0gLUVOT01FTTsK Pj4+ICsgICAgICAgICAgICAgICAgICAgICBnb3RvIG91dF9mcmVlX2wyOwo+Pj4gKyAgICAgICAg ICAgICB9Cj4+PiArCj4+PiArICAgICAgICAgICAgIGFybV9zbW11X2luaXRfYnlwYXNzX3N0ZXMo ZGVzYy0+bDJwdHIsIDEgPDwgU1RSVEFCX1NQTElUKTsKPj4+ICsgICAgICAgICAgICAgYXJtX3Nt bXVfd3JpdGVfc3RydGFiX2wxX2Rlc2Moc3RydGFiLCBkZXNjKTsKPj4+ICsgICAgICAgICAgICAg c3RydGFiICs9IFNUUlRBQl9TVEVfRFdPUkRTOwo+Pj4gKyAgICAgfQo+Pj4gKwo+Pj4gKyAgICAg cmV0dXJuIDA7Cj4+PiArCj4+PiArb3V0X2ZyZWVfbDI6Cj4+PiArICAgICBhcm1fc21tdV9mcmVl X2wyX3N0cnRhYihzbW11KTsKPj4+ICsgICAgIHJldHVybiByZXQ7Cj4+PiArfQo+Pj4gKwo+Pj4g K3N0YXRpYyBpbnQgYXJtX3NtbXVfaW5pdF9zdHJ0YWIoc3RydWN0IGFybV9zbW11X2RldmljZSAq c21tdSkKPj4+ICt7Cj4+PiArICAgICB2b2lkICpzdHJ0YWI7Cj4+PiArICAgICB1NjQgcmVnOwo+ Pj4gKyAgICAgdTMyIHNpemU7Cj4+PiArICAgICBpbnQgcmV0ID0gMDsKPj4+ICsKPj4+ICsgICAg IHN0cnRhYiA9IGRtYV96YWxsb2NfY29oZXJlbnQoc21tdS0+ZGV2LCAxIDw8IFNUUlRBQl9MMV9T Wl9TSElGVCwKPj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnNtbXUtPnN0 cnRhYl9jZmcuc3RydGFiX2RtYSwgR0ZQX0tFUk5FTCk7Cj4+Cj4+IEFzIGFib3ZlLCB3aGVuIEx2 MiB0YWJsZXMgYXJlIGR5bmFtaWMgYWxsb2NhdGlvbiwgd2UgY2FuIGNyZWF0ZSBMdjEgdGFibGUK Pj4gYmFzZSBvbiBTTU1VX0lEUjEuU0lEU0laRSBhbmQgc3VwcG9ydCBub24tcGljIGRldmljZXMu IE9oLCBpZiBTSURTSVpFIGlzCj4+IHRvbyBsYXJnZSwgbGlrZSAzMi4gTWF5YmUgd2Ugc2hvdWxk IHVzZSA2NEsgc2l6ZSBMdjIgdGFibGUuICBCdXQgd2UgY2FuCj4+IG9ubHkgdXNlIFBBR0VfU0la RSBmaXJzdCwgZm9yIGxhenkuCj4gCj4gUmlnaHQgbm93LCB0aGUgbDIgdGFibGVzIGFyZSA0ayBh bmQgbDEgdGFibGUgaXMgOGsuIFRoYXQncyAoYSkgbmljZSBmb3IKPiBhbGxvY2F0aW9uIG9uIGEg c3lzdGVtIHdpdGggNGsgcGFnZXMgYW5kIChiKSBlbm91Z2ggdG8gY292ZXIgYSBQQ0kgaG9zdAo+ IGNvbnRyb2xsZXIuIFRoZSBwcm9ibGVtIHdpdGggc3VwcG9ydGluZyAzMi1iaXQgU0lEcyBpcyB0 aGF0IHRoZSBsMSB3aWxsCj4gYmVjb21lIGEgc2l6ZWFibGUgY29udGlndW91cyBjaHVuayB3aGlj aCB3ZSdsbCBoYXZlIHRvIGFsbG9jYXRlCj4gcmVnYXJkbGVzcy4KPiAKPiBTbywgaWYgd2Uga2Vl cCB0aGUgbDIgc2l6ZSBhdCA0ayBmb3IgdGhlIG1vbWVudCwgaG93IGJpZyB3b3VsZCB5b3UgbGlr ZQo+IHRoZSBsMT8gRm9yIGEgMzItYml0IG51bWJlcnNwYWNlLCBpdCB3b3VsZCBiZSA0TUIsIHdo aWNoIEkgZG9uJ3QgdGhpbmsgaXMKPiBwcmFjdGljYWwuCgpZZXMsIGJlY2F1c2UgSSBkb24ndCB0 aGluayBTTU1VX0lEUjEuU0lEU0laRSA9IDMyIHJlYWxseSBleGlzdCwgc28gSSBzYWlkIHVzZSBQ QUdFX1NJWkUgZmlyc3QuCgpCdXQgbm93LCB0aGlzIHBhdGNoIG9ubHkgc3VwcG9ydCBTTU1VX0lE UjEuU0lEU0laRSA8PSAxNi4gU3VwcG9zZSBTTU1VX0lEUjEuU0lEU0laRSA9IDI177yMTHYyCnRh YmxlIHNpemUgYXQgNEssIHRoZW4gTHYxIHRhYmxlIG5lZWQgMl4oMjUgLSA2ICsgMykgPSAyXjIy ID0gNE0uIElmIHdlIHByZS1hbGxvY2F0ZWQgYWxsIEx2MiB0YWJsZSwKd2UgbmVlZCAyXjI1ICog NjQgPSAyXjMxID0gMkcsIHRoYXQncyB0b28gYmlnLiBTbyB3ZSBtdXN0IG9ubHkgYWxsb2NhdGUg THYyIHRhYmxlIHdoZW4gd2UgbmVlZGVkLgoKSWYgU01NVV9JRFIxLlNJRFNJWkUgPSAzMiByZWFs bHkgZXhpc3Qob3IgdG9vIGJpZyksIHdlIG5lZWQgZHluYW1pYyBjaG9vc2UgTHYyIHRhYmxlIHNp emUoNEssMTZLLDY0SykuCkJlY2F1c2UgTHYxIHRhYmxlIG1heWJlIHRvbyBiaWcsIGFuZCBjYW4g bm90IGJlIGFsbG9jYXRlZCBieSBjdXJyZW50IEFQSSwgYSBkdHMgY29uZmlndXJhdGlvbiBzaG91 bGQgYmUKYWRkZWQsIGxpa2UgbHYxLXRhYmxlLWJhc2UgPSA8MHgwIDB4MD4sIGFuZCB3ZSB1c2Ug aW9yZW1hcF9jYWNoZSBnZXQgVkEobWF5YmUgaW9yZW1hcCwgZm9yIG5vbi1jb2hlcmVudCBTTU1V KS4KCk9oLCBJIGNhbiBkbyBpdCBhZnRlciB5b3VyIHBhdGNoZXMgdXBzdHJlYW1lZCwgYmVjYXVz ZSB0aGlzIHByb2JsZW0gbWF5YmUgb25seSBJIG1ldC4KCgo+IAo+Pj4gKyAgICAgaWYgKCFzdHJ0 YWIpIHsKPj4+ICsgICAgICAgICAgICAgZGV2X2VycihzbW11LT5kZXYsICJmYWlsZWQgdG8gYWxs b2NhdGUgbDEgc3RyZWFtIHRhYmxlXG4iKTsKPj4+ICsgICAgICAgICAgICAgcmV0dXJuIC1FTk9N RU07Cj4+PiArICAgICB9Cj4+PiArICAgICBzbW11LT5zdHJ0YWJfY2ZnLnN0cnRhYiA9IHN0cnRh YjsKPj4+ICsKPj4+ICsgICAgIHJlZyAgPSBzbW11LT5zdHJ0YWJfY2ZnLnN0cnRhYl9kbWEgJgo+ Pj4gKyAgICAgICAgICAgIFNUUlRBQl9CQVNFX0FERFJfTUFTSyA8PCBTVFJUQUJfQkFTRV9BRERS X1NISUZUOwo+Pj4gKyAgICAgcmVnIHw9IFNUUlRBQl9CQVNFX1JBOwo+Pj4gKyAgICAgc21tdS0+ c3RydGFiX2NmZy5zdHJ0YWJfYmFzZSA9IHJlZzsKPj4+ICsKPj4+ICsgICAgIGlmIChzbW11LT5m ZWF0dXJlcyAmIEFSTV9TTU1VX0ZFQVRfMl9MVkxfU1RSVEFCKSB7Cj4+PiArICAgICAgICAgICAg IHNpemUgPSBTVFJUQUJfTDFfU1pfU0hJRlQgLSAoaWxvZzIoU1RSVEFCX0wxX0RFU0NfRFdPUkRT KSArIDMpOwo+Pj4gKyAgICAgICAgICAgICBzbW11LT5zdHJ0YWJfY2ZnLm51bV9sMV9kZXNjcyA9 IDEgPDwgc2l6ZTsKPj4+ICsgICAgICAgICAgICAgc2l6ZSArPSBTVFJUQUJfU1BMSVQ7Cj4+PiAr ICAgICAgICAgICAgIHJlZyA9IFNUUlRBQl9CQVNFX0NGR19GTVRfMkxWTDsKPj4+ICsKPj4+ICsg ICAgICAgICAgICAgcmV0ID0gYXJtX3NtbXVfYWxsb2NfbDJfc3RydGFiKHNtbXUpOwo+Pj4gKyAg ICAgICAgICAgICBpZiAocmV0KQo+Pj4gKyAgICAgICAgICAgICAgICAgICAgIGdvdG8gb3V0X2Zy ZWVfbDE7Cj4+PiArICAgICB9IGVsc2Ugewo+Pj4gKyAgICAgICAgICAgICBzaXplID0gU1RSVEFC X0wxX1NaX1NISUZUIC0gKGlsb2cyKFNUUlRBQl9TVEVfRFdPUkRTKSArIDMpOwo+Pj4gKyAgICAg ICAgICAgICBzbW11LT5zdHJ0YWJfY2ZnLm51bV9sMV9kZXNjcyA9IDA7Cj4+PiArICAgICAgICAg ICAgIHJlZyA9IFNUUlRBQl9CQVNFX0NGR19GTVRfTElORUFSOwo+Pj4gKyAgICAgICAgICAgICBh cm1fc21tdV9pbml0X2J5cGFzc19zdGVzKHN0cnRhYiwgMSA8PCBzaXplKTsKPj4+ICsgICAgIH0K Pj4+ICsKPj4+ICsgICAgIGlmIChzaXplIDwgc21tdS0+c2lkX2JpdHMpCj4+PiArICAgICAgICAg ICAgIGRldl93YXJuKHNtbXUtPmRldiwgIiVzIHN0cnRhYiBvbmx5IGNvdmVycyAldS8ldSBiaXRz IG9mIFNJRFxuIiwKPj4+ICsgICAgICAgICAgICAgICAgICAgICAgc21tdS0+ZmVhdHVyZXMgJiBB Uk1fU01NVV9GRUFUXzJfTFZMX1NUUlRBQiA/Cj4+PiArICAgICAgICAgICAgICAgICAgICAgICIy LWxldmVsIiA6ICJsaW5lYXIiLAo+Pj4gKyAgICAgICAgICAgICAgICAgICAgICBzaXplLCBzbW11 LT5zaWRfYml0cyk7Cj4+PiArCj4+PiArICAgICByZWcgfD0gKHNpemUgJiBTVFJUQUJfQkFTRV9D RkdfTE9HMlNJWkVfTUFTSykKPj4+ICsgICAgICAgICAgICAgPDwgU1RSVEFCX0JBU0VfQ0ZHX0xP RzJTSVpFX1NISUZUOwo+Pj4gKyAgICAgcmVnIHw9IChTVFJUQUJfU1BMSVQgJiBTVFJUQUJfQkFT RV9DRkdfU1BMSVRfTUFTSykKPj4+ICsgICAgICAgICAgICAgPDwgU1RSVEFCX0JBU0VfQ0ZHX1NQ TElUX1NISUZUOwo+Pj4gKyAgICAgc21tdS0+c3RydGFiX2NmZy5zdHJ0YWJfYmFzZV9jZmcgPSBy ZWc7Cj4+PiArCj4+PiArICAgICAvKiBBbGxvY2F0ZSB0aGUgZmlyc3QgVk1JRCBmb3Igc3RhZ2Ut MiBieXBhc3MgU1RFcyAqLwo+Pj4gKyAgICAgc2V0X2JpdCgwLCBzbW11LT52bWlkX21hcCk7Cj4+ PiArICAgICByZXR1cm4gMDsKPj4+ICsKPj4+ICtvdXRfZnJlZV9sMToKPj4+ICsgICAgIGRtYV9m cmVlX2NvaGVyZW50KHNtbXUtPmRldiwgMSA8PCBTVFJUQUJfTDFfU1pfU0hJRlQsIHN0cnRhYiwK Pj4+ICsgICAgICAgICAgICAgICAgICAgICAgIHNtbXUtPnN0cnRhYl9jZmcuc3RydGFiX2RtYSk7 Cj4+PiArICAgICByZXR1cm4gcmV0Owo+Pj4gK30KPj4+ICsKPj4+ICtzdGF0aWMgdm9pZCBhcm1f c21tdV9mcmVlX3N0cnRhYihzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11KQo+Pj4gK3sKPj4+ ICsgICAgIHN0cnVjdCBhcm1fc21tdV9zdHJ0YWJfY2ZnICpjZmcgPSAmc21tdS0+c3RydGFiX2Nm ZzsKPj4+ICsKPj4+ICsgICAgIGFybV9zbW11X2ZyZWVfbDJfc3RydGFiKHNtbXUpOwo+Pj4gKyAg ICAgZG1hX2ZyZWVfY29oZXJlbnQoc21tdS0+ZGV2LCAxIDw8IFNUUlRBQl9MMV9TWl9TSElGVCwg Y2ZnLT5zdHJ0YWIsCj4+PiArICAgICAgICAgICAgICAgICAgICAgICBjZmctPnN0cnRhYl9kbWEp Owo+Pj4gK30KPj4+ICsKPj4KPj4+ICsKPj4+ICtzdGF0aWMgaW50IGFybV9zbW11X2RldmljZV9y ZXNldChzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11KQo+Pj4gK3sKPj4+ICsgICAgIGludCBy ZXQ7Cj4+PiArICAgICB1MzIgcmVnLCBlbmFibGVzOwo+Pj4gKyAgICAgc3RydWN0IGFybV9zbW11 X2NtZHFfZW50IGNtZDsKPj4+ICsKPj4+ICsgICAgIC8qIENsZWFyIENSMCBhbmQgc3luYyAoZGlz YWJsZXMgU01NVSBhbmQgcXVldWUgcHJvY2Vzc2luZykgKi8KPj4+ICsgICAgIHJlZyA9IHJlYWRs X3JlbGF4ZWQoc21tdS0+YmFzZSArIEFSTV9TTU1VX0NSMCk7Cj4+PiArICAgICBpZiAocmVnICYg Q1IwX1NNTVVFTikKPj4+ICsgICAgICAgICAgICAgZGV2X3dhcm4oc21tdS0+ZGV2LCAiU01NVSBj dXJyZW50bHkgZW5hYmxlZCEgUmVzZXR0aW5nLi4uXG4iKTsKPj4+ICsKPj4+ICsgICAgIHJldCA9 IGFybV9zbW11X2RldmljZV9kaXNhYmxlKHNtbXUpOwo+Pj4gKyAgICAgaWYgKHJldCkKPj4+ICsg ICAgICAgICAgICAgcmV0dXJuIHJldDsKPj4+ICsKPj4+ICsgICAgIC8qIENSMSAodGFibGUgYW5k IHF1ZXVlIG1lbW9yeSBhdHRyaWJ1dGVzKSAqLwo+Pj4gKyAgICAgcmVnID0gKENSMV9TSF9JU0gg PDwgQ1IxX1RBQkxFX1NIX1NISUZUKSB8Cj4+PiArICAgICAgICAgICAoQ1IxX0NBQ0hFX1dCIDw8 IENSMV9UQUJMRV9PQ19TSElGVCkgfAo+Pj4gKyAgICAgICAgICAgKENSMV9DQUNIRV9XQiA8PCBD UjFfVEFCTEVfSUNfU0hJRlQpIHwKPj4+ICsgICAgICAgICAgIChDUjFfU0hfSVNIIDw8IENSMV9R VUVVRV9TSF9TSElGVCkgfAo+Pj4gKyAgICAgICAgICAgKENSMV9DQUNIRV9XQiA8PCBDUjFfUVVF VUVfT0NfU0hJRlQpIHwKPj4+ICsgICAgICAgICAgIChDUjFfQ0FDSEVfV0IgPDwgQ1IxX1FVRVVF X0lDX1NISUZUKTsKPj4+ICsgICAgIHdyaXRlbF9yZWxheGVkKHJlZywgc21tdS0+YmFzZSArIEFS TV9TTU1VX0NSMSk7Cj4+PiArCj4+PiArICAgICAvKiBDUjIgKHJhbmRvbSBjcmFwKSAqLwo+Pj4g KyAgICAgcmVnID0gQ1IyX1BUTSB8IENSMl9SRUNJTlZNSUQgfCBDUjJfRTJIOwo+Pgo+PiBEbyB3 ZSBuZWVkIHRvIGV4cGxpY2l0bHkgc2V0IENSMl9FMkg/IExpbnV4IG9ubHkgcnVuIGF0IEVMMS4K PiAKPiBTZXR0aW5nIEUySCB3b24ndCBjYXVzZSBhbnkgaGFybSBhbmQgSSdkIGV4cGVjdCBMaW51 eCB0byBydW4gdGhlcmUgaW4gdGhlCj4gZnV0dXJlLiBJZiB3ZSBldmVyIGRlY2lkZSB0byBzaGFy ZSBDUFUgcGFnZSB0YWJsZXMgd2l0aCB0aGUgU01NVSwgdGhlbiB3ZSdsbAo+IG5lZWQgdGhpcyBz ZXQgdG8gcGFydGljaXBhdGUgaW4gRFZNLgoKT0sKCj4gCj4+PiArICAgICB3cml0ZWxfcmVsYXhl ZChyZWcsIHNtbXUtPmJhc2UgKyBBUk1fU01NVV9DUjIpOwo+Pj4gKwo+Pj4gKyAgICAgLyogU3Ry ZWFtIHRhYmxlICovCj4+PiArICAgICB3cml0ZXFfcmVsYXhlZChzbW11LT5zdHJ0YWJfY2ZnLnN0 cnRhYl9iYXNlLAo+Pj4gKyAgICAgICAgICAgICAgICAgICAgc21tdS0+YmFzZSArIEFSTV9TTU1V X1NUUlRBQl9CQVNFKTsKPj4+ICsgICAgIHdyaXRlbF9yZWxheGVkKHNtbXUtPnN0cnRhYl9jZmcu c3RydGFiX2Jhc2VfY2ZnLAo+Pj4gKyAgICAgICAgICAgICAgICAgICAgc21tdS0+YmFzZSArIEFS TV9TTU1VX1NUUlRBQl9CQVNFX0NGRyk7Cj4+PiArCj4+PiArICAgICAvKiBDb21tYW5kIHF1ZXVl ICovCj4+PiArICAgICB3cml0ZXFfcmVsYXhlZChzbW11LT5jbWRxLnEucV9iYXNlLCBzbW11LT5i YXNlICsgQVJNX1NNTVVfQ01EUV9CQVNFKTsKPj4+ICsgICAgIHdyaXRlbF9yZWxheGVkKHNtbXUt PmNtZHEucS5wcm9kLCBzbW11LT5iYXNlICsgQVJNX1NNTVVfQ01EUV9QUk9EKTsKPj4+ICsgICAg IHdyaXRlbF9yZWxheGVkKHNtbXUtPmNtZHEucS5jb25zLCBzbW11LT5iYXNlICsgQVJNX1NNTVVf Q01EUV9DT05TKTsKPj4+ICsKPj4+ICsgICAgIGVuYWJsZXMgPSBDUjBfQ01EUUVOOwo+Pj4gKyAg ICAgcmV0ID0gYXJtX3NtbXVfd3JpdGVfcmVnX3N5bmMoc21tdSwgZW5hYmxlcywgQVJNX1NNTVVf Q1IwLAo+Pj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQVJNX1NNTVVfQ1Iw QUNLKTsKPj4+ICsgICAgIGlmIChyZXQpIHsKPj4+ICsgICAgICAgICAgICAgZGV2X2VycihzbW11 LT5kZXYsICJmYWlsZWQgdG8gZW5hYmxlIGNvbW1hbmQgcXVldWVcbiIpOwo+Pj4gKyAgICAgICAg ICAgICByZXR1cm4gcmV0Owo+Pj4gKyAgICAgfQo+Pj4gKwo+Pj4gKyAgICAgLyogSW52YWxpZGF0 ZSBhbnkgY2FjaGVkIGNvbmZpZ3VyYXRpb24gKi8KPj4+ICsgICAgIGNtZC5vcGNvZGUgPSBDTURR X09QX0NGR0lfQUxMOwo+Pj4gKyAgICAgYXJtX3NtbXVfY21kcV9pc3N1ZV9jbWQoc21tdSwgJmNt ZCk7Cj4+PiArICAgICBjbWQub3Bjb2RlID0gQ01EUV9PUF9DTURfU1lOQzsKPj4+ICsgICAgIGFy bV9zbW11X2NtZHFfaXNzdWVfY21kKHNtbXUsICZjbWQpOwo+Pj4gKwo+Pj4gKyAgICAgLyogSW52 YWxpZGF0ZSBhbnkgc3RhbGUgVExCIGVudHJpZXMgKi8KPj4+ICsgICAgIGNtZC5vcGNvZGUgPSBD TURRX09QX1RMQklfRUwyX0FMTDsKPj4KPj4gRG8gd2UgbmVlZCB0byBleGVjdXRlIENNRFFfT1Bf VExCSV9FTDJfQUxMPyBMaW51eCBvbmx5IHJ1biBhdCBFTDEuIEl0IGF0Cj4+IGxlYXN0IHJlbHkg b24gU01NVV9JRFIwLkh5cAo+IAo+IFRoZSBTTU1VIGlzbid0IGd1YXJhbnRlZWQgdG8gY29tZSB1 cCBjbGVhbiBvdXQgb2YgcmVzZXQsIHNvIGl0J3MgYSBnb29kCj4gaWRlYSB0byBwZXJmb3JtIHRo aXMgaW52YWxpZGF0aW9uIGluIGNhc2Ugb2YganVuayBpbiB0aGUgVExCLiBHaXZlbiB0aGF0Cj4g TGludXggb3ducyB0aGUgc3RhZ2UtMiB0cmFuc2xhdGlvbiwgdGhlbiB0aGlzIGlzIHRoZSByaWdo dCBwbGFjZSB0byBkbyBpdC4KCk9LLiBCdXQgaXQgc2hvdWxkIGJlIGNvbnRyb2xlZCBieSBTTU1V X0lEUjAuSHlwLiBJIG1lYW5zOgppZiAoU01NVV9JRFIwLkh5cCkKCWV4ZWN1dGUgY29tbWFuZCBD TURRX09QX1RMQklfRUwyX0FMTAoJCldoZW4gU01NVV9JRFIwLkh5cD3igJkw4oCZLCB0aGlzIGNv bW1hbmQgY2F1c2VzIENFUlJPUl9JTEwKCj4gCj4gV2lsbAo+IAo+IC4KPiAKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwppb21tdSBtYWlsaW5nIGxpc3QK aW9tbXVAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5k YXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vaW9tbXU= From mboxrd@z Thu Jan 1 00:00:00 1970 From: thunder.leizhen@huawei.com (leizhen) Date: Wed, 13 May 2015 16:33:19 +0800 Subject: [PATCH 2/3] iommu/arm-smmu: Add initial driver support for ARM SMMUv3 devices In-Reply-To: <20150512165500.GE2062@arm.com> References: <1431108046-9675-1-git-send-email-will.deacon@arm.com> <1431108046-9675-3-git-send-email-will.deacon@arm.com> <5551AE56.6050906@huawei.com> <20150512165500.GE2062@arm.com> Message-ID: <55530C4F.5000605@huawei.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On 2015/5/13 0:55, Will Deacon wrote: > Hi Leizhen, > > Thanks for the review! > > On Tue, May 12, 2015 at 08:40:06AM +0100, leizhen wrote: >> >>> + >>> +static int queue_poll_cons(struct arm_smmu_queue *q, u32 until, bool wfe) >>> +{ >>> + ktime_t timeout = ktime_add_us(ktime_get(), ARM_SMMU_POLL_TIMEOUT_US); >>> + >>> + while (queue_sync_cons(q), __queue_cons_before(q, until)) { >>> + if (ktime_compare(ktime_get(), timeout) > 0) >> >> Is it good to limit hardware behavior? May be wait for ever will be >> better. If SMMU can not consume queue items under normal condition, the >> SMMU hardware is broken, will lead software system to be crashed later. > > I disagree. Having a broken SMMU lock-up the entire kernel is considerably > worse than having e.g. a DMA master get stuck. If this timeout expires, > then we'll print a message and continue without waiting any longer for > a CMD_SYNC completion (see arm_smmu_cmdq_issue_cmd). OK > >>> + return -ETIMEDOUT; >>> + >>> + if (wfe) { >>> + wfe(); >>> + } else { >>> + cpu_relax(); >>> + udelay(1); >>> + } >>> + } >>> + >>> + return 0; >>> +} >>> + >>> +static void queue_write(__le64 *dst, u64 *src, size_t n_dwords) >>> +{ >>> + int i; >>> + >>> + for (i = 0; i < n_dwords; ++i) >>> + *dst++ = cpu_to_le64(*src++); >>> +} >>> + >>> +static int queue_insert_raw(struct arm_smmu_queue *q, u64 *ent) >>> +{ >>> + if (queue_full(q)) >>> + return -ENOSPC; >>> + >>> + queue_write(Q_ENT(q, q->prod), ent, q->ent_dwords); >> >> A dmb or dsb maybe needed. We must insure all data written are completed, >> then notify hardware to consume. > > The dsb is performed when we update the producer pointer in queue_inc_prod > (since we use writel as opposed to writel_relaxed). OK, I saw. > >>> + queue_inc_prod(q); >>> + return 0; >>> +} >>> + >>> + >>> +/* High-level queue accessors */ >>> +static int arm_smmu_cmdq_build_cmd(u64 *cmd, struct arm_smmu_cmdq_ent *ent) >>> +{ >>> + memset(cmd, 0, CMDQ_ENT_DWORDS << 3); >>> + cmd[0] |= (ent->opcode & CMDQ_0_OP_MASK) << CMDQ_0_OP_SHIFT; >>> + >>> + switch (ent->opcode) { >>> + case CMDQ_OP_TLBI_EL2_ALL: >> >>> + case CMDQ_OP_CMD_SYNC: >>> + cmd[0] |= CMDQ_SYNC_0_CS_SEV; >> >> We can not always set SIG_SEV, actually it should base upon >> SMMU_IDR0.SEV(smmu->features & ARM_SMMU_FEAT_SEV) > > It doesn't matter for the CMD_SYNC command (which treats SIG_SEV as > SIG_NONE in this case). What actually matters is that we don't perform > wfe() when the SMMU can't issue the event, but that's already taken care > of in arm_smmu_cmdq_issue_cmd. OK > >>> + break; >>> + default: >>> + return -ENOENT; >>> + } >>> + >>> + return 0; >>> +} >> >>> + >>> +static int arm_smmu_domain_finalise_s1(struct arm_smmu_domain *smmu_domain, >>> + struct io_pgtable_cfg *pgtbl_cfg) >>> +{ >>> + int ret; >>> + u16 asid; >>> + struct arm_smmu_device *smmu = smmu_domain->smmu; >>> + struct arm_smmu_s1_cfg *cfg = &smmu_domain->s1_cfg; >>> + >>> + asid = arm_smmu_bitmap_alloc(smmu->asid_map, smmu->asid_bits); >>> + if (IS_ERR_VALUE(asid)) >>> + return asid; >>> + >>> + cfg->cdptr = dma_zalloc_coherent(smmu->dev, CTXDESC_CD_DWORDS << 3, >>> + &cfg->cdptr_dma, GFP_KERNEL); >> >> Why use dma_zalloc_coherent? iova is coverted from PA by calling >> phys_to_dma. I afraid PA and iova maybe not equal. In fact, the mapping >> between iova and PA is rely on SMMU driver itself. Why not use >> virt_to_phys to get PA, SMMU hardware actually require PA. > > The SMMU structure walker is not allowed to be chained into another SMMU, > so the physical and DMA addresses are equal here. That said, the walker > does not need to be cache coherent, so I need to use the coherent DMA > allocator to get memory of the correct attributes. I also need the table > to be naturally aligned. > > An alternative would be something like __get_free_pages with homebrew > cache maintenance for non-coherent SMMUs, but I don't want to re-invent > the DMA mapping code in the driver (we already have a similar mess with > the page tables, which I'd like to sort out). OK, I have not considered non-coherent SMMU before. But non-coherent SMMU maybe rare. > >>> +static int arm_smmu_alloc_l2_strtab(struct arm_smmu_device *smmu) >>> +{ >>> + int ret; >>> + unsigned int i; >>> + struct arm_smmu_strtab_cfg *cfg = &smmu->strtab_cfg; >>> + size_t size = sizeof(*cfg->l1_desc) * cfg->num_l1_descs; >>> + void *strtab = smmu->strtab_cfg.strtab; >>> + >>> + cfg->l1_desc = devm_kzalloc(smmu->dev, size, GFP_KERNEL); >>> + if (!cfg->l1_desc) { >>> + dev_err(smmu->dev, "failed to allocate l1 stream table desc\n"); >>> + return -ENOMEM; >>> + } >>> + >>> + size = 1 << (STRTAB_SPLIT + ilog2(STRTAB_STE_DWORDS) + 3); >>> + for (i = 0; i < cfg->num_l1_descs; ++i) { >>> + struct arm_smmu_strtab_l1_desc *desc = &cfg->l1_desc[i]; >>> + >>> + desc->span = STRTAB_SPLIT + 1; >>> + desc->l2ptr = dma_zalloc_coherent(smmu->dev, size, >>> + &desc->l2ptr_dma, GFP_KERNEL); >> >> No, no, please don't allocate all Lv2 table memory, we should dynamic >> allocation when needed. Otherwise we can not save memory relative to one >> level table. And cfg->l1_desc seems not necessary. Before create mapping >> for a specified StreamID, we read corresponding Lv1 table entry, if L2Ptr >> is NULL, then we build Lv2 table. Otherwise, means this Lv2 table have >> already been built, because a Lv2 table is shared by a group of StreamIDs. > > The purpose of the two level approach isn't to save memory; it's to remove > the need for a single (large) contiguous block. Furthermore, we need all > master devices in the system to come up in a state where their transactions > bypass the SMMU (i.e. we don't require them to use the SMMU for > translation). Achieving this necessitates a fully-populated stream-table > before any DMA occurs. OK, but for non-pci devices(maybe pci devices also), initialize all devices(StreamIDs) to bypass mode maybe incorrect. Some devices maybe capable bring attributes by itself, and access different memory with different attributes(device attribute or cacheable attribute); some devices maybe not capable bring attributes by itself, but need access memory with cacheable attribute only, so we should set STE.MTCFG = 1. Provide dts configuration will be better. Oh, I can do it after your patches upstreamed, because this problem maybe only I met. Furthermore, I don't agree initialize all devices to bypass by default. Suppose a non-pci device's StreamID can be dynamic configured. We require StreamID-A, but the device actually issue StreamID-B because of software configuration fault. We really hope SMMU can report Bad StreamID fault. > > I suppose we could look into populating it based on the ->add_device > callback, which currently does have some range checks > (arm_smmu_sid_in_range). Is that what you had in mind? Yes, maybe attach_dev. But we should allocated the whole Lv1 table base on SMMU_IDR1.SIDSIZE > >>> + if (!desc->l2ptr) { >>> + dev_err(smmu->dev, >>> + "failed to allocate l2 stream table %u\n", i); >>> + ret = -ENOMEM; >>> + goto out_free_l2; >>> + } >>> + >>> + arm_smmu_init_bypass_stes(desc->l2ptr, 1 << STRTAB_SPLIT); >>> + arm_smmu_write_strtab_l1_desc(strtab, desc); >>> + strtab += STRTAB_STE_DWORDS; >>> + } >>> + >>> + return 0; >>> + >>> +out_free_l2: >>> + arm_smmu_free_l2_strtab(smmu); >>> + return ret; >>> +} >>> + >>> +static int arm_smmu_init_strtab(struct arm_smmu_device *smmu) >>> +{ >>> + void *strtab; >>> + u64 reg; >>> + u32 size; >>> + int ret = 0; >>> + >>> + strtab = dma_zalloc_coherent(smmu->dev, 1 << STRTAB_L1_SZ_SHIFT, >>> + &smmu->strtab_cfg.strtab_dma, GFP_KERNEL); >> >> As above, when Lv2 tables are dynamic allocation, we can create Lv1 table >> base on SMMU_IDR1.SIDSIZE and support non-pic devices. Oh, if SIDSIZE is >> too large, like 32. Maybe we should use 64K size Lv2 table. But we can >> only use PAGE_SIZE first, for lazy. > > Right now, the l2 tables are 4k and l1 table is 8k. That's (a) nice for > allocation on a system with 4k pages and (b) enough to cover a PCI host > controller. The problem with supporting 32-bit SIDs is that the l1 will > become a sizeable contiguous chunk which we'll have to allocate > regardless. > > So, if we keep the l2 size at 4k for the moment, how big would you like > the l1? For a 32-bit numberspace, it would be 4MB, which I don't think is > practical. Yes, because I don't think SMMU_IDR1.SIDSIZE = 32 really exist, so I said use PAGE_SIZE first. But now, this patch only support SMMU_IDR1.SIDSIZE <= 16. Suppose SMMU_IDR1.SIDSIZE = 25?Lv2 table size@4K, then Lv1 table need 2^(25 - 6 + 3) = 2^22 = 4M. If we pre-allocated all Lv2 table, we need 2^25 * 64 = 2^31 = 2G, that's too big. So we must only allocate Lv2 table when we needed. If SMMU_IDR1.SIDSIZE = 32 really exist(or too big), we need dynamic choose Lv2 table size(4K,16K,64K). Because Lv1 table maybe too big, and can not be allocated by current API, a dts configuration should be added, like lv1-table-base = <0x0 0x0>, and we use ioremap_cache get VA(maybe ioremap, for non-coherent SMMU). Oh, I can do it after your patches upstreamed, because this problem maybe only I met. > >>> + if (!strtab) { >>> + dev_err(smmu->dev, "failed to allocate l1 stream table\n"); >>> + return -ENOMEM; >>> + } >>> + smmu->strtab_cfg.strtab = strtab; >>> + >>> + reg = smmu->strtab_cfg.strtab_dma & >>> + STRTAB_BASE_ADDR_MASK << STRTAB_BASE_ADDR_SHIFT; >>> + reg |= STRTAB_BASE_RA; >>> + smmu->strtab_cfg.strtab_base = reg; >>> + >>> + if (smmu->features & ARM_SMMU_FEAT_2_LVL_STRTAB) { >>> + size = STRTAB_L1_SZ_SHIFT - (ilog2(STRTAB_L1_DESC_DWORDS) + 3); >>> + smmu->strtab_cfg.num_l1_descs = 1 << size; >>> + size += STRTAB_SPLIT; >>> + reg = STRTAB_BASE_CFG_FMT_2LVL; >>> + >>> + ret = arm_smmu_alloc_l2_strtab(smmu); >>> + if (ret) >>> + goto out_free_l1; >>> + } else { >>> + size = STRTAB_L1_SZ_SHIFT - (ilog2(STRTAB_STE_DWORDS) + 3); >>> + smmu->strtab_cfg.num_l1_descs = 0; >>> + reg = STRTAB_BASE_CFG_FMT_LINEAR; >>> + arm_smmu_init_bypass_stes(strtab, 1 << size); >>> + } >>> + >>> + if (size < smmu->sid_bits) >>> + dev_warn(smmu->dev, "%s strtab only covers %u/%u bits of SID\n", >>> + smmu->features & ARM_SMMU_FEAT_2_LVL_STRTAB ? >>> + "2-level" : "linear", >>> + size, smmu->sid_bits); >>> + >>> + reg |= (size & STRTAB_BASE_CFG_LOG2SIZE_MASK) >>> + << STRTAB_BASE_CFG_LOG2SIZE_SHIFT; >>> + reg |= (STRTAB_SPLIT & STRTAB_BASE_CFG_SPLIT_MASK) >>> + << STRTAB_BASE_CFG_SPLIT_SHIFT; >>> + smmu->strtab_cfg.strtab_base_cfg = reg; >>> + >>> + /* Allocate the first VMID for stage-2 bypass STEs */ >>> + set_bit(0, smmu->vmid_map); >>> + return 0; >>> + >>> +out_free_l1: >>> + dma_free_coherent(smmu->dev, 1 << STRTAB_L1_SZ_SHIFT, strtab, >>> + smmu->strtab_cfg.strtab_dma); >>> + return ret; >>> +} >>> + >>> +static void arm_smmu_free_strtab(struct arm_smmu_device *smmu) >>> +{ >>> + struct arm_smmu_strtab_cfg *cfg = &smmu->strtab_cfg; >>> + >>> + arm_smmu_free_l2_strtab(smmu); >>> + dma_free_coherent(smmu->dev, 1 << STRTAB_L1_SZ_SHIFT, cfg->strtab, >>> + cfg->strtab_dma); >>> +} >>> + >> >>> + >>> +static int arm_smmu_device_reset(struct arm_smmu_device *smmu) >>> +{ >>> + int ret; >>> + u32 reg, enables; >>> + struct arm_smmu_cmdq_ent cmd; >>> + >>> + /* Clear CR0 and sync (disables SMMU and queue processing) */ >>> + reg = readl_relaxed(smmu->base + ARM_SMMU_CR0); >>> + if (reg & CR0_SMMUEN) >>> + dev_warn(smmu->dev, "SMMU currently enabled! Resetting...\n"); >>> + >>> + ret = arm_smmu_device_disable(smmu); >>> + if (ret) >>> + return ret; >>> + >>> + /* CR1 (table and queue memory attributes) */ >>> + reg = (CR1_SH_ISH << CR1_TABLE_SH_SHIFT) | >>> + (CR1_CACHE_WB << CR1_TABLE_OC_SHIFT) | >>> + (CR1_CACHE_WB << CR1_TABLE_IC_SHIFT) | >>> + (CR1_SH_ISH << CR1_QUEUE_SH_SHIFT) | >>> + (CR1_CACHE_WB << CR1_QUEUE_OC_SHIFT) | >>> + (CR1_CACHE_WB << CR1_QUEUE_IC_SHIFT); >>> + writel_relaxed(reg, smmu->base + ARM_SMMU_CR1); >>> + >>> + /* CR2 (random crap) */ >>> + reg = CR2_PTM | CR2_RECINVMID | CR2_E2H; >> >> Do we need to explicitly set CR2_E2H? Linux only run at EL1. > > Setting E2H won't cause any harm and I'd expect Linux to run there in the > future. If we ever decide to share CPU page tables with the SMMU, then we'll > need this set to participate in DVM. OK > >>> + writel_relaxed(reg, smmu->base + ARM_SMMU_CR2); >>> + >>> + /* Stream table */ >>> + writeq_relaxed(smmu->strtab_cfg.strtab_base, >>> + smmu->base + ARM_SMMU_STRTAB_BASE); >>> + writel_relaxed(smmu->strtab_cfg.strtab_base_cfg, >>> + smmu->base + ARM_SMMU_STRTAB_BASE_CFG); >>> + >>> + /* Command queue */ >>> + writeq_relaxed(smmu->cmdq.q.q_base, smmu->base + ARM_SMMU_CMDQ_BASE); >>> + writel_relaxed(smmu->cmdq.q.prod, smmu->base + ARM_SMMU_CMDQ_PROD); >>> + writel_relaxed(smmu->cmdq.q.cons, smmu->base + ARM_SMMU_CMDQ_CONS); >>> + >>> + enables = CR0_CMDQEN; >>> + ret = arm_smmu_write_reg_sync(smmu, enables, ARM_SMMU_CR0, >>> + ARM_SMMU_CR0ACK); >>> + if (ret) { >>> + dev_err(smmu->dev, "failed to enable command queue\n"); >>> + return ret; >>> + } >>> + >>> + /* Invalidate any cached configuration */ >>> + cmd.opcode = CMDQ_OP_CFGI_ALL; >>> + arm_smmu_cmdq_issue_cmd(smmu, &cmd); >>> + cmd.opcode = CMDQ_OP_CMD_SYNC; >>> + arm_smmu_cmdq_issue_cmd(smmu, &cmd); >>> + >>> + /* Invalidate any stale TLB entries */ >>> + cmd.opcode = CMDQ_OP_TLBI_EL2_ALL; >> >> Do we need to execute CMDQ_OP_TLBI_EL2_ALL? Linux only run at EL1. It at >> least rely on SMMU_IDR0.Hyp > > The SMMU isn't guaranteed to come up clean out of reset, so it's a good > idea to perform this invalidation in case of junk in the TLB. Given that > Linux owns the stage-2 translation, then this is the right place to do it. OK. But it should be controled by SMMU_IDR0.Hyp. I means: if (SMMU_IDR0.Hyp) execute command CMDQ_OP_TLBI_EL2_ALL When SMMU_IDR0.Hyp=?0?, this command causes CERROR_ILL > > Will > > . >