~hc/RK356X_SDK_RELEASE.git

..	..	@@ -13,6 +13,7 @@
13	13	#include <linux/slab.h>
14	14	#include <linux/soundwire/sdw_registers.h>
15	15	#include <linux/soundwire/sdw.h>
	16	+#include <sound/soc.h>
16	17	#include "bus.h"
17	18
18	19	/*
..	..	@@ -21,41 +22,46 @@
21	22	* The rows are arranged as per the array index value programmed
22	23	* in register. The index 15 has dummy value 0 in order to fill hole.
23	24	*/
24		-int rows[SDW_FRAME_ROWS] = {48, 50, 60, 64, 75, 80, 125, 147,
	25	+int sdw_rows[SDW_FRAME_ROWS] = {48, 50, 60, 64, 75, 80, 125, 147,
25	26	96, 100, 120, 128, 150, 160, 250, 0,
26	27	192, 200, 240, 256, 72, 144, 90, 180};
	28	+EXPORT_SYMBOL(sdw_rows);
27	29
28		-int cols[SDW_FRAME_COLS] = {2, 4, 6, 8, 10, 12, 14, 16};
	30	+int sdw_cols[SDW_FRAME_COLS] = {2, 4, 6, 8, 10, 12, 14, 16};
	31	+EXPORT_SYMBOL(sdw_cols);
29	32
30		-static int sdw_find_col_index(int col)
	33	+int sdw_find_col_index(int col)
31	34	{
32	35	int i;
33	36
34	37	for (i = 0; i < SDW_FRAME_COLS; i++) {
35		- if (cols[i] == col)
	38	+ if (sdw_cols[i] == col)
36	39	return i;
37	40	}
38	41
39	42	pr_warn("Requested column not found, selecting lowest column no: 2\n");
40	43	return 0;
41	44	}
	45	+EXPORT_SYMBOL(sdw_find_col_index);
42	46
43		-static int sdw_find_row_index(int row)
	47	+int sdw_find_row_index(int row)
44	48	{
45	49	int i;
46	50
47	51	for (i = 0; i < SDW_FRAME_ROWS; i++) {
48		- if (rows[i] == row)
	52	+ if (sdw_rows[i] == row)
49	53	return i;
50	54	}
51	55
52	56	pr_warn("Requested row not found, selecting lowest row no: 48\n");
53	57	return 0;
54	58	}
	59	+EXPORT_SYMBOL(sdw_find_row_index);
	60	+
55	61	static int _sdw_program_slave_port_params(struct sdw_bus *bus,
56		- struct sdw_slave *slave,
57		- struct sdw_transport_params *t_params,
58		- enum sdw_dpn_type type)
	62	+ struct sdw_slave *slave,
	63	+ struct sdw_transport_params *t_params,
	64	+ enum sdw_dpn_type type)
59	65	{
60	66	u32 addr1, addr2, addr3, addr4;
61	67	int ret;
..	..	@@ -76,51 +82,48 @@
76	82	/* Program DPN_OffsetCtrl2 registers */
77	83	ret = sdw_write(slave, addr1, t_params->offset2);
78	84	if (ret < 0) {
79		- dev_err(bus->dev, "DPN_OffsetCtrl2 register write failed");
	85	+ dev_err(bus->dev, "DPN_OffsetCtrl2 register write failed\n");
80	86	return ret;
81	87	}
82	88
83	89	/* Program DPN_BlockCtrl3 register */
84	90	ret = sdw_write(slave, addr2, t_params->blk_pkg_mode);
85	91	if (ret < 0) {
86		- dev_err(bus->dev, "DPN_BlockCtrl3 register write failed");
	92	+ dev_err(bus->dev, "DPN_BlockCtrl3 register write failed\n");
87	93	return ret;
88	94	}
89	95
90	96	/*
91	97	* Data ports are FULL, SIMPLE and REDUCED. This function handles
92		- * FULL and REDUCED only and and beyond this point only FULL is
	98	+ * FULL and REDUCED only and beyond this point only FULL is
93	99	* handled, so bail out if we are not FULL data port type
94	100	*/
95	101	if (type != SDW_DPN_FULL)
96	102	return ret;
97	103
98	104	/* Program DPN_SampleCtrl2 register */
99		- wbuf = (t_params->sample_interval - 1);
100		- wbuf &= SDW_DPN_SAMPLECTRL_HIGH;
101		- wbuf >>= SDW_REG_SHIFT(SDW_DPN_SAMPLECTRL_HIGH);
	105	+ wbuf = FIELD_GET(SDW_DPN_SAMPLECTRL_HIGH, t_params->sample_interval - 1);
102	106
103	107	ret = sdw_write(slave, addr3, wbuf);
104	108	if (ret < 0) {
105		- dev_err(bus->dev, "DPN_SampleCtrl2 register write failed");
	109	+ dev_err(bus->dev, "DPN_SampleCtrl2 register write failed\n");
106	110	return ret;
107	111	}
108	112
109	113	/* Program DPN_HCtrl register */
110		- wbuf = t_params->hstart;
111		- wbuf <<= SDW_REG_SHIFT(SDW_DPN_HCTRL_HSTART);
112		- wbuf \|= t_params->hstop;
	114	+ wbuf = FIELD_PREP(SDW_DPN_HCTRL_HSTART, t_params->hstart);
	115	+ wbuf \|= FIELD_PREP(SDW_DPN_HCTRL_HSTOP, t_params->hstop);
113	116
114	117	ret = sdw_write(slave, addr4, wbuf);
115	118	if (ret < 0)
116		- dev_err(bus->dev, "DPN_HCtrl register write failed");
	119	+ dev_err(bus->dev, "DPN_HCtrl register write failed\n");
117	120
118	121	return ret;
119	122	}
120	123
121	124	static int sdw_program_slave_port_params(struct sdw_bus *bus,
122		- struct sdw_slave_runtime *s_rt,
123		- struct sdw_port_runtime *p_rt)
	125	+ struct sdw_slave_runtime *s_rt,
	126	+ struct sdw_port_runtime *p_rt)
124	127	{
125	128	struct sdw_transport_params *t_params = &p_rt->transport_params;
126	129	struct sdw_port_params *p_params = &p_rt->port_params;
..	..	@@ -131,8 +134,8 @@
131	134	u8 wbuf;
132	135
133	136	dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave,
134		- s_rt->direction,
135		- t_params->port_num);
	137	+ s_rt->direction,
	138	+ t_params->port_num);
136	139	if (!dpn_prop)
137	140	return -EINVAL;
138	141
..	..	@@ -153,24 +156,26 @@
153	156	}
154	157
155	158	/* Program DPN_PortCtrl register */
156		- wbuf = p_params->data_mode << SDW_REG_SHIFT(SDW_DPN_PORTCTRL_DATAMODE);
157		- wbuf \|= p_params->flow_mode;
	159	+ wbuf = FIELD_PREP(SDW_DPN_PORTCTRL_DATAMODE, p_params->data_mode);
	160	+ wbuf \|= FIELD_PREP(SDW_DPN_PORTCTRL_FLOWMODE, p_params->flow_mode);
158	161
159	162	ret = sdw_update(s_rt->slave, addr1, 0xF, wbuf);
160	163	if (ret < 0) {
161	164	dev_err(&s_rt->slave->dev,
162		- "DPN_PortCtrl register write failed for port %d",
	165	+ "DPN_PortCtrl register write failed for port %d\n",
163	166	t_params->port_num);
164	167	return ret;
165	168	}
166	169
167		- /* Program DPN_BlockCtrl1 register */
168		- ret = sdw_write(s_rt->slave, addr2, (p_params->bps - 1));
169		- if (ret < 0) {
170		- dev_err(&s_rt->slave->dev,
171		- "DPN_BlockCtrl1 register write failed for port %d",
172		- t_params->port_num);
173		- return ret;
	170	+ if (!dpn_prop->read_only_wordlength) {
	171	+ /* Program DPN_BlockCtrl1 register */
	172	+ ret = sdw_write(s_rt->slave, addr2, (p_params->bps - 1));
	173	+ if (ret < 0) {
	174	+ dev_err(&s_rt->slave->dev,
	175	+ "DPN_BlockCtrl1 register write failed for port %d\n",
	176	+ t_params->port_num);
	177	+ return ret;
	178	+ }
174	179	}
175	180
176	181	/* Program DPN_SampleCtrl1 register */
..	..	@@ -178,7 +183,7 @@
178	183	ret = sdw_write(s_rt->slave, addr3, wbuf);
179	184	if (ret < 0) {
180	185	dev_err(&s_rt->slave->dev,
181		- "DPN_SampleCtrl1 register write failed for port %d",
	186	+ "DPN_SampleCtrl1 register write failed for port %d\n",
182	187	t_params->port_num);
183	188	return ret;
184	189	}
..	..	@@ -187,7 +192,7 @@
187	192	ret = sdw_write(s_rt->slave, addr4, t_params->offset1);
188	193	if (ret < 0) {
189	194	dev_err(&s_rt->slave->dev,
190		- "DPN_OffsetCtrl1 register write failed for port %d",
	195	+ "DPN_OffsetCtrl1 register write failed for port %d\n",
191	196	t_params->port_num);
192	197	return ret;
193	198	}
..	..	@@ -197,7 +202,7 @@
197	202	ret = sdw_write(s_rt->slave, addr5, t_params->blk_grp_ctrl);
198	203	if (ret < 0) {
199	204	dev_err(&s_rt->slave->dev,
200		- "DPN_BlockCtrl2 reg write failed for port %d",
	205	+ "DPN_BlockCtrl2 reg write failed for port %d\n",
201	206	t_params->port_num);
202	207	return ret;
203	208	}
..	..	@@ -208,7 +213,7 @@
208	213	ret = sdw_write(s_rt->slave, addr6, t_params->lane_ctrl);
209	214	if (ret < 0) {
210	215	dev_err(&s_rt->slave->dev,
211		- "DPN_LaneCtrl register write failed for port %d",
	216	+ "DPN_LaneCtrl register write failed for port %d\n",
212	217	t_params->port_num);
213	218	return ret;
214	219	}
..	..	@@ -216,10 +221,10 @@
216	221
217	222	if (dpn_prop->type != SDW_DPN_SIMPLE) {
218	223	ret = _sdw_program_slave_port_params(bus, s_rt->slave,
219		- t_params, dpn_prop->type);
	224	+ t_params, dpn_prop->type);
220	225	if (ret < 0)
221	226	dev_err(&s_rt->slave->dev,
222		- "Transport reg write failed for port: %d",
	227	+ "Transport reg write failed for port: %d\n",
223	228	t_params->port_num);
224	229	}
225	230
..	..	@@ -227,13 +232,13 @@
227	232	}
228	233
229	234	static int sdw_program_master_port_params(struct sdw_bus *bus,
230		- struct sdw_port_runtime *p_rt)
	235	+ struct sdw_port_runtime *p_rt)
