1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates.
5 * Author: Vitor Soares <vitor.soares@synopsys.com>
8 #include <linux/bitops.h>
10 #include <linux/completion.h>
11 #include <linux/err.h>
12 #include <linux/errno.h>
13 #include <linux/i3c/master.h>
14 #include <linux/interrupt.h>
15 #include <linux/ioport.h>
16 #include <linux/iopoll.h>
17 #include <linux/list.h>
18 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/reset.h>
22 #include <linux/slab.h>
24 #include "dw-i3c-master.h"
26 #define DEVICE_CTRL 0x0
27 #define DEV_CTRL_ENABLE BIT(31)
28 #define DEV_CTRL_RESUME BIT(30)
29 #define DEV_CTRL_HOT_JOIN_NACK BIT(8)
30 #define DEV_CTRL_I2C_SLAVE_PRESENT BIT(7)
32 #define DEVICE_ADDR 0x4
33 #define DEV_ADDR_DYNAMIC_ADDR_VALID BIT(31)
34 #define DEV_ADDR_DYNAMIC(x) (((x) << 16) & GENMASK(22, 16))
36 #define HW_CAPABILITY 0x8
37 #define COMMAND_QUEUE_PORT 0xc
38 #define COMMAND_PORT_TOC BIT(30)
39 #define COMMAND_PORT_READ_TRANSFER BIT(28)
40 #define COMMAND_PORT_SDAP BIT(27)
41 #define COMMAND_PORT_ROC BIT(26)
42 #define COMMAND_PORT_SPEED(x) (((x) << 21) & GENMASK(23, 21))
43 #define COMMAND_PORT_DEV_INDEX(x) (((x) << 16) & GENMASK(20, 16))
44 #define COMMAND_PORT_CP BIT(15)
45 #define COMMAND_PORT_CMD(x) (((x) << 7) & GENMASK(14, 7))
46 #define COMMAND_PORT_TID(x) (((x) << 3) & GENMASK(6, 3))
48 #define COMMAND_PORT_ARG_DATA_LEN(x) (((x) << 16) & GENMASK(31, 16))
49 #define COMMAND_PORT_ARG_DATA_LEN_MAX 65536
50 #define COMMAND_PORT_TRANSFER_ARG 0x01
52 #define COMMAND_PORT_SDA_DATA_BYTE_3(x) (((x) << 24) & GENMASK(31, 24))
53 #define COMMAND_PORT_SDA_DATA_BYTE_2(x) (((x) << 16) & GENMASK(23, 16))
54 #define COMMAND_PORT_SDA_DATA_BYTE_1(x) (((x) << 8) & GENMASK(15, 8))
55 #define COMMAND_PORT_SDA_BYTE_STRB_3 BIT(5)
56 #define COMMAND_PORT_SDA_BYTE_STRB_2 BIT(4)
57 #define COMMAND_PORT_SDA_BYTE_STRB_1 BIT(3)
58 #define COMMAND_PORT_SHORT_DATA_ARG 0x02
60 #define COMMAND_PORT_DEV_COUNT(x) (((x) << 21) & GENMASK(25, 21))
61 #define COMMAND_PORT_ADDR_ASSGN_CMD 0x03
63 #define RESPONSE_QUEUE_PORT 0x10
64 #define RESPONSE_PORT_ERR_STATUS(x) (((x) & GENMASK(31, 28)) >> 28)
65 #define RESPONSE_NO_ERROR 0
66 #define RESPONSE_ERROR_CRC 1
67 #define RESPONSE_ERROR_PARITY 2
68 #define RESPONSE_ERROR_FRAME 3
69 #define RESPONSE_ERROR_IBA_NACK 4
70 #define RESPONSE_ERROR_ADDRESS_NACK 5
71 #define RESPONSE_ERROR_OVER_UNDER_FLOW 6
72 #define RESPONSE_ERROR_TRANSF_ABORT 8
73 #define RESPONSE_ERROR_I2C_W_NACK_ERR 9
74 #define RESPONSE_PORT_TID(x) (((x) & GENMASK(27, 24)) >> 24)
75 #define RESPONSE_PORT_DATA_LEN(x) ((x) & GENMASK(15, 0))
77 #define RX_TX_DATA_PORT 0x14
78 #define IBI_QUEUE_STATUS 0x18
79 #define IBI_QUEUE_STATUS_IBI_ID(x) (((x) & GENMASK(15, 8)) >> 8)
80 #define IBI_QUEUE_STATUS_DATA_LEN(x) ((x) & GENMASK(7, 0))
81 #define IBI_QUEUE_IBI_ADDR(x) (IBI_QUEUE_STATUS_IBI_ID(x) >> 1)
82 #define IBI_QUEUE_IBI_RNW(x) (IBI_QUEUE_STATUS_IBI_ID(x) & BIT(0))
83 #define IBI_TYPE_MR(x) \
84 ((IBI_QUEUE_IBI_ADDR(x) != I3C_HOT_JOIN_ADDR) && !IBI_QUEUE_IBI_RNW(x))
85 #define IBI_TYPE_HJ(x) \
86 ((IBI_QUEUE_IBI_ADDR(x) == I3C_HOT_JOIN_ADDR) && !IBI_QUEUE_IBI_RNW(x))
87 #define IBI_TYPE_SIRQ(x) \
88 ((IBI_QUEUE_IBI_ADDR(x) != I3C_HOT_JOIN_ADDR) && IBI_QUEUE_IBI_RNW(x))
90 #define QUEUE_THLD_CTRL 0x1c
91 #define QUEUE_THLD_CTRL_IBI_STAT_MASK GENMASK(31, 24)
92 #define QUEUE_THLD_CTRL_IBI_STAT(x) (((x) - 1) << 24)
93 #define QUEUE_THLD_CTRL_IBI_DATA_MASK GENMASK(20, 16)
94 #define QUEUE_THLD_CTRL_IBI_DATA(x) ((x) << 16)
95 #define QUEUE_THLD_CTRL_RESP_BUF_MASK GENMASK(15, 8)
96 #define QUEUE_THLD_CTRL_RESP_BUF(x) (((x) - 1) << 8)
98 #define DATA_BUFFER_THLD_CTRL 0x20
99 #define DATA_BUFFER_THLD_CTRL_RX_BUF GENMASK(11, 8)
101 #define IBI_QUEUE_CTRL 0x24
102 #define IBI_MR_REQ_REJECT 0x2C
103 #define IBI_SIR_REQ_REJECT 0x30
104 #define IBI_REQ_REJECT_ALL GENMASK(31, 0)
106 #define RESET_CTRL 0x34
107 #define RESET_CTRL_IBI_QUEUE BIT(5)
108 #define RESET_CTRL_RX_FIFO BIT(4)
109 #define RESET_CTRL_TX_FIFO BIT(3)
110 #define RESET_CTRL_RESP_QUEUE BIT(2)
111 #define RESET_CTRL_CMD_QUEUE BIT(1)
112 #define RESET_CTRL_SOFT BIT(0)
114 #define SLV_EVENT_CTRL 0x38
115 #define INTR_STATUS 0x3c
116 #define INTR_STATUS_EN 0x40
117 #define INTR_SIGNAL_EN 0x44
118 #define INTR_FORCE 0x48
119 #define INTR_BUSOWNER_UPDATE_STAT BIT(13)
120 #define INTR_IBI_UPDATED_STAT BIT(12)
121 #define INTR_READ_REQ_RECV_STAT BIT(11)
122 #define INTR_DEFSLV_STAT BIT(10)
123 #define INTR_TRANSFER_ERR_STAT BIT(9)
124 #define INTR_DYN_ADDR_ASSGN_STAT BIT(8)
125 #define INTR_CCC_UPDATED_STAT BIT(6)
126 #define INTR_TRANSFER_ABORT_STAT BIT(5)
127 #define INTR_RESP_READY_STAT BIT(4)
128 #define INTR_CMD_QUEUE_READY_STAT BIT(3)
129 #define INTR_IBI_THLD_STAT BIT(2)
130 #define INTR_RX_THLD_STAT BIT(1)
131 #define INTR_TX_THLD_STAT BIT(0)
132 #define INTR_ALL (INTR_BUSOWNER_UPDATE_STAT | \
133 INTR_IBI_UPDATED_STAT | \
134 INTR_READ_REQ_RECV_STAT | \
136 INTR_TRANSFER_ERR_STAT | \
137 INTR_DYN_ADDR_ASSGN_STAT | \
138 INTR_CCC_UPDATED_STAT | \
139 INTR_TRANSFER_ABORT_STAT | \
140 INTR_RESP_READY_STAT | \
141 INTR_CMD_QUEUE_READY_STAT | \
142 INTR_IBI_THLD_STAT | \
143 INTR_TX_THLD_STAT | \
146 #define INTR_MASTER_MASK (INTR_TRANSFER_ERR_STAT | \
147 INTR_RESP_READY_STAT)
149 #define QUEUE_STATUS_LEVEL 0x4c
150 #define QUEUE_STATUS_IBI_STATUS_CNT(x) (((x) & GENMASK(28, 24)) >> 24)
151 #define QUEUE_STATUS_IBI_BUF_BLR(x) (((x) & GENMASK(23, 16)) >> 16)
152 #define QUEUE_STATUS_LEVEL_RESP(x) (((x) & GENMASK(15, 8)) >> 8)
153 #define QUEUE_STATUS_LEVEL_CMD(x) ((x) & GENMASK(7, 0))
155 #define DATA_BUFFER_STATUS_LEVEL 0x50
156 #define DATA_BUFFER_STATUS_LEVEL_TX(x) ((x) & GENMASK(7, 0))
158 #define PRESENT_STATE 0x54
159 #define CCC_DEVICE_STATUS 0x58
160 #define DEVICE_ADDR_TABLE_POINTER 0x5c
161 #define DEVICE_ADDR_TABLE_DEPTH(x) (((x) & GENMASK(31, 16)) >> 16)
162 #define DEVICE_ADDR_TABLE_ADDR(x) ((x) & GENMASK(7, 0))
164 #define DEV_CHAR_TABLE_POINTER 0x60
165 #define VENDOR_SPECIFIC_REG_POINTER 0x6c
166 #define SLV_PID_VALUE 0x74
167 #define SLV_CHAR_CTRL 0x78
168 #define SLV_MAX_LEN 0x7c
169 #define MAX_READ_TURNAROUND 0x80
170 #define MAX_DATA_SPEED 0x84
171 #define SLV_DEBUG_STATUS 0x88
172 #define SLV_INTR_REQ 0x8c
173 #define DEVICE_CTRL_EXTENDED 0xb0
174 #define SCL_I3C_OD_TIMING 0xb4
175 #define SCL_I3C_PP_TIMING 0xb8
176 #define SCL_I3C_TIMING_HCNT(x) (((x) << 16) & GENMASK(23, 16))
177 #define SCL_I3C_TIMING_LCNT(x) ((x) & GENMASK(7, 0))
178 #define SCL_I3C_TIMING_CNT_MIN 5
180 #define SCL_I2C_FM_TIMING 0xbc
181 #define SCL_I2C_FM_TIMING_HCNT(x) (((x) << 16) & GENMASK(31, 16))
182 #define SCL_I2C_FM_TIMING_LCNT(x) ((x) & GENMASK(15, 0))
184 #define SCL_I2C_FMP_TIMING 0xc0
185 #define SCL_I2C_FMP_TIMING_HCNT(x) (((x) << 16) & GENMASK(23, 16))
186 #define SCL_I2C_FMP_TIMING_LCNT(x) ((x) & GENMASK(15, 0))
188 #define SCL_EXT_LCNT_TIMING 0xc8
189 #define SCL_EXT_LCNT_4(x) (((x) << 24) & GENMASK(31, 24))
190 #define SCL_EXT_LCNT_3(x) (((x) << 16) & GENMASK(23, 16))
191 #define SCL_EXT_LCNT_2(x) (((x) << 8) & GENMASK(15, 8))
192 #define SCL_EXT_LCNT_1(x) ((x) & GENMASK(7, 0))
194 #define SCL_EXT_TERMN_LCNT_TIMING 0xcc
195 #define BUS_FREE_TIMING 0xd4
196 #define BUS_I3C_MST_FREE(x) ((x) & GENMASK(15, 0))
198 #define BUS_IDLE_TIMING 0xd8
199 #define I3C_VER_ID 0xe0
200 #define I3C_VER_TYPE 0xe4
201 #define EXTENDED_CAPABILITY 0xe8
202 #define SLAVE_CONFIG 0xec
204 #define DEV_ADDR_TABLE_IBI_MDB BIT(12)
205 #define DEV_ADDR_TABLE_SIR_REJECT BIT(13)
206 #define DEV_ADDR_TABLE_LEGACY_I2C_DEV BIT(31)
207 #define DEV_ADDR_TABLE_DYNAMIC_ADDR(x) (((x) << 16) & GENMASK(23, 16))
208 #define DEV_ADDR_TABLE_STATIC_ADDR(x) ((x) & GENMASK(6, 0))
209 #define DEV_ADDR_TABLE_LOC(start, idx) ((start) + ((idx) << 2))
211 #define I3C_BUS_SDR1_SCL_RATE 8000000
212 #define I3C_BUS_SDR2_SCL_RATE 6000000
213 #define I3C_BUS_SDR3_SCL_RATE 4000000
214 #define I3C_BUS_SDR4_SCL_RATE 2000000
215 #define I3C_BUS_I2C_FM_TLOW_MIN_NS 1300
216 #define I3C_BUS_I2C_FMP_TLOW_MIN_NS 500
217 #define I3C_BUS_THIGH_MAX_NS 41
219 #define XFER_TIMEOUT (msecs_to_jiffies(1000))
232 struct list_head node;
233 struct completion comp;
236 struct dw_i3c_cmd cmds[] __counted_by(ncmds);
239 struct dw_i3c_i2c_dev_data {
241 struct i3c_generic_ibi_pool *ibi_pool;
244 static u8 even_parity(u8 p)
249 return (0x9669 >> p) & 1;
252 static bool dw_i3c_master_supports_ccc_cmd(struct i3c_master_controller *m,
253 const struct i3c_ccc_cmd *cmd)
259 case I3C_CCC_ENEC(true):
260 case I3C_CCC_ENEC(false):
261 case I3C_CCC_DISEC(true):
262 case I3C_CCC_DISEC(false):
263 case I3C_CCC_ENTAS(0, true):
264 case I3C_CCC_ENTAS(0, false):
265 case I3C_CCC_RSTDAA(true):
266 case I3C_CCC_RSTDAA(false):
268 case I3C_CCC_SETMWL(true):
269 case I3C_CCC_SETMWL(false):
270 case I3C_CCC_SETMRL(true):
271 case I3C_CCC_SETMRL(false):
272 case I3C_CCC_ENTHDR(0):
273 case I3C_CCC_SETDASA:
274 case I3C_CCC_SETNEWDA:
280 case I3C_CCC_GETSTATUS:
281 case I3C_CCC_GETMXDS:
282 case I3C_CCC_GETHDRCAP:
289 static inline struct dw_i3c_master *
290 to_dw_i3c_master(struct i3c_master_controller *master)
292 return container_of(master, struct dw_i3c_master, base);
295 static void dw_i3c_master_disable(struct dw_i3c_master *master)
297 writel(readl(master->regs + DEVICE_CTRL) & ~DEV_CTRL_ENABLE,
298 master->regs + DEVICE_CTRL);
301 static void dw_i3c_master_enable(struct dw_i3c_master *master)
303 writel(readl(master->regs + DEVICE_CTRL) | DEV_CTRL_ENABLE,
304 master->regs + DEVICE_CTRL);
307 static int dw_i3c_master_get_addr_pos(struct dw_i3c_master *master, u8 addr)
311 for (pos = 0; pos < master->maxdevs; pos++) {
312 if (addr == master->devs[pos].addr)
319 static int dw_i3c_master_get_free_pos(struct dw_i3c_master *master)
321 if (!(master->free_pos & GENMASK(master->maxdevs - 1, 0)))
324 return ffs(master->free_pos) - 1;
327 static void dw_i3c_master_wr_tx_fifo(struct dw_i3c_master *master,
328 const u8 *bytes, int nbytes)
330 writesl(master->regs + RX_TX_DATA_PORT, bytes, nbytes / 4);
334 memcpy(&tmp, bytes + (nbytes & ~3), nbytes & 3);
335 writesl(master->regs + RX_TX_DATA_PORT, &tmp, 1);
339 static void dw_i3c_master_read_fifo(struct dw_i3c_master *master,
340 int reg, u8 *bytes, int nbytes)
342 readsl(master->regs + reg, bytes, nbytes / 4);
346 readsl(master->regs + reg, &tmp, 1);
347 memcpy(bytes + (nbytes & ~3), &tmp, nbytes & 3);
351 static void dw_i3c_master_read_rx_fifo(struct dw_i3c_master *master,
352 u8 *bytes, int nbytes)
354 return dw_i3c_master_read_fifo(master, RX_TX_DATA_PORT, bytes, nbytes);
357 static void dw_i3c_master_read_ibi_fifo(struct dw_i3c_master *master,
358 u8 *bytes, int nbytes)
360 return dw_i3c_master_read_fifo(master, IBI_QUEUE_STATUS, bytes, nbytes);
363 static struct dw_i3c_xfer *
364 dw_i3c_master_alloc_xfer(struct dw_i3c_master *master, unsigned int ncmds)
366 struct dw_i3c_xfer *xfer;
368 xfer = kzalloc(struct_size(xfer, cmds, ncmds), GFP_KERNEL);
372 INIT_LIST_HEAD(&xfer->node);
374 xfer->ret = -ETIMEDOUT;
379 static void dw_i3c_master_free_xfer(struct dw_i3c_xfer *xfer)
384 static void dw_i3c_master_start_xfer_locked(struct dw_i3c_master *master)
386 struct dw_i3c_xfer *xfer = master->xferqueue.cur;
393 for (i = 0; i < xfer->ncmds; i++) {
394 struct dw_i3c_cmd *cmd = &xfer->cmds[i];
396 dw_i3c_master_wr_tx_fifo(master, cmd->tx_buf, cmd->tx_len);
399 thld_ctrl = readl(master->regs + QUEUE_THLD_CTRL);
400 thld_ctrl &= ~QUEUE_THLD_CTRL_RESP_BUF_MASK;
401 thld_ctrl |= QUEUE_THLD_CTRL_RESP_BUF(xfer->ncmds);
402 writel(thld_ctrl, master->regs + QUEUE_THLD_CTRL);
404 for (i = 0; i < xfer->ncmds; i++) {
405 struct dw_i3c_cmd *cmd = &xfer->cmds[i];
407 writel(cmd->cmd_hi, master->regs + COMMAND_QUEUE_PORT);
408 writel(cmd->cmd_lo, master->regs + COMMAND_QUEUE_PORT);
412 static void dw_i3c_master_enqueue_xfer(struct dw_i3c_master *master,
413 struct dw_i3c_xfer *xfer)
417 init_completion(&xfer->comp);
418 spin_lock_irqsave(&master->xferqueue.lock, flags);
419 if (master->xferqueue.cur) {
420 list_add_tail(&xfer->node, &master->xferqueue.list);
422 master->xferqueue.cur = xfer;
423 dw_i3c_master_start_xfer_locked(master);
425 spin_unlock_irqrestore(&master->xferqueue.lock, flags);
428 static void dw_i3c_master_dequeue_xfer_locked(struct dw_i3c_master *master,
429 struct dw_i3c_xfer *xfer)
431 if (master->xferqueue.cur == xfer) {
434 master->xferqueue.cur = NULL;
436 writel(RESET_CTRL_RX_FIFO | RESET_CTRL_TX_FIFO |
437 RESET_CTRL_RESP_QUEUE | RESET_CTRL_CMD_QUEUE,
438 master->regs + RESET_CTRL);
440 readl_poll_timeout_atomic(master->regs + RESET_CTRL, status,
441 !status, 10, 1000000);
443 list_del_init(&xfer->node);
447 static void dw_i3c_master_dequeue_xfer(struct dw_i3c_master *master,
448 struct dw_i3c_xfer *xfer)
452 spin_lock_irqsave(&master->xferqueue.lock, flags);
453 dw_i3c_master_dequeue_xfer_locked(master, xfer);
454 spin_unlock_irqrestore(&master->xferqueue.lock, flags);
457 static void dw_i3c_master_end_xfer_locked(struct dw_i3c_master *master, u32 isr)
459 struct dw_i3c_xfer *xfer = master->xferqueue.cur;
466 nresp = readl(master->regs + QUEUE_STATUS_LEVEL);
467 nresp = QUEUE_STATUS_LEVEL_RESP(nresp);
469 for (i = 0; i < nresp; i++) {
470 struct dw_i3c_cmd *cmd;
473 resp = readl(master->regs + RESPONSE_QUEUE_PORT);
475 cmd = &xfer->cmds[RESPONSE_PORT_TID(resp)];
476 cmd->rx_len = RESPONSE_PORT_DATA_LEN(resp);
477 cmd->error = RESPONSE_PORT_ERR_STATUS(resp);
478 if (cmd->rx_len && !cmd->error)
479 dw_i3c_master_read_rx_fifo(master, cmd->rx_buf,
483 for (i = 0; i < nresp; i++) {
484 switch (xfer->cmds[i].error) {
485 case RESPONSE_NO_ERROR:
487 case RESPONSE_ERROR_PARITY:
488 case RESPONSE_ERROR_IBA_NACK:
489 case RESPONSE_ERROR_TRANSF_ABORT:
490 case RESPONSE_ERROR_CRC:
491 case RESPONSE_ERROR_FRAME:
494 case RESPONSE_ERROR_OVER_UNDER_FLOW:
497 case RESPONSE_ERROR_I2C_W_NACK_ERR:
498 case RESPONSE_ERROR_ADDRESS_NACK:
506 complete(&xfer->comp);
509 dw_i3c_master_dequeue_xfer_locked(master, xfer);
510 writel(readl(master->regs + DEVICE_CTRL) | DEV_CTRL_RESUME,
511 master->regs + DEVICE_CTRL);
514 xfer = list_first_entry_or_null(&master->xferqueue.list,
518 list_del_init(&xfer->node);
520 master->xferqueue.cur = xfer;
521 dw_i3c_master_start_xfer_locked(master);
524 static int dw_i3c_clk_cfg(struct dw_i3c_master *master)
526 unsigned long core_rate, core_period;
530 core_rate = clk_get_rate(master->core_clk);
534 core_period = DIV_ROUND_UP(1000000000, core_rate);
536 hcnt = DIV_ROUND_UP(I3C_BUS_THIGH_MAX_NS, core_period) - 1;
537 if (hcnt < SCL_I3C_TIMING_CNT_MIN)
538 hcnt = SCL_I3C_TIMING_CNT_MIN;
540 lcnt = DIV_ROUND_UP(core_rate, master->base.bus.scl_rate.i3c) - hcnt;
541 if (lcnt < SCL_I3C_TIMING_CNT_MIN)
542 lcnt = SCL_I3C_TIMING_CNT_MIN;
544 scl_timing = SCL_I3C_TIMING_HCNT(hcnt) | SCL_I3C_TIMING_LCNT(lcnt);
545 writel(scl_timing, master->regs + SCL_I3C_PP_TIMING);
548 * In pure i3c mode, MST_FREE represents tCAS. In shared mode, this
549 * will be set up by dw_i2c_clk_cfg as tLOW.
551 if (master->base.bus.mode == I3C_BUS_MODE_PURE)
552 writel(BUS_I3C_MST_FREE(lcnt), master->regs + BUS_FREE_TIMING);
555 DIV_ROUND_UP(I3C_BUS_TLOW_OD_MIN_NS, core_period), lcnt);
556 scl_timing = SCL_I3C_TIMING_HCNT(hcnt) | SCL_I3C_TIMING_LCNT(lcnt);
557 writel(scl_timing, master->regs + SCL_I3C_OD_TIMING);
559 lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR1_SCL_RATE) - hcnt;
560 scl_timing = SCL_EXT_LCNT_1(lcnt);
561 lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR2_SCL_RATE) - hcnt;
562 scl_timing |= SCL_EXT_LCNT_2(lcnt);
563 lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR3_SCL_RATE) - hcnt;
564 scl_timing |= SCL_EXT_LCNT_3(lcnt);
565 lcnt = DIV_ROUND_UP(core_rate, I3C_BUS_SDR4_SCL_RATE) - hcnt;
566 scl_timing |= SCL_EXT_LCNT_4(lcnt);
567 writel(scl_timing, master->regs + SCL_EXT_LCNT_TIMING);
572 static int dw_i2c_clk_cfg(struct dw_i3c_master *master)
574 unsigned long core_rate, core_period;
578 core_rate = clk_get_rate(master->core_clk);
582 core_period = DIV_ROUND_UP(1000000000, core_rate);
584 lcnt = DIV_ROUND_UP(I3C_BUS_I2C_FMP_TLOW_MIN_NS, core_period);
585 hcnt = DIV_ROUND_UP(core_rate, I3C_BUS_I2C_FM_PLUS_SCL_RATE) - lcnt;
586 scl_timing = SCL_I2C_FMP_TIMING_HCNT(hcnt) |
587 SCL_I2C_FMP_TIMING_LCNT(lcnt);
588 writel(scl_timing, master->regs + SCL_I2C_FMP_TIMING);
590 lcnt = DIV_ROUND_UP(I3C_BUS_I2C_FM_TLOW_MIN_NS, core_period);
591 hcnt = DIV_ROUND_UP(core_rate, I3C_BUS_I2C_FM_SCL_RATE) - lcnt;
592 scl_timing = SCL_I2C_FM_TIMING_HCNT(hcnt) |
593 SCL_I2C_FM_TIMING_LCNT(lcnt);
594 writel(scl_timing, master->regs + SCL_I2C_FM_TIMING);
596 writel(BUS_I3C_MST_FREE(lcnt), master->regs + BUS_FREE_TIMING);
597 writel(readl(master->regs + DEVICE_CTRL) | DEV_CTRL_I2C_SLAVE_PRESENT,
598 master->regs + DEVICE_CTRL);
603 static int dw_i3c_master_bus_init(struct i3c_master_controller *m)
605 struct dw_i3c_master *master = to_dw_i3c_master(m);
606 struct i3c_bus *bus = i3c_master_get_bus(m);
607 struct i3c_device_info info = { };
611 ret = master->platform_ops->init(master);
616 case I3C_BUS_MODE_MIXED_FAST:
617 case I3C_BUS_MODE_MIXED_LIMITED:
618 ret = dw_i2c_clk_cfg(master);
622 case I3C_BUS_MODE_PURE:
623 ret = dw_i3c_clk_cfg(master);
631 thld_ctrl = readl(master->regs + QUEUE_THLD_CTRL);
632 thld_ctrl &= ~(QUEUE_THLD_CTRL_RESP_BUF_MASK |
633 QUEUE_THLD_CTRL_IBI_STAT_MASK |
634 QUEUE_THLD_CTRL_IBI_STAT_MASK);
635 thld_ctrl |= QUEUE_THLD_CTRL_IBI_STAT(1) |
636 QUEUE_THLD_CTRL_IBI_DATA(31);
637 writel(thld_ctrl, master->regs + QUEUE_THLD_CTRL);
639 thld_ctrl = readl(master->regs + DATA_BUFFER_THLD_CTRL);
640 thld_ctrl &= ~DATA_BUFFER_THLD_CTRL_RX_BUF;
641 writel(thld_ctrl, master->regs + DATA_BUFFER_THLD_CTRL);
643 writel(INTR_ALL, master->regs + INTR_STATUS);
644 writel(INTR_MASTER_MASK, master->regs + INTR_STATUS_EN);
645 writel(INTR_MASTER_MASK, master->regs + INTR_SIGNAL_EN);
647 ret = i3c_master_get_free_addr(m, 0);
651 writel(DEV_ADDR_DYNAMIC_ADDR_VALID | DEV_ADDR_DYNAMIC(ret),
652 master->regs + DEVICE_ADDR);
654 memset(&info, 0, sizeof(info));
657 ret = i3c_master_set_info(&master->base, &info);
661 writel(IBI_REQ_REJECT_ALL, master->regs + IBI_SIR_REQ_REJECT);
662 writel(IBI_REQ_REJECT_ALL, master->regs + IBI_MR_REQ_REJECT);
664 /* For now don't support Hot-Join */
665 writel(readl(master->regs + DEVICE_CTRL) | DEV_CTRL_HOT_JOIN_NACK,
666 master->regs + DEVICE_CTRL);
668 dw_i3c_master_enable(master);
673 static void dw_i3c_master_bus_cleanup(struct i3c_master_controller *m)
675 struct dw_i3c_master *master = to_dw_i3c_master(m);
677 dw_i3c_master_disable(master);
680 static int dw_i3c_ccc_set(struct dw_i3c_master *master,
681 struct i3c_ccc_cmd *ccc)
683 struct dw_i3c_xfer *xfer;
684 struct dw_i3c_cmd *cmd;
687 if (ccc->id & I3C_CCC_DIRECT) {
688 pos = dw_i3c_master_get_addr_pos(master, ccc->dests[0].addr);
693 xfer = dw_i3c_master_alloc_xfer(master, 1);
698 cmd->tx_buf = ccc->dests[0].payload.data;
699 cmd->tx_len = ccc->dests[0].payload.len;
701 cmd->cmd_hi = COMMAND_PORT_ARG_DATA_LEN(ccc->dests[0].payload.len) |
702 COMMAND_PORT_TRANSFER_ARG;
704 cmd->cmd_lo = COMMAND_PORT_CP |
705 COMMAND_PORT_DEV_INDEX(pos) |
706 COMMAND_PORT_CMD(ccc->id) |
710 dw_i3c_master_enqueue_xfer(master, xfer);
711 if (!wait_for_completion_timeout(&xfer->comp, XFER_TIMEOUT))
712 dw_i3c_master_dequeue_xfer(master, xfer);
715 if (xfer->cmds[0].error == RESPONSE_ERROR_IBA_NACK)
716 ccc->err = I3C_ERROR_M2;
718 dw_i3c_master_free_xfer(xfer);
723 static int dw_i3c_ccc_get(struct dw_i3c_master *master, struct i3c_ccc_cmd *ccc)
725 struct dw_i3c_xfer *xfer;
726 struct dw_i3c_cmd *cmd;
729 pos = dw_i3c_master_get_addr_pos(master, ccc->dests[0].addr);
733 xfer = dw_i3c_master_alloc_xfer(master, 1);
738 cmd->rx_buf = ccc->dests[0].payload.data;
739 cmd->rx_len = ccc->dests[0].payload.len;
741 cmd->cmd_hi = COMMAND_PORT_ARG_DATA_LEN(ccc->dests[0].payload.len) |
742 COMMAND_PORT_TRANSFER_ARG;
744 cmd->cmd_lo = COMMAND_PORT_READ_TRANSFER |
746 COMMAND_PORT_DEV_INDEX(pos) |
747 COMMAND_PORT_CMD(ccc->id) |
751 dw_i3c_master_enqueue_xfer(master, xfer);
752 if (!wait_for_completion_timeout(&xfer->comp, XFER_TIMEOUT))
753 dw_i3c_master_dequeue_xfer(master, xfer);
756 if (xfer->cmds[0].error == RESPONSE_ERROR_IBA_NACK)
757 ccc->err = I3C_ERROR_M2;
758 dw_i3c_master_free_xfer(xfer);
763 static int dw_i3c_master_send_ccc_cmd(struct i3c_master_controller *m,
764 struct i3c_ccc_cmd *ccc)
766 struct dw_i3c_master *master = to_dw_i3c_master(m);
769 if (ccc->id == I3C_CCC_ENTDAA)
773 ret = dw_i3c_ccc_get(master, ccc);
775 ret = dw_i3c_ccc_set(master, ccc);
780 static int dw_i3c_master_daa(struct i3c_master_controller *m)
782 struct dw_i3c_master *master = to_dw_i3c_master(m);
783 struct dw_i3c_xfer *xfer;
784 struct dw_i3c_cmd *cmd;
785 u32 olddevs, newdevs;
789 olddevs = ~(master->free_pos);
791 /* Prepare DAT before launching DAA. */
792 for (pos = 0; pos < master->maxdevs; pos++) {
793 if (olddevs & BIT(pos))
796 ret = i3c_master_get_free_addr(m, last_addr + 1);
800 master->devs[pos].addr = ret;
801 p = even_parity(ret);
805 writel(DEV_ADDR_TABLE_DYNAMIC_ADDR(ret),
807 DEV_ADDR_TABLE_LOC(master->datstartaddr, pos));
810 xfer = dw_i3c_master_alloc_xfer(master, 1);
814 pos = dw_i3c_master_get_free_pos(master);
816 dw_i3c_master_free_xfer(xfer);
819 cmd = &xfer->cmds[0];
821 cmd->cmd_lo = COMMAND_PORT_DEV_COUNT(master->maxdevs - pos) |
822 COMMAND_PORT_DEV_INDEX(pos) |
823 COMMAND_PORT_CMD(I3C_CCC_ENTDAA) |
824 COMMAND_PORT_ADDR_ASSGN_CMD |
828 dw_i3c_master_enqueue_xfer(master, xfer);
829 if (!wait_for_completion_timeout(&xfer->comp, XFER_TIMEOUT))
830 dw_i3c_master_dequeue_xfer(master, xfer);
832 newdevs = GENMASK(master->maxdevs - cmd->rx_len - 1, 0);
835 for (pos = 0; pos < master->maxdevs; pos++) {
836 if (newdevs & BIT(pos))
837 i3c_master_add_i3c_dev_locked(m, master->devs[pos].addr);
840 dw_i3c_master_free_xfer(xfer);
845 static int dw_i3c_master_priv_xfers(struct i3c_dev_desc *dev,
846 struct i3c_priv_xfer *i3c_xfers,
849 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
850 struct i3c_master_controller *m = i3c_dev_get_master(dev);
851 struct dw_i3c_master *master = to_dw_i3c_master(m);
852 unsigned int nrxwords = 0, ntxwords = 0;
853 struct dw_i3c_xfer *xfer;
859 if (i3c_nxfers > master->caps.cmdfifodepth)
862 for (i = 0; i < i3c_nxfers; i++) {
863 if (i3c_xfers[i].rnw)
864 nrxwords += DIV_ROUND_UP(i3c_xfers[i].len, 4);
866 ntxwords += DIV_ROUND_UP(i3c_xfers[i].len, 4);
869 if (ntxwords > master->caps.datafifodepth ||
870 nrxwords > master->caps.datafifodepth)
873 xfer = dw_i3c_master_alloc_xfer(master, i3c_nxfers);
877 for (i = 0; i < i3c_nxfers; i++) {
878 struct dw_i3c_cmd *cmd = &xfer->cmds[i];
880 cmd->cmd_hi = COMMAND_PORT_ARG_DATA_LEN(i3c_xfers[i].len) |
881 COMMAND_PORT_TRANSFER_ARG;
883 if (i3c_xfers[i].rnw) {
884 cmd->rx_buf = i3c_xfers[i].data.in;
885 cmd->rx_len = i3c_xfers[i].len;
886 cmd->cmd_lo = COMMAND_PORT_READ_TRANSFER |
887 COMMAND_PORT_SPEED(dev->info.max_read_ds);
890 cmd->tx_buf = i3c_xfers[i].data.out;
891 cmd->tx_len = i3c_xfers[i].len;
893 COMMAND_PORT_SPEED(dev->info.max_write_ds);
896 cmd->cmd_lo |= COMMAND_PORT_TID(i) |
897 COMMAND_PORT_DEV_INDEX(data->index) |
900 if (i == (i3c_nxfers - 1))
901 cmd->cmd_lo |= COMMAND_PORT_TOC;
904 dw_i3c_master_enqueue_xfer(master, xfer);
905 if (!wait_for_completion_timeout(&xfer->comp, XFER_TIMEOUT))
906 dw_i3c_master_dequeue_xfer(master, xfer);
908 for (i = 0; i < i3c_nxfers; i++) {
909 struct dw_i3c_cmd *cmd = &xfer->cmds[i];
911 if (i3c_xfers[i].rnw)
912 i3c_xfers[i].len = cmd->rx_len;
916 dw_i3c_master_free_xfer(xfer);
921 static int dw_i3c_master_reattach_i3c_dev(struct i3c_dev_desc *dev,
924 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
925 struct i3c_master_controller *m = i3c_dev_get_master(dev);
926 struct dw_i3c_master *master = to_dw_i3c_master(m);
929 pos = dw_i3c_master_get_free_pos(master);
931 if (data->index > pos && pos > 0) {
934 DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
936 master->devs[data->index].addr = 0;
937 master->free_pos |= BIT(data->index);
940 master->devs[pos].addr = dev->info.dyn_addr;
941 master->free_pos &= ~BIT(pos);
944 writel(DEV_ADDR_TABLE_DYNAMIC_ADDR(dev->info.dyn_addr),
946 DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
948 master->devs[data->index].addr = dev->info.dyn_addr;
953 static int dw_i3c_master_attach_i3c_dev(struct i3c_dev_desc *dev)
955 struct i3c_master_controller *m = i3c_dev_get_master(dev);
956 struct dw_i3c_master *master = to_dw_i3c_master(m);
957 struct dw_i3c_i2c_dev_data *data;
960 pos = dw_i3c_master_get_free_pos(master);
964 data = kzalloc(sizeof(*data), GFP_KERNEL);
969 master->devs[pos].addr = dev->info.dyn_addr ? : dev->info.static_addr;
970 master->free_pos &= ~BIT(pos);
971 i3c_dev_set_master_data(dev, data);
973 writel(DEV_ADDR_TABLE_DYNAMIC_ADDR(master->devs[pos].addr),
975 DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
980 static void dw_i3c_master_detach_i3c_dev(struct i3c_dev_desc *dev)
982 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
983 struct i3c_master_controller *m = i3c_dev_get_master(dev);
984 struct dw_i3c_master *master = to_dw_i3c_master(m);
988 DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
990 i3c_dev_set_master_data(dev, NULL);
991 master->devs[data->index].addr = 0;
992 master->free_pos |= BIT(data->index);
996 static int dw_i3c_master_i2c_xfers(struct i2c_dev_desc *dev,
997 const struct i2c_msg *i2c_xfers,
1000 struct dw_i3c_i2c_dev_data *data = i2c_dev_get_master_data(dev);
1001 struct i3c_master_controller *m = i2c_dev_get_master(dev);
1002 struct dw_i3c_master *master = to_dw_i3c_master(m);
1003 unsigned int nrxwords = 0, ntxwords = 0;
1004 struct dw_i3c_xfer *xfer;
1010 if (i2c_nxfers > master->caps.cmdfifodepth)
1013 for (i = 0; i < i2c_nxfers; i++) {
1014 if (i2c_xfers[i].flags & I2C_M_RD)
1015 nrxwords += DIV_ROUND_UP(i2c_xfers[i].len, 4);
1017 ntxwords += DIV_ROUND_UP(i2c_xfers[i].len, 4);
1020 if (ntxwords > master->caps.datafifodepth ||
1021 nrxwords > master->caps.datafifodepth)
1024 xfer = dw_i3c_master_alloc_xfer(master, i2c_nxfers);
1028 for (i = 0; i < i2c_nxfers; i++) {
1029 struct dw_i3c_cmd *cmd = &xfer->cmds[i];
1031 cmd->cmd_hi = COMMAND_PORT_ARG_DATA_LEN(i2c_xfers[i].len) |
1032 COMMAND_PORT_TRANSFER_ARG;
1034 cmd->cmd_lo = COMMAND_PORT_TID(i) |
1035 COMMAND_PORT_DEV_INDEX(data->index) |
1038 if (i2c_xfers[i].flags & I2C_M_RD) {
1039 cmd->cmd_lo |= COMMAND_PORT_READ_TRANSFER;
1040 cmd->rx_buf = i2c_xfers[i].buf;
1041 cmd->rx_len = i2c_xfers[i].len;
1043 cmd->tx_buf = i2c_xfers[i].buf;
1044 cmd->tx_len = i2c_xfers[i].len;
1047 if (i == (i2c_nxfers - 1))
1048 cmd->cmd_lo |= COMMAND_PORT_TOC;
1051 dw_i3c_master_enqueue_xfer(master, xfer);
1052 if (!wait_for_completion_timeout(&xfer->comp, XFER_TIMEOUT))
1053 dw_i3c_master_dequeue_xfer(master, xfer);
1056 dw_i3c_master_free_xfer(xfer);
1061 static int dw_i3c_master_attach_i2c_dev(struct i2c_dev_desc *dev)
1063 struct i3c_master_controller *m = i2c_dev_get_master(dev);
1064 struct dw_i3c_master *master = to_dw_i3c_master(m);
1065 struct dw_i3c_i2c_dev_data *data;
1068 pos = dw_i3c_master_get_free_pos(master);
1072 data = kzalloc(sizeof(*data), GFP_KERNEL);
1077 master->devs[pos].addr = dev->addr;
1078 master->free_pos &= ~BIT(pos);
1079 i2c_dev_set_master_data(dev, data);
1081 writel(DEV_ADDR_TABLE_LEGACY_I2C_DEV |
1082 DEV_ADDR_TABLE_STATIC_ADDR(dev->addr),
1084 DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
1089 static void dw_i3c_master_detach_i2c_dev(struct i2c_dev_desc *dev)
1091 struct dw_i3c_i2c_dev_data *data = i2c_dev_get_master_data(dev);
1092 struct i3c_master_controller *m = i2c_dev_get_master(dev);
1093 struct dw_i3c_master *master = to_dw_i3c_master(m);
1097 DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
1099 i2c_dev_set_master_data(dev, NULL);
1100 master->devs[data->index].addr = 0;
1101 master->free_pos |= BIT(data->index);
1105 static int dw_i3c_master_request_ibi(struct i3c_dev_desc *dev,
1106 const struct i3c_ibi_setup *req)
1108 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
1109 struct i3c_master_controller *m = i3c_dev_get_master(dev);
1110 struct dw_i3c_master *master = to_dw_i3c_master(m);
1111 unsigned long flags;
1113 data->ibi_pool = i3c_generic_ibi_alloc_pool(dev, req);
1114 if (IS_ERR(data->ibi_pool))
1115 return PTR_ERR(data->ibi_pool);
1117 spin_lock_irqsave(&master->devs_lock, flags);
1118 master->devs[data->index].ibi_dev = dev;
1119 spin_unlock_irqrestore(&master->devs_lock, flags);
1124 static void dw_i3c_master_free_ibi(struct i3c_dev_desc *dev)
1126 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
1127 struct i3c_master_controller *m = i3c_dev_get_master(dev);
1128 struct dw_i3c_master *master = to_dw_i3c_master(m);
1129 unsigned long flags;
1131 spin_lock_irqsave(&master->devs_lock, flags);
1132 master->devs[data->index].ibi_dev = NULL;
1133 spin_unlock_irqrestore(&master->devs_lock, flags);
1135 i3c_generic_ibi_free_pool(data->ibi_pool);
1136 data->ibi_pool = NULL;
1139 static void dw_i3c_master_set_sir_enabled(struct dw_i3c_master *master,
1140 struct i3c_dev_desc *dev,
1141 u8 idx, bool enable)
1143 unsigned long flags;
1147 dat_entry = DEV_ADDR_TABLE_LOC(master->datstartaddr, idx);
1149 spin_lock_irqsave(&master->devs_lock, flags);
1150 reg = readl(master->regs + dat_entry);
1152 reg &= ~DEV_ADDR_TABLE_SIR_REJECT;
1153 if (dev->info.bcr & I3C_BCR_IBI_PAYLOAD)
1154 reg |= DEV_ADDR_TABLE_IBI_MDB;
1156 reg |= DEV_ADDR_TABLE_SIR_REJECT;
1158 master->platform_ops->set_dat_ibi(master, dev, enable, ®);
1159 writel(reg, master->regs + dat_entry);
1161 reg = readl(master->regs + IBI_SIR_REQ_REJECT);
1163 global = reg == 0xffffffff;
1169 writel(reg, master->regs + IBI_SIR_REQ_REJECT);
1172 reg = readl(master->regs + INTR_STATUS_EN);
1173 reg &= ~INTR_IBI_THLD_STAT;
1175 reg |= INTR_IBI_THLD_STAT;
1176 writel(reg, master->regs + INTR_STATUS_EN);
1178 reg = readl(master->regs + INTR_SIGNAL_EN);
1179 reg &= ~INTR_IBI_THLD_STAT;
1181 reg |= INTR_IBI_THLD_STAT;
1182 writel(reg, master->regs + INTR_SIGNAL_EN);
1185 spin_unlock_irqrestore(&master->devs_lock, flags);
1188 static int dw_i3c_master_enable_ibi(struct i3c_dev_desc *dev)
1190 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
1191 struct i3c_master_controller *m = i3c_dev_get_master(dev);
1192 struct dw_i3c_master *master = to_dw_i3c_master(m);
1195 dw_i3c_master_set_sir_enabled(master, dev, data->index, true);
1197 rc = i3c_master_enec_locked(m, dev->info.dyn_addr, I3C_CCC_EVENT_SIR);
1200 dw_i3c_master_set_sir_enabled(master, dev, data->index, false);
1205 static int dw_i3c_master_disable_ibi(struct i3c_dev_desc *dev)
1207 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
1208 struct i3c_master_controller *m = i3c_dev_get_master(dev);
1209 struct dw_i3c_master *master = to_dw_i3c_master(m);
1212 rc = i3c_master_disec_locked(m, dev->info.dyn_addr, I3C_CCC_EVENT_SIR);
1216 dw_i3c_master_set_sir_enabled(master, dev, data->index, false);
1221 static void dw_i3c_master_recycle_ibi_slot(struct i3c_dev_desc *dev,
1222 struct i3c_ibi_slot *slot)
1224 struct dw_i3c_i2c_dev_data *data = i3c_dev_get_master_data(dev);
1226 i3c_generic_ibi_recycle_slot(data->ibi_pool, slot);
1229 static void dw_i3c_master_drain_ibi_queue(struct dw_i3c_master *master,
1234 for (i = 0; i < DIV_ROUND_UP(len, 4); i++)
1235 readl(master->regs + IBI_QUEUE_STATUS);
1238 static void dw_i3c_master_handle_ibi_sir(struct dw_i3c_master *master,
1241 struct dw_i3c_i2c_dev_data *data;
1242 struct i3c_ibi_slot *slot;
1243 struct i3c_dev_desc *dev;
1244 unsigned long flags;
1248 addr = IBI_QUEUE_IBI_ADDR(status);
1249 len = IBI_QUEUE_STATUS_DATA_LEN(status);
1252 * We be tempted to check the error status in bit 30; however, due
1253 * to the PEC errata workaround on some platform implementations (see
1254 * ast2600_i3c_set_dat_ibi()), those will almost always have a PEC
1255 * error on IBI payload data, as well as losing the last byte of
1258 * If we implement error status checking on that bit, we may need
1259 * a new platform op to validate it.
1262 spin_lock_irqsave(&master->devs_lock, flags);
1263 idx = dw_i3c_master_get_addr_pos(master, addr);
1265 dev_dbg_ratelimited(&master->base.dev,
1266 "IBI from unknown addr 0x%x\n", addr);
1270 dev = master->devs[idx].ibi_dev;
1271 if (!dev || !dev->ibi) {
1272 dev_dbg_ratelimited(&master->base.dev,
1273 "IBI from non-requested dev idx %d\n", idx);
1277 data = i3c_dev_get_master_data(dev);
1278 slot = i3c_generic_ibi_get_free_slot(data->ibi_pool);
1280 dev_dbg_ratelimited(&master->base.dev,
1281 "No IBI slots available\n");
1285 if (dev->ibi->max_payload_len < len) {
1286 dev_dbg_ratelimited(&master->base.dev,
1287 "IBI payload len %d greater than max %d\n",
1288 len, dev->ibi->max_payload_len);
1293 dw_i3c_master_read_ibi_fifo(master, slot->data, len);
1296 i3c_master_queue_ibi(dev, slot);
1298 spin_unlock_irqrestore(&master->devs_lock, flags);
1303 dw_i3c_master_drain_ibi_queue(master, len);
1305 spin_unlock_irqrestore(&master->devs_lock, flags);
1308 /* "ibis": referring to In-Band Interrupts, and not
1309 * https://en.wikipedia.org/wiki/Australian_white_ibis. The latter should
1312 static void dw_i3c_master_irq_handle_ibis(struct dw_i3c_master *master)
1314 unsigned int i, len, n_ibis;
1317 reg = readl(master->regs + QUEUE_STATUS_LEVEL);
1318 n_ibis = QUEUE_STATUS_IBI_STATUS_CNT(reg);
1322 for (i = 0; i < n_ibis; i++) {
1323 reg = readl(master->regs + IBI_QUEUE_STATUS);
1325 if (IBI_TYPE_SIRQ(reg)) {
1326 dw_i3c_master_handle_ibi_sir(master, reg);
1328 len = IBI_QUEUE_STATUS_DATA_LEN(reg);
1329 dev_info(&master->base.dev,
1330 "unsupported IBI type 0x%lx len %d\n",
1331 IBI_QUEUE_STATUS_IBI_ID(reg), len);
1332 dw_i3c_master_drain_ibi_queue(master, len);
1337 static irqreturn_t dw_i3c_master_irq_handler(int irq, void *dev_id)
1339 struct dw_i3c_master *master = dev_id;
1342 status = readl(master->regs + INTR_STATUS);
1344 if (!(status & readl(master->regs + INTR_STATUS_EN))) {
1345 writel(INTR_ALL, master->regs + INTR_STATUS);
1349 spin_lock(&master->xferqueue.lock);
1350 dw_i3c_master_end_xfer_locked(master, status);
1351 if (status & INTR_TRANSFER_ERR_STAT)
1352 writel(INTR_TRANSFER_ERR_STAT, master->regs + INTR_STATUS);
1353 spin_unlock(&master->xferqueue.lock);
1355 if (status & INTR_IBI_THLD_STAT)
1356 dw_i3c_master_irq_handle_ibis(master);
1361 static const struct i3c_master_controller_ops dw_mipi_i3c_ops = {
1362 .bus_init = dw_i3c_master_bus_init,
1363 .bus_cleanup = dw_i3c_master_bus_cleanup,
1364 .attach_i3c_dev = dw_i3c_master_attach_i3c_dev,
1365 .reattach_i3c_dev = dw_i3c_master_reattach_i3c_dev,
1366 .detach_i3c_dev = dw_i3c_master_detach_i3c_dev,
1367 .do_daa = dw_i3c_master_daa,
1368 .supports_ccc_cmd = dw_i3c_master_supports_ccc_cmd,
1369 .send_ccc_cmd = dw_i3c_master_send_ccc_cmd,
1370 .priv_xfers = dw_i3c_master_priv_xfers,
1371 .attach_i2c_dev = dw_i3c_master_attach_i2c_dev,
1372 .detach_i2c_dev = dw_i3c_master_detach_i2c_dev,
1373 .i2c_xfers = dw_i3c_master_i2c_xfers,
1376 static const struct i3c_master_controller_ops dw_mipi_i3c_ibi_ops = {
1377 .bus_init = dw_i3c_master_bus_init,
1378 .bus_cleanup = dw_i3c_master_bus_cleanup,
1379 .attach_i3c_dev = dw_i3c_master_attach_i3c_dev,
1380 .reattach_i3c_dev = dw_i3c_master_reattach_i3c_dev,
1381 .detach_i3c_dev = dw_i3c_master_detach_i3c_dev,
1382 .do_daa = dw_i3c_master_daa,
1383 .supports_ccc_cmd = dw_i3c_master_supports_ccc_cmd,
1384 .send_ccc_cmd = dw_i3c_master_send_ccc_cmd,
1385 .priv_xfers = dw_i3c_master_priv_xfers,
1386 .attach_i2c_dev = dw_i3c_master_attach_i2c_dev,
1387 .detach_i2c_dev = dw_i3c_master_detach_i2c_dev,
1388 .i2c_xfers = dw_i3c_master_i2c_xfers,
1389 .request_ibi = dw_i3c_master_request_ibi,
1390 .free_ibi = dw_i3c_master_free_ibi,
1391 .enable_ibi = dw_i3c_master_enable_ibi,
1392 .disable_ibi = dw_i3c_master_disable_ibi,
1393 .recycle_ibi_slot = dw_i3c_master_recycle_ibi_slot,
1396 /* default platform ops implementations */
1397 static int dw_i3c_platform_init_nop(struct dw_i3c_master *i3c)
1402 static void dw_i3c_platform_set_dat_ibi_nop(struct dw_i3c_master *i3c,
1403 struct i3c_dev_desc *dev,
1404 bool enable, u32 *dat)
1408 static const struct dw_i3c_platform_ops dw_i3c_platform_ops_default = {
1409 .init = dw_i3c_platform_init_nop,
1410 .set_dat_ibi = dw_i3c_platform_set_dat_ibi_nop,
1413 int dw_i3c_common_probe(struct dw_i3c_master *master,
1414 struct platform_device *pdev)
1416 const struct i3c_master_controller_ops *ops;
1419 if (!master->platform_ops)
1420 master->platform_ops = &dw_i3c_platform_ops_default;
1422 master->regs = devm_platform_ioremap_resource(pdev, 0);
1423 if (IS_ERR(master->regs))
1424 return PTR_ERR(master->regs);
1426 master->core_clk = devm_clk_get(&pdev->dev, NULL);
1427 if (IS_ERR(master->core_clk))
1428 return PTR_ERR(master->core_clk);
1430 master->core_rst = devm_reset_control_get_optional_exclusive(&pdev->dev,
1432 if (IS_ERR(master->core_rst))
1433 return PTR_ERR(master->core_rst);
1435 ret = clk_prepare_enable(master->core_clk);
1437 goto err_disable_core_clk;
1439 reset_control_deassert(master->core_rst);
1441 spin_lock_init(&master->xferqueue.lock);
1442 INIT_LIST_HEAD(&master->xferqueue.list);
1444 writel(INTR_ALL, master->regs + INTR_STATUS);
1445 irq = platform_get_irq(pdev, 0);
1446 ret = devm_request_irq(&pdev->dev, irq,
1447 dw_i3c_master_irq_handler, 0,
1448 dev_name(&pdev->dev), master);
1450 goto err_assert_rst;
1452 platform_set_drvdata(pdev, master);
1454 /* Information regarding the FIFOs/QUEUEs depth */
1455 ret = readl(master->regs + QUEUE_STATUS_LEVEL);
1456 master->caps.cmdfifodepth = QUEUE_STATUS_LEVEL_CMD(ret);
1458 ret = readl(master->regs + DATA_BUFFER_STATUS_LEVEL);
1459 master->caps.datafifodepth = DATA_BUFFER_STATUS_LEVEL_TX(ret);
1461 ret = readl(master->regs + DEVICE_ADDR_TABLE_POINTER);
1462 master->datstartaddr = ret;
1463 master->maxdevs = ret >> 16;
1464 master->free_pos = GENMASK(master->maxdevs - 1, 0);
1466 ops = &dw_mipi_i3c_ops;
1467 if (master->ibi_capable)
1468 ops = &dw_mipi_i3c_ibi_ops;
1470 ret = i3c_master_register(&master->base, &pdev->dev, ops, false);
1472 goto err_assert_rst;
1477 reset_control_assert(master->core_rst);
1479 err_disable_core_clk:
1480 clk_disable_unprepare(master->core_clk);
1484 EXPORT_SYMBOL_GPL(dw_i3c_common_probe);
1486 void dw_i3c_common_remove(struct dw_i3c_master *master)
1488 i3c_master_unregister(&master->base);
1490 reset_control_assert(master->core_rst);
1492 clk_disable_unprepare(master->core_clk);
1494 EXPORT_SYMBOL_GPL(dw_i3c_common_remove);
1496 /* base platform implementation */
1498 static int dw_i3c_probe(struct platform_device *pdev)
1500 struct dw_i3c_master *master;
1502 master = devm_kzalloc(&pdev->dev, sizeof(*master), GFP_KERNEL);
1506 return dw_i3c_common_probe(master, pdev);
1509 static void dw_i3c_remove(struct platform_device *pdev)
1511 struct dw_i3c_master *master = platform_get_drvdata(pdev);
1513 dw_i3c_common_remove(master);
1516 static const struct of_device_id dw_i3c_master_of_match[] = {
1517 { .compatible = "snps,dw-i3c-master-1.00a", },
1520 MODULE_DEVICE_TABLE(of, dw_i3c_master_of_match);
1522 static struct platform_driver dw_i3c_driver = {
1523 .probe = dw_i3c_probe,
1524 .remove_new = dw_i3c_remove,
1526 .name = "dw-i3c-master",
1527 .of_match_table = dw_i3c_master_of_match,
1530 module_platform_driver(dw_i3c_driver);
1532 MODULE_AUTHOR("Vitor Soares <vitor.soares@synopsys.com>");
1533 MODULE_DESCRIPTION("DesignWare MIPI I3C driver");
1534 MODULE_LICENSE("GPL v2");