From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [Xen-devel][PATCH 3/3] ALSA: xen-front: Use Xen common shared buffer implementation Date: Thu, 22 Nov 2018 12:02:30 +0200 Message-ID: <20181122100230.14976-3-andr2000@gmail.com> References: <20181122100230.14976-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20181122100230.14976-1-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, alsa-devel@alsa-project.org, jgross@suse.com, boris.ostrovsky@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko List-Id: alsa-devel@alsa-project.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKVXNlIHBhZ2UgZGlyZWN0b3J5IGJhc2VkIHNoYXJlZCBidWZmZXIgaW1wbGVtZW50 YXRpb24Kbm93IGF2YWlsYWJsZSBhcyBjb21tb24gY29kZSBmb3IgWGVuIGZyb250ZW5kIGRyaXZl cnMuCgpTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2Fu ZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0tLQogc291bmQveGVuL0tjb25maWcgICAgICAgICAgICAg ICB8ICAgMSArCiBzb3VuZC94ZW4vTWFrZWZpbGUgICAgICAgICAgICAgIHwgICAxIC0KIHNvdW5k L3hlbi94ZW5fc25kX2Zyb250LmMgICAgICAgfCAgIDcgKy0KIHNvdW5kL3hlbi94ZW5fc25kX2Zy b250LmggICAgICAgfCAgIDQgKy0KIHNvdW5kL3hlbi94ZW5fc25kX2Zyb250X2Fsc2EuYyAgfCAx MDEgKysrKysrKysrKysrKy0tLS0KIHNvdW5kL3hlbi94ZW5fc25kX2Zyb250X3NoYnVmLmMgfCAx OTQgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIHNvdW5kL3hlbi94ZW5fc25kX2Zy b250X3NoYnVmLmggfCAgMzYgLS0tLS0tCiA3IGZpbGVzIGNoYW5nZWQsIDgzIGluc2VydGlvbnMo KyksIDI2MSBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBzb3VuZC94ZW4veGVuX3Nu ZF9mcm9udF9zaGJ1Zi5jCiBkZWxldGUgbW9kZSAxMDA2NDQgc291bmQveGVuL3hlbl9zbmRfZnJv bnRfc2hidWYuaAoKZGlmZiAtLWdpdCBhL3NvdW5kL3hlbi9LY29uZmlnIGIvc291bmQveGVuL0tj b25maWcKaW5kZXggNGYxZmNlZWE4MmQyLi5lNGQ3YmViNGRmMWMgMTAwNjQ0Ci0tLSBhL3NvdW5k L3hlbi9LY29uZmlnCisrKyBiL3NvdW5kL3hlbi9LY29uZmlnCkBAIC01LDYgKzUsNyBAQCBjb25m aWcgU05EX1hFTl9GUk9OVEVORAogCWRlcGVuZHMgb24gWEVOCiAJc2VsZWN0IFNORF9QQ00KIAlz ZWxlY3QgWEVOX1hFTkJVU19GUk9OVEVORAorCXNlbGVjdCBYRU5fRlJPTlRfUEdESVJfU0hCVUYK IAloZWxwCiAJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxlIGEgcGFy YS12aXJ0dWFsaXplZAogCSAgZnJvbnRlbmQgc291bmQgZHJpdmVyIGZvciBYZW4gZ3Vlc3QgT1Nl cy4KZGlmZiAtLWdpdCBhL3NvdW5kL3hlbi9NYWtlZmlsZSBiL3NvdW5kL3hlbi9NYWtlZmlsZQpp bmRleCAxZTY0NzBlY2MyZjIuLjI0MDMxNzc1YjcxNSAxMDA2NDQKLS0tIGEvc291bmQveGVuL01h a2VmaWxlCisrKyBiL3NvdW5kL3hlbi9NYWtlZmlsZQpAQCAtMyw3ICszLDYgQEAKIHNuZF94ZW5f ZnJvbnQtb2JqcyA6PSB4ZW5fc25kX2Zyb250Lm8gXAogCQkgICAgICB4ZW5fc25kX2Zyb250X2Nm Zy5vIFwKIAkJICAgICAgeGVuX3NuZF9mcm9udF9ldnRjaG5sLm8gXAotCQkgICAgICB4ZW5fc25k X2Zyb250X3NoYnVmLm8gXAogCQkgICAgICB4ZW5fc25kX2Zyb250X2Fsc2EubwogCiBvYmotJChD T05GSUdfU05EX1hFTl9GUk9OVEVORCkgKz0gc25kX3hlbl9mcm9udC5vCmRpZmYgLS1naXQgYS9z b3VuZC94ZW4veGVuX3NuZF9mcm9udC5jIGIvc291bmQveGVuL3hlbl9zbmRfZnJvbnQuYwppbmRl eCBiMDg5YjEzYjUxNjAuLmE5ZTVjMmNkNzY5OCAxMDA2NDQKLS0tIGEvc291bmQveGVuL3hlbl9z bmRfZnJvbnQuYworKysgYi9zb3VuZC94ZW4veGVuX3NuZF9mcm9udC5jCkBAIC0xNiwxMiArMTYs MTIgQEAKICNpbmNsdWRlIDx4ZW4veGVuLmg+CiAjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgogCisj aW5jbHVkZSA8eGVuL3hlbi1mcm9udC1wZ2Rpci1zaGJ1Zi5oPgogI2luY2x1ZGUgPHhlbi9pbnRl cmZhY2UvaW8vc25kaWYuaD4KIAogI2luY2x1ZGUgInhlbl9zbmRfZnJvbnQuaCIKICNpbmNsdWRl ICJ4ZW5fc25kX2Zyb250X2Fsc2EuaCIKICNpbmNsdWRlICJ4ZW5fc25kX2Zyb250X2V2dGNobmwu aCIKLSNpbmNsdWRlICJ4ZW5fc25kX2Zyb250X3NoYnVmLmgiCiAKIHN0YXRpYyBzdHJ1Y3QgeGVu c25kX3JlcSAqCiBiZV9zdHJlYW1fcHJlcGFyZV9yZXEoc3RydWN0IHhlbl9zbmRfZnJvbnRfZXZ0 Y2hubCAqZXZ0Y2hubCwgdTggb3BlcmF0aW9uKQpAQCAtODIsNyArODIsNyBAQCBpbnQgeGVuX3Nu ZF9mcm9udF9zdHJlYW1fcXVlcnlfaHdfcGFyYW0oc3RydWN0IHhlbl9zbmRfZnJvbnRfZXZ0Y2hu bCAqZXZ0Y2hubCwKIH0KIAogaW50IHhlbl9zbmRfZnJvbnRfc3RyZWFtX3ByZXBhcmUoc3RydWN0 IHhlbl9zbmRfZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCwKLQkJCQkgc3RydWN0IHhlbl9zbmRfZnJv bnRfc2hidWYgKnNoX2J1ZiwKKwkJCQkgc3RydWN0IHhlbl9mcm9udF9wZ2Rpcl9zaGJ1ZiAqc2hi dWYsCiAJCQkJIHU4IGZvcm1hdCwgdW5zaWduZWQgaW50IGNoYW5uZWxzLAogCQkJCSB1bnNpZ25l ZCBpbnQgcmF0ZSwgdTMyIGJ1ZmZlcl9zeiwKIAkJCQkgdTMyIHBlcmlvZF9zeikKQEAgLTk5LDcg Kzk5LDggQEAgaW50IHhlbl9zbmRfZnJvbnRfc3RyZWFtX3ByZXBhcmUoc3RydWN0IHhlbl9zbmRf ZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCwKIAlyZXEtPm9wLm9wZW4ucGNtX3JhdGUgPSByYXRlOwog CXJlcS0+b3Aub3Blbi5idWZmZXJfc3ogPSBidWZmZXJfc3o7CiAJcmVxLT5vcC5vcGVuLnBlcmlv ZF9zeiA9IHBlcmlvZF9zejsKLQlyZXEtPm9wLm9wZW4uZ3JlZl9kaXJlY3RvcnkgPSB4ZW5fc25k X2Zyb250X3NoYnVmX2dldF9kaXJfc3RhcnQoc2hfYnVmKTsKKwlyZXEtPm9wLm9wZW4uZ3JlZl9k aXJlY3RvcnkgPQorCQl4ZW5fZnJvbnRfcGdkaXJfc2hidWZfZ2V0X2Rpcl9zdGFydChzaGJ1Zik7 CiAJbXV0ZXhfdW5sb2NrKCZldnRjaG5sLT5yaW5nX2lvX2xvY2spOwogCiAJcmV0ID0gYmVfc3Ry ZWFtX2RvX2lvKGV2dGNobmwpOwpkaWZmIC0tZ2l0IGEvc291bmQveGVuL3hlbl9zbmRfZnJvbnQu aCBiL3NvdW5kL3hlbi94ZW5fc25kX2Zyb250LmgKaW5kZXggYTJlYTI0NjNiY2M1Li4wNTYxMWYx MTNiOTQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3hlbi94ZW5fc25kX2Zyb250LmgKKysrIGIvc291bmQv eGVuL3hlbl9zbmRfZnJvbnQuaApAQCAtMTYsNyArMTYsNyBAQAogc3RydWN0IHhlbl9zbmRfZnJv bnRfY2FyZF9pbmZvOwogc3RydWN0IHhlbl9zbmRfZnJvbnRfZXZ0Y2hubDsKIHN0cnVjdCB4ZW5f c25kX2Zyb250X2V2dGNobmxfcGFpcjsKLXN0cnVjdCB4ZW5fc25kX2Zyb250X3NoYnVmOworc3Ry dWN0IHhlbl9mcm9udF9wZ2Rpcl9zaGJ1ZjsKIHN0cnVjdCB4ZW5zbmRfcXVlcnlfaHdfcGFyYW07 CiAKIHN0cnVjdCB4ZW5fc25kX2Zyb250X2luZm8gewpAQCAtMzUsNyArMzUsNyBAQCBpbnQgeGVu X3NuZF9mcm9udF9zdHJlYW1fcXVlcnlfaHdfcGFyYW0oc3RydWN0IHhlbl9zbmRfZnJvbnRfZXZ0 Y2hubCAqZXZ0Y2hubCwKIAkJCQkJc3RydWN0IHhlbnNuZF9xdWVyeV9od19wYXJhbSAqaHdfcGFy YW1fcmVzcCk7CiAKIGludCB4ZW5fc25kX2Zyb250X3N0cmVhbV9wcmVwYXJlKHN0cnVjdCB4ZW5f c25kX2Zyb250X2V2dGNobmwgKmV2dGNobmwsCi0JCQkJIHN0cnVjdCB4ZW5fc25kX2Zyb250X3No YnVmICpzaF9idWYsCisJCQkJIHN0cnVjdCB4ZW5fZnJvbnRfcGdkaXJfc2hidWYgKnNoYnVmLAog CQkJCSB1OCBmb3JtYXQsIHVuc2lnbmVkIGludCBjaGFubmVscywKIAkJCQkgdW5zaWduZWQgaW50 IHJhdGUsIHUzMiBidWZmZXJfc3osCiAJCQkJIHUzMiBwZXJpb2Rfc3opOwpkaWZmIC0tZ2l0IGEv c291bmQveGVuL3hlbl9zbmRfZnJvbnRfYWxzYS5jIGIvc291bmQveGVuL3hlbl9zbmRfZnJvbnRf YWxzYS5jCmluZGV4IDEyOTE4MGUxN2RiMS4uNWI4NzRhNzAxNGUwIDEwMDY0NAotLS0gYS9zb3Vu ZC94ZW4veGVuX3NuZF9mcm9udF9hbHNhLmMKKysrIGIvc291bmQveGVuL3hlbl9zbmRfZnJvbnRf YWxzYS5jCkBAIC0xNSwxNyArMTUsMjQgQEAKICNpbmNsdWRlIDxzb3VuZC9wY21fcGFyYW1zLmg+ CiAKICNpbmNsdWRlIDx4ZW4veGVuYnVzLmg+CisjaW5jbHVkZSA8eGVuL3hlbi1mcm9udC1wZ2Rp ci1zaGJ1Zi5oPgogCiAjaW5jbHVkZSAieGVuX3NuZF9mcm9udC5oIgogI2luY2x1ZGUgInhlbl9z bmRfZnJvbnRfYWxzYS5oIgogI2luY2x1ZGUgInhlbl9zbmRfZnJvbnRfY2ZnLmgiCiAjaW5jbHVk ZSAieGVuX3NuZF9mcm9udF9ldnRjaG5sLmgiCi0jaW5jbHVkZSAieGVuX3NuZF9mcm9udF9zaGJ1 Zi5oIgogCiBzdHJ1Y3QgeGVuX3NuZF9mcm9udF9wY21fc3RyZWFtX2luZm8gewogCXN0cnVjdCB4 ZW5fc25kX2Zyb250X2luZm8gKmZyb250X2luZm87CiAJc3RydWN0IHhlbl9zbmRfZnJvbnRfZXZ0 Y2hubF9wYWlyICpldnRfcGFpcjsKLQlzdHJ1Y3QgeGVuX3NuZF9mcm9udF9zaGJ1ZiBzaF9idWY7 CisKKwkvKiBUaGlzIGlzIHRoZSBzaGFyZWQgYnVmZmVyIHdpdGggaXRzIGJhY2tpbmcgc3RvcmFn ZS4gKi8KKwlzdHJ1Y3QgeGVuX2Zyb250X3BnZGlyX3NoYnVmIHNoYnVmOworCXU4ICpidWZmZXI7 CisJc2l6ZV90IGJ1ZmZlcl9zejsKKwlpbnQgbnVtX3BhZ2VzOworCXN0cnVjdCBwYWdlICoqcGFn ZXM7CisKIAlpbnQgaW5kZXg7CiAKIAlib29sIGlzX29wZW47CkBAIC0yMTQsMTIgKzIyMSwxOSBA QCBzdGF0aWMgdm9pZCBzdHJlYW1fY2xlYXIoc3RydWN0IHhlbl9zbmRfZnJvbnRfcGNtX3N0cmVh bV9pbmZvICpzdHJlYW0pCiAJc3RyZWFtLT5vdXRfZnJhbWVzID0gMDsKIAlhdG9taWNfc2V0KCZz dHJlYW0tPmh3X3B0ciwgMCk7CiAJeGVuX3NuZF9mcm9udF9ldnRjaG5sX3BhaXJfY2xlYXIoc3Ry ZWFtLT5ldnRfcGFpcik7Ci0JeGVuX3NuZF9mcm9udF9zaGJ1Zl9jbGVhcigmc3RyZWFtLT5zaF9i dWYpOworCW1lbXNldCgmc3RyZWFtLT5zaGJ1ZiwgMCwgc2l6ZW9mKHN0cmVhbS0+c2hidWYpKTsK KwlzdHJlYW0tPmJ1ZmZlciA9IE5VTEw7CisJc3RyZWFtLT5idWZmZXJfc3ogPSAwOworCXN0cmVh bS0+cGFnZXMgPSBOVUxMOworCXN0cmVhbS0+bnVtX3BhZ2VzID0gMDsKIH0KIAogc3RhdGljIHZv aWQgc3RyZWFtX2ZyZWUoc3RydWN0IHhlbl9zbmRfZnJvbnRfcGNtX3N0cmVhbV9pbmZvICpzdHJl YW0pCiB7Ci0JeGVuX3NuZF9mcm9udF9zaGJ1Zl9mcmVlKCZzdHJlYW0tPnNoX2J1Zik7CisJeGVu X2Zyb250X3BnZGlyX3NoYnVmX3VubWFwKCZzdHJlYW0tPnNoYnVmKTsKKwl4ZW5fZnJvbnRfcGdk aXJfc2hidWZfZnJlZSgmc3RyZWFtLT5zaGJ1Zik7CisJZnJlZV9wYWdlc19leGFjdChzdHJlYW0t PmJ1ZmZlciwgc3RyZWFtLT5idWZmZXJfc3opOworCWtmcmVlKHN0cmVhbS0+cGFnZXMpOwogCXN0 cmVhbV9jbGVhcihzdHJlYW0pOwogfQogCkBAIC00MjEsMTAgKzQzNSwzNCBAQCBzdGF0aWMgaW50 IGFsc2FfY2xvc2Uoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0pCiAJcmV0dXJu IDA7CiB9CiAKK3N0YXRpYyBpbnQgc2hidWZfc2V0dXBfYmFja3N0b3JlKHN0cnVjdCB4ZW5fc25k X2Zyb250X3BjbV9zdHJlYW1faW5mbyAqc3RyZWFtLAorCQkJCSBzaXplX3QgYnVmZmVyX3N6KQor eworCWludCBpOworCisJc3RyZWFtLT5idWZmZXJfc3ogPSBidWZmZXJfc3o7CisJc3RyZWFtLT5i dWZmZXIgPSBhbGxvY19wYWdlc19leGFjdChzdHJlYW0tPmJ1ZmZlcl9zeiwgR0ZQX0tFUk5FTCk7 CisJaWYgKCFzdHJlYW0tPmJ1ZmZlcikKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlzdHJlYW0tPm51 bV9wYWdlcyA9IERJVl9ST1VORF9VUChzdHJlYW0tPmJ1ZmZlcl9zeiwgUEFHRV9TSVpFKTsKKwlz dHJlYW0tPnBhZ2VzID0ga2NhbGxvYyhzdHJlYW0tPm51bV9wYWdlcywgc2l6ZW9mKHN0cnVjdCBw YWdlICopLAorCQkJCUdGUF9LRVJORUwpOworCWlmICghc3RyZWFtLT5wYWdlcykKKwkJcmV0dXJu IC1FTk9NRU07CisKKwlmb3IgKGkgPSAwOyBpIDwgc3RyZWFtLT5udW1fcGFnZXM7IGkrKykKKwkJ c3RyZWFtLT5wYWdlc1tpXSA9IHZpcnRfdG9fcGFnZShzdHJlYW0tPmJ1ZmZlciArIGkgKiBQQUdF X1NJWkUpOworCisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyBpbnQgYWxzYV9od19wYXJhbXMoc3Ry dWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCiAJCQkgIHN0cnVjdCBzbmRfcGNtX2h3 X3BhcmFtcyAqcGFyYW1zKQogewogCXN0cnVjdCB4ZW5fc25kX2Zyb250X3BjbV9zdHJlYW1faW5m byAqc3RyZWFtID0gc3RyZWFtX2dldChzdWJzdHJlYW0pOworCXN0cnVjdCB4ZW5fc25kX2Zyb250 X2luZm8gKmZyb250X2luZm8gPSBzdHJlYW0tPmZyb250X2luZm87CisJc3RydWN0IHhlbl9mcm9u dF9wZ2Rpcl9zaGJ1Zl9jZmcgYnVmX2NmZzsKIAlpbnQgcmV0OwogCiAJLyoKQEAgLTQzMiwxOSAr NDcwLDMyIEBAIHN0YXRpYyBpbnQgYWxzYV9od19wYXJhbXMoc3RydWN0IHNuZF9wY21fc3Vic3Ry ZWFtICpzdWJzdHJlYW0sCiAJICogc28gZnJlZSB0aGUgcHJldmlvdXNseSBhbGxvY2F0ZWQgc2hh cmVkIGJ1ZmZlciBpZiBhbnkuCiAJICovCiAJc3RyZWFtX2ZyZWUoc3RyZWFtKTsKKwlyZXQgPSBz aGJ1Zl9zZXR1cF9iYWNrc3RvcmUoc3RyZWFtLCBwYXJhbXNfYnVmZmVyX2J5dGVzKHBhcmFtcykp OworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CiAKLQlyZXQgPSB4ZW5fc25kX2Zyb250X3No YnVmX2FsbG9jKHN0cmVhbS0+ZnJvbnRfaW5mby0+eGJfZGV2LAotCQkJCQkmc3RyZWFtLT5zaF9i dWYsCi0JCQkJCXBhcmFtc19idWZmZXJfYnl0ZXMocGFyYW1zKSk7Ci0JaWYgKHJldCA8IDApIHsK LQkJc3RyZWFtX2ZyZWUoc3RyZWFtKTsKLQkJZGV2X2Vycigmc3RyZWFtLT5mcm9udF9pbmZvLT54 Yl9kZXYtPmRldiwKLQkJCSJGYWlsZWQgdG8gYWxsb2NhdGUgYnVmZmVycyBmb3Igc3RyZWFtIHdp dGggaW5kZXggJWRcbiIsCi0JCQlzdHJlYW0tPmluZGV4KTsKLQkJcmV0dXJuIHJldDsKLQl9CisJ bWVtc2V0KCZidWZfY2ZnLCAwLCBzaXplb2YoYnVmX2NmZykpOworCWJ1Zl9jZmcueGJfZGV2ID0g ZnJvbnRfaW5mby0+eGJfZGV2OworCWJ1Zl9jZmcucGdkaXIgPSAmc3RyZWFtLT5zaGJ1ZjsKKwli dWZfY2ZnLm51bV9wYWdlcyA9IHN0cmVhbS0+bnVtX3BhZ2VzOworCWJ1Zl9jZmcucGFnZXMgPSBz dHJlYW0tPnBhZ2VzOworCisJcmV0ID0geGVuX2Zyb250X3BnZGlyX3NoYnVmX2FsbG9jKCZidWZf Y2ZnKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0geGVuX2Zyb250X3Bn ZGlyX3NoYnVmX21hcCgmc3RyZWFtLT5zaGJ1Zik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFp bDsKIAogCXJldHVybiAwOworCitmYWlsOgorCXN0cmVhbV9mcmVlKHN0cmVhbSk7CisJZGV2X2Vy cigmZnJvbnRfaW5mby0+eGJfZGV2LT5kZXYsCisJCSJGYWlsZWQgdG8gYWxsb2NhdGUgYnVmZmVy cyBmb3Igc3RyZWFtIHdpdGggaW5kZXggJWRcbiIsCisJCXN0cmVhbS0+aW5kZXgpOworCXJldHVy biByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgYWxzYV9od19mcmVlKHN0cnVjdCBzbmRfcGNtX3N1YnN0 cmVhbSAqc3Vic3RyZWFtKQpAQCAtNDc2LDcgKzUyNyw3IEBAIHN0YXRpYyBpbnQgYWxzYV9wcmVw YXJlKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtKQogCQlzbmRpZl9mb3JtYXQg PSByZXQ7CiAKIAkJcmV0ID0geGVuX3NuZF9mcm9udF9zdHJlYW1fcHJlcGFyZSgmc3RyZWFtLT5l dnRfcGFpci0+cmVxLAotCQkJCQkJICAgJnN0cmVhbS0+c2hfYnVmLAorCQkJCQkJICAgJnN0cmVh bS0+c2hidWYsCiAJCQkJCQkgICBzbmRpZl9mb3JtYXQsCiAJCQkJCQkgICBydW50aW1lLT5jaGFu bmVscywKIAkJCQkJCSAgIHJ1bnRpbWUtPnJhdGUsCkBAIC01NTYsMTAgKzYwNywxMCBAQCBzdGF0 aWMgaW50IGFsc2FfcGJfY29weV91c2VyKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3Ry ZWFtLAogewogCXN0cnVjdCB4ZW5fc25kX2Zyb250X3BjbV9zdHJlYW1faW5mbyAqc3RyZWFtID0g c3RyZWFtX2dldChzdWJzdHJlYW0pOwogCi0JaWYgKHVubGlrZWx5KHBvcyArIGNvdW50ID4gc3Ry ZWFtLT5zaF9idWYuYnVmZmVyX3N6KSkKKwlpZiAodW5saWtlbHkocG9zICsgY291bnQgPiBzdHJl YW0tPmJ1ZmZlcl9zeikpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaWYgKGNvcHlfZnJvbV91c2Vy KHN0cmVhbS0+c2hfYnVmLmJ1ZmZlciArIHBvcywgc3JjLCBjb3VudCkpCisJaWYgKGNvcHlfZnJv bV91c2VyKHN0cmVhbS0+YnVmZmVyICsgcG9zLCBzcmMsIGNvdW50KSkKIAkJcmV0dXJuIC1FRkFV TFQ7CiAKIAlyZXR1cm4geGVuX3NuZF9mcm9udF9zdHJlYW1fd3JpdGUoJnN0cmVhbS0+ZXZ0X3Bh aXItPnJlcSwgcG9zLCBjb3VudCk7CkBAIC01NzEsMTAgKzYyMiwxMCBAQCBzdGF0aWMgaW50IGFs c2FfcGJfY29weV9rZXJuZWwoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCiB7 CiAJc3RydWN0IHhlbl9zbmRfZnJvbnRfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzdHJlYW1f Z2V0KHN1YnN0cmVhbSk7CiAKLQlpZiAodW5saWtlbHkocG9zICsgY291bnQgPiBzdHJlYW0tPnNo X2J1Zi5idWZmZXJfc3opKQorCWlmICh1bmxpa2VseShwb3MgKyBjb3VudCA+IHN0cmVhbS0+YnVm ZmVyX3N6KSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQltZW1jcHkoc3RyZWFtLT5zaF9idWYuYnVm ZmVyICsgcG9zLCBzcmMsIGNvdW50KTsKKwltZW1jcHkoc3RyZWFtLT5idWZmZXIgKyBwb3MsIHNy YywgY291bnQpOwogCiAJcmV0dXJuIHhlbl9zbmRfZnJvbnRfc3RyZWFtX3dyaXRlKCZzdHJlYW0t PmV2dF9wYWlyLT5yZXEsIHBvcywgY291bnQpOwogfQpAQCAtNTg2LDE0ICs2MzcsMTQgQEAgc3Rh dGljIGludCBhbHNhX2NhcF9jb3B5X3VzZXIoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJz dHJlYW0sCiAJc3RydWN0IHhlbl9zbmRfZnJvbnRfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBz dHJlYW1fZ2V0KHN1YnN0cmVhbSk7CiAJaW50IHJldDsKIAotCWlmICh1bmxpa2VseShwb3MgKyBj b3VudCA+IHN0cmVhbS0+c2hfYnVmLmJ1ZmZlcl9zeikpCisJaWYgKHVubGlrZWx5KHBvcyArIGNv dW50ID4gc3RyZWFtLT5idWZmZXJfc3opKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCXJldCA9IHhl bl9zbmRfZnJvbnRfc3RyZWFtX3JlYWQoJnN0cmVhbS0+ZXZ0X3BhaXItPnJlcSwgcG9zLCBjb3Vu dCk7CiAJaWYgKHJldCA8IDApCiAJCXJldHVybiByZXQ7CiAKLQlyZXR1cm4gY29weV90b191c2Vy KGRzdCwgc3RyZWFtLT5zaF9idWYuYnVmZmVyICsgcG9zLCBjb3VudCkgPworCXJldHVybiBjb3B5 X3RvX3VzZXIoZHN0LCBzdHJlYW0tPmJ1ZmZlciArIHBvcywgY291bnQpID8KIAkJLUVGQVVMVCA6 IDA7CiB9CiAKQEAgLTYwNCwxNCArNjU1LDE0IEBAIHN0YXRpYyBpbnQgYWxzYV9jYXBfY29weV9r ZXJuZWwoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0sCiAJc3RydWN0IHhlbl9z bmRfZnJvbnRfcGNtX3N0cmVhbV9pbmZvICpzdHJlYW0gPSBzdHJlYW1fZ2V0KHN1YnN0cmVhbSk7 CiAJaW50IHJldDsKIAotCWlmICh1bmxpa2VseShwb3MgKyBjb3VudCA+IHN0cmVhbS0+c2hfYnVm LmJ1ZmZlcl9zeikpCisJaWYgKHVubGlrZWx5KHBvcyArIGNvdW50ID4gc3RyZWFtLT5idWZmZXJf c3opKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCXJldCA9IHhlbl9zbmRfZnJvbnRfc3RyZWFtX3Jl YWQoJnN0cmVhbS0+ZXZ0X3BhaXItPnJlcSwgcG9zLCBjb3VudCk7CiAJaWYgKHJldCA8IDApCiAJ CXJldHVybiByZXQ7CiAKLQltZW1jcHkoZHN0LCBzdHJlYW0tPnNoX2J1Zi5idWZmZXIgKyBwb3Ms IGNvdW50KTsKKwltZW1jcHkoZHN0LCBzdHJlYW0tPmJ1ZmZlciArIHBvcywgY291bnQpOwogCiAJ cmV0dXJuIDA7CiB9CkBAIC02MjIsMTAgKzY3MywxMCBAQCBzdGF0aWMgaW50IGFsc2FfcGJfZmls bF9zaWxlbmNlKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtLAogewogCXN0cnVj dCB4ZW5fc25kX2Zyb250X3BjbV9zdHJlYW1faW5mbyAqc3RyZWFtID0gc3RyZWFtX2dldChzdWJz dHJlYW0pOwogCi0JaWYgKHVubGlrZWx5KHBvcyArIGNvdW50ID4gc3RyZWFtLT5zaF9idWYuYnVm ZmVyX3N6KSkKKwlpZiAodW5saWtlbHkocG9zICsgY291bnQgPiBzdHJlYW0tPmJ1ZmZlcl9zeikp CiAJCXJldHVybiAtRUlOVkFMOwogCi0JbWVtc2V0KHN0cmVhbS0+c2hfYnVmLmJ1ZmZlciArIHBv cywgMCwgY291bnQpOworCW1lbXNldChzdHJlYW0tPmJ1ZmZlciArIHBvcywgMCwgY291bnQpOwog CiAJcmV0dXJuIHhlbl9zbmRfZnJvbnRfc3RyZWFtX3dyaXRlKCZzdHJlYW0tPmV2dF9wYWlyLT5y ZXEsIHBvcywgY291bnQpOwogfQpkaWZmIC0tZ2l0IGEvc291bmQveGVuL3hlbl9zbmRfZnJvbnRf c2hidWYuYyBiL3NvdW5kL3hlbi94ZW5fc25kX2Zyb250X3NoYnVmLmMKZGVsZXRlZCBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDA3YWMxNzZhNDFiYS4uMDAwMDAwMDAwMDAwCi0tLSBhL3NvdW5kL3hl bi94ZW5fc25kX2Zyb250X3NoYnVmLmMKKysrIC9kZXYvbnVsbApAQCAtMSwxOTQgKzAsMCBAQAot Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCi0KLS8qCi0gKiBYZW4g cGFyYS12aXJ0dWFsIHNvdW5kIGRldmljZQotICoKLSAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4 IEVQQU0gU3lzdGVtcyBJbmMuCi0gKgotICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5r byA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0gKi8KLQotI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgotI2luY2x1ZGUgPHhlbi94ZW4uaD4KLSNpbmNsdWRlIDx4ZW4veGVuYnVz Lmg+Ci0KLSNpbmNsdWRlICJ4ZW5fc25kX2Zyb250X3NoYnVmLmgiCi0KLWdyYW50X3JlZl90IHhl bl9zbmRfZnJvbnRfc2hidWZfZ2V0X2Rpcl9zdGFydChzdHJ1Y3QgeGVuX3NuZF9mcm9udF9zaGJ1 ZiAqYnVmKQotewotCWlmICghYnVmLT5ncmVmcykKLQkJcmV0dXJuIEdSQU5UX0lOVkFMSURfUkVG OwotCi0JcmV0dXJuIGJ1Zi0+Z3JlZnNbMF07Ci19Ci0KLXZvaWQgeGVuX3NuZF9mcm9udF9zaGJ1 Zl9jbGVhcihzdHJ1Y3QgeGVuX3NuZF9mcm9udF9zaGJ1ZiAqYnVmKQotewotCW1lbXNldChidWYs IDAsIHNpemVvZigqYnVmKSk7Ci19Ci0KLXZvaWQgeGVuX3NuZF9mcm9udF9zaGJ1Zl9mcmVlKHN0 cnVjdCB4ZW5fc25kX2Zyb250X3NoYnVmICpidWYpCi17Ci0JaW50IGk7Ci0KLQlpZiAoYnVmLT5n cmVmcykgewotCQlmb3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fZ3JlZnM7IGkrKykKLQkJCWlmIChi dWYtPmdyZWZzW2ldICE9IEdSQU5UX0lOVkFMSURfUkVGKQotCQkJCWdudHRhYl9lbmRfZm9yZWln bl9hY2Nlc3MoYnVmLT5ncmVmc1tpXSwKLQkJCQkJCQkgIDAsIDBVTCk7Ci0JCWtmcmVlKGJ1Zi0+ Z3JlZnMpOwotCX0KLQlrZnJlZShidWYtPmRpcmVjdG9yeSk7Ci0JZnJlZV9wYWdlc19leGFjdChi dWYtPmJ1ZmZlciwgYnVmLT5idWZmZXJfc3opOwotCXhlbl9zbmRfZnJvbnRfc2hidWZfY2xlYXIo YnVmKTsKLX0KLQotLyoKLSAqIG51bWJlciBvZiBncmFudCByZWZlcmVuY2VzIGEgcGFnZSBjYW4g aG9sZCB3aXRoIHJlc3BlY3QgdG8gdGhlCi0gKiB4ZW5zbmRfcGFnZV9kaXJlY3RvcnkgaGVhZGVy Ci0gKi8KLSNkZWZpbmUgWEVOU05EX05VTV9HUkVGU19QRVJfUEFHRSAoKFhFTl9QQUdFX1NJWkUg LSBcCi0JCW9mZnNldG9mKHN0cnVjdCB4ZW5zbmRfcGFnZV9kaXJlY3RvcnksIGdyZWYpKSAvIFwK LQkJc2l6ZW9mKGdyYW50X3JlZl90KSkKLQotc3RhdGljIHZvaWQgZmlsbF9wYWdlX2RpcihzdHJ1 Y3QgeGVuX3NuZF9mcm9udF9zaGJ1ZiAqYnVmLAotCQkJICBpbnQgbnVtX3BhZ2VzX2RpcikKLXsK LQlzdHJ1Y3QgeGVuc25kX3BhZ2VfZGlyZWN0b3J5ICpwYWdlX2RpcjsKLQl1bnNpZ25lZCBjaGFy ICpwdHI7Ci0JaW50IGksIGN1cl9ncmVmLCBncmVmc19sZWZ0LCB0b19jb3B5OwotCi0JcHRyID0g YnVmLT5kaXJlY3Rvcnk7Ci0JZ3JlZnNfbGVmdCA9IGJ1Zi0+bnVtX2dyZWZzIC0gbnVtX3BhZ2Vz X2RpcjsKLQkvKgotCSAqIHNraXAgZ3JhbnQgcmVmZXJlbmNlcyBhdCB0aGUgYmVnaW5uaW5nLCB0 aGV5IGFyZSBmb3IgcGFnZXMgZ3JhbnRlZAotCSAqIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgaXRz ZWxmCi0JICovCi0JY3VyX2dyZWYgPSBudW1fcGFnZXNfZGlyOwotCWZvciAoaSA9IDA7IGkgPCBu dW1fcGFnZXNfZGlyOyBpKyspIHsKLQkJcGFnZV9kaXIgPSAoc3RydWN0IHhlbnNuZF9wYWdlX2Rp cmVjdG9yeSAqKXB0cjsKLQkJaWYgKGdyZWZzX2xlZnQgPD0gWEVOU05EX05VTV9HUkVGU19QRVJf UEFHRSkgewotCQkJdG9fY29weSA9IGdyZWZzX2xlZnQ7Ci0JCQlwYWdlX2Rpci0+Z3JlZl9kaXJf bmV4dF9wYWdlID0gR1JBTlRfSU5WQUxJRF9SRUY7Ci0JCX0gZWxzZSB7Ci0JCQl0b19jb3B5ID0g WEVOU05EX05VTV9HUkVGU19QRVJfUEFHRTsKLQkJCXBhZ2VfZGlyLT5ncmVmX2Rpcl9uZXh0X3Bh Z2UgPSBidWYtPmdyZWZzW2kgKyAxXTsKLQkJfQotCi0JCW1lbWNweSgmcGFnZV9kaXItPmdyZWYs ICZidWYtPmdyZWZzW2N1cl9ncmVmXSwKLQkJICAgICAgIHRvX2NvcHkgKiBzaXplb2YoZ3JhbnRf cmVmX3QpKTsKLQotCQlwdHIgKz0gWEVOX1BBR0VfU0laRTsKLQkJZ3JlZnNfbGVmdCAtPSB0b19j b3B5OwotCQljdXJfZ3JlZiArPSB0b19jb3B5OwotCX0KLX0KLQotc3RhdGljIGludCBncmFudF9y ZWZlcmVuY2VzKHN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYsCi0JCQkgICAgc3RydWN0IHhl bl9zbmRfZnJvbnRfc2hidWYgKmJ1ZiwKLQkJCSAgICBpbnQgbnVtX3BhZ2VzX2RpciwgaW50IG51 bV9wYWdlc19idWZmZXIsCi0JCQkgICAgaW50IG51bV9ncmVmcykKLXsKLQlncmFudF9yZWZfdCBw cml2X2dyZWZfaGVhZDsKLQl1bnNpZ25lZCBsb25nIGZyYW1lOwotCWludCByZXQsIGksIGosIGN1 cl9yZWY7Ci0JaW50IG90aGVyZW5kX2lkOwotCi0JcmV0ID0gZ250dGFiX2FsbG9jX2dyYW50X3Jl ZmVyZW5jZXMobnVtX2dyZWZzLCAmcHJpdl9ncmVmX2hlYWQpOwotCWlmIChyZXQpCi0JCXJldHVy biByZXQ7Ci0KLQlidWYtPm51bV9ncmVmcyA9IG51bV9ncmVmczsKLQlvdGhlcmVuZF9pZCA9IHhi X2Rldi0+b3RoZXJlbmRfaWQ7Ci0JaiA9IDA7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgbnVtX3BhZ2Vz X2RpcjsgaSsrKSB7Ci0JCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1fZ3JhbnRfcmVmZXJlbmNlKCZw cml2X2dyZWZfaGVhZCk7Ci0JCWlmIChjdXJfcmVmIDwgMCkgewotCQkJcmV0ID0gY3VyX3JlZjsK LQkJCWdvdG8gZmFpbDsKLQkJfQotCi0JCWZyYW1lID0geGVuX3BhZ2VfdG9fZ2ZuKHZpcnRfdG9f cGFnZShidWYtPmRpcmVjdG9yeSArCi0JCQkJCQkgICAgIFhFTl9QQUdFX1NJWkUgKiBpKSk7Ci0J CWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoY3VyX3JlZiwgb3RoZXJlbmRfaWQsIGZy YW1lLCAwKTsKLQkJYnVmLT5ncmVmc1tqKytdID0gY3VyX3JlZjsKLQl9Ci0KLQlmb3IgKGkgPSAw OyBpIDwgbnVtX3BhZ2VzX2J1ZmZlcjsgaSsrKSB7Ci0JCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1f Z3JhbnRfcmVmZXJlbmNlKCZwcml2X2dyZWZfaGVhZCk7Ci0JCWlmIChjdXJfcmVmIDwgMCkgewot CQkJcmV0ID0gY3VyX3JlZjsKLQkJCWdvdG8gZmFpbDsKLQkJfQotCi0JCWZyYW1lID0geGVuX3Bh Z2VfdG9fZ2ZuKHZpcnRfdG9fcGFnZShidWYtPmJ1ZmZlciArCi0JCQkJCQkgICAgIFhFTl9QQUdF X1NJWkUgKiBpKSk7Ci0JCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoY3VyX3JlZiwg b3RoZXJlbmRfaWQsIGZyYW1lLCAwKTsKLQkJYnVmLT5ncmVmc1tqKytdID0gY3VyX3JlZjsKLQl9 Ci0KLQlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVuY2VzKHByaXZfZ3JlZl9oZWFkKTsKLQlmaWxs X3BhZ2VfZGlyKGJ1ZiwgbnVtX3BhZ2VzX2Rpcik7Ci0JcmV0dXJuIDA7Ci0KLWZhaWw6Ci0JZ250 dGFiX2ZyZWVfZ3JhbnRfcmVmZXJlbmNlcyhwcml2X2dyZWZfaGVhZCk7Ci0JcmV0dXJuIHJldDsK LX0KLQotc3RhdGljIGludCBhbGxvY19pbnRfYnVmZmVycyhzdHJ1Y3QgeGVuX3NuZF9mcm9udF9z aGJ1ZiAqYnVmLAotCQkJICAgICBpbnQgbnVtX3BhZ2VzX2RpciwgaW50IG51bV9wYWdlc19idWZm ZXIsCi0JCQkgICAgIGludCBudW1fZ3JlZnMpCi17Ci0JYnVmLT5ncmVmcyA9IGtjYWxsb2MobnVt X2dyZWZzLCBzaXplb2YoKmJ1Zi0+Z3JlZnMpLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWJ1Zi0+Z3Jl ZnMpCi0JCXJldHVybiAtRU5PTUVNOwotCi0JYnVmLT5kaXJlY3RvcnkgPSBrY2FsbG9jKG51bV9w YWdlc19kaXIsIFhFTl9QQUdFX1NJWkUsIEdGUF9LRVJORUwpOwotCWlmICghYnVmLT5kaXJlY3Rv cnkpCi0JCWdvdG8gZmFpbDsKLQotCWJ1Zi0+YnVmZmVyX3N6ID0gbnVtX3BhZ2VzX2J1ZmZlciAq IFhFTl9QQUdFX1NJWkU7Ci0JYnVmLT5idWZmZXIgPSBhbGxvY19wYWdlc19leGFjdChidWYtPmJ1 ZmZlcl9zeiwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFidWYtPmJ1ZmZlcikKLQkJZ290byBmYWlsOwot Ci0JcmV0dXJuIDA7Ci0KLWZhaWw6Ci0Ja2ZyZWUoYnVmLT5ncmVmcyk7Ci0JYnVmLT5ncmVmcyA9 IE5VTEw7Ci0Ja2ZyZWUoYnVmLT5kaXJlY3RvcnkpOwotCWJ1Zi0+ZGlyZWN0b3J5ID0gTlVMTDsK LQlyZXR1cm4gLUVOT01FTTsKLX0KLQotaW50IHhlbl9zbmRfZnJvbnRfc2hidWZfYWxsb2Moc3Ry dWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldiwKLQkJCSAgICAgIHN0cnVjdCB4ZW5fc25kX2Zyb250 X3NoYnVmICpidWYsCi0JCQkgICAgICB1bnNpZ25lZCBpbnQgYnVmZmVyX3N6KQotewotCWludCBu dW1fcGFnZXNfYnVmZmVyLCBudW1fcGFnZXNfZGlyLCBudW1fZ3JlZnM7Ci0JaW50IHJldDsKLQot CXhlbl9zbmRfZnJvbnRfc2hidWZfY2xlYXIoYnVmKTsKLQotCW51bV9wYWdlc19idWZmZXIgPSBE SVZfUk9VTkRfVVAoYnVmZmVyX3N6LCBYRU5fUEFHRV9TSVpFKTsKLQkvKiBudW1iZXIgb2YgcGFn ZXMgdGhlIHBhZ2UgZGlyZWN0b3J5IGNvbnN1bWVzIGl0c2VsZiAqLwotCW51bV9wYWdlc19kaXIg PSBESVZfUk9VTkRfVVAobnVtX3BhZ2VzX2J1ZmZlciwKLQkJCQkgICAgIFhFTlNORF9OVU1fR1JF RlNfUEVSX1BBR0UpOwotCW51bV9ncmVmcyA9IG51bV9wYWdlc19idWZmZXIgKyBudW1fcGFnZXNf ZGlyOwotCi0JcmV0ID0gYWxsb2NfaW50X2J1ZmZlcnMoYnVmLCBudW1fcGFnZXNfZGlyLAotCQkJ CW51bV9wYWdlc19idWZmZXIsIG51bV9ncmVmcyk7Ci0JaWYgKHJldCA8IDApCi0JCXJldHVybiBy ZXQ7Ci0KLQlyZXQgPSBncmFudF9yZWZlcmVuY2VzKHhiX2RldiwgYnVmLCBudW1fcGFnZXNfZGly LCBudW1fcGFnZXNfYnVmZmVyLAotCQkJICAgICAgIG51bV9ncmVmcyk7Ci0JaWYgKHJldCA8IDAp Ci0JCXJldHVybiByZXQ7Ci0KLQlmaWxsX3BhZ2VfZGlyKGJ1ZiwgbnVtX3BhZ2VzX2Rpcik7Ci0J cmV0dXJuIDA7Ci19CmRpZmYgLS1naXQgYS9zb3VuZC94ZW4veGVuX3NuZF9mcm9udF9zaGJ1Zi5o IGIvc291bmQveGVuL3hlbl9zbmRfZnJvbnRfc2hidWYuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggZDI4ZTk3YzQ3YjJjLi4wMDAwMDAwMDAwMDAKLS0tIGEvc291bmQveGVuL3hlbl9z bmRfZnJvbnRfc2hidWYuaAorKysgL2Rldi9udWxsCkBAIC0xLDM2ICswLDAgQEAKLS8qIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLwotCi0vKgotICogWGVuIHBhcmEt dmlydHVhbCBzb3VuZCBkZXZpY2UKLSAqCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFN IFN5c3RlbXMgSW5jLgotICoKLSAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9s ZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgotICovCi0KLSNpZm5kZWYgX19YRU5fU05E X0ZST05UX1NIQlVGX0gKLSNkZWZpbmUgX19YRU5fU05EX0ZST05UX1NIQlVGX0gKLQotI2luY2x1 ZGUgPHhlbi9ncmFudF90YWJsZS5oPgotCi0jaW5jbHVkZSAieGVuX3NuZF9mcm9udF9ldnRjaG5s LmgiCi0KLXN0cnVjdCB4ZW5fc25kX2Zyb250X3NoYnVmIHsKLQlpbnQgbnVtX2dyZWZzOwotCWdy YW50X3JlZl90ICpncmVmczsKLQl1OCAqZGlyZWN0b3J5OwotCXU4ICpidWZmZXI7Ci0Jc2l6ZV90 IGJ1ZmZlcl9zejsKLX07Ci0KLWdyYW50X3JlZl90IHhlbl9zbmRfZnJvbnRfc2hidWZfZ2V0X2Rp cl9zdGFydChzdHJ1Y3QgeGVuX3NuZF9mcm9udF9zaGJ1ZiAqYnVmKTsKLQotaW50IHhlbl9zbmRf ZnJvbnRfc2hidWZfYWxsb2Moc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldiwKLQkJCSAgICAg IHN0cnVjdCB4ZW5fc25kX2Zyb250X3NoYnVmICpidWYsCi0JCQkgICAgICB1bnNpZ25lZCBpbnQg YnVmZmVyX3N6KTsKLQotdm9pZCB4ZW5fc25kX2Zyb250X3NoYnVmX2NsZWFyKHN0cnVjdCB4ZW5f c25kX2Zyb250X3NoYnVmICpidWYpOwotCi12b2lkIHhlbl9zbmRfZnJvbnRfc2hidWZfZnJlZShz dHJ1Y3QgeGVuX3NuZF9mcm9udF9zaGJ1ZiAqYnVmKTsKLQotI2VuZGlmIC8qIF9fWEVOX1NORF9G Uk9OVF9TSEJVRl9IICovCi0tIAoyLjE5LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E0B2BC43610 for ; Thu, 22 Nov 2018 10:02:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8C15E20831 for ; Thu, 22 Nov 2018 10:02:47 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="aOTMC282" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8C15E20831 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2393680AbeKVUla (ORCPT ); Thu, 22 Nov 2018 15:41:30 -0500 Received: from mail-lj1-f196.google.com ([209.85.208.196]:33971 "EHLO mail-lj1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387721AbeKVUl3 (ORCPT ); Thu, 22 Nov 2018 15:41:29 -0500 Received: by mail-lj1-f196.google.com with SMTP id u6-v6so7452824ljd.1 for ; Thu, 22 Nov 2018 02:02:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=dRQ1Sf8pPkvYF49fBUyyUb4KpUjCpxuckPEMO2XA0zo=; b=aOTMC282DdY/TXt3G6YWZ3YK6xuSt7vlBPHk0gb2JVATdjp4xDWH7opniGwzwgZw+h bwIITjCbLbedleydWABytDSU4UOl8upZ/E1/lGKmz9HiOBZLTolqZqzo6lMvgbZp3yoI 5ZQLTF0CKAgLjzz7/AtbAcvquSihmHLOENw+dZKSanZOZ4kiEE/wu5tiaoLEKl+qnVRB wspJQZwUNstWVCyW+2n7ztQDObgIkPUJh9TMdYRjpVPpu/v5CiofjQxkXmdGHfE8Yio9 ZQaRUmMJUgy5CNp3YYy27nAMOECzoHCYBbFOlV4srb7S4jphgpOfjtLhq2aJ4lQN2Kdo 8V/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=dRQ1Sf8pPkvYF49fBUyyUb4KpUjCpxuckPEMO2XA0zo=; b=ZsYiK60oyVeAyLfbV0gPcWxGFi8MIWVHv3d1a9D4Rigk0pLvMVmXn0zmGxUDszwomj ohFY9ow224etSE+rfjonDZdxp86f9mKppSoQY8WtX9seF47NXJAEUekjZTofnMSH3PTn EiAgfiAHaXJXHmJpQREHAgnBYMuekAx3f65HMgyUEIXBx53Z3B6sL8qqpnNF1V9H5rZX 8kjHjwIdB8quoU/I0HvyEskjqGPUgV6EmTMN/zT9F9J8rRhHNVOUUcCxrTInZzwq4/d4 QxKJHUURe502Ogq9JiGb/XtsTgJN65Iu44PE9rkxFszONKl8p8mT2WGQUHpzuy7xOqja vqEQ== X-Gm-Message-State: AA+aEWb4SF3QNvKTs2hrjWpv5aMLSLowu+0AMx/p87ia9k4x2jolQXp6 u4V+V7/ScpFXmhBckrTMmDo= X-Google-Smtp-Source: AFSGD/WZaMm4ia7nPskbJMxC616zQiNClDHAEjSFPFuG1P/FgCHq/xmy4u6RPYMPtgqX3nCJC27iug== X-Received: by 2002:a2e:4503:: with SMTP id s3-v6mr4635765lja.44.1542880960252; Thu, 22 Nov 2018 02:02:40 -0800 (PST) Received: from a2k-HP-ProDesk-600-G2-SFF.kyiv.epam.com (ll-22.209.223.85.sovam.net.ua. [85.223.209.22]) by smtp.gmail.com with ESMTPSA id v19sm2043421lfe.69.2018.11.22.02.02.38 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 22 Nov 2018 02:02:39 -0800 (PST) From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, alsa-devel@alsa-project.org, jgross@suse.com, boris.ostrovsky@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko Subject: [Xen-devel][PATCH 3/3] ALSA: xen-front: Use Xen common shared buffer implementation Date: Thu, 22 Nov 2018 12:02:30 +0200 Message-Id: <20181122100230.14976-3-andr2000@gmail.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20181122100230.14976-1-andr2000@gmail.com> References: <20181122100230.14976-1-andr2000@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Use page directory based shared buffer implementation now available as common code for Xen frontend drivers. Signed-off-by: Oleksandr Andrushchenko --- sound/xen/Kconfig | 1 + sound/xen/Makefile | 1 - sound/xen/xen_snd_front.c | 7 +- sound/xen/xen_snd_front.h | 4 +- sound/xen/xen_snd_front_alsa.c | 101 +++++++++++++---- sound/xen/xen_snd_front_shbuf.c | 194 -------------------------------- sound/xen/xen_snd_front_shbuf.h | 36 ------ 7 files changed, 83 insertions(+), 261 deletions(-) delete mode 100644 sound/xen/xen_snd_front_shbuf.c delete mode 100644 sound/xen/xen_snd_front_shbuf.h diff --git a/sound/xen/Kconfig b/sound/xen/Kconfig index 4f1fceea82d2..e4d7beb4df1c 100644 --- a/sound/xen/Kconfig +++ b/sound/xen/Kconfig @@ -5,6 +5,7 @@ config SND_XEN_FRONTEND depends on XEN select SND_PCM select XEN_XENBUS_FRONTEND + select XEN_FRONT_PGDIR_SHBUF help Choose this option if you want to enable a para-virtualized frontend sound driver for Xen guest OSes. diff --git a/sound/xen/Makefile b/sound/xen/Makefile index 1e6470ecc2f2..24031775b715 100644 --- a/sound/xen/Makefile +++ b/sound/xen/Makefile @@ -3,7 +3,6 @@ snd_xen_front-objs := xen_snd_front.o \ xen_snd_front_cfg.o \ xen_snd_front_evtchnl.o \ - xen_snd_front_shbuf.o \ xen_snd_front_alsa.o obj-$(CONFIG_SND_XEN_FRONTEND) += snd_xen_front.o diff --git a/sound/xen/xen_snd_front.c b/sound/xen/xen_snd_front.c index b089b13b5160..a9e5c2cd7698 100644 --- a/sound/xen/xen_snd_front.c +++ b/sound/xen/xen_snd_front.c @@ -16,12 +16,12 @@ #include #include +#include #include #include "xen_snd_front.h" #include "xen_snd_front_alsa.h" #include "xen_snd_front_evtchnl.h" -#include "xen_snd_front_shbuf.h" static struct xensnd_req * be_stream_prepare_req(struct xen_snd_front_evtchnl *evtchnl, u8 operation) @@ -82,7 +82,7 @@ int xen_snd_front_stream_query_hw_param(struct xen_snd_front_evtchnl *evtchnl, } int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl, - struct xen_snd_front_shbuf *sh_buf, + struct xen_front_pgdir_shbuf *shbuf, u8 format, unsigned int channels, unsigned int rate, u32 buffer_sz, u32 period_sz) @@ -99,7 +99,8 @@ int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl, req->op.open.pcm_rate = rate; req->op.open.buffer_sz = buffer_sz; req->op.open.period_sz = period_sz; - req->op.open.gref_directory = xen_snd_front_shbuf_get_dir_start(sh_buf); + req->op.open.gref_directory = + xen_front_pgdir_shbuf_get_dir_start(shbuf); mutex_unlock(&evtchnl->ring_io_lock); ret = be_stream_do_io(evtchnl); diff --git a/sound/xen/xen_snd_front.h b/sound/xen/xen_snd_front.h index a2ea2463bcc5..05611f113b94 100644 --- a/sound/xen/xen_snd_front.h +++ b/sound/xen/xen_snd_front.h @@ -16,7 +16,7 @@ struct xen_snd_front_card_info; struct xen_snd_front_evtchnl; struct xen_snd_front_evtchnl_pair; -struct xen_snd_front_shbuf; +struct xen_front_pgdir_shbuf; struct xensnd_query_hw_param; struct xen_snd_front_info { @@ -35,7 +35,7 @@ int xen_snd_front_stream_query_hw_param(struct xen_snd_front_evtchnl *evtchnl, struct xensnd_query_hw_param *hw_param_resp); int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl, - struct xen_snd_front_shbuf *sh_buf, + struct xen_front_pgdir_shbuf *shbuf, u8 format, unsigned int channels, unsigned int rate, u32 buffer_sz, u32 period_sz); diff --git a/sound/xen/xen_snd_front_alsa.c b/sound/xen/xen_snd_front_alsa.c index 129180e17db1..5b874a7014e0 100644 --- a/sound/xen/xen_snd_front_alsa.c +++ b/sound/xen/xen_snd_front_alsa.c @@ -15,17 +15,24 @@ #include #include +#include #include "xen_snd_front.h" #include "xen_snd_front_alsa.h" #include "xen_snd_front_cfg.h" #include "xen_snd_front_evtchnl.h" -#include "xen_snd_front_shbuf.h" struct xen_snd_front_pcm_stream_info { struct xen_snd_front_info *front_info; struct xen_snd_front_evtchnl_pair *evt_pair; - struct xen_snd_front_shbuf sh_buf; + + /* This is the shared buffer with its backing storage. */ + struct xen_front_pgdir_shbuf shbuf; + u8 *buffer; + size_t buffer_sz; + int num_pages; + struct page **pages; + int index; bool is_open; @@ -214,12 +221,19 @@ static void stream_clear(struct xen_snd_front_pcm_stream_info *stream) stream->out_frames = 0; atomic_set(&stream->hw_ptr, 0); xen_snd_front_evtchnl_pair_clear(stream->evt_pair); - xen_snd_front_shbuf_clear(&stream->sh_buf); + memset(&stream->shbuf, 0, sizeof(stream->shbuf)); + stream->buffer = NULL; + stream->buffer_sz = 0; + stream->pages = NULL; + stream->num_pages = 0; } static void stream_free(struct xen_snd_front_pcm_stream_info *stream) { - xen_snd_front_shbuf_free(&stream->sh_buf); + xen_front_pgdir_shbuf_unmap(&stream->shbuf); + xen_front_pgdir_shbuf_free(&stream->shbuf); + free_pages_exact(stream->buffer, stream->buffer_sz); + kfree(stream->pages); stream_clear(stream); } @@ -421,10 +435,34 @@ static int alsa_close(struct snd_pcm_substream *substream) return 0; } +static int shbuf_setup_backstore(struct xen_snd_front_pcm_stream_info *stream, + size_t buffer_sz) +{ + int i; + + stream->buffer_sz = buffer_sz; + stream->buffer = alloc_pages_exact(stream->buffer_sz, GFP_KERNEL); + if (!stream->buffer) + return -ENOMEM; + + stream->num_pages = DIV_ROUND_UP(stream->buffer_sz, PAGE_SIZE); + stream->pages = kcalloc(stream->num_pages, sizeof(struct page *), + GFP_KERNEL); + if (!stream->pages) + return -ENOMEM; + + for (i = 0; i < stream->num_pages; i++) + stream->pages[i] = virt_to_page(stream->buffer + i * PAGE_SIZE); + + return 0; +} + static int alsa_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct xen_snd_front_pcm_stream_info *stream = stream_get(substream); + struct xen_snd_front_info *front_info = stream->front_info; + struct xen_front_pgdir_shbuf_cfg buf_cfg; int ret; /* @@ -432,19 +470,32 @@ static int alsa_hw_params(struct snd_pcm_substream *substream, * so free the previously allocated shared buffer if any. */ stream_free(stream); + ret = shbuf_setup_backstore(stream, params_buffer_bytes(params)); + if (ret < 0) + goto fail; - ret = xen_snd_front_shbuf_alloc(stream->front_info->xb_dev, - &stream->sh_buf, - params_buffer_bytes(params)); - if (ret < 0) { - stream_free(stream); - dev_err(&stream->front_info->xb_dev->dev, - "Failed to allocate buffers for stream with index %d\n", - stream->index); - return ret; - } + memset(&buf_cfg, 0, sizeof(buf_cfg)); + buf_cfg.xb_dev = front_info->xb_dev; + buf_cfg.pgdir = &stream->shbuf; + buf_cfg.num_pages = stream->num_pages; + buf_cfg.pages = stream->pages; + + ret = xen_front_pgdir_shbuf_alloc(&buf_cfg); + if (ret < 0) + goto fail; + + ret = xen_front_pgdir_shbuf_map(&stream->shbuf); + if (ret < 0) + goto fail; return 0; + +fail: + stream_free(stream); + dev_err(&front_info->xb_dev->dev, + "Failed to allocate buffers for stream with index %d\n", + stream->index); + return ret; } static int alsa_hw_free(struct snd_pcm_substream *substream) @@ -476,7 +527,7 @@ static int alsa_prepare(struct snd_pcm_substream *substream) sndif_format = ret; ret = xen_snd_front_stream_prepare(&stream->evt_pair->req, - &stream->sh_buf, + &stream->shbuf, sndif_format, runtime->channels, runtime->rate, @@ -556,10 +607,10 @@ static int alsa_pb_copy_user(struct snd_pcm_substream *substream, { struct xen_snd_front_pcm_stream_info *stream = stream_get(substream); - if (unlikely(pos + count > stream->sh_buf.buffer_sz)) + if (unlikely(pos + count > stream->buffer_sz)) return -EINVAL; - if (copy_from_user(stream->sh_buf.buffer + pos, src, count)) + if (copy_from_user(stream->buffer + pos, src, count)) return -EFAULT; return xen_snd_front_stream_write(&stream->evt_pair->req, pos, count); @@ -571,10 +622,10 @@ static int alsa_pb_copy_kernel(struct snd_pcm_substream *substream, { struct xen_snd_front_pcm_stream_info *stream = stream_get(substream); - if (unlikely(pos + count > stream->sh_buf.buffer_sz)) + if (unlikely(pos + count > stream->buffer_sz)) return -EINVAL; - memcpy(stream->sh_buf.buffer + pos, src, count); + memcpy(stream->buffer + pos, src, count); return xen_snd_front_stream_write(&stream->evt_pair->req, pos, count); } @@ -586,14 +637,14 @@ static int alsa_cap_copy_user(struct snd_pcm_substream *substream, struct xen_snd_front_pcm_stream_info *stream = stream_get(substream); int ret; - if (unlikely(pos + count > stream->sh_buf.buffer_sz)) + if (unlikely(pos + count > stream->buffer_sz)) return -EINVAL; ret = xen_snd_front_stream_read(&stream->evt_pair->req, pos, count); if (ret < 0) return ret; - return copy_to_user(dst, stream->sh_buf.buffer + pos, count) ? + return copy_to_user(dst, stream->buffer + pos, count) ? -EFAULT : 0; } @@ -604,14 +655,14 @@ static int alsa_cap_copy_kernel(struct snd_pcm_substream *substream, struct xen_snd_front_pcm_stream_info *stream = stream_get(substream); int ret; - if (unlikely(pos + count > stream->sh_buf.buffer_sz)) + if (unlikely(pos + count > stream->buffer_sz)) return -EINVAL; ret = xen_snd_front_stream_read(&stream->evt_pair->req, pos, count); if (ret < 0) return ret; - memcpy(dst, stream->sh_buf.buffer + pos, count); + memcpy(dst, stream->buffer + pos, count); return 0; } @@ -622,10 +673,10 @@ static int alsa_pb_fill_silence(struct snd_pcm_substream *substream, { struct xen_snd_front_pcm_stream_info *stream = stream_get(substream); - if (unlikely(pos + count > stream->sh_buf.buffer_sz)) + if (unlikely(pos + count > stream->buffer_sz)) return -EINVAL; - memset(stream->sh_buf.buffer + pos, 0, count); + memset(stream->buffer + pos, 0, count); return xen_snd_front_stream_write(&stream->evt_pair->req, pos, count); } diff --git a/sound/xen/xen_snd_front_shbuf.c b/sound/xen/xen_snd_front_shbuf.c deleted file mode 100644 index 07ac176a41ba..000000000000 --- a/sound/xen/xen_snd_front_shbuf.c +++ /dev/null @@ -1,194 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 OR MIT - -/* - * Xen para-virtual sound device - * - * Copyright (C) 2016-2018 EPAM Systems Inc. - * - * Author: Oleksandr Andrushchenko - */ - -#include -#include -#include - -#include "xen_snd_front_shbuf.h" - -grant_ref_t xen_snd_front_shbuf_get_dir_start(struct xen_snd_front_shbuf *buf) -{ - if (!buf->grefs) - return GRANT_INVALID_REF; - - return buf->grefs[0]; -} - -void xen_snd_front_shbuf_clear(struct xen_snd_front_shbuf *buf) -{ - memset(buf, 0, sizeof(*buf)); -} - -void xen_snd_front_shbuf_free(struct xen_snd_front_shbuf *buf) -{ - int i; - - if (buf->grefs) { - for (i = 0; i < buf->num_grefs; i++) - if (buf->grefs[i] != GRANT_INVALID_REF) - gnttab_end_foreign_access(buf->grefs[i], - 0, 0UL); - kfree(buf->grefs); - } - kfree(buf->directory); - free_pages_exact(buf->buffer, buf->buffer_sz); - xen_snd_front_shbuf_clear(buf); -} - -/* - * number of grant references a page can hold with respect to the - * xensnd_page_directory header - */ -#define XENSND_NUM_GREFS_PER_PAGE ((XEN_PAGE_SIZE - \ - offsetof(struct xensnd_page_directory, gref)) / \ - sizeof(grant_ref_t)) - -static void fill_page_dir(struct xen_snd_front_shbuf *buf, - int num_pages_dir) -{ - struct xensnd_page_directory *page_dir; - unsigned char *ptr; - int i, cur_gref, grefs_left, to_copy; - - ptr = buf->directory; - grefs_left = buf->num_grefs - num_pages_dir; - /* - * skip grant references at the beginning, they are for pages granted - * for the page directory itself - */ - cur_gref = num_pages_dir; - for (i = 0; i < num_pages_dir; i++) { - page_dir = (struct xensnd_page_directory *)ptr; - if (grefs_left <= XENSND_NUM_GREFS_PER_PAGE) { - to_copy = grefs_left; - page_dir->gref_dir_next_page = GRANT_INVALID_REF; - } else { - to_copy = XENSND_NUM_GREFS_PER_PAGE; - page_dir->gref_dir_next_page = buf->grefs[i + 1]; - } - - memcpy(&page_dir->gref, &buf->grefs[cur_gref], - to_copy * sizeof(grant_ref_t)); - - ptr += XEN_PAGE_SIZE; - grefs_left -= to_copy; - cur_gref += to_copy; - } -} - -static int grant_references(struct xenbus_device *xb_dev, - struct xen_snd_front_shbuf *buf, - int num_pages_dir, int num_pages_buffer, - int num_grefs) -{ - grant_ref_t priv_gref_head; - unsigned long frame; - int ret, i, j, cur_ref; - int otherend_id; - - ret = gnttab_alloc_grant_references(num_grefs, &priv_gref_head); - if (ret) - return ret; - - buf->num_grefs = num_grefs; - otherend_id = xb_dev->otherend_id; - j = 0; - - for (i = 0; i < num_pages_dir; i++) { - cur_ref = gnttab_claim_grant_reference(&priv_gref_head); - if (cur_ref < 0) { - ret = cur_ref; - goto fail; - } - - frame = xen_page_to_gfn(virt_to_page(buf->directory + - XEN_PAGE_SIZE * i)); - gnttab_grant_foreign_access_ref(cur_ref, otherend_id, frame, 0); - buf->grefs[j++] = cur_ref; - } - - for (i = 0; i < num_pages_buffer; i++) { - cur_ref = gnttab_claim_grant_reference(&priv_gref_head); - if (cur_ref < 0) { - ret = cur_ref; - goto fail; - } - - frame = xen_page_to_gfn(virt_to_page(buf->buffer + - XEN_PAGE_SIZE * i)); - gnttab_grant_foreign_access_ref(cur_ref, otherend_id, frame, 0); - buf->grefs[j++] = cur_ref; - } - - gnttab_free_grant_references(priv_gref_head); - fill_page_dir(buf, num_pages_dir); - return 0; - -fail: - gnttab_free_grant_references(priv_gref_head); - return ret; -} - -static int alloc_int_buffers(struct xen_snd_front_shbuf *buf, - int num_pages_dir, int num_pages_buffer, - int num_grefs) -{ - buf->grefs = kcalloc(num_grefs, sizeof(*buf->grefs), GFP_KERNEL); - if (!buf->grefs) - return -ENOMEM; - - buf->directory = kcalloc(num_pages_dir, XEN_PAGE_SIZE, GFP_KERNEL); - if (!buf->directory) - goto fail; - - buf->buffer_sz = num_pages_buffer * XEN_PAGE_SIZE; - buf->buffer = alloc_pages_exact(buf->buffer_sz, GFP_KERNEL); - if (!buf->buffer) - goto fail; - - return 0; - -fail: - kfree(buf->grefs); - buf->grefs = NULL; - kfree(buf->directory); - buf->directory = NULL; - return -ENOMEM; -} - -int xen_snd_front_shbuf_alloc(struct xenbus_device *xb_dev, - struct xen_snd_front_shbuf *buf, - unsigned int buffer_sz) -{ - int num_pages_buffer, num_pages_dir, num_grefs; - int ret; - - xen_snd_front_shbuf_clear(buf); - - num_pages_buffer = DIV_ROUND_UP(buffer_sz, XEN_PAGE_SIZE); - /* number of pages the page directory consumes itself */ - num_pages_dir = DIV_ROUND_UP(num_pages_buffer, - XENSND_NUM_GREFS_PER_PAGE); - num_grefs = num_pages_buffer + num_pages_dir; - - ret = alloc_int_buffers(buf, num_pages_dir, - num_pages_buffer, num_grefs); - if (ret < 0) - return ret; - - ret = grant_references(xb_dev, buf, num_pages_dir, num_pages_buffer, - num_grefs); - if (ret < 0) - return ret; - - fill_page_dir(buf, num_pages_dir); - return 0; -} diff --git a/sound/xen/xen_snd_front_shbuf.h b/sound/xen/xen_snd_front_shbuf.h deleted file mode 100644 index d28e97c47b2c..000000000000 --- a/sound/xen/xen_snd_front_shbuf.h +++ /dev/null @@ -1,36 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 OR MIT */ - -/* - * Xen para-virtual sound device - * - * Copyright (C) 2016-2018 EPAM Systems Inc. - * - * Author: Oleksandr Andrushchenko - */ - -#ifndef __XEN_SND_FRONT_SHBUF_H -#define __XEN_SND_FRONT_SHBUF_H - -#include - -#include "xen_snd_front_evtchnl.h" - -struct xen_snd_front_shbuf { - int num_grefs; - grant_ref_t *grefs; - u8 *directory; - u8 *buffer; - size_t buffer_sz; -}; - -grant_ref_t xen_snd_front_shbuf_get_dir_start(struct xen_snd_front_shbuf *buf); - -int xen_snd_front_shbuf_alloc(struct xenbus_device *xb_dev, - struct xen_snd_front_shbuf *buf, - unsigned int buffer_sz); - -void xen_snd_front_shbuf_clear(struct xen_snd_front_shbuf *buf); - -void xen_snd_front_shbuf_free(struct xen_snd_front_shbuf *buf); - -#endif /* __XEN_SND_FRONT_SHBUF_H */ -- 2.19.1