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

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