231	236	{
232	237	int ret;
233	238
234	239	/*
235	240	* we need to set transport and port parameters for the port.
236		- * Transport parameters refers to the smaple interval, offsets and
	241	+ * Transport parameters refers to the sample interval, offsets and
237	242	* hstart/stop etc of the data. Port parameters refers to word
238	243	* length, flow mode etc of the port
239	244	*/
..	..	@@ -244,8 +249,8 @@
244	249	return ret;
245	250
246	251	return bus->port_ops->dpn_set_port_params(bus,
247		- &p_rt->port_params,
248		- bus->params.next_bank);
	252	+ &p_rt->port_params,
	253	+ bus->params.next_bank);
249	254	}
250	255
251	256	/**
..	..	@@ -292,8 +297,9 @@
292	297	* actual enable/disable is done with a bank switch
293	298	*/
294	299	static int sdw_enable_disable_slave_ports(struct sdw_bus *bus,
295		- struct sdw_slave_runtime *s_rt,
296		- struct sdw_port_runtime *p_rt, bool en)
	300	+ struct sdw_slave_runtime *s_rt,
	301	+ struct sdw_port_runtime *p_rt,
	302	+ bool en)
297	303	{
298	304	struct sdw_transport_params *t_params = &p_rt->transport_params;
299	305	u32 addr;
..	..	@@ -309,25 +315,26 @@
309	315	* it is safe to reset this register
310	316	*/
311	317	if (en)
312		- ret = sdw_update(s_rt->slave, addr, 0xFF, p_rt->ch_mask);
	318	+ ret = sdw_write(s_rt->slave, addr, p_rt->ch_mask);
313	319	else
314		- ret = sdw_update(s_rt->slave, addr, 0xFF, 0x0);
	320	+ ret = sdw_write(s_rt->slave, addr, 0x0);
315	321
316	322	if (ret < 0)
317	323	dev_err(&s_rt->slave->dev,
318		- "Slave chn_en reg write failed:%d port:%d",
	324	+ "Slave chn_en reg write failed:%d port:%d\n",
319	325	ret, t_params->port_num);
320	326
321	327	return ret;
322	328	}
323	329
324	330	static int sdw_enable_disable_master_ports(struct sdw_master_runtime *m_rt,
325		- struct sdw_port_runtime *p_rt, bool en)
	331	+ struct sdw_port_runtime *p_rt,
	332	+ bool en)
326	333	{
327	334	struct sdw_transport_params *t_params = &p_rt->transport_params;
328	335	struct sdw_bus *bus = m_rt->bus;
329	336	struct sdw_enable_ch enable_ch;
330		- int ret = 0;
	337	+ int ret;
331	338
332	339	enable_ch.port_num = p_rt->num;
333	340	enable_ch.ch_mask = p_rt->ch_mask;
..	..	@@ -336,10 +343,11 @@
336	343	/* Perform Master port channel(s) enable/disable */
337	344	if (bus->port_ops->dpn_port_enable_ch) {
338	345	ret = bus->port_ops->dpn_port_enable_ch(bus,
339		- &enable_ch, bus->params.next_bank);
	346	+ &enable_ch,
	347	+ bus->params.next_bank);
340	348	if (ret < 0) {
341	349	dev_err(bus->dev,
342		- "Master chn_en write failed:%d port:%d",
	350	+ "Master chn_en write failed:%d port:%d\n",
343	351	ret, t_params->port_num);
344	352	return ret;
345	353	}
..	..	@@ -363,14 +371,14 @@
363	371	static int sdw_enable_disable_ports(struct sdw_master_runtime *m_rt, bool en)
364	372	{
365	373	struct sdw_port_runtime s_port, m_port;
366		- struct sdw_slave_runtime *s_rt = NULL;
	374	+ struct sdw_slave_runtime *s_rt;
367	375	int ret = 0;
368	376
369	377	/* Enable/Disable Slave port(s) */
370	378	list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
371	379	list_for_each_entry(s_port, &s_rt->port_list, port_node) {
372	380	ret = sdw_enable_disable_slave_ports(m_rt->bus, s_rt,
373		- s_port, en);
	381	+ s_port, en);
374	382	if (ret < 0)
375	383	return ret;
376	384	}
..	..	@@ -387,7 +395,8 @@
387	395	}
388	396
389	397	static int sdw_do_port_prep(struct sdw_slave_runtime *s_rt,
390		- struct sdw_prepare_ch prep_ch, enum sdw_port_prep_ops cmd)
	398	+ struct sdw_prepare_ch prep_ch,
	399	+ enum sdw_port_prep_ops cmd)
391	400	{
392	401	const struct sdw_slave_ops *ops = s_rt->slave->ops;
393	402	int ret;
..	..	@@ -396,7 +405,8 @@
396	405	ret = ops->port_prep(s_rt->slave, &prep_ch, cmd);
397	406	if (ret < 0) {
398	407	dev_err(&s_rt->slave->dev,
399		- "Slave Port Prep cmd %d failed: %d", cmd, ret);
	408	+ "Slave Port Prep cmd %d failed: %d\n",
	409	+ cmd, ret);
400	410	return ret;
401	411	}
402	412	}
..	..	@@ -405,13 +415,13 @@
405	415	}
406	416
407	417	static int sdw_prep_deprep_slave_ports(struct sdw_bus *bus,
408		- struct sdw_slave_runtime *s_rt,
409		- struct sdw_port_runtime *p_rt, bool prep)
	418	+ struct sdw_slave_runtime *s_rt,
	419	+ struct sdw_port_runtime *p_rt,
	420	+ bool prep)
410	421	{
411		- struct completion *port_ready = NULL;
	422	+ struct completion *port_ready;
412	423	struct sdw_dpn_prop *dpn_prop;
413	424	struct sdw_prepare_ch prep_ch;
414		- unsigned int time_left;
415	425	bool intr = false;
416	426	int ret = 0, val;
417	427	u32 addr;
..	..	@@ -420,11 +430,11 @@
420	430	prep_ch.ch_mask = p_rt->ch_mask;
421	431
422	432	dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave,
423		- s_rt->direction,
424		- prep_ch.num);
	433	+ s_rt->direction,
	434	+ prep_ch.num);
425	435	if (!dpn_prop) {
426	436	dev_err(bus->dev,
427		- "Slave Port:%d properties not found", prep_ch.num);
	437	+ "Slave Port:%d properties not found\n", prep_ch.num);
428	438	return -EINVAL;
429	439	}
430	440
..	..	@@ -432,7 +442,8 @@
432	442
433	443	prep_ch.bank = bus->params.next_bank;
434	444
435		- if (dpn_prop->device_interrupts \|\| !dpn_prop->simple_ch_prep_sm)
	445	+ if (dpn_prop->imp_def_interrupts \|\| !dpn_prop->simple_ch_prep_sm \|\|
	446	+ bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL)
436	447	intr = true;
437	448
438	449	/*
..	..	@@ -442,7 +453,7 @@
442	453	*/
443	454	if (prep && intr) {
444	455	ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep,
445		- dpn_prop->device_interrupts);
	456	+ dpn_prop->imp_def_interrupts);
446	457	if (ret < 0)
447	458	return ret;
448	459	}
..	..	@@ -455,28 +466,27 @@
455	466	addr = SDW_DPN_PREPARECTRL(p_rt->num);
456	467
457	468	if (prep)
458		- ret = sdw_update(s_rt->slave, addr,
459		- 0xFF, p_rt->ch_mask);
	469	+ ret = sdw_write(s_rt->slave, addr, p_rt->ch_mask);
460	470	else
461		- ret = sdw_update(s_rt->slave, addr, 0xFF, 0x0);
	471	+ ret = sdw_write(s_rt->slave, addr, 0x0);
462	472
463	473	if (ret < 0) {
464	474	dev_err(&s_rt->slave->dev,
465		- "Slave prep_ctrl reg write failed");
	475	+ "Slave prep_ctrl reg write failed\n");
