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 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 */
106 static 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
124 static 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
134 static 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 */
150 static const struct acpi_device_id ivsc_acpi_ids[] = {
151 { "INTC1059" },
152 { "INTC1095" },
153 { "INTC100A" },
154 { "INTC10CF" },
155 };
156
ipu_bridge_get_ivsc_acpi_dev(struct acpi_device * adev)157 static 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
ipu_bridge_match_ivsc_dev(struct device * dev,const void * adev)178 static 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
ipu_bridge_get_ivsc_csi_dev(struct acpi_device * adev)189 static 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
ipu_bridge_check_ivsc_dev(struct ipu_sensor * sensor,struct acpi_device * sensor_adev)211 static 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
ipu_bridge_read_acpi_buffer(struct acpi_device * adev,char * id,void * data,u32 size)233 static 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
266 out_free_buff:
267 kfree(buffer.pointer);
268 return ret;
269 }
270
ipu_bridge_parse_rotation(struct acpi_device * adev,struct ipu_sensor_ssdb * ssdb)271 static 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
ipu_bridge_parse_orientation(struct acpi_device * adev)293 static 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
ipu_bridge_parse_ssdb(struct acpi_device * adev,struct ipu_sensor * sensor)327 int 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 }
357 EXPORT_SYMBOL_NS_GPL(ipu_bridge_parse_ssdb, "INTEL_IPU_BRIDGE");
358
ipu_bridge_create_fwnode_properties(struct ipu_sensor * sensor,struct ipu_bridge * bridge,const struct ipu_sensor_config * cfg)359 static 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
ipu_bridge_init_swnode_names(struct ipu_sensor * sensor)447 static 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
ipu_bridge_init_swnode_group(struct ipu_sensor * sensor)474 static 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
ipu_bridge_create_connection_swnodes(struct ipu_bridge * bridge,struct ipu_sensor * sensor)506 static 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 */
564 struct 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
ipu_bridge_instantiate_vcm_work(struct work_struct * work)571 static 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
609 out_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
ipu_bridge_instantiate_vcm(struct device * sensor)617 int 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 }
663 EXPORT_SYMBOL_NS_GPL(ipu_bridge_instantiate_vcm, "INTEL_IPU_BRIDGE");
664
ipu_bridge_instantiate_ivsc(struct ipu_sensor * sensor)665 static 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
ipu_bridge_unregister_sensors(struct ipu_bridge * bridge)681 static 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
ipu_bridge_connect_sensor(const struct ipu_sensor_config * cfg,struct ipu_bridge * bridge)695 static 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
757 err_free_swnodes:
758 software_node_unregister_node_group(sensor->group);
759 err_put_ivsc:
760 put_device(sensor->csi_dev);
761 acpi_dev_put(sensor->ivsc_adev);
762 err_put_adev:
763 acpi_dev_put(adev);
764 return ret;
765 }
766
ipu_bridge_connect_sensors(struct ipu_bridge * bridge)767 static 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
783 err_unregister_sensors:
784 ipu_bridge_unregister_sensors(bridge);
785 return ret;
786 }
787
ipu_bridge_ivsc_is_ready(void)788 static 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
ipu_bridge_check_fwnode_graph(struct fwnode_handle * fwnode)819 static 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
835 static DEFINE_MUTEX(ipu_bridge_mutex);
836
ipu_bridge_init(struct device * dev,ipu_parse_sensor_fwnode_t parse_sensor_fwnode)837 int 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
897 err_unregister_sensors:
898 ipu_bridge_unregister_sensors(bridge);
899 err_unregister_ipu:
900 software_node_unregister(&bridge->ipu_hid_node);
901 err_free_bridge:
902 kfree(bridge);
903
904 return ret;
905 }
906 EXPORT_SYMBOL_NS_GPL(ipu_bridge_init, "INTEL_IPU_BRIDGE");
907
908 MODULE_LICENSE("GPL");
909 MODULE_DESCRIPTION("Intel IPU Sensors Bridge driver");
910