git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/pvrusb2/pvrusb2-v4l2.c

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