GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / soundwire / cadence_master.c
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>
16 #include <sound/pcm_params.h>
17 #include <sound/soc.h>
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_MCP_SLAVE_STAT                     0x50
85 #define CDNS_MCP_SLAVE_STAT_MASK                GENMASK(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(31, 0)
100 #define CDNS_MCP_SLAVE_INTMASK1_MASK            GENMASK(15, 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  */
186 static inline u32 cdns_readl(struct sdw_cdns *cdns, int offset)
187 {
188         return readl(cdns->registers + offset);
189 }
190
191 static inline void cdns_writel(struct sdw_cdns *cdns, int offset, u32 value)
192 {
193         writel(value, cdns->registers + offset);
194 }
195
196 static 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
206 static 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
226 /*
227  * IO Calls
228  */
229 static 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
264 static 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
309 static 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
372 static 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
401 enum sdw_command_response
402 cdns_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
424 exit:
425         return ret;
426 }
427 EXPORT_SYMBOL(cdns_xfer_msg);
428
429 enum sdw_command_response
430 cdns_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 }
449 EXPORT_SYMBOL(cdns_xfer_msg_defer);
450
451 enum sdw_command_response
452 cdns_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 }
463 EXPORT_SYMBOL(cdns_reset_page_addr);
464
465 /*
466  * IRQ handling
467  */
468
469 static 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
485 static 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  */
549 irqreturn_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
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
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 }
604 EXPORT_SYMBOL(sdw_cdns_irq);
605
606 /**
607  * sdw_cdns_thread() - Cadence irq thread handler
608  * @irq: irq number
609  * @dev_id: irq context
610  */
611 irqreturn_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 }
632 EXPORT_SYMBOL(sdw_cdns_thread);
633
634 /*
635  * init routines
636  */
637 static 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  */
660 int 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 }
672 EXPORT_SYMBOL(sdw_cdns_enable_interrupt);
673
674 static 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  */
703 int 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 }
786 EXPORT_SYMBOL(sdw_cdns_pdi_init);
787
788 /**
789  * sdw_cdns_init() - Cadence initialization
790  * @cdns: Cadence instance
791  */
792 int 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 }
847 EXPORT_SYMBOL(sdw_cdns_init);
848
849 int 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 }
873 EXPORT_SYMBOL(cdns_bus_conf);
874
875 static 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
900 static 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
954 static 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
971 static 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
977 /**
978  * sdw_cdns_probe() - Cadence probe routine
979  * @cdns: Cadence instance
980  */
981 int sdw_cdns_probe(struct sdw_cdns *cdns)
982 {
983         init_completion(&cdns->tx_complete);
984         cdns->bus.port_ops = &cdns_port_ops;
985
986         return 0;
987 }
988 EXPORT_SYMBOL(sdw_cdns_probe);
989
990 int 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 }
1017 EXPORT_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  */
1028 static 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  */
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)
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 }
1068 EXPORT_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  */
1078 static 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  */
1113 int 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 }
1130 EXPORT_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  */
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)
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 }
1167 EXPORT_SYMBOL(sdw_cdns_alloc_stream);
1168
1169 void 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 }
1181 EXPORT_SYMBOL(sdw_cdns_shutdown);
1182
1183 MODULE_LICENSE("Dual BSD/GPL");
1184 MODULE_DESCRIPTION("Cadence Soundwire Library");