V4L/DVB (4515): Fixed module name, since it is, in fact, a decoder.
[linux-2.6] / drivers / media / video / pvrusb2 / pvrusb2-v4l2.c
1 /*
2  *
3  *  $Id$
4  *
5  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
6  *  Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
7  *
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
11  *
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.
16  *
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
20  *
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/version.h>
25 #include "pvrusb2-context.h"
26 #include "pvrusb2-hdw.h"
27 #include "pvrusb2.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-common.h>
33
34 struct pvr2_v4l2_dev;
35 struct pvr2_v4l2_fh;
36 struct pvr2_v4l2;
37
38 /* V4L no longer provide the ability to set / get a private context pointer
39    (i.e. video_get_drvdata / video_set_drvdata), which means we have to
40    concoct our own context locating mechanism.  Supposedly this is intended
41    to simplify driver implementation.  It's not clear to me how that can
42    possibly be true.  Our solution here is to maintain a lookup table of
43    our context instances, indexed by the minor device number of the V4L
44    device.  See pvr2_v4l2_open() for some implications of this approach. */
45 static struct pvr2_v4l2_dev *devices[256];
46 static DEFINE_MUTEX(device_lock);
47
48 struct pvr2_v4l2_dev {
49         struct pvr2_v4l2 *v4lp;
50         struct video_device *vdev;
51         struct pvr2_context_stream *stream;
52         int ctxt_idx;
53         enum pvr2_config config;
54 };
55
56 struct pvr2_v4l2_fh {
57         struct pvr2_channel channel;
58         struct pvr2_v4l2_dev *dev_info;
59         enum v4l2_priority prio;
60         struct pvr2_ioread *rhp;
61         struct file *file;
62         struct pvr2_v4l2 *vhead;
63         struct pvr2_v4l2_fh *vnext;
64         struct pvr2_v4l2_fh *vprev;
65         wait_queue_head_t wait_data;
66         int fw_mode_flag;
67 };
68
69 struct pvr2_v4l2 {
70         struct pvr2_channel channel;
71         struct pvr2_v4l2_fh *vfirst;
72         struct pvr2_v4l2_fh *vlast;
73
74         struct v4l2_prio_state prio;
75
76         /* streams */
77         struct pvr2_v4l2_dev video_dev;
78 };
79
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 minor");
83
84 static struct v4l2_capability pvr_capability ={
85         .driver         = "pvrusb2",
86         .card           = "Hauppauge WinTV pvr-usb2",
87         .bus_info       = "usb",
88         .version        = KERNEL_VERSION(0,8,0),
89         .capabilities   = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
90                            V4L2_CAP_TUNER | V4L2_CAP_AUDIO |
91                            V4L2_CAP_READWRITE),
92         .reserved       = {0,0,0,0}
93 };
94
95 static struct v4l2_tuner pvr_v4l2_tuners[]= {
96         {
97                 .index      = 0,
98                 .name       = "TV Tuner",
99                 .type           = V4L2_TUNER_ANALOG_TV,
100                 .capability     = (V4L2_TUNER_CAP_NORM |
101                                    V4L2_TUNER_CAP_STEREO |
102                                    V4L2_TUNER_CAP_LANG1 |
103                                    V4L2_TUNER_CAP_LANG2),
104                 .rangelow   = 0,
105                 .rangehigh  = 0,
106                 .rxsubchans     = V4L2_TUNER_SUB_STEREO,
107                 .audmode        = V4L2_TUNER_MODE_STEREO,
108                 .signal         = 0,
109                 .afc            = 0,
110                 .reserved       = {0,0,0,0}
111         }
112 };
113
114 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
115         {
116                 .index          = 0,
117                 .type           = V4L2_BUF_TYPE_VIDEO_CAPTURE,
118                 .flags          = V4L2_FMT_FLAG_COMPRESSED,
119                 .description    = "MPEG1/2",
120                 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
121                 // breaks when I do that.
122                 .pixelformat    = 0, // V4L2_PIX_FMT_MPEG,
123                 .reserved       = { 0, 0, 0, 0 }
124         }
125 };
126
127 #define PVR_FORMAT_PIX  0
128 #define PVR_FORMAT_VBI  1
129
130 static struct v4l2_format pvr_format [] = {
131         [PVR_FORMAT_PIX] = {
132                 .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
133                 .fmt    = {
134                         .pix        = {
135                                 .width          = 720,
136                                 .height             = 576,
137                                 // This should really be V4L2_PIX_FMT_MPEG,
138                                 // but xawtv breaks when I do that.
139                                 .pixelformat    = 0, // V4L2_PIX_FMT_MPEG,
140                                 .field          = V4L2_FIELD_INTERLACED,
141                                 .bytesperline   = 0,  // doesn't make sense
142                                                       // here
143                                 //FIXME : Don't know what to put here...
144                                 .sizeimage          = (32*1024),
145                                 .colorspace     = 0, // doesn't make sense here
146                                 .priv           = 0
147                         }
148                 }
149         },
150         [PVR_FORMAT_VBI] = {
151                 .type   = V4L2_BUF_TYPE_VBI_CAPTURE,
152                 .fmt    = {
153                         .vbi        = {
154                                 .sampling_rate = 27000000,
155                                 .offset = 248,
156                                 .samples_per_line = 1443,
157                                 .sample_format = V4L2_PIX_FMT_GREY,
158                                 .start = { 0, 0 },
159                                 .count = { 0, 0 },
160                                 .flags = 0,
161                                 .reserved = { 0, 0 }
162                         }
163                 }
164         }
165 };
166
167 /*
168  * pvr_ioctl()
169  *
170  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
171  *
172  */
173 static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
174                               unsigned int cmd, void *arg)
175 {
176         struct pvr2_v4l2_fh *fh = file->private_data;
177         struct pvr2_v4l2 *vp = fh->vhead;
178         struct pvr2_v4l2_dev *dev_info = fh->dev_info;
179         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
180         int ret = -EINVAL;
181
182         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
183                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
184         }
185
186         if (!pvr2_hdw_dev_ok(hdw)) {
187                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
188                            "ioctl failed - bad or no context");
189                 return -EFAULT;
190         }
191
192         /* check priority */
193         switch (cmd) {
194         case VIDIOC_S_CTRL:
195         case VIDIOC_S_STD:
196         case VIDIOC_S_INPUT:
197         case VIDIOC_S_TUNER:
198         case VIDIOC_S_FREQUENCY:
199                 ret = v4l2_prio_check(&vp->prio, &fh->prio);
200                 if (ret)
201                         return ret;
202         }
203
204         switch (cmd) {
205         case VIDIOC_QUERYCAP:
206         {
207                 struct v4l2_capability *cap = arg;
208
209                 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
210
211                 ret = 0;
212                 break;
213         }
214
215         case VIDIOC_G_PRIORITY:
216         {
217                 enum v4l2_priority *p = arg;
218
219                 *p = v4l2_prio_max(&vp->prio);
220                 ret = 0;
221                 break;
222         }
223
224         case VIDIOC_S_PRIORITY:
225         {
226                 enum v4l2_priority *prio = arg;
227
228                 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
229                 break;
230         }
231
232         case VIDIOC_ENUMSTD:
233         {
234                 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
235                 int idx = vs->index;
236                 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
237                 break;
238         }
239
240         case VIDIOC_G_STD:
241         {
242                 int val = 0;
243                 ret = pvr2_ctrl_get_value(
244                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
245                 *(v4l2_std_id *)arg = val;
246                 break;
247         }
248
249         case VIDIOC_S_STD:
250         {
251                 ret = pvr2_ctrl_set_value(
252                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
253                         *(v4l2_std_id *)arg);
254                 break;
255         }
256
257         case VIDIOC_ENUMINPUT:
258         {
259                 struct pvr2_ctrl *cptr;
260                 struct v4l2_input *vi = (struct v4l2_input *)arg;
261                 struct v4l2_input tmp;
262                 unsigned int cnt;
263
264                 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
265
266                 memset(&tmp,0,sizeof(tmp));
267                 tmp.index = vi->index;
268                 ret = 0;
269                 switch (vi->index) {
270                 case PVR2_CVAL_INPUT_TV:
271                 case PVR2_CVAL_INPUT_RADIO:
272                         tmp.type = V4L2_INPUT_TYPE_TUNER;
273                         break;
274                 case PVR2_CVAL_INPUT_SVIDEO:
275                 case PVR2_CVAL_INPUT_COMPOSITE:
276                         tmp.type = V4L2_INPUT_TYPE_CAMERA;
277                         break;
278                 default:
279                         ret = -EINVAL;
280                         break;
281                 }
282                 if (ret < 0) break;
283
284                 cnt = 0;
285                 pvr2_ctrl_get_valname(cptr,vi->index,
286                                       tmp.name,sizeof(tmp.name)-1,&cnt);
287                 tmp.name[cnt] = 0;
288
289                 /* Don't bother with audioset, since this driver currently
290                    always switches the audio whenever the video is
291                    switched. */
292
293                 /* Handling std is a tougher problem.  It doesn't make
294                    sense in cases where a device might be multi-standard.
295                    We could just copy out the current value for the
296                    standard, but it can change over time.  For now just
297                    leave it zero. */
298
299                 memcpy(vi, &tmp, sizeof(tmp));
300
301                 ret = 0;
302                 break;
303         }
304
305         case VIDIOC_G_INPUT:
306         {
307                 struct pvr2_ctrl *cptr;
308                 struct v4l2_input *vi = (struct v4l2_input *)arg;
309                 int val;
310                 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
311                 val = 0;
312                 ret = pvr2_ctrl_get_value(cptr,&val);
313                 vi->index = val;
314                 break;
315         }
316
317         case VIDIOC_S_INPUT:
318         {
319                 struct v4l2_input *vi = (struct v4l2_input *)arg;
320                 ret = pvr2_ctrl_set_value(
321                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
322                         vi->index);
323                 break;
324         }
325
326         case VIDIOC_ENUMAUDIO:
327         {
328                 ret = -EINVAL;
329                 break;
330         }
331
332         case VIDIOC_G_AUDIO:
333         {
334                 ret = -EINVAL;
335                 break;
336         }
337
338         case VIDIOC_S_AUDIO:
339         {
340                 ret = -EINVAL;
341                 break;
342         }
343         case VIDIOC_G_TUNER:
344         {
345                 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
346                 unsigned int status_mask;
347                 int val;
348                 if (vt->index !=0) break;
349
350                 status_mask = pvr2_hdw_get_signal_status(hdw);
351
352                 memcpy(vt, &pvr_v4l2_tuners[vt->index],
353                        sizeof(struct v4l2_tuner));
354
355                 vt->signal = 0;
356                 if (status_mask & PVR2_SIGNAL_OK) {
357                         if (status_mask & PVR2_SIGNAL_STEREO) {
358                                 vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
359                         } else {
360                                 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
361                         }
362                         if (status_mask & PVR2_SIGNAL_SAP) {
363                                 vt->rxsubchans |= (V4L2_TUNER_SUB_LANG1 |
364                                                    V4L2_TUNER_SUB_LANG2);
365                         }
366                         vt->signal = 65535;
367                 }
368
369                 val = 0;
370                 ret = pvr2_ctrl_get_value(
371                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
372                         &val);
373                 vt->audmode = val;
374                 break;
375         }
376
377         case VIDIOC_S_TUNER:
378         {
379                 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
380
381                 if (vt->index != 0)
382                         break;
383
384                 ret = pvr2_ctrl_set_value(
385                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
386                         vt->audmode);
387         }
388
389         case VIDIOC_S_FREQUENCY:
390         {
391                 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
392                 ret = pvr2_ctrl_set_value(
393                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
394                         vf->frequency * 62500);
395                 break;
396         }
397
398         case VIDIOC_G_FREQUENCY:
399         {
400                 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
401                 int val = 0;
402                 ret = pvr2_ctrl_get_value(
403                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
404                         &val);
405                 val /= 62500;
406                 vf->frequency = val;
407                 break;
408         }
409
410         case VIDIOC_ENUM_FMT:
411         {
412                 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
413
414                 /* Only one format is supported : mpeg.*/
415                 if (fd->index != 0)
416                         break;
417
418                 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
419                 ret = 0;
420                 break;
421         }
422
423         case VIDIOC_G_FMT:
424         {
425                 struct v4l2_format *vf = (struct v4l2_format *)arg;
426                 int val;
427                 switch(vf->type) {
428                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
429                         memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
430                                sizeof(struct v4l2_format));
431                         val = 0;
432                         pvr2_ctrl_get_value(
433                                 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
434                                 &val);
435                         vf->fmt.pix.width = val;
436                         val = 0;
437                         pvr2_ctrl_get_value(
438                                 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
439                                 &val);
440                         vf->fmt.pix.height = val;
441                         ret = 0;
442                         break;
443                 case V4L2_BUF_TYPE_VBI_CAPTURE:
444                         // ????? Still need to figure out to do VBI correctly
445                         ret = -EINVAL;
446                         break;
447                 default:
448                         ret = -EINVAL;
449                         break;
450                 }
451                 break;
452         }
453
454         case VIDIOC_TRY_FMT:
455         case VIDIOC_S_FMT:
456         {
457                 struct v4l2_format *vf = (struct v4l2_format *)arg;
458
459                 ret = 0;
460                 switch(vf->type) {
461                 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
462                         int lmin,lmax;
463                         struct pvr2_ctrl *hcp,*vcp;
464                         int h = vf->fmt.pix.height;
465                         int w = vf->fmt.pix.width;
466                         hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
467                         vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
468
469                         lmin = pvr2_ctrl_get_min(hcp);
470                         lmax = pvr2_ctrl_get_max(hcp);
471                         if (h < lmin) {
472                                 h = lmin;
473                         } else if (h > lmax) {
474                                 h = lmax;
475                         }
476                         lmin = pvr2_ctrl_get_min(vcp);
477                         lmax = pvr2_ctrl_get_max(vcp);
478                         if (w < lmin) {
479                                 w = lmin;
480                         } else if (w > lmax) {
481                                 w = lmax;
482                         }
483
484                         memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
485                                sizeof(struct v4l2_format));
486                         vf->fmt.pix.width = w;
487                         vf->fmt.pix.height = h;
488
489                         if (cmd == VIDIOC_S_FMT) {
490                                 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
491                                 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
492                         }
493                 } break;
494                 case V4L2_BUF_TYPE_VBI_CAPTURE:
495                         // ????? Still need to figure out to do VBI correctly
496                         ret = -EINVAL;
497                         break;
498                 default:
499                         ret = -EINVAL;
500                         break;
501                 }
502                 break;
503         }
504
505         case VIDIOC_STREAMON:
506         {
507                 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
508                 if (ret < 0) return ret;
509                 ret = pvr2_hdw_set_streaming(hdw,!0);
510                 break;
511         }
512
513         case VIDIOC_STREAMOFF:
514         {
515                 ret = pvr2_hdw_set_streaming(hdw,0);
516                 break;
517         }
518
519         case VIDIOC_QUERYCTRL:
520         {
521                 struct pvr2_ctrl *cptr;
522                 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
523                 ret = 0;
524                 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
525                         cptr = pvr2_hdw_get_ctrl_nextv4l(
526                                 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
527                         if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
528                 } else {
529                         cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
530                 }
531                 if (!cptr) {
532                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
533                                    "QUERYCTRL id=0x%x not implemented here",
534                                    vc->id);
535                         ret = -EINVAL;
536                         break;
537                 }
538
539                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
540                            "QUERYCTRL id=0x%x mapping name=%s (%s)",
541                            vc->id,pvr2_ctrl_get_name(cptr),
542                            pvr2_ctrl_get_desc(cptr));
543                 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
544                 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
545                 vc->default_value = pvr2_ctrl_get_def(cptr);
546                 switch (pvr2_ctrl_get_type(cptr)) {
547                 case pvr2_ctl_enum:
548                         vc->type = V4L2_CTRL_TYPE_MENU;
549                         vc->minimum = 0;
550                         vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
551                         vc->step = 1;
552                         break;
553                 case pvr2_ctl_bool:
554                         vc->type = V4L2_CTRL_TYPE_BOOLEAN;
555                         vc->minimum = 0;
556                         vc->maximum = 1;
557                         vc->step = 1;
558                         break;
559                 case pvr2_ctl_int:
560                         vc->type = V4L2_CTRL_TYPE_INTEGER;
561                         vc->minimum = pvr2_ctrl_get_min(cptr);
562                         vc->maximum = pvr2_ctrl_get_max(cptr);
563                         vc->step = 1;
564                         break;
565                 default:
566                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
567                                    "QUERYCTRL id=0x%x name=%s not mappable",
568                                    vc->id,pvr2_ctrl_get_name(cptr));
569                         ret = -EINVAL;
570                         break;
571                 }
572                 break;
573         }
574
575         case VIDIOC_QUERYMENU:
576         {
577                 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
578                 unsigned int cnt = 0;
579                 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
580                                             vm->index,
581                                             vm->name,sizeof(vm->name)-1,
582                                             &cnt);
583                 vm->name[cnt] = 0;
584                 break;
585         }
586
587         case VIDIOC_G_CTRL:
588         {
589                 struct v4l2_control *vc = (struct v4l2_control *)arg;
590                 int val = 0;
591                 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
592                                           &val);
593                 vc->value = val;
594                 break;
595         }
596
597         case VIDIOC_S_CTRL:
598         {
599                 struct v4l2_control *vc = (struct v4l2_control *)arg;
600                 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
601                                           vc->value);
602                 break;
603         }
604
605         case VIDIOC_G_EXT_CTRLS:
606         {
607                 struct v4l2_ext_controls *ctls =
608                         (struct v4l2_ext_controls *)arg;
609                 struct v4l2_ext_control *ctrl;
610                 unsigned int idx;
611                 int val;
612                 for (idx = 0; idx < ctls->count; idx++) {
613                         ctrl = ctls->controls + idx;
614                         ret = pvr2_ctrl_get_value(
615                                 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
616                         if (ret) {
617                                 ctls->error_idx = idx;
618                                 break;
619                         }
620                         /* Ensure that if read as a 64 bit value, the user
621                            will still get a hopefully sane value */
622                         ctrl->value64 = 0;
623                         ctrl->value = val;
624                 }
625                 break;
626         }
627
628         case VIDIOC_S_EXT_CTRLS:
629         {
630                 struct v4l2_ext_controls *ctls =
631                         (struct v4l2_ext_controls *)arg;
632                 struct v4l2_ext_control *ctrl;
633                 unsigned int idx;
634                 for (idx = 0; idx < ctls->count; idx++) {
635                         ctrl = ctls->controls + idx;
636                         ret = pvr2_ctrl_set_value(
637                                 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
638                                 ctrl->value);
639                         if (ret) {
640                                 ctls->error_idx = idx;
641                                 break;
642                         }
643                 }
644                 break;
645         }
646
647         case VIDIOC_TRY_EXT_CTRLS:
648         {
649                 struct v4l2_ext_controls *ctls =
650                         (struct v4l2_ext_controls *)arg;
651                 struct v4l2_ext_control *ctrl;
652                 struct pvr2_ctrl *pctl;
653                 unsigned int idx;
654                 /* For the moment just validate that the requested control
655                    actually exists. */
656                 for (idx = 0; idx < ctls->count; idx++) {
657                         ctrl = ctls->controls + idx;
658                         pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
659                         if (!pctl) {
660                                 ret = -EINVAL;
661                                 ctls->error_idx = idx;
662                                 break;
663                         }
664                 }
665                 break;
666         }
667
668         case VIDIOC_LOG_STATUS:
669         {
670                 pvr2_hdw_trigger_module_log(hdw);
671                 ret = 0;
672                 break;
673         }
674
675         default :
676                 ret = v4l_compat_translate_ioctl(inode,file,cmd,
677                                                  arg,pvr2_v4l2_do_ioctl);
678         }
679
680         pvr2_hdw_commit_ctl(hdw);
681
682         if (ret < 0) {
683                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
684                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
685                                    "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
686                 } else {
687                         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
688                                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
689                                            "pvr2_v4l2_do_ioctl failure, ret=%d"
690                                            " command was:",ret);
691                                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
692                                                 cmd);
693                         }
694                 }
695         } else {
696                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
697                            "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
698                            ret,ret);
699         }
700         return ret;
701 }
702
703
704 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
705 {
706         printk(KERN_INFO "pvrusb2: unregistering device video%d [%s]\n",
707                dip->vdev->minor,pvr2_config_get_name(dip->config));
708         if (dip->ctxt_idx >= 0) {
709                 mutex_lock(&device_lock);
710                 devices[dip->ctxt_idx] = NULL;
711                 dip->ctxt_idx = -1;
712                 mutex_unlock(&device_lock);
713         }
714         video_unregister_device(dip->vdev);
715 }
716
717
718 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
719 {
720         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,-1);
721         pvr2_v4l2_dev_destroy(&vp->video_dev);
722
723         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
724         pvr2_channel_done(&vp->channel);
725         kfree(vp);
726 }
727
728
729 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
730 {
731         struct pvr2_v4l2 *vp;
732         vp = container_of(chp,struct pvr2_v4l2,channel);
733         if (!vp->channel.mc_head->disconnect_flag) return;
734         if (vp->vfirst) return;
735         pvr2_v4l2_destroy_no_lock(vp);
736 }
737
738
739 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
740                            unsigned int cmd, unsigned long arg)
741 {
742
743 /* Temporary hack : use ivtv api until a v4l2 one is available. */
744 #define IVTV_IOC_G_CODEC        0xFFEE7703
745 #define IVTV_IOC_S_CODEC        0xFFEE7704
746         if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
747         return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
748 }
749
750
751 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
752 {
753         struct pvr2_v4l2_fh *fhp = file->private_data;
754         struct pvr2_v4l2 *vp = fhp->vhead;
755         struct pvr2_context *mp = fhp->vhead->channel.mc_head;
756
757         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
758
759         if (fhp->rhp) {
760                 struct pvr2_stream *sp;
761                 struct pvr2_hdw *hdw;
762                 hdw = fhp->channel.mc_head->hdw;
763                 pvr2_hdw_set_streaming(hdw,0);
764                 sp = pvr2_ioread_get_stream(fhp->rhp);
765                 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
766                 pvr2_ioread_destroy(fhp->rhp);
767                 fhp->rhp = NULL;
768         }
769         v4l2_prio_close(&vp->prio, &fhp->prio);
770         file->private_data = NULL;
771
772         pvr2_context_enter(mp); do {
773                 if (fhp->vnext) {
774                         fhp->vnext->vprev = fhp->vprev;
775                 } else {
776                         vp->vlast = fhp->vprev;
777                 }
778                 if (fhp->vprev) {
779                         fhp->vprev->vnext = fhp->vnext;
780                 } else {
781                         vp->vfirst = fhp->vnext;
782                 }
783                 fhp->vnext = NULL;
784                 fhp->vprev = NULL;
785                 fhp->vhead = NULL;
786                 pvr2_channel_done(&fhp->channel);
787                 pvr2_trace(PVR2_TRACE_STRUCT,
788                            "Destroying pvr_v4l2_fh id=%p",fhp);
789                 kfree(fhp);
790                 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
791                         pvr2_v4l2_destroy_no_lock(vp);
792                 }
793         } while (0); pvr2_context_exit(mp);
794         return 0;
795 }
796
797
798 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
799 {
800         struct pvr2_v4l2_dev *dip = NULL; /* Our own context pointer */
801         struct pvr2_v4l2_fh *fhp;
802         struct pvr2_v4l2 *vp;
803         struct pvr2_hdw *hdw;
804
805         mutex_lock(&device_lock);
806         /* MCI 7-Jun-2006 Even though we're just doing what amounts to an
807            atomic read of the device mapping array here, we still need the
808            mutex.  The problem is that there is a tiny race possible when
809            we register the device.  We can't update the device mapping
810            array until after the device has been registered, owing to the
811            fact that we can't know the minor device number until after the
812            registration succeeds.  And if another thread tries to open the
813            device in the window of time after registration but before the
814            map is updated, then it will get back an erroneous null pointer
815            and the open will result in a spurious failure.  The only way to
816            prevent that is to (a) be inside the mutex here before we access
817            the array, and (b) cover the entire registration process later
818            on with this same mutex.  Thus if we get inside the mutex here,
819            then we can be assured that the registration process actually
820            completed correctly.  This is an unhappy complication from the
821            use of global data in a driver that lives in a preemptible
822            environment.  It sure would be nice if the video device itself
823            had a means for storing and retrieving a local context pointer.
824            Oh wait.  It did.  But now it's gone.  Silly me. */
825         {
826                 unsigned int midx = iminor(file->f_dentry->d_inode);
827                 if (midx < sizeof(devices)/sizeof(devices[0])) {
828                         dip = devices[midx];
829                 }
830         }
831         mutex_unlock(&device_lock);
832
833         if (!dip) return -ENODEV; /* Should be impossible but I'm paranoid */
834
835         vp = dip->v4lp;
836         hdw = vp->channel.hdw;
837
838         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
839
840         if (!pvr2_hdw_dev_ok(hdw)) {
841                 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
842                            "pvr2_v4l2_open: hardware not ready");
843                 return -EIO;
844         }
845
846         fhp = kmalloc(sizeof(*fhp),GFP_KERNEL);
847         if (!fhp) {
848                 return -ENOMEM;
849         }
850         memset(fhp,0,sizeof(*fhp));
851
852         init_waitqueue_head(&fhp->wait_data);
853         fhp->dev_info = dip;
854
855         pvr2_context_enter(vp->channel.mc_head); do {
856                 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
857                 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
858                 fhp->vnext = NULL;
859                 fhp->vprev = vp->vlast;
860                 if (vp->vlast) {
861                         vp->vlast->vnext = fhp;
862                 } else {
863                         vp->vfirst = fhp;
864                 }
865                 vp->vlast = fhp;
866                 fhp->vhead = vp;
867         } while (0); pvr2_context_exit(vp->channel.mc_head);
868
869         fhp->file = file;
870         file->private_data = fhp;
871         v4l2_prio_open(&vp->prio,&fhp->prio);
872
873         fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
874
875         return 0;
876 }
877
878
879 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
880 {
881         wake_up(&fhp->wait_data);
882 }
883
884 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
885 {
886         int ret;
887         struct pvr2_stream *sp;
888         struct pvr2_hdw *hdw;
889         if (fh->rhp) return 0;
890
891         /* First read() attempt.  Try to claim the stream and start
892            it... */
893         if ((ret = pvr2_channel_claim_stream(&fh->channel,
894                                              fh->dev_info->stream)) != 0) {
895                 /* Someone else must already have it */
896                 return ret;
897         }
898
899         fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
900         if (!fh->rhp) {
901                 pvr2_channel_claim_stream(&fh->channel,NULL);
902                 return -ENOMEM;
903         }
904
905         hdw = fh->channel.mc_head->hdw;
906         sp = fh->dev_info->stream->stream;
907         pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
908         pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
909         pvr2_hdw_set_streaming(hdw,!0);
910         ret = pvr2_ioread_set_enabled(fh->rhp,!0);
911
912         return ret;
913 }
914
915
916 static ssize_t pvr2_v4l2_read(struct file *file,
917                               char __user *buff, size_t count, loff_t *ppos)
918 {
919         struct pvr2_v4l2_fh *fh = file->private_data;
920         int ret;
921
922         if (fh->fw_mode_flag) {
923                 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
924                 char *tbuf;
925                 int c1,c2;
926                 int tcnt = 0;
927                 unsigned int offs = *ppos;
928
929                 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
930                 if (!tbuf) return -ENOMEM;
931
932                 while (count) {
933                         c1 = count;
934                         if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
935                         c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
936                         if (c2 < 0) {
937                                 tcnt = c2;
938                                 break;
939                         }
940                         if (!c2) break;
941                         if (copy_to_user(buff,tbuf,c2)) {
942                                 tcnt = -EFAULT;
943                                 break;
944                         }
945                         offs += c2;
946                         tcnt += c2;
947                         buff += c2;
948                         count -= c2;
949                         *ppos += c2;
950                 }
951                 kfree(tbuf);
952                 return tcnt;
953         }
954
955         if (!fh->rhp) {
956                 ret = pvr2_v4l2_iosetup(fh);
957                 if (ret) {
958                         return ret;
959                 }
960         }
961
962         for (;;) {
963                 ret = pvr2_ioread_read(fh->rhp,buff,count);
964                 if (ret >= 0) break;
965                 if (ret != -EAGAIN) break;
966                 if (file->f_flags & O_NONBLOCK) break;
967                 /* Doing blocking I/O.  Wait here. */
968                 ret = wait_event_interruptible(
969                         fh->wait_data,
970                         pvr2_ioread_avail(fh->rhp) >= 0);
971                 if (ret < 0) break;
972         }
973
974         return ret;
975 }
976
977
978 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
979 {
980         unsigned int mask = 0;
981         struct pvr2_v4l2_fh *fh = file->private_data;
982         int ret;
983
984         if (fh->fw_mode_flag) {
985                 mask |= POLLIN | POLLRDNORM;
986                 return mask;
987         }
988
989         if (!fh->rhp) {
990                 ret = pvr2_v4l2_iosetup(fh);
991                 if (ret) return POLLERR;
992         }
993
994         poll_wait(file,&fh->wait_data,wait);
995
996         if (pvr2_ioread_avail(fh->rhp) >= 0) {
997                 mask |= POLLIN | POLLRDNORM;
998         }
999
1000         return mask;
1001 }
1002
1003
1004 static struct file_operations vdev_fops = {
1005         .owner      = THIS_MODULE,
1006         .open       = pvr2_v4l2_open,
1007         .release    = pvr2_v4l2_release,
1008         .read       = pvr2_v4l2_read,
1009         .ioctl      = pvr2_v4l2_ioctl,
1010         .llseek     = no_llseek,
1011         .poll       = pvr2_v4l2_poll,
1012 };
1013
1014
1015 #define VID_HARDWARE_PVRUSB2    38  /* FIXME : need a good value */
1016
1017 static struct video_device vdev_template = {
1018         .owner      = THIS_MODULE,
1019         .type       = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
1020         .type2      = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
1021                        | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
1022                        | V4L2_CAP_READWRITE),
1023         .hardware   = VID_HARDWARE_PVRUSB2,
1024         .fops       = &vdev_fops,
1025 };
1026
1027
1028 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1029                                struct pvr2_v4l2 *vp,
1030                                enum pvr2_config cfg)
1031 {
1032         int mindevnum;
1033         int unit_number;
1034         int v4l_type;
1035         dip->v4lp = vp;
1036         dip->config = cfg;
1037
1038
1039         switch (cfg) {
1040         case pvr2_config_mpeg:
1041                 v4l_type = VFL_TYPE_GRABBER;
1042                 dip->stream = &vp->channel.mc_head->video_stream;
1043                 break;
1044         case pvr2_config_vbi:
1045                 v4l_type = VFL_TYPE_VBI;
1046                 break;
1047         case pvr2_config_radio:
1048                 v4l_type = VFL_TYPE_RADIO;
1049                 break;
1050         default:
1051                 /* Bail out (this should be impossible) */
1052                 err("Failed to set up pvrusb2 v4l dev"
1053                     " due to unrecognized config");
1054                 return;
1055         }
1056
1057         if (!dip->stream) {
1058                 err("Failed to set up pvrusb2 v4l dev"
1059                     " due to missing stream instance");
1060                 return;
1061         }
1062
1063         dip->vdev = video_device_alloc();
1064         if (!dip->vdev) {
1065                 err("Alloc of pvrusb2 v4l video device failed");
1066                 return;
1067         }
1068
1069         memcpy(dip->vdev,&vdev_template,sizeof(vdev_template));
1070         dip->vdev->release = video_device_release;
1071         mutex_lock(&device_lock);
1072
1073         mindevnum = -1;
1074         unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1075         if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1076                 mindevnum = video_nr[unit_number];
1077         }
1078         if ((video_register_device(dip->vdev, v4l_type, mindevnum) < 0) &&
1079             (video_register_device(dip->vdev, v4l_type, -1) < 0)) {
1080                 err("Failed to register pvrusb2 v4l video device");
1081         } else {
1082                 printk(KERN_INFO "pvrusb2: registered device video%d [%s]\n",
1083                        dip->vdev->minor,pvr2_config_get_name(dip->config));
1084         }
1085
1086         if ((dip->vdev->minor < sizeof(devices)/sizeof(devices[0])) &&
1087             (devices[dip->vdev->minor] == NULL)) {
1088                 dip->ctxt_idx = dip->vdev->minor;
1089                 devices[dip->ctxt_idx] = dip;
1090         }
1091         mutex_unlock(&device_lock);
1092
1093         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1094                                         dip->vdev->minor);
1095 }
1096
1097
1098 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1099 {
1100         struct pvr2_v4l2 *vp;
1101
1102         vp = kmalloc(sizeof(*vp),GFP_KERNEL);
1103         if (!vp) return vp;
1104         memset(vp,0,sizeof(*vp));
1105         vp->video_dev.ctxt_idx = -1;
1106         pvr2_channel_init(&vp->channel,mnp);
1107         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1108
1109         vp->channel.check_func = pvr2_v4l2_internal_check;
1110
1111         /* register streams */
1112         pvr2_v4l2_dev_init(&vp->video_dev,vp,pvr2_config_mpeg);
1113
1114
1115         return vp;
1116 }
1117
1118 /*
1119   Stuff for Emacs to see, in order to encourage consistent editing style:
1120   *** Local Variables: ***
1121   *** mode: c ***
1122   *** fill-column: 75 ***
1123   *** tab-width: 8 ***
1124   *** c-basic-offset: 8 ***
1125   *** End: ***
1126   */