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