466	476	return ret;
467	477	}
468	478
469	479	/* Wait for completion on port ready */
470	480	port_ready = &s_rt->slave->port_ready[prep_ch.num];
471		- time_left = wait_for_completion_timeout(port_ready,
472		- msecs_to_jiffies(dpn_prop->ch_prep_timeout));
	481	+ wait_for_completion_timeout(port_ready,
	482	+ msecs_to_jiffies(dpn_prop->ch_prep_timeout));
473	483
474	484	val = sdw_read(s_rt->slave, SDW_DPN_PREPARESTATUS(p_rt->num));
475		- val &= p_rt->ch_mask;
476		- if (!time_left \|\| val) {
	485	+ if ((val < 0) \|\| (val & p_rt->ch_mask)) {
	486	+ ret = (val < 0) ? val : -ETIMEDOUT;
477	487	dev_err(&s_rt->slave->dev,
478		- "Chn prep failed for port:%d", prep_ch.num);
479		- return -ETIMEDOUT;
	488	+ "Chn prep failed for port %d: %d\n", prep_ch.num, ret);
	489	+ return ret;
480	490	}
481	491	}
482	492
..	..	@@ -486,13 +496,14 @@
486	496	/* Disable interrupt after Port de-prepare */
487	497	if (!prep && intr)
488	498	ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep,
489		- dpn_prop->device_interrupts);
	499	+ dpn_prop->imp_def_interrupts);
490	500
491	501	return ret;
492	502	}
493	503
494	504	static int sdw_prep_deprep_master_ports(struct sdw_master_runtime *m_rt,
495		- struct sdw_port_runtime *p_rt, bool prep)
	505	+ struct sdw_port_runtime *p_rt,
	506	+ bool prep)
496	507	{
497	508	struct sdw_transport_params *t_params = &p_rt->transport_params;
498	509	struct sdw_bus *bus = m_rt->bus;
..	..	@@ -509,8 +520,8 @@
509	520	if (ops->dpn_port_prep) {
510	521	ret = ops->dpn_port_prep(bus, &prep_ch);
511	522	if (ret < 0) {
512		- dev_err(bus->dev, "Port prepare failed for port:%d",
513		- t_params->port_num);
	523	+ dev_err(bus->dev, "Port prepare failed for port:%d\n",
	524	+ t_params->port_num);
514	525	return ret;
515	526	}
516	527	}
..	..	@@ -527,7 +538,7 @@
527	538	*/
528	539	static int sdw_prep_deprep_ports(struct sdw_master_runtime *m_rt, bool prep)
529	540	{
530		- struct sdw_slave_runtime *s_rt = NULL;
	541	+ struct sdw_slave_runtime *s_rt;
531	542	struct sdw_port_runtime *p_rt;
532	543	int ret = 0;
533	544
..	..	@@ -535,7 +546,7 @@
535	546	list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
536	547	list_for_each_entry(p_rt, &s_rt->port_list, port_node) {
537	548	ret = sdw_prep_deprep_slave_ports(m_rt->bus, s_rt,
538		- p_rt, prep);
	549	+ p_rt, prep);
539	550	if (ret < 0)
540	551	return ret;
541	552	}
..	..	@@ -577,10 +588,11 @@
577	588
578	589	if (slave->ops->bus_config) {
579	590	ret = slave->ops->bus_config(slave, &bus->params);
580		- if (ret < 0)
581		- dev_err(bus->dev, "Notify Slave: %d failed",
582		- slave->dev_num);
583		- return ret;
	591	+ if (ret < 0) {
	592	+ dev_err(bus->dev, "Notify Slave: %d failed\n",
	593	+ slave->dev_num);
	594	+ return ret;
	595	+ }
584	596	}
585	597	}
586	598
..	..	@@ -592,23 +604,36 @@
592	604	* and Slave(s)
593	605	*
594	606	* @bus: SDW bus instance
	607	+ * @prepare: true if sdw_program_params() is called by _prepare.
595	608	*/
596		-static int sdw_program_params(struct sdw_bus *bus)
	609	+static int sdw_program_params(struct sdw_bus *bus, bool prepare)
597	610	{
598		- struct sdw_master_runtime *m_rt = NULL;
	611	+ struct sdw_master_runtime *m_rt;
599	612	int ret = 0;
600	613
601	614	list_for_each_entry(m_rt, &bus->m_rt_list, bus_node) {
	615	+
	616	+ /*
	617	+ * this loop walks through all master runtimes for a
	618	+ * bus, but the ports can only be configured while
	619	+ * explicitly preparing a stream or handling an
	620	+ * already-prepared stream otherwise.
	621	+ */
	622	+ if (!prepare &&
	623	+ m_rt->stream->state == SDW_STREAM_CONFIGURED)
	624	+ continue;
	625	+
602	626	ret = sdw_program_port_params(m_rt);
603	627	if (ret < 0) {
604	628	dev_err(bus->dev,
605		- "Program transport params failed: %d", ret);
	629	+ "Program transport params failed: %d\n", ret);
606	630	return ret;
607	631	}
608	632
609	633	ret = sdw_notify_config(m_rt);
610	634	if (ret < 0) {
611		- dev_err(bus->dev, "Notify bus config failed: %d", ret);
	635	+ dev_err(bus->dev,
	636	+ "Notify bus config failed: %d\n", ret);
612	637	return ret;
613	638	}
614	639
..	..	@@ -618,7 +643,7 @@
618	643
619	644	ret = sdw_enable_disable_ports(m_rt, true);
620	645	if (ret < 0) {
621		- dev_err(bus->dev, "Enable channel failed: %d", ret);
	646	+ dev_err(bus->dev, "Enable channel failed: %d\n", ret);
622	647	return ret;
623	648	}
624	649	}
..	..	@@ -626,17 +651,20 @@
626	651	return ret;
627	652	}
628	653
629		-static int sdw_bank_switch(struct sdw_bus *bus)
	654	+static int sdw_bank_switch(struct sdw_bus *bus, int m_rt_count)
