2105 lines · c
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 <linux/soundwire/sdw_type.h>17#include <sound/soc.h>18#include "bus.h"19 20/*21 * Array of supported rows and columns as per MIPI SoundWire Specification 1.122 *23 * The rows are arranged as per the array index value programmed24 * in register. The index 15 has dummy value 0 in order to fill hole.25 */26int sdw_rows[SDW_FRAME_ROWS] = {48, 50, 60, 64, 75, 80, 125, 147,27 96, 100, 120, 128, 150, 160, 250, 0,28 192, 200, 240, 256, 72, 144, 90, 180};29EXPORT_SYMBOL(sdw_rows);30 31int sdw_cols[SDW_FRAME_COLS] = {2, 4, 6, 8, 10, 12, 14, 16};32EXPORT_SYMBOL(sdw_cols);33 34int sdw_find_col_index(int col)35{36 int i;37 38 for (i = 0; i < SDW_FRAME_COLS; i++) {39 if (sdw_cols[i] == col)40 return i;41 }42 43 pr_warn("Requested column not found, selecting lowest column no: 2\n");44 return 0;45}46EXPORT_SYMBOL(sdw_find_col_index);47 48int sdw_find_row_index(int row)49{50 int i;51 52 for (i = 0; i < SDW_FRAME_ROWS; i++) {53 if (sdw_rows[i] == row)54 return i;55 }56 57 pr_warn("Requested row not found, selecting lowest row no: 48\n");58 return 0;59}60EXPORT_SYMBOL(sdw_find_row_index);61 62static int _sdw_program_slave_port_params(struct sdw_bus *bus,63 struct sdw_slave *slave,64 struct sdw_transport_params *t_params,65 enum sdw_dpn_type type)66{67 u32 addr1, addr2, addr3, addr4;68 int ret;69 u16 wbuf;70 71 if (bus->params.next_bank) {72 addr1 = SDW_DPN_OFFSETCTRL2_B1(t_params->port_num);73 addr2 = SDW_DPN_BLOCKCTRL3_B1(t_params->port_num);74 addr3 = SDW_DPN_SAMPLECTRL2_B1(t_params->port_num);75 addr4 = SDW_DPN_HCTRL_B1(t_params->port_num);76 } else {77 addr1 = SDW_DPN_OFFSETCTRL2_B0(t_params->port_num);78 addr2 = SDW_DPN_BLOCKCTRL3_B0(t_params->port_num);79 addr3 = SDW_DPN_SAMPLECTRL2_B0(t_params->port_num);80 addr4 = SDW_DPN_HCTRL_B0(t_params->port_num);81 }82 83 /* Program DPN_OffsetCtrl2 registers */84 ret = sdw_write_no_pm(slave, addr1, t_params->offset2);85 if (ret < 0) {86 dev_err(bus->dev, "DPN_OffsetCtrl2 register write failed\n");87 return ret;88 }89 90 /* Program DPN_BlockCtrl3 register */91 ret = sdw_write_no_pm(slave, addr2, t_params->blk_pkg_mode);92 if (ret < 0) {93 dev_err(bus->dev, "DPN_BlockCtrl3 register write failed\n");94 return ret;95 }96 97 /*98 * Data ports are FULL, SIMPLE and REDUCED. This function handles99 * FULL and REDUCED only and beyond this point only FULL is100 * handled, so bail out if we are not FULL data port type101 */102 if (type != SDW_DPN_FULL)103 return ret;104 105 /* Program DPN_SampleCtrl2 register */106 wbuf = FIELD_GET(SDW_DPN_SAMPLECTRL_HIGH, t_params->sample_interval - 1);107 108 ret = sdw_write_no_pm(slave, addr3, wbuf);109 if (ret < 0) {110 dev_err(bus->dev, "DPN_SampleCtrl2 register write failed\n");111 return ret;112 }113 114 /* Program DPN_HCtrl register */115 wbuf = FIELD_PREP(SDW_DPN_HCTRL_HSTART, t_params->hstart);116 wbuf |= FIELD_PREP(SDW_DPN_HCTRL_HSTOP, t_params->hstop);117 118 ret = sdw_write_no_pm(slave, addr4, wbuf);119 if (ret < 0)120 dev_err(bus->dev, "DPN_HCtrl register write failed\n");121 122 return ret;123}124 125static int sdw_program_slave_port_params(struct sdw_bus *bus,126 struct sdw_slave_runtime *s_rt,127 struct sdw_port_runtime *p_rt)128{129 struct sdw_transport_params *t_params = &p_rt->transport_params;130 struct sdw_port_params *p_params = &p_rt->port_params;131 struct sdw_slave_prop *slave_prop = &s_rt->slave->prop;132 u32 addr1, addr2, addr3, addr4, addr5, addr6;133 struct sdw_dpn_prop *dpn_prop;134 int ret;135 u8 wbuf;136 137 if (s_rt->slave->is_mockup_device)138 return 0;139 140 dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave,141 s_rt->direction,142 t_params->port_num);143 if (!dpn_prop)144 return -EINVAL;145 146 addr1 = SDW_DPN_PORTCTRL(t_params->port_num);147 addr2 = SDW_DPN_BLOCKCTRL1(t_params->port_num);148 149 if (bus->params.next_bank) {150 addr3 = SDW_DPN_SAMPLECTRL1_B1(t_params->port_num);151 addr4 = SDW_DPN_OFFSETCTRL1_B1(t_params->port_num);152 addr5 = SDW_DPN_BLOCKCTRL2_B1(t_params->port_num);153 addr6 = SDW_DPN_LANECTRL_B1(t_params->port_num);154 155 } else {156 addr3 = SDW_DPN_SAMPLECTRL1_B0(t_params->port_num);157 addr4 = SDW_DPN_OFFSETCTRL1_B0(t_params->port_num);158 addr5 = SDW_DPN_BLOCKCTRL2_B0(t_params->port_num);159 addr6 = SDW_DPN_LANECTRL_B0(t_params->port_num);160 }161 162 /* Program DPN_PortCtrl register */163 wbuf = FIELD_PREP(SDW_DPN_PORTCTRL_DATAMODE, p_params->data_mode);164 wbuf |= FIELD_PREP(SDW_DPN_PORTCTRL_FLOWMODE, p_params->flow_mode);165 166 ret = sdw_update_no_pm(s_rt->slave, addr1, 0xF, wbuf);167 if (ret < 0) {168 dev_err(&s_rt->slave->dev,169 "DPN_PortCtrl register write failed for port %d\n",170 t_params->port_num);171 return ret;172 }173 174 if (!dpn_prop->read_only_wordlength) {175 /* Program DPN_BlockCtrl1 register */176 ret = sdw_write_no_pm(s_rt->slave, addr2, (p_params->bps - 1));177 if (ret < 0) {178 dev_err(&s_rt->slave->dev,179 "DPN_BlockCtrl1 register write failed for port %d\n",180 t_params->port_num);181 return ret;182 }183 }184 185 /* Program DPN_SampleCtrl1 register */186 wbuf = (t_params->sample_interval - 1) & SDW_DPN_SAMPLECTRL_LOW;187 ret = sdw_write_no_pm(s_rt->slave, addr3, wbuf);188 if (ret < 0) {189 dev_err(&s_rt->slave->dev,190 "DPN_SampleCtrl1 register write failed for port %d\n",191 t_params->port_num);192 return ret;193 }194 195 /* Program DPN_OffsetCtrl1 registers */196 ret = sdw_write_no_pm(s_rt->slave, addr4, t_params->offset1);197 if (ret < 0) {198 dev_err(&s_rt->slave->dev,199 "DPN_OffsetCtrl1 register write failed for port %d\n",200 t_params->port_num);201 return ret;202 }203 204 /* Program DPN_BlockCtrl2 register*/205 if (t_params->blk_grp_ctrl_valid) {206 ret = sdw_write_no_pm(s_rt->slave, addr5, t_params->blk_grp_ctrl);207 if (ret < 0) {208 dev_err(&s_rt->slave->dev,209 "DPN_BlockCtrl2 reg write failed for port %d\n",210 t_params->port_num);211 return ret;212 }213 }214 215 /* program DPN_LaneCtrl register */216 if (slave_prop->lane_control_support) {217 ret = sdw_write_no_pm(s_rt->slave, addr6, t_params->lane_ctrl);218 if (ret < 0) {219 dev_err(&s_rt->slave->dev,220 "DPN_LaneCtrl register write failed for port %d\n",221 t_params->port_num);222 return ret;223 }224 }225 226 if (dpn_prop->type != SDW_DPN_SIMPLE) {227 ret = _sdw_program_slave_port_params(bus, s_rt->slave,228 t_params, dpn_prop->type);229 if (ret < 0)230 dev_err(&s_rt->slave->dev,231 "Transport reg write failed for port: %d\n",232 t_params->port_num);233 }234 235 return ret;236}237 238static int sdw_program_master_port_params(struct sdw_bus *bus,239 struct sdw_port_runtime *p_rt)240{241 int ret;242 243 /*244 * we need to set transport and port parameters for the port.245 * Transport parameters refers to the sample interval, offsets and246 * hstart/stop etc of the data. Port parameters refers to word247 * length, flow mode etc of the port248 */249 ret = bus->port_ops->dpn_set_port_transport_params(bus,250 &p_rt->transport_params,251 bus->params.next_bank);252 if (ret < 0)253 return ret;254 255 return bus->port_ops->dpn_set_port_params(bus,256 &p_rt->port_params,257 bus->params.next_bank);258}259 260/**261 * sdw_program_port_params() - Programs transport parameters of Master(s)262 * and Slave(s)263 *264 * @m_rt: Master stream runtime265 */266static int sdw_program_port_params(struct sdw_master_runtime *m_rt)267{268 struct sdw_slave_runtime *s_rt;269 struct sdw_bus *bus = m_rt->bus;270 struct sdw_port_runtime *p_rt;271 int ret = 0;272 273 /* Program transport & port parameters for Slave(s) */274 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {275 list_for_each_entry(p_rt, &s_rt->port_list, port_node) {276 ret = sdw_program_slave_port_params(bus, s_rt, p_rt);277 if (ret < 0)278 return ret;279 }280 }281 282 /* Program transport & port parameters for Master(s) */283 list_for_each_entry(p_rt, &m_rt->port_list, port_node) {284 ret = sdw_program_master_port_params(bus, p_rt);285 if (ret < 0)286 return ret;287 }288 289 return 0;290}291 292/**293 * sdw_enable_disable_slave_ports: Enable/disable slave data port294 *295 * @bus: bus instance296 * @s_rt: slave runtime297 * @p_rt: port runtime298 * @en: enable or disable operation299 *300 * This function only sets the enable/disable bits in the relevant bank, the301 * actual enable/disable is done with a bank switch302 */303static int sdw_enable_disable_slave_ports(struct sdw_bus *bus,304 struct sdw_slave_runtime *s_rt,305 struct sdw_port_runtime *p_rt,306 bool en)307{308 struct sdw_transport_params *t_params = &p_rt->transport_params;309 u32 addr;310 int ret;311 312 if (bus->params.next_bank)313 addr = SDW_DPN_CHANNELEN_B1(p_rt->num);314 else315 addr = SDW_DPN_CHANNELEN_B0(p_rt->num);316 317 /*318 * Since bus doesn't support sharing a port across two streams,319 * it is safe to reset this register320 */321 if (en)322 ret = sdw_write_no_pm(s_rt->slave, addr, p_rt->ch_mask);323 else324 ret = sdw_write_no_pm(s_rt->slave, addr, 0x0);325 326 if (ret < 0)327 dev_err(&s_rt->slave->dev,328 "Slave chn_en reg write failed:%d port:%d\n",329 ret, t_params->port_num);330 331 return ret;332}333 334static int sdw_enable_disable_master_ports(struct sdw_master_runtime *m_rt,335 struct sdw_port_runtime *p_rt,336 bool en)337{338 struct sdw_transport_params *t_params = &p_rt->transport_params;339 struct sdw_bus *bus = m_rt->bus;340 struct sdw_enable_ch enable_ch;341 int ret;342 343 enable_ch.port_num = p_rt->num;344 enable_ch.ch_mask = p_rt->ch_mask;345 enable_ch.enable = en;346 347 /* Perform Master port channel(s) enable/disable */348 if (bus->port_ops->dpn_port_enable_ch) {349 ret = bus->port_ops->dpn_port_enable_ch(bus,350 &enable_ch,351 bus->params.next_bank);352 if (ret < 0) {353 dev_err(bus->dev,354 "Master chn_en write failed:%d port:%d\n",355 ret, t_params->port_num);356 return ret;357 }358 } else {359 dev_err(bus->dev,360 "dpn_port_enable_ch not supported, %s failed\n",361 en ? "enable" : "disable");362 return -EINVAL;363 }364 365 return 0;366}367 368/**369 * sdw_enable_disable_ports() - Enable/disable port(s) for Master and370 * Slave(s)371 *372 * @m_rt: Master stream runtime373 * @en: mode (enable/disable)374 */375static int sdw_enable_disable_ports(struct sdw_master_runtime *m_rt, bool en)376{377 struct sdw_port_runtime *s_port, *m_port;378 struct sdw_slave_runtime *s_rt;379 int ret = 0;380 381 /* Enable/Disable Slave port(s) */382 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {383 list_for_each_entry(s_port, &s_rt->port_list, port_node) {384 ret = sdw_enable_disable_slave_ports(m_rt->bus, s_rt,385 s_port, en);386 if (ret < 0)387 return ret;388 }389 }390 391 /* Enable/Disable Master port(s) */392 list_for_each_entry(m_port, &m_rt->port_list, port_node) {393 ret = sdw_enable_disable_master_ports(m_rt, m_port, en);394 if (ret < 0)395 return ret;396 }397 398 return 0;399}400 401static int sdw_do_port_prep(struct sdw_slave_runtime *s_rt,402 struct sdw_prepare_ch prep_ch,403 enum sdw_port_prep_ops cmd)404{405 int ret = 0;406 struct sdw_slave *slave = s_rt->slave;407 408 mutex_lock(&slave->sdw_dev_lock);409 410 if (slave->probed) {411 struct device *dev = &slave->dev;412 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);413 414 if (drv->ops && drv->ops->port_prep) {415 ret = drv->ops->port_prep(slave, &prep_ch, cmd);416 if (ret < 0)417 dev_err(dev, "Slave Port Prep cmd %d failed: %d\n",418 cmd, ret);419 }420 }421 422 mutex_unlock(&slave->sdw_dev_lock);423 424 return ret;425}426 427static int sdw_prep_deprep_slave_ports(struct sdw_bus *bus,428 struct sdw_slave_runtime *s_rt,429 struct sdw_port_runtime *p_rt,430 bool prep)431{432 struct completion *port_ready;433 struct sdw_dpn_prop *dpn_prop;434 struct sdw_prepare_ch prep_ch;435 bool intr = false;436 int ret = 0, val;437 u32 addr;438 439 prep_ch.num = p_rt->num;440 prep_ch.ch_mask = p_rt->ch_mask;441 442 dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave,443 s_rt->direction,444 prep_ch.num);445 if (!dpn_prop) {446 dev_err(bus->dev,447 "Slave Port:%d properties not found\n", prep_ch.num);448 return -EINVAL;449 }450 451 prep_ch.prepare = prep;452 453 prep_ch.bank = bus->params.next_bank;454 455 if (dpn_prop->imp_def_interrupts || !dpn_prop->simple_ch_prep_sm ||456 bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL)457 intr = true;458 459 /*460 * Enable interrupt before Port prepare.461 * For Port de-prepare, it is assumed that port462 * was prepared earlier463 */464 if (prep && intr) {465 ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep,466 dpn_prop->imp_def_interrupts);467 if (ret < 0)468 return ret;469 }470 471 /* Inform slave about the impending port prepare */472 sdw_do_port_prep(s_rt, prep_ch, prep ? SDW_OPS_PORT_PRE_PREP : SDW_OPS_PORT_PRE_DEPREP);473 474 /* Prepare Slave port implementing CP_SM */475 if (!dpn_prop->simple_ch_prep_sm) {476 addr = SDW_DPN_PREPARECTRL(p_rt->num);477 478 if (prep)479 ret = sdw_write_no_pm(s_rt->slave, addr, p_rt->ch_mask);480 else481 ret = sdw_write_no_pm(s_rt->slave, addr, 0x0);482 483 if (ret < 0) {484 dev_err(&s_rt->slave->dev,485 "Slave prep_ctrl reg write failed\n");486 return ret;487 }488 489 /* Wait for completion on port ready */490 port_ready = &s_rt->slave->port_ready[prep_ch.num];491 wait_for_completion_timeout(port_ready,492 msecs_to_jiffies(dpn_prop->ch_prep_timeout));493 494 val = sdw_read_no_pm(s_rt->slave, SDW_DPN_PREPARESTATUS(p_rt->num));495 if ((val < 0) || (val & p_rt->ch_mask)) {496 ret = (val < 0) ? val : -ETIMEDOUT;497 dev_err(&s_rt->slave->dev,498 "Chn prep failed for port %d: %d\n", prep_ch.num, ret);499 return ret;500 }501 }502 503 /* Inform slaves about ports prepared */504 sdw_do_port_prep(s_rt, prep_ch, prep ? SDW_OPS_PORT_POST_PREP : SDW_OPS_PORT_POST_DEPREP);505 506 /* Disable interrupt after Port de-prepare */507 if (!prep && intr)508 ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep,509 dpn_prop->imp_def_interrupts);510 511 return ret;512}513 514static int sdw_prep_deprep_master_ports(struct sdw_master_runtime *m_rt,515 struct sdw_port_runtime *p_rt,516 bool prep)517{518 struct sdw_transport_params *t_params = &p_rt->transport_params;519 struct sdw_bus *bus = m_rt->bus;520 const struct sdw_master_port_ops *ops = bus->port_ops;521 struct sdw_prepare_ch prep_ch;522 int ret = 0;523 524 prep_ch.num = p_rt->num;525 prep_ch.ch_mask = p_rt->ch_mask;526 prep_ch.prepare = prep; /* Prepare/De-prepare */527 prep_ch.bank = bus->params.next_bank;528 529 /* Pre-prepare/Pre-deprepare port(s) */530 if (ops->dpn_port_prep) {531 ret = ops->dpn_port_prep(bus, &prep_ch);532 if (ret < 0) {533 dev_err(bus->dev, "Port prepare failed for port:%d\n",534 t_params->port_num);535 return ret;536 }537 }538 539 return ret;540}541 542/**543 * sdw_prep_deprep_ports() - Prepare/De-prepare port(s) for Master(s) and544 * Slave(s)545 *546 * @m_rt: Master runtime handle547 * @prep: Prepare or De-prepare548 */549static int sdw_prep_deprep_ports(struct sdw_master_runtime *m_rt, bool prep)550{551 struct sdw_slave_runtime *s_rt;552 struct sdw_port_runtime *p_rt;553 int ret = 0;554 555 /* Prepare/De-prepare Slave port(s) */556 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {557 list_for_each_entry(p_rt, &s_rt->port_list, port_node) {558 ret = sdw_prep_deprep_slave_ports(m_rt->bus, s_rt,559 p_rt, prep);560 if (ret < 0)561 return ret;562 }563 }564 565 /* Prepare/De-prepare Master port(s) */566 list_for_each_entry(p_rt, &m_rt->port_list, port_node) {567 ret = sdw_prep_deprep_master_ports(m_rt, p_rt, prep);568 if (ret < 0)569 return ret;570 }571 572 return ret;573}574 575/**576 * sdw_notify_config() - Notify bus configuration577 *578 * @m_rt: Master runtime handle579 *580 * This function notifies the Master(s) and Slave(s) of the581 * new bus configuration.582 */583static int sdw_notify_config(struct sdw_master_runtime *m_rt)584{585 struct sdw_slave_runtime *s_rt;586 struct sdw_bus *bus = m_rt->bus;587 struct sdw_slave *slave;588 int ret;589 590 if (bus->ops->set_bus_conf) {591 ret = bus->ops->set_bus_conf(bus, &bus->params);592 if (ret < 0)593 return ret;594 }595 596 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {597 slave = s_rt->slave;598 599 mutex_lock(&slave->sdw_dev_lock);600 601 if (slave->probed) {602 struct device *dev = &slave->dev;603 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);604 605 if (drv->ops && drv->ops->bus_config) {606 ret = drv->ops->bus_config(slave, &bus->params);607 if (ret < 0) {608 dev_err(dev, "Notify Slave: %d failed\n",609 slave->dev_num);610 mutex_unlock(&slave->sdw_dev_lock);611 return ret;612 }613 }614 }615 616 mutex_unlock(&slave->sdw_dev_lock);617 }618 619 return 0;620}621 622/**623 * sdw_program_params() - Program transport and port parameters for Master(s)624 * and Slave(s)625 *626 * @bus: SDW bus instance627 * @prepare: true if sdw_program_params() is called by _prepare.628 */629static int sdw_program_params(struct sdw_bus *bus, bool prepare)630{631 struct sdw_master_runtime *m_rt;632 int ret = 0;633 634 list_for_each_entry(m_rt, &bus->m_rt_list, bus_node) {635 636 /*637 * this loop walks through all master runtimes for a638 * bus, but the ports can only be configured while639 * explicitly preparing a stream or handling an640 * already-prepared stream otherwise.641 */642 if (!prepare &&643 m_rt->stream->state == SDW_STREAM_CONFIGURED)644 continue;645 646 ret = sdw_program_port_params(m_rt);647 if (ret < 0) {648 dev_err(bus->dev,649 "Program transport params failed: %d\n", ret);650 return ret;651 }652 653 ret = sdw_notify_config(m_rt);654 if (ret < 0) {655 dev_err(bus->dev,656 "Notify bus config failed: %d\n", ret);657 return ret;658 }659 660 /* Enable port(s) on alternate bank for all active streams */661 if (m_rt->stream->state != SDW_STREAM_ENABLED)662 continue;663 664 ret = sdw_enable_disable_ports(m_rt, true);665 if (ret < 0) {666 dev_err(bus->dev, "Enable channel failed: %d\n", ret);667 return ret;668 }669 }670 671 return ret;672}673 674static int sdw_bank_switch(struct sdw_bus *bus, int m_rt_count)675{676 int col_index, row_index;677 bool multi_link;678 struct sdw_msg *wr_msg;679 u8 *wbuf;680 int ret;681 u16 addr;682 683 wr_msg = kzalloc(sizeof(*wr_msg), GFP_KERNEL);684 if (!wr_msg)685 return -ENOMEM;686 687 wbuf = kzalloc(sizeof(*wbuf), GFP_KERNEL);688 if (!wbuf) {689 ret = -ENOMEM;690 goto error_1;691 }692 693 /* Get row and column index to program register */694 col_index = sdw_find_col_index(bus->params.col);695 row_index = sdw_find_row_index(bus->params.row);696 wbuf[0] = col_index | (row_index << 3);697 698 if (bus->params.next_bank)699 addr = SDW_SCP_FRAMECTRL_B1;700 else701 addr = SDW_SCP_FRAMECTRL_B0;702 703 sdw_fill_msg(wr_msg, NULL, addr, 1, SDW_BROADCAST_DEV_NUM,704 SDW_MSG_FLAG_WRITE, wbuf);705 wr_msg->ssp_sync = true;706 707 /*708 * Set the multi_link flag only when both the hardware supports709 * and hardware-based sync is required710 */711 multi_link = bus->multi_link && (m_rt_count >= bus->hw_sync_min_links);712 713 if (multi_link)714 ret = sdw_transfer_defer(bus, wr_msg);715 else716 ret = sdw_transfer(bus, wr_msg);717 718 if (ret < 0 && ret != -ENODATA) {719 dev_err(bus->dev, "Slave frame_ctrl reg write failed\n");720 goto error;721 }722 723 if (!multi_link) {724 kfree(wbuf);725 kfree(wr_msg);726 bus->defer_msg.msg = NULL;727 bus->params.curr_bank = !bus->params.curr_bank;728 bus->params.next_bank = !bus->params.next_bank;729 }730 731 return 0;732 733error:734 kfree(wbuf);735error_1:736 kfree(wr_msg);737 bus->defer_msg.msg = NULL;738 return ret;739}740 741/**742 * sdw_ml_sync_bank_switch: Multilink register bank switch743 *744 * @bus: SDW bus instance745 * @multi_link: whether this is a multi-link stream with hardware-based sync746 *747 * Caller function should free the buffers on error748 */749static int sdw_ml_sync_bank_switch(struct sdw_bus *bus, bool multi_link)750{751 unsigned long time_left;752 753 if (!multi_link)754 return 0;755 756 /* Wait for completion of transfer */757 time_left = wait_for_completion_timeout(&bus->defer_msg.complete,758 bus->bank_switch_timeout);759 760 if (!time_left) {761 dev_err(bus->dev, "Controller Timed out on bank switch\n");762 return -ETIMEDOUT;763 }764 765 bus->params.curr_bank = !bus->params.curr_bank;766 bus->params.next_bank = !bus->params.next_bank;767 768 if (bus->defer_msg.msg) {769 kfree(bus->defer_msg.msg->buf);770 kfree(bus->defer_msg.msg);771 bus->defer_msg.msg = NULL;772 }773 774 return 0;775}776 777static int do_bank_switch(struct sdw_stream_runtime *stream)778{779 struct sdw_master_runtime *m_rt;780 const struct sdw_master_ops *ops;781 struct sdw_bus *bus;782 bool multi_link = false;783 int m_rt_count;784 int ret = 0;785 786 m_rt_count = stream->m_rt_count;787 788 list_for_each_entry(m_rt, &stream->master_list, stream_node) {789 bus = m_rt->bus;790 ops = bus->ops;791 792 if (bus->multi_link && m_rt_count >= bus->hw_sync_min_links) {793 multi_link = true;794 mutex_lock(&bus->msg_lock);795 }796 797 /* Pre-bank switch */798 if (ops->pre_bank_switch) {799 ret = ops->pre_bank_switch(bus);800 if (ret < 0) {801 dev_err(bus->dev,802 "Pre bank switch op failed: %d\n", ret);803 goto msg_unlock;804 }805 }806 807 /*808 * Perform Bank switch operation.809 * For multi link cases, the actual bank switch is810 * synchronized across all Masters and happens later as a811 * part of post_bank_switch ops.812 */813 ret = sdw_bank_switch(bus, m_rt_count);814 if (ret < 0) {815 dev_err(bus->dev, "Bank switch failed: %d\n", ret);816 goto error;817 }818 }819 820 /*821 * For multi link cases, it is expected that the bank switch is822 * triggered by the post_bank_switch for the first Master in the list823 * and for the other Masters the post_bank_switch() should return doing824 * nothing.825 */826 list_for_each_entry(m_rt, &stream->master_list, stream_node) {827 bus = m_rt->bus;828 ops = bus->ops;829 830 /* Post-bank switch */831 if (ops->post_bank_switch) {832 ret = ops->post_bank_switch(bus);833 if (ret < 0) {834 dev_err(bus->dev,835 "Post bank switch op failed: %d\n",836 ret);837 goto error;838 }839 } else if (multi_link) {840 dev_err(bus->dev,841 "Post bank switch ops not implemented\n");842 ret = -EINVAL;843 goto error;844 }845 846 /* Set the bank switch timeout to default, if not set */847 if (!bus->bank_switch_timeout)848 bus->bank_switch_timeout = DEFAULT_BANK_SWITCH_TIMEOUT;849 850 /* Check if bank switch was successful */851 ret = sdw_ml_sync_bank_switch(bus, multi_link);852 if (ret < 0) {853 dev_err(bus->dev,854 "multi link bank switch failed: %d\n", ret);855 goto error;856 }857 858 if (multi_link)859 mutex_unlock(&bus->msg_lock);860 }861 862 return ret;863 864error:865 list_for_each_entry(m_rt, &stream->master_list, stream_node) {866 bus = m_rt->bus;867 if (bus->defer_msg.msg) {868 kfree(bus->defer_msg.msg->buf);869 kfree(bus->defer_msg.msg);870 bus->defer_msg.msg = NULL;871 }872 }873 874msg_unlock:875 876 if (multi_link) {877 list_for_each_entry(m_rt, &stream->master_list, stream_node) {878 bus = m_rt->bus;879 if (mutex_is_locked(&bus->msg_lock))880 mutex_unlock(&bus->msg_lock);881 }882 }883 884 return ret;885}886 887static struct sdw_port_runtime *sdw_port_alloc(struct list_head *port_list)888{889 struct sdw_port_runtime *p_rt;890 891 p_rt = kzalloc(sizeof(*p_rt), GFP_KERNEL);892 if (!p_rt)893 return NULL;894 895 list_add_tail(&p_rt->port_node, port_list);896 897 return p_rt;898}899 900static int sdw_port_config(struct sdw_port_runtime *p_rt,901 const struct sdw_port_config *port_config,902 int port_index)903{904 p_rt->ch_mask = port_config[port_index].ch_mask;905 p_rt->num = port_config[port_index].num;906 907 /*908 * TODO: Check port capabilities for requested configuration909 */910 911 return 0;912}913 914static void sdw_port_free(struct sdw_port_runtime *p_rt)915{916 list_del(&p_rt->port_node);917 kfree(p_rt);918}919 920static bool sdw_slave_port_allocated(struct sdw_slave_runtime *s_rt)921{922 return !list_empty(&s_rt->port_list);923}924 925static void sdw_slave_port_free(struct sdw_slave *slave,926 struct sdw_stream_runtime *stream)927{928 struct sdw_port_runtime *p_rt, *_p_rt;929 struct sdw_master_runtime *m_rt;930 struct sdw_slave_runtime *s_rt;931 932 list_for_each_entry(m_rt, &stream->master_list, stream_node) {933 list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {934 if (s_rt->slave != slave)935 continue;936 937 list_for_each_entry_safe(p_rt, _p_rt,938 &s_rt->port_list, port_node) {939 sdw_port_free(p_rt);940 }941 }942 }943}944 945static int sdw_slave_port_alloc(struct sdw_slave *slave,946 struct sdw_slave_runtime *s_rt,947 unsigned int num_config)948{949 struct sdw_port_runtime *p_rt;950 int i;951 952 /* Iterate for number of ports to perform initialization */953 for (i = 0; i < num_config; i++) {954 p_rt = sdw_port_alloc(&s_rt->port_list);955 if (!p_rt)956 return -ENOMEM;957 }958 959 return 0;960}961 962static int sdw_slave_port_is_valid_range(struct device *dev, int num)963{964 if (!SDW_VALID_PORT_RANGE(num)) {965 dev_err(dev, "SoundWire: Invalid port number :%d\n", num);966 return -EINVAL;967 }968 969 return 0;970}971 972static int sdw_slave_port_config(struct sdw_slave *slave,973 struct sdw_slave_runtime *s_rt,974 const struct sdw_port_config *port_config)975{976 struct sdw_port_runtime *p_rt;977 int ret;978 int i;979 980 i = 0;981 list_for_each_entry(p_rt, &s_rt->port_list, port_node) {982 /*983 * TODO: Check valid port range as defined by DisCo/984 * slave985 */986 ret = sdw_slave_port_is_valid_range(&slave->dev, port_config[i].num);987 if (ret < 0)988 return ret;989 990 ret = sdw_port_config(p_rt, port_config, i);991 if (ret < 0)992 return ret;993 i++;994 }995 996 return 0;997}998 999static bool sdw_master_port_allocated(struct sdw_master_runtime *m_rt)1000{1001 return !list_empty(&m_rt->port_list);1002}1003 1004static void sdw_master_port_free(struct sdw_master_runtime *m_rt)1005{1006 struct sdw_port_runtime *p_rt, *_p_rt;1007 1008 list_for_each_entry_safe(p_rt, _p_rt, &m_rt->port_list, port_node) {1009 sdw_port_free(p_rt);1010 }1011}1012 1013static int sdw_master_port_alloc(struct sdw_master_runtime *m_rt,1014 unsigned int num_ports)1015{1016 struct sdw_port_runtime *p_rt;1017 int i;1018 1019 /* Iterate for number of ports to perform initialization */1020 for (i = 0; i < num_ports; i++) {1021 p_rt = sdw_port_alloc(&m_rt->port_list);1022 if (!p_rt)1023 return -ENOMEM;1024 }1025 1026 return 0;1027}1028 1029static int sdw_master_port_config(struct sdw_master_runtime *m_rt,1030 const struct sdw_port_config *port_config)1031{1032 struct sdw_port_runtime *p_rt;1033 int ret;1034 int i;1035 1036 i = 0;1037 list_for_each_entry(p_rt, &m_rt->port_list, port_node) {1038 ret = sdw_port_config(p_rt, port_config, i);1039 if (ret < 0)1040 return ret;1041 i++;1042 }1043 1044 return 0;1045}1046 1047/**1048 * sdw_slave_rt_alloc() - Allocate a Slave runtime handle.1049 *1050 * @slave: Slave handle1051 * @m_rt: Master runtime handle1052 *1053 * This function is to be called with bus_lock held.1054 */1055static struct sdw_slave_runtime1056*sdw_slave_rt_alloc(struct sdw_slave *slave,1057 struct sdw_master_runtime *m_rt)1058{1059 struct sdw_slave_runtime *s_rt;1060 1061 s_rt = kzalloc(sizeof(*s_rt), GFP_KERNEL);1062 if (!s_rt)1063 return NULL;1064 1065 INIT_LIST_HEAD(&s_rt->port_list);1066 s_rt->slave = slave;1067 1068 list_add_tail(&s_rt->m_rt_node, &m_rt->slave_rt_list);1069 1070 return s_rt;1071}1072 1073/**1074 * sdw_slave_rt_config() - Configure a Slave runtime handle.1075 *1076 * @s_rt: Slave runtime handle1077 * @stream_config: Stream configuration1078 *1079 * This function is to be called with bus_lock held.1080 */1081static int sdw_slave_rt_config(struct sdw_slave_runtime *s_rt,1082 struct sdw_stream_config *stream_config)1083{1084 s_rt->ch_count = stream_config->ch_count;1085 s_rt->direction = stream_config->direction;1086 1087 return 0;1088}1089 1090static struct sdw_slave_runtime *sdw_slave_rt_find(struct sdw_slave *slave,1091 struct sdw_stream_runtime *stream)1092{1093 struct sdw_slave_runtime *s_rt, *_s_rt;1094 struct sdw_master_runtime *m_rt;1095 1096 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1097 /* Retrieve Slave runtime handle */1098 list_for_each_entry_safe(s_rt, _s_rt,1099 &m_rt->slave_rt_list, m_rt_node) {1100 if (s_rt->slave == slave)1101 return s_rt;1102 }1103 }1104 return NULL;1105}1106 1107/**1108 * sdw_slave_rt_free() - Free Slave(s) runtime handle1109 *1110 * @slave: Slave handle.1111 * @stream: Stream runtime handle.1112 *1113 * This function is to be called with bus_lock held.1114 */1115static void sdw_slave_rt_free(struct sdw_slave *slave,1116 struct sdw_stream_runtime *stream)1117{1118 struct sdw_slave_runtime *s_rt;1119 1120 s_rt = sdw_slave_rt_find(slave, stream);1121 if (s_rt) {1122 list_del(&s_rt->m_rt_node);1123 kfree(s_rt);1124 }1125}1126 1127static struct sdw_master_runtime1128*sdw_master_rt_find(struct sdw_bus *bus,1129 struct sdw_stream_runtime *stream)1130{1131 struct sdw_master_runtime *m_rt;1132 1133 /* Retrieve Bus handle if already available */1134 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1135 if (m_rt->bus == bus)1136 return m_rt;1137 }1138 1139 return NULL;1140}1141 1142/**1143 * sdw_master_rt_alloc() - Allocates a Master runtime handle1144 *1145 * @bus: SDW bus instance1146 * @stream: Stream runtime handle.1147 *1148 * This function is to be called with bus_lock held.1149 */1150static struct sdw_master_runtime1151*sdw_master_rt_alloc(struct sdw_bus *bus,1152 struct sdw_stream_runtime *stream)1153{1154 struct sdw_master_runtime *m_rt, *walk_m_rt;1155 struct list_head *insert_after;1156 1157 m_rt = kzalloc(sizeof(*m_rt), GFP_KERNEL);1158 if (!m_rt)1159 return NULL;1160 1161 /* Initialization of Master runtime handle */1162 INIT_LIST_HEAD(&m_rt->port_list);1163 INIT_LIST_HEAD(&m_rt->slave_rt_list);1164 1165 /*1166 * Add in order of bus id so that when taking the bus_lock1167 * of multiple buses they will always be taken in the same1168 * order to prevent a mutex deadlock.1169 */1170 insert_after = &stream->master_list;1171 list_for_each_entry_reverse(walk_m_rt, &stream->master_list, stream_node) {1172 if (walk_m_rt->bus->id < bus->id) {1173 insert_after = &walk_m_rt->stream_node;1174 break;1175 }1176 }1177 list_add(&m_rt->stream_node, insert_after);1178 1179 list_add_tail(&m_rt->bus_node, &bus->m_rt_list);1180 1181 m_rt->bus = bus;1182 m_rt->stream = stream;1183 1184 bus->stream_refcount++;1185 1186 return m_rt;1187}1188 1189/**1190 * sdw_master_rt_config() - Configure Master runtime handle1191 *1192 * @m_rt: Master runtime handle1193 * @stream_config: Stream configuration1194 *1195 * This function is to be called with bus_lock held.1196 */1197 1198static int sdw_master_rt_config(struct sdw_master_runtime *m_rt,1199 struct sdw_stream_config *stream_config)1200{1201 m_rt->ch_count = stream_config->ch_count;1202 m_rt->direction = stream_config->direction;1203 1204 return 0;1205}1206 1207/**1208 * sdw_master_rt_free() - Free Master runtime handle1209 *1210 * @m_rt: Master runtime node1211 * @stream: Stream runtime handle.1212 *1213 * This function is to be called with bus_lock held1214 * It frees the Master runtime handle and associated Slave(s) runtime1215 * handle. If this is called first then sdw_slave_rt_free() will have1216 * no effect as Slave(s) runtime handle would already be freed up.1217 */1218static void sdw_master_rt_free(struct sdw_master_runtime *m_rt,1219 struct sdw_stream_runtime *stream)1220{1221 struct sdw_slave_runtime *s_rt, *_s_rt;1222 struct sdw_bus *bus = m_rt->bus;1223 1224 list_for_each_entry_safe(s_rt, _s_rt, &m_rt->slave_rt_list, m_rt_node) {1225 sdw_slave_port_free(s_rt->slave, stream);1226 sdw_slave_rt_free(s_rt->slave, stream);1227 }1228 1229 list_del(&m_rt->stream_node);1230 list_del(&m_rt->bus_node);1231 kfree(m_rt);1232 1233 bus->stream_refcount--;1234}1235 1236/**1237 * sdw_config_stream() - Configure the allocated stream1238 *1239 * @dev: SDW device1240 * @stream: SoundWire stream1241 * @stream_config: Stream configuration for audio stream1242 * @is_slave: is API called from Slave or Master1243 *1244 * This function is to be called with bus_lock held.1245 */1246static int sdw_config_stream(struct device *dev,1247 struct sdw_stream_runtime *stream,1248 struct sdw_stream_config *stream_config,1249 bool is_slave)1250{1251 /*1252 * Update the stream rate, channel and bps based on data1253 * source. For more than one data source (multilink),1254 * match the rate, bps, stream type and increment number of channels.1255 *1256 * If rate/bps is zero, it means the values are not set, so skip1257 * comparison and allow the value to be set and stored in stream1258 */1259 if (stream->params.rate &&1260 stream->params.rate != stream_config->frame_rate) {1261 dev_err(dev, "rate not matching, stream:%s\n", stream->name);1262 return -EINVAL;1263 }1264 1265 if (stream->params.bps &&1266 stream->params.bps != stream_config->bps) {1267 dev_err(dev, "bps not matching, stream:%s\n", stream->name);1268 return -EINVAL;1269 }1270 1271 stream->type = stream_config->type;1272 stream->params.rate = stream_config->frame_rate;1273 stream->params.bps = stream_config->bps;1274 1275 /* TODO: Update this check during Device-device support */1276 if (is_slave)1277 stream->params.ch_count += stream_config->ch_count;1278 1279 return 0;1280}1281 1282/**1283 * sdw_get_slave_dpn_prop() - Get Slave port capabilities1284 *1285 * @slave: Slave handle1286 * @direction: Data direction.1287 * @port_num: Port number1288 */1289struct sdw_dpn_prop *sdw_get_slave_dpn_prop(struct sdw_slave *slave,1290 enum sdw_data_direction direction,1291 unsigned int port_num)1292{1293 struct sdw_dpn_prop *dpn_prop;1294 u8 num_ports;1295 int i;1296 1297 if (direction == SDW_DATA_DIR_TX) {1298 num_ports = hweight32(slave->prop.source_ports);1299 dpn_prop = slave->prop.src_dpn_prop;1300 } else {1301 num_ports = hweight32(slave->prop.sink_ports);1302 dpn_prop = slave->prop.sink_dpn_prop;1303 }1304 1305 for (i = 0; i < num_ports; i++) {1306 if (dpn_prop[i].num == port_num)1307 return &dpn_prop[i];1308 }1309 1310 return NULL;1311}1312 1313/**1314 * sdw_acquire_bus_lock: Acquire bus lock for all Master runtime(s)1315 *1316 * @stream: SoundWire stream1317 *1318 * Acquire bus_lock for each of the master runtime(m_rt) part of this1319 * stream to reconfigure the bus.1320 * NOTE: This function is called from SoundWire stream ops and is1321 * expected that a global lock is held before acquiring bus_lock.1322 */1323static void sdw_acquire_bus_lock(struct sdw_stream_runtime *stream)1324{1325 struct sdw_master_runtime *m_rt;1326 struct sdw_bus *bus;1327 1328 /* Iterate for all Master(s) in Master list */1329 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1330 bus = m_rt->bus;1331 1332 mutex_lock(&bus->bus_lock);1333 }1334}1335 1336/**1337 * sdw_release_bus_lock: Release bus lock for all Master runtime(s)1338 *1339 * @stream: SoundWire stream1340 *1341 * Release the previously held bus_lock after reconfiguring the bus.1342 * NOTE: This function is called from SoundWire stream ops and is1343 * expected that a global lock is held before releasing bus_lock.1344 */1345static void sdw_release_bus_lock(struct sdw_stream_runtime *stream)1346{1347 struct sdw_master_runtime *m_rt;1348 struct sdw_bus *bus;1349 1350 /* Iterate for all Master(s) in Master list */1351 list_for_each_entry_reverse(m_rt, &stream->master_list, stream_node) {1352 bus = m_rt->bus;1353 mutex_unlock(&bus->bus_lock);1354 }1355}1356 1357static int _sdw_prepare_stream(struct sdw_stream_runtime *stream,1358 bool update_params)1359{1360 struct sdw_master_runtime *m_rt;1361 struct sdw_bus *bus;1362 struct sdw_master_prop *prop;1363 struct sdw_bus_params params;1364 int ret;1365 1366 /* Prepare Master(s) and Slave(s) port(s) associated with stream */1367 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1368 bus = m_rt->bus;1369 prop = &bus->prop;1370 memcpy(¶ms, &bus->params, sizeof(params));1371 1372 /* TODO: Support Asynchronous mode */1373 if ((prop->max_clk_freq % stream->params.rate) != 0) {1374 dev_err(bus->dev, "Async mode not supported\n");1375 return -EINVAL;1376 }1377 1378 if (update_params) {1379 /* Increment cumulative bus bandwidth */1380 /* TODO: Update this during Device-Device support */1381 bus->params.bandwidth += m_rt->stream->params.rate *1382 m_rt->ch_count * m_rt->stream->params.bps;1383 1384 /* Compute params */1385 if (bus->compute_params) {1386 ret = bus->compute_params(bus);1387 if (ret < 0) {1388 dev_err(bus->dev, "Compute params failed: %d\n",1389 ret);1390 goto restore_params;1391 }1392 }1393 }1394 1395 /* Program params */1396 ret = sdw_program_params(bus, true);1397 if (ret < 0) {1398 dev_err(bus->dev, "Program params failed: %d\n", ret);1399 goto restore_params;1400 }1401 }1402 1403 ret = do_bank_switch(stream);1404 if (ret < 0) {1405 pr_err("%s: do_bank_switch failed: %d\n", __func__, ret);1406 goto restore_params;1407 }1408 1409 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1410 bus = m_rt->bus;1411 1412 /* Prepare port(s) on the new clock configuration */1413 ret = sdw_prep_deprep_ports(m_rt, true);1414 if (ret < 0) {1415 dev_err(bus->dev, "Prepare port(s) failed ret = %d\n",1416 ret);1417 return ret;1418 }1419 }1420 1421 stream->state = SDW_STREAM_PREPARED;1422 1423 return ret;1424 1425restore_params:1426 memcpy(&bus->params, ¶ms, sizeof(params));1427 return ret;1428}1429 1430/**1431 * sdw_prepare_stream() - Prepare SoundWire stream1432 *1433 * @stream: Soundwire stream1434 *1435 * Documentation/driver-api/soundwire/stream.rst explains this API in detail1436 */1437int sdw_prepare_stream(struct sdw_stream_runtime *stream)1438{1439 bool update_params = true;1440 int ret;1441 1442 if (!stream) {1443 pr_err("SoundWire: Handle not found for stream\n");1444 return -EINVAL;1445 }1446 1447 sdw_acquire_bus_lock(stream);1448 1449 if (stream->state == SDW_STREAM_PREPARED) {1450 ret = 0;1451 goto state_err;1452 }1453 1454 if (stream->state != SDW_STREAM_CONFIGURED &&1455 stream->state != SDW_STREAM_DEPREPARED &&1456 stream->state != SDW_STREAM_DISABLED) {1457 pr_err("%s: %s: inconsistent state state %d\n",1458 __func__, stream->name, stream->state);1459 ret = -EINVAL;1460 goto state_err;1461 }1462 1463 /*1464 * when the stream is DISABLED, this means sdw_prepare_stream()1465 * is called as a result of an underflow or a resume operation.1466 * In this case, the bus parameters shall not be recomputed, but1467 * still need to be re-applied1468 */1469 if (stream->state == SDW_STREAM_DISABLED)1470 update_params = false;1471 1472 ret = _sdw_prepare_stream(stream, update_params);1473 1474state_err:1475 sdw_release_bus_lock(stream);1476 return ret;1477}1478EXPORT_SYMBOL(sdw_prepare_stream);1479 1480static int _sdw_enable_stream(struct sdw_stream_runtime *stream)1481{1482 struct sdw_master_runtime *m_rt;1483 struct sdw_bus *bus;1484 int ret;1485 1486 /* Enable Master(s) and Slave(s) port(s) associated with stream */1487 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1488 bus = m_rt->bus;1489 1490 /* Program params */1491 ret = sdw_program_params(bus, false);1492 if (ret < 0) {1493 dev_err(bus->dev, "%s: Program params failed: %d\n", __func__, ret);1494 return ret;1495 }1496 1497 /* Enable port(s) */1498 ret = sdw_enable_disable_ports(m_rt, true);1499 if (ret < 0) {1500 dev_err(bus->dev,1501 "Enable port(s) failed ret: %d\n", ret);1502 return ret;1503 }1504 }1505 1506 ret = do_bank_switch(stream);1507 if (ret < 0) {1508 pr_err("%s: do_bank_switch failed: %d\n", __func__, ret);1509 return ret;1510 }1511 1512 stream->state = SDW_STREAM_ENABLED;1513 return 0;1514}1515 1516/**1517 * sdw_enable_stream() - Enable SoundWire stream1518 *1519 * @stream: Soundwire stream1520 *1521 * Documentation/driver-api/soundwire/stream.rst explains this API in detail1522 */1523int sdw_enable_stream(struct sdw_stream_runtime *stream)1524{1525 int ret;1526 1527 if (!stream) {1528 pr_err("SoundWire: Handle not found for stream\n");1529 return -EINVAL;1530 }1531 1532 sdw_acquire_bus_lock(stream);1533 1534 if (stream->state == SDW_STREAM_ENABLED) {1535 ret = 0;1536 goto state_err;1537 }1538 1539 if (stream->state != SDW_STREAM_PREPARED &&1540 stream->state != SDW_STREAM_DISABLED) {1541 pr_err("%s: %s: inconsistent state state %d\n",1542 __func__, stream->name, stream->state);1543 ret = -EINVAL;1544 goto state_err;1545 }1546 1547 ret = _sdw_enable_stream(stream);1548 1549state_err:1550 sdw_release_bus_lock(stream);1551 return ret;1552}1553EXPORT_SYMBOL(sdw_enable_stream);1554 1555static int _sdw_disable_stream(struct sdw_stream_runtime *stream)1556{1557 struct sdw_master_runtime *m_rt;1558 int ret;1559 1560 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1561 struct sdw_bus *bus = m_rt->bus;1562 1563 /* Disable port(s) */1564 ret = sdw_enable_disable_ports(m_rt, false);1565 if (ret < 0) {1566 dev_err(bus->dev, "Disable port(s) failed: %d\n", ret);1567 return ret;1568 }1569 }1570 stream->state = SDW_STREAM_DISABLED;1571 1572 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1573 struct sdw_bus *bus = m_rt->bus;1574 1575 /* Program params */1576 ret = sdw_program_params(bus, false);1577 if (ret < 0) {1578 dev_err(bus->dev, "%s: Program params failed: %d\n", __func__, ret);1579 return ret;1580 }1581 }1582 1583 ret = do_bank_switch(stream);1584 if (ret < 0) {1585 pr_err("%s: do_bank_switch failed: %d\n", __func__, ret);1586 return ret;1587 }1588 1589 /* make sure alternate bank (previous current) is also disabled */1590 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1591 struct sdw_bus *bus = m_rt->bus;1592 1593 /* Disable port(s) */1594 ret = sdw_enable_disable_ports(m_rt, false);1595 if (ret < 0) {1596 dev_err(bus->dev, "Disable port(s) failed: %d\n", ret);1597 return ret;1598 }1599 }1600 1601 return 0;1602}1603 1604/**1605 * sdw_disable_stream() - Disable SoundWire stream1606 *1607 * @stream: Soundwire stream1608 *1609 * Documentation/driver-api/soundwire/stream.rst explains this API in detail1610 */1611int sdw_disable_stream(struct sdw_stream_runtime *stream)1612{1613 int ret;1614 1615 if (!stream) {1616 pr_err("SoundWire: Handle not found for stream\n");1617 return -EINVAL;1618 }1619 1620 sdw_acquire_bus_lock(stream);1621 1622 if (stream->state == SDW_STREAM_DISABLED) {1623 ret = 0;1624 goto state_err;1625 }1626 1627 if (stream->state != SDW_STREAM_ENABLED) {1628 pr_err("%s: %s: inconsistent state state %d\n",1629 __func__, stream->name, stream->state);1630 ret = -EINVAL;1631 goto state_err;1632 }1633 1634 ret = _sdw_disable_stream(stream);1635 1636state_err:1637 sdw_release_bus_lock(stream);1638 return ret;1639}1640EXPORT_SYMBOL(sdw_disable_stream);1641 1642static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream)1643{1644 struct sdw_master_runtime *m_rt;1645 struct sdw_bus *bus;1646 int ret = 0;1647 1648 list_for_each_entry(m_rt, &stream->master_list, stream_node) {1649 bus = m_rt->bus;1650 /* De-prepare port(s) */1651 ret = sdw_prep_deprep_ports(m_rt, false);1652 if (ret < 0) {1653 dev_err(bus->dev,1654 "De-prepare port(s) failed: %d\n", ret);1655 return ret;1656 }1657 1658 /* TODO: Update this during Device-Device support */1659 bus->params.bandwidth -= m_rt->stream->params.rate *1660 m_rt->ch_count * m_rt->stream->params.bps;1661 1662 /* Compute params */1663 if (bus->compute_params) {1664 ret = bus->compute_params(bus);1665 if (ret < 0) {1666 dev_err(bus->dev, "Compute params failed: %d\n",1667 ret);1668 return ret;1669 }1670 }1671 1672 /* Program params */1673 ret = sdw_program_params(bus, false);1674 if (ret < 0) {1675 dev_err(bus->dev, "%s: Program params failed: %d\n", __func__, ret);1676 return ret;1677 }1678 }1679 1680 stream->state = SDW_STREAM_DEPREPARED;1681 return do_bank_switch(stream);1682}1683 1684/**1685 * sdw_deprepare_stream() - Deprepare SoundWire stream1686 *1687 * @stream: Soundwire stream1688 *1689 * Documentation/driver-api/soundwire/stream.rst explains this API in detail1690 */1691int sdw_deprepare_stream(struct sdw_stream_runtime *stream)1692{1693 int ret;1694 1695 if (!stream) {1696 pr_err("SoundWire: Handle not found for stream\n");1697 return -EINVAL;1698 }1699 1700 sdw_acquire_bus_lock(stream);1701 1702 if (stream->state == SDW_STREAM_DEPREPARED) {1703 ret = 0;1704 goto state_err;1705 }1706 1707 if (stream->state != SDW_STREAM_PREPARED &&1708 stream->state != SDW_STREAM_DISABLED) {1709 pr_err("%s: %s: inconsistent state state %d\n",1710 __func__, stream->name, stream->state);1711 ret = -EINVAL;1712 goto state_err;1713 }1714 1715 ret = _sdw_deprepare_stream(stream);1716 1717state_err:1718 sdw_release_bus_lock(stream);1719 return ret;1720}1721EXPORT_SYMBOL(sdw_deprepare_stream);1722 1723static int set_stream(struct snd_pcm_substream *substream,1724 struct sdw_stream_runtime *sdw_stream)1725{1726 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);1727 struct snd_soc_dai *dai;1728 int ret = 0;1729 int i;1730 1731 /* Set stream pointer on all DAIs */1732 for_each_rtd_dais(rtd, i, dai) {1733 ret = snd_soc_dai_set_stream(dai, sdw_stream, substream->stream);1734 if (ret < 0) {1735 dev_err(rtd->dev, "failed to set stream pointer on dai %s\n", dai->name);1736 break;1737 }1738 }1739 1740 return ret;1741}1742 1743/**1744 * sdw_alloc_stream() - Allocate and return stream runtime1745 *1746 * @stream_name: SoundWire stream name1747 *1748 * Allocates a SoundWire stream runtime instance.1749 * sdw_alloc_stream should be called only once per stream. Typically1750 * invoked from ALSA/ASoC machine/platform driver.1751 */1752struct sdw_stream_runtime *sdw_alloc_stream(const char *stream_name)1753{1754 struct sdw_stream_runtime *stream;1755 1756 stream = kzalloc(sizeof(*stream), GFP_KERNEL);1757 if (!stream)1758 return NULL;1759 1760 stream->name = stream_name;1761 INIT_LIST_HEAD(&stream->master_list);1762 stream->state = SDW_STREAM_ALLOCATED;1763 stream->m_rt_count = 0;1764 1765 return stream;1766}1767EXPORT_SYMBOL(sdw_alloc_stream);1768 1769/**1770 * sdw_startup_stream() - Startup SoundWire stream1771 *1772 * @sdw_substream: Soundwire stream1773 *1774 * Documentation/driver-api/soundwire/stream.rst explains this API in detail1775 */1776int sdw_startup_stream(void *sdw_substream)1777{1778 struct snd_pcm_substream *substream = sdw_substream;1779 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);1780 struct sdw_stream_runtime *sdw_stream;1781 char *name;1782 int ret;1783 1784 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)1785 name = kasprintf(GFP_KERNEL, "%s-Playback", substream->name);1786 else1787 name = kasprintf(GFP_KERNEL, "%s-Capture", substream->name);1788 1789 if (!name)1790 return -ENOMEM;1791 1792 sdw_stream = sdw_alloc_stream(name);1793 if (!sdw_stream) {1794 dev_err(rtd->dev, "alloc stream failed for substream DAI %s\n", substream->name);1795 ret = -ENOMEM;1796 goto error;1797 }1798 1799 ret = set_stream(substream, sdw_stream);1800 if (ret < 0)1801 goto release_stream;1802 return 0;1803 1804release_stream:1805 sdw_release_stream(sdw_stream);1806 set_stream(substream, NULL);1807error:1808 kfree(name);1809 return ret;1810}1811EXPORT_SYMBOL(sdw_startup_stream);1812 1813/**1814 * sdw_shutdown_stream() - Shutdown SoundWire stream1815 *1816 * @sdw_substream: Soundwire stream1817 *1818 * Documentation/driver-api/soundwire/stream.rst explains this API in detail1819 */1820void sdw_shutdown_stream(void *sdw_substream)1821{1822 struct snd_pcm_substream *substream = sdw_substream;1823 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);1824 struct sdw_stream_runtime *sdw_stream;1825 struct snd_soc_dai *dai;1826 1827 /* Find stream from first CPU DAI */1828 dai = snd_soc_rtd_to_cpu(rtd, 0);1829 1830 sdw_stream = snd_soc_dai_get_stream(dai, substream->stream);1831 1832 if (IS_ERR(sdw_stream)) {1833 dev_err(rtd->dev, "no stream found for DAI %s\n", dai->name);1834 return;1835 }1836 1837 /* release memory */1838 kfree(sdw_stream->name);1839 sdw_release_stream(sdw_stream);1840 1841 /* clear DAI data */1842 set_stream(substream, NULL);1843}1844EXPORT_SYMBOL(sdw_shutdown_stream);1845 1846/**1847 * sdw_release_stream() - Free the assigned stream runtime1848 *1849 * @stream: SoundWire stream runtime1850 *1851 * sdw_release_stream should be called only once per stream1852 */1853void sdw_release_stream(struct sdw_stream_runtime *stream)1854{1855 kfree(stream);1856}1857EXPORT_SYMBOL(sdw_release_stream);1858 1859/**1860 * sdw_stream_add_master() - Allocate and add master runtime to a stream1861 *1862 * @bus: SDW Bus instance1863 * @stream_config: Stream configuration for audio stream1864 * @port_config: Port configuration for audio stream1865 * @num_ports: Number of ports1866 * @stream: SoundWire stream1867 */1868int sdw_stream_add_master(struct sdw_bus *bus,1869 struct sdw_stream_config *stream_config,1870 const struct sdw_port_config *port_config,1871 unsigned int num_ports,1872 struct sdw_stream_runtime *stream)1873{1874 struct sdw_master_runtime *m_rt;1875 bool alloc_master_rt = false;1876 int ret;1877 1878 mutex_lock(&bus->bus_lock);1879 1880 /*1881 * For multi link streams, add the second master only if1882 * the bus supports it.1883 * Check if bus->multi_link is set1884 */1885 if (!bus->multi_link && stream->m_rt_count > 0) {1886 dev_err(bus->dev,1887 "Multilink not supported, link %d\n", bus->link_id);1888 ret = -EINVAL;1889 goto unlock;1890 }1891 1892 /*1893 * check if Master is already allocated (e.g. as a result of Slave adding1894 * it first), if so skip allocation and go to configuration1895 */1896 m_rt = sdw_master_rt_find(bus, stream);1897 if (!m_rt) {1898 m_rt = sdw_master_rt_alloc(bus, stream);1899 if (!m_rt) {1900 dev_err(bus->dev, "%s: Master runtime alloc failed for stream:%s\n",1901 __func__, stream->name);1902 ret = -ENOMEM;1903 goto unlock;1904 }1905 1906 alloc_master_rt = true;1907 }1908 1909 if (!sdw_master_port_allocated(m_rt)) {1910 ret = sdw_master_port_alloc(m_rt, num_ports);1911 if (ret)1912 goto alloc_error;1913 1914 stream->m_rt_count++;1915 }1916 1917 ret = sdw_master_rt_config(m_rt, stream_config);1918 if (ret < 0)1919 goto unlock;1920 1921 ret = sdw_config_stream(bus->dev, stream, stream_config, false);1922 if (ret)1923 goto unlock;1924 1925 ret = sdw_master_port_config(m_rt, port_config);1926 1927 goto unlock;1928 1929alloc_error:1930 /*1931 * we only cleanup what was allocated in this routine1932 */1933 if (alloc_master_rt)1934 sdw_master_rt_free(m_rt, stream);1935unlock:1936 mutex_unlock(&bus->bus_lock);1937 return ret;1938}1939EXPORT_SYMBOL(sdw_stream_add_master);1940 1941/**1942 * sdw_stream_remove_master() - Remove master from sdw_stream1943 *1944 * @bus: SDW Bus instance1945 * @stream: SoundWire stream1946 *1947 * This removes and frees port_rt and master_rt from a stream1948 */1949int sdw_stream_remove_master(struct sdw_bus *bus,1950 struct sdw_stream_runtime *stream)1951{1952 struct sdw_master_runtime *m_rt, *_m_rt;1953 1954 mutex_lock(&bus->bus_lock);1955 1956 list_for_each_entry_safe(m_rt, _m_rt,1957 &stream->master_list, stream_node) {1958 if (m_rt->bus != bus)1959 continue;1960 1961 sdw_master_port_free(m_rt);1962 sdw_master_rt_free(m_rt, stream);1963 stream->m_rt_count--;1964 }1965 1966 if (list_empty(&stream->master_list))1967 stream->state = SDW_STREAM_RELEASED;1968 1969 mutex_unlock(&bus->bus_lock);1970 1971 return 0;1972}1973EXPORT_SYMBOL(sdw_stream_remove_master);1974 1975/**1976 * sdw_stream_add_slave() - Allocate and add master/slave runtime to a stream1977 *1978 * @slave: SDW Slave instance1979 * @stream_config: Stream configuration for audio stream1980 * @stream: SoundWire stream1981 * @port_config: Port configuration for audio stream1982 * @num_ports: Number of ports1983 *1984 * It is expected that Slave is added before adding Master1985 * to the Stream.1986 *1987 */1988int sdw_stream_add_slave(struct sdw_slave *slave,1989 struct sdw_stream_config *stream_config,1990 const struct sdw_port_config *port_config,1991 unsigned int num_ports,1992 struct sdw_stream_runtime *stream)1993{1994 struct sdw_slave_runtime *s_rt;1995 struct sdw_master_runtime *m_rt;1996 bool alloc_master_rt = false;1997 bool alloc_slave_rt = false;1998 1999 int ret;2000 2001 mutex_lock(&slave->bus->bus_lock);2002 2003 /*2004 * check if Master is already allocated, if so skip allocation2005 * and go to configuration2006 */2007 m_rt = sdw_master_rt_find(slave->bus, stream);2008 if (!m_rt) {2009 /*2010 * If this API is invoked by Slave first then m_rt is not valid.2011 * So, allocate m_rt and add Slave to it.2012 */2013 m_rt = sdw_master_rt_alloc(slave->bus, stream);2014 if (!m_rt) {2015 dev_err(&slave->dev, "%s: Master runtime alloc failed for stream:%s\n",2016 __func__, stream->name);2017 ret = -ENOMEM;2018 goto unlock;2019 }2020 2021 alloc_master_rt = true;2022 }2023 2024 s_rt = sdw_slave_rt_find(slave, stream);2025 if (!s_rt) {2026 s_rt = sdw_slave_rt_alloc(slave, m_rt);2027 if (!s_rt) {2028 dev_err(&slave->dev, "Slave runtime alloc failed for stream:%s\n",2029 stream->name);2030 ret = -ENOMEM;2031 goto alloc_error;2032 }2033 2034 alloc_slave_rt = true;2035 }2036 2037 if (!sdw_slave_port_allocated(s_rt)) {2038 ret = sdw_slave_port_alloc(slave, s_rt, num_ports);2039 if (ret)2040 goto alloc_error;2041 }2042 2043 ret = sdw_master_rt_config(m_rt, stream_config);2044 if (ret)2045 goto unlock;2046 2047 ret = sdw_slave_rt_config(s_rt, stream_config);2048 if (ret)2049 goto unlock;2050 2051 ret = sdw_config_stream(&slave->dev, stream, stream_config, true);2052 if (ret)2053 goto unlock;2054 2055 ret = sdw_slave_port_config(slave, s_rt, port_config);2056 if (ret)2057 goto unlock;2058 2059 /*2060 * Change stream state to CONFIGURED on first Slave add.2061 * Bus is not aware of number of Slave(s) in a stream at this2062 * point so cannot depend on all Slave(s) to be added in order to2063 * change stream state to CONFIGURED.2064 */2065 stream->state = SDW_STREAM_CONFIGURED;2066 goto unlock;2067 2068alloc_error:2069 /*2070 * we only cleanup what was allocated in this routine. The 'else if'2071 * is intentional, the 'master_rt_free' will call sdw_slave_rt_free()2072 * internally.2073 */2074 if (alloc_master_rt)2075 sdw_master_rt_free(m_rt, stream);2076 else if (alloc_slave_rt)2077 sdw_slave_rt_free(slave, stream);2078unlock:2079 mutex_unlock(&slave->bus->bus_lock);2080 return ret;2081}2082EXPORT_SYMBOL(sdw_stream_add_slave);2083 2084/**2085 * sdw_stream_remove_slave() - Remove slave from sdw_stream2086 *2087 * @slave: SDW Slave instance2088 * @stream: SoundWire stream2089 *2090 * This removes and frees port_rt and slave_rt from a stream2091 */2092int sdw_stream_remove_slave(struct sdw_slave *slave,2093 struct sdw_stream_runtime *stream)2094{2095 mutex_lock(&slave->bus->bus_lock);2096 2097 sdw_slave_port_free(slave, stream);2098 sdw_slave_rt_free(slave, stream);2099 2100 mutex_unlock(&slave->bus->bus_lock);2101 2102 return 0;2103}2104EXPORT_SYMBOL(sdw_stream_remove_slave);2105