1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2 // Copyright(c) 2015-18 Intel Corporation. 3 4 /* 5 * stream.c - SoundWire Bus stream operations. 6 */ 7 8 #include <linux/delay.h> 9 #include <linux/device.h> 10 #include <linux/init.h> 11 #include <linux/module.h> 12 #include <linux/mod_devicetable.h> 13 #include <linux/slab.h> 14 #include <linux/soundwire/sdw_registers.h> 15 #include <linux/soundwire/sdw.h> 16 #include "bus.h" 17 18 /* 19 * Array of supported rows and columns as per MIPI SoundWire Specification 1.1 20 * 21 * The rows are arranged as per the array index value programmed 22 * in register. The index 15 has dummy value 0 in order to fill hole. 23 */ 24 int rows[SDW_FRAME_ROWS] = {48, 50, 60, 64, 75, 80, 125, 147, 25 96, 100, 120, 128, 150, 160, 250, 0, 26 192, 200, 240, 256, 72, 144, 90, 180}; 27 28 int cols[SDW_FRAME_COLS] = {2, 4, 6, 8, 10, 12, 14, 16}; 29 30 static int sdw_find_col_index(int col) 31 { 32 int i; 33 34 for (i = 0; i < SDW_FRAME_COLS; i++) { 35 if (cols[i] == col) 36 return i; 37 } 38 39 pr_warn("Requested column not found, selecting lowest column no: 2\n"); 40 return 0; 41 } 42 43 static int sdw_find_row_index(int row) 44 { 45 int i; 46 47 for (i = 0; i < SDW_FRAME_ROWS; i++) { 48 if (rows[i] == row) 49 return i; 50 } 51 52 pr_warn("Requested row not found, selecting lowest row no: 48\n"); 53 return 0; 54 } 55 static int _sdw_program_slave_port_params(struct sdw_bus *bus, 56 struct sdw_slave *slave, 57 struct sdw_transport_params *t_params, 58 enum sdw_dpn_type type) 59 { 60 u32 addr1, addr2, addr3, addr4; 61 int ret; 62 u16 wbuf; 63 64 if (bus->params.next_bank) { 65 addr1 = SDW_DPN_OFFSETCTRL2_B1(t_params->port_num); 66 addr2 = SDW_DPN_BLOCKCTRL3_B1(t_params->port_num); 67 addr3 = SDW_DPN_SAMPLECTRL2_B1(t_params->port_num); 68 addr4 = SDW_DPN_HCTRL_B1(t_params->port_num); 69 } else { 70 addr1 = SDW_DPN_OFFSETCTRL2_B0(t_params->port_num); 71 addr2 = SDW_DPN_BLOCKCTRL3_B0(t_params->port_num); 72 addr3 = SDW_DPN_SAMPLECTRL2_B0(t_params->port_num); 73 addr4 = SDW_DPN_HCTRL_B0(t_params->port_num); 74 } 75 76 /* Program DPN_OffsetCtrl2 registers */ 77 ret = sdw_write(slave, addr1, t_params->offset2); 78 if (ret < 0) { 79 dev_err(bus->dev, "DPN_OffsetCtrl2 register write failed"); 80 return ret; 81 } 82 83 /* Program DPN_BlockCtrl3 register */ 84 ret = sdw_write(slave, addr2, t_params->blk_pkg_mode); 85 if (ret < 0) { 86 dev_err(bus->dev, "DPN_BlockCtrl3 register write failed"); 87 return ret; 88 } 89 90 /* 91 * Data ports are FULL, SIMPLE and REDUCED. This function handles 92 * FULL and REDUCED only and and beyond this point only FULL is 93 * handled, so bail out if we are not FULL data port type 94 */ 95 if (type != SDW_DPN_FULL) 96 return ret; 97 98 /* Program DPN_SampleCtrl2 register */ 99 wbuf = (t_params->sample_interval - 1); 100 wbuf &= SDW_DPN_SAMPLECTRL_HIGH; 101 wbuf >>= SDW_REG_SHIFT(SDW_DPN_SAMPLECTRL_HIGH); 102 103 ret = sdw_write(slave, addr3, wbuf); 104 if (ret < 0) { 105 dev_err(bus->dev, "DPN_SampleCtrl2 register write failed"); 106 return ret; 107 } 108 109 /* Program DPN_HCtrl register */ 110 wbuf = t_params->hstart; 111 wbuf <<= SDW_REG_SHIFT(SDW_DPN_HCTRL_HSTART); 112 wbuf |= t_params->hstop; 113 114 ret = sdw_write(slave, addr4, wbuf); 115 if (ret < 0) 116 dev_err(bus->dev, "DPN_HCtrl register write failed"); 117 118 return ret; 119 } 120 121 static int sdw_program_slave_port_params(struct sdw_bus *bus, 122 struct sdw_slave_runtime *s_rt, 123 struct sdw_port_runtime *p_rt) 124 { 125 struct sdw_transport_params *t_params = &p_rt->transport_params; 126 struct sdw_port_params *p_params = &p_rt->port_params; 127 struct sdw_slave_prop *slave_prop = &s_rt->slave->prop; 128 u32 addr1, addr2, addr3, addr4, addr5, addr6; 129 struct sdw_dpn_prop *dpn_prop; 130 int ret; 131 u8 wbuf; 132 133 dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave, 134 s_rt->direction, 135 t_params->port_num); 136 if (!dpn_prop) 137 return -EINVAL; 138 139 addr1 = SDW_DPN_PORTCTRL(t_params->port_num); 140 addr2 = SDW_DPN_BLOCKCTRL1(t_params->port_num); 141 142 if (bus->params.next_bank) { 143 addr3 = SDW_DPN_SAMPLECTRL1_B1(t_params->port_num); 144 addr4 = SDW_DPN_OFFSETCTRL1_B1(t_params->port_num); 145 addr5 = SDW_DPN_BLOCKCTRL2_B1(t_params->port_num); 146 addr6 = SDW_DPN_LANECTRL_B1(t_params->port_num); 147 148 } else { 149 addr3 = SDW_DPN_SAMPLECTRL1_B0(t_params->port_num); 150 addr4 = SDW_DPN_OFFSETCTRL1_B0(t_params->port_num); 151 addr5 = SDW_DPN_BLOCKCTRL2_B0(t_params->port_num); 152 addr6 = SDW_DPN_LANECTRL_B0(t_params->port_num); 153 } 154 155 /* Program DPN_PortCtrl register */ 156 wbuf = p_params->data_mode << SDW_REG_SHIFT(SDW_DPN_PORTCTRL_DATAMODE); 157 wbuf |= p_params->flow_mode; 158 159 ret = sdw_update(s_rt->slave, addr1, 0xF, wbuf); 160 if (ret < 0) { 161 dev_err(&s_rt->slave->dev, 162 "DPN_PortCtrl register write failed for port %d", 163 t_params->port_num); 164 return ret; 165 } 166 167 /* Program DPN_BlockCtrl1 register */ 168 ret = sdw_write(s_rt->slave, addr2, (p_params->bps - 1)); 169 if (ret < 0) { 170 dev_err(&s_rt->slave->dev, 171 "DPN_BlockCtrl1 register write failed for port %d", 172 t_params->port_num); 173 return ret; 174 } 175 176 /* Program DPN_SampleCtrl1 register */ 177 wbuf = (t_params->sample_interval - 1) & SDW_DPN_SAMPLECTRL_LOW; 178 ret = sdw_write(s_rt->slave, addr3, wbuf); 179 if (ret < 0) { 180 dev_err(&s_rt->slave->dev, 181 "DPN_SampleCtrl1 register write failed for port %d", 182 t_params->port_num); 183 return ret; 184 } 185 186 /* Program DPN_OffsetCtrl1 registers */ 187 ret = sdw_write(s_rt->slave, addr4, t_params->offset1); 188 if (ret < 0) { 189 dev_err(&s_rt->slave->dev, 190 "DPN_OffsetCtrl1 register write failed for port %d", 191 t_params->port_num); 192 return ret; 193 } 194 195 /* Program DPN_BlockCtrl2 register*/ 196 if (t_params->blk_grp_ctrl_valid) { 197 ret = sdw_write(s_rt->slave, addr5, t_params->blk_grp_ctrl); 198 if (ret < 0) { 199 dev_err(&s_rt->slave->dev, 200 "DPN_BlockCtrl2 reg write failed for port %d", 201 t_params->port_num); 202 return ret; 203 } 204 } 205 206 /* program DPN_LaneCtrl register */ 207 if (slave_prop->lane_control_support) { 208 ret = sdw_write(s_rt->slave, addr6, t_params->lane_ctrl); 209 if (ret < 0) { 210 dev_err(&s_rt->slave->dev, 211 "DPN_LaneCtrl register write failed for port %d", 212 t_params->port_num); 213 return ret; 214 } 215 } 216 217 if (dpn_prop->type != SDW_DPN_SIMPLE) { 218 ret = _sdw_program_slave_port_params(bus, s_rt->slave, 219 t_params, dpn_prop->type); 220 if (ret < 0) 221 dev_err(&s_rt->slave->dev, 222 "Transport reg write failed for port: %d", 223 t_params->port_num); 224 } 225 226 return ret; 227 } 228 229 static int sdw_program_master_port_params(struct sdw_bus *bus, 230 struct sdw_port_runtime *p_rt) 231 { 232 int ret; 233 234 /* 235 * we need to set transport and port parameters for the port. 236 * Transport parameters refers to the smaple interval, offsets and 237 * hstart/stop etc of the data. Port parameters refers to word 238 * length, flow mode etc of the port 239 */ 240 ret = bus->port_ops->dpn_set_port_transport_params(bus, 241 &p_rt->transport_params, 242 bus->params.next_bank); 243 if (ret < 0) 244 return ret; 245 246 return bus->port_ops->dpn_set_port_params(bus, 247 &p_rt->port_params, 248 bus->params.next_bank); 249 } 250 251 /** 252 * sdw_program_port_params() - Programs transport parameters of Master(s) 253 * and Slave(s) 254 * 255 * @m_rt: Master stream runtime 256 */ 257 static int sdw_program_port_params(struct sdw_master_runtime *m_rt) 258 { 259 struct sdw_slave_runtime *s_rt = NULL; 260 struct sdw_bus *bus = m_rt->bus; 261 struct sdw_port_runtime *p_rt; 262 int ret = 0; 263 264 /* Program transport & port parameters for Slave(s) */ 265 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) { 266 list_for_each_entry(p_rt, &s_rt->port_list, port_node) { 267 ret = sdw_program_slave_port_params(bus, s_rt, p_rt); 268 if (ret < 0) 269 return ret; 270 } 271 } 272 273 /* Program transport & port parameters for Master(s) */ 274 list_for_each_entry(p_rt, &m_rt->port_list, port_node) { 275 ret = sdw_program_master_port_params(bus, p_rt); 276 if (ret < 0) 277 return ret; 278 } 279 280 return 0; 281 } 282 283 /** 284 * sdw_enable_disable_slave_ports: Enable/disable slave data port 285 * 286 * @bus: bus instance 287 * @s_rt: slave runtime 288 * @p_rt: port runtime 289 * @en: enable or disable operation 290 * 291 * This function only sets the enable/disable bits in the relevant bank, the 292 * actual enable/disable is done with a bank switch 293 */ 294 static int sdw_enable_disable_slave_ports(struct sdw_bus *bus, 295 struct sdw_slave_runtime *s_rt, 296 struct sdw_port_runtime *p_rt, bool en) 297 { 298 struct sdw_transport_params *t_params = &p_rt->transport_params; 299 u32 addr; 300 int ret; 301 302 if (bus->params.next_bank) 303 addr = SDW_DPN_CHANNELEN_B1(p_rt->num); 304 else 305 addr = SDW_DPN_CHANNELEN_B0(p_rt->num); 306 307 /* 308 * Since bus doesn't support sharing a port across two streams, 309 * it is safe to reset this register 310 */ 311 if (en) 312 ret = sdw_update(s_rt->slave, addr, 0xFF, p_rt->ch_mask); 313 else 314 ret = sdw_update(s_rt->slave, addr, 0xFF, 0x0); 315 316 if (ret < 0) 317 dev_err(&s_rt->slave->dev, 318 "Slave chn_en reg write failed:%d port:%d", 319 ret, t_params->port_num); 320 321 return ret; 322 } 323 324 static int sdw_enable_disable_master_ports(struct sdw_master_runtime *m_rt, 325 struct sdw_port_runtime *p_rt, bool en) 326 { 327 struct sdw_transport_params *t_params = &p_rt->transport_params; 328 struct sdw_bus *bus = m_rt->bus; 329 struct sdw_enable_ch enable_ch; 330 int ret = 0; 331 332 enable_ch.port_num = p_rt->num; 333 enable_ch.ch_mask = p_rt->ch_mask; 334 enable_ch.enable = en; 335 336 /* Perform Master port channel(s) enable/disable */ 337 if (bus->port_ops->dpn_port_enable_ch) { 338 ret = bus->port_ops->dpn_port_enable_ch(bus, 339 &enable_ch, bus->params.next_bank); 340 if (ret < 0) { 341 dev_err(bus->dev, 342 "Master chn_en write failed:%d port:%d", 343 ret, t_params->port_num); 344 return ret; 345 } 346 } else { 347 dev_err(bus->dev, 348 "dpn_port_enable_ch not supported, %s failed\n", 349 en ? "enable" : "disable"); 350 return -EINVAL; 351 } 352 353 return 0; 354 } 355 356 /** 357 * sdw_enable_disable_ports() - Enable/disable port(s) for Master and 358 * Slave(s) 359 * 360 * @m_rt: Master stream runtime 361 * @en: mode (enable/disable) 362 */ 363 static int sdw_enable_disable_ports(struct sdw_master_runtime *m_rt, bool en) 364 { 365 struct sdw_port_runtime *s_port, *m_port; 366 struct sdw_slave_runtime *s_rt = NULL; 367 int ret = 0; 368 369 /* Enable/Disable Slave port(s) */ 370 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) { 371 list_for_each_entry(s_port, &s_rt->port_list, port_node) { 372 ret = sdw_enable_disable_slave_ports(m_rt->bus, s_rt, 373 s_port, en); 374 if (ret < 0) 375 return ret; 376 } 377 } 378 379 /* Enable/Disable Master port(s) */ 380 list_for_each_entry(m_port, &m_rt->port_list, port_node) { 381 ret = sdw_enable_disable_master_ports(m_rt, m_port, en); 382 if (ret < 0) 383 return ret; 384 } 385 386 return 0; 387 } 388 389 static int sdw_do_port_prep(struct sdw_slave_runtime *s_rt, 390 struct sdw_prepare_ch prep_ch, enum sdw_port_prep_ops cmd) 391 { 392 const struct sdw_slave_ops *ops = s_rt->slave->ops; 393 int ret; 394 395 if (ops->port_prep) { 396 ret = ops->port_prep(s_rt->slave, &prep_ch, cmd); 397 if (ret < 0) { 398 dev_err(&s_rt->slave->dev, 399 "Slave Port Prep cmd %d failed: %d", cmd, ret); 400 return ret; 401 } 402 } 403 404 return 0; 405 } 406 407 static int sdw_prep_deprep_slave_ports(struct sdw_bus *bus, 408 struct sdw_slave_runtime *s_rt, 409 struct sdw_port_runtime *p_rt, bool prep) 410 { 411 struct completion *port_ready = NULL; 412 struct sdw_dpn_prop *dpn_prop; 413 struct sdw_prepare_ch prep_ch; 414 unsigned int time_left; 415 bool intr = false; 416 int ret = 0, val; 417 u32 addr; 418 419 prep_ch.num = p_rt->num; 420 prep_ch.ch_mask = p_rt->ch_mask; 421 422 dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave, 423 s_rt->direction, 424 prep_ch.num); 425 if (!dpn_prop) { 426 dev_err(bus->dev, 427 "Slave Port:%d properties not found", prep_ch.num); 428 return -EINVAL; 429 } 430 431 prep_ch.prepare = prep; 432 433 prep_ch.bank = bus->params.next_bank; 434 435 if (dpn_prop->device_interrupts || !dpn_prop->simple_ch_prep_sm) 436 intr = true; 437 438 /* 439 * Enable interrupt before Port prepare. 440 * For Port de-prepare, it is assumed that port 441 * was prepared earlier 442 */ 443 if (prep && intr) { 444 ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep, 445 dpn_prop->device_interrupts); 446 if (ret < 0) 447 return ret; 448 } 449 450 /* Inform slave about the impending port prepare */ 451 sdw_do_port_prep(s_rt, prep_ch, SDW_OPS_PORT_PRE_PREP); 452 453 /* Prepare Slave port implementing CP_SM */ 454 if (!dpn_prop->simple_ch_prep_sm) { 455 addr = SDW_DPN_PREPARECTRL(p_rt->num); 456 457 if (prep) 458 ret = sdw_update(s_rt->slave, addr, 459 0xFF, p_rt->ch_mask); 460 else 461 ret = sdw_update(s_rt->slave, addr, 0xFF, 0x0); 462 463 if (ret < 0) { 464 dev_err(&s_rt->slave->dev, 465 "Slave prep_ctrl reg write failed"); 466 return ret; 467 } 468 469 /* Wait for completion on port ready */ 470 port_ready = &s_rt->slave->port_ready[prep_ch.num]; 471 time_left = wait_for_completion_timeout(port_ready, 472 msecs_to_jiffies(dpn_prop->ch_prep_timeout)); 473 474 val = sdw_read(s_rt->slave, SDW_DPN_PREPARESTATUS(p_rt->num)); 475 val &= p_rt->ch_mask; 476 if (!time_left || val) { 477 dev_err(&s_rt->slave->dev, 478 "Chn prep failed for port:%d", prep_ch.num); 479 return -ETIMEDOUT; 480 } 481 } 482 483 /* Inform slaves about ports prepared */ 484 sdw_do_port_prep(s_rt, prep_ch, SDW_OPS_PORT_POST_PREP); 485 486 /* Disable interrupt after Port de-prepare */ 487 if (!prep && intr) 488 ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep, 489 dpn_prop->device_interrupts); 490 491 return ret; 492 } 493 494 static int sdw_prep_deprep_master_ports(struct sdw_master_runtime *m_rt, 495 struct sdw_port_runtime *p_rt, bool prep) 496 { 497 struct sdw_transport_params *t_params = &p_rt->transport_params; 498 struct sdw_bus *bus = m_rt->bus; 499 const struct sdw_master_port_ops *ops = bus->port_ops; 500 struct sdw_prepare_ch prep_ch; 501 int ret = 0; 502 503 prep_ch.num = p_rt->num; 504 prep_ch.ch_mask = p_rt->ch_mask; 505 prep_ch.prepare = prep; /* Prepare/De-prepare */ 506 prep_ch.bank = bus->params.next_bank; 507 508 /* Pre-prepare/Pre-deprepare port(s) */ 509 if (ops->dpn_port_prep) { 510 ret = ops->dpn_port_prep(bus, &prep_ch); 511 if (ret < 0) { 512 dev_err(bus->dev, "Port prepare failed for port:%d", 513 t_params->port_num); 514 return ret; 515 } 516 } 517 518 return ret; 519 } 520 521 /** 522 * sdw_prep_deprep_ports() - Prepare/De-prepare port(s) for Master(s) and 523 * Slave(s) 524 * 525 * @m_rt: Master runtime handle 526 * @prep: Prepare or De-prepare 527 */ 528 static int sdw_prep_deprep_ports(struct sdw_master_runtime *m_rt, bool prep) 529 { 530 struct sdw_slave_runtime *s_rt = NULL; 531 struct sdw_port_runtime *p_rt; 532 int ret = 0; 533 534 /* Prepare/De-prepare Slave port(s) */ 535 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) { 536 list_for_each_entry(p_rt, &s_rt->port_list, port_node) { 537 ret = sdw_prep_deprep_slave_ports(m_rt->bus, s_rt, 538 p_rt, prep); 539 if (ret < 0) 540 return ret; 541 } 542 } 543 544 /* Prepare/De-prepare Master port(s) */ 545 list_for_each_entry(p_rt, &m_rt->port_list, port_node) { 546 ret = sdw_prep_deprep_master_ports(m_rt, p_rt, prep); 547 if (ret < 0) 548 return ret; 549 } 550 551 return ret; 552 } 553 554 /** 555 * sdw_notify_config() - Notify bus configuration 556 * 557 * @m_rt: Master runtime handle 558 * 559 * This function notifies the Master(s) and Slave(s) of the 560 * new bus configuration. 561 */ 562 static int sdw_notify_config(struct sdw_master_runtime *m_rt) 563 { 564 struct sdw_slave_runtime *s_rt; 565 struct sdw_bus *bus = m_rt->bus; 566 struct sdw_slave *slave; 567 int ret = 0; 568 569 if (bus->ops->set_bus_conf) { 570 ret = bus->ops->set_bus_conf(bus, &bus->params); 571 if (ret < 0) 572 return ret; 573 } 574 575 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) { 576 slave = s_rt->slave; 577 578 if (slave->ops->bus_config) { 579 ret = slave->ops->bus_config(slave, &bus->params); 580 if (ret < 0) 581 dev_err(bus->dev, "Notify Slave: %d failed", 582 slave->dev_num); 583 return ret; 584 } 585 } 586 587 return ret; 588 } 589 590 /** 591 * sdw_program_params() - Program transport and port parameters for Master(s) 592 * and Slave(s) 593 * 594 * @bus: SDW bus instance 595 */ 596 static int sdw_program_params(struct sdw_bus *bus) 597 { 598 struct sdw_master_runtime *m_rt = NULL; 599 int ret = 0; 600 601 list_for_each_entry(m_rt, &bus->m_rt_list, bus_node) { 602 ret = sdw_program_port_params(m_rt); 603 if (ret < 0) { 604 dev_err(bus->dev, 605 "Program transport params failed: %d", ret); 606 return ret; 607 } 608 609 ret = sdw_notify_config(m_rt); 610 if (ret < 0) { 611 dev_err(bus->dev, "Notify bus config failed: %d", ret); 612 return ret; 613 } 614 615 /* Enable port(s) on alternate bank for all active streams */ 616 if (m_rt->stream->state != SDW_STREAM_ENABLED) 617 continue; 618 619 ret = sdw_enable_disable_ports(m_rt, true); 620 if (ret < 0) { 621 dev_err(bus->dev, "Enable channel failed: %d", ret); 622 return ret; 623 } 624 } 625 626 return ret; 627 } 628 629 static int sdw_bank_switch(struct sdw_bus *bus) 630 { 631 int col_index, row_index; 632 struct sdw_msg *wr_msg; 633 u8 *wbuf = NULL; 634 int ret = 0; 635 u16 addr; 636 637 wr_msg = kzalloc(sizeof(*wr_msg), GFP_KERNEL); 638 if (!wr_msg) 639 return -ENOMEM; 640 641 wbuf = kzalloc(sizeof(*wbuf), GFP_KERNEL); 642 if (!wbuf) { 643 ret = -ENOMEM; 644 goto error_1; 645 } 646 647 /* Get row and column index to program register */ 648 col_index = sdw_find_col_index(bus->params.col); 649 row_index = sdw_find_row_index(bus->params.row); 650 wbuf[0] = col_index | (row_index << 3); 651 652 if (bus->params.next_bank) 653 addr = SDW_SCP_FRAMECTRL_B1; 654 else 655 addr = SDW_SCP_FRAMECTRL_B0; 656 657 sdw_fill_msg(wr_msg, NULL, addr, 1, SDW_BROADCAST_DEV_NUM, 658 SDW_MSG_FLAG_WRITE, wbuf); 659 wr_msg->ssp_sync = true; 660 661 ret = sdw_transfer(bus, wr_msg); 662 if (ret < 0) { 663 dev_err(bus->dev, "Slave frame_ctrl reg write failed"); 664 goto error; 665 } 666 667 kfree(wr_msg); 668 kfree(wbuf); 669 bus->defer_msg.msg = NULL; 670 bus->params.curr_bank = !bus->params.curr_bank; 671 bus->params.next_bank = !bus->params.next_bank; 672 673 return 0; 674 675 error: 676 kfree(wbuf); 677 error_1: 678 kfree(wr_msg); 679 return ret; 680 } 681 682 static int do_bank_switch(struct sdw_stream_runtime *stream) 683 { 684 struct sdw_master_runtime *m_rt = stream->m_rt; 685 const struct sdw_master_ops *ops; 686 struct sdw_bus *bus = m_rt->bus; 687 int ret = 0; 688 689 ops = bus->ops; 690 691 /* Pre-bank switch */ 692 if (ops->pre_bank_switch) { 693 ret = ops->pre_bank_switch(bus); 694 if (ret < 0) { 695 dev_err(bus->dev, "Pre bank switch op failed: %d", ret); 696 return ret; 697 } 698 } 699 700 /* Bank switch */ 701 ret = sdw_bank_switch(bus); 702 if (ret < 0) { 703 dev_err(bus->dev, "Bank switch failed: %d", ret); 704 return ret; 705 } 706 707 /* Post-bank switch */ 708 if (ops->post_bank_switch) { 709 ret = ops->post_bank_switch(bus); 710 if (ret < 0) { 711 dev_err(bus->dev, 712 "Post bank switch op failed: %d", ret); 713 } 714 } 715 716 return ret; 717 } 718 719 /** 720 * sdw_release_stream() - Free the assigned stream runtime 721 * 722 * @stream: SoundWire stream runtime 723 * 724 * sdw_release_stream should be called only once per stream 725 */ 726 void sdw_release_stream(struct sdw_stream_runtime *stream) 727 { 728 kfree(stream); 729 } 730 EXPORT_SYMBOL(sdw_release_stream); 731 732 /** 733 * sdw_alloc_stream() - Allocate and return stream runtime 734 * 735 * @stream_name: SoundWire stream name 736 * 737 * Allocates a SoundWire stream runtime instance. 738 * sdw_alloc_stream should be called only once per stream. Typically 739 * invoked from ALSA/ASoC machine/platform driver. 740 */ 741 struct sdw_stream_runtime *sdw_alloc_stream(char *stream_name) 742 { 743 struct sdw_stream_runtime *stream; 744 745 stream = kzalloc(sizeof(*stream), GFP_KERNEL); 746 if (!stream) 747 return NULL; 748 749 stream->name = stream_name; 750 stream->state = SDW_STREAM_ALLOCATED; 751 752 return stream; 753 } 754 EXPORT_SYMBOL(sdw_alloc_stream); 755 756 /** 757 * sdw_alloc_master_rt() - Allocates and initialize Master runtime handle 758 * 759 * @bus: SDW bus instance 760 * @stream_config: Stream configuration 761 * @stream: Stream runtime handle. 762 * 763 * This function is to be called with bus_lock held. 764 */ 765 static struct sdw_master_runtime 766 *sdw_alloc_master_rt(struct sdw_bus *bus, 767 struct sdw_stream_config *stream_config, 768 struct sdw_stream_runtime *stream) 769 { 770 struct sdw_master_runtime *m_rt; 771 772 m_rt = stream->m_rt; 773 774 /* 775 * check if Master is already allocated (as a result of Slave adding 776 * it first), if so skip allocation and go to configure 777 */ 778 if (m_rt) 779 goto stream_config; 780 781 m_rt = kzalloc(sizeof(*m_rt), GFP_KERNEL); 782 if (!m_rt) 783 return NULL; 784 785 /* Initialization of Master runtime handle */ 786 INIT_LIST_HEAD(&m_rt->port_list); 787 INIT_LIST_HEAD(&m_rt->slave_rt_list); 788 stream->m_rt = m_rt; 789 790 list_add_tail(&m_rt->bus_node, &bus->m_rt_list); 791 792 stream_config: 793 m_rt->ch_count = stream_config->ch_count; 794 m_rt->bus = bus; 795 m_rt->stream = stream; 796 m_rt->direction = stream_config->direction; 797 798 return m_rt; 799 } 800 801 /** 802 * sdw_alloc_slave_rt() - Allocate and initialize Slave runtime handle. 803 * 804 * @slave: Slave handle 805 * @stream_config: Stream configuration 806 * @stream: Stream runtime handle 807 * 808 * This function is to be called with bus_lock held. 809 */ 810 static struct sdw_slave_runtime 811 *sdw_alloc_slave_rt(struct sdw_slave *slave, 812 struct sdw_stream_config *stream_config, 813 struct sdw_stream_runtime *stream) 814 { 815 struct sdw_slave_runtime *s_rt = NULL; 816 817 s_rt = kzalloc(sizeof(*s_rt), GFP_KERNEL); 818 if (!s_rt) 819 return NULL; 820 821 INIT_LIST_HEAD(&s_rt->port_list); 822 s_rt->ch_count = stream_config->ch_count; 823 s_rt->direction = stream_config->direction; 824 s_rt->slave = slave; 825 826 return s_rt; 827 } 828 829 static void sdw_master_port_release(struct sdw_bus *bus, 830 struct sdw_master_runtime *m_rt) 831 { 832 struct sdw_port_runtime *p_rt, *_p_rt; 833 834 list_for_each_entry_safe(p_rt, _p_rt, 835 &m_rt->port_list, port_node) { 836 list_del(&p_rt->port_node); 837 kfree(p_rt); 838 } 839 } 840 841 static void sdw_slave_port_release(struct sdw_bus *bus, 842 struct sdw_slave *slave, 843 struct sdw_stream_runtime *stream) 844 { 845 struct sdw_port_runtime *p_rt, *_p_rt; 846 struct sdw_master_runtime *m_rt = stream->m_rt; 847 struct sdw_slave_runtime *s_rt; 848 849 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) { 850 if (s_rt->slave != slave) 851 continue; 852 853 list_for_each_entry_safe(p_rt, _p_rt, 854 &s_rt->port_list, port_node) { 855 list_del(&p_rt->port_node); 856 kfree(p_rt); 857 } 858 } 859 } 860 861 /** 862 * sdw_release_slave_stream() - Free Slave(s) runtime handle 863 * 864 * @slave: Slave handle. 865 * @stream: Stream runtime handle. 866 * 867 * This function is to be called with bus_lock held. 868 */ 869 static void sdw_release_slave_stream(struct sdw_slave *slave, 870 struct sdw_stream_runtime *stream) 871 { 872 struct sdw_slave_runtime *s_rt, *_s_rt; 873 struct sdw_master_runtime *m_rt = stream->m_rt; 874 875 /* Retrieve Slave runtime handle */ 876 list_for_each_entry_safe(s_rt, _s_rt, 877 &m_rt->slave_rt_list, m_rt_node) { 878 879 if (s_rt->slave == slave) { 880 list_del(&s_rt->m_rt_node); 881 kfree(s_rt); 882 return; 883 } 884 } 885 } 886 887 /** 888 * sdw_release_master_stream() - Free Master runtime handle 889 * 890 * @stream: Stream runtime handle. 891 * 892 * This function is to be called with bus_lock held 893 * It frees the Master runtime handle and associated Slave(s) runtime 894 * handle. If this is called first then sdw_release_slave_stream() will have 895 * no effect as Slave(s) runtime handle would already be freed up. 896 */ 897 static void sdw_release_master_stream(struct sdw_stream_runtime *stream) 898 { 899 struct sdw_master_runtime *m_rt = stream->m_rt; 900 struct sdw_slave_runtime *s_rt, *_s_rt; 901 902 list_for_each_entry_safe(s_rt, _s_rt, &m_rt->slave_rt_list, m_rt_node) { 903 sdw_slave_port_release(s_rt->slave->bus, s_rt->slave, stream); 904 sdw_release_slave_stream(s_rt->slave, stream); 905 } 906 907 list_del(&m_rt->bus_node); 908 } 909 910 /** 911 * sdw_stream_remove_master() - Remove master from sdw_stream 912 * 913 * @bus: SDW Bus instance 914 * @stream: SoundWire stream 915 * 916 * This removes and frees port_rt and master_rt from a stream 917 */ 918 int sdw_stream_remove_master(struct sdw_bus *bus, 919 struct sdw_stream_runtime *stream) 920 { 921 mutex_lock(&bus->bus_lock); 922 923 sdw_release_master_stream(stream); 924 sdw_master_port_release(bus, stream->m_rt); 925 stream->state = SDW_STREAM_RELEASED; 926 kfree(stream->m_rt); 927 stream->m_rt = NULL; 928 929 mutex_unlock(&bus->bus_lock); 930 931 return 0; 932 } 933 EXPORT_SYMBOL(sdw_stream_remove_master); 934 935 /** 936 * sdw_stream_remove_slave() - Remove slave from sdw_stream 937 * 938 * @slave: SDW Slave instance 939 * @stream: SoundWire stream 940 * 941 * This removes and frees port_rt and slave_rt from a stream 942 */ 943 int sdw_stream_remove_slave(struct sdw_slave *slave, 944 struct sdw_stream_runtime *stream) 945 { 946 mutex_lock(&slave->bus->bus_lock); 947 948 sdw_slave_port_release(slave->bus, slave, stream); 949 sdw_release_slave_stream(slave, stream); 950 951 mutex_unlock(&slave->bus->bus_lock); 952 953 return 0; 954 } 955 EXPORT_SYMBOL(sdw_stream_remove_slave); 956 957 /** 958 * sdw_config_stream() - Configure the allocated stream 959 * 960 * @dev: SDW device 961 * @stream: SoundWire stream 962 * @stream_config: Stream configuration for audio stream 963 * @is_slave: is API called from Slave or Master 964 * 965 * This function is to be called with bus_lock held. 966 */ 967 static int sdw_config_stream(struct device *dev, 968 struct sdw_stream_runtime *stream, 969 struct sdw_stream_config *stream_config, bool is_slave) 970 { 971 /* 972 * Update the stream rate, channel and bps based on data 973 * source. For more than one data source (multilink), 974 * match the rate, bps, stream type and increment number of channels. 975 * 976 * If rate/bps is zero, it means the values are not set, so skip 977 * comparison and allow the value to be set and stored in stream 978 */ 979 if (stream->params.rate && 980 stream->params.rate != stream_config->frame_rate) { 981 dev_err(dev, "rate not matching, stream:%s", stream->name); 982 return -EINVAL; 983 } 984 985 if (stream->params.bps && 986 stream->params.bps != stream_config->bps) { 987 dev_err(dev, "bps not matching, stream:%s", stream->name); 988 return -EINVAL; 989 } 990 991 stream->type = stream_config->type; 992 stream->params.rate = stream_config->frame_rate; 993 stream->params.bps = stream_config->bps; 994 995 /* TODO: Update this check during Device-device support */ 996 if (is_slave) 997 stream->params.ch_count += stream_config->ch_count; 998 999 return 0; 1000 } 1001 1002 static int sdw_is_valid_port_range(struct device *dev, 1003 struct sdw_port_runtime *p_rt) 1004 { 1005 if (!SDW_VALID_PORT_RANGE(p_rt->num)) { 1006 dev_err(dev, 1007 "SoundWire: Invalid port number :%d", p_rt->num); 1008 return -EINVAL; 1009 } 1010 1011 return 0; 1012 } 1013 1014 static struct sdw_port_runtime *sdw_port_alloc(struct device *dev, 1015 struct sdw_port_config *port_config, 1016 int port_index) 1017 { 1018 struct sdw_port_runtime *p_rt; 1019 1020 p_rt = kzalloc(sizeof(*p_rt), GFP_KERNEL); 1021 if (!p_rt) 1022 return NULL; 1023 1024 p_rt->ch_mask = port_config[port_index].ch_mask; 1025 p_rt->num = port_config[port_index].num; 1026 1027 return p_rt; 1028 } 1029 1030 static int sdw_master_port_config(struct sdw_bus *bus, 1031 struct sdw_master_runtime *m_rt, 1032 struct sdw_port_config *port_config, 1033 unsigned int num_ports) 1034 { 1035 struct sdw_port_runtime *p_rt; 1036 int i; 1037 1038 /* Iterate for number of ports to perform initialization */ 1039 for (i = 0; i < num_ports; i++) { 1040 p_rt = sdw_port_alloc(bus->dev, port_config, i); 1041 if (!p_rt) 1042 return -ENOMEM; 1043 1044 /* 1045 * TODO: Check port capabilities for requested 1046 * configuration (audio mode support) 1047 */ 1048 1049 list_add_tail(&p_rt->port_node, &m_rt->port_list); 1050 } 1051 1052 return 0; 1053 } 1054 1055 static int sdw_slave_port_config(struct sdw_slave *slave, 1056 struct sdw_slave_runtime *s_rt, 1057 struct sdw_port_config *port_config, 1058 unsigned int num_config) 1059 { 1060 struct sdw_port_runtime *p_rt; 1061 int i, ret; 1062 1063 /* Iterate for number of ports to perform initialization */ 1064 for (i = 0; i < num_config; i++) { 1065 p_rt = sdw_port_alloc(&slave->dev, port_config, i); 1066 if (!p_rt) 1067 return -ENOMEM; 1068 1069 /* 1070 * TODO: Check valid port range as defined by DisCo/ 1071 * slave 1072 */ 1073 ret = sdw_is_valid_port_range(&slave->dev, p_rt); 1074 if (ret < 0) { 1075 kfree(p_rt); 1076 return ret; 1077 } 1078 1079 /* 1080 * TODO: Check port capabilities for requested 1081 * configuration (audio mode support) 1082 */ 1083 1084 list_add_tail(&p_rt->port_node, &s_rt->port_list); 1085 } 1086 1087 return 0; 1088 } 1089 1090 /** 1091 * sdw_stream_add_master() - Allocate and add master runtime to a stream 1092 * 1093 * @bus: SDW Bus instance 1094 * @stream_config: Stream configuration for audio stream 1095 * @port_config: Port configuration for audio stream 1096 * @num_ports: Number of ports 1097 * @stream: SoundWire stream 1098 */ 1099 int sdw_stream_add_master(struct sdw_bus *bus, 1100 struct sdw_stream_config *stream_config, 1101 struct sdw_port_config *port_config, 1102 unsigned int num_ports, 1103 struct sdw_stream_runtime *stream) 1104 { 1105 struct sdw_master_runtime *m_rt = NULL; 1106 int ret; 1107 1108 mutex_lock(&bus->bus_lock); 1109 1110 m_rt = sdw_alloc_master_rt(bus, stream_config, stream); 1111 if (!m_rt) { 1112 dev_err(bus->dev, 1113 "Master runtime config failed for stream:%s", 1114 stream->name); 1115 ret = -ENOMEM; 1116 goto unlock; 1117 } 1118 1119 ret = sdw_config_stream(bus->dev, stream, stream_config, false); 1120 if (ret) 1121 goto stream_error; 1122 1123 ret = sdw_master_port_config(bus, m_rt, port_config, num_ports); 1124 if (ret) 1125 goto stream_error; 1126 1127 goto unlock; 1128 1129 stream_error: 1130 sdw_release_master_stream(stream); 1131 unlock: 1132 mutex_unlock(&bus->bus_lock); 1133 return ret; 1134 } 1135 EXPORT_SYMBOL(sdw_stream_add_master); 1136 1137 /** 1138 * sdw_stream_add_slave() - Allocate and add master/slave runtime to a stream 1139 * 1140 * @slave: SDW Slave instance 1141 * @stream_config: Stream configuration for audio stream 1142 * @stream: SoundWire stream 1143 * @port_config: Port configuration for audio stream 1144 * @num_ports: Number of ports 1145 * 1146 * It is expected that Slave is added before adding Master 1147 * to the Stream. 1148 * 1149 */ 1150 int sdw_stream_add_slave(struct sdw_slave *slave, 1151 struct sdw_stream_config *stream_config, 1152 struct sdw_port_config *port_config, 1153 unsigned int num_ports, 1154 struct sdw_stream_runtime *stream) 1155 { 1156 struct sdw_slave_runtime *s_rt; 1157 struct sdw_master_runtime *m_rt; 1158 int ret; 1159 1160 mutex_lock(&slave->bus->bus_lock); 1161 1162 /* 1163 * If this API is invoked by Slave first then m_rt is not valid. 1164 * So, allocate m_rt and add Slave to it. 1165 */ 1166 m_rt = sdw_alloc_master_rt(slave->bus, stream_config, stream); 1167 if (!m_rt) { 1168 dev_err(&slave->dev, 1169 "alloc master runtime failed for stream:%s", 1170 stream->name); 1171 ret = -ENOMEM; 1172 goto error; 1173 } 1174 1175 s_rt = sdw_alloc_slave_rt(slave, stream_config, stream); 1176 if (!s_rt) { 1177 dev_err(&slave->dev, 1178 "Slave runtime config failed for stream:%s", 1179 stream->name); 1180 ret = -ENOMEM; 1181 goto stream_error; 1182 } 1183 1184 ret = sdw_config_stream(&slave->dev, stream, stream_config, true); 1185 if (ret) 1186 goto stream_error; 1187 1188 list_add_tail(&s_rt->m_rt_node, &m_rt->slave_rt_list); 1189 1190 ret = sdw_slave_port_config(slave, s_rt, port_config, num_ports); 1191 if (ret) 1192 goto stream_error; 1193 1194 /* 1195 * Change stream state to CONFIGURED on first Slave add. 1196 * Bus is not aware of number of Slave(s) in a stream at this 1197 * point so cannot depend on all Slave(s) to be added in order to 1198 * change stream state to CONFIGURED. 1199 */ 1200 stream->state = SDW_STREAM_CONFIGURED; 1201 goto error; 1202 1203 stream_error: 1204 /* 1205 * we hit error so cleanup the stream, release all Slave(s) and 1206 * Master runtime 1207 */ 1208 sdw_release_master_stream(stream); 1209 error: 1210 mutex_unlock(&slave->bus->bus_lock); 1211 return ret; 1212 } 1213 EXPORT_SYMBOL(sdw_stream_add_slave); 1214 1215 /** 1216 * sdw_get_slave_dpn_prop() - Get Slave port capabilities 1217 * 1218 * @slave: Slave handle 1219 * @direction: Data direction. 1220 * @port_num: Port number 1221 */ 1222 struct sdw_dpn_prop *sdw_get_slave_dpn_prop(struct sdw_slave *slave, 1223 enum sdw_data_direction direction, 1224 unsigned int port_num) 1225 { 1226 struct sdw_dpn_prop *dpn_prop; 1227 u8 num_ports; 1228 int i; 1229 1230 if (direction == SDW_DATA_DIR_TX) { 1231 num_ports = hweight32(slave->prop.source_ports); 1232 dpn_prop = slave->prop.src_dpn_prop; 1233 } else { 1234 num_ports = hweight32(slave->prop.sink_ports); 1235 dpn_prop = slave->prop.sink_dpn_prop; 1236 } 1237 1238 for (i = 0; i < num_ports; i++) { 1239 dpn_prop = &dpn_prop[i]; 1240 1241 if (dpn_prop->num == port_num) 1242 return &dpn_prop[i]; 1243 } 1244 1245 return NULL; 1246 } 1247 1248 static int _sdw_prepare_stream(struct sdw_stream_runtime *stream) 1249 { 1250 struct sdw_master_runtime *m_rt = stream->m_rt; 1251 struct sdw_bus *bus = m_rt->bus; 1252 struct sdw_master_prop *prop = NULL; 1253 struct sdw_bus_params params; 1254 int ret; 1255 1256 prop = &bus->prop; 1257 memcpy(¶ms, &bus->params, sizeof(params)); 1258 1259 /* TODO: Support Asynchronous mode */ 1260 if ((prop->max_freq % stream->params.rate) != 0) { 1261 dev_err(bus->dev, "Async mode not supported"); 1262 return -EINVAL; 1263 } 1264 1265 /* Increment cumulative bus bandwidth */ 1266 /* TODO: Update this during Device-Device support */ 1267 bus->params.bandwidth += m_rt->stream->params.rate * 1268 m_rt->ch_count * m_rt->stream->params.bps; 1269 1270 /* Program params */ 1271 ret = sdw_program_params(bus); 1272 if (ret < 0) { 1273 dev_err(bus->dev, "Program params failed: %d", ret); 1274 goto restore_params; 1275 } 1276 1277 ret = do_bank_switch(stream); 1278 if (ret < 0) { 1279 dev_err(bus->dev, "Bank switch failed: %d", ret); 1280 goto restore_params; 1281 } 1282 1283 /* Prepare port(s) on the new clock configuration */ 1284 ret = sdw_prep_deprep_ports(m_rt, true); 1285 if (ret < 0) { 1286 dev_err(bus->dev, "Prepare port(s) failed ret = %d", 1287 ret); 1288 return ret; 1289 } 1290 1291 stream->state = SDW_STREAM_PREPARED; 1292 1293 return ret; 1294 1295 restore_params: 1296 memcpy(&bus->params, ¶ms, sizeof(params)); 1297 return ret; 1298 } 1299 1300 /** 1301 * sdw_prepare_stream() - Prepare SoundWire stream 1302 * 1303 * @stream: Soundwire stream 1304 * 1305 * Documentation/driver-api/soundwire/stream.rst explains this API in detail 1306 */ 1307 int sdw_prepare_stream(struct sdw_stream_runtime *stream) 1308 { 1309 int ret = 0; 1310 1311 if (!stream) { 1312 pr_err("SoundWire: Handle not found for stream"); 1313 return -EINVAL; 1314 } 1315 1316 mutex_lock(&stream->m_rt->bus->bus_lock); 1317 1318 ret = _sdw_prepare_stream(stream); 1319 if (ret < 0) 1320 pr_err("Prepare for stream:%s failed: %d", stream->name, ret); 1321 1322 mutex_unlock(&stream->m_rt->bus->bus_lock); 1323 return ret; 1324 } 1325 EXPORT_SYMBOL(sdw_prepare_stream); 1326 1327 static int _sdw_enable_stream(struct sdw_stream_runtime *stream) 1328 { 1329 struct sdw_master_runtime *m_rt = stream->m_rt; 1330 struct sdw_bus *bus = m_rt->bus; 1331 int ret; 1332 1333 /* Program params */ 1334 ret = sdw_program_params(bus); 1335 if (ret < 0) { 1336 dev_err(bus->dev, "Program params failed: %d", ret); 1337 return ret; 1338 } 1339 1340 /* Enable port(s) */ 1341 ret = sdw_enable_disable_ports(m_rt, true); 1342 if (ret < 0) { 1343 dev_err(bus->dev, "Enable port(s) failed ret: %d", ret); 1344 return ret; 1345 } 1346 1347 ret = do_bank_switch(stream); 1348 if (ret < 0) { 1349 dev_err(bus->dev, "Bank switch failed: %d", ret); 1350 return ret; 1351 } 1352 1353 stream->state = SDW_STREAM_ENABLED; 1354 return 0; 1355 } 1356 1357 /** 1358 * sdw_enable_stream() - Enable SoundWire stream 1359 * 1360 * @stream: Soundwire stream 1361 * 1362 * Documentation/driver-api/soundwire/stream.rst explains this API in detail 1363 */ 1364 int sdw_enable_stream(struct sdw_stream_runtime *stream) 1365 { 1366 int ret = 0; 1367 1368 if (!stream) { 1369 pr_err("SoundWire: Handle not found for stream"); 1370 return -EINVAL; 1371 } 1372 1373 mutex_lock(&stream->m_rt->bus->bus_lock); 1374 1375 ret = _sdw_enable_stream(stream); 1376 if (ret < 0) 1377 pr_err("Enable for stream:%s failed: %d", stream->name, ret); 1378 1379 mutex_unlock(&stream->m_rt->bus->bus_lock); 1380 return ret; 1381 } 1382 EXPORT_SYMBOL(sdw_enable_stream); 1383 1384 static int _sdw_disable_stream(struct sdw_stream_runtime *stream) 1385 { 1386 struct sdw_master_runtime *m_rt = stream->m_rt; 1387 struct sdw_bus *bus = m_rt->bus; 1388 int ret; 1389 1390 /* Disable port(s) */ 1391 ret = sdw_enable_disable_ports(m_rt, false); 1392 if (ret < 0) { 1393 dev_err(bus->dev, "Disable port(s) failed: %d", ret); 1394 return ret; 1395 } 1396 1397 stream->state = SDW_STREAM_DISABLED; 1398 1399 /* Program params */ 1400 ret = sdw_program_params(bus); 1401 if (ret < 0) { 1402 dev_err(bus->dev, "Program params failed: %d", ret); 1403 return ret; 1404 } 1405 1406 return do_bank_switch(stream); 1407 } 1408 1409 /** 1410 * sdw_disable_stream() - Disable SoundWire stream 1411 * 1412 * @stream: Soundwire stream 1413 * 1414 * Documentation/driver-api/soundwire/stream.rst explains this API in detail 1415 */ 1416 int sdw_disable_stream(struct sdw_stream_runtime *stream) 1417 { 1418 int ret = 0; 1419 1420 if (!stream) { 1421 pr_err("SoundWire: Handle not found for stream"); 1422 return -EINVAL; 1423 } 1424 1425 mutex_lock(&stream->m_rt->bus->bus_lock); 1426 1427 ret = _sdw_disable_stream(stream); 1428 if (ret < 0) 1429 pr_err("Disable for stream:%s failed: %d", stream->name, ret); 1430 1431 mutex_unlock(&stream->m_rt->bus->bus_lock); 1432 return ret; 1433 } 1434 EXPORT_SYMBOL(sdw_disable_stream); 1435 1436 static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream) 1437 { 1438 struct sdw_master_runtime *m_rt = stream->m_rt; 1439 struct sdw_bus *bus = m_rt->bus; 1440 int ret = 0; 1441 1442 /* De-prepare port(s) */ 1443 ret = sdw_prep_deprep_ports(m_rt, false); 1444 if (ret < 0) { 1445 dev_err(bus->dev, "De-prepare port(s) failed: %d", ret); 1446 return ret; 1447 } 1448 1449 stream->state = SDW_STREAM_DEPREPARED; 1450 1451 /* TODO: Update this during Device-Device support */ 1452 bus->params.bandwidth -= m_rt->stream->params.rate * 1453 m_rt->ch_count * m_rt->stream->params.bps; 1454 1455 /* Program params */ 1456 ret = sdw_program_params(bus); 1457 if (ret < 0) { 1458 dev_err(bus->dev, "Program params failed: %d", ret); 1459 return ret; 1460 } 1461 1462 return do_bank_switch(stream); 1463 } 1464 1465 /** 1466 * sdw_deprepare_stream() - Deprepare SoundWire stream 1467 * 1468 * @stream: Soundwire stream 1469 * 1470 * Documentation/driver-api/soundwire/stream.rst explains this API in detail 1471 */ 1472 int sdw_deprepare_stream(struct sdw_stream_runtime *stream) 1473 { 1474 int ret = 0; 1475 1476 if (!stream) { 1477 pr_err("SoundWire: Handle not found for stream"); 1478 return -EINVAL; 1479 } 1480 1481 mutex_lock(&stream->m_rt->bus->bus_lock); 1482 1483 ret = _sdw_deprepare_stream(stream); 1484 if (ret < 0) 1485 pr_err("De-prepare for stream:%d failed: %d", ret, ret); 1486 1487 mutex_unlock(&stream->m_rt->bus->bus_lock); 1488 return ret; 1489 } 1490 EXPORT_SYMBOL(sdw_deprepare_stream); 1491