git.oblomov.eu Git - linux-2.6/blob - 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 inode *inode, 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(inode,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
 894 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
 895 {
 896         int minor_id = dip->devbase.minor;
 897         struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
 898         enum pvr2_config cfg = dip->config;
 899         int v4l_type = dip->v4l_type;
 900
 901         pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
 902
 903         /* Paranoia */
 904         dip->v4lp = NULL;
 905         dip->stream = NULL;
 906
 907         /* Actual deallocation happens later when all internal references
 908            are gone. */
 909         video_unregister_device(&dip->devbase);
 910
 911         printk(KERN_INFO "pvrusb2: unregistered device %s%u [%s]\n",
 912                get_v4l_name(v4l_type),minor_id & 0x1f,
 913                pvr2_config_get_name(cfg));
 914
 915 }
 916
 917
 918 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
 919 {
 920         if (vp->dev_video) {
 921                 pvr2_v4l2_dev_destroy(vp->dev_video);
 922                 vp->dev_video = NULL;
 923         }
 924         if (vp->dev_radio) {
 925                 pvr2_v4l2_dev_destroy(vp->dev_radio);
 926                 vp->dev_radio = NULL;
 927         }
 928
 929         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
 930         pvr2_channel_done(&vp->channel);
 931         kfree(vp);
 932 }
 933
 934
 935 static void pvr2_video_device_release(struct video_device *vdev)
 936 {
 937         struct pvr2_v4l2_dev *dev;
 938         dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
 939         kfree(dev);
 940 }
 941
 942
 943 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
 944 {
 945         struct pvr2_v4l2 *vp;
 946         vp = container_of(chp,struct pvr2_v4l2,channel);
 947         if (!vp->channel.mc_head->disconnect_flag) return;
 948         if (vp->vfirst) return;
 949         pvr2_v4l2_destroy_no_lock(vp);
 950 }
 951
 952
 953 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
 954                            unsigned int cmd, unsigned long arg)
 955 {
 956
 957 /* Temporary hack : use ivtv api until a v4l2 one is available. */
 958 #define IVTV_IOC_G_CODEC        0xFFEE7703
 959 #define IVTV_IOC_S_CODEC        0xFFEE7704
 960         if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
 961         return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
 962 }
 963
 964
 965 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
 966 {
 967         struct pvr2_v4l2_fh *fhp = file->private_data;
 968         struct pvr2_v4l2 *vp = fhp->vhead;
 969         struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
 970
 971         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
 972
 973         if (fhp->rhp) {
 974                 struct pvr2_stream *sp;
 975                 pvr2_hdw_set_streaming(hdw,0);
 976                 sp = pvr2_ioread_get_stream(fhp->rhp);
 977                 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
 978                 pvr2_ioread_destroy(fhp->rhp);
 979                 fhp->rhp = NULL;
 980         }
 981
 982         v4l2_prio_close(&vp->prio, &fhp->prio);
 983         file->private_data = NULL;
 984
 985         if (fhp->vnext) {
 986                 fhp->vnext->vprev = fhp->vprev;
 987         } else {
 988                 vp->vlast = fhp->vprev;
 989         }
 990         if (fhp->vprev) {
 991                 fhp->vprev->vnext = fhp->vnext;
 992         } else {
 993                 vp->vfirst = fhp->vnext;
 994         }
 995         fhp->vnext = NULL;
 996         fhp->vprev = NULL;
 997         fhp->vhead = NULL;
 998         pvr2_channel_done(&fhp->channel);
 999         pvr2_trace(PVR2_TRACE_STRUCT,
1000                    "Destroying pvr_v4l2_fh id=%p",fhp);
1001         if (fhp->input_map) {
1002                 kfree(fhp->input_map);
1003                 fhp->input_map = NULL;
1004         }
1005         kfree(fhp);
1006         if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
1007                 pvr2_v4l2_destroy_no_lock(vp);
1008         }
1009         return 0;
1010 }
1011
1012
1013 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
1014 {
1015         struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1016         struct pvr2_v4l2_fh *fhp;
1017         struct pvr2_v4l2 *vp;
1018         struct pvr2_hdw *hdw;
1019         unsigned int input_mask = 0;
1020         unsigned int input_cnt,idx;
1021         int ret = 0;
1022
1023         dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1024
1025         vp = dip->v4lp;
1026         hdw = vp->channel.hdw;
1027
1028         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1029
1030         if (!pvr2_hdw_dev_ok(hdw)) {
1031                 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1032                            "pvr2_v4l2_open: hardware not ready");
1033                 return -EIO;
1034         }
1035
1036         fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1037         if (!fhp) {
1038                 return -ENOMEM;
1039         }
1040
1041         init_waitqueue_head(&fhp->wait_data);
1042         fhp->dev_info = dip;
1043
1044         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1045         pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1046
1047         if (dip->v4l_type == VFL_TYPE_RADIO) {
1048                 /* Opening device as a radio, legal input selection subset
1049                    is just the radio. */
1050                 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1051         } else {
1052                 /* Opening the main V4L device, legal input selection
1053                    subset includes all analog inputs. */
1054                 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1055                               (1 << PVR2_CVAL_INPUT_TV) |
1056                               (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1057                               (1 << PVR2_CVAL_INPUT_SVIDEO));
1058         }
1059         ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1060         if (ret) {
1061                 pvr2_channel_done(&fhp->channel);
1062                 pvr2_trace(PVR2_TRACE_STRUCT,
1063                            "Destroying pvr_v4l2_fh id=%p (input mask error)",
1064                            fhp);
1065
1066                 kfree(fhp);
1067                 return ret;
1068         }
1069
1070         input_mask &= pvr2_hdw_get_input_available(hdw);
1071         input_cnt = 0;
1072         for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1073                 if (input_mask & (1 << idx)) input_cnt++;
1074         }
1075         fhp->input_cnt = input_cnt;
1076         fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1077         if (!fhp->input_map) {
1078                 pvr2_channel_done(&fhp->channel);
1079                 pvr2_trace(PVR2_TRACE_STRUCT,
1080                            "Destroying pvr_v4l2_fh id=%p (input map failure)",
1081                            fhp);
1082                 kfree(fhp);
1083                 return -ENOMEM;
1084         }
1085         input_cnt = 0;
1086         for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1087                 if (!(input_mask & (1 << idx))) continue;
1088                 fhp->input_map[input_cnt++] = idx;
1089         }
1090
1091         fhp->vnext = NULL;
1092         fhp->vprev = vp->vlast;
1093         if (vp->vlast) {
1094                 vp->vlast->vnext = fhp;
1095         } else {
1096                 vp->vfirst = fhp;
1097         }
1098         vp->vlast = fhp;
1099         fhp->vhead = vp;
1100
1101         fhp->file = file;
1102         file->private_data = fhp;
1103         v4l2_prio_open(&vp->prio,&fhp->prio);
1104
1105         fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1106
1107         return 0;
1108 }
1109
1110
1111 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1112 {
1113         wake_up(&fhp->wait_data);
1114 }
1115
1116 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1117 {
1118         int ret;
1119         struct pvr2_stream *sp;
1120         struct pvr2_hdw *hdw;
1121         if (fh->rhp) return 0;
1122
1123         if (!fh->dev_info->stream) {
1124                 /* No stream defined for this node.  This means that we're
1125                    not currently allowed to stream from this node. */
1126                 return -EPERM;
1127         }
1128
1129         /* First read() attempt.  Try to claim the stream and start
1130            it... */
1131         if ((ret = pvr2_channel_claim_stream(&fh->channel,
1132                                              fh->dev_info->stream)) != 0) {
1133                 /* Someone else must already have it */
1134                 return ret;
1135         }
1136
1137         fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
1138         if (!fh->rhp) {
1139                 pvr2_channel_claim_stream(&fh->channel,NULL);
1140                 return -ENOMEM;
1141         }
1142
1143         hdw = fh->channel.mc_head->hdw;
1144         sp = fh->dev_info->stream->stream;
1145         pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1146         pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
1147         if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1148         return pvr2_ioread_set_enabled(fh->rhp,!0);
1149 }
1150
1151
1152 static ssize_t pvr2_v4l2_read(struct file *file,
1153                               char __user *buff, size_t count, loff_t *ppos)
1154 {
1155         struct pvr2_v4l2_fh *fh = file->private_data;
1156         int ret;
1157
1158         if (fh->fw_mode_flag) {
1159                 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1160                 char *tbuf;
1161                 int c1,c2;
1162                 int tcnt = 0;
1163                 unsigned int offs = *ppos;
1164
1165                 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1166                 if (!tbuf) return -ENOMEM;
1167
1168                 while (count) {
1169                         c1 = count;
1170                         if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1171                         c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1172                         if (c2 < 0) {
1173                                 tcnt = c2;
1174                                 break;
1175                         }
1176                         if (!c2) break;
1177                         if (copy_to_user(buff,tbuf,c2)) {
1178                                 tcnt = -EFAULT;
1179                                 break;
1180                         }
1181                         offs += c2;
1182                         tcnt += c2;
1183                         buff += c2;
1184                         count -= c2;
1185                         *ppos += c2;
1186                 }
1187                 kfree(tbuf);
1188                 return tcnt;
1189         }
1190
1191         if (!fh->rhp) {
1192                 ret = pvr2_v4l2_iosetup(fh);
1193                 if (ret) {
1194                         return ret;
1195                 }
1196         }
1197
1198         for (;;) {
1199                 ret = pvr2_ioread_read(fh->rhp,buff,count);
1200                 if (ret >= 0) break;
1201                 if (ret != -EAGAIN) break;
1202                 if (file->f_flags & O_NONBLOCK) break;
1203                 /* Doing blocking I/O.  Wait here. */
1204                 ret = wait_event_interruptible(
1205                         fh->wait_data,
1206                         pvr2_ioread_avail(fh->rhp) >= 0);
1207                 if (ret < 0) break;
1208         }
1209
1210         return ret;
1211 }
1212
1213
1214 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1215 {
1216         unsigned int mask = 0;
1217         struct pvr2_v4l2_fh *fh = file->private_data;
1218         int ret;
1219
1220         if (fh->fw_mode_flag) {
1221                 mask |= POLLIN | POLLRDNORM;
1222                 return mask;
1223         }
1224
1225         if (!fh->rhp) {
1226                 ret = pvr2_v4l2_iosetup(fh);
1227                 if (ret) return POLLERR;
1228         }
1229
1230         poll_wait(file,&fh->wait_data,wait);
1231
1232         if (pvr2_ioread_avail(fh->rhp) >= 0) {
1233                 mask |= POLLIN | POLLRDNORM;
1234         }
1235
1236         return mask;
1237 }
1238
1239
1240 static const struct file_operations vdev_fops = {
1241         .owner      = THIS_MODULE,
1242         .open       = pvr2_v4l2_open,
1243         .release    = pvr2_v4l2_release,
1244         .read       = pvr2_v4l2_read,
1245         .ioctl      = pvr2_v4l2_ioctl,
1246         .llseek     = no_llseek,
1247         .poll       = pvr2_v4l2_poll,
1248 };
1249
1250
1251 static struct video_device vdev_template = {
1252         .fops       = &vdev_fops,
1253 };
1254
1255
1256 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1257                                struct pvr2_v4l2 *vp,
1258                                int v4l_type)
1259 {
1260         int mindevnum;
1261         int unit_number;
1262         int *nr_ptr = NULL;
1263         dip->v4lp = vp;
1264
1265
1266         dip->v4l_type = v4l_type;
1267         switch (v4l_type) {
1268         case VFL_TYPE_GRABBER:
1269                 dip->stream = &vp->channel.mc_head->video_stream;
1270                 dip->config = pvr2_config_mpeg;
1271                 dip->minor_type = pvr2_v4l_type_video;
1272                 nr_ptr = video_nr;
1273                 if (!dip->stream) {
1274                         err("Failed to set up pvrusb2 v4l video dev"
1275                             " due to missing stream instance");
1276                         return;
1277                 }
1278                 break;
1279         case VFL_TYPE_VBI:
1280                 dip->config = pvr2_config_vbi;
1281                 dip->minor_type = pvr2_v4l_type_vbi;
1282                 nr_ptr = vbi_nr;
1283                 break;
1284         case VFL_TYPE_RADIO:
1285                 dip->stream = &vp->channel.mc_head->video_stream;
1286                 dip->config = pvr2_config_mpeg;
1287                 dip->minor_type = pvr2_v4l_type_radio;
1288                 nr_ptr = radio_nr;
1289                 break;
1290         default:
1291                 /* Bail out (this should be impossible) */
1292                 err("Failed to set up pvrusb2 v4l dev"
1293                     " due to unrecognized config");
1294                 return;
1295         }
1296
1297         memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
1298         dip->devbase.release = pvr2_video_device_release;
1299
1300         mindevnum = -1;
1301         unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1302         if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1303                 mindevnum = nr_ptr[unit_number];
1304         }
1305         if ((video_register_device(&dip->devbase,
1306                                    dip->v4l_type, mindevnum) < 0) &&
1307             (video_register_device(&dip->devbase,
1308                                    dip->v4l_type, -1) < 0)) {
1309                 err("Failed to register pvrusb2 v4l device");
1310         }
1311
1312         printk(KERN_INFO "pvrusb2: registered device %s%u [%s]\n",
1313                get_v4l_name(dip->v4l_type),dip->devbase.minor & 0x1f,
1314                pvr2_config_get_name(dip->config));
1315
1316         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1317                                         dip->minor_type,dip->devbase.minor);
1318 }
1319
1320
1321 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1322 {
1323         struct pvr2_v4l2 *vp;
1324
1325         vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1326         if (!vp) return vp;
1327         pvr2_channel_init(&vp->channel,mnp);
1328         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1329
1330         vp->channel.check_func = pvr2_v4l2_internal_check;
1331
1332         /* register streams */
1333         vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1334         if (!vp->dev_video) goto fail;
1335         pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1336         if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1337             (1 << PVR2_CVAL_INPUT_RADIO)) {
1338                 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1339                 if (!vp->dev_radio) goto fail;
1340                 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1341         }
1342
1343         return vp;
1344  fail:
1345         pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1346         pvr2_v4l2_destroy_no_lock(vp);
1347         return NULL;
1348 }
1349
1350 /*
1351   Stuff for Emacs to see, in order to encourage consistent editing style:
1352   *** Local Variables: ***
1353   *** mode: c ***
1354   *** fill-column: 75 ***
1355   *** tab-width: 8 ***
1356   *** c-basic-offset: 8 ***
1357   *** End: ***
1358   */