1 // SPDX-License-Identifier: GPL-2.0
2 /* Author: Dan Scally <djrscally@gmail.com> */
3
4 #include <linux/acpi.h>
5 #include <linux/device.h>
6 #include <linux/i2c.h>
7 #include <linux/pci.h>
8 #include <linux/property.h>
9 #include <media/v4l2-fwnode.h>
10
11 #include "cio2-bridge.h"
12
13 /*
14 * Extend this array with ACPI Hardware IDs of devices known to be working
15 * plus the number of link-frequencies expected by their drivers, along with
16 * the frequency values in hertz. This is somewhat opportunistic way of adding
17 * support for this for now in the hopes of a better source for the information
18 * (possibly some encoded value in the SSDB buffer that we're unaware of)
19 * becoming apparent in the future.
20 *
21 * Do not add an entry for a sensor that is not actually supported.
22 */
23 static const struct cio2_sensor_config cio2_supported_sensors[] = {
24 /* Omnivision OV5693 */
25 CIO2_SENSOR_CONFIG("INT33BE", 1, 419200000),
26 /* Omnivision OV8865 */
27 CIO2_SENSOR_CONFIG("INT347A", 1, 360000000),
28 /* Omnivision OV7251 */
29 CIO2_SENSOR_CONFIG("INT347E", 1, 319200000),
30 /* Omnivision OV2680 */
31 CIO2_SENSOR_CONFIG("OVTI2680", 0),
32 };
33
34 static const struct cio2_property_names prop_names = {
35 .clock_frequency = "clock-frequency",
36 .rotation = "rotation",
37 .orientation = "orientation",
38 .bus_type = "bus-type",
39 .data_lanes = "data-lanes",
40 .remote_endpoint = "remote-endpoint",
41 .link_frequencies = "link-frequencies",
42 };
43
44 static const char * const cio2_vcm_types[] = {
45 "ad5823",
46 "dw9714",
47 "ad5816",
48 "dw9719",
49 "dw9718",
50 "dw9806b",
51 "wv517s",
52 "lc898122xa",
53 "lc898212axb",
54 };
55
cio2_bridge_read_acpi_buffer(struct acpi_device * adev,char * id,void * data,u32 size)56 static int cio2_bridge_read_acpi_buffer(struct acpi_device *adev, char *id,
57 void *data, u32 size)
58 {
59 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
60 union acpi_object *obj;
61 acpi_status status;
62 int ret = 0;
63
64 status = acpi_evaluate_object(adev->handle, id, NULL, &buffer);
65 if (ACPI_FAILURE(status))
66 return -ENODEV;
67
68 obj = buffer.pointer;
69 if (!obj) {
70 dev_err(&adev->dev, "Couldn't locate ACPI buffer\n");
71 return -ENODEV;
72 }
73
74 if (obj->type != ACPI_TYPE_BUFFER) {
75 dev_err(&adev->dev, "Not an ACPI buffer\n");
76 ret = -ENODEV;
77 goto out_free_buff;
78 }
79
80 if (obj->buffer.length > size) {
81 dev_err(&adev->dev, "Given buffer is too small\n");
82 ret = -EINVAL;
83 goto out_free_buff;
84 }
85
86 memcpy(data, obj->buffer.pointer, obj->buffer.length);
87
88 out_free_buff:
89 kfree(buffer.pointer);
90 return ret;
91 }
92
cio2_bridge_parse_rotation(struct cio2_sensor * sensor)93 static u32 cio2_bridge_parse_rotation(struct cio2_sensor *sensor)
94 {
95 switch (sensor->ssdb.degree) {
96 case CIO2_SENSOR_ROTATION_NORMAL:
97 return 0;
98 case CIO2_SENSOR_ROTATION_INVERTED:
99 return 180;
100 default:
101 dev_warn(&sensor->adev->dev,
102 "Unknown rotation %d. Assume 0 degree rotation\n",
103 sensor->ssdb.degree);
104 return 0;
105 }
106 }
107
cio2_bridge_parse_orientation(struct cio2_sensor * sensor)108 static enum v4l2_fwnode_orientation cio2_bridge_parse_orientation(struct cio2_sensor *sensor)
109 {
110 switch (sensor->pld->panel) {
111 case ACPI_PLD_PANEL_FRONT:
112 return V4L2_FWNODE_ORIENTATION_FRONT;
113 case ACPI_PLD_PANEL_BACK:
114 return V4L2_FWNODE_ORIENTATION_BACK;
115 case ACPI_PLD_PANEL_TOP:
116 case ACPI_PLD_PANEL_LEFT:
117 case ACPI_PLD_PANEL_RIGHT:
118 case ACPI_PLD_PANEL_UNKNOWN:
119 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
120 default:
121 dev_warn(&sensor->adev->dev, "Unknown _PLD panel value %d\n",
122 sensor->pld->panel);
123 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
124 }
125 }
126
cio2_bridge_create_fwnode_properties(struct cio2_sensor * sensor,struct cio2_bridge * bridge,const struct cio2_sensor_config * cfg)127 static void cio2_bridge_create_fwnode_properties(
128 struct cio2_sensor *sensor,
129 struct cio2_bridge *bridge,
130 const struct cio2_sensor_config *cfg)
131 {
132 u32 rotation;
133 enum v4l2_fwnode_orientation orientation;
134
135 rotation = cio2_bridge_parse_rotation(sensor);
136 orientation = cio2_bridge_parse_orientation(sensor);
137
138 sensor->prop_names = prop_names;
139
140 sensor->local_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_CIO2_ENDPOINT]);
141 sensor->remote_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_SENSOR_ENDPOINT]);
142
143 sensor->dev_properties[0] = PROPERTY_ENTRY_U32(
144 sensor->prop_names.clock_frequency,
145 sensor->ssdb.mclkspeed);
146 sensor->dev_properties[1] = PROPERTY_ENTRY_U32(
147 sensor->prop_names.rotation,
148 rotation);
149 sensor->dev_properties[2] = PROPERTY_ENTRY_U32(
150 sensor->prop_names.orientation,
151 orientation);
152 if (sensor->ssdb.vcmtype) {
153 sensor->vcm_ref[0] =
154 SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_VCM]);
155 sensor->dev_properties[3] =
156 PROPERTY_ENTRY_REF_ARRAY("lens-focus", sensor->vcm_ref);
157 }
158
159 sensor->ep_properties[0] = PROPERTY_ENTRY_U32(
160 sensor->prop_names.bus_type,
161 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
162 sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN(
163 sensor->prop_names.data_lanes,
164 bridge->data_lanes,
165 sensor->ssdb.lanes);
166 sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY(
167 sensor->prop_names.remote_endpoint,
168 sensor->local_ref);
169
170 if (cfg->nr_link_freqs > 0)
171 sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN(
172 sensor->prop_names.link_frequencies,
173 cfg->link_freqs,
174 cfg->nr_link_freqs);
175
176 sensor->cio2_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN(
177 sensor->prop_names.data_lanes,
178 bridge->data_lanes,
179 sensor->ssdb.lanes);
180 sensor->cio2_properties[1] = PROPERTY_ENTRY_REF_ARRAY(
181 sensor->prop_names.remote_endpoint,
182 sensor->remote_ref);
183 }
184
cio2_bridge_init_swnode_names(struct cio2_sensor * sensor)185 static void cio2_bridge_init_swnode_names(struct cio2_sensor *sensor)
186 {
187 snprintf(sensor->node_names.remote_port,
188 sizeof(sensor->node_names.remote_port),
189 SWNODE_GRAPH_PORT_NAME_FMT, sensor->ssdb.link);
190 snprintf(sensor->node_names.port,
191 sizeof(sensor->node_names.port),
192 SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */
193 snprintf(sensor->node_names.endpoint,
194 sizeof(sensor->node_names.endpoint),
195 SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */
196 }
197
cio2_bridge_init_swnode_group(struct cio2_sensor * sensor)198 static void cio2_bridge_init_swnode_group(struct cio2_sensor *sensor)
199 {
200 struct software_node *nodes = sensor->swnodes;
201
202 sensor->group[SWNODE_SENSOR_HID] = &nodes[SWNODE_SENSOR_HID];
203 sensor->group[SWNODE_SENSOR_PORT] = &nodes[SWNODE_SENSOR_PORT];
204 sensor->group[SWNODE_SENSOR_ENDPOINT] = &nodes[SWNODE_SENSOR_ENDPOINT];
205 sensor->group[SWNODE_CIO2_PORT] = &nodes[SWNODE_CIO2_PORT];
206 sensor->group[SWNODE_CIO2_ENDPOINT] = &nodes[SWNODE_CIO2_ENDPOINT];
207 if (sensor->ssdb.vcmtype)
208 sensor->group[SWNODE_VCM] = &nodes[SWNODE_VCM];
209 }
210
cio2_bridge_create_connection_swnodes(struct cio2_bridge * bridge,struct cio2_sensor * sensor)211 static void cio2_bridge_create_connection_swnodes(struct cio2_bridge *bridge,
212 struct cio2_sensor *sensor)
213 {
214 struct software_node *nodes = sensor->swnodes;
215
216 cio2_bridge_init_swnode_names(sensor);
217
218 nodes[SWNODE_SENSOR_HID] = NODE_SENSOR(sensor->name,
219 sensor->dev_properties);
220 nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port,
221 &nodes[SWNODE_SENSOR_HID]);
222 nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT(
223 sensor->node_names.endpoint,
224 &nodes[SWNODE_SENSOR_PORT],
225 sensor->ep_properties);
226 nodes[SWNODE_CIO2_PORT] = NODE_PORT(sensor->node_names.remote_port,
227 &bridge->cio2_hid_node);
228 nodes[SWNODE_CIO2_ENDPOINT] = NODE_ENDPOINT(
229 sensor->node_names.endpoint,
230 &nodes[SWNODE_CIO2_PORT],
231 sensor->cio2_properties);
232 if (sensor->ssdb.vcmtype)
233 nodes[SWNODE_VCM] =
234 NODE_VCM(cio2_vcm_types[sensor->ssdb.vcmtype - 1]);
235
236 cio2_bridge_init_swnode_group(sensor);
237 }
238
cio2_bridge_instantiate_vcm_i2c_client(struct cio2_sensor * sensor)239 static void cio2_bridge_instantiate_vcm_i2c_client(struct cio2_sensor *sensor)
240 {
241 struct i2c_board_info board_info = { };
242 char name[16];
243
244 if (!sensor->ssdb.vcmtype)
245 return;
246
247 snprintf(name, sizeof(name), "%s-VCM", acpi_dev_name(sensor->adev));
248 board_info.dev_name = name;
249 strscpy(board_info.type, cio2_vcm_types[sensor->ssdb.vcmtype - 1],
250 ARRAY_SIZE(board_info.type));
251 board_info.swnode = &sensor->swnodes[SWNODE_VCM];
252
253 sensor->vcm_i2c_client =
254 i2c_acpi_new_device_by_fwnode(acpi_fwnode_handle(sensor->adev),
255 1, &board_info);
256 if (IS_ERR(sensor->vcm_i2c_client)) {
257 dev_warn(&sensor->adev->dev, "Error instantiation VCM i2c-client: %ld\n",
258 PTR_ERR(sensor->vcm_i2c_client));
259 sensor->vcm_i2c_client = NULL;
260 }
261 }
262
cio2_bridge_unregister_sensors(struct cio2_bridge * bridge)263 static void cio2_bridge_unregister_sensors(struct cio2_bridge *bridge)
264 {
265 struct cio2_sensor *sensor;
266 unsigned int i;
267
268 for (i = 0; i < bridge->n_sensors; i++) {
269 sensor = &bridge->sensors[i];
270 software_node_unregister_node_group(sensor->group);
271 ACPI_FREE(sensor->pld);
272 acpi_dev_put(sensor->adev);
273 i2c_unregister_device(sensor->vcm_i2c_client);
274 }
275 }
276
cio2_bridge_connect_sensor(const struct cio2_sensor_config * cfg,struct cio2_bridge * bridge,struct pci_dev * cio2)277 static int cio2_bridge_connect_sensor(const struct cio2_sensor_config *cfg,
278 struct cio2_bridge *bridge,
279 struct pci_dev *cio2)
280 {
281 struct fwnode_handle *fwnode, *primary;
282 struct cio2_sensor *sensor;
283 struct acpi_device *adev;
284 acpi_status status;
285 int ret;
286
287 for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
288 if (!adev->status.enabled)
289 continue;
290
291 if (bridge->n_sensors >= CIO2_NUM_PORTS) {
292 acpi_dev_put(adev);
293 dev_err(&cio2->dev, "Exceeded available CIO2 ports\n");
294 return -EINVAL;
295 }
296
297 sensor = &bridge->sensors[bridge->n_sensors];
298 strscpy(sensor->name, cfg->hid, sizeof(sensor->name));
299
300 ret = cio2_bridge_read_acpi_buffer(adev, "SSDB",
301 &sensor->ssdb,
302 sizeof(sensor->ssdb));
303 if (ret)
304 goto err_put_adev;
305
306 if (sensor->ssdb.vcmtype > ARRAY_SIZE(cio2_vcm_types)) {
307 dev_warn(&adev->dev, "Unknown VCM type %d\n",
308 sensor->ssdb.vcmtype);
309 sensor->ssdb.vcmtype = 0;
310 }
311
312 status = acpi_get_physical_device_location(adev->handle, &sensor->pld);
313 if (ACPI_FAILURE(status)) {
314 ret = -ENODEV;
315 goto err_put_adev;
316 }
317
318 if (sensor->ssdb.lanes > CIO2_MAX_LANES) {
319 dev_err(&adev->dev,
320 "Number of lanes in SSDB is invalid\n");
321 ret = -EINVAL;
322 goto err_free_pld;
323 }
324
325 cio2_bridge_create_fwnode_properties(sensor, bridge, cfg);
326 cio2_bridge_create_connection_swnodes(bridge, sensor);
327
328 ret = software_node_register_node_group(sensor->group);
329 if (ret)
330 goto err_free_pld;
331
332 fwnode = software_node_fwnode(&sensor->swnodes[
333 SWNODE_SENSOR_HID]);
334 if (!fwnode) {
335 ret = -ENODEV;
336 goto err_free_swnodes;
337 }
338
339 sensor->adev = acpi_dev_get(adev);
340
341 primary = acpi_fwnode_handle(adev);
342 primary->secondary = fwnode;
343
344 cio2_bridge_instantiate_vcm_i2c_client(sensor);
345
346 dev_info(&cio2->dev, "Found supported sensor %s\n",
347 acpi_dev_name(adev));
348
349 bridge->n_sensors++;
350 }
351
352 return 0;
353
354 err_free_swnodes:
355 software_node_unregister_node_group(sensor->group);
356 err_free_pld:
357 ACPI_FREE(sensor->pld);
358 err_put_adev:
359 acpi_dev_put(adev);
360 return ret;
361 }
362
cio2_bridge_connect_sensors(struct cio2_bridge * bridge,struct pci_dev * cio2)363 static int cio2_bridge_connect_sensors(struct cio2_bridge *bridge,
364 struct pci_dev *cio2)
365 {
366 unsigned int i;
367 int ret;
368
369 for (i = 0; i < ARRAY_SIZE(cio2_supported_sensors); i++) {
370 const struct cio2_sensor_config *cfg =
371 &cio2_supported_sensors[i];
372
373 ret = cio2_bridge_connect_sensor(cfg, bridge, cio2);
374 if (ret)
375 goto err_unregister_sensors;
376 }
377
378 return 0;
379
380 err_unregister_sensors:
381 cio2_bridge_unregister_sensors(bridge);
382 return ret;
383 }
384
385 /*
386 * The VCM cannot be probed until the PMIC is completely setup. We cannot rely
387 * on -EPROBE_DEFER for this, since the consumer<->supplier relations between
388 * the VCM and regulators/clks are not described in ACPI, instead they are
389 * passed as board-data to the PMIC drivers. Since -PROBE_DEFER does not work
390 * for the clks/regulators the VCM i2c-clients must not be instantiated until
391 * the PMIC is fully setup.
392 *
393 * The sensor/VCM ACPI device has an ACPI _DEP on the PMIC, check this using the
394 * acpi_dev_ready_for_enumeration() helper, like the i2c-core-acpi code does
395 * for the sensors.
396 */
cio2_bridge_sensors_are_ready(void)397 static int cio2_bridge_sensors_are_ready(void)
398 {
399 struct acpi_device *adev;
400 bool ready = true;
401 unsigned int i;
402
403 for (i = 0; i < ARRAY_SIZE(cio2_supported_sensors); i++) {
404 const struct cio2_sensor_config *cfg =
405 &cio2_supported_sensors[i];
406
407 for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
408 if (!adev->status.enabled)
409 continue;
410
411 if (!acpi_dev_ready_for_enumeration(adev))
412 ready = false;
413 }
414 }
415
416 return ready;
417 }
418
cio2_bridge_init(struct pci_dev * cio2)419 int cio2_bridge_init(struct pci_dev *cio2)
420 {
421 struct device *dev = &cio2->dev;
422 struct fwnode_handle *fwnode;
423 struct cio2_bridge *bridge;
424 unsigned int i;
425 int ret;
426
427 if (!cio2_bridge_sensors_are_ready())
428 return -EPROBE_DEFER;
429
430 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
431 if (!bridge)
432 return -ENOMEM;
433
434 strscpy(bridge->cio2_node_name, CIO2_HID,
435 sizeof(bridge->cio2_node_name));
436 bridge->cio2_hid_node.name = bridge->cio2_node_name;
437
438 ret = software_node_register(&bridge->cio2_hid_node);
439 if (ret < 0) {
440 dev_err(dev, "Failed to register the CIO2 HID node\n");
441 goto err_free_bridge;
442 }
443
444 /*
445 * Map the lane arrangement, which is fixed for the IPU3 (meaning we
446 * only need one, rather than one per sensor). We include it as a
447 * member of the struct cio2_bridge rather than a global variable so
448 * that it survives if the module is unloaded along with the rest of
449 * the struct.
450 */
451 for (i = 0; i < CIO2_MAX_LANES; i++)
452 bridge->data_lanes[i] = i + 1;
453
454 ret = cio2_bridge_connect_sensors(bridge, cio2);
455 if (ret || bridge->n_sensors == 0)
456 goto err_unregister_cio2;
457
458 dev_info(dev, "Connected %d cameras\n", bridge->n_sensors);
459
460 fwnode = software_node_fwnode(&bridge->cio2_hid_node);
461 if (!fwnode) {
462 dev_err(dev, "Error getting fwnode from cio2 software_node\n");
463 ret = -ENODEV;
464 goto err_unregister_sensors;
465 }
466
467 set_secondary_fwnode(dev, fwnode);
468
469 return 0;
470
471 err_unregister_sensors:
472 cio2_bridge_unregister_sensors(bridge);
473 err_unregister_cio2:
474 software_node_unregister(&bridge->cio2_hid_node);
475 err_free_bridge:
476 kfree(bridge);
477
478 return ret;
479 }
480