From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH RESEND 09/11] ALSA: vsnd: Implement ALSA PCM operations Date: Mon, 7 Aug 2017 14:50:43 +0300 Message-ID: <1502106645-6731-10-git-send-email-andr2000@gmail.com> References: <1502106645-6731-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: <1502106645-6731-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 YW0uY29tPgoKSW1wbGVtZW50IEFMU0EgZHJpdmVyIG9wZXJhdGlvbnMgaW5jbHVkaW5nOgotIHN0 YXJ0L3N0b3AgcGVyaW9kIGludGVycnVwdCBlbXVsYXRpb24KLSBtYW5hZ2UgZnJvbnRlbmQvYmFj a2VuZCBzaHJhZWQgYnVmZmVycwotIG1hbmFnZSBYZW4gYnVzIGV2ZW50IGNoYW5uZWwgc3RhdGUK ClNpZ25lZC1vZmYtYnk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVz aGNoZW5rb0BlcGFtLmNvbT4KLS0tCiBzb3VuZC9kcml2ZXJzL3hlbi1mcm9udC5jIHwgMTc1ICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0KIDEgZmlsZSBjaGFu Z2VkLCAxNjMgaW5zZXJ0aW9ucygrKSwgMTIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc291 bmQvZHJpdmVycy94ZW4tZnJvbnQuYyBiL3NvdW5kL2RyaXZlcnMveGVuLWZyb250LmMKaW5kZXgg NTA3YzVlYjM0M2M4Li43Mjc1ZTljYjM4YzAgMTAwNjQ0Ci0tLSBhL3NvdW5kL2RyaXZlcnMveGVu LWZyb250LmMKKysrIGIvc291bmQvZHJpdmVycy94ZW4tZnJvbnQuYwpAQCAtMTUxLDYgKzE1MSwx MSBAQCBzdHJ1Y3QgeGRydl9pbmZvIHsKIAlzdHJ1Y3Qgc2Rldl9jYXJkX3BsYXRfZGF0YSBjZmdf cGxhdF9kYXRhOwogfTsKIAorc3RhdGljIGlubGluZSB2b2lkIHNoX2J1Zl9jbGVhcihzdHJ1Y3Qg c2hfYnVmX2luZm8gKmJ1Zik7CitzdGF0aWMgdm9pZCBzaF9idWZfZnJlZShzdHJ1Y3Qgc2hfYnVm X2luZm8gKmJ1Zik7CitzdGF0aWMgaW50IHNoX2J1Zl9hbGxvYyhzdHJ1Y3QgeGVuYnVzX2Rldmlj ZSAqeGJfZGV2LCBzdHJ1Y3Qgc2hfYnVmX2luZm8gKmJ1ZiwKKwl1bnNpZ25lZCBpbnQgYnVmZmVy X3NpemUpOworCiBzdGF0aWMgc3RydWN0IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzZHJ2X3N0cmVh bV9nZXQoCiAJc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0pCiB7CkBAIC0zMTEs NzEgKzMxNiwyMTcgQEAgc3RhdGljIHZvaWQgc2Rydl9jb3B5X3BjbV9odyhzdHJ1Y3Qgc25kX3Bj bV9oYXJkd2FyZSAqZHN0LAogCiBzdGF0aWMgaW50IHNkcnZfYWxzYV9vcGVuKHN0cnVjdCBzbmRf cGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtKQogewotCXJldHVybiAwOworCXN0cnVjdCBzZGV2X3Bj bV9pbnN0YW5jZV9pbmZvICpwY21faW5zdGFuY2UgPQorCQlzbmRfcGNtX3N1YnN0cmVhbV9jaGlw KHN1YnN0cmVhbSk7CisJc3RydWN0IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzZHJ2 X3N0cmVhbV9nZXQoc3Vic3RyZWFtKTsKKwlzdHJ1Y3Qgc25kX3BjbV9ydW50aW1lICpydW50aW1l ID0gc3Vic3RyZWFtLT5ydW50aW1lOworCXN0cnVjdCB4ZHJ2X2luZm8gKnhkcnZfaW5mbzsKKwl1 bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByZXQ7CisKKwlzZHJ2X2NvcHlfcGNtX2h3KCZydW50 aW1lLT5odywgJnN0cmVhbS0+cGNtX2h3LCAmcGNtX2luc3RhbmNlLT5wY21faHcpOworCXJ1bnRp bWUtPmh3LmluZm8gJj0gfihTTkRSVl9QQ01fSU5GT19NTUFQIHwKKwkJU05EUlZfUENNX0lORk9f TU1BUF9WQUxJRCB8CisJCVNORFJWX1BDTV9JTkZPX0RPVUJMRSB8CisJCVNORFJWX1BDTV9JTkZP X0JBVENIIHwKKwkJU05EUlZfUENNX0lORk9fTk9OSU5URVJMRUFWRUQgfAorCQlTTkRSVl9QQ01f SU5GT19SRVNVTUUgfAorCQlTTkRSVl9QQ01fSU5GT19QQVVTRSk7CisJcnVudGltZS0+aHcuaW5m byB8PSBTTkRSVl9QQ01fSU5GT19JTlRFUkxFQVZFRDsKKworCXhkcnZfaW5mbyA9IHBjbV9pbnN0 YW5jZS0+Y2FyZF9pbmZvLT54ZHJ2X2luZm87CisKKwlyZXQgPSBzZHJ2X2Fsc2FfdGltZXJfY3Jl YXRlKHN1YnN0cmVhbSk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmeGRydl9pbmZvLT5pb19sb2Nr LCBmbGFncyk7CisJc2hfYnVmX2NsZWFyKCZzdHJlYW0tPnNoX2J1Zik7CisJc3RyZWFtLT5ldnRf Y2hubCA9ICZ4ZHJ2X2luZm8tPmV2dF9jaG5sc1tzdHJlYW0tPnVuaXF1ZV9pZF07CisJaWYgKHJl dCA8IDApCisJCXN0cmVhbS0+ZXZ0X2NobmwtPnN0YXRlID0gRVZUQ0hOTF9TVEFURV9ESVNDT05O RUNURUQ7CisJZWxzZQorCQlzdHJlYW0tPmV2dF9jaG5sLT5zdGF0ZSA9IEVWVENITkxfU1RBVEVf Q09OTkVDVEVEOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnhkcnZfaW5mby0+aW9fbG9jaywg ZmxhZ3MpOworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgc2Rydl9hbHNhX2Nsb3NlKHN0 cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtKQogeworCXN0cnVjdCBzZGV2X3BjbV9p bnN0YW5jZV9pbmZvICpwY21faW5zdGFuY2UgPQorCQlzbmRfcGNtX3N1YnN0cmVhbV9jaGlwKHN1 YnN0cmVhbSk7CisJc3RydWN0IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzZHJ2X3N0 cmVhbV9nZXQoc3Vic3RyZWFtKTsKKwlzdHJ1Y3QgeGRydl9pbmZvICp4ZHJ2X2luZm87CisJdW5z aWduZWQgbG9uZyBmbGFnczsKKworCXhkcnZfaW5mbyA9IHBjbV9pbnN0YW5jZS0+Y2FyZF9pbmZv LT54ZHJ2X2luZm87CisKKwlzZHJ2X2Fsc2FfdGltZXJfc3RvcChzdWJzdHJlYW0pOworCisJc3Bp bl9sb2NrX2lycXNhdmUoJnhkcnZfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXN0cmVhbS0+ZXZ0 X2NobmwtPnN0YXRlID0gRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQ7CisJc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmeGRydl9pbmZvLT5pb19sb2NrLCBmbGFncyk7CiAJcmV0dXJuIDA7CiB9CiAK IHN0YXRpYyBpbnQgc2Rydl9hbHNhX2h3X3BhcmFtcyhzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0g KnN1YnN0cmVhbSwKIAlzdHJ1Y3Qgc25kX3BjbV9od19wYXJhbXMgKnBhcmFtcykKIHsKKwlzdHJ1 Y3Qgc2Rldl9wY21faW5zdGFuY2VfaW5mbyAqcGNtX2luc3RhbmNlID0KKwkJc25kX3BjbV9zdWJz dHJlYW1fY2hpcChzdWJzdHJlYW0pOworCXN0cnVjdCBzZGV2X3BjbV9zdHJlYW1faW5mbyAqc3Ry ZWFtID0gc2Rydl9zdHJlYW1fZ2V0KHN1YnN0cmVhbSk7CisJc3RydWN0IHhkcnZfaW5mbyAqeGRy dl9pbmZvOworCXVuc2lnbmVkIGludCBidWZmZXJfc2l6ZTsKKwlpbnQgcmV0OworCisJYnVmZmVy X3NpemUgPSBwYXJhbXNfYnVmZmVyX2J5dGVzKHBhcmFtcyk7CisJc2hfYnVmX2NsZWFyKCZzdHJl YW0tPnNoX2J1Zik7CisJeGRydl9pbmZvID0gcGNtX2luc3RhbmNlLT5jYXJkX2luZm8tPnhkcnZf aW5mbzsKKwlyZXQgPSBzaF9idWZfYWxsb2MoeGRydl9pbmZvLT54Yl9kZXYsCisJCSZzdHJlYW0t PnNoX2J1ZiwgYnVmZmVyX3NpemUpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CiAJcmV0 dXJuIDA7CisKK2ZhaWw6CisJZGV2X2VycigmeGRydl9pbmZvLT54Yl9kZXYtPmRldiwKKwkJIkZh aWxlZCB0byBhbGxvY2F0ZSBidWZmZXJzIGZvciBzdHJlYW0gaWR4ICVkXG4iLAorCQlzdHJlYW0t PnVuaXF1ZV9pZCk7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBzZHJ2X2Fsc2FfaHdf ZnJlZShzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSkKIHsKKwlzdHJ1Y3Qgc2Rl dl9wY21faW5zdGFuY2VfaW5mbyAqcGNtX2luc3RhbmNlID0KKwkJc25kX3BjbV9zdWJzdHJlYW1f Y2hpcChzdWJzdHJlYW0pOworCXN0cnVjdCBzZGV2X3BjbV9zdHJlYW1faW5mbyAqc3RyZWFtID0g c2Rydl9zdHJlYW1fZ2V0KHN1YnN0cmVhbSk7CisJc3RydWN0IHhkcnZfaW5mbyAqeGRydl9pbmZv OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwl4ZHJ2X2luZm8gPSBwY21faW5zdGFuY2UtPmNh cmRfaW5mby0+eGRydl9pbmZvOworCXNwaW5fbG9ja19pcnFzYXZlKCZ4ZHJ2X2luZm8tPmlvX2xv Y2ssIGZsYWdzKTsKKwlzaF9idWZfZnJlZSgmc3RyZWFtLT5zaF9idWYpOworCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJnhkcnZfaW5mby0+aW9fbG9jaywgZmxhZ3MpOwogCXJldHVybiAwOwogfQog CiBzdGF0aWMgaW50IHNkcnZfYWxzYV9wcmVwYXJlKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAq c3Vic3RyZWFtKQogewotCXJldHVybiAwOworCXN0cnVjdCBzZGV2X3BjbV9zdHJlYW1faW5mbyAq c3RyZWFtID0gc2Rydl9zdHJlYW1fZ2V0KHN1YnN0cmVhbSk7CisJaW50IHJldCA9IDA7CisKKwlp ZiAoIXN0cmVhbS0+aXNfb3BlbikKKwkJcmV0ID0gc2Rydl9hbHNhX3RpbWVyX3ByZXBhcmUoc3Vi c3RyZWFtKTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgaW50IHNkcnZfYWxzYV90cmlnZ2Vy KHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtLCBpbnQgY21kKQogeworCXN3aXRj aCAoY21kKSB7CisJY2FzZSBTTkRSVl9QQ01fVFJJR0dFUl9TVEFSVDoKKwkJLyogZmFsbCB0aHJv dWdoICovCisJY2FzZSBTTkRSVl9QQ01fVFJJR0dFUl9SRVNVTUU6CisJCXJldHVybiBzZHJ2X2Fs c2FfdGltZXJfc3RhcnQoc3Vic3RyZWFtKTsKKworCWNhc2UgU05EUlZfUENNX1RSSUdHRVJfU1RP UDoKKwkJLyogZmFsbCB0aHJvdWdoICovCisJY2FzZSBTTkRSVl9QQ01fVFJJR0dFUl9TVVNQRU5E OgorCQlyZXR1cm4gc2Rydl9hbHNhX3RpbWVyX3N0b3Aoc3Vic3RyZWFtKTsKKworCWRlZmF1bHQ6 CisJCWJyZWFrOworCX0KIAlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGlubGluZSBzbmRfcGNtX3Vm cmFtZXNfdCBzZHJ2X2Fsc2FfcG9pbnRlcigKIAlzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1 YnN0cmVhbSkKIHsKKwlyZXR1cm4gc2Rydl9hbHNhX3RpbWVyX3BvaW50ZXIoc3Vic3RyZWFtKTsK K30KKworc3RhdGljIGludCBzZHJ2X2Fsc2FfcGxheWJhY2tfZG9fd3JpdGUoc3RydWN0IHNuZF9w Y21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCisJdW5zaWduZWQgbG9uZyBwb3MsIHVuc2lnbmVkIGxv bmcgY291bnQpCit7CiAJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyBpbnQgc2Rydl9hbHNhX3BsYXli YWNrX2NvcHlfdXNlcihzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnN0cmVhbSwKLQkJaW50 IGNoYW5uZWwsIHVuc2lnbmVkIGxvbmcgcG9zLCB2b2lkIF9fdXNlciAqYnVmLAotCQl1bnNpZ25l ZCBsb25nIGJ5dGVzKQorCQlpbnQgY2hhbm5lbCwgdW5zaWduZWQgbG9uZyBwb3MsIHZvaWQgX191 c2VyICpzcmMsCisJCXVuc2lnbmVkIGxvbmcgY291bnQpCiB7Ci0JcmV0dXJuIDA7CisJc3RydWN0 IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzZHJ2X3N0cmVhbV9nZXQoc3Vic3RyZWFt KTsKKworCWlmICh1bmxpa2VseShwb3MgKyBjb3VudCA+IHN0cmVhbS0+c2hfYnVmLnZidWZmZXJf c3opKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChjb3B5X2Zyb21fdXNlcihzdHJlYW0tPnNo X2J1Zi52YnVmZmVyICsgcG9zLCBzcmMsIGNvdW50KSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwly ZXR1cm4gc2Rydl9hbHNhX3BsYXliYWNrX2RvX3dyaXRlKHN1YnN0cmVhbSwgcG9zLCBjb3VudCk7 CiB9CiAKIHN0YXRpYyBpbnQgc2Rydl9hbHNhX3BsYXliYWNrX2NvcHlfa2VybmVsKHN0cnVjdCBz bmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtLAotCQlpbnQgY2hhbm5lbCwgdW5zaWduZWQgbG9u ZyBwb3MsIHZvaWQgKmJ1ZiwgdW5zaWduZWQgbG9uZyBieXRlcykKKwkJaW50IGNoYW5uZWwsIHVu c2lnbmVkIGxvbmcgcG9zLCB2b2lkICpzcmMsIHVuc2lnbmVkIGxvbmcgY291bnQpCit7CisJc3Ry dWN0IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzZHJ2X3N0cmVhbV9nZXQoc3Vic3Ry ZWFtKTsKKworCWlmICh1bmxpa2VseShwb3MgKyBjb3VudCA+IHN0cmVhbS0+c2hfYnVmLnZidWZm ZXJfc3opKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCW1lbWNweShzdHJlYW0tPnNoX2J1Zi52YnVm ZmVyICsgcG9zLCBzcmMsIGNvdW50KTsKKwlyZXR1cm4gc2Rydl9hbHNhX3BsYXliYWNrX2RvX3dy aXRlKHN1YnN0cmVhbSwgcG9zLCBjb3VudCk7Cit9CisKK3N0YXRpYyBpbnQgc2Rydl9hbHNhX3Bs YXliYWNrX2RvX3JlYWQoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCisJdW5z aWduZWQgbG9uZyBwb3MsIHVuc2lnbmVkIGxvbmcgY291bnQpCiB7CiAJcmV0dXJuIDA7CiB9CiAK IHN0YXRpYyBpbnQgc2Rydl9hbHNhX2NhcHR1cmVfY29weV91c2VyKHN0cnVjdCBzbmRfcGNtX3N1 YnN0cmVhbSAqc3Vic3RyZWFtLAotCQlpbnQgY2hhbm5lbCwgdW5zaWduZWQgbG9uZyBwb3MsIHZv aWQgX191c2VyICpidWYsCi0JCXVuc2lnbmVkIGxvbmcgYnl0ZXMpCisJCWludCBjaGFubmVsLCB1 bnNpZ25lZCBsb25nIHBvcywgdm9pZCBfX3VzZXIgKmRzdCwKKwkJdW5zaWduZWQgbG9uZyBjb3Vu dCkKIHsKLQlyZXR1cm4gMDsKKwlzdHJ1Y3Qgc2Rldl9wY21fc3RyZWFtX2luZm8gKnN0cmVhbSA9 IHNkcnZfc3RyZWFtX2dldChzdWJzdHJlYW0pOworCWludCByZXQ7CisKKwlpZiAodW5saWtlbHko cG9zICsgY291bnQgPiBzdHJlYW0tPnNoX2J1Zi52YnVmZmVyX3N6KSkKKwkJcmV0dXJuIC1FSU5W QUw7CisKKwlyZXQgPSBzZHJ2X2Fsc2FfcGxheWJhY2tfZG9fcmVhZChzdWJzdHJlYW0sIHBvcywg Y291bnQpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJcmV0dXJuIGNvcHlfdG9f dXNlcihkc3QsIHN0cmVhbS0+c2hfYnVmLnZidWZmZXIgKyBwb3MsIGNvdW50KSA/CisJCS1FRkFV TFQgOiAwOwogfQogCiBzdGF0aWMgaW50IHNkcnZfYWxzYV9jYXB0dXJlX2NvcHlfa2VybmVsKHN0 cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtLAotCQlpbnQgY2hhbm5lbCwgdW5zaWdu ZWQgbG9uZyBwb3MsIHZvaWQgKmJ1ZiwgdW5zaWduZWQgbG9uZyBieXRlcykKKwkJaW50IGNoYW5u ZWwsIHVuc2lnbmVkIGxvbmcgcG9zLCB2b2lkICpkc3QsIHVuc2lnbmVkIGxvbmcgY291bnQpCiB7 CisJc3RydWN0IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzZHJ2X3N0cmVhbV9nZXQo c3Vic3RyZWFtKTsKKwlpbnQgcmV0OworCisJaWYgKHVubGlrZWx5KHBvcyArIGNvdW50ID4gc3Ry ZWFtLT5zaF9idWYudmJ1ZmZlcl9zeikpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0ID0gc2Ry dl9hbHNhX3BsYXliYWNrX2RvX3JlYWQoc3Vic3RyZWFtLCBwb3MsIGNvdW50KTsKKwlpZiAocmV0 IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCW1lbWNweShkc3QsIHN0cmVhbS0+c2hfYnVmLnZidWZm ZXIgKyBwb3MsIGNvdW50KTsKIAlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGludCBzZHJ2X2Fsc2Ff cGxheWJhY2tfZmlsbF9zaWxlbmNlKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFt LAotCWludCBjaGFubmVsLCB1bnNpZ25lZCBsb25nIHBvcywgdW5zaWduZWQgbG9uZyBieXRlcykK KwlpbnQgY2hhbm5lbCwgdW5zaWduZWQgbG9uZyBwb3MsIHVuc2lnbmVkIGxvbmcgY291bnQpCiB7 Ci0JcmV0dXJuIDA7CisJc3RydWN0IHNkZXZfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzZHJ2 X3N0cmVhbV9nZXQoc3Vic3RyZWFtKTsKKworCWlmICh1bmxpa2VseShwb3MgKyBjb3VudCA+IHN0 cmVhbS0+c2hfYnVmLnZidWZmZXJfc3opKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCW1lbXNldChz dHJlYW0tPnNoX2J1Zi52YnVmZmVyICsgcG9zLCAwLCBjb3VudCk7CisJcmV0dXJuIHNkcnZfYWxz YV9wbGF5YmFja19kb193cml0ZShzdWJzdHJlYW0sIHBvcywgY291bnQpOwogfQogCiAjZGVmaW5l IE1BWF9YRU5fQlVGRkVSX1NJWkUJKDY0ICogMTAyNCkKLS0gCjIuNy40CgoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlz dApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwczovL2xpc3RzLnhlbi5vcmcveGVuLWRldmVs Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753394AbdHGLwk (ORCPT ); Mon, 7 Aug 2017 07:52:40 -0400 Received: from mail-lf0-f65.google.com ([209.85.215.65]:36531 "EHLO mail-lf0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753027AbdHGLvG (ORCPT ); Mon, 7 Aug 2017 07:51:06 -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 RESEND 09/11] ALSA: vsnd: Implement ALSA PCM operations Date: Mon, 7 Aug 2017 14:50:43 +0300 Message-Id: <1502106645-6731-10-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1502106645-6731-1-git-send-email-andr2000@gmail.com> References: <1502106645-6731-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 Implement ALSA driver operations including: - start/stop period interrupt emulation - manage frontend/backend shraed buffers - manage Xen bus event channel state Signed-off-by: Oleksandr Andrushchenko --- sound/drivers/xen-front.c | 175 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 163 insertions(+), 12 deletions(-) diff --git a/sound/drivers/xen-front.c b/sound/drivers/xen-front.c index 507c5eb343c8..7275e9cb38c0 100644 --- a/sound/drivers/xen-front.c +++ b/sound/drivers/xen-front.c @@ -151,6 +151,11 @@ struct xdrv_info { struct sdev_card_plat_data cfg_plat_data; }; +static inline void sh_buf_clear(struct sh_buf_info *buf); +static void sh_buf_free(struct sh_buf_info *buf); +static int sh_buf_alloc(struct xenbus_device *xb_dev, struct sh_buf_info *buf, + unsigned int buffer_size); + static struct sdev_pcm_stream_info *sdrv_stream_get( struct snd_pcm_substream *substream) { @@ -311,71 +316,217 @@ static void sdrv_copy_pcm_hw(struct snd_pcm_hardware *dst, static int sdrv_alsa_open(struct snd_pcm_substream *substream) { - return 0; + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + struct snd_pcm_runtime *runtime = substream->runtime; + struct xdrv_info *xdrv_info; + unsigned long flags; + int ret; + + sdrv_copy_pcm_hw(&runtime->hw, &stream->pcm_hw, &pcm_instance->pcm_hw); + runtime->hw.info &= ~(SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_DOUBLE | + SNDRV_PCM_INFO_BATCH | + SNDRV_PCM_INFO_NONINTERLEAVED | + SNDRV_PCM_INFO_RESUME | + SNDRV_PCM_INFO_PAUSE); + runtime->hw.info |= SNDRV_PCM_INFO_INTERLEAVED; + + xdrv_info = pcm_instance->card_info->xdrv_info; + + ret = sdrv_alsa_timer_create(substream); + + spin_lock_irqsave(&xdrv_info->io_lock, flags); + sh_buf_clear(&stream->sh_buf); + stream->evt_chnl = &xdrv_info->evt_chnls[stream->unique_id]; + if (ret < 0) + stream->evt_chnl->state = EVTCHNL_STATE_DISCONNECTED; + else + stream->evt_chnl->state = EVTCHNL_STATE_CONNECTED; + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); + return ret; } static int sdrv_alsa_close(struct snd_pcm_substream *substream) { + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + struct xdrv_info *xdrv_info; + unsigned long flags; + + xdrv_info = pcm_instance->card_info->xdrv_info; + + sdrv_alsa_timer_stop(substream); + + spin_lock_irqsave(&xdrv_info->io_lock, flags); + stream->evt_chnl->state = EVTCHNL_STATE_DISCONNECTED; + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); return 0; } static int sdrv_alsa_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + struct xdrv_info *xdrv_info; + unsigned int buffer_size; + int ret; + + buffer_size = params_buffer_bytes(params); + sh_buf_clear(&stream->sh_buf); + xdrv_info = pcm_instance->card_info->xdrv_info; + ret = sh_buf_alloc(xdrv_info->xb_dev, + &stream->sh_buf, buffer_size); + if (ret < 0) + goto fail; return 0; + +fail: + dev_err(&xdrv_info->xb_dev->dev, + "Failed to allocate buffers for stream idx %d\n", + stream->unique_id); + return ret; } static int sdrv_alsa_hw_free(struct snd_pcm_substream *substream) { + struct sdev_pcm_instance_info *pcm_instance = + snd_pcm_substream_chip(substream); + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + struct xdrv_info *xdrv_info; + unsigned long flags; + + xdrv_info = pcm_instance->card_info->xdrv_info; + spin_lock_irqsave(&xdrv_info->io_lock, flags); + sh_buf_free(&stream->sh_buf); + spin_unlock_irqrestore(&xdrv_info->io_lock, flags); return 0; } static int sdrv_alsa_prepare(struct snd_pcm_substream *substream) { - return 0; + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + int ret = 0; + + if (!stream->is_open) + ret = sdrv_alsa_timer_prepare(substream); + return ret; } static int sdrv_alsa_trigger(struct snd_pcm_substream *substream, int cmd) { + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + /* fall through */ + case SNDRV_PCM_TRIGGER_RESUME: + return sdrv_alsa_timer_start(substream); + + case SNDRV_PCM_TRIGGER_STOP: + /* fall through */ + case SNDRV_PCM_TRIGGER_SUSPEND: + return sdrv_alsa_timer_stop(substream); + + default: + break; + } return 0; } static inline snd_pcm_uframes_t sdrv_alsa_pointer( struct snd_pcm_substream *substream) { + return sdrv_alsa_timer_pointer(substream); +} + +static int sdrv_alsa_playback_do_write(struct snd_pcm_substream *substream, + unsigned long pos, unsigned long count) +{ 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) + int channel, unsigned long pos, void __user *src, + unsigned long count) { - return 0; + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + + if (unlikely(pos + count > stream->sh_buf.vbuffer_sz)) + return -EINVAL; + + if (copy_from_user(stream->sh_buf.vbuffer + pos, src, count)) + return -EFAULT; + + return sdrv_alsa_playback_do_write(substream, pos, count); } static int sdrv_alsa_playback_copy_kernel(struct snd_pcm_substream *substream, - int channel, unsigned long pos, void *buf, unsigned long bytes) + int channel, unsigned long pos, void *src, unsigned long count) +{ + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + + if (unlikely(pos + count > stream->sh_buf.vbuffer_sz)) + return -EINVAL; + + memcpy(stream->sh_buf.vbuffer + pos, src, count); + return sdrv_alsa_playback_do_write(substream, pos, count); +} + +static int sdrv_alsa_playback_do_read(struct snd_pcm_substream *substream, + unsigned long pos, unsigned long count) { 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) + int channel, unsigned long pos, void __user *dst, + unsigned long count) { - return 0; + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + int ret; + + if (unlikely(pos + count > stream->sh_buf.vbuffer_sz)) + return -EINVAL; + + ret = sdrv_alsa_playback_do_read(substream, pos, count); + if (ret < 0) + return ret; + + return copy_to_user(dst, stream->sh_buf.vbuffer + pos, count) ? + -EFAULT : 0; } static int sdrv_alsa_capture_copy_kernel(struct snd_pcm_substream *substream, - int channel, unsigned long pos, void *buf, unsigned long bytes) + int channel, unsigned long pos, void *dst, unsigned long count) { + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + int ret; + + if (unlikely(pos + count > stream->sh_buf.vbuffer_sz)) + return -EINVAL; + + ret = sdrv_alsa_playback_do_read(substream, pos, count); + if (ret < 0) + return ret; + + memcpy(dst, stream->sh_buf.vbuffer + pos, count); return 0; } static int sdrv_alsa_playback_fill_silence(struct snd_pcm_substream *substream, - int channel, unsigned long pos, unsigned long bytes) + int channel, unsigned long pos, unsigned long count) { - return 0; + struct sdev_pcm_stream_info *stream = sdrv_stream_get(substream); + + if (unlikely(pos + count > stream->sh_buf.vbuffer_sz)) + return -EINVAL; + + memset(stream->sh_buf.vbuffer + pos, 0, count); + return sdrv_alsa_playback_do_write(substream, pos, count); } #define MAX_XEN_BUFFER_SIZE (64 * 1024) -- 2.7.4