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: [v3] dmaengine: pl330: flush before wait, and add dev burst support. From: Frank Mori Hess Message-Id: <23394379.8nZhno5foU@bear> Date: Tue, 06 Mar 2018 11:03:22 -0500 To: dmaengine@vger.kernel.org Cc: Vinod Koul , Dan Williams , linux-kernel@vger.kernel.org List-ID: RG8gRE1BRkxVU0hQIF9iZWZvcmVfIHRoZSBmaXJzdCBETUFXRlAgdG8gZW5zdXJlIGNvbnRyb2xs ZXIKYW5kIHBlcmlwaGVyYWwgYXJlIGluIGFncmVlbWVudCBhYm91dCBkbWEgcmVxdWVzdCBzdGF0 ZSBiZWZvcmUgZmlyc3QKdHJhbnNmZXIuICBBZGQgc3VwcG9ydCBmb3IgYnVyc3QgdHJhbnNmZXJz IHRvL2Zyb20gcGVyaXBoZXJhbHMuIEluIHRoZSBuZXcKc2NoZW1lLCB0aGUgY29udHJvbGxlciBk b2VzIGFzIG1hbnkgYnVyc3QgdHJhbnNmZXJzIGFzIGl0IGNhbiB0aGVuCnRyYW5zZmVycyB0aGUg cmVtYWluaW5nIGRyZWdzIHdpdGggZWl0aGVyIHNpbmdsZSB0cmFuc2ZlcnMgZm9yCnBlcmlwaGVy YWxzLCBvciB3aXRoIGEgcmVkdWNlZCBzaXplIGJ1cnN0IGZvciBtZW1vcnktdG8tbWVtb3J5IHRy YW5zZmVycy4KClNpZ25lZC1vZmYtYnk6IEZyYW5rIE1vcmkgSGVzcyA8Zm1oNmpqQGdtYWlsLmNv bT4KVGVzdGVkLWJ5OiBGcmFuayBNb3JpIEhlc3MgPGZtaDZqakBnbWFpbC5jb20+CgpJIHRlc3Rl ZCBkbWEgdHJhbnNmZXJzIHRvIHBlcmlwaGVyYWxzIHdpdGggZGVzaWdud2FyZSBzZXJpYWwgcG9y dAooZHJpdmVycy90dHkvc2VyaWFsLzgyNTAvODI1MF9kdy5jKSBhbmQgYSBHUElCIGludGVyZmFj ZQooaHR0cHM6Ly9naXRodWIuY29tL2ZtaGVzcy9mbWhfZ3BpYl9jb3JlKS4gIEkgdGVzdGVkIG1l bW9yeS10by1tZW1vcnkKdHJhbnNmZXJzIHVzaW5nIHRoZSBkbWF0ZXN0IG1vZHVsZS4KCnYzIG9m IHRoaXMgcGF0Y2ggc2hvdWxkIGJlIHRoZSBzYW1lIGFzIHYyIGV4Y2VwdCB3aXRoIGNoZWNrcGF0 Y2gucGwKd2FybmluZ3MgYW5kIGVycm9ycyBjbGVhbmVkIHVwLgotLS0KIGRyaXZlcnMvZG1hL3Bs MzMwLmMgfCAxNDYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0t LS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDEwNCBpbnNlcnRpb25zKCspLCA0MiBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9wbDMzMC5jIGIvZHJpdmVycy9kbWEvcGwzMzAu YwppbmRleCBkNzMyN2ZkNWY0NDUuLmNjMmU0NDU2YmVjMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9k bWEvcGwzMzAuYworKysgYi9kcml2ZXJzL2RtYS9wbDMzMC5jCkBAIC0xMDk0LDI2ICsxMDk0LDMz IEBAIHN0YXRpYyBpbmxpbmUgaW50IF9sZHN0X21lbXRvbWVtKHVuc2lnbmVkIGRyeV9ydW4sIHU4 IGJ1ZltdLAogCXJldHVybiBvZmY7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IF9sZHN0X2RldnRv bWVtKHN0cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwgdW5zaWduZWQgZHJ5X3J1biwKLQkJCQkgdTgg YnVmW10sIGNvbnN0IHN0cnVjdCBfeGZlcl9zcGVjICpweHMsCi0JCQkJIGludCBjeWMpCitzdGF0 aWMgaW5saW5lIGludCBfbGRzdF9kZXZ0b21lbShzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsCisJ CQkJdW5zaWduZWQgaW50IGRyeV9ydW4sIHU4IGJ1ZltdLAorCQkJCWNvbnN0IHN0cnVjdCBfeGZl cl9zcGVjICpweHMsCisJCQkJaW50IGN5YywgZW51bSBwbDMzMF9jb25kIGNvbmQpCiB7CiAJaW50 IG9mZiA9IDA7Ci0JZW51bSBwbDMzMF9jb25kIGNvbmQ7CiAKIAlpZiAocGwzMzAtPnF1aXJrcyAm IFBMMzMwX1FVSVJLX0JST0tFTl9OT19GTFVTSFApCiAJCWNvbmQgPSBCVVJTVDsKLQllbHNlCi0J CWNvbmQgPSBTSU5HTEU7CiAKKwkvKiBkbyBGTFVTSFAgYXQgYmVnaW5uaW5nIHRvIGNsZWFyIGFu eSBzdGFsZSBkbWEgcmVxdWVzdHMgYmVmb3JlIHRoZQorCSAqIGZpcnN0IFdGUC4KKwkgKi8KKwlp ZiAoIShwbDMzMC0+cXVpcmtzICYgUEwzMzBfUVVJUktfQlJPS0VOX05PX0ZMVVNIUCkpCisJCW9m ZiArPSBfZW1pdF9GTFVTSFAoZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMtPmRlc2MtPnBlcmkpOwog CXdoaWxlIChjeWMtLSkgewogCQlvZmYgKz0gX2VtaXRfV0ZQKGRyeV9ydW4sICZidWZbb2ZmXSwg Y29uZCwgcHhzLT5kZXNjLT5wZXJpKTsKLQkJb2ZmICs9IF9lbWl0X0xEUChkcnlfcnVuLCAmYnVm W29mZl0sIGNvbmQsIHB4cy0+ZGVzYy0+cGVyaSk7CisJCWlmIChjb25kID09IEFMV0FZUykgewor CQkJb2ZmICs9IF9lbWl0X0xEUChkcnlfcnVuLCAmYnVmW29mZl0sIFNJTkdMRSwKKwkJCQlweHMt PmRlc2MtPnBlcmkpOworCQkJb2ZmICs9IF9lbWl0X0xEUChkcnlfcnVuLCAmYnVmW29mZl0sIEJV UlNULAorCQkJCXB4cy0+ZGVzYy0+cGVyaSk7CisJCX0gZWxzZSB7CisJCQlvZmYgKz0gX2VtaXRf TERQKGRyeV9ydW4sICZidWZbb2ZmXSwgY29uZCwKKwkJCQlweHMtPmRlc2MtPnBlcmkpOworCQl9 CiAJCW9mZiArPSBfZW1pdF9TVChkcnlfcnVuLCAmYnVmW29mZl0sIEFMV0FZUyk7Ci0KLQkJaWYg KCEocGwzMzAtPnF1aXJrcyAmIFBMMzMwX1FVSVJLX0JST0tFTl9OT19GTFVTSFApKQotCQkJb2Zm ICs9IF9lbWl0X0ZMVVNIUChkcnlfcnVuLCAmYnVmW29mZl0sCi0JCQkJCSAgICBweHMtPmRlc2Mt PnBlcmkpOwogCX0KIAogCXJldHVybiBvZmY7CkBAIC0xMTIxLDI0ICsxMTI4LDMxIEBAIHN0YXRp YyBpbmxpbmUgaW50IF9sZHN0X2RldnRvbWVtKHN0cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwgdW5z aWduZWQgZHJ5X3J1biwKIAogc3RhdGljIGlubGluZSBpbnQgX2xkc3RfbWVtdG9kZXYoc3RydWN0 IHBsMzMwX2RtYWMgKnBsMzMwLAogCQkJCSB1bnNpZ25lZCBkcnlfcnVuLCB1OCBidWZbXSwKLQkJ CQkgY29uc3Qgc3RydWN0IF94ZmVyX3NwZWMgKnB4cywgaW50IGN5YykKKwkJCQkgY29uc3Qgc3Ry dWN0IF94ZmVyX3NwZWMgKnB4cywgaW50IGN5YywKKwkJCQkgZW51bSBwbDMzMF9jb25kIGNvbmQp CiB7CiAJaW50IG9mZiA9IDA7Ci0JZW51bSBwbDMzMF9jb25kIGNvbmQ7CiAKIAlpZiAocGwzMzAt PnF1aXJrcyAmIFBMMzMwX1FVSVJLX0JST0tFTl9OT19GTFVTSFApCiAJCWNvbmQgPSBCVVJTVDsK LQllbHNlCi0JCWNvbmQgPSBTSU5HTEU7CiAKKwkvKiBkbyBGTFVTSFAgYXQgYmVnaW5uaW5nIHRv IGNsZWFyIGFueSBzdGFsZSBkbWEgcmVxdWVzdHMgYmVmb3JlIHRoZQorCSAqIGZpcnN0IFdGUC4K KwkgKi8KKwlpZiAoIShwbDMzMC0+cXVpcmtzICYgUEwzMzBfUVVJUktfQlJPS0VOX05PX0ZMVVNI UCkpCisJCW9mZiArPSBfZW1pdF9GTFVTSFAoZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMtPmRlc2Mt PnBlcmkpOwogCXdoaWxlIChjeWMtLSkgewogCQlvZmYgKz0gX2VtaXRfV0ZQKGRyeV9ydW4sICZi dWZbb2ZmXSwgY29uZCwgcHhzLT5kZXNjLT5wZXJpKTsKIAkJb2ZmICs9IF9lbWl0X0xEKGRyeV9y dW4sICZidWZbb2ZmXSwgQUxXQVlTKTsKLQkJb2ZmICs9IF9lbWl0X1NUUChkcnlfcnVuLCAmYnVm W29mZl0sIGNvbmQsIHB4cy0+ZGVzYy0+cGVyaSk7Ci0KLQkJaWYgKCEocGwzMzAtPnF1aXJrcyAm IFBMMzMwX1FVSVJLX0JST0tFTl9OT19GTFVTSFApKQotCQkJb2ZmICs9IF9lbWl0X0ZMVVNIUChk cnlfcnVuLCAmYnVmW29mZl0sCi0JCQkJCSAgICBweHMtPmRlc2MtPnBlcmkpOworCQlpZiAoY29u ZCA9PSBBTFdBWVMpIHsKKwkJCW9mZiArPSBfZW1pdF9TVFAoZHJ5X3J1biwgJmJ1ZltvZmZdLCBT SU5HTEUsCisJCQkJcHhzLT5kZXNjLT5wZXJpKTsKKwkJCW9mZiArPSBfZW1pdF9TVFAoZHJ5X3J1 biwgJmJ1ZltvZmZdLCBCVVJTVCwKKwkJCQlweHMtPmRlc2MtPnBlcmkpOworCQl9IGVsc2Ugewor CQkJb2ZmICs9IF9lbWl0X1NUUChkcnlfcnVuLCAmYnVmW29mZl0sIGNvbmQsCisJCQkJcHhzLT5k ZXNjLT5wZXJpKTsKKwkJfQogCX0KIAogCXJldHVybiBvZmY7CkBAIC0xMTQ4LDEzICsxMTYyLDE2 IEBAIHN0YXRpYyBpbnQgX2J1cnN0cyhzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsIHVuc2lnbmVk IGRyeV9ydW4sIHU4IGJ1ZltdLAogCQljb25zdCBzdHJ1Y3QgX3hmZXJfc3BlYyAqcHhzLCBpbnQg Y3ljKQogewogCWludCBvZmYgPSAwOworCWVudW0gcGwzMzBfY29uZCBjb25kID0gQlJTVF9MRU4o cHhzLT5jY3IpID4gMSA/IEJVUlNUIDogU0lOR0xFOwogCiAJc3dpdGNoIChweHMtPmRlc2MtPnJx dHlwZSkgewogCWNhc2UgRE1BX01FTV9UT19ERVY6Ci0JCW9mZiArPSBfbGRzdF9tZW10b2Rldihw bDMzMCwgZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMsIGN5Yyk7CisJCW9mZiArPSBfbGRzdF9tZW10 b2RldihwbDMzMCwgZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMsIGN5YywKKwkJCWNvbmQpOwogCQli cmVhazsKIAljYXNlIERNQV9ERVZfVE9fTUVNOgotCQlvZmYgKz0gX2xkc3RfZGV2dG9tZW0ocGwz MzAsIGRyeV9ydW4sICZidWZbb2ZmXSwgcHhzLCBjeWMpOworCQlvZmYgKz0gX2xkc3RfZGV2dG9t ZW0ocGwzMzAsIGRyeV9ydW4sICZidWZbb2ZmXSwgcHhzLCBjeWMsCisJCQljb25kKTsKIAkJYnJl YWs7CiAJY2FzZSBETUFfTUVNX1RPX01FTToKIAkJb2ZmICs9IF9sZHN0X21lbXRvbWVtKGRyeV9y dW4sICZidWZbb2ZmXSwgcHhzLCBjeWMpOwpAQCAtMTE2Nyw2ICsxMTg0LDQ2IEBAIHN0YXRpYyBp bnQgX2J1cnN0cyhzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsIHVuc2lnbmVkIGRyeV9ydW4sIHU4 IGJ1ZltdLAogCXJldHVybiBvZmY7CiB9CiAKKy8qIHRyYW5zZmVyIGRyZWdzIHdpdGggc2luZ2xl IHRyYW5zZmVycyB0byBwZXJpcGhlcmFsLCBvciBhIHJlZHVjZWQgc2l6ZSBidXJzdAorICogZm9y IG1lbS10by1tZW0uCisgKi8KK3N0YXRpYyBpbnQgX2RyZWdzKHN0cnVjdCBwbDMzMF9kbWFjICpw bDMzMCwgdW5zaWduZWQgaW50IGRyeV9ydW4sIHU4IGJ1ZltdLAorCQljb25zdCBzdHJ1Y3QgX3hm ZXJfc3BlYyAqcHhzLCBpbnQgdHJhbnNmZXJfbGVuZ3RoKQoreworCWludCBvZmYgPSAwOworCWlu dCBkcmVnc19jY3I7CisKKwlpZiAodHJhbnNmZXJfbGVuZ3RoID09IDApCisJCXJldHVybiBvZmY7 CisKKwlzd2l0Y2ggKHB4cy0+ZGVzYy0+cnF0eXBlKSB7CisJY2FzZSBETUFfTUVNX1RPX0RFVjoK KwkJb2ZmICs9IF9sZHN0X21lbXRvZGV2KHBsMzMwLCBkcnlfcnVuLCAmYnVmW29mZl0sIHB4cywK KwkJCXRyYW5zZmVyX2xlbmd0aCwgU0lOR0xFKTsKKwkJYnJlYWs7CisJY2FzZSBETUFfREVWX1RP X01FTToKKwkJb2ZmICs9IF9sZHN0X2RldnRvbWVtKHBsMzMwLCBkcnlfcnVuLCAmYnVmW29mZl0s IHB4cywKKwkJCXRyYW5zZmVyX2xlbmd0aCwgU0lOR0xFKTsKKwkJYnJlYWs7CisJY2FzZSBETUFf TUVNX1RPX01FTToKKwkJZHJlZ3NfY2NyID0gcHhzLT5jY3I7CisJCWRyZWdzX2NjciAmPSB+KCgw eGYgPDwgQ0NfU1JDQlJTVExFTl9TSEZUKSB8CisJCQkoMHhmIDw8IENDX0RTVEJSU1RMRU5fU0hG VCkpOworCQlkcmVnc19jY3IgfD0gKCgodHJhbnNmZXJfbGVuZ3RoIC0gMSkgJiAweGYpIDw8CisJ CQlDQ19TUkNCUlNUTEVOX1NIRlQpOworCQlkcmVnc19jY3IgfD0gKCgodHJhbnNmZXJfbGVuZ3Ro IC0gMSkgJiAweGYpIDw8CisJCQlDQ19EU1RCUlNUTEVOX1NIRlQpOworCQlvZmYgKz0gX2VtaXRf TU9WKGRyeV9ydW4sICZidWZbb2ZmXSwgQ0NSLCBkcmVnc19jY3IpOworCQlvZmYgKz0gX2xkc3Rf bWVtdG9tZW0oZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMsIDEpOworCQlicmVhazsKKwlkZWZhdWx0 OgorCQlvZmYgKz0gMHg0MDAwMDAwMDsgLyogU2NhcmUgb2ZmIHRoZSBDbGllbnQgKi8KKwkJYnJl YWs7CisJfQorCisJcmV0dXJuIG9mZjsKK30KKwogLyogUmV0dXJucyBieXRlcyBjb25zdW1lZCBh bmQgdXBkYXRlcyBidXJzdHMgKi8KIHN0YXRpYyBpbmxpbmUgaW50IF9sb29wKHN0cnVjdCBwbDMz MF9kbWFjICpwbDMzMCwgdW5zaWduZWQgZHJ5X3J1biwgdTggYnVmW10sCiAJCXVuc2lnbmVkIGxv bmcgKmJ1cnN0cywgY29uc3Qgc3RydWN0IF94ZmVyX3NwZWMgKnB4cykKQEAgLTEyNTYsNiArMTMx Myw4IEBAIHN0YXRpYyBpbmxpbmUgaW50IF9zZXR1cF9sb29wcyhzdHJ1Y3QgcGwzMzBfZG1hYyAq cGwzMzAsCiAJc3RydWN0IHBsMzMwX3hmZXIgKnggPSAmcHhzLT5kZXNjLT5weDsKIAl1MzIgY2Ny ID0gcHhzLT5jY3I7CiAJdW5zaWduZWQgbG9uZyBjLCBidXJzdHMgPSBCWVRFX1RPX0JVUlNUKHgt PmJ5dGVzLCBjY3IpOworCWludCBudW1fZHJlZ3MgPSAoeC0+Ynl0ZXMgLSBCVVJTVF9UT19CWVRF KGJ1cnN0cywgY2NyKSkgLworCQlCUlNUX1NJWkUoY2NyKTsKIAlpbnQgb2ZmID0gMDsKIAogCXdo aWxlIChidXJzdHMpIHsKQEAgLTEyNjMsNiArMTMyMiw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IF9z ZXR1cF9sb29wcyhzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsCiAJCW9mZiArPSBfbG9vcChwbDMz MCwgZHJ5X3J1biwgJmJ1ZltvZmZdLCAmYywgcHhzKTsKIAkJYnVyc3RzIC09IGM7CiAJfQorCW9m ZiArPSBfZHJlZ3MocGwzMzAsIGRyeV9ydW4sICZidWZbb2ZmXSwgcHhzLCBudW1fZHJlZ3MpOwog CiAJcmV0dXJuIG9mZjsKIH0KQEAgLTEyOTQsNyArMTM1NCw2IEBAIHN0YXRpYyBpbnQgX3NldHVw X3JlcShzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsIHVuc2lnbmVkIGRyeV9ydW4sCiAJCSAgICAg IHN0cnVjdCBfeGZlcl9zcGVjICpweHMpCiB7CiAJc3RydWN0IF9wbDMzMF9yZXEgKnJlcSA9ICZ0 aHJkLT5yZXFbaW5kZXhdOwotCXN0cnVjdCBwbDMzMF94ZmVyICp4OwogCXU4ICpidWYgPSByZXEt Pm1jX2NwdTsKIAlpbnQgb2ZmID0gMDsKIApAQCAtMTMwMywxMSArMTM2Miw2IEBAIHN0YXRpYyBp bnQgX3NldHVwX3JlcShzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsIHVuc2lnbmVkIGRyeV9ydW4s CiAJLyogRE1BTU9WIENDUiwgY2NyICovCiAJb2ZmICs9IF9lbWl0X01PVihkcnlfcnVuLCAmYnVm W29mZl0sIENDUiwgcHhzLT5jY3IpOwogCi0JeCA9ICZweHMtPmRlc2MtPnB4OwotCS8qIEVycm9y IGlmIHhmZXIgbGVuZ3RoIGlzIG5vdCBhbGlnbmVkIGF0IGJ1cnN0IHNpemUgKi8KLQlpZiAoeC0+ Ynl0ZXMgJSAoQlJTVF9TSVpFKHB4cy0+Y2NyKSAqIEJSU1RfTEVOKHB4cy0+Y2NyKSkpCi0JCXJl dHVybiAtRUlOVkFMOwotCiAJb2ZmICs9IF9zZXR1cF94ZmVyKHBsMzMwLCBkcnlfcnVuLCAmYnVm W29mZl0sIHB4cyk7CiAKIAkvKiBETUFTRVYgcGVyaXBoZXJhbC9ldmVudCAqLwpAQCAtMjExNSwx NSArMjE2OSwyOSBAQCBzdGF0aWMgaW50IHBsMzMwX2NvbmZpZyhzdHJ1Y3QgZG1hX2NoYW4gKmNo YW4sCiAJCQlwY2gtPmZpZm9fYWRkciA9IHNsYXZlX2NvbmZpZy0+ZHN0X2FkZHI7CiAJCWlmIChz bGF2ZV9jb25maWctPmRzdF9hZGRyX3dpZHRoKQogCQkJcGNoLT5idXJzdF9zeiA9IF9fZmZzKHNs YXZlX2NvbmZpZy0+ZHN0X2FkZHJfd2lkdGgpOwotCQlpZiAoc2xhdmVfY29uZmlnLT5kc3RfbWF4 YnVyc3QpCi0JCQlwY2gtPmJ1cnN0X2xlbiA9IHNsYXZlX2NvbmZpZy0+ZHN0X21heGJ1cnN0Owor CQlpZiAocGNoLT5kbWFjLT5xdWlya3MgJiBQTDMzMF9RVUlSS19CUk9LRU5fTk9fRkxVU0hQKQor CQkJcGNoLT5idXJzdF9sZW4gPSAxOworCQllbHNlIGlmIChzbGF2ZV9jb25maWctPmRzdF9tYXhi dXJzdCkgeworCQkJaWYgKHNsYXZlX2NvbmZpZy0+ZHN0X21heGJ1cnN0ID4gUEwzMzBfTUFYX0JV UlNUKQorCQkJCXBjaC0+YnVyc3RfbGVuID0gUEwzMzBfTUFYX0JVUlNUOworCQkJZWxzZQorCQkJ CXBjaC0+YnVyc3RfbGVuID0gc2xhdmVfY29uZmlnLT5kc3RfbWF4YnVyc3Q7CisJCX0gZWxzZQor CQkJcGNoLT5idXJzdF9sZW4gPSAxOwogCX0gZWxzZSBpZiAoc2xhdmVfY29uZmlnLT5kaXJlY3Rp b24gPT0gRE1BX0RFVl9UT19NRU0pIHsKIAkJaWYgKHNsYXZlX2NvbmZpZy0+c3JjX2FkZHIpCiAJ CQlwY2gtPmZpZm9fYWRkciA9IHNsYXZlX2NvbmZpZy0+c3JjX2FkZHI7CiAJCWlmIChzbGF2ZV9j b25maWctPnNyY19hZGRyX3dpZHRoKQogCQkJcGNoLT5idXJzdF9zeiA9IF9fZmZzKHNsYXZlX2Nv bmZpZy0+c3JjX2FkZHJfd2lkdGgpOwotCQlpZiAoc2xhdmVfY29uZmlnLT5zcmNfbWF4YnVyc3Qp Ci0JCQlwY2gtPmJ1cnN0X2xlbiA9IHNsYXZlX2NvbmZpZy0+c3JjX21heGJ1cnN0OworCQlpZiAo cGNoLT5kbWFjLT5xdWlya3MgJiBQTDMzMF9RVUlSS19CUk9LRU5fTk9fRkxVU0hQKQorCQkJcGNo LT5idXJzdF9sZW4gPSAxOworCQllbHNlIGlmIChzbGF2ZV9jb25maWctPnNyY19tYXhidXJzdCkg eworCQkJaWYgKHNsYXZlX2NvbmZpZy0+c3JjX21heGJ1cnN0ID4gUEwzMzBfTUFYX0JVUlNUKQor CQkJCXBjaC0+YnVyc3RfbGVuID0gUEwzMzBfTUFYX0JVUlNUOworCQkJZWxzZQorCQkJCXBjaC0+ YnVyc3RfbGVuID0gc2xhdmVfY29uZmlnLT5zcmNfbWF4YnVyc3Q7CisJCX0gZWxzZQorCQkJcGNo LT5idXJzdF9sZW4gPSAxOwogCX0KIAogCXJldHVybiAwOwpAQCAtMjUxNywxNCArMjU4NSw4IEBA IHN0YXRpYyBpbmxpbmUgaW50IGdldF9idXJzdF9sZW4oc3RydWN0IGRtYV9wbDMzMF9kZXNjICpk ZXNjLCBzaXplX3QgbGVuKQogCWJ1cnN0X2xlbiA+Pj0gZGVzYy0+cnFjZmcuYnJzdF9zaXplOwog CiAJLyogc3JjL2RzdF9idXJzdF9sZW4gY2FuJ3QgYmUgbW9yZSB0aGFuIDE2ICovCi0JaWYgKGJ1 cnN0X2xlbiA+IDE2KQotCQlidXJzdF9sZW4gPSAxNjsKLQotCXdoaWxlIChidXJzdF9sZW4gPiAx KSB7Ci0JCWlmICghKGxlbiAlIChidXJzdF9sZW4gPDwgZGVzYy0+cnFjZmcuYnJzdF9zaXplKSkp Ci0JCQlicmVhazsKLQkJYnVyc3RfbGVuLS07Ci0JfQorCWlmIChidXJzdF9sZW4gPiBQTDMzMF9N QVhfQlVSU1QpCisJCWJ1cnN0X2xlbiA9IFBMMzMwX01BWF9CVVJTVDsKIAogCXJldHVybiBidXJz dF9sZW47CiB9CkBAIC0yNTk2LDcgKzI2NTgsNyBAQCBzdGF0aWMgc3RydWN0IGRtYV9hc3luY190 eF9kZXNjcmlwdG9yICpwbDMzMF9wcmVwX2RtYV9jeWNsaWMoCiAKIAkJZGVzYy0+cnF0eXBlID0g ZGlyZWN0aW9uOwogCQlkZXNjLT5ycWNmZy5icnN0X3NpemUgPSBwY2gtPmJ1cnN0X3N6OwotCQlk ZXNjLT5ycWNmZy5icnN0X2xlbiA9IDE7CisJCWRlc2MtPnJxY2ZnLmJyc3RfbGVuID0gcGNoLT5i dXJzdF9sZW47CiAJCWRlc2MtPmJ5dGVzX3JlcXVlc3RlZCA9IHBlcmlvZF9sZW47CiAJCWZpbGxf cHgoJmRlc2MtPnB4LCBkc3QsIHNyYywgcGVyaW9kX2xlbik7CiAKQEAgLTI3NDEsNyArMjgwMyw3 IEBAIHBsMzMwX3ByZXBfc2xhdmVfc2coc3RydWN0IGRtYV9jaGFuICpjaGFuLCBzdHJ1Y3Qgc2Nh dHRlcmxpc3QgKnNnbCwKIAkJfQogCiAJCWRlc2MtPnJxY2ZnLmJyc3Rfc2l6ZSA9IHBjaC0+YnVy c3Rfc3o7Ci0JCWRlc2MtPnJxY2ZnLmJyc3RfbGVuID0gMTsKKwkJZGVzYy0+cnFjZmcuYnJzdF9s ZW4gPSBwY2gtPmJ1cnN0X2xlbjsKIAkJZGVzYy0+cnF0eXBlID0gZGlyZWN0aW9uOwogCQlkZXNj LT5ieXRlc19yZXF1ZXN0ZWQgPSBzZ19kbWFfbGVuKHNnKTsKIAl9Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753881AbeCFQDf (ORCPT ); Tue, 6 Mar 2018 11:03:35 -0500 Received: from mail-qt0-f195.google.com ([209.85.216.195]:34060 "EHLO mail-qt0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750836AbeCFQDd (ORCPT ); Tue, 6 Mar 2018 11:03:33 -0500 X-Google-Smtp-Source: AG47ELt4s48wquVF9aVRUAruCyJIT6L3zy2JC2apP8SG33Hmmsq4//EayR50noCMLpWyXN0pH49glQ== From: Frank Mori Hess To: dmaengine@vger.kernel.org Reply-To: fmhess@users.sourceforge.net Cc: Vinod Koul , Dan Williams , linux-kernel@vger.kernel.org Subject: [PATCH v3] dmaengine: pl330: flush before wait, and add dev burst support. Date: Tue, 06 Mar 2018 11:03:22 -0500 Message-ID: <23394379.8nZhno5foU@bear> User-Agent: KMail/5.2.3 (Linux/4.9.0-6-amd64; KDE/5.28.0; x86_64; ; ) In-Reply-To: <20180306120259.GT15443@localhost> References: <1957017.QzKNMJJqD6@bear> <20180306120259.GT15443@localhost> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Do DMAFLUSHP _before_ the first DMAWFP to ensure controller and peripheral are in agreement about dma request state before first transfer. Add support for burst transfers to/from peripherals. In the new scheme, the controller does as many burst transfers as it can then transfers the remaining dregs with either single transfers for peripherals, or with a reduced size burst for memory-to-memory transfers. Signed-off-by: Frank Mori Hess Tested-by: Frank Mori Hess I tested dma transfers to peripherals with designware serial port (drivers/tty/serial/8250/8250_dw.c) and a GPIB interface (https://github.com/fmhess/fmh_gpib_core). I tested memory-to-memory transfers using the dmatest module. v3 of this patch should be the same as v2 except with checkpatch.pl warnings and errors cleaned up. --- drivers/dma/pl330.c | 146 +++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 104 insertions(+), 42 deletions(-) diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c index d7327fd5f445..cc2e4456bec1 100644 --- a/drivers/dma/pl330.c +++ b/drivers/dma/pl330.c @@ -1094,26 +1094,33 @@ static inline int _ldst_memtomem(unsigned dry_run, u8 buf[], return off; } -static inline int _ldst_devtomem(struct pl330_dmac *pl330, unsigned dry_run, - u8 buf[], const struct _xfer_spec *pxs, - int cyc) +static inline int _ldst_devtomem(struct pl330_dmac *pl330, + unsigned int dry_run, u8 buf[], + const struct _xfer_spec *pxs, + int cyc, enum pl330_cond cond) { int off = 0; - enum pl330_cond cond; if (pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP) cond = BURST; - else - cond = SINGLE; + /* do FLUSHP at beginning to clear any stale dma requests before the + * first WFP. + */ + if (!(pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP)) + off += _emit_FLUSHP(dry_run, &buf[off], pxs->desc->peri); while (cyc--) { off += _emit_WFP(dry_run, &buf[off], cond, pxs->desc->peri); - off += _emit_LDP(dry_run, &buf[off], cond, pxs->desc->peri); + if (cond == ALWAYS) { + off += _emit_LDP(dry_run, &buf[off], SINGLE, + pxs->desc->peri); + off += _emit_LDP(dry_run, &buf[off], BURST, + pxs->desc->peri); + } else { + off += _emit_LDP(dry_run, &buf[off], cond, + pxs->desc->peri); + } off += _emit_ST(dry_run, &buf[off], ALWAYS); - - if (!(pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP)) - off += _emit_FLUSHP(dry_run, &buf[off], - pxs->desc->peri); } return off; @@ -1121,24 +1128,31 @@ static inline int _ldst_devtomem(struct pl330_dmac *pl330, unsigned dry_run, static inline int _ldst_memtodev(struct pl330_dmac *pl330, unsigned dry_run, u8 buf[], - const struct _xfer_spec *pxs, int cyc) + const struct _xfer_spec *pxs, int cyc, + enum pl330_cond cond) { int off = 0; - enum pl330_cond cond; if (pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP) cond = BURST; - else - cond = SINGLE; + /* do FLUSHP at beginning to clear any stale dma requests before the + * first WFP. + */ + if (!(pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP)) + off += _emit_FLUSHP(dry_run, &buf[off], pxs->desc->peri); while (cyc--) { off += _emit_WFP(dry_run, &buf[off], cond, pxs->desc->peri); off += _emit_LD(dry_run, &buf[off], ALWAYS); - off += _emit_STP(dry_run, &buf[off], cond, pxs->desc->peri); - - if (!(pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP)) - off += _emit_FLUSHP(dry_run, &buf[off], - pxs->desc->peri); + if (cond == ALWAYS) { + off += _emit_STP(dry_run, &buf[off], SINGLE, + pxs->desc->peri); + off += _emit_STP(dry_run, &buf[off], BURST, + pxs->desc->peri); + } else { + off += _emit_STP(dry_run, &buf[off], cond, + pxs->desc->peri); + } } return off; @@ -1148,13 +1162,16 @@ static int _bursts(struct pl330_dmac *pl330, unsigned dry_run, u8 buf[], const struct _xfer_spec *pxs, int cyc) { int off = 0; + enum pl330_cond cond = BRST_LEN(pxs->ccr) > 1 ? BURST : SINGLE; switch (pxs->desc->rqtype) { case DMA_MEM_TO_DEV: - off += _ldst_memtodev(pl330, dry_run, &buf[off], pxs, cyc); + off += _ldst_memtodev(pl330, dry_run, &buf[off], pxs, cyc, + cond); break; case DMA_DEV_TO_MEM: - off += _ldst_devtomem(pl330, dry_run, &buf[off], pxs, cyc); + off += _ldst_devtomem(pl330, dry_run, &buf[off], pxs, cyc, + cond); break; case DMA_MEM_TO_MEM: off += _ldst_memtomem(dry_run, &buf[off], pxs, cyc); @@ -1167,6 +1184,46 @@ static int _bursts(struct pl330_dmac *pl330, unsigned dry_run, u8 buf[], return off; } +/* transfer dregs with single transfers to peripheral, or a reduced size burst + * for mem-to-mem. + */ +static int _dregs(struct pl330_dmac *pl330, unsigned int dry_run, u8 buf[], + const struct _xfer_spec *pxs, int transfer_length) +{ + int off = 0; + int dregs_ccr; + + if (transfer_length == 0) + return off; + + switch (pxs->desc->rqtype) { + case DMA_MEM_TO_DEV: + off += _ldst_memtodev(pl330, dry_run, &buf[off], pxs, + transfer_length, SINGLE); + break; + case DMA_DEV_TO_MEM: + off += _ldst_devtomem(pl330, dry_run, &buf[off], pxs, + transfer_length, SINGLE); + break; + case DMA_MEM_TO_MEM: + dregs_ccr = pxs->ccr; + dregs_ccr &= ~((0xf << CC_SRCBRSTLEN_SHFT) | + (0xf << CC_DSTBRSTLEN_SHFT)); + dregs_ccr |= (((transfer_length - 1) & 0xf) << + CC_SRCBRSTLEN_SHFT); + dregs_ccr |= (((transfer_length - 1) & 0xf) << + CC_DSTBRSTLEN_SHFT); + off += _emit_MOV(dry_run, &buf[off], CCR, dregs_ccr); + off += _ldst_memtomem(dry_run, &buf[off], pxs, 1); + break; + default: + off += 0x40000000; /* Scare off the Client */ + break; + } + + return off; +} + /* Returns bytes consumed and updates bursts */ static inline int _loop(struct pl330_dmac *pl330, unsigned dry_run, u8 buf[], unsigned long *bursts, const struct _xfer_spec *pxs) @@ -1256,6 +1313,8 @@ static inline int _setup_loops(struct pl330_dmac *pl330, struct pl330_xfer *x = &pxs->desc->px; u32 ccr = pxs->ccr; unsigned long c, bursts = BYTE_TO_BURST(x->bytes, ccr); + int num_dregs = (x->bytes - BURST_TO_BYTE(bursts, ccr)) / + BRST_SIZE(ccr); int off = 0; while (bursts) { @@ -1263,6 +1322,7 @@ static inline int _setup_loops(struct pl330_dmac *pl330, off += _loop(pl330, dry_run, &buf[off], &c, pxs); bursts -= c; } + off += _dregs(pl330, dry_run, &buf[off], pxs, num_dregs); return off; } @@ -1294,7 +1354,6 @@ static int _setup_req(struct pl330_dmac *pl330, unsigned dry_run, struct _xfer_spec *pxs) { struct _pl330_req *req = &thrd->req[index]; - struct pl330_xfer *x; u8 *buf = req->mc_cpu; int off = 0; @@ -1303,11 +1362,6 @@ static int _setup_req(struct pl330_dmac *pl330, unsigned dry_run, /* DMAMOV CCR, ccr */ off += _emit_MOV(dry_run, &buf[off], CCR, pxs->ccr); - x = &pxs->desc->px; - /* Error if xfer length is not aligned at burst size */ - if (x->bytes % (BRST_SIZE(pxs->ccr) * BRST_LEN(pxs->ccr))) - return -EINVAL; - off += _setup_xfer(pl330, dry_run, &buf[off], pxs); /* DMASEV peripheral/event */ @@ -2115,15 +2169,29 @@ static int pl330_config(struct dma_chan *chan, pch->fifo_addr = slave_config->dst_addr; if (slave_config->dst_addr_width) pch->burst_sz = __ffs(slave_config->dst_addr_width); - if (slave_config->dst_maxburst) - pch->burst_len = slave_config->dst_maxburst; + if (pch->dmac->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP) + pch->burst_len = 1; + else if (slave_config->dst_maxburst) { + if (slave_config->dst_maxburst > PL330_MAX_BURST) + pch->burst_len = PL330_MAX_BURST; + else + pch->burst_len = slave_config->dst_maxburst; + } else + pch->burst_len = 1; } else if (slave_config->direction == DMA_DEV_TO_MEM) { if (slave_config->src_addr) pch->fifo_addr = slave_config->src_addr; if (slave_config->src_addr_width) pch->burst_sz = __ffs(slave_config->src_addr_width); - if (slave_config->src_maxburst) - pch->burst_len = slave_config->src_maxburst; + if (pch->dmac->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP) + pch->burst_len = 1; + else if (slave_config->src_maxburst) { + if (slave_config->src_maxburst > PL330_MAX_BURST) + pch->burst_len = PL330_MAX_BURST; + else + pch->burst_len = slave_config->src_maxburst; + } else + pch->burst_len = 1; } return 0; @@ -2517,14 +2585,8 @@ static inline int get_burst_len(struct dma_pl330_desc *desc, size_t len) burst_len >>= desc->rqcfg.brst_size; /* src/dst_burst_len can't be more than 16 */ - if (burst_len > 16) - burst_len = 16; - - while (burst_len > 1) { - if (!(len % (burst_len << desc->rqcfg.brst_size))) - break; - burst_len--; - } + if (burst_len > PL330_MAX_BURST) + burst_len = PL330_MAX_BURST; return burst_len; } @@ -2596,7 +2658,7 @@ static struct dma_async_tx_descriptor *pl330_prep_dma_cyclic( desc->rqtype = direction; desc->rqcfg.brst_size = pch->burst_sz; - desc->rqcfg.brst_len = 1; + desc->rqcfg.brst_len = pch->burst_len; desc->bytes_requested = period_len; fill_px(&desc->px, dst, src, period_len); @@ -2741,7 +2803,7 @@ pl330_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl, } desc->rqcfg.brst_size = pch->burst_sz; - desc->rqcfg.brst_len = 1; + desc->rqcfg.brst_len = pch->burst_len; desc->rqtype = direction; desc->bytes_requested = sg_dma_len(sg); } -- 2.11.0