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