From mboxrd@z Thu Jan 1 00:00:00 1970 From: Maurus Cuelenaere Subject: [PATCH 2/3] ASoC: Add SmartQ sound driver Date: Sat, 03 Jul 2010 02:46:12 +0200 Message-ID: <4c2e8856.487e0e0a.3bb5.3ec0@mx.google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-ew0-f51.google.com (mail-ew0-f51.google.com [209.85.215.51]) by alsa0.perex.cz (Postfix) with ESMTP id D5BE2103879 for ; Sat, 3 Jul 2010 02:46:15 +0200 (CEST) Received: by ewy21 with SMTP id 21so1165579ewy.38 for ; Fri, 02 Jul 2010 17:46:15 -0700 (PDT) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: alsa-devel-bounces@alsa-project.org Errors-To: alsa-devel-bounces@alsa-project.org To: alsa-devel@alsa-project.org Cc: linux-samsung-soc@vger.kernel.org, Takashi Iwai , Mark Brown , linux-arm-kernel@lists.infradead.org, Liam Girdwood List-Id: alsa-devel@alsa-project.org VGhpcyBhZGRzIHNvdW5kIHN1cHBvcnQgZm9yIHRoZSBTbWFydFEgYm9hcmQuCgpUaGUgaGFyZHdh cmUgY29uc2lzdHMgb2YgYSBTM0M2NDEwIGNvdXBsZWQgd2l0aCBhIFdNODk4NyBvdmVyIEnCslMu IFRoZSBXTTg3NTAKZHJpdmVyIGlzIHVzZWQgZm9yIGRyaXZpbmcgdGhlIFdNODk4NywgYXMgdGhl eSBhcmUgcmVnaXN0ZXIgY29tcGF0aWJsZS4KClNpZ25lZC1vZmYtYnk6IE1hdXJ1cyBDdWVsZW5h ZXJlIDxtY3VlbGVuYWVyZUBnbWFpbC5jb20+Ci0tLQogc291bmQvc29jL3MzYzI0eHgvS2NvbmZp ZyAgICAgICAgIHwgICAgNiArCiBzb3VuZC9zb2MvczNjMjR4eC9NYWtlZmlsZSAgICAgICAgfCAg ICAyICsKIHNvdW5kL3NvYy9zM2MyNHh4L3NtYXJ0cV93bTg5ODcuYyB8ICAyOTYgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCAzMDQgaW5zZXJ0 aW9ucygrKSwgMCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzb3VuZC9zb2MvczNj MjR4eC9zbWFydHFfd204OTg3LmMKCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvczNjMjR4eC9LY29u ZmlnIGIvc291bmQvc29jL3MzYzI0eHgvS2NvbmZpZwppbmRleCAyYTdjYzIyLi40ZjQ2YmEwIDEw MDY0NAotLS0gYS9zb3VuZC9zb2MvczNjMjR4eC9LY29uZmlnCisrKyBiL3NvdW5kL3NvYy9zM2My NHh4L0tjb25maWcKQEAgLTEyNSwzICsxMjUsOSBAQCBjb25maWcgU05EX1NPQ19TTURLX1dNOTcx MwogCXNlbGVjdCBTTkRfUzNDX1NPQ19BQzk3CiAJaGVscAogCSAgU2F0IFkgaWYgeW91IHdhbnQg dG8gYWRkIHN1cHBvcnQgZm9yIFNvQyBhdWRpbyBvbiB0aGUgU01ESy4KKworY29uZmlnIFNORF9T M0M2NFhYX1NPQ19TTUFSVFEKKwl0cmlzdGF0ZSAiU29DIEkyUyBBdWRpbyBzdXBwb3J0IGZvciBT bWFydFEgYm9hcmQiCisJZGVwZW5kcyBvbiBTTkRfUzNDMjRYWF9TT0MgJiYgTUFDSF9TTUFSVFEK KwlzZWxlY3QgU05EX1MzQzY0WFhfU09DX0kyUworCXNlbGVjdCBTTkRfU09DX1dNODc1MApkaWZm IC0tZ2l0IGEvc291bmQvc29jL3MzYzI0eHgvTWFrZWZpbGUgYi9zb3VuZC9zb2MvczNjMjR4eC9N YWtlZmlsZQppbmRleCA4MWQ4ZGM1Li41MDE3MmMzIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvczNj MjR4eC9NYWtlZmlsZQorKysgYi9zb3VuZC9zb2MvczNjMjR4eC9NYWtlZmlsZQpAQCAtMjksNiAr MjksNyBAQCBzbmQtc29jLXMzYzI0eHgtc2ltdGVjLWhlcm1lcy1vYmpzIDo9IHMzYzI0eHhfc2lt dGVjX2hlcm1lcy5vCiBzbmQtc29jLXMzYzI0eHgtc2ltdGVjLXRsdjMyMGFpYzIzLW9ianMgOj0g czNjMjR4eF9zaW10ZWNfdGx2MzIwYWljMjMubwogc25kLXNvYy1zbWRrNjR4eC13bTg1ODAtb2Jq cyA6PSBzbWRrNjR4eF93bTg1ODAubwogc25kLXNvYy1zbWRrLXdtOTcxMy1vYmpzIDo9IHNtZGtf d205NzEzLm8KK3NuZC1zb2MtczNjNjR4eC1zbWFydHEtd204OTg3LW9ianMgOj0gc21hcnRxX3dt ODk4Ny5vCiAKIG9iai0kKENPTkZJR19TTkRfUzNDMjRYWF9TT0NfSklWRV9XTTg3NTApICs9IHNu ZC1zb2Mtaml2ZS13bTg3NTAubwogb2JqLSQoQ09ORklHX1NORF9TM0MyNFhYX1NPQ19ORU8xOTcz X1dNODc1MykgKz0gc25kLXNvYy1uZW8xOTczLXdtODc1My5vCkBAIC00MSwzICs0Miw0IEBAIG9i ai0kKENPTkZJR19TTkRfUzNDMjRYWF9TT0NfU0lNVEVDX0hFUk1FUykgKz0gc25kLXNvYy1zM2My NHh4LXNpbXRlYy1oZXJtZXMubwogb2JqLSQoQ09ORklHX1NORF9TM0MyNFhYX1NPQ19TSU1URUNf VExWMzIwQUlDMjMpICs9IHNuZC1zb2MtczNjMjR4eC1zaW10ZWMtdGx2MzIwYWljMjMubwogb2Jq LSQoQ09ORklHX1NORF9TM0M2NFhYX1NPQ19XTTg1ODApICs9IHNuZC1zb2Mtc21kazY0eHgtd204 NTgwLm8KIG9iai0kKENPTkZJR19TTkRfU09DX1NNREtfV005NzEzKSArPSBzbmQtc29jLXNtZGst d205NzEzLm8KK29iai0kKENPTkZJR19TTkRfUzNDNjRYWF9TT0NfU01BUlRRKSArPSBzbmQtc29j LXMzYzY0eHgtc21hcnRxLXdtODk4Ny5vCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvczNjMjR4eC9z bWFydHFfd204OTg3LmMgYi9zb3VuZC9zb2MvczNjMjR4eC9zbWFydHFfd204OTg3LmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzkwZWY5NgotLS0gL2Rldi9udWxsCisrKyBi L3NvdW5kL3NvYy9zM2MyNHh4L3NtYXJ0cV93bTg5ODcuYwpAQCAtMCwwICsxLDI5NiBAQAorLyog c291bmQvc29jL3MzYzI0eHgvc21hcnRxX3dtODk4Ny5jCisgKgorICogQ29weXJpZ2h0IDIwMTAg TWF1cnVzIEN1ZWxlbmFlcmUgPG1jdWVsZW5hZXJlQGdtYWlsLmNvbT4KKyAqCisgKiBCYXNlZCBv biBzbWRrNjQxMF93bTg5ODcuYworICogICAgIENvcHlyaWdodCAyMDA3IFdvbGZzb24gTWljcm9l bGVjdHJvbmljcyBQTEMuIC0gbGludXhAd29sZnNvbm1pY3JvLmNvbQorICogICAgIEdyYWVtZSBH cmVnb3J5IC0gZ3JhZW1lLmdyZWdvcnlAd29sZnNvbm1pY3JvLmNvbQorICoKKyAqICBUaGlzIHBy b2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgIGl0IGFuZC9vciBt b2RpZnkgaXQKKyAqICB1bmRlciAgdGhlIHRlcm1zIG9mICB0aGUgR05VIEdlbmVyYWwgIFB1Ymxp YyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247ICBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSAgTGljZW5zZSwgb3IgKGF0IHlvdXIKKyAqICBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvbW9k dWxlLmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGlu dXgvZ3Bpby5oPgorCisjaW5jbHVkZSA8c291bmQvcGNtLmg+CisjaW5jbHVkZSA8c291bmQvcGNt X3BhcmFtcy5oPgorI2luY2x1ZGUgPHNvdW5kL3NvYy1kYXBtLmg+CisjaW5jbHVkZSA8c291bmQv amFjay5oPgorCisjaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KKworI2luY2x1ZGUgInMzYy1k bWEuaCIKKyNpbmNsdWRlICJzM2M2NHh4LWkycy5oIgorCisjaW5jbHVkZSAiLi4vY29kZWNzL3dt ODc1MC5oIgorCisvKgorICogV004OTg3IGlzIHJlZ2lzdGVyIGNvbXBhdGlibGUgd2l0aCBXTTg3 NTAsIHNvIHVzaW5nIHRoYXQgYXMgYmFzZSBkcml2ZXIuCisgKi8KKworc3RhdGljIHN0cnVjdCBz bmRfc29jX2NhcmQgc25kX3NvY19zbWFydHE7CisKK3N0YXRpYyBpbnQgc21hcnRxX2hpZmlfaHdf cGFyYW1zKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtLAorCXN0cnVjdCBzbmRf cGNtX2h3X3BhcmFtcyAqcGFyYW1zKQoreworCXN0cnVjdCBzbmRfc29jX3BjbV9ydW50aW1lICpy dGQgPSBzdWJzdHJlYW0tPnByaXZhdGVfZGF0YTsKKwlzdHJ1Y3Qgc25kX3NvY19kYWkgKmNvZGVj X2RhaSA9IHJ0ZC0+ZGFpLT5jb2RlY19kYWk7CisJc3RydWN0IHNuZF9zb2NfZGFpICpjcHVfZGFp ID0gcnRkLT5kYWktPmNwdV9kYWk7CisJc3RydWN0IHMzY19pMnN2Ml9yYXRlX2NhbGMgZGl2Owor CXVuc2lnbmVkIGludCBjbGsgPSAwOworCWludCByZXQ7CisKKwlzM2NfaTJzdjJfaWlzX2NhbGNf cmF0ZSgmZGl2LCBOVUxMLCBwYXJhbXNfcmF0ZShwYXJhbXMpLAorCQkJCXMzY19pMnN2Ml9nZXRf Y2xvY2soY3B1X2RhaSkpOworCisJc3dpdGNoIChwYXJhbXNfcmF0ZShwYXJhbXMpKSB7CisJY2Fz ZSA4MDAwOgorCWNhc2UgMTYwMDA6CisJY2FzZSAzMjAwMDoKKwljYXNlIDQ4MDAwOgorCWNhc2Ug OTYwMDA6CisJCWNsayA9IDEyMjg4MDAwOworCQlicmVhazsKKwljYXNlIDExMDI1OgorCWNhc2Ug MjIwNTA6CisJY2FzZSA0NDEwMDoKKwljYXNlIDg4MjAwOgorCQljbGsgPSAxMTI4OTYwMDsKKwkJ YnJlYWs7CisJfQorCisJLyogc2V0IGNvZGVjIERBSSBjb25maWd1cmF0aW9uICovCisJcmV0ID0g c25kX3NvY19kYWlfc2V0X2ZtdChjb2RlY19kYWksIFNORF9TT0NfREFJRk1UX0kyUyB8CisJCQkJ CSAgICAgU05EX1NPQ19EQUlGTVRfTkJfTkYgfAorCQkJCQkgICAgIFNORF9TT0NfREFJRk1UX0NC U19DRlMpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJLyogc2V0IGNwdSBEQUkg Y29uZmlndXJhdGlvbiAqLworCXJldCA9IHNuZF9zb2NfZGFpX3NldF9mbXQoY3B1X2RhaSwgU05E X1NPQ19EQUlGTVRfSTJTIHwKKwkJCQkJICAgU05EX1NPQ19EQUlGTVRfTkJfTkYgfAorCQkJCQkg ICBTTkRfU09DX0RBSUZNVF9DQlNfQ0ZTKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsK KworCS8qIHNldCB0aGUgY29kZWMgc3lzdGVtIGNsb2NrIGZvciBEQUMgYW5kIEFEQyAqLworCXJl dCA9IHNuZF9zb2NfZGFpX3NldF9zeXNjbGsoY29kZWNfZGFpLCBXTTg3NTBfU1lTQ0xLLCBjbGss CisJCQkJICAgICBTTkRfU09DX0NMT0NLX0lOKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJl dDsKKworCS8qIHNldCBNQ0xLIGRpdmlzaW9uIGZvciBzYW1wbGUgcmF0ZSAqLworCXJldCA9IHNu ZF9zb2NfZGFpX3NldF9jbGtkaXYoY3B1X2RhaSwgUzNDX0kyU1YyX0RJVl9SQ0xLLCBkaXYuZnNf ZGl2KTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCS8qIHNldCBwcmVzY2FsZXIg ZGl2aXNpb24gZm9yIHNhbXBsZSByYXRlICovCisJcmV0ID0gc25kX3NvY19kYWlfc2V0X2Nsa2Rp dihjcHVfZGFpLCBTM0NfSTJTVjJfRElWX1BSRVNDQUxFUiwKKwkJCQkgICAgIGRpdi5jbGtfZGl2 IC0gMSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKwor LyoKKyAqIFNtYXJ0USBXTTg5ODcgSGlGaSBEQUkgb3BlcmF0aW9ucy4KKyAqLworc3RhdGljIHN0 cnVjdCBzbmRfc29jX29wcyBzbWFydHFfaGlmaV9vcHMgPSB7CisJLmh3X3BhcmFtcyA9IHNtYXJ0 cV9oaWZpX2h3X3BhcmFtcywKK307CisKK3N0YXRpYyBzdHJ1Y3Qgc25kX3NvY19qYWNrIHNtYXJ0 cV9qYWNrOworCitzdGF0aWMgc3RydWN0IHNuZF9zb2NfamFja19waW4gc21hcnRxX2phY2tfcGlu c1tdID0geworCS8qIERpc2FibGUgc3BlYWtlciB3aGVuIGhlYWRwaG9uZSBpcyBwbHVnZ2VkIGlu ICovCisJeworCQkucGluCT0gIkludGVybmFsIFNwZWFrZXIiLAorCQkubWFzawk9IFNORF9KQUNL X0hFQURQSE9ORSwKKwkJLmludmVydAk9IHRydWUsCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3Qg c25kX3NvY19qYWNrX2dwaW8gc21hcnRxX2phY2tfZ3Bpb3NbXSA9IHsKKwl7CisJCS5ncGlvCQk9 IFMzQzY0WFhfR1BMKDEyKSwKKwkJLm5hbWUJCT0gImhlYWRwaG9uZSBkZXRlY3QiLAorCQkucmVw b3J0CQk9IFNORF9KQUNLX0hFQURQSE9ORSwKKwkJLmRlYm91bmNlX3RpbWUJPSAyMDAsCisJfSwK K307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2tjb250cm9sX25ldyB3bTg5ODdfc21hcnRx X2NvbnRyb2xzW10gPSB7CisJU09DX0RBUE1fUElOX1NXSVRDSCgiSW50ZXJuYWwgU3BlYWtlciIp LAorCVNPQ19EQVBNX1BJTl9TV0lUQ0goIkhlYWRwaG9uZSBKYWNrIiksCisJU09DX0RBUE1fUElO X1NXSVRDSCgiSW50ZXJuYWwgTWljIiksCit9OworCitzdGF0aWMgaW50IHNtYXJ0cV9zcGVha2Vy X2V2ZW50KHN0cnVjdCBzbmRfc29jX2RhcG1fd2lkZ2V0ICp3LAorCQkJCXN0cnVjdCBzbmRfa2Nv bnRyb2wgKmssCisJCQkJaW50IGV2ZW50KQoreworCWdwaW9fc2V0X3ZhbHVlKFMzQzY0WFhfR1BL KDEyKSwgU05EX1NPQ19EQVBNX0VWRU5UX09GRihldmVudCkpOworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX3NvY19kYXBtX3dpZGdldCB3bTg5ODdfZGFwbV93aWRn ZXRzW10gPSB7CisJU05EX1NPQ19EQVBNX1NQSygiSW50ZXJuYWwgU3BlYWtlciIsIHNtYXJ0cV9z cGVha2VyX2V2ZW50KSwKKwlTTkRfU09DX0RBUE1fSFAoIkhlYWRwaG9uZSBKYWNrIiwgTlVMTCks CisJU05EX1NPQ19EQVBNX01JQygiSW50ZXJuYWwgTWljIiwgTlVMTCksCit9OworCitzdGF0aWMg Y29uc3Qgc3RydWN0IHNuZF9zb2NfZGFwbV9yb3V0ZSBhdWRpb19tYXBbXSA9IHsKKwl7IkhlYWRw aG9uZSBKYWNrIiwgTlVMTCwgIkxPVVQyIn0sCisJeyJIZWFkcGhvbmUgSmFjayIsIE5VTEwsICJS T1VUMiJ9LAorCisJeyJJbnRlcm5hbCBTcGVha2VyIiwgTlVMTCwgIkxPVVQyIn0sCisJeyJJbnRl cm5hbCBTcGVha2VyIiwgTlVMTCwgIlJPVVQyIn0sCisKKwl7Ik1pYyBCaWFzIiwgTlVMTCwgIklu dGVybmFsIE1pYyJ9LAorCXsiTElOUFVUMiIsIE5VTEwsICJNaWMgQmlhcyJ9LAorfTsKKworc3Rh dGljIGludCBzbWFydHFfd204OTg3X2luaXQoc3RydWN0IHNuZF9zb2NfY29kZWMgKmNvZGVjKQor eworCWludCBlcnIgPSAwOworCisJLyogQWRkIFNtYXJ0USBzcGVjaWZpYyB3aWRnZXRzICovCisJ c25kX3NvY19kYXBtX25ld19jb250cm9scyhjb2RlYywgd204OTg3X2RhcG1fd2lkZ2V0cywKKwkJ CQkgIEFSUkFZX1NJWkUod204OTg3X2RhcG1fd2lkZ2V0cykpOworCisJLyogYWRkIFNtYXJ0USBz cGVjaWZpYyBjb250cm9scyAqLworCWVyciA9IHNuZF9zb2NfYWRkX2NvbnRyb2xzKGNvZGVjLCB3 bTg5ODdfc21hcnRxX2NvbnRyb2xzLAorCQkJCSAgIEFSUkFZX1NJWkUod204OTg3X3NtYXJ0cV9j b250cm9scykpOworCisJaWYgKGVyciA8IDApCisJCXJldHVybiBlcnI7CisKKwkvKiBzZXR1cCBT bWFydFEgc3BlY2lmaWMgYXVkaW8gcGF0aCAqLworCXNuZF9zb2NfZGFwbV9hZGRfcm91dGVzKGNv ZGVjLCBhdWRpb19tYXAsIEFSUkFZX1NJWkUoYXVkaW9fbWFwKSk7CisKKwkvKiBzZXQgZW5kcG9p bnRzIHRvIG5vdCBjb25uZWN0ZWQgKi8KKwlzbmRfc29jX2RhcG1fbmNfcGluKGNvZGVjLCAiTElO UFVUMSIpOworCXNuZF9zb2NfZGFwbV9uY19waW4oY29kZWMsICJSSU5QVVQxIik7CisJc25kX3Nv Y19kYXBtX25jX3Bpbihjb2RlYywgIk9VVDMiKTsKKwlzbmRfc29jX2RhcG1fbmNfcGluKGNvZGVj LCAiUk9VVDEiKTsKKworCS8qIHNldCBlbmRwb2ludHMgdG8gZGVmYXVsdCBvZmYgbW9kZSAqLwor CXNuZF9zb2NfZGFwbV9lbmFibGVfcGluKGNvZGVjLCAiSW50ZXJuYWwgU3BlYWtlciIpOworCXNu ZF9zb2NfZGFwbV9lbmFibGVfcGluKGNvZGVjLCAiSW50ZXJuYWwgTWljIik7CisJc25kX3NvY19k YXBtX2Rpc2FibGVfcGluKGNvZGVjLCAiSGVhZHBob25lIEphY2siKTsKKworCWVyciA9IHNuZF9z b2NfZGFwbV9zeW5jKGNvZGVjKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJLyogSGVh ZHBob25lIGphY2sgZGV0ZWN0aW9uICovCisJZXJyID0gc25kX3NvY19qYWNrX25ldygmc25kX3Nv Y19zbWFydHEsICJIZWFkcGhvbmUgSmFjayIsCisJCQkgICAgICAgU05EX0pBQ0tfSEVBRFBIT05F LCAmc21hcnRxX2phY2spOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwllcnIgPSBzbmRf c29jX2phY2tfYWRkX3BpbnMoJnNtYXJ0cV9qYWNrLCBBUlJBWV9TSVpFKHNtYXJ0cV9qYWNrX3Bp bnMpLAorCQkJCSAgICBzbWFydHFfamFja19waW5zKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJy OworCisJZXJyID0gc25kX3NvY19qYWNrX2FkZF9ncGlvcygmc21hcnRxX2phY2ssCisJCQkJICAg ICBBUlJBWV9TSVpFKHNtYXJ0cV9qYWNrX2dwaW9zKSwKKwkJCQkgICAgIHNtYXJ0cV9qYWNrX2dw aW9zKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc25kX3NvY19kYWlfbGlu ayBzbWFydHFfZGFpW10gPSB7CisJeworCQkubmFtZQkJPSAid204OTg3IiwKKwkJLnN0cmVhbV9u YW1lCT0gIlNtYXJ0USBIaS1GaSIsCisJCS5jcHVfZGFpCT0gJnMzYzY0eHhfaTJzX2RhaVswXSwK KwkJLmNvZGVjX2RhaQk9ICZ3bTg3NTBfZGFpLAorCQkuaW5pdAkJPSBzbWFydHFfd204OTg3X2lu aXQsCisJCS5vcHMJCT0gJnNtYXJ0cV9oaWZpX29wcywKKwl9LAorfTsKKworc3RhdGljIHN0cnVj dCBzbmRfc29jX2NhcmQgc25kX3NvY19zbWFydHEgPSB7CisJLm5hbWUgPSAiU21hcnRRIiwKKwku cGxhdGZvcm0gPSAmczNjMjR4eF9zb2NfcGxhdGZvcm0sCisJLmRhaV9saW5rID0gc21hcnRxX2Rh aSwKKwkubnVtX2xpbmtzID0gQVJSQVlfU0laRShzbWFydHFfZGFpKSwKK307CisKK3N0YXRpYyBz dHJ1Y3Qgc25kX3NvY19kZXZpY2Ugc21hcnRxX3NuZF9kZXZkYXRhID0geworCS5jYXJkID0gJnNu ZF9zb2Nfc21hcnRxLAorCS5jb2RlY19kZXYgPSAmc29jX2NvZGVjX2Rldl93bTg3NTAsCit9Owor CitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqc21hcnRxX3NuZF9kZXZpY2U7CisKK3N0 YXRpYyBpbnQgX19pbml0IHNtYXJ0cV9pbml0KHZvaWQpCit7CisJaW50IHJldDsKKworCWlmICgh bWFjaGluZV9pc19zbWFydHE3KCkgJiYgIW1hY2hpbmVfaXNfc21hcnRxNSgpKSB7CisJCXByX2lu Zm8oIk9ubHkgU21hcnRRIGlzIHN1cHBvcnRlZCBieSB0aGlzIEFTb0MgZHJpdmVyXG4iKTsKKwkJ cmV0dXJuIC1FTk9ERVY7CisJfQorCisJc21hcnRxX3NuZF9kZXZpY2UgPSBwbGF0Zm9ybV9kZXZp Y2VfYWxsb2MoInNvYy1hdWRpbyIsIC0xKTsKKwlpZiAoIXNtYXJ0cV9zbmRfZGV2aWNlKQorCQly ZXR1cm4gLUVOT01FTTsKKworCXBsYXRmb3JtX3NldF9kcnZkYXRhKHNtYXJ0cV9zbmRfZGV2aWNl LCAmc21hcnRxX3NuZF9kZXZkYXRhKTsKKwlzbWFydHFfc25kX2RldmRhdGEuZGV2ID0gJnNtYXJ0 cV9zbmRfZGV2aWNlLT5kZXY7CisKKwlyZXQgPSBwbGF0Zm9ybV9kZXZpY2VfYWRkKHNtYXJ0cV9z bmRfZGV2aWNlKTsKKwlpZiAocmV0KSB7CisJCXBsYXRmb3JtX2RldmljZV9wdXQoc21hcnRxX3Nu ZF9kZXZpY2UpOworCQlyZXR1cm4gcmV0OworCX0KKworCS8qIEluaXRpYWxpc2UgR1BJT3MgdXNl ZCBieSBhbXBsaWZpZXJzICovCisJcmV0ID0gZ3Bpb19yZXF1ZXN0KFMzQzY0WFhfR1BLKDEyKSwg ImFtcGxpZmllcnMgc2h1dGRvd24iKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoJnNtYXJ0cV9z bmRfZGV2aWNlLT5kZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgR1BLMTJcbiIpOworCQlnb3RvIGVy cl91bnJlZ2lzdGVyX2RldmljZTsKKwl9CisKKwkvKiBEaXNhYmxlIGFtcGxpZmllcnMgKi8KKwly ZXQgPSBncGlvX2RpcmVjdGlvbl9vdXRwdXQoUzNDNjRYWF9HUEsoMTIpLCAxKTsKKwlpZiAocmV0 KSB7CisJCWRldl9lcnIoJnNtYXJ0cV9zbmRfZGV2aWNlLT5kZXYsICJGYWlsZWQgdG8gY29uZmln dXJlIEdQSzEyXG4iKTsKKwkJZ290byBlcnJfZnJlZV9ncGlvX2FtcF9zaHV0OworCX0KKworCXJl dHVybiAwOworCitlcnJfZnJlZV9ncGlvX2FtcF9zaHV0OgorCWdwaW9fZnJlZShTM0M2NFhYX0dQ SygxMikpOworZXJyX3VucmVnaXN0ZXJfZGV2aWNlOgorCXBsYXRmb3JtX2RldmljZV91bnJlZ2lz dGVyKHNtYXJ0cV9zbmRfZGV2aWNlKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lk IF9fZXhpdCBzbWFydHFfZXhpdCh2b2lkKQoreworCXNuZF9zb2NfamFja19mcmVlX2dwaW9zKCZz bWFydHFfamFjaywgQVJSQVlfU0laRShzbWFydHFfamFja19ncGlvcyksCisJCQkJc21hcnRxX2ph Y2tfZ3Bpb3MpOworCisJcGxhdGZvcm1fZGV2aWNlX3VucmVnaXN0ZXIoc21hcnRxX3NuZF9kZXZp Y2UpOworfQorCittb2R1bGVfaW5pdChzbWFydHFfaW5pdCk7Cittb2R1bGVfZXhpdChzbWFydHFf ZXhpdCk7CisKKy8qIE1vZHVsZSBpbmZvcm1hdGlvbiAqLworTU9EVUxFX0FVVEhPUigiTWF1cnVz IEN1ZWxlbmFlcmUgPG1jdWVsZW5hZXJlQGdtYWlsLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElP TigiQUxTQSBTb0MgU21hcnRRIFdNODk4NyIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwotLSAK MS43LjAuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K QWxzYS1kZXZlbCBtYWlsaW5nIGxpc3QKQWxzYS1kZXZlbEBhbHNhLXByb2plY3Qub3JnCmh0dHA6 Ly9tYWlsbWFuLmFsc2EtcHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbHNhLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: mcuelenaere@gmail.com (Maurus Cuelenaere) Date: Sat, 03 Jul 2010 02:46:12 +0200 Subject: [PATCH 2/3] ASoC: Add SmartQ sound driver Message-ID: <4c2e8856.487e0e0a.3bb5.3ec0@mx.google.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org This adds sound support for the SmartQ board. The hardware consists of a S3C6410 coupled with a WM8987 over I?S. The WM8750 driver is used for driving the WM8987, as they are register compatible. Signed-off-by: Maurus Cuelenaere --- sound/soc/s3c24xx/Kconfig | 6 + sound/soc/s3c24xx/Makefile | 2 + sound/soc/s3c24xx/smartq_wm8987.c | 296 +++++++++++++++++++++++++++++++++++++ 3 files changed, 304 insertions(+), 0 deletions(-) create mode 100644 sound/soc/s3c24xx/smartq_wm8987.c diff --git a/sound/soc/s3c24xx/Kconfig b/sound/soc/s3c24xx/Kconfig index 2a7cc22..4f46ba0 100644 --- a/sound/soc/s3c24xx/Kconfig +++ b/sound/soc/s3c24xx/Kconfig @@ -125,3 +125,9 @@ config SND_SOC_SMDK_WM9713 select SND_S3C_SOC_AC97 help Sat Y if you want to add support for SoC audio on the SMDK. + +config SND_S3C64XX_SOC_SMARTQ + tristate "SoC I2S Audio support for SmartQ board" + depends on SND_S3C24XX_SOC && MACH_SMARTQ + select SND_S3C64XX_SOC_I2S + select SND_SOC_WM8750 diff --git a/sound/soc/s3c24xx/Makefile b/sound/soc/s3c24xx/Makefile index 81d8dc5..50172c3 100644 --- a/sound/soc/s3c24xx/Makefile +++ b/sound/soc/s3c24xx/Makefile @@ -29,6 +29,7 @@ snd-soc-s3c24xx-simtec-hermes-objs := s3c24xx_simtec_hermes.o snd-soc-s3c24xx-simtec-tlv320aic23-objs := s3c24xx_simtec_tlv320aic23.o snd-soc-smdk64xx-wm8580-objs := smdk64xx_wm8580.o snd-soc-smdk-wm9713-objs := smdk_wm9713.o +snd-soc-s3c64xx-smartq-wm8987-objs := smartq_wm8987.o obj-$(CONFIG_SND_S3C24XX_SOC_JIVE_WM8750) += snd-soc-jive-wm8750.o obj-$(CONFIG_SND_S3C24XX_SOC_NEO1973_WM8753) += snd-soc-neo1973-wm8753.o @@ -41,3 +42,4 @@ obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_HERMES) += snd-soc-s3c24xx-simtec-hermes.o obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_TLV320AIC23) += snd-soc-s3c24xx-simtec-tlv320aic23.o obj-$(CONFIG_SND_S3C64XX_SOC_WM8580) += snd-soc-smdk64xx-wm8580.o obj-$(CONFIG_SND_SOC_SMDK_WM9713) += snd-soc-smdk-wm9713.o +obj-$(CONFIG_SND_S3C64XX_SOC_SMARTQ) += snd-soc-s3c64xx-smartq-wm8987.o diff --git a/sound/soc/s3c24xx/smartq_wm8987.c b/sound/soc/s3c24xx/smartq_wm8987.c new file mode 100644 index 0000000..c90ef96 --- /dev/null +++ b/sound/soc/s3c24xx/smartq_wm8987.c @@ -0,0 +1,296 @@ +/* sound/soc/s3c24xx/smartq_wm8987.c + * + * Copyright 2010 Maurus Cuelenaere + * + * Based on smdk6410_wm8987.c + * Copyright 2007 Wolfson Microelectronics PLC. - linux at wolfsonmicro.com + * Graeme Gregory - graeme.gregory at wolfsonmicro.com + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include "s3c-dma.h" +#include "s3c64xx-i2s.h" + +#include "../codecs/wm8750.h" + +/* + * WM8987 is register compatible with WM8750, so using that as base driver. + */ + +static struct snd_soc_card snd_soc_smartq; + +static int smartq_hifi_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct snd_soc_dai *codec_dai = rtd->dai->codec_dai; + struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; + struct s3c_i2sv2_rate_calc div; + unsigned int clk = 0; + int ret; + + s3c_i2sv2_iis_calc_rate(&div, NULL, params_rate(params), + s3c_i2sv2_get_clock(cpu_dai)); + + switch (params_rate(params)) { + case 8000: + case 16000: + case 32000: + case 48000: + case 96000: + clk = 12288000; + break; + case 11025: + case 22050: + case 44100: + case 88200: + clk = 11289600; + break; + } + + /* set codec DAI configuration */ + ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S | + SND_SOC_DAIFMT_NB_NF | + SND_SOC_DAIFMT_CBS_CFS); + if (ret < 0) + return ret; + + /* set cpu DAI configuration */ + ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S | + SND_SOC_DAIFMT_NB_NF | + SND_SOC_DAIFMT_CBS_CFS); + if (ret < 0) + return ret; + + /* set the codec system clock for DAC and ADC */ + ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk, + SND_SOC_CLOCK_IN); + if (ret < 0) + return ret; + + /* set MCLK division for sample rate */ + ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_RCLK, div.fs_div); + if (ret < 0) + return ret; + + /* set prescaler division for sample rate */ + ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_PRESCALER, + div.clk_div - 1); + if (ret < 0) + return ret; + + return 0; +} + +/* + * SmartQ WM8987 HiFi DAI operations. + */ +static struct snd_soc_ops smartq_hifi_ops = { + .hw_params = smartq_hifi_hw_params, +}; + +static struct snd_soc_jack smartq_jack; + +static struct snd_soc_jack_pin smartq_jack_pins[] = { + /* Disable speaker when headphone is plugged in */ + { + .pin = "Internal Speaker", + .mask = SND_JACK_HEADPHONE, + .invert = true, + }, +}; + +static struct snd_soc_jack_gpio smartq_jack_gpios[] = { + { + .gpio = S3C64XX_GPL(12), + .name = "headphone detect", + .report = SND_JACK_HEADPHONE, + .debounce_time = 200, + }, +}; + +static const struct snd_kcontrol_new wm8987_smartq_controls[] = { + SOC_DAPM_PIN_SWITCH("Internal Speaker"), + SOC_DAPM_PIN_SWITCH("Headphone Jack"), + SOC_DAPM_PIN_SWITCH("Internal Mic"), +}; + +static int smartq_speaker_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, + int event) +{ + gpio_set_value(S3C64XX_GPK(12), SND_SOC_DAPM_EVENT_OFF(event)); + + return 0; +} + +static const struct snd_soc_dapm_widget wm8987_dapm_widgets[] = { + SND_SOC_DAPM_SPK("Internal Speaker", smartq_speaker_event), + SND_SOC_DAPM_HP("Headphone Jack", NULL), + SND_SOC_DAPM_MIC("Internal Mic", NULL), +}; + +static const struct snd_soc_dapm_route audio_map[] = { + {"Headphone Jack", NULL, "LOUT2"}, + {"Headphone Jack", NULL, "ROUT2"}, + + {"Internal Speaker", NULL, "LOUT2"}, + {"Internal Speaker", NULL, "ROUT2"}, + + {"Mic Bias", NULL, "Internal Mic"}, + {"LINPUT2", NULL, "Mic Bias"}, +}; + +static int smartq_wm8987_init(struct snd_soc_codec *codec) +{ + int err = 0; + + /* Add SmartQ specific widgets */ + snd_soc_dapm_new_controls(codec, wm8987_dapm_widgets, + ARRAY_SIZE(wm8987_dapm_widgets)); + + /* add SmartQ specific controls */ + err = snd_soc_add_controls(codec, wm8987_smartq_controls, + ARRAY_SIZE(wm8987_smartq_controls)); + + if (err < 0) + return err; + + /* setup SmartQ specific audio path */ + snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); + + /* set endpoints to not connected */ + snd_soc_dapm_nc_pin(codec, "LINPUT1"); + snd_soc_dapm_nc_pin(codec, "RINPUT1"); + snd_soc_dapm_nc_pin(codec, "OUT3"); + snd_soc_dapm_nc_pin(codec, "ROUT1"); + + /* set endpoints to default off mode */ + snd_soc_dapm_enable_pin(codec, "Internal Speaker"); + snd_soc_dapm_enable_pin(codec, "Internal Mic"); + snd_soc_dapm_disable_pin(codec, "Headphone Jack"); + + err = snd_soc_dapm_sync(codec); + if (err) + return err; + + /* Headphone jack detection */ + err = snd_soc_jack_new(&snd_soc_smartq, "Headphone Jack", + SND_JACK_HEADPHONE, &smartq_jack); + if (err) + return err; + + err = snd_soc_jack_add_pins(&smartq_jack, ARRAY_SIZE(smartq_jack_pins), + smartq_jack_pins); + if (err) + return err; + + err = snd_soc_jack_add_gpios(&smartq_jack, + ARRAY_SIZE(smartq_jack_gpios), + smartq_jack_gpios); + + return err; +} + +static struct snd_soc_dai_link smartq_dai[] = { + { + .name = "wm8987", + .stream_name = "SmartQ Hi-Fi", + .cpu_dai = &s3c64xx_i2s_dai[0], + .codec_dai = &wm8750_dai, + .init = smartq_wm8987_init, + .ops = &smartq_hifi_ops, + }, +}; + +static struct snd_soc_card snd_soc_smartq = { + .name = "SmartQ", + .platform = &s3c24xx_soc_platform, + .dai_link = smartq_dai, + .num_links = ARRAY_SIZE(smartq_dai), +}; + +static struct snd_soc_device smartq_snd_devdata = { + .card = &snd_soc_smartq, + .codec_dev = &soc_codec_dev_wm8750, +}; + +static struct platform_device *smartq_snd_device; + +static int __init smartq_init(void) +{ + int ret; + + if (!machine_is_smartq7() && !machine_is_smartq5()) { + pr_info("Only SmartQ is supported by this ASoC driver\n"); + return -ENODEV; + } + + smartq_snd_device = platform_device_alloc("soc-audio", -1); + if (!smartq_snd_device) + return -ENOMEM; + + platform_set_drvdata(smartq_snd_device, &smartq_snd_devdata); + smartq_snd_devdata.dev = &smartq_snd_device->dev; + + ret = platform_device_add(smartq_snd_device); + if (ret) { + platform_device_put(smartq_snd_device); + return ret; + } + + /* Initialise GPIOs used by amplifiers */ + ret = gpio_request(S3C64XX_GPK(12), "amplifiers shutdown"); + if (ret) { + dev_err(&smartq_snd_device->dev, "Failed to register GPK12\n"); + goto err_unregister_device; + } + + /* Disable amplifiers */ + ret = gpio_direction_output(S3C64XX_GPK(12), 1); + if (ret) { + dev_err(&smartq_snd_device->dev, "Failed to configure GPK12\n"); + goto err_free_gpio_amp_shut; + } + + return 0; + +err_free_gpio_amp_shut: + gpio_free(S3C64XX_GPK(12)); +err_unregister_device: + platform_device_unregister(smartq_snd_device); + + return ret; +} + +static void __exit smartq_exit(void) +{ + snd_soc_jack_free_gpios(&smartq_jack, ARRAY_SIZE(smartq_jack_gpios), + smartq_jack_gpios); + + platform_device_unregister(smartq_snd_device); +} + +module_init(smartq_init); +module_exit(smartq_exit); + +/* Module information */ +MODULE_AUTHOR("Maurus Cuelenaere "); +MODULE_DESCRIPTION("ALSA SoC SmartQ WM8987"); +MODULE_LICENSE("GPL"); -- 1.7.0.4