From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [V3,1/2] dmaengine: fsl-dpaa2-qdma: Add the DPDMAI(Data Path DMA Interface) support From: Peng Ma Message-Id: <20190409072212.15860-1-peng.ma@nxp.com> Date: Tue, 9 Apr 2019 15:22:11 +0800 To: vkoul@kernel.org, dan.j.williams@intel.com, leoyang.li@nxp.com Cc: linux-kernel@vger.kernel.org, dmaengine@vger.kernel.org, Peng Ma List-ID: VGhlIE1DIGV4cG9ydHMgdGhlIERQRE1BSSBvYmplY3QgYXMgYW4gaW50ZXJmYWNlIHRvIG9wZXJh dGUgdGhlIERQQUEyIFFETUEKRW5naW5lLiBUaGUgRFBETUFJIGVuYWJsZXMgc2VuZGluZyBmcmFt ZS1iYXNlZCByZXF1ZXN0cyB0byBRRE1BIGFuZCByZWNlaXZpbmcKYmFjayBjb25maXJtYXRpb24g cmVzcG9uc2Ugb24gdHJhbnNhY3Rpb24gY29tcGxldGlvbiwgdXRpbGl6aW5nIHRoZSBEUEFBMiBR Qk1hbgppbmZyYXN0cnVjdHVyZS4gRFBETUFJIG9iamVjdCBwcm92aWRlcyB1cCB0byB0d28gcHJp b3JpdGllcyBmb3IgcHJvY2Vzc2luZyBRRE1BCnJlcXVlc3RzLgpUaGUgZm9sbG93aW5nIGxpc3Qg c3VtbWFyaXplcyB0aGUgRFBETUFJIG1haW4gZmVhdHVyZXMgYW5kIGNhcGFiaWxpdGllczoKCTEu IFN1cHBvcnRzIHVwIHRvIHR3byBzY2hlZHVsaW5nIHByaW9yaXRpZXMgZm9yIHByb2Nlc3Npbmcg c2VydmljZQoJcmVxdWVzdHMuCgktIEVhY2ggRFBETUFJIHRyYW5zbWl0IHF1ZXVlIGlzIG1hcHBl ZCB0byBvbmUgb2YgdHdvIHNlcnZpY2UgcHJpb3JpdGllcywKCWFsbG93aW5nIGZ1cnRoZXIgcHJp b3JpdGl6YXRpb24gaW4gaGFyZHdhcmUgYmV0d2VlbiByZXF1ZXN0cyBmcm9tCglkaWZmZXJlbnQg RFBETUFJIG9iamVjdHMuCgkyLiBTdXBwb3J0cyB1cCB0byB0d28gcmVjZWl2ZSBxdWV1ZXMgZm9y IGluY29taW5nIHRyYW5zYWN0aW9uIGNvbXBsZXRpb24KCWNvbmZpcm1hdGlvbnMuCgktIEVhY2gg RFBETUFJIHJlY2VpdmUgcXVldWUgaXMgbWFwcGVkIHRvIG9uZSBvZiB0d28gcmVjZWl2ZSBwcmlv cml0aWVzLAoJYWxsb3dpbmcgZnVydGhlciBwcmlvcml0aXphdGlvbiBiZXR3ZWVuIG90aGVyIGlu dGVyZmFjZXMgd2hlbiBhc3NvY2lhdGluZwoJdGhlIERQRE1BSSByZWNlaXZlIHF1ZXVlcyB0byBE UElPIG9yIERQQ09OIG9iamVjdHMuCgkzLiBTdXBwb3J0cyBkaWZmZXJlbnQgc2NoZWR1bGluZyBv cHRpb25zIGZvciBwcm9jZXNzaW5nIHJlY2VpdmVkIHBhY2tldHM6CgktIFF1ZXVlcyBjYW4gYmUg Y29uZmlndXJlZCBlaXRoZXIgaW4gJ3BhcmtlZCcgbW9kZSAoZGVmYXVsdCksIG9hdHRhY2hlZAoJ dG8gYSBEUElPIG9iamVjdCwgb3IgYXR0YWNoZWQgdG8gRFBDT04gb2JqZWN0LgoJNC4gQWxsb3dz IGludGVyYWN0aW9uIHdpdGggb25lIG9yIG1vcmUgRFBJTyBvYmplY3RzIGZvciBkZXF1ZXVlaW5n L2VucXVldWVpbmcKCWZyYW1lIGRlc2NyaXB0b3JzKEZEKSBhbmQgZm9yIGFjcXVpcmluZy9yZWxl YXNpbmcgYnVmZmVycy4KCTUuIFN1cHBvcnRzIGVuYWJsZSwgZGlzYWJsZSwgYW5kIHJlc2V0IG9w ZXJhdGlvbnMuCkFkZCBkcGRtYWkgdG8gc3VwcG9ydCBzb21lIHBsYXRmb3JtcyB3aXRoIGRwYWEy IHFkbWEgZW5naW5lLgoKU2lnbmVkLW9mZi1ieTogUGVuZyBNYSA8cGVuZy5tYUBueHAuY29tPgot LS0KY2hhbmdlZCBmb3IgdjM6CgktIG5vIGNoYW5nZWQgCgogZHJpdmVycy9kbWEvZnNsLWRwYWEy LXFkbWEvZHBkbWFpLmMgICAgIHwgIDQ4MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBk cml2ZXJzL2RtYS9mc2wtZHBhYTItcWRtYS9kcGRtYWkuaCAgICAgfCAgNTI0ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZG1hL2ZzbC1kcGFhMi1xZG1hL2RwZG1haV9j bWQuaCB8ICAxOTcgKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDEyMDQgaW5zZXJ0aW9u cygrKSwgMCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS9mc2wt ZHBhYTItcWRtYS9kcGRtYWkuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZG1hL2ZzbC1k cGFhMi1xZG1hL2RwZG1haS5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEvZnNsLWRw YWEyLXFkbWEvZHBkbWFpX2NtZC5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZnNsLWRwYWEy LXFkbWEvZHBkbWFpLmMgYi9kcml2ZXJzL2RtYS9mc2wtZHBhYTItcWRtYS9kcGRtYWkuYwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ODVlYWJlCi0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9kbWEvZnNsLWRwYWEyLXFkbWEvZHBkbWFpLmMKQEAgLTAsMCArMSw0ODMgQEAK Ky8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvLyBDb3B5cmlnaHQgMjAxNC0y MDE4IE5YUAorCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5o PgorI2luY2x1ZGUgImRwZG1haS5oIgorI2luY2x1ZGUgImRwZG1haV9jbWQuaCIKKyNpbmNsdWRl IDxsaW51eC9mc2wvbWMuaD4KKworc3RydWN0IGRwZG1haV9jbWRfb3BlbiB7CisJX19sZTMyIGRw ZG1haV9pZDsKK307CisKK3N0cnVjdCBkcGRtYWlfcnNwX2dldF9hdHRyaWJ1dGVzIHsKKwlfX2xl MzIgaWQ7CisJdTggbnVtX29mX3ByaW9yaXRpZXM7CisJdTggcGFkMFszXTsKKwlfX2xlMTYgbWFq b3I7CisJX19sZTE2IG1pbm9yOworfTsKKworc3RydWN0IGRwZG1haV9jbWRfcXVldWUgeworCV9f bGUzMiBkZXN0X2lkOworCXU4IHByaW9yaXR5OworCXU4IHF1ZXVlOworCXU4IGRlc3RfdHlwZTsK Kwl1OCBwYWQ7CisJX19sZTY0IHVzZXJfY3R4OworCXVuaW9uIHsKKwkJX19sZTMyIG9wdGlvbnM7 CisJCV9fbGUzMiBmcWlkOworCX07Cit9OworCitzdHJ1Y3QgZHBkbWFpX3JzcF9nZXRfdHhfcXVl dWUgeworCV9fbGU2NCBwYWQ7CisJX19sZTMyIGZxaWQ7Cit9OworCitpbnQgZHBkbWFpX29wZW4o c3RydWN0IGZzbF9tY19pbyAqbWNfaW8sCisJCXUzMiBjbWRfZmxhZ3MsCisJCWludCBkcGRtYWlf aWQsCisJCXUxNiAqdG9rZW4pCit7CisJc3RydWN0IGZzbF9tY19jb21tYW5kIGNtZCA9IHsgMCB9 OworCXN0cnVjdCBkcGRtYWlfY21kX29wZW4gKmNtZF9wYXJhbXM7CisJaW50IGVycjsKKworCS8q IHByZXBhcmUgY29tbWFuZCAqLworCWNtZC5oZWFkZXIgPSBtY19lbmNvZGVfY21kX2hlYWRlcihE UERNQUlfQ01ESURfT1BFTiwKKwkJCQkJICBjbWRfZmxhZ3MsCisJCQkJCSAgMCk7CisKKwljbWRf cGFyYW1zID0gKHN0cnVjdCBkcGRtYWlfY21kX29wZW4gKiljbWQucGFyYW1zOworCWNtZF9wYXJh bXMtPmRwZG1haV9pZCA9IGNwdV90b19sZTMyKGRwZG1haV9pZCk7CisKKwkvKiBzZW5kIGNvbW1h bmQgdG8gbWMqLworCWVyciA9IG1jX3NlbmRfY29tbWFuZChtY19pbywgJmNtZCk7CisJaWYgKGVy cikKKwkJcmV0dXJuIGVycjsKKworCS8qIHJldHJpZXZlIHJlc3BvbnNlIHBhcmFtZXRlcnMgKi8K KwkqdG9rZW4gPSBtY19jbWRfaGRyX3JlYWRfdG9rZW4oJmNtZCk7CisJcmV0dXJuIDA7Cit9CisK K2ludCBkcGRtYWlfY2xvc2Uoc3RydWN0IGZzbF9tY19pbyAqbWNfaW8sCisJCSB1MzIgY21kX2Zs YWdzLAorCQkgdTE2IHRva2VuKQoreworCXN0cnVjdCBmc2xfbWNfY29tbWFuZCBjbWQgPSB7IDAg fTsKKworCS8qIHByZXBhcmUgY29tbWFuZCAqLworCWNtZC5oZWFkZXIgPSBtY19lbmNvZGVfY21k X2hlYWRlcihEUERNQUlfQ01ESURfQ0xPU0UsCisJCQkJCSAgY21kX2ZsYWdzLCB0b2tlbik7CisK KwkvKiBzZW5kIGNvbW1hbmQgdG8gbWMqLworCXJldHVybiBtY19zZW5kX2NvbW1hbmQobWNfaW8s ICZjbWQpOworfQorCitpbnQgZHBkbWFpX2NyZWF0ZShzdHJ1Y3QgZnNsX21jX2lvICptY19pbywK KwkJICB1MzIgY21kX2ZsYWdzLAorCQkgIGNvbnN0IHN0cnVjdCBkcGRtYWlfY2ZnICpjZmcsCisJ CSAgdTE2ICp0b2tlbikKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQgY21kID0geyAwIH07CisJ aW50IGVycjsKKworCS8qIHByZXBhcmUgY29tbWFuZCAqLworCWNtZC5oZWFkZXIgPSBtY19lbmNv ZGVfY21kX2hlYWRlcihEUERNQUlfQ01ESURfQ1JFQVRFLAorCQkJCQkgIGNtZF9mbGFncywKKwkJ CQkJICAwKTsKKwlEUERNQUlfQ01EX0NSRUFURShjbWQsIGNmZyk7CisKKwkvKiBzZW5kIGNvbW1h bmQgdG8gbWMqLworCWVyciA9IG1jX3NlbmRfY29tbWFuZChtY19pbywgJmNtZCk7CisJaWYgKGVy cikKKwkJcmV0dXJuIGVycjsKKworCS8qIHJldHJpZXZlIHJlc3BvbnNlIHBhcmFtZXRlcnMgKi8K KwkqdG9rZW4gPSBNQ19DTURfSERSX1JFQURfVE9LRU4oY21kLmhlYWRlcik7CisKKwlyZXR1cm4g MDsKK30KKworaW50IGRwZG1haV9kZXN0cm95KHN0cnVjdCBmc2xfbWNfaW8gKm1jX2lvLAorCQkg ICB1MzIgY21kX2ZsYWdzLAorCQkgICB1MTYgdG9rZW4pCit7CisJc3RydWN0IGZzbF9tY19jb21t YW5kIGNtZCA9IHsgMCB9OworCisJLyogcHJlcGFyZSBjb21tYW5kICovCisJY21kLmhlYWRlciA9 IG1jX2VuY29kZV9jbWRfaGVhZGVyKERQRE1BSV9DTURJRF9ERVNUUk9ZLAorCQkJCQkgIGNtZF9m bGFncywKKwkJCQkJICB0b2tlbik7CisKKwkvKiBzZW5kIGNvbW1hbmQgdG8gbWMqLworCXJldHVy biBtY19zZW5kX2NvbW1hbmQobWNfaW8sICZjbWQpOworfQorCitpbnQgZHBkbWFpX2VuYWJsZShz dHJ1Y3QgZnNsX21jX2lvICptY19pbywKKwkJICB1MzIgY21kX2ZsYWdzLAorCQkgIHUxNiB0b2tl bikKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQgY21kID0geyAwIH07CisKKwkvKiBwcmVwYXJl IGNvbW1hbmQgKi8KKwljbWQuaGVhZGVyID0gbWNfZW5jb2RlX2NtZF9oZWFkZXIoRFBETUFJX0NN RElEX0VOQUJMRSwKKwkJCQkJICBjbWRfZmxhZ3MsCisJCQkJCSAgdG9rZW4pOworCisJLyogc2Vu ZCBjb21tYW5kIHRvIG1jKi8KKwlyZXR1cm4gbWNfc2VuZF9jb21tYW5kKG1jX2lvLCAmY21kKTsK K30KKworaW50IGRwZG1haV9kaXNhYmxlKHN0cnVjdCBmc2xfbWNfaW8gKm1jX2lvLAorCQkgICB1 MzIgY21kX2ZsYWdzLAorCQkgICB1MTYgdG9rZW4pCit7CisJc3RydWN0IGZzbF9tY19jb21tYW5k IGNtZCA9IHsgMCB9OworCisJLyogcHJlcGFyZSBjb21tYW5kICovCisJY21kLmhlYWRlciA9IG1j X2VuY29kZV9jbWRfaGVhZGVyKERQRE1BSV9DTURJRF9ESVNBQkxFLAorCQkJCQkgIGNtZF9mbGFn cywKKwkJCQkJICB0b2tlbik7CisKKwkvKiBzZW5kIGNvbW1hbmQgdG8gbWMqLworCXJldHVybiBt Y19zZW5kX2NvbW1hbmQobWNfaW8sICZjbWQpOworfQorCitpbnQgZHBkbWFpX2lzX2VuYWJsZWQo c3RydWN0IGZzbF9tY19pbyAqbWNfaW8sCisJCSAgICAgIHUzMiBjbWRfZmxhZ3MsCisJCSAgICAg IHUxNiB0b2tlbiwKKwkJICAgICAgaW50ICplbikKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQg Y21kID0geyAwIH07CisJaW50IGVycjsKKwkvKiBwcmVwYXJlIGNvbW1hbmQgKi8KKwljbWQuaGVh ZGVyID0gbWNfZW5jb2RlX2NtZF9oZWFkZXIoRFBETUFJX0NNRElEX0lTX0VOQUJMRUQsCisJCQkJ CSAgY21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsKKworCS8qIHNlbmQgY29tbWFuZCB0byBtYyov CisJZXJyID0gbWNfc2VuZF9jb21tYW5kKG1jX2lvLCAmY21kKTsKKwlpZiAoZXJyKQorCQlyZXR1 cm4gZXJyOworCisJLyogcmV0cmlldmUgcmVzcG9uc2UgcGFyYW1ldGVycyAqLworCURQRE1BSV9S U1BfSVNfRU5BQkxFRChjbWQsICplbik7CisKKwlyZXR1cm4gMDsKK30KKworaW50IGRwZG1haV9y ZXNldChzdHJ1Y3QgZnNsX21jX2lvICptY19pbywKKwkJIHUzMiBjbWRfZmxhZ3MsCisJCSB1MTYg dG9rZW4pCit7CisJc3RydWN0IGZzbF9tY19jb21tYW5kIGNtZCA9IHsgMCB9OworCisJLyogcHJl cGFyZSBjb21tYW5kICovCisJY21kLmhlYWRlciA9IG1jX2VuY29kZV9jbWRfaGVhZGVyKERQRE1B SV9DTURJRF9SRVNFVCwKKwkJCQkJICBjbWRfZmxhZ3MsCisJCQkJCSAgdG9rZW4pOworCisJLyog c2VuZCBjb21tYW5kIHRvIG1jKi8KKwlyZXR1cm4gbWNfc2VuZF9jb21tYW5kKG1jX2lvLCAmY21k KTsKK30KKworaW50IGRwZG1haV9nZXRfaXJxKHN0cnVjdCBmc2xfbWNfaW8gKm1jX2lvLAorCQkg ICB1MzIgY21kX2ZsYWdzLAorCQkgICB1MTYgdG9rZW4sCisJCSAgIHU4IGlycV9pbmRleCwKKwkJ ICAgaW50ICp0eXBlLAorCQkgICBzdHJ1Y3QgZHBkbWFpX2lycV9jZmcJKmlycV9jZmcpCit7CisJ c3RydWN0IGZzbF9tY19jb21tYW5kIGNtZCA9IHsgMCB9OworCWludCBlcnI7CisKKwkvKiBwcmVw YXJlIGNvbW1hbmQgKi8KKwljbWQuaGVhZGVyID0gbWNfZW5jb2RlX2NtZF9oZWFkZXIoRFBETUFJ X0NNRElEX0dFVF9JUlEsCisJCQkJCSAgY21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsKKwlEUERN QUlfQ01EX0dFVF9JUlEoY21kLCBpcnFfaW5kZXgpOworCisJLyogc2VuZCBjb21tYW5kIHRvIG1j Ki8KKwllcnIgPSBtY19zZW5kX2NvbW1hbmQobWNfaW8sICZjbWQpOworCWlmIChlcnIpCisJCXJl dHVybiBlcnI7CisKKwkvKiByZXRyaWV2ZSByZXNwb25zZSBwYXJhbWV0ZXJzICovCisJRFBETUFJ X1JTUF9HRVRfSVJRKGNtZCwgKnR5cGUsIGlycV9jZmcpOworCisJcmV0dXJuIDA7Cit9CisKK2lu dCBkcGRtYWlfc2V0X2lycShzdHJ1Y3QgZnNsX21jX2lvICptY19pbywKKwkJICAgdTMyIGNtZF9m bGFncywKKwkJICAgdTE2IHRva2VuLAorCQkgICB1OCBpcnFfaW5kZXgsCisJCSAgIHN0cnVjdCBk cGRtYWlfaXJxX2NmZyAqaXJxX2NmZykKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQgY21kID0g eyAwIH07CisKKwkvKiBwcmVwYXJlIGNvbW1hbmQgKi8KKwljbWQuaGVhZGVyID0gbWNfZW5jb2Rl X2NtZF9oZWFkZXIoRFBETUFJX0NNRElEX1NFVF9JUlEsCisJCQkJCSAgY21kX2ZsYWdzLAorCQkJ CQkgIHRva2VuKTsKKwlEUERNQUlfQ01EX1NFVF9JUlEoY21kLCBpcnFfaW5kZXgsIGlycV9jZmcp OworCisJLyogc2VuZCBjb21tYW5kIHRvIG1jKi8KKwlyZXR1cm4gbWNfc2VuZF9jb21tYW5kKG1j X2lvLCAmY21kKTsKK30KKworaW50IGRwZG1haV9nZXRfaXJxX2VuYWJsZShzdHJ1Y3QgZnNsX21j X2lvICptY19pbywKKwkJCSAgdTMyIGNtZF9mbGFncywKKwkJCSAgdTE2IHRva2VuLAorCQkJICB1 OCBpcnFfaW5kZXgsCisJCQkgIHU4ICplbikKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQgY21k ID0geyAwIH07CisJaW50IGVycjsKKworCS8qIHByZXBhcmUgY29tbWFuZCAqLworCWNtZC5oZWFk ZXIgPSBtY19lbmNvZGVfY21kX2hlYWRlcihEUERNQUlfQ01ESURfR0VUX0lSUV9FTkFCTEUsCisJ CQkJCSAgY21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsKKwlEUERNQUlfQ01EX0dFVF9JUlFfRU5B QkxFKGNtZCwgaXJxX2luZGV4KTsKKworCS8qIHNlbmQgY29tbWFuZCB0byBtYyovCisJZXJyID0g bWNfc2VuZF9jb21tYW5kKG1jX2lvLCAmY21kKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwor CisJLyogcmV0cmlldmUgcmVzcG9uc2UgcGFyYW1ldGVycyAqLworCURQRE1BSV9SU1BfR0VUX0lS UV9FTkFCTEUoY21kLCAqZW4pOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBkcGRtYWlfc2V0X2ly cV9lbmFibGUoc3RydWN0IGZzbF9tY19pbyAqbWNfaW8sCisJCQkgIHUzMiBjbWRfZmxhZ3MsCisJ CQkgIHUxNiB0b2tlbiwKKwkJCSAgdTggaXJxX2luZGV4LAorCQkJICB1OCBlbikKK3sKKwlzdHJ1 Y3QgZnNsX21jX2NvbW1hbmQgY21kID0geyAwIH07CisKKwkvKiBwcmVwYXJlIGNvbW1hbmQgKi8K KwljbWQuaGVhZGVyID0gbWNfZW5jb2RlX2NtZF9oZWFkZXIoRFBETUFJX0NNRElEX1NFVF9JUlFf RU5BQkxFLAorCQkJCQkgIGNtZF9mbGFncywKKwkJCQkJICB0b2tlbik7CisJRFBETUFJX0NNRF9T RVRfSVJRX0VOQUJMRShjbWQsIGlycV9pbmRleCwgZW4pOworCisJLyogc2VuZCBjb21tYW5kIHRv IG1jKi8KKwlyZXR1cm4gbWNfc2VuZF9jb21tYW5kKG1jX2lvLCAmY21kKTsKK30KKworaW50IGRw ZG1haV9nZXRfaXJxX21hc2soc3RydWN0IGZzbF9tY19pbyAqbWNfaW8sCisJCQl1MzIgY21kX2Zs YWdzLAorCQkJdTE2IHRva2VuLAorCQkJdTggaXJxX2luZGV4LAorCQkJdTMyICptYXNrKQorewor CXN0cnVjdCBmc2xfbWNfY29tbWFuZCBjbWQgPSB7IDAgfTsKKwlpbnQgZXJyOworCisJLyogcHJl cGFyZSBjb21tYW5kICovCisJY21kLmhlYWRlciA9IG1jX2VuY29kZV9jbWRfaGVhZGVyKERQRE1B SV9DTURJRF9HRVRfSVJRX01BU0ssCisJCQkJCSAgY21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsK KwlEUERNQUlfQ01EX0dFVF9JUlFfTUFTSyhjbWQsIGlycV9pbmRleCk7CisKKwkvKiBzZW5kIGNv bW1hbmQgdG8gbWMqLworCWVyciA9IG1jX3NlbmRfY29tbWFuZChtY19pbywgJmNtZCk7CisJaWYg KGVycikKKwkJcmV0dXJuIGVycjsKKworCS8qIHJldHJpZXZlIHJlc3BvbnNlIHBhcmFtZXRlcnMg Ki8KKwlEUERNQUlfUlNQX0dFVF9JUlFfTUFTSyhjbWQsICptYXNrKTsKKworCXJldHVybiAwOwor fQorCitpbnQgZHBkbWFpX3NldF9pcnFfbWFzayhzdHJ1Y3QgZnNsX21jX2lvICptY19pbywKKwkJ CXUzMiBjbWRfZmxhZ3MsCisJCQl1MTYgdG9rZW4sCisJCQl1OCBpcnFfaW5kZXgsCisJCQl1MzIg bWFzaykKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQgY21kID0geyAwIH07CisKKwkvKiBwcmVw YXJlIGNvbW1hbmQgKi8KKwljbWQuaGVhZGVyID0gbWNfZW5jb2RlX2NtZF9oZWFkZXIoRFBETUFJ X0NNRElEX1NFVF9JUlFfTUFTSywKKwkJCQkJICBjbWRfZmxhZ3MsCisJCQkJCSAgdG9rZW4pOwor CURQRE1BSV9DTURfU0VUX0lSUV9NQVNLKGNtZCwgaXJxX2luZGV4LCBtYXNrKTsKKworCS8qIHNl bmQgY29tbWFuZCB0byBtYyovCisJcmV0dXJuIG1jX3NlbmRfY29tbWFuZChtY19pbywgJmNtZCk7 Cit9CisKK2ludCBkcGRtYWlfZ2V0X2lycV9zdGF0dXMoc3RydWN0IGZzbF9tY19pbyAqbWNfaW8s CisJCQkgIHUzMiBjbWRfZmxhZ3MsCisJCQkgIHUxNiB0b2tlbiwKKwkJCSAgdTggaXJxX2luZGV4 LAorCQkJICB1MzIgKnN0YXR1cykKK3sKKwlzdHJ1Y3QgZnNsX21jX2NvbW1hbmQgY21kID0geyAw IH07CisJaW50IGVycjsKKworCS8qIHByZXBhcmUgY29tbWFuZCAqLworCWNtZC5oZWFkZXIgPSBt Y19lbmNvZGVfY21kX2hlYWRlcihEUERNQUlfQ01ESURfR0VUX0lSUV9TVEFUVVMsCisJCQkJCSAg Y21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsKKwlEUERNQUlfQ01EX0dFVF9JUlFfU1RBVFVTKGNt ZCwgaXJxX2luZGV4LCAqc3RhdHVzKTsKKworCS8qIHNlbmQgY29tbWFuZCB0byBtYyovCisJZXJy ID0gbWNfc2VuZF9jb21tYW5kKG1jX2lvLCAmY21kKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJy OworCisJLyogcmV0cmlldmUgcmVzcG9uc2UgcGFyYW1ldGVycyAqLworCURQRE1BSV9SU1BfR0VU X0lSUV9TVEFUVVMoY21kLCAqc3RhdHVzKTsKKworCXJldHVybiAwOworfQorCitpbnQgZHBkbWFp X2NsZWFyX2lycV9zdGF0dXMoc3RydWN0IGZzbF9tY19pbyAqbWNfaW8sCisJCQkgICAgdTMyIGNt ZF9mbGFncywKKwkJCSAgICB1MTYgdG9rZW4sCisJCQkgICAgdTggaXJxX2luZGV4LAorCQkJICAg IHUzMiBzdGF0dXMpCit7CisJc3RydWN0IGZzbF9tY19jb21tYW5kIGNtZCA9IHsgMCB9OworCisJ LyogcHJlcGFyZSBjb21tYW5kICovCisJY21kLmhlYWRlciA9IG1jX2VuY29kZV9jbWRfaGVhZGVy KERQRE1BSV9DTURJRF9DTEVBUl9JUlFfU1RBVFVTLAorCQkJCQkgIGNtZF9mbGFncywKKwkJCQkJ ICB0b2tlbik7CisJRFBETUFJX0NNRF9DTEVBUl9JUlFfU1RBVFVTKGNtZCwgaXJxX2luZGV4LCBz dGF0dXMpOworCisJLyogc2VuZCBjb21tYW5kIHRvIG1jKi8KKwlyZXR1cm4gbWNfc2VuZF9jb21t YW5kKG1jX2lvLCAmY21kKTsKK30KKworaW50IGRwZG1haV9nZXRfYXR0cmlidXRlcyhzdHJ1Y3Qg ZnNsX21jX2lvICptY19pbywKKwkJCSAgdTMyIGNtZF9mbGFncywKKwkJCSAgdTE2IHRva2VuLAor CQkJICBzdHJ1Y3QgZHBkbWFpX2F0dHIgKmF0dHIpCit7CisJc3RydWN0IGZzbF9tY19jb21tYW5k IGNtZCA9IHsgMCB9OworCWludCBlcnI7CisJc3RydWN0IGRwZG1haV9yc3BfZ2V0X2F0dHJpYnV0 ZXMgKnJzcF9wYXJhbXM7CisKKwkvKiBwcmVwYXJlIGNvbW1hbmQgKi8KKwljbWQuaGVhZGVyID0g bWNfZW5jb2RlX2NtZF9oZWFkZXIoRFBETUFJX0NNRElEX0dFVF9BVFRSLAorCQkJCQkgIGNtZF9m bGFncywKKwkJCQkJICB0b2tlbik7CisKKwkvKiBzZW5kIGNvbW1hbmQgdG8gbWMqLworCWVyciA9 IG1jX3NlbmRfY29tbWFuZChtY19pbywgJmNtZCk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsK KworCS8qIHJldHJpZXZlIHJlc3BvbnNlIHBhcmFtZXRlcnMgKi8KKwlyc3BfcGFyYW1zID0gKHN0 cnVjdCBkcGRtYWlfcnNwX2dldF9hdHRyaWJ1dGVzICopY21kLnBhcmFtczsKKwlhdHRyLT5pZCA9 IGxlMzJfdG9fY3B1KHJzcF9wYXJhbXMtPmlkKTsKKwlhdHRyLT52ZXJzaW9uLm1ham9yID0gbGUx Nl90b19jcHUocnNwX3BhcmFtcy0+bWFqb3IpOworCWF0dHItPnZlcnNpb24ubWlub3IgPSBsZTE2 X3RvX2NwdShyc3BfcGFyYW1zLT5taW5vcik7CisJYXR0ci0+bnVtX29mX3ByaW9yaXRpZXMgPSBy c3BfcGFyYW1zLT5udW1fb2ZfcHJpb3JpdGllczsKKworCXJldHVybiAwOworfQorCitpbnQgZHBk bWFpX3NldF9yeF9xdWV1ZShzdHJ1Y3QgZnNsX21jX2lvICptY19pbywKKwkJCXUzMiBjbWRfZmxh Z3MsCisJCQl1MTYgdG9rZW4sCisJCQl1OCBwcmlvcml0eSwKKwkJCWNvbnN0IHN0cnVjdCBkcGRt YWlfcnhfcXVldWVfY2ZnICpjZmcpCit7CisJc3RydWN0IGZzbF9tY19jb21tYW5kIGNtZCA9IHsg MCB9OworCXN0cnVjdCBkcGRtYWlfY21kX3F1ZXVlICpjbWRfcGFyYW1zOworCisJLyogcHJlcGFy ZSBjb21tYW5kICovCisJY21kLmhlYWRlciA9IG1jX2VuY29kZV9jbWRfaGVhZGVyKERQRE1BSV9D TURJRF9TRVRfUlhfUVVFVUUsCisJCQkJCSAgY21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsKKwor CWNtZF9wYXJhbXMgPSAoc3RydWN0IGRwZG1haV9jbWRfcXVldWUgKiljbWQucGFyYW1zOworCWNt ZF9wYXJhbXMtPmRlc3RfaWQgPSBjcHVfdG9fbGUzMihjZmctPmRlc3RfY2ZnLmRlc3RfaWQpOwor CWNtZF9wYXJhbXMtPnByaW9yaXR5ID0gY2ZnLT5kZXN0X2NmZy5wcmlvcml0eTsKKwljbWRfcGFy YW1zLT5xdWV1ZSA9IHByaW9yaXR5OworCWNtZF9wYXJhbXMtPmRlc3RfdHlwZSA9IGNmZy0+ZGVz dF9jZmcuZGVzdF90eXBlOworCWNtZF9wYXJhbXMtPnVzZXJfY3R4ID0gY3B1X3RvX2xlNjQoY2Zn LT51c2VyX2N0eCk7CisJY21kX3BhcmFtcy0+b3B0aW9ucyA9IGNwdV90b19sZTMyKGNmZy0+b3B0 aW9ucyk7CisKKwkvKiBzZW5kIGNvbW1hbmQgdG8gbWMqLworCXJldHVybiBtY19zZW5kX2NvbW1h bmQobWNfaW8sICZjbWQpOworfQorCitpbnQgZHBkbWFpX2dldF9yeF9xdWV1ZShzdHJ1Y3QgZnNs X21jX2lvICptY19pbywKKwkJCXUzMiBjbWRfZmxhZ3MsCisJCQl1MTYgdG9rZW4sCisJCQl1OCBw cmlvcml0eSwgc3RydWN0IGRwZG1haV9yeF9xdWV1ZV9hdHRyICphdHRyKQoreworCXN0cnVjdCBm c2xfbWNfY29tbWFuZCBjbWQgPSB7IDAgfTsKKwlzdHJ1Y3QgZHBkbWFpX2NtZF9xdWV1ZSAqY21k X3BhcmFtczsKKwlpbnQgZXJyOworCisJLyogcHJlcGFyZSBjb21tYW5kICovCisJY21kLmhlYWRl ciA9IG1jX2VuY29kZV9jbWRfaGVhZGVyKERQRE1BSV9DTURJRF9HRVRfUlhfUVVFVUUsCisJCQkJ CSAgY21kX2ZsYWdzLAorCQkJCQkgIHRva2VuKTsKKworCWNtZF9wYXJhbXMgPSAoc3RydWN0IGRw ZG1haV9jbWRfcXVldWUgKiljbWQucGFyYW1zOworCWNtZF9wYXJhbXMtPnF1ZXVlID0gcHJpb3Jp dHk7CisKKwkvKiBzZW5kIGNvbW1hbmQgdG8gbWMqLworCWVyciA9IG1jX3NlbmRfY29tbWFuZCht Y19pbywgJmNtZCk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCS8qIHJldHJpZXZlIHJl c3BvbnNlIHBhcmFtZXRlcnMgKi8KKwlhdHRyLT5kZXN0X2NmZy5kZXN0X2lkID0gbGUzMl90b19j cHUoY21kX3BhcmFtcy0+ZGVzdF9pZCk7CisJYXR0ci0+ZGVzdF9jZmcucHJpb3JpdHkgPSBjbWRf cGFyYW1zLT5wcmlvcml0eTsKKwlhdHRyLT5kZXN0X2NmZy5kZXN0X3R5cGUgPSBjbWRfcGFyYW1z LT5kZXN0X3R5cGU7CisJYXR0ci0+dXNlcl9jdHggPSBsZTY0X3RvX2NwdShjbWRfcGFyYW1zLT51 c2VyX2N0eCk7CisJYXR0ci0+ZnFpZCA9IGxlMzJfdG9fY3B1KGNtZF9wYXJhbXMtPmZxaWQpOwor CisJcmV0dXJuIDA7Cit9CisKK2ludCBkcGRtYWlfZ2V0X3R4X3F1ZXVlKHN0cnVjdCBmc2xfbWNf aW8gKm1jX2lvLAorCQkJdTMyIGNtZF9mbGFncywKKwkJCXUxNiB0b2tlbiwKKwkJCXU4IHByaW9y aXR5LAorCQkJc3RydWN0IGRwZG1haV90eF9xdWV1ZV9hdHRyICphdHRyKQoreworCXN0cnVjdCBm c2xfbWNfY29tbWFuZCBjbWQgPSB7IDAgfTsKKwlzdHJ1Y3QgZHBkbWFpX2NtZF9xdWV1ZSAqY21k X3BhcmFtczsKKwlzdHJ1Y3QgZHBkbWFpX3JzcF9nZXRfdHhfcXVldWUgKnJzcF9wYXJhbXM7CisJ aW50IGVycjsKKworCS8qIHByZXBhcmUgY29tbWFuZCAqLworCWNtZC5oZWFkZXIgPSBtY19lbmNv ZGVfY21kX2hlYWRlcihEUERNQUlfQ01ESURfR0VUX1RYX1FVRVVFLAorCQkJCQkgIGNtZF9mbGFn cywKKwkJCQkJICB0b2tlbik7CisKKwljbWRfcGFyYW1zID0gKHN0cnVjdCBkcGRtYWlfY21kX3F1 ZXVlICopY21kLnBhcmFtczsKKwljbWRfcGFyYW1zLT5xdWV1ZSA9IHByaW9yaXR5OworCisJLyog c2VuZCBjb21tYW5kIHRvIG1jKi8KKwllcnIgPSBtY19zZW5kX2NvbW1hbmQobWNfaW8sICZjbWQp OworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwkvKiByZXRyaWV2ZSByZXNwb25zZSBwYXJh bWV0ZXJzICovCisKKwlyc3BfcGFyYW1zID0gKHN0cnVjdCBkcGRtYWlfcnNwX2dldF90eF9xdWV1 ZSAqKWNtZC5wYXJhbXM7CisJYXR0ci0+ZnFpZCA9IGxlMzJfdG9fY3B1KHJzcF9wYXJhbXMtPmZx aWQpOworCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9mc2wtZHBhYTIt cWRtYS9kcGRtYWkuaCBiL2RyaXZlcnMvZG1hL2ZzbC1kcGFhMi1xZG1hL2RwZG1haS5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM4YTdiN2YKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL2RtYS9mc2wtZHBhYTItcWRtYS9kcGRtYWkuaApAQCAtMCwwICsxLDUyNCBAQAor LyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KKy8qIENvcHlyaWdodCAyMDE0 LTIwMTggTlhQICovCisKKy8qCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUgbWV0Ogor ICogKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqICogTmVpdGhlciB0aGUgbmFtZSBvZiB0aGUgYWJvdmUtbGlzdGVkIGNvcHly aWdodCBob2xkZXJzIG5vciB0aGUKKyAqIG5hbWVzIG9mIGFueSBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzCisgKiBkZXJpdmVkIGZyb20gdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKgorICogQUxURVJOQVRJVkVMWSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKCJH UEwiKSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIGVp dGhlciB2ZXJzaW9uIDIgb2YgdGhhdCBMaWNlbnNlIG9yIChhdCB5b3VyIG9wdGlvbikgYW55Cisg KiBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMgIkFTIElTIgorICogQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UKKyAqIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUIEhPTERFUlMgT1IgQ09OVFJJQlVUT1JTIEJFCisgKiBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFCisgKiBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworI2lmbmRlZiBfX0ZTTF9EUERNQUlfSAorI2Rl ZmluZSBfX0ZTTF9EUERNQUlfSAorCitzdHJ1Y3QgZnNsX21jX2lvOworCisvKiBEYXRhIFBhdGgg RE1BIEludGVyZmFjZSBBUEkKKyAqIENvbnRhaW5zIGluaXRpYWxpemF0aW9uIEFQSXMgYW5kIHJ1 bnRpbWUgY29udHJvbCBBUElzIGZvciBEUERNQUkKKyAqLworCisvKiBHZW5lcmFsIERQRE1BSSBt YWNyb3MgKi8KKworLyoqCisgKiBNYXhpbXVtIG51bWJlciBvZiBUeC9SeCBwcmlvcml0aWVzIHBl ciBEUERNQUkgb2JqZWN0CisgKi8KKyNkZWZpbmUgRFBETUFJX1BSSU9fTlVNCQkyCisKKy8qKgor ICogQWxsIHF1ZXVlcyBjb25zaWRlcmVkOyBzZWUgZHBkbWFpX3NldF9yeF9xdWV1ZSgpCisgKi8K KyNkZWZpbmUgRFBETUFJX0FMTF9RVUVVRVMJKHU4KSgtMSkKKworLyoqCisgKiBkcGRtYWlfb3Bl bigpIC0gT3BlbiBhIGNvbnRyb2wgc2Vzc2lvbiBmb3IgdGhlIHNwZWNpZmllZCBvYmplY3QKKyAq IEBtY19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21kX2ZsYWdz OglDb21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICogQGRwZG1h aV9pZDoJRFBETUFJIHVuaXF1ZSBJRAorICogQHRva2VuOglSZXR1cm5lZCB0b2tlbjsgdXNlIGlu IHN1YnNlcXVlbnQgQVBJIGNhbGxzCisgKgorICogVGhpcyBmdW5jdGlvbiBjYW4gYmUgdXNlZCB0 byBvcGVuIGEgY29udHJvbCBzZXNzaW9uIGZvciBhbgorICogYWxyZWFkeSBjcmVhdGVkIG9iamVj dDsgYW4gb2JqZWN0IG1heSBoYXZlIGJlZW4gZGVjbGFyZWQgaW4KKyAqIHRoZSBEUEwgb3IgYnkg Y2FsbGluZyB0aGUgZHBkbWFpX2NyZWF0ZSgpIGZ1bmN0aW9uLgorICogVGhpcyBmdW5jdGlvbiBy ZXR1cm5zIGEgdW5pcXVlIGF1dGhlbnRpY2F0aW9uIHRva2VuLAorICogYXNzb2NpYXRlZCB3aXRo IHRoZSBzcGVjaWZpYyBvYmplY3QgSUQgYW5kIHRoZSBzcGVjaWZpYyBNQworICogcG9ydGFsOyB0 aGlzIHRva2VuIG11c3QgYmUgdXNlZCBpbiBhbGwgc3Vic2VxdWVudCBjb21tYW5kcyBmb3IKKyAq IHRoaXMgc3BlY2lmaWMgb2JqZWN0LgorICoKKyAqIFJldHVybjoJJzAnIG9uIFN1Y2Nlc3M7IEVy cm9yIGNvZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX29wZW4oc3RydWN0IGZzbF9tY19p bwkqbWNfaW8sCisJCXUzMgkJY21kX2ZsYWdzLAorCQlpbnQJCQlkcGRtYWlfaWQsCisJCXUxNgkJ KnRva2VuKTsKKworLyoqCisgKiBkcGRtYWlfY2xvc2UoKSAtIENsb3NlIHRoZSBjb250cm9sIHNl c3Npb24gb2YgdGhlIG9iamVjdAorICogQG1jX2lvOglQb2ludGVyIHRvIE1DIHBvcnRhbCdzIEkv TyBvYmplY3QKKyAqIEBjbWRfZmxhZ3M6CUNvbW1hbmQgZmxhZ3M7IG9uZSBvciBtb3JlIG9mICdN Q19DTURfRkxBR18nCisgKiBAdG9rZW46CVRva2VuIG9mIERQRE1BSSBvYmplY3QKKyAqCisgKiBB ZnRlciB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCwgbm8gZnVydGhlciBvcGVyYXRpb25zIGFyZQor ICogYWxsb3dlZCBvbiB0aGUgb2JqZWN0IHdpdGhvdXQgb3BlbmluZyBhIG5ldyBjb250cm9sIHNl c3Npb24uCisgKgorICogUmV0dXJuOgknMCcgb24gU3VjY2VzczsgRXJyb3IgY29kZSBvdGhlcndp c2UuCisgKi8KK2ludCBkcGRtYWlfY2xvc2Uoc3RydWN0IGZzbF9tY19pbwkqbWNfaW8sCisJCSB1 MzIJCWNtZF9mbGFncywKKwkJIHUxNgkJdG9rZW4pOworCisvKioKKyAqIHN0cnVjdCBkcGRtYWlf Y2ZnIC0gU3RydWN0dXJlIHJlcHJlc2VudGluZyBEUERNQUkgY29uZmlndXJhdGlvbgorICogQHBy aW9yaXRpZXM6IFByaW9yaXRpZXMgZm9yIHRoZSBETUEgaGFyZHdhcmUgcHJvY2Vzc2luZzsgdmFs aWQgcHJpb3JpdGllcyBhcmUKKyAqCWNvbmZpZ3VyZWQgd2l0aCB2YWx1ZXMgMS04OyB0aGUgZW50 cnkgZm9sbG93aW5nIGxhc3QgdmFsaWQgZW50cnkKKyAqCXNob3VsZCBiZSBjb25maWd1cmVkIHdp dGggMAorICovCitzdHJ1Y3QgZHBkbWFpX2NmZyB7CisJdTggcHJpb3JpdGllc1tEUERNQUlfUFJJ T19OVU1dOworfTsKKworLyoqCisgKiBkcGRtYWlfY3JlYXRlKCkgLSBDcmVhdGUgdGhlIERQRE1B SSBvYmplY3QKKyAqIEBtY19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0Cisg KiBAY21kX2ZsYWdzOglDb21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdf JworICogQGNmZzoJQ29uZmlndXJhdGlvbiBzdHJ1Y3R1cmUKKyAqIEB0b2tlbjoJUmV0dXJuZWQg dG9rZW47IHVzZSBpbiBzdWJzZXF1ZW50IEFQSSBjYWxscworICoKKyAqIENyZWF0ZSB0aGUgRFBE TUFJIG9iamVjdCwgYWxsb2NhdGUgcmVxdWlyZWQgcmVzb3VyY2VzIGFuZAorICogcGVyZm9ybSBy ZXF1aXJlZCBpbml0aWFsaXphdGlvbi4KKyAqCisgKiBUaGUgb2JqZWN0IGNhbiBiZSBjcmVhdGVk IGVpdGhlciBieSBkZWNsYXJpbmcgaXQgaW4gdGhlCisgKiBEUEwgZmlsZSwgb3IgYnkgY2FsbGlu ZyB0aGlzIGZ1bmN0aW9uLgorICoKKyAqIFRoaXMgZnVuY3Rpb24gcmV0dXJucyBhIHVuaXF1ZSBh dXRoZW50aWNhdGlvbiB0b2tlbiwKKyAqIGFzc29jaWF0ZWQgd2l0aCB0aGUgc3BlY2lmaWMgb2Jq ZWN0IElEIGFuZCB0aGUgc3BlY2lmaWMgTUMKKyAqIHBvcnRhbDsgdGhpcyB0b2tlbiBtdXN0IGJl IHVzZWQgaW4gYWxsIHN1YnNlcXVlbnQgY2FsbHMgdG8KKyAqIHRoaXMgc3BlY2lmaWMgb2JqZWN0 LiBGb3Igb2JqZWN0cyB0aGF0IGFyZSBjcmVhdGVkIHVzaW5nIHRoZQorICogRFBMIGZpbGUsIGNh bGwgZHBkbWFpX29wZW4oKSBmdW5jdGlvbiB0byBnZXQgYW4gYXV0aGVudGljYXRpb24KKyAqIHRv a2VuIGZpcnN0LgorICoKKyAqIFJldHVybjoJJzAnIG9uIFN1Y2Nlc3M7IEVycm9yIGNvZGUgb3Ro ZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX2NyZWF0ZShzdHJ1Y3QgZnNsX21jX2lvCQkqbWNfaW8s CisJCSAgdTMyCQkJY21kX2ZsYWdzLAorCQkgIGNvbnN0IHN0cnVjdCBkcGRtYWlfY2ZnCSpjZmcs CisJCSAgdTE2CQkJKnRva2VuKTsKKworLyoqCisgKiBkcGRtYWlfZGVzdHJveSgpIC0gRGVzdHJv eSB0aGUgRFBETUFJIG9iamVjdCBhbmQgcmVsZWFzZSBhbGwgaXRzIHJlc291cmNlcy4KKyAqIEBt Y19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21kX2ZsYWdzOglD b21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICogQHRva2VuOglU b2tlbiBvZiBEUERNQUkgb2JqZWN0CisgKgorICogUmV0dXJuOgknMCcgb24gU3VjY2VzczsgZXJy b3IgY29kZSBvdGhlcndpc2UuCisgKi8KK2ludCBkcGRtYWlfZGVzdHJveShzdHJ1Y3QgZnNsX21j X2lvCSptY19pbywKKwkJICAgdTMyCQljbWRfZmxhZ3MsCisJCSAgIHUxNgkJdG9rZW4pOworCisv KioKKyAqIGRwZG1haV9lbmFibGUoKSAtIEVuYWJsZSB0aGUgRFBETUFJLCBhbGxvdyBzZW5kaW5n IGFuZCByZWNlaXZpbmcgZnJhbWVzLgorICogQG1jX2lvOglQb2ludGVyIHRvIE1DIHBvcnRhbCdz IEkvTyBvYmplY3QKKyAqIEBjbWRfZmxhZ3M6CUNvbW1hbmQgZmxhZ3M7IG9uZSBvciBtb3JlIG9m ICdNQ19DTURfRkxBR18nCisgKiBAdG9rZW46CVRva2VuIG9mIERQRE1BSSBvYmplY3QKKyAqCisg KiBSZXR1cm46CScwJyBvbiBTdWNjZXNzOyBFcnJvciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50 IGRwZG1haV9lbmFibGUoc3RydWN0IGZzbF9tY19pbwkqbWNfaW8sCisJCSAgdTMyCQljbWRfZmxh Z3MsCisJCSAgdTE2CQl0b2tlbik7CisKKy8qKgorICogZHBkbWFpX2Rpc2FibGUoKSAtIERpc2Fi bGUgdGhlIERQRE1BSSwgc3RvcCBzZW5kaW5nIGFuZCByZWNlaXZpbmcgZnJhbWVzLgorICogQG1j X2lvOglQb2ludGVyIHRvIE1DIHBvcnRhbCdzIEkvTyBvYmplY3QKKyAqIEBjbWRfZmxhZ3M6CUNv bW1hbmQgZmxhZ3M7IG9uZSBvciBtb3JlIG9mICdNQ19DTURfRkxBR18nCisgKiBAdG9rZW46CVRv a2VuIG9mIERQRE1BSSBvYmplY3QKKyAqCisgKiBSZXR1cm46CScwJyBvbiBTdWNjZXNzOyBFcnJv ciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50IGRwZG1haV9kaXNhYmxlKHN0cnVjdCBmc2xfbWNf aW8JKm1jX2lvLAorCQkgICB1MzIJCWNtZF9mbGFncywKKwkJICAgdTE2CQl0b2tlbik7CisKKy8q KgorICogZHBkbWFpX2lzX2VuYWJsZWQoKSAtIENoZWNrIGlmIHRoZSBEUERNQUkgaXMgZW5hYmxl ZC4KKyAqIEBtY19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21k X2ZsYWdzOglDb21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICog QHRva2VuOglUb2tlbiBvZiBEUERNQUkgb2JqZWN0CisgKiBAZW46CQlSZXR1cm5zICcxJyBpZiBv YmplY3QgaXMgZW5hYmxlZDsgJzAnIG90aGVyd2lzZQorICoKKyAqIFJldHVybjoJJzAnIG9uIFN1 Y2Nlc3M7IEVycm9yIGNvZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX2lzX2VuYWJsZWQo c3RydWN0IGZzbF9tY19pbwkqbWNfaW8sCisJCSAgICAgIHUzMgkJY21kX2ZsYWdzLAorCQkgICAg ICB1MTYJCXRva2VuLAorCQkgICAgICBpbnQJCSplbik7CisKKy8qKgorICogZHBkbWFpX3Jlc2V0 KCkgLSBSZXNldCB0aGUgRFBETUFJLCByZXR1cm5zIHRoZSBvYmplY3QgdG8gaW5pdGlhbCBzdGF0 ZS4KKyAqIEBtY19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21k X2ZsYWdzOglDb21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICog QHRva2VuOglUb2tlbiBvZiBEUERNQUkgb2JqZWN0CisgKgorICogUmV0dXJuOgknMCcgb24gU3Vj Y2VzczsgRXJyb3IgY29kZSBvdGhlcndpc2UuCisgKi8KK2ludCBkcGRtYWlfcmVzZXQoc3RydWN0 IGZzbF9tY19pbwkqbWNfaW8sCisJCSB1MzIJCWNtZF9mbGFncywKKwkJIHUxNgkJdG9rZW4pOwor CisvKioKKyAqIHN0cnVjdCBkcGRtYWlfaXJxX2NmZyAtIElSUSBjb25maWd1cmF0aW9uCisgKiBA YWRkcjoJQWRkcmVzcyB0aGF0IG11c3QgYmUgd3JpdHRlbiB0byBzaWduYWwgYSBtZXNzYWdlLWJh c2VkIGludGVycnVwdAorICogQHZhbDoJVmFsdWUgdG8gd3JpdGUgaW50byBpcnFfYWRkciBhZGRy ZXNzCisgKiBAaXJxX251bTogQSB1c2VyIGRlZmluZWQgbnVtYmVyIGFzc29jaWF0ZWQgd2l0aCB0 aGlzIElSUQorICovCitzdHJ1Y3QgZHBkbWFpX2lycV9jZmcgeworCXU2NAlhZGRyOworCXUzMgl2 YWw7CisJaW50CQlpcnFfbnVtOworfTsKKworLyoqCisgKiBkcGRtYWlfc2V0X2lycSgpIC0gU2V0 IElSUSBpbmZvcm1hdGlvbiBmb3IgdGhlIERQRE1BSSB0byB0cmlnZ2VyCisgKiBhbiBpbnRlcnJ1 cHQuCisgKiBAbWNfaW86CVBvaW50ZXIgdG8gTUMgcG9ydGFsJ3MgSS9PIG9iamVjdAorICogQGNt ZF9mbGFnczoJQ29tbWFuZCBmbGFnczsgb25lIG9yIG1vcmUgb2YgJ01DX0NNRF9GTEFHXycKKyAq IEB0b2tlbjoJVG9rZW4gb2YgRFBETUFJIG9iamVjdAorICogQGlycV9pbmRleDoJSWRlbnRpZmll cyB0aGUgaW50ZXJydXB0IGluZGV4IHRvIGNvbmZpZ3VyZQorICogQGlycV9jZmc6CUlSUSBjb25m aWd1cmF0aW9uCisgKgorICogUmV0dXJuOgknMCcgb24gU3VjY2VzczsgRXJyb3IgY29kZSBvdGhl cndpc2UuCisgKi8KK2ludCBkcGRtYWlfc2V0X2lycShzdHJ1Y3QgZnNsX21jX2lvCQkqbWNfaW8s CisJCSAgIHUzMgkJCWNtZF9mbGFncywKKwkJICAgdTE2CQkJdG9rZW4sCisJCSAgIHU4CQkJaXJx X2luZGV4LAorCQkgICBzdHJ1Y3QgZHBkbWFpX2lycV9jZmcJKmlycV9jZmcpOworCisvKioKKyAq IGRwZG1haV9nZXRfaXJxKCkgLSBHZXQgSVJRIGluZm9ybWF0aW9uIGZyb20gdGhlIERQRE1BSQor ICoKKyAqIEBtY19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21k X2ZsYWdzOglDb21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICog QHRva2VuOglUb2tlbiBvZiBEUERNQUkgb2JqZWN0CisgKiBAaXJxX2luZGV4OglUaGUgaW50ZXJy dXB0IGluZGV4IHRvIGNvbmZpZ3VyZQorICogQHR5cGU6CUludGVycnVwdCB0eXBlOiAwIHJlcHJl c2VudHMgbWVzc2FnZSBpbnRlcnJ1cHQKKyAqCQl0eXBlIChib3RoIGlycV9hZGRyIGFuZCBpcnFf dmFsIGFyZSB2YWxpZCkKKyAqIEBpcnFfY2ZnOglJUlEgYXR0cmlidXRlcworICoKKyAqIFJldHVy bjoJJzAnIG9uIFN1Y2Nlc3M7IEVycm9yIGNvZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFp X2dldF9pcnEoc3RydWN0IGZzbF9tY19pbwkJKm1jX2lvLAorCQkgICB1MzIJCQljbWRfZmxhZ3Ms CisJCSAgIHUxNgkJCXRva2VuLAorCQkgICB1OAkJCWlycV9pbmRleCwKKwkJICAgaW50CQkJCSp0 eXBlLAorCQkgICBzdHJ1Y3QgZHBkbWFpX2lycV9jZmcJKmlycV9jZmcpOworCisvKioKKyAqIGRw ZG1haV9zZXRfaXJxX2VuYWJsZSgpIC0gU2V0IG92ZXJhbGwgaW50ZXJydXB0IHN0YXRlLgorICog QG1jX2lvOglQb2ludGVyIHRvIE1DIHBvcnRhbCdzIEkvTyBvYmplY3QKKyAqIEBjbWRfZmxhZ3M6 CUNvbW1hbmQgZmxhZ3M7IG9uZSBvciBtb3JlIG9mICdNQ19DTURfRkxBR18nCisgKiBAdG9rZW46 CQlUb2tlbiBvZiBEUERNQUkgb2JqZWN0CisgKiBAaXJxX2luZGV4OglUaGUgaW50ZXJydXB0IGlu ZGV4IHRvIGNvbmZpZ3VyZQorICogQGVuOgkJCUludGVycnVwdCBzdGF0ZSAtIGVuYWJsZSA9IDEs IGRpc2FibGUgPSAwCisgKgorICogQWxsb3dzIEdQUCBzb2Z0d2FyZSB0byBjb250cm9sIHdoZW4g aW50ZXJydXB0cyBhcmUgZ2VuZXJhdGVkLgorICogRWFjaCBpbnRlcnJ1cHQgY2FuIGhhdmUgdXAg dG8gMzIgY2F1c2VzLiAgVGhlIGVuYWJsZS9kaXNhYmxlIGNvbnRyb2wncyB0aGUKKyAqIG92ZXJh bGwgaW50ZXJydXB0IHN0YXRlLiBpZiB0aGUgaW50ZXJydXB0IGlzIGRpc2FibGVkIG5vIGNhdXNl cyB3aWxsIGNhdXNlCisgKiBhbiBpbnRlcnJ1cHQKKyAqCisgKiBSZXR1cm46CScwJyBvbiBTdWNj ZXNzOyBFcnJvciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50IGRwZG1haV9zZXRfaXJxX2VuYWJs ZShzdHJ1Y3QgZnNsX21jX2lvCSptY19pbywKKwkJCSAgdTMyCQljbWRfZmxhZ3MsCisJCQkgIHUx NgkJdG9rZW4sCisJCQkgIHU4CQlpcnFfaW5kZXgsCisJCQkgIHU4CQllbik7CisKKy8qKgorICog ZHBkbWFpX2dldF9pcnFfZW5hYmxlKCkgLSBHZXQgb3ZlcmFsbCBpbnRlcnJ1cHQgc3RhdGUKKyAq IEBtY19pbzoJUG9pbnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21kX2ZsYWdz OglDb21tYW5kIGZsYWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICogQHRva2Vu OgkJVG9rZW4gb2YgRFBETUFJIG9iamVjdAorICogQGlycV9pbmRleDoJVGhlIGludGVycnVwdCBp bmRleCB0byBjb25maWd1cmUKKyAqIEBlbjoJCQlSZXR1cm5lZCBJbnRlcnJ1cHQgc3RhdGUgLSBl bmFibGUgPSAxLCBkaXNhYmxlID0gMAorICoKKyAqIFJldHVybjoJJzAnIG9uIFN1Y2Nlc3M7IEVy cm9yIGNvZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX2dldF9pcnFfZW5hYmxlKHN0cnVj dCBmc2xfbWNfaW8JKm1jX2lvLAorCQkJICB1MzIJCWNtZF9mbGFncywKKwkJCSAgdTE2CQl0b2tl biwKKwkJCSAgdTgJCWlycV9pbmRleCwKKwkJCSAgdTgJCSplbik7CisKKy8qKgorICogZHBkbWFp X3NldF9pcnFfbWFzaygpIC0gU2V0IGludGVycnVwdCBtYXNrLgorICogQG1jX2lvOglQb2ludGVy IHRvIE1DIHBvcnRhbCdzIEkvTyBvYmplY3QKKyAqIEBjbWRfZmxhZ3M6CUNvbW1hbmQgZmxhZ3M7 IG9uZSBvciBtb3JlIG9mICdNQ19DTURfRkxBR18nCisgKiBAdG9rZW46CQlUb2tlbiBvZiBEUERN QUkgb2JqZWN0CisgKiBAaXJxX2luZGV4OglUaGUgaW50ZXJydXB0IGluZGV4IHRvIGNvbmZpZ3Vy ZQorICogQG1hc2s6CQlldmVudCBtYXNrIHRvIHRyaWdnZXIgaW50ZXJydXB0OworICoJCQkJZWFj aCBiaXQ6CisgKgkJCQkJMCA9IGlnbm9yZSBldmVudAorICoJCQkJCTEgPSBjb25zaWRlciBldmVu dCBmb3IgYXNzZXJ0aW5nIElSUQorICoKKyAqIEV2ZXJ5IGludGVycnVwdCBjYW4gaGF2ZSB1cCB0 byAzMiBjYXVzZXMgYW5kIHRoZSBpbnRlcnJ1cHQgbW9kZWwgc3VwcG9ydHMKKyAqIG1hc2tpbmcv dW5tYXNraW5nIGVhY2ggY2F1c2UgaW5kZXBlbmRlbnRseQorICoKKyAqIFJldHVybjoJJzAnIG9u IFN1Y2Nlc3M7IEVycm9yIGNvZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX3NldF9pcnFf bWFzayhzdHJ1Y3QgZnNsX21jX2lvCSptY19pbywKKwkJCXUzMgkJY21kX2ZsYWdzLAorCQkJdTE2 CQl0b2tlbiwKKwkJCXU4CQlpcnFfaW5kZXgsCisJCQl1MzIJCW1hc2spOworCisvKioKKyAqIGRw ZG1haV9nZXRfaXJxX21hc2soKSAtIEdldCBpbnRlcnJ1cHQgbWFzay4KKyAqIEBtY19pbzoJUG9p bnRlciB0byBNQyBwb3J0YWwncyBJL08gb2JqZWN0CisgKiBAY21kX2ZsYWdzOglDb21tYW5kIGZs YWdzOyBvbmUgb3IgbW9yZSBvZiAnTUNfQ01EX0ZMQUdfJworICogQHRva2VuOgkJVG9rZW4gb2Yg RFBETUFJIG9iamVjdAorICogQGlycV9pbmRleDoJVGhlIGludGVycnVwdCBpbmRleCB0byBjb25m aWd1cmUKKyAqIEBtYXNrOgkJUmV0dXJuZWQgZXZlbnQgbWFzayB0byB0cmlnZ2VyIGludGVycnVw dAorICoKKyAqIEV2ZXJ5IGludGVycnVwdCBjYW4gaGF2ZSB1cCB0byAzMiBjYXVzZXMgYW5kIHRo ZSBpbnRlcnJ1cHQgbW9kZWwgc3VwcG9ydHMKKyAqIG1hc2tpbmcvdW5tYXNraW5nIGVhY2ggY2F1 c2UgaW5kZXBlbmRlbnRseQorICoKKyAqIFJldHVybjoJJzAnIG9uIFN1Y2Nlc3M7IEVycm9yIGNv ZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX2dldF9pcnFfbWFzayhzdHJ1Y3QgZnNsX21j X2lvCSptY19pbywKKwkJCXUzMgkJY21kX2ZsYWdzLAorCQkJdTE2CQl0b2tlbiwKKwkJCXU4CQlp cnFfaW5kZXgsCisJCQl1MzIJCSptYXNrKTsKKworLyoqCisgKiBkcGRtYWlfZ2V0X2lycV9zdGF0 dXMoKSAtIEdldCB0aGUgY3VycmVudCBzdGF0dXMgb2YgYW55IHBlbmRpbmcgaW50ZXJydXB0cwor ICogQG1jX2lvOglQb2ludGVyIHRvIE1DIHBvcnRhbCdzIEkvTyBvYmplY3QKKyAqIEBjbWRfZmxh Z3M6CUNvbW1hbmQgZmxhZ3M7IG9uZSBvciBtb3JlIG9mICdNQ19DTURfRkxBR18nCisgKiBAdG9r ZW46CQlUb2tlbiBvZiBEUERNQUkgb2JqZWN0CisgKiBAaXJxX2luZGV4OglUaGUgaW50ZXJydXB0 IGluZGV4IHRvIGNvbmZpZ3VyZQorICogQHN0YXR1czoJCVJldHVybmVkIGludGVycnVwdHMgc3Rh dHVzIC0gb25lIGJpdCBwZXIgY2F1c2U6CisgKgkJCQkJMCA9IG5vIGludGVycnVwdCBwZW5kaW5n CisgKgkJCQkJMSA9IGludGVycnVwdCBwZW5kaW5nCisgKgorICogUmV0dXJuOgknMCcgb24gU3Vj Y2VzczsgRXJyb3IgY29kZSBvdGhlcndpc2UuCisgKi8KK2ludCBkcGRtYWlfZ2V0X2lycV9zdGF0 dXMoc3RydWN0IGZzbF9tY19pbwkqbWNfaW8sCisJCQkgIHUzMgkJY21kX2ZsYWdzLAorCQkJICB1 MTYJCXRva2VuLAorCQkJICB1OAkJaXJxX2luZGV4LAorCQkJICB1MzIJCSpzdGF0dXMpOworCisv KioKKyAqIGRwZG1haV9jbGVhcl9pcnFfc3RhdHVzKCkgLSBDbGVhciBhIHBlbmRpbmcgaW50ZXJy dXB0J3Mgc3RhdHVzCisgKiBAbWNfaW86CVBvaW50ZXIgdG8gTUMgcG9ydGFsJ3MgSS9PIG9iamVj dAorICogQGNtZF9mbGFnczoJQ29tbWFuZCBmbGFnczsgb25lIG9yIG1vcmUgb2YgJ01DX0NNRF9G TEFHXycKKyAqIEB0b2tlbjoJVG9rZW4gb2YgRFBETUFJIG9iamVjdAorICogQGlycV9pbmRleDoJ VGhlIGludGVycnVwdCBpbmRleCB0byBjb25maWd1cmUKKyAqIEBzdGF0dXM6CWJpdHMgdG8gY2xl YXIgKFcxQykgLSBvbmUgYml0IHBlciBjYXVzZToKKyAqCQkJMCA9IGRvbid0IGNoYW5nZQorICoJ CQkxID0gY2xlYXIgc3RhdHVzIGJpdAorICoKKyAqIFJldHVybjoJJzAnIG9uIFN1Y2Nlc3M7IEVy cm9yIGNvZGUgb3RoZXJ3aXNlLgorICovCitpbnQgZHBkbWFpX2NsZWFyX2lycV9zdGF0dXMoc3Ry dWN0IGZzbF9tY19pbwkqbWNfaW8sCisJCQkgICAgdTMyCQljbWRfZmxhZ3MsCisJCQkgICAgdTE2 CQl0b2tlbiwKKwkJCSAgICB1OAkJaXJxX2luZGV4LAorCQkJICAgIHUzMgkJc3RhdHVzKTsKKwor LyoqCisgKiBzdHJ1Y3QgZHBkbWFpX2F0dHIgLSBTdHJ1Y3R1cmUgcmVwcmVzZW50aW5nIERQRE1B SSBhdHRyaWJ1dGVzCisgKiBAaWQ6IERQRE1BSSBvYmplY3QgSUQKKyAqIEB2ZXJzaW9uOiBEUERN QUkgdmVyc2lvbgorICogQG51bV9vZl9wcmlvcml0aWVzOiBudW1iZXIgb2YgcHJpb3JpdGllcwor ICovCitzdHJ1Y3QgZHBkbWFpX2F0dHIgeworCWludAlpZDsKKwkvKioKKwkgKiBzdHJ1Y3QgdmVy c2lvbiAtIERQRE1BSSB2ZXJzaW9uCisJICogQG1ham9yOiBEUERNQUkgbWFqb3IgdmVyc2lvbgor CSAqIEBtaW5vcjogRFBETUFJIG1pbm9yIHZlcnNpb24KKwkgKi8KKwlzdHJ1Y3QgeworCQl1MTYg bWFqb3I7CisJCXUxNiBtaW5vcjsKKwl9IHZlcnNpb247CisJdTggbnVtX29mX3ByaW9yaXRpZXM7 Cit9OworCisvKioKKyAqIGRwZG1haV9nZXRfYXR0cmlidXRlcygpIC0gUmV0cmlldmUgRFBETUFJ IGF0dHJpYnV0ZXMuCisgKiBAbWNfaW86CVBvaW50ZXIgdG8gTUMgcG9ydGFsJ3MgSS9PIG9iamVj dAorICogQGNtZF9mbGFnczoJQ29tbWFuZCBmbGFnczsgb25lIG9yIG1vcmUgb2YgJ01DX0NNRF9G TEFHXycKKyAqIEB0b2tlbjoJVG9rZW4gb2YgRFBETUFJIG9iamVjdAorICogQGF0dHI6CVJldHVy bmVkIG9iamVjdCdzIGF0dHJpYnV0ZXMKKyAqCisgKiBSZXR1cm46CScwJyBvbiBTdWNjZXNzOyBF cnJvciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50IGRwZG1haV9nZXRfYXR0cmlidXRlcyhzdHJ1 Y3QgZnNsX21jX2lvCSptY19pbywKKwkJCSAgdTMyCQljbWRfZmxhZ3MsCisJCQkgIHUxNgkJdG9r ZW4sCisJCQkgIHN0cnVjdCBkcGRtYWlfYXR0cgkqYXR0cik7CisKKy8qKgorICogZW51bSBkcGRt YWlfZGVzdCAtIERQRE1BSSBkZXN0aW5hdGlvbiB0eXBlcworICogQERQRE1BSV9ERVNUX05PTkU6 IFVuYXNzaWduZWQgZGVzdGluYXRpb247IFRoZSBxdWV1ZSBpcyBzZXQgaW4gcGFya2VkIG1vZGUK KyAqCWFuZCBkb2VzIG5vdCBnZW5lcmF0ZSBGUURBTiBub3RpZmljYXRpb25zOyB1c2VyIGlzIGV4 cGVjdGVkIHRvIGRlcXVldWUKKyAqCWZyb20gdGhlIHF1ZXVlIGJhc2VkIG9uIHBvbGxpbmcgb3Ig b3RoZXIgdXNlci1kZWZpbmVkIG1ldGhvZAorICogQERQRE1BSV9ERVNUX0RQSU86IFRoZSBxdWV1 ZSBpcyBzZXQgaW4gc2NoZWR1bGUgbW9kZSBhbmQgZ2VuZXJhdGVzIEZRREFOCisgKglub3RpZmlj YXRpb25zIHRvIHRoZSBzcGVjaWZpZWQgRFBJTzsgdXNlciBpcyBleHBlY3RlZCB0byBkZXF1ZXVl CisgKglmcm9tIHRoZSBxdWV1ZSBvbmx5IGFmdGVyIG5vdGlmaWNhdGlvbiBpcyByZWNlaXZlZAor ICogQERQRE1BSV9ERVNUX0RQQ09OOiBUaGUgcXVldWUgaXMgc2V0IGluIHNjaGVkdWxlIG1vZGUg YW5kIGRvZXMgbm90IGdlbmVyYXRlCisgKglGUURBTiBub3RpZmljYXRpb25zLCBidXQgaXMgY29u bmVjdGVkIHRvIHRoZSBzcGVjaWZpZWQgRFBDT04gb2JqZWN0OworICoJdXNlciBpcyBleHBlY3Rl ZCB0byBkZXF1ZXVlIGZyb20gdGhlIERQQ09OIGNoYW5uZWwKKyAqLworZW51bSBkcGRtYWlfZGVz dCB7CisJRFBETUFJX0RFU1RfTk9ORSA9IDAsCisJRFBETUFJX0RFU1RfRFBJTyA9IDEsCisJRFBE TUFJX0RFU1RfRFBDT04gPSAyCit9OworCisvKioKKyAqIHN0cnVjdCBkcGRtYWlfZGVzdF9jZmcg LSBTdHJ1Y3R1cmUgcmVwcmVzZW50aW5nIERQRE1BSSBkZXN0aW5hdGlvbiBwYXJhbWV0ZXJzCisg KiBAZGVzdF90eXBlOiBEZXN0aW5hdGlvbiB0eXBlCisgKiBAZGVzdF9pZDogRWl0aGVyIERQSU8g SUQgb3IgRFBDT04gSUQsIGRlcGVuZGluZyBvbiB0aGUgZGVzdGluYXRpb24gdHlwZQorICogQHBy aW9yaXR5OiBQcmlvcml0eSBzZWxlY3Rpb24gd2l0aGluIHRoZSBEUElPIG9yIERQQ09OIGNoYW5u ZWw7IHZhbGlkIHZhbHVlcworICoJYXJlIDAtMSBvciAwLTcsIGRlcGVuZGluZyBvbiB0aGUgbnVt YmVyIG9mIHByaW9yaXRpZXMgaW4gdGhhdAorICoJY2hhbm5lbDsgbm90IHJlbGV2YW50IGZvciAn RFBETUFJX0RFU1RfTk9ORScgb3B0aW9uCisgKi8KK3N0cnVjdCBkcGRtYWlfZGVzdF9jZmcgewor CWVudW0gZHBkbWFpX2Rlc3QJZGVzdF90eXBlOworCWludAkJCWRlc3RfaWQ7CisJdTgJCXByaW9y aXR5OworfTsKKworLyogRFBETUFJIHF1ZXVlIG1vZGlmaWNhdGlvbiBvcHRpb25zICovCisKKy8q KgorICogU2VsZWN0IHRvIG1vZGlmeSB0aGUgdXNlcidzIGNvbnRleHQgYXNzb2NpYXRlZCB3aXRo IHRoZSBxdWV1ZQorICovCisjZGVmaW5lIERQRE1BSV9RVUVVRV9PUFRfVVNFUl9DVFgJMHgwMDAw MDAwMQorCisvKioKKyAqIFNlbGVjdCB0byBtb2RpZnkgdGhlIHF1ZXVlJ3MgZGVzdGluYXRpb24K KyAqLworI2RlZmluZSBEUERNQUlfUVVFVUVfT1BUX0RFU1QJCTB4MDAwMDAwMDIKKworLyoqCisg KiBzdHJ1Y3QgZHBkbWFpX3J4X3F1ZXVlX2NmZyAtIERQRE1BSSBSWCBxdWV1ZSBjb25maWd1cmF0 aW9uCisgKiBAb3B0aW9uczogRmxhZ3MgcmVwcmVzZW50aW5nIHRoZSBzdWdnZXN0ZWQgbW9kaWZp Y2F0aW9ucyB0byB0aGUgcXVldWU7CisgKglVc2UgYW55IGNvbWJpbmF0aW9uIG9mICdEUERNQUlf UVVFVUVfT1BUXzxYPicgZmxhZ3MKKyAqIEB1c2VyX2N0eDogVXNlciBjb250ZXh0IHZhbHVlIHBy b3ZpZGVkIGluIHRoZSBmcmFtZSBkZXNjcmlwdG9yIG9mIGVhY2gKKyAqCWRlcXVldWVkIGZyYW1l OworICoJdmFsaWQgb25seSBpZiAnRFBETUFJX1FVRVVFX09QVF9VU0VSX0NUWCcgaXMgY29udGFp bmVkIGluICdvcHRpb25zJworICogQGRlc3RfY2ZnOiBRdWV1ZSBkZXN0aW5hdGlvbiBwYXJhbWV0 ZXJzOworICoJdmFsaWQgb25seSBpZiAnRFBETUFJX1FVRVVFX09QVF9ERVNUJyBpcyBjb250YWlu ZWQgaW4gJ29wdGlvbnMnCisgKi8KK3N0cnVjdCBkcGRtYWlfcnhfcXVldWVfY2ZnIHsKKwl1MzIJ CW9wdGlvbnM7CisJdTY0CQl1c2VyX2N0eDsKKwlzdHJ1Y3QgZHBkbWFpX2Rlc3RfY2ZnCWRlc3Rf Y2ZnOworCit9OworCisvKioKKyAqIGRwZG1haV9zZXRfcnhfcXVldWUoKSAtIFNldCBSeCBxdWV1 ZSBjb25maWd1cmF0aW9uCisgKiBAbWNfaW86CVBvaW50ZXIgdG8gTUMgcG9ydGFsJ3MgSS9PIG9i amVjdAorICogQGNtZF9mbGFnczoJQ29tbWFuZCBmbGFnczsgb25lIG9yIG1vcmUgb2YgJ01DX0NN RF9GTEFHXycKKyAqIEB0b2tlbjoJVG9rZW4gb2YgRFBETUFJIG9iamVjdAorICogQHByaW9yaXR5 OglTZWxlY3QgdGhlIHF1ZXVlIHJlbGF0aXZlIHRvIG51bWJlciBvZgorICoJCQlwcmlvcml0aWVz IGNvbmZpZ3VyZWQgYXQgRFBETUFJIGNyZWF0aW9uOyB1c2UKKyAqCQkJRFBETUFJX0FMTF9RVUVV RVMgdG8gY29uZmlndXJlIGFsbCBSeCBxdWV1ZXMKKyAqCQkJaWRlbnRpY2FsbHkuCisgKiBAY2Zn OglSeCBxdWV1ZSBjb25maWd1cmF0aW9uCisgKgorICogUmV0dXJuOgknMCcgb24gU3VjY2Vzczsg RXJyb3IgY29kZSBvdGhlcndpc2UuCisgKi8KK2ludCBkcGRtYWlfc2V0X3J4X3F1ZXVlKHN0cnVj dCBmc2xfbWNfaW8JCQkqbWNfaW8sCisJCQl1MzIJCQkJY21kX2ZsYWdzLAorCQkJdTE2CQkJCXRv a2VuLAorCQkJdTgJCQkJCXByaW9yaXR5LAorCQkJY29uc3Qgc3RydWN0IGRwZG1haV9yeF9xdWV1 ZV9jZmcJKmNmZyk7CisKKy8qKgorICogc3RydWN0IGRwZG1haV9yeF9xdWV1ZV9hdHRyIC0gU3Ry dWN0dXJlIHJlcHJlc2VudGluZyBhdHRyaWJ1dGVzIG9mIFJ4IHF1ZXVlcworICogQHVzZXJfY3R4 OiAgVXNlciBjb250ZXh0IHZhbHVlIHByb3ZpZGVkIGluIHRoZSBmcmFtZSBkZXNjcmlwdG9yIG9m IGVhY2gKKyAqCSBkZXF1ZXVlZCBmcmFtZQorICogQGRlc3RfY2ZnOiBRdWV1ZSBkZXN0aW5hdGlv biBjb25maWd1cmF0aW9uCisgKiBAZnFpZDogVmlydHVhbCBGUUlEIHZhbHVlIHRvIGJlIHVzZWQg Zm9yIGRlcXVldWUgb3BlcmF0aW9ucworICovCitzdHJ1Y3QgZHBkbWFpX3J4X3F1ZXVlX2F0dHIg eworCXU2NAkJdXNlcl9jdHg7CisJc3RydWN0IGRwZG1haV9kZXN0X2NmZwlkZXN0X2NmZzsKKwl1 MzIJCWZxaWQ7Cit9OworCisvKioKKyAqIGRwZG1haV9nZXRfcnhfcXVldWUoKSAtIFJldHJpZXZl IFJ4IHF1ZXVlIGF0dHJpYnV0ZXMuCisgKiBAbWNfaW86CVBvaW50ZXIgdG8gTUMgcG9ydGFsJ3Mg SS9PIG9iamVjdAorICogQGNtZF9mbGFnczoJQ29tbWFuZCBmbGFnczsgb25lIG9yIG1vcmUgb2Yg J01DX0NNRF9GTEFHXycKKyAqIEB0b2tlbjoJVG9rZW4gb2YgRFBETUFJIG9iamVjdAorICogQHBy aW9yaXR5OglTZWxlY3QgdGhlIHF1ZXVlIHJlbGF0aXZlIHRvIG51bWJlciBvZgorICoJCQkJcHJp b3JpdGllcyBjb25maWd1cmVkIGF0IERQRE1BSSBjcmVhdGlvbgorICogQGF0dHI6CVJldHVybmVk IFJ4IHF1ZXVlIGF0dHJpYnV0ZXMKKyAqCisgKiBSZXR1cm46CScwJyBvbiBTdWNjZXNzOyBFcnJv ciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50IGRwZG1haV9nZXRfcnhfcXVldWUoc3RydWN0IGZz bF9tY19pbwkJKm1jX2lvLAorCQkJdTMyCQkJY21kX2ZsYWdzLAorCQkJdTE2CQkJdG9rZW4sCisJ CQl1OAkJCQlwcmlvcml0eSwKKwkJCXN0cnVjdCBkcGRtYWlfcnhfcXVldWVfYXR0cgkqYXR0cik7 CisKKy8qKgorICogc3RydWN0IGRwZG1haV90eF9xdWV1ZV9hdHRyIC0gU3RydWN0dXJlIHJlcHJl c2VudGluZyBhdHRyaWJ1dGVzIG9mIFR4IHF1ZXVlcworICogQGZxaWQ6IFZpcnR1YWwgRlFJRCB0 byBiZSB1c2VkIGZvciBzZW5kaW5nIGZyYW1lcyB0byBETUEgaGFyZHdhcmUKKyAqLworCitzdHJ1 Y3QgZHBkbWFpX3R4X3F1ZXVlX2F0dHIgeworCXUzMiBmcWlkOworfTsKKworLyoqCisgKiBkcGRt YWlfZ2V0X3R4X3F1ZXVlKCkgLSBSZXRyaWV2ZSBUeCBxdWV1ZSBhdHRyaWJ1dGVzLgorICogQG1j X2lvOglQb2ludGVyIHRvIE1DIHBvcnRhbCdzIEkvTyBvYmplY3QKKyAqIEBjbWRfZmxhZ3M6CUNv bW1hbmQgZmxhZ3M7IG9uZSBvciBtb3JlIG9mICdNQ19DTURfRkxBR18nCisgKiBAdG9rZW46CVRv a2VuIG9mIERQRE1BSSBvYmplY3QKKyAqIEBwcmlvcml0eToJU2VsZWN0IHRoZSBxdWV1ZSByZWxh dGl2ZSB0byBudW1iZXIgb2YKKyAqCQkJcHJpb3JpdGllcyBjb25maWd1cmVkIGF0IERQRE1BSSBj cmVhdGlvbgorICogQGF0dHI6CVJldHVybmVkIFR4IHF1ZXVlIGF0dHJpYnV0ZXMKKyAqCisgKiBS ZXR1cm46CScwJyBvbiBTdWNjZXNzOyBFcnJvciBjb2RlIG90aGVyd2lzZS4KKyAqLworaW50IGRw ZG1haV9nZXRfdHhfcXVldWUoc3RydWN0IGZzbF9tY19pbwkJKm1jX2lvLAorCQkJdTMyCQkJY21k X2ZsYWdzLAorCQkJdTE2CQkJdG9rZW4sCisJCQl1OAkJCQlwcmlvcml0eSwKKwkJCXN0cnVjdCBk cGRtYWlfdHhfcXVldWVfYXR0cgkqYXR0cik7CisKKyNlbmRpZiAvKiBfX0ZTTF9EUERNQUlfSCAq LwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZnNsLWRwYWEyLXFkbWEvZHBkbWFpX2NtZC5oIGIv ZHJpdmVycy9kbWEvZnNsLWRwYWEyLXFkbWEvZHBkbWFpX2NtZC5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLjA3MWExYTcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2Rt YS9mc2wtZHBhYTItcWRtYS9kcGRtYWlfY21kLmgKQEAgLTAsMCArMSwxOTcgQEAKKy8qIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCisvKiBDb3B5cmlnaHQgMjAxNC0yMDE4IE5Y UCAqLworCisjaWZuZGVmIF9GU0xfRFBETUFJX0NNRF9ICisjZGVmaW5lIF9GU0xfRFBETUFJX0NN RF9ICisKKy8qIERQRE1BSSBWZXJzaW9uICovCisjZGVmaW5lIERQRE1BSV9WRVJfTUFKT1IJCTIK KyNkZWZpbmUgRFBETUFJX1ZFUl9NSU5PUgkJMgorCisjZGVmaW5lIERQRE1BSV9DTURfQkFTRV9W RVJTSU9OCQkwCisjZGVmaW5lIERQRE1BSV9DTURfSURfT0ZGU0VUCQk0CisKKyNkZWZpbmUgRFBE TUFJX0NNRElEX0ZPUk1BVCh4KQkJKCgoeCkgPDwgRFBETUFJX0NNRF9JRF9PRkZTRVQpIHwgXAor CQkJCQlEUERNQUlfQ01EX0JBU0VfVkVSU0lPTikKKworLyogQ29tbWFuZCBJRHMgKi8KKyNkZWZp bmUgRFBETUFJX0NNRElEX0NMT1NFCQlEUERNQUlfQ01ESURfRk9STUFUKDB4ODAwKQorI2RlZmlu ZSBEUERNQUlfQ01ESURfT1BFTiAgICAgICAgICAgICAgIERQRE1BSV9DTURJRF9GT1JNQVQoMHg4 MEUpCisjZGVmaW5lIERQRE1BSV9DTURJRF9DUkVBVEUgICAgICAgICAgICAgRFBETUFJX0NNRElE X0ZPUk1BVCgweDkwRSkKKyNkZWZpbmUgRFBETUFJX0NNRElEX0RFU1RST1kgICAgICAgICAgICBE UERNQUlfQ01ESURfRk9STUFUKDB4OTAwKQorCisjZGVmaW5lIERQRE1BSV9DTURJRF9FTkFCTEUg ICAgICAgICAgICAgRFBETUFJX0NNRElEX0ZPUk1BVCgweDAwMikKKyNkZWZpbmUgRFBETUFJX0NN RElEX0RJU0FCTEUgICAgICAgICAgICBEUERNQUlfQ01ESURfRk9STUFUKDB4MDAzKQorI2RlZmlu ZSBEUERNQUlfQ01ESURfR0VUX0FUVFIgICAgICAgICAgIERQRE1BSV9DTURJRF9GT1JNQVQoMHgw MDQpCisjZGVmaW5lIERQRE1BSV9DTURJRF9SRVNFVCAgICAgICAgICAgICAgRFBETUFJX0NNRElE X0ZPUk1BVCgweDAwNSkKKyNkZWZpbmUgRFBETUFJX0NNRElEX0lTX0VOQUJMRUQgICAgICAgICBE UERNQUlfQ01ESURfRk9STUFUKDB4MDA2KQorCisjZGVmaW5lIERQRE1BSV9DTURJRF9TRVRfSVJR ICAgICAgICAgICAgRFBETUFJX0NNRElEX0ZPUk1BVCgweDAxMCkKKyNkZWZpbmUgRFBETUFJX0NN RElEX0dFVF9JUlEgICAgICAgICAgICBEUERNQUlfQ01ESURfRk9STUFUKDB4MDExKQorI2RlZmlu ZSBEUERNQUlfQ01ESURfU0VUX0lSUV9FTkFCTEUgICAgIERQRE1BSV9DTURJRF9GT1JNQVQoMHgw MTIpCisjZGVmaW5lIERQRE1BSV9DTURJRF9HRVRfSVJRX0VOQUJMRSAgICAgRFBETUFJX0NNRElE X0ZPUk1BVCgweDAxMykKKyNkZWZpbmUgRFBETUFJX0NNRElEX1NFVF9JUlFfTUFTSyAgICAgICBE UERNQUlfQ01ESURfRk9STUFUKDB4MDE0KQorI2RlZmluZSBEUERNQUlfQ01ESURfR0VUX0lSUV9N QVNLICAgICAgIERQRE1BSV9DTURJRF9GT1JNQVQoMHgwMTUpCisjZGVmaW5lIERQRE1BSV9DTURJ RF9HRVRfSVJRX1NUQVRVUyAgICAgRFBETUFJX0NNRElEX0ZPUk1BVCgweDAxNikKKyNkZWZpbmUg RFBETUFJX0NNRElEX0NMRUFSX0lSUV9TVEFUVVMJRFBETUFJX0NNRElEX0ZPUk1BVCgweDAxNykK KworI2RlZmluZSBEUERNQUlfQ01ESURfU0VUX1JYX1FVRVVFCURQRE1BSV9DTURJRF9GT1JNQVQo MHgxQTApCisjZGVmaW5lIERQRE1BSV9DTURJRF9HRVRfUlhfUVVFVUUgICAgICAgRFBETUFJX0NN RElEX0ZPUk1BVCgweDFBMSkKKyNkZWZpbmUgRFBETUFJX0NNRElEX0dFVF9UWF9RVUVVRSAgICAg ICBEUERNQUlfQ01ESURfRk9STUFUKDB4MUEyKQorCisjZGVmaW5lIE1DX0NNRF9IRFJfVE9LRU5f TyAzMiAgLyogVG9rZW4gZmllbGQgb2Zmc2V0ICovCisjZGVmaW5lIE1DX0NNRF9IRFJfVE9LRU5f UyAxNiAgLyogVG9rZW4gZmllbGQgc2l6ZSAqLworCisjZGVmaW5lIE1BS0VfVU1BU0s2NChfd2lk dGgpIFwKKwkoKHU2NCkoKF93aWR0aCkgPCA2NCA/ICgodTY0KTEgPDwgKF93aWR0aCkpIC0gMSA6 IFwKKwkodTY0KS0xKSkgXAorCitzdGF0aWMgaW5saW5lIHU2NCBtY19lbmMoaW50IGxzb2Zmc2V0 LCBpbnQgd2lkdGgsIHU2NCB2YWwpCit7CisJcmV0dXJuICh1NjQpKCgodTY0KXZhbCAmIE1BS0Vf VU1BU0s2NCh3aWR0aCkpIDw8IGxzb2Zmc2V0KTsKK30KKworc3RhdGljIGlubGluZSB1NjQgbWNf ZGVjKHU2NCB2YWwsIGludCBsc29mZnNldCwgaW50IHdpZHRoKQoreworCXJldHVybiAodTY0KSgo dmFsID4+IGxzb2Zmc2V0KSAmIE1BS0VfVU1BU0s2NCh3aWR0aCkpOworfQorCisjZGVmaW5lIE1D X0NNRF9PUChfY21kLCBfcGFyYW0sIF9vZmZzZXQsIF93aWR0aCwgX3R5cGUsIF9hcmcpIFwKKwko KF9jbWQpLnBhcmFtc1tfcGFyYW1dIHw9IG1jX2VuYygoX29mZnNldCksIChfd2lkdGgpLCBfYXJn KSkKKworI2RlZmluZSBNQ19SU1BfT1AoX2NtZCwgX3BhcmFtLCBfb2Zmc2V0LCBfd2lkdGgsIF90 eXBlLCBfYXJnKSBcCisJKF9hcmcgPSAoX3R5cGUpbWNfZGVjKF9jbWQucGFyYW1zW19wYXJhbV0s IChfb2Zmc2V0KSwgKF93aWR0aCkpKQorCisjZGVmaW5lIE1DX0NNRF9IRFJfUkVBRF9UT0tFTihf aGRyKSBcCisJKCh1MTYpbWNfZGVjKChfaGRyKSwgTUNfQ01EX0hEUl9UT0tFTl9PLCBNQ19DTURf SERSX1RPS0VOX1MpKQorCisvKiAgICAgICAgICAgICAgICBjbWQsIHBhcmFtLCBvZmZzZXQsIHdp ZHRoLCB0eXBlLCBhcmdfbmFtZSAqLworI2RlZmluZSBEUERNQUlfQ01EX09QRU4oY21kLCBkcGRt YWlfaWQpIFwKKwlNQ19DTURfT1AoY21kLCAwLCAwLCAgMzIsIGludCwgICAgICBkcGRtYWlfaWQp CisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFy Z19uYW1lICovCisjZGVmaW5lIERQRE1BSV9DTURfQ1JFQVRFKGNtZCwgY2ZnKSBcCitkbyB7IFwK KwlNQ19DTURfT1AoY21kLCAwLCA4LCAgOCwgIHU4LCAgKGNmZyktPnByaW9yaXRpZXNbMF0pO1wK KwlNQ19DTURfT1AoY21kLCAwLCAxNiwgOCwgIHU4LCAgKGNmZyktPnByaW9yaXRpZXNbMV0pO1wK K30gd2hpbGUgKDApCisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lk dGgsIHR5cGUsIGFyZ19uYW1lICovCisjZGVmaW5lIERQRE1BSV9SU1BfSVNfRU5BQkxFRChjbWQs IGVuKSBcCisJTUNfUlNQX09QKGNtZCwgMCwgMCwgIDEsICBpbnQsCSAgICBlbikKKworLyogICAg ICAgICAgICAgICAgY21kLCBwYXJhbSwgb2Zmc2V0LCB3aWR0aCwgdHlwZSwgYXJnX25hbWUgKi8K KyNkZWZpbmUgRFBETUFJX0NNRF9TRVRfSVJRKGNtZCwgaXJxX2luZGV4LCBpcnFfY2ZnKSBcCitk byB7IFwKKwlNQ19DTURfT1AoY21kLCAwLCAwLCAgOCwgIHU4LCAgaXJxX2luZGV4KTtcCisJTUNf Q01EX09QKGNtZCwgMCwgMzIsIDMyLCB1MzIsIGlycV9jZmctPnZhbCk7XAorCU1DX0NNRF9PUChj bWQsIDEsIDAsICA2NCwgdTY0LCBpcnFfY2ZnLT5hZGRyKTtcCisJTUNfQ01EX09QKGNtZCwgMiwg MCwgIDMyLCBpbnQsCSAgICBpcnFfY2ZnLT5pcnFfbnVtKTsgXAorfSB3aGlsZSAoMCkKKworLyog ICAgICAgICAgICAgICAgY21kLCBwYXJhbSwgb2Zmc2V0LCB3aWR0aCwgdHlwZSwgYXJnX25hbWUg Ki8KKyNkZWZpbmUgRFBETUFJX0NNRF9HRVRfSVJRKGNtZCwgaXJxX2luZGV4KSBcCisJTUNfQ01E X09QKGNtZCwgMCwgMzIsIDgsICB1OCwgIGlycV9pbmRleCkKKworLyogICAgICAgICAgICAgICAg Y21kLCBwYXJhbSwgb2Zmc2V0LCB3aWR0aCwgdHlwZSwgYXJnX25hbWUgKi8KKyNkZWZpbmUgRFBE TUFJX1JTUF9HRVRfSVJRKGNtZCwgdHlwZSwgaXJxX2NmZykgXAorZG8geyBcCisJTUNfUlNQX09Q KGNtZCwgMCwgMCwgIDMyLCB1MzIsIGlycV9jZmctPnZhbCk7IFwKKwlNQ19SU1BfT1AoY21kLCAx LCAwLCAgNjQsIHU2NCwgaXJxX2NmZy0+YWRkcik7XAorCU1DX1JTUF9PUChjbWQsIDIsIDAsICAz MiwgaW50LAkgICAgaXJxX2NmZy0+aXJxX251bSk7IFwKKwlNQ19SU1BfT1AoY21kLCAyLCAzMiwg MzIsIGludCwJICAgIHR5cGUpOyBcCit9IHdoaWxlICgwKQorCisvKiAgICAgICAgICAgICAgICBj bWQsIHBhcmFtLCBvZmZzZXQsIHdpZHRoLCB0eXBlLCBhcmdfbmFtZSAqLworI2RlZmluZSBEUERN QUlfQ01EX1NFVF9JUlFfRU5BQkxFKGNtZCwgaXJxX2luZGV4LCBlbmFibGVfc3RhdGUpIFwKK2Rv IHsgXAorCU1DX0NNRF9PUChjbWQsIDAsIDAsICA4LCAgdTgsICBlbmFibGVfc3RhdGUpOyBcCisJ TUNfQ01EX09QKGNtZCwgMCwgMzIsIDgsICB1OCwgIGlycV9pbmRleCk7IFwKK30gd2hpbGUgKDAp CisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFy Z19uYW1lICovCisjZGVmaW5lIERQRE1BSV9DTURfR0VUX0lSUV9FTkFCTEUoY21kLCBpcnFfaW5k ZXgpIFwKKwlNQ19DTURfT1AoY21kLCAwLCAzMiwgOCwgIHU4LCAgaXJxX2luZGV4KQorCisvKiAg ICAgICAgICAgICAgICBjbWQsIHBhcmFtLCBvZmZzZXQsIHdpZHRoLCB0eXBlLCBhcmdfbmFtZSAq LworI2RlZmluZSBEUERNQUlfUlNQX0dFVF9JUlFfRU5BQkxFKGNtZCwgZW5hYmxlX3N0YXRlKSBc CisJTUNfUlNQX09QKGNtZCwgMCwgMCwgIDgsICB1OCwgIGVuYWJsZV9zdGF0ZSkKKworLyogICAg ICAgICAgICAgICAgY21kLCBwYXJhbSwgb2Zmc2V0LCB3aWR0aCwgdHlwZSwgYXJnX25hbWUgKi8K KyNkZWZpbmUgRFBETUFJX0NNRF9TRVRfSVJRX01BU0soY21kLCBpcnFfaW5kZXgsIG1hc2spIFwK K2RvIHsgXAorCU1DX0NNRF9PUChjbWQsIDAsIDAsICAzMiwgdTMyLCBtYXNrKTsgXAorCU1DX0NN RF9PUChjbWQsIDAsIDMyLCA4LCAgdTgsICBpcnFfaW5kZXgpOyBcCit9IHdoaWxlICgwKQorCisv KiAgICAgICAgICAgICAgICBjbWQsIHBhcmFtLCBvZmZzZXQsIHdpZHRoLCB0eXBlLCBhcmdfbmFt ZSAqLworI2RlZmluZSBEUERNQUlfQ01EX0dFVF9JUlFfTUFTSyhjbWQsIGlycV9pbmRleCkgXAor CU1DX0NNRF9PUChjbWQsIDAsIDMyLCA4LCAgdTgsICBpcnFfaW5kZXgpCisKKy8qICAgICAgICAg ICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFyZ19uYW1lICovCisjZGVm aW5lIERQRE1BSV9SU1BfR0VUX0lSUV9NQVNLKGNtZCwgbWFzaykgXAorCU1DX1JTUF9PUChjbWQs IDAsIDAsICAzMiwgdTMyLCBtYXNrKQorCisvKiAgICAgICAgICAgICAgICBjbWQsIHBhcmFtLCBv ZmZzZXQsIHdpZHRoLCB0eXBlLCBhcmdfbmFtZSAqLworI2RlZmluZSBEUERNQUlfQ01EX0dFVF9J UlFfU1RBVFVTKGNtZCwgaXJxX2luZGV4LCBzdGF0dXMpIFwKK2RvIHsgXAorCU1DX0NNRF9PUChj bWQsIDAsIDAsICAzMiwgdTMyLCBzdGF0dXMpO1wKKwlNQ19DTURfT1AoY21kLCAwLCAzMiwgOCwg IHU4LCAgaXJxX2luZGV4KTtcCit9IHdoaWxlICgwKQorCisvKiAgICAgICAgICAgICAgICBjbWQs IHBhcmFtLCBvZmZzZXQsIHdpZHRoLCB0eXBlLCBhcmdfbmFtZSAqLworI2RlZmluZSBEUERNQUlf UlNQX0dFVF9JUlFfU1RBVFVTKGNtZCwgc3RhdHVzKSBcCisJTUNfUlNQX09QKGNtZCwgMCwgMCwg IDMyLCB1MzIsICBzdGF0dXMpCisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNl dCwgd2lkdGgsIHR5cGUsIGFyZ19uYW1lICovCisjZGVmaW5lIERQRE1BSV9DTURfQ0xFQVJfSVJR X1NUQVRVUyhjbWQsIGlycV9pbmRleCwgc3RhdHVzKSBcCitkbyB7IFwKKwlNQ19DTURfT1AoY21k LCAwLCAwLCAgMzIsIHUzMiwgc3RhdHVzKTsgXAorCU1DX0NNRF9PUChjbWQsIDAsIDMyLCA4LCAg dTgsICBpcnFfaW5kZXgpOyBcCit9IHdoaWxlICgwKQorCisvKiAgICAgICAgICAgICAgICBjbWQs IHBhcmFtLCBvZmZzZXQsIHdpZHRoLCB0eXBlLCBhcmdfbmFtZSAqLworI2RlZmluZSBEUERNQUlf UlNQX0dFVF9BVFRSKGNtZCwgYXR0cikgXAorZG8geyBcCisJTUNfUlNQX09QKGNtZCwgMCwgMCwg IDMyLCBpbnQsCShhdHRyKS0+aWQpOyBcCisJTUNfUlNQX09QKGNtZCwgMCwgMzIsICA4LCAgdTgs CShhdHRyKS0+bnVtX29mX3ByaW9yaXRpZXMpOyBcCisJTUNfUlNQX09QKGNtZCwgMSwgMCwgIDE2 LCB1MTYsCShhdHRyKS0+dmVyc2lvbi5tYWpvcik7XAorCU1DX1JTUF9PUChjbWQsIDEsIDE2LCAx NiwgdTE2LAkoYXR0ciktPnZlcnNpb24ubWlub3IpO1wKK30gd2hpbGUgKDApCisKKy8qICAgICAg ICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFyZ19uYW1lICovCisj ZGVmaW5lIERQRE1BSV9DTURfU0VUX1JYX1FVRVVFKGNtZCwgcHJpb3JpdHksIGNmZykgXAorZG8g eyBcCisJTUNfQ01EX09QKGNtZCwgMCwgMCwgIDMyLCBpbnQsCShjZmcpLT5kZXN0X2NmZy5kZXN0 X2lkKTsgXAorCU1DX0NNRF9PUChjbWQsIDAsIDMyLCA4LCAgdTgsCShjZmcpLT5kZXN0X2NmZy5w cmlvcml0eSk7IFwKKwlNQ19DTURfT1AoY21kLCAwLCA0MCwgOCwgIHU4LAlwcmlvcml0eSk7IFwK KwlNQ19DTURfT1AoY21kLCAwLCA0OCwgNCwgIGVudW0gZHBkbWFpX2Rlc3QsIFwKKwkJCShjZmcp LT5kZXN0X2NmZy5kZXN0X3R5cGUpOyBcCisJTUNfQ01EX09QKGNtZCwgMSwgMCwgIDY0LCB1NjQs CShjZmcpLT51c2VyX2N0eCk7IFwKKwlNQ19DTURfT1AoY21kLCAyLCAwLCAgMzIsIHUzMiwJKGNm ZyktPm9wdGlvbnMpO1wKK30gd2hpbGUgKDApCisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFy YW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFyZ19uYW1lICovCisjZGVmaW5lIERQRE1BSV9DTURf R0VUX1JYX1FVRVVFKGNtZCwgcHJpb3JpdHkpIFwKKwlNQ19DTURfT1AoY21kLCAwLCA0MCwgOCwg IHU4LCAgcHJpb3JpdHkpCisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwg d2lkdGgsIHR5cGUsIGFyZ19uYW1lICovCisjZGVmaW5lIERQRE1BSV9SU1BfR0VUX1JYX1FVRVVF KGNtZCwgYXR0cikgXAorZG8geyBcCisJTUNfUlNQX09QKGNtZCwgMCwgMCwgIDMyLCBpbnQsCShh dHRyKS0+ZGVzdF9jZmcuZGVzdF9pZCk7XAorCU1DX1JTUF9PUChjbWQsIDAsIDMyLCA4LCAgdTgs CShhdHRyKS0+ZGVzdF9jZmcucHJpb3JpdHkpO1wKKwlNQ19SU1BfT1AoY21kLCAwLCA0OCwgNCwg IGVudW0gZHBkbWFpX2Rlc3QsIFwKKwkJCShhdHRyKS0+ZGVzdF9jZmcuZGVzdF90eXBlKTtcCisJ TUNfUlNQX09QKGNtZCwgMSwgMCwgIDY0LCB1NjQsICAoYXR0ciktPnVzZXJfY3R4KTtcCisJTUNf UlNQX09QKGNtZCwgMiwgMCwgIDMyLCB1MzIsICAoYXR0ciktPmZxaWQpO1wKK30gd2hpbGUgKDAp CisKKy8qICAgICAgICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFy Z19uYW1lICovCisjZGVmaW5lIERQRE1BSV9DTURfR0VUX1RYX1FVRVVFKGNtZCwgcHJpb3JpdHkp IFwKKwlNQ19DTURfT1AoY21kLCAwLCA0MCwgOCwgIHU4LCAgcHJpb3JpdHkpCisKKy8qICAgICAg ICAgICAgICAgIGNtZCwgcGFyYW0sIG9mZnNldCwgd2lkdGgsIHR5cGUsIGFyZ19uYW1lICovCisj ZGVmaW5lIERQRE1BSV9SU1BfR0VUX1RYX1FVRVVFKGNtZCwgYXR0cikgXAorCU1DX1JTUF9PUChj bWQsIDEsIDAsICAzMiwgdTMyLCAgKGF0dHIpLT5mcWlkKQorCisjZW5kaWYgLyogX0ZTTF9EUERN QUlfQ01EX0ggKi8K 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.0 required=3.0 tests=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 9FE9DC10F0E for ; Tue, 9 Apr 2019 07:29:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6F1E220883 for ; Tue, 9 Apr 2019 07:29:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726668AbfDIH3O (ORCPT ); Tue, 9 Apr 2019 03:29:14 -0400 Received: from inva021.nxp.com ([92.121.34.21]:43548 "EHLO inva021.nxp.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726236AbfDIH3O (ORCPT ); Tue, 9 Apr 2019 03:29:14 -0400 Received: from inva021.nxp.com (localhost [127.0.0.1]) by inva021.eu-rdc02.nxp.com (Postfix) with ESMTP id CC38C2001CA; Tue, 9 Apr 2019 09:29:05 +0200 (CEST) Received: from invc005.ap-rdc01.nxp.com (invc005.ap-rdc01.nxp.com [165.114.16.14]) by inva021.eu-rdc02.nxp.com (Postfix) with ESMTP id 6CA182001E8; Tue, 9 Apr 2019 09:29:02 +0200 (CEST) Received: from titan.ap.freescale.net (TITAN.ap.freescale.net [10.192.208.233]) by invc005.ap-rdc01.nxp.com (Postfix) with ESMTP id 3941540318; Tue, 9 Apr 2019 15:28:58 +0800 (SGT) From: Peng Ma To: vkoul@kernel.org, dan.j.williams@intel.com, leoyang.li@nxp.com Cc: linux-kernel@vger.kernel.org, dmaengine@vger.kernel.org, Peng Ma Subject: [V3 1/2] dmaengine: fsl-dpaa2-qdma: Add the DPDMAI(Data Path DMA Interface) support Date: Tue, 9 Apr 2019 15:22:11 +0800 Message-Id: <20190409072212.15860-1-peng.ma@nxp.com> X-Mailer: git-send-email 2.14.1 X-Virus-Scanned: ClamAV using ClamSMTP 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: <20190409072211.QxmYgAElnH3qz84Qh1ehtBoWVlsLHlwP3blXXxIt6DA@z> The MC exports the DPDMAI object as an interface to operate the DPAA2 QDMA Engine. The DPDMAI enables sending frame-based requests to QDMA and receiving back confirmation response on transaction completion, utilizing the DPAA2 QBMan infrastructure. DPDMAI object provides up to two priorities for processing QDMA requests. The following list summarizes the DPDMAI main features and capabilities: 1. Supports up to two scheduling priorities for processing service requests. - Each DPDMAI transmit queue is mapped to one of two service priorities, allowing further prioritization in hardware between requests from different DPDMAI objects. 2. Supports up to two receive queues for incoming transaction completion confirmations. - Each DPDMAI receive queue is mapped to one of two receive priorities, allowing further prioritization between other interfaces when associating the DPDMAI receive queues to DPIO or DPCON objects. 3. Supports different scheduling options for processing received packets: - Queues can be configured either in 'parked' mode (default), oattached to a DPIO object, or attached to DPCON object. 4. Allows interaction with one or more DPIO objects for dequeueing/enqueueing frame descriptors(FD) and for acquiring/releasing buffers. 5. Supports enable, disable, and reset operations. Add dpdmai to support some platforms with dpaa2 qdma engine. Signed-off-by: Peng Ma --- changed for v3: - no changed drivers/dma/fsl-dpaa2-qdma/dpdmai.c | 483 ++++++++++++++++++++++++++++ drivers/dma/fsl-dpaa2-qdma/dpdmai.h | 524 +++++++++++++++++++++++++++++++ drivers/dma/fsl-dpaa2-qdma/dpdmai_cmd.h | 197 ++++++++++++ 3 files changed, 1204 insertions(+), 0 deletions(-) create mode 100644 drivers/dma/fsl-dpaa2-qdma/dpdmai.c create mode 100644 drivers/dma/fsl-dpaa2-qdma/dpdmai.h create mode 100644 drivers/dma/fsl-dpaa2-qdma/dpdmai_cmd.h diff --git a/drivers/dma/fsl-dpaa2-qdma/dpdmai.c b/drivers/dma/fsl-dpaa2-qdma/dpdmai.c new file mode 100644 index 0000000..685eabe --- /dev/null +++ b/drivers/dma/fsl-dpaa2-qdma/dpdmai.c @@ -0,0 +1,483 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright 2014-2018 NXP + +#include +#include +#include "dpdmai.h" +#include "dpdmai_cmd.h" +#include + +struct dpdmai_cmd_open { + __le32 dpdmai_id; +}; + +struct dpdmai_rsp_get_attributes { + __le32 id; + u8 num_of_priorities; + u8 pad0[3]; + __le16 major; + __le16 minor; +}; + +struct dpdmai_cmd_queue { + __le32 dest_id; + u8 priority; + u8 queue; + u8 dest_type; + u8 pad; + __le64 user_ctx; + union { + __le32 options; + __le32 fqid; + }; +}; + +struct dpdmai_rsp_get_tx_queue { + __le64 pad; + __le32 fqid; +}; + +int dpdmai_open(struct fsl_mc_io *mc_io, + u32 cmd_flags, + int dpdmai_id, + u16 *token) +{ + struct fsl_mc_command cmd = { 0 }; + struct dpdmai_cmd_open *cmd_params; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_OPEN, + cmd_flags, + 0); + + cmd_params = (struct dpdmai_cmd_open *)cmd.params; + cmd_params->dpdmai_id = cpu_to_le32(dpdmai_id); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + *token = mc_cmd_hdr_read_token(&cmd); + return 0; +} + +int dpdmai_close(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CLOSE, + cmd_flags, token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_create(struct fsl_mc_io *mc_io, + u32 cmd_flags, + const struct dpdmai_cfg *cfg, + u16 *token) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CREATE, + cmd_flags, + 0); + DPDMAI_CMD_CREATE(cmd, cfg); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + *token = MC_CMD_HDR_READ_TOKEN(cmd.header); + + return 0; +} + +int dpdmai_destroy(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_DESTROY, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_enable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_ENABLE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_disable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_DISABLE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_is_enabled(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + int *en) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_IS_ENABLED, + cmd_flags, + token); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPDMAI_RSP_IS_ENABLED(cmd, *en); + + return 0; +} + +int dpdmai_reset(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_RESET, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_get_irq(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + int *type, + struct dpdmai_irq_cfg *irq_cfg) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_IRQ, + cmd_flags, + token); + DPDMAI_CMD_GET_IRQ(cmd, irq_index); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPDMAI_RSP_GET_IRQ(cmd, *type, irq_cfg); + + return 0; +} + +int dpdmai_set_irq(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + struct dpdmai_irq_cfg *irq_cfg) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_IRQ, + cmd_flags, + token); + DPDMAI_CMD_SET_IRQ(cmd, irq_index, irq_cfg); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_get_irq_enable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u8 *en) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_IRQ_ENABLE, + cmd_flags, + token); + DPDMAI_CMD_GET_IRQ_ENABLE(cmd, irq_index); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPDMAI_RSP_GET_IRQ_ENABLE(cmd, *en); + + return 0; +} + +int dpdmai_set_irq_enable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u8 en) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_IRQ_ENABLE, + cmd_flags, + token); + DPDMAI_CMD_SET_IRQ_ENABLE(cmd, irq_index, en); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_get_irq_mask(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 *mask) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_IRQ_MASK, + cmd_flags, + token); + DPDMAI_CMD_GET_IRQ_MASK(cmd, irq_index); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPDMAI_RSP_GET_IRQ_MASK(cmd, *mask); + + return 0; +} + +int dpdmai_set_irq_mask(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 mask) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_IRQ_MASK, + cmd_flags, + token); + DPDMAI_CMD_SET_IRQ_MASK(cmd, irq_index, mask); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_get_irq_status(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 *status) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_IRQ_STATUS, + cmd_flags, + token); + DPDMAI_CMD_GET_IRQ_STATUS(cmd, irq_index, *status); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPDMAI_RSP_GET_IRQ_STATUS(cmd, *status); + + return 0; +} + +int dpdmai_clear_irq_status(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 status) +{ + struct fsl_mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_CLEAR_IRQ_STATUS, + cmd_flags, + token); + DPDMAI_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_get_attributes(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + struct dpdmai_attr *attr) +{ + struct fsl_mc_command cmd = { 0 }; + int err; + struct dpdmai_rsp_get_attributes *rsp_params; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_ATTR, + cmd_flags, + token); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + rsp_params = (struct dpdmai_rsp_get_attributes *)cmd.params; + attr->id = le32_to_cpu(rsp_params->id); + attr->version.major = le16_to_cpu(rsp_params->major); + attr->version.minor = le16_to_cpu(rsp_params->minor); + attr->num_of_priorities = rsp_params->num_of_priorities; + + return 0; +} + +int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 priority, + const struct dpdmai_rx_queue_cfg *cfg) +{ + struct fsl_mc_command cmd = { 0 }; + struct dpdmai_cmd_queue *cmd_params; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_SET_RX_QUEUE, + cmd_flags, + token); + + cmd_params = (struct dpdmai_cmd_queue *)cmd.params; + cmd_params->dest_id = cpu_to_le32(cfg->dest_cfg.dest_id); + cmd_params->priority = cfg->dest_cfg.priority; + cmd_params->queue = priority; + cmd_params->dest_type = cfg->dest_cfg.dest_type; + cmd_params->user_ctx = cpu_to_le64(cfg->user_ctx); + cmd_params->options = cpu_to_le32(cfg->options); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 priority, struct dpdmai_rx_queue_attr *attr) +{ + struct fsl_mc_command cmd = { 0 }; + struct dpdmai_cmd_queue *cmd_params; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_RX_QUEUE, + cmd_flags, + token); + + cmd_params = (struct dpdmai_cmd_queue *)cmd.params; + cmd_params->queue = priority; + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + attr->dest_cfg.dest_id = le32_to_cpu(cmd_params->dest_id); + attr->dest_cfg.priority = cmd_params->priority; + attr->dest_cfg.dest_type = cmd_params->dest_type; + attr->user_ctx = le64_to_cpu(cmd_params->user_ctx); + attr->fqid = le32_to_cpu(cmd_params->fqid); + + return 0; +} + +int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 priority, + struct dpdmai_tx_queue_attr *attr) +{ + struct fsl_mc_command cmd = { 0 }; + struct dpdmai_cmd_queue *cmd_params; + struct dpdmai_rsp_get_tx_queue *rsp_params; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPDMAI_CMDID_GET_TX_QUEUE, + cmd_flags, + token); + + cmd_params = (struct dpdmai_cmd_queue *)cmd.params; + cmd_params->queue = priority; + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + + rsp_params = (struct dpdmai_rsp_get_tx_queue *)cmd.params; + attr->fqid = le32_to_cpu(rsp_params->fqid); + + return 0; +} diff --git a/drivers/dma/fsl-dpaa2-qdma/dpdmai.h b/drivers/dma/fsl-dpaa2-qdma/dpdmai.h new file mode 100644 index 0000000..c8a7b7f --- /dev/null +++ b/drivers/dma/fsl-dpaa2-qdma/dpdmai.h @@ -0,0 +1,524 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright 2014-2018 NXP */ + +/* + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the above-listed copyright holders nor the + * names of any contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef __FSL_DPDMAI_H +#define __FSL_DPDMAI_H + +struct fsl_mc_io; + +/* Data Path DMA Interface API + * Contains initialization APIs and runtime control APIs for DPDMAI + */ + +/* General DPDMAI macros */ + +/** + * Maximum number of Tx/Rx priorities per DPDMAI object + */ +#define DPDMAI_PRIO_NUM 2 + +/** + * All queues considered; see dpdmai_set_rx_queue() + */ +#define DPDMAI_ALL_QUEUES (u8)(-1) + +/** + * dpdmai_open() - Open a control session for the specified object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @dpdmai_id: DPDMAI unique ID + * @token: Returned token; use in subsequent API calls + * + * This function can be used to open a control session for an + * already created object; an object may have been declared in + * the DPL or by calling the dpdmai_create() function. + * This function returns a unique authentication token, + * associated with the specific object ID and the specific MC + * portal; this token must be used in all subsequent commands for + * this specific object. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_open(struct fsl_mc_io *mc_io, + u32 cmd_flags, + int dpdmai_id, + u16 *token); + +/** + * dpdmai_close() - Close the control session of the object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * + * After this function is called, no further operations are + * allowed on the object without opening a new control session. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_close(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token); + +/** + * struct dpdmai_cfg - Structure representing DPDMAI configuration + * @priorities: Priorities for the DMA hardware processing; valid priorities are + * configured with values 1-8; the entry following last valid entry + * should be configured with 0 + */ +struct dpdmai_cfg { + u8 priorities[DPDMAI_PRIO_NUM]; +}; + +/** + * dpdmai_create() - Create the DPDMAI object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @cfg: Configuration structure + * @token: Returned token; use in subsequent API calls + * + * Create the DPDMAI object, allocate required resources and + * perform required initialization. + * + * The object can be created either by declaring it in the + * DPL file, or by calling this function. + * + * This function returns a unique authentication token, + * associated with the specific object ID and the specific MC + * portal; this token must be used in all subsequent calls to + * this specific object. For objects that are created using the + * DPL file, call dpdmai_open() function to get an authentication + * token first. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_create(struct fsl_mc_io *mc_io, + u32 cmd_flags, + const struct dpdmai_cfg *cfg, + u16 *token); + +/** + * dpdmai_destroy() - Destroy the DPDMAI object and release all its resources. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * + * Return: '0' on Success; error code otherwise. + */ +int dpdmai_destroy(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token); + +/** + * dpdmai_enable() - Enable the DPDMAI, allow sending and receiving frames. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_enable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token); + +/** + * dpdmai_disable() - Disable the DPDMAI, stop sending and receiving frames. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_disable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token); + +/** + * dpdmai_is_enabled() - Check if the DPDMAI is enabled. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @en: Returns '1' if object is enabled; '0' otherwise + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_is_enabled(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + int *en); + +/** + * dpdmai_reset() - Reset the DPDMAI, returns the object to initial state. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_reset(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token); + +/** + * struct dpdmai_irq_cfg - IRQ configuration + * @addr: Address that must be written to signal a message-based interrupt + * @val: Value to write into irq_addr address + * @irq_num: A user defined number associated with this IRQ + */ +struct dpdmai_irq_cfg { + u64 addr; + u32 val; + int irq_num; +}; + +/** + * dpdmai_set_irq() - Set IRQ information for the DPDMAI to trigger + * an interrupt. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: Identifies the interrupt index to configure + * @irq_cfg: IRQ configuration + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_set_irq(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + struct dpdmai_irq_cfg *irq_cfg); + +/** + * dpdmai_get_irq() - Get IRQ information from the DPDMAI + * + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @type: Interrupt type: 0 represents message interrupt + * type (both irq_addr and irq_val are valid) + * @irq_cfg: IRQ attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_irq(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + int *type, + struct dpdmai_irq_cfg *irq_cfg); + +/** + * dpdmai_set_irq_enable() - Set overall interrupt state. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @en: Interrupt state - enable = 1, disable = 0 + * + * Allows GPP software to control when interrupts are generated. + * Each interrupt can have up to 32 causes. The enable/disable control's the + * overall interrupt state. if the interrupt is disabled no causes will cause + * an interrupt + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_set_irq_enable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u8 en); + +/** + * dpdmai_get_irq_enable() - Get overall interrupt state + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @en: Returned Interrupt state - enable = 1, disable = 0 + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_irq_enable(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u8 *en); + +/** + * dpdmai_set_irq_mask() - Set interrupt mask. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @mask: event mask to trigger interrupt; + * each bit: + * 0 = ignore event + * 1 = consider event for asserting IRQ + * + * Every interrupt can have up to 32 causes and the interrupt model supports + * masking/unmasking each cause independently + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_set_irq_mask(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 mask); + +/** + * dpdmai_get_irq_mask() - Get interrupt mask. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @mask: Returned event mask to trigger interrupt + * + * Every interrupt can have up to 32 causes and the interrupt model supports + * masking/unmasking each cause independently + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_irq_mask(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 *mask); + +/** + * dpdmai_get_irq_status() - Get the current status of any pending interrupts + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @status: Returned interrupts status - one bit per cause: + * 0 = no interrupt pending + * 1 = interrupt pending + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_irq_status(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 *status); + +/** + * dpdmai_clear_irq_status() - Clear a pending interrupt's status + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @irq_index: The interrupt index to configure + * @status: bits to clear (W1C) - one bit per cause: + * 0 = don't change + * 1 = clear status bit + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_clear_irq_status(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 irq_index, + u32 status); + +/** + * struct dpdmai_attr - Structure representing DPDMAI attributes + * @id: DPDMAI object ID + * @version: DPDMAI version + * @num_of_priorities: number of priorities + */ +struct dpdmai_attr { + int id; + /** + * struct version - DPDMAI version + * @major: DPDMAI major version + * @minor: DPDMAI minor version + */ + struct { + u16 major; + u16 minor; + } version; + u8 num_of_priorities; +}; + +/** + * dpdmai_get_attributes() - Retrieve DPDMAI attributes. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @attr: Returned object's attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_attributes(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + struct dpdmai_attr *attr); + +/** + * enum dpdmai_dest - DPDMAI destination types + * @DPDMAI_DEST_NONE: Unassigned destination; The queue is set in parked mode + * and does not generate FQDAN notifications; user is expected to dequeue + * from the queue based on polling or other user-defined method + * @DPDMAI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN + * notifications to the specified DPIO; user is expected to dequeue + * from the queue only after notification is received + * @DPDMAI_DEST_DPCON: The queue is set in schedule mode and does not generate + * FQDAN notifications, but is connected to the specified DPCON object; + * user is expected to dequeue from the DPCON channel + */ +enum dpdmai_dest { + DPDMAI_DEST_NONE = 0, + DPDMAI_DEST_DPIO = 1, + DPDMAI_DEST_DPCON = 2 +}; + +/** + * struct dpdmai_dest_cfg - Structure representing DPDMAI destination parameters + * @dest_type: Destination type + * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type + * @priority: Priority selection within the DPIO or DPCON channel; valid values + * are 0-1 or 0-7, depending on the number of priorities in that + * channel; not relevant for 'DPDMAI_DEST_NONE' option + */ +struct dpdmai_dest_cfg { + enum dpdmai_dest dest_type; + int dest_id; + u8 priority; +}; + +/* DPDMAI queue modification options */ + +/** + * Select to modify the user's context associated with the queue + */ +#define DPDMAI_QUEUE_OPT_USER_CTX 0x00000001 + +/** + * Select to modify the queue's destination + */ +#define DPDMAI_QUEUE_OPT_DEST 0x00000002 + +/** + * struct dpdmai_rx_queue_cfg - DPDMAI RX queue configuration + * @options: Flags representing the suggested modifications to the queue; + * Use any combination of 'DPDMAI_QUEUE_OPT_' flags + * @user_ctx: User context value provided in the frame descriptor of each + * dequeued frame; + * valid only if 'DPDMAI_QUEUE_OPT_USER_CTX' is contained in 'options' + * @dest_cfg: Queue destination parameters; + * valid only if 'DPDMAI_QUEUE_OPT_DEST' is contained in 'options' + */ +struct dpdmai_rx_queue_cfg { + u32 options; + u64 user_ctx; + struct dpdmai_dest_cfg dest_cfg; + +}; + +/** + * dpdmai_set_rx_queue() - Set Rx queue configuration + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @priority: Select the queue relative to number of + * priorities configured at DPDMAI creation; use + * DPDMAI_ALL_QUEUES to configure all Rx queues + * identically. + * @cfg: Rx queue configuration + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_set_rx_queue(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 priority, + const struct dpdmai_rx_queue_cfg *cfg); + +/** + * struct dpdmai_rx_queue_attr - Structure representing attributes of Rx queues + * @user_ctx: User context value provided in the frame descriptor of each + * dequeued frame + * @dest_cfg: Queue destination configuration + * @fqid: Virtual FQID value to be used for dequeue operations + */ +struct dpdmai_rx_queue_attr { + u64 user_ctx; + struct dpdmai_dest_cfg dest_cfg; + u32 fqid; +}; + +/** + * dpdmai_get_rx_queue() - Retrieve Rx queue attributes. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @priority: Select the queue relative to number of + * priorities configured at DPDMAI creation + * @attr: Returned Rx queue attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_rx_queue(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 priority, + struct dpdmai_rx_queue_attr *attr); + +/** + * struct dpdmai_tx_queue_attr - Structure representing attributes of Tx queues + * @fqid: Virtual FQID to be used for sending frames to DMA hardware + */ + +struct dpdmai_tx_queue_attr { + u32 fqid; +}; + +/** + * dpdmai_get_tx_queue() - Retrieve Tx queue attributes. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPDMAI object + * @priority: Select the queue relative to number of + * priorities configured at DPDMAI creation + * @attr: Returned Tx queue attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dpdmai_get_tx_queue(struct fsl_mc_io *mc_io, + u32 cmd_flags, + u16 token, + u8 priority, + struct dpdmai_tx_queue_attr *attr); + +#endif /* __FSL_DPDMAI_H */ diff --git a/drivers/dma/fsl-dpaa2-qdma/dpdmai_cmd.h b/drivers/dma/fsl-dpaa2-qdma/dpdmai_cmd.h new file mode 100644 index 0000000..071a1a7 --- /dev/null +++ b/drivers/dma/fsl-dpaa2-qdma/dpdmai_cmd.h @@ -0,0 +1,197 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright 2014-2018 NXP */ + +#ifndef _FSL_DPDMAI_CMD_H +#define _FSL_DPDMAI_CMD_H + +/* DPDMAI Version */ +#define DPDMAI_VER_MAJOR 2 +#define DPDMAI_VER_MINOR 2 + +#define DPDMAI_CMD_BASE_VERSION 0 +#define DPDMAI_CMD_ID_OFFSET 4 + +#define DPDMAI_CMDID_FORMAT(x) (((x) << DPDMAI_CMD_ID_OFFSET) | \ + DPDMAI_CMD_BASE_VERSION) + +/* Command IDs */ +#define DPDMAI_CMDID_CLOSE DPDMAI_CMDID_FORMAT(0x800) +#define DPDMAI_CMDID_OPEN DPDMAI_CMDID_FORMAT(0x80E) +#define DPDMAI_CMDID_CREATE DPDMAI_CMDID_FORMAT(0x90E) +#define DPDMAI_CMDID_DESTROY DPDMAI_CMDID_FORMAT(0x900) + +#define DPDMAI_CMDID_ENABLE DPDMAI_CMDID_FORMAT(0x002) +#define DPDMAI_CMDID_DISABLE DPDMAI_CMDID_FORMAT(0x003) +#define DPDMAI_CMDID_GET_ATTR DPDMAI_CMDID_FORMAT(0x004) +#define DPDMAI_CMDID_RESET DPDMAI_CMDID_FORMAT(0x005) +#define DPDMAI_CMDID_IS_ENABLED DPDMAI_CMDID_FORMAT(0x006) + +#define DPDMAI_CMDID_SET_IRQ DPDMAI_CMDID_FORMAT(0x010) +#define DPDMAI_CMDID_GET_IRQ DPDMAI_CMDID_FORMAT(0x011) +#define DPDMAI_CMDID_SET_IRQ_ENABLE DPDMAI_CMDID_FORMAT(0x012) +#define DPDMAI_CMDID_GET_IRQ_ENABLE DPDMAI_CMDID_FORMAT(0x013) +#define DPDMAI_CMDID_SET_IRQ_MASK DPDMAI_CMDID_FORMAT(0x014) +#define DPDMAI_CMDID_GET_IRQ_MASK DPDMAI_CMDID_FORMAT(0x015) +#define DPDMAI_CMDID_GET_IRQ_STATUS DPDMAI_CMDID_FORMAT(0x016) +#define DPDMAI_CMDID_CLEAR_IRQ_STATUS DPDMAI_CMDID_FORMAT(0x017) + +#define DPDMAI_CMDID_SET_RX_QUEUE DPDMAI_CMDID_FORMAT(0x1A0) +#define DPDMAI_CMDID_GET_RX_QUEUE DPDMAI_CMDID_FORMAT(0x1A1) +#define DPDMAI_CMDID_GET_TX_QUEUE DPDMAI_CMDID_FORMAT(0x1A2) + +#define MC_CMD_HDR_TOKEN_O 32 /* Token field offset */ +#define MC_CMD_HDR_TOKEN_S 16 /* Token field size */ + +#define MAKE_UMASK64(_width) \ + ((u64)((_width) < 64 ? ((u64)1 << (_width)) - 1 : \ + (u64)-1)) \ + +static inline u64 mc_enc(int lsoffset, int width, u64 val) +{ + return (u64)(((u64)val & MAKE_UMASK64(width)) << lsoffset); +} + +static inline u64 mc_dec(u64 val, int lsoffset, int width) +{ + return (u64)((val >> lsoffset) & MAKE_UMASK64(width)); +} + +#define MC_CMD_OP(_cmd, _param, _offset, _width, _type, _arg) \ + ((_cmd).params[_param] |= mc_enc((_offset), (_width), _arg)) + +#define MC_RSP_OP(_cmd, _param, _offset, _width, _type, _arg) \ + (_arg = (_type)mc_dec(_cmd.params[_param], (_offset), (_width))) + +#define MC_CMD_HDR_READ_TOKEN(_hdr) \ + ((u16)mc_dec((_hdr), MC_CMD_HDR_TOKEN_O, MC_CMD_HDR_TOKEN_S)) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_OPEN(cmd, dpdmai_id) \ + MC_CMD_OP(cmd, 0, 0, 32, int, dpdmai_id) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_CREATE(cmd, cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 8, 8, u8, (cfg)->priorities[0]);\ + MC_CMD_OP(cmd, 0, 16, 8, u8, (cfg)->priorities[1]);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_IS_ENABLED(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 1, int, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_SET_IRQ(cmd, irq_index, irq_cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, u8, irq_index);\ + MC_CMD_OP(cmd, 0, 32, 32, u32, irq_cfg->val);\ + MC_CMD_OP(cmd, 1, 0, 64, u64, irq_cfg->addr);\ + MC_CMD_OP(cmd, 2, 0, 32, int, irq_cfg->irq_num); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_GET_IRQ(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_IRQ(cmd, type, irq_cfg) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, u32, irq_cfg->val); \ + MC_RSP_OP(cmd, 1, 0, 64, u64, irq_cfg->addr);\ + MC_RSP_OP(cmd, 2, 0, 32, int, irq_cfg->irq_num); \ + MC_RSP_OP(cmd, 2, 32, 32, int, type); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_SET_IRQ_ENABLE(cmd, irq_index, enable_state) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, u8, enable_state); \ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_GET_IRQ_ENABLE(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_IRQ_ENABLE(cmd, enable_state) \ + MC_RSP_OP(cmd, 0, 0, 8, u8, enable_state) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_SET_IRQ_MASK(cmd, irq_index, mask) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, u32, mask); \ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_GET_IRQ_MASK(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_IRQ_MASK(cmd, mask) \ + MC_RSP_OP(cmd, 0, 0, 32, u32, mask) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_GET_IRQ_STATUS(cmd, irq_index, status) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, u32, status);\ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_IRQ_STATUS(cmd, status) \ + MC_RSP_OP(cmd, 0, 0, 32, u32, status) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, u32, status); \ + MC_CMD_OP(cmd, 0, 32, 8, u8, irq_index); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_ATTR(cmd, attr) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, int, (attr)->id); \ + MC_RSP_OP(cmd, 0, 32, 8, u8, (attr)->num_of_priorities); \ + MC_RSP_OP(cmd, 1, 0, 16, u16, (attr)->version.major);\ + MC_RSP_OP(cmd, 1, 16, 16, u16, (attr)->version.minor);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_SET_RX_QUEUE(cmd, priority, cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, int, (cfg)->dest_cfg.dest_id); \ + MC_CMD_OP(cmd, 0, 32, 8, u8, (cfg)->dest_cfg.priority); \ + MC_CMD_OP(cmd, 0, 40, 8, u8, priority); \ + MC_CMD_OP(cmd, 0, 48, 4, enum dpdmai_dest, \ + (cfg)->dest_cfg.dest_type); \ + MC_CMD_OP(cmd, 1, 0, 64, u64, (cfg)->user_ctx); \ + MC_CMD_OP(cmd, 2, 0, 32, u32, (cfg)->options);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_GET_RX_QUEUE(cmd, priority) \ + MC_CMD_OP(cmd, 0, 40, 8, u8, priority) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_RX_QUEUE(cmd, attr) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, int, (attr)->dest_cfg.dest_id);\ + MC_RSP_OP(cmd, 0, 32, 8, u8, (attr)->dest_cfg.priority);\ + MC_RSP_OP(cmd, 0, 48, 4, enum dpdmai_dest, \ + (attr)->dest_cfg.dest_type);\ + MC_RSP_OP(cmd, 1, 0, 64, u64, (attr)->user_ctx);\ + MC_RSP_OP(cmd, 2, 0, 32, u32, (attr)->fqid);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_CMD_GET_TX_QUEUE(cmd, priority) \ + MC_CMD_OP(cmd, 0, 40, 8, u8, priority) + +/* cmd, param, offset, width, type, arg_name */ +#define DPDMAI_RSP_GET_TX_QUEUE(cmd, attr) \ + MC_RSP_OP(cmd, 1, 0, 32, u32, (attr)->fqid) + +#endif /* _FSL_DPDMAI_CMD_H */ -- 1.7.1