1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * V4L2 sub-device
4  *
5  * Copyright (C) 2010 Nokia Corporation
6  *
7  * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
8  *	    Sakari Ailus <sakari.ailus@iki.fi>
9  */
10 
11 #include <linux/export.h>
12 #include <linux/ioctl.h>
13 #include <linux/leds.h>
14 #include <linux/mm.h>
15 #include <linux/module.h>
16 #include <linux/overflow.h>
17 #include <linux/slab.h>
18 #include <linux/types.h>
19 #include <linux/version.h>
20 #include <linux/videodev2.h>
21 
22 #include <media/v4l2-ctrls.h>
23 #include <media/v4l2-device.h>
24 #include <media/v4l2-event.h>
25 #include <media/v4l2-fh.h>
26 #include <media/v4l2-ioctl.h>
27 
28 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
29 /*
30  * The Streams API is an experimental feature. To use the Streams API, set
31  * 'v4l2_subdev_enable_streams_api' to 1 below.
32  */
33 
34 static bool v4l2_subdev_enable_streams_api;
35 #endif
36 
37 /*
38  * Maximum stream ID is 63 for now, as we use u64 bitmask to represent a set
39  * of streams.
40  *
41  * Note that V4L2_FRAME_DESC_ENTRY_MAX is related: V4L2_FRAME_DESC_ENTRY_MAX
42  * restricts the total number of streams in a pad, although the stream ID is
43  * not restricted.
44  */
45 #define V4L2_SUBDEV_MAX_STREAM_ID 63
46 
47 #include "v4l2-subdev-priv.h"
48 
49 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
50 static int subdev_fh_init(struct v4l2_subdev_fh *fh, struct v4l2_subdev *sd)
51 {
52 	struct v4l2_subdev_state *state;
53 	static struct lock_class_key key;
54 
55 	state = __v4l2_subdev_state_alloc(sd, "fh->state->lock", &key);
56 	if (IS_ERR(state))
57 		return PTR_ERR(state);
58 
59 	fh->state = state;
60 
61 	return 0;
62 }
63 
64 static void subdev_fh_free(struct v4l2_subdev_fh *fh)
65 {
66 	__v4l2_subdev_state_free(fh->state);
67 	fh->state = NULL;
68 }
69 
70 static int subdev_open(struct file *file)
71 {
72 	struct video_device *vdev = video_devdata(file);
73 	struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
74 	struct v4l2_subdev_fh *subdev_fh;
75 	int ret;
76 
77 	subdev_fh = kzalloc(sizeof(*subdev_fh), GFP_KERNEL);
78 	if (subdev_fh == NULL)
79 		return -ENOMEM;
80 
81 	ret = subdev_fh_init(subdev_fh, sd);
82 	if (ret) {
83 		kfree(subdev_fh);
84 		return ret;
85 	}
86 
87 	v4l2_fh_init(&subdev_fh->vfh, vdev);
88 	v4l2_fh_add(&subdev_fh->vfh);
89 	file->private_data = &subdev_fh->vfh;
90 
91 	if (sd->v4l2_dev->mdev && sd->entity.graph_obj.mdev->dev) {
92 		struct module *owner;
93 
94 		owner = sd->entity.graph_obj.mdev->dev->driver->owner;
95 		if (!try_module_get(owner)) {
96 			ret = -EBUSY;
97 			goto err;
98 		}
99 		subdev_fh->owner = owner;
100 	}
101 
102 	if (sd->internal_ops && sd->internal_ops->open) {
103 		ret = sd->internal_ops->open(sd, subdev_fh);
104 		if (ret < 0)
105 			goto err;
106 	}
107 
108 	return 0;
109 
110 err:
111 	module_put(subdev_fh->owner);
112 	v4l2_fh_del(&subdev_fh->vfh);
113 	v4l2_fh_exit(&subdev_fh->vfh);
114 	subdev_fh_free(subdev_fh);
115 	kfree(subdev_fh);
116 
117 	return ret;
118 }
119 
120 static int subdev_close(struct file *file)
121 {
122 	struct video_device *vdev = video_devdata(file);
123 	struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
124 	struct v4l2_fh *vfh = file->private_data;
125 	struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh);
126 
127 	if (sd->internal_ops && sd->internal_ops->close)
128 		sd->internal_ops->close(sd, subdev_fh);
129 	module_put(subdev_fh->owner);
130 	v4l2_fh_del(vfh);
131 	v4l2_fh_exit(vfh);
132 	subdev_fh_free(subdev_fh);
133 	kfree(subdev_fh);
134 	file->private_data = NULL;
135 
136 	return 0;
137 }
138 #else /* CONFIG_VIDEO_V4L2_SUBDEV_API */
139 static int subdev_open(struct file *file)
140 {
141 	return -ENODEV;
142 }
143 
144 static int subdev_close(struct file *file)
145 {
146 	return -ENODEV;
147 }
148 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */
149 
150 static inline int check_which(u32 which)
151 {
152 	if (which != V4L2_SUBDEV_FORMAT_TRY &&
153 	    which != V4L2_SUBDEV_FORMAT_ACTIVE)
154 		return -EINVAL;
155 
156 	return 0;
157 }
158 
159 static inline int check_pad(struct v4l2_subdev *sd, u32 pad)
160 {
161 #if defined(CONFIG_MEDIA_CONTROLLER)
162 	if (sd->entity.num_pads) {
163 		if (pad >= sd->entity.num_pads)
164 			return -EINVAL;
165 		return 0;
166 	}
167 #endif
168 	/* allow pad 0 on subdevices not registered as media entities */
169 	if (pad > 0)
170 		return -EINVAL;
171 	return 0;
172 }
173 
174 static int check_state(struct v4l2_subdev *sd, struct v4l2_subdev_state *state,
175 		       u32 which, u32 pad, u32 stream)
176 {
177 	if (sd->flags & V4L2_SUBDEV_FL_STREAMS) {
178 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
179 		if (!v4l2_subdev_state_get_stream_format(state, pad, stream))
180 			return -EINVAL;
181 		return 0;
182 #else
183 		return -EINVAL;
184 #endif
185 	}
186 
187 	if (stream != 0)
188 		return -EINVAL;
189 
190 	if (which == V4L2_SUBDEV_FORMAT_TRY && (!state || !state->pads))
191 		return -EINVAL;
192 
193 	return 0;
194 }
195 
196 static inline int check_format(struct v4l2_subdev *sd,
197 			       struct v4l2_subdev_state *state,
198 			       struct v4l2_subdev_format *format)
199 {
200 	if (!format)
201 		return -EINVAL;
202 
203 	return check_which(format->which) ? : check_pad(sd, format->pad) ? :
204 	       check_state(sd, state, format->which, format->pad, format->stream);
205 }
206 
207 static int call_get_fmt(struct v4l2_subdev *sd,
208 			struct v4l2_subdev_state *state,
209 			struct v4l2_subdev_format *format)
210 {
211 	return check_format(sd, state, format) ? :
212 	       sd->ops->pad->get_fmt(sd, state, format);
213 }
214 
215 static int call_set_fmt(struct v4l2_subdev *sd,
216 			struct v4l2_subdev_state *state,
217 			struct v4l2_subdev_format *format)
218 {
219 	return check_format(sd, state, format) ? :
220 	       sd->ops->pad->set_fmt(sd, state, format);
221 }
222 
223 static int call_enum_mbus_code(struct v4l2_subdev *sd,
224 			       struct v4l2_subdev_state *state,
225 			       struct v4l2_subdev_mbus_code_enum *code)
226 {
227 	if (!code)
228 		return -EINVAL;
229 
230 	return check_which(code->which) ? : check_pad(sd, code->pad) ? :
231 	       check_state(sd, state, code->which, code->pad, code->stream) ? :
232 	       sd->ops->pad->enum_mbus_code(sd, state, code);
233 }
234 
235 static int call_enum_frame_size(struct v4l2_subdev *sd,
236 				struct v4l2_subdev_state *state,
237 				struct v4l2_subdev_frame_size_enum *fse)
238 {
239 	if (!fse)
240 		return -EINVAL;
241 
242 	return check_which(fse->which) ? : check_pad(sd, fse->pad) ? :
243 	       check_state(sd, state, fse->which, fse->pad, fse->stream) ? :
244 	       sd->ops->pad->enum_frame_size(sd, state, fse);
245 }
246 
247 static inline int check_frame_interval(struct v4l2_subdev *sd,
248 				       struct v4l2_subdev_frame_interval *fi)
249 {
250 	if (!fi)
251 		return -EINVAL;
252 
253 	return check_pad(sd, fi->pad);
254 }
255 
256 static int call_g_frame_interval(struct v4l2_subdev *sd,
257 				 struct v4l2_subdev_frame_interval *fi)
258 {
259 	return check_frame_interval(sd, fi) ? :
260 	       sd->ops->video->g_frame_interval(sd, fi);
261 }
262 
263 static int call_s_frame_interval(struct v4l2_subdev *sd,
264 				 struct v4l2_subdev_frame_interval *fi)
265 {
266 	return check_frame_interval(sd, fi) ? :
267 	       sd->ops->video->s_frame_interval(sd, fi);
268 }
269 
270 static int call_enum_frame_interval(struct v4l2_subdev *sd,
271 				    struct v4l2_subdev_state *state,
272 				    struct v4l2_subdev_frame_interval_enum *fie)
273 {
274 	if (!fie)
275 		return -EINVAL;
276 
277 	return check_which(fie->which) ? : check_pad(sd, fie->pad) ? :
278 	       check_state(sd, state, fie->which, fie->pad, fie->stream) ? :
279 	       sd->ops->pad->enum_frame_interval(sd, state, fie);
280 }
281 
282 static inline int check_selection(struct v4l2_subdev *sd,
283 				  struct v4l2_subdev_state *state,
284 				  struct v4l2_subdev_selection *sel)
285 {
286 	if (!sel)
287 		return -EINVAL;
288 
289 	return check_which(sel->which) ? : check_pad(sd, sel->pad) ? :
290 	       check_state(sd, state, sel->which, sel->pad, sel->stream);
291 }
292 
293 static int call_get_selection(struct v4l2_subdev *sd,
294 			      struct v4l2_subdev_state *state,
295 			      struct v4l2_subdev_selection *sel)
296 {
297 	return check_selection(sd, state, sel) ? :
298 	       sd->ops->pad->get_selection(sd, state, sel);
299 }
300 
301 static int call_set_selection(struct v4l2_subdev *sd,
302 			      struct v4l2_subdev_state *state,
303 			      struct v4l2_subdev_selection *sel)
304 {
305 	return check_selection(sd, state, sel) ? :
306 	       sd->ops->pad->set_selection(sd, state, sel);
307 }
308 
309 static inline int check_edid(struct v4l2_subdev *sd,
310 			     struct v4l2_subdev_edid *edid)
311 {
312 	if (!edid)
313 		return -EINVAL;
314 
315 	if (edid->blocks && edid->edid == NULL)
316 		return -EINVAL;
317 
318 	return check_pad(sd, edid->pad);
319 }
320 
321 static int call_get_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid)
322 {
323 	return check_edid(sd, edid) ? : sd->ops->pad->get_edid(sd, edid);
324 }
325 
326 static int call_set_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid)
327 {
328 	return check_edid(sd, edid) ? : sd->ops->pad->set_edid(sd, edid);
329 }
330 
331 static int call_dv_timings_cap(struct v4l2_subdev *sd,
332 			       struct v4l2_dv_timings_cap *cap)
333 {
334 	if (!cap)
335 		return -EINVAL;
336 
337 	return check_pad(sd, cap->pad) ? :
338 	       sd->ops->pad->dv_timings_cap(sd, cap);
339 }
340 
341 static int call_enum_dv_timings(struct v4l2_subdev *sd,
342 				struct v4l2_enum_dv_timings *dvt)
343 {
344 	if (!dvt)
345 		return -EINVAL;
346 
347 	return check_pad(sd, dvt->pad) ? :
348 	       sd->ops->pad->enum_dv_timings(sd, dvt);
349 }
350 
351 static int call_get_mbus_config(struct v4l2_subdev *sd, unsigned int pad,
352 				struct v4l2_mbus_config *config)
353 {
354 	return check_pad(sd, pad) ? :
355 	       sd->ops->pad->get_mbus_config(sd, pad, config);
356 }
357 
358 static int call_s_stream(struct v4l2_subdev *sd, int enable)
359 {
360 	int ret;
361 
362 	/*
363 	 * The .s_stream() operation must never be called to start or stop an
364 	 * already started or stopped subdev. Catch offenders but don't return
365 	 * an error yet to avoid regressions.
366 	 *
367 	 * As .s_stream() is mutually exclusive with the .enable_streams() and
368 	 * .disable_streams() operation, we can use the enabled_streams field
369 	 * to store the subdev streaming state.
370 	 */
371 	if (WARN_ON(!!sd->enabled_streams == !!enable))
372 		return 0;
373 
374 	ret = sd->ops->video->s_stream(sd, enable);
375 
376 	if (!enable && ret < 0) {
377 		dev_warn(sd->dev, "disabling streaming failed (%d)\n", ret);
378 		ret = 0;
379 	}
380 
381 	if (!ret) {
382 		sd->enabled_streams = enable ? BIT(0) : 0;
383 
384 #if IS_REACHABLE(CONFIG_LEDS_CLASS)
385 		if (!IS_ERR_OR_NULL(sd->privacy_led)) {
386 			if (enable)
387 				led_set_brightness(sd->privacy_led,
388 						   sd->privacy_led->max_brightness);
389 			else
390 				led_set_brightness(sd->privacy_led, 0);
391 		}
392 #endif
393 	}
394 
395 	return ret;
396 }
397 
398 #ifdef CONFIG_MEDIA_CONTROLLER
399 /*
400  * Create state-management wrapper for pad ops dealing with subdev state. The
401  * wrapper handles the case where the caller does not provide the called
402  * subdev's state. This should be removed when all the callers are fixed.
403  */
404 #define DEFINE_STATE_WRAPPER(f, arg_type)                                  \
405 	static int call_##f##_state(struct v4l2_subdev *sd,                \
406 				    struct v4l2_subdev_state *_state,      \
407 				    arg_type *arg)                         \
408 	{                                                                  \
409 		struct v4l2_subdev_state *state = _state;                  \
410 		int ret;                                                   \
411 		if (!_state)                                               \
412 			state = v4l2_subdev_lock_and_get_active_state(sd); \
413 		ret = call_##f(sd, state, arg);                            \
414 		if (!_state && state)                                      \
415 			v4l2_subdev_unlock_state(state);                   \
416 		return ret;                                                \
417 	}
418 
419 #else /* CONFIG_MEDIA_CONTROLLER */
420 
421 #define DEFINE_STATE_WRAPPER(f, arg_type)                            \
422 	static int call_##f##_state(struct v4l2_subdev *sd,          \
423 				    struct v4l2_subdev_state *state, \
424 				    arg_type *arg)                   \
425 	{                                                            \
426 		return call_##f(sd, state, arg);                     \
427 	}
428 
429 #endif /* CONFIG_MEDIA_CONTROLLER */
430 
431 DEFINE_STATE_WRAPPER(get_fmt, struct v4l2_subdev_format);
432 DEFINE_STATE_WRAPPER(set_fmt, struct v4l2_subdev_format);
433 DEFINE_STATE_WRAPPER(enum_mbus_code, struct v4l2_subdev_mbus_code_enum);
434 DEFINE_STATE_WRAPPER(enum_frame_size, struct v4l2_subdev_frame_size_enum);
435 DEFINE_STATE_WRAPPER(enum_frame_interval, struct v4l2_subdev_frame_interval_enum);
436 DEFINE_STATE_WRAPPER(get_selection, struct v4l2_subdev_selection);
437 DEFINE_STATE_WRAPPER(set_selection, struct v4l2_subdev_selection);
438 
439 static const struct v4l2_subdev_pad_ops v4l2_subdev_call_pad_wrappers = {
440 	.get_fmt		= call_get_fmt_state,
441 	.set_fmt		= call_set_fmt_state,
442 	.enum_mbus_code		= call_enum_mbus_code_state,
443 	.enum_frame_size	= call_enum_frame_size_state,
444 	.enum_frame_interval	= call_enum_frame_interval_state,
445 	.get_selection		= call_get_selection_state,
446 	.set_selection		= call_set_selection_state,
447 	.get_edid		= call_get_edid,
448 	.set_edid		= call_set_edid,
449 	.dv_timings_cap		= call_dv_timings_cap,
450 	.enum_dv_timings	= call_enum_dv_timings,
451 	.get_mbus_config	= call_get_mbus_config,
452 };
453 
454 static const struct v4l2_subdev_video_ops v4l2_subdev_call_video_wrappers = {
455 	.g_frame_interval	= call_g_frame_interval,
456 	.s_frame_interval	= call_s_frame_interval,
457 	.s_stream		= call_s_stream,
458 };
459 
460 const struct v4l2_subdev_ops v4l2_subdev_call_wrappers = {
461 	.pad	= &v4l2_subdev_call_pad_wrappers,
462 	.video	= &v4l2_subdev_call_video_wrappers,
463 };
464 EXPORT_SYMBOL(v4l2_subdev_call_wrappers);
465 
466 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
467 
468 static struct v4l2_subdev_state *
469 subdev_ioctl_get_state(struct v4l2_subdev *sd, struct v4l2_subdev_fh *subdev_fh,
470 		       unsigned int cmd, void *arg)
471 {
472 	u32 which;
473 
474 	switch (cmd) {
475 	default:
476 		return NULL;
477 	case VIDIOC_SUBDEV_G_FMT:
478 	case VIDIOC_SUBDEV_S_FMT:
479 		which = ((struct v4l2_subdev_format *)arg)->which;
480 		break;
481 	case VIDIOC_SUBDEV_G_CROP:
482 	case VIDIOC_SUBDEV_S_CROP:
483 		which = ((struct v4l2_subdev_crop *)arg)->which;
484 		break;
485 	case VIDIOC_SUBDEV_ENUM_MBUS_CODE:
486 		which = ((struct v4l2_subdev_mbus_code_enum *)arg)->which;
487 		break;
488 	case VIDIOC_SUBDEV_ENUM_FRAME_SIZE:
489 		which = ((struct v4l2_subdev_frame_size_enum *)arg)->which;
490 		break;
491 	case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL:
492 		which = ((struct v4l2_subdev_frame_interval_enum *)arg)->which;
493 		break;
494 	case VIDIOC_SUBDEV_G_SELECTION:
495 	case VIDIOC_SUBDEV_S_SELECTION:
496 		which = ((struct v4l2_subdev_selection *)arg)->which;
497 		break;
498 	case VIDIOC_SUBDEV_G_ROUTING:
499 	case VIDIOC_SUBDEV_S_ROUTING:
500 		which = ((struct v4l2_subdev_routing *)arg)->which;
501 		break;
502 	}
503 
504 	return which == V4L2_SUBDEV_FORMAT_TRY ?
505 			     subdev_fh->state :
506 			     v4l2_subdev_get_unlocked_active_state(sd);
507 }
508 
509 static long subdev_do_ioctl(struct file *file, unsigned int cmd, void *arg,
510 			    struct v4l2_subdev_state *state)
511 {
512 	struct video_device *vdev = video_devdata(file);
513 	struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
514 	struct v4l2_fh *vfh = file->private_data;
515 	struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh);
516 	bool ro_subdev = test_bit(V4L2_FL_SUBDEV_RO_DEVNODE, &vdev->flags);
517 	bool streams_subdev = sd->flags & V4L2_SUBDEV_FL_STREAMS;
518 	bool client_supports_streams = subdev_fh->client_caps &
519 				       V4L2_SUBDEV_CLIENT_CAP_STREAMS;
520 	int rval;
521 
522 	/*
523 	 * If the streams API is not enabled, remove V4L2_SUBDEV_CAP_STREAMS.
524 	 * Remove this when the API is no longer experimental.
525 	 */
526 	if (!v4l2_subdev_enable_streams_api)
527 		streams_subdev = false;
528 
529 	switch (cmd) {
530 	case VIDIOC_SUBDEV_QUERYCAP: {
531 		struct v4l2_subdev_capability *cap = arg;
532 
533 		memset(cap->reserved, 0, sizeof(cap->reserved));
534 		cap->version = LINUX_VERSION_CODE;
535 		cap->capabilities =
536 			(ro_subdev ? V4L2_SUBDEV_CAP_RO_SUBDEV : 0) |
537 			(streams_subdev ? V4L2_SUBDEV_CAP_STREAMS : 0);
538 
539 		return 0;
540 	}
541 
542 	case VIDIOC_QUERYCTRL:
543 		/*
544 		 * TODO: this really should be folded into v4l2_queryctrl (this
545 		 * currently returns -EINVAL for NULL control handlers).
546 		 * However, v4l2_queryctrl() is still called directly by
547 		 * drivers as well and until that has been addressed I believe
548 		 * it is safer to do the check here. The same is true for the
549 		 * other control ioctls below.
550 		 */
551 		if (!vfh->ctrl_handler)
552 			return -ENOTTY;
553 		return v4l2_queryctrl(vfh->ctrl_handler, arg);
554 
555 	case VIDIOC_QUERY_EXT_CTRL:
556 		if (!vfh->ctrl_handler)
557 			return -ENOTTY;
558 		return v4l2_query_ext_ctrl(vfh->ctrl_handler, arg);
559 
560 	case VIDIOC_QUERYMENU:
561 		if (!vfh->ctrl_handler)
562 			return -ENOTTY;
563 		return v4l2_querymenu(vfh->ctrl_handler, arg);
564 
565 	case VIDIOC_G_CTRL:
566 		if (!vfh->ctrl_handler)
567 			return -ENOTTY;
568 		return v4l2_g_ctrl(vfh->ctrl_handler, arg);
569 
570 	case VIDIOC_S_CTRL:
571 		if (!vfh->ctrl_handler)
572 			return -ENOTTY;
573 		return v4l2_s_ctrl(vfh, vfh->ctrl_handler, arg);
574 
575 	case VIDIOC_G_EXT_CTRLS:
576 		if (!vfh->ctrl_handler)
577 			return -ENOTTY;
578 		return v4l2_g_ext_ctrls(vfh->ctrl_handler,
579 					vdev, sd->v4l2_dev->mdev, arg);
580 
581 	case VIDIOC_S_EXT_CTRLS:
582 		if (!vfh->ctrl_handler)
583 			return -ENOTTY;
584 		return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler,
585 					vdev, sd->v4l2_dev->mdev, arg);
586 
587 	case VIDIOC_TRY_EXT_CTRLS:
588 		if (!vfh->ctrl_handler)
589 			return -ENOTTY;
590 		return v4l2_try_ext_ctrls(vfh->ctrl_handler,
591 					  vdev, sd->v4l2_dev->mdev, arg);
592 
593 	case VIDIOC_DQEVENT:
594 		if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS))
595 			return -ENOIOCTLCMD;
596 
597 		return v4l2_event_dequeue(vfh, arg, file->f_flags & O_NONBLOCK);
598 
599 	case VIDIOC_SUBSCRIBE_EVENT:
600 		return v4l2_subdev_call(sd, core, subscribe_event, vfh, arg);
601 
602 	case VIDIOC_UNSUBSCRIBE_EVENT:
603 		return v4l2_subdev_call(sd, core, unsubscribe_event, vfh, arg);
604 
605 #ifdef CONFIG_VIDEO_ADV_DEBUG
606 	case VIDIOC_DBG_G_REGISTER:
607 	{
608 		struct v4l2_dbg_register *p = arg;
609 
610 		if (!capable(CAP_SYS_ADMIN))
611 			return -EPERM;
612 		return v4l2_subdev_call(sd, core, g_register, p);
613 	}
614 	case VIDIOC_DBG_S_REGISTER:
615 	{
616 		struct v4l2_dbg_register *p = arg;
617 
618 		if (!capable(CAP_SYS_ADMIN))
619 			return -EPERM;
620 		return v4l2_subdev_call(sd, core, s_register, p);
621 	}
622 	case VIDIOC_DBG_G_CHIP_INFO:
623 	{
624 		struct v4l2_dbg_chip_info *p = arg;
625 
626 		if (p->match.type != V4L2_CHIP_MATCH_SUBDEV || p->match.addr)
627 			return -EINVAL;
628 		if (sd->ops->core && sd->ops->core->s_register)
629 			p->flags |= V4L2_CHIP_FL_WRITABLE;
630 		if (sd->ops->core && sd->ops->core->g_register)
631 			p->flags |= V4L2_CHIP_FL_READABLE;
632 		strscpy(p->name, sd->name, sizeof(p->name));
633 		return 0;
634 	}
635 #endif
636 
637 	case VIDIOC_LOG_STATUS: {
638 		int ret;
639 
640 		pr_info("%s: =================  START STATUS  =================\n",
641 			sd->name);
642 		ret = v4l2_subdev_call(sd, core, log_status);
643 		pr_info("%s: ==================  END STATUS  ==================\n",
644 			sd->name);
645 		return ret;
646 	}
647 
648 	case VIDIOC_SUBDEV_G_FMT: {
649 		struct v4l2_subdev_format *format = arg;
650 
651 		if (!client_supports_streams)
652 			format->stream = 0;
653 
654 		memset(format->reserved, 0, sizeof(format->reserved));
655 		memset(format->format.reserved, 0, sizeof(format->format.reserved));
656 		return v4l2_subdev_call(sd, pad, get_fmt, state, format);
657 	}
658 
659 	case VIDIOC_SUBDEV_S_FMT: {
660 		struct v4l2_subdev_format *format = arg;
661 
662 		if (format->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev)
663 			return -EPERM;
664 
665 		if (!client_supports_streams)
666 			format->stream = 0;
667 
668 		memset(format->reserved, 0, sizeof(format->reserved));
669 		memset(format->format.reserved, 0, sizeof(format->format.reserved));
670 		return v4l2_subdev_call(sd, pad, set_fmt, state, format);
671 	}
672 
673 	case VIDIOC_SUBDEV_G_CROP: {
674 		struct v4l2_subdev_crop *crop = arg;
675 		struct v4l2_subdev_selection sel;
676 
677 		if (!client_supports_streams)
678 			crop->stream = 0;
679 
680 		memset(crop->reserved, 0, sizeof(crop->reserved));
681 		memset(&sel, 0, sizeof(sel));
682 		sel.which = crop->which;
683 		sel.pad = crop->pad;
684 		sel.stream = crop->stream;
685 		sel.target = V4L2_SEL_TGT_CROP;
686 
687 		rval = v4l2_subdev_call(
688 			sd, pad, get_selection, state, &sel);
689 
690 		crop->rect = sel.r;
691 
692 		return rval;
693 	}
694 
695 	case VIDIOC_SUBDEV_S_CROP: {
696 		struct v4l2_subdev_crop *crop = arg;
697 		struct v4l2_subdev_selection sel;
698 
699 		if (crop->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev)
700 			return -EPERM;
701 
702 		if (!client_supports_streams)
703 			crop->stream = 0;
704 
705 		memset(crop->reserved, 0, sizeof(crop->reserved));
706 		memset(&sel, 0, sizeof(sel));
707 		sel.which = crop->which;
708 		sel.pad = crop->pad;
709 		sel.stream = crop->stream;
710 		sel.target = V4L2_SEL_TGT_CROP;
711 		sel.r = crop->rect;
712 
713 		rval = v4l2_subdev_call(
714 			sd, pad, set_selection, state, &sel);
715 
716 		crop->rect = sel.r;
717 
718 		return rval;
719 	}
720 
721 	case VIDIOC_SUBDEV_ENUM_MBUS_CODE: {
722 		struct v4l2_subdev_mbus_code_enum *code = arg;
723 
724 		if (!client_supports_streams)
725 			code->stream = 0;
726 
727 		memset(code->reserved, 0, sizeof(code->reserved));
728 		return v4l2_subdev_call(sd, pad, enum_mbus_code, state,
729 					code);
730 	}
731 
732 	case VIDIOC_SUBDEV_ENUM_FRAME_SIZE: {
733 		struct v4l2_subdev_frame_size_enum *fse = arg;
734 
735 		if (!client_supports_streams)
736 			fse->stream = 0;
737 
738 		memset(fse->reserved, 0, sizeof(fse->reserved));
739 		return v4l2_subdev_call(sd, pad, enum_frame_size, state,
740 					fse);
741 	}
742 
743 	case VIDIOC_SUBDEV_G_FRAME_INTERVAL: {
744 		struct v4l2_subdev_frame_interval *fi = arg;
745 
746 		if (!client_supports_streams)
747 			fi->stream = 0;
748 
749 		memset(fi->reserved, 0, sizeof(fi->reserved));
750 		return v4l2_subdev_call(sd, video, g_frame_interval, arg);
751 	}
752 
753 	case VIDIOC_SUBDEV_S_FRAME_INTERVAL: {
754 		struct v4l2_subdev_frame_interval *fi = arg;
755 
756 		if (ro_subdev)
757 			return -EPERM;
758 
759 		if (!client_supports_streams)
760 			fi->stream = 0;
761 
762 		memset(fi->reserved, 0, sizeof(fi->reserved));
763 		return v4l2_subdev_call(sd, video, s_frame_interval, arg);
764 	}
765 
766 	case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: {
767 		struct v4l2_subdev_frame_interval_enum *fie = arg;
768 
769 		if (!client_supports_streams)
770 			fie->stream = 0;
771 
772 		memset(fie->reserved, 0, sizeof(fie->reserved));
773 		return v4l2_subdev_call(sd, pad, enum_frame_interval, state,
774 					fie);
775 	}
776 
777 	case VIDIOC_SUBDEV_G_SELECTION: {
778 		struct v4l2_subdev_selection *sel = arg;
779 
780 		if (!client_supports_streams)
781 			sel->stream = 0;
782 
783 		memset(sel->reserved, 0, sizeof(sel->reserved));
784 		return v4l2_subdev_call(
785 			sd, pad, get_selection, state, sel);
786 	}
787 
788 	case VIDIOC_SUBDEV_S_SELECTION: {
789 		struct v4l2_subdev_selection *sel = arg;
790 
791 		if (sel->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev)
792 			return -EPERM;
793 
794 		if (!client_supports_streams)
795 			sel->stream = 0;
796 
797 		memset(sel->reserved, 0, sizeof(sel->reserved));
798 		return v4l2_subdev_call(
799 			sd, pad, set_selection, state, sel);
800 	}
801 
802 	case VIDIOC_G_EDID: {
803 		struct v4l2_subdev_edid *edid = arg;
804 
805 		return v4l2_subdev_call(sd, pad, get_edid, edid);
806 	}
807 
808 	case VIDIOC_S_EDID: {
809 		struct v4l2_subdev_edid *edid = arg;
810 
811 		return v4l2_subdev_call(sd, pad, set_edid, edid);
812 	}
813 
814 	case VIDIOC_SUBDEV_DV_TIMINGS_CAP: {
815 		struct v4l2_dv_timings_cap *cap = arg;
816 
817 		return v4l2_subdev_call(sd, pad, dv_timings_cap, cap);
818 	}
819 
820 	case VIDIOC_SUBDEV_ENUM_DV_TIMINGS: {
821 		struct v4l2_enum_dv_timings *dvt = arg;
822 
823 		return v4l2_subdev_call(sd, pad, enum_dv_timings, dvt);
824 	}
825 
826 	case VIDIOC_SUBDEV_QUERY_DV_TIMINGS:
827 		return v4l2_subdev_call(sd, video, query_dv_timings, arg);
828 
829 	case VIDIOC_SUBDEV_G_DV_TIMINGS:
830 		return v4l2_subdev_call(sd, video, g_dv_timings, arg);
831 
832 	case VIDIOC_SUBDEV_S_DV_TIMINGS:
833 		if (ro_subdev)
834 			return -EPERM;
835 
836 		return v4l2_subdev_call(sd, video, s_dv_timings, arg);
837 
838 	case VIDIOC_SUBDEV_G_STD:
839 		return v4l2_subdev_call(sd, video, g_std, arg);
840 
841 	case VIDIOC_SUBDEV_S_STD: {
842 		v4l2_std_id *std = arg;
843 
844 		if (ro_subdev)
845 			return -EPERM;
846 
847 		return v4l2_subdev_call(sd, video, s_std, *std);
848 	}
849 
850 	case VIDIOC_SUBDEV_ENUMSTD: {
851 		struct v4l2_standard *p = arg;
852 		v4l2_std_id id;
853 
854 		if (v4l2_subdev_call(sd, video, g_tvnorms, &id))
855 			return -EINVAL;
856 
857 		return v4l_video_std_enumstd(p, id);
858 	}
859 
860 	case VIDIOC_SUBDEV_QUERYSTD:
861 		return v4l2_subdev_call(sd, video, querystd, arg);
862 
863 	case VIDIOC_SUBDEV_G_ROUTING: {
864 		struct v4l2_subdev_routing *routing = arg;
865 		struct v4l2_subdev_krouting *krouting;
866 
867 		if (!v4l2_subdev_enable_streams_api)
868 			return -ENOIOCTLCMD;
869 
870 		if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS))
871 			return -ENOIOCTLCMD;
872 
873 		memset(routing->reserved, 0, sizeof(routing->reserved));
874 
875 		krouting = &state->routing;
876 
877 		if (routing->num_routes < krouting->num_routes) {
878 			routing->num_routes = krouting->num_routes;
879 			return -ENOSPC;
880 		}
881 
882 		memcpy((struct v4l2_subdev_route *)(uintptr_t)routing->routes,
883 		       krouting->routes,
884 		       krouting->num_routes * sizeof(*krouting->routes));
885 		routing->num_routes = krouting->num_routes;
886 
887 		return 0;
888 	}
889 
890 	case VIDIOC_SUBDEV_S_ROUTING: {
891 		struct v4l2_subdev_routing *routing = arg;
892 		struct v4l2_subdev_route *routes =
893 			(struct v4l2_subdev_route *)(uintptr_t)routing->routes;
894 		struct v4l2_subdev_krouting krouting = {};
895 		unsigned int i;
896 
897 		if (!v4l2_subdev_enable_streams_api)
898 			return -ENOIOCTLCMD;
899 
900 		if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS))
901 			return -ENOIOCTLCMD;
902 
903 		if (routing->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev)
904 			return -EPERM;
905 
906 		memset(routing->reserved, 0, sizeof(routing->reserved));
907 
908 		for (i = 0; i < routing->num_routes; ++i) {
909 			const struct v4l2_subdev_route *route = &routes[i];
910 			const struct media_pad *pads = sd->entity.pads;
911 
912 			if (route->sink_stream > V4L2_SUBDEV_MAX_STREAM_ID ||
913 			    route->source_stream > V4L2_SUBDEV_MAX_STREAM_ID)
914 				return -EINVAL;
915 
916 			if (route->sink_pad >= sd->entity.num_pads)
917 				return -EINVAL;
918 
919 			if (!(pads[route->sink_pad].flags &
920 			      MEDIA_PAD_FL_SINK))
921 				return -EINVAL;
922 
923 			if (route->source_pad >= sd->entity.num_pads)
924 				return -EINVAL;
925 
926 			if (!(pads[route->source_pad].flags &
927 			      MEDIA_PAD_FL_SOURCE))
928 				return -EINVAL;
929 		}
930 
931 		krouting.num_routes = routing->num_routes;
932 		krouting.routes = routes;
933 
934 		return v4l2_subdev_call(sd, pad, set_routing, state,
935 					routing->which, &krouting);
936 	}
937 
938 	case VIDIOC_SUBDEV_G_CLIENT_CAP: {
939 		struct v4l2_subdev_client_capability *client_cap = arg;
940 
941 		client_cap->capabilities = subdev_fh->client_caps;
942 
943 		return 0;
944 	}
945 
946 	case VIDIOC_SUBDEV_S_CLIENT_CAP: {
947 		struct v4l2_subdev_client_capability *client_cap = arg;
948 
949 		/*
950 		 * Clear V4L2_SUBDEV_CLIENT_CAP_STREAMS if streams API is not
951 		 * enabled. Remove this when streams API is no longer
952 		 * experimental.
953 		 */
954 		if (!v4l2_subdev_enable_streams_api)
955 			client_cap->capabilities &= ~V4L2_SUBDEV_CLIENT_CAP_STREAMS;
956 
957 		/* Filter out unsupported capabilities */
958 		client_cap->capabilities &= V4L2_SUBDEV_CLIENT_CAP_STREAMS;
959 
960 		subdev_fh->client_caps = client_cap->capabilities;
961 
962 		return 0;
963 	}
964 
965 	default:
966 		return v4l2_subdev_call(sd, core, ioctl, cmd, arg);
967 	}
968 
969 	return 0;
970 }
971 
972 static long subdev_do_ioctl_lock(struct file *file, unsigned int cmd, void *arg)
973 {
974 	struct video_device *vdev = video_devdata(file);
975 	struct mutex *lock = vdev->lock;
976 	long ret = -ENODEV;
977 
978 	if (lock && mutex_lock_interruptible(lock))
979 		return -ERESTARTSYS;
980 
981 	if (video_is_registered(vdev)) {
982 		struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
983 		struct v4l2_fh *vfh = file->private_data;
984 		struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh);
985 		struct v4l2_subdev_state *state;
986 
987 		state = subdev_ioctl_get_state(sd, subdev_fh, cmd, arg);
988 
989 		if (state)
990 			v4l2_subdev_lock_state(state);
991 
992 		ret = subdev_do_ioctl(file, cmd, arg, state);
993 
994 		if (state)
995 			v4l2_subdev_unlock_state(state);
996 	}
997 
998 	if (lock)
999 		mutex_unlock(lock);
1000 	return ret;
1001 }
1002 
1003 static long subdev_ioctl(struct file *file, unsigned int cmd,
1004 	unsigned long arg)
1005 {
1006 	return video_usercopy(file, cmd, arg, subdev_do_ioctl_lock);
1007 }
1008 
1009 #ifdef CONFIG_COMPAT
1010 static long subdev_compat_ioctl32(struct file *file, unsigned int cmd,
1011 	unsigned long arg)
1012 {
1013 	struct video_device *vdev = video_devdata(file);
1014 	struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
1015 
1016 	return v4l2_subdev_call(sd, core, compat_ioctl32, cmd, arg);
1017 }
1018 #endif
1019 
1020 #else /* CONFIG_VIDEO_V4L2_SUBDEV_API */
1021 static long subdev_ioctl(struct file *file, unsigned int cmd,
1022 			 unsigned long arg)
1023 {
1024 	return -ENODEV;
1025 }
1026 
1027 #ifdef CONFIG_COMPAT
1028 static long subdev_compat_ioctl32(struct file *file, unsigned int cmd,
1029 				  unsigned long arg)
1030 {
1031 	return -ENODEV;
1032 }
1033 #endif
1034 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */
1035 
1036 static __poll_t subdev_poll(struct file *file, poll_table *wait)
1037 {
1038 	struct video_device *vdev = video_devdata(file);
1039 	struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
1040 	struct v4l2_fh *fh = file->private_data;
1041 
1042 	if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS))
1043 		return EPOLLERR;
1044 
1045 	poll_wait(file, &fh->wait, wait);
1046 
1047 	if (v4l2_event_pending(fh))
1048 		return EPOLLPRI;
1049 
1050 	return 0;
1051 }
1052 
1053 const struct v4l2_file_operations v4l2_subdev_fops = {
1054 	.owner = THIS_MODULE,
1055 	.open = subdev_open,
1056 	.unlocked_ioctl = subdev_ioctl,
1057 #ifdef CONFIG_COMPAT
1058 	.compat_ioctl32 = subdev_compat_ioctl32,
1059 #endif
1060 	.release = subdev_close,
1061 	.poll = subdev_poll,
1062 };
1063 
1064 #ifdef CONFIG_MEDIA_CONTROLLER
1065 
1066 int v4l2_subdev_get_fwnode_pad_1_to_1(struct media_entity *entity,
1067 				      struct fwnode_endpoint *endpoint)
1068 {
1069 	struct fwnode_handle *fwnode;
1070 	struct v4l2_subdev *sd;
1071 
1072 	if (!is_media_entity_v4l2_subdev(entity))
1073 		return -EINVAL;
1074 
1075 	sd = media_entity_to_v4l2_subdev(entity);
1076 
1077 	fwnode = fwnode_graph_get_port_parent(endpoint->local_fwnode);
1078 	fwnode_handle_put(fwnode);
1079 
1080 	if (device_match_fwnode(sd->dev, fwnode))
1081 		return endpoint->port;
1082 
1083 	return -ENXIO;
1084 }
1085 EXPORT_SYMBOL_GPL(v4l2_subdev_get_fwnode_pad_1_to_1);
1086 
1087 int v4l2_subdev_link_validate_default(struct v4l2_subdev *sd,
1088 				      struct media_link *link,
1089 				      struct v4l2_subdev_format *source_fmt,
1090 				      struct v4l2_subdev_format *sink_fmt)
1091 {
1092 	bool pass = true;
1093 
1094 	/* The width, height and code must match. */
1095 	if (source_fmt->format.width != sink_fmt->format.width) {
1096 		dev_dbg(sd->entity.graph_obj.mdev->dev,
1097 			"%s: width does not match (source %u, sink %u)\n",
1098 			__func__,
1099 			source_fmt->format.width, sink_fmt->format.width);
1100 		pass = false;
1101 	}
1102 
1103 	if (source_fmt->format.height != sink_fmt->format.height) {
1104 		dev_dbg(sd->entity.graph_obj.mdev->dev,
1105 			"%s: height does not match (source %u, sink %u)\n",
1106 			__func__,
1107 			source_fmt->format.height, sink_fmt->format.height);
1108 		pass = false;
1109 	}
1110 
1111 	if (source_fmt->format.code != sink_fmt->format.code) {
1112 		dev_dbg(sd->entity.graph_obj.mdev->dev,
1113 			"%s: media bus code does not match (source 0x%8.8x, sink 0x%8.8x)\n",
1114 			__func__,
1115 			source_fmt->format.code, sink_fmt->format.code);
1116 		pass = false;
1117 	}
1118 
1119 	/* The field order must match, or the sink field order must be NONE
1120 	 * to support interlaced hardware connected to bridges that support
1121 	 * progressive formats only.
1122 	 */
1123 	if (source_fmt->format.field != sink_fmt->format.field &&
1124 	    sink_fmt->format.field != V4L2_FIELD_NONE) {
1125 		dev_dbg(sd->entity.graph_obj.mdev->dev,
1126 			"%s: field does not match (source %u, sink %u)\n",
1127 			__func__,
1128 			source_fmt->format.field, sink_fmt->format.field);
1129 		pass = false;
1130 	}
1131 
1132 	if (pass)
1133 		return 0;
1134 
1135 	dev_dbg(sd->entity.graph_obj.mdev->dev,
1136 		"%s: link was \"%s\":%u -> \"%s\":%u\n", __func__,
1137 		link->source->entity->name, link->source->index,
1138 		link->sink->entity->name, link->sink->index);
1139 
1140 	return -EPIPE;
1141 }
1142 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate_default);
1143 
1144 static int
1145 v4l2_subdev_link_validate_get_format(struct media_pad *pad, u32 stream,
1146 				     struct v4l2_subdev_format *fmt,
1147 				     bool states_locked)
1148 {
1149 	struct v4l2_subdev_state *state;
1150 	struct v4l2_subdev *sd;
1151 	int ret;
1152 
1153 	if (!is_media_entity_v4l2_subdev(pad->entity)) {
1154 		WARN(pad->entity->function != MEDIA_ENT_F_IO_V4L,
1155 		     "Driver bug! Wrong media entity type 0x%08x, entity %s\n",
1156 		     pad->entity->function, pad->entity->name);
1157 
1158 		return -EINVAL;
1159 	}
1160 
1161 	sd = media_entity_to_v4l2_subdev(pad->entity);
1162 
1163 	fmt->which = V4L2_SUBDEV_FORMAT_ACTIVE;
1164 	fmt->pad = pad->index;
1165 	fmt->stream = stream;
1166 
1167 	if (states_locked)
1168 		state = v4l2_subdev_get_locked_active_state(sd);
1169 	else
1170 		state = v4l2_subdev_lock_and_get_active_state(sd);
1171 
1172 	ret = v4l2_subdev_call(sd, pad, get_fmt, state, fmt);
1173 
1174 	if (!states_locked && state)
1175 		v4l2_subdev_unlock_state(state);
1176 
1177 	return ret;
1178 }
1179 
1180 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
1181 
1182 static void __v4l2_link_validate_get_streams(struct media_pad *pad,
1183 					     u64 *streams_mask,
1184 					     bool states_locked)
1185 {
1186 	struct v4l2_subdev_route *route;
1187 	struct v4l2_subdev_state *state;
1188 	struct v4l2_subdev *subdev;
1189 
1190 	subdev = media_entity_to_v4l2_subdev(pad->entity);
1191 
1192 	*streams_mask = 0;
1193 
1194 	if (states_locked)
1195 		state = v4l2_subdev_get_locked_active_state(subdev);
1196 	else
1197 		state = v4l2_subdev_lock_and_get_active_state(subdev);
1198 
1199 	if (WARN_ON(!state))
1200 		return;
1201 
1202 	for_each_active_route(&state->routing, route) {
1203 		u32 route_pad;
1204 		u32 route_stream;
1205 
1206 		if (pad->flags & MEDIA_PAD_FL_SOURCE) {
1207 			route_pad = route->source_pad;
1208 			route_stream = route->source_stream;
1209 		} else {
1210 			route_pad = route->sink_pad;
1211 			route_stream = route->sink_stream;
1212 		}
1213 
1214 		if (route_pad != pad->index)
1215 			continue;
1216 
1217 		*streams_mask |= BIT_ULL(route_stream);
1218 	}
1219 
1220 	if (!states_locked)
1221 		v4l2_subdev_unlock_state(state);
1222 }
1223 
1224 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */
1225 
1226 static void v4l2_link_validate_get_streams(struct media_pad *pad,
1227 					   u64 *streams_mask,
1228 					   bool states_locked)
1229 {
1230 	struct v4l2_subdev *subdev = media_entity_to_v4l2_subdev(pad->entity);
1231 
1232 	if (!(subdev->flags & V4L2_SUBDEV_FL_STREAMS)) {
1233 		/* Non-streams subdevs have an implicit stream 0 */
1234 		*streams_mask = BIT_ULL(0);
1235 		return;
1236 	}
1237 
1238 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
1239 	__v4l2_link_validate_get_streams(pad, streams_mask, states_locked);
1240 #else
1241 	/* This shouldn't happen */
1242 	*streams_mask = 0;
1243 #endif
1244 }
1245 
1246 static int v4l2_subdev_link_validate_locked(struct media_link *link, bool states_locked)
1247 {
1248 	struct v4l2_subdev *sink_subdev =
1249 		media_entity_to_v4l2_subdev(link->sink->entity);
1250 	struct device *dev = sink_subdev->entity.graph_obj.mdev->dev;
1251 	u64 source_streams_mask;
1252 	u64 sink_streams_mask;
1253 	u64 dangling_sink_streams;
1254 	u32 stream;
1255 	int ret;
1256 
1257 	dev_dbg(dev, "validating link \"%s\":%u -> \"%s\":%u\n",
1258 		link->source->entity->name, link->source->index,
1259 		link->sink->entity->name, link->sink->index);
1260 
1261 	v4l2_link_validate_get_streams(link->source, &source_streams_mask, states_locked);
1262 	v4l2_link_validate_get_streams(link->sink, &sink_streams_mask, states_locked);
1263 
1264 	/*
1265 	 * It is ok to have more source streams than sink streams as extra
1266 	 * source streams can just be ignored by the receiver, but having extra
1267 	 * sink streams is an error as streams must have a source.
1268 	 */
1269 	dangling_sink_streams = (source_streams_mask ^ sink_streams_mask) &
1270 				sink_streams_mask;
1271 	if (dangling_sink_streams) {
1272 		dev_err(dev, "Dangling sink streams: mask %#llx\n",
1273 			dangling_sink_streams);
1274 		return -EINVAL;
1275 	}
1276 
1277 	/* Validate source and sink stream formats */
1278 
1279 	for (stream = 0; stream < sizeof(sink_streams_mask) * 8; ++stream) {
1280 		struct v4l2_subdev_format sink_fmt, source_fmt;
1281 
1282 		if (!(sink_streams_mask & BIT_ULL(stream)))
1283 			continue;
1284 
1285 		dev_dbg(dev, "validating stream \"%s\":%u:%u -> \"%s\":%u:%u\n",
1286 			link->source->entity->name, link->source->index, stream,
1287 			link->sink->entity->name, link->sink->index, stream);
1288 
1289 		ret = v4l2_subdev_link_validate_get_format(link->source, stream,
1290 							   &source_fmt, states_locked);
1291 		if (ret < 0) {
1292 			dev_dbg(dev,
1293 				"Failed to get format for \"%s\":%u:%u (but that's ok)\n",
1294 				link->source->entity->name, link->source->index,
1295 				stream);
1296 			continue;
1297 		}
1298 
1299 		ret = v4l2_subdev_link_validate_get_format(link->sink, stream,
1300 							   &sink_fmt, states_locked);
1301 		if (ret < 0) {
1302 			dev_dbg(dev,
1303 				"Failed to get format for \"%s\":%u:%u (but that's ok)\n",
1304 				link->sink->entity->name, link->sink->index,
1305 				stream);
1306 			continue;
1307 		}
1308 
1309 		/* TODO: add stream number to link_validate() */
1310 		ret = v4l2_subdev_call(sink_subdev, pad, link_validate, link,
1311 				       &source_fmt, &sink_fmt);
1312 		if (!ret)
1313 			continue;
1314 
1315 		if (ret != -ENOIOCTLCMD)
1316 			return ret;
1317 
1318 		ret = v4l2_subdev_link_validate_default(sink_subdev, link,
1319 							&source_fmt, &sink_fmt);
1320 
1321 		if (ret)
1322 			return ret;
1323 	}
1324 
1325 	return 0;
1326 }
1327 
1328 int v4l2_subdev_link_validate(struct media_link *link)
1329 {
1330 	struct v4l2_subdev *source_sd, *sink_sd;
1331 	struct v4l2_subdev_state *source_state, *sink_state;
1332 	bool states_locked;
1333 	int ret;
1334 
1335 	if (!is_media_entity_v4l2_subdev(link->sink->entity) ||
1336 	    !is_media_entity_v4l2_subdev(link->source->entity)) {
1337 		pr_warn_once("%s of link '%s':%u->'%s':%u is not a V4L2 sub-device, driver bug!\n",
1338 			     !is_media_entity_v4l2_subdev(link->sink->entity) ?
1339 			     "sink" : "source",
1340 			     link->source->entity->name, link->source->index,
1341 			     link->sink->entity->name, link->sink->index);
1342 		return 0;
1343 	}
1344 
1345 	sink_sd = media_entity_to_v4l2_subdev(link->sink->entity);
1346 	source_sd = media_entity_to_v4l2_subdev(link->source->entity);
1347 
1348 	sink_state = v4l2_subdev_get_unlocked_active_state(sink_sd);
1349 	source_state = v4l2_subdev_get_unlocked_active_state(source_sd);
1350 
1351 	states_locked = sink_state && source_state;
1352 
1353 	if (states_locked) {
1354 		v4l2_subdev_lock_state(sink_state);
1355 		v4l2_subdev_lock_state(source_state);
1356 	}
1357 
1358 	ret = v4l2_subdev_link_validate_locked(link, states_locked);
1359 
1360 	if (states_locked) {
1361 		v4l2_subdev_unlock_state(sink_state);
1362 		v4l2_subdev_unlock_state(source_state);
1363 	}
1364 
1365 	return ret;
1366 }
1367 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate);
1368 
1369 bool v4l2_subdev_has_pad_interdep(struct media_entity *entity,
1370 				  unsigned int pad0, unsigned int pad1)
1371 {
1372 	struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
1373 	struct v4l2_subdev_krouting *routing;
1374 	struct v4l2_subdev_state *state;
1375 	unsigned int i;
1376 
1377 	state = v4l2_subdev_lock_and_get_active_state(sd);
1378 
1379 	routing = &state->routing;
1380 
1381 	for (i = 0; i < routing->num_routes; ++i) {
1382 		struct v4l2_subdev_route *route = &routing->routes[i];
1383 
1384 		if (!(route->flags & V4L2_SUBDEV_ROUTE_FL_ACTIVE))
1385 			continue;
1386 
1387 		if ((route->sink_pad == pad0 && route->source_pad == pad1) ||
1388 		    (route->source_pad == pad0 && route->sink_pad == pad1)) {
1389 			v4l2_subdev_unlock_state(state);
1390 			return true;
1391 		}
1392 	}
1393 
1394 	v4l2_subdev_unlock_state(state);
1395 
1396 	return false;
1397 }
1398 EXPORT_SYMBOL_GPL(v4l2_subdev_has_pad_interdep);
1399 
1400 struct v4l2_subdev_state *
1401 __v4l2_subdev_state_alloc(struct v4l2_subdev *sd, const char *lock_name,
1402 			  struct lock_class_key *lock_key)
1403 {
1404 	struct v4l2_subdev_state *state;
1405 	int ret;
1406 
1407 	state = kzalloc(sizeof(*state), GFP_KERNEL);
1408 	if (!state)
1409 		return ERR_PTR(-ENOMEM);
1410 
1411 	__mutex_init(&state->_lock, lock_name, lock_key);
1412 	if (sd->state_lock)
1413 		state->lock = sd->state_lock;
1414 	else
1415 		state->lock = &state->_lock;
1416 
1417 	/* Drivers that support streams do not need the legacy pad config */
1418 	if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS) && sd->entity.num_pads) {
1419 		state->pads = kvcalloc(sd->entity.num_pads,
1420 				       sizeof(*state->pads), GFP_KERNEL);
1421 		if (!state->pads) {
1422 			ret = -ENOMEM;
1423 			goto err;
1424 		}
1425 	}
1426 
1427 	/*
1428 	 * There can be no race at this point, but we lock the state anyway to
1429 	 * satisfy lockdep checks.
1430 	 */
1431 	v4l2_subdev_lock_state(state);
1432 	ret = v4l2_subdev_call(sd, pad, init_cfg, state);
1433 	v4l2_subdev_unlock_state(state);
1434 
1435 	if (ret < 0 && ret != -ENOIOCTLCMD)
1436 		goto err;
1437 
1438 	return state;
1439 
1440 err:
1441 	if (state && state->pads)
1442 		kvfree(state->pads);
1443 
1444 	kfree(state);
1445 
1446 	return ERR_PTR(ret);
1447 }
1448 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_alloc);
1449 
1450 void __v4l2_subdev_state_free(struct v4l2_subdev_state *state)
1451 {
1452 	if (!state)
1453 		return;
1454 
1455 	mutex_destroy(&state->_lock);
1456 
1457 	kfree(state->routing.routes);
1458 	kvfree(state->stream_configs.configs);
1459 	kvfree(state->pads);
1460 	kfree(state);
1461 }
1462 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_free);
1463 
1464 int __v4l2_subdev_init_finalize(struct v4l2_subdev *sd, const char *name,
1465 				struct lock_class_key *key)
1466 {
1467 	struct v4l2_subdev_state *state;
1468 
1469 	state = __v4l2_subdev_state_alloc(sd, name, key);
1470 	if (IS_ERR(state))
1471 		return PTR_ERR(state);
1472 
1473 	sd->active_state = state;
1474 
1475 	return 0;
1476 }
1477 EXPORT_SYMBOL_GPL(__v4l2_subdev_init_finalize);
1478 
1479 void v4l2_subdev_cleanup(struct v4l2_subdev *sd)
1480 {
1481 	struct v4l2_async_subdev_endpoint *ase, *ase_tmp;
1482 
1483 	__v4l2_subdev_state_free(sd->active_state);
1484 	sd->active_state = NULL;
1485 
1486 	if (list_empty(&sd->async_subdev_endpoint_list))
1487 		return;
1488 
1489 	list_for_each_entry_safe(ase, ase_tmp, &sd->async_subdev_endpoint_list,
1490 				 async_subdev_endpoint_entry) {
1491 		list_del(&ase->async_subdev_endpoint_entry);
1492 
1493 		kfree(ase);
1494 	}
1495 }
1496 EXPORT_SYMBOL_GPL(v4l2_subdev_cleanup);
1497 
1498 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
1499 
1500 static int
1501 v4l2_subdev_init_stream_configs(struct v4l2_subdev_stream_configs *stream_configs,
1502 				const struct v4l2_subdev_krouting *routing)
1503 {
1504 	struct v4l2_subdev_stream_configs new_configs = { 0 };
1505 	struct v4l2_subdev_route *route;
1506 	u32 idx;
1507 
1508 	/* Count number of formats needed */
1509 	for_each_active_route(routing, route) {
1510 		/*
1511 		 * Each route needs a format on both ends of the route.
1512 		 */
1513 		new_configs.num_configs += 2;
1514 	}
1515 
1516 	if (new_configs.num_configs) {
1517 		new_configs.configs = kvcalloc(new_configs.num_configs,
1518 					       sizeof(*new_configs.configs),
1519 					       GFP_KERNEL);
1520 
1521 		if (!new_configs.configs)
1522 			return -ENOMEM;
1523 	}
1524 
1525 	/*
1526 	 * Fill in the 'pad' and stream' value for each item in the array from
1527 	 * the routing table
1528 	 */
1529 	idx = 0;
1530 
1531 	for_each_active_route(routing, route) {
1532 		new_configs.configs[idx].pad = route->sink_pad;
1533 		new_configs.configs[idx].stream = route->sink_stream;
1534 
1535 		idx++;
1536 
1537 		new_configs.configs[idx].pad = route->source_pad;
1538 		new_configs.configs[idx].stream = route->source_stream;
1539 
1540 		idx++;
1541 	}
1542 
1543 	kvfree(stream_configs->configs);
1544 	*stream_configs = new_configs;
1545 
1546 	return 0;
1547 }
1548 
1549 int v4l2_subdev_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *state,
1550 			struct v4l2_subdev_format *format)
1551 {
1552 	struct v4l2_mbus_framefmt *fmt;
1553 
1554 	if (sd->flags & V4L2_SUBDEV_FL_STREAMS)
1555 		fmt = v4l2_subdev_state_get_stream_format(state, format->pad,
1556 							  format->stream);
1557 	else if (format->pad < sd->entity.num_pads && format->stream == 0)
1558 		fmt = v4l2_subdev_get_pad_format(sd, state, format->pad);
1559 	else
1560 		fmt = NULL;
1561 
1562 	if (!fmt)
1563 		return -EINVAL;
1564 
1565 	format->format = *fmt;
1566 
1567 	return 0;
1568 }
1569 EXPORT_SYMBOL_GPL(v4l2_subdev_get_fmt);
1570 
1571 int v4l2_subdev_set_routing(struct v4l2_subdev *sd,
1572 			    struct v4l2_subdev_state *state,
1573 			    const struct v4l2_subdev_krouting *routing)
1574 {
1575 	struct v4l2_subdev_krouting *dst = &state->routing;
1576 	const struct v4l2_subdev_krouting *src = routing;
1577 	struct v4l2_subdev_krouting new_routing = { 0 };
1578 	size_t bytes;
1579 	int r;
1580 
1581 	if (unlikely(check_mul_overflow((size_t)src->num_routes,
1582 					sizeof(*src->routes), &bytes)))
1583 		return -EOVERFLOW;
1584 
1585 	lockdep_assert_held(state->lock);
1586 
1587 	if (src->num_routes > 0) {
1588 		new_routing.routes = kmemdup(src->routes, bytes, GFP_KERNEL);
1589 		if (!new_routing.routes)
1590 			return -ENOMEM;
1591 	}
1592 
1593 	new_routing.num_routes = src->num_routes;
1594 
1595 	r = v4l2_subdev_init_stream_configs(&state->stream_configs,
1596 					    &new_routing);
1597 	if (r) {
1598 		kfree(new_routing.routes);
1599 		return r;
1600 	}
1601 
1602 	kfree(dst->routes);
1603 	*dst = new_routing;
1604 
1605 	return 0;
1606 }
1607 EXPORT_SYMBOL_GPL(v4l2_subdev_set_routing);
1608 
1609 struct v4l2_subdev_route *
1610 __v4l2_subdev_next_active_route(const struct v4l2_subdev_krouting *routing,
1611 				struct v4l2_subdev_route *route)
1612 {
1613 	if (route)
1614 		++route;
1615 	else
1616 		route = &routing->routes[0];
1617 
1618 	for (; route < routing->routes + routing->num_routes; ++route) {
1619 		if (!(route->flags & V4L2_SUBDEV_ROUTE_FL_ACTIVE))
1620 			continue;
1621 
1622 		return route;
1623 	}
1624 
1625 	return NULL;
1626 }
1627 EXPORT_SYMBOL_GPL(__v4l2_subdev_next_active_route);
1628 
1629 int v4l2_subdev_set_routing_with_fmt(struct v4l2_subdev *sd,
1630 				     struct v4l2_subdev_state *state,
1631 				     const struct v4l2_subdev_krouting *routing,
1632 				     const struct v4l2_mbus_framefmt *fmt)
1633 {
1634 	struct v4l2_subdev_stream_configs *stream_configs;
1635 	unsigned int i;
1636 	int ret;
1637 
1638 	ret = v4l2_subdev_set_routing(sd, state, routing);
1639 	if (ret)
1640 		return ret;
1641 
1642 	stream_configs = &state->stream_configs;
1643 
1644 	for (i = 0; i < stream_configs->num_configs; ++i)
1645 		stream_configs->configs[i].fmt = *fmt;
1646 
1647 	return 0;
1648 }
1649 EXPORT_SYMBOL_GPL(v4l2_subdev_set_routing_with_fmt);
1650 
1651 struct v4l2_mbus_framefmt *
1652 v4l2_subdev_state_get_stream_format(struct v4l2_subdev_state *state,
1653 				    unsigned int pad, u32 stream)
1654 {
1655 	struct v4l2_subdev_stream_configs *stream_configs;
1656 	unsigned int i;
1657 
1658 	lockdep_assert_held(state->lock);
1659 
1660 	stream_configs = &state->stream_configs;
1661 
1662 	for (i = 0; i < stream_configs->num_configs; ++i) {
1663 		if (stream_configs->configs[i].pad == pad &&
1664 		    stream_configs->configs[i].stream == stream)
1665 			return &stream_configs->configs[i].fmt;
1666 	}
1667 
1668 	return NULL;
1669 }
1670 EXPORT_SYMBOL_GPL(v4l2_subdev_state_get_stream_format);
1671 
1672 struct v4l2_rect *
1673 v4l2_subdev_state_get_stream_crop(struct v4l2_subdev_state *state,
1674 				  unsigned int pad, u32 stream)
1675 {
1676 	struct v4l2_subdev_stream_configs *stream_configs;
1677 	unsigned int i;
1678 
1679 	lockdep_assert_held(state->lock);
1680 
1681 	stream_configs = &state->stream_configs;
1682 
1683 	for (i = 0; i < stream_configs->num_configs; ++i) {
1684 		if (stream_configs->configs[i].pad == pad &&
1685 		    stream_configs->configs[i].stream == stream)
1686 			return &stream_configs->configs[i].crop;
1687 	}
1688 
1689 	return NULL;
1690 }
1691 EXPORT_SYMBOL_GPL(v4l2_subdev_state_get_stream_crop);
1692 
1693 struct v4l2_rect *
1694 v4l2_subdev_state_get_stream_compose(struct v4l2_subdev_state *state,
1695 				     unsigned int pad, u32 stream)
1696 {
1697 	struct v4l2_subdev_stream_configs *stream_configs;
1698 	unsigned int i;
1699 
1700 	lockdep_assert_held(state->lock);
1701 
1702 	stream_configs = &state->stream_configs;
1703 
1704 	for (i = 0; i < stream_configs->num_configs; ++i) {
1705 		if (stream_configs->configs[i].pad == pad &&
1706 		    stream_configs->configs[i].stream == stream)
1707 			return &stream_configs->configs[i].compose;
1708 	}
1709 
1710 	return NULL;
1711 }
1712 EXPORT_SYMBOL_GPL(v4l2_subdev_state_get_stream_compose);
1713 
1714 int v4l2_subdev_routing_find_opposite_end(const struct v4l2_subdev_krouting *routing,
1715 					  u32 pad, u32 stream, u32 *other_pad,
1716 					  u32 *other_stream)
1717 {
1718 	unsigned int i;
1719 
1720 	for (i = 0; i < routing->num_routes; ++i) {
1721 		struct v4l2_subdev_route *route = &routing->routes[i];
1722 
1723 		if (route->source_pad == pad &&
1724 		    route->source_stream == stream) {
1725 			if (other_pad)
1726 				*other_pad = route->sink_pad;
1727 			if (other_stream)
1728 				*other_stream = route->sink_stream;
1729 			return 0;
1730 		}
1731 
1732 		if (route->sink_pad == pad && route->sink_stream == stream) {
1733 			if (other_pad)
1734 				*other_pad = route->source_pad;
1735 			if (other_stream)
1736 				*other_stream = route->source_stream;
1737 			return 0;
1738 		}
1739 	}
1740 
1741 	return -EINVAL;
1742 }
1743 EXPORT_SYMBOL_GPL(v4l2_subdev_routing_find_opposite_end);
1744 
1745 struct v4l2_mbus_framefmt *
1746 v4l2_subdev_state_get_opposite_stream_format(struct v4l2_subdev_state *state,
1747 					     u32 pad, u32 stream)
1748 {
1749 	u32 other_pad, other_stream;
1750 	int ret;
1751 
1752 	ret = v4l2_subdev_routing_find_opposite_end(&state->routing,
1753 						    pad, stream,
1754 						    &other_pad, &other_stream);
1755 	if (ret)
1756 		return NULL;
1757 
1758 	return v4l2_subdev_state_get_stream_format(state, other_pad,
1759 						   other_stream);
1760 }
1761 EXPORT_SYMBOL_GPL(v4l2_subdev_state_get_opposite_stream_format);
1762 
1763 u64 v4l2_subdev_state_xlate_streams(const struct v4l2_subdev_state *state,
1764 				    u32 pad0, u32 pad1, u64 *streams)
1765 {
1766 	const struct v4l2_subdev_krouting *routing = &state->routing;
1767 	struct v4l2_subdev_route *route;
1768 	u64 streams0 = 0;
1769 	u64 streams1 = 0;
1770 
1771 	for_each_active_route(routing, route) {
1772 		if (route->sink_pad == pad0 && route->source_pad == pad1 &&
1773 		    (*streams & BIT_ULL(route->sink_stream))) {
1774 			streams0 |= BIT_ULL(route->sink_stream);
1775 			streams1 |= BIT_ULL(route->source_stream);
1776 		}
1777 		if (route->source_pad == pad0 && route->sink_pad == pad1 &&
1778 		    (*streams & BIT_ULL(route->source_stream))) {
1779 			streams0 |= BIT_ULL(route->source_stream);
1780 			streams1 |= BIT_ULL(route->sink_stream);
1781 		}
1782 	}
1783 
1784 	*streams = streams0;
1785 	return streams1;
1786 }
1787 EXPORT_SYMBOL_GPL(v4l2_subdev_state_xlate_streams);
1788 
1789 int v4l2_subdev_routing_validate(struct v4l2_subdev *sd,
1790 				 const struct v4l2_subdev_krouting *routing,
1791 				 enum v4l2_subdev_routing_restriction disallow)
1792 {
1793 	u32 *remote_pads = NULL;
1794 	unsigned int i, j;
1795 	int ret = -EINVAL;
1796 
1797 	if (disallow & (V4L2_SUBDEV_ROUTING_NO_STREAM_MIX |
1798 			V4L2_SUBDEV_ROUTING_NO_MULTIPLEXING)) {
1799 		remote_pads = kcalloc(sd->entity.num_pads, sizeof(*remote_pads),
1800 				      GFP_KERNEL);
1801 		if (!remote_pads)
1802 			return -ENOMEM;
1803 
1804 		for (i = 0; i < sd->entity.num_pads; ++i)
1805 			remote_pads[i] = U32_MAX;
1806 	}
1807 
1808 	for (i = 0; i < routing->num_routes; ++i) {
1809 		const struct v4l2_subdev_route *route = &routing->routes[i];
1810 
1811 		/* Validate the sink and source pad numbers. */
1812 		if (route->sink_pad >= sd->entity.num_pads ||
1813 		    !(sd->entity.pads[route->sink_pad].flags & MEDIA_PAD_FL_SINK)) {
1814 			dev_dbg(sd->dev, "route %u sink (%u) is not a sink pad\n",
1815 				i, route->sink_pad);
1816 			goto out;
1817 		}
1818 
1819 		if (route->source_pad >= sd->entity.num_pads ||
1820 		    !(sd->entity.pads[route->source_pad].flags & MEDIA_PAD_FL_SOURCE)) {
1821 			dev_dbg(sd->dev, "route %u source (%u) is not a source pad\n",
1822 				i, route->source_pad);
1823 			goto out;
1824 		}
1825 
1826 		/*
1827 		 * V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX: all streams from a
1828 		 * sink pad must be routed to a single source pad.
1829 		 */
1830 		if (disallow & V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX) {
1831 			if (remote_pads[route->sink_pad] != U32_MAX &&
1832 			    remote_pads[route->sink_pad] != route->source_pad) {
1833 				dev_dbg(sd->dev,
1834 					"route %u attempts to mix %s streams\n",
1835 					i, "sink");
1836 				goto out;
1837 			}
1838 		}
1839 
1840 		/*
1841 		 * V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX: all streams on a
1842 		 * source pad must originate from a single sink pad.
1843 		 */
1844 		if (disallow & V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX) {
1845 			if (remote_pads[route->source_pad] != U32_MAX &&
1846 			    remote_pads[route->source_pad] != route->sink_pad) {
1847 				dev_dbg(sd->dev,
1848 					"route %u attempts to mix %s streams\n",
1849 					i, "source");
1850 				goto out;
1851 			}
1852 		}
1853 
1854 		/*
1855 		 * V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING: Pads on the sink
1856 		 * side can not do stream multiplexing, i.e. there can be only
1857 		 * a single stream in a sink pad.
1858 		 */
1859 		if (disallow & V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING) {
1860 			if (remote_pads[route->sink_pad] != U32_MAX) {
1861 				dev_dbg(sd->dev,
1862 					"route %u attempts to multiplex on %s pad %u\n",
1863 					i, "sink", route->sink_pad);
1864 				goto out;
1865 			}
1866 		}
1867 
1868 		/*
1869 		 * V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING: Pads on the
1870 		 * source side can not do stream multiplexing, i.e. there can
1871 		 * be only a single stream in a source pad.
1872 		 */
1873 		if (disallow & V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING) {
1874 			if (remote_pads[route->source_pad] != U32_MAX) {
1875 				dev_dbg(sd->dev,
1876 					"route %u attempts to multiplex on %s pad %u\n",
1877 					i, "source", route->source_pad);
1878 				goto out;
1879 			}
1880 		}
1881 
1882 		if (remote_pads) {
1883 			remote_pads[route->sink_pad] = route->source_pad;
1884 			remote_pads[route->source_pad] = route->sink_pad;
1885 		}
1886 
1887 		for (j = i + 1; j < routing->num_routes; ++j) {
1888 			const struct v4l2_subdev_route *r = &routing->routes[j];
1889 
1890 			/*
1891 			 * V4L2_SUBDEV_ROUTING_NO_1_TO_N: No two routes can
1892 			 * originate from the same (sink) stream.
1893 			 */
1894 			if ((disallow & V4L2_SUBDEV_ROUTING_NO_1_TO_N) &&
1895 			    route->sink_pad == r->sink_pad &&
1896 			    route->sink_stream == r->sink_stream) {
1897 				dev_dbg(sd->dev,
1898 					"routes %u and %u originate from same sink (%u/%u)\n",
1899 					i, j, route->sink_pad,
1900 					route->sink_stream);
1901 				goto out;
1902 			}
1903 
1904 			/*
1905 			 * V4L2_SUBDEV_ROUTING_NO_N_TO_1: No two routes can end
1906 			 * at the same (source) stream.
1907 			 */
1908 			if ((disallow & V4L2_SUBDEV_ROUTING_NO_N_TO_1) &&
1909 			    route->source_pad == r->source_pad &&
1910 			    route->source_stream == r->source_stream) {
1911 				dev_dbg(sd->dev,
1912 					"routes %u and %u end at same source (%u/%u)\n",
1913 					i, j, route->source_pad,
1914 					route->source_stream);
1915 				goto out;
1916 			}
1917 		}
1918 	}
1919 
1920 	ret = 0;
1921 
1922 out:
1923 	kfree(remote_pads);
1924 	return ret;
1925 }
1926 EXPORT_SYMBOL_GPL(v4l2_subdev_routing_validate);
1927 
1928 static int v4l2_subdev_enable_streams_fallback(struct v4l2_subdev *sd, u32 pad,
1929 					       u64 streams_mask)
1930 {
1931 	struct device *dev = sd->entity.graph_obj.mdev->dev;
1932 	unsigned int i;
1933 	int ret;
1934 
1935 	/*
1936 	 * The subdev doesn't implement pad-based stream enable, fall back
1937 	 * on the .s_stream() operation. This can only be done for subdevs that
1938 	 * have a single source pad, as sd->enabled_streams is global to the
1939 	 * subdev.
1940 	 */
1941 	if (!(sd->entity.pads[pad].flags & MEDIA_PAD_FL_SOURCE))
1942 		return -EOPNOTSUPP;
1943 
1944 	for (i = 0; i < sd->entity.num_pads; ++i) {
1945 		if (i != pad && sd->entity.pads[i].flags & MEDIA_PAD_FL_SOURCE)
1946 			return -EOPNOTSUPP;
1947 	}
1948 
1949 	if (sd->enabled_streams & streams_mask) {
1950 		dev_dbg(dev, "set of streams %#llx already enabled on %s:%u\n",
1951 			streams_mask, sd->entity.name, pad);
1952 		return -EALREADY;
1953 	}
1954 
1955 	/* Start streaming when the first streams are enabled. */
1956 	if (!sd->enabled_streams) {
1957 		ret = v4l2_subdev_call(sd, video, s_stream, 1);
1958 		if (ret)
1959 			return ret;
1960 	}
1961 
1962 	sd->enabled_streams |= streams_mask;
1963 
1964 	return 0;
1965 }
1966 
1967 int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,
1968 			       u64 streams_mask)
1969 {
1970 	struct device *dev = sd->entity.graph_obj.mdev->dev;
1971 	struct v4l2_subdev_state *state;
1972 	u64 found_streams = 0;
1973 	unsigned int i;
1974 	int ret;
1975 
1976 	/* A few basic sanity checks first. */
1977 	if (pad >= sd->entity.num_pads)
1978 		return -EINVAL;
1979 
1980 	if (!streams_mask)
1981 		return 0;
1982 
1983 	/* Fallback on .s_stream() if .enable_streams() isn't available. */
1984 	if (!sd->ops->pad || !sd->ops->pad->enable_streams)
1985 		return v4l2_subdev_enable_streams_fallback(sd, pad,
1986 							   streams_mask);
1987 
1988 	state = v4l2_subdev_lock_and_get_active_state(sd);
1989 
1990 	/*
1991 	 * Verify that the requested streams exist and that they are not
1992 	 * already enabled.
1993 	 */
1994 	for (i = 0; i < state->stream_configs.num_configs; ++i) {
1995 		struct v4l2_subdev_stream_config *cfg =
1996 			&state->stream_configs.configs[i];
1997 
1998 		if (cfg->pad != pad || !(streams_mask & BIT_ULL(cfg->stream)))
1999 			continue;
2000 
2001 		found_streams |= BIT_ULL(cfg->stream);
2002 
2003 		if (cfg->enabled) {
2004 			dev_dbg(dev, "stream %u already enabled on %s:%u\n",
2005 				cfg->stream, sd->entity.name, pad);
2006 			ret = -EALREADY;
2007 			goto done;
2008 		}
2009 	}
2010 
2011 	if (found_streams != streams_mask) {
2012 		dev_dbg(dev, "streams 0x%llx not found on %s:%u\n",
2013 			streams_mask & ~found_streams, sd->entity.name, pad);
2014 		ret = -EINVAL;
2015 		goto done;
2016 	}
2017 
2018 	dev_dbg(dev, "enable streams %u:%#llx\n", pad, streams_mask);
2019 
2020 	/* Call the .enable_streams() operation. */
2021 	ret = v4l2_subdev_call(sd, pad, enable_streams, state, pad,
2022 			       streams_mask);
2023 	if (ret) {
2024 		dev_dbg(dev, "enable streams %u:%#llx failed: %d\n", pad,
2025 			streams_mask, ret);
2026 		goto done;
2027 	}
2028 
2029 	/* Mark the streams as enabled. */
2030 	for (i = 0; i < state->stream_configs.num_configs; ++i) {
2031 		struct v4l2_subdev_stream_config *cfg =
2032 			&state->stream_configs.configs[i];
2033 
2034 		if (cfg->pad == pad && (streams_mask & BIT_ULL(cfg->stream)))
2035 			cfg->enabled = true;
2036 	}
2037 
2038 done:
2039 	v4l2_subdev_unlock_state(state);
2040 
2041 	return ret;
2042 }
2043 EXPORT_SYMBOL_GPL(v4l2_subdev_enable_streams);
2044 
2045 static int v4l2_subdev_disable_streams_fallback(struct v4l2_subdev *sd, u32 pad,
2046 						u64 streams_mask)
2047 {
2048 	struct device *dev = sd->entity.graph_obj.mdev->dev;
2049 	unsigned int i;
2050 	int ret;
2051 
2052 	/*
2053 	 * If the subdev doesn't implement pad-based stream enable, fall  back
2054 	 * on the .s_stream() operation. This can only be done for subdevs that
2055 	 * have a single source pad, as sd->enabled_streams is global to the
2056 	 * subdev.
2057 	 */
2058 	if (!(sd->entity.pads[pad].flags & MEDIA_PAD_FL_SOURCE))
2059 		return -EOPNOTSUPP;
2060 
2061 	for (i = 0; i < sd->entity.num_pads; ++i) {
2062 		if (i != pad && sd->entity.pads[i].flags & MEDIA_PAD_FL_SOURCE)
2063 			return -EOPNOTSUPP;
2064 	}
2065 
2066 	if ((sd->enabled_streams & streams_mask) != streams_mask) {
2067 		dev_dbg(dev, "set of streams %#llx already disabled on %s:%u\n",
2068 			streams_mask, sd->entity.name, pad);
2069 		return -EALREADY;
2070 	}
2071 
2072 	/* Stop streaming when the last streams are disabled. */
2073 	if (!(sd->enabled_streams & ~streams_mask)) {
2074 		ret = v4l2_subdev_call(sd, video, s_stream, 0);
2075 		if (ret)
2076 			return ret;
2077 	}
2078 
2079 	sd->enabled_streams &= ~streams_mask;
2080 
2081 	return 0;
2082 }
2083 
2084 int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad,
2085 				u64 streams_mask)
2086 {
2087 	struct device *dev = sd->entity.graph_obj.mdev->dev;
2088 	struct v4l2_subdev_state *state;
2089 	u64 found_streams = 0;
2090 	unsigned int i;
2091 	int ret;
2092 
2093 	/* A few basic sanity checks first. */
2094 	if (pad >= sd->entity.num_pads)
2095 		return -EINVAL;
2096 
2097 	if (!streams_mask)
2098 		return 0;
2099 
2100 	/* Fallback on .s_stream() if .disable_streams() isn't available. */
2101 	if (!sd->ops->pad || !sd->ops->pad->disable_streams)
2102 		return v4l2_subdev_disable_streams_fallback(sd, pad,
2103 							    streams_mask);
2104 
2105 	state = v4l2_subdev_lock_and_get_active_state(sd);
2106 
2107 	/*
2108 	 * Verify that the requested streams exist and that they are not
2109 	 * already disabled.
2110 	 */
2111 	for (i = 0; i < state->stream_configs.num_configs; ++i) {
2112 		struct v4l2_subdev_stream_config *cfg =
2113 			&state->stream_configs.configs[i];
2114 
2115 		if (cfg->pad != pad || !(streams_mask & BIT_ULL(cfg->stream)))
2116 			continue;
2117 
2118 		found_streams |= BIT_ULL(cfg->stream);
2119 
2120 		if (!cfg->enabled) {
2121 			dev_dbg(dev, "stream %u already disabled on %s:%u\n",
2122 				cfg->stream, sd->entity.name, pad);
2123 			ret = -EALREADY;
2124 			goto done;
2125 		}
2126 	}
2127 
2128 	if (found_streams != streams_mask) {
2129 		dev_dbg(dev, "streams 0x%llx not found on %s:%u\n",
2130 			streams_mask & ~found_streams, sd->entity.name, pad);
2131 		ret = -EINVAL;
2132 		goto done;
2133 	}
2134 
2135 	dev_dbg(dev, "disable streams %u:%#llx\n", pad, streams_mask);
2136 
2137 	/* Call the .disable_streams() operation. */
2138 	ret = v4l2_subdev_call(sd, pad, disable_streams, state, pad,
2139 			       streams_mask);
2140 	if (ret) {
2141 		dev_dbg(dev, "disable streams %u:%#llx failed: %d\n", pad,
2142 			streams_mask, ret);
2143 		goto done;
2144 	}
2145 
2146 	/* Mark the streams as disabled. */
2147 	for (i = 0; i < state->stream_configs.num_configs; ++i) {
2148 		struct v4l2_subdev_stream_config *cfg =
2149 			&state->stream_configs.configs[i];
2150 
2151 		if (cfg->pad == pad && (streams_mask & BIT_ULL(cfg->stream)))
2152 			cfg->enabled = false;
2153 	}
2154 
2155 done:
2156 	v4l2_subdev_unlock_state(state);
2157 
2158 	return ret;
2159 }
2160 EXPORT_SYMBOL_GPL(v4l2_subdev_disable_streams);
2161 
2162 int v4l2_subdev_s_stream_helper(struct v4l2_subdev *sd, int enable)
2163 {
2164 	struct v4l2_subdev_state *state;
2165 	struct v4l2_subdev_route *route;
2166 	struct media_pad *pad;
2167 	u64 source_mask = 0;
2168 	int pad_index = -1;
2169 
2170 	/*
2171 	 * Find the source pad. This helper is meant for subdevs that have a
2172 	 * single source pad, so failures shouldn't happen, but catch them
2173 	 * loudly nonetheless as they indicate a driver bug.
2174 	 */
2175 	media_entity_for_each_pad(&sd->entity, pad) {
2176 		if (pad->flags & MEDIA_PAD_FL_SOURCE) {
2177 			pad_index = pad->index;
2178 			break;
2179 		}
2180 	}
2181 
2182 	if (WARN_ON(pad_index == -1))
2183 		return -EINVAL;
2184 
2185 	/*
2186 	 * As there's a single source pad, just collect all the source streams.
2187 	 */
2188 	state = v4l2_subdev_lock_and_get_active_state(sd);
2189 
2190 	for_each_active_route(&state->routing, route)
2191 		source_mask |= BIT_ULL(route->source_stream);
2192 
2193 	v4l2_subdev_unlock_state(state);
2194 
2195 	if (enable)
2196 		return v4l2_subdev_enable_streams(sd, pad_index, source_mask);
2197 	else
2198 		return v4l2_subdev_disable_streams(sd, pad_index, source_mask);
2199 }
2200 EXPORT_SYMBOL_GPL(v4l2_subdev_s_stream_helper);
2201 
2202 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */
2203 
2204 #endif /* CONFIG_MEDIA_CONTROLLER */
2205 
2206 void v4l2_subdev_init(struct v4l2_subdev *sd, const struct v4l2_subdev_ops *ops)
2207 {
2208 	INIT_LIST_HEAD(&sd->list);
2209 	BUG_ON(!ops);
2210 	sd->ops = ops;
2211 	sd->v4l2_dev = NULL;
2212 	sd->flags = 0;
2213 	sd->name[0] = '\0';
2214 	sd->grp_id = 0;
2215 	sd->dev_priv = NULL;
2216 	sd->host_priv = NULL;
2217 	sd->privacy_led = NULL;
2218 	INIT_LIST_HEAD(&sd->async_subdev_endpoint_list);
2219 #if defined(CONFIG_MEDIA_CONTROLLER)
2220 	sd->entity.name = sd->name;
2221 	sd->entity.obj_type = MEDIA_ENTITY_TYPE_V4L2_SUBDEV;
2222 	sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
2223 #endif
2224 }
2225 EXPORT_SYMBOL(v4l2_subdev_init);
2226 
2227 void v4l2_subdev_notify_event(struct v4l2_subdev *sd,
2228 			      const struct v4l2_event *ev)
2229 {
2230 	v4l2_event_queue(sd->devnode, ev);
2231 	v4l2_subdev_notify(sd, V4L2_DEVICE_NOTIFY_EVENT, (void *)ev);
2232 }
2233 EXPORT_SYMBOL_GPL(v4l2_subdev_notify_event);
2234 
2235 int v4l2_subdev_get_privacy_led(struct v4l2_subdev *sd)
2236 {
2237 #if IS_REACHABLE(CONFIG_LEDS_CLASS)
2238 	sd->privacy_led = led_get(sd->dev, "privacy-led");
2239 	if (IS_ERR(sd->privacy_led) && PTR_ERR(sd->privacy_led) != -ENOENT)
2240 		return dev_err_probe(sd->dev, PTR_ERR(sd->privacy_led),
2241 				     "getting privacy LED\n");
2242 
2243 	if (!IS_ERR_OR_NULL(sd->privacy_led)) {
2244 		mutex_lock(&sd->privacy_led->led_access);
2245 		led_sysfs_disable(sd->privacy_led);
2246 		led_trigger_remove(sd->privacy_led);
2247 		led_set_brightness(sd->privacy_led, 0);
2248 		mutex_unlock(&sd->privacy_led->led_access);
2249 	}
2250 #endif
2251 	return 0;
2252 }
2253 EXPORT_SYMBOL_GPL(v4l2_subdev_get_privacy_led);
2254 
2255 void v4l2_subdev_put_privacy_led(struct v4l2_subdev *sd)
2256 {
2257 #if IS_REACHABLE(CONFIG_LEDS_CLASS)
2258 	if (!IS_ERR_OR_NULL(sd->privacy_led)) {
2259 		mutex_lock(&sd->privacy_led->led_access);
2260 		led_sysfs_enable(sd->privacy_led);
2261 		mutex_unlock(&sd->privacy_led->led_access);
2262 		led_put(sd->privacy_led);
2263 	}
2264 #endif
2265 }
2266 EXPORT_SYMBOL_GPL(v4l2_subdev_put_privacy_led);
2267