630	655	{
631	656	int col_index, row_index;
	657	+ bool multi_link;
632	658	struct sdw_msg *wr_msg;
633		- u8 *wbuf = NULL;
634		- int ret = 0;
	659	+ u8 *wbuf;
	660	+ int ret;
635	661	u16 addr;
636	662
637	663	wr_msg = kzalloc(sizeof(*wr_msg), GFP_KERNEL);
638	664	if (!wr_msg)
639	665	return -ENOMEM;
	666	+
	667	+ bus->defer_msg.msg = wr_msg;
640	668
641	669	wbuf = kzalloc(sizeof(*wbuf), GFP_KERNEL);
642	670	if (!wbuf) {
..	..	@@ -655,20 +683,32 @@
655	683	addr = SDW_SCP_FRAMECTRL_B0;
656	684
657	685	sdw_fill_msg(wr_msg, NULL, addr, 1, SDW_BROADCAST_DEV_NUM,
658		- SDW_MSG_FLAG_WRITE, wbuf);
	686	+ SDW_MSG_FLAG_WRITE, wbuf);
659	687	wr_msg->ssp_sync = true;
660	688
661		- ret = sdw_transfer(bus, wr_msg);
	689	+ /*
	690	+ * Set the multi_link flag only when both the hardware supports
	691	+ * and hardware-based sync is required
	692	+ */
	693	+ multi_link = bus->multi_link && (m_rt_count >= bus->hw_sync_min_links);
	694	+
	695	+ if (multi_link)
	696	+ ret = sdw_transfer_defer(bus, wr_msg, &bus->defer_msg);
	697	+ else
	698	+ ret = sdw_transfer(bus, wr_msg);
	699	+
662	700	if (ret < 0) {
663		- dev_err(bus->dev, "Slave frame_ctrl reg write failed");
	701	+ dev_err(bus->dev, "Slave frame_ctrl reg write failed\n");
664	702	goto error;
665	703	}
666	704
667		- kfree(wr_msg);
668		- kfree(wbuf);
669		- bus->defer_msg.msg = NULL;
670		- bus->params.curr_bank = !bus->params.curr_bank;
671		- bus->params.next_bank = !bus->params.next_bank;
	705	+ if (!multi_link) {
	706	+ kfree(wr_msg);
	707	+ kfree(wbuf);
	708	+ bus->defer_msg.msg = NULL;
	709	+ bus->params.curr_bank = !bus->params.curr_bank;
	710	+ bus->params.next_bank = !bus->params.next_bank;
	711	+ }
672	712
673	713	return 0;
674	714
..	..	@@ -676,40 +716,146 @@
676	716	kfree(wbuf);
677	717	error_1:
678	718	kfree(wr_msg);
	719	+ bus->defer_msg.msg = NULL;
679	720	return ret;
	721	+}
	722	+
	723	+/**
	724	+ * sdw_ml_sync_bank_switch: Multilink register bank switch
	725	+ *
	726	+ * @bus: SDW bus instance
	727	+ *
	728	+ * Caller function should free the buffers on error
	729	+ */
	730	+static int sdw_ml_sync_bank_switch(struct sdw_bus *bus)
	731	+{
	732	+ unsigned long time_left;
	733	+
	734	+ if (!bus->multi_link)
	735	+ return 0;
	736	+
	737	+ /* Wait for completion of transfer */
	738	+ time_left = wait_for_completion_timeout(&bus->defer_msg.complete,
	739	+ bus->bank_switch_timeout);
	740	+
	741	+ if (!time_left) {
	742	+ dev_err(bus->dev, "Controller Timed out on bank switch\n");
	743	+ return -ETIMEDOUT;
	744	+ }
	745	+
	746	+ bus->params.curr_bank = !bus->params.curr_bank;
	747	+ bus->params.next_bank = !bus->params.next_bank;
	748	+
	749	+ if (bus->defer_msg.msg) {
	750	+ kfree(bus->defer_msg.msg->buf);
	751	+ kfree(bus->defer_msg.msg);
	752	+ }
	753	+
	754	+ return 0;
680	755	}
681	756
682	757	static int do_bank_switch(struct sdw_stream_runtime *stream)
683	758	{
684		- struct sdw_master_runtime *m_rt = stream->m_rt;
	759	+ struct sdw_master_runtime *m_rt;
685	760	const struct sdw_master_ops *ops;
686		- struct sdw_bus *bus = m_rt->bus;
	761	+ struct sdw_bus *bus;
	762	+ bool multi_link = false;
	763	+ int m_rt_count;
687	764	int ret = 0;
688	765
689		- ops = bus->ops;
	766	+ m_rt_count = stream->m_rt_count;
690	767
691		- /* Pre-bank switch */
692		- if (ops->pre_bank_switch) {
693		- ret = ops->pre_bank_switch(bus);
	768	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	769	+ bus = m_rt->bus;
	770	+ ops = bus->ops;
	771	+
	772	+ if (bus->multi_link && m_rt_count >= bus->hw_sync_min_links) {
	773	+ multi_link = true;
	774	+ mutex_lock(&bus->msg_lock);
	775	+ }
	776	+
	777	+ /* Pre-bank switch */
	778	+ if (ops->pre_bank_switch) {
	779	+ ret = ops->pre_bank_switch(bus);
	780	+ if (ret < 0) {
	781	+ dev_err(bus->dev,
	782	+ "Pre bank switch op failed: %d\n", ret);
	783	+ goto msg_unlock;
	784	+ }
	785	+ }
	786	+
	787	+ /*
	788	+ * Perform Bank switch operation.
	789	+ * For multi link cases, the actual bank switch is
	790	+ * synchronized across all Masters and happens later as a
	791	+ * part of post_bank_switch ops.
	792	+ */
	793	+ ret = sdw_bank_switch(bus, m_rt_count);
694	794	if (ret < 0) {
695		- dev_err(bus->dev, "Pre bank switch op failed: %d", ret);
696		- return ret;
	795	+ dev_err(bus->dev, "Bank switch failed: %d\n", ret);
	796	+ goto error;
697	797	}
698	798	}
699	799
700		- /* Bank switch */
701		- ret = sdw_bank_switch(bus);
702		- if (ret < 0) {
703		- dev_err(bus->dev, "Bank switch failed: %d", ret);
704		- return ret;
705		- }
	800	+ /*
	801	+ * For multi link cases, it is expected that the bank switch is
	802	+ * triggered by the post_bank_switch for the first Master in the list
	803	+ * and for the other Masters the post_bank_switch() should return doing
	804	+ * nothing.
	805	+ */
	806	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	807	+ bus = m_rt->bus;
	808	+ ops = bus->ops;
706	809
707		- /* Post-bank switch */
708		- if (ops->post_bank_switch) {
709		- ret = ops->post_bank_switch(bus);
	810	+ /* Post-bank switch */
	811	+ if (ops->post_bank_switch) {
	812	+ ret = ops->post_bank_switch(bus);
	813	+ if (ret < 0) {
	814	+ dev_err(bus->dev,
	815	+ "Post bank switch op failed: %d\n",
	816	+ ret);
	817	+ goto error;
	818	+ }
	819	+ } else if (multi_link) {
	820	+ dev_err(bus->dev,
	821	+ "Post bank switch ops not implemented\n");
	822	+ goto error;
	823	+ }
	824	+
	825	+ /* Set the bank switch timeout to default, if not set */
	826	+ if (!bus->bank_switch_timeout)
	827	+ bus->bank_switch_timeout = DEFAULT_BANK_SWITCH_TIMEOUT;
	828	+
	829	+ /* Check if bank switch was successful */
	830	+ ret = sdw_ml_sync_bank_switch(bus);
710	831	if (ret < 0) {
711	832	dev_err(bus->dev,
712		- "Post bank switch op failed: %d", ret);
	833	+ "multi link bank switch failed: %d\n", ret);
	834	+ goto error;
	835	+ }
	836	+
	837	+ if (multi_link)
	838	+ mutex_unlock(&bus->msg_lock);
	839	+ }
	840	+
	841	+ return ret;
	842	+
	843	+error:
	844	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	845	+ bus = m_rt->bus;
	846	+ if (bus->defer_msg.msg) {
	847	+ kfree(bus->defer_msg.msg->buf);
	848	+ kfree(bus->defer_msg.msg);
	849	+ }
	850	+ }
	851	+
	852	+msg_unlock:
	853	+
	854	+ if (multi_link) {
	855	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	856	+ bus = m_rt->bus;
	857	+ if (mutex_is_locked(&bus->msg_lock))
	858	+ mutex_unlock(&bus->msg_lock);
713	859	}
714	860	}
715	861
..	..	@@ -738,7 +884,7 @@
738	884	* sdw_alloc_stream should be called only once per stream. Typically
739	885	* invoked from ALSA/ASoC machine/platform driver.
740	886	*/
741		-struct sdw_stream_runtime sdw_alloc_stream(char stream_name)
	887	+struct sdw_stream_runtime sdw_alloc_stream(const char stream_name)
742	888	{
743	889	struct sdw_stream_runtime *stream;
744	890
..	..	@@ -747,11 +893,28 @@
747	893	return NULL;
748	894
749	895	stream->name = stream_name;
	896	+ INIT_LIST_HEAD(&stream->master_list);
750	897	stream->state = SDW_STREAM_ALLOCATED;
	898	+ stream->m_rt_count = 0;
751	899
752	900	return stream;
753	901	}
754	902	EXPORT_SYMBOL(sdw_alloc_stream);
	903	+
	904	+static struct sdw_master_runtime
	905	+sdw_find_master_rt(struct sdw_bus bus,
	906	+ struct sdw_stream_runtime *stream)
	907	+{
	908	+ struct sdw_master_runtime *m_rt;
	909	+
	910	+ /* Retrieve Bus handle if already available */
	911	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	912	+ if (m_rt->bus == bus)
	913	+ return m_rt;
	914	+ }
	915	+
	916	+ return NULL;
	917	+}
755	918
756	919	/**
757	920	* sdw_alloc_master_rt() - Allocates and initialize Master runtime handle
..	..	@@ -764,17 +927,16 @@
764	927	*/
765	928	static struct sdw_master_runtime
766	929	sdw_alloc_master_rt(struct sdw_bus bus,
767		- struct sdw_stream_config *stream_config,
768		- struct sdw_stream_runtime *stream)
	930	+ struct sdw_stream_config *stream_config,
	931	+ struct sdw_stream_runtime *stream)
769	932	{
770	933	struct sdw_master_runtime *m_rt;
771		-
772		- m_rt = stream->m_rt;
773	934
774	935	/*
775	936	* check if Master is already allocated (as a result of Slave adding
776	937	* it first), if so skip allocation and go to configure
777	938	*/
	939	+ m_rt = sdw_find_master_rt(bus, stream);
778	940	if (m_rt)
779	941	goto stream_config;
780	942
..	..	@@ -785,7 +947,7 @@
785	947	/* Initialization of Master runtime handle */
786	948	INIT_LIST_HEAD(&m_rt->port_list);
787	949	INIT_LIST_HEAD(&m_rt->slave_rt_list);
788		- stream->m_rt = m_rt;
	950	+ list_add_tail(&m_rt->stream_node, &stream->master_list);
789	951
790	952	list_add_tail(&m_rt->bus_node, &bus->m_rt_list);
791	953
..	..	@@ -809,10 +971,10 @@
809	971	*/
810	972	static struct sdw_slave_runtime
811	973	sdw_alloc_slave_rt(struct sdw_slave slave,
812		- struct sdw_stream_config *stream_config,
813		- struct sdw_stream_runtime *stream)
	974	+ struct sdw_stream_config *stream_config,
	975	+ struct sdw_stream_runtime *stream)
814	976	{
815		- struct sdw_slave_runtime *s_rt = NULL;
	977	+ struct sdw_slave_runtime *s_rt;
816	978
817	979	s_rt = kzalloc(sizeof(*s_rt), GFP_KERNEL);
818	980	if (!s_rt)
..	..	@@ -827,33 +989,34 @@
827	989	}
828	990
829	991	static void sdw_master_port_release(struct sdw_bus *bus,
830		- struct sdw_master_runtime *m_rt)
	992	+ struct sdw_master_runtime *m_rt)
831	993	{
832	994	struct sdw_port_runtime p_rt, _p_rt;
833	995
834		- list_for_each_entry_safe(p_rt, _p_rt,
835		- &m_rt->port_list, port_node) {
	996	+ list_for_each_entry_safe(p_rt, _p_rt, &m_rt->port_list, port_node) {
836	997	list_del(&p_rt->port_node);
837	998	kfree(p_rt);
838	999	}
839	1000	}
840	1001
841	1002	static void sdw_slave_port_release(struct sdw_bus *bus,
842		- struct sdw_slave *slave,
843		- struct sdw_stream_runtime *stream)
	1003	+ struct sdw_slave *slave,
	1004	+ struct sdw_stream_runtime *stream)
