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

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