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