4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
5 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/kernel.h>
23 #include <linux/slab.h>
24 #include "pvrusb2-context.h"
25 #include "pvrusb2-hdw.h"
27 #include "pvrusb2-debug.h"
28 #include "pvrusb2-v4l2.h"
29 #include "pvrusb2-ioread.h"
30 #include <linux/videodev2.h>
31 #include <linux/module.h>
32 #include <media/v4l2-dev.h>
33 #include <media/v4l2-device.h>
34 #include <media/v4l2-fh.h>
35 #include <media/v4l2-common.h>
36 #include <media/v4l2-ioctl.h>
42 struct pvr2_v4l2_dev {
43 struct video_device devbase; /* MUST be first! */
44 struct pvr2_v4l2 *v4lp;
45 struct pvr2_context_stream *stream;
46 /* Information about this device: */
47 enum pvr2_config config; /* Expected stream format */
48 int v4l_type; /* V4L defined type for this device node */
49 enum pvr2_v4l_type minor_type; /* pvr2-understood minor device type */
54 struct pvr2_channel channel;
55 struct pvr2_v4l2_dev *pdi;
56 struct pvr2_ioread *rhp;
58 wait_queue_head_t wait_data;
60 /* Map contiguous ordinal value to input id */
61 unsigned char *input_map;
62 unsigned int input_cnt;
66 struct pvr2_channel channel;
68 /* streams - Note that these must be separately, individually,
69 * allocated pointers. This is because the v4l core is going to
70 * manage their deletion - separately, individually... */
71 struct pvr2_v4l2_dev *dev_video;
72 struct pvr2_v4l2_dev *dev_radio;
75 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
76 module_param_array(video_nr, int, NULL, 0444);
77 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
78 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
79 module_param_array(radio_nr, int, NULL, 0444);
80 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
81 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
82 module_param_array(vbi_nr, int, NULL, 0444);
83 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
85 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
88 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
89 .flags = V4L2_FMT_FLAG_COMPRESSED,
90 .description = "MPEG1/2",
91 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
92 // breaks when I do that.
93 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
97 #define PVR_FORMAT_PIX 0
98 #define PVR_FORMAT_VBI 1
100 static struct v4l2_format pvr_format [] = {
102 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
107 // This should really be V4L2_PIX_FMT_MPEG,
108 // but xawtv breaks when I do that.
109 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
110 .field = V4L2_FIELD_INTERLACED,
111 .bytesperline = 0, // doesn't make sense
113 //FIXME : Don't know what to put here...
114 .sizeimage = (32*1024),
115 .colorspace = 0, // doesn't make sense here
121 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
124 .sampling_rate = 27000000,
126 .samples_per_line = 1443,
127 .sample_format = V4L2_PIX_FMT_GREY,
139 * This is part of Video 4 Linux API. These procedures handle ioctl() calls.
141 static int pvr2_querycap(struct file *file, void *priv, struct v4l2_capability *cap)
143 struct pvr2_v4l2_fh *fh = file->private_data;
144 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
146 strlcpy(cap->driver, "pvrusb2", sizeof(cap->driver));
147 strlcpy(cap->bus_info, pvr2_hdw_get_bus_info(hdw),
148 sizeof(cap->bus_info));
149 strlcpy(cap->card, pvr2_hdw_get_desc(hdw), sizeof(cap->card));
150 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
151 V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
152 V4L2_CAP_READWRITE | V4L2_CAP_DEVICE_CAPS;
153 switch (fh->pdi->devbase.vfl_type) {
154 case VFL_TYPE_GRABBER:
155 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_AUDIO;
158 cap->device_caps = V4L2_CAP_RADIO;
161 cap->device_caps |= V4L2_CAP_TUNER | V4L2_CAP_READWRITE;
165 static int pvr2_g_std(struct file *file, void *priv, v4l2_std_id *std)
167 struct pvr2_v4l2_fh *fh = file->private_data;
168 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
172 ret = pvr2_ctrl_get_value(
173 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_STDCUR), &val);
178 static int pvr2_s_std(struct file *file, void *priv, v4l2_std_id std)
180 struct pvr2_v4l2_fh *fh = file->private_data;
181 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
183 return pvr2_ctrl_set_value(
184 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_STDCUR), std);
187 static int pvr2_querystd(struct file *file, void *priv, v4l2_std_id *std)
189 struct pvr2_v4l2_fh *fh = file->private_data;
190 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
194 ret = pvr2_ctrl_get_value(
195 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_STDDETECT), &val);
200 static int pvr2_enum_input(struct file *file, void *priv, struct v4l2_input *vi)
202 struct pvr2_v4l2_fh *fh = file->private_data;
203 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
204 struct pvr2_ctrl *cptr;
205 struct v4l2_input tmp;
209 cptr = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_INPUT);
211 memset(&tmp, 0, sizeof(tmp));
212 tmp.index = vi->index;
213 if (vi->index >= fh->input_cnt)
215 val = fh->input_map[vi->index];
217 case PVR2_CVAL_INPUT_TV:
218 case PVR2_CVAL_INPUT_DTV:
219 case PVR2_CVAL_INPUT_RADIO:
220 tmp.type = V4L2_INPUT_TYPE_TUNER;
222 case PVR2_CVAL_INPUT_SVIDEO:
223 case PVR2_CVAL_INPUT_COMPOSITE:
224 tmp.type = V4L2_INPUT_TYPE_CAMERA;
231 pvr2_ctrl_get_valname(cptr, val,
232 tmp.name, sizeof(tmp.name) - 1, &cnt);
235 /* Don't bother with audioset, since this driver currently
236 always switches the audio whenever the video is
239 /* Handling std is a tougher problem. It doesn't make
240 sense in cases where a device might be multi-standard.
241 We could just copy out the current value for the
242 standard, but it can change over time. For now just
248 static int pvr2_g_input(struct file *file, void *priv, unsigned int *i)
250 struct pvr2_v4l2_fh *fh = file->private_data;
251 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
253 struct pvr2_ctrl *cptr;
257 cptr = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_INPUT);
259 ret = pvr2_ctrl_get_value(cptr, &val);
261 for (idx = 0; idx < fh->input_cnt; idx++) {
262 if (fh->input_map[idx] == val) {
270 static int pvr2_s_input(struct file *file, void *priv, unsigned int inp)
272 struct pvr2_v4l2_fh *fh = file->private_data;
273 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
275 if (inp >= fh->input_cnt)
277 return pvr2_ctrl_set_value(
278 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_INPUT),
282 static int pvr2_enumaudio(struct file *file, void *priv, struct v4l2_audio *vin)
284 /* pkt: FIXME: We are returning one "fake" input here
285 which could very well be called "whatever_we_like".
286 This is for apps that want to see an audio input
287 just to feel comfortable, as well as to test if
288 it can do stereo or sth. There is actually no guarantee
289 that the actual audio input cannot change behind the app's
290 back, but most applications should not mind that either.
292 Hopefully, mplayer people will work with us on this (this
293 whole mess is to support mplayer pvr://), or Hans will come
294 up with a more standard way to say "we have inputs but we
295 don 't want you to change them independent of video" which
301 strncpy(vin->name, "PVRUSB2 Audio", 14);
302 vin->capability = V4L2_AUDCAP_STEREO;
306 static int pvr2_g_audio(struct file *file, void *priv, struct v4l2_audio *vin)
308 /* pkt: FIXME: see above comment (VIDIOC_ENUMAUDIO) */
310 strncpy(vin->name, "PVRUSB2 Audio", 14);
311 vin->capability = V4L2_AUDCAP_STEREO;
315 static int pvr2_s_audio(struct file *file, void *priv, const struct v4l2_audio *vout)
322 static int pvr2_g_tuner(struct file *file, void *priv, struct v4l2_tuner *vt)
324 struct pvr2_v4l2_fh *fh = file->private_data;
325 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
328 return -EINVAL; /* Only answer for the 1st tuner */
330 pvr2_hdw_execute_tuner_poll(hdw);
331 return pvr2_hdw_get_tuner_status(hdw, vt);
334 static int pvr2_s_tuner(struct file *file, void *priv, const struct v4l2_tuner *vt)
336 struct pvr2_v4l2_fh *fh = file->private_data;
337 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
342 return pvr2_ctrl_set_value(
343 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_AUDIOMODE),
347 static int pvr2_s_frequency(struct file *file, void *priv, const struct v4l2_frequency *vf)
349 struct pvr2_v4l2_fh *fh = file->private_data;
350 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
352 struct v4l2_tuner vt;
354 struct pvr2_ctrl *ctrlp;
357 ret = pvr2_hdw_get_tuner_status(hdw, &vt);
360 ctrlp = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_INPUT);
361 ret = pvr2_ctrl_get_value(ctrlp, &cur_input);
364 if (vf->type == V4L2_TUNER_RADIO) {
365 if (cur_input != PVR2_CVAL_INPUT_RADIO)
366 pvr2_ctrl_set_value(ctrlp, PVR2_CVAL_INPUT_RADIO);
368 if (cur_input == PVR2_CVAL_INPUT_RADIO)
369 pvr2_ctrl_set_value(ctrlp, PVR2_CVAL_INPUT_TV);
372 if (vt.capability & V4L2_TUNER_CAP_LOW)
376 return pvr2_ctrl_set_value(
377 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
380 static int pvr2_g_frequency(struct file *file, void *priv, struct v4l2_frequency *vf)
382 struct pvr2_v4l2_fh *fh = file->private_data;
383 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
386 struct v4l2_tuner vt;
389 ret = pvr2_hdw_get_tuner_status(hdw, &vt);
392 ret = pvr2_ctrl_get_value(
393 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_FREQUENCY),
398 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_INPUT),
400 if (cur_input == PVR2_CVAL_INPUT_RADIO)
401 vf->type = V4L2_TUNER_RADIO;
403 vf->type = V4L2_TUNER_ANALOG_TV;
404 if (vt.capability & V4L2_TUNER_CAP_LOW)
405 val = (val * 2) / 125;
412 static int pvr2_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *fd)
414 /* Only one format is supported : mpeg.*/
418 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
422 static int pvr2_g_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *vf)
424 struct pvr2_v4l2_fh *fh = file->private_data;
425 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
428 memcpy(vf, &pvr_format[PVR_FORMAT_PIX], sizeof(struct v4l2_format));
431 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_HRES),
433 vf->fmt.pix.width = val;
436 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_VRES),
438 vf->fmt.pix.height = val;
442 static int pvr2_try_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *vf)
444 struct pvr2_v4l2_fh *fh = file->private_data;
445 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
446 int lmin, lmax, ldef;
447 struct pvr2_ctrl *hcp, *vcp;
448 int h = vf->fmt.pix.height;
449 int w = vf->fmt.pix.width;
451 hcp = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_HRES);
452 vcp = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_VRES);
454 lmin = pvr2_ctrl_get_min(hcp);
455 lmax = pvr2_ctrl_get_max(hcp);
456 pvr2_ctrl_get_def(hcp, &ldef);
463 lmin = pvr2_ctrl_get_min(vcp);
464 lmax = pvr2_ctrl_get_max(vcp);
465 pvr2_ctrl_get_def(vcp, &ldef);
473 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
474 sizeof(struct v4l2_format));
475 vf->fmt.pix.width = w;
476 vf->fmt.pix.height = h;
480 static int pvr2_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *vf)
482 struct pvr2_v4l2_fh *fh = file->private_data;
483 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
484 struct pvr2_ctrl *hcp, *vcp;
485 int ret = pvr2_try_fmt_vid_cap(file, fh, vf);
489 hcp = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_HRES);
490 vcp = pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_VRES);
491 pvr2_ctrl_set_value(hcp, vf->fmt.pix.width);
492 pvr2_ctrl_set_value(vcp, vf->fmt.pix.height);
496 static int pvr2_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
498 struct pvr2_v4l2_fh *fh = file->private_data;
499 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
500 struct pvr2_v4l2_dev *pdi = fh->pdi;
503 if (!fh->pdi->stream) {
504 /* No stream defined for this node. This means
505 that we're not currently allowed to stream from
509 ret = pvr2_hdw_set_stream_type(hdw, pdi->config);
512 return pvr2_hdw_set_streaming(hdw, !0);
515 static int pvr2_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
517 struct pvr2_v4l2_fh *fh = file->private_data;
518 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
520 if (!fh->pdi->stream) {
521 /* No stream defined for this node. This means
522 that we're not currently allowed to stream from
526 return pvr2_hdw_set_streaming(hdw, 0);
529 static int pvr2_queryctrl(struct file *file, void *priv,
530 struct v4l2_queryctrl *vc)
532 struct pvr2_v4l2_fh *fh = file->private_data;
533 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
534 struct pvr2_ctrl *cptr;
537 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
538 cptr = pvr2_hdw_get_ctrl_nextv4l(
539 hdw, (vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
541 vc->id = pvr2_ctrl_get_v4lid(cptr);
543 cptr = pvr2_hdw_get_ctrl_v4l(hdw, vc->id);
546 pvr2_trace(PVR2_TRACE_V4LIOCTL,
547 "QUERYCTRL id=0x%x not implemented here",
552 pvr2_trace(PVR2_TRACE_V4LIOCTL,
553 "QUERYCTRL id=0x%x mapping name=%s (%s)",
554 vc->id, pvr2_ctrl_get_name(cptr),
555 pvr2_ctrl_get_desc(cptr));
556 strlcpy(vc->name, pvr2_ctrl_get_desc(cptr), sizeof(vc->name));
557 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
558 pvr2_ctrl_get_def(cptr, &val);
559 vc->default_value = val;
560 switch (pvr2_ctrl_get_type(cptr)) {
562 vc->type = V4L2_CTRL_TYPE_MENU;
564 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
568 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
574 vc->type = V4L2_CTRL_TYPE_INTEGER;
575 vc->minimum = pvr2_ctrl_get_min(cptr);
576 vc->maximum = pvr2_ctrl_get_max(cptr);
580 pvr2_trace(PVR2_TRACE_V4LIOCTL,
581 "QUERYCTRL id=0x%x name=%s not mappable",
582 vc->id, pvr2_ctrl_get_name(cptr));
588 static int pvr2_querymenu(struct file *file, void *priv, struct v4l2_querymenu *vm)
590 struct pvr2_v4l2_fh *fh = file->private_data;
591 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
592 unsigned int cnt = 0;
595 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw, vm->id),
597 vm->name, sizeof(vm->name) - 1,
603 static int pvr2_g_ctrl(struct file *file, void *priv, struct v4l2_control *vc)
605 struct pvr2_v4l2_fh *fh = file->private_data;
606 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
610 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw, vc->id),
616 static int pvr2_s_ctrl(struct file *file, void *priv, struct v4l2_control *vc)
618 struct pvr2_v4l2_fh *fh = file->private_data;
619 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
621 return pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw, vc->id),
625 static int pvr2_g_ext_ctrls(struct file *file, void *priv,
626 struct v4l2_ext_controls *ctls)
628 struct pvr2_v4l2_fh *fh = file->private_data;
629 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
630 struct v4l2_ext_control *ctrl;
631 struct pvr2_ctrl *cptr;
637 for (idx = 0; idx < ctls->count; idx++) {
638 ctrl = ctls->controls + idx;
639 cptr = pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id);
641 if (ctls->which == V4L2_CTRL_WHICH_DEF_VAL)
642 pvr2_ctrl_get_def(cptr, &val);
644 ret = pvr2_ctrl_get_value(cptr, &val);
649 ctls->error_idx = idx;
652 /* Ensure that if read as a 64 bit value, the user
653 will still get a hopefully sane value */
660 static int pvr2_s_ext_ctrls(struct file *file, void *priv,
661 struct v4l2_ext_controls *ctls)
663 struct pvr2_v4l2_fh *fh = file->private_data;
664 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
665 struct v4l2_ext_control *ctrl;
669 /* Default value cannot be changed */
670 if (ctls->which == V4L2_CTRL_WHICH_DEF_VAL)
674 for (idx = 0; idx < ctls->count; idx++) {
675 ctrl = ctls->controls + idx;
676 ret = pvr2_ctrl_set_value(
677 pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id),
680 ctls->error_idx = idx;
687 static int pvr2_try_ext_ctrls(struct file *file, void *priv,
688 struct v4l2_ext_controls *ctls)
690 struct pvr2_v4l2_fh *fh = file->private_data;
691 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
692 struct v4l2_ext_control *ctrl;
693 struct pvr2_ctrl *pctl;
696 /* For the moment just validate that the requested control
698 for (idx = 0; idx < ctls->count; idx++) {
699 ctrl = ctls->controls + idx;
700 pctl = pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id);
702 ctls->error_idx = idx;
709 static int pvr2_cropcap(struct file *file, void *priv, struct v4l2_cropcap *cap)
711 struct pvr2_v4l2_fh *fh = file->private_data;
712 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
715 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
717 ret = pvr2_hdw_get_cropcap(hdw, cap);
718 cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
722 static int pvr2_g_selection(struct file *file, void *priv,
723 struct v4l2_selection *sel)
725 struct pvr2_v4l2_fh *fh = file->private_data;
726 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
727 struct v4l2_cropcap cap;
731 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
734 cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
736 switch (sel->target) {
737 case V4L2_SEL_TGT_CROP:
738 ret = pvr2_ctrl_get_value(
739 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL), &val);
743 ret = pvr2_ctrl_get_value(
744 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT), &val);
748 ret = pvr2_ctrl_get_value(
749 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW), &val);
753 ret = pvr2_ctrl_get_value(
754 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH), &val);
759 case V4L2_SEL_TGT_CROP_DEFAULT:
760 ret = pvr2_hdw_get_cropcap(hdw, &cap);
761 sel->r = cap.defrect;
763 case V4L2_SEL_TGT_CROP_BOUNDS:
764 ret = pvr2_hdw_get_cropcap(hdw, &cap);
773 static int pvr2_s_selection(struct file *file, void *priv,
774 struct v4l2_selection *sel)
776 struct pvr2_v4l2_fh *fh = file->private_data;
777 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
780 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
781 sel->target != V4L2_SEL_TGT_CROP)
783 ret = pvr2_ctrl_set_value(
784 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL),
788 ret = pvr2_ctrl_set_value(
789 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT),
793 ret = pvr2_ctrl_set_value(
794 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW),
798 ret = pvr2_ctrl_set_value(
799 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH),
806 static int pvr2_log_status(struct file *file, void *priv)
808 struct pvr2_v4l2_fh *fh = file->private_data;
809 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
811 pvr2_hdw_trigger_module_log(hdw);
815 static const struct v4l2_ioctl_ops pvr2_ioctl_ops = {
816 .vidioc_querycap = pvr2_querycap,
817 .vidioc_s_audio = pvr2_s_audio,
818 .vidioc_g_audio = pvr2_g_audio,
819 .vidioc_enumaudio = pvr2_enumaudio,
820 .vidioc_enum_input = pvr2_enum_input,
821 .vidioc_cropcap = pvr2_cropcap,
822 .vidioc_s_selection = pvr2_s_selection,
823 .vidioc_g_selection = pvr2_g_selection,
824 .vidioc_g_input = pvr2_g_input,
825 .vidioc_s_input = pvr2_s_input,
826 .vidioc_g_frequency = pvr2_g_frequency,
827 .vidioc_s_frequency = pvr2_s_frequency,
828 .vidioc_s_tuner = pvr2_s_tuner,
829 .vidioc_g_tuner = pvr2_g_tuner,
830 .vidioc_g_std = pvr2_g_std,
831 .vidioc_s_std = pvr2_s_std,
832 .vidioc_querystd = pvr2_querystd,
833 .vidioc_log_status = pvr2_log_status,
834 .vidioc_enum_fmt_vid_cap = pvr2_enum_fmt_vid_cap,
835 .vidioc_g_fmt_vid_cap = pvr2_g_fmt_vid_cap,
836 .vidioc_s_fmt_vid_cap = pvr2_s_fmt_vid_cap,
837 .vidioc_try_fmt_vid_cap = pvr2_try_fmt_vid_cap,
838 .vidioc_streamon = pvr2_streamon,
839 .vidioc_streamoff = pvr2_streamoff,
840 .vidioc_queryctrl = pvr2_queryctrl,
841 .vidioc_querymenu = pvr2_querymenu,
842 .vidioc_g_ctrl = pvr2_g_ctrl,
843 .vidioc_s_ctrl = pvr2_s_ctrl,
844 .vidioc_g_ext_ctrls = pvr2_g_ext_ctrls,
845 .vidioc_s_ext_ctrls = pvr2_s_ext_ctrls,
846 .vidioc_try_ext_ctrls = pvr2_try_ext_ctrls,
849 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
851 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
852 enum pvr2_config cfg = dip->config;
856 /* Construct the unregistration message *before* we actually
857 perform the unregistration step. By doing it this way we don't
858 have to worry about potentially touching deleted resources. */
859 mcnt = scnprintf(msg, sizeof(msg) - 1,
860 "pvrusb2: unregistered device %s [%s]",
861 video_device_node_name(&dip->devbase),
862 pvr2_config_get_name(cfg));
865 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
871 /* Actual deallocation happens later when all internal references
873 video_unregister_device(&dip->devbase);
875 printk(KERN_INFO "%s\n", msg);
880 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
883 if (!dip->devbase.v4l2_dev->dev) return;
884 dip->devbase.v4l2_dev->dev = NULL;
885 device_move(&dip->devbase.dev, NULL, DPM_ORDER_NONE);
889 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
892 pvr2_v4l2_dev_destroy(vp->dev_video);
893 vp->dev_video = NULL;
896 pvr2_v4l2_dev_destroy(vp->dev_radio);
897 vp->dev_radio = NULL;
900 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
901 pvr2_channel_done(&vp->channel);
906 static void pvr2_video_device_release(struct video_device *vdev)
908 struct pvr2_v4l2_dev *dev;
909 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
914 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
916 struct pvr2_v4l2 *vp;
917 vp = container_of(chp,struct pvr2_v4l2,channel);
918 if (!vp->channel.mc_head->disconnect_flag) return;
919 pvr2_v4l2_dev_disassociate_parent(vp->dev_video);
920 pvr2_v4l2_dev_disassociate_parent(vp->dev_radio);
921 if (!list_empty(&vp->dev_video->devbase.fh_list) ||
923 !list_empty(&vp->dev_radio->devbase.fh_list))) {
924 pvr2_trace(PVR2_TRACE_STRUCT,
925 "pvr2_v4l2 internal_check exit-empty id=%p", vp);
928 pvr2_v4l2_destroy_no_lock(vp);
932 static long pvr2_v4l2_ioctl(struct file *file,
933 unsigned int cmd, unsigned long arg)
936 struct pvr2_v4l2_fh *fh = file->private_data;
937 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
940 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL)
941 v4l_printk_ioctl(pvr2_hdw_get_driver_name(hdw), cmd);
943 if (!pvr2_hdw_dev_ok(hdw)) {
944 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
945 "ioctl failed - bad or no context");
949 ret = video_ioctl2(file, cmd, arg);
951 pvr2_hdw_commit_ctl(hdw);
954 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
955 pvr2_trace(PVR2_TRACE_V4LIOCTL,
956 "pvr2_v4l2_do_ioctl failure, ret=%ld"
957 " command was:", ret);
958 v4l_printk_ioctl(pvr2_hdw_get_driver_name(hdw), cmd);
961 pvr2_trace(PVR2_TRACE_V4LIOCTL,
962 "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
970 static int pvr2_v4l2_release(struct file *file)
972 struct pvr2_v4l2_fh *fhp = file->private_data;
973 struct pvr2_v4l2 *vp = fhp->pdi->v4lp;
974 struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
976 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
979 struct pvr2_stream *sp;
980 pvr2_hdw_set_streaming(hdw,0);
981 sp = pvr2_ioread_get_stream(fhp->rhp);
982 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
983 pvr2_ioread_destroy(fhp->rhp);
987 v4l2_fh_del(&fhp->fh);
988 v4l2_fh_exit(&fhp->fh);
989 file->private_data = NULL;
991 pvr2_channel_done(&fhp->channel);
992 pvr2_trace(PVR2_TRACE_STRUCT,
993 "Destroying pvr_v4l2_fh id=%p",fhp);
994 if (fhp->input_map) {
995 kfree(fhp->input_map);
996 fhp->input_map = NULL;
999 if (vp->channel.mc_head->disconnect_flag &&
1000 list_empty(&vp->dev_video->devbase.fh_list) &&
1002 list_empty(&vp->dev_radio->devbase.fh_list))) {
1003 pvr2_v4l2_destroy_no_lock(vp);
1009 static int pvr2_v4l2_open(struct file *file)
1011 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1012 struct pvr2_v4l2_fh *fhp;
1013 struct pvr2_v4l2 *vp;
1014 struct pvr2_hdw *hdw;
1015 unsigned int input_mask = 0;
1016 unsigned int input_cnt,idx;
1019 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1022 hdw = vp->channel.hdw;
1024 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1026 if (!pvr2_hdw_dev_ok(hdw)) {
1027 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1028 "pvr2_v4l2_open: hardware not ready");
1032 fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1037 v4l2_fh_init(&fhp->fh, &dip->devbase);
1038 init_waitqueue_head(&fhp->wait_data);
1041 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1042 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1044 if (dip->v4l_type == VFL_TYPE_RADIO) {
1045 /* Opening device as a radio, legal input selection subset
1046 is just the radio. */
1047 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1049 /* Opening the main V4L device, legal input selection
1050 subset includes all analog inputs. */
1051 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1052 (1 << PVR2_CVAL_INPUT_TV) |
1053 (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1054 (1 << PVR2_CVAL_INPUT_SVIDEO));
1056 ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1058 pvr2_channel_done(&fhp->channel);
1059 pvr2_trace(PVR2_TRACE_STRUCT,
1060 "Destroying pvr_v4l2_fh id=%p (input mask error)",
1067 input_mask &= pvr2_hdw_get_input_available(hdw);
1069 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1070 if (input_mask & (1 << idx)) input_cnt++;
1072 fhp->input_cnt = input_cnt;
1073 fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1074 if (!fhp->input_map) {
1075 pvr2_channel_done(&fhp->channel);
1076 pvr2_trace(PVR2_TRACE_STRUCT,
1077 "Destroying pvr_v4l2_fh id=%p (input map failure)",
1083 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1084 if (!(input_mask & (1 << idx))) continue;
1085 fhp->input_map[input_cnt++] = idx;
1089 file->private_data = fhp;
1091 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1092 v4l2_fh_add(&fhp->fh);
1098 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1100 wake_up(&fhp->wait_data);
1103 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1106 struct pvr2_stream *sp;
1107 struct pvr2_hdw *hdw;
1108 if (fh->rhp) return 0;
1110 if (!fh->pdi->stream) {
1111 /* No stream defined for this node. This means that we're
1112 not currently allowed to stream from this node. */
1116 /* First read() attempt. Try to claim the stream and start
1118 if ((ret = pvr2_channel_claim_stream(&fh->channel,
1119 fh->pdi->stream)) != 0) {
1120 /* Someone else must already have it */
1124 fh->rhp = pvr2_channel_create_mpeg_stream(fh->pdi->stream);
1126 pvr2_channel_claim_stream(&fh->channel,NULL);
1130 hdw = fh->channel.mc_head->hdw;
1131 sp = fh->pdi->stream->stream;
1132 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1133 pvr2_hdw_set_stream_type(hdw,fh->pdi->config);
1134 if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1135 return pvr2_ioread_set_enabled(fh->rhp,!0);
1139 static ssize_t pvr2_v4l2_read(struct file *file,
1140 char __user *buff, size_t count, loff_t *ppos)
1142 struct pvr2_v4l2_fh *fh = file->private_data;
1145 if (fh->fw_mode_flag) {
1146 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1150 unsigned int offs = *ppos;
1152 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1153 if (!tbuf) return -ENOMEM;
1157 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1158 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1164 if (copy_to_user(buff,tbuf,c2)) {
1179 ret = pvr2_v4l2_iosetup(fh);
1186 ret = pvr2_ioread_read(fh->rhp,buff,count);
1187 if (ret >= 0) break;
1188 if (ret != -EAGAIN) break;
1189 if (file->f_flags & O_NONBLOCK) break;
1190 /* Doing blocking I/O. Wait here. */
1191 ret = wait_event_interruptible(
1193 pvr2_ioread_avail(fh->rhp) >= 0);
1201 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1203 unsigned int mask = 0;
1204 struct pvr2_v4l2_fh *fh = file->private_data;
1207 if (fh->fw_mode_flag) {
1208 mask |= POLLIN | POLLRDNORM;
1213 ret = pvr2_v4l2_iosetup(fh);
1214 if (ret) return POLLERR;
1217 poll_wait(file,&fh->wait_data,wait);
1219 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1220 mask |= POLLIN | POLLRDNORM;
1227 static const struct v4l2_file_operations vdev_fops = {
1228 .owner = THIS_MODULE,
1229 .open = pvr2_v4l2_open,
1230 .release = pvr2_v4l2_release,
1231 .read = pvr2_v4l2_read,
1232 .unlocked_ioctl = pvr2_v4l2_ioctl,
1233 .poll = pvr2_v4l2_poll,
1237 static struct video_device vdev_template = {
1242 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1243 struct pvr2_v4l2 *vp,
1248 struct pvr2_hdw *hdw;
1252 hdw = vp->channel.mc_head->hdw;
1253 dip->v4l_type = v4l_type;
1255 case VFL_TYPE_GRABBER:
1256 dip->stream = &vp->channel.mc_head->video_stream;
1257 dip->config = pvr2_config_mpeg;
1258 dip->minor_type = pvr2_v4l_type_video;
1261 pr_err(KBUILD_MODNAME
1262 ": Failed to set up pvrusb2 v4l video dev"
1263 " due to missing stream instance\n");
1268 dip->config = pvr2_config_vbi;
1269 dip->minor_type = pvr2_v4l_type_vbi;
1272 case VFL_TYPE_RADIO:
1273 dip->stream = &vp->channel.mc_head->video_stream;
1274 dip->config = pvr2_config_mpeg;
1275 dip->minor_type = pvr2_v4l_type_radio;
1279 /* Bail out (this should be impossible) */
1280 pr_err(KBUILD_MODNAME ": Failed to set up pvrusb2 v4l dev"
1281 " due to unrecognized config\n");
1285 dip->devbase = vdev_template;
1286 dip->devbase.release = pvr2_video_device_release;
1287 dip->devbase.ioctl_ops = &pvr2_ioctl_ops;
1290 pvr2_ctrl_get_value(
1291 pvr2_hdw_get_ctrl_by_id(hdw,
1292 PVR2_CID_STDAVAIL), &val);
1293 dip->devbase.tvnorms = (v4l2_std_id)val;
1297 unit_number = pvr2_hdw_get_unit_number(hdw);
1298 if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1299 mindevnum = nr_ptr[unit_number];
1301 pvr2_hdw_set_v4l2_dev(hdw, &dip->devbase);
1302 if ((video_register_device(&dip->devbase,
1303 dip->v4l_type, mindevnum) < 0) &&
1304 (video_register_device(&dip->devbase,
1305 dip->v4l_type, -1) < 0)) {
1306 pr_err(KBUILD_MODNAME
1307 ": Failed to register pvrusb2 v4l device\n");
1310 printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1311 video_device_node_name(&dip->devbase),
1312 pvr2_config_get_name(dip->config));
1314 pvr2_hdw_v4l_store_minor_number(hdw,
1315 dip->minor_type,dip->devbase.minor);
1319 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1321 struct pvr2_v4l2 *vp;
1323 vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1325 pvr2_channel_init(&vp->channel,mnp);
1326 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1328 vp->channel.check_func = pvr2_v4l2_internal_check;
1330 /* register streams */
1331 vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1332 if (!vp->dev_video) goto fail;
1333 pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1334 if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1335 (1 << PVR2_CVAL_INPUT_RADIO)) {
1336 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1337 if (!vp->dev_radio) goto fail;
1338 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1343 pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1344 pvr2_v4l2_destroy_no_lock(vp);