From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jean-Francois Moine Subject: [PATCH] ASoC: generic: add generic compound card with DT support Date: Tue, 31 Dec 2013 11:31:38 +0100 Message-ID: <20131231113138.102044cf@armhf> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from smtp6-g21.free.fr (smtp6-g21.free.fr [212.27.42.6]) by alsa0.perex.cz (Postfix) with ESMTP id 56BE92619D0 for ; Tue, 31 Dec 2013 11:32:33 +0100 (CET) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: alsa-devel-bounces@alsa-project.org Sender: alsa-devel-bounces@alsa-project.org To: Liam Girdwood , Lars-Peter Clausen Cc: alsa-devel@alsa-project.org, Mark Brown , linux-kernel@vger.kernel.org List-Id: alsa-devel@alsa-project.org U29tZSBhdWRpbyBjYXJkcyBhcmUgYnVpbHQgZnJvbSBkaWZmZXJlbnQgaGFyZHdhcmUgY29tcG9u ZW50cy4KV2hlbiBzdWNoIGNvbXBvdW5kIGNhcmRzIGRvbid0IG5lZWQgc3BlY2lmaWMgY29kZSwg dGhpcyBkcml2ZXIgY3JlYXRlcwp0aGVtIHdpdGggdGhlIHJlcXVpcmVkIERBSSBsaW5rcyBhbmQg cm91dGVzIGZyb20gYSBEVC4KClNpZ25lZC1vZmYtYnk6IEplYW4tRnJhbmNvaXMgTW9pbmUgPG1v aW5lamZAZnJlZS5mcj4KLS0tClRoaXMgY29kZSB3YXMgZmlyc3QgZGV2ZWxvcHBlZCBvbiB0aGUg Z2VuZXJpYyBzaW1wbGUgY2FyZCwgYnV0IGl0cwpyZWNlbnQgRFQgZXh0ZW5zaW9uIGNhbm5vdCBi ZSBlYXNpbHkgZXh0ZW5kZWQgYWdhaW4gdG8gc3VwcG9ydCBjb21wb3VuZApjYXJkcyBhcyB0aGUg b25lIGluIHRoZSBDdWJveC4KTm90ZSBhbHNvIHRoYXQgdGhlIGV4YW1wbGUgcmVsaWVzIG9uIGEg cHJvcG9zZWQgcGF0Y2ggb2YgbWluZSBhaW1pbmcgdG8KcmVuZGVyIHRoZSBjb2RlYyBuYW1lIC8g T0Ygbm9kZSBvcHRpb25hbCBpbiBEQUkgbGlua3MKKGh0dHA6Ly9tYWlsbWFuLmFsc2EtcHJvamVj dC5vcmcvcGlwZXJtYWlsL2Fsc2EtZGV2ZWwvMjAxMy1EZWNlbWJlci8wNzAwODIuaHRtbCkuCi0t LQogLi4uL2RldmljZXRyZWUvYmluZGluZ3Mvc291bmQvY29tcG91bmQtY2FyZC50eHQgfCAgOTUg KysrKysrKysrKysrCiBzb3VuZC9zb2MvZ2VuZXJpYy9LY29uZmlnICAgICAgICAgICAgICAgICAg ICAgICB8ICAgNiArCiBzb3VuZC9zb2MvZ2VuZXJpYy9NYWtlZmlsZSAgICAgICAgICAgICAgICAg ICAgICB8ICAgMiArCiBzb3VuZC9zb2MvZ2VuZXJpYy9jb21wb3VuZC1jYXJkLmMgICAgICAgICAg ICAgICB8IDI0NyArKysrKysrKysrKysrKysrKysrKysrKysrCiA0IGZpbGUgY2hhbmdlZCwgMzUw IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmlu ZGluZ3Mvc291bmQvY29tcG91bmQtY2FyZC50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUv YmluZGluZ3Mvc291bmQvY29tcG91bmQtY2FyZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uNTU0YTc5NgotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vZGV2 aWNldHJlZS9iaW5kaW5ncy9zb3VuZC9jb21wb3VuZC1jYXJkLnR4dApAQCAtMCwwICsxLDk1IEBA CitEZXZpY2UtVHJlZSBiaW5kaW5ncyBmb3IgY29tcG91bmQgYXVkaW8gY2FyZAorCitDb21wb3Vu ZCBhdWRpbyBjYXJkIGRlc2NyaWJlcyB0aGUgbGlua3MgYmV0d2VlbiB0aGUgZGlmZmVyZW50IHBh cnRzCitvZiBhbiBhdWRpbyBjYXJkIGJ1aWx0IGZyb20gZGlmZmVyZW50IGhhcmR3YXJlIGNvbXBv bmVudHMuCisKK1JlcXVpcmVkIHByb3BlcnRpZXM6CisgIC0gY29tcGF0aWJsZTogc2hvdWxkIGJl ICJjb21wb3VuZC1hdWRpby1jYXJkIgorICAtIGF1ZGlvLWNvbnRyb2xsZXI6IHBoYW5kbGUgb2Yg dGhlIGF1ZGlvIGNvbnRyb2xsZXIKKworT3B0aW9uYWwgcHJvcGVydGllczoKKyAgLSByb3V0ZXM6 IGxpc3Qgb2YgY291cGxlIG9mIHN0cmluZ3MgKHNpbmssIHNvdXJjZSkKKworUmVxdWlyZWQgc3Vi bm9kZXM6CisgIC0gbGluazogREFJIGxpbmsgc3Vibm9kZQorCUF0IGxlYXN0IG9uZSBsaW5rIG11 c3QgYmUgc3BlY2lmaWVkLgorCitSZXF1aXJlZCBsaW5rIHN1Ym5vZGUgcHJvcGVydGllczoKKyAg LSBsaW5rLW5hbWU6IG5hbWVzIG9mIHRoZSBEQUkgbGluayBhbmQgb2YgdGhlIHN0cmVhbQorICAt IGNwdS1kYWktbmFtZTogbmFtZSBvZiB0aGUgQ1BVIG9yIENPREVDIERBSQorCQlBbiBlbXB0eSBz dHJpbmcgaW5kaWNhdGVzIHRoYXQgdGhlIENQVSBEQUkgaXMKKwkJdGhlIHNhbWUgYXMgdGhlIGF1 ZGlvIGNvbnRyb2xsZXIuCisgIC0gY29kZWMtZGFpLW5hbWU6IG5hbWUgb2YgdGhlIENPREVDIERB SQorCitPcHRpb25hbCBsaW5rIHN1Ym5vZGUgcHJvcGVydGllczoKKyAgLSBhdWRpby1jb2RlYyBv ciBjb2RlYy1uYW1lOiBwaGFuZGxlIG9yIG5hbWUgb2YgdGhlIENPREVDCisJCWluIGNhc2UgdGhl IGNvZGVjLWRhaS1uYW1lIGlzIG5vdCB1bmlxdWUKKyAgLSBmb3JtYXQ6IERBSSBmb3JtYXQuIE9u ZSBvZjoKKwkJImkycyIsICJyaWdodF9qIiwgImxlZnRfaiIgLCAiZHNwX2EiCisJCSJkc3BfYiIs ICJhYzk3IiwgInBkbSIsICJtc2IiLCAibHNiIgorICAtIGZyb250LWVuZCBvciBiYWNrLWVuZDog cHJlc2VudCBpZiB0aGUgREFJIGxpbmsgZGVzY3JpYmVzIHJlc3AuCisJCWEgZnJvbnQtZW5kIENQ VSBEQUkgb3IgYSBiYWNrLWVuZCBDT0RFQyBEQUkKKyAgLSBwbGF5YmFjayBvciBjYXB0dXJlOiBw cmVzZW50IGlmIHRoZSBEQUkgbGluayBpcyB1c2VkIGZvcgorCQlwbGF5YmFjayBvciBjYXB0dXJl IG9ubHkKKworRXhhbXBsZSBub2RlOgorCitUaGUgYXVkaW8gc3Vic3lzdGVtIGZvdW5kIGluIHRo ZSBTb2xpZFJ1biBDdWJveCBpcyBjb21wb3NlZCBvZjoKKworLSBhbiBhdWRpbyBjb250cm9sbGVy IHdoaWNoIG91dHB1dHMgcGxheWJhY2sgc3RyZWFtcyBvbiBlaXRoZXIgb25lIG9yIGJvdGgKKyAg b2YgSTJTIGFuZCBTL1BESUYsCisKKy0gYSBIRE1JIHRyYW5zbWl0dGVyIHdoaWNoIGNhbiBnZXQg aXRzIGlucHV0IGZyb20gZWl0aGVyIEkyUyBvciBTL1BESUYsCisKKy0gYW4gb3B0aWNhbCBTL1BE SUYgY29ubmVjdG9yLgorCisJc291bmQgeworCQljb21wYXRpYmxlID0gImNvbXBvdW5kLWF1ZGlv LWNhcmQiOworCQlhdWRpby1jb250cm9sbGVyID0gPCZhdWRpbzE+OworCQlyb3V0ZXMgPQorCQkJ IkkyUyBQbGF5YmFjayIsICAgIlN5c3RlbSBQbGF5YmFjayIsCisJCQkiU1BESUYgUGxheWJhY2si LCAiU3lzdGVtIFBsYXliYWNrIiwKKwkJCSJoZG1pLW91dCIsCSJJMlMgUGxheWJhY2siLAorCQkJ ImhkbWktb3V0IiwJIlNQRElGIFBsYXliYWNrIiwKKwkJCSJzcGRpZi1vdXQiLAkiU1BESUYgUGxh eWJhY2siOworCQlsaW5rQDAgeworCQkJbGluay1uYW1lID0gIlN5c3RlbSBhdWRpbyI7CisJCQlm cm9udC1lbmQ7CisJCQljcHUtZGFpLW5hbWUgPSAibXZlYnUtYXVkaW8iOworCQkJY29kZWMtZGFp LW5hbWUgPSAic25kLXNvYy1kdW1teS1kYWkiOworCQkJZm9ybWF0ID0gImkycyI7CisJCQlwbGF5 YmFjazsKKwkJfTsKKwkJbGlua0AxIHsKKwkJCWxpbmstbmFtZSA9ICJoZG1pLWkycyI7CisJCQli YWNrLWVuZDsKKwkJCWNwdS1kYWktbmFtZSA9ICJpMnMiOworCQkJY29kZWMtZGFpLW5hbWUgPSAi aTJzLWhpZmkiOworCQkJcGxheWJhY2s7CisJCX07CisJCWxpbmtAMiB7CisJCQlsaW5rLW5hbWUg PSAiaGRtaS1zcGRpZiI7CisJCQliYWNrLWVuZDsKKwkJCWNwdS1kYWktbmFtZSA9ICJzcGRpZiI7 CisJCQljb2RlYy1kYWktbmFtZSA9ICJzcGRpZi1oaWZpIjsKKwkJCXBsYXliYWNrOworCQl9Owor CQlsaW5rQDMgeworCQkJbGluay1uYW1lID0gInNwZGlmIjsKKwkJCWJhY2stZW5kOworCQkJY3B1 LWRhaS1uYW1lID0gInNwZGlmIjsKKwkJCWNvZGVjLWRhaS1uYW1lID0gImRpdC1oaWZpIjsKKwkJ CXBsYXliYWNrOworCQl9OworCX07CisKKwloZG1pX2NvZGVjOiBoZG1pLWNvZGVjIHsKKwkJY29t cGF0aWJsZSA9ICJueHAsdGRhOTk4eC1jb2RlYyI7CisJCWF1ZGlvLXBvcnRzID0gPDB4MDM+LCA8 MHgwND47CisJfTsKKworCXNwZGlmX2NvZGVjOiBzcGRpZi1jb2RlYyB7CisJCWNvbXBhdGlibGUg PSAibGludXgsc3BkaWYtZGl0IjsKKwl9OworCisKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9nZW5l cmljL0tjb25maWcgYi9zb3VuZC9zb2MvZ2VuZXJpYy9LY29uZmlnCmluZGV4IDYxMGY2MTIuLmYy Njc4YWUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9nZW5lcmljL0tjb25maWcKKysrIGIvc291bmQv c29jL2dlbmVyaWMvS2NvbmZpZwpAQCAtMiwzICsyLDkgQEAgY29uZmlnIFNORF9TSU1QTEVfQ0FS RAogCXRyaXN0YXRlICJBU29DIFNpbXBsZSBzb3VuZCBjYXJkIHN1cHBvcnQiCiAJaGVscAogCSAg VGhpcyBvcHRpb24gZW5hYmxlcyBnZW5lcmljIHNpbXBsZSBzb3VuZCBjYXJkIHN1cHBvcnQKKwor Y29uZmlnIFNORF9DT01QT1VORF9DQVJECisJdHJpc3RhdGUgIkFTb0MgQ29tcG91bmQgc291bmQg Y2FyZCBzdXBwb3J0IgorCWRlcGVuZHMgb24gT0YKKwloZWxwCisJICBUaGlzIG9wdGlvbiBlbmFi bGVzIHRoZSBnZW5lcmljIGNvbXBvdW5kIHNvdW5kIGNhcmQgc3VwcG9ydC4KZGlmZiAtLWdpdCBh L3NvdW5kL3NvYy9nZW5lcmljL01ha2VmaWxlIGIvc291bmQvc29jL2dlbmVyaWMvTWFrZWZpbGUK aW5kZXggOWMzYjI0Ni4uNDM0Y2I3OSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2dlbmVyaWMvTWFr ZWZpbGUKKysrIGIvc291bmQvc29jL2dlbmVyaWMvTWFrZWZpbGUKQEAgLTEsMyArMSw1IEBACiBz bmQtc29jLXNpbXBsZS1jYXJkLW9ianMJOj0gc2ltcGxlLWNhcmQubworc25kLXNvYy1jb21wb3Vu ZC1jYXJkLW9ianMJOj0gY29tcG91bmQtY2FyZC5vCiAKIG9iai0kKENPTkZJR19TTkRfU0lNUExF X0NBUkQpCSs9IHNuZC1zb2Mtc2ltcGxlLWNhcmQubworb2JqLSQoQ09ORklHX1NORF9DT01QT1VO RF9DQVJEKQkrPSBzbmQtc29jLWNvbXBvdW5kLWNhcmQubwpkaWZmIC0tZ2l0IGEvc291bmQvc29j L2dlbmVyaWMvY29tcG91bmQtY2FyZC5jIGIvc291bmQvc29jL2dlbmVyaWMvY29tcG91bmQtY2Fy ZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY1N2UxNTkKLS0tIC9kZXYv bnVsbAorKysgYi9zb3VuZC9zb2MvZ2VuZXJpYy9jb21wb3VuZC1jYXJkLmMKQEAgLTAsMCArMSwy NDcgQEAKKy8qCisgKiBBU29DIGNvbXBvdW5kIHNvdW5kIGNhcmQgc3VwcG9ydAorICoKKyAqIENv cHlyaWdodCAoQykgMjAxMyBKZWFuLUZyYW5jb2lzIE1vaW5lIDxtb2luZWpmQGZyZWUuZnI+Cisg KgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2 aWNlLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4K KyNpbmNsdWRlIDxzb3VuZC9zb2MuaD4KKworLy8gbGluayB0eXBlcworI2RlZmluZSBMSU5LX0ZF IDAJLyogZnJvbnQtZW5kICovCisjZGVmaW5lIExJTktfQkUgMQkvKiBiYWNrLWVuZCAqLworI2Rl ZmluZSBMSU5LX0NDIDIJLyogKGNvbnRyb2xsZXIgb3IgY29kZWMpIHRvIGNvZGVjICovCisKK3N0 cnVjdCBjb21wb3VuZF9jYXJkX2RhdGEgeworCXN0cnVjdCBzbmRfc29jX2NhcmQgc25kX2NhcmQ7 CisJc3RydWN0IHNuZF9zb2NfZGFpX2xpbmsgKnNuZF9saW5rczsKK307CisKKy8qIGdldCBhIERB SSBsaW5rICovCitzdGF0aWMgaW50IGdldF9saW5rKHN0cnVjdCBjb21wb3VuZF9jYXJkX2RhdGEg KnByaXYsCisJCQlzdHJ1Y3Qgc25kX3NvY19kYWlfbGluayAqbGluaywKKwkJCXN0cnVjdCBkZXZp Y2Vfbm9kZSAqY3RybF9ucCwKKwkJCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApCit7CisJc3RydWN0 IGRldmljZV9ub2RlICpjb2RlY19ucDsKKwljb25zdCBjaGFyICpjcHVfZGFpX25hbWU7CisJaW50 IHR5cGUsIHJldDsKKworCS8qIG9wdGlvbmFsIGxpbmstbmFtZSAqLworCW9mX3Byb3BlcnR5X3Jl YWRfc3RyaW5nKG5wLCAibGluay1uYW1lIiwgJmxpbmstPm5hbWUpOworCWxpbmstPnN0cmVhbV9u YW1lID0gbGluay0+bmFtZTsKKworCS8qIGxpbmsgdHlwZSAqLworCWlmIChvZl9wcm9wZXJ0eV9y ZWFkX2Jvb2wobnAsICJmcm9udC1lbmQiKSkKKwkJdHlwZSA9IExJTktfRkU7CisJZWxzZSBpZiAo b2ZfcHJvcGVydHlfcmVhZF9ib29sKG5wLCAiYmFjay1lbmQiKSkKKwkJdHlwZSA9IExJTktfQkU7 CisJZWxzZQorCQl0eXBlID0gTElOS19DQzsKKworCS8qIGNwdS1kYWktbmFtZSAqLworCXJldCA9 IG9mX3Byb3BlcnR5X3JlYWRfc3RyaW5nKG5wLCAiY3B1LWRhaS1uYW1lIiwKKwkJCQkJJmNwdV9k YWlfbmFtZSk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKHByaXYtPnNuZF9jYXJkLmRldiwKKwkJ CSJObyB2YWxpZCBjcHUtZGFpLW5hbWUgZm91bmRcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKwor CS8qIGFuIGVtcHR5IGNwdS1kYWktbmFtZSBmb3JjZXMgdGhlIGF1ZGlvLWNvbnRyb2xsZXIgKi8K KwlpZiAoY3B1X2RhaV9uYW1lWzBdID09ICdcMCcpCisJCWxpbmstPmNwdV9vZl9ub2RlID0gY3Ry bF9ucDsKKwllbHNlCisJCWxpbmstPmNwdV9kYWlfbmFtZSA9IGNwdV9kYWlfbmFtZTsKKworCS8q IHRoZSBjb2RlYyBtYXkgYmUgb21pdHRlZCBvciBzcGVjaWZpZWQgYnkgbmFtZSBvciBwaGFuZGxl ICovCisJY29kZWNfbnAgPSBvZl9wYXJzZV9waGFuZGxlKG5wLCAiYXVkaW8tY29kZWMiLCAwKTsK KwlpZiAoY29kZWNfbnApCisJCWxpbmstPmNvZGVjX29mX25vZGUgPSBjb2RlY19ucDsKKwllbHNl CisJCW9mX3Byb3BlcnR5X3JlYWRfc3RyaW5nKG5wLCAiY29kZWMtbmFtZSIsCisJCQkJCSZsaW5r LT5jb2RlY19uYW1lKTsKKworCS8qIGNvZGVjLWRhaS1uYW1lICovCisJcmV0ID0gb2ZfcHJvcGVy dHlfcmVhZF9zdHJpbmcobnAsICJjb2RlYy1kYWktbmFtZSIsCisJCQkJCSZsaW5rLT5jb2RlY19k YWlfbmFtZSk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKHByaXYtPnNuZF9jYXJkLmRldiwKKwkJ CSJGYWlsZWQgdG8gcGFyc2UgY29kZWMtZGFpLW5hbWVcbiIpOworCQlyZXR1cm4gcmV0OworCX0K KworCWlmICh0eXBlID09IExJTktfQkUpIHsKKwkJbGluay0+bm9fcGNtID0gMTsKKwkJLyogZG9u J3Qgc2V0IHRoZSBwbGF0Zm9ybSwgb3RoZXJ3aXNlLCB0aGUgcGxhdGZvcm0gZnVuY3Rpb25zCisJ CSAqIGFyZSBjYWxsZWQgbWFueSB0aW1lcyAqLworCX0gZWxzZSB7CisJCWxpbmstPnBsYXRmb3Jt X29mX25vZGUgPSBjdHJsX25wOworCQlpZiAodHlwZSA9PSBMSU5LX0ZFKQorCQkJbGluay0+ZHlu YW1pYyA9IDE7CisJfQorCisJLyogREFJIGZvcm1hdCAqLworCWxpbmstPmRhaV9mbXQgPSBzbmRf c29jX29mX3BhcnNlX2RhaWZtdChucCwgTlVMTCkgJgorCQkJCVNORF9TT0NfREFJRk1UX0ZPUk1B VF9NQVNLOworCisJaWYgKG9mX3Byb3BlcnR5X3JlYWRfYm9vbChucCwgInBsYXliYWNrIikpCisJ CWxpbmstPnBsYXliYWNrX29ubHkgPSAxOworCWVsc2UgaWYgKG9mX3Byb3BlcnR5X3JlYWRfYm9v bChucCwgImNhcHR1cmUiKSkKKwkJbGluay0+Y2FwdHVyZV9vbmx5ID0gMTsKKworCXJldHVybiAw OworfQorCitzdGF0aWMgaW50IGNvbXBvdW5kX2NhcmRfZHRfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldiwKKwkJc3RydWN0IGNvbXBvdW5kX2NhcmRfZGF0YSAqcHJpdikKK3sKKwlz dHJ1Y3QgZGV2aWNlX25vZGUgKm5wLCAqY3RybF9ucCwgKmxpbmtfbnA7CisJc3RydWN0IHNuZF9z b2NfZGFpX2xpbmsgKmxpbms7CisJaW50IHJldCwgbnVtX2xpbmtzOworCisJbnAgPSBwZGV2LT5k ZXYub2Zfbm9kZTsKKworCWN0cmxfbnAgPSBvZl9wYXJzZV9waGFuZGxlKG5wLCAiYXVkaW8tY29u dHJvbGxlciIsIDApOworCWlmICghY3RybF9ucCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJO byB2YWxpZCBhdWRpby1jb250cm9sbGVyIHBoYW5kbGUgZm91bmRcbiIpOworCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwkvKiBnZXQgdGhlIG9wdGlvbmFsIHJvdXRlcyAqLworCWlmIChvZl9wcm9w ZXJ0eV9jb3VudF9zdHJpbmdzKG5wLCAicm91dGVzIikpCisJCXNuZF9zb2Nfb2ZfcGFyc2VfYXVk aW9fcm91dGluZygmcHJpdi0+c25kX2NhcmQsICJyb3V0ZXMiKTsKKworCXByaXYtPnNuZF9jYXJk Lm5hbWUgPSAiQVNvQyBjb21wb3VuZCBzb3VuZCBjYXJkIjsKKworCS8qIGNoZWNrIHRoZSBudW1i ZXIgb2YgbGlua3MgKi8KKwludW1fbGlua3MgPSAwOworCWZvcl9lYWNoX2NoaWxkX29mX25vZGUo bnAsIGxpbmtfbnApCisJCW51bV9saW5rcysrOworCisJaWYgKG51bV9saW5rcyA9PSAwKSB7CisJ CWRldl9lcnIoJnBkZXYtPmRldiwgIk5vIERBSSBsaW5rXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7 CisJfQorCisJbGluayA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LAorCQkJCXNpemVvZihzdHJ1 Y3Qgc25kX3NvY19kYWlfbGluaykgKiBudW1fbGlua3MsCisJCQkJR0ZQX0tFUk5FTCk7CisJaWYg KCFsaW5rKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZXJyOworCX0KKwlwcml2LT5zbmRf bGlua3MgPSBsaW5rOworCXByaXYtPnNuZF9jYXJkLm51bV9saW5rcyA9IG51bV9saW5rczsKKwlm b3JfZWFjaF9jaGlsZF9vZl9ub2RlKG5wLCBsaW5rX25wKSB7CisJCXJldCA9IGdldF9saW5rKHBy aXYsIGxpbmssIGN0cmxfbnAsIGxpbmtfbnApOworCQlpZiAocmV0KQorCQkJZ290byBlcnI7CisJ CWxpbmsrKzsKKwl9CisKKwlyZXR1cm4gMDsKKworZXJyOgorCWlmIChsaW5rX25wKQorCQlvZl9u b2RlX3B1dChsaW5rX25wKTsKKwlpZiAoY3RybF9ucCkKKwkJb2Zfbm9kZV9wdXQoY3RybF9ucCk7 CisJZm9yIChudW1fbGlua3MgPSAwLCBsaW5rID0gcHJpdi0+c25kX2xpbmtzOworCSAgICAgbnVt X2xpbmtzIDwgcHJpdi0+c25kX2NhcmQubnVtX2xpbmtzOworCSAgICAgbnVtX2xpbmtzKyssIGxp bmsrKykgeworCQlzdHJ1Y3QgZGV2aWNlX25vZGUgKmNvZGVjX25wOworCisJCWNvZGVjX25wID0g KHN0cnVjdCBkZXZpY2Vfbm9kZSAqKSBsaW5rLT5jb2RlY19vZl9ub2RlOworCQlpZiAoIWNvZGVj X25wKQorCQkJYnJlYWs7CisJCW9mX25vZGVfcHV0KGNvZGVjX25wKTsKKwl9CisJcmV0dXJuIHJl dDsKK30KKworc3RhdGljIGludCBjb21wb3VuZF9jYXJkX2R0X3JlbW92ZShzdHJ1Y3QgcGxhdGZv cm1fZGV2aWNlICpwZGV2LAorCQlzdHJ1Y3QgY29tcG91bmRfY2FyZF9kYXRhICpwcml2KQorewor CXN0cnVjdCBkZXZpY2Vfbm9kZSAqY29kZWNfbnA7CisJc3RydWN0IHNuZF9zb2NfZGFpX2xpbmsg Kmxpbms7CisJaW50IG51bV9saW5rczsKKworCWlmICghcHJpdi0+c25kX2xpbmtzKQorCQlyZXR1 cm4gMDsKKwlpZiAocHJpdi0+c25kX2xpbmtzLT5wbGF0Zm9ybV9vZl9ub2RlKQorCQlvZl9ub2Rl X3B1dCgoc3RydWN0IGRldmljZV9ub2RlICopCisJCQkJcHJpdi0+c25kX2xpbmtzLT5wbGF0Zm9y bV9vZl9ub2RlKTsKKwlmb3IgKG51bV9saW5rcyA9IDAsIGxpbmsgPSBwcml2LT5zbmRfbGlua3M7 CisJICAgICBudW1fbGlua3MgPCBwcml2LT5zbmRfY2FyZC5udW1fbGlua3M7CisJICAgICBudW1f bGlua3MrKywgbGluaysrKSB7CisJCWNvZGVjX25wID0gKHN0cnVjdCBkZXZpY2Vfbm9kZSAqKSBs aW5rLT5jb2RlY19vZl9ub2RlOworCQlpZiAoIWNvZGVjX25wKQorCQkJYnJlYWs7CisJCW9mX25v ZGVfcHV0KGNvZGVjX25wKTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY29tcG91 bmRfY2FyZF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBj b21wb3VuZF9jYXJkX2RhdGEgKnByaXY7CisJaW50IHJldDsKKworCXByaXYgPSBkZXZtX2t6YWxs b2MoJnBkZXYtPmRldiwgc2l6ZW9mICpwcml2LCBHRlBfS0VSTkVMKTsKKwlpZiAoIXByaXYpCisJ CXJldHVybiAtRU5PTUVNOworCisJcHJpdi0+c25kX2NhcmQub3duZXIgPSBUSElTX01PRFVMRTsK Kwlwcml2LT5zbmRfY2FyZC5kZXYgPSAmcGRldi0+ZGV2OworCisJcmV0ID0gY29tcG91bmRfY2Fy ZF9kdF9wcm9iZShwZGV2LCBwcml2KTsKKworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlw cml2LT5zbmRfY2FyZC5kYWlfbGluayA9IHByaXYtPnNuZF9saW5rczsKKworCWRldl9zZXRfZHJ2 ZGF0YSgmcGRldi0+ZGV2LCBwcml2KTsKKworCXJldHVybiBzbmRfc29jX3JlZ2lzdGVyX2NhcmQo JnByaXYtPnNuZF9jYXJkKTsKK30KKworc3RhdGljIGludCBjb21wb3VuZF9jYXJkX3JlbW92ZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBjb21wb3VuZF9jYXJkX2Rh dGEgKnByaXYgPSBkZXZfZ2V0X2RydmRhdGEoJnBkZXYtPmRldik7CisgCisJc25kX3NvY191bnJl Z2lzdGVyX2NhcmQoJnByaXYtPnNuZF9jYXJkKTsKKworCWNvbXBvdW5kX2NhcmRfZHRfcmVtb3Zl KHBkZXYsIHByaXYpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2Zf ZGV2aWNlX2lkIGNvbXBvdW5kX2NhcmRfb2ZfZGV2X2lkc1tdID0geworCXsgLmNvbXBhdGlibGUg PSAiY29tcG91bmQtYXVkaW8tY2FyZCIsIH0sCisJe30KK307CitNT0RVTEVfREVWSUNFX1RBQkxF KG9mLCBjb21wb3VuZF9jYXJkX29mX2Rldl9pZHMpOworCitzdGF0aWMgc3RydWN0IHBsYXRmb3Jt X2RyaXZlciBjb21wb3VuZF9jYXJkID0geworCS5kcml2ZXIgPSB7CisJCS5uYW1lCT0gImFzb2Mt Y29tcG91bmQtY2FyZCIsCisJCS5vd25lciA9IFRISVNfTU9EVUxFLAorCQkub2ZfbWF0Y2hfdGFi bGUgPSBjb21wb3VuZF9jYXJkX29mX2Rldl9pZHMsCisJfSwKKwkucHJvYmUJCT0gY29tcG91bmRf Y2FyZF9wcm9iZSwKKwkucmVtb3ZlCQk9IGNvbXBvdW5kX2NhcmRfcmVtb3ZlLAorfTsKKworbW9k dWxlX3BsYXRmb3JtX2RyaXZlcihjb21wb3VuZF9jYXJkKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQ TCIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJBU29DIENvbXBvdW5kIFNvdW5kIENhcmQiKTsKK01P RFVMRV9BVVRIT1IoIkplYW4tRnJhbmNvaXMgTW9pbmUgPG1vaW5lamZAZnJlZS5mcj4iKTsKCi0t IApLZW4gYXIgYydoZW50YcOxCXwJICAgICAgKiogQnJlaXpoIGhhIExpbnV4IGF0YXYhICoqCkpl ZgkJfAkJaHR0cDovL21vaW5lamYuZnJlZS5mci8KX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KQWxzYS1kZXZlbCBtYWlsaW5nIGxpc3QKQWxzYS1kZXZlbEBh bHNhLXByb2plY3Qub3JnCmh0dHA6Ly9tYWlsbWFuLmFsc2EtcHJvamVjdC5vcmcvbWFpbG1hbi9s aXN0aW5mby9hbHNhLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752665Ab3LaKck (ORCPT ); Tue, 31 Dec 2013 05:32:40 -0500 Received: from smtp6-g21.free.fr ([212.27.42.6]:34543 "EHLO smtp6-g21.free.fr" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752254Ab3LaKch convert rfc822-to-8bit (ORCPT ); Tue, 31 Dec 2013 05:32:37 -0500 Date: Tue, 31 Dec 2013 11:31:38 +0100 From: Jean-Francois Moine To: Liam Girdwood , Lars-Peter Clausen Cc: alsa-devel@alsa-project.org, Mark Brown , linux-kernel@vger.kernel.org Subject: [PATCH] ASoC: generic: add generic compound card with DT support Message-ID: <20131231113138.102044cf@armhf> X-Mailer: Claws Mail 3.9.3 (GTK+ 2.24.22; arm-unknown-linux-gnueabihf) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Some audio cards are built from different hardware components. When such compound cards don't need specific code, this driver creates them with the required DAI links and routes from a DT. Signed-off-by: Jean-Francois Moine --- This code was first developped on the generic simple card, but its recent DT extension cannot be easily extended again to support compound cards as the one in the Cubox. Note also that the example relies on a proposed patch of mine aiming to render the codec name / OF node optional in DAI links (http://mailman.alsa-project.org/pipermail/alsa-devel/2013-December/070082.html). --- .../devicetree/bindings/sound/compound-card.txt | 95 ++++++++++++ sound/soc/generic/Kconfig | 6 + sound/soc/generic/Makefile | 2 + sound/soc/generic/compound-card.c | 247 +++++++++++++++++++++++++ 4 file changed, 350 insertions(+) diff --git a/Documentation/devicetree/bindings/sound/compound-card.txt b/Documentation/devicetree/bindings/sound/compound-card.txt new file mode 100644 index 0000000..554a796 --- /dev/null +++ b/Documentation/devicetree/bindings/sound/compound-card.txt @@ -0,0 +1,95 @@ +Device-Tree bindings for compound audio card + +Compound audio card describes the links between the different parts +of an audio card built from different hardware components. + +Required properties: + - compatible: should be "compound-audio-card" + - audio-controller: phandle of the audio controller + +Optional properties: + - routes: list of couple of strings (sink, source) + +Required subnodes: + - link: DAI link subnode + At least one link must be specified. + +Required link subnode properties: + - link-name: names of the DAI link and of the stream + - cpu-dai-name: name of the CPU or CODEC DAI + An empty string indicates that the CPU DAI is + the same as the audio controller. + - codec-dai-name: name of the CODEC DAI + +Optional link subnode properties: + - audio-codec or codec-name: phandle or name of the CODEC + in case the codec-dai-name is not unique + - format: DAI format. One of: + "i2s", "right_j", "left_j" , "dsp_a" + "dsp_b", "ac97", "pdm", "msb", "lsb" + - front-end or back-end: present if the DAI link describes resp. + a front-end CPU DAI or a back-end CODEC DAI + - playback or capture: present if the DAI link is used for + playback or capture only + +Example node: + +The audio subsystem found in the SolidRun Cubox is composed of: + +- an audio controller which outputs playback streams on either one or both + of I2S and S/PDIF, + +- a HDMI transmitter which can get its input from either I2S or S/PDIF, + +- an optical S/PDIF connector. + + sound { + compatible = "compound-audio-card"; + audio-controller = <&audio1>; + routes = + "I2S Playback", "System Playback", + "SPDIF Playback", "System Playback", + "hdmi-out", "I2S Playback", + "hdmi-out", "SPDIF Playback", + "spdif-out", "SPDIF Playback"; + link@0 { + link-name = "System audio"; + front-end; + cpu-dai-name = "mvebu-audio"; + codec-dai-name = "snd-soc-dummy-dai"; + format = "i2s"; + playback; + }; + link@1 { + link-name = "hdmi-i2s"; + back-end; + cpu-dai-name = "i2s"; + codec-dai-name = "i2s-hifi"; + playback; + }; + link@2 { + link-name = "hdmi-spdif"; + back-end; + cpu-dai-name = "spdif"; + codec-dai-name = "spdif-hifi"; + playback; + }; + link@3 { + link-name = "spdif"; + back-end; + cpu-dai-name = "spdif"; + codec-dai-name = "dit-hifi"; + playback; + }; + }; + + hdmi_codec: hdmi-codec { + compatible = "nxp,tda998x-codec"; + audio-ports = <0x03>, <0x04>; + }; + + spdif_codec: spdif-codec { + compatible = "linux,spdif-dit"; + }; + + diff --git a/sound/soc/generic/Kconfig b/sound/soc/generic/Kconfig index 610f612..f2678ae 100644 --- a/sound/soc/generic/Kconfig +++ b/sound/soc/generic/Kconfig @@ -2,3 +2,9 @@ config SND_SIMPLE_CARD tristate "ASoC Simple sound card support" help This option enables generic simple sound card support + +config SND_COMPOUND_CARD + tristate "ASoC Compound sound card support" + depends on OF + help + This option enables the generic compound sound card support. diff --git a/sound/soc/generic/Makefile b/sound/soc/generic/Makefile index 9c3b246..434cb79 100644 --- a/sound/soc/generic/Makefile +++ b/sound/soc/generic/Makefile @@ -1,3 +1,5 @@ snd-soc-simple-card-objs := simple-card.o +snd-soc-compound-card-objs := compound-card.o obj-$(CONFIG_SND_SIMPLE_CARD) += snd-soc-simple-card.o +obj-$(CONFIG_SND_COMPOUND_CARD) += snd-soc-compound-card.o diff --git a/sound/soc/generic/compound-card.c b/sound/soc/generic/compound-card.c new file mode 100644 index 0000000..f57e159 --- /dev/null +++ b/sound/soc/generic/compound-card.c @@ -0,0 +1,247 @@ +/* + * ASoC compound sound card support + * + * Copyright (C) 2013 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 + +// link types +#define LINK_FE 0 /* front-end */ +#define LINK_BE 1 /* back-end */ +#define LINK_CC 2 /* (controller or codec) to codec */ + +struct compound_card_data { + struct snd_soc_card snd_card; + struct snd_soc_dai_link *snd_links; +}; + +/* get a DAI link */ +static int get_link(struct compound_card_data *priv, + struct snd_soc_dai_link *link, + struct device_node *ctrl_np, + struct device_node *np) +{ + struct device_node *codec_np; + const char *cpu_dai_name; + int type, ret; + + /* optional link-name */ + of_property_read_string(np, "link-name", &link->name); + link->stream_name = link->name; + + /* link type */ + if (of_property_read_bool(np, "front-end")) + type = LINK_FE; + else if (of_property_read_bool(np, "back-end")) + type = LINK_BE; + else + type = LINK_CC; + + /* cpu-dai-name */ + ret = of_property_read_string(np, "cpu-dai-name", + &cpu_dai_name); + if (ret) { + dev_err(priv->snd_card.dev, + "No valid cpu-dai-name found\n"); + return ret; + } + + /* an empty cpu-dai-name forces the audio-controller */ + if (cpu_dai_name[0] == '\0') + link->cpu_of_node = ctrl_np; + else + link->cpu_dai_name = cpu_dai_name; + + /* the codec may be omitted or specified by name or phandle */ + codec_np = of_parse_phandle(np, "audio-codec", 0); + if (codec_np) + link->codec_of_node = codec_np; + else + of_property_read_string(np, "codec-name", + &link->codec_name); + + /* codec-dai-name */ + ret = of_property_read_string(np, "codec-dai-name", + &link->codec_dai_name); + if (ret) { + dev_err(priv->snd_card.dev, + "Failed to parse codec-dai-name\n"); + return ret; + } + + if (type == LINK_BE) { + link->no_pcm = 1; + /* don't set the platform, otherwise, the platform functions + * are called many times */ + } else { + link->platform_of_node = ctrl_np; + if (type == LINK_FE) + link->dynamic = 1; + } + + /* DAI format */ + link->dai_fmt = snd_soc_of_parse_daifmt(np, NULL) & + SND_SOC_DAIFMT_FORMAT_MASK; + + if (of_property_read_bool(np, "playback")) + link->playback_only = 1; + else if (of_property_read_bool(np, "capture")) + link->capture_only = 1; + + return 0; +} + +static int compound_card_dt_probe(struct platform_device *pdev, + struct compound_card_data *priv) +{ + struct device_node *np, *ctrl_np, *link_np; + struct snd_soc_dai_link *link; + int ret, num_links; + + np = pdev->dev.of_node; + + ctrl_np = of_parse_phandle(np, "audio-controller", 0); + if (!ctrl_np) { + dev_err(&pdev->dev, "No valid audio-controller phandle found\n"); + return -EINVAL; + } + + /* get the optional routes */ + if (of_property_count_strings(np, "routes")) + snd_soc_of_parse_audio_routing(&priv->snd_card, "routes"); + + priv->snd_card.name = "ASoC compound sound card"; + + /* check the number of links */ + num_links = 0; + for_each_child_of_node(np, link_np) + num_links++; + + if (num_links == 0) { + dev_err(&pdev->dev, "No DAI link\n"); + return -EINVAL; + } + + link = devm_kzalloc(&pdev->dev, + sizeof(struct snd_soc_dai_link) * num_links, + GFP_KERNEL); + if (!link) { + ret = -ENOMEM; + goto err; + } + priv->snd_links = link; + priv->snd_card.num_links = num_links; + for_each_child_of_node(np, link_np) { + ret = get_link(priv, link, ctrl_np, link_np); + if (ret) + goto err; + link++; + } + + return 0; + +err: + if (link_np) + of_node_put(link_np); + if (ctrl_np) + of_node_put(ctrl_np); + for (num_links = 0, link = priv->snd_links; + num_links < priv->snd_card.num_links; + num_links++, link++) { + struct device_node *codec_np; + + codec_np = (struct device_node *) link->codec_of_node; + if (!codec_np) + break; + of_node_put(codec_np); + } + return ret; +} + +static int compound_card_dt_remove(struct platform_device *pdev, + struct compound_card_data *priv) +{ + struct device_node *codec_np; + struct snd_soc_dai_link *link; + int num_links; + + if (!priv->snd_links) + return 0; + if (priv->snd_links->platform_of_node) + of_node_put((struct device_node *) + priv->snd_links->platform_of_node); + for (num_links = 0, link = priv->snd_links; + num_links < priv->snd_card.num_links; + num_links++, link++) { + codec_np = (struct device_node *) link->codec_of_node; + if (!codec_np) + break; + of_node_put(codec_np); + } + return 0; +} + +static int compound_card_probe(struct platform_device *pdev) +{ + struct compound_card_data *priv; + int ret; + + priv = devm_kzalloc(&pdev->dev, sizeof *priv, GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->snd_card.owner = THIS_MODULE; + priv->snd_card.dev = &pdev->dev; + + ret = compound_card_dt_probe(pdev, priv); + + if (ret) + return ret; + + priv->snd_card.dai_link = priv->snd_links; + + dev_set_drvdata(&pdev->dev, priv); + + return snd_soc_register_card(&priv->snd_card); +} + +static int compound_card_remove(struct platform_device *pdev) +{ + struct compound_card_data *priv = dev_get_drvdata(&pdev->dev); + + snd_soc_unregister_card(&priv->snd_card); + + compound_card_dt_remove(pdev, priv); + + return 0; +} + +static const struct of_device_id compound_card_of_dev_ids[] = { + { .compatible = "compound-audio-card", }, + {} +}; +MODULE_DEVICE_TABLE(of, compound_card_of_dev_ids); + +static struct platform_driver compound_card = { + .driver = { + .name = "asoc-compound-card", + .owner = THIS_MODULE, + .of_match_table = compound_card_of_dev_ids, + }, + .probe = compound_card_probe, + .remove = compound_card_remove, +}; + +module_platform_driver(compound_card); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("ASoC Compound Sound Card"); +MODULE_AUTHOR("Jean-Francois Moine "); -- Ken ar c'hentañ | ** Breizh ha Linux atav! ** Jef | http://moinejf.free.fr/