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