From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail26.static.mailgun.info ([104.130.122.26]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jWyqY-0008KR-RL for ath11k@lists.infradead.org; Fri, 08 May 2020 08:59:09 +0000 From: Govind Singh Subject: [PATCH 4/4] ath11k: Register mhi controller device for qca6390 Date: Fri, 8 May 2020 14:28:50 +0530 Message-Id: <20200508085850.23363-5-govinds@codeaurora.org> In-Reply-To: <20200508085850.23363-1-govinds@codeaurora.org> References: <20200508085850.23363-1-govinds@codeaurora.org> MIME-Version: 1.0 List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "ath11k" Errors-To: ath11k-bounces+kvalo=adurom.com@lists.infradead.org To: ath11k@lists.infradead.org Cc: Govind Singh , linux-wireless@vger.kernel.org TUhJIGlzIGEgY29tbXVuaWNhdGlvbiBwcm90b2NvbCB0byBjb21tdW5pY2F0ZSB3aXRoIGV4dGVy bmFsClF1YWxjb21tIG1vZGVtcyBhbmQgV2ktRmkgY2hpcHNldHMgb3ZlciBoaWdoIHNwZWVkIHBl cmlwaGVyYWwgYnVzZXMuIEV2ZW4KdGhvdWdoIE1ISSBkb2VzbuKAmXQgZGljdGF0ZSB1bmRlcmx5 aW5nIHBoeXNpY2FsIGxheWVyLCBwcm90b2NvbCBhbmQgbWhpIHN0YWNrCmlzIHN0cnVjdHVyZWQg Zm9yIFBDSWUgYmFzZWQgZGV2aWNlcy4KClJlZ2lzdGVyIGRpcmVjdGx5IHdpdGggbWhpIGNvcmUg bGF5ZXIgYXMgYSBtaGkgZGV2aWNlIGRyaXZlciBmb3IKZmlybXdhcmUgZG93bmxvYWQuCgpUZXN0 ZWQgUUNBNjM5MCBvbiBYODYgcGxhdGZvcm0uClRlc3RlZCBmaXJtd2FyZSBXTEFOLkhTVC4xLjAu MS5jMS0wMDQ0MC1RQ0FIU1RTV1BMWl9WMl9UT19YODYtMS4KClNpZ25lZC1vZmYtYnk6IEdvdmlu ZCBTaW5naCA8Z292aW5kc0Bjb2RlYXVyb3JhLm9yZz4KLS0tCiBkcml2ZXJzL25ldC93aXJlbGVz cy9hdGgvYXRoMTFrL0tjb25maWcgIHwgICA1ICstCiBkcml2ZXJzL25ldC93aXJlbGVzcy9hdGgv YXRoMTFrL01ha2VmaWxlIHwgICAyICstCiBkcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFr L21oaS5jICAgIHwgMzc5ICsrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL25ldC93aXJl bGVzcy9hdGgvYXRoMTFrL21oaS5oICAgIHwgIDI4ICsrCiBkcml2ZXJzL25ldC93aXJlbGVzcy9h dGgvYXRoMTFrL3BjaS5jICAgIHwgIDk3ICsrKysrKwogZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRo L2F0aDExay9wY2kuaCAgICB8ICAxMyArCiA2IGZpbGVzIGNoYW5nZWQsIDUyMCBpbnNlcnRpb25z KCspLCA0IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbmV0L3dpcmVs ZXNzL2F0aC9hdGgxMWsvbWhpLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL25ldC93aXJl bGVzcy9hdGgvYXRoMTFrL21oaS5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mv YXRoL2F0aDExay9LY29uZmlnIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDExay9LY29u ZmlnCmluZGV4IDMyMGIzYjE1MWJjZS4uYmQ0ODc5Njc0MmJiIDEwMDY0NAotLS0gYS9kcml2ZXJz L25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL0tjb25maWcKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxl c3MvYXRoL2F0aDExay9LY29uZmlnCkBAIC0yLDcgKzIsNiBAQAogY29uZmlnIEFUSDExSwogCXRy aXN0YXRlICJRdWFsY29tbSBUZWNobm9sb2dpZXMgODAyLjExYXggY2hpcHNldCBzdXBwb3J0Igog CWRlcGVuZHMgb24gTUFDODAyMTEgJiYgSEFTX0RNQQotCWRlcGVuZHMgb24gUkVNT1RFUFJPQwog CWRlcGVuZHMgb24gQ1JZUFRPX01JQ0hBRUxfTUlDCiAJZGVwZW5kcyBvbiBBUkNIX1FDT00gfHwg Q09NUElMRV9URVNUCiAJc2VsZWN0IEFUSF9DT01NT04KQEAgLTE1LDEzICsxNCwxMyBAQCBjb25m aWcgQVRIMTFLCiAKIGNvbmZpZyBBVEgxMUtfQUhCCiAJdHJpc3RhdGUgIlF1YWxjb21tIFRlY2hu b2xvZ2llcyA4MDIuMTFheCBjaGlwc2V0IEFIQiBzdXBwb3J0IgotCWRlcGVuZHMgb24gQVRIMTFL CisJZGVwZW5kcyBvbiBBVEgxMUsgJiYgUkVNT1RFUFJPQwogCS0tLWhlbHAtLS0KIAkgIFRoaXMg bW9kdWxlIGFkZHMgc3VwcG9ydCBmb3IgQUhCIGJ1cwogCiBjb25maWcgQVRIMTFLX1BDSQogCXRy aXN0YXRlICJRdWFsY29tbSBUZWNobm9sb2dpZXMgODAyLjExYXggY2hpcHNldCBQQ0kgc3VwcG9y dCIKLQlkZXBlbmRzIG9uIEFUSDExSyAmJiBQQ0kKKwlkZXBlbmRzIG9uIEFUSDExSyAmJiBQQ0kg JiYgTUhJX0JVUwogCS0tLWhlbHAtLS0KIAkgIFRoaXMgbW9kdWxlIGFkZHMgc3VwcG9ydCBmb3Ig UENJRSBidXMKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDExay9N YWtlZmlsZSBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMWsvTWFrZWZpbGUKaW5kZXgg OTMzZmNiMmZkNTVkLi44MzQzYzdkZmFhZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVs ZXNzL2F0aC9hdGgxMWsvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0 aDExay9NYWtlZmlsZQpAQCAtMjUsNyArMjUsNyBAQCBvYmotJChDT05GSUdfQVRIMTFLX0FIQikg Kz0gYXRoMTFrX2FoYi5vCiBhdGgxMWtfYWhiLXkgKz0gYWhiLm8KIAogb2JqLSQoQ09ORklHX0FU SDExS19QQ0kpICs9IGF0aDExa19wY2kubwotYXRoMTFrX3BjaS15ICs9IHBjaS5vCithdGgxMWtf cGNpLXkgKz0gbWhpLm8gcGNpLm8KIAogIyBmb3IgdHJhY2luZyBmcmFtZXdvcmsgdG8gZmluZCB0 cmFjZS5oCiBDRkxBR1NfdHJhY2UubyA6PSAtSSQoc3JjKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9u ZXQvd2lyZWxlc3MvYXRoL2F0aDExay9taGkuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9h dGgxMWsvbWhpLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xY2E0 MzI0M2UyNjUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRo MTFrL21oaS5jCkBAIC0wLDAgKzEsMzc5IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog QlNELTMtQ2xhdXNlLUNsZWFyCisvKiBDb3B5cmlnaHQgKGMpIDIwMjAgVGhlIExpbnV4IEZvdW5k YXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuICovCisKKyNpbmNsdWRlIDxsaW51eC9tc2kuaD4K KyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKworI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAi bWhpLmgiCisKKyNkZWZpbmUgTUhJX1RJTUVPVVRfREVGQVVMVF9NUwk5MDAwMAorCitzdGF0aWMg c3RydWN0IG1oaV9jaGFubmVsX2NvbmZpZyBhdGgxMWtfbWhpX2NoYW5uZWxzW10gPSB7CisJewor CQkubnVtID0gMCwKKwkJLm5hbWUgPSAiTE9PUEJBQ0siLAorCQkubnVtX2VsZW1lbnRzID0gMzIs CisJCS5ldmVudF9yaW5nID0gMCwKKwkJLmRpciA9IERNQV9UT19ERVZJQ0UsCisJCS5lZV9tYXNr ID0gMHg0LAorCQkucG9sbGNmZyA9IDAsCisJCS5kb29yYmVsbCA9IE1ISV9EQl9CUlNUX0RJU0FC TEUsCisJCS5scG1fbm90aWZ5ID0gZmFsc2UsCisJCS5vZmZsb2FkX2NoYW5uZWwgPSBmYWxzZSwK KwkJLmRvb3JiZWxsX21vZGVfc3dpdGNoID0gZmFsc2UsCisJCS5hdXRvX3F1ZXVlID0gZmFsc2Us CisJCS5hdXRvX3N0YXJ0ID0gZmFsc2UsCisJfSwKKwl7CisJCS5udW0gPSAxLAorCQkubmFtZSA9 ICJMT09QQkFDSyIsCisJCS5udW1fZWxlbWVudHMgPSAzMiwKKwkJLmV2ZW50X3JpbmcgPSAwLAor CQkuZGlyID0gRE1BX0ZST01fREVWSUNFLAorCQkuZWVfbWFzayA9IDB4NCwKKwkJLnBvbGxjZmcg PSAwLAorCQkuZG9vcmJlbGwgPSBNSElfREJfQlJTVF9ESVNBQkxFLAorCQkubHBtX25vdGlmeSA9 IGZhbHNlLAorCQkub2ZmbG9hZF9jaGFubmVsID0gZmFsc2UsCisJCS5kb29yYmVsbF9tb2RlX3N3 aXRjaCA9IGZhbHNlLAorCQkuYXV0b19xdWV1ZSA9IGZhbHNlLAorCQkuYXV0b19zdGFydCA9IGZh bHNlLAorCX0sCisJeworCQkubnVtID0gMjAsCisJCS5uYW1lID0gIklQQ1IiLAorCQkubnVtX2Vs ZW1lbnRzID0gNjQsCisJCS5ldmVudF9yaW5nID0gMSwKKwkJLmRpciA9IERNQV9UT19ERVZJQ0Us CisJCS5lZV9tYXNrID0gMHg0LAorCQkucG9sbGNmZyA9IDAsCisJCS5kb29yYmVsbCA9IE1ISV9E Ql9CUlNUX0RJU0FCTEUsCisJCS5scG1fbm90aWZ5ID0gZmFsc2UsCisJCS5vZmZsb2FkX2NoYW5u ZWwgPSBmYWxzZSwKKwkJLmRvb3JiZWxsX21vZGVfc3dpdGNoID0gZmFsc2UsCisJCS5hdXRvX3F1 ZXVlID0gZmFsc2UsCisJCS5hdXRvX3N0YXJ0ID0gdHJ1ZSwKKwl9LAorCXsKKwkJLm51bSA9IDIx LAorCQkubmFtZSA9ICJJUENSIiwKKwkJLm51bV9lbGVtZW50cyA9IDY0LAorCQkuZXZlbnRfcmlu ZyA9IDEsCisJCS5kaXIgPSBETUFfRlJPTV9ERVZJQ0UsCisJCS5lZV9tYXNrID0gMHg0LAorCQku cG9sbGNmZyA9IDAsCisJCS5kb29yYmVsbCA9IE1ISV9EQl9CUlNUX0RJU0FCTEUsCisJCS5scG1f bm90aWZ5ID0gZmFsc2UsCisJCS5vZmZsb2FkX2NoYW5uZWwgPSBmYWxzZSwKKwkJLmRvb3JiZWxs X21vZGVfc3dpdGNoID0gZmFsc2UsCisJCS5hdXRvX3F1ZXVlID0gdHJ1ZSwKKwkJLmF1dG9fc3Rh cnQgPSB0cnVlLAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IG1oaV9ldmVudF9jb25maWcgYXRo MTFrX21oaV9ldmVudHNbXSA9IHsKKwl7CisJCS5udW1fZWxlbWVudHMgPSAzMiwKKwkJLmlycV9t b2RlcmF0aW9uX21zID0gMCwKKwkJLmlycSA9IDEsCisJCS5tb2RlID0gTUhJX0RCX0JSU1RfRElT QUJMRSwKKwkJLmhhcmR3YXJlX2V2ZW50ID0gZmFsc2UsCisJCS5jbGllbnRfbWFuYWdlZCA9IGZh bHNlLAorCQkub2ZmbG9hZF9jaGFubmVsID0gZmFsc2UsCisJfSwKKwl7CisJCS5udW1fZWxlbWVu dHMgPSAyNTYsCisJCS5pcnFfbW9kZXJhdGlvbl9tcyA9IDEsCisJCS5pcnEgPSAyLAorCQkubW9k ZSA9IE1ISV9EQl9CUlNUX0RJU0FCTEUsCisJCS5wcmlvcml0eSA9IDEsCisJCS5oYXJkd2FyZV9l dmVudCA9IGZhbHNlLAorCQkuY2xpZW50X21hbmFnZWQgPSBmYWxzZSwKKwkJLm9mZmxvYWRfY2hh bm5lbCA9IGZhbHNlLAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IG1oaV9jb250cm9sbGVyX2Nv bmZpZyBhdGgxMWtfbWhpX2NvbmZpZyA9IHsKKwkubWF4X2NoYW5uZWxzID0gMTI4LAorCS50aW1l b3V0X21zID0gMjAwMCwKKwkudXNlX2JvdW5jZV9idWYgPSBmYWxzZSwKKwkuYnVmX2xlbiA9IDAs CisJLm51bV9jaGFubmVscyA9IEFSUkFZX1NJWkUoYXRoMTFrX21oaV9jaGFubmVscyksCisJLmNo X2NmZyA9IGF0aDExa19taGlfY2hhbm5lbHMsCisJLm51bV9ldmVudHMgPSBBUlJBWV9TSVpFKGF0 aDExa19taGlfZXZlbnRzKSwKKwkuZXZlbnRfY2ZnID0gYXRoMTFrX21oaV9ldmVudHMsCit9Owor CitzdGF0aWMgaW50IGF0aDExa19wY2lfZ2V0X21oaV9tc2koc3RydWN0IGF0aDExa19wY2kgKmFi X3BjaSkKK3sKKwlzdHJ1Y3QgYXRoMTFrX2Jhc2UgKmFiID0gYWJfcGNpLT5hYjsKKwl1MzIgdXNl cl9iYXNlX2RhdGEsIGJhc2VfdmVjdG9yOworCWludCByZXQsIG51bV92ZWN0b3JzLCBpOworCWlu dCAqaXJxOworCisJcmV0ID0gYXRoMTFrX3BjaV9nZXRfdXNlcl9tc2lfYXNzaWdubWVudChhYl9w Y2ksCisJCQkJCQkgIk1ISSIsICZudW1fdmVjdG9ycywKKwkJCQkJCSAmdXNlcl9iYXNlX2RhdGEs ICZiYXNlX3ZlY3Rvcik7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWF0aDExa19kYmco YWIsIEFUSDExS19EQkdfUENJLCAiTnVtYmVyIG9mIGFzc2lnbmVkIE1TSSBmb3IgTUhJIGlzICVk LCBiYXNlIHZlY3RvciBpcyAlZFxuIiwKKwkJICAgbnVtX3ZlY3RvcnMsIGJhc2VfdmVjdG9yKTsK KworCWlycSA9IGtjYWxsb2MobnVtX3ZlY3RvcnMsIHNpemVvZihpbnQpLCBHRlBfS0VSTkVMKTsK KwlpZiAoIWlycSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3Zl Y3RvcnM7IGkrKykKKwkJaXJxW2ldID0gYXRoMTFrX3BjaV9nZXRfbXNpX2lycShhYl9wY2ktPmRl diwKKwkJCQkJCWJhc2VfdmVjdG9yICsgaSk7CisKKwlhYl9wY2ktPm1oaV9jdHJsLT5pcnEgPSBp cnE7CisJYWJfcGNpLT5taGlfY3RybC0+bnJfaXJxcyA9IG51bV92ZWN0b3JzOworCisJcmV0dXJu IDA7Cit9CisKK2ludCBhdGgxMWtfcGNpX3JlZ2lzdGVyX21oaShzdHJ1Y3QgYXRoMTFrX3BjaSAq YWJfcGNpKQoreworCXN0cnVjdCBhdGgxMWtfYmFzZSAqYWIgPSBhYl9wY2ktPmFiOworCXN0cnVj dCBtaGlfY29udHJvbGxlciAqbWhpX2N0cmw7CisJaW50IHJldDsKKworCW1oaV9jdHJsID0ga3ph bGxvYyhzaXplb2YoKm1oaV9jdHJsKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFtaGlfY3RybCkKKwkJ cmV0dXJuIFBUUl9FUlIobWhpX2N0cmwpOworCisJYWJfcGNpLT5taGlfY3RybCA9IG1oaV9jdHJs OworCW1oaV9jdHJsLT5md19pbWFnZSA9IEFUSDExS19QQ0lfRldfRklMRV9OQU1FOworCW1oaV9j dHJsLT5yZWdzID0gYWJfcGNpLT5tZW07CisKKwlyZXQgPSBhdGgxMWtfcGNpX2dldF9taGlfbXNp KGFiX3BjaSk7CisJaWYgKHJldCkgeworCQlhdGgxMWtfZXJyKGFiLCAiZmFpbGVkIHRvIGdldCBt c2kgZm9yIG1oaVxuIik7CisJCWtmcmVlKG1oaV9jdHJsKTsKKwkJcmV0dXJuIHJldDsKKwl9CisK KwltaGlfY3RybC0+aW92YV9zdGFydCA9IDA7CisJbWhpX2N0cmwtPmlvdmFfc3RvcCA9IDB4ZmZm ZmZmZmY7CisJbWhpX2N0cmwtPnNibF9zaXplID0gU1pfNTEySzsKKwltaGlfY3RybC0+c2VnX2xl biA9IFNaXzUxMks7CisJbWhpX2N0cmwtPmZiY19kb3dubG9hZCA9IHRydWU7CisKKwlyZXQgPSBt aGlfcmVnaXN0ZXJfY29udHJvbGxlcihtaGlfY3RybCwgJmF0aDExa19taGlfY29uZmlnKTsKKwlp ZiAocmV0KSB7CisJCWF0aDExa19lcnIoYWIsICJmYWlsZWQgdG8gcmVnaXN0ZXIgdG8gbWhpIGJ1 cywgZXJyID0gJWRcbiIsIHJldCk7CisJCWtmcmVlKG1oaV9jdHJsKTsKKwkJcmV0dXJuIHJldDsK Kwl9CisKKwlyZXR1cm4gMDsKK30KKwordm9pZCBhdGgxMWtfcGNpX3VucmVnaXN0ZXJfbWhpKHN0 cnVjdCBhdGgxMWtfcGNpICphYl9wY2kpCit7CisJc3RydWN0IG1oaV9jb250cm9sbGVyICptaGlf Y3RybCA9IGFiX3BjaS0+bWhpX2N0cmw7CisKKwltaGlfdW5yZWdpc3Rlcl9jb250cm9sbGVyKG1o aV9jdHJsKTsKKwlrZnJlZShtaGlfY3RybC0+aXJxKTsKK30KKworc3RhdGljIGNoYXIgKmF0aDEx a19taGlfc3RhdGVfdG9fc3RyKGVudW0gYXRoMTFrX21oaV9zdGF0ZSBtaGlfc3RhdGUpCit7CisJ c3dpdGNoIChtaGlfc3RhdGUpIHsKKwljYXNlIEFUSDExS19NSElfSU5JVDoKKwkJcmV0dXJuICJJ TklUIjsKKwljYXNlIEFUSDExS19NSElfREVJTklUOgorCQlyZXR1cm4gIkRFSU5JVCI7CisJY2Fz ZSBBVEgxMUtfTUhJX1BPV0VSX09OOgorCQlyZXR1cm4gIlBPV0VSX09OIjsKKwljYXNlIEFUSDEx S19NSElfUE9XRVJfT0ZGOgorCQlyZXR1cm4gIlBPV0VSX09GRiI7CisJY2FzZSBBVEgxMUtfTUhJ X0ZPUkNFX1BPV0VSX09GRjoKKwkJcmV0dXJuICJGT1JDRV9QT1dFUl9PRkYiOworCWNhc2UgQVRI MTFLX01ISV9TVVNQRU5EOgorCQlyZXR1cm4gIlNVU1BFTkQiOworCWNhc2UgQVRIMTFLX01ISV9S RVNVTUU6CisJCXJldHVybiAiUkVTVU1FIjsKKwljYXNlIEFUSDExS19NSElfVFJJR0dFUl9SRERN OgorCQlyZXR1cm4gIlRSSUdHRVJfUkRETSI7CisJY2FzZSBBVEgxMUtfTUhJX1JERE1fRE9ORToK KwkJcmV0dXJuICJSRERNX0RPTkUiOworCWRlZmF1bHQ6CisJCXJldHVybiAiVU5LTk9XTiI7CisJ fQorfTsKKworc3RhdGljIHZvaWQgYXRoMTFrX3BjaV9zZXRfbWhpX3N0YXRlX2JpdChzdHJ1Y3Qg YXRoMTFrX3BjaSAqYWJfcGNpLAorCQkJCQkgZW51bSBhdGgxMWtfbWhpX3N0YXRlIG1oaV9zdGF0 ZSkKK3sKKwlzdHJ1Y3QgYXRoMTFrX2Jhc2UgKmFiID0gYWJfcGNpLT5hYjsKKworCXN3aXRjaCAo bWhpX3N0YXRlKSB7CisJY2FzZSBBVEgxMUtfTUhJX0lOSVQ6CisJCXNldF9iaXQoQVRIMTFLX01I SV9JTklULCAmYWJfcGNpLT5taGlfc3RhdGUpOworCQlicmVhazsKKwljYXNlIEFUSDExS19NSElf REVJTklUOgorCQljbGVhcl9iaXQoQVRIMTFLX01ISV9JTklULCAmYWJfcGNpLT5taGlfc3RhdGUp OworCQlicmVhazsKKwljYXNlIEFUSDExS19NSElfUE9XRVJfT046CisJCXNldF9iaXQoQVRIMTFL X01ISV9QT1dFUl9PTiwgJmFiX3BjaS0+bWhpX3N0YXRlKTsKKwkJYnJlYWs7CisJY2FzZSBBVEgx MUtfTUhJX1BPV0VSX09GRjoKKwljYXNlIEFUSDExS19NSElfRk9SQ0VfUE9XRVJfT0ZGOgorCQlj bGVhcl9iaXQoQVRIMTFLX01ISV9QT1dFUl9PTiwgJmFiX3BjaS0+bWhpX3N0YXRlKTsKKwkJY2xl YXJfYml0KEFUSDExS19NSElfVFJJR0dFUl9SRERNLCAmYWJfcGNpLT5taGlfc3RhdGUpOworCQlj bGVhcl9iaXQoQVRIMTFLX01ISV9SRERNX0RPTkUsICZhYl9wY2ktPm1oaV9zdGF0ZSk7CisJCWJy ZWFrOworCWNhc2UgQVRIMTFLX01ISV9TVVNQRU5EOgorCQlzZXRfYml0KEFUSDExS19NSElfU1VT UEVORCwgJmFiX3BjaS0+bWhpX3N0YXRlKTsKKwkJYnJlYWs7CisJY2FzZSBBVEgxMUtfTUhJX1JF U1VNRToKKwkJY2xlYXJfYml0KEFUSDExS19NSElfU1VTUEVORCwgJmFiX3BjaS0+bWhpX3N0YXRl KTsKKwkJYnJlYWs7CisJY2FzZSBBVEgxMUtfTUhJX1RSSUdHRVJfUkRETToKKwkJc2V0X2JpdChB VEgxMUtfTUhJX1RSSUdHRVJfUkRETSwgJmFiX3BjaS0+bWhpX3N0YXRlKTsKKwkJYnJlYWs7CisJ Y2FzZSBBVEgxMUtfTUhJX1JERE1fRE9ORToKKwkJc2V0X2JpdChBVEgxMUtfTUhJX1JERE1fRE9O RSwgJmFiX3BjaS0+bWhpX3N0YXRlKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYXRoMTFrX2Vy cihhYiwgInVuaGFuZGxlZCBtaGkgc3RhdGUgKCVkKVxuIiwgbWhpX3N0YXRlKTsKKwl9Cit9CisK K3N0YXRpYyBpbnQgYXRoMTFrX3BjaV9jaGVja19taGlfc3RhdGVfYml0KHN0cnVjdCBhdGgxMWtf cGNpICphYl9wY2ksCisJCQkJCSAgZW51bSBhdGgxMWtfbWhpX3N0YXRlIG1oaV9zdGF0ZSkKK3sK KwlzdHJ1Y3QgYXRoMTFrX2Jhc2UgKmFiID0gYWJfcGNpLT5hYjsKKworCXN3aXRjaCAobWhpX3N0 YXRlKSB7CisJY2FzZSBBVEgxMUtfTUhJX0lOSVQ6CisJCWlmICghdGVzdF9iaXQoQVRIMTFLX01I SV9JTklULCAmYWJfcGNpLT5taGlfc3RhdGUpKQorCQkJcmV0dXJuIDA7CisJCWJyZWFrOworCWNh c2UgQVRIMTFLX01ISV9ERUlOSVQ6CisJY2FzZSBBVEgxMUtfTUhJX1BPV0VSX09OOgorCQlpZiAo dGVzdF9iaXQoQVRIMTFLX01ISV9JTklULCAmYWJfcGNpLT5taGlfc3RhdGUpICYmCisJCSAgICAh dGVzdF9iaXQoQVRIMTFLX01ISV9QT1dFUl9PTiwgJmFiX3BjaS0+bWhpX3N0YXRlKSkKKwkJCXJl dHVybiAwOworCQlicmVhazsKKwljYXNlIEFUSDExS19NSElfRk9SQ0VfUE9XRVJfT0ZGOgorCQlp ZiAodGVzdF9iaXQoQVRIMTFLX01ISV9QT1dFUl9PTiwgJmFiX3BjaS0+bWhpX3N0YXRlKSkKKwkJ CXJldHVybiAwOworCQlicmVhazsKKwljYXNlIEFUSDExS19NSElfUE9XRVJfT0ZGOgorCWNhc2Ug QVRIMTFLX01ISV9TVVNQRU5EOgorCQlpZiAodGVzdF9iaXQoQVRIMTFLX01ISV9QT1dFUl9PTiwg JmFiX3BjaS0+bWhpX3N0YXRlKSAmJgorCQkgICAgIXRlc3RfYml0KEFUSDExS19NSElfU1VTUEVO RCwgJmFiX3BjaS0+bWhpX3N0YXRlKSkKKwkJCXJldHVybiAwOworCQlicmVhazsKKwljYXNlIEFU SDExS19NSElfUkVTVU1FOgorCQlpZiAodGVzdF9iaXQoQVRIMTFLX01ISV9TVVNQRU5ELCAmYWJf cGNpLT5taGlfc3RhdGUpKQorCQkJcmV0dXJuIDA7CisJCWJyZWFrOworCWNhc2UgQVRIMTFLX01I SV9UUklHR0VSX1JERE06CisJCWlmICh0ZXN0X2JpdChBVEgxMUtfTUhJX1BPV0VSX09OLCAmYWJf cGNpLT5taGlfc3RhdGUpICYmCisJCSAgICAhdGVzdF9iaXQoQVRIMTFLX01ISV9UUklHR0VSX1JE RE0sICZhYl9wY2ktPm1oaV9zdGF0ZSkpCisJCQlyZXR1cm4gMDsKKwkJYnJlYWs7CisJY2FzZSBB VEgxMUtfTUhJX1JERE1fRE9ORToKKwkJcmV0dXJuIDA7CisJZGVmYXVsdDoKKwkJYXRoMTFrX2Vy cihhYiwgInVuaGFuZGxlZCBtaGkgc3RhdGU6ICVzKCVkKVxuIiwKKwkJCSAgIGF0aDExa19taGlf c3RhdGVfdG9fc3RyKG1oaV9zdGF0ZSksIG1oaV9zdGF0ZSk7CisJfQorCisJYXRoMTFrX2Vycihh YiwgImZhaWxlZCB0byBzZXQgbWhpIHN0YXRlICVzKCVkKSBpbiBjdXJyZW50IG1oaSBzdGF0ZSAo MHglbHgpXG4iLAorCQkgICBhdGgxMWtfbWhpX3N0YXRlX3RvX3N0cihtaGlfc3RhdGUpLCBtaGlf c3RhdGUsCisJCSAgIGFiX3BjaS0+bWhpX3N0YXRlKTsKKworCXJldHVybiAtRUlOVkFMOworfQor CitzdGF0aWMgaW50IGF0aDExa19wY2lfc2V0X21oaV9zdGF0ZShzdHJ1Y3QgYXRoMTFrX3BjaSAq YWJfcGNpLAorCQkJCSAgICBlbnVtIGF0aDExa19taGlfc3RhdGUgbWhpX3N0YXRlKQoreworCXN0 cnVjdCBhdGgxMWtfYmFzZSAqYWIgPSBhYl9wY2ktPmFiOworCWludCByZXQ7CisKKwlyZXQgPSBh dGgxMWtfcGNpX2NoZWNrX21oaV9zdGF0ZV9iaXQoYWJfcGNpLCBtaGlfc3RhdGUpOworCWlmIChy ZXQpCisJCWdvdG8gb3V0OworCisJYXRoMTFrX2RiZyhhYiwgQVRIMTFLX0RCR19QQ0ksICJzZXR0 aW5nIG1oaSBzdGF0ZTogJXMoJWQpXG4iLAorCQkgICBhdGgxMWtfbWhpX3N0YXRlX3RvX3N0ciht aGlfc3RhdGUpLCBtaGlfc3RhdGUpOworCisJc3dpdGNoIChtaGlfc3RhdGUpIHsKKwljYXNlIEFU SDExS19NSElfSU5JVDoKKwkJcmV0ID0gbWhpX3ByZXBhcmVfZm9yX3Bvd2VyX3VwKGFiX3BjaS0+ bWhpX2N0cmwpOworCQlicmVhazsKKwljYXNlIEFUSDExS19NSElfREVJTklUOgorCQltaGlfdW5w cmVwYXJlX2FmdGVyX3Bvd2VyX2Rvd24oYWJfcGNpLT5taGlfY3RybCk7CisJCXJldCA9IDA7CisJ CWJyZWFrOworCWNhc2UgQVRIMTFLX01ISV9QT1dFUl9PTjoKKwkJcmV0ID0gbWhpX2FzeW5jX3Bv d2VyX3VwKGFiX3BjaS0+bWhpX2N0cmwpOworCQlicmVhazsKKwljYXNlIEFUSDExS19NSElfUE9X RVJfT0ZGOgorCQltaGlfcG93ZXJfZG93bihhYl9wY2ktPm1oaV9jdHJsLCB0cnVlKTsKKwkJcmV0 ID0gMDsKKwkJYnJlYWs7CisJY2FzZSBBVEgxMUtfTUhJX0ZPUkNFX1BPV0VSX09GRjoKKwkJbWhp X3Bvd2VyX2Rvd24oYWJfcGNpLT5taGlfY3RybCwgZmFsc2UpOworCQlyZXQgPSAwOworCQlicmVh azsKKwljYXNlIEFUSDExS19NSElfU1VTUEVORDoKKwkJYnJlYWs7CisJY2FzZSBBVEgxMUtfTUhJ X1JFU1VNRToKKwkJYnJlYWs7CisJY2FzZSBBVEgxMUtfTUhJX1RSSUdHRVJfUkRETToKKwkJcmV0 ID0gbWhpX2ZvcmNlX3JkZG1fbW9kZShhYl9wY2ktPm1oaV9jdHJsKTsKKwkJYnJlYWs7CisJY2Fz ZSBBVEgxMUtfTUhJX1JERE1fRE9ORToKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYXRoMTFrX2Vy cihhYiwgInVuaGFuZGxlZCBNSEkgc3RhdGUgKCVkKVxuIiwgbWhpX3N0YXRlKTsKKwkJcmV0ID0g LUVJTlZBTDsKKwl9CisKKwlpZiAocmV0KQorCQlnb3RvIG91dDsKKworCWF0aDExa19wY2lfc2V0 X21oaV9zdGF0ZV9iaXQoYWJfcGNpLCBtaGlfc3RhdGUpOworCisJcmV0dXJuIDA7CisKK291dDoK KwlhdGgxMWtfZXJyKGFiLCAiZmFpbGVkIHRvIHNldCBtaGkgc3RhdGU6ICVzKCVkKVxuIiwKKwkJ ICAgYXRoMTFrX21oaV9zdGF0ZV90b19zdHIobWhpX3N0YXRlKSwgbWhpX3N0YXRlKTsKKwlyZXR1 cm4gcmV0OworfQorCitpbnQgYXRoMTFrX3BjaV9zdGFydF9taGkoc3RydWN0IGF0aDExa19wY2kg KmFiX3BjaSkKK3sKKwlzdHJ1Y3QgYXRoMTFrX2Jhc2UgKmFiID0gYWJfcGNpLT5hYjsKKwlpbnQg cmV0OworCisJYWJfcGNpLT5taGlfY3RybC0+dGltZW91dF9tcyA9IE1ISV9USU1FT1VUX0RFRkFV TFRfTVM7CisKKwlyZXQgPSBhdGgxMWtfcGNpX3NldF9taGlfc3RhdGUoYWJfcGNpLCBBVEgxMUtf TUhJX0lOSVQpOworCWlmIChyZXQpCisJCWF0aDExa19lcnIoYWIsICJmYWlsZWQgdG8gc2V0IG1o aSBpbml0IHN0YXRlOiAlZFxuIiwgcmV0KTsKKworCXJldCA9IGF0aDExa19wY2lfc2V0X21oaV9z dGF0ZShhYl9wY2ksIEFUSDExS19NSElfUE9XRVJfT04pOworCWlmIChyZXQpCisJCWF0aDExa19l cnIoYWIsICJmYWlsZWQgdG8gc2V0IG1oaSBwb3dlciBvbiBzdGF0ZTogJWRcbiIsIHJldCk7CisK KwlyZXR1cm4gcmV0OworfQorCit2b2lkIGF0aDExa19wY2lfc3RvcF9taGkoc3RydWN0IGF0aDEx a19wY2kgKmFiX3BjaSkKK3sKKwlhdGgxMWtfcGNpX3NldF9taGlfc3RhdGUoYWJfcGNpLCBBVEgx MUtfTUhJX1JFU1VNRSk7CisJYXRoMTFrX3BjaV9zZXRfbWhpX3N0YXRlKGFiX3BjaSwgQVRIMTFL X01ISV9QT1dFUl9PRkYpOworCWF0aDExa19wY2lfc2V0X21oaV9zdGF0ZShhYl9wY2ksIEFUSDEx S19NSElfREVJTklUKTsKK30KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRo L2F0aDExay9taGkuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGgxMWsvbWhpLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zNTVkZTVhMmMyNDEKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL21oaS5oCkBAIC0w LDAgKzEsMjggQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBCU0QtMy1DbGF1c2UtQ2xl YXIgKi8KKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMjAgVGhlIExpbnV4IEZvdW5kYXRpb24uIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKi8KKyNpZm5kZWYgX0FUSDExS19NSElfSAorI2RlZmluZSBf QVRIMTFLX01ISV9ICisKKyNpbmNsdWRlICJwY2kuaCIKKyNkZWZpbmUgQVRIMTFLX1BDSV9GV19G SUxFX05BTUUJCSJhbXNzLmJpbiIKKworZW51bSBhdGgxMWtfbWhpX3N0YXRlIHsKKwlBVEgxMUtf TUhJX0lOSVQsCisJQVRIMTFLX01ISV9ERUlOSVQsCisJQVRIMTFLX01ISV9QT1dFUl9PTiwKKwlB VEgxMUtfTUhJX1BPV0VSX09GRiwKKwlBVEgxMUtfTUhJX0ZPUkNFX1BPV0VSX09GRiwKKwlBVEgx MUtfTUhJX1NVU1BFTkQsCisJQVRIMTFLX01ISV9SRVNVTUUsCisJQVRIMTFLX01ISV9UUklHR0VS X1JERE0sCisJQVRIMTFLX01ISV9SRERNLAorCUFUSDExS19NSElfUkRETV9ET05FLAorfTsKKwor aW50IGF0aDExa19wY2lfc3RhcnRfbWhpKHN0cnVjdCBhdGgxMWtfcGNpICphcl9wY2kpOwordm9p ZCBhdGgxMWtfcGNpX3N0b3BfbWhpKHN0cnVjdCBhdGgxMWtfcGNpICphcl9wY2kpOworaW50IGF0 aDExa19wY2lfcmVnaXN0ZXJfbWhpKHN0cnVjdCBhdGgxMWtfcGNpICphcl9wY2kpOwordm9pZCBh dGgxMWtfcGNpX3VucmVnaXN0ZXJfbWhpKHN0cnVjdCBhdGgxMWtfcGNpICphcl9wY2kpOworI2Vu ZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL3BjaS5jIGIv ZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDExay9wY2kuYwppbmRleCBkODlkY2I1ZmU4MWUu LjkzODA3OGVlOGQ4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDEx ay9wY2kuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL3BjaS5jCkBAIC05 LDYgKzksOCBAQAogCiAjaW5jbHVkZSAiYWhiLmgiCiAjaW5jbHVkZSAiY29yZS5oIgorI2luY2x1 ZGUgImhpZi5oIgorI2luY2x1ZGUgIm1oaS5oIgogI2luY2x1ZGUgInBjaS5oIgogI2luY2x1ZGUg ImRlYnVnLmgiCiAKQEAgLTMxLDYgKzMzLDYwIEBAIHN0YXRpYyBzdHJ1Y3QgYXRoMTFrX21zaV9j b25maWcgbXNpX2NvbmZpZyA9IHsKIAl9LAogfTsKIAoraW50IGF0aDExa19wY2lfZ2V0X21zaV9p cnEoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgdmVjdG9yKQoreworCXN0cnVjdCBw Y2lfZGV2ICpwY2lfZGV2ID0gdG9fcGNpX2RldihkZXYpOworCWludCBpcnFfbnVtOworCisJaXJx X251bSA9IHBjaV9pcnFfdmVjdG9yKHBjaV9kZXYsIHZlY3Rvcik7CisKKwlyZXR1cm4gaXJxX251 bTsKK30KKworaW50IGF0aDExa19wY2lfZ2V0X3VzZXJfbXNpX2Fzc2lnbm1lbnQoc3RydWN0IGF0 aDExa19wY2kgKmFiX3BjaSwgY2hhciAqdXNlcl9uYW1lLAorCQkJCSAgICAgICBpbnQgKm51bV92 ZWN0b3JzLCB1MzIgKnVzZXJfYmFzZV9kYXRhLAorCQkJCSAgICAgICB1MzIgKmJhc2VfdmVjdG9y KQoreworCXN0cnVjdCBhdGgxMWtfYmFzZSAqYWIgPSBhYl9wY2ktPmFiOworCXN0cnVjdCBhdGgx MWtfbXNpX2NvbmZpZyAqbXNpX2NvbmZpZzsKKwlpbnQgaWR4OworCisJbXNpX2NvbmZpZyA9IGFi X3BjaS0+bXNpX2NvbmZpZzsKKwlpZiAoIW1zaV9jb25maWcpIHsKKwkJYXRoMTFrX2VycihhYiwg Ik1TSSBpcyBub3Qgc3VwcG9ydGVkLlxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWZv ciAoaWR4ID0gMDsgaWR4IDwgbXNpX2NvbmZpZy0+dG90YWxfdXNlcnM7IGlkeCsrKSB7CisJCWlm IChzdHJjbXAodXNlcl9uYW1lLCBtc2lfY29uZmlnLT51c2Vyc1tpZHhdLm5hbWUpID09IDApIHsK KwkJCSpudW1fdmVjdG9ycyA9IG1zaV9jb25maWctPnVzZXJzW2lkeF0ubnVtX3ZlY3RvcnM7CisJ CQkqdXNlcl9iYXNlX2RhdGEgPSBtc2lfY29uZmlnLT51c2Vyc1tpZHhdLmJhc2VfdmVjdG9yCisJ CQkJKyBhYl9wY2ktPm1zaV9lcF9iYXNlX2RhdGE7CisJCQkqYmFzZV92ZWN0b3IgPSBtc2lfY29u ZmlnLT51c2Vyc1tpZHhdLmJhc2VfdmVjdG9yOworCisJCQlhdGgxMWtfZGJnKGFiLCBBVEgxMUtf REJHX1BDSSwgIkFzc2lnbiBNU0kgdG8gdXNlcjogJXMsIG51bV92ZWN0b3JzOiAlZCwgdXNlcl9i YXNlX2RhdGE6ICV1LCBiYXNlX3ZlY3RvcjogJXVcbiIsCisJCQkJICAgdXNlcl9uYW1lLCAqbnVt X3ZlY3RvcnMsICp1c2VyX2Jhc2VfZGF0YSwKKwkJCQkgICAqYmFzZV92ZWN0b3IpOworCisJCQly ZXR1cm4gMDsKKwkJfQorCX0KKworCWF0aDExa19lcnIoYWIsICJGYWlsZWQgdG8gZmluZCBNU0kg YXNzaWdubWVudCBmb3IgJXMhXG4iLCB1c2VyX25hbWUpOworCisJcmV0dXJuIC1FSU5WQUw7Cit9 CisKK3N0YXRpYyBpbnQgYXRoMTFrX3BjaV9xY2E2eDkwX3Bvd2VydXAoc3RydWN0IGF0aDExa19w Y2kgKmFiX3BjaSkKK3sKKwlyZXR1cm4gYXRoMTFrX3BjaV9zdGFydF9taGkoYWJfcGNpKTsKK30K Kworc3RhdGljIHZvaWQgYXRoMTFrX3BjaV9xY2E2eDkwX3Bvd2VyZG93bihzdHJ1Y3QgYXRoMTFr X3BjaSAqYWJfcGNpKQoreworCWF0aDExa19wY2lfc3RvcF9taGkoYWJfcGNpKTsKK30KKwogc3Rh dGljIGludCBhdGgxMWtfcGNpX2dldF9tc2lfYXNzaWdubWVudChzdHJ1Y3QgYXRoMTFrX3BjaSAq YWJfcGNpKQogewogCWFiX3BjaS0+bXNpX2NvbmZpZyA9ICZtc2lfY29uZmlnOwpAQCAtMTg0LDYg KzI0MCwzNCBAQCBzdGF0aWMgdm9pZCBhdGgxMWtfcGNpX2ZyZWVfcmVnaW9uKHN0cnVjdCBhdGgx MWtfcGNpICphYl9wY2kpCiAJCXBjaV9kaXNhYmxlX2RldmljZShwY2lfZGV2KTsKIH0KIAorc3Rh dGljIGludCBhdGgxMWtfcGNpX3Bvd2VyX3VwKHN0cnVjdCBhdGgxMWtfYmFzZSAqYWIpCit7CisJ c3RydWN0IGF0aDExa19wY2kgKmFiX3BjaTsKKwlpbnQgcmV0OworCisJYWJfcGNpID0gYXRoMTFr X3BjaV9wcml2KGFiKTsKKwlyZXQgPSBhdGgxMWtfcGNpX3FjYTZ4OTBfcG93ZXJ1cChhYl9wY2kp OworCWlmIChyZXQpIHsKKwkJYXRoMTFrX2VycihhYiwgImZhaWxlZCB0byBwb3dlciBvbiAgbWhp OiAlZFxuIiwgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3Rh dGljIHZvaWQgYXRoMTFrX3BjaV9wb3dlcl9kb3duKHN0cnVjdCBhdGgxMWtfYmFzZSAqYWIpCit7 CisJc3RydWN0IGF0aDExa19wY2kgKmFiX3BjaTsKKworCWFiX3BjaSA9IGF0aDExa19wY2lfcHJp dihhYik7CisJYXRoMTFrX3BjaV9xY2E2eDkwX3Bvd2VyZG93bihhYl9wY2kpOworfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGF0aDExa19oaWZfb3BzIGF0aDExa19wY2lfaGlmX29wcyA9IHsKKwku cG93ZXJfZG93biA9IGF0aDExa19wY2lfcG93ZXJfZG93biwKKwkucG93ZXJfdXAgPSBhdGgxMWtf cGNpX3Bvd2VyX3VwLAorfTsKKwogc3RhdGljIGludCBhdGgxMWtfcGNpX3Byb2JlKHN0cnVjdCBw Y2lfZGV2ICpwZGV2LAogCQkJICAgIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICpwY2lfZGV2 KQogewpAQCAtMjI5LDE0ICszMTMsMjYgQEAgc3RhdGljIGludCBhdGgxMWtfcGNpX3Byb2JlKHN0 cnVjdCBwY2lfZGV2ICpwZGV2LAogCQlnb3RvIGVycl9mcmVlX2NvcmU7CiAJfQogCisJYWItPm1l bSA9IGFiX3BjaS0+bWVtOworCWFiLT5tZW1fbGVuID0gYWJfcGNpLT5tZW1fbGVuOworCiAJcmV0 ID0gYXRoMTFrX3BjaV9lbmFibGVfbXNpKGFiX3BjaSk7CiAJaWYgKHJldCkgewogCQlhdGgxMWtf ZXJyKGFiLCAiZmFpbGVkIHRvIGVuYWJsZSAgbXNpOiAlZFxuIiwgcmV0KTsKIAkJZ290byBlcnJf cGNpX2ZyZWVfcmVnaW9uOwogCX0KIAorCXJldCA9IGF0aDExa19wY2lfcmVnaXN0ZXJfbWhpKGFi X3BjaSk7CisJaWYgKHJldCkgeworCQlhdGgxMWtfZXJyKGFiLCAiZmFpbGVkIHRvIHJlZ2lzdGVy ICBtaGk6ICVkXG4iLCByZXQpOworCQlnb3RvIGVycl9wY2lfZGlzYWJsZV9tc2k7CisJfQorCiAJ cmV0dXJuIDA7CiAKK2Vycl9wY2lfZGlzYWJsZV9tc2k6CisJYXRoMTFrX3BjaV9kaXNhYmxlX21z aShhYl9wY2kpOworCiBlcnJfcGNpX2ZyZWVfcmVnaW9uOgogCWF0aDExa19wY2lfZnJlZV9yZWdp b24oYWJfcGNpKTsKIApAQCAtMjUyLDYgKzM0OCw3IEBAIHN0YXRpYyB2b2lkIGF0aDExa19wY2lf cmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQogCXN0cnVjdCBhdGgxMWtfcGNpICphYl9wY2kg PSBhdGgxMWtfcGNpX3ByaXYoYWIpOwogCiAJc2V0X2JpdChBVEgxMUtfRkxBR19VTlJFR0lTVEVS SU5HLCAmYWItPmRldl9mbGFncyk7CisJYXRoMTFrX3BjaV91bnJlZ2lzdGVyX21oaShhYl9wY2kp OwogCWF0aDExa19wY2lfZGlzYWJsZV9tc2koYWJfcGNpKTsKIAlhdGgxMWtfcGNpX2ZyZWVfcmVn aW9uKGFiX3BjaSk7CiAJYXRoMTFrX2NvcmVfZnJlZShhYik7CmRpZmYgLS1naXQgYS9kcml2ZXJz L25ldC93aXJlbGVzcy9hdGgvYXRoMTFrL3BjaS5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRo L2F0aDExay9wY2kuaAppbmRleCA3YzdmYTE5NjVhYTYuLjgzYjQ4NWJlNmM1MCAxMDA2NDQKLS0t IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDExay9wY2kuaAorKysgYi9kcml2ZXJzL25l dC93aXJlbGVzcy9hdGgvYXRoMTFrL3BjaS5oCkBAIC0yLDYgKzIsMTAgQEAKIC8qCiAgKiBDb3B5 cmlnaHQgKGMpIDIwMTktMjAyMCBUaGUgTGludXggRm91bmRhdGlvbi4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KICAqLworI2lmbmRlZiBfQVRIMTFLX1BDSV9ICisjZGVmaW5lIF9BVEgxMUtfUENJX0gK KworI2luY2x1ZGUgPGxpbnV4L21oaS5oPgogCiAjZGVmaW5lIFFDQTYyOTBfVkVORE9SX0lECQkw eDE3Q0IKICNkZWZpbmUgUUNBNjI5MF9ERVZJQ0VfSUQJCTB4MTEwMApAQCAtMzMsNCArMzcsMTMg QEAgc3RydWN0IGF0aDExa19wY2kgewogCXUzMiBjaGlwX2lkOwogCXN0cnVjdCBhdGgxMWtfbXNp X2NvbmZpZyAqbXNpX2NvbmZpZzsKIAl1MzIgbXNpX2VwX2Jhc2VfZGF0YTsKKwlzdHJ1Y3QgbWhp X2NvbnRyb2xsZXIgKm1oaV9jdHJsOworCXVuc2lnbmVkIGxvbmcgbWhpX3N0YXRlOwogfTsKKwor aW50IGF0aDExa19wY2lfZ2V0X3VzZXJfbXNpX2Fzc2lnbm1lbnQoc3RydWN0IGF0aDExa19wY2kg KmFyX3BjaSwgY2hhciAqdXNlcl9uYW1lLAorCQkJCSAgICAgICBpbnQgKm51bV92ZWN0b3JzLCB1 MzIgKnVzZXJfYmFzZV9kYXRhLAorCQkJCSAgICAgICB1MzIgKmJhc2VfdmVjdG9yKTsKKworaW50 IGF0aDExa19wY2lfZ2V0X21zaV9pcnEoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQg dmVjdG9yKTsKKyNlbmRpZgotLSAKMi4yMi4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwphdGgxMWsgbWFpbGluZyBsaXN0CmF0aDExa0BsaXN0cy5pbmZy YWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vYXRo MTFrCg== 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.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 30763C38A2A for ; Fri, 8 May 2020 08:59:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id F40D0208D6 for ; Fri, 8 May 2020 08:59:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="oZkQeEzq" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726325AbgEHI7H (ORCPT ); Fri, 8 May 2020 04:59:07 -0400 Received: from mail27.static.mailgun.info ([104.130.122.27]:42235 "EHLO mail27.static.mailgun.info" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725815AbgEHI7G (ORCPT ); Fri, 8 May 2020 04:59:06 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1588928345; h=Content-Transfer-Encoding: Content-Type: MIME-Version: References: In-Reply-To: Message-Id: Date: Subject: Cc: To: From: Sender; bh=sIgGgnZXhNnAAr8Mjqcxp18lvWdeKu3HGg4JCh593eI=; b=oZkQeEzqpl3iSv2FCD4DzpyYLeTb5JtZDWLTCkfL3Hz9hWMv1WD/QB/UGyHCbNGZ+IGmkoiX raGfdP/JItrk8ReuDK7RoyheKNSS5mhPEL/rifVav+XuLHDTgCZAWvcvTlqnjmZEVTPHJqd1 hgw148BKIlInJ+7LpOX1lctgKnA= X-Mailgun-Sending-Ip: 104.130.122.27 X-Mailgun-Sid: WyI3YTAwOSIsICJsaW51eC13aXJlbGVzc0B2Z2VyLmtlcm5lbC5vcmciLCAiYmU5ZTRhIl0= Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by mxa.mailgun.org with ESMTP id 5eb51f59.7f721a613f80-smtp-out-n03; Fri, 08 May 2020 08:59:05 -0000 (UTC) Received: by smtp.codeaurora.org (Postfix, from userid 1001) id 4B8C2C433F2; Fri, 8 May 2020 08:59:04 +0000 (UTC) Received: from govinds-linux.qualcomm.com (blr-c-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.19.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: govinds) by smtp.codeaurora.org (Postfix) with ESMTPSA id C6832C44793; Fri, 8 May 2020 08:59:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org C6832C44793 Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=govinds@codeaurora.org From: Govind Singh To: ath11k@lists.infradead.org Cc: linux-wireless@vger.kernel.org, Govind Singh Subject: [PATCH 4/4] ath11k: Register mhi controller device for qca6390 Date: Fri, 8 May 2020 14:28:50 +0530 Message-Id: <20200508085850.23363-5-govinds@codeaurora.org> X-Mailer: git-send-email 2.22.0 In-Reply-To: <20200508085850.23363-1-govinds@codeaurora.org> References: <20200508085850.23363-1-govinds@codeaurora.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-wireless-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org MHI is a communication protocol to communicate with external Qualcomm modems and Wi-Fi chipsets over high speed peripheral buses. Even though MHI doesn’t dictate underlying physical layer, protocol and mhi stack is structured for PCIe based devices. Register directly with mhi core layer as a mhi device driver for firmware download. Tested QCA6390 on X86 platform. Tested firmware WLAN.HST.1.0.1.c1-00440-QCAHSTSWPLZ_V2_TO_X86-1. Signed-off-by: Govind Singh --- drivers/net/wireless/ath/ath11k/Kconfig | 5 +- drivers/net/wireless/ath/ath11k/Makefile | 2 +- drivers/net/wireless/ath/ath11k/mhi.c | 379 +++++++++++++++++++++++ drivers/net/wireless/ath/ath11k/mhi.h | 28 ++ drivers/net/wireless/ath/ath11k/pci.c | 97 ++++++ drivers/net/wireless/ath/ath11k/pci.h | 13 + 6 files changed, 520 insertions(+), 4 deletions(-) create mode 100644 drivers/net/wireless/ath/ath11k/mhi.c create mode 100644 drivers/net/wireless/ath/ath11k/mhi.h diff --git a/drivers/net/wireless/ath/ath11k/Kconfig b/drivers/net/wireless/ath/ath11k/Kconfig index 320b3b151bce..bd48796742bb 100644 --- a/drivers/net/wireless/ath/ath11k/Kconfig +++ b/drivers/net/wireless/ath/ath11k/Kconfig @@ -2,7 +2,6 @@ config ATH11K tristate "Qualcomm Technologies 802.11ax chipset support" depends on MAC80211 && HAS_DMA - depends on REMOTEPROC depends on CRYPTO_MICHAEL_MIC depends on ARCH_QCOM || COMPILE_TEST select ATH_COMMON @@ -15,13 +14,13 @@ config ATH11K config ATH11K_AHB tristate "Qualcomm Technologies 802.11ax chipset AHB support" - depends on ATH11K + depends on ATH11K && REMOTEPROC ---help--- This module adds support for AHB bus config ATH11K_PCI tristate "Qualcomm Technologies 802.11ax chipset PCI support" - depends on ATH11K && PCI + depends on ATH11K && PCI && MHI_BUS ---help--- This module adds support for PCIE bus diff --git a/drivers/net/wireless/ath/ath11k/Makefile b/drivers/net/wireless/ath/ath11k/Makefile index 933fcb2fd55d..8343c7dfaae3 100644 --- a/drivers/net/wireless/ath/ath11k/Makefile +++ b/drivers/net/wireless/ath/ath11k/Makefile @@ -25,7 +25,7 @@ obj-$(CONFIG_ATH11K_AHB) += ath11k_ahb.o ath11k_ahb-y += ahb.o obj-$(CONFIG_ATH11K_PCI) += ath11k_pci.o -ath11k_pci-y += pci.o +ath11k_pci-y += mhi.o pci.o # for tracing framework to find trace.h CFLAGS_trace.o := -I$(src) diff --git a/drivers/net/wireless/ath/ath11k/mhi.c b/drivers/net/wireless/ath/ath11k/mhi.c new file mode 100644 index 000000000000..1ca43243e265 --- /dev/null +++ b/drivers/net/wireless/ath/ath11k/mhi.c @@ -0,0 +1,379 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* Copyright (c) 2020 The Linux Foundation. All rights reserved. */ + +#include +#include + +#include "debug.h" +#include "mhi.h" + +#define MHI_TIMEOUT_DEFAULT_MS 90000 + +static struct mhi_channel_config ath11k_mhi_channels[] = { + { + .num = 0, + .name = "LOOPBACK", + .num_elements = 32, + .event_ring = 0, + .dir = DMA_TO_DEVICE, + .ee_mask = 0x4, + .pollcfg = 0, + .doorbell = MHI_DB_BRST_DISABLE, + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + .auto_start = false, + }, + { + .num = 1, + .name = "LOOPBACK", + .num_elements = 32, + .event_ring = 0, + .dir = DMA_FROM_DEVICE, + .ee_mask = 0x4, + .pollcfg = 0, + .doorbell = MHI_DB_BRST_DISABLE, + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + .auto_start = false, + }, + { + .num = 20, + .name = "IPCR", + .num_elements = 64, + .event_ring = 1, + .dir = DMA_TO_DEVICE, + .ee_mask = 0x4, + .pollcfg = 0, + .doorbell = MHI_DB_BRST_DISABLE, + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + .auto_start = true, + }, + { + .num = 21, + .name = "IPCR", + .num_elements = 64, + .event_ring = 1, + .dir = DMA_FROM_DEVICE, + .ee_mask = 0x4, + .pollcfg = 0, + .doorbell = MHI_DB_BRST_DISABLE, + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = true, + .auto_start = true, + }, +}; + +static struct mhi_event_config ath11k_mhi_events[] = { + { + .num_elements = 32, + .irq_moderation_ms = 0, + .irq = 1, + .mode = MHI_DB_BRST_DISABLE, + .hardware_event = false, + .client_managed = false, + .offload_channel = false, + }, + { + .num_elements = 256, + .irq_moderation_ms = 1, + .irq = 2, + .mode = MHI_DB_BRST_DISABLE, + .priority = 1, + .hardware_event = false, + .client_managed = false, + .offload_channel = false, + }, +}; + +static struct mhi_controller_config ath11k_mhi_config = { + .max_channels = 128, + .timeout_ms = 2000, + .use_bounce_buf = false, + .buf_len = 0, + .num_channels = ARRAY_SIZE(ath11k_mhi_channels), + .ch_cfg = ath11k_mhi_channels, + .num_events = ARRAY_SIZE(ath11k_mhi_events), + .event_cfg = ath11k_mhi_events, +}; + +static int ath11k_pci_get_mhi_msi(struct ath11k_pci *ab_pci) +{ + struct ath11k_base *ab = ab_pci->ab; + u32 user_base_data, base_vector; + int ret, num_vectors, i; + int *irq; + + ret = ath11k_pci_get_user_msi_assignment(ab_pci, + "MHI", &num_vectors, + &user_base_data, &base_vector); + if (ret) + return ret; + + ath11k_dbg(ab, ATH11K_DBG_PCI, "Number of assigned MSI for MHI is %d, base vector is %d\n", + num_vectors, base_vector); + + irq = kcalloc(num_vectors, sizeof(int), GFP_KERNEL); + if (!irq) + return -ENOMEM; + + for (i = 0; i < num_vectors; i++) + irq[i] = ath11k_pci_get_msi_irq(ab_pci->dev, + base_vector + i); + + ab_pci->mhi_ctrl->irq = irq; + ab_pci->mhi_ctrl->nr_irqs = num_vectors; + + return 0; +} + +int ath11k_pci_register_mhi(struct ath11k_pci *ab_pci) +{ + struct ath11k_base *ab = ab_pci->ab; + struct mhi_controller *mhi_ctrl; + int ret; + + mhi_ctrl = kzalloc(sizeof(*mhi_ctrl), GFP_KERNEL); + if (!mhi_ctrl) + return PTR_ERR(mhi_ctrl); + + ab_pci->mhi_ctrl = mhi_ctrl; + mhi_ctrl->fw_image = ATH11K_PCI_FW_FILE_NAME; + mhi_ctrl->regs = ab_pci->mem; + + ret = ath11k_pci_get_mhi_msi(ab_pci); + if (ret) { + ath11k_err(ab, "failed to get msi for mhi\n"); + kfree(mhi_ctrl); + return ret; + } + + mhi_ctrl->iova_start = 0; + mhi_ctrl->iova_stop = 0xffffffff; + mhi_ctrl->sbl_size = SZ_512K; + mhi_ctrl->seg_len = SZ_512K; + mhi_ctrl->fbc_download = true; + + ret = mhi_register_controller(mhi_ctrl, &ath11k_mhi_config); + if (ret) { + ath11k_err(ab, "failed to register to mhi bus, err = %d\n", ret); + kfree(mhi_ctrl); + return ret; + } + + return 0; +} + +void ath11k_pci_unregister_mhi(struct ath11k_pci *ab_pci) +{ + struct mhi_controller *mhi_ctrl = ab_pci->mhi_ctrl; + + mhi_unregister_controller(mhi_ctrl); + kfree(mhi_ctrl->irq); +} + +static char *ath11k_mhi_state_to_str(enum ath11k_mhi_state mhi_state) +{ + switch (mhi_state) { + case ATH11K_MHI_INIT: + return "INIT"; + case ATH11K_MHI_DEINIT: + return "DEINIT"; + case ATH11K_MHI_POWER_ON: + return "POWER_ON"; + case ATH11K_MHI_POWER_OFF: + return "POWER_OFF"; + case ATH11K_MHI_FORCE_POWER_OFF: + return "FORCE_POWER_OFF"; + case ATH11K_MHI_SUSPEND: + return "SUSPEND"; + case ATH11K_MHI_RESUME: + return "RESUME"; + case ATH11K_MHI_TRIGGER_RDDM: + return "TRIGGER_RDDM"; + case ATH11K_MHI_RDDM_DONE: + return "RDDM_DONE"; + default: + return "UNKNOWN"; + } +}; + +static void ath11k_pci_set_mhi_state_bit(struct ath11k_pci *ab_pci, + enum ath11k_mhi_state mhi_state) +{ + struct ath11k_base *ab = ab_pci->ab; + + switch (mhi_state) { + case ATH11K_MHI_INIT: + set_bit(ATH11K_MHI_INIT, &ab_pci->mhi_state); + break; + case ATH11K_MHI_DEINIT: + clear_bit(ATH11K_MHI_INIT, &ab_pci->mhi_state); + break; + case ATH11K_MHI_POWER_ON: + set_bit(ATH11K_MHI_POWER_ON, &ab_pci->mhi_state); + break; + case ATH11K_MHI_POWER_OFF: + case ATH11K_MHI_FORCE_POWER_OFF: + clear_bit(ATH11K_MHI_POWER_ON, &ab_pci->mhi_state); + clear_bit(ATH11K_MHI_TRIGGER_RDDM, &ab_pci->mhi_state); + clear_bit(ATH11K_MHI_RDDM_DONE, &ab_pci->mhi_state); + break; + case ATH11K_MHI_SUSPEND: + set_bit(ATH11K_MHI_SUSPEND, &ab_pci->mhi_state); + break; + case ATH11K_MHI_RESUME: + clear_bit(ATH11K_MHI_SUSPEND, &ab_pci->mhi_state); + break; + case ATH11K_MHI_TRIGGER_RDDM: + set_bit(ATH11K_MHI_TRIGGER_RDDM, &ab_pci->mhi_state); + break; + case ATH11K_MHI_RDDM_DONE: + set_bit(ATH11K_MHI_RDDM_DONE, &ab_pci->mhi_state); + break; + default: + ath11k_err(ab, "unhandled mhi state (%d)\n", mhi_state); + } +} + +static int ath11k_pci_check_mhi_state_bit(struct ath11k_pci *ab_pci, + enum ath11k_mhi_state mhi_state) +{ + struct ath11k_base *ab = ab_pci->ab; + + switch (mhi_state) { + case ATH11K_MHI_INIT: + if (!test_bit(ATH11K_MHI_INIT, &ab_pci->mhi_state)) + return 0; + break; + case ATH11K_MHI_DEINIT: + case ATH11K_MHI_POWER_ON: + if (test_bit(ATH11K_MHI_INIT, &ab_pci->mhi_state) && + !test_bit(ATH11K_MHI_POWER_ON, &ab_pci->mhi_state)) + return 0; + break; + case ATH11K_MHI_FORCE_POWER_OFF: + if (test_bit(ATH11K_MHI_POWER_ON, &ab_pci->mhi_state)) + return 0; + break; + case ATH11K_MHI_POWER_OFF: + case ATH11K_MHI_SUSPEND: + if (test_bit(ATH11K_MHI_POWER_ON, &ab_pci->mhi_state) && + !test_bit(ATH11K_MHI_SUSPEND, &ab_pci->mhi_state)) + return 0; + break; + case ATH11K_MHI_RESUME: + if (test_bit(ATH11K_MHI_SUSPEND, &ab_pci->mhi_state)) + return 0; + break; + case ATH11K_MHI_TRIGGER_RDDM: + if (test_bit(ATH11K_MHI_POWER_ON, &ab_pci->mhi_state) && + !test_bit(ATH11K_MHI_TRIGGER_RDDM, &ab_pci->mhi_state)) + return 0; + break; + case ATH11K_MHI_RDDM_DONE: + return 0; + default: + ath11k_err(ab, "unhandled mhi state: %s(%d)\n", + ath11k_mhi_state_to_str(mhi_state), mhi_state); + } + + ath11k_err(ab, "failed to set mhi state %s(%d) in current mhi state (0x%lx)\n", + ath11k_mhi_state_to_str(mhi_state), mhi_state, + ab_pci->mhi_state); + + return -EINVAL; +} + +static int ath11k_pci_set_mhi_state(struct ath11k_pci *ab_pci, + enum ath11k_mhi_state mhi_state) +{ + struct ath11k_base *ab = ab_pci->ab; + int ret; + + ret = ath11k_pci_check_mhi_state_bit(ab_pci, mhi_state); + if (ret) + goto out; + + ath11k_dbg(ab, ATH11K_DBG_PCI, "setting mhi state: %s(%d)\n", + ath11k_mhi_state_to_str(mhi_state), mhi_state); + + switch (mhi_state) { + case ATH11K_MHI_INIT: + ret = mhi_prepare_for_power_up(ab_pci->mhi_ctrl); + break; + case ATH11K_MHI_DEINIT: + mhi_unprepare_after_power_down(ab_pci->mhi_ctrl); + ret = 0; + break; + case ATH11K_MHI_POWER_ON: + ret = mhi_async_power_up(ab_pci->mhi_ctrl); + break; + case ATH11K_MHI_POWER_OFF: + mhi_power_down(ab_pci->mhi_ctrl, true); + ret = 0; + break; + case ATH11K_MHI_FORCE_POWER_OFF: + mhi_power_down(ab_pci->mhi_ctrl, false); + ret = 0; + break; + case ATH11K_MHI_SUSPEND: + break; + case ATH11K_MHI_RESUME: + break; + case ATH11K_MHI_TRIGGER_RDDM: + ret = mhi_force_rddm_mode(ab_pci->mhi_ctrl); + break; + case ATH11K_MHI_RDDM_DONE: + break; + default: + ath11k_err(ab, "unhandled MHI state (%d)\n", mhi_state); + ret = -EINVAL; + } + + if (ret) + goto out; + + ath11k_pci_set_mhi_state_bit(ab_pci, mhi_state); + + return 0; + +out: + ath11k_err(ab, "failed to set mhi state: %s(%d)\n", + ath11k_mhi_state_to_str(mhi_state), mhi_state); + return ret; +} + +int ath11k_pci_start_mhi(struct ath11k_pci *ab_pci) +{ + struct ath11k_base *ab = ab_pci->ab; + int ret; + + ab_pci->mhi_ctrl->timeout_ms = MHI_TIMEOUT_DEFAULT_MS; + + ret = ath11k_pci_set_mhi_state(ab_pci, ATH11K_MHI_INIT); + if (ret) + ath11k_err(ab, "failed to set mhi init state: %d\n", ret); + + ret = ath11k_pci_set_mhi_state(ab_pci, ATH11K_MHI_POWER_ON); + if (ret) + ath11k_err(ab, "failed to set mhi power on state: %d\n", ret); + + return ret; +} + +void ath11k_pci_stop_mhi(struct ath11k_pci *ab_pci) +{ + ath11k_pci_set_mhi_state(ab_pci, ATH11K_MHI_RESUME); + ath11k_pci_set_mhi_state(ab_pci, ATH11K_MHI_POWER_OFF); + ath11k_pci_set_mhi_state(ab_pci, ATH11K_MHI_DEINIT); +} + diff --git a/drivers/net/wireless/ath/ath11k/mhi.h b/drivers/net/wireless/ath/ath11k/mhi.h new file mode 100644 index 000000000000..355de5a2c241 --- /dev/null +++ b/drivers/net/wireless/ath/ath11k/mhi.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* + * Copyright (c) 2020 The Linux Foundation. All rights reserved. + */ +#ifndef _ATH11K_MHI_H +#define _ATH11K_MHI_H + +#include "pci.h" +#define ATH11K_PCI_FW_FILE_NAME "amss.bin" + +enum ath11k_mhi_state { + ATH11K_MHI_INIT, + ATH11K_MHI_DEINIT, + ATH11K_MHI_POWER_ON, + ATH11K_MHI_POWER_OFF, + ATH11K_MHI_FORCE_POWER_OFF, + ATH11K_MHI_SUSPEND, + ATH11K_MHI_RESUME, + ATH11K_MHI_TRIGGER_RDDM, + ATH11K_MHI_RDDM, + ATH11K_MHI_RDDM_DONE, +}; + +int ath11k_pci_start_mhi(struct ath11k_pci *ar_pci); +void ath11k_pci_stop_mhi(struct ath11k_pci *ar_pci); +int ath11k_pci_register_mhi(struct ath11k_pci *ar_pci); +void ath11k_pci_unregister_mhi(struct ath11k_pci *ar_pci); +#endif diff --git a/drivers/net/wireless/ath/ath11k/pci.c b/drivers/net/wireless/ath/ath11k/pci.c index d89dcb5fe81e..938078ee8d80 100644 --- a/drivers/net/wireless/ath/ath11k/pci.c +++ b/drivers/net/wireless/ath/ath11k/pci.c @@ -9,6 +9,8 @@ #include "ahb.h" #include "core.h" +#include "hif.h" +#include "mhi.h" #include "pci.h" #include "debug.h" @@ -31,6 +33,60 @@ static struct ath11k_msi_config msi_config = { }, }; +int ath11k_pci_get_msi_irq(struct device *dev, unsigned int vector) +{ + struct pci_dev *pci_dev = to_pci_dev(dev); + int irq_num; + + irq_num = pci_irq_vector(pci_dev, vector); + + return irq_num; +} + +int ath11k_pci_get_user_msi_assignment(struct ath11k_pci *ab_pci, char *user_name, + int *num_vectors, u32 *user_base_data, + u32 *base_vector) +{ + struct ath11k_base *ab = ab_pci->ab; + struct ath11k_msi_config *msi_config; + int idx; + + msi_config = ab_pci->msi_config; + if (!msi_config) { + ath11k_err(ab, "MSI is not supported.\n"); + return -EINVAL; + } + + for (idx = 0; idx < msi_config->total_users; idx++) { + if (strcmp(user_name, msi_config->users[idx].name) == 0) { + *num_vectors = msi_config->users[idx].num_vectors; + *user_base_data = msi_config->users[idx].base_vector + + ab_pci->msi_ep_base_data; + *base_vector = msi_config->users[idx].base_vector; + + ath11k_dbg(ab, ATH11K_DBG_PCI, "Assign MSI to user: %s, num_vectors: %d, user_base_data: %u, base_vector: %u\n", + user_name, *num_vectors, *user_base_data, + *base_vector); + + return 0; + } + } + + ath11k_err(ab, "Failed to find MSI assignment for %s!\n", user_name); + + return -EINVAL; +} + +static int ath11k_pci_qca6x90_powerup(struct ath11k_pci *ab_pci) +{ + return ath11k_pci_start_mhi(ab_pci); +} + +static void ath11k_pci_qca6x90_powerdown(struct ath11k_pci *ab_pci) +{ + ath11k_pci_stop_mhi(ab_pci); +} + static int ath11k_pci_get_msi_assignment(struct ath11k_pci *ab_pci) { ab_pci->msi_config = &msi_config; @@ -184,6 +240,34 @@ static void ath11k_pci_free_region(struct ath11k_pci *ab_pci) pci_disable_device(pci_dev); } +static int ath11k_pci_power_up(struct ath11k_base *ab) +{ + struct ath11k_pci *ab_pci; + int ret; + + ab_pci = ath11k_pci_priv(ab); + ret = ath11k_pci_qca6x90_powerup(ab_pci); + if (ret) { + ath11k_err(ab, "failed to power on mhi: %d\n", ret); + return ret; + } + + return 0; +} + +static void ath11k_pci_power_down(struct ath11k_base *ab) +{ + struct ath11k_pci *ab_pci; + + ab_pci = ath11k_pci_priv(ab); + ath11k_pci_qca6x90_powerdown(ab_pci); +} + +static const struct ath11k_hif_ops ath11k_pci_hif_ops = { + .power_down = ath11k_pci_power_down, + .power_up = ath11k_pci_power_up, +}; + static int ath11k_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pci_dev) { @@ -229,14 +313,26 @@ static int ath11k_pci_probe(struct pci_dev *pdev, goto err_free_core; } + ab->mem = ab_pci->mem; + ab->mem_len = ab_pci->mem_len; + ret = ath11k_pci_enable_msi(ab_pci); if (ret) { ath11k_err(ab, "failed to enable msi: %d\n", ret); goto err_pci_free_region; } + ret = ath11k_pci_register_mhi(ab_pci); + if (ret) { + ath11k_err(ab, "failed to register mhi: %d\n", ret); + goto err_pci_disable_msi; + } + return 0; +err_pci_disable_msi: + ath11k_pci_disable_msi(ab_pci); + err_pci_free_region: ath11k_pci_free_region(ab_pci); @@ -252,6 +348,7 @@ static void ath11k_pci_remove(struct pci_dev *pdev) struct ath11k_pci *ab_pci = ath11k_pci_priv(ab); set_bit(ATH11K_FLAG_UNREGISTERING, &ab->dev_flags); + ath11k_pci_unregister_mhi(ab_pci); ath11k_pci_disable_msi(ab_pci); ath11k_pci_free_region(ab_pci); ath11k_core_free(ab); diff --git a/drivers/net/wireless/ath/ath11k/pci.h b/drivers/net/wireless/ath/ath11k/pci.h index 7c7fa1965aa6..83b485be6c50 100644 --- a/drivers/net/wireless/ath/ath11k/pci.h +++ b/drivers/net/wireless/ath/ath11k/pci.h @@ -2,6 +2,10 @@ /* * Copyright (c) 2019-2020 The Linux Foundation. All rights reserved. */ +#ifndef _ATH11K_PCI_H +#define _ATH11K_PCI_H + +#include #define QCA6290_VENDOR_ID 0x17CB #define QCA6290_DEVICE_ID 0x1100 @@ -33,4 +37,13 @@ struct ath11k_pci { u32 chip_id; struct ath11k_msi_config *msi_config; u32 msi_ep_base_data; + struct mhi_controller *mhi_ctrl; + unsigned long mhi_state; }; + +int ath11k_pci_get_user_msi_assignment(struct ath11k_pci *ar_pci, char *user_name, + int *num_vectors, u32 *user_base_data, + u32 *base_vector); + +int ath11k_pci_get_msi_irq(struct device *dev, unsigned int vector); +#endif -- 2.22.0