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,v6,5/6] dmaengine: Add Synopsys eDMA IP PCIe glue-logic From: Gustavo Pimentel Message-Id: <7db737e11950c6eced69f68f75584fa1b7b37982.1556043127.git.gustavo.pimentel@synopsys.com> Date: Tue, 23 Apr 2019 20:30:12 +0200 To: linux-pci@vger.kernel.org, dmaengine@vger.kernel.org Cc: Gustavo Pimentel , Vinod Koul , Dan Williams , Russell King , Lorenzo Pieralisi , Joao Pinto List-ID: U3lub3BzeXMgZURNQSBJUCBpcyBub3JtYWxseSBkaXN0cmlidXRlZCBhbG9uZyB3aXRoIFN5bm9w c3lzIFBDSWUKRW5kUG9pbnQgSVAgKGRlcGVuZHMgb2YgdGhlIHVzZSBhbmQgbGljZW5zaW5nIGFn cmVlbWVudCkuCgpUaGlzIElQIHJlcXVpcmVzIHNvbWUgYmFzaWMgY29uZmlndXJhdGlvbnMsIHN1 Y2ggYXM6CiAtIGVETUEgcmVnaXN0ZXJzIEJBUgogLSBlRE1BIHJlZ2lzdGVycyBvZmZzZXQKIC0g ZURNQSByZWdpc3RlcnMgc2l6ZQogLSBlRE1BIGxpbmtlZCBsaXN0IG1lbW9yeSBCQVIKIC0gZURN QSBsaW5rZWQgbGlzdCBtZW1vcnkgb2Zmc2V0CiAtIGVETUEgbGlua2VkIGxpc3QgbWVtb3J5IHNp emUKIC0gZURNQSBkYXRhIG1lbW9yeSBCQVIKIC0gZURNQSBkYXRhIG1lbW9yeSBvZmZzZXQKIC0g ZURNQSBkYXRhIG1lbW9yeSBzaXplCiAtIGVETUEgdmVyc2lvbgogLSBlRE1BIG1vZGUKIC0gSVJR cyBhdmFpbGFibGUgZm9yIGVETUEKCkFzIGEgd29ya2luZyBleGFtcGxlLCBQQ0llIGdsdWUtbG9n aWMgd2lsbCBhdHRhY2ggdG8gYSBTeW5vcHN5cyBQQ0llCkVuZFBvaW50IElQIHByb3RvdHlwZSBr aXQgKFZlbmRvciBJRCA9IDB4MTZjMywgRGV2aWNlIElEID0gMHhlZGRhKSwKd2hpY2ggaGFzIGJ1 aWx0LWluIGFuIGVETUEgSVAgd2l0aCB0aGlzIGRlZmF1bHQgY29uZmlndXJhdGlvbjoKIC0gZURN QSByZWdpc3RlcnMgQkFSID0gMAogLSBlRE1BIHJlZ2lzdGVycyBvZmZzZXQgPSAweDAwMDAxMDAw ICg0IEtieXRlcykKIC0gZURNQSByZWdpc3RlcnMgc2l6ZSA9IDB4MDAwMDIwMDAgKDggS2J5dGVz KQogLSBlRE1BIGxpbmtlZCBsaXN0IG1lbW9yeSBCQVIgPSAyCiAtIGVETUEgbGlua2VkIGxpc3Qg bWVtb3J5IG9mZnNldCA9IDB4MDAwMDAwMDAgKDAgS2J5dGVzKQogLSBlRE1BIGxpbmtlZCBsaXN0 IG1lbW9yeSBzaXplID0gMHgwMDgwMDAwMCAoOCBNYnl0ZXMpCiAtIGVETUEgZGF0YSBtZW1vcnkg QkFSID0gMgogLSBlRE1BIGRhdGEgbWVtb3J5IG9mZnNldCA9IDB4MDA4MDAwMDAgKDggTWJ5dGVz KQogLSBlRE1BIGRhdGEgbWVtb3J5IHNpemUgPSAweDAzODAwMDAwICg1NiBNYnl0ZXMpCiAtIGVE TUEgdmVyc2lvbiA9IDAKIC0gZURNQSBtb2RlID0gRURNQV9NT0RFX1VOUk9MTAogLSBJUlFzID0g MQoKVGhpcyBkcml2ZXIgY2FuIGJlIGNvbXBpbGUgYXMgYnVpbHQtaW4gb3IgZXh0ZXJuYWwgbW9k dWxlIGluIGtlcm5lbC4KClRvIGVuYWJsZSB0aGlzIGRyaXZlciBqdXN0IHNlbGVjdCBEV19FRE1B X1BDSUUgb3B0aW9uIGluIGtlcm5lbApjb25maWd1cmF0aW9uLCBob3dldmVyIGl0IHJlcXVpcmVz IGFuZCBzZWxlY3RzIGF1dG9tYXRpY2FsbHkgRFdfRURNQQpvcHRpb24gdG9vLgoKU2lnbmVkLW9m Zi1ieTogR3VzdGF2byBQaW1lbnRlbCA8Z3VzdGF2by5waW1lbnRlbEBzeW5vcHN5cy5jb20+CkNj OiBWaW5vZCBLb3VsIDx2a291bEBrZXJuZWwub3JnPgpDYzogRGFuIFdpbGxpYW1zIDxkYW4uai53 aWxsaWFtc0BpbnRlbC5jb20+CkNjOiBSdXNzZWxsIEtpbmcgPHJtaytrZXJuZWxAYXJtbGludXgu b3JnLnVrPgpDYzogTG9yZW56byBQaWVyYWxpc2kgPGxvcmVuem8ucGllcmFsaXNpQGFybS5jb20+ CkNjOiBKb2FvIFBpbnRvIDxqcGludG9Ac3lub3BzeXMuY29tPgotLS0KQ2hhbmdlczoKUkZDIHYx LT5SRkMgdjI6CiAtIFJlcGxhY2UgY29tbWVudHMgLy8gKEM5OSBzdHlsZSkgYnkgLyoqLwogLSBN ZXJnZSB0d28gcGNpbV9pb21hcF9yZWdpb25zKCkgY2FsbHMgaW50byBqdXN0IG9uZSBjYWxsCiAt IFJlbW92ZSBwY2lfdHJ5X3NldF9td2koKSBjYWxsCiAtIFJlcGxhY2Ugc29tZSBkZXZfaW5mbygp IGJ5IGRldl9kYmcoKSB0byByZWR1Y2UgKm5vaXNlKgogLSBSZW1vdmUgcGNpX25hbWUocGRldikg Y2FsbCBhZnRlciBiZWluZyBjYWxsIGR3X2VkbWFfcmVtb3ZlKCkKIC0gUmVtb3ZlIGFsbCBwb3dl ciBtYW5hZ2VtZW50IHN1cHBvcnQKIC0gRml4IHRoZSBoZWFkZXJzIG9mIHRoZSAuYyBhbmQgLmgg ZmlsZXMgYWNjb3JkaW5nIHRvIHRoZSBtb3N0IHJlY2VudAogICBjb252ZW50aW9uCiAtIEZpeCBl cnJvcnMgYW5kIGNoZWNrcyBwb2ludGVkIG91dCBieSBjaGVja3BhdGNoIHdpdGggLS1zdHJpY3Qg b3B0aW9uCiAtIFJlcGxhY2UgcGF0Y2ggc21hbGwgZGVzY3JpcHRpb24gdGFnIGZyb20gZG1hIGJ5 IGRtYWVuZ2luZQpSRkMgdjItPlJGQyB2MzoKIC0gRml4IHByaW50ayB2YXJpYWJsZSBvZiBwaHlz X2FkZHJfdCB0eXBlCiAtIEZpeCBtaXNzaW5nIHZhcmlhYmxlIGluaXRpYWxpemF0aW9uIChjaGFu LT5jb25maWd1cmVkKQogLSBDaGFuZ2UgbGlua2VkIGxpc3Qgc2l6ZSB0byA1MTIgS2J5dGVzCiAt IEFkZCBkYXRhIG1lbW9yeSBpbmZvcm1hdGlvbgogLSBBZGQgcmVnaXN0ZXIgc2l6ZSBpbmZvcm1h dGlvbgogLSBBZGQgY29tbWVudHMgb3IgaW1wcm92ZSBleGlzdGluZyBvbmVzCiAtIEFkZCBwb3Nz aWJpbGl0eSB0byB3b3JrIHdpdGggbXVsdGlwbGUgSVJRcyBmZWF0dXJlCiAtIFJlcGxhY2UgTVNJ IGFuZCBNU0ktWCBlbmFibGUgY29uZGl0aW9uIGJ5IHBjaV9kZXZfbXNpX2VuYWJsZWQoKQogLSBS ZXBsYWNlIGNvZGUgdG8gYWNxdWlyZSBNU0koLVgpIGFkZHJlc3MgYW5kIGRhdGEgYnkKICAgZ2V0 X2NhY2hlZF9tc2lfbXNnKCkKIC0gUmViYXNlIHRvIHY1LjAtcmMxClJGQyB2My0+UkZDIHY0Ogog LSBSZXBsYWNlIGVudW0gZHdfZWRtYV9wY2llIGFuZCB1c2UgYnkgZW51bSBwY2lfYmFybm8KIC0g UmVtb3ZlIHVubmVjZXNzYXJ5IGRldl9pbmZvKCkgY2FsbHMKIC0gUmVtb3ZlIHVubmVjZXNzYXJ5 IHBvaW50ZXIgbnVsbCB2YWxpZGF0aW9uCiAtIFJlb3JkZXIgdmFyaWFibGVzIGRlY2xhcmF0aW9u IGluIHJldmVyc2UgdHJlZSBvcmRlciBpbgogICBkd19lZG1hX3BjaWVfcHJvYmUoKQogLSBSZW1v dmUgcGRhdGEgdmFsaWRhdGlvbgogLSBSZW1vdmUgZGlzYWJsZV9tc2l4IHBhcmFtZXRlcgogLSBG aXggbGljZW5zZSBoZWFkZXIKIC0gTW92ZSBnZXRfY2FjaGVkX21zaV9tc2coKSB0byBkdy1lZG1h LWNvcmUgZmlsZQpSRkMgdjQtPlJGQyB2NToKIC0gUGF0Y2ggcmVzZW5kZWQsIGZvcmdvdCB0byBy ZXBsYWNlIG9mICdfX18nIGJ5ICctLS0nIGFuZCB0byByZW1vdmUKIGR1cGxpY2F0ZSBzaWduZWQt b2ZmClJGQyB2NS0+UkZDIHY2OgogLSBBZGQgYXV0aG9yIG9uIGZpbGUgaGVhZGVyCgogZHJpdmVy cy9kbWEvZHctZWRtYS9LY29uZmlnICAgICAgICB8ICAgOSArKwogZHJpdmVycy9kbWEvZHctZWRt YS9NYWtlZmlsZSAgICAgICB8ICAgMSArCiBkcml2ZXJzL2RtYS9kdy1lZG1hL2R3LWVkbWEtcGNp ZS5jIHwgMjI5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMg Y2hhbmdlZCwgMjM5IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2Rt YS9kdy1lZG1hL2R3LWVkbWEtcGNpZS5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZHctZWRt YS9LY29uZmlnIGIvZHJpdmVycy9kbWEvZHctZWRtYS9LY29uZmlnCmluZGV4IDMwMTZiZWQuLmMw ODM4Y2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL2R3LWVkbWEvS2NvbmZpZworKysgYi9kcml2 ZXJzL2RtYS9kdy1lZG1hL0tjb25maWcKQEAgLTcsMyArNywxMiBAQCBjb25maWcgRFdfRURNQQog CWhlbHAKIAkgIFN1cHBvcnQgdGhlIFN5bm9wc3lzIERlc2lnbldhcmUgZURNQSBjb250cm9sbGVy LCBub3JtYWxseQogCSAgaW1wbGVtZW50ZWQgb24gZW5kcG9pbnRzIFNvQ3MuCisKK2NvbmZpZyBE V19FRE1BX1BDSUUKKwl0cmlzdGF0ZSAiU3lub3BzeXMgRGVzaWduV2FyZSBlRE1BIFBDSWUgZHJp dmVyIgorCWRlcGVuZHMgb24gUENJICYmIFBDSV9NU0kKKwlzZWxlY3QgRFdfRURNQQorCWhlbHAK KwkgIFByb3ZpZGVzIGEgZ2x1ZS1sb2dpYyBiZXR3ZWVuIHRoZSBTeW5vcHN5cyBEZXNpZ25XYXJl CisJICBlRE1BIGNvbnRyb2xsZXIgYW5kIGFuIGVuZHBvaW50IFBDSWUgZGV2aWNlLiBUaGlzIGFs c28gc2VydmVzCisJICBhcyBhIHJlZmVyZW5jZSBkZXNpZ24gdG8gd2hvbSBkZXNpcmVzIHRvIHVz ZSB0aGlzIElQLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZHctZWRtYS9NYWtlZmlsZSBiL2Ry aXZlcnMvZG1hL2R3LWVkbWEvTWFrZWZpbGUKaW5kZXggMGM1MzAzMy4uOGQ0NWMwZCAxMDA2NDQK LS0tIGEvZHJpdmVycy9kbWEvZHctZWRtYS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2RtYS9kdy1l ZG1hL01ha2VmaWxlCkBAIC00LDMgKzQsNCBAQCBvYmotJChDT05GSUdfRFdfRURNQSkJCSs9IGR3 LWVkbWEubwogZHctZWRtYS0kKENPTkZJR19ERUJVR19GUykJOj0gZHctZWRtYS12MC1kZWJ1Z2Zz Lm8KIGR3LWVkbWEtb2JqcwkJCTo9IGR3LWVkbWEtY29yZS5vIFwKIAkJCQkJZHctZWRtYS12MC1j b3JlLm8gJChkdy1lZG1hLXkpCitvYmotJChDT05GSUdfRFdfRURNQV9QQ0lFKQkrPSBkdy1lZG1h LXBjaWUubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZHctZWRtYS9kdy1lZG1hLXBjaWUuYyBi L2RyaXZlcnMvZG1hL2R3LWVkbWEvZHctZWRtYS1wY2llLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uNGM5NmUxYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZG1hL2R3 LWVkbWEvZHctZWRtYS1wY2llLmMKQEAgLTAsMCArMSwyMjkgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogQ29weXJpZ2h0IChjKSAyMDE4LTIwMTkgU3lub3Bz eXMsIEluYy4gYW5kL29yIGl0cyBhZmZpbGlhdGVzLgorICogU3lub3BzeXMgRGVzaWduV2FyZSBl RE1BIFBDSWUgZHJpdmVyCisgKgorICogQXV0aG9yOiBHdXN0YXZvIFBpbWVudGVsIDxndXN0YXZv LnBpbWVudGVsQHN5bm9wc3lzLmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+ CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5j bHVkZSA8bGludXgvZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvZG1hL2VkbWEuaD4KKyNpbmNs dWRlIDxsaW51eC9wY2ktZXBmLmg+CisjaW5jbHVkZSA8bGludXgvbXNpLmg+CisKKyNpbmNsdWRl ICJkdy1lZG1hLWNvcmUuaCIKKworc3RydWN0IGR3X2VkbWFfcGNpZV9kYXRhIHsKKwkvKiBlRE1B IHJlZ2lzdGVycyBsb2NhdGlvbiAqLworCWVudW0gcGNpX2Jhcm5vCQkJcmdfYmFyOworCW9mZl90 CQkJCXJnX29mZjsKKwlzaXplX3QJCQkJcmdfc3o7CisJLyogZURNQSBtZW1vcnkgbGlua2VkIGxp c3QgbG9jYXRpb24gKi8KKwllbnVtIHBjaV9iYXJubwkJCWxsX2JhcjsKKwlvZmZfdAkJCQlsbF9v ZmY7CisJc2l6ZV90CQkJCWxsX3N6OworCS8qIGVETUEgbWVtb3J5IGRhdGEgbG9jYXRpb24gKi8K KwllbnVtIHBjaV9iYXJubwkJCWR0X2JhcjsKKwlvZmZfdAkJCQlkdF9vZmY7CisJc2l6ZV90CQkJ CWR0X3N6OworCS8qIE90aGVyICovCisJdTMyCQkJCXZlcnNpb247CisJZW51bSBkd19lZG1hX21v ZGUJCW1vZGU7CisJdTgJCQkJaXJxczsKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHdfZWRt YV9wY2llX2RhdGEgc25wc19lZGRhX2RhdGEgPSB7CisJLyogZURNQSByZWdpc3RlcnMgbG9jYXRp b24gKi8KKwkucmdfYmFyCQkJCT0gQkFSXzAsCisJLnJnX29mZgkJCQk9IDB4MDAwMDEwMDAsCS8q ICA0IEtieXRlcyAqLworCS5yZ19zegkJCQk9IDB4MDAwMDIwMDAsCS8qICA4IEtieXRlcyAqLwor CS8qIGVETUEgbWVtb3J5IGxpbmtlZCBsaXN0IGxvY2F0aW9uICovCisJLmxsX2JhcgkJCQk9IEJB Ul8yLAorCS5sbF9vZmYJCQkJPSAweDAwMDAwMDAwLAkvKiAgMCBLYnl0ZXMgKi8KKwkubGxfc3oJ CQkJPSAweDAwODAwMDAwLAkvKiAgOCBNYnl0ZXMgKi8KKwkvKiBlRE1BIG1lbW9yeSBkYXRhIGxv Y2F0aW9uICovCisJLmR0X2JhcgkJCQk9IEJBUl8yLAorCS5kdF9vZmYJCQkJPSAweDAwODAwMDAw LAkvKiAgOCBNYnl0ZXMgKi8KKwkuZHRfc3oJCQkJPSAweDAzODAwMDAwLAkvKiA1NiBNYnl0ZXMg Ki8KKwkvKiBPdGhlciAqLworCS52ZXJzaW9uCQkJPSAwLAorCS5tb2RlCQkJCT0gRURNQV9NT0RF X1VOUk9MTCwKKwkuaXJxcwkJCQk9IDEsCit9OworCitzdGF0aWMgaW50IGR3X2VkbWFfcGNpZV9w cm9iZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBwY2lfZGV2 aWNlX2lkICpwaWQpCit7CisJY29uc3Qgc3RydWN0IGR3X2VkbWFfcGNpZV9kYXRhICpwZGF0YSA9 ICh2b2lkICopcGlkLT5kcml2ZXJfZGF0YTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ ZGV2OworCXN0cnVjdCBkd19lZG1hX2NoaXAgKmNoaXA7CisJaW50IGVyciwgbnJfaXJxczsKKwlz dHJ1Y3QgZHdfZWRtYSAqZHc7CisKKwkvKiBFbmFibGUgUENJIGRldmljZSAqLworCWVyciA9IHBj aW1fZW5hYmxlX2RldmljZShwZGV2KTsKKwlpZiAoZXJyKSB7CisJCXBjaV9lcnIocGRldiwgImVu YWJsaW5nIGRldmljZSBmYWlsZWRcbiIpOworCQlyZXR1cm4gZXJyOworCX0KKworCS8qIE1hcHBp bmcgUENJIEJBUiByZWdpb25zICovCisJZXJyID0gcGNpbV9pb21hcF9yZWdpb25zKHBkZXYsIEJJ VChwZGF0YS0+cmdfYmFyKSB8CisJCQkJICAgICAgIEJJVChwZGF0YS0+bGxfYmFyKSB8CisJCQkJ ICAgICAgIEJJVChwZGF0YS0+ZHRfYmFyKSwKKwkJCQkgcGNpX25hbWUocGRldikpOworCWlmIChl cnIpIHsKKwkJcGNpX2VycihwZGV2LCAiZURNQSBCQVIgSS9PIHJlbWFwcGluZyBmYWlsZWRcbiIp OworCQlyZXR1cm4gZXJyOworCX0KKworCXBjaV9zZXRfbWFzdGVyKHBkZXYpOworCisJLyogRE1B IGNvbmZpZ3VyYXRpb24gKi8KKwllcnIgPSBwY2lfc2V0X2RtYV9tYXNrKHBkZXYsIERNQV9CSVRf TUFTSyg2NCkpOworCWlmICghZXJyKSB7CisJCWVyciA9IHBjaV9zZXRfY29uc2lzdGVudF9kbWFf bWFzayhwZGV2LCBETUFfQklUX01BU0soNjQpKTsKKwkJaWYgKGVycikgeworCQkJcGNpX2Vycihw ZGV2LCAiY29uc2lzdGVudCBETUEgbWFzayA2NCBzZXQgZmFpbGVkXG4iKTsKKwkJCXJldHVybiBl cnI7CisJCX0KKwl9IGVsc2UgeworCQlwY2lfZXJyKHBkZXYsICJETUEgbWFzayA2NCBzZXQgZmFp bGVkXG4iKTsKKworCQllcnIgPSBwY2lfc2V0X2RtYV9tYXNrKHBkZXYsIERNQV9CSVRfTUFTSygz MikpOworCQlpZiAoZXJyKSB7CisJCQlwY2lfZXJyKHBkZXYsICJETUEgbWFzayAzMiBzZXQgZmFp bGVkXG4iKTsKKwkJCXJldHVybiBlcnI7CisJCX0KKworCQllcnIgPSBwY2lfc2V0X2NvbnNpc3Rl bnRfZG1hX21hc2socGRldiwgRE1BX0JJVF9NQVNLKDMyKSk7CisJCWlmIChlcnIpIHsKKwkJCXBj aV9lcnIocGRldiwgImNvbnNpc3RlbnQgRE1BIG1hc2sgMzIgc2V0IGZhaWxlZFxuIik7CisJCQly ZXR1cm4gZXJyOworCQl9CisJfQorCisJLyogRGF0YSBzdHJ1Y3R1cmUgYWxsb2NhdGlvbiAqLwor CWNoaXAgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmNoaXApLCBHRlBfS0VSTkVMKTsKKwlp ZiAoIWNoaXApCisJCXJldHVybiAtRU5PTUVNOworCisJZHcgPSBkZXZtX2t6YWxsb2MoZGV2LCBz aXplb2YoKmR3KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFkdykKKwkJcmV0dXJuIC1FTk9NRU07CisK KwkvKiBJUlFzIGFsbG9jYXRpb24gKi8KKwlucl9pcnFzID0gcGNpX2FsbG9jX2lycV92ZWN0b3Jz KHBkZXYsIDEsIHBkYXRhLT5pcnFzLAorCQkJCQlQQ0lfSVJRX01TSSB8IFBDSV9JUlFfTVNJWCk7 CisJaWYgKG5yX2lycXMgPCAxKSB7CisJCXBjaV9lcnIocGRldiwgImZhaWwgdG8gYWxsb2MgSVJR IHZlY3RvciAobnVtYmVyIG9mIElSUXM9JXUpXG4iLAorCQkJbnJfaXJxcyk7CisJCXJldHVybiAt RVBFUk07CisJfQorCisJLyogRGF0YSBzdHJ1Y3R1cmUgaW5pdGlhbGl6YXRpb24gKi8KKwljaGlw LT5kdyA9IGR3OworCWNoaXAtPmRldiA9IGRldjsKKwljaGlwLT5pZCA9IHBkZXYtPmRldmZuOwor CWNoaXAtPmlycSA9IHBkZXYtPmlycTsKKworCWR3LT5yZ19yZWdpb24udmFkZHIgPSAoZG1hX2Fk ZHJfdClwY2ltX2lvbWFwX3RhYmxlKHBkZXYpW3BkYXRhLT5yZ19iYXJdOworCWR3LT5yZ19yZWdp b24udmFkZHIgKz0gcGRhdGEtPnJnX29mZjsKKwlkdy0+cmdfcmVnaW9uLnBhZGRyID0gcGRldi0+ cmVzb3VyY2VbcGRhdGEtPnJnX2Jhcl0uc3RhcnQ7CisJZHctPnJnX3JlZ2lvbi5wYWRkciArPSBw ZGF0YS0+cmdfb2ZmOworCWR3LT5yZ19yZWdpb24uc3ogPSBwZGF0YS0+cmdfc3o7CisKKwlkdy0+ bGxfcmVnaW9uLnZhZGRyID0gKGRtYV9hZGRyX3QpcGNpbV9pb21hcF90YWJsZShwZGV2KVtwZGF0 YS0+bGxfYmFyXTsKKwlkdy0+bGxfcmVnaW9uLnZhZGRyICs9IHBkYXRhLT5sbF9vZmY7CisJZHct PmxsX3JlZ2lvbi5wYWRkciA9IHBkZXYtPnJlc291cmNlW3BkYXRhLT5sbF9iYXJdLnN0YXJ0Owor CWR3LT5sbF9yZWdpb24ucGFkZHIgKz0gcGRhdGEtPmxsX29mZjsKKwlkdy0+bGxfcmVnaW9uLnN6 ID0gcGRhdGEtPmxsX3N6OworCisJZHctPmR0X3JlZ2lvbi52YWRkciA9IChkbWFfYWRkcl90KXBj aW1faW9tYXBfdGFibGUocGRldilbcGRhdGEtPmR0X2Jhcl07CisJZHctPmR0X3JlZ2lvbi52YWRk ciArPSBwZGF0YS0+ZHRfb2ZmOworCWR3LT5kdF9yZWdpb24ucGFkZHIgPSBwZGV2LT5yZXNvdXJj ZVtwZGF0YS0+ZHRfYmFyXS5zdGFydDsKKwlkdy0+ZHRfcmVnaW9uLnBhZGRyICs9IHBkYXRhLT5k dF9vZmY7CisJZHctPmR0X3JlZ2lvbi5zeiA9IHBkYXRhLT5kdF9zejsKKworCWR3LT52ZXJzaW9u ID0gcGRhdGEtPnZlcnNpb247CisJZHctPm1vZGUgPSBwZGF0YS0+bW9kZTsKKwlkdy0+bnJfaXJx cyA9IG5yX2lycXM7CisKKwkvKiBEZWJ1ZyBpbmZvICovCisJcGNpX2RiZyhwZGV2LCAiVmVyc2lv bjpcdCV1XG4iLCBkdy0+dmVyc2lvbik7CisKKwlwY2lfZGJnKHBkZXYsICJNb2RlOlx0JXNcbiIs CisJCWR3LT5tb2RlID09IEVETUFfTU9ERV9MRUdBQ1kgPyAiTGVnYWN5IiA6ICJVbnJvbGwiKTsK KworCXBjaV9kYmcocGRldiwgIlJlZ2lzdGVyczpcdEJBUj0ldSwgb2ZmPTB4JS44bHgsIHN6PTB4 JXp4IGJ5dGVzLCBhZGRyKHY9JXBhLCBwPSVwYSlcbiIsCisJCXBkYXRhLT5yZ19iYXIsIHBkYXRh LT5yZ19vZmYsIHBkYXRhLT5yZ19zeiwKKwkJJmR3LT5yZ19yZWdpb24udmFkZHIsICZkdy0+cmdf cmVnaW9uLnBhZGRyKTsKKworCXBjaV9kYmcocGRldiwgIkwuIExpc3Q6XHRCQVI9JXUsIG9mZj0w eCUuOGx4LCBzej0weCV6eCBieXRlcywgYWRkcih2PSVwYSwgcD0lcGEpXG4iLAorCQlwZGF0YS0+ bGxfYmFyLCBwZGF0YS0+bGxfb2ZmLCBwZGF0YS0+bGxfc3osCisJCSZkdy0+bGxfcmVnaW9uLnZh ZGRyLCAmZHctPmxsX3JlZ2lvbi5wYWRkcik7CisKKwlwY2lfZGJnKHBkZXYsICJEYXRhOlx0QkFS PSV1LCBvZmY9MHglLjhseCwgc3o9MHglenggYnl0ZXMsIGFkZHIodj0lcGEsIHA9JXBhKVxuIiwK KwkJcGRhdGEtPmR0X2JhciwgcGRhdGEtPmR0X29mZiwgcGRhdGEtPmR0X3N6LAorCQkmZHctPmR0 X3JlZ2lvbi52YWRkciwgJmR3LT5kdF9yZWdpb24ucGFkZHIpOworCisJcGNpX2RiZyhwZGV2LCAi TnIuIElSUXM6XHQldVxuIiwgZHctPm5yX2lycXMpOworCisJLyogVmFsaWRhdGluZyBpZiBQQ0kg aW50ZXJydXB0cyB3ZXJlIGVuYWJsZWQgKi8KKwlpZiAoIXBjaV9kZXZfbXNpX2VuYWJsZWQocGRl dikpIHsKKwkJcGNpX2VycihwZGV2LCAiZW5hYmxlIGludGVycnVwdCBmYWlsZWRcbiIpOworCQly ZXR1cm4gLUVQRVJNOworCX0KKworCWR3LT5pcnEgPSBkZXZtX2tjYWxsb2MoZGV2LCBucl9pcnFz LCBzaXplb2YoKmR3LT5pcnEpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWR3LT5pcnEpCisJCXJldHVy biAtRU5PTUVNOworCisJLyogU3RhcnRpbmcgZURNQSBkcml2ZXIgKi8KKwllcnIgPSBkd19lZG1h X3Byb2JlKGNoaXApOworCWlmIChlcnIpIHsKKwkJcGNpX2VycihwZGV2LCAiZURNQSBwcm9iZSBm YWlsZWRcbiIpOworCQlyZXR1cm4gZXJyOworCX0KKworCS8qIFNhdmluZyBkYXRhIHN0cnVjdHVy ZSByZWZlcmVuY2UgKi8KKwlwY2lfc2V0X2RydmRhdGEocGRldiwgY2hpcCk7CisKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIHZvaWQgZHdfZWRtYV9wY2llX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAq cGRldikKK3sKKwlzdHJ1Y3QgZHdfZWRtYV9jaGlwICpjaGlwID0gcGNpX2dldF9kcnZkYXRhKHBk ZXYpOworCWludCBlcnI7CisKKwkvKiBTdG9wcGluZyBlRE1BIGRyaXZlciAqLworCWVyciA9IGR3 X2VkbWFfcmVtb3ZlKGNoaXApOworCWlmIChlcnIpCisJCXBjaV93YXJuKHBkZXYsICJjYW4ndCBy ZW1vdmUgZGV2aWNlIHByb3Blcmx5OiAlZFxuIiwgZXJyKTsKKworCS8qIEZyZWVpbmcgSVJRcyAq LworCXBjaV9mcmVlX2lycV92ZWN0b3JzKHBkZXYpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0 IHBjaV9kZXZpY2VfaWQgZHdfZWRtYV9wY2llX2lkX3RhYmxlW10gPSB7CisJeyBQQ0lfREVWSUNF X0RBVEEoU1lOT1BTWVMsIEVEREEsICZzbnBzX2VkZGFfZGF0YSkgfSwKKwl7IH0KK307CitNT0RV TEVfREVWSUNFX1RBQkxFKHBjaSwgZHdfZWRtYV9wY2llX2lkX3RhYmxlKTsKKworc3RhdGljIHN0 cnVjdCBwY2lfZHJpdmVyIGR3X2VkbWFfcGNpZV9kcml2ZXIgPSB7CisJLm5hbWUJCT0gImR3LWVk bWEtcGNpZSIsCisJLmlkX3RhYmxlCT0gZHdfZWRtYV9wY2llX2lkX3RhYmxlLAorCS5wcm9iZQkJ PSBkd19lZG1hX3BjaWVfcHJvYmUsCisJLnJlbW92ZQkJPSBkd19lZG1hX3BjaWVfcmVtb3ZlLAor fTsKKworbW9kdWxlX3BjaV9kcml2ZXIoZHdfZWRtYV9wY2llX2RyaXZlcik7CisKK01PRFVMRV9M SUNFTlNFKCJHUEwgdjIiKTsKK01PRFVMRV9ERVNDUklQVElPTigiU3lub3BzeXMgRGVzaWduV2Fy ZSBlRE1BIFBDSWUgZHJpdmVyIik7CitNT0RVTEVfQVVUSE9SKCJHdXN0YXZvIFBpbWVudGVsIDxn dXN0YXZvLnBpbWVudGVsQHN5bm9wc3lzLmNvbT4iKTsK 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=unavailable 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 BA600C282E5 for ; Tue, 23 Apr 2019 18:30:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8074D20693 for ; Tue, 23 Apr 2019 18:30:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=synopsys.com header.i=@synopsys.com header.b="J86d5Q+D" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726211AbfDWSa1 (ORCPT ); Tue, 23 Apr 2019 14:30:27 -0400 Received: from dc2-smtprelay2.synopsys.com ([198.182.61.142]:60386 "EHLO smtprelay-out1.synopsys.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726124AbfDWSa0 (ORCPT ); Tue, 23 Apr 2019 14:30:26 -0400 Received: from mailhost.synopsys.com (dc2-mailhost2.synopsys.com [10.12.135.162]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) (No client certificate requested) by smtprelay-out1.synopsys.com (Postfix) with ESMTPS id 1577FC0B16; Tue, 23 Apr 2019 18:30:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=synopsys.com; s=mail; t=1556044225; bh=RmUDVbuamu6fton8ZT3BKpmeH38c4wATuViqRZL99Jo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:In-Reply-To: References:From; b=J86d5Q+DGIYMO2bkyaoNDS6f+dljEv0BEE+/+3zA4sWjl7BYcFAocUyjL3rFAamkE klbE5U2kPmdMnFVQUQoEZNPHaN2adlqtoQXkEr889RUj8+gfOuhUVwR+XJa9Imavj1 Sn1O1uphHQ0SZsJa5rx0de7sBxBP7Ldhg+F1TRsKrKQP3fzdflolDZuSQH1pK45Oi+ efja3+L/wkOIcbc3MIPz6q0sdu+BMBYf14KWWczPRIbwdnzN0tBsUVtshOHIFdkYlE 28Re/SbUmNWo+/iGn/x6AecgBk7E+Yb8UzvsgRgjoMmczflrIxuxtvBH8vwVZEpoD+ hjLUTVp6U8PQA== Received: from de02.synopsys.com (de02.internal.synopsys.com [10.225.17.21]) by mailhost.synopsys.com (Postfix) with ESMTP id CA5E9A009B; Tue, 23 Apr 2019 18:30:25 +0000 (UTC) Received: from de02dwia024.internal.synopsys.com (de02dwia024.internal.synopsys.com [10.225.19.81]) by de02.synopsys.com (Postfix) with ESMTP id 043123F831; Tue, 23 Apr 2019 20:30:24 +0200 (CEST) From: Gustavo Pimentel To: linux-pci@vger.kernel.org, dmaengine@vger.kernel.org Cc: Gustavo Pimentel , Vinod Koul , Dan Williams , Russell King , Lorenzo Pieralisi , Joao Pinto Subject: [RFC v6 5/6] dmaengine: Add Synopsys eDMA IP PCIe glue-logic Date: Tue, 23 Apr 2019 20:30:12 +0200 Message-Id: <7db737e11950c6eced69f68f75584fa1b7b37982.1556043127.git.gustavo.pimentel@synopsys.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: References: In-Reply-To: References: Sender: dmaengine-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: dmaengine@vger.kernel.org Content-Type: text/plain; charset="UTF-8" Message-ID: <20190423183012.yYbiQdOoif_Ps7RKWSxVNteAfCN71yNfVR3tEUxGfLs@z> Synopsys eDMA IP is normally distributed along with Synopsys PCIe EndPoint IP (depends of the use and licensing agreement). This IP requires some basic configurations, such as: - eDMA registers BAR - eDMA registers offset - eDMA registers size - eDMA linked list memory BAR - eDMA linked list memory offset - eDMA linked list memory size - eDMA data memory BAR - eDMA data memory offset - eDMA data memory size - eDMA version - eDMA mode - IRQs available for eDMA As a working example, PCIe glue-logic will attach to a Synopsys PCIe EndPoint IP prototype kit (Vendor ID = 0x16c3, Device ID = 0xedda), which has built-in an eDMA IP with this default configuration: - eDMA registers BAR = 0 - eDMA registers offset = 0x00001000 (4 Kbytes) - eDMA registers size = 0x00002000 (8 Kbytes) - eDMA linked list memory BAR = 2 - eDMA linked list memory offset = 0x00000000 (0 Kbytes) - eDMA linked list memory size = 0x00800000 (8 Mbytes) - eDMA data memory BAR = 2 - eDMA data memory offset = 0x00800000 (8 Mbytes) - eDMA data memory size = 0x03800000 (56 Mbytes) - eDMA version = 0 - eDMA mode = EDMA_MODE_UNROLL - IRQs = 1 This driver can be compile as built-in or external module in kernel. To enable this driver just select DW_EDMA_PCIE option in kernel configuration, however it requires and selects automatically DW_EDMA option too. Signed-off-by: Gustavo Pimentel Cc: Vinod Koul Cc: Dan Williams Cc: Russell King Cc: Lorenzo Pieralisi Cc: Joao Pinto --- Changes: RFC v1->RFC v2: - Replace comments // (C99 style) by /**/ - Merge two pcim_iomap_regions() calls into just one call - Remove pci_try_set_mwi() call - Replace some dev_info() by dev_dbg() to reduce *noise* - Remove pci_name(pdev) call after being call dw_edma_remove() - Remove all power management support - 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 RFC v2->RFC v3: - Fix printk variable of phys_addr_t type - Fix missing variable initialization (chan->configured) - Change linked list size to 512 Kbytes - Add data memory information - Add register size information - Add comments or improve existing ones - Add possibility to work with multiple IRQs feature - Replace MSI and MSI-X enable condition by pci_dev_msi_enabled() - Replace code to acquire MSI(-X) address and data by get_cached_msi_msg() - Rebase to v5.0-rc1 RFC v3->RFC v4: - Replace enum dw_edma_pcie and use by enum pci_barno - Remove unnecessary dev_info() calls - Remove unnecessary pointer null validation - Reorder variables declaration in reverse tree order in dw_edma_pcie_probe() - Remove pdata validation - Remove disable_msix parameter - Fix license header - Move get_cached_msi_msg() to dw-edma-core file RFC v4->RFC v5: - Patch resended, forgot to replace of '___' by '---' and to remove duplicate signed-off RFC v5->RFC v6: - Add author on file header drivers/dma/dw-edma/Kconfig | 9 ++ drivers/dma/dw-edma/Makefile | 1 + drivers/dma/dw-edma/dw-edma-pcie.c | 229 +++++++++++++++++++++++++++++++++++++ 3 files changed, 239 insertions(+) create mode 100644 drivers/dma/dw-edma/dw-edma-pcie.c diff --git a/drivers/dma/dw-edma/Kconfig b/drivers/dma/dw-edma/Kconfig index 3016bed..c0838ce 100644 --- a/drivers/dma/dw-edma/Kconfig +++ b/drivers/dma/dw-edma/Kconfig @@ -7,3 +7,12 @@ config DW_EDMA help Support the Synopsys DesignWare eDMA controller, normally implemented on endpoints SoCs. + +config DW_EDMA_PCIE + tristate "Synopsys DesignWare eDMA PCIe driver" + depends on PCI && PCI_MSI + select DW_EDMA + help + Provides a glue-logic between the Synopsys DesignWare + eDMA controller and an endpoint PCIe device. This also serves + as a reference design to whom desires to use this IP. diff --git a/drivers/dma/dw-edma/Makefile b/drivers/dma/dw-edma/Makefile index 0c53033..8d45c0d 100644 --- a/drivers/dma/dw-edma/Makefile +++ b/drivers/dma/dw-edma/Makefile @@ -4,3 +4,4 @@ obj-$(CONFIG_DW_EDMA) += dw-edma.o dw-edma-$(CONFIG_DEBUG_FS) := dw-edma-v0-debugfs.o dw-edma-objs := dw-edma-core.o \ dw-edma-v0-core.o $(dw-edma-y) +obj-$(CONFIG_DW_EDMA_PCIE) += dw-edma-pcie.o diff --git a/drivers/dma/dw-edma/dw-edma-pcie.c b/drivers/dma/dw-edma/dw-edma-pcie.c new file mode 100644 index 0000000..4c96e1c --- /dev/null +++ b/drivers/dma/dw-edma/dw-edma-pcie.c @@ -0,0 +1,229 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2018-2019 Synopsys, Inc. and/or its affiliates. + * Synopsys DesignWare eDMA PCIe driver + * + * Author: Gustavo Pimentel + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "dw-edma-core.h" + +struct dw_edma_pcie_data { + /* eDMA registers location */ + enum pci_barno rg_bar; + off_t rg_off; + size_t rg_sz; + /* eDMA memory linked list location */ + enum pci_barno ll_bar; + off_t ll_off; + size_t ll_sz; + /* eDMA memory data location */ + enum pci_barno dt_bar; + off_t dt_off; + size_t dt_sz; + /* Other */ + u32 version; + enum dw_edma_mode mode; + u8 irqs; +}; + +static const struct dw_edma_pcie_data snps_edda_data = { + /* eDMA registers location */ + .rg_bar = BAR_0, + .rg_off = 0x00001000, /* 4 Kbytes */ + .rg_sz = 0x00002000, /* 8 Kbytes */ + /* eDMA memory linked list location */ + .ll_bar = BAR_2, + .ll_off = 0x00000000, /* 0 Kbytes */ + .ll_sz = 0x00800000, /* 8 Mbytes */ + /* eDMA memory data location */ + .dt_bar = BAR_2, + .dt_off = 0x00800000, /* 8 Mbytes */ + .dt_sz = 0x03800000, /* 56 Mbytes */ + /* Other */ + .version = 0, + .mode = EDMA_MODE_UNROLL, + .irqs = 1, +}; + +static int dw_edma_pcie_probe(struct pci_dev *pdev, + const struct pci_device_id *pid) +{ + const struct dw_edma_pcie_data *pdata = (void *)pid->driver_data; + struct device *dev = &pdev->dev; + struct dw_edma_chip *chip; + int err, nr_irqs; + struct dw_edma *dw; + + /* Enable PCI device */ + err = pcim_enable_device(pdev); + if (err) { + pci_err(pdev, "enabling device failed\n"); + return err; + } + + /* Mapping PCI BAR regions */ + err = pcim_iomap_regions(pdev, BIT(pdata->rg_bar) | + BIT(pdata->ll_bar) | + BIT(pdata->dt_bar), + pci_name(pdev)); + if (err) { + pci_err(pdev, "eDMA BAR I/O remapping failed\n"); + return err; + } + + pci_set_master(pdev); + + /* DMA configuration */ + err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)); + if (!err) { + err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); + if (err) { + pci_err(pdev, "consistent DMA mask 64 set failed\n"); + return err; + } + } else { + pci_err(pdev, "DMA mask 64 set failed\n"); + + err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); + if (err) { + pci_err(pdev, "DMA mask 32 set failed\n"); + return err; + } + + err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); + if (err) { + pci_err(pdev, "consistent DMA mask 32 set failed\n"); + return err; + } + } + + /* Data structure allocation */ + chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL); + if (!chip) + return -ENOMEM; + + dw = devm_kzalloc(dev, sizeof(*dw), GFP_KERNEL); + if (!dw) + return -ENOMEM; + + /* IRQs allocation */ + nr_irqs = pci_alloc_irq_vectors(pdev, 1, pdata->irqs, + PCI_IRQ_MSI | PCI_IRQ_MSIX); + if (nr_irqs < 1) { + pci_err(pdev, "fail to alloc IRQ vector (number of IRQs=%u)\n", + nr_irqs); + return -EPERM; + } + + /* Data structure initialization */ + chip->dw = dw; + chip->dev = dev; + chip->id = pdev->devfn; + chip->irq = pdev->irq; + + dw->rg_region.vaddr = (dma_addr_t)pcim_iomap_table(pdev)[pdata->rg_bar]; + dw->rg_region.vaddr += pdata->rg_off; + dw->rg_region.paddr = pdev->resource[pdata->rg_bar].start; + dw->rg_region.paddr += pdata->rg_off; + dw->rg_region.sz = pdata->rg_sz; + + dw->ll_region.vaddr = (dma_addr_t)pcim_iomap_table(pdev)[pdata->ll_bar]; + dw->ll_region.vaddr += pdata->ll_off; + dw->ll_region.paddr = pdev->resource[pdata->ll_bar].start; + dw->ll_region.paddr += pdata->ll_off; + dw->ll_region.sz = pdata->ll_sz; + + dw->dt_region.vaddr = (dma_addr_t)pcim_iomap_table(pdev)[pdata->dt_bar]; + dw->dt_region.vaddr += pdata->dt_off; + dw->dt_region.paddr = pdev->resource[pdata->dt_bar].start; + dw->dt_region.paddr += pdata->dt_off; + dw->dt_region.sz = pdata->dt_sz; + + dw->version = pdata->version; + dw->mode = pdata->mode; + dw->nr_irqs = nr_irqs; + + /* Debug info */ + pci_dbg(pdev, "Version:\t%u\n", dw->version); + + pci_dbg(pdev, "Mode:\t%s\n", + dw->mode == EDMA_MODE_LEGACY ? "Legacy" : "Unroll"); + + pci_dbg(pdev, "Registers:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%pa, p=%pa)\n", + pdata->rg_bar, pdata->rg_off, pdata->rg_sz, + &dw->rg_region.vaddr, &dw->rg_region.paddr); + + pci_dbg(pdev, "L. List:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%pa, p=%pa)\n", + pdata->ll_bar, pdata->ll_off, pdata->ll_sz, + &dw->ll_region.vaddr, &dw->ll_region.paddr); + + pci_dbg(pdev, "Data:\tBAR=%u, off=0x%.8lx, sz=0x%zx bytes, addr(v=%pa, p=%pa)\n", + pdata->dt_bar, pdata->dt_off, pdata->dt_sz, + &dw->dt_region.vaddr, &dw->dt_region.paddr); + + pci_dbg(pdev, "Nr. IRQs:\t%u\n", dw->nr_irqs); + + /* Validating if PCI interrupts were enabled */ + if (!pci_dev_msi_enabled(pdev)) { + pci_err(pdev, "enable interrupt failed\n"); + return -EPERM; + } + + dw->irq = devm_kcalloc(dev, nr_irqs, sizeof(*dw->irq), GFP_KERNEL); + if (!dw->irq) + return -ENOMEM; + + /* Starting eDMA driver */ + err = dw_edma_probe(chip); + if (err) { + pci_err(pdev, "eDMA probe failed\n"); + return err; + } + + /* Saving data structure reference */ + pci_set_drvdata(pdev, chip); + + return 0; +} + +static void dw_edma_pcie_remove(struct pci_dev *pdev) +{ + struct dw_edma_chip *chip = pci_get_drvdata(pdev); + int err; + + /* Stopping eDMA driver */ + err = dw_edma_remove(chip); + if (err) + pci_warn(pdev, "can't remove device properly: %d\n", err); + + /* Freeing IRQs */ + pci_free_irq_vectors(pdev); +} + +static const struct pci_device_id dw_edma_pcie_id_table[] = { + { PCI_DEVICE_DATA(SYNOPSYS, EDDA, &snps_edda_data) }, + { } +}; +MODULE_DEVICE_TABLE(pci, dw_edma_pcie_id_table); + +static struct pci_driver dw_edma_pcie_driver = { + .name = "dw-edma-pcie", + .id_table = dw_edma_pcie_id_table, + .probe = dw_edma_pcie_probe, + .remove = dw_edma_pcie_remove, +}; + +module_pci_driver(dw_edma_pcie_driver); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("Synopsys DesignWare eDMA PCIe driver"); +MODULE_AUTHOR("Gustavo Pimentel "); -- 2.7.4