1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Designware HDMI CEC driver
4 *
5 * Copyright (C) 2015-2017 Russell King.
6 */
7#include <linux/interrupt.h>
8#include <linux/io.h>
9#include <linux/module.h>
10#include <linux/platform_device.h>
11#include <linux/sched.h>
12#include <linux/slab.h>
13
14#include <drm/drm_edid.h>
15
16#include <media/cec.h>
17#include <media/cec-notifier.h>
18
19#include "dw-hdmi-cec.h"
20
21enum {
22	HDMI_IH_CEC_STAT0	= 0x0106,
23	HDMI_IH_MUTE_CEC_STAT0	= 0x0186,
24
25	HDMI_CEC_CTRL		= 0x7d00,
26	CEC_CTRL_START		= BIT(0),
27	CEC_CTRL_FRAME_TYP	= 3 << 1,
28	CEC_CTRL_RETRY		= 0 << 1,
29	CEC_CTRL_NORMAL		= 1 << 1,
30	CEC_CTRL_IMMED		= 2 << 1,
31
32	HDMI_CEC_STAT		= 0x7d01,
33	CEC_STAT_DONE		= BIT(0),
34	CEC_STAT_EOM		= BIT(1),
35	CEC_STAT_NACK		= BIT(2),
36	CEC_STAT_ARBLOST	= BIT(3),
37	CEC_STAT_ERROR_INIT	= BIT(4),
38	CEC_STAT_ERROR_FOLL	= BIT(5),
39	CEC_STAT_WAKEUP		= BIT(6),
40
41	HDMI_CEC_MASK		= 0x7d02,
42	HDMI_CEC_POLARITY	= 0x7d03,
43	HDMI_CEC_INT		= 0x7d04,
44	HDMI_CEC_ADDR_L		= 0x7d05,
45	HDMI_CEC_ADDR_H		= 0x7d06,
46	HDMI_CEC_TX_CNT		= 0x7d07,
47	HDMI_CEC_RX_CNT		= 0x7d08,
48	HDMI_CEC_TX_DATA0	= 0x7d10,
49	HDMI_CEC_RX_DATA0	= 0x7d20,
50	HDMI_CEC_LOCK		= 0x7d30,
51	HDMI_CEC_WKUPCTRL	= 0x7d31,
52};
53
54struct dw_hdmi_cec {
55	struct dw_hdmi *hdmi;
56	const struct dw_hdmi_cec_ops *ops;
57	u32 addresses;
58	struct cec_adapter *adap;
59	struct cec_msg rx_msg;
60	unsigned int tx_status;
61	bool tx_done;
62	bool rx_done;
63	struct cec_notifier *notify;
64	int irq;
65
66	u8 regs_polarity;
67	u8 regs_mask;
68	u8 regs_mute_stat0;
69};
70
71static void dw_hdmi_write(struct dw_hdmi_cec *cec, u8 val, int offset)
72{
73	cec->ops->write(cec->hdmi, val, offset);
74}
75
76static u8 dw_hdmi_read(struct dw_hdmi_cec *cec, int offset)
77{
78	return cec->ops->read(cec->hdmi, offset);
79}
80
81static int dw_hdmi_cec_log_addr(struct cec_adapter *adap, u8 logical_addr)
82{
83	struct dw_hdmi_cec *cec = cec_get_drvdata(adap);
84
85	if (logical_addr == CEC_LOG_ADDR_INVALID)
86		cec->addresses = 0;
87	else
88		cec->addresses |= BIT(logical_addr) | BIT(15);
89
90	dw_hdmi_write(cec, cec->addresses & 255, HDMI_CEC_ADDR_L);
91	dw_hdmi_write(cec, cec->addresses >> 8, HDMI_CEC_ADDR_H);
92
93	return 0;
94}
95
96static int dw_hdmi_cec_transmit(struct cec_adapter *adap, u8 attempts,
97				u32 signal_free_time, struct cec_msg *msg)
98{
99	struct dw_hdmi_cec *cec = cec_get_drvdata(adap);
100	unsigned int i, ctrl;
101
102	switch (signal_free_time) {
103	case CEC_SIGNAL_FREE_TIME_RETRY:
104		ctrl = CEC_CTRL_RETRY;
105		break;
106	case CEC_SIGNAL_FREE_TIME_NEW_INITIATOR:
107	default:
108		ctrl = CEC_CTRL_NORMAL;
109		break;
110	case CEC_SIGNAL_FREE_TIME_NEXT_XFER:
111		ctrl = CEC_CTRL_IMMED;
112		break;
113	}
114
115	for (i = 0; i < msg->len; i++)
116		dw_hdmi_write(cec, msg->msg[i], HDMI_CEC_TX_DATA0 + i);
117
118	dw_hdmi_write(cec, msg->len, HDMI_CEC_TX_CNT);
119	dw_hdmi_write(cec, ctrl | CEC_CTRL_START, HDMI_CEC_CTRL);
120
121	return 0;
122}
123
124static irqreturn_t dw_hdmi_cec_hardirq(int irq, void *data)
125{
126	struct cec_adapter *adap = data;
127	struct dw_hdmi_cec *cec = cec_get_drvdata(adap);
128	unsigned int stat = dw_hdmi_read(cec, HDMI_IH_CEC_STAT0);
129	irqreturn_t ret = IRQ_HANDLED;
130
131	if (stat == 0)
132		return IRQ_NONE;
133
134	dw_hdmi_write(cec, stat, HDMI_IH_CEC_STAT0);
135
136	if (stat & CEC_STAT_ERROR_INIT) {
137		cec->tx_status = CEC_TX_STATUS_ERROR;
138		cec->tx_done = true;
139		ret = IRQ_WAKE_THREAD;
140	} else if (stat & CEC_STAT_DONE) {
141		cec->tx_status = CEC_TX_STATUS_OK;
142		cec->tx_done = true;
143		ret = IRQ_WAKE_THREAD;
144	} else if (stat & CEC_STAT_NACK) {
145		cec->tx_status = CEC_TX_STATUS_NACK;
146		cec->tx_done = true;
147		ret = IRQ_WAKE_THREAD;
148	} else if (stat & CEC_STAT_ARBLOST) {
149		cec->tx_status = CEC_TX_STATUS_ARB_LOST;
150		cec->tx_done = true;
151		ret = IRQ_WAKE_THREAD;
152	}
153
154	if (stat & CEC_STAT_EOM) {
155		unsigned int len, i;
156
157		len = dw_hdmi_read(cec, HDMI_CEC_RX_CNT);
158		if (len > sizeof(cec->rx_msg.msg))
159			len = sizeof(cec->rx_msg.msg);
160
161		for (i = 0; i < len; i++)
162			cec->rx_msg.msg[i] =
163				dw_hdmi_read(cec, HDMI_CEC_RX_DATA0 + i);
164
165		dw_hdmi_write(cec, 0, HDMI_CEC_LOCK);
166
167		cec->rx_msg.len = len;
168		smp_wmb();
169		cec->rx_done = true;
170
171		ret = IRQ_WAKE_THREAD;
172	}
173
174	return ret;
175}
176
177static irqreturn_t dw_hdmi_cec_thread(int irq, void *data)
178{
179	struct cec_adapter *adap = data;
180	struct dw_hdmi_cec *cec = cec_get_drvdata(adap);
181
182	if (cec->tx_done) {
183		cec->tx_done = false;
184		cec_transmit_attempt_done(adap, cec->tx_status);
185	}
186	if (cec->rx_done) {
187		cec->rx_done = false;
188		smp_rmb();
189		cec_received_msg(adap, &cec->rx_msg);
190	}
191	return IRQ_HANDLED;
192}
193
194static int dw_hdmi_cec_enable(struct cec_adapter *adap, bool enable)
195{
196	struct dw_hdmi_cec *cec = cec_get_drvdata(adap);
197
198	if (!enable) {
199		dw_hdmi_write(cec, ~0, HDMI_CEC_MASK);
200		dw_hdmi_write(cec, ~0, HDMI_IH_MUTE_CEC_STAT0);
201		dw_hdmi_write(cec, 0, HDMI_CEC_POLARITY);
202
203		cec->ops->disable(cec->hdmi);
204	} else {
205		unsigned int irqs;
206
207		dw_hdmi_write(cec, 0, HDMI_CEC_CTRL);
208		dw_hdmi_write(cec, ~0, HDMI_IH_CEC_STAT0);
209		dw_hdmi_write(cec, 0, HDMI_CEC_LOCK);
210
211		dw_hdmi_cec_log_addr(cec->adap, CEC_LOG_ADDR_INVALID);
212
213		cec->ops->enable(cec->hdmi);
214
215		irqs = CEC_STAT_ERROR_INIT | CEC_STAT_NACK | CEC_STAT_EOM |
216		       CEC_STAT_ARBLOST | CEC_STAT_DONE;
217		dw_hdmi_write(cec, irqs, HDMI_CEC_POLARITY);
218		dw_hdmi_write(cec, ~irqs, HDMI_CEC_MASK);
219		dw_hdmi_write(cec, ~irqs, HDMI_IH_MUTE_CEC_STAT0);
220	}
221	return 0;
222}
223
224static const struct cec_adap_ops dw_hdmi_cec_ops = {
225	.adap_enable = dw_hdmi_cec_enable,
226	.adap_log_addr = dw_hdmi_cec_log_addr,
227	.adap_transmit = dw_hdmi_cec_transmit,
228};
229
230static void dw_hdmi_cec_del(void *data)
231{
232	struct dw_hdmi_cec *cec = data;
233
234	cec_delete_adapter(cec->adap);
235}
236
237static int dw_hdmi_cec_probe(struct platform_device *pdev)
238{
239	struct dw_hdmi_cec_data *data = dev_get_platdata(&pdev->dev);
240	struct dw_hdmi_cec *cec;
241	int ret;
242
243	if (!data)
244		return -ENXIO;
245
246	/*
247	 * Our device is just a convenience - we want to link to the real
248	 * hardware device here, so that userspace can see the association
249	 * between the HDMI hardware and its associated CEC chardev.
250	 */
251	cec = devm_kzalloc(&pdev->dev, sizeof(*cec), GFP_KERNEL);
252	if (!cec)
253		return -ENOMEM;
254
255	cec->irq = data->irq;
256	cec->ops = data->ops;
257	cec->hdmi = data->hdmi;
258
259	platform_set_drvdata(pdev, cec);
260
261	dw_hdmi_write(cec, 0, HDMI_CEC_TX_CNT);
262	dw_hdmi_write(cec, ~0, HDMI_CEC_MASK);
263	dw_hdmi_write(cec, ~0, HDMI_IH_MUTE_CEC_STAT0);
264	dw_hdmi_write(cec, 0, HDMI_CEC_POLARITY);
265
266	cec->adap = cec_allocate_adapter(&dw_hdmi_cec_ops, cec, "dw_hdmi",
267					 CEC_CAP_DEFAULTS |
268					 CEC_CAP_CONNECTOR_INFO,
269					 CEC_MAX_LOG_ADDRS);
270	if (IS_ERR(cec->adap))
271		return PTR_ERR(cec->adap);
272
273	/* override the module pointer */
274	cec->adap->owner = THIS_MODULE;
275
276	ret = devm_add_action_or_reset(&pdev->dev, dw_hdmi_cec_del, cec);
277	if (ret)
278		return ret;
279
280	ret = devm_request_threaded_irq(&pdev->dev, cec->irq,
281					dw_hdmi_cec_hardirq,
282					dw_hdmi_cec_thread, IRQF_SHARED,
283					"dw-hdmi-cec", cec->adap);
284	if (ret < 0)
285		return ret;
286
287	cec->notify = cec_notifier_cec_adap_register(pdev->dev.parent,
288						     NULL, cec->adap);
289	if (!cec->notify)
290		return -ENOMEM;
291
292	ret = cec_register_adapter(cec->adap, pdev->dev.parent);
293	if (ret < 0) {
294		cec_notifier_cec_adap_unregister(cec->notify, cec->adap);
295		return ret;
296	}
297
298	/*
299	 * CEC documentation says we must not call cec_delete_adapter
300	 * after a successful call to cec_register_adapter().
301	 */
302	devm_remove_action(&pdev->dev, dw_hdmi_cec_del, cec);
303
304	return 0;
305}
306
307static void dw_hdmi_cec_remove(struct platform_device *pdev)
308{
309	struct dw_hdmi_cec *cec = platform_get_drvdata(pdev);
310
311	cec_notifier_cec_adap_unregister(cec->notify, cec->adap);
312	cec_unregister_adapter(cec->adap);
313}
314
315static int __maybe_unused dw_hdmi_cec_resume(struct device *dev)
316{
317	struct dw_hdmi_cec *cec = dev_get_drvdata(dev);
318
319	/* Restore logical address */
320	dw_hdmi_write(cec, cec->addresses & 255, HDMI_CEC_ADDR_L);
321	dw_hdmi_write(cec, cec->addresses >> 8, HDMI_CEC_ADDR_H);
322
323	/* Restore interrupt status/mask registers */
324	dw_hdmi_write(cec, cec->regs_polarity, HDMI_CEC_POLARITY);
325	dw_hdmi_write(cec, cec->regs_mask, HDMI_CEC_MASK);
326	dw_hdmi_write(cec, cec->regs_mute_stat0, HDMI_IH_MUTE_CEC_STAT0);
327
328	return 0;
329}
330
331static int __maybe_unused dw_hdmi_cec_suspend(struct device *dev)
332{
333	struct dw_hdmi_cec *cec = dev_get_drvdata(dev);
334
335	/* store interrupt status/mask registers */
336	 cec->regs_polarity = dw_hdmi_read(cec, HDMI_CEC_POLARITY);
337	 cec->regs_mask = dw_hdmi_read(cec, HDMI_CEC_MASK);
338	 cec->regs_mute_stat0 = dw_hdmi_read(cec, HDMI_IH_MUTE_CEC_STAT0);
339
340	return 0;
341}
342
343static const struct dev_pm_ops dw_hdmi_cec_pm = {
344	SET_SYSTEM_SLEEP_PM_OPS(dw_hdmi_cec_suspend, dw_hdmi_cec_resume)
345};
346
347static struct platform_driver dw_hdmi_cec_driver = {
348	.probe	= dw_hdmi_cec_probe,
349	.remove_new = dw_hdmi_cec_remove,
350	.driver = {
351		.name = "dw-hdmi-cec",
352		.pm = &dw_hdmi_cec_pm,
353	},
354};
355module_platform_driver(dw_hdmi_cec_driver);
356
357MODULE_AUTHOR("Russell King <rmk+kernel@armlinux.org.uk>");
358MODULE_DESCRIPTION("Synopsys Designware HDMI CEC driver for i.MX");
359MODULE_LICENSE("GPL");
360MODULE_ALIAS(PLATFORM_MODULE_PREFIX "dw-hdmi-cec");
361