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         struct pvr2_ctrl *cptr;
 632         unsigned int idx;
 633         int val;
 634         int ret;
 635
 636         ret = 0;
 637         for (idx = 0; idx < ctls->count; idx++) {
 638                 ctrl = ctls->controls + idx;
 639                 cptr = pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id);
 640                 if (cptr) {
 641                         if (ctls->which == V4L2_CTRL_WHICH_DEF_VAL)
 642                                 pvr2_ctrl_get_def(cptr, &val);
 643                         else
 644                                 ret = pvr2_ctrl_get_value(cptr, &val);
 645                 } else
 646                         ret = -EINVAL;
 647
 648                 if (ret) {
 649                         ctls->error_idx = idx;
 650                         return ret;
 651                 }
 652                 /* Ensure that if read as a 64 bit value, the user
 653                    will still get a hopefully sane value */
 654                 ctrl->value64 = 0;
 655                 ctrl->value = val;
 656         }
 657         return 0;
 658 }
 659
 660 static int pvr2_s_ext_ctrls(struct file *file, void *priv,
 661                 struct v4l2_ext_controls *ctls)
 662 {
 663         struct pvr2_v4l2_fh *fh = file->private_data;
 664         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 665         struct v4l2_ext_control *ctrl;
 666         unsigned int idx;
 667         int ret;
 668
 669         /* Default value cannot be changed */
 670         if (ctls->which == V4L2_CTRL_WHICH_DEF_VAL)
 671                 return -EINVAL;
 672
 673         ret = 0;
 674         for (idx = 0; idx < ctls->count; idx++) {
 675                 ctrl = ctls->controls + idx;
 676                 ret = pvr2_ctrl_set_value(
 677                                 pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id),
 678                                 ctrl->value);
 679                 if (ret) {
 680                         ctls->error_idx = idx;
 681                         return ret;
 682                 }
 683         }
 684         return 0;
 685 }
 686
 687 static int pvr2_try_ext_ctrls(struct file *file, void *priv,
 688                 struct v4l2_ext_controls *ctls)
 689 {
 690         struct pvr2_v4l2_fh *fh = file->private_data;
 691         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 692         struct v4l2_ext_control *ctrl;
 693         struct pvr2_ctrl *pctl;
 694         unsigned int idx;
 695
 696         /* For the moment just validate that the requested control
 697            actually exists. */
 698         for (idx = 0; idx < ctls->count; idx++) {
 699                 ctrl = ctls->controls + idx;
 700                 pctl = pvr2_hdw_get_ctrl_v4l(hdw, ctrl->id);
 701                 if (!pctl) {
 702                         ctls->error_idx = idx;
 703                         return -EINVAL;
 704                 }
 705         }
 706         return 0;
 707 }
 708
 709 static int pvr2_cropcap(struct file *file, void *priv, struct v4l2_cropcap *cap)
 710 {
 711         struct pvr2_v4l2_fh *fh = file->private_data;
 712         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 713         int ret;
 714
 715         if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 716                 return -EINVAL;
 717         ret = pvr2_hdw_get_cropcap(hdw, cap);
 718         cap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* paranoia */
 719         return ret;
 720 }
 721
 722 static int pvr2_g_selection(struct file *file, void *priv,
 723                             struct v4l2_selection *sel)
 724 {
 725         struct pvr2_v4l2_fh *fh = file->private_data;
 726         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 727         struct v4l2_cropcap cap;
 728         int val = 0;
 729         int ret;
 730
 731         if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 732                 return -EINVAL;
 733
 734         cap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 735
 736         switch (sel->target) {
 737         case V4L2_SEL_TGT_CROP:
 738                 ret = pvr2_ctrl_get_value(
 739                           pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL), &val);
 740                 if (ret != 0)
 741                         return -EINVAL;
 742                 sel->r.left = val;
 743                 ret = pvr2_ctrl_get_value(
 744                           pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT), &val);
 745                 if (ret != 0)
 746                         return -EINVAL;
 747                 sel->r.top = val;
 748                 ret = pvr2_ctrl_get_value(
 749                           pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW), &val);
 750                 if (ret != 0)
 751                         return -EINVAL;
 752                 sel->r.width = val;
 753                 ret = pvr2_ctrl_get_value(
 754                           pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH), &val);
 755                 if (ret != 0)
 756                         return -EINVAL;
 757                 sel->r.height = val;
 758                 break;
 759         case V4L2_SEL_TGT_CROP_DEFAULT:
 760                 ret = pvr2_hdw_get_cropcap(hdw, &cap);
 761                 sel->r = cap.defrect;
 762                 break;
 763         case V4L2_SEL_TGT_CROP_BOUNDS:
 764                 ret = pvr2_hdw_get_cropcap(hdw, &cap);
 765                 sel->r = cap.bounds;
 766                 break;
 767         default:
 768                 return -EINVAL;
 769         }
 770         return ret;
 771 }
 772
 773 static int pvr2_s_selection(struct file *file, void *priv,
 774                             struct v4l2_selection *sel)
 775 {
 776         struct pvr2_v4l2_fh *fh = file->private_data;
 777         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 778         int ret;
 779
 780         if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 781             sel->target != V4L2_SEL_TGT_CROP)
 782                 return -EINVAL;
 783         ret = pvr2_ctrl_set_value(
 784                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPL),
 785                         sel->r.left);
 786         if (ret != 0)
 787                 return -EINVAL;
 788         ret = pvr2_ctrl_set_value(
 789                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPT),
 790                         sel->r.top);
 791         if (ret != 0)
 792                 return -EINVAL;
 793         ret = pvr2_ctrl_set_value(
 794                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPW),
 795                         sel->r.width);
 796         if (ret != 0)
 797                 return -EINVAL;
 798         ret = pvr2_ctrl_set_value(
 799                         pvr2_hdw_get_ctrl_by_id(hdw, PVR2_CID_CROPH),
 800                         sel->r.height);
 801         if (ret != 0)
 802                 return -EINVAL;
 803         return 0;
 804 }
 805
 806 static int pvr2_log_status(struct file *file, void *priv)
 807 {
 808         struct pvr2_v4l2_fh *fh = file->private_data;
 809         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 810
 811         pvr2_hdw_trigger_module_log(hdw);
 812         return 0;
 813 }
 814
 815 static const struct v4l2_ioctl_ops pvr2_ioctl_ops = {
 816         .vidioc_querycap                    = pvr2_querycap,
 817         .vidioc_s_audio                     = pvr2_s_audio,
 818         .vidioc_g_audio                     = pvr2_g_audio,
 819         .vidioc_enumaudio                   = pvr2_enumaudio,
 820         .vidioc_enum_input                  = pvr2_enum_input,
 821         .vidioc_cropcap                     = pvr2_cropcap,
 822         .vidioc_s_selection                 = pvr2_s_selection,
 823         .vidioc_g_selection                 = pvr2_g_selection,
 824         .vidioc_g_input                     = pvr2_g_input,
 825         .vidioc_s_input                     = pvr2_s_input,
 826         .vidioc_g_frequency                 = pvr2_g_frequency,
 827         .vidioc_s_frequency                 = pvr2_s_frequency,
 828         .vidioc_s_tuner                     = pvr2_s_tuner,
 829         .vidioc_g_tuner                     = pvr2_g_tuner,
 830         .vidioc_g_std                       = pvr2_g_std,
 831         .vidioc_s_std                       = pvr2_s_std,
 832         .vidioc_querystd                    = pvr2_querystd,
 833         .vidioc_log_status                  = pvr2_log_status,
 834         .vidioc_enum_fmt_vid_cap            = pvr2_enum_fmt_vid_cap,
 835         .vidioc_g_fmt_vid_cap               = pvr2_g_fmt_vid_cap,
 836         .vidioc_s_fmt_vid_cap               = pvr2_s_fmt_vid_cap,
 837         .vidioc_try_fmt_vid_cap             = pvr2_try_fmt_vid_cap,
 838         .vidioc_streamon                    = pvr2_streamon,
 839         .vidioc_streamoff                   = pvr2_streamoff,
 840         .vidioc_queryctrl                   = pvr2_queryctrl,
 841         .vidioc_querymenu                   = pvr2_querymenu,
 842         .vidioc_g_ctrl                      = pvr2_g_ctrl,
 843         .vidioc_s_ctrl                      = pvr2_s_ctrl,
 844         .vidioc_g_ext_ctrls                 = pvr2_g_ext_ctrls,
 845         .vidioc_s_ext_ctrls                 = pvr2_s_ext_ctrls,
 846         .vidioc_try_ext_ctrls               = pvr2_try_ext_ctrls,
 847 };
 848
 849 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
 850 {
 851         struct pvr2_hdw *hdw = dip->v4lp->channel.mc_head->hdw;
 852         enum pvr2_config cfg = dip->config;
 853         char msg[80];
 854         unsigned int mcnt;
 855
 856         /* Construct the unregistration message *before* we actually
 857            perform the unregistration step.  By doing it this way we don't
 858            have to worry about potentially touching deleted resources. */
 859         mcnt = scnprintf(msg, sizeof(msg) - 1,
 860                          "pvrusb2: unregistered device %s [%s]",
 861                          video_device_node_name(&dip->devbase),
 862                          pvr2_config_get_name(cfg));
 863         msg[mcnt] = 0;
 864
 865         pvr2_hdw_v4l_store_minor_number(hdw,dip->minor_type,-1);
 866
 867         /* Paranoia */
 868         dip->v4lp = NULL;
 869         dip->stream = NULL;
 870
 871         /* Actual deallocation happens later when all internal references
 872            are gone. */
 873         video_unregister_device(&dip->devbase);
 874
 875         printk(KERN_INFO "%s\n", msg);
 876
 877 }
 878
 879
 880 static void pvr2_v4l2_dev_disassociate_parent(struct pvr2_v4l2_dev *dip)
 881 {
 882         if (!dip) return;
 883         if (!dip->devbase.v4l2_dev->dev) return;
 884         dip->devbase.v4l2_dev->dev = NULL;
 885         device_move(&dip->devbase.dev, NULL, DPM_ORDER_NONE);
 886 }
 887
 888
 889 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
 890 {
 891         if (vp->dev_video) {
 892                 pvr2_v4l2_dev_destroy(vp->dev_video);
 893                 vp->dev_video = NULL;
 894         }
 895         if (vp->dev_radio) {
 896                 pvr2_v4l2_dev_destroy(vp->dev_radio);
 897                 vp->dev_radio = NULL;
 898         }
 899
 900         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
 901         pvr2_channel_done(&vp->channel);
 902         kfree(vp);
 903 }
 904
 905
 906 static void pvr2_video_device_release(struct video_device *vdev)
 907 {
 908         struct pvr2_v4l2_dev *dev;
 909         dev = container_of(vdev,struct pvr2_v4l2_dev,devbase);
 910         kfree(dev);
 911 }
 912
 913
 914 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
 915 {
 916         struct pvr2_v4l2 *vp;
 917         vp = container_of(chp,struct pvr2_v4l2,channel);
 918         if (!vp->channel.mc_head->disconnect_flag) return;
 919         pvr2_v4l2_dev_disassociate_parent(vp->dev_video);
 920         pvr2_v4l2_dev_disassociate_parent(vp->dev_radio);
 921         if (!list_empty(&vp->dev_video->devbase.fh_list) ||
 922             (vp->dev_radio &&
 923              !list_empty(&vp->dev_radio->devbase.fh_list))) {
 924                 pvr2_trace(PVR2_TRACE_STRUCT,
 925                            "pvr2_v4l2 internal_check exit-empty id=%p", vp);
 926                 return;
 927         }
 928         pvr2_v4l2_destroy_no_lock(vp);
 929 }
 930
 931
 932 static long pvr2_v4l2_ioctl(struct file *file,
 933                            unsigned int cmd, unsigned long arg)
 934 {
 935
 936         struct pvr2_v4l2_fh *fh = file->private_data;
 937         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 938         long ret = -EINVAL;
 939
 940         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL)
 941                 v4l_printk_ioctl(pvr2_hdw_get_driver_name(hdw), cmd);
 942
 943         if (!pvr2_hdw_dev_ok(hdw)) {
 944                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 945                            "ioctl failed - bad or no context");
 946                 return -EFAULT;
 947         }
 948
 949         ret = video_ioctl2(file, cmd, arg);
 950
 951         pvr2_hdw_commit_ctl(hdw);
 952
 953         if (ret < 0) {
 954                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 955                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 956                                    "pvr2_v4l2_do_ioctl failure, ret=%ld"
 957                                    " command was:", ret);
 958                         v4l_printk_ioctl(pvr2_hdw_get_driver_name(hdw), cmd);
 959                 }
 960         } else {
 961                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 962                            "pvr2_v4l2_do_ioctl complete, ret=%ld (0x%lx)",
 963                            ret, ret);
 964         }
 965         return ret;
 966
 967 }
 968
 969
 970 static int pvr2_v4l2_release(struct file *file)
 971 {
 972         struct pvr2_v4l2_fh *fhp = file->private_data;
 973         struct pvr2_v4l2 *vp = fhp->pdi->v4lp;
 974         struct pvr2_hdw *hdw = fhp->channel.mc_head->hdw;
 975
 976         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
 977
 978         if (fhp->rhp) {
 979                 struct pvr2_stream *sp;
 980                 pvr2_hdw_set_streaming(hdw,0);
 981                 sp = pvr2_ioread_get_stream(fhp->rhp);
 982                 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
 983                 pvr2_ioread_destroy(fhp->rhp);
 984                 fhp->rhp = NULL;
 985         }
 986
 987         v4l2_fh_del(&fhp->fh);
 988         v4l2_fh_exit(&fhp->fh);
 989         file->private_data = NULL;
 990
 991         pvr2_channel_done(&fhp->channel);
 992         pvr2_trace(PVR2_TRACE_STRUCT,
 993                    "Destroying pvr_v4l2_fh id=%p",fhp);
 994         if (fhp->input_map) {
 995                 kfree(fhp->input_map);
 996                 fhp->input_map = NULL;
 997         }
 998         kfree(fhp);
 999         if (vp->channel.mc_head->disconnect_flag &&
1000             list_empty(&vp->dev_video->devbase.fh_list) &&
1001             (!vp->dev_radio ||
1002              list_empty(&vp->dev_radio->devbase.fh_list))) {
1003                 pvr2_v4l2_destroy_no_lock(vp);
1004         }
1005         return 0;
1006 }
1007
1008
1009 static int pvr2_v4l2_open(struct file *file)
1010 {
1011         struct pvr2_v4l2_dev *dip; /* Our own context pointer */
1012         struct pvr2_v4l2_fh *fhp;
1013         struct pvr2_v4l2 *vp;
1014         struct pvr2_hdw *hdw;
1015         unsigned int input_mask = 0;
1016         unsigned int input_cnt,idx;
1017         int ret = 0;
1018
1019         dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase);
1020
1021         vp = dip->v4lp;
1022         hdw = vp->channel.hdw;
1023
1024         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
1025
1026         if (!pvr2_hdw_dev_ok(hdw)) {
1027                 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
1028                            "pvr2_v4l2_open: hardware not ready");
1029                 return -EIO;
1030         }
1031
1032         fhp = kzalloc(sizeof(*fhp),GFP_KERNEL);
1033         if (!fhp) {
1034                 return -ENOMEM;
1035         }
1036
1037         v4l2_fh_init(&fhp->fh, &dip->devbase);
1038         init_waitqueue_head(&fhp->wait_data);
1039         fhp->pdi = dip;
1040
1041         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
1042         pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
1043
1044         if (dip->v4l_type == VFL_TYPE_RADIO) {
1045                 /* Opening device as a radio, legal input selection subset
1046                    is just the radio. */
1047                 input_mask = (1 << PVR2_CVAL_INPUT_RADIO);
1048         } else {
1049                 /* Opening the main V4L device, legal input selection
1050                    subset includes all analog inputs. */
1051                 input_mask = ((1 << PVR2_CVAL_INPUT_RADIO) |
1052                               (1 << PVR2_CVAL_INPUT_TV) |
1053                               (1 << PVR2_CVAL_INPUT_COMPOSITE) |
1054                               (1 << PVR2_CVAL_INPUT_SVIDEO));
1055         }
1056         ret = pvr2_channel_limit_inputs(&fhp->channel,input_mask);
1057         if (ret) {
1058                 pvr2_channel_done(&fhp->channel);
1059                 pvr2_trace(PVR2_TRACE_STRUCT,
1060                            "Destroying pvr_v4l2_fh id=%p (input mask error)",
1061                            fhp);
1062
1063                 kfree(fhp);
1064                 return ret;
1065         }
1066
1067         input_mask &= pvr2_hdw_get_input_available(hdw);
1068         input_cnt = 0;
1069         for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1070                 if (input_mask & (1 << idx)) input_cnt++;
1071         }
1072         fhp->input_cnt = input_cnt;
1073         fhp->input_map = kzalloc(input_cnt,GFP_KERNEL);
1074         if (!fhp->input_map) {
1075                 pvr2_channel_done(&fhp->channel);
1076                 pvr2_trace(PVR2_TRACE_STRUCT,
1077                            "Destroying pvr_v4l2_fh id=%p (input map failure)",
1078                            fhp);
1079                 kfree(fhp);
1080                 return -ENOMEM;
1081         }
1082         input_cnt = 0;
1083         for (idx = 0; idx < (sizeof(input_mask) << 3); idx++) {
1084                 if (!(input_mask & (1 << idx))) continue;
1085                 fhp->input_map[input_cnt++] = idx;
1086         }
1087
1088         fhp->file = file;
1089         file->private_data = fhp;
1090
1091         fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
1092         v4l2_fh_add(&fhp->fh);
1093
1094         return 0;
1095 }
1096
1097
1098 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
1099 {
1100         wake_up(&fhp->wait_data);
1101 }
1102
1103 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
1104 {
1105         int ret;
1106         struct pvr2_stream *sp;
1107         struct pvr2_hdw *hdw;
1108         if (fh->rhp) return 0;
1109
1110         if (!fh->pdi->stream) {
1111                 /* No stream defined for this node.  This means that we're
1112                    not currently allowed to stream from this node. */
1113                 return -EPERM;
1114         }
1115
1116         /* First read() attempt.  Try to claim the stream and start
1117            it... */
1118         if ((ret = pvr2_channel_claim_stream(&fh->channel,
1119                                              fh->pdi->stream)) != 0) {
1120                 /* Someone else must already have it */
1121                 return ret;
1122         }
1123
1124         fh->rhp = pvr2_channel_create_mpeg_stream(fh->pdi->stream);
1125         if (!fh->rhp) {
1126                 pvr2_channel_claim_stream(&fh->channel,NULL);
1127                 return -ENOMEM;
1128         }
1129
1130         hdw = fh->channel.mc_head->hdw;
1131         sp = fh->pdi->stream->stream;
1132         pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
1133         pvr2_hdw_set_stream_type(hdw,fh->pdi->config);
1134         if ((ret = pvr2_hdw_set_streaming(hdw,!0)) < 0) return ret;
1135         return pvr2_ioread_set_enabled(fh->rhp,!0);
1136 }
1137
1138
1139 static ssize_t pvr2_v4l2_read(struct file *file,
1140                               char __user *buff, size_t count, loff_t *ppos)
1141 {
1142         struct pvr2_v4l2_fh *fh = file->private_data;
1143         int ret;
1144
1145         if (fh->fw_mode_flag) {
1146                 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
1147                 char *tbuf;
1148                 int c1,c2;
1149                 int tcnt = 0;
1150                 unsigned int offs = *ppos;
1151
1152                 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
1153                 if (!tbuf) return -ENOMEM;
1154
1155                 while (count) {
1156                         c1 = count;
1157                         if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
1158                         c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
1159                         if (c2 < 0) {
1160                                 tcnt = c2;
1161                                 break;
1162                         }
1163                         if (!c2) break;
1164                         if (copy_to_user(buff,tbuf,c2)) {
1165                                 tcnt = -EFAULT;
1166                                 break;
1167                         }
1168                         offs += c2;
1169                         tcnt += c2;
1170                         buff += c2;
1171                         count -= c2;
1172                         *ppos += c2;
1173                 }
1174                 kfree(tbuf);
1175                 return tcnt;
1176         }
1177
1178         if (!fh->rhp) {
1179                 ret = pvr2_v4l2_iosetup(fh);
1180                 if (ret) {
1181                         return ret;
1182                 }
1183         }
1184
1185         for (;;) {
1186                 ret = pvr2_ioread_read(fh->rhp,buff,count);
1187                 if (ret >= 0) break;
1188                 if (ret != -EAGAIN) break;
1189                 if (file->f_flags & O_NONBLOCK) break;
1190                 /* Doing blocking I/O.  Wait here. */
1191                 ret = wait_event_interruptible(
1192                         fh->wait_data,
1193                         pvr2_ioread_avail(fh->rhp) >= 0);
1194                 if (ret < 0) break;
1195         }
1196
1197         return ret;
1198 }
1199
1200
1201 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
1202 {
1203         unsigned int mask = 0;
1204         struct pvr2_v4l2_fh *fh = file->private_data;
1205         int ret;
1206
1207         if (fh->fw_mode_flag) {
1208                 mask |= POLLIN | POLLRDNORM;
1209                 return mask;
1210         }
1211
1212         if (!fh->rhp) {
1213                 ret = pvr2_v4l2_iosetup(fh);
1214                 if (ret) return POLLERR;
1215         }
1216
1217         poll_wait(file,&fh->wait_data,wait);
1218
1219         if (pvr2_ioread_avail(fh->rhp) >= 0) {
1220                 mask |= POLLIN | POLLRDNORM;
1221         }
1222
1223         return mask;
1224 }
1225
1226
1227 static const struct v4l2_file_operations vdev_fops = {
1228         .owner      = THIS_MODULE,
1229         .open       = pvr2_v4l2_open,
1230         .release    = pvr2_v4l2_release,
1231         .read       = pvr2_v4l2_read,
1232         .unlocked_ioctl = pvr2_v4l2_ioctl,
1233         .poll       = pvr2_v4l2_poll,
1234 };
1235
1236
1237 static struct video_device vdev_template = {
1238         .fops       = &vdev_fops,
1239 };
1240
1241
1242 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1243                                struct pvr2_v4l2 *vp,
1244                                int v4l_type)
1245 {
1246         int mindevnum;
1247         int unit_number;
1248         struct pvr2_hdw *hdw;
1249         int *nr_ptr = NULL;
1250         dip->v4lp = vp;
1251
1252         hdw = vp->channel.mc_head->hdw;
1253         dip->v4l_type = v4l_type;
1254         switch (v4l_type) {
1255         case VFL_TYPE_GRABBER:
1256                 dip->stream = &vp->channel.mc_head->video_stream;
1257                 dip->config = pvr2_config_mpeg;
1258                 dip->minor_type = pvr2_v4l_type_video;
1259                 nr_ptr = video_nr;
1260                 if (!dip->stream) {
1261                         pr_err(KBUILD_MODNAME
1262                                 ": Failed to set up pvrusb2 v4l video dev"
1263                                 " due to missing stream instance\n");
1264                         return;
1265                 }
1266                 break;
1267         case VFL_TYPE_VBI:
1268                 dip->config = pvr2_config_vbi;
1269                 dip->minor_type = pvr2_v4l_type_vbi;
1270                 nr_ptr = vbi_nr;
1271                 break;
1272         case VFL_TYPE_RADIO:
1273                 dip->stream = &vp->channel.mc_head->video_stream;
1274                 dip->config = pvr2_config_mpeg;
1275                 dip->minor_type = pvr2_v4l_type_radio;
1276                 nr_ptr = radio_nr;
1277                 break;
1278         default:
1279                 /* Bail out (this should be impossible) */
1280                 pr_err(KBUILD_MODNAME ": Failed to set up pvrusb2 v4l dev"
1281                     " due to unrecognized config\n");
1282                 return;
1283         }
1284
1285         dip->devbase = vdev_template;
1286         dip->devbase.release = pvr2_video_device_release;
1287         dip->devbase.ioctl_ops = &pvr2_ioctl_ops;
1288         {
1289                 int val;
1290                 pvr2_ctrl_get_value(
1291                         pvr2_hdw_get_ctrl_by_id(hdw,
1292                                                 PVR2_CID_STDAVAIL), &val);
1293                 dip->devbase.tvnorms = (v4l2_std_id)val;
1294         }
1295
1296         mindevnum = -1;
1297         unit_number = pvr2_hdw_get_unit_number(hdw);
1298         if (nr_ptr && (unit_number >= 0) && (unit_number < PVR_NUM)) {
1299                 mindevnum = nr_ptr[unit_number];
1300         }
1301         pvr2_hdw_set_v4l2_dev(hdw, &dip->devbase);
1302         if ((video_register_device(&dip->devbase,
1303                                    dip->v4l_type, mindevnum) < 0) &&
1304             (video_register_device(&dip->devbase,
1305                                    dip->v4l_type, -1) < 0)) {
1306                 pr_err(KBUILD_MODNAME
1307                         ": Failed to register pvrusb2 v4l device\n");
1308         }
1309
1310         printk(KERN_INFO "pvrusb2: registered device %s [%s]\n",
1311                video_device_node_name(&dip->devbase),
1312                pvr2_config_get_name(dip->config));
1313
1314         pvr2_hdw_v4l_store_minor_number(hdw,
1315                                         dip->minor_type,dip->devbase.minor);
1316 }
1317
1318
1319 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1320 {
1321         struct pvr2_v4l2 *vp;
1322
1323         vp = kzalloc(sizeof(*vp),GFP_KERNEL);
1324         if (!vp) return vp;
1325         pvr2_channel_init(&vp->channel,mnp);
1326         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1327
1328         vp->channel.check_func = pvr2_v4l2_internal_check;
1329
1330         /* register streams */
1331         vp->dev_video = kzalloc(sizeof(*vp->dev_video),GFP_KERNEL);
1332         if (!vp->dev_video) goto fail;
1333         pvr2_v4l2_dev_init(vp->dev_video,vp,VFL_TYPE_GRABBER);
1334         if (pvr2_hdw_get_input_available(vp->channel.mc_head->hdw) &
1335             (1 << PVR2_CVAL_INPUT_RADIO)) {
1336                 vp->dev_radio = kzalloc(sizeof(*vp->dev_radio),GFP_KERNEL);
1337                 if (!vp->dev_radio) goto fail;
1338                 pvr2_v4l2_dev_init(vp->dev_radio,vp,VFL_TYPE_RADIO);
1339         }
1340
1341         return vp;
1342  fail:
1343         pvr2_trace(PVR2_TRACE_STRUCT,"Failure creating pvr2_v4l2 id=%p",vp);
1344         pvr2_v4l2_destroy_no_lock(vp);
1345         return NULL;
1346 }