From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v8,2/3] dmaengine: fsl-edma: add edma version and configurable registers From: Angelo Dureghello Message-Id: <20180803193244.12084-2-angelo@sysam.it> Date: Fri, 3 Aug 2018 21:32:43 +0200 To: vinod.koul@linaro.org Cc: dmaengine@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-m68k@vger.kernel.org, stefan@agner.ch, krzk@kernel.org, Angelo Dureghello List-ID: VGhpcyBwYXRjaCBhZGRzIGNvbmZpZ3VyYWJsZSByZWdpc3RlcnMgKHVzaW5nIF9faW9tZW0gYWRk cmVzc2VzKQp0byBhbGxvdyB0aGUgdXNlIG9mIGZzbC1lZG1hLWNvbW1vbiBjb2RlIHdpdGggc2xp Z2h0bHkgZGlmZmVyZW50CmVkbWEgbW9kdWxlIHZlcnNpb25zLCBhcyBWeWJyaWQgKHYxKSBhbmQg Q29sZEZpcmUgKHYyKSBhcmUuCgpSZW1vdmFsIG9mIG9sZCBtZW1iYXNlLXJlZmVyZW5jZWQgcmVn aXN0ZXJzLCBhbWQgc29tZSBmaXhlcyBvbgptYWNyb2VzIGFyZSBpbmNsdWRlZC4KClNpZ25lZC1v ZmYtYnk6IEFuZ2VsbyBEdXJlZ2hlbGxvIDxhbmdlbG9Ac3lzYW0uaXQ+Ci0tLQpDaGFuZ2VzIGZy b20gdjc6Ci0gcGF0Y2ggcmV3cml0dGVuIGZyb20gc2NyYXRjaCwgdGhpcyBwYXRjaCAoMi8zKSBo YXMganVzdCBiZWVuIGFkZGVkLgotLS0KIGRyaXZlcnMvZG1hL2ZzbC1lZG1hLWNvbW1vbi5jIHwg MTM4ICsrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0KIGRyaXZlcnMvZG1hL2ZzbC1l ZG1hLWNvbW1vbi5oIHwgMTE1ICsrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMv ZG1hL2ZzbC1lZG1hLmMgICAgICAgIHwgIDMyICsrKystLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDE4 MiBpbnNlcnRpb25zKCspLCAxMDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9k bWEvZnNsLWVkbWEtY29tbW9uLmMgYi9kcml2ZXJzL2RtYS9mc2wtZWRtYS1jb21tb24uYwppbmRl eCAwYWU3MDk0ZjQ3N2EuLjk0OGEzZWU1MWJiYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvZnNs LWVkbWEtY29tbW9uLmMKKysrIGIvZHJpdmVycy9kbWEvZnNsLWVkbWEtY29tbW9uLmMKQEAgLTks NiArOSwzOCBAQAogCiAjaW5jbHVkZSAiZnNsLWVkbWEtY29tbW9uLmgiCiAKKyNkZWZpbmUgRURN QV9DUgkJCTB4MDAKKyNkZWZpbmUgRURNQV9FUwkJCTB4MDQKKyNkZWZpbmUgRURNQV9FUlEJCTB4 MEMKKyNkZWZpbmUgRURNQV9FRUkJCTB4MTQKKyNkZWZpbmUgRURNQV9TRVJRCQkweDFCCisjZGVm aW5lIEVETUFfQ0VSUQkJMHgxQQorI2RlZmluZSBFRE1BX1NFRUkJCTB4MTkKKyNkZWZpbmUgRURN QV9DRUVJCQkweDE4CisjZGVmaW5lIEVETUFfQ0lOVAkJMHgxRgorI2RlZmluZSBFRE1BX0NFUlIJ CTB4MUUKKyNkZWZpbmUgRURNQV9TU1JUCQkweDFECisjZGVmaW5lIEVETUFfQ0RORQkJMHgxQwor I2RlZmluZSBFRE1BX0lOVFIJCTB4MjQKKyNkZWZpbmUgRURNQV9FUlIJCTB4MkMKKworI2RlZmlu ZSBFRE1BNjRfRVJRSAkJMHgwOAorI2RlZmluZSBFRE1BNjRfRUVJSAkJMHgxMAorI2RlZmluZSBF RE1BNjRfU0VSUQkJMHgxOAorI2RlZmluZSBFRE1BNjRfQ0VSUQkJMHgxOQorI2RlZmluZSBFRE1B NjRfU0VFSQkJMHgxYQorI2RlZmluZSBFRE1BNjRfQ0VFSQkJMHgxYgorI2RlZmluZSBFRE1BNjRf Q0lOVAkJMHgxYworI2RlZmluZSBFRE1BNjRfQ0VSUgkJMHgxZAorI2RlZmluZSBFRE1BNjRfU1NS VAkJMHgxZQorI2RlZmluZSBFRE1BNjRfQ0RORQkJMHgxZgorI2RlZmluZSBFRE1BNjRfSU5USAkJ MHgyMAorI2RlZmluZSBFRE1BNjRfSU5UTAkJMHgyNAorI2RlZmluZSBFRE1BNjRfRVJSSAkJMHgy OAorI2RlZmluZSBFRE1BNjRfRVJSTAkJMHgyYworCisjZGVmaW5lIEVETUFfVENECQkweDEwMDAK KwogLyoKICAqIFIvVyBmdW5jdGlvbnMgZm9yIGJpZy0gb3IgbGl0dGxlLWVuZGlhbiByZWdpc3Rl cnM6CiAgKiBUaGUgZURNQSBjb250cm9sbGVyJ3MgZW5kaWFuIGlzIGluZGVwZW5kZW50IG9mIHRo ZSBDUFUgY29yZSdzIGVuZGlhbi4KQEAgLTY3LDIwICs5OSwyMCBAQCBFWFBPUlRfU1lNQk9MX0dQ TCh0b19mc2xfZWRtYV9kZXNjKTsKIAogc3RhdGljIHZvaWQgZnNsX2VkbWFfZW5hYmxlX3JlcXVl c3Qoc3RydWN0IGZzbF9lZG1hX2NoYW4gKmZzbF9jaGFuKQogewotCXZvaWQgX19pb21lbSAqYWRk ciA9IGZzbF9jaGFuLT5lZG1hLT5tZW1iYXNlOworCXN0cnVjdCBlZG1hX3JlZ3MgKnJlZ3MgPSAm ZnNsX2NoYW4tPmVkbWEtPnJlZ3M7CiAJdTMyIGNoID0gZnNsX2NoYW4tPnZjaGFuLmNoYW4uY2hh bl9pZDsKIAotCWVkbWFfd3JpdGViKGZzbF9jaGFuLT5lZG1hLCBFRE1BX1NFRUlfU0VFSShjaCks IGFkZHIgKyBFRE1BX1NFRUkpOwotCWVkbWFfd3JpdGViKGZzbF9jaGFuLT5lZG1hLCBjaCwgYWRk ciArIEVETUFfU0VSUSk7CisJZWRtYV93cml0ZWIoZnNsX2NoYW4tPmVkbWEsIEVETUFfU0VFSV9T RUVJKGNoKSwgcmVncy0+c2VlaSk7CisJZWRtYV93cml0ZWIoZnNsX2NoYW4tPmVkbWEsIGNoLCBy ZWdzLT5zZXJxKTsKIH0KIAogdm9pZCBmc2xfZWRtYV9kaXNhYmxlX3JlcXVlc3Qoc3RydWN0IGZz bF9lZG1hX2NoYW4gKmZzbF9jaGFuKQogewotCXZvaWQgX19pb21lbSAqYWRkciA9IGZzbF9jaGFu LT5lZG1hLT5tZW1iYXNlOworCXN0cnVjdCBlZG1hX3JlZ3MgKnJlZ3MgPSAmZnNsX2NoYW4tPmVk bWEtPnJlZ3M7CiAJdTMyIGNoID0gZnNsX2NoYW4tPnZjaGFuLmNoYW4uY2hhbl9pZDsKIAotCWVk bWFfd3JpdGViKGZzbF9jaGFuLT5lZG1hLCBjaCwgYWRkciArIEVETUFfQ0VSUSk7Ci0JZWRtYV93 cml0ZWIoZnNsX2NoYW4tPmVkbWEsIEVETUFfQ0VFSV9DRUVJKGNoKSwgYWRkciArIEVETUFfQ0VF SSk7CisJZWRtYV93cml0ZWIoZnNsX2NoYW4tPmVkbWEsIGNoLCByZWdzLT5jZXJxKTsKKwllZG1h X3dyaXRlYihmc2xfY2hhbi0+ZWRtYSwgRURNQV9DRUVJX0NFRUkoY2gpLCByZWdzLT5jZWVpKTsK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKGZzbF9lZG1hX2Rpc2FibGVfcmVxdWVzdCk7CiAKQEAgLTIw OCw3ICsyNDAsNyBAQCBzdGF0aWMgc2l6ZV90IGZzbF9lZG1hX2Rlc2NfcmVzaWR1ZShzdHJ1Y3Qg ZnNsX2VkbWFfY2hhbiAqZnNsX2NoYW4sCiAJCXN0cnVjdCB2aXJ0X2RtYV9kZXNjICp2ZGVzYywg Ym9vbCBpbl9wcm9ncmVzcykKIHsKIAlzdHJ1Y3QgZnNsX2VkbWFfZGVzYyAqZWRlc2MgPSBmc2xf Y2hhbi0+ZWRlc2M7Ci0Jdm9pZCBfX2lvbWVtICphZGRyID0gZnNsX2NoYW4tPmVkbWEtPm1lbWJh c2U7CisJc3RydWN0IGVkbWFfcmVncyAqcmVncyA9ICZmc2xfY2hhbi0+ZWRtYS0+cmVnczsKIAl1 MzIgY2ggPSBmc2xfY2hhbi0+dmNoYW4uY2hhbi5jaGFuX2lkOwogCWVudW0gZG1hX3RyYW5zZmVy X2RpcmVjdGlvbiBkaXIgPSBmc2xfY2hhbi0+ZnNjLmRpcjsKIAlkbWFfYWRkcl90IGN1cl9hZGRy LCBkbWFfYWRkcjsKQEAgLTIyNCwxMSArMjU2LDkgQEAgc3RhdGljIHNpemVfdCBmc2xfZWRtYV9k ZXNjX3Jlc2lkdWUoc3RydWN0IGZzbF9lZG1hX2NoYW4gKmZzbF9jaGFuLAogCQlyZXR1cm4gbGVu OwogCiAJaWYgKGRpciA9PSBETUFfTUVNX1RPX0RFVikKLQkJY3VyX2FkZHIgPSBlZG1hX3JlYWRs KAotCQkJZnNsX2NoYW4tPmVkbWEsIGFkZHIgKyBFRE1BX1RDRF9TQUREUihjaCkpOworCQljdXJf YWRkciA9IGVkbWFfcmVhZGwoZnNsX2NoYW4tPmVkbWEsICZyZWdzLT50Y2RbY2hdLnNhZGRyKTsK IAllbHNlCi0JCWN1cl9hZGRyID0gZWRtYV9yZWFkbCgKLQkJCWZzbF9jaGFuLT5lZG1hLCBhZGRy ICsgRURNQV9UQ0RfREFERFIoY2gpKTsKKwkJY3VyX2FkZHIgPSBlZG1hX3JlYWRsKGZzbF9jaGFu LT5lZG1hLCAmcmVncy0+dGNkW2NoXS5kYWRkcik7CiAKIAkvKiBmaWd1cmUgb3V0IHRoZSBmaW5p c2hlZCBhbmQgY2FsY3VsYXRlIHRoZSByZXNpZHVlICovCiAJZm9yIChpID0gMDsgaSA8IGZzbF9j aGFuLT5lZGVzYy0+bl90Y2RzOyBpKyspIHsKQEAgLTI4NSw3ICszMTUsNyBAQCBzdGF0aWMgdm9p ZCBmc2xfZWRtYV9zZXRfdGNkX3JlZ3Moc3RydWN0IGZzbF9lZG1hX2NoYW4gKmZzbF9jaGFuLAog CQkJCSAgc3RydWN0IGZzbF9lZG1hX2h3X3RjZCAqdGNkKQogewogCXN0cnVjdCBmc2xfZWRtYV9l bmdpbmUgKmVkbWEgPSBmc2xfY2hhbi0+ZWRtYTsKLQl2b2lkIF9faW9tZW0gKmFkZHIgPSBmc2xf Y2hhbi0+ZWRtYS0+bWVtYmFzZTsKKwlzdHJ1Y3QgZWRtYV9yZWdzICpyZWdzID0gJmZzbF9jaGFu LT5lZG1hLT5yZWdzOwogCXUzMiBjaCA9IGZzbF9jaGFuLT52Y2hhbi5jaGFuLmNoYW5faWQ7CiAK IAkvKgpAQCAtMjkzLDI0ICszMjMsMjQgQEAgc3RhdGljIHZvaWQgZnNsX2VkbWFfc2V0X3RjZF9y ZWdzKHN0cnVjdCBmc2xfZWRtYV9jaGFuICpmc2xfY2hhbiwKIAkgKiBlbmRpYW4gZm9ybWF0LiBI b3dldmVyLCB3ZSBuZWVkIHRvIGxvYWQgdGhlIFRDRCByZWdpc3RlcnMgaW4KIAkgKiBiaWctIG9y IGxpdHRsZS1lbmRpYW4gb2JleWluZyB0aGUgZURNQSBlbmdpbmUgbW9kZWwgZW5kaWFuLgogCSAq LwotCWVkbWFfd3JpdGV3KGVkbWEsIDAsIGFkZHIgKyBFRE1BX1RDRF9DU1IoY2gpKTsKLQllZG1h X3dyaXRlbChlZG1hLCBsZTMyX3RvX2NwdSh0Y2QtPnNhZGRyKSwgYWRkciArIEVETUFfVENEX1NB RERSKGNoKSk7Ci0JZWRtYV93cml0ZWwoZWRtYSwgbGUzMl90b19jcHUodGNkLT5kYWRkciksIGFk ZHIgKyBFRE1BX1RDRF9EQUREUihjaCkpOworCWVkbWFfd3JpdGV3KGVkbWEsIDAsICAmcmVncy0+ dGNkW2NoXS5jc3IpOworCWVkbWFfd3JpdGVsKGVkbWEsIGxlMzJfdG9fY3B1KHRjZC0+c2FkZHIp LCAmcmVncy0+dGNkW2NoXS5zYWRkcik7CisJZWRtYV93cml0ZWwoZWRtYSwgbGUzMl90b19jcHUo dGNkLT5kYWRkciksICZyZWdzLT50Y2RbY2hdLmRhZGRyKTsKIAotCWVkbWFfd3JpdGV3KGVkbWEs IGxlMTZfdG9fY3B1KHRjZC0+YXR0ciksIGFkZHIgKyBFRE1BX1RDRF9BVFRSKGNoKSk7Ci0JZWRt YV93cml0ZXcoZWRtYSwgbGUxNl90b19jcHUodGNkLT5zb2ZmKSwgYWRkciArIEVETUFfVENEX1NP RkYoY2gpKTsKKwllZG1hX3dyaXRldyhlZG1hLCBsZTE2X3RvX2NwdSh0Y2QtPmF0dHIpLCAmcmVn cy0+dGNkW2NoXS5hdHRyKTsKKwllZG1hX3dyaXRldyhlZG1hLCBsZTE2X3RvX2NwdSh0Y2QtPnNv ZmYpLCAmcmVncy0+dGNkW2NoXS5zb2ZmKTsKIAotCWVkbWFfd3JpdGVsKGVkbWEsIGxlMzJfdG9f Y3B1KHRjZC0+bmJ5dGVzKSwgYWRkciArIEVETUFfVENEX05CWVRFUyhjaCkpOwotCWVkbWFfd3Jp dGVsKGVkbWEsIGxlMzJfdG9fY3B1KHRjZC0+c2xhc3QpLCBhZGRyICsgRURNQV9UQ0RfU0xBU1Qo Y2gpKTsKKwllZG1hX3dyaXRlbChlZG1hLCBsZTMyX3RvX2NwdSh0Y2QtPm5ieXRlcyksICZyZWdz LT50Y2RbY2hdLm5ieXRlcyk7CisJZWRtYV93cml0ZWwoZWRtYSwgbGUzMl90b19jcHUodGNkLT5z bGFzdCksICZyZWdzLT50Y2RbY2hdLnNsYXN0KTsKIAotCWVkbWFfd3JpdGV3KGVkbWEsIGxlMTZf dG9fY3B1KHRjZC0+Y2l0ZXIpLCBhZGRyICsgRURNQV9UQ0RfQ0lURVIoY2gpKTsKLQllZG1hX3dy aXRldyhlZG1hLCBsZTE2X3RvX2NwdSh0Y2QtPmJpdGVyKSwgYWRkciArIEVETUFfVENEX0JJVEVS KGNoKSk7Ci0JZWRtYV93cml0ZXcoZWRtYSwgbGUxNl90b19jcHUodGNkLT5kb2ZmKSwgYWRkciAr IEVETUFfVENEX0RPRkYoY2gpKTsKKwllZG1hX3dyaXRldyhlZG1hLCBsZTE2X3RvX2NwdSh0Y2Qt PmNpdGVyKSwgJnJlZ3MtPnRjZFtjaF0uY2l0ZXIpOworCWVkbWFfd3JpdGV3KGVkbWEsIGxlMTZf dG9fY3B1KHRjZC0+Yml0ZXIpLCAmcmVncy0+dGNkW2NoXS5iaXRlcik7CisJZWRtYV93cml0ZXco ZWRtYSwgbGUxNl90b19jcHUodGNkLT5kb2ZmKSwgJnJlZ3MtPnRjZFtjaF0uZG9mZik7CiAKLQll ZG1hX3dyaXRlbChlZG1hLAotCQkgICAgbGUzMl90b19jcHUodGNkLT5kbGFzdF9zZ2EpLCBhZGRy ICsgRURNQV9UQ0RfRExBU1RfU0dBKGNoKSk7CisJZWRtYV93cml0ZWwoZWRtYSwgbGUzMl90b19j cHUodGNkLT5kbGFzdF9zZ2EpLAorCQkJJnJlZ3MtPnRjZFtjaF0uZGxhc3Rfc2dhKTsKIAotCWVk bWFfd3JpdGV3KGVkbWEsIGxlMTZfdG9fY3B1KHRjZC0+Y3NyKSwgYWRkciArIEVETUFfVENEX0NT UihjaCkpOworCWVkbWFfd3JpdGV3KGVkbWEsIGxlMTZfdG9fY3B1KHRjZC0+Y3NyKSwgJnJlZ3Mt PnRjZFtjaF0uY3NyKTsKIH0KIAogc3RhdGljIGlubGluZQpAQCAtMzMyLDE1ICszNjIsMTUgQEAg dm9pZCBmc2xfZWRtYV9maWxsX3RjZChzdHJ1Y3QgZnNsX2VkbWFfaHdfdGNkICp0Y2QsIHUzMiBz cmMsIHUzMiBkc3QsCiAKIAl0Y2QtPmF0dHIgPSBjcHVfdG9fbGUxNihhdHRyKTsKIAotCXRjZC0+ c29mZiA9IGNwdV90b19sZTE2KEVETUFfVENEX1NPRkZfU09GRihzb2ZmKSk7CisJdGNkLT5zb2Zm ID0gY3B1X3RvX2xlMTYoc29mZik7CiAKLQl0Y2QtPm5ieXRlcyA9IGNwdV90b19sZTMyKEVETUFf VENEX05CWVRFU19OQllURVMobmJ5dGVzKSk7Ci0JdGNkLT5zbGFzdCA9IGNwdV90b19sZTMyKEVE TUFfVENEX1NMQVNUX1NMQVNUKHNsYXN0KSk7CisJdGNkLT5uYnl0ZXMgPSBjcHVfdG9fbGUzMihu Ynl0ZXMpOworCXRjZC0+c2xhc3QgPSBjcHVfdG9fbGUzMihzbGFzdCk7CiAKIAl0Y2QtPmNpdGVy ID0gY3B1X3RvX2xlMTYoRURNQV9UQ0RfQ0lURVJfQ0lURVIoY2l0ZXIpKTsKLQl0Y2QtPmRvZmYg PSBjcHVfdG9fbGUxNihFRE1BX1RDRF9ET0ZGX0RPRkYoZG9mZikpOworCXRjZC0+ZG9mZiA9IGNw dV90b19sZTE2KGRvZmYpOwogCi0JdGNkLT5kbGFzdF9zZ2EgPSBjcHVfdG9fbGUzMihFRE1BX1RD RF9ETEFTVF9TR0FfRExBU1RfU0dBKGRsYXN0X3NnYSkpOworCXRjZC0+ZGxhc3Rfc2dhID0gY3B1 X3RvX2xlMzIoZGxhc3Rfc2dhKTsKIAogCXRjZC0+Yml0ZXIgPSBjcHVfdG9fbGUxNihFRE1BX1RD RF9CSVRFUl9CSVRFUihiaXRlcikpOwogCWlmIChtYWpvcl9pbnQpCkBAIC01NzMsNCArNjAzLDUy IEBAIHZvaWQgZnNsX2VkbWFfY2xlYW51cF92Y2hhbihzdHJ1Y3QgZG1hX2RldmljZSAqZG1hZGV2 KQogfQogRVhQT1JUX1NZTUJPTF9HUEwoZnNsX2VkbWFfY2xlYW51cF92Y2hhbik7CiAKKy8qCisg KiBPbiB0aGUgMzIgY2hhbm5lbHMgVnlicmlkL21wYzU3N3ggZWRtYSB2ZXJzaW9uIChoZXJlIGNh bGxlZCAidjEiKSwKKyAqIHJlZ2lzdGVyIG9mZnNldHMgYXJlIGRpZmZlcmVudCBjb21wYXJlZCB0 byBDb2xkRmlyZSBtY2Y1NDQxeCA2NCBjaGFubmVscworICogZWRtYSAoaGVyZSBjYWxsZWQgInYy IikuCisgKgorICogVGhpcyBmdW5jdGlvbiBzZXRzIHVwIHJlZ2lzdGVyIG9mZnNldHMgYXMgcGVy IHByb3BlciBkZWNsYXJlZCB2ZXJzaW9uCisgKiBzbyBtdXN0IGJlIGNhbGxlZCBpbiB4eHhfZWRt YV9wcm9iZSgpIGp1c3QgYWZ0ZXIgc2V0dGluZyB0aGUKKyAqIGVkbWEgInZlcnNpb24iIGFuZCAi bWVtYmFzZSIgYXBwcm9wcmlhdGVseS4KKyAqLwordm9pZCBmc2xfZWRtYV9zZXR1cF9yZWdzKHN0 cnVjdCBmc2xfZWRtYV9lbmdpbmUgKmVkbWEpCit7CisJZWRtYS0+cmVncy5jciA9IGVkbWEtPm1l bWJhc2UgKyBFRE1BX0NSOworCWVkbWEtPnJlZ3MuZXMgPSBlZG1hLT5tZW1iYXNlICsgRURNQV9F UzsKKwllZG1hLT5yZWdzLmVycWwgPSBlZG1hLT5tZW1iYXNlICsgRURNQV9FUlE7CisJZWRtYS0+ cmVncy5lZWlsID0gZWRtYS0+bWVtYmFzZSArIEVETUFfRUVJOworCisJZWRtYS0+cmVncy5zZXJx ID0gZWRtYS0+bWVtYmFzZSArICgoZWRtYS0+dmVyc2lvbiA9PSB2MSkgPworCQkJRURNQV9TRVJR IDogRURNQTY0X1NFUlEpOworCWVkbWEtPnJlZ3MuY2VycSA9IGVkbWEtPm1lbWJhc2UgKyAoKGVk bWEtPnZlcnNpb24gPT0gdjEpID8KKwkJCUVETUFfQ0VSUSA6IEVETUE2NF9DRVJRKTsKKwllZG1h LT5yZWdzLnNlZWkgPSBlZG1hLT5tZW1iYXNlICsgKChlZG1hLT52ZXJzaW9uID09IHYxKSA/CisJ CQlFRE1BX1NFRUkgOiBFRE1BNjRfU0VFSSk7CisJZWRtYS0+cmVncy5jZWVpID0gZWRtYS0+bWVt YmFzZSArICgoZWRtYS0+dmVyc2lvbiA9PSB2MSkgPworCQkJRURNQV9DRUVJIDogRURNQTY0X0NF RUkpOworCWVkbWEtPnJlZ3MuY2ludCA9IGVkbWEtPm1lbWJhc2UgKyAoKGVkbWEtPnZlcnNpb24g PT0gdjEpID8KKwkJCUVETUFfQ0lOVCA6IEVETUE2NF9DSU5UKTsKKwllZG1hLT5yZWdzLmNlcnIg PSBlZG1hLT5tZW1iYXNlICsgKChlZG1hLT52ZXJzaW9uID09IHYxKSA/CisJCQlFRE1BX0NFUlIg OiBFRE1BNjRfQ0VSUik7CisJZWRtYS0+cmVncy5zc3J0ID0gZWRtYS0+bWVtYmFzZSArICgoZWRt YS0+dmVyc2lvbiA9PSB2MSkgPworCQkJRURNQV9TU1JUIDogRURNQTY0X1NTUlQpOworCWVkbWEt PnJlZ3MuY2RuZSA9IGVkbWEtPm1lbWJhc2UgKyAoKGVkbWEtPnZlcnNpb24gPT0gdjEpID8KKwkJ CUVETUFfQ0RORSA6IEVETUE2NF9DRE5FKTsKKwllZG1hLT5yZWdzLmludGwgPSBlZG1hLT5tZW1i YXNlICsgKChlZG1hLT52ZXJzaW9uID09IHYxKSA/CisJCQlFRE1BX0lOVFIgOiBFRE1BNjRfSU5U TCk7CisJZWRtYS0+cmVncy5lcnJsID0gZWRtYS0+bWVtYmFzZSArICgoZWRtYS0+dmVyc2lvbiA9 PSB2MSkgPworCQkJRURNQV9FUlIgOiBFRE1BNjRfRVJSTCk7CisKKwlpZiAoZWRtYS0+dmVyc2lv biA9PSB2MikgeworCQllZG1hLT5yZWdzLmVycWggPSBlZG1hLT5tZW1iYXNlICsgRURNQTY0X0VS UUg7CisJCWVkbWEtPnJlZ3MuZWVpaCA9IGVkbWEtPm1lbWJhc2UgKyBFRE1BNjRfRUVJSDsKKwkJ ZWRtYS0+cmVncy5lcnJoID0gZWRtYS0+bWVtYmFzZSArIEVETUE2NF9FUlJIOworCQllZG1hLT5y ZWdzLmludGggPSBlZG1hLT5tZW1iYXNlICsgRURNQTY0X0lOVEg7CisJfQorCisJZWRtYS0+cmVn cy50Y2QgPSBlZG1hLT5tZW1iYXNlICsgRURNQV9UQ0Q7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChm c2xfZWRtYV9zZXR1cF9yZWdzKTsKKwogTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9kbWEvZnNsLWVkbWEtY29tbW9uLmggYi9kcml2ZXJzL2RtYS9mc2wtZWRt YS1jb21tb24uaAppbmRleCBmM2VhNjhlMTViMjMuLjdhOTIzMWU3NjM5ZiAxMDA2NDQKLS0tIGEv ZHJpdmVycy9kbWEvZnNsLWVkbWEtY29tbW9uLmgKKysrIGIvZHJpdmVycy9kbWEvZnNsLWVkbWEt Y29tbW9uLmgKQEAgLTgsMzUgKzgsNiBAQAogCiAjaW5jbHVkZSAidmlydC1kbWEuaCIKIAotI2Rl ZmluZSBFRE1BX0NSCQkJMHgwMAotI2RlZmluZSBFRE1BX0VTCQkJMHgwNAotI2RlZmluZSBFRE1B X0VSUQkJMHgwQwotI2RlZmluZSBFRE1BX0VFSQkJMHgxNAotI2RlZmluZSBFRE1BX1NFUlEJCTB4 MUIKLSNkZWZpbmUgRURNQV9DRVJRCQkweDFBCi0jZGVmaW5lIEVETUFfU0VFSQkJMHgxOQotI2Rl ZmluZSBFRE1BX0NFRUkJCTB4MTgKLSNkZWZpbmUgRURNQV9DSU5UCQkweDFGCi0jZGVmaW5lIEVE TUFfQ0VSUgkJMHgxRQotI2RlZmluZSBFRE1BX1NTUlQJCTB4MUQKLSNkZWZpbmUgRURNQV9DRE5F CQkweDFDCi0jZGVmaW5lIEVETUFfSU5UUgkJMHgyNAotI2RlZmluZSBFRE1BX0VSUgkJMHgyQwot Ci0jZGVmaW5lIEVETUFfVENEX1NBRERSKHgpCSgweDEwMDAgKyAzMiAqICh4KSkKLSNkZWZpbmUg RURNQV9UQ0RfU09GRih4KQkoMHgxMDA0ICsgMzIgKiAoeCkpCi0jZGVmaW5lIEVETUFfVENEX0FU VFIoeCkJKDB4MTAwNiArIDMyICogKHgpKQotI2RlZmluZSBFRE1BX1RDRF9OQllURVMoeCkJKDB4 MTAwOCArIDMyICogKHgpKQotI2RlZmluZSBFRE1BX1RDRF9TTEFTVCh4KQkoMHgxMDBDICsgMzIg KiAoeCkpCi0jZGVmaW5lIEVETUFfVENEX0RBRERSKHgpCSgweDEwMTAgKyAzMiAqICh4KSkKLSNk ZWZpbmUgRURNQV9UQ0RfRE9GRih4KQkoMHgxMDE0ICsgMzIgKiAoeCkpCi0jZGVmaW5lIEVETUFf VENEX0NJVEVSX0VMSU5LKHgpCSgweDEwMTYgKyAzMiAqICh4KSkKLSNkZWZpbmUgRURNQV9UQ0Rf Q0lURVIoeCkJKDB4MTAxNiArIDMyICogKHgpKQotI2RlZmluZSBFRE1BX1RDRF9ETEFTVF9TR0Eo eCkJKDB4MTAxOCArIDMyICogKHgpKQotI2RlZmluZSBFRE1BX1RDRF9DU1IoeCkJCSgweDEwMUMg KyAzMiAqICh4KSkKLSNkZWZpbmUgRURNQV9UQ0RfQklURVJfRUxJTksoeCkJKDB4MTAxRSArIDMy ICogKHgpKQotI2RlZmluZSBFRE1BX1RDRF9CSVRFUih4KQkoMHgxMDFFICsgMzIgKiAoeCkpCi0K ICNkZWZpbmUgRURNQV9DUl9FREJHCQlCSVQoMSkKICNkZWZpbmUgRURNQV9DUl9FUkNBCQlCSVQo MikKICNkZWZpbmUgRURNQV9DUl9FUkdBCQlCSVQoMykKQEAgLTQ3LDM0ICsxOCwyOSBAQAogI2Rl ZmluZSBFRE1BX0NSX0VDWAkJQklUKDE2KQogI2RlZmluZSBFRE1BX0NSX0NYCQlCSVQoMTcpCiAK LSNkZWZpbmUgRURNQV9TRUVJX1NFRUkoeCkJKCh4KSAmIDB4MUYpCi0jZGVmaW5lIEVETUFfQ0VF SV9DRUVJKHgpCSgoeCkgJiAweDFGKQotI2RlZmluZSBFRE1BX0NJTlRfQ0lOVCh4KQkoKHgpICYg MHgxRikKLSNkZWZpbmUgRURNQV9DRVJSX0NFUlIoeCkJKCh4KSAmIDB4MUYpCi0KLSNkZWZpbmUg RURNQV9UQ0RfQVRUUl9EU0laRSh4KQkJKCgoeCkgJiAweDAwMDcpKQotI2RlZmluZSBFRE1BX1RD RF9BVFRSX0RNT0QoeCkJCSgoKHgpICYgMHgwMDFGKSA8PCAzKQotI2RlZmluZSBFRE1BX1RDRF9B VFRSX1NTSVpFKHgpCQkoKCh4KSAmIDB4MDAwNykgPDwgOCkKLSNkZWZpbmUgRURNQV9UQ0RfQVRU Ul9TTU9EKHgpCQkoKCh4KSAmIDB4MDAxRikgPDwgMTEpCi0jZGVmaW5lIEVETUFfVENEX0FUVFJf U1NJWkVfOEJJVAkoMHgwMDAwKQotI2RlZmluZSBFRE1BX1RDRF9BVFRSX1NTSVpFXzE2QklUCSgw eDAxMDApCi0jZGVmaW5lIEVETUFfVENEX0FUVFJfU1NJWkVfMzJCSVQJKDB4MDIwMCkKLSNkZWZp bmUgRURNQV9UQ0RfQVRUUl9TU0laRV82NEJJVAkoMHgwMzAwKQotI2RlZmluZSBFRE1BX1RDRF9B VFRSX1NTSVpFXzMyQllURQkoMHgwNTAwKQotI2RlZmluZSBFRE1BX1RDRF9BVFRSX0RTSVpFXzhC SVQJKDB4MDAwMCkKLSNkZWZpbmUgRURNQV9UQ0RfQVRUUl9EU0laRV8xNkJJVAkoMHgwMDAxKQot I2RlZmluZSBFRE1BX1RDRF9BVFRSX0RTSVpFXzMyQklUCSgweDAwMDIpCi0jZGVmaW5lIEVETUFf VENEX0FUVFJfRFNJWkVfNjRCSVQJKDB4MDAwMykKLSNkZWZpbmUgRURNQV9UQ0RfQVRUUl9EU0la RV8zMkJZVEUJKDB4MDAwNSkKLQotI2RlZmluZSBFRE1BX1RDRF9TT0ZGX1NPRkYoeCkJCSh4KQot I2RlZmluZSBFRE1BX1RDRF9OQllURVNfTkJZVEVTKHgpCSh4KQotI2RlZmluZSBFRE1BX1RDRF9T TEFTVF9TTEFTVCh4KQkJKHgpCi0jZGVmaW5lIEVETUFfVENEX0RBRERSX0RBRERSKHgpCQkoeCkK LSNkZWZpbmUgRURNQV9UQ0RfQ0lURVJfQ0lURVIoeCkJCSgoeCkgJiAweDdGRkYpCi0jZGVmaW5l IEVETUFfVENEX0RPRkZfRE9GRih4KQkJKHgpCi0jZGVmaW5lIEVETUFfVENEX0RMQVNUX1NHQV9E TEFTVF9TR0EoeCkJKHgpCi0jZGVmaW5lIEVETUFfVENEX0JJVEVSX0JJVEVSKHgpCQkoKHgpICYg MHg3RkZGKQorI2RlZmluZSBFRE1BX1NFRUlfU0VFSSh4KQkoKHgpICYgR0VOTUFTSyg0LCAwKSkK KyNkZWZpbmUgRURNQV9DRUVJX0NFRUkoeCkJKCh4KSAmIEdFTk1BU0soNCwgMCkpCisjZGVmaW5l IEVETUFfQ0lOVF9DSU5UKHgpCSgoeCkgJiBHRU5NQVNLKDQsIDApKQorI2RlZmluZSBFRE1BX0NF UlJfQ0VSUih4KQkoKHgpICYgR0VOTUFTSyg0LCAwKSkKKworI2RlZmluZSBFRE1BX1RDRF9BVFRS X0RTSVpFKHgpCQkoKCh4KSAmIEdFTk1BU0soMiwgMCkpKQorI2RlZmluZSBFRE1BX1RDRF9BVFRS X0RNT0QoeCkJCSgoKHgpICYgR0VOTUFTSyg0LCAwKSkgPDwgMykKKyNkZWZpbmUgRURNQV9UQ0Rf QVRUUl9TU0laRSh4KQkJKCgoeCkgJiBHRU5NQVNLKDIsIDApKSA8PCA4KQorI2RlZmluZSBFRE1B X1RDRF9BVFRSX1NNT0QoeCkJCSgoKHgpICYgR0VOTUFTSyg0LCAwKSkgPDwgMTEpCisKKyNkZWZp bmUgRURNQV9UQ0RfQVRUUl9EU0laRV84QklUCTAKKyNkZWZpbmUgRURNQV9UQ0RfQVRUUl9EU0la RV8xNkJJVAlCSVQoMCkKKyNkZWZpbmUgRURNQV9UQ0RfQVRUUl9EU0laRV8zMkJJVAlCSVQoMSkK KyNkZWZpbmUgRURNQV9UQ0RfQVRUUl9EU0laRV82NEJJVAkoQklUKDApIHwgQklUKDEpKQorI2Rl ZmluZSBFRE1BX1RDRF9BVFRSX0RTSVpFXzMyQllURQkoQklUKDMpIHwgQklUKDApKQorI2RlZmlu ZSBFRE1BX1RDRF9BVFRSX1NTSVpFXzhCSVQJMAorI2RlZmluZSBFRE1BX1RDRF9BVFRSX1NTSVpF XzE2QklUCShFRE1BX1RDRF9BVFRSX0RTSVpFXzE2QklUIDw8IDgpCisjZGVmaW5lIEVETUFfVENE X0FUVFJfU1NJWkVfMzJCSVQJKEVETUFfVENEX0FUVFJfRFNJWkVfMzJCSVQgPDwgOCkKKyNkZWZp bmUgRURNQV9UQ0RfQVRUUl9TU0laRV82NEJJVAkoRURNQV9UQ0RfQVRUUl9EU0laRV82NEJJVCA8 PCA4KQorI2RlZmluZSBFRE1BX1RDRF9BVFRSX1NTSVpFXzMyQllURQkoRURNQV9UQ0RfQVRUUl9E U0laRV8zMkJZVEUgPDwgOCkKKworI2RlZmluZSBFRE1BX1RDRF9DSVRFUl9DSVRFUih4KQkJKCh4 KSAmIEdFTk1BU0soMTQsIDApKQorI2RlZmluZSBFRE1BX1RDRF9CSVRFUl9CSVRFUih4KQkJKCh4 KSAmIEdFTk1BU0soMTQsIDApKQogCiAjZGVmaW5lIEVETUFfVENEX0NTUl9TVEFSVAkJQklUKDAp CiAjZGVmaW5lIEVETUFfVENEX0NTUl9JTlRfTUFKT1IJCUJJVCgxKQpAQCAtODcsNyArNTMsNyBA QAogCiAjZGVmaW5lIEVETUFNVVhfQ0hDRkdfRElTCQkweDAKICNkZWZpbmUgRURNQU1VWF9DSENG R19FTkJMCQkweDgwCi0jZGVmaW5lIEVETUFNVVhfQ0hDRkdfU09VUkNFKG4pCQkoKG4pICYgMHgz RikKKyNkZWZpbmUgRURNQU1VWF9DSENGR19TT1VSQ0UobikJCSgobikgJiBHRU5NQVNLKDYsIDAp KQogCiAjZGVmaW5lIERNQU1VWF9OUgkyCiAKQEAgLTExNCw2ICs4MCwzMSBAQCBzdHJ1Y3QgZnNs X2VkbWFfaHdfdGNkIHsKIAlfX2xlMTYJYml0ZXI7CiB9OwogCisvKgorICogVGhpcyBhcmUgaW9t ZW0gcG9pbnRlcnMsIGZvciBib3RoIHYzMiBhbmQgdjY0LgorICovCitzdHJ1Y3QgZWRtYV9yZWdz IHsKKwl2b2lkIF9faW9tZW0gKmNyOworCXZvaWQgX19pb21lbSAqZXM7CisJdm9pZCBfX2lvbWVt ICplcnFoOworCXZvaWQgX19pb21lbSAqZXJxbDsJLyogYWthIGVycSBvbiB2MzIgKi8KKwl2b2lk IF9faW9tZW0gKmVlaWg7CisJdm9pZCBfX2lvbWVtICplZWlsOwkvKiBha2EgZWVpIG9uIHYzMiAq LworCXZvaWQgX19pb21lbSAqc2VlaTsKKwl2b2lkIF9faW9tZW0gKmNlZWk7CisJdm9pZCBfX2lv bWVtICpzZXJxOworCXZvaWQgX19pb21lbSAqY2VycTsKKwl2b2lkIF9faW9tZW0gKmNpbnQ7CisJ dm9pZCBfX2lvbWVtICpjZXJyOworCXZvaWQgX19pb21lbSAqc3NydDsKKwl2b2lkIF9faW9tZW0g KmNkbmU7CisJdm9pZCBfX2lvbWVtICppbnRoOworCXZvaWQgX19pb21lbSAqaW50bDsKKwl2b2lk IF9faW9tZW0gKmVycmg7CisJdm9pZCBfX2lvbWVtICplcnJsOworCXN0cnVjdCBmc2xfZWRtYV9o d190Y2QgX19pb21lbSAqdGNkOworfTsKKwogc3RydWN0IGZzbF9lZG1hX3N3X3RjZCB7CiAJZG1h X2FkZHJfdAkJCXB0Y2Q7CiAJc3RydWN0IGZzbF9lZG1hX2h3X3RjZAkJKnZ0Y2Q7CkBAIC0xNDcs NiArMTM4LDExIEBAIHN0cnVjdCBmc2xfZWRtYV9kZXNjIHsKIAlzdHJ1Y3QgZnNsX2VkbWFfc3df dGNkCQl0Y2RbXTsKIH07CiAKK2VudW0gZWRtYV92ZXJzaW9uIHsKKwl2MSwgLyogMzJjaCwgVnli ZGlyLCBtcGM1N3gsIGV0YyAqLworCXYyLCAvKiA2NGNoIENvbGRmaXJlICovCit9OworCiBzdHJ1 Y3QgZnNsX2VkbWFfZW5naW5lIHsKIAlzdHJ1Y3QgZG1hX2RldmljZQlkbWFfZGV2OwogCXZvaWQg X19pb21lbQkJKm1lbWJhc2U7CkBAIC0xNTcsNiArMTUzLDggQEAgc3RydWN0IGZzbF9lZG1hX2Vu Z2luZSB7CiAJaW50CQkJdHhpcnE7CiAJaW50CQkJZXJyaXJxOwogCWJvb2wJCQliaWdfZW5kaWFu OworCWVudW0gZWRtYV92ZXJzaW9uCXZlcnNpb247CisJc3RydWN0IGVkbWFfcmVncwlyZWdzOwog CXN0cnVjdCBmc2xfZWRtYV9jaGFuCWNoYW5zW107CiB9OwogCkBAIC0xOTIsNSArMTkwLDYgQEAg dm9pZCBmc2xfZWRtYV9pc3N1ZV9wZW5kaW5nKHN0cnVjdCBkbWFfY2hhbiAqY2hhbik7CiBpbnQg ZnNsX2VkbWFfYWxsb2NfY2hhbl9yZXNvdXJjZXMoc3RydWN0IGRtYV9jaGFuICpjaGFuKTsKIHZv aWQgZnNsX2VkbWFfZnJlZV9jaGFuX3Jlc291cmNlcyhzdHJ1Y3QgZG1hX2NoYW4gKmNoYW4pOwog dm9pZCBmc2xfZWRtYV9jbGVhbnVwX3ZjaGFuKHN0cnVjdCBkbWFfZGV2aWNlICpkbWFkZXYpOwor dm9pZCBmc2xfZWRtYV9zZXR1cF9yZWdzKHN0cnVjdCBmc2xfZWRtYV9lbmdpbmUgKmVkbWEpOwog CiAjZW5kaWYgLyogX0ZTTF9FRE1BX0NPTU1PTl9IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9k bWEvZnNsLWVkbWEuYyBiL2RyaXZlcnMvZG1hL2ZzbC1lZG1hLmMKaW5kZXggMzM3YWQwYzBlYTc4 Li4zNGQ3MDExMmZjYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL2ZzbC1lZG1hLmMKKysrIGIv ZHJpdmVycy9kbWEvZnNsLWVkbWEuYwpAQCAtMjgsMTkgKzI4LDE2IEBAIHN0YXRpYyBpcnFyZXR1 cm5fdCBmc2xfZWRtYV90eF9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHsKIAlzdHJ1 Y3QgZnNsX2VkbWFfZW5naW5lICpmc2xfZWRtYSA9IGRldl9pZDsKIAl1bnNpZ25lZCBpbnQgaW50 ciwgY2g7Ci0Jdm9pZCBfX2lvbWVtICpiYXNlX2FkZHI7CisJc3RydWN0IGVkbWFfcmVncyAqcmVn cyA9ICZmc2xfZWRtYS0+cmVnczsKIAlzdHJ1Y3QgZnNsX2VkbWFfY2hhbiAqZnNsX2NoYW47CiAK LQliYXNlX2FkZHIgPSBmc2xfZWRtYS0+bWVtYmFzZTsKLQotCWludHIgPSBlZG1hX3JlYWRsKGZz bF9lZG1hLCBiYXNlX2FkZHIgKyBFRE1BX0lOVFIpOworCWludHIgPSBlZG1hX3JlYWRsKGZzbF9l ZG1hLCByZWdzLT5pbnRsKTsKIAlpZiAoIWludHIpCiAJCXJldHVybiBJUlFfTk9ORTsKIAogCWZv ciAoY2ggPSAwOyBjaCA8IGZzbF9lZG1hLT5uX2NoYW5zOyBjaCsrKSB7CiAJCWlmIChpbnRyICYg KDB4MSA8PCBjaCkpIHsKLQkJCWVkbWFfd3JpdGViKGZzbF9lZG1hLCBFRE1BX0NJTlRfQ0lOVChj aCksCi0JCQkJYmFzZV9hZGRyICsgRURNQV9DSU5UKTsKKwkJCWVkbWFfd3JpdGViKGZzbF9lZG1h LCBFRE1BX0NJTlRfQ0lOVChjaCksIHJlZ3MtPmNpbnQpOwogCiAJCQlmc2xfY2hhbiA9ICZmc2xf ZWRtYS0+Y2hhbnNbY2hdOwogCkBAIC02OCwxNiArNjUsMTYgQEAgc3RhdGljIGlycXJldHVybl90 IGZzbF9lZG1hX2Vycl9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHsKIAlzdHJ1Y3Qg ZnNsX2VkbWFfZW5naW5lICpmc2xfZWRtYSA9IGRldl9pZDsKIAl1bnNpZ25lZCBpbnQgZXJyLCBj aDsKKwlzdHJ1Y3QgZWRtYV9yZWdzICpyZWdzID0gJmZzbF9lZG1hLT5yZWdzOwogCi0JZXJyID0g ZWRtYV9yZWFkbChmc2xfZWRtYSwgZnNsX2VkbWEtPm1lbWJhc2UgKyBFRE1BX0VSUik7CisJZXJy ID0gZWRtYV9yZWFkbChmc2xfZWRtYSwgcmVncy0+ZXJybCk7CiAJaWYgKCFlcnIpCiAJCXJldHVy biBJUlFfTk9ORTsKIAogCWZvciAoY2ggPSAwOyBjaCA8IGZzbF9lZG1hLT5uX2NoYW5zOyBjaCsr KSB7CiAJCWlmIChlcnIgJiAoMHgxIDw8IGNoKSkgewogCQkJZnNsX2VkbWFfZGlzYWJsZV9yZXF1 ZXN0KCZmc2xfZWRtYS0+Y2hhbnNbY2hdKTsKLQkJCWVkbWFfd3JpdGViKGZzbF9lZG1hLCBFRE1B X0NFUlJfQ0VSUihjaCksCi0JCQkJZnNsX2VkbWEtPm1lbWJhc2UgKyBFRE1BX0NFUlIpOworCQkJ ZWRtYV93cml0ZWIoZnNsX2VkbWEsIEVETUFfQ0VSUl9DRVJSKGNoKSwgcmVncy0+Y2Vycik7CiAJ CQlmc2xfZWRtYS0+Y2hhbnNbY2hdLnN0YXR1cyA9IERNQV9FUlJPUjsKIAkJCWZzbF9lZG1hLT5j aGFuc1tjaF0uaWRsZSA9IHRydWU7CiAJCX0KQEAgLTE5Miw2ICsxODksNyBAQCBzdGF0aWMgaW50 IGZzbF9lZG1hX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJc3RydWN0IGRl dmljZV9ub2RlICpucCA9IHBkZXYtPmRldi5vZl9ub2RlOwogCXN0cnVjdCBmc2xfZWRtYV9lbmdp bmUgKmZzbF9lZG1hOwogCXN0cnVjdCBmc2xfZWRtYV9jaGFuICpmc2xfY2hhbjsKKwlzdHJ1Y3Qg ZWRtYV9yZWdzICpyZWdzOwogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCWludCBsZW4sIGNoYW5z OwogCWludCByZXQsIGk7CkBAIC0yMDcsNiArMjA1LDcgQEAgc3RhdGljIGludCBmc2xfZWRtYV9w cm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmICghZnNsX2VkbWEpCiAJCXJl dHVybiAtRU5PTUVNOwogCisJZnNsX2VkbWEtPnZlcnNpb24gPSB2MTsKIAlmc2xfZWRtYS0+bl9j aGFucyA9IGNoYW5zOwogCW11dGV4X2luaXQoJmZzbF9lZG1hLT5mc2xfZWRtYV9tdXRleCk7CiAK QEAgLTIxNSw2ICsyMTQsOSBAQCBzdGF0aWMgaW50IGZzbF9lZG1hX3Byb2JlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKElTX0VSUihmc2xfZWRtYS0+bWVtYmFzZSkpCiAJCXJl dHVybiBQVFJfRVJSKGZzbF9lZG1hLT5tZW1iYXNlKTsKIAorCWZzbF9lZG1hX3NldHVwX3JlZ3Mo ZnNsX2VkbWEpOworCXJlZ3MgPSAmZnNsX2VkbWEtPnJlZ3M7CisKIAlmb3IgKGkgPSAwOyBpIDwg RE1BTVVYX05SOyBpKyspIHsKIAkJY2hhciBjbGtuYW1lWzMyXTsKIApAQCAtMjU1LDExICsyNTcs MTEgQEAgc3RhdGljIGludCBmc2xfZWRtYV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2KQogCQlmc2xfY2hhbi0+dmNoYW4uZGVzY19mcmVlID0gZnNsX2VkbWFfZnJlZV9kZXNjOwog CQl2Y2hhbl9pbml0KCZmc2xfY2hhbi0+dmNoYW4sICZmc2xfZWRtYS0+ZG1hX2Rldik7CiAKLQkJ ZWRtYV93cml0ZXcoZnNsX2VkbWEsIDB4MCwgZnNsX2VkbWEtPm1lbWJhc2UgKyBFRE1BX1RDRF9D U1IoaSkpOworCQllZG1hX3dyaXRldyhmc2xfZWRtYSwgMHgwLCAmcmVncy0+dGNkW2ldLmNzcik7 CiAJCWZzbF9lZG1hX2NoYW5fbXV4KGZzbF9jaGFuLCAwLCBmYWxzZSk7CiAJfQogCi0JZWRtYV93 cml0ZWwoZnNsX2VkbWEsIH4wLCBmc2xfZWRtYS0+bWVtYmFzZSArIEVETUFfSU5UUik7CisJZWRt YV93cml0ZWwoZnNsX2VkbWEsIH4wLCByZWdzLT5pbnRsKTsKIAlyZXQgPSBmc2xfZWRtYV9pcnFf aW5pdChwZGV2LCBmc2xfZWRtYSk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKQEAgLTMwNiw3 ICszMDgsNyBAQCBzdGF0aWMgaW50IGZzbF9lZG1hX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCiAJfQogCiAJLyogZW5hYmxlIHJvdW5kIHJvYmluIGFyYml0cmF0aW9uICovCi0J ZWRtYV93cml0ZWwoZnNsX2VkbWEsIEVETUFfQ1JfRVJHQSB8IEVETUFfQ1JfRVJDQSwgZnNsX2Vk bWEtPm1lbWJhc2UgKyBFRE1BX0NSKTsKKwllZG1hX3dyaXRlbChmc2xfZWRtYSwgRURNQV9DUl9F UkdBIHwgRURNQV9DUl9FUkNBLCByZWdzLT5jcik7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTM1Mywx OCArMzU1LDE4IEBAIHN0YXRpYyBpbnQgZnNsX2VkbWFfcmVzdW1lX2Vhcmx5KHN0cnVjdCBkZXZp Y2UgKmRldikKIHsKIAlzdHJ1Y3QgZnNsX2VkbWFfZW5naW5lICpmc2xfZWRtYSA9IGRldl9nZXRf ZHJ2ZGF0YShkZXYpOwogCXN0cnVjdCBmc2xfZWRtYV9jaGFuICpmc2xfY2hhbjsKKwlzdHJ1Y3Qg ZWRtYV9yZWdzICpyZWdzID0gJmZzbF9lZG1hLT5yZWdzOwogCWludCBpOwogCiAJZm9yIChpID0g MDsgaSA8IGZzbF9lZG1hLT5uX2NoYW5zOyBpKyspIHsKIAkJZnNsX2NoYW4gPSAmZnNsX2VkbWEt PmNoYW5zW2ldOwogCQlmc2xfY2hhbi0+cG1fc3RhdGUgPSBSVU5OSU5HOwotCQllZG1hX3dyaXRl dyhmc2xfZWRtYSwgMHgwLCBmc2xfZWRtYS0+bWVtYmFzZSArIEVETUFfVENEX0NTUihpKSk7CisJ CWVkbWFfd3JpdGV3KGZzbF9lZG1hLCAweDAsICZyZWdzLT50Y2RbaV0uY3NyKTsKIAkJaWYgKGZz bF9jaGFuLT5zbGF2ZV9pZCAhPSAwKQogCQkJZnNsX2VkbWFfY2hhbl9tdXgoZnNsX2NoYW4sIGZz bF9jaGFuLT5zbGF2ZV9pZCwgdHJ1ZSk7CiAJfQogCi0JZWRtYV93cml0ZWwoZnNsX2VkbWEsIEVE TUFfQ1JfRVJHQSB8IEVETUFfQ1JfRVJDQSwKLQkJCWZzbF9lZG1hLT5tZW1iYXNlICsgRURNQV9D Uik7CisJZWRtYV93cml0ZWwoZnNsX2VkbWEsIEVETUFfQ1JfRVJHQSB8IEVETUFfQ1JfRVJDQSwg cmVncy0+Y3IpOwogCiAJcmV0dXJuIDA7CiB9Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: Angelo Dureghello Subject: [PATCH v8 2/3] dmaengine: fsl-edma: add edma version and configurable registers Date: Fri, 3 Aug 2018 21:32:43 +0200 Message-ID: <20180803193244.12084-2-angelo@sysam.it> References: <20180803193244.12084-1-angelo@sysam.it> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: <20180803193244.12084-1-angelo@sysam.it> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: vinod.koul@linaro.org Cc: linux-m68k@vger.kernel.org, Angelo Dureghello , krzk@kernel.org, stefan@agner.ch, dmaengine@vger.kernel.org, linux-arm-kernel@lists.infradead.org List-Id: linux-m68k@vger.kernel.org This patch adds configurable registers (using __iomem addresses) to allow the use of fsl-edma-common code with slightly different edma module versions, as Vybrid (v1) and ColdFire (v2) are. Removal of old membase-referenced registers, amd some fixes on macroes are included. Signed-off-by: Angelo Dureghello --- Changes from v7: - patch rewritten from scratch, this patch (2/3) has just been added. --- drivers/dma/fsl-edma-common.c | 138 ++++++++++++++++++++++++++-------- drivers/dma/fsl-edma-common.h | 115 ++++++++++++++-------------- drivers/dma/fsl-edma.c | 32 ++++---- 3 files changed, 182 insertions(+), 103 deletions(-) diff --git a/drivers/dma/fsl-edma-common.c b/drivers/dma/fsl-edma-common.c index 0ae7094f477a..948a3ee51bbb 100644 --- a/drivers/dma/fsl-edma-common.c +++ b/drivers/dma/fsl-edma-common.c @@ -9,6 +9,38 @@ #include "fsl-edma-common.h" +#define EDMA_CR 0x00 +#define EDMA_ES 0x04 +#define EDMA_ERQ 0x0C +#define EDMA_EEI 0x14 +#define EDMA_SERQ 0x1B +#define EDMA_CERQ 0x1A +#define EDMA_SEEI 0x19 +#define EDMA_CEEI 0x18 +#define EDMA_CINT 0x1F +#define EDMA_CERR 0x1E +#define EDMA_SSRT 0x1D +#define EDMA_CDNE 0x1C +#define EDMA_INTR 0x24 +#define EDMA_ERR 0x2C + +#define EDMA64_ERQH 0x08 +#define EDMA64_EEIH 0x10 +#define EDMA64_SERQ 0x18 +#define EDMA64_CERQ 0x19 +#define EDMA64_SEEI 0x1a +#define EDMA64_CEEI 0x1b +#define EDMA64_CINT 0x1c +#define EDMA64_CERR 0x1d +#define EDMA64_SSRT 0x1e +#define EDMA64_CDNE 0x1f +#define EDMA64_INTH 0x20 +#define EDMA64_INTL 0x24 +#define EDMA64_ERRH 0x28 +#define EDMA64_ERRL 0x2c + +#define EDMA_TCD 0x1000 + /* * R/W functions for big- or little-endian registers: * The eDMA controller's endian is independent of the CPU core's endian. @@ -67,20 +99,20 @@ EXPORT_SYMBOL_GPL(to_fsl_edma_desc); static void fsl_edma_enable_request(struct fsl_edma_chan *fsl_chan) { - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; - edma_writeb(fsl_chan->edma, EDMA_SEEI_SEEI(ch), addr + EDMA_SEEI); - edma_writeb(fsl_chan->edma, ch, addr + EDMA_SERQ); + edma_writeb(fsl_chan->edma, EDMA_SEEI_SEEI(ch), regs->seei); + edma_writeb(fsl_chan->edma, ch, regs->serq); } void fsl_edma_disable_request(struct fsl_edma_chan *fsl_chan) { - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; - edma_writeb(fsl_chan->edma, ch, addr + EDMA_CERQ); - edma_writeb(fsl_chan->edma, EDMA_CEEI_CEEI(ch), addr + EDMA_CEEI); + edma_writeb(fsl_chan->edma, ch, regs->cerq); + edma_writeb(fsl_chan->edma, EDMA_CEEI_CEEI(ch), regs->ceei); } EXPORT_SYMBOL_GPL(fsl_edma_disable_request); @@ -208,7 +240,7 @@ static size_t fsl_edma_desc_residue(struct fsl_edma_chan *fsl_chan, struct virt_dma_desc *vdesc, bool in_progress) { struct fsl_edma_desc *edesc = fsl_chan->edesc; - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; enum dma_transfer_direction dir = fsl_chan->fsc.dir; dma_addr_t cur_addr, dma_addr; @@ -224,11 +256,9 @@ static size_t fsl_edma_desc_residue(struct fsl_edma_chan *fsl_chan, return len; if (dir == DMA_MEM_TO_DEV) - cur_addr = edma_readl( - fsl_chan->edma, addr + EDMA_TCD_SADDR(ch)); + cur_addr = edma_readl(fsl_chan->edma, ®s->tcd[ch].saddr); else - cur_addr = edma_readl( - fsl_chan->edma, addr + EDMA_TCD_DADDR(ch)); + cur_addr = edma_readl(fsl_chan->edma, ®s->tcd[ch].daddr); /* figure out the finished and calculate the residue */ for (i = 0; i < fsl_chan->edesc->n_tcds; i++) { @@ -285,7 +315,7 @@ static void fsl_edma_set_tcd_regs(struct fsl_edma_chan *fsl_chan, struct fsl_edma_hw_tcd *tcd) { struct fsl_edma_engine *edma = fsl_chan->edma; - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; /* @@ -293,24 +323,24 @@ static void fsl_edma_set_tcd_regs(struct fsl_edma_chan *fsl_chan, * endian format. However, we need to load the TCD registers in * big- or little-endian obeying the eDMA engine model endian. */ - edma_writew(edma, 0, addr + EDMA_TCD_CSR(ch)); - edma_writel(edma, le32_to_cpu(tcd->saddr), addr + EDMA_TCD_SADDR(ch)); - edma_writel(edma, le32_to_cpu(tcd->daddr), addr + EDMA_TCD_DADDR(ch)); + edma_writew(edma, 0, ®s->tcd[ch].csr); + edma_writel(edma, le32_to_cpu(tcd->saddr), ®s->tcd[ch].saddr); + edma_writel(edma, le32_to_cpu(tcd->daddr), ®s->tcd[ch].daddr); - edma_writew(edma, le16_to_cpu(tcd->attr), addr + EDMA_TCD_ATTR(ch)); - edma_writew(edma, le16_to_cpu(tcd->soff), addr + EDMA_TCD_SOFF(ch)); + edma_writew(edma, le16_to_cpu(tcd->attr), ®s->tcd[ch].attr); + edma_writew(edma, le16_to_cpu(tcd->soff), ®s->tcd[ch].soff); - edma_writel(edma, le32_to_cpu(tcd->nbytes), addr + EDMA_TCD_NBYTES(ch)); - edma_writel(edma, le32_to_cpu(tcd->slast), addr + EDMA_TCD_SLAST(ch)); + edma_writel(edma, le32_to_cpu(tcd->nbytes), ®s->tcd[ch].nbytes); + edma_writel(edma, le32_to_cpu(tcd->slast), ®s->tcd[ch].slast); - edma_writew(edma, le16_to_cpu(tcd->citer), addr + EDMA_TCD_CITER(ch)); - edma_writew(edma, le16_to_cpu(tcd->biter), addr + EDMA_TCD_BITER(ch)); - edma_writew(edma, le16_to_cpu(tcd->doff), addr + EDMA_TCD_DOFF(ch)); + edma_writew(edma, le16_to_cpu(tcd->citer), ®s->tcd[ch].citer); + edma_writew(edma, le16_to_cpu(tcd->biter), ®s->tcd[ch].biter); + edma_writew(edma, le16_to_cpu(tcd->doff), ®s->tcd[ch].doff); - edma_writel(edma, - le32_to_cpu(tcd->dlast_sga), addr + EDMA_TCD_DLAST_SGA(ch)); + edma_writel(edma, le32_to_cpu(tcd->dlast_sga), + ®s->tcd[ch].dlast_sga); - edma_writew(edma, le16_to_cpu(tcd->csr), addr + EDMA_TCD_CSR(ch)); + edma_writew(edma, le16_to_cpu(tcd->csr), ®s->tcd[ch].csr); } static inline @@ -332,15 +362,15 @@ void fsl_edma_fill_tcd(struct fsl_edma_hw_tcd *tcd, u32 src, u32 dst, tcd->attr = cpu_to_le16(attr); - tcd->soff = cpu_to_le16(EDMA_TCD_SOFF_SOFF(soff)); + tcd->soff = cpu_to_le16(soff); - tcd->nbytes = cpu_to_le32(EDMA_TCD_NBYTES_NBYTES(nbytes)); - tcd->slast = cpu_to_le32(EDMA_TCD_SLAST_SLAST(slast)); + tcd->nbytes = cpu_to_le32(nbytes); + tcd->slast = cpu_to_le32(slast); tcd->citer = cpu_to_le16(EDMA_TCD_CITER_CITER(citer)); - tcd->doff = cpu_to_le16(EDMA_TCD_DOFF_DOFF(doff)); + tcd->doff = cpu_to_le16(doff); - tcd->dlast_sga = cpu_to_le32(EDMA_TCD_DLAST_SGA_DLAST_SGA(dlast_sga)); + tcd->dlast_sga = cpu_to_le32(dlast_sga); tcd->biter = cpu_to_le16(EDMA_TCD_BITER_BITER(biter)); if (major_int) @@ -573,4 +603,52 @@ void fsl_edma_cleanup_vchan(struct dma_device *dmadev) } EXPORT_SYMBOL_GPL(fsl_edma_cleanup_vchan); +/* + * On the 32 channels Vybrid/mpc577x edma version (here called "v1"), + * register offsets are different compared to ColdFire mcf5441x 64 channels + * edma (here called "v2"). + * + * This function sets up register offsets as per proper declared version + * so must be called in xxx_edma_probe() just after setting the + * edma "version" and "membase" appropriately. + */ +void fsl_edma_setup_regs(struct fsl_edma_engine *edma) +{ + edma->regs.cr = edma->membase + EDMA_CR; + edma->regs.es = edma->membase + EDMA_ES; + edma->regs.erql = edma->membase + EDMA_ERQ; + edma->regs.eeil = edma->membase + EDMA_EEI; + + edma->regs.serq = edma->membase + ((edma->version == v1) ? + EDMA_SERQ : EDMA64_SERQ); + edma->regs.cerq = edma->membase + ((edma->version == v1) ? + EDMA_CERQ : EDMA64_CERQ); + edma->regs.seei = edma->membase + ((edma->version == v1) ? + EDMA_SEEI : EDMA64_SEEI); + edma->regs.ceei = edma->membase + ((edma->version == v1) ? + EDMA_CEEI : EDMA64_CEEI); + edma->regs.cint = edma->membase + ((edma->version == v1) ? + EDMA_CINT : EDMA64_CINT); + edma->regs.cerr = edma->membase + ((edma->version == v1) ? + EDMA_CERR : EDMA64_CERR); + edma->regs.ssrt = edma->membase + ((edma->version == v1) ? + EDMA_SSRT : EDMA64_SSRT); + edma->regs.cdne = edma->membase + ((edma->version == v1) ? + EDMA_CDNE : EDMA64_CDNE); + edma->regs.intl = edma->membase + ((edma->version == v1) ? + EDMA_INTR : EDMA64_INTL); + edma->regs.errl = edma->membase + ((edma->version == v1) ? + EDMA_ERR : EDMA64_ERRL); + + if (edma->version == v2) { + edma->regs.erqh = edma->membase + EDMA64_ERQH; + edma->regs.eeih = edma->membase + EDMA64_EEIH; + edma->regs.errh = edma->membase + EDMA64_ERRH; + edma->regs.inth = edma->membase + EDMA64_INTH; + } + + edma->regs.tcd = edma->membase + EDMA_TCD; +} +EXPORT_SYMBOL_GPL(fsl_edma_setup_regs); + MODULE_LICENSE("GPL v2"); diff --git a/drivers/dma/fsl-edma-common.h b/drivers/dma/fsl-edma-common.h index f3ea68e15b23..7a9231e7639f 100644 --- a/drivers/dma/fsl-edma-common.h +++ b/drivers/dma/fsl-edma-common.h @@ -8,35 +8,6 @@ #include "virt-dma.h" -#define EDMA_CR 0x00 -#define EDMA_ES 0x04 -#define EDMA_ERQ 0x0C -#define EDMA_EEI 0x14 -#define EDMA_SERQ 0x1B -#define EDMA_CERQ 0x1A -#define EDMA_SEEI 0x19 -#define EDMA_CEEI 0x18 -#define EDMA_CINT 0x1F -#define EDMA_CERR 0x1E -#define EDMA_SSRT 0x1D -#define EDMA_CDNE 0x1C -#define EDMA_INTR 0x24 -#define EDMA_ERR 0x2C - -#define EDMA_TCD_SADDR(x) (0x1000 + 32 * (x)) -#define EDMA_TCD_SOFF(x) (0x1004 + 32 * (x)) -#define EDMA_TCD_ATTR(x) (0x1006 + 32 * (x)) -#define EDMA_TCD_NBYTES(x) (0x1008 + 32 * (x)) -#define EDMA_TCD_SLAST(x) (0x100C + 32 * (x)) -#define EDMA_TCD_DADDR(x) (0x1010 + 32 * (x)) -#define EDMA_TCD_DOFF(x) (0x1014 + 32 * (x)) -#define EDMA_TCD_CITER_ELINK(x) (0x1016 + 32 * (x)) -#define EDMA_TCD_CITER(x) (0x1016 + 32 * (x)) -#define EDMA_TCD_DLAST_SGA(x) (0x1018 + 32 * (x)) -#define EDMA_TCD_CSR(x) (0x101C + 32 * (x)) -#define EDMA_TCD_BITER_ELINK(x) (0x101E + 32 * (x)) -#define EDMA_TCD_BITER(x) (0x101E + 32 * (x)) - #define EDMA_CR_EDBG BIT(1) #define EDMA_CR_ERCA BIT(2) #define EDMA_CR_ERGA BIT(3) @@ -47,34 +18,29 @@ #define EDMA_CR_ECX BIT(16) #define EDMA_CR_CX BIT(17) -#define EDMA_SEEI_SEEI(x) ((x) & 0x1F) -#define EDMA_CEEI_CEEI(x) ((x) & 0x1F) -#define EDMA_CINT_CINT(x) ((x) & 0x1F) -#define EDMA_CERR_CERR(x) ((x) & 0x1F) - -#define EDMA_TCD_ATTR_DSIZE(x) (((x) & 0x0007)) -#define EDMA_TCD_ATTR_DMOD(x) (((x) & 0x001F) << 3) -#define EDMA_TCD_ATTR_SSIZE(x) (((x) & 0x0007) << 8) -#define EDMA_TCD_ATTR_SMOD(x) (((x) & 0x001F) << 11) -#define EDMA_TCD_ATTR_SSIZE_8BIT (0x0000) -#define EDMA_TCD_ATTR_SSIZE_16BIT (0x0100) -#define EDMA_TCD_ATTR_SSIZE_32BIT (0x0200) -#define EDMA_TCD_ATTR_SSIZE_64BIT (0x0300) -#define EDMA_TCD_ATTR_SSIZE_32BYTE (0x0500) -#define EDMA_TCD_ATTR_DSIZE_8BIT (0x0000) -#define EDMA_TCD_ATTR_DSIZE_16BIT (0x0001) -#define EDMA_TCD_ATTR_DSIZE_32BIT (0x0002) -#define EDMA_TCD_ATTR_DSIZE_64BIT (0x0003) -#define EDMA_TCD_ATTR_DSIZE_32BYTE (0x0005) - -#define EDMA_TCD_SOFF_SOFF(x) (x) -#define EDMA_TCD_NBYTES_NBYTES(x) (x) -#define EDMA_TCD_SLAST_SLAST(x) (x) -#define EDMA_TCD_DADDR_DADDR(x) (x) -#define EDMA_TCD_CITER_CITER(x) ((x) & 0x7FFF) -#define EDMA_TCD_DOFF_DOFF(x) (x) -#define EDMA_TCD_DLAST_SGA_DLAST_SGA(x) (x) -#define EDMA_TCD_BITER_BITER(x) ((x) & 0x7FFF) +#define EDMA_SEEI_SEEI(x) ((x) & GENMASK(4, 0)) +#define EDMA_CEEI_CEEI(x) ((x) & GENMASK(4, 0)) +#define EDMA_CINT_CINT(x) ((x) & GENMASK(4, 0)) +#define EDMA_CERR_CERR(x) ((x) & GENMASK(4, 0)) + +#define EDMA_TCD_ATTR_DSIZE(x) (((x) & GENMASK(2, 0))) +#define EDMA_TCD_ATTR_DMOD(x) (((x) & GENMASK(4, 0)) << 3) +#define EDMA_TCD_ATTR_SSIZE(x) (((x) & GENMASK(2, 0)) << 8) +#define EDMA_TCD_ATTR_SMOD(x) (((x) & GENMASK(4, 0)) << 11) + +#define EDMA_TCD_ATTR_DSIZE_8BIT 0 +#define EDMA_TCD_ATTR_DSIZE_16BIT BIT(0) +#define EDMA_TCD_ATTR_DSIZE_32BIT BIT(1) +#define EDMA_TCD_ATTR_DSIZE_64BIT (BIT(0) | BIT(1)) +#define EDMA_TCD_ATTR_DSIZE_32BYTE (BIT(3) | BIT(0)) +#define EDMA_TCD_ATTR_SSIZE_8BIT 0 +#define EDMA_TCD_ATTR_SSIZE_16BIT (EDMA_TCD_ATTR_DSIZE_16BIT << 8) +#define EDMA_TCD_ATTR_SSIZE_32BIT (EDMA_TCD_ATTR_DSIZE_32BIT << 8) +#define EDMA_TCD_ATTR_SSIZE_64BIT (EDMA_TCD_ATTR_DSIZE_64BIT << 8) +#define EDMA_TCD_ATTR_SSIZE_32BYTE (EDMA_TCD_ATTR_DSIZE_32BYTE << 8) + +#define EDMA_TCD_CITER_CITER(x) ((x) & GENMASK(14, 0)) +#define EDMA_TCD_BITER_BITER(x) ((x) & GENMASK(14, 0)) #define EDMA_TCD_CSR_START BIT(0) #define EDMA_TCD_CSR_INT_MAJOR BIT(1) @@ -87,7 +53,7 @@ #define EDMAMUX_CHCFG_DIS 0x0 #define EDMAMUX_CHCFG_ENBL 0x80 -#define EDMAMUX_CHCFG_SOURCE(n) ((n) & 0x3F) +#define EDMAMUX_CHCFG_SOURCE(n) ((n) & GENMASK(6, 0)) #define DMAMUX_NR 2 @@ -114,6 +80,31 @@ struct fsl_edma_hw_tcd { __le16 biter; }; +/* + * This are iomem pointers, for both v32 and v64. + */ +struct edma_regs { + void __iomem *cr; + void __iomem *es; + void __iomem *erqh; + void __iomem *erql; /* aka erq on v32 */ + void __iomem *eeih; + void __iomem *eeil; /* aka eei on v32 */ + void __iomem *seei; + void __iomem *ceei; + void __iomem *serq; + void __iomem *cerq; + void __iomem *cint; + void __iomem *cerr; + void __iomem *ssrt; + void __iomem *cdne; + void __iomem *inth; + void __iomem *intl; + void __iomem *errh; + void __iomem *errl; + struct fsl_edma_hw_tcd __iomem *tcd; +}; + struct fsl_edma_sw_tcd { dma_addr_t ptcd; struct fsl_edma_hw_tcd *vtcd; @@ -147,6 +138,11 @@ struct fsl_edma_desc { struct fsl_edma_sw_tcd tcd[]; }; +enum edma_version { + v1, /* 32ch, Vybdir, mpc57x, etc */ + v2, /* 64ch Coldfire */ +}; + struct fsl_edma_engine { struct dma_device dma_dev; void __iomem *membase; @@ -157,6 +153,8 @@ struct fsl_edma_engine { int txirq; int errirq; bool big_endian; + enum edma_version version; + struct edma_regs regs; struct fsl_edma_chan chans[]; }; @@ -192,5 +190,6 @@ void fsl_edma_issue_pending(struct dma_chan *chan); int fsl_edma_alloc_chan_resources(struct dma_chan *chan); void fsl_edma_free_chan_resources(struct dma_chan *chan); void fsl_edma_cleanup_vchan(struct dma_device *dmadev); +void fsl_edma_setup_regs(struct fsl_edma_engine *edma); #endif /* _FSL_EDMA_COMMON_H_ */ diff --git a/drivers/dma/fsl-edma.c b/drivers/dma/fsl-edma.c index 337ad0c0ea78..34d70112fcc9 100644 --- a/drivers/dma/fsl-edma.c +++ b/drivers/dma/fsl-edma.c @@ -28,19 +28,16 @@ static irqreturn_t fsl_edma_tx_handler(int irq, void *dev_id) { struct fsl_edma_engine *fsl_edma = dev_id; unsigned int intr, ch; - void __iomem *base_addr; + struct edma_regs *regs = &fsl_edma->regs; struct fsl_edma_chan *fsl_chan; - base_addr = fsl_edma->membase; - - intr = edma_readl(fsl_edma, base_addr + EDMA_INTR); + intr = edma_readl(fsl_edma, regs->intl); if (!intr) return IRQ_NONE; for (ch = 0; ch < fsl_edma->n_chans; ch++) { if (intr & (0x1 << ch)) { - edma_writeb(fsl_edma, EDMA_CINT_CINT(ch), - base_addr + EDMA_CINT); + edma_writeb(fsl_edma, EDMA_CINT_CINT(ch), regs->cint); fsl_chan = &fsl_edma->chans[ch]; @@ -68,16 +65,16 @@ static irqreturn_t fsl_edma_err_handler(int irq, void *dev_id) { struct fsl_edma_engine *fsl_edma = dev_id; unsigned int err, ch; + struct edma_regs *regs = &fsl_edma->regs; - err = edma_readl(fsl_edma, fsl_edma->membase + EDMA_ERR); + err = edma_readl(fsl_edma, regs->errl); if (!err) return IRQ_NONE; for (ch = 0; ch < fsl_edma->n_chans; ch++) { if (err & (0x1 << ch)) { fsl_edma_disable_request(&fsl_edma->chans[ch]); - edma_writeb(fsl_edma, EDMA_CERR_CERR(ch), - fsl_edma->membase + EDMA_CERR); + edma_writeb(fsl_edma, EDMA_CERR_CERR(ch), regs->cerr); fsl_edma->chans[ch].status = DMA_ERROR; fsl_edma->chans[ch].idle = true; } @@ -192,6 +189,7 @@ static int fsl_edma_probe(struct platform_device *pdev) struct device_node *np = pdev->dev.of_node; struct fsl_edma_engine *fsl_edma; struct fsl_edma_chan *fsl_chan; + struct edma_regs *regs; struct resource *res; int len, chans; int ret, i; @@ -207,6 +205,7 @@ static int fsl_edma_probe(struct platform_device *pdev) if (!fsl_edma) return -ENOMEM; + fsl_edma->version = v1; fsl_edma->n_chans = chans; mutex_init(&fsl_edma->fsl_edma_mutex); @@ -215,6 +214,9 @@ static int fsl_edma_probe(struct platform_device *pdev) if (IS_ERR(fsl_edma->membase)) return PTR_ERR(fsl_edma->membase); + fsl_edma_setup_regs(fsl_edma); + regs = &fsl_edma->regs; + for (i = 0; i < DMAMUX_NR; i++) { char clkname[32]; @@ -255,11 +257,11 @@ static int fsl_edma_probe(struct platform_device *pdev) fsl_chan->vchan.desc_free = fsl_edma_free_desc; vchan_init(&fsl_chan->vchan, &fsl_edma->dma_dev); - edma_writew(fsl_edma, 0x0, fsl_edma->membase + EDMA_TCD_CSR(i)); + edma_writew(fsl_edma, 0x0, ®s->tcd[i].csr); fsl_edma_chan_mux(fsl_chan, 0, false); } - edma_writel(fsl_edma, ~0, fsl_edma->membase + EDMA_INTR); + edma_writel(fsl_edma, ~0, regs->intl); ret = fsl_edma_irq_init(pdev, fsl_edma); if (ret) return ret; @@ -306,7 +308,7 @@ static int fsl_edma_probe(struct platform_device *pdev) } /* enable round robin arbitration */ - edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, fsl_edma->membase + EDMA_CR); + edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, regs->cr); return 0; } @@ -353,18 +355,18 @@ static int fsl_edma_resume_early(struct device *dev) { struct fsl_edma_engine *fsl_edma = dev_get_drvdata(dev); struct fsl_edma_chan *fsl_chan; + struct edma_regs *regs = &fsl_edma->regs; int i; for (i = 0; i < fsl_edma->n_chans; i++) { fsl_chan = &fsl_edma->chans[i]; fsl_chan->pm_state = RUNNING; - edma_writew(fsl_edma, 0x0, fsl_edma->membase + EDMA_TCD_CSR(i)); + edma_writew(fsl_edma, 0x0, ®s->tcd[i].csr); if (fsl_chan->slave_id != 0) fsl_edma_chan_mux(fsl_chan, fsl_chan->slave_id, true); } - edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, - fsl_edma->membase + EDMA_CR); + edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, regs->cr); return 0; } -- 2.18.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: angelo@sysam.it (Angelo Dureghello) Date: Fri, 3 Aug 2018 21:32:43 +0200 Subject: [PATCH v8 2/3] dmaengine: fsl-edma: add edma version and configurable registers In-Reply-To: <20180803193244.12084-1-angelo@sysam.it> References: <20180803193244.12084-1-angelo@sysam.it> Message-ID: <20180803193244.12084-2-angelo@sysam.it> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org This patch adds configurable registers (using __iomem addresses) to allow the use of fsl-edma-common code with slightly different edma module versions, as Vybrid (v1) and ColdFire (v2) are. Removal of old membase-referenced registers, amd some fixes on macroes are included. Signed-off-by: Angelo Dureghello --- Changes from v7: - patch rewritten from scratch, this patch (2/3) has just been added. --- drivers/dma/fsl-edma-common.c | 138 ++++++++++++++++++++++++++-------- drivers/dma/fsl-edma-common.h | 115 ++++++++++++++-------------- drivers/dma/fsl-edma.c | 32 ++++---- 3 files changed, 182 insertions(+), 103 deletions(-) diff --git a/drivers/dma/fsl-edma-common.c b/drivers/dma/fsl-edma-common.c index 0ae7094f477a..948a3ee51bbb 100644 --- a/drivers/dma/fsl-edma-common.c +++ b/drivers/dma/fsl-edma-common.c @@ -9,6 +9,38 @@ #include "fsl-edma-common.h" +#define EDMA_CR 0x00 +#define EDMA_ES 0x04 +#define EDMA_ERQ 0x0C +#define EDMA_EEI 0x14 +#define EDMA_SERQ 0x1B +#define EDMA_CERQ 0x1A +#define EDMA_SEEI 0x19 +#define EDMA_CEEI 0x18 +#define EDMA_CINT 0x1F +#define EDMA_CERR 0x1E +#define EDMA_SSRT 0x1D +#define EDMA_CDNE 0x1C +#define EDMA_INTR 0x24 +#define EDMA_ERR 0x2C + +#define EDMA64_ERQH 0x08 +#define EDMA64_EEIH 0x10 +#define EDMA64_SERQ 0x18 +#define EDMA64_CERQ 0x19 +#define EDMA64_SEEI 0x1a +#define EDMA64_CEEI 0x1b +#define EDMA64_CINT 0x1c +#define EDMA64_CERR 0x1d +#define EDMA64_SSRT 0x1e +#define EDMA64_CDNE 0x1f +#define EDMA64_INTH 0x20 +#define EDMA64_INTL 0x24 +#define EDMA64_ERRH 0x28 +#define EDMA64_ERRL 0x2c + +#define EDMA_TCD 0x1000 + /* * R/W functions for big- or little-endian registers: * The eDMA controller's endian is independent of the CPU core's endian. @@ -67,20 +99,20 @@ EXPORT_SYMBOL_GPL(to_fsl_edma_desc); static void fsl_edma_enable_request(struct fsl_edma_chan *fsl_chan) { - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; - edma_writeb(fsl_chan->edma, EDMA_SEEI_SEEI(ch), addr + EDMA_SEEI); - edma_writeb(fsl_chan->edma, ch, addr + EDMA_SERQ); + edma_writeb(fsl_chan->edma, EDMA_SEEI_SEEI(ch), regs->seei); + edma_writeb(fsl_chan->edma, ch, regs->serq); } void fsl_edma_disable_request(struct fsl_edma_chan *fsl_chan) { - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; - edma_writeb(fsl_chan->edma, ch, addr + EDMA_CERQ); - edma_writeb(fsl_chan->edma, EDMA_CEEI_CEEI(ch), addr + EDMA_CEEI); + edma_writeb(fsl_chan->edma, ch, regs->cerq); + edma_writeb(fsl_chan->edma, EDMA_CEEI_CEEI(ch), regs->ceei); } EXPORT_SYMBOL_GPL(fsl_edma_disable_request); @@ -208,7 +240,7 @@ static size_t fsl_edma_desc_residue(struct fsl_edma_chan *fsl_chan, struct virt_dma_desc *vdesc, bool in_progress) { struct fsl_edma_desc *edesc = fsl_chan->edesc; - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; enum dma_transfer_direction dir = fsl_chan->fsc.dir; dma_addr_t cur_addr, dma_addr; @@ -224,11 +256,9 @@ static size_t fsl_edma_desc_residue(struct fsl_edma_chan *fsl_chan, return len; if (dir == DMA_MEM_TO_DEV) - cur_addr = edma_readl( - fsl_chan->edma, addr + EDMA_TCD_SADDR(ch)); + cur_addr = edma_readl(fsl_chan->edma, ®s->tcd[ch].saddr); else - cur_addr = edma_readl( - fsl_chan->edma, addr + EDMA_TCD_DADDR(ch)); + cur_addr = edma_readl(fsl_chan->edma, ®s->tcd[ch].daddr); /* figure out the finished and calculate the residue */ for (i = 0; i < fsl_chan->edesc->n_tcds; i++) { @@ -285,7 +315,7 @@ static void fsl_edma_set_tcd_regs(struct fsl_edma_chan *fsl_chan, struct fsl_edma_hw_tcd *tcd) { struct fsl_edma_engine *edma = fsl_chan->edma; - void __iomem *addr = fsl_chan->edma->membase; + struct edma_regs *regs = &fsl_chan->edma->regs; u32 ch = fsl_chan->vchan.chan.chan_id; /* @@ -293,24 +323,24 @@ static void fsl_edma_set_tcd_regs(struct fsl_edma_chan *fsl_chan, * endian format. However, we need to load the TCD registers in * big- or little-endian obeying the eDMA engine model endian. */ - edma_writew(edma, 0, addr + EDMA_TCD_CSR(ch)); - edma_writel(edma, le32_to_cpu(tcd->saddr), addr + EDMA_TCD_SADDR(ch)); - edma_writel(edma, le32_to_cpu(tcd->daddr), addr + EDMA_TCD_DADDR(ch)); + edma_writew(edma, 0, ®s->tcd[ch].csr); + edma_writel(edma, le32_to_cpu(tcd->saddr), ®s->tcd[ch].saddr); + edma_writel(edma, le32_to_cpu(tcd->daddr), ®s->tcd[ch].daddr); - edma_writew(edma, le16_to_cpu(tcd->attr), addr + EDMA_TCD_ATTR(ch)); - edma_writew(edma, le16_to_cpu(tcd->soff), addr + EDMA_TCD_SOFF(ch)); + edma_writew(edma, le16_to_cpu(tcd->attr), ®s->tcd[ch].attr); + edma_writew(edma, le16_to_cpu(tcd->soff), ®s->tcd[ch].soff); - edma_writel(edma, le32_to_cpu(tcd->nbytes), addr + EDMA_TCD_NBYTES(ch)); - edma_writel(edma, le32_to_cpu(tcd->slast), addr + EDMA_TCD_SLAST(ch)); + edma_writel(edma, le32_to_cpu(tcd->nbytes), ®s->tcd[ch].nbytes); + edma_writel(edma, le32_to_cpu(tcd->slast), ®s->tcd[ch].slast); - edma_writew(edma, le16_to_cpu(tcd->citer), addr + EDMA_TCD_CITER(ch)); - edma_writew(edma, le16_to_cpu(tcd->biter), addr + EDMA_TCD_BITER(ch)); - edma_writew(edma, le16_to_cpu(tcd->doff), addr + EDMA_TCD_DOFF(ch)); + edma_writew(edma, le16_to_cpu(tcd->citer), ®s->tcd[ch].citer); + edma_writew(edma, le16_to_cpu(tcd->biter), ®s->tcd[ch].biter); + edma_writew(edma, le16_to_cpu(tcd->doff), ®s->tcd[ch].doff); - edma_writel(edma, - le32_to_cpu(tcd->dlast_sga), addr + EDMA_TCD_DLAST_SGA(ch)); + edma_writel(edma, le32_to_cpu(tcd->dlast_sga), + ®s->tcd[ch].dlast_sga); - edma_writew(edma, le16_to_cpu(tcd->csr), addr + EDMA_TCD_CSR(ch)); + edma_writew(edma, le16_to_cpu(tcd->csr), ®s->tcd[ch].csr); } static inline @@ -332,15 +362,15 @@ void fsl_edma_fill_tcd(struct fsl_edma_hw_tcd *tcd, u32 src, u32 dst, tcd->attr = cpu_to_le16(attr); - tcd->soff = cpu_to_le16(EDMA_TCD_SOFF_SOFF(soff)); + tcd->soff = cpu_to_le16(soff); - tcd->nbytes = cpu_to_le32(EDMA_TCD_NBYTES_NBYTES(nbytes)); - tcd->slast = cpu_to_le32(EDMA_TCD_SLAST_SLAST(slast)); + tcd->nbytes = cpu_to_le32(nbytes); + tcd->slast = cpu_to_le32(slast); tcd->citer = cpu_to_le16(EDMA_TCD_CITER_CITER(citer)); - tcd->doff = cpu_to_le16(EDMA_TCD_DOFF_DOFF(doff)); + tcd->doff = cpu_to_le16(doff); - tcd->dlast_sga = cpu_to_le32(EDMA_TCD_DLAST_SGA_DLAST_SGA(dlast_sga)); + tcd->dlast_sga = cpu_to_le32(dlast_sga); tcd->biter = cpu_to_le16(EDMA_TCD_BITER_BITER(biter)); if (major_int) @@ -573,4 +603,52 @@ void fsl_edma_cleanup_vchan(struct dma_device *dmadev) } EXPORT_SYMBOL_GPL(fsl_edma_cleanup_vchan); +/* + * On the 32 channels Vybrid/mpc577x edma version (here called "v1"), + * register offsets are different compared to ColdFire mcf5441x 64 channels + * edma (here called "v2"). + * + * This function sets up register offsets as per proper declared version + * so must be called in xxx_edma_probe() just after setting the + * edma "version" and "membase" appropriately. + */ +void fsl_edma_setup_regs(struct fsl_edma_engine *edma) +{ + edma->regs.cr = edma->membase + EDMA_CR; + edma->regs.es = edma->membase + EDMA_ES; + edma->regs.erql = edma->membase + EDMA_ERQ; + edma->regs.eeil = edma->membase + EDMA_EEI; + + edma->regs.serq = edma->membase + ((edma->version == v1) ? + EDMA_SERQ : EDMA64_SERQ); + edma->regs.cerq = edma->membase + ((edma->version == v1) ? + EDMA_CERQ : EDMA64_CERQ); + edma->regs.seei = edma->membase + ((edma->version == v1) ? + EDMA_SEEI : EDMA64_SEEI); + edma->regs.ceei = edma->membase + ((edma->version == v1) ? + EDMA_CEEI : EDMA64_CEEI); + edma->regs.cint = edma->membase + ((edma->version == v1) ? + EDMA_CINT : EDMA64_CINT); + edma->regs.cerr = edma->membase + ((edma->version == v1) ? + EDMA_CERR : EDMA64_CERR); + edma->regs.ssrt = edma->membase + ((edma->version == v1) ? + EDMA_SSRT : EDMA64_SSRT); + edma->regs.cdne = edma->membase + ((edma->version == v1) ? + EDMA_CDNE : EDMA64_CDNE); + edma->regs.intl = edma->membase + ((edma->version == v1) ? + EDMA_INTR : EDMA64_INTL); + edma->regs.errl = edma->membase + ((edma->version == v1) ? + EDMA_ERR : EDMA64_ERRL); + + if (edma->version == v2) { + edma->regs.erqh = edma->membase + EDMA64_ERQH; + edma->regs.eeih = edma->membase + EDMA64_EEIH; + edma->regs.errh = edma->membase + EDMA64_ERRH; + edma->regs.inth = edma->membase + EDMA64_INTH; + } + + edma->regs.tcd = edma->membase + EDMA_TCD; +} +EXPORT_SYMBOL_GPL(fsl_edma_setup_regs); + MODULE_LICENSE("GPL v2"); diff --git a/drivers/dma/fsl-edma-common.h b/drivers/dma/fsl-edma-common.h index f3ea68e15b23..7a9231e7639f 100644 --- a/drivers/dma/fsl-edma-common.h +++ b/drivers/dma/fsl-edma-common.h @@ -8,35 +8,6 @@ #include "virt-dma.h" -#define EDMA_CR 0x00 -#define EDMA_ES 0x04 -#define EDMA_ERQ 0x0C -#define EDMA_EEI 0x14 -#define EDMA_SERQ 0x1B -#define EDMA_CERQ 0x1A -#define EDMA_SEEI 0x19 -#define EDMA_CEEI 0x18 -#define EDMA_CINT 0x1F -#define EDMA_CERR 0x1E -#define EDMA_SSRT 0x1D -#define EDMA_CDNE 0x1C -#define EDMA_INTR 0x24 -#define EDMA_ERR 0x2C - -#define EDMA_TCD_SADDR(x) (0x1000 + 32 * (x)) -#define EDMA_TCD_SOFF(x) (0x1004 + 32 * (x)) -#define EDMA_TCD_ATTR(x) (0x1006 + 32 * (x)) -#define EDMA_TCD_NBYTES(x) (0x1008 + 32 * (x)) -#define EDMA_TCD_SLAST(x) (0x100C + 32 * (x)) -#define EDMA_TCD_DADDR(x) (0x1010 + 32 * (x)) -#define EDMA_TCD_DOFF(x) (0x1014 + 32 * (x)) -#define EDMA_TCD_CITER_ELINK(x) (0x1016 + 32 * (x)) -#define EDMA_TCD_CITER(x) (0x1016 + 32 * (x)) -#define EDMA_TCD_DLAST_SGA(x) (0x1018 + 32 * (x)) -#define EDMA_TCD_CSR(x) (0x101C + 32 * (x)) -#define EDMA_TCD_BITER_ELINK(x) (0x101E + 32 * (x)) -#define EDMA_TCD_BITER(x) (0x101E + 32 * (x)) - #define EDMA_CR_EDBG BIT(1) #define EDMA_CR_ERCA BIT(2) #define EDMA_CR_ERGA BIT(3) @@ -47,34 +18,29 @@ #define EDMA_CR_ECX BIT(16) #define EDMA_CR_CX BIT(17) -#define EDMA_SEEI_SEEI(x) ((x) & 0x1F) -#define EDMA_CEEI_CEEI(x) ((x) & 0x1F) -#define EDMA_CINT_CINT(x) ((x) & 0x1F) -#define EDMA_CERR_CERR(x) ((x) & 0x1F) - -#define EDMA_TCD_ATTR_DSIZE(x) (((x) & 0x0007)) -#define EDMA_TCD_ATTR_DMOD(x) (((x) & 0x001F) << 3) -#define EDMA_TCD_ATTR_SSIZE(x) (((x) & 0x0007) << 8) -#define EDMA_TCD_ATTR_SMOD(x) (((x) & 0x001F) << 11) -#define EDMA_TCD_ATTR_SSIZE_8BIT (0x0000) -#define EDMA_TCD_ATTR_SSIZE_16BIT (0x0100) -#define EDMA_TCD_ATTR_SSIZE_32BIT (0x0200) -#define EDMA_TCD_ATTR_SSIZE_64BIT (0x0300) -#define EDMA_TCD_ATTR_SSIZE_32BYTE (0x0500) -#define EDMA_TCD_ATTR_DSIZE_8BIT (0x0000) -#define EDMA_TCD_ATTR_DSIZE_16BIT (0x0001) -#define EDMA_TCD_ATTR_DSIZE_32BIT (0x0002) -#define EDMA_TCD_ATTR_DSIZE_64BIT (0x0003) -#define EDMA_TCD_ATTR_DSIZE_32BYTE (0x0005) - -#define EDMA_TCD_SOFF_SOFF(x) (x) -#define EDMA_TCD_NBYTES_NBYTES(x) (x) -#define EDMA_TCD_SLAST_SLAST(x) (x) -#define EDMA_TCD_DADDR_DADDR(x) (x) -#define EDMA_TCD_CITER_CITER(x) ((x) & 0x7FFF) -#define EDMA_TCD_DOFF_DOFF(x) (x) -#define EDMA_TCD_DLAST_SGA_DLAST_SGA(x) (x) -#define EDMA_TCD_BITER_BITER(x) ((x) & 0x7FFF) +#define EDMA_SEEI_SEEI(x) ((x) & GENMASK(4, 0)) +#define EDMA_CEEI_CEEI(x) ((x) & GENMASK(4, 0)) +#define EDMA_CINT_CINT(x) ((x) & GENMASK(4, 0)) +#define EDMA_CERR_CERR(x) ((x) & GENMASK(4, 0)) + +#define EDMA_TCD_ATTR_DSIZE(x) (((x) & GENMASK(2, 0))) +#define EDMA_TCD_ATTR_DMOD(x) (((x) & GENMASK(4, 0)) << 3) +#define EDMA_TCD_ATTR_SSIZE(x) (((x) & GENMASK(2, 0)) << 8) +#define EDMA_TCD_ATTR_SMOD(x) (((x) & GENMASK(4, 0)) << 11) + +#define EDMA_TCD_ATTR_DSIZE_8BIT 0 +#define EDMA_TCD_ATTR_DSIZE_16BIT BIT(0) +#define EDMA_TCD_ATTR_DSIZE_32BIT BIT(1) +#define EDMA_TCD_ATTR_DSIZE_64BIT (BIT(0) | BIT(1)) +#define EDMA_TCD_ATTR_DSIZE_32BYTE (BIT(3) | BIT(0)) +#define EDMA_TCD_ATTR_SSIZE_8BIT 0 +#define EDMA_TCD_ATTR_SSIZE_16BIT (EDMA_TCD_ATTR_DSIZE_16BIT << 8) +#define EDMA_TCD_ATTR_SSIZE_32BIT (EDMA_TCD_ATTR_DSIZE_32BIT << 8) +#define EDMA_TCD_ATTR_SSIZE_64BIT (EDMA_TCD_ATTR_DSIZE_64BIT << 8) +#define EDMA_TCD_ATTR_SSIZE_32BYTE (EDMA_TCD_ATTR_DSIZE_32BYTE << 8) + +#define EDMA_TCD_CITER_CITER(x) ((x) & GENMASK(14, 0)) +#define EDMA_TCD_BITER_BITER(x) ((x) & GENMASK(14, 0)) #define EDMA_TCD_CSR_START BIT(0) #define EDMA_TCD_CSR_INT_MAJOR BIT(1) @@ -87,7 +53,7 @@ #define EDMAMUX_CHCFG_DIS 0x0 #define EDMAMUX_CHCFG_ENBL 0x80 -#define EDMAMUX_CHCFG_SOURCE(n) ((n) & 0x3F) +#define EDMAMUX_CHCFG_SOURCE(n) ((n) & GENMASK(6, 0)) #define DMAMUX_NR 2 @@ -114,6 +80,31 @@ struct fsl_edma_hw_tcd { __le16 biter; }; +/* + * This are iomem pointers, for both v32 and v64. + */ +struct edma_regs { + void __iomem *cr; + void __iomem *es; + void __iomem *erqh; + void __iomem *erql; /* aka erq on v32 */ + void __iomem *eeih; + void __iomem *eeil; /* aka eei on v32 */ + void __iomem *seei; + void __iomem *ceei; + void __iomem *serq; + void __iomem *cerq; + void __iomem *cint; + void __iomem *cerr; + void __iomem *ssrt; + void __iomem *cdne; + void __iomem *inth; + void __iomem *intl; + void __iomem *errh; + void __iomem *errl; + struct fsl_edma_hw_tcd __iomem *tcd; +}; + struct fsl_edma_sw_tcd { dma_addr_t ptcd; struct fsl_edma_hw_tcd *vtcd; @@ -147,6 +138,11 @@ struct fsl_edma_desc { struct fsl_edma_sw_tcd tcd[]; }; +enum edma_version { + v1, /* 32ch, Vybdir, mpc57x, etc */ + v2, /* 64ch Coldfire */ +}; + struct fsl_edma_engine { struct dma_device dma_dev; void __iomem *membase; @@ -157,6 +153,8 @@ struct fsl_edma_engine { int txirq; int errirq; bool big_endian; + enum edma_version version; + struct edma_regs regs; struct fsl_edma_chan chans[]; }; @@ -192,5 +190,6 @@ void fsl_edma_issue_pending(struct dma_chan *chan); int fsl_edma_alloc_chan_resources(struct dma_chan *chan); void fsl_edma_free_chan_resources(struct dma_chan *chan); void fsl_edma_cleanup_vchan(struct dma_device *dmadev); +void fsl_edma_setup_regs(struct fsl_edma_engine *edma); #endif /* _FSL_EDMA_COMMON_H_ */ diff --git a/drivers/dma/fsl-edma.c b/drivers/dma/fsl-edma.c index 337ad0c0ea78..34d70112fcc9 100644 --- a/drivers/dma/fsl-edma.c +++ b/drivers/dma/fsl-edma.c @@ -28,19 +28,16 @@ static irqreturn_t fsl_edma_tx_handler(int irq, void *dev_id) { struct fsl_edma_engine *fsl_edma = dev_id; unsigned int intr, ch; - void __iomem *base_addr; + struct edma_regs *regs = &fsl_edma->regs; struct fsl_edma_chan *fsl_chan; - base_addr = fsl_edma->membase; - - intr = edma_readl(fsl_edma, base_addr + EDMA_INTR); + intr = edma_readl(fsl_edma, regs->intl); if (!intr) return IRQ_NONE; for (ch = 0; ch < fsl_edma->n_chans; ch++) { if (intr & (0x1 << ch)) { - edma_writeb(fsl_edma, EDMA_CINT_CINT(ch), - base_addr + EDMA_CINT); + edma_writeb(fsl_edma, EDMA_CINT_CINT(ch), regs->cint); fsl_chan = &fsl_edma->chans[ch]; @@ -68,16 +65,16 @@ static irqreturn_t fsl_edma_err_handler(int irq, void *dev_id) { struct fsl_edma_engine *fsl_edma = dev_id; unsigned int err, ch; + struct edma_regs *regs = &fsl_edma->regs; - err = edma_readl(fsl_edma, fsl_edma->membase + EDMA_ERR); + err = edma_readl(fsl_edma, regs->errl); if (!err) return IRQ_NONE; for (ch = 0; ch < fsl_edma->n_chans; ch++) { if (err & (0x1 << ch)) { fsl_edma_disable_request(&fsl_edma->chans[ch]); - edma_writeb(fsl_edma, EDMA_CERR_CERR(ch), - fsl_edma->membase + EDMA_CERR); + edma_writeb(fsl_edma, EDMA_CERR_CERR(ch), regs->cerr); fsl_edma->chans[ch].status = DMA_ERROR; fsl_edma->chans[ch].idle = true; } @@ -192,6 +189,7 @@ static int fsl_edma_probe(struct platform_device *pdev) struct device_node *np = pdev->dev.of_node; struct fsl_edma_engine *fsl_edma; struct fsl_edma_chan *fsl_chan; + struct edma_regs *regs; struct resource *res; int len, chans; int ret, i; @@ -207,6 +205,7 @@ static int fsl_edma_probe(struct platform_device *pdev) if (!fsl_edma) return -ENOMEM; + fsl_edma->version = v1; fsl_edma->n_chans = chans; mutex_init(&fsl_edma->fsl_edma_mutex); @@ -215,6 +214,9 @@ static int fsl_edma_probe(struct platform_device *pdev) if (IS_ERR(fsl_edma->membase)) return PTR_ERR(fsl_edma->membase); + fsl_edma_setup_regs(fsl_edma); + regs = &fsl_edma->regs; + for (i = 0; i < DMAMUX_NR; i++) { char clkname[32]; @@ -255,11 +257,11 @@ static int fsl_edma_probe(struct platform_device *pdev) fsl_chan->vchan.desc_free = fsl_edma_free_desc; vchan_init(&fsl_chan->vchan, &fsl_edma->dma_dev); - edma_writew(fsl_edma, 0x0, fsl_edma->membase + EDMA_TCD_CSR(i)); + edma_writew(fsl_edma, 0x0, ®s->tcd[i].csr); fsl_edma_chan_mux(fsl_chan, 0, false); } - edma_writel(fsl_edma, ~0, fsl_edma->membase + EDMA_INTR); + edma_writel(fsl_edma, ~0, regs->intl); ret = fsl_edma_irq_init(pdev, fsl_edma); if (ret) return ret; @@ -306,7 +308,7 @@ static int fsl_edma_probe(struct platform_device *pdev) } /* enable round robin arbitration */ - edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, fsl_edma->membase + EDMA_CR); + edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, regs->cr); return 0; } @@ -353,18 +355,18 @@ static int fsl_edma_resume_early(struct device *dev) { struct fsl_edma_engine *fsl_edma = dev_get_drvdata(dev); struct fsl_edma_chan *fsl_chan; + struct edma_regs *regs = &fsl_edma->regs; int i; for (i = 0; i < fsl_edma->n_chans; i++) { fsl_chan = &fsl_edma->chans[i]; fsl_chan->pm_state = RUNNING; - edma_writew(fsl_edma, 0x0, fsl_edma->membase + EDMA_TCD_CSR(i)); + edma_writew(fsl_edma, 0x0, ®s->tcd[i].csr); if (fsl_chan->slave_id != 0) fsl_edma_chan_mux(fsl_chan, fsl_chan->slave_id, true); } - edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, - fsl_edma->membase + EDMA_CR); + edma_writel(fsl_edma, EDMA_CR_ERGA | EDMA_CR_ERCA, regs->cr); return 0; } -- 2.18.0