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: [RFC,v3,2/7] dmaengine: Add Synopsys eDMA IP version 0 support From: Gustavo Pimentel Message-Id: Date: Fri, 11 Jan 2019 19:33:38 +0100 To: linux-pci@vger.kernel.org, dmaengine@vger.kernel.org Cc: Gustavo Pimentel , Vinod Koul , Dan Williams , Eugeniy Paltsev , Andy Shevchenko , Russell King , Niklas Cassel , Joao Pinto , Jose Abreu , Luis Oliveira , Vitor Soares , Nelson Costa , Pedro Sousa List-ID: QWRkIHN1cHBvcnQgZm9yIHRoZSBlRE1BIElQIHZlcnNpb24gMCBkcml2ZXIgZm9yIGJvdGggcmVn aXN0ZXIgbWFwcyAobGVnYWN5CmFuZCB1bnJvbGwpLgoKVGhlIGxlZ2FjeSByZWdpc3RlciBtYXBw aW5nIHdhcyB0aGUgaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiwgd2hpY2ggY29uc2lzdGVkCmluIGhh dmluZyBhbGwgcmVnaXN0ZXJzIGJlbG9uZ2luZyB0byBjaGFubmVscyBtdWx0aXBsZXhlZCwgd2hp Y2ggY291bGQgYmUKY2hhbmdlIGFueXRpbWUgKHdoaWNoIGNvdWxkIGxlZCBhIHJhY2UtY29uZGl0 aW9uKSBieSB2aWV3IHBvcnQgcmVnaXN0ZXIKKGFjY2VzcyB0byBvbmx5IG9uZSBjaGFubmVsIGF2 YWlsYWJsZSBlYWNoIHRpbWUpLgoKVGhpcyByZWdpc3RlciBtYXBwaW5nIGlzIG5vdCB2ZXJ5IGVm ZmVjdGl2ZSBhbmQgZWZmaWNpZW50IGluIGEgbXVsdGl0aHJlYWQKZW52aXJvbm1lbnQsIHdoaWNo IGhhcyBsZWQgdG8gdGhlIGRldmVsb3BtZW50IG9mIHVucm9sbCByZWdpc3RlcnMgbWFwcGluZywK d2hpY2ggY29uc2lzdHMgb2YgaGF2aW5nIGFsbCBjaGFubmVscyByZWdpc3RlcnMgYWNjZXNzaWJs ZSBhbnkgdGltZSBieQpzcHJlYWRpbmcgYWxsIGNoYW5uZWxzIHJlZ2lzdGVycyBieSBhbiBvZmZz ZXQgYmV0d2VlbiB0aGVtLgoKVGhpcyB2ZXJzaW9uIHN1cHBvcnRzIGEgbWF4aW11bSBvZiAxNiBp bmRlcGVuZGVudCBjaGFubmVscyAoOCB3cml0ZSArCjggcmVhZCksIHdoaWNoIGNhbiBydW4gc2lt dWx0YW5lb3VzbHkuCgpJbXBsZW1lbnRzIGEgc2NhdHRlci1nYXRoZXIgdHJhbnNmZXIgdGhyb3Vn aCBhIGxpbmtlZCBsaXN0LCB3aGVyZSB0aGUgc2l6ZQpvZiBsaW5rZWQgbGlzdCBkZXBlbmRzIG9u IHRoZSBhbGxvY2F0ZWQgbWVtb3J5IGRpdmlkZWQgZXF1YWxseSBhbW9uZyBhbGwKY2hhbm5lbHMu CgpFYWNoIGxpbmtlZCBsaXN0IGRlc2NyaXB0b3IgY2FuIHRyYW5zZmVyIGZyb20gMSBieXRlIHRv IDQgR2J5dGVzIGFuZCBpcwphbGlnbm1lbnRlZCB0byBEV09SRC4KCkJvdGggU0FSIChTb3VyY2Ug QWRkcmVzcyBSZWdpc3RlcikgYW5kIERBUiAoRGVzdGluYXRpb24gQWRkcmVzcyBSZWdpc3RlcikK YXJlIGFsaWdubWVudGVkIHRvIGJ5dGUuCgpDaGFuZ2VzOgpSRkMgdjEtPlJGQyB2MjoKIC0gUmVw bGFjZSBjb21tZW50cyAvLyAoQzk5IHN0eWxlKSBieSAvKiovCiAtIFJlcGxhY2UgbWFnaWMgbnVt YmVycyBieSBkZWZpbmVzCiAtIFJlcGxhY2UgYm9vbGVhbiByZXR1cm4gZnJvbSB0ZXJuYXJ5IG9w ZXJhdGlvbiBieSBhIGRvdWJsZSBuZWdhdGlvbgogICBvcGVyYXRpb24KIC0gUmVwbGFjZSBRV09S RF9ISS9RV09SRF9MTyBtYWNyb3MgYnkgdXBwZXJfMzJfYml0cygpL2xvd2VyXzMyX2JpdHMoKQog LSBGaXggdGhlIGhlYWRlcnMgb2YgdGhlIC5jIGFuZCAuaCBmaWxlcyBhY2NvcmRpbmcgdG8gdGhl IG1vc3QgcmVjZW50CiAgIGNvbnZlbnRpb24KIC0gRml4IGVycm9ycyBhbmQgY2hlY2tzIHBvaW50 ZWQgb3V0IGJ5IGNoZWNrcGF0Y2ggd2l0aCAtLXN0cmljdCBvcHRpb24KIC0gUmVwbGFjZSBwYXRj aCBzbWFsbCBkZXNjcmlwdGlvbiB0YWcgZnJvbSBkbWEgYnkgZG1hZW5naW5lCiAtIFJlZmFjdG9y IGNvZGUgdG8gcmVwbGFjZSBhdG9taWNfdCBieSB1MzIgdmFyaWFibGUgdHlwZQpSRkMgdjItPlJG QyB2MzoKIC0gQ29kZSByZXdyaXRlIHRvIHVzZSBGSUVMRF9QUkVQKCkgYW5kIEZJRUxEX0dFVCgp CiAtIEFkZCBkZWZpbmUgdG8gbWFnaWMgbnVtYmVycwogLSBGaXggbWlub3IgYnVncwoKU2lnbmVk LW9mZi1ieTogR3VzdGF2byBQaW1lbnRlbCA8Z3VzdGF2by5waW1lbnRlbEBzeW5vcHN5cy5jb20+ CkNjOiBWaW5vZCBLb3VsIDx2a291bEBrZXJuZWwub3JnPgpDYzogRGFuIFdpbGxpYW1zIDxkYW4u ai53aWxsaWFtc0BpbnRlbC5jb20+CkNjOiBFdWdlbml5IFBhbHRzZXYgPHBhbHRzZXZAc3lub3Bz eXMuY29tPgpDYzogQW5keSBTaGV2Y2hlbmtvIDxhbmRyaXkuc2hldmNoZW5rb0BsaW51eC5pbnRl bC5jb20+CkNjOiBSdXNzZWxsIEtpbmcgPHJtaytrZXJuZWxAYXJtbGludXgub3JnLnVrPgpDYzog TmlrbGFzIENhc3NlbCA8bmlrbGFzLmNhc3NlbEBsaW5hcm8ub3JnPgpDYzogSm9hbyBQaW50byA8 anBpbnRvQHN5bm9wc3lzLmNvbT4KQ2M6IEpvc2UgQWJyZXUgPGpvc2UuYWJyZXVAc3lub3BzeXMu Y29tPgpDYzogTHVpcyBPbGl2ZWlyYSA8bG9saXZlaUBzeW5vcHN5cy5jb20+CkNjOiBWaXRvciBT b2FyZXMgPHZpdG9yLnNvYXJlc0BzeW5vcHN5cy5jb20+CkNjOiBOZWxzb24gQ29zdGEgPG5lbHNv bi5jb3N0YUBzeW5vcHN5cy5jb20+CkNjOiBQZWRybyBTb3VzYSA8cGVkcm9tLnNvdXNhQHN5bm9w c3lzLmNvbT4KLS0tCiBkcml2ZXJzL2RtYS9kdy1lZG1hL01ha2VmaWxlICAgICAgICAgIHwgICAz ICstCiBkcml2ZXJzL2RtYS9kdy1lZG1hL2R3LWVkbWEtY29yZS5jICAgIHwgIDIxICsrKwogZHJp dmVycy9kbWEvZHctZWRtYS9kdy1lZG1hLXYwLWNvcmUuYyB8IDM0NiArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2RtYS9kdy1lZG1hL2R3LWVkbWEtdjAtY29yZS5o IHwgIDI2ICsrKwogZHJpdmVycy9kbWEvZHctZWRtYS9kdy1lZG1hLXYwLXJlZ3MuaCB8IDE1NiAr KysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgNTUxIGluc2VydGlvbnMoKyksIDEgZGVs ZXRpb24oLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS9kdy1lZG1hL2R3LWVkbWEt djAtY29yZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEvZHctZWRtYS9kdy1lZG1h LXYwLWNvcmUuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRt YS12MC1yZWdzLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9kdy1lZG1hL01ha2VmaWxlIGIv ZHJpdmVycy9kbWEvZHctZWRtYS9NYWtlZmlsZQppbmRleCAzMjI0MDEwLi4wMWM3YzYzIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2RtYS9kdy1lZG1hL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZG1hL2R3 LWVkbWEvTWFrZWZpbGUKQEAgLTEsNCArMSw1IEBACiAjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wCiAKIG9iai0kKENPTkZJR19EV19FRE1BKQkJKz0gZHctZWRtYS5vCi1kdy1lZG1h LW9ianMJCQk6PSBkdy1lZG1hLWNvcmUubworZHctZWRtYS1vYmpzCQkJOj0gZHctZWRtYS1jb3Jl Lm8gXAorCQkJCQlkdy1lZG1hLXYwLWNvcmUubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZHct ZWRtYS9kdy1lZG1hLWNvcmUuYyBiL2RyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRtYS1jb3JlLmMK aW5kZXggMmI2YjcwZi4uNzcyYTIyZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvZHctZWRtYS9k dy1lZG1hLWNvcmUuYworKysgYi9kcml2ZXJzL2RtYS9kdy1lZG1hL2R3LWVkbWEtY29yZS5jCkBA IC0xNSw2ICsxNSw3IEBACiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CiAKICNpbmNsdWRlICJkdy1l ZG1hLWNvcmUuaCIKKyNpbmNsdWRlICJkdy1lZG1hLXYwLWNvcmUuaCIKICNpbmNsdWRlICIuLi9k bWFlbmdpbmUuaCIKICNpbmNsdWRlICIuLi92aXJ0LWRtYS5oIgogCkBAIC0yNyw2ICsyOCwyMiBA QAogCQlTRVQoZHctPnJkX2VkbWEsIG5hbWUsIHZhbHVlKTsJXAogCX0gd2hpbGUgKDApCiAKK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgZHdfZWRtYV9jb3JlX29wcyBkd19lZG1hX3YwX2NvcmVfb3BzID0g eworCS8qIGVETUEgbWFuYWdlbWVudCBjYWxsYmFja3MgKi8KKwkub2ZmID0gZHdfZWRtYV92MF9j b3JlX29mZiwKKwkuY2hfY291bnQgPSBkd19lZG1hX3YwX2NvcmVfY2hfY291bnQsCisJLmNoX3N0 YXR1cyA9IGR3X2VkbWFfdjBfY29yZV9jaF9zdGF0dXMsCisJLmNsZWFyX2RvbmVfaW50ID0gZHdf ZWRtYV92MF9jb3JlX2NsZWFyX2RvbmVfaW50LAorCS5jbGVhcl9hYm9ydF9pbnQgPSBkd19lZG1h X3YwX2NvcmVfY2xlYXJfYWJvcnRfaW50LAorCS5zdGF0dXNfZG9uZV9pbnQgPSBkd19lZG1hX3Yw X2NvcmVfc3RhdHVzX2RvbmVfaW50LAorCS5zdGF0dXNfYWJvcnRfaW50ID0gZHdfZWRtYV92MF9j b3JlX3N0YXR1c19hYm9ydF9pbnQsCisJLnN0YXJ0ID0gZHdfZWRtYV92MF9jb3JlX3N0YXJ0LAor CS5kZXZpY2VfY29uZmlnID0gZHdfZWRtYV92MF9jb3JlX2RldmljZV9jb25maWcsCisJLyogZURN QSBkZWJ1ZyBmcyBjYWxsYmFja3MgKi8KKwkuZGVidWdmc19vbiA9IGR3X2VkbWFfdjBfY29yZV9k ZWJ1Z2ZzX29uLAorCS5kZWJ1Z2ZzX29mZiA9IGR3X2VkbWFfdjBfY29yZV9kZWJ1Z2ZzX29mZiwK K307CisKIHN0YXRpYyBpbmxpbmUKIHN0cnVjdCBkZXZpY2UgKmRjaGFuMmRldihzdHJ1Y3QgZG1h X2NoYW4gKmRjaGFuKQogewpAQCAtODAyLDEwICs4MTksMTQgQEAgaW50IGR3X2VkbWFfcHJvYmUo c3RydWN0IGR3X2VkbWFfY2hpcCAqY2hpcCkKIAogCS8qIENhbGxiYWNrIG9wZXJhdGlvbiBzZWxl Y3Rpb24gYWNjb3JkaW5nbHkgdG8gZURNQSB2ZXJzaW9uICovCiAJc3dpdGNoIChkdy0+dmVyc2lv bikgeworCWNhc2UgMDoKKwkJb3BzID0gJmR3X2VkbWFfdjBfY29yZV9vcHM7CisJCWJyZWFrOwog CWRlZmF1bHQ6CiAJCWRldl9lcnIoZGV2LCAidW5zdXBwb3J0ZWQgdmVyc2lvblxuIik7CiAJCXJl dHVybiAtRVBFUk07CiAJfQorCWR3LT5vcHMgPSBvcHM7CiAKIAlwbV9ydW50aW1lX2dldF9zeW5j KGRldik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRtYS12MC1jb3Jl LmMgYi9kcml2ZXJzL2RtYS9kdy1lZG1hL2R3LWVkbWEtdjAtY29yZS5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjViNzZlNDIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L2RtYS9kdy1lZG1hL2R3LWVkbWEtdjAtY29yZS5jCkBAIC0wLDAgKzEsMzQ2IEBACisvLyBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAxOCBT eW5vcHN5cywgSW5jLiBhbmQvb3IgaXRzIGFmZmlsaWF0ZXMuCisgKiBTeW5vcHN5cyBEZXNpZ25X YXJlIGVETUEgdjAgY29yZQorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRmaWVsZC5oPgorCisj aW5jbHVkZSAiZHctZWRtYS1jb3JlLmgiCisjaW5jbHVkZSAiZHctZWRtYS12MC1jb3JlLmgiCisj aW5jbHVkZSAiZHctZWRtYS12MC1yZWdzLmgiCisjaW5jbHVkZSAiZHctZWRtYS12MC1kZWJ1Z2Zz LmgiCisKK2VudW0gZHdfZWRtYV9jb250cm9sIHsKKwlEV19FRE1BX1YwX0NCCQkJCQk9IEJJVCgw KSwKKwlEV19FRE1BX1YwX1RDQgkJCQkJPSBCSVQoMSksCisJRFdfRURNQV9WMF9MTFAJCQkJCT0g QklUKDIpLAorCURXX0VETUFfVjBfTElFCQkJCQk9IEJJVCgzKSwKKwlEV19FRE1BX1YwX1JJRQkJ CQkJPSBCSVQoNCksCisJRFdfRURNQV9WMF9DQ1MJCQkJCT0gQklUKDgpLAorCURXX0VETUFfVjBf TExFCQkJCQk9IEJJVCg5KSwKK307CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGR3X2VkbWFfdjBf cmVncyBfX2lvbWVtICpfX2R3X3JlZ3Moc3RydWN0IGR3X2VkbWEgKmR3KQoreworCXJldHVybiAo c3RydWN0IGR3X2VkbWFfdjBfcmVncyBfX2lvbWVtICopZHctPnJnX3JlZ2lvbi52YWRkcjsKK30K KworI2RlZmluZSBTRVQoZHcsIG5hbWUsIHZhbHVlKQkJCQlcCisJd3JpdGVsKHZhbHVlLCAmKF9f ZHdfcmVncyhkdyktPm5hbWUpKQorCisjZGVmaW5lIEdFVChkdywgbmFtZSkJCQkJCVwKKwlyZWFk bCgmKF9fZHdfcmVncyhkdyktPm5hbWUpKQorCisjZGVmaW5lIFNFVF9SVyhkdywgZGlyLCBuYW1l LCB2YWx1ZSkJCQlcCisJZG8gewkJCQkJCVwKKwkJaWYgKChkaXIpID09IEVETUFfRElSX1dSSVRF KQkJXAorCQkJU0VUKGR3LCB3cl8jI25hbWUsIHZhbHVlKTsJXAorCQllbHNlCQkJCQlcCisJCQlT RVQoZHcsIHJkXyMjbmFtZSwgdmFsdWUpOwlcCisJfSB3aGlsZSAoMCkKKworI2RlZmluZSBHRVRf UlcoZHcsIGRpciwgbmFtZSkJCQkJXAorCSgoZGlyKSA9PSBFRE1BX0RJUl9XUklURQkJCVwKKwkg ID8gR0VUKGR3LCB3cl8jI25hbWUpCQkJCVwKKwkgIDogR0VUKGR3LCByZF8jI25hbWUpKQorCisj ZGVmaW5lIFNFVF9CT1RIKGR3LCBuYW1lLCB2YWx1ZSkJCQlcCisJZG8gewkJCQkJCVwKKwkJU0VU KGR3LCB3cl8jI25hbWUsIHZhbHVlKTsJCVwKKwkJU0VUKGR3LCByZF8jI25hbWUsIHZhbHVlKTsJ CVwKKwl9IHdoaWxlICgwKQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBkd19lZG1hX3YwX2NoX3Jl Z3MgX19pb21lbSAqCitfX2R3X2NoX3JlZ3Moc3RydWN0IGR3X2VkbWEgKmR3LCBlbnVtIGR3X2Vk bWFfZGlyIGRpciwgdTE2IGNoKQoreworCWlmIChkdy0+bW9kZSA9PSBFRE1BX01PREVfTEVHQUNZ KQorCQlyZXR1cm4gJihfX2R3X3JlZ3MoZHcpLT50eXBlLmxlZ2FjeS5jaCk7CisKKwlpZiAoZGly ID09IEVETUFfRElSX1dSSVRFKQorCQlyZXR1cm4gJl9fZHdfcmVncyhkdyktPnR5cGUudW5yb2xs LmNoW2NoXS53cjsKKworCXJldHVybiAmX19kd19yZWdzKGR3KS0+dHlwZS51bnJvbGwuY2hbY2hd LnJkOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3JpdGVsX2NoKHN0cnVjdCBkd19lZG1hICpk dywgZW51bSBkd19lZG1hX2RpciBkaXIsIHUxNiBjaCwKKwkJCSAgICAgdTMyIHZhbHVlLCB2b2lk IF9faW9tZW0gKmFkZHIpCit7CisJaWYgKGR3LT5tb2RlID09IEVETUFfTU9ERV9MRUdBQ1kpIHsK KwkJdTMyIHZpZXdwb3J0X3NlbDsKKwkJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCQlyYXdfc3Bp bl9sb2NrX2lycXNhdmUoJmR3LT5sb2NrLCBmbGFncyk7CisKKwkJdmlld3BvcnRfc2VsID0gRklF TERfUFJFUChFRE1BX1YwX1ZJRVdQT1JUX01BU0ssIGNoKTsKKwkJaWYgKGRpciA9PSBFRE1BX0RJ Ul9SRUFEKQorCQkJdmlld3BvcnRfc2VsIHw9IEJJVCgzMSk7CisKKwkJd3JpdGVsKHZpZXdwb3J0 X3NlbCwKKwkJICAgICAgICYoX19kd19yZWdzKGR3KS0+dHlwZS5sZWdhY3kudmlld3BvcnRfc2Vs KSk7CisJCXdyaXRlbCh2YWx1ZSwgYWRkcik7CisKKwkJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3Rv cmUoJmR3LT5sb2NrLCBmbGFncyk7CisJfSBlbHNlIHsKKwkJd3JpdGVsKHZhbHVlLCBhZGRyKTsK Kwl9Cit9CisKK3N0YXRpYyBpbmxpbmUgdTMyIHJlYWRsX2NoKHN0cnVjdCBkd19lZG1hICpkdywg ZW51bSBkd19lZG1hX2RpciBkaXIsIHUxNiBjaCwKKwkJCSAgIGNvbnN0IHZvaWQgX19pb21lbSAq YWRkcikKK3sKKwl1MzIgdmFsdWU7CisKKwlpZiAoZHctPm1vZGUgPT0gRURNQV9NT0RFX0xFR0FD WSkgeworCQl1MzIgdmlld3BvcnRfc2VsOworCQl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJCXJh d19zcGluX2xvY2tfaXJxc2F2ZSgmZHctPmxvY2ssIGZsYWdzKTsKKworCQl2aWV3cG9ydF9zZWwg PSBGSUVMRF9QUkVQKEVETUFfVjBfVklFV1BPUlRfTUFTSywgY2gpOworCQlpZiAoZGlyID09IEVE TUFfRElSX1JFQUQpCisJCQl2aWV3cG9ydF9zZWwgfD0gQklUKDMxKTsKKworCQl3cml0ZWwodmll d3BvcnRfc2VsLAorCQkgICAgICAgJihfX2R3X3JlZ3MoZHcpLT50eXBlLmxlZ2FjeS52aWV3cG9y dF9zZWwpKTsKKwkJdmFsdWUgPSByZWFkbChhZGRyKTsKKworCQlyYXdfc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmZHctPmxvY2ssIGZsYWdzKTsKKwl9IGVsc2UgeworCQl2YWx1ZSA9IHJlYWRsKGFk ZHIpOworCX0KKworCXJldHVybiB2YWx1ZTsKK30KKworI2RlZmluZSBTRVRfQ0goZHcsIGRpciwg Y2gsIG5hbWUsIHZhbHVlKSBcCisJd3JpdGVsX2NoKGR3LCBkaXIsIGNoLCB2YWx1ZSwgJihfX2R3 X2NoX3JlZ3MoZHcsIGRpciwgY2gpLT5uYW1lKSkKKworI2RlZmluZSBHRVRfQ0goZHcsIGRpciwg Y2gsIG5hbWUpIFwKKwlyZWFkbF9jaChkdywgZGlyLCBjaCwgJihfX2R3X2NoX3JlZ3MoZHcsIGRp ciwgY2gpLT5uYW1lKSkKKworI2RlZmluZSBTRVRfTEwobGwsIHZhbHVlKSBcCisJd3JpdGVsKHZh bHVlLCBsbCkKKworLyogZURNQSBtYW5hZ2VtZW50IGNhbGxiYWNrcyAqLwordm9pZCBkd19lZG1h X3YwX2NvcmVfb2ZmKHN0cnVjdCBkd19lZG1hICpkdykKK3sKKwlTRVRfQk9USChkdywgaW50X21h c2ssIEVETUFfVjBfRE9ORV9JTlRfTUFTSyB8IEVETUFfVjBfQUJPUlRfSU5UX01BU0spOworCVNF VF9CT1RIKGR3LCBpbnRfY2xlYXIsIEVETUFfVjBfRE9ORV9JTlRfTUFTSyB8IEVETUFfVjBfQUJP UlRfSU5UX01BU0spOworCVNFVF9CT1RIKGR3LCBlbmdpbmVfZW4sIDApOworfQorCit1MTYgZHdf ZWRtYV92MF9jb3JlX2NoX2NvdW50KHN0cnVjdCBkd19lZG1hICpkdywgZW51bSBkd19lZG1hX2Rp ciBkaXIpCit7CisJdTMyIG51bV9jaDsKKworCWlmIChkaXIgPT0gRURNQV9ESVJfV1JJVEUpCisJ CW51bV9jaCA9IEZJRUxEX0dFVChFRE1BX1YwX1dSSVRFX0NIX0NPVU5UX01BU0ssIEdFVChkdywg Y3RybCkpOworCWVsc2UKKwkJbnVtX2NoID0gRklFTERfR0VUKEVETUFfVjBfUkVBRF9DSF9DT1VO VF9NQVNLLCBHRVQoZHcsIGN0cmwpKTsKKworCWlmIChudW1fY2ggPiBFRE1BX1YwX01BWF9OUl9D SCkKKwkJbnVtX2NoID0gRURNQV9WMF9NQVhfTlJfQ0g7CisKKwlyZXR1cm4gKHUxNiludW1fY2g7 Cit9CisKK2VudW0gZG1hX3N0YXR1cyBkd19lZG1hX3YwX2NvcmVfY2hfc3RhdHVzKHN0cnVjdCBk d19lZG1hX2NoYW4gKmNoYW4pCit7CisJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hhbi0+Y2hpcC0+ ZHc7CisJdTMyIHRtcDsKKworCXRtcCA9IEZJRUxEX0dFVChFRE1BX1YwX0NIX1NUQVRVU19NQVNL LAorCQkJR0VUX0NIKGR3LCBjaGFuLT5kaXIsIGNoYW4tPmlkLCBjaF9jb250cm9sMSkpOworCisJ aWYgKHRtcCA9PSAxKQorCQlyZXR1cm4gRE1BX0lOX1BST0dSRVNTOworCWVsc2UgaWYgKHRtcCA9 PSAzKQorCQlyZXR1cm4gRE1BX0NPTVBMRVRFOworCWVsc2UKKwkJcmV0dXJuIERNQV9FUlJPUjsK K30KKwordm9pZCBkd19lZG1hX3YwX2NvcmVfY2xlYXJfZG9uZV9pbnQoc3RydWN0IGR3X2VkbWFf Y2hhbiAqY2hhbikKK3sKKwlzdHJ1Y3QgZHdfZWRtYSAqZHcgPSBjaGFuLT5jaGlwLT5kdzsKKwor CVNFVF9SVyhkdywgY2hhbi0+ZGlyLCBpbnRfY2xlYXIsCisJICAgICAgIEZJRUxEX1BSRVAoRURN QV9WMF9ET05FX0lOVF9NQVNLLCBCSVQoY2hhbi0+aWQpKSk7Cit9CisKK3ZvaWQgZHdfZWRtYV92 MF9jb3JlX2NsZWFyX2Fib3J0X2ludChzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuKQoreworCXN0 cnVjdCBkd19lZG1hICpkdyA9IGNoYW4tPmNoaXAtPmR3OworCisJU0VUX1JXKGR3LCBjaGFuLT5k aXIsIGludF9jbGVhciwKKwkgICAgICAgRklFTERfUFJFUChFRE1BX1YwX0FCT1JUX0lOVF9NQVNL LCBCSVQoY2hhbi0+aWQpKSk7Cit9CisKK3UzMiBkd19lZG1hX3YwX2NvcmVfc3RhdHVzX2RvbmVf aW50KHN0cnVjdCBkd19lZG1hICpkdywgZW51bSBkd19lZG1hX2RpciBkaXIpCit7CisJcmV0dXJu IEZJRUxEX0dFVChFRE1BX1YwX0RPTkVfSU5UX01BU0ssIEdFVF9SVyhkdywgZGlyLCBpbnRfc3Rh dHVzKSk7Cit9CisKK3UzMiBkd19lZG1hX3YwX2NvcmVfc3RhdHVzX2Fib3J0X2ludChzdHJ1Y3Qg ZHdfZWRtYSAqZHcsIGVudW0gZHdfZWRtYV9kaXIgZGlyKQoreworCXJldHVybiBGSUVMRF9HRVQo RURNQV9WMF9BQk9SVF9JTlRfTUFTSywgR0VUX1JXKGR3LCBkaXIsIGludF9zdGF0dXMpKTsKK30K Kworc3RhdGljIHZvaWQgZHdfZWRtYV92MF9jb3JlX3dyaXRlX2NodW5rKHN0cnVjdCBkd19lZG1h X2NodW5rICpjaHVuaykKK3sKKwlzdHJ1Y3QgZHdfZWRtYV9idXJzdCAqY2hpbGQ7CisJc3RydWN0 IGR3X2VkbWFfdjBfbGxpICpsbGk7CisJc3RydWN0IGR3X2VkbWFfdjBfbGxwICpsbHA7CisJdTMy IGNvbnRyb2wgPSAwLCBpID0gMDsKKwl1NjQgc2FyLCBkYXIsIGFkZHI7CisJaW50IGo7CisKKwls bGkgPSAoc3RydWN0IGR3X2VkbWFfdjBfbGxpICopY2h1bmstPmxsX3JlZ2lvbi52YWRkcjsKKwor CWlmIChjaHVuay0+Y2IpCisJCWNvbnRyb2wgPSBEV19FRE1BX1YwX0NCOworCisJaiA9IGNodW5r LT5idXJzdHNfYWxsb2M7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShjaGlsZCwgJmNodW5rLT5idXJz dC0+bGlzdCwgbGlzdCkgeworCQlqLS07CisJCWlmICghaikKKwkJCWNvbnRyb2wgfD0gKERXX0VE TUFfVjBfTElFIHwgRFdfRURNQV9WMF9SSUUpOworCisJCS8qIENoYW5uZWwgY29udHJvbCAqLwor CQlTRVRfTEwoJmxsaVtpXS5jb250cm9sLCBjb250cm9sKTsKKwkJLyogVHJhbnNmZXIgc2l6ZSAq LworCQlTRVRfTEwoJmxsaVtpXS50cmFuc2Zlcl9zaXplLCBjaGlsZC0+c3opOworCQkvKiBTQVIg LSBsb3csIGhpZ2ggKi8KKwkJc2FyID0gY3B1X3RvX2xlNjQoY2hpbGQtPnNhcik7CisJCVNFVF9M TCgmbGxpW2ldLnNhcl9sb3csIGxvd2VyXzMyX2JpdHMoc2FyKSk7CisJCVNFVF9MTCgmbGxpW2ld LnNhcl9oaWdoLCB1cHBlcl8zMl9iaXRzKHNhcikpOworCQkvKiBEQVIgLSBsb3csIGhpZ2ggKi8K KwkJZGFyID0gY3B1X3RvX2xlNjQoY2hpbGQtPmRhcik7CisJCVNFVF9MTCgmbGxpW2ldLmRhcl9s b3csIGxvd2VyXzMyX2JpdHMoZGFyKSk7CisJCVNFVF9MTCgmbGxpW2ldLmRhcl9oaWdoLCB1cHBl cl8zMl9iaXRzKGRhcikpOworCQlpKys7CisJfQorCisJbGxwID0gKHN0cnVjdCBkd19lZG1hX3Yw X2xscCAqKSZsbGlbaV07CisJY29udHJvbCA9IERXX0VETUFfVjBfTExQIHwgRFdfRURNQV9WMF9U Q0I7CisJaWYgKCFjaHVuay0+Y2IpCisJCWNvbnRyb2wgfD0gRFdfRURNQV9WMF9DQjsKKworCS8q IENoYW5uZWwgY29udHJvbCAqLworCVNFVF9MTCgmbGxwLT5jb250cm9sLCBjb250cm9sKTsKKwkv KiBMaW5rZWQgbGlzdCAgLSBsb3csIGhpZ2ggKi8KKwlhZGRyID0gY3B1X3RvX2xlNjQoY2h1bmst PmxsX3JlZ2lvbi5wYWRkcik7CisJU0VUX0xMKCZsbHAtPmxscF9sb3csIGxvd2VyXzMyX2JpdHMo YWRkcikpOworCVNFVF9MTCgmbGxwLT5sbHBfaGlnaCwgdXBwZXJfMzJfYml0cyhhZGRyKSk7Cit9 CisKK3ZvaWQgZHdfZWRtYV92MF9jb3JlX3N0YXJ0KHN0cnVjdCBkd19lZG1hX2NodW5rICpjaHVu aywgYm9vbCBmaXJzdCkKK3sKKwlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuID0gY2h1bmstPmNo YW47CisJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hhbi0+Y2hpcC0+ZHc7CisJdTMyIHRtcDsKKwl1 NjQgbGxwOworCisJZHdfZWRtYV92MF9jb3JlX3dyaXRlX2NodW5rKGNodW5rKTsKKworCWlmIChm aXJzdCkgeworCQkvKiBFbmFibGUgZW5naW5lICovCisJCVNFVF9SVyhkdywgY2hhbi0+ZGlyLCBl bmdpbmVfZW4sIEJJVCgwKSk7CisJCS8qIEludGVycnVwdCB1bm1hc2sgLSBkb25lLCBhYm9ydCAq LworCQl0bXAgPSBHRVRfUlcoZHcsIGNoYW4tPmRpciwgaW50X21hc2spOworCQl0bXAgJj0gfkZJ RUxEX1BSRVAoRURNQV9WMF9ET05FX0lOVF9NQVNLLCBCSVQoY2hhbi0+aWQpKTsKKwkJdG1wICY9 IH5GSUVMRF9QUkVQKEVETUFfVjBfQUJPUlRfSU5UX01BU0ssIEJJVChjaGFuLT5pZCkpOworCQlT RVRfUlcoZHcsIGNoYW4tPmRpciwgaW50X21hc2ssIHRtcCk7CisJCS8qIExpbmtlZCBsaXN0IGVy cm9yICovCisJCXRtcCA9IEdFVF9SVyhkdywgY2hhbi0+ZGlyLCBsaW5rZWRfbGlzdF9lcnJfZW4p OworCQl0bXAgfD0gRklFTERfUFJFUChFRE1BX1YwX0xJTktFRF9MSVNUX0VSUl9NQVNLLCBCSVQo Y2hhbi0+aWQpKTsKKwkJU0VUX1JXKGR3LCBjaGFuLT5kaXIsIGxpbmtlZF9saXN0X2Vycl9lbiwg dG1wKTsKKwkJLyogQ2hhbm5lbCBjb250cm9sICovCisJCVNFVF9DSChkdywgY2hhbi0+ZGlyLCBj aGFuLT5pZCwgY2hfY29udHJvbDEsCisJCSAgICAgICAoRFdfRURNQV9WMF9DQ1MgfCBEV19FRE1B X1YwX0xMRSkpOworCQkvKiBMaW5rZWQgbGlzdCAtIGxvdywgaGlnaCAqLworCQlsbHAgPSBjcHVf dG9fbGU2NChjaHVuay0+bGxfcmVnaW9uLnBhZGRyKTsKKwkJU0VUX0NIKGR3LCBjaGFuLT5kaXIs IGNoYW4tPmlkLCBsbHBfbG93LCBsb3dlcl8zMl9iaXRzKGxscCkpOworCQlTRVRfQ0goZHcsIGNo YW4tPmRpciwgY2hhbi0+aWQsIGxscF9oaWdoLCB1cHBlcl8zMl9iaXRzKGxscCkpOworCX0KKwkv KiBEb29yYmVsbCAqLworCVNFVF9SVyhkdywgY2hhbi0+ZGlyLCBkb29yYmVsbCwKKwkgICAgICAg RklFTERfUFJFUChFRE1BX1YwX0RPT1JCRUxMX0NIX01BU0ssIGNoYW4tPmlkKSk7Cit9CisKK2lu dCBkd19lZG1hX3YwX2NvcmVfZGV2aWNlX2NvbmZpZyhzdHJ1Y3QgZG1hX2NoYW4gKmRjaGFuKQor eworCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4gPSBkY2hhbjJkd19lZG1hX2NoYW4oZGNoYW4p OworCXN0cnVjdCBkd19lZG1hICpkdyA9IGNoYW4tPmNoaXAtPmR3OworCXUzMiB0bXAgPSAwOwor CisJLyogTVNJIGRvbmUgYWRkciAtIGxvdywgaGlnaCAqLworCVNFVF9SVyhkdywgY2hhbi0+ZGly LCBkb25lX2ltd3JfbG93LCBjaGFuLT5tc2kuYWRkcmVzc19sbyk7CisJU0VUX1JXKGR3LCBjaGFu LT5kaXIsIGRvbmVfaW13cl9oaWdoLCBjaGFuLT5tc2kuYWRkcmVzc19oaSk7CisJLyogTVNJIGFi b3J0IGFkZHIgLSBsb3csIGhpZ2ggKi8KKwlTRVRfUlcoZHcsIGNoYW4tPmRpciwgYWJvcnRfaW13 cl9sb3csIGNoYW4tPm1zaS5hZGRyZXNzX2xvKTsKKwlTRVRfUlcoZHcsIGNoYW4tPmRpciwgYWJv cnRfaW13cl9oaWdoLCBjaGFuLT5tc2kuYWRkcmVzc19oaSk7CisJLyogTVNJIGRhdGEgLSBsb3cs IGhpZ2ggKi8KKwlzd2l0Y2ggKGNoYW4tPmlkKSB7CisJY2FzZSAwOgorCWNhc2UgMToKKwkJdG1w ID0gR0VUX1JXKGR3LCBjaGFuLT5kaXIsIGNoMDFfaW13cl9kYXRhKTsKKwkJYnJlYWs7CisJY2Fz ZSAyOgorCWNhc2UgMzoKKwkJdG1wID0gR0VUX1JXKGR3LCBjaGFuLT5kaXIsIGNoMjNfaW13cl9k YXRhKTsKKwkJYnJlYWs7CisJY2FzZSA0OgorCWNhc2UgNToKKwkJdG1wID0gR0VUX1JXKGR3LCBj aGFuLT5kaXIsIGNoNDVfaW13cl9kYXRhKTsKKwkJYnJlYWs7CisJY2FzZSA2OgorCWNhc2UgNzoK KwkJdG1wID0gR0VUX1JXKGR3LCBjaGFuLT5kaXIsIGNoNjdfaW13cl9kYXRhKTsKKwkJYnJlYWs7 CisJfQorCisJaWYgKGNoYW4tPmlkICYgQklUKDApKSB7CisJCS8qIENoYW5uZWwgb2RkIHsxLCAz LCA1LCA3fSAqLworCQl0bXAgJj0gRURNQV9WMF9DSF9FVkVOX01TSV9EQVRBX01BU0s7CisJCXRt cCB8PSBGSUVMRF9QUkVQKEVETUFfVjBfQ0hfT0REX01TSV9EQVRBX01BU0ssCisJCQkJICBjaGFu LT5tc2kuZGF0YSk7CisJfSBlbHNlIHsKKwkJLyogQ2hhbm5lbCBldmVuIHswLCAyLCA0LCA2fSAq LworCQl0bXAgJj0gRURNQV9WMF9DSF9PRERfTVNJX0RBVEFfTUFTSzsKKwkJdG1wIHw9IEZJRUxE X1BSRVAoRURNQV9WMF9DSF9FVkVOX01TSV9EQVRBX01BU0ssCisJCQkJICBjaGFuLT5tc2kuZGF0 YSk7CisJfQorCisJc3dpdGNoIChjaGFuLT5pZCkgeworCWNhc2UgMDoKKwljYXNlIDE6CisJCVNF VF9SVyhkdywgY2hhbi0+ZGlyLCBjaDAxX2ltd3JfZGF0YSwgdG1wKTsKKwkJYnJlYWs7CisJY2Fz ZSAyOgorCWNhc2UgMzoKKwkJU0VUX1JXKGR3LCBjaGFuLT5kaXIsIGNoMjNfaW13cl9kYXRhLCB0 bXApOworCQlicmVhazsKKwljYXNlIDQ6CisJY2FzZSA1OgorCQlTRVRfUlcoZHcsIGNoYW4tPmRp ciwgY2g0NV9pbXdyX2RhdGEsIHRtcCk7CisJCWJyZWFrOworCWNhc2UgNjoKKwljYXNlIDc6CisJ CVNFVF9SVyhkdywgY2hhbi0+ZGlyLCBjaDY3X2ltd3JfZGF0YSwgdG1wKTsKKwkJYnJlYWs7CisJ fQorCisJcmV0dXJuIDA7Cit9CisKKy8qIGVETUEgZGVidWdmcyBjYWxsYmFja3MgKi8KK2ludCBk d19lZG1hX3YwX2NvcmVfZGVidWdmc19vbihzdHJ1Y3QgZHdfZWRtYV9jaGlwICpjaGlwKQorewor CXJldHVybiAwOworfQorCit2b2lkIGR3X2VkbWFfdjBfY29yZV9kZWJ1Z2ZzX29mZih2b2lkKQor eworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZHctZWRtYS9kdy1lZG1hLXYwLWNvcmUuaCBi L2RyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRtYS12MC1jb3JlLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uMmQzNWJmZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZG1h L2R3LWVkbWEvZHctZWRtYS12MC1jb3JlLmgKQEAgLTAsMCArMSwyNiBAQAorLyogU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMTggU3lu b3BzeXMsIEluYy4gYW5kL29yIGl0cyBhZmZpbGlhdGVzLgorICogU3lub3BzeXMgRGVzaWduV2Fy ZSBlRE1BIHYwIGNvcmUKKyAqLworCisjaWZuZGVmIF9EV19FRE1BX1YwX0NPUkVfSAorI2RlZmlu ZSBfRFdfRURNQV9WMF9DT1JFX0gKKworI2luY2x1ZGUgPGxpbnV4L2RtYS9lZG1hLmg+CisKKy8q IGVETUEgbWFuYWdlbWVudCBjYWxsYmFja3MgKi8KK3ZvaWQgZHdfZWRtYV92MF9jb3JlX29mZihz dHJ1Y3QgZHdfZWRtYSAqY2hhbik7Cit1MTYgZHdfZWRtYV92MF9jb3JlX2NoX2NvdW50KHN0cnVj dCBkd19lZG1hICpjaGFuLCBlbnVtIGR3X2VkbWFfZGlyIGRpcik7CitlbnVtIGRtYV9zdGF0dXMg ZHdfZWRtYV92MF9jb3JlX2NoX3N0YXR1cyhzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuKTsKK3Zv aWQgZHdfZWRtYV92MF9jb3JlX2NsZWFyX2RvbmVfaW50KHN0cnVjdCBkd19lZG1hX2NoYW4gKmNo YW4pOwordm9pZCBkd19lZG1hX3YwX2NvcmVfY2xlYXJfYWJvcnRfaW50KHN0cnVjdCBkd19lZG1h X2NoYW4gKmNoYW4pOwordTMyIGR3X2VkbWFfdjBfY29yZV9zdGF0dXNfZG9uZV9pbnQoc3RydWN0 IGR3X2VkbWEgKmNoYW4sIGVudW0gZHdfZWRtYV9kaXIgZGlyKTsKK3UzMiBkd19lZG1hX3YwX2Nv cmVfc3RhdHVzX2Fib3J0X2ludChzdHJ1Y3QgZHdfZWRtYSAqY2hhbiwgZW51bSBkd19lZG1hX2Rp ciBkaXIpOwordm9pZCBkd19lZG1hX3YwX2NvcmVfc3RhcnQoc3RydWN0IGR3X2VkbWFfY2h1bmsg KmNodW5rLCBib29sIGZpcnN0KTsKK2ludCBkd19lZG1hX3YwX2NvcmVfZGV2aWNlX2NvbmZpZyhz dHJ1Y3QgZG1hX2NoYW4gKmRjaGFuKTsKKy8qIGVETUEgZGVidWcgZnMgY2FsbGJhY2tzICovCitp bnQgZHdfZWRtYV92MF9jb3JlX2RlYnVnZnNfb24oc3RydWN0IGR3X2VkbWFfY2hpcCAqY2hpcCk7 Cit2b2lkIGR3X2VkbWFfdjBfY29yZV9kZWJ1Z2ZzX29mZih2b2lkKTsKKworI2VuZGlmIC8qIF9E V19FRE1BX1YwX0NPUkVfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZHctZWRtYS9kdy1l ZG1hLXYwLXJlZ3MuaCBiL2RyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRtYS12MC1yZWdzLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWIwNDcxNQotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRtYS12MC1yZWdzLmgKQEAgLTAsMCArMSwxNTYg QEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCisvKgorICogQ29weXJp Z2h0IChjKSAyMDE4IFN5bm9wc3lzLCBJbmMuIGFuZC9vciBpdHMgYWZmaWxpYXRlcy4KKyAqIFN5 bm9wc3lzIERlc2lnbldhcmUgZURNQSB2MCBjb3JlCisgKi8KKworI2lmbmRlZiBfRFdfRURNQV9W MF9SRUdTX0gKKyNkZWZpbmUgX0RXX0VETUFfVjBfUkVHU19ICisKKyNpbmNsdWRlIDxsaW51eC9k bWFlbmdpbmUuaD4KKworI2RlZmluZSBFRE1BX1YwX01BWF9OUl9DSAkJCQk4CisjZGVmaW5lIEVE TUFfVjBfVklFV1BPUlRfTUFTSwkJCQlHRU5NQVNLKDIsIDApCisjZGVmaW5lIEVETUFfVjBfRE9O RV9JTlRfTUFTSwkJCQlHRU5NQVNLKDcsIDApCisjZGVmaW5lIEVETUFfVjBfQUJPUlRfSU5UX01B U0sJCQkJR0VOTUFTSygyMywgMTYpCisjZGVmaW5lIEVETUFfVjBfV1JJVEVfQ0hfQ09VTlRfTUFT SwkJCUdFTk1BU0soMywgMCkKKyNkZWZpbmUgRURNQV9WMF9SRUFEX0NIX0NPVU5UX01BU0sJCQlH RU5NQVNLKDE5LCAxNikKKyNkZWZpbmUgRURNQV9WMF9DSF9TVEFUVVNfTUFTSwkJCQlHRU5NQVNL KDYsIDUpCisjZGVmaW5lIEVETUFfVjBfRE9PUkJFTExfQ0hfTUFTSwkJCUdFTk1BU0soMiwgMCkK KyNkZWZpbmUgRURNQV9WMF9MSU5LRURfTElTVF9FUlJfTUFTSwkJCUdFTk1BU0soNywgMCkKKwor I2RlZmluZSBFRE1BX1YwX0NIX09ERF9NU0lfREFUQV9NQVNLCQkJR0VOTUFTSygxNSwgOCkKKyNk ZWZpbmUgRURNQV9WMF9DSF9FVkVOX01TSV9EQVRBX01BU0sJCQlHRU5NQVNLKDcsIDApCisKK3N0 cnVjdCBkd19lZG1hX3YwX2NoX3JlZ3MgeworCXUzMiBjaF9jb250cm9sMTsJCQkJLyogMHgwMDAg Ki8KKwl1MzIgY2hfY29udHJvbDI7CQkJCS8qIDB4MDA0ICovCisJdTMyIHRyYW5zZmVyX3NpemU7 CQkJCS8qIDB4MDA4ICovCisJdTMyIHNhcl9sb3c7CQkJCQkvKiAweDAwYyAqLworCXUzMiBzYXJf aGlnaDsJCQkJCS8qIDB4MDEwICovCisJdTMyIGRhcl9sb3c7CQkJCQkvKiAweDAxNCAqLworCXUz MiBkYXJfaGlnaDsJCQkJCS8qIDB4MDE4ICovCisJdTMyIGxscF9sb3c7CQkJCQkvKiAweDAxYyAq LworCXUzMiBsbHBfaGlnaDsJCQkJCS8qIDB4MDIwICovCit9OworCitzdHJ1Y3QgZHdfZWRtYV92 MF9jaCB7CisJc3RydWN0IGR3X2VkbWFfdjBfY2hfcmVncyB3cjsJCQkvKiAweDIwMCAqLworCXUz MiBwYWRkaW5nXzFbNTVdOwkJCQkvKiBbMHgyMjQuLjB4MmZjXSAqLworCXN0cnVjdCBkd19lZG1h X3YwX2NoX3JlZ3MgcmQ7CQkJLyogMHgzMDAgKi8KKwl1MzIgcGFkZGluZ18yWzU1XTsJCQkJLyog WzB4MjI0Li4weDJmY10gKi8KK307CisKK3N0cnVjdCBkd19lZG1hX3YwX3Vucm9sbCB7CisJdTMy IHBhZGRpbmdfMTsJCQkJCS8qIDB4MGY4ICovCisJdTMyIHdyX2VuZ2luZV9jaGdyb3VwOwkJCQkv KiAweDEwMCAqLworCXUzMiByZF9lbmdpbmVfY2hncm91cDsJCQkJLyogMHgxMDQgKi8KKwl1MzIg d3JfZW5naW5lX2hzaGFrZV9jbnRfbG93OwkJCS8qIDB4MTA4ICovCisJdTMyIHdyX2VuZ2luZV9o c2hha2VfY250X2hpZ2g7CQkJLyogMHgxMGMgKi8KKwl1MzIgcGFkZGluZ18yWzJdOwkJCQkvKiBb MHgxMTAuLjB4MTE0XSAqLworCXUzMiByZF9lbmdpbmVfaHNoYWtlX2NudF9sb3c7CQkJLyogMHgx MTggKi8KKwl1MzIgcmRfZW5naW5lX2hzaGFrZV9jbnRfaGlnaDsJCQkvKiAweDExYyAqLworCXUz MiBwYWRkaW5nXzNbMl07CQkJCS8qIFsweDEyMC4uMHgxMjRdICovCisJdTMyIHdyX2NoMF9wd3Jf ZW47CQkJCS8qIDB4MTI4ICovCisJdTMyIHdyX2NoMV9wd3JfZW47CQkJCS8qIDB4MTJjICovCisJ dTMyIHdyX2NoMl9wd3JfZW47CQkJCS8qIDB4MTMwICovCisJdTMyIHdyX2NoM19wd3JfZW47CQkJ CS8qIDB4MTM0ICovCisJdTMyIHdyX2NoNF9wd3JfZW47CQkJCS8qIDB4MTM4ICovCisJdTMyIHdy X2NoNV9wd3JfZW47CQkJCS8qIDB4MTNjICovCisJdTMyIHdyX2NoNl9wd3JfZW47CQkJCS8qIDB4 MTQwICovCisJdTMyIHdyX2NoN19wd3JfZW47CQkJCS8qIDB4MTQ0ICovCisJdTMyIHBhZGRpbmdf NFs4XTsJCQkJLyogWzB4MTQ4Li4weDE2NF0gKi8KKwl1MzIgcmRfY2gwX3B3cl9lbjsJCQkJLyog MHgxNjggKi8KKwl1MzIgcmRfY2gxX3B3cl9lbjsJCQkJLyogMHgxNmMgKi8KKwl1MzIgcmRfY2gy X3B3cl9lbjsJCQkJLyogMHgxNzAgKi8KKwl1MzIgcmRfY2gzX3B3cl9lbjsJCQkJLyogMHgxNzQg Ki8KKwl1MzIgcmRfY2g0X3B3cl9lbjsJCQkJLyogMHgxNzggKi8KKwl1MzIgcmRfY2g1X3B3cl9l bjsJCQkJLyogMHgxOGMgKi8KKwl1MzIgcmRfY2g2X3B3cl9lbjsJCQkJLyogMHgxODAgKi8KKwl1 MzIgcmRfY2g3X3B3cl9lbjsJCQkJLyogMHgxODQgKi8KKwl1MzIgcGFkZGluZ181WzMwXTsJCQkJ LyogWzB4MTg4Li4weDFmY10gKi8KKwlzdHJ1Y3QgZHdfZWRtYV92MF9jaCBjaFtFRE1BX1YwX01B WF9OUl9DSF07CS8qIFsweDIwMC4uMHgxMTIwXSAqLworfTsKKworc3RydWN0IGR3X2VkbWFfdjBf bGVnYWN5IHsKKwl1MzIgdmlld3BvcnRfc2VsOwkJCQkvKiAweDBmOCAqLworCXN0cnVjdCBkd19l ZG1hX3YwX2NoX3JlZ3MgY2g7CQkJLyogWzB4MTAwLi4weDEyMF0gKi8KK307CisKK3N0cnVjdCBk d19lZG1hX3YwX3JlZ3MgeworCS8qIGVETUEgZ2xvYmFsIHJlZ2lzdGVycyAqLworCXUzMiBjdHJs X2RhdGFfYXJiX3ByaW9yOwkJCS8qIDB4MDAwICovCisJdTMyIHBhZGRpbmdfMTsJCQkJCS8qIDB4 MDA0ICovCisJdTMyIGN0cmw7CQkJCQkvKiAweDAwOCAqLworCXUzMiB3cl9lbmdpbmVfZW47CQkJ CS8qIDB4MDBjICovCisJdTMyIHdyX2Rvb3JiZWxsOwkJCQkvKiAweDAxMCAqLworCXUzMiBwYWRk aW5nXzI7CQkJCQkvKiAweDAxNCAqLworCXUzMiB3cl9jaF9hcmJfd2VpZ2h0X2xvdzsJCQkvKiAw eDAxOCAqLworCXUzMiB3cl9jaF9hcmJfd2VpZ2h0X2hpZ2g7CQkJLyogMHgwMWMgKi8KKwl1MzIg cGFkZGluZ18zWzNdOwkJCQkvKiBbMHgwMjAuLjB4MDI4XSAqLworCXUzMiByZF9lbmdpbmVfZW47 CQkJCS8qIDB4MDJjICovCisJdTMyIHJkX2Rvb3JiZWxsOwkJCQkvKiAweDAzMCAqLworCXUzMiBw YWRkaW5nXzQ7CQkJCQkvKiAweDAzNCAqLworCXUzMiByZF9jaF9hcmJfd2VpZ2h0X2xvdzsJCQkv KiAweDAzOCAqLworCXUzMiByZF9jaF9hcmJfd2VpZ2h0X2hpZ2g7CQkJLyogMHgwM2MgKi8KKwl1 MzIgcGFkZGluZ181WzNdOwkJCQkvKiBbMHgwNDAuLjB4MDQ4XSAqLworCS8qIGVETUEgaW50ZXJy dXB0cyByZWdpc3RlcnMgKi8KKwl1MzIgd3JfaW50X3N0YXR1czsJCQkJLyogMHgwNGMgKi8KKwl1 MzIgcGFkZGluZ182OwkJCQkJLyogMHgwNTAgKi8KKwl1MzIgd3JfaW50X21hc2s7CQkJCS8qIDB4 MDU0ICovCisJdTMyIHdyX2ludF9jbGVhcjsJCQkJLyogMHgwNTggKi8KKwl1MzIgd3JfZXJyX3N0 YXR1czsJCQkJLyogMHgwNWMgKi8KKwl1MzIgd3JfZG9uZV9pbXdyX2xvdzsJCQkJLyogMHgwNjAg Ki8KKwl1MzIgd3JfZG9uZV9pbXdyX2hpZ2g7CQkJCS8qIDB4MDY0ICovCisJdTMyIHdyX2Fib3J0 X2ltd3JfbG93OwkJCQkvKiAweDA2OCAqLworCXUzMiB3cl9hYm9ydF9pbXdyX2hpZ2g7CQkJCS8q IDB4MDZjICovCisJdTMyIHdyX2NoMDFfaW13cl9kYXRhOwkJCQkvKiAweDA3MCAqLworCXUzMiB3 cl9jaDIzX2ltd3JfZGF0YTsJCQkJLyogMHgwNzQgKi8KKwl1MzIgd3JfY2g0NV9pbXdyX2RhdGE7 CQkJCS8qIDB4MDc4ICovCisJdTMyIHdyX2NoNjdfaW13cl9kYXRhOwkJCQkvKiAweDA3YyAqLwor CXUzMiBwYWRkaW5nXzdbNF07CQkJCS8qIFsweDA4MC4uMHgwOGNdICovCisJdTMyIHdyX2xpbmtl ZF9saXN0X2Vycl9lbjsJCQkvKiAweDA5MCAqLworCXUzMiBwYWRkaW5nXzhbM107CQkJCS8qIFsw eDA5NC4uMHgwOWNdICovCisJdTMyIHJkX2ludF9zdGF0dXM7CQkJCS8qIDB4MGEwICovCisJdTMy IHBhZGRpbmdfOTsJCQkJCS8qIDB4MGE0ICovCisJdTMyIHJkX2ludF9tYXNrOwkJCQkvKiAweDBh OCAqLworCXUzMiByZF9pbnRfY2xlYXI7CQkJCS8qIDB4MGFjICovCisJdTMyIHBhZGRpbmdfMTA7 CQkJCQkvKiAweDBiMCAqLworCXUzMiByZF9lcnJfc3RhdHVzX2xvdzsJCQkJLyogMHgwYjQgKi8K Kwl1MzIgcmRfZXJyX3N0YXR1c19oaWdoOwkJCQkvKiAweDBiOCAqLworCXUzMiBwYWRkaW5nXzEx WzJdOwkJCQkvKiBbMHgwYmMuLjB4MGMwXSAqLworCXUzMiByZF9saW5rZWRfbGlzdF9lcnJfZW47 CQkJLyogMHgwYzQgKi8KKwl1MzIgcGFkZGluZ18xMjsJCQkJCS8qIDB4MGM4ICovCisJdTMyIHJk X2RvbmVfaW13cl9sb3c7CQkJCS8qIDB4MGNjICovCisJdTMyIHJkX2RvbmVfaW13cl9oaWdoOwkJ CQkvKiAweDBkMCAqLworCXUzMiByZF9hYm9ydF9pbXdyX2xvdzsJCQkJLyogMHgwZDQgKi8KKwl1 MzIgcmRfYWJvcnRfaW13cl9oaWdoOwkJCQkvKiAweDBkOCAqLworCXUzMiByZF9jaDAxX2ltd3Jf ZGF0YTsJCQkJLyogMHgwZGMgKi8KKwl1MzIgcmRfY2gyM19pbXdyX2RhdGE7CQkJCS8qIDB4MGUw ICovCisJdTMyIHJkX2NoNDVfaW13cl9kYXRhOwkJCQkvKiAweDBlNCAqLworCXUzMiByZF9jaDY3 X2ltd3JfZGF0YTsJCQkJLyogMHgwZTggKi8KKwl1MzIgcGFkZGluZ18xM1s0XTsJCQkJLyogWzB4 MGVjLi4weDBmOF0gKi8KKwkvKiBlRE1BIGNoYW5uZWwgY29udGV4dCBncm91cGluZyAqLworCXVu aW9uIFR5cGUgeworCQlzdHJ1Y3QgZHdfZWRtYV92MF9sZWdhY3kgbGVnYWN5OwkvKiBbMHgwZjgu LjB4MTIwXSAqLworCQlzdHJ1Y3QgZHdfZWRtYV92MF91bnJvbGwgdW5yb2xsOwkvKiBbMHgwZjgu LjB4MTEyMF0gKi8KKwl9IHR5cGU7Cit9OworCitzdHJ1Y3QgZHdfZWRtYV92MF9sbGkgeworCXUz MiBjb250cm9sOworCXUzMiB0cmFuc2Zlcl9zaXplOworCXUzMiBzYXJfbG93OworCXUzMiBzYXJf aGlnaDsKKwl1MzIgZGFyX2xvdzsKKwl1MzIgZGFyX2hpZ2g7Cit9OworCitzdHJ1Y3QgZHdfZWRt YV92MF9sbHAgeworCXUzMiBjb250cm9sOworCXUzMiByZXNlcnZlZDsKKwl1MzIgbGxwX2xvdzsK Kwl1MzIgbGxwX2hpZ2g7Cit9OworCisjZW5kaWYgLyogX0RXX0VETUFfVjBfUkVHU19IICovCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E9C38C43444 for ; Fri, 11 Jan 2019 18:33:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id ABE9620872 for ; Fri, 11 Jan 2019 18:33:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=synopsys.com header.i=@synopsys.com header.b="O8BIVfKg" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387821AbfAKSd5 (ORCPT ); Fri, 11 Jan 2019 13:33:57 -0500 Received: from smtprelay.synopsys.com ([198.182.60.111]:50430 "EHLO smtprelay.synopsys.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732979AbfAKSdx (ORCPT ); Fri, 11 Jan 2019 13:33:53 -0500 Received: from mailhost.synopsys.com (mailhost1.synopsys.com [10.12.238.239]) by smtprelay.synopsys.com (Postfix) with ESMTP id C5DF710C0CB3; Fri, 11 Jan 2019 10:33:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=synopsys.com; s=mail; t=1547231632; bh=fhtIE+uLyqxd2WirTJv1fgixrAEoWENdX8V56Nlvq9A=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=O8BIVfKgYhPd1XUjOQ6assF0fiaU01QyakgD9JCG7asPxvD6K00hF15mjZqOrLCda 9WM91qWLkRg9jCsDykK2BnzC39ZtldhOdUn7AThvfaPogk/qlwmYwxYndNhG6ldUX8 Y3q7g/r4ALutULKvzJ2coRuqUiE1rpBdsDW/FOVJBAoZYx7e48SPm8L67+bx4WJlH6 QrJ4g8QfiZBIwuzZpFYbxvRd56AVHTkPaMouwOM/wjpMdLtCRXtA3chi53s/B/XLb8 5MaT3FLMyFE+u0vsrpPHrAieX0gUVLYuT8H9EgUrFnXfyB3F0p4a6/cZX+CHMhwbNm 1qwea92ZUZCjw== Received: from de02.synopsys.com (germany.internal.synopsys.com [10.225.17.21]) by mailhost.synopsys.com (Postfix) with ESMTP id 52AAF57A3; Fri, 11 Jan 2019 10:33:51 -0800 (PST) Received: from de02dwia024.internal.synopsys.com (de02dwia024.internal.synopsys.com [10.225.19.81]) by de02.synopsys.com (Postfix) with ESMTP id C01BF3ED88; Fri, 11 Jan 2019 19:33:50 +0100 (CET) From: Gustavo Pimentel To: linux-pci@vger.kernel.org, dmaengine@vger.kernel.org Cc: Gustavo Pimentel , Vinod Koul , Dan Williams , Eugeniy Paltsev , Andy Shevchenko , Russell King , Niklas Cassel , Joao Pinto , Jose Abreu , Luis Oliveira , Vitor Soares , Nelson Costa , Pedro Sousa Subject: [RFC v3 2/7] dmaengine: Add Synopsys eDMA IP version 0 support Date: Fri, 11 Jan 2019 19:33:38 +0100 Message-Id: X-Mailer: git-send-email 2.7.4 In-Reply-To: References: In-Reply-To: References: Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org Add support for the eDMA IP version 0 driver for both register maps (legacy and unroll). The legacy register mapping was the initial implementation, which consisted in having all registers belonging to channels multiplexed, which could be change anytime (which could led a race-condition) by view port register (access to only one channel available each time). This register mapping is not very effective and efficient in a multithread environment, which has led to the development of unroll registers mapping, which consists of having all channels registers accessible any time by spreading all channels registers by an offset between them. This version supports a maximum of 16 independent channels (8 write + 8 read), which can run simultaneously. Implements a scatter-gather transfer through a linked list, where the size of linked list depends on the allocated memory divided equally among all channels. Each linked list descriptor can transfer from 1 byte to 4 Gbytes and is alignmented to DWORD. Both SAR (Source Address Register) and DAR (Destination Address Register) are alignmented to byte. Changes: RFC v1->RFC v2: - Replace comments // (C99 style) by /**/ - Replace magic numbers by defines - Replace boolean return from ternary operation by a double negation operation - Replace QWORD_HI/QWORD_LO macros by upper_32_bits()/lower_32_bits() - Fix the headers of the .c and .h files according to the most recent convention - Fix errors and checks pointed out by checkpatch with --strict option - Replace patch small description tag from dma by dmaengine - Refactor code to replace atomic_t by u32 variable type RFC v2->RFC v3: - Code rewrite to use FIELD_PREP() and FIELD_GET() - Add define to magic numbers - Fix minor bugs Signed-off-by: Gustavo Pimentel Cc: Vinod Koul Cc: Dan Williams Cc: Eugeniy Paltsev Cc: Andy Shevchenko Cc: Russell King Cc: Niklas Cassel Cc: Joao Pinto Cc: Jose Abreu Cc: Luis Oliveira Cc: Vitor Soares Cc: Nelson Costa Cc: Pedro Sousa --- drivers/dma/dw-edma/Makefile | 3 +- drivers/dma/dw-edma/dw-edma-core.c | 21 +++ drivers/dma/dw-edma/dw-edma-v0-core.c | 346 ++++++++++++++++++++++++++++++++++ drivers/dma/dw-edma/dw-edma-v0-core.h | 26 +++ drivers/dma/dw-edma/dw-edma-v0-regs.h | 156 +++++++++++++++ 5 files changed, 551 insertions(+), 1 deletion(-) create mode 100644 drivers/dma/dw-edma/dw-edma-v0-core.c create mode 100644 drivers/dma/dw-edma/dw-edma-v0-core.h create mode 100644 drivers/dma/dw-edma/dw-edma-v0-regs.h diff --git a/drivers/dma/dw-edma/Makefile b/drivers/dma/dw-edma/Makefile index 3224010..01c7c63 100644 --- a/drivers/dma/dw-edma/Makefile +++ b/drivers/dma/dw-edma/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_DW_EDMA) += dw-edma.o -dw-edma-objs := dw-edma-core.o +dw-edma-objs := dw-edma-core.o \ + dw-edma-v0-core.o diff --git a/drivers/dma/dw-edma/dw-edma-core.c b/drivers/dma/dw-edma/dw-edma-core.c index 2b6b70f..772a22f 100644 --- a/drivers/dma/dw-edma/dw-edma-core.c +++ b/drivers/dma/dw-edma/dw-edma-core.c @@ -15,6 +15,7 @@ #include #include "dw-edma-core.h" +#include "dw-edma-v0-core.h" #include "../dmaengine.h" #include "../virt-dma.h" @@ -27,6 +28,22 @@ SET(dw->rd_edma, name, value); \ } while (0) +static const struct dw_edma_core_ops dw_edma_v0_core_ops = { + /* eDMA management callbacks */ + .off = dw_edma_v0_core_off, + .ch_count = dw_edma_v0_core_ch_count, + .ch_status = dw_edma_v0_core_ch_status, + .clear_done_int = dw_edma_v0_core_clear_done_int, + .clear_abort_int = dw_edma_v0_core_clear_abort_int, + .status_done_int = dw_edma_v0_core_status_done_int, + .status_abort_int = dw_edma_v0_core_status_abort_int, + .start = dw_edma_v0_core_start, + .device_config = dw_edma_v0_core_device_config, + /* eDMA debug fs callbacks */ + .debugfs_on = dw_edma_v0_core_debugfs_on, + .debugfs_off = dw_edma_v0_core_debugfs_off, +}; + static inline struct device *dchan2dev(struct dma_chan *dchan) { @@ -802,10 +819,14 @@ int dw_edma_probe(struct dw_edma_chip *chip) /* Callback operation selection accordingly to eDMA version */ switch (dw->version) { + case 0: + ops = &dw_edma_v0_core_ops; + break; default: dev_err(dev, "unsupported version\n"); return -EPERM; } + dw->ops = ops; pm_runtime_get_sync(dev); diff --git a/drivers/dma/dw-edma/dw-edma-v0-core.c b/drivers/dma/dw-edma/dw-edma-v0-core.c new file mode 100644 index 0000000..5b76e42 --- /dev/null +++ b/drivers/dma/dw-edma/dw-edma-v0-core.c @@ -0,0 +1,346 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. + * Synopsys DesignWare eDMA v0 core + */ + +#include + +#include "dw-edma-core.h" +#include "dw-edma-v0-core.h" +#include "dw-edma-v0-regs.h" +#include "dw-edma-v0-debugfs.h" + +enum dw_edma_control { + DW_EDMA_V0_CB = BIT(0), + DW_EDMA_V0_TCB = BIT(1), + DW_EDMA_V0_LLP = BIT(2), + DW_EDMA_V0_LIE = BIT(3), + DW_EDMA_V0_RIE = BIT(4), + DW_EDMA_V0_CCS = BIT(8), + DW_EDMA_V0_LLE = BIT(9), +}; + +static inline struct dw_edma_v0_regs __iomem *__dw_regs(struct dw_edma *dw) +{ + return (struct dw_edma_v0_regs __iomem *)dw->rg_region.vaddr; +} + +#define SET(dw, name, value) \ + writel(value, &(__dw_regs(dw)->name)) + +#define GET(dw, name) \ + readl(&(__dw_regs(dw)->name)) + +#define SET_RW(dw, dir, name, value) \ + do { \ + if ((dir) == EDMA_DIR_WRITE) \ + SET(dw, wr_##name, value); \ + else \ + SET(dw, rd_##name, value); \ + } while (0) + +#define GET_RW(dw, dir, name) \ + ((dir) == EDMA_DIR_WRITE \ + ? GET(dw, wr_##name) \ + : GET(dw, rd_##name)) + +#define SET_BOTH(dw, name, value) \ + do { \ + SET(dw, wr_##name, value); \ + SET(dw, rd_##name, value); \ + } while (0) + +static inline struct dw_edma_v0_ch_regs __iomem * +__dw_ch_regs(struct dw_edma *dw, enum dw_edma_dir dir, u16 ch) +{ + if (dw->mode == EDMA_MODE_LEGACY) + return &(__dw_regs(dw)->type.legacy.ch); + + if (dir == EDMA_DIR_WRITE) + return &__dw_regs(dw)->type.unroll.ch[ch].wr; + + return &__dw_regs(dw)->type.unroll.ch[ch].rd; +} + +static inline void writel_ch(struct dw_edma *dw, enum dw_edma_dir dir, u16 ch, + u32 value, void __iomem *addr) +{ + if (dw->mode == EDMA_MODE_LEGACY) { + u32 viewport_sel; + unsigned long flags; + + raw_spin_lock_irqsave(&dw->lock, flags); + + viewport_sel = FIELD_PREP(EDMA_V0_VIEWPORT_MASK, ch); + if (dir == EDMA_DIR_READ) + viewport_sel |= BIT(31); + + writel(viewport_sel, + &(__dw_regs(dw)->type.legacy.viewport_sel)); + writel(value, addr); + + raw_spin_unlock_irqrestore(&dw->lock, flags); + } else { + writel(value, addr); + } +} + +static inline u32 readl_ch(struct dw_edma *dw, enum dw_edma_dir dir, u16 ch, + const void __iomem *addr) +{ + u32 value; + + if (dw->mode == EDMA_MODE_LEGACY) { + u32 viewport_sel; + unsigned long flags; + + raw_spin_lock_irqsave(&dw->lock, flags); + + viewport_sel = FIELD_PREP(EDMA_V0_VIEWPORT_MASK, ch); + if (dir == EDMA_DIR_READ) + viewport_sel |= BIT(31); + + writel(viewport_sel, + &(__dw_regs(dw)->type.legacy.viewport_sel)); + value = readl(addr); + + raw_spin_unlock_irqrestore(&dw->lock, flags); + } else { + value = readl(addr); + } + + return value; +} + +#define SET_CH(dw, dir, ch, name, value) \ + writel_ch(dw, dir, ch, value, &(__dw_ch_regs(dw, dir, ch)->name)) + +#define GET_CH(dw, dir, ch, name) \ + readl_ch(dw, dir, ch, &(__dw_ch_regs(dw, dir, ch)->name)) + +#define SET_LL(ll, value) \ + writel(value, ll) + +/* eDMA management callbacks */ +void dw_edma_v0_core_off(struct dw_edma *dw) +{ + SET_BOTH(dw, int_mask, EDMA_V0_DONE_INT_MASK | EDMA_V0_ABORT_INT_MASK); + SET_BOTH(dw, int_clear, EDMA_V0_DONE_INT_MASK | EDMA_V0_ABORT_INT_MASK); + SET_BOTH(dw, engine_en, 0); +} + +u16 dw_edma_v0_core_ch_count(struct dw_edma *dw, enum dw_edma_dir dir) +{ + u32 num_ch; + + if (dir == EDMA_DIR_WRITE) + num_ch = FIELD_GET(EDMA_V0_WRITE_CH_COUNT_MASK, GET(dw, ctrl)); + else + num_ch = FIELD_GET(EDMA_V0_READ_CH_COUNT_MASK, GET(dw, ctrl)); + + if (num_ch > EDMA_V0_MAX_NR_CH) + num_ch = EDMA_V0_MAX_NR_CH; + + return (u16)num_ch; +} + +enum dma_status dw_edma_v0_core_ch_status(struct dw_edma_chan *chan) +{ + struct dw_edma *dw = chan->chip->dw; + u32 tmp; + + tmp = FIELD_GET(EDMA_V0_CH_STATUS_MASK, + GET_CH(dw, chan->dir, chan->id, ch_control1)); + + if (tmp == 1) + return DMA_IN_PROGRESS; + else if (tmp == 3) + return DMA_COMPLETE; + else + return DMA_ERROR; +} + +void dw_edma_v0_core_clear_done_int(struct dw_edma_chan *chan) +{ + struct dw_edma *dw = chan->chip->dw; + + SET_RW(dw, chan->dir, int_clear, + FIELD_PREP(EDMA_V0_DONE_INT_MASK, BIT(chan->id))); +} + +void dw_edma_v0_core_clear_abort_int(struct dw_edma_chan *chan) +{ + struct dw_edma *dw = chan->chip->dw; + + SET_RW(dw, chan->dir, int_clear, + FIELD_PREP(EDMA_V0_ABORT_INT_MASK, BIT(chan->id))); +} + +u32 dw_edma_v0_core_status_done_int(struct dw_edma *dw, enum dw_edma_dir dir) +{ + return FIELD_GET(EDMA_V0_DONE_INT_MASK, GET_RW(dw, dir, int_status)); +} + +u32 dw_edma_v0_core_status_abort_int(struct dw_edma *dw, enum dw_edma_dir dir) +{ + return FIELD_GET(EDMA_V0_ABORT_INT_MASK, GET_RW(dw, dir, int_status)); +} + +static void dw_edma_v0_core_write_chunk(struct dw_edma_chunk *chunk) +{ + struct dw_edma_burst *child; + struct dw_edma_v0_lli *lli; + struct dw_edma_v0_llp *llp; + u32 control = 0, i = 0; + u64 sar, dar, addr; + int j; + + lli = (struct dw_edma_v0_lli *)chunk->ll_region.vaddr; + + if (chunk->cb) + control = DW_EDMA_V0_CB; + + j = chunk->bursts_alloc; + list_for_each_entry(child, &chunk->burst->list, list) { + j--; + if (!j) + control |= (DW_EDMA_V0_LIE | DW_EDMA_V0_RIE); + + /* Channel control */ + SET_LL(&lli[i].control, control); + /* Transfer size */ + SET_LL(&lli[i].transfer_size, child->sz); + /* SAR - low, high */ + sar = cpu_to_le64(child->sar); + SET_LL(&lli[i].sar_low, lower_32_bits(sar)); + SET_LL(&lli[i].sar_high, upper_32_bits(sar)); + /* DAR - low, high */ + dar = cpu_to_le64(child->dar); + SET_LL(&lli[i].dar_low, lower_32_bits(dar)); + SET_LL(&lli[i].dar_high, upper_32_bits(dar)); + i++; + } + + llp = (struct dw_edma_v0_llp *)&lli[i]; + control = DW_EDMA_V0_LLP | DW_EDMA_V0_TCB; + if (!chunk->cb) + control |= DW_EDMA_V0_CB; + + /* Channel control */ + SET_LL(&llp->control, control); + /* Linked list - low, high */ + addr = cpu_to_le64(chunk->ll_region.paddr); + SET_LL(&llp->llp_low, lower_32_bits(addr)); + SET_LL(&llp->llp_high, upper_32_bits(addr)); +} + +void dw_edma_v0_core_start(struct dw_edma_chunk *chunk, bool first) +{ + struct dw_edma_chan *chan = chunk->chan; + struct dw_edma *dw = chan->chip->dw; + u32 tmp; + u64 llp; + + dw_edma_v0_core_write_chunk(chunk); + + if (first) { + /* Enable engine */ + SET_RW(dw, chan->dir, engine_en, BIT(0)); + /* Interrupt unmask - done, abort */ + tmp = GET_RW(dw, chan->dir, int_mask); + tmp &= ~FIELD_PREP(EDMA_V0_DONE_INT_MASK, BIT(chan->id)); + tmp &= ~FIELD_PREP(EDMA_V0_ABORT_INT_MASK, BIT(chan->id)); + SET_RW(dw, chan->dir, int_mask, tmp); + /* Linked list error */ + tmp = GET_RW(dw, chan->dir, linked_list_err_en); + tmp |= FIELD_PREP(EDMA_V0_LINKED_LIST_ERR_MASK, BIT(chan->id)); + SET_RW(dw, chan->dir, linked_list_err_en, tmp); + /* Channel control */ + SET_CH(dw, chan->dir, chan->id, ch_control1, + (DW_EDMA_V0_CCS | DW_EDMA_V0_LLE)); + /* Linked list - low, high */ + llp = cpu_to_le64(chunk->ll_region.paddr); + SET_CH(dw, chan->dir, chan->id, llp_low, lower_32_bits(llp)); + SET_CH(dw, chan->dir, chan->id, llp_high, upper_32_bits(llp)); + } + /* Doorbell */ + SET_RW(dw, chan->dir, doorbell, + FIELD_PREP(EDMA_V0_DOORBELL_CH_MASK, chan->id)); +} + +int dw_edma_v0_core_device_config(struct dma_chan *dchan) +{ + struct dw_edma_chan *chan = dchan2dw_edma_chan(dchan); + struct dw_edma *dw = chan->chip->dw; + u32 tmp = 0; + + /* MSI done addr - low, high */ + SET_RW(dw, chan->dir, done_imwr_low, chan->msi.address_lo); + SET_RW(dw, chan->dir, done_imwr_high, chan->msi.address_hi); + /* MSI abort addr - low, high */ + SET_RW(dw, chan->dir, abort_imwr_low, chan->msi.address_lo); + SET_RW(dw, chan->dir, abort_imwr_high, chan->msi.address_hi); + /* MSI data - low, high */ + switch (chan->id) { + case 0: + case 1: + tmp = GET_RW(dw, chan->dir, ch01_imwr_data); + break; + case 2: + case 3: + tmp = GET_RW(dw, chan->dir, ch23_imwr_data); + break; + case 4: + case 5: + tmp = GET_RW(dw, chan->dir, ch45_imwr_data); + break; + case 6: + case 7: + tmp = GET_RW(dw, chan->dir, ch67_imwr_data); + break; + } + + if (chan->id & BIT(0)) { + /* Channel odd {1, 3, 5, 7} */ + tmp &= EDMA_V0_CH_EVEN_MSI_DATA_MASK; + tmp |= FIELD_PREP(EDMA_V0_CH_ODD_MSI_DATA_MASK, + chan->msi.data); + } else { + /* Channel even {0, 2, 4, 6} */ + tmp &= EDMA_V0_CH_ODD_MSI_DATA_MASK; + tmp |= FIELD_PREP(EDMA_V0_CH_EVEN_MSI_DATA_MASK, + chan->msi.data); + } + + switch (chan->id) { + case 0: + case 1: + SET_RW(dw, chan->dir, ch01_imwr_data, tmp); + break; + case 2: + case 3: + SET_RW(dw, chan->dir, ch23_imwr_data, tmp); + break; + case 4: + case 5: + SET_RW(dw, chan->dir, ch45_imwr_data, tmp); + break; + case 6: + case 7: + SET_RW(dw, chan->dir, ch67_imwr_data, tmp); + break; + } + + return 0; +} + +/* eDMA debugfs callbacks */ +int dw_edma_v0_core_debugfs_on(struct dw_edma_chip *chip) +{ + return 0; +} + +void dw_edma_v0_core_debugfs_off(void) +{ +} diff --git a/drivers/dma/dw-edma/dw-edma-v0-core.h b/drivers/dma/dw-edma/dw-edma-v0-core.h new file mode 100644 index 0000000..2d35bff --- /dev/null +++ b/drivers/dma/dw-edma/dw-edma-v0-core.h @@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. + * Synopsys DesignWare eDMA v0 core + */ + +#ifndef _DW_EDMA_V0_CORE_H +#define _DW_EDMA_V0_CORE_H + +#include + +/* eDMA management callbacks */ +void dw_edma_v0_core_off(struct dw_edma *chan); +u16 dw_edma_v0_core_ch_count(struct dw_edma *chan, enum dw_edma_dir dir); +enum dma_status dw_edma_v0_core_ch_status(struct dw_edma_chan *chan); +void dw_edma_v0_core_clear_done_int(struct dw_edma_chan *chan); +void dw_edma_v0_core_clear_abort_int(struct dw_edma_chan *chan); +u32 dw_edma_v0_core_status_done_int(struct dw_edma *chan, enum dw_edma_dir dir); +u32 dw_edma_v0_core_status_abort_int(struct dw_edma *chan, enum dw_edma_dir dir); +void dw_edma_v0_core_start(struct dw_edma_chunk *chunk, bool first); +int dw_edma_v0_core_device_config(struct dma_chan *dchan); +/* eDMA debug fs callbacks */ +int dw_edma_v0_core_debugfs_on(struct dw_edma_chip *chip); +void dw_edma_v0_core_debugfs_off(void); + +#endif /* _DW_EDMA_V0_CORE_H */ diff --git a/drivers/dma/dw-edma/dw-edma-v0-regs.h b/drivers/dma/dw-edma/dw-edma-v0-regs.h new file mode 100644 index 0000000..eb04715 --- /dev/null +++ b/drivers/dma/dw-edma/dw-edma-v0-regs.h @@ -0,0 +1,156 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. + * Synopsys DesignWare eDMA v0 core + */ + +#ifndef _DW_EDMA_V0_REGS_H +#define _DW_EDMA_V0_REGS_H + +#include + +#define EDMA_V0_MAX_NR_CH 8 +#define EDMA_V0_VIEWPORT_MASK GENMASK(2, 0) +#define EDMA_V0_DONE_INT_MASK GENMASK(7, 0) +#define EDMA_V0_ABORT_INT_MASK GENMASK(23, 16) +#define EDMA_V0_WRITE_CH_COUNT_MASK GENMASK(3, 0) +#define EDMA_V0_READ_CH_COUNT_MASK GENMASK(19, 16) +#define EDMA_V0_CH_STATUS_MASK GENMASK(6, 5) +#define EDMA_V0_DOORBELL_CH_MASK GENMASK(2, 0) +#define EDMA_V0_LINKED_LIST_ERR_MASK GENMASK(7, 0) + +#define EDMA_V0_CH_ODD_MSI_DATA_MASK GENMASK(15, 8) +#define EDMA_V0_CH_EVEN_MSI_DATA_MASK GENMASK(7, 0) + +struct dw_edma_v0_ch_regs { + u32 ch_control1; /* 0x000 */ + u32 ch_control2; /* 0x004 */ + u32 transfer_size; /* 0x008 */ + u32 sar_low; /* 0x00c */ + u32 sar_high; /* 0x010 */ + u32 dar_low; /* 0x014 */ + u32 dar_high; /* 0x018 */ + u32 llp_low; /* 0x01c */ + u32 llp_high; /* 0x020 */ +}; + +struct dw_edma_v0_ch { + struct dw_edma_v0_ch_regs wr; /* 0x200 */ + u32 padding_1[55]; /* [0x224..0x2fc] */ + struct dw_edma_v0_ch_regs rd; /* 0x300 */ + u32 padding_2[55]; /* [0x224..0x2fc] */ +}; + +struct dw_edma_v0_unroll { + u32 padding_1; /* 0x0f8 */ + u32 wr_engine_chgroup; /* 0x100 */ + u32 rd_engine_chgroup; /* 0x104 */ + u32 wr_engine_hshake_cnt_low; /* 0x108 */ + u32 wr_engine_hshake_cnt_high; /* 0x10c */ + u32 padding_2[2]; /* [0x110..0x114] */ + u32 rd_engine_hshake_cnt_low; /* 0x118 */ + u32 rd_engine_hshake_cnt_high; /* 0x11c */ + u32 padding_3[2]; /* [0x120..0x124] */ + u32 wr_ch0_pwr_en; /* 0x128 */ + u32 wr_ch1_pwr_en; /* 0x12c */ + u32 wr_ch2_pwr_en; /* 0x130 */ + u32 wr_ch3_pwr_en; /* 0x134 */ + u32 wr_ch4_pwr_en; /* 0x138 */ + u32 wr_ch5_pwr_en; /* 0x13c */ + u32 wr_ch6_pwr_en; /* 0x140 */ + u32 wr_ch7_pwr_en; /* 0x144 */ + u32 padding_4[8]; /* [0x148..0x164] */ + u32 rd_ch0_pwr_en; /* 0x168 */ + u32 rd_ch1_pwr_en; /* 0x16c */ + u32 rd_ch2_pwr_en; /* 0x170 */ + u32 rd_ch3_pwr_en; /* 0x174 */ + u32 rd_ch4_pwr_en; /* 0x178 */ + u32 rd_ch5_pwr_en; /* 0x18c */ + u32 rd_ch6_pwr_en; /* 0x180 */ + u32 rd_ch7_pwr_en; /* 0x184 */ + u32 padding_5[30]; /* [0x188..0x1fc] */ + struct dw_edma_v0_ch ch[EDMA_V0_MAX_NR_CH]; /* [0x200..0x1120] */ +}; + +struct dw_edma_v0_legacy { + u32 viewport_sel; /* 0x0f8 */ + struct dw_edma_v0_ch_regs ch; /* [0x100..0x120] */ +}; + +struct dw_edma_v0_regs { + /* eDMA global registers */ + u32 ctrl_data_arb_prior; /* 0x000 */ + u32 padding_1; /* 0x004 */ + u32 ctrl; /* 0x008 */ + u32 wr_engine_en; /* 0x00c */ + u32 wr_doorbell; /* 0x010 */ + u32 padding_2; /* 0x014 */ + u32 wr_ch_arb_weight_low; /* 0x018 */ + u32 wr_ch_arb_weight_high; /* 0x01c */ + u32 padding_3[3]; /* [0x020..0x028] */ + u32 rd_engine_en; /* 0x02c */ + u32 rd_doorbell; /* 0x030 */ + u32 padding_4; /* 0x034 */ + u32 rd_ch_arb_weight_low; /* 0x038 */ + u32 rd_ch_arb_weight_high; /* 0x03c */ + u32 padding_5[3]; /* [0x040..0x048] */ + /* eDMA interrupts registers */ + u32 wr_int_status; /* 0x04c */ + u32 padding_6; /* 0x050 */ + u32 wr_int_mask; /* 0x054 */ + u32 wr_int_clear; /* 0x058 */ + u32 wr_err_status; /* 0x05c */ + u32 wr_done_imwr_low; /* 0x060 */ + u32 wr_done_imwr_high; /* 0x064 */ + u32 wr_abort_imwr_low; /* 0x068 */ + u32 wr_abort_imwr_high; /* 0x06c */ + u32 wr_ch01_imwr_data; /* 0x070 */ + u32 wr_ch23_imwr_data; /* 0x074 */ + u32 wr_ch45_imwr_data; /* 0x078 */ + u32 wr_ch67_imwr_data; /* 0x07c */ + u32 padding_7[4]; /* [0x080..0x08c] */ + u32 wr_linked_list_err_en; /* 0x090 */ + u32 padding_8[3]; /* [0x094..0x09c] */ + u32 rd_int_status; /* 0x0a0 */ + u32 padding_9; /* 0x0a4 */ + u32 rd_int_mask; /* 0x0a8 */ + u32 rd_int_clear; /* 0x0ac */ + u32 padding_10; /* 0x0b0 */ + u32 rd_err_status_low; /* 0x0b4 */ + u32 rd_err_status_high; /* 0x0b8 */ + u32 padding_11[2]; /* [0x0bc..0x0c0] */ + u32 rd_linked_list_err_en; /* 0x0c4 */ + u32 padding_12; /* 0x0c8 */ + u32 rd_done_imwr_low; /* 0x0cc */ + u32 rd_done_imwr_high; /* 0x0d0 */ + u32 rd_abort_imwr_low; /* 0x0d4 */ + u32 rd_abort_imwr_high; /* 0x0d8 */ + u32 rd_ch01_imwr_data; /* 0x0dc */ + u32 rd_ch23_imwr_data; /* 0x0e0 */ + u32 rd_ch45_imwr_data; /* 0x0e4 */ + u32 rd_ch67_imwr_data; /* 0x0e8 */ + u32 padding_13[4]; /* [0x0ec..0x0f8] */ + /* eDMA channel context grouping */ + union Type { + struct dw_edma_v0_legacy legacy; /* [0x0f8..0x120] */ + struct dw_edma_v0_unroll unroll; /* [0x0f8..0x1120] */ + } type; +}; + +struct dw_edma_v0_lli { + u32 control; + u32 transfer_size; + u32 sar_low; + u32 sar_high; + u32 dar_low; + u32 dar_high; +}; + +struct dw_edma_v0_llp { + u32 control; + u32 reserved; + u32 llp_low; + u32 llp_high; +}; + +#endif /* _DW_EDMA_V0_REGS_H */ -- 2.7.4