5 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/kernel.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>
39 struct pvr2_v4l2_dev {
40 struct video_device devbase; /* MUST be first! */
41 struct pvr2_v4l2 *v4lp;
42 struct pvr2_context_stream *stream;
43 enum pvr2_config config;
47 struct pvr2_channel channel;
48 struct pvr2_v4l2_dev *dev_info;
49 enum v4l2_priority prio;
50 struct pvr2_ioread *rhp;
52 struct pvr2_v4l2 *vhead;
53 struct pvr2_v4l2_fh *vnext;
54 struct pvr2_v4l2_fh *vprev;
55 wait_queue_head_t wait_data;
60 struct pvr2_channel channel;
61 struct pvr2_v4l2_fh *vfirst;
62 struct pvr2_v4l2_fh *vlast;
64 struct v4l2_prio_state prio;
66 /* streams - Note that these must be separately, individually,
67 * allocated pointers. This is because the v4l core is going to
68 * manage their deletion - separately, individually... */
69 struct pvr2_v4l2_dev *dev_video;
70 struct pvr2_v4l2_dev *dev_radio;
73 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
74 module_param_array(video_nr, int, NULL, 0444);
75 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
76 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
77 module_param_array(radio_nr, int, NULL, 0444);
78 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
79 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
80 module_param_array(vbi_nr, int, NULL, 0444);
81 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
83 static struct v4l2_capability pvr_capability ={
85 .card = "Hauppauge WinTV pvr-usb2",
87 .version = KERNEL_VERSION(0,8,0),
88 .capabilities = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
89 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
94 static struct v4l2_tuner pvr_v4l2_tuners[]= {
98 .type = V4L2_TUNER_ANALOG_TV,
99 .capability = (V4L2_TUNER_CAP_NORM |
100 V4L2_TUNER_CAP_STEREO |
101 V4L2_TUNER_CAP_LANG1 |
102 V4L2_TUNER_CAP_LANG2),
105 .rxsubchans = V4L2_TUNER_SUB_STEREO,
106 .audmode = V4L2_TUNER_MODE_STEREO,
109 .reserved = {0,0,0,0}
113 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
116 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
117 .flags = V4L2_FMT_FLAG_COMPRESSED,
118 .description = "MPEG1/2",
119 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
120 // breaks when I do that.
121 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
122 .reserved = { 0, 0, 0, 0 }
126 #define PVR_FORMAT_PIX 0
127 #define PVR_FORMAT_VBI 1
129 static struct v4l2_format pvr_format [] = {
131 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
136 // This should really be V4L2_PIX_FMT_MPEG,
137 // but xawtv breaks when I do that.
138 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
139 .field = V4L2_FIELD_INTERLACED,
140 .bytesperline = 0, // doesn't make sense
142 //FIXME : Don't know what to put here...
143 .sizeimage = (32*1024),
144 .colorspace = 0, // doesn't make sense here
150 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
153 .sampling_rate = 27000000,
155 .samples_per_line = 1443,
156 .sample_format = V4L2_PIX_FMT_GREY,
169 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
172 static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
173 unsigned int cmd, void *arg)
175 struct pvr2_v4l2_fh *fh = file->private_data;
176 struct pvr2_v4l2 *vp = fh->vhead;
177 struct pvr2_v4l2_dev *dev_info = fh->dev_info;
178 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
181 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
182 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
185 if (!pvr2_hdw_dev_ok(hdw)) {
186 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
187 "ioctl failed - bad or no context");
197 case VIDIOC_S_FREQUENCY:
198 ret = v4l2_prio_check(&vp->prio, &fh->prio);
204 case VIDIOC_QUERYCAP:
206 struct v4l2_capability *cap = arg;
208 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
214 case VIDIOC_G_PRIORITY:
216 enum v4l2_priority *p = arg;
218 *p = v4l2_prio_max(&vp->prio);
223 case VIDIOC_S_PRIORITY:
225 enum v4l2_priority *prio = arg;
227 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
233 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
235 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
242 ret = pvr2_ctrl_get_value(
243 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
244 *(v4l2_std_id *)arg = val;
250 ret = pvr2_ctrl_set_value(
251 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
252 *(v4l2_std_id *)arg);
256 case VIDIOC_ENUMINPUT:
258 struct pvr2_ctrl *cptr;
259 struct v4l2_input *vi = (struct v4l2_input *)arg;
260 struct v4l2_input tmp;
263 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
265 memset(&tmp,0,sizeof(tmp));
266 tmp.index = vi->index;
269 case PVR2_CVAL_INPUT_TV:
270 case PVR2_CVAL_INPUT_RADIO:
271 tmp.type = V4L2_INPUT_TYPE_TUNER;
273 case PVR2_CVAL_INPUT_SVIDEO:
274 case PVR2_CVAL_INPUT_COMPOSITE:
275 tmp.type = V4L2_INPUT_TYPE_CAMERA;
284 pvr2_ctrl_get_valname(cptr,vi->index,
285 tmp.name,sizeof(tmp.name)-1,&cnt);
288 /* Don't bother with audioset, since this driver currently
289 always switches the audio whenever the video is
292 /* Handling std is a tougher problem. It doesn't make
293 sense in cases where a device might be multi-standard.
294 We could just copy out the current value for the
295 standard, but it can change over time. For now just
298 memcpy(vi, &tmp, sizeof(tmp));
306 struct pvr2_ctrl *cptr;
307 struct v4l2_input *vi = (struct v4l2_input *)arg;
309 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
311 ret = pvr2_ctrl_get_value(cptr,&val);
318 struct v4l2_input *vi = (struct v4l2_input *)arg;
319 ret = pvr2_ctrl_set_value(
320 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
325 case VIDIOC_ENUMAUDIO:
344 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
345 unsigned int status_mask;
347 if (vt->index !=0) break;
349 status_mask = pvr2_hdw_get_signal_status(hdw);
351 memcpy(vt, &pvr_v4l2_tuners[vt->index],
352 sizeof(struct v4l2_tuner));
355 if (status_mask & PVR2_SIGNAL_OK) {
356 if (status_mask & PVR2_SIGNAL_STEREO) {
357 vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
359 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
361 if (status_mask & PVR2_SIGNAL_SAP) {
362 vt->rxsubchans |= (V4L2_TUNER_SUB_LANG1 |
363 V4L2_TUNER_SUB_LANG2);
369 ret = pvr2_ctrl_get_value(
370 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
378 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
383 ret = pvr2_ctrl_set_value(
384 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
388 case VIDIOC_S_FREQUENCY:
390 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
391 ret = pvr2_ctrl_set_value(
392 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
393 vf->frequency * 62500);
397 case VIDIOC_G_FREQUENCY:
399 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
401 ret = pvr2_ctrl_get_value(
402 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
409 case VIDIOC_ENUM_FMT:
411 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
413 /* Only one format is supported : mpeg.*/
417 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
424 struct v4l2_format *vf = (struct v4l2_format *)arg;
427 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
428 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
429 sizeof(struct v4l2_format));
432 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
434 vf->fmt.pix.width = val;
437 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
439 vf->fmt.pix.height = val;
442 case V4L2_BUF_TYPE_VBI_CAPTURE:
443 // ????? Still need to figure out to do VBI correctly
456 struct v4l2_format *vf = (struct v4l2_format *)arg;
460 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
462 struct pvr2_ctrl *hcp,*vcp;
463 int h = vf->fmt.pix.height;
464 int w = vf->fmt.pix.width;
465 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
466 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
468 lmin = pvr2_ctrl_get_min(hcp);
469 lmax = pvr2_ctrl_get_max(hcp);
472 } else if (w > lmax) {
475 lmin = pvr2_ctrl_get_min(vcp);
476 lmax = pvr2_ctrl_get_max(vcp);
479 } else if (h > lmax) {
483 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
484 sizeof(struct v4l2_format));
485 vf->fmt.pix.width = w;
486 vf->fmt.pix.height = h;
488 if (cmd == VIDIOC_S_FMT) {
489 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
490 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
493 case V4L2_BUF_TYPE_VBI_CAPTURE:
494 // ????? Still need to figure out to do VBI correctly
504 case VIDIOC_STREAMON:
506 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
507 if (ret < 0) return ret;
508 ret = pvr2_hdw_set_streaming(hdw,!0);
512 case VIDIOC_STREAMOFF:
514 ret = pvr2_hdw_set_streaming(hdw,0);
518 case VIDIOC_QUERYCTRL:
520 struct pvr2_ctrl *cptr;
521 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
523 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
524 cptr = pvr2_hdw_get_ctrl_nextv4l(
525 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
526 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
528 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
531 pvr2_trace(PVR2_TRACE_V4LIOCTL,
532 "QUERYCTRL id=0x%x not implemented here",
538 pvr2_trace(PVR2_TRACE_V4LIOCTL,
539 "QUERYCTRL id=0x%x mapping name=%s (%s)",
540 vc->id,pvr2_ctrl_get_name(cptr),
541 pvr2_ctrl_get_desc(cptr));
542 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
543 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
544 vc->default_value = pvr2_ctrl_get_def(cptr);
545 switch (pvr2_ctrl_get_type(cptr)) {
547 vc->type = V4L2_CTRL_TYPE_MENU;
549 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
553 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
559 vc->type = V4L2_CTRL_TYPE_INTEGER;
560 vc->minimum = pvr2_ctrl_get_min(cptr);
561 vc->maximum = pvr2_ctrl_get_max(cptr);
565 pvr2_trace(PVR2_TRACE_V4LIOCTL,
566 "QUERYCTRL id=0x%x name=%s not mappable",
567 vc->id,pvr2_ctrl_get_name(cptr));
574 case VIDIOC_QUERYMENU:
576 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
577 unsigned int cnt = 0;
578 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
580 vm->name,sizeof(vm->name)-1,
588 struct v4l2_control *vc = (struct v4l2_control *)arg;
590 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
598 struct v4l2_control *vc = (struct v4l2_control *)arg;
599 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
604 case VIDIOC_G_EXT_CTRLS:
606 struct v4l2_ext_controls *ctls =
607 (struct v4l2_ext_controls *)arg;
608 struct v4l2_ext_control *ctrl;
611 for (idx = 0; idx < ctls->count; idx++) {
612 ctrl = ctls->controls + idx;
613 ret = pvr2_ctrl_get_value(
614 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
616 ctls->error_idx = idx;
619 /* Ensure that if read as a 64 bit value, the user
620 will still get a hopefully sane value */
627 case VIDIOC_S_EXT_CTRLS:
629 struct v4l2_ext_controls *ctls =
630 (struct v4l2_ext_controls *)arg;
631 struct v4l2_ext_control *ctrl;
633 for (idx = 0; idx < ctls->count; idx++) {
634 ctrl = ctls->controls + idx;
635 ret = pvr2_ctrl_set_value(
636 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
639 ctls->error_idx = idx;
646 case VIDIOC_TRY_EXT_CTRLS:
648 struct v4l2_ext_controls *ctls =
649 (struct v4l2_ext_controls *)arg;
650 struct v4l2_ext_control *ctrl;
651 struct pvr2_ctrl *pctl;
653 /* For the moment just validate that the requested control
655 for (idx = 0; idx < ctls->count; idx++) {
656 ctrl = ctls->controls + idx;
657 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
660 ctls->error_idx = idx;
667 case VIDIOC_LOG_STATUS:
669 pvr2_hdw_trigger_module_log(hdw);
673 #ifdef CONFIG_VIDEO_ADV_DEBUG
674 case VIDIOC_INT_G_REGISTER:
675 case VIDIOC_INT_S_REGISTER:
678 struct v4l2_register *req = (struct v4l2_register *)arg;
679 if (cmd == VIDIOC_INT_S_REGISTER) val = req->val;
680 ret = pvr2_hdw_register_access(
681 hdw,req->i2c_id,req->reg,
682 cmd == VIDIOC_INT_S_REGISTER,&val);
683 if (cmd == VIDIOC_INT_G_REGISTER) req->val = val;
689 ret = v4l_compat_translate_ioctl(inode,file,cmd,
690 arg,pvr2_v4l2_do_ioctl);
693 pvr2_hdw_commit_ctl(hdw);
696 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
697 pvr2_trace(PVR2_TRACE_V4LIOCTL,
698 "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
700 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
701 pvr2_trace(PVR2_TRACE_V4LIOCTL,
702 "pvr2_v4l2_do_ioctl failure, ret=%d"
703 " command was:",ret);
704 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
709 pvr2_trace(PVR2_TRACE_V4LIOCTL,
710 "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
717 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
719 enum pvr2_config cfg = dip->config;
720 int minor_id = dip->devbase.minor;
721 enum pvr2_v4l_type pvt;
722 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
725 case pvr2_config_mpeg:
726 pvt = pvr2_v4l_type_video;
728 case pvr2_config_vbi:
729 pvt = pvr2_v4l_type_vbi;
731 case pvr2_config_radio:
732 pvt = pvr2_v4l_type_radio;
734 default: /* paranoia */
735 pvt = pvr2_v4l_type_video;
738 pvr2_hdw_v4l_store_minor_number(hdw,pvt,-1);
744 /* Actual deallocation happens later when all internal references
746 video_unregister_device(&dip->devbase);
749 case pvr2_config_mpeg:
750 printk(KERN_INFO "pvrusb2: unregistered device video%d [%s]\n",
752 pvr2_config_get_name(cfg));
754 case pvr2_config_radio:
755 printk(KERN_INFO "pvrusb2: unregistered device radio%d [%s]\n",
757 pvr2_config_get_name(cfg));
759 case pvr2_config_vbi:
760 printk(KERN_INFO "pvrusb2: unregistered device vbi%d [%s]\n",
762 pvr2_config_get_name(cfg));
771 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
774 pvr2_v4l2_dev_destroy(vp->dev_video);
778 pvr2_v4l2_dev_destroy(vp->dev_radio);
782 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
783 pvr2_channel_done(&vp->channel);
788 static void pvr2_video_device_release(struct video_device *vdev)
790 struct pvr2_v4l2_dev *dev;
791 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
796 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
798 struct pvr2_v4l2 *vp;
799 vp = container_of(chp,struct pvr2_v4l2,channel);
800 if (!vp->channel.mc_head->disconnect_flag) return;
801 if (vp->vfirst) return;
802 pvr2_v4l2_destroy_no_lock(vp);
806 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
807 unsigned int cmd, unsigned long arg)
810 /* Temporary hack : use ivtv api until a v4l2 one is available. */
811 #define IVTV_IOC_G_CODEC 0xFFEE7703
812 #define IVTV_IOC_S_CODEC 0xFFEE7704
813 if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
814 return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
818 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
820 struct pvr2_v4l2_fh *fhp = file->private_data;
821 struct pvr2_v4l2 *vp = fhp->vhead;
822 struct pvr2_context *mp = fhp->vhead->channel.mc_head;
824 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
827 struct pvr2_stream *sp;
828 struct pvr2_hdw *hdw;
829 hdw = fhp->channel.mc_head->hdw;
830 pvr2_hdw_set_streaming(hdw,0);
831 sp = pvr2_ioread_get_stream(fhp->rhp);
832 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
833 pvr2_ioread_destroy(fhp->rhp);
837 if (fhp->dev_info->config == pvr2_config_radio) {
839 struct pvr2_hdw *hdw;
840 hdw = fhp->channel.mc_head->hdw;
841 if ((ret = pvr2_ctrl_set_value(
842 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
843 PVR2_CVAL_INPUT_TV))) {
848 v4l2_prio_close(&vp->prio, &fhp->prio);
849 file->private_data = NULL;
851 pvr2_context_enter(mp); do {
853 fhp->vnext->vprev = fhp->vprev;
855 vp->vlast = fhp->vprev;
858 fhp->vprev->vnext = fhp->vnext;
860 vp->vfirst = fhp->vnext;
865 pvr2_channel_done(&fhp->channel);
866 pvr2_trace(PVR2_TRACE_STRUCT,
867 "Destroying pvr_v4l2_fh id=%p",fhp);
869 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
870 pvr2_v4l2_destroy_no_lock(vp);
872 } while (0); pvr2_context_exit(mp);
877 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
879 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
880 struct pvr2_v4l2_fh *fhp;
881 struct pvr2_v4l2 *vp;
882 struct pvr2_hdw *hdw;
884 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
887 hdw = vp->channel.hdw;
889 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
891 if (!pvr2_hdw_dev_ok(hdw)) {
892 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
893 "pvr2_v4l2_open: hardware not ready");
897 fhp = kmalloc(sizeof(*fhp),GFP_KERNEL);
901 memset(fhp,0,sizeof(*fhp));
903 init_waitqueue_head(&fhp->wait_data);
906 pvr2_context_enter(vp->channel.mc_head); do {
907 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
908 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
910 /* pk: warning, severe ugliness follows. 18+ only.
911 please blaim V4L(ivtv) for braindamaged interfaces,
912 not the implementor. This is probably flawed, but
913 suggestions on how to do this "right" are welcome! */
914 if (dip->config == pvr2_config_radio) {
916 if ((pvr2_channel_check_stream_no_lock(&fhp->channel,
917 fhp->dev_info->stream)) != 0) {
918 /* We can 't switch modes while streaming */
919 pvr2_channel_done(&fhp->channel);
921 pvr2_context_exit(vp->channel.mc_head);
925 if ((ret = pvr2_ctrl_set_value(
926 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
927 PVR2_CVAL_INPUT_RADIO))) {
928 pvr2_channel_done(&fhp->channel);
930 pvr2_context_exit(vp->channel.mc_head);
936 fhp->vprev = vp->vlast;
938 vp->vlast->vnext = fhp;
944 } while (0); pvr2_context_exit(vp->channel.mc_head);
947 file->private_data = fhp;
948 v4l2_prio_open(&vp->prio,&fhp->prio);
950 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
956 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
958 wake_up(&fhp->wait_data);
961 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
964 struct pvr2_stream *sp;
965 struct pvr2_hdw *hdw;
966 if (fh->rhp) return 0;
968 /* First read() attempt. Try to claim the stream and start
970 if ((ret = pvr2_channel_claim_stream(&fh->channel,
971 fh->dev_info->stream)) != 0) {
972 /* Someone else must already have it */
976 fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
978 pvr2_channel_claim_stream(&fh->channel,NULL);
982 hdw = fh->channel.mc_head->hdw;
983 sp = fh->dev_info->stream->stream;
984 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
985 pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
986 pvr2_hdw_set_streaming(hdw,!0);
987 ret = pvr2_ioread_set_enabled(fh->rhp,!0);
993 static ssize_t pvr2_v4l2_read(struct file *file,
994 char __user *buff, size_t count, loff_t *ppos)
996 struct pvr2_v4l2_fh *fh = file->private_data;
999 if (fh->fw_mode_flag) {
1000 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1004 unsigned int offs = *ppos;
1006 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1007 if (!tbuf) return -ENOMEM;
1011 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1012 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1018 if (copy_to_user(buff,tbuf,c2)) {
1032 if (fh->dev_info->config == pvr2_config_radio) {
1033 /* Radio device nodes on this device
1034 cannot be read or written. */
1039 ret = pvr2_v4l2_iosetup(fh);
1046 ret = pvr2_ioread_read(fh->rhp,buff,count);
1047 if (ret >= 0) break;
1048 if (ret != -EAGAIN) break;
1049 if (file->f_flags & O_NONBLOCK) break;
1050 /* Doing blocking I/O. Wait here. */
1051 ret = wait_event_interruptible(
1053 pvr2_ioread_avail(fh->rhp) >= 0);
1061 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1063 unsigned int mask = 0;
1064 struct pvr2_v4l2_fh *fh = file->private_data;
1067 if (fh->fw_mode_flag) {
1068 mask |= POLLIN | POLLRDNORM;
1072 if (fh->dev_info->config == pvr2_config_radio) {
1073 /* Radio device nodes on this device
1074 cannot be read or written. */
1079 ret = pvr2_v4l2_iosetup(fh);
1080 if (ret) return POLLERR;
1083 poll_wait(file,&fh->wait_data,wait);
1085 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1086 mask |= POLLIN | POLLRDNORM;
1093 static const struct file_operations vdev_fops = {
1094 .owner = THIS_MODULE,
1095 .open = pvr2_v4l2_open,
1096 .release = pvr2_v4l2_release,
1097 .read = pvr2_v4l2_read,
1098 .ioctl = pvr2_v4l2_ioctl,
1099 .llseek = no_llseek,
1100 .poll = pvr2_v4l2_poll,
1104 #define VID_HARDWARE_PVRUSB2 38 /* FIXME : need a good value */
1106 static struct video_device vdev_template = {
1107 .owner = THIS_MODULE,
1108 .type = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
1109 .type2 = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
1110 | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
1111 | V4L2_CAP_READWRITE),
1112 .hardware = VID_HARDWARE_PVRUSB2,
1117 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1118 struct pvr2_v4l2 *vp,
1119 enum pvr2_config cfg)
1124 enum pvr2_v4l_type pvt;
1129 switch (dip->config) {
1130 case pvr2_config_mpeg:
1131 v4l_type = VFL_TYPE_GRABBER;
1132 pvt = pvr2_v4l_type_video;
1133 dip->stream = &vp->channel.mc_head->video_stream;
1135 case pvr2_config_vbi:
1136 v4l_type = VFL_TYPE_VBI;
1137 pvt = pvr2_v4l_type_vbi;
1139 case pvr2_config_radio:
1140 v4l_type = VFL_TYPE_RADIO;
1141 pvt = pvr2_v4l_type_radio;
1144 /* Bail out (this should be impossible) */
1145 err("Failed to set up pvrusb2 v4l dev"
1146 " due to unrecognized config");
1150 /* radio device doesn 't need its own stream */
1151 if (!dip->stream && dip->config != pvr2_config_radio) {
1152 err("Failed to set up pvrusb2 v4l dev"
1153 " due to missing stream instance");
1157 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1158 dip->devbase.release = pvr2_video_device_release;
1161 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1162 if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1165 mindevnum = vbi_nr[unit_number];
1167 case VFL_TYPE_RADIO:
1168 mindevnum = radio_nr[unit_number];
1170 case VFL_TYPE_GRABBER:
1172 mindevnum = video_nr[unit_number];
1176 if ((video_register_device(&dip->devbase, v4l_type, mindevnum) < 0) &&
1177 (video_register_device(&dip->devbase, v4l_type, -1) < 0)) {
1178 err("Failed to register pvrusb2 v4l device");
1180 switch (dip->config) {
1181 case pvr2_config_mpeg:
1182 printk(KERN_INFO "pvrusb2: registered device video%d [%s]\n",
1183 dip->devbase.minor & 0x1f,
1184 pvr2_config_get_name(dip->config));
1186 case pvr2_config_radio:
1187 printk(KERN_INFO "pvrusb2: registered device radio%d [%s]\n",
1188 dip->devbase.minor & 0x1f,
1189 pvr2_config_get_name(dip->config));
1191 case pvr2_config_vbi:
1192 printk(KERN_INFO "pvrusb2: registered device vbi%d [%s]\n",
1193 dip->devbase.minor & 0x1f,
1194 pvr2_config_get_name(dip->config));
1200 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1201 pvt,dip->devbase.minor);
1205 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1207 struct pvr2_v4l2 *vp;
1209 vp = kmalloc(sizeof(*vp),GFP_KERNEL);
1211 memset(vp,0,sizeof(*vp));
1212 vp->dev_video = kmalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1213 vp->dev_radio = kmalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1214 if (!(vp->dev_video && vp->dev_radio)) {
1215 if (vp->dev_video) kfree(vp->dev_video);
1216 if (vp->dev_radio) kfree(vp->dev_radio);
1220 memset(vp->dev_video,0,sizeof(*vp->dev_video));
1221 memset(vp->dev_radio,0,sizeof(*vp->dev_radio));
1222 pvr2_channel_init(&vp->channel,mnp);
1223 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1225 vp->channel.check_func = pvr2_v4l2_internal_check;
1227 /* register streams */
1228 pvr2_v4l2_dev_init(vp->dev_video,vp,pvr2_config_mpeg);
1229 pvr2_v4l2_dev_init(vp->dev_radio,vp,pvr2_config_radio);
1235 Stuff for Emacs to see, in order to encourage consistent editing style:
1236 *** Local Variables: ***
1238 *** fill-column: 75 ***
1239 *** tab-width: 8 ***
1240 *** c-basic-offset: 8 ***