From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville Syrjala Subject: [PATCH 04/18] video/hdmi: Constify infoframe passed to the pack functions Date: Thu, 20 Sep 2018 21:51:31 +0300 Message-ID: <20180920185145.1912-5-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 RnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KCkxl dCdzIG1ha2UgdGhlIGluZm9mcmFtZSBwYWNrIGZ1bmN0aW9ucyB1c2FibGUgd2l0aCBhIGNvbnN0 IGluZm9mcmFtZQpzdHJ1Y3R1cmUuIFRoaXMgYWxsb3dzIHVzIHRvIHByZWNvbXB1dGUgdGhlIGlu Zm9mcmFtZSBlYXJsaWVyLCBhbmQgc3RpbGwKcGFjayBpdCBsYXRlciB3aGVuIHdlJ3JlIG5vIGxv bmdlciBhbGxvd2VkIHRvIG1vZGlmeSB0aGUgc3RydWN0dXJlLgpTbyBub3cgd2UgZW5kIHVwIHdp dGggYSBfY2hlY2soKStfcGFja19vbmx5KCkgb3IgX3BhY2soKSBmdW5jdGlvbnMKZGVwZW5kaW5n IG9uIHdoZXRoZXIgeW91IHdhbnQgdG8gcHJlY29tcHV0ZSB0aGUgaW5mb2ZyYW1lcyBvciBub3Qu ClRoZSBuYW1lcyBhcmVuJ3QgZ3JlYXRlIGJ1dCBJIHdhcyBsYXp5IGFuZCBkaWRuJ3Qgd2FudCB0 byBjaGFuZ2UgYWxsIHRoZQpkcml2ZXJzLgoKdjI6IERlYWwgd2l0aCBleHlub3MgY2h1cm4KICAg IEFjdHVhbGx5IGV4cG9ydCB0aGUgbmV3IGZ1bmNzCgpDYzogVGhpZXJyeSBSZWRpbmcgPHRoaWVy cnkucmVkaW5nQGdtYWlsLmNvbT4KQ2M6IEhhbnMgVmVya3VpbCA8aGFucy52ZXJrdWlsQGNpc2Nv LmNvbT4KQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwpTaWduZWQtb2ZmLWJ5OiBWaWxs ZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgotLS0KIGRyaXZlcnMv dmlkZW8vaGRtaS5jIHwgNDI1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0tLQogaW5jbHVkZS9saW51eC9oZG1pLmggfCAgMTkgKystCiAyIGZpbGVzIGNo YW5nZWQsIDQxNiBpbnNlcnRpb25zKCspLCAyOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9k cml2ZXJzL3ZpZGVvL2hkbWkuYyBiL2RyaXZlcnMvdmlkZW8vaGRtaS5jCmluZGV4IDUzZTdlZTJj ODNmYy4uOTUwN2Y2NjhhNTY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2hkbWkuYworKysg Yi9kcml2ZXJzL3ZpZGVvL2hkbWkuYwpAQCAtNjgsOCArNjgsMzYgQEAgaW50IGhkbWlfYXZpX2lu Zm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lKQogfQogRVhQT1JU X1NZTUJPTChoZG1pX2F2aV9pbmZvZnJhbWVfaW5pdCk7CiAKK3N0YXRpYyBpbnQgaGRtaV9hdmlf aW5mb2ZyYW1lX2NoZWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJh bWUpCit7CisJaWYgKGZyYW1lLT50eXBlICE9IEhETUlfSU5GT0ZSQU1FX1RZUEVfQVZJIHx8CisJ ICAgIGZyYW1lLT52ZXJzaW9uICE9IDIgfHwKKwkgICAgZnJhbWUtPmxlbmd0aCAhPSBIRE1JX0FW SV9JTkZPRlJBTUVfU0laRSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoZnJhbWUtPnBpY3R1 cmVfYXNwZWN0ID4gSERNSV9QSUNUVVJFX0FTUEVDVF8xNl85KQorCQlyZXR1cm4gLUVJTlZBTDsK KworCXJldHVybiAwOworfQorCiAvKioKLSAqIGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrKCkgLSB3 cml0ZSBIRE1JIEFWSSBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgorICogaGRtaV9hdmlfaW5m b2ZyYW1lX2NoZWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIEFWSSBpbmZvZnJhbWUKKyAq IEBmcmFtZTogSERNSSBBVkkgaW5mb2ZyYW1lCisgKgorICogVmFsaWRhdGVzIHRoYXQgdGhlIGlu Zm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCisgKiAoZWcu IGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgorICoKKyAqIFJldHVybnMgMCBvbiBzdWNj ZXNzIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgaGRtaV9h dmlfaW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lKQorewor CXJldHVybiBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cit9CitFWFBPUlRf U1lNQk9MKGhkbWlfYXZpX2luZm9mcmFtZV9jaGVjayk7CisKKy8qKgorICogaGRtaV9hdmlfaW5m b2ZyYW1lX3BhY2tfb25seSgpIC0gd3JpdGUgSERNSSBBVkkgaW5mb2ZyYW1lIHRvIGJpbmFyeSBi dWZmZXIKICAqIEBmcmFtZTogSERNSSBBVkkgaW5mb2ZyYW1lCiAgKiBAYnVmZmVyOiBkZXN0aW5h dGlvbiBidWZmZXIKICAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgpAQCAtODIsMjAgKzExMCwyMiBA QCBFWFBPUlRfU1lNQk9MKGhkbWlfYXZpX2luZm9mcmFtZV9pbml0KTsKICAqIFJldHVybnMgdGhl IG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0 aXZlCiAgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCiAgKi8KLXNzaXplX3QgaGRtaV9hdmlfaW5m b2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXZpX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZl ciwKLQkJCQlzaXplX3Qgc2l6ZSkKK3NzaXplX3QgaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2tfb25s eShjb25zdCBzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwKKwkJCQkgICAgIHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpCiB7CiAJdTggKnB0ciA9IGJ1ZmZlcjsKIAlzaXplX3QgbGVu Z3RoOworCWludCByZXQ7CisKKwlyZXQgPSBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2tfb25seShm cmFtZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKIAogCWxlbmd0aCA9IEhETUlfSU5GT0ZS QU1FX0hFQURFUl9TSVpFICsgZnJhbWUtPmxlbmd0aDsKIAogCWlmIChzaXplIDwgbGVuZ3RoKQog CQlyZXR1cm4gLUVOT1NQQzsKIAotCWlmIChmcmFtZS0+cGljdHVyZV9hc3BlY3QgPiBIRE1JX1BJ Q1RVUkVfQVNQRUNUXzE2XzkpCi0JCXJldHVybiAtRUlOVkFMOwotCiAJbWVtc2V0KGJ1ZmZlciwg MCwgc2l6ZSk7CiAKIAlwdHJbMF0gPSBmcmFtZS0+dHlwZTsKQEAgLTE1Miw2ICsxODIsMzYgQEAg c3NpemVfdCBoZG1pX2F2aV9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1l ICpmcmFtZSwgdm9pZCAqYnVmZmVyLAogCiAJcmV0dXJuIGxlbmd0aDsKIH0KK0VYUE9SVF9TWU1C T0woaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2tfb25seSk7CisKKy8qKgorICogaGRtaV9hdmlfaW5m b2ZyYW1lX3BhY2soKSAtIENoZWNrIGFuZCBjaGVjayBhIEhETUkgQVZJIGluZm9mcmFtZSwKKyAq ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZl cgorICogQGZyYW1lOiBIRE1JIEFWSSBpbmZvZnJhbWUKKyAqIEBidWZmZXI6IGRlc3RpbmF0aW9u IGJ1ZmZlcgorICogQHNpemU6IHNpemUgb2YgYnVmZmVyCisgKgorICogVmFsaWRhdGVzIHRoYXQg dGhlIGluZm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCisg KiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3aGljaCBwYWNrcyB0 aGUgaW5mb3JtYXRpb24KKyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBpbnRv IGEgYmluYXJ5IHJlcHJlc2VudGF0aW9uIHRoYXQKKyAqIGNhbiBiZSB3cml0dGVuIGludG8gdGhl IGNvcnJlc3BvbmRpbmcgY29udHJvbGxlciByZWdpc3RlcnMuIEFsc28KKyAqIGNvbXB1dGVzIHRo ZSBjaGVja3N1bSBhcyByZXF1aXJlZCBieSBzZWN0aW9uIDUuMy41IG9mIHRoZSBIRE1JIDEuNAor ICogc3BlY2lmaWNhdGlvbi4KKyAqCisgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFj a2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQorICogZXJyb3IgY29kZSBv biBmYWlsdXJlLgorICovCitzc2l6ZV90IGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBo ZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lLAorCQkJCXZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUp Cit7CisJaW50IHJldDsKKworCXJldCA9IGhkbWlfYXZpX2luZm9mcmFtZV9jaGVjayhmcmFtZSk7 CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiBoZG1pX2F2aV9pbmZvZnJhbWVf cGFja19vbmx5KGZyYW1lLCBidWZmZXIsIHNpemUpOworfQogRVhQT1JUX1NZTUJPTChoZG1pX2F2 aV9pbmZvZnJhbWVfcGFjayk7CiAKIC8qKgpAQCAtMTc4LDggKzIzOCwzMyBAQCBpbnQgaGRtaV9z cGRfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCiB9CiBF WFBPUlRfU1lNQk9MKGhkbWlfc3BkX2luZm9mcmFtZV9pbml0KTsKIAorc3RhdGljIGludCBoZG1p X3NwZF9pbmZvZnJhbWVfY2hlY2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1l ICpmcmFtZSkKK3sKKwlpZiAoZnJhbWUtPnR5cGUgIT0gSERNSV9JTkZPRlJBTUVfVFlQRV9TUEQg fHwKKwkgICAgZnJhbWUtPnZlcnNpb24gIT0gMSB8fAorCSAgICBmcmFtZS0+bGVuZ3RoICE9IEhE TUlfU1BEX0lORk9GUkFNRV9TSVpFKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXJldHVybiAwOwor fQorCiAvKioKLSAqIGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKCkgLSB3cml0ZSBIRE1JIFNQRCBp bmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgorICogaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrKCkg LSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIFNQRCBpbmZvZnJhbWUKKyAqIEBmcmFtZTogSERNSSBT UEQgaW5mb2ZyYW1lCisgKgorICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBpcyBjb25z aXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCisgKiAoZWcuIGxlbmd0aCkgYmFzZWQg b24gb3RoZXIgZmllbGRzLgorICoKKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzIG9yIGEgbmVnYXRp dmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2No ZWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lKQoreworCXJldHVybiBoZG1pX3Nw ZF9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cit9CitFWFBPUlRfU1lNQk9MKGhkbWlfc3Bk X2luZm9mcmFtZV9jaGVjayk7CisKKy8qKgorICogaGRtaV9zcGRfaW5mb2ZyYW1lX3BhY2tfb25s eSgpIC0gd3JpdGUgSERNSSBTUEQgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKICAqIEBmcmFt ZTogSERNSSBTUEQgaW5mb2ZyYW1lCiAgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKICAq IEBzaXplOiBzaXplIG9mIGJ1ZmZlcgpAQCAtMTkyLDExICsyNzcsMTYgQEAgRVhQT1JUX1NZTUJP TChoZG1pX3NwZF9pbmZvZnJhbWVfaW5pdCk7CiAgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0 ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQogICogZXJyb3Ig Y29kZSBvbiBmYWlsdXJlLgogICovCi1zc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKHN0 cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsCi0JCQkJc2l6ZV90 IHNpemUpCitzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0 IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCisJCQkJICAgICB2b2lkICpidWZmZXIsIHNpemVf dCBzaXplKQogewogCXU4ICpwdHIgPSBidWZmZXI7CiAJc2l6ZV90IGxlbmd0aDsKKwlpbnQgcmV0 OworCisJcmV0ID0gaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOworCWlmIChy ZXQpCisJCXJldHVybiByZXQ7CiAKIAlsZW5ndGggPSBIRE1JX0lORk9GUkFNRV9IRUFERVJfU0la RSArIGZyYW1lLT5sZW5ndGg7CiAKQEAgLTIyMiw2ICszMTIsMzYgQEAgc3NpemVfdCBoZG1pX3Nw ZF9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAq YnVmZmVyLAogCiAJcmV0dXJuIGxlbmd0aDsKIH0KK0VYUE9SVF9TWU1CT0woaGRtaV9zcGRfaW5m b2ZyYW1lX3BhY2tfb25seSk7CisKKy8qKgorICogaGRtaV9zcGRfaW5mb2ZyYW1lX3BhY2soKSAt IENoZWNrIGFuZCBjaGVjayBhIEhETUkgU1BEIGluZm9mcmFtZSwKKyAqICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZlcgorICogQGZyYW1lOiBI RE1JIFNQRCBpbmZvZnJhbWUKKyAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1ZmZlcgorICogQHNp emU6IHNpemUgb2YgYnVmZmVyCisgKgorICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBp cyBjb25zaXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCisgKiAoZWcuIGxlbmd0aCkg YmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3aGljaCBwYWNrcyB0aGUgaW5mb3JtYXRpb24K KyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBpbnRvIGEgYmluYXJ5IHJlcHJl c2VudGF0aW9uIHRoYXQKKyAqIGNhbiBiZSB3cml0dGVuIGludG8gdGhlIGNvcnJlc3BvbmRpbmcg Y29udHJvbGxlciByZWdpc3RlcnMuIEFsc28KKyAqIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBhcyBy ZXF1aXJlZCBieSBzZWN0aW9uIDUuMy41IG9mIHRoZSBIRE1JIDEuNAorICogc3BlY2lmaWNhdGlv bi4KKyAqCisgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJp bmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQorICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICov Citzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJh bWUgKmZyYW1lLAorCQkJCXZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCit7CisJaW50IHJldDsK KworCXJldCA9IGhkbWlfc3BkX2luZm9mcmFtZV9jaGVjayhmcmFtZSk7CisJaWYgKHJldCkKKwkJ cmV0dXJuIHJldDsKKworCXJldHVybiBoZG1pX3NwZF9pbmZvZnJhbWVfcGFja19vbmx5KGZyYW1l LCBidWZmZXIsIHNpemUpOworfQogRVhQT1JUX1NZTUJPTChoZG1pX3NwZF9pbmZvZnJhbWVfcGFj ayk7CiAKIC8qKgpAQCAtMjQyLDggKzM2MiwzMyBAQCBpbnQgaGRtaV9hdWRpb19pbmZvZnJhbWVf aW5pdChzdHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lKQogfQogRVhQT1JUX1NZTUJP TChoZG1pX2F1ZGlvX2luZm9mcmFtZV9pbml0KTsKIAorc3RhdGljIGludCBoZG1pX2F1ZGlvX2lu Zm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJh bWUpCit7CisJaWYgKGZyYW1lLT50eXBlICE9IEhETUlfSU5GT0ZSQU1FX1RZUEVfQVVESU8gfHwK KwkgICAgZnJhbWUtPnZlcnNpb24gIT0gMSB8fAorCSAgICBmcmFtZS0+bGVuZ3RoICE9IEhETUlf QVVESU9fSU5GT0ZSQU1FX1NJWkUpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIDA7Cit9 CisKKy8qKgorICogaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2soKSAtIENoZWNrIGFuZCBjaGVj ayBhIEhETUkgYXVkaW8gaW5mb2ZyYW1lCisgKiBAZnJhbWU6IEhETUkgYXVkaW8gaW5mb2ZyYW1l CisgKgorICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9mcmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1 cGRhdGVzIGRlcml2ZWQgZmllbGRzCisgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmll bGRzLgorICoKKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzIG9yIGEgbmVnYXRpdmUgZXJyb3IgY29k ZSBvbiBmYWlsdXJlLgorICovCitpbnQgaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2soc3RydWN0 IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSkKK3sKKwlyZXR1cm4gaGRtaV9hdWRpb19pbmZv ZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cit9CitFWFBPUlRfU1lNQk9MKGhkbWlfYXVkaW9faW5m b2ZyYW1lX2NoZWNrKTsKKwogLyoqCi0gKiBoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrKCkgLSB3 cml0ZSBIRE1JIGF1ZGlvIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCisgKiBoZG1pX2F1ZGlv X2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIEhETUkgYXVkaW8gaW5mb2ZyYW1lIHRvIGJp bmFyeSBidWZmZXIKICAqIEBmcmFtZTogSERNSSBhdWRpbyBpbmZvZnJhbWUKICAqIEBidWZmZXI6 IGRlc3RpbmF0aW9uIGJ1ZmZlcgogICogQHNpemU6IHNpemUgb2YgYnVmZmVyCkBAIC0yNTYsMTIg KzQwMSwxNyBAQCBFWFBPUlRfU1lNQk9MKGhkbWlfYXVkaW9faW5mb2ZyYW1lX2luaXQpOwogICog UmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVy IG9yIGEgbmVnYXRpdmUKICAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KICAqLwotc3NpemVfdCBo ZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJh bWUsCi0JCQkJICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQorc3NpemVfdCBoZG1pX2F1ZGlv X2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpm cmFtZSwKKwkJCQkgICAgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKIHsKIAl1bnNpZ25l ZCBjaGFyIGNoYW5uZWxzOwogCXU4ICpwdHIgPSBidWZmZXI7CiAJc2l6ZV90IGxlbmd0aDsKKwlp bnQgcmV0OworCisJcmV0ID0gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7 CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKIAogCWxlbmd0aCA9IEhETUlfSU5GT0ZSQU1FX0hF QURFUl9TSVpFICsgZnJhbWUtPmxlbmd0aDsKIApAQCAtMjk3LDYgKzQ0NywzNiBAQCBzc2l6ZV90 IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpm cmFtZSwKIAogCXJldHVybiBsZW5ndGg7CiB9CitFWFBPUlRfU1lNQk9MKGhkbWlfYXVkaW9faW5m b2ZyYW1lX3BhY2tfb25seSk7CisKKy8qKgorICogaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjaygp IC0gQ2hlY2sgYW5kIGNoZWNrIGEgSERNSSBBdWRpbyBpbmZvZnJhbWUsCisgKiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZlcgorICogQGZy YW1lOiBIRE1JIEF1ZGlvIGluZm9mcmFtZQorICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVy CisgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKKyAqCisgKiBWYWxpZGF0ZXMgdGhhdCB0aGUgaW5m b2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVsZHMKKyAqIChlZy4g bGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIHBhY2tzIHRoZSBpbmZv cm1hdGlvbgorICogY29udGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBiaW5h cnkgcmVwcmVzZW50YXRpb24gdGhhdAorICogY2FuIGJlIHdyaXR0ZW4gaW50byB0aGUgY29ycmVz cG9uZGluZyBjb250cm9sbGVyIHJlZ2lzdGVycy4gQWxzbworICogY29tcHV0ZXMgdGhlIGNoZWNr c3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhlIEhETUkgMS40CisgKiBzcGVj aWZpY2F0aW9uLgorICoKKyAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50 byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCisgKiBlcnJvciBjb2RlIG9uIGZhaWx1 cmUuCisgKi8KK3NzaXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9h dWRpb19pbmZvZnJhbWUgKmZyYW1lLAorCQkJCSAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkK K3sKKwlpbnQgcmV0OworCisJcmV0ID0gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2soZnJhbWUp OworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gaGRtaV9hdWRpb19pbmZvZnJh bWVfcGFja19vbmx5KGZyYW1lLCBidWZmZXIsIHNpemUpOworfQogRVhQT1JUX1NZTUJPTChoZG1p X2F1ZGlvX2luZm9mcmFtZV9wYWNrKTsKIAogLyoqCkBAIC0zMTksNiArNDk5LDcgQEAgaW50IGhk bWlfdmVuZG9yX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZy YW1lKQogCSAqIHZhbHVlCiAJICovCiAJZnJhbWUtPnMzZF9zdHJ1Y3QgPSBIRE1JXzNEX1NUUlVD VFVSRV9JTlZBTElEOworCWZyYW1lLT5sZW5ndGggPSA0OwogCiAJcmV0dXJuIDA7CiB9CkBAIC0z MzUsOCArNTE2LDQyIEBAIHN0YXRpYyBpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2xlbmd0aChj b25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtCiAJCXJldHVybiA0OwogfQog CitzdGF0aWMgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHN0cnVj dCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKQoreworCWlmIChmcmFtZS0+dHlwZSAhPSBI RE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUiB8fAorCSAgICBmcmFtZS0+dmVyc2lvbiAhPSAxIHx8 CisJICAgIGZyYW1lLT5vdWkgIT0gSERNSV9JRUVFX09VSSkKKwkJcmV0dXJuIC1FSU5WQUw7CisK KwkvKiBvbmx5IG9uZSBvZiB0aG9zZSBjYW4gYmUgc3VwcGxpZWQgKi8KKwlpZiAoZnJhbWUtPnZp YyAhPSAwICYmIGZyYW1lLT5zM2Rfc3RydWN0ICE9IEhETUlfM0RfU1RSVUNUVVJFX0lOVkFMSUQp CisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGZyYW1lLT5sZW5ndGggIT0gaGRtaV92ZW5kb3Jf aW5mb2ZyYW1lX2xlbmd0aChmcmFtZSkpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIDA7 Cit9CisKIC8qKgotICogaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soKSAtIHdyaXRlIGEgSERN SSB2ZW5kb3IgaW5mb2ZyYW1lIHRvIGJpbmFyeSBidWZmZXIKKyAqIGhkbWlfdmVuZG9yX2luZm9m cmFtZV9jaGVjaygpIC0gQ2hlY2sgYW5kIGNoZWNrIGEgSERNSSB2ZW5kb3IgaW5mb2ZyYW1lCisg KiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCisgKgorICogVmFsaWRhdGVzIHRoYXQgdGhlIGluZm9m cmFtZSBpcyBjb25zaXN0ZW50IGFuZCB1cGRhdGVzIGRlcml2ZWQgZmllbGRzCisgKiAoZWcuIGxl bmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgorICoKKyAqIFJldHVybnMgMCBvbiBzdWNjZXNz IG9yIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgorICovCitpbnQgaGRtaV92ZW5k b3JfaW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKQor eworCWZyYW1lLT5sZW5ndGggPSBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGZyYW1lKTsK KworCXJldHVybiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cit9CitF WFBPUlRfU1lNQk9MKGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVjayk7CisKKy8qKgorICogaGRt aV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tfb25seSgpIC0gd3JpdGUgYSBIRE1JIHZlbmRvciBpbmZv ZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgogICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQogICogQGJ1 ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCiAgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKQEAgLTM0 OSwxNyArNTY0LDE2IEBAIHN0YXRpYyBpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2xlbmd0aChj b25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtCiAgKiBSZXR1cm5zIHRoZSBu dW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2 ZQogICogZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogICovCi1zc2l6ZV90IGhkbWlfdmVuZG9yX2lu Zm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lLAotCQkJCSB2 b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQorc3NpemVfdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVf cGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lLAorCQkJ CQl2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQogewogCXU4ICpwdHIgPSBidWZmZXI7CiAJc2l6 ZV90IGxlbmd0aDsKKwlpbnQgcmV0OwogCi0JLyogb25seSBvbmUgb2YgdGhvc2UgY2FuIGJlIHN1 cHBsaWVkICovCi0JaWYgKGZyYW1lLT52aWMgIT0gMCAmJiBmcmFtZS0+czNkX3N0cnVjdCAhPSBI RE1JXzNEX1NUUlVDVFVSRV9JTlZBTElEKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWZyYW1lLT5s ZW5ndGggPSBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGZyYW1lKTsKKwlyZXQgPSBoZG1p X3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7CisJaWYgKHJldCkKKwkJcmV0dXJu IHJldDsKIAogCWxlbmd0aCA9IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgZnJhbWUtPmxl bmd0aDsKIApAQCAtMzk0LDI0ICs2MDgsMTM0IEBAIHNzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2Zy YW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUsCiAKIAlyZXR1cm4g bGVuZ3RoOwogfQorRVhQT1JUX1NZTUJPTChoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFja19vbmx5 KTsKKworLyoqCisgKiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjaygpIC0gQ2hlY2sgYW5kIGNo ZWNrIGEgSERNSSBWZW5kb3IgaW5mb2ZyYW1lLAorICogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGFuZCB3cml0ZSBpdCB0byBiaW5hcnkgYnVmZmVyCisgKiBAZnJhbWU6IEhETUkgVmVu ZG9yIGluZm9mcmFtZQorICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCisgKiBAc2l6ZTog c2l6ZSBvZiBidWZmZXIKKyAqCisgKiBWYWxpZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNv bnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVsZHMKKyAqIChlZy4gbGVuZ3RoKSBiYXNl ZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIHBhY2tzIHRoZSBpbmZvcm1hdGlvbgorICog Y29udGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBiaW5hcnkgcmVwcmVzZW50 YXRpb24gdGhhdAorICogY2FuIGJlIHdyaXR0ZW4gaW50byB0aGUgY29ycmVzcG9uZGluZyBjb250 cm9sbGVyIHJlZ2lzdGVycy4gQWxzbworICogY29tcHV0ZXMgdGhlIGNoZWNrc3VtIGFzIHJlcXVp cmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhlIEhETUkgMS40CisgKiBzcGVjaWZpY2F0aW9uLgor ICoKKyAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmluYXJ5 IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCisgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCisgKi8KK3Nz aXplX3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9m cmFtZSAqZnJhbWUsCisJCQkJICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKK3sKKwlpbnQg cmV0OworCisJcmV0ID0gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrKGZyYW1lKTsKKwlpZiAo cmV0KQorCQlyZXR1cm4gcmV0OworCisJcmV0dXJuIGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNr X29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cit9CiBFWFBPUlRfU1lNQk9MKGhkbWlfdmVuZG9y X2luZm9mcmFtZV9wYWNrKTsKIAorc3RhdGljIGludAoraGRtaV92ZW5kb3JfYW55X2luZm9mcmFt ZV9jaGVja19vbmx5KGNvbnN0IHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1l KQoreworCWlmIChmcmFtZS0+YW55LnR5cGUgIT0gSERNSV9JTkZPRlJBTUVfVFlQRV9WRU5ET1Ig fHwKKwkgICAgZnJhbWUtPmFueS52ZXJzaW9uICE9IDEpCisJCXJldHVybiAtRUlOVkFMOworCisJ cmV0dXJuIDA7Cit9CisKIC8qCi0gKiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2soKSAt IHdyaXRlIGEgdmVuZG9yIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCisgKiBoZG1pX3ZlbmRv cl9hbnlfaW5mb2ZyYW1lX2NoZWNrKCkgLSBjaGVjayBhbmQgY2hlY2sgYSB2ZW5kb3IgaW5mb2Zy YW1lCisgKi8KK3N0YXRpYyBpbnQKK2hkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfY2hlY2sodW5p b24gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUpCit7CisJaW50IHJldDsKKworCXJl dCA9IGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7CisJaWYgKHJl dCkKKwkJcmV0dXJuIHJldDsKKworCS8qIHdlIG9ubHkga25vdyBhYm91dCBIRE1JIHZlbmRvciBp bmZvZnJhbWVzICovCisJaWYgKGZyYW1lLT5hbnkub3VpICE9IEhETUlfSUVFRV9PVUkpCisJCXJl dHVybiAtRUlOVkFMOworCisJcmV0dXJuIGhkbWlfdmVuZG9yX2luZm9mcmFtZV9jaGVjaygmZnJh bWUtPmhkbWkpOworfQorCisvKgorICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrX29u bHkoKSAtIHdyaXRlIGEgdmVuZG9yIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCiAgKi8KIHN0 YXRpYyBzc2l6ZV90Ci1oZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV92 ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUsCi0JCQkgICB2b2lkICpidWZmZXIsIHNpemVfdCBz aXplKQoraGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3QgdW5pb24gaGRt aV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUsCisJCQkJICAgIHZvaWQgKmJ1ZmZlciwgc2l6 ZV90IHNpemUpCiB7CisJaW50IHJldDsKKworCXJldCA9IGhkbWlfdmVuZG9yX2FueV9pbmZvZnJh bWVfY2hlY2tfb25seShmcmFtZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKwogCS8qIHdl IG9ubHkga25vdyBhYm91dCBIRE1JIHZlbmRvciBpbmZvZnJhbWVzICovCiAJaWYgKGZyYW1lLT5h bnkub3VpICE9IEhETUlfSUVFRV9PVUkpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JcmV0dXJuIGhk bWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrKCZmcmFtZS0+aGRtaSwgYnVmZmVyLCBzaXplKTsKKwly ZXR1cm4gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tfb25seSgmZnJhbWUtPmhkbWksIGJ1ZmZl ciwgc2l6ZSk7Cit9CisKKy8qCisgKiBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2soKSAt IGNoZWNrIGFuZCBjaGVjayBhIHZlbmRvciBpbmZvZnJhbWUsCisgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZl cgorICovCitzdGF0aWMgc3NpemVfdAoraGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrKHVu aW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAorCQkJICAgICAgIHZvaWQgKmJ1 ZmZlciwgc2l6ZV90IHNpemUpCit7CisJaW50IHJldDsKKworCXJldCA9IGhkbWlfdmVuZG9yX2Fu eV9pbmZvZnJhbWVfY2hlY2soZnJhbWUpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwly ZXR1cm4gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwg c2l6ZSk7Cit9CisKKy8qKgorICogaGRtaV9pbmZvZnJhbWVfY2hlY2soKSAtIENoZWNrIGNoZWNr IGEgSERNSSBpbmZvZnJhbWUKKyAqIEBmcmFtZTogSERNSSBpbmZvZnJhbWUKKyAqCisgKiBWYWxp ZGF0ZXMgdGhhdCB0aGUgaW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZl ZCBmaWVsZHMKKyAqIChlZy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMuCisgKgorICog UmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUu CisgKi8KK2ludAoraGRtaV9pbmZvZnJhbWVfY2hlY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZy YW1lKQoreworCXN3aXRjaCAoZnJhbWUtPmFueS50eXBlKSB7CisJY2FzZSBIRE1JX0lORk9GUkFN RV9UWVBFX0FWSToKKwkJcmV0dXJuIGhkbWlfYXZpX2luZm9mcmFtZV9jaGVjaygmZnJhbWUtPmF2 aSk7CisJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1NQRDoKKwkJcmV0dXJuIGhkbWlfc3BkX2lu Zm9mcmFtZV9jaGVjaygmZnJhbWUtPnNwZCk7CisJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX0FV RElPOgorCQlyZXR1cm4gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2soJmZyYW1lLT5hdWRpbyk7 CisJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUjoKKwkJcmV0dXJuIGhkbWlfdmVuZG9y X2FueV9pbmZvZnJhbWVfY2hlY2soJmZyYW1lLT52ZW5kb3IpOworCWRlZmF1bHQ6CisJCVdBUk4o MSwgIkJhZCBpbmZvZnJhbWUgdHlwZSAlZFxuIiwgZnJhbWUtPmFueS50eXBlKTsKKwkJcmV0dXJu IC1FSU5WQUw7CisJfQogfQorRVhQT1JUX1NZTUJPTChoZG1pX2luZm9mcmFtZV9jaGVjayk7CiAK IC8qKgotICogaGRtaV9pbmZvZnJhbWVfcGFjaygpIC0gd3JpdGUgYSBIRE1JIGluZm9mcmFtZSB0 byBiaW5hcnkgYnVmZmVyCisgKiBoZG1pX2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIGEg SERNSSBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgogICogQGZyYW1lOiBIRE1JIGluZm9mcmFt ZQogICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCiAgKiBAc2l6ZTogc2l6ZSBvZiBidWZm ZXIKQEAgLTQyNSw3ICs3NDksNTYgQEAgaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrKHVu aW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAogICogZXJyb3IgY29kZSBvbiBm YWlsdXJlLgogICovCiBzc2l6ZV90Ci1oZG1pX2luZm9mcmFtZV9wYWNrKHVuaW9uIGhkbWlfaW5m b2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKK2hkbWlfaW5mb2ZyYW1l X3BhY2tfb25seShjb25zdCB1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZl ciwgc2l6ZV90IHNpemUpCit7CisJc3NpemVfdCBsZW5ndGg7CisKKwlzd2l0Y2ggKGZyYW1lLT5h bnkudHlwZSkgeworCWNhc2UgSERNSV9JTkZPRlJBTUVfVFlQRV9BVkk6CisJCWxlbmd0aCA9IGhk bWlfYXZpX2luZm9mcmFtZV9wYWNrX29ubHkoJmZyYW1lLT5hdmksCisJCQkJCQkgICAgICBidWZm ZXIsIHNpemUpOworCQlicmVhazsKKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfU1BEOgorCQls ZW5ndGggPSBoZG1pX3NwZF9pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+c3BkLAorCQkJCQkJ ICAgICAgYnVmZmVyLCBzaXplKTsKKwkJYnJlYWs7CisJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBF X0FVRElPOgorCQlsZW5ndGggPSBoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrX29ubHkoJmZyYW1l LT5hdWRpbywKKwkJCQkJCQlidWZmZXIsIHNpemUpOworCQlicmVhazsKKwljYXNlIEhETUlfSU5G T0ZSQU1FX1RZUEVfVkVORE9SOgorCQlsZW5ndGggPSBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1l X3BhY2tfb25seSgmZnJhbWUtPnZlbmRvciwKKwkJCQkJCQkgICAgIGJ1ZmZlciwgc2l6ZSk7CisJ CWJyZWFrOworCWRlZmF1bHQ6CisJCVdBUk4oMSwgIkJhZCBpbmZvZnJhbWUgdHlwZSAlZFxuIiwg ZnJhbWUtPmFueS50eXBlKTsKKwkJbGVuZ3RoID0gLUVJTlZBTDsKKwl9CisKKwlyZXR1cm4gbGVu Z3RoOworfQorRVhQT1JUX1NZTUJPTChoZG1pX2luZm9mcmFtZV9wYWNrX29ubHkpOworCisvKioK KyAqIGhkbWlfaW5mb2ZyYW1lX3BhY2soKSAtIENoZWNrIGNoZWNrIGEgSERNSSBpbmZvZnJhbWUs CisgKiAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZl cgorICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQorICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVm ZmVyCisgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKKyAqCisgKiBWYWxpZGF0ZXMgdGhhdCB0aGUg aW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVsZHMKKyAqIChl Zy4gbGVuZ3RoKSBiYXNlZCBvbiBvdGhlciBmaWVsZHMsIGFmdGVyIHdoaWNoIHBhY2tzIHRoZSBp bmZvcm1hdGlvbgorICogY29udGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBi aW5hcnkgcmVwcmVzZW50YXRpb24gdGhhdAorICogY2FuIGJlIHdyaXR0ZW4gaW50byB0aGUgY29y cmVzcG9uZGluZyBjb250cm9sbGVyIHJlZ2lzdGVycy4gQWxzbworICogY29tcHV0ZXMgdGhlIGNo ZWNrc3VtIGFzIHJlcXVpcmVkIGJ5IHNlY3Rpb24gNS4zLjUgb2YgdGhlIEhETUkgMS40CisgKiBz cGVjaWZpY2F0aW9uLgorICoKKyAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQg aW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCisgKiBlcnJvciBjb2RlIG9uIGZh aWx1cmUuCisgKi8KK3NzaXplX3QKK2hkbWlfaW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV9pbmZv ZnJhbWUgKmZyYW1lLAorCQkgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKIHsKIAlzc2l6 ZV90IGxlbmd0aDsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9oZG1pLmggYi9pbmNsdWRl L2xpbnV4L2hkbWkuaAppbmRleCBiY2UxYWJiMWZlNTcuLmM3NmI1MGE0OGU0OCAxMDA2NDQKLS0t IGEvaW5jbHVkZS9saW51eC9oZG1pLmgKKysrIGIvaW5jbHVkZS9saW51eC9oZG1pLmgKQEAgLTE2 Myw2ICsxNjMsOSBAQCBzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lIHsKIGludCBoZG1pX2F2aV9p bmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSk7CiBzc2l6ZV90 IGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1l LCB2b2lkICpidWZmZXIsCiAJCQkJc2l6ZV90IHNpemUpOworc3NpemVfdCBoZG1pX2F2aV9pbmZv ZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lLAor CQkJCSAgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7CitpbnQgaGRtaV9hdmlfaW5mb2Zy YW1lX2NoZWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lKTsKIAogZW51bSBoZG1p X3NwZF9zZGkgewogCUhETUlfU1BEX1NESV9VTktOT1dOLApAQCAtMTk0LDYgKzE5Nyw5IEBAIGlu dCBoZG1pX3NwZF9pbmZvZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFt ZSwKIAkJCSAgICBjb25zdCBjaGFyICp2ZW5kb3IsIGNvbnN0IGNoYXIgKnByb2R1Y3QpOwogc3Np emVfdCBoZG1pX3NwZF9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpm cmFtZSwgdm9pZCAqYnVmZmVyLAogCQkJCXNpemVfdCBzaXplKTsKK3NzaXplX3QgaGRtaV9zcGRf aW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFt ZSwKKwkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOworaW50IGhkbWlfc3BkX2lu Zm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSk7CiAKIGVudW0g aGRtaV9hdWRpb19jb2RpbmdfdHlwZSB7CiAJSERNSV9BVURJT19DT0RJTkdfVFlQRV9TVFJFQU0s CkBAIC0yNzIsNiArMjc4LDkgQEAgc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lIHsKIGludCBo ZG1pX2F1ZGlvX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJh bWUpOwogc3NpemVfdCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX2F1ZGlv X2luZm9mcmFtZSAqZnJhbWUsCiAJCQkJICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKK3Nz aXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F1 ZGlvX2luZm9mcmFtZSAqZnJhbWUsCisJCQkJICAgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNp emUpOworaW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX2F1ZGlvX2lu Zm9mcmFtZSAqZnJhbWUpOwogCiBlbnVtIGhkbWlfM2Rfc3RydWN0dXJlIHsKIAlIRE1JXzNEX1NU UlVDVFVSRV9JTlZBTElEID0gLTEsCkBAIC0yOTksNiArMzA4LDkgQEAgc3RydWN0IGhkbWlfdmVu ZG9yX2luZm9mcmFtZSB7CiBpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhk bWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUpOwogc3NpemVfdCBoZG1pX3ZlbmRvcl9pbmZvZnJh bWVfcGFjayhzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtZSwKIAkJCQkgICB2b2lk ICpidWZmZXIsIHNpemVfdCBzaXplKTsKK3NzaXplX3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3Bh Y2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtZSwKKwkJCQkJ dm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7CitpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2No ZWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lKTsKIAogdW5pb24gaGRtaV92 ZW5kb3JfYW55X2luZm9mcmFtZSB7CiAJc3RydWN0IHsKQEAgLTMzMCw4ICszNDIsMTEgQEAgdW5p b24gaGRtaV9pbmZvZnJhbWUgewogCXN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSBhdWRpbzsK IH07CiAKLXNzaXplX3QKLWhkbWlfaW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV9pbmZvZnJhbWUg KmZyYW1lLCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKK3NzaXplX3QgaGRtaV9pbmZvZnJh bWVfcGFjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwKKwkJCSAg ICBzaXplX3Qgc2l6ZSk7Citzc2l6ZV90IGhkbWlfaW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCB1 bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsCisJCQkJIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNp emUpOworaW50IGhkbWlfaW5mb2ZyYW1lX2NoZWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFt ZSk7CiBpbnQgaGRtaV9pbmZvZnJhbWVfdW5wYWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFt ZSwKIAkJCSAgY29uc3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7CiB2b2lkIGhkbWlfaW5m b2ZyYW1lX2xvZyhjb25zdCBjaGFyICpsZXZlbCwgc3RydWN0IGRldmljZSAqZGV2LAotLSAKMi4x Ni40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRl bC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6 Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga05.intel.com ([192.55.52.43]:19952 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727171AbeIUAgy (ORCPT ); Thu, 20 Sep 2018 20:36:54 -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 04/18] video/hdmi: Constify infoframe passed to the pack functions Date: Thu, 20 Sep 2018 21:51:31 +0300 Message-Id: <20180920185145.1912-5-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ä Let's make the infoframe pack functions usable with a const infoframe structure. This allows us to precompute the infoframe earlier, and still pack it later when we're no longer allowed to modify the structure. So now we end up with a _check()+_pack_only() or _pack() functions depending on whether you want to precompute the infoframes or not. The names aren't greate but I was lazy and didn't want to change all the drivers. v2: Deal with exynos churn Actually export the new funcs Cc: Thierry Reding Cc: Hans Verkuil Cc: linux-media@vger.kernel.org Signed-off-by: Ville Syrjälä --- drivers/video/hdmi.c | 425 +++++++++++++++++++++++++++++++++++++++++++++++---- include/linux/hdmi.h | 19 ++- 2 files changed, 416 insertions(+), 28 deletions(-) diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c index 53e7ee2c83fc..9507f668a569 100644 --- a/drivers/video/hdmi.c +++ b/drivers/video/hdmi.c @@ -68,8 +68,36 @@ int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame) } EXPORT_SYMBOL(hdmi_avi_infoframe_init); +static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe *frame) +{ + if (frame->type != HDMI_INFOFRAME_TYPE_AVI || + frame->version != 2 || + frame->length != HDMI_AVI_INFOFRAME_SIZE) + return -EINVAL; + + if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9) + return -EINVAL; + + return 0; +} + /** - * hdmi_avi_infoframe_pack() - write HDMI AVI infoframe to binary buffer + * hdmi_avi_infoframe_check() - Check and check a HDMI AVI infoframe + * @frame: HDMI AVI infoframe + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields. + * + * Returns 0 on success or a negative error code on failure. + */ +int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame) +{ + return hdmi_avi_infoframe_check_only(frame); +} +EXPORT_SYMBOL(hdmi_avi_infoframe_check); + +/** + * hdmi_avi_infoframe_pack_only() - write HDMI AVI infoframe to binary buffer * @frame: HDMI AVI infoframe * @buffer: destination buffer * @size: size of buffer @@ -82,20 +110,22 @@ EXPORT_SYMBOL(hdmi_avi_infoframe_init); * Returns the number of bytes packed into the binary buffer or a negative * error code on failure. */ -ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, - size_t size) +ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame, + void *buffer, size_t size) { u8 *ptr = buffer; size_t length; + int ret; + + ret = hdmi_avi_infoframe_check_only(frame); + if (ret) + return ret; length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; if (size < length) return -ENOSPC; - if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9) - return -EINVAL; - memset(buffer, 0, size); ptr[0] = frame->type; @@ -152,6 +182,36 @@ ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, return length; } +EXPORT_SYMBOL(hdmi_avi_infoframe_pack_only); + +/** + * hdmi_avi_infoframe_pack() - Check and check a HDMI AVI infoframe, + * and write it to binary buffer + * @frame: HDMI AVI infoframe + * @buffer: destination buffer + * @size: size of buffer + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields, after which packs the information + * contained in the @frame structure into a binary representation that + * can be written into the corresponding controller registers. Also + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 + * specification. + * + * Returns the number of bytes packed into the binary buffer or a negative + * error code on failure. + */ +ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, + void *buffer, size_t size) +{ + int ret; + + ret = hdmi_avi_infoframe_check(frame); + if (ret) + return ret; + + return hdmi_avi_infoframe_pack_only(frame, buffer, size); +} EXPORT_SYMBOL(hdmi_avi_infoframe_pack); /** @@ -178,8 +238,33 @@ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, } EXPORT_SYMBOL(hdmi_spd_infoframe_init); +static int hdmi_spd_infoframe_check_only(const struct hdmi_spd_infoframe *frame) +{ + if (frame->type != HDMI_INFOFRAME_TYPE_SPD || + frame->version != 1 || + frame->length != HDMI_SPD_INFOFRAME_SIZE) + return -EINVAL; + + return 0; +} + /** - * hdmi_spd_infoframe_pack() - write HDMI SPD infoframe to binary buffer + * hdmi_spd_infoframe_check() - Check and check a HDMI SPD infoframe + * @frame: HDMI SPD infoframe + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields. + * + * Returns 0 on success or a negative error code on failure. + */ +int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame) +{ + return hdmi_spd_infoframe_check_only(frame); +} +EXPORT_SYMBOL(hdmi_spd_infoframe_check); + +/** + * hdmi_spd_infoframe_pack_only() - write HDMI SPD infoframe to binary buffer * @frame: HDMI SPD infoframe * @buffer: destination buffer * @size: size of buffer @@ -192,11 +277,16 @@ EXPORT_SYMBOL(hdmi_spd_infoframe_init); * Returns the number of bytes packed into the binary buffer or a negative * error code on failure. */ -ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, - size_t size) +ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame, + void *buffer, size_t size) { u8 *ptr = buffer; size_t length; + int ret; + + ret = hdmi_spd_infoframe_check_only(frame); + if (ret) + return ret; length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; @@ -222,6 +312,36 @@ ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, return length; } +EXPORT_SYMBOL(hdmi_spd_infoframe_pack_only); + +/** + * hdmi_spd_infoframe_pack() - Check and check a HDMI SPD infoframe, + * and write it to binary buffer + * @frame: HDMI SPD infoframe + * @buffer: destination buffer + * @size: size of buffer + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields, after which packs the information + * contained in the @frame structure into a binary representation that + * can be written into the corresponding controller registers. Also + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 + * specification. + * + * Returns the number of bytes packed into the binary buffer or a negative + * error code on failure. + */ +ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, + void *buffer, size_t size) +{ + int ret; + + ret = hdmi_spd_infoframe_check(frame); + if (ret) + return ret; + + return hdmi_spd_infoframe_pack_only(frame, buffer, size); +} EXPORT_SYMBOL(hdmi_spd_infoframe_pack); /** @@ -242,8 +362,33 @@ int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame) } EXPORT_SYMBOL(hdmi_audio_infoframe_init); +static int hdmi_audio_infoframe_check_only(const struct hdmi_audio_infoframe *frame) +{ + if (frame->type != HDMI_INFOFRAME_TYPE_AUDIO || + frame->version != 1 || + frame->length != HDMI_AUDIO_INFOFRAME_SIZE) + return -EINVAL; + + return 0; +} + +/** + * hdmi_audio_infoframe_check() - Check and check a HDMI audio infoframe + * @frame: HDMI audio infoframe + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields. + * + * Returns 0 on success or a negative error code on failure. + */ +int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe *frame) +{ + return hdmi_audio_infoframe_check_only(frame); +} +EXPORT_SYMBOL(hdmi_audio_infoframe_check); + /** - * hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer + * hdmi_audio_infoframe_pack_only() - write HDMI audio infoframe to binary buffer * @frame: HDMI audio infoframe * @buffer: destination buffer * @size: size of buffer @@ -256,12 +401,17 @@ EXPORT_SYMBOL(hdmi_audio_infoframe_init); * Returns the number of bytes packed into the binary buffer or a negative * error code on failure. */ -ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, - void *buffer, size_t size) +ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame, + void *buffer, size_t size) { unsigned char channels; u8 *ptr = buffer; size_t length; + int ret; + + ret = hdmi_audio_infoframe_check_only(frame); + if (ret) + return ret; length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; @@ -297,6 +447,36 @@ ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, return length; } +EXPORT_SYMBOL(hdmi_audio_infoframe_pack_only); + +/** + * hdmi_audio_infoframe_pack() - Check and check a HDMI Audio infoframe, + * and write it to binary buffer + * @frame: HDMI Audio infoframe + * @buffer: destination buffer + * @size: size of buffer + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields, after which packs the information + * contained in the @frame structure into a binary representation that + * can be written into the corresponding controller registers. Also + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 + * specification. + * + * Returns the number of bytes packed into the binary buffer or a negative + * error code on failure. + */ +ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, + void *buffer, size_t size) +{ + int ret; + + ret = hdmi_audio_infoframe_check(frame); + if (ret) + return ret; + + return hdmi_audio_infoframe_pack_only(frame, buffer, size); +} EXPORT_SYMBOL(hdmi_audio_infoframe_pack); /** @@ -319,6 +499,7 @@ int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame) * value */ frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID; + frame->length = 4; return 0; } @@ -335,8 +516,42 @@ static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *fram return 4; } +static int hdmi_vendor_infoframe_check_only(const struct hdmi_vendor_infoframe *frame) +{ + if (frame->type != HDMI_INFOFRAME_TYPE_VENDOR || + frame->version != 1 || + frame->oui != HDMI_IEEE_OUI) + return -EINVAL; + + /* only one of those can be supplied */ + if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) + return -EINVAL; + + if (frame->length != hdmi_vendor_infoframe_length(frame)) + return -EINVAL; + + return 0; +} + /** - * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer + * hdmi_vendor_infoframe_check() - Check and check a HDMI vendor infoframe + * @frame: HDMI infoframe + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields. + * + * Returns 0 on success or a negative error code on failure. + */ +int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame) +{ + frame->length = hdmi_vendor_infoframe_length(frame); + + return hdmi_vendor_infoframe_check_only(frame); +} +EXPORT_SYMBOL(hdmi_vendor_infoframe_check); + +/** + * hdmi_vendor_infoframe_pack_only() - write a HDMI vendor infoframe to binary buffer * @frame: HDMI infoframe * @buffer: destination buffer * @size: size of buffer @@ -349,17 +564,16 @@ static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *fram * Returns the number of bytes packed into the binary buffer or a negative * error code on failure. */ -ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, - void *buffer, size_t size) +ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame, + void *buffer, size_t size) { u8 *ptr = buffer; size_t length; + int ret; - /* only one of those can be supplied */ - if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) - return -EINVAL; - - frame->length = hdmi_vendor_infoframe_length(frame); + ret = hdmi_vendor_infoframe_check_only(frame); + if (ret) + return ret; length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; @@ -394,24 +608,134 @@ ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, return length; } +EXPORT_SYMBOL(hdmi_vendor_infoframe_pack_only); + +/** + * hdmi_vendor_infoframe_pack() - Check and check a HDMI Vendor infoframe, + * and write it to binary buffer + * @frame: HDMI Vendor infoframe + * @buffer: destination buffer + * @size: size of buffer + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields, after which packs the information + * contained in the @frame structure into a binary representation that + * can be written into the corresponding controller registers. Also + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 + * specification. + * + * Returns the number of bytes packed into the binary buffer or a negative + * error code on failure. + */ +ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, + void *buffer, size_t size) +{ + int ret; + + ret = hdmi_vendor_infoframe_check(frame); + if (ret) + return ret; + + return hdmi_vendor_infoframe_pack_only(frame, buffer, size); +} EXPORT_SYMBOL(hdmi_vendor_infoframe_pack); +static int +hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe *frame) +{ + if (frame->any.type != HDMI_INFOFRAME_TYPE_VENDOR || + frame->any.version != 1) + return -EINVAL; + + return 0; +} + /* - * hdmi_vendor_any_infoframe_pack() - write a vendor infoframe to binary buffer + * hdmi_vendor_any_infoframe_check() - check and check a vendor infoframe + */ +static int +hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe *frame) +{ + int ret; + + ret = hdmi_vendor_any_infoframe_check_only(frame); + if (ret) + return ret; + + /* we only know about HDMI vendor infoframes */ + if (frame->any.oui != HDMI_IEEE_OUI) + return -EINVAL; + + return hdmi_vendor_infoframe_check(&frame->hdmi); +} + +/* + * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer */ static ssize_t -hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, - void *buffer, size_t size) +hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe *frame, + void *buffer, size_t size) { + int ret; + + ret = hdmi_vendor_any_infoframe_check_only(frame); + if (ret) + return ret; + /* we only know about HDMI vendor infoframes */ if (frame->any.oui != HDMI_IEEE_OUI) return -EINVAL; - return hdmi_vendor_infoframe_pack(&frame->hdmi, buffer, size); + return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size); +} + +/* + * hdmi_vendor_any_infoframe_pack() - check and check a vendor infoframe, + * and write it to binary buffer + */ +static ssize_t +hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, + void *buffer, size_t size) +{ + int ret; + + ret = hdmi_vendor_any_infoframe_check(frame); + if (ret) + return ret; + + return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size); +} + +/** + * hdmi_infoframe_check() - Check check a HDMI infoframe + * @frame: HDMI infoframe + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields. + * + * Returns 0 on success or a negative error code on failure. + */ +int +hdmi_infoframe_check(union hdmi_infoframe *frame) +{ + switch (frame->any.type) { + case HDMI_INFOFRAME_TYPE_AVI: + return hdmi_avi_infoframe_check(&frame->avi); + case HDMI_INFOFRAME_TYPE_SPD: + return hdmi_spd_infoframe_check(&frame->spd); + case HDMI_INFOFRAME_TYPE_AUDIO: + return hdmi_audio_infoframe_check(&frame->audio); + case HDMI_INFOFRAME_TYPE_VENDOR: + return hdmi_vendor_any_infoframe_check(&frame->vendor); + default: + WARN(1, "Bad infoframe type %d\n", frame->any.type); + return -EINVAL; + } } +EXPORT_SYMBOL(hdmi_infoframe_check); /** - * hdmi_infoframe_pack() - write a HDMI infoframe to binary buffer + * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer * @frame: HDMI infoframe * @buffer: destination buffer * @size: size of buffer @@ -425,7 +749,56 @@ hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, * error code on failure. */ ssize_t -hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size) +hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size) +{ + ssize_t length; + + switch (frame->any.type) { + case HDMI_INFOFRAME_TYPE_AVI: + length = hdmi_avi_infoframe_pack_only(&frame->avi, + buffer, size); + break; + case HDMI_INFOFRAME_TYPE_SPD: + length = hdmi_spd_infoframe_pack_only(&frame->spd, + buffer, size); + break; + case HDMI_INFOFRAME_TYPE_AUDIO: + length = hdmi_audio_infoframe_pack_only(&frame->audio, + buffer, size); + break; + case HDMI_INFOFRAME_TYPE_VENDOR: + length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor, + buffer, size); + break; + default: + WARN(1, "Bad infoframe type %d\n", frame->any.type); + length = -EINVAL; + } + + return length; +} +EXPORT_SYMBOL(hdmi_infoframe_pack_only); + +/** + * hdmi_infoframe_pack() - Check check a HDMI infoframe, + * and write it to binary buffer + * @frame: HDMI infoframe + * @buffer: destination buffer + * @size: size of buffer + * + * Validates that the infoframe is consistent and updates derived fields + * (eg. length) based on other fields, after which packs the information + * contained in the @frame structure into a binary representation that + * can be written into the corresponding controller registers. Also + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 + * specification. + * + * Returns the number of bytes packed into the binary buffer or a negative + * error code on failure. + */ +ssize_t +hdmi_infoframe_pack(union hdmi_infoframe *frame, + void *buffer, size_t size) { ssize_t length; diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h index bce1abb1fe57..c76b50a48e48 100644 --- a/include/linux/hdmi.h +++ b/include/linux/hdmi.h @@ -163,6 +163,9 @@ struct hdmi_avi_infoframe { int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame); ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, size_t size); +ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame, + void *buffer, size_t size); +int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame); enum hdmi_spd_sdi { HDMI_SPD_SDI_UNKNOWN, @@ -194,6 +197,9 @@ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, const char *vendor, const char *product); ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, size_t size); +ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame, + void *buffer, size_t size); +int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame); enum hdmi_audio_coding_type { HDMI_AUDIO_CODING_TYPE_STREAM, @@ -272,6 +278,9 @@ struct hdmi_audio_infoframe { int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame); ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, void *buffer, size_t size); +ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame, + void *buffer, size_t size); +int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe *frame); enum hdmi_3d_structure { HDMI_3D_STRUCTURE_INVALID = -1, @@ -299,6 +308,9 @@ struct hdmi_vendor_infoframe { int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame); ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, void *buffer, size_t size); +ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame, + void *buffer, size_t size); +int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame); union hdmi_vendor_any_infoframe { struct { @@ -330,8 +342,11 @@ union hdmi_infoframe { struct hdmi_audio_infoframe audio; }; -ssize_t -hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size); +ssize_t hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, + size_t size); +ssize_t hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, + void *buffer, size_t size); +int hdmi_infoframe_check(union hdmi_infoframe *frame); int hdmi_infoframe_unpack(union hdmi_infoframe *frame, const void *buffer, size_t size); void hdmi_infoframe_log(const char *level, struct device *dev, -- 2.16.4