~ljy/RK356X_SDK_RELEASE.git

..	..	@@ -2,31 +2,68 @@
2	2	// Copyright(c) 2015-17 Intel Corporation.
3	3
4	4	#include <linux/acpi.h>
	5	+#include <linux/delay.h>
5	6	#include <linux/mod_devicetable.h>
6	7	#include <linux/pm_runtime.h>
7	8	#include <linux/soundwire/sdw_registers.h>
8	9	#include <linux/soundwire/sdw.h>
9	10	#include "bus.h"
	11	+#include "sysfs_local.h"
	12	+
	13	+static DEFINE_IDA(sdw_ida);
	14	+
	15	+static int sdw_get_id(struct sdw_bus *bus)
	16	+{
	17	+ int rc = ida_alloc(&sdw_ida, GFP_KERNEL);
	18	+
	19	+ if (rc < 0)
	20	+ return rc;
	21	+
	22	+ bus->id = rc;
	23	+ return 0;
	24	+}
10	25
11	26	/**
12		- * sdw_add_bus_master() - add a bus Master instance
	27	+ * sdw_bus_master_add() - add a bus Master instance
13	28	* @bus: bus instance
	29	+ * @parent: parent device
	30	+ * @fwnode: firmware node handle
14	31	*
15	32	* Initializes the bus instance, read properties and create child
16	33	* devices.
17	34	*/
18		-int sdw_add_bus_master(struct sdw_bus *bus)
	35	+int sdw_bus_master_add(struct sdw_bus bus, struct device parent,
	36	+ struct fwnode_handle *fwnode)
19	37	{
20	38	struct sdw_master_prop *prop = NULL;
21	39	int ret;
22	40
23		- if (!bus->dev) {
24		- pr_err("SoundWire bus has no device");
	41	+ if (!parent) {
	42	+ pr_err("SoundWire parent device is not set\n");
25	43	return -ENODEV;
26	44	}
27	45
	46	+ ret = sdw_get_id(bus);
	47	+ if (ret) {
	48	+ dev_err(parent, "Failed to get bus id\n");
	49	+ return ret;
	50	+ }
	51	+
	52	+ ret = sdw_master_device_add(bus, parent, fwnode);
	53	+ if (ret) {
	54	+ dev_err(parent, "Failed to add master device at link %d\n",
	55	+ bus->link_id);
	56	+ return ret;
	57	+ }
	58	+
28	59	if (!bus->ops) {
29		- dev_err(bus->dev, "SoundWire Bus ops are not set");
	60	+ dev_err(bus->dev, "SoundWire Bus ops are not set\n");
	61	+ return -EINVAL;
	62	+ }
	63	+
	64	+ if (!bus->compute_params) {
	65	+ dev_err(bus->dev,
	66	+ "Bandwidth allocation not configured, compute_params no set\n");
30	67	return -EINVAL;
31	68	}
32	69
..	..	@@ -35,16 +72,24 @@
35	72	INIT_LIST_HEAD(&bus->slaves);
36	73	INIT_LIST_HEAD(&bus->m_rt_list);
37	74
	75	+ /*
	76	+ * Initialize multi_link flag
	77	+ * TODO: populate this flag by reading property from FW node
	78	+ */
	79	+ bus->multi_link = false;
38	80	if (bus->ops->read_prop) {
39	81	ret = bus->ops->read_prop(bus);
40	82	if (ret < 0) {
41		- dev_err(bus->dev, "Bus read properties failed:%d", ret);
	83	+ dev_err(bus->dev,
	84	+ "Bus read properties failed:%d\n", ret);
42	85	return ret;
43	86	}
44	87	}
45	88
	89	+ sdw_bus_debugfs_init(bus);
	90	+
46	91	/*
47		- * Device numbers in SoundWire are 0 thru 15. Enumeration device
	92	+ * Device numbers in SoundWire are 0 through 15. Enumeration device
48	93	* number (0), Broadcast device number (15), Group numbers (12 and
49	94	* 13) and Master device number (14) are not used for assignment so
50	95	* mask these and other higher bits.
..	..	@@ -71,6 +116,8 @@
71	116	*/
72	117	if (IS_ENABLED(CONFIG_ACPI) && ACPI_HANDLE(bus->dev))
73	118	ret = sdw_acpi_find_slaves(bus);
	119	+ else if (IS_ENABLED(CONFIG_OF) && bus->dev->of_node)
	120	+ ret = sdw_of_find_slaves(bus);
74	121	else
75	122	ret = -ENOTSUPP; /* No ACPI/DT so error out */
76	123
..	..	@@ -81,7 +128,7 @@
81	128
82	129	/*
83	130	* Initialize clock values based on Master properties. The max
84		- * frequency is read from max_freq property. Current assumption
	131	+ * frequency is read from max_clk_freq property. Current assumption
85	132	* is that the bus will start at highest clock frequency when
86	133	* powered on.
87	134	*
..	..	@@ -89,19 +136,23 @@
89	136	* to start with bank 0 (Table 40 of Spec)
90	137	*/
91	138	prop = &bus->prop;
92		- bus->params.max_dr_freq = prop->max_freq * SDW_DOUBLE_RATE_FACTOR;
	139	+ bus->params.max_dr_freq = prop->max_clk_freq * SDW_DOUBLE_RATE_FACTOR;
93	140	bus->params.curr_dr_freq = bus->params.max_dr_freq;
94	141	bus->params.curr_bank = SDW_BANK0;
95	142	bus->params.next_bank = SDW_BANK1;
96	143
97	144	return 0;
98	145	}
99		-EXPORT_SYMBOL(sdw_add_bus_master);
	146	+EXPORT_SYMBOL(sdw_bus_master_add);
100	147
101	148	static int sdw_delete_slave(struct device dev, void data)
102	149	{
103	150	struct sdw_slave *slave = dev_to_sdw_dev(dev);
104	151	struct sdw_bus *bus = slave->bus;
	152	+
	153	+ pm_runtime_disable(dev);
	154	+
	155	+ sdw_slave_debugfs_exit(slave);
105	156
106	157	mutex_lock(&bus->bus_lock);
107	158
..	..	@@ -116,16 +167,20 @@
116	167	}
117	168
118	169	/**
119		- * sdw_delete_bus_master() - delete the bus master instance
	170	+ * sdw_bus_master_delete() - delete the bus master instance
120	171	* @bus: bus to be deleted
121	172	*
122	173	* Remove the instance, delete the child devices.
123	174	*/
124		-void sdw_delete_bus_master(struct sdw_bus *bus)
	175	+void sdw_bus_master_delete(struct sdw_bus *bus)
125	176	{
126	177	device_for_each_child(bus->dev, NULL, sdw_delete_slave);
	178	+ sdw_master_device_del(bus);
	179	+
	180	+ sdw_bus_debugfs_exit(bus);
	181	+ ida_free(&sdw_ida, bus->id);
127	182	}
128		-EXPORT_SYMBOL(sdw_delete_bus_master);
	183	+EXPORT_SYMBOL(sdw_bus_master_delete);
129	184
130	185	/*
131	186	* SDW IO Calls
..	..	@@ -167,7 +222,8 @@
167	222	}
168	223
169	224	static inline int do_transfer_defer(struct sdw_bus *bus,
170		- struct sdw_msg msg, struct sdw_defer defer)
	225	+ struct sdw_msg *msg,
	226	+ struct sdw_defer *defer)
171	227	{
172	228	int retry = bus->prop.err_threshold;
173	229	enum sdw_command_response resp;
..	..	@@ -205,6 +261,21 @@
205	261	return ret;
206	262	}
207	263
	264	+static int sdw_transfer_unlocked(struct sdw_bus bus, struct sdw_msg msg)
	265	+{
	266	+ int ret;
	267	+
	268	+ ret = do_transfer(bus, msg);
	269	+ if (ret != 0 && ret != -ENODATA)
	270	+ dev_err(bus->dev, "trf on Slave %d failed:%d\n",
	271	+ msg->dev_num, ret);
	272	+
	273	+ if (msg->page)
	274	+ sdw_reset_page(bus, msg->dev_num);
	275	+
	276	+ return ret;
	277	+}
	278	+
208	279	/**
209	280	* sdw_transfer() - Synchronous transfer message to a SDW Slave device
210	281	* @bus: SDW bus
..	..	@@ -216,13 +287,7 @@
216	287
217	288	mutex_lock(&bus->msg_lock);
218	289
219		- ret = do_transfer(bus, msg);
220		- if (ret != 0 && ret != -ENODATA)
221		- dev_err(bus->dev, "trf on Slave %d failed:%d\n",
222		- msg->dev_num, ret);
223		-
224		- if (msg->page)
225		- sdw_reset_page(bus, msg->dev_num);
	290	+ ret = sdw_transfer_unlocked(bus, msg);
226	291
227	292	mutex_unlock(&bus->msg_lock);
228	293
..	..	@@ -238,7 +303,7 @@
238	303	* Caller needs to hold the msg_lock lock while calling this
239	304	*/
240	305	int sdw_transfer_defer(struct sdw_bus bus, struct sdw_msg msg,
241		- struct sdw_defer *defer)
	306	+ struct sdw_defer *defer)
