From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville Syrjala Subject: [PATCH 02/18] video/hdmi: Pass buffer size to infoframe unpack functions Date: Thu, 20 Sep 2018 21:51:29 +0300 Message-ID: <20180920185145.1912-3-ville.syrjala@linux.intel.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180920185145.1912-1-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Hans Verkuil , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KClRv IG1ha2Ugc3VyZSB0aGUgaW5mb2ZyYW1lIHVucGFjayBmdW5jdGlvbnMgZG9uJ3QgZW5kIHVwIGV4 YW1pbmluZwpzdGFjayBnYXJiYWdlIG9yIG9vcHNpbmcsIGxldCdzIHBhc3MgaW4gdGhlIHNpemUg b2YgdGhlIGJ1ZmZlci4KCnYyOiBDb252ZXJ0IHRkYTE5OTd4LmMgYXMgd2VsbCAoa2J1aWxkIHRl c3Qgcm9ib3QpCgpDYzogVGhpZXJyeSBSZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNvbT4K Q2M6IEhhbnMgVmVya3VpbCA8aGFucy52ZXJrdWlsQGNpc2NvLmNvbT4KQ2M6IGxpbnV4LW1lZGlh QHZnZXIua2VybmVsLm9yZwpTaWduZWQtb2ZmLWJ5OiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5 cmphbGFAbGludXguaW50ZWwuY29tPgotLS0KIGRyaXZlcnMvbWVkaWEvaTJjL2Fkdjc1MTEuYyAg fCAgMiArLQogZHJpdmVycy9tZWRpYS9pMmMvYWR2NzYwNC5jICB8ICAyICstCiBkcml2ZXJzL21l ZGlhL2kyYy9hZHY3ODQyLmMgIHwgIDIgKy0KIGRyaXZlcnMvbWVkaWEvaTJjL3RjMzU4NzQzLmMg fCAgMiArLQogZHJpdmVycy9tZWRpYS9pMmMvdGRhMTk5N3guYyB8ICA0ICsrLS0KIGRyaXZlcnMv dmlkZW8vaGRtaS5jICAgICAgICAgfCA1MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Ky0tLS0tLS0tLS0tLQogaW5jbHVkZS9saW51eC9oZG1pLmggICAgICAgICB8ICAyICstCiA3IGZp bGVzIGNoYW5nZWQsIDQ0IGluc2VydGlvbnMoKyksIDIxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWVkaWEvaTJjL2Fkdjc1MTEuYyBiL2RyaXZlcnMvbWVkaWEvaTJjL2Fkdjc1 MTEuYwppbmRleCA1NWMyZWEwNzIwZDkuLmI4NWIxODFiYmI2YyAxMDA2NDQKLS0tIGEvZHJpdmVy cy9tZWRpYS9pMmMvYWR2NzUxMS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvaTJjL2Fkdjc1MTEuYwpA QCAtNTUwLDcgKzU1MCw3IEBAIHN0YXRpYyB2b2lkIGxvZ19pbmZvZnJhbWUoc3RydWN0IHY0bDJf c3ViZGV2ICpzZCwgY29uc3Qgc3RydWN0IGFkdjc1MTFfY2ZnX3JlYWRfCiAJYnVmZmVyWzNdID0g MDsKIAlidWZmZXJbM10gPSBoZG1pX2luZm9mcmFtZV9jaGVja3N1bShidWZmZXIsIGxlbiArIDQp OwogCi0JaWYgKGhkbWlfaW5mb2ZyYW1lX3VucGFjaygmZnJhbWUsIGJ1ZmZlcikgPCAwKSB7CisJ aWYgKGhkbWlfaW5mb2ZyYW1lX3VucGFjaygmZnJhbWUsIGJ1ZmZlciwgc2l6ZW9mKGJ1ZmZlcikp IDwgMCkgewogCQl2NGwyX2VycihzZCwgIiVzOiB1bnBhY2sgb2YgJXMgaW5mb2ZyYW1lIGZhaWxl ZFxuIiwgX19mdW5jX18sIGNyaS0+ZGVzYyk7CiAJCXJldHVybjsKIAl9CmRpZmYgLS1naXQgYS9k cml2ZXJzL21lZGlhL2kyYy9hZHY3NjA0LmMgYi9kcml2ZXJzL21lZGlhL2kyYy9hZHY3NjA0LmMK aW5kZXggNjY4YmUyYmNhNTdhLi4yZTdhMjhkYmFkNGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVk aWEvaTJjL2Fkdjc2MDQuYworKysgYi9kcml2ZXJzL21lZGlhL2kyYy9hZHY3NjA0LmMKQEAgLTI0 MTgsNyArMjQxOCw3IEBAIHN0YXRpYyBpbnQgYWR2NzZ4eF9yZWFkX2luZm9mcmFtZShzdHJ1Y3Qg djRsMl9zdWJkZXYgKnNkLCBpbnQgaW5kZXgsCiAJCWJ1ZmZlcltpICsgM10gPSBpbmZvZnJhbWVf cmVhZChzZCwKIAkJCQkgICAgICAgYWR2NzZ4eF9jcmlbaW5kZXhdLnBheWxvYWRfYWRkciArIGkp OwogCi0JaWYgKGhkbWlfaW5mb2ZyYW1lX3VucGFjayhmcmFtZSwgYnVmZmVyKSA8IDApIHsKKwlp ZiAoaGRtaV9pbmZvZnJhbWVfdW5wYWNrKGZyYW1lLCBidWZmZXIsIHNpemVvZihidWZmZXIpKSA8 IDApIHsKIAkJdjRsMl9lcnIoc2QsICIlczogdW5wYWNrIG9mICVzIGluZm9mcmFtZSBmYWlsZWRc biIsIF9fZnVuY19fLAogCQkJIGFkdjc2eHhfY3JpW2luZGV4XS5kZXNjKTsKIAkJcmV0dXJuIC1F Tk9FTlQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2kyYy9hZHY3ODQyLmMgYi9kcml2ZXJz L21lZGlhL2kyYy9hZHY3ODQyLmMKaW5kZXggNGY4ZmJkZDAwZTM1Li4yY2ZkMDNmOTI5YjIgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvaTJjL2Fkdjc4NDIuYworKysgYi9kcml2ZXJzL21lZGlh L2kyYy9hZHY3ODQyLmMKQEAgLTI1NjMsNyArMjU2Myw3IEBAIHN0YXRpYyB2b2lkIGxvZ19pbmZv ZnJhbWUoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgc3RydWN0IGFkdjc4NDJfY2ZnX3JlYWRfaW5m b2ZyCiAJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQogCQlidWZmZXJbaSArIDNdID0gaW5mb2Zy YW1lX3JlYWQoc2QsIGNyaS0+cGF5bG9hZF9hZGRyICsgaSk7CiAKLQlpZiAoaGRtaV9pbmZvZnJh bWVfdW5wYWNrKCZmcmFtZSwgYnVmZmVyKSA8IDApIHsKKwlpZiAoaGRtaV9pbmZvZnJhbWVfdW5w YWNrKCZmcmFtZSwgYnVmZmVyLCBzaXplb2YoYnVmZmVyKSkgPCAwKSB7CiAJCXY0bDJfZXJyKHNk LCAiJXM6IHVucGFjayBvZiAlcyBpbmZvZnJhbWUgZmFpbGVkXG4iLCBfX2Z1bmNfXywgY3JpLT5k ZXNjKTsKIAkJcmV0dXJuOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvaTJjL3RjMzU4 NzQzLmMgYi9kcml2ZXJzL21lZGlhL2kyYy90YzM1ODc0My5jCmluZGV4IDQ0YzQxOTMzNDE1YS4u NTE5YmY5MjUwOGQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2kyYy90YzM1ODc0My5jCisr KyBiL2RyaXZlcnMvbWVkaWEvaTJjL3RjMzU4NzQzLmMKQEAgLTQ0NCw3ICs0NDQsNyBAQCBzdGF0 aWMgdm9pZCBwcmludF9hdmlfaW5mb2ZyYW1lKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QpCiAKIAlp MmNfcmQoc2QsIFBLX0FWSV8wSEVBRCwgYnVmZmVyLCBIRE1JX0lORk9GUkFNRV9TSVpFKEFWSSkp OwogCi0JaWYgKGhkbWlfaW5mb2ZyYW1lX3VucGFjaygmZnJhbWUsIGJ1ZmZlcikgPCAwKSB7CisJ aWYgKGhkbWlfaW5mb2ZyYW1lX3VucGFjaygmZnJhbWUsIGJ1ZmZlciwgc2l6ZW9mKGJ1ZmZlcikp IDwgMCkgewogCQl2NGwyX2VycihzZCwgIiVzOiB1bnBhY2sgb2YgQVZJIGluZm9mcmFtZSBmYWls ZWRcbiIsIF9fZnVuY19fKTsKIAkJcmV0dXJuOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVk aWEvaTJjL3RkYTE5OTd4LmMgYi9kcml2ZXJzL21lZGlhL2kyYy90ZGExOTk3eC5jCmluZGV4IGQx MTRhYzUyNDNlYy4uMTk1YTFmYzc0ZWU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2kyYy90 ZGExOTk3eC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvaTJjL3RkYTE5OTd4LmMKQEAgLTEyNTMsNyAr MTI1Myw3IEBAIHRkYTE5OTd4X3BhcnNlX2luZm9mcmFtZShzdHJ1Y3QgdGRhMTk5N3hfc3RhdGUg KnN0YXRlLCB1MTYgYWRkcikKIAogCS8qIHJlYWQgZGF0YSAqLwogCWxlbiA9IGlvX3JlYWRuKHNk LCBhZGRyLCBzaXplb2YoYnVmZmVyKSwgYnVmZmVyKTsKLQllcnIgPSBoZG1pX2luZm9mcmFtZV91 bnBhY2soJmZyYW1lLCBidWZmZXIpOworCWVyciA9IGhkbWlfaW5mb2ZyYW1lX3VucGFjaygmZnJh bWUsIGJ1ZmZlciwgc2l6ZW9mKGJ1ZmZlcikpOwogCWlmIChlcnIpIHsKIAkJdjRsX2VycihzdGF0 ZS0+Y2xpZW50LAogCQkJImZhaWxlZCBwYXJzaW5nICVkIGJ5dGUgaW5mb2ZyYW1lOiAweCUwNHgv MHglMDJ4XG4iLApAQCAtMTkyOCw3ICsxOTI4LDcgQEAgc3RhdGljIGludCB0ZGExOTk3eF9sb2df aW5mb2ZyYW1lKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsIGludCBhZGRyKQogCS8qIHJlYWQgZGF0 YSAqLwogCWxlbiA9IGlvX3JlYWRuKHNkLCBhZGRyLCBzaXplb2YoYnVmZmVyKSwgYnVmZmVyKTsK IAl2NGwyX2RiZygxLCBkZWJ1Zywgc2QsICJpbmZvZnJhbWU6IGFkZHI9JWQgbGVuPSVkXG4iLCBh ZGRyLCBsZW4pOwotCWVyciA9IGhkbWlfaW5mb2ZyYW1lX3VucGFjaygmZnJhbWUsIGJ1ZmZlcik7 CisJZXJyID0gaGRtaV9pbmZvZnJhbWVfdW5wYWNrKCZmcmFtZSwgYnVmZmVyLCBzaXplb2YoYnVm ZmVyKSk7CiAJaWYgKGVycikgewogCQl2NGxfZXJyKHN0YXRlLT5jbGllbnQsCiAJCQkiZmFpbGVk IHBhcnNpbmcgJWQgYnl0ZSBpbmZvZnJhbWU6IDB4JTA0eC8weCUwMnhcbiIsCmRpZmYgLS1naXQg YS9kcml2ZXJzL3ZpZGVvL2hkbWkuYyBiL2RyaXZlcnMvdmlkZW8vaGRtaS5jCmluZGV4IDY1Yjkx NWVhNDkzNi4uYjVkNDkxMDE0YjBiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2hkbWkuYwor KysgYi9kcml2ZXJzL3ZpZGVvL2hkbWkuYwpAQCAtMTAwNSw4ICsxMDA1LDkgQEAgRVhQT1JUX1NZ TUJPTChoZG1pX2luZm9mcmFtZV9sb2cpOwogCiAvKioKICAqIGhkbWlfYXZpX2luZm9mcmFtZV91 bnBhY2soKSAtIHVucGFjayBiaW5hcnkgYnVmZmVyIHRvIGEgSERNSSBBVkkgaW5mb2ZyYW1lCi0g KiBAYnVmZmVyOiBzb3VyY2UgYnVmZmVyCiAgKiBAZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQor ICogQGJ1ZmZlcjogc291cmNlIGJ1ZmZlcgorICogQHNpemU6IHNpemUgb2YgYnVmZmVyCiAgKgog ICogVW5wYWNrcyB0aGUgaW5mb3JtYXRpb24gY29udGFpbmVkIGluIGJpbmFyeSBAYnVmZmVyIGlu dG8gYSBzdHJ1Y3R1cmVkCiAgKiBAZnJhbWUgb2YgdGhlIEhETUkgQXV4aWxpYXJ5IFZpZGVvIChB VkkpIGluZm9ybWF0aW9uIGZyYW1lLgpAQCAtMTAxNiwxMSArMTAxNywxNCBAQCBFWFBPUlRfU1lN Qk9MKGhkbWlfaW5mb2ZyYW1lX2xvZyk7CiAgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5l Z2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KICAqLwogc3RhdGljIGludCBoZG1pX2F2aV9p bmZvZnJhbWVfdW5wYWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lLAotCQkJCSAg ICAgY29uc3Qgdm9pZCAqYnVmZmVyKQorCQkJCSAgICAgY29uc3Qgdm9pZCAqYnVmZmVyLCBzaXpl X3Qgc2l6ZSkKIHsKIAljb25zdCB1OCAqcHRyID0gYnVmZmVyOwogCWludCByZXQ7CiAKKwlpZiAo c2l6ZSA8IEhETUlfSU5GT0ZSQU1FX1NJWkUoQVZJKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKIAlp ZiAocHRyWzBdICE9IEhETUlfSU5GT0ZSQU1FX1RZUEVfQVZJIHx8CiAJICAgIHB0clsxXSAhPSAy IHx8CiAJICAgIHB0clsyXSAhPSBIRE1JX0FWSV9JTkZPRlJBTUVfU0laRSkKQEAgLTEwNjgsOCAr MTA3Miw5IEBAIHN0YXRpYyBpbnQgaGRtaV9hdmlfaW5mb2ZyYW1lX3VucGFjayhzdHJ1Y3QgaGRt aV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwKIAogLyoqCiAgKiBoZG1pX3NwZF9pbmZvZnJhbWVfdW5w YWNrKCkgLSB1bnBhY2sgYmluYXJ5IGJ1ZmZlciB0byBhIEhETUkgU1BEIGluZm9mcmFtZQotICog QGJ1ZmZlcjogc291cmNlIGJ1ZmZlcgogICogQGZyYW1lOiBIRE1JIFNQRCBpbmZvZnJhbWUKKyAq IEBidWZmZXI6IHNvdXJjZSBidWZmZXIKKyAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgogICoKICAq IFVucGFja3MgdGhlIGluZm9ybWF0aW9uIGNvbnRhaW5lZCBpbiBiaW5hcnkgQGJ1ZmZlciBpbnRv IGEgc3RydWN0dXJlZAogICogQGZyYW1lIG9mIHRoZSBIRE1JIFNvdXJjZSBQcm9kdWN0IERlc2Ny aXB0aW9uIChTUEQpIGluZm9ybWF0aW9uIGZyYW1lLgpAQCAtMTA3OSwxMSArMTA4NCwxNCBAQCBz dGF0aWMgaW50IGhkbWlfYXZpX2luZm9mcmFtZV91bnBhY2soc3RydWN0IGhkbWlfYXZpX2luZm9m cmFtZSAqZnJhbWUsCiAgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9y IGNvZGUgb24gZmFpbHVyZS4KICAqLwogc3RhdGljIGludCBoZG1pX3NwZF9pbmZvZnJhbWVfdW5w YWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLAotCQkJCSAgICAgY29uc3Qgdm9p ZCAqYnVmZmVyKQorCQkJCSAgICAgY29uc3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKIHsK IAljb25zdCB1OCAqcHRyID0gYnVmZmVyOwogCWludCByZXQ7CiAKKwlpZiAoc2l6ZSA8IEhETUlf SU5GT0ZSQU1FX1NJWkUoU1BEKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKIAlpZiAocHRyWzBdICE9 IEhETUlfSU5GT0ZSQU1FX1RZUEVfU1BEIHx8CiAJICAgIHB0clsxXSAhPSAxIHx8CiAJICAgIHB0 clsyXSAhPSBIRE1JX1NQRF9JTkZPRlJBTUVfU0laRSkgewpAQCAtMTEwNiw4ICsxMTE0LDkgQEAg c3RhdGljIGludCBoZG1pX3NwZF9pbmZvZnJhbWVfdW5wYWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZv ZnJhbWUgKmZyYW1lLAogCiAvKioKICAqIGhkbWlfYXVkaW9faW5mb2ZyYW1lX3VucGFjaygpIC0g dW5wYWNrIGJpbmFyeSBidWZmZXIgdG8gYSBIRE1JIEFVRElPIGluZm9mcmFtZQotICogQGJ1ZmZl cjogc291cmNlIGJ1ZmZlcgogICogQGZyYW1lOiBIRE1JIEF1ZGlvIGluZm9mcmFtZQorICogQGJ1 ZmZlcjogc291cmNlIGJ1ZmZlcgorICogQHNpemU6IHNpemUgb2YgYnVmZmVyCiAgKgogICogVW5w YWNrcyB0aGUgaW5mb3JtYXRpb24gY29udGFpbmVkIGluIGJpbmFyeSBAYnVmZmVyIGludG8gYSBz dHJ1Y3R1cmVkCiAgKiBAZnJhbWUgb2YgdGhlIEhETUkgQXVkaW8gaW5mb3JtYXRpb24gZnJhbWUu CkBAIC0xMTE3LDExICsxMTI2LDE0IEBAIHN0YXRpYyBpbnQgaGRtaV9zcGRfaW5mb2ZyYW1lX3Vu cGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwKICAqIFJldHVybnMgMCBvbiBz dWNjZXNzIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogICovCiBzdGF0aWMg aW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3VucGFjayhzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJh bWUgKmZyYW1lLAotCQkJCSAgICAgICBjb25zdCB2b2lkICpidWZmZXIpCisJCQkJICAgICAgIGNv bnN0IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCiB7CiAJY29uc3QgdTggKnB0ciA9IGJ1ZmZl cjsKIAlpbnQgcmV0OwogCisJaWYgKHNpemUgPCBIRE1JX0lORk9GUkFNRV9TSVpFKEFVRElPKSkK KwkJcmV0dXJuIC1FSU5WQUw7CisKIAlpZiAocHRyWzBdICE9IEhETUlfSU5GT0ZSQU1FX1RZUEVf QVVESU8gfHwKIAkgICAgcHRyWzFdICE9IDEgfHwKIAkgICAgcHRyWzJdICE9IEhETUlfQVVESU9f SU5GT0ZSQU1FX1NJWkUpIHsKQEAgLTExNTEsOCArMTE2Myw5IEBAIHN0YXRpYyBpbnQgaGRtaV9h dWRpb19pbmZvZnJhbWVfdW5wYWNrKHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJhbWUs CiAKIC8qKgogICogaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3VucGFjaygpIC0gdW5wYWNrIGJpbmFy eSBidWZmZXIgdG8gYSBIRE1JIHZlbmRvciBpbmZvZnJhbWUKLSAqIEBidWZmZXI6IHNvdXJjZSBi dWZmZXIKICAqIEBmcmFtZTogSERNSSBWZW5kb3IgaW5mb2ZyYW1lCisgKiBAYnVmZmVyOiBzb3Vy Y2UgYnVmZmVyCisgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKICAqCiAgKiBVbnBhY2tzIHRoZSBp bmZvcm1hdGlvbiBjb250YWluZWQgaW4gYmluYXJ5IEBidWZmZXIgaW50byBhIHN0cnVjdHVyZWQK ICAqIEBmcmFtZSBvZiB0aGUgSERNSSBWZW5kb3IgaW5mb3JtYXRpb24gZnJhbWUuCkBAIC0xMTYz LDcgKzExNzYsNyBAQCBzdGF0aWMgaW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3VucGFjayhzdHJ1 Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lLAogICovCiBzdGF0aWMgaW50CiBoZG1pX3Zl bmRvcl9hbnlfaW5mb2ZyYW1lX3VucGFjayh1bmlvbiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1l ICpmcmFtZSwKLQkJCQkgY29uc3Qgdm9pZCAqYnVmZmVyKQorCQkJCSBjb25zdCB2b2lkICpidWZm ZXIsIHNpemVfdCBzaXplKQogewogCWNvbnN0IHU4ICpwdHIgPSBidWZmZXI7CiAJc2l6ZV90IGxl bmd0aDsKQEAgLTExNzEsNiArMTE4NCw5IEBAIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfdW5w YWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAogCXU4IGhkbWlfdmlk ZW9fZm9ybWF0OwogCXN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmh2ZiA9ICZmcmFtZS0+ aGRtaTsKIAorCWlmIChzaXplIDwgSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUpCisJCXJldHVy biAtRUlOVkFMOworCiAJaWYgKHB0clswXSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUiB8 fAogCSAgICBwdHJbMV0gIT0gMSB8fAogCSAgICAocHRyWzJdICE9IDQgJiYgcHRyWzJdICE9IDUg JiYgcHRyWzJdICE9IDYpKQpAQCAtMTE3OCw2ICsxMTk0LDkgQEAgaGRtaV92ZW5kb3JfYW55X2lu Zm9mcmFtZV91bnBhY2sodW5pb24gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUsCiAK IAlsZW5ndGggPSBwdHJbMl07CiAKKwlpZiAoc2l6ZSA8IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9T SVpFICsgbGVuZ3RoKQorCQlyZXR1cm4gLUVJTlZBTDsKKwogCWlmIChoZG1pX2luZm9mcmFtZV9j aGVja3N1bShidWZmZXIsCiAJCQkJICAgIEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgbGVu Z3RoKSAhPSAwKQogCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTEyMjQsOCArMTI0Myw5IEBAIGhkbWlf dmVuZG9yX2FueV9pbmZvZnJhbWVfdW5wYWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJh bWUgKmZyYW1lLAogCiAvKioKICAqIGhkbWlfaW5mb2ZyYW1lX3VucGFjaygpIC0gdW5wYWNrIGJp bmFyeSBidWZmZXIgdG8gYSBIRE1JIGluZm9mcmFtZQotICogQGJ1ZmZlcjogc291cmNlIGJ1ZmZl cgogICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQorICogQGJ1ZmZlcjogc291cmNlIGJ1ZmZlcgor ICogQHNpemU6IHNpemUgb2YgYnVmZmVyCiAgKgogICogVW5wYWNrcyB0aGUgaW5mb3JtYXRpb24g Y29udGFpbmVkIGluIGJpbmFyeSBidWZmZXIgQGJ1ZmZlciBpbnRvIGEgc3RydWN0dXJlZAogICog QGZyYW1lIG9mIGEgSERNSSBpbmZvZnJhbWUuCkBAIC0xMjM1LDIzICsxMjU1LDI2IEBAIGhkbWlf dmVuZG9yX2FueV9pbmZvZnJhbWVfdW5wYWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJh bWUgKmZyYW1lLAogICogUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBj b2RlIG9uIGZhaWx1cmUuCiAgKi8KIGludCBoZG1pX2luZm9mcmFtZV91bnBhY2sodW5pb24gaGRt aV9pbmZvZnJhbWUgKmZyYW1lLAotCQkJICBjb25zdCB2b2lkICpidWZmZXIpCisJCQkgIGNvbnN0 IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCiB7CiAJaW50IHJldDsKIAljb25zdCB1OCAqcHRy ID0gYnVmZmVyOwogCisJaWYgKHNpemUgPCBIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRSkKKwkJ cmV0dXJuIC1FSU5WQUw7CisKIAlzd2l0Y2ggKHB0clswXSkgewogCWNhc2UgSERNSV9JTkZPRlJB TUVfVFlQRV9BVkk6Ci0JCXJldCA9IGhkbWlfYXZpX2luZm9mcmFtZV91bnBhY2soJmZyYW1lLT5h dmksIGJ1ZmZlcik7CisJCXJldCA9IGhkbWlfYXZpX2luZm9mcmFtZV91bnBhY2soJmZyYW1lLT5h dmksIGJ1ZmZlciwgc2l6ZSk7CiAJCWJyZWFrOwogCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9T UEQ6Ci0JCXJldCA9IGhkbWlfc3BkX2luZm9mcmFtZV91bnBhY2soJmZyYW1lLT5zcGQsIGJ1ZmZl cik7CisJCXJldCA9IGhkbWlfc3BkX2luZm9mcmFtZV91bnBhY2soJmZyYW1lLT5zcGQsIGJ1ZmZl ciwgc2l6ZSk7CiAJCWJyZWFrOwogCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9BVURJTzoKLQkJ cmV0ID0gaGRtaV9hdWRpb19pbmZvZnJhbWVfdW5wYWNrKCZmcmFtZS0+YXVkaW8sIGJ1ZmZlcik7 CisJCXJldCA9IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3VucGFjaygmZnJhbWUtPmF1ZGlvLCBidWZm ZXIsIHNpemUpOwogCQlicmVhazsKIAljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfVkVORE9SOgot CQlyZXQgPSBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3VucGFjaygmZnJhbWUtPnZlbmRvciwg YnVmZmVyKTsKKwkJcmV0ID0gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV91bnBhY2soJmZyYW1l LT52ZW5kb3IsIGJ1ZmZlciwgc2l6ZSk7CiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXJldCA9IC1F SU5WQUw7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2hkbWkuaCBiL2luY2x1ZGUvbGludXgv aGRtaS5oCmluZGV4IGQzODE2MTcwYzA2Mi4uYTU3N2Q0YWUyNTcwIDEwMDY0NAotLS0gYS9pbmNs dWRlL2xpbnV4L2hkbWkuaAorKysgYi9pbmNsdWRlL2xpbnV4L2hkbWkuaApAQCAtMzMzLDcgKzMz Myw3IEBAIHVuaW9uIGhkbWlfaW5mb2ZyYW1lIHsKIHNzaXplX3QKIGhkbWlfaW5mb2ZyYW1lX3Bh Y2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXpl KTsKIGludCBoZG1pX2luZm9mcmFtZV91bnBhY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1l LAotCQkJICBjb25zdCB2b2lkICpidWZmZXIpOworCQkJICBjb25zdCB2b2lkICpidWZmZXIsIHNp emVfdCBzaXplKTsKIHZvaWQgaGRtaV9pbmZvZnJhbWVfbG9nKGNvbnN0IGNoYXIgKmxldmVsLCBz dHJ1Y3QgZGV2aWNlICpkZXYsCiAJCQl1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUpOwogCi0t IAoyLjE2LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga03.intel.com ([134.134.136.65]:25817 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727171AbeIUAgs (ORCPT ); Thu, 20 Sep 2018 20:36:48 -0400 From: Ville Syrjala To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org Subject: [PATCH 02/18] video/hdmi: Pass buffer size to infoframe unpack functions Date: Thu, 20 Sep 2018 21:51:29 +0300 Message-Id: <20180920185145.1912-3-ville.syrjala@linux.intel.com> In-Reply-To: <20180920185145.1912-1-ville.syrjala@linux.intel.com> References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org List-ID: From: Ville Syrjälä To make sure the infoframe unpack functions don't end up examining stack garbage or oopsing, let's pass in the size of the buffer. v2: Convert tda1997x.c as well (kbuild test robot) Cc: Thierry Reding Cc: Hans Verkuil Cc: linux-media@vger.kernel.org Signed-off-by: Ville Syrjälä --- drivers/media/i2c/adv7511.c | 2 +- drivers/media/i2c/adv7604.c | 2 +- drivers/media/i2c/adv7842.c | 2 +- drivers/media/i2c/tc358743.c | 2 +- drivers/media/i2c/tda1997x.c | 4 ++-- drivers/video/hdmi.c | 51 ++++++++++++++++++++++++++++++++------------ include/linux/hdmi.h | 2 +- 7 files changed, 44 insertions(+), 21 deletions(-) diff --git a/drivers/media/i2c/adv7511.c b/drivers/media/i2c/adv7511.c index 55c2ea0720d9..b85b181bbb6c 100644 --- a/drivers/media/i2c/adv7511.c +++ b/drivers/media/i2c/adv7511.c @@ -550,7 +550,7 @@ static void log_infoframe(struct v4l2_subdev *sd, const struct adv7511_cfg_read_ buffer[3] = 0; buffer[3] = hdmi_infoframe_checksum(buffer, len + 4); - if (hdmi_infoframe_unpack(&frame, buffer) < 0) { + if (hdmi_infoframe_unpack(&frame, buffer, sizeof(buffer)) < 0) { v4l2_err(sd, "%s: unpack of %s infoframe failed\n", __func__, cri->desc); return; } diff --git a/drivers/media/i2c/adv7604.c b/drivers/media/i2c/adv7604.c index 668be2bca57a..2e7a28dbad4e 100644 --- a/drivers/media/i2c/adv7604.c +++ b/drivers/media/i2c/adv7604.c @@ -2418,7 +2418,7 @@ static int adv76xx_read_infoframe(struct v4l2_subdev *sd, int index, buffer[i + 3] = infoframe_read(sd, adv76xx_cri[index].payload_addr + i); - if (hdmi_infoframe_unpack(frame, buffer) < 0) { + if (hdmi_infoframe_unpack(frame, buffer, sizeof(buffer)) < 0) { v4l2_err(sd, "%s: unpack of %s infoframe failed\n", __func__, adv76xx_cri[index].desc); return -ENOENT; diff --git a/drivers/media/i2c/adv7842.c b/drivers/media/i2c/adv7842.c index 4f8fbdd00e35..2cfd03f929b2 100644 --- a/drivers/media/i2c/adv7842.c +++ b/drivers/media/i2c/adv7842.c @@ -2563,7 +2563,7 @@ static void log_infoframe(struct v4l2_subdev *sd, struct adv7842_cfg_read_infofr for (i = 0; i < len; i++) buffer[i + 3] = infoframe_read(sd, cri->payload_addr + i); - if (hdmi_infoframe_unpack(&frame, buffer) < 0) { + if (hdmi_infoframe_unpack(&frame, buffer, sizeof(buffer)) < 0) { v4l2_err(sd, "%s: unpack of %s infoframe failed\n", __func__, cri->desc); return; } diff --git a/drivers/media/i2c/tc358743.c b/drivers/media/i2c/tc358743.c index 44c41933415a..519bf92508d5 100644 --- a/drivers/media/i2c/tc358743.c +++ b/drivers/media/i2c/tc358743.c @@ -444,7 +444,7 @@ static void print_avi_infoframe(struct v4l2_subdev *sd) i2c_rd(sd, PK_AVI_0HEAD, buffer, HDMI_INFOFRAME_SIZE(AVI)); - if (hdmi_infoframe_unpack(&frame, buffer) < 0) { + if (hdmi_infoframe_unpack(&frame, buffer, sizeof(buffer)) < 0) { v4l2_err(sd, "%s: unpack of AVI infoframe failed\n", __func__); return; } diff --git a/drivers/media/i2c/tda1997x.c b/drivers/media/i2c/tda1997x.c index d114ac5243ec..195a1fc74ee8 100644 --- a/drivers/media/i2c/tda1997x.c +++ b/drivers/media/i2c/tda1997x.c @@ -1253,7 +1253,7 @@ tda1997x_parse_infoframe(struct tda1997x_state *state, u16 addr) /* read data */ len = io_readn(sd, addr, sizeof(buffer), buffer); - err = hdmi_infoframe_unpack(&frame, buffer); + err = hdmi_infoframe_unpack(&frame, buffer, sizeof(buffer)); if (err) { v4l_err(state->client, "failed parsing %d byte infoframe: 0x%04x/0x%02x\n", @@ -1928,7 +1928,7 @@ static int tda1997x_log_infoframe(struct v4l2_subdev *sd, int addr) /* read data */ len = io_readn(sd, addr, sizeof(buffer), buffer); v4l2_dbg(1, debug, sd, "infoframe: addr=%d len=%d\n", addr, len); - err = hdmi_infoframe_unpack(&frame, buffer); + err = hdmi_infoframe_unpack(&frame, buffer, sizeof(buffer)); if (err) { v4l_err(state->client, "failed parsing %d byte infoframe: 0x%04x/0x%02x\n", diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c index 65b915ea4936..b5d491014b0b 100644 --- a/drivers/video/hdmi.c +++ b/drivers/video/hdmi.c @@ -1005,8 +1005,9 @@ EXPORT_SYMBOL(hdmi_infoframe_log); /** * hdmi_avi_infoframe_unpack() - unpack binary buffer to a HDMI AVI infoframe - * @buffer: source buffer * @frame: HDMI AVI infoframe + * @buffer: source buffer + * @size: size of buffer * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Auxiliary Video (AVI) information frame. @@ -1016,11 +1017,14 @@ EXPORT_SYMBOL(hdmi_infoframe_log); * Returns 0 on success or a negative error code on failure. */ static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame, - const void *buffer) + const void *buffer, size_t size) { const u8 *ptr = buffer; int ret; + if (size < HDMI_INFOFRAME_SIZE(AVI)) + return -EINVAL; + if (ptr[0] != HDMI_INFOFRAME_TYPE_AVI || ptr[1] != 2 || ptr[2] != HDMI_AVI_INFOFRAME_SIZE) @@ -1068,8 +1072,9 @@ static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame, /** * hdmi_spd_infoframe_unpack() - unpack binary buffer to a HDMI SPD infoframe - * @buffer: source buffer * @frame: HDMI SPD infoframe + * @buffer: source buffer + * @size: size of buffer * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Source Product Description (SPD) information frame. @@ -1079,11 +1084,14 @@ static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame, * Returns 0 on success or a negative error code on failure. */ static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame, - const void *buffer) + const void *buffer, size_t size) { const u8 *ptr = buffer; int ret; + if (size < HDMI_INFOFRAME_SIZE(SPD)) + return -EINVAL; + if (ptr[0] != HDMI_INFOFRAME_TYPE_SPD || ptr[1] != 1 || ptr[2] != HDMI_SPD_INFOFRAME_SIZE) { @@ -1106,8 +1114,9 @@ static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame, /** * hdmi_audio_infoframe_unpack() - unpack binary buffer to a HDMI AUDIO infoframe - * @buffer: source buffer * @frame: HDMI Audio infoframe + * @buffer: source buffer + * @size: size of buffer * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Audio information frame. @@ -1117,11 +1126,14 @@ static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame, * Returns 0 on success or a negative error code on failure. */ static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame, - const void *buffer) + const void *buffer, size_t size) { const u8 *ptr = buffer; int ret; + if (size < HDMI_INFOFRAME_SIZE(AUDIO)) + return -EINVAL; + if (ptr[0] != HDMI_INFOFRAME_TYPE_AUDIO || ptr[1] != 1 || ptr[2] != HDMI_AUDIO_INFOFRAME_SIZE) { @@ -1151,8 +1163,9 @@ static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame, /** * hdmi_vendor_infoframe_unpack() - unpack binary buffer to a HDMI vendor infoframe - * @buffer: source buffer * @frame: HDMI Vendor infoframe + * @buffer: source buffer + * @size: size of buffer * * Unpacks the information contained in binary @buffer into a structured * @frame of the HDMI Vendor information frame. @@ -1163,7 +1176,7 @@ static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame, */ static int hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, - const void *buffer) + const void *buffer, size_t size) { const u8 *ptr = buffer; size_t length; @@ -1171,6 +1184,9 @@ hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, u8 hdmi_video_format; struct hdmi_vendor_infoframe *hvf = &frame->hdmi; + if (size < HDMI_INFOFRAME_HEADER_SIZE) + return -EINVAL; + if (ptr[0] != HDMI_INFOFRAME_TYPE_VENDOR || ptr[1] != 1 || (ptr[2] != 4 && ptr[2] != 5 && ptr[2] != 6)) @@ -1178,6 +1194,9 @@ hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, length = ptr[2]; + if (size < HDMI_INFOFRAME_HEADER_SIZE + length) + return -EINVAL; + if (hdmi_infoframe_checksum(buffer, HDMI_INFOFRAME_HEADER_SIZE + length) != 0) return -EINVAL; @@ -1224,8 +1243,9 @@ hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, /** * hdmi_infoframe_unpack() - unpack binary buffer to a HDMI infoframe - * @buffer: source buffer * @frame: HDMI infoframe + * @buffer: source buffer + * @size: size of buffer * * Unpacks the information contained in binary buffer @buffer into a structured * @frame of a HDMI infoframe. @@ -1235,23 +1255,26 @@ hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame, * Returns 0 on success or a negative error code on failure. */ int hdmi_infoframe_unpack(union hdmi_infoframe *frame, - const void *buffer) + const void *buffer, size_t size) { int ret; const u8 *ptr = buffer; + if (size < HDMI_INFOFRAME_HEADER_SIZE) + return -EINVAL; + switch (ptr[0]) { case HDMI_INFOFRAME_TYPE_AVI: - ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer); + ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer, size); break; case HDMI_INFOFRAME_TYPE_SPD: - ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer); + ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer, size); break; case HDMI_INFOFRAME_TYPE_AUDIO: - ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer); + ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer, size); break; case HDMI_INFOFRAME_TYPE_VENDOR: - ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer); + ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer, size); break; default: ret = -EINVAL; diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h index d3816170c062..a577d4ae2570 100644 --- a/include/linux/hdmi.h +++ b/include/linux/hdmi.h @@ -333,7 +333,7 @@ union hdmi_infoframe { ssize_t hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size); int hdmi_infoframe_unpack(union hdmi_infoframe *frame, - const void *buffer); + const void *buffer, size_t size); void hdmi_infoframe_log(const char *level, struct device *dev, union hdmi_infoframe *frame); -- 2.16.4