From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lorenzo Pieralisi Subject: Re: [PATCH V5 05/12] drivers: platform: Configure dma operations at probe time Date: Thu, 19 Jan 2017 19:02:50 +0000 Message-ID: <20170119190250.GA11181@red-moon> References: <1484838356-24962-1-git-send-email-sricharan@codeaurora.org> <1484838356-24962-6-git-send-email-sricharan@codeaurora.org> <327b5a9b-35f6-f6e0-4ef9-d2ed15bb4e49@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <327b5a9b-35f6-f6e0-4ef9-d2ed15bb4e49-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: Robin Murphy Cc: linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, will.deacon-5wv7dgnIgG8@public.gmane.org, iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org List-Id: linux-arm-msm@vger.kernel.org T24gVGh1LCBKYW4gMTksIDIwMTcgYXQgMDU6NDk6NThQTSArMDAwMCwgUm9iaW4gTXVycGh5IHdy b3RlOgo+IE9uIDE5LzAxLzE3IDE1OjA1LCBTcmljaGFyYW4gUiB3cm90ZToKPiA+IENvbmZpZ3Vy aW5nIERNQSBvcHMgYXQgcHJvYmUgdGltZSB3aWxsIGFsbG93IGRlZmVycmluZyBkZXZpY2UgcHJv YmUgd2hlbgo+ID4gdGhlIElPTU1VIGlzbid0IGF2YWlsYWJsZSB5ZXQuIFRoZSBkbWFfY29uZmln dXJlIGZvciB0aGUgZGV2aWNlIGlzCj4gPiBub3cgY2FsbGVkIGZyb20gdGhlIGdlbmVyaWMgZGV2 aWNlX2F0dGFjaCBjYWxsYmFjayBqdXN0IGJlZm9yZSB0aGUKPiA+IGJ1cy9kcml2ZXIgcHJvYmUg aXMgY2FsbGVkLiBUaGlzIHdheSwgY29uZmlndXJpbmcgdGhlIERNQSBvcHMgZm9yIHRoZQo+ID4g ZGV2aWNlIHdvdWxkIGJlIGNhbGxlZCBhdCB0aGUgc2FtZSBwbGFjZSBmb3IgYWxsIGJ1c190eXBl cywgaGVuY2UgdGhlCj4gPiBkZWZlcnJlZCBwcm9iaW5nIG1lY2hhbmlzbSBzaG91bGQgd29yayBm b3IgYWxsIGJ1c2VzIGFzIHdlbGwuCj4gPiAKPiA+IHBjaV9idXNfYWRkX2RldmljZXMgICAgKHBs YXRmb3JtL2FtYmEpKF9kZXZpY2VfY3JlYXRlL2RyaXZlcl9yZWdpc3RlcikKPiA+ICAgICAgICB8 ICAgICAgICAgICAgICAgICAgICAgICAgIHwKPiA+IHBjaV9idXNfYWRkX2RldmljZSAgICAgKGRl dmljZV9hZGQvZHJpdmVyX3JlZ2lzdGVyKQo+ID4gICAgICAgIHwgICAgICAgICAgICAgICAgICAg ICAgICAgfAo+ID4gZGV2aWNlX2F0dGFjaCAgICAgICAgICAgZGV2aWNlX2luaXRpYWxfcHJvYmUK PiA+ICAgICAgICB8ICAgICAgICAgICAgICAgICAgICAgICAgIHwKPiA+IF9fZGV2aWNlX2F0dGFj aF9kcml2ZXIgICAgX19kZXZpY2VfYXR0YWNoX2RyaXZlcgo+ID4gICAgICAgIHwKPiA+IGRyaXZl cl9wcm9iZV9kZXZpY2UKPiA+ICAgICAgICB8Cj4gPiByZWFsbHlfcHJvYmUKPiA+ICAgICAgICB8 Cj4gPiBkbWFfY29uZmlndXJlCj4gPiAKPiA+IFNpbWlsYXJseSBvbiB0aGUgZGV2aWNlL2RyaXZl cl91bnJlZ2lzdGVyIHBhdGggX19kZXZpY2VfcmVsZWFzZV9kcml2ZXIgaXMKPiA+IGNhbGxlZCB3 aGljaCBpbnR1cm4gY2FsbHMgZG1hX2RlY29uZmlndXJlLgo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5 OiBTcmljaGFyYW4gUiA8c3JpY2hhcmFuQGNvZGVhdXJvcmEub3JnPgo+ID4gLS0tCj4gPiAgKiBS ZW1vdmVkIHRoZSBkbWEgY29uZmlndXJhdGlvbiBmb3IgdGhlIHBjaSBkZXZpY2VzIGluIGNhc2Ug b2YgRFQKPiA+ICAgIGZyb20gcGNpX2RtYV9jb25maWd1cmUgd2hpY2ggd2FzIGhhbmdpbmcgb3V0 c2lkZSBzZXBhcmF0ZWx5IGFuZAo+ID4gICAgZG9pbmcgaXQgaW4gZG1hX2NvbmZpZ3VyZSBmdW5j dGlvbiBpdHNlbGYuCj4gPiAKPiA+ICBkcml2ZXJzL2Jhc2UvZGQuYyAgICAgICAgICAgfCAgOSAr KysrKysrKysKPiA+ICBkcml2ZXJzL2Jhc2UvZG1hLW1hcHBpbmcuYyAgfCAzMiArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKwo+ID4gIGRyaXZlcnMvb2YvcGxhdGZvcm0uYyAgICAgICB8 ICA1ICstLS0tCj4gPiAgZHJpdmVycy9wY2kvcHJvYmUuYyAgICAgICAgIHwgIDUgKy0tLS0KPiA+ ICBpbmNsdWRlL2xpbnV4L2RtYS1tYXBwaW5nLmggfCAgMyArKysKPiA+ICA1IGZpbGVzIGNoYW5n ZWQsIDQ2IGluc2VydGlvbnMoKyksIDggZGVsZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2Jhc2UvZGQuYyBiL2RyaXZlcnMvYmFzZS9kZC5jCj4gPiBpbmRleCBhMWZiZjU1 Li40ODgyZjA2IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9iYXNlL2RkLmMKPiA+ICsrKyBiL2Ry aXZlcnMvYmFzZS9kZC5jCj4gPiBAQCAtMTksNiArMTksNyBAQAo+ID4gIAo+ID4gICNpbmNsdWRl IDxsaW51eC9kZXZpY2UuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KPiA+ICsjaW5j bHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ Cj4gPiAgI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvd2Fp dC5oPgo+ID4gQEAgLTM1Niw2ICszNTcsMTAgQEAgc3RhdGljIGludCByZWFsbHlfcHJvYmUoc3Ry dWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2KQo+ID4gIAlpZiAocmV0 KQo+ID4gIAkJZ290byBwaW5jdHJsX2JpbmRfZmFpbGVkOwo+ID4gIAo+ID4gKwlyZXQgPSBkbWFf Y29uZmlndXJlKGRldik7Cj4gPiArCWlmIChyZXQpCj4gPiArCQlnb3RvIGRtYV9mYWlsZWQ7Cj4g PiArCj4gPiAgCWlmIChkcml2ZXJfc3lzZnNfYWRkKGRldikpIHsKPiA+ICAJCXByaW50ayhLRVJO X0VSUiAiJXM6IGRyaXZlcl9zeXNmc19hZGQoJXMpIGZhaWxlZFxuIiwKPiA+ICAJCQlfX2Z1bmNf XywgZGV2X25hbWUoZGV2KSk7Cj4gPiBAQCAtNDE3LDYgKzQyMiw4IEBAIHN0YXRpYyBpbnQgcmVh bGx5X3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9kcml2ZXIgKmRydikK PiA+ICAJZ290byBkb25lOwo+ID4gIAo+ID4gIHByb2JlX2ZhaWxlZDoKPiA+ICsJZG1hX2RlY29u ZmlndXJlKGRldik7Cj4gPiArZG1hX2ZhaWxlZDoKPiA+ICAJaWYgKGRldi0+YnVzKQo+ID4gIAkJ YmxvY2tpbmdfbm90aWZpZXJfY2FsbF9jaGFpbigmZGV2LT5idXMtPnAtPmJ1c19ub3RpZmllciwK PiA+ICAJCQkJCSAgICAgQlVTX05PVElGWV9EUklWRVJfTk9UX0JPVU5ELCBkZXYpOwo+ID4gQEAg LTgyNiw2ICs4MzMsOCBAQCBzdGF0aWMgdm9pZCBfX2RldmljZV9yZWxlYXNlX2RyaXZlcihzdHJ1 Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKnBhcmVudCkKPiA+ICAJCQlkcnYtPnJlbW92 ZShkZXYpOwo+ID4gIAo+ID4gIAkJZGV2aWNlX2xpbmtzX2RyaXZlcl9jbGVhbnVwKGRldik7Cj4g PiArCQlkbWFfZGVjb25maWd1cmUoZGV2KTsKPiA+ICsKPiA+ICAJCWRldnJlc19yZWxlYXNlX2Fs bChkZXYpOwo+ID4gIAkJZGV2LT5kcml2ZXIgPSBOVUxMOwo+ID4gIAkJZGV2X3NldF9kcnZkYXRh KGRldiwgTlVMTCk7Cj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL2RtYS1tYXBwaW5nLmMg Yi9kcml2ZXJzL2Jhc2UvZG1hLW1hcHBpbmcuYwo+ID4gaW5kZXggZWZkNzFjZi4uZGZlNmZkNyAx MDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvYmFzZS9kbWEtbWFwcGluZy5jCj4gPiArKysgYi9kcml2 ZXJzL2Jhc2UvZG1hLW1hcHBpbmcuYwo+ID4gQEAgLTEwLDYgKzEwLDcgQEAKPiA+ICAjaW5jbHVk ZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+Cj4g PiAgI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2Uu aD4KPiA+ICAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC92bWFs bG9jLmg+Cj4gPiAgCj4gPiBAQCAtMzQxLDMgKzM0MiwzNCBAQCB2b2lkIGRtYV9jb21tb25fZnJl ZV9yZW1hcCh2b2lkICpjcHVfYWRkciwgc2l6ZV90IHNpemUsIHVuc2lnbmVkIGxvbmcgdm1fZmxh Z3MpCj4gPiAgCXZ1bm1hcChjcHVfYWRkcik7Cj4gPiAgfQo+ID4gICNlbmRpZgo+ID4gKwo+ID4g Ky8qCj4gPiArICogQ29tbW9uIGNvbmZpZ3VyYXRpb24gdG8gZW5hYmxlIERNQSBBUEkgdXNlIGZv ciBhIGRldmljZQo+ID4gKyAqLwo+ID4gKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KPiA+ICsKPiA+ ICtpbnQgZG1hX2NvbmZpZ3VyZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gPiArewo+ID4gKwlzdHJ1 Y3QgZGV2aWNlICpfZGV2ID0gZGV2Owo+ID4gKwlpbnQgaXNfcGNpID0gZGV2X2lzX3BjaShkZXYp Owo+ID4gKwo+ID4gKwlpZiAoaXNfcGNpKSB7Cj4gPiArCQlfZGV2ID0gcGNpX2dldF9ob3N0X2Jy aWRnZV9kZXZpY2UodG9fcGNpX2RldihkZXYpKTsKPiA+ICsJCWlmIChJU19FTkFCTEVEKENPTkZJ R19PRikgJiYgX2Rldi0+cGFyZW50ICYmCj4gPiArCQkgICAgX2Rldi0+cGFyZW50LT5vZl9ub2Rl KQo+ID4gKwkJCV9kZXYgPSBfZGV2LT5wYXJlbnQ7Cj4gPiArCX0KPiA+ICsKPiA+ICsJaWYgKF9k ZXYtPm9mX25vZGUpCj4gPiArCQlvZl9kbWFfY29uZmlndXJlKGRldiwgX2Rldi0+b2Zfbm9kZSk7 Cj4gPiArCj4gPiArCWlmIChpc19wY2kpCj4gPiArCQlwY2lfcHV0X2hvc3RfYnJpZGdlX2Rldmlj ZShfZGV2KTsKPiAKPiBUaGVyZSdzIGEgZnVuIGJ1ZyBoZXJlIC0gYXQgdGhpcyBwb2ludCBfZGV2 IGlzIHRoZSAqcGFyZW50KiBvZiB0aGUKPiBicmlkZ2UgZGV2aWNlLCBzbyB3ZSBwdXQgdGhlIHJl ZmNvdW50IG9uIHRoZSB3cm9uZyBkZXZpY2UgKHRoZSBwbGF0Zm9ybQo+IGRldmljZSByZXByZXNl bnRpbmcgdGhlIGhvc3QgY29udHJvbGxlciwgcmF0aGVyIHRoYW4gdGhlIFBDSSBkZXZpY2UKPiBy ZXByZXNlbnRpbmcgaXRzIGluc2lkZXMpLCB3aGljaCBmcmVlcyB0aGUgZ3V5IHdlJ3JlIGluIHRo ZSBtaWRkbGUgb2YKPiBwcm9iaW5nLCBhbmQgdGhpbmdzIHJhcGlkbHkgZ28gd3JvbmcgYWZ0ZXJ3 YXJkczoKPiAKPiBbICAgIDEuNDYxMDI2XSBidXM6ICdwbGF0Zm9ybSc6IGRyaXZlcl9wcm9iZV9k ZXZpY2U6IG1hdGNoZWQgZGV2aWNlCj4gNDAwMDAwMDAucGNpZS1jb250cm9sbGVyIHdpdGggZHJp dmVyIHBjaS1ob3N0LWdlbmVyaWMKPiBbICAgIDEuNDcxNjQwXSBidXM6ICdwbGF0Zm9ybSc6IHJl YWxseV9wcm9iZTogcHJvYmluZyBkcml2ZXIKPiBwY2ktaG9zdC1nZW5lcmljIHdpdGggZGV2aWNl IDQwMDAwMDAwLnBjaWUtY29udHJvbGxlcgo+IFsgICAgMS40ODE2NzhdIE9GOiBQQ0k6IGhvc3Qg YnJpZGdlIC9wY2llLWNvbnRyb2xsZXJANDAwMDAwMDAgcmFuZ2VzOgo+IAo+IC4uLgo+IAo+IFsg ICAgMi4xNTgyNTldIGJ1czogJ3BjaSc6IGRyaXZlcl9wcm9iZV9kZXZpY2U6IG1hdGNoZWQgZGV2 aWNlCj4gMDAwMDowMjoxMC4wIHdpdGggZHJpdmVyIHBjaWVwb3J0Cj4gWyAgICAyLjE2NjcxNl0g YnVzOiAncGNpJzogcmVhbGx5X3Byb2JlOiBwcm9iaW5nIGRyaXZlciBwY2llcG9ydCB3aXRoCj4g ZGV2aWNlIDAwMDA6MDI6MTAuMAo+IFsgICAgMi4xNzQ1OTBdIHBjaSAwMDAwOjAyOjEwLjA6IERy aXZlciBwY2llcG9ydCByZXF1ZXN0cyBwcm9iZSBkZWZlcnJhbAo+IFsgICAgMi4xODA5NzhdIHBj aSAwMDAwOjAyOjEwLjA6IEFkZGVkIHRvIGRlZmVycmVkIGxpc3QKPiBbICAgIDIuMTg1OTE1XSBi dXM6ICdwY2knOiBkcml2ZXJfcHJvYmVfZGV2aWNlOiBtYXRjaGVkIGRldmljZQo+IDAwMDA6MDI6 MWYuMCB3aXRoIGRyaXZlciBwY2llcG9ydAo+IFsgICAgMi4xOTQzNjZdIGJ1czogJ3BjaSc6IHJl YWxseV9wcm9iZTogcHJvYmluZyBkcml2ZXIgcGNpZXBvcnQgd2l0aAo+IGRldmljZSAwMDAwOjAy OjFmLjAKPiBbICAgIDIuMjAyMjM3XSBwY2kgMDAwMDowMjoxZi4wOiBEcml2ZXIgcGNpZXBvcnQg cmVxdWVzdHMgcHJvYmUgZGVmZXJyYWwKPiBbICAgIDIuMjA4NjI1XSBwY2kgMDAwMDowMjoxZi4w OiBBZGRlZCB0byBkZWZlcnJlZCBsaXN0Cj4gWyAgICAyLjIxMzU4Ml0gZHJpdmVyOiAncGNpLWhv c3QtZ2VuZXJpYyc6IGRyaXZlcl9ib3VuZDogYm91bmQgdG8gZGV2aWNlCj4gJ++/ve+/ve+/vXbv v73vv73vv73vv70ucGNpZS1jb250cm9sbGVyJwo+IFsgICAgMi4yMjIyOTNdIGJ1czogJ3BsYXRm b3JtJzogcmVhbGx5X3Byb2JlOiBib3VuZCBkZXZpY2UKPiDvv73vv73vv71277+977+977+977+9 LnBjaWUtY29udHJvbGxlciB0byBkcml2ZXIgcGNpLWhvc3QtZ2VuZXJpYwo+IFsgICAgMi4yMzIw NDFdIFVuYWJsZSB0byBoYW5kbGUga2VybmVsIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSBhdAo+ IHZpcnR1YWwgYWRkcmVzcyAwMDAwMDAwMAo+IAo+IEkgcmVjYWxsIGRlYnVnZ2luZyB0aGlzIHNh bWUgaXNzdWUgYmVmb3JlLCBhbmQgSSBzZWVtIHRvIGhhdmUgYSBsb2NhbAo+IHZlcnNpb24gb2Yg dGhpcyBjb21taXQgZGF0ZWQgYWJvdXQgNiB3ZWVrcyBhZ28gd2hlcmUgZG1hX2NvbmZpZ3VyZSgp Cj4gbG9va3MgbGlrZSB0aGlzOgo+IAo+IC0tLT44LS0tCj4gaW50IGRtYV9jb25maWd1cmUoc3Ry dWN0IGRldmljZSAqZGV2KQo+IHsKPiAJc3RydWN0IGRldmljZSAqYnJpZGdlID0gTlVMTCwgKmRt YV9kZXYgPSBkZXY7Cj4gCj4gCWlmIChkZXZfaXNfcGNpKGRldikpIHsKPiAJCWJyaWRnZSA9IHBj aV9nZXRfaG9zdF9icmlkZ2VfZGV2aWNlKHRvX3BjaV9kZXYoZGV2KSk7Cj4gCQlkbWFfZGV2ID0g YnJpZGdlLT5wYXJlbnQ7CgpUaGlzIHdvdWxkIGJyZWFrIEFDUEksIGRtYV9kZXYgd291bGQgYmUg TlVMTCBoZXJlLCBzbyBmcm9tCnRoaXMgc3RhbmRwb2ludCAoQUNQSSkgdGhlIGN1cnJlbnQgcGF0 Y2ggaXMgY29ycmVjdCAoYnV0IHRob3NlIFtkZXYsX2Rldl0Kc2hvdWxkIGJlIHJlbmFtZWQsIHRo ZXkgYXJlIGV4dHJlbWVseSBtaXNsZWFkaW5nIHNvIG5hbWluZyBhcwppbiB0aGlzIGh1bmssIHdo aWNoIGZpeGVzIERUIHRvbywgaXMgdmVyeSB3ZWxjb21lKS4KCk9uIEFDUEkgdGhlIERNQSBhdHRy aWJ1dGVzIGFyZSBjaGVja2VkIG9uIHRoZSBicmlkZ2UncyBjb21wYW5pb24KKGllIGl0cyBhc3Nv Y2lhdGVkIGFjcGlfZGV2aWNlKS4KClRoYW5rcywKTG9yZW56bwoKPiAJfQo+IAo+IAlpZiAoZG1h X2RldiAmJiBkbWFfZGV2LT5vZl9ub2RlKSB7Cj4gCQlvZl9kbWFfY29uZmlndXJlKGRldiwgZG1h X2Rldi0+b2Zfbm9kZSk7Cj4gCX0gZWxzZSBpZiAoZG1hX2RldiAmJiBoYXNfYWNwaV9jb21wYW5p b24oZG1hX2RldikpIHsKPiAJCXN0cnVjdCBhY3BpX2RldmljZSAqYWRldiA9IHRvX2FjcGlfZGV2 aWNlX25vZGUoZG1hX2Rldi0+Zndub2RlKTsKPiAJCWVudW0gZGV2X2RtYV9hdHRyIGF0dHIgPSBh Y3BpX2dldF9kbWFfYXR0cihhZGV2KTsKPiAKPiAJCWlmIChhdHRyID09IERFVl9ETUFfTk9UX1NV UFBPUlRFRCkKPiAJCQlkZXZfd2FybihkZXYsICJETUEgbm90IHN1cHBvcnRlZC5cbiIpOwo+IAkJ ZWxzZQo+IAkJCWFyY2hfc2V0dXBfZG1hX29wcyhkZXYsIDAsIDAsIE5VTEwsCj4gCQkJCQkgICBh dHRyID09IERFVl9ETUFfQ09IRVJFTlQpOwo+IAl9Cj4gCj4gCWlmIChicmlkZ2UpCj4gCQlwY2lf cHV0X2hvc3RfYnJpZGdlX2RldmljZShicmlkZ2UpOwo+IAo+IAlyZXR1cm4gMDsKPiB9Cj4gLS0t ODwtLS0KPiAKPiBJIGhhdmUgYSBmZWVsaW5nIEkgd2FzIGhhdmluZyBhIGdvIGF0IHRpZHlpbmcg dXAgdGhlICJQQ0kgaGFja3MiIGZyb20gdjQKPiBteXNlbGYsIGJ1dCBvdGhlciB0aGluZ3MgZW5k ZWQgdXAgdGFraW5nIHByZWNlZGVuY2UuCj4gCj4gUm9iaW4uCj4gCj4gPiArCj4gPiArCXJldHVy biAwOwo+ID4gK30KPiA+ICsKPiA+ICt2b2lkIGRtYV9kZWNvbmZpZ3VyZShzdHJ1Y3QgZGV2aWNl ICpkZXYpCj4gPiArewo+ID4gKwlvZl9kbWFfZGVjb25maWd1cmUoZGV2KTsKPiA+ICt9Cj4gPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9vZi9wbGF0Zm9ybS5jIGIvZHJpdmVycy9vZi9wbGF0Zm9ybS5j Cj4gPiBpbmRleCA1NzQxOGY3Li5jZjM1MDMwIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9vZi9w bGF0Zm9ybS5jCj4gPiArKysgYi9kcml2ZXJzL29mL3BsYXRmb3JtLmMKPiA+IEBAIC0yMiw2ICsy Miw3IEBACj4gPiAgI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgv b2ZfYWRkcmVzcy5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4KPiA+ICsjaW5j bHVkZSA8bGludXgvb2ZfaW9tbXUuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvb2ZfaXJxLmg+Cj4g PiAgI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3JtLmg+Cj4gPiAgI2luY2x1ZGUgPGxpbnV4L3Bs YXRmb3JtX2RldmljZS5oPgo+ID4gQEAgLTE4NiwxMSArMTg3LDkgQEAgc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKm9mX3BsYXRmb3JtX2RldmljZV9jcmVhdGVfcGRhdGEoCj4gPiAgCj4g PiAgCWRldi0+ZGV2LmJ1cyA9ICZwbGF0Zm9ybV9idXNfdHlwZTsKPiA+ICAJZGV2LT5kZXYucGxh dGZvcm1fZGF0YSA9IHBsYXRmb3JtX2RhdGE7Cj4gPiAtCW9mX2RtYV9jb25maWd1cmUoJmRldi0+ ZGV2LCBkZXYtPmRldi5vZl9ub2RlKTsKPiA+ICAJb2ZfbXNpX2NvbmZpZ3VyZSgmZGV2LT5kZXYs IGRldi0+ZGV2Lm9mX25vZGUpOwo+ID4gIAo+ID4gIAlpZiAob2ZfZGV2aWNlX2FkZChkZXYpICE9 IDApIHsKPiA+IC0JCW9mX2RtYV9kZWNvbmZpZ3VyZSgmZGV2LT5kZXYpOwo+ID4gIAkJcGxhdGZv cm1fZGV2aWNlX3B1dChkZXYpOwo+ID4gIAkJZ290byBlcnJfY2xlYXJfZmxhZzsKPiA+ICAJfQo+ ID4gQEAgLTI0OCw3ICsyNDcsNiBAQCBzdGF0aWMgc3RydWN0IGFtYmFfZGV2aWNlICpvZl9hbWJh X2RldmljZV9jcmVhdGUoc3RydWN0IGRldmljZV9ub2RlICpub2RlLAo+ID4gIAkJZGV2X3NldF9u YW1lKCZkZXYtPmRldiwgIiVzIiwgYnVzX2lkKTsKPiA+ICAJZWxzZQo+ID4gIAkJb2ZfZGV2aWNl X21ha2VfYnVzX2lkKCZkZXYtPmRldik7Cj4gPiAtCW9mX2RtYV9jb25maWd1cmUoJmRldi0+ZGV2 LCBkZXYtPmRldi5vZl9ub2RlKTsKPiA+ICAKPiA+ICAJLyogQWxsb3cgdGhlIEhXIFBlcmlwaGVy YWwgSUQgdG8gYmUgb3ZlcnJpZGRlbiAqLwo+ID4gIAlwcm9wID0gb2ZfZ2V0X3Byb3BlcnR5KG5v ZGUsICJhcm0scHJpbWVjZWxsLXBlcmlwaGlkIiwgTlVMTCk7Cj4gPiBAQCAtNTQyLDcgKzU0MCw2 IEBAIHN0YXRpYyBpbnQgb2ZfcGxhdGZvcm1fZGV2aWNlX2Rlc3Ryb3koc3RydWN0IGRldmljZSAq ZGV2LCB2b2lkICpkYXRhKQo+ID4gIAkJYW1iYV9kZXZpY2VfdW5yZWdpc3Rlcih0b19hbWJhX2Rl dmljZShkZXYpKTsKPiA+ICAjZW5kaWYKPiA+ICAKPiA+IC0Jb2ZfZG1hX2RlY29uZmlndXJlKGRl dik7Cj4gPiAgCW9mX25vZGVfY2xlYXJfZmxhZyhkZXYtPm9mX25vZGUsIE9GX1BPUFVMQVRFRCk7 Cj4gPiAgCW9mX25vZGVfY2xlYXJfZmxhZyhkZXYtPm9mX25vZGUsIE9GX1BPUFVMQVRFRF9CVVMp Owo+ID4gIAlyZXR1cm4gMDsKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wcm9iZS5jIGIv ZHJpdmVycy9wY2kvcHJvYmUuYwo+ID4gaW5kZXggZTE2NGI1Yy4uNjM0ZDM0ZSAxMDA2NDQKPiA+ IC0tLSBhL2RyaXZlcnMvcGNpL3Byb2JlLmMKPiA+ICsrKyBiL2RyaXZlcnMvcGNpL3Byb2JlLmMK PiA+IEBAIC0xODczLDEwICsxODczLDcgQEAgc3RhdGljIHZvaWQgcGNpX2RtYV9jb25maWd1cmUo c3RydWN0IHBjaV9kZXYgKmRldikKPiA+ICB7Cj4gPiAgCXN0cnVjdCBkZXZpY2UgKmJyaWRnZSA9 IHBjaV9nZXRfaG9zdF9icmlkZ2VfZGV2aWNlKGRldik7Cj4gPiAgCj4gPiAtCWlmIChJU19FTkFC TEVEKENPTkZJR19PRikgJiYKPiA+IC0JCWJyaWRnZS0+cGFyZW50ICYmIGJyaWRnZS0+cGFyZW50 LT5vZl9ub2RlKSB7Cj4gPiAtCQkJb2ZfZG1hX2NvbmZpZ3VyZSgmZGV2LT5kZXYsIGJyaWRnZS0+ cGFyZW50LT5vZl9ub2RlKTsKPiA+IC0JfSBlbHNlIGlmIChoYXNfYWNwaV9jb21wYW5pb24oYnJp ZGdlKSkgewo+ID4gKwlpZiAoaGFzX2FjcGlfY29tcGFuaW9uKGJyaWRnZSkpIHsKPiA+ICAJCXN0 cnVjdCBhY3BpX2RldmljZSAqYWRldiA9IHRvX2FjcGlfZGV2aWNlX25vZGUoYnJpZGdlLT5md25v ZGUpOwo+ID4gIAkJZW51bSBkZXZfZG1hX2F0dHIgYXR0ciA9IGFjcGlfZ2V0X2RtYV9hdHRyKGFk ZXYpOwo+ID4gIAo+ID4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLW1hcHBpbmcuaCBi L2luY2x1ZGUvbGludXgvZG1hLW1hcHBpbmcuaAo+ID4gaW5kZXggYWJmNjg1ZWQuLmI1NjMyMGEg MTAwNjQ0Cj4gPiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RtYS1tYXBwaW5nLmgKPiA+ICsrKyBiL2lu Y2x1ZGUvbGludXgvZG1hLW1hcHBpbmcuaAo+ID4gQEAgLTcxOCw2ICs3MTgsOSBAQCB2b2lkICpk bWFfbWFya19kZWNsYXJlZF9tZW1vcnlfb2NjdXBpZWQoc3RydWN0IGRldmljZSAqZGV2LAo+ID4g IH0KPiA+ICAjZW5kaWYgLyogQ09ORklHX0hBVkVfR0VORVJJQ19ETUFfQ09IRVJFTlQgKi8KPiA+ ICAKPiA+ICtpbnQgZG1hX2NvbmZpZ3VyZShzdHJ1Y3QgZGV2aWNlICpkZXYpOwo+ID4gK3ZvaWQg ZG1hX2RlY29uZmlndXJlKHN0cnVjdCBkZXZpY2UgKmRldik7Cj4gPiArCj4gPiAgLyoKPiA+ICAg KiBNYW5hZ2VkIERNQSBBUEkKPiA+ICAgKi8KPiA+IAo+IApfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwppb21tdSBtYWlsaW5nIGxpc3QKaW9tbXVAbGlzdHMu bGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21h aWxtYW4vbGlzdGluZm8vaW9tbXU= From mboxrd@z Thu Jan 1 00:00:00 1970 From: lorenzo.pieralisi@arm.com (Lorenzo Pieralisi) Date: Thu, 19 Jan 2017 19:02:50 +0000 Subject: [PATCH V5 05/12] drivers: platform: Configure dma operations at probe time In-Reply-To: <327b5a9b-35f6-f6e0-4ef9-d2ed15bb4e49@arm.com> References: <1484838356-24962-1-git-send-email-sricharan@codeaurora.org> <1484838356-24962-6-git-send-email-sricharan@codeaurora.org> <327b5a9b-35f6-f6e0-4ef9-d2ed15bb4e49@arm.com> Message-ID: <20170119190250.GA11181@red-moon> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Thu, Jan 19, 2017 at 05:49:58PM +0000, Robin Murphy wrote: > On 19/01/17 15:05, Sricharan R wrote: > > Configuring DMA ops at probe time will allow deferring device probe when > > the IOMMU isn't available yet. The dma_configure for the device is > > now called from the generic device_attach callback just before the > > bus/driver probe is called. This way, configuring the DMA ops for the > > device would be called at the same place for all bus_types, hence the > > deferred probing mechanism should work for all buses as well. > > > > pci_bus_add_devices (platform/amba)(_device_create/driver_register) > > | | > > pci_bus_add_device (device_add/driver_register) > > | | > > device_attach device_initial_probe > > | | > > __device_attach_driver __device_attach_driver > > | > > driver_probe_device > > | > > really_probe > > | > > dma_configure > > > > Similarly on the device/driver_unregister path __device_release_driver is > > called which inturn calls dma_deconfigure. > > > > Signed-off-by: Sricharan R > > --- > > * Removed the dma configuration for the pci devices in case of DT > > from pci_dma_configure which was hanging outside separately and > > doing it in dma_configure function itself. > > > > drivers/base/dd.c | 9 +++++++++ > > drivers/base/dma-mapping.c | 32 ++++++++++++++++++++++++++++++++ > > drivers/of/platform.c | 5 +---- > > drivers/pci/probe.c | 5 +---- > > include/linux/dma-mapping.h | 3 +++ > > 5 files changed, 46 insertions(+), 8 deletions(-) > > > > diff --git a/drivers/base/dd.c b/drivers/base/dd.c > > index a1fbf55..4882f06 100644 > > --- a/drivers/base/dd.c > > +++ b/drivers/base/dd.c > > @@ -19,6 +19,7 @@ > > > > #include > > #include > > +#include > > #include > > #include > > #include > > @@ -356,6 +357,10 @@ static int really_probe(struct device *dev, struct device_driver *drv) > > if (ret) > > goto pinctrl_bind_failed; > > > > + ret = dma_configure(dev); > > + if (ret) > > + goto dma_failed; > > + > > if (driver_sysfs_add(dev)) { > > printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", > > __func__, dev_name(dev)); > > @@ -417,6 +422,8 @@ static int really_probe(struct device *dev, struct device_driver *drv) > > goto done; > > > > probe_failed: > > + dma_deconfigure(dev); > > +dma_failed: > > if (dev->bus) > > blocking_notifier_call_chain(&dev->bus->p->bus_notifier, > > BUS_NOTIFY_DRIVER_NOT_BOUND, dev); > > @@ -826,6 +833,8 @@ static void __device_release_driver(struct device *dev, struct device *parent) > > drv->remove(dev); > > > > device_links_driver_cleanup(dev); > > + dma_deconfigure(dev); > > + > > devres_release_all(dev); > > dev->driver = NULL; > > dev_set_drvdata(dev, NULL); > > diff --git a/drivers/base/dma-mapping.c b/drivers/base/dma-mapping.c > > index efd71cf..dfe6fd7 100644 > > --- a/drivers/base/dma-mapping.c > > +++ b/drivers/base/dma-mapping.c > > @@ -10,6 +10,7 @@ > > #include > > #include > > #include > > +#include > > #include > > #include > > > > @@ -341,3 +342,34 @@ void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags) > > vunmap(cpu_addr); > > } > > #endif > > + > > +/* > > + * Common configuration to enable DMA API use for a device > > + */ > > +#include > > + > > +int dma_configure(struct device *dev) > > +{ > > + struct device *_dev = dev; > > + int is_pci = dev_is_pci(dev); > > + > > + if (is_pci) { > > + _dev = pci_get_host_bridge_device(to_pci_dev(dev)); > > + if (IS_ENABLED(CONFIG_OF) && _dev->parent && > > + _dev->parent->of_node) > > + _dev = _dev->parent; > > + } > > + > > + if (_dev->of_node) > > + of_dma_configure(dev, _dev->of_node); > > + > > + if (is_pci) > > + pci_put_host_bridge_device(_dev); > > There's a fun bug here - at this point _dev is the *parent* of the > bridge device, so we put the refcount on the wrong device (the platform > device representing the host controller, rather than the PCI device > representing its insides), which frees the guy we're in the middle of > probing, and things rapidly go wrong afterwards: > > [ 1.461026] bus: 'platform': driver_probe_device: matched device > 40000000.pcie-controller with driver pci-host-generic > [ 1.471640] bus: 'platform': really_probe: probing driver > pci-host-generic with device 40000000.pcie-controller > [ 1.481678] OF: PCI: host bridge /pcie-controller at 40000000 ranges: > > ... > > [ 2.158259] bus: 'pci': driver_probe_device: matched device > 0000:02:10.0 with driver pcieport > [ 2.166716] bus: 'pci': really_probe: probing driver pcieport with > device 0000:02:10.0 > [ 2.174590] pci 0000:02:10.0: Driver pcieport requests probe deferral > [ 2.180978] pci 0000:02:10.0: Added to deferred list > [ 2.185915] bus: 'pci': driver_probe_device: matched device > 0000:02:1f.0 with driver pcieport > [ 2.194366] bus: 'pci': really_probe: probing driver pcieport with > device 0000:02:1f.0 > [ 2.202237] pci 0000:02:1f.0: Driver pcieport requests probe deferral > [ 2.208625] pci 0000:02:1f.0: Added to deferred list > [ 2.213582] driver: 'pci-host-generic': driver_bound: bound to device > '???v????.pcie-controller' > [ 2.222293] bus: 'platform': really_probe: bound device > ???v????.pcie-controller to driver pci-host-generic > [ 2.232041] Unable to handle kernel NULL pointer dereference at > virtual address 00000000 > > I recall debugging this same issue before, and I seem to have a local > version of this commit dated about 6 weeks ago where dma_configure() > looks like this: > > --->8--- > int dma_configure(struct device *dev) > { > struct device *bridge = NULL, *dma_dev = dev; > > if (dev_is_pci(dev)) { > bridge = pci_get_host_bridge_device(to_pci_dev(dev)); > dma_dev = bridge->parent; This would break ACPI, dma_dev would be NULL here, so from this standpoint (ACPI) the current patch is correct (but those [dev,_dev] should be renamed, they are extremely misleading so naming as in this hunk, which fixes DT too, is very welcome). On ACPI the DMA attributes are checked on the bridge's companion (ie its associated acpi_device). Thanks, Lorenzo > } > > if (dma_dev && dma_dev->of_node) { > of_dma_configure(dev, dma_dev->of_node); > } else if (dma_dev && has_acpi_companion(dma_dev)) { > struct acpi_device *adev = to_acpi_device_node(dma_dev->fwnode); > enum dev_dma_attr attr = acpi_get_dma_attr(adev); > > if (attr == DEV_DMA_NOT_SUPPORTED) > dev_warn(dev, "DMA not supported.\n"); > else > arch_setup_dma_ops(dev, 0, 0, NULL, > attr == DEV_DMA_COHERENT); > } > > if (bridge) > pci_put_host_bridge_device(bridge); > > return 0; > } > ---8<--- > > I have a feeling I was having a go at tidying up the "PCI hacks" from v4 > myself, but other things ended up taking precedence. > > Robin. > > > + > > + return 0; > > +} > > + > > +void dma_deconfigure(struct device *dev) > > +{ > > + of_dma_deconfigure(dev); > > +} > > diff --git a/drivers/of/platform.c b/drivers/of/platform.c > > index 57418f7..cf35030 100644 > > --- a/drivers/of/platform.c > > +++ b/drivers/of/platform.c > > @@ -22,6 +22,7 @@ > > #include > > #include > > #include > > +#include > > #include > > #include > > #include > > @@ -186,11 +187,9 @@ static struct platform_device *of_platform_device_create_pdata( > > > > dev->dev.bus = &platform_bus_type; > > dev->dev.platform_data = platform_data; > > - of_dma_configure(&dev->dev, dev->dev.of_node); > > of_msi_configure(&dev->dev, dev->dev.of_node); > > > > if (of_device_add(dev) != 0) { > > - of_dma_deconfigure(&dev->dev); > > platform_device_put(dev); > > goto err_clear_flag; > > } > > @@ -248,7 +247,6 @@ static struct amba_device *of_amba_device_create(struct device_node *node, > > dev_set_name(&dev->dev, "%s", bus_id); > > else > > of_device_make_bus_id(&dev->dev); > > - of_dma_configure(&dev->dev, dev->dev.of_node); > > > > /* Allow the HW Peripheral ID to be overridden */ > > prop = of_get_property(node, "arm,primecell-periphid", NULL); > > @@ -542,7 +540,6 @@ static int of_platform_device_destroy(struct device *dev, void *data) > > amba_device_unregister(to_amba_device(dev)); > > #endif > > > > - of_dma_deconfigure(dev); > > of_node_clear_flag(dev->of_node, OF_POPULATED); > > of_node_clear_flag(dev->of_node, OF_POPULATED_BUS); > > return 0; > > diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c > > index e164b5c..634d34e 100644 > > --- a/drivers/pci/probe.c > > +++ b/drivers/pci/probe.c > > @@ -1873,10 +1873,7 @@ static void pci_dma_configure(struct pci_dev *dev) > > { > > struct device *bridge = pci_get_host_bridge_device(dev); > > > > - if (IS_ENABLED(CONFIG_OF) && > > - bridge->parent && bridge->parent->of_node) { > > - of_dma_configure(&dev->dev, bridge->parent->of_node); > > - } else if (has_acpi_companion(bridge)) { > > + if (has_acpi_companion(bridge)) { > > struct acpi_device *adev = to_acpi_device_node(bridge->fwnode); > > enum dev_dma_attr attr = acpi_get_dma_attr(adev); > > > > diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h > > index abf685ed..b56320a 100644 > > --- a/include/linux/dma-mapping.h > > +++ b/include/linux/dma-mapping.h > > @@ -718,6 +718,9 @@ void *dma_mark_declared_memory_occupied(struct device *dev, > > } > > #endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */ > > > > +int dma_configure(struct device *dev); > > +void dma_deconfigure(struct device *dev); > > + > > /* > > * Managed DMA API > > */ > > >