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/io.h>
  13 #include <linux/module.h>
  14 #include <linux/mod_devicetable.h>
  15 #include <linux/soundwire/sdw_registers.h>
  16 #include <linux/soundwire/sdw.h>
  17 #include <sound/pcm_params.h>
  18 #include <sound/soc.h>
  19 #include "bus.h"
  20 #include "cadence_master.h"
  21
  22 #define CDNS_MCP_CONFIG                         0x0
  23
  24 #define CDNS_MCP_CONFIG_MCMD_RETRY              GENMASK(27, 24)
  25 #define CDNS_MCP_CONFIG_MPREQ_DELAY             GENMASK(20, 16)
  26 #define CDNS_MCP_CONFIG_MMASTER                 BIT(7)
  27 #define CDNS_MCP_CONFIG_BUS_REL                 BIT(6)
  28 #define CDNS_MCP_CONFIG_SNIFFER                 BIT(5)
  29 #define CDNS_MCP_CONFIG_SSPMOD                  BIT(4)
  30 #define CDNS_MCP_CONFIG_CMD                     BIT(3)
  31 #define CDNS_MCP_CONFIG_OP                      GENMASK(2, 0)
  32 #define CDNS_MCP_CONFIG_OP_NORMAL               0
  33
  34 #define CDNS_MCP_CONTROL                        0x4
  35
  36 #define CDNS_MCP_CONTROL_RST_DELAY              GENMASK(10, 8)
  37 #define CDNS_MCP_CONTROL_CMD_RST                BIT(7)
  38 #define CDNS_MCP_CONTROL_SOFT_RST               BIT(6)
  39 #define CDNS_MCP_CONTROL_SW_RST                 BIT(5)
  40 #define CDNS_MCP_CONTROL_HW_RST                 BIT(4)
  41 #define CDNS_MCP_CONTROL_CLK_PAUSE              BIT(3)
  42 #define CDNS_MCP_CONTROL_CLK_STOP_CLR           BIT(2)
  43 #define CDNS_MCP_CONTROL_CMD_ACCEPT             BIT(1)
  44 #define CDNS_MCP_CONTROL_BLOCK_WAKEUP           BIT(0)
  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
 230 cdns_fill_msg_resp(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_ratelimited(cdns->dev, "Msg Ack not received\n");
 241                         if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
 242                                 nack = 1;
 243                                 dev_err_ratelimited(cdns->dev, "Msg NACK received\n");
 244                         }
 245                 }
 246         }
 247
 248         if (nack) {
 249                 dev_err_ratelimited(cdns->dev, "Msg NACKed for Slave %d\n", msg->dev_num);
 250                 return SDW_CMD_FAIL;
 251         } else if (no_ack) {
 252                 dev_dbg_ratelimited(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
 310 cdns_program_scp_addr(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\n");
 351                         if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
 352                                 nack = 1;
 353                                 dev_err(cdns->dev, "Program SCP NACK received\n");
 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_ratelimited(cdns->dev,
 361                                     "SCP_addrpage NACKed for Slave %d\n", msg->dev_num);
 362                 return SDW_CMD_FAIL;
 363         } else if (no_ack) {
 364                 dev_dbg_ratelimited(cdns->dev,
 365                                     "SCP_addrpage ignored for Slave %d\n", 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;
 491         u32 mask;
 492         int i, set_status;
 493
 494         /* combine the two status */
 495         slave = ((u64)slave1 << 32) | slave0;
 496         memset(status, 0, sizeof(status));
 497
 498         for (i = 0; i <= SDW_MAX_DEVICES; i++) {
 499                 mask = (slave >> (i * CDNS_MCP_SLAVE_STATUS_NUM)) &
 500                                 CDNS_MCP_SLAVE_STATUS_BITS;
 501                 if (!mask)
 502                         continue;
 503
 504                 is_slave = true;
 505                 set_status = 0;
 506
 507                 if (mask & CDNS_MCP_SLAVE_INTSTAT_RESERVED) {
 508                         status[i] = SDW_SLAVE_RESERVED;
 509                         set_status++;
 510                 }
 511
 512                 if (mask & CDNS_MCP_SLAVE_INTSTAT_ATTACHED) {
 513                         status[i] = SDW_SLAVE_ATTACHED;
 514                         set_status++;
 515                 }
 516
 517                 if (mask & CDNS_MCP_SLAVE_INTSTAT_ALERT) {
 518                         status[i] = SDW_SLAVE_ALERT;
 519                         set_status++;
 520                 }
 521
 522                 if (mask & CDNS_MCP_SLAVE_INTSTAT_NPRESENT) {
 523                         status[i] = SDW_SLAVE_UNATTACHED;
 524                         set_status++;
 525                 }
 526
 527                 /* first check if Slave reported multiple status */
 528                 if (set_status > 1) {
 529                         dev_warn_ratelimited(cdns->dev,
 530                                              "Slave reported multiple Status: %d\n",
 531                                              mask);
 532                         /*
 533                          * TODO: we need to reread the status here by
 534                          * issuing a PING cmd
 535                          */
 536                 }
 537         }
 538
 539         if (is_slave)
 540                 return sdw_handle_slave_status(&cdns->bus, status);
 541
 542         return 0;
 543 }
 544
 545 /**
 546  * sdw_cdns_irq() - Cadence interrupt handler
 547  * @irq: irq number
 548  * @dev_id: irq context
 549  */
 550 irqreturn_t sdw_cdns_irq(int irq, void *dev_id)
 551 {
 552         struct sdw_cdns *cdns = dev_id;
 553         u32 int_status;
 554         int ret = IRQ_HANDLED;
 555
 556         /* Check if the link is up */
 557         if (!cdns->link_up)
 558                 return IRQ_NONE;
 559
 560         int_status = cdns_readl(cdns, CDNS_MCP_INTSTAT);
 561
 562         if (!(int_status & CDNS_MCP_INT_IRQ))
 563                 return IRQ_NONE;
 564
 565         if (int_status & CDNS_MCP_INT_RX_WL) {
 566                 cdns_read_response(cdns);
 567
 568                 if (cdns->defer) {
 569                         cdns_fill_msg_resp(cdns, cdns->defer->msg,
 570                                            cdns->defer->length, 0);
 571                         complete(&cdns->defer->complete);
 572                         cdns->defer = NULL;
 573                 } else {
 574                         complete(&cdns->tx_complete);
 575                 }
 576         }
 577
 578         if (int_status & CDNS_MCP_INT_CTRL_CLASH) {
 579                 /* Slave is driving bit slot during control word */
 580                 dev_err_ratelimited(cdns->dev, "Bus clash for control word\n");
 581                 int_status |= CDNS_MCP_INT_CTRL_CLASH;
 582         }
 583
 584         if (int_status & CDNS_MCP_INT_DATA_CLASH) {
 585                 /*
 586                  * Multiple slaves trying to drive bit slot, or issue with
 587                  * ownership of data bits or Slave gone bonkers
 588                  */
 589                 dev_err_ratelimited(cdns->dev, "Bus clash for data word\n");
 590                 int_status |= CDNS_MCP_INT_DATA_CLASH;
 591         }
 592
 593         if (int_status & CDNS_MCP_INT_SLAVE_MASK) {
 594                 /* Mask the Slave interrupt and wake thread */
 595                 cdns_updatel(cdns, CDNS_MCP_INTMASK,
 596                              CDNS_MCP_INT_SLAVE_MASK, 0);
 597
 598                 int_status &= ~CDNS_MCP_INT_SLAVE_MASK;
 599                 ret = IRQ_WAKE_THREAD;
 600         }
 601
 602         cdns_writel(cdns, CDNS_MCP_INTSTAT, int_status);
 603         return ret;
 604 }
 605 EXPORT_SYMBOL(sdw_cdns_irq);
 606
 607 /**
 608  * sdw_cdns_thread() - Cadence irq thread handler
 609  * @irq: irq number
 610  * @dev_id: irq context
 611  */
 612 irqreturn_t sdw_cdns_thread(int irq, void *dev_id)
 613 {
 614         struct sdw_cdns *cdns = dev_id;
 615         u32 slave0, slave1;
 616
 617         dev_dbg_ratelimited(cdns->dev, "Slave status change\n");
 618
 619         slave0 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT0);
 620         slave1 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT1);
 621
 622         cdns_update_slave_status(cdns, slave0, slave1);
 623         cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT0, slave0);
 624         cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT1, slave1);
 625
 626         /* clear and unmask Slave interrupt now */
 627         cdns_writel(cdns, CDNS_MCP_INTSTAT, CDNS_MCP_INT_SLAVE_MASK);
 628         cdns_updatel(cdns, CDNS_MCP_INTMASK,
 629                      CDNS_MCP_INT_SLAVE_MASK, CDNS_MCP_INT_SLAVE_MASK);
 630
 631         return IRQ_HANDLED;
 632 }
 633 EXPORT_SYMBOL(sdw_cdns_thread);
 634
 635 /*
 636  * init routines
 637  */
 638 static int _cdns_enable_interrupt(struct sdw_cdns *cdns)
 639 {
 640         u32 mask;
 641
 642         cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK0,
 643                     CDNS_MCP_SLAVE_INTMASK0_MASK);
 644         cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK1,
 645                     CDNS_MCP_SLAVE_INTMASK1_MASK);
 646
 647         mask = CDNS_MCP_INT_SLAVE_RSVD | CDNS_MCP_INT_SLAVE_ALERT |
 648                 CDNS_MCP_INT_SLAVE_ATTACH | CDNS_MCP_INT_SLAVE_NATTACH |
 649                 CDNS_MCP_INT_CTRL_CLASH | CDNS_MCP_INT_DATA_CLASH |
 650                 CDNS_MCP_INT_RX_WL | CDNS_MCP_INT_IRQ | CDNS_MCP_INT_DPINT;
 651
 652         cdns_writel(cdns, CDNS_MCP_INTMASK, mask);
 653
 654         return 0;
 655 }
 656
 657 /**
 658  * sdw_cdns_enable_interrupt() - Enable SDW interrupts and update config
 659  * @cdns: Cadence instance
 660  */
 661 int sdw_cdns_enable_interrupt(struct sdw_cdns *cdns)
 662 {
 663         int ret;
 664
 665         _cdns_enable_interrupt(cdns);
 666         ret = cdns_clear_bit(cdns, CDNS_MCP_CONFIG_UPDATE,
 667                              CDNS_MCP_CONFIG_UPDATE_BIT);
 668         if (ret < 0)
 669                 dev_err(cdns->dev, "Config update timedout\n");
 670
 671         return ret;
 672 }
 673 EXPORT_SYMBOL(sdw_cdns_enable_interrupt);
 674
 675 static int cdns_allocate_pdi(struct sdw_cdns *cdns,
 676                              struct sdw_cdns_pdi **stream,
 677                              u32 num, u32 pdi_offset)
 678 {
 679         struct sdw_cdns_pdi *pdi;
 680         int i;
 681
 682         if (!num)
 683                 return 0;
 684
 685         pdi = devm_kcalloc(cdns->dev, num, sizeof(*pdi), GFP_KERNEL);
 686         if (!pdi)
 687                 return -ENOMEM;
 688
 689         for (i = 0; i < num; i++) {
 690                 pdi[i].num = i + pdi_offset;
 691                 pdi[i].assigned = false;
 692         }
 693
 694         *stream = pdi;
 695         return 0;
 696 }
 697
 698 /**
 699  * sdw_cdns_pdi_init() - PDI initialization routine
 700  *
 701  * @cdns: Cadence instance
 702  * @config: Stream configurations
 703  */
 704 int sdw_cdns_pdi_init(struct sdw_cdns *cdns,
 705                       struct sdw_cdns_stream_config config)
 706 {
 707         struct sdw_cdns_streams *stream;
 708         int offset, i, ret;
 709
 710         cdns->pcm.num_bd = config.pcm_bd;
 711         cdns->pcm.num_in = config.pcm_in;
 712         cdns->pcm.num_out = config.pcm_out;
 713         cdns->pdm.num_bd = config.pdm_bd;
 714         cdns->pdm.num_in = config.pdm_in;
 715         cdns->pdm.num_out = config.pdm_out;
 716
 717         /* Allocate PDIs for PCMs */
 718         stream = &cdns->pcm;
 719
 720         /* First two PDIs are reserved for bulk transfers */
 721         if (stream->num_bd < CDNS_PCM_PDI_OFFSET)
 722                 return -EINVAL;
 723         stream->num_bd -= CDNS_PCM_PDI_OFFSET;
 724         offset = CDNS_PCM_PDI_OFFSET;
 725
 726         ret = cdns_allocate_pdi(cdns, &stream->bd,
 727                                 stream->num_bd, offset);
 728         if (ret)
 729                 return ret;
 730
 731         offset += stream->num_bd;
 732
 733         ret = cdns_allocate_pdi(cdns, &stream->in,
 734                                 stream->num_in, offset);
 735         if (ret)
 736                 return ret;
 737
 738         offset += stream->num_in;
 739
 740         ret = cdns_allocate_pdi(cdns, &stream->out,
 741                                 stream->num_out, offset);
 742         if (ret)
 743                 return ret;
 744
 745         /* Update total number of PCM PDIs */
 746         stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
 747         cdns->num_ports = stream->num_pdi;
 748
 749         /* Allocate PDIs for PDMs */
 750         stream = &cdns->pdm;
 751         offset = CDNS_PDM_PDI_OFFSET;
 752         ret = cdns_allocate_pdi(cdns, &stream->bd,
 753                                 stream->num_bd, offset);
 754         if (ret)
 755                 return ret;
 756
 757         offset += stream->num_bd;
 758
 759         ret = cdns_allocate_pdi(cdns, &stream->in,
 760                                 stream->num_in, offset);
 761         if (ret)
 762                 return ret;
 763
 764         offset += stream->num_in;
 765
 766         ret = cdns_allocate_pdi(cdns, &stream->out,
 767                                 stream->num_out, offset);
 768         if (ret)
 769                 return ret;
 770
 771         /* Update total number of PDM PDIs */
 772         stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
 773         cdns->num_ports += stream->num_pdi;
 774
 775         cdns->ports = devm_kcalloc(cdns->dev, cdns->num_ports,
 776                                    sizeof(*cdns->ports), GFP_KERNEL);
 777         if (!cdns->ports) {
 778                 ret = -ENOMEM;
 779                 return ret;
 780         }
 781
 782         for (i = 0; i < cdns->num_ports; i++) {
 783                 cdns->ports[i].assigned = false;
 784                 cdns->ports[i].num = i + 1; /* Port 0 reserved for bulk */
 785         }
 786
 787         return 0;
 788 }
 789 EXPORT_SYMBOL(sdw_cdns_pdi_init);
 790
 791 /**
 792  * sdw_cdns_init() - Cadence initialization
 793  * @cdns: Cadence instance
 794  */
 795 int sdw_cdns_init(struct sdw_cdns *cdns)
 796 {
 797         u32 val;
 798         int ret;
 799
 800         /* Exit clock stop */
 801         ret = cdns_clear_bit(cdns, CDNS_MCP_CONTROL,
 802                              CDNS_MCP_CONTROL_CLK_STOP_CLR);
 803         if (ret < 0) {
 804                 dev_err(cdns->dev, "Couldn't exit from clock stop\n");
 805                 return ret;
 806         }
 807
 808         /* Set clock divider */
 809         val = cdns_readl(cdns, CDNS_MCP_CLK_CTRL0);
 810         val |= CDNS_DEFAULT_CLK_DIVIDER;
 811         cdns_writel(cdns, CDNS_MCP_CLK_CTRL0, val);
 812
 813         /* Set the default frame shape */
 814         cdns_writel(cdns, CDNS_MCP_FRAME_SHAPE_INIT, CDNS_DEFAULT_FRAME_SHAPE);
 815
 816         /* Set SSP interval to default value */
 817         cdns_writel(cdns, CDNS_MCP_SSP_CTRL0, CDNS_DEFAULT_SSP_INTERVAL);
 818         cdns_writel(cdns, CDNS_MCP_SSP_CTRL1, CDNS_DEFAULT_SSP_INTERVAL);
 819
 820         /* Set cmd accept mode */
 821         cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_ACCEPT,
 822                      CDNS_MCP_CONTROL_CMD_ACCEPT);
 823
 824         /* Configure mcp config */
 825         val = cdns_readl(cdns, CDNS_MCP_CONFIG);
 826
 827         /* Set Max cmd retry to 15 */
 828         val |= CDNS_MCP_CONFIG_MCMD_RETRY;
 829
 830         /* Set frame delay between PREQ and ping frame to 15 frames */
 831         val |= 0xF << SDW_REG_SHIFT(CDNS_MCP_CONFIG_MPREQ_DELAY);
 832
 833         /* Disable auto bus release */
 834         val &= ~CDNS_MCP_CONFIG_BUS_REL;
 835
 836         /* Disable sniffer mode */
 837         val &= ~CDNS_MCP_CONFIG_SNIFFER;
 838
 839         /* Set cmd mode for Tx and Rx cmds */
 840         val &= ~CDNS_MCP_CONFIG_CMD;
 841
 842         /* Set operation to normal */
 843         val &= ~CDNS_MCP_CONFIG_OP;
 844         val |= CDNS_MCP_CONFIG_OP_NORMAL;
 845
 846         cdns_writel(cdns, CDNS_MCP_CONFIG, val);
 847
 848         return 0;
 849 }
 850 EXPORT_SYMBOL(sdw_cdns_init);
 851
 852 int cdns_bus_conf(struct sdw_bus *bus, struct sdw_bus_params *params)
 853 {
 854         struct sdw_cdns *cdns = bus_to_cdns(bus);
 855         int mcp_clkctrl_off, mcp_clkctrl;
 856         int divider;
 857
 858         if (!params->curr_dr_freq) {
 859                 dev_err(cdns->dev, "NULL curr_dr_freq\n");
 860                 return -EINVAL;
 861         }
 862
 863         divider = (params->max_dr_freq / params->curr_dr_freq) - 1;
 864
 865         if (params->next_bank)
 866                 mcp_clkctrl_off = CDNS_MCP_CLK_CTRL1;
 867         else
 868                 mcp_clkctrl_off = CDNS_MCP_CLK_CTRL0;
 869
 870         mcp_clkctrl = cdns_readl(cdns, mcp_clkctrl_off);
 871         mcp_clkctrl |= divider;
 872         cdns_writel(cdns, mcp_clkctrl_off, mcp_clkctrl);
 873
 874         return 0;
 875 }
 876 EXPORT_SYMBOL(cdns_bus_conf);
 877
 878 static int cdns_port_params(struct sdw_bus *bus,
 879                             struct sdw_port_params *p_params, unsigned int bank)
 880 {
 881         struct sdw_cdns *cdns = bus_to_cdns(bus);
 882         int dpn_config = 0, dpn_config_off;
 883
 884         if (bank)
 885                 dpn_config_off = CDNS_DPN_B1_CONFIG(p_params->num);
 886         else
 887                 dpn_config_off = CDNS_DPN_B0_CONFIG(p_params->num);
 888
 889         dpn_config = cdns_readl(cdns, dpn_config_off);
 890
 891         dpn_config |= ((p_params->bps - 1) <<
 892                                 SDW_REG_SHIFT(CDNS_DPN_CONFIG_WL));
 893         dpn_config |= (p_params->flow_mode <<
 894                                 SDW_REG_SHIFT(CDNS_DPN_CONFIG_PORT_FLOW));
 895         dpn_config |= (p_params->data_mode <<
 896                                 SDW_REG_SHIFT(CDNS_DPN_CONFIG_PORT_DAT));
 897
 898         cdns_writel(cdns, dpn_config_off, dpn_config);
 899
 900         return 0;
 901 }
 902
 903 static int cdns_transport_params(struct sdw_bus *bus,
 904                                  struct sdw_transport_params *t_params,
 905                                  enum sdw_reg_bank bank)
 906 {
 907         struct sdw_cdns *cdns = bus_to_cdns(bus);
 908         int dpn_offsetctrl = 0, dpn_offsetctrl_off;
 909         int dpn_config = 0, dpn_config_off;
 910         int dpn_hctrl = 0, dpn_hctrl_off;
 911         int num = t_params->port_num;
 912         int dpn_samplectrl_off;
 913
 914         /*
 915          * Note: Only full data port is supported on the Master side for
 916          * both PCM and PDM ports.
 917          */
 918
 919         if (bank) {
 920                 dpn_config_off = CDNS_DPN_B1_CONFIG(num);
 921                 dpn_samplectrl_off = CDNS_DPN_B1_SAMPLE_CTRL(num);
 922                 dpn_hctrl_off = CDNS_DPN_B1_HCTRL(num);
 923                 dpn_offsetctrl_off = CDNS_DPN_B1_OFFSET_CTRL(num);
 924         } else {
 925                 dpn_config_off = CDNS_DPN_B0_CONFIG(num);
 926                 dpn_samplectrl_off = CDNS_DPN_B0_SAMPLE_CTRL(num);
 927                 dpn_hctrl_off = CDNS_DPN_B0_HCTRL(num);
 928                 dpn_offsetctrl_off = CDNS_DPN_B0_OFFSET_CTRL(num);
 929         }
 930
 931         dpn_config = cdns_readl(cdns, dpn_config_off);
 932
 933         dpn_config |= (t_params->blk_grp_ctrl <<
 934                                 SDW_REG_SHIFT(CDNS_DPN_CONFIG_BGC));
 935         dpn_config |= (t_params->blk_pkg_mode <<
 936                                 SDW_REG_SHIFT(CDNS_DPN_CONFIG_BPM));
 937         cdns_writel(cdns, dpn_config_off, dpn_config);
 938
 939         dpn_offsetctrl |= (t_params->offset1 <<
 940                                 SDW_REG_SHIFT(CDNS_DPN_OFFSET_CTRL_1));
 941         dpn_offsetctrl |= (t_params->offset2 <<
 942                                 SDW_REG_SHIFT(CDNS_DPN_OFFSET_CTRL_2));
 943         cdns_writel(cdns, dpn_offsetctrl_off,  dpn_offsetctrl);
 944
 945         dpn_hctrl |= (t_params->hstart <<
 946                                 SDW_REG_SHIFT(CDNS_DPN_HCTRL_HSTART));
 947         dpn_hctrl |= (t_params->hstop << SDW_REG_SHIFT(CDNS_DPN_HCTRL_HSTOP));
 948         dpn_hctrl |= (t_params->lane_ctrl <<
 949                                 SDW_REG_SHIFT(CDNS_DPN_HCTRL_LCTRL));
 950
 951         cdns_writel(cdns, dpn_hctrl_off, dpn_hctrl);
 952         cdns_writel(cdns, dpn_samplectrl_off, (t_params->sample_interval - 1));
 953
 954         return 0;
 955 }
 956
 957 static int cdns_port_enable(struct sdw_bus *bus,
 958                             struct sdw_enable_ch *enable_ch, unsigned int bank)
 959 {
 960         struct sdw_cdns *cdns = bus_to_cdns(bus);
 961         int dpn_chnen_off, ch_mask;
 962
 963         if (bank)
 964                 dpn_chnen_off = CDNS_DPN_B1_CH_EN(enable_ch->port_num);
 965         else
 966                 dpn_chnen_off = CDNS_DPN_B0_CH_EN(enable_ch->port_num);
 967
 968         ch_mask = enable_ch->ch_mask * enable_ch->enable;
 969         cdns_writel(cdns, dpn_chnen_off, ch_mask);
 970
 971         return 0;
 972 }
 973
 974 static const struct sdw_master_port_ops cdns_port_ops = {
 975         .dpn_set_port_params = cdns_port_params,
 976         .dpn_set_port_transport_params = cdns_transport_params,
 977         .dpn_port_enable_ch = cdns_port_enable,
 978 };
 979
 980 /**
 981  * sdw_cdns_probe() - Cadence probe routine
 982  * @cdns: Cadence instance
 983  */
 984 int sdw_cdns_probe(struct sdw_cdns *cdns)
 985 {
 986         init_completion(&cdns->tx_complete);
 987         cdns->bus.port_ops = &cdns_port_ops;
 988
 989         return 0;
 990 }
 991 EXPORT_SYMBOL(sdw_cdns_probe);
 992
 993 int cdns_set_sdw_stream(struct snd_soc_dai *dai,
 994                         void *stream, bool pcm, int direction)
 995 {
 996         struct sdw_cdns *cdns = snd_soc_dai_get_drvdata(dai);
 997         struct sdw_cdns_dma_data *dma;
 998
 999         dma = kzalloc(sizeof(*dma), GFP_KERNEL);
1000         if (!dma)
1001                 return -ENOMEM;
1002
1003         if (pcm)
1004                 dma->stream_type = SDW_STREAM_PCM;
1005         else
1006                 dma->stream_type = SDW_STREAM_PDM;
1007
1008         dma->bus = &cdns->bus;
1009         dma->link_id = cdns->instance;
1010
1011         dma->stream = stream;
1012
1013         if (direction == SNDRV_PCM_STREAM_PLAYBACK)
1014                 dai->playback_dma_data = dma;
1015         else
1016                 dai->capture_dma_data = dma;
1017
1018         return 0;
1019 }
1020 EXPORT_SYMBOL(cdns_set_sdw_stream);
1021
1022 /**
1023  * cdns_find_pdi() - Find a free PDI
1024  *
1025  * @cdns: Cadence instance
1026  * @num: Number of PDIs
1027  * @pdi: PDI instances
1028  *
1029  * Find and return a free PDI for a given PDI array
1030  */
1031 static struct sdw_cdns_pdi *cdns_find_pdi(struct sdw_cdns *cdns,
1032                                           unsigned int num,
1033                                           struct sdw_cdns_pdi *pdi)
1034 {
1035         int i;
1036
1037         for (i = 0; i < num; i++) {
1038                 if (pdi[i].assigned)
1039                         continue;
1040                 pdi[i].assigned = true;
1041                 return &pdi[i];
1042         }
1043
1044         return NULL;
1045 }
1046
1047 /**
1048  * sdw_cdns_config_stream: Configure a stream
1049  *
1050  * @cdns: Cadence instance
1051  * @port: Cadence data port
1052  * @ch: Channel count
1053  * @dir: Data direction
1054  * @pdi: PDI to be used
1055  */
1056 void sdw_cdns_config_stream(struct sdw_cdns *cdns,
1057                             struct sdw_cdns_port *port,
1058                             u32 ch, u32 dir, struct sdw_cdns_pdi *pdi)
1059 {
1060         u32 offset, val = 0;
1061
1062         if (dir == SDW_DATA_DIR_RX)
1063                 val = CDNS_PORTCTRL_DIRN;
1064
1065         offset = CDNS_PORTCTRL + port->num * CDNS_PORT_OFFSET;
1066         cdns_updatel(cdns, offset, CDNS_PORTCTRL_DIRN, val);
1067
1068         val = port->num;
1069         val |= ((1 << ch) - 1) << SDW_REG_SHIFT(CDNS_PDI_CONFIG_CHANNEL);
1070         cdns_writel(cdns, CDNS_PDI_CONFIG(pdi->num), val);
1071 }
1072 EXPORT_SYMBOL(sdw_cdns_config_stream);
1073
1074 /**
1075  * cdns_get_num_pdi() - Get number of PDIs required
1076  *
1077  * @cdns: Cadence instance
1078  * @pdi: PDI to be used
1079  * @num: Number of PDIs
1080  * @ch_count: Channel count
1081  */
1082 static int cdns_get_num_pdi(struct sdw_cdns *cdns,
1083                             struct sdw_cdns_pdi *pdi,
1084                             unsigned int num, u32 ch_count)
1085 {
1086         int i, pdis = 0;
1087
1088         for (i = 0; i < num; i++) {
1089                 if (pdi[i].assigned)
1090                         continue;
1091
1092                 if (pdi[i].ch_count < ch_count)
1093                         ch_count -= pdi[i].ch_count;
1094                 else
1095                         ch_count = 0;
1096
1097                 pdis++;
1098
1099                 if (!ch_count)
1100                         break;
1101         }
1102
1103         if (ch_count)
1104                 return 0;
1105
1106         return pdis;
1107 }
1108
1109 /**
1110  * sdw_cdns_get_stream() - Get stream information
1111  *
1112  * @cdns: Cadence instance
1113  * @stream: Stream to be allocated
1114  * @ch: Channel count
1115  * @dir: Data direction
1116  */
1117 int sdw_cdns_get_stream(struct sdw_cdns *cdns,
1118                         struct sdw_cdns_streams *stream,
1119                         u32 ch, u32 dir)
1120 {
1121         int pdis = 0;
1122
1123         if (dir == SDW_DATA_DIR_RX)
1124                 pdis = cdns_get_num_pdi(cdns, stream->in, stream->num_in, ch);
1125         else
1126                 pdis = cdns_get_num_pdi(cdns, stream->out, stream->num_out, ch);
1127
1128         /* check if we found PDI, else find in bi-directional */
1129         if (!pdis)
1130                 pdis = cdns_get_num_pdi(cdns, stream->bd, stream->num_bd, ch);
1131
1132         return pdis;
1133 }
1134 EXPORT_SYMBOL(sdw_cdns_get_stream);
1135
1136 /**
1137  * sdw_cdns_alloc_stream() - Allocate a stream
1138  *
1139  * @cdns: Cadence instance
1140  * @stream: Stream to be allocated
1141  * @port: Cadence data port
1142  * @ch: Channel count
1143  * @dir: Data direction
1144  */
1145 int sdw_cdns_alloc_stream(struct sdw_cdns *cdns,
1146                           struct sdw_cdns_streams *stream,
1147                           struct sdw_cdns_port *port, u32 ch, u32 dir)
1148 {
1149         struct sdw_cdns_pdi *pdi = NULL;
1150
1151         if (dir == SDW_DATA_DIR_RX)
1152                 pdi = cdns_find_pdi(cdns, stream->num_in, stream->in);
1153         else
1154                 pdi = cdns_find_pdi(cdns, stream->num_out, stream->out);
1155
1156         /* check if we found a PDI, else find in bi-directional */
1157         if (!pdi)
1158                 pdi = cdns_find_pdi(cdns, stream->num_bd, stream->bd);
1159
1160         if (!pdi)
1161                 return -EIO;
1162
1163         port->pdi = pdi;
1164         pdi->l_ch_num = 0;
1165         pdi->h_ch_num = ch - 1;
1166         pdi->dir = dir;
1167         pdi->ch_count = ch;
1168
1169         return 0;
1170 }
1171 EXPORT_SYMBOL(sdw_cdns_alloc_stream);
1172
1173 void sdw_cdns_shutdown(struct snd_pcm_substream *substream,
1174                        struct snd_soc_dai *dai)
1175 {
1176         struct sdw_cdns_dma_data *dma;
1177
1178         dma = snd_soc_dai_get_dma_data(dai, substream);
1179         if (!dma)
1180                 return;
1181
1182         snd_soc_dai_set_dma_data(dai, substream, NULL);
1183         kfree(dma);
1184 }
1185 EXPORT_SYMBOL(sdw_cdns_shutdown);
1186
1187 MODULE_LICENSE("Dual BSD/GPL");
1188 MODULE_DESCRIPTION("Cadence Soundwire Library");