From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christian Zigotzky Subject: Re: use generic DMA mapping code in powerpc V4 Date: Fri, 30 Nov 2018 13:23:20 +0100 Message-ID: <8694431d-c669-b7b9-99fa-e99db5d45a7d@xenosoft.de> References: <20181114082314.8965-1-hch@lst.de> <20181127074253.GB30186@lst.de> <87zhttfonk.fsf@concordia.ellerman.id.au> <4d4e3cdd-d1a9-affe-0f63-45b8c342bbd6@xenosoft.de> <20181129170351.GC27951@lst.de> <20181130105346.GB26765@lst.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20181130105346.GB26765-jcswGhMUV9g@public.gmane.org> Content-Language: de-DE 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: Christoph Hellwig Cc: linux-arch-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Michael Ellerman , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, Paul Mackerras , Benjamin Herrenschmidt , linuxppc-dev-uLR06cmDAlY/bJ5BZ2RsiQ@public.gmane.org List-Id: linux-arch.vger.kernel.org SGkgQ2hyaXN0b3BoLAoKVGhhbmtzIGEgbG90IGZvciB5b3VyIGZhc3QgcmVwbHkuCgpPbiAzMCBO b3ZlbWJlciAyMDE4IGF0IDExOjUzQU0sIENocmlzdG9waCBIZWxsd2lnIHdyb3RlOgo+IEhpIENo cmlzdGlhbiwKPgo+IGZvciBzdWNoIGEgZGl2ZXJzZSBhcmNoaXRlY3R1cmUgbGlrZSBwb3dlcnBj IHdlJ2xsIGhhdmUgdG8gcmVseSBvbgo+IHVzZXJzIC8gbm9uIGNvcmUgZGV2ZWxvcGVycyBsaWtl IHlvdSB0byBoZWxwIHdpdGggdGVzdGluZy4KSSBzZWUuIEkgd2lsbCBoZWxwIGFzIGdvb2QgYXMg SSBjYW4uCj4KPiBDYW4geW91IHRyeSB0aGUgcGF0Y2ggYmVsb3cgZm9yIGhlIGN5cnVzIGNvbmZp Zz8KWWVzLCBvZiBjb3Vyc2UuIEkgcGF0Y2hlZCB5b3VyIEdpdCBrZXJuZWwgYW5kIGFmdGVyIHRo YXQgSSBjb21waWxlZCBpdCAKYWdhaW4uIFUtQm9vdCBsb2FkcyB0aGUga2VybmVsIGFuZCB0aGUg ZHRiIGZpbGUuIFRoZW4gdGhlIGtlcm5lbCBzdGFydHMgCmJ1dCBpdCBkb2Vzbid0IGZpbmQgYW55 IGhhcmQgZGlza3MgKHBhcnRpdGlvbnMpLgoKQEFsbApDb3VsZCB5b3UgcGxlYXNlIGFsc28gdGVz dCBDaHJpc3RvcGgncyBrZXJuZWwgb24geW91ciBQQVNFTUkgYW5kIE5YUCAKYm9hcmRzPyBEb3du bG9hZDogJ2dpdCBjbG9uZSBnaXQ6Ly9naXQuaW5mcmFkZWFkLm9yZy91c2Vycy9oY2gvbWlzYy5n aXQgCi1iIHBvd2VycGMtZG1hLjQgYScKKlBMRUFTRSoKPgo+IEZvciB0aGUgbmVtbyBvbmUgSSBo YXZlIG5vIGlkZWEgeWV0LApXZSBoYWQgc29tZSBwcm9ibGVtcyB3aXRoIHRoZSBQQVNFTUkgZXRo ZXJuZXQgYW5kIERNQSB0d28geWVhcnMgYWdvLiBJIApoYWQgdG8gZGVhY3RpdmF0ZSB0aGUgb3B0 aW9uIFBBU0VNSV9JT01NVV9ETUFfRk9SQ0UuCgpjb21taXQgNDE2ZjM3ZDA4MTZiIHBvd2VycGMv cGFzZW1pOiBGaXggY29oZXJlbnRfZG1hX21hc2sgZm9yIGRtYSBlbmdpbmU6CgpDb21taXQgODE3 ODIwYjAgKCJwb3dlcnBjL2lvbW11OiBTdXBwb3J0ICJoeWJyaWQiIGlvbW11L2RpcmVjdCBETUEK b3BzIGZvciBjb2hlcmVudF9tYXNrIDwgZG1hX21hc2spIGFkZHMgYSBjaGVjayBvZiBjb2hlcmVu dF9kbWFfbWFzayBmb3IKZG1hIGFsbG9jYXRpb25zLgoKVW5mb3J0dW5hdGVseSBjdXJyZW50IFBB U2VtaSBjb2RlIGRvZXMgbm90IHNldCB0aGlzIHZhbHVlIGZvciB0aGUgRE1BCmVuZ2luZSwgd2hp Y2ggZW5kcyB1cCB3aXRoIHRoZSBkZWZhdWx0IHZhbHVlIG9mIDB4ZmZmZmZmZmYsIHRoZSByZXN1 bHQKaXMgb24gYSBQQVNlbWkgc3lzdGVtIHdpdGggPjJHYiByYW0gYW5kIGlvbW11IGVuYWJsZWQg dGhlIG9uYm9hcmQKZXRoZXJuZXQgc3RvcHMgd29ya2luZyBkdWUgdG8gYW4gaW5hYmlsaXR5IHRv IGFsbG9jYXRlIG1lbW9yeS4gQWRkIGFuCmluaXRpYWxpc2F0aW9uIHRvIHBjaV9kbWFfZGV2X3Nl dHVwX3Bhc2VtaSgpLgpTaWduZWQtb2ZmLWJ5OiBEYXJyZW4gU3RldmVucyA8ZGFycmVuQHN0ZXZl bnMtem9uZS5uZXQ+ClNpZ25lZC1vZmYtYnk6IE1pY2hhZWwgRWxsZXJtYW4gPG1wZUBlbGxlcm1h bi5pZC5hdT4KCkxpbmtzOgpodHRwczovL2xpc3RzLm96bGFicy5vcmcvcGlwZXJtYWlsL2xpbnV4 cHBjLWRldi8yMDE2LUp1bHkvMTQ2NzAxLmh0bWwKaHR0cHM6Ly9naXQua2VybmVsLm9yZy9wdWIv c2NtL2xpbnV4L2tlcm5lbC9naXQvdG9ydmFsZHMvbGludXguZ2l0L2NvbW1pdC8/aWQ9NDE2ZjM3 ZDA4MTZiOTcyMGI4MjI3OTUzZTU1OTU0ZDgxNDU2Zjk5MQoKRllJOiBETUEgaGFuZGxpbmcgaGFz IGJlZW4gcmV3cml0dGVuIGluIDIwMTUuIFdlIGhhZCBzb21lIHByb2JsZW1zIHdpdGggCnRoZSBu ZXcgRE1BIGNvZGUgaW4gMjAxNS4gSSBoYWQgdG8gcmV2ZXJ0IHRoZSBjb21taXQgJyBbUkZDL1BB VENILHYyXSAKcG93ZXJwYy9pb21tdTogU3VwcG9ydCAiaHlicmlkIiBpb21tdS9kaXJlY3QgRE1B IG9wcyBmb3IgY29oZXJlbnRfbWFzayA8IApkbWFfbWFzaycgaW4gMjAxNS4KCkxpbms6IGh0dHBz Oi8vcGF0Y2h3b3JrLm96bGFicy5vcmcvcGF0Y2gvNDcyNTM1LwoKSSBoYWQgdG8gY3JlYXRlIGEg cGF0Y2ggaW4gMjAxNToKCiDCoMKgwqAgZGlmZiAtcnVwTiBsaW51eC00LjQvYXJjaC9wb3dlcnBj L0tjb25maWcgCmxpbnV4LTQuNC1uZW1vL2FyY2gvcG93ZXJwYy9LY29uZmlnCiDCoMKgwqAgLS0t IGxpbnV4LTQuNC9hcmNoL3Bvd2VycGMvS2NvbmZpZ8KgwqDCoCAyMDE1LTEyLTA3IDAwOjQzOjEy LjAwMDAwMDAwMCAKKzAxMDAKIMKgwqDCoCArKysgbGludXgtNC40LW5lbW8vYXJjaC9wb3dlcnBj L0tjb25maWfCoMKgwqAgMjAxNS0xMi0wNyAKMTQ6NDg6MjMuMzcxOTg3OTg4ICswMTAwCiDCoMKg wqAgQEAgLTE1OCw4ICsxNTUsNiBAQCBjb25maWcgUFBDCiDCoMKgwqDCoMKgwqDCoMKgIHNlbGVj dCBIQVZFX1BFUkZfRVZFTlRTX05NSSBpZiBQUEM2NAogwqDCoMKgwqDCoMKgwqDCoCBzZWxlY3Qg RURBQ19TVVBQT1JUCiDCoMKgwqDCoMKgwqDCoMKgIHNlbGVjdCBFREFDX0FUT01JQ19TQ1JVQgog wqDCoMKgIC3CoMKgwqAgc2VsZWN0IEFSQ0hfSEFTX0RNQV9TRVRfQ09IRVJFTlRfTUFTSwogwqDC oMKgIC3CoMKgwqAgc2VsZWN0IEhBVkVfQVJDSF9TRUNDT01QX0ZJTFRFUgoKIMKgwqDCoMKgIGNv bmZpZyBHRU5FUklDX0NTVU0KIMKgwqDCoMKgwqDCoMKgwqAgZGVmX2Jvb2wgQ1BVX0xJVFRMRV9F TkRJQU4KIMKgwqDCoCBAQCAtNDE5LDggKzQxNCw3IEBAIGNvbmZpZyBQUEM2NF9TVVBQT1JUU19N RU1PUllfRkFJTFVSRQoKIMKgwqDCoMKgIGNvbmZpZyBLRVhFQwogwqDCoMKgwqDCoMKgwqDCoCBi b29sICJrZXhlYyBzeXN0ZW0gY2FsbCIKIMKgwqDCoCAtwqDCoMKgIGRlcGVuZHMgb24gKFBQQ19C T09LM1MgfHwgRlNMX0JPT0tFIHx8ICg0NHggJiYgIVNNUCkpIHx8IApQUENfQk9PSzNFCiDCoMKg wqAgLcKgwqDCoCBzZWxlY3QgS0VYRUNfQ09SRQogwqDCoMKgICvCoMKgwqAgZGVwZW5kcyBvbiAo UFBDX0JPT0szUyB8fCBGU0xfQk9PS0UgfHwgKDQ0eCAmJiAhU01QKSkKIMKgwqDCoMKgwqDCoMKg wqAgaGVscAogwqDCoMKgwqDCoMKgwqDCoMKgwqAga2V4ZWMgaXMgYSBzeXN0ZW0gY2FsbCB0aGF0 IGltcGxlbWVudHMgdGhlIGFiaWxpdHkgdG8gCnNodXRkb3duIHlvdXIKIMKgwqDCoMKgwqDCoMKg wqDCoMKgIGN1cnJlbnQga2VybmVsLCBhbmQgdG8gc3RhcnQgYW5vdGhlciBrZXJuZWwuwqAgSXQg aXMgbGlrZSBhIApyZWJvb3QKCiDCoMKgwqAgZGlmZiAtcnVwTiBsaW51eC00LjQvYXJjaC9wb3dl cnBjL2tlcm5lbC9kbWEuYyAKbGludXgtNC40LW5lbW8vYXJjaC9wb3dlcnBjL2tlcm5lbC9kbWEu YwogwqDCoMKgIC0tLSBsaW51eC00LjQvYXJjaC9wb3dlcnBjL2tlcm5lbC9kbWEuY8KgwqDCoCAy MDE1LTEyLTA3IAowMDo0MzoxMi4wMDAwMDAwMDAgKzAxMDAKIMKgwqDCoCArKysgbGludXgtNC40 LW5lbW8vYXJjaC9wb3dlcnBjL2tlcm5lbC9kbWEuY8KgwqDCoCAyMDE1LTEyLTA3IAoxNDo0OToz OC4wOTgyODY4OTIgKzAxMDAKIMKgwqDCoCBAQCAtNDAsMzEgKzM5LDkgQEAgc3RhdGljIHU2NCBf X21heWJlX3VudXNlZCBnZXRfcGZuX2xpbWl0KAogwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gcGZu OwogwqDCoMKgwqAgfQoKIMKgwqDCoCAtc3RhdGljIGludCBkbWFfZGlyZWN0X2RtYV9zdXBwb3J0 ZWQoc3RydWN0IGRldmljZSAqZGV2LCB1NjQgbWFzaykKIMKgwqDCoCAtewogwqDCoMKgIC0jaWZk ZWYgQ09ORklHX1BQQzY0CiDCoMKgwqAgLcKgwqDCoCB1NjQgbGltaXQgPSBnZXRfZG1hX29mZnNl dChkZXYpICsgKG1lbWJsb2NrX2VuZF9vZl9EUkFNKCkgLSAxKTsKIMKgwqDCoCAtCiDCoMKgwqAg LcKgwqDCoCAvKiBMaW1pdCBmaXRzIGluIHRoZSBtYXNrLCB3ZSBhcmUgZ29vZCAqLwogwqDCoMKg IC3CoMKgwqAgaWYgKG1hc2sgPj0gbGltaXQpCiDCoMKgwqAgLcKgwqDCoMKgwqDCoMKgIHJldHVy biAxOwogwqDCoMKgIC0KIMKgwqDCoCAtI2lmZGVmIENPTkZJR19GU0xfU09DCiDCoMKgwqAgLcKg wqDCoCAvKiBGcmVlc2NhbGUgZ2V0cyBhbm90aGVyIGNoYW5jZSB2aWEgWk9ORV9ETUEvWk9ORV9E TUEzMiwgaG93ZXZlcgogwqDCoMKgIC3CoMKgwqDCoCAqIHRoYXQgd2lsbCBoYXZlIHRvIGJlIHJl ZmluZWQgaWYvd2hlbiB0aGV5IHN1cHBvcnQgaW9tbXVzCiDCoMKgwqAgLcKgwqDCoMKgICovCiDC oMKgwqAgLcKgwqDCoCByZXR1cm4gMTsKIMKgwqDCoCAtI2VuZGlmCiDCoMKgwqAgLcKgwqDCoCAv KiBTb3JyeSAuLi4gKi8KIMKgwqDCoCAtwqDCoMKgIHJldHVybiAwOwogwqDCoMKgIC0jZWxzZQog wqDCoMKgIC3CoMKgwqAgcmV0dXJuIDE7CiDCoMKgwqAgLSNlbmRpZgogwqDCoMKgIC19CiDCoMKg wqAgLQogwqDCoMKgIC12b2lkICpfX2RtYV9kaXJlY3RfYWxsb2NfY29oZXJlbnQoc3RydWN0IGRl dmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKIMKgwqDCoCAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBkbWFfYWRkcl90ICpkbWFfaGFuZGxlLCBnZnBfdCBmbGFnLAogwqDCoMKgIC3C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJz KQogwqDCoMKgICt2b2lkICpkbWFfZGlyZWN0X2FsbG9jX2NvaGVyZW50KHN0cnVjdCBkZXZpY2Ug KmRldiwgc2l6ZV90IHNpemUsCiDCoMKgwqAgK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBkbWFfYWRkcl90ICpkbWFfaGFuZGxlLCBnZnBfdCBmbGFnLAogwqDCoMKgICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCiDCoMKgwqDCoCB7 CiDCoMKgwqDCoMKgwqDCoMKgIHZvaWQgKnJldDsKIMKgwqDCoMKgICNpZmRlZiBDT05GSUdfTk9U X0NPSEVSRU5UX0NBQ0hFCiDCoMKgwqAgQEAgLTExOSw5ICs5Niw5IEBAIHZvaWQgKl9fZG1hX2Rp cmVjdF9hbGxvY19jb2hlcmVudChzdHJ1Y3QKIMKgwqDCoMKgICNlbmRpZgogwqDCoMKgwqAgfQoK IMKgwqDCoCAtdm9pZCBfX2RtYV9kaXJlY3RfZnJlZV9jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpk ZXYsIHNpemVfdCBzaXplLAogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg dm9pZCAqdmFkZHIsIGRtYV9hZGRyX3QgZG1hX2hhbmRsZSwKIMKgwqDCoCAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQogwqDCoMKgICt2b2lk IGRtYV9kaXJlY3RfZnJlZV9jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXpl LAogwqDCoMKgICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZvaWQgKnZhZGRy LCBkbWFfYWRkcl90IGRtYV9oYW5kbGUsCiDCoMKgwqAgK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCiDCoMKgwqDCoCB7CiDCoMKgwqDC oCAjaWZkZWYgQ09ORklHX05PVF9DT0hFUkVOVF9DQUNIRQogwqDCoMKgwqDCoMKgwqDCoCBfX2Rt YV9mcmVlX2NvaGVyZW50KHNpemUsIHZhZGRyKTsKIMKgwqDCoCBAQCAtMTMwLDUxICsxMDcsNiBA QCB2b2lkIF9fZG1hX2RpcmVjdF9mcmVlX2NvaGVyZW50KHN0cnVjdCBkCiDCoMKgwqDCoCAjZW5k aWYKIMKgwqDCoMKgIH0KCiDCoMKgwqAgLXN0YXRpYyB2b2lkICpkbWFfZGlyZWN0X2FsbG9jX2Nv aGVyZW50KHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IApzaXplLAogwqDCoMKgIC3CoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkbWFfYWRkcl90ICpkbWFfaGFu ZGxlLCBnZnBfdCBmbGFnLAogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCBzdHJ1Y3QgZG1hX2F0dHJzICphdHRycykKIMKgwqDCoCAtewogwqDCoMKg IC3CoMKgwqAgc3RydWN0IGlvbW11X3RhYmxlICppb21tdTsKIMKgwqDCoCAtCiDCoMKgwqAgLcKg wqDCoCAvKiBUaGUgY29oZXJlbnQgbWFzayBtYXkgYmUgc21hbGxlciB0aGFuIHRoZSByZWFsIG1h c2ssIGNoZWNrIGlmCiDCoMKgwqAgLcKgwqDCoMKgICogd2UgY2FuIHJlYWxseSB1c2UgdGhlIGRp cmVjdCBvcHMKIMKgwqDCoCAtwqDCoMKgwqAgKi8KIMKgwqDCoCAtwqDCoMKgIGlmIChkbWFfZGly ZWN0X2RtYV9zdXBwb3J0ZWQoZGV2LCBkZXYtPmNvaGVyZW50X2RtYV9tYXNrKSkKIMKgwqDCoCAt wqDCoMKgwqDCoMKgwqAgcmV0dXJuIF9fZG1hX2RpcmVjdF9hbGxvY19jb2hlcmVudChkZXYsIHNp emUsIGRtYV9oYW5kbGUsCiDCoMKgwqAgLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgZmxhZywgYXR0cnMpOwogwqDCoMKgIC0KIMKgwqDCoCAtwqDC oMKgIC8qIE9rIHdlIGNhbid0IC4uLiBkbyB3ZSBoYXZlIGFuIGlvbW11ID8gSWYgbm90LCBmYWls ICovCiDCoMKgwqAgLcKgwqDCoCBpb21tdSA9IGdldF9pb21tdV90YWJsZV9iYXNlKGRldik7CiDC oMKgwqAgLcKgwqDCoCBpZiAoIWlvbW11KQogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoCByZXR1cm4g TlVMTDsKIMKgwqDCoCAtCiDCoMKgwqAgLcKgwqDCoCAvKiBUcnkgdG8gdXNlIHRoZSBpb21tdSAq LwogwqDCoMKgIC3CoMKgwqAgcmV0dXJuIGlvbW11X2FsbG9jX2NvaGVyZW50KGRldiwgaW9tbXUs IHNpemUsIGRtYV9oYW5kbGUsCiDCoMKgwqAgLcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGRldi0+Y29oZXJlbnRfZG1hX21hc2ssIGZsYWcsCiDCoMKgwqAgLcKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRldl90b19ub2RlKGRldikpOwogwqDCoMKg IC19CiDCoMKgwqAgLQogwqDCoMKgIC1zdGF0aWMgdm9pZCBkbWFfZGlyZWN0X2ZyZWVfY29oZXJl bnQoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKIMKgwqDCoCAtwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2b2lkICp2YWRkciwgZG1hX2FkZHJfdCBkbWFf aGFuZGxlLAogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHN0cnVjdCBkbWFfYXR0cnMgKmF0dHJzKQogwqDCoMKgIC17CiDCoMKgwqAgLcKgwqDCoCBzdHJ1 Y3QgaW9tbXVfdGFibGUgKmlvbW11OwogwqDCoMKgIC0KIMKgwqDCoCAtwqDCoMKgIC8qIFNlZSBj b21tZW50cyBpbiBkbWFfZGlyZWN0X2FsbG9jX2NvaGVyZW50KCkgKi8KIMKgwqDCoCAtwqDCoMKg IGlmIChkbWFfZGlyZWN0X2RtYV9zdXBwb3J0ZWQoZGV2LCBkZXYtPmNvaGVyZW50X2RtYV9tYXNr KSkKIMKgwqDCoCAtwqDCoMKgwqDCoMKgwqAgcmV0dXJuIF9fZG1hX2RpcmVjdF9mcmVlX2NvaGVy ZW50KGRldiwgc2l6ZSwgdmFkZHIsIApkbWFfaGFuZGxlLAogwqDCoMKgIC3CoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBhdHRycyk7CiDCoMKgwqAgLcKg wqDCoCAvKiBNYXliZSB3ZSB1c2VkIGFuIGlvbW11IC4uLiAqLwogwqDCoMKgIC3CoMKgwqAgaW9t bXUgPSBnZXRfaW9tbXVfdGFibGVfYmFzZShkZXYpOwogwqDCoMKgIC0KIMKgwqDCoCAtwqDCoMKg IC8qIElmIHdlIGhpdCB0aGF0IHdlIHNob3VsZCBoYXZlIG5ldmVyIGFsbG9jYXRlZCBpbiB0aGUg Zmlyc3QKIMKgwqDCoCAtwqDCoMKgwqAgKiBwbGFjZSBzbyBob3cgY29tZSB3ZSBhcmUgZnJlZWlu ZyA/CiDCoMKgwqAgLcKgwqDCoMKgICovCiDCoMKgwqAgLcKgwqDCoCBpZiAoV0FSTl9PTighaW9t bXUpKQogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoCByZXR1cm47CiDCoMKgwqAgLcKgwqDCoCBpb21t dV9mcmVlX2NvaGVyZW50KGlvbW11LCBzaXplLCB2YWRkciwgZG1hX2hhbmRsZSk7CiDCoMKgwqAg LX0KIMKgwqDCoCAtCiDCoMKgwqDCoCBpbnQgZG1hX2RpcmVjdF9tbWFwX2NvaGVyZW50KHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IAp2bV9hcmVhX3N0cnVjdCAqdm1hLAogwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90 IGhhbmRsZSwgc2l6ZV90IHNpemUsCiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgc3RydWN0IGRtYV9hdHRycyAqYXR0cnMpCiDCoMKgwqAgQEAgLTIxNSw2ICsxNDcs MTggQEAgc3RhdGljIHZvaWQgZG1hX2RpcmVjdF91bm1hcF9zZyhzdHJ1Y3QgZAogwqDCoMKgwqAg ewogwqDCoMKgwqAgfQoKIMKgwqDCoCArc3RhdGljIGludCBkbWFfZGlyZWN0X2RtYV9zdXBwb3J0 ZWQoc3RydWN0IGRldmljZSAqZGV2LCB1NjQgbWFzaykKIMKgwqDCoCArewogwqDCoMKgICsjaWZk ZWYgQ09ORklHX1BQQzY0CiDCoMKgwqAgK8KgwqDCoCAvKiBDb3VsZCBiZSBpbXByb3ZlZCBzbyBw bGF0Zm9ybXMgY2FuIHNldCB0aGUgbGltaXQgaW4gY2FzZQogwqDCoMKgICvCoMKgwqDCoCAqIHRo ZXkgaGF2ZSBsaW1pdGVkIERNQSB3aW5kb3dzCiDCoMKgwqAgK8KgwqDCoMKgICovCiDCoMKgwqAg K8KgwqDCoCByZXR1cm4gbWFzayA+PSBnZXRfZG1hX29mZnNldChkZXYpICsgKG1lbWJsb2NrX2Vu ZF9vZl9EUkFNKCkgLSAxKTsKIMKgwqDCoCArI2Vsc2UKIMKgwqDCoCArwqDCoMKgIHJldHVybiAx OwogwqDCoMKgICsjZW5kaWYKIMKgwqDCoCArfQogwqDCoMKgICsKIMKgwqDCoMKgIHN0YXRpYyB1 NjQgZG1hX2RpcmVjdF9nZXRfcmVxdWlyZWRfbWFzayhzdHJ1Y3QgZGV2aWNlICpkZXYpCiDCoMKg wqDCoCB7CiDCoMKgwqDCoMKgwqDCoMKgIHU2NCBlbmQsIG1hc2s7CiDCoMKgwqAgQEAgLTI4Niwy NSArMjMwLDYgQEAgc3RydWN0IGRtYV9tYXBfb3BzIGRtYV9kaXJlY3Rfb3BzID0gewogwqDCoMKg wqAgfTsKIMKgwqDCoMKgIEVYUE9SVF9TWU1CT0woZG1hX2RpcmVjdF9vcHMpOwoKIMKgwqDCoCAt aW50IGRtYV9zZXRfY29oZXJlbnRfbWFzayhzdHJ1Y3QgZGV2aWNlICpkZXYsIHU2NCBtYXNrKQog wqDCoMKgIC17CiDCoMKgwqAgLcKgwqDCoCBpZiAoIWRtYV9zdXBwb3J0ZWQoZGV2LCBtYXNrKSkg ewogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoCAvKgogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKgICog V2UgbmVlZCB0byBzcGVjaWFsIGNhc2UgdGhlIGRpcmVjdCBETUEgb3BzIHdoaWNoIGNhbgogwqDC oMKgIC3CoMKgwqDCoMKgwqDCoMKgICogc3VwcG9ydCBhIGZhbGxiYWNrIGZvciBjb2hlcmVudCBh bGxvY2F0aW9ucy4gVGhlcmUKIMKgwqDCoCAtwqDCoMKgwqDCoMKgwqDCoCAqIGlzIG5vIGRtYV9v cC0+c2V0X2NvaGVyZW50X21hc2soKSBzbyB3ZSBoYXZlIHRvIGRvCiDCoMKgwqAgLcKgwqDCoMKg wqDCoMKgwqAgKiB0aGluZ3MgdGhlIGhhcmQgd2F5OgogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKg ICovCiDCoMKgwqAgLcKgwqDCoMKgwqDCoMKgIGlmIChnZXRfZG1hX29wcyhkZXYpICE9ICZkbWFf ZGlyZWN0X29wcyB8fAogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGdldF9pb21tdV90 YWJsZV9iYXNlKGRldikgPT0gTlVMTCB8fAogwqDCoMKgIC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKg ICFkbWFfaW9tbXVfZG1hX3N1cHBvcnRlZChkZXYsIG1hc2spKQogwqDCoMKgIC3CoMKgwqDCoMKg wqDCoMKgwqDCoMKgIHJldHVybiAtRUlPOwogwqDCoMKgIC3CoMKgwqAgfQogwqDCoMKgIC3CoMKg wqAgZGV2LT5jb2hlcmVudF9kbWFfbWFzayA9IG1hc2s7CiDCoMKgwqAgLcKgwqDCoCByZXR1cm4g MDsKIMKgwqDCoCAtfQogwqDCoMKgIC1FWFBPUlRfU1lNQk9MKGRtYV9zZXRfY29oZXJlbnRfbWFz ayk7CiDCoMKgwqAgLQogwqDCoMKgwqAgI2RlZmluZSBQUkVBTExPQ19ETUFfREVCVUdfRU5UUklF UyAoMSA8PCAxNikKCiDCoMKgwqDCoCBpbnQgX19kbWFfc2V0X21hc2soc3RydWN0IGRldmljZSAq ZGV2LCB1NjQgZG1hX21hc2spCgpJbnRlcmVzdGluZyBQQVNFTUkgZXRoZXJuZXQgZmlsZXM6Cgph cmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bhc2VtaS9pb21tdS5jCmRyaXZlcnMvbmV0L2V0aGVybmV0 L3Bhc2VtaS9wYXNlbWlfbWFjLmMKZHJpdmVycy9uZXQvZXRoZXJuZXQvcGFzZW1pL3Bhc2VtaV9t YWMuaApkcml2ZXJzL25ldC9ldGhlcm5ldC9wYXNlbWkvcGFzZW1pX21hY19ldGh0b29sLmMKZHJp dmVycy9uZXQvZXRoZXJuZXQvcGFzZW1pL01ha2VmaWxlCmRyaXZlcnMvbmV0L2V0aGVybmV0L3Bh c2VtaS9LY29uZmlnCgpJIGtub3cgdGhpcyBpcyBhIGxvdCBvZiBpbmZvcm1hdGlvbiBidXQgSSBo b3BlIGl0IGhlbHBzLgoKVGhhbmtzLApDaHJpc3RpYW4KX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KaW9tbXUgbWFpbGluZyBsaXN0CmlvbW11QGxpc3RzLmxp bnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWls bWFuL2xpc3RpbmZvL2lvbW11 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mo4-p01-ob.smtp.rzone.de ([85.215.255.50]:30952 "EHLO mo4-p01-ob.smtp.rzone.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726564AbeK3XdI (ORCPT ); Fri, 30 Nov 2018 18:33:08 -0500 Subject: Re: use generic DMA mapping code in powerpc V4 References: <20181114082314.8965-1-hch@lst.de> <20181127074253.GB30186@lst.de> <87zhttfonk.fsf@concordia.ellerman.id.au> <4d4e3cdd-d1a9-affe-0f63-45b8c342bbd6@xenosoft.de> <20181129170351.GC27951@lst.de> <20181130105346.GB26765@lst.de> From: Christian Zigotzky Message-ID: <8694431d-c669-b7b9-99fa-e99db5d45a7d@xenosoft.de> Date: Fri, 30 Nov 2018 13:23:20 +0100 MIME-Version: 1.0 In-Reply-To: <20181130105346.GB26765@lst.de> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: de-DE Sender: linux-arch-owner@vger.kernel.org List-ID: To: Christoph Hellwig Cc: Michael Ellerman , Benjamin Herrenschmidt , Paul Mackerras , linux-arch@vger.kernel.org, linux-mm@kvack.org, iommu@lists.linux-foundation.org, linuxppc-dev@lists.ozlabs.org, linux-kernel@vger.kernel.org, Olof Johansson Message-ID: <20181130122320.9dBg0hMCqVYeMP_tlrhNkYLOhvMMGmAnyNE5_9NocMI@z> Hi Christoph, Thanks a lot for your fast reply. On 30 November 2018 at 11:53AM, Christoph Hellwig wrote: > Hi Christian, > > for such a diverse architecture like powerpc we'll have to rely on > users / non core developers like you to help with testing. I see. I will help as good as I can. > > Can you try the patch below for he cyrus config? Yes, of course. I patched your Git kernel and after that I compiled it again. U-Boot loads the kernel and the dtb file. Then the kernel starts but it doesn't find any hard disks (partitions). @All Could you please also test Christoph's kernel on your PASEMI and NXP boards? Download: 'git clone git://git.infradead.org/users/hch/misc.git -b powerpc-dma.4 a' *PLEASE* > > For the nemo one I have no idea yet, We had some problems with the PASEMI ethernet and DMA two years ago. I had to deactivate the option PASEMI_IOMMU_DMA_FORCE. commit 416f37d0816b powerpc/pasemi: Fix coherent_dma_mask for dma engine: Commit 817820b0 ("powerpc/iommu: Support "hybrid" iommu/direct DMA ops for coherent_mask < dma_mask) adds a check of coherent_dma_mask for dma allocations. Unfortunately current PASemi code does not set this value for the DMA engine, which ends up with the default value of 0xffffffff, the result is on a PASemi system with >2Gb ram and iommu enabled the onboard ethernet stops working due to an inability to allocate memory. Add an initialisation to pci_dma_dev_setup_pasemi(). Signed-off-by: Darren Stevens Signed-off-by: Michael Ellerman Links: https://lists.ozlabs.org/pipermail/linuxppc-dev/2016-July/146701.html https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=416f37d0816b9720b8227953e55954d81456f991 FYI: DMA handling has been rewritten in 2015. We had some problems with the new DMA code in 2015. I had to revert the commit ' [RFC/PATCH,v2] powerpc/iommu: Support "hybrid" iommu/direct DMA ops for coherent_mask < dma_mask' in 2015. Link: https://patchwork.ozlabs.org/patch/472535/ I had to create a patch in 2015:     diff -rupN linux-4.4/arch/powerpc/Kconfig linux-4.4-nemo/arch/powerpc/Kconfig     --- linux-4.4/arch/powerpc/Kconfig    2015-12-07 00:43:12.000000000 +0100     +++ linux-4.4-nemo/arch/powerpc/Kconfig    2015-12-07 14:48:23.371987988 +0100     @@ -158,8 +155,6 @@ config PPC          select HAVE_PERF_EVENTS_NMI if PPC64          select EDAC_SUPPORT          select EDAC_ATOMIC_SCRUB     -    select ARCH_HAS_DMA_SET_COHERENT_MASK     -    select HAVE_ARCH_SECCOMP_FILTER      config GENERIC_CSUM          def_bool CPU_LITTLE_ENDIAN     @@ -419,8 +414,7 @@ config PPC64_SUPPORTS_MEMORY_FAILURE      config KEXEC          bool "kexec system call"     -    depends on (PPC_BOOK3S || FSL_BOOKE || (44x && !SMP)) || PPC_BOOK3E     -    select KEXEC_CORE     +    depends on (PPC_BOOK3S || FSL_BOOKE || (44x && !SMP))          help            kexec is a system call that implements the ability to shutdown your            current kernel, and to start another kernel.  It is like a reboot     diff -rupN linux-4.4/arch/powerpc/kernel/dma.c linux-4.4-nemo/arch/powerpc/kernel/dma.c     --- linux-4.4/arch/powerpc/kernel/dma.c    2015-12-07 00:43:12.000000000 +0100     +++ linux-4.4-nemo/arch/powerpc/kernel/dma.c    2015-12-07 14:49:38.098286892 +0100     @@ -40,31 +39,9 @@ static u64 __maybe_unused get_pfn_limit(          return pfn;      }     -static int dma_direct_dma_supported(struct device *dev, u64 mask)     -{     -#ifdef CONFIG_PPC64     -    u64 limit = get_dma_offset(dev) + (memblock_end_of_DRAM() - 1);     -     -    /* Limit fits in the mask, we are good */     -    if (mask >= limit)     -        return 1;     -     -#ifdef CONFIG_FSL_SOC     -    /* Freescale gets another chance via ZONE_DMA/ZONE_DMA32, however     -     * that will have to be refined if/when they support iommus     -     */     -    return 1;     -#endif     -    /* Sorry ... */     -    return 0;     -#else     -    return 1;     -#endif     -}     -     -void *__dma_direct_alloc_coherent(struct device *dev, size_t size,     -                  dma_addr_t *dma_handle, gfp_t flag,     -                  struct dma_attrs *attrs)     +void *dma_direct_alloc_coherent(struct device *dev, size_t size,     +                dma_addr_t *dma_handle, gfp_t flag,     +                struct dma_attrs *attrs)      {          void *ret;      #ifdef CONFIG_NOT_COHERENT_CACHE     @@ -119,9 +96,9 @@ void *__dma_direct_alloc_coherent(struct      #endif      }     -void __dma_direct_free_coherent(struct device *dev, size_t size,     -                void *vaddr, dma_addr_t dma_handle,     -                struct dma_attrs *attrs)     +void dma_direct_free_coherent(struct device *dev, size_t size,     +                  void *vaddr, dma_addr_t dma_handle,     +                  struct dma_attrs *attrs)      {      #ifdef CONFIG_NOT_COHERENT_CACHE          __dma_free_coherent(size, vaddr);     @@ -130,51 +107,6 @@ void __dma_direct_free_coherent(struct d      #endif      }     -static void *dma_direct_alloc_coherent(struct device *dev, size_t size,     -                       dma_addr_t *dma_handle, gfp_t flag,     -                       struct dma_attrs *attrs)     -{     -    struct iommu_table *iommu;     -     -    /* The coherent mask may be smaller than the real mask, check if     -     * we can really use the direct ops     -     */     -    if (dma_direct_dma_supported(dev, dev->coherent_dma_mask))     -        return __dma_direct_alloc_coherent(dev, size, dma_handle,     -                           flag, attrs);     -     -    /* Ok we can't ... do we have an iommu ? If not, fail */     -    iommu = get_iommu_table_base(dev);     -    if (!iommu)     -        return NULL;     -     -    /* Try to use the iommu */     -    return iommu_alloc_coherent(dev, iommu, size, dma_handle,     -                    dev->coherent_dma_mask, flag,     -                    dev_to_node(dev));     -}     -     -static void dma_direct_free_coherent(struct device *dev, size_t size,     -                     void *vaddr, dma_addr_t dma_handle,     -                     struct dma_attrs *attrs)     -{     -    struct iommu_table *iommu;     -     -    /* See comments in dma_direct_alloc_coherent() */     -    if (dma_direct_dma_supported(dev, dev->coherent_dma_mask))     -        return __dma_direct_free_coherent(dev, size, vaddr, dma_handle,     -                          attrs);     -    /* Maybe we used an iommu ... */     -    iommu = get_iommu_table_base(dev);     -     -    /* If we hit that we should have never allocated in the first     -     * place so how come we are freeing ?     -     */     -    if (WARN_ON(!iommu))     -        return;     -    iommu_free_coherent(iommu, size, vaddr, dma_handle);     -}     -      int dma_direct_mmap_coherent(struct device *dev, struct vm_area_struct *vma,                       void *cpu_addr, dma_addr_t handle, size_t size,                       struct dma_attrs *attrs)     @@ -215,6 +147,18 @@ static void dma_direct_unmap_sg(struct d      {      }     +static int dma_direct_dma_supported(struct device *dev, u64 mask)     +{     +#ifdef CONFIG_PPC64     +    /* Could be improved so platforms can set the limit in case     +     * they have limited DMA windows     +     */     +    return mask >= get_dma_offset(dev) + (memblock_end_of_DRAM() - 1);     +#else     +    return 1;     +#endif     +}     +      static u64 dma_direct_get_required_mask(struct device *dev)      {          u64 end, mask;     @@ -286,25 +230,6 @@ struct dma_map_ops dma_direct_ops = {      };      EXPORT_SYMBOL(dma_direct_ops);     -int dma_set_coherent_mask(struct device *dev, u64 mask)     -{     -    if (!dma_supported(dev, mask)) {     -        /*     -         * We need to special case the direct DMA ops which can     -         * support a fallback for coherent allocations. There     -         * is no dma_op->set_coherent_mask() so we have to do     -         * things the hard way:     -         */     -        if (get_dma_ops(dev) != &dma_direct_ops ||     -            get_iommu_table_base(dev) == NULL ||     -            !dma_iommu_dma_supported(dev, mask))     -            return -EIO;     -    }     -    dev->coherent_dma_mask = mask;     -    return 0;     -}     -EXPORT_SYMBOL(dma_set_coherent_mask);     -      #define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)      int __dma_set_mask(struct device *dev, u64 dma_mask) Interesting PASEMI ethernet files: arch/powerpc/platforms/pasemi/iommu.c drivers/net/ethernet/pasemi/pasemi_mac.c drivers/net/ethernet/pasemi/pasemi_mac.h drivers/net/ethernet/pasemi/pasemi_mac_ethtool.c drivers/net/ethernet/pasemi/Makefile drivers/net/ethernet/pasemi/Kconfig I know this is a lot of information but I hope it helps. Thanks, Christian