From mboxrd@z Thu Jan 1 00:00:00 1970 From: David Lechner Subject: [PATCH] drm/tinydrm: Allocate dummy SPI RX buffer if needed Date: Mon, 19 Feb 2018 17:21:01 -0600 Message-ID: <1519082461-32405-1-git-send-email-david@lechnology.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from vern.gendns.com (vern.gendns.com [206.190.152.46]) by gabe.freedesktop.org (Postfix) with ESMTPS id BE1EE6E08D for ; Mon, 19 Feb 2018 23:21:06 +0000 (UTC) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org, David Lechner List-Id: dri-devel@lists.freedesktop.org VGhpcyBhZGRzIGEgbmV3IGZlYXR1cmUgdG8gYWxsb2NhdGUgYSBkdW1teSBSWCBidWZmZXIgZm9y IFNQSSBjb250cm9sbGVycwp0aGF0IHJlcXVpcmUgYW4gUlggYnVmZmVyIGV2ZW4gd2hlbiBub3Qg cmVjZWl2aW5nLiBJZiBhbiBSWCBidWZmZXIgaXMgbm90CnN1cHBsaWVkLCB0aGUgU1BJIGNvbnRy b2xsZXIgd2lsbCByZWFsbG9jYXRlIGEgbmV3IGJ1ZmZlciBvbiBlYWNoCnRyYW5zZmVyLgoKT24g c3lzdGVtcyB3aXRoIGxpbWl0ZWQgbWVtb3J5IChlLmcuIDY0TUIgYW5kIENPTkZJR19TV0FQPW4p LCB0aGlzCnJlYWxsb2NhdGlvbiB3aWxsIG9jY2FzaW9uYWxseSBmYWlsLCB3aGljaCBjYXVzZXMg dGhlIGRpc3BsYXkgdG8gc3RvcAp3b3JraW5nLiBCeSBhbGxvY2F0aW5nIHRoaXMgYnVmZmVyIG9u Y2UgYW5kIHJldXNpbmcgaXQsIHdlIGNhbiBwcmV2ZW50CnRoaXMgcHJvYmxlbS4KClRoaXMgcGF0 Y2ggYWxzbyBpbnRyb2R1Y2VzIHNvbWUgaGVscGVyIGZ1bmN0aW9ucyBmb3IgY2FsY3VsYXRpbmcg dGhlCnNpemUgb2YgdGhpcyBidWZmZXIsIHNvIHRoZXNlIGZ1bmN0aW9ucyBhcmUgcmUtdXNlZCB3 aGVyZSBwb3NzaWJsZQooZS5nLiBpbiBtaXBpX2RiaV9pbml0KCkpLgoKQ2M6IE5vcmFsZiBUcsO4 bm5lcyA8bm9yYWxmQHRyb25uZXMub3JnPgpTdWdnZXN0ZWQtYnk6IE5vcmFsZiBUcsO4bm5lcyA8 bm9yYWxmQHRyb25uZXMub3JnPgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBMZWNobmVyIDxkYXZpZEBs ZWNobm9sb2d5LmNvbT4KLS0tCgpUaGlzIGlzIGEgZm9sbG93IHVwIGZyb20gdGhlIG1haWwgdGhy ZWFkICJ0aW55ZHJtOiBwYWdlIGFsbG9jYXRpb24gZmFpbHVyZSIgWzFdLgpJIGFjdHVhbGx5IGdv dCBhbiBhbGxvY2F0aW9uIGZhaWx1cmUgYSBmZXcgdGltZXMgZXZlbiB3aGVuIEkgaGFkIHN3YXAg ZW5hYmxlZCwKc28gSSB0aGluayB0aGlzIGNoYW5nZSBpcyBuZWVkZWQuCgpbMV06IGh0dHBzOi8v d3d3Lm1haWwtYXJjaGl2ZS5jb20vZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZy9tc2cy MDM2NTcuaHRtbAoKIGRyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2NvcmUvdGlueWRybS1oZWxwZXJz LmMgfCAgOSArKysrKysrKy0KIGRyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2lsaTkyMjUuYyAgICAg ICAgICAgICAgfCAgOCArKysrKy0tLQogZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vbWkwMjgzcXQu YyAgICAgICAgICAgICB8ICAzICsrLQogZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vbWlwaS1kYmku YyAgICAgICAgICAgICB8IDIwICsrKysrKysrKysrKysrKystLS0tCiBkcml2ZXJzL2dwdS9kcm0v dGlueWRybS9zdDc1ODYuYyAgICAgICAgICAgICAgIHwgMTMgKysrKysrKysrKystLQogZHJpdmVy cy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NzM1ci5jICAgICAgICAgICAgICB8ICAzICsrLQogaW5jbHVk ZS9kcm0vdGlueWRybS9taXBpLWRiaS5oICAgICAgICAgICAgICAgICB8IDE2ICsrKysrKysrKysr KysrKy0KIGluY2x1ZGUvZHJtL3Rpbnlkcm0vdGlueWRybS1oZWxwZXJzLmggICAgICAgICAgfCAg MiArLQogOCBmaWxlcyBjaGFuZ2VkLCA2MCBpbnNlcnRpb25zKCspLCAxNCBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9jb3JlL3Rpbnlkcm0taGVscGVy cy5jIGIvZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vY29yZS90aW55ZHJtLWhlbHBlcnMuYwppbmRl eCBiZjk2MDcyLi5mNWMxNzVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9j b3JlL3Rpbnlkcm0taGVscGVycy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2NvcmUv dGlueWRybS1oZWxwZXJzLmMKQEAgLTQzNCw2ICs0MzQsNyBAQCBFWFBPUlRfU1lNQk9MKF90aW55 ZHJtX2RiZ19zcGlfbWVzc2FnZSk7CiAgKiBAaGVhZGVyOiBPcHRpb25hbCBoZWFkZXIgdHJhbnNm ZXIKICAqIEBicHc6IEJpdHMgcGVyIHdvcmQKICAqIEBidWY6IEJ1ZmZlciB0byB0cmFuc2Zlcgor ICogQHJ4X2J1ZjogT3B0aW9uYWwgZHVtbXkgYnVmZmVyCiAgKiBAbGVuOiBCdWZmZXIgbGVuZ3Ro CiAgKgogICogVGhpcyBTUEkgdHJhbnNmZXIgaGVscGVyIGJyZWFrcyB1cCB0aGUgdHJhbnNmZXIg b2YgQGJ1ZiBpbnRvIGNodW5rcyB3aGljaApAQCAtNDQyLDE2ICs0NDMsMjIgQEAgRVhQT1JUX1NZ TUJPTChfdGlueWRybV9kYmdfc3BpX21lc3NhZ2UpOwogICogZG9lcyBhIDgtYml0IHRyYW5zZmVy LgogICogSWYgQGhlYWRlciBpcyBzZXQsIGl0IGlzIHByZXBlbmRlZCB0byBlYWNoIFNQSSBtZXNz YWdlLgogICoKKyAqIFNvbWUgU1BJIGNvbnRyb2xsZXJzIG5lZWQgYW4gUlggYnVmZmVyIGV2ZW4g dGhvdWdoIHdlIGFyZSBub3QgcmVjZWl2aW5nCisgKiBhbnl0aGluZyB1c2VmdWwuIEByeF9idWYg Y2FuIGJlIHByb3ZpZGVkIHNvIHRoYXQgdGhlIFNQSSBjb250cm9sbGVyIGRvZXMgbm90CisgKiBo YXZlIHRvIHJlYWxsb2NhdGUgdGhpcyBidWZmZXIgb24gZWFjaCB0cmFuc2Zlci4gVGhpcyBpcyB1 c2VmdWwgZm9yIGxhcmdlCisgKiB0cmFuc2ZlcnMsIGUuZy4gd2hlbiB1cGRhdGluZyB0aGUgR1JB TS4KKyAqCiAgKiBSZXR1cm5zOgogICogWmVybyBvbiBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJvciBj b2RlIG9uIGZhaWx1cmUuCiAgKi8KIGludCB0aW55ZHJtX3NwaV90cmFuc2ZlcihzdHJ1Y3Qgc3Bp X2RldmljZSAqc3BpLCB1MzIgc3BlZWRfaHosCiAJCQkgc3RydWN0IHNwaV90cmFuc2ZlciAqaGVh ZGVyLCB1OCBicHcsIGNvbnN0IHZvaWQgKmJ1ZiwKLQkJCSBzaXplX3QgbGVuKQorCQkJIHZvaWQg KnJ4X2J1Ziwgc2l6ZV90IGxlbikKIHsKIAlzdHJ1Y3Qgc3BpX3RyYW5zZmVyIHRyID0gewogCQku Yml0c19wZXJfd29yZCA9IGJwdywKIAkJLnNwZWVkX2h6ID0gc3BlZWRfaHosCisJCS5yeF9idWYg PSByeF9idWYsCiAJfTsKIAlzdHJ1Y3Qgc3BpX21lc3NhZ2UgbTsKIAl1MTYgKnN3YXBfYnVmID0g TlVMTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL2lsaTkyMjUuYyBiL2Ry aXZlcnMvZ3B1L2RybS90aW55ZHJtL2lsaTkyMjUuYwppbmRleCBhMDc1OTUwLi5jMTVmNDlhIDEw MDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9pbGk5MjI1LmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL3Rpbnlkcm0vaWxpOTIyNS5jCkBAIC0zMDAsNyArMzAwLDcgQEAgc3RhdGljIGlu dCBpbGk5MjI1X2RiaV9jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21kLCB1OCAq cGFyLAogCiAJZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKG1pcGktPmRjLCAwKTsKIAlzcGVlZF9o eiA9IG1pcGlfZGJpX3NwaV9jbWRfbWF4X3NwZWVkKHNwaSwgMSk7Ci0JcmV0ID0gdGlueWRybV9z cGlfdHJhbnNmZXIoc3BpLCBzcGVlZF9oeiwgTlVMTCwgOCwgJmNtZCwgMSk7CisJcmV0ID0gdGlu eWRybV9zcGlfdHJhbnNmZXIoc3BpLCBzcGVlZF9oeiwgTlVMTCwgOCwgJmNtZCwgTlVMTCwgMSk7 CiAJaWYgKHJldCB8fCAhbnVtKQogCQlyZXR1cm4gcmV0OwogCkBAIC0zMTAsNyArMzEwLDggQEAg c3RhdGljIGludCBpbGk5MjI1X2RiaV9jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTgg Y21kLCB1OCAqcGFyLAogCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChtaXBpLT5kYywgMSk7CiAJ c3BlZWRfaHogPSBtaXBpX2RiaV9zcGlfY21kX21heF9zcGVlZChzcGksIG51bSk7CiAKLQlyZXR1 cm4gdGlueWRybV9zcGlfdHJhbnNmZXIoc3BpLCBzcGVlZF9oeiwgTlVMTCwgYnB3LCBwYXIsIG51 bSk7CisJcmV0dXJuIHRpbnlkcm1fc3BpX3RyYW5zZmVyKHNwaSwgc3BlZWRfaHosIE5VTEwsIGJw dywgcGFyLCBtaXBpLT5yeF9idWYsCisJCQkJICAgIG51bSk7CiB9CiAKIHN0YXRpYyBjb25zdCB1 MzIgaWxpOTIyNV9mb3JtYXRzW10gPSB7CkBAIC00MDAsNiArNDAxLDcgQEAgTU9EVUxFX0RFVklD RV9UQUJMRShzcGksIGlsaTkyMjVfaWQpOwogCiBzdGF0aWMgaW50IGlsaTkyMjVfcHJvYmUoc3Ry dWN0IHNwaV9kZXZpY2UgKnNwaSkKIHsKKwlzaXplX3QgYnVmc2l6ZSA9IG1pcGlfZGJpX21heF9i dWZfc2l6ZSgmaWxpOTIyNV9tb2RlKTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmc3BpLT5kZXY7 CiAJc3RydWN0IG1pcGlfZGJpICptaXBpOwogCXN0cnVjdCBncGlvX2Rlc2MgKnJzOwpAQCAtNDI0 LDcgKzQyNiw3IEBAIHN0YXRpYyBpbnQgaWxpOTIyNV9wcm9iZShzdHJ1Y3Qgc3BpX2RldmljZSAq c3BpKQogCiAJZGV2aWNlX3Byb3BlcnR5X3JlYWRfdTMyKGRldiwgInJvdGF0aW9uIiwgJnJvdGF0 aW9uKTsKIAotCXJldCA9IG1pcGlfZGJpX3NwaV9pbml0KHNwaSwgbWlwaSwgcnMpOworCXJldCA9 IG1pcGlfZGJpX3NwaV9pbml0KHNwaSwgbWlwaSwgcnMsIGJ1ZnNpemUpOwogCWlmIChyZXQpCiAJ CXJldHVybiByZXQ7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL21pMDI4 M3F0LmMgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9taTAyODNxdC5jCmluZGV4IDc5Y2I1YWYu LmMzZmE2ODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL21pMDI4M3F0LmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vbWkwMjgzcXQuYwpAQCAtMTY5LDYgKzE2OSw3 IEBAIE1PRFVMRV9ERVZJQ0VfVEFCTEUoc3BpLCBtaTAyODNxdF9pZCk7CiAKIHN0YXRpYyBpbnQg bWkwMjgzcXRfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKIHsKKwlzaXplX3QgYnVmc2l6 ZSA9IG1pcGlfZGJpX21heF9idWZfc2l6ZSgmbWkwMjgzcXRfbW9kZSk7CiAJc3RydWN0IGRldmlj ZSAqZGV2ID0gJnNwaS0+ZGV2OwogCXN0cnVjdCBtaXBpX2RiaSAqbWlwaTsKIAlzdHJ1Y3QgZ3Bp b19kZXNjICpkYzsKQEAgLTIwMSw3ICsyMDIsNyBAQCBzdGF0aWMgaW50IG1pMDI4M3F0X3Byb2Jl KHN0cnVjdCBzcGlfZGV2aWNlICpzcGkpCiAKIAlkZXZpY2VfcHJvcGVydHlfcmVhZF91MzIoZGV2 LCAicm90YXRpb24iLCAmcm90YXRpb24pOwogCi0JcmV0ID0gbWlwaV9kYmlfc3BpX2luaXQoc3Bp LCBtaXBpLCBkYyk7CisJcmV0ID0gbWlwaV9kYmlfc3BpX2luaXQoc3BpLCBtaXBpLCBkYywgYnVm c2l6ZSk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3Rpbnlkcm0vbWlwaS1kYmkuYyBiL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL21pcGkt ZGJpLmMKaW5kZXggNzVkZDY1Yy4uMTZiZWUwNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L3Rpbnlkcm0vbWlwaS1kYmkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9taXBpLWRi aS5jCkBAIC0zNjQsNyArMzY0LDcgQEAgaW50IG1pcGlfZGJpX2luaXQoc3RydWN0IGRldmljZSAq ZGV2LCBzdHJ1Y3QgbWlwaV9kYmkgKm1pcGksCiAJCSAgc3RydWN0IGRybV9kcml2ZXIgKmRyaXZl ciwKIAkJICBjb25zdCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSwgdW5zaWduZWQgaW50 IHJvdGF0aW9uKQogewotCXNpemVfdCBidWZzaXplID0gbW9kZS0+dmRpc3BsYXkgKiBtb2RlLT5o ZGlzcGxheSAqIHNpemVvZih1MTYpOworCXNpemVfdCBidWZzaXplID0gbWlwaV9kYmlfbWF4X2J1 Zl9zaXplKG1vZGUpOwogCXN0cnVjdCB0aW55ZHJtX2RldmljZSAqdGRldiA9ICZtaXBpLT50aW55 ZHJtOwogCWludCByZXQ7CiAKQEAgLTg0OCw3ICs4NDgsNyBAQCBzdGF0aWMgaW50IG1pcGlfZGJp X3R5cGVjM19jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21kLAogCiAJZ3Bpb2Rf c2V0X3ZhbHVlX2NhbnNsZWVwKG1pcGktPmRjLCAwKTsKIAlzcGVlZF9oeiA9IG1pcGlfZGJpX3Nw aV9jbWRfbWF4X3NwZWVkKHNwaSwgMSk7Ci0JcmV0ID0gdGlueWRybV9zcGlfdHJhbnNmZXIoc3Bp LCBzcGVlZF9oeiwgTlVMTCwgOCwgJmNtZCwgMSk7CisJcmV0ID0gdGlueWRybV9zcGlfdHJhbnNm ZXIoc3BpLCBzcGVlZF9oeiwgTlVMTCwgOCwgJmNtZCwgTlVMTCwgMSk7CiAJaWYgKHJldCB8fCAh bnVtKQogCQlyZXR1cm4gcmV0OwogCkBAIC04NTgsNyArODU4LDggQEAgc3RhdGljIGludCBtaXBp X2RiaV90eXBlYzNfY29tbWFuZChzdHJ1Y3QgbWlwaV9kYmkgKm1pcGksIHU4IGNtZCwKIAlncGlv ZF9zZXRfdmFsdWVfY2Fuc2xlZXAobWlwaS0+ZGMsIDEpOwogCXNwZWVkX2h6ID0gbWlwaV9kYmlf c3BpX2NtZF9tYXhfc3BlZWQoc3BpLCBudW0pOwogCi0JcmV0dXJuIHRpbnlkcm1fc3BpX3RyYW5z ZmVyKHNwaSwgc3BlZWRfaHosIE5VTEwsIGJwdywgcGFyLCBudW0pOworCXJldHVybiB0aW55ZHJt X3NwaV90cmFuc2ZlcihzcGksIHNwZWVkX2h6LCBOVUxMLCBicHcsIHBhciwgbWlwaS0+cnhfYnVm LAorCQkJCSAgICBudW0pOwogfQogCiAvKioKQEAgLTg2Niw2ICs4NjcsNyBAQCBzdGF0aWMgaW50 IG1pcGlfZGJpX3R5cGVjM19jb21tYW5kKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21kLAog ICogQHNwaTogU1BJIGRldmljZQogICogQG1pcGk6ICZtaXBpX2RiaSBzdHJ1Y3R1cmUgdG8gaW5p dGlhbGl6ZQogICogQGRjOiBEL0MgZ3BpbyAob3B0aW9uYWwpCisgKiBAbWF4X3NpemU6IE1heGlt dW0gVFggYnVmZmVyIHNpemUgbmVlZGVkIGJ5IHRoZSBjYWxsZXIKICAqCiAgKiBUaGlzIGZ1bmN0 aW9uIHNldHMgJm1pcGlfZGJpLT5jb21tYW5kLCBlbmFibGVzICZtaXBpLT5yZWFkX2NvbW1hbmRz IGZvciB0aGUKICAqIHVzdWFsIHJlYWQgY29tbWFuZHMuIEl0IHNob3VsZCBiZSBmb2xsb3dlZCBi eSBhIGNhbGwgdG8gbWlwaV9kYmlfaW5pdCgpIG9yCkBAIC04ODQsNyArODg2LDcgQEAgc3RhdGlj IGludCBtaXBpX2RiaV90eXBlYzNfY29tbWFuZChzdHJ1Y3QgbWlwaV9kYmkgKm1pcGksIHU4IGNt ZCwKICAqIFplcm8gb24gc3VjY2VzcywgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgog ICovCiBpbnQgbWlwaV9kYmlfc3BpX2luaXQoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgc3RydWN0 IG1pcGlfZGJpICptaXBpLAotCQkgICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICpkYykKKwkJICAgICAg c3RydWN0IGdwaW9fZGVzYyAqZGMsIHNpemVfdCBtYXhfc2l6ZSkKIHsKIAlzaXplX3QgdHhfc2l6 ZSA9IHRpbnlkcm1fc3BpX21heF90cmFuc2Zlcl9zaXplKHNwaSwgMCk7CiAJc3RydWN0IGRldmlj ZSAqZGV2ID0gJnNwaS0+ZGV2OwpAQCAtOTMwLDYgKzkzMiwxNiBAQCBpbnQgbWlwaV9kYmlfc3Bp X2luaXQoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgc3RydWN0IG1pcGlfZGJpICptaXBpLAogCQkJ cmV0dXJuIC1FTk9NRU07CiAJfQogCisJLyoKKwkgKiBBbGxvY2F0ZSBhIGR1bW15IFJYIGJ1ZmZl ciBpZiBuZWVkZWQsIG90aGVyd2lzZSB0aGUgU1BJIGNvbnRyb2xsZXIKKwkgKiB3aWxsIGhhdmUg dG8gcmVhbGxvY2F0ZSBhIG5ldyBidWZmZXIgb24gZWFjaCB0cmFuc2Zlci4KKwkgKi8KKwlpZiAo c3BpLT5jb250cm9sbGVyLT5mbGFncyAmIFNQSV9DT05UUk9MTEVSX01VU1RfUlgpIHsKKwkJbWlw aS0+cnhfYnVmID0gZGV2bV9rbWFsbG9jKGRldiwgbWF4X3NpemUsIEdGUF9LRVJORUwpOworCQlp ZiAoIW1pcGktPnJ4X2J1ZikKKwkJCXJldHVybiAtRU5PTUVNOworCX0KKwogCURSTV9ERUJVR19E UklWRVIoIlNQSSBzcGVlZDogJXVNSHpcbiIsIHNwaS0+bWF4X3NwZWVkX2h6IC8gMTAwMDAwMCk7 CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL3N0NzU4 Ni5jIGIvZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NTg2LmMKaW5kZXggYTYzOTZlZi4uYmIw ZDU1ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NTg2LmMKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3Rpbnlkcm0vc3Q3NTg2LmMKQEAgLTQyLDYgKzQyLDE0IEBACiAjZGVm aW5lIFNUNzU4Nl9ESVNQX0NUUkxfTVgJQklUKDYpCiAjZGVmaW5lIFNUNzU4Nl9ESVNQX0NUUkxf TVkJQklUKDcpCiAKK3N0YXRpYyBpbmxpbmUgc2l6ZV90IHN0NzU4Nl9idWZfbWF4X3NpemUoY29u c3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpCit7CisJc2l6ZV90IHdpZHRoID0gKG1v ZGUtPmhkaXNwbGF5ICsgMikgLyAzOyAvKiAzIHBpeGVscyBwZXIgYnl0ZSAqLworCXNpemVfdCBo ZWlnaHQgPSBtb2RlLT52ZGlzcGxheTsKKworCXJldHVybiB3aWR0aCAqIGhlaWdodDsKK30KKwog LyoKICAqIFRoZSBTVDc1ODYgY29udHJvbGxlciBoYXMgYW4gdW51c3VhbCBwaXhlbCBmb3JtYXQg d2hlcmUgMmJwcCBncmF5c2NhbGUgaXMKICAqIHBhY2tlZCAzIHBpeGVscyBwZXIgYnl0ZSB3aXRo IHRoZSBmaXJzdCB0d28gcGl4ZWxzIHVzaW5nIDMgYml0cyBhbmQgdGhlIDNyZApAQCAtMjYzLDcg KzI3MSw3IEBAIHN0YXRpYyBpbnQgc3Q3NTg2X2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1 Y3QgbWlwaV9kYmkgKm1pcGksCiAJCXN0cnVjdCBkcm1fZHJpdmVyICpkcml2ZXIsIGNvbnN0IHN0 cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlLAogCQl1bnNpZ25lZCBpbnQgcm90YXRpb24pCiB7 Ci0Jc2l6ZV90IGJ1ZnNpemUgPSAobW9kZS0+dmRpc3BsYXkgKyAyKSAvIDMgKiBtb2RlLT5oZGlz cGxheTsKKwlzaXplX3QgYnVmc2l6ZSA9IHN0NzU4Nl9idWZfbWF4X3NpemUobW9kZSk7CiAJc3Ry dWN0IHRpbnlkcm1fZGV2aWNlICp0ZGV2ID0gJm1pcGktPnRpbnlkcm07CiAJaW50IHJldDsKIApA QCAtMzM3LDYgKzM0NSw3IEBAIE1PRFVMRV9ERVZJQ0VfVEFCTEUoc3BpLCBzdDc1ODZfaWQpOwog CiBzdGF0aWMgaW50IHN0NzU4Nl9wcm9iZShzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQogeworCXNp emVfdCBidWZzaXplID0gc3Q3NTg2X2J1Zl9tYXhfc2l6ZSgmc3Q3NTg2X21vZGUpOwogCXN0cnVj dCBkZXZpY2UgKmRldiA9ICZzcGktPmRldjsKIAlzdHJ1Y3QgbWlwaV9kYmkgKm1pcGk7CiAJc3Ry dWN0IGdwaW9fZGVzYyAqYTA7CkBAIC0zNjEsNyArMzcwLDcgQEAgc3RhdGljIGludCBzdDc1ODZf cHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKIAogCWRldmljZV9wcm9wZXJ0eV9yZWFkX3Uz MihkZXYsICJyb3RhdGlvbiIsICZyb3RhdGlvbik7CiAKLQlyZXQgPSBtaXBpX2RiaV9zcGlfaW5p dChzcGksIG1pcGksIGEwKTsKKwlyZXQgPSBtaXBpX2RiaV9zcGlfaW5pdChzcGksIG1pcGksIGEw LCBidWZzaXplKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwogCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vdGlueWRybS9zdDc3MzVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vdGlueWRybS9z dDc3MzVyLmMKaW5kZXggMDhiNGZiMS4uYzA0N2JhYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL3Rpbnlkcm0vc3Q3NzM1ci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS90aW55ZHJtL3N0Nzcz NXIuYwpAQCAtMTQxLDYgKzE0MSw3IEBAIE1PRFVMRV9ERVZJQ0VfVEFCTEUoc3BpLCBzdDc3MzVy X2lkKTsKIAogc3RhdGljIGludCBzdDc3MzVyX3Byb2JlKHN0cnVjdCBzcGlfZGV2aWNlICpzcGkp CiB7CisJc2l6ZV90IGJ1ZnNpemUgPSBtaXBpX2RiaV9tYXhfYnVmX3NpemUoJmpkX3QxODAwM190 MDFfbW9kZSk7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnNwaS0+ZGV2OwogCXN0cnVjdCBtaXBp X2RiaSAqbWlwaTsKIAlzdHJ1Y3QgZ3Bpb19kZXNjICpkYzsKQEAgLTE2OSw3ICsxNzAsNyBAQCBz dGF0aWMgaW50IHN0NzczNXJfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKIAogCWRldmlj ZV9wcm9wZXJ0eV9yZWFkX3UzMihkZXYsICJyb3RhdGlvbiIsICZyb3RhdGlvbik7CiAKLQlyZXQg PSBtaXBpX2RiaV9zcGlfaW5pdChzcGksIG1pcGksIGRjKTsKKwlyZXQgPSBtaXBpX2RiaV9zcGlf aW5pdChzcGksIG1pcGksIGRjLCBidWZzaXplKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0Owog CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS90aW55ZHJtL21pcGktZGJpLmggYi9pbmNsdWRlL2Ry bS90aW55ZHJtL21pcGktZGJpLmgKaW5kZXggNDRlODI0YS4uZGVlZTg2MiAxMDA2NDQKLS0tIGEv aW5jbHVkZS9kcm0vdGlueWRybS9taXBpLWRiaS5oCisrKyBiL2luY2x1ZGUvZHJtL3Rpbnlkcm0v bWlwaS1kYmkuaApAQCAtMzEsNiArMzEsNyBAQCBzdHJ1Y3QgcmVndWxhdG9yOwogICogQHR4X2J1 ZjogQnVmZmVyIHVzZWQgZm9yIHRyYW5zZmVyIChjb3B5IGNsaXAgcmVjdCBhcmVhKQogICogQHR4 X2J1Zjk6IEJ1ZmZlciB1c2VkIGZvciBPcHRpb24gMSA5LWJpdCBjb252ZXJzaW9uCiAgKiBAdHhf YnVmOV9sZW46IFNpemUgb2YgdHhfYnVmOS4KKyAqIEByeF9idWY6IE9wdGlvbmFsIGR1bW15IFJY IGJ1ZmZlci4KICAqIEBzd2FwX2J5dGVzOiBTd2FwIGJ5dGVzIGluIGJ1ZmZlciBiZWZvcmUgdHJh bnNmZXIKICAqIEByZXNldDogT3B0aW9uYWwgcmVzZXQgZ3BpbwogICogQHJvdGF0aW9uOiBpbml0 aWFsIHJvdGF0aW9uIGluIGRlZ3JlZXMgQ291bnRlciBDbG9jayBXaXNlCkBAIC00OCw2ICs0OSw3 IEBAIHN0cnVjdCBtaXBpX2RiaSB7CiAJdTE2ICp0eF9idWY7CiAJdm9pZCAqdHhfYnVmOTsKIAlz aXplX3QgdHhfYnVmOV9sZW47CisJdm9pZCAqcnhfYnVmOwogCWJvb2wgc3dhcF9ieXRlczsKIAlz dHJ1Y3QgZ3Bpb19kZXNjICpyZXNldDsKIAl1bnNpZ25lZCBpbnQgcm90YXRpb247CkBAIC02Miw3 ICs2NCw3IEBAIG1pcGlfZGJpX2Zyb21fdGlueWRybShzdHJ1Y3QgdGlueWRybV9kZXZpY2UgKnRk ZXYpCiB9CiAKIGludCBtaXBpX2RiaV9zcGlfaW5pdChzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCBz dHJ1Y3QgbWlwaV9kYmkgKm1pcGksCi0JCSAgICAgIHN0cnVjdCBncGlvX2Rlc2MgKmRjKTsKKwkJ ICAgICAgc3RydWN0IGdwaW9fZGVzYyAqZGMsIHNpemVfdCBtYXhfc2l6ZSk7CiBpbnQgbWlwaV9k YmlfaW5pdChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwKIAkJICBj b25zdCBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MgKnBpcGVfZnVuY3MsCiAJ CSAgc3RydWN0IGRybV9kcml2ZXIgKmRyaXZlciwKQEAgLTc5LDYgKzgxLDE4IEBAIGludCBtaXBp X2RiaV9jb21tYW5kX3JlYWQoc3RydWN0IG1pcGlfZGJpICptaXBpLCB1OCBjbWQsIHU4ICp2YWwp OwogaW50IG1pcGlfZGJpX2NvbW1hbmRfYnVmKHN0cnVjdCBtaXBpX2RiaSAqbWlwaSwgdTggY21k LCB1OCAqZGF0YSwgc2l6ZV90IGxlbik7CiBpbnQgbWlwaV9kYmlfYnVmX2NvcHkodm9pZCAqZHN0 LCBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwKIAkJICAgICAgc3RydWN0IGRybV9jbGlwX3Jl Y3QgKmNsaXAsIGJvb2wgc3dhcCk7CisKKy8qKgorICogbWlwaV9kYmlfbWF4X2J1Zl9zaXplIC0g R2V0IHRoZSBtYXhpbXVtIHJlcXVpcmVkIGZyYW1lYnVmZmVyIG1lbW9yeSBzaXplCisgKiBAbW9k ZTogVGhlIGRpc3BsYXkgbW9kZSBkYXRhCisgKgorICogQ29tcHV0ZXMgdGhlIG1heGltdW0gYnVm ZmVyIHNpemUgbmVlZGVkIGZvciBhIDIgYnl0ZSBwZXIgcGl4ZWwgZGlzcGxheS4KKyAqLworc3Rh dGljIGlubGluZSBzaXplX3QgbWlwaV9kYmlfbWF4X2J1Zl9zaXplKGNvbnN0IHN0cnVjdCBkcm1f ZGlzcGxheV9tb2RlICptb2RlKQoreworCXJldHVybiBtb2RlLT5oZGlzcGxheSAqIG1vZGUtPnZk aXNwbGF5ICogc2l6ZW9mKHUxNik7Cit9CisKIC8qKgogICogbWlwaV9kYmlfY29tbWFuZCAtIE1J UEkgRENTIGNvbW1hbmQgd2l0aCBvcHRpb25hbCBwYXJhbWV0ZXIocykKICAqIEBtaXBpOiBNSVBJ IHN0cnVjdHVyZQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vdGlueWRybS90aW55ZHJtLWhlbHBl cnMuaCBiL2luY2x1ZGUvZHJtL3Rpbnlkcm0vdGlueWRybS1oZWxwZXJzLmgKaW5kZXggZDU1NGRl ZC4uZTVlOGY1OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vdGlueWRybS90aW55ZHJtLWhlbHBl cnMuaAorKysgYi9pbmNsdWRlL2RybS90aW55ZHJtL3Rpbnlkcm0taGVscGVycy5oCkBAIC01NCw3 ICs1NCw3IEBAIHNpemVfdCB0aW55ZHJtX3NwaV9tYXhfdHJhbnNmZXJfc2l6ZShzdHJ1Y3Qgc3Bp X2RldmljZSAqc3BpLCBzaXplX3QgbWF4X2xlbik7CiBib29sIHRpbnlkcm1fc3BpX2Jwd19zdXBw b3J0ZWQoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgdTggYnB3KTsKIGludCB0aW55ZHJtX3NwaV90 cmFuc2ZlcihzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCB1MzIgc3BlZWRfaHosCiAJCQkgc3RydWN0 IHNwaV90cmFuc2ZlciAqaGVhZGVyLCB1OCBicHcsIGNvbnN0IHZvaWQgKmJ1ZiwKLQkJCSBzaXpl X3QgbGVuKTsKKwkJCSB2b2lkICpyeF9idWYsIHNpemVfdCBsZW4pOwogdm9pZCBfdGlueWRybV9k Ymdfc3BpX21lc3NhZ2Uoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSwgc3RydWN0IHNwaV9tZXNzYWdl ICptKTsKIAogI2lmZGVmIERFQlVHCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932313AbeBSXVI (ORCPT ); Mon, 19 Feb 2018 18:21:08 -0500 Received: from vern.gendns.com ([206.190.152.46]:36106 "EHLO vern.gendns.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932196AbeBSXVG (ORCPT ); Mon, 19 Feb 2018 18:21:06 -0500 From: David Lechner To: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org, David Lechner , =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= Subject: [PATCH] drm/tinydrm: Allocate dummy SPI RX buffer if needed Date: Mon, 19 Feb 2018 17:21:01 -0600 Message-Id: <1519082461-32405-1-git-send-email-david@lechnology.com> X-Mailer: git-send-email 2.7.4 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-AntiAbuse: This header was added to track abuse, please include it with any abuse report X-AntiAbuse: Primary Hostname - vern.gendns.com X-AntiAbuse: Original Domain - vger.kernel.org X-AntiAbuse: Originator/Caller UID/GID - [47 12] / [47 12] X-AntiAbuse: Sender Address Domain - lechnology.com X-Get-Message-Sender-Via: vern.gendns.com: authenticated_id: davidmain+lechnology.com/only user confirmed/virtual account not confirmed X-Authenticated-Sender: vern.gendns.com: davidmain@lechnology.com X-Source: X-Source-Args: X-Source-Dir: Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This adds a new feature to allocate a dummy RX buffer for SPI controllers that require an RX buffer even when not receiving. If an RX buffer is not supplied, the SPI controller will reallocate a new buffer on each transfer. On systems with limited memory (e.g. 64MB and CONFIG_SWAP=n), this reallocation will occasionally fail, which causes the display to stop working. By allocating this buffer once and reusing it, we can prevent this problem. This patch also introduces some helper functions for calculating the size of this buffer, so these functions are re-used where possible (e.g. in mipi_dbi_init()). Cc: Noralf Trønnes Suggested-by: Noralf Trønnes Signed-off-by: David Lechner --- This is a follow up from the mail thread "tinydrm: page allocation failure" [1]. I actually got an allocation failure a few times even when I had swap enabled, so I think this change is needed. [1]: https://www.mail-archive.com/dri-devel@lists.freedesktop.org/msg203657.html drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c | 9 ++++++++- drivers/gpu/drm/tinydrm/ili9225.c | 8 +++++--- drivers/gpu/drm/tinydrm/mi0283qt.c | 3 ++- drivers/gpu/drm/tinydrm/mipi-dbi.c | 20 ++++++++++++++++---- drivers/gpu/drm/tinydrm/st7586.c | 13 +++++++++++-- drivers/gpu/drm/tinydrm/st7735r.c | 3 ++- include/drm/tinydrm/mipi-dbi.h | 16 +++++++++++++++- include/drm/tinydrm/tinydrm-helpers.h | 2 +- 8 files changed, 60 insertions(+), 14 deletions(-) diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c b/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c index bf96072..f5c175e 100644 --- a/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c +++ b/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c @@ -434,6 +434,7 @@ EXPORT_SYMBOL(_tinydrm_dbg_spi_message); * @header: Optional header transfer * @bpw: Bits per word * @buf: Buffer to transfer + * @rx_buf: Optional dummy buffer * @len: Buffer length * * This SPI transfer helper breaks up the transfer of @buf into chunks which @@ -442,16 +443,22 @@ EXPORT_SYMBOL(_tinydrm_dbg_spi_message); * does a 8-bit transfer. * If @header is set, it is prepended to each SPI message. * + * Some SPI controllers need an RX buffer even though we are not receiving + * anything useful. @rx_buf can be provided so that the SPI controller does not + * have to reallocate this buffer on each transfer. This is useful for large + * transfers, e.g. when updating the GRAM. + * * Returns: * Zero on success, negative error code on failure. */ int tinydrm_spi_transfer(struct spi_device *spi, u32 speed_hz, struct spi_transfer *header, u8 bpw, const void *buf, - size_t len) + void *rx_buf, size_t len) { struct spi_transfer tr = { .bits_per_word = bpw, .speed_hz = speed_hz, + .rx_buf = rx_buf, }; struct spi_message m; u16 *swap_buf = NULL; diff --git a/drivers/gpu/drm/tinydrm/ili9225.c b/drivers/gpu/drm/tinydrm/ili9225.c index a075950..c15f49a 100644 --- a/drivers/gpu/drm/tinydrm/ili9225.c +++ b/drivers/gpu/drm/tinydrm/ili9225.c @@ -300,7 +300,7 @@ static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 cmd, u8 *par, gpiod_set_value_cansleep(mipi->dc, 0); speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1); - ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1); + ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, NULL, 1); if (ret || !num) return ret; @@ -310,7 +310,8 @@ static int ili9225_dbi_command(struct mipi_dbi *mipi, u8 cmd, u8 *par, gpiod_set_value_cansleep(mipi->dc, 1); speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num); - return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, num); + return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, mipi->rx_buf, + num); } static const u32 ili9225_formats[] = { @@ -400,6 +401,7 @@ MODULE_DEVICE_TABLE(spi, ili9225_id); static int ili9225_probe(struct spi_device *spi) { + size_t bufsize = mipi_dbi_max_buf_size(&ili9225_mode); struct device *dev = &spi->dev; struct mipi_dbi *mipi; struct gpio_desc *rs; @@ -424,7 +426,7 @@ static int ili9225_probe(struct spi_device *spi) device_property_read_u32(dev, "rotation", &rotation); - ret = mipi_dbi_spi_init(spi, mipi, rs); + ret = mipi_dbi_spi_init(spi, mipi, rs, bufsize); if (ret) return ret; diff --git a/drivers/gpu/drm/tinydrm/mi0283qt.c b/drivers/gpu/drm/tinydrm/mi0283qt.c index 79cb5af..c3fa682 100644 --- a/drivers/gpu/drm/tinydrm/mi0283qt.c +++ b/drivers/gpu/drm/tinydrm/mi0283qt.c @@ -169,6 +169,7 @@ MODULE_DEVICE_TABLE(spi, mi0283qt_id); static int mi0283qt_probe(struct spi_device *spi) { + size_t bufsize = mipi_dbi_max_buf_size(&mi0283qt_mode); struct device *dev = &spi->dev; struct mipi_dbi *mipi; struct gpio_desc *dc; @@ -201,7 +202,7 @@ static int mi0283qt_probe(struct spi_device *spi) device_property_read_u32(dev, "rotation", &rotation); - ret = mipi_dbi_spi_init(spi, mipi, dc); + ret = mipi_dbi_spi_init(spi, mipi, dc, bufsize); if (ret) return ret; diff --git a/drivers/gpu/drm/tinydrm/mipi-dbi.c b/drivers/gpu/drm/tinydrm/mipi-dbi.c index 75dd65c..16bee06 100644 --- a/drivers/gpu/drm/tinydrm/mipi-dbi.c +++ b/drivers/gpu/drm/tinydrm/mipi-dbi.c @@ -364,7 +364,7 @@ int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi, struct drm_driver *driver, const struct drm_display_mode *mode, unsigned int rotation) { - size_t bufsize = mode->vdisplay * mode->hdisplay * sizeof(u16); + size_t bufsize = mipi_dbi_max_buf_size(mode); struct tinydrm_device *tdev = &mipi->tinydrm; int ret; @@ -848,7 +848,7 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, gpiod_set_value_cansleep(mipi->dc, 0); speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1); - ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1); + ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, NULL, 1); if (ret || !num) return ret; @@ -858,7 +858,8 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, gpiod_set_value_cansleep(mipi->dc, 1); speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num); - return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, num); + return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, mipi->rx_buf, + num); } /** @@ -866,6 +867,7 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, * @spi: SPI device * @mipi: &mipi_dbi structure to initialize * @dc: D/C gpio (optional) + * @max_size: Maximum TX buffer size needed by the caller * * This function sets &mipi_dbi->command, enables &mipi->read_commands for the * usual read commands. It should be followed by a call to mipi_dbi_init() or @@ -884,7 +886,7 @@ static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd, * Zero on success, negative error code on failure. */ int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi, - struct gpio_desc *dc) + struct gpio_desc *dc, size_t max_size) { size_t tx_size = tinydrm_spi_max_transfer_size(spi, 0); struct device *dev = &spi->dev; @@ -930,6 +932,16 @@ int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi, return -ENOMEM; } + /* + * Allocate a dummy RX buffer if needed, otherwise the SPI controller + * will have to reallocate a new buffer on each transfer. + */ + if (spi->controller->flags & SPI_CONTROLLER_MUST_RX) { + mipi->rx_buf = devm_kmalloc(dev, max_size, GFP_KERNEL); + if (!mipi->rx_buf) + return -ENOMEM; + } + DRM_DEBUG_DRIVER("SPI speed: %uMHz\n", spi->max_speed_hz / 1000000); return 0; diff --git a/drivers/gpu/drm/tinydrm/st7586.c b/drivers/gpu/drm/tinydrm/st7586.c index a6396ef..bb0d55d 100644 --- a/drivers/gpu/drm/tinydrm/st7586.c +++ b/drivers/gpu/drm/tinydrm/st7586.c @@ -42,6 +42,14 @@ #define ST7586_DISP_CTRL_MX BIT(6) #define ST7586_DISP_CTRL_MY BIT(7) +static inline size_t st7586_buf_max_size(const struct drm_display_mode *mode) +{ + size_t width = (mode->hdisplay + 2) / 3; /* 3 pixels per byte */ + size_t height = mode->vdisplay; + + return width * height; +} + /* * The ST7586 controller has an unusual pixel format where 2bpp grayscale is * packed 3 pixels per byte with the first two pixels using 3 bits and the 3rd @@ -263,7 +271,7 @@ static int st7586_init(struct device *dev, struct mipi_dbi *mipi, struct drm_driver *driver, const struct drm_display_mode *mode, unsigned int rotation) { - size_t bufsize = (mode->vdisplay + 2) / 3 * mode->hdisplay; + size_t bufsize = st7586_buf_max_size(mode); struct tinydrm_device *tdev = &mipi->tinydrm; int ret; @@ -337,6 +345,7 @@ MODULE_DEVICE_TABLE(spi, st7586_id); static int st7586_probe(struct spi_device *spi) { + size_t bufsize = st7586_buf_max_size(&st7586_mode); struct device *dev = &spi->dev; struct mipi_dbi *mipi; struct gpio_desc *a0; @@ -361,7 +370,7 @@ static int st7586_probe(struct spi_device *spi) device_property_read_u32(dev, "rotation", &rotation); - ret = mipi_dbi_spi_init(spi, mipi, a0); + ret = mipi_dbi_spi_init(spi, mipi, a0, bufsize); if (ret) return ret; diff --git a/drivers/gpu/drm/tinydrm/st7735r.c b/drivers/gpu/drm/tinydrm/st7735r.c index 08b4fb1..c047bac 100644 --- a/drivers/gpu/drm/tinydrm/st7735r.c +++ b/drivers/gpu/drm/tinydrm/st7735r.c @@ -141,6 +141,7 @@ MODULE_DEVICE_TABLE(spi, st7735r_id); static int st7735r_probe(struct spi_device *spi) { + size_t bufsize = mipi_dbi_max_buf_size(&jd_t18003_t01_mode); struct device *dev = &spi->dev; struct mipi_dbi *mipi; struct gpio_desc *dc; @@ -169,7 +170,7 @@ static int st7735r_probe(struct spi_device *spi) device_property_read_u32(dev, "rotation", &rotation); - ret = mipi_dbi_spi_init(spi, mipi, dc); + ret = mipi_dbi_spi_init(spi, mipi, dc, bufsize); if (ret) return ret; diff --git a/include/drm/tinydrm/mipi-dbi.h b/include/drm/tinydrm/mipi-dbi.h index 44e824a..deee862 100644 --- a/include/drm/tinydrm/mipi-dbi.h +++ b/include/drm/tinydrm/mipi-dbi.h @@ -31,6 +31,7 @@ struct regulator; * @tx_buf: Buffer used for transfer (copy clip rect area) * @tx_buf9: Buffer used for Option 1 9-bit conversion * @tx_buf9_len: Size of tx_buf9. + * @rx_buf: Optional dummy RX buffer. * @swap_bytes: Swap bytes in buffer before transfer * @reset: Optional reset gpio * @rotation: initial rotation in degrees Counter Clock Wise @@ -48,6 +49,7 @@ struct mipi_dbi { u16 *tx_buf; void *tx_buf9; size_t tx_buf9_len; + void *rx_buf; bool swap_bytes; struct gpio_desc *reset; unsigned int rotation; @@ -62,7 +64,7 @@ mipi_dbi_from_tinydrm(struct tinydrm_device *tdev) } int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi, - struct gpio_desc *dc); + struct gpio_desc *dc, size_t max_size); int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi, const struct drm_simple_display_pipe_funcs *pipe_funcs, struct drm_driver *driver, @@ -79,6 +81,18 @@ int mipi_dbi_command_read(struct mipi_dbi *mipi, u8 cmd, u8 *val); int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len); int mipi_dbi_buf_copy(void *dst, struct drm_framebuffer *fb, struct drm_clip_rect *clip, bool swap); + +/** + * mipi_dbi_max_buf_size - Get the maximum required framebuffer memory size + * @mode: The display mode data + * + * Computes the maximum buffer size needed for a 2 byte per pixel display. + */ +static inline size_t mipi_dbi_max_buf_size(const struct drm_display_mode *mode) +{ + return mode->hdisplay * mode->vdisplay * sizeof(u16); +} + /** * mipi_dbi_command - MIPI DCS command with optional parameter(s) * @mipi: MIPI structure diff --git a/include/drm/tinydrm/tinydrm-helpers.h b/include/drm/tinydrm/tinydrm-helpers.h index d554ded..e5e8f59 100644 --- a/include/drm/tinydrm/tinydrm-helpers.h +++ b/include/drm/tinydrm/tinydrm-helpers.h @@ -54,7 +54,7 @@ size_t tinydrm_spi_max_transfer_size(struct spi_device *spi, size_t max_len); bool tinydrm_spi_bpw_supported(struct spi_device *spi, u8 bpw); int tinydrm_spi_transfer(struct spi_device *spi, u32 speed_hz, struct spi_transfer *header, u8 bpw, const void *buf, - size_t len); + void *rx_buf, size_t len); void _tinydrm_dbg_spi_message(struct spi_device *spi, struct spi_message *m); #ifdef DEBUG -- 2.7.4