From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH RESEND1 04/12] ALSA: vsnd: Read sound driver configuration from Xen store Date: Mon, 7 Aug 2017 15:22:49 +0300 Message-ID: <1502108577-8099-5-git-send-email-andr2000@gmail.com> References: <1502108577-8099-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1502108577-8099-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: alsa-devel@alsa-project.org, xen-devel@lists.xen.org, linux-kernel@vger.kernel.org Cc: andr2000@gmail.com, Oleksandr Andrushchenko , tiwai@suse.com, perex@perex.cz List-Id: alsa-devel@alsa-project.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKUmVhZCBjb25maWd1cmF0aW9uIHZhbHVlcyBmcm9tIFhlbiBzdG9yZSBhY2NvcmRp bmcKdG8geGVuL2ludGVyZmFjZS9pby9zbmRpZi5oIHByb3RvY29sOgotIGludHJvZHVjZSBjb25m aWd1cmF0aW9uIHN0cnVjdHVyZXMgZm9yIGRpZmZlcmVudAogIGNvbXBvbmVudHMsIGUuZy4gc291 bmQgY2FyZCwgZGV2aWNlLCBzdHJlYW0KLSByZWFkIFBDTSBIVyBwYXJhbWV0ZXJzLCBlLmcgcmF0 ZSwgZm9ybWF0IGV0Yy4KLSBkZXRlY3Qgc3RyZWFtIHR5cGUgKGNhcHR1cmUvcGxheWJhY2spCi0g cmVhZCBkZXZpY2UgYW5kIGNhcmQgcGFyYW1ldGVycwoKRmlsbCBpbiBwbGF0Zm9ybSBkYXRhIHdp dGggdGhlIGNvbmZpZ3VyYXRpb24gcmVhZCwgc28KaXQgY2FuIGJlIHBhc3NlZCB0byBzb3VuZCBk cml2ZXIgbGF0ZXIuCgpTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xl a3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0tLQogc291bmQvZHJpdmVycy94ZW4tZnJv bnQuYyB8IDUzMCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr CiAxIGZpbGUgY2hhbmdlZCwgNTMwIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9zb3VuZC9k cml2ZXJzL3hlbi1mcm9udC5jIGIvc291bmQvZHJpdmVycy94ZW4tZnJvbnQuYwppbmRleCBjNGZk MjFjYWMzYTcuLmVmNDhjYmY0NGNmMiAxMDA2NDQKLS0tIGEvc291bmQvZHJpdmVycy94ZW4tZnJv bnQuYworKysgYi9zb3VuZC9kcml2ZXJzL3hlbi1mcm9udC5jCkBAIC0yMCwyNCArMjAsNTU0IEBA CiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KIAorI2luY2x1ZGUgPHNvdW5kL2NvcmUuaD4K KyNpbmNsdWRlIDxzb3VuZC9wY20uaD4KKwogI2luY2x1ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4K ICNpbmNsdWRlIDx4ZW4veGVuLmg+CiAjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgogCiAjaW5jbHVk ZSA8eGVuL2ludGVyZmFjZS9pby9zbmRpZi5oPgogCisvKiBtYXhpbXVtIG51bWJlciBvZiBzdXBw b3J0ZWQgc3RyZWFtcyAqLworI2RlZmluZSBWU05EX01BWF9TVFJFQU0JCTgKKworc3RydWN0IGNm Z19zdHJlYW0geworCWludCB1bmlxdWVfaWQ7CisJY2hhciAqeGVuc3RvcmVfcGF0aDsKKwlzdHJ1 Y3Qgc25kX3BjbV9oYXJkd2FyZSBwY21faHc7Cit9OworCitzdHJ1Y3QgY2ZnX3BjbV9pbnN0YW5j ZSB7CisJY2hhciBuYW1lWzgwXTsKKwlpbnQgZGV2aWNlX2lkOworCXN0cnVjdCBzbmRfcGNtX2hh cmR3YXJlIHBjbV9odzsKKwlpbnQgIG51bV9zdHJlYW1zX3BiOworCXN0cnVjdCBjZmdfc3RyZWFt ICpzdHJlYW1zX3BiOworCWludCAgbnVtX3N0cmVhbXNfY2FwOworCXN0cnVjdCBjZmdfc3RyZWFt ICpzdHJlYW1zX2NhcDsKK307CisKK3N0cnVjdCBjZmdfY2FyZCB7CisJY2hhciBuYW1lX3Nob3J0 WzMyXTsKKwljaGFyIG5hbWVfbG9uZ1s4MF07CisJc3RydWN0IHNuZF9wY21faGFyZHdhcmUgcGNt X2h3OworCWludCBudW1fcGNtX2luc3RhbmNlczsKKwlzdHJ1Y3QgY2ZnX3BjbV9pbnN0YW5jZSAq cGNtX2luc3RhbmNlczsKK307CisKK3N0cnVjdCBzZGV2X2NhcmRfcGxhdF9kYXRhIHsKKwlzdHJ1 Y3QgeGRydl9pbmZvICp4ZHJ2X2luZm87CisJc3RydWN0IGNmZ19jYXJkIGNmZ19jYXJkOworfTsK Kwogc3RydWN0IHhkcnZfaW5mbyB7CiAJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldjsKIAlz cGlubG9ja190IGlvX2xvY2s7CiAJc3RydWN0IG11dGV4IG11dGV4OworCXN0cnVjdCBzZGV2X2Nh cmRfcGxhdF9kYXRhIGNmZ19wbGF0X2RhdGE7CiB9OwogCisjZGVmaW5lIE1BWF9YRU5fQlVGRkVS X1NJWkUJKDY0ICogMTAyNCkKKyNkZWZpbmUgTUFYX0JVRkZFUl9TSVpFCQlNQVhfWEVOX0JVRkZF Ul9TSVpFCisjZGVmaW5lIE1JTl9QRVJJT0RfU0laRQkJNjQKKyNkZWZpbmUgTUFYX1BFUklPRF9T SVpFCQkoTUFYX0JVRkZFUl9TSVpFIC8gOCkKKyNkZWZpbmUgVVNFX0ZPUk1BVFMJCShTTkRSVl9Q Q01fRk1UQklUX1U4IHwgXAorCQkJCSBTTkRSVl9QQ01fRk1UQklUX1MxNl9MRSkKKyNkZWZpbmUg VVNFX1JBVEUJCShTTkRSVl9QQ01fUkFURV9DT05USU5VT1VTIHwgXAorCQkJCSBTTkRSVl9QQ01f UkFURV84MDAwXzQ4MDAwKQorI2RlZmluZSBVU0VfUkFURV9NSU4JCTU1MTIKKyNkZWZpbmUgVVNF X1JBVEVfTUFYCQk0ODAwMAorI2RlZmluZSBVU0VfQ0hBTk5FTFNfTUlOCTEKKyNkZWZpbmUgVVNF X0NIQU5ORUxTX01BWAkyCisjZGVmaW5lIFVTRV9QRVJJT0RTX01JTgkJMgorI2RlZmluZSBVU0Vf UEVSSU9EU19NQVgJCTgKKworc3RhdGljIHN0cnVjdCBzbmRfcGNtX2hhcmR3YXJlIHNkcnZfcGNt X2h3X2RlZmF1bHQgPSB7CisJLmluZm8gPSAoU05EUlZfUENNX0lORk9fTU1BUCB8CisJCSBTTkRS Vl9QQ01fSU5GT19JTlRFUkxFQVZFRCB8CisJCSBTTkRSVl9QQ01fSU5GT19SRVNVTUUgfAorCQkg U05EUlZfUENNX0lORk9fTU1BUF9WQUxJRCksCisJLmZvcm1hdHMgPSBVU0VfRk9STUFUUywKKwku cmF0ZXMgPSBVU0VfUkFURSwKKwkucmF0ZV9taW4gPSBVU0VfUkFURV9NSU4sCisJLnJhdGVfbWF4 ID0gVVNFX1JBVEVfTUFYLAorCS5jaGFubmVsc19taW4gPSBVU0VfQ0hBTk5FTFNfTUlOLAorCS5j aGFubmVsc19tYXggPSBVU0VfQ0hBTk5FTFNfTUFYLAorCS5idWZmZXJfYnl0ZXNfbWF4ID0gTUFY X0JVRkZFUl9TSVpFLAorCS5wZXJpb2RfYnl0ZXNfbWluID0gTUlOX1BFUklPRF9TSVpFLAorCS5w ZXJpb2RfYnl0ZXNfbWF4ID0gTUFYX1BFUklPRF9TSVpFLAorCS5wZXJpb2RzX21pbiA9IFVTRV9Q RVJJT0RTX01JTiwKKwkucGVyaW9kc19tYXggPSBVU0VfUEVSSU9EU19NQVgsCisJLmZpZm9fc2l6 ZSA9IDAsCit9OworCitzdHJ1Y3QgQ0ZHX0hXX1NBTVBMRV9SQVRFIHsKKwljb25zdCBjaGFyICpu YW1lOworCXVuc2lnbmVkIGludCBtYXNrOworCXVuc2lnbmVkIGludCB2YWx1ZTsKK307CisKK3N0 YXRpYyBzdHJ1Y3QgQ0ZHX0hXX1NBTVBMRV9SQVRFIGNmZ19od19zdXBwb3J0ZWRfcmF0ZXNbXSA9 IHsKKwl7IC5uYW1lID0gIjU1MTIiLCAgIC5tYXNrID0gU05EUlZfUENNX1JBVEVfNTUxMiwgICAu dmFsdWUgPSA1NTEyIH0sCisJeyAubmFtZSA9ICI4MDAwIiwgICAubWFzayA9IFNORFJWX1BDTV9S QVRFXzgwMDAsICAgLnZhbHVlID0gODAwMCB9LAorCXsgLm5hbWUgPSAiMTEwMjUiLCAgLm1hc2sg PSBTTkRSVl9QQ01fUkFURV8xMTAyNSwgIC52YWx1ZSA9IDExMDI1IH0sCisJeyAubmFtZSA9ICIx NjAwMCIsICAubWFzayA9IFNORFJWX1BDTV9SQVRFXzE2MDAwLCAgLnZhbHVlID0gMTYwMDAgfSwK Kwl7IC5uYW1lID0gIjIyMDUwIiwgIC5tYXNrID0gU05EUlZfUENNX1JBVEVfMjIwNTAsICAudmFs dWUgPSAyMjA1MCB9LAorCXsgLm5hbWUgPSAiMzIwMDAiLCAgLm1hc2sgPSBTTkRSVl9QQ01fUkFU RV8zMjAwMCwgIC52YWx1ZSA9IDMyMDAwIH0sCisJeyAubmFtZSA9ICI0NDEwMCIsICAubWFzayA9 IFNORFJWX1BDTV9SQVRFXzQ0MTAwLCAgLnZhbHVlID0gNDQxMDAgfSwKKwl7IC5uYW1lID0gIjQ4 MDAwIiwgIC5tYXNrID0gU05EUlZfUENNX1JBVEVfNDgwMDAsICAudmFsdWUgPSA0ODAwMCB9LAor CXsgLm5hbWUgPSAiNjQwMDAiLCAgLm1hc2sgPSBTTkRSVl9QQ01fUkFURV82NDAwMCwgIC52YWx1 ZSA9IDY0MDAwIH0sCisJeyAubmFtZSA9ICI5NjAwMCIsICAubWFzayA9IFNORFJWX1BDTV9SQVRF Xzk2MDAwLCAgLnZhbHVlID0gOTYwMDAgfSwKKwl7IC5uYW1lID0gIjE3NjQwMCIsIC5tYXNrID0g U05EUlZfUENNX1JBVEVfMTc2NDAwLCAudmFsdWUgPSAxNzY0MDAgfSwKKwl7IC5uYW1lID0gIjE5 MjAwMCIsIC5tYXNrID0gU05EUlZfUENNX1JBVEVfMTkyMDAwLCAudmFsdWUgPSAxOTIwMDAgfSwK K307CisKK3N0cnVjdCBDRkdfSFdfU0FNUExFX0ZPUk1BVCB7CisJY29uc3QgY2hhciAqbmFtZTsK Kwl1NjQgbWFzazsKK307CisKK3N0YXRpYyBzdHJ1Y3QgQ0ZHX0hXX1NBTVBMRV9GT1JNQVQgY2Zn X2h3X3N1cHBvcnRlZF9mb3JtYXRzW10gPSB7CisJeworCQkubmFtZSA9IFhFTlNORF9QQ01fRk9S TUFUX1U4X1NUUiwKKwkJLm1hc2sgPSBTTkRSVl9QQ01fRk1UQklUX1U4CisJfSwKKwl7CisJCS5u YW1lID0gWEVOU05EX1BDTV9GT1JNQVRfUzhfU1RSLAorCQkubWFzayA9IFNORFJWX1BDTV9GTVRC SVRfUzgKKwl9LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENNX0ZPUk1BVF9VMTZfTEVfU1RSLAor CQkubWFzayA9IFNORFJWX1BDTV9GTVRCSVRfVTE2X0xFCisJfSwKKwl7CisJCS5uYW1lID0gWEVO U05EX1BDTV9GT1JNQVRfVTE2X0JFX1NUUiwKKwkJLm1hc2sgPSBTTkRSVl9QQ01fRk1UQklUX1Ux Nl9CRQorCX0sCisJeworCQkubmFtZSA9IFhFTlNORF9QQ01fRk9STUFUX1MxNl9MRV9TVFIsCisJ CS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9TMTZfTEUKKwl9LAorCXsKKwkJLm5hbWUgPSBYRU5T TkRfUENNX0ZPUk1BVF9TMTZfQkVfU1RSLAorCQkubWFzayA9IFNORFJWX1BDTV9GTVRCSVRfUzE2 X0JFCisJfSwKKwl7CisJCS5uYW1lID0gWEVOU05EX1BDTV9GT1JNQVRfVTI0X0xFX1NUUiwKKwkJ Lm1hc2sgPSBTTkRSVl9QQ01fRk1UQklUX1UyNF9MRQorCX0sCisJeworCQkubmFtZSA9IFhFTlNO RF9QQ01fRk9STUFUX1UyNF9CRV9TVFIsCisJCS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9VMjRf QkUKKwl9LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENNX0ZPUk1BVF9TMjRfTEVfU1RSLAorCQku bWFzayA9IFNORFJWX1BDTV9GTVRCSVRfUzI0X0xFCisJfSwKKwl7CisJCS5uYW1lID0gWEVOU05E X1BDTV9GT1JNQVRfUzI0X0JFX1NUUiwKKwkJLm1hc2sgPSBTTkRSVl9QQ01fRk1UQklUX1MyNF9C RQorCX0sCisJeworCQkubmFtZSA9IFhFTlNORF9QQ01fRk9STUFUX1UzMl9MRV9TVFIsCisJCS5t YXNrID0gU05EUlZfUENNX0ZNVEJJVF9VMzJfTEUKKwl9LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRf UENNX0ZPUk1BVF9VMzJfQkVfU1RSLAorCQkubWFzayA9IFNORFJWX1BDTV9GTVRCSVRfVTMyX0JF CisJfSwKKwl7CisJCS5uYW1lID0gWEVOU05EX1BDTV9GT1JNQVRfUzMyX0xFX1NUUiwKKwkJLm1h c2sgPSBTTkRSVl9QQ01fRk1UQklUX1MzMl9MRQorCX0sCisJeworCQkubmFtZSA9IFhFTlNORF9Q Q01fRk9STUFUX1MzMl9CRV9TVFIsCisJCS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9TMzJfQkUK Kwl9LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENNX0ZPUk1BVF9BX0xBV19TVFIsCisJCS5tYXNr ID0gU05EUlZfUENNX0ZNVEJJVF9BX0xBVworCX0sCisJeworCQkubmFtZSA9IFhFTlNORF9QQ01f Rk9STUFUX01VX0xBV19TVFIsCisJCS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9NVV9MQVcKKwl9 LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENNX0ZPUk1BVF9GMzJfTEVfU1RSLAorCQkubWFzayA9 IFNORFJWX1BDTV9GTVRCSVRfRkxPQVRfTEUKKwl9LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENN X0ZPUk1BVF9GMzJfQkVfU1RSLAorCQkubWFzayA9IFNORFJWX1BDTV9GTVRCSVRfRkxPQVRfQkUK Kwl9LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENNX0ZPUk1BVF9GNjRfTEVfU1RSLAorCQkubWFz ayA9IFNORFJWX1BDTV9GTVRCSVRfRkxPQVQ2NF9MRQorCX0sCisJeworCQkubmFtZSA9IFhFTlNO RF9QQ01fRk9STUFUX0Y2NF9CRV9TVFIsCisJCS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9GTE9B VDY0X0JFCisJfSwKKwl7CisJCS5uYW1lID0gWEVOU05EX1BDTV9GT1JNQVRfSUVDOTU4X1NVQkZS QU1FX0xFX1NUUiwKKwkJLm1hc2sgPSBTTkRSVl9QQ01fRk1UQklUX0lFQzk1OF9TVUJGUkFNRV9M RQorCX0sCisJeworCQkubmFtZSA9IFhFTlNORF9QQ01fRk9STUFUX0lFQzk1OF9TVUJGUkFNRV9C RV9TVFIsCisJCS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9JRUM5NThfU1VCRlJBTUVfQkUKKwl9 LAorCXsKKwkJLm5hbWUgPSBYRU5TTkRfUENNX0ZPUk1BVF9JTUFfQURQQ01fU1RSLAorCQkubWFz ayA9IFNORFJWX1BDTV9GTVRCSVRfSU1BX0FEUENNCisJfSwKKwl7CisJCS5uYW1lID0gWEVOU05E X1BDTV9GT1JNQVRfTVBFR19TVFIsCisJCS5tYXNrID0gU05EUlZfUENNX0ZNVEJJVF9NUEVHCisJ fSwKKwl7CisJCS5uYW1lID0gWEVOU05EX1BDTV9GT1JNQVRfR1NNX1NUUiwKKwkJLm1hc2sgPSBT TkRSVl9QQ01fRk1UQklUX0dTTQorCX0sCit9OworCitzdGF0aWMgdm9pZCBjZmdfaHdfcmF0ZXMo Y2hhciAqbGlzdCwgdW5zaWduZWQgaW50IGxlbiwKKwljb25zdCBjaGFyICpwYXRoLCBzdHJ1Y3Qg c25kX3BjbV9oYXJkd2FyZSAqcGNtX2h3KQoreworCWNoYXIgKmN1cl9yYXRlOworCXVuc2lnbmVk IGludCBjdXJfbWFzazsKKwl1bnNpZ25lZCBpbnQgY3VyX3ZhbHVlOworCXVuc2lnbmVkIGludCBy YXRlczsKKwl1bnNpZ25lZCBpbnQgcmF0ZV9taW47CisJdW5zaWduZWQgaW50IHJhdGVfbWF4Owor CWludCBpOworCisJcmF0ZXMgPSAwOworCXJhdGVfbWluID0gLTE7CisJcmF0ZV9tYXggPSAwOwor CXdoaWxlICgoY3VyX3JhdGUgPSBzdHJzZXAoJmxpc3QsIFhFTlNORF9MSVNUX1NFUEFSQVRPUikp KSB7CisJCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGNmZ19od19zdXBwb3J0ZWRfcmF0ZXMp OyBpKyspCisJCQlpZiAoIXN0cm5jYXNlY21wKGN1cl9yYXRlLAorCQkJCQljZmdfaHdfc3VwcG9y dGVkX3JhdGVzW2ldLm5hbWUsCisJCQkJCVhFTlNORF9TQU1QTEVfUkFURV9NQVhfTEVOKSkgewor CQkJCWN1cl9tYXNrID0gY2ZnX2h3X3N1cHBvcnRlZF9yYXRlc1tpXS5tYXNrOworCQkJCWN1cl92 YWx1ZSA9IGNmZ19od19zdXBwb3J0ZWRfcmF0ZXNbaV0udmFsdWU7CisJCQkJcmF0ZXMgfD0gY3Vy X21hc2s7CisJCQkJaWYgKHJhdGVfbWluID4gY3VyX3ZhbHVlKQorCQkJCQlyYXRlX21pbiA9IGN1 cl92YWx1ZTsKKwkJCQlpZiAocmF0ZV9tYXggPCBjdXJfdmFsdWUpCisJCQkJCXJhdGVfbWF4ID0g Y3VyX3ZhbHVlOworCQkJfQorCX0KKworCWlmIChyYXRlcykgeworCQlwY21faHctPnJhdGVzID0g cmF0ZXM7CisJCXBjbV9ody0+cmF0ZV9taW4gPSByYXRlX21pbjsKKwkJcGNtX2h3LT5yYXRlX21h eCA9IHJhdGVfbWF4OworCX0KK30KKworc3RhdGljIHZvaWQgY2ZnX2Zvcm1hdHMoY2hhciAqbGlz dCwgdW5zaWduZWQgaW50IGxlbiwKKwljb25zdCBjaGFyICpwYXRoLCBzdHJ1Y3Qgc25kX3BjbV9o YXJkd2FyZSAqcGNtX2h3KQoreworCXU2NCBmb3JtYXRzOworCWNoYXIgKmN1cl9mb3JtYXQ7CisJ aW50IGk7CisKKwlmb3JtYXRzID0gMDsKKwl3aGlsZSAoKGN1cl9mb3JtYXQgPSBzdHJzZXAoJmxp c3QsIFhFTlNORF9MSVNUX1NFUEFSQVRPUikpKSB7CisJCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9T SVpFKGNmZ19od19zdXBwb3J0ZWRfZm9ybWF0cyk7IGkrKykKKwkJCWlmICghc3RybmNhc2VjbXAo Y3VyX2Zvcm1hdCwKKwkJCQkJY2ZnX2h3X3N1cHBvcnRlZF9mb3JtYXRzW2ldLm5hbWUsCisJCQkJ CVhFTlNORF9TQU1QTEVfRk9STUFUX01BWF9MRU4pKQorCQkJCWZvcm1hdHMgfD0gY2ZnX2h3X3N1 cHBvcnRlZF9mb3JtYXRzW2ldLm1hc2s7CisJfQorCisJaWYgKGZvcm1hdHMpCisJCXBjbV9ody0+ Zm9ybWF0cyA9IGZvcm1hdHM7Cit9CisKK3N0YXRpYyB2b2lkIGNmZ19wY21faHcoY29uc3QgY2hh ciAqcGF0aCwKKwlzdHJ1Y3Qgc25kX3BjbV9oYXJkd2FyZSAqcGFyZW50X3BjbV9odywKKwlzdHJ1 Y3Qgc25kX3BjbV9oYXJkd2FyZSAqcGNtX2h3KQoreworCWNoYXIgKmxpc3Q7CisJaW50IHZhbDsK KwlzaXplX3QgYnVmX3N6OworCXVuc2lnbmVkIGludCBsZW47CisKKwkvKiBpbmhlcml0IHBhcmVu dCdzIFBDTSBIVyBhbmQgcmVhZCBvdmVycmlkZXMgaWYgYW55ICovCisJKnBjbV9odyA9ICpwYXJl bnRfcGNtX2h3OworCisJdmFsID0geGVuYnVzX3JlYWRfdW5zaWduZWQocGF0aCwgWEVOU05EX0ZJ RUxEX0NIQU5ORUxTX01JTiwgMCk7CisJaWYgKHZhbCkKKwkJcGNtX2h3LT5jaGFubmVsc19taW4g PSB2YWw7CisKKwl2YWwgPSB4ZW5idXNfcmVhZF91bnNpZ25lZChwYXRoLCBYRU5TTkRfRklFTERf Q0hBTk5FTFNfTUFYLCAwKTsKKwlpZiAodmFsKQorCQlwY21faHctPmNoYW5uZWxzX21heCA9IHZh bDsKKworCWxpc3QgPSB4ZW5idXNfcmVhZChYQlRfTklMLCBwYXRoLCBYRU5TTkRfRklFTERfU0FN UExFX1JBVEVTLCAmbGVuKTsKKwlpZiAoIUlTX0VSUihsaXN0KSkgeworCQljZmdfaHdfcmF0ZXMo bGlzdCwgbGVuLCBwYXRoLCBwY21faHcpOworCQlrZnJlZShsaXN0KTsKKwl9CisKKwlsaXN0ID0g eGVuYnVzX3JlYWQoWEJUX05JTCwgcGF0aCwgWEVOU05EX0ZJRUxEX1NBTVBMRV9GT1JNQVRTLCAm bGVuKTsKKwlpZiAoIUlTX0VSUihsaXN0KSkgeworCQljZmdfZm9ybWF0cyhsaXN0LCBsZW4sIHBh dGgsIHBjbV9odyk7CisJCWtmcmVlKGxpc3QpOworCX0KKworCWJ1Zl9zeiA9IHhlbmJ1c19yZWFk X3Vuc2lnbmVkKHBhdGgsIFhFTlNORF9GSUVMRF9CVUZGRVJfU0laRSwgMCk7CisJaWYgKGJ1Zl9z eikKKwkJcGNtX2h3LT5idWZmZXJfYnl0ZXNfbWF4ID0gYnVmX3N6OworfQorCitzdGF0aWMgaW50 IGNmZ19nZXRfc3RyZWFtX3R5cGUoY29uc3QgY2hhciAqcGF0aCwgaW50IGluZGV4LAorCWludCAq bnVtX3BiLCBpbnQgKm51bV9jYXApCit7CisJY2hhciAqc3RyID0gTlVMTDsKKwljaGFyICpzdHJl YW1fcGF0aDsKKwlpbnQgcmV0OworCisJKm51bV9wYiA9IDA7CisJKm51bV9jYXAgPSAwOworCXN0 cmVhbV9wYXRoID0ga2FzcHJpbnRmKEdGUF9LRVJORUwsICIlcy8lZCIsIHBhdGgsIGluZGV4KTsK KwlpZiAoIXN0cmVhbV9wYXRoKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZmFpbDsKKwl9 CisKKwlzdHIgPSB4ZW5idXNfcmVhZChYQlRfTklMLCBzdHJlYW1fcGF0aCwgWEVOU05EX0ZJRUxE X1RZUEUsIE5VTEwpOworCWlmIChJU19FUlIoc3RyKSkgeworCQlyZXQgPSAtRUlOVkFMOworCQln b3RvIGZhaWw7CisJfQorCisJaWYgKCFzdHJuY2FzZWNtcChzdHIsIFhFTlNORF9TVFJFQU1fVFlQ RV9QTEFZQkFDSywKKwkJc2l6ZW9mKFhFTlNORF9TVFJFQU1fVFlQRV9QTEFZQkFDSykpKQorCQko Km51bV9wYikrKzsKKwllbHNlIGlmICghc3RybmNhc2VjbXAoc3RyLCBYRU5TTkRfU1RSRUFNX1RZ UEVfQ0FQVFVSRSwKKwkJc2l6ZW9mKFhFTlNORF9TVFJFQU1fVFlQRV9DQVBUVVJFKSkpCisJCSgq bnVtX2NhcCkrKzsKKwllbHNlIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byBmYWlsOworCX0K KwlyZXQgPSAwOworCitmYWlsOgorCWtmcmVlKHN0cmVhbV9wYXRoKTsKKwlrZnJlZShzdHIpOwor CXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgY2ZnX3N0cmVhbShzdHJ1Y3QgeGRydl9pbmZv ICpkcnZfaW5mbywKKwlzdHJ1Y3QgY2ZnX3BjbV9pbnN0YW5jZSAqcGNtX2luc3RhbmNlLAorCWNv bnN0IGNoYXIgKnBhdGgsIGludCBpbmRleCwgaW50ICpjdXJfcGIsIGludCAqY3VyX2NhcCwKKwlp bnQgKnN0cmVhbV9pZHgpCit7CisJY2hhciAqc3RyID0gTlVMTDsKKwljaGFyICpzdHJlYW1fcGF0 aDsKKwlzdHJ1Y3QgY2ZnX3N0cmVhbSAqc3RyZWFtOworCWludCByZXQ7CisKKwlzdHJlYW1fcGF0 aCA9IGRldm1fa2FzcHJpbnRmKCZkcnZfaW5mby0+eGJfZGV2LT5kZXYsCisJCUdGUF9LRVJORUws ICIlcy8lZCIsIHBhdGgsIGluZGV4KTsKKwlpZiAoIXN0cmVhbV9wYXRoKSB7CisJCXJldCA9IC1F Tk9NRU07CisJCWdvdG8gZmFpbDsKKwl9CisKKwlzdHIgPSB4ZW5idXNfcmVhZChYQlRfTklMLCBz dHJlYW1fcGF0aCwgWEVOU05EX0ZJRUxEX1RZUEUsIE5VTEwpOworCWlmIChJU19FUlIoc3RyKSkg eworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIGZhaWw7CisJfQorCisJaWYgKCFzdHJuY2FzZWNt cChzdHIsIFhFTlNORF9TVFJFQU1fVFlQRV9QTEFZQkFDSywKKwkJc2l6ZW9mKFhFTlNORF9TVFJF QU1fVFlQRV9QTEFZQkFDSykpKSB7CisJCXN0cmVhbSA9ICZwY21faW5zdGFuY2UtPnN0cmVhbXNf cGJbKCpjdXJfcGIpKytdOworCX0gZWxzZSBpZiAoIXN0cm5jYXNlY21wKHN0ciwgWEVOU05EX1NU UkVBTV9UWVBFX0NBUFRVUkUsCisJCXNpemVvZihYRU5TTkRfU1RSRUFNX1RZUEVfQ0FQVFVSRSkp KSB7CisJCXN0cmVhbSA9ICZwY21faW5zdGFuY2UtPnN0cmVhbXNfY2FwWygqY3VyX2NhcCkrK107 CisJfSBlbHNlIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byBmYWlsOworCX0KKworCS8qIGdl dCBuZXh0IHN0cmVhbSBpbmRleCAqLworCXN0cmVhbS0+dW5pcXVlX2lkID0gKCpzdHJlYW1faWR4 KSsrOworCXN0cmVhbS0+eGVuc3RvcmVfcGF0aCA9IHN0cmVhbV9wYXRoOworCS8qCisJICogY2hl Y2sgaW4gWGVuIHN0b3JlIGlmIFBDTSBIVyBjb25maWd1cmF0aW9uIGV4aXN0cyBmb3IgdGhpcyBz dHJlYW0KKwkgKiBhbmQgdXBkYXRlIGlmIHNvLCBlLmcuIHdlIGluaGVyaXQgYWxsIHZhbHVlcyBm cm9tIGRldmljZSdzIFBDTSBIVywKKwkgKiBidXQgY2FuIHN0aWxsIG92ZXJyaWRlIHNvbWUgb2Yg dGhlIHZhbHVlcyBmb3IgdGhlIHN0cmVhbQorCSAqLworCWNmZ19wY21faHcoc3RyZWFtLT54ZW5z dG9yZV9wYXRoLAorCQkmcGNtX2luc3RhbmNlLT5wY21faHcsICZzdHJlYW0tPnBjbV9odyk7CisJ cmV0ID0gMDsKKworZmFpbDoKKwlrZnJlZShzdHIpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRp YyBpbnQgY2ZnX2RldmljZShzdHJ1Y3QgeGRydl9pbmZvICpkcnZfaW5mbywKKwlzdHJ1Y3QgY2Zn X3BjbV9pbnN0YW5jZSAqcGNtX2luc3RhbmNlLAorCXN0cnVjdCBzbmRfcGNtX2hhcmR3YXJlICpw YXJlbnRfcGNtX2h3LAorCWNvbnN0IGNoYXIgKnBhdGgsIGludCBub2RlX2luZGV4LCBpbnQgKnN0 cmVhbV9pZHgpCit7CisJY2hhciAqc3RyOworCWNoYXIgKmRldmljZV9wYXRoOworCWludCByZXQs IGksIG51bV9zdHJlYW1zOworCWludCBudW1fcGIsIG51bV9jYXA7CisJaW50IGN1cl9wYiwgY3Vy X2NhcDsKKwljaGFyIG5vZGVbM107CisKKwlkZXZpY2VfcGF0aCA9IGthc3ByaW50ZihHRlBfS0VS TkVMLCAiJXMvJWQiLCBwYXRoLCBub2RlX2luZGV4KTsKKwlpZiAoIWRldmljZV9wYXRoKQorCQly ZXR1cm4gLUVOT01FTTsKKworCXN0ciA9IHhlbmJ1c19yZWFkKFhCVF9OSUwsIGRldmljZV9wYXRo LCBYRU5TTkRfRklFTERfREVWSUNFX05BTUUsIE5VTEwpOworCWlmICghSVNfRVJSKHN0cikpIHsK KwkJc3RybmNweShwY21faW5zdGFuY2UtPm5hbWUsIHN0ciwgc2l6ZW9mKHBjbV9pbnN0YW5jZS0+ bmFtZSkpOworCQlrZnJlZShzdHIpOworCX0KKworCXBjbV9pbnN0YW5jZS0+ZGV2aWNlX2lkID0g bm9kZV9pbmRleDsKKworCS8qCisJICogY2hlY2sgaW4gWGVuIHN0b3JlIGlmIFBDTSBIVyBjb25m aWd1cmF0aW9uIGV4aXN0cyBmb3IgdGhpcyBkZXZpY2UKKwkgKiBhbmQgdXBkYXRlIGlmIHNvLCBl LmcuIHdlIGluaGVyaXQgYWxsIHZhbHVlcyBmcm9tIGNhcmQncyBQQ00gSFcsCisJICogYnV0IGNh biBzdGlsbCBvdmVycmlkZSBzb21lIG9mIHRoZSB2YWx1ZXMgZm9yIHRoZSBkZXZpY2UKKwkgKi8K KwljZmdfcGNtX2h3KGRldmljZV9wYXRoLCBwYXJlbnRfcGNtX2h3LCAmcGNtX2luc3RhbmNlLT5w Y21faHcpOworCisJLyoKKwkgKiBmaW5kIG91dCBob3cgbWFueSBzdHJlYW1zIHdlcmUgY29uZmln dXJlZCBpbiBYZW4gc3RvcmU6CisJICogc3RyZWFtcyBtdXN0IGhhdmUgc2VxdWVudGlhbCB1bmlx dWUgSURzLCBzbyBzdG9wIHdoZW4gb25lCisJICogZG9lcyBub3QgZXhpc3QKKwkgKi8KKwludW1f c3RyZWFtcyA9IDA7CisJZG8geworCQlzbnByaW50Zihub2RlLCBzaXplb2Yobm9kZSksICIlZCIs IG51bV9zdHJlYW1zKTsKKwkJaWYgKCF4ZW5idXNfZXhpc3RzKFhCVF9OSUwsIGRldmljZV9wYXRo LCBub2RlKSkKKwkJCWJyZWFrOworCisJCW51bV9zdHJlYW1zKys7CisJfSB3aGlsZSAobnVtX3N0 cmVhbXMgPCBWU05EX01BWF9TVFJFQU0pOworCisJcGNtX2luc3RhbmNlLT5udW1fc3RyZWFtc19w YiA9IDA7CisJcGNtX2luc3RhbmNlLT5udW1fc3RyZWFtc19jYXAgPSAwOworCS8qIGdldCBudW1i ZXIgb2YgcGxheWJhY2sgYW5kIGNhcHR1cmUgc3RyZWFtcyAqLworCWZvciAoaSA9IDA7IGkgPCBu dW1fc3RyZWFtczsgaSsrKSB7CisJCXJldCA9IGNmZ19nZXRfc3RyZWFtX3R5cGUoZGV2aWNlX3Bh dGgsIGksICZudW1fcGIsICZudW1fY2FwKTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWw7 CisKKwkJcGNtX2luc3RhbmNlLT5udW1fc3RyZWFtc19wYiArPSBudW1fcGI7CisJCXBjbV9pbnN0 YW5jZS0+bnVtX3N0cmVhbXNfY2FwICs9IG51bV9jYXA7CisJfQorCisJaWYgKHBjbV9pbnN0YW5j ZS0+bnVtX3N0cmVhbXNfcGIpIHsKKwkJcGNtX2luc3RhbmNlLT5zdHJlYW1zX3BiID0gZGV2bV9r Y2FsbG9jKAorCQkJJmRydl9pbmZvLT54Yl9kZXYtPmRldiwKKwkJCXBjbV9pbnN0YW5jZS0+bnVt X3N0cmVhbXNfcGIsCisJCQlzaXplb2Yoc3RydWN0IGNmZ19zdHJlYW0pLCBHRlBfS0VSTkVMKTsK KwkJaWYgKCFwY21faW5zdGFuY2UtPnN0cmVhbXNfcGIpIHsKKwkJCXJldCA9IC1FTk9NRU07CisJ CQlnb3RvIGZhaWw7CisJCX0KKwl9CisKKwlpZiAocGNtX2luc3RhbmNlLT5udW1fc3RyZWFtc19j YXApIHsKKwkJcGNtX2luc3RhbmNlLT5zdHJlYW1zX2NhcCA9IGRldm1fa2NhbGxvYygKKwkJCSZk cnZfaW5mby0+eGJfZGV2LT5kZXYsCisJCQlwY21faW5zdGFuY2UtPm51bV9zdHJlYW1zX2NhcCwK KwkJCXNpemVvZihzdHJ1Y3QgY2ZnX3N0cmVhbSksIEdGUF9LRVJORUwpOworCQlpZiAoIXBjbV9p bnN0YW5jZS0+c3RyZWFtc19jYXApIHsKKwkJCXJldCA9IC1FTk9NRU07CisJCQlnb3RvIGZhaWw7 CisJCX0KKwl9CisKKwljdXJfcGIgPSAwOworCWN1cl9jYXAgPSAwOworCWZvciAoaSA9IDA7IGkg PCBudW1fc3RyZWFtczsgaSsrKSB7CisJCXJldCA9IGNmZ19zdHJlYW0oZHJ2X2luZm8sCisJCQlw Y21faW5zdGFuY2UsIGRldmljZV9wYXRoLCBpLCAmY3VyX3BiLCAmY3VyX2NhcCwKKwkJCXN0cmVh bV9pZHgpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbDsKKwl9CisJcmV0ID0gMDsKKwor ZmFpbDoKKwlrZnJlZShkZXZpY2VfcGF0aCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGlu dCBjZmdfY2FyZChzdHJ1Y3QgeGRydl9pbmZvICpkcnZfaW5mbywKKwlzdHJ1Y3Qgc2Rldl9jYXJk X3BsYXRfZGF0YSAqcGxhdF9kYXRhLCBpbnQgKnN0cmVhbV9pZHgpCit7CisJc3RydWN0IHhlbmJ1 c19kZXZpY2UgKnhiX2RldiA9IGRydl9pbmZvLT54Yl9kZXY7CisJaW50IHJldCwgbnVtX2Rldmlj ZXMsIGk7CisJY2hhciBub2RlWzNdOworCisJbnVtX2RldmljZXMgPSAwOworCWRvIHsKKwkJc25w cmludGYobm9kZSwgc2l6ZW9mKG5vZGUpLCAiJWQiLCBudW1fZGV2aWNlcyk7CisJCWlmICgheGVu YnVzX2V4aXN0cyhYQlRfTklMLCB4Yl9kZXYtPm5vZGVuYW1lLCBub2RlKSkKKwkJCWJyZWFrOwor CisJCW51bV9kZXZpY2VzKys7CisJfSB3aGlsZSAobnVtX2RldmljZXMgPCBTTkRSVl9QQ01fREVW SUNFUyk7CisKKwlpZiAoIW51bV9kZXZpY2VzKSB7CisJCWRldl93YXJuKCZ4Yl9kZXYtPmRldiwK KwkJCSJObyBkZXZpY2VzIGNvbmZpZ3VyZWQgZm9yIHNvdW5kIGNhcmQgYXQgJXNcbiIsCisJCQl4 Yl9kZXYtPm5vZGVuYW1lKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJLyogc3RhcnQgZnJv bSBkZWZhdWx0IFBDTSBIVyBjb25maWd1cmF0aW9uIGZvciB0aGUgY2FyZCAqLworCWNmZ19wY21f aHcoeGJfZGV2LT5ub2RlbmFtZSwgJnNkcnZfcGNtX2h3X2RlZmF1bHQsCisJCSZwbGF0X2RhdGEt PmNmZ19jYXJkLnBjbV9odyk7CisKKwlwbGF0X2RhdGEtPmNmZ19jYXJkLnBjbV9pbnN0YW5jZXMg PSBkZXZtX2tjYWxsb2MoCisJCSZkcnZfaW5mby0+eGJfZGV2LT5kZXYsIG51bV9kZXZpY2VzLAor CQlzaXplb2Yoc3RydWN0IGNmZ19wY21faW5zdGFuY2UpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXBs YXRfZGF0YS0+Y2ZnX2NhcmQucGNtX2luc3RhbmNlcykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlm b3IgKGkgPSAwOyBpIDwgbnVtX2RldmljZXM7IGkrKykgeworCQlyZXQgPSBjZmdfZGV2aWNlKGRy dl9pbmZvLAorCQkJJnBsYXRfZGF0YS0+Y2ZnX2NhcmQucGNtX2luc3RhbmNlc1tpXSwKKwkJCSZw bGF0X2RhdGEtPmNmZ19jYXJkLnBjbV9odywKKwkJCXhiX2Rldi0+bm9kZW5hbWUsIGksIHN0cmVh bV9pZHgpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiByZXQ7CisJfQorCXBsYXRfZGF0YS0+ Y2ZnX2NhcmQubnVtX3BjbV9pbnN0YW5jZXMgPSBudW1fZGV2aWNlczsKKwlyZXR1cm4gMDsKK30K Kwogc3RhdGljIHZvaWQgeGRydl9yZW1vdmVfaW50ZXJuYWwoc3RydWN0IHhkcnZfaW5mbyAqZHJ2 X2luZm8pCiB7CiB9CiAKIHN0YXRpYyBpbnQgeGRydl9iZV9vbl9pbml0d2FpdChzdHJ1Y3QgeGRy dl9pbmZvICpkcnZfaW5mbykKIHsKKwlpbnQgc3RyZWFtX2lkeDsKKwlpbnQgcmV0OworCisJZHJ2 X2luZm8tPmNmZ19wbGF0X2RhdGEueGRydl9pbmZvID0gZHJ2X2luZm87CisJc3RyZWFtX2lkeCA9 IDA7CisJcmV0ID0gY2ZnX2NhcmQoZHJ2X2luZm8sICZkcnZfaW5mby0+Y2ZnX3BsYXRfZGF0YSwg JnN0cmVhbV9pZHgpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OwogCXJldHVybiAwOwog fQogCi0tIAoyLjcuNAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0 cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753454AbdHGMZt (ORCPT ); Mon, 7 Aug 2017 08:25:49 -0400 Received: from mail-lf0-f67.google.com ([209.85.215.67]:32786 "EHLO mail-lf0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753275AbdHGMXJ (ORCPT ); Mon, 7 Aug 2017 08:23:09 -0400 From: Oleksandr Andrushchenko To: alsa-devel@alsa-project.org, xen-devel@lists.xen.org, linux-kernel@vger.kernel.org Cc: perex@perex.cz, tiwai@suse.com, andr2000@gmail.com, Oleksandr Andrushchenko Subject: [PATCH RESEND1 04/12] ALSA: vsnd: Read sound driver configuration from Xen store Date: Mon, 7 Aug 2017 15:22:49 +0300 Message-Id: <1502108577-8099-5-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1502108577-8099-1-git-send-email-andr2000@gmail.com> References: <1502108577-8099-1-git-send-email-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Read configuration values from Xen store according to xen/interface/io/sndif.h protocol: - introduce configuration structures for different components, e.g. sound card, device, stream - read PCM HW parameters, e.g rate, format etc. - detect stream type (capture/playback) - read device and card parameters Fill in platform data with the configuration read, so it can be passed to sound driver later. Signed-off-by: Oleksandr Andrushchenko --- sound/drivers/xen-front.c | 530 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 530 insertions(+) diff --git a/sound/drivers/xen-front.c b/sound/drivers/xen-front.c index c4fd21cac3a7..ef48cbf44cf2 100644 --- a/sound/drivers/xen-front.c +++ b/sound/drivers/xen-front.c @@ -20,24 +20,554 @@ #include +#include +#include + #include #include #include #include +/* maximum number of supported streams */ +#define VSND_MAX_STREAM 8 + +struct cfg_stream { + int unique_id; + char *xenstore_path; + struct snd_pcm_hardware pcm_hw; +}; + +struct cfg_pcm_instance { + char name[80]; + int device_id; + struct snd_pcm_hardware pcm_hw; + int num_streams_pb; + struct cfg_stream *streams_pb; + int num_streams_cap; + struct cfg_stream *streams_cap; +}; + +struct cfg_card { + char name_short[32]; + char name_long[80]; + struct snd_pcm_hardware pcm_hw; + int num_pcm_instances; + struct cfg_pcm_instance *pcm_instances; +}; + +struct sdev_card_plat_data { + struct xdrv_info *xdrv_info; + struct cfg_card cfg_card; +}; + struct xdrv_info { struct xenbus_device *xb_dev; spinlock_t io_lock; struct mutex mutex; + struct sdev_card_plat_data cfg_plat_data; }; +#define MAX_XEN_BUFFER_SIZE (64 * 1024) +#define MAX_BUFFER_SIZE MAX_XEN_BUFFER_SIZE +#define MIN_PERIOD_SIZE 64 +#define MAX_PERIOD_SIZE (MAX_BUFFER_SIZE / 8) +#define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | \ + SNDRV_PCM_FMTBIT_S16_LE) +#define USE_RATE (SNDRV_PCM_RATE_CONTINUOUS | \ + SNDRV_PCM_RATE_8000_48000) +#define USE_RATE_MIN 5512 +#define USE_RATE_MAX 48000 +#define USE_CHANNELS_MIN 1 +#define USE_CHANNELS_MAX 2 +#define USE_PERIODS_MIN 2 +#define USE_PERIODS_MAX 8 + +static struct snd_pcm_hardware sdrv_pcm_hw_default = { + .info = (SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_RESUME | + SNDRV_PCM_INFO_MMAP_VALID), + .formats = USE_FORMATS, + .rates = USE_RATE, + .rate_min = USE_RATE_MIN, + .rate_max = USE_RATE_MAX, + .channels_min = USE_CHANNELS_MIN, + .channels_max = USE_CHANNELS_MAX, + .buffer_bytes_max = MAX_BUFFER_SIZE, + .period_bytes_min = MIN_PERIOD_SIZE, + .period_bytes_max = MAX_PERIOD_SIZE, + .periods_min = USE_PERIODS_MIN, + .periods_max = USE_PERIODS_MAX, + .fifo_size = 0, +}; + +struct CFG_HW_SAMPLE_RATE { + const char *name; + unsigned int mask; + unsigned int value; +}; + +static struct CFG_HW_SAMPLE_RATE cfg_hw_supported_rates[] = { + { .name = "5512", .mask = SNDRV_PCM_RATE_5512, .value = 5512 }, + { .name = "8000", .mask = SNDRV_PCM_RATE_8000, .value = 8000 }, + { .name = "11025", .mask = SNDRV_PCM_RATE_11025, .value = 11025 }, + { .name = "16000", .mask = SNDRV_PCM_RATE_16000, .value = 16000 }, + { .name = "22050", .mask = SNDRV_PCM_RATE_22050, .value = 22050 }, + { .name = "32000", .mask = SNDRV_PCM_RATE_32000, .value = 32000 }, + { .name = "44100", .mask = SNDRV_PCM_RATE_44100, .value = 44100 }, + { .name = "48000", .mask = SNDRV_PCM_RATE_48000, .value = 48000 }, + { .name = "64000", .mask = SNDRV_PCM_RATE_64000, .value = 64000 }, + { .name = "96000", .mask = SNDRV_PCM_RATE_96000, .value = 96000 }, + { .name = "176400", .mask = SNDRV_PCM_RATE_176400, .value = 176400 }, + { .name = "192000", .mask = SNDRV_PCM_RATE_192000, .value = 192000 }, +}; + +struct CFG_HW_SAMPLE_FORMAT { + const char *name; + u64 mask; +}; + +static struct CFG_HW_SAMPLE_FORMAT cfg_hw_supported_formats[] = { + { + .name = XENSND_PCM_FORMAT_U8_STR, + .mask = SNDRV_PCM_FMTBIT_U8 + }, + { + .name = XENSND_PCM_FORMAT_S8_STR, + .mask = SNDRV_PCM_FMTBIT_S8 + }, + { + .name = XENSND_PCM_FORMAT_U16_LE_STR, + .mask = SNDRV_PCM_FMTBIT_U16_LE + }, + { + .name = XENSND_PCM_FORMAT_U16_BE_STR, + .mask = SNDRV_PCM_FMTBIT_U16_BE + }, + { + .name = XENSND_PCM_FORMAT_S16_LE_STR, + .mask = SNDRV_PCM_FMTBIT_S16_LE + }, + { + .name = XENSND_PCM_FORMAT_S16_BE_STR, + .mask = SNDRV_PCM_FMTBIT_S16_BE + }, + { + .name = XENSND_PCM_FORMAT_U24_LE_STR, + .mask = SNDRV_PCM_FMTBIT_U24_LE + }, + { + .name = XENSND_PCM_FORMAT_U24_BE_STR, + .mask = SNDRV_PCM_FMTBIT_U24_BE + }, + { + .name = XENSND_PCM_FORMAT_S24_LE_STR, + .mask = SNDRV_PCM_FMTBIT_S24_LE + }, + { + .name = XENSND_PCM_FORMAT_S24_BE_STR, + .mask = SNDRV_PCM_FMTBIT_S24_BE + }, + { + .name = XENSND_PCM_FORMAT_U32_LE_STR, + .mask = SNDRV_PCM_FMTBIT_U32_LE + }, + { + .name = XENSND_PCM_FORMAT_U32_BE_STR, + .mask = SNDRV_PCM_FMTBIT_U32_BE + }, + { + .name = XENSND_PCM_FORMAT_S32_LE_STR, + .mask = SNDRV_PCM_FMTBIT_S32_LE + }, + { + .name = XENSND_PCM_FORMAT_S32_BE_STR, + .mask = SNDRV_PCM_FMTBIT_S32_BE + }, + { + .name = XENSND_PCM_FORMAT_A_LAW_STR, + .mask = SNDRV_PCM_FMTBIT_A_LAW + }, + { + .name = XENSND_PCM_FORMAT_MU_LAW_STR, + .mask = SNDRV_PCM_FMTBIT_MU_LAW + }, + { + .name = XENSND_PCM_FORMAT_F32_LE_STR, + .mask = SNDRV_PCM_FMTBIT_FLOAT_LE + }, + { + .name = XENSND_PCM_FORMAT_F32_BE_STR, + .mask = SNDRV_PCM_FMTBIT_FLOAT_BE + }, + { + .name = XENSND_PCM_FORMAT_F64_LE_STR, + .mask = SNDRV_PCM_FMTBIT_FLOAT64_LE + }, + { + .name = XENSND_PCM_FORMAT_F64_BE_STR, + .mask = SNDRV_PCM_FMTBIT_FLOAT64_BE + }, + { + .name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_LE_STR, + .mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE + }, + { + .name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_BE_STR, + .mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE + }, + { + .name = XENSND_PCM_FORMAT_IMA_ADPCM_STR, + .mask = SNDRV_PCM_FMTBIT_IMA_ADPCM + }, + { + .name = XENSND_PCM_FORMAT_MPEG_STR, + .mask = SNDRV_PCM_FMTBIT_MPEG + }, + { + .name = XENSND_PCM_FORMAT_GSM_STR, + .mask = SNDRV_PCM_FMTBIT_GSM + }, +}; + +static void cfg_hw_rates(char *list, unsigned int len, + const char *path, struct snd_pcm_hardware *pcm_hw) +{ + char *cur_rate; + unsigned int cur_mask; + unsigned int cur_value; + unsigned int rates; + unsigned int rate_min; + unsigned int rate_max; + int i; + + rates = 0; + rate_min = -1; + rate_max = 0; + while ((cur_rate = strsep(&list, XENSND_LIST_SEPARATOR))) { + for (i = 0; i < ARRAY_SIZE(cfg_hw_supported_rates); i++) + if (!strncasecmp(cur_rate, + cfg_hw_supported_rates[i].name, + XENSND_SAMPLE_RATE_MAX_LEN)) { + cur_mask = cfg_hw_supported_rates[i].mask; + cur_value = cfg_hw_supported_rates[i].value; + rates |= cur_mask; + if (rate_min > cur_value) + rate_min = cur_value; + if (rate_max < cur_value) + rate_max = cur_value; + } + } + + if (rates) { + pcm_hw->rates = rates; + pcm_hw->rate_min = rate_min; + pcm_hw->rate_max = rate_max; + } +} + +static void cfg_formats(char *list, unsigned int len, + const char *path, struct snd_pcm_hardware *pcm_hw) +{ + u64 formats; + char *cur_format; + int i; + + formats = 0; + while ((cur_format = strsep(&list, XENSND_LIST_SEPARATOR))) { + for (i = 0; i < ARRAY_SIZE(cfg_hw_supported_formats); i++) + if (!strncasecmp(cur_format, + cfg_hw_supported_formats[i].name, + XENSND_SAMPLE_FORMAT_MAX_LEN)) + formats |= cfg_hw_supported_formats[i].mask; + } + + if (formats) + pcm_hw->formats = formats; +} + +static void cfg_pcm_hw(const char *path, + struct snd_pcm_hardware *parent_pcm_hw, + struct snd_pcm_hardware *pcm_hw) +{ + char *list; + int val; + size_t buf_sz; + unsigned int len; + + /* inherit parent's PCM HW and read overrides if any */ + *pcm_hw = *parent_pcm_hw; + + val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MIN, 0); + if (val) + pcm_hw->channels_min = val; + + val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MAX, 0); + if (val) + pcm_hw->channels_max = val; + + list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_RATES, &len); + if (!IS_ERR(list)) { + cfg_hw_rates(list, len, path, pcm_hw); + kfree(list); + } + + list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_FORMATS, &len); + if (!IS_ERR(list)) { + cfg_formats(list, len, path, pcm_hw); + kfree(list); + } + + buf_sz = xenbus_read_unsigned(path, XENSND_FIELD_BUFFER_SIZE, 0); + if (buf_sz) + pcm_hw->buffer_bytes_max = buf_sz; +} + +static int cfg_get_stream_type(const char *path, int index, + int *num_pb, int *num_cap) +{ + char *str = NULL; + char *stream_path; + int ret; + + *num_pb = 0; + *num_cap = 0; + stream_path = kasprintf(GFP_KERNEL, "%s/%d", path, index); + if (!stream_path) { + ret = -ENOMEM; + goto fail; + } + + str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL); + if (IS_ERR(str)) { + ret = -EINVAL; + goto fail; + } + + if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK, + sizeof(XENSND_STREAM_TYPE_PLAYBACK))) + (*num_pb)++; + else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE, + sizeof(XENSND_STREAM_TYPE_CAPTURE))) + (*num_cap)++; + else { + ret = -EINVAL; + goto fail; + } + ret = 0; + +fail: + kfree(stream_path); + kfree(str); + return ret; +} + +static int cfg_stream(struct xdrv_info *drv_info, + struct cfg_pcm_instance *pcm_instance, + const char *path, int index, int *cur_pb, int *cur_cap, + int *stream_idx) +{ + char *str = NULL; + char *stream_path; + struct cfg_stream *stream; + int ret; + + stream_path = devm_kasprintf(&drv_info->xb_dev->dev, + GFP_KERNEL, "%s/%d", path, index); + if (!stream_path) { + ret = -ENOMEM; + goto fail; + } + + str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL); + if (IS_ERR(str)) { + ret = -EINVAL; + goto fail; + } + + if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK, + sizeof(XENSND_STREAM_TYPE_PLAYBACK))) { + stream = &pcm_instance->streams_pb[(*cur_pb)++]; + } else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE, + sizeof(XENSND_STREAM_TYPE_CAPTURE))) { + stream = &pcm_instance->streams_cap[(*cur_cap)++]; + } else { + ret = -EINVAL; + goto fail; + } + + /* get next stream index */ + stream->unique_id = (*stream_idx)++; + stream->xenstore_path = stream_path; + /* + * check in Xen store if PCM HW configuration exists for this stream + * and update if so, e.g. we inherit all values from device's PCM HW, + * but can still override some of the values for the stream + */ + cfg_pcm_hw(stream->xenstore_path, + &pcm_instance->pcm_hw, &stream->pcm_hw); + ret = 0; + +fail: + kfree(str); + return ret; +} + +static int cfg_device(struct xdrv_info *drv_info, + struct cfg_pcm_instance *pcm_instance, + struct snd_pcm_hardware *parent_pcm_hw, + const char *path, int node_index, int *stream_idx) +{ + char *str; + char *device_path; + int ret, i, num_streams; + int num_pb, num_cap; + int cur_pb, cur_cap; + char node[3]; + + device_path = kasprintf(GFP_KERNEL, "%s/%d", path, node_index); + if (!device_path) + return -ENOMEM; + + str = xenbus_read(XBT_NIL, device_path, XENSND_FIELD_DEVICE_NAME, NULL); + if (!IS_ERR(str)) { + strncpy(pcm_instance->name, str, sizeof(pcm_instance->name)); + kfree(str); + } + + pcm_instance->device_id = node_index; + + /* + * check in Xen store if PCM HW configuration exists for this device + * and update if so, e.g. we inherit all values from card's PCM HW, + * but can still override some of the values for the device + */ + cfg_pcm_hw(device_path, parent_pcm_hw, &pcm_instance->pcm_hw); + + /* + * find out how many streams were configured in Xen store: + * streams must have sequential unique IDs, so stop when one + * does not exist + */ + num_streams = 0; + do { + snprintf(node, sizeof(node), "%d", num_streams); + if (!xenbus_exists(XBT_NIL, device_path, node)) + break; + + num_streams++; + } while (num_streams < VSND_MAX_STREAM); + + pcm_instance->num_streams_pb = 0; + pcm_instance->num_streams_cap = 0; + /* get number of playback and capture streams */ + for (i = 0; i < num_streams; i++) { + ret = cfg_get_stream_type(device_path, i, &num_pb, &num_cap); + if (ret < 0) + goto fail; + + pcm_instance->num_streams_pb += num_pb; + pcm_instance->num_streams_cap += num_cap; + } + + if (pcm_instance->num_streams_pb) { + pcm_instance->streams_pb = devm_kcalloc( + &drv_info->xb_dev->dev, + pcm_instance->num_streams_pb, + sizeof(struct cfg_stream), GFP_KERNEL); + if (!pcm_instance->streams_pb) { + ret = -ENOMEM; + goto fail; + } + } + + if (pcm_instance->num_streams_cap) { + pcm_instance->streams_cap = devm_kcalloc( + &drv_info->xb_dev->dev, + pcm_instance->num_streams_cap, + sizeof(struct cfg_stream), GFP_KERNEL); + if (!pcm_instance->streams_cap) { + ret = -ENOMEM; + goto fail; + } + } + + cur_pb = 0; + cur_cap = 0; + for (i = 0; i < num_streams; i++) { + ret = cfg_stream(drv_info, + pcm_instance, device_path, i, &cur_pb, &cur_cap, + stream_idx); + if (ret < 0) + goto fail; + } + ret = 0; + +fail: + kfree(device_path); + return ret; +} + +static int cfg_card(struct xdrv_info *drv_info, + struct sdev_card_plat_data *plat_data, int *stream_idx) +{ + struct xenbus_device *xb_dev = drv_info->xb_dev; + int ret, num_devices, i; + char node[3]; + + num_devices = 0; + do { + snprintf(node, sizeof(node), "%d", num_devices); + if (!xenbus_exists(XBT_NIL, xb_dev->nodename, node)) + break; + + num_devices++; + } while (num_devices < SNDRV_PCM_DEVICES); + + if (!num_devices) { + dev_warn(&xb_dev->dev, + "No devices configured for sound card at %s\n", + xb_dev->nodename); + return -ENODEV; + } + + /* start from default PCM HW configuration for the card */ + cfg_pcm_hw(xb_dev->nodename, &sdrv_pcm_hw_default, + &plat_data->cfg_card.pcm_hw); + + plat_data->cfg_card.pcm_instances = devm_kcalloc( + &drv_info->xb_dev->dev, num_devices, + sizeof(struct cfg_pcm_instance), GFP_KERNEL); + if (!plat_data->cfg_card.pcm_instances) + return -ENOMEM; + + for (i = 0; i < num_devices; i++) { + ret = cfg_device(drv_info, + &plat_data->cfg_card.pcm_instances[i], + &plat_data->cfg_card.pcm_hw, + xb_dev->nodename, i, stream_idx); + if (ret < 0) + return ret; + } + plat_data->cfg_card.num_pcm_instances = num_devices; + return 0; +} + static void xdrv_remove_internal(struct xdrv_info *drv_info) { } static int xdrv_be_on_initwait(struct xdrv_info *drv_info) { + int stream_idx; + int ret; + + drv_info->cfg_plat_data.xdrv_info = drv_info; + stream_idx = 0; + ret = cfg_card(drv_info, &drv_info->cfg_plat_data, &stream_idx); + if (ret < 0) + return ret; return 0; } -- 2.7.4