242	307	{
243	308	int ret;
244	309
..	..	@@ -248,7 +313,7 @@
248	313	ret = do_transfer_defer(bus, msg, defer);
249	314	if (ret != 0 && ret != -ENODATA)
250	315	dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n",
251		- msg->dev_num, ret);
	316	+ msg->dev_num, ret);
252	317
253	318	if (msg->page)
254	319	sdw_reset_page(bus, msg->dev_num);
..	..	@@ -256,9 +321,8 @@
256	321	return ret;
257	322	}
258	323
259		-
260	324	int sdw_fill_msg(struct sdw_msg msg, struct sdw_slave slave,
261		- u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf)
	325	+ u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf)
262	326	{
263	327	memset(msg, 0, sizeof(*msg));
264	328	msg->addr = addr; /* addr is 16 bit and truncated here */
..	..	@@ -266,12 +330,11 @@
266	330	msg->dev_num = dev_num;
267	331	msg->flags = flags;
268	332	msg->buf = buf;
269		- msg->ssp_sync = false;
270		- msg->page = false;
271	333
272		- if (addr < SDW_REG_NO_PAGE) { /* no paging area */
	334	+ if (addr < SDW_REG_NO_PAGE) /* no paging area */
273	335	return 0;
274		- } else if (addr >= SDW_REG_MAX) { /* illegal addr */
	336	+
	337	+ if (addr >= SDW_REG_MAX) { /* illegal addr */
275	338	pr_err("SDW: Invalid address %x passed\n", addr);
276	339	return -EINVAL;
277	340	}
..	..	@@ -279,7 +342,7 @@
279	342	if (addr < SDW_REG_OPTIONAL_PAGE) { /* 32k but no page */
280	343	if (slave && !slave->prop.paging_support)
281	344	return 0;
282		- /* no need for else as that will fall thru to paging */
	345	+ /* no need for else as that will fall-through to paging */
283	346	}
284	347
285	348	/* paging mandatory */
..	..	@@ -291,18 +354,152 @@
291	354	if (!slave) {
292	355	pr_err("SDW: No slave for paging addr\n");
293	356	return -EINVAL;
294		- } else if (!slave->prop.paging_support) {
	357	+ }
	358	+
	359	+ if (!slave->prop.paging_support) {
295	360	dev_err(&slave->dev,
296		- "address %x needs paging but no support", addr);
	361	+ "address %x needs paging but no support\n", addr);
297	362	return -EINVAL;
298	363	}
299	364
300		- msg->addr_page1 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE1_MASK));
301		- msg->addr_page2 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE2_MASK));
	365	+ msg->addr_page1 = FIELD_GET(SDW_SCP_ADDRPAGE1_MASK, addr);
	366	+ msg->addr_page2 = FIELD_GET(SDW_SCP_ADDRPAGE2_MASK, addr);
302	367	msg->addr \|= BIT(15);
303	368	msg->page = true;
304	369
305	370	return 0;
	371	+}
	372	+
	373	+/*
	374	+ * Read/Write IO functions.
	375	+ * no_pm versions can only be called by the bus, e.g. while enumerating or
	376	+ * handling suspend-resume sequences.
	377	+ * all clients need to use the pm versions
	378	+ */
	379	+
	380	+static int
	381	+sdw_nread_no_pm(struct sdw_slave slave, u32 addr, size_t count, u8 val)
	382	+{
	383	+ struct sdw_msg msg;
	384	+ int ret;
	385	+
	386	+ ret = sdw_fill_msg(&msg, slave, addr, count,
	387	+ slave->dev_num, SDW_MSG_FLAG_READ, val);
	388	+ if (ret < 0)
	389	+ return ret;
	390	+
	391	+ return sdw_transfer(slave->bus, &msg);
	392	+}
	393	+
	394	+static int
	395	+sdw_nwrite_no_pm(struct sdw_slave slave, u32 addr, size_t count, u8 val)
	396	+{
	397	+ struct sdw_msg msg;
	398	+ int ret;
	399	+
	400	+ ret = sdw_fill_msg(&msg, slave, addr, count,
	401	+ slave->dev_num, SDW_MSG_FLAG_WRITE, val);
	402	+ if (ret < 0)
	403	+ return ret;
	404	+
	405	+ return sdw_transfer(slave->bus, &msg);
	406	+}
	407	+
	408	+int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
	409	+{
	410	+ return sdw_nwrite_no_pm(slave, addr, 1, &value);
	411	+}
	412	+EXPORT_SYMBOL(sdw_write_no_pm);
	413	+
	414	+static int
	415	+sdw_bread_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr)
	416	+{
	417	+ struct sdw_msg msg;
	418	+ u8 buf;
	419	+ int ret;
	420	+
	421	+ ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
	422	+ SDW_MSG_FLAG_READ, &buf);
	423	+ if (ret)
	424	+ return ret;
	425	+
	426	+ ret = sdw_transfer(bus, &msg);
	427	+ if (ret < 0)
	428	+ return ret;
	429	+
	430	+ return buf;
	431	+}
	432	+
	433	+static int
	434	+sdw_bwrite_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value)
	435	+{
	436	+ struct sdw_msg msg;
	437	+ int ret;
	438	+
	439	+ ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
	440	+ SDW_MSG_FLAG_WRITE, &value);
	441	+ if (ret)
	442	+ return ret;
	443	+
	444	+ return sdw_transfer(bus, &msg);
	445	+}
	446	+
	447	+int sdw_bread_no_pm_unlocked(struct sdw_bus *bus, u16 dev_num, u32 addr)
	448	+{
	449	+ struct sdw_msg msg;
	450	+ u8 buf;
	451	+ int ret;
	452	+
	453	+ ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
	454	+ SDW_MSG_FLAG_READ, &buf);
	455	+ if (ret)
	456	+ return ret;
	457	+
	458	+ ret = sdw_transfer_unlocked(bus, &msg);
	459	+ if (ret < 0)
	460	+ return ret;
	461	+
	462	+ return buf;
	463	+}
	464	+EXPORT_SYMBOL(sdw_bread_no_pm_unlocked);
	465	+
	466	+int sdw_bwrite_no_pm_unlocked(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value)
	467	+{
	468	+ struct sdw_msg msg;
	469	+ int ret;
	470	+
	471	+ ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num,
	472	+ SDW_MSG_FLAG_WRITE, &value);
	473	+ if (ret)
	474	+ return ret;
	475	+
	476	+ return sdw_transfer_unlocked(bus, &msg);
	477	+}
	478	+EXPORT_SYMBOL(sdw_bwrite_no_pm_unlocked);
	479	+
	480	+int sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
	481	+{
	482	+ u8 buf;
	483	+ int ret;
	484	+
	485	+ ret = sdw_nread_no_pm(slave, addr, 1, &buf);
	486	+ if (ret < 0)
	487	+ return ret;
	488	+ else
	489	+ return buf;
	490	+}
	491	+EXPORT_SYMBOL(sdw_read_no_pm);
	492	+
	493	+static int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
	494	+{
	495	+ int tmp;
	496	+
	497	+ tmp = sdw_read_no_pm(slave, addr);
	498	+ if (tmp < 0)
	499	+ return tmp;
	500	+
	501	+ tmp = (tmp & ~mask) \| val;
	502	+ return sdw_write_no_pm(slave, addr, tmp);
306	503	}
307	504
308	505	/**
..	..	@@ -314,20 +511,18 @@
314	511	*/
315	512	int sdw_nread(struct sdw_slave slave, u32 addr, size_t count, u8 val)
316	513	{
317		- struct sdw_msg msg;
318	514	int ret;
319	515
320		- ret = sdw_fill_msg(&msg, slave, addr, count,
321		- slave->dev_num, SDW_MSG_FLAG_READ, val);
322		- if (ret < 0)
	516	+ ret = pm_runtime_get_sync(&slave->dev);
	517	+ if (ret < 0 && ret != -EACCES) {
	518	+ pm_runtime_put_noidle(&slave->dev);
323	519	return ret;
	520	+ }
324	521
325		- ret = pm_runtime_get_sync(slave->bus->dev);
326		- if (ret < 0)
327		- return ret;
	522	+ ret = sdw_nread_no_pm(slave, addr, count, val);
328	523
329		- ret = sdw_transfer(slave->bus, &msg);
330		- pm_runtime_put(slave->bus->dev);
	524	+ pm_runtime_mark_last_busy(&slave->dev);
	525	+ pm_runtime_put(&slave->dev);
331	526
332	527	return ret;
333	528	}
..	..	@@ -342,20 +537,18 @@
342	537	*/
343	538	int sdw_nwrite(struct sdw_slave slave, u32 addr, size_t count, u8 val)
344	539	{
345		- struct sdw_msg msg;
346	540	int ret;
347	541
348		- ret = sdw_fill_msg(&msg, slave, addr, count,
349		- slave->dev_num, SDW_MSG_FLAG_WRITE, val);
350		- if (ret < 0)
	542	+ ret = pm_runtime_get_sync(&slave->dev);
	543	+ if (ret < 0 && ret != -EACCES) {
	544	+ pm_runtime_put_noidle(&slave->dev);
351	545	return ret;
	546	+ }
352	547
353		- ret = pm_runtime_get_sync(slave->bus->dev);
354		- if (ret < 0)
355		- return ret;
	548	+ ret = sdw_nwrite_no_pm(slave, addr, count, val);
356	549
357		- ret = sdw_transfer(slave->bus, &msg);
358		- pm_runtime_put(slave->bus->dev);
	550	+ pm_runtime_mark_last_busy(&slave->dev);
	551	+ pm_runtime_put(&slave->dev);
359	552
360	553	return ret;
361	554	}
..	..	@@ -374,8 +567,8 @@
374	567	ret = sdw_nread(slave, addr, 1, &buf);
375	568	if (ret < 0)
376	569	return ret;
377		- else
378		- return buf;
	570	+
	571	+ return buf;
