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: [v5] dmaengine: pl330: flush before wait, and add dev burst support. From: Frank Mori Hess Message-Id: <1643219.q45jaR7ETT@bear> Date: Wed, 18 Apr 2018 20:31:06 -0400 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+Ci0tLQoKSSB0 ZXN0ZWQgZG1hIHRyYW5zZmVycyB0byBwZXJpcGhlcmFscyB3aXRoIHYzIHBhdGNoIGFuZCBkZXNp Z253YXJlIHNlcmlhbCAKcG9ydCAoZHJpdmVycy90dHkvc2VyaWFsLzgyNTAvODI1MF9kdy5jKSBh bmQgYSBHUElCIGludGVyZmFjZQooaHR0cHM6Ly9naXRodWIuY29tL2ZtaGVzcy9mbWhfZ3BpYl9j b3JlKS4gIEkgdGVzdGVkIG1lbW9yeS10by1tZW1vcnkKdHJhbnNmZXJzIHVzaW5nIHRoZSBkbWF0 ZXN0IG1vZHVsZS4KCnYzIG9mIHRoaXMgcGF0Y2ggc2hvdWxkIGJlIHRoZSBzYW1lIGFzIHYyIGV4 Y2VwdCB3aXRoIGNoZWNrcGF0Y2gucGwKd2FybmluZ3MgYW5kIGVycm9ycyBjbGVhbmVkIHVwLgoK djQgYWRkcmVzc2VzIGNvc21ldGljIGNvbXBsYWludHMgYWJvdXQgdjMsIHNob3VsZCBiZSBmdW5j dGlvbmFsbHkgdW5jaGFuZ2VkLgoKdjUgdW5jaGFuZ2VkIG90aGVyIHRoYW4gcmViYXNpbmcgdG8g SEVBRCBvbiAibmV4dCIgYnJhbmNoIG9mIApodHRwOi8vZ2l0LmluZnJhZGVhZC5vcmcvdXNlcnMv dmtvdWwvc2xhdmUtZG1hLmdpdCAKUmV0ZXN0ZWQgd2l0aCB0cmFuc2ZlcnMgdG8vZnJvbSBwZXJp cGhlcmFsLgoKIGRyaXZlcnMvZG1hL3BsMzMwLmMgfCAyMDkgKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDE1OSBpbnNl cnRpb25zKCspLCA1MCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9wbDMz MC5jIGIvZHJpdmVycy9kbWEvcGwzMzAuYwppbmRleCBkZTFmZDU5ZmUxMzYuLjYyMzcwNjkwMDFj NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvcGwzMzAuYworKysgYi9kcml2ZXJzL2RtYS9wbDMz MC5jCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSA8bGludXgvb2ZfZG1hLmg+CiAjaW5jbHVk ZSA8bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvcG1fcnVudGltZS5oPgorI2luY2x1ZGUg PGxpbnV4L2J1Zy5oPgogCiAjaW5jbHVkZSAiZG1hZW5naW5lLmgiCiAjZGVmaW5lIFBMMzMwX01B WF9DSEFOCQk4CkBAIC0xMDk0LDUxICsxMDk1LDk2IEBAIHN0YXRpYyBpbmxpbmUgaW50IF9sZHN0 X21lbXRvbWVtKHVuc2lnbmVkIGRyeV9ydW4sIHU4IGJ1ZltdLAogCXJldHVybiBvZmY7CiB9CiAK LXN0YXRpYyBpbmxpbmUgaW50IF9sZHN0X2RldnRvbWVtKHN0cnVjdCBwbDMzMF9kbWFjICpwbDMz MCwgdW5zaWduZWQgZHJ5X3J1biwKLQkJCQkgdTggYnVmW10sIGNvbnN0IHN0cnVjdCBfeGZlcl9z cGVjICpweHMsCi0JCQkJIGludCBjeWMpCitzdGF0aWMgdTMyIF9lbWl0X2xvYWQodW5zaWduZWQg aW50IGRyeV9ydW4sIHU4IGJ1ZltdLAorCWVudW0gcGwzMzBfY29uZCBjb25kLCBlbnVtIGRtYV90 cmFuc2Zlcl9kaXJlY3Rpb24gZGlyZWN0aW9uLAorCXU4IHBlcmkpCiB7CiAJaW50IG9mZiA9IDA7 Ci0JZW51bSBwbDMzMF9jb25kIGNvbmQ7CiAKLQlpZiAocGwzMzAtPnF1aXJrcyAmIFBMMzMwX1FV SVJLX0JST0tFTl9OT19GTFVTSFApCi0JCWNvbmQgPSBCVVJTVDsKLQllbHNlCi0JCWNvbmQgPSBT SU5HTEU7CisJc3dpdGNoIChkaXJlY3Rpb24pIHsKKwljYXNlIERNQV9NRU1fVE9fTUVNOgorCQkv KiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIERNQV9NRU1fVE9fREVWOgorCQlvZmYgKz0gX2VtaXRf TEQoZHJ5X3J1biwgJmJ1ZltvZmZdLCBjb25kKTsKKwkJYnJlYWs7CiAKLQl3aGlsZSAoY3ljLS0p IHsKLQkJb2ZmICs9IF9lbWl0X1dGUChkcnlfcnVuLCAmYnVmW29mZl0sIGNvbmQsIHB4cy0+ZGVz Yy0+cGVyaSk7Ci0JCW9mZiArPSBfZW1pdF9MRFAoZHJ5X3J1biwgJmJ1ZltvZmZdLCBjb25kLCBw eHMtPmRlc2MtPnBlcmkpOwotCQlvZmYgKz0gX2VtaXRfU1QoZHJ5X3J1biwgJmJ1ZltvZmZdLCBB TFdBWVMpOworCWNhc2UgRE1BX0RFVl9UT19NRU06CisJCWlmIChjb25kID09IEFMV0FZUykgewor CQkJb2ZmICs9IF9lbWl0X0xEUChkcnlfcnVuLCAmYnVmW29mZl0sIFNJTkdMRSwKKwkJCQlwZXJp KTsKKwkJCW9mZiArPSBfZW1pdF9MRFAoZHJ5X3J1biwgJmJ1ZltvZmZdLCBCVVJTVCwKKwkJCQlw ZXJpKTsKKwkJfSBlbHNlIHsKKwkJCW9mZiArPSBfZW1pdF9MRFAoZHJ5X3J1biwgJmJ1ZltvZmZd LCBjb25kLAorCQkJCXBlcmkpOworCQl9CisJCWJyZWFrOwogCi0JCWlmICghKHBsMzMwLT5xdWly a3MgJiBQTDMzMF9RVUlSS19CUk9LRU5fTk9fRkxVU0hQKSkKLQkJCW9mZiArPSBfZW1pdF9GTFVT SFAoZHJ5X3J1biwgJmJ1ZltvZmZdLAotCQkJCQkgICAgcHhzLT5kZXNjLT5wZXJpKTsKKwlkZWZh dWx0OgorCQkvKiB0aGlzIGNvZGUgc2hvdWxkIGJlIHVucmVhY2hhYmxlICovCisJCVdBUk5fT04o MSk7CisJCWJyZWFrOwogCX0KIAogCXJldHVybiBvZmY7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50 IF9sZHN0X21lbXRvZGV2KHN0cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwKK3N0YXRpYyBpbmxpbmUg dTMyIF9lbWl0X3N0b3JlKHVuc2lnbmVkIGludCBkcnlfcnVuLCB1OCBidWZbXSwKKwllbnVtIHBs MzMwX2NvbmQgY29uZCwgZW51bSBkbWFfdHJhbnNmZXJfZGlyZWN0aW9uIGRpcmVjdGlvbiwKKwl1 OCBwZXJpKQoreworCWludCBvZmYgPSAwOworCisJc3dpdGNoIChkaXJlY3Rpb24pIHsKKwljYXNl IERNQV9NRU1fVE9fTUVNOgorCQkvKiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIERNQV9ERVZfVE9f TUVNOgorCQlvZmYgKz0gX2VtaXRfU1QoZHJ5X3J1biwgJmJ1ZltvZmZdLCBjb25kKTsKKwkJYnJl YWs7CisKKwljYXNlIERNQV9NRU1fVE9fREVWOgorCQlpZiAoY29uZCA9PSBBTFdBWVMpIHsKKwkJ CW9mZiArPSBfZW1pdF9TVFAoZHJ5X3J1biwgJmJ1ZltvZmZdLCBTSU5HTEUsCisJCQkJcGVyaSk7 CisJCQlvZmYgKz0gX2VtaXRfU1RQKGRyeV9ydW4sICZidWZbb2ZmXSwgQlVSU1QsCisJCQkJcGVy aSk7CisJCX0gZWxzZSB7CisJCQlvZmYgKz0gX2VtaXRfU1RQKGRyeV9ydW4sICZidWZbb2ZmXSwg Y29uZCwKKwkJCQlwZXJpKTsKKwkJfQorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCS8qIHRoaXMg Y29kZSBzaG91bGQgYmUgdW5yZWFjaGFibGUgKi8KKwkJV0FSTl9PTigxKTsKKwkJYnJlYWs7CisJ fQorCisJcmV0dXJuIG9mZjsKK30KKworc3RhdGljIGlubGluZSBpbnQgX2xkc3RfcGVyaXBoZXJh bChzdHJ1Y3QgcGwzMzBfZG1hYyAqcGwzMzAsCiAJCQkJIHVuc2lnbmVkIGRyeV9ydW4sIHU4IGJ1 ZltdLAotCQkJCSBjb25zdCBzdHJ1Y3QgX3hmZXJfc3BlYyAqcHhzLCBpbnQgY3ljKQorCQkJCSBj b25zdCBzdHJ1Y3QgX3hmZXJfc3BlYyAqcHhzLCBpbnQgY3ljLAorCQkJCSBlbnVtIHBsMzMwX2Nv bmQgY29uZCkKIHsKIAlpbnQgb2ZmID0gMDsKLQllbnVtIHBsMzMwX2NvbmQgY29uZDsKIAogCWlm IChwbDMzMC0+cXVpcmtzICYgUEwzMzBfUVVJUktfQlJPS0VOX05PX0ZMVVNIUCkKIAkJY29uZCA9 IEJVUlNUOwotCWVsc2UKLQkJY29uZCA9IFNJTkdMRTsKIAorCS8qCisJICogZG8gRkxVU0hQIGF0 IGJlZ2lubmluZyB0byBjbGVhciBhbnkgc3RhbGUgZG1hIHJlcXVlc3RzIGJlZm9yZSB0aGUKKwkg KiBmaXJzdCBXRlAuCisJICovCisJaWYgKCEocGwzMzAtPnF1aXJrcyAmIFBMMzMwX1FVSVJLX0JS T0tFTl9OT19GTFVTSFApKQorCQlvZmYgKz0gX2VtaXRfRkxVU0hQKGRyeV9ydW4sICZidWZbb2Zm XSwgcHhzLT5kZXNjLT5wZXJpKTsKIAl3aGlsZSAoY3ljLS0pIHsKIAkJb2ZmICs9IF9lbWl0X1dG UChkcnlfcnVuLCAmYnVmW29mZl0sIGNvbmQsIHB4cy0+ZGVzYy0+cGVyaSk7Ci0JCW9mZiArPSBf ZW1pdF9MRChkcnlfcnVuLCAmYnVmW29mZl0sIEFMV0FZUyk7Ci0JCW9mZiArPSBfZW1pdF9TVFAo ZHJ5X3J1biwgJmJ1ZltvZmZdLCBjb25kLCBweHMtPmRlc2MtPnBlcmkpOwotCi0JCWlmICghKHBs MzMwLT5xdWlya3MgJiBQTDMzMF9RVUlSS19CUk9LRU5fTk9fRkxVU0hQKSkKLQkJCW9mZiArPSBf ZW1pdF9GTFVTSFAoZHJ5X3J1biwgJmJ1ZltvZmZdLAotCQkJCQkgICAgcHhzLT5kZXNjLT5wZXJp KTsKKwkJb2ZmICs9IF9lbWl0X2xvYWQoZHJ5X3J1biwgJmJ1ZltvZmZdLCBjb25kLCBweHMtPmRl c2MtPnJxdHlwZSwKKwkJCXB4cy0+ZGVzYy0+cGVyaSk7CisJCW9mZiArPSBfZW1pdF9zdG9yZShk cnlfcnVuLCAmYnVmW29mZl0sIGNvbmQsIHB4cy0+ZGVzYy0+cnF0eXBlLAorCQkJcHhzLT5kZXNj LT5wZXJpKTsKIAl9CiAKIAlyZXR1cm4gb2ZmOwpAQCAtMTE0OCwxOSArMTE5NCw2NSBAQCBzdGF0 aWMgaW50IF9idXJzdHMoc3RydWN0IHBsMzMwX2RtYWMgKnBsMzMwLCB1bnNpZ25lZCBkcnlfcnVu LCB1OCBidWZbXSwKIAkJY29uc3Qgc3RydWN0IF94ZmVyX3NwZWMgKnB4cywgaW50IGN5YykKIHsK IAlpbnQgb2ZmID0gMDsKKwllbnVtIHBsMzMwX2NvbmQgY29uZCA9IEJSU1RfTEVOKHB4cy0+Y2Ny KSA+IDEgPyBCVVJTVCA6IFNJTkdMRTsKIAogCXN3aXRjaCAocHhzLT5kZXNjLT5ycXR5cGUpIHsK IAljYXNlIERNQV9NRU1fVE9fREVWOgotCQlvZmYgKz0gX2xkc3RfbWVtdG9kZXYocGwzMzAsIGRy eV9ydW4sICZidWZbb2ZmXSwgcHhzLCBjeWMpOwotCQlicmVhazsKKwkJLyogZmFsbCB0aHJvdWdo ICovCiAJY2FzZSBETUFfREVWX1RPX01FTToKLQkJb2ZmICs9IF9sZHN0X2RldnRvbWVtKHBsMzMw LCBkcnlfcnVuLCAmYnVmW29mZl0sIHB4cywgY3ljKTsKKwkJb2ZmICs9IF9sZHN0X3BlcmlwaGVy YWwocGwzMzAsIGRyeV9ydW4sICZidWZbb2ZmXSwgcHhzLCBjeWMsCisJCQljb25kKTsKIAkJYnJl YWs7CisKIAljYXNlIERNQV9NRU1fVE9fTUVNOgogCQlvZmYgKz0gX2xkc3RfbWVtdG9tZW0oZHJ5 X3J1biwgJmJ1ZltvZmZdLCBweHMsIGN5Yyk7CiAJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJLyog dGhpcyBjb2RlIHNob3VsZCBiZSB1bnJlYWNoYWJsZSAqLworCQlXQVJOX09OKDEpOworCQlicmVh azsKKwl9CisKKwlyZXR1cm4gb2ZmOworfQorCisvKgorICogdHJhbnNmZXIgZHJlZ3Mgd2l0aCBz aW5nbGUgdHJhbnNmZXJzIHRvIHBlcmlwaGVyYWwsIG9yIGEgcmVkdWNlZCBzaXplIGJ1cnN0Cisg KiBmb3IgbWVtLXRvLW1lbS4KKyAqLworc3RhdGljIGludCBfZHJlZ3Moc3RydWN0IHBsMzMwX2Rt YWMgKnBsMzMwLCB1bnNpZ25lZCBpbnQgZHJ5X3J1biwgdTggYnVmW10sCisJCWNvbnN0IHN0cnVj dCBfeGZlcl9zcGVjICpweHMsIGludCB0cmFuc2Zlcl9sZW5ndGgpCit7CisJaW50IG9mZiA9IDA7 CisJaW50IGRyZWdzX2NjcjsKKworCWlmICh0cmFuc2Zlcl9sZW5ndGggPT0gMCkKKwkJcmV0dXJu IG9mZjsKKworCXN3aXRjaCAocHhzLT5kZXNjLT5ycXR5cGUpIHsKKwljYXNlIERNQV9NRU1fVE9f REVWOgorCQkvKiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIERNQV9ERVZfVE9fTUVNOgorCQlvZmYg Kz0gX2xkc3RfcGVyaXBoZXJhbChwbDMzMCwgZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMsCisJCQl0 cmFuc2Zlcl9sZW5ndGgsIFNJTkdMRSk7CisJCWJyZWFrOworCisJY2FzZSBETUFfTUVNX1RPX01F TToKKwkJZHJlZ3NfY2NyID0gcHhzLT5jY3I7CisJCWRyZWdzX2NjciAmPSB+KCgweGYgPDwgQ0Nf U1JDQlJTVExFTl9TSEZUKSB8CisJCQkoMHhmIDw8IENDX0RTVEJSU1RMRU5fU0hGVCkpOworCQlk cmVnc19jY3IgfD0gKCgodHJhbnNmZXJfbGVuZ3RoIC0gMSkgJiAweGYpIDw8CisJCQlDQ19TUkNC UlNUTEVOX1NIRlQpOworCQlkcmVnc19jY3IgfD0gKCgodHJhbnNmZXJfbGVuZ3RoIC0gMSkgJiAw eGYpIDw8CisJCQlDQ19EU1RCUlNUTEVOX1NIRlQpOworCQlvZmYgKz0gX2VtaXRfTU9WKGRyeV9y dW4sICZidWZbb2ZmXSwgQ0NSLCBkcmVnc19jY3IpOworCQlvZmYgKz0gX2xkc3RfbWVtdG9tZW0o ZHJ5X3J1biwgJmJ1ZltvZmZdLCBweHMsIDEpOworCQlicmVhazsKKwogCWRlZmF1bHQ6Ci0JCW9m ZiArPSAweDQwMDAwMDAwOyAvKiBTY2FyZSBvZmYgdGhlIENsaWVudCAqLworCQkvKiB0aGlzIGNv ZGUgc2hvdWxkIGJlIHVucmVhY2hhYmxlICovCisJCVdBUk5fT04oMSk7CiAJCWJyZWFrOwogCX0K IApAQCAtMTI1Niw2ICsxMzQ4LDggQEAgc3RhdGljIGlubGluZSBpbnQgX3NldHVwX2xvb3BzKHN0 cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwKIAlzdHJ1Y3QgcGwzMzBfeGZlciAqeCA9ICZweHMtPmRl c2MtPnB4OwogCXUzMiBjY3IgPSBweHMtPmNjcjsKIAl1bnNpZ25lZCBsb25nIGMsIGJ1cnN0cyA9 IEJZVEVfVE9fQlVSU1QoeC0+Ynl0ZXMsIGNjcik7CisJaW50IG51bV9kcmVncyA9ICh4LT5ieXRl cyAtIEJVUlNUX1RPX0JZVEUoYnVyc3RzLCBjY3IpKSAvCisJCUJSU1RfU0laRShjY3IpOwogCWlu dCBvZmYgPSAwOwogCiAJd2hpbGUgKGJ1cnN0cykgewpAQCAtMTI2Myw2ICsxMzU3LDcgQEAgc3Rh dGljIGlubGluZSBpbnQgX3NldHVwX2xvb3BzKHN0cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwKIAkJ b2ZmICs9IF9sb29wKHBsMzMwLCBkcnlfcnVuLCAmYnVmW29mZl0sICZjLCBweHMpOwogCQlidXJz dHMgLT0gYzsKIAl9CisJb2ZmICs9IF9kcmVncyhwbDMzMCwgZHJ5X3J1biwgJmJ1ZltvZmZdLCBw eHMsIG51bV9kcmVncyk7CiAKIAlyZXR1cm4gb2ZmOwogfQpAQCAtMTI5NCw3ICsxMzg5LDYgQEAg c3RhdGljIGludCBfc2V0dXBfcmVxKHN0cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwgdW5zaWduZWQg ZHJ5X3J1biwKIAkJICAgICAgc3RydWN0IF94ZmVyX3NwZWMgKnB4cykKIHsKIAlzdHJ1Y3QgX3Bs MzMwX3JlcSAqcmVxID0gJnRocmQtPnJlcVtpbmRleF07Ci0Jc3RydWN0IHBsMzMwX3hmZXIgKng7 CiAJdTggKmJ1ZiA9IHJlcS0+bWNfY3B1OwogCWludCBvZmYgPSAwOwogCkBAIC0xMzAzLDExICsx Mzk3LDYgQEAgc3RhdGljIGludCBfc2V0dXBfcmVxKHN0cnVjdCBwbDMzMF9kbWFjICpwbDMzMCwg dW5zaWduZWQgZHJ5X3J1biwKIAkvKiBETUFNT1YgQ0NSLCBjY3IgKi8KIAlvZmYgKz0gX2VtaXRf TU9WKGRyeV9ydW4sICZidWZbb2ZmXSwgQ0NSLCBweHMtPmNjcik7CiAKLQl4ID0gJnB4cy0+ZGVz Yy0+cHg7Ci0JLyogRXJyb3IgaWYgeGZlciBsZW5ndGggaXMgbm90IGFsaWduZWQgYXQgYnVyc3Qg c2l6ZSAqLwotCWlmICh4LT5ieXRlcyAlIChCUlNUX1NJWkUocHhzLT5jY3IpICogQlJTVF9MRU4o cHhzLT5jY3IpKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KIAlvZmYgKz0gX3NldHVwX3hmZXIocGwz MzAsIGRyeV9ydW4sICZidWZbb2ZmXSwgcHhzKTsKIAogCS8qIERNQVNFViBwZXJpcGhlcmFsL2V2 ZW50ICovCkBAIC0xMzY1LDYgKzE0NTQsMjAgQEAgc3RhdGljIGludCBwbDMzMF9zdWJtaXRfcmVx KHN0cnVjdCBwbDMzMF90aHJlYWQgKnRocmQsCiAJdTMyIGNjcjsKIAlpbnQgcmV0ID0gMDsKIAor CXN3aXRjaCAoZGVzYy0+cnF0eXBlKSB7CisJY2FzZSBETUFfTUVNX1RPX0RFVjoKKwkJYnJlYWs7 CisKKwljYXNlIERNQV9ERVZfVE9fTUVNOgorCQlicmVhazsKKworCWNhc2UgRE1BX01FTV9UT19N RU06CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJcmV0dXJuIC1FTk9UU1VQUDsKKwl9CisKIAlp ZiAocGwzMzAtPnN0YXRlID09IERZSU5HCiAJCXx8IHBsMzMwLT5kbWFjX3RiZC5yZXNldF9jaGFu ICYgKDEgPDwgdGhyZC0+aWQpKSB7CiAJCWRldl9pbmZvKHRocmQtPmRtYWMtPmRkbWEuZGV2LCAi JXM6JWRcbiIsCkBAIC0yMTA2LDYgKzIyMDksMTggQEAgc3RhdGljIGJvb2wgcGwzMzBfcHJlcF9z bGF2ZV9maWZvKHN0cnVjdCBkbWFfcGwzMzBfY2hhbiAqcGNoLAogCXJldHVybiB0cnVlOwogfQog CitzdGF0aWMgaW50IGZpeHVwX2J1cnN0X2xlbihpbnQgbWF4X2J1cnN0X2xlbiwgaW50IHF1aXJr cykKK3sKKwlpZiAocXVpcmtzICYgUEwzMzBfUVVJUktfQlJPS0VOX05PX0ZMVVNIUCkKKwkJcmV0 dXJuIDE7CisJZWxzZSBpZiAobWF4X2J1cnN0X2xlbiA+IFBMMzMwX01BWF9CVVJTVCkKKwkJcmV0 dXJuIFBMMzMwX01BWF9CVVJTVDsKKwllbHNlIGlmIChtYXhfYnVyc3RfbGVuIDwgMSkKKwkJcmV0 dXJuIDE7CisJZWxzZQorCQlyZXR1cm4gbWF4X2J1cnN0X2xlbjsKK30KKwogc3RhdGljIGludCBw bDMzMF9jb25maWcoc3RydWN0IGRtYV9jaGFuICpjaGFuLAogCQkJc3RydWN0IGRtYV9zbGF2ZV9j b25maWcgKnNsYXZlX2NvbmZpZykKIHsKQEAgLTIxMTcsMTUgKzIyMzIsMTUgQEAgc3RhdGljIGlu dCBwbDMzMF9jb25maWcoc3RydWN0IGRtYV9jaGFuICpjaGFuLAogCQkJcGNoLT5maWZvX2FkZHIg PSBzbGF2ZV9jb25maWctPmRzdF9hZGRyOwogCQlpZiAoc2xhdmVfY29uZmlnLT5kc3RfYWRkcl93 aWR0aCkKIAkJCXBjaC0+YnVyc3Rfc3ogPSBfX2ZmcyhzbGF2ZV9jb25maWctPmRzdF9hZGRyX3dp ZHRoKTsKLQkJaWYgKHNsYXZlX2NvbmZpZy0+ZHN0X21heGJ1cnN0KQotCQkJcGNoLT5idXJzdF9s ZW4gPSBzbGF2ZV9jb25maWctPmRzdF9tYXhidXJzdDsKKwkJcGNoLT5idXJzdF9sZW4gPSBmaXh1 cF9idXJzdF9sZW4oc2xhdmVfY29uZmlnLT5kc3RfbWF4YnVyc3QsCisJCQlwY2gtPmRtYWMtPnF1 aXJrcyk7CiAJfSBlbHNlIGlmIChzbGF2ZV9jb25maWctPmRpcmVjdGlvbiA9PSBETUFfREVWX1RP X01FTSkgewogCQlpZiAoc2xhdmVfY29uZmlnLT5zcmNfYWRkcikKIAkJCXBjaC0+Zmlmb19hZGRy ID0gc2xhdmVfY29uZmlnLT5zcmNfYWRkcjsKIAkJaWYgKHNsYXZlX2NvbmZpZy0+c3JjX2FkZHJf d2lkdGgpCiAJCQlwY2gtPmJ1cnN0X3N6ID0gX19mZnMoc2xhdmVfY29uZmlnLT5zcmNfYWRkcl93 aWR0aCk7Ci0JCWlmIChzbGF2ZV9jb25maWctPnNyY19tYXhidXJzdCkKLQkJCXBjaC0+YnVyc3Rf bGVuID0gc2xhdmVfY29uZmlnLT5zcmNfbWF4YnVyc3Q7CisJCXBjaC0+YnVyc3RfbGVuID0gZml4 dXBfYnVyc3RfbGVuKHNsYXZlX2NvbmZpZy0+c3JjX21heGJ1cnN0LAorCQkJcGNoLT5kbWFjLT5x dWlya3MpOwogCX0KIAogCXJldHVybiAwOwpAQCAtMjUxOSwxNCArMjYzNCw4IEBAIHN0YXRpYyBp bmxpbmUgaW50IGdldF9idXJzdF9sZW4oc3RydWN0IGRtYV9wbDMzMF9kZXNjICpkZXNjLCBzaXpl X3QgbGVuKQogCWJ1cnN0X2xlbiA+Pj0gZGVzYy0+cnFjZmcuYnJzdF9zaXplOwogCiAJLyogc3Jj L2RzdF9idXJzdF9sZW4gY2FuJ3QgYmUgbW9yZSB0aGFuIDE2ICovCi0JaWYgKGJ1cnN0X2xlbiA+ IDE2KQotCQlidXJzdF9sZW4gPSAxNjsKLQotCXdoaWxlIChidXJzdF9sZW4gPiAxKSB7Ci0JCWlm ICghKGxlbiAlIChidXJzdF9sZW4gPDwgZGVzYy0+cnFjZmcuYnJzdF9zaXplKSkpCi0JCQlicmVh azsKLQkJYnVyc3RfbGVuLS07Ci0JfQorCWlmIChidXJzdF9sZW4gPiBQTDMzMF9NQVhfQlVSU1Qp CisJCWJ1cnN0X2xlbiA9IFBMMzMwX01BWF9CVVJTVDsKIAogCXJldHVybiBidXJzdF9sZW47CiB9 CkBAIC0yNTk4LDcgKzI3MDcsNyBAQCBzdGF0aWMgc3RydWN0IGRtYV9hc3luY190eF9kZXNjcmlw dG9yICpwbDMzMF9wcmVwX2RtYV9jeWNsaWMoCiAKIAkJZGVzYy0+cnF0eXBlID0gZGlyZWN0aW9u OwogCQlkZXNjLT5ycWNmZy5icnN0X3NpemUgPSBwY2gtPmJ1cnN0X3N6OwotCQlkZXNjLT5ycWNm Zy5icnN0X2xlbiA9IDE7CisJCWRlc2MtPnJxY2ZnLmJyc3RfbGVuID0gcGNoLT5idXJzdF9sZW47 CiAJCWRlc2MtPmJ5dGVzX3JlcXVlc3RlZCA9IHBlcmlvZF9sZW47CiAJCWZpbGxfcHgoJmRlc2Mt PnB4LCBkc3QsIHNyYywgcGVyaW9kX2xlbik7CiAKQEAgLTI3NDMsNyArMjg1Miw3IEBAIHBsMzMw X3ByZXBfc2xhdmVfc2coc3RydWN0IGRtYV9jaGFuICpjaGFuLCBzdHJ1Y3Qgc2NhdHRlcmxpc3Qg KnNnbCwKIAkJfQogCiAJCWRlc2MtPnJxY2ZnLmJyc3Rfc2l6ZSA9IHBjaC0+YnVyc3Rfc3o7Ci0J CWRlc2MtPnJxY2ZnLmJyc3RfbGVuID0gMTsKKwkJZGVzYy0+cnFjZmcuYnJzdF9sZW4gPSBwY2gt PmJ1cnN0X2xlbjsKIAkJZGVzYy0+cnF0eXBlID0gZGlyZWN0aW9uOwogCQlkZXNjLT5ieXRlc19y ZXF1ZXN0ZWQgPSBzZ19kbWFfbGVuKHNnKTsKIAl9Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752785AbeDSAbQ (ORCPT ); Wed, 18 Apr 2018 20:31:16 -0400 Received: from mail-qk0-f193.google.com ([209.85.220.193]:42526 "EHLO mail-qk0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752135AbeDSAbO (ORCPT ); Wed, 18 Apr 2018 20:31:14 -0400 X-Google-Smtp-Source: AB8JxZrXmZSASAex+BNYyAYcgoUkUKv2+241FGW9gE6hZo5NbwEktXBpsFh0Vh7bdYeBpJlRBOsUig== From: Frank Mori Hess To: dmaengine@vger.kernel.org Cc: Vinod Koul , Dan Williams , linux-kernel@vger.kernel.org Subject: [PATCH v5] dmaengine: pl330: flush before wait, and add dev burst support. Date: Wed, 18 Apr 2018 20:31:06 -0400 Message-ID: <1643219.q45jaR7ETT@bear> User-Agent: KMail/5.2.3 (Linux/4.9.0-6-amd64; KDE/5.28.0; x86_64; ; ) 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 v3 patch and 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. v4 addresses cosmetic complaints about v3, should be functionally unchanged. v5 unchanged other than rebasing to HEAD on "next" branch of http://git.infradead.org/users/vkoul/slave-dma.git Retested with transfers to/from peripheral. drivers/dma/pl330.c | 209 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 159 insertions(+), 50 deletions(-) diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c index de1fd59fe136..6237069001c4 100644 --- a/drivers/dma/pl330.c +++ b/drivers/dma/pl330.c @@ -27,6 +27,7 @@ #include #include #include +#include #include "dmaengine.h" #define PL330_MAX_CHAN 8 @@ -1094,51 +1095,96 @@ 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 u32 _emit_load(unsigned int dry_run, u8 buf[], + enum pl330_cond cond, enum dma_transfer_direction direction, + u8 peri) { int off = 0; - enum pl330_cond cond; - if (pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP) - cond = BURST; - else - cond = SINGLE; + switch (direction) { + case DMA_MEM_TO_MEM: + /* fall through */ + case DMA_MEM_TO_DEV: + off += _emit_LD(dry_run, &buf[off], cond); + break; - while (cyc--) { - off += _emit_WFP(dry_run, &buf[off], cond, pxs->desc->peri); - off += _emit_LDP(dry_run, &buf[off], cond, pxs->desc->peri); - off += _emit_ST(dry_run, &buf[off], ALWAYS); + case DMA_DEV_TO_MEM: + if (cond == ALWAYS) { + off += _emit_LDP(dry_run, &buf[off], SINGLE, + peri); + off += _emit_LDP(dry_run, &buf[off], BURST, + peri); + } else { + off += _emit_LDP(dry_run, &buf[off], cond, + peri); + } + break; - if (!(pl330->quirks & PL330_QUIRK_BROKEN_NO_FLUSHP)) - off += _emit_FLUSHP(dry_run, &buf[off], - pxs->desc->peri); + default: + /* this code should be unreachable */ + WARN_ON(1); + break; } return off; } -static inline int _ldst_memtodev(struct pl330_dmac *pl330, +static inline u32 _emit_store(unsigned int dry_run, u8 buf[], + enum pl330_cond cond, enum dma_transfer_direction direction, + u8 peri) +{ + int off = 0; + + switch (direction) { + case DMA_MEM_TO_MEM: + /* fall through */ + case DMA_DEV_TO_MEM: + off += _emit_ST(dry_run, &buf[off], cond); + break; + + case DMA_MEM_TO_DEV: + if (cond == ALWAYS) { + off += _emit_STP(dry_run, &buf[off], SINGLE, + peri); + off += _emit_STP(dry_run, &buf[off], BURST, + peri); + } else { + off += _emit_STP(dry_run, &buf[off], cond, + peri); + } + break; + + default: + /* this code should be unreachable */ + WARN_ON(1); + break; + } + + return off; +} + +static inline int _ldst_peripheral(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); + off += _emit_load(dry_run, &buf[off], cond, pxs->desc->rqtype, + pxs->desc->peri); + off += _emit_store(dry_run, &buf[off], cond, pxs->desc->rqtype, + pxs->desc->peri); } return off; @@ -1148,19 +1194,65 @@ 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); - break; + /* fall through */ case DMA_DEV_TO_MEM: - off += _ldst_devtomem(pl330, dry_run, &buf[off], pxs, cyc); + off += _ldst_peripheral(pl330, dry_run, &buf[off], pxs, cyc, + cond); break; + case DMA_MEM_TO_MEM: off += _ldst_memtomem(dry_run, &buf[off], pxs, cyc); break; + + default: + /* this code should be unreachable */ + WARN_ON(1); + break; + } + + 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: + /* fall through */ + case DMA_DEV_TO_MEM: + off += _ldst_peripheral(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 */ + /* this code should be unreachable */ + WARN_ON(1); break; } @@ -1256,6 +1348,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 +1357,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 +1389,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 +1397,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 */ @@ -1365,6 +1454,20 @@ static int pl330_submit_req(struct pl330_thread *thrd, u32 ccr; int ret = 0; + switch (desc->rqtype) { + case DMA_MEM_TO_DEV: + break; + + case DMA_DEV_TO_MEM: + break; + + case DMA_MEM_TO_MEM: + break; + + default: + return -ENOTSUPP; + } + if (pl330->state == DYING || pl330->dmac_tbd.reset_chan & (1 << thrd->id)) { dev_info(thrd->dmac->ddma.dev, "%s:%d\n", @@ -2106,6 +2209,18 @@ static bool pl330_prep_slave_fifo(struct dma_pl330_chan *pch, return true; } +static int fixup_burst_len(int max_burst_len, int quirks) +{ + if (quirks & PL330_QUIRK_BROKEN_NO_FLUSHP) + return 1; + else if (max_burst_len > PL330_MAX_BURST) + return PL330_MAX_BURST; + else if (max_burst_len < 1) + return 1; + else + return max_burst_len; +} + static int pl330_config(struct dma_chan *chan, struct dma_slave_config *slave_config) { @@ -2117,15 +2232,15 @@ 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; + pch->burst_len = fixup_burst_len(slave_config->dst_maxburst, + pch->dmac->quirks); } 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; + pch->burst_len = fixup_burst_len(slave_config->src_maxburst, + pch->dmac->quirks); } return 0; @@ -2519,14 +2634,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; } @@ -2598,7 +2707,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); @@ -2743,7 +2852,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