ipu-bridge.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Author: Dan Scally <djrscally@gmail.com> */
  3
  4#include <linux/acpi.h>
  5#include <acpi/acpi_bus.h>
  6#include <linux/cleanup.h>
  7#include <linux/device.h>
  8#include <linux/dmi.h>
  9#include <linux/i2c.h>
 10#include <linux/mei_cl_bus.h>
 11#include <linux/platform_device.h>
 12#include <linux/pm_runtime.h>
 13#include <linux/property.h>
 14#include <linux/string.h>
 15#include <linux/workqueue.h>
 16
 17#include <media/ipu-bridge.h>
 18#include <media/v4l2-fwnode.h>
 19
 20#define ADEV_DEV(adev) ACPI_PTR(&((adev)->dev))
 21
 22/*
 23 * 92335fcf-3203-4472-af93-7b4453ac29da
 24 *
 25 * Used to build MEI CSI device name to lookup MEI CSI device by
 26 * device_find_child_by_name().
 27 */
 28#define MEI_CSI_UUID							\
 29	UUID_LE(0x92335FCF, 0x3203, 0x4472,				\
 30		0xAF, 0x93, 0x7B, 0x44, 0x53, 0xAC, 0x29, 0xDA)
 31
 32/*
 33 * IVSC device name
 34 *
 35 * Used to match IVSC device by ipu_bridge_match_ivsc_dev()
 36 */
 37#define IVSC_DEV_NAME "intel_vsc"
 38
 39/*
 40 * Extend this array with ACPI Hardware IDs of devices known to be working
 41 * plus the number of link-frequencies expected by their drivers, along with
 42 * the frequency values in hertz. This is somewhat opportunistic way of adding
 43 * support for this for now in the hopes of a better source for the information
 44 * (possibly some encoded value in the SSDB buffer that we're unaware of)
 45 * becoming apparent in the future.
 46 *
 47 * Do not add an entry for a sensor that is not actually supported.
 48 *
 49 * Please keep the list sorted by ACPI HID.
 50 */
 51static const struct ipu_sensor_config ipu_supported_sensors[] = {
 52	/* Himax HM11B1 */
 53	IPU_SENSOR_CONFIG("HIMX11B1", 1, 384000000),
 54	/* Himax HM2170 */
 55	IPU_SENSOR_CONFIG("HIMX2170", 1, 384000000),
 56	/* Himax HM2172 */
 57	IPU_SENSOR_CONFIG("HIMX2172", 1, 384000000),
 58	/* GalaxyCore GC0310 */
 59	IPU_SENSOR_CONFIG("INT0310", 1, 55692000),
 60	/* Omnivision OV5693 */
 61	IPU_SENSOR_CONFIG("INT33BE", 1, 419200000),
 62	/* Onsemi MT9M114 */
 63	IPU_SENSOR_CONFIG("INT33F0", 1, 384000000),
 64	/* Omnivision OV2740 */
 65	IPU_SENSOR_CONFIG("INT3474", 1, 180000000),
 66	/* Omnivision OV5670 */
 67	IPU_SENSOR_CONFIG("INT3479", 1, 422400000),
 68	/* Omnivision OV8865 */
 69	IPU_SENSOR_CONFIG("INT347A", 1, 360000000),
 70	/* Omnivision OV7251 */
 71	IPU_SENSOR_CONFIG("INT347E", 1, 319200000),
 72	/* Hynix Hi-556 */
 73	IPU_SENSOR_CONFIG("INT3537", 1, 437000000),
 74	/* Lontium lt6911uxe */
 75	IPU_SENSOR_CONFIG("INTC10C5", 0),
 76	/* Omnivision OV01A10 / OV01A1S */
 77	IPU_SENSOR_CONFIG("OVTI01A0", 1, 400000000),
 78	IPU_SENSOR_CONFIG("OVTI01AS", 1, 400000000),
 79	/* Omnivision OV02C10 */
 80	IPU_SENSOR_CONFIG("OVTI02C1", 1, 400000000),
 81	/* Omnivision OV02E10 */
 82	IPU_SENSOR_CONFIG("OVTI02E1", 1, 360000000),
 83	/* Omnivision ov05c10 */
 84	IPU_SENSOR_CONFIG("OVTI05C1", 1, 480000000),
 85	/* Omnivision OV08A10 */
 86	IPU_SENSOR_CONFIG("OVTI08A1", 1, 500000000),
 87	/* Omnivision OV08x40 */
 88	IPU_SENSOR_CONFIG("OVTI08F4", 3, 400000000, 749000000, 800000000),
 89	/* Omnivision OV13B10 */
 90	IPU_SENSOR_CONFIG("OVTI13B1", 1, 560000000),
 91	IPU_SENSOR_CONFIG("OVTIDB10", 1, 560000000),
 92	/* Omnivision OV2680 */
 93	IPU_SENSOR_CONFIG("OVTI2680", 1, 331200000),
 94	/* Omnivision OV8856 */
 95	IPU_SENSOR_CONFIG("OVTI8856", 3, 180000000, 360000000, 720000000),
 96	/* Sony IMX471 */
 97	IPU_SENSOR_CONFIG("SONY471A", 1, 200000000),
 98	/* Toshiba T4KA3 */
 99	IPU_SENSOR_CONFIG("XMCC0003", 1, 321468000),
100};
101
102/*
103 * DMI matches for laptops which have their sensor mounted upside-down
104 * without reporting a rotation of 180° in neither the SSDB nor the _PLD.
105 */
106static const struct dmi_system_id upside_down_sensor_dmi_ids[] = {
107	{
108		.matches = {
109			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
110			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 13 9350"),
111		},
112		.driver_data = "OVTI02C1",
113	},
114	{
115		.matches = {
116			DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
117			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "XPS 16 9640"),
118		},
119		.driver_data = "OVTI02C1",
120	},
121	{} /* Terminating entry */
122};
123
124static const struct ipu_property_names prop_names = {
125	.clock_frequency = "clock-frequency",
126	.rotation = "rotation",
127	.orientation = "orientation",
128	.bus_type = "bus-type",
129	.data_lanes = "data-lanes",
130	.remote_endpoint = "remote-endpoint",
131	.link_frequencies = "link-frequencies",
132};
133
134static const char * const ipu_vcm_types[] = {
135	"ad5823",
136	"dw9714",
137	"ad5816",
138	"dw9719",
139	"dw9718",
140	"dw9806b",
141	"wv517s",
142	"lc898122xa",
143	"lc898212axb",
144};
145
146/*
147 * Used to figure out IVSC acpi device by ipu_bridge_get_ivsc_acpi_dev()
148 * instead of device and driver match to probe IVSC device.
149 */
150static const struct acpi_device_id ivsc_acpi_ids[] = {
151	{ "INTC1059" },
152	{ "INTC1095" },
153	{ "INTC100A" },
154	{ "INTC10CF" },
155};
156
157static struct acpi_device *ipu_bridge_get_ivsc_acpi_dev(struct acpi_device *adev)
158{
159	unsigned int i;
160
161	for (i = 0; i < ARRAY_SIZE(ivsc_acpi_ids); i++) {
162		const struct acpi_device_id *acpi_id = &ivsc_acpi_ids[i];
163		struct acpi_device *consumer, *ivsc_adev;
164
165		acpi_handle handle = acpi_device_handle(ACPI_PTR(adev));
166		for_each_acpi_dev_match(ivsc_adev, acpi_id->id, NULL, -1)
167			/* camera sensor depends on IVSC in DSDT if exist */
168			for_each_acpi_consumer_dev(ivsc_adev, consumer)
169				if (ACPI_PTR(consumer->handle) == handle) {
170					acpi_dev_put(consumer);
171					return ivsc_adev;
172				}
173	}
174
175	return NULL;
176}
177
178static int ipu_bridge_match_ivsc_dev(struct device *dev, const void *adev)
179{
180	if (ACPI_COMPANION(dev) != adev)
181		return 0;
182
183	if (!sysfs_streq(dev_name(dev), IVSC_DEV_NAME))
184		return 0;
185
186	return 1;
187}
188
189static struct device *ipu_bridge_get_ivsc_csi_dev(struct acpi_device *adev)
190{
191	struct device *dev, *csi_dev;
192	uuid_le uuid = MEI_CSI_UUID;
193	char name[64];
194
195	/* IVSC device on platform bus */
196	dev = bus_find_device(&platform_bus_type, NULL, adev,
197			      ipu_bridge_match_ivsc_dev);
198	if (dev) {
199		snprintf(name, sizeof(name), "%s-%pUl", dev_name(dev), &uuid);
200
201		csi_dev = device_find_child_by_name(dev, name);
202
203		put_device(dev);
204
205		return csi_dev;
206	}
207
208	return NULL;
209}
210
211static int ipu_bridge_check_ivsc_dev(struct ipu_sensor *sensor,
212				     struct acpi_device *sensor_adev)
213{
214	struct acpi_device *adev;
215	struct device *csi_dev;
216
217	adev = ipu_bridge_get_ivsc_acpi_dev(sensor_adev);
218	if (adev) {
219		csi_dev = ipu_bridge_get_ivsc_csi_dev(adev);
220		if (!csi_dev) {
221			acpi_dev_put(adev);
222			dev_err(ADEV_DEV(adev), "Failed to find MEI CSI dev\n");
223			return -ENODEV;
224		}
225
226		sensor->csi_dev = csi_dev;
227		sensor->ivsc_adev = adev;
228	}
229
230	return 0;
231}
232
233static int ipu_bridge_read_acpi_buffer(struct acpi_device *adev, char *id,
234				       void *data, u32 size)
235{
236	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
237	union acpi_object *obj;
238	acpi_status status;
239	int ret = 0;
240
241	status = acpi_evaluate_object(ACPI_PTR(adev->handle),
242				      id, NULL, &buffer);
243	if (ACPI_FAILURE(status))
244		return -ENODEV;
245
246	obj = buffer.pointer;
247	if (!obj) {
248		dev_err(ADEV_DEV(adev), "Couldn't locate ACPI buffer\n");
249		return -ENODEV;
250	}
251
252	if (obj->type != ACPI_TYPE_BUFFER) {
253		dev_err(ADEV_DEV(adev), "Not an ACPI buffer\n");
254		ret = -ENODEV;
255		goto out_free_buff;
256	}
257
258	if (obj->buffer.length > size) {
259		dev_err(ADEV_DEV(adev), "Given buffer is too small\n");
260		ret = -EINVAL;
261		goto out_free_buff;
262	}
263
264	memcpy(data, obj->buffer.pointer, obj->buffer.length);
265
266out_free_buff:
267	kfree(buffer.pointer);
268	return ret;
269}
270
271static u32 ipu_bridge_parse_rotation(struct acpi_device *adev,
272				     struct ipu_sensor_ssdb *ssdb)
273{
274	const struct dmi_system_id *dmi_id;
275
276	dmi_id = dmi_first_match(upside_down_sensor_dmi_ids);
277	if (dmi_id && acpi_dev_hid_match(adev, dmi_id->driver_data))
278		return 180;
279
280	switch (ssdb->degree) {
281	case IPU_SENSOR_ROTATION_NORMAL:
282		return 0;
283	case IPU_SENSOR_ROTATION_INVERTED:
284		return 180;
285	default:
286		dev_warn(ADEV_DEV(adev),
287			 "Unknown rotation %d. Assume 0 degree rotation\n",
288			 ssdb->degree);
289		return 0;
290	}
291}
292
293static enum v4l2_fwnode_orientation ipu_bridge_parse_orientation(struct acpi_device *adev)
294{
295	enum v4l2_fwnode_orientation orientation;
296	struct acpi_pld_info *pld = NULL;
297
298	if (!acpi_get_physical_device_location(ACPI_PTR(adev->handle), &pld)) {
299		dev_warn(ADEV_DEV(adev), "_PLD call failed, using default orientation\n");
300		return V4L2_FWNODE_ORIENTATION_EXTERNAL;
301	}
302
303	switch (pld->panel) {
304	case ACPI_PLD_PANEL_FRONT:
305		orientation = V4L2_FWNODE_ORIENTATION_FRONT;
306		break;
307	case ACPI_PLD_PANEL_BACK:
308		orientation = V4L2_FWNODE_ORIENTATION_BACK;
309		break;
310	case ACPI_PLD_PANEL_TOP:
311	case ACPI_PLD_PANEL_LEFT:
312	case ACPI_PLD_PANEL_RIGHT:
313	case ACPI_PLD_PANEL_UNKNOWN:
314		orientation = V4L2_FWNODE_ORIENTATION_EXTERNAL;
315		break;
316	default:
317		dev_warn(ADEV_DEV(adev), "Unknown _PLD panel val %d\n",
318			 pld->panel);
319		orientation = V4L2_FWNODE_ORIENTATION_EXTERNAL;
320		break;
321	}
322
323	ACPI_FREE(pld);
324	return orientation;
325}
326
327int ipu_bridge_parse_ssdb(struct acpi_device *adev, struct ipu_sensor *sensor)
328{
329	struct ipu_sensor_ssdb ssdb = {};
330	int ret;
331
332	ret = ipu_bridge_read_acpi_buffer(adev, "SSDB", &ssdb, sizeof(ssdb));
333	if (ret)
334		return ret;
335
336	if (ssdb.vcmtype > ARRAY_SIZE(ipu_vcm_types)) {
337		dev_warn(ADEV_DEV(adev), "Unknown VCM type %d\n", ssdb.vcmtype);
338		ssdb.vcmtype = 0;
339	}
340
341	if (ssdb.lanes > IPU_MAX_LANES) {
342		dev_err(ADEV_DEV(adev), "Number of lanes in SSDB is invalid\n");
343		return -EINVAL;
344	}
345
346	sensor->link = ssdb.link;
347	sensor->lanes = ssdb.lanes;
348	sensor->mclkspeed = ssdb.mclkspeed;
349	sensor->rotation = ipu_bridge_parse_rotation(adev, &ssdb);
350	sensor->orientation = ipu_bridge_parse_orientation(adev);
351
352	if (ssdb.vcmtype)
353		sensor->vcm_type = ipu_vcm_types[ssdb.vcmtype - 1];
354
355	return 0;
356}
357EXPORT_SYMBOL_NS_GPL(ipu_bridge_parse_ssdb, "INTEL_IPU_BRIDGE");
358
359static void ipu_bridge_create_fwnode_properties(
360	struct ipu_sensor *sensor,
361	struct ipu_bridge *bridge,
362	const struct ipu_sensor_config *cfg)
363{
364	struct ipu_property_names *names = &sensor->prop_names;
365	struct software_node *nodes = sensor->swnodes;
366
367	sensor->prop_names = prop_names;
368
369	if (sensor->csi_dev) {
370		sensor->local_ref[0] =
371			SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IVSC_SENSOR_ENDPOINT]);
372		sensor->remote_ref[0] =
373			SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IVSC_IPU_ENDPOINT]);
374		sensor->ivsc_sensor_ref[0] =
375			SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_SENSOR_ENDPOINT]);
376		sensor->ivsc_ipu_ref[0] =
377			SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IPU_ENDPOINT]);
378
379		sensor->ivsc_sensor_ep_properties[0] =
380			PROPERTY_ENTRY_U32(names->bus_type,
381					   V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
382		sensor->ivsc_sensor_ep_properties[1] =
383			PROPERTY_ENTRY_U32_ARRAY_LEN(names->data_lanes,
384						     bridge->data_lanes,
385						     sensor->lanes);
386		sensor->ivsc_sensor_ep_properties[2] =
387			PROPERTY_ENTRY_REF_ARRAY(names->remote_endpoint,
388						 sensor->ivsc_sensor_ref);
389
390		sensor->ivsc_ipu_ep_properties[0] =
391			PROPERTY_ENTRY_U32(names->bus_type,
392					   V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
393		sensor->ivsc_ipu_ep_properties[1] =
394			PROPERTY_ENTRY_U32_ARRAY_LEN(names->data_lanes,
395						     bridge->data_lanes,
396						     sensor->lanes);
397		sensor->ivsc_ipu_ep_properties[2] =
398			PROPERTY_ENTRY_REF_ARRAY(names->remote_endpoint,
399						 sensor->ivsc_ipu_ref);
400	} else {
401		sensor->local_ref[0] =
402			SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_IPU_ENDPOINT]);
403		sensor->remote_ref[0] =
404			SOFTWARE_NODE_REFERENCE(&nodes[SWNODE_SENSOR_ENDPOINT]);
405	}
406
407	sensor->dev_properties[0] = PROPERTY_ENTRY_U32(
408					sensor->prop_names.clock_frequency,
409					sensor->mclkspeed);
410	sensor->dev_properties[1] = PROPERTY_ENTRY_U32(
411					sensor->prop_names.rotation,
412					sensor->rotation);
413	sensor->dev_properties[2] = PROPERTY_ENTRY_U32(
414					sensor->prop_names.orientation,
415					sensor->orientation);
416	if (sensor->vcm_type) {
417		sensor->vcm_ref[0] =
418			SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_VCM]);
419		sensor->dev_properties[3] =
420			PROPERTY_ENTRY_REF_ARRAY("lens-focus", sensor->vcm_ref);
421	}
422
423	sensor->ep_properties[0] = PROPERTY_ENTRY_U32(
424					sensor->prop_names.bus_type,
425					V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
426	sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN(
427					sensor->prop_names.data_lanes,
428					bridge->data_lanes, sensor->lanes);
429	sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY(
430					sensor->prop_names.remote_endpoint,
431					sensor->local_ref);
432
433	if (cfg->nr_link_freqs > 0)
434		sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN(
435			sensor->prop_names.link_frequencies,
436			cfg->link_freqs,
437			cfg->nr_link_freqs);
438
439	sensor->ipu_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN(
440					sensor->prop_names.data_lanes,
441					bridge->data_lanes, sensor->lanes);
442	sensor->ipu_properties[1] = PROPERTY_ENTRY_REF_ARRAY(
443					sensor->prop_names.remote_endpoint,
444					sensor->remote_ref);
445}
446
447static void ipu_bridge_init_swnode_names(struct ipu_sensor *sensor)
448{
449	snprintf(sensor->node_names.remote_port,
450		 sizeof(sensor->node_names.remote_port),
451		 SWNODE_GRAPH_PORT_NAME_FMT, sensor->link);
452	snprintf(sensor->node_names.port,
453		 sizeof(sensor->node_names.port),
454		 SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */
455	snprintf(sensor->node_names.endpoint,
456		 sizeof(sensor->node_names.endpoint),
457		 SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */
458	if (sensor->vcm_type) {
459		/* append link to distinguish nodes with same model VCM */
460		snprintf(sensor->node_names.vcm, sizeof(sensor->node_names.vcm),
461			 "%s-%u", sensor->vcm_type, sensor->link);
462	}
463
464	if (sensor->csi_dev) {
465		snprintf(sensor->node_names.ivsc_sensor_port,
466			 sizeof(sensor->node_names.ivsc_sensor_port),
467			 SWNODE_GRAPH_PORT_NAME_FMT, 0);
468		snprintf(sensor->node_names.ivsc_ipu_port,
469			 sizeof(sensor->node_names.ivsc_ipu_port),
470			 SWNODE_GRAPH_PORT_NAME_FMT, 1);
471	}
472}
473
474static void ipu_bridge_init_swnode_group(struct ipu_sensor *sensor)
475{
476	struct software_node *nodes = sensor->swnodes;
477
478	sensor->group[SWNODE_SENSOR_HID] = &nodes[SWNODE_SENSOR_HID];
479	sensor->group[SWNODE_SENSOR_PORT] = &nodes[SWNODE_SENSOR_PORT];
480	sensor->group[SWNODE_SENSOR_ENDPOINT] = &nodes[SWNODE_SENSOR_ENDPOINT];
481	sensor->group[SWNODE_IPU_PORT] = &nodes[SWNODE_IPU_PORT];
482	sensor->group[SWNODE_IPU_ENDPOINT] = &nodes[SWNODE_IPU_ENDPOINT];
483	if (sensor->vcm_type)
484		sensor->group[SWNODE_VCM] =  &nodes[SWNODE_VCM];
485
486	if (sensor->csi_dev) {
487		sensor->group[SWNODE_IVSC_HID] =
488					&nodes[SWNODE_IVSC_HID];
489		sensor->group[SWNODE_IVSC_SENSOR_PORT] =
490					&nodes[SWNODE_IVSC_SENSOR_PORT];
491		sensor->group[SWNODE_IVSC_SENSOR_ENDPOINT] =
492					&nodes[SWNODE_IVSC_SENSOR_ENDPOINT];
493		sensor->group[SWNODE_IVSC_IPU_PORT] =
494					&nodes[SWNODE_IVSC_IPU_PORT];
495		sensor->group[SWNODE_IVSC_IPU_ENDPOINT] =
496					&nodes[SWNODE_IVSC_IPU_ENDPOINT];
497
498		if (sensor->vcm_type)
499			sensor->group[SWNODE_VCM] = &nodes[SWNODE_VCM];
500	} else {
501		if (sensor->vcm_type)
502			sensor->group[SWNODE_IVSC_HID] = &nodes[SWNODE_VCM];
503	}
504}
505
506static void ipu_bridge_create_connection_swnodes(struct ipu_bridge *bridge,
507						 struct ipu_sensor *sensor)
508{
509	struct ipu_node_names *names = &sensor->node_names;
510	struct software_node *nodes = sensor->swnodes;
511
512	ipu_bridge_init_swnode_names(sensor);
513
514	nodes[SWNODE_SENSOR_HID] = NODE_SENSOR(sensor->name,
515					       sensor->dev_properties);
516	nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port,
517					      &nodes[SWNODE_SENSOR_HID]);
518	nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT(
519						sensor->node_names.endpoint,
520						&nodes[SWNODE_SENSOR_PORT],
521						sensor->ep_properties);
522	nodes[SWNODE_IPU_PORT] = NODE_PORT(sensor->node_names.remote_port,
523					   &bridge->ipu_hid_node);
524	nodes[SWNODE_IPU_ENDPOINT] = NODE_ENDPOINT(
525						sensor->node_names.endpoint,
526						&nodes[SWNODE_IPU_PORT],
527						sensor->ipu_properties);
528
529	if (sensor->csi_dev) {
530		const char *device_hid = "";
531
532		device_hid = acpi_device_hid(sensor->ivsc_adev);
533
534		snprintf(sensor->ivsc_name, sizeof(sensor->ivsc_name), "%s-%u",
535			 device_hid, sensor->link);
536
537		nodes[SWNODE_IVSC_HID] = NODE_SENSOR(sensor->ivsc_name,
538						     sensor->ivsc_properties);
539		nodes[SWNODE_IVSC_SENSOR_PORT] =
540				NODE_PORT(names->ivsc_sensor_port,
541					  &nodes[SWNODE_IVSC_HID]);
542		nodes[SWNODE_IVSC_SENSOR_ENDPOINT] =
543				NODE_ENDPOINT(names->endpoint,
544					      &nodes[SWNODE_IVSC_SENSOR_PORT],
545					      sensor->ivsc_sensor_ep_properties);
546		nodes[SWNODE_IVSC_IPU_PORT] =
547				NODE_PORT(names->ivsc_ipu_port,
548					  &nodes[SWNODE_IVSC_HID]);
549		nodes[SWNODE_IVSC_IPU_ENDPOINT] =
550				NODE_ENDPOINT(names->endpoint,
551					      &nodes[SWNODE_IVSC_IPU_PORT],
552					      sensor->ivsc_ipu_ep_properties);
553	}
554
555	nodes[SWNODE_VCM] = NODE_VCM(sensor->node_names.vcm);
556
557	ipu_bridge_init_swnode_group(sensor);
558}
559
560/*
561 * The actual instantiation must be done from a workqueue to avoid
562 * a deadlock on taking list_lock from v4l2-async twice.
563 */
564struct ipu_bridge_instantiate_vcm_work_data {
565	struct work_struct work;
566	struct device *sensor;
567	char name[16];
568	struct i2c_board_info board_info;
569};
570
571static void ipu_bridge_instantiate_vcm_work(struct work_struct *work)
572{
573	struct ipu_bridge_instantiate_vcm_work_data *data =
574		container_of(work, struct ipu_bridge_instantiate_vcm_work_data,
575			     work);
576	struct acpi_device *adev = ACPI_COMPANION(data->sensor);
577	struct i2c_client *vcm_client;
578	bool put_fwnode = true;
579	int ret;
580
581	/*
582	 * The client may get probed before the device_link gets added below
583	 * make sure the sensor is powered-up during probe.
584	 */
585	ret = pm_runtime_get_sync(data->sensor);
586	if (ret < 0) {
587		dev_err(data->sensor, "Error %d runtime-resuming sensor, cannot instantiate VCM\n",
588			ret);
589		goto out_pm_put;
590	}
591
592	/*
593	 * Note the client is created only once and then kept around
594	 * even after a rmmod, just like the software-nodes.
595	 */
596	vcm_client = i2c_acpi_new_device_by_fwnode(acpi_fwnode_handle(adev),
597						   1, &data->board_info);
598	if (IS_ERR(vcm_client)) {
599		dev_err(data->sensor, "Error instantiating VCM client: %pe\n",
600			vcm_client);
601		goto out_pm_put;
602	}
603
604	device_link_add(&vcm_client->dev, data->sensor, DL_FLAG_PM_RUNTIME);
605
606	dev_info(data->sensor, "Instantiated %s VCM\n", data->board_info.type);
607	put_fwnode = false; /* Ownership has passed to the i2c-client */
608
609out_pm_put:
610	pm_runtime_put(data->sensor);
611	put_device(data->sensor);
612	if (put_fwnode)
613		fwnode_handle_put(data->board_info.fwnode);
614	kfree(data);
615}
616
617int ipu_bridge_instantiate_vcm(struct device *sensor)
618{
619	struct ipu_bridge_instantiate_vcm_work_data *data;
620	struct fwnode_handle *vcm_fwnode;
621	struct i2c_client *vcm_client;
622	struct acpi_device *adev;
623	char *sep;
624
625	adev = ACPI_COMPANION(sensor);
626	if (!adev)
627		return 0;
628
629	vcm_fwnode = fwnode_find_reference(dev_fwnode(sensor), "lens-focus", 0);
630	if (IS_ERR(vcm_fwnode))
631		return 0;
632
633	/* When reloading modules the client will already exist */
634	vcm_client = i2c_find_device_by_fwnode(vcm_fwnode);
635	if (vcm_client) {
636		fwnode_handle_put(vcm_fwnode);
637		put_device(&vcm_client->dev);
638		return 0;
639	}
640
641	data = kzalloc(sizeof(*data), GFP_KERNEL);
642	if (!data) {
643		fwnode_handle_put(vcm_fwnode);
644		return -ENOMEM;
645	}
646
647	INIT_WORK(&data->work, ipu_bridge_instantiate_vcm_work);
648	data->sensor = get_device(sensor);
649	snprintf(data->name, sizeof(data->name), "%s-VCM",
650		 acpi_dev_name(adev));
651	data->board_info.dev_name = data->name;
652	data->board_info.fwnode = vcm_fwnode;
653	snprintf(data->board_info.type, sizeof(data->board_info.type),
654		 "%pfwP", vcm_fwnode);
655	/* Strip "-<link>" postfix */
656	sep = strchrnul(data->board_info.type, '-');
657	*sep = 0;
658
659	queue_work(system_long_wq, &data->work);
660
661	return 0;
662}
663EXPORT_SYMBOL_NS_GPL(ipu_bridge_instantiate_vcm, "INTEL_IPU_BRIDGE");
664
665static int ipu_bridge_instantiate_ivsc(struct ipu_sensor *sensor)
666{
667	struct fwnode_handle *fwnode;
668
669	if (!sensor->csi_dev)
670		return 0;
671
672	fwnode = software_node_fwnode(&sensor->swnodes[SWNODE_IVSC_HID]);
673	if (!fwnode)
674		return -ENODEV;
675
676	set_secondary_fwnode(sensor->csi_dev, fwnode);
677
678	return 0;
679}
680
681static void ipu_bridge_unregister_sensors(struct ipu_bridge *bridge)
682{
683	struct ipu_sensor *sensor;
684	unsigned int i;
685
686	for (i = 0; i < bridge->n_sensors; i++) {
687		sensor = &bridge->sensors[i];
688		software_node_unregister_node_group(sensor->group);
689		acpi_dev_put(sensor->adev);
690		put_device(sensor->csi_dev);
691		acpi_dev_put(sensor->ivsc_adev);
692	}
693}
694
695static int ipu_bridge_connect_sensor(const struct ipu_sensor_config *cfg,
696				     struct ipu_bridge *bridge)
697{
698	struct fwnode_handle *fwnode, *primary;
699	struct ipu_sensor *sensor;
700	struct acpi_device *adev = NULL;
701	int ret;
702
703	for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
704		if (!ACPI_PTR(adev->status.enabled))
705			continue;
706
707		if (bridge->n_sensors >= IPU_MAX_PORTS) {
708			acpi_dev_put(adev);
709			dev_err(bridge->dev, "Exceeded available IPU ports\n");
710			return -EINVAL;
711		}
712
713		sensor = &bridge->sensors[bridge->n_sensors];
714
715		ret = bridge->parse_sensor_fwnode(adev, sensor);
716		if (ret)
717			goto err_put_adev;
718
719		snprintf(sensor->name, sizeof(sensor->name), "%s-%u",
720			 cfg->hid, sensor->link);
721
722		ret = ipu_bridge_check_ivsc_dev(sensor, adev);
723		if (ret)
724			goto err_put_adev;
725
726		ipu_bridge_create_fwnode_properties(sensor, bridge, cfg);
727		ipu_bridge_create_connection_swnodes(bridge, sensor);
728
729		ret = software_node_register_node_group(sensor->group);
730		if (ret)
731			goto err_put_ivsc;
732
733		fwnode = software_node_fwnode(&sensor->swnodes[
734						      SWNODE_SENSOR_HID]);
735		if (!fwnode) {
736			ret = -ENODEV;
737			goto err_free_swnodes;
738		}
739
740		sensor->adev = ACPI_PTR(acpi_dev_get(adev));
741
742		primary = acpi_fwnode_handle(adev);
743		primary->secondary = fwnode;
744
745		ret = ipu_bridge_instantiate_ivsc(sensor);
746		if (ret)
747			goto err_free_swnodes;
748
749		dev_info(bridge->dev, "Found supported sensor %s\n",
750			 acpi_dev_name(adev));
751
752		bridge->n_sensors++;
753	}
754
755	return 0;
756
757err_free_swnodes:
758	software_node_unregister_node_group(sensor->group);
759err_put_ivsc:
760	put_device(sensor->csi_dev);
761	acpi_dev_put(sensor->ivsc_adev);
762err_put_adev:
763	acpi_dev_put(adev);
764	return ret;
765}
766
767static int ipu_bridge_connect_sensors(struct ipu_bridge *bridge)
768{
769	unsigned int i;
770	int ret;
771
772	for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) {
773		const struct ipu_sensor_config *cfg =
774			&ipu_supported_sensors[i];
775
776		ret = ipu_bridge_connect_sensor(cfg, bridge);
777		if (ret)
778			goto err_unregister_sensors;
779	}
780
781	return 0;
782
783err_unregister_sensors:
784	ipu_bridge_unregister_sensors(bridge);
785	return ret;
786}
787
788static int ipu_bridge_ivsc_is_ready(void)
789{
790	struct acpi_device *sensor_adev, *adev;
791	struct device *csi_dev;
792	bool ready = true;
793	unsigned int i;
794
795	for (i = 0; i < ARRAY_SIZE(ipu_supported_sensors); i++) {
796		const struct ipu_sensor_config *cfg =
797			&ipu_supported_sensors[i];
798
799		for_each_acpi_dev_match(sensor_adev, cfg->hid, NULL, -1) {
800			if (!ACPI_PTR(sensor_adev->status.enabled))
801				continue;
802
803			adev = ipu_bridge_get_ivsc_acpi_dev(sensor_adev);
804			if (!adev)
805				continue;
806
807			csi_dev = ipu_bridge_get_ivsc_csi_dev(adev);
808			if (!csi_dev)
809				ready = false;
810
811			put_device(csi_dev);
812			acpi_dev_put(adev);
813		}
814	}
815
816	return ready;
817}
818
819static int ipu_bridge_check_fwnode_graph(struct fwnode_handle *fwnode)
820{
821	struct fwnode_handle *endpoint;
822
823	if (IS_ERR_OR_NULL(fwnode))
824		return -EINVAL;
825
826	endpoint = fwnode_graph_get_next_endpoint(fwnode, NULL);
827	if (endpoint) {
828		fwnode_handle_put(endpoint);
829		return 0;
830	}
831
832	return ipu_bridge_check_fwnode_graph(fwnode->secondary);
833}
834
835static DEFINE_MUTEX(ipu_bridge_mutex);
836
837int ipu_bridge_init(struct device *dev,
838		    ipu_parse_sensor_fwnode_t parse_sensor_fwnode)
839{
840	struct fwnode_handle *fwnode;
841	struct ipu_bridge *bridge;
842	unsigned int i;
843	int ret;
844
845	guard(mutex)(&ipu_bridge_mutex);
846
847	if (!ipu_bridge_check_fwnode_graph(dev_fwnode(dev)))
848		return 0;
849
850	if (!ipu_bridge_ivsc_is_ready())
851		return dev_err_probe(dev, -EPROBE_DEFER,
852				     "waiting for IVSC to become ready\n");
853
854	bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
855	if (!bridge)
856		return -ENOMEM;
857
858	strscpy(bridge->ipu_node_name, IPU_HID,
859		sizeof(bridge->ipu_node_name));
860	bridge->ipu_hid_node.name = bridge->ipu_node_name;
861	bridge->dev = dev;
862	bridge->parse_sensor_fwnode = parse_sensor_fwnode;
863
864	ret = software_node_register(&bridge->ipu_hid_node);
865	if (ret < 0) {
866		dev_err(dev, "Failed to register the IPU HID node\n");
867		goto err_free_bridge;
868	}
869
870	/*
871	 * Map the lane arrangement, which is fixed for the IPU3 (meaning we
872	 * only need one, rather than one per sensor). We include it as a
873	 * member of the struct ipu_bridge rather than a global variable so
874	 * that it survives if the module is unloaded along with the rest of
875	 * the struct.
876	 */
877	for (i = 0; i < IPU_MAX_LANES; i++)
878		bridge->data_lanes[i] = i + 1;
879
880	ret = ipu_bridge_connect_sensors(bridge);
881	if (ret || bridge->n_sensors == 0)
882		goto err_unregister_ipu;
883
884	dev_info(dev, "Connected %d cameras\n", bridge->n_sensors);
885
886	fwnode = software_node_fwnode(&bridge->ipu_hid_node);
887	if (!fwnode) {
888		dev_err(dev, "Error getting fwnode from ipu software_node\n");
889		ret = -ENODEV;
890		goto err_unregister_sensors;
891	}
892
893	set_secondary_fwnode(dev, fwnode);
894
895	return 0;
896
897err_unregister_sensors:
898	ipu_bridge_unregister_sensors(bridge);
899err_unregister_ipu:
900	software_node_unregister(&bridge->ipu_hid_node);
901err_free_bridge:
902	kfree(bridge);
903
904	return ret;
905}
906EXPORT_SYMBOL_NS_GPL(ipu_bridge_init, "INTEL_IPU_BRIDGE");
907
908MODULE_LICENSE("GPL");
909MODULE_DESCRIPTION("Intel IPU Sensors Bridge driver");