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