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