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