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 <linux/version.h>
25 #include "pvrusb2-context.h"
26 #include "pvrusb2-hdw.h"
28 #include "pvrusb2-debug.h"
29 #include "pvrusb2-v4l2.h"
30 #include "pvrusb2-ioread.h"
31 #include <linux/videodev2.h>
32 #include <media/v4l2-dev.h>
33 #include <media/v4l2-common.h>
34 #include <media/v4l2-ioctl.h>
40 struct pvr2_v4l2_dev {
41 struct video_device devbase; /* MUST be first! */
42 struct pvr2_v4l2 *v4lp;
43 struct pvr2_context_stream *stream;
44 /* Information about this device: */
45 enum pvr2_config config; /* Expected stream format */
46 int v4l_type; /* V4L defined type for this device node */
47 enum pvr2_v4l_type minor_type; /* pvr2-understood minor device type */
51 struct pvr2_channel channel;
52 struct pvr2_v4l2_dev *dev_info;
53 enum v4l2_priority prio;
54 struct pvr2_ioread *rhp;
56 struct pvr2_v4l2 *vhead;
57 struct pvr2_v4l2_fh *vnext;
58 struct pvr2_v4l2_fh *vprev;
59 wait_queue_head_t wait_data;
61 /* Map contiguous ordinal value to input id */
62 unsigned char *input_map;
63 unsigned int input_cnt;
67 struct pvr2_channel channel;
68 struct pvr2_v4l2_fh *vfirst;
69 struct pvr2_v4l2_fh *vlast;
71 struct v4l2_prio_state prio;
73 /* streams - Note that these must be separately, individually,
74 * allocated pointers. This is because the v4l core is going to
75 * manage their deletion - separately, individually... */
76 struct pvr2_v4l2_dev *dev_video;
77 struct pvr2_v4l2_dev *dev_radio;
80 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
81 module_param_array(video_nr, int, NULL, 0444);
82 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
83 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
84 module_param_array(radio_nr, int, NULL, 0444);
85 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
86 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
87 module_param_array(vbi_nr, int, NULL, 0444);
88 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
90 static struct v4l2_capability pvr_capability ={
92 .card = "Hauppauge WinTV pvr-usb2",
94 .version = KERNEL_VERSION(0, 9, 0),
95 .capabilities = (V4L2_CAP_VIDEO_CAPTURE |
96 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
101 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
104 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
105 .flags = V4L2_FMT_FLAG_COMPRESSED,
106 .description = "MPEG1/2",
107 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
108 // breaks when I do that.
109 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
110 .reserved = { 0, 0, 0, 0 }
114 #define PVR_FORMAT_PIX 0
115 #define PVR_FORMAT_VBI 1
117 static struct v4l2_format pvr_format [] = {
119 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
124 // This should really be V4L2_PIX_FMT_MPEG,
125 // but xawtv breaks when I do that.
126 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
127 .field = V4L2_FIELD_INTERLACED,
128 .bytesperline = 0, // doesn't make sense
130 //FIXME : Don't know what to put here...
131 .sizeimage = (32*1024),
132 .colorspace = 0, // doesn't make sense here
138 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
141 .sampling_rate = 27000000,
143 .samples_per_line = 1443,
144 .sample_format = V4L2_PIX_FMT_GREY,
158 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
161 static long pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
163 struct pvr2_v4l2_fh *fh = file->private_data;
164 struct pvr2_v4l2 *vp = fh->vhead;
165 struct pvr2_v4l2_dev *dev_info = fh->dev_info;
166 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
169 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
170 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
173 if (!pvr2_hdw_dev_ok(hdw)) {
174 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
175 "ioctl failed - bad or no context");
185 case VIDIOC_S_FREQUENCY:
186 ret = v4l2_prio_check(&vp->prio, &fh->prio);
192 case VIDIOC_QUERYCAP:
194 struct v4l2_capability *cap = arg;
196 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
197 strlcpy(cap->bus_info,pvr2_hdw_get_bus_info(hdw),
198 sizeof(cap->bus_info));
199 strlcpy(cap->card,pvr2_hdw_get_desc(hdw),sizeof(cap->card));
205 case VIDIOC_G_PRIORITY:
207 enum v4l2_priority *p = arg;
209 *p = v4l2_prio_max(&vp->prio);
214 case VIDIOC_S_PRIORITY:
216 enum v4l2_priority *prio = arg;
218 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
224 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
226 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
233 ret = pvr2_ctrl_get_value(
234 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
235 *(v4l2_std_id *)arg = val;
241 ret = pvr2_ctrl_set_value(
242 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
243 *(v4l2_std_id *)arg);
247 case VIDIOC_ENUMINPUT:
249 struct pvr2_ctrl *cptr;
250 struct v4l2_input *vi = (struct v4l2_input *)arg;
251 struct v4l2_input tmp;
255 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
257 memset(&tmp,0,sizeof(tmp));
258 tmp.index = vi->index;
260 if (vi->index >= fh->input_cnt) {
264 val = fh->input_map[vi->index];
266 case PVR2_CVAL_INPUT_TV:
267 case PVR2_CVAL_INPUT_DTV:
268 case PVR2_CVAL_INPUT_RADIO:
269 tmp.type = V4L2_INPUT_TYPE_TUNER;
271 case PVR2_CVAL_INPUT_SVIDEO:
272 case PVR2_CVAL_INPUT_COMPOSITE:
273 tmp.type = V4L2_INPUT_TYPE_CAMERA;
282 pvr2_ctrl_get_valname(cptr,val,
283 tmp.name,sizeof(tmp.name)-1,&cnt);
286 /* Don't bother with audioset, since this driver currently
287 always switches the audio whenever the video is
290 /* Handling std is a tougher problem. It doesn't make
291 sense in cases where a device might be multi-standard.
292 We could just copy out the current value for the
293 standard, but it can change over time. For now just
296 memcpy(vi, &tmp, sizeof(tmp));
305 struct pvr2_ctrl *cptr;
306 struct v4l2_input *vi = (struct v4l2_input *)arg;
308 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
310 ret = pvr2_ctrl_get_value(cptr,&val);
312 for (idx = 0; idx < fh->input_cnt; idx++) {
313 if (fh->input_map[idx] == val) {
323 struct v4l2_input *vi = (struct v4l2_input *)arg;
324 if (vi->index >= fh->input_cnt) {
328 ret = pvr2_ctrl_set_value(
329 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
330 fh->input_map[vi->index]);
334 case VIDIOC_ENUMAUDIO:
336 /* pkt: FIXME: We are returning one "fake" input here
337 which could very well be called "whatever_we_like".
338 This is for apps that want to see an audio input
339 just to feel comfortable, as well as to test if
340 it can do stereo or sth. There is actually no guarantee
341 that the actual audio input cannot change behind the app's
342 back, but most applications should not mind that either.
344 Hopefully, mplayer people will work with us on this (this
345 whole mess is to support mplayer pvr://), or Hans will come
346 up with a more standard way to say "we have inputs but we
347 don 't want you to change them independent of video" which
350 struct v4l2_audio *vin = arg;
352 if (vin->index > 0) break;
353 strncpy(vin->name, "PVRUSB2 Audio",14);
354 vin->capability = V4L2_AUDCAP_STEREO;
362 /* pkt: FIXME: see above comment (VIDIOC_ENUMAUDIO) */
363 struct v4l2_audio *vin = arg;
364 memset(vin,0,sizeof(*vin));
366 strncpy(vin->name, "PVRUSB2 Audio",14);
367 vin->capability = V4L2_AUDCAP_STEREO;
379 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
381 if (vt->index != 0) break; /* Only answer for the 1st tuner */
383 pvr2_hdw_execute_tuner_poll(hdw);
384 ret = pvr2_hdw_get_tuner_status(hdw,vt);
390 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
395 ret = pvr2_ctrl_set_value(
396 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
401 case VIDIOC_S_FREQUENCY:
403 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
405 struct v4l2_tuner vt;
407 struct pvr2_ctrl *ctrlp;
408 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
410 ctrlp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
411 ret = pvr2_ctrl_get_value(ctrlp,&cur_input);
413 if (vf->type == V4L2_TUNER_RADIO) {
414 if (cur_input != PVR2_CVAL_INPUT_RADIO) {
415 pvr2_ctrl_set_value(ctrlp,
416 PVR2_CVAL_INPUT_RADIO);
419 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
420 pvr2_ctrl_set_value(ctrlp,
425 if (vt.capability & V4L2_TUNER_CAP_LOW) {
430 ret = pvr2_ctrl_set_value(
431 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
435 case VIDIOC_G_FREQUENCY:
437 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
440 struct v4l2_tuner vt;
441 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
443 ret = pvr2_ctrl_get_value(
444 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
448 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
450 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
451 vf->type = V4L2_TUNER_RADIO;
453 vf->type = V4L2_TUNER_ANALOG_TV;
455 if (vt.capability & V4L2_TUNER_CAP_LOW) {
456 val = (val * 2) / 125;
464 case VIDIOC_ENUM_FMT:
466 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
468 /* Only one format is supported : mpeg.*/
472 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
479 struct v4l2_format *vf = (struct v4l2_format *)arg;
482 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
483 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
484 sizeof(struct v4l2_format));
487 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
489 vf->fmt.pix.width = val;
492 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
494 vf->fmt.pix.height = val;
497 case V4L2_BUF_TYPE_VBI_CAPTURE:
498 // ????? Still need to figure out to do VBI correctly
511 struct v4l2_format *vf = (struct v4l2_format *)arg;
515 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
517 struct pvr2_ctrl *hcp,*vcp;
518 int h = vf->fmt.pix.height;
519 int w = vf->fmt.pix.width;
520 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
521 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
523 lmin = pvr2_ctrl_get_min(hcp);
524 lmax = pvr2_ctrl_get_max(hcp);
525 pvr2_ctrl_get_def(hcp, &ldef);
528 } else if (w < lmin) {
530 } else if (w > lmax) {
533 lmin = pvr2_ctrl_get_min(vcp);
534 lmax = pvr2_ctrl_get_max(vcp);
535 pvr2_ctrl_get_def(vcp, &ldef);
538 } else if (h < lmin) {
540 } else if (h > lmax) {
544 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
545 sizeof(struct v4l2_format));
546 vf->fmt.pix.width = w;
547 vf->fmt.pix.height = h;
549 if (cmd == VIDIOC_S_FMT) {
550 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
551 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
554 case V4L2_BUF_TYPE_VBI_CAPTURE:
555 // ????? Still need to figure out to do VBI correctly
565 case VIDIOC_STREAMON:
567 if (!fh->dev_info->stream) {
568 /* No stream defined for this node. This means
569 that we're not currently allowed to stream from
574 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
575 if (ret < 0) return ret;
576 ret = pvr2_hdw_set_streaming(hdw,!0);
580 case VIDIOC_STREAMOFF:
582 if (!fh->dev_info->stream) {
583 /* No stream defined for this node. This means
584 that we're not currently allowed to stream from
589 ret = pvr2_hdw_set_streaming(hdw,0);
593 case VIDIOC_QUERYCTRL:
595 struct pvr2_ctrl *cptr;
597 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
599 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
600 cptr = pvr2_hdw_get_ctrl_nextv4l(
601 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
602 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
604 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
607 pvr2_trace(PVR2_TRACE_V4LIOCTL,
608 "QUERYCTRL id=0x%x not implemented here",
614 pvr2_trace(PVR2_TRACE_V4LIOCTL,
615 "QUERYCTRL id=0x%x mapping name=%s (%s)",
616 vc->id,pvr2_ctrl_get_name(cptr),
617 pvr2_ctrl_get_desc(cptr));
618 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
619 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
620 pvr2_ctrl_get_def(cptr, &val);
621 vc->default_value = val;
622 switch (pvr2_ctrl_get_type(cptr)) {
624 vc->type = V4L2_CTRL_TYPE_MENU;
626 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
630 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
636 vc->type = V4L2_CTRL_TYPE_INTEGER;
637 vc->minimum = pvr2_ctrl_get_min(cptr);
638 vc->maximum = pvr2_ctrl_get_max(cptr);
642 pvr2_trace(PVR2_TRACE_V4LIOCTL,
643 "QUERYCTRL id=0x%x name=%s not mappable",
644 vc->id,pvr2_ctrl_get_name(cptr));
651 case VIDIOC_QUERYMENU:
653 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
654 unsigned int cnt = 0;
655 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
657 vm->name,sizeof(vm->name)-1,
665 struct v4l2_control *vc = (struct v4l2_control *)arg;
667 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
675 struct v4l2_control *vc = (struct v4l2_control *)arg;
676 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
681 case VIDIOC_G_EXT_CTRLS:
683 struct v4l2_ext_controls *ctls =
684 (struct v4l2_ext_controls *)arg;
685 struct v4l2_ext_control *ctrl;
689 for (idx = 0; idx < ctls->count; idx++) {
690 ctrl = ctls->controls + idx;
691 ret = pvr2_ctrl_get_value(
692 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
694 ctls->error_idx = idx;
697 /* Ensure that if read as a 64 bit value, the user
698 will still get a hopefully sane value */
705 case VIDIOC_S_EXT_CTRLS:
707 struct v4l2_ext_controls *ctls =
708 (struct v4l2_ext_controls *)arg;
709 struct v4l2_ext_control *ctrl;
712 for (idx = 0; idx < ctls->count; idx++) {
713 ctrl = ctls->controls + idx;
714 ret = pvr2_ctrl_set_value(
715 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
718 ctls->error_idx = idx;
725 case VIDIOC_TRY_EXT_CTRLS:
727 struct v4l2_ext_controls *ctls =
728 (struct v4l2_ext_controls *)arg;
729 struct v4l2_ext_control *ctrl;
730 struct pvr2_ctrl *pctl;
732 /* For the moment just validate that the requested control
735 for (idx = 0; idx < ctls->count; idx++) {
736 ctrl = ctls->controls + idx;
737 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
740 ctls->error_idx = idx;
749 struct v4l2_cropcap *cap = (struct v4l2_cropcap *)arg;
750 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
754 ret = pvr2_hdw_get_cropcap(hdw, cap);
755 cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
760 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
762 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
766 ret = pvr2_ctrl_get_value(
767 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL), &val);
773 ret = pvr2_ctrl_get_value(
774 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT), &val);
780 ret = pvr2_ctrl_get_value(
781 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW), &val);
787 ret = pvr2_ctrl_get_value(
788 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH), &val);
793 crop->c.height = val;
797 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
798 struct v4l2_cropcap cap;
799 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
803 cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
804 ret = pvr2_ctrl_set_value(
805 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL),
811 ret = pvr2_ctrl_set_value(
812 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT),
818 ret = pvr2_ctrl_set_value(
819 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW),
825 ret = pvr2_ctrl_set_value(
826 pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH),
833 case VIDIOC_LOG_STATUS:
835 pvr2_hdw_trigger_module_log(hdw);
839 #ifdef CONFIG_VIDEO_ADV_DEBUG
840 case VIDIOC_DBG_S_REGISTER:
841 case VIDIOC_DBG_G_REGISTER:
844 struct v4l2_dbg_register *req = (struct v4l2_dbg_register *)arg;
845 if (cmd == VIDIOC_DBG_S_REGISTER) val = req->val;
846 ret = pvr2_hdw_register_access(
847 hdw, &req->match, req->reg,
848 cmd == VIDIOC_DBG_S_REGISTER, &val);
849 if (cmd == VIDIOC_DBG_G_REGISTER) req->val = val;
855 ret = v4l_compat_translate_ioctl(file, cmd,
856 arg, pvr2_v4l2_do_ioctl);
859 pvr2_hdw_commit_ctl(hdw);
862 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
863 pvr2_trace(PVR2_TRACE_V4LIOCTL,
864 "pvr2_v4l2_do_ioctl failure, ret=%ld", ret);
866 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
867 pvr2_trace(PVR2_TRACE_V4LIOCTL,
868 "pvr2_v4l2_do_ioctl failure, ret=%ld"
869 " command was:", ret);
870 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
875 pvr2_trace(PVR2_TRACE_V4LIOCTL,
876 "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
882 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
884 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
885 enum pvr2_config cfg = dip->config;
887 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
893 /* Actual deallocation happens later when all internal references
895 video_unregister_device(&dip->devbase);
897 printk(KERN_INFO "pvrusb2: unregistered device %s [%s]\n",
898 video_device_node_name(&dip->devbase),
899 pvr2_config_get_name(cfg));
904 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
907 if (!dip->devbase.parent) return;
908 dip->devbase.parent = NULL;
909 device_move(&dip->devbase.dev, NULL, DPM_ORDER_NONE);
913 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
916 pvr2_v4l2_dev_destroy(vp->dev_video);
917 vp->dev_video = NULL;
920 pvr2_v4l2_dev_destroy(vp->dev_radio);
921 vp->dev_radio = NULL;
924 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
925 pvr2_channel_done(&vp->channel);
930 static void pvr2_video_device_release(struct video_device *vdev)
932 struct pvr2_v4l2_dev *dev;
933 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
938 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
940 struct pvr2_v4l2 *vp;
941 vp = container_of(chp,struct pvr2_v4l2,channel);
942 if (!vp->channel.mc_head->disconnect_flag) return;
943 pvr2_v4l2_dev_disassociate_parent(vp->dev_video);
944 pvr2_v4l2_dev_disassociate_parent(vp->dev_radio);
945 if (vp->vfirst) return;
946 pvr2_v4l2_destroy_no_lock(vp);
950 static long pvr2_v4l2_ioctl(struct file *file,
951 unsigned int cmd, unsigned long arg)
954 return video_usercopy(file, cmd, arg, pvr2_v4l2_do_ioctl);
958 static int pvr2_v4l2_release(struct file *file)
960 struct pvr2_v4l2_fh *fhp = file->private_data;
961 struct pvr2_v4l2 *vp = fhp->vhead;
962 struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
964 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
967 struct pvr2_stream *sp;
968 pvr2_hdw_set_streaming(hdw,0);
969 sp = pvr2_ioread_get_stream(fhp->rhp);
970 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
971 pvr2_ioread_destroy(fhp->rhp);
975 v4l2_prio_close(&vp->prio, &fhp->prio);
976 file->private_data = NULL;
979 fhp->vnext->vprev = fhp->vprev;
981 vp->vlast = fhp->vprev;
984 fhp->vprev->vnext = fhp->vnext;
986 vp->vfirst = fhp->vnext;
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 && !vp->vfirst) {
1000 pvr2_v4l2_destroy_no_lock(vp);
1006 static int pvr2_v4l2_open(struct file *file)
1008 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1009 struct pvr2_v4l2_fh *fhp;
1010 struct pvr2_v4l2 *vp;
1011 struct pvr2_hdw *hdw;
1012 unsigned int input_mask = 0;
1013 unsigned int input_cnt,idx;
1016 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1019 hdw = vp->channel.hdw;
1021 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1023 if (!pvr2_hdw_dev_ok(hdw)) {
1024 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1025 "pvr2_v4l2_open: hardware not ready");
1029 fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1034 init_waitqueue_head(&fhp->wait_data);
1035 fhp->dev_info = dip;
1037 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1038 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1040 if (dip->v4l_type == VFL_TYPE_RADIO) {
1041 /* Opening device as a radio, legal input selection subset
1042 is just the radio. */
1043 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1045 /* Opening the main V4L device, legal input selection
1046 subset includes all analog inputs. */
1047 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1048 (1 << PVR2_CVAL_INPUT_TV) |
1049 (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1050 (1 << PVR2_CVAL_INPUT_SVIDEO));
1052 ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1054 pvr2_channel_done(&fhp->channel);
1055 pvr2_trace(PVR2_TRACE_STRUCT,
1056 "Destroying pvr_v4l2_fh id=%p (input mask error)",
1063 input_mask &= pvr2_hdw_get_input_available(hdw);
1065 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1066 if (input_mask & (1 << idx)) input_cnt++;
1068 fhp->input_cnt = input_cnt;
1069 fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1070 if (!fhp->input_map) {
1071 pvr2_channel_done(&fhp->channel);
1072 pvr2_trace(PVR2_TRACE_STRUCT,
1073 "Destroying pvr_v4l2_fh id=%p (input map failure)",
1079 for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1080 if (!(input_mask & (1 << idx))) continue;
1081 fhp->input_map[input_cnt++] = idx;
1085 fhp->vprev = vp->vlast;
1087 vp->vlast->vnext = fhp;
1095 file->private_data = fhp;
1096 v4l2_prio_open(&vp->prio,&fhp->prio);
1098 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1104 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1106 wake_up(&fhp->wait_data);
1109 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1112 struct pvr2_stream *sp;
1113 struct pvr2_hdw *hdw;
1114 if (fh->rhp) return 0;
1116 if (!fh->dev_info->stream) {
1117 /* No stream defined for this node. This means that we're
1118 not currently allowed to stream from this node. */
1122 /* First read() attempt. Try to claim the stream and start
1124 if ((ret = pvr2_channel_claim_stream(&fh->channel,
1125 fh->dev_info->stream)) != 0) {
1126 /* Someone else must already have it */
1130 fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
1132 pvr2_channel_claim_stream(&fh->channel,NULL);
1136 hdw = fh->channel.mc_head->hdw;
1137 sp = fh->dev_info->stream->stream;
1138 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1139 pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
1140 if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1141 return pvr2_ioread_set_enabled(fh->rhp,!0);
1145 static ssize_t pvr2_v4l2_read(struct file *file,
1146 char __user *buff, size_t count, loff_t *ppos)
1148 struct pvr2_v4l2_fh *fh = file->private_data;
1151 if (fh->fw_mode_flag) {
1152 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1156 unsigned int offs = *ppos;
1158 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1159 if (!tbuf) return -ENOMEM;
1163 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1164 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1170 if (copy_to_user(buff,tbuf,c2)) {
1185 ret = pvr2_v4l2_iosetup(fh);
1192 ret = pvr2_ioread_read(fh->rhp,buff,count);
1193 if (ret >= 0) break;
1194 if (ret != -EAGAIN) break;
1195 if (file->f_flags & O_NONBLOCK) break;
1196 /* Doing blocking I/O. Wait here. */
1197 ret = wait_event_interruptible(
1199 pvr2_ioread_avail(fh->rhp) >= 0);
1207 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1209 unsigned int mask = 0;
1210 struct pvr2_v4l2_fh *fh = file->private_data;
1213 if (fh->fw_mode_flag) {
1214 mask |= POLLIN | POLLRDNORM;
1219 ret = pvr2_v4l2_iosetup(fh);
1220 if (ret) return POLLERR;
1223 poll_wait(file,&fh->wait_data,wait);
1225 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1226 mask |= POLLIN | POLLRDNORM;
1233 static const struct v4l2_file_operations vdev_fops = {
1234 .owner = THIS_MODULE,
1235 .open = pvr2_v4l2_open,
1236 .release = pvr2_v4l2_release,
1237 .read = pvr2_v4l2_read,
1238 .ioctl = pvr2_v4l2_ioctl,
1239 .poll = pvr2_v4l2_poll,
1243 static struct video_device vdev_template = {
1248 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1249 struct pvr2_v4l2 *vp,
1252 struct usb_device *usbdev;
1258 usbdev = pvr2_hdw_get_dev(vp->channel.mc_head->hdw);
1259 dip->v4l_type = v4l_type;
1261 case VFL_TYPE_GRABBER:
1262 dip->stream = &vp->channel.mc_head->video_stream;
1263 dip->config = pvr2_config_mpeg;
1264 dip->minor_type = pvr2_v4l_type_video;
1267 pr_err(KBUILD_MODNAME
1268 ": Failed to set up pvrusb2 v4l video dev"
1269 " due to missing stream instance\n");
1274 dip->config = pvr2_config_vbi;
1275 dip->minor_type = pvr2_v4l_type_vbi;
1278 case VFL_TYPE_RADIO:
1279 dip->stream = &vp->channel.mc_head->video_stream;
1280 dip->config = pvr2_config_mpeg;
1281 dip->minor_type = pvr2_v4l_type_radio;
1285 /* Bail out (this should be impossible) */
1286 pr_err(KBUILD_MODNAME ": Failed to set up pvrusb2 v4l dev"
1287 " due to unrecognized config\n");
1291 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1292 dip->devbase.release = pvr2_video_device_release;
1295 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1296 if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1297 mindevnum = nr_ptr[unit_number];
1299 dip->devbase.parent = &usbdev->dev;
1300 if ((video_register_device(&dip->devbase,
1301 dip->v4l_type, mindevnum) < 0) &&
1302 (video_register_device(&dip->devbase,
1303 dip->v4l_type, -1) < 0)) {
1304 pr_err(KBUILD_MODNAME
1305 ": Failed to register pvrusb2 v4l device\n");
1308 printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1309 video_device_node_name(&dip->devbase),
1310 pvr2_config_get_name(dip->config));
1312 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1313 dip->minor_type,dip->devbase.minor);
1317 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1319 struct pvr2_v4l2 *vp;
1321 vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1323 pvr2_channel_init(&vp->channel,mnp);
1324 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1326 vp->channel.check_func = pvr2_v4l2_internal_check;
1328 /* register streams */
1329 vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1330 if (!vp->dev_video) goto fail;
1331 pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1332 if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1333 (1 << PVR2_CVAL_INPUT_RADIO)) {
1334 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1335 if (!vp->dev_radio) goto fail;
1336 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1341 pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1342 pvr2_v4l2_destroy_no_lock(vp);
1347 Stuff for Emacs to see, in order to encourage consistent editing style:
1348 *** Local Variables: ***
1350 *** fill-column: 75 ***
1351 *** tab-width: 8 ***
1352 *** c-basic-offset: 8 ***