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