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