From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Shevchenko, Andriy" Subject: Re: [PATCH V2] dma: add channel request API that supports deferred probe Date: Tue, 19 Nov 2013 11:49:46 +0000 Message-ID: <1384861763.14845.219.camel@smile> References: <1384803581-23871-1-git-send-email-swarren@wwwdotorg.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1384803581-23871-1-git-send-email-swarren-3lzwWm7+Weoh9ZMKESR00Q@public.gmane.org> Content-Language: en-US Content-ID: <6B5FEDC7B9E7D94EABAA88F0DD56F105-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org> Sender: linux-tegra-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: Stephen Warren Cc: "Koul, Vinod" , Stephen Warren , "treding-DDmLM1+adcrQT0dZR+AlfA@public.gmane.org" , "pdeschrijver-DDmLM1+adcrQT0dZR+AlfA@public.gmane.org" , "linux-tegra-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org" , "Williams, Dan J" , "dmaengine-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" List-Id: linux-tegra@vger.kernel.org T24gTW9uLCAyMDEzLTExLTE4IGF0IDEyOjM5IC0wNzAwLCBTdGVwaGVuIFdhcnJlbiB3cm90ZToN Cj4gRnJvbTogU3RlcGhlbiBXYXJyZW4gPHN3YXJyZW5AbnZpZGlhLmNvbT4NCg0KVGhhbmtzIGZv ciBhbiB1cGRhdGVkIHZlcnNpb24uDQpTdGlsbCBjb3VwbGUgb2YgY29tbWVudHMgYmVsb3cuDQoN CkFmdGVyIGFkZHJlc3NpbmcgdGhlbQ0KDQpBY2tlZC1ieTogQW5keSBTaGV2Y2hlbmtvIDxhbmRy aXkuc2hldmNoZW5rb0BpbnRlbC5jb20+DQoNCmZvciB0aGUgYWNwaS1kbWEuYyBwYXJ0Lg0KDQoN Cj4gZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbCgpIHNpbXBseSByZXR1cm5zIE5VTEwgd2hlbmV2 ZXIgRE1BIGNoYW5uZWwNCj4gbG9va3VwIGZhaWxzLiBMb29rdXAgY291bGQgZmFpbCBmb3IgdHdv IGRpc3RpbmN0IHJlYXNvbnM6DQo+IA0KPiBhKSBObyBETUEgc3BlY2lmaWNhdGlvbiBleGlzdHMg Zm9yIHRoZSBjaGFubmVsIG5hbWUuDQo+ICAgIFRoaXMgaW5jbHVkZXMgc2l0dWF0aW9ucyB3aGVy ZSBubyBETUEgc3BlY2lmaWNhdGlvbnMgZXhpc3QgYXQgYWxsLCBvcg0KPiAgICBvdGhlciBnZW5l cmFsIGxvb2t1cCBwcm9ibGVtcy4NCj4gDQo+IGIpIEEgRE1BIHNwZWNpZmljYXRpb24gZG9lcyBl eGlzdCwgeWV0IHRoZSBkcml2ZXIgZm9yIHRoYXQgY2hhbm5lbCBpcyBub3QNCj4gICAgeWV0IHJl Z2lzdGVyZWQuDQo+IA0KPiBDYXNlIChiKSBzaG91bGQgdHJpZ2dlciBkZWZlcnJlZCBwcm9iZSBp biBjbGllbnQgZHJpdmVycy4gSG93ZXZlciwgc2luY2UNCj4gdGhleSBoYXZlIG5vIHdheSB0byBk aWZmZXJlbnRpYXRlIHRoZSB0d28gc2l0dWF0aW9ucywgaXQgY2Fubm90Lg0KPiANCj4gSW1wbGVt ZW50IG5ldyBmdW5jdGlvbiBkbWFfcmVxdWVzdF9zbGF2ZV9jaGFubmVsX29yX2VycigpLCB3aGlj aCBwZXJmb3Jtcw0KPiBpZGVudGljYWxseSB0byBkbWFfcmVxdWVzdF9zbGF2ZV9jaGFubmVsKCks IGV4Y2VwdCB0aGF0IGl0IHJldHVybnMgYW4NCj4gZXJyb3ItcG9pbnRlciByYXRoZXIgdGhhbiBO VUxMLCB3aGljaCBhbGxvd3MgY2FsbGVycyB0byBkZXRlY3Qgd2hlbg0KPiBkZWZlcnJlZCBwcm9i ZSBzaG91bGQgb2NjdXIuDQo+IA0KPiBFdmVudHVhbGx5LCBhbGwgZHJpdmVycyBzaG91bGQgYmUg Y29udmVydGVkIHRvIHRoaXMgbmV3IEFQSSwgdGhlIG9sZCBBUEkNCj4gcmVtb3ZlZCwgYW5kIHRo ZSBuZXcgQVBJIHJlbmFtZWQgdG8gdGhlIG1vcmUgZGVzaXJhYmxlIG5hbWUuIFRoaXMgcGF0Y2gN Cj4gZG9lc24ndCBjb252ZXJ0IHRoZSBleGlzdGluZyBBUEkgYW5kIGFsbCBkcml2ZXJzIGluIG9u ZSBnbywgc2luY2Ugc29tZQ0KPiBkcml2ZXJzIGNhbGwgZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5l bCgpIHRoZW4gZG1hX3JlcXVlc3RfY2hhbm5lbCgpIGlmDQo+IHRoYXQgZmFpbHMuIFRoYXQgd291 bGQgcmVxdWlyZSBtb2RpZnlpbmcgZG1hX3JlcXVlc3RfY2hhbm5lbCgpIGluIHRoZQ0KPiBzYW1l IHdheSwgd2hpY2ggd291bGQgdGhlbiByZXF1aXJlIG1vZGlmeWluZyBjbG9zZSB0byAxMDAgZHJp dmVycyBhdCBvbmNlLA0KPiByYXRoZXIgdGhhbiBqdXN0IHRoZSAxNS0yMCBvciBzbyB0aGF0IHVz ZSBkbWFfcmVxdWVzdF9zbGF2ZV9jaGFubmVsKCksDQo+IHdoaWNoIG1pZ2h0IGJlIHRlbmFibGUg aW4gYSBzaW5nbGUgcGF0Y2guDQo+IA0KPiBhY3BpX2RtYV9yZXF1ZXN0X3NsYXZlX2NoYW5fYnlf aW5kZXgoKSBkb2Vzbid0IGFjdHVhbGx5IGltcGxlbWVudA0KPiBkZWZlcnJlZCBwcm9iZS4gUGVy aGFwcyBpdCBzaG91bGQ/DQoNClllcywgaXQgc2hvdWxkLiBZb3UgbWF5IG1lbnRpb25lZCB0aGF0 IGl0IHdpbGwgYmUgdXBkYXRlZCBsYXRlcg0KYWNjb3JkaW5nbHkuDQoNCj4gDQo+IENjOiB0cmVk aW5nQG52aWRpYS5jb20NCj4gQ2M6IHBkZXNjaHJpanZlckBudmlkaWEuY29tDQo+IENjOiBsaW51 eC10ZWdyYUB2Z2VyLmtlcm5lbC5vcmcNCj4gQ2M6IGxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5m cmFkZWFkLm9yZw0KPiBDYzogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+ DQo+IFRvOiBWaW5vZCBLb3VsIDx2aW5vZC5rb3VsQGludGVsLmNvbT4NCj4gVG86IEFuZHJpeSBT aGV2Y2hlbmtvIDxhbmRyaXkuc2hldmNoZW5rb0BpbnRlbC5jb20+DQo+IENjOiBkbWFlbmdpbmVA dmdlci5rZXJuZWwub3JnDQo+IFNpZ25lZC1vZmYtYnk6IFN0ZXBoZW4gV2FycmVuIDxzd2FycmVu QG52aWRpYS5jb20+DQo+IC0tLQ0KPiB2MjoNCj4gKiBpbmNsdWRlIDxsaW51eC9lcnIuaD4gaW4g PGxpbnV4L2RtYWVuZ2luZS5oPg0KPiAqIFJldHVybiAtRU5PREFUQSBpZiBzbGF2ZV9pZCBvciBj aGFuX2lkIG91dC1vZi1yYW5nZS4NCj4gKiBSZXR1cm4gYW4gZXJyb3ItcG9pbnRlciBub3QgTlVM TCBpZiB3ZSBjYW4ndCBmaW5kIGEgbWF0Y2hpbmcgRE1BDQo+ICAgY29udHJvbGxlciBvciB0cmFu c2xhdGUgdGhlIGNoYW5uZWwuDQo+IA0KPiBUaGlzIHBhdGNoIGlzIHBhcnQgb2YgYSBzZXJpZXMg d2l0aCBzdHJvbmcgaW50ZXJuYWwgZGVwZGVuZGVuY2llcy4gSSdtDQo+IGxvb2tpbmcgZm9yIGFu IGFjayBzbyB0aGF0IEkgY2FuIHRha2UgdGhlIGVudGlyZSBzZXJpZXMgdGhyb3VnaCB0aGUgVGVn cmENCj4gYW5kIGFybS1zb2MgdHJlZXMuIFRoZSBzZXJpZXMgd2lsbCBiZSBwYXJ0IG9mIGEgc3Rh YmxlIGJyYW5jaCB0aGF0IGNhbiBiZQ0KPiBtZXJnZWQgaW50byBvdGhlciBzdWJzeXN0ZW1zIGlm IG5lZWRlZCB0byBhdm9pZC9yZXNvbHZlIGRlcGVuZGVuY2llcy4NCj4gTm90ZSB0aGF0IEknbSBq dXN0IHJlcG9zdGluZyB0aGlzIG9uZSBwYXRjaCBmcm9tIHRoZSBzZXJpZXMgZm9yIFYyLg0KPiAN Cj4gQWx0ZXJuYXRpdmVseSwgaWYgdGhpcyBwYXRjaCBjYW4gYmUgYXBwbGllZCBkaXJlY3RseSBv biB0b3Agb2YgMy4xMy1yYzENCj4gKG9uY2UgaXQgYXBwZWFycykgYWxvbmUgaW4gYSBzdGFibGUg dG9waWMgYnJhbmNoLCBJIGNhbiBtZXJnZSB0aGF0IGludG8NCj4gbXkgVGVncmEgdHJlZSBhbmQg dXNlIGl0IGFzIGEgYmFzZS4NCj4gLS0tDQo+ICBkcml2ZXJzL2RtYS9hY3BpLWRtYS5jICAgIHwg MTQgKysrKysrKy0tLS0tLS0NCj4gIGRyaXZlcnMvZG1hL2RtYWVuZ2luZS5jICAgfCA0NCArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLQ0KPiAgZHJpdmVycy9kbWEv b2YtZG1hLmMgICAgICB8IDEyICsrKysrKystLS0tLQ0KPiAgaW5jbHVkZS9saW51eC9kbWFlbmdp bmUuaCB8ICA4ICsrKysrKysrDQo+ICBpbmNsdWRlL2xpbnV4L29mX2RtYS5oICAgIHwgIDkgKysr KysrLS0tDQo+ICA1IGZpbGVzIGNoYW5nZWQsIDY4IGluc2VydGlvbnMoKyksIDE5IGRlbGV0aW9u cygtKQ0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL2FjcGktZG1hLmMgYi9kcml2ZXJz L2RtYS9hY3BpLWRtYS5jDQo+IGluZGV4IGU2OWIwM2MwZmE1MC4uZTNkOTU2OGYzMWEzIDEwMDY0 NA0KPiAtLS0gYS9kcml2ZXJzL2RtYS9hY3BpLWRtYS5jDQo+ICsrKyBiL2RyaXZlcnMvZG1hL2Fj cGktZG1hLmMNCj4gQEAgLTMzNCw3ICszMzQsNyBAQCBzdGF0aWMgaW50IGFjcGlfZG1hX3BhcnNl X2ZpeGVkX2RtYShzdHJ1Y3QgYWNwaV9yZXNvdXJjZSAqcmVzLCB2b2lkICpkYXRhKQ0KPiAgICog QGRldjoJc3RydWN0IGRldmljZSB0byBnZXQgRE1BIHJlcXVlc3QgZnJvbQ0KPiAgICogQGluZGV4 OglpbmRleCBvZiBGaXhlZERNQSBkZXNjcmlwdG9yIGZvciBAZGV2DQo+ICAgKg0KPiAtICogUmV0 dXJucyBwb2ludGVyIHRvIGFwcHJvcHJpYXRlIGRtYSBjaGFubmVsIG9uIHN1Y2Nlc3Mgb3IgTlVM TCBvbiBlcnJvci4NCj4gKyAqIFJldHVybnMgcG9pbnRlciB0byBhcHByb3ByaWF0ZSBkbWEgY2hh bm5lbCBvbiBzdWNjZXNzIG9yIGFuIGVycm9yIHBvaW50ZXIuDQo+ICAgKi8NCj4gIHN0cnVjdCBk bWFfY2hhbiAqYWNwaV9kbWFfcmVxdWVzdF9zbGF2ZV9jaGFuX2J5X2luZGV4KHN0cnVjdCBkZXZp Y2UgKmRldiwNCj4gIAkJc2l6ZV90IGluZGV4KQ0KPiBAQCAtMzQ5LDEwICszNDksMTAgQEAgc3Ry dWN0IGRtYV9jaGFuICphY3BpX2RtYV9yZXF1ZXN0X3NsYXZlX2NoYW5fYnlfaW5kZXgoc3RydWN0 IGRldmljZSAqZGV2LA0KPiAgDQo+ICAJLyogQ2hlY2sgaWYgdGhlIGRldmljZSB3YXMgZW51bWVy YXRlZCBieSBBQ1BJICovDQo+ICAJaWYgKCFkZXYgfHwgIUFDUElfSEFORExFKGRldikpDQo+IC0J CXJldHVybiBOVUxMOw0KPiArCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsNCj4gIA0KPiAgCWlm IChhY3BpX2J1c19nZXRfZGV2aWNlKEFDUElfSEFORExFKGRldiksICZhZGV2KSkNCj4gLQkJcmV0 dXJuIE5VTEw7DQo+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOw0KPiAgDQo+ICAJbWVtc2V0 KCZwZGF0YSwgMCwgc2l6ZW9mKHBkYXRhKSk7DQo+ICAJcGRhdGEuaW5kZXggPSBpbmRleDsNCj4g QEAgLTM2Nyw3ICszNjcsNyBAQCBzdHJ1Y3QgZG1hX2NoYW4gKmFjcGlfZG1hX3JlcXVlc3Rfc2xh dmVfY2hhbl9ieV9pbmRleChzdHJ1Y3QgZGV2aWNlICpkZXYsDQo+ICAJYWNwaV9kZXZfZnJlZV9y ZXNvdXJjZV9saXN0KCZyZXNvdXJjZV9saXN0KTsNCj4gIA0KPiAgCWlmIChkbWFfc3BlYy0+c2xh dmVfaWQgPCAwIHx8IGRtYV9zcGVjLT5jaGFuX2lkIDwgMCkNCj4gLQkJcmV0dXJuIE5VTEw7DQo+ ICsJCXJldHVybiBFUlJfUFRSKC1FTk9EQVRBKTsNCj4gIA0KPiAgCW11dGV4X2xvY2soJmFjcGlf ZG1hX2xvY2spOw0KPiAgDQo+IEBAIC0zOTAsNyArMzkwLDcgQEAgc3RydWN0IGRtYV9jaGFuICph Y3BpX2RtYV9yZXF1ZXN0X3NsYXZlX2NoYW5fYnlfaW5kZXgoc3RydWN0IGRldmljZSAqZGV2LA0K PiAgCX0NCj4gIA0KPiAgCW11dGV4X3VubG9jaygmYWNwaV9kbWFfbG9jayk7DQo+IC0JcmV0dXJu IGNoYW47DQo+ICsJcmV0dXJuIGNoYW4gPyBjaGFuIDogRVJSX1BUUigtRU5PRU5UKTsNCj4gIH0N Cj4gIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbl9ieV9pbmRl eCk7DQo+ICANCj4gQEAgLTQwMyw3ICs0MDMsNyBAQCBFWFBPUlRfU1lNQk9MX0dQTChhY3BpX2Rt YV9yZXF1ZXN0X3NsYXZlX2NoYW5fYnlfaW5kZXgpOw0KPiAgICogdHJhbnNsYXRlIHRoZSBuYW1l cyAidHgiIGFuZCAicngiIGhlcmUgYmFzZWQgb24gdGhlIG1vc3QgY29tbW9uIGNhc2Ugd2hlcmUN Cj4gICAqIHRoZSBmaXJzdCBGaXhlZERNQSBkZXNjcmlwdG9yIGlzIFRYIGFuZCBzZWNvbmQgaXMg UlguDQo+ICAgKg0KPiAtICogUmV0dXJucyBwb2ludGVyIHRvIGFwcHJvcHJpYXRlIGRtYSBjaGFu bmVsIG9uIHN1Y2Nlc3Mgb3IgTlVMTCBvbiBlcnJvci4NCj4gKyAqIFJldHVybnMgcG9pbnRlciB0 byBhcHByb3ByaWF0ZSBkbWEgY2hhbm5lbCBvbiBzdWNjZXNzIG9yIGFuIGVycm9yIHBvaW50ZXIu DQo+ICAgKi8NCj4gIHN0cnVjdCBkbWFfY2hhbiAqYWNwaV9kbWFfcmVxdWVzdF9zbGF2ZV9jaGFu X2J5X25hbWUoc3RydWN0IGRldmljZSAqZGV2LA0KPiAgCQljb25zdCBjaGFyICpuYW1lKQ0KPiBA QCAtNDE1LDcgKzQxNSw3IEBAIHN0cnVjdCBkbWFfY2hhbiAqYWNwaV9kbWFfcmVxdWVzdF9zbGF2 ZV9jaGFuX2J5X25hbWUoc3RydWN0IGRldmljZSAqZGV2LA0KPiAgCWVsc2UgaWYgKCFzdHJjbXAo bmFtZSwgInJ4IikpDQo+ICAJCWluZGV4ID0gMTsNCj4gIAllbHNlDQo+IC0JCXJldHVybiBOVUxM Ow0KPiArCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsNCg0KSSBzdGlsbCB0aGluayAtRUlOVkFM IHN1aXRzIGEgYml0IGJldHRlciBoZXJlLg0KDQo+ICANCj4gIAlyZXR1cm4gYWNwaV9kbWFfcmVx dWVzdF9zbGF2ZV9jaGFuX2J5X2luZGV4KGRldiwgaW5kZXgpOw0KPiAgfQ0KPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9kbWEvZG1hZW5naW5lLmMgYi9kcml2ZXJzL2RtYS9kbWFlbmdpbmUuYw0KPiBp bmRleCBlYTgwNmJkYzEyZWYuLjVlN2Y4YWYyZjBlYyAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9k bWEvZG1hZW5naW5lLmMNCj4gKysrIGIvZHJpdmVycy9kbWEvZG1hZW5naW5lLmMNCj4gQEAgLTU0 MCw2ICs1NDAsOCBAQCBFWFBPUlRfU1lNQk9MX0dQTChkbWFfZ2V0X3NsYXZlX2NoYW5uZWwpOw0K PiAgICogQG1hc2s6IGNhcGFiaWxpdGllcyB0aGF0IHRoZSBjaGFubmVsIG11c3Qgc2F0aXNmeQ0K PiAgICogQGZuOiBvcHRpb25hbCBjYWxsYmFjayB0byBkaXNwb3NpdGlvbiBhdmFpbGFibGUgY2hh bm5lbHMNCj4gICAqIEBmbl9wYXJhbTogb3BhcXVlIHBhcmFtZXRlciB0byBwYXNzIHRvIGRtYV9m aWx0ZXJfZm4NCj4gKyAqDQo+ICsgKiBSZXR1cm5zIHBvaW50ZXIgdG8gYXBwcm9wcmlhdGUgZG1h IGNoYW5uZWwgb24gc3VjY2VzcyBvciBOVUxMLg0KPiAgICovDQo+ICBzdHJ1Y3QgZG1hX2NoYW4g Kl9fZG1hX3JlcXVlc3RfY2hhbm5lbChjb25zdCBkbWFfY2FwX21hc2tfdCAqbWFzaywNCj4gIAkJ CQkgICAgICAgZG1hX2ZpbHRlcl9mbiBmbiwgdm9pZCAqZm5fcGFyYW0pDQo+IEBAIC01ODgsMjQg KzU5MCw1OCBAQCBzdHJ1Y3QgZG1hX2NoYW4gKl9fZG1hX3JlcXVlc3RfY2hhbm5lbChjb25zdCBk bWFfY2FwX21hc2tfdCAqbWFzaywNCj4gIEVYUE9SVF9TWU1CT0xfR1BMKF9fZG1hX3JlcXVlc3Rf Y2hhbm5lbCk7DQo+ICANCj4gIC8qKg0KPiAtICogZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbCAt IHRyeSB0byBhbGxvY2F0ZSBhbiBleGNsdXNpdmUgc2xhdmUgY2hhbm5lbA0KPiArICogX19kbWFf cmVxdWVzdF9zbGF2ZV9jaGFubmVsIC0gdHJ5IHRvIGFsbG9jYXRlIGFuIGV4Y2x1c2l2ZSBzbGF2 ZQ0KPiArICogICBjaGFubmVsDQo+ICAgKiBAZGV2Oglwb2ludGVyIHRvIGNsaWVudCBkZXZpY2Ug c3RydWN0dXJlDQo+ICAgKiBAbmFtZToJc2xhdmUgY2hhbm5lbCBuYW1lDQo+ICsgKg0KPiArICog UmV0dXJucyBwb2ludGVyIHRvIGFwcHJvcHJpYXRlIGRtYSBjaGFubmVsIG9uIHN1Y2Nlc3Mgb3Ig YW4gZXJyb3IgcG9pbnRlci4NCj4gICAqLw0KPiAtc3RydWN0IGRtYV9jaGFuICpkbWFfcmVxdWVz dF9zbGF2ZV9jaGFubmVsKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3QgY2hhciAqbmFtZSkNCj4g K3N0YXRpYyBzdHJ1Y3QgZG1hX2NoYW4gKl9fZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbChzdHJ1 Y3QgZGV2aWNlICpkZXYsDQo+ICsJCQkJCWNvbnN0IGNoYXIgKm5hbWUsIGJvb2wgZGVmZXIpDQo+ ICB7DQo+ICAJLyogSWYgZGV2aWNlLXRyZWUgaXMgcHJlc2VudCBnZXQgc2xhdmUgaW5mbyBmcm9t IGhlcmUgKi8NCj4gIAlpZiAoZGV2LT5vZl9ub2RlKQ0KPiAtCQlyZXR1cm4gb2ZfZG1hX3JlcXVl c3Rfc2xhdmVfY2hhbm5lbChkZXYtPm9mX25vZGUsIG5hbWUpOw0KPiArCQlyZXR1cm4gb2ZfZG1h X3JlcXVlc3Rfc2xhdmVfY2hhbm5lbChkZXYtPm9mX25vZGUsIG5hbWUsIGRlZmVyKTsNCj4gIA0K PiAgCS8qIElmIGRldmljZSB3YXMgZW51bWVyYXRlZCBieSBBQ1BJIGdldCBzbGF2ZSBpbmZvIGZy b20gaGVyZSAqLw0KPiAgCWlmIChBQ1BJX0hBTkRMRShkZXYpKQ0KPiAgCQlyZXR1cm4gYWNwaV9k bWFfcmVxdWVzdF9zbGF2ZV9jaGFuX2J5X25hbWUoZGV2LCBuYW1lKTsNCj4gIA0KPiAtCXJldHVy biBOVUxMOw0KPiArCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOw0KPiArfQ0KPiArDQo+ICsvKioN Cj4gKyAqIGRtYV9yZXF1ZXN0X3NsYXZlX2NoYW5uZWwgLSB0cnkgdG8gYWxsb2NhdGUgYW4gZXhj bHVzaXZlIHNsYXZlIGNoYW5uZWwNCj4gKyAqIEBkZXY6CXBvaW50ZXIgdG8gY2xpZW50IGRldmlj ZSBzdHJ1Y3R1cmUNCj4gKyAqIEBuYW1lOglzbGF2ZSBjaGFubmVsIG5hbWUNCj4gKyAqDQo+ICsg KiBSZXR1cm5zIHBvaW50ZXIgdG8gYXBwcm9wcmlhdGUgZG1hIGNoYW5uZWwgb24gc3VjY2VzcyBv ciBOVUxMLg0KPiArICovDQo+ICtzdHJ1Y3QgZG1hX2NoYW4gKmRtYV9yZXF1ZXN0X3NsYXZlX2No YW5uZWwoc3RydWN0IGRldmljZSAqZGV2LA0KPiArCQkJCQkgICBjb25zdCBjaGFyICpuYW1lKQ0K PiArew0KPiArCXN0cnVjdCBkbWFfY2hhbiAqY2ggPSBfX2RtYV9yZXF1ZXN0X3NsYXZlX2NoYW5u ZWwoZGV2LCBuYW1lLCBmYWxzZSk7DQo+ICsJaWYgKElTX0VSUihjaCkpDQo+ICsJCXJldHVybiBO VUxMOw0KPiArCXJldHVybiBjaDsNCj4gIH0NCj4gIEVYUE9SVF9TWU1CT0xfR1BMKGRtYV9yZXF1 ZXN0X3NsYXZlX2NoYW5uZWwpOw0KPiAgDQo+ICsvKioNCj4gKyAqIGRtYV9yZXF1ZXN0X3NsYXZl X2NoYW5uZWxfb3JfZXJyIC0gdHJ5IHRvIGFsbG9jYXRlIGFuIGV4Y2x1c2l2ZSBzbGF2ZSBjaGFu bmVsDQo+ICsgKiBAZGV2Oglwb2ludGVyIHRvIGNsaWVudCBkZXZpY2Ugc3RydWN0dXJlDQo+ICsg KiBAbmFtZToJc2xhdmUgY2hhbm5lbCBuYW1lDQo+ICsgKg0KPiArICogUmV0dXJucyBwb2ludGVy IHRvIGFwcHJvcHJpYXRlIGRtYSBjaGFubmVsIG9uIHN1Y2Nlc3Mgb3IgYW4gZXJyb3IgcG9pbnRl ci4NCj4gKyAqLw0KPiArc3RydWN0IGRtYV9jaGFuICpkbWFfcmVxdWVzdF9zbGF2ZV9jaGFubmVs X29yX2VycihzdHJ1Y3QgZGV2aWNlICpkZXYsDQo+ICsJCQkJCQkgIGNvbnN0IGNoYXIgKm5hbWUp DQo+ICt7DQo+ICsJcmV0dXJuIF9fZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbChkZXYsIG5hbWUs IHRydWUpOw0KPiArfQ0KPiArRVhQT1JUX1NZTUJPTF9HUEwoZG1hX3JlcXVlc3Rfc2xhdmVfY2hh bm5lbF9vcl9lcnIpOw0KPiArDQo+ICB2b2lkIGRtYV9yZWxlYXNlX2NoYW5uZWwoc3RydWN0IGRt YV9jaGFuICpjaGFuKQ0KPiAgew0KPiAgCW11dGV4X2xvY2soJmRtYV9saXN0X211dGV4KTsNCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL29mLWRtYS5jIGIvZHJpdmVycy9kbWEvb2YtZG1hLmMN Cj4gaW5kZXggMGI4OGRkM2QwNWY0Li45MjgxNDFmNmYyMWIgMTAwNjQ0DQo+IC0tLSBhL2RyaXZl cnMvZG1hL29mLWRtYS5jDQo+ICsrKyBiL2RyaXZlcnMvZG1hL29mLWRtYS5jDQo+IEBAIC0xNDMs MTAgKzE0MywxMCBAQCBzdGF0aWMgaW50IG9mX2RtYV9tYXRjaF9jaGFubmVsKHN0cnVjdCBkZXZp Y2Vfbm9kZSAqbnAsIGNvbnN0IGNoYXIgKm5hbWUsDQo+ICAgKiBAbnA6CQlkZXZpY2Ugbm9kZSB0 byBnZXQgRE1BIHJlcXVlc3QgZnJvbQ0KPiAgICogQG5hbWU6CW5hbWUgb2YgZGVzaXJlZCBjaGFu bmVsDQo+ICAgKg0KPiAtICogUmV0dXJucyBwb2ludGVyIHRvIGFwcHJvcHJpYXRlIGRtYSBjaGFu bmVsIG9uIHN1Y2Nlc3Mgb3IgTlVMTCBvbiBlcnJvci4NCj4gKyAqIFJldHVybnMgcG9pbnRlciB0 byBhcHByb3ByaWF0ZSBkbWEgY2hhbm5lbCBvbiBzdWNjZXNzIG9yIGFuIGVycm9yIHBvaW50ZXIu DQo+ICAgKi8NCj4gIHN0cnVjdCBkbWFfY2hhbiAqb2ZfZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5l bChzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLA0KPiAtCQkJCQkgICAgICBjb25zdCBjaGFyICpuYW1l KQ0KPiArCQkJCQkgICAgICBjb25zdCBjaGFyICpuYW1lLCBib29sIGRlZmVyKQ0KPiAgew0KPiAg CXN0cnVjdCBvZl9waGFuZGxlX2FyZ3MJZG1hX3NwZWM7DQo+ICAJc3RydWN0IG9mX2RtYQkJKm9m ZG1hOw0KPiBAQCAtMTU1LDE0ICsxNTUsMTQgQEAgc3RydWN0IGRtYV9jaGFuICpvZl9kbWFfcmVx dWVzdF9zbGF2ZV9jaGFubmVsKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsDQo+ICANCj4gIAlpZiAo IW5wIHx8ICFuYW1lKSB7DQo+ICAJCXByX2VycigiJXM6IG5vdCBlbm91Z2ggaW5mb3JtYXRpb24g cHJvdmlkZWRcbiIsIF9fZnVuY19fKTsNCj4gLQkJcmV0dXJuIE5VTEw7DQo+ICsJCXJldHVybiBF UlJfUFRSKC1FTk9ERVYpOw0KPiAgCX0NCj4gIA0KPiAgCWNvdW50ID0gb2ZfcHJvcGVydHlfY291 bnRfc3RyaW5ncyhucCwgImRtYS1uYW1lcyIpOw0KPiAgCWlmIChjb3VudCA8IDApIHsNCj4gIAkJ cHJfZXJyKCIlczogZG1hLW5hbWVzIHByb3BlcnR5IG9mIG5vZGUgJyVzJyBtaXNzaW5nIG9yIGVt cHR5XG4iLA0KPiAgCQkJX19mdW5jX18sIG5wLT5mdWxsX25hbWUpOw0KPiAtCQlyZXR1cm4gTlVM TDsNCj4gKwkJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7DQo+ICAJfQ0KPiAgDQo+ICAJZm9yIChp ID0gMDsgaSA8IGNvdW50OyBpKyspIHsNCj4gQEAgLTE4MSwxMSArMTgxLDEzIEBAIHN0cnVjdCBk bWFfY2hhbiAqb2ZfZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbChzdHJ1Y3QgZGV2aWNlX25vZGUg Km5wLA0KPiAgDQo+ICAJCW9mX25vZGVfcHV0KGRtYV9zcGVjLm5wKTsNCj4gIA0KPiArCQlpZiAo IW9mZG1hICYmIGRlZmVyKQ0KPiArCQkJcmV0dXJuIEVSUl9QVFIoLUVQUk9CRV9ERUZFUik7DQo+ ICAJCWlmIChjaGFuKQ0KPiAgCQkJcmV0dXJuIGNoYW47DQo+ICAJfQ0KPiAgDQo+IC0JcmV0dXJu IE5VTEw7DQo+ICsJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7DQo+ICB9DQo+ICANCj4gIC8qKg0K PiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWFlbmdpbmUuaCBiL2luY2x1ZGUvbGludXgv ZG1hZW5naW5lLmgNCj4gaW5kZXggNDFjZjBjMzk5Mjg4Li5mMTU2YzE0NWZhZDIgMTAwNjQ0DQo+ IC0tLSBhL2luY2x1ZGUvbGludXgvZG1hZW5naW5lLmgNCj4gKysrIGIvaW5jbHVkZS9saW51eC9k bWFlbmdpbmUuaA0KPiBAQCAtMjIsNiArMjIsNyBAQA0KPiAgI2RlZmluZSBMSU5VWF9ETUFFTkdJ TkVfSA0KPiAgDQo+ICAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+DQo+ICsjaW5jbHVkZSA8bGlu dXgvZXJyLmg+DQo+ICAjaW5jbHVkZSA8bGludXgvdWlvLmg+DQo+ICAjaW5jbHVkZSA8bGludXgv YnVnLmg+DQo+ICAjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4NCj4gQEAgLTEwNDEsNiAr MTA0Miw4IEBAIHZvaWQgZG1hX2lzc3VlX3BlbmRpbmdfYWxsKHZvaWQpOw0KPiAgc3RydWN0IGRt YV9jaGFuICpfX2RtYV9yZXF1ZXN0X2NoYW5uZWwoY29uc3QgZG1hX2NhcF9tYXNrX3QgKm1hc2ss DQo+ICAJCQkJCWRtYV9maWx0ZXJfZm4gZm4sIHZvaWQgKmZuX3BhcmFtKTsNCj4gIHN0cnVjdCBk bWFfY2hhbiAqZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbChzdHJ1Y3QgZGV2aWNlICpkZXYsIGNv bnN0IGNoYXIgKm5hbWUpOw0KPiArc3RydWN0IGRtYV9jaGFuICpkbWFfcmVxdWVzdF9zbGF2ZV9j aGFubmVsX29yX2VycihzdHJ1Y3QgZGV2aWNlICpkZXYsDQo+ICsJCQkJCQkgIGNvbnN0IGNoYXIg Km5hbWUpOw0KPiAgdm9pZCBkbWFfcmVsZWFzZV9jaGFubmVsKHN0cnVjdCBkbWFfY2hhbiAqY2hh bik7DQo+ICAjZWxzZQ0KPiAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZG1hX2NoYW4gKmRtYV9maW5k X2NoYW5uZWwoZW51bSBkbWFfdHJhbnNhY3Rpb25fdHlwZSB0eF90eXBlKQ0KPiBAQCAtMTA2OCw2 ICsxMDcxLDExIEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IGRtYV9jaGFuICpkbWFfcmVxdWVzdF9z bGF2ZV9jaGFubmVsKHN0cnVjdCBkZXZpY2UgKmRldiwNCj4gIHsNCj4gIAlyZXR1cm4gTlVMTDsN Cj4gIH0NCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRtYV9jaGFuICpkbWFfcmVxdWVzdF9zbGF2 ZV9jaGFubmVsX29yX2VycigNCj4gKwkJCQkJc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBjaGFy ICpuYW1lKQ0KPiArew0KPiArCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOw0KPiArfQ0KPiAgc3Rh dGljIGlubGluZSB2b2lkIGRtYV9yZWxlYXNlX2NoYW5uZWwoc3RydWN0IGRtYV9jaGFuICpjaGFu KQ0KPiAgew0KPiAgfQ0KPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9vZl9kbWEuaCBiL2lu Y2x1ZGUvbGludXgvb2ZfZG1hLmgNCj4gaW5kZXggYWUzNjI5OGJhMDc2Li4wNTA0NDYxNTc0YzYg MTAwNjQ0DQo+IC0tLSBhL2luY2x1ZGUvbGludXgvb2ZfZG1hLmgNCj4gKysrIGIvaW5jbHVkZS9s aW51eC9vZl9kbWEuaA0KPiBAQCAtMzgsNyArMzgsOCBAQCBleHRlcm4gaW50IG9mX2RtYV9jb250 cm9sbGVyX3JlZ2lzdGVyKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsDQo+ICAJCXZvaWQgKmRhdGEp Ow0KPiAgZXh0ZXJuIHZvaWQgb2ZfZG1hX2NvbnRyb2xsZXJfZnJlZShzdHJ1Y3QgZGV2aWNlX25v ZGUgKm5wKTsNCj4gIGV4dGVybiBzdHJ1Y3QgZG1hX2NoYW4gKm9mX2RtYV9yZXF1ZXN0X3NsYXZl X2NoYW5uZWwoc3RydWN0IGRldmljZV9ub2RlICpucCwNCj4gLQkJCQkJCSAgICAgY29uc3QgY2hh ciAqbmFtZSk7DQo+ICsJCQkJCQkgICAgIGNvbnN0IGNoYXIgKm5hbWUsDQo+ICsJCQkJCQkgICAg IGJvb2wgZGVmZXIpOw0KPiAgZXh0ZXJuIHN0cnVjdCBkbWFfY2hhbiAqb2ZfZG1hX3NpbXBsZV94 bGF0ZShzdHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzICpkbWFfc3BlYywNCj4gIAkJc3RydWN0IG9mX2Rt YSAqb2ZkbWEpOw0KPiAgI2Vsc2UNCj4gQEAgLTU0LDggKzU1LDEwIEBAIHN0YXRpYyBpbmxpbmUg dm9pZCBvZl9kbWFfY29udHJvbGxlcl9mcmVlKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApDQo+ICB7 DQo+ICB9DQo+ICANCj4gLXN0YXRpYyBpbmxpbmUgc3RydWN0IGRtYV9jaGFuICpvZl9kbWFfcmVx dWVzdF9zbGF2ZV9jaGFubmVsKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsDQo+IC0JCQkJCQkgICAg IGNvbnN0IGNoYXIgKm5hbWUpDQo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBkbWFfY2hhbiAqb2Zf ZG1hX3JlcXVlc3Rfc2xhdmVfY2hhbm5lbCgNCj4gKwkJCQkJc3RydWN0IGRldmljZV9ub2RlICpu cCwNCj4gKwkJCQkJY29uc3QgY2hhciAqbmFtZSwNCj4gKwkJCQkJYm9vbCBkZWZlcikNCj4gIHsN Cj4gIAlyZXR1cm4gTlVMTDsNCj4gIH0NCg0KLS0gDQpBbmR5IFNoZXZjaGVua28gPGFuZHJpeS5z aGV2Y2hlbmtvQGludGVsLmNvbT4NCkludGVsIEZpbmxhbmQgT3kNCi0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpJbnRl bCBGaW5sYW5kIE95ClJlZ2lzdGVyZWQgQWRkcmVzczogUEwgMjgxLCAwMDE4MSBIZWxzaW5raSAK QnVzaW5lc3MgSWRlbnRpdHkgQ29kZTogMDM1NzYwNiAtIDQgCkRvbWljaWxlZCBpbiBIZWxzaW5r aSAKClRoaXMgZS1tYWlsIGFuZCBhbnkgYXR0YWNobWVudHMgbWF5IGNvbnRhaW4gY29uZmlkZW50 aWFsIG1hdGVyaWFsIGZvcgp0aGUgc29sZSB1c2Ugb2YgdGhlIGludGVuZGVkIHJlY2lwaWVudChz KS4gQW55IHJldmlldyBvciBkaXN0cmlidXRpb24KYnkgb3RoZXJzIGlzIHN0cmljdGx5IHByb2hp Yml0ZWQuIElmIHlvdSBhcmUgbm90IHRoZSBpbnRlbmRlZApyZWNpcGllbnQsIHBsZWFzZSBjb250 YWN0IHRoZSBzZW5kZXIgYW5kIGRlbGV0ZSBhbGwgY29waWVzLgo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: andriy.shevchenko@intel.com (Shevchenko, Andriy) Date: Tue, 19 Nov 2013 11:49:46 +0000 Subject: [PATCH V2] dma: add channel request API that supports deferred probe In-Reply-To: <1384803581-23871-1-git-send-email-swarren@wwwdotorg.org> References: <1384803581-23871-1-git-send-email-swarren@wwwdotorg.org> Message-ID: <1384861763.14845.219.camel@smile> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Mon, 2013-11-18 at 12:39 -0700, Stephen Warren wrote: > From: Stephen Warren Thanks for an updated version. Still couple of comments below. After addressing them Acked-by: Andy Shevchenko for the acpi-dma.c part. > dma_request_slave_channel() simply returns NULL whenever DMA channel > lookup fails. Lookup could fail for two distinct reasons: > > a) No DMA specification exists for the channel name. > This includes situations where no DMA specifications exist at all, or > other general lookup problems. > > b) A DMA specification does exist, yet the driver for that channel is not > yet registered. > > Case (b) should trigger deferred probe in client drivers. However, since > they have no way to differentiate the two situations, it cannot. > > Implement new function dma_request_slave_channel_or_err(), which performs > identically to dma_request_slave_channel(), except that it returns an > error-pointer rather than NULL, which allows callers to detect when > deferred probe should occur. > > Eventually, all drivers should be converted to this new API, the old API > removed, and the new API renamed to the more desirable name. This patch > doesn't convert the existing API and all drivers in one go, since some > drivers call dma_request_slave_channel() then dma_request_channel() if > that fails. That would require modifying dma_request_channel() in the > same way, which would then require modifying close to 100 drivers at once, > rather than just the 15-20 or so that use dma_request_slave_channel(), > which might be tenable in a single patch. > > acpi_dma_request_slave_chan_by_index() doesn't actually implement > deferred probe. Perhaps it should? Yes, it should. You may mentioned that it will be updated later accordingly. > > Cc: treding at nvidia.com > Cc: pdeschrijver at nvidia.com > Cc: linux-tegra at vger.kernel.org > Cc: linux-arm-kernel at lists.infradead.org > Cc: Dan Williams > To: Vinod Koul > To: Andriy Shevchenko > Cc: dmaengine at vger.kernel.org > Signed-off-by: Stephen Warren > --- > v2: > * include in > * Return -ENODATA if slave_id or chan_id out-of-range. > * Return an error-pointer not NULL if we can't find a matching DMA > controller or translate the channel. > > This patch is part of a series with strong internal depdendencies. I'm > looking for an ack so that I can take the entire series through the Tegra > and arm-soc trees. The series will be part of a stable branch that can be > merged into other subsystems if needed to avoid/resolve dependencies. > Note that I'm just reposting this one patch from the series for V2. > > Alternatively, if this patch can be applied directly on top of 3.13-rc1 > (once it appears) alone in a stable topic branch, I can merge that into > my Tegra tree and use it as a base. > --- > drivers/dma/acpi-dma.c | 14 +++++++------- > drivers/dma/dmaengine.c | 44 ++++++++++++++++++++++++++++++++++++++++---- > drivers/dma/of-dma.c | 12 +++++++----- > include/linux/dmaengine.h | 8 ++++++++ > include/linux/of_dma.h | 9 ++++++--- > 5 files changed, 68 insertions(+), 19 deletions(-) > > diff --git a/drivers/dma/acpi-dma.c b/drivers/dma/acpi-dma.c > index e69b03c0fa50..e3d9568f31a3 100644 > --- a/drivers/dma/acpi-dma.c > +++ b/drivers/dma/acpi-dma.c > @@ -334,7 +334,7 @@ static int acpi_dma_parse_fixed_dma(struct acpi_resource *res, void *data) > * @dev: struct device to get DMA request from > * @index: index of FixedDMA descriptor for @dev > * > - * Returns pointer to appropriate dma channel on success or NULL on error. > + * Returns pointer to appropriate dma channel on success or an error pointer. > */ > struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev, > size_t index) > @@ -349,10 +349,10 @@ struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev, > > /* Check if the device was enumerated by ACPI */ > if (!dev || !ACPI_HANDLE(dev)) > - return NULL; > + return ERR_PTR(-ENODEV); > > if (acpi_bus_get_device(ACPI_HANDLE(dev), &adev)) > - return NULL; > + return ERR_PTR(-ENODEV); > > memset(&pdata, 0, sizeof(pdata)); > pdata.index = index; > @@ -367,7 +367,7 @@ struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev, > acpi_dev_free_resource_list(&resource_list); > > if (dma_spec->slave_id < 0 || dma_spec->chan_id < 0) > - return NULL; > + return ERR_PTR(-ENODATA); > > mutex_lock(&acpi_dma_lock); > > @@ -390,7 +390,7 @@ struct dma_chan *acpi_dma_request_slave_chan_by_index(struct device *dev, > } > > mutex_unlock(&acpi_dma_lock); > - return chan; > + return chan ? chan : ERR_PTR(-ENOENT); > } > EXPORT_SYMBOL_GPL(acpi_dma_request_slave_chan_by_index); > > @@ -403,7 +403,7 @@ EXPORT_SYMBOL_GPL(acpi_dma_request_slave_chan_by_index); > * translate the names "tx" and "rx" here based on the most common case where > * the first FixedDMA descriptor is TX and second is RX. > * > - * Returns pointer to appropriate dma channel on success or NULL on error. > + * Returns pointer to appropriate dma channel on success or an error pointer. > */ > struct dma_chan *acpi_dma_request_slave_chan_by_name(struct device *dev, > const char *name) > @@ -415,7 +415,7 @@ struct dma_chan *acpi_dma_request_slave_chan_by_name(struct device *dev, > else if (!strcmp(name, "rx")) > index = 1; > else > - return NULL; > + return ERR_PTR(-ENODEV); I still think -EINVAL suits a bit better here. > > return acpi_dma_request_slave_chan_by_index(dev, index); > } > diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c > index ea806bdc12ef..5e7f8af2f0ec 100644 > --- a/drivers/dma/dmaengine.c > +++ b/drivers/dma/dmaengine.c > @@ -540,6 +540,8 @@ EXPORT_SYMBOL_GPL(dma_get_slave_channel); > * @mask: capabilities that the channel must satisfy > * @fn: optional callback to disposition available channels > * @fn_param: opaque parameter to pass to dma_filter_fn > + * > + * Returns pointer to appropriate dma channel on success or NULL. > */ > struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask, > dma_filter_fn fn, void *fn_param) > @@ -588,24 +590,58 @@ struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask, > EXPORT_SYMBOL_GPL(__dma_request_channel); > > /** > - * dma_request_slave_channel - try to allocate an exclusive slave channel > + * __dma_request_slave_channel - try to allocate an exclusive slave > + * channel > * @dev: pointer to client device structure > * @name: slave channel name > + * > + * Returns pointer to appropriate dma channel on success or an error pointer. > */ > -struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name) > +static struct dma_chan *__dma_request_slave_channel(struct device *dev, > + const char *name, bool defer) > { > /* If device-tree is present get slave info from here */ > if (dev->of_node) > - return of_dma_request_slave_channel(dev->of_node, name); > + return of_dma_request_slave_channel(dev->of_node, name, defer); > > /* If device was enumerated by ACPI get slave info from here */ > if (ACPI_HANDLE(dev)) > return acpi_dma_request_slave_chan_by_name(dev, name); > > - return NULL; > + return ERR_PTR(-ENODEV); > +} > + > +/** > + * dma_request_slave_channel - try to allocate an exclusive slave channel > + * @dev: pointer to client device structure > + * @name: slave channel name > + * > + * Returns pointer to appropriate dma channel on success or NULL. > + */ > +struct dma_chan *dma_request_slave_channel(struct device *dev, > + const char *name) > +{ > + struct dma_chan *ch = __dma_request_slave_channel(dev, name, false); > + if (IS_ERR(ch)) > + return NULL; > + return ch; > } > EXPORT_SYMBOL_GPL(dma_request_slave_channel); > > +/** > + * dma_request_slave_channel_or_err - try to allocate an exclusive slave channel > + * @dev: pointer to client device structure > + * @name: slave channel name > + * > + * Returns pointer to appropriate dma channel on success or an error pointer. > + */ > +struct dma_chan *dma_request_slave_channel_or_err(struct device *dev, > + const char *name) > +{ > + return __dma_request_slave_channel(dev, name, true); > +} > +EXPORT_SYMBOL_GPL(dma_request_slave_channel_or_err); > + > void dma_release_channel(struct dma_chan *chan) > { > mutex_lock(&dma_list_mutex); > diff --git a/drivers/dma/of-dma.c b/drivers/dma/of-dma.c > index 0b88dd3d05f4..928141f6f21b 100644 > --- a/drivers/dma/of-dma.c > +++ b/drivers/dma/of-dma.c > @@ -143,10 +143,10 @@ static int of_dma_match_channel(struct device_node *np, const char *name, > * @np: device node to get DMA request from > * @name: name of desired channel > * > - * Returns pointer to appropriate dma channel on success or NULL on error. > + * Returns pointer to appropriate dma channel on success or an error pointer. > */ > struct dma_chan *of_dma_request_slave_channel(struct device_node *np, > - const char *name) > + const char *name, bool defer) > { > struct of_phandle_args dma_spec; > struct of_dma *ofdma; > @@ -155,14 +155,14 @@ struct dma_chan *of_dma_request_slave_channel(struct device_node *np, > > if (!np || !name) { > pr_err("%s: not enough information provided\n", __func__); > - return NULL; > + return ERR_PTR(-ENODEV); > } > > count = of_property_count_strings(np, "dma-names"); > if (count < 0) { > pr_err("%s: dma-names property of node '%s' missing or empty\n", > __func__, np->full_name); > - return NULL; > + return ERR_PTR(-ENODEV); > } > > for (i = 0; i < count; i++) { > @@ -181,11 +181,13 @@ struct dma_chan *of_dma_request_slave_channel(struct device_node *np, > > of_node_put(dma_spec.np); > > + if (!ofdma && defer) > + return ERR_PTR(-EPROBE_DEFER); > if (chan) > return chan; > } > > - return NULL; > + return ERR_PTR(-ENODEV); > } > > /** > diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h > index 41cf0c399288..f156c145fad2 100644 > --- a/include/linux/dmaengine.h > +++ b/include/linux/dmaengine.h > @@ -22,6 +22,7 @@ > #define LINUX_DMAENGINE_H > > #include > +#include > #include > #include > #include > @@ -1041,6 +1042,8 @@ void dma_issue_pending_all(void); > struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask, > dma_filter_fn fn, void *fn_param); > struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name); > +struct dma_chan *dma_request_slave_channel_or_err(struct device *dev, > + const char *name); > void dma_release_channel(struct dma_chan *chan); > #else > static inline struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) > @@ -1068,6 +1071,11 @@ static inline struct dma_chan *dma_request_slave_channel(struct device *dev, > { > return NULL; > } > +static inline struct dma_chan *dma_request_slave_channel_or_err( > + struct device *dev, const char *name) > +{ > + return ERR_PTR(-ENODEV); > +} > static inline void dma_release_channel(struct dma_chan *chan) > { > } > diff --git a/include/linux/of_dma.h b/include/linux/of_dma.h > index ae36298ba076..0504461574c6 100644 > --- a/include/linux/of_dma.h > +++ b/include/linux/of_dma.h > @@ -38,7 +38,8 @@ extern int of_dma_controller_register(struct device_node *np, > void *data); > extern void of_dma_controller_free(struct device_node *np); > extern struct dma_chan *of_dma_request_slave_channel(struct device_node *np, > - const char *name); > + const char *name, > + bool defer); > extern struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec, > struct of_dma *ofdma); > #else > @@ -54,8 +55,10 @@ static inline void of_dma_controller_free(struct device_node *np) > { > } > > -static inline struct dma_chan *of_dma_request_slave_channel(struct device_node *np, > - const char *name) > +static inline struct dma_chan *of_dma_request_slave_channel( > + struct device_node *np, > + const char *name, > + bool defer) > { > return NULL; > } -- Andy Shevchenko Intel Finland Oy --------------------------------------------------------------------- Intel Finland Oy Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.