Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net
[sfrench/cifs-2.6.git] / drivers / media / platform / meson / ao-cec.c
1 /*
2  * Driver for Amlogic Meson AO CEC Controller
3  *
4  * Copyright (C) 2015 Amlogic, Inc. All rights reserved
5  * Copyright (C) 2017 BayLibre, SAS
6  * Author: Neil Armstrong <narmstrong@baylibre.com>
7  *
8  * SPDX-License-Identifier: GPL-2.0+
9  */
10
11 #include <linux/bitfield.h>
12 #include <linux/clk.h>
13 #include <linux/device.h>
14 #include <linux/io.h>
15 #include <linux/delay.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/of.h>
19 #include <linux/of_platform.h>
20 #include <linux/platform_device.h>
21 #include <linux/types.h>
22 #include <linux/interrupt.h>
23 #include <linux/reset.h>
24 #include <media/cec.h>
25 #include <media/cec-notifier.h>
26
27 /* CEC Registers */
28
29 /*
30  * [2:1] cntl_clk
31  *  - 0 = Disable clk (Power-off mode)
32  *  - 1 = Enable gated clock (Normal mode)
33  *  - 2 = Enable free-run clk (Debug mode)
34  */
35 #define CEC_GEN_CNTL_REG                0x00
36
37 #define CEC_GEN_CNTL_RESET              BIT(0)
38 #define CEC_GEN_CNTL_CLK_DISABLE        0
39 #define CEC_GEN_CNTL_CLK_ENABLE         1
40 #define CEC_GEN_CNTL_CLK_ENABLE_DBG     2
41 #define CEC_GEN_CNTL_CLK_CTRL_MASK      GENMASK(2, 1)
42
43 /*
44  * [7:0] cec_reg_addr
45  * [15:8] cec_reg_wrdata
46  * [16] cec_reg_wr
47  *  - 0 = Read
48  *  - 1 = Write
49  * [23] bus free
50  * [31:24] cec_reg_rddata
51  */
52 #define CEC_RW_REG                      0x04
53
54 #define CEC_RW_ADDR                     GENMASK(7, 0)
55 #define CEC_RW_WR_DATA                  GENMASK(15, 8)
56 #define CEC_RW_WRITE_EN                 BIT(16)
57 #define CEC_RW_BUS_BUSY                 BIT(23)
58 #define CEC_RW_RD_DATA                  GENMASK(31, 24)
59
60 /*
61  * [1] tx intr
62  * [2] rx intr
63  */
64 #define CEC_INTR_MASKN_REG              0x08
65 #define CEC_INTR_CLR_REG                0x0c
66 #define CEC_INTR_STAT_REG               0x10
67
68 #define CEC_INTR_TX                     BIT(1)
69 #define CEC_INTR_RX                     BIT(2)
70
71 /* CEC Commands */
72
73 #define CEC_TX_MSG_0_HEADER             0x00
74 #define CEC_TX_MSG_1_OPCODE             0x01
75 #define CEC_TX_MSG_2_OP1                0x02
76 #define CEC_TX_MSG_3_OP2                0x03
77 #define CEC_TX_MSG_4_OP3                0x04
78 #define CEC_TX_MSG_5_OP4                0x05
79 #define CEC_TX_MSG_6_OP5                0x06
80 #define CEC_TX_MSG_7_OP6                0x07
81 #define CEC_TX_MSG_8_OP7                0x08
82 #define CEC_TX_MSG_9_OP8                0x09
83 #define CEC_TX_MSG_A_OP9                0x0A
84 #define CEC_TX_MSG_B_OP10               0x0B
85 #define CEC_TX_MSG_C_OP11               0x0C
86 #define CEC_TX_MSG_D_OP12               0x0D
87 #define CEC_TX_MSG_E_OP13               0x0E
88 #define CEC_TX_MSG_F_OP14               0x0F
89 #define CEC_TX_MSG_LENGTH               0x10
90 #define CEC_TX_MSG_CMD                  0x11
91 #define CEC_TX_WRITE_BUF                0x12
92 #define CEC_TX_CLEAR_BUF                0x13
93 #define CEC_RX_MSG_CMD                  0x14
94 #define CEC_RX_CLEAR_BUF                0x15
95 #define CEC_LOGICAL_ADDR0               0x16
96 #define CEC_LOGICAL_ADDR1               0x17
97 #define CEC_LOGICAL_ADDR2               0x18
98 #define CEC_LOGICAL_ADDR3               0x19
99 #define CEC_LOGICAL_ADDR4               0x1A
100 #define CEC_CLOCK_DIV_H                 0x1B
101 #define CEC_CLOCK_DIV_L                 0x1C
102 #define CEC_QUIESCENT_25MS_BIT7_0       0x20
103 #define CEC_QUIESCENT_25MS_BIT11_8      0x21
104 #define CEC_STARTBITMINL2H_3MS5_BIT7_0  0x22
105 #define CEC_STARTBITMINL2H_3MS5_BIT8    0x23
106 #define CEC_STARTBITMAXL2H_3MS9_BIT7_0  0x24
107 #define CEC_STARTBITMAXL2H_3MS9_BIT8    0x25
108 #define CEC_STARTBITMINH_0MS6_BIT7_0    0x26
109 #define CEC_STARTBITMINH_0MS6_BIT8      0x27
110 #define CEC_STARTBITMAXH_1MS0_BIT7_0    0x28
111 #define CEC_STARTBITMAXH_1MS0_BIT8      0x29
112 #define CEC_STARTBITMINTOT_4MS3_BIT7_0  0x2A
113 #define CEC_STARTBITMINTOT_4MS3_BIT9_8  0x2B
114 #define CEC_STARTBITMAXTOT_4MS7_BIT7_0  0x2C
115 #define CEC_STARTBITMAXTOT_4MS7_BIT9_8  0x2D
116 #define CEC_LOGIC1MINL2H_0MS4_BIT7_0    0x2E
117 #define CEC_LOGIC1MINL2H_0MS4_BIT8      0x2F
118 #define CEC_LOGIC1MAXL2H_0MS8_BIT7_0    0x30
119 #define CEC_LOGIC1MAXL2H_0MS8_BIT8      0x31
120 #define CEC_LOGIC0MINL2H_1MS3_BIT7_0    0x32
121 #define CEC_LOGIC0MINL2H_1MS3_BIT8      0x33
122 #define CEC_LOGIC0MAXL2H_1MS7_BIT7_0    0x34
123 #define CEC_LOGIC0MAXL2H_1MS7_BIT8      0x35
124 #define CEC_LOGICMINTOTAL_2MS05_BIT7_0  0x36
125 #define CEC_LOGICMINTOTAL_2MS05_BIT9_8  0x37
126 #define CEC_LOGICMAXHIGH_2MS8_BIT7_0    0x38
127 #define CEC_LOGICMAXHIGH_2MS8_BIT8      0x39
128 #define CEC_LOGICERRLOW_3MS4_BIT7_0     0x3A
129 #define CEC_LOGICERRLOW_3MS4_BIT8       0x3B
130 #define CEC_NOMSMPPOINT_1MS05           0x3C
131 #define CEC_DELCNTR_LOGICERR            0x3E
132 #define CEC_TXTIME_17MS_BIT7_0          0x40
133 #define CEC_TXTIME_17MS_BIT10_8         0x41
134 #define CEC_TXTIME_2BIT_BIT7_0          0x42
135 #define CEC_TXTIME_2BIT_BIT10_8         0x43
136 #define CEC_TXTIME_4BIT_BIT7_0          0x44
137 #define CEC_TXTIME_4BIT_BIT10_8         0x45
138 #define CEC_STARTBITNOML2H_3MS7_BIT7_0  0x46
139 #define CEC_STARTBITNOML2H_3MS7_BIT8    0x47
140 #define CEC_STARTBITNOMH_0MS8_BIT7_0    0x48
141 #define CEC_STARTBITNOMH_0MS8_BIT8      0x49
142 #define CEC_LOGIC1NOML2H_0MS6_BIT7_0    0x4A
143 #define CEC_LOGIC1NOML2H_0MS6_BIT8      0x4B
144 #define CEC_LOGIC0NOML2H_1MS5_BIT7_0    0x4C
145 #define CEC_LOGIC0NOML2H_1MS5_BIT8      0x4D
146 #define CEC_LOGIC1NOMH_1MS8_BIT7_0      0x4E
147 #define CEC_LOGIC1NOMH_1MS8_BIT8        0x4F
148 #define CEC_LOGIC0NOMH_0MS9_BIT7_0      0x50
149 #define CEC_LOGIC0NOMH_0MS9_BIT8        0x51
150 #define CEC_LOGICERRLOW_3MS6_BIT7_0     0x52
151 #define CEC_LOGICERRLOW_3MS6_BIT8       0x53
152 #define CEC_CHKCONTENTION_0MS1          0x54
153 #define CEC_PREPARENXTBIT_0MS05_BIT7_0  0x56
154 #define CEC_PREPARENXTBIT_0MS05_BIT8    0x57
155 #define CEC_NOMSMPACKPOINT_0MS45        0x58
156 #define CEC_ACK0NOML2H_1MS5_BIT7_0      0x5A
157 #define CEC_ACK0NOML2H_1MS5_BIT8        0x5B
158 #define CEC_BUGFIX_DISABLE_0            0x60
159 #define CEC_BUGFIX_DISABLE_1            0x61
160 #define CEC_RX_MSG_0_HEADER             0x80
161 #define CEC_RX_MSG_1_OPCODE             0x81
162 #define CEC_RX_MSG_2_OP1                0x82
163 #define CEC_RX_MSG_3_OP2                0x83
164 #define CEC_RX_MSG_4_OP3                0x84
165 #define CEC_RX_MSG_5_OP4                0x85
166 #define CEC_RX_MSG_6_OP5                0x86
167 #define CEC_RX_MSG_7_OP6                0x87
168 #define CEC_RX_MSG_8_OP7                0x88
169 #define CEC_RX_MSG_9_OP8                0x89
170 #define CEC_RX_MSG_A_OP9                0x8A
171 #define CEC_RX_MSG_B_OP10               0x8B
172 #define CEC_RX_MSG_C_OP11               0x8C
173 #define CEC_RX_MSG_D_OP12               0x8D
174 #define CEC_RX_MSG_E_OP13               0x8E
175 #define CEC_RX_MSG_F_OP14               0x8F
176 #define CEC_RX_MSG_LENGTH               0x90
177 #define CEC_RX_MSG_STATUS               0x91
178 #define CEC_RX_NUM_MSG                  0x92
179 #define CEC_TX_MSG_STATUS               0x93
180 #define CEC_TX_NUM_MSG                  0x94
181
182
183 /* CEC_TX_MSG_CMD definition */
184 #define TX_NO_OP        0  /* No transaction */
185 #define TX_REQ_CURRENT  1  /* Transmit earliest message in buffer */
186 #define TX_ABORT        2  /* Abort transmitting earliest message */
187 #define TX_REQ_NEXT     3  /* Overwrite earliest msg, transmit next */
188
189 /* tx_msg_status definition */
190 #define TX_IDLE         0  /* No transaction */
191 #define TX_BUSY         1  /* Transmitter is busy */
192 #define TX_DONE         2  /* Message successfully transmitted */
193 #define TX_ERROR        3  /* Message transmitted with error */
194
195 /* rx_msg_cmd */
196 #define RX_NO_OP        0  /* No transaction */
197 #define RX_ACK_CURRENT  1  /* Read earliest message in buffer */
198 #define RX_DISABLE      2  /* Disable receiving latest message */
199 #define RX_ACK_NEXT     3  /* Clear earliest msg, read next */
200
201 /* rx_msg_status */
202 #define RX_IDLE         0  /* No transaction */
203 #define RX_BUSY         1  /* Receiver is busy */
204 #define RX_DONE         2  /* Message has been received successfully */
205 #define RX_ERROR        3  /* Message has been received with error */
206
207 /* RX_CLEAR_BUF options */
208 #define CLEAR_START     1
209 #define CLEAR_STOP      0
210
211 /* CEC_LOGICAL_ADDRx options */
212 #define LOGICAL_ADDR_MASK       0xf
213 #define LOGICAL_ADDR_VALID      BIT(4)
214 #define LOGICAL_ADDR_DISABLE    0
215
216 #define CEC_CLK_RATE            32768
217
218 struct meson_ao_cec_device {
219         struct platform_device          *pdev;
220         void __iomem                    *base;
221         struct clk                      *core;
222         spinlock_t                      cec_reg_lock;
223         struct cec_notifier             *notify;
224         struct cec_adapter              *adap;
225         struct cec_msg                  rx_msg;
226 };
227
228 #define writel_bits_relaxed(mask, val, addr) \
229         writel_relaxed((readl_relaxed(addr) & ~(mask)) | (val), addr)
230
231 static inline int meson_ao_cec_wait_busy(struct meson_ao_cec_device *ao_cec)
232 {
233         ktime_t timeout = ktime_add_us(ktime_get(), 5000);
234
235         while (readl_relaxed(ao_cec->base + CEC_RW_REG) & CEC_RW_BUS_BUSY) {
236                 if (ktime_compare(ktime_get(), timeout) > 0)
237                         return -ETIMEDOUT;
238         }
239
240         return 0;
241 }
242
243 static void meson_ao_cec_read(struct meson_ao_cec_device *ao_cec,
244                              unsigned long address, u8 *data,
245                              int *res)
246 {
247         unsigned long flags;
248         u32 reg = FIELD_PREP(CEC_RW_ADDR, address);
249         int ret = 0;
250
251         if (res && *res)
252                 return;
253
254         spin_lock_irqsave(&ao_cec->cec_reg_lock, flags);
255
256         ret = meson_ao_cec_wait_busy(ao_cec);
257         if (ret)
258                 goto read_out;
259
260         writel_relaxed(reg, ao_cec->base + CEC_RW_REG);
261
262         ret = meson_ao_cec_wait_busy(ao_cec);
263         if (ret)
264                 goto read_out;
265
266         *data = FIELD_GET(CEC_RW_RD_DATA,
267                           readl_relaxed(ao_cec->base + CEC_RW_REG));
268
269 read_out:
270         spin_unlock_irqrestore(&ao_cec->cec_reg_lock, flags);
271
272         if (res)
273                 *res = ret;
274 }
275
276 static void meson_ao_cec_write(struct meson_ao_cec_device *ao_cec,
277                                unsigned long address, u8 data,
278                                int *res)
279 {
280         unsigned long flags;
281         u32 reg = FIELD_PREP(CEC_RW_ADDR, address) |
282                   FIELD_PREP(CEC_RW_WR_DATA, data) |
283                   CEC_RW_WRITE_EN;
284         int ret = 0;
285
286         if (res && *res)
287                 return;
288
289         spin_lock_irqsave(&ao_cec->cec_reg_lock, flags);
290
291         ret = meson_ao_cec_wait_busy(ao_cec);
292         if (ret)
293                 goto write_out;
294
295         writel_relaxed(reg, ao_cec->base + CEC_RW_REG);
296
297 write_out:
298         spin_unlock_irqrestore(&ao_cec->cec_reg_lock, flags);
299
300         if (res)
301                 *res = ret;
302 }
303
304 static inline void meson_ao_cec_irq_setup(struct meson_ao_cec_device *ao_cec,
305                                       bool enable)
306 {
307         u32 cfg = CEC_INTR_TX | CEC_INTR_RX;
308
309         writel_bits_relaxed(cfg, enable ? cfg : 0,
310                             ao_cec->base + CEC_INTR_MASKN_REG);
311 }
312
313 static inline int meson_ao_cec_clear(struct meson_ao_cec_device *ao_cec)
314 {
315         int ret = 0;
316
317         meson_ao_cec_write(ao_cec, CEC_RX_MSG_CMD, RX_DISABLE, &ret);
318         meson_ao_cec_write(ao_cec, CEC_TX_MSG_CMD, TX_ABORT, &ret);
319         meson_ao_cec_write(ao_cec, CEC_RX_CLEAR_BUF, 1, &ret);
320         meson_ao_cec_write(ao_cec, CEC_TX_CLEAR_BUF, 1, &ret);
321         if (ret)
322                 return ret;
323
324         udelay(100);
325
326         meson_ao_cec_write(ao_cec, CEC_RX_CLEAR_BUF, 0, &ret);
327         meson_ao_cec_write(ao_cec, CEC_TX_CLEAR_BUF, 0, &ret);
328         if (ret)
329                 return ret;
330
331         udelay(100);
332
333         meson_ao_cec_write(ao_cec, CEC_RX_MSG_CMD, RX_NO_OP, &ret);
334         meson_ao_cec_write(ao_cec, CEC_TX_MSG_CMD, TX_NO_OP, &ret);
335
336         return ret;
337 }
338
339 static int meson_ao_cec_arbit_bit_time_set(struct meson_ao_cec_device *ao_cec,
340                                            unsigned int bit_set,
341                                            unsigned int time_set)
342 {
343         int ret = 0;
344
345         switch (bit_set) {
346         case CEC_SIGNAL_FREE_TIME_RETRY:
347                 meson_ao_cec_write(ao_cec, CEC_TXTIME_4BIT_BIT7_0,
348                                    time_set & 0xff, &ret);
349                 meson_ao_cec_write(ao_cec, CEC_TXTIME_4BIT_BIT10_8,
350                                    (time_set >> 8) & 0x7, &ret);
351                 break;
352
353         case CEC_SIGNAL_FREE_TIME_NEW_INITIATOR:
354                 meson_ao_cec_write(ao_cec, CEC_TXTIME_2BIT_BIT7_0,
355                                    time_set & 0xff, &ret);
356                 meson_ao_cec_write(ao_cec, CEC_TXTIME_2BIT_BIT10_8,
357                                    (time_set >> 8) & 0x7, &ret);
358                 break;
359
360         case CEC_SIGNAL_FREE_TIME_NEXT_XFER:
361                 meson_ao_cec_write(ao_cec, CEC_TXTIME_17MS_BIT7_0,
362                                    time_set & 0xff, &ret);
363                 meson_ao_cec_write(ao_cec, CEC_TXTIME_17MS_BIT10_8,
364                                    (time_set >> 8) & 0x7, &ret);
365                 break;
366         }
367
368         return ret;
369 }
370
371 static irqreturn_t meson_ao_cec_irq(int irq, void *data)
372 {
373         struct meson_ao_cec_device *ao_cec = data;
374         u32 stat = readl_relaxed(ao_cec->base + CEC_INTR_STAT_REG);
375
376         if (stat)
377                 return IRQ_WAKE_THREAD;
378
379         return IRQ_NONE;
380 }
381
382 static void meson_ao_cec_irq_tx(struct meson_ao_cec_device *ao_cec)
383 {
384         unsigned long tx_status = 0;
385         u8 stat;
386         int ret = 0;
387
388         meson_ao_cec_read(ao_cec, CEC_TX_MSG_STATUS, &stat, &ret);
389         if (ret)
390                 goto tx_reg_err;
391
392         switch (stat) {
393         case TX_DONE:
394                 tx_status = CEC_TX_STATUS_OK;
395                 break;
396
397         case TX_BUSY:
398                 tx_status = CEC_TX_STATUS_ARB_LOST;
399                 break;
400
401         case TX_IDLE:
402                 tx_status = CEC_TX_STATUS_LOW_DRIVE;
403                 break;
404
405         case TX_ERROR:
406         default:
407                 tx_status = CEC_TX_STATUS_NACK;
408                 break;
409         }
410
411         /* Clear Interruption */
412         writel_relaxed(CEC_INTR_TX, ao_cec->base + CEC_INTR_CLR_REG);
413
414         /* Stop TX */
415         meson_ao_cec_write(ao_cec, CEC_TX_MSG_CMD, TX_NO_OP, &ret);
416         if (ret)
417                 goto tx_reg_err;
418
419         cec_transmit_attempt_done(ao_cec->adap, tx_status);
420         return;
421
422 tx_reg_err:
423         cec_transmit_attempt_done(ao_cec->adap, CEC_TX_STATUS_ERROR);
424 }
425
426 static void meson_ao_cec_irq_rx(struct meson_ao_cec_device *ao_cec)
427 {
428         int i, ret = 0;
429         u8 reg;
430
431         meson_ao_cec_read(ao_cec, CEC_RX_MSG_STATUS, &reg, &ret);
432         if (reg != RX_DONE)
433                 goto rx_out;
434
435         meson_ao_cec_read(ao_cec, CEC_RX_NUM_MSG, &reg, &ret);
436         if (reg != 1)
437                 goto rx_out;
438
439         meson_ao_cec_read(ao_cec, CEC_RX_MSG_LENGTH, &reg, &ret);
440
441         ao_cec->rx_msg.len = reg + 1;
442         if (ao_cec->rx_msg.len > CEC_MAX_MSG_SIZE)
443                 ao_cec->rx_msg.len = CEC_MAX_MSG_SIZE;
444
445         for (i = 0; i < ao_cec->rx_msg.len; i++) {
446                 u8 byte;
447
448                 meson_ao_cec_read(ao_cec, CEC_RX_MSG_0_HEADER + i, &byte, &ret);
449
450                 ao_cec->rx_msg.msg[i] = byte;
451         }
452
453         if (ret)
454                 goto rx_out;
455
456         cec_received_msg(ao_cec->adap, &ao_cec->rx_msg);
457
458 rx_out:
459         /* Clear Interruption */
460         writel_relaxed(CEC_INTR_RX, ao_cec->base + CEC_INTR_CLR_REG);
461
462         /* Ack RX message */
463         meson_ao_cec_write(ao_cec, CEC_RX_MSG_CMD, RX_ACK_CURRENT, &ret);
464         meson_ao_cec_write(ao_cec, CEC_RX_MSG_CMD, RX_NO_OP, &ret);
465
466         /* Clear RX buffer */
467         meson_ao_cec_write(ao_cec, CEC_RX_CLEAR_BUF, CLEAR_START, &ret);
468         meson_ao_cec_write(ao_cec, CEC_RX_CLEAR_BUF, CLEAR_STOP, &ret);
469 }
470
471 static irqreturn_t meson_ao_cec_irq_thread(int irq, void *data)
472 {
473         struct meson_ao_cec_device *ao_cec = data;
474         u32 stat = readl_relaxed(ao_cec->base + CEC_INTR_STAT_REG);
475
476         if (stat & CEC_INTR_TX)
477                 meson_ao_cec_irq_tx(ao_cec);
478
479         meson_ao_cec_irq_rx(ao_cec);
480
481         return IRQ_HANDLED;
482 }
483
484 static int meson_ao_cec_set_log_addr(struct cec_adapter *adap, u8 logical_addr)
485 {
486         struct meson_ao_cec_device *ao_cec = adap->priv;
487         int ret = 0;
488
489         meson_ao_cec_write(ao_cec, CEC_LOGICAL_ADDR0,
490                            LOGICAL_ADDR_DISABLE, &ret);
491         if (ret)
492                 return ret;
493
494         ret = meson_ao_cec_clear(ao_cec);
495         if (ret)
496                 return ret;
497
498         if (logical_addr == CEC_LOG_ADDR_INVALID)
499                 return 0;
500
501         meson_ao_cec_write(ao_cec, CEC_LOGICAL_ADDR0,
502                            logical_addr & LOGICAL_ADDR_MASK, &ret);
503         if (ret)
504                 return ret;
505
506         udelay(100);
507
508         meson_ao_cec_write(ao_cec, CEC_LOGICAL_ADDR0,
509                            (logical_addr & LOGICAL_ADDR_MASK) |
510                            LOGICAL_ADDR_VALID, &ret);
511
512         return ret;
513 }
514
515 static int meson_ao_cec_transmit(struct cec_adapter *adap, u8 attempts,
516                                  u32 signal_free_time, struct cec_msg *msg)
517 {
518         struct meson_ao_cec_device *ao_cec = adap->priv;
519         int i, ret = 0;
520         u8 reg;
521
522         meson_ao_cec_read(ao_cec, CEC_TX_MSG_STATUS, &reg, &ret);
523         if (ret)
524                 return ret;
525
526         if (reg == TX_BUSY) {
527                 dev_dbg(&ao_cec->pdev->dev, "%s: busy TX: aborting\n",
528                         __func__);
529                 meson_ao_cec_write(ao_cec, CEC_TX_MSG_CMD, TX_ABORT, &ret);
530         }
531
532         for (i = 0; i < msg->len; i++) {
533                 meson_ao_cec_write(ao_cec, CEC_TX_MSG_0_HEADER + i,
534                                    msg->msg[i], &ret);
535         }
536
537         meson_ao_cec_write(ao_cec, CEC_TX_MSG_LENGTH, msg->len - 1, &ret);
538         meson_ao_cec_write(ao_cec, CEC_TX_MSG_CMD, TX_REQ_CURRENT, &ret);
539
540         return ret;
541 }
542
543 static int meson_ao_cec_adap_enable(struct cec_adapter *adap, bool enable)
544 {
545         struct meson_ao_cec_device *ao_cec = adap->priv;
546         int ret;
547
548         meson_ao_cec_irq_setup(ao_cec, false);
549
550         writel_bits_relaxed(CEC_GEN_CNTL_RESET, CEC_GEN_CNTL_RESET,
551                             ao_cec->base + CEC_GEN_CNTL_REG);
552
553         if (!enable)
554                 return 0;
555
556         /* Enable gated clock (Normal mode). */
557         writel_bits_relaxed(CEC_GEN_CNTL_CLK_CTRL_MASK,
558                             FIELD_PREP(CEC_GEN_CNTL_CLK_CTRL_MASK,
559                                        CEC_GEN_CNTL_CLK_ENABLE),
560                             ao_cec->base + CEC_GEN_CNTL_REG);
561
562         udelay(100);
563
564         /* Release Reset */
565         writel_bits_relaxed(CEC_GEN_CNTL_RESET, 0,
566                             ao_cec->base + CEC_GEN_CNTL_REG);
567
568         /* Clear buffers */
569         ret = meson_ao_cec_clear(ao_cec);
570         if (ret)
571                 return ret;
572
573         /* CEC arbitration 3/5/7 bit time set. */
574         ret = meson_ao_cec_arbit_bit_time_set(ao_cec,
575                                         CEC_SIGNAL_FREE_TIME_RETRY,
576                                         0x118);
577         if (ret)
578                 return ret;
579         ret = meson_ao_cec_arbit_bit_time_set(ao_cec,
580                                         CEC_SIGNAL_FREE_TIME_NEW_INITIATOR,
581                                         0x000);
582         if (ret)
583                 return ret;
584         ret = meson_ao_cec_arbit_bit_time_set(ao_cec,
585                                         CEC_SIGNAL_FREE_TIME_NEXT_XFER,
586                                         0x2aa);
587         if (ret)
588                 return ret;
589
590         meson_ao_cec_irq_setup(ao_cec, true);
591
592         return 0;
593 }
594
595 static const struct cec_adap_ops meson_ao_cec_ops = {
596         .adap_enable = meson_ao_cec_adap_enable,
597         .adap_log_addr = meson_ao_cec_set_log_addr,
598         .adap_transmit = meson_ao_cec_transmit,
599 };
600
601 static int meson_ao_cec_probe(struct platform_device *pdev)
602 {
603         struct meson_ao_cec_device *ao_cec;
604         struct device *hdmi_dev;
605         struct resource *res;
606         int ret, irq;
607
608         hdmi_dev = cec_notifier_parse_hdmi_phandle(&pdev->dev);
609
610         if (IS_ERR(hdmi_dev))
611                 return PTR_ERR(hdmi_dev);
612
613         ao_cec = devm_kzalloc(&pdev->dev, sizeof(*ao_cec), GFP_KERNEL);
614         if (!ao_cec)
615                 return -ENOMEM;
616
617         spin_lock_init(&ao_cec->cec_reg_lock);
618
619         ao_cec->adap = cec_allocate_adapter(&meson_ao_cec_ops, ao_cec,
620                                             "meson_ao_cec",
621                                             CEC_CAP_DEFAULTS |
622                                             CEC_CAP_CONNECTOR_INFO,
623                                             1); /* Use 1 for now */
624         if (IS_ERR(ao_cec->adap))
625                 return PTR_ERR(ao_cec->adap);
626
627         ao_cec->adap->owner = THIS_MODULE;
628
629         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
630         ao_cec->base = devm_ioremap_resource(&pdev->dev, res);
631         if (IS_ERR(ao_cec->base)) {
632                 ret = PTR_ERR(ao_cec->base);
633                 goto out_probe_adapter;
634         }
635
636         irq = platform_get_irq(pdev, 0);
637         ret = devm_request_threaded_irq(&pdev->dev, irq,
638                                         meson_ao_cec_irq,
639                                         meson_ao_cec_irq_thread,
640                                         0, NULL, ao_cec);
641         if (ret) {
642                 dev_err(&pdev->dev, "irq request failed\n");
643                 goto out_probe_adapter;
644         }
645
646         ao_cec->core = devm_clk_get(&pdev->dev, "core");
647         if (IS_ERR(ao_cec->core)) {
648                 dev_err(&pdev->dev, "core clock request failed\n");
649                 ret = PTR_ERR(ao_cec->core);
650                 goto out_probe_adapter;
651         }
652
653         ret = clk_prepare_enable(ao_cec->core);
654         if (ret) {
655                 dev_err(&pdev->dev, "core clock enable failed\n");
656                 goto out_probe_adapter;
657         }
658
659         ret = clk_set_rate(ao_cec->core, CEC_CLK_RATE);
660         if (ret) {
661                 dev_err(&pdev->dev, "core clock set rate failed\n");
662                 goto out_probe_clk;
663         }
664
665         device_reset_optional(&pdev->dev);
666
667         ao_cec->pdev = pdev;
668         platform_set_drvdata(pdev, ao_cec);
669
670         ao_cec->notify = cec_notifier_cec_adap_register(hdmi_dev, NULL,
671                                                         ao_cec->adap);
672         if (!ao_cec->notify) {
673                 ret = -ENOMEM;
674                 goto out_probe_clk;
675         }
676
677         ret = cec_register_adapter(ao_cec->adap, &pdev->dev);
678         if (ret < 0)
679                 goto out_probe_notify;
680
681         /* Setup Hardware */
682         writel_relaxed(CEC_GEN_CNTL_RESET,
683                        ao_cec->base + CEC_GEN_CNTL_REG);
684
685         return 0;
686
687 out_probe_notify:
688         cec_notifier_cec_adap_unregister(ao_cec->notify);
689
690 out_probe_clk:
691         clk_disable_unprepare(ao_cec->core);
692
693 out_probe_adapter:
694         cec_delete_adapter(ao_cec->adap);
695
696         dev_err(&pdev->dev, "CEC controller registration failed\n");
697
698         return ret;
699 }
700
701 static int meson_ao_cec_remove(struct platform_device *pdev)
702 {
703         struct meson_ao_cec_device *ao_cec = platform_get_drvdata(pdev);
704
705         clk_disable_unprepare(ao_cec->core);
706
707         cec_notifier_cec_adap_unregister(ao_cec->notify);
708         cec_unregister_adapter(ao_cec->adap);
709
710         return 0;
711 }
712
713 static const struct of_device_id meson_ao_cec_of_match[] = {
714         { .compatible = "amlogic,meson-gx-ao-cec", },
715         { /* sentinel */ }
716 };
717 MODULE_DEVICE_TABLE(of, meson_ao_cec_of_match);
718
719 static struct platform_driver meson_ao_cec_driver = {
720         .probe   = meson_ao_cec_probe,
721         .remove  = meson_ao_cec_remove,
722         .driver  = {
723                 .name = "meson-ao-cec",
724                 .of_match_table = of_match_ptr(meson_ao_cec_of_match),
725         },
726 };
727
728 module_platform_driver(meson_ao_cec_driver);
729
730 MODULE_DESCRIPTION("Meson AO CEC Controller driver");
731 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
732 MODULE_LICENSE("GPL");