1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 // Copyright(c) 2015-17 Intel Corporation.
5 * Cadence SoundWire Master module
6 * Used by Master driver
9 #include <linux/delay.h>
10 #include <linux/device.h>
11 #include <linux/interrupt.h>
12 #include <linux/module.h>
13 #include <linux/mod_devicetable.h>
14 #include <linux/soundwire/sdw_registers.h>
15 #include <linux/soundwire/sdw.h>
16 #include <sound/pcm_params.h>
17 #include <sound/soc.h>
19 #include "cadence_master.h"
21 #define CDNS_MCP_CONFIG 0x0
23 #define CDNS_MCP_CONFIG_MCMD_RETRY GENMASK(27, 24)
24 #define CDNS_MCP_CONFIG_MPREQ_DELAY GENMASK(20, 16)
25 #define CDNS_MCP_CONFIG_MMASTER BIT(7)
26 #define CDNS_MCP_CONFIG_BUS_REL BIT(6)
27 #define CDNS_MCP_CONFIG_SNIFFER BIT(5)
28 #define CDNS_MCP_CONFIG_SSPMOD BIT(4)
29 #define CDNS_MCP_CONFIG_CMD BIT(3)
30 #define CDNS_MCP_CONFIG_OP GENMASK(2, 0)
31 #define CDNS_MCP_CONFIG_OP_NORMAL 0
33 #define CDNS_MCP_CONTROL 0x4
35 #define CDNS_MCP_CONTROL_RST_DELAY GENMASK(10, 8)
36 #define CDNS_MCP_CONTROL_CMD_RST BIT(7)
37 #define CDNS_MCP_CONTROL_SOFT_RST BIT(6)
38 #define CDNS_MCP_CONTROL_SW_RST BIT(5)
39 #define CDNS_MCP_CONTROL_HW_RST BIT(4)
40 #define CDNS_MCP_CONTROL_CLK_PAUSE BIT(3)
41 #define CDNS_MCP_CONTROL_CLK_STOP_CLR BIT(2)
42 #define CDNS_MCP_CONTROL_CMD_ACCEPT BIT(1)
43 #define CDNS_MCP_CONTROL_BLOCK_WAKEUP BIT(0)
45 #define CDNS_MCP_CMDCTRL 0x8
46 #define CDNS_MCP_SSPSTAT 0xC
47 #define CDNS_MCP_FRAME_SHAPE 0x10
48 #define CDNS_MCP_FRAME_SHAPE_INIT 0x14
50 #define CDNS_MCP_CONFIG_UPDATE 0x18
51 #define CDNS_MCP_CONFIG_UPDATE_BIT BIT(0)
53 #define CDNS_MCP_PHYCTRL 0x1C
54 #define CDNS_MCP_SSP_CTRL0 0x20
55 #define CDNS_MCP_SSP_CTRL1 0x28
56 #define CDNS_MCP_CLK_CTRL0 0x30
57 #define CDNS_MCP_CLK_CTRL1 0x38
59 #define CDNS_MCP_STAT 0x40
61 #define CDNS_MCP_STAT_ACTIVE_BANK BIT(20)
62 #define CDNS_MCP_STAT_CLK_STOP BIT(16)
64 #define CDNS_MCP_INTSTAT 0x44
65 #define CDNS_MCP_INTMASK 0x48
67 #define CDNS_MCP_INT_IRQ BIT(31)
68 #define CDNS_MCP_INT_WAKEUP BIT(16)
69 #define CDNS_MCP_INT_SLAVE_RSVD BIT(15)
70 #define CDNS_MCP_INT_SLAVE_ALERT BIT(14)
71 #define CDNS_MCP_INT_SLAVE_ATTACH BIT(13)
72 #define CDNS_MCP_INT_SLAVE_NATTACH BIT(12)
73 #define CDNS_MCP_INT_SLAVE_MASK GENMASK(15, 12)
74 #define CDNS_MCP_INT_DPINT BIT(11)
75 #define CDNS_MCP_INT_CTRL_CLASH BIT(10)
76 #define CDNS_MCP_INT_DATA_CLASH BIT(9)
77 #define CDNS_MCP_INT_CMD_ERR BIT(7)
78 #define CDNS_MCP_INT_RX_WL BIT(2)
79 #define CDNS_MCP_INT_TXE BIT(1)
81 #define CDNS_MCP_INTSET 0x4C
83 #define CDNS_SDW_SLAVE_STAT 0x50
84 #define CDNS_MCP_SLAVE_STAT_MASK BIT(1, 0)
86 #define CDNS_MCP_SLAVE_INTSTAT0 0x54
87 #define CDNS_MCP_SLAVE_INTSTAT1 0x58
88 #define CDNS_MCP_SLAVE_INTSTAT_NPRESENT BIT(0)
89 #define CDNS_MCP_SLAVE_INTSTAT_ATTACHED BIT(1)
90 #define CDNS_MCP_SLAVE_INTSTAT_ALERT BIT(2)
91 #define CDNS_MCP_SLAVE_INTSTAT_RESERVED BIT(3)
92 #define CDNS_MCP_SLAVE_STATUS_BITS GENMASK(3, 0)
93 #define CDNS_MCP_SLAVE_STATUS_NUM 4
95 #define CDNS_MCP_SLAVE_INTMASK0 0x5C
96 #define CDNS_MCP_SLAVE_INTMASK1 0x60
98 #define CDNS_MCP_SLAVE_INTMASK0_MASK GENMASK(30, 0)
99 #define CDNS_MCP_SLAVE_INTMASK1_MASK GENMASK(16, 0)
101 #define CDNS_MCP_PORT_INTSTAT 0x64
102 #define CDNS_MCP_PDI_STAT 0x6C
104 #define CDNS_MCP_FIFOLEVEL 0x78
105 #define CDNS_MCP_FIFOSTAT 0x7C
106 #define CDNS_MCP_RX_FIFO_AVAIL GENMASK(5, 0)
108 #define CDNS_MCP_CMD_BASE 0x80
109 #define CDNS_MCP_RESP_BASE 0x80
110 #define CDNS_MCP_CMD_LEN 0x20
111 #define CDNS_MCP_CMD_WORD_LEN 0x4
113 #define CDNS_MCP_CMD_SSP_TAG BIT(31)
114 #define CDNS_MCP_CMD_COMMAND GENMASK(30, 28)
115 #define CDNS_MCP_CMD_DEV_ADDR GENMASK(27, 24)
116 #define CDNS_MCP_CMD_REG_ADDR_H GENMASK(23, 16)
117 #define CDNS_MCP_CMD_REG_ADDR_L GENMASK(15, 8)
118 #define CDNS_MCP_CMD_REG_DATA GENMASK(7, 0)
120 #define CDNS_MCP_CMD_READ 2
121 #define CDNS_MCP_CMD_WRITE 3
123 #define CDNS_MCP_RESP_RDATA GENMASK(15, 8)
124 #define CDNS_MCP_RESP_ACK BIT(0)
125 #define CDNS_MCP_RESP_NACK BIT(1)
127 #define CDNS_DP_SIZE 128
129 #define CDNS_DPN_B0_CONFIG(n) (0x100 + CDNS_DP_SIZE * (n))
130 #define CDNS_DPN_B0_CH_EN(n) (0x104 + CDNS_DP_SIZE * (n))
131 #define CDNS_DPN_B0_SAMPLE_CTRL(n) (0x108 + CDNS_DP_SIZE * (n))
132 #define CDNS_DPN_B0_OFFSET_CTRL(n) (0x10C + CDNS_DP_SIZE * (n))
133 #define CDNS_DPN_B0_HCTRL(n) (0x110 + CDNS_DP_SIZE * (n))
134 #define CDNS_DPN_B0_ASYNC_CTRL(n) (0x114 + CDNS_DP_SIZE * (n))
136 #define CDNS_DPN_B1_CONFIG(n) (0x118 + CDNS_DP_SIZE * (n))
137 #define CDNS_DPN_B1_CH_EN(n) (0x11C + CDNS_DP_SIZE * (n))
138 #define CDNS_DPN_B1_SAMPLE_CTRL(n) (0x120 + CDNS_DP_SIZE * (n))
139 #define CDNS_DPN_B1_OFFSET_CTRL(n) (0x124 + CDNS_DP_SIZE * (n))
140 #define CDNS_DPN_B1_HCTRL(n) (0x128 + CDNS_DP_SIZE * (n))
141 #define CDNS_DPN_B1_ASYNC_CTRL(n) (0x12C + CDNS_DP_SIZE * (n))
143 #define CDNS_DPN_CONFIG_BPM BIT(18)
144 #define CDNS_DPN_CONFIG_BGC GENMASK(17, 16)
145 #define CDNS_DPN_CONFIG_WL GENMASK(12, 8)
146 #define CDNS_DPN_CONFIG_PORT_DAT GENMASK(3, 2)
147 #define CDNS_DPN_CONFIG_PORT_FLOW GENMASK(1, 0)
149 #define CDNS_DPN_SAMPLE_CTRL_SI GENMASK(15, 0)
151 #define CDNS_DPN_OFFSET_CTRL_1 GENMASK(7, 0)
152 #define CDNS_DPN_OFFSET_CTRL_2 GENMASK(15, 8)
154 #define CDNS_DPN_HCTRL_HSTOP GENMASK(3, 0)
155 #define CDNS_DPN_HCTRL_HSTART GENMASK(7, 4)
156 #define CDNS_DPN_HCTRL_LCTRL GENMASK(10, 8)
158 #define CDNS_PORTCTRL 0x130
159 #define CDNS_PORTCTRL_DIRN BIT(7)
160 #define CDNS_PORTCTRL_BANK_INVERT BIT(8)
162 #define CDNS_PORT_OFFSET 0x80
164 #define CDNS_PDI_CONFIG(n) (0x1100 + (n) * 16)
166 #define CDNS_PDI_CONFIG_SOFT_RESET BIT(24)
167 #define CDNS_PDI_CONFIG_CHANNEL GENMASK(15, 8)
168 #define CDNS_PDI_CONFIG_PORT GENMASK(4, 0)
170 /* Driver defaults */
172 #define CDNS_DEFAULT_CLK_DIVIDER 0
173 #define CDNS_DEFAULT_FRAME_SHAPE 0x30
174 #define CDNS_DEFAULT_SSP_INTERVAL 0x18
175 #define CDNS_TX_TIMEOUT 2000
177 #define CDNS_PCM_PDI_OFFSET 0x2
178 #define CDNS_PDM_PDI_OFFSET 0x6
180 #define CDNS_SCP_RX_FIFOLEVEL 0x2
183 * register accessor helpers
185 static inline u32
cdns_readl(struct sdw_cdns
*cdns
, int offset
)
187 return readl(cdns
->registers
+ offset
);
190 static inline void cdns_writel(struct sdw_cdns
*cdns
, int offset
, u32 value
)
192 writel(value
, cdns
->registers
+ offset
);
195 static inline void cdns_updatel(struct sdw_cdns
*cdns
,
196 int offset
, u32 mask
, u32 val
)
200 tmp
= cdns_readl(cdns
, offset
);
201 tmp
= (tmp
& ~mask
) | val
;
202 cdns_writel(cdns
, offset
, tmp
);
205 static int cdns_clear_bit(struct sdw_cdns
*cdns
, int offset
, u32 value
)
210 writel(value
, cdns
->registers
+ offset
);
212 /* Wait for bit to be self cleared */
214 reg_read
= readl(cdns
->registers
+ offset
);
215 if ((reg_read
& value
) == 0)
220 } while (timeout
!= 0);
228 static enum sdw_command_response
229 cdns_fill_msg_resp(struct sdw_cdns
*cdns
,
230 struct sdw_msg
*msg
, int count
, int offset
)
232 int nack
= 0, no_ack
= 0;
235 /* check message response */
236 for (i
= 0; i
< count
; i
++) {
237 if (!(cdns
->response_buf
[i
] & CDNS_MCP_RESP_ACK
)) {
239 dev_dbg(cdns
->dev
, "Msg Ack not received\n");
240 if (cdns
->response_buf
[i
] & CDNS_MCP_RESP_NACK
) {
242 dev_err(cdns
->dev
, "Msg NACK received\n");
248 dev_err(cdns
->dev
, "Msg NACKed for Slave %d\n", msg
->dev_num
);
251 dev_dbg(cdns
->dev
, "Msg ignored for Slave %d\n", msg
->dev_num
);
252 return SDW_CMD_IGNORED
;
256 for (i
= 0; i
< count
; i
++)
257 msg
->buf
[i
+ offset
] = cdns
->response_buf
[i
] >>
258 SDW_REG_SHIFT(CDNS_MCP_RESP_RDATA
);
263 static enum sdw_command_response
264 _cdns_xfer_msg(struct sdw_cdns
*cdns
, struct sdw_msg
*msg
, int cmd
,
265 int offset
, int count
, bool defer
)
271 /* Program the watermark level for RX FIFO */
272 if (cdns
->msg_count
!= count
) {
273 cdns_writel(cdns
, CDNS_MCP_FIFOLEVEL
, count
);
274 cdns
->msg_count
= count
;
277 base
= CDNS_MCP_CMD_BASE
;
280 for (i
= 0; i
< count
; i
++) {
281 data
= msg
->dev_num
<< SDW_REG_SHIFT(CDNS_MCP_CMD_DEV_ADDR
);
282 data
|= cmd
<< SDW_REG_SHIFT(CDNS_MCP_CMD_COMMAND
);
283 data
|= addr
++ << SDW_REG_SHIFT(CDNS_MCP_CMD_REG_ADDR_L
);
285 if (msg
->flags
== SDW_MSG_FLAG_WRITE
)
286 data
|= msg
->buf
[i
+ offset
];
288 data
|= msg
->ssp_sync
<< SDW_REG_SHIFT(CDNS_MCP_CMD_SSP_TAG
);
289 cdns_writel(cdns
, base
, data
);
290 base
+= CDNS_MCP_CMD_WORD_LEN
;
296 /* wait for timeout or response */
297 time
= wait_for_completion_timeout(&cdns
->tx_complete
,
298 msecs_to_jiffies(CDNS_TX_TIMEOUT
));
300 dev_err(cdns
->dev
, "IO transfer timed out\n");
302 return SDW_CMD_TIMEOUT
;
305 return cdns_fill_msg_resp(cdns
, msg
, count
, offset
);
308 static enum sdw_command_response
309 cdns_program_scp_addr(struct sdw_cdns
*cdns
, struct sdw_msg
*msg
)
311 int nack
= 0, no_ack
= 0;
316 /* Program the watermark level for RX FIFO */
317 if (cdns
->msg_count
!= CDNS_SCP_RX_FIFOLEVEL
) {
318 cdns_writel(cdns
, CDNS_MCP_FIFOLEVEL
, CDNS_SCP_RX_FIFOLEVEL
);
319 cdns
->msg_count
= CDNS_SCP_RX_FIFOLEVEL
;
322 data
[0] = msg
->dev_num
<< SDW_REG_SHIFT(CDNS_MCP_CMD_DEV_ADDR
);
323 data
[0] |= 0x3 << SDW_REG_SHIFT(CDNS_MCP_CMD_COMMAND
);
326 data
[0] |= SDW_SCP_ADDRPAGE1
<< SDW_REG_SHIFT(CDNS_MCP_CMD_REG_ADDR_L
);
327 data
[1] |= SDW_SCP_ADDRPAGE2
<< SDW_REG_SHIFT(CDNS_MCP_CMD_REG_ADDR_L
);
329 data
[0] |= msg
->addr_page1
;
330 data
[1] |= msg
->addr_page2
;
332 base
= CDNS_MCP_CMD_BASE
;
333 cdns_writel(cdns
, base
, data
[0]);
334 base
+= CDNS_MCP_CMD_WORD_LEN
;
335 cdns_writel(cdns
, base
, data
[1]);
337 time
= wait_for_completion_timeout(&cdns
->tx_complete
,
338 msecs_to_jiffies(CDNS_TX_TIMEOUT
));
340 dev_err(cdns
->dev
, "SCP Msg trf timed out\n");
342 return SDW_CMD_TIMEOUT
;
345 /* check response the writes */
346 for (i
= 0; i
< 2; i
++) {
347 if (!(cdns
->response_buf
[i
] & CDNS_MCP_RESP_ACK
)) {
349 dev_err(cdns
->dev
, "Program SCP Ack not received\n");
350 if (cdns
->response_buf
[i
] & CDNS_MCP_RESP_NACK
) {
352 dev_err(cdns
->dev
, "Program SCP NACK received\n");
357 /* For NACK, NO ack, don't return err if we are in Broadcast mode */
360 "SCP_addrpage NACKed for Slave %d\n", msg
->dev_num
);
364 "SCP_addrpage ignored for Slave %d\n", msg
->dev_num
);
365 return SDW_CMD_IGNORED
;
371 static int cdns_prep_msg(struct sdw_cdns
*cdns
, struct sdw_msg
*msg
, int *cmd
)
376 ret
= cdns_program_scp_addr(cdns
, msg
);
383 switch (msg
->flags
) {
384 case SDW_MSG_FLAG_READ
:
385 *cmd
= CDNS_MCP_CMD_READ
;
388 case SDW_MSG_FLAG_WRITE
:
389 *cmd
= CDNS_MCP_CMD_WRITE
;
393 dev_err(cdns
->dev
, "Invalid msg cmd: %d\n", msg
->flags
);
400 enum sdw_command_response
401 cdns_xfer_msg(struct sdw_bus
*bus
, struct sdw_msg
*msg
)
403 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
406 ret
= cdns_prep_msg(cdns
, msg
, &cmd
);
408 return SDW_CMD_FAIL_OTHER
;
410 for (i
= 0; i
< msg
->len
/ CDNS_MCP_CMD_LEN
; i
++) {
411 ret
= _cdns_xfer_msg(cdns
, msg
, cmd
, i
* CDNS_MCP_CMD_LEN
,
412 CDNS_MCP_CMD_LEN
, false);
417 if (!(msg
->len
% CDNS_MCP_CMD_LEN
))
420 ret
= _cdns_xfer_msg(cdns
, msg
, cmd
, i
* CDNS_MCP_CMD_LEN
,
421 msg
->len
% CDNS_MCP_CMD_LEN
, false);
426 EXPORT_SYMBOL(cdns_xfer_msg
);
428 enum sdw_command_response
429 cdns_xfer_msg_defer(struct sdw_bus
*bus
,
430 struct sdw_msg
*msg
, struct sdw_defer
*defer
)
432 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
435 /* for defer only 1 message is supported */
439 ret
= cdns_prep_msg(cdns
, msg
, &cmd
);
441 return SDW_CMD_FAIL_OTHER
;
444 cdns
->defer
->length
= msg
->len
;
446 return _cdns_xfer_msg(cdns
, msg
, cmd
, 0, msg
->len
, true);
448 EXPORT_SYMBOL(cdns_xfer_msg_defer
);
450 enum sdw_command_response
451 cdns_reset_page_addr(struct sdw_bus
*bus
, unsigned int dev_num
)
453 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
456 /* Create dummy message with valid device number */
457 memset(&msg
, 0, sizeof(msg
));
458 msg
.dev_num
= dev_num
;
460 return cdns_program_scp_addr(cdns
, &msg
);
462 EXPORT_SYMBOL(cdns_reset_page_addr
);
468 static void cdns_read_response(struct sdw_cdns
*cdns
)
470 u32 num_resp
, cmd_base
;
473 num_resp
= cdns_readl(cdns
, CDNS_MCP_FIFOSTAT
);
474 num_resp
&= CDNS_MCP_RX_FIFO_AVAIL
;
476 cmd_base
= CDNS_MCP_CMD_BASE
;
478 for (i
= 0; i
< num_resp
; i
++) {
479 cdns
->response_buf
[i
] = cdns_readl(cdns
, cmd_base
);
480 cmd_base
+= CDNS_MCP_CMD_WORD_LEN
;
484 static int cdns_update_slave_status(struct sdw_cdns
*cdns
,
485 u32 slave0
, u32 slave1
)
487 enum sdw_slave_status status
[SDW_MAX_DEVICES
+ 1];
488 bool is_slave
= false;
492 /* combine the two status */
493 slave
= ((u64
)slave1
<< 32) | slave0
;
494 memset(status
, 0, sizeof(status
));
496 for (i
= 0; i
<= SDW_MAX_DEVICES
; i
++) {
497 mask
= (slave
>> (i
* CDNS_MCP_SLAVE_STATUS_NUM
)) &
498 CDNS_MCP_SLAVE_STATUS_BITS
;
505 if (mask
& CDNS_MCP_SLAVE_INTSTAT_RESERVED
) {
506 status
[i
] = SDW_SLAVE_RESERVED
;
510 if (mask
& CDNS_MCP_SLAVE_INTSTAT_ATTACHED
) {
511 status
[i
] = SDW_SLAVE_ATTACHED
;
515 if (mask
& CDNS_MCP_SLAVE_INTSTAT_ALERT
) {
516 status
[i
] = SDW_SLAVE_ALERT
;
520 if (mask
& CDNS_MCP_SLAVE_INTSTAT_NPRESENT
) {
521 status
[i
] = SDW_SLAVE_UNATTACHED
;
525 /* first check if Slave reported multiple status */
526 if (set_status
> 1) {
528 "Slave reported multiple Status: %d\n",
531 * TODO: we need to reread the status here by
538 return sdw_handle_slave_status(&cdns
->bus
, status
);
544 * sdw_cdns_irq() - Cadence interrupt handler
546 * @dev_id: irq context
548 irqreturn_t
sdw_cdns_irq(int irq
, void *dev_id
)
550 struct sdw_cdns
*cdns
= dev_id
;
552 int ret
= IRQ_HANDLED
;
554 /* Check if the link is up */
558 int_status
= cdns_readl(cdns
, CDNS_MCP_INTSTAT
);
560 if (!(int_status
& CDNS_MCP_INT_IRQ
))
563 if (int_status
& CDNS_MCP_INT_RX_WL
) {
564 cdns_read_response(cdns
);
567 cdns_fill_msg_resp(cdns
, cdns
->defer
->msg
,
568 cdns
->defer
->length
, 0);
569 complete(&cdns
->defer
->complete
);
572 complete(&cdns
->tx_complete
);
576 if (int_status
& CDNS_MCP_INT_CTRL_CLASH
) {
577 /* Slave is driving bit slot during control word */
578 dev_err_ratelimited(cdns
->dev
, "Bus clash for control word\n");
579 int_status
|= CDNS_MCP_INT_CTRL_CLASH
;
582 if (int_status
& CDNS_MCP_INT_DATA_CLASH
) {
584 * Multiple slaves trying to drive bit slot, or issue with
585 * ownership of data bits or Slave gone bonkers
587 dev_err_ratelimited(cdns
->dev
, "Bus clash for data word\n");
588 int_status
|= CDNS_MCP_INT_DATA_CLASH
;
591 if (int_status
& CDNS_MCP_INT_SLAVE_MASK
) {
592 /* Mask the Slave interrupt and wake thread */
593 cdns_updatel(cdns
, CDNS_MCP_INTMASK
,
594 CDNS_MCP_INT_SLAVE_MASK
, 0);
596 int_status
&= ~CDNS_MCP_INT_SLAVE_MASK
;
597 ret
= IRQ_WAKE_THREAD
;
600 cdns_writel(cdns
, CDNS_MCP_INTSTAT
, int_status
);
603 EXPORT_SYMBOL(sdw_cdns_irq
);
606 * sdw_cdns_thread() - Cadence irq thread handler
608 * @dev_id: irq context
610 irqreturn_t
sdw_cdns_thread(int irq
, void *dev_id
)
612 struct sdw_cdns
*cdns
= dev_id
;
615 dev_dbg(cdns
->dev
, "Slave status change\n");
617 slave0
= cdns_readl(cdns
, CDNS_MCP_SLAVE_INTSTAT0
);
618 slave1
= cdns_readl(cdns
, CDNS_MCP_SLAVE_INTSTAT1
);
620 cdns_update_slave_status(cdns
, slave0
, slave1
);
621 cdns_writel(cdns
, CDNS_MCP_SLAVE_INTSTAT0
, slave0
);
622 cdns_writel(cdns
, CDNS_MCP_SLAVE_INTSTAT1
, slave1
);
624 /* clear and unmask Slave interrupt now */
625 cdns_writel(cdns
, CDNS_MCP_INTSTAT
, CDNS_MCP_INT_SLAVE_MASK
);
626 cdns_updatel(cdns
, CDNS_MCP_INTMASK
,
627 CDNS_MCP_INT_SLAVE_MASK
, CDNS_MCP_INT_SLAVE_MASK
);
631 EXPORT_SYMBOL(sdw_cdns_thread
);
636 static int _cdns_enable_interrupt(struct sdw_cdns
*cdns
)
640 cdns_writel(cdns
, CDNS_MCP_SLAVE_INTMASK0
,
641 CDNS_MCP_SLAVE_INTMASK0_MASK
);
642 cdns_writel(cdns
, CDNS_MCP_SLAVE_INTMASK1
,
643 CDNS_MCP_SLAVE_INTMASK1_MASK
);
645 mask
= CDNS_MCP_INT_SLAVE_RSVD
| CDNS_MCP_INT_SLAVE_ALERT
|
646 CDNS_MCP_INT_SLAVE_ATTACH
| CDNS_MCP_INT_SLAVE_NATTACH
|
647 CDNS_MCP_INT_CTRL_CLASH
| CDNS_MCP_INT_DATA_CLASH
|
648 CDNS_MCP_INT_RX_WL
| CDNS_MCP_INT_IRQ
| CDNS_MCP_INT_DPINT
;
650 cdns_writel(cdns
, CDNS_MCP_INTMASK
, mask
);
656 * sdw_cdns_enable_interrupt() - Enable SDW interrupts and update config
657 * @cdns: Cadence instance
659 int sdw_cdns_enable_interrupt(struct sdw_cdns
*cdns
)
663 _cdns_enable_interrupt(cdns
);
664 ret
= cdns_clear_bit(cdns
, CDNS_MCP_CONFIG_UPDATE
,
665 CDNS_MCP_CONFIG_UPDATE_BIT
);
667 dev_err(cdns
->dev
, "Config update timedout\n");
671 EXPORT_SYMBOL(sdw_cdns_enable_interrupt
);
673 static int cdns_allocate_pdi(struct sdw_cdns
*cdns
,
674 struct sdw_cdns_pdi
**stream
,
675 u32 num
, u32 pdi_offset
)
677 struct sdw_cdns_pdi
*pdi
;
683 pdi
= devm_kcalloc(cdns
->dev
, num
, sizeof(*pdi
), GFP_KERNEL
);
687 for (i
= 0; i
< num
; i
++) {
688 pdi
[i
].num
= i
+ pdi_offset
;
689 pdi
[i
].assigned
= false;
697 * sdw_cdns_pdi_init() - PDI initialization routine
699 * @cdns: Cadence instance
700 * @config: Stream configurations
702 int sdw_cdns_pdi_init(struct sdw_cdns
*cdns
,
703 struct sdw_cdns_stream_config config
)
705 struct sdw_cdns_streams
*stream
;
708 cdns
->pcm
.num_bd
= config
.pcm_bd
;
709 cdns
->pcm
.num_in
= config
.pcm_in
;
710 cdns
->pcm
.num_out
= config
.pcm_out
;
711 cdns
->pdm
.num_bd
= config
.pdm_bd
;
712 cdns
->pdm
.num_in
= config
.pdm_in
;
713 cdns
->pdm
.num_out
= config
.pdm_out
;
715 /* Allocate PDIs for PCMs */
718 /* First two PDIs are reserved for bulk transfers */
719 stream
->num_bd
-= CDNS_PCM_PDI_OFFSET
;
720 offset
= CDNS_PCM_PDI_OFFSET
;
722 ret
= cdns_allocate_pdi(cdns
, &stream
->bd
,
723 stream
->num_bd
, offset
);
727 offset
+= stream
->num_bd
;
729 ret
= cdns_allocate_pdi(cdns
, &stream
->in
,
730 stream
->num_in
, offset
);
734 offset
+= stream
->num_in
;
736 ret
= cdns_allocate_pdi(cdns
, &stream
->out
,
737 stream
->num_out
, offset
);
741 /* Update total number of PCM PDIs */
742 stream
->num_pdi
= stream
->num_bd
+ stream
->num_in
+ stream
->num_out
;
743 cdns
->num_ports
= stream
->num_pdi
;
745 /* Allocate PDIs for PDMs */
747 offset
= CDNS_PDM_PDI_OFFSET
;
748 ret
= cdns_allocate_pdi(cdns
, &stream
->bd
,
749 stream
->num_bd
, offset
);
753 offset
+= stream
->num_bd
;
755 ret
= cdns_allocate_pdi(cdns
, &stream
->in
,
756 stream
->num_in
, offset
);
760 offset
+= stream
->num_in
;
762 ret
= cdns_allocate_pdi(cdns
, &stream
->out
,
763 stream
->num_out
, offset
);
767 /* Update total number of PDM PDIs */
768 stream
->num_pdi
= stream
->num_bd
+ stream
->num_in
+ stream
->num_out
;
769 cdns
->num_ports
+= stream
->num_pdi
;
771 cdns
->ports
= devm_kcalloc(cdns
->dev
, cdns
->num_ports
,
772 sizeof(*cdns
->ports
), GFP_KERNEL
);
778 for (i
= 0; i
< cdns
->num_ports
; i
++) {
779 cdns
->ports
[i
].assigned
= false;
780 cdns
->ports
[i
].num
= i
+ 1; /* Port 0 reserved for bulk */
785 EXPORT_SYMBOL(sdw_cdns_pdi_init
);
788 * sdw_cdns_init() - Cadence initialization
789 * @cdns: Cadence instance
791 int sdw_cdns_init(struct sdw_cdns
*cdns
)
796 /* Exit clock stop */
797 ret
= cdns_clear_bit(cdns
, CDNS_MCP_CONTROL
,
798 CDNS_MCP_CONTROL_CLK_STOP_CLR
);
800 dev_err(cdns
->dev
, "Couldn't exit from clock stop\n");
804 /* Set clock divider */
805 val
= cdns_readl(cdns
, CDNS_MCP_CLK_CTRL0
);
806 val
|= CDNS_DEFAULT_CLK_DIVIDER
;
807 cdns_writel(cdns
, CDNS_MCP_CLK_CTRL0
, val
);
809 /* Set the default frame shape */
810 cdns_writel(cdns
, CDNS_MCP_FRAME_SHAPE_INIT
, CDNS_DEFAULT_FRAME_SHAPE
);
812 /* Set SSP interval to default value */
813 cdns_writel(cdns
, CDNS_MCP_SSP_CTRL0
, CDNS_DEFAULT_SSP_INTERVAL
);
814 cdns_writel(cdns
, CDNS_MCP_SSP_CTRL1
, CDNS_DEFAULT_SSP_INTERVAL
);
816 /* Set cmd accept mode */
817 cdns_updatel(cdns
, CDNS_MCP_CONTROL
, CDNS_MCP_CONTROL_CMD_ACCEPT
,
818 CDNS_MCP_CONTROL_CMD_ACCEPT
);
820 /* Configure mcp config */
821 val
= cdns_readl(cdns
, CDNS_MCP_CONFIG
);
823 /* Set Max cmd retry to 15 */
824 val
|= CDNS_MCP_CONFIG_MCMD_RETRY
;
826 /* Set frame delay between PREQ and ping frame to 15 frames */
827 val
|= 0xF << SDW_REG_SHIFT(CDNS_MCP_CONFIG_MPREQ_DELAY
);
829 /* Disable auto bus release */
830 val
&= ~CDNS_MCP_CONFIG_BUS_REL
;
832 /* Disable sniffer mode */
833 val
&= ~CDNS_MCP_CONFIG_SNIFFER
;
835 /* Set cmd mode for Tx and Rx cmds */
836 val
&= ~CDNS_MCP_CONFIG_CMD
;
838 /* Set operation to normal */
839 val
&= ~CDNS_MCP_CONFIG_OP
;
840 val
|= CDNS_MCP_CONFIG_OP_NORMAL
;
842 cdns_writel(cdns
, CDNS_MCP_CONFIG
, val
);
846 EXPORT_SYMBOL(sdw_cdns_init
);
848 int cdns_bus_conf(struct sdw_bus
*bus
, struct sdw_bus_params
*params
)
850 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
851 int mcp_clkctrl_off
, mcp_clkctrl
;
854 if (!params
->curr_dr_freq
) {
855 dev_err(cdns
->dev
, "NULL curr_dr_freq\n");
859 divider
= (params
->max_dr_freq
/ params
->curr_dr_freq
) - 1;
861 if (params
->next_bank
)
862 mcp_clkctrl_off
= CDNS_MCP_CLK_CTRL1
;
864 mcp_clkctrl_off
= CDNS_MCP_CLK_CTRL0
;
866 mcp_clkctrl
= cdns_readl(cdns
, mcp_clkctrl_off
);
867 mcp_clkctrl
|= divider
;
868 cdns_writel(cdns
, mcp_clkctrl_off
, mcp_clkctrl
);
872 EXPORT_SYMBOL(cdns_bus_conf
);
874 static int cdns_port_params(struct sdw_bus
*bus
,
875 struct sdw_port_params
*p_params
, unsigned int bank
)
877 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
878 int dpn_config
= 0, dpn_config_off
;
881 dpn_config_off
= CDNS_DPN_B1_CONFIG(p_params
->num
);
883 dpn_config_off
= CDNS_DPN_B0_CONFIG(p_params
->num
);
885 dpn_config
= cdns_readl(cdns
, dpn_config_off
);
887 dpn_config
|= ((p_params
->bps
- 1) <<
888 SDW_REG_SHIFT(CDNS_DPN_CONFIG_WL
));
889 dpn_config
|= (p_params
->flow_mode
<<
890 SDW_REG_SHIFT(CDNS_DPN_CONFIG_PORT_FLOW
));
891 dpn_config
|= (p_params
->data_mode
<<
892 SDW_REG_SHIFT(CDNS_DPN_CONFIG_PORT_DAT
));
894 cdns_writel(cdns
, dpn_config_off
, dpn_config
);
899 static int cdns_transport_params(struct sdw_bus
*bus
,
900 struct sdw_transport_params
*t_params
,
901 enum sdw_reg_bank bank
)
903 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
904 int dpn_offsetctrl
= 0, dpn_offsetctrl_off
;
905 int dpn_config
= 0, dpn_config_off
;
906 int dpn_hctrl
= 0, dpn_hctrl_off
;
907 int num
= t_params
->port_num
;
908 int dpn_samplectrl_off
;
911 * Note: Only full data port is supported on the Master side for
912 * both PCM and PDM ports.
916 dpn_config_off
= CDNS_DPN_B1_CONFIG(num
);
917 dpn_samplectrl_off
= CDNS_DPN_B1_SAMPLE_CTRL(num
);
918 dpn_hctrl_off
= CDNS_DPN_B1_HCTRL(num
);
919 dpn_offsetctrl_off
= CDNS_DPN_B1_OFFSET_CTRL(num
);
921 dpn_config_off
= CDNS_DPN_B0_CONFIG(num
);
922 dpn_samplectrl_off
= CDNS_DPN_B0_SAMPLE_CTRL(num
);
923 dpn_hctrl_off
= CDNS_DPN_B0_HCTRL(num
);
924 dpn_offsetctrl_off
= CDNS_DPN_B0_OFFSET_CTRL(num
);
927 dpn_config
= cdns_readl(cdns
, dpn_config_off
);
929 dpn_config
|= (t_params
->blk_grp_ctrl
<<
930 SDW_REG_SHIFT(CDNS_DPN_CONFIG_BGC
));
931 dpn_config
|= (t_params
->blk_pkg_mode
<<
932 SDW_REG_SHIFT(CDNS_DPN_CONFIG_BPM
));
933 cdns_writel(cdns
, dpn_config_off
, dpn_config
);
935 dpn_offsetctrl
|= (t_params
->offset1
<<
936 SDW_REG_SHIFT(CDNS_DPN_OFFSET_CTRL_1
));
937 dpn_offsetctrl
|= (t_params
->offset2
<<
938 SDW_REG_SHIFT(CDNS_DPN_OFFSET_CTRL_2
));
939 cdns_writel(cdns
, dpn_offsetctrl_off
, dpn_offsetctrl
);
941 dpn_hctrl
|= (t_params
->hstart
<<
942 SDW_REG_SHIFT(CDNS_DPN_HCTRL_HSTART
));
943 dpn_hctrl
|= (t_params
->hstop
<< SDW_REG_SHIFT(CDNS_DPN_HCTRL_HSTOP
));
944 dpn_hctrl
|= (t_params
->lane_ctrl
<<
945 SDW_REG_SHIFT(CDNS_DPN_HCTRL_LCTRL
));
947 cdns_writel(cdns
, dpn_hctrl_off
, dpn_hctrl
);
948 cdns_writel(cdns
, dpn_samplectrl_off
, (t_params
->sample_interval
- 1));
953 static int cdns_port_enable(struct sdw_bus
*bus
,
954 struct sdw_enable_ch
*enable_ch
, unsigned int bank
)
956 struct sdw_cdns
*cdns
= bus_to_cdns(bus
);
957 int dpn_chnen_off
, ch_mask
;
960 dpn_chnen_off
= CDNS_DPN_B1_CH_EN(enable_ch
->port_num
);
962 dpn_chnen_off
= CDNS_DPN_B0_CH_EN(enable_ch
->port_num
);
964 ch_mask
= enable_ch
->ch_mask
* enable_ch
->enable
;
965 cdns_writel(cdns
, dpn_chnen_off
, ch_mask
);
970 static const struct sdw_master_port_ops cdns_port_ops
= {
971 .dpn_set_port_params
= cdns_port_params
,
972 .dpn_set_port_transport_params
= cdns_transport_params
,
973 .dpn_port_enable_ch
= cdns_port_enable
,
977 * sdw_cdns_probe() - Cadence probe routine
978 * @cdns: Cadence instance
980 int sdw_cdns_probe(struct sdw_cdns
*cdns
)
982 init_completion(&cdns
->tx_complete
);
983 cdns
->bus
.port_ops
= &cdns_port_ops
;
987 EXPORT_SYMBOL(sdw_cdns_probe
);
989 int cdns_set_sdw_stream(struct snd_soc_dai
*dai
,
990 void *stream
, bool pcm
, int direction
)
992 struct sdw_cdns
*cdns
= snd_soc_dai_get_drvdata(dai
);
993 struct sdw_cdns_dma_data
*dma
;
995 dma
= kzalloc(sizeof(*dma
), GFP_KERNEL
);
1000 dma
->stream_type
= SDW_STREAM_PCM
;
1002 dma
->stream_type
= SDW_STREAM_PDM
;
1004 dma
->bus
= &cdns
->bus
;
1005 dma
->link_id
= cdns
->instance
;
1007 dma
->stream
= stream
;
1009 if (direction
== SNDRV_PCM_STREAM_PLAYBACK
)
1010 dai
->playback_dma_data
= dma
;
1012 dai
->capture_dma_data
= dma
;
1016 EXPORT_SYMBOL(cdns_set_sdw_stream
);
1019 * cdns_find_pdi() - Find a free PDI
1021 * @cdns: Cadence instance
1022 * @num: Number of PDIs
1023 * @pdi: PDI instances
1025 * Find and return a free PDI for a given PDI array
1027 static struct sdw_cdns_pdi
*cdns_find_pdi(struct sdw_cdns
*cdns
,
1029 struct sdw_cdns_pdi
*pdi
)
1033 for (i
= 0; i
< num
; i
++) {
1034 if (pdi
[i
].assigned
)
1036 pdi
[i
].assigned
= true;
1044 * sdw_cdns_config_stream: Configure a stream
1046 * @cdns: Cadence instance
1047 * @port: Cadence data port
1048 * @ch: Channel count
1049 * @dir: Data direction
1050 * @pdi: PDI to be used
1052 void sdw_cdns_config_stream(struct sdw_cdns
*cdns
,
1053 struct sdw_cdns_port
*port
,
1054 u32 ch
, u32 dir
, struct sdw_cdns_pdi
*pdi
)
1056 u32 offset
, val
= 0;
1058 if (dir
== SDW_DATA_DIR_RX
)
1059 val
= CDNS_PORTCTRL_DIRN
;
1061 offset
= CDNS_PORTCTRL
+ port
->num
* CDNS_PORT_OFFSET
;
1062 cdns_updatel(cdns
, offset
, CDNS_PORTCTRL_DIRN
, val
);
1065 val
|= ((1 << ch
) - 1) << SDW_REG_SHIFT(CDNS_PDI_CONFIG_CHANNEL
);
1066 cdns_writel(cdns
, CDNS_PDI_CONFIG(pdi
->num
), val
);
1068 EXPORT_SYMBOL(sdw_cdns_config_stream
);
1071 * cdns_get_num_pdi() - Get number of PDIs required
1073 * @cdns: Cadence instance
1074 * @pdi: PDI to be used
1075 * @num: Number of PDIs
1076 * @ch_count: Channel count
1078 static int cdns_get_num_pdi(struct sdw_cdns
*cdns
,
1079 struct sdw_cdns_pdi
*pdi
,
1080 unsigned int num
, u32 ch_count
)
1084 for (i
= 0; i
< num
; i
++) {
1085 if (pdi
[i
].assigned
)
1088 if (pdi
[i
].ch_count
< ch_count
)
1089 ch_count
-= pdi
[i
].ch_count
;
1106 * sdw_cdns_get_stream() - Get stream information
1108 * @cdns: Cadence instance
1109 * @stream: Stream to be allocated
1110 * @ch: Channel count
1111 * @dir: Data direction
1113 int sdw_cdns_get_stream(struct sdw_cdns
*cdns
,
1114 struct sdw_cdns_streams
*stream
,
1119 if (dir
== SDW_DATA_DIR_RX
)
1120 pdis
= cdns_get_num_pdi(cdns
, stream
->in
, stream
->num_in
, ch
);
1122 pdis
= cdns_get_num_pdi(cdns
, stream
->out
, stream
->num_out
, ch
);
1124 /* check if we found PDI, else find in bi-directional */
1126 pdis
= cdns_get_num_pdi(cdns
, stream
->bd
, stream
->num_bd
, ch
);
1130 EXPORT_SYMBOL(sdw_cdns_get_stream
);
1133 * sdw_cdns_alloc_stream() - Allocate a stream
1135 * @cdns: Cadence instance
1136 * @stream: Stream to be allocated
1137 * @port: Cadence data port
1138 * @ch: Channel count
1139 * @dir: Data direction
1141 int sdw_cdns_alloc_stream(struct sdw_cdns
*cdns
,
1142 struct sdw_cdns_streams
*stream
,
1143 struct sdw_cdns_port
*port
, u32 ch
, u32 dir
)
1145 struct sdw_cdns_pdi
*pdi
= NULL
;
1147 if (dir
== SDW_DATA_DIR_RX
)
1148 pdi
= cdns_find_pdi(cdns
, stream
->num_in
, stream
->in
);
1150 pdi
= cdns_find_pdi(cdns
, stream
->num_out
, stream
->out
);
1152 /* check if we found a PDI, else find in bi-directional */
1154 pdi
= cdns_find_pdi(cdns
, stream
->num_bd
, stream
->bd
);
1161 pdi
->h_ch_num
= ch
- 1;
1167 EXPORT_SYMBOL(sdw_cdns_alloc_stream
);
1169 void sdw_cdns_shutdown(struct snd_pcm_substream
*substream
,
1170 struct snd_soc_dai
*dai
)
1172 struct sdw_cdns_dma_data
*dma
;
1174 dma
= snd_soc_dai_get_dma_data(dai
, substream
);
1178 snd_soc_dai_set_dma_data(dai
, substream
, NULL
);
1181 EXPORT_SYMBOL(sdw_cdns_shutdown
);
1183 MODULE_LICENSE("Dual BSD/GPL");
1184 MODULE_DESCRIPTION("Cadence Soundwire Library");