Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * HDMI CEC
4 *
5 * Based on the CEC code from hdmi_ti_4xxx_ip.c from Android.
6 *
7 * Copyright (C) 2010-2011 Texas Instruments Incorporated - https://www.ti.com/
8 * Authors: Yong Zhi
9 * Mythri pk <mythripk@ti.com>
10 *
11 * Heavily modified to use the linux CEC framework:
12 *
13 * Copyright 2016-2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
14 */
15
16#include <linux/kernel.h>
17#include <linux/err.h>
18#include <linux/io.h>
19#include <linux/platform_device.h>
20#include <linux/slab.h>
21
22#include "dss.h"
23#include "hdmi.h"
24#include "hdmi4_core.h"
25#include "hdmi4_cec.h"
26
27/* HDMI CEC */
28#define HDMI_CEC_DEV_ID 0x900
29#define HDMI_CEC_SPEC 0x904
30
31/* Not really a debug register, more a low-level control register */
32#define HDMI_CEC_DBG_3 0x91C
33#define HDMI_CEC_TX_INIT 0x920
34#define HDMI_CEC_TX_DEST 0x924
35#define HDMI_CEC_SETUP 0x938
36#define HDMI_CEC_TX_COMMAND 0x93C
37#define HDMI_CEC_TX_OPERAND 0x940
38#define HDMI_CEC_TRANSMIT_DATA 0x97C
39#define HDMI_CEC_CA_7_0 0x988
40#define HDMI_CEC_CA_15_8 0x98C
41#define HDMI_CEC_INT_STATUS_0 0x998
42#define HDMI_CEC_INT_STATUS_1 0x99C
43#define HDMI_CEC_INT_ENABLE_0 0x990
44#define HDMI_CEC_INT_ENABLE_1 0x994
45#define HDMI_CEC_RX_CONTROL 0x9B0
46#define HDMI_CEC_RX_COUNT 0x9B4
47#define HDMI_CEC_RX_CMD_HEADER 0x9B8
48#define HDMI_CEC_RX_COMMAND 0x9BC
49#define HDMI_CEC_RX_OPERAND 0x9C0
50
51#define HDMI_CEC_TX_FIFO_INT_MASK 0x64
52#define HDMI_CEC_RETRANSMIT_CNT_INT_MASK 0x2
53
54#define HDMI_CORE_CEC_RETRY 200
55
56static void hdmi_cec_received_msg(struct hdmi_core_data *core)
57{
58 u32 cnt = hdmi_read_reg(core->base, HDMI_CEC_RX_COUNT) & 0xff;
59
60 /* While there are CEC frames in the FIFO */
61 while (cnt & 0x70) {
62 /* and the frame doesn't have an error */
63 if (!(cnt & 0x80)) {
64 struct cec_msg msg = {};
65 unsigned int i;
66
67 /* then read the message */
68 msg.len = cnt & 0xf;
69 if (msg.len > CEC_MAX_MSG_SIZE - 2)
70 msg.len = CEC_MAX_MSG_SIZE - 2;
71 msg.msg[0] = hdmi_read_reg(core->base,
72 HDMI_CEC_RX_CMD_HEADER);
73 msg.msg[1] = hdmi_read_reg(core->base,
74 HDMI_CEC_RX_COMMAND);
75 for (i = 0; i < msg.len; i++) {
76 unsigned int reg = HDMI_CEC_RX_OPERAND + i * 4;
77
78 msg.msg[2 + i] =
79 hdmi_read_reg(core->base, reg);
80 }
81 msg.len += 2;
82 cec_received_msg(core->adap, &msg);
83 }
84 /* Clear the current frame from the FIFO */
85 hdmi_write_reg(core->base, HDMI_CEC_RX_CONTROL, 1);
86 /* Wait until the current frame is cleared */
87 while (hdmi_read_reg(core->base, HDMI_CEC_RX_CONTROL) & 1)
88 udelay(1);
89 /*
90 * Re-read the count register and loop to see if there are
91 * more messages in the FIFO.
92 */
93 cnt = hdmi_read_reg(core->base, HDMI_CEC_RX_COUNT) & 0xff;
94 }
95}
96
97void hdmi4_cec_irq(struct hdmi_core_data *core)
98{
99 u32 stat0 = hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_0);
100 u32 stat1 = hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_1);
101
102 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_0, stat0);
103 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, stat1);
104
105 if (stat0 & 0x20) {
106 cec_transmit_done(core->adap, CEC_TX_STATUS_OK,
107 0, 0, 0, 0);
108 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
109 } else if (stat1 & 0x02) {
110 u32 dbg3 = hdmi_read_reg(core->base, HDMI_CEC_DBG_3);
111
112 cec_transmit_done(core->adap,
113 CEC_TX_STATUS_NACK |
114 CEC_TX_STATUS_MAX_RETRIES,
115 0, (dbg3 >> 4) & 7, 0, 0);
116 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
117 }
118 if (stat0 & 0x02)
119 hdmi_cec_received_msg(core);
120}
121
122static bool hdmi_cec_clear_tx_fifo(struct cec_adapter *adap)
123{
124 struct hdmi_core_data *core = cec_get_drvdata(adap);
125 int retry = HDMI_CORE_CEC_RETRY;
126 int temp;
127
128 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
129 while (retry) {
130 temp = hdmi_read_reg(core->base, HDMI_CEC_DBG_3);
131 if (FLD_GET(temp, 7, 7) == 0)
132 break;
133 retry--;
134 }
135 return retry != 0;
136}
137
138static bool hdmi_cec_clear_rx_fifo(struct cec_adapter *adap)
139{
140 struct hdmi_core_data *core = cec_get_drvdata(adap);
141 int retry = HDMI_CORE_CEC_RETRY;
142 int temp;
143
144 hdmi_write_reg(core->base, HDMI_CEC_RX_CONTROL, 0x3);
145 retry = HDMI_CORE_CEC_RETRY;
146 while (retry) {
147 temp = hdmi_read_reg(core->base, HDMI_CEC_RX_CONTROL);
148 if (FLD_GET(temp, 1, 0) == 0)
149 break;
150 retry--;
151 }
152 return retry != 0;
153}
154
155static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
156{
157 struct hdmi_core_data *core = cec_get_drvdata(adap);
158 int temp, err;
159
160 if (!enable) {
161 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_0, 0);
162 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_1, 0);
163 REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0, 3, 3);
164 hdmi_wp_clear_irqenable(core->wp, HDMI_IRQ_CORE);
165 hdmi_wp_set_irqstatus(core->wp, HDMI_IRQ_CORE);
166 REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
167 hdmi4_core_disable(core);
168 return 0;
169 }
170 err = hdmi4_core_enable(core);
171 if (err)
172 return err;
173
174 /*
175 * Initialize CEC clock divider: CEC needs 2MHz clock hence
176 * set the divider to 24 to get 48/24=2MHz clock
177 */
178 REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0);
179
180 /* Clear TX FIFO */
181 if (!hdmi_cec_clear_tx_fifo(adap)) {
182 pr_err("cec-%s: could not clear TX FIFO\n", adap->name);
183 err = -EIO;
184 goto err_disable_clk;
185 }
186
187 /* Clear RX FIFO */
188 if (!hdmi_cec_clear_rx_fifo(adap)) {
189 pr_err("cec-%s: could not clear RX FIFO\n", adap->name);
190 err = -EIO;
191 goto err_disable_clk;
192 }
193
194 /* Clear CEC interrupts */
195 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1,
196 hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_1));
197 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_0,
198 hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_0));
199
200 /* Enable HDMI core interrupts */
201 hdmi_wp_set_irqenable(core->wp, HDMI_IRQ_CORE);
202 /* Unmask CEC interrupt */
203 REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0x1, 3, 3);
204 /*
205 * Enable CEC interrupts:
206 * Transmit Buffer Full/Empty Change event
207 * Receiver FIFO Not Empty event
208 */
209 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_0, 0x22);
210 /*
211 * Enable CEC interrupts:
212 * Frame Retransmit Count Exceeded event
213 */
214 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_1, 0x02);
215
216 /* cec calibration enable (self clearing) */
217 hdmi_write_reg(core->base, HDMI_CEC_SETUP, 0x03);
218 msleep(20);
219 hdmi_write_reg(core->base, HDMI_CEC_SETUP, 0x04);
220
221 temp = hdmi_read_reg(core->base, HDMI_CEC_SETUP);
222 if (FLD_GET(temp, 4, 4) != 0) {
223 temp = FLD_MOD(temp, 0, 4, 4);
224 hdmi_write_reg(core->base, HDMI_CEC_SETUP, temp);
225
226 /*
227 * If we enabled CEC in middle of a CEC message on the bus,
228 * we could have start bit irregularity and/or short
229 * pulse event. Clear them now.
230 */
231 temp = hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_1);
232 temp = FLD_MOD(0x0, 0x5, 2, 0);
233 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, temp);
234 }
235 return 0;
236
237err_disable_clk:
238 REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
239 hdmi4_core_disable(core);
240
241 return err;
242}
243
244static int hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
245{
246 struct hdmi_core_data *core = cec_get_drvdata(adap);
247 u32 v;
248
249 if (log_addr == CEC_LOG_ADDR_INVALID) {
250 hdmi_write_reg(core->base, HDMI_CEC_CA_7_0, 0);
251 hdmi_write_reg(core->base, HDMI_CEC_CA_15_8, 0);
252 return 0;
253 }
254 if (log_addr <= 7) {
255 v = hdmi_read_reg(core->base, HDMI_CEC_CA_7_0);
256 v |= 1 << log_addr;
257 hdmi_write_reg(core->base, HDMI_CEC_CA_7_0, v);
258 } else {
259 v = hdmi_read_reg(core->base, HDMI_CEC_CA_15_8);
260 v |= 1 << (log_addr - 8);
261 hdmi_write_reg(core->base, HDMI_CEC_CA_15_8, v);
262 }
263 return 0;
264}
265
266static int hdmi_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
267 u32 signal_free_time, struct cec_msg *msg)
268{
269 struct hdmi_core_data *core = cec_get_drvdata(adap);
270 int temp;
271 u32 i;
272
273 /* Clear TX FIFO */
274 if (!hdmi_cec_clear_tx_fifo(adap)) {
275 pr_err("cec-%s: could not clear TX FIFO for transmit\n",
276 adap->name);
277 return -EIO;
278 }
279
280 /* Clear TX interrupts */
281 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_0,
282 HDMI_CEC_TX_FIFO_INT_MASK);
283
284 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1,
285 HDMI_CEC_RETRANSMIT_CNT_INT_MASK);
286
287 /* Set the retry count */
288 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, attempts - 1, 6, 4);
289
290 /* Set the initiator addresses */
291 hdmi_write_reg(core->base, HDMI_CEC_TX_INIT, cec_msg_initiator(msg));
292
293 /* Set destination id */
294 temp = cec_msg_destination(msg);
295 if (msg->len == 1)
296 temp |= 0x80;
297 hdmi_write_reg(core->base, HDMI_CEC_TX_DEST, temp);
298 if (msg->len == 1)
299 return 0;
300
301 /* Setup command and arguments for the command */
302 hdmi_write_reg(core->base, HDMI_CEC_TX_COMMAND, msg->msg[1]);
303
304 for (i = 0; i < msg->len - 2; i++)
305 hdmi_write_reg(core->base, HDMI_CEC_TX_OPERAND + i * 4,
306 msg->msg[2 + i]);
307
308 /* Operand count */
309 hdmi_write_reg(core->base, HDMI_CEC_TRANSMIT_DATA,
310 (msg->len - 2) | 0x10);
311 return 0;
312}
313
314static const struct cec_adap_ops hdmi_cec_adap_ops = {
315 .adap_enable = hdmi_cec_adap_enable,
316 .adap_log_addr = hdmi_cec_adap_log_addr,
317 .adap_transmit = hdmi_cec_adap_transmit,
318};
319
320void hdmi4_cec_set_phys_addr(struct hdmi_core_data *core, u16 pa)
321{
322 cec_s_phys_addr(core->adap, pa, false);
323}
324
325int hdmi4_cec_init(struct platform_device *pdev, struct hdmi_core_data *core,
326 struct hdmi_wp_data *wp)
327{
328 const u32 caps = CEC_CAP_TRANSMIT | CEC_CAP_LOG_ADDRS |
329 CEC_CAP_PASSTHROUGH | CEC_CAP_RC;
330 int ret;
331
332 core->adap = cec_allocate_adapter(&hdmi_cec_adap_ops, core,
333 "omap4", caps, CEC_MAX_LOG_ADDRS);
334 ret = PTR_ERR_OR_ZERO(core->adap);
335 if (ret < 0)
336 return ret;
337 core->wp = wp;
338
339 /* Disable clock initially, hdmi_cec_adap_enable() manages it */
340 REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0, 5, 0);
341
342 ret = cec_register_adapter(core->adap, &pdev->dev);
343 if (ret < 0) {
344 cec_delete_adapter(core->adap);
345 return ret;
346 }
347 return 0;
348}
349
350void hdmi4_cec_uninit(struct hdmi_core_data *core)
351{
352 cec_unregister_adapter(core->adap);
353}
1/*
2 * HDMI CEC
3 *
4 * Based on the CEC code from hdmi_ti_4xxx_ip.c from Android.
5 *
6 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com/
7 * Authors: Yong Zhi
8 * Mythri pk <mythripk@ti.com>
9 *
10 * Heavily modified to use the linux CEC framework:
11 *
12 * Copyright 2016-2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
13 *
14 * This program is free software; you may redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; version 2 of the License.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
22 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
23 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
26 */
27
28#include <linux/kernel.h>
29#include <linux/err.h>
30#include <linux/io.h>
31#include <linux/platform_device.h>
32#include <linux/slab.h>
33
34#include "dss.h"
35#include "hdmi.h"
36#include "hdmi4_core.h"
37#include "hdmi4_cec.h"
38
39/* HDMI CEC */
40#define HDMI_CEC_DEV_ID 0x900
41#define HDMI_CEC_SPEC 0x904
42
43/* Not really a debug register, more a low-level control register */
44#define HDMI_CEC_DBG_3 0x91C
45#define HDMI_CEC_TX_INIT 0x920
46#define HDMI_CEC_TX_DEST 0x924
47#define HDMI_CEC_SETUP 0x938
48#define HDMI_CEC_TX_COMMAND 0x93C
49#define HDMI_CEC_TX_OPERAND 0x940
50#define HDMI_CEC_TRANSMIT_DATA 0x97C
51#define HDMI_CEC_CA_7_0 0x988
52#define HDMI_CEC_CA_15_8 0x98C
53#define HDMI_CEC_INT_STATUS_0 0x998
54#define HDMI_CEC_INT_STATUS_1 0x99C
55#define HDMI_CEC_INT_ENABLE_0 0x990
56#define HDMI_CEC_INT_ENABLE_1 0x994
57#define HDMI_CEC_RX_CONTROL 0x9B0
58#define HDMI_CEC_RX_COUNT 0x9B4
59#define HDMI_CEC_RX_CMD_HEADER 0x9B8
60#define HDMI_CEC_RX_COMMAND 0x9BC
61#define HDMI_CEC_RX_OPERAND 0x9C0
62
63#define HDMI_CEC_TX_FIFO_INT_MASK 0x64
64#define HDMI_CEC_RETRANSMIT_CNT_INT_MASK 0x2
65
66#define HDMI_CORE_CEC_RETRY 200
67
68static void hdmi_cec_received_msg(struct hdmi_core_data *core)
69{
70 u32 cnt = hdmi_read_reg(core->base, HDMI_CEC_RX_COUNT) & 0xff;
71
72 /* While there are CEC frames in the FIFO */
73 while (cnt & 0x70) {
74 /* and the frame doesn't have an error */
75 if (!(cnt & 0x80)) {
76 struct cec_msg msg = {};
77 unsigned int i;
78
79 /* then read the message */
80 msg.len = cnt & 0xf;
81 if (msg.len > CEC_MAX_MSG_SIZE - 2)
82 msg.len = CEC_MAX_MSG_SIZE - 2;
83 msg.msg[0] = hdmi_read_reg(core->base,
84 HDMI_CEC_RX_CMD_HEADER);
85 msg.msg[1] = hdmi_read_reg(core->base,
86 HDMI_CEC_RX_COMMAND);
87 for (i = 0; i < msg.len; i++) {
88 unsigned int reg = HDMI_CEC_RX_OPERAND + i * 4;
89
90 msg.msg[2 + i] =
91 hdmi_read_reg(core->base, reg);
92 }
93 msg.len += 2;
94 cec_received_msg(core->adap, &msg);
95 }
96 /* Clear the current frame from the FIFO */
97 hdmi_write_reg(core->base, HDMI_CEC_RX_CONTROL, 1);
98 /* Wait until the current frame is cleared */
99 while (hdmi_read_reg(core->base, HDMI_CEC_RX_CONTROL) & 1)
100 udelay(1);
101 /*
102 * Re-read the count register and loop to see if there are
103 * more messages in the FIFO.
104 */
105 cnt = hdmi_read_reg(core->base, HDMI_CEC_RX_COUNT) & 0xff;
106 }
107}
108
109void hdmi4_cec_irq(struct hdmi_core_data *core)
110{
111 u32 stat0 = hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_0);
112 u32 stat1 = hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_1);
113
114 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_0, stat0);
115 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, stat1);
116
117 if (stat0 & 0x20) {
118 cec_transmit_done(core->adap, CEC_TX_STATUS_OK,
119 0, 0, 0, 0);
120 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
121 } else if (stat1 & 0x02) {
122 u32 dbg3 = hdmi_read_reg(core->base, HDMI_CEC_DBG_3);
123
124 cec_transmit_done(core->adap,
125 CEC_TX_STATUS_NACK |
126 CEC_TX_STATUS_MAX_RETRIES,
127 0, (dbg3 >> 4) & 7, 0, 0);
128 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
129 }
130 if (stat0 & 0x02)
131 hdmi_cec_received_msg(core);
132}
133
134static bool hdmi_cec_clear_tx_fifo(struct cec_adapter *adap)
135{
136 struct hdmi_core_data *core = cec_get_drvdata(adap);
137 int retry = HDMI_CORE_CEC_RETRY;
138 int temp;
139
140 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, 0x1, 7, 7);
141 while (retry) {
142 temp = hdmi_read_reg(core->base, HDMI_CEC_DBG_3);
143 if (FLD_GET(temp, 7, 7) == 0)
144 break;
145 retry--;
146 }
147 return retry != 0;
148}
149
150static bool hdmi_cec_clear_rx_fifo(struct cec_adapter *adap)
151{
152 struct hdmi_core_data *core = cec_get_drvdata(adap);
153 int retry = HDMI_CORE_CEC_RETRY;
154 int temp;
155
156 hdmi_write_reg(core->base, HDMI_CEC_RX_CONTROL, 0x3);
157 retry = HDMI_CORE_CEC_RETRY;
158 while (retry) {
159 temp = hdmi_read_reg(core->base, HDMI_CEC_RX_CONTROL);
160 if (FLD_GET(temp, 1, 0) == 0)
161 break;
162 retry--;
163 }
164 return retry != 0;
165}
166
167static int hdmi_cec_adap_enable(struct cec_adapter *adap, bool enable)
168{
169 struct hdmi_core_data *core = cec_get_drvdata(adap);
170 int temp, err;
171
172 if (!enable) {
173 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_0, 0);
174 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_1, 0);
175 REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0, 3, 3);
176 hdmi_wp_clear_irqenable(core->wp, HDMI_IRQ_CORE);
177 hdmi_wp_set_irqstatus(core->wp, HDMI_IRQ_CORE);
178 hdmi4_core_disable(core);
179 return 0;
180 }
181 err = hdmi4_core_enable(core);
182 if (err)
183 return err;
184
185 /* Clear TX FIFO */
186 if (!hdmi_cec_clear_tx_fifo(adap)) {
187 pr_err("cec-%s: could not clear TX FIFO\n", adap->name);
188 return -EIO;
189 }
190
191 /* Clear RX FIFO */
192 if (!hdmi_cec_clear_rx_fifo(adap)) {
193 pr_err("cec-%s: could not clear RX FIFO\n", adap->name);
194 return -EIO;
195 }
196
197 /* Clear CEC interrupts */
198 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1,
199 hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_1));
200 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_0,
201 hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_0));
202
203 /* Enable HDMI core interrupts */
204 hdmi_wp_set_irqenable(core->wp, HDMI_IRQ_CORE);
205 /* Unmask CEC interrupt */
206 REG_FLD_MOD(core->base, HDMI_CORE_SYS_INTR_UNMASK4, 0x1, 3, 3);
207 /*
208 * Enable CEC interrupts:
209 * Transmit Buffer Full/Empty Change event
210 * Receiver FIFO Not Empty event
211 */
212 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_0, 0x22);
213 /*
214 * Enable CEC interrupts:
215 * Frame Retransmit Count Exceeded event
216 */
217 hdmi_write_reg(core->base, HDMI_CEC_INT_ENABLE_1, 0x02);
218
219 /* cec calibration enable (self clearing) */
220 hdmi_write_reg(core->base, HDMI_CEC_SETUP, 0x03);
221 msleep(20);
222 hdmi_write_reg(core->base, HDMI_CEC_SETUP, 0x04);
223
224 temp = hdmi_read_reg(core->base, HDMI_CEC_SETUP);
225 if (FLD_GET(temp, 4, 4) != 0) {
226 temp = FLD_MOD(temp, 0, 4, 4);
227 hdmi_write_reg(core->base, HDMI_CEC_SETUP, temp);
228
229 /*
230 * If we enabled CEC in middle of a CEC message on the bus,
231 * we could have start bit irregularity and/or short
232 * pulse event. Clear them now.
233 */
234 temp = hdmi_read_reg(core->base, HDMI_CEC_INT_STATUS_1);
235 temp = FLD_MOD(0x0, 0x5, 2, 0);
236 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1, temp);
237 }
238 return 0;
239}
240
241static int hdmi_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
242{
243 struct hdmi_core_data *core = cec_get_drvdata(adap);
244 u32 v;
245
246 if (log_addr == CEC_LOG_ADDR_INVALID) {
247 hdmi_write_reg(core->base, HDMI_CEC_CA_7_0, 0);
248 hdmi_write_reg(core->base, HDMI_CEC_CA_15_8, 0);
249 return 0;
250 }
251 if (log_addr <= 7) {
252 v = hdmi_read_reg(core->base, HDMI_CEC_CA_7_0);
253 v |= 1 << log_addr;
254 hdmi_write_reg(core->base, HDMI_CEC_CA_7_0, v);
255 } else {
256 v = hdmi_read_reg(core->base, HDMI_CEC_CA_15_8);
257 v |= 1 << (log_addr - 8);
258 hdmi_write_reg(core->base, HDMI_CEC_CA_15_8, v);
259 }
260 return 0;
261}
262
263static int hdmi_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
264 u32 signal_free_time, struct cec_msg *msg)
265{
266 struct hdmi_core_data *core = cec_get_drvdata(adap);
267 int temp;
268 u32 i;
269
270 /* Clear TX FIFO */
271 if (!hdmi_cec_clear_tx_fifo(adap)) {
272 pr_err("cec-%s: could not clear TX FIFO for transmit\n",
273 adap->name);
274 return -EIO;
275 }
276
277 /* Clear TX interrupts */
278 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_0,
279 HDMI_CEC_TX_FIFO_INT_MASK);
280
281 hdmi_write_reg(core->base, HDMI_CEC_INT_STATUS_1,
282 HDMI_CEC_RETRANSMIT_CNT_INT_MASK);
283
284 /* Set the retry count */
285 REG_FLD_MOD(core->base, HDMI_CEC_DBG_3, attempts - 1, 6, 4);
286
287 /* Set the initiator addresses */
288 hdmi_write_reg(core->base, HDMI_CEC_TX_INIT, cec_msg_initiator(msg));
289
290 /* Set destination id */
291 temp = cec_msg_destination(msg);
292 if (msg->len == 1)
293 temp |= 0x80;
294 hdmi_write_reg(core->base, HDMI_CEC_TX_DEST, temp);
295 if (msg->len == 1)
296 return 0;
297
298 /* Setup command and arguments for the command */
299 hdmi_write_reg(core->base, HDMI_CEC_TX_COMMAND, msg->msg[1]);
300
301 for (i = 0; i < msg->len - 2; i++)
302 hdmi_write_reg(core->base, HDMI_CEC_TX_OPERAND + i * 4,
303 msg->msg[2 + i]);
304
305 /* Operand count */
306 hdmi_write_reg(core->base, HDMI_CEC_TRANSMIT_DATA,
307 (msg->len - 2) | 0x10);
308 return 0;
309}
310
311static const struct cec_adap_ops hdmi_cec_adap_ops = {
312 .adap_enable = hdmi_cec_adap_enable,
313 .adap_log_addr = hdmi_cec_adap_log_addr,
314 .adap_transmit = hdmi_cec_adap_transmit,
315};
316
317void hdmi4_cec_set_phys_addr(struct hdmi_core_data *core, u16 pa)
318{
319 cec_s_phys_addr(core->adap, pa, false);
320}
321
322int hdmi4_cec_init(struct platform_device *pdev, struct hdmi_core_data *core,
323 struct hdmi_wp_data *wp)
324{
325 const u32 caps = CEC_CAP_TRANSMIT | CEC_CAP_LOG_ADDRS |
326 CEC_CAP_PASSTHROUGH | CEC_CAP_RC;
327 int ret;
328
329 core->adap = cec_allocate_adapter(&hdmi_cec_adap_ops, core,
330 "omap4", caps, CEC_MAX_LOG_ADDRS);
331 ret = PTR_ERR_OR_ZERO(core->adap);
332 if (ret < 0)
333 return ret;
334 core->wp = wp;
335
336 /*
337 * Initialize CEC clock divider: CEC needs 2MHz clock hence
338 * set the devider to 24 to get 48/24=2MHz clock
339 */
340 REG_FLD_MOD(core->wp->base, HDMI_WP_CLK, 0x18, 5, 0);
341
342 ret = cec_register_adapter(core->adap, &pdev->dev);
343 if (ret < 0) {
344 cec_delete_adapter(core->adap);
345 return ret;
346 }
347 return 0;
348}
349
350void hdmi4_cec_uninit(struct hdmi_core_data *core)
351{
352 cec_unregister_adapter(core->adap);
353}