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