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