379	572	}
380	573	EXPORT_SYMBOL(sdw_read);
381	574
..	..	@@ -388,7 +581,6 @@
388	581	int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
389	582	{
390	583	return sdw_nwrite(slave, addr, 1, &value);
391		-
392	584	}
393	585	EXPORT_SYMBOL(sdw_write);
394	586
..	..	@@ -411,11 +603,11 @@
411	603
412	604	static int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
413	605	{
414		-
415		- if ((slave->id.unique_id != id.unique_id) \|\|
416		- (slave->id.mfg_id != id.mfg_id) \|\|
417		- (slave->id.part_id != id.part_id) \|\|
418		- (slave->id.class_id != id.class_id))
	606	+ if (slave->id.mfg_id != id.mfg_id \|\|
	607	+ slave->id.part_id != id.part_id \|\|
	608	+ slave->id.class_id != id.class_id \|\|
	609	+ (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID &&
	610	+ slave->id.unique_id != id.unique_id))
419	611	return -ENODEV;
420	612
421	613	return 0;
..	..	@@ -445,67 +637,64 @@
445	637	static int sdw_assign_device_num(struct sdw_slave *slave)
446	638	{
447	639	int ret, dev_num;
	640	+ bool new_device = false;
448	641
449	642	/* check first if device number is assigned, if so reuse that */
450	643	if (!slave->dev_num) {
451		- mutex_lock(&slave->bus->bus_lock);
452		- dev_num = sdw_get_device_num(slave);
453		- mutex_unlock(&slave->bus->bus_lock);
454		- if (dev_num < 0) {
455		- dev_err(slave->bus->dev, "Get dev_num failed: %d",
456		- dev_num);
457		- return dev_num;
	644	+ if (!slave->dev_num_sticky) {
	645	+ mutex_lock(&slave->bus->bus_lock);
	646	+ dev_num = sdw_get_device_num(slave);
	647	+ mutex_unlock(&slave->bus->bus_lock);
	648	+ if (dev_num < 0) {
	649	+ dev_err(slave->bus->dev, "Get dev_num failed: %d\n",
	650	+ dev_num);
	651	+ return dev_num;
	652	+ }
	653	+ slave->dev_num = dev_num;
	654	+ slave->dev_num_sticky = dev_num;
	655	+ new_device = true;
	656	+ } else {
	657	+ slave->dev_num = slave->dev_num_sticky;
458	658	}
459		- } else {
460		- dev_info(slave->bus->dev,
461		- "Slave already registered dev_num:%d",
462		- slave->dev_num);
463		-
464		- /* Clear the slave->dev_num to transfer message on device 0 */
465		- dev_num = slave->dev_num;
466		- slave->dev_num = 0;
467		-
468	659	}
469	660
470		- ret = sdw_write(slave, SDW_SCP_DEVNUMBER, dev_num);
	661	+ if (!new_device)
	662	+ dev_dbg(slave->bus->dev,
	663	+ "Slave already registered, reusing dev_num:%d\n",
	664	+ slave->dev_num);
	665	+
	666	+ /* Clear the slave->dev_num to transfer message on device 0 */
	667	+ dev_num = slave->dev_num;
	668	+ slave->dev_num = 0;
	669	+
	670	+ ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, dev_num);
471	671	if (ret < 0) {
472		- dev_err(&slave->dev, "Program device_num failed: %d", ret);
	672	+ dev_err(&slave->dev, "Program device_num %d failed: %d\n",
	673	+ dev_num, ret);
473	674	return ret;
474	675	}
475	676
476	677	/* After xfer of msg, restore dev_num */
477		- slave->dev_num = dev_num;
	678	+ slave->dev_num = slave->dev_num_sticky;
478	679
479	680	return 0;
480	681	}
481	682
482	683	void sdw_extract_slave_id(struct sdw_bus *bus,
483		- u64 addr, struct sdw_slave_id *id)
	684	+ u64 addr, struct sdw_slave_id *id)
484	685	{
485		- dev_dbg(bus->dev, "SDW Slave Addr: %llx", addr);
	686	+ dev_dbg(bus->dev, "SDW Slave Addr: %llx\n", addr);
486	687
487		- /*
488		- * Spec definition
489		- * Register Bit Contents
490		- * DevId_0 [7:4] 47:44 sdw_version
491		- * DevId_0 [3:0] 43:40 unique_id
492		- * DevId_1 39:32 mfg_id [15:8]
493		- * DevId_2 31:24 mfg_id [7:0]
494		- * DevId_3 23:16 part_id [15:8]
495		- * DevId_4 15:08 part_id [7:0]
496		- * DevId_5 07:00 class_id
497		- */
498		- id->sdw_version = (addr >> 44) & GENMASK(3, 0);
499		- id->unique_id = (addr >> 40) & GENMASK(3, 0);
500		- id->mfg_id = (addr >> 24) & GENMASK(15, 0);
501		- id->part_id = (addr >> 8) & GENMASK(15, 0);
502		- id->class_id = addr & GENMASK(7, 0);
	688	+ id->sdw_version = SDW_VERSION(addr);
	689	+ id->unique_id = SDW_UNIQUE_ID(addr);
	690	+ id->mfg_id = SDW_MFG_ID(addr);
	691	+ id->part_id = SDW_PART_ID(addr);
	692	+ id->class_id = SDW_CLASS_ID(addr);
503	693
504	694	dev_dbg(bus->dev,
505		- "SDW Slave class_id %x, part_id %x, mfg_id %x, unique_id %x, version %x",
	695	+ "SDW Slave class_id %x, part_id %x, mfg_id %x, unique_id %x, version %x\n",
506	696	id->class_id, id->part_id, id->mfg_id,
507	697	id->unique_id, id->sdw_version);
508		-
509	698	}
510	699
511	700	static int sdw_program_device_num(struct sdw_bus *bus)
..	..	@@ -520,13 +709,14 @@
520	709
521	710	/* No Slave, so use raw xfer api */
522	711	ret = sdw_fill_msg(&msg, NULL, SDW_SCP_DEVID_0,
523		- SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf);
	712	+ SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf);
