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