From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752510AbeENWky (ORCPT ); Mon, 14 May 2018 18:40:54 -0400 Received: from mail-lf0-f68.google.com ([209.85.215.68]:36726 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752402AbeENWkr (ORCPT ); Mon, 14 May 2018 18:40:47 -0400 X-Google-Smtp-Source: AB8JxZrl7J8Wx+yTkoqocn2vDg8nyKzq2Eh1a/AHVVzXzv/CB4WwdMso6XHunkXW32n9+qs/Kex6Vw== From: Neil Armstrong To: airlied@linux.ie, hans.verkuil@cisco.com, lee.jones@linaro.org, olof@lixom.net, seanpaul@google.com Cc: Neil Armstrong , sadolfsson@google.com, felixe@google.com, bleung@google.com, darekm@google.com, marcheu@chromium.org, fparent@baylibre.com, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH 2/5] media: cec-notifier: Get notifier by device and connector name Date: Tue, 15 May 2018 00:40:36 +0200 Message-Id: <1526337639-3568-3-git-send-email-narmstrong@baylibre.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1526337639-3568-1-git-send-email-narmstrong@baylibre.com> References: <1526337639-3568-1-git-send-email-narmstrong@baylibre.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org In non device-tree world, we can need to get the notifier by the driver name directly and eventually defer probe if not yet created. This patch adds a variant of the get function by using the device name instead and will not create a notifier if not yet created. But the i915 driver exposes at least 2 HDMI connectors, this patch also adds the possibility to add a connector name tied to the notifier device to form a tuple and associate different CEC controllers for each HDMI connectors. Signed-off-by: Neil Armstrong --- drivers/media/cec/cec-notifier.c | 30 ++++++++++++++++++++++++--- include/media/cec-notifier.h | 44 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 69 insertions(+), 5 deletions(-) diff --git a/drivers/media/cec/cec-notifier.c b/drivers/media/cec/cec-notifier.c index 16dffa0..716070a 100644 --- a/drivers/media/cec/cec-notifier.c +++ b/drivers/media/cec/cec-notifier.c @@ -21,6 +21,7 @@ struct cec_notifier { struct list_head head; struct kref kref; struct device *dev; + const char *conn; struct cec_adapter *cec_adap; void (*callback)(struct cec_adapter *adap, u16 pa); @@ -30,13 +31,34 @@ struct cec_notifier { static LIST_HEAD(cec_notifiers); static DEFINE_MUTEX(cec_notifiers_lock); -struct cec_notifier *cec_notifier_get(struct device *dev) +struct cec_notifier *cec_notifier_get_byname(const char *name, + const char *conn) { struct cec_notifier *n; mutex_lock(&cec_notifiers_lock); list_for_each_entry(n, &cec_notifiers, head) { - if (n->dev == dev) { + if (!strcmp(dev_name(n->dev), name) && + (!conn || !strcmp(n->conn, conn))) { + kref_get(&n->kref); + mutex_unlock(&cec_notifiers_lock); + return n; + } + } + mutex_unlock(&cec_notifiers_lock); + + return NULL; +} +EXPORT_SYMBOL_GPL(cec_notifier_get_byname); + +struct cec_notifier *cec_notifier_get_conn(struct device *dev, const char *conn) +{ + struct cec_notifier *n; + + mutex_lock(&cec_notifiers_lock); + list_for_each_entry(n, &cec_notifiers, head) { + if (n->dev == dev && + (!conn || !strcmp(n->conn, conn))) { kref_get(&n->kref); mutex_unlock(&cec_notifiers_lock); return n; @@ -46,6 +68,8 @@ struct cec_notifier *cec_notifier_get(struct device *dev) if (!n) goto unlock; n->dev = dev; + if (conn) + n->conn = devm_kstrdup(dev, conn, GFP_KERNEL); n->phys_addr = CEC_PHYS_ADDR_INVALID; mutex_init(&n->lock); kref_init(&n->kref); @@ -54,7 +78,7 @@ struct cec_notifier *cec_notifier_get(struct device *dev) mutex_unlock(&cec_notifiers_lock); return n; } -EXPORT_SYMBOL_GPL(cec_notifier_get); +EXPORT_SYMBOL_GPL(cec_notifier_get_conn); static void cec_notifier_release(struct kref *kref) { diff --git a/include/media/cec-notifier.h b/include/media/cec-notifier.h index cf0add7..70f2974 100644 --- a/include/media/cec-notifier.h +++ b/include/media/cec-notifier.h @@ -20,6 +20,37 @@ struct cec_notifier; #if IS_REACHABLE(CONFIG_CEC_CORE) && IS_ENABLED(CONFIG_CEC_NOTIFIER) /** + * cec_notifier_get_byname - find a cec_notifier for the given device name + * and connector tuple. + * @name: device name that sends the events. + * @conn: the connector name from which the event occurs + * + * If a notifier for device @name exists, then increase the refcount and + * return that notifier. + * + * If it doesn't exist, return NULL + */ +struct cec_notifier *cec_notifier_get_byname(const char *name, + const char *conn); + +/** + * cec_notifier_get_conn - find or create a new cec_notifier for the given + * device and connector tuple. + * @dev: device that sends the events. + * @conn: the connector name from which the event occurs + * + * If a notifier for device @dev already exists, then increase the refcount + * and return that notifier. + * + * If it doesn't exist, then allocate a new notifier struct and return a + * pointer to that new struct. + * + * Return NULL if the memory could not be allocated. + */ +struct cec_notifier *cec_notifier_get_conn(struct device *dev, + const char *conn); + +/** * cec_notifier_get - find or create a new cec_notifier for the given device. * @dev: device that sends the events. * @@ -31,7 +62,10 @@ struct cec_notifier; * * Return NULL if the memory could not be allocated. */ -struct cec_notifier *cec_notifier_get(struct device *dev); +static inline struct cec_notifier *cec_notifier_get(struct device *dev) +{ + return cec_notifier_get_conn(dev, NULL); +} /** * cec_notifier_put - decrease refcount and delete when the refcount reaches 0. @@ -85,12 +119,18 @@ void cec_register_cec_notifier(struct cec_adapter *adap, struct cec_notifier *notifier); #else -static inline struct cec_notifier *cec_notifier_get(struct device *dev) +static inline struct cec_notifier *cec_notifier_get_conn(struct device *dev, + const char *conn) { /* A non-NULL pointer is expected on success */ return (struct cec_notifier *)0xdeadfeed; } +static inline struct cec_notifier *cec_notifier_get(struct device *dev) +{ + return cec_notifier_get_conn(dev, NULL); +} + static inline void cec_notifier_put(struct cec_notifier *n) { } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Neil Armstrong Subject: [RFC PATCH 2/5] media: cec-notifier: Get notifier by device and connector name Date: Tue, 15 May 2018 00:40:36 +0200 Message-ID: <1526337639-3568-3-git-send-email-narmstrong@baylibre.com> References: <1526337639-3568-1-git-send-email-narmstrong@baylibre.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1526337639-3568-1-git-send-email-narmstrong@baylibre.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: airlied@linux.ie, hans.verkuil@cisco.com, lee.jones@linaro.org, olof@lixom.net, seanpaul@google.com Cc: Neil Armstrong , sadolfsson@google.com, intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, fparent@baylibre.com, felixe@google.com, bleung@google.com, darekm@google.com, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SW4gbm9uIGRldmljZS10cmVlIHdvcmxkLCB3ZSBjYW4gbmVlZCB0byBnZXQgdGhlIG5vdGlmaWVy IGJ5IHRoZSBkcml2ZXIKbmFtZSBkaXJlY3RseSBhbmQgZXZlbnR1YWxseSBkZWZlciBwcm9iZSBp ZiBub3QgeWV0IGNyZWF0ZWQuCgpUaGlzIHBhdGNoIGFkZHMgYSB2YXJpYW50IG9mIHRoZSBnZXQg ZnVuY3Rpb24gYnkgdXNpbmcgdGhlIGRldmljZSBuYW1lCmluc3RlYWQgYW5kIHdpbGwgbm90IGNy ZWF0ZSBhIG5vdGlmaWVyIGlmIG5vdCB5ZXQgY3JlYXRlZC4KCkJ1dCB0aGUgaTkxNSBkcml2ZXIg ZXhwb3NlcyBhdCBsZWFzdCAyIEhETUkgY29ubmVjdG9ycywgdGhpcyBwYXRjaCBhbHNvCmFkZHMg dGhlIHBvc3NpYmlsaXR5IHRvIGFkZCBhIGNvbm5lY3RvciBuYW1lIHRpZWQgdG8gdGhlIG5vdGlm aWVyIGRldmljZQp0byBmb3JtIGEgdHVwbGUgYW5kIGFzc29jaWF0ZSBkaWZmZXJlbnQgQ0VDIGNv bnRyb2xsZXJzIGZvciBlYWNoIEhETUkKY29ubmVjdG9ycy4KClNpZ25lZC1vZmYtYnk6IE5laWwg QXJtc3Ryb25nIDxuYXJtc3Ryb25nQGJheWxpYnJlLmNvbT4KLS0tCiBkcml2ZXJzL21lZGlhL2Nl Yy9jZWMtbm90aWZpZXIuYyB8IDMwICsrKysrKysrKysrKysrKysrKysrKysrKy0tLQogaW5jbHVk ZS9tZWRpYS9jZWMtbm90aWZpZXIuaCAgICAgfCA0NCArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDY5IGluc2VydGlvbnMoKyksIDUgZGVs ZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jZWMvY2VjLW5vdGlmaWVyLmMg Yi9kcml2ZXJzL21lZGlhL2NlYy9jZWMtbm90aWZpZXIuYwppbmRleCAxNmRmZmEwLi43MTYwNzBh IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2NlYy9jZWMtbm90aWZpZXIuYworKysgYi9kcml2 ZXJzL21lZGlhL2NlYy9jZWMtbm90aWZpZXIuYwpAQCAtMjEsNiArMjEsNyBAQCBzdHJ1Y3QgY2Vj X25vdGlmaWVyIHsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGhlYWQ7CiAJc3RydWN0IGtyZWYga3JlZjsK IAlzdHJ1Y3QgZGV2aWNlICpkZXY7CisJY29uc3QgY2hhciAqY29ubjsKIAlzdHJ1Y3QgY2VjX2Fk YXB0ZXIgKmNlY19hZGFwOwogCXZvaWQgKCpjYWxsYmFjaykoc3RydWN0IGNlY19hZGFwdGVyICph ZGFwLCB1MTYgcGEpOwogCkBAIC0zMCwxMyArMzEsMzQgQEAgc3RydWN0IGNlY19ub3RpZmllciB7 CiBzdGF0aWMgTElTVF9IRUFEKGNlY19ub3RpZmllcnMpOwogc3RhdGljIERFRklORV9NVVRFWChj ZWNfbm90aWZpZXJzX2xvY2spOwogCi1zdHJ1Y3QgY2VjX25vdGlmaWVyICpjZWNfbm90aWZpZXJf Z2V0KHN0cnVjdCBkZXZpY2UgKmRldikKK3N0cnVjdCBjZWNfbm90aWZpZXIgKmNlY19ub3RpZmll cl9nZXRfYnluYW1lKGNvbnN0IGNoYXIgKm5hbWUsCisJCQkJCSAgICAgY29uc3QgY2hhciAqY29u bikKIHsKIAlzdHJ1Y3QgY2VjX25vdGlmaWVyICpuOwogCiAJbXV0ZXhfbG9jaygmY2VjX25vdGlm aWVyc19sb2NrKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KG4sICZjZWNfbm90aWZpZXJzLCBoZWFk KSB7Ci0JCWlmIChuLT5kZXYgPT0gZGV2KSB7CisJCWlmICghc3RyY21wKGRldl9uYW1lKG4tPmRl diksIG5hbWUpICYmCisJCSAgICAoIWNvbm4gfHwgIXN0cmNtcChuLT5jb25uLCBjb25uKSkpIHsK KwkJCWtyZWZfZ2V0KCZuLT5rcmVmKTsKKwkJCW11dGV4X3VubG9jaygmY2VjX25vdGlmaWVyc19s b2NrKTsKKwkJCXJldHVybiBuOworCQl9CisJfQorCW11dGV4X3VubG9jaygmY2VjX25vdGlmaWVy c19sb2NrKTsKKworCXJldHVybiBOVUxMOworfQorRVhQT1JUX1NZTUJPTF9HUEwoY2VjX25vdGlm aWVyX2dldF9ieW5hbWUpOworCitzdHJ1Y3QgY2VjX25vdGlmaWVyICpjZWNfbm90aWZpZXJfZ2V0 X2Nvbm4oc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBjaGFyICpjb25uKQoreworCXN0cnVjdCBj ZWNfbm90aWZpZXIgKm47CisKKwltdXRleF9sb2NrKCZjZWNfbm90aWZpZXJzX2xvY2spOworCWxp c3RfZm9yX2VhY2hfZW50cnkobiwgJmNlY19ub3RpZmllcnMsIGhlYWQpIHsKKwkJaWYgKG4tPmRl diA9PSBkZXYgJiYKKwkJICAgICghY29ubiB8fCAhc3RyY21wKG4tPmNvbm4sIGNvbm4pKSkgewog CQkJa3JlZl9nZXQoJm4tPmtyZWYpOwogCQkJbXV0ZXhfdW5sb2NrKCZjZWNfbm90aWZpZXJzX2xv Y2spOwogCQkJcmV0dXJuIG47CkBAIC00Niw2ICs2OCw4IEBAIHN0cnVjdCBjZWNfbm90aWZpZXIg KmNlY19ub3RpZmllcl9nZXQoc3RydWN0IGRldmljZSAqZGV2KQogCWlmICghbikKIAkJZ290byB1 bmxvY2s7CiAJbi0+ZGV2ID0gZGV2OworCWlmIChjb25uKQorCQluLT5jb25uID0gZGV2bV9rc3Ry ZHVwKGRldiwgY29ubiwgR0ZQX0tFUk5FTCk7CiAJbi0+cGh5c19hZGRyID0gQ0VDX1BIWVNfQURE Ul9JTlZBTElEOwogCW11dGV4X2luaXQoJm4tPmxvY2spOwogCWtyZWZfaW5pdCgmbi0+a3JlZik7 CkBAIC01NCw3ICs3OCw3IEBAIHN0cnVjdCBjZWNfbm90aWZpZXIgKmNlY19ub3RpZmllcl9nZXQo c3RydWN0IGRldmljZSAqZGV2KQogCW11dGV4X3VubG9jaygmY2VjX25vdGlmaWVyc19sb2NrKTsK IAlyZXR1cm4gbjsKIH0KLUVYUE9SVF9TWU1CT0xfR1BMKGNlY19ub3RpZmllcl9nZXQpOworRVhQ T1JUX1NZTUJPTF9HUEwoY2VjX25vdGlmaWVyX2dldF9jb25uKTsKIAogc3RhdGljIHZvaWQgY2Vj X25vdGlmaWVyX3JlbGVhc2Uoc3RydWN0IGtyZWYgKmtyZWYpCiB7CmRpZmYgLS1naXQgYS9pbmNs dWRlL21lZGlhL2NlYy1ub3RpZmllci5oIGIvaW5jbHVkZS9tZWRpYS9jZWMtbm90aWZpZXIuaApp bmRleCBjZjBhZGQ3Li43MGYyOTc0IDEwMDY0NAotLS0gYS9pbmNsdWRlL21lZGlhL2NlYy1ub3Rp Zmllci5oCisrKyBiL2luY2x1ZGUvbWVkaWEvY2VjLW5vdGlmaWVyLmgKQEAgLTIwLDYgKzIwLDM3 IEBAIHN0cnVjdCBjZWNfbm90aWZpZXI7CiAjaWYgSVNfUkVBQ0hBQkxFKENPTkZJR19DRUNfQ09S RSkgJiYgSVNfRU5BQkxFRChDT05GSUdfQ0VDX05PVElGSUVSKQogCiAvKioKKyAqIGNlY19ub3Rp Zmllcl9nZXRfYnluYW1lIC0gZmluZCBhIGNlY19ub3RpZmllciBmb3IgdGhlIGdpdmVuIGRldmlj ZSBuYW1lCisgKiBhbmQgY29ubmVjdG9yIHR1cGxlLgorICogQG5hbWU6IGRldmljZSBuYW1lIHRo YXQgc2VuZHMgdGhlIGV2ZW50cy4KKyAqIEBjb25uOiB0aGUgY29ubmVjdG9yIG5hbWUgZnJvbSB3 aGljaCB0aGUgZXZlbnQgb2NjdXJzCisgKgorICogSWYgYSBub3RpZmllciBmb3IgZGV2aWNlIEBu YW1lIGV4aXN0cywgdGhlbiBpbmNyZWFzZSB0aGUgcmVmY291bnQgYW5kCisgKiByZXR1cm4gdGhh dCBub3RpZmllci4KKyAqCisgKiBJZiBpdCBkb2Vzbid0IGV4aXN0LCByZXR1cm4gTlVMTAorICov CitzdHJ1Y3QgY2VjX25vdGlmaWVyICpjZWNfbm90aWZpZXJfZ2V0X2J5bmFtZShjb25zdCBjaGFy ICpuYW1lLAorCQkJCQkgICAgIGNvbnN0IGNoYXIgKmNvbm4pOworCisvKioKKyAqIGNlY19ub3Rp Zmllcl9nZXRfY29ubiAtIGZpbmQgb3IgY3JlYXRlIGEgbmV3IGNlY19ub3RpZmllciBmb3IgdGhl IGdpdmVuCisgKiBkZXZpY2UgYW5kIGNvbm5lY3RvciB0dXBsZS4KKyAqIEBkZXY6IGRldmljZSB0 aGF0IHNlbmRzIHRoZSBldmVudHMuCisgKiBAY29ubjogdGhlIGNvbm5lY3RvciBuYW1lIGZyb20g d2hpY2ggdGhlIGV2ZW50IG9jY3VycworICoKKyAqIElmIGEgbm90aWZpZXIgZm9yIGRldmljZSBA ZGV2IGFscmVhZHkgZXhpc3RzLCB0aGVuIGluY3JlYXNlIHRoZSByZWZjb3VudAorICogYW5kIHJl dHVybiB0aGF0IG5vdGlmaWVyLgorICoKKyAqIElmIGl0IGRvZXNuJ3QgZXhpc3QsIHRoZW4gYWxs b2NhdGUgYSBuZXcgbm90aWZpZXIgc3RydWN0IGFuZCByZXR1cm4gYQorICogcG9pbnRlciB0byB0 aGF0IG5ldyBzdHJ1Y3QuCisgKgorICogUmV0dXJuIE5VTEwgaWYgdGhlIG1lbW9yeSBjb3VsZCBu b3QgYmUgYWxsb2NhdGVkLgorICovCitzdHJ1Y3QgY2VjX25vdGlmaWVyICpjZWNfbm90aWZpZXJf Z2V0X2Nvbm4oc3RydWN0IGRldmljZSAqZGV2LAorCQkJCQkgICBjb25zdCBjaGFyICpjb25uKTsK KworLyoqCiAgKiBjZWNfbm90aWZpZXJfZ2V0IC0gZmluZCBvciBjcmVhdGUgYSBuZXcgY2VjX25v dGlmaWVyIGZvciB0aGUgZ2l2ZW4gZGV2aWNlLgogICogQGRldjogZGV2aWNlIHRoYXQgc2VuZHMg dGhlIGV2ZW50cy4KICAqCkBAIC0zMSw3ICs2MiwxMCBAQCBzdHJ1Y3QgY2VjX25vdGlmaWVyOwog ICoKICAqIFJldHVybiBOVUxMIGlmIHRoZSBtZW1vcnkgY291bGQgbm90IGJlIGFsbG9jYXRlZC4K ICAqLwotc3RydWN0IGNlY19ub3RpZmllciAqY2VjX25vdGlmaWVyX2dldChzdHJ1Y3QgZGV2aWNl ICpkZXYpOworc3RhdGljIGlubGluZSBzdHJ1Y3QgY2VjX25vdGlmaWVyICpjZWNfbm90aWZpZXJf Z2V0KHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gY2VjX25vdGlmaWVyX2dldF9jb25u KGRldiwgTlVMTCk7Cit9CiAKIC8qKgogICogY2VjX25vdGlmaWVyX3B1dCAtIGRlY3JlYXNlIHJl ZmNvdW50IGFuZCBkZWxldGUgd2hlbiB0aGUgcmVmY291bnQgcmVhY2hlcyAwLgpAQCAtODUsMTIg KzExOSwxOCBAQCB2b2lkIGNlY19yZWdpc3Rlcl9jZWNfbm90aWZpZXIoc3RydWN0IGNlY19hZGFw dGVyICphZGFwLAogCQkJICAgICAgIHN0cnVjdCBjZWNfbm90aWZpZXIgKm5vdGlmaWVyKTsKIAog I2Vsc2UKLXN0YXRpYyBpbmxpbmUgc3RydWN0IGNlY19ub3RpZmllciAqY2VjX25vdGlmaWVyX2dl dChzdHJ1Y3QgZGV2aWNlICpkZXYpCitzdGF0aWMgaW5saW5lIHN0cnVjdCBjZWNfbm90aWZpZXIg KmNlY19ub3RpZmllcl9nZXRfY29ubihzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCQkJIGNvbnN0 IGNoYXIgKmNvbm4pCiB7CiAJLyogQSBub24tTlVMTCBwb2ludGVyIGlzIGV4cGVjdGVkIG9uIHN1 Y2Nlc3MgKi8KIAlyZXR1cm4gKHN0cnVjdCBjZWNfbm90aWZpZXIgKikweGRlYWRmZWVkOwogfQog CitzdGF0aWMgaW5saW5lIHN0cnVjdCBjZWNfbm90aWZpZXIgKmNlY19ub3RpZmllcl9nZXQoc3Ry dWN0IGRldmljZSAqZGV2KQoreworCXJldHVybiBjZWNfbm90aWZpZXJfZ2V0X2Nvbm4oZGV2LCBO VUxMKTsKK30KKwogc3RhdGljIGlubGluZSB2b2lkIGNlY19ub3RpZmllcl9wdXQoc3RydWN0IGNl Y19ub3RpZmllciAqbikKIHsKIH0KLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9pbnRlbC1nZngK