1 /*
2  * V4L2 fwnode binding parsing library
3  *
4  * The origins of the V4L2 fwnode library are in V4L2 OF library that
5  * formerly was located in v4l2-of.c.
6  *
7  * Copyright (c) 2016 Intel Corporation.
8  * Author: Sakari Ailus <sakari.ailus@linux.intel.com>
9  *
10  * Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd.
11  * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
12  *
13  * Copyright (C) 2012 Renesas Electronics Corp.
14  * Author: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
15  *
16  * This program is free software; you can redistribute it and/or modify
17  * it under the terms of version 2 of the GNU General Public License as
18  * published by the Free Software Foundation.
19  */
20 #include <linux/acpi.h>
21 #include <linux/kernel.h>
22 #include <linux/mm.h>
23 #include <linux/module.h>
24 #include <linux/of.h>
25 #include <linux/property.h>
26 #include <linux/slab.h>
27 #include <linux/string.h>
28 #include <linux/types.h>
29 
30 #include <media/v4l2-async.h>
31 #include <media/v4l2-fwnode.h>
32 #include <media/v4l2-subdev.h>
33 
34 enum v4l2_fwnode_bus_type {
35 	V4L2_FWNODE_BUS_TYPE_GUESS = 0,
36 	V4L2_FWNODE_BUS_TYPE_CSI2_CPHY,
37 	V4L2_FWNODE_BUS_TYPE_CSI1,
38 	V4L2_FWNODE_BUS_TYPE_CCP2,
39 	V4L2_FWNODE_BUS_TYPE_CSI2_DPHY,
40 	V4L2_FWNODE_BUS_TYPE_PARALLEL,
41 	V4L2_FWNODE_BUS_TYPE_BT656,
42 	NR_OF_V4L2_FWNODE_BUS_TYPE,
43 };
44 
45 static const struct v4l2_fwnode_bus_conv {
46 	enum v4l2_fwnode_bus_type fwnode_bus_type;
47 	enum v4l2_mbus_type mbus_type;
48 	const char *name;
49 } buses[] = {
50 	{
51 		V4L2_FWNODE_BUS_TYPE_GUESS,
52 		V4L2_MBUS_UNKNOWN,
53 		"not specified",
54 	}, {
55 		V4L2_FWNODE_BUS_TYPE_CSI2_CPHY,
56 		V4L2_MBUS_CSI2_CPHY,
57 		"MIPI CSI-2 C-PHY",
58 	}, {
59 		V4L2_FWNODE_BUS_TYPE_CSI1,
60 		V4L2_MBUS_CSI1,
61 		"MIPI CSI-1",
62 	}, {
63 		V4L2_FWNODE_BUS_TYPE_CCP2,
64 		V4L2_MBUS_CCP2,
65 		"compact camera port 2",
66 	}, {
67 		V4L2_FWNODE_BUS_TYPE_CSI2_DPHY,
68 		V4L2_MBUS_CSI2_DPHY,
69 		"MIPI CSI-2 D-PHY",
70 	}, {
71 		V4L2_FWNODE_BUS_TYPE_PARALLEL,
72 		V4L2_MBUS_PARALLEL,
73 		"parallel",
74 	}, {
75 		V4L2_FWNODE_BUS_TYPE_BT656,
76 		V4L2_MBUS_BT656,
77 		"Bt.656",
78 	}
79 };
80 
81 static const struct v4l2_fwnode_bus_conv *
82 get_v4l2_fwnode_bus_conv_by_fwnode_bus(enum v4l2_fwnode_bus_type type)
83 {
84 	unsigned int i;
85 
86 	for (i = 0; i < ARRAY_SIZE(buses); i++)
87 		if (buses[i].fwnode_bus_type == type)
88 			return &buses[i];
89 
90 	return NULL;
91 }
92 
93 static enum v4l2_mbus_type
94 v4l2_fwnode_bus_type_to_mbus(enum v4l2_fwnode_bus_type type)
95 {
96 	const struct v4l2_fwnode_bus_conv *conv =
97 		get_v4l2_fwnode_bus_conv_by_fwnode_bus(type);
98 
99 	return conv ? conv->mbus_type : V4L2_MBUS_UNKNOWN;
100 }
101 
102 static const char *
103 v4l2_fwnode_bus_type_to_string(enum v4l2_fwnode_bus_type type)
104 {
105 	const struct v4l2_fwnode_bus_conv *conv =
106 		get_v4l2_fwnode_bus_conv_by_fwnode_bus(type);
107 
108 	return conv ? conv->name : "not found";
109 }
110 
111 static const struct v4l2_fwnode_bus_conv *
112 get_v4l2_fwnode_bus_conv_by_mbus(enum v4l2_mbus_type type)
113 {
114 	unsigned int i;
115 
116 	for (i = 0; i < ARRAY_SIZE(buses); i++)
117 		if (buses[i].mbus_type == type)
118 			return &buses[i];
119 
120 	return NULL;
121 }
122 
123 static const char *
124 v4l2_fwnode_mbus_type_to_string(enum v4l2_mbus_type type)
125 {
126 	const struct v4l2_fwnode_bus_conv *conv =
127 		get_v4l2_fwnode_bus_conv_by_mbus(type);
128 
129 	return conv ? conv->name : "not found";
130 }
131 
132 static int v4l2_fwnode_endpoint_parse_csi2_bus(struct fwnode_handle *fwnode,
133 					       struct v4l2_fwnode_endpoint *vep,
134 					       enum v4l2_mbus_type bus_type)
135 {
136 	struct v4l2_fwnode_bus_mipi_csi2 *bus = &vep->bus.mipi_csi2;
137 	bool have_clk_lane = false, have_data_lanes = false,
138 		have_lane_polarities = false;
139 	unsigned int flags = 0, lanes_used = 0;
140 	u32 array[1 + V4L2_FWNODE_CSI2_MAX_DATA_LANES];
141 	u32 clock_lane = 0;
142 	unsigned int num_data_lanes = 0;
143 	bool use_default_lane_mapping = false;
144 	unsigned int i;
145 	u32 v;
146 	int rval;
147 
148 	if (bus_type == V4L2_MBUS_CSI2_DPHY ||
149 	    bus_type == V4L2_MBUS_CSI2_CPHY) {
150 		use_default_lane_mapping = true;
151 
152 		num_data_lanes = min_t(u32, bus->num_data_lanes,
153 				       V4L2_FWNODE_CSI2_MAX_DATA_LANES);
154 
155 		clock_lane = bus->clock_lane;
156 		if (clock_lane)
157 			use_default_lane_mapping = false;
158 
159 		for (i = 0; i < num_data_lanes; i++) {
160 			array[i] = bus->data_lanes[i];
161 			if (array[i])
162 				use_default_lane_mapping = false;
163 		}
164 
165 		if (use_default_lane_mapping)
166 			pr_debug("using default lane mapping\n");
167 	}
168 
169 	rval = fwnode_property_read_u32_array(fwnode, "data-lanes", NULL, 0);
170 	if (rval > 0) {
171 		num_data_lanes =
172 			min_t(int, V4L2_FWNODE_CSI2_MAX_DATA_LANES, rval);
173 
174 		fwnode_property_read_u32_array(fwnode, "data-lanes", array,
175 					       num_data_lanes);
176 
177 		have_data_lanes = true;
178 	}
179 
180 	for (i = 0; i < num_data_lanes; i++) {
181 		if (lanes_used & BIT(array[i])) {
182 			if (have_data_lanes || !use_default_lane_mapping)
183 				pr_warn("duplicated lane %u in data-lanes, using defaults\n",
184 					array[i]);
185 			use_default_lane_mapping = true;
186 		}
187 		lanes_used |= BIT(array[i]);
188 
189 		if (have_data_lanes)
190 			pr_debug("lane %u position %u\n", i, array[i]);
191 	}
192 
193 	rval = fwnode_property_read_u32_array(fwnode, "lane-polarities", NULL,
194 					      0);
195 	if (rval > 0) {
196 		if (rval != 1 + num_data_lanes /* clock+data */) {
197 			pr_warn("invalid number of lane-polarities entries (need %u, got %u)\n",
198 				1 + num_data_lanes, rval);
199 			return -EINVAL;
200 		}
201 
202 		have_lane_polarities = true;
203 	}
204 
205 	if (!fwnode_property_read_u32(fwnode, "clock-lanes", &v)) {
206 		clock_lane = v;
207 		pr_debug("clock lane position %u\n", v);
208 		have_clk_lane = true;
209 	}
210 
211 	if (lanes_used & BIT(clock_lane)) {
212 		if (have_clk_lane || !use_default_lane_mapping)
213 			pr_warn("duplicated lane %u in clock-lanes, using defaults\n",
214 				v);
215 		use_default_lane_mapping = true;
216 	}
217 
218 	if (fwnode_property_present(fwnode, "clock-noncontinuous")) {
219 		flags |= V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK;
220 		pr_debug("non-continuous clock\n");
221 	} else {
222 		flags |= V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
223 	}
224 
225 	if (bus_type == V4L2_MBUS_CSI2_DPHY ||
226 	    bus_type == V4L2_MBUS_CSI2_CPHY || lanes_used ||
227 	    have_clk_lane || (flags & ~V4L2_MBUS_CSI2_CONTINUOUS_CLOCK)) {
228 		bus->flags = flags;
229 		if (bus_type == V4L2_MBUS_UNKNOWN)
230 			vep->bus_type = V4L2_MBUS_CSI2_DPHY;
231 		bus->num_data_lanes = num_data_lanes;
232 
233 		if (use_default_lane_mapping) {
234 			bus->clock_lane = 0;
235 			for (i = 0; i < num_data_lanes; i++)
236 				bus->data_lanes[i] = 1 + i;
237 		} else {
238 			bus->clock_lane = clock_lane;
239 			for (i = 0; i < num_data_lanes; i++)
240 				bus->data_lanes[i] = array[i];
241 		}
242 
243 		if (have_lane_polarities) {
244 			fwnode_property_read_u32_array(fwnode,
245 						       "lane-polarities", array,
246 						       1 + num_data_lanes);
247 
248 			for (i = 0; i < 1 + num_data_lanes; i++) {
249 				bus->lane_polarities[i] = array[i];
250 				pr_debug("lane %u polarity %sinverted",
251 					 i, array[i] ? "" : "not ");
252 			}
253 		} else {
254 			pr_debug("no lane polarities defined, assuming not inverted\n");
255 		}
256 	}
257 
258 	return 0;
259 }
260 
261 #define PARALLEL_MBUS_FLAGS (V4L2_MBUS_HSYNC_ACTIVE_HIGH |	\
262 			     V4L2_MBUS_HSYNC_ACTIVE_LOW |	\
263 			     V4L2_MBUS_VSYNC_ACTIVE_HIGH |	\
264 			     V4L2_MBUS_VSYNC_ACTIVE_LOW |	\
265 			     V4L2_MBUS_FIELD_EVEN_HIGH |	\
266 			     V4L2_MBUS_FIELD_EVEN_LOW)
267 
268 static void
269 v4l2_fwnode_endpoint_parse_parallel_bus(struct fwnode_handle *fwnode,
270 					struct v4l2_fwnode_endpoint *vep,
271 					enum v4l2_mbus_type bus_type)
272 {
273 	struct v4l2_fwnode_bus_parallel *bus = &vep->bus.parallel;
274 	unsigned int flags = 0;
275 	u32 v;
276 
277 	if (bus_type == V4L2_MBUS_PARALLEL || bus_type == V4L2_MBUS_BT656)
278 		flags = bus->flags;
279 
280 	if (!fwnode_property_read_u32(fwnode, "hsync-active", &v)) {
281 		flags &= ~(V4L2_MBUS_HSYNC_ACTIVE_HIGH |
282 			   V4L2_MBUS_HSYNC_ACTIVE_LOW);
283 		flags |= v ? V4L2_MBUS_HSYNC_ACTIVE_HIGH :
284 			V4L2_MBUS_HSYNC_ACTIVE_LOW;
285 		pr_debug("hsync-active %s\n", v ? "high" : "low");
286 	}
287 
288 	if (!fwnode_property_read_u32(fwnode, "vsync-active", &v)) {
289 		flags &= ~(V4L2_MBUS_VSYNC_ACTIVE_HIGH |
290 			   V4L2_MBUS_VSYNC_ACTIVE_LOW);
291 		flags |= v ? V4L2_MBUS_VSYNC_ACTIVE_HIGH :
292 			V4L2_MBUS_VSYNC_ACTIVE_LOW;
293 		pr_debug("vsync-active %s\n", v ? "high" : "low");
294 	}
295 
296 	if (!fwnode_property_read_u32(fwnode, "field-even-active", &v)) {
297 		flags &= ~(V4L2_MBUS_FIELD_EVEN_HIGH |
298 			   V4L2_MBUS_FIELD_EVEN_LOW);
299 		flags |= v ? V4L2_MBUS_FIELD_EVEN_HIGH :
300 			V4L2_MBUS_FIELD_EVEN_LOW;
301 		pr_debug("field-even-active %s\n", v ? "high" : "low");
302 	}
303 
304 	if (!fwnode_property_read_u32(fwnode, "pclk-sample", &v)) {
305 		flags &= ~(V4L2_MBUS_PCLK_SAMPLE_RISING |
306 			   V4L2_MBUS_PCLK_SAMPLE_FALLING);
307 		flags |= v ? V4L2_MBUS_PCLK_SAMPLE_RISING :
308 			V4L2_MBUS_PCLK_SAMPLE_FALLING;
309 		pr_debug("pclk-sample %s\n", v ? "high" : "low");
310 	}
311 
312 	if (!fwnode_property_read_u32(fwnode, "data-active", &v)) {
313 		flags &= ~(V4L2_MBUS_DATA_ACTIVE_HIGH |
314 			   V4L2_MBUS_DATA_ACTIVE_LOW);
315 		flags |= v ? V4L2_MBUS_DATA_ACTIVE_HIGH :
316 			V4L2_MBUS_DATA_ACTIVE_LOW;
317 		pr_debug("data-active %s\n", v ? "high" : "low");
318 	}
319 
320 	if (fwnode_property_present(fwnode, "slave-mode")) {
321 		pr_debug("slave mode\n");
322 		flags &= ~V4L2_MBUS_MASTER;
323 		flags |= V4L2_MBUS_SLAVE;
324 	} else {
325 		flags &= ~V4L2_MBUS_SLAVE;
326 		flags |= V4L2_MBUS_MASTER;
327 	}
328 
329 	if (!fwnode_property_read_u32(fwnode, "bus-width", &v)) {
330 		bus->bus_width = v;
331 		pr_debug("bus-width %u\n", v);
332 	}
333 
334 	if (!fwnode_property_read_u32(fwnode, "data-shift", &v)) {
335 		bus->data_shift = v;
336 		pr_debug("data-shift %u\n", v);
337 	}
338 
339 	if (!fwnode_property_read_u32(fwnode, "sync-on-green-active", &v)) {
340 		flags &= ~(V4L2_MBUS_VIDEO_SOG_ACTIVE_HIGH |
341 			   V4L2_MBUS_VIDEO_SOG_ACTIVE_LOW);
342 		flags |= v ? V4L2_MBUS_VIDEO_SOG_ACTIVE_HIGH :
343 			V4L2_MBUS_VIDEO_SOG_ACTIVE_LOW;
344 		pr_debug("sync-on-green-active %s\n", v ? "high" : "low");
345 	}
346 
347 	if (!fwnode_property_read_u32(fwnode, "data-enable-active", &v)) {
348 		flags &= ~(V4L2_MBUS_DATA_ENABLE_HIGH |
349 			   V4L2_MBUS_DATA_ENABLE_LOW);
350 		flags |= v ? V4L2_MBUS_DATA_ENABLE_HIGH :
351 			V4L2_MBUS_DATA_ENABLE_LOW;
352 		pr_debug("data-enable-active %s\n", v ? "high" : "low");
353 	}
354 
355 	switch (bus_type) {
356 	default:
357 		bus->flags = flags;
358 		if (flags & PARALLEL_MBUS_FLAGS)
359 			vep->bus_type = V4L2_MBUS_PARALLEL;
360 		else
361 			vep->bus_type = V4L2_MBUS_BT656;
362 		break;
363 	case V4L2_MBUS_PARALLEL:
364 		vep->bus_type = V4L2_MBUS_PARALLEL;
365 		bus->flags = flags;
366 		break;
367 	case V4L2_MBUS_BT656:
368 		vep->bus_type = V4L2_MBUS_BT656;
369 		bus->flags = flags & ~PARALLEL_MBUS_FLAGS;
370 		break;
371 	}
372 }
373 
374 static void
375 v4l2_fwnode_endpoint_parse_csi1_bus(struct fwnode_handle *fwnode,
376 				    struct v4l2_fwnode_endpoint *vep,
377 				    enum v4l2_mbus_type bus_type)
378 {
379 	struct v4l2_fwnode_bus_mipi_csi1 *bus = &vep->bus.mipi_csi1;
380 	u32 v;
381 
382 	if (!fwnode_property_read_u32(fwnode, "clock-inv", &v)) {
383 		bus->clock_inv = v;
384 		pr_debug("clock-inv %u\n", v);
385 	}
386 
387 	if (!fwnode_property_read_u32(fwnode, "strobe", &v)) {
388 		bus->strobe = v;
389 		pr_debug("strobe %u\n", v);
390 	}
391 
392 	if (!fwnode_property_read_u32(fwnode, "data-lanes", &v)) {
393 		bus->data_lane = v;
394 		pr_debug("data-lanes %u\n", v);
395 	}
396 
397 	if (!fwnode_property_read_u32(fwnode, "clock-lanes", &v)) {
398 		bus->clock_lane = v;
399 		pr_debug("clock-lanes %u\n", v);
400 	}
401 
402 	if (bus_type == V4L2_MBUS_CCP2)
403 		vep->bus_type = V4L2_MBUS_CCP2;
404 	else
405 		vep->bus_type = V4L2_MBUS_CSI1;
406 }
407 
408 static int __v4l2_fwnode_endpoint_parse(struct fwnode_handle *fwnode,
409 					struct v4l2_fwnode_endpoint *vep)
410 {
411 	u32 bus_type = V4L2_FWNODE_BUS_TYPE_GUESS;
412 	enum v4l2_mbus_type mbus_type;
413 	int rval;
414 
415 	if (vep->bus_type == V4L2_MBUS_UNKNOWN) {
416 		/* Zero fields from bus union to until the end */
417 		memset(&vep->bus, 0,
418 		       sizeof(*vep) - offsetof(typeof(*vep), bus));
419 	}
420 
421 	pr_debug("===== begin V4L2 endpoint properties\n");
422 
423 	/*
424 	 * Zero the fwnode graph endpoint memory in case we don't end up parsing
425 	 * the endpoint.
426 	 */
427 	memset(&vep->base, 0, sizeof(vep->base));
428 
429 	fwnode_property_read_u32(fwnode, "bus-type", &bus_type);
430 	pr_debug("fwnode video bus type %s (%u), mbus type %s (%u)\n",
431 		 v4l2_fwnode_bus_type_to_string(bus_type), bus_type,
432 		 v4l2_fwnode_mbus_type_to_string(vep->bus_type),
433 		 vep->bus_type);
434 	mbus_type = v4l2_fwnode_bus_type_to_mbus(bus_type);
435 
436 	if (vep->bus_type != V4L2_MBUS_UNKNOWN) {
437 		if (mbus_type != V4L2_MBUS_UNKNOWN &&
438 		    vep->bus_type != mbus_type) {
439 			pr_debug("expecting bus type %s\n",
440 				 v4l2_fwnode_mbus_type_to_string(vep->bus_type));
441 			return -ENXIO;
442 		}
443 	} else {
444 		vep->bus_type = mbus_type;
445 	}
446 
447 	switch (vep->bus_type) {
448 	case V4L2_MBUS_UNKNOWN:
449 		rval = v4l2_fwnode_endpoint_parse_csi2_bus(fwnode, vep,
450 							   V4L2_MBUS_UNKNOWN);
451 		if (rval)
452 			return rval;
453 
454 		if (vep->bus_type == V4L2_MBUS_UNKNOWN)
455 			v4l2_fwnode_endpoint_parse_parallel_bus(fwnode, vep,
456 								V4L2_MBUS_UNKNOWN);
457 
458 		pr_debug("assuming media bus type %s (%u)\n",
459 			 v4l2_fwnode_mbus_type_to_string(vep->bus_type),
460 			 vep->bus_type);
461 
462 		break;
463 	case V4L2_MBUS_CCP2:
464 	case V4L2_MBUS_CSI1:
465 		v4l2_fwnode_endpoint_parse_csi1_bus(fwnode, vep, vep->bus_type);
466 
467 		break;
468 	case V4L2_MBUS_CSI2_DPHY:
469 	case V4L2_MBUS_CSI2_CPHY:
470 		rval = v4l2_fwnode_endpoint_parse_csi2_bus(fwnode, vep,
471 							   vep->bus_type);
472 		if (rval)
473 			return rval;
474 
475 		break;
476 	case V4L2_MBUS_PARALLEL:
477 	case V4L2_MBUS_BT656:
478 		v4l2_fwnode_endpoint_parse_parallel_bus(fwnode, vep,
479 							vep->bus_type);
480 
481 		break;
482 	default:
483 		pr_warn("unsupported bus type %u\n", mbus_type);
484 		return -EINVAL;
485 	}
486 
487 	fwnode_graph_parse_endpoint(fwnode, &vep->base);
488 
489 	return 0;
490 }
491 
492 int v4l2_fwnode_endpoint_parse(struct fwnode_handle *fwnode,
493 			       struct v4l2_fwnode_endpoint *vep)
494 {
495 	int ret;
496 
497 	ret = __v4l2_fwnode_endpoint_parse(fwnode, vep);
498 
499 	pr_debug("===== end V4L2 endpoint properties\n");
500 
501 	return ret;
502 }
503 EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_parse);
504 
505 void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep)
506 {
507 	if (IS_ERR_OR_NULL(vep))
508 		return;
509 
510 	kfree(vep->link_frequencies);
511 }
512 EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_free);
513 
514 int v4l2_fwnode_endpoint_alloc_parse(struct fwnode_handle *fwnode,
515 				     struct v4l2_fwnode_endpoint *vep)
516 {
517 	int rval;
518 
519 	rval = __v4l2_fwnode_endpoint_parse(fwnode, vep);
520 	if (rval < 0)
521 		return rval;
522 
523 	rval = fwnode_property_read_u64_array(fwnode, "link-frequencies",
524 					      NULL, 0);
525 	if (rval > 0) {
526 		unsigned int i;
527 
528 		vep->link_frequencies =
529 			kmalloc_array(rval, sizeof(*vep->link_frequencies),
530 				      GFP_KERNEL);
531 		if (!vep->link_frequencies)
532 			return -ENOMEM;
533 
534 		vep->nr_of_link_frequencies = rval;
535 
536 		rval = fwnode_property_read_u64_array(fwnode,
537 						      "link-frequencies",
538 						      vep->link_frequencies,
539 						      vep->nr_of_link_frequencies);
540 		if (rval < 0) {
541 			v4l2_fwnode_endpoint_free(vep);
542 			return rval;
543 		}
544 
545 		for (i = 0; i < vep->nr_of_link_frequencies; i++)
546 			pr_info("link-frequencies %u value %llu\n", i,
547 				vep->link_frequencies[i]);
548 	}
549 
550 	pr_debug("===== end V4L2 endpoint properties\n");
551 
552 	return 0;
553 }
554 EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_alloc_parse);
555 
556 int v4l2_fwnode_parse_link(struct fwnode_handle *__fwnode,
557 			   struct v4l2_fwnode_link *link)
558 {
559 	const char *port_prop = is_of_node(__fwnode) ? "reg" : "port";
560 	struct fwnode_handle *fwnode;
561 
562 	memset(link, 0, sizeof(*link));
563 
564 	fwnode = fwnode_get_parent(__fwnode);
565 	fwnode_property_read_u32(fwnode, port_prop, &link->local_port);
566 	fwnode = fwnode_get_next_parent(fwnode);
567 	if (is_of_node(fwnode) && of_node_name_eq(to_of_node(fwnode), "ports"))
568 		fwnode = fwnode_get_next_parent(fwnode);
569 	link->local_node = fwnode;
570 
571 	fwnode = fwnode_graph_get_remote_endpoint(__fwnode);
572 	if (!fwnode) {
573 		fwnode_handle_put(fwnode);
574 		return -ENOLINK;
575 	}
576 
577 	fwnode = fwnode_get_parent(fwnode);
578 	fwnode_property_read_u32(fwnode, port_prop, &link->remote_port);
579 	fwnode = fwnode_get_next_parent(fwnode);
580 	if (is_of_node(fwnode) && of_node_name_eq(to_of_node(fwnode), "ports"))
581 		fwnode = fwnode_get_next_parent(fwnode);
582 	link->remote_node = fwnode;
583 
584 	return 0;
585 }
586 EXPORT_SYMBOL_GPL(v4l2_fwnode_parse_link);
587 
588 void v4l2_fwnode_put_link(struct v4l2_fwnode_link *link)
589 {
590 	fwnode_handle_put(link->local_node);
591 	fwnode_handle_put(link->remote_node);
592 }
593 EXPORT_SYMBOL_GPL(v4l2_fwnode_put_link);
594 
595 static int
596 v4l2_async_notifier_fwnode_parse_endpoint(struct device *dev,
597 					  struct v4l2_async_notifier *notifier,
598 					  struct fwnode_handle *endpoint,
599 					  unsigned int asd_struct_size,
600 					  parse_endpoint_func parse_endpoint)
601 {
602 	struct v4l2_fwnode_endpoint vep = { .bus_type = 0 };
603 	struct v4l2_async_subdev *asd;
604 	int ret;
605 
606 	asd = kzalloc(asd_struct_size, GFP_KERNEL);
607 	if (!asd)
608 		return -ENOMEM;
609 
610 	asd->match_type = V4L2_ASYNC_MATCH_FWNODE;
611 	asd->match.fwnode =
612 		fwnode_graph_get_remote_port_parent(endpoint);
613 	if (!asd->match.fwnode) {
614 		dev_dbg(dev, "no remote endpoint found\n");
615 		ret = -ENOTCONN;
616 		goto out_err;
617 	}
618 
619 	ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &vep);
620 	if (ret) {
621 		dev_warn(dev, "unable to parse V4L2 fwnode endpoint (%d)\n",
622 			 ret);
623 		goto out_err;
624 	}
625 
626 	ret = parse_endpoint ? parse_endpoint(dev, &vep, asd) : 0;
627 	if (ret == -ENOTCONN)
628 		dev_dbg(dev, "ignoring port@%u/endpoint@%u\n", vep.base.port,
629 			vep.base.id);
630 	else if (ret < 0)
631 		dev_warn(dev,
632 			 "driver could not parse port@%u/endpoint@%u (%d)\n",
633 			 vep.base.port, vep.base.id, ret);
634 	v4l2_fwnode_endpoint_free(&vep);
635 	if (ret < 0)
636 		goto out_err;
637 
638 	ret = v4l2_async_notifier_add_subdev(notifier, asd);
639 	if (ret < 0) {
640 		/* not an error if asd already exists */
641 		if (ret == -EEXIST)
642 			ret = 0;
643 		goto out_err;
644 	}
645 
646 	return 0;
647 
648 out_err:
649 	fwnode_handle_put(asd->match.fwnode);
650 	kfree(asd);
651 
652 	return ret == -ENOTCONN ? 0 : ret;
653 }
654 
655 static int
656 __v4l2_async_notifier_parse_fwnode_ep(struct device *dev,
657 				      struct v4l2_async_notifier *notifier,
658 				      size_t asd_struct_size,
659 				      unsigned int port,
660 				      bool has_port,
661 				      parse_endpoint_func parse_endpoint)
662 {
663 	struct fwnode_handle *fwnode;
664 	int ret = 0;
665 
666 	if (WARN_ON(asd_struct_size < sizeof(struct v4l2_async_subdev)))
667 		return -EINVAL;
668 
669 	fwnode_graph_for_each_endpoint(dev_fwnode(dev), fwnode) {
670 		struct fwnode_handle *dev_fwnode;
671 		bool is_available;
672 
673 		dev_fwnode = fwnode_graph_get_port_parent(fwnode);
674 		is_available = fwnode_device_is_available(dev_fwnode);
675 		fwnode_handle_put(dev_fwnode);
676 		if (!is_available)
677 			continue;
678 
679 		if (has_port) {
680 			struct fwnode_endpoint ep;
681 
682 			ret = fwnode_graph_parse_endpoint(fwnode, &ep);
683 			if (ret)
684 				break;
685 
686 			if (ep.port != port)
687 				continue;
688 		}
689 
690 		ret = v4l2_async_notifier_fwnode_parse_endpoint(dev,
691 								notifier,
692 								fwnode,
693 								asd_struct_size,
694 								parse_endpoint);
695 		if (ret < 0)
696 			break;
697 	}
698 
699 	fwnode_handle_put(fwnode);
700 
701 	return ret;
702 }
703 
704 int
705 v4l2_async_notifier_parse_fwnode_endpoints(struct device *dev,
706 					   struct v4l2_async_notifier *notifier,
707 					   size_t asd_struct_size,
708 					   parse_endpoint_func parse_endpoint)
709 {
710 	return __v4l2_async_notifier_parse_fwnode_ep(dev, notifier,
711 						     asd_struct_size, 0,
712 						     false, parse_endpoint);
713 }
714 EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints);
715 
716 int
717 v4l2_async_notifier_parse_fwnode_endpoints_by_port(struct device *dev,
718 						   struct v4l2_async_notifier *notifier,
719 						   size_t asd_struct_size,
720 						   unsigned int port,
721 						   parse_endpoint_func parse_endpoint)
722 {
723 	return __v4l2_async_notifier_parse_fwnode_ep(dev, notifier,
724 						     asd_struct_size,
725 						     port, true,
726 						     parse_endpoint);
727 }
728 EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints_by_port);
729 
730 /*
731  * v4l2_fwnode_reference_parse - parse references for async sub-devices
732  * @dev: the device node the properties of which are parsed for references
733  * @notifier: the async notifier where the async subdevs will be added
734  * @prop: the name of the property
735  *
736  * Return: 0 on success
737  *	   -ENOENT if no entries were found
738  *	   -ENOMEM if memory allocation failed
739  *	   -EINVAL if property parsing failed
740  */
741 static int v4l2_fwnode_reference_parse(struct device *dev,
742 				       struct v4l2_async_notifier *notifier,
743 				       const char *prop)
744 {
745 	struct fwnode_reference_args args;
746 	unsigned int index;
747 	int ret;
748 
749 	for (index = 0;
750 	     !(ret = fwnode_property_get_reference_args(dev_fwnode(dev),
751 							prop, NULL, 0,
752 							index, &args));
753 	     index++)
754 		fwnode_handle_put(args.fwnode);
755 
756 	if (!index)
757 		return -ENOENT;
758 
759 	/*
760 	 * Note that right now both -ENODATA and -ENOENT may signal
761 	 * out-of-bounds access. Return the error in cases other than that.
762 	 */
763 	if (ret != -ENOENT && ret != -ENODATA)
764 		return ret;
765 
766 	for (index = 0;
767 	     !fwnode_property_get_reference_args(dev_fwnode(dev), prop, NULL,
768 						 0, index, &args);
769 	     index++) {
770 		struct v4l2_async_subdev *asd;
771 
772 		asd = v4l2_async_notifier_add_fwnode_subdev(notifier,
773 							    args.fwnode,
774 							    sizeof(*asd));
775 		if (IS_ERR(asd)) {
776 			ret = PTR_ERR(asd);
777 			/* not an error if asd already exists */
778 			if (ret == -EEXIST) {
779 				fwnode_handle_put(args.fwnode);
780 				continue;
781 			}
782 
783 			goto error;
784 		}
785 	}
786 
787 	return 0;
788 
789 error:
790 	fwnode_handle_put(args.fwnode);
791 	return ret;
792 }
793 
794 /*
795  * v4l2_fwnode_reference_get_int_prop - parse a reference with integer
796  *					arguments
797  * @fwnode: fwnode to read @prop from
798  * @notifier: notifier for @dev
799  * @prop: the name of the property
800  * @index: the index of the reference to get
801  * @props: the array of integer property names
802  * @nprops: the number of integer property names in @nprops
803  *
804  * First find an fwnode referred to by the reference at @index in @prop.
805  *
806  * Then under that fwnode, @nprops times, for each property in @props,
807  * iteratively follow child nodes starting from fwnode such that they have the
808  * property in @props array at the index of the child node distance from the
809  * root node and the value of that property matching with the integer argument
810  * of the reference, at the same index.
811  *
812  * The child fwnode reached at the end of the iteration is then returned to the
813  * caller.
814  *
815  * The core reason for this is that you cannot refer to just any node in ACPI.
816  * So to refer to an endpoint (easy in DT) you need to refer to a device, then
817  * provide a list of (property name, property value) tuples where each tuple
818  * uniquely identifies a child node. The first tuple identifies a child directly
819  * underneath the device fwnode, the next tuple identifies a child node
820  * underneath the fwnode identified by the previous tuple, etc. until you
821  * reached the fwnode you need.
822  *
823  * An example with a graph, as defined in Documentation/acpi/dsd/graph.txt:
824  *
825  *	Scope (\_SB.PCI0.I2C2)
826  *	{
827  *		Device (CAM0)
828  *		{
829  *			Name (_DSD, Package () {
830  *				ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
831  *				Package () {
832  *					Package () {
833  *						"compatible",
834  *						Package () { "nokia,smia" }
835  *					},
836  *				},
837  *				ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
838  *				Package () {
839  *					Package () { "port0", "PRT0" },
840  *				}
841  *			})
842  *			Name (PRT0, Package() {
843  *				ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
844  *				Package () {
845  *					Package () { "port", 0 },
846  *				},
847  *				ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
848  *				Package () {
849  *					Package () { "endpoint0", "EP00" },
850  *				}
851  *			})
852  *			Name (EP00, Package() {
853  *				ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
854  *				Package () {
855  *					Package () { "endpoint", 0 },
856  *					Package () {
857  *						"remote-endpoint",
858  *						Package() {
859  *							\_SB.PCI0.ISP, 4, 0
860  *						}
861  *					},
862  *				}
863  *			})
864  *		}
865  *	}
866  *
867  *	Scope (\_SB.PCI0)
868  *	{
869  *		Device (ISP)
870  *		{
871  *			Name (_DSD, Package () {
872  *				ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
873  *				Package () {
874  *					Package () { "port4", "PRT4" },
875  *				}
876  *			})
877  *
878  *			Name (PRT4, Package() {
879  *				ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
880  *				Package () {
881  *					Package () { "port", 4 },
882  *				},
883  *				ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
884  *				Package () {
885  *					Package () { "endpoint0", "EP40" },
886  *				}
887  *			})
888  *
889  *			Name (EP40, Package() {
890  *				ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
891  *				Package () {
892  *					Package () { "endpoint", 0 },
893  *					Package () {
894  *						"remote-endpoint",
895  *						Package () {
896  *							\_SB.PCI0.I2C2.CAM0,
897  *							0, 0
898  *						}
899  *					},
900  *				}
901  *			})
902  *		}
903  *	}
904  *
905  * From the EP40 node under ISP device, you could parse the graph remote
906  * endpoint using v4l2_fwnode_reference_get_int_prop with these arguments:
907  *
908  *  @fwnode: fwnode referring to EP40 under ISP.
909  *  @prop: "remote-endpoint"
910  *  @index: 0
911  *  @props: "port", "endpoint"
912  *  @nprops: 2
913  *
914  * And you'd get back fwnode referring to EP00 under CAM0.
915  *
916  * The same works the other way around: if you use EP00 under CAM0 as the
917  * fwnode, you'll get fwnode referring to EP40 under ISP.
918  *
919  * The same example in DT syntax would look like this:
920  *
921  * cam: cam0 {
922  *	compatible = "nokia,smia";
923  *
924  *	port {
925  *		port = <0>;
926  *		endpoint {
927  *			endpoint = <0>;
928  *			remote-endpoint = <&isp 4 0>;
929  *		};
930  *	};
931  * };
932  *
933  * isp: isp {
934  *	ports {
935  *		port@4 {
936  *			port = <4>;
937  *			endpoint {
938  *				endpoint = <0>;
939  *				remote-endpoint = <&cam 0 0>;
940  *			};
941  *		};
942  *	};
943  * };
944  *
945  * Return: 0 on success
946  *	   -ENOENT if no entries (or the property itself) were found
947  *	   -EINVAL if property parsing otherwise failed
948  *	   -ENOMEM if memory allocation failed
949  */
950 static struct fwnode_handle *
951 v4l2_fwnode_reference_get_int_prop(struct fwnode_handle *fwnode,
952 				   const char *prop,
953 				   unsigned int index,
954 				   const char * const *props,
955 				   unsigned int nprops)
956 {
957 	struct fwnode_reference_args fwnode_args;
958 	u64 *args = fwnode_args.args;
959 	struct fwnode_handle *child;
960 	int ret;
961 
962 	/*
963 	 * Obtain remote fwnode as well as the integer arguments.
964 	 *
965 	 * Note that right now both -ENODATA and -ENOENT may signal
966 	 * out-of-bounds access. Return -ENOENT in that case.
967 	 */
968 	ret = fwnode_property_get_reference_args(fwnode, prop, NULL, nprops,
969 						 index, &fwnode_args);
970 	if (ret)
971 		return ERR_PTR(ret == -ENODATA ? -ENOENT : ret);
972 
973 	/*
974 	 * Find a node in the tree under the referred fwnode corresponding to
975 	 * the integer arguments.
976 	 */
977 	fwnode = fwnode_args.fwnode;
978 	while (nprops--) {
979 		u32 val;
980 
981 		/* Loop over all child nodes under fwnode. */
982 		fwnode_for_each_child_node(fwnode, child) {
983 			if (fwnode_property_read_u32(child, *props, &val))
984 				continue;
985 
986 			/* Found property, see if its value matches. */
987 			if (val == *args)
988 				break;
989 		}
990 
991 		fwnode_handle_put(fwnode);
992 
993 		/* No property found; return an error here. */
994 		if (!child) {
995 			fwnode = ERR_PTR(-ENOENT);
996 			break;
997 		}
998 
999 		props++;
1000 		args++;
1001 		fwnode = child;
1002 	}
1003 
1004 	return fwnode;
1005 }
1006 
1007 struct v4l2_fwnode_int_props {
1008 	const char *name;
1009 	const char * const *props;
1010 	unsigned int nprops;
1011 };
1012 
1013 /*
1014  * v4l2_fwnode_reference_parse_int_props - parse references for async
1015  *					   sub-devices
1016  * @dev: struct device pointer
1017  * @notifier: notifier for @dev
1018  * @prop: the name of the property
1019  * @props: the array of integer property names
1020  * @nprops: the number of integer properties
1021  *
1022  * Use v4l2_fwnode_reference_get_int_prop to find fwnodes through reference in
1023  * property @prop with integer arguments with child nodes matching in properties
1024  * @props. Then, set up V4L2 async sub-devices for those fwnodes in the notifier
1025  * accordingly.
1026  *
1027  * While it is technically possible to use this function on DT, it is only
1028  * meaningful on ACPI. On Device tree you can refer to any node in the tree but
1029  * on ACPI the references are limited to devices.
1030  *
1031  * Return: 0 on success
1032  *	   -ENOENT if no entries (or the property itself) were found
1033  *	   -EINVAL if property parsing otherwisefailed
1034  *	   -ENOMEM if memory allocation failed
1035  */
1036 static int
1037 v4l2_fwnode_reference_parse_int_props(struct device *dev,
1038 				      struct v4l2_async_notifier *notifier,
1039 				      const struct v4l2_fwnode_int_props *p)
1040 {
1041 	struct fwnode_handle *fwnode;
1042 	unsigned int index;
1043 	int ret;
1044 	const char *prop = p->name;
1045 	const char * const *props = p->props;
1046 	unsigned int nprops = p->nprops;
1047 
1048 	index = 0;
1049 	do {
1050 		fwnode = v4l2_fwnode_reference_get_int_prop(dev_fwnode(dev),
1051 							    prop, index,
1052 							    props, nprops);
1053 		if (IS_ERR(fwnode)) {
1054 			/*
1055 			 * Note that right now both -ENODATA and -ENOENT may
1056 			 * signal out-of-bounds access. Return the error in
1057 			 * cases other than that.
1058 			 */
1059 			if (PTR_ERR(fwnode) != -ENOENT &&
1060 			    PTR_ERR(fwnode) != -ENODATA)
1061 				return PTR_ERR(fwnode);
1062 			break;
1063 		}
1064 		fwnode_handle_put(fwnode);
1065 		index++;
1066 	} while (1);
1067 
1068 	for (index = 0;
1069 	     !IS_ERR((fwnode = v4l2_fwnode_reference_get_int_prop(dev_fwnode(dev),
1070 								  prop, index,
1071 								  props,
1072 								  nprops)));
1073 	     index++) {
1074 		struct v4l2_async_subdev *asd;
1075 
1076 		asd = v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode,
1077 							    sizeof(*asd));
1078 		if (IS_ERR(asd)) {
1079 			ret = PTR_ERR(asd);
1080 			/* not an error if asd already exists */
1081 			if (ret == -EEXIST) {
1082 				fwnode_handle_put(fwnode);
1083 				continue;
1084 			}
1085 
1086 			goto error;
1087 		}
1088 	}
1089 
1090 	return PTR_ERR(fwnode) == -ENOENT ? 0 : PTR_ERR(fwnode);
1091 
1092 error:
1093 	fwnode_handle_put(fwnode);
1094 	return ret;
1095 }
1096 
1097 int v4l2_async_notifier_parse_fwnode_sensor_common(struct device *dev,
1098 						   struct v4l2_async_notifier *notifier)
1099 {
1100 	static const char * const led_props[] = { "led" };
1101 	static const struct v4l2_fwnode_int_props props[] = {
1102 		{ "flash-leds", led_props, ARRAY_SIZE(led_props) },
1103 		{ "lens-focus", NULL, 0 },
1104 	};
1105 	unsigned int i;
1106 
1107 	for (i = 0; i < ARRAY_SIZE(props); i++) {
1108 		int ret;
1109 
1110 		if (props[i].props && is_acpi_node(dev_fwnode(dev)))
1111 			ret = v4l2_fwnode_reference_parse_int_props(dev,
1112 								    notifier,
1113 								    &props[i]);
1114 		else
1115 			ret = v4l2_fwnode_reference_parse(dev, notifier,
1116 							  props[i].name);
1117 		if (ret && ret != -ENOENT) {
1118 			dev_warn(dev, "parsing property \"%s\" failed (%d)\n",
1119 				 props[i].name, ret);
1120 			return ret;
1121 		}
1122 	}
1123 
1124 	return 0;
1125 }
1126 EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_sensor_common);
1127 
1128 int v4l2_async_register_subdev_sensor_common(struct v4l2_subdev *sd)
1129 {
1130 	struct v4l2_async_notifier *notifier;
1131 	int ret;
1132 
1133 	if (WARN_ON(!sd->dev))
1134 		return -ENODEV;
1135 
1136 	notifier = kzalloc(sizeof(*notifier), GFP_KERNEL);
1137 	if (!notifier)
1138 		return -ENOMEM;
1139 
1140 	v4l2_async_notifier_init(notifier);
1141 
1142 	ret = v4l2_async_notifier_parse_fwnode_sensor_common(sd->dev,
1143 							     notifier);
1144 	if (ret < 0)
1145 		goto out_cleanup;
1146 
1147 	ret = v4l2_async_subdev_notifier_register(sd, notifier);
1148 	if (ret < 0)
1149 		goto out_cleanup;
1150 
1151 	ret = v4l2_async_register_subdev(sd);
1152 	if (ret < 0)
1153 		goto out_unregister;
1154 
1155 	sd->subdev_notifier = notifier;
1156 
1157 	return 0;
1158 
1159 out_unregister:
1160 	v4l2_async_notifier_unregister(notifier);
1161 
1162 out_cleanup:
1163 	v4l2_async_notifier_cleanup(notifier);
1164 	kfree(notifier);
1165 
1166 	return ret;
1167 }
1168 EXPORT_SYMBOL_GPL(v4l2_async_register_subdev_sensor_common);
1169 
1170 int v4l2_async_register_fwnode_subdev(struct v4l2_subdev *sd,
1171 				      size_t asd_struct_size,
1172 				      unsigned int *ports,
1173 				      unsigned int num_ports,
1174 				      parse_endpoint_func parse_endpoint)
1175 {
1176 	struct v4l2_async_notifier *notifier;
1177 	struct device *dev = sd->dev;
1178 	struct fwnode_handle *fwnode;
1179 	int ret;
1180 
1181 	if (WARN_ON(!dev))
1182 		return -ENODEV;
1183 
1184 	fwnode = dev_fwnode(dev);
1185 	if (!fwnode_device_is_available(fwnode))
1186 		return -ENODEV;
1187 
1188 	notifier = kzalloc(sizeof(*notifier), GFP_KERNEL);
1189 	if (!notifier)
1190 		return -ENOMEM;
1191 
1192 	v4l2_async_notifier_init(notifier);
1193 
1194 	if (!ports) {
1195 		ret = v4l2_async_notifier_parse_fwnode_endpoints(dev, notifier,
1196 								 asd_struct_size,
1197 								 parse_endpoint);
1198 		if (ret < 0)
1199 			goto out_cleanup;
1200 	} else {
1201 		unsigned int i;
1202 
1203 		for (i = 0; i < num_ports; i++) {
1204 			ret = v4l2_async_notifier_parse_fwnode_endpoints_by_port(dev, notifier, asd_struct_size, ports[i], parse_endpoint);
1205 			if (ret < 0)
1206 				goto out_cleanup;
1207 		}
1208 	}
1209 
1210 	ret = v4l2_async_subdev_notifier_register(sd, notifier);
1211 	if (ret < 0)
1212 		goto out_cleanup;
1213 
1214 	ret = v4l2_async_register_subdev(sd);
1215 	if (ret < 0)
1216 		goto out_unregister;
1217 
1218 	sd->subdev_notifier = notifier;
1219 
1220 	return 0;
1221 
1222 out_unregister:
1223 	v4l2_async_notifier_unregister(notifier);
1224 out_cleanup:
1225 	v4l2_async_notifier_cleanup(notifier);
1226 	kfree(notifier);
1227 
1228 	return ret;
1229 }
1230 EXPORT_SYMBOL_GPL(v4l2_async_register_fwnode_subdev);
1231 
1232 MODULE_LICENSE("GPL");
1233 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>");
1234 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
1235 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
1236