844	1005	{
845	1006	struct sdw_port_runtime p_rt, _p_rt;
846		- struct sdw_master_runtime *m_rt = stream->m_rt;
	1007	+ struct sdw_master_runtime *m_rt;
847	1008	struct sdw_slave_runtime *s_rt;
848	1009
849		- list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
850		- if (s_rt->slave != slave)
851		- continue;
	1010	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1011	+ list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
	1012	+ if (s_rt->slave != slave)
	1013	+ continue;
852	1014
853		- list_for_each_entry_safe(p_rt, _p_rt,
854		- &s_rt->port_list, port_node) {
855		- list_del(&p_rt->port_node);
856		- kfree(p_rt);
	1015	+ list_for_each_entry_safe(p_rt, _p_rt,
	1016	+ &s_rt->port_list, port_node) {
	1017	+ list_del(&p_rt->port_node);
	1018	+ kfree(p_rt);
	1019	+ }
857	1020	}
858	1021	}
859	1022	}
..	..	@@ -867,19 +1030,20 @@
867	1030	* This function is to be called with bus_lock held.
868	1031	*/
869	1032	static void sdw_release_slave_stream(struct sdw_slave *slave,
870		- struct sdw_stream_runtime *stream)
	1033	+ struct sdw_stream_runtime *stream)
871	1034	{
872	1035	struct sdw_slave_runtime s_rt, _s_rt;
873		- struct sdw_master_runtime *m_rt = stream->m_rt;
	1036	+ struct sdw_master_runtime *m_rt;
874	1037
875		- /* Retrieve Slave runtime handle */
876		- list_for_each_entry_safe(s_rt, _s_rt,
877		- &m_rt->slave_rt_list, m_rt_node) {
878		-
879		- if (s_rt->slave == slave) {
880		- list_del(&s_rt->m_rt_node);
881		- kfree(s_rt);
882		- return;
	1038	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1039	+ /* Retrieve Slave runtime handle */
	1040	+ list_for_each_entry_safe(s_rt, _s_rt,
	1041	+ &m_rt->slave_rt_list, m_rt_node) {
	1042	+ if (s_rt->slave == slave) {
	1043	+ list_del(&s_rt->m_rt_node);
	1044	+ kfree(s_rt);
	1045	+ return;
	1046	+ }
883	1047	}
884	1048	}
885	1049	}
..	..	@@ -887,6 +1051,7 @@
887	1051	/**
888	1052	* sdw_release_master_stream() - Free Master runtime handle
889	1053	*
	1054	+ * @m_rt: Master runtime node
890	1055	* @stream: Stream runtime handle.
891	1056	*
892	1057	* This function is to be called with bus_lock held
..	..	@@ -894,9 +1059,9 @@
894	1059	* handle. If this is called first then sdw_release_slave_stream() will have
895	1060	* no effect as Slave(s) runtime handle would already be freed up.
896	1061	*/
897		-static void sdw_release_master_stream(struct sdw_stream_runtime *stream)
	1062	+static void sdw_release_master_stream(struct sdw_master_runtime *m_rt,
	1063	+ struct sdw_stream_runtime *stream)
898	1064	{
899		- struct sdw_master_runtime *m_rt = stream->m_rt;
900	1065	struct sdw_slave_runtime s_rt, _s_rt;
901	1066
902	1067	list_for_each_entry_safe(s_rt, _s_rt, &m_rt->slave_rt_list, m_rt_node) {
..	..	@@ -904,7 +1069,9 @@
904	1069	sdw_release_slave_stream(s_rt->slave, stream);
905	1070	}
906	1071
	1072	+ list_del(&m_rt->stream_node);
907	1073	list_del(&m_rt->bus_node);
	1074	+ kfree(m_rt);
908	1075	}
909	1076
910	1077	/**
..	..	@@ -916,15 +1083,24 @@
916	1083	* This removes and frees port_rt and master_rt from a stream
917	1084	*/
918	1085	int sdw_stream_remove_master(struct sdw_bus *bus,
919		- struct sdw_stream_runtime *stream)
	1086	+ struct sdw_stream_runtime *stream)
920	1087	{
	1088	+ struct sdw_master_runtime m_rt, _m_rt;
	1089	+
921	1090	mutex_lock(&bus->bus_lock);
922	1091
923		- sdw_release_master_stream(stream);
924		- sdw_master_port_release(bus, stream->m_rt);
925		- stream->state = SDW_STREAM_RELEASED;
926		- kfree(stream->m_rt);
927		- stream->m_rt = NULL;
	1092	+ list_for_each_entry_safe(m_rt, _m_rt,
	1093	+ &stream->master_list, stream_node) {
	1094	+ if (m_rt->bus != bus)
	1095	+ continue;
	1096	+
	1097	+ sdw_master_port_release(bus, m_rt);
	1098	+ sdw_release_master_stream(m_rt, stream);
	1099	+ stream->m_rt_count--;
	1100	+ }
	1101	+
	1102	+ if (list_empty(&stream->master_list))
	1103	+ stream->state = SDW_STREAM_RELEASED;
928	1104
929	1105	mutex_unlock(&bus->bus_lock);
930	1106
..	..	@@ -941,7 +1117,7 @@
941	1117	* This removes and frees port_rt and slave_rt from a stream
942	1118	*/
943	1119	int sdw_stream_remove_slave(struct sdw_slave *slave,
944		- struct sdw_stream_runtime *stream)
	1120	+ struct sdw_stream_runtime *stream)
945	1121	{
946	1122	mutex_lock(&slave->bus->bus_lock);
947	1123
..	..	@@ -965,8 +1141,9 @@
965	1141	* This function is to be called with bus_lock held.
966	1142	*/
967	1143	static int sdw_config_stream(struct device *dev,
968		- struct sdw_stream_runtime *stream,
969		- struct sdw_stream_config *stream_config, bool is_slave)
	1144	+ struct sdw_stream_runtime *stream,
	1145	+ struct sdw_stream_config *stream_config,
	1146	+ bool is_slave)
970	1147	{
971	1148	/*
972	1149	* Update the stream rate, channel and bps based on data
..	..	@@ -977,14 +1154,14 @@
977	1154	* comparison and allow the value to be set and stored in stream
978	1155	*/
979	1156	if (stream->params.rate &&
980		- stream->params.rate != stream_config->frame_rate) {
981		- dev_err(dev, "rate not matching, stream:%s", stream->name);
	1157	+ stream->params.rate != stream_config->frame_rate) {
	1158	+ dev_err(dev, "rate not matching, stream:%s\n", stream->name);
982	1159	return -EINVAL;
983	1160	}
984	1161
985	1162	if (stream->params.bps &&
986		- stream->params.bps != stream_config->bps) {
987		- dev_err(dev, "bps not matching, stream:%s", stream->name);
	1163	+ stream->params.bps != stream_config->bps) {
	1164	+ dev_err(dev, "bps not matching, stream:%s\n", stream->name);
988	1165	return -EINVAL;
989	1166	}
990	1167
..	..	@@ -1000,20 +1177,21 @@
1000	1177	}
1001	1178
1002	1179	static int sdw_is_valid_port_range(struct device *dev,
1003		- struct sdw_port_runtime *p_rt)
	1180	+ struct sdw_port_runtime *p_rt)
1004	1181	{
1005	1182	if (!SDW_VALID_PORT_RANGE(p_rt->num)) {
1006	1183	dev_err(dev,
1007		- "SoundWire: Invalid port number :%d", p_rt->num);
	1184	+ "SoundWire: Invalid port number :%d\n", p_rt->num);
1008	1185	return -EINVAL;
1009	1186	}
1010	1187
1011	1188	return 0;
1012	1189	}
1013	1190
1014		-static struct sdw_port_runtime sdw_port_alloc(struct device dev,
1015		- struct sdw_port_config *port_config,
1016		- int port_index)
	1191	+static struct sdw_port_runtime
	1192	+sdw_port_alloc(struct device dev,
	1193	+ struct sdw_port_config *port_config,
	1194	+ int port_index)
1017	1195	{
1018	1196	struct sdw_port_runtime *p_rt;
1019	1197
..	..	@@ -1028,9 +1206,9 @@
1028	1206	}
1029	1207
1030	1208	static int sdw_master_port_config(struct sdw_bus *bus,
1031		- struct sdw_master_runtime *m_rt,
1032		- struct sdw_port_config *port_config,
1033		- unsigned int num_ports)
	1209	+ struct sdw_master_runtime *m_rt,
	1210	+ struct sdw_port_config *port_config,
	1211	+ unsigned int num_ports)
1034	1212	{
1035	1213	struct sdw_port_runtime *p_rt;
1036	1214	int i;
..	..	@@ -1053,9 +1231,9 @@
1053	1231	}
1054	1232
1055	1233	static int sdw_slave_port_config(struct sdw_slave *slave,
1056		- struct sdw_slave_runtime *s_rt,
1057		- struct sdw_port_config *port_config,
1058		- unsigned int num_config)
	1234	+ struct sdw_slave_runtime *s_rt,
	1235	+ struct sdw_port_config *port_config,
	1236	+ unsigned int num_config)
1059	1237	{
1060	1238	struct sdw_port_runtime *p_rt;
1061	1239	int i, ret;
..	..	@@ -1097,21 +1275,33 @@
1097	1275	* @stream: SoundWire stream
1098	1276	*/
1099	1277	int sdw_stream_add_master(struct sdw_bus *bus,
1100		- struct sdw_stream_config *stream_config,
1101		- struct sdw_port_config *port_config,
1102		- unsigned int num_ports,
1103		- struct sdw_stream_runtime *stream)
	1278	+ struct sdw_stream_config *stream_config,
	1279	+ struct sdw_port_config *port_config,
	1280	+ unsigned int num_ports,
	1281	+ struct sdw_stream_runtime *stream)
