?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dm writecache: fix incorrect flush sequence when doing SSD mode commit
[linux/fpc-iii.git] / drivers / soundwire / cadence_master.c
blobfed21e2b22774de380d464499ae349b20dbd690e
1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 // Copyright(c) 2015-17 Intel Corporation.
3
4 /*
5 * Cadence SoundWire Master module
6 * Used by Master driver
7 */
8
9 #include <linux/delay.h>
10 #include <linux/device.h>
11 #include <linux/debugfs.h>
12 #include <linux/interrupt.h>
13 #include <linux/io.h>
14 #include <linux/module.h>
15 #include <linux/mod_devicetable.h>
16 #include <linux/soundwire/sdw_registers.h>
17 #include <linux/soundwire/sdw.h>
18 #include <sound/pcm_params.h>
19 #include <sound/soc.h>
20 #include "bus.h"
21 #include "cadence_master.h"
22
23 static int interrupt_mask;
24 module_param_named(cnds_mcp_int_mask, interrupt_mask, int, 0444);
25 MODULE_PARM_DESC(cdns_mcp_int_mask, "Cadence MCP IntMask");
26
27 #define CDNS_MCP_CONFIG 0x0
28
29 #define CDNS_MCP_CONFIG_MCMD_RETRY GENMASK(27, 24)
30 #define CDNS_MCP_CONFIG_MPREQ_DELAY GENMASK(20, 16)
31 #define CDNS_MCP_CONFIG_MMASTER BIT(7)
32 #define CDNS_MCP_CONFIG_BUS_REL BIT(6)
33 #define CDNS_MCP_CONFIG_SNIFFER BIT(5)
34 #define CDNS_MCP_CONFIG_SSPMOD BIT(4)
35 #define CDNS_MCP_CONFIG_CMD BIT(3)
36 #define CDNS_MCP_CONFIG_OP GENMASK(2, 0)
37 #define CDNS_MCP_CONFIG_OP_NORMAL 0
38
39 #define CDNS_MCP_CONTROL 0x4
40
41 #define CDNS_MCP_CONTROL_RST_DELAY GENMASK(10, 8)
42 #define CDNS_MCP_CONTROL_CMD_RST BIT(7)
43 #define CDNS_MCP_CONTROL_SOFT_RST BIT(6)
44 #define CDNS_MCP_CONTROL_SW_RST BIT(5)
45 #define CDNS_MCP_CONTROL_HW_RST BIT(4)
46 #define CDNS_MCP_CONTROL_CLK_PAUSE BIT(3)
47 #define CDNS_MCP_CONTROL_CLK_STOP_CLR BIT(2)
48 #define CDNS_MCP_CONTROL_CMD_ACCEPT BIT(1)
49 #define CDNS_MCP_CONTROL_BLOCK_WAKEUP BIT(0)
50
51 #define CDNS_MCP_CMDCTRL 0x8
52 #define CDNS_MCP_SSPSTAT 0xC
53 #define CDNS_MCP_FRAME_SHAPE 0x10
54 #define CDNS_MCP_FRAME_SHAPE_INIT 0x14
55 #define CDNS_MCP_FRAME_SHAPE_COL_MASK GENMASK(2, 0)
56 #define CDNS_MCP_FRAME_SHAPE_ROW_OFFSET 3
57
58 #define CDNS_MCP_CONFIG_UPDATE 0x18
59 #define CDNS_MCP_CONFIG_UPDATE_BIT BIT(0)
60
61 #define CDNS_MCP_PHYCTRL 0x1C
62 #define CDNS_MCP_SSP_CTRL0 0x20
63 #define CDNS_MCP_SSP_CTRL1 0x28
64 #define CDNS_MCP_CLK_CTRL0 0x30
65 #define CDNS_MCP_CLK_CTRL1 0x38
66 #define CDNS_MCP_CLK_MCLKD_MASK GENMASK(7, 0)
67
68 #define CDNS_MCP_STAT 0x40
69
70 #define CDNS_MCP_STAT_ACTIVE_BANK BIT(20)
71 #define CDNS_MCP_STAT_CLK_STOP BIT(16)
72
73 #define CDNS_MCP_INTSTAT 0x44
74 #define CDNS_MCP_INTMASK 0x48
75
76 #define CDNS_MCP_INT_IRQ BIT(31)
77 #define CDNS_MCP_INT_WAKEUP BIT(16)
78 #define CDNS_MCP_INT_SLAVE_RSVD BIT(15)
79 #define CDNS_MCP_INT_SLAVE_ALERT BIT(14)
80 #define CDNS_MCP_INT_SLAVE_ATTACH BIT(13)
81 #define CDNS_MCP_INT_SLAVE_NATTACH BIT(12)
82 #define CDNS_MCP_INT_SLAVE_MASK GENMASK(15, 12)
83 #define CDNS_MCP_INT_DPINT BIT(11)
84 #define CDNS_MCP_INT_CTRL_CLASH BIT(10)
85 #define CDNS_MCP_INT_DATA_CLASH BIT(9)
86 #define CDNS_MCP_INT_PARITY BIT(8)
87 #define CDNS_MCP_INT_CMD_ERR BIT(7)
88 #define CDNS_MCP_INT_RX_NE BIT(3)
89 #define CDNS_MCP_INT_RX_WL BIT(2)
90 #define CDNS_MCP_INT_TXE BIT(1)
91 #define CDNS_MCP_INT_TXF BIT(0)
92
93 #define CDNS_MCP_INTSET 0x4C
94
95 #define CDNS_MCP_SLAVE_STAT 0x50
96 #define CDNS_MCP_SLAVE_STAT_MASK GENMASK(1, 0)
97
98 #define CDNS_MCP_SLAVE_INTSTAT0 0x54
99 #define CDNS_MCP_SLAVE_INTSTAT1 0x58
100 #define CDNS_MCP_SLAVE_INTSTAT_NPRESENT BIT(0)
101 #define CDNS_MCP_SLAVE_INTSTAT_ATTACHED BIT(1)
102 #define CDNS_MCP_SLAVE_INTSTAT_ALERT BIT(2)
103 #define CDNS_MCP_SLAVE_INTSTAT_RESERVED BIT(3)
104 #define CDNS_MCP_SLAVE_STATUS_BITS GENMASK(3, 0)
105 #define CDNS_MCP_SLAVE_STATUS_NUM 4
106
107 #define CDNS_MCP_SLAVE_INTMASK0 0x5C
108 #define CDNS_MCP_SLAVE_INTMASK1 0x60
109
110 #define CDNS_MCP_SLAVE_INTMASK0_MASK GENMASK(31, 0)
111 #define CDNS_MCP_SLAVE_INTMASK1_MASK GENMASK(15, 0)
112
113 #define CDNS_MCP_PORT_INTSTAT 0x64
114 #define CDNS_MCP_PDI_STAT 0x6C
115
116 #define CDNS_MCP_FIFOLEVEL 0x78
117 #define CDNS_MCP_FIFOSTAT 0x7C
118 #define CDNS_MCP_RX_FIFO_AVAIL GENMASK(5, 0)
119
120 #define CDNS_MCP_CMD_BASE 0x80
121 #define CDNS_MCP_RESP_BASE 0x80
122 #define CDNS_MCP_CMD_LEN 0x20
123 #define CDNS_MCP_CMD_WORD_LEN 0x4
124
125 #define CDNS_MCP_CMD_SSP_TAG BIT(31)
126 #define CDNS_MCP_CMD_COMMAND GENMASK(30, 28)
127 #define CDNS_MCP_CMD_DEV_ADDR GENMASK(27, 24)
128 #define CDNS_MCP_CMD_REG_ADDR_H GENMASK(23, 16)
129 #define CDNS_MCP_CMD_REG_ADDR_L GENMASK(15, 8)
130 #define CDNS_MCP_CMD_REG_DATA GENMASK(7, 0)
131
132 #define CDNS_MCP_CMD_READ 2
133 #define CDNS_MCP_CMD_WRITE 3
134
135 #define CDNS_MCP_RESP_RDATA GENMASK(15, 8)
136 #define CDNS_MCP_RESP_ACK BIT(0)
137 #define CDNS_MCP_RESP_NACK BIT(1)
138
139 #define CDNS_DP_SIZE 128
140
141 #define CDNS_DPN_B0_CONFIG(n) (0x100 + CDNS_DP_SIZE * (n))
142 #define CDNS_DPN_B0_CH_EN(n) (0x104 + CDNS_DP_SIZE * (n))
143 #define CDNS_DPN_B0_SAMPLE_CTRL(n) (0x108 + CDNS_DP_SIZE * (n))
144 #define CDNS_DPN_B0_OFFSET_CTRL(n) (0x10C + CDNS_DP_SIZE * (n))
145 #define CDNS_DPN_B0_HCTRL(n) (0x110 + CDNS_DP_SIZE * (n))
146 #define CDNS_DPN_B0_ASYNC_CTRL(n) (0x114 + CDNS_DP_SIZE * (n))
147
148 #define CDNS_DPN_B1_CONFIG(n) (0x118 + CDNS_DP_SIZE * (n))
149 #define CDNS_DPN_B1_CH_EN(n) (0x11C + CDNS_DP_SIZE * (n))
150 #define CDNS_DPN_B1_SAMPLE_CTRL(n) (0x120 + CDNS_DP_SIZE * (n))
151 #define CDNS_DPN_B1_OFFSET_CTRL(n) (0x124 + CDNS_DP_SIZE * (n))
152 #define CDNS_DPN_B1_HCTRL(n) (0x128 + CDNS_DP_SIZE * (n))
153 #define CDNS_DPN_B1_ASYNC_CTRL(n) (0x12C + CDNS_DP_SIZE * (n))
154
155 #define CDNS_DPN_CONFIG_BPM BIT(18)
156 #define CDNS_DPN_CONFIG_BGC GENMASK(17, 16)
157 #define CDNS_DPN_CONFIG_WL GENMASK(12, 8)
158 #define CDNS_DPN_CONFIG_PORT_DAT GENMASK(3, 2)
159 #define CDNS_DPN_CONFIG_PORT_FLOW GENMASK(1, 0)
160
161 #define CDNS_DPN_SAMPLE_CTRL_SI GENMASK(15, 0)
162
163 #define CDNS_DPN_OFFSET_CTRL_1 GENMASK(7, 0)
164 #define CDNS_DPN_OFFSET_CTRL_2 GENMASK(15, 8)
165
166 #define CDNS_DPN_HCTRL_HSTOP GENMASK(3, 0)
167 #define CDNS_DPN_HCTRL_HSTART GENMASK(7, 4)
168 #define CDNS_DPN_HCTRL_LCTRL GENMASK(10, 8)
169
170 #define CDNS_PORTCTRL 0x130
171 #define CDNS_PORTCTRL_DIRN BIT(7)
172 #define CDNS_PORTCTRL_BANK_INVERT BIT(8)
173
174 #define CDNS_PORT_OFFSET 0x80
175
176 #define CDNS_PDI_CONFIG(n) (0x1100 + (n) * 16)
177
178 #define CDNS_PDI_CONFIG_SOFT_RESET BIT(24)
179 #define CDNS_PDI_CONFIG_CHANNEL GENMASK(15, 8)
180 #define CDNS_PDI_CONFIG_PORT GENMASK(4, 0)
181
182 /* Driver defaults */
183 #define CDNS_DEFAULT_SSP_INTERVAL 0x18
184 #define CDNS_TX_TIMEOUT 2000
185
186 #define CDNS_SCP_RX_FIFOLEVEL 0x2
187
188 /*
189 * register accessor helpers
190 */
191 static inline u32 cdns_readl(struct sdw_cdns *cdns, int offset)
192 {
193 return readl(cdns->registers + offset);
194 }
195
196 static inline void cdns_writel(struct sdw_cdns *cdns, int offset, u32 value)
197 {
198 writel(value, cdns->registers + offset);
199 }
200
201 static inline void cdns_updatel(struct sdw_cdns *cdns,
202 int offset, u32 mask, u32 val)
203 {
204 u32 tmp;
205
206 tmp = cdns_readl(cdns, offset);
207 tmp = (tmp & ~mask) | val;
208 cdns_writel(cdns, offset, tmp);
209 }
210
211 static int cdns_clear_bit(struct sdw_cdns *cdns, int offset, u32 value)
212 {
213 int timeout = 10;
214 u32 reg_read;
215
216 writel(value, cdns->registers + offset);
217
218 /* Wait for bit to be self cleared */
219 do {
220 reg_read = readl(cdns->registers + offset);
221 if ((reg_read & value) == 0)
222 return 0;
223
224 timeout--;
225 udelay(50);
226 } while (timeout != 0);
227
228 return -EAGAIN;
229 }
230
231 /*
232 * all changes to the MCP_CONFIG, MCP_CONTROL, MCP_CMDCTRL and MCP_PHYCTRL
233 * need to be confirmed with a write to MCP_CONFIG_UPDATE
234 */
235 static int cdns_update_config(struct sdw_cdns *cdns)
236 {
237 int ret;
238
239 ret = cdns_clear_bit(cdns, CDNS_MCP_CONFIG_UPDATE,
240 CDNS_MCP_CONFIG_UPDATE_BIT);
241 if (ret < 0)
242 dev_err(cdns->dev, "Config update timedout\n");
243
244 return ret;
245 }
246
247 /*
248 * debugfs
249 */
250 #ifdef CONFIG_DEBUG_FS
251
252 #define RD_BUF (2 * PAGE_SIZE)
253
254 static ssize_t cdns_sprintf(struct sdw_cdns *cdns,
255 char *buf, size_t pos, unsigned int reg)
256 {
257 return scnprintf(buf + pos, RD_BUF - pos,
258 "%4x\t%8x\n", reg, cdns_readl(cdns, reg));
259 }
260
261 static int cdns_reg_show(struct seq_file *s, void *data)
262 {
263 struct sdw_cdns *cdns = s->private;
264 char *buf;
265 ssize_t ret;
266 int num_ports;
267 int i, j;
268
269 buf = kzalloc(RD_BUF, GFP_KERNEL);
270 if (!buf)
271 return -ENOMEM;
272
273 ret = scnprintf(buf, RD_BUF, "Register Value\n");
274 ret += scnprintf(buf + ret, RD_BUF - ret, "\nMCP Registers\n");
275 /* 8 MCP registers */
276 for (i = CDNS_MCP_CONFIG; i <= CDNS_MCP_PHYCTRL; i += sizeof(u32))
277 ret += cdns_sprintf(cdns, buf, ret, i);
278
279 ret += scnprintf(buf + ret, RD_BUF - ret,
280 "\nStatus & Intr Registers\n");
281 /* 13 Status & Intr registers (offsets 0x70 and 0x74 not defined) */
282 for (i = CDNS_MCP_STAT; i <= CDNS_MCP_FIFOSTAT; i += sizeof(u32))
283 ret += cdns_sprintf(cdns, buf, ret, i);
284
285 ret += scnprintf(buf + ret, RD_BUF - ret,
286 "\nSSP & Clk ctrl Registers\n");
287 ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_SSP_CTRL0);
288 ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_SSP_CTRL1);
289 ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_CLK_CTRL0);
290 ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_CLK_CTRL1);
291
292 ret += scnprintf(buf + ret, RD_BUF - ret,
293 "\nDPn B0 Registers\n");
294
295 num_ports = cdns->num_ports;
296
297 for (i = 0; i < num_ports; i++) {
298 ret += scnprintf(buf + ret, RD_BUF - ret,
299 "\nDP-%d\n", i);
300 for (j = CDNS_DPN_B0_CONFIG(i);
301 j < CDNS_DPN_B0_ASYNC_CTRL(i); j += sizeof(u32))
302 ret += cdns_sprintf(cdns, buf, ret, j);
303 }
304
305 ret += scnprintf(buf + ret, RD_BUF - ret,
306 "\nDPn B1 Registers\n");
307 for (i = 0; i < num_ports; i++) {
308 ret += scnprintf(buf + ret, RD_BUF - ret,
309 "\nDP-%d\n", i);
310
311 for (j = CDNS_DPN_B1_CONFIG(i);
312 j < CDNS_DPN_B1_ASYNC_CTRL(i); j += sizeof(u32))
313 ret += cdns_sprintf(cdns, buf, ret, j);
314 }
315
316 ret += scnprintf(buf + ret, RD_BUF - ret,
317 "\nDPn Control Registers\n");
318 for (i = 0; i < num_ports; i++)
319 ret += cdns_sprintf(cdns, buf, ret,
320 CDNS_PORTCTRL + i * CDNS_PORT_OFFSET);
321
322 ret += scnprintf(buf + ret, RD_BUF - ret,
323 "\nPDIn Config Registers\n");
324
325 /* number of PDI and ports is interchangeable */
326 for (i = 0; i < num_ports; i++)
327 ret += cdns_sprintf(cdns, buf, ret, CDNS_PDI_CONFIG(i));
328
329 seq_printf(s, "%s", buf);
330 kfree(buf);
331
332 return 0;
333 }
334 DEFINE_SHOW_ATTRIBUTE(cdns_reg);
335
336 static int cdns_hw_reset(void *data, u64 value)
337 {
338 struct sdw_cdns *cdns = data;
339 int ret;
340
341 if (value != 1)
342 return -EINVAL;
343
344 /* Userspace changed the hardware state behind the kernel's back */
345 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
346
347 ret = sdw_cdns_exit_reset(cdns);
348
349 dev_dbg(cdns->dev, "link hw_reset done: %d\n", ret);
350
351 return ret;
352 }
353
354 DEFINE_DEBUGFS_ATTRIBUTE(cdns_hw_reset_fops, NULL, cdns_hw_reset, "%llu\n");
355
356 /**
357 * sdw_cdns_debugfs_init() - Cadence debugfs init
358 * @cdns: Cadence instance
359 * @root: debugfs root
360 */
361 void sdw_cdns_debugfs_init(struct sdw_cdns *cdns, struct dentry *root)
362 {
363 debugfs_create_file("cdns-registers", 0400, root, cdns, &cdns_reg_fops);
364
365 debugfs_create_file("cdns-hw-reset", 0200, root, cdns,
366 &cdns_hw_reset_fops);
367 }
368 EXPORT_SYMBOL_GPL(sdw_cdns_debugfs_init);
369
370 #endif /* CONFIG_DEBUG_FS */
371
372 /*
373 * IO Calls
374 */
375 static enum sdw_command_response
376 cdns_fill_msg_resp(struct sdw_cdns *cdns,
377 struct sdw_msg *msg, int count, int offset)
378 {
379 int nack = 0, no_ack = 0;
380 int i;
381
382 /* check message response */
383 for (i = 0; i < count; i++) {
384 if (!(cdns->response_buf[i] & CDNS_MCP_RESP_ACK)) {
385 no_ack = 1;
386 dev_dbg_ratelimited(cdns->dev, "Msg Ack not received\n");
387 if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
388 nack = 1;
389 dev_err_ratelimited(cdns->dev, "Msg NACK received\n");
390 }
391 }
392 }
393
394 if (nack) {
395 dev_err_ratelimited(cdns->dev, "Msg NACKed for Slave %d\n", msg->dev_num);
396 return SDW_CMD_FAIL;
397 } else if (no_ack) {
398 dev_dbg_ratelimited(cdns->dev, "Msg ignored for Slave %d\n", msg->dev_num);
399 return SDW_CMD_IGNORED;
400 }
401
402 /* fill response */
403 for (i = 0; i < count; i++)
404 msg->buf[i + offset] = cdns->response_buf[i] >>
405 SDW_REG_SHIFT(CDNS_MCP_RESP_RDATA);
406
407 return SDW_CMD_OK;
408 }
409
410 static enum sdw_command_response
411 _cdns_xfer_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int cmd,
412 int offset, int count, bool defer)
413 {
414 unsigned long time;
415 u32 base, i, data;
416 u16 addr;
417
418 /* Program the watermark level for RX FIFO */
419 if (cdns->msg_count != count) {
420 cdns_writel(cdns, CDNS_MCP_FIFOLEVEL, count);
421 cdns->msg_count = count;
422 }
423
424 base = CDNS_MCP_CMD_BASE;
425 addr = msg->addr;
426
427 for (i = 0; i < count; i++) {
428 data = msg->dev_num << SDW_REG_SHIFT(CDNS_MCP_CMD_DEV_ADDR);
429 data |= cmd << SDW_REG_SHIFT(CDNS_MCP_CMD_COMMAND);
430 data |= addr++ << SDW_REG_SHIFT(CDNS_MCP_CMD_REG_ADDR_L);
431
432 if (msg->flags == SDW_MSG_FLAG_WRITE)
433 data |= msg->buf[i + offset];
434
435 data |= msg->ssp_sync << SDW_REG_SHIFT(CDNS_MCP_CMD_SSP_TAG);
436 cdns_writel(cdns, base, data);
437 base += CDNS_MCP_CMD_WORD_LEN;
438 }
439
440 if (defer)
441 return SDW_CMD_OK;
442
443 /* wait for timeout or response */
444 time = wait_for_completion_timeout(&cdns->tx_complete,
445 msecs_to_jiffies(CDNS_TX_TIMEOUT));
446 if (!time) {
447 dev_err(cdns->dev, "IO transfer timed out\n");
448 msg->len = 0;
449 return SDW_CMD_TIMEOUT;
450 }
451
452 return cdns_fill_msg_resp(cdns, msg, count, offset);
453 }
454
455 static enum sdw_command_response
456 cdns_program_scp_addr(struct sdw_cdns *cdns, struct sdw_msg *msg)
457 {
458 int nack = 0, no_ack = 0;
459 unsigned long time;
460 u32 data[2], base;
461 int i;
462
463 /* Program the watermark level for RX FIFO */
464 if (cdns->msg_count != CDNS_SCP_RX_FIFOLEVEL) {
465 cdns_writel(cdns, CDNS_MCP_FIFOLEVEL, CDNS_SCP_RX_FIFOLEVEL);
466 cdns->msg_count = CDNS_SCP_RX_FIFOLEVEL;
467 }
468
469 data[0] = msg->dev_num << SDW_REG_SHIFT(CDNS_MCP_CMD_DEV_ADDR);
470 data[0] |= 0x3 << SDW_REG_SHIFT(CDNS_MCP_CMD_COMMAND);
471 data[1] = data[0];
472
473 data[0] |= SDW_SCP_ADDRPAGE1 << SDW_REG_SHIFT(CDNS_MCP_CMD_REG_ADDR_L);
474 data[1] |= SDW_SCP_ADDRPAGE2 << SDW_REG_SHIFT(CDNS_MCP_CMD_REG_ADDR_L);
475
476 data[0] |= msg->addr_page1;
477 data[1] |= msg->addr_page2;
478
479 base = CDNS_MCP_CMD_BASE;
480 cdns_writel(cdns, base, data[0]);
481 base += CDNS_MCP_CMD_WORD_LEN;
482 cdns_writel(cdns, base, data[1]);
483
484 time = wait_for_completion_timeout(&cdns->tx_complete,
485 msecs_to_jiffies(CDNS_TX_TIMEOUT));
486 if (!time) {
487 dev_err(cdns->dev, "SCP Msg trf timed out\n");
488 msg->len = 0;
489 return SDW_CMD_TIMEOUT;
490 }
491
492 /* check response the writes */
493 for (i = 0; i < 2; i++) {
494 if (!(cdns->response_buf[i] & CDNS_MCP_RESP_ACK)) {
495 no_ack = 1;
496 dev_err(cdns->dev, "Program SCP Ack not received\n");
497 if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
498 nack = 1;
499 dev_err(cdns->dev, "Program SCP NACK received\n");
500 }
501 }
502 }
503
504 /* For NACK, NO ack, don't return err if we are in Broadcast mode */
505 if (nack) {
506 dev_err_ratelimited(cdns->dev,
507 "SCP_addrpage NACKed for Slave %d\n", msg->dev_num);
508 return SDW_CMD_FAIL;
509 } else if (no_ack) {
510 dev_dbg_ratelimited(cdns->dev,
511 "SCP_addrpage ignored for Slave %d\n", msg->dev_num);
512 return SDW_CMD_IGNORED;
513 }
514
515 return SDW_CMD_OK;
516 }
517
518 static int cdns_prep_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int *cmd)
519 {
520 int ret;
521
522 if (msg->page) {
523 ret = cdns_program_scp_addr(cdns, msg);
524 if (ret) {
525 msg->len = 0;
526 return ret;
527 }
528 }
529
530 switch (msg->flags) {
531 case SDW_MSG_FLAG_READ:
532 *cmd = CDNS_MCP_CMD_READ;
533 break;
534
535 case SDW_MSG_FLAG_WRITE:
536 *cmd = CDNS_MCP_CMD_WRITE;
537 break;
538
539 default:
540 dev_err(cdns->dev, "Invalid msg cmd: %d\n", msg->flags);
541 return -EINVAL;
542 }
543
544 return 0;
545 }
546
547 enum sdw_command_response
548 cdns_xfer_msg(struct sdw_bus *bus, struct sdw_msg *msg)
549 {
550 struct sdw_cdns *cdns = bus_to_cdns(bus);
551 int cmd = 0, ret, i;
552
553 ret = cdns_prep_msg(cdns, msg, &cmd);
554 if (ret)
555 return SDW_CMD_FAIL_OTHER;
556
557 for (i = 0; i < msg->len / CDNS_MCP_CMD_LEN; i++) {
558 ret = _cdns_xfer_msg(cdns, msg, cmd, i * CDNS_MCP_CMD_LEN,
559 CDNS_MCP_CMD_LEN, false);
560 if (ret < 0)
561 goto exit;
562 }
563
564 if (!(msg->len % CDNS_MCP_CMD_LEN))
565 goto exit;
566
567 ret = _cdns_xfer_msg(cdns, msg, cmd, i * CDNS_MCP_CMD_LEN,
568 msg->len % CDNS_MCP_CMD_LEN, false);
569
570 exit:
571 return ret;
572 }
573 EXPORT_SYMBOL(cdns_xfer_msg);
574
575 enum sdw_command_response
576 cdns_xfer_msg_defer(struct sdw_bus *bus,
577 struct sdw_msg *msg, struct sdw_defer *defer)
578 {
579 struct sdw_cdns *cdns = bus_to_cdns(bus);
580 int cmd = 0, ret;
581
582 /* for defer only 1 message is supported */
583 if (msg->len > 1)
584 return -ENOTSUPP;
585
586 ret = cdns_prep_msg(cdns, msg, &cmd);
587 if (ret)
588 return SDW_CMD_FAIL_OTHER;
589
590 cdns->defer = defer;
591 cdns->defer->length = msg->len;
592
593 return _cdns_xfer_msg(cdns, msg, cmd, 0, msg->len, true);
594 }
595 EXPORT_SYMBOL(cdns_xfer_msg_defer);
596
597 enum sdw_command_response
598 cdns_reset_page_addr(struct sdw_bus *bus, unsigned int dev_num)
599 {
600 struct sdw_cdns *cdns = bus_to_cdns(bus);
601 struct sdw_msg msg;
602
603 /* Create dummy message with valid device number */
604 memset(&msg, 0, sizeof(msg));
605 msg.dev_num = dev_num;
606
607 return cdns_program_scp_addr(cdns, &msg);
608 }
609 EXPORT_SYMBOL(cdns_reset_page_addr);
610
611 /*
612 * IRQ handling
613 */
614
615 static void cdns_read_response(struct sdw_cdns *cdns)
616 {
617 u32 num_resp, cmd_base;
618 int i;
619
620 num_resp = cdns_readl(cdns, CDNS_MCP_FIFOSTAT);
621 num_resp &= CDNS_MCP_RX_FIFO_AVAIL;
622
623 cmd_base = CDNS_MCP_CMD_BASE;
624
625 for (i = 0; i < num_resp; i++) {
626 cdns->response_buf[i] = cdns_readl(cdns, cmd_base);
627 cmd_base += CDNS_MCP_CMD_WORD_LEN;
628 }
629 }
630
631 static int cdns_update_slave_status(struct sdw_cdns *cdns,
632 u32 slave0, u32 slave1)
633 {
634 enum sdw_slave_status status[SDW_MAX_DEVICES + 1];
635 bool is_slave = false;
636 u64 slave;
637 u32 mask;
638 int i, set_status;
639
640 /* combine the two status */
641 slave = ((u64)slave1 << 32) | slave0;
642 memset(status, 0, sizeof(status));
643
644 for (i = 0; i <= SDW_MAX_DEVICES; i++) {
645 mask = (slave >> (i * CDNS_MCP_SLAVE_STATUS_NUM)) &
646 CDNS_MCP_SLAVE_STATUS_BITS;
647 if (!mask)
648 continue;
649
650 is_slave = true;
651 set_status = 0;
652
653 if (mask & CDNS_MCP_SLAVE_INTSTAT_RESERVED) {
654 status[i] = SDW_SLAVE_RESERVED;
655 set_status++;
656 }
657
658 if (mask & CDNS_MCP_SLAVE_INTSTAT_ATTACHED) {
659 status[i] = SDW_SLAVE_ATTACHED;
660 set_status++;
661 }
662
663 if (mask & CDNS_MCP_SLAVE_INTSTAT_ALERT) {
664 status[i] = SDW_SLAVE_ALERT;
665 set_status++;
666 }
667
668 if (mask & CDNS_MCP_SLAVE_INTSTAT_NPRESENT) {
669 status[i] = SDW_SLAVE_UNATTACHED;
670 set_status++;
671 }
672
673 /* first check if Slave reported multiple status */
674 if (set_status > 1) {
675 dev_warn_ratelimited(cdns->dev,
676 "Slave reported multiple Status: %d\n",
677 mask);
678 /*
679 * TODO: we need to reread the status here by
680 * issuing a PING cmd
681 */
682 }
683 }
684
685 if (is_slave)
686 return sdw_handle_slave_status(&cdns->bus, status);
687
688 return 0;
689 }
690
691 /**
692 * sdw_cdns_irq() - Cadence interrupt handler
693 * @irq: irq number
694 * @dev_id: irq context
695 */
696 irqreturn_t sdw_cdns_irq(int irq, void *dev_id)
697 {
698 struct sdw_cdns *cdns = dev_id;
699 u32 int_status;
700 int ret = IRQ_HANDLED;
701
702 /* Check if the link is up */
703 if (!cdns->link_up)
704 return IRQ_NONE;
705
706 int_status = cdns_readl(cdns, CDNS_MCP_INTSTAT);
707
708 if (!(int_status & CDNS_MCP_INT_IRQ))
709 return IRQ_NONE;
710
711 if (int_status & CDNS_MCP_INT_RX_WL) {
712 cdns_read_response(cdns);
713
714 if (cdns->defer) {
715 cdns_fill_msg_resp(cdns, cdns->defer->msg,
716 cdns->defer->length, 0);
717 complete(&cdns->defer->complete);
718 cdns->defer = NULL;
719 } else {
720 complete(&cdns->tx_complete);
721 }
722 }
723
724 if (int_status & CDNS_MCP_INT_PARITY) {
725 /* Parity error detected by Master */
726 dev_err_ratelimited(cdns->dev, "Parity error\n");
727 }
728
729 if (int_status & CDNS_MCP_INT_CTRL_CLASH) {
730 /* Slave is driving bit slot during control word */
731 dev_err_ratelimited(cdns->dev, "Bus clash for control word\n");
732 }
733
734 if (int_status & CDNS_MCP_INT_DATA_CLASH) {
735 /*
736 * Multiple slaves trying to drive bit slot, or issue with
737 * ownership of data bits or Slave gone bonkers
738 */
739 dev_err_ratelimited(cdns->dev, "Bus clash for data word\n");
740 }
741
742 if (int_status & CDNS_MCP_INT_SLAVE_MASK) {
743 /* Mask the Slave interrupt and wake thread */
744 cdns_updatel(cdns, CDNS_MCP_INTMASK,
745 CDNS_MCP_INT_SLAVE_MASK, 0);
746
747 int_status &= ~CDNS_MCP_INT_SLAVE_MASK;
748 ret = IRQ_WAKE_THREAD;
749 }
750
751 cdns_writel(cdns, CDNS_MCP_INTSTAT, int_status);
752 return ret;
753 }
754 EXPORT_SYMBOL(sdw_cdns_irq);
755
756 /**
757 * sdw_cdns_thread() - Cadence irq thread handler
758 * @irq: irq number
759 * @dev_id: irq context
760 */
761 irqreturn_t sdw_cdns_thread(int irq, void *dev_id)
762 {
763 struct sdw_cdns *cdns = dev_id;
764 u32 slave0, slave1;
765
766 dev_dbg_ratelimited(cdns->dev, "Slave status change\n");
767
768 slave0 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT0);
769 slave1 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT1);
770
771 cdns_update_slave_status(cdns, slave0, slave1);
772 cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT0, slave0);
773 cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT1, slave1);
774
775 /* clear and unmask Slave interrupt now */
776 cdns_writel(cdns, CDNS_MCP_INTSTAT, CDNS_MCP_INT_SLAVE_MASK);
777 cdns_updatel(cdns, CDNS_MCP_INTMASK,
778 CDNS_MCP_INT_SLAVE_MASK, CDNS_MCP_INT_SLAVE_MASK);
779
780 return IRQ_HANDLED;
781 }
782 EXPORT_SYMBOL(sdw_cdns_thread);
783
784 /*
785 * init routines
786 */
787
788 /**
789 * sdw_cdns_exit_reset() - Program reset parameters and start bus operations
790 * @cdns: Cadence instance
791 */
792 int sdw_cdns_exit_reset(struct sdw_cdns *cdns)
793 {
794 /* program maximum length reset to be safe */
795 cdns_updatel(cdns, CDNS_MCP_CONTROL,
796 CDNS_MCP_CONTROL_RST_DELAY,
797 CDNS_MCP_CONTROL_RST_DELAY);
798
799 /* use hardware generated reset */
800 cdns_updatel(cdns, CDNS_MCP_CONTROL,
801 CDNS_MCP_CONTROL_HW_RST,
802 CDNS_MCP_CONTROL_HW_RST);
803
804 /* enable bus operations with clock and data */
805 cdns_updatel(cdns, CDNS_MCP_CONFIG,
806 CDNS_MCP_CONFIG_OP,
807 CDNS_MCP_CONFIG_OP_NORMAL);
808
809 /* commit changes */
810 return cdns_update_config(cdns);
811 }
812 EXPORT_SYMBOL(sdw_cdns_exit_reset);
813
814 /**
815 * sdw_cdns_enable_interrupt() - Enable SDW interrupts and update config
816 * @cdns: Cadence instance
817 */
818 int sdw_cdns_enable_interrupt(struct sdw_cdns *cdns, bool state)
819 {
820 u32 slave_intmask0 = 0;
821 u32 slave_intmask1 = 0;
822 u32 mask = 0;
823
824 if (!state)
825 goto update_masks;
826
827 slave_intmask0 = CDNS_MCP_SLAVE_INTMASK0_MASK;
828 slave_intmask1 = CDNS_MCP_SLAVE_INTMASK1_MASK;
829
830 /* enable detection of all slave state changes */
831 mask = CDNS_MCP_INT_SLAVE_MASK;
832
833 /* enable detection of bus issues */
834 mask |= CDNS_MCP_INT_CTRL_CLASH | CDNS_MCP_INT_DATA_CLASH |
835 CDNS_MCP_INT_PARITY;
836
837 /* no detection of port interrupts for now */
838
839 /* enable detection of RX fifo level */
840 mask |= CDNS_MCP_INT_RX_WL;
841
842 /*
843 * CDNS_MCP_INT_IRQ needs to be set otherwise all previous
844 * settings are irrelevant
845 */
846 mask |= CDNS_MCP_INT_IRQ;
847
848 if (interrupt_mask) /* parameter override */
849 mask = interrupt_mask;
850
851 update_masks:
852 cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK0, slave_intmask0);
853 cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK1, slave_intmask1);
854 cdns_writel(cdns, CDNS_MCP_INTMASK, mask);
855
856 /* commit changes */
857 return cdns_update_config(cdns);
858 }
859 EXPORT_SYMBOL(sdw_cdns_enable_interrupt);
860
861 static int cdns_allocate_pdi(struct sdw_cdns *cdns,
862 struct sdw_cdns_pdi **stream,
863 u32 num, u32 pdi_offset)
864 {
865 struct sdw_cdns_pdi *pdi;
866 int i;
867
868 if (!num)
869 return 0;
870
871 pdi = devm_kcalloc(cdns->dev, num, sizeof(*pdi), GFP_KERNEL);
872 if (!pdi)
873 return -ENOMEM;
874
875 for (i = 0; i < num; i++) {
876 pdi[i].num = i + pdi_offset;
877 }
878
879 *stream = pdi;
880 return 0;
881 }
882
883 /**
884 * sdw_cdns_pdi_init() - PDI initialization routine
885 *
886 * @cdns: Cadence instance
887 * @config: Stream configurations
888 */
889 int sdw_cdns_pdi_init(struct sdw_cdns *cdns,
890 struct sdw_cdns_stream_config config)
891 {
892 struct sdw_cdns_streams *stream;
893 int offset;
894 int ret;
895
896 cdns->pcm.num_bd = config.pcm_bd;
897 cdns->pcm.num_in = config.pcm_in;
898 cdns->pcm.num_out = config.pcm_out;
899 cdns->pdm.num_bd = config.pdm_bd;
900 cdns->pdm.num_in = config.pdm_in;
901 cdns->pdm.num_out = config.pdm_out;
902
903 /* Allocate PDIs for PCMs */
904 stream = &cdns->pcm;
905
906 /* we allocate PDI0 and PDI1 which are used for Bulk */
907 offset = 0;
908
909 ret = cdns_allocate_pdi(cdns, &stream->bd,
910 stream->num_bd, offset);
911 if (ret)
912 return ret;
913
914 offset += stream->num_bd;
915
916 ret = cdns_allocate_pdi(cdns, &stream->in,
917 stream->num_in, offset);
918 if (ret)
919 return ret;
920
921 offset += stream->num_in;
922
923 ret = cdns_allocate_pdi(cdns, &stream->out,
924 stream->num_out, offset);
925 if (ret)
926 return ret;
927
928 /* Update total number of PCM PDIs */
929 stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
930 cdns->num_ports = stream->num_pdi;
931
932 /* Allocate PDIs for PDMs */
933 stream = &cdns->pdm;
934 ret = cdns_allocate_pdi(cdns, &stream->bd,
935 stream->num_bd, offset);
936 if (ret)
937 return ret;
938
939 offset += stream->num_bd;
940
941 ret = cdns_allocate_pdi(cdns, &stream->in,
942 stream->num_in, offset);
943 if (ret)
944 return ret;
945
946 offset += stream->num_in;
947
948 ret = cdns_allocate_pdi(cdns, &stream->out,
949 stream->num_out, offset);
950
951 offset += stream->num_out;
952
953 if (ret)
954 return ret;
955
956 /* Update total number of PDM PDIs */
957 stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
958 cdns->num_ports += stream->num_pdi;
959
960 return 0;
961 }
962 EXPORT_SYMBOL(sdw_cdns_pdi_init);
963
964 static u32 cdns_set_initial_frame_shape(int n_rows, int n_cols)
965 {
966 u32 val;
967 int c;
968 int r;
969
970 r = sdw_find_row_index(n_rows);
971 c = sdw_find_col_index(n_cols) & CDNS_MCP_FRAME_SHAPE_COL_MASK;
972
973 val = (r << CDNS_MCP_FRAME_SHAPE_ROW_OFFSET) | c;
974
975 return val;
976 }
977
978 /**
979 * sdw_cdns_init() - Cadence initialization
980 * @cdns: Cadence instance
981 */
982 int sdw_cdns_init(struct sdw_cdns *cdns, bool clock_stop_exit)
983 {
984 struct sdw_bus *bus = &cdns->bus;
985 struct sdw_master_prop *prop = &bus->prop;
986 u32 val;
987 int divider;
988 int ret;
989
990 if (clock_stop_exit) {
991 ret = cdns_clear_bit(cdns, CDNS_MCP_CONTROL,
992 CDNS_MCP_CONTROL_CLK_STOP_CLR);
993 if (ret < 0) {
994 dev_err(cdns->dev, "Couldn't exit from clock stop\n");
995 return ret;
996 }
997 }
998
999 /* Set clock divider */
1000 divider = (prop->mclk_freq / prop->max_clk_freq) - 1;
1001
1002 cdns_updatel(cdns, CDNS_MCP_CLK_CTRL0,
1003 CDNS_MCP_CLK_MCLKD_MASK, divider);
1004 cdns_updatel(cdns, CDNS_MCP_CLK_CTRL1,
1005 CDNS_MCP_CLK_MCLKD_MASK, divider);
1006
1007 /*
1008 * Frame shape changes after initialization have to be done
1009 * with the bank switch mechanism
1010 */
1011 val = cdns_set_initial_frame_shape(prop->default_row,
1012 prop->default_col);
1013 cdns_writel(cdns, CDNS_MCP_FRAME_SHAPE_INIT, val);
1014
1015 /* Set SSP interval to default value */
1016 cdns_writel(cdns, CDNS_MCP_SSP_CTRL0, CDNS_DEFAULT_SSP_INTERVAL);
1017 cdns_writel(cdns, CDNS_MCP_SSP_CTRL1, CDNS_DEFAULT_SSP_INTERVAL);
1018
1019 /* flush command FIFOs */
1020 cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_RST,
1021 CDNS_MCP_CONTROL_CMD_RST);
1022
1023 /* Set cmd accept mode */
1024 cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_ACCEPT,
1025 CDNS_MCP_CONTROL_CMD_ACCEPT);
1026
1027 /* Configure mcp config */
1028 val = cdns_readl(cdns, CDNS_MCP_CONFIG);
1029
1030 /* Set Max cmd retry to 15 */
1031 val |= CDNS_MCP_CONFIG_MCMD_RETRY;
1032
1033 /* Set frame delay between PREQ and ping frame to 15 frames */
1034 val |= 0xF << SDW_REG_SHIFT(CDNS_MCP_CONFIG_MPREQ_DELAY);
1035
1036 /* Disable auto bus release */
1037 val &= ~CDNS_MCP_CONFIG_BUS_REL;
1038
1039 /* Disable sniffer mode */
1040 val &= ~CDNS_MCP_CONFIG_SNIFFER;
1041
1042 /* Set cmd mode for Tx and Rx cmds */
1043 val &= ~CDNS_MCP_CONFIG_CMD;
1044
1045 cdns_writel(cdns, CDNS_MCP_CONFIG, val);
1046
1047 /* commit changes */
1048 return cdns_update_config(cdns);
1049 }
1050 EXPORT_SYMBOL(sdw_cdns_init);
1051
1052 int cdns_bus_conf(struct sdw_bus *bus, struct sdw_bus_params *params)
1053 {
1054 struct sdw_master_prop *prop = &bus->prop;
1055 struct sdw_cdns *cdns = bus_to_cdns(bus);
1056 int mcp_clkctrl_off;
1057 int divider;
1058
1059 if (!params->curr_dr_freq) {
1060 dev_err(cdns->dev, "NULL curr_dr_freq\n");
1061 return -EINVAL;
1062 }
1063
1064 divider = prop->mclk_freq * SDW_DOUBLE_RATE_FACTOR /
1065 params->curr_dr_freq;
1066 divider--; /* divider is 1/(N+1) */
1067
1068 if (params->next_bank)
1069 mcp_clkctrl_off = CDNS_MCP_CLK_CTRL1;
1070 else
1071 mcp_clkctrl_off = CDNS_MCP_CLK_CTRL0;
1072
1073 cdns_updatel(cdns, mcp_clkctrl_off, CDNS_MCP_CLK_MCLKD_MASK, divider);
1074
1075 return 0;
1076 }
1077 EXPORT_SYMBOL(cdns_bus_conf);
1078
1079 static int cdns_port_params(struct sdw_bus *bus,
1080 struct sdw_port_params *p_params, unsigned int bank)
1081 {
1082 struct sdw_cdns *cdns = bus_to_cdns(bus);
1083 int dpn_config = 0, dpn_config_off;
1084
1085 if (bank)
1086 dpn_config_off = CDNS_DPN_B1_CONFIG(p_params->num);
1087 else
1088 dpn_config_off = CDNS_DPN_B0_CONFIG(p_params->num);
1089
1090 dpn_config = cdns_readl(cdns, dpn_config_off);
1091
1092 dpn_config |= ((p_params->bps - 1) <<
1093 SDW_REG_SHIFT(CDNS_DPN_CONFIG_WL));
1094 dpn_config |= (p_params->flow_mode <<
1095 SDW_REG_SHIFT(CDNS_DPN_CONFIG_PORT_FLOW));
1096 dpn_config |= (p_params->data_mode <<
1097 SDW_REG_SHIFT(CDNS_DPN_CONFIG_PORT_DAT));
1098
1099 cdns_writel(cdns, dpn_config_off, dpn_config);
1100
1101 return 0;
1102 }
1103
1104 static int cdns_transport_params(struct sdw_bus *bus,
1105 struct sdw_transport_params *t_params,
1106 enum sdw_reg_bank bank)
1107 {
1108 struct sdw_cdns *cdns = bus_to_cdns(bus);
1109 int dpn_offsetctrl = 0, dpn_offsetctrl_off;
1110 int dpn_config = 0, dpn_config_off;
1111 int dpn_hctrl = 0, dpn_hctrl_off;
1112 int num = t_params->port_num;
1113 int dpn_samplectrl_off;
1114
1115 /*
1116 * Note: Only full data port is supported on the Master side for
1117 * both PCM and PDM ports.
1118 */
1119
1120 if (bank) {
1121 dpn_config_off = CDNS_DPN_B1_CONFIG(num);
1122 dpn_samplectrl_off = CDNS_DPN_B1_SAMPLE_CTRL(num);
1123 dpn_hctrl_off = CDNS_DPN_B1_HCTRL(num);
1124 dpn_offsetctrl_off = CDNS_DPN_B1_OFFSET_CTRL(num);
1125 } else {
1126 dpn_config_off = CDNS_DPN_B0_CONFIG(num);
1127 dpn_samplectrl_off = CDNS_DPN_B0_SAMPLE_CTRL(num);
1128 dpn_hctrl_off = CDNS_DPN_B0_HCTRL(num);
1129 dpn_offsetctrl_off = CDNS_DPN_B0_OFFSET_CTRL(num);
1130 }
1131
1132 dpn_config = cdns_readl(cdns, dpn_config_off);
1133
1134 dpn_config |= (t_params->blk_grp_ctrl <<
1135 SDW_REG_SHIFT(CDNS_DPN_CONFIG_BGC));
1136 dpn_config |= (t_params->blk_pkg_mode <<
1137 SDW_REG_SHIFT(CDNS_DPN_CONFIG_BPM));
1138 cdns_writel(cdns, dpn_config_off, dpn_config);
1139
1140 dpn_offsetctrl |= (t_params->offset1 <<
1141 SDW_REG_SHIFT(CDNS_DPN_OFFSET_CTRL_1));
1142 dpn_offsetctrl |= (t_params->offset2 <<
1143 SDW_REG_SHIFT(CDNS_DPN_OFFSET_CTRL_2));
1144 cdns_writel(cdns, dpn_offsetctrl_off, dpn_offsetctrl);
1145
1146 dpn_hctrl |= (t_params->hstart <<
1147 SDW_REG_SHIFT(CDNS_DPN_HCTRL_HSTART));
1148 dpn_hctrl |= (t_params->hstop << SDW_REG_SHIFT(CDNS_DPN_HCTRL_HSTOP));
1149 dpn_hctrl |= (t_params->lane_ctrl <<
1150 SDW_REG_SHIFT(CDNS_DPN_HCTRL_LCTRL));
1151
1152 cdns_writel(cdns, dpn_hctrl_off, dpn_hctrl);
1153 cdns_writel(cdns, dpn_samplectrl_off, (t_params->sample_interval - 1));
1154
1155 return 0;
1156 }
1157
1158 static int cdns_port_enable(struct sdw_bus *bus,
1159 struct sdw_enable_ch *enable_ch, unsigned int bank)
1160 {
1161 struct sdw_cdns *cdns = bus_to_cdns(bus);
1162 int dpn_chnen_off, ch_mask;
1163
1164 if (bank)
1165 dpn_chnen_off = CDNS_DPN_B1_CH_EN(enable_ch->port_num);
1166 else
1167 dpn_chnen_off = CDNS_DPN_B0_CH_EN(enable_ch->port_num);
1168
1169 ch_mask = enable_ch->ch_mask * enable_ch->enable;
1170 cdns_writel(cdns, dpn_chnen_off, ch_mask);
1171
1172 return 0;
1173 }
1174
1175 static const struct sdw_master_port_ops cdns_port_ops = {
1176 .dpn_set_port_params = cdns_port_params,
1177 .dpn_set_port_transport_params = cdns_transport_params,
1178 .dpn_port_enable_ch = cdns_port_enable,
1179 };
1180
1181 /**
1182 * sdw_cdns_probe() - Cadence probe routine
1183 * @cdns: Cadence instance
1184 */
1185 int sdw_cdns_probe(struct sdw_cdns *cdns)
1186 {
1187 init_completion(&cdns->tx_complete);
1188 cdns->bus.port_ops = &cdns_port_ops;
1189
1190 return 0;
1191 }
1192 EXPORT_SYMBOL(sdw_cdns_probe);
1193
1194 int cdns_set_sdw_stream(struct snd_soc_dai *dai,
1195 void *stream, bool pcm, int direction)
1196 {
1197 struct sdw_cdns *cdns = snd_soc_dai_get_drvdata(dai);
1198 struct sdw_cdns_dma_data *dma;
1199
1200 dma = kzalloc(sizeof(*dma), GFP_KERNEL);
1201 if (!dma)
1202 return -ENOMEM;
1203
1204 if (pcm)
1205 dma->stream_type = SDW_STREAM_PCM;
1206 else
1207 dma->stream_type = SDW_STREAM_PDM;
1208
1209 dma->bus = &cdns->bus;
1210 dma->link_id = cdns->instance;
1211
1212 dma->stream = stream;
1213
1214 if (direction == SNDRV_PCM_STREAM_PLAYBACK)
1215 dai->playback_dma_data = dma;
1216 else
1217 dai->capture_dma_data = dma;
1218
1219 return 0;
1220 }
1221 EXPORT_SYMBOL(cdns_set_sdw_stream);
1222
1223 /**
1224 * cdns_find_pdi() - Find a free PDI
1225 *
1226 * @cdns: Cadence instance
1227 * @num: Number of PDIs
1228 * @pdi: PDI instances
1229 *
1230 * Find a PDI for a given PDI array. The PDI num and dai_id are
1231 * expected to match, return NULL otherwise.
1232 */
1233 static struct sdw_cdns_pdi *cdns_find_pdi(struct sdw_cdns *cdns,
1234 unsigned int offset,
1235 unsigned int num,
1236 struct sdw_cdns_pdi *pdi,
1237 int dai_id)
1238 {
1239 int i;
1240
1241 for (i = offset; i < offset + num; i++)
1242 if (pdi[i].num == dai_id)
1243 return &pdi[i];
1244
1245 return NULL;
1246 }
1247
1248 /**
1249 * sdw_cdns_config_stream: Configure a stream
1250 *
1251 * @cdns: Cadence instance
1252 * @ch: Channel count
1253 * @dir: Data direction
1254 * @pdi: PDI to be used
1255 */
1256 void sdw_cdns_config_stream(struct sdw_cdns *cdns,
1257 u32 ch, u32 dir, struct sdw_cdns_pdi *pdi)
1258 {
1259 u32 offset, val = 0;
1260
1261 if (dir == SDW_DATA_DIR_RX)
1262 val = CDNS_PORTCTRL_DIRN;
1263
1264 offset = CDNS_PORTCTRL + pdi->num * CDNS_PORT_OFFSET;
1265 cdns_updatel(cdns, offset, CDNS_PORTCTRL_DIRN, val);
1266
1267 val = pdi->num;
1268 val |= ((1 << ch) - 1) << SDW_REG_SHIFT(CDNS_PDI_CONFIG_CHANNEL);
1269 cdns_writel(cdns, CDNS_PDI_CONFIG(pdi->num), val);
1270 }
1271 EXPORT_SYMBOL(sdw_cdns_config_stream);
1272
1273 /**
1274 * sdw_cdns_alloc_pdi() - Allocate a PDI
1275 *
1276 * @cdns: Cadence instance
1277 * @stream: Stream to be allocated
1278 * @ch: Channel count
1279 * @dir: Data direction
1280 */
1281 struct sdw_cdns_pdi *sdw_cdns_alloc_pdi(struct sdw_cdns *cdns,
1282 struct sdw_cdns_streams *stream,
1283 u32 ch, u32 dir, int dai_id)
1284 {
1285 struct sdw_cdns_pdi *pdi = NULL;
1286
1287 if (dir == SDW_DATA_DIR_RX)
1288 pdi = cdns_find_pdi(cdns, 0, stream->num_in, stream->in,
1289 dai_id);
1290 else
1291 pdi = cdns_find_pdi(cdns, 0, stream->num_out, stream->out,
1292 dai_id);
1293
1294 /* check if we found a PDI, else find in bi-directional */
1295 if (!pdi)
1296 pdi = cdns_find_pdi(cdns, 2, stream->num_bd, stream->bd,
1297 dai_id);
1298
1299 if (pdi) {
1300 pdi->l_ch_num = 0;
1301 pdi->h_ch_num = ch - 1;
1302 pdi->dir = dir;
1303 pdi->ch_count = ch;
1304 }
1305
1306 return pdi;
1307 }
1308 EXPORT_SYMBOL(sdw_cdns_alloc_pdi);
1309
1310 MODULE_LICENSE("Dual BSD/GPL");
1311 MODULE_DESCRIPTION("Cadence Soundwire Library");
Linux with added FPC-III support