drivers/media/video/pvrusb2/pvrusb2-v4l2.c

   1 /*
   2  *
   3  *
   4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   5  *  Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
   6  *
   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
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/version.h>
  24 #include "pvrusb2-context.h"
  25 #include "pvrusb2-hdw.h"
  26 #include "pvrusb2.h"
  27 #include "pvrusb2-debug.h"
  28 #include "pvrusb2-v4l2.h"
  29 #include "pvrusb2-ioread.h"
  30 #include <linux/videodev2.h>
  31 #include <media/v4l2-dev.h>
  32 #include <media/v4l2-common.h>
  33 #include <media/v4l2-ioctl.h>
  34
  35 struct pvr2_v4l2_dev;
  36 struct pvr2_v4l2_fh;
  37 struct pvr2_v4l2;
  38
  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 */
  47 };
  48
  49 struct pvr2_v4l2_fh {
  50         struct pvr2_channel channel;
  51         struct pvr2_v4l2_dev *dev_info;
  52         enum v4l2_priority prio;
  53         struct pvr2_ioread *rhp;
  54         struct file *file;
  55         struct pvr2_v4l2 *vhead;
  56         struct pvr2_v4l2_fh *vnext;
  57         struct pvr2_v4l2_fh *vprev;
  58         wait_queue_head_t wait_data;
  59         int fw_mode_flag;
  60         /* Map contiguous ordinal value to input id */
  61         unsigned char *input_map;
  62         unsigned int input_cnt;
  63 };
  64
  65 struct pvr2_v4l2 {
  66         struct pvr2_channel channel;
  67         struct pvr2_v4l2_fh *vfirst;
  68         struct pvr2_v4l2_fh *vlast;
  69
  70         struct v4l2_prio_state prio;
  71
  72         /* streams - Note that these must be separately, individually,
  73          * allocated pointers.  This is because the v4l core is going to
  74          * manage their deletion - separately, individually...  */
  75         struct pvr2_v4l2_dev *dev_video;
  76         struct pvr2_v4l2_dev *dev_radio;
  77 };
  78
  79 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
  80 module_param_array(video_nr, int, NULL, 0444);
  81 MODULE_PARM_DESC(video_nr, "Offset for device's video dev minor");
  82 static int radio_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
  83 module_param_array(radio_nr, int, NULL, 0444);
  84 MODULE_PARM_DESC(radio_nr, "Offset for device's radio dev minor");
  85 static int vbi_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
  86 module_param_array(vbi_nr, int, NULL, 0444);
  87 MODULE_PARM_DESC(vbi_nr, "Offset for device's vbi dev minor");
  88
  89 static struct v4l2_capability pvr_capability ={
  90         .driver         = "pvrusb2",
  91         .card           = "Hauppauge WinTV pvr-usb2",
  92         .bus_info       = "usb",
  93         .version        = KERNEL_VERSION(0,8,0),
  94         .capabilities   = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
  95                            V4L2_CAP_TUNER | V4L2_CAP_AUDIO | V4L2_CAP_RADIO |
  96                            V4L2_CAP_READWRITE),
  97         .reserved       = {0,0,0,0}
  98 };
  99
 100 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
 101         {
 102                 .index          = 0,
 103                 .type           = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 104                 .flags          = V4L2_FMT_FLAG_COMPRESSED,
 105                 .description    = "MPEG1/2",
 106                 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
 107                 // breaks when I do that.
 108                 .pixelformat    = 0, // V4L2_PIX_FMT_MPEG,
 109                 .reserved       = { 0, 0, 0, 0 }
 110         }
 111 };
 112
 113 #define PVR_FORMAT_PIX  0
 114 #define PVR_FORMAT_VBI  1
 115
 116 static struct v4l2_format pvr_format [] = {
 117         [PVR_FORMAT_PIX] = {
 118                 .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 119                 .fmt    = {
 120                         .pix        = {
 121                                 .width          = 720,
 122                                 .height             = 576,
 123                                 // This should really be V4L2_PIX_FMT_MPEG,
 124                                 // but xawtv breaks when I do that.
 125                                 .pixelformat    = 0, // V4L2_PIX_FMT_MPEG,
 126                                 .field          = V4L2_FIELD_INTERLACED,
 127                                 .bytesperline   = 0,  // doesn't make sense
 128                                                       // here
 129                                 //FIXME : Don't know what to put here...
 130                                 .sizeimage          = (32*1024),
 131                                 .colorspace     = 0, // doesn't make sense here
 132                                 .priv           = 0
 133                         }
 134                 }
 135         },
 136         [PVR_FORMAT_VBI] = {
 137                 .type   = V4L2_BUF_TYPE_VBI_CAPTURE,
 138                 .fmt    = {
 139                         .vbi        = {
 140                                 .sampling_rate = 27000000,
 141                                 .offset = 248,
 142                                 .samples_per_line = 1443,
 143                                 .sample_format = V4L2_PIX_FMT_GREY,
 144                                 .start = { 0, 0 },
 145                                 .count = { 0, 0 },
 146                                 .flags = 0,
 147                                 .reserved = { 0, 0 }
 148                         }
 149                 }
 150         }
 151 };
 152
 153
 154 static const char *get_v4l_name(int v4l_type)
 155 {
 156         switch (v4l_type) {
 157         case VFL_TYPE_GRABBER: return "video";
 158         case VFL_TYPE_RADIO: return "radio";
 159         case VFL_TYPE_VBI: return "vbi";
 160         default: return "?";
 161         }
 162 }
 163
 164
 165 /*
 166  * pvr_ioctl()
 167  *
 168  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
 169  *
 170  */
 171 static int __pvr2_v4l2_do_ioctl(struct file *file,
 172                               unsigned int cmd, void *arg)
 173 {
 174         struct pvr2_v4l2_fh *fh = file->private_data;
 175         struct pvr2_v4l2 *vp = fh->vhead;
 176         struct pvr2_v4l2_dev *dev_info = fh->dev_info;
 177         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 178         int ret = -EINVAL;
 179
 180         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 181                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
 182         }
 183
 184         if (!pvr2_hdw_dev_ok(hdw)) {
 185                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 186                            "ioctl failed - bad or no context");
 187                 return -EFAULT;
 188         }
 189
 190         /* check priority */
 191         switch (cmd) {
 192         case VIDIOC_S_CTRL:
 193         case VIDIOC_S_STD:
 194         case VIDIOC_S_INPUT:
 195         case VIDIOC_S_TUNER:
 196         case VIDIOC_S_FREQUENCY:
 197                 ret = v4l2_prio_check(&vp->prio, &fh->prio);
 198                 if (ret)
 199                         return ret;
 200         }
 201
 202         switch (cmd) {
 203         case VIDIOC_QUERYCAP:
 204         {
 205                 struct v4l2_capability *cap = arg;
 206
 207                 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
 208                 strlcpy(cap->bus_info,pvr2_hdw_get_bus_info(hdw),
 209                         sizeof(cap->bus_info));
 210                 strlcpy(cap->card,pvr2_hdw_get_desc(hdw),sizeof(cap->card));
 211
 212                 ret = 0;
 213                 break;
 214         }
 215
 216         case VIDIOC_G_PRIORITY:
 217         {
 218                 enum v4l2_priority *p = arg;
 219
 220                 *p = v4l2_prio_max(&vp->prio);
 221                 ret = 0;
 222                 break;
 223         }
 224
 225         case VIDIOC_S_PRIORITY:
 226         {
 227                 enum v4l2_priority *prio = arg;
 228
 229                 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
 230                 break;
 231         }
 232
 233         case VIDIOC_ENUMSTD:
 234         {
 235                 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
 236                 int idx = vs->index;
 237                 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
 238                 break;
 239         }
 240
 241         case VIDIOC_G_STD:
 242         {
 243                 int val = 0;
 244                 ret = pvr2_ctrl_get_value(
 245                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
 246                 *(v4l2_std_id *)arg = val;
 247                 break;
 248         }
 249
 250         case VIDIOC_S_STD:
 251         {
 252                 ret = pvr2_ctrl_set_value(
 253                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
 254                         *(v4l2_std_id *)arg);
 255                 break;
 256         }
 257
 258         case VIDIOC_ENUMINPUT:
 259         {
 260                 struct pvr2_ctrl *cptr;
 261                 struct v4l2_input *vi = (struct v4l2_input *)arg;
 262                 struct v4l2_input tmp;
 263                 unsigned int cnt;
 264                 int val;
 265
 266                 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
 267
 268                 memset(&tmp,0,sizeof(tmp));
 269                 tmp.index = vi->index;
 270                 ret = 0;
 271                 if ((vi->index < 0) || (vi->index >= fh->input_cnt)) {
 272                         ret = -EINVAL;
 273                         break;
 274                 }
 275                 val = fh->input_map[vi->index];
 276                 switch (val) {
 277                 case PVR2_CVAL_INPUT_TV:
 278                 case PVR2_CVAL_INPUT_DTV:
 279                 case PVR2_CVAL_INPUT_RADIO:
 280                         tmp.type = V4L2_INPUT_TYPE_TUNER;
 281                         break;
 282                 case PVR2_CVAL_INPUT_SVIDEO:
 283                 case PVR2_CVAL_INPUT_COMPOSITE:
 284                         tmp.type = V4L2_INPUT_TYPE_CAMERA;
 285                         break;
 286                 default:
 287                         ret = -EINVAL;
 288                         break;
 289                 }
 290                 if (ret < 0) break;
 291
 292                 cnt = 0;
 293                 pvr2_ctrl_get_valname(cptr,val,
 294                                       tmp.name,sizeof(tmp.name)-1,&cnt);
 295                 tmp.name[cnt] = 0;
 296
 297                 /* Don't bother with audioset, since this driver currently
 298                    always switches the audio whenever the video is
 299                    switched. */
 300
 301                 /* Handling std is a tougher problem.  It doesn't make
 302                    sense in cases where a device might be multi-standard.
 303                    We could just copy out the current value for the
 304                    standard, but it can change over time.  For now just
 305                    leave it zero. */
 306
 307                 memcpy(vi, &tmp, sizeof(tmp));
 308
 309                 ret = 0;
 310                 break;
 311         }
 312
 313         case VIDIOC_G_INPUT:
 314         {
 315                 unsigned int idx;
 316                 struct pvr2_ctrl *cptr;
 317                 struct v4l2_input *vi = (struct v4l2_input *)arg;
 318                 int val;
 319                 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
 320                 val = 0;
 321                 ret = pvr2_ctrl_get_value(cptr,&val);
 322                 vi->index = 0;
 323                 for (idx = 0; idx < fh->input_cnt; idx++) {
 324                         if (fh->input_map[idx] == val) {
 325                                 vi->index = idx;
 326                                 break;
 327                         }
 328                 }
 329                 break;
 330         }
 331
 332         case VIDIOC_S_INPUT:
 333         {
 334                 struct v4l2_input *vi = (struct v4l2_input *)arg;
 335                 if ((vi->index < 0) || (vi->index >= fh->input_cnt)) {
 336                         ret = -ERANGE;
 337                         break;
 338                 }
 339                 ret = pvr2_ctrl_set_value(
 340                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
 341                         fh->input_map[vi->index]);
 342                 break;
 343         }
 344
 345         case VIDIOC_ENUMAUDIO:
 346         {
 347                 /* pkt: FIXME: We are returning one "fake" input here
 348                    which could very well be called "whatever_we_like".
 349                    This is for apps that want to see an audio input
 350                    just to feel comfortable, as well as to test if
 351                    it can do stereo or sth. There is actually no guarantee
 352                    that the actual audio input cannot change behind the app's
 353                    back, but most applications should not mind that either.
 354
 355                    Hopefully, mplayer people will work with us on this (this
 356                    whole mess is to support mplayer pvr://), or Hans will come
 357                    up with a more standard way to say "we have inputs but we
 358                    don 't want you to change them independent of video" which
 359                    will sort this mess.
 360                  */
 361                 struct v4l2_audio *vin = arg;
 362                 ret = -EINVAL;
 363                 if (vin->index > 0) break;
 364                 strncpy(vin->name, "PVRUSB2 Audio",14);
 365                 vin->capability = V4L2_AUDCAP_STEREO;
 366                 ret = 0;
 367                 break;
 368                 break;
 369         }
 370
 371         case VIDIOC_G_AUDIO:
 372         {
 373                 /* pkt: FIXME: see above comment (VIDIOC_ENUMAUDIO) */
 374                 struct v4l2_audio *vin = arg;
 375                 memset(vin,0,sizeof(*vin));
 376                 vin->index = 0;
 377                 strncpy(vin->name, "PVRUSB2 Audio",14);
 378                 vin->capability = V4L2_AUDCAP_STEREO;
 379                 ret = 0;
 380                 break;
 381         }
 382
 383         case VIDIOC_S_AUDIO:
 384         {
 385                 ret = -EINVAL;
 386                 break;
 387         }
 388         case VIDIOC_G_TUNER:
 389         {
 390                 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
 391
 392                 if (vt->index != 0) break; /* Only answer for the 1st tuner */
 393
 394                 pvr2_hdw_execute_tuner_poll(hdw);
 395                 ret = pvr2_hdw_get_tuner_status(hdw,vt);
 396                 break;
 397         }
 398
 399         case VIDIOC_S_TUNER:
 400         {
 401                 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
 402
 403                 if (vt->index != 0)
 404                         break;
 405
 406                 ret = pvr2_ctrl_set_value(
 407                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
 408                         vt->audmode);
 409                 break;
 410         }
 411
 412         case VIDIOC_S_FREQUENCY:
 413         {
 414                 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
 415                 unsigned long fv;
 416                 struct v4l2_tuner vt;
 417                 int cur_input;
 418                 struct pvr2_ctrl *ctrlp;
 419                 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
 420                 if (ret != 0) break;
 421                 ctrlp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
 422                 ret = pvr2_ctrl_get_value(ctrlp,&cur_input);
 423                 if (ret != 0) break;
 424                 if (vf->type == V4L2_TUNER_RADIO) {
 425                         if (cur_input != PVR2_CVAL_INPUT_RADIO) {
 426                                 pvr2_ctrl_set_value(ctrlp,
 427                                                     PVR2_CVAL_INPUT_RADIO);
 428                         }
 429                 } else {
 430                         if (cur_input == PVR2_CVAL_INPUT_RADIO) {
 431                                 pvr2_ctrl_set_value(ctrlp,
 432                                                     PVR2_CVAL_INPUT_TV);
 433                         }
 434                 }
 435                 fv = vf->frequency;
 436                 if (vt.capability & V4L2_TUNER_CAP_LOW) {
 437                         fv = (fv * 125) / 2;
 438                 } else {
 439                         fv = fv * 62500;
 440                 }
 441                 ret = pvr2_ctrl_set_value(
 442                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),fv);
 443                 break;
 444         }
 445
 446         case VIDIOC_G_FREQUENCY:
 447         {
 448                 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
 449                 int val = 0;
 450                 int cur_input;
 451                 struct v4l2_tuner vt;
 452                 ret = pvr2_hdw_get_tuner_status(hdw,&vt);
 453                 if (ret != 0) break;
 454                 ret = pvr2_ctrl_get_value(
 455                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
 456                         &val);
 457                 if (ret != 0) break;
 458                 pvr2_ctrl_get_value(
 459                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
 460                         &cur_input);
 461                 if (cur_input == PVR2_CVAL_INPUT_RADIO) {
 462                         vf->type = V4L2_TUNER_RADIO;
 463                 } else {
 464                         vf->type = V4L2_TUNER_ANALOG_TV;
 465                 }
 466                 if (vt.capability & V4L2_TUNER_CAP_LOW) {
 467                         val = (val * 2) / 125;
 468                 } else {
 469                         val /= 62500;
 470                 }
 471                 vf->frequency = val;
 472                 break;
 473         }
 474
 475         case VIDIOC_ENUM_FMT:
 476         {
 477                 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
 478
 479                 /* Only one format is supported : mpeg.*/
 480                 if (fd->index != 0)
 481                         break;
 482
 483                 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
 484                 ret = 0;
 485                 break;
 486         }
 487
 488         case VIDIOC_G_FMT:
 489         {
 490                 struct v4l2_format *vf = (struct v4l2_format *)arg;
 491                 int val;
 492                 switch(vf->type) {
 493                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 494                         memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
 495                                sizeof(struct v4l2_format));
 496                         val = 0;
 497                         pvr2_ctrl_get_value(
 498                                 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
 499                                 &val);
 500                         vf->fmt.pix.width = val;
 501                         val = 0;
 502                         pvr2_ctrl_get_value(
 503                                 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
 504                                 &val);
 505                         vf->fmt.pix.height = val;
 506                         ret = 0;
 507                         break;
 508                 case V4L2_BUF_TYPE_VBI_CAPTURE:
 509                         // ????? Still need to figure out to do VBI correctly
 510                         ret = -EINVAL;
 511                         break;
 512                 default:
 513                         ret = -EINVAL;
 514                         break;
 515                 }
 516                 break;
 517         }
 518
 519         case VIDIOC_TRY_FMT:
 520         case VIDIOC_S_FMT:
 521         {
 522                 struct v4l2_format *vf = (struct v4l2_format *)arg;
 523
 524                 ret = 0;
 525                 switch(vf->type) {
 526                 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
 527                         int lmin,lmax,ldef;
 528                         struct pvr2_ctrl *hcp,*vcp;
 529                         int h = vf->fmt.pix.height;
 530                         int w = vf->fmt.pix.width;
 531                         hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
 532                         vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
 533
 534                         lmin = pvr2_ctrl_get_min(hcp);
 535                         lmax = pvr2_ctrl_get_max(hcp);
 536                         pvr2_ctrl_get_def(hcp, &ldef);
 537                         if (w == -1) {
 538                                 w = ldef;
 539                         } else if (w < lmin) {
 540                                 w = lmin;
 541                         } else if (w > lmax) {
 542                                 w = lmax;
 543                         }
 544                         lmin = pvr2_ctrl_get_min(vcp);
 545                         lmax = pvr2_ctrl_get_max(vcp);
 546                         pvr2_ctrl_get_def(vcp, &ldef);
 547                         if (h == -1) {
 548                                 h = ldef;
 549                         } else if (h < lmin) {
 550                                 h = lmin;
 551                         } else if (h > lmax) {
 552                                 h = lmax;
 553                         }
 554
 555                         memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
 556                                sizeof(struct v4l2_format));
 557                         vf->fmt.pix.width = w;
 558                         vf->fmt.pix.height = h;
 559
 560                         if (cmd == VIDIOC_S_FMT) {
 561                                 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
 562                                 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
 563                         }
 564                 } break;
 565                 case V4L2_BUF_TYPE_VBI_CAPTURE:
 566                         // ????? Still need to figure out to do VBI correctly
 567                         ret = -EINVAL;
 568                         break;
 569                 default:
 570                         ret = -EINVAL;
 571                         break;
 572                 }
 573                 break;
 574         }
 575
 576         case VIDIOC_STREAMON:
 577         {
 578                 if (!fh->dev_info->stream) {
 579                         /* No stream defined for this node.  This means
 580                            that we're not currently allowed to stream from
 581                            this node. */
 582                         ret = -EPERM;
 583                         break;
 584                 }
 585                 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
 586                 if (ret < 0) return ret;
 587                 ret = pvr2_hdw_set_streaming(hdw,!0);
 588                 break;
 589         }
 590
 591         case VIDIOC_STREAMOFF:
 592         {
 593                 if (!fh->dev_info->stream) {
 594                         /* No stream defined for this node.  This means
 595                            that we're not currently allowed to stream from
 596                            this node. */
 597                         ret = -EPERM;
 598                         break;
 599                 }
 600                 ret = pvr2_hdw_set_streaming(hdw,0);
 601                 break;
 602         }
 603
 604         case VIDIOC_QUERYCTRL:
 605         {
 606                 struct pvr2_ctrl *cptr;
 607                 int val;
 608                 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
 609                 ret = 0;
 610                 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
 611                         cptr = pvr2_hdw_get_ctrl_nextv4l(
 612                                 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
 613                         if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
 614                 } else {
 615                         cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
 616                 }
 617                 if (!cptr) {
 618                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 619                                    "QUERYCTRL id=0x%x not implemented here",
 620                                    vc->id);
 621                         ret = -EINVAL;
 622                         break;
 623                 }
 624
 625                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 626                            "QUERYCTRL id=0x%x mapping name=%s (%s)",
 627                            vc->id,pvr2_ctrl_get_name(cptr),
 628                            pvr2_ctrl_get_desc(cptr));
 629                 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
 630                 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
 631                 pvr2_ctrl_get_def(cptr, &val);
 632                 vc->default_value = val;
 633                 switch (pvr2_ctrl_get_type(cptr)) {
 634                 case pvr2_ctl_enum:
 635                         vc->type = V4L2_CTRL_TYPE_MENU;
 636                         vc->minimum = 0;
 637                         vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
 638                         vc->step = 1;
 639                         break;
 640                 case pvr2_ctl_bool:
 641                         vc->type = V4L2_CTRL_TYPE_BOOLEAN;
 642                         vc->minimum = 0;
 643                         vc->maximum = 1;
 644                         vc->step = 1;
 645                         break;
 646                 case pvr2_ctl_int:
 647                         vc->type = V4L2_CTRL_TYPE_INTEGER;
 648                         vc->minimum = pvr2_ctrl_get_min(cptr);
 649                         vc->maximum = pvr2_ctrl_get_max(cptr);
 650                         vc->step = 1;
 651                         break;
 652                 default:
 653                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 654                                    "QUERYCTRL id=0x%x name=%s not mappable",
 655                                    vc->id,pvr2_ctrl_get_name(cptr));
 656                         ret = -EINVAL;
 657                         break;
 658                 }
 659                 break;
 660         }
 661
 662         case VIDIOC_QUERYMENU:
 663         {
 664                 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
 665                 unsigned int cnt = 0;
 666                 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
 667                                             vm->index,
 668                                             vm->name,sizeof(vm->name)-1,
 669                                             &cnt);
 670                 vm->name[cnt] = 0;
 671                 break;
 672         }
 673
 674         case VIDIOC_G_CTRL:
 675         {
 676                 struct v4l2_control *vc = (struct v4l2_control *)arg;
 677                 int val = 0;
 678                 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
 679                                           &val);
 680                 vc->value = val;
 681                 break;
 682         }
 683
 684         case VIDIOC_S_CTRL:
 685         {
 686                 struct v4l2_control *vc = (struct v4l2_control *)arg;
 687                 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
 688                                           vc->value);
 689                 break;
 690         }
 691
 692         case VIDIOC_G_EXT_CTRLS:
 693         {
 694                 struct v4l2_ext_controls *ctls =
 695                         (struct v4l2_ext_controls *)arg;
 696                 struct v4l2_ext_control *ctrl;
 697                 unsigned int idx;
 698                 int val;
 699                 ret = 0;
 700                 for (idx = 0; idx < ctls->count; idx++) {
 701                         ctrl = ctls->controls + idx;
 702                         ret = pvr2_ctrl_get_value(
 703                                 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
 704                         if (ret) {
 705                                 ctls->error_idx = idx;
 706                                 break;
 707                         }
 708                         /* Ensure that if read as a 64 bit value, the user
 709                            will still get a hopefully sane value */
 710                         ctrl->value64 = 0;
 711                         ctrl->value = val;
 712                 }
 713                 break;
 714         }
 715
 716         case VIDIOC_S_EXT_CTRLS:
 717         {
 718                 struct v4l2_ext_controls *ctls =
 719                         (struct v4l2_ext_controls *)arg;
 720                 struct v4l2_ext_control *ctrl;
 721                 unsigned int idx;
 722                 ret = 0;
 723                 for (idx = 0; idx < ctls->count; idx++) {
 724                         ctrl = ctls->controls + idx;
 725                         ret = pvr2_ctrl_set_value(
 726                                 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
 727                                 ctrl->value);
 728                         if (ret) {
 729                                 ctls->error_idx = idx;
 730                                 break;
 731                         }
 732                 }
 733                 break;
 734         }
 735
 736         case VIDIOC_TRY_EXT_CTRLS:
 737         {
 738                 struct v4l2_ext_controls *ctls =
 739                         (struct v4l2_ext_controls *)arg;
 740                 struct v4l2_ext_control *ctrl;
 741                 struct pvr2_ctrl *pctl;
 742                 unsigned int idx;
 743                 /* For the moment just validate that the requested control
 744                    actually exists. */
 745                 ret = 0;
 746                 for (idx = 0; idx < ctls->count; idx++) {
 747                         ctrl = ctls->controls + idx;
 748                         pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
 749                         if (!pctl) {
 750                                 ret = -EINVAL;
 751                                 ctls->error_idx = idx;
 752                                 break;
 753                         }
 754                 }
 755                 break;
 756         }
 757
 758         case VIDIOC_CROPCAP:
 759         {
 760                 struct v4l2_cropcap *cap = (struct v4l2_cropcap *)arg;
 761                 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 762                         ret = -EINVAL;
 763                         break;
 764                 }
 765                 ret = pvr2_hdw_get_cropcap(hdw, cap);
 766                 cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
 767                 break;
 768         }
 769         case VIDIOC_G_CROP:
 770         {
 771                 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
 772                 int val = 0;
 773                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 774                         ret = -EINVAL;
 775                         break;
 776                 }
 777                 ret = pvr2_ctrl_get_value(
 778                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL), &val);
 779                 if (ret != 0) {
 780                         ret = -EINVAL;
 781                         break;
 782                 }
 783                 crop->c.left = val;
 784                 ret = pvr2_ctrl_get_value(
 785                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT), &val);
 786                 if (ret != 0) {
 787                         ret = -EINVAL;
 788                         break;
 789                 }
 790                 crop->c.top = val;
 791                 ret = pvr2_ctrl_get_value(
 792                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW), &val);
 793                 if (ret != 0) {
 794                         ret = -EINVAL;
 795                         break;
 796                 }
 797                 crop->c.width = val;
 798                 ret = pvr2_ctrl_get_value(
 799                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH), &val);
 800                 if (ret != 0) {
 801                         ret = -EINVAL;
 802                         break;
 803                 }
 804                 crop->c.height = val;
 805         }
 806         case VIDIOC_S_CROP:
 807         {
 808                 struct v4l2_crop *crop = (struct v4l2_crop *)arg;
 809                 struct v4l2_cropcap cap;
 810                 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 811                         ret = -EINVAL;
 812                         break;
 813                 }
 814                 cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 815                 ret = pvr2_ctrl_set_value(
 816                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL),
 817                         crop->c.left);
 818                 if (ret != 0) {
 819                         ret = -EINVAL;
 820                         break;
 821                 }
 822                 ret = pvr2_ctrl_set_value(
 823                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT),
 824                         crop->c.top);
 825                 if (ret != 0) {
 826                         ret = -EINVAL;
 827                         break;
 828                 }
 829                 ret = pvr2_ctrl_set_value(
 830                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW),
 831                         crop->c.width);
 832                 if (ret != 0) {
 833                         ret = -EINVAL;
 834                         break;
 835                 }
 836                 ret = pvr2_ctrl_set_value(
 837                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH),
 838                         crop->c.height);
 839                 if (ret != 0) {
 840                         ret = -EINVAL;
 841                         break;
 842                 }
 843         }
 844         case VIDIOC_LOG_STATUS:
 845         {
 846                 pvr2_hdw_trigger_module_log(hdw);
 847                 ret = 0;
 848                 break;
 849         }
 850 #ifdef CONFIG_VIDEO_ADV_DEBUG
 851         case VIDIOC_DBG_S_REGISTER:
 852         case VIDIOC_DBG_G_REGISTER:
 853         {
 854                 u64 val;
 855                 struct v4l2_register *req = (struct v4l2_register *)arg;
 856                 if (cmd == VIDIOC_DBG_S_REGISTER) val = req->val;
 857                 ret = pvr2_hdw_register_access(
 858                         hdw,req->match_type,req->match_chip,req->reg,
 859                         cmd == VIDIOC_DBG_S_REGISTER,&val);
 860                 if (cmd == VIDIOC_DBG_G_REGISTER) req->val = val;
 861                 break;
 862         }
 863 #endif
 864
 865         default :
 866                 ret = v4l_compat_translate_ioctl(file, cmd,
 867                                                  arg, __pvr2_v4l2_do_ioctl);
 868         }
 869
 870         pvr2_hdw_commit_ctl(hdw);
 871
 872         if (ret < 0) {
 873                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 874                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 875                                    "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
 876                 } else {
 877                         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 878                                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 879                                            "pvr2_v4l2_do_ioctl failure, ret=%d"
 880                                            " command was:",ret);
 881                                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
 882                                                 cmd);
 883                         }
 884                 }
 885         } else {
 886                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 887                            "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
 888                            ret,ret);
 889         }
 890         return ret;
 891 }
 892
 893 static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 894                               unsigned int cmd, void *arg)
 895 {
 896         return __pvr2_v4l2_do_ioctl(file, cmd, arg);
 897 }
 898
 899 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
 900 {
 901         int num = dip->devbase.num;
 902         struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
 903         enum pvr2_config cfg = dip->config;
 904         int v4l_type = dip->v4l_type;
 905
 906         pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
 907
 908         /* Paranoia */
 909         dip->v4lp = NULL;
 910         dip->stream = NULL;
 911
 912         /* Actual deallocation happens later when all internal references
 913            are gone. */
 914         video_unregister_device(&dip->devbase);
 915
 916         printk(KERN_INFO "pvrusb2: unregistered device %s%u [%s]\n",
 917                get_v4l_name(v4l_type), num,
 918                pvr2_config_get_name(cfg));
 919
 920 }
 921
 922
 923 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
 924 {
 925         if (vp->dev_video) {
 926                 pvr2_v4l2_dev_destroy(vp->dev_video);
 927                 vp->dev_video = NULL;
 928         }
 929         if (vp->dev_radio) {
 930                 pvr2_v4l2_dev_destroy(vp->dev_radio);
 931                 vp->dev_radio = NULL;
 932         }
 933
 934         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
 935         pvr2_channel_done(&vp->channel);
 936         kfree(vp);
 937 }
 938
 939
 940 static void pvr2_video_device_release(struct video_device *vdev)
 941 {
 942         struct pvr2_v4l2_dev *dev;
 943         dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
 944         kfree(dev);
 945 }
 946
 947
 948 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
 949 {
 950         struct pvr2_v4l2 *vp;
 951         vp = container_of(chp,struct pvr2_v4l2,channel);
 952         if (!vp->channel.mc_head->disconnect_flag) return;
 953         if (vp->vfirst) return;
 954         pvr2_v4l2_destroy_no_lock(vp);
 955 }
 956
 957
 958 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
 959                            unsigned int cmd, unsigned long arg)
 960 {
 961
 962 /* Temporary hack : use ivtv api until a v4l2 one is available. */
 963 #define IVTV_IOC_G_CODEC        0xFFEE7703
 964 #define IVTV_IOC_S_CODEC        0xFFEE7704
 965         if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
 966         return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
 967 }
 968
 969
 970 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
 971 {
 972         struct pvr2_v4l2_fh *fhp = file->private_data;
 973         struct pvr2_v4l2 *vp = fhp->vhead;
 974         struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
 975
 976         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
 977
 978         if (fhp->rhp) {
 979                 struct pvr2_stream *sp;
 980                 pvr2_hdw_set_streaming(hdw,0);
 981                 sp = pvr2_ioread_get_stream(fhp->rhp);
 982                 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
 983                 pvr2_ioread_destroy(fhp->rhp);
 984                 fhp->rhp = NULL;
 985         }
 986
 987         v4l2_prio_close(&vp->prio, &fhp->prio);
 988         file->private_data = NULL;
 989
 990         if (fhp->vnext) {
 991                 fhp->vnext->vprev = fhp->vprev;
 992         } else {
 993                 vp->vlast = fhp->vprev;
 994         }
 995         if (fhp->vprev) {
 996                 fhp->vprev->vnext = fhp->vnext;
 997         } else {
 998                 vp->vfirst = fhp->vnext;
 999         }
1000         fhp->vnext = NULL;
1001         fhp->vprev = NULL;
1002         fhp->vhead = NULL;
1003         pvr2_channel_done(&fhp->channel);
1004         pvr2_trace(PVR2_TRACE_STRUCT,
1005                    "Destroying pvr_v4l2_fh id=%p",fhp);
1006         if (fhp->input_map) {
1007                 kfree(fhp->input_map);
1008                 fhp->input_map = NULL;
1009         }
1010         kfree(fhp);
1011         if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
1012                 pvr2_v4l2_destroy_no_lock(vp);
1013         }
1014         return 0;
1015 }
1016
1017
1018 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
1019 {
1020         struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1021         struct pvr2_v4l2_fh *fhp;
1022         struct pvr2_v4l2 *vp;
1023         struct pvr2_hdw *hdw;
1024         unsigned int input_mask = 0;
1025         unsigned int input_cnt,idx;
1026         int ret = 0;
1027
1028         dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1029
1030         vp = dip->v4lp;
1031         hdw = vp->channel.hdw;
1032
1033         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1034
1035         if (!pvr2_hdw_dev_ok(hdw)) {
1036                 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1037                            "pvr2_v4l2_open: hardware not ready");
1038                 return -EIO;
1039         }
1040
1041         fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1042         if (!fhp) {
1043                 return -ENOMEM;
1044         }
1045
1046         init_waitqueue_head(&fhp->wait_data);
1047         fhp->dev_info = dip;
1048
1049         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1050         pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1051
1052         if (dip->v4l_type == VFL_TYPE_RADIO) {
1053                 /* Opening device as a radio, legal input selection subset
1054                    is just the radio. */
1055                 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1056         } else {
1057                 /* Opening the main V4L device, legal input selection
1058                    subset includes all analog inputs. */
1059                 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1060                               (1 << PVR2_CVAL_INPUT_TV) |
1061                               (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1062                               (1 << PVR2_CVAL_INPUT_SVIDEO));
1063         }
1064         ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1065         if (ret) {
1066                 pvr2_channel_done(&fhp->channel);
1067                 pvr2_trace(PVR2_TRACE_STRUCT,
1068                            "Destroying pvr_v4l2_fh id=%p (input mask error)",
1069                            fhp);
1070
1071                 kfree(fhp);
1072                 return ret;
1073         }
1074
1075         input_mask &= pvr2_hdw_get_input_available(hdw);
1076         input_cnt = 0;
1077         for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1078                 if (input_mask & (1 << idx)) input_cnt++;
1079         }
1080         fhp->input_cnt = input_cnt;
1081         fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1082         if (!fhp->input_map) {
1083                 pvr2_channel_done(&fhp->channel);
1084                 pvr2_trace(PVR2_TRACE_STRUCT,
1085                            "Destroying pvr_v4l2_fh id=%p (input map failure)",
1086                            fhp);
1087                 kfree(fhp);
1088                 return -ENOMEM;
1089         }
1090         input_cnt = 0;
1091         for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1092                 if (!(input_mask & (1 << idx))) continue;
1093                 fhp->input_map[input_cnt++] = idx;
1094         }
1095
1096         fhp->vnext = NULL;
1097         fhp->vprev = vp->vlast;
1098         if (vp->vlast) {
1099                 vp->vlast->vnext = fhp;
1100         } else {
1101                 vp->vfirst = fhp;
1102         }
1103         vp->vlast = fhp;
1104         fhp->vhead = vp;
1105
1106         fhp->file = file;
1107         file->private_data = fhp;
1108         v4l2_prio_open(&vp->prio,&fhp->prio);
1109
1110         fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1111
1112         return 0;
1113 }
1114
1115
1116 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1117 {
1118         wake_up(&fhp->wait_data);
1119 }
1120
1121 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1122 {
1123         int ret;
1124         struct pvr2_stream *sp;
1125         struct pvr2_hdw *hdw;
1126         if (fh->rhp) return 0;
1127
1128         if (!fh->dev_info->stream) {
1129                 /* No stream defined for this node.  This means that we're
1130                    not currently allowed to stream from this node. */
1131                 return -EPERM;
1132         }
1133
1134         /* First read() attempt.  Try to claim the stream and start
1135            it... */
1136         if ((ret = pvr2_channel_claim_stream(&fh->channel,
1137                                              fh->dev_info->stream)) != 0) {
1138                 /* Someone else must already have it */
1139                 return ret;
1140         }
1141
1142         fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
1143         if (!fh->rhp) {
1144                 pvr2_channel_claim_stream(&fh->channel,NULL);
1145                 return -ENOMEM;
1146         }
1147
1148         hdw = fh->channel.mc_head->hdw;
1149         sp = fh->dev_info->stream->stream;
1150         pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1151         pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
1152         if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1153         return pvr2_ioread_set_enabled(fh->rhp,!0);
1154 }
1155
1156
1157 static ssize_t pvr2_v4l2_read(struct file *file,
1158                               char __user *buff, size_t count, loff_t *ppos)
1159 {
1160         struct pvr2_v4l2_fh *fh = file->private_data;
1161         int ret;
1162
1163         if (fh->fw_mode_flag) {
1164                 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1165                 char *tbuf;
1166                 int c1,c2;
1167                 int tcnt = 0;
1168                 unsigned int offs = *ppos;
1169
1170                 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1171                 if (!tbuf) return -ENOMEM;
1172
1173                 while (count) {
1174                         c1 = count;
1175                         if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1176                         c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1177                         if (c2 < 0) {
1178                                 tcnt = c2;
1179                                 break;
1180                         }
1181                         if (!c2) break;
1182                         if (copy_to_user(buff,tbuf,c2)) {
1183                                 tcnt = -EFAULT;
1184                                 break;
1185                         }
1186                         offs += c2;
1187                         tcnt += c2;
1188                         buff += c2;
1189                         count -= c2;
1190                         *ppos += c2;
1191                 }
1192                 kfree(tbuf);
1193                 return tcnt;
1194         }
1195
1196         if (!fh->rhp) {
1197                 ret = pvr2_v4l2_iosetup(fh);
1198                 if (ret) {
1199                         return ret;
1200                 }
1201         }
1202
1203         for (;;) {
1204                 ret = pvr2_ioread_read(fh->rhp,buff,count);
1205                 if (ret >= 0) break;
1206                 if (ret != -EAGAIN) break;
1207                 if (file->f_flags & O_NONBLOCK) break;
1208                 /* Doing blocking I/O.  Wait here. */
1209                 ret = wait_event_interruptible(
1210                         fh->wait_data,
1211                         pvr2_ioread_avail(fh->rhp) >= 0);
1212                 if (ret < 0) break;
1213         }
1214
1215         return ret;
1216 }
1217
1218
1219 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1220 {
1221         unsigned int mask = 0;
1222         struct pvr2_v4l2_fh *fh = file->private_data;
1223         int ret;
1224
1225         if (fh->fw_mode_flag) {
1226                 mask |= POLLIN | POLLRDNORM;
1227                 return mask;
1228         }
1229
1230         if (!fh->rhp) {
1231                 ret = pvr2_v4l2_iosetup(fh);
1232                 if (ret) return POLLERR;
1233         }
1234
1235         poll_wait(file,&fh->wait_data,wait);
1236
1237         if (pvr2_ioread_avail(fh->rhp) >= 0) {
1238                 mask |= POLLIN | POLLRDNORM;
1239         }
1240
1241         return mask;
1242 }
1243
1244
1245 static const struct file_operations vdev_fops = {
1246         .owner      = THIS_MODULE,
1247         .open       = pvr2_v4l2_open,
1248         .release    = pvr2_v4l2_release,
1249         .read       = pvr2_v4l2_read,
1250         .ioctl      = pvr2_v4l2_ioctl,
1251         .llseek     = no_llseek,
1252         .poll       = pvr2_v4l2_poll,
1253 };
1254
1255
1256 static struct video_device vdev_template = {
1257         .fops       = &vdev_fops,
1258 };
1259
1260
1261 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1262                                struct pvr2_v4l2 *vp,
1263                                int v4l_type)
1264 {
1265         int mindevnum;
1266         int unit_number;
1267         int *nr_ptr = NULL;
1268         dip->v4lp = vp;
1269
1270
1271         dip->v4l_type = v4l_type;
1272         switch (v4l_type) {
1273         case VFL_TYPE_GRABBER:
1274                 dip->stream = &vp->channel.mc_head->video_stream;
1275                 dip->config = pvr2_config_mpeg;
1276                 dip->minor_type = pvr2_v4l_type_video;
1277                 nr_ptr = video_nr;
1278                 if (!dip->stream) {
1279                         err("Failed to set up pvrusb2 v4l video dev"
1280                             " due to missing stream instance");
1281                         return;
1282                 }
1283                 break;
1284         case VFL_TYPE_VBI:
1285                 dip->config = pvr2_config_vbi;
1286                 dip->minor_type = pvr2_v4l_type_vbi;
1287                 nr_ptr = vbi_nr;
1288                 break;
1289         case VFL_TYPE_RADIO:
1290                 dip->stream = &vp->channel.mc_head->video_stream;
1291                 dip->config = pvr2_config_mpeg;
1292                 dip->minor_type = pvr2_v4l_type_radio;
1293                 nr_ptr = radio_nr;
1294                 break;
1295         default:
1296                 /* Bail out (this should be impossible) */
1297                 err("Failed to set up pvrusb2 v4l dev"
1298                     " due to unrecognized config");
1299                 return;
1300         }
1301
1302         memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1303         dip->devbase.release = pvr2_video_device_release;
1304
1305         mindevnum = -1;
1306         unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1307         if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1308                 mindevnum = nr_ptr[unit_number];
1309         }
1310         if ((video_register_device(&dip->devbase,
1311                                    dip->v4l_type, mindevnum) < 0) &&
1312             (video_register_device(&dip->devbase,
1313                                    dip->v4l_type, -1) < 0)) {
1314                 err("Failed to register pvrusb2 v4l device");
1315         }
1316
1317         printk(KERN_INFO "pvrusb2: registered device %s%u [%s]\n",
1318                get_v4l_name(dip->v4l_type), dip->devbase.num,
1319                pvr2_config_get_name(dip->config));
1320
1321         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1322                                         dip->minor_type,dip->devbase.minor);
1323 }
1324
1325
1326 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1327 {
1328         struct pvr2_v4l2 *vp;
1329
1330         vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1331         if (!vp) return vp;
1332         pvr2_channel_init(&vp->channel,mnp);
1333         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1334
1335         vp->channel.check_func = pvr2_v4l2_internal_check;
1336
1337         /* register streams */
1338         vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1339         if (!vp->dev_video) goto fail;
1340         pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1341         if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1342             (1 << PVR2_CVAL_INPUT_RADIO)) {
1343                 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1344                 if (!vp->dev_radio) goto fail;
1345                 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1346         }
1347
1348         return vp;
1349  fail:
1350         pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1351         pvr2_v4l2_destroy_no_lock(vp);
1352         return NULL;
1353 }
1354
1355 /*
1356   Stuff for Emacs to see, in order to encourage consistent editing style:
1357   *** Local Variables: ***
1358   *** mode: c ***
1359   *** fill-column: 75 ***
1360   *** tab-width: 8 ***
1361   *** c-basic-offset: 8 ***
1362   *** End: ***
1363   */