4 * Copyright (C) 2010 Nokia Corporation
6 * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
7 * Sakari Ailus <sakari.ailus@iki.fi>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/ioctl.h>
24 #include <linux/slab.h>
25 #include <linux/types.h>
26 #include <linux/videodev2.h>
27 #include <linux/export.h>
29 #include <media/v4l2-ctrls.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-fh.h>
33 #include <media/v4l2-event.h>
35 static int subdev_fh_init(struct v4l2_subdev_fh
*fh
, struct v4l2_subdev
*sd
)
37 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
38 fh
->pad
= kzalloc(sizeof(*fh
->pad
) * sd
->entity
.num_pads
, GFP_KERNEL
);
45 static void subdev_fh_free(struct v4l2_subdev_fh
*fh
)
47 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
53 static int subdev_open(struct file
*file
)
55 struct video_device
*vdev
= video_devdata(file
);
56 struct v4l2_subdev
*sd
= vdev_to_v4l2_subdev(vdev
);
57 struct v4l2_subdev_fh
*subdev_fh
;
58 #if defined(CONFIG_MEDIA_CONTROLLER)
59 struct media_entity
*entity
= NULL
;
63 subdev_fh
= kzalloc(sizeof(*subdev_fh
), GFP_KERNEL
);
64 if (subdev_fh
== NULL
)
67 ret
= subdev_fh_init(subdev_fh
, sd
);
73 v4l2_fh_init(&subdev_fh
->vfh
, vdev
);
74 v4l2_fh_add(&subdev_fh
->vfh
);
75 file
->private_data
= &subdev_fh
->vfh
;
76 #if defined(CONFIG_MEDIA_CONTROLLER)
77 if (sd
->v4l2_dev
->mdev
) {
78 entity
= media_entity_get(&sd
->entity
);
86 if (sd
->internal_ops
&& sd
->internal_ops
->open
) {
87 ret
= sd
->internal_ops
->open(sd
, subdev_fh
);
95 #if defined(CONFIG_MEDIA_CONTROLLER)
97 media_entity_put(entity
);
99 v4l2_fh_del(&subdev_fh
->vfh
);
100 v4l2_fh_exit(&subdev_fh
->vfh
);
101 subdev_fh_free(subdev_fh
);
107 static int subdev_close(struct file
*file
)
109 struct video_device
*vdev
= video_devdata(file
);
110 struct v4l2_subdev
*sd
= vdev_to_v4l2_subdev(vdev
);
111 struct v4l2_fh
*vfh
= file
->private_data
;
112 struct v4l2_subdev_fh
*subdev_fh
= to_v4l2_subdev_fh(vfh
);
114 if (sd
->internal_ops
&& sd
->internal_ops
->close
)
115 sd
->internal_ops
->close(sd
, subdev_fh
);
116 #if defined(CONFIG_MEDIA_CONTROLLER)
117 if (sd
->v4l2_dev
->mdev
)
118 media_entity_put(&sd
->entity
);
122 subdev_fh_free(subdev_fh
);
124 file
->private_data
= NULL
;
129 static long subdev_do_ioctl(struct file
*file
, unsigned int cmd
, void *arg
)
131 struct video_device
*vdev
= video_devdata(file
);
132 struct v4l2_subdev
*sd
= vdev_to_v4l2_subdev(vdev
);
133 struct v4l2_fh
*vfh
= file
->private_data
;
134 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
135 struct v4l2_subdev_fh
*subdev_fh
= to_v4l2_subdev_fh(vfh
);
139 case VIDIOC_QUERYCTRL
:
140 return v4l2_queryctrl(vfh
->ctrl_handler
, arg
);
142 case VIDIOC_QUERYMENU
:
143 return v4l2_querymenu(vfh
->ctrl_handler
, arg
);
146 return v4l2_g_ctrl(vfh
->ctrl_handler
, arg
);
149 return v4l2_s_ctrl(vfh
, vfh
->ctrl_handler
, arg
);
151 case VIDIOC_G_EXT_CTRLS
:
152 return v4l2_g_ext_ctrls(vfh
->ctrl_handler
, arg
);
154 case VIDIOC_S_EXT_CTRLS
:
155 return v4l2_s_ext_ctrls(vfh
, vfh
->ctrl_handler
, arg
);
157 case VIDIOC_TRY_EXT_CTRLS
:
158 return v4l2_try_ext_ctrls(vfh
->ctrl_handler
, arg
);
161 if (!(sd
->flags
& V4L2_SUBDEV_FL_HAS_EVENTS
))
164 return v4l2_event_dequeue(vfh
, arg
, file
->f_flags
& O_NONBLOCK
);
166 case VIDIOC_SUBSCRIBE_EVENT
:
167 return v4l2_subdev_call(sd
, core
, subscribe_event
, vfh
, arg
);
169 case VIDIOC_UNSUBSCRIBE_EVENT
:
170 return v4l2_subdev_call(sd
, core
, unsubscribe_event
, vfh
, arg
);
172 #ifdef CONFIG_VIDEO_ADV_DEBUG
173 case VIDIOC_DBG_G_REGISTER
:
175 struct v4l2_dbg_register
*p
= arg
;
177 if (!capable(CAP_SYS_ADMIN
))
179 return v4l2_subdev_call(sd
, core
, g_register
, p
);
181 case VIDIOC_DBG_S_REGISTER
:
183 struct v4l2_dbg_register
*p
= arg
;
185 if (!capable(CAP_SYS_ADMIN
))
187 return v4l2_subdev_call(sd
, core
, s_register
, p
);
191 case VIDIOC_LOG_STATUS
: {
194 pr_info("%s: ================= START STATUS =================\n",
196 ret
= v4l2_subdev_call(sd
, core
, log_status
);
197 pr_info("%s: ================== END STATUS ==================\n",
202 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
203 case VIDIOC_SUBDEV_G_FMT
: {
204 struct v4l2_subdev_format
*format
= arg
;
206 if (format
->which
!= V4L2_SUBDEV_FORMAT_TRY
&&
207 format
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
210 if (format
->pad
>= sd
->entity
.num_pads
)
213 return v4l2_subdev_call(sd
, pad
, get_fmt
, subdev_fh
, format
);
216 case VIDIOC_SUBDEV_S_FMT
: {
217 struct v4l2_subdev_format
*format
= arg
;
219 if (format
->which
!= V4L2_SUBDEV_FORMAT_TRY
&&
220 format
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
223 if (format
->pad
>= sd
->entity
.num_pads
)
226 return v4l2_subdev_call(sd
, pad
, set_fmt
, subdev_fh
, format
);
229 case VIDIOC_SUBDEV_G_CROP
: {
230 struct v4l2_subdev_crop
*crop
= arg
;
231 struct v4l2_subdev_selection sel
;
234 if (crop
->which
!= V4L2_SUBDEV_FORMAT_TRY
&&
235 crop
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
238 if (crop
->pad
>= sd
->entity
.num_pads
)
241 rval
= v4l2_subdev_call(sd
, pad
, get_crop
, subdev_fh
, crop
);
242 if (rval
!= -ENOIOCTLCMD
)
245 memset(&sel
, 0, sizeof(sel
));
246 sel
.which
= crop
->which
;
248 sel
.target
= V4L2_SEL_TGT_CROP
;
250 rval
= v4l2_subdev_call(
251 sd
, pad
, get_selection
, subdev_fh
, &sel
);
258 case VIDIOC_SUBDEV_S_CROP
: {
259 struct v4l2_subdev_crop
*crop
= arg
;
260 struct v4l2_subdev_selection sel
;
263 if (crop
->which
!= V4L2_SUBDEV_FORMAT_TRY
&&
264 crop
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
267 if (crop
->pad
>= sd
->entity
.num_pads
)
270 rval
= v4l2_subdev_call(sd
, pad
, set_crop
, subdev_fh
, crop
);
271 if (rval
!= -ENOIOCTLCMD
)
274 memset(&sel
, 0, sizeof(sel
));
275 sel
.which
= crop
->which
;
277 sel
.target
= V4L2_SEL_TGT_CROP
;
280 rval
= v4l2_subdev_call(
281 sd
, pad
, set_selection
, subdev_fh
, &sel
);
288 case VIDIOC_SUBDEV_ENUM_MBUS_CODE
: {
289 struct v4l2_subdev_mbus_code_enum
*code
= arg
;
291 if (code
->pad
>= sd
->entity
.num_pads
)
294 return v4l2_subdev_call(sd
, pad
, enum_mbus_code
, subdev_fh
,
298 case VIDIOC_SUBDEV_ENUM_FRAME_SIZE
: {
299 struct v4l2_subdev_frame_size_enum
*fse
= arg
;
301 if (fse
->pad
>= sd
->entity
.num_pads
)
304 return v4l2_subdev_call(sd
, pad
, enum_frame_size
, subdev_fh
,
308 case VIDIOC_SUBDEV_G_FRAME_INTERVAL
: {
309 struct v4l2_subdev_frame_interval
*fi
= arg
;
311 if (fi
->pad
>= sd
->entity
.num_pads
)
314 return v4l2_subdev_call(sd
, video
, g_frame_interval
, arg
);
317 case VIDIOC_SUBDEV_S_FRAME_INTERVAL
: {
318 struct v4l2_subdev_frame_interval
*fi
= arg
;
320 if (fi
->pad
>= sd
->entity
.num_pads
)
323 return v4l2_subdev_call(sd
, video
, s_frame_interval
, arg
);
326 case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL
: {
327 struct v4l2_subdev_frame_interval_enum
*fie
= arg
;
329 if (fie
->pad
>= sd
->entity
.num_pads
)
332 return v4l2_subdev_call(sd
, pad
, enum_frame_interval
, subdev_fh
,
336 case VIDIOC_SUBDEV_G_SELECTION
: {
337 struct v4l2_subdev_selection
*sel
= arg
;
339 if (sel
->which
!= V4L2_SUBDEV_FORMAT_TRY
&&
340 sel
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
343 if (sel
->pad
>= sd
->entity
.num_pads
)
346 return v4l2_subdev_call(
347 sd
, pad
, get_selection
, subdev_fh
, sel
);
350 case VIDIOC_SUBDEV_S_SELECTION
: {
351 struct v4l2_subdev_selection
*sel
= arg
;
353 if (sel
->which
!= V4L2_SUBDEV_FORMAT_TRY
&&
354 sel
->which
!= V4L2_SUBDEV_FORMAT_ACTIVE
)
357 if (sel
->pad
>= sd
->entity
.num_pads
)
360 return v4l2_subdev_call(
361 sd
, pad
, set_selection
, subdev_fh
, sel
);
364 case VIDIOC_G_EDID
: {
365 struct v4l2_subdev_edid
*edid
= arg
;
367 if (edid
->pad
>= sd
->entity
.num_pads
)
369 if (edid
->blocks
&& edid
->edid
== NULL
)
372 return v4l2_subdev_call(sd
, pad
, get_edid
, edid
);
375 case VIDIOC_S_EDID
: {
376 struct v4l2_subdev_edid
*edid
= arg
;
378 if (edid
->pad
>= sd
->entity
.num_pads
)
380 if (edid
->blocks
&& edid
->edid
== NULL
)
383 return v4l2_subdev_call(sd
, pad
, set_edid
, edid
);
386 case VIDIOC_SUBDEV_DV_TIMINGS_CAP
: {
387 struct v4l2_dv_timings_cap
*cap
= arg
;
389 if (cap
->pad
>= sd
->entity
.num_pads
)
392 return v4l2_subdev_call(sd
, pad
, dv_timings_cap
, cap
);
395 case VIDIOC_SUBDEV_ENUM_DV_TIMINGS
: {
396 struct v4l2_enum_dv_timings
*dvt
= arg
;
398 if (dvt
->pad
>= sd
->entity
.num_pads
)
401 return v4l2_subdev_call(sd
, pad
, enum_dv_timings
, dvt
);
404 case VIDIOC_SUBDEV_QUERY_DV_TIMINGS
:
405 return v4l2_subdev_call(sd
, video
, query_dv_timings
, arg
);
407 case VIDIOC_SUBDEV_G_DV_TIMINGS
:
408 return v4l2_subdev_call(sd
, video
, g_dv_timings
, arg
);
410 case VIDIOC_SUBDEV_S_DV_TIMINGS
:
411 return v4l2_subdev_call(sd
, video
, s_dv_timings
, arg
);
414 return v4l2_subdev_call(sd
, core
, ioctl
, cmd
, arg
);
420 static long subdev_ioctl(struct file
*file
, unsigned int cmd
,
423 return video_usercopy(file
, cmd
, arg
, subdev_do_ioctl
);
427 static long subdev_compat_ioctl32(struct file
*file
, unsigned int cmd
,
430 struct video_device
*vdev
= video_devdata(file
);
431 struct v4l2_subdev
*sd
= vdev_to_v4l2_subdev(vdev
);
433 return v4l2_subdev_call(sd
, core
, compat_ioctl32
, cmd
, arg
);
437 static unsigned int subdev_poll(struct file
*file
, poll_table
*wait
)
439 struct video_device
*vdev
= video_devdata(file
);
440 struct v4l2_subdev
*sd
= vdev_to_v4l2_subdev(vdev
);
441 struct v4l2_fh
*fh
= file
->private_data
;
443 if (!(sd
->flags
& V4L2_SUBDEV_FL_HAS_EVENTS
))
446 poll_wait(file
, &fh
->wait
, wait
);
448 if (v4l2_event_pending(fh
))
454 const struct v4l2_file_operations v4l2_subdev_fops
= {
455 .owner
= THIS_MODULE
,
457 .unlocked_ioctl
= subdev_ioctl
,
459 .compat_ioctl32
= subdev_compat_ioctl32
,
461 .release
= subdev_close
,
465 #ifdef CONFIG_MEDIA_CONTROLLER
466 int v4l2_subdev_link_validate_default(struct v4l2_subdev
*sd
,
467 struct media_link
*link
,
468 struct v4l2_subdev_format
*source_fmt
,
469 struct v4l2_subdev_format
*sink_fmt
)
471 if (source_fmt
->format
.width
!= sink_fmt
->format
.width
472 || source_fmt
->format
.height
!= sink_fmt
->format
.height
473 || source_fmt
->format
.code
!= sink_fmt
->format
.code
)
478 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate_default
);
481 v4l2_subdev_link_validate_get_format(struct media_pad
*pad
,
482 struct v4l2_subdev_format
*fmt
)
484 if (media_entity_type(pad
->entity
) == MEDIA_ENT_T_V4L2_SUBDEV
) {
485 struct v4l2_subdev
*sd
=
486 media_entity_to_v4l2_subdev(pad
->entity
);
488 fmt
->which
= V4L2_SUBDEV_FORMAT_ACTIVE
;
489 fmt
->pad
= pad
->index
;
490 return v4l2_subdev_call(sd
, pad
, get_fmt
, NULL
, fmt
);
493 WARN(pad
->entity
->type
!= MEDIA_ENT_T_DEVNODE_V4L
,
494 "Driver bug! Wrong media entity type 0x%08x, entity %s\n",
495 pad
->entity
->type
, pad
->entity
->name
);
500 int v4l2_subdev_link_validate(struct media_link
*link
)
502 struct v4l2_subdev
*sink
;
503 struct v4l2_subdev_format sink_fmt
, source_fmt
;
506 rval
= v4l2_subdev_link_validate_get_format(
507 link
->source
, &source_fmt
);
511 rval
= v4l2_subdev_link_validate_get_format(
512 link
->sink
, &sink_fmt
);
516 sink
= media_entity_to_v4l2_subdev(link
->sink
->entity
);
518 rval
= v4l2_subdev_call(sink
, pad
, link_validate
, link
,
519 &source_fmt
, &sink_fmt
);
520 if (rval
!= -ENOIOCTLCMD
)
523 return v4l2_subdev_link_validate_default(
524 sink
, link
, &source_fmt
, &sink_fmt
);
526 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate
);
527 #endif /* CONFIG_MEDIA_CONTROLLER */
529 void v4l2_subdev_init(struct v4l2_subdev
*sd
, const struct v4l2_subdev_ops
*ops
)
531 INIT_LIST_HEAD(&sd
->list
);
539 sd
->host_priv
= NULL
;
540 #if defined(CONFIG_MEDIA_CONTROLLER)
541 sd
->entity
.name
= sd
->name
;
542 sd
->entity
.type
= MEDIA_ENT_T_V4L2_SUBDEV
;
545 EXPORT_SYMBOL(v4l2_subdev_init
);