From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sakari Ailus Subject: [PATCH v3 07/23] v4l: fwnode: Let the caller provide V4L2 fwnode endpoint Date: Thu, 13 Sep 2018 00:29:26 +0300 Message-ID: <20180912212942.19641-8-sakari.ailus@linux.intel.com> References: <20180912212942.19641-1-sakari.ailus@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180912212942.19641-1-sakari.ailus@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-media@vger.kernel.org Cc: devicetree@vger.kernel.org, jacopo@jmondi.org, dri-devel@lists.freedesktop.org, slongerbeam@gmail.com, niklas.soderlund@ragnatech.se List-Id: devicetree@vger.kernel.org SW5zdGVhZCBvZiBhbGxvY2F0aW5nIHRoZSBWNEwyIGZ3bm9kZSBlbmRwb2ludCBpbgp2NGwyX2Z3 bm9kZV9lbmRwb2ludF9hbGxvY19wYXJzZSwgbGV0IHRoZSBjYWxsZXIgdG8gZG8gdGhpcy4gVGhp cyBhbGxvd3MKc2V0dGluZyBkZWZhdWx0IHBhcmFtZXRlcnMgZm9yIHRoZSBlbmRwb2ludCB3aGlj aCBpcyBhIHZlcnkgY29tbW9uIG5lZWQKZm9yIGRyaXZlcnMuCgpTaWduZWQtb2ZmLWJ5OiBTYWth cmkgQWlsdXMgPHNha2FyaS5haWx1c0BsaW51eC5pbnRlbC5jb20+ClRlc3RlZC1ieTogU3RldmUg TG9uZ2VyYmVhbSA8c3RldmVfbG9uZ2VyYmVhbUBtZW50b3IuY29tPgotLS0KIGRyaXZlcnMvbWVk aWEvaTJjL292MjY1OS5jICAgICAgICAgICAgIHwgMTQgKysrKystLS0tLQogZHJpdmVycy9tZWRp YS9pMmMvc21pYXBwL3NtaWFwcC1jb3JlLmMgfCAyNiArKysrKysrKystLS0tLS0tLS0KIGRyaXZl cnMvbWVkaWEvaTJjL3RjMzU4NzQzLmMgICAgICAgICAgIHwgMjYgKysrKysrKysrLS0tLS0tLS0t CiBkcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWZ3bm9kZS5jICB8IDQ5ICsrKysrKysrKysr KystLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGluY2x1ZGUvbWVkaWEvdjRsMi1md25vZGUuaCAgICAg ICAgICAgIHwgMTAgKysrKy0tLQogNSBmaWxlcyBjaGFuZ2VkLCA2MCBpbnNlcnRpb25zKCspLCA2 NSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2kyYy9vdjI2NTkuYyBi L2RyaXZlcnMvbWVkaWEvaTJjL292MjY1OS5jCmluZGV4IDQ3MTVlZGM4Y2EzMy4uNzk5YWNjZTgw M2ZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2kyYy9vdjI2NTkuYworKysgYi9kcml2ZXJz L21lZGlhL2kyYy9vdjI2NTkuYwpAQCAtMTM0Nyw4ICsxMzQ3LDkgQEAgc3RhdGljIHN0cnVjdCBv djI2NTlfcGxhdGZvcm1fZGF0YSAqCiBvdjI2NTlfZ2V0X3BkYXRhKHN0cnVjdCBpMmNfY2xpZW50 ICpjbGllbnQpCiB7CiAJc3RydWN0IG92MjY1OV9wbGF0Zm9ybV9kYXRhICpwZGF0YTsKLQlzdHJ1 Y3QgdjRsMl9md25vZGVfZW5kcG9pbnQgKmJ1c19jZmc7CisJc3RydWN0IHY0bDJfZndub2RlX2Vu ZHBvaW50IGJ1c19jZmcgPSB7IC5idXNfdHlwZSA9IDAgfTsKIAlzdHJ1Y3QgZGV2aWNlX25vZGUg KmVuZHBvaW50OworCWludCByZXQ7CiAKIAlpZiAoIUlTX0VOQUJMRUQoQ09ORklHX09GKSB8fCAh Y2xpZW50LT5kZXYub2Zfbm9kZSkKIAkJcmV0dXJuIGNsaWVudC0+ZGV2LnBsYXRmb3JtX2RhdGE7 CkBAIC0xMzU3LDggKzEzNTgsOSBAQCBvdjI2NTlfZ2V0X3BkYXRhKHN0cnVjdCBpMmNfY2xpZW50 ICpjbGllbnQpCiAJaWYgKCFlbmRwb2ludCkKIAkJcmV0dXJuIE5VTEw7CiAKLQlidXNfY2ZnID0g djRsMl9md25vZGVfZW5kcG9pbnRfYWxsb2NfcGFyc2Uob2ZfZndub2RlX2hhbmRsZShlbmRwb2lu dCkpOwotCWlmIChJU19FUlIoYnVzX2NmZykpIHsKKwlyZXQgPSB2NGwyX2Z3bm9kZV9lbmRwb2lu dF9hbGxvY19wYXJzZShvZl9md25vZGVfaGFuZGxlKGVuZHBvaW50KSwKKwkJCQkJICAgICAgICZi dXNfY2ZnKTsKKwlpZiAocmV0KSB7CiAJCXBkYXRhID0gTlVMTDsKIAkJZ290byBkb25lOwogCX0K QEAgLTEzNjcsMTcgKzEzNjksMTcgQEAgb3YyNjU5X2dldF9wZGF0YShzdHJ1Y3QgaTJjX2NsaWVu dCAqY2xpZW50KQogCWlmICghcGRhdGEpCiAJCWdvdG8gZG9uZTsKIAotCWlmICghYnVzX2NmZy0+ bnJfb2ZfbGlua19mcmVxdWVuY2llcykgeworCWlmICghYnVzX2NmZy5ucl9vZl9saW5rX2ZyZXF1 ZW5jaWVzKSB7CiAJCWRldl9lcnIoJmNsaWVudC0+ZGV2LAogCQkJImxpbmstZnJlcXVlbmNpZXMg cHJvcGVydHkgbm90IGZvdW5kIG9yIHRvbyBtYW55XG4iKTsKIAkJcGRhdGEgPSBOVUxMOwogCQln b3RvIGRvbmU7CiAJfQogCi0JcGRhdGEtPmxpbmtfZnJlcXVlbmN5ID0gYnVzX2NmZy0+bGlua19m cmVxdWVuY2llc1swXTsKKwlwZGF0YS0+bGlua19mcmVxdWVuY3kgPSBidXNfY2ZnLmxpbmtfZnJl cXVlbmNpZXNbMF07CiAKIGRvbmU6Ci0JdjRsMl9md25vZGVfZW5kcG9pbnRfZnJlZShidXNfY2Zn KTsKKwl2NGwyX2Z3bm9kZV9lbmRwb2ludF9mcmVlKCZidXNfY2ZnKTsKIAlvZl9ub2RlX3B1dChl bmRwb2ludCk7CiAJcmV0dXJuIHBkYXRhOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9p MmMvc21pYXBwL3NtaWFwcC1jb3JlLmMgYi9kcml2ZXJzL21lZGlhL2kyYy9zbWlhcHAvc21pYXBw LWNvcmUuYwppbmRleCA5ZTMzYzIwMDhiYTYuLjA0OGFiNmNmYWE5NyAxMDA2NDQKLS0tIGEvZHJp dmVycy9tZWRpYS9pMmMvc21pYXBwL3NtaWFwcC1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS9p MmMvc21pYXBwL3NtaWFwcC1jb3JlLmMKQEAgLTI3NjEsNyArMjc2MSw3IEBAIHN0YXRpYyBpbnQg X19tYXliZV91bnVzZWQgc21pYXBwX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiBzdGF0aWMg c3RydWN0IHNtaWFwcF9od2NvbmZpZyAqc21pYXBwX2dldF9od2NvbmZpZyhzdHJ1Y3QgZGV2aWNl ICpkZXYpCiB7CiAJc3RydWN0IHNtaWFwcF9od2NvbmZpZyAqaHdjZmc7Ci0Jc3RydWN0IHY0bDJf Zndub2RlX2VuZHBvaW50ICpidXNfY2ZnOworCXN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2ludCBi dXNfY2ZnID0geyAuYnVzX3R5cGUgPSAwIH07CiAJc3RydWN0IGZ3bm9kZV9oYW5kbGUgKmVwOwog CXN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUgPSBkZXZfZndub2RlKGRldik7CiAJdTMyIHJv dGF0aW9uOwpAQCAtMjc3NSwyNyArMjc3NSwyNyBAQCBzdGF0aWMgc3RydWN0IHNtaWFwcF9od2Nv bmZpZyAqc21pYXBwX2dldF9od2NvbmZpZyhzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJaWYgKCFlcCkK IAkJcmV0dXJuIE5VTEw7CiAKLQlidXNfY2ZnID0gdjRsMl9md25vZGVfZW5kcG9pbnRfYWxsb2Nf cGFyc2UoZXApOwotCWlmIChJU19FUlIoYnVzX2NmZykpCisJcnZhbCA9IHY0bDJfZndub2RlX2Vu ZHBvaW50X2FsbG9jX3BhcnNlKGVwLCAmYnVzX2NmZyk7CisJaWYgKHJ2YWwpCiAJCWdvdG8gb3V0 X2VycjsKIAogCWh3Y2ZnID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpod2NmZyksIEdGUF9L RVJORUwpOwogCWlmICghaHdjZmcpCiAJCWdvdG8gb3V0X2VycjsKIAotCXN3aXRjaCAoYnVzX2Nm Zy0+YnVzX3R5cGUpIHsKKwlzd2l0Y2ggKGJ1c19jZmcuYnVzX3R5cGUpIHsKIAljYXNlIFY0TDJf TUJVU19DU0kyX0RQSFk6CiAJCWh3Y2ZnLT5jc2lfc2lnbmFsbGluZ19tb2RlID0gU01JQVBQX0NT SV9TSUdOQUxMSU5HX01PREVfQ1NJMjsKLQkJaHdjZmctPmxhbmVzID0gYnVzX2NmZy0+YnVzLm1p cGlfY3NpMi5udW1fZGF0YV9sYW5lczsKKwkJaHdjZmctPmxhbmVzID0gYnVzX2NmZy5idXMubWlw aV9jc2kyLm51bV9kYXRhX2xhbmVzOwogCQlicmVhazsKIAljYXNlIFY0TDJfTUJVU19DQ1AyOgot CQlod2NmZy0+Y3NpX3NpZ25hbGxpbmdfbW9kZSA9IChidXNfY2ZnLT5idXMubWlwaV9jc2kxLnN0 cm9iZSkgPworCQlod2NmZy0+Y3NpX3NpZ25hbGxpbmdfbW9kZSA9IChidXNfY2ZnLmJ1cy5taXBp X2NzaTEuc3Ryb2JlKSA/CiAJCVNNSUFQUF9DU0lfU0lHTkFMTElOR19NT0RFX0NDUDJfREFUQV9T VFJPQkUgOgogCQlTTUlBUFBfQ1NJX1NJR05BTExJTkdfTU9ERV9DQ1AyX0RBVEFfQ0xPQ0s7CiAJ CWh3Y2ZnLT5sYW5lcyA9IDE7CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCWRldl9lcnIoZGV2LCAi dW5zdXBwb3J0ZWQgYnVzICV1XG4iLCBidXNfY2ZnLT5idXNfdHlwZSk7CisJCWRldl9lcnIoZGV2 LCAidW5zdXBwb3J0ZWQgYnVzICV1XG4iLCBidXNfY2ZnLmJ1c190eXBlKTsKIAkJZ290byBvdXRf ZXJyOwogCX0KIApAQCAtMjgyNywyOCArMjgyNywyOCBAQCBzdGF0aWMgc3RydWN0IHNtaWFwcF9o d2NvbmZpZyAqc21pYXBwX2dldF9od2NvbmZpZyhzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJZGV2X2Ri ZyhkZXYsICJudm0gJWQsIGNsayAlZCwgbW9kZSAlZFxuIiwKIAkJaHdjZmctPm52bV9zaXplLCBo d2NmZy0+ZXh0X2NsaywgaHdjZmctPmNzaV9zaWduYWxsaW5nX21vZGUpOwogCi0JaWYgKCFidXNf Y2ZnLT5ucl9vZl9saW5rX2ZyZXF1ZW5jaWVzKSB7CisJaWYgKCFidXNfY2ZnLm5yX29mX2xpbmtf ZnJlcXVlbmNpZXMpIHsKIAkJZGV2X3dhcm4oZGV2LCAibm8gbGluayBmcmVxdWVuY2llcyBkZWZp bmVkXG4iKTsKIAkJZ290byBvdXRfZXJyOwogCX0KIAogCWh3Y2ZnLT5vcF9zeXNfY2xvY2sgPSBk ZXZtX2tjYWxsb2MoCi0JCWRldiwgYnVzX2NmZy0+bnJfb2ZfbGlua19mcmVxdWVuY2llcyArIDEg LyogZ3VhcmRpYW4gKi8sCisJCWRldiwgYnVzX2NmZy5ucl9vZl9saW5rX2ZyZXF1ZW5jaWVzICsg MSAvKiBndWFyZGlhbiAqLywKIAkJc2l6ZW9mKCpod2NmZy0+b3Bfc3lzX2Nsb2NrKSwgR0ZQX0tF Uk5FTCk7CiAJaWYgKCFod2NmZy0+b3Bfc3lzX2Nsb2NrKQogCQlnb3RvIG91dF9lcnI7CiAKLQlm b3IgKGkgPSAwOyBpIDwgYnVzX2NmZy0+bnJfb2ZfbGlua19mcmVxdWVuY2llczsgaSsrKSB7Ci0J CWh3Y2ZnLT5vcF9zeXNfY2xvY2tbaV0gPSBidXNfY2ZnLT5saW5rX2ZyZXF1ZW5jaWVzW2ldOwor CWZvciAoaSA9IDA7IGkgPCBidXNfY2ZnLm5yX29mX2xpbmtfZnJlcXVlbmNpZXM7IGkrKykgewor CQlod2NmZy0+b3Bfc3lzX2Nsb2NrW2ldID0gYnVzX2NmZy5saW5rX2ZyZXF1ZW5jaWVzW2ldOwog CQlkZXZfZGJnKGRldiwgImZyZXEgJWQ6ICVsbGRcbiIsIGksIGh3Y2ZnLT5vcF9zeXNfY2xvY2tb aV0pOwogCX0KIAotCXY0bDJfZndub2RlX2VuZHBvaW50X2ZyZWUoYnVzX2NmZyk7CisJdjRsMl9m d25vZGVfZW5kcG9pbnRfZnJlZSgmYnVzX2NmZyk7CiAJZndub2RlX2hhbmRsZV9wdXQoZXApOwog CXJldHVybiBod2NmZzsKIAogb3V0X2VycjoKLQl2NGwyX2Z3bm9kZV9lbmRwb2ludF9mcmVlKGJ1 c19jZmcpOworCXY0bDJfZndub2RlX2VuZHBvaW50X2ZyZWUoJmJ1c19jZmcpOwogCWZ3bm9kZV9o YW5kbGVfcHV0KGVwKTsKIAlyZXR1cm4gTlVMTDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVk aWEvaTJjL3RjMzU4NzQzLmMgYi9kcml2ZXJzL21lZGlhL2kyYy90YzM1ODc0My5jCmluZGV4IDZh MjA2NDU5NzEyNC4uODQwMmQ1NDBlYjhjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2kyYy90 YzM1ODc0My5jCisrKyBiL2RyaXZlcnMvbWVkaWEvaTJjL3RjMzU4NzQzLmMKQEAgLTE4OTUsMTEg KzE4OTUsMTEgQEAgc3RhdGljIHZvaWQgdGMzNTg3NDNfZ3Bpb19yZXNldChzdHJ1Y3QgdGMzNTg3 NDNfc3RhdGUgKnN0YXRlKQogc3RhdGljIGludCB0YzM1ODc0M19wcm9iZV9vZihzdHJ1Y3QgdGMz NTg3NDNfc3RhdGUgKnN0YXRlKQogewogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZzdGF0ZS0+aTJj X2NsaWVudC0+ZGV2OwotCXN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2ludCAqZW5kcG9pbnQ7CisJ c3RydWN0IHY0bDJfZndub2RlX2VuZHBvaW50IGVuZHBvaW50ID0geyAuYnVzX3R5cGUgPSAwIH07 CiAJc3RydWN0IGRldmljZV9ub2RlICplcDsKIAlzdHJ1Y3QgY2xrICpyZWZjbGs7CiAJdTMyIGJw c19wcl9sYW5lOwotCWludCByZXQgPSAtRUlOVkFMOworCWludCByZXQ7CiAKIAlyZWZjbGsgPSBk ZXZtX2Nsa19nZXQoZGV2LCAicmVmY2xrIik7CiAJaWYgKElTX0VSUihyZWZjbGspKSB7CkBAIC0x OTE1LDI2ICsxOTE1LDI4IEBAIHN0YXRpYyBpbnQgdGMzNTg3NDNfcHJvYmVfb2Yoc3RydWN0IHRj MzU4NzQzX3N0YXRlICpzdGF0ZSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0JZW5kcG9pbnQg PSB2NGwyX2Z3bm9kZV9lbmRwb2ludF9hbGxvY19wYXJzZShvZl9md25vZGVfaGFuZGxlKGVwKSk7 Ci0JaWYgKElTX0VSUihlbmRwb2ludCkpIHsKKwlyZXQgPSB2NGwyX2Z3bm9kZV9lbmRwb2ludF9h bGxvY19wYXJzZShvZl9md25vZGVfaGFuZGxlKGVwKSwgJmVuZHBvaW50KTsKKwlpZiAocmV0KSB7 CiAJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHBhcnNlIGVuZHBvaW50XG4iKTsKLQkJcmV0ID0g UFRSX0VSUihlbmRwb2ludCk7CisJCXJldCA9IHJldDsKIAkJZ290byBwdXRfbm9kZTsKIAl9CiAK LQlpZiAoZW5kcG9pbnQtPmJ1c190eXBlICE9IFY0TDJfTUJVU19DU0kyX0RQSFkgfHwKLQkgICAg ZW5kcG9pbnQtPmJ1cy5taXBpX2NzaTIubnVtX2RhdGFfbGFuZXMgPT0gMCB8fAotCSAgICBlbmRw b2ludC0+bnJfb2ZfbGlua19mcmVxdWVuY2llcyA9PSAwKSB7CisJaWYgKGVuZHBvaW50LmJ1c190 eXBlICE9IFY0TDJfTUJVU19DU0kyX0RQSFkgfHwKKwkgICAgZW5kcG9pbnQuYnVzLm1pcGlfY3Np Mi5udW1fZGF0YV9sYW5lcyA9PSAwIHx8CisJICAgIGVuZHBvaW50Lm5yX29mX2xpbmtfZnJlcXVl bmNpZXMgPT0gMCkgewogCQlkZXZfZXJyKGRldiwgIm1pc3NpbmcgQ1NJLTIgcHJvcGVydGllcyBp biBlbmRwb2ludFxuIik7CisJCXJldCA9IC1FSU5WQUw7CiAJCWdvdG8gZnJlZV9lbmRwb2ludDsK IAl9CiAKLQlpZiAoZW5kcG9pbnQtPmJ1cy5taXBpX2NzaTIubnVtX2RhdGFfbGFuZXMgPiA0KSB7 CisJaWYgKGVuZHBvaW50LmJ1cy5taXBpX2NzaTIubnVtX2RhdGFfbGFuZXMgPiA0KSB7CiAJCWRl dl9lcnIoZGV2LCAiaW52YWxpZCBudW1iZXIgb2YgbGFuZXNcbiIpOworCQlyZXQgPSAtRUlOVkFM OwogCQlnb3RvIGZyZWVfZW5kcG9pbnQ7CiAJfQogCi0Jc3RhdGUtPmJ1cyA9IGVuZHBvaW50LT5i dXMubWlwaV9jc2kyOworCXN0YXRlLT5idXMgPSBlbmRwb2ludC5idXMubWlwaV9jc2kyOwogCiAJ cmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKHJlZmNsayk7CiAJaWYgKHJldCkgewpAQCAtMTk2Nyw3 ICsxOTY5LDcgQEAgc3RhdGljIGludCB0YzM1ODc0M19wcm9iZV9vZihzdHJ1Y3QgdGMzNTg3NDNf c3RhdGUgKnN0YXRlKQogCSAqIFRoZSBDU0kgYnBzIHBlciBsYW5lIG11c3QgYmUgYmV0d2VlbiA2 Mi41IE1icHMgYW5kIDEgR2Jwcy4KIAkgKiBUaGUgZGVmYXVsdCBpcyA1OTQgTWJwcyBmb3IgNC1s YW5lIDEwODBwNjAgb3IgMi1sYW5lIDcyMHA2MC4KIAkgKi8KLQlicHNfcHJfbGFuZSA9IDIgKiBl bmRwb2ludC0+bGlua19mcmVxdWVuY2llc1swXTsKKwlicHNfcHJfbGFuZSA9IDIgKiBlbmRwb2lu dC5saW5rX2ZyZXF1ZW5jaWVzWzBdOwogCWlmIChicHNfcHJfbGFuZSA8IDYyNTAwMDAwVSB8fCBi cHNfcHJfbGFuZSA+IDEwMDAwMDAwMDBVKSB7CiAJCWRldl9lcnIoZGV2LCAidW5zdXBwb3J0ZWQg YnBzIHBlciBsYW5lOiAldSBicHNcbiIsIGJwc19wcl9sYW5lKTsKIAkJZ290byBkaXNhYmxlX2Ns azsKQEAgLTIwMTMsNyArMjAxNSw3IEBAIHN0YXRpYyBpbnQgdGMzNTg3NDNfcHJvYmVfb2Yoc3Ry dWN0IHRjMzU4NzQzX3N0YXRlICpzdGF0ZSkKIGRpc2FibGVfY2xrOgogCWNsa19kaXNhYmxlX3Vu cHJlcGFyZShyZWZjbGspOwogZnJlZV9lbmRwb2ludDoKLQl2NGwyX2Z3bm9kZV9lbmRwb2ludF9m cmVlKGVuZHBvaW50KTsKKwl2NGwyX2Z3bm9kZV9lbmRwb2ludF9mcmVlKCZlbmRwb2ludCk7CiBw dXRfbm9kZToKIAlvZl9ub2RlX3B1dChlcCk7CiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbWVkaWEvdjRsMi1jb3JlL3Y0bDItZndub2RlLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDIt Y29yZS92NGwyLWZ3bm9kZS5jCmluZGV4IDU0MTYyMjE3YmIzNi4uZDZiYTNlNWQ0MzU2IDEwMDY0 NAotLS0gYS9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWZ3bm9kZS5jCisrKyBiL2RyaXZl cnMvbWVkaWEvdjRsMi1jb3JlL3Y0bDItZndub2RlLmMKQEAgLTI5MCwyMyArMjkwLDE3IEBAIHZv aWQgdjRsMl9md25vZGVfZW5kcG9pbnRfZnJlZShzdHJ1Y3QgdjRsMl9md25vZGVfZW5kcG9pbnQg KnZlcCkKIAkJcmV0dXJuOwogCiAJa2ZyZWUodmVwLT5saW5rX2ZyZXF1ZW5jaWVzKTsKLQlrZnJl ZSh2ZXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwodjRsMl9md25vZGVfZW5kcG9pbnRfZnJlZSk7 CiAKLXN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2ludCAqdjRsMl9md25vZGVfZW5kcG9pbnRfYWxs b2NfcGFyc2UoCi0Jc3RydWN0IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSkKK2ludCB2NGwyX2Z3bm9k ZV9lbmRwb2ludF9hbGxvY19wYXJzZSgKKwlzdHJ1Y3QgZndub2RlX2hhbmRsZSAqZndub2RlLCBz dHJ1Y3QgdjRsMl9md25vZGVfZW5kcG9pbnQgKnZlcCkKIHsKLQlzdHJ1Y3QgdjRsMl9md25vZGVf ZW5kcG9pbnQgKnZlcDsKIAlpbnQgcnZhbDsKIAotCXZlcCA9IGt6YWxsb2Moc2l6ZW9mKCp2ZXAp LCBHRlBfS0VSTkVMKTsKLQlpZiAoIXZlcCkKLQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Ci0K IAlydmFsID0gX192NGwyX2Z3bm9kZV9lbmRwb2ludF9wYXJzZShmd25vZGUsIHZlcCk7CiAJaWYg KHJ2YWwgPCAwKQotCQlnb3RvIG91dF9lcnI7CisJCXJldHVybiBydmFsOwogCiAJcnZhbCA9IGZ3 bm9kZV9wcm9wZXJ0eV9yZWFkX3U2NF9hcnJheShmd25vZGUsICJsaW5rLWZyZXF1ZW5jaWVzIiwK IAkJCQkJICAgICAgTlVMTCwgMCk7CkBAIC0zMTYsMTggKzMxMCwxOCBAQCBzdHJ1Y3QgdjRsMl9m d25vZGVfZW5kcG9pbnQgKnY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3BhcnNlKAogCQl2ZXAt PmxpbmtfZnJlcXVlbmNpZXMgPQogCQkJa21hbGxvY19hcnJheShydmFsLCBzaXplb2YoKnZlcC0+ bGlua19mcmVxdWVuY2llcyksCiAJCQkJICAgICAgR0ZQX0tFUk5FTCk7Ci0JCWlmICghdmVwLT5s aW5rX2ZyZXF1ZW5jaWVzKSB7Ci0JCQlydmFsID0gLUVOT01FTTsKLQkJCWdvdG8gb3V0X2VycjsK LQkJfQorCQlpZiAoIXZlcC0+bGlua19mcmVxdWVuY2llcykKKwkJCXJldHVybiAtRU5PTUVNOwog CiAJCXZlcC0+bnJfb2ZfbGlua19mcmVxdWVuY2llcyA9IHJ2YWw7CiAKIAkJcnZhbCA9IGZ3bm9k ZV9wcm9wZXJ0eV9yZWFkX3U2NF9hcnJheSgKIAkJCWZ3bm9kZSwgImxpbmstZnJlcXVlbmNpZXMi LCB2ZXAtPmxpbmtfZnJlcXVlbmNpZXMsCiAJCQl2ZXAtPm5yX29mX2xpbmtfZnJlcXVlbmNpZXMp OwotCQlpZiAocnZhbCA8IDApCi0JCQlnb3RvIG91dF9lcnI7CisJCWlmIChydmFsIDwgMCkgewor CQkJdjRsMl9md25vZGVfZW5kcG9pbnRfZnJlZSh2ZXApOworCQkJcmV0dXJuIHJ2YWw7CisJCX0K IAogCQlmb3IgKGkgPSAwOyBpIDwgdmVwLT5ucl9vZl9saW5rX2ZyZXF1ZW5jaWVzOyBpKyspCiAJ CQlwcl9pbmZvKCJsaW5rLWZyZXF1ZW5jaWVzICV1IHZhbHVlICVsbHVcbiIsIGksCkBAIC0zMzYs MTEgKzMzMCw3IEBAIHN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2ludCAqdjRsMl9md25vZGVfZW5k cG9pbnRfYWxsb2NfcGFyc2UoCiAKIAlwcl9kZWJ1ZygiPT09PT0gZW5kIFY0TDIgZW5kcG9pbnQg cHJvcGVydGllc1xuIik7CiAKLQlyZXR1cm4gdmVwOwotCi1vdXRfZXJyOgotCXY0bDJfZndub2Rl X2VuZHBvaW50X2ZyZWUodmVwKTsKLQlyZXR1cm4gRVJSX1BUUihydmFsKTsKKwlyZXR1cm4gMDsK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKHY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3BhcnNlKTsK IApAQCAtMzkyLDkgKzM4Miw5IEBAIHN0YXRpYyBpbnQgdjRsMl9hc3luY19ub3RpZmllcl9md25v ZGVfcGFyc2VfZW5kcG9pbnQoCiAJCQkgICAgc3RydWN0IHY0bDJfZndub2RlX2VuZHBvaW50ICp2 ZXAsCiAJCQkgICAgc3RydWN0IHY0bDJfYXN5bmNfc3ViZGV2ICphc2QpKQogeworCXN0cnVjdCB2 NGwyX2Z3bm9kZV9lbmRwb2ludCB2ZXAgPSB7IC5idXNfdHlwZSA9IDAgfTsKIAlzdHJ1Y3QgdjRs Ml9hc3luY19zdWJkZXYgKmFzZDsKLQlzdHJ1Y3QgdjRsMl9md25vZGVfZW5kcG9pbnQgKnZlcDsK LQlpbnQgcmV0ID0gMDsKKwlpbnQgcmV0OwogCiAJYXNkID0ga3phbGxvYyhhc2Rfc3RydWN0X3Np emUsIEdGUF9LRVJORUwpOwogCWlmICghYXNkKQpAQCAtNDA5LDIzICszOTksMjIgQEAgc3RhdGlj IGludCB2NGwyX2FzeW5jX25vdGlmaWVyX2Z3bm9kZV9wYXJzZV9lbmRwb2ludCgKIAkJZ290byBv dXRfZXJyOwogCX0KIAotCXZlcCA9IHY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3BhcnNlKGVu ZHBvaW50KTsKLQlpZiAoSVNfRVJSKHZlcCkpIHsKLQkJcmV0ID0gUFRSX0VSUih2ZXApOworCXJl dCA9IHY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3BhcnNlKGVuZHBvaW50LCAmdmVwKTsKKwlp ZiAocmV0KSB7CiAJCWRldl93YXJuKGRldiwgInVuYWJsZSB0byBwYXJzZSBWNEwyIGZ3bm9kZSBl bmRwb2ludCAoJWQpXG4iLAogCQkJIHJldCk7CiAJCWdvdG8gb3V0X2VycjsKIAl9CiAKLQlyZXQg PSBwYXJzZV9lbmRwb2ludCA/IHBhcnNlX2VuZHBvaW50KGRldiwgdmVwLCBhc2QpIDogMDsKKwly ZXQgPSBwYXJzZV9lbmRwb2ludCA/IHBhcnNlX2VuZHBvaW50KGRldiwgJnZlcCwgYXNkKSA6IDA7 CiAJaWYgKHJldCA9PSAtRU5PVENPTk4pCi0JCWRldl9kYmcoZGV2LCAiaWdub3JpbmcgcG9ydEAl dS9lbmRwb2ludEAldVxuIiwgdmVwLT5iYXNlLnBvcnQsCi0JCQl2ZXAtPmJhc2UuaWQpOworCQlk ZXZfZGJnKGRldiwgImlnbm9yaW5nIHBvcnRAJXUvZW5kcG9pbnRAJXVcbiIsIHZlcC5iYXNlLnBv cnQsCisJCQl2ZXAuYmFzZS5pZCk7CiAJZWxzZSBpZiAocmV0IDwgMCkKIAkJZGV2X3dhcm4oZGV2 LAogCQkJICJkcml2ZXIgY291bGQgbm90IHBhcnNlIHBvcnRAJXUvZW5kcG9pbnRAJXUgKCVkKVxu IiwKLQkJCSB2ZXAtPmJhc2UucG9ydCwgdmVwLT5iYXNlLmlkLCByZXQpOwotCXY0bDJfZndub2Rl X2VuZHBvaW50X2ZyZWUodmVwKTsKKwkJCSB2ZXAuYmFzZS5wb3J0LCB2ZXAuYmFzZS5pZCwgcmV0 KTsKKwl2NGwyX2Z3bm9kZV9lbmRwb2ludF9mcmVlKCZ2ZXApOwogCWlmIChyZXQgPCAwKQogCQln b3RvIG91dF9lcnI7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbWVkaWEvdjRsMi1md25vZGUuaCBi L2luY2x1ZGUvbWVkaWEvdjRsMi1md25vZGUuaAppbmRleCA4YjQ4NzNjMzcwOTguLjRhMzcxYzNh ZDg2YyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZWRpYS92NGwyLWZ3bm9kZS5oCisrKyBiL2luY2x1 ZGUvbWVkaWEvdjRsMi1md25vZGUuaApAQCAtMTYxLDYgKzE2MSw3IEBAIHZvaWQgdjRsMl9md25v ZGVfZW5kcG9pbnRfZnJlZShzdHJ1Y3QgdjRsMl9md25vZGVfZW5kcG9pbnQgKnZlcCk7CiAvKioK ICAqIHY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3BhcnNlKCkgLSBwYXJzZSBhbGwgZndub2Rl IG5vZGUgcHJvcGVydGllcwogICogQGZ3bm9kZTogcG9pbnRlciB0byB0aGUgZW5kcG9pbnQncyBm d25vZGUgaGFuZGxlCisgKiBAdmVwOiBwb2ludGVyIHRvIHRoZSBWNEwyIGZ3bm9kZSBkYXRhIHN0 cnVjdHVyZQogICoKICAqIEFsbCBwcm9wZXJ0aWVzIGFyZSBvcHRpb25hbC4gSWYgbm9uZSBhcmUg Zm91bmQsIHdlIGRvbid0IHNldCBhbnkgZmxhZ3MuIFRoaXMKICAqIG1lYW5zIHRoZSBwb3J0IGhh cyBhIHN0YXRpYyBjb25maWd1cmF0aW9uIGFuZCBubyBwcm9wZXJ0aWVzIGhhdmUgdG8gYmUKQEAg LTE3MCw2ICsxNzEsOCBAQCB2b2lkIHY0bDJfZndub2RlX2VuZHBvaW50X2ZyZWUoc3RydWN0IHY0 bDJfZndub2RlX2VuZHBvaW50ICp2ZXApOwogICogc2V0IHRoZSBWNEwyX01CVVNfQ1NJMl9DT05U SU5VT1VTX0NMT0NLIGZsYWcuIFRoZSBjYWxsZXIgc2hvdWxkIGhvbGQgYQogICogcmVmZXJlbmNl IHRvIEBmd25vZGUuCiAgKgorICogVGhlIGNhbGxlciBtdXN0IHNldCB0aGUgYnVzX3R5cGUgZmll bGQgb2YgQHZlcCB0byB6ZXJvLgorICoKICAqIHY0bDJfZndub2RlX2VuZHBvaW50X2FsbG9jX3Bh cnNlKCkgaGFzIHR3byBpbXBvcnRhbnQgZGlmZmVyZW5jZXMgdG8KICAqIHY0bDJfZndub2RlX2Vu ZHBvaW50X3BhcnNlKCk6CiAgKgpAQCAtMTc4LDExICsxODEsMTAgQEAgdm9pZCB2NGwyX2Z3bm9k ZV9lbmRwb2ludF9mcmVlKHN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2ludCAqdmVwKTsKICAqIDIu IFRoZSBtZW1vcnkgaXQgaGFzIGFsbG9jYXRlZCB0byBzdG9yZSB0aGUgdmFyaWFibGUgc2l6ZSBk YXRhIG11c3QgYmUgZnJlZWQKICAqICAgIHVzaW5nIHY0bDJfZndub2RlX2VuZHBvaW50X2ZyZWUo KSB3aGVuIG5vIGxvbmdlciBuZWVkZWQuCiAgKgotICogUmV0dXJuOiBQb2ludGVyIHRvIHY0bDJf Zndub2RlX2VuZHBvaW50IGlmIHN1Y2Nlc3NmdWwsIG9uIGFuIGVycm9yIHBvaW50ZXIKLSAqIG9u IGVycm9yLgorICogUmV0dXJuOiAwIG9uIHN1Y2Nlc3Mgb3IgYSBuZWdhdGl2ZSBlcnJvciBjb2Rl IG9uIGZhaWx1cmUuCiAgKi8KLXN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2ludCAqdjRsMl9md25v ZGVfZW5kcG9pbnRfYWxsb2NfcGFyc2UoCi0Jc3RydWN0IGZ3bm9kZV9oYW5kbGUgKmZ3bm9kZSk7 CitpbnQgdjRsMl9md25vZGVfZW5kcG9pbnRfYWxsb2NfcGFyc2UoCisJc3RydWN0IGZ3bm9kZV9o YW5kbGUgKmZ3bm9kZSwgc3RydWN0IHY0bDJfZndub2RlX2VuZHBvaW50ICp2ZXApOwogCiAvKioK ICAqIHY0bDJfZndub2RlX3BhcnNlX2xpbmsoKSAtIHBhcnNlIGEgbGluayBiZXR3ZWVuIHR3byBl bmRwb2ludHMKLS0gCjIuMTEuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from nblzone-211-213.nblnetworks.fi ([83.145.211.213]:40960 "EHLO hillosipuli.retiisi.org.uk" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1728232AbeIMCgK (ORCPT ); Wed, 12 Sep 2018 22:36:10 -0400 From: Sakari Ailus To: linux-media@vger.kernel.org Cc: devicetree@vger.kernel.org, slongerbeam@gmail.com, niklas.soderlund@ragnatech.se, jacopo@jmondi.org, p.zabel@pengutronix.de, dri-devel@lists.freedesktop.org Subject: [PATCH v3 07/23] v4l: fwnode: Let the caller provide V4L2 fwnode endpoint Date: Thu, 13 Sep 2018 00:29:26 +0300 Message-Id: <20180912212942.19641-8-sakari.ailus@linux.intel.com> In-Reply-To: <20180912212942.19641-1-sakari.ailus@linux.intel.com> References: <20180912212942.19641-1-sakari.ailus@linux.intel.com> Sender: linux-media-owner@vger.kernel.org List-ID: Instead of allocating the V4L2 fwnode endpoint in v4l2_fwnode_endpoint_alloc_parse, let the caller to do this. This allows setting default parameters for the endpoint which is a very common need for drivers. Signed-off-by: Sakari Ailus Tested-by: Steve Longerbeam --- drivers/media/i2c/ov2659.c | 14 +++++----- drivers/media/i2c/smiapp/smiapp-core.c | 26 +++++++++--------- drivers/media/i2c/tc358743.c | 26 +++++++++--------- drivers/media/v4l2-core/v4l2-fwnode.c | 49 +++++++++++++--------------------- include/media/v4l2-fwnode.h | 10 ++++--- 5 files changed, 60 insertions(+), 65 deletions(-) diff --git a/drivers/media/i2c/ov2659.c b/drivers/media/i2c/ov2659.c index 4715edc8ca33..799acce803fe 100644 --- a/drivers/media/i2c/ov2659.c +++ b/drivers/media/i2c/ov2659.c @@ -1347,8 +1347,9 @@ static struct ov2659_platform_data * ov2659_get_pdata(struct i2c_client *client) { struct ov2659_platform_data *pdata; - struct v4l2_fwnode_endpoint *bus_cfg; + struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = 0 }; struct device_node *endpoint; + int ret; if (!IS_ENABLED(CONFIG_OF) || !client->dev.of_node) return client->dev.platform_data; @@ -1357,8 +1358,9 @@ ov2659_get_pdata(struct i2c_client *client) if (!endpoint) return NULL; - bus_cfg = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(endpoint)); - if (IS_ERR(bus_cfg)) { + ret = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(endpoint), + &bus_cfg); + if (ret) { pdata = NULL; goto done; } @@ -1367,17 +1369,17 @@ ov2659_get_pdata(struct i2c_client *client) if (!pdata) goto done; - if (!bus_cfg->nr_of_link_frequencies) { + if (!bus_cfg.nr_of_link_frequencies) { dev_err(&client->dev, "link-frequencies property not found or too many\n"); pdata = NULL; goto done; } - pdata->link_frequency = bus_cfg->link_frequencies[0]; + pdata->link_frequency = bus_cfg.link_frequencies[0]; done: - v4l2_fwnode_endpoint_free(bus_cfg); + v4l2_fwnode_endpoint_free(&bus_cfg); of_node_put(endpoint); return pdata; } diff --git a/drivers/media/i2c/smiapp/smiapp-core.c b/drivers/media/i2c/smiapp/smiapp-core.c index 9e33c2008ba6..048ab6cfaa97 100644 --- a/drivers/media/i2c/smiapp/smiapp-core.c +++ b/drivers/media/i2c/smiapp/smiapp-core.c @@ -2761,7 +2761,7 @@ static int __maybe_unused smiapp_resume(struct device *dev) static struct smiapp_hwconfig *smiapp_get_hwconfig(struct device *dev) { struct smiapp_hwconfig *hwcfg; - struct v4l2_fwnode_endpoint *bus_cfg; + struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = 0 }; struct fwnode_handle *ep; struct fwnode_handle *fwnode = dev_fwnode(dev); u32 rotation; @@ -2775,27 +2775,27 @@ static struct smiapp_hwconfig *smiapp_get_hwconfig(struct device *dev) if (!ep) return NULL; - bus_cfg = v4l2_fwnode_endpoint_alloc_parse(ep); - if (IS_ERR(bus_cfg)) + rval = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); + if (rval) goto out_err; hwcfg = devm_kzalloc(dev, sizeof(*hwcfg), GFP_KERNEL); if (!hwcfg) goto out_err; - switch (bus_cfg->bus_type) { + switch (bus_cfg.bus_type) { case V4L2_MBUS_CSI2_DPHY: hwcfg->csi_signalling_mode = SMIAPP_CSI_SIGNALLING_MODE_CSI2; - hwcfg->lanes = bus_cfg->bus.mipi_csi2.num_data_lanes; + hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes; break; case V4L2_MBUS_CCP2: - hwcfg->csi_signalling_mode = (bus_cfg->bus.mipi_csi1.strobe) ? + hwcfg->csi_signalling_mode = (bus_cfg.bus.mipi_csi1.strobe) ? SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_STROBE : SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_CLOCK; hwcfg->lanes = 1; break; default: - dev_err(dev, "unsupported bus %u\n", bus_cfg->bus_type); + dev_err(dev, "unsupported bus %u\n", bus_cfg.bus_type); goto out_err; } @@ -2827,28 +2827,28 @@ static struct smiapp_hwconfig *smiapp_get_hwconfig(struct device *dev) dev_dbg(dev, "nvm %d, clk %d, mode %d\n", hwcfg->nvm_size, hwcfg->ext_clk, hwcfg->csi_signalling_mode); - if (!bus_cfg->nr_of_link_frequencies) { + if (!bus_cfg.nr_of_link_frequencies) { dev_warn(dev, "no link frequencies defined\n"); goto out_err; } hwcfg->op_sys_clock = devm_kcalloc( - dev, bus_cfg->nr_of_link_frequencies + 1 /* guardian */, + dev, bus_cfg.nr_of_link_frequencies + 1 /* guardian */, sizeof(*hwcfg->op_sys_clock), GFP_KERNEL); if (!hwcfg->op_sys_clock) goto out_err; - for (i = 0; i < bus_cfg->nr_of_link_frequencies; i++) { - hwcfg->op_sys_clock[i] = bus_cfg->link_frequencies[i]; + for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++) { + hwcfg->op_sys_clock[i] = bus_cfg.link_frequencies[i]; dev_dbg(dev, "freq %d: %lld\n", i, hwcfg->op_sys_clock[i]); } - v4l2_fwnode_endpoint_free(bus_cfg); + v4l2_fwnode_endpoint_free(&bus_cfg); fwnode_handle_put(ep); return hwcfg; out_err: - v4l2_fwnode_endpoint_free(bus_cfg); + v4l2_fwnode_endpoint_free(&bus_cfg); fwnode_handle_put(ep); return NULL; } diff --git a/drivers/media/i2c/tc358743.c b/drivers/media/i2c/tc358743.c index 6a2064597124..8402d540eb8c 100644 --- a/drivers/media/i2c/tc358743.c +++ b/drivers/media/i2c/tc358743.c @@ -1895,11 +1895,11 @@ static void tc358743_gpio_reset(struct tc358743_state *state) static int tc358743_probe_of(struct tc358743_state *state) { struct device *dev = &state->i2c_client->dev; - struct v4l2_fwnode_endpoint *endpoint; + struct v4l2_fwnode_endpoint endpoint = { .bus_type = 0 }; struct device_node *ep; struct clk *refclk; u32 bps_pr_lane; - int ret = -EINVAL; + int ret; refclk = devm_clk_get(dev, "refclk"); if (IS_ERR(refclk)) { @@ -1915,26 +1915,28 @@ static int tc358743_probe_of(struct tc358743_state *state) return -EINVAL; } - endpoint = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(ep)); - if (IS_ERR(endpoint)) { + ret = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(ep), &endpoint); + if (ret) { dev_err(dev, "failed to parse endpoint\n"); - ret = PTR_ERR(endpoint); + ret = ret; goto put_node; } - if (endpoint->bus_type != V4L2_MBUS_CSI2_DPHY || - endpoint->bus.mipi_csi2.num_data_lanes == 0 || - endpoint->nr_of_link_frequencies == 0) { + if (endpoint.bus_type != V4L2_MBUS_CSI2_DPHY || + endpoint.bus.mipi_csi2.num_data_lanes == 0 || + endpoint.nr_of_link_frequencies == 0) { dev_err(dev, "missing CSI-2 properties in endpoint\n"); + ret = -EINVAL; goto free_endpoint; } - if (endpoint->bus.mipi_csi2.num_data_lanes > 4) { + if (endpoint.bus.mipi_csi2.num_data_lanes > 4) { dev_err(dev, "invalid number of lanes\n"); + ret = -EINVAL; goto free_endpoint; } - state->bus = endpoint->bus.mipi_csi2; + state->bus = endpoint.bus.mipi_csi2; ret = clk_prepare_enable(refclk); if (ret) { @@ -1967,7 +1969,7 @@ static int tc358743_probe_of(struct tc358743_state *state) * The CSI bps per lane must be between 62.5 Mbps and 1 Gbps. * The default is 594 Mbps for 4-lane 1080p60 or 2-lane 720p60. */ - bps_pr_lane = 2 * endpoint->link_frequencies[0]; + bps_pr_lane = 2 * endpoint.link_frequencies[0]; if (bps_pr_lane < 62500000U || bps_pr_lane > 1000000000U) { dev_err(dev, "unsupported bps per lane: %u bps\n", bps_pr_lane); goto disable_clk; @@ -2013,7 +2015,7 @@ static int tc358743_probe_of(struct tc358743_state *state) disable_clk: clk_disable_unprepare(refclk); free_endpoint: - v4l2_fwnode_endpoint_free(endpoint); + v4l2_fwnode_endpoint_free(&endpoint); put_node: of_node_put(ep); return ret; diff --git a/drivers/media/v4l2-core/v4l2-fwnode.c b/drivers/media/v4l2-core/v4l2-fwnode.c index 54162217bb36..d6ba3e5d4356 100644 --- a/drivers/media/v4l2-core/v4l2-fwnode.c +++ b/drivers/media/v4l2-core/v4l2-fwnode.c @@ -290,23 +290,17 @@ void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep) return; kfree(vep->link_frequencies); - kfree(vep); } EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_free); -struct v4l2_fwnode_endpoint *v4l2_fwnode_endpoint_alloc_parse( - struct fwnode_handle *fwnode) +int v4l2_fwnode_endpoint_alloc_parse( + struct fwnode_handle *fwnode, struct v4l2_fwnode_endpoint *vep) { - struct v4l2_fwnode_endpoint *vep; int rval; - vep = kzalloc(sizeof(*vep), GFP_KERNEL); - if (!vep) - return ERR_PTR(-ENOMEM); - rval = __v4l2_fwnode_endpoint_parse(fwnode, vep); if (rval < 0) - goto out_err; + return rval; rval = fwnode_property_read_u64_array(fwnode, "link-frequencies", NULL, 0); @@ -316,18 +310,18 @@ struct v4l2_fwnode_endpoint *v4l2_fwnode_endpoint_alloc_parse( vep->link_frequencies = kmalloc_array(rval, sizeof(*vep->link_frequencies), GFP_KERNEL); - if (!vep->link_frequencies) { - rval = -ENOMEM; - goto out_err; - } + if (!vep->link_frequencies) + return -ENOMEM; vep->nr_of_link_frequencies = rval; rval = fwnode_property_read_u64_array( fwnode, "link-frequencies", vep->link_frequencies, vep->nr_of_link_frequencies); - if (rval < 0) - goto out_err; + if (rval < 0) { + v4l2_fwnode_endpoint_free(vep); + return rval; + } for (i = 0; i < vep->nr_of_link_frequencies; i++) pr_info("link-frequencies %u value %llu\n", i, @@ -336,11 +330,7 @@ struct v4l2_fwnode_endpoint *v4l2_fwnode_endpoint_alloc_parse( pr_debug("===== end V4L2 endpoint properties\n"); - return vep; - -out_err: - v4l2_fwnode_endpoint_free(vep); - return ERR_PTR(rval); + return 0; } EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_alloc_parse); @@ -392,9 +382,9 @@ static int v4l2_async_notifier_fwnode_parse_endpoint( struct v4l2_fwnode_endpoint *vep, struct v4l2_async_subdev *asd)) { + struct v4l2_fwnode_endpoint vep = { .bus_type = 0 }; struct v4l2_async_subdev *asd; - struct v4l2_fwnode_endpoint *vep; - int ret = 0; + int ret; asd = kzalloc(asd_struct_size, GFP_KERNEL); if (!asd) @@ -409,23 +399,22 @@ static int v4l2_async_notifier_fwnode_parse_endpoint( goto out_err; } - vep = v4l2_fwnode_endpoint_alloc_parse(endpoint); - if (IS_ERR(vep)) { - ret = PTR_ERR(vep); + ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &vep); + if (ret) { dev_warn(dev, "unable to parse V4L2 fwnode endpoint (%d)\n", ret); goto out_err; } - ret = parse_endpoint ? parse_endpoint(dev, vep, asd) : 0; + ret = parse_endpoint ? parse_endpoint(dev, &vep, asd) : 0; if (ret == -ENOTCONN) - dev_dbg(dev, "ignoring port@%u/endpoint@%u\n", vep->base.port, - vep->base.id); + dev_dbg(dev, "ignoring port@%u/endpoint@%u\n", vep.base.port, + vep.base.id); else if (ret < 0) dev_warn(dev, "driver could not parse port@%u/endpoint@%u (%d)\n", - vep->base.port, vep->base.id, ret); - v4l2_fwnode_endpoint_free(vep); + vep.base.port, vep.base.id, ret); + v4l2_fwnode_endpoint_free(&vep); if (ret < 0) goto out_err; diff --git a/include/media/v4l2-fwnode.h b/include/media/v4l2-fwnode.h index 8b4873c37098..4a371c3ad86c 100644 --- a/include/media/v4l2-fwnode.h +++ b/include/media/v4l2-fwnode.h @@ -161,6 +161,7 @@ void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep); /** * v4l2_fwnode_endpoint_alloc_parse() - parse all fwnode node properties * @fwnode: pointer to the endpoint's fwnode handle + * @vep: pointer to the V4L2 fwnode data structure * * All properties are optional. If none are found, we don't set any flags. This * means the port has a static configuration and no properties have to be @@ -170,6 +171,8 @@ void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep); * set the V4L2_MBUS_CSI2_CONTINUOUS_CLOCK flag. The caller should hold a * reference to @fwnode. * + * The caller must set the bus_type field of @vep to zero. + * * v4l2_fwnode_endpoint_alloc_parse() has two important differences to * v4l2_fwnode_endpoint_parse(): * @@ -178,11 +181,10 @@ void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep); * 2. The memory it has allocated to store the variable size data must be freed * using v4l2_fwnode_endpoint_free() when no longer needed. * - * Return: Pointer to v4l2_fwnode_endpoint if successful, on an error pointer - * on error. + * Return: 0 on success or a negative error code on failure. */ -struct v4l2_fwnode_endpoint *v4l2_fwnode_endpoint_alloc_parse( - struct fwnode_handle *fwnode); +int v4l2_fwnode_endpoint_alloc_parse( + struct fwnode_handle *fwnode, struct v4l2_fwnode_endpoint *vep); /** * v4l2_fwnode_parse_link() - parse a link between two endpoints -- 2.11.0