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