git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/pvrusb2/pvrusb2-v4l2.c

   1 /*
   2  *
   3  *  $Id$
   4  *
   5  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   6  *  Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23 #include <linux/kernel.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 <media/v4l2-common.h>
  33
  34 struct pvr2_v4l2_dev;
  35 struct pvr2_v4l2_fh;
  36 struct pvr2_v4l2;
  37
  38 /* V4L no longer provide the ability to set / get a private context pointer
  39    (i.e. video_get_drvdata / video_set_drvdata), which means we have to
  40    concoct our own context locating mechanism.  Supposedly this is intended
  41    to simplify driver implementation.  It's not clear to me how that can
  42    possibly be true.  Our solution here is to maintain a lookup table of
  43    our context instances, indexed by the minor device number of the V4L
  44    device.  See pvr2_v4l2_open() for some implications of this approach. */
  45 static struct pvr2_v4l2_dev *devices[256];
  46 static DEFINE_MUTEX(device_lock);
  47
  48 struct pvr2_v4l2_dev {
  49         struct pvr2_v4l2 *v4lp;
  50         struct video_device *vdev;
  51         struct pvr2_context_stream *stream;
  52         int ctxt_idx;
  53         enum pvr2_config config;
  54 };
  55
  56 struct pvr2_v4l2_fh {
  57         struct pvr2_channel channel;
  58         struct pvr2_v4l2_dev *dev_info;
  59         enum v4l2_priority prio;
  60         struct pvr2_ioread *rhp;
  61         struct file *file;
  62         struct pvr2_v4l2 *vhead;
  63         struct pvr2_v4l2_fh *vnext;
  64         struct pvr2_v4l2_fh *vprev;
  65         wait_queue_head_t wait_data;
  66         int fw_mode_flag;
  67 };
  68
  69 struct pvr2_v4l2 {
  70         struct pvr2_channel channel;
  71         struct pvr2_v4l2_fh *vfirst;
  72         struct pvr2_v4l2_fh *vlast;
  73
  74         struct v4l2_prio_state prio;
  75
  76         /* streams */
  77         struct pvr2_v4l2_dev video_dev;
  78 };
  79
  80 static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1};
  81 module_param_array(video_nr, int, NULL, 0444);
  82 MODULE_PARM_DESC(video_nr, "Offset for device's minor");
  83
  84 static struct v4l2_capability pvr_capability ={
  85         .driver         = "pvrusb2",
  86         .card           = "Hauppauge WinTV pvr-usb2",
  87         .bus_info       = "usb",
  88         .version        = KERNEL_VERSION(0,8,0),
  89         .capabilities   = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE |
  90                            V4L2_CAP_TUNER | V4L2_CAP_AUDIO |
  91                            V4L2_CAP_READWRITE),
  92         .reserved       = {0,0,0,0}
  93 };
  94
  95 static struct v4l2_tuner pvr_v4l2_tuners[]= {
  96         {
  97                 .index      = 0,
  98                 .name       = "TV Tuner",
  99                 .type           = V4L2_TUNER_ANALOG_TV,
 100                 .capability     = (V4L2_TUNER_CAP_NORM |
 101                                    V4L2_TUNER_CAP_STEREO |
 102                                    V4L2_TUNER_CAP_LANG1 |
 103                                    V4L2_TUNER_CAP_LANG2),
 104                 .rangelow   = 0,
 105                 .rangehigh  = 0,
 106                 .rxsubchans     = V4L2_TUNER_SUB_STEREO,
 107                 .audmode        = V4L2_TUNER_MODE_STEREO,
 108                 .signal         = 0,
 109                 .afc            = 0,
 110                 .reserved       = {0,0,0,0}
 111         }
 112 };
 113
 114 static struct v4l2_fmtdesc pvr_fmtdesc [] = {
 115         {
 116                 .index          = 0,
 117                 .type           = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 118                 .flags          = V4L2_FMT_FLAG_COMPRESSED,
 119                 .description    = "MPEG1/2",
 120                 // This should really be V4L2_PIX_FMT_MPEG, but xawtv
 121                 // breaks when I do that.
 122                 .pixelformat    = 0, // V4L2_PIX_FMT_MPEG,
 123                 .reserved       = { 0, 0, 0, 0 }
 124         }
 125 };
 126
 127 #define PVR_FORMAT_PIX  0
 128 #define PVR_FORMAT_VBI  1
 129
 130 static struct v4l2_format pvr_format [] = {
 131         [PVR_FORMAT_PIX] = {
 132                 .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 133                 .fmt    = {
 134                         .pix        = {
 135                                 .width          = 720,
 136                                 .height             = 576,
 137                                 // This should really be V4L2_PIX_FMT_MPEG,
 138                                 // but xawtv breaks when I do that.
 139                                 .pixelformat    = 0, // V4L2_PIX_FMT_MPEG,
 140                                 .field          = V4L2_FIELD_INTERLACED,
 141                                 .bytesperline   = 0,  // doesn't make sense
 142                                                       // here
 143                                 //FIXME : Don't know what to put here...
 144                                 .sizeimage          = (32*1024),
 145                                 .colorspace     = 0, // doesn't make sense here
 146                                 .priv           = 0
 147                         }
 148                 }
 149         },
 150         [PVR_FORMAT_VBI] = {
 151                 .type   = V4L2_BUF_TYPE_VBI_CAPTURE,
 152                 .fmt    = {
 153                         .vbi        = {
 154                                 .sampling_rate = 27000000,
 155                                 .offset = 248,
 156                                 .samples_per_line = 1443,
 157                                 .sample_format = V4L2_PIX_FMT_GREY,
 158                                 .start = { 0, 0 },
 159                                 .count = { 0, 0 },
 160                                 .flags = 0,
 161                                 .reserved = { 0, 0 }
 162                         }
 163                 }
 164         }
 165 };
 166
 167 /*
 168  * pvr_ioctl()
 169  *
 170  * This is part of Video 4 Linux API. The procedure handles ioctl() calls.
 171  *
 172  */
 173 static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file,
 174                               unsigned int cmd, void *arg)
 175 {
 176         struct pvr2_v4l2_fh *fh = file->private_data;
 177         struct pvr2_v4l2 *vp = fh->vhead;
 178         struct pvr2_v4l2_dev *dev_info = fh->dev_info;
 179         struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 180         int ret = -EINVAL;
 181
 182         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 183                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),cmd);
 184         }
 185
 186         if (!pvr2_hdw_dev_ok(hdw)) {
 187                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 188                            "ioctl failed - bad or no context");
 189                 return -EFAULT;
 190         }
 191
 192         /* check priority */
 193         switch (cmd) {
 194         case VIDIOC_S_CTRL:
 195         case VIDIOC_S_STD:
 196         case VIDIOC_S_INPUT:
 197         case VIDIOC_S_TUNER:
 198         case VIDIOC_S_FREQUENCY:
 199                 ret = v4l2_prio_check(&vp->prio, &fh->prio);
 200                 if (ret)
 201                         return ret;
 202         }
 203
 204         switch (cmd) {
 205         case VIDIOC_QUERYCAP:
 206         {
 207                 struct v4l2_capability *cap = arg;
 208
 209                 memcpy(cap, &pvr_capability, sizeof(struct v4l2_capability));
 210
 211                 ret = 0;
 212                 break;
 213         }
 214
 215         case VIDIOC_G_PRIORITY:
 216         {
 217                 enum v4l2_priority *p = arg;
 218
 219                 *p = v4l2_prio_max(&vp->prio);
 220                 ret = 0;
 221                 break;
 222         }
 223
 224         case VIDIOC_S_PRIORITY:
 225         {
 226                 enum v4l2_priority *prio = arg;
 227
 228                 ret = v4l2_prio_change(&vp->prio, &fh->prio, *prio);
 229                 break;
 230         }
 231
 232         case VIDIOC_ENUMSTD:
 233         {
 234                 struct v4l2_standard *vs = (struct v4l2_standard *)arg;
 235                 int idx = vs->index;
 236                 ret = pvr2_hdw_get_stdenum_value(hdw,vs,idx+1);
 237                 break;
 238         }
 239
 240         case VIDIOC_G_STD:
 241         {
 242                 int val = 0;
 243                 ret = pvr2_ctrl_get_value(
 244                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),&val);
 245                 *(v4l2_std_id *)arg = val;
 246                 break;
 247         }
 248
 249         case VIDIOC_S_STD:
 250         {
 251                 ret = pvr2_ctrl_set_value(
 252                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_STDCUR),
 253                         *(v4l2_std_id *)arg);
 254                 break;
 255         }
 256
 257         case VIDIOC_ENUMINPUT:
 258         {
 259                 struct pvr2_ctrl *cptr;
 260                 struct v4l2_input *vi = (struct v4l2_input *)arg;
 261                 struct v4l2_input tmp;
 262                 unsigned int cnt;
 263
 264                 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
 265
 266                 memset(&tmp,0,sizeof(tmp));
 267                 tmp.index = vi->index;
 268                 ret = 0;
 269                 switch (vi->index) {
 270                 case PVR2_CVAL_INPUT_TV:
 271                 case PVR2_CVAL_INPUT_RADIO:
 272                         tmp.type = V4L2_INPUT_TYPE_TUNER;
 273                         break;
 274                 case PVR2_CVAL_INPUT_SVIDEO:
 275                 case PVR2_CVAL_INPUT_COMPOSITE:
 276                         tmp.type = V4L2_INPUT_TYPE_CAMERA;
 277                         break;
 278                 default:
 279                         ret = -EINVAL;
 280                         break;
 281                 }
 282                 if (ret < 0) break;
 283
 284                 cnt = 0;
 285                 pvr2_ctrl_get_valname(cptr,vi->index,
 286                                       tmp.name,sizeof(tmp.name)-1,&cnt);
 287                 tmp.name[cnt] = 0;
 288
 289                 /* Don't bother with audioset, since this driver currently
 290                    always switches the audio whenever the video is
 291                    switched. */
 292
 293                 /* Handling std is a tougher problem.  It doesn't make
 294                    sense in cases where a device might be multi-standard.
 295                    We could just copy out the current value for the
 296                    standard, but it can change over time.  For now just
 297                    leave it zero. */
 298
 299                 memcpy(vi, &tmp, sizeof(tmp));
 300
 301                 ret = 0;
 302                 break;
 303         }
 304
 305         case VIDIOC_G_INPUT:
 306         {
 307                 struct pvr2_ctrl *cptr;
 308                 struct v4l2_input *vi = (struct v4l2_input *)arg;
 309                 int val;
 310                 cptr = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT);
 311                 val = 0;
 312                 ret = pvr2_ctrl_get_value(cptr,&val);
 313                 vi->index = val;
 314                 break;
 315         }
 316
 317         case VIDIOC_S_INPUT:
 318         {
 319                 struct v4l2_input *vi = (struct v4l2_input *)arg;
 320                 ret = pvr2_ctrl_set_value(
 321                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_INPUT),
 322                         vi->index);
 323                 break;
 324         }
 325
 326         case VIDIOC_ENUMAUDIO:
 327         {
 328                 ret = -EINVAL;
 329                 break;
 330         }
 331
 332         case VIDIOC_G_AUDIO:
 333         {
 334                 ret = -EINVAL;
 335                 break;
 336         }
 337
 338         case VIDIOC_S_AUDIO:
 339         {
 340                 ret = -EINVAL;
 341                 break;
 342         }
 343         case VIDIOC_G_TUNER:
 344         {
 345                 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
 346                 unsigned int status_mask;
 347                 int val;
 348                 if (vt->index !=0) break;
 349
 350                 status_mask = pvr2_hdw_get_signal_status(hdw);
 351
 352                 memcpy(vt, &pvr_v4l2_tuners[vt->index],
 353                        sizeof(struct v4l2_tuner));
 354
 355                 vt->signal = 0;
 356                 if (status_mask & PVR2_SIGNAL_OK) {
 357                         if (status_mask & PVR2_SIGNAL_STEREO) {
 358                                 vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
 359                         } else {
 360                                 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
 361                         }
 362                         if (status_mask & PVR2_SIGNAL_SAP) {
 363                                 vt->rxsubchans |= (V4L2_TUNER_SUB_LANG1 |
 364                                                    V4L2_TUNER_SUB_LANG2);
 365                         }
 366                         vt->signal = 65535;
 367                 }
 368
 369                 val = 0;
 370                 ret = pvr2_ctrl_get_value(
 371                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
 372                         &val);
 373                 vt->audmode = val;
 374                 break;
 375         }
 376
 377         case VIDIOC_S_TUNER:
 378         {
 379                 struct v4l2_tuner *vt=(struct v4l2_tuner *)arg;
 380
 381                 if (vt->index != 0)
 382                         break;
 383
 384                 ret = pvr2_ctrl_set_value(
 385                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_AUDIOMODE),
 386                         vt->audmode);
 387         }
 388
 389         case VIDIOC_S_FREQUENCY:
 390         {
 391                 const struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
 392                 ret = pvr2_ctrl_set_value(
 393                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
 394                         vf->frequency * 62500);
 395                 break;
 396         }
 397
 398         case VIDIOC_G_FREQUENCY:
 399         {
 400                 struct v4l2_frequency *vf = (struct v4l2_frequency *)arg;
 401                 int val = 0;
 402                 ret = pvr2_ctrl_get_value(
 403                         pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_FREQUENCY),
 404                         &val);
 405                 val /= 62500;
 406                 vf->frequency = val;
 407                 break;
 408         }
 409
 410         case VIDIOC_ENUM_FMT:
 411         {
 412                 struct v4l2_fmtdesc *fd = (struct v4l2_fmtdesc *)arg;
 413
 414                 /* Only one format is supported : mpeg.*/
 415                 if (fd->index != 0)
 416                         break;
 417
 418                 memcpy(fd, pvr_fmtdesc, sizeof(struct v4l2_fmtdesc));
 419                 ret = 0;
 420                 break;
 421         }
 422
 423         case VIDIOC_G_FMT:
 424         {
 425                 struct v4l2_format *vf = (struct v4l2_format *)arg;
 426                 int val;
 427                 switch(vf->type) {
 428                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 429                         memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
 430                                sizeof(struct v4l2_format));
 431                         val = 0;
 432                         pvr2_ctrl_get_value(
 433                                 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES),
 434                                 &val);
 435                         vf->fmt.pix.width = val;
 436                         val = 0;
 437                         pvr2_ctrl_get_value(
 438                                 pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES),
 439                                 &val);
 440                         vf->fmt.pix.height = val;
 441                         ret = 0;
 442                         break;
 443                 case V4L2_BUF_TYPE_VBI_CAPTURE:
 444                         // ????? Still need to figure out to do VBI correctly
 445                         ret = -EINVAL;
 446                         break;
 447                 default:
 448                         ret = -EINVAL;
 449                         break;
 450                 }
 451                 break;
 452         }
 453
 454         case VIDIOC_TRY_FMT:
 455         case VIDIOC_S_FMT:
 456         {
 457                 struct v4l2_format *vf = (struct v4l2_format *)arg;
 458
 459                 ret = 0;
 460                 switch(vf->type) {
 461                 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
 462                         int lmin,lmax;
 463                         struct pvr2_ctrl *hcp,*vcp;
 464                         int h = vf->fmt.pix.height;
 465                         int w = vf->fmt.pix.width;
 466                         hcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_HRES);
 467                         vcp = pvr2_hdw_get_ctrl_by_id(hdw,PVR2_CID_VRES);
 468
 469                         lmin = pvr2_ctrl_get_min(hcp);
 470                         lmax = pvr2_ctrl_get_max(hcp);
 471                         if (h < lmin) {
 472                                 h = lmin;
 473                         } else if (h > lmax) {
 474                                 h = lmax;
 475                         }
 476                         lmin = pvr2_ctrl_get_min(vcp);
 477                         lmax = pvr2_ctrl_get_max(vcp);
 478                         if (w < lmin) {
 479                                 w = lmin;
 480                         } else if (w > lmax) {
 481                                 w = lmax;
 482                         }
 483
 484                         memcpy(vf, &pvr_format[PVR_FORMAT_PIX],
 485                                sizeof(struct v4l2_format));
 486                         vf->fmt.pix.width = w;
 487                         vf->fmt.pix.height = h;
 488
 489                         if (cmd == VIDIOC_S_FMT) {
 490                                 pvr2_ctrl_set_value(hcp,vf->fmt.pix.width);
 491                                 pvr2_ctrl_set_value(vcp,vf->fmt.pix.height);
 492                         }
 493                 } break;
 494                 case V4L2_BUF_TYPE_VBI_CAPTURE:
 495                         // ????? Still need to figure out to do VBI correctly
 496                         ret = -EINVAL;
 497                         break;
 498                 default:
 499                         ret = -EINVAL;
 500                         break;
 501                 }
 502                 break;
 503         }
 504
 505         case VIDIOC_STREAMON:
 506         {
 507                 ret = pvr2_hdw_set_stream_type(hdw,dev_info->config);
 508                 if (ret < 0) return ret;
 509                 ret = pvr2_hdw_set_streaming(hdw,!0);
 510                 break;
 511         }
 512
 513         case VIDIOC_STREAMOFF:
 514         {
 515                 ret = pvr2_hdw_set_streaming(hdw,0);
 516                 break;
 517         }
 518
 519         case VIDIOC_QUERYCTRL:
 520         {
 521                 struct pvr2_ctrl *cptr;
 522                 struct v4l2_queryctrl *vc = (struct v4l2_queryctrl *)arg;
 523                 ret = 0;
 524                 if (vc->id & V4L2_CTRL_FLAG_NEXT_CTRL) {
 525                         cptr = pvr2_hdw_get_ctrl_nextv4l(
 526                                 hdw,(vc->id & ~V4L2_CTRL_FLAG_NEXT_CTRL));
 527                         if (cptr) vc->id = pvr2_ctrl_get_v4lid(cptr);
 528                 } else {
 529                         cptr = pvr2_hdw_get_ctrl_v4l(hdw,vc->id);
 530                 }
 531                 if (!cptr) {
 532                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 533                                    "QUERYCTRL id=0x%x not implemented here",
 534                                    vc->id);
 535                         ret = -EINVAL;
 536                         break;
 537                 }
 538
 539                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 540                            "QUERYCTRL id=0x%x mapping name=%s (%s)",
 541                            vc->id,pvr2_ctrl_get_name(cptr),
 542                            pvr2_ctrl_get_desc(cptr));
 543                 strlcpy(vc->name,pvr2_ctrl_get_desc(cptr),sizeof(vc->name));
 544                 vc->flags = pvr2_ctrl_get_v4lflags(cptr);
 545                 vc->default_value = pvr2_ctrl_get_def(cptr);
 546                 switch (pvr2_ctrl_get_type(cptr)) {
 547                 case pvr2_ctl_enum:
 548                         vc->type = V4L2_CTRL_TYPE_MENU;
 549                         vc->minimum = 0;
 550                         vc->maximum = pvr2_ctrl_get_cnt(cptr) - 1;
 551                         vc->step = 1;
 552                         break;
 553                 case pvr2_ctl_bool:
 554                         vc->type = V4L2_CTRL_TYPE_BOOLEAN;
 555                         vc->minimum = 0;
 556                         vc->maximum = 1;
 557                         vc->step = 1;
 558                         break;
 559                 case pvr2_ctl_int:
 560                         vc->type = V4L2_CTRL_TYPE_INTEGER;
 561                         vc->minimum = pvr2_ctrl_get_min(cptr);
 562                         vc->maximum = pvr2_ctrl_get_max(cptr);
 563                         vc->step = 1;
 564                         break;
 565                 default:
 566                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 567                                    "QUERYCTRL id=0x%x name=%s not mappable",
 568                                    vc->id,pvr2_ctrl_get_name(cptr));
 569                         ret = -EINVAL;
 570                         break;
 571                 }
 572                 break;
 573         }
 574
 575         case VIDIOC_QUERYMENU:
 576         {
 577                 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
 578                 unsigned int cnt = 0;
 579                 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
 580                                             vm->index,
 581                                             vm->name,sizeof(vm->name)-1,
 582                                             &cnt);
 583                 vm->name[cnt] = 0;
 584                 break;
 585         }
 586
 587         case VIDIOC_G_CTRL:
 588         {
 589                 struct v4l2_control *vc = (struct v4l2_control *)arg;
 590                 int val = 0;
 591                 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
 592                                           &val);
 593                 vc->value = val;
 594                 break;
 595         }
 596
 597         case VIDIOC_S_CTRL:
 598         {
 599                 struct v4l2_control *vc = (struct v4l2_control *)arg;
 600                 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
 601                                           vc->value);
 602                 break;
 603         }
 604
 605         case VIDIOC_G_EXT_CTRLS:
 606         {
 607                 struct v4l2_ext_controls *ctls =
 608                         (struct v4l2_ext_controls *)arg;
 609                 struct v4l2_ext_control *ctrl;
 610                 unsigned int idx;
 611                 int val;
 612                 for (idx = 0; idx < ctls->count; idx++) {
 613                         ctrl = ctls->controls + idx;
 614                         ret = pvr2_ctrl_get_value(
 615                                 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),&val);
 616                         if (ret) {
 617                                 ctls->error_idx = idx;
 618                                 break;
 619                         }
 620                         /* Ensure that if read as a 64 bit value, the user
 621                            will still get a hopefully sane value */
 622                         ctrl->value64 = 0;
 623                         ctrl->value = val;
 624                 }
 625                 break;
 626         }
 627
 628         case VIDIOC_S_EXT_CTRLS:
 629         {
 630                 struct v4l2_ext_controls *ctls =
 631                         (struct v4l2_ext_controls *)arg;
 632                 struct v4l2_ext_control *ctrl;
 633                 unsigned int idx;
 634                 for (idx = 0; idx < ctls->count; idx++) {
 635                         ctrl = ctls->controls + idx;
 636                         ret = pvr2_ctrl_set_value(
 637                                 pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id),
 638                                 ctrl->value);
 639                         if (ret) {
 640                                 ctls->error_idx = idx;
 641                                 break;
 642                         }
 643                 }
 644                 break;
 645         }
 646
 647         case VIDIOC_TRY_EXT_CTRLS:
 648         {
 649                 struct v4l2_ext_controls *ctls =
 650                         (struct v4l2_ext_controls *)arg;
 651                 struct v4l2_ext_control *ctrl;
 652                 struct pvr2_ctrl *pctl;
 653                 unsigned int idx;
 654                 /* For the moment just validate that the requested control
 655                    actually exists. */
 656                 for (idx = 0; idx < ctls->count; idx++) {
 657                         ctrl = ctls->controls + idx;
 658                         pctl = pvr2_hdw_get_ctrl_v4l(hdw,ctrl->id);
 659                         if (!pctl) {
 660                                 ret = -EINVAL;
 661                                 ctls->error_idx = idx;
 662                                 break;
 663                         }
 664                 }
 665                 break;
 666         }
 667
 668         case VIDIOC_LOG_STATUS:
 669         {
 670                 pvr2_hdw_trigger_module_log(hdw);
 671                 ret = 0;
 672                 break;
 673         }
 674
 675         default :
 676                 ret = v4l_compat_translate_ioctl(inode,file,cmd,
 677                                                  arg,pvr2_v4l2_do_ioctl);
 678         }
 679
 680         pvr2_hdw_commit_ctl(hdw);
 681
 682         if (ret < 0) {
 683                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 684                         pvr2_trace(PVR2_TRACE_V4LIOCTL,
 685                                    "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
 686                 } else {
 687                         if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 688                                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 689                                            "pvr2_v4l2_do_ioctl failure, ret=%d"
 690                                            " command was:",ret);
 691                                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
 692                                                 cmd);
 693                         }
 694                 }
 695         } else {
 696                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 697                            "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
 698                            ret,ret);
 699         }
 700         return ret;
 701 }
 702
 703
 704 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
 705 {
 706         printk(KERN_INFO "pvrusb2: unregistering device video%d [%s]\n",
 707                dip->vdev->minor,pvr2_config_get_name(dip->config));
 708         if (dip->ctxt_idx >= 0) {
 709                 mutex_lock(&device_lock);
 710                 devices[dip->ctxt_idx] = NULL;
 711                 dip->ctxt_idx = -1;
 712                 mutex_unlock(&device_lock);
 713         }
 714         video_unregister_device(dip->vdev);
 715 }
 716
 717
 718 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
 719 {
 720         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,-1);
 721         pvr2_v4l2_dev_destroy(&vp->video_dev);
 722
 723         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
 724         pvr2_channel_done(&vp->channel);
 725         kfree(vp);
 726 }
 727
 728
 729 static void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
 730 {
 731         struct pvr2_v4l2 *vp;
 732         vp = container_of(chp,struct pvr2_v4l2,channel);
 733         if (!vp->channel.mc_head->disconnect_flag) return;
 734         if (vp->vfirst) return;
 735         pvr2_v4l2_destroy_no_lock(vp);
 736 }
 737
 738
 739 static int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
 740                            unsigned int cmd, unsigned long arg)
 741 {
 742
 743 /* Temporary hack : use ivtv api until a v4l2 one is available. */
 744 #define IVTV_IOC_G_CODEC        0xFFEE7703
 745 #define IVTV_IOC_S_CODEC        0xFFEE7704
 746         if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
 747         return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
 748 }
 749
 750
 751 static int pvr2_v4l2_release(struct inode *inode, struct file *file)
 752 {
 753         struct pvr2_v4l2_fh *fhp = file->private_data;
 754         struct pvr2_v4l2 *vp = fhp->vhead;
 755         struct pvr2_context *mp = fhp->vhead->channel.mc_head;
 756
 757         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
 758
 759         if (fhp->rhp) {
 760                 struct pvr2_stream *sp;
 761                 struct pvr2_hdw *hdw;
 762                 hdw = fhp->channel.mc_head->hdw;
 763                 pvr2_hdw_set_streaming(hdw,0);
 764                 sp = pvr2_ioread_get_stream(fhp->rhp);
 765                 if (sp) pvr2_stream_set_callback(sp,NULL,NULL);
 766                 pvr2_ioread_destroy(fhp->rhp);
 767                 fhp->rhp = NULL;
 768         }
 769         v4l2_prio_close(&vp->prio, &fhp->prio);
 770         file->private_data = NULL;
 771
 772         pvr2_context_enter(mp); do {
 773                 if (fhp->vnext) {
 774                         fhp->vnext->vprev = fhp->vprev;
 775                 } else {
 776                         vp->vlast = fhp->vprev;
 777                 }
 778                 if (fhp->vprev) {
 779                         fhp->vprev->vnext = fhp->vnext;
 780                 } else {
 781                         vp->vfirst = fhp->vnext;
 782                 }
 783                 fhp->vnext = NULL;
 784                 fhp->vprev = NULL;
 785                 fhp->vhead = NULL;
 786                 pvr2_channel_done(&fhp->channel);
 787                 pvr2_trace(PVR2_TRACE_STRUCT,
 788                            "Destroying pvr_v4l2_fh id=%p",fhp);
 789                 kfree(fhp);
 790                 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
 791                         pvr2_v4l2_destroy_no_lock(vp);
 792                 }
 793         } while (0); pvr2_context_exit(mp);
 794         return 0;
 795 }
 796
 797
 798 static int pvr2_v4l2_open(struct inode *inode, struct file *file)
 799 {
 800         struct pvr2_v4l2_dev *dip = NULL; /* Our own context pointer */
 801         struct pvr2_v4l2_fh *fhp;
 802         struct pvr2_v4l2 *vp;
 803         struct pvr2_hdw *hdw;
 804
 805         mutex_lock(&device_lock);
 806         /* MCI 7-Jun-2006 Even though we're just doing what amounts to an
 807            atomic read of the device mapping array here, we still need the
 808            mutex.  The problem is that there is a tiny race possible when
 809            we register the device.  We can't update the device mapping
 810            array until after the device has been registered, owing to the
 811            fact that we can't know the minor device number until after the
 812            registration succeeds.  And if another thread tries to open the
 813            device in the window of time after registration but before the
 814            map is updated, then it will get back an erroneous null pointer
 815            and the open will result in a spurious failure.  The only way to
 816            prevent that is to (a) be inside the mutex here before we access
 817            the array, and (b) cover the entire registration process later
 818            on with this same mutex.  Thus if we get inside the mutex here,
 819            then we can be assured that the registration process actually
 820            completed correctly.  This is an unhappy complication from the
 821            use of global data in a driver that lives in a preemptible
 822            environment.  It sure would be nice if the video device itself
 823            had a means for storing and retrieving a local context pointer.
 824            Oh wait.  It did.  But now it's gone.  Silly me. */
 825         {
 826                 unsigned int midx = iminor(file->f_dentry->d_inode);
 827                 if (midx < sizeof(devices)/sizeof(devices[0])) {
 828                         dip = devices[midx];
 829                 }
 830         }
 831         mutex_unlock(&device_lock);
 832
 833         if (!dip) return -ENODEV; /* Should be impossible but I'm paranoid */
 834
 835         vp = dip->v4lp;
 836         hdw = vp->channel.hdw;
 837
 838         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
 839
 840         if (!pvr2_hdw_dev_ok(hdw)) {
 841                 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
 842                            "pvr2_v4l2_open: hardware not ready");
 843                 return -EIO;
 844         }
 845
 846         fhp = kmalloc(sizeof(*fhp),GFP_KERNEL);
 847         if (!fhp) {
 848                 return -ENOMEM;
 849         }
 850         memset(fhp,0,sizeof(*fhp));
 851
 852         init_waitqueue_head(&fhp->wait_data);
 853         fhp->dev_info = dip;
 854
 855         pvr2_context_enter(vp->channel.mc_head); do {
 856                 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
 857                 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
 858                 fhp->vnext = NULL;
 859                 fhp->vprev = vp->vlast;
 860                 if (vp->vlast) {
 861                         vp->vlast->vnext = fhp;
 862                 } else {
 863                         vp->vfirst = fhp;
 864                 }
 865                 vp->vlast = fhp;
 866                 fhp->vhead = vp;
 867         } while (0); pvr2_context_exit(vp->channel.mc_head);
 868
 869         fhp->file = file;
 870         file->private_data = fhp;
 871         v4l2_prio_open(&vp->prio,&fhp->prio);
 872
 873         fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
 874
 875         return 0;
 876 }
 877
 878
 879 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
 880 {
 881         wake_up(&fhp->wait_data);
 882 }
 883
 884 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
 885 {
 886         int ret;
 887         struct pvr2_stream *sp;
 888         struct pvr2_hdw *hdw;
 889         if (fh->rhp) return 0;
 890
 891         /* First read() attempt.  Try to claim the stream and start
 892            it... */
 893         if ((ret = pvr2_channel_claim_stream(&fh->channel,
 894                                              fh->dev_info->stream)) != 0) {
 895                 /* Someone else must already have it */
 896                 return ret;
 897         }
 898
 899         fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
 900         if (!fh->rhp) {
 901                 pvr2_channel_claim_stream(&fh->channel,NULL);
 902                 return -ENOMEM;
 903         }
 904
 905         hdw = fh->channel.mc_head->hdw;
 906         sp = fh->dev_info->stream->stream;
 907         pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
 908         pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
 909         pvr2_hdw_set_streaming(hdw,!0);
 910         ret = pvr2_ioread_set_enabled(fh->rhp,!0);
 911
 912         return ret;
 913 }
 914
 915
 916 static ssize_t pvr2_v4l2_read(struct file *file,
 917                               char __user *buff, size_t count, loff_t *ppos)
 918 {
 919         struct pvr2_v4l2_fh *fh = file->private_data;
 920         int ret;
 921
 922         if (fh->fw_mode_flag) {
 923                 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 924                 char *tbuf;
 925                 int c1,c2;
 926                 int tcnt = 0;
 927                 unsigned int offs = *ppos;
 928
 929                 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
 930                 if (!tbuf) return -ENOMEM;
 931
 932                 while (count) {
 933                         c1 = count;
 934                         if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
 935                         c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
 936                         if (c2 < 0) {
 937                                 tcnt = c2;
 938                                 break;
 939                         }
 940                         if (!c2) break;
 941                         if (copy_to_user(buff,tbuf,c2)) {
 942                                 tcnt = -EFAULT;
 943                                 break;
 944                         }
 945                         offs += c2;
 946                         tcnt += c2;
 947                         buff += c2;
 948                         count -= c2;
 949                         *ppos += c2;
 950                 }
 951                 kfree(tbuf);
 952                 return tcnt;
 953         }
 954
 955         if (!fh->rhp) {
 956                 ret = pvr2_v4l2_iosetup(fh);
 957                 if (ret) {
 958                         return ret;
 959                 }
 960         }
 961
 962         for (;;) {
 963                 ret = pvr2_ioread_read(fh->rhp,buff,count);
 964                 if (ret >= 0) break;
 965                 if (ret != -EAGAIN) break;
 966                 if (file->f_flags & O_NONBLOCK) break;
 967                 /* Doing blocking I/O.  Wait here. */
 968                 ret = wait_event_interruptible(
 969                         fh->wait_data,
 970                         pvr2_ioread_avail(fh->rhp) >= 0);
 971                 if (ret < 0) break;
 972         }
 973
 974         return ret;
 975 }
 976
 977
 978 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
 979 {
 980         unsigned int mask = 0;
 981         struct pvr2_v4l2_fh *fh = file->private_data;
 982         int ret;
 983
 984         if (fh->fw_mode_flag) {
 985                 mask |= POLLIN | POLLRDNORM;
 986                 return mask;
 987         }
 988
 989         if (!fh->rhp) {
 990                 ret = pvr2_v4l2_iosetup(fh);
 991                 if (ret) return POLLERR;
 992         }
 993
 994         poll_wait(file,&fh->wait_data,wait);
 995
 996         if (pvr2_ioread_avail(fh->rhp) >= 0) {
 997                 mask |= POLLIN | POLLRDNORM;
 998         }
 999
1000         return mask;
1001 }
1002
1003
1004 static struct file_operations vdev_fops = {
1005         .owner      = THIS_MODULE,
1006         .open       = pvr2_v4l2_open,
1007         .release    = pvr2_v4l2_release,
1008         .read       = pvr2_v4l2_read,
1009         .ioctl      = pvr2_v4l2_ioctl,
1010         .llseek     = no_llseek,
1011         .poll       = pvr2_v4l2_poll,
1012 };
1013
1014
1015 #define VID_HARDWARE_PVRUSB2    38  /* FIXME : need a good value */
1016
1017 static struct video_device vdev_template = {
1018         .owner      = THIS_MODULE,
1019         .type       = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
1020         .type2      = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
1021                        | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
1022                        | V4L2_CAP_READWRITE),
1023         .hardware   = VID_HARDWARE_PVRUSB2,
1024         .fops       = &vdev_fops,
1025 };
1026
1027
1028 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
1029                                struct pvr2_v4l2 *vp,
1030                                enum pvr2_config cfg)
1031 {
1032         int mindevnum;
1033         int unit_number;
1034         int v4l_type;
1035         dip->v4lp = vp;
1036         dip->config = cfg;
1037
1038
1039         switch (cfg) {
1040         case pvr2_config_mpeg:
1041                 v4l_type = VFL_TYPE_GRABBER;
1042                 dip->stream = &vp->channel.mc_head->video_stream;
1043                 break;
1044         case pvr2_config_vbi:
1045                 v4l_type = VFL_TYPE_VBI;
1046                 break;
1047         case pvr2_config_radio:
1048                 v4l_type = VFL_TYPE_RADIO;
1049                 break;
1050         default:
1051                 /* Bail out (this should be impossible) */
1052                 err("Failed to set up pvrusb2 v4l dev"
1053                     " due to unrecognized config");
1054                 return;
1055         }
1056
1057         if (!dip->stream) {
1058                 err("Failed to set up pvrusb2 v4l dev"
1059                     " due to missing stream instance");
1060                 return;
1061         }
1062
1063         dip->vdev = video_device_alloc();
1064         if (!dip->vdev) {
1065                 err("Alloc of pvrusb2 v4l video device failed");
1066                 return;
1067         }
1068
1069         memcpy(dip->vdev,&vdev_template,sizeof(vdev_template));
1070         dip->vdev->release = video_device_release;
1071         mutex_lock(&device_lock);
1072
1073         mindevnum = -1;
1074         unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
1075         if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
1076                 mindevnum = video_nr[unit_number];
1077         }
1078         if ((video_register_device(dip->vdev, v4l_type, mindevnum) < 0) &&
1079             (video_register_device(dip->vdev, v4l_type, -1) < 0)) {
1080                 err("Failed to register pvrusb2 v4l video device");
1081         } else {
1082                 printk(KERN_INFO "pvrusb2: registered device video%d [%s]\n",
1083                        dip->vdev->minor,pvr2_config_get_name(dip->config));
1084         }
1085
1086         if ((dip->vdev->minor < sizeof(devices)/sizeof(devices[0])) &&
1087             (devices[dip->vdev->minor] == NULL)) {
1088                 dip->ctxt_idx = dip->vdev->minor;
1089                 devices[dip->ctxt_idx] = dip;
1090         }
1091         mutex_unlock(&device_lock);
1092
1093         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1094                                         dip->vdev->minor);
1095 }
1096
1097
1098 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1099 {
1100         struct pvr2_v4l2 *vp;
1101
1102         vp = kmalloc(sizeof(*vp),GFP_KERNEL);
1103         if (!vp) return vp;
1104         memset(vp,0,sizeof(*vp));
1105         vp->video_dev.ctxt_idx = -1;
1106         pvr2_channel_init(&vp->channel,mnp);
1107         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1108
1109         vp->channel.check_func = pvr2_v4l2_internal_check;
1110
1111         /* register streams */
1112         pvr2_v4l2_dev_init(&vp->video_dev,vp,pvr2_config_mpeg);
1113
1114
1115         return vp;
1116 }
1117
1118 /*
1119   Stuff for Emacs to see, in order to encourage consistent editing style:
1120   *** Local Variables: ***
1121   *** mode: c ***
1122   *** fill-column: 75 ***
1123   *** tab-width: 8 ***
1124   *** c-basic-offset: 8 ***
1125   *** End: ***
1126   */