From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jean-Francois Moine Subject: Re: [alsa-devel] [PATCH RFC v2 REPOST 3/8] ASoC: davinci-evm: HDMI audio support for TDA998x trough McASP I2S bus Date: Fri, 24 Jan 2014 17:54:31 +0100 Message-ID: <20140124175431.47a82d57@armhf> References: <20131231132555.GA31886@sirena.org.uk> <52D67099.1040904@ti.com> <20140115165100.3bfab96f@armhf> <52DF8D60.9020505@ti.com> <20140122111953.238349a5@armhf> <20140122114647.20f75d0d@armhf> <52E26325.4040203@ti.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <52E26325.4040203@ti.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dri-devel-bounces@lists.freedesktop.org Errors-To: dri-devel-bounces@lists.freedesktop.org To: Jyri Sarha Cc: alsa-devel@alsa-project.org, linux-omap@vger.kernel.org, linux-arm-kernel@lists.infradead.org, dri-devel@lists.freedesktop.org List-Id: alsa-devel@alsa-project.org T24gRnJpLCAyNCBKYW4gMjAxNCAxNDo1NzowOSArMDIwMApKeXJpIFNhcmhhIDxqc2FyaGFAdGku Y29tPiB3cm90ZToKCj4gQ291bGQgeW91IGdpdmUgbWUgYSBsaW5rIHRvIGEgZ2l0IHJlcG8gd2l0 aCB5b3VyIHRkYTk5OHggY29kZWMgY29kZSBzbyBJIAo+IGNvdWxkIHByZXBhcmUgdG8gdXNlIHRo YXQgdG9vPwoKSSBoYXZlIG5vIGdpdCByZXBvLiBJbnN0ZWFkLCBoZXJlIGlzIHRoZSBzb3VyY2Uu CgpJdCBnb2VzIGludG8gc291bmQvc29jL2NvZGVjcyBhbmQgaXMgc2VsZWN0ZWQgd2l0aCBDT05G SUdfT0YgYW5kCkNPTkZJR19EUk1fSTJDX05YUF9UREE5OThYLgoKSXQgbmVlZHMgMiBleHBvcnRl ZCBmdW5jdGlvbnMgb2YgdGhlIHRkYTk5OHggZHJpdmVyOiB0aGUgZmlyc3Qgb25lIHRvCnNlbGVj dCB0aGUgYXVkaW8gcG9ydCAodGRhOTk4eF9hdWRpb191cGRhdGUpICBhbmQgdGhlIG90aGVyIG9u ZSB0byBnZXQKdGhlIEVMRCAodGRhOTk4eF9hdWRpb19nZXRfZWxkKS4KCkZvciB0aGVzZSBmdW5j dGlvbnMgdG8gcmVjZWl2ZSB0aGUgY29ycmVjdCBpMmNfY2xpZW50LCB0aGUgY29kZWMKc2VhcmNo ZXMgdGhlIHRkYTk5OHggZHJpdmVyIGluIHRoZSBEVCBieSBpdHMgY29tcGF0aWJsZSAibnhwLHRk YTk5OHgiLgpJZiB0aGUgdGRhOTk4eCBpcyBsb2FkZWQgYnkgZHJtX2kyY19lbmNvZGVyX2luaXQo KSwgaXQgc2hvdWxkIG5vdCBiZQpkZWNsYXJlZCBpbiB0aGUgRFQsIHNvLCB0aGlzIHJhaXNlcyBh IHByb2JsZW0uIEkgZG9uJ3Qga25vdyB3aGF0IG11c3QKYmUgZG9uZSBpbiB0aGlzIGNhc2UuCgpU aGUgY29kZWMgaXMgdXNlZCB3aXRoIHRoZSBzaW1wbGUgY2FyZCBhcyB0aGUgc291bmQgY2FyZC4g Rm9yIHlvdSwgdGhlCkRUIGNvdWxkIGJlOgoKCWhkbWlfY29kZWM6IGhkbWktY29kZWMgewoJCWNv bXBhdGlibGUgPSAibnhwLHRkYTk5OHgtY29kZWMiOwoJCSNzb3VuZC1kYWktY2VsbHMgPSA8MT47 CgkJYXVkaW8tcG9ydHMgPSA8MHgwMz4sIDwweDA0PjsJLyogaTJzIC0gcy9wZGlmICovCgl9OwoK CXNvdW5kIHsKCQljb21wYXRpYmxlID0gInNpbXBsZS1hdWRpby1jYXJkIjsKCQlzaW1wbGUtYXVk aW8tY2FyZCxjcHUgewoJCQlzb3VuZC1kYWkgPSA8JmF1ZGlvMSAxPjsKCQkJZm9ybWF0ID0gImky cyI7CgkJfTsKCQlzaW1wbGUtYXVkaW8tY2FyZCxjb2RlYyB7CgkJCXNvdW5kLWRhaSA9IDwmaGRt aV9jb2RlYyAwPjsJLyogaTJzICovCgkJfTsKCX07CgooJ2F1ZGlvMScgaXMgdGhlIGF1ZGlvIGNv bnRyb2xsZXIpCgotLS0tLS0tLS0tLS0tLS0tLS0tODwtLS0tLS0tLS0tLS0tLS0tIHNvdXJjZSBz b3VuZC9zb2MvY29kZWNzL3RkYTk5OHguYwovKgogKiBBTFNBIFNvQyBUREE5OThYIGRyaXZlcgog KgogKiBUaGlzIGRyaXZlciBpcyB1c2VkIGJ5IHRoZSBOWFAgVERBOTk4eCBIRE1JIHRyYW5zbWl0 dGVyLgogKgogKiBDb3B5cmlnaHQgKEMpIDIwMTQgSmVhbi1GcmFuY29pcyBNb2luZQogKgogKiBU aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yIG1vZGlmeQogKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIHZlcnNpb24gMiBhcwogKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbi4KICovCgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxzb3Vu ZC9zb2MuaD4KI2luY2x1ZGUgPHNvdW5kL3BjbS5oPgojaW5jbHVkZSA8bGludXgvb2YuaD4KI2lu Y2x1ZGUgPGxpbnV4L2kyYy5oPgojaW5jbHVkZSA8ZHJtL2RybV9lbmNvZGVyX3NsYXZlLmg+CiNp bmNsdWRlIDxkcm0vaTJjL3RkYTk5OHguaD4KCiNkZWZpbmUgVERBOTk4WF9GT1JNQVRTCShTTkRS Vl9QQ01fRk1UQklUX1MxNl9MRSB8IFwKCQkJU05EUlZfUENNX0ZNVEJJVF9TMjBfM0xFIHwgXAoJ CQlTTkRSVl9QQ01fRk1UQklUX1MyNF9MRSB8IFwKCQkJU05EUlZfUENNX0ZNVEJJVF9TMzJfTEUp CgpzdHJ1Y3QgdGRhX3ByaXYgewoJc3RydWN0IGkyY19jbGllbnQgKmkyY19jbGllbnQ7CglzdHJ1 Y3Qgc25kX3NvY19jb2RlYyAqY29kZWM7Cgl1MzIgcG9ydHNbMl07CglpbnQgZGFpX2lkOwoJdTgg KmVsZDsKfTsKCnN0YXRpYyB2b2lkIHRkYV9nZXRfZW5jb2RlcihzdHJ1Y3QgdGRhX3ByaXYgKnBy aXYpCnsKCXN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYyA9IHByaXYtPmNvZGVjOwoJc3RydWN0 IGRldmljZV9ub2RlICpucDsKCXN0cnVjdCBpMmNfY2xpZW50ICppMmNfY2xpZW50OwoJc3RhdGlj IGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgdGRhX2R0W10gPSB7CgkJeyAuY29tcGF0aWJsZSA9 ICJueHAsdGRhOTk4eCIgfSwKCQl7IH0sCgl9OwoKCS8qIHNlYXJjaCB0aGUgdGRhOTk4eCBkZXZp Y2UgKG9ubHkgb25lISkgKi8KCW5wID0gb2ZfZmluZF9tYXRjaGluZ19ub2RlX2FuZF9tYXRjaChO VUxMLCB0ZGFfZHQsIE5VTEwpOwoJaWYgKCFucCB8fCAhb2ZfZGV2aWNlX2lzX2F2YWlsYWJsZShu cCkpIHsKCQlkZXZfZXJyKGNvZGVjLT5kZXYsICJObyB0ZGE5OTh4IGluIERUXG4iKTsKCQlyZXR1 cm47Cgl9CglpMmNfY2xpZW50ID0gb2ZfZmluZF9pMmNfZGV2aWNlX2J5X25vZGUobnApOwoJb2Zf bm9kZV9wdXQobnApOwoJaWYgKCFpMmNfY2xpZW50KSB7CgkJZGV2X2Vycihjb2RlYy0+ZGV2LCAi bm8gdGRhOTk4eCBpMmMgY2xpZW50XG4iKTsKCQlyZXR1cm47Cgl9CglpZiAoIWkyY19nZXRfY2xp ZW50ZGF0YShpMmNfY2xpZW50KSkgewoJCWRldl9lcnIoY29kZWMtPmRldiwgInRkYTk5OHggbm90 IGluaXRpYWxpemVkXG4iKTsKCQlyZXR1cm47Cgl9CgoJcHJpdi0+aTJjX2NsaWVudCA9IGkyY19j bGllbnQ7Cn0KCnN0YXRpYyBpbnQgdGRhX3N0YXJ0X3N0b3Aoc3RydWN0IHRkYV9wcml2ICpwcml2 LAoJCQlpbnQgc3RhcnQpCnsKCWludCBmb3JtYXQ7Cgl1MzIgcG9ydDsKCglpZiAoIXByaXYtPmky Y19jbGllbnQpIHsKCQl0ZGFfZ2V0X2VuY29kZXIocHJpdik7CgkJaWYgKCFwcml2LT5pMmNfY2xp ZW50KQoJCQlyZXR1cm4gLUVJTlZBTDsKCX0KCgkvKiBnaXZlIHRoZSBhdWRpbyBpbnB1dCB0eXBl IGFuZCBwb3J0cyB0byB0aGUgSERNSSBlbmNvZGVyICovCglmb3JtYXQgPSBzdGFydCA/IHByaXYt PmRhaV9pZCA6IDA7Cglzd2l0Y2ggKGZvcm1hdCkgewoJY2FzZSBBRk1UX0kyUzoKCQlwb3J0ID0g cHJpdi0+cG9ydHNbMF07CgkJYnJlYWs7CglkZWZhdWx0OgoJY2FzZSBBRk1UX1NQRElGOgoJCXBv cnQgPSBwcml2LT5wb3J0c1sxXTsKCQlicmVhazsKCX0KCXRkYTk5OHhfYXVkaW9fdXBkYXRlKHBy aXYtPmkyY19jbGllbnQsIGZvcm1hdCwgcG9ydCk7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCB0 ZGFfc3RhcnR1cChzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSwKCQkJc3RydWN0 IHNuZF9zb2NfZGFpICpkYWkpCnsKCXN0cnVjdCB0ZGFfcHJpdiAqcHJpdiA9IHNuZF9zb2NfY29k ZWNfZ2V0X2RydmRhdGEoZGFpLT5jb2RlYyk7Cgl1OCAqZWxkID0gTlVMTDsKCXN0YXRpYyB1bnNp Z25lZCByYXRlc19tYXNrW10gPSB7CgkJU05EUlZfUENNX1JBVEVfMzIwMDAsCgkJU05EUlZfUENN X1JBVEVfNDQxMDAsCgkJU05EUlZfUENNX1JBVEVfNDgwMDAsCgkJU05EUlZfUENNX1JBVEVfODgy MDAsCgkJU05EUlZfUENNX1JBVEVfOTYwMDAsCgkJU05EUlZfUENNX1JBVEVfMTc2NDAwLAoJCVNO RFJWX1BDTV9SQVRFXzE5MjAwMCwKCX07CgoJLyogbWVtb3JpemUgdGhlIHVzZWQgREFJICovCglw cml2LT5kYWlfaWQgPSBkYWktPmlkOwoKCS8qIGdldCB0aGUgRUxEIGZyb20gdGhlIHRkYTk5OHgg ZHJpdmVyICovCglpZiAoIXByaXYtPmkyY19jbGllbnQpCgkJdGRhX2dldF9lbmNvZGVyKHByaXYp OwoJaWYgKHByaXYtPmkyY19jbGllbnQpCgkJZWxkID0gdGRhOTk4eF9hdWRpb19nZXRfZWxkKHBy aXYtPmkyY19jbGllbnQpOwoKCS8qIGxpbWl0IHRoZSBodyBwYXJhbXMgZnJvbSB0aGUgRUxEIChF RElEKSAqLwoJaWYgKGVsZCkgewoJCXN0cnVjdCBzbmRfc29jX2RhaV9kcml2ZXIgKmRhaV9kcnYg PSBkYWktPmRyaXZlcjsKCQlzdHJ1Y3Qgc25kX3NvY19wY21fc3RyZWFtICpzdHJlYW0gPSAmZGFp X2Rydi0+cGxheWJhY2s7CgkJdTggKnNhZDsKCQlpbnQgc2FkX2NvdW50OwoJCXVuc2lnbmVkIGVs ZF92ZXIsIG1ubCwgcmF0ZXMsIHJhdGVfbWFzaywgaTsKCQl1bnNpZ25lZCBtYXhfY2hhbm5lbHM7 CgoJCWVsZF92ZXIgPSBlbGRbMF0gPj4gMzsKCQlpZiAoZWxkX3ZlciAhPSAyICYmIGVsZF92ZXIg IT0gMzEpCgkJCXJldHVybiAwOwoKCQltbmwgPSBlbGRbNF0gJiAweDFmOwoJCWlmIChtbmwgPiAx NikKCQkJcmV0dXJuIDA7CgoJCXNhZF9jb3VudCA9IGVsZFs1XSA+PiA0OwoJCXNhZCA9IGVsZCAr IDIwICsgbW5sOwoKCQkvKiBTdGFydCBmcm9tIHRoZSBiYXNpYyBhdWRpbyBzZXR0aW5ncyAqLwoJ CW1heF9jaGFubmVscyA9IDI7CgkJcmF0ZXMgPSAwOwoJCXdoaWxlIChzYWRfY291bnQtLSkgewoJ CQlzd2l0Y2ggKHNhZFswXSAmIDB4NzgpIHsKCQkJY2FzZSAweDA4OiAvKiBQQ00gKi8KCQkJCW1h eF9jaGFubmVscyA9IG1heChtYXhfY2hhbm5lbHMsIChzYWRbMF0gJiA3KSArIDF1KTsKCQkJCXJh dGVzIHw9IHNhZFsxXTsKCQkJCWJyZWFrOwoJCQl9CgkJCXNhZCArPSAzOwoJCX0KCgkJZm9yIChy YXRlX21hc2sgPSBpID0gMDsgaSA8IEFSUkFZX1NJWkUocmF0ZXNfbWFzayk7IGkrKykKCQkJaWYg KHJhdGVzICYgMSA8PCBpKQoJCQkJcmF0ZV9tYXNrIHw9IHJhdGVzX21hc2tbaV07CgoJCS8qIGNo YW5nZSB0aGUgc25kX3NvY19wY21fc3RyZWFtIHZhbHVlcyBvZiB0aGUgZHJpdmVyICovCgkJc3Ry ZWFtLT5yYXRlcyA9IHJhdGVfbWFzazsKCQlzdHJlYW0tPmNoYW5uZWxzX21heCA9IG1heF9jaGFu bmVsczsKCX0KCgkvKiBzdGFydCB0aGUgVERBOTk4eCBhdWRpbyAqLwoJcmV0dXJuIHRkYV9zdGFy dF9zdG9wKHByaXYsIDEpOwp9CgpzdGF0aWMgdm9pZCB0ZGFfc2h1dGRvd24oc3RydWN0IHNuZF9w Y21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCgkJCXN0cnVjdCBzbmRfc29jX2RhaSAqZGFpKQp7Cglz dHJ1Y3QgdGRhX3ByaXYgKnByaXYgPSBzbmRfc29jX2NvZGVjX2dldF9kcnZkYXRhKGRhaS0+Y29k ZWMpOwoKCXByaXYtPmRhaV9pZCA9IDA7Cgl0ZGFfc3RhcnRfc3RvcChwcml2LCAwKTsKfQoKc3Rh dGljIGNvbnN0IHN0cnVjdCBzbmRfc29jX2RhaV9vcHMgdGRhX29wcyA9IHsKCS5zdGFydHVwID0g dGRhX3N0YXJ0dXAsCgkuc2h1dGRvd24gPSB0ZGFfc2h1dGRvd24sCn07CgpzdGF0aWMgY29uc3Qg c3RydWN0IHNuZF9zb2NfZGFpX2RyaXZlciB0ZGE5OTh4X2RhaVtdID0gewogICAgewoJLm5hbWUg PSAiaTJzLWhpZmkiLAoJLmlkID0gQUZNVF9JMlMsCgkucGxheWJhY2sgPSB7CgkJLnN0cmVhbV9u YW1lCT0gIkhETUkgSTJTIFBsYXliYWNrIiwKCQkuY2hhbm5lbHNfbWluCT0gMSwKCQkuY2hhbm5l bHNfbWF4CT0gOCwKCQkucmF0ZXMJCT0gU05EUlZfUENNX1JBVEVfQ09OVElOVU9VUywKCQkucmF0 ZV9taW4JPSA1NTEyLAoJCS5yYXRlX21heAk9IDE5MjAwMCwKCQkuZm9ybWF0cwk9IFREQTk5OFhf Rk9STUFUUywKCgl9LAoJLm9wcyA9ICZ0ZGFfb3BzLAogICAgfSwKICAgIHsKCS5uYW1lID0gInNw ZGlmLWhpZmkiLAoJLmlkID0gQUZNVF9TUERJRiwKCS5wbGF5YmFjayA9IHsKCQkuc3RyZWFtX25h bWUJPSAiSERNSSBTUERJRiBQbGF5YmFjayIsCgkJLmNoYW5uZWxzX21pbgk9IDEsCgkJLmNoYW5u ZWxzX21heAk9IDIsCgkJLnJhdGVzCQk9IFNORFJWX1BDTV9SQVRFX0NPTlRJTlVPVVMsCgkJLnJh dGVfbWluCT0gMjIwNTAsCgkJLnJhdGVfbWF4CT0gMTkyMDAwLAoJCS5mb3JtYXRzCT0gVERBOTk4 WF9GT1JNQVRTLAoJfSwKCS5vcHMgPSAmdGRhX29wcywKICAgIH0sCn07CgpzdGF0aWMgY29uc3Qg c3RydWN0IHNuZF9zb2NfZGFwbV93aWRnZXQgdGRhX3dpZGdldHNbXSA9IHsKCVNORF9TT0NfREFQ TV9PVVRQVVQoImhkbWktb3V0IiksCn07CnN0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX3NvY19kYXBt X3JvdXRlIHRkYV9yb3V0ZXNbXSA9IHsKCXsgImhkbWktb3V0IiwgTlVMTCwgIkhETUkgSTJTIFBs YXliYWNrIiB9LAoJeyAiaGRtaS1vdXQiLCBOVUxMLCAiSERNSSBTUERJRiBQbGF5YmFjayIgfSwK fTsKCnN0YXRpYyBpbnQgdGRhX3Byb2JlKHN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYykKewoJ c3RydWN0IHRkYV9wcml2ICpwcml2OwoJc3RydWN0IGRldmljZV9ub2RlICpucDsKCWludCBpLCBy ZXQ7CgoJcHJpdiA9IGRldm1fa3phbGxvYyhjb2RlYy0+ZGV2LCBzaXplb2YoKnByaXYpLCBHRlBf S0VSTkVMKTsKCWlmICghcHJpdikKCQlyZXR1cm4gLUVOT01FTTsKCXNuZF9zb2NfY29kZWNfc2V0 X2RydmRhdGEoY29kZWMsIHByaXYpOwoJcHJpdi0+Y29kZWMgPSBjb2RlYzsKCgkvKiBnZXQgdGhl IGF1ZGlvIGlucHV0IHBvcnRzIChJMnMgYW5kIFMvUERJRikgKi8KCW5wID0gY29kZWMtPmRldi0+ b2Zfbm9kZTsKCWZvciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKCQlyZXQgPSBvZl9wcm9wZXJ0eV9y ZWFkX3UzMl9pbmRleChucCwgImF1ZGlvLXBvcnRzIiwgaSwKCQkJCQkJJnByaXYtPnBvcnRzW2ld KTsKCQlpZiAocmV0KSB7CgkJCWlmIChpID09IDApCgkJCQlkZXZfZXJyKGNvZGVjLT5kZXYsCgkJ CQkJImJhZCBvciBtaXNzaW5nIGF1ZGlvLXBvcnRzXG4iKTsKCQkJYnJlYWs7CgkJfQoJfQoKCXJl dHVybiAwOwp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9zb2NfY29kZWNfZHJpdmVyIHNvY19j b2RlY190ZGE5OTh4ID0gewoJLnByb2JlID0gdGRhX3Byb2JlLAoJLmRhcG1fd2lkZ2V0cyA9IHRk YV93aWRnZXRzLAoJLm51bV9kYXBtX3dpZGdldHMgPSBBUlJBWV9TSVpFKHRkYV93aWRnZXRzKSwK CS5kYXBtX3JvdXRlcyA9IHRkYV9yb3V0ZXMsCgkubnVtX2RhcG1fcm91dGVzID0gQVJSQVlfU0la RSh0ZGFfcm91dGVzKSwKfTsKCnN0YXRpYyBpbnQgdGRhOTk4eF9kZXZfcHJvYmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKewoJc3RydWN0IHNuZF9zb2NfZGFpX2RyaXZlciAqZGFpX2Ry djsKCgkvKiBjb3B5IHRoZSBEQUkgZHJpdmVyIHRvIGEgd3JpdGFibGUgYXJlYSAqLwoJZGFpX2Ry diA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YodGRhOTk4eF9kYWkpLCBHRlBfS0VS TkVMKTsKCWlmICghZGFpX2RydikKCQlyZXR1cm4gLUVOT01FTTsKCW1lbWNweShkYWlfZHJ2LCB0 ZGE5OTh4X2RhaSwgc2l6ZW9mKHRkYTk5OHhfZGFpKSk7CgoJcmV0dXJuIHNuZF9zb2NfcmVnaXN0 ZXJfY29kZWMoJnBkZXYtPmRldiwKCQkJCSZzb2NfY29kZWNfdGRhOTk4eCwKCQkJCWRhaV9kcnYs IEFSUkFZX1NJWkUodGRhOTk4eF9kYWkpKTsKfQoKc3RhdGljIGludCB0ZGE5OTh4X2Rldl9yZW1v dmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKewoJc25kX3NvY191bnJlZ2lzdGVyX2Nv ZGVjKCZwZGV2LT5kZXYpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2 aWNlX2lkIHRkYTk5OHhfY29kZWNfaWRzW10gPSB7Cgl7IC5jb21wYXRpYmxlID0gIm54cCx0ZGE5 OTh4LWNvZGVjIiwgfSwKCXsgfQp9OwpNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCB0ZGE5OTh4X2Nv ZGVjX2lkcyk7CgpzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciB0ZGE5OTh4X2RyaXZlciA9 IHsKCS5wcm9iZQkJPSB0ZGE5OTh4X2Rldl9wcm9iZSwKCS5yZW1vdmUJCT0gdGRhOTk4eF9kZXZf cmVtb3ZlLAoJLmRyaXZlcgkJPSB7CgkJLm5hbWUJPSAidGRhOTk4eC1jb2RlYyIsCgkJLm93bmVy CT0gVEhJU19NT0RVTEUsCgkJLm9mX21hdGNoX3RhYmxlID0gdGRhOTk4eF9jb2RlY19pZHMsCgl9 LAp9OwoKbW9kdWxlX3BsYXRmb3JtX2RyaXZlcih0ZGE5OTh4X2RyaXZlcik7CgpNT0RVTEVfQVVU SE9SKCJKZWFuLUZyYW5jb2lzIE1vaW5lIik7Ck1PRFVMRV9ERVNDUklQVElPTigiVERBOTk4eCBj b2RlYyBkcml2ZXIiKTsKTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwotLS0tLS0tLS0tLS0tLS0tLS0t ODwtLS0tLS0tLS0tLS0tLS0tCgotLSAKS2VuIGFyIGMnaGVudGHDsQl8CSAgICAgICoqIEJyZWl6 aCBoYSBMaW51eCBhdGF2ISAqKgpKZWYJCXwJCWh0dHA6Ly9tb2luZWpmLmZyZWUuZnIvCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: moinejf@free.fr (Jean-Francois Moine) Date: Fri, 24 Jan 2014 17:54:31 +0100 Subject: [alsa-devel] [PATCH RFC v2 REPOST 3/8] ASoC: davinci-evm: HDMI audio support for TDA998x trough McASP I2S bus In-Reply-To: <52E26325.4040203@ti.com> References: <20131231132555.GA31886@sirena.org.uk> <52D67099.1040904@ti.com> <20140115165100.3bfab96f@armhf> <52DF8D60.9020505@ti.com> <20140122111953.238349a5@armhf> <20140122114647.20f75d0d@armhf> <52E26325.4040203@ti.com> Message-ID: <20140124175431.47a82d57@armhf> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Fri, 24 Jan 2014 14:57:09 +0200 Jyri Sarha wrote: > Could you give me a link to a git repo with your tda998x codec code so I > could prepare to use that too? I have no git repo. Instead, here is the source. It goes into sound/soc/codecs and is selected with CONFIG_OF and CONFIG_DRM_I2C_NXP_TDA998X. It needs 2 exported functions of the tda998x driver: the first one to select the audio port (tda998x_audio_update) and the other one to get the ELD (tda998x_audio_get_eld). For these functions to receive the correct i2c_client, the codec searches the tda998x driver in the DT by its compatible "nxp,tda998x". If the tda998x is loaded by drm_i2c_encoder_init(), it should not be declared in the DT, so, this raises a problem. I don't know what must be done in this case. The codec is used with the simple card as the sound card. For you, the DT could be: hdmi_codec: hdmi-codec { compatible = "nxp,tda998x-codec"; #sound-dai-cells = <1>; audio-ports = <0x03>, <0x04>; /* i2s - s/pdif */ }; sound { compatible = "simple-audio-card"; simple-audio-card,cpu { sound-dai = <&audio1 1>; format = "i2s"; }; simple-audio-card,codec { sound-dai = <&hdmi_codec 0>; /* i2s */ }; }; ('audio1' is the audio controller) -------------------8<---------------- source sound/soc/codecs/tda998x.c /* * ALSA SoC TDA998X driver * * This driver is used by the NXP TDA998x HDMI transmitter. * * Copyright (C) 2014 Jean-Francois Moine * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #define TDA998X_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \ SNDRV_PCM_FMTBIT_S20_3LE | \ SNDRV_PCM_FMTBIT_S24_LE | \ SNDRV_PCM_FMTBIT_S32_LE) struct tda_priv { struct i2c_client *i2c_client; struct snd_soc_codec *codec; u32 ports[2]; int dai_id; u8 *eld; }; static void tda_get_encoder(struct tda_priv *priv) { struct snd_soc_codec *codec = priv->codec; struct device_node *np; struct i2c_client *i2c_client; static const struct of_device_id tda_dt[] = { { .compatible = "nxp,tda998x" }, { }, }; /* search the tda998x device (only one!) */ np = of_find_matching_node_and_match(NULL, tda_dt, NULL); if (!np || !of_device_is_available(np)) { dev_err(codec->dev, "No tda998x in DT\n"); return; } i2c_client = of_find_i2c_device_by_node(np); of_node_put(np); if (!i2c_client) { dev_err(codec->dev, "no tda998x i2c client\n"); return; } if (!i2c_get_clientdata(i2c_client)) { dev_err(codec->dev, "tda998x not initialized\n"); return; } priv->i2c_client = i2c_client; } static int tda_start_stop(struct tda_priv *priv, int start) { int format; u32 port; if (!priv->i2c_client) { tda_get_encoder(priv); if (!priv->i2c_client) return -EINVAL; } /* give the audio input type and ports to the HDMI encoder */ format = start ? priv->dai_id : 0; switch (format) { case AFMT_I2S: port = priv->ports[0]; break; default: case AFMT_SPDIF: port = priv->ports[1]; break; } tda998x_audio_update(priv->i2c_client, format, port); return 0; } static int tda_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct tda_priv *priv = snd_soc_codec_get_drvdata(dai->codec); u8 *eld = NULL; static unsigned rates_mask[] = { SNDRV_PCM_RATE_32000, SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_48000, SNDRV_PCM_RATE_88200, SNDRV_PCM_RATE_96000, SNDRV_PCM_RATE_176400, SNDRV_PCM_RATE_192000, }; /* memorize the used DAI */ priv->dai_id = dai->id; /* get the ELD from the tda998x driver */ if (!priv->i2c_client) tda_get_encoder(priv); if (priv->i2c_client) eld = tda998x_audio_get_eld(priv->i2c_client); /* limit the hw params from the ELD (EDID) */ if (eld) { struct snd_soc_dai_driver *dai_drv = dai->driver; struct snd_soc_pcm_stream *stream = &dai_drv->playback; u8 *sad; int sad_count; unsigned eld_ver, mnl, rates, rate_mask, i; unsigned max_channels; eld_ver = eld[0] >> 3; if (eld_ver != 2 && eld_ver != 31) return 0; mnl = eld[4] & 0x1f; if (mnl > 16) return 0; sad_count = eld[5] >> 4; sad = eld + 20 + mnl; /* Start from the basic audio settings */ max_channels = 2; rates = 0; while (sad_count--) { switch (sad[0] & 0x78) { case 0x08: /* PCM */ max_channels = max(max_channels, (sad[0] & 7) + 1u); rates |= sad[1]; break; } sad += 3; } for (rate_mask = i = 0; i < ARRAY_SIZE(rates_mask); i++) if (rates & 1 << i) rate_mask |= rates_mask[i]; /* change the snd_soc_pcm_stream values of the driver */ stream->rates = rate_mask; stream->channels_max = max_channels; } /* start the TDA998x audio */ return tda_start_stop(priv, 1); } static void tda_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct tda_priv *priv = snd_soc_codec_get_drvdata(dai->codec); priv->dai_id = 0; tda_start_stop(priv, 0); } static const struct snd_soc_dai_ops tda_ops = { .startup = tda_startup, .shutdown = tda_shutdown, }; static const struct snd_soc_dai_driver tda998x_dai[] = { { .name = "i2s-hifi", .id = AFMT_I2S, .playback = { .stream_name = "HDMI I2S Playback", .channels_min = 1, .channels_max = 8, .rates = SNDRV_PCM_RATE_CONTINUOUS, .rate_min = 5512, .rate_max = 192000, .formats = TDA998X_FORMATS, }, .ops = &tda_ops, }, { .name = "spdif-hifi", .id = AFMT_SPDIF, .playback = { .stream_name = "HDMI SPDIF Playback", .channels_min = 1, .channels_max = 2, .rates = SNDRV_PCM_RATE_CONTINUOUS, .rate_min = 22050, .rate_max = 192000, .formats = TDA998X_FORMATS, }, .ops = &tda_ops, }, }; static const struct snd_soc_dapm_widget tda_widgets[] = { SND_SOC_DAPM_OUTPUT("hdmi-out"), }; static const struct snd_soc_dapm_route tda_routes[] = { { "hdmi-out", NULL, "HDMI I2S Playback" }, { "hdmi-out", NULL, "HDMI SPDIF Playback" }, }; static int tda_probe(struct snd_soc_codec *codec) { struct tda_priv *priv; struct device_node *np; int i, ret; priv = devm_kzalloc(codec->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; snd_soc_codec_set_drvdata(codec, priv); priv->codec = codec; /* get the audio input ports (I2s and S/PDIF) */ np = codec->dev->of_node; for (i = 0; i < 2; i++) { ret = of_property_read_u32_index(np, "audio-ports", i, &priv->ports[i]); if (ret) { if (i == 0) dev_err(codec->dev, "bad or missing audio-ports\n"); break; } } return 0; } static const struct snd_soc_codec_driver soc_codec_tda998x = { .probe = tda_probe, .dapm_widgets = tda_widgets, .num_dapm_widgets = ARRAY_SIZE(tda_widgets), .dapm_routes = tda_routes, .num_dapm_routes = ARRAY_SIZE(tda_routes), }; static int tda998x_dev_probe(struct platform_device *pdev) { struct snd_soc_dai_driver *dai_drv; /* copy the DAI driver to a writable area */ dai_drv = devm_kzalloc(&pdev->dev, sizeof(tda998x_dai), GFP_KERNEL); if (!dai_drv) return -ENOMEM; memcpy(dai_drv, tda998x_dai, sizeof(tda998x_dai)); return snd_soc_register_codec(&pdev->dev, &soc_codec_tda998x, dai_drv, ARRAY_SIZE(tda998x_dai)); } static int tda998x_dev_remove(struct platform_device *pdev) { snd_soc_unregister_codec(&pdev->dev); return 0; } static const struct of_device_id tda998x_codec_ids[] = { { .compatible = "nxp,tda998x-codec", }, { } }; MODULE_DEVICE_TABLE(of, tda998x_codec_ids); static struct platform_driver tda998x_driver = { .probe = tda998x_dev_probe, .remove = tda998x_dev_remove, .driver = { .name = "tda998x-codec", .owner = THIS_MODULE, .of_match_table = tda998x_codec_ids, }, }; module_platform_driver(tda998x_driver); MODULE_AUTHOR("Jean-Francois Moine"); MODULE_DESCRIPTION("TDA998x codec driver"); MODULE_LICENSE("GPL"); -------------------8<---------------- -- Ken ar c'henta? | ** Breizh ha Linux atav! ** Jef | http://moinejf.free.fr/