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/pci.h>
7 #include <linux/property.h>
8 #include <media/v4l2-fwnode.h>
9
10 #include "cio2-bridge.h"
11
12 /*
13 * Extend this array with ACPI Hardware IDs of devices known to be working
14 * plus the number of link-frequencies expected by their drivers, along with
15 * the frequency values in hertz. This is somewhat opportunistic way of adding
16 * support for this for now in the hopes of a better source for the information
17 * (possibly some encoded value in the SSDB buffer that we're unaware of)
18 * becoming apparent in the future.
19 *
20 * Do not add an entry for a sensor that is not actually supported.
21 */
22 static const struct cio2_sensor_config cio2_supported_sensors[] = {
23 /* Omnivision OV5693 */
24 CIO2_SENSOR_CONFIG("INT33BE", 0),
25 /* Omnivision OV2680 */
26 CIO2_SENSOR_CONFIG("OVTI2680", 0),
27 };
28
29 static const struct cio2_property_names prop_names = {
30 .clock_frequency = "clock-frequency",
31 .rotation = "rotation",
32 .orientation = "orientation",
33 .bus_type = "bus-type",
34 .data_lanes = "data-lanes",
35 .remote_endpoint = "remote-endpoint",
36 .link_frequencies = "link-frequencies",
37 };
38
cio2_bridge_read_acpi_buffer(struct acpi_device * adev,char * id,void * data,u32 size)39 static int cio2_bridge_read_acpi_buffer(struct acpi_device *adev, char *id,
40 void *data, u32 size)
41 {
42 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
43 union acpi_object *obj;
44 acpi_status status;
45 int ret = 0;
46
47 status = acpi_evaluate_object(adev->handle, id, NULL, &buffer);
48 if (ACPI_FAILURE(status))
49 return -ENODEV;
50
51 obj = buffer.pointer;
52 if (!obj) {
53 dev_err(&adev->dev, "Couldn't locate ACPI buffer\n");
54 return -ENODEV;
55 }
56
57 if (obj->type != ACPI_TYPE_BUFFER) {
58 dev_err(&adev->dev, "Not an ACPI buffer\n");
59 ret = -ENODEV;
60 goto out_free_buff;
61 }
62
63 if (obj->buffer.length > size) {
64 dev_err(&adev->dev, "Given buffer is too small\n");
65 ret = -EINVAL;
66 goto out_free_buff;
67 }
68
69 memcpy(data, obj->buffer.pointer, obj->buffer.length);
70
71 out_free_buff:
72 kfree(buffer.pointer);
73 return ret;
74 }
75
cio2_bridge_parse_rotation(struct cio2_sensor * sensor)76 static u32 cio2_bridge_parse_rotation(struct cio2_sensor *sensor)
77 {
78 switch (sensor->ssdb.degree) {
79 case CIO2_SENSOR_ROTATION_NORMAL:
80 return 0;
81 case CIO2_SENSOR_ROTATION_INVERTED:
82 return 180;
83 default:
84 dev_warn(&sensor->adev->dev,
85 "Unknown rotation %d. Assume 0 degree rotation\n",
86 sensor->ssdb.degree);
87 return 0;
88 }
89 }
90
cio2_bridge_parse_orientation(struct cio2_sensor * sensor)91 static enum v4l2_fwnode_orientation cio2_bridge_parse_orientation(struct cio2_sensor *sensor)
92 {
93 switch (sensor->pld->panel) {
94 case ACPI_PLD_PANEL_FRONT:
95 return V4L2_FWNODE_ORIENTATION_FRONT;
96 case ACPI_PLD_PANEL_BACK:
97 return V4L2_FWNODE_ORIENTATION_BACK;
98 case ACPI_PLD_PANEL_TOP:
99 case ACPI_PLD_PANEL_LEFT:
100 case ACPI_PLD_PANEL_RIGHT:
101 case ACPI_PLD_PANEL_UNKNOWN:
102 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
103 default:
104 dev_warn(&sensor->adev->dev, "Unknown _PLD panel value %d\n",
105 sensor->pld->panel);
106 return V4L2_FWNODE_ORIENTATION_EXTERNAL;
107 }
108 }
109
cio2_bridge_create_fwnode_properties(struct cio2_sensor * sensor,struct cio2_bridge * bridge,const struct cio2_sensor_config * cfg)110 static void cio2_bridge_create_fwnode_properties(
111 struct cio2_sensor *sensor,
112 struct cio2_bridge *bridge,
113 const struct cio2_sensor_config *cfg)
114 {
115 u32 rotation;
116 enum v4l2_fwnode_orientation orientation;
117
118 rotation = cio2_bridge_parse_rotation(sensor);
119 orientation = cio2_bridge_parse_orientation(sensor);
120
121 sensor->prop_names = prop_names;
122
123 sensor->local_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_CIO2_ENDPOINT]);
124 sensor->remote_ref[0] = SOFTWARE_NODE_REFERENCE(&sensor->swnodes[SWNODE_SENSOR_ENDPOINT]);
125
126 sensor->dev_properties[0] = PROPERTY_ENTRY_U32(
127 sensor->prop_names.clock_frequency,
128 sensor->ssdb.mclkspeed);
129 sensor->dev_properties[1] = PROPERTY_ENTRY_U32(
130 sensor->prop_names.rotation,
131 rotation);
132 sensor->dev_properties[2] = PROPERTY_ENTRY_U32(
133 sensor->prop_names.orientation,
134 orientation);
135
136 sensor->ep_properties[0] = PROPERTY_ENTRY_U32(
137 sensor->prop_names.bus_type,
138 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY);
139 sensor->ep_properties[1] = PROPERTY_ENTRY_U32_ARRAY_LEN(
140 sensor->prop_names.data_lanes,
141 bridge->data_lanes,
142 sensor->ssdb.lanes);
143 sensor->ep_properties[2] = PROPERTY_ENTRY_REF_ARRAY(
144 sensor->prop_names.remote_endpoint,
145 sensor->local_ref);
146
147 if (cfg->nr_link_freqs > 0)
148 sensor->ep_properties[3] = PROPERTY_ENTRY_U64_ARRAY_LEN(
149 sensor->prop_names.link_frequencies,
150 cfg->link_freqs,
151 cfg->nr_link_freqs);
152
153 sensor->cio2_properties[0] = PROPERTY_ENTRY_U32_ARRAY_LEN(
154 sensor->prop_names.data_lanes,
155 bridge->data_lanes,
156 sensor->ssdb.lanes);
157 sensor->cio2_properties[1] = PROPERTY_ENTRY_REF_ARRAY(
158 sensor->prop_names.remote_endpoint,
159 sensor->remote_ref);
160 }
161
cio2_bridge_init_swnode_names(struct cio2_sensor * sensor)162 static void cio2_bridge_init_swnode_names(struct cio2_sensor *sensor)
163 {
164 snprintf(sensor->node_names.remote_port,
165 sizeof(sensor->node_names.remote_port),
166 SWNODE_GRAPH_PORT_NAME_FMT, sensor->ssdb.link);
167 snprintf(sensor->node_names.port,
168 sizeof(sensor->node_names.port),
169 SWNODE_GRAPH_PORT_NAME_FMT, 0); /* Always port 0 */
170 snprintf(sensor->node_names.endpoint,
171 sizeof(sensor->node_names.endpoint),
172 SWNODE_GRAPH_ENDPOINT_NAME_FMT, 0); /* And endpoint 0 */
173 }
174
cio2_bridge_create_connection_swnodes(struct cio2_bridge * bridge,struct cio2_sensor * sensor)175 static void cio2_bridge_create_connection_swnodes(struct cio2_bridge *bridge,
176 struct cio2_sensor *sensor)
177 {
178 struct software_node *nodes = sensor->swnodes;
179
180 cio2_bridge_init_swnode_names(sensor);
181
182 nodes[SWNODE_SENSOR_HID] = NODE_SENSOR(sensor->name,
183 sensor->dev_properties);
184 nodes[SWNODE_SENSOR_PORT] = NODE_PORT(sensor->node_names.port,
185 &nodes[SWNODE_SENSOR_HID]);
186 nodes[SWNODE_SENSOR_ENDPOINT] = NODE_ENDPOINT(
187 sensor->node_names.endpoint,
188 &nodes[SWNODE_SENSOR_PORT],
189 sensor->ep_properties);
190 nodes[SWNODE_CIO2_PORT] = NODE_PORT(sensor->node_names.remote_port,
191 &bridge->cio2_hid_node);
192 nodes[SWNODE_CIO2_ENDPOINT] = NODE_ENDPOINT(
193 sensor->node_names.endpoint,
194 &nodes[SWNODE_CIO2_PORT],
195 sensor->cio2_properties);
196 }
197
cio2_bridge_unregister_sensors(struct cio2_bridge * bridge)198 static void cio2_bridge_unregister_sensors(struct cio2_bridge *bridge)
199 {
200 struct cio2_sensor *sensor;
201 unsigned int i;
202
203 for (i = 0; i < bridge->n_sensors; i++) {
204 sensor = &bridge->sensors[i];
205 software_node_unregister_nodes(sensor->swnodes);
206 ACPI_FREE(sensor->pld);
207 acpi_dev_put(sensor->adev);
208 }
209 }
210
cio2_bridge_connect_sensor(const struct cio2_sensor_config * cfg,struct cio2_bridge * bridge,struct pci_dev * cio2)211 static int cio2_bridge_connect_sensor(const struct cio2_sensor_config *cfg,
212 struct cio2_bridge *bridge,
213 struct pci_dev *cio2)
214 {
215 struct fwnode_handle *fwnode;
216 struct cio2_sensor *sensor;
217 struct acpi_device *adev;
218 acpi_status status;
219 int ret;
220
221 for_each_acpi_dev_match(adev, cfg->hid, NULL, -1) {
222 if (!adev->status.enabled)
223 continue;
224
225 if (bridge->n_sensors >= CIO2_NUM_PORTS) {
226 acpi_dev_put(adev);
227 dev_err(&cio2->dev, "Exceeded available CIO2 ports\n");
228 return -EINVAL;
229 }
230
231 sensor = &bridge->sensors[bridge->n_sensors];
232 strscpy(sensor->name, cfg->hid, sizeof(sensor->name));
233
234 ret = cio2_bridge_read_acpi_buffer(adev, "SSDB",
235 &sensor->ssdb,
236 sizeof(sensor->ssdb));
237 if (ret)
238 goto err_put_adev;
239
240 status = acpi_get_physical_device_location(adev->handle, &sensor->pld);
241 if (ACPI_FAILURE(status))
242 goto err_put_adev;
243
244 if (sensor->ssdb.lanes > CIO2_MAX_LANES) {
245 dev_err(&adev->dev,
246 "Number of lanes in SSDB is invalid\n");
247 ret = -EINVAL;
248 goto err_free_pld;
249 }
250
251 cio2_bridge_create_fwnode_properties(sensor, bridge, cfg);
252 cio2_bridge_create_connection_swnodes(bridge, sensor);
253
254 ret = software_node_register_nodes(sensor->swnodes);
255 if (ret)
256 goto err_free_pld;
257
258 fwnode = software_node_fwnode(&sensor->swnodes[
259 SWNODE_SENSOR_HID]);
260 if (!fwnode) {
261 ret = -ENODEV;
262 goto err_free_swnodes;
263 }
264
265 sensor->adev = acpi_dev_get(adev);
266 adev->fwnode.secondary = fwnode;
267
268 dev_info(&cio2->dev, "Found supported sensor %s\n",
269 acpi_dev_name(adev));
270
271 bridge->n_sensors++;
272 }
273
274 return 0;
275
276 err_free_swnodes:
277 software_node_unregister_nodes(sensor->swnodes);
278 err_free_pld:
279 ACPI_FREE(sensor->pld);
280 err_put_adev:
281 acpi_dev_put(adev);
282 return ret;
283 }
284
cio2_bridge_connect_sensors(struct cio2_bridge * bridge,struct pci_dev * cio2)285 static int cio2_bridge_connect_sensors(struct cio2_bridge *bridge,
286 struct pci_dev *cio2)
287 {
288 unsigned int i;
289 int ret;
290
291 for (i = 0; i < ARRAY_SIZE(cio2_supported_sensors); i++) {
292 const struct cio2_sensor_config *cfg =
293 &cio2_supported_sensors[i];
294
295 ret = cio2_bridge_connect_sensor(cfg, bridge, cio2);
296 if (ret)
297 goto err_unregister_sensors;
298 }
299
300 return 0;
301
302 err_unregister_sensors:
303 cio2_bridge_unregister_sensors(bridge);
304 return ret;
305 }
306
cio2_bridge_init(struct pci_dev * cio2)307 int cio2_bridge_init(struct pci_dev *cio2)
308 {
309 struct device *dev = &cio2->dev;
310 struct fwnode_handle *fwnode;
311 struct cio2_bridge *bridge;
312 unsigned int i;
313 int ret;
314
315 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
316 if (!bridge)
317 return -ENOMEM;
318
319 strscpy(bridge->cio2_node_name, CIO2_HID,
320 sizeof(bridge->cio2_node_name));
321 bridge->cio2_hid_node.name = bridge->cio2_node_name;
322
323 ret = software_node_register(&bridge->cio2_hid_node);
324 if (ret < 0) {
325 dev_err(dev, "Failed to register the CIO2 HID node\n");
326 goto err_free_bridge;
327 }
328
329 /*
330 * Map the lane arrangement, which is fixed for the IPU3 (meaning we
331 * only need one, rather than one per sensor). We include it as a
332 * member of the struct cio2_bridge rather than a global variable so
333 * that it survives if the module is unloaded along with the rest of
334 * the struct.
335 */
336 for (i = 0; i < CIO2_MAX_LANES; i++)
337 bridge->data_lanes[i] = i + 1;
338
339 ret = cio2_bridge_connect_sensors(bridge, cio2);
340 if (ret || bridge->n_sensors == 0)
341 goto err_unregister_cio2;
342
343 dev_info(dev, "Connected %d cameras\n", bridge->n_sensors);
344
345 fwnode = software_node_fwnode(&bridge->cio2_hid_node);
346 if (!fwnode) {
347 dev_err(dev, "Error getting fwnode from cio2 software_node\n");
348 ret = -ENODEV;
349 goto err_unregister_sensors;
350 }
351
352 set_secondary_fwnode(dev, fwnode);
353
354 return 0;
355
356 err_unregister_sensors:
357 cio2_bridge_unregister_sensors(bridge);
358 err_unregister_cio2:
359 software_node_unregister(&bridge->cio2_hid_node);
360 err_free_bridge:
361 kfree(bridge);
362
363 return ret;
364 }
365