From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH RESEND1 08/12] ALSA: vsnd: Initialize virtul sound card Date: Mon, 7 Aug 2017 15:22:53 +0300 Message-ID: <1502108577-8099-9-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 YW0uY29tPgoKSW5pdGlhbGl6ZSB2aXJ0dWFsIHNvdW5kIGNhcmQgd2l0aCBzdHJlYW1zIGFjY29y ZGluZyB0byB0aGUKWGVuIHN0b3JlIGNvbmZpZ3VyYXRpb24uCkFkZCBzdHVicyBmb3Igc3RyZWFt IFBDTSBvcGVyYXRpb25zLgoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28g PG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIHNvdW5kL2RyaXZlcnMveGVu LWZyb250LmMgfCAyMzIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKwogMSBmaWxlIGNoYW5nZWQsIDIzMiBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvc291 bmQvZHJpdmVycy94ZW4tZnJvbnQuYyBiL3NvdW5kL2RyaXZlcnMveGVuLWZyb250LmMKaW5kZXgg ZjNlM2Y2NGYwYWE2Li45ZjMxZTY4MzIwODYgMTAwNjQ0Ci0tLSBhL3NvdW5kL2RyaXZlcnMveGVu LWZyb250LmMKKysrIGIvc291bmQvZHJpdmVycy94ZW4tZnJvbnQuYwpAQCAtMTM0LDYgKzEzNCwx MjkgQEAgc3RydWN0IHhkcnZfaW5mbyB7CiAJc3RydWN0IHNkZXZfY2FyZF9wbGF0X2RhdGEgY2Zn X3BsYXRfZGF0YTsKIH07CiAKK3N0YXRpYyBzdHJ1Y3Qgc2Rldl9wY21fc3RyZWFtX2luZm8gKnNk cnZfc3RyZWFtX2dldCgKKwlzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSkKK3sK KwlzdHJ1Y3Qgc2Rldl9wY21faW5zdGFuY2VfaW5mbyAqcGNtX2luc3RhbmNlID0KKwkJc25kX3Bj bV9zdWJzdHJlYW1fY2hpcChzdWJzdHJlYW0pOworCXN0cnVjdCBzZGV2X3BjbV9zdHJlYW1faW5m byAqc3RyZWFtOworCisJaWYgKHN1YnN0cmVhbS0+c3RyZWFtID09IFNORFJWX1BDTV9TVFJFQU1f UExBWUJBQ0spCisJCXN0cmVhbSA9ICZwY21faW5zdGFuY2UtPnN0cmVhbXNfcGJbc3Vic3RyZWFt LT5udW1iZXJdOworCWVsc2UKKwkJc3RyZWFtID0gJnBjbV9pbnN0YW5jZS0+c3RyZWFtc19jYXBb c3Vic3RyZWFtLT5udW1iZXJdOworCXJldHVybiBzdHJlYW07Cit9CisKK3N0YXRpYyB2b2lkIHNk cnZfY29weV9wY21faHcoc3RydWN0IHNuZF9wY21faGFyZHdhcmUgKmRzdCwKKwlzdHJ1Y3Qgc25k X3BjbV9oYXJkd2FyZSAqc3JjLAorCXN0cnVjdCBzbmRfcGNtX2hhcmR3YXJlICpyZWZfcGNtX2h3 KQoreworCSpkc3QgPSAqcmVmX3BjbV9odzsKKworCWlmIChzcmMtPmZvcm1hdHMpCisJCWRzdC0+ Zm9ybWF0cyA9IHNyYy0+Zm9ybWF0czsKKwlpZiAoc3JjLT5idWZmZXJfYnl0ZXNfbWF4KQorCQlk c3QtPmJ1ZmZlcl9ieXRlc19tYXggPQorCQkJc3JjLT5idWZmZXJfYnl0ZXNfbWF4OworCWlmIChz cmMtPnBlcmlvZF9ieXRlc19taW4pCisJCWRzdC0+cGVyaW9kX2J5dGVzX21pbiA9CisJCQlzcmMt PnBlcmlvZF9ieXRlc19taW47CisJaWYgKHNyYy0+cGVyaW9kX2J5dGVzX21heCkKKwkJZHN0LT5w ZXJpb2RfYnl0ZXNfbWF4ID0KKwkJCXNyYy0+cGVyaW9kX2J5dGVzX21heDsKKwlpZiAoc3JjLT5w ZXJpb2RzX21pbikKKwkJZHN0LT5wZXJpb2RzX21pbiA9IHNyYy0+cGVyaW9kc19taW47CisJaWYg KHNyYy0+cGVyaW9kc19tYXgpCisJCWRzdC0+cGVyaW9kc19tYXggPSBzcmMtPnBlcmlvZHNfbWF4 OworCWlmIChzcmMtPnJhdGVzKQorCQlkc3QtPnJhdGVzID0gc3JjLT5yYXRlczsKKwlpZiAoc3Jj LT5yYXRlX21pbikKKwkJZHN0LT5yYXRlX21pbiA9IHNyYy0+cmF0ZV9taW47CisJaWYgKHNyYy0+ cmF0ZV9tYXgpCisJCWRzdC0+cmF0ZV9tYXggPSBzcmMtPnJhdGVfbWF4OworCWlmIChzcmMtPmNo YW5uZWxzX21pbikKKwkJZHN0LT5jaGFubmVsc19taW4gPSBzcmMtPmNoYW5uZWxzX21pbjsKKwlp ZiAoc3JjLT5jaGFubmVsc19tYXgpCisJCWRzdC0+Y2hhbm5lbHNfbWF4ID0gc3JjLT5jaGFubmVs c19tYXg7CisJaWYgKHNyYy0+YnVmZmVyX2J5dGVzX21heCkgeworCQlkc3QtPmJ1ZmZlcl9ieXRl c19tYXggPSBzcmMtPmJ1ZmZlcl9ieXRlc19tYXg7CisJCWRzdC0+cGVyaW9kX2J5dGVzX21heCA9 IHNyYy0+YnVmZmVyX2J5dGVzX21heCAvCisJCQlzcmMtPnBlcmlvZHNfbWF4OworCQlkc3QtPnBl cmlvZHNfbWF4ID0gZHN0LT5idWZmZXJfYnl0ZXNfbWF4IC8KKwkJCWRzdC0+cGVyaW9kX2J5dGVz X21heDsKKwl9Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX29wZW4oc3RydWN0IHNuZF9wY21f c3Vic3RyZWFtICpzdWJzdHJlYW0pCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Ry dl9hbHNhX2Nsb3NlKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtKQoreworCXJl dHVybiAwOworfQorCitzdGF0aWMgaW50IHNkcnZfYWxzYV9od19wYXJhbXMoc3RydWN0IHNuZF9w Y21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCisJc3RydWN0IHNuZF9wY21faHdfcGFyYW1zICpwYXJh bXMpCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX2h3X2ZyZWUoc3Ry dWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0pCit7CisJcmV0dXJuIDA7Cit9CisKK3N0 YXRpYyBpbnQgc2Rydl9hbHNhX3ByZXBhcmUoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJz dHJlYW0pCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX3RyaWdnZXIo c3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sIGludCBjbWQpCit7CisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgc25kX3BjbV91ZnJhbWVzX3Qgc2Rydl9hbHNhX3BvaW50 ZXIoCisJc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0pCit7CisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX3BsYXliYWNrX2NvcHlfdXNlcihzdHJ1Y3Qgc25k X3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSwKKwkJaW50IGNoYW5uZWwsIHVuc2lnbmVkIGxvbmcg cG9zLCB2b2lkIF9fdXNlciAqYnVmLAorCQl1bnNpZ25lZCBsb25nIGJ5dGVzKQoreworCXJldHVy biAwOworfQorCitzdGF0aWMgaW50IHNkcnZfYWxzYV9wbGF5YmFja19jb3B5X2tlcm5lbChzdHJ1 Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSwKKwkJaW50IGNoYW5uZWwsIHVuc2lnbmVk IGxvbmcgcG9zLCB2b2lkICpidWYsIHVuc2lnbmVkIGxvbmcgYnl0ZXMpCit7CisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX2NhcHR1cmVfY29weV91c2VyKHN0cnVjdCBzbmRf cGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtLAorCQlpbnQgY2hhbm5lbCwgdW5zaWduZWQgbG9uZyBw b3MsIHZvaWQgX191c2VyICpidWYsCisJCXVuc2lnbmVkIGxvbmcgYnl0ZXMpCit7CisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX2NhcHR1cmVfY29weV9rZXJuZWwoc3RydWN0 IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCisJCWludCBjaGFubmVsLCB1bnNpZ25lZCBs b25nIHBvcywgdm9pZCAqYnVmLCB1bnNpZ25lZCBsb25nIGJ5dGVzKQoreworCXJldHVybiAwOwor fQorCitzdGF0aWMgaW50IHNkcnZfYWxzYV9wbGF5YmFja19maWxsX3NpbGVuY2Uoc3RydWN0IHNu ZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCisJaW50IGNoYW5uZWwsIHVuc2lnbmVkIGxvbmcg cG9zLCB1bnNpZ25lZCBsb25nIGJ5dGVzKQoreworCXJldHVybiAwOworfQorCiAjZGVmaW5lIE1B WF9YRU5fQlVGRkVSX1NJWkUJKDY0ICogMTAyNCkKICNkZWZpbmUgTUFYX0JVRkZFUl9TSVpFCQlN QVhfWEVOX0JVRkZFUl9TSVpFCiAjZGVmaW5lIE1JTl9QRVJJT0RfU0laRQkJNjQKQEAgLTE2OCwx MCArMjkxLDExOSBAQCBzdGF0aWMgc3RydWN0IHNuZF9wY21faGFyZHdhcmUgc2Rydl9wY21faHdf ZGVmYXVsdCA9IHsKIAkuZmlmb19zaXplID0gMCwKIH07CiAKKy8qCisgKiBGSVhNRTogVGhlIG1t YXBlZCBkYXRhIHRyYW5zZmVyIGlzIGFzeW5jaHJvbm91cyBhbmQgdGhlcmUgaXMgbm8KKyAqIGFj ayBzaWduYWwgZnJvbSB1c2VyLXNwYWNlIHdoZW4gaXQgaXMgZG9uZS4gVGhpcyBpcyB0aGUKKyAq IHJlYXNvbiBpdCBpcyBub3QgaW1wbGVtZW50ZWQgaW4gdGhlIFBWIGRyaXZlciBhcyB3ZSBkbyBu ZWVkCisgKiB0byBrbm93IHdoZW4gdGhlIGJ1ZmZlciBjYW4gYmUgdHJhbnNmZXJyZWQgdG8gdGhl IGJhY2tlbmQuCisgKi8KKworc3RhdGljIHN0cnVjdCBzbmRfcGNtX29wcyBzZHJ2X2Fsc2FfcGxh eWJhY2tfb3BzID0geworCS5vcGVuID0gc2Rydl9hbHNhX29wZW4sCisJLmNsb3NlID0gc2Rydl9h bHNhX2Nsb3NlLAorCS5pb2N0bCA9IHNuZF9wY21fbGliX2lvY3RsLAorCS5od19wYXJhbXMgPSBz ZHJ2X2Fsc2FfaHdfcGFyYW1zLAorCS5od19mcmVlID0gc2Rydl9hbHNhX2h3X2ZyZWUsCisJLnBy ZXBhcmUgPSBzZHJ2X2Fsc2FfcHJlcGFyZSwKKwkudHJpZ2dlciA9IHNkcnZfYWxzYV90cmlnZ2Vy LAorCS5wb2ludGVyID0gc2Rydl9hbHNhX3BvaW50ZXIsCisJLmNvcHlfdXNlciA9IHNkcnZfYWxz YV9wbGF5YmFja19jb3B5X3VzZXIsCisJLmNvcHlfa2VybmVsID0gc2Rydl9hbHNhX3BsYXliYWNr X2NvcHlfa2VybmVsLAorCS5maWxsX3NpbGVuY2UgPSBzZHJ2X2Fsc2FfcGxheWJhY2tfZmlsbF9z aWxlbmNlLAorfTsKKworc3RhdGljIHN0cnVjdCBzbmRfcGNtX29wcyBzZHJ2X2Fsc2FfY2FwdHVy ZV9vcHMgPSB7CisJLm9wZW4gPSBzZHJ2X2Fsc2Ffb3BlbiwKKwkuY2xvc2UgPSBzZHJ2X2Fsc2Ff Y2xvc2UsCisJLmlvY3RsID0gc25kX3BjbV9saWJfaW9jdGwsCisJLmh3X3BhcmFtcyA9IHNkcnZf YWxzYV9od19wYXJhbXMsCisJLmh3X2ZyZWUgPSBzZHJ2X2Fsc2FfaHdfZnJlZSwKKwkucHJlcGFy ZSA9IHNkcnZfYWxzYV9wcmVwYXJlLAorCS50cmlnZ2VyID0gc2Rydl9hbHNhX3RyaWdnZXIsCisJ LnBvaW50ZXIgPSBzZHJ2X2Fsc2FfcG9pbnRlciwKKwkuY29weV91c2VyID0gc2Rydl9hbHNhX2Nh cHR1cmVfY29weV91c2VyLAorCS5jb3B5X2tlcm5lbCA9IHNkcnZfYWxzYV9jYXB0dXJlX2NvcHlf a2VybmVsLAorfTsKKwogc3RhdGljIGludCBzZHJ2X25ld19wY20oc3RydWN0IHNkZXZfY2FyZF9p bmZvICpjYXJkX2luZm8sCiAJc3RydWN0IGNmZ19wY21faW5zdGFuY2UgKmluc3RhbmNlX2NvbmZp ZywKIAlzdHJ1Y3Qgc2Rldl9wY21faW5zdGFuY2VfaW5mbyAqcGNtX2luc3RhbmNlX2luZm8pCiB7 CisJc3RydWN0IHNuZF9wY20gKnBjbTsKKwlpbnQgcmV0LCBpOworCisJZGV2X2RiZygmY2FyZF9p bmZvLT54ZHJ2X2luZm8tPnhiX2Rldi0+ZGV2LAorCQkiTmV3IFBDTSBkZXZpY2UgXCIlc1wiIHdp dGggaWQgJWQgcGxheWJhY2sgJWQgY2FwdHVyZSAlZCIsCisJCWluc3RhbmNlX2NvbmZpZy0+bmFt ZSwKKwkJaW5zdGFuY2VfY29uZmlnLT5kZXZpY2VfaWQsCisJCWluc3RhbmNlX2NvbmZpZy0+bnVt X3N0cmVhbXNfcGIsCisJCWluc3RhbmNlX2NvbmZpZy0+bnVtX3N0cmVhbXNfY2FwKTsKKworCXBj bV9pbnN0YW5jZV9pbmZvLT5jYXJkX2luZm8gPSBjYXJkX2luZm87CisKKwlzZHJ2X2NvcHlfcGNt X2h3KCZwY21faW5zdGFuY2VfaW5mby0+cGNtX2h3LAorCQkmaW5zdGFuY2VfY29uZmlnLT5wY21f aHcsICZjYXJkX2luZm8tPnBjbV9odyk7CisKKwlpZiAoaW5zdGFuY2VfY29uZmlnLT5udW1fc3Ry ZWFtc19wYikgeworCQlwY21faW5zdGFuY2VfaW5mby0+c3RyZWFtc19wYiA9IGRldm1fa2NhbGxv YygKKwkJCSZjYXJkX2luZm8tPmNhcmQtPmNhcmRfZGV2LAorCQkJaW5zdGFuY2VfY29uZmlnLT5u dW1fc3RyZWFtc19wYiwKKwkJCXNpemVvZihzdHJ1Y3Qgc2Rldl9wY21fc3RyZWFtX2luZm8pLAor CQkJR0ZQX0tFUk5FTCk7CisJCWlmICghcGNtX2luc3RhbmNlX2luZm8tPnN0cmVhbXNfcGIpCisJ CQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlpZiAoaW5zdGFuY2VfY29uZmlnLT5udW1fc3RyZWFt c19jYXApIHsKKwkJcGNtX2luc3RhbmNlX2luZm8tPnN0cmVhbXNfY2FwID0gZGV2bV9rY2FsbG9j KAorCQkJJmNhcmRfaW5mby0+Y2FyZC0+Y2FyZF9kZXYsCisJCQlpbnN0YW5jZV9jb25maWctPm51 bV9zdHJlYW1zX2NhcCwKKwkJCXNpemVvZihzdHJ1Y3Qgc2Rldl9wY21fc3RyZWFtX2luZm8pLAor CQkJR0ZQX0tFUk5FTCk7CisJCWlmICghcGNtX2luc3RhbmNlX2luZm8tPnN0cmVhbXNfY2FwKQor CQkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJcGNtX2luc3RhbmNlX2luZm8tPm51bV9wY21fc3Ry ZWFtc19wYiA9CisJCQlpbnN0YW5jZV9jb25maWctPm51bV9zdHJlYW1zX3BiOworCXBjbV9pbnN0 YW5jZV9pbmZvLT5udW1fcGNtX3N0cmVhbXNfY2FwID0KKwkJCWluc3RhbmNlX2NvbmZpZy0+bnVt X3N0cmVhbXNfY2FwOworCisJZm9yIChpID0gMDsgaSA8IHBjbV9pbnN0YW5jZV9pbmZvLT5udW1f cGNtX3N0cmVhbXNfcGI7IGkrKykgeworCQlwY21faW5zdGFuY2VfaW5mby0+c3RyZWFtc19wYltp XS5wY21faHcgPQorCQkJaW5zdGFuY2VfY29uZmlnLT5zdHJlYW1zX3BiW2ldLnBjbV9odzsKKwkJ cGNtX2luc3RhbmNlX2luZm8tPnN0cmVhbXNfcGJbaV0udW5pcXVlX2lkID0KKwkJCWluc3RhbmNl X2NvbmZpZy0+c3RyZWFtc19wYltpXS51bmlxdWVfaWQ7CisJfQorCisJZm9yIChpID0gMDsgaSA8 IHBjbV9pbnN0YW5jZV9pbmZvLT5udW1fcGNtX3N0cmVhbXNfY2FwOyBpKyspIHsKKwkJcGNtX2lu c3RhbmNlX2luZm8tPnN0cmVhbXNfY2FwW2ldLnBjbV9odyA9CisJCQlpbnN0YW5jZV9jb25maWct PnN0cmVhbXNfY2FwW2ldLnBjbV9odzsKKwkJcGNtX2luc3RhbmNlX2luZm8tPnN0cmVhbXNfY2Fw W2ldLnVuaXF1ZV9pZCA9CisJCQlpbnN0YW5jZV9jb25maWctPnN0cmVhbXNfY2FwW2ldLnVuaXF1 ZV9pZDsKKwl9CisKKwlyZXQgPSBzbmRfcGNtX25ldyhjYXJkX2luZm8tPmNhcmQsIGluc3RhbmNl X2NvbmZpZy0+bmFtZSwKKwkJCWluc3RhbmNlX2NvbmZpZy0+ZGV2aWNlX2lkLAorCQkJaW5zdGFu Y2VfY29uZmlnLT5udW1fc3RyZWFtc19wYiwKKwkJCWluc3RhbmNlX2NvbmZpZy0+bnVtX3N0cmVh bXNfY2FwLAorCQkJJnBjbSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlwY20t PnByaXZhdGVfZGF0YSA9IHBjbV9pbnN0YW5jZV9pbmZvOworCXBjbS0+aW5mb19mbGFncyA9IDA7 CisJc3RybmNweShwY20tPm5hbWUsICJWaXJ0dWFsIGNhcmQgUENNIiwgc2l6ZW9mKHBjbS0+bmFt ZSkpOworCisJaWYgKGluc3RhbmNlX2NvbmZpZy0+bnVtX3N0cmVhbXNfcGIpCisJCXNuZF9wY21f c2V0X29wcyhwY20sIFNORFJWX1BDTV9TVFJFQU1fUExBWUJBQ0ssCisJCQkJJnNkcnZfYWxzYV9w bGF5YmFja19vcHMpOworCisJaWYgKGluc3RhbmNlX2NvbmZpZy0+bnVtX3N0cmVhbXNfY2FwKQor CQlzbmRfcGNtX3NldF9vcHMocGNtLCBTTkRSVl9QQ01fU1RSRUFNX0NBUFRVUkUsCisJCQkJJnNk cnZfYWxzYV9jYXB0dXJlX29wcyk7CisKKwlwY21faW5zdGFuY2VfaW5mby0+cGNtID0gcGNtOwog CXJldHVybiAwOwogfQogCi0tIAoyLjcuNAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3Rz Lnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753438AbdHGMYy (ORCPT ); Mon, 7 Aug 2017 08:24:54 -0400 Received: from mail-lf0-f66.google.com ([209.85.215.66]:32798 "EHLO mail-lf0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753280AbdHGMXO (ORCPT ); Mon, 7 Aug 2017 08:23:14 -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 08/12] ALSA: vsnd: Initialize virtul sound card Date: Mon, 7 Aug 2017 15:22:53 +0300 Message-Id: <1502108577-8099-9-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 Initialize virtual sound card with streams according to the Xen store configuration. Add stubs for stream PCM operations. Signed-off-by: Oleksandr Andrushchenko --- sound/drivers/xen-front.c | 232 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) diff --git a/sound/drivers/xen-front.c b/sound/drivers/xen-front.c index f3e3f64f0aa6..9f31e6832086 100644 --- a/sound/drivers/xen-front.c +++ b/sound/drivers/xen-front.c @@ -134,6 +134,129 @@ struct xdrv_info { struct sdev_card_plat_data cfg_plat_data; }; +static struct sdev_pcm_stream_info *sdrv_stream_get( + struct snd_pcm_substream *substream) +{ + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct sdev_pcm_stream_info *stream; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + stream = &pcm_instance->streams_pb[substream->number]; + else + stream = &pcm_instance->streams_cap[substream->number]; + return stream; +} + +static void sdrv_copy_pcm_hw(struct snd_pcm_hardware *dst, + struct snd_pcm_hardware *src, + struct snd_pcm_hardware *ref_pcm_hw) +{ + *dst = *ref_pcm_hw; + + if (src->formats) + dst->formats = src->formats; + if (src->buffer_bytes_max) + dst->buffer_bytes_max = + src->buffer_bytes_max; + if (src->period_bytes_min) + dst->period_bytes_min = + src->period_bytes_min; + if (src->period_bytes_max) + dst->period_bytes_max = + src->period_bytes_max; + if (src->periods_min) + dst->periods_min = src->periods_min; + if (src->periods_max) + dst->periods_max = src->periods_max; + if (src->rates) + dst->rates = src->rates; + if (src->rate_min) + dst->rate_min = src->rate_min; + if (src->rate_max) + dst->rate_max = src->rate_max; + if (src->channels_min) + dst->channels_min = src->channels_min; + if (src->channels_max) + dst->channels_max = src->channels_max; + if (src->buffer_bytes_max) { + dst->buffer_bytes_max = src->buffer_bytes_max; + dst->period_bytes_max = src->buffer_bytes_max / + src->periods_max; + dst->periods_max = dst->buffer_bytes_max / + dst->period_bytes_max; + } +} + +static int sdrv_alsa_open(struct snd_pcm_substream *substream) +{ + return 0; +} + +static int sdrv_alsa_close(struct snd_pcm_substream *substream) +{ + return 0; +} + +static int sdrv_alsa_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +{ + return 0; +} + +static int sdrv_alsa_hw_free(struct snd_pcm_substream *substream) +{ + return 0; +} + +static int sdrv_alsa_prepare(struct snd_pcm_substream *substream) +{ + return 0; +} + +static int sdrv_alsa_trigger(struct snd_pcm_substream *substream, int cmd) +{ + return 0; +} + +static inline snd_pcm_uframes_t sdrv_alsa_pointer( + struct snd_pcm_substream *substream) +{ + return 0; +} + +static int sdrv_alsa_playback_copy_user(struct snd_pcm_substream *substream, + int channel, unsigned long pos, void __user *buf, + unsigned long bytes) +{ + return 0; +} + +static int sdrv_alsa_playback_copy_kernel(struct snd_pcm_substream *substream, + int channel, unsigned long pos, void *buf, unsigned long bytes) +{ + return 0; +} + +static int sdrv_alsa_capture_copy_user(struct snd_pcm_substream *substream, + int channel, unsigned long pos, void __user *buf, + unsigned long bytes) +{ + return 0; +} + +static int sdrv_alsa_capture_copy_kernel(struct snd_pcm_substream *substream, + int channel, unsigned long pos, void *buf, unsigned long bytes) +{ + return 0; +} + +static int sdrv_alsa_playback_fill_silence(struct snd_pcm_substream *substream, + int channel, unsigned long pos, unsigned long bytes) +{ + return 0; +} + #define MAX_XEN_BUFFER_SIZE (64 * 1024) #define MAX_BUFFER_SIZE MAX_XEN_BUFFER_SIZE #define MIN_PERIOD_SIZE 64 @@ -168,10 +291,119 @@ static struct snd_pcm_hardware sdrv_pcm_hw_default = { .fifo_size = 0, }; +/* + * FIXME: The mmaped data transfer is asynchronous and there is no + * ack signal from user-space when it is done. This is the + * reason it is not implemented in the PV driver as we do need + * to know when the buffer can be transferred to the backend. + */ + +static struct snd_pcm_ops sdrv_alsa_playback_ops = { + .open = sdrv_alsa_open, + .close = sdrv_alsa_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = sdrv_alsa_hw_params, + .hw_free = sdrv_alsa_hw_free, + .prepare = sdrv_alsa_prepare, + .trigger = sdrv_alsa_trigger, + .pointer = sdrv_alsa_pointer, + .copy_user = sdrv_alsa_playback_copy_user, + .copy_kernel = sdrv_alsa_playback_copy_kernel, + .fill_silence = sdrv_alsa_playback_fill_silence, +}; + +static struct snd_pcm_ops sdrv_alsa_capture_ops = { + .open = sdrv_alsa_open, + .close = sdrv_alsa_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = sdrv_alsa_hw_params, + .hw_free = sdrv_alsa_hw_free, + .prepare = sdrv_alsa_prepare, + .trigger = sdrv_alsa_trigger, + .pointer = sdrv_alsa_pointer, + .copy_user = sdrv_alsa_capture_copy_user, + .copy_kernel = sdrv_alsa_capture_copy_kernel, +}; + static int sdrv_new_pcm(struct sdev_card_info *card_info, struct cfg_pcm_instance *instance_config, struct sdev_pcm_instance_info *pcm_instance_info) { + struct snd_pcm *pcm; + int ret, i; + + dev_dbg(&card_info->xdrv_info->xb_dev->dev, + "New PCM device \"%s\" with id %d playback %d capture %d", + instance_config->name, + instance_config->device_id, + instance_config->num_streams_pb, + instance_config->num_streams_cap); + + pcm_instance_info->card_info = card_info; + + sdrv_copy_pcm_hw(&pcm_instance_info->pcm_hw, + &instance_config->pcm_hw, &card_info->pcm_hw); + + if (instance_config->num_streams_pb) { + pcm_instance_info->streams_pb = devm_kcalloc( + &card_info->card->card_dev, + instance_config->num_streams_pb, + sizeof(struct sdev_pcm_stream_info), + GFP_KERNEL); + if (!pcm_instance_info->streams_pb) + return -ENOMEM; + } + + if (instance_config->num_streams_cap) { + pcm_instance_info->streams_cap = devm_kcalloc( + &card_info->card->card_dev, + instance_config->num_streams_cap, + sizeof(struct sdev_pcm_stream_info), + GFP_KERNEL); + if (!pcm_instance_info->streams_cap) + return -ENOMEM; + } + + pcm_instance_info->num_pcm_streams_pb = + instance_config->num_streams_pb; + pcm_instance_info->num_pcm_streams_cap = + instance_config->num_streams_cap; + + for (i = 0; i < pcm_instance_info->num_pcm_streams_pb; i++) { + pcm_instance_info->streams_pb[i].pcm_hw = + instance_config->streams_pb[i].pcm_hw; + pcm_instance_info->streams_pb[i].unique_id = + instance_config->streams_pb[i].unique_id; + } + + for (i = 0; i < pcm_instance_info->num_pcm_streams_cap; i++) { + pcm_instance_info->streams_cap[i].pcm_hw = + instance_config->streams_cap[i].pcm_hw; + pcm_instance_info->streams_cap[i].unique_id = + instance_config->streams_cap[i].unique_id; + } + + ret = snd_pcm_new(card_info->card, instance_config->name, + instance_config->device_id, + instance_config->num_streams_pb, + instance_config->num_streams_cap, + &pcm); + if (ret < 0) + return ret; + + pcm->private_data = pcm_instance_info; + pcm->info_flags = 0; + strncpy(pcm->name, "Virtual card PCM", sizeof(pcm->name)); + + if (instance_config->num_streams_pb) + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, + &sdrv_alsa_playback_ops); + + if (instance_config->num_streams_cap) + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, + &sdrv_alsa_capture_ops); + + pcm_instance_info->pcm = pcm; return 0; } -- 2.7.4