1104	1282	{
1105		- struct sdw_master_runtime *m_rt = NULL;
	1283	+ struct sdw_master_runtime *m_rt;
1106	1284	int ret;
1107	1285
1108	1286	mutex_lock(&bus->bus_lock);
1109	1287
	1288	+ /*
	1289	+ * For multi link streams, add the second master only if
	1290	+ * the bus supports it.
	1291	+ * Check if bus->multi_link is set
	1292	+ */
	1293	+ if (!bus->multi_link && stream->m_rt_count > 0) {
	1294	+ dev_err(bus->dev,
	1295	+ "Multilink not supported, link %d\n", bus->link_id);
	1296	+ ret = -EINVAL;
	1297	+ goto unlock;
	1298	+ }
	1299	+
1110	1300	m_rt = sdw_alloc_master_rt(bus, stream_config, stream);
1111	1301	if (!m_rt) {
1112	1302	dev_err(bus->dev,
1113		- "Master runtime config failed for stream:%s",
1114		- stream->name);
	1303	+ "Master runtime config failed for stream:%s\n",
	1304	+ stream->name);
1115	1305	ret = -ENOMEM;
1116	1306	goto unlock;
1117	1307	}
..	..	@@ -1124,10 +1314,12 @@
1124	1314	if (ret)
1125	1315	goto stream_error;
1126	1316
	1317	+ stream->m_rt_count++;
	1318	+
1127	1319	goto unlock;
1128	1320
1129	1321	stream_error:
1130		- sdw_release_master_stream(stream);
	1322	+ sdw_release_master_stream(m_rt, stream);
1131	1323	unlock:
1132	1324	mutex_unlock(&bus->bus_lock);
1133	1325	return ret;
..	..	@@ -1148,10 +1340,10 @@
1148	1340	*
1149	1341	*/
1150	1342	int sdw_stream_add_slave(struct sdw_slave *slave,
1151		- struct sdw_stream_config *stream_config,
1152		- struct sdw_port_config *port_config,
1153		- unsigned int num_ports,
1154		- struct sdw_stream_runtime *stream)
	1343	+ struct sdw_stream_config *stream_config,
	1344	+ struct sdw_port_config *port_config,
	1345	+ unsigned int num_ports,
	1346	+ struct sdw_stream_runtime *stream)
1155	1347	{
1156	1348	struct sdw_slave_runtime *s_rt;
1157	1349	struct sdw_master_runtime *m_rt;
..	..	@@ -1166,8 +1358,8 @@
1166	1358	m_rt = sdw_alloc_master_rt(slave->bus, stream_config, stream);
1167	1359	if (!m_rt) {
1168	1360	dev_err(&slave->dev,
1169		- "alloc master runtime failed for stream:%s",
1170		- stream->name);
	1361	+ "alloc master runtime failed for stream:%s\n",
	1362	+ stream->name);
1171	1363	ret = -ENOMEM;
1172	1364	goto error;
1173	1365	}
..	..	@@ -1175,8 +1367,8 @@
1175	1367	s_rt = sdw_alloc_slave_rt(slave, stream_config, stream);
1176	1368	if (!s_rt) {
1177	1369	dev_err(&slave->dev,
1178		- "Slave runtime config failed for stream:%s",
1179		- stream->name);
	1370	+ "Slave runtime config failed for stream:%s\n",
	1371	+ stream->name);
1180	1372	ret = -ENOMEM;
1181	1373	goto stream_error;
1182	1374	}
..	..	@@ -1213,7 +1405,7 @@
1213	1405	* we hit error so cleanup the stream, release all Slave(s) and
1214	1406	* Master runtime
1215	1407	*/
1216		- sdw_release_master_stream(stream);
	1408	+ sdw_release_master_stream(m_rt, stream);
1217	1409	error:
1218	1410	mutex_unlock(&slave->bus->bus_lock);
1219	1411	return ret;
..	..	@@ -1228,8 +1420,8 @@
1228	1420	* @port_num: Port number
1229	1421	*/
1230	1422	struct sdw_dpn_prop sdw_get_slave_dpn_prop(struct sdw_slave slave,
1231		- enum sdw_data_direction direction,
1232		- unsigned int port_num)
	1423	+ enum sdw_data_direction direction,
	1424	+ unsigned int port_num)
1233	1425	{
1234	1426	struct sdw_dpn_prop *dpn_prop;
1235	1427	u8 num_ports;
..	..	@@ -1251,47 +1443,119 @@
1251	1443	return NULL;
1252	1444	}
1253	1445
1254		-static int _sdw_prepare_stream(struct sdw_stream_runtime *stream)
	1446	+/**
	1447	+ * sdw_acquire_bus_lock: Acquire bus lock for all Master runtime(s)
	1448	+ *
	1449	+ * @stream: SoundWire stream
	1450	+ *
	1451	+ * Acquire bus_lock for each of the master runtime(m_rt) part of this
	1452	+ * stream to reconfigure the bus.
	1453	+ * NOTE: This function is called from SoundWire stream ops and is
	1454	+ * expected that a global lock is held before acquiring bus_lock.
	1455	+ */
	1456	+static void sdw_acquire_bus_lock(struct sdw_stream_runtime *stream)
