drivers/media/cec/core/cec-notifier.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * cec-notifier.c - notify CEC drivers of physical address changes
   4  *
   5  * Copyright 2016 Russell King.
   6  * Copyright 2016-2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   7  */
   8
   9 #include <linux/export.h>
  10 #include <linux/string.h>
  11 #include <linux/slab.h>
  12 #include <linux/i2c.h>
  13 #include <linux/list.h>
  14 #include <linux/kref.h>
  15 #include <linux/of_platform.h>
  16
  17 #include <media/cec.h>
  18 #include <media/cec-notifier.h>
  19 #include <drm/drm_edid.h>
  20
  21 struct cec_notifier {
  22         struct mutex lock;
  23         struct list_head head;
  24         struct kref kref;
  25         struct device *hdmi_dev;
  26         struct cec_connector_info conn_info;
  27         const char *port_name;
  28         struct cec_adapter *cec_adap;
  29
  30         u16 phys_addr;
  31 };
  32
  33 static LIST_HEAD(cec_notifiers);
  34 static DEFINE_MUTEX(cec_notifiers_lock);
  35
  36 /**
  37  * cec_notifier_get_conn - find or create a new cec_notifier for the given
  38  * device and connector tuple.
  39  * @hdmi_dev: device that sends the events.
  40  * @port_name: the connector name from which the event occurs
  41  *
  42  * If a notifier for device @dev already exists, then increase the refcount
  43  * and return that notifier.
  44  *
  45  * If it doesn't exist, then allocate a new notifier struct and return a
  46  * pointer to that new struct.
  47  *
  48  * Return NULL if the memory could not be allocated.
  49  */
  50 static struct cec_notifier *
  51 cec_notifier_get_conn(struct device *hdmi_dev, const char *port_name)
  52 {
  53         struct cec_notifier *n;
  54
  55         mutex_lock(&cec_notifiers_lock);
  56         list_for_each_entry(n, &cec_notifiers, head) {
  57                 if (n->hdmi_dev == hdmi_dev &&
  58                     (!port_name ||
  59                      (n->port_name && !strcmp(n->port_name, port_name)))) {
  60                         kref_get(&n->kref);
  61                         mutex_unlock(&cec_notifiers_lock);
  62                         return n;
  63                 }
  64         }
  65         n = kzalloc(sizeof(*n), GFP_KERNEL);
  66         if (!n)
  67                 goto unlock;
  68         n->hdmi_dev = hdmi_dev;
  69         if (port_name) {
  70                 n->port_name = kstrdup(port_name, GFP_KERNEL);
  71                 if (!n->port_name) {
  72                         kfree(n);
  73                         n = NULL;
  74                         goto unlock;
  75                 }
  76         }
  77         n->phys_addr = CEC_PHYS_ADDR_INVALID;
  78
  79         mutex_init(&n->lock);
  80         kref_init(&n->kref);
  81         list_add_tail(&n->head, &cec_notifiers);
  82 unlock:
  83         mutex_unlock(&cec_notifiers_lock);
  84         return n;
  85 }
  86
  87 static void cec_notifier_release(struct kref *kref)
  88 {
  89         struct cec_notifier *n =
  90                 container_of(kref, struct cec_notifier, kref);
  91
  92         list_del(&n->head);
  93         kfree(n->port_name);
  94         kfree(n);
  95 }
  96
  97 static void cec_notifier_put(struct cec_notifier *n)
  98 {
  99         mutex_lock(&cec_notifiers_lock);
 100         kref_put(&n->kref, cec_notifier_release);
 101         mutex_unlock(&cec_notifiers_lock);
 102 }
 103
 104 struct cec_notifier *
 105 cec_notifier_conn_register(struct device *hdmi_dev, const char *port_name,
 106                            const struct cec_connector_info *conn_info)
 107 {
 108         struct cec_notifier *n = cec_notifier_get_conn(hdmi_dev, port_name);
 109
 110         if (!n)
 111                 return n;
 112
 113         mutex_lock(&n->lock);
 114         n->phys_addr = CEC_PHYS_ADDR_INVALID;
 115         if (conn_info)
 116                 n->conn_info = *conn_info;
 117         else
 118                 memset(&n->conn_info, 0, sizeof(n->conn_info));
 119         if (n->cec_adap) {
 120                 if (!n->cec_adap->adap_controls_phys_addr)
 121                         cec_phys_addr_invalidate(n->cec_adap);
 122                 cec_s_conn_info(n->cec_adap, conn_info);
 123         }
 124         mutex_unlock(&n->lock);
 125         return n;
 126 }
 127 EXPORT_SYMBOL_GPL(cec_notifier_conn_register);
 128
 129 void cec_notifier_conn_unregister(struct cec_notifier *n)
 130 {
 131         if (!n)
 132                 return;
 133
 134         mutex_lock(&n->lock);
 135         memset(&n->conn_info, 0, sizeof(n->conn_info));
 136         n->phys_addr = CEC_PHYS_ADDR_INVALID;
 137         if (n->cec_adap) {
 138                 if (!n->cec_adap->adap_controls_phys_addr)
 139                         cec_phys_addr_invalidate(n->cec_adap);
 140                 cec_s_conn_info(n->cec_adap, NULL);
 141         }
 142         mutex_unlock(&n->lock);
 143         cec_notifier_put(n);
 144 }
 145 EXPORT_SYMBOL_GPL(cec_notifier_conn_unregister);
 146
 147 struct cec_notifier *
 148 cec_notifier_cec_adap_register(struct device *hdmi_dev, const char *port_name,
 149                                struct cec_adapter *adap)
 150 {
 151         struct cec_notifier *n;
 152
 153         if (WARN_ON(!adap))
 154                 return NULL;
 155
 156         n = cec_notifier_get_conn(hdmi_dev, port_name);
 157         if (!n)
 158                 return n;
 159
 160         mutex_lock(&n->lock);
 161         n->cec_adap = adap;
 162         adap->conn_info = n->conn_info;
 163         adap->notifier = n;
 164         if (!adap->adap_controls_phys_addr)
 165                 cec_s_phys_addr(adap, n->phys_addr, false);
 166         mutex_unlock(&n->lock);
 167         return n;
 168 }
 169 EXPORT_SYMBOL_GPL(cec_notifier_cec_adap_register);
 170
 171 void cec_notifier_cec_adap_unregister(struct cec_notifier *n,
 172                                       struct cec_adapter *adap)
 173 {
 174         if (!n)
 175                 return;
 176
 177         mutex_lock(&n->lock);
 178         adap->notifier = NULL;
 179         n->cec_adap = NULL;
 180         mutex_unlock(&n->lock);
 181         cec_notifier_put(n);
 182 }
 183 EXPORT_SYMBOL_GPL(cec_notifier_cec_adap_unregister);
 184
 185 void cec_notifier_set_phys_addr(struct cec_notifier *n, u16 pa)
 186 {
 187         if (n == NULL)
 188                 return;
 189
 190         mutex_lock(&n->lock);
 191         n->phys_addr = pa;
 192         if (n->cec_adap && !n->cec_adap->adap_controls_phys_addr)
 193                 cec_s_phys_addr(n->cec_adap, n->phys_addr, false);
 194         mutex_unlock(&n->lock);
 195 }
 196 EXPORT_SYMBOL_GPL(cec_notifier_set_phys_addr);
 197
 198 void cec_notifier_set_phys_addr_from_edid(struct cec_notifier *n,
 199                                           const struct edid *edid)
 200 {
 201         u16 pa = CEC_PHYS_ADDR_INVALID;
 202
 203         if (n == NULL)
 204                 return;
 205
 206         if (edid && edid->extensions)
 207                 pa = cec_get_edid_phys_addr((const u8 *)edid,
 208                                 EDID_LENGTH * (edid->extensions + 1), NULL);
 209         cec_notifier_set_phys_addr(n, pa);
 210 }
 211 EXPORT_SYMBOL_GPL(cec_notifier_set_phys_addr_from_edid);
 212
 213 struct device *cec_notifier_parse_hdmi_phandle(struct device *dev)
 214 {
 215         struct platform_device *hdmi_pdev;
 216         struct device *hdmi_dev = NULL;
 217         struct device_node *np;
 218
 219         np = of_parse_phandle(dev->of_node, "hdmi-phandle", 0);
 220
 221         if (!np) {
 222                 dev_err(dev, "Failed to find HDMI node in device tree\n");
 223                 return ERR_PTR(-ENODEV);
 224         }
 225
 226         hdmi_pdev = of_find_device_by_node(np);
 227         if (hdmi_pdev)
 228                 hdmi_dev = &hdmi_pdev->dev;
 229 #if IS_REACHABLE(CONFIG_I2C)
 230         if (!hdmi_dev) {
 231                 struct i2c_client *hdmi_client = of_find_i2c_device_by_node(np);
 232
 233                 if (hdmi_client)
 234                         hdmi_dev = &hdmi_client->dev;
 235         }
 236 #endif
 237         of_node_put(np);
 238         if (!hdmi_dev)
 239                 return ERR_PTR(-EPROBE_DEFER);
 240
 241         /*
 242          * Note that the device struct is only used as a key into the
 243          * cec_notifiers list, it is never actually accessed.
 244          * So we decrement the reference here so we don't leak
 245          * memory.
 246          */
 247         put_device(hdmi_dev);
 248         return hdmi_dev;
 249 }
 250 EXPORT_SYMBOL_GPL(cec_notifier_parse_hdmi_phandle);