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