524	713	if (ret < 0)
525	714	return ret;
526	715
527	716	do {
528	717	ret = sdw_transfer(bus, &msg);
529	718	if (ret == -ENODATA) { /* end of device id reads */
	719	+ dev_dbg(bus->dev, "No more devices to enumerate\n");
530	720	ret = 0;
531	721	break;
532	722	}
..	..	@@ -560,7 +750,7 @@
560	750	ret = sdw_assign_device_num(slave);
561	751	if (ret) {
562	752	dev_err(slave->bus->dev,
563		- "Assign dev_num failed:%d",
	753	+ "Assign dev_num failed:%d\n",
564	754	ret);
565	755	return ret;
566	756	}
..	..	@@ -569,9 +759,18 @@
569	759	}
570	760	}
571	761
572		- if (found == false) {
	762	+ if (!found) {
573	763	/* TODO: Park this device in Group 13 */
574		- dev_err(bus->dev, "Slave Entry not found");
	764	+
	765	+ /*
	766	+ * add Slave device even if there is no platform
	767	+ * firmware description. There will be no driver probe
	768	+ * but the user/integration will be able to see the
	769	+ * device, enumeration status and device number in sysfs
	770	+ */
	771	+ sdw_slave_add(bus, &id, NULL);
	772	+
	773	+ dev_err(bus->dev, "Slave Entry not found\n");
575	774	}
576	775
577	776	count++;
..	..	@@ -588,19 +787,346 @@
588	787	}
589	788
590	789	static void sdw_modify_slave_status(struct sdw_slave *slave,
591		- enum sdw_slave_status status)
	790	+ enum sdw_slave_status status)
592	791	{
593	792	mutex_lock(&slave->bus->bus_lock);
	793	+
	794	+ dev_vdbg(&slave->dev,
	795	+ "%s: changing status slave %d status %d new status %d\n",
	796	+ __func__, slave->dev_num, slave->status, status);
	797	+
	798	+ if (status == SDW_SLAVE_UNATTACHED) {
	799	+ dev_dbg(&slave->dev,
	800	+ "%s: initializing completion for Slave %d\n",
	801	+ __func__, slave->dev_num);
	802	+
	803	+ init_completion(&slave->enumeration_complete);
	804	+ init_completion(&slave->initialization_complete);
	805	+
	806	+ } else if ((status == SDW_SLAVE_ATTACHED) &&
	807	+ (slave->status == SDW_SLAVE_UNATTACHED)) {
	808	+ dev_dbg(&slave->dev,
	809	+ "%s: signaling completion for Slave %d\n",
	810	+ __func__, slave->dev_num);
	811	+
	812	+ complete(&slave->enumeration_complete);
	813	+ }
594	814	slave->status = status;
595	815	mutex_unlock(&slave->bus->bus_lock);
596	816	}
597	817
	818	+static enum sdw_clk_stop_mode sdw_get_clk_stop_mode(struct sdw_slave *slave)
	819	+{
	820	+ enum sdw_clk_stop_mode mode;
	821	+
	822	+ /*
	823	+ * Query for clock stop mode if Slave implements
	824	+ * ops->get_clk_stop_mode, else read from property.
	825	+ */
	826	+ if (slave->ops && slave->ops->get_clk_stop_mode) {
	827	+ mode = slave->ops->get_clk_stop_mode(slave);
	828	+ } else {
	829	+ if (slave->prop.clk_stop_mode1)
	830	+ mode = SDW_CLK_STOP_MODE1;
	831	+ else
	832	+ mode = SDW_CLK_STOP_MODE0;
	833	+ }
	834	+
	835	+ return mode;
	836	+}
	837	+
	838	+static int sdw_slave_clk_stop_callback(struct sdw_slave *slave,
	839	+ enum sdw_clk_stop_mode mode,
	840	+ enum sdw_clk_stop_type type)
	841	+{
	842	+ int ret;
	843	+
	844	+ if (slave->ops && slave->ops->clk_stop) {
	845	+ ret = slave->ops->clk_stop(slave, mode, type);
	846	+ if (ret < 0) {
	847	+ dev_err(&slave->dev,
	848	+ "Clk Stop type =%d failed: %d\n", type, ret);
	849	+ return ret;
	850	+ }
	851	+ }
	852	+
	853	+ return 0;
	854	+}
	855	+
	856	+static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave,
	857	+ enum sdw_clk_stop_mode mode,
	858	+ bool prepare)
	859	+{
	860	+ bool wake_en;
	861	+ u32 val = 0;
	862	+ int ret;
	863	+
	864	+ wake_en = slave->prop.wake_capable;
	865	+
	866	+ if (prepare) {
	867	+ val = SDW_SCP_SYSTEMCTRL_CLK_STP_PREP;
	868	+
	869	+ if (mode == SDW_CLK_STOP_MODE1)
	870	+ val \|= SDW_SCP_SYSTEMCTRL_CLK_STP_MODE1;
	871	+
	872	+ if (wake_en)
	873	+ val \|= SDW_SCP_SYSTEMCTRL_WAKE_UP_EN;
	874	+ } else {
	875	+ val = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL);
	876	+
	877	+ val &= ~(SDW_SCP_SYSTEMCTRL_CLK_STP_PREP);
	878	+ }
	879	+
	880	+ ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val);
	881	+
	882	+ if (ret != 0)
	883	+ dev_err(&slave->dev,
	884	+ "Clock Stop prepare failed for slave: %d", ret);
	885	+
	886	+ return ret;
	887	+}
	888	+
	889	+static int sdw_bus_wait_for_clk_prep_deprep(struct sdw_bus *bus, u16 dev_num)
	890	+{
	891	+ int retry = bus->clk_stop_timeout;
	892	+ int val;
	893	+
	894	+ do {
	895	+ val = sdw_bread_no_pm(bus, dev_num, SDW_SCP_STAT) &
	896	+ SDW_SCP_STAT_CLK_STP_NF;
	897	+ if (!val) {
	898	+ dev_info(bus->dev, "clock stop prep/de-prep done slave:%d",
	899	+ dev_num);
	900	+ return 0;
	901	+ }
	902	+
	903	+ usleep_range(1000, 1500);
	904	+ retry--;
	905	+ } while (retry);
	906	+
	907	+ dev_err(bus->dev, "clock stop prep/de-prep failed slave:%d",
	908	+ dev_num);
	909	+
	910	+ return -ETIMEDOUT;
	911	+}
	912	+
	913	+/**
	914	+ * sdw_bus_prep_clk_stop: prepare Slave(s) for clock stop
	915	+ *
	916	+ * @bus: SDW bus instance
	917	+ *
	918	+ * Query Slave for clock stop mode and prepare for that mode.
	919	+ */
	920	+int sdw_bus_prep_clk_stop(struct sdw_bus *bus)
	921	+{
	922	+ enum sdw_clk_stop_mode slave_mode;
	923	+ bool simple_clk_stop = true;
	924	+ struct sdw_slave *slave;
	925	+ bool is_slave = false;
	926	+ int ret = 0;
	927	+
	928	+ /*
	929	+ * In order to save on transition time, prepare
	930	+ * each Slave and then wait for all Slave(s) to be
	931	+ * prepared for clock stop.
	932	+ */
	933	+ list_for_each_entry(slave, &bus->slaves, node) {
	934	+ if (!slave->dev_num)
	935	+ continue;
	936	+
	937	+ if (slave->status != SDW_SLAVE_ATTACHED &&
	938	+ slave->status != SDW_SLAVE_ALERT)
	939	+ continue;
	940	+
	941	+ /* Identify if Slave(s) are available on Bus */
	942	+ is_slave = true;
	943	+
	944	+ slave_mode = sdw_get_clk_stop_mode(slave);
	945	+ slave->curr_clk_stop_mode = slave_mode;
	946	+
	947	+ ret = sdw_slave_clk_stop_callback(slave, slave_mode,
	948	+ SDW_CLK_PRE_PREPARE);
	949	+ if (ret < 0) {
	950	+ dev_err(&slave->dev,
	951	+ "pre-prepare failed:%d", ret);
	952	+ return ret;
	953	+ }
	954	+
	955	+ ret = sdw_slave_clk_stop_prepare(slave,
	956	+ slave_mode, true);
	957	+ if (ret < 0) {
	958	+ dev_err(&slave->dev,
	959	+ "pre-prepare failed:%d", ret);
	960	+ return ret;
	961	+ }
	962	+
	963	+ if (slave_mode == SDW_CLK_STOP_MODE1)
	964	+ simple_clk_stop = false;
	965	+ }
	966	+
	967	+ if (is_slave && !simple_clk_stop) {
	968	+ ret = sdw_bus_wait_for_clk_prep_deprep(bus,
	969	+ SDW_BROADCAST_DEV_NUM);
	970	+ if (ret < 0)
	971	+ return ret;
	972	+ }
	973	+
	974	+ /* Don't need to inform slaves if there is no slave attached */
	975	+ if (!is_slave)
	976	+ return ret;
	977	+
	978	+ /* Inform slaves that prep is done */
	979	+ list_for_each_entry(slave, &bus->slaves, node) {
	980	+ if (!slave->dev_num)
	981	+ continue;
	982	+
	983	+ if (slave->status != SDW_SLAVE_ATTACHED &&
	984	+ slave->status != SDW_SLAVE_ALERT)
	985	+ continue;
	986	+
	987	+ slave_mode = slave->curr_clk_stop_mode;
	988	+
	989	+ if (slave_mode == SDW_CLK_STOP_MODE1) {
	990	+ ret = sdw_slave_clk_stop_callback(slave,
	991	+ slave_mode,
	992	+ SDW_CLK_POST_PREPARE);
	993	+
	994	+ if (ret < 0) {
	995	+ dev_err(&slave->dev,
	996	+ "post-prepare failed:%d", ret);
	997	+ }
	998	+ }
	999	+ }
	1000	+
	1001	+ return ret;
	1002	+}
	1003	+EXPORT_SYMBOL(sdw_bus_prep_clk_stop);
	1004	+
	1005	+/**
	1006	+ * sdw_bus_clk_stop: stop bus clock
	1007	+ *
	1008	+ * @bus: SDW bus instance
	1009	+ *
	1010	+ * After preparing the Slaves for clock stop, stop the clock by broadcasting
	1011	+ * write to SCP_CTRL register.
	1012	+ */
	1013	+int sdw_bus_clk_stop(struct sdw_bus *bus)
	1014	+{
	1015	+ int ret;
	1016	+
	1017	+ /*
	1018	+ * broadcast clock stop now, attached Slaves will ACK this,
	1019	+ * unattached will ignore
	1020	+ */
	1021	+ ret = sdw_bwrite_no_pm(bus, SDW_BROADCAST_DEV_NUM,
	1022	+ SDW_SCP_CTRL, SDW_SCP_CTRL_CLK_STP_NOW);
	1023	+ if (ret < 0) {
	1024	+ if (ret == -ENODATA)
	1025	+ dev_dbg(bus->dev,
	1026	+ "ClockStopNow Broadcast msg ignored %d", ret);
	1027	+ else
	1028	+ dev_err(bus->dev,
	1029	+ "ClockStopNow Broadcast msg failed %d", ret);
	1030	+ return ret;
	1031	+ }
	1032	+
	1033	+ return 0;
	1034	+}
	1035	+EXPORT_SYMBOL(sdw_bus_clk_stop);
	1036	+
	1037	+/**
	1038	+ * sdw_bus_exit_clk_stop: Exit clock stop mode
	1039	+ *
	1040	+ * @bus: SDW bus instance
	1041	+ *
	1042	+ * This De-prepares the Slaves by exiting Clock Stop Mode 0. For the Slaves
	1043	+ * exiting Clock Stop Mode 1, they will be de-prepared after they enumerate
	1044	+ * back.
	1045	+ */
	1046	+int sdw_bus_exit_clk_stop(struct sdw_bus *bus)
	1047	+{
	1048	+ enum sdw_clk_stop_mode mode;
	1049	+ bool simple_clk_stop = true;
	1050	+ struct sdw_slave *slave;
	1051	+ bool is_slave = false;
	1052	+ int ret;
	1053	+
	1054	+ /*
	1055	+ * In order to save on transition time, de-prepare
	1056	+ * each Slave and then wait for all Slave(s) to be
	1057	+ * de-prepared after clock resume.
	1058	+ */
	1059	+ list_for_each_entry(slave, &bus->slaves, node) {
	1060	+ if (!slave->dev_num)
	1061	+ continue;
	1062	+
	1063	+ if (slave->status != SDW_SLAVE_ATTACHED &&
	1064	+ slave->status != SDW_SLAVE_ALERT)
	1065	+ continue;
	1066	+
	1067	+ /* Identify if Slave(s) are available on Bus */
	1068	+ is_slave = true;
	1069	+
	1070	+ mode = slave->curr_clk_stop_mode;
	1071	+
	1072	+ if (mode == SDW_CLK_STOP_MODE1) {
	1073	+ simple_clk_stop = false;
	1074	+ continue;
	1075	+ }
	1076	+
	1077	+ ret = sdw_slave_clk_stop_callback(slave, mode,
	1078	+ SDW_CLK_PRE_DEPREPARE);
	1079	+ if (ret < 0)
	1080	+ dev_warn(&slave->dev,
	1081	+ "clk stop deprep failed:%d", ret);
	1082	+
	1083	+ ret = sdw_slave_clk_stop_prepare(slave, mode,
	1084	+ false);
	1085	+
	1086	+ if (ret < 0)
	1087	+ dev_warn(&slave->dev,
	1088	+ "clk stop deprep failed:%d", ret);
	1089	+ }
	1090	+
	1091	+ if (is_slave && !simple_clk_stop)
	1092	+ sdw_bus_wait_for_clk_prep_deprep(bus, SDW_BROADCAST_DEV_NUM);
	1093	+
	1094	+ /*
	1095	+ * Don't need to call slave callback function if there is no slave
	1096	+ * attached
	1097	+ */
	1098	+ if (!is_slave)
	1099	+ return 0;
	1100	+
	1101	+ list_for_each_entry(slave, &bus->slaves, node) {
	1102	+ if (!slave->dev_num)
	1103	+ continue;
	1104	+
	1105	+ if (slave->status != SDW_SLAVE_ATTACHED &&
	1106	+ slave->status != SDW_SLAVE_ALERT)
	1107	+ continue;
	1108	+
	1109	+ mode = slave->curr_clk_stop_mode;
	1110	+ sdw_slave_clk_stop_callback(slave, mode,
	1111	+ SDW_CLK_POST_DEPREPARE);
	1112	+ }
	1113	+
	1114	+ return 0;
	1115	+}
	1116	+EXPORT_SYMBOL(sdw_bus_exit_clk_stop);
	1117	+
