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