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 /* Information about this device: */
44 enum pvr2_config config; /* Expected stream format */
45 int v4l_type; /* V4L defined type for this device node */
46 enum pvr2_v4l_type minor_type; /* pvr2-understood minor device type */
50 struct pvr2_channel channel;
51 struct pvr2_v4l2_dev *dev_info;
52 enum v4l2_priority prio;
53 struct pvr2_ioread *rhp;
55 struct pvr2_v4l2 *vhead;
56 struct pvr2_v4l2_fh *vnext;
57 struct pvr2_v4l2_fh *vprev;
58 wait_queue_head_t wait_data;
64 struct pvr2_channel channel;
65 struct pvr2_v4l2_fh *vfirst;
66 struct pvr2_v4l2_fh *vlast;
68 struct v4l2_prio_state prio;
70 /* streams - Note that these must be separately, individually,
71 * allocated pointers. This is because the v4l core is going to
72 * manage their deletion - separately, individually... */
73 struct pvr2_v4l2_dev *dev_video;
74 struct pvr2_v4l2_dev *dev_radio;
77 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
78 module_param_array(video_nr, int, NULL, 0444);
79 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
80 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
81 module_param_array(radio_nr, int, NULL, 0444);
82 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
83 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
84 module_param_array(vbi_nr, int, NULL, 0444);
85 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
87 static struct v4l2_capability pvr_capability ={
89 .card = "Hauppauge WinTV pvr-usb2",
91 .version = KERNEL_VERSION(0,8,0),
92 .capabilities = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
93 V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
98 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
101 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
102 .flags = V4L2_FMT_FLAG_COMPRESSED,
103 .description = "MPEG1/2",
104 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
105 // breaks when I do that.
106 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
107 .reserved = { 0, 0, 0, 0 }
111 #define PVR_FORMAT_PIX 0
112 #define PVR_FORMAT_VBI 1
114 static struct v4l2_format pvr_format [] = {
116 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
121 // This should really be V4L2_PIX_FMT_MPEG,
122 // but xawtv breaks when I do that.
123 .pixelformat = 0, // V4L2_PIX_FMT_MPEG,
124 .field = V4L2_FIELD_INTERLACED,
125 .bytesperline = 0, // doesn't make sense
127 //FIXME : Don't know what to put here...
128 .sizeimage = (32*1024),
129 .colorspace = 0, // doesn't make sense here
135 .type = V4L2_BUF_TYPE_VBI_CAPTURE,
138 .sampling_rate = 27000000,
140 .samples_per_line = 1443,
141 .sample_format = V4L2_PIX_FMT_GREY,
152 static const char *get_v4l_name(int v4l_type)
155 case VFL_TYPE_GRABBER: return "video";
156 case VFL_TYPE_RADIO: return "radio";
157 case VFL_TYPE_VBI: return "vbi";
166 * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
169 static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
170 unsigned int cmd, void *arg)
172 struct pvr2_v4l2_fh *fh = file->private_data;
173 struct pvr2_v4l2 *vp = fh->vhead;
174 struct pvr2_v4l2_dev *dev_info = fh->dev_info;
175 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
178 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
179 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
182 if (!pvr2_hdw_dev_ok(hdw)) {
183 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
184 "ioctl failed - bad or no context");
194 case VIDIOC_S_FREQUENCY:
195 ret = v4l2_prio_check(&vp->prio, &fh->prio);
201 case VIDIOC_QUERYCAP:
203 struct v4l2_capability *cap = arg;
205 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
211 case VIDIOC_G_PRIORITY:
213 enum v4l2_priority *p = arg;
215 *p = v4l2_prio_max(&vp->prio);
220 case VIDIOC_S_PRIORITY:
222 enum v4l2_priority *prio = arg;
224 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
230 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
232 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
239 ret = pvr2_ctrl_get_value(
240 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
241 *(v4l2_std_id *)arg = val;
247 ret = pvr2_ctrl_set_value(
248 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
249 *(v4l2_std_id *)arg);
253 case VIDIOC_ENUMINPUT:
255 struct pvr2_ctrl *cptr;
256 struct v4l2_input *vi = (struct v4l2_input *)arg;
257 struct v4l2_input tmp;
260 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
262 memset(&tmp,0,sizeof(tmp));
263 tmp.index = vi->index;
266 case PVR2_CVAL_INPUT_TV:
267 case PVR2_CVAL_INPUT_RADIO:
268 tmp.type = V4L2_INPUT_TYPE_TUNER;
270 case PVR2_CVAL_INPUT_SVIDEO:
271 case PVR2_CVAL_INPUT_COMPOSITE:
272 tmp.type = V4L2_INPUT_TYPE_CAMERA;
281 pvr2_ctrl_get_valname(cptr,vi->index,
282 tmp.name,sizeof(tmp.name)-1,&cnt);
285 /* Don't bother with audioset, since this driver currently
286 always switches the audio whenever the video is
289 /* Handling std is a tougher problem. It doesn't make
290 sense in cases where a device might be multi-standard.
291 We could just copy out the current value for the
292 standard, but it can change over time. For now just
295 memcpy(vi, &tmp, sizeof(tmp));
303 struct pvr2_ctrl *cptr;
304 struct v4l2_input *vi = (struct v4l2_input *)arg;
306 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
308 ret = pvr2_ctrl_get_value(cptr,&val);
315 struct v4l2_input *vi = (struct v4l2_input *)arg;
316 ret = pvr2_ctrl_set_value(
317 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
322 case VIDIOC_ENUMAUDIO:
324 /* pkt: FIXME: We are returning one "fake" input here
325 which could very well be called "whatever_we_like".
326 This is for apps that want to see an audio input
327 just to feel comfortable, as well as to test if
328 it can do stereo or sth. There is actually no guarantee
329 that the actual audio input cannot change behind the app's
330 back, but most applications should not mind that either.
332 Hopefully, mplayer people will work with us on this (this
333 whole mess is to support mplayer pvr://), or Hans will come
334 up with a more standard way to say "we have inputs but we
335 don 't want you to change them independent of video" which
338 struct v4l2_audio *vin = arg;
340 if (vin->index > 0) break;
341 strncpy(vin->name, "PVRUSB2 Audio",14);
342 vin->capability = V4L2_AUDCAP_STEREO;
350 /* pkt: FIXME: see above comment (VIDIOC_ENUMAUDIO) */
351 struct v4l2_audio *vin = arg;
352 memset(vin,0,sizeof(*vin));
354 strncpy(vin->name, "PVRUSB2 Audio",14);
355 vin->capability = V4L2_AUDCAP_STEREO;
367 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
368 pvr2_hdw_execute_tuner_poll(hdw);
369 ret = pvr2_hdw_get_tuner_status(hdw,vt);
375 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
380 ret = pvr2_ctrl_set_value(
381 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
386 case VIDIOC_S_FREQUENCY:
388 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
390 struct v4l2_tuner vt;
392 struct pvr2_ctrl *ctrlp;
393 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
395 ctrlp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
396 ret = pvr2_ctrl_get_value(ctrlp,&cur_input);
398 if (vf->type == V4L2_TUNER_RADIO) {
399 if (cur_input != PVR2_CVAL_INPUT_RADIO) {
400 pvr2_ctrl_set_value(ctrlp,
401 PVR2_CVAL_INPUT_RADIO);
404 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
405 pvr2_ctrl_set_value(ctrlp,
410 if (vt.capability & V4L2_TUNER_CAP_LOW) {
415 ret = pvr2_ctrl_set_value(
416 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
420 case VIDIOC_G_FREQUENCY:
422 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
425 struct v4l2_tuner vt;
426 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
428 ret = pvr2_ctrl_get_value(
429 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
433 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
435 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
436 vf->type = V4L2_TUNER_RADIO;
438 vf->type = V4L2_TUNER_ANALOG_TV;
440 if (vt.capability & V4L2_TUNER_CAP_LOW) {
441 val = (val * 2) / 125;
449 case VIDIOC_ENUM_FMT:
451 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
453 /* Only one format is supported : mpeg.*/
457 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
464 struct v4l2_format *vf = (struct v4l2_format *)arg;
467 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
468 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
469 sizeof(struct v4l2_format));
472 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
474 vf->fmt.pix.width = val;
477 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
479 vf->fmt.pix.height = val;
482 case V4L2_BUF_TYPE_VBI_CAPTURE:
483 // ????? Still need to figure out to do VBI correctly
496 struct v4l2_format *vf = (struct v4l2_format *)arg;
500 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
502 struct pvr2_ctrl *hcp,*vcp;
503 int h = vf->fmt.pix.height;
504 int w = vf->fmt.pix.width;
505 hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
506 vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
508 lmin = pvr2_ctrl_get_min(hcp);
509 lmax = pvr2_ctrl_get_max(hcp);
512 } else if (w > lmax) {
515 lmin = pvr2_ctrl_get_min(vcp);
516 lmax = pvr2_ctrl_get_max(vcp);
519 } else if (h > lmax) {
523 memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
524 sizeof(struct v4l2_format));
525 vf->fmt.pix.width = w;
526 vf->fmt.pix.height = h;
528 if (cmd == VIDIOC_S_FMT) {
529 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
530 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
533 case V4L2_BUF_TYPE_VBI_CAPTURE:
534 // ????? Still need to figure out to do VBI correctly
544 case VIDIOC_STREAMON:
546 if (!fh->dev_info->stream) {
547 /* No stream defined for this node. This means
548 that we're not currently allowed to stream from
553 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
554 if (ret < 0) return ret;
555 ret = pvr2_hdw_set_streaming(hdw,!0);
559 case VIDIOC_STREAMOFF:
561 if (!fh->dev_info->stream) {
562 /* No stream defined for this node. This means
563 that we're not currently allowed to stream from
568 ret = pvr2_hdw_set_streaming(hdw,0);
572 case VIDIOC_QUERYCTRL:
574 struct pvr2_ctrl *cptr;
575 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
577 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
578 cptr = pvr2_hdw_get_ctrl_nextv4l(
579 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
580 if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
582 cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
585 pvr2_trace(PVR2_TRACE_V4LIOCTL,
586 "QUERYCTRL id=0x%x not implemented here",
592 pvr2_trace(PVR2_TRACE_V4LIOCTL,
593 "QUERYCTRL id=0x%x mapping name=%s (%s)",
594 vc->id,pvr2_ctrl_get_name(cptr),
595 pvr2_ctrl_get_desc(cptr));
596 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
597 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
598 vc->default_value = pvr2_ctrl_get_def(cptr);
599 switch (pvr2_ctrl_get_type(cptr)) {
601 vc->type = V4L2_CTRL_TYPE_MENU;
603 vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
607 vc->type = V4L2_CTRL_TYPE_BOOLEAN;
613 vc->type = V4L2_CTRL_TYPE_INTEGER;
614 vc->minimum = pvr2_ctrl_get_min(cptr);
615 vc->maximum = pvr2_ctrl_get_max(cptr);
619 pvr2_trace(PVR2_TRACE_V4LIOCTL,
620 "QUERYCTRL id=0x%x name=%s not mappable",
621 vc->id,pvr2_ctrl_get_name(cptr));
628 case VIDIOC_QUERYMENU:
630 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
631 unsigned int cnt = 0;
632 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
634 vm->name,sizeof(vm->name)-1,
642 struct v4l2_control *vc = (struct v4l2_control *)arg;
644 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
652 struct v4l2_control *vc = (struct v4l2_control *)arg;
653 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
658 case VIDIOC_G_EXT_CTRLS:
660 struct v4l2_ext_controls *ctls =
661 (struct v4l2_ext_controls *)arg;
662 struct v4l2_ext_control *ctrl;
666 for (idx = 0; idx < ctls->count; idx++) {
667 ctrl = ctls->controls + idx;
668 ret = pvr2_ctrl_get_value(
669 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
671 ctls->error_idx = idx;
674 /* Ensure that if read as a 64 bit value, the user
675 will still get a hopefully sane value */
682 case VIDIOC_S_EXT_CTRLS:
684 struct v4l2_ext_controls *ctls =
685 (struct v4l2_ext_controls *)arg;
686 struct v4l2_ext_control *ctrl;
689 for (idx = 0; idx < ctls->count; idx++) {
690 ctrl = ctls->controls + idx;
691 ret = pvr2_ctrl_set_value(
692 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
695 ctls->error_idx = idx;
702 case VIDIOC_TRY_EXT_CTRLS:
704 struct v4l2_ext_controls *ctls =
705 (struct v4l2_ext_controls *)arg;
706 struct v4l2_ext_control *ctrl;
707 struct pvr2_ctrl *pctl;
709 /* For the moment just validate that the requested control
712 for (idx = 0; idx < ctls->count; idx++) {
713 ctrl = ctls->controls + idx;
714 pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
717 ctls->error_idx = idx;
724 case VIDIOC_LOG_STATUS:
726 pvr2_hdw_trigger_module_log(hdw);
730 #ifdef CONFIG_VIDEO_ADV_DEBUG
731 case VIDIOC_INT_G_REGISTER:
732 case VIDIOC_INT_S_REGISTER:
735 struct v4l2_register *req = (struct v4l2_register *)arg;
736 if (cmd == VIDIOC_INT_S_REGISTER) val = req->val;
737 ret = pvr2_hdw_register_access(
738 hdw,req->i2c_id,req->reg,
739 cmd == VIDIOC_INT_S_REGISTER,&val);
740 if (cmd == VIDIOC_INT_G_REGISTER) req->val = val;
746 ret = v4l_compat_translate_ioctl(inode,file,cmd,
747 arg,pvr2_v4l2_do_ioctl);
750 pvr2_hdw_commit_ctl(hdw);
753 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
754 pvr2_trace(PVR2_TRACE_V4LIOCTL,
755 "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
757 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
758 pvr2_trace(PVR2_TRACE_V4LIOCTL,
759 "pvr2_v4l2_do_ioctl failure, ret=%d"
760 " command was:",ret);
761 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
766 pvr2_trace(PVR2_TRACE_V4LIOCTL,
767 "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
774 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
776 int minor_id = dip->devbase.minor;
777 struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
778 enum pvr2_config cfg = dip->config;
779 int v4l_type = dip->v4l_type;
781 pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
787 /* Actual deallocation happens later when all internal references
789 video_unregister_device(&dip->devbase);
791 printk(KERN_INFO "pvrusb2: unregistered device %s%u [%s]\n",
792 get_v4l_name(v4l_type),minor_id & 0x1f,
793 pvr2_config_get_name(cfg));
798 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
801 pvr2_v4l2_dev_destroy(vp->dev_video);
805 pvr2_v4l2_dev_destroy(vp->dev_radio);
809 pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
810 pvr2_channel_done(&vp->channel);
815 static void pvr2_video_device_release(struct video_device *vdev)
817 struct pvr2_v4l2_dev *dev;
818 dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
823 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
825 struct pvr2_v4l2 *vp;
826 vp = container_of(chp,struct pvr2_v4l2,channel);
827 if (!vp->channel.mc_head->disconnect_flag) return;
828 if (vp->vfirst) return;
829 pvr2_v4l2_destroy_no_lock(vp);
833 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
834 unsigned int cmd, unsigned long arg)
837 /* Temporary hack : use ivtv api until a v4l2 one is available. */
838 #define IVTV_IOC_G_CODEC 0xFFEE7703
839 #define IVTV_IOC_S_CODEC 0xFFEE7704
840 if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
841 return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
845 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
847 struct pvr2_v4l2_fh *fhp = file->private_data;
848 struct pvr2_v4l2 *vp = fhp->vhead;
849 struct pvr2_context *mp = fhp->vhead->channel.mc_head;
850 struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
852 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
855 struct pvr2_stream *sp;
856 pvr2_hdw_set_streaming(hdw,0);
857 sp = pvr2_ioread_get_stream(fhp->rhp);
858 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
859 pvr2_ioread_destroy(fhp->rhp);
863 v4l2_prio_close(&vp->prio, &fhp->prio);
864 file->private_data = NULL;
866 pvr2_context_enter(mp); do {
867 /* Restore the previous input selection, if it makes sense
869 if (fhp->dev_info->v4l_type == VFL_TYPE_RADIO) {
870 struct pvr2_ctrl *cp;
872 cp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
873 pvr2_ctrl_get_value(cp,&pval);
874 /* Only restore if we're still selecting the radio */
875 if (pval == PVR2_CVAL_INPUT_RADIO) {
876 pvr2_ctrl_set_value(cp,fhp->prev_input_val);
877 pvr2_hdw_commit_ctl(hdw);
882 fhp->vnext->vprev = fhp->vprev;
884 vp->vlast = fhp->vprev;
887 fhp->vprev->vnext = fhp->vnext;
889 vp->vfirst = fhp->vnext;
894 pvr2_channel_done(&fhp->channel);
895 pvr2_trace(PVR2_TRACE_STRUCT,
896 "Destroying pvr_v4l2_fh id=%p",fhp);
898 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
899 pvr2_v4l2_destroy_no_lock(vp);
901 } while (0); pvr2_context_exit(mp);
906 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
908 struct pvr2_v4l2_dev *dip; /* Our own context pointer */
909 struct pvr2_v4l2_fh *fhp;
910 struct pvr2_v4l2 *vp;
911 struct pvr2_hdw *hdw;
913 dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
916 hdw = vp->channel.hdw;
918 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
920 if (!pvr2_hdw_dev_ok(hdw)) {
921 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
922 "pvr2_v4l2_open: hardware not ready");
926 fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
931 init_waitqueue_head(&fhp->wait_data);
934 pvr2_context_enter(vp->channel.mc_head); do {
935 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
936 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
939 fhp->vprev = vp->vlast;
941 vp->vlast->vnext = fhp;
948 /* Opening the /dev/radioX device implies a mode switch.
949 So execute that here. Note that you can get the
950 IDENTICAL effect merely by opening the normal video
951 device and setting the input appropriately. */
952 if (dip->v4l_type == VFL_TYPE_RADIO) {
953 struct pvr2_ctrl *cp;
954 cp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
955 pvr2_ctrl_get_value(cp,&fhp->prev_input_val);
956 pvr2_ctrl_set_value(cp,PVR2_CVAL_INPUT_RADIO);
957 pvr2_hdw_commit_ctl(hdw);
959 } while (0); pvr2_context_exit(vp->channel.mc_head);
962 file->private_data = fhp;
963 v4l2_prio_open(&vp->prio,&fhp->prio);
965 fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
971 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
973 wake_up(&fhp->wait_data);
976 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
979 struct pvr2_stream *sp;
980 struct pvr2_hdw *hdw;
981 if (fh->rhp) return 0;
983 if (!fh->dev_info->stream) {
984 /* No stream defined for this node. This means that we're
985 not currently allowed to stream from this node. */
989 /* First read() attempt. Try to claim the stream and start
991 if ((ret = pvr2_channel_claim_stream(&fh->channel,
992 fh->dev_info->stream)) != 0) {
993 /* Someone else must already have it */
997 fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
999 pvr2_channel_claim_stream(&fh->channel,NULL);
1003 hdw = fh->channel.mc_head->hdw;
1004 sp = fh->dev_info->stream->stream;
1005 pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1006 pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
1007 pvr2_hdw_set_streaming(hdw,!0);
1008 ret = pvr2_ioread_set_enabled(fh->rhp,!0);
1014 static ssize_t pvr2_v4l2_read(struct file *file,
1015 char __user *buff, size_t count, loff_t *ppos)
1017 struct pvr2_v4l2_fh *fh = file->private_data;
1020 if (fh->fw_mode_flag) {
1021 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1025 unsigned int offs = *ppos;
1027 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1028 if (!tbuf) return -ENOMEM;
1032 if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1033 c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1039 if (copy_to_user(buff,tbuf,c2)) {
1054 ret = pvr2_v4l2_iosetup(fh);
1061 ret = pvr2_ioread_read(fh->rhp,buff,count);
1062 if (ret >= 0) break;
1063 if (ret != -EAGAIN) break;
1064 if (file->f_flags & O_NONBLOCK) break;
1065 /* Doing blocking I/O. Wait here. */
1066 ret = wait_event_interruptible(
1068 pvr2_ioread_avail(fh->rhp) >= 0);
1076 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1078 unsigned int mask = 0;
1079 struct pvr2_v4l2_fh *fh = file->private_data;
1082 if (fh->fw_mode_flag) {
1083 mask |= POLLIN | POLLRDNORM;
1088 ret = pvr2_v4l2_iosetup(fh);
1089 if (ret) return POLLERR;
1092 poll_wait(file,&fh->wait_data,wait);
1094 if (pvr2_ioread_avail(fh->rhp) >= 0) {
1095 mask |= POLLIN | POLLRDNORM;
1102 static const struct file_operations vdev_fops = {
1103 .owner = THIS_MODULE,
1104 .open = pvr2_v4l2_open,
1105 .release = pvr2_v4l2_release,
1106 .read = pvr2_v4l2_read,
1107 .ioctl = pvr2_v4l2_ioctl,
1108 .llseek = no_llseek,
1109 .poll = pvr2_v4l2_poll,
1113 #define VID_HARDWARE_PVRUSB2 38 /* FIXME : need a good value */
1115 static struct video_device vdev_template = {
1116 .owner = THIS_MODULE,
1117 .type = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
1118 .type2 = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
1119 | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
1120 | V4L2_CAP_READWRITE),
1121 .hardware = VID_HARDWARE_PVRUSB2,
1126 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1127 struct pvr2_v4l2 *vp,
1136 dip->v4l_type = v4l_type;
1138 case VFL_TYPE_GRABBER:
1139 dip->stream = &vp->channel.mc_head->video_stream;
1140 dip->config = pvr2_config_mpeg;
1141 dip->minor_type = pvr2_v4l_type_video;
1144 err("Failed to set up pvrusb2 v4l video dev"
1145 " due to missing stream instance");
1150 dip->config = pvr2_config_vbi;
1151 dip->minor_type = pvr2_v4l_type_vbi;
1154 case VFL_TYPE_RADIO:
1155 dip->stream = &vp->channel.mc_head->video_stream;
1156 dip->config = pvr2_config_mpeg;
1157 dip->minor_type = pvr2_v4l_type_radio;
1161 /* Bail out (this should be impossible) */
1162 err("Failed to set up pvrusb2 v4l dev"
1163 " due to unrecognized config");
1167 memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1168 dip->devbase.release = pvr2_video_device_release;
1171 unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1172 if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1173 mindevnum = nr_ptr[unit_number];
1175 if ((video_register_device(&dip->devbase,
1176 dip->v4l_type, mindevnum) < 0) &&
1177 (video_register_device(&dip->devbase,
1178 dip->v4l_type, -1) < 0)) {
1179 err("Failed to register pvrusb2 v4l device");
1182 printk(KERN_INFO "pvrusb2: registered device %s%u [%s]\n",
1183 get_v4l_name(dip->v4l_type),dip->devbase.minor & 0x1f,
1184 pvr2_config_get_name(dip->config));
1186 pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1187 dip->minor_type,dip->devbase.minor);
1191 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1193 struct pvr2_v4l2 *vp;
1195 vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1197 vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1198 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1199 if (!(vp->dev_video && vp->dev_radio)) {
1200 kfree(vp->dev_video);
1201 kfree(vp->dev_radio);
1205 pvr2_channel_init(&vp->channel,mnp);
1206 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1208 vp->channel.check_func = pvr2_v4l2_internal_check;
1210 /* register streams */
1211 pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1212 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1218 Stuff for Emacs to see, in order to encourage consistent editing style:
1219 *** Local Variables: ***
1221 *** fill-column: 75 ***
1222 *** tab-width: 8 ***
1223 *** c-basic-offset: 8 ***