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/debugfs.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/module.h>
  15 #include <linux/mod_devicetable.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/soundwire/sdw_registers.h>
  18 #include <linux/soundwire/sdw.h>
  19 #include <sound/pcm_params.h>
  20 #include <sound/soc.h>
  21 #include <linux/workqueue.h>
  22 #include "bus.h"
  23 #include "cadence_master.h"
  24
  25 static int interrupt_mask;
  26 module_param_named(cnds_mcp_int_mask, interrupt_mask, int, 0444);
  27 MODULE_PARM_DESC(cdns_mcp_int_mask, "Cadence MCP IntMask");
  28
  29 #define CDNS_MCP_CONFIG                         0x0
  30
  31 #define CDNS_MCP_CONFIG_MCMD_RETRY              GENMASK(27, 24)
  32 #define CDNS_MCP_CONFIG_MPREQ_DELAY             GENMASK(20, 16)
  33 #define CDNS_MCP_CONFIG_MMASTER                 BIT(7)
  34 #define CDNS_MCP_CONFIG_BUS_REL                 BIT(6)
  35 #define CDNS_MCP_CONFIG_SNIFFER                 BIT(5)
  36 #define CDNS_MCP_CONFIG_SSPMOD                  BIT(4)
  37 #define CDNS_MCP_CONFIG_CMD                     BIT(3)
  38 #define CDNS_MCP_CONFIG_OP                      GENMASK(2, 0)
  39 #define CDNS_MCP_CONFIG_OP_NORMAL               0
  40
  41 #define CDNS_MCP_CONTROL                        0x4
  42
  43 #define CDNS_MCP_CONTROL_RST_DELAY              GENMASK(10, 8)
  44 #define CDNS_MCP_CONTROL_CMD_RST                BIT(7)
  45 #define CDNS_MCP_CONTROL_SOFT_RST               BIT(6)
  46 #define CDNS_MCP_CONTROL_SW_RST                 BIT(5)
  47 #define CDNS_MCP_CONTROL_HW_RST                 BIT(4)
  48 #define CDNS_MCP_CONTROL_CLK_PAUSE              BIT(3)
  49 #define CDNS_MCP_CONTROL_CLK_STOP_CLR           BIT(2)
  50 #define CDNS_MCP_CONTROL_CMD_ACCEPT             BIT(1)
  51 #define CDNS_MCP_CONTROL_BLOCK_WAKEUP           BIT(0)
  52
  53 #define CDNS_MCP_CMDCTRL                        0x8
  54
  55 #define CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR      BIT(2)
  56
  57 #define CDNS_MCP_SSPSTAT                        0xC
  58 #define CDNS_MCP_FRAME_SHAPE                    0x10
  59 #define CDNS_MCP_FRAME_SHAPE_INIT               0x14
  60 #define CDNS_MCP_FRAME_SHAPE_COL_MASK           GENMASK(2, 0)
  61 #define CDNS_MCP_FRAME_SHAPE_ROW_MASK           GENMASK(7, 3)
  62
  63 #define CDNS_MCP_CONFIG_UPDATE                  0x18
  64 #define CDNS_MCP_CONFIG_UPDATE_BIT              BIT(0)
  65
  66 #define CDNS_MCP_PHYCTRL                        0x1C
  67 #define CDNS_MCP_SSP_CTRL0                      0x20
  68 #define CDNS_MCP_SSP_CTRL1                      0x28
  69 #define CDNS_MCP_CLK_CTRL0                      0x30
  70 #define CDNS_MCP_CLK_CTRL1                      0x38
  71 #define CDNS_MCP_CLK_MCLKD_MASK         GENMASK(7, 0)
  72
  73 #define CDNS_MCP_STAT                           0x40
  74
  75 #define CDNS_MCP_STAT_ACTIVE_BANK               BIT(20)
  76 #define CDNS_MCP_STAT_CLK_STOP                  BIT(16)
  77
  78 #define CDNS_MCP_INTSTAT                        0x44
  79 #define CDNS_MCP_INTMASK                        0x48
  80
  81 #define CDNS_MCP_INT_IRQ                        BIT(31)
  82 #define CDNS_MCP_INT_RESERVED1                  GENMASK(30, 17)
  83 #define CDNS_MCP_INT_WAKEUP                     BIT(16)
  84 #define CDNS_MCP_INT_SLAVE_RSVD                 BIT(15)
  85 #define CDNS_MCP_INT_SLAVE_ALERT                BIT(14)
  86 #define CDNS_MCP_INT_SLAVE_ATTACH               BIT(13)
  87 #define CDNS_MCP_INT_SLAVE_NATTACH              BIT(12)
  88 #define CDNS_MCP_INT_SLAVE_MASK                 GENMASK(15, 12)
  89 #define CDNS_MCP_INT_DPINT                      BIT(11)
  90 #define CDNS_MCP_INT_CTRL_CLASH                 BIT(10)
  91 #define CDNS_MCP_INT_DATA_CLASH                 BIT(9)
  92 #define CDNS_MCP_INT_PARITY                     BIT(8)
  93 #define CDNS_MCP_INT_CMD_ERR                    BIT(7)
  94 #define CDNS_MCP_INT_RESERVED2                  GENMASK(6, 4)
  95 #define CDNS_MCP_INT_RX_NE                      BIT(3)
  96 #define CDNS_MCP_INT_RX_WL                      BIT(2)
  97 #define CDNS_MCP_INT_TXE                        BIT(1)
  98 #define CDNS_MCP_INT_TXF                        BIT(0)
  99 #define CDNS_MCP_INT_RESERVED (CDNS_MCP_INT_RESERVED1 | CDNS_MCP_INT_RESERVED2)
 100
 101 #define CDNS_MCP_INTSET                         0x4C
 102
 103 #define CDNS_MCP_SLAVE_STAT                     0x50
 104 #define CDNS_MCP_SLAVE_STAT_MASK                GENMASK(1, 0)
 105
 106 #define CDNS_MCP_SLAVE_INTSTAT0                 0x54
 107 #define CDNS_MCP_SLAVE_INTSTAT1                 0x58
 108 #define CDNS_MCP_SLAVE_INTSTAT_NPRESENT         BIT(0)
 109 #define CDNS_MCP_SLAVE_INTSTAT_ATTACHED         BIT(1)
 110 #define CDNS_MCP_SLAVE_INTSTAT_ALERT            BIT(2)
 111 #define CDNS_MCP_SLAVE_INTSTAT_RESERVED         BIT(3)
 112 #define CDNS_MCP_SLAVE_STATUS_BITS              GENMASK(3, 0)
 113 #define CDNS_MCP_SLAVE_STATUS_NUM               4
 114
 115 #define CDNS_MCP_SLAVE_INTMASK0                 0x5C
 116 #define CDNS_MCP_SLAVE_INTMASK1                 0x60
 117
 118 #define CDNS_MCP_SLAVE_INTMASK0_MASK            GENMASK(31, 0)
 119 #define CDNS_MCP_SLAVE_INTMASK1_MASK            GENMASK(15, 0)
 120
 121 #define CDNS_MCP_PORT_INTSTAT                   0x64
 122 #define CDNS_MCP_PDI_STAT                       0x6C
 123
 124 #define CDNS_MCP_FIFOLEVEL                      0x78
 125 #define CDNS_MCP_FIFOSTAT                       0x7C
 126 #define CDNS_MCP_RX_FIFO_AVAIL                  GENMASK(5, 0)
 127
 128 #define CDNS_MCP_CMD_BASE                       0x80
 129 #define CDNS_MCP_RESP_BASE                      0x80
 130 #define CDNS_MCP_CMD_LEN                        0x20
 131 #define CDNS_MCP_CMD_WORD_LEN                   0x4
 132
 133 #define CDNS_MCP_CMD_SSP_TAG                    BIT(31)
 134 #define CDNS_MCP_CMD_COMMAND                    GENMASK(30, 28)
 135 #define CDNS_MCP_CMD_DEV_ADDR                   GENMASK(27, 24)
 136 #define CDNS_MCP_CMD_REG_ADDR                   GENMASK(23, 8)
 137 #define CDNS_MCP_CMD_REG_DATA                   GENMASK(7, 0)
 138
 139 #define CDNS_MCP_CMD_READ                       2
 140 #define CDNS_MCP_CMD_WRITE                      3
 141
 142 #define CDNS_MCP_RESP_RDATA                     GENMASK(15, 8)
 143 #define CDNS_MCP_RESP_ACK                       BIT(0)
 144 #define CDNS_MCP_RESP_NACK                      BIT(1)
 145
 146 #define CDNS_DP_SIZE                            128
 147
 148 #define CDNS_DPN_B0_CONFIG(n)                   (0x100 + CDNS_DP_SIZE * (n))
 149 #define CDNS_DPN_B0_CH_EN(n)                    (0x104 + CDNS_DP_SIZE * (n))
 150 #define CDNS_DPN_B0_SAMPLE_CTRL(n)              (0x108 + CDNS_DP_SIZE * (n))
 151 #define CDNS_DPN_B0_OFFSET_CTRL(n)              (0x10C + CDNS_DP_SIZE * (n))
 152 #define CDNS_DPN_B0_HCTRL(n)                    (0x110 + CDNS_DP_SIZE * (n))
 153 #define CDNS_DPN_B0_ASYNC_CTRL(n)               (0x114 + CDNS_DP_SIZE * (n))
 154
 155 #define CDNS_DPN_B1_CONFIG(n)                   (0x118 + CDNS_DP_SIZE * (n))
 156 #define CDNS_DPN_B1_CH_EN(n)                    (0x11C + CDNS_DP_SIZE * (n))
 157 #define CDNS_DPN_B1_SAMPLE_CTRL(n)              (0x120 + CDNS_DP_SIZE * (n))
 158 #define CDNS_DPN_B1_OFFSET_CTRL(n)              (0x124 + CDNS_DP_SIZE * (n))
 159 #define CDNS_DPN_B1_HCTRL(n)                    (0x128 + CDNS_DP_SIZE * (n))
 160 #define CDNS_DPN_B1_ASYNC_CTRL(n)               (0x12C + CDNS_DP_SIZE * (n))
 161
 162 #define CDNS_DPN_CONFIG_BPM                     BIT(18)
 163 #define CDNS_DPN_CONFIG_BGC                     GENMASK(17, 16)
 164 #define CDNS_DPN_CONFIG_WL                      GENMASK(12, 8)
 165 #define CDNS_DPN_CONFIG_PORT_DAT                GENMASK(3, 2)
 166 #define CDNS_DPN_CONFIG_PORT_FLOW               GENMASK(1, 0)
 167
 168 #define CDNS_DPN_SAMPLE_CTRL_SI                 GENMASK(15, 0)
 169
 170 #define CDNS_DPN_OFFSET_CTRL_1                  GENMASK(7, 0)
 171 #define CDNS_DPN_OFFSET_CTRL_2                  GENMASK(15, 8)
 172
 173 #define CDNS_DPN_HCTRL_HSTOP                    GENMASK(3, 0)
 174 #define CDNS_DPN_HCTRL_HSTART                   GENMASK(7, 4)
 175 #define CDNS_DPN_HCTRL_LCTRL                    GENMASK(10, 8)
 176
 177 #define CDNS_PORTCTRL                           0x130
 178 #define CDNS_PORTCTRL_TEST_FAILED               BIT(1)
 179 #define CDNS_PORTCTRL_DIRN                      BIT(7)
 180 #define CDNS_PORTCTRL_BANK_INVERT               BIT(8)
 181
 182 #define CDNS_PORT_OFFSET                        0x80
 183
 184 #define CDNS_PDI_CONFIG(n)                      (0x1100 + (n) * 16)
 185
 186 #define CDNS_PDI_CONFIG_SOFT_RESET              BIT(24)
 187 #define CDNS_PDI_CONFIG_CHANNEL                 GENMASK(15, 8)
 188 #define CDNS_PDI_CONFIG_PORT                    GENMASK(4, 0)
 189
 190 /* Driver defaults */
 191 #define CDNS_TX_TIMEOUT                         500
 192
 193 #define CDNS_SCP_RX_FIFOLEVEL                   0x2
 194
 195 /*
 196  * register accessor helpers
 197  */
 198 static inline u32 cdns_readl(struct sdw_cdns *cdns, int offset)
 199 {
 200         return readl(cdns->registers + offset);
 201 }
 202
 203 static inline void cdns_writel(struct sdw_cdns *cdns, int offset, u32 value)
 204 {
 205         writel(value, cdns->registers + offset);
 206 }
 207
 208 static inline void cdns_updatel(struct sdw_cdns *cdns,
 209                                 int offset, u32 mask, u32 val)
 210 {
 211         u32 tmp;
 212
 213         tmp = cdns_readl(cdns, offset);
 214         tmp = (tmp & ~mask) | val;
 215         cdns_writel(cdns, offset, tmp);
 216 }
 217
 218 static int cdns_set_wait(struct sdw_cdns *cdns, int offset, u32 mask, u32 value)
 219 {
 220         int timeout = 10;
 221         u32 reg_read;
 222
 223         /* Wait for bit to be set */
 224         do {
 225                 reg_read = readl(cdns->registers + offset);
 226                 if ((reg_read & mask) == value)
 227                         return 0;
 228
 229                 timeout--;
 230                 usleep_range(50, 100);
 231         } while (timeout != 0);
 232
 233         return -ETIMEDOUT;
 234 }
 235
 236 static int cdns_clear_bit(struct sdw_cdns *cdns, int offset, u32 value)
 237 {
 238         writel(value, cdns->registers + offset);
 239
 240         /* Wait for bit to be self cleared */
 241         return cdns_set_wait(cdns, offset, value, 0);
 242 }
 243
 244 /*
 245  * all changes to the MCP_CONFIG, MCP_CONTROL, MCP_CMDCTRL and MCP_PHYCTRL
 246  * need to be confirmed with a write to MCP_CONFIG_UPDATE
 247  */
 248 static int cdns_config_update(struct sdw_cdns *cdns)
 249 {
 250         int ret;
 251
 252         if (sdw_cdns_is_clock_stop(cdns)) {
 253                 dev_err(cdns->dev, "Cannot program MCP_CONFIG_UPDATE in ClockStopMode\n");
 254                 return -EINVAL;
 255         }
 256
 257         ret = cdns_clear_bit(cdns, CDNS_MCP_CONFIG_UPDATE,
 258                              CDNS_MCP_CONFIG_UPDATE_BIT);
 259         if (ret < 0)
 260                 dev_err(cdns->dev, "Config update timedout\n");
 261
 262         return ret;
 263 }
 264
 265 /*
 266  * debugfs
 267  */
 268 #ifdef CONFIG_DEBUG_FS
 269
 270 #define RD_BUF (2 * PAGE_SIZE)
 271
 272 static ssize_t cdns_sprintf(struct sdw_cdns *cdns,
 273                             char *buf, size_t pos, unsigned int reg)
 274 {
 275         return scnprintf(buf + pos, RD_BUF - pos,
 276                          "%4x\t%8x\n", reg, cdns_readl(cdns, reg));
 277 }
 278
 279 static int cdns_reg_show(struct seq_file *s, void *data)
 280 {
 281         struct sdw_cdns *cdns = s->private;
 282         char *buf;
 283         ssize_t ret;
 284         int num_ports;
 285         int i, j;
 286
 287         buf = kzalloc(RD_BUF, GFP_KERNEL);
 288         if (!buf)
 289                 return -ENOMEM;
 290
 291         ret = scnprintf(buf, RD_BUF, "Register  Value\n");
 292         ret += scnprintf(buf + ret, RD_BUF - ret, "\nMCP Registers\n");
 293         /* 8 MCP registers */
 294         for (i = CDNS_MCP_CONFIG; i <= CDNS_MCP_PHYCTRL; i += sizeof(u32))
 295                 ret += cdns_sprintf(cdns, buf, ret, i);
 296
 297         ret += scnprintf(buf + ret, RD_BUF - ret,
 298                          "\nStatus & Intr Registers\n");
 299         /* 13 Status & Intr registers (offsets 0x70 and 0x74 not defined) */
 300         for (i = CDNS_MCP_STAT; i <=  CDNS_MCP_FIFOSTAT; i += sizeof(u32))
 301                 ret += cdns_sprintf(cdns, buf, ret, i);
 302
 303         ret += scnprintf(buf + ret, RD_BUF - ret,
 304                          "\nSSP & Clk ctrl Registers\n");
 305         ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_SSP_CTRL0);
 306         ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_SSP_CTRL1);
 307         ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_CLK_CTRL0);
 308         ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_CLK_CTRL1);
 309
 310         ret += scnprintf(buf + ret, RD_BUF - ret,
 311                          "\nDPn B0 Registers\n");
 312
 313         num_ports = cdns->num_ports;
 314
 315         for (i = 0; i < num_ports; i++) {
 316                 ret += scnprintf(buf + ret, RD_BUF - ret,
 317                                  "\nDP-%d\n", i);
 318                 for (j = CDNS_DPN_B0_CONFIG(i);
 319                      j < CDNS_DPN_B0_ASYNC_CTRL(i); j += sizeof(u32))
 320                         ret += cdns_sprintf(cdns, buf, ret, j);
 321         }
 322
 323         ret += scnprintf(buf + ret, RD_BUF - ret,
 324                          "\nDPn B1 Registers\n");
 325         for (i = 0; i < num_ports; i++) {
 326                 ret += scnprintf(buf + ret, RD_BUF - ret,
 327                                  "\nDP-%d\n", i);
 328
 329                 for (j = CDNS_DPN_B1_CONFIG(i);
 330                      j < CDNS_DPN_B1_ASYNC_CTRL(i); j += sizeof(u32))
 331                         ret += cdns_sprintf(cdns, buf, ret, j);
 332         }
 333
 334         ret += scnprintf(buf + ret, RD_BUF - ret,
 335                          "\nDPn Control Registers\n");
 336         for (i = 0; i < num_ports; i++)
 337                 ret += cdns_sprintf(cdns, buf, ret,
 338                                 CDNS_PORTCTRL + i * CDNS_PORT_OFFSET);
 339
 340         ret += scnprintf(buf + ret, RD_BUF - ret,
 341                          "\nPDIn Config Registers\n");
 342
 343         /* number of PDI and ports is interchangeable */
 344         for (i = 0; i < num_ports; i++)
 345                 ret += cdns_sprintf(cdns, buf, ret, CDNS_PDI_CONFIG(i));
 346
 347         seq_printf(s, "%s", buf);
 348         kfree(buf);
 349
 350         return 0;
 351 }
 352 DEFINE_SHOW_ATTRIBUTE(cdns_reg);
 353
 354 static int cdns_hw_reset(void *data, u64 value)
 355 {
 356         struct sdw_cdns *cdns = data;
 357         int ret;
 358
 359         if (value != 1)
 360                 return -EINVAL;
 361
 362         /* Userspace changed the hardware state behind the kernel's back */
 363         add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 364
 365         ret = sdw_cdns_exit_reset(cdns);
 366
 367         dev_dbg(cdns->dev, "link hw_reset done: %d\n", ret);
 368
 369         return ret;
 370 }
 371
 372 DEFINE_DEBUGFS_ATTRIBUTE(cdns_hw_reset_fops, NULL, cdns_hw_reset, "%llu\n");
 373
 374 static int cdns_parity_error_injection(void *data, u64 value)
 375 {
 376         struct sdw_cdns *cdns = data;
 377         struct sdw_bus *bus;
 378         int ret;
 379
 380         if (value != 1)
 381                 return -EINVAL;
 382
 383         bus = &cdns->bus;
 384
 385         /*
 386          * Resume Master device. If this results in a bus reset, the
 387          * Slave devices will re-attach and be re-enumerated.
 388          */
 389         ret = pm_runtime_resume_and_get(bus->dev);
 390         if (ret < 0 && ret != -EACCES) {
 391                 dev_err_ratelimited(cdns->dev,
 392                                     "pm_runtime_resume_and_get failed in %s, ret %d\n",
 393                                     __func__, ret);
 394                 return ret;
 395         }
 396
 397         /*
 398          * wait long enough for Slave(s) to be in steady state. This
 399          * does not need to be super precise.
 400          */
 401         msleep(200);
 402
 403         /*
 404          * Take the bus lock here to make sure that any bus transactions
 405          * will be queued while we inject a parity error on a dummy read
 406          */
 407         mutex_lock(&bus->bus_lock);
 408
 409         /* program hardware to inject parity error */
 410         cdns_updatel(cdns, CDNS_MCP_CMDCTRL,
 411                      CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR,
 412                      CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR);
 413
 414         /* commit changes */
 415         cdns_updatel(cdns, CDNS_MCP_CONFIG_UPDATE,
 416                      CDNS_MCP_CONFIG_UPDATE_BIT,
 417                      CDNS_MCP_CONFIG_UPDATE_BIT);
 418
 419         /* do a broadcast dummy read to avoid bus clashes */
 420         ret = sdw_bread_no_pm_unlocked(&cdns->bus, 0xf, SDW_SCP_DEVID_0);
 421         dev_info(cdns->dev, "parity error injection, read: %d\n", ret);
 422
 423         /* program hardware to disable parity error */
 424         cdns_updatel(cdns, CDNS_MCP_CMDCTRL,
 425                      CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR,
 426                      0);
 427
 428         /* commit changes */
 429         cdns_updatel(cdns, CDNS_MCP_CONFIG_UPDATE,
 430                      CDNS_MCP_CONFIG_UPDATE_BIT,
 431                      CDNS_MCP_CONFIG_UPDATE_BIT);
 432
 433         /* Continue bus operation with parity error injection disabled */
 434         mutex_unlock(&bus->bus_lock);
 435
 436         /* Userspace changed the hardware state behind the kernel's back */
 437         add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 438
 439         /*
 440          * allow Master device to enter pm_runtime suspend. This may
 441          * also result in Slave devices suspending.
 442          */
 443         pm_runtime_mark_last_busy(bus->dev);
 444         pm_runtime_put_autosuspend(bus->dev);
 445
 446         return 0;
 447 }
 448
 449 DEFINE_DEBUGFS_ATTRIBUTE(cdns_parity_error_fops, NULL,
 450                          cdns_parity_error_injection, "%llu\n");
 451
 452 static int cdns_set_pdi_loopback_source(void *data, u64 value)
 453 {
 454         struct sdw_cdns *cdns = data;
 455         unsigned int pdi_out_num = cdns->pcm.num_bd + cdns->pcm.num_out;
 456
 457         if (value > pdi_out_num)
 458                 return -EINVAL;
 459
 460         /* Userspace changed the hardware state behind the kernel's back */
 461         add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 462
 463         cdns->pdi_loopback_source = value;
 464
 465         return 0;
 466 }
 467 DEFINE_DEBUGFS_ATTRIBUTE(cdns_pdi_loopback_source_fops, NULL, cdns_set_pdi_loopback_source, "%llu\n");
 468
 469 static int cdns_set_pdi_loopback_target(void *data, u64 value)
 470 {
 471         struct sdw_cdns *cdns = data;
 472         unsigned int pdi_in_num = cdns->pcm.num_bd + cdns->pcm.num_in;
 473
 474         if (value > pdi_in_num)
 475                 return -EINVAL;
 476
 477         /* Userspace changed the hardware state behind the kernel's back */
 478         add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 479
 480         cdns->pdi_loopback_target = value;
 481
 482         return 0;
 483 }
 484 DEFINE_DEBUGFS_ATTRIBUTE(cdns_pdi_loopback_target_fops, NULL, cdns_set_pdi_loopback_target, "%llu\n");
 485
 486 /**
 487  * sdw_cdns_debugfs_init() - Cadence debugfs init
 488  * @cdns: Cadence instance
 489  * @root: debugfs root
 490  */
 491 void sdw_cdns_debugfs_init(struct sdw_cdns *cdns, struct dentry *root)
 492 {
 493         debugfs_create_file("cdns-registers", 0400, root, cdns, &cdns_reg_fops);
 494
 495         debugfs_create_file("cdns-hw-reset", 0200, root, cdns,
 496                             &cdns_hw_reset_fops);
 497
 498         debugfs_create_file("cdns-parity-error-injection", 0200, root, cdns,
 499                             &cdns_parity_error_fops);
 500
 501         cdns->pdi_loopback_source = -1;
 502         cdns->pdi_loopback_target = -1;
 503
 504         debugfs_create_file("cdns-pdi-loopback-source", 0200, root, cdns,
 505                             &cdns_pdi_loopback_source_fops);
 506
 507         debugfs_create_file("cdns-pdi-loopback-target", 0200, root, cdns,
 508                             &cdns_pdi_loopback_target_fops);
 509
 510 }
 511 EXPORT_SYMBOL_GPL(sdw_cdns_debugfs_init);
 512
 513 #endif /* CONFIG_DEBUG_FS */
 514
 515 /*
 516  * IO Calls
 517  */
 518 static enum sdw_command_response
 519 cdns_fill_msg_resp(struct sdw_cdns *cdns,
 520                    struct sdw_msg *msg, int count, int offset)
 521 {
 522         int nack = 0, no_ack = 0;
 523         int i;
 524
 525         /* check message response */
 526         for (i = 0; i < count; i++) {
 527                 if (!(cdns->response_buf[i] & CDNS_MCP_RESP_ACK)) {
 528                         no_ack = 1;
 529                         dev_vdbg(cdns->dev, "Msg Ack not received, cmd %d\n", i);
 530                 }
 531                 if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
 532                         nack = 1;
 533                         dev_err_ratelimited(cdns->dev, "Msg NACK received, cmd %d\n", i);
 534                 }
 535         }
 536
 537         if (nack) {
 538                 dev_err_ratelimited(cdns->dev, "Msg NACKed for Slave %d\n", msg->dev_num);
 539                 return SDW_CMD_FAIL;
 540         }
 541
 542         if (no_ack) {
 543                 dev_dbg_ratelimited(cdns->dev, "Msg ignored for Slave %d\n", msg->dev_num);
 544                 return SDW_CMD_IGNORED;
 545         }
 546
 547         /* fill response */
 548         for (i = 0; i < count; i++)
 549                 msg->buf[i + offset] = FIELD_GET(CDNS_MCP_RESP_RDATA, cdns->response_buf[i]);
 550
 551         return SDW_CMD_OK;
 552 }
 553
 554 static enum sdw_command_response
 555 _cdns_xfer_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int cmd,
 556                int offset, int count, bool defer)
 557 {
 558         unsigned long time;
 559         u32 base, i, data;
 560         u16 addr;
 561
 562         /* Program the watermark level for RX FIFO */
 563         if (cdns->msg_count != count) {
 564                 cdns_writel(cdns, CDNS_MCP_FIFOLEVEL, count);
 565                 cdns->msg_count = count;
 566         }
 567
 568         base = CDNS_MCP_CMD_BASE;
 569         addr = msg->addr;
 570
 571         for (i = 0; i < count; i++) {
 572                 data = FIELD_PREP(CDNS_MCP_CMD_DEV_ADDR, msg->dev_num);
 573                 data |= FIELD_PREP(CDNS_MCP_CMD_COMMAND, cmd);
 574                 data |= FIELD_PREP(CDNS_MCP_CMD_REG_ADDR, addr);
 575                 addr++;
 576
 577                 if (msg->flags == SDW_MSG_FLAG_WRITE)
 578                         data |= msg->buf[i + offset];
 579
 580                 data |= FIELD_PREP(CDNS_MCP_CMD_SSP_TAG, msg->ssp_sync);
 581                 cdns_writel(cdns, base, data);
 582                 base += CDNS_MCP_CMD_WORD_LEN;
 583         }
 584
 585         if (defer)
 586                 return SDW_CMD_OK;
 587
 588         /* wait for timeout or response */
 589         time = wait_for_completion_timeout(&cdns->tx_complete,
 590                                            msecs_to_jiffies(CDNS_TX_TIMEOUT));
 591         if (!time) {
 592                 dev_err(cdns->dev, "IO transfer timed out, cmd %d device %d addr %x len %d\n",
 593                         cmd, msg->dev_num, msg->addr, msg->len);
 594                 msg->len = 0;
 595                 return SDW_CMD_TIMEOUT;
 596         }
 597
 598         return cdns_fill_msg_resp(cdns, msg, count, offset);
 599 }
 600
 601 static enum sdw_command_response
 602 cdns_program_scp_addr(struct sdw_cdns *cdns, struct sdw_msg *msg)
 603 {
 604         int nack = 0, no_ack = 0;
 605         unsigned long time;
 606         u32 data[2], base;
 607         int i;
 608
 609         /* Program the watermark level for RX FIFO */
 610         if (cdns->msg_count != CDNS_SCP_RX_FIFOLEVEL) {
 611                 cdns_writel(cdns, CDNS_MCP_FIFOLEVEL, CDNS_SCP_RX_FIFOLEVEL);
 612                 cdns->msg_count = CDNS_SCP_RX_FIFOLEVEL;
 613         }
 614
 615         data[0] = FIELD_PREP(CDNS_MCP_CMD_DEV_ADDR, msg->dev_num);
 616         data[0] |= FIELD_PREP(CDNS_MCP_CMD_COMMAND, 0x3);
 617         data[1] = data[0];
 618
 619         data[0] |= FIELD_PREP(CDNS_MCP_CMD_REG_ADDR, SDW_SCP_ADDRPAGE1);
 620         data[1] |= FIELD_PREP(CDNS_MCP_CMD_REG_ADDR, SDW_SCP_ADDRPAGE2);
 621
 622         data[0] |= msg->addr_page1;
 623         data[1] |= msg->addr_page2;
 624
 625         base = CDNS_MCP_CMD_BASE;
 626         cdns_writel(cdns, base, data[0]);
 627         base += CDNS_MCP_CMD_WORD_LEN;
 628         cdns_writel(cdns, base, data[1]);
 629
 630         time = wait_for_completion_timeout(&cdns->tx_complete,
 631                                            msecs_to_jiffies(CDNS_TX_TIMEOUT));
 632         if (!time) {
 633                 dev_err(cdns->dev, "SCP Msg trf timed out\n");
 634                 msg->len = 0;
 635                 return SDW_CMD_TIMEOUT;
 636         }
 637
 638         /* check response the writes */
 639         for (i = 0; i < 2; i++) {
 640                 if (!(cdns->response_buf[i] & CDNS_MCP_RESP_ACK)) {
 641                         no_ack = 1;
 642                         dev_err(cdns->dev, "Program SCP Ack not received\n");
 643                         if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
 644                                 nack = 1;
 645                                 dev_err(cdns->dev, "Program SCP NACK received\n");
 646                         }
 647                 }
 648         }
 649
 650         /* For NACK, NO ack, don't return err if we are in Broadcast mode */
 651         if (nack) {
 652                 dev_err_ratelimited(cdns->dev,
 653                                     "SCP_addrpage NACKed for Slave %d\n", msg->dev_num);
 654                 return SDW_CMD_FAIL;
 655         }
 656
 657         if (no_ack) {
 658                 dev_dbg_ratelimited(cdns->dev,
 659                                     "SCP_addrpage ignored for Slave %d\n", msg->dev_num);
 660                 return SDW_CMD_IGNORED;
 661         }
 662
 663         return SDW_CMD_OK;
 664 }
 665
 666 static int cdns_prep_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int *cmd)
 667 {
 668         int ret;
 669
 670         if (msg->page) {
 671                 ret = cdns_program_scp_addr(cdns, msg);
 672                 if (ret) {
 673                         msg->len = 0;
 674                         return ret;
 675                 }
 676         }
 677
 678         switch (msg->flags) {
 679         case SDW_MSG_FLAG_READ:
 680                 *cmd = CDNS_MCP_CMD_READ;
 681                 break;
 682
 683         case SDW_MSG_FLAG_WRITE:
 684                 *cmd = CDNS_MCP_CMD_WRITE;
 685                 break;
 686
 687         default:
 688                 dev_err(cdns->dev, "Invalid msg cmd: %d\n", msg->flags);
 689                 return -EINVAL;
 690         }
 691
 692         return 0;
 693 }
 694
 695 enum sdw_command_response
 696 cdns_xfer_msg(struct sdw_bus *bus, struct sdw_msg *msg)
 697 {
 698         struct sdw_cdns *cdns = bus_to_cdns(bus);
 699         int cmd = 0, ret, i;
 700
 701         ret = cdns_prep_msg(cdns, msg, &cmd);
 702         if (ret)
 703                 return SDW_CMD_FAIL_OTHER;
 704
 705         for (i = 0; i < msg->len / CDNS_MCP_CMD_LEN; i++) {
 706                 ret = _cdns_xfer_msg(cdns, msg, cmd, i * CDNS_MCP_CMD_LEN,
 707                                      CDNS_MCP_CMD_LEN, false);
 708                 if (ret < 0)
 709                         goto exit;
 710         }
 711
 712         if (!(msg->len % CDNS_MCP_CMD_LEN))
 713                 goto exit;
 714
 715         ret = _cdns_xfer_msg(cdns, msg, cmd, i * CDNS_MCP_CMD_LEN,
 716                              msg->len % CDNS_MCP_CMD_LEN, false);
 717
 718 exit:
 719         return ret;
 720 }
 721 EXPORT_SYMBOL(cdns_xfer_msg);
 722
 723 enum sdw_command_response
 724 cdns_xfer_msg_defer(struct sdw_bus *bus,
 725                     struct sdw_msg *msg, struct sdw_defer *defer)
 726 {
 727         struct sdw_cdns *cdns = bus_to_cdns(bus);
 728         int cmd = 0, ret;
 729
 730         /* for defer only 1 message is supported */
 731         if (msg->len > 1)
 732                 return -ENOTSUPP;
 733
 734         ret = cdns_prep_msg(cdns, msg, &cmd);
 735         if (ret)
 736                 return SDW_CMD_FAIL_OTHER;
 737
 738         cdns->defer = defer;
 739         cdns->defer->length = msg->len;
 740
 741         return _cdns_xfer_msg(cdns, msg, cmd, 0, msg->len, true);
 742 }
 743 EXPORT_SYMBOL(cdns_xfer_msg_defer);
 744
 745 enum sdw_command_response
 746 cdns_reset_page_addr(struct sdw_bus *bus, unsigned int dev_num)
 747 {
 748         struct sdw_cdns *cdns = bus_to_cdns(bus);
 749         struct sdw_msg msg;
 750
 751         /* Create dummy message with valid device number */
 752         memset(&msg, 0, sizeof(msg));
 753         msg.dev_num = dev_num;
 754
 755         return cdns_program_scp_addr(cdns, &msg);
 756 }
 757 EXPORT_SYMBOL(cdns_reset_page_addr);
 758
 759 /*
 760  * IRQ handling
 761  */
 762
 763 static void cdns_read_response(struct sdw_cdns *cdns)
 764 {
 765         u32 num_resp, cmd_base;
 766         int i;
 767
 768         num_resp = cdns_readl(cdns, CDNS_MCP_FIFOSTAT);
 769         num_resp &= CDNS_MCP_RX_FIFO_AVAIL;
 770
 771         cmd_base = CDNS_MCP_CMD_BASE;
 772
 773         for (i = 0; i < num_resp; i++) {
 774                 cdns->response_buf[i] = cdns_readl(cdns, cmd_base);
 775                 cmd_base += CDNS_MCP_CMD_WORD_LEN;
 776         }
 777 }
 778
 779 static int cdns_update_slave_status(struct sdw_cdns *cdns,
 780                                     u64 slave_intstat)
 781 {
 782         enum sdw_slave_status status[SDW_MAX_DEVICES + 1];
 783         bool is_slave = false;
 784         u32 mask;
 785         int i, set_status;
 786
 787         memset(status, 0, sizeof(status));
 788
 789         for (i = 0; i <= SDW_MAX_DEVICES; i++) {
 790                 mask = (slave_intstat >> (i * CDNS_MCP_SLAVE_STATUS_NUM)) &
 791                         CDNS_MCP_SLAVE_STATUS_BITS;
 792                 if (!mask)
 793                         continue;
 794
 795                 is_slave = true;
 796                 set_status = 0;
 797
 798                 if (mask & CDNS_MCP_SLAVE_INTSTAT_RESERVED) {
 799                         status[i] = SDW_SLAVE_RESERVED;
 800                         set_status++;
 801                 }
 802
 803                 if (mask & CDNS_MCP_SLAVE_INTSTAT_ATTACHED) {
 804                         status[i] = SDW_SLAVE_ATTACHED;
 805                         set_status++;
 806                 }
 807
 808                 if (mask & CDNS_MCP_SLAVE_INTSTAT_ALERT) {
 809                         status[i] = SDW_SLAVE_ALERT;
 810                         set_status++;
 811                 }
 812
 813                 if (mask & CDNS_MCP_SLAVE_INTSTAT_NPRESENT) {
 814                         status[i] = SDW_SLAVE_UNATTACHED;
 815                         set_status++;
 816                 }
 817
 818                 /* first check if Slave reported multiple status */
 819                 if (set_status > 1) {
 820                         u32 val;
 821
 822                         dev_warn_ratelimited(cdns->dev,
 823                                              "Slave %d reported multiple Status: %d\n",
 824                                              i, mask);
 825
 826                         /* check latest status extracted from PING commands */
 827                         val = cdns_readl(cdns, CDNS_MCP_SLAVE_STAT);
 828                         val >>= (i * 2);
 829
 830                         switch (val & 0x3) {
 831                         case 0:
 832                                 status[i] = SDW_SLAVE_UNATTACHED;
 833                                 break;
 834                         case 1:
 835                                 status[i] = SDW_SLAVE_ATTACHED;
 836                                 break;
 837                         case 2:
 838                                 status[i] = SDW_SLAVE_ALERT;
 839                                 break;
 840                         case 3:
 841                         default:
 842                                 status[i] = SDW_SLAVE_RESERVED;
 843                                 break;
 844                         }
 845
 846                         dev_warn_ratelimited(cdns->dev,
 847                                              "Slave %d status updated to %d\n",
 848                                              i, status[i]);
 849
 850                 }
 851         }
 852
 853         if (is_slave)
 854                 return sdw_handle_slave_status(&cdns->bus, status);
 855
 856         return 0;
 857 }
 858
 859 /**
 860  * sdw_cdns_irq() - Cadence interrupt handler
 861  * @irq: irq number
 862  * @dev_id: irq context
 863  */
 864 irqreturn_t sdw_cdns_irq(int irq, void *dev_id)
 865 {
 866         struct sdw_cdns *cdns = dev_id;
 867         u32 int_status;
 868
 869         /* Check if the link is up */
 870         if (!cdns->link_up)
 871                 return IRQ_NONE;
 872
 873         int_status = cdns_readl(cdns, CDNS_MCP_INTSTAT);
 874
 875         /* check for reserved values read as zero */
 876         if (int_status & CDNS_MCP_INT_RESERVED)
 877                 return IRQ_NONE;
 878
 879         if (!(int_status & CDNS_MCP_INT_IRQ))
 880                 return IRQ_NONE;
 881
 882         if (int_status & CDNS_MCP_INT_RX_WL) {
 883                 cdns_read_response(cdns);
 884
 885                 if (cdns->defer) {
 886                         cdns_fill_msg_resp(cdns, cdns->defer->msg,
 887                                            cdns->defer->length, 0);
 888                         complete(&cdns->defer->complete);
 889                         cdns->defer = NULL;
 890                 } else {
 891                         complete(&cdns->tx_complete);
 892                 }
 893         }
 894
 895         if (int_status & CDNS_MCP_INT_PARITY) {
 896                 /* Parity error detected by Master */
 897                 dev_err_ratelimited(cdns->dev, "Parity error\n");
 898         }
 899
 900         if (int_status & CDNS_MCP_INT_CTRL_CLASH) {
 901                 /* Slave is driving bit slot during control word */
 902                 dev_err_ratelimited(cdns->dev, "Bus clash for control word\n");
 903         }
 904
 905         if (int_status & CDNS_MCP_INT_DATA_CLASH) {
 906                 /*
 907                  * Multiple slaves trying to drive bit slot, or issue with
 908                  * ownership of data bits or Slave gone bonkers
 909                  */
 910                 dev_err_ratelimited(cdns->dev, "Bus clash for data word\n");
 911         }
 912
 913         if (cdns->bus.params.m_data_mode != SDW_PORT_DATA_MODE_NORMAL &&
 914             int_status & CDNS_MCP_INT_DPINT) {
 915                 u32 port_intstat;
 916
 917                 /* just log which ports report an error */
 918                 port_intstat = cdns_readl(cdns, CDNS_MCP_PORT_INTSTAT);
 919                 dev_err_ratelimited(cdns->dev, "DP interrupt: PortIntStat %8x\n",
 920                                     port_intstat);
 921
 922                 /* clear status w/ write1 */
 923                 cdns_writel(cdns, CDNS_MCP_PORT_INTSTAT, port_intstat);
 924         }
 925
 926         if (int_status & CDNS_MCP_INT_SLAVE_MASK) {
 927                 /* Mask the Slave interrupt and wake thread */
 928                 cdns_updatel(cdns, CDNS_MCP_INTMASK,
 929                              CDNS_MCP_INT_SLAVE_MASK, 0);
 930
 931                 int_status &= ~CDNS_MCP_INT_SLAVE_MASK;
 932
 933                 /*
 934                  * Deal with possible race condition between interrupt
 935                  * handling and disabling interrupts on suspend.
 936                  *
 937                  * If the master is in the process of disabling
 938                  * interrupts, don't schedule a workqueue
 939                  */
 940                 if (cdns->interrupt_enabled)
 941                         schedule_work(&cdns->work);
 942         }
 943
 944         cdns_writel(cdns, CDNS_MCP_INTSTAT, int_status);
 945         return IRQ_HANDLED;
 946 }
 947 EXPORT_SYMBOL(sdw_cdns_irq);
 948
 949 /**
 950  * cdns_update_slave_status_work - update slave status in a work since we will need to handle
 951  * other interrupts eg. CDNS_MCP_INT_RX_WL during the update slave
 952  * process.
 953  * @work: cdns worker thread
 954  */
 955 static void cdns_update_slave_status_work(struct work_struct *work)
 956 {
 957         struct sdw_cdns *cdns =
 958                 container_of(work, struct sdw_cdns, work);
 959         u32 slave0, slave1;
 960         u64 slave_intstat;
 961         u32 device0_status;
 962         int retry_count = 0;
 963
 964         slave0 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT0);
 965         slave1 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT1);
 966
 967         /* combine the two status */
 968         slave_intstat = ((u64)slave1 << 32) | slave0;
 969
 970         dev_dbg_ratelimited(cdns->dev, "Slave status change: 0x%llx\n", slave_intstat);
 971
 972 update_status:
 973         cdns_update_slave_status(cdns, slave_intstat);
 974         cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT0, slave0);
 975         cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT1, slave1);
 976
 977         /*
 978          * When there is more than one peripheral per link, it's
 979          * possible that a deviceB becomes attached after we deal with
 980          * the attachment of deviceA. Since the hardware does a
 981          * logical AND, the attachment of the second device does not
 982          * change the status seen by the driver.
 983          *
 984          * In that case, clearing the registers above would result in
 985          * the deviceB never being detected - until a change of status
 986          * is observed on the bus.
 987          *
 988          * To avoid this race condition, re-check if any device0 needs
 989          * attention with PING commands. There is no need to check for
 990          * ALERTS since they are not allowed until a non-zero
 991          * device_number is assigned.
 992          */
 993
 994         device0_status = cdns_readl(cdns, CDNS_MCP_SLAVE_STAT);
 995         device0_status &= 3;
 996
 997         if (device0_status == SDW_SLAVE_ATTACHED) {
 998                 if (retry_count++ < SDW_MAX_DEVICES) {
 999                         dev_dbg_ratelimited(cdns->dev,
1000                                             "Device0 detected after clearing status, iteration %d\n",
1001                                             retry_count);
1002                         slave_intstat = CDNS_MCP_SLAVE_INTSTAT_ATTACHED;
1003                         goto update_status;
1004                 } else {
1005                         dev_err_ratelimited(cdns->dev,
1006                                             "Device0 detected after %d iterations\n",
1007                                             retry_count);
1008                 }
1009         }
1010
1011         /* clear and unmask Slave interrupt now */
1012         cdns_writel(cdns, CDNS_MCP_INTSTAT, CDNS_MCP_INT_SLAVE_MASK);
1013         cdns_updatel(cdns, CDNS_MCP_INTMASK,
1014                      CDNS_MCP_INT_SLAVE_MASK, CDNS_MCP_INT_SLAVE_MASK);
1015
1016 }
1017
1018 /* paranoia check to make sure self-cleared bits are indeed cleared */
1019 void sdw_cdns_check_self_clearing_bits(struct sdw_cdns *cdns, const char *string,
1020                                        bool initial_delay, int reset_iterations)
1021 {
1022         u32 mcp_control;
1023         u32 mcp_config_update;
1024         int i;
1025
1026         if (initial_delay)
1027                 usleep_range(1000, 1500);
1028
1029         mcp_control = cdns_readl(cdns, CDNS_MCP_CONTROL);
1030
1031         /* the following bits should be cleared immediately */
1032         if (mcp_control & CDNS_MCP_CONTROL_CMD_RST)
1033                 dev_err(cdns->dev, "%s failed: MCP_CONTROL_CMD_RST is not cleared\n", string);
1034         if (mcp_control & CDNS_MCP_CONTROL_SOFT_RST)
1035                 dev_err(cdns->dev, "%s failed: MCP_CONTROL_SOFT_RST is not cleared\n", string);
1036         if (mcp_control & CDNS_MCP_CONTROL_SW_RST)
1037                 dev_err(cdns->dev, "%s failed: MCP_CONTROL_SW_RST is not cleared\n", string);
1038         if (mcp_control & CDNS_MCP_CONTROL_CLK_STOP_CLR)
1039                 dev_err(cdns->dev, "%s failed: MCP_CONTROL_CLK_STOP_CLR is not cleared\n", string);
1040         mcp_config_update = cdns_readl(cdns, CDNS_MCP_CONFIG_UPDATE);
1041         if (mcp_config_update & CDNS_MCP_CONFIG_UPDATE_BIT)
1042                 dev_err(cdns->dev, "%s failed: MCP_CONFIG_UPDATE_BIT is not cleared\n", string);
1043
1044         i = 0;
1045         while (mcp_control & CDNS_MCP_CONTROL_HW_RST) {
1046                 if (i == reset_iterations) {
1047                         dev_err(cdns->dev, "%s failed: MCP_CONTROL_HW_RST is not cleared\n", string);
1048                         break;
1049                 }
1050
1051                 dev_dbg(cdns->dev, "%s: MCP_CONTROL_HW_RST is not cleared at iteration %d\n", string, i);
1052                 i++;
1053
1054                 usleep_range(1000, 1500);
1055                 mcp_control = cdns_readl(cdns, CDNS_MCP_CONTROL);
1056         }
1057
1058 }
1059 EXPORT_SYMBOL(sdw_cdns_check_self_clearing_bits);
1060
1061 /*
1062  * init routines
1063  */
1064
1065 /**
1066  * sdw_cdns_exit_reset() - Program reset parameters and start bus operations
1067  * @cdns: Cadence instance
1068  */
1069 int sdw_cdns_exit_reset(struct sdw_cdns *cdns)
1070 {
1071         /* keep reset delay unchanged to 4096 cycles */
1072
1073         /* use hardware generated reset */
1074         cdns_updatel(cdns, CDNS_MCP_CONTROL,
1075                      CDNS_MCP_CONTROL_HW_RST,
1076                      CDNS_MCP_CONTROL_HW_RST);
1077
1078         /* commit changes */
1079         cdns_updatel(cdns, CDNS_MCP_CONFIG_UPDATE,
1080                      CDNS_MCP_CONFIG_UPDATE_BIT,
1081                      CDNS_MCP_CONFIG_UPDATE_BIT);
1082
1083         /* don't wait here */
1084         return 0;
1085
1086 }
1087 EXPORT_SYMBOL(sdw_cdns_exit_reset);
1088
1089 /**
1090  * cdns_enable_slave_interrupts() - Enable SDW slave interrupts
1091  * @cdns: Cadence instance
1092  * @state: boolean for true/false
1093  */
1094 static void cdns_enable_slave_interrupts(struct sdw_cdns *cdns, bool state)
1095 {
1096         u32 mask;
1097
1098         mask = cdns_readl(cdns, CDNS_MCP_INTMASK);
1099         if (state)
1100                 mask |= CDNS_MCP_INT_SLAVE_MASK;
1101         else
1102                 mask &= ~CDNS_MCP_INT_SLAVE_MASK;
1103
1104         cdns_writel(cdns, CDNS_MCP_INTMASK, mask);
1105 }
1106
1107 /**
1108  * sdw_cdns_enable_interrupt() - Enable SDW interrupts
1109  * @cdns: Cadence instance
1110  * @state: True if we are trying to enable interrupt.
1111  */
1112 int sdw_cdns_enable_interrupt(struct sdw_cdns *cdns, bool state)
1113 {
1114         u32 slave_intmask0 = 0;
1115         u32 slave_intmask1 = 0;
1116         u32 mask = 0;
1117
1118         if (!state)
1119                 goto update_masks;
1120
1121         slave_intmask0 = CDNS_MCP_SLAVE_INTMASK0_MASK;
1122         slave_intmask1 = CDNS_MCP_SLAVE_INTMASK1_MASK;
1123
1124         /* enable detection of all slave state changes */
1125         mask = CDNS_MCP_INT_SLAVE_MASK;
1126
1127         /* enable detection of bus issues */
1128         mask |= CDNS_MCP_INT_CTRL_CLASH | CDNS_MCP_INT_DATA_CLASH |
1129                 CDNS_MCP_INT_PARITY;
1130
1131         /* port interrupt limited to test modes for now */
1132         if (cdns->bus.params.m_data_mode != SDW_PORT_DATA_MODE_NORMAL)
1133                 mask |= CDNS_MCP_INT_DPINT;
1134
1135         /* enable detection of RX fifo level */
1136         mask |= CDNS_MCP_INT_RX_WL;
1137
1138         /*
1139          * CDNS_MCP_INT_IRQ needs to be set otherwise all previous
1140          * settings are irrelevant
1141          */
1142         mask |= CDNS_MCP_INT_IRQ;
1143
1144         if (interrupt_mask) /* parameter override */
1145                 mask = interrupt_mask;
1146
1147 update_masks:
1148         /* clear slave interrupt status before enabling interrupt */
1149         if (state) {
1150                 u32 slave_state;
1151
1152                 slave_state = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT0);
1153                 cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT0, slave_state);
1154                 slave_state = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT1);
1155                 cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT1, slave_state);
1156         }
1157         cdns->interrupt_enabled = state;
1158
1159         /*
1160          * Complete any on-going status updates before updating masks,
1161          * and cancel queued status updates.
1162          *
1163          * There could be a race with a new interrupt thrown before
1164          * the 3 mask updates below are complete, so in the interrupt
1165          * we use the 'interrupt_enabled' status to prevent new work
1166          * from being queued.
1167          */
1168         if (!state)
1169                 cancel_work_sync(&cdns->work);
1170
1171         cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK0, slave_intmask0);
1172         cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK1, slave_intmask1);
1173         cdns_writel(cdns, CDNS_MCP_INTMASK, mask);
1174
1175         return 0;
1176 }
1177 EXPORT_SYMBOL(sdw_cdns_enable_interrupt);
1178
1179 static int cdns_allocate_pdi(struct sdw_cdns *cdns,
1180                              struct sdw_cdns_pdi **stream,
1181                              u32 num, u32 pdi_offset)
1182 {
1183         struct sdw_cdns_pdi *pdi;
1184         int i;
1185
1186         if (!num)
1187                 return 0;
1188
1189         pdi = devm_kcalloc(cdns->dev, num, sizeof(*pdi), GFP_KERNEL);
1190         if (!pdi)
1191                 return -ENOMEM;
1192
1193         for (i = 0; i < num; i++) {
1194                 pdi[i].num = i + pdi_offset;
1195         }
1196
1197         *stream = pdi;
1198         return 0;
1199 }
1200
1201 /**
1202  * sdw_cdns_pdi_init() - PDI initialization routine
1203  *
1204  * @cdns: Cadence instance
1205  * @config: Stream configurations
1206  */
1207 int sdw_cdns_pdi_init(struct sdw_cdns *cdns,
1208                       struct sdw_cdns_stream_config config)
1209 {
1210         struct sdw_cdns_streams *stream;
1211         int offset;
1212         int ret;
1213
1214         cdns->pcm.num_bd = config.pcm_bd;
1215         cdns->pcm.num_in = config.pcm_in;
1216         cdns->pcm.num_out = config.pcm_out;
1217
1218         /* Allocate PDIs for PCMs */
1219         stream = &cdns->pcm;
1220
1221         /* we allocate PDI0 and PDI1 which are used for Bulk */
1222         offset = 0;
1223
1224         ret = cdns_allocate_pdi(cdns, &stream->bd,
1225                                 stream->num_bd, offset);
1226         if (ret)
1227                 return ret;
1228
1229         offset += stream->num_bd;
1230
1231         ret = cdns_allocate_pdi(cdns, &stream->in,
1232                                 stream->num_in, offset);
1233         if (ret)
1234                 return ret;
1235
1236         offset += stream->num_in;
1237
1238         ret = cdns_allocate_pdi(cdns, &stream->out,
1239                                 stream->num_out, offset);
1240         if (ret)
1241                 return ret;
1242
1243         /* Update total number of PCM PDIs */
1244         stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
1245         cdns->num_ports = stream->num_pdi;
1246
1247         return 0;
1248 }
1249 EXPORT_SYMBOL(sdw_cdns_pdi_init);
1250
1251 static u32 cdns_set_initial_frame_shape(int n_rows, int n_cols)
1252 {
1253         u32 val;
1254         int c;
1255         int r;
1256
1257         r = sdw_find_row_index(n_rows);
1258         c = sdw_find_col_index(n_cols);
1259
1260         val = FIELD_PREP(CDNS_MCP_FRAME_SHAPE_ROW_MASK, r);
1261         val |= FIELD_PREP(CDNS_MCP_FRAME_SHAPE_COL_MASK, c);
1262
1263         return val;
1264 }
1265
1266 static void cdns_init_clock_ctrl(struct sdw_cdns *cdns)
1267 {
1268         struct sdw_bus *bus = &cdns->bus;
1269         struct sdw_master_prop *prop = &bus->prop;
1270         u32 val;
1271         u32 ssp_interval;
1272         int divider;
1273
1274         /* Set clock divider */
1275         divider = (prop->mclk_freq / prop->max_clk_freq) - 1;
1276
1277         cdns_updatel(cdns, CDNS_MCP_CLK_CTRL0,
1278                      CDNS_MCP_CLK_MCLKD_MASK, divider);
1279         cdns_updatel(cdns, CDNS_MCP_CLK_CTRL1,
1280                      CDNS_MCP_CLK_MCLKD_MASK, divider);
1281
1282         /*
1283          * Frame shape changes after initialization have to be done
1284          * with the bank switch mechanism
1285          */
1286         val = cdns_set_initial_frame_shape(prop->default_row,
1287                                            prop->default_col);
1288         cdns_writel(cdns, CDNS_MCP_FRAME_SHAPE_INIT, val);
1289
1290         /* Set SSP interval to default value */
1291         ssp_interval = prop->default_frame_rate / SDW_CADENCE_GSYNC_HZ;
1292         cdns_writel(cdns, CDNS_MCP_SSP_CTRL0, ssp_interval);
1293         cdns_writel(cdns, CDNS_MCP_SSP_CTRL1, ssp_interval);
1294 }
1295
1296 /**
1297  * sdw_cdns_init() - Cadence initialization
1298  * @cdns: Cadence instance
1299  */
1300 int sdw_cdns_init(struct sdw_cdns *cdns)
1301 {
1302         u32 val;
1303
1304         cdns_init_clock_ctrl(cdns);
1305
1306         sdw_cdns_check_self_clearing_bits(cdns, __func__, false, 0);
1307
1308         /* reset msg_count to default value of FIFOLEVEL */
1309         cdns->msg_count = cdns_readl(cdns, CDNS_MCP_FIFOLEVEL);
1310
1311         /* flush command FIFOs */
1312         cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_RST,
1313                      CDNS_MCP_CONTROL_CMD_RST);
1314
1315         /* Set cmd accept mode */
1316         cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_ACCEPT,
1317                      CDNS_MCP_CONTROL_CMD_ACCEPT);
1318
1319         /* Configure mcp config */
1320         val = cdns_readl(cdns, CDNS_MCP_CONFIG);
1321
1322         /* enable bus operations with clock and data */
1323         val &= ~CDNS_MCP_CONFIG_OP;
1324         val |= CDNS_MCP_CONFIG_OP_NORMAL;
1325
1326         /* Set cmd mode for Tx and Rx cmds */
1327         val &= ~CDNS_MCP_CONFIG_CMD;
1328
1329         /* Disable sniffer mode */
1330         val &= ~CDNS_MCP_CONFIG_SNIFFER;
1331
1332         /* Disable auto bus release */
1333         val &= ~CDNS_MCP_CONFIG_BUS_REL;
1334
1335         if (cdns->bus.multi_link)
1336                 /* Set Multi-master mode to take gsync into account */
1337                 val |= CDNS_MCP_CONFIG_MMASTER;
1338
1339         /* leave frame delay to hardware default of 0x1F */
1340
1341         /* leave command retry to hardware default of 0 */
1342
1343         cdns_writel(cdns, CDNS_MCP_CONFIG, val);
1344
1345         /* changes will be committed later */
1346         return 0;
1347 }
1348 EXPORT_SYMBOL(sdw_cdns_init);
1349
1350 int cdns_bus_conf(struct sdw_bus *bus, struct sdw_bus_params *params)
1351 {
1352         struct sdw_master_prop *prop = &bus->prop;
1353         struct sdw_cdns *cdns = bus_to_cdns(bus);
1354         int mcp_clkctrl_off;
1355         int divider;
1356
1357         if (!params->curr_dr_freq) {
1358                 dev_err(cdns->dev, "NULL curr_dr_freq\n");
1359                 return -EINVAL;
1360         }
1361
1362         divider = prop->mclk_freq * SDW_DOUBLE_RATE_FACTOR /
1363                 params->curr_dr_freq;
1364         divider--; /* divider is 1/(N+1) */
1365
1366         if (params->next_bank)
1367                 mcp_clkctrl_off = CDNS_MCP_CLK_CTRL1;
1368         else
1369                 mcp_clkctrl_off = CDNS_MCP_CLK_CTRL0;
1370
1371         cdns_updatel(cdns, mcp_clkctrl_off, CDNS_MCP_CLK_MCLKD_MASK, divider);
1372
1373         return 0;
1374 }
1375 EXPORT_SYMBOL(cdns_bus_conf);
1376
1377 static int cdns_port_params(struct sdw_bus *bus,
1378                             struct sdw_port_params *p_params, unsigned int bank)
1379 {
1380         struct sdw_cdns *cdns = bus_to_cdns(bus);
1381         int dpn_config_off_source;
1382         int dpn_config_off_target;
1383         int target_num = p_params->num;
1384         int source_num = p_params->num;
1385         bool override = false;
1386         int dpn_config;
1387
1388         if (target_num == cdns->pdi_loopback_target &&
1389             cdns->pdi_loopback_source != -1) {
1390                 source_num = cdns->pdi_loopback_source;
1391                 override = true;
1392         }
1393
1394         if (bank) {
1395                 dpn_config_off_source = CDNS_DPN_B1_CONFIG(source_num);
1396                 dpn_config_off_target = CDNS_DPN_B1_CONFIG(target_num);
1397         } else {
1398                 dpn_config_off_source = CDNS_DPN_B0_CONFIG(source_num);
1399                 dpn_config_off_target = CDNS_DPN_B0_CONFIG(target_num);
1400         }
1401
1402         dpn_config = cdns_readl(cdns, dpn_config_off_source);
1403
1404         /* use port params if there is no loopback, otherwise use source as is */
1405         if (!override) {
1406                 u32p_replace_bits(&dpn_config, p_params->bps - 1, CDNS_DPN_CONFIG_WL);
1407                 u32p_replace_bits(&dpn_config, p_params->flow_mode, CDNS_DPN_CONFIG_PORT_FLOW);
1408                 u32p_replace_bits(&dpn_config, p_params->data_mode, CDNS_DPN_CONFIG_PORT_DAT);
1409         }
1410
1411         cdns_writel(cdns, dpn_config_off_target, dpn_config);
1412
1413         return 0;
1414 }
1415
1416 static int cdns_transport_params(struct sdw_bus *bus,
1417                                  struct sdw_transport_params *t_params,
1418                                  enum sdw_reg_bank bank)
1419 {
1420         struct sdw_cdns *cdns = bus_to_cdns(bus);
1421         int dpn_config;
1422         int dpn_config_off_source;
1423         int dpn_config_off_target;
1424         int dpn_hctrl;
1425         int dpn_hctrl_off_source;
1426         int dpn_hctrl_off_target;
1427         int dpn_offsetctrl;
1428         int dpn_offsetctrl_off_source;
1429         int dpn_offsetctrl_off_target;
1430         int dpn_samplectrl;
1431         int dpn_samplectrl_off_source;
1432         int dpn_samplectrl_off_target;
1433         int source_num = t_params->port_num;
1434         int target_num = t_params->port_num;
1435         bool override = false;
1436
1437         if (target_num == cdns->pdi_loopback_target &&
1438             cdns->pdi_loopback_source != -1) {
1439                 source_num = cdns->pdi_loopback_source;
1440                 override = true;
1441         }
1442
1443         /*
1444          * Note: Only full data port is supported on the Master side for
1445          * both PCM and PDM ports.
1446          */
1447
1448         if (bank) {
1449                 dpn_config_off_source = CDNS_DPN_B1_CONFIG(source_num);
1450                 dpn_hctrl_off_source = CDNS_DPN_B1_HCTRL(source_num);
1451                 dpn_offsetctrl_off_source = CDNS_DPN_B1_OFFSET_CTRL(source_num);
1452                 dpn_samplectrl_off_source = CDNS_DPN_B1_SAMPLE_CTRL(source_num);
1453
1454                 dpn_config_off_target = CDNS_DPN_B1_CONFIG(target_num);
1455                 dpn_hctrl_off_target = CDNS_DPN_B1_HCTRL(target_num);
1456                 dpn_offsetctrl_off_target = CDNS_DPN_B1_OFFSET_CTRL(target_num);
1457                 dpn_samplectrl_off_target = CDNS_DPN_B1_SAMPLE_CTRL(target_num);
1458
1459         } else {
1460                 dpn_config_off_source = CDNS_DPN_B0_CONFIG(source_num);
1461                 dpn_hctrl_off_source = CDNS_DPN_B0_HCTRL(source_num);
1462                 dpn_offsetctrl_off_source = CDNS_DPN_B0_OFFSET_CTRL(source_num);
1463                 dpn_samplectrl_off_source = CDNS_DPN_B0_SAMPLE_CTRL(source_num);
1464
1465                 dpn_config_off_target = CDNS_DPN_B0_CONFIG(target_num);
1466                 dpn_hctrl_off_target = CDNS_DPN_B0_HCTRL(target_num);
1467                 dpn_offsetctrl_off_target = CDNS_DPN_B0_OFFSET_CTRL(target_num);
1468                 dpn_samplectrl_off_target = CDNS_DPN_B0_SAMPLE_CTRL(target_num);
1469         }
1470
1471         dpn_config = cdns_readl(cdns, dpn_config_off_source);
1472         if (!override) {
1473                 u32p_replace_bits(&dpn_config, t_params->blk_grp_ctrl, CDNS_DPN_CONFIG_BGC);
1474                 u32p_replace_bits(&dpn_config, t_params->blk_pkg_mode, CDNS_DPN_CONFIG_BPM);
1475         }
1476         cdns_writel(cdns, dpn_config_off_target, dpn_config);
1477
1478         if (!override) {
1479                 dpn_offsetctrl = 0;
1480                 u32p_replace_bits(&dpn_offsetctrl, t_params->offset1, CDNS_DPN_OFFSET_CTRL_1);
1481                 u32p_replace_bits(&dpn_offsetctrl, t_params->offset2, CDNS_DPN_OFFSET_CTRL_2);
1482         } else {
1483                 dpn_offsetctrl = cdns_readl(cdns, dpn_offsetctrl_off_source);
1484         }
1485         cdns_writel(cdns, dpn_offsetctrl_off_target,  dpn_offsetctrl);
1486
1487         if (!override) {
1488                 dpn_hctrl = 0;
1489                 u32p_replace_bits(&dpn_hctrl, t_params->hstart, CDNS_DPN_HCTRL_HSTART);
1490                 u32p_replace_bits(&dpn_hctrl, t_params->hstop, CDNS_DPN_HCTRL_HSTOP);
1491                 u32p_replace_bits(&dpn_hctrl, t_params->lane_ctrl, CDNS_DPN_HCTRL_LCTRL);
1492         } else {
1493                 dpn_hctrl = cdns_readl(cdns, dpn_hctrl_off_source);
1494         }
1495         cdns_writel(cdns, dpn_hctrl_off_target, dpn_hctrl);
1496
1497         if (!override)
1498                 dpn_samplectrl = t_params->sample_interval - 1;
1499         else
1500                 dpn_samplectrl = cdns_readl(cdns, dpn_samplectrl_off_source);
1501         cdns_writel(cdns, dpn_samplectrl_off_target, dpn_samplectrl);
1502
1503         return 0;
1504 }
1505
1506 static int cdns_port_enable(struct sdw_bus *bus,
1507                             struct sdw_enable_ch *enable_ch, unsigned int bank)
1508 {
1509         struct sdw_cdns *cdns = bus_to_cdns(bus);
1510         int dpn_chnen_off, ch_mask;
1511
1512         if (bank)
1513                 dpn_chnen_off = CDNS_DPN_B1_CH_EN(enable_ch->port_num);
1514         else
1515                 dpn_chnen_off = CDNS_DPN_B0_CH_EN(enable_ch->port_num);
1516
1517         ch_mask = enable_ch->ch_mask * enable_ch->enable;
1518         cdns_writel(cdns, dpn_chnen_off, ch_mask);
1519
1520         return 0;
1521 }
1522
1523 static const struct sdw_master_port_ops cdns_port_ops = {
1524         .dpn_set_port_params = cdns_port_params,
1525         .dpn_set_port_transport_params = cdns_transport_params,
1526         .dpn_port_enable_ch = cdns_port_enable,
1527 };
1528
1529 /**
1530  * sdw_cdns_is_clock_stop: Check clock status
1531  *
1532  * @cdns: Cadence instance
1533  */
1534 bool sdw_cdns_is_clock_stop(struct sdw_cdns *cdns)
1535 {
1536         return !!(cdns_readl(cdns, CDNS_MCP_STAT) & CDNS_MCP_STAT_CLK_STOP);
1537 }
1538 EXPORT_SYMBOL(sdw_cdns_is_clock_stop);
1539
1540 /**
1541  * sdw_cdns_clock_stop: Cadence clock stop configuration routine
1542  *
1543  * @cdns: Cadence instance
1544  * @block_wake: prevent wakes if required by the platform
1545  */
1546 int sdw_cdns_clock_stop(struct sdw_cdns *cdns, bool block_wake)
1547 {
1548         bool slave_present = false;
1549         struct sdw_slave *slave;
1550         int ret;
1551
1552         sdw_cdns_check_self_clearing_bits(cdns, __func__, false, 0);
1553
1554         /* Check suspend status */
1555         if (sdw_cdns_is_clock_stop(cdns)) {
1556                 dev_dbg(cdns->dev, "Clock is already stopped\n");
1557                 return 0;
1558         }
1559
1560         /*
1561          * Before entering clock stop we mask the Slave
1562          * interrupts. This helps avoid having to deal with e.g. a
1563          * Slave becoming UNATTACHED while the clock is being stopped
1564          */
1565         cdns_enable_slave_interrupts(cdns, false);
1566
1567         /*
1568          * For specific platforms, it is required to be able to put
1569          * master into a state in which it ignores wake-up trials
1570          * in clock stop state
1571          */
1572         if (block_wake)
1573                 cdns_updatel(cdns, CDNS_MCP_CONTROL,
1574                              CDNS_MCP_CONTROL_BLOCK_WAKEUP,
1575                              CDNS_MCP_CONTROL_BLOCK_WAKEUP);
1576
1577         list_for_each_entry(slave, &cdns->bus.slaves, node) {
1578                 if (slave->status == SDW_SLAVE_ATTACHED ||
1579                     slave->status == SDW_SLAVE_ALERT) {
1580                         slave_present = true;
1581                         break;
1582                 }
1583         }
1584
1585         /* commit changes */
1586         ret = cdns_config_update(cdns);
1587         if (ret < 0) {
1588                 dev_err(cdns->dev, "%s: config_update failed\n", __func__);
1589                 return ret;
1590         }
1591
1592         /* Prepare slaves for clock stop */
1593         if (slave_present) {
1594                 ret = sdw_bus_prep_clk_stop(&cdns->bus);
1595                 if (ret < 0 && ret != -ENODATA) {
1596                         dev_err(cdns->dev, "prepare clock stop failed %d\n", ret);
1597                         return ret;
1598                 }
1599         }
1600
1601         /*
1602          * Enter clock stop mode and only report errors if there are
1603          * Slave devices present (ALERT or ATTACHED)
1604          */
1605         ret = sdw_bus_clk_stop(&cdns->bus);
1606         if (ret < 0 && slave_present && ret != -ENODATA) {
1607                 dev_err(cdns->dev, "bus clock stop failed %d\n", ret);
1608                 return ret;
1609         }
1610
1611         ret = cdns_set_wait(cdns, CDNS_MCP_STAT,
1612                             CDNS_MCP_STAT_CLK_STOP,
1613                             CDNS_MCP_STAT_CLK_STOP);
1614         if (ret < 0)
1615                 dev_err(cdns->dev, "Clock stop failed %d\n", ret);
1616
1617         return ret;
1618 }
1619 EXPORT_SYMBOL(sdw_cdns_clock_stop);
1620
1621 /**
1622  * sdw_cdns_clock_restart: Cadence PM clock restart configuration routine
1623  *
1624  * @cdns: Cadence instance
1625  * @bus_reset: context may be lost while in low power modes and the bus
1626  * may require a Severe Reset and re-enumeration after a wake.
1627  */
1628 int sdw_cdns_clock_restart(struct sdw_cdns *cdns, bool bus_reset)
1629 {
1630         int ret;
1631
1632         /* unmask Slave interrupts that were masked when stopping the clock */
1633         cdns_enable_slave_interrupts(cdns, true);
1634
1635         ret = cdns_clear_bit(cdns, CDNS_MCP_CONTROL,
1636                              CDNS_MCP_CONTROL_CLK_STOP_CLR);
1637         if (ret < 0) {
1638                 dev_err(cdns->dev, "Couldn't exit from clock stop\n");
1639                 return ret;
1640         }
1641
1642         ret = cdns_set_wait(cdns, CDNS_MCP_STAT, CDNS_MCP_STAT_CLK_STOP, 0);
1643         if (ret < 0) {
1644                 dev_err(cdns->dev, "clock stop exit failed %d\n", ret);
1645                 return ret;
1646         }
1647
1648         cdns_updatel(cdns, CDNS_MCP_CONTROL,
1649                      CDNS_MCP_CONTROL_BLOCK_WAKEUP, 0);
1650
1651         cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_ACCEPT,
1652                      CDNS_MCP_CONTROL_CMD_ACCEPT);
1653
1654         if (!bus_reset) {
1655
1656                 /* enable bus operations with clock and data */
1657                 cdns_updatel(cdns, CDNS_MCP_CONFIG,
1658                              CDNS_MCP_CONFIG_OP,
1659                              CDNS_MCP_CONFIG_OP_NORMAL);
1660
1661                 ret = cdns_config_update(cdns);
1662                 if (ret < 0) {
1663                         dev_err(cdns->dev, "%s: config_update failed\n", __func__);
1664                         return ret;
1665                 }
1666
1667                 ret = sdw_bus_exit_clk_stop(&cdns->bus);
1668                 if (ret < 0)
1669                         dev_err(cdns->dev, "bus failed to exit clock stop %d\n", ret);
1670         }
1671
1672         return ret;
1673 }
1674 EXPORT_SYMBOL(sdw_cdns_clock_restart);
1675
1676 /**
1677  * sdw_cdns_probe() - Cadence probe routine
1678  * @cdns: Cadence instance
1679  */
1680 int sdw_cdns_probe(struct sdw_cdns *cdns)
1681 {
1682         init_completion(&cdns->tx_complete);
1683         cdns->bus.port_ops = &cdns_port_ops;
1684
1685         INIT_WORK(&cdns->work, cdns_update_slave_status_work);
1686         return 0;
1687 }
1688 EXPORT_SYMBOL(sdw_cdns_probe);
1689
1690 int cdns_set_sdw_stream(struct snd_soc_dai *dai,
1691                         void *stream, int direction)
1692 {
1693         struct sdw_cdns *cdns = snd_soc_dai_get_drvdata(dai);
1694         struct sdw_cdns_dma_data *dma;
1695
1696         if (stream) {
1697                 /* first paranoia check */
1698                 if (direction == SNDRV_PCM_STREAM_PLAYBACK)
1699                         dma = dai->playback_dma_data;
1700                 else
1701                         dma = dai->capture_dma_data;
1702
1703                 if (dma) {
1704                         dev_err(dai->dev,
1705                                 "dma_data already allocated for dai %s\n",
1706                                 dai->name);
1707                         return -EINVAL;
1708                 }
1709
1710                 /* allocate and set dma info */
1711                 dma = kzalloc(sizeof(*dma), GFP_KERNEL);
1712                 if (!dma)
1713                         return -ENOMEM;
1714
1715                 dma->stream_type = SDW_STREAM_PCM;
1716
1717                 dma->bus = &cdns->bus;
1718                 dma->link_id = cdns->instance;
1719
1720                 dma->stream = stream;
1721
1722                 if (direction == SNDRV_PCM_STREAM_PLAYBACK)
1723                         dai->playback_dma_data = dma;
1724                 else
1725                         dai->capture_dma_data = dma;
1726         } else {
1727                 /* for NULL stream we release allocated dma_data */
1728                 if (direction == SNDRV_PCM_STREAM_PLAYBACK) {
1729                         kfree(dai->playback_dma_data);
1730                         dai->playback_dma_data = NULL;
1731                 } else {
1732                         kfree(dai->capture_dma_data);
1733                         dai->capture_dma_data = NULL;
1734                 }
1735         }
1736         return 0;
1737 }
1738 EXPORT_SYMBOL(cdns_set_sdw_stream);
1739
1740 /**
1741  * cdns_find_pdi() - Find a free PDI
1742  *
1743  * @cdns: Cadence instance
1744  * @offset: Starting offset
1745  * @num: Number of PDIs
1746  * @pdi: PDI instances
1747  * @dai_id: DAI id
1748  *
1749  * Find a PDI for a given PDI array. The PDI num and dai_id are
1750  * expected to match, return NULL otherwise.
1751  */
1752 static struct sdw_cdns_pdi *cdns_find_pdi(struct sdw_cdns *cdns,
1753                                           unsigned int offset,
1754                                           unsigned int num,
1755                                           struct sdw_cdns_pdi *pdi,
1756                                           int dai_id)
1757 {
1758         int i;
1759
1760         for (i = offset; i < offset + num; i++)
1761                 if (pdi[i].num == dai_id)
1762                         return &pdi[i];
1763
1764         return NULL;
1765 }
1766
1767 /**
1768  * sdw_cdns_config_stream: Configure a stream
1769  *
1770  * @cdns: Cadence instance
1771  * @ch: Channel count
1772  * @dir: Data direction
1773  * @pdi: PDI to be used
1774  */
1775 void sdw_cdns_config_stream(struct sdw_cdns *cdns,
1776                             u32 ch, u32 dir, struct sdw_cdns_pdi *pdi)
1777 {
1778         u32 offset, val = 0;
1779
1780         if (dir == SDW_DATA_DIR_RX) {
1781                 val = CDNS_PORTCTRL_DIRN;
1782
1783                 if (cdns->bus.params.m_data_mode != SDW_PORT_DATA_MODE_NORMAL)
1784                         val |= CDNS_PORTCTRL_TEST_FAILED;
1785         }
1786         offset = CDNS_PORTCTRL + pdi->num * CDNS_PORT_OFFSET;
1787         cdns_updatel(cdns, offset,
1788                      CDNS_PORTCTRL_DIRN | CDNS_PORTCTRL_TEST_FAILED,
1789                      val);
1790
1791         val = pdi->num;
1792         val |= CDNS_PDI_CONFIG_SOFT_RESET;
1793         val |= FIELD_PREP(CDNS_PDI_CONFIG_CHANNEL, (1 << ch) - 1);
1794         cdns_writel(cdns, CDNS_PDI_CONFIG(pdi->num), val);
1795 }
1796 EXPORT_SYMBOL(sdw_cdns_config_stream);
1797
1798 /**
1799  * sdw_cdns_alloc_pdi() - Allocate a PDI
1800  *
1801  * @cdns: Cadence instance
1802  * @stream: Stream to be allocated
1803  * @ch: Channel count
1804  * @dir: Data direction
1805  * @dai_id: DAI id
1806  */
1807 struct sdw_cdns_pdi *sdw_cdns_alloc_pdi(struct sdw_cdns *cdns,
1808                                         struct sdw_cdns_streams *stream,
1809                                         u32 ch, u32 dir, int dai_id)
1810 {
1811         struct sdw_cdns_pdi *pdi = NULL;
1812
1813         if (dir == SDW_DATA_DIR_RX)
1814                 pdi = cdns_find_pdi(cdns, 0, stream->num_in, stream->in,
1815                                     dai_id);
1816         else
1817                 pdi = cdns_find_pdi(cdns, 0, stream->num_out, stream->out,
1818                                     dai_id);
1819
1820         /* check if we found a PDI, else find in bi-directional */
1821         if (!pdi)
1822                 pdi = cdns_find_pdi(cdns, 2, stream->num_bd, stream->bd,
1823                                     dai_id);
1824
1825         if (pdi) {
1826                 pdi->l_ch_num = 0;
1827                 pdi->h_ch_num = ch - 1;
1828                 pdi->dir = dir;
1829                 pdi->ch_count = ch;
1830         }
1831
1832         return pdi;
1833 }
1834 EXPORT_SYMBOL(sdw_cdns_alloc_pdi);
1835
1836 MODULE_LICENSE("Dual BSD/GPL");
1837 MODULE_DESCRIPTION("Cadence Soundwire Library");