From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jordan Crouse Subject: [PATCH v1 1/4] drm/msm/gpu: Move zap shader loading to adreno Date: Tue, 12 Mar 2019 12:13:39 -0600 Message-ID: <1552414422-9568-2-git-send-email-jcrouse@codeaurora.org> References: <1552414422-9568-1-git-send-email-jcrouse@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1552414422-9568-1-git-send-email-jcrouse-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Cc: Douglas Anderson , Kees Cook , Jonathan Marek , David Airlie , linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Sharat Masetty , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Bjorn Andersson , Rob Clark , Mamta Shukla , Daniel Vetter , Sean Paul List-Id: linux-arm-msm@vger.kernel.org YTV4eCBhbmQgYTZ4eCBib3RoIHNoYXJlIChtb3N0bHkpIHRoZSBzYW1lIGNvZGUgdG8gbG9hZCB0 aGUgemFwIHNoYWRlciBhbmQKYnJpbmcgdGhlIEdQVSBvdXQgb2Ygc2VjdXJlIG1vZGUuIE1vdmUg dGhlIGZvcm1lcmx5IDV4eCBzcGVjaWZpYyBjb2RlIHRvCmFkcmVubyB0byBtYWtlIGl0IGF2YWls YWJsZSBmb3IgYTZ4eCB0b28uCgpTaWduZWQtb2ZmLWJ5OiBKb3JkYW4gQ3JvdXNlIDxqY3JvdXNl QGNvZGVhdXJvcmEub3JnPgotLS0KCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X2dw dS5jICAgfCAxMDkgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9k cm0vbXNtL2FkcmVuby9hZHJlbm9fZ3B1LmMgfCAxMTMgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2FkcmVub19ncHUuaCB8ICAgNiAr KwogMyBmaWxlcyBjaGFuZ2VkLCAxMjAgaW5zZXJ0aW9ucygrKSwgMTA4IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZ3B1LmMgYi9kcml2 ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X2dwdS5jCmluZGV4IGQ1ZjVlNTYuLmU1ZmNlZmEg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZ3B1LmMKKysrIGIv ZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9ncHUuYwpAQCAtMTUsOSArMTUsNiBAQAog I2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8bGludXgvY3B1bWFzay5oPgogI2lu Y2x1ZGUgPGxpbnV4L3Fjb21fc2NtLmg+Ci0jaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4K LSNpbmNsdWRlIDxsaW51eC9vZl9hZGRyZXNzLmg+Ci0jaW5jbHVkZSA8bGludXgvc29jL3Fjb20v bWR0X2xvYWRlci5oPgogI2luY2x1ZGUgPGxpbnV4L3BtX29wcC5oPgogI2luY2x1ZGUgPGxpbnV4 L252bWVtLWNvbnN1bWVyLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgpAQCAtMzAsOTQgKzI3 LDYgQEAgc3RhdGljIHZvaWQgYTV4eF9kdW1wKHN0cnVjdCBtc21fZ3B1ICpncHUpOwogCiAjZGVm aW5lIEdQVV9QQVNfSUQgMTMKIAotc3RhdGljIGludCB6YXBfc2hhZGVyX2xvYWRfbWR0KHN0cnVj dCBtc21fZ3B1ICpncHUsIGNvbnN0IGNoYXIgKmZ3bmFtZSkKLXsKLQlzdHJ1Y3QgZGV2aWNlICpk ZXYgPSAmZ3B1LT5wZGV2LT5kZXY7Ci0JY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdzsKLQlzdHJ1 Y3QgZGV2aWNlX25vZGUgKm5wOwotCXN0cnVjdCByZXNvdXJjZSByOwotCXBoeXNfYWRkcl90IG1l bV9waHlzOwotCXNzaXplX3QgbWVtX3NpemU7Ci0Jdm9pZCAqbWVtX3JlZ2lvbiA9IE5VTEw7Ci0J aW50IHJldDsKLQotCWlmICghSVNfRU5BQkxFRChDT05GSUdfQVJDSF9RQ09NKSkKLQkJcmV0dXJu IC1FSU5WQUw7Ci0KLQlucCA9IG9mX2dldF9jaGlsZF9ieV9uYW1lKGRldi0+b2Zfbm9kZSwgInph cC1zaGFkZXIiKTsKLQlpZiAoIW5wKQotCQlyZXR1cm4gLUVOT0RFVjsKLQotCW5wID0gb2ZfcGFy c2VfcGhhbmRsZShucCwgIm1lbW9yeS1yZWdpb24iLCAwKTsKLQlpZiAoIW5wKQotCQlyZXR1cm4g LUVJTlZBTDsKLQotCXJldCA9IG9mX2FkZHJlc3NfdG9fcmVzb3VyY2UobnAsIDAsICZyKTsKLQlp ZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JbWVtX3BoeXMgPSByLnN0YXJ0OwotCW1lbV9zaXpl ID0gcmVzb3VyY2Vfc2l6ZSgmcik7Ci0KLQkvKiBSZXF1ZXN0IHRoZSBNRFQgZmlsZSBmb3IgdGhl IGZpcm13YXJlICovCi0JZncgPSBhZHJlbm9fcmVxdWVzdF9mdyh0b19hZHJlbm9fZ3B1KGdwdSks IGZ3bmFtZSk7Ci0JaWYgKElTX0VSUihmdykpIHsKLQkJRFJNX0RFVl9FUlJPUihkZXYsICJVbmFi bGUgdG8gbG9hZCAlc1xuIiwgZnduYW1lKTsKLQkJcmV0dXJuIFBUUl9FUlIoZncpOwotCX0KLQot CS8qIEZpZ3VyZSBvdXQgaG93IG11Y2ggbWVtb3J5IHdlIG5lZWQgKi8KLQltZW1fc2l6ZSA9IHFj b21fbWR0X2dldF9zaXplKGZ3KTsKLQlpZiAobWVtX3NpemUgPCAwKSB7Ci0JCXJldCA9IG1lbV9z aXplOwotCQlnb3RvIG91dDsKLQl9Ci0KLQkvKiBBbGxvY2F0ZSBtZW1vcnkgZm9yIHRoZSBmaXJt d2FyZSBpbWFnZSAqLwotCW1lbV9yZWdpb24gPSBtZW1yZW1hcChtZW1fcGh5cywgbWVtX3NpemUs ICBNRU1SRU1BUF9XQyk7Ci0JaWYgKCFtZW1fcmVnaW9uKSB7Ci0JCXJldCA9IC1FTk9NRU07Ci0J CWdvdG8gb3V0OwotCX0KLQotCS8qCi0JICogTG9hZCB0aGUgcmVzdCBvZiB0aGUgTURUCi0JICoK LQkgKiBOb3RlIHRoYXQgd2UgY291bGQgYmUgZGVhbGluZyB3aXRoIHR3byBkaWZmZXJlbnQgcGF0 aHMsIHNpbmNlCi0JICogd2l0aCB1cHN0cmVhbSBsaW51eC1maXJtd2FyZSBpdCB3b3VsZCBiZSBp biBhIHFjb20vIHN1YmRpci4uCi0JICogYWRyZW5vX3JlcXVlc3RfZncoKSBoYW5kbGVzIHRoaXMs IGJ1dCBxY29tX21kdF9sb2FkKCkgZG9lcwotCSAqIG5vdC4gIEJ1dCBzaW5jZSB3ZSd2ZSBhbHJl YWR5IGdvdHRlbiB0aHJ1IGFkcmVub19yZXF1ZXN0X2Z3KCkKLQkgKiB3ZSBrbm93IHdoaWNoIG9m IHRoZSB0d28gY2FzZXMgaXQgaXM6Ci0JICovCi0JaWYgKHRvX2FkcmVub19ncHUoZ3B1KS0+Znds b2MgPT0gRldfTE9DQVRJT05fTEVHQUNZKSB7Ci0JCXJldCA9IHFjb21fbWR0X2xvYWQoZGV2LCBm dywgZnduYW1lLCBHUFVfUEFTX0lELAotCQkJCW1lbV9yZWdpb24sIG1lbV9waHlzLCBtZW1fc2l6 ZSwgTlVMTCk7Ci0JfSBlbHNlIHsKLQkJY2hhciAqbmV3bmFtZTsKLQotCQluZXduYW1lID0ga2Fz cHJpbnRmKEdGUF9LRVJORUwsICJxY29tLyVzIiwgZnduYW1lKTsKLQotCQlyZXQgPSBxY29tX21k dF9sb2FkKGRldiwgZncsIG5ld25hbWUsIEdQVV9QQVNfSUQsCi0JCQkJbWVtX3JlZ2lvbiwgbWVt X3BoeXMsIG1lbV9zaXplLCBOVUxMKTsKLQkJa2ZyZWUobmV3bmFtZSk7Ci0JfQotCWlmIChyZXQp Ci0JCWdvdG8gb3V0OwotCi0JLyogU2VuZCB0aGUgaW1hZ2UgdG8gdGhlIHNlY3VyZSB3b3JsZCAq LwotCXJldCA9IHFjb21fc2NtX3Bhc19hdXRoX2FuZF9yZXNldChHUFVfUEFTX0lEKTsKLQlpZiAo cmV0KQotCQlEUk1fREVWX0VSUk9SKGRldiwgIlVuYWJsZSB0byBhdXRob3JpemUgdGhlIGltYWdl XG4iKTsKLQotb3V0OgotCWlmIChtZW1fcmVnaW9uKQotCQltZW11bm1hcChtZW1fcmVnaW9uKTsK LQotCXJlbGVhc2VfZmlybXdhcmUoZncpOwotCi0JcmV0dXJuIHJldDsKLX0KLQogc3RhdGljIHZv aWQgYTV4eF9mbHVzaChzdHJ1Y3QgbXNtX2dwdSAqZ3B1LCBzdHJ1Y3QgbXNtX3JpbmdidWZmZXIg KnJpbmcpCiB7CiAJc3RydWN0IGFkcmVub19ncHUgKmFkcmVub19ncHUgPSB0b19hZHJlbm9fZ3B1 KGdwdSk7CkBAIC01NjMsOCArNDcyLDYgQEAgc3RhdGljIGludCBhNXh4X3phcF9zaGFkZXJfcmVz dW1lKHN0cnVjdCBtc21fZ3B1ICpncHUpCiBzdGF0aWMgaW50IGE1eHhfemFwX3NoYWRlcl9pbml0 KHN0cnVjdCBtc21fZ3B1ICpncHUpCiB7CiAJc3RhdGljIGJvb2wgbG9hZGVkOwotCXN0cnVjdCBh ZHJlbm9fZ3B1ICphZHJlbm9fZ3B1ID0gdG9fYWRyZW5vX2dwdShncHUpOwotCXN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYgPSBncHUtPnBkZXY7CiAJaW50IHJldDsKIAogCS8qCkBAIC01NzQs MjMgKzQ4MSw5IEBAIHN0YXRpYyBpbnQgYTV4eF96YXBfc2hhZGVyX2luaXQoc3RydWN0IG1zbV9n cHUgKmdwdSkKIAlpZiAobG9hZGVkKQogCQlyZXR1cm4gYTV4eF96YXBfc2hhZGVyX3Jlc3VtZShn cHUpOwogCi0JLyogV2UgbmVlZCBTQ00gdG8gYmUgYWJsZSB0byBsb2FkIHRoZSBmaXJtd2FyZSAq LwotCWlmICghcWNvbV9zY21faXNfYXZhaWxhYmxlKCkpIHsKLQkJRFJNX0RFVl9FUlJPUigmcGRl di0+ZGV2LCAiU0NNIGlzIG5vdCBhdmFpbGFibGVcbiIpOwotCQlyZXR1cm4gLUVQUk9CRV9ERUZF UjsKLQl9Ci0KLQkvKiBFYWNoIEdQVSBoYXMgYSB0YXJnZXQgc3BlY2lmaWMgemFwIHNoYWRlciBm aXJtd2FyZSBuYW1lIHRvIHVzZSAqLwotCWlmICghYWRyZW5vX2dwdS0+aW5mby0+emFwZncpIHsK LQkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LAotCQkJIlphcCBzaGFkZXIgZmlybXdhcmUgZmls ZSBub3Qgc3BlY2lmaWVkIGZvciB0aGlzIHRhcmdldFxuIik7Ci0JCXJldHVybiAtRU5PREVWOwot CX0KLQotCXJldCA9IHphcF9zaGFkZXJfbG9hZF9tZHQoZ3B1LCBhZHJlbm9fZ3B1LT5pbmZvLT56 YXBmdyk7CisJcmV0ID0gYWRyZW5vX3phcF9zaGFkZXJfbG9hZChncHUsIEdQVV9QQVNfSUQpOwog CiAJbG9hZGVkID0gIXJldDsKLQogCXJldHVybiByZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9tc20vYWRyZW5vL2FkcmVub19ncHUuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20v YWRyZW5vL2FkcmVub19ncHUuYwppbmRleCAyNzg5ODQ3Li5hOWViNThjIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hZHJlbm9fZ3B1LmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL21zbS9hZHJlbm8vYWRyZW5vX2dwdS5jCkBAIC0xOSwxMyArMTksMTI2IEBACiAKICNpbmNs dWRlIDxsaW51eC9hc2NpaTg1Lmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJjb25uZWN0Lmg+Cisj aW5jbHVkZSA8bGludXgvcWNvbV9zY20uaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNp bmNsdWRlIDxsaW51eC9vZl9hZGRyZXNzLmg+CiAjaW5jbHVkZSA8bGludXgvcG1fb3BwLmg+CiAj aW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3NvYy9xY29tL21kdF9sb2Fk ZXIuaD4KICNpbmNsdWRlICJhZHJlbm9fZ3B1LmgiCiAjaW5jbHVkZSAibXNtX2dlbS5oIgogI2lu Y2x1ZGUgIm1zbV9tbXUuaCIKIAorc3RhdGljIGludCB6YXBfc2hhZGVyX2xvYWRfbWR0KHN0cnVj dCBtc21fZ3B1ICpncHUsIGNvbnN0IGNoYXIgKmZ3bmFtZSwKKwkJdTMyIHBhc2lkKQoreworCXN0 cnVjdCBkZXZpY2UgKmRldiA9ICZncHUtPnBkZXYtPmRldjsKKwljb25zdCBzdHJ1Y3QgZmlybXdh cmUgKmZ3OworCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7CisJc3RydWN0IHJlc291cmNlIHI7CisJ cGh5c19hZGRyX3QgbWVtX3BoeXM7CisJc3NpemVfdCBtZW1fc2l6ZTsKKwl2b2lkICptZW1fcmVn aW9uID0gTlVMTDsKKwlpbnQgcmV0OworCisJaWYgKCFJU19FTkFCTEVEKENPTkZJR19BUkNIX1FD T00pKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCW5wID0gb2ZfZ2V0X2NoaWxkX2J5X25hbWUoZGV2 LT5vZl9ub2RlLCAiemFwLXNoYWRlciIpOworCWlmICghbnApCisJCXJldHVybiAtRU5PREVWOwor CisJbnAgPSBvZl9wYXJzZV9waGFuZGxlKG5wLCAibWVtb3J5LXJlZ2lvbiIsIDApOworCWlmICgh bnApCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0ID0gb2ZfYWRkcmVzc190b19yZXNvdXJjZShu cCwgMCwgJnIpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwltZW1fcGh5cyA9IHIuc3Rh cnQ7CisJbWVtX3NpemUgPSByZXNvdXJjZV9zaXplKCZyKTsKKworCS8qIFJlcXVlc3QgdGhlIE1E VCBmaWxlIGZvciB0aGUgZmlybXdhcmUgKi8KKwlmdyA9IGFkcmVub19yZXF1ZXN0X2Z3KHRvX2Fk cmVub19ncHUoZ3B1KSwgZnduYW1lKTsKKwlpZiAoSVNfRVJSKGZ3KSkgeworCQlEUk1fREVWX0VS Uk9SKGRldiwgIlVuYWJsZSB0byBsb2FkICVzXG4iLCBmd25hbWUpOworCQlyZXR1cm4gUFRSX0VS Uihmdyk7CisJfQorCisJLyogRmlndXJlIG91dCBob3cgbXVjaCBtZW1vcnkgd2UgbmVlZCAqLwor CW1lbV9zaXplID0gcWNvbV9tZHRfZ2V0X3NpemUoZncpOworCWlmIChtZW1fc2l6ZSA8IDApIHsK KwkJcmV0ID0gbWVtX3NpemU7CisJCWdvdG8gb3V0OworCX0KKworCS8qIEFsbG9jYXRlIG1lbW9y eSBmb3IgdGhlIGZpcm13YXJlIGltYWdlICovCisJbWVtX3JlZ2lvbiA9IG1lbXJlbWFwKG1lbV9w aHlzLCBtZW1fc2l6ZSwgIE1FTVJFTUFQX1dDKTsKKwlpZiAoIW1lbV9yZWdpb24pIHsKKwkJcmV0 ID0gLUVOT01FTTsKKwkJZ290byBvdXQ7CisJfQorCisJLyoKKwkgKiBMb2FkIHRoZSByZXN0IG9m IHRoZSBNRFQKKwkgKgorCSAqIE5vdGUgdGhhdCB3ZSBjb3VsZCBiZSBkZWFsaW5nIHdpdGggdHdv IGRpZmZlcmVudCBwYXRocywgc2luY2UKKwkgKiB3aXRoIHVwc3RyZWFtIGxpbnV4LWZpcm13YXJl IGl0IHdvdWxkIGJlIGluIGEgcWNvbS8gc3ViZGlyLi4KKwkgKiBhZHJlbm9fcmVxdWVzdF9mdygp IGhhbmRsZXMgdGhpcywgYnV0IHFjb21fbWR0X2xvYWQoKSBkb2VzCisJICogbm90LiAgQnV0IHNp bmNlIHdlJ3ZlIGFscmVhZHkgZ290dGVuIHRocm91Z2ggYWRyZW5vX3JlcXVlc3RfZncoKQorCSAq IHdlIGtub3cgd2hpY2ggb2YgdGhlIHR3byBjYXNlcyBpdCBpczoKKwkgKi8KKwlpZiAodG9fYWRy ZW5vX2dwdShncHUpLT5md2xvYyA9PSBGV19MT0NBVElPTl9MRUdBQ1kpIHsKKwkJcmV0ID0gcWNv bV9tZHRfbG9hZChkZXYsIGZ3LCBmd25hbWUsIHBhc2lkLAorCQkJCW1lbV9yZWdpb24sIG1lbV9w aHlzLCBtZW1fc2l6ZSwgTlVMTCk7CisJfSBlbHNlIHsKKwkJY2hhciAqbmV3bmFtZTsKKworCQlu ZXduYW1lID0ga2FzcHJpbnRmKEdGUF9LRVJORUwsICJxY29tLyVzIiwgZnduYW1lKTsKKworCQly ZXQgPSBxY29tX21kdF9sb2FkKGRldiwgZncsIG5ld25hbWUsIHBhc2lkLAorCQkJCW1lbV9yZWdp b24sIG1lbV9waHlzLCBtZW1fc2l6ZSwgTlVMTCk7CisJCWtmcmVlKG5ld25hbWUpOworCX0KKwlp ZiAocmV0KQorCQlnb3RvIG91dDsKKworCS8qIFNlbmQgdGhlIGltYWdlIHRvIHRoZSBzZWN1cmUg d29ybGQgKi8KKwlyZXQgPSBxY29tX3NjbV9wYXNfYXV0aF9hbmRfcmVzZXQocGFzaWQpOworCWlm IChyZXQpCisJCURSTV9ERVZfRVJST1IoZGV2LCAiVW5hYmxlIHRvIGF1dGhvcml6ZSB0aGUgaW1h Z2VcbiIpOworCitvdXQ6CisJaWYgKG1lbV9yZWdpb24pCisJCW1lbXVubWFwKG1lbV9yZWdpb24p OworCisJcmVsZWFzZV9maXJtd2FyZShmdyk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQgYWRy ZW5vX3phcF9zaGFkZXJfbG9hZChzdHJ1Y3QgbXNtX2dwdSAqZ3B1LCB1MzIgcGFzaWQpCit7CisJ c3RydWN0IGFkcmVub19ncHUgKmFkcmVub19ncHUgPSB0b19hZHJlbm9fZ3B1KGdwdSk7CisJc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IGdwdS0+cGRldjsKKworCS8qIFdlIG5lZWQgU0NN IHRvIGJlIGFibGUgdG8gbG9hZCB0aGUgZmlybXdhcmUgKi8KKwlpZiAoIXFjb21fc2NtX2lzX2F2 YWlsYWJsZSgpKSB7CisJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwgIlNDTSBpcyBub3QgYXZh aWxhYmxlXG4iKTsKKwkJcmV0dXJuIC1FUFJPQkVfREVGRVI7CisJfQorCisJLyogRWFjaCBHUFUg aGFzIGEgdGFyZ2V0IHNwZWNpZmljIHphcCBzaGFkZXIgZmlybXdhcmUgbmFtZSB0byB1c2UgKi8K KwlpZiAoIWFkcmVub19ncHUtPmluZm8tPnphcGZ3KSB7CisJCURSTV9ERVZfRVJST1IoJnBkZXYt PmRldiwKKwkJCSJaYXAgc2hhZGVyIGZpcm13YXJlIGZpbGUgbm90IHNwZWNpZmllZCBmb3IgdGhp cyB0YXJnZXRcbiIpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlyZXR1cm4gemFwX3NoYWRl cl9sb2FkX21kdChncHUsIGFkcmVub19ncHUtPmluZm8tPnphcGZ3LCBwYXNpZCk7Cit9CisKIGlu dCBhZHJlbm9fZ2V0X3BhcmFtKHN0cnVjdCBtc21fZ3B1ICpncHUsIHVpbnQzMl90IHBhcmFtLCB1 aW50NjRfdCAqdmFsdWUpCiB7CiAJc3RydWN0IGFkcmVub19ncHUgKmFkcmVub19ncHUgPSB0b19h ZHJlbm9fZ3B1KGdwdSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9h ZHJlbm9fZ3B1LmggYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hZHJlbm9fZ3B1LmgKaW5k ZXggNWRiNDU5Yi4uMDkyNTYwNmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRy ZW5vL2FkcmVub19ncHUuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hZHJlbm9f Z3B1LmgKQEAgLTI1Miw2ICsyNTIsMTIgQEAgdm9pZCBhZHJlbm9fZ3B1X3N0YXRlX2Rlc3Ryb3ko c3RydWN0IG1zbV9ncHVfc3RhdGUgKnN0YXRlKTsKIGludCBhZHJlbm9fZ3B1X3N0YXRlX2dldChz dHJ1Y3QgbXNtX2dwdSAqZ3B1LCBzdHJ1Y3QgbXNtX2dwdV9zdGF0ZSAqc3RhdGUpOwogaW50IGFk cmVub19ncHVfc3RhdGVfcHV0KHN0cnVjdCBtc21fZ3B1X3N0YXRlICpzdGF0ZSk7CiAKKy8qCisg KiBGb3IgYTV4eCBhbmQgYTZ4eCB0YXJnZXRzIGxvYWQgdGhlIHphcCBzaGFkZXIgdGhhdCBpcyB1 c2VkIHRvIHB1bGwgdGhlIEdQVQorICogb3V0IG9mIHNlY3VyZSBtb2RlCisgKi8KK2ludCBhZHJl bm9femFwX3NoYWRlcl9sb2FkKHN0cnVjdCBtc21fZ3B1ICpncHUsIHUzMiBwYXNpZCk7CisKIC8q IHJpbmdidWZmZXIgaGVscGVycyAodGhlIHBhcnRzIHRoYXQgYXJlIGFkcmVubyBzcGVjaWZpYykg Ki8KIAogc3RhdGljIGlubGluZSB2b2lkCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KRnJlZWRyZW5vIG1haWxpbmcgbGlzdApGcmVlZHJl bm9AbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vZnJlZWRyZW5v 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.8 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,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 B466FC43381 for ; Tue, 12 Mar 2019 18:14:23 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 71E862087C for ; Tue, 12 Mar 2019 18:14:23 +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="Blx8KfFo"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="k+KLN5/2" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727633AbfCLSOV (ORCPT ); Tue, 12 Mar 2019 14:14:21 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:58296 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727531AbfCLSOR (ORCPT ); Tue, 12 Mar 2019 14:14:17 -0400 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id BD95F619CF; Tue, 12 Mar 2019 18:14:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1552414455; bh=aNzkhEBdMH/+RdBcUjDsck1i/+rqLAmasAElAo9C2u0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Blx8KfFocf3V/7A5gw807gfysqQHTwtoGbz9dputmh4aN8TWgNT4M4cZ0iBmybH6E iRygIfL7Km4tYZEiBAf1VSxSaW8VTQYDTywITFc6W2E/1xbAj3BvIt5tvxx/dhtaQm dKVKqEVSMW+Pj+yDP/HHLVD2IM74bkJ47Ql9mCn8= Received: from jcrouse1-lnx.qualcomm.com (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: jcrouse@smtp.codeaurora.org) by smtp.codeaurora.org (Postfix) with ESMTPSA id E1446619AE; Tue, 12 Mar 2019 18:14:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1552414449; bh=aNzkhEBdMH/+RdBcUjDsck1i/+rqLAmasAElAo9C2u0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=k+KLN5/2+BUIH2KHS4mIDzgUdvXg0v7ee7k+IYMts+b1lGDKFbohWH6nsCNutdcUP 7h2FQgw191I11skwcjlpskwLdQUrjkTteW19dppOrsQIaY3T4f38j/ilhraBTS4+3j TRokdOoF8arO9ODO7dw1AHLE0gGo3yio+YVZ4tEg= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org E1446619AE 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=jcrouse@codeaurora.org From: Jordan Crouse To: freedreno@lists.freedesktop.org Cc: Bjorn Andersson , Sean Paul , linux-arm-msm@vger.kernel.org, Kees Cook , Sharat Masetty , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Douglas Anderson , Rob Clark , David Airlie , Jonathan Marek , Mamta Shukla , Daniel Vetter Subject: [PATCH v1 1/4] drm/msm/gpu: Move zap shader loading to adreno Date: Tue, 12 Mar 2019 12:13:39 -0600 Message-Id: <1552414422-9568-2-git-send-email-jcrouse@codeaurora.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1552414422-9568-1-git-send-email-jcrouse@codeaurora.org> References: <1552414422-9568-1-git-send-email-jcrouse@codeaurora.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org a5xx and a6xx both share (mostly) the same code to load the zap shader and bring the GPU out of secure mode. Move the formerly 5xx specific code to adreno to make it available for a6xx too. Signed-off-by: Jordan Crouse --- drivers/gpu/drm/msm/adreno/a5xx_gpu.c | 109 +----------------------------- drivers/gpu/drm/msm/adreno/adreno_gpu.c | 113 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/msm/adreno/adreno_gpu.h | 6 ++ 3 files changed, 120 insertions(+), 108 deletions(-) diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c index d5f5e56..e5fcefa 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c @@ -15,9 +15,6 @@ #include #include #include -#include -#include -#include #include #include #include @@ -30,94 +27,6 @@ static void a5xx_dump(struct msm_gpu *gpu); #define GPU_PAS_ID 13 -static int zap_shader_load_mdt(struct msm_gpu *gpu, const char *fwname) -{ - struct device *dev = &gpu->pdev->dev; - const struct firmware *fw; - struct device_node *np; - struct resource r; - phys_addr_t mem_phys; - ssize_t mem_size; - void *mem_region = NULL; - int ret; - - if (!IS_ENABLED(CONFIG_ARCH_QCOM)) - return -EINVAL; - - np = of_get_child_by_name(dev->of_node, "zap-shader"); - if (!np) - return -ENODEV; - - np = of_parse_phandle(np, "memory-region", 0); - if (!np) - return -EINVAL; - - ret = of_address_to_resource(np, 0, &r); - if (ret) - return ret; - - mem_phys = r.start; - mem_size = resource_size(&r); - - /* Request the MDT file for the firmware */ - fw = adreno_request_fw(to_adreno_gpu(gpu), fwname); - if (IS_ERR(fw)) { - DRM_DEV_ERROR(dev, "Unable to load %s\n", fwname); - return PTR_ERR(fw); - } - - /* Figure out how much memory we need */ - mem_size = qcom_mdt_get_size(fw); - if (mem_size < 0) { - ret = mem_size; - goto out; - } - - /* Allocate memory for the firmware image */ - mem_region = memremap(mem_phys, mem_size, MEMREMAP_WC); - if (!mem_region) { - ret = -ENOMEM; - goto out; - } - - /* - * Load the rest of the MDT - * - * Note that we could be dealing with two different paths, since - * with upstream linux-firmware it would be in a qcom/ subdir.. - * adreno_request_fw() handles this, but qcom_mdt_load() does - * not. But since we've already gotten thru adreno_request_fw() - * we know which of the two cases it is: - */ - if (to_adreno_gpu(gpu)->fwloc == FW_LOCATION_LEGACY) { - ret = qcom_mdt_load(dev, fw, fwname, GPU_PAS_ID, - mem_region, mem_phys, mem_size, NULL); - } else { - char *newname; - - newname = kasprintf(GFP_KERNEL, "qcom/%s", fwname); - - ret = qcom_mdt_load(dev, fw, newname, GPU_PAS_ID, - mem_region, mem_phys, mem_size, NULL); - kfree(newname); - } - if (ret) - goto out; - - /* Send the image to the secure world */ - ret = qcom_scm_pas_auth_and_reset(GPU_PAS_ID); - if (ret) - DRM_DEV_ERROR(dev, "Unable to authorize the image\n"); - -out: - if (mem_region) - memunmap(mem_region); - - release_firmware(fw); - - return ret; -} - static void a5xx_flush(struct msm_gpu *gpu, struct msm_ringbuffer *ring) { struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); @@ -563,8 +472,6 @@ static int a5xx_zap_shader_resume(struct msm_gpu *gpu) static int a5xx_zap_shader_init(struct msm_gpu *gpu) { static bool loaded; - struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); - struct platform_device *pdev = gpu->pdev; int ret; /* @@ -574,23 +481,9 @@ static int a5xx_zap_shader_init(struct msm_gpu *gpu) if (loaded) return a5xx_zap_shader_resume(gpu); - /* We need SCM to be able to load the firmware */ - if (!qcom_scm_is_available()) { - DRM_DEV_ERROR(&pdev->dev, "SCM is not available\n"); - return -EPROBE_DEFER; - } - - /* Each GPU has a target specific zap shader firmware name to use */ - if (!adreno_gpu->info->zapfw) { - DRM_DEV_ERROR(&pdev->dev, - "Zap shader firmware file not specified for this target\n"); - return -ENODEV; - } - - ret = zap_shader_load_mdt(gpu, adreno_gpu->info->zapfw); + ret = adreno_zap_shader_load(gpu, GPU_PAS_ID); loaded = !ret; - return ret; } diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.c b/drivers/gpu/drm/msm/adreno/adreno_gpu.c index 2789847..a9eb58c 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.c +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.c @@ -19,13 +19,126 @@ #include #include +#include #include +#include #include #include +#include #include "adreno_gpu.h" #include "msm_gem.h" #include "msm_mmu.h" +static int zap_shader_load_mdt(struct msm_gpu *gpu, const char *fwname, + u32 pasid) +{ + struct device *dev = &gpu->pdev->dev; + const struct firmware *fw; + struct device_node *np; + struct resource r; + phys_addr_t mem_phys; + ssize_t mem_size; + void *mem_region = NULL; + int ret; + + if (!IS_ENABLED(CONFIG_ARCH_QCOM)) + return -EINVAL; + + np = of_get_child_by_name(dev->of_node, "zap-shader"); + if (!np) + return -ENODEV; + + np = of_parse_phandle(np, "memory-region", 0); + if (!np) + return -EINVAL; + + ret = of_address_to_resource(np, 0, &r); + if (ret) + return ret; + + mem_phys = r.start; + mem_size = resource_size(&r); + + /* Request the MDT file for the firmware */ + fw = adreno_request_fw(to_adreno_gpu(gpu), fwname); + if (IS_ERR(fw)) { + DRM_DEV_ERROR(dev, "Unable to load %s\n", fwname); + return PTR_ERR(fw); + } + + /* Figure out how much memory we need */ + mem_size = qcom_mdt_get_size(fw); + if (mem_size < 0) { + ret = mem_size; + goto out; + } + + /* Allocate memory for the firmware image */ + mem_region = memremap(mem_phys, mem_size, MEMREMAP_WC); + if (!mem_region) { + ret = -ENOMEM; + goto out; + } + + /* + * Load the rest of the MDT + * + * Note that we could be dealing with two different paths, since + * with upstream linux-firmware it would be in a qcom/ subdir.. + * adreno_request_fw() handles this, but qcom_mdt_load() does + * not. But since we've already gotten through adreno_request_fw() + * we know which of the two cases it is: + */ + if (to_adreno_gpu(gpu)->fwloc == FW_LOCATION_LEGACY) { + ret = qcom_mdt_load(dev, fw, fwname, pasid, + mem_region, mem_phys, mem_size, NULL); + } else { + char *newname; + + newname = kasprintf(GFP_KERNEL, "qcom/%s", fwname); + + ret = qcom_mdt_load(dev, fw, newname, pasid, + mem_region, mem_phys, mem_size, NULL); + kfree(newname); + } + if (ret) + goto out; + + /* Send the image to the secure world */ + ret = qcom_scm_pas_auth_and_reset(pasid); + if (ret) + DRM_DEV_ERROR(dev, "Unable to authorize the image\n"); + +out: + if (mem_region) + memunmap(mem_region); + + release_firmware(fw); + + return ret; +} + +int adreno_zap_shader_load(struct msm_gpu *gpu, u32 pasid) +{ + struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); + struct platform_device *pdev = gpu->pdev; + + /* We need SCM to be able to load the firmware */ + if (!qcom_scm_is_available()) { + DRM_DEV_ERROR(&pdev->dev, "SCM is not available\n"); + return -EPROBE_DEFER; + } + + /* Each GPU has a target specific zap shader firmware name to use */ + if (!adreno_gpu->info->zapfw) { + DRM_DEV_ERROR(&pdev->dev, + "Zap shader firmware file not specified for this target\n"); + return -ENODEV; + } + + return zap_shader_load_mdt(gpu, adreno_gpu->info->zapfw, pasid); +} + int adreno_get_param(struct msm_gpu *gpu, uint32_t param, uint64_t *value) { struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu); diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.h b/drivers/gpu/drm/msm/adreno/adreno_gpu.h index 5db459b..0925606e 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.h +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.h @@ -252,6 +252,12 @@ void adreno_gpu_state_destroy(struct msm_gpu_state *state); int adreno_gpu_state_get(struct msm_gpu *gpu, struct msm_gpu_state *state); int adreno_gpu_state_put(struct msm_gpu_state *state); +/* + * For a5xx and a6xx targets load the zap shader that is used to pull the GPU + * out of secure mode + */ +int adreno_zap_shader_load(struct msm_gpu *gpu, u32 pasid); + /* ringbuffer helpers (the parts that are adreno specific) */ static inline void -- 2.7.4