598	1118	int sdw_configure_dpn_intr(struct sdw_slave *slave,
599		- int port, bool enable, int mask)
	1119	+ int port, bool enable, int mask)
600	1120	{
601	1121	u32 addr;
602	1122	int ret;
603	1123	u8 val = 0;
	1124	+
	1125	+ if (slave->bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL) {
	1126	+ dev_dbg(&slave->dev, "TEST FAIL interrupt %s\n",
	1127	+ enable ? "on" : "off");
	1128	+ mask \|= SDW_DPN_INT_TEST_FAIL;
	1129	+ }
604	1130
605	1131	addr = SDW_DPN_INTMASK(port);
606	1132
..	..	@@ -616,7 +1142,110 @@
616	1142	ret = sdw_update(slave, addr, (mask \| SDW_DPN_INT_PORT_READY), val);
617	1143	if (ret < 0)
618	1144	dev_err(slave->bus->dev,
619		- "SDW_DPN_INTMASK write failed:%d", val);
	1145	+ "SDW_DPN_INTMASK write failed:%d\n", val);
	1146	+
	1147	+ return ret;
	1148	+}
	1149	+
	1150	+static int sdw_slave_set_frequency(struct sdw_slave *slave)
	1151	+{
	1152	+ u32 mclk_freq = slave->bus->prop.mclk_freq;
	1153	+ u32 curr_freq = slave->bus->params.curr_dr_freq >> 1;
	1154	+ unsigned int scale;
	1155	+ u8 scale_index;
	1156	+ u8 base;
	1157	+ int ret;
	1158	+
	1159	+ /*
	1160	+ * frequency base and scale registers are required for SDCA
	1161	+ * devices. They may also be used for 1.2+/non-SDCA devices,
	1162	+ * but we will need a DisCo property to cover this case
	1163	+ */
	1164	+ if (!slave->id.class_id)
	1165	+ return 0;
	1166	+
	1167	+ if (!mclk_freq) {
	1168	+ dev_err(&slave->dev,
	1169	+ "no bus MCLK, cannot set SDW_SCP_BUS_CLOCK_BASE\n");
	1170	+ return -EINVAL;
	1171	+ }
	1172	+
	1173	+ /*
	1174	+ * map base frequency using Table 89 of SoundWire 1.2 spec.
	1175	+ * The order of the tests just follows the specification, this
	1176	+ * is not a selection between possible values or a search for
	1177	+ * the best value but just a mapping. Only one case per platform
	1178	+ * is relevant.
	1179	+ * Some BIOS have inconsistent values for mclk_freq but a
	1180	+ * correct root so we force the mclk_freq to avoid variations.
	1181	+ */
	1182	+ if (!(19200000 % mclk_freq)) {
	1183	+ mclk_freq = 19200000;
	1184	+ base = SDW_SCP_BASE_CLOCK_19200000_HZ;
	1185	+ } else if (!(24000000 % mclk_freq)) {
	1186	+ mclk_freq = 24000000;
	1187	+ base = SDW_SCP_BASE_CLOCK_24000000_HZ;
	1188	+ } else if (!(24576000 % mclk_freq)) {
	1189	+ mclk_freq = 24576000;
	1190	+ base = SDW_SCP_BASE_CLOCK_24576000_HZ;
	1191	+ } else if (!(22579200 % mclk_freq)) {
	1192	+ mclk_freq = 22579200;
	1193	+ base = SDW_SCP_BASE_CLOCK_22579200_HZ;
	1194	+ } else if (!(32000000 % mclk_freq)) {
	1195	+ mclk_freq = 32000000;
	1196	+ base = SDW_SCP_BASE_CLOCK_32000000_HZ;
	1197	+ } else {
	1198	+ dev_err(&slave->dev,
	1199	+ "Unsupported clock base, mclk %d\n",
	1200	+ mclk_freq);
	1201	+ return -EINVAL;
	1202	+ }
	1203	+
	1204	+ if (mclk_freq % curr_freq) {
	1205	+ dev_err(&slave->dev,
	1206	+ "mclk %d is not multiple of bus curr_freq %d\n",
	1207	+ mclk_freq, curr_freq);
	1208	+ return -EINVAL;
	1209	+ }
	1210	+
	1211	+ scale = mclk_freq / curr_freq;
	1212	+
	1213	+ /*
	1214	+ * map scale to Table 90 of SoundWire 1.2 spec - and check
	1215	+ * that the scale is a power of two and maximum 64
	1216	+ */
	1217	+ scale_index = ilog2(scale);
	1218	+
	1219	+ if (BIT(scale_index) != scale \|\| scale_index > 6) {
	1220	+ dev_err(&slave->dev,
	1221	+ "No match found for scale %d, bus mclk %d curr_freq %d\n",
	1222	+ scale, mclk_freq, curr_freq);
	1223	+ return -EINVAL;
	1224	+ }
	1225	+ scale_index++;
	1226	+
	1227	+ ret = sdw_write_no_pm(slave, SDW_SCP_BUS_CLOCK_BASE, base);
	1228	+ if (ret < 0) {
	1229	+ dev_err(&slave->dev,
	1230	+ "SDW_SCP_BUS_CLOCK_BASE write failed:%d\n", ret);
	1231	+ return ret;
	1232	+ }
	1233	+
	1234	+ /* initialize scale for both banks */
	1235	+ ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B0, scale_index);
	1236	+ if (ret < 0) {
	1237	+ dev_err(&slave->dev,
	1238	+ "SDW_SCP_BUSCLOCK_SCALE_B0 write failed:%d\n", ret);
	1239	+ return ret;
	1240	+ }
	1241	+ ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B1, scale_index);
	1242	+ if (ret < 0)
	1243	+ dev_err(&slave->dev,
	1244	+ "SDW_SCP_BUSCLOCK_SCALE_B1 write failed:%d\n", ret);
	1245	+
	1246	+ dev_dbg(&slave->dev,
	1247	+ "Configured bus base %d, scale %d, mclk %d, curr_freq %d\n",
	1248	+ base, scale_index, mclk_freq, curr_freq);
