From mboxrd@z Thu Jan 1 00:00:00 1970 From: Robin Murphy Subject: Re: [PATCH v16 1/5] iommu/arm-smmu: Add pm_runtime/sleep ops Date: Wed, 26 Sep 2018 16:27:39 +0100 Message-ID: <1a918f99-83b0-2f51-7634-126639a220de@arm.com> References: <20180830144541.17740-1-vivek.gautam@codeaurora.org> <20180830144541.17740-2-vivek.gautam@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180830144541.17740-2-vivek.gautam-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org> Content-Language: en-GB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: Vivek Gautam , joro-zLv9SwRftAIdnm+yROfE0A@public.gmane.org, robh+dt-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, will.deacon-5wv7dgnIgG8@public.gmane.org, iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org Cc: mark.rutland-5wv7dgnIgG8@public.gmane.org, architt-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, jcrouse-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, linux-pm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, sboyd-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, sricharan-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, rjw-LthD3rsA81gm4RdzfppkhA@public.gmane.org, robdclark-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, tfiga-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, alex.williamson-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org, linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, m.szyprowski-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org List-Id: linux-arm-msm@vger.kernel.org T24gMzAvMDgvMTggMTU6NDUsIFZpdmVrIEdhdXRhbSB3cm90ZToKPiBGcm9tOiBTcmljaGFyYW4g UiA8c3JpY2hhcmFuQGNvZGVhdXJvcmEub3JnPgo+IAo+IFRoZSBzbW11IG5lZWRzIHRvIGJlIGZ1 bmN0aW9uYWwgb25seSB3aGVuIHRoZSByZXNwZWN0aXZlCj4gbWFzdGVyJ3MgdXNpbmcgaXQgYXJl IGFjdGl2ZS4gVGhlIGRldmljZV9saW5rIGZlYXR1cmUKPiBoZWxwcyB0byB0cmFjayBzdWNoIGZ1 bmN0aW9uYWwgZGVwZW5kZW5jaWVzLCBzbyB0aGF0IHRoZQo+IGlvbW11IGdldHMgcG93ZXJlZCB3 aGVuIHRoZSBtYXN0ZXIgZGV2aWNlIGVuYWJsZXMgaXRzZWxmCj4gdXNpbmcgcG1fcnVudGltZS4g U28gYnkgYWRhcHRpbmcgdGhlIHNtbXUgZHJpdmVyIGZvcgo+IHJ1bnRpbWUgcG0sIGFib3ZlIHNh aWQgZGVwZW5kZW5jeSBjYW4gYmUgYWRkcmVzc2VkLgo+IAo+IFRoaXMgcGF0Y2ggYWRkcyB0aGUg cG0gcnVudGltZS9zbGVlcCBjYWxsYmFja3MgdG8gdGhlCj4gZHJpdmVyIGFuZCBhbHNvIHRoZSBm dW5jdGlvbnMgdG8gcGFyc2UgdGhlIHNtbXUgY2xvY2tzCj4gZnJvbSBEVCBhbmQgZW5hYmxlIHRo ZW0gaW4gcmVzdW1lL3N1c3BlbmQuCj4gCj4gQWxzbywgd2hpbGUgd2UgZW5hYmxlIHRoZSBydW50 aW1lIHBtIGFkZCBhIHBtIHNsZWVwIHN1c3BlbmQKPiBjYWxsYmFjayB0aGF0IHB1c2hlcyBkZXZp Y2VzIHRvIGxvdyBwb3dlciBzdGF0ZSBieSB0dXJuaW5nCj4gdGhlIGNsb2NrcyBvZmYgaW4gYSBz eXN0ZW0gc2xlZXAuCj4gQWxzbyBhZGQgY29ycmVzcG9uZGluZyBjbG9jayBlbmFibGUgcGF0aCBp biByZXN1bWUgY2FsbGJhY2suCj4gCj4gU2lnbmVkLW9mZi1ieTogU3JpY2hhcmFuIFIgPHNyaWNo YXJhbkBjb2RlYXVyb3JhLm9yZz4KPiBTaWduZWQtb2ZmLWJ5OiBBcmNoaXQgVGFuZWphIDxhcmNo aXR0QGNvZGVhdXJvcmEub3JnPgo+IFt2aXZlazogcmV3b3JrIGZvciBjbG9jayBhbmQgcG0gb3Bz XQo+IFNpZ25lZC1vZmYtYnk6IFZpdmVrIEdhdXRhbSA8dml2ZWsuZ2F1dGFtQGNvZGVhdXJvcmEu b3JnPgo+IFJldmlld2VkLWJ5OiBUb21hc3ogRmlnYSA8dGZpZ2FAY2hyb21pdW0ub3JnPgo+IFRl c3RlZC1ieTogU3Jpbml2YXMgS2FuZGFnYXRsYSA8c3Jpbml2YXMua2FuZGFnYXRsYUBsaW5hcm8u b3JnPgo+IC0tLQo+ICAgZHJpdmVycy9pb21tdS9hcm0tc21tdS5jIHwgNzcgKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tCj4gICAxIGZpbGUgY2hhbmdlZCwg NzQgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9pb21tdS9hcm0tc21tdS5jIGIvZHJpdmVycy9pb21tdS9hcm0tc21tdS5jCj4gaW5kZXggZmQx YjgwZWY5NDkwLi5kOTAwZTAwN2MzYzkgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9pb21tdS9hcm0t c21tdS5jCj4gKysrIGIvZHJpdmVycy9pb21tdS9hcm0tc21tdS5jCj4gQEAgLTQ4LDYgKzQ4LDcg QEAKPiAgICNpbmNsdWRlIDxsaW51eC9vZl9pb21tdS5oPgo+ICAgI2luY2x1ZGUgPGxpbnV4L3Bj aS5oPgo+ICAgI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8 bGludXgvcG1fcnVudGltZS5oPgo+ICAgI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiAgICNpbmNs dWRlIDxsaW51eC9zcGlubG9jay5oPgo+ICAgCj4gQEAgLTIwNSw2ICsyMDYsOCBAQCBzdHJ1Y3Qg YXJtX3NtbXVfZGV2aWNlIHsKPiAgIAl1MzIJCQkJbnVtX2dsb2JhbF9pcnFzOwo+ICAgCXUzMgkJ CQludW1fY29udGV4dF9pcnFzOwo+ICAgCXVuc2lnbmVkIGludAkJCSppcnFzOwo+ICsJc3RydWN0 IGNsa19idWxrX2RhdGEJCSpjbGtzOwo+ICsJaW50CQkJCW51bV9jbGtzOwo+ICAgCj4gICAJdTMy CQkJCWNhdml1bV9pZF9iYXNlOyAvKiBTcGVjaWZpYyB0byBDYXZpdW0gKi8KPiAgIAo+IEBAIC0x ODk2LDEwICsxODk5LDEyIEBAIHN0YXRpYyBpbnQgYXJtX3NtbXVfZGV2aWNlX2NmZ19wcm9iZShz dHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11KQo+ICAgc3RydWN0IGFybV9zbW11X21hdGNoX2Rh dGEgewo+ICAgCWVudW0gYXJtX3NtbXVfYXJjaF92ZXJzaW9uIHZlcnNpb247Cj4gICAJZW51bSBh cm1fc21tdV9pbXBsZW1lbnRhdGlvbiBtb2RlbDsKPiArCWNvbnN0IGNoYXIgKiBjb25zdCAqY2xr czsKPiArCWludCBudW1fY2xrczsKPiAgIH07Cj4gICAKPiAgICNkZWZpbmUgQVJNX1NNTVVfTUFU Q0hfREFUQShuYW1lLCB2ZXIsIGltcCkJXAo+IC1zdGF0aWMgc3RydWN0IGFybV9zbW11X21hdGNo X2RhdGEgbmFtZSA9IHsgLnZlcnNpb24gPSB2ZXIsIC5tb2RlbCA9IGltcCB9Cj4gK3N0YXRpYyBj b25zdCBzdHJ1Y3QgYXJtX3NtbXVfbWF0Y2hfZGF0YSBuYW1lID0geyAudmVyc2lvbiA9IHZlciwg Lm1vZGVsID0gaW1wIH0KPiAgIAo+ICAgQVJNX1NNTVVfTUFUQ0hfREFUQShzbW11X2dlbmVyaWNf djEsIEFSTV9TTU1VX1YxLCBHRU5FUklDX1NNTVUpOwo+ICAgQVJNX1NNTVVfTUFUQ0hfREFUQShz bW11X2dlbmVyaWNfdjIsIEFSTV9TTU1VX1YyLCBHRU5FUklDX1NNTVUpOwo+IEBAIC0xOTE4LDYg KzE5MjMsMjMgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYXJtX3NtbXVfb2Zf bWF0Y2hbXSA9IHsKPiAgIH07Cj4gICBNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBhcm1fc21tdV9v Zl9tYXRjaCk7Cj4gICAKPiArc3RhdGljIHZvaWQgYXJtX3NtbXVfZmlsbF9jbGtfZGF0YShzdHJ1 Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11LAo+ICsJCQkJICAgY29uc3QgY2hhciAqIGNvbnN0ICpj bGtzKQo+ICt7Cj4gKwlpbnQgaTsKPiArCj4gKwlpZiAoc21tdS0+bnVtX2Nsa3MgPCAxKQo+ICsJ CXJldHVybjsKPiArCj4gKwlzbW11LT5jbGtzID0gZGV2bV9rY2FsbG9jKHNtbXUtPmRldiwgc21t dS0+bnVtX2Nsa3MsCj4gKwkJCQkgIHNpemVvZigqc21tdS0+Y2xrcyksIEdGUF9LRVJORUwpOwo+ ICsJaWYgKCFzbW11LT5jbGtzKQo+ICsJCXJldHVybjsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwg c21tdS0+bnVtX2Nsa3M7IGkrKykKPiArCQlzbW11LT5jbGtzW2ldLmlkID0gY2xrc1tpXTsKPiAr fQo+ICsKPiAgICNpZmRlZiBDT05GSUdfQUNQSQo+ICAgc3RhdGljIGludCBhY3BpX3NtbXVfZ2V0 X2RhdGEodTMyIG1vZGVsLCBzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11KQo+ICAgewo+IEBA IC0yMDAwLDYgKzIwMjIsOSBAQCBzdGF0aWMgaW50IGFybV9zbW11X2RldmljZV9kdF9wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAo+ICAgCWRhdGEgPSBvZl9kZXZpY2VfZ2V0X21h dGNoX2RhdGEoZGV2KTsKPiAgIAlzbW11LT52ZXJzaW9uID0gZGF0YS0+dmVyc2lvbjsKPiAgIAlz bW11LT5tb2RlbCA9IGRhdGEtPm1vZGVsOwo+ICsJc21tdS0+bnVtX2Nsa3MgPSBkYXRhLT5udW1f Y2xrczsKPiArCj4gKwlhcm1fc21tdV9maWxsX2Nsa19kYXRhKHNtbXUsIGRhdGEtPmNsa3MpOwo+ ICAgCj4gICAJcGFyc2VfZHJpdmVyX29wdGlvbnMoc21tdSk7Cj4gICAKPiBAQCAtMjA5OCw2ICsy MTIzLDE0IEBAIHN0YXRpYyBpbnQgYXJtX3NtbXVfZGV2aWNlX3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCj4gICAJCXNtbXUtPmlycXNbaV0gPSBpcnE7Cj4gICAJfQo+ICAgCj4g KwllcnIgPSBkZXZtX2Nsa19idWxrX2dldChzbW11LT5kZXYsIHNtbXUtPm51bV9jbGtzLCBzbW11 LT5jbGtzKTsKPiArCWlmIChlcnIpCj4gKwkJcmV0dXJuIGVycjsKPiArCj4gKwllcnIgPSBjbGtf YnVsa19wcmVwYXJlX2VuYWJsZShzbW11LT5udW1fY2xrcywgc21tdS0+Y2xrcyk7Cj4gKwlpZiAo ZXJyKQo+ICsJCXJldHVybiBlcnI7Cj4gKwoKSG1tLCBpZiB3ZSBlcnJvciBvdXQgYmV5b25kIGhl cmUgaXQgbG9va3MgbGlrZSB3ZSBzaG91bGQgc3RyaWN0bHkgCmJhbGFuY2UgdGhhdCBwcmVwYXJl L2VuYWJsZSBiZWZvcmUgZGV2cmVzIGRvZXMgdGhlIGNsa19idWxrX3B1dCgpLCAKaG93ZXZlciB0 aGUgcHJvYmUgZXJyb3IgcGF0aCBpcyBzdGFydGluZyB0byBsb29rIGxpa2UgaXQgbmVlZHMgYSBi aXQgb2YgCmxvdmUgaW4gZ2VuZXJhbCwgc28gSSBtaWdodCBqdXN0IHNwaW4gYSBjbGVhbnVwIHBh dGNoIG9uIHRvcCAoYW5kIGV2ZW4gCnRoZW4gb25seSBmb3IgdGhlIHNha2Ugb2Ygbm90IGJlaW5n IGEgYmFkIGV4YW1wbGU7IFNNTVUgcHJvYmUgZmFpbHVyZSBpcyAKbmV2ZXIgYSByZWFsaXN0aWMg c2l0dWF0aW9uIGZvciB0aGUgc3lzdGVtIHRvIGFjdHVhbGx5IHJlY292ZXIgZnJvbSkuCgpPdGhl cndpc2UsCgpSZXZpZXdlZC1ieTogUm9iaW4gTXVycGh5IDxyb2Jpbi5tdXJwaHlAYXJtLmNvbT4K Cj4gICAJZXJyID0gYXJtX3NtbXVfZGV2aWNlX2NmZ19wcm9iZShzbW11KTsKPiAgIAlpZiAoZXJy KQo+ICAgCQlyZXR1cm4gZXJyOwo+IEBAIC0yMTg0LDYgKzIyMTcsOSBAQCBzdGF0aWMgaW50IGFy bV9zbW11X2RldmljZV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiAgIAo+ ICAgCS8qIFR1cm4gdGhlIHRoaW5nIG9mZiAqLwo+ICAgCXdyaXRlbChzQ1IwX0NMSUVOVFBELCBB Uk1fU01NVV9HUjBfTlMoc21tdSkgKyBBUk1fU01NVV9HUjBfc0NSMCk7Cj4gKwo+ICsJY2xrX2J1 bGtfZGlzYWJsZV91bnByZXBhcmUoc21tdS0+bnVtX2Nsa3MsIHNtbXUtPmNsa3MpOwo+ICsKPiAg IAlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+IEBAIC0yMTkyLDE1ICsyMjI4LDUwIEBAIHN0YXRpYyB2 b2lkIGFybV9zbW11X2RldmljZV9zaHV0ZG93bihzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 KQo+ICAgCWFybV9zbW11X2RldmljZV9yZW1vdmUocGRldik7Cj4gICB9Cj4gICAKPiAtc3RhdGlj IGludCBfX21heWJlX3VudXNlZCBhcm1fc21tdV9wbV9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2 KQo+ICtzdGF0aWMgaW50IF9fbWF5YmVfdW51c2VkIGFybV9zbW11X3J1bnRpbWVfcmVzdW1lKHN0 cnVjdCBkZXZpY2UgKmRldikKPiAgIHsKPiAgIAlzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11 ID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGNsa19i dWxrX2VuYWJsZShzbW11LT5udW1fY2xrcywgc21tdS0+Y2xrcyk7Cj4gKwlpZiAocmV0KQo+ICsJ CXJldHVybiByZXQ7Cj4gICAKPiAgIAlhcm1fc21tdV9kZXZpY2VfcmVzZXQoc21tdSk7Cj4gKwo+ ICAgCXJldHVybiAwOwo+ICAgfQo+ICAgCj4gLXN0YXRpYyBTSU1QTEVfREVWX1BNX09QUyhhcm1f c21tdV9wbV9vcHMsIE5VTEwsIGFybV9zbW11X3BtX3Jlc3VtZSk7Cj4gK3N0YXRpYyBpbnQgX19t YXliZV91bnVzZWQgYXJtX3NtbXVfcnVudGltZV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikK PiArewo+ICsJc3RydWN0IGFybV9zbW11X2RldmljZSAqc21tdSA9IGRldl9nZXRfZHJ2ZGF0YShk ZXYpOwo+ICsKPiArCWNsa19idWxrX2Rpc2FibGUoc21tdS0+bnVtX2Nsa3MsIHNtbXUtPmNsa3Mp Owo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IF9fbWF5YmVfdW51c2Vk IGFybV9zbW11X3BtX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCWlmIChwbV9y dW50aW1lX3N1c3BlbmRlZChkZXYpKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCXJldHVybiBhcm1f c21tdV9ydW50aW1lX3Jlc3VtZShkZXYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IF9fbWF5YmVf dW51c2VkIGFybV9zbW11X3BtX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlp ZiAocG1fcnVudGltZV9zdXNwZW5kZWQoZGV2KSkKPiArCQlyZXR1cm4gMDsKPiArCj4gKwlyZXR1 cm4gYXJtX3NtbXVfcnVudGltZV9zdXNwZW5kKGRldik7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25z dCBzdHJ1Y3QgZGV2X3BtX29wcyBhcm1fc21tdV9wbV9vcHMgPSB7Cj4gKwlTRVRfU1lTVEVNX1NM RUVQX1BNX09QUyhhcm1fc21tdV9wbV9zdXNwZW5kLCBhcm1fc21tdV9wbV9yZXN1bWUpCj4gKwlT RVRfUlVOVElNRV9QTV9PUFMoYXJtX3NtbXVfcnVudGltZV9zdXNwZW5kLAo+ICsJCQkgICBhcm1f c21tdV9ydW50aW1lX3Jlc3VtZSwgTlVMTCkKPiArfTsKPiAgIAo+ICAgc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kcml2ZXIgYXJtX3NtbXVfZHJpdmVyID0gewo+ICAgCS5kcml2ZXIJPSB7Cj4gCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkZyZWVkcmVubyBt YWlsaW5nIGxpc3QKRnJlZWRyZW5vQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ZyZWVkcmVubwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0E1D6C43382 for ; Wed, 26 Sep 2018 15:27:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id B8D9E214FF for ; Wed, 26 Sep 2018 15:27:46 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B8D9E214FF Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728266AbeIZVlM (ORCPT ); Wed, 26 Sep 2018 17:41:12 -0400 Received: from foss.arm.com ([217.140.101.70]:48540 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727067AbeIZVlL (ORCPT ); Wed, 26 Sep 2018 17:41:11 -0400 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 1827C18A; Wed, 26 Sep 2018 08:27:44 -0700 (PDT) Received: from [10.4.12.131] (e110467-lin.emea.arm.com [10.4.12.131]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id E02003F5BD; Wed, 26 Sep 2018 08:27:40 -0700 (PDT) Subject: Re: [PATCH v16 1/5] iommu/arm-smmu: Add pm_runtime/sleep ops To: Vivek Gautam , joro@8bytes.org, robh+dt@kernel.org, will.deacon@arm.com, iommu@lists.linux-foundation.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Cc: alex.williamson@redhat.com, mark.rutland@arm.com, rjw@rjwysocki.net, robdclark@gmail.com, linux-pm@vger.kernel.org, freedreno@lists.freedesktop.org, sboyd@kernel.org, tfiga@chromium.org, jcrouse@codeaurora.org, sricharan@codeaurora.org, m.szyprowski@samsung.com, architt@codeaurora.org, linux-arm-msm@vger.kernel.org References: <20180830144541.17740-1-vivek.gautam@codeaurora.org> <20180830144541.17740-2-vivek.gautam@codeaurora.org> From: Robin Murphy Message-ID: <1a918f99-83b0-2f51-7634-126639a220de@arm.com> Date: Wed, 26 Sep 2018 16:27:39 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: <20180830144541.17740-2-vivek.gautam@codeaurora.org> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-GB Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 30/08/18 15:45, Vivek Gautam wrote: > From: Sricharan R > > The smmu needs to be functional only when the respective > master's using it are active. The device_link feature > helps to track such functional dependencies, so that the > iommu gets powered when the master device enables itself > using pm_runtime. So by adapting the smmu driver for > runtime pm, above said dependency can be addressed. > > This patch adds the pm runtime/sleep callbacks to the > driver and also the functions to parse the smmu clocks > from DT and enable them in resume/suspend. > > Also, while we enable the runtime pm add a pm sleep suspend > callback that pushes devices to low power state by turning > the clocks off in a system sleep. > Also add corresponding clock enable path in resume callback. > > Signed-off-by: Sricharan R > Signed-off-by: Archit Taneja > [vivek: rework for clock and pm ops] > Signed-off-by: Vivek Gautam > Reviewed-by: Tomasz Figa > Tested-by: Srinivas Kandagatla > --- > drivers/iommu/arm-smmu.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++-- > 1 file changed, 74 insertions(+), 3 deletions(-) > > diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c > index fd1b80ef9490..d900e007c3c9 100644 > --- a/drivers/iommu/arm-smmu.c > +++ b/drivers/iommu/arm-smmu.c > @@ -48,6 +48,7 @@ > #include > #include > #include > +#include > #include > #include > > @@ -205,6 +206,8 @@ struct arm_smmu_device { > u32 num_global_irqs; > u32 num_context_irqs; > unsigned int *irqs; > + struct clk_bulk_data *clks; > + int num_clks; > > u32 cavium_id_base; /* Specific to Cavium */ > > @@ -1896,10 +1899,12 @@ static int arm_smmu_device_cfg_probe(struct arm_smmu_device *smmu) > struct arm_smmu_match_data { > enum arm_smmu_arch_version version; > enum arm_smmu_implementation model; > + const char * const *clks; > + int num_clks; > }; > > #define ARM_SMMU_MATCH_DATA(name, ver, imp) \ > -static struct arm_smmu_match_data name = { .version = ver, .model = imp } > +static const struct arm_smmu_match_data name = { .version = ver, .model = imp } > > ARM_SMMU_MATCH_DATA(smmu_generic_v1, ARM_SMMU_V1, GENERIC_SMMU); > ARM_SMMU_MATCH_DATA(smmu_generic_v2, ARM_SMMU_V2, GENERIC_SMMU); > @@ -1918,6 +1923,23 @@ static const struct of_device_id arm_smmu_of_match[] = { > }; > MODULE_DEVICE_TABLE(of, arm_smmu_of_match); > > +static void arm_smmu_fill_clk_data(struct arm_smmu_device *smmu, > + const char * const *clks) > +{ > + int i; > + > + if (smmu->num_clks < 1) > + return; > + > + smmu->clks = devm_kcalloc(smmu->dev, smmu->num_clks, > + sizeof(*smmu->clks), GFP_KERNEL); > + if (!smmu->clks) > + return; > + > + for (i = 0; i < smmu->num_clks; i++) > + smmu->clks[i].id = clks[i]; > +} > + > #ifdef CONFIG_ACPI > static int acpi_smmu_get_data(u32 model, struct arm_smmu_device *smmu) > { > @@ -2000,6 +2022,9 @@ static int arm_smmu_device_dt_probe(struct platform_device *pdev, > data = of_device_get_match_data(dev); > smmu->version = data->version; > smmu->model = data->model; > + smmu->num_clks = data->num_clks; > + > + arm_smmu_fill_clk_data(smmu, data->clks); > > parse_driver_options(smmu); > > @@ -2098,6 +2123,14 @@ static int arm_smmu_device_probe(struct platform_device *pdev) > smmu->irqs[i] = irq; > } > > + err = devm_clk_bulk_get(smmu->dev, smmu->num_clks, smmu->clks); > + if (err) > + return err; > + > + err = clk_bulk_prepare_enable(smmu->num_clks, smmu->clks); > + if (err) > + return err; > + Hmm, if we error out beyond here it looks like we should strictly balance that prepare/enable before devres does the clk_bulk_put(), however the probe error path is starting to look like it needs a bit of love in general, so I might just spin a cleanup patch on top (and even then only for the sake of not being a bad example; SMMU probe failure is never a realistic situation for the system to actually recover from). Otherwise, Reviewed-by: Robin Murphy > err = arm_smmu_device_cfg_probe(smmu); > if (err) > return err; > @@ -2184,6 +2217,9 @@ static int arm_smmu_device_remove(struct platform_device *pdev) > > /* Turn the thing off */ > writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); > + > + clk_bulk_disable_unprepare(smmu->num_clks, smmu->clks); > + > return 0; > } > > @@ -2192,15 +2228,50 @@ static void arm_smmu_device_shutdown(struct platform_device *pdev) > arm_smmu_device_remove(pdev); > } > > -static int __maybe_unused arm_smmu_pm_resume(struct device *dev) > +static int __maybe_unused arm_smmu_runtime_resume(struct device *dev) > { > struct arm_smmu_device *smmu = dev_get_drvdata(dev); > + int ret; > + > + ret = clk_bulk_enable(smmu->num_clks, smmu->clks); > + if (ret) > + return ret; > > arm_smmu_device_reset(smmu); > + > return 0; > } > > -static SIMPLE_DEV_PM_OPS(arm_smmu_pm_ops, NULL, arm_smmu_pm_resume); > +static int __maybe_unused arm_smmu_runtime_suspend(struct device *dev) > +{ > + struct arm_smmu_device *smmu = dev_get_drvdata(dev); > + > + clk_bulk_disable(smmu->num_clks, smmu->clks); > + > + return 0; > +} > + > +static int __maybe_unused arm_smmu_pm_resume(struct device *dev) > +{ > + if (pm_runtime_suspended(dev)) > + return 0; > + > + return arm_smmu_runtime_resume(dev); > +} > + > +static int __maybe_unused arm_smmu_pm_suspend(struct device *dev) > +{ > + if (pm_runtime_suspended(dev)) > + return 0; > + > + return arm_smmu_runtime_suspend(dev); > +} > + > +static const struct dev_pm_ops arm_smmu_pm_ops = { > + SET_SYSTEM_SLEEP_PM_OPS(arm_smmu_pm_suspend, arm_smmu_pm_resume) > + SET_RUNTIME_PM_OPS(arm_smmu_runtime_suspend, > + arm_smmu_runtime_resume, NULL) > +}; > > static struct platform_driver arm_smmu_driver = { > .driver = { >