From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 04/11] ALSA: vsnd: Implement Xen event channel handling Date: Mon, 7 Aug 2017 10:43:09 +0300 Message-ID: <1502091796-14413-5-git-send-email-andr2000@gmail.com> References: <1502091796-14413-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: <1502091796-14413-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 YW0uY29tPgoKMS4gQ3JlYXRlIGV2ZW50IGNoYW5uZWxzIGZvciBhbGwgY29uZmlndXJlZCBzdHJl YW1zIGFuZCBwdWJsaXNoCmNvcnJlc3BvbmRpbmcgcmluZyByZWZlcmVuY2VzIGFuZCBldmVudCBj aGFubmVscyBpbiBYZW4gc3RvcmUsCnNvIGJhY2tlbmQgY2FuIGNvbm5lY3QuCjIuIEltcGxlbWVu dCBldmVudCBjaGFubmVsIGludGVycnVwdCBoYW5kbGVyLgozLiBDcmVhdGUgYW5kIGRlc3Ryb3kg ZXZlbnQgY2hhbm5lbHMgd2l0aCByZXNwZWN0IHRvIFhlbiBidXMgc3RhdGUuCgpTaWduZWQtb2Zm LWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBh bS5jb20+Ci0tLQogc291bmQvZHJpdmVycy94ZW4tZnJvbnQuYyB8IDI2OSArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiAxIGZpbGUgY2hhbmdlZCwgMjY4IGlu c2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zb3VuZC9kcml2ZXJzL3hl bi1mcm9udC5jIGIvc291bmQvZHJpdmVycy94ZW4tZnJvbnQuYwppbmRleCBlZjQ4Y2JmNDRjZjIu LmE5MjQ1OWIyNzM3ZSAxMDA2NDQKLS0tIGEvc291bmQvZHJpdmVycy94ZW4tZnJvbnQuYworKysg Yi9zb3VuZC9kcml2ZXJzL3hlbi1mcm9udC5jCkBAIC0yNCwxNCArMjQsNDAgQEAKICNpbmNsdWRl IDxzb3VuZC9wY20uaD4KIAogI2luY2x1ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4KKyNpbmNsdWRl IDx4ZW4vZXZlbnRzLmg+CisjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CiAjaW5jbHVkZSA8 eGVuL3hlbi5oPgogI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KIAogI2luY2x1ZGUgPHhlbi9pbnRl cmZhY2UvaW8vc25kaWYuaD4KIAorLyoKKyAqIEZJWE1FOiB1c2FnZSBvZiBncmFudCByZWZlcmVu Y2UgMCBhcyBpbnZhbGlkIGdyYW50IHJlZmVyZW5jZToKKyAqIGdyYW50IHJlZmVyZW5jZSAwIGlz IHZhbGlkLCBidXQgbmV2ZXIgZXhwb3NlZCB0byBhIFBWIGRyaXZlciwKKyAqIGJlY2F1c2Ugb2Yg dGhlIGZhY3QgaXQgaXMgYWxyZWFkeSBpbiB1c2UvcmVzZXJ2ZWQgYnkgdGhlIFBWIGNvbnNvbGUu CisgKi8KKyNkZWZpbmUgR1JBTlRfSU5WQUxJRF9SRUYJMAogLyogbWF4aW11bSBudW1iZXIgb2Yg c3VwcG9ydGVkIHN0cmVhbXMgKi8KICNkZWZpbmUgVlNORF9NQVhfU1RSRUFNCQk4CiAKK2VudW0g eGRydl9ldnRjaG5sX3N0YXRlIHsKKwlFVlRDSE5MX1NUQVRFX0RJU0NPTk5FQ1RFRCwKKwlFVlRD SE5MX1NUQVRFX0NPTk5FQ1RFRCwKK307CisKK3N0cnVjdCB4ZHJ2X2V2dGNobmxfaW5mbyB7CisJ c3RydWN0IHhkcnZfaW5mbyAqZHJ2X2luZm87CisJc3RydWN0IHhlbl9zbmRpZl9mcm9udF9yaW5n IHJpbmc7CisJaW50IHJpbmdfcmVmOworCWludCBwb3J0OworCWludCBpcnE7CisJc3RydWN0IGNv bXBsZXRpb24gY29tcGxldGlvbjsKKwllbnVtIHhkcnZfZXZ0Y2hubF9zdGF0ZSBzdGF0ZTsKKwkv KiBsYXRlc3QgcmVzcG9uc2Ugc3RhdHVzIGFuZCBpdHMgY29ycmVzcG9uZGluZyBpZCAqLworCWlu dCByZXNwX3N0YXR1czsKKwl1aW50MTZfdCByZXNwX2lkOworfTsKKwogc3RydWN0IGNmZ19zdHJl YW0gewogCWludCB1bmlxdWVfaWQ7CiAJY2hhciAqeGVuc3RvcmVfcGF0aDsKQEAgLTY1LDYgKzkx LDggQEAgc3RydWN0IHhkcnZfaW5mbyB7CiAJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldjsK IAlzcGlubG9ja190IGlvX2xvY2s7CiAJc3RydWN0IG11dGV4IG11dGV4OworCWludCBudW1fZXZ0 X2NoYW5uZWxzOworCXN0cnVjdCB4ZHJ2X2V2dGNobmxfaW5mbyAqZXZ0X2NobmxzOwogCXN0cnVj dCBzZGV2X2NhcmRfcGxhdF9kYXRhIGNmZ19wbGF0X2RhdGE7CiB9OwogCkBAIC0xMDIsNiArMTMw LDI0NCBAQCBzdGF0aWMgc3RydWN0IHNuZF9wY21faGFyZHdhcmUgc2Rydl9wY21faHdfZGVmYXVs dCA9IHsKIAkuZmlmb19zaXplID0gMCwKIH07CiAKK3N0YXRpYyBpcnFyZXR1cm5fdCB4ZHJ2X2V2 dGNobmxfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwlzdHJ1Y3QgeGRydl9l dnRjaG5sX2luZm8gKmNoYW5uZWwgPSBkZXZfaWQ7CisJc3RydWN0IHhkcnZfaW5mbyAqZHJ2X2lu Zm8gPSBjaGFubmVsLT5kcnZfaW5mbzsKKwlzdHJ1Y3QgeGVuc25kX3Jlc3AgKnJlc3A7CisJUklO R19JRFggaSwgcnA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZl KCZkcnZfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCWlmICh1bmxpa2VseShjaGFubmVsLT5zdGF0 ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkpCisJCWdvdG8gb3V0OworCithZ2FpbjoKKwly cCA9IGNoYW5uZWwtPnJpbmcuc3JpbmctPnJzcF9wcm9kOworCS8qIGVuc3VyZSB3ZSBzZWUgcXVl dWVkIHJlc3BvbnNlcyB1cCB0byBycCAqLworCXJtYigpOworCisJZm9yIChpID0gY2hhbm5lbC0+ cmluZy5yc3BfY29uczsgaSAhPSBycDsgaSsrKSB7CisJCXJlc3AgPSBSSU5HX0dFVF9SRVNQT05T RSgmY2hhbm5lbC0+cmluZywgaSk7CisJCWlmIChyZXNwLT5pZCAhPSBjaGFubmVsLT5yZXNwX2lk KQorCQkJY29udGludWU7CisJCXN3aXRjaCAocmVzcC0+b3BlcmF0aW9uKSB7CisJCWNhc2UgWEVO U05EX09QX09QRU46CisJCQkvKiBmYWxsIHRocm91Z2ggKi8KKwkJY2FzZSBYRU5TTkRfT1BfQ0xP U0U6CisJCQkvKiBmYWxsIHRocm91Z2ggKi8KKwkJY2FzZSBYRU5TTkRfT1BfUkVBRDoKKwkJCS8q IGZhbGwgdGhyb3VnaCAqLworCQljYXNlIFhFTlNORF9PUF9XUklURToKKwkJCWNoYW5uZWwtPnJl c3Bfc3RhdHVzID0gcmVzcC0+c3RhdHVzOworCQkJY29tcGxldGUoJmNoYW5uZWwtPmNvbXBsZXRp b24pOworCQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJCWRldl9lcnIoJmRydl9pbmZvLT54Yl9k ZXYtPmRldiwKKwkJCQkiT3BlcmF0aW9uICVkIGlzIG5vdCBzdXBwb3J0ZWRcbiIsCisJCQkJcmVz cC0+b3BlcmF0aW9uKTsKKwkJCWJyZWFrOworCQl9CisJfQorCisJY2hhbm5lbC0+cmluZy5yc3Bf Y29ucyA9IGk7CisJaWYgKGkgIT0gY2hhbm5lbC0+cmluZy5yZXFfcHJvZF9wdnQpIHsKKwkJaW50 IG1vcmVfdG9fZG87CisKKwkJUklOR19GSU5BTF9DSEVDS19GT1JfUkVTUE9OU0VTKCZjaGFubmVs LT5yaW5nLCBtb3JlX3RvX2RvKTsKKwkJaWYgKG1vcmVfdG9fZG8pCisJCQlnb3RvIGFnYWluOwor CX0gZWxzZQorCQljaGFubmVsLT5yaW5nLnNyaW5nLT5yc3BfZXZlbnQgPSBpICsgMTsKKworb3V0 OgorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRydl9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJ cmV0dXJuIElSUV9IQU5ETEVEOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgeGRydl9ldnRjaG5s X2ZsdXNoKAorCQlzdHJ1Y3QgeGRydl9ldnRjaG5sX2luZm8gKmNoYW5uZWwpCit7CisJaW50IG5v dGlmeTsKKworCWNoYW5uZWwtPnJpbmcucmVxX3Byb2RfcHZ0Kys7CisJUklOR19QVVNIX1JFUVVF U1RTX0FORF9DSEVDS19OT1RJRlkoJmNoYW5uZWwtPnJpbmcsIG5vdGlmeSk7CisJaWYgKG5vdGlm eSkKKwkJbm90aWZ5X3JlbW90ZV92aWFfaXJxKGNoYW5uZWwtPmlycSk7Cit9CisKK3N0YXRpYyB2 b2lkIHhkcnZfZXZ0Y2hubF9mcmVlKHN0cnVjdCB4ZHJ2X2luZm8gKmRydl9pbmZvLAorCQlzdHJ1 Y3QgeGRydl9ldnRjaG5sX2luZm8gKmNoYW5uZWwpCit7CisJaWYgKCFjaGFubmVsLT5yaW5nLnNy aW5nKQorCQlyZXR1cm47CisKKwljaGFubmVsLT5zdGF0ZSA9IEVWVENITkxfU1RBVEVfRElTQ09O TkVDVEVEOworCWNoYW5uZWwtPnJlc3Bfc3RhdHVzID0gLUVJTzsKKwljb21wbGV0ZV9hbGwoJmNo YW5uZWwtPmNvbXBsZXRpb24pOworCisJaWYgKGNoYW5uZWwtPmlycSkKKwkJdW5iaW5kX2Zyb21f aXJxaGFuZGxlcihjaGFubmVsLT5pcnEsIGNoYW5uZWwpOworCWNoYW5uZWwtPmlycSA9IDA7CisK KwlpZiAoY2hhbm5lbC0+cG9ydCkKKwkJeGVuYnVzX2ZyZWVfZXZ0Y2huKGRydl9pbmZvLT54Yl9k ZXYsIGNoYW5uZWwtPnBvcnQpOworCWNoYW5uZWwtPnBvcnQgPSAwOworCisJaWYgKGNoYW5uZWwt PnJpbmdfcmVmICE9IEdSQU5UX0lOVkFMSURfUkVGKQorCQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNj ZXNzKGNoYW5uZWwtPnJpbmdfcmVmLCAwLAorCQkJKHVuc2lnbmVkIGxvbmcpY2hhbm5lbC0+cmlu Zy5zcmluZyk7CisJY2hhbm5lbC0+cmluZ19yZWYgPSBHUkFOVF9JTlZBTElEX1JFRjsKKwljaGFu bmVsLT5yaW5nLnNyaW5nID0gTlVMTDsKK30KKworc3RhdGljIHZvaWQgeGRydl9ldnRjaG5sX2Zy ZWVfYWxsKHN0cnVjdCB4ZHJ2X2luZm8gKmRydl9pbmZvKQoreworCWludCBpOworCisJaWYgKCFk cnZfaW5mby0+ZXZ0X2NobmxzKQorCQlyZXR1cm47CisKKwlmb3IgKGkgPSAwOyBpIDwgZHJ2X2lu Zm8tPm51bV9ldnRfY2hhbm5lbHM7IGkrKykKKwkJeGRydl9ldnRjaG5sX2ZyZWUoZHJ2X2luZm8s ICZkcnZfaW5mby0+ZXZ0X2NobmxzW2ldKTsKKworCWRldm1fa2ZyZWUoJmRydl9pbmZvLT54Yl9k ZXYtPmRldiwgZHJ2X2luZm8tPmV2dF9jaG5scyk7CisJZHJ2X2luZm8tPmV2dF9jaG5scyA9IE5V TEw7Cit9CisKK3N0YXRpYyBpbnQgeGRydl9ldnRjaG5sX2FsbG9jKHN0cnVjdCB4ZHJ2X2luZm8g KmRydl9pbmZvLAorCQlzdHJ1Y3QgeGRydl9ldnRjaG5sX2luZm8gKmV2dF9jaGFubmVsKQorewor CXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYgPSBkcnZfaW5mby0+eGJfZGV2OworCXN0cnVj dCB4ZW5fc25kaWZfc3JpbmcgKnNyaW5nOworCWdyYW50X3JlZl90IGdyZWY7CisJaW50IHJldDsK KworCWV2dF9jaGFubmVsLT5kcnZfaW5mbyA9IGRydl9pbmZvOworCWluaXRfY29tcGxldGlvbigm ZXZ0X2NoYW5uZWwtPmNvbXBsZXRpb24pOworCWV2dF9jaGFubmVsLT5zdGF0ZSA9IEVWVENITkxf U1RBVEVfRElTQ09OTkVDVEVEOworCWV2dF9jaGFubmVsLT5yaW5nX3JlZiA9IEdSQU5UX0lOVkFM SURfUkVGOworCWV2dF9jaGFubmVsLT5yaW5nLnNyaW5nID0gTlVMTDsKKwlldnRfY2hhbm5lbC0+ cG9ydCA9IDA7CisJZXZ0X2NoYW5uZWwtPmlycSA9IDA7CisKKwlzcmluZyA9IChzdHJ1Y3QgeGVu X3NuZGlmX3NyaW5nICopZ2V0X3plcm9lZF9wYWdlKAorCQlHRlBfTk9JTyB8IF9fR0ZQX0hJR0gp OworCWlmICghc3JpbmcpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOworCX0KKwor CVNIQVJFRF9SSU5HX0lOSVQoc3JpbmcpOworCUZST05UX1JJTkdfSU5JVCgmZXZ0X2NoYW5uZWwt PnJpbmcsIHNyaW5nLCBYRU5fUEFHRV9TSVpFKTsKKwlyZXQgPSB4ZW5idXNfZ3JhbnRfcmluZyh4 Yl9kZXYsIHNyaW5nLCAxLCAmZ3JlZik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbDsKKwll dnRfY2hhbm5lbC0+cmluZ19yZWYgPSBncmVmOworCisJcmV0ID0geGVuYnVzX2FsbG9jX2V2dGNo bih4Yl9kZXYsICZldnRfY2hhbm5lbC0+cG9ydCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFp bDsKKworCXJldCA9IGJpbmRfZXZ0Y2huX3RvX2lycWhhbmRsZXIoZXZ0X2NoYW5uZWwtPnBvcnQs CisJCXhkcnZfZXZ0Y2hubF9pbnRlcnJ1cHQsIDAsIHhiX2Rldi0+ZGV2aWNldHlwZSwgZXZ0X2No YW5uZWwpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CisKKwlldnRfY2hhbm5lbC0+aXJx ID0gcmV0OworCXJldHVybiAwOworCitmYWlsOgorCWRldl9lcnIoJnhiX2Rldi0+ZGV2LCAiRmFp bGVkIHRvIGFsbG9jYXRlIHJpbmc6ICVkXG4iLCByZXQpOworCXJldHVybiByZXQ7Cit9CisKK3N0 YXRpYyBpbnQgeGRydl9ldnRjaG5sX2NyZWF0ZShzdHJ1Y3QgeGRydl9pbmZvICpkcnZfaW5mbywK KwkJc3RydWN0IHhkcnZfZXZ0Y2hubF9pbmZvICpldnRfY2hhbm5lbCwKKwkJY29uc3QgY2hhciAq cGF0aCkKK3sKKwlpbnQgcmV0OworCisJcmV0ID0geGRydl9ldnRjaG5sX2FsbG9jKGRydl9pbmZv LCBldnRfY2hhbm5lbCk7CisJaWYgKHJldCA8IDApIHsKKwkJZGV2X2VycigmZHJ2X2luZm8tPnhi X2Rldi0+ZGV2LAorCQkJImFsbG9jYXRpbmcgZXZlbnQgY2hhbm5lbDogJWRcbiIsIHJldCk7CisJ CXJldHVybiByZXQ7CisJfQorCisJLyoKKwkgKiB3cml0ZSB2YWx1ZXMgdG8gWGVuIHN0b3JlLCBz byBiYWNrZW5kIGNhbiBmaW5kIHJpbmcgcmVmZXJlbmNlCisJICogYW5kIGV2ZW50IGNoYW5uZWwK KwkgKi8KKwlyZXQgPSB4ZW5idXNfcHJpbnRmKFhCVF9OSUwsIHBhdGgsIFhFTlNORF9GSUVMRF9S SU5HX1JFRiwgIiV1IiwKKwkJCWV2dF9jaGFubmVsLT5yaW5nX3JlZik7CisJaWYgKHJldCA8IDAp IHsKKwkJZGV2X2VycigmZHJ2X2luZm8tPnhiX2Rldi0+ZGV2LAorCQkJIndyaXRpbmcgIiBYRU5T TkRfRklFTERfUklOR19SRUYiOiAlZFxuIiwgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwly ZXQgPSB4ZW5idXNfcHJpbnRmKFhCVF9OSUwsIHBhdGgsIFhFTlNORF9GSUVMRF9FVlRfQ0hOTCwg IiV1IiwKKwkJZXZ0X2NoYW5uZWwtPnBvcnQpOworCWlmIChyZXQgPCAwKSB7CisJCWRldl9lcnIo JmRydl9pbmZvLT54Yl9kZXYtPmRldiwKKwkJCSJ3cml0aW5nICIgWEVOU05EX0ZJRUxEX0VWVF9D SE5MIjogJWRcbiIsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCXJldHVybiAwOworfQorCitz dGF0aWMgaW50IHhkcnZfZXZ0Y2hubF9jcmVhdGVfYWxsKHN0cnVjdCB4ZHJ2X2luZm8gKmRydl9p bmZvLAorCQlpbnQgbnVtX3N0cmVhbXMpCit7CisJc3RydWN0IGNmZ19jYXJkICpjZmdfY2FyZDsK KwlpbnQgZCwgcmV0ID0gMDsKKworCWRydl9pbmZvLT5ldnRfY2hubHMgPSBkZXZtX2tjYWxsb2Mo JmRydl9pbmZvLT54Yl9kZXYtPmRldiwKKwkJbnVtX3N0cmVhbXMsIHNpemVvZihzdHJ1Y3QgeGRy dl9ldnRjaG5sX2luZm8pLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRydl9pbmZvLT5ldnRfY2hubHMp IHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOworCX0KKworCWNmZ19jYXJkID0gJmRy dl9pbmZvLT5jZmdfcGxhdF9kYXRhLmNmZ19jYXJkOworCS8qIGl0ZXJhdGUgb3ZlciBkZXZpY2Vz IGFuZCB0aGVpciBzdHJlYW1zIGFuZCBjcmVhdGUgZXZlbnQgY2hhbm5lbHMgKi8KKwlmb3IgKGQg PSAwOyBkIDwgY2ZnX2NhcmQtPm51bV9wY21faW5zdGFuY2VzOyBkKyspIHsKKwkJc3RydWN0IGNm Z19wY21faW5zdGFuY2UgKnBjbV9pbnN0YW5jZTsKKwkJaW50IHMsIHN0cmVhbV9pZHg7CisKKwkJ cGNtX2luc3RhbmNlID0gJmNmZ19jYXJkLT5wY21faW5zdGFuY2VzW2RdOworCisJCWZvciAocyA9 IDA7IHMgPCBwY21faW5zdGFuY2UtPm51bV9zdHJlYW1zX3BiOyBzKyspIHsKKwkJCXN0cmVhbV9p ZHggPSBwY21faW5zdGFuY2UtPnN0cmVhbXNfcGJbc10udW5pcXVlX2lkOworCQkJcmV0ID0geGRy dl9ldnRjaG5sX2NyZWF0ZShkcnZfaW5mbywKKwkJCQkmZHJ2X2luZm8tPmV2dF9jaG5sc1tzdHJl YW1faWR4XSwKKwkJCQlwY21faW5zdGFuY2UtPnN0cmVhbXNfcGJbc10ueGVuc3RvcmVfcGF0aCk7 CisJCQlpZiAocmV0IDwgMCkKKwkJCQlnb3RvIGZhaWw7CisJCX0KKworCQlmb3IgKHMgPSAwOyBz IDwgcGNtX2luc3RhbmNlLT5udW1fc3RyZWFtc19jYXA7IHMrKykgeworCQkJc3RyZWFtX2lkeCA9 IHBjbV9pbnN0YW5jZS0+c3RyZWFtc19jYXBbc10udW5pcXVlX2lkOworCQkJcmV0ID0geGRydl9l dnRjaG5sX2NyZWF0ZShkcnZfaW5mbywKKwkJCQkmZHJ2X2luZm8tPmV2dF9jaG5sc1tzdHJlYW1f aWR4XSwKKwkJCQlwY21faW5zdGFuY2UtPnN0cmVhbXNfY2FwW3NdLnhlbnN0b3JlX3BhdGgpOwor CQkJaWYgKHJldCA8IDApCisJCQkJZ290byBmYWlsOworCQl9CisJfQorCWlmIChyZXQgPCAwKQor CQlnb3RvIGZhaWw7CisKKwlkcnZfaW5mby0+bnVtX2V2dF9jaGFubmVscyA9IG51bV9zdHJlYW1z OworCXJldHVybiAwOworCitmYWlsOgorCXhkcnZfZXZ0Y2hubF9mcmVlX2FsbChkcnZfaW5mbyk7 CisJcmV0dXJuIHJldDsKK30KKwogc3RydWN0IENGR19IV19TQU1QTEVfUkFURSB7CiAJY29uc3Qg Y2hhciAqbmFtZTsKIAl1bnNpZ25lZCBpbnQgbWFzazsKQEAgLTU1Niw2ICs4MjIsNyBAQCBzdGF0 aWMgaW50IGNmZ19jYXJkKHN0cnVjdCB4ZHJ2X2luZm8gKmRydl9pbmZvLAogCiBzdGF0aWMgdm9p ZCB4ZHJ2X3JlbW92ZV9pbnRlcm5hbChzdHJ1Y3QgeGRydl9pbmZvICpkcnZfaW5mbykKIHsKKwl4 ZHJ2X2V2dGNobmxfZnJlZV9hbGwoZHJ2X2luZm8pOwogfQogCiBzdGF0aWMgaW50IHhkcnZfYmVf b25faW5pdHdhaXQoc3RydWN0IHhkcnZfaW5mbyAqZHJ2X2luZm8pCkBAIC01NjgsNyArODM1LDcg QEAgc3RhdGljIGludCB4ZHJ2X2JlX29uX2luaXR3YWl0KHN0cnVjdCB4ZHJ2X2luZm8gKmRydl9p bmZvKQogCXJldCA9IGNmZ19jYXJkKGRydl9pbmZvLCAmZHJ2X2luZm8tPmNmZ19wbGF0X2RhdGEs ICZzdHJlYW1faWR4KTsKIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKLQlyZXR1cm4gMDsK KwlyZXR1cm4geGRydl9ldnRjaG5sX2NyZWF0ZV9hbGwoZHJ2X2luZm8sIHN0cmVhbV9pZHgpOwog fQogCiBzdGF0aWMgaW5saW5lIGludCB4ZHJ2X2JlX29uX2Nvbm5lY3RlZChzdHJ1Y3QgeGRydl9p bmZvICpkcnZfaW5mbykKLS0gCjIuNy40CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMu eGVuLm9yZwpodHRwczovL2xpc3RzLnhlbi5vcmcveGVuLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752647AbdHGHqY (ORCPT ); Mon, 7 Aug 2017 03:46:24 -0400 Received: from mail-lf0-f68.google.com ([209.85.215.68]:33178 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752286AbdHGHnk (ORCPT ); Mon, 7 Aug 2017 03:43:40 -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 04/11] ALSA: vsnd: Implement Xen event channel handling Date: Mon, 7 Aug 2017 10:43:09 +0300 Message-Id: <1502091796-14413-5-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1502091796-14413-1-git-send-email-andr2000@gmail.com> References: <1502091796-14413-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 1. Create event channels for all configured streams and publish corresponding ring references and event channels in Xen store, so backend can connect. 2. Implement event channel interrupt handler. 3. Create and destroy event channels with respect to Xen bus state. Signed-off-by: Oleksandr Andrushchenko --- sound/drivers/xen-front.c | 269 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 268 insertions(+), 1 deletion(-) diff --git a/sound/drivers/xen-front.c b/sound/drivers/xen-front.c index ef48cbf44cf2..a92459b2737e 100644 --- a/sound/drivers/xen-front.c +++ b/sound/drivers/xen-front.c @@ -24,14 +24,40 @@ #include #include +#include +#include #include #include #include +/* + * FIXME: usage of grant reference 0 as invalid grant reference: + * grant reference 0 is valid, but never exposed to a PV driver, + * because of the fact it is already in use/reserved by the PV console. + */ +#define GRANT_INVALID_REF 0 /* maximum number of supported streams */ #define VSND_MAX_STREAM 8 +enum xdrv_evtchnl_state { + EVTCHNL_STATE_DISCONNECTED, + EVTCHNL_STATE_CONNECTED, +}; + +struct xdrv_evtchnl_info { + struct xdrv_info *drv_info; + struct xen_sndif_front_ring ring; + int ring_ref; + int port; + int irq; + struct completion completion; + enum xdrv_evtchnl_state state; + /* latest response status and its corresponding id */ + int resp_status; + uint16_t resp_id; +}; + struct cfg_stream { int unique_id; char *xenstore_path; @@ -65,6 +91,8 @@ struct xdrv_info { struct xenbus_device *xb_dev; spinlock_t io_lock; struct mutex mutex; + int num_evt_channels; + struct xdrv_evtchnl_info *evt_chnls; struct sdev_card_plat_data cfg_plat_data; }; @@ -102,6 +130,244 @@ static struct snd_pcm_hardware sdrv_pcm_hw_default = { .fifo_size = 0, }; +static irqreturn_t xdrv_evtchnl_interrupt(int irq, void *dev_id) +{ + struct xdrv_evtchnl_info *channel = dev_id; + struct xdrv_info *drv_info = channel->drv_info; + struct xensnd_resp *resp; + RING_IDX i, rp; + unsigned long flags; + + spin_lock_irqsave(&drv_info->io_lock, flags); + if (unlikely(channel->state != EVTCHNL_STATE_CONNECTED)) + goto out; + +again: + rp = channel->ring.sring->rsp_prod; + /* ensure we see queued responses up to rp */ + rmb(); + + for (i = channel->ring.rsp_cons; i != rp; i++) { + resp = RING_GET_RESPONSE(&channel->ring, i); + if (resp->id != channel->resp_id) + continue; + switch (resp->operation) { + case XENSND_OP_OPEN: + /* fall through */ + case XENSND_OP_CLOSE: + /* fall through */ + case XENSND_OP_READ: + /* fall through */ + case XENSND_OP_WRITE: + channel->resp_status = resp->status; + complete(&channel->completion); + break; + + default: + dev_err(&drv_info->xb_dev->dev, + "Operation %d is not supported\n", + resp->operation); + break; + } + } + + channel->ring.rsp_cons = i; + if (i != channel->ring.req_prod_pvt) { + int more_to_do; + + RING_FINAL_CHECK_FOR_RESPONSES(&channel->ring, more_to_do); + if (more_to_do) + goto again; + } else + channel->ring.sring->rsp_event = i + 1; + +out: + spin_unlock_irqrestore(&drv_info->io_lock, flags); + return IRQ_HANDLED; +} + +static inline void xdrv_evtchnl_flush( + struct xdrv_evtchnl_info *channel) +{ + int notify; + + channel->ring.req_prod_pvt++; + RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&channel->ring, notify); + if (notify) + notify_remote_via_irq(channel->irq); +} + +static void xdrv_evtchnl_free(struct xdrv_info *drv_info, + struct xdrv_evtchnl_info *channel) +{ + if (!channel->ring.sring) + return; + + channel->state = EVTCHNL_STATE_DISCONNECTED; + channel->resp_status = -EIO; + complete_all(&channel->completion); + + if (channel->irq) + unbind_from_irqhandler(channel->irq, channel); + channel->irq = 0; + + if (channel->port) + xenbus_free_evtchn(drv_info->xb_dev, channel->port); + channel->port = 0; + + if (channel->ring_ref != GRANT_INVALID_REF) + gnttab_end_foreign_access(channel->ring_ref, 0, + (unsigned long)channel->ring.sring); + channel->ring_ref = GRANT_INVALID_REF; + channel->ring.sring = NULL; +} + +static void xdrv_evtchnl_free_all(struct xdrv_info *drv_info) +{ + int i; + + if (!drv_info->evt_chnls) + return; + + for (i = 0; i < drv_info->num_evt_channels; i++) + xdrv_evtchnl_free(drv_info, &drv_info->evt_chnls[i]); + + devm_kfree(&drv_info->xb_dev->dev, drv_info->evt_chnls); + drv_info->evt_chnls = NULL; +} + +static int xdrv_evtchnl_alloc(struct xdrv_info *drv_info, + struct xdrv_evtchnl_info *evt_channel) +{ + struct xenbus_device *xb_dev = drv_info->xb_dev; + struct xen_sndif_sring *sring; + grant_ref_t gref; + int ret; + + evt_channel->drv_info = drv_info; + init_completion(&evt_channel->completion); + evt_channel->state = EVTCHNL_STATE_DISCONNECTED; + evt_channel->ring_ref = GRANT_INVALID_REF; + evt_channel->ring.sring = NULL; + evt_channel->port = 0; + evt_channel->irq = 0; + + sring = (struct xen_sndif_sring *)get_zeroed_page( + GFP_NOIO | __GFP_HIGH); + if (!sring) { + ret = -ENOMEM; + goto fail; + } + + SHARED_RING_INIT(sring); + FRONT_RING_INIT(&evt_channel->ring, sring, XEN_PAGE_SIZE); + ret = xenbus_grant_ring(xb_dev, sring, 1, &gref); + if (ret < 0) + goto fail; + evt_channel->ring_ref = gref; + + ret = xenbus_alloc_evtchn(xb_dev, &evt_channel->port); + if (ret < 0) + goto fail; + + ret = bind_evtchn_to_irqhandler(evt_channel->port, + xdrv_evtchnl_interrupt, 0, xb_dev->devicetype, evt_channel); + if (ret < 0) + goto fail; + + evt_channel->irq = ret; + return 0; + +fail: + dev_err(&xb_dev->dev, "Failed to allocate ring: %d\n", ret); + return ret; +} + +static int xdrv_evtchnl_create(struct xdrv_info *drv_info, + struct xdrv_evtchnl_info *evt_channel, + const char *path) +{ + int ret; + + ret = xdrv_evtchnl_alloc(drv_info, evt_channel); + if (ret < 0) { + dev_err(&drv_info->xb_dev->dev, + "allocating event channel: %d\n", ret); + return ret; + } + + /* + * write values to Xen store, so backend can find ring reference + * and event channel + */ + ret = xenbus_printf(XBT_NIL, path, XENSND_FIELD_RING_REF, "%u", + evt_channel->ring_ref); + if (ret < 0) { + dev_err(&drv_info->xb_dev->dev, + "writing " XENSND_FIELD_RING_REF": %d\n", ret); + return ret; + } + + ret = xenbus_printf(XBT_NIL, path, XENSND_FIELD_EVT_CHNL, "%u", + evt_channel->port); + if (ret < 0) { + dev_err(&drv_info->xb_dev->dev, + "writing " XENSND_FIELD_EVT_CHNL": %d\n", ret); + return ret; + } + return 0; +} + +static int xdrv_evtchnl_create_all(struct xdrv_info *drv_info, + int num_streams) +{ + struct cfg_card *cfg_card; + int d, ret = 0; + + drv_info->evt_chnls = devm_kcalloc(&drv_info->xb_dev->dev, + num_streams, sizeof(struct xdrv_evtchnl_info), GFP_KERNEL); + if (!drv_info->evt_chnls) { + ret = -ENOMEM; + goto fail; + } + + cfg_card = &drv_info->cfg_plat_data.cfg_card; + /* iterate over devices and their streams and create event channels */ + for (d = 0; d < cfg_card->num_pcm_instances; d++) { + struct cfg_pcm_instance *pcm_instance; + int s, stream_idx; + + pcm_instance = &cfg_card->pcm_instances[d]; + + for (s = 0; s < pcm_instance->num_streams_pb; s++) { + stream_idx = pcm_instance->streams_pb[s].unique_id; + ret = xdrv_evtchnl_create(drv_info, + &drv_info->evt_chnls[stream_idx], + pcm_instance->streams_pb[s].xenstore_path); + if (ret < 0) + goto fail; + } + + for (s = 0; s < pcm_instance->num_streams_cap; s++) { + stream_idx = pcm_instance->streams_cap[s].unique_id; + ret = xdrv_evtchnl_create(drv_info, + &drv_info->evt_chnls[stream_idx], + pcm_instance->streams_cap[s].xenstore_path); + if (ret < 0) + goto fail; + } + } + if (ret < 0) + goto fail; + + drv_info->num_evt_channels = num_streams; + return 0; + +fail: + xdrv_evtchnl_free_all(drv_info); + return ret; +} + struct CFG_HW_SAMPLE_RATE { const char *name; unsigned int mask; @@ -556,6 +822,7 @@ static int cfg_card(struct xdrv_info *drv_info, static void xdrv_remove_internal(struct xdrv_info *drv_info) { + xdrv_evtchnl_free_all(drv_info); } static int xdrv_be_on_initwait(struct xdrv_info *drv_info) @@ -568,7 +835,7 @@ static int xdrv_be_on_initwait(struct xdrv_info *drv_info) ret = cfg_card(drv_info, &drv_info->cfg_plat_data, &stream_idx); if (ret < 0) return ret; - return 0; + return xdrv_evtchnl_create_all(drv_info, stream_idx); } static inline int xdrv_be_on_connected(struct xdrv_info *drv_info) -- 2.7.4