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");