1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * CEC driver for ChromeOS Embedded Controller
4  *
5  * Copyright (c) 2018 BayLibre, SAS
6  * Author: Neil Armstrong <narmstrong@baylibre.com>
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/platform_device.h>
12 #include <linux/dmi.h>
13 #include <linux/pci.h>
14 #include <linux/cec.h>
15 #include <linux/slab.h>
16 #include <linux/interrupt.h>
17 #include <linux/platform_data/cros_ec_commands.h>
18 #include <linux/platform_data/cros_ec_proto.h>
19 #include <media/cec.h>
20 #include <media/cec-notifier.h>
21 
22 #define DRV_NAME	"cros-ec-cec"
23 
24 /**
25  * struct cros_ec_cec - Driver data for EC CEC
26  *
27  * @cros_ec: Pointer to EC device
28  * @notifier: Notifier info for responding to EC events
29  * @adap: CEC adapter
30  * @notify: CEC notifier pointer
31  * @rx_msg: storage for a received message
32  */
33 struct cros_ec_cec {
34 	struct cros_ec_device *cros_ec;
35 	struct notifier_block notifier;
36 	struct cec_adapter *adap;
37 	struct cec_notifier *notify;
38 	struct cec_msg rx_msg;
39 };
40 
41 static void handle_cec_message(struct cros_ec_cec *cros_ec_cec)
42 {
43 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
44 	uint8_t *cec_message = cros_ec->event_data.data.cec_message;
45 	unsigned int len = cros_ec->event_size;
46 
47 	cros_ec_cec->rx_msg.len = len;
48 	memcpy(cros_ec_cec->rx_msg.msg, cec_message, len);
49 
50 	cec_received_msg(cros_ec_cec->adap, &cros_ec_cec->rx_msg);
51 }
52 
53 static void handle_cec_event(struct cros_ec_cec *cros_ec_cec)
54 {
55 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
56 	uint32_t events = cros_ec->event_data.data.cec_events;
57 
58 	if (events & EC_MKBP_CEC_SEND_OK)
59 		cec_transmit_attempt_done(cros_ec_cec->adap,
60 					  CEC_TX_STATUS_OK);
61 
62 	/* FW takes care of all retries, tell core to avoid more retries */
63 	if (events & EC_MKBP_CEC_SEND_FAILED)
64 		cec_transmit_attempt_done(cros_ec_cec->adap,
65 					  CEC_TX_STATUS_MAX_RETRIES |
66 					  CEC_TX_STATUS_NACK);
67 }
68 
69 static int cros_ec_cec_event(struct notifier_block *nb,
70 			     unsigned long queued_during_suspend,
71 			     void *_notify)
72 {
73 	struct cros_ec_cec *cros_ec_cec;
74 	struct cros_ec_device *cros_ec;
75 
76 	cros_ec_cec = container_of(nb, struct cros_ec_cec, notifier);
77 	cros_ec = cros_ec_cec->cros_ec;
78 
79 	if (cros_ec->event_data.event_type == EC_MKBP_EVENT_CEC_EVENT) {
80 		handle_cec_event(cros_ec_cec);
81 		return NOTIFY_OK;
82 	}
83 
84 	if (cros_ec->event_data.event_type == EC_MKBP_EVENT_CEC_MESSAGE) {
85 		handle_cec_message(cros_ec_cec);
86 		return NOTIFY_OK;
87 	}
88 
89 	return NOTIFY_DONE;
90 }
91 
92 static int cros_ec_cec_set_log_addr(struct cec_adapter *adap, u8 logical_addr)
93 {
94 	struct cros_ec_cec *cros_ec_cec = adap->priv;
95 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
96 	struct {
97 		struct cros_ec_command msg;
98 		struct ec_params_cec_set data;
99 	} __packed msg = {};
100 	int ret;
101 
102 	msg.msg.command = EC_CMD_CEC_SET;
103 	msg.msg.outsize = sizeof(msg.data);
104 	msg.data.cmd = CEC_CMD_LOGICAL_ADDRESS;
105 	msg.data.val = logical_addr;
106 
107 	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
108 	if (ret < 0) {
109 		dev_err(cros_ec->dev,
110 			"error setting CEC logical address on EC: %d\n", ret);
111 		return ret;
112 	}
113 
114 	return 0;
115 }
116 
117 static int cros_ec_cec_transmit(struct cec_adapter *adap, u8 attempts,
118 				u32 signal_free_time, struct cec_msg *cec_msg)
119 {
120 	struct cros_ec_cec *cros_ec_cec = adap->priv;
121 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
122 	struct {
123 		struct cros_ec_command msg;
124 		struct ec_params_cec_write data;
125 	} __packed msg = {};
126 	int ret;
127 
128 	msg.msg.command = EC_CMD_CEC_WRITE_MSG;
129 	msg.msg.outsize = cec_msg->len;
130 	memcpy(msg.data.msg, cec_msg->msg, cec_msg->len);
131 
132 	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
133 	if (ret < 0) {
134 		dev_err(cros_ec->dev,
135 			"error writing CEC msg on EC: %d\n", ret);
136 		return ret;
137 	}
138 
139 	return 0;
140 }
141 
142 static int cros_ec_cec_adap_enable(struct cec_adapter *adap, bool enable)
143 {
144 	struct cros_ec_cec *cros_ec_cec = adap->priv;
145 	struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec;
146 	struct {
147 		struct cros_ec_command msg;
148 		struct ec_params_cec_set data;
149 	} __packed msg = {};
150 	int ret;
151 
152 	msg.msg.command = EC_CMD_CEC_SET;
153 	msg.msg.outsize = sizeof(msg.data);
154 	msg.data.cmd = CEC_CMD_ENABLE;
155 	msg.data.val = enable;
156 
157 	ret = cros_ec_cmd_xfer_status(cros_ec, &msg.msg);
158 	if (ret < 0) {
159 		dev_err(cros_ec->dev,
160 			"error %sabling CEC on EC: %d\n",
161 			(enable ? "en" : "dis"), ret);
162 		return ret;
163 	}
164 
165 	return 0;
166 }
167 
168 static const struct cec_adap_ops cros_ec_cec_ops = {
169 	.adap_enable = cros_ec_cec_adap_enable,
170 	.adap_log_addr = cros_ec_cec_set_log_addr,
171 	.adap_transmit = cros_ec_cec_transmit,
172 };
173 
174 #ifdef CONFIG_PM_SLEEP
175 static int cros_ec_cec_suspend(struct device *dev)
176 {
177 	struct platform_device *pdev = to_platform_device(dev);
178 	struct cros_ec_cec *cros_ec_cec = dev_get_drvdata(&pdev->dev);
179 
180 	if (device_may_wakeup(dev))
181 		enable_irq_wake(cros_ec_cec->cros_ec->irq);
182 
183 	return 0;
184 }
185 
186 static int cros_ec_cec_resume(struct device *dev)
187 {
188 	struct platform_device *pdev = to_platform_device(dev);
189 	struct cros_ec_cec *cros_ec_cec = dev_get_drvdata(&pdev->dev);
190 
191 	if (device_may_wakeup(dev))
192 		disable_irq_wake(cros_ec_cec->cros_ec->irq);
193 
194 	return 0;
195 }
196 #endif
197 
198 static SIMPLE_DEV_PM_OPS(cros_ec_cec_pm_ops,
199 	cros_ec_cec_suspend, cros_ec_cec_resume);
200 
201 #if IS_ENABLED(CONFIG_PCI) && IS_ENABLED(CONFIG_DMI)
202 
203 /*
204  * The Firmware only handles a single CEC interface tied to a single HDMI
205  * connector we specify along with the DRM device name handling the HDMI output
206  */
207 
208 struct cec_dmi_match {
209 	const char *sys_vendor;
210 	const char *product_name;
211 	const char *devname;
212 	const char *conn;
213 };
214 
215 static const struct cec_dmi_match cec_dmi_match_table[] = {
216 	/* Google Fizz */
217 	{ "Google", "Fizz", "0000:00:02.0", "Port B" },
218 };
219 
220 static struct device *cros_ec_cec_find_hdmi_dev(struct device *dev,
221 						const char **conn)
222 {
223 	int i;
224 
225 	for (i = 0 ; i < ARRAY_SIZE(cec_dmi_match_table) ; ++i) {
226 		const struct cec_dmi_match *m = &cec_dmi_match_table[i];
227 
228 		if (dmi_match(DMI_SYS_VENDOR, m->sys_vendor) &&
229 		    dmi_match(DMI_PRODUCT_NAME, m->product_name)) {
230 			struct device *d;
231 
232 			/* Find the device, bail out if not yet registered */
233 			d = bus_find_device_by_name(&pci_bus_type, NULL,
234 						    m->devname);
235 			if (!d)
236 				return ERR_PTR(-EPROBE_DEFER);
237 			put_device(d);
238 			*conn = m->conn;
239 			return d;
240 		}
241 	}
242 
243 	/* Hardware support must be added in the cec_dmi_match_table */
244 	dev_warn(dev, "CEC notifier not configured for this hardware\n");
245 
246 	return ERR_PTR(-ENODEV);
247 }
248 
249 #else
250 
251 static struct device *cros_ec_cec_find_hdmi_dev(struct device *dev,
252 						const char **conn)
253 {
254 	return ERR_PTR(-ENODEV);
255 }
256 
257 #endif
258 
259 static int cros_ec_cec_probe(struct platform_device *pdev)
260 {
261 	struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent);
262 	struct cros_ec_device *cros_ec = ec_dev->ec_dev;
263 	struct cros_ec_cec *cros_ec_cec;
264 	struct device *hdmi_dev;
265 	const char *conn = NULL;
266 	int ret;
267 
268 	hdmi_dev = cros_ec_cec_find_hdmi_dev(&pdev->dev, &conn);
269 	if (IS_ERR(hdmi_dev))
270 		return PTR_ERR(hdmi_dev);
271 
272 	cros_ec_cec = devm_kzalloc(&pdev->dev, sizeof(*cros_ec_cec),
273 				   GFP_KERNEL);
274 	if (!cros_ec_cec)
275 		return -ENOMEM;
276 
277 	platform_set_drvdata(pdev, cros_ec_cec);
278 	cros_ec_cec->cros_ec = cros_ec;
279 
280 	device_init_wakeup(&pdev->dev, 1);
281 
282 	cros_ec_cec->adap = cec_allocate_adapter(&cros_ec_cec_ops, cros_ec_cec,
283 						 DRV_NAME,
284 						 CEC_CAP_DEFAULTS |
285 						 CEC_CAP_CONNECTOR_INFO, 1);
286 	if (IS_ERR(cros_ec_cec->adap))
287 		return PTR_ERR(cros_ec_cec->adap);
288 
289 	cros_ec_cec->notify = cec_notifier_cec_adap_register(hdmi_dev, conn,
290 							     cros_ec_cec->adap);
291 	if (!cros_ec_cec->notify) {
292 		ret = -ENOMEM;
293 		goto out_probe_adapter;
294 	}
295 
296 	/* Get CEC events from the EC. */
297 	cros_ec_cec->notifier.notifier_call = cros_ec_cec_event;
298 	ret = blocking_notifier_chain_register(&cros_ec->event_notifier,
299 					       &cros_ec_cec->notifier);
300 	if (ret) {
301 		dev_err(&pdev->dev, "failed to register notifier\n");
302 		goto out_probe_notify;
303 	}
304 
305 	ret = cec_register_adapter(cros_ec_cec->adap, &pdev->dev);
306 	if (ret < 0)
307 		goto out_probe_notify;
308 
309 	return 0;
310 
311 out_probe_notify:
312 	cec_notifier_cec_adap_unregister(cros_ec_cec->notify,
313 					 cros_ec_cec->adap);
314 out_probe_adapter:
315 	cec_delete_adapter(cros_ec_cec->adap);
316 	return ret;
317 }
318 
319 static int cros_ec_cec_remove(struct platform_device *pdev)
320 {
321 	struct cros_ec_cec *cros_ec_cec = platform_get_drvdata(pdev);
322 	struct device *dev = &pdev->dev;
323 	int ret;
324 
325 	ret = blocking_notifier_chain_unregister(
326 			&cros_ec_cec->cros_ec->event_notifier,
327 			&cros_ec_cec->notifier);
328 
329 	if (ret) {
330 		dev_err(dev, "failed to unregister notifier\n");
331 		return ret;
332 	}
333 
334 	cec_notifier_cec_adap_unregister(cros_ec_cec->notify,
335 					 cros_ec_cec->adap);
336 	cec_unregister_adapter(cros_ec_cec->adap);
337 
338 	return 0;
339 }
340 
341 static struct platform_driver cros_ec_cec_driver = {
342 	.probe = cros_ec_cec_probe,
343 	.remove  = cros_ec_cec_remove,
344 	.driver = {
345 		.name = DRV_NAME,
346 		.pm = &cros_ec_cec_pm_ops,
347 	},
348 };
349 
350 module_platform_driver(cros_ec_cec_driver);
351 
352 MODULE_DESCRIPTION("CEC driver for ChromeOS ECs");
353 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
354 MODULE_LICENSE("GPL");
355 MODULE_ALIAS("platform:" DRV_NAME);
356