1255	1457	{
1256		- struct sdw_master_runtime *m_rt = stream->m_rt;
1257		- struct sdw_bus *bus = m_rt->bus;
1258		- struct sdw_master_prop *prop = NULL;
	1458	+ struct sdw_master_runtime *m_rt;
	1459	+ struct sdw_bus *bus = NULL;
	1460	+
	1461	+ /* Iterate for all Master(s) in Master list */
	1462	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1463	+ bus = m_rt->bus;
	1464	+
	1465	+ mutex_lock(&bus->bus_lock);
	1466	+ }
	1467	+}
	1468	+
	1469	+/**
	1470	+ * sdw_release_bus_lock: Release bus lock for all Master runtime(s)
	1471	+ *
	1472	+ * @stream: SoundWire stream
	1473	+ *
	1474	+ * Release the previously held bus_lock after reconfiguring the bus.
	1475	+ * NOTE: This function is called from SoundWire stream ops and is
	1476	+ * expected that a global lock is held before releasing bus_lock.
	1477	+ */
	1478	+static void sdw_release_bus_lock(struct sdw_stream_runtime *stream)
	1479	+{
	1480	+ struct sdw_master_runtime *m_rt = NULL;
	1481	+ struct sdw_bus *bus = NULL;
	1482	+
	1483	+ /* Iterate for all Master(s) in Master list */
	1484	+ list_for_each_entry_reverse(m_rt, &stream->master_list, stream_node) {
	1485	+ bus = m_rt->bus;
	1486	+ mutex_unlock(&bus->bus_lock);
	1487	+ }
	1488	+}
	1489	+
	1490	+static int _sdw_prepare_stream(struct sdw_stream_runtime *stream,
	1491	+ bool update_params)
	1492	+{
	1493	+ struct sdw_master_runtime *m_rt;
	1494	+ struct sdw_bus *bus = NULL;
	1495	+ struct sdw_master_prop *prop;
1259	1496	struct sdw_bus_params params;
1260	1497	int ret;
1261	1498
1262		- prop = &bus->prop;
1263		- memcpy(&params, &bus->params, sizeof(params));
	1499	+ /* Prepare Master(s) and Slave(s) port(s) associated with stream */
	1500	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1501	+ bus = m_rt->bus;
	1502	+ prop = &bus->prop;
	1503	+ memcpy(&params, &bus->params, sizeof(params));
1264	1504
1265		- /* TODO: Support Asynchronous mode */
1266		- if ((prop->max_freq % stream->params.rate) != 0) {
1267		- dev_err(bus->dev, "Async mode not supported");
1268		- return -EINVAL;
	1505	+ /* TODO: Support Asynchronous mode */
	1506	+ if ((prop->max_clk_freq % stream->params.rate) != 0) {
	1507	+ dev_err(bus->dev, "Async mode not supported\n");
	1508	+ return -EINVAL;
	1509	+ }
	1510	+
	1511	+ if (!update_params)
	1512	+ goto program_params;
	1513	+
	1514	+ /* Increment cumulative bus bandwidth */
	1515	+ /* TODO: Update this during Device-Device support */
	1516	+ bus->params.bandwidth += m_rt->stream->params.rate *
	1517	+ m_rt->ch_count * m_rt->stream->params.bps;
	1518	+
	1519	+ /* Compute params */
	1520	+ if (bus->compute_params) {
	1521	+ ret = bus->compute_params(bus);
	1522	+ if (ret < 0) {
	1523	+ dev_err(bus->dev, "Compute params failed: %d",
	1524	+ ret);
	1525	+ return ret;
	1526	+ }
	1527	+ }
	1528	+
	1529	+program_params:
	1530	+ /* Program params */
	1531	+ ret = sdw_program_params(bus, true);
	1532	+ if (ret < 0) {
	1533	+ dev_err(bus->dev, "Program params failed: %d\n", ret);
	1534	+ goto restore_params;
	1535	+ }
1269	1536	}
1270	1537
1271		- /* Increment cumulative bus bandwidth */
1272		- /* TODO: Update this during Device-Device support */
1273		- bus->params.bandwidth += m_rt->stream->params.rate *
1274		- m_rt->ch_count * m_rt->stream->params.bps;
1275		-
1276		- /* Program params */
1277		- ret = sdw_program_params(bus);
1278		- if (ret < 0) {
1279		- dev_err(bus->dev, "Program params failed: %d", ret);
1280		- goto restore_params;
	1538	+ if (!bus) {
	1539	+ pr_err("Configuration error in %s\n", __func__);
	1540	+ return -EINVAL;
1281	1541	}
1282	1542
1283	1543	ret = do_bank_switch(stream);
1284	1544	if (ret < 0) {
1285		- dev_err(bus->dev, "Bank switch failed: %d", ret);
	1545	+ dev_err(bus->dev, "Bank switch failed: %d\n", ret);
1286	1546	goto restore_params;
1287	1547	}
1288	1548
1289		- /* Prepare port(s) on the new clock configuration */
1290		- ret = sdw_prep_deprep_ports(m_rt, true);
1291		- if (ret < 0) {
1292		- dev_err(bus->dev, "Prepare port(s) failed ret = %d",
	1549	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1550	+ bus = m_rt->bus;
	1551	+
	1552	+ /* Prepare port(s) on the new clock configuration */
	1553	+ ret = sdw_prep_deprep_ports(m_rt, true);
	1554	+ if (ret < 0) {
	1555	+ dev_err(bus->dev, "Prepare port(s) failed ret = %d\n",
1293	1556	ret);
1294		- return ret;
	1557	+ return ret;
	1558	+ }
1295	1559	}
1296	1560
1297	1561	stream->state = SDW_STREAM_PREPARED;
..	..	@@ -1312,47 +1576,81 @@
1312	1576	*/
1313	1577	int sdw_prepare_stream(struct sdw_stream_runtime *stream)
1314	1578	{
1315		- int ret = 0;
	1579	+ bool update_params = true;
	1580	+ int ret;
1316	1581
1317	1582	if (!stream) {
1318		- pr_err("SoundWire: Handle not found for stream");
	1583	+ pr_err("SoundWire: Handle not found for stream\n");
1319	1584	return -EINVAL;
1320	1585	}
1321	1586
1322		- mutex_lock(&stream->m_rt->bus->bus_lock);
	1587	+ sdw_acquire_bus_lock(stream);
1323	1588
1324		- ret = _sdw_prepare_stream(stream);
1325		- if (ret < 0)
1326		- pr_err("Prepare for stream:%s failed: %d", stream->name, ret);
	1589	+ if (stream->state == SDW_STREAM_PREPARED) {
	1590	+ ret = 0;
	1591	+ goto state_err;
	1592	+ }
1327	1593
1328		- mutex_unlock(&stream->m_rt->bus->bus_lock);
	1594	+ if (stream->state != SDW_STREAM_CONFIGURED &&
	1595	+ stream->state != SDW_STREAM_DEPREPARED &&
	1596	+ stream->state != SDW_STREAM_DISABLED) {
	1597	+ pr_err("%s: %s: inconsistent state state %d\n",
	1598	+ __func__, stream->name, stream->state);
	1599	+ ret = -EINVAL;
	1600	+ goto state_err;
	1601	+ }
	1602	+
	1603	+ /*
	1604	+ * when the stream is DISABLED, this means sdw_prepare_stream()
	1605	+ * is called as a result of an underflow or a resume operation.
	1606	+ * In this case, the bus parameters shall not be recomputed, but
	1607	+ * still need to be re-applied
	1608	+ */
	1609	+ if (stream->state == SDW_STREAM_DISABLED)
	1610	+ update_params = false;
	1611	+
	1612	+ ret = _sdw_prepare_stream(stream, update_params);
	1613	+
	1614	+state_err:
	1615	+ sdw_release_bus_lock(stream);
1329	1616	return ret;
1330	1617	}
1331	1618	EXPORT_SYMBOL(sdw_prepare_stream);
1332	1619
1333	1620	static int _sdw_enable_stream(struct sdw_stream_runtime *stream)
1334	1621	{
1335		- struct sdw_master_runtime *m_rt = stream->m_rt;
1336		- struct sdw_bus *bus = m_rt->bus;
	1622	+ struct sdw_master_runtime *m_rt;
	1623	+ struct sdw_bus *bus = NULL;
1337	1624	int ret;
1338	1625
1339		- /* Program params */
1340		- ret = sdw_program_params(bus);
1341		- if (ret < 0) {
1342		- dev_err(bus->dev, "Program params failed: %d", ret);
1343		- return ret;
	1626	+ /* Enable Master(s) and Slave(s) port(s) associated with stream */
	1627	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1628	+ bus = m_rt->bus;
	1629	+
	1630	+ /* Program params */
	1631	+ ret = sdw_program_params(bus, false);
	1632	+ if (ret < 0) {
	1633	+ dev_err(bus->dev, "Program params failed: %d\n", ret);
	1634	+ return ret;
	1635	+ }
	1636	+
	1637	+ /* Enable port(s) */
	1638	+ ret = sdw_enable_disable_ports(m_rt, true);
	1639	+ if (ret < 0) {
	1640	+ dev_err(bus->dev,
	1641	+ "Enable port(s) failed ret: %d\n", ret);
	1642	+ return ret;
	1643	+ }
1344	1644	}
1345	1645
1346		- /* Enable port(s) */
1347		- ret = sdw_enable_disable_ports(m_rt, true);
1348		- if (ret < 0) {
1349		- dev_err(bus->dev, "Enable port(s) failed ret: %d", ret);
1350		- return ret;
	1646	+ if (!bus) {
	1647	+ pr_err("Configuration error in %s\n", __func__);
	1648	+ return -EINVAL;
1351	1649	}
1352	1650
1353	1651	ret = do_bank_switch(stream);
1354	1652	if (ret < 0) {
1355		- dev_err(bus->dev, "Bank switch failed: %d", ret);
	1653	+ dev_err(bus->dev, "Bank switch failed: %d\n", ret);
1356	1654	return ret;
1357	1655	}
1358	1656
..	..	@@ -1369,47 +1667,78 @@
1369	1667	*/
1370	1668	int sdw_enable_stream(struct sdw_stream_runtime *stream)
1371	1669	{
1372		- int ret = 0;
	1670	+ int ret;
1373	1671
1374	1672	if (!stream) {
1375		- pr_err("SoundWire: Handle not found for stream");
	1673	+ pr_err("SoundWire: Handle not found for stream\n");
1376	1674	return -EINVAL;
1377	1675	}
1378	1676
1379		- mutex_lock(&stream->m_rt->bus->bus_lock);
	1677	+ sdw_acquire_bus_lock(stream);
	1678	+
	1679	+ if (stream->state != SDW_STREAM_PREPARED &&
	1680	+ stream->state != SDW_STREAM_DISABLED) {
	1681	+ pr_err("%s: %s: inconsistent state state %d\n",
	1682	+ __func__, stream->name, stream->state);
	1683	+ ret = -EINVAL;
	1684	+ goto state_err;
	1685	+ }
1380	1686
1381	1687	ret = _sdw_enable_stream(stream);
1382		- if (ret < 0)
1383		- pr_err("Enable for stream:%s failed: %d", stream->name, ret);
1384	1688
1385		- mutex_unlock(&stream->m_rt->bus->bus_lock);
	1689	+state_err:
	1690	+ sdw_release_bus_lock(stream);
1386	1691	return ret;
1387	1692	}
1388	1693	EXPORT_SYMBOL(sdw_enable_stream);
1389	1694
1390	1695	static int _sdw_disable_stream(struct sdw_stream_runtime *stream)
1391	1696	{
1392		- struct sdw_master_runtime *m_rt = stream->m_rt;
1393		- struct sdw_bus *bus = m_rt->bus;
	1697	+ struct sdw_master_runtime *m_rt;
1394	1698	int ret;
1395	1699
1396		- /* Disable port(s) */
1397		- ret = sdw_enable_disable_ports(m_rt, false);
1398		- if (ret < 0) {
1399		- dev_err(bus->dev, "Disable port(s) failed: %d", ret);
1400		- return ret;
1401		- }
	1700	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1701	+ struct sdw_bus *bus = m_rt->bus;
1402	1702
	1703	+ /* Disable port(s) */
	1704	+ ret = sdw_enable_disable_ports(m_rt, false);
	1705	+ if (ret < 0) {
	1706	+ dev_err(bus->dev, "Disable port(s) failed: %d\n", ret);
	1707	+ return ret;
	1708	+ }
	1709	+ }
1403	1710	stream->state = SDW_STREAM_DISABLED;
1404	1711
1405		- /* Program params */
1406		- ret = sdw_program_params(bus);
	1712	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1713	+ struct sdw_bus *bus = m_rt->bus;
	1714	+
	1715	+ /* Program params */
	1716	+ ret = sdw_program_params(bus, false);
	1717	+ if (ret < 0) {
	1718	+ dev_err(bus->dev, "Program params failed: %d\n", ret);
	1719	+ return ret;
	1720	+ }
	1721	+ }
	1722	+
	1723	+ ret = do_bank_switch(stream);
1407	1724	if (ret < 0) {
1408		- dev_err(bus->dev, "Program params failed: %d", ret);
	1725	+ pr_err("Bank switch failed: %d\n", ret);
1409	1726	return ret;
1410	1727	}
1411	1728
1412		- return do_bank_switch(stream);
	1729	+ /* make sure alternate bank (previous current) is also disabled */
	1730	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1731	+ struct sdw_bus *bus = m_rt->bus;
	1732	+
	1733	+ /* Disable port(s) */
	1734	+ ret = sdw_enable_disable_ports(m_rt, false);
	1735	+ if (ret < 0) {
	1736	+ dev_err(bus->dev, "Disable port(s) failed: %d\n", ret);
	1737	+ return ret;
	1738	+ }
	1739	+ }
	1740	+
	1741	+ return 0;
1413	1742	}
1414	1743
1415	1744	/**
..	..	@@ -1421,50 +1750,69 @@
1421	1750	*/
1422	1751	int sdw_disable_stream(struct sdw_stream_runtime *stream)
1423	1752	{
1424		- int ret = 0;
	1753	+ int ret;
1425	1754
1426	1755	if (!stream) {
1427		- pr_err("SoundWire: Handle not found for stream");
	1756	+ pr_err("SoundWire: Handle not found for stream\n");
1428	1757	return -EINVAL;
1429	1758	}
1430	1759
1431		- mutex_lock(&stream->m_rt->bus->bus_lock);
	1760	+ sdw_acquire_bus_lock(stream);
	1761	+
	1762	+ if (stream->state != SDW_STREAM_ENABLED) {
	1763	+ pr_err("%s: %s: inconsistent state state %d\n",
	1764	+ __func__, stream->name, stream->state);
	1765	+ ret = -EINVAL;
	1766	+ goto state_err;
	1767	+ }
1432	1768
1433	1769	ret = _sdw_disable_stream(stream);
1434		- if (ret < 0)
1435		- pr_err("Disable for stream:%s failed: %d", stream->name, ret);
1436	1770
1437		- mutex_unlock(&stream->m_rt->bus->bus_lock);
	1771	+state_err:
	1772	+ sdw_release_bus_lock(stream);
1438	1773	return ret;
1439	1774	}
1440	1775	EXPORT_SYMBOL(sdw_disable_stream);
1441	1776
1442	1777	static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream)
1443	1778	{
1444		- struct sdw_master_runtime *m_rt = stream->m_rt;
1445		- struct sdw_bus *bus = m_rt->bus;
	1779	+ struct sdw_master_runtime *m_rt;
	1780	+ struct sdw_bus *bus;
1446	1781	int ret = 0;
1447	1782
1448		- /* De-prepare port(s) */
1449		- ret = sdw_prep_deprep_ports(m_rt, false);
1450		- if (ret < 0) {
1451		- dev_err(bus->dev, "De-prepare port(s) failed: %d", ret);
1452		- return ret;
	1783	+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
	1784	+ bus = m_rt->bus;
	1785	+ /* De-prepare port(s) */
	1786	+ ret = sdw_prep_deprep_ports(m_rt, false);
	1787	+ if (ret < 0) {
	1788	+ dev_err(bus->dev,
	1789	+ "De-prepare port(s) failed: %d\n", ret);
	1790	+ return ret;
	1791	+ }
	1792	+
	1793	+ /* TODO: Update this during Device-Device support */
	1794	+ bus->params.bandwidth -= m_rt->stream->params.rate *
	1795	+ m_rt->ch_count * m_rt->stream->params.bps;
	1796	+
	1797	+ /* Compute params */
	1798	+ if (bus->compute_params) {
	1799	+ ret = bus->compute_params(bus);
	1800	+ if (ret < 0) {
	1801	+ dev_err(bus->dev, "Compute params failed: %d",
	1802	+ ret);
	1803	+ return ret;
	1804	+ }
	1805	+ }
	1806	+
	1807	+ /* Program params */
	1808	+ ret = sdw_program_params(bus, false);
	1809	+ if (ret < 0) {
	1810	+ dev_err(bus->dev, "Program params failed: %d\n", ret);
	1811	+ return ret;
	1812	+ }
1453	1813	}
1454	1814
1455	1815	stream->state = SDW_STREAM_DEPREPARED;
1456		-
1457		- /* TODO: Update this during Device-Device support */
1458		- bus->params.bandwidth -= m_rt->stream->params.rate *
1459		- m_rt->ch_count * m_rt->stream->params.bps;
1460		-
1461		- /* Program params */
1462		- ret = sdw_program_params(bus);
1463		- if (ret < 0) {
1464		- dev_err(bus->dev, "Program params failed: %d", ret);
1465		- return ret;
1466		- }
1467		-
1468	1816	return do_bank_switch(stream);
1469	1817	}
1470	1818
..	..	@@ -1477,20 +1825,124 @@
1477	1825	*/
1478	1826	int sdw_deprepare_stream(struct sdw_stream_runtime *stream)
1479	1827	{
1480		- int ret = 0;
	1828	+ int ret;
1481	1829
1482	1830	if (!stream) {
1483		- pr_err("SoundWire: Handle not found for stream");
	1831	+ pr_err("SoundWire: Handle not found for stream\n");
1484	1832	return -EINVAL;
1485	1833	}
1486	1834
1487		- mutex_lock(&stream->m_rt->bus->bus_lock);
	1835	+ sdw_acquire_bus_lock(stream);
	1836	+
	1837	+ if (stream->state != SDW_STREAM_PREPARED &&
	1838	+ stream->state != SDW_STREAM_DISABLED) {
	1839	+ pr_err("%s: %s: inconsistent state state %d\n",
	1840	+ __func__, stream->name, stream->state);
	1841	+ ret = -EINVAL;
	1842	+ goto state_err;
	1843	+ }
1488	1844
1489	1845	ret = _sdw_deprepare_stream(stream);
1490		- if (ret < 0)
1491		- pr_err("De-prepare for stream:%d failed: %d", ret, ret);
1492	1846
1493		- mutex_unlock(&stream->m_rt->bus->bus_lock);
	1847	+state_err:
	1848	+ sdw_release_bus_lock(stream);
1494	1849	return ret;
1495	1850	}
1496	1851	EXPORT_SYMBOL(sdw_deprepare_stream);
	1852	+
	1853	+static int set_stream(struct snd_pcm_substream *substream,
	1854	+ struct sdw_stream_runtime *sdw_stream)
	1855	+{
	1856	+ struct snd_soc_pcm_runtime *rtd = substream->private_data;
	1857	+ struct snd_soc_dai *dai;
	1858	+ int ret = 0;
	1859	+ int i;
	1860	+
	1861	+ /* Set stream pointer on all DAIs */
	1862	+ for_each_rtd_dais(rtd, i, dai) {
	1863	+ ret = snd_soc_dai_set_sdw_stream(dai, sdw_stream, substream->stream);
	1864	+ if (ret < 0) {
	1865	+ dev_err(rtd->dev, "failed to set stream pointer on dai %s", dai->name);
	1866	+ break;
	1867	+ }
	1868	+ }
	1869	+
	1870	+ return ret;
	1871	+}
	1872	+
	1873	+/**
	1874	+ * sdw_startup_stream() - Startup SoundWire stream
	1875	+ *
	1876	+ * @sdw_substream: Soundwire stream
	1877	+ *
	1878	+ * Documentation/driver-api/soundwire/stream.rst explains this API in detail
	1879	+ */
	1880	+int sdw_startup_stream(void *sdw_substream)
	1881	+{
	1882	+ struct snd_pcm_substream *substream = sdw_substream;
	1883	+ struct snd_soc_pcm_runtime *rtd = substream->private_data;
	1884	+ struct sdw_stream_runtime *sdw_stream;
	1885	+ char *name;
	1886	+ int ret;
	1887	+
	1888	+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	1889	+ name = kasprintf(GFP_KERNEL, "%s-Playback", substream->name);
	1890	+ else
	1891	+ name = kasprintf(GFP_KERNEL, "%s-Capture", substream->name);
	1892	+
	1893	+ if (!name)
	1894	+ return -ENOMEM;
	1895	+
	1896	+ sdw_stream = sdw_alloc_stream(name);
	1897	+ if (!sdw_stream) {
	1898	+ dev_err(rtd->dev, "alloc stream failed for substream DAI %s", substream->name);
	1899	+ ret = -ENOMEM;
	1900	+ goto error;
	1901	+ }
	1902	+
	1903	+ ret = set_stream(substream, sdw_stream);
	1904	+ if (ret < 0)
	1905	+ goto release_stream;
	1906	+ return 0;
	1907	+
	1908	+release_stream:
	1909	+ sdw_release_stream(sdw_stream);
	1910	+ set_stream(substream, NULL);
	1911	+error:
	1912	+ kfree(name);
	1913	+ return ret;
	1914	+}
	1915	+EXPORT_SYMBOL(sdw_startup_stream);
	1916	+
	1917	+/**
	1918	+ * sdw_shutdown_stream() - Shutdown SoundWire stream
	1919	+ *
	1920	+ * @sdw_substream: Soundwire stream
	1921	+ *
	1922	+ * Documentation/driver-api/soundwire/stream.rst explains this API in detail
	1923	+ */
	1924	+void sdw_shutdown_stream(void *sdw_substream)
	1925	+{
	1926	+ struct snd_pcm_substream *substream = sdw_substream;
	1927	+ struct snd_soc_pcm_runtime *rtd = substream->private_data;
	1928	+ struct sdw_stream_runtime *sdw_stream;
	1929	+ struct snd_soc_dai *dai;
	1930	+
	1931	+ /* Find stream from first CPU DAI */
	1932	+ dai = asoc_rtd_to_cpu(rtd, 0);
	1933	+
	1934	+ sdw_stream = snd_soc_dai_get_sdw_stream(dai, substream->stream);
	1935	+
	1936	+ if (IS_ERR(sdw_stream)) {
	1937	+ dev_err(rtd->dev, "no stream found for DAI %s", dai->name);
	1938	+ return;
	1939	+ }
	1940	+
	1941	+ /* release memory */
	1942	+ kfree(sdw_stream->name);
	1943	+ sdw_release_stream(sdw_stream);
	1944	+
	1945	+ /* clear DAI data */
	1946	+ set_stream(substream, NULL);
	1947	+}
	1948	+EXPORT_SYMBOL(sdw_shutdown_stream);