mipi_disco.c

  1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
  2// Copyright(c) 2015-17 Intel Corporation.
  3
  4/*
  5 * MIPI Discovery And Configuration (DisCo) Specification for SoundWire
  6 * specifies properties to be implemented for SoundWire Masters and Slaves.
  7 * The DisCo spec doesn't mandate these properties. However, SDW bus cannot
  8 * work without knowing these values.
  9 *
 10 * The helper functions read the Master and Slave properties. Implementers
 11 * of Master or Slave drivers can use any of the below three mechanisms:
 12 *    a) Use these APIs here as .read_prop() callback for Master and Slave
 13 *    b) Implement own methods and set those as .read_prop(), but invoke
 14 *    APIs in this file for generic read and override the values with
 15 *    platform specific data
 16 *    c) Implement ones own methods which do not use anything provided
 17 *    here
 18 */
 19
 20#include <linux/device.h>
 21#include <linux/property.h>
 22#include <linux/mod_devicetable.h>
 23#include <linux/soundwire/sdw.h>
 24#include "bus.h"
 25
 26static bool mipi_fwnode_property_read_bool(const struct fwnode_handle *fwnode,
 27					   const char *propname)
 28{
 29	int ret;
 30	u8 val;
 31
 32	if (!fwnode_property_present(fwnode, propname))
 33		return false;
 34	ret = fwnode_property_read_u8_array(fwnode, propname, &val, 1);
 35	if (ret < 0)
 36		return false;
 37	return !!val;
 38}
 39
 40static bool mipi_device_property_read_bool(const struct device *dev,
 41					   const char *propname)
 42{
 43	return mipi_fwnode_property_read_bool(dev_fwnode(dev), propname);
 44}
 45
 46/**
 47 * sdw_master_read_prop() - Read Master properties
 48 * @bus: SDW bus instance
 49 */
 50int sdw_master_read_prop(struct sdw_bus *bus)
 51{
 52	struct sdw_master_prop *prop = &bus->prop;
 53	struct fwnode_handle *link;
 54	const char *scales_prop;
 55	char name[32];
 56	int nval;
 57	int ret;
 58	int i;
 59
 60	device_property_read_u32(bus->dev,
 61				 "mipi-sdw-sw-interface-revision",
 62				 &prop->revision);
 63
 64	/* Find master handle */
 65	snprintf(name, sizeof(name),
 66		 "mipi-sdw-link-%d-subproperties", bus->link_id);
 67
 68	link = device_get_named_child_node(bus->dev, name);
 69	if (!link) {
 70		dev_err(bus->dev, "Master node %s not found\n", name);
 71		return -EIO;
 72	}
 73
 74	if (mipi_fwnode_property_read_bool(link,
 75				      "mipi-sdw-clock-stop-mode0-supported"))
 76		prop->clk_stop_modes |= BIT(SDW_CLK_STOP_MODE0);
 77
 78	if (mipi_fwnode_property_read_bool(link,
 79				      "mipi-sdw-clock-stop-mode1-supported"))
 80		prop->clk_stop_modes |= BIT(SDW_CLK_STOP_MODE1);
 81
 82	fwnode_property_read_u32(link,
 83				 "mipi-sdw-max-clock-frequency",
 84				 &prop->max_clk_freq);
 85
 86	nval = fwnode_property_count_u32(link, "mipi-sdw-clock-frequencies-supported");
 87	if (nval > 0) {
 88		prop->num_clk_freq = nval;
 89		prop->clk_freq = devm_kcalloc(bus->dev, prop->num_clk_freq,
 90					      sizeof(*prop->clk_freq),
 91					      GFP_KERNEL);
 92		if (!prop->clk_freq) {
 93			fwnode_handle_put(link);
 94			return -ENOMEM;
 95		}
 96
 97		ret = fwnode_property_read_u32_array(link,
 98				"mipi-sdw-clock-frequencies-supported",
 99				prop->clk_freq, prop->num_clk_freq);
100		if (ret < 0)
101			return ret;
102	}
103
104	/*
105	 * Check the frequencies supported. If FW doesn't provide max
106	 * freq, then populate here by checking values.
107	 */
108	if (!prop->max_clk_freq && prop->clk_freq) {
109		prop->max_clk_freq = prop->clk_freq[0];
110		for (i = 1; i < prop->num_clk_freq; i++) {
111			if (prop->clk_freq[i] > prop->max_clk_freq)
112				prop->max_clk_freq = prop->clk_freq[i];
113		}
114	}
115
116	scales_prop = "mipi-sdw-supported-clock-scales";
117	nval = fwnode_property_count_u32(link, scales_prop);
118	if (nval == 0) {
119		scales_prop = "mipi-sdw-supported-clock-gears";
120		nval = fwnode_property_count_u32(link, scales_prop);
121	}
122	if (nval > 0) {
123		prop->num_clk_gears = nval;
124		prop->clk_gears = devm_kcalloc(bus->dev, prop->num_clk_gears,
125					       sizeof(*prop->clk_gears),
126					       GFP_KERNEL);
127		if (!prop->clk_gears) {
128			fwnode_handle_put(link);
129			return -ENOMEM;
130		}
131
132		ret = fwnode_property_read_u32_array(link,
133					       scales_prop,
134					       prop->clk_gears,
135					       prop->num_clk_gears);
136		if (ret < 0)
137			return ret;
138	}
139
140	fwnode_property_read_u32(link, "mipi-sdw-default-frame-rate",
141				 &prop->default_frame_rate);
142
143	fwnode_property_read_u32(link, "mipi-sdw-default-frame-row-size",
144				 &prop->default_row);
145
146	fwnode_property_read_u32(link, "mipi-sdw-default-frame-col-size",
147				 &prop->default_col);
148
149	prop->dynamic_frame =  mipi_fwnode_property_read_bool(link,
150			"mipi-sdw-dynamic-frame-shape");
151
152	fwnode_property_read_u32(link, "mipi-sdw-command-error-threshold",
153				 &prop->err_threshold);
154
155	fwnode_handle_put(link);
156
157	return 0;
158}
159EXPORT_SYMBOL(sdw_master_read_prop);
160
161static int sdw_slave_read_dp0(struct sdw_slave *slave,
162			      struct fwnode_handle *port,
163			      struct sdw_dp0_prop *dp0)
164{
165	int nval;
166	int ret;
167
168	fwnode_property_read_u32(port, "mipi-sdw-port-max-wordlength",
169				 &dp0->max_word);
170
171	fwnode_property_read_u32(port, "mipi-sdw-port-min-wordlength",
172				 &dp0->min_word);
173
174	nval = fwnode_property_count_u32(port, "mipi-sdw-port-wordlength-configs");
175	if (nval > 0) {
176
177		dp0->num_words = nval;
178		dp0->words = devm_kcalloc(&slave->dev,
179					  dp0->num_words, sizeof(*dp0->words),
180					  GFP_KERNEL);
181		if (!dp0->words)
182			return -ENOMEM;
183
184		ret = fwnode_property_read_u32_array(port,
185				"mipi-sdw-port-wordlength-configs",
186				dp0->words, dp0->num_words);
187		if (ret < 0)
188			return ret;
189	}
190
191	dp0->BRA_flow_controlled = mipi_fwnode_property_read_bool(port,
192				"mipi-sdw-bra-flow-controlled");
193
194	dp0->simple_ch_prep_sm = mipi_fwnode_property_read_bool(port,
195				"mipi-sdw-simplified-channel-prepare-sm");
196
197	dp0->imp_def_interrupts = mipi_fwnode_property_read_bool(port,
198				"mipi-sdw-imp-def-dp0-interrupts-supported");
199
200	nval = fwnode_property_count_u32(port, "mipi-sdw-lane-list");
201	if (nval > 0) {
202		dp0->num_lanes = nval;
203		dp0->lane_list = devm_kcalloc(&slave->dev,
204					      dp0->num_lanes, sizeof(*dp0->lane_list),
205					      GFP_KERNEL);
206		if (!dp0->lane_list)
207			return -ENOMEM;
208
209		ret = fwnode_property_read_u32_array(port,
210					       "mipi-sdw-lane-list",
211					       dp0->lane_list, dp0->num_lanes);
212		if (ret < 0)
213			return ret;
214	}
215
216	return 0;
217}
218
219static int sdw_slave_read_dpn(struct sdw_slave *slave,
220			      struct sdw_dpn_prop *dpn, int count, int ports,
221			      char *type)
222{
223	struct fwnode_handle *node;
224	u32 bit, i = 0;
225	unsigned long addr;
226	char name[40];
227	int nval;
228	int ret;
229
230	addr = ports;
231	/* valid ports are 1 to 14 so apply mask */
232	addr &= GENMASK(14, 1);
233
234	for_each_set_bit(bit, &addr, 32) {
235		snprintf(name, sizeof(name),
236			 "mipi-sdw-dp-%d-%s-subproperties", bit, type);
237
238		dpn[i].num = bit;
239
240		node = device_get_named_child_node(&slave->dev, name);
241		if (!node) {
242			dev_err(&slave->dev, "%s dpN not found\n", name);
243			return -EIO;
244		}
245
246		fwnode_property_read_u32(node, "mipi-sdw-port-max-wordlength",
247					 &dpn[i].max_word);
248		fwnode_property_read_u32(node, "mipi-sdw-port-min-wordlength",
249					 &dpn[i].min_word);
250
251		nval = fwnode_property_count_u32(node, "mipi-sdw-port-wordlength-configs");
252		if (nval > 0) {
253			dpn[i].num_words = nval;
254			dpn[i].words = devm_kcalloc(&slave->dev,
255						    dpn[i].num_words,
256						    sizeof(*dpn[i].words),
257						    GFP_KERNEL);
258			if (!dpn[i].words) {
259				fwnode_handle_put(node);
260				return -ENOMEM;
261			}
262
263			ret = fwnode_property_read_u32_array(node,
264					"mipi-sdw-port-wordlength-configs",
265					dpn[i].words, dpn[i].num_words);
266			if (ret < 0)
267				return ret;
268		}
269
270		fwnode_property_read_u32(node, "mipi-sdw-data-port-type",
271					 &dpn[i].type);
272
273		fwnode_property_read_u32(node,
274					 "mipi-sdw-max-grouping-supported",
275					 &dpn[i].max_grouping);
276
277		dpn[i].simple_ch_prep_sm = mipi_fwnode_property_read_bool(node,
278				"mipi-sdw-simplified-channelprepare-sm");
279
280		fwnode_property_read_u32(node,
281					 "mipi-sdw-port-channelprepare-timeout",
282					 &dpn[i].ch_prep_timeout);
283
284		fwnode_property_read_u32(node,
285				"mipi-sdw-imp-def-dpn-interrupts-supported",
286				&dpn[i].imp_def_interrupts);
287
288		fwnode_property_read_u32(node, "mipi-sdw-min-channel-number",
289					 &dpn[i].min_ch);
290
291		fwnode_property_read_u32(node, "mipi-sdw-max-channel-number",
292					 &dpn[i].max_ch);
293
294		nval = fwnode_property_count_u32(node, "mipi-sdw-channel-number-list");
295		if (nval > 0) {
296			dpn[i].num_channels = nval;
297			dpn[i].channels = devm_kcalloc(&slave->dev,
298						       dpn[i].num_channels,
299						       sizeof(*dpn[i].channels),
300						 GFP_KERNEL);
301			if (!dpn[i].channels) {
302				fwnode_handle_put(node);
303				return -ENOMEM;
304			}
305
306			ret = fwnode_property_read_u32_array(node,
307					"mipi-sdw-channel-number-list",
308					dpn[i].channels, dpn[i].num_channels);
309			if (ret < 0)
310				return ret;
311		}
312
313		nval = fwnode_property_count_u32(node, "mipi-sdw-channel-combination-list");
314		if (nval > 0) {
315			dpn[i].num_ch_combinations = nval;
316			dpn[i].ch_combinations = devm_kcalloc(&slave->dev,
317					dpn[i].num_ch_combinations,
318					sizeof(*dpn[i].ch_combinations),
319					GFP_KERNEL);
320			if (!dpn[i].ch_combinations) {
321				fwnode_handle_put(node);
322				return -ENOMEM;
323			}
324
325			ret = fwnode_property_read_u32_array(node,
326					"mipi-sdw-channel-combination-list",
327					dpn[i].ch_combinations,
328					dpn[i].num_ch_combinations);
329			if (ret < 0)
330				return ret;
331		}
332
333		fwnode_property_read_u32(node,
334				"mipi-sdw-modes-supported", &dpn[i].modes);
335
336		fwnode_property_read_u32(node, "mipi-sdw-max-async-buffer",
337					 &dpn[i].max_async_buffer);
338
339		dpn[i].block_pack_mode = mipi_fwnode_property_read_bool(node,
340				"mipi-sdw-block-packing-mode");
341
342		fwnode_property_read_u32(node, "mipi-sdw-port-encoding-type",
343					 &dpn[i].port_encoding);
344
345		nval = fwnode_property_count_u32(node, "mipi-sdw-lane-list");
346		if (nval > 0) {
347			dpn[i].num_lanes = nval;
348			dpn[i].lane_list = devm_kcalloc(&slave->dev,
349							dpn[i].num_lanes, sizeof(*dpn[i].lane_list),
350							GFP_KERNEL);
351			if (!dpn[i].lane_list)
352				return -ENOMEM;
353
354			ret = fwnode_property_read_u32_array(node,
355						       "mipi-sdw-lane-list",
356						       dpn[i].lane_list, dpn[i].num_lanes);
357			if (ret < 0)
358				return ret;
359		}
360
361		fwnode_handle_put(node);
362
363		i++;
364	}
365
366	return 0;
367}
368
369/*
370 * In MIPI DisCo spec for SoundWire, lane mapping for a slave device is done with
371 * mipi-sdw-lane-x-mapping properties, where x is 1..7, and the values for those
372 * properties are mipi-sdw-manager-lane-x or mipi-sdw-peripheral-link-y, where x
373 * is an integer between 1 to 7 if the lane is connected to a manager lane, y is a
374 * character between A to E if the lane is connected to another peripheral lane.
375 */
376int sdw_slave_read_lane_mapping(struct sdw_slave *slave)
377{
378	struct sdw_slave_prop *prop = &slave->prop;
379	struct device *dev = &slave->dev;
380	char prop_name[30];
381	const char *prop_val;
382	size_t len;
383	int ret, i;
384	u8 lane;
385
386	for (i = 0; i < SDW_MAX_LANES; i++) {
387		snprintf(prop_name, sizeof(prop_name), "mipi-sdw-lane-%d-mapping", i);
388		ret = device_property_read_string(dev, prop_name, &prop_val);
389		if (ret)
390			continue;
391
392		len = strlen(prop_val);
393		if (len < 1)
394			return -EINVAL;
395
396		/* The last character is enough to identify the connection */
397		ret = kstrtou8(&prop_val[len - 1], 10, &lane);
398		if (ret)
399			return ret;
400		if (in_range(lane, 1, SDW_MAX_LANES - 1))
401			prop->lane_maps[i] = lane;
402	}
403	return 0;
404}
405EXPORT_SYMBOL(sdw_slave_read_lane_mapping);
406
407/**
408 * sdw_slave_read_prop() - Read Slave properties
409 * @slave: SDW Slave
410 */
411int sdw_slave_read_prop(struct sdw_slave *slave)
412{
413	struct sdw_slave_prop *prop = &slave->prop;
414	struct device *dev = &slave->dev;
415	struct fwnode_handle *port;
416	int nval;
417	int ret;
418
419	device_property_read_u32(dev, "mipi-sdw-sw-interface-revision",
420				 &prop->mipi_revision);
421
422	prop->wake_capable = mipi_device_property_read_bool(dev,
423				"mipi-sdw-wake-up-unavailable");
424	prop->wake_capable = !prop->wake_capable;
425
426	prop->test_mode_capable = mipi_device_property_read_bool(dev,
427				"mipi-sdw-test-mode-supported");
428
429	prop->clk_stop_mode1 = false;
430	if (mipi_device_property_read_bool(dev,
431				"mipi-sdw-clock-stop-mode1-supported"))
432		prop->clk_stop_mode1 = true;
433
434	prop->simple_clk_stop_capable = mipi_device_property_read_bool(dev,
435			"mipi-sdw-simplified-clockstopprepare-sm-supported");
436
437	device_property_read_u32(dev, "mipi-sdw-clockstopprepare-timeout",
438				 &prop->clk_stop_timeout);
439
440	ret = device_property_read_u32(dev, "mipi-sdw-peripheral-channelprepare-timeout",
441				       &prop->ch_prep_timeout);
442	if (ret < 0)
443		device_property_read_u32(dev, "mipi-sdw-slave-channelprepare-timeout",
444					 &prop->ch_prep_timeout);
445
446	device_property_read_u32(dev,
447			"mipi-sdw-clockstopprepare-hard-reset-behavior",
448			&prop->reset_behave);
449
450	prop->high_PHY_capable = mipi_device_property_read_bool(dev,
451			"mipi-sdw-highPHY-capable");
452
453	prop->paging_support = mipi_device_property_read_bool(dev,
454			"mipi-sdw-paging-supported");
455
456	prop->bank_delay_support = mipi_device_property_read_bool(dev,
457			"mipi-sdw-bank-delay-supported");
458
459	device_property_read_u32(dev,
460			"mipi-sdw-port15-read-behavior", &prop->p15_behave);
461
462	device_property_read_u32(dev, "mipi-sdw-master-count",
463				 &prop->master_count);
464
465	device_property_read_u32(dev, "mipi-sdw-source-port-list",
466				 &prop->source_ports);
467
468	device_property_read_u32(dev, "mipi-sdw-sink-port-list",
469				 &prop->sink_ports);
470
471	device_property_read_u32(dev, "mipi-sdw-sdca-interrupt-register-list",
472				 &prop->sdca_interrupt_register_list);
473
474	prop->commit_register_supported = mipi_device_property_read_bool(dev,
475			"mipi-sdw-commit-register-supported");
476
477	/*
478	 * Read dp0 properties - we don't rely on the 'mipi-sdw-dp-0-supported'
479	 * property since the 'mipi-sdw-dp0-subproperties' property is logically
480	 * equivalent.
481	 */
482	port = device_get_named_child_node(dev, "mipi-sdw-dp-0-subproperties");
483	if (!port) {
484		dev_dbg(dev, "DP0 node not found!!\n");
485	} else {
486		prop->dp0_prop = devm_kzalloc(&slave->dev,
487					      sizeof(*prop->dp0_prop),
488					      GFP_KERNEL);
489		if (!prop->dp0_prop) {
490			fwnode_handle_put(port);
491			return -ENOMEM;
492		}
493
494		sdw_slave_read_dp0(slave, port, prop->dp0_prop);
495
496		fwnode_handle_put(port);
497	}
498
499	/*
500	 * Based on each DPn port, get source and sink dpn properties.
501	 * Also, some ports can operate as both source or sink.
502	 */
503
504	/* Allocate memory for set bits in port lists */
505	nval = hweight32(prop->source_ports);
506	prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
507					  sizeof(*prop->src_dpn_prop),
508					  GFP_KERNEL);
509	if (!prop->src_dpn_prop)
510		return -ENOMEM;
511
512	/* Read dpn properties for source port(s) */
513	sdw_slave_read_dpn(slave, prop->src_dpn_prop, nval,
514			   prop->source_ports, "source");
515
516	nval = hweight32(prop->sink_ports);
517	prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
518					   sizeof(*prop->sink_dpn_prop),
519					   GFP_KERNEL);
520	if (!prop->sink_dpn_prop)
521		return -ENOMEM;
522
523	/* Read dpn properties for sink port(s) */
524	sdw_slave_read_dpn(slave, prop->sink_dpn_prop, nval,
525			   prop->sink_ports, "sink");
526
527	return sdw_slave_read_lane_mapping(slave);
528}
529EXPORT_SYMBOL(sdw_slave_read_prop);