From mboxrd@z Thu Jan 1 00:00:00 1970 From: Vivek Gautam Subject: [PATCH v17 2/5] iommu/arm-smmu: Invoke pm_runtime during probe, add/remove device Date: Tue, 2 Oct 2018 12:42:31 +0530 Message-ID: <20181002071231.9787-1-vivek.gautam@codeaurora.org> References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: joro-zLv9SwRftAIdnm+yROfE0A@public.gmane.org, robh+dt-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, rjw-LthD3rsA81gm4RdzfppkhA@public.gmane.org, robin.murphy-5wv7dgnIgG8@public.gmane.org, will.deacon-5wv7dgnIgG8@public.gmane.org, iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org Cc: mark.rutland-5wv7dgnIgG8@public.gmane.org, devicetree-u79uwXL29TY76Z2rM5mHXA@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, robdclark-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, tfiga-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, alex.williamson-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org, Vivek Gautam , linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, m.szyprowski-Sze3O3UU22JBDgjK7y7TUQ@public.gmane.org List-Id: linux-arm-msm@vger.kernel.org RnJvbTogU3JpY2hhcmFuIFIgPHNyaWNoYXJhbkBjb2RlYXVyb3JhLm9yZz4KClRoZSBzbW11IGRl dmljZSBwcm9iZS9yZW1vdmUgYW5kIGFkZC9yZW1vdmUgbWFzdGVyIGRldmljZSBjYWxsYmFja3MK Z2V0cyBjYWxsZWQgd2hlbiB0aGUgc21tdSBpcyBub3QgbGlua2VkIHRvIGl0cyBtYXN0ZXIsIHRo YXQgaXMgd2l0aG91dAp0aGUgY29udGV4dCBvZiB0aGUgbWFzdGVyIGRldmljZS4gU28gY2FsbGlu ZyBydW50aW1lIGFwaXMgaW4gdGhvc2UgcGxhY2VzCnNlcGFyYXRlbHkuCkdsb2JhbCBsb2NrcyBh cmUgYWxzbyBpbml0aWFsaXplZCBiZWZvcmUgZW5hYmxpbmcgcnVudGltZSBwbSBhcyB0aGUKcnVu dGltZV9yZXN1bWUoKSBjYWxscyBkZXZpY2VfcmVzZXQoKSB3aGljaCBkb2VzIHRsYl9zeW5jX2ds b2JhbCgpCnRoYXQgdWx0aW1hdGVseSByZXF1aXJlcyBsb2NrcyB0byBiZSBpbml0aWFsaXplZC4K ClNpZ25lZC1vZmYtYnk6IFNyaWNoYXJhbiBSIDxzcmljaGFyYW5AY29kZWF1cm9yYS5vcmc+Clt2 aXZlazogQ2xlYW51cCBwbSBydW50aW1lIGNhbGxzXQpTaWduZWQtb2ZmLWJ5OiBWaXZlayBHYXV0 YW0gPHZpdmVrLmdhdXRhbUBjb2RlYXVyb3JhLm9yZz4KUmV2aWV3ZWQtYnk6IFRvbWFzeiBGaWdh IDx0ZmlnYUBjaHJvbWl1bS5vcmc+ClRlc3RlZC1ieTogU3Jpbml2YXMgS2FuZGFnYXRsYSA8c3Jp bml2YXMua2FuZGFnYXRsYUBsaW5hcm8ub3JnPgpSZXZpZXdlZC1ieTogUm9iaW4gTXVycGh5IDxy b2Jpbi5tdXJwaHlAYXJtLmNvbT4KLS0tCgpDaGFuZ2VzIHNpbmNlIHYxNjoKIC0gUmViYXNlZCBv biBXaWxsJ3MgdHJlZSBmb3IgYXJtLXNtbXUgdXBkYXRlcyBbMV0uCiAtIEFkZGVkIHJwbXtnZXR8 cHV0fSBjYWxscyB0byAuZmx1c2hfaW90bGJfYWxsLCBhbmQgLmlvdGxiX3N5bmMKICAgY2FsbGJh Y2tzIHRvIHRha2UgY2FyZSBvZiBub24tc3RyaWN0IHRsYiBmbHVzaCBxdWV1ZSB1cGRhdGVzLgoK IGRyaXZlcnMvaW9tbXUvYXJtLXNtbXUuYyB8IDEwMSArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKystLS0tLQogMSBmaWxlIGNoYW5nZWQsIDkxIGluc2VydGlvbnMoKyks IDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvYXJtLXNtbXUuYyBi L2RyaXZlcnMvaW9tbXUvYXJtLXNtbXUuYwppbmRleCA1OWQxNDMwYTlmMmQuLmJmMTA2Njg4YWI3 YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pb21tdS9hcm0tc21tdS5jCisrKyBiL2RyaXZlcnMvaW9t bXUvYXJtLXNtbXUuYwpAQCAtMjY5LDYgKzI2OSwyMCBAQCBzdGF0aWMgc3RydWN0IGFybV9zbW11 X29wdGlvbl9wcm9wIGFybV9zbW11X29wdGlvbnNbXSA9IHsKIAl7IDAsIE5VTEx9LAogfTsKIAor c3RhdGljIGlubGluZSBpbnQgYXJtX3NtbXVfcnBtX2dldChzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNl ICpzbW11KQoreworCWlmIChwbV9ydW50aW1lX2VuYWJsZWQoc21tdS0+ZGV2KSkKKwkJcmV0dXJu IHBtX3J1bnRpbWVfZ2V0X3N5bmMoc21tdS0+ZGV2KTsKKworCXJldHVybiAwOworfQorCitzdGF0 aWMgaW5saW5lIHZvaWQgYXJtX3NtbXVfcnBtX3B1dChzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpz bW11KQoreworCWlmIChwbV9ydW50aW1lX2VuYWJsZWQoc21tdS0+ZGV2KSkKKwkJcG1fcnVudGlt ZV9wdXQoc21tdS0+ZGV2KTsKK30KKwogc3RhdGljIHN0cnVjdCBhcm1fc21tdV9kb21haW4gKnRv X3NtbXVfZG9tYWluKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbSkKIHsKIAlyZXR1cm4gY29udGFp bmVyX29mKGRvbSwgc3RydWN0IGFybV9zbW11X2RvbWFpbiwgZG9tYWluKTsKQEAgLTkyOCwxMSAr OTQyLDE1IEBAIHN0YXRpYyB2b2lkIGFybV9zbW11X2Rlc3Ryb3lfZG9tYWluX2NvbnRleHQoc3Ry dWN0IGlvbW11X2RvbWFpbiAqZG9tYWluKQogCXN0cnVjdCBhcm1fc21tdV9kb21haW4gKnNtbXVf ZG9tYWluID0gdG9fc21tdV9kb21haW4oZG9tYWluKTsKIAlzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNl ICpzbW11ID0gc21tdV9kb21haW4tPnNtbXU7CiAJc3RydWN0IGFybV9zbW11X2NmZyAqY2ZnID0g JnNtbXVfZG9tYWluLT5jZmc7Ci0JaW50IGlycTsKKwlpbnQgcmV0LCBpcnE7CiAKIAlpZiAoIXNt bXUgfHwgZG9tYWluLT50eXBlID09IElPTU1VX0RPTUFJTl9JREVOVElUWSkKIAkJcmV0dXJuOwog CisJcmV0ID0gYXJtX3NtbXVfcnBtX2dldChzbW11KTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJu OworCiAJLyoKIAkgKiBEaXNhYmxlIHRoZSBjb250ZXh0IGJhbmsgYW5kIGZyZWUgdGhlIHBhZ2Ug dGFibGVzIGJlZm9yZSBmcmVlaW5nCiAJICogaXQuCkBAIC05NDcsNiArOTY1LDggQEAgc3RhdGlj IHZvaWQgYXJtX3NtbXVfZGVzdHJveV9kb21haW5fY29udGV4dChzdHJ1Y3QgaW9tbXVfZG9tYWlu ICpkb21haW4pCiAKIAlmcmVlX2lvX3BndGFibGVfb3BzKHNtbXVfZG9tYWluLT5wZ3RibF9vcHMp OwogCV9fYXJtX3NtbXVfZnJlZV9iaXRtYXAoc21tdS0+Y29udGV4dF9tYXAsIGNmZy0+Y2JuZHgp OworCisJYXJtX3NtbXVfcnBtX3B1dChzbW11KTsKIH0KIAogc3RhdGljIHN0cnVjdCBpb21tdV9k b21haW4gKmFybV9zbW11X2RvbWFpbl9hbGxvYyh1bnNpZ25lZCB0eXBlKQpAQCAtMTIyOCwxMCAr MTI0OCwxNSBAQCBzdGF0aWMgaW50IGFybV9zbW11X2F0dGFjaF9kZXYoc3RydWN0IGlvbW11X2Rv bWFpbiAqZG9tYWluLCBzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJCXJldHVybiAtRU5PREVWOwogCiAJ c21tdSA9IGZ3c3BlY19zbW11KGZ3c3BlYyk7CisKKwlyZXQgPSBhcm1fc21tdV9ycG1fZ2V0KHNt bXUpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCiAJLyogRW5zdXJlIHRoYXQgdGhl IGRvbWFpbiBpcyBmaW5hbGlzZWQgKi8KIAlyZXQgPSBhcm1fc21tdV9pbml0X2RvbWFpbl9jb250 ZXh0KGRvbWFpbiwgc21tdSk7CiAJaWYgKHJldCA8IDApCi0JCXJldHVybiByZXQ7CisJCWdvdG8g cnBtX3B1dDsKIAogCS8qCiAJICogU2FuaXR5IGNoZWNrIHRoZSBkb21haW4uIFdlIGRvbid0IHN1 cHBvcnQgZG9tYWlucyBhY3Jvc3MKQEAgLTEyNDEsNDkgKzEyNjYsNzQgQEAgc3RhdGljIGludCBh cm1fc21tdV9hdHRhY2hfZGV2KHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgc3RydWN0IGRl dmljZSAqZGV2KQogCQlkZXZfZXJyKGRldiwKIAkJCSJjYW5ub3QgYXR0YWNoIHRvIFNNTVUgJXMg d2hpbHN0IGFscmVhZHkgYXR0YWNoZWQgdG8gZG9tYWluIG9uIFNNTVUgJXNcbiIsCiAJCQlkZXZf bmFtZShzbW11X2RvbWFpbi0+c21tdS0+ZGV2KSwgZGV2X25hbWUoc21tdS0+ZGV2KSk7Ci0JCXJl dHVybiAtRUlOVkFMOworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIHJwbV9wdXQ7CiAJfQogCiAJ LyogTG9va3Mgb2ssIHNvIGFkZCB0aGUgZGV2aWNlIHRvIHRoZSBkb21haW4gKi8KLQlyZXR1cm4g YXJtX3NtbXVfZG9tYWluX2FkZF9tYXN0ZXIoc21tdV9kb21haW4sIGZ3c3BlYyk7CisJcmV0ID0g YXJtX3NtbXVfZG9tYWluX2FkZF9tYXN0ZXIoc21tdV9kb21haW4sIGZ3c3BlYyk7CisKK3JwbV9w dXQ6CisJYXJtX3NtbXVfcnBtX3B1dChzbW11KTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMg aW50IGFybV9zbW11X21hcChzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sIHVuc2lnbmVkIGxv bmcgaW92YSwKIAkJCXBoeXNfYWRkcl90IHBhZGRyLCBzaXplX3Qgc2l6ZSwgaW50IHByb3QpCiB7 CiAJc3RydWN0IGlvX3BndGFibGVfb3BzICpvcHMgPSB0b19zbW11X2RvbWFpbihkb21haW4pLT5w Z3RibF9vcHM7CisJc3RydWN0IGFybV9zbW11X2RldmljZSAqc21tdSA9IHRvX3NtbXVfZG9tYWlu KGRvbWFpbiktPnNtbXU7CisJaW50IHJldDsKIAogCWlmICghb3BzKQogCQlyZXR1cm4gLUVOT0RF VjsKIAotCXJldHVybiBvcHMtPm1hcChvcHMsIGlvdmEsIHBhZGRyLCBzaXplLCBwcm90KTsKKwlh cm1fc21tdV9ycG1fZ2V0KHNtbXUpOworCXJldCA9IG9wcy0+bWFwKG9wcywgaW92YSwgcGFkZHIs IHNpemUsIHByb3QpOworCWFybV9zbW11X3JwbV9wdXQoc21tdSk7CisKKwlyZXR1cm4gcmV0Owog fQogCiBzdGF0aWMgc2l6ZV90IGFybV9zbW11X3VubWFwKHN0cnVjdCBpb21tdV9kb21haW4gKmRv bWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAogCQkJICAgICBzaXplX3Qgc2l6ZSkKIHsKIAlzdHJ1 Y3QgaW9fcGd0YWJsZV9vcHMgKm9wcyA9IHRvX3NtbXVfZG9tYWluKGRvbWFpbiktPnBndGJsX29w czsKKwlzdHJ1Y3QgYXJtX3NtbXVfZGV2aWNlICpzbW11ID0gdG9fc21tdV9kb21haW4oZG9tYWlu KS0+c21tdTsKKwlzaXplX3QgcmV0OwogCiAJaWYgKCFvcHMpCiAJCXJldHVybiAwOwogCi0JcmV0 dXJuIG9wcy0+dW5tYXAob3BzLCBpb3ZhLCBzaXplKTsKKwlhcm1fc21tdV9ycG1fZ2V0KHNtbXUp OworCXJldCA9IG9wcy0+dW5tYXAob3BzLCBpb3ZhLCBzaXplKTsKKwlhcm1fc21tdV9ycG1fcHV0 KHNtbXUpOworCisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIHZvaWQgYXJtX3NtbXVfZmx1c2hf aW90bGJfYWxsKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbikKIHsKIAlzdHJ1Y3QgYXJtX3Nt bXVfZG9tYWluICpzbW11X2RvbWFpbiA9IHRvX3NtbXVfZG9tYWluKGRvbWFpbik7CisJc3RydWN0 IGFybV9zbW11X2RldmljZSAqc21tdSA9IHNtbXVfZG9tYWluLT5zbW11OwogCi0JaWYgKHNtbXVf ZG9tYWluLT50bGJfb3BzKQorCWlmIChzbW11X2RvbWFpbi0+dGxiX29wcykgeworCQlhcm1fc21t dV9ycG1fZ2V0KHNtbXUpOwogCQlzbW11X2RvbWFpbi0+dGxiX29wcy0+dGxiX2ZsdXNoX2FsbChz bW11X2RvbWFpbik7CisJCWFybV9zbW11X3JwbV9wdXQoc21tdSk7CisJfQogfQogCiBzdGF0aWMg dm9pZCBhcm1fc21tdV9pb3RsYl9zeW5jKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbikKIHsK IAlzdHJ1Y3QgYXJtX3NtbXVfZG9tYWluICpzbW11X2RvbWFpbiA9IHRvX3NtbXVfZG9tYWluKGRv bWFpbik7CisJc3RydWN0IGFybV9zbW11X2RldmljZSAqc21tdSA9IHNtbXVfZG9tYWluLT5zbW11 OwogCi0JaWYgKHNtbXVfZG9tYWluLT50bGJfb3BzKQorCWlmIChzbW11X2RvbWFpbi0+dGxiX29w cykgeworCQlhcm1fc21tdV9ycG1fZ2V0KHNtbXUpOwogCQlzbW11X2RvbWFpbi0+dGxiX29wcy0+ dGxiX3N5bmMoc21tdV9kb21haW4pOworCQlhcm1fc21tdV9ycG1fcHV0KHNtbXUpOworCX0KIH0K IAogc3RhdGljIHBoeXNfYWRkcl90IGFybV9zbW11X2lvdmFfdG9fcGh5c19oYXJkKHN0cnVjdCBp b21tdV9kb21haW4gKmRvbWFpbiwKQEAgLTE0MzAsNyArMTQ4MCwxMyBAQCBzdGF0aWMgaW50IGFy bV9zbW11X2FkZF9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2KQogCXdoaWxlIChpLS0pCiAJCWNm Zy0+c21lbmR4W2ldID0gSU5WQUxJRF9TTUVORFg7CiAKKwlyZXQgPSBhcm1fc21tdV9ycG1fZ2V0 KHNtbXUpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dF9jZmdfZnJlZTsKKwogCXJldCA9IGFy bV9zbW11X21hc3Rlcl9hbGxvY19zbWVzKGRldik7CisJYXJtX3NtbXVfcnBtX3B1dChzbW11KTsK KwogCWlmIChyZXQpCiAJCWdvdG8gb3V0X2NmZ19mcmVlOwogCkBAIC0xNDUwLDcgKzE1MDYsNyBA QCBzdGF0aWMgdm9pZCBhcm1fc21tdV9yZW1vdmVfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldikK IAlzdHJ1Y3QgaW9tbXVfZndzcGVjICpmd3NwZWMgPSBkZXYtPmlvbW11X2Z3c3BlYzsKIAlzdHJ1 Y3QgYXJtX3NtbXVfbWFzdGVyX2NmZyAqY2ZnOwogCXN0cnVjdCBhcm1fc21tdV9kZXZpY2UgKnNt bXU7Ci0KKwlpbnQgcmV0OwogCiAJaWYgKCFmd3NwZWMgfHwgZndzcGVjLT5vcHMgIT0gJmFybV9z bW11X29wcykKIAkJcmV0dXJuOwpAQCAtMTQ1OCw4ICsxNTE0LDE1IEBAIHN0YXRpYyB2b2lkIGFy bV9zbW11X3JlbW92ZV9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2KQogCWNmZyAgPSBmd3NwZWMt PmlvbW11X3ByaXY7CiAJc21tdSA9IGNmZy0+c21tdTsKIAorCXJldCA9IGFybV9zbW11X3JwbV9n ZXQoc21tdSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybjsKKwogCWlvbW11X2RldmljZV91bmxp bmsoJnNtbXUtPmlvbW11LCBkZXYpOwogCWFybV9zbW11X21hc3Rlcl9mcmVlX3NtZXMoZndzcGVj KTsKKworCWFybV9zbW11X3JwbV9wdXQoc21tdSk7CisKIAlpb21tdV9ncm91cF9yZW1vdmVfZGV2 aWNlKGRldik7CiAJa2ZyZWUoZndzcGVjLT5pb21tdV9wcml2KTsKIAlpb21tdV9md3NwZWNfZnJl ZShkZXYpOwpAQCAtMjIyNSw2ICsyMjg4LDE3IEBAIHN0YXRpYyBpbnQgYXJtX3NtbXVfZGV2aWNl X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJYXJtX3NtbXVfZGV2aWNlX3Jl c2V0KHNtbXUpOwogCWFybV9zbW11X3Rlc3Rfc21yX21hc2tzKHNtbXUpOwogCisJLyoKKwkgKiBX ZSB3YW50IHRvIGF2b2lkIHRvdWNoaW5nIGRldi0+cG93ZXIubG9jayBpbiBmYXN0cGF0aHMgdW5s ZXNzCisJICogaXQncyByZWFsbHkgZ29pbmcgdG8gZG8gc29tZXRoaW5nIHVzZWZ1bCAtIHBtX3J1 bnRpbWVfZW5hYmxlZCgpCisJICogY2FuIHNlcnZlIGFzIGFuIGlkZWFsIHByb3h5IGZvciB0aGF0 IGRlY2lzaW9uLiBTbywgY29uZGl0aW9uYWxseQorCSAqIGVuYWJsZSBwbV9ydW50aW1lLgorCSAq LworCWlmIChkZXYtPnBtX2RvbWFpbikgeworCQlwbV9ydW50aW1lX3NldF9hY3RpdmUoZGV2KTsK KwkJcG1fcnVudGltZV9lbmFibGUoZGV2KTsKKwl9CisKIAkvKgogCSAqIEZvciBBQ1BJIGFuZCBn ZW5lcmljIERUIGJpbmRpbmdzLCBhbiBTTU1VIHdpbGwgYmUgcHJvYmVkIGJlZm9yZQogCSAqIGFu eSBkZXZpY2Ugd2hpY2ggbWlnaHQgbmVlZCBpdCwgc28gd2Ugd2FudCB0aGUgYnVzIG9wcyBpbiBw bGFjZQpAQCAtMjI2MCwxMCArMjMzNCwxNyBAQCBzdGF0aWMgaW50IGFybV9zbW11X2RldmljZV9y ZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlpZiAoIWJpdG1hcF9lbXB0eShz bW11LT5jb250ZXh0X21hcCwgQVJNX1NNTVVfTUFYX0NCUykpCiAJCWRldl9lcnIoJnBkZXYtPmRl diwgInJlbW92aW5nIGRldmljZSB3aXRoIGFjdGl2ZSBkb21haW5zIVxuIik7CiAKKwlhcm1fc21t dV9ycG1fZ2V0KHNtbXUpOwogCS8qIFR1cm4gdGhlIHRoaW5nIG9mZiAqLwogCXdyaXRlbChzQ1Iw X0NMSUVOVFBELCBBUk1fU01NVV9HUjBfTlMoc21tdSkgKyBBUk1fU01NVV9HUjBfc0NSMCk7CisJ YXJtX3NtbXVfcnBtX3B1dChzbW11KTsKKworCWlmIChwbV9ydW50aW1lX2VuYWJsZWQoc21tdS0+ ZGV2KSkKKwkJcG1fcnVudGltZV9mb3JjZV9zdXNwZW5kKHNtbXUtPmRldik7CisJZWxzZQorCQlj bGtfYnVsa19kaXNhYmxlKHNtbXUtPm51bV9jbGtzLCBzbW11LT5jbGtzKTsKIAotCWNsa19idWxr X2Rpc2FibGVfdW5wcmVwYXJlKHNtbXUtPm51bV9jbGtzLCBzbW11LT5jbGtzKTsKKwljbGtfYnVs a191bnByZXBhcmUoc21tdS0+bnVtX2Nsa3MsIHNtbXUtPmNsa3MpOwogCiAJcmV0dXJuIDA7CiB9 Ci0tIApRVUFMQ09NTSBJTkRJQSwgb24gYmVoYWxmIG9mIFF1YWxjb21tIElubm92YXRpb24gQ2Vu dGVyLCBJbmMuIGlzIGEgbWVtYmVyCm9mIENvZGUgQXVyb3JhIEZvcnVtLCBob3N0ZWQgYnkgVGhl IExpbnV4IEZvdW5kYXRpb24KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCkZyZWVkcmVubyBtYWlsaW5nIGxpc3QKRnJlZWRyZW5vQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Zy ZWVkcmVubwo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: vivek.gautam@codeaurora.org (Vivek Gautam) Date: Tue, 2 Oct 2018 12:42:31 +0530 Subject: [PATCH v17 2/5] iommu/arm-smmu: Invoke pm_runtime during probe, add/remove device In-Reply-To: References: Message-ID: <20181002071231.9787-1-vivek.gautam@codeaurora.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org From: Sricharan R The smmu device probe/remove and add/remove master device callbacks gets called when the smmu is not linked to its master, that is without the context of the master device. So calling runtime apis in those places separately. Global locks are also initialized before enabling runtime pm as the runtime_resume() calls device_reset() which does tlb_sync_global() that ultimately requires locks to be initialized. Signed-off-by: Sricharan R [vivek: Cleanup pm runtime calls] Signed-off-by: Vivek Gautam Reviewed-by: Tomasz Figa Tested-by: Srinivas Kandagatla Reviewed-by: Robin Murphy --- Changes since v16: - Rebased on Will's tree for arm-smmu updates [1]. - Added rpm{get|put} calls to .flush_iotlb_all, and .iotlb_sync callbacks to take care of non-strict tlb flush queue updates. drivers/iommu/arm-smmu.c | 101 ++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 91 insertions(+), 10 deletions(-) diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c index 59d1430a9f2d..bf106688ab7a 100644 --- a/drivers/iommu/arm-smmu.c +++ b/drivers/iommu/arm-smmu.c @@ -269,6 +269,20 @@ static struct arm_smmu_option_prop arm_smmu_options[] = { { 0, NULL}, }; +static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) +{ + if (pm_runtime_enabled(smmu->dev)) + return pm_runtime_get_sync(smmu->dev); + + return 0; +} + +static inline void arm_smmu_rpm_put(struct arm_smmu_device *smmu) +{ + if (pm_runtime_enabled(smmu->dev)) + pm_runtime_put(smmu->dev); +} + static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain *dom) { return container_of(dom, struct arm_smmu_domain, domain); @@ -928,11 +942,15 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); struct arm_smmu_device *smmu = smmu_domain->smmu; struct arm_smmu_cfg *cfg = &smmu_domain->cfg; - int irq; + int ret, irq; if (!smmu || domain->type == IOMMU_DOMAIN_IDENTITY) return; + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + return; + /* * Disable the context bank and free the page tables before freeing * it. @@ -947,6 +965,8 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) free_io_pgtable_ops(smmu_domain->pgtbl_ops); __arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx); + + arm_smmu_rpm_put(smmu); } static struct iommu_domain *arm_smmu_domain_alloc(unsigned type) @@ -1228,10 +1248,15 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) return -ENODEV; smmu = fwspec_smmu(fwspec); + + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + return ret; + /* Ensure that the domain is finalised */ ret = arm_smmu_init_domain_context(domain, smmu); if (ret < 0) - return ret; + goto rpm_put; /* * Sanity check the domain. We don't support domains across @@ -1241,49 +1266,74 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) dev_err(dev, "cannot attach to SMMU %s whilst already attached to domain on SMMU %s\n", dev_name(smmu_domain->smmu->dev), dev_name(smmu->dev)); - return -EINVAL; + ret = -EINVAL; + goto rpm_put; } /* Looks ok, so add the device to the domain */ - return arm_smmu_domain_add_master(smmu_domain, fwspec); + ret = arm_smmu_domain_add_master(smmu_domain, fwspec); + +rpm_put: + arm_smmu_rpm_put(smmu); + return ret; } static int arm_smmu_map(struct iommu_domain *domain, unsigned long iova, phys_addr_t paddr, size_t size, int prot) { struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; + struct arm_smmu_device *smmu = to_smmu_domain(domain)->smmu; + int ret; if (!ops) return -ENODEV; - return ops->map(ops, iova, paddr, size, prot); + arm_smmu_rpm_get(smmu); + ret = ops->map(ops, iova, paddr, size, prot); + arm_smmu_rpm_put(smmu); + + return ret; } static size_t arm_smmu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size) { struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; + struct arm_smmu_device *smmu = to_smmu_domain(domain)->smmu; + size_t ret; if (!ops) return 0; - return ops->unmap(ops, iova, size); + arm_smmu_rpm_get(smmu); + ret = ops->unmap(ops, iova, size); + arm_smmu_rpm_put(smmu); + + return ret; } static void arm_smmu_flush_iotlb_all(struct iommu_domain *domain) { struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); + struct arm_smmu_device *smmu = smmu_domain->smmu; - if (smmu_domain->tlb_ops) + if (smmu_domain->tlb_ops) { + arm_smmu_rpm_get(smmu); smmu_domain->tlb_ops->tlb_flush_all(smmu_domain); + arm_smmu_rpm_put(smmu); + } } static void arm_smmu_iotlb_sync(struct iommu_domain *domain) { struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); + struct arm_smmu_device *smmu = smmu_domain->smmu; - if (smmu_domain->tlb_ops) + if (smmu_domain->tlb_ops) { + arm_smmu_rpm_get(smmu); smmu_domain->tlb_ops->tlb_sync(smmu_domain); + arm_smmu_rpm_put(smmu); + } } static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, @@ -1430,7 +1480,13 @@ static int arm_smmu_add_device(struct device *dev) while (i--) cfg->smendx[i] = INVALID_SMENDX; + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + goto out_cfg_free; + ret = arm_smmu_master_alloc_smes(dev); + arm_smmu_rpm_put(smmu); + if (ret) goto out_cfg_free; @@ -1450,7 +1506,7 @@ static void arm_smmu_remove_device(struct device *dev) struct iommu_fwspec *fwspec = dev->iommu_fwspec; struct arm_smmu_master_cfg *cfg; struct arm_smmu_device *smmu; - + int ret; if (!fwspec || fwspec->ops != &arm_smmu_ops) return; @@ -1458,8 +1514,15 @@ static void arm_smmu_remove_device(struct device *dev) cfg = fwspec->iommu_priv; smmu = cfg->smmu; + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + return; + iommu_device_unlink(&smmu->iommu, dev); arm_smmu_master_free_smes(fwspec); + + arm_smmu_rpm_put(smmu); + iommu_group_remove_device(dev); kfree(fwspec->iommu_priv); iommu_fwspec_free(dev); @@ -2225,6 +2288,17 @@ static int arm_smmu_device_probe(struct platform_device *pdev) arm_smmu_device_reset(smmu); arm_smmu_test_smr_masks(smmu); + /* + * We want to avoid touching dev->power.lock in fastpaths unless + * it's really going to do something useful - pm_runtime_enabled() + * can serve as an ideal proxy for that decision. So, conditionally + * enable pm_runtime. + */ + if (dev->pm_domain) { + pm_runtime_set_active(dev); + pm_runtime_enable(dev); + } + /* * For ACPI and generic DT bindings, an SMMU will be probed before * any device which might need it, so we want the bus ops in place @@ -2260,10 +2334,17 @@ static int arm_smmu_device_remove(struct platform_device *pdev) if (!bitmap_empty(smmu->context_map, ARM_SMMU_MAX_CBS)) dev_err(&pdev->dev, "removing device with active domains!\n"); + arm_smmu_rpm_get(smmu); /* Turn the thing off */ writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); + arm_smmu_rpm_put(smmu); + + if (pm_runtime_enabled(smmu->dev)) + pm_runtime_force_suspend(smmu->dev); + else + clk_bulk_disable(smmu->num_clks, smmu->clks); - clk_bulk_disable_unprepare(smmu->num_clks, smmu->clks); + clk_bulk_unprepare(smmu->num_clks, smmu->clks); return 0; } -- QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation 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=-8.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 11934C43143 for ; Tue, 2 Oct 2018 07:13:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A525A206B2 for ; Tue, 2 Oct 2018 07:13:01 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="TI/EZA3F"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="GctS6vfT" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A525A206B2 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=codeaurora.org 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 S1726861AbeJBNyq (ORCPT ); Tue, 2 Oct 2018 09:54:46 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:56002 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726686AbeJBNyp (ORCPT ); Tue, 2 Oct 2018 09:54:45 -0400 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id 2D2A760C65; Tue, 2 Oct 2018 07:12:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1538464378; bh=ggyTXjo+P0ftCf/XJz+SZ63OlHvrN/TxTPtpdPHPuGs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=TI/EZA3F4+cTnj2d7Vi/j3MiRVBL5dEnE+3XstIaL3cBcfDb9mWsBxzNgomcucHAY NGgz8GxXWe2YpevvMf3m5N+8/IURik/si5nOikhQ+1u4XvX4SlnaCeHBFhnByNSPA6 bpjRoP9koEr6Zm6fYR17o+r/+4ug2wGkrKAIZes8= Received: from blr-ubuntu-41.ap.qualcomm.com (blr-bdr-fw-01_globalnat_allzones-outside.qualcomm.com [103.229.18.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: vivek.gautam@smtp.codeaurora.org) by smtp.codeaurora.org (Postfix) with ESMTPSA id D1D0F60C1D; Tue, 2 Oct 2018 07:12:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1538464376; bh=ggyTXjo+P0ftCf/XJz+SZ63OlHvrN/TxTPtpdPHPuGs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GctS6vfTkl2Afbt+k0gVPsZzT9Yzkh457aNxwCgZtnWICzJ57nsoTRsnt1mv92FgJ pJphEyHwPJvNxEwoslw9HpXWbRu7P2mJca8Rk5xQ7OkXWyfW2Fe+qztXr6Brx+SYEt CkG/JvOe9m1Y2H2N0YlQWh1SF1GzZvBrc//+kv50= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org D1D0F60C1D Authentication-Results: pdx-caf-mail.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: pdx-caf-mail.web.codeaurora.org; spf=none smtp.mailfrom=vivek.gautam@codeaurora.org From: Vivek Gautam To: joro@8bytes.org, robh+dt@kernel.org, rjw@rjwysocki.net, robin.murphy@arm.com, will.deacon@arm.com, iommu@lists.linux-foundation.org, linux-kernel@vger.kernel.org Cc: alex.williamson@redhat.com, mark.rutland@arm.com, robdclark@gmail.com, devicetree@vger.kernel.org, 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, linux-arm-kernel@lists.infradead.org, Vivek Gautam Subject: [PATCH v17 2/5] iommu/arm-smmu: Invoke pm_runtime during probe, add/remove device Date: Tue, 2 Oct 2018 12:42:31 +0530 Message-Id: <20181002071231.9787-1-vivek.gautam@codeaurora.org> X-Mailer: git-send-email 2.16.1.72.g5be1f00a9a70 In-Reply-To: References: Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Sricharan R The smmu device probe/remove and add/remove master device callbacks gets called when the smmu is not linked to its master, that is without the context of the master device. So calling runtime apis in those places separately. Global locks are also initialized before enabling runtime pm as the runtime_resume() calls device_reset() which does tlb_sync_global() that ultimately requires locks to be initialized. Signed-off-by: Sricharan R [vivek: Cleanup pm runtime calls] Signed-off-by: Vivek Gautam Reviewed-by: Tomasz Figa Tested-by: Srinivas Kandagatla Reviewed-by: Robin Murphy --- Changes since v16: - Rebased on Will's tree for arm-smmu updates [1]. - Added rpm{get|put} calls to .flush_iotlb_all, and .iotlb_sync callbacks to take care of non-strict tlb flush queue updates. drivers/iommu/arm-smmu.c | 101 ++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 91 insertions(+), 10 deletions(-) diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c index 59d1430a9f2d..bf106688ab7a 100644 --- a/drivers/iommu/arm-smmu.c +++ b/drivers/iommu/arm-smmu.c @@ -269,6 +269,20 @@ static struct arm_smmu_option_prop arm_smmu_options[] = { { 0, NULL}, }; +static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) +{ + if (pm_runtime_enabled(smmu->dev)) + return pm_runtime_get_sync(smmu->dev); + + return 0; +} + +static inline void arm_smmu_rpm_put(struct arm_smmu_device *smmu) +{ + if (pm_runtime_enabled(smmu->dev)) + pm_runtime_put(smmu->dev); +} + static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain *dom) { return container_of(dom, struct arm_smmu_domain, domain); @@ -928,11 +942,15 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); struct arm_smmu_device *smmu = smmu_domain->smmu; struct arm_smmu_cfg *cfg = &smmu_domain->cfg; - int irq; + int ret, irq; if (!smmu || domain->type == IOMMU_DOMAIN_IDENTITY) return; + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + return; + /* * Disable the context bank and free the page tables before freeing * it. @@ -947,6 +965,8 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) free_io_pgtable_ops(smmu_domain->pgtbl_ops); __arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx); + + arm_smmu_rpm_put(smmu); } static struct iommu_domain *arm_smmu_domain_alloc(unsigned type) @@ -1228,10 +1248,15 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) return -ENODEV; smmu = fwspec_smmu(fwspec); + + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + return ret; + /* Ensure that the domain is finalised */ ret = arm_smmu_init_domain_context(domain, smmu); if (ret < 0) - return ret; + goto rpm_put; /* * Sanity check the domain. We don't support domains across @@ -1241,49 +1266,74 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) dev_err(dev, "cannot attach to SMMU %s whilst already attached to domain on SMMU %s\n", dev_name(smmu_domain->smmu->dev), dev_name(smmu->dev)); - return -EINVAL; + ret = -EINVAL; + goto rpm_put; } /* Looks ok, so add the device to the domain */ - return arm_smmu_domain_add_master(smmu_domain, fwspec); + ret = arm_smmu_domain_add_master(smmu_domain, fwspec); + +rpm_put: + arm_smmu_rpm_put(smmu); + return ret; } static int arm_smmu_map(struct iommu_domain *domain, unsigned long iova, phys_addr_t paddr, size_t size, int prot) { struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; + struct arm_smmu_device *smmu = to_smmu_domain(domain)->smmu; + int ret; if (!ops) return -ENODEV; - return ops->map(ops, iova, paddr, size, prot); + arm_smmu_rpm_get(smmu); + ret = ops->map(ops, iova, paddr, size, prot); + arm_smmu_rpm_put(smmu); + + return ret; } static size_t arm_smmu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size) { struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; + struct arm_smmu_device *smmu = to_smmu_domain(domain)->smmu; + size_t ret; if (!ops) return 0; - return ops->unmap(ops, iova, size); + arm_smmu_rpm_get(smmu); + ret = ops->unmap(ops, iova, size); + arm_smmu_rpm_put(smmu); + + return ret; } static void arm_smmu_flush_iotlb_all(struct iommu_domain *domain) { struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); + struct arm_smmu_device *smmu = smmu_domain->smmu; - if (smmu_domain->tlb_ops) + if (smmu_domain->tlb_ops) { + arm_smmu_rpm_get(smmu); smmu_domain->tlb_ops->tlb_flush_all(smmu_domain); + arm_smmu_rpm_put(smmu); + } } static void arm_smmu_iotlb_sync(struct iommu_domain *domain) { struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); + struct arm_smmu_device *smmu = smmu_domain->smmu; - if (smmu_domain->tlb_ops) + if (smmu_domain->tlb_ops) { + arm_smmu_rpm_get(smmu); smmu_domain->tlb_ops->tlb_sync(smmu_domain); + arm_smmu_rpm_put(smmu); + } } static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, @@ -1430,7 +1480,13 @@ static int arm_smmu_add_device(struct device *dev) while (i--) cfg->smendx[i] = INVALID_SMENDX; + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + goto out_cfg_free; + ret = arm_smmu_master_alloc_smes(dev); + arm_smmu_rpm_put(smmu); + if (ret) goto out_cfg_free; @@ -1450,7 +1506,7 @@ static void arm_smmu_remove_device(struct device *dev) struct iommu_fwspec *fwspec = dev->iommu_fwspec; struct arm_smmu_master_cfg *cfg; struct arm_smmu_device *smmu; - + int ret; if (!fwspec || fwspec->ops != &arm_smmu_ops) return; @@ -1458,8 +1514,15 @@ static void arm_smmu_remove_device(struct device *dev) cfg = fwspec->iommu_priv; smmu = cfg->smmu; + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) + return; + iommu_device_unlink(&smmu->iommu, dev); arm_smmu_master_free_smes(fwspec); + + arm_smmu_rpm_put(smmu); + iommu_group_remove_device(dev); kfree(fwspec->iommu_priv); iommu_fwspec_free(dev); @@ -2225,6 +2288,17 @@ static int arm_smmu_device_probe(struct platform_device *pdev) arm_smmu_device_reset(smmu); arm_smmu_test_smr_masks(smmu); + /* + * We want to avoid touching dev->power.lock in fastpaths unless + * it's really going to do something useful - pm_runtime_enabled() + * can serve as an ideal proxy for that decision. So, conditionally + * enable pm_runtime. + */ + if (dev->pm_domain) { + pm_runtime_set_active(dev); + pm_runtime_enable(dev); + } + /* * For ACPI and generic DT bindings, an SMMU will be probed before * any device which might need it, so we want the bus ops in place @@ -2260,10 +2334,17 @@ static int arm_smmu_device_remove(struct platform_device *pdev) if (!bitmap_empty(smmu->context_map, ARM_SMMU_MAX_CBS)) dev_err(&pdev->dev, "removing device with active domains!\n"); + arm_smmu_rpm_get(smmu); /* Turn the thing off */ writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); + arm_smmu_rpm_put(smmu); + + if (pm_runtime_enabled(smmu->dev)) + pm_runtime_force_suspend(smmu->dev); + else + clk_bulk_disable(smmu->num_clks, smmu->clks); - clk_bulk_disable_unprepare(smmu->num_clks, smmu->clks); + clk_bulk_unprepare(smmu->num_clks, smmu->clks); return 0; } -- QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation