1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 // Copyright(c) 2015-18 Intel Corporation.
5 * stream.c - SoundWire Bus stream operations.
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 <sound/soc.h>
20 * Array of supported rows and columns as per MIPI SoundWire Specification 1.1
22 * The rows are arranged as per the array index value programmed
23 * in register. The index 15 has dummy value 0 in order to fill hole.
25 int sdw_rows
[SDW_FRAME_ROWS
] = {48, 50, 60, 64, 75, 80, 125, 147,
26 96, 100, 120, 128, 150, 160, 250, 0,
27 192, 200, 240, 256, 72, 144, 90, 180};
28 EXPORT_SYMBOL(sdw_rows
);
30 int sdw_cols
[SDW_FRAME_COLS
] = {2, 4, 6, 8, 10, 12, 14, 16};
31 EXPORT_SYMBOL(sdw_cols
);
33 int sdw_find_col_index(int col
)
37 for (i
= 0; i
< SDW_FRAME_COLS
; i
++) {
38 if (sdw_cols
[i
] == col
)
42 pr_warn("Requested column not found, selecting lowest column no: 2\n");
45 EXPORT_SYMBOL(sdw_find_col_index
);
47 int sdw_find_row_index(int row
)
51 for (i
= 0; i
< SDW_FRAME_ROWS
; i
++) {
52 if (sdw_rows
[i
] == row
)
56 pr_warn("Requested row not found, selecting lowest row no: 48\n");
59 EXPORT_SYMBOL(sdw_find_row_index
);
61 static int _sdw_program_slave_port_params(struct sdw_bus
*bus
,
62 struct sdw_slave
*slave
,
63 struct sdw_transport_params
*t_params
,
64 enum sdw_dpn_type type
)
66 u32 addr1
, addr2
, addr3
, addr4
;
70 if (bus
->params
.next_bank
) {
71 addr1
= SDW_DPN_OFFSETCTRL2_B1(t_params
->port_num
);
72 addr2
= SDW_DPN_BLOCKCTRL3_B1(t_params
->port_num
);
73 addr3
= SDW_DPN_SAMPLECTRL2_B1(t_params
->port_num
);
74 addr4
= SDW_DPN_HCTRL_B1(t_params
->port_num
);
76 addr1
= SDW_DPN_OFFSETCTRL2_B0(t_params
->port_num
);
77 addr2
= SDW_DPN_BLOCKCTRL3_B0(t_params
->port_num
);
78 addr3
= SDW_DPN_SAMPLECTRL2_B0(t_params
->port_num
);
79 addr4
= SDW_DPN_HCTRL_B0(t_params
->port_num
);
82 /* Program DPN_OffsetCtrl2 registers */
83 ret
= sdw_write(slave
, addr1
, t_params
->offset2
);
85 dev_err(bus
->dev
, "DPN_OffsetCtrl2 register write failed\n");
89 /* Program DPN_BlockCtrl3 register */
90 ret
= sdw_write(slave
, addr2
, t_params
->blk_pkg_mode
);
92 dev_err(bus
->dev
, "DPN_BlockCtrl3 register write failed\n");
97 * Data ports are FULL, SIMPLE and REDUCED. This function handles
98 * FULL and REDUCED only and beyond this point only FULL is
99 * handled, so bail out if we are not FULL data port type
101 if (type
!= SDW_DPN_FULL
)
104 /* Program DPN_SampleCtrl2 register */
105 wbuf
= FIELD_GET(SDW_DPN_SAMPLECTRL_HIGH
, t_params
->sample_interval
- 1);
107 ret
= sdw_write(slave
, addr3
, wbuf
);
109 dev_err(bus
->dev
, "DPN_SampleCtrl2 register write failed\n");
113 /* Program DPN_HCtrl register */
114 wbuf
= FIELD_PREP(SDW_DPN_HCTRL_HSTART
, t_params
->hstart
);
115 wbuf
|= FIELD_PREP(SDW_DPN_HCTRL_HSTOP
, t_params
->hstop
);
117 ret
= sdw_write(slave
, addr4
, wbuf
);
119 dev_err(bus
->dev
, "DPN_HCtrl register write failed\n");
124 static int sdw_program_slave_port_params(struct sdw_bus
*bus
,
125 struct sdw_slave_runtime
*s_rt
,
126 struct sdw_port_runtime
*p_rt
)
128 struct sdw_transport_params
*t_params
= &p_rt
->transport_params
;
129 struct sdw_port_params
*p_params
= &p_rt
->port_params
;
130 struct sdw_slave_prop
*slave_prop
= &s_rt
->slave
->prop
;
131 u32 addr1
, addr2
, addr3
, addr4
, addr5
, addr6
;
132 struct sdw_dpn_prop
*dpn_prop
;
136 if (s_rt
->slave
->is_mockup_device
)
139 dpn_prop
= sdw_get_slave_dpn_prop(s_rt
->slave
,
145 addr1
= SDW_DPN_PORTCTRL(t_params
->port_num
);
146 addr2
= SDW_DPN_BLOCKCTRL1(t_params
->port_num
);
148 if (bus
->params
.next_bank
) {
149 addr3
= SDW_DPN_SAMPLECTRL1_B1(t_params
->port_num
);
150 addr4
= SDW_DPN_OFFSETCTRL1_B1(t_params
->port_num
);
151 addr5
= SDW_DPN_BLOCKCTRL2_B1(t_params
->port_num
);
152 addr6
= SDW_DPN_LANECTRL_B1(t_params
->port_num
);
155 addr3
= SDW_DPN_SAMPLECTRL1_B0(t_params
->port_num
);
156 addr4
= SDW_DPN_OFFSETCTRL1_B0(t_params
->port_num
);
157 addr5
= SDW_DPN_BLOCKCTRL2_B0(t_params
->port_num
);
158 addr6
= SDW_DPN_LANECTRL_B0(t_params
->port_num
);
161 /* Program DPN_PortCtrl register */
162 wbuf
= FIELD_PREP(SDW_DPN_PORTCTRL_DATAMODE
, p_params
->data_mode
);
163 wbuf
|= FIELD_PREP(SDW_DPN_PORTCTRL_FLOWMODE
, p_params
->flow_mode
);
165 ret
= sdw_update(s_rt
->slave
, addr1
, 0xF, wbuf
);
167 dev_err(&s_rt
->slave
->dev
,
168 "DPN_PortCtrl register write failed for port %d\n",
173 if (!dpn_prop
->read_only_wordlength
) {
174 /* Program DPN_BlockCtrl1 register */
175 ret
= sdw_write(s_rt
->slave
, addr2
, (p_params
->bps
- 1));
177 dev_err(&s_rt
->slave
->dev
,
178 "DPN_BlockCtrl1 register write failed for port %d\n",
184 /* Program DPN_SampleCtrl1 register */
185 wbuf
= (t_params
->sample_interval
- 1) & SDW_DPN_SAMPLECTRL_LOW
;
186 ret
= sdw_write(s_rt
->slave
, addr3
, wbuf
);
188 dev_err(&s_rt
->slave
->dev
,
189 "DPN_SampleCtrl1 register write failed for port %d\n",
194 /* Program DPN_OffsetCtrl1 registers */
195 ret
= sdw_write(s_rt
->slave
, addr4
, t_params
->offset1
);
197 dev_err(&s_rt
->slave
->dev
,
198 "DPN_OffsetCtrl1 register write failed for port %d\n",
203 /* Program DPN_BlockCtrl2 register*/
204 if (t_params
->blk_grp_ctrl_valid
) {
205 ret
= sdw_write(s_rt
->slave
, addr5
, t_params
->blk_grp_ctrl
);
207 dev_err(&s_rt
->slave
->dev
,
208 "DPN_BlockCtrl2 reg write failed for port %d\n",
214 /* program DPN_LaneCtrl register */
215 if (slave_prop
->lane_control_support
) {
216 ret
= sdw_write(s_rt
->slave
, addr6
, t_params
->lane_ctrl
);
218 dev_err(&s_rt
->slave
->dev
,
219 "DPN_LaneCtrl register write failed for port %d\n",
225 if (dpn_prop
->type
!= SDW_DPN_SIMPLE
) {
226 ret
= _sdw_program_slave_port_params(bus
, s_rt
->slave
,
227 t_params
, dpn_prop
->type
);
229 dev_err(&s_rt
->slave
->dev
,
230 "Transport reg write failed for port: %d\n",
237 static int sdw_program_master_port_params(struct sdw_bus
*bus
,
238 struct sdw_port_runtime
*p_rt
)
243 * we need to set transport and port parameters for the port.
244 * Transport parameters refers to the sample interval, offsets and
245 * hstart/stop etc of the data. Port parameters refers to word
246 * length, flow mode etc of the port
248 ret
= bus
->port_ops
->dpn_set_port_transport_params(bus
,
249 &p_rt
->transport_params
,
250 bus
->params
.next_bank
);
254 return bus
->port_ops
->dpn_set_port_params(bus
,
256 bus
->params
.next_bank
);
260 * sdw_program_port_params() - Programs transport parameters of Master(s)
263 * @m_rt: Master stream runtime
265 static int sdw_program_port_params(struct sdw_master_runtime
*m_rt
)
267 struct sdw_slave_runtime
*s_rt
;
268 struct sdw_bus
*bus
= m_rt
->bus
;
269 struct sdw_port_runtime
*p_rt
;
272 /* Program transport & port parameters for Slave(s) */
273 list_for_each_entry(s_rt
, &m_rt
->slave_rt_list
, m_rt_node
) {
274 list_for_each_entry(p_rt
, &s_rt
->port_list
, port_node
) {
275 ret
= sdw_program_slave_port_params(bus
, s_rt
, p_rt
);
281 /* Program transport & port parameters for Master(s) */
282 list_for_each_entry(p_rt
, &m_rt
->port_list
, port_node
) {
283 ret
= sdw_program_master_port_params(bus
, p_rt
);
292 * sdw_enable_disable_slave_ports: Enable/disable slave data port
295 * @s_rt: slave runtime
296 * @p_rt: port runtime
297 * @en: enable or disable operation
299 * This function only sets the enable/disable bits in the relevant bank, the
300 * actual enable/disable is done with a bank switch
302 static int sdw_enable_disable_slave_ports(struct sdw_bus
*bus
,
303 struct sdw_slave_runtime
*s_rt
,
304 struct sdw_port_runtime
*p_rt
,
307 struct sdw_transport_params
*t_params
= &p_rt
->transport_params
;
311 if (bus
->params
.next_bank
)
312 addr
= SDW_DPN_CHANNELEN_B1(p_rt
->num
);
314 addr
= SDW_DPN_CHANNELEN_B0(p_rt
->num
);
317 * Since bus doesn't support sharing a port across two streams,
318 * it is safe to reset this register
321 ret
= sdw_write(s_rt
->slave
, addr
, p_rt
->ch_mask
);
323 ret
= sdw_write(s_rt
->slave
, addr
, 0x0);
326 dev_err(&s_rt
->slave
->dev
,
327 "Slave chn_en reg write failed:%d port:%d\n",
328 ret
, t_params
->port_num
);
333 static int sdw_enable_disable_master_ports(struct sdw_master_runtime
*m_rt
,
334 struct sdw_port_runtime
*p_rt
,
337 struct sdw_transport_params
*t_params
= &p_rt
->transport_params
;
338 struct sdw_bus
*bus
= m_rt
->bus
;
339 struct sdw_enable_ch enable_ch
;
342 enable_ch
.port_num
= p_rt
->num
;
343 enable_ch
.ch_mask
= p_rt
->ch_mask
;
344 enable_ch
.enable
= en
;
346 /* Perform Master port channel(s) enable/disable */
347 if (bus
->port_ops
->dpn_port_enable_ch
) {
348 ret
= bus
->port_ops
->dpn_port_enable_ch(bus
,
350 bus
->params
.next_bank
);
353 "Master chn_en write failed:%d port:%d\n",
354 ret
, t_params
->port_num
);
359 "dpn_port_enable_ch not supported, %s failed\n",
360 en
? "enable" : "disable");
368 * sdw_enable_disable_ports() - Enable/disable port(s) for Master and
371 * @m_rt: Master stream runtime
372 * @en: mode (enable/disable)
374 static int sdw_enable_disable_ports(struct sdw_master_runtime
*m_rt
, bool en
)
376 struct sdw_port_runtime
*s_port
, *m_port
;
377 struct sdw_slave_runtime
*s_rt
;
380 /* Enable/Disable Slave port(s) */
381 list_for_each_entry(s_rt
, &m_rt
->slave_rt_list
, m_rt_node
) {
382 list_for_each_entry(s_port
, &s_rt
->port_list
, port_node
) {
383 ret
= sdw_enable_disable_slave_ports(m_rt
->bus
, s_rt
,
390 /* Enable/Disable Master port(s) */
391 list_for_each_entry(m_port
, &m_rt
->port_list
, port_node
) {
392 ret
= sdw_enable_disable_master_ports(m_rt
, m_port
, en
);
400 static int sdw_do_port_prep(struct sdw_slave_runtime
*s_rt
,
401 struct sdw_prepare_ch prep_ch
,
402 enum sdw_port_prep_ops cmd
)
404 const struct sdw_slave_ops
*ops
= s_rt
->slave
->ops
;
407 if (ops
->port_prep
) {
408 ret
= ops
->port_prep(s_rt
->slave
, &prep_ch
, cmd
);
410 dev_err(&s_rt
->slave
->dev
,
411 "Slave Port Prep cmd %d failed: %d\n",
420 static int sdw_prep_deprep_slave_ports(struct sdw_bus
*bus
,
421 struct sdw_slave_runtime
*s_rt
,
422 struct sdw_port_runtime
*p_rt
,
425 struct completion
*port_ready
;
426 struct sdw_dpn_prop
*dpn_prop
;
427 struct sdw_prepare_ch prep_ch
;
432 prep_ch
.num
= p_rt
->num
;
433 prep_ch
.ch_mask
= p_rt
->ch_mask
;
435 dpn_prop
= sdw_get_slave_dpn_prop(s_rt
->slave
,
440 "Slave Port:%d properties not found\n", prep_ch
.num
);
444 prep_ch
.prepare
= prep
;
446 prep_ch
.bank
= bus
->params
.next_bank
;
448 if (dpn_prop
->imp_def_interrupts
|| !dpn_prop
->simple_ch_prep_sm
||
449 bus
->params
.s_data_mode
!= SDW_PORT_DATA_MODE_NORMAL
)
453 * Enable interrupt before Port prepare.
454 * For Port de-prepare, it is assumed that port
455 * was prepared earlier
458 ret
= sdw_configure_dpn_intr(s_rt
->slave
, p_rt
->num
, prep
,
459 dpn_prop
->imp_def_interrupts
);
464 /* Inform slave about the impending port prepare */
465 sdw_do_port_prep(s_rt
, prep_ch
, SDW_OPS_PORT_PRE_PREP
);
467 /* Prepare Slave port implementing CP_SM */
468 if (!dpn_prop
->simple_ch_prep_sm
) {
469 addr
= SDW_DPN_PREPARECTRL(p_rt
->num
);
472 ret
= sdw_write(s_rt
->slave
, addr
, p_rt
->ch_mask
);
474 ret
= sdw_write(s_rt
->slave
, addr
, 0x0);
477 dev_err(&s_rt
->slave
->dev
,
478 "Slave prep_ctrl reg write failed\n");
482 /* Wait for completion on port ready */
483 port_ready
= &s_rt
->slave
->port_ready
[prep_ch
.num
];
484 wait_for_completion_timeout(port_ready
,
485 msecs_to_jiffies(dpn_prop
->ch_prep_timeout
));
487 val
= sdw_read(s_rt
->slave
, SDW_DPN_PREPARESTATUS(p_rt
->num
));
488 if ((val
< 0) || (val
& p_rt
->ch_mask
)) {
489 ret
= (val
< 0) ? val
: -ETIMEDOUT
;
490 dev_err(&s_rt
->slave
->dev
,
491 "Chn prep failed for port %d: %d\n", prep_ch
.num
, ret
);
496 /* Inform slaves about ports prepared */
497 sdw_do_port_prep(s_rt
, prep_ch
, SDW_OPS_PORT_POST_PREP
);
499 /* Disable interrupt after Port de-prepare */
501 ret
= sdw_configure_dpn_intr(s_rt
->slave
, p_rt
->num
, prep
,
502 dpn_prop
->imp_def_interrupts
);
507 static int sdw_prep_deprep_master_ports(struct sdw_master_runtime
*m_rt
,
508 struct sdw_port_runtime
*p_rt
,
511 struct sdw_transport_params
*t_params
= &p_rt
->transport_params
;
512 struct sdw_bus
*bus
= m_rt
->bus
;
513 const struct sdw_master_port_ops
*ops
= bus
->port_ops
;
514 struct sdw_prepare_ch prep_ch
;
517 prep_ch
.num
= p_rt
->num
;
518 prep_ch
.ch_mask
= p_rt
->ch_mask
;
519 prep_ch
.prepare
= prep
; /* Prepare/De-prepare */
520 prep_ch
.bank
= bus
->params
.next_bank
;
522 /* Pre-prepare/Pre-deprepare port(s) */
523 if (ops
->dpn_port_prep
) {
524 ret
= ops
->dpn_port_prep(bus
, &prep_ch
);
526 dev_err(bus
->dev
, "Port prepare failed for port:%d\n",
536 * sdw_prep_deprep_ports() - Prepare/De-prepare port(s) for Master(s) and
539 * @m_rt: Master runtime handle
540 * @prep: Prepare or De-prepare
542 static int sdw_prep_deprep_ports(struct sdw_master_runtime
*m_rt
, bool prep
)
544 struct sdw_slave_runtime
*s_rt
;
545 struct sdw_port_runtime
*p_rt
;
548 /* Prepare/De-prepare Slave port(s) */
549 list_for_each_entry(s_rt
, &m_rt
->slave_rt_list
, m_rt_node
) {
550 list_for_each_entry(p_rt
, &s_rt
->port_list
, port_node
) {
551 ret
= sdw_prep_deprep_slave_ports(m_rt
->bus
, s_rt
,
558 /* Prepare/De-prepare Master port(s) */
559 list_for_each_entry(p_rt
, &m_rt
->port_list
, port_node
) {
560 ret
= sdw_prep_deprep_master_ports(m_rt
, p_rt
, prep
);
569 * sdw_notify_config() - Notify bus configuration
571 * @m_rt: Master runtime handle
573 * This function notifies the Master(s) and Slave(s) of the
574 * new bus configuration.
576 static int sdw_notify_config(struct sdw_master_runtime
*m_rt
)
578 struct sdw_slave_runtime
*s_rt
;
579 struct sdw_bus
*bus
= m_rt
->bus
;
580 struct sdw_slave
*slave
;
583 if (bus
->ops
->set_bus_conf
) {
584 ret
= bus
->ops
->set_bus_conf(bus
, &bus
->params
);
589 list_for_each_entry(s_rt
, &m_rt
->slave_rt_list
, m_rt_node
) {
592 if (slave
->ops
->bus_config
) {
593 ret
= slave
->ops
->bus_config(slave
, &bus
->params
);
595 dev_err(bus
->dev
, "Notify Slave: %d failed\n",
606 * sdw_program_params() - Program transport and port parameters for Master(s)
609 * @bus: SDW bus instance
610 * @prepare: true if sdw_program_params() is called by _prepare.
612 static int sdw_program_params(struct sdw_bus
*bus
, bool prepare
)
614 struct sdw_master_runtime
*m_rt
;
617 list_for_each_entry(m_rt
, &bus
->m_rt_list
, bus_node
) {
620 * this loop walks through all master runtimes for a
621 * bus, but the ports can only be configured while
622 * explicitly preparing a stream or handling an
623 * already-prepared stream otherwise.
626 m_rt
->stream
->state
== SDW_STREAM_CONFIGURED
)
629 ret
= sdw_program_port_params(m_rt
);
632 "Program transport params failed: %d\n", ret
);
636 ret
= sdw_notify_config(m_rt
);
639 "Notify bus config failed: %d\n", ret
);
643 /* Enable port(s) on alternate bank for all active streams */
644 if (m_rt
->stream
->state
!= SDW_STREAM_ENABLED
)
647 ret
= sdw_enable_disable_ports(m_rt
, true);
649 dev_err(bus
->dev
, "Enable channel failed: %d\n", ret
);
657 static int sdw_bank_switch(struct sdw_bus
*bus
, int m_rt_count
)
659 int col_index
, row_index
;
661 struct sdw_msg
*wr_msg
;
666 wr_msg
= kzalloc(sizeof(*wr_msg
), GFP_KERNEL
);
670 bus
->defer_msg
.msg
= wr_msg
;
672 wbuf
= kzalloc(sizeof(*wbuf
), GFP_KERNEL
);
678 /* Get row and column index to program register */
679 col_index
= sdw_find_col_index(bus
->params
.col
);
680 row_index
= sdw_find_row_index(bus
->params
.row
);
681 wbuf
[0] = col_index
| (row_index
<< 3);
683 if (bus
->params
.next_bank
)
684 addr
= SDW_SCP_FRAMECTRL_B1
;
686 addr
= SDW_SCP_FRAMECTRL_B0
;
688 sdw_fill_msg(wr_msg
, NULL
, addr
, 1, SDW_BROADCAST_DEV_NUM
,
689 SDW_MSG_FLAG_WRITE
, wbuf
);
690 wr_msg
->ssp_sync
= true;
693 * Set the multi_link flag only when both the hardware supports
694 * and hardware-based sync is required
696 multi_link
= bus
->multi_link
&& (m_rt_count
>= bus
->hw_sync_min_links
);
699 ret
= sdw_transfer_defer(bus
, wr_msg
, &bus
->defer_msg
);
701 ret
= sdw_transfer(bus
, wr_msg
);
703 if (ret
< 0 && ret
!= -ENODATA
) {
704 dev_err(bus
->dev
, "Slave frame_ctrl reg write failed\n");
711 bus
->defer_msg
.msg
= NULL
;
712 bus
->params
.curr_bank
= !bus
->params
.curr_bank
;
713 bus
->params
.next_bank
= !bus
->params
.next_bank
;
722 bus
->defer_msg
.msg
= NULL
;
727 * sdw_ml_sync_bank_switch: Multilink register bank switch
729 * @bus: SDW bus instance
731 * Caller function should free the buffers on error
733 static int sdw_ml_sync_bank_switch(struct sdw_bus
*bus
)
735 unsigned long time_left
;
737 if (!bus
->multi_link
)
740 /* Wait for completion of transfer */
741 time_left
= wait_for_completion_timeout(&bus
->defer_msg
.complete
,
742 bus
->bank_switch_timeout
);
745 dev_err(bus
->dev
, "Controller Timed out on bank switch\n");
749 bus
->params
.curr_bank
= !bus
->params
.curr_bank
;
750 bus
->params
.next_bank
= !bus
->params
.next_bank
;
752 if (bus
->defer_msg
.msg
) {
753 kfree(bus
->defer_msg
.msg
->buf
);
754 kfree(bus
->defer_msg
.msg
);
760 static int do_bank_switch(struct sdw_stream_runtime
*stream
)
762 struct sdw_master_runtime
*m_rt
;
763 const struct sdw_master_ops
*ops
;
765 bool multi_link
= false;
769 m_rt_count
= stream
->m_rt_count
;
771 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
775 if (bus
->multi_link
&& m_rt_count
>= bus
->hw_sync_min_links
) {
777 mutex_lock(&bus
->msg_lock
);
780 /* Pre-bank switch */
781 if (ops
->pre_bank_switch
) {
782 ret
= ops
->pre_bank_switch(bus
);
785 "Pre bank switch op failed: %d\n", ret
);
791 * Perform Bank switch operation.
792 * For multi link cases, the actual bank switch is
793 * synchronized across all Masters and happens later as a
794 * part of post_bank_switch ops.
796 ret
= sdw_bank_switch(bus
, m_rt_count
);
798 dev_err(bus
->dev
, "Bank switch failed: %d\n", ret
);
804 * For multi link cases, it is expected that the bank switch is
805 * triggered by the post_bank_switch for the first Master in the list
806 * and for the other Masters the post_bank_switch() should return doing
809 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
813 /* Post-bank switch */
814 if (ops
->post_bank_switch
) {
815 ret
= ops
->post_bank_switch(bus
);
818 "Post bank switch op failed: %d\n",
822 } else if (multi_link
) {
824 "Post bank switch ops not implemented\n");
828 /* Set the bank switch timeout to default, if not set */
829 if (!bus
->bank_switch_timeout
)
830 bus
->bank_switch_timeout
= DEFAULT_BANK_SWITCH_TIMEOUT
;
832 /* Check if bank switch was successful */
833 ret
= sdw_ml_sync_bank_switch(bus
);
836 "multi link bank switch failed: %d\n", ret
);
841 mutex_unlock(&bus
->msg_lock
);
847 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
849 if (bus
->defer_msg
.msg
) {
850 kfree(bus
->defer_msg
.msg
->buf
);
851 kfree(bus
->defer_msg
.msg
);
858 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
860 if (mutex_is_locked(&bus
->msg_lock
))
861 mutex_unlock(&bus
->msg_lock
);
869 * sdw_release_stream() - Free the assigned stream runtime
871 * @stream: SoundWire stream runtime
873 * sdw_release_stream should be called only once per stream
875 void sdw_release_stream(struct sdw_stream_runtime
*stream
)
879 EXPORT_SYMBOL(sdw_release_stream
);
882 * sdw_alloc_stream() - Allocate and return stream runtime
884 * @stream_name: SoundWire stream name
886 * Allocates a SoundWire stream runtime instance.
887 * sdw_alloc_stream should be called only once per stream. Typically
888 * invoked from ALSA/ASoC machine/platform driver.
890 struct sdw_stream_runtime
*sdw_alloc_stream(const char *stream_name
)
892 struct sdw_stream_runtime
*stream
;
894 stream
= kzalloc(sizeof(*stream
), GFP_KERNEL
);
898 stream
->name
= stream_name
;
899 INIT_LIST_HEAD(&stream
->master_list
);
900 stream
->state
= SDW_STREAM_ALLOCATED
;
901 stream
->m_rt_count
= 0;
905 EXPORT_SYMBOL(sdw_alloc_stream
);
907 static struct sdw_master_runtime
908 *sdw_find_master_rt(struct sdw_bus
*bus
,
909 struct sdw_stream_runtime
*stream
)
911 struct sdw_master_runtime
*m_rt
;
913 /* Retrieve Bus handle if already available */
914 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
915 if (m_rt
->bus
== bus
)
923 * sdw_alloc_master_rt() - Allocates and initialize Master runtime handle
925 * @bus: SDW bus instance
926 * @stream_config: Stream configuration
927 * @stream: Stream runtime handle.
929 * This function is to be called with bus_lock held.
931 static struct sdw_master_runtime
932 *sdw_alloc_master_rt(struct sdw_bus
*bus
,
933 struct sdw_stream_config
*stream_config
,
934 struct sdw_stream_runtime
*stream
)
936 struct sdw_master_runtime
*m_rt
;
939 * check if Master is already allocated (as a result of Slave adding
940 * it first), if so skip allocation and go to configure
942 m_rt
= sdw_find_master_rt(bus
, stream
);
946 m_rt
= kzalloc(sizeof(*m_rt
), GFP_KERNEL
);
950 /* Initialization of Master runtime handle */
951 INIT_LIST_HEAD(&m_rt
->port_list
);
952 INIT_LIST_HEAD(&m_rt
->slave_rt_list
);
953 list_add_tail(&m_rt
->stream_node
, &stream
->master_list
);
955 list_add_tail(&m_rt
->bus_node
, &bus
->m_rt_list
);
958 m_rt
->ch_count
= stream_config
->ch_count
;
960 m_rt
->stream
= stream
;
961 m_rt
->direction
= stream_config
->direction
;
967 * sdw_alloc_slave_rt() - Allocate and initialize Slave runtime handle.
969 * @slave: Slave handle
970 * @stream_config: Stream configuration
971 * @stream: Stream runtime handle
973 * This function is to be called with bus_lock held.
975 static struct sdw_slave_runtime
976 *sdw_alloc_slave_rt(struct sdw_slave
*slave
,
977 struct sdw_stream_config
*stream_config
,
978 struct sdw_stream_runtime
*stream
)
980 struct sdw_slave_runtime
*s_rt
;
982 s_rt
= kzalloc(sizeof(*s_rt
), GFP_KERNEL
);
986 INIT_LIST_HEAD(&s_rt
->port_list
);
987 s_rt
->ch_count
= stream_config
->ch_count
;
988 s_rt
->direction
= stream_config
->direction
;
994 static void sdw_master_port_release(struct sdw_bus
*bus
,
995 struct sdw_master_runtime
*m_rt
)
997 struct sdw_port_runtime
*p_rt
, *_p_rt
;
999 list_for_each_entry_safe(p_rt
, _p_rt
, &m_rt
->port_list
, port_node
) {
1000 list_del(&p_rt
->port_node
);
1005 static void sdw_slave_port_release(struct sdw_bus
*bus
,
1006 struct sdw_slave
*slave
,
1007 struct sdw_stream_runtime
*stream
)
1009 struct sdw_port_runtime
*p_rt
, *_p_rt
;
1010 struct sdw_master_runtime
*m_rt
;
1011 struct sdw_slave_runtime
*s_rt
;
1013 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1014 list_for_each_entry(s_rt
, &m_rt
->slave_rt_list
, m_rt_node
) {
1015 if (s_rt
->slave
!= slave
)
1018 list_for_each_entry_safe(p_rt
, _p_rt
,
1019 &s_rt
->port_list
, port_node
) {
1020 list_del(&p_rt
->port_node
);
1028 * sdw_release_slave_stream() - Free Slave(s) runtime handle
1030 * @slave: Slave handle.
1031 * @stream: Stream runtime handle.
1033 * This function is to be called with bus_lock held.
1035 static void sdw_release_slave_stream(struct sdw_slave
*slave
,
1036 struct sdw_stream_runtime
*stream
)
1038 struct sdw_slave_runtime
*s_rt
, *_s_rt
;
1039 struct sdw_master_runtime
*m_rt
;
1041 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1042 /* Retrieve Slave runtime handle */
1043 list_for_each_entry_safe(s_rt
, _s_rt
,
1044 &m_rt
->slave_rt_list
, m_rt_node
) {
1045 if (s_rt
->slave
== slave
) {
1046 list_del(&s_rt
->m_rt_node
);
1055 * sdw_release_master_stream() - Free Master runtime handle
1057 * @m_rt: Master runtime node
1058 * @stream: Stream runtime handle.
1060 * This function is to be called with bus_lock held
1061 * It frees the Master runtime handle and associated Slave(s) runtime
1062 * handle. If this is called first then sdw_release_slave_stream() will have
1063 * no effect as Slave(s) runtime handle would already be freed up.
1065 static void sdw_release_master_stream(struct sdw_master_runtime
*m_rt
,
1066 struct sdw_stream_runtime
*stream
)
1068 struct sdw_slave_runtime
*s_rt
, *_s_rt
;
1070 list_for_each_entry_safe(s_rt
, _s_rt
, &m_rt
->slave_rt_list
, m_rt_node
) {
1071 sdw_slave_port_release(s_rt
->slave
->bus
, s_rt
->slave
, stream
);
1072 sdw_release_slave_stream(s_rt
->slave
, stream
);
1075 list_del(&m_rt
->stream_node
);
1076 list_del(&m_rt
->bus_node
);
1081 * sdw_stream_remove_master() - Remove master from sdw_stream
1083 * @bus: SDW Bus instance
1084 * @stream: SoundWire stream
1086 * This removes and frees port_rt and master_rt from a stream
1088 int sdw_stream_remove_master(struct sdw_bus
*bus
,
1089 struct sdw_stream_runtime
*stream
)
1091 struct sdw_master_runtime
*m_rt
, *_m_rt
;
1093 mutex_lock(&bus
->bus_lock
);
1095 list_for_each_entry_safe(m_rt
, _m_rt
,
1096 &stream
->master_list
, stream_node
) {
1097 if (m_rt
->bus
!= bus
)
1100 sdw_master_port_release(bus
, m_rt
);
1101 sdw_release_master_stream(m_rt
, stream
);
1102 stream
->m_rt_count
--;
1105 if (list_empty(&stream
->master_list
))
1106 stream
->state
= SDW_STREAM_RELEASED
;
1108 mutex_unlock(&bus
->bus_lock
);
1112 EXPORT_SYMBOL(sdw_stream_remove_master
);
1115 * sdw_stream_remove_slave() - Remove slave from sdw_stream
1117 * @slave: SDW Slave instance
1118 * @stream: SoundWire stream
1120 * This removes and frees port_rt and slave_rt from a stream
1122 int sdw_stream_remove_slave(struct sdw_slave
*slave
,
1123 struct sdw_stream_runtime
*stream
)
1125 mutex_lock(&slave
->bus
->bus_lock
);
1127 sdw_slave_port_release(slave
->bus
, slave
, stream
);
1128 sdw_release_slave_stream(slave
, stream
);
1130 mutex_unlock(&slave
->bus
->bus_lock
);
1134 EXPORT_SYMBOL(sdw_stream_remove_slave
);
1137 * sdw_config_stream() - Configure the allocated stream
1140 * @stream: SoundWire stream
1141 * @stream_config: Stream configuration for audio stream
1142 * @is_slave: is API called from Slave or Master
1144 * This function is to be called with bus_lock held.
1146 static int sdw_config_stream(struct device
*dev
,
1147 struct sdw_stream_runtime
*stream
,
1148 struct sdw_stream_config
*stream_config
,
1152 * Update the stream rate, channel and bps based on data
1153 * source. For more than one data source (multilink),
1154 * match the rate, bps, stream type and increment number of channels.
1156 * If rate/bps is zero, it means the values are not set, so skip
1157 * comparison and allow the value to be set and stored in stream
1159 if (stream
->params
.rate
&&
1160 stream
->params
.rate
!= stream_config
->frame_rate
) {
1161 dev_err(dev
, "rate not matching, stream:%s\n", stream
->name
);
1165 if (stream
->params
.bps
&&
1166 stream
->params
.bps
!= stream_config
->bps
) {
1167 dev_err(dev
, "bps not matching, stream:%s\n", stream
->name
);
1171 stream
->type
= stream_config
->type
;
1172 stream
->params
.rate
= stream_config
->frame_rate
;
1173 stream
->params
.bps
= stream_config
->bps
;
1175 /* TODO: Update this check during Device-device support */
1177 stream
->params
.ch_count
+= stream_config
->ch_count
;
1182 static int sdw_is_valid_port_range(struct device
*dev
,
1183 struct sdw_port_runtime
*p_rt
)
1185 if (!SDW_VALID_PORT_RANGE(p_rt
->num
)) {
1187 "SoundWire: Invalid port number :%d\n", p_rt
->num
);
1194 static struct sdw_port_runtime
1195 *sdw_port_alloc(struct device
*dev
,
1196 struct sdw_port_config
*port_config
,
1199 struct sdw_port_runtime
*p_rt
;
1201 p_rt
= kzalloc(sizeof(*p_rt
), GFP_KERNEL
);
1205 p_rt
->ch_mask
= port_config
[port_index
].ch_mask
;
1206 p_rt
->num
= port_config
[port_index
].num
;
1211 static int sdw_master_port_config(struct sdw_bus
*bus
,
1212 struct sdw_master_runtime
*m_rt
,
1213 struct sdw_port_config
*port_config
,
1214 unsigned int num_ports
)
1216 struct sdw_port_runtime
*p_rt
;
1219 /* Iterate for number of ports to perform initialization */
1220 for (i
= 0; i
< num_ports
; i
++) {
1221 p_rt
= sdw_port_alloc(bus
->dev
, port_config
, i
);
1226 * TODO: Check port capabilities for requested
1227 * configuration (audio mode support)
1230 list_add_tail(&p_rt
->port_node
, &m_rt
->port_list
);
1236 static int sdw_slave_port_config(struct sdw_slave
*slave
,
1237 struct sdw_slave_runtime
*s_rt
,
1238 struct sdw_port_config
*port_config
,
1239 unsigned int num_config
)
1241 struct sdw_port_runtime
*p_rt
;
1244 /* Iterate for number of ports to perform initialization */
1245 for (i
= 0; i
< num_config
; i
++) {
1246 p_rt
= sdw_port_alloc(&slave
->dev
, port_config
, i
);
1251 * TODO: Check valid port range as defined by DisCo/
1254 ret
= sdw_is_valid_port_range(&slave
->dev
, p_rt
);
1261 * TODO: Check port capabilities for requested
1262 * configuration (audio mode support)
1265 list_add_tail(&p_rt
->port_node
, &s_rt
->port_list
);
1272 * sdw_stream_add_master() - Allocate and add master runtime to a stream
1274 * @bus: SDW Bus instance
1275 * @stream_config: Stream configuration for audio stream
1276 * @port_config: Port configuration for audio stream
1277 * @num_ports: Number of ports
1278 * @stream: SoundWire stream
1280 int sdw_stream_add_master(struct sdw_bus
*bus
,
1281 struct sdw_stream_config
*stream_config
,
1282 struct sdw_port_config
*port_config
,
1283 unsigned int num_ports
,
1284 struct sdw_stream_runtime
*stream
)
1286 struct sdw_master_runtime
*m_rt
;
1289 mutex_lock(&bus
->bus_lock
);
1292 * For multi link streams, add the second master only if
1293 * the bus supports it.
1294 * Check if bus->multi_link is set
1296 if (!bus
->multi_link
&& stream
->m_rt_count
> 0) {
1298 "Multilink not supported, link %d\n", bus
->link_id
);
1303 m_rt
= sdw_alloc_master_rt(bus
, stream_config
, stream
);
1306 "Master runtime config failed for stream:%s\n",
1312 ret
= sdw_config_stream(bus
->dev
, stream
, stream_config
, false);
1316 ret
= sdw_master_port_config(bus
, m_rt
, port_config
, num_ports
);
1320 stream
->m_rt_count
++;
1325 sdw_release_master_stream(m_rt
, stream
);
1327 mutex_unlock(&bus
->bus_lock
);
1330 EXPORT_SYMBOL(sdw_stream_add_master
);
1333 * sdw_stream_add_slave() - Allocate and add master/slave runtime to a stream
1335 * @slave: SDW Slave instance
1336 * @stream_config: Stream configuration for audio stream
1337 * @stream: SoundWire stream
1338 * @port_config: Port configuration for audio stream
1339 * @num_ports: Number of ports
1341 * It is expected that Slave is added before adding Master
1345 int sdw_stream_add_slave(struct sdw_slave
*slave
,
1346 struct sdw_stream_config
*stream_config
,
1347 struct sdw_port_config
*port_config
,
1348 unsigned int num_ports
,
1349 struct sdw_stream_runtime
*stream
)
1351 struct sdw_slave_runtime
*s_rt
;
1352 struct sdw_master_runtime
*m_rt
;
1355 mutex_lock(&slave
->bus
->bus_lock
);
1358 * If this API is invoked by Slave first then m_rt is not valid.
1359 * So, allocate m_rt and add Slave to it.
1361 m_rt
= sdw_alloc_master_rt(slave
->bus
, stream_config
, stream
);
1363 dev_err(&slave
->dev
,
1364 "alloc master runtime failed for stream:%s\n",
1370 s_rt
= sdw_alloc_slave_rt(slave
, stream_config
, stream
);
1372 dev_err(&slave
->dev
,
1373 "Slave runtime config failed for stream:%s\n",
1379 ret
= sdw_config_stream(&slave
->dev
, stream
, stream_config
, true);
1382 * sdw_release_master_stream will release s_rt in slave_rt_list in
1383 * stream_error case, but s_rt is only added to slave_rt_list
1384 * when sdw_config_stream is successful, so free s_rt explicitly
1385 * when sdw_config_stream is failed.
1391 list_add_tail(&s_rt
->m_rt_node
, &m_rt
->slave_rt_list
);
1393 ret
= sdw_slave_port_config(slave
, s_rt
, port_config
, num_ports
);
1398 * Change stream state to CONFIGURED on first Slave add.
1399 * Bus is not aware of number of Slave(s) in a stream at this
1400 * point so cannot depend on all Slave(s) to be added in order to
1401 * change stream state to CONFIGURED.
1403 stream
->state
= SDW_STREAM_CONFIGURED
;
1408 * we hit error so cleanup the stream, release all Slave(s) and
1411 sdw_release_master_stream(m_rt
, stream
);
1413 mutex_unlock(&slave
->bus
->bus_lock
);
1416 EXPORT_SYMBOL(sdw_stream_add_slave
);
1419 * sdw_get_slave_dpn_prop() - Get Slave port capabilities
1421 * @slave: Slave handle
1422 * @direction: Data direction.
1423 * @port_num: Port number
1425 struct sdw_dpn_prop
*sdw_get_slave_dpn_prop(struct sdw_slave
*slave
,
1426 enum sdw_data_direction direction
,
1427 unsigned int port_num
)
1429 struct sdw_dpn_prop
*dpn_prop
;
1433 if (direction
== SDW_DATA_DIR_TX
) {
1434 num_ports
= hweight32(slave
->prop
.source_ports
);
1435 dpn_prop
= slave
->prop
.src_dpn_prop
;
1437 num_ports
= hweight32(slave
->prop
.sink_ports
);
1438 dpn_prop
= slave
->prop
.sink_dpn_prop
;
1441 for (i
= 0; i
< num_ports
; i
++) {
1442 if (dpn_prop
[i
].num
== port_num
)
1443 return &dpn_prop
[i
];
1450 * sdw_acquire_bus_lock: Acquire bus lock for all Master runtime(s)
1452 * @stream: SoundWire stream
1454 * Acquire bus_lock for each of the master runtime(m_rt) part of this
1455 * stream to reconfigure the bus.
1456 * NOTE: This function is called from SoundWire stream ops and is
1457 * expected that a global lock is held before acquiring bus_lock.
1459 static void sdw_acquire_bus_lock(struct sdw_stream_runtime
*stream
)
1461 struct sdw_master_runtime
*m_rt
;
1462 struct sdw_bus
*bus
;
1464 /* Iterate for all Master(s) in Master list */
1465 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1468 mutex_lock(&bus
->bus_lock
);
1473 * sdw_release_bus_lock: Release bus lock for all Master runtime(s)
1475 * @stream: SoundWire stream
1477 * Release the previously held bus_lock after reconfiguring the bus.
1478 * NOTE: This function is called from SoundWire stream ops and is
1479 * expected that a global lock is held before releasing bus_lock.
1481 static void sdw_release_bus_lock(struct sdw_stream_runtime
*stream
)
1483 struct sdw_master_runtime
*m_rt
;
1484 struct sdw_bus
*bus
;
1486 /* Iterate for all Master(s) in Master list */
1487 list_for_each_entry_reverse(m_rt
, &stream
->master_list
, stream_node
) {
1489 mutex_unlock(&bus
->bus_lock
);
1493 static int _sdw_prepare_stream(struct sdw_stream_runtime
*stream
,
1496 struct sdw_master_runtime
*m_rt
;
1497 struct sdw_bus
*bus
= NULL
;
1498 struct sdw_master_prop
*prop
;
1499 struct sdw_bus_params params
;
1502 /* Prepare Master(s) and Slave(s) port(s) associated with stream */
1503 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1506 memcpy(¶ms
, &bus
->params
, sizeof(params
));
1508 /* TODO: Support Asynchronous mode */
1509 if ((prop
->max_clk_freq
% stream
->params
.rate
) != 0) {
1510 dev_err(bus
->dev
, "Async mode not supported\n");
1515 goto program_params
;
1517 /* Increment cumulative bus bandwidth */
1518 /* TODO: Update this during Device-Device support */
1519 bus
->params
.bandwidth
+= m_rt
->stream
->params
.rate
*
1520 m_rt
->ch_count
* m_rt
->stream
->params
.bps
;
1522 /* Compute params */
1523 if (bus
->compute_params
) {
1524 ret
= bus
->compute_params(bus
);
1526 dev_err(bus
->dev
, "Compute params failed: %d\n",
1533 /* Program params */
1534 ret
= sdw_program_params(bus
, true);
1536 dev_err(bus
->dev
, "Program params failed: %d\n", ret
);
1537 goto restore_params
;
1542 pr_err("Configuration error in %s\n", __func__
);
1546 ret
= do_bank_switch(stream
);
1548 dev_err(bus
->dev
, "Bank switch failed: %d\n", ret
);
1549 goto restore_params
;
1552 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1555 /* Prepare port(s) on the new clock configuration */
1556 ret
= sdw_prep_deprep_ports(m_rt
, true);
1558 dev_err(bus
->dev
, "Prepare port(s) failed ret = %d\n",
1564 stream
->state
= SDW_STREAM_PREPARED
;
1569 memcpy(&bus
->params
, ¶ms
, sizeof(params
));
1574 * sdw_prepare_stream() - Prepare SoundWire stream
1576 * @stream: Soundwire stream
1578 * Documentation/driver-api/soundwire/stream.rst explains this API in detail
1580 int sdw_prepare_stream(struct sdw_stream_runtime
*stream
)
1582 bool update_params
= true;
1586 pr_err("SoundWire: Handle not found for stream\n");
1590 sdw_acquire_bus_lock(stream
);
1592 if (stream
->state
== SDW_STREAM_PREPARED
) {
1597 if (stream
->state
!= SDW_STREAM_CONFIGURED
&&
1598 stream
->state
!= SDW_STREAM_DEPREPARED
&&
1599 stream
->state
!= SDW_STREAM_DISABLED
) {
1600 pr_err("%s: %s: inconsistent state state %d\n",
1601 __func__
, stream
->name
, stream
->state
);
1607 * when the stream is DISABLED, this means sdw_prepare_stream()
1608 * is called as a result of an underflow or a resume operation.
1609 * In this case, the bus parameters shall not be recomputed, but
1610 * still need to be re-applied
1612 if (stream
->state
== SDW_STREAM_DISABLED
)
1613 update_params
= false;
1615 ret
= _sdw_prepare_stream(stream
, update_params
);
1618 sdw_release_bus_lock(stream
);
1621 EXPORT_SYMBOL(sdw_prepare_stream
);
1623 static int _sdw_enable_stream(struct sdw_stream_runtime
*stream
)
1625 struct sdw_master_runtime
*m_rt
;
1626 struct sdw_bus
*bus
= NULL
;
1629 /* Enable Master(s) and Slave(s) port(s) associated with stream */
1630 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1633 /* Program params */
1634 ret
= sdw_program_params(bus
, false);
1636 dev_err(bus
->dev
, "Program params failed: %d\n", ret
);
1640 /* Enable port(s) */
1641 ret
= sdw_enable_disable_ports(m_rt
, true);
1644 "Enable port(s) failed ret: %d\n", ret
);
1650 pr_err("Configuration error in %s\n", __func__
);
1654 ret
= do_bank_switch(stream
);
1656 dev_err(bus
->dev
, "Bank switch failed: %d\n", ret
);
1660 stream
->state
= SDW_STREAM_ENABLED
;
1665 * sdw_enable_stream() - Enable SoundWire stream
1667 * @stream: Soundwire stream
1669 * Documentation/driver-api/soundwire/stream.rst explains this API in detail
1671 int sdw_enable_stream(struct sdw_stream_runtime
*stream
)
1676 pr_err("SoundWire: Handle not found for stream\n");
1680 sdw_acquire_bus_lock(stream
);
1682 if (stream
->state
!= SDW_STREAM_PREPARED
&&
1683 stream
->state
!= SDW_STREAM_DISABLED
) {
1684 pr_err("%s: %s: inconsistent state state %d\n",
1685 __func__
, stream
->name
, stream
->state
);
1690 ret
= _sdw_enable_stream(stream
);
1693 sdw_release_bus_lock(stream
);
1696 EXPORT_SYMBOL(sdw_enable_stream
);
1698 static int _sdw_disable_stream(struct sdw_stream_runtime
*stream
)
1700 struct sdw_master_runtime
*m_rt
;
1703 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1704 struct sdw_bus
*bus
= m_rt
->bus
;
1706 /* Disable port(s) */
1707 ret
= sdw_enable_disable_ports(m_rt
, false);
1709 dev_err(bus
->dev
, "Disable port(s) failed: %d\n", ret
);
1713 stream
->state
= SDW_STREAM_DISABLED
;
1715 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1716 struct sdw_bus
*bus
= m_rt
->bus
;
1718 /* Program params */
1719 ret
= sdw_program_params(bus
, false);
1721 dev_err(bus
->dev
, "Program params failed: %d\n", ret
);
1726 ret
= do_bank_switch(stream
);
1728 pr_err("Bank switch failed: %d\n", ret
);
1732 /* make sure alternate bank (previous current) is also disabled */
1733 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1734 struct sdw_bus
*bus
= m_rt
->bus
;
1736 /* Disable port(s) */
1737 ret
= sdw_enable_disable_ports(m_rt
, false);
1739 dev_err(bus
->dev
, "Disable port(s) failed: %d\n", ret
);
1748 * sdw_disable_stream() - Disable SoundWire stream
1750 * @stream: Soundwire stream
1752 * Documentation/driver-api/soundwire/stream.rst explains this API in detail
1754 int sdw_disable_stream(struct sdw_stream_runtime
*stream
)
1759 pr_err("SoundWire: Handle not found for stream\n");
1763 sdw_acquire_bus_lock(stream
);
1765 if (stream
->state
!= SDW_STREAM_ENABLED
) {
1766 pr_err("%s: %s: inconsistent state state %d\n",
1767 __func__
, stream
->name
, stream
->state
);
1772 ret
= _sdw_disable_stream(stream
);
1775 sdw_release_bus_lock(stream
);
1778 EXPORT_SYMBOL(sdw_disable_stream
);
1780 static int _sdw_deprepare_stream(struct sdw_stream_runtime
*stream
)
1782 struct sdw_master_runtime
*m_rt
;
1783 struct sdw_bus
*bus
;
1786 list_for_each_entry(m_rt
, &stream
->master_list
, stream_node
) {
1788 /* De-prepare port(s) */
1789 ret
= sdw_prep_deprep_ports(m_rt
, false);
1792 "De-prepare port(s) failed: %d\n", ret
);
1796 /* TODO: Update this during Device-Device support */
1797 bus
->params
.bandwidth
-= m_rt
->stream
->params
.rate
*
1798 m_rt
->ch_count
* m_rt
->stream
->params
.bps
;
1800 /* Compute params */
1801 if (bus
->compute_params
) {
1802 ret
= bus
->compute_params(bus
);
1804 dev_err(bus
->dev
, "Compute params failed: %d\n",
1810 /* Program params */
1811 ret
= sdw_program_params(bus
, false);
1813 dev_err(bus
->dev
, "Program params failed: %d\n", ret
);
1818 stream
->state
= SDW_STREAM_DEPREPARED
;
1819 return do_bank_switch(stream
);
1823 * sdw_deprepare_stream() - Deprepare SoundWire stream
1825 * @stream: Soundwire stream
1827 * Documentation/driver-api/soundwire/stream.rst explains this API in detail
1829 int sdw_deprepare_stream(struct sdw_stream_runtime
*stream
)
1834 pr_err("SoundWire: Handle not found for stream\n");
1838 sdw_acquire_bus_lock(stream
);
1840 if (stream
->state
!= SDW_STREAM_PREPARED
&&
1841 stream
->state
!= SDW_STREAM_DISABLED
) {
1842 pr_err("%s: %s: inconsistent state state %d\n",
1843 __func__
, stream
->name
, stream
->state
);
1848 ret
= _sdw_deprepare_stream(stream
);
1851 sdw_release_bus_lock(stream
);
1854 EXPORT_SYMBOL(sdw_deprepare_stream
);
1856 static int set_stream(struct snd_pcm_substream
*substream
,
1857 struct sdw_stream_runtime
*sdw_stream
)
1859 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1860 struct snd_soc_dai
*dai
;
1864 /* Set stream pointer on all DAIs */
1865 for_each_rtd_dais(rtd
, i
, dai
) {
1866 ret
= snd_soc_dai_set_sdw_stream(dai
, sdw_stream
, substream
->stream
);
1868 dev_err(rtd
->dev
, "failed to set stream pointer on dai %s\n", dai
->name
);
1877 * sdw_startup_stream() - Startup SoundWire stream
1879 * @sdw_substream: Soundwire stream
1881 * Documentation/driver-api/soundwire/stream.rst explains this API in detail
1883 int sdw_startup_stream(void *sdw_substream
)
1885 struct snd_pcm_substream
*substream
= sdw_substream
;
1886 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1887 struct sdw_stream_runtime
*sdw_stream
;
1891 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1892 name
= kasprintf(GFP_KERNEL
, "%s-Playback", substream
->name
);
1894 name
= kasprintf(GFP_KERNEL
, "%s-Capture", substream
->name
);
1899 sdw_stream
= sdw_alloc_stream(name
);
1901 dev_err(rtd
->dev
, "alloc stream failed for substream DAI %s\n", substream
->name
);
1906 ret
= set_stream(substream
, sdw_stream
);
1908 goto release_stream
;
1912 sdw_release_stream(sdw_stream
);
1913 set_stream(substream
, NULL
);
1918 EXPORT_SYMBOL(sdw_startup_stream
);
1921 * sdw_shutdown_stream() - Shutdown SoundWire stream
1923 * @sdw_substream: Soundwire stream
1925 * Documentation/driver-api/soundwire/stream.rst explains this API in detail
1927 void sdw_shutdown_stream(void *sdw_substream
)
1929 struct snd_pcm_substream
*substream
= sdw_substream
;
1930 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
1931 struct sdw_stream_runtime
*sdw_stream
;
1932 struct snd_soc_dai
*dai
;
1934 /* Find stream from first CPU DAI */
1935 dai
= asoc_rtd_to_cpu(rtd
, 0);
1937 sdw_stream
= snd_soc_dai_get_sdw_stream(dai
, substream
->stream
);
1939 if (IS_ERR(sdw_stream
)) {
1940 dev_err(rtd
->dev
, "no stream found for DAI %s\n", dai
->name
);
1944 /* release memory */
1945 kfree(sdw_stream
->name
);
1946 sdw_release_stream(sdw_stream
);
1948 /* clear DAI data */
1949 set_stream(substream
, NULL
);
1951 EXPORT_SYMBOL(sdw_shutdown_stream
);