620	1249
621	1250	return ret;
622	1251	}
..	..	@@ -627,20 +1256,24 @@
627	1256	int ret;
628	1257	u8 val;
629	1258
	1259	+ ret = sdw_slave_set_frequency(slave);
	1260	+ if (ret < 0)
	1261	+ return ret;
	1262	+
630	1263	/*
631		- * Set bus clash, parity and SCP implementation
632		- * defined interrupt mask
633		- * TODO: Read implementation defined interrupt mask
634		- * from Slave property
	1264	+ * Set SCP_INT1_MASK register, typically bus clash and
	1265	+ * implementation-defined interrupt mask. The Parity detection
	1266	+ * may not always be correct on startup so its use is
	1267	+ * device-dependent, it might e.g. only be enabled in
	1268	+ * steady-state after a couple of frames.
635	1269	*/
636		- val = SDW_SCP_INT1_IMPL_DEF \| SDW_SCP_INT1_BUS_CLASH \|
637		- SDW_SCP_INT1_PARITY;
	1270	+ val = slave->prop.scp_int1_mask;
638	1271
639	1272	/* Enable SCP interrupts */
640		- ret = sdw_update(slave, SDW_SCP_INTMASK1, val, val);
	1273	+ ret = sdw_update_no_pm(slave, SDW_SCP_INTMASK1, val, val);
641	1274	if (ret < 0) {
642	1275	dev_err(slave->bus->dev,
643		- "SDW_SCP_INTMASK1 write failed:%d", ret);
	1276	+ "SDW_SCP_INTMASK1 write failed:%d\n", ret);
644	1277	return ret;
645	1278	}
646	1279
..	..	@@ -649,17 +1282,14 @@
649	1282	return 0;
650	1283
651	1284	/* Enable DP0 interrupts */
652		- val = prop->dp0_prop->device_interrupts;
	1285	+ val = prop->dp0_prop->imp_def_interrupts;
653	1286	val \|= SDW_DP0_INT_PORT_READY \| SDW_DP0_INT_BRA_FAILURE;
654	1287
655		- ret = sdw_update(slave, SDW_DP0_INTMASK, val, val);
656		- if (ret < 0) {
	1288	+ ret = sdw_update_no_pm(slave, SDW_DP0_INTMASK, val, val);
	1289	+ if (ret < 0)
657	1290	dev_err(slave->bus->dev,
658		- "SDW_DP0_INTMASK read failed:%d", ret);
659		- return val;
660		- }
661		-
662		- return 0;
	1291	+ "SDW_DP0_INTMASK read failed:%d\n", ret);
	1292	+ return ret;
663	1293	}
664	1294
665	1295	static int sdw_handle_dp0_interrupt(struct sdw_slave slave, u8 slave_status)
..	..	@@ -670,14 +1300,13 @@
670	1300	status = sdw_read(slave, SDW_DP0_INT);
671	1301	if (status < 0) {
672	1302	dev_err(slave->bus->dev,
673		- "SDW_DP0_INT read failed:%d", status);
	1303	+ "SDW_DP0_INT read failed:%d\n", status);
674	1304	return status;
675	1305	}
676	1306
677	1307	do {
678		-
679	1308	if (status & SDW_DP0_INT_TEST_FAIL) {
680		- dev_err(&slave->dev, "Test fail for port 0");
	1309	+ dev_err(&slave->dev, "Test fail for port 0\n");
681	1310	clear \|= SDW_DP0_INT_TEST_FAIL;
682	1311	}
683	1312
..	..	@@ -692,7 +1321,7 @@
692	1321	}
693	1322
694	1323	if (status & SDW_DP0_INT_BRA_FAILURE) {
695		- dev_err(&slave->dev, "BRA failed");
	1324	+ dev_err(&slave->dev, "BRA failed\n");
696	1325	clear \|= SDW_DP0_INT_BRA_FAILURE;
697	1326	}
698	1327
..	..	@@ -708,7 +1337,7 @@
708	1337	ret = sdw_write(slave, SDW_DP0_INT, clear);
709	1338	if (ret < 0) {
710	1339	dev_err(slave->bus->dev,
711		- "SDW_DP0_INT write failed:%d", ret);
	1340	+ "SDW_DP0_INT write failed:%d\n", ret);
712	1341	return ret;
713	1342	}
714	1343
..	..	@@ -716,7 +1345,7 @@
716	1345	status2 = sdw_read(slave, SDW_DP0_INT);
717	1346	if (status2 < 0) {
718	1347	dev_err(slave->bus->dev,
719		- "SDW_DP0_INT read failed:%d", status2);
	1348	+ "SDW_DP0_INT read failed:%d\n", status2);
720	1349	return status2;
721	1350	}
722	1351	status &= status2;
..	..	@@ -727,13 +1356,13 @@
727	1356	} while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
728	1357
729	1358	if (count == SDW_READ_INTR_CLEAR_RETRY)
730		- dev_warn(slave->bus->dev, "Reached MAX_RETRY on DP0 read");
	1359	+ dev_warn(slave->bus->dev, "Reached MAX_RETRY on DP0 read\n");
731	1360
732	1361	return ret;
733	1362	}
734	1363
735	1364	static int sdw_handle_port_interrupt(struct sdw_slave *slave,
736		- int port, u8 *slave_status)
	1365	+ int port, u8 *slave_status)
737	1366	{
738	1367	u8 clear = 0, impl_int_mask;
739	1368	int status, status2, ret, count = 0;
..	..	@@ -746,15 +1375,14 @@
746	1375	status = sdw_read(slave, addr);
747	1376	if (status < 0) {
748	1377	dev_err(slave->bus->dev,
749		- "SDW_DPN_INT read failed:%d", status);
	1378	+ "SDW_DPN_INT read failed:%d\n", status);
750	1379
751	1380	return status;
752	1381	}
753	1382
754	1383	do {
755		-
756	1384	if (status & SDW_DPN_INT_TEST_FAIL) {
757		- dev_err(&slave->dev, "Test fail for port:%d", port);
	1385	+ dev_err(&slave->dev, "Test fail for port:%d\n", port);
758	1386	clear \|= SDW_DPN_INT_TEST_FAIL;
759	1387	}
760	1388
..	..	@@ -770,7 +1398,6 @@
770	1398	impl_int_mask = SDW_DPN_INT_IMPDEF1 \|
771	1399	SDW_DPN_INT_IMPDEF2 \| SDW_DPN_INT_IMPDEF3;
772	1400
773		-
774	1401	if (status & impl_int_mask) {
775	1402	clear \|= impl_int_mask;
776	1403	*slave_status = clear;
..	..	@@ -780,7 +1407,7 @@
780	1407	ret = sdw_write(slave, addr, clear);
781	1408	if (ret < 0) {
782	1409	dev_err(slave->bus->dev,
783		- "SDW_DPN_INT write failed:%d", ret);
	1410	+ "SDW_DPN_INT write failed:%d\n", ret);
784	1411	return ret;
785	1412	}
786	1413
..	..	@@ -788,7 +1415,7 @@
788	1415	status2 = sdw_read(slave, addr);
789	1416	if (status2 < 0) {
790	1417	dev_err(slave->bus->dev,
791		- "SDW_DPN_INT read failed:%d", status2);
	1418	+ "SDW_DPN_INT read failed:%d\n", status2);
792	1419	return status2;
793	1420	}
794	1421	status &= status2;
..	..	@@ -812,22 +1439,32 @@
812	1439	unsigned long port;
813	1440	bool slave_notify = false;
814	1441	u8 buf, buf2[2], _buf, _buf2[2];
	1442	+ bool parity_check;
	1443	+ bool parity_quirk;
815	1444
816	1445	sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
817	1446
818		- /* Read Instat 1, Instat 2 and Instat 3 registers */
819		- buf = ret = sdw_read(slave, SDW_SCP_INT1);
820		- if (ret < 0) {
821		- dev_err(slave->bus->dev,
822		- "SDW_SCP_INT1 read failed:%d", ret);
	1447	+ ret = pm_runtime_get_sync(&slave->dev);
	1448	+ if (ret < 0 && ret != -EACCES) {
	1449	+ dev_err(&slave->dev, "Failed to resume device: %d\n", ret);
	1450	+ pm_runtime_put_noidle(&slave->dev);
823	1451	return ret;
824	1452	}
	1453	+
	1454	+ /* Read Intstat 1, Intstat 2 and Intstat 3 registers */
	1455	+ ret = sdw_read(slave, SDW_SCP_INT1);
	1456	+ if (ret < 0) {
	1457	+ dev_err(slave->bus->dev,
	1458	+ "SDW_SCP_INT1 read failed:%d\n", ret);
	1459	+ goto io_err;
	1460	+ }
	1461	+ buf = ret;
825	1462
826	1463	ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, buf2);
827	1464	if (ret < 0) {
828	1465	dev_err(slave->bus->dev,
829		- "SDW_SCP_INT2/3 read failed:%d", ret);
830		- return ret;
	1466	+ "SDW_SCP_INT2/3 read failed:%d\n", ret);
	1467	+ goto io_err;
831	1468	}
832	1469
833	1470	do {
..	..	@@ -836,12 +1473,18 @@
836	1473	* interrupt
837	1474	*/
838	1475	if (buf & SDW_SCP_INT1_PARITY) {
839		- dev_err(&slave->dev, "Parity error detected");
	1476	+ parity_check = slave->prop.scp_int1_mask & SDW_SCP_INT1_PARITY;
	1477	+ parity_quirk = !slave->first_interrupt_done &&
	1478	+ (slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY);
	1479	+
	1480	+ if (parity_check && !parity_quirk)
	1481	+ dev_err(&slave->dev, "Parity error detected\n");
840	1482	clear \|= SDW_SCP_INT1_PARITY;
841	1483	}
842	1484
843	1485	if (buf & SDW_SCP_INT1_BUS_CLASH) {
844		- dev_err(&slave->dev, "Bus clash error detected");
	1486	+ if (slave->prop.scp_int1_mask & SDW_SCP_INT1_BUS_CLASH)
	1487	+ dev_err(&slave->dev, "Bus clash detected\n");
845	1488	clear \|= SDW_SCP_INT1_BUS_CLASH;
846	1489	}
847	1490
..	..	@@ -853,20 +1496,21 @@
853	1496	*/
854	1497
855	1498	if (buf & SDW_SCP_INT1_IMPL_DEF) {
856		- dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
	1499	+ if (slave->prop.scp_int1_mask & SDW_SCP_INT1_IMPL_DEF) {
	1500	+ dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
	1501	+ slave_notify = true;
	1502	+ }
857	1503	clear \|= SDW_SCP_INT1_IMPL_DEF;
858		- slave_notify = true;
859	1504	}
860	1505
861	1506	/* Check port 0 - 3 interrupts */
862	1507	port = buf & SDW_SCP_INT1_PORT0_3;
863	1508
864	1509	/* To get port number corresponding to bits, shift it */
865		- port = port >> SDW_REG_SHIFT(SDW_SCP_INT1_PORT0_3);
	1510	+ port = FIELD_GET(SDW_SCP_INT1_PORT0_3, port);
866	1511	for_each_set_bit(bit, &port, 8) {
867	1512	sdw_handle_port_interrupt(slave, bit,
868		- &port_status[bit]);
869		-
	1513	+ &port_status[bit]);
870	1514	}
871	1515
872	1516	/* Check if cascade 2 interrupt is present */
..	..	@@ -894,11 +1538,11 @@
894	1538	}
895	1539
896	1540	/* Update the Slave driver */
897		- if (slave_notify && (slave->ops) &&
898		- (slave->ops->interrupt_callback)) {
	1541	+ if (slave_notify && slave->ops &&
	1542	+ slave->ops->interrupt_callback) {
899	1543	slave_intr.control_port = clear;
900	1544	memcpy(slave_intr.port, &port_status,
901		- sizeof(slave_intr.port));
	1545	+ sizeof(slave_intr.port));
902	1546
903	1547	slave->ops->interrupt_callback(slave, &slave_intr);
904	1548	}
..	..	@@ -907,26 +1551,30 @@
907	1551	ret = sdw_write(slave, SDW_SCP_INT1, clear);
908	1552	if (ret < 0) {
909	1553	dev_err(slave->bus->dev,
910		- "SDW_SCP_INT1 write failed:%d", ret);
911		- return ret;
	1554	+ "SDW_SCP_INT1 write failed:%d\n", ret);
	1555	+ goto io_err;
912	1556	}
	1557	+
	1558	+ /* at this point all initial interrupt sources were handled */
	1559	+ slave->first_interrupt_done = true;
913	1560
914	1561	/*
915	1562	* Read status again to ensure no new interrupts arrived
916	1563	* while servicing interrupts.
917	1564	*/
918		- _buf = ret = sdw_read(slave, SDW_SCP_INT1);
	1565	+ ret = sdw_read(slave, SDW_SCP_INT1);
919	1566	if (ret < 0) {
920	1567	dev_err(slave->bus->dev,
921		- "SDW_SCP_INT1 read failed:%d", ret);
922		- return ret;
	1568	+ "SDW_SCP_INT1 read failed:%d\n", ret);
	1569	+ goto io_err;
923	1570	}
	1571	+ _buf = ret;
924	1572
925	1573	ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, _buf2);
926	1574	if (ret < 0) {
927	1575	dev_err(slave->bus->dev,
928		- "SDW_SCP_INT2/3 read failed:%d", ret);
929		- return ret;
	1576	+ "SDW_SCP_INT2/3 read failed:%d\n", ret);
	1577	+ goto io_err;
930	1578	}
931	1579
932	1580	/* Make sure no interrupts are pending */
..	..	@@ -945,18 +1593,41 @@
945	1593	} while (stat != 0 && count < SDW_READ_INTR_CLEAR_RETRY);
946	1594
947	1595	if (count == SDW_READ_INTR_CLEAR_RETRY)
948		- dev_warn(slave->bus->dev, "Reached MAX_RETRY on alert read");
	1596	+ dev_warn(slave->bus->dev, "Reached MAX_RETRY on alert read\n");
	1597	+
	1598	+io_err:
	1599	+ pm_runtime_mark_last_busy(&slave->dev);
	1600	+ pm_runtime_put_autosuspend(&slave->dev);
949	1601
950	1602	return ret;
951	1603	}
952	1604
953	1605	static int sdw_update_slave_status(struct sdw_slave *slave,
954		- enum sdw_slave_status status)
	1606	+ enum sdw_slave_status status)
955	1607	{
956		- if ((slave->ops) && (slave->ops->update_status))
957		- return slave->ops->update_status(slave, status);
	1608	+ unsigned long time;
958	1609
959		- return 0;
	1610	+ if (!slave->probed) {
	1611	+ /*
	1612	+ * the slave status update is typically handled in an
	1613	+ * interrupt thread, which can race with the driver
	1614	+ * probe, e.g. when a module needs to be loaded.
	1615	+ *
	1616	+ * make sure the probe is complete before updating
	1617	+ * status.
	1618	+ */
	1619	+ time = wait_for_completion_timeout(&slave->probe_complete,
	1620	+ msecs_to_jiffies(DEFAULT_PROBE_TIMEOUT));
	1621	+ if (!time) {
	1622	+ dev_err(&slave->dev, "Probe not complete, timed out\n");
	1623	+ return -ETIMEDOUT;
	1624	+ }
	1625	+ }
	1626	+
	1627	+ if (!slave->ops \|\| !slave->ops->update_status)
	1628	+ return 0;
	1629	+
	1630	+ return slave->ops->update_status(slave, status);
960	1631	}
961	1632
962	1633	/**
..	..	@@ -965,16 +1636,41 @@
965	1636	* @status: Status for all Slave(s)
966	1637	*/
967	1638	int sdw_handle_slave_status(struct sdw_bus *bus,
968		- enum sdw_slave_status status[])
	1639	+ enum sdw_slave_status status[])
969	1640	{
970	1641	enum sdw_slave_status prev_status;
971	1642	struct sdw_slave *slave;
	1643	+ bool attached_initializing;
972	1644	int i, ret = 0;
973	1645
	1646	+ /* first check if any Slaves fell off the bus */
	1647	+ for (i = 1; i <= SDW_MAX_DEVICES; i++) {
	1648	+ mutex_lock(&bus->bus_lock);
	1649	+ if (test_bit(i, bus->assigned) == false) {
	1650	+ mutex_unlock(&bus->bus_lock);
	1651	+ continue;
	1652	+ }
	1653	+ mutex_unlock(&bus->bus_lock);
	1654	+
	1655	+ slave = sdw_get_slave(bus, i);
	1656	+ if (!slave)
	1657	+ continue;
	1658	+
	1659	+ if (status[i] == SDW_SLAVE_UNATTACHED &&
	1660	+ slave->status != SDW_SLAVE_UNATTACHED)
	1661	+ sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
	1662	+ }
	1663	+
974	1664	if (status[0] == SDW_SLAVE_ATTACHED) {
	1665	+ dev_dbg(bus->dev, "Slave attached, programming device number\n");
975	1666	ret = sdw_program_device_num(bus);
976	1667	if (ret)
977		- dev_err(bus->dev, "Slave attach failed: %d", ret);
	1668	+ dev_err(bus->dev, "Slave attach failed: %d\n", ret);
	1669	+ /*
	1670	+ * programming a device number will have side effects,
	1671	+ * so we deal with other devices at a later time
	1672	+ */
	1673	+ return ret;
978	1674	}
979	1675
980	1676	/* Continue to check other slave statuses */
..	..	@@ -990,6 +1686,8 @@
990	1686	if (!slave)
991	1687	continue;
992	1688
	1689	+ attached_initializing = false;
	1690	+
993	1691	switch (status[i]) {
994	1692	case SDW_SLAVE_UNATTACHED:
995	1693	if (slave->status == SDW_SLAVE_UNATTACHED)
..	..	@@ -1002,7 +1700,7 @@
1002	1700	ret = sdw_handle_slave_alerts(slave);
1003	1701	if (ret)
1004	1702	dev_err(bus->dev,
1005		- "Slave %d alert handling failed: %d",
	1703	+ "Slave %d alert handling failed: %d\n",
1006	1704	i, ret);
1007	1705	break;
1008	1706
..	..	@@ -1016,27 +1714,59 @@
1016	1714	if (prev_status == SDW_SLAVE_ALERT)
1017	1715	break;
1018	1716
	1717	+ attached_initializing = true;
	1718	+
1019	1719	ret = sdw_initialize_slave(slave);
1020	1720	if (ret)
1021	1721	dev_err(bus->dev,
1022		- "Slave %d initialization failed: %d",
	1722	+ "Slave %d initialization failed: %d\n",
1023	1723	i, ret);
1024	1724
1025	1725	break;
1026	1726
1027	1727	default:
1028		- dev_err(bus->dev, "Invalid slave %d status:%d",
1029		- i, status[i]);
	1728	+ dev_err(bus->dev, "Invalid slave %d status:%d\n",
	1729	+ i, status[i]);
1030	1730	break;
1031	1731	}
1032	1732
1033	1733	ret = sdw_update_slave_status(slave, status[i]);
1034	1734	if (ret)
1035	1735	dev_err(slave->bus->dev,
1036		- "Update Slave status failed:%d", ret);
1037		-
	1736	+ "Update Slave status failed:%d\n", ret);
	1737	+ if (attached_initializing)
	1738	+ complete(&slave->initialization_complete);
1038	1739	}
1039	1740
1040	1741	return ret;
1041	1742	}
1042	1743	EXPORT_SYMBOL(sdw_handle_slave_status);
	1744	+
	1745	+void sdw_clear_slave_status(struct sdw_bus *bus, u32 request)
	1746	+{
	1747	+ struct sdw_slave *slave;
	1748	+ int i;
	1749	+
	1750	+ /* Check all non-zero devices */
	1751	+ for (i = 1; i <= SDW_MAX_DEVICES; i++) {
	1752	+ mutex_lock(&bus->bus_lock);
	1753	+ if (test_bit(i, bus->assigned) == false) {
	1754	+ mutex_unlock(&bus->bus_lock);
	1755	+ continue;
	1756	+ }
	1757	+ mutex_unlock(&bus->bus_lock);
	1758	+
	1759	+ slave = sdw_get_slave(bus, i);
	1760	+ if (!slave)
	1761	+ continue;
	1762	+
	1763	+ if (slave->status != SDW_SLAVE_UNATTACHED) {
	1764	+ sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
	1765	+ slave->first_interrupt_done = false;
	1766	+ }
	1767	+
	1768	+ /* keep track of request, used in pm_runtime resume */
	1769	+ slave->unattach_request = request;
	1770	+ }
	1771	+}
	1772	+EXPORT_SYMBOL(sdw_clear_slave_status);