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