SAFE public projects git trees. - safe/jmp/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_int:
 538                         vc->type = V4L2_CTRL_TYPE_INTEGER;
 539                         vc->minimum = pvr2_ctrl_get_min(cptr);
 540                         vc->maximum = pvr2_ctrl_get_max(cptr);
 541                         vc->step = 1;
 542                         break;
 543                 default:
 544                         ret = -EINVAL;
 545                         break;
 546                 }
 547                 break;
 548         }
 549
 550         case VIDIOC_QUERYMENU:
 551         {
 552                 struct v4l2_querymenu *vm = (struct v4l2_querymenu *)arg;
 553                 unsigned int cnt = 0;
 554                 ret = pvr2_ctrl_get_valname(pvr2_hdw_get_ctrl_v4l(hdw,vm->id),
 555                                             vm->index,
 556                                             vm->name,sizeof(vm->name)-1,
 557                                             &cnt);
 558                 vm->name[cnt] = 0;
 559                 break;
 560         }
 561
 562         case VIDIOC_G_CTRL:
 563         {
 564                 struct v4l2_control *vc = (struct v4l2_control *)arg;
 565                 int val = 0;
 566                 ret = pvr2_ctrl_get_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
 567                                           &val);
 568                 vc->value = val;
 569                 break;
 570         }
 571
 572         case VIDIOC_S_CTRL:
 573         {
 574                 struct v4l2_control *vc = (struct v4l2_control *)arg;
 575                 ret = pvr2_ctrl_set_value(pvr2_hdw_get_ctrl_v4l(hdw,vc->id),
 576                                           vc->value);
 577                 break;
 578         }
 579
 580         case VIDIOC_LOG_STATUS:
 581         {
 582                 pvr2_hdw_trigger_module_log(hdw);
 583                 ret = 0;
 584                 break;
 585         }
 586
 587         default :
 588                 ret = v4l_compat_translate_ioctl(inode,file,cmd,
 589                                                  arg,pvr2_v4l2_do_ioctl);
 590         }
 591
 592         pvr2_hdw_commit_ctl(hdw);
 593
 594         if (ret < 0) {
 595                 if (pvrusb2_debug & PVR2_TRACE_V4LIOCTL) {
 596                         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 597                                    "pvr2_v4l2_do_ioctl failure, ret=%d",ret);
 598                 } else {
 599                         if (pvrusb2_debug & PVR2_TRACE_ERROR_LEGS) {
 600                                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 601                                            "pvr2_v4l2_do_ioctl failure, ret=%d"
 602                                            " command was:",ret);
 603                                 v4l_print_ioctl(pvr2_hdw_get_driver_name(hdw),
 604                                                 cmd);
 605                         }
 606                 }
 607         } else {
 608                 pvr2_trace(PVR2_TRACE_V4LIOCTL,
 609                            "pvr2_v4l2_do_ioctl complete, ret=%d (0x%x)",
 610                            ret,ret);
 611         }
 612         return ret;
 613 }
 614
 615
 616 static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip)
 617 {
 618         pvr2_trace(PVR2_TRACE_INIT,
 619                    "unregistering device video%d [%s]",
 620                    dip->vdev->minor,pvr2_config_get_name(dip->config));
 621         if (dip->ctxt_idx >= 0) {
 622                 mutex_lock(&device_lock);
 623                 devices[dip->ctxt_idx] = NULL;
 624                 dip->ctxt_idx = -1;
 625                 mutex_unlock(&device_lock);
 626         }
 627         video_unregister_device(dip->vdev);
 628 }
 629
 630
 631 static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp)
 632 {
 633         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,-1);
 634         pvr2_v4l2_dev_destroy(&vp->video_dev);
 635
 636         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp);
 637         pvr2_channel_done(&vp->channel);
 638         kfree(vp);
 639 }
 640
 641
 642 void pvr2_v4l2_internal_check(struct pvr2_channel *chp)
 643 {
 644         struct pvr2_v4l2 *vp;
 645         vp = container_of(chp,struct pvr2_v4l2,channel);
 646         if (!vp->channel.mc_head->disconnect_flag) return;
 647         if (vp->vfirst) return;
 648         pvr2_v4l2_destroy_no_lock(vp);
 649 }
 650
 651
 652 int pvr2_v4l2_ioctl(struct inode *inode, struct file *file,
 653                     unsigned int cmd, unsigned long arg)
 654 {
 655
 656 /* Temporary hack : use ivtv api until a v4l2 one is available. */
 657 #define IVTV_IOC_G_CODEC        0xFFEE7703
 658 #define IVTV_IOC_S_CODEC        0xFFEE7704
 659         if (cmd == IVTV_IOC_G_CODEC || cmd == IVTV_IOC_S_CODEC) return 0;
 660         return video_usercopy(inode, file, cmd, arg, pvr2_v4l2_do_ioctl);
 661 }
 662
 663
 664 int pvr2_v4l2_release(struct inode *inode, struct file *file)
 665 {
 666         struct pvr2_v4l2_fh *fhp = file->private_data;
 667         struct pvr2_v4l2 *vp = fhp->vhead;
 668         struct pvr2_context *mp = fhp->vhead->channel.mc_head;
 669
 670         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_release");
 671
 672         if (fhp->rhp) {
 673                 struct pvr2_stream *sp;
 674                 struct pvr2_hdw *hdw;
 675                 hdw = fhp->channel.mc_head->hdw;
 676                 pvr2_hdw_set_streaming(hdw,0);
 677                 sp = pvr2_ioread_get_stream(fhp->rhp);
 678                 if (sp) pvr2_stream_set_callback(sp,0,0);
 679                 pvr2_ioread_destroy(fhp->rhp);
 680                 fhp->rhp = 0;
 681         }
 682         v4l2_prio_close(&vp->prio, &fhp->prio);
 683         file->private_data = NULL;
 684
 685         pvr2_context_enter(mp); do {
 686                 if (fhp->vnext) {
 687                         fhp->vnext->vprev = fhp->vprev;
 688                 } else {
 689                         vp->vlast = fhp->vprev;
 690                 }
 691                 if (fhp->vprev) {
 692                         fhp->vprev->vnext = fhp->vnext;
 693                 } else {
 694                         vp->vfirst = fhp->vnext;
 695                 }
 696                 fhp->vnext = 0;
 697                 fhp->vprev = 0;
 698                 fhp->vhead = 0;
 699                 pvr2_channel_done(&fhp->channel);
 700                 pvr2_trace(PVR2_TRACE_STRUCT,
 701                            "Destroying pvr_v4l2_fh id=%p",fhp);
 702                 kfree(fhp);
 703                 if (vp->channel.mc_head->disconnect_flag && !vp->vfirst) {
 704                         pvr2_v4l2_destroy_no_lock(vp);
 705                 }
 706         } while (0); pvr2_context_exit(mp);
 707         return 0;
 708 }
 709
 710
 711 int pvr2_v4l2_open(struct inode *inode, struct file *file)
 712 {
 713         struct pvr2_v4l2_dev *dip = 0; /* Our own context pointer */
 714         struct pvr2_v4l2_fh *fhp;
 715         struct pvr2_v4l2 *vp;
 716         struct pvr2_hdw *hdw;
 717
 718         mutex_lock(&device_lock);
 719         /* MCI 7-Jun-2006 Even though we're just doing what amounts to an
 720            atomic read of the device mapping array here, we still need the
 721            mutex.  The problem is that there is a tiny race possible when
 722            we register the device.  We can't update the device mapping
 723            array until after the device has been registered, owing to the
 724            fact that we can't know the minor device number until after the
 725            registration succeeds.  And if another thread tries to open the
 726            device in the window of time after registration but before the
 727            map is updated, then it will get back an erroneous null pointer
 728            and the open will result in a spurious failure.  The only way to
 729            prevent that is to (a) be inside the mutex here before we access
 730            the array, and (b) cover the entire registration process later
 731            on with this same mutex.  Thus if we get inside the mutex here,
 732            then we can be assured that the registration process actually
 733            completed correctly.  This is an unhappy complication from the
 734            use of global data in a driver that lives in a preemptible
 735            environment.  It sure would be nice if the video device itself
 736            had a means for storing and retrieving a local context pointer.
 737            Oh wait.  It did.  But now it's gone.  Silly me. */
 738         {
 739                 unsigned int midx = iminor(file->f_dentry->d_inode);
 740                 if (midx < sizeof(devices)/sizeof(devices[0])) {
 741                         dip = devices[midx];
 742                 }
 743         }
 744         mutex_unlock(&device_lock);
 745
 746         if (!dip) return -ENODEV; /* Should be impossible but I'm paranoid */
 747
 748         vp = dip->v4lp;
 749         hdw = vp->channel.hdw;
 750
 751         pvr2_trace(PVR2_TRACE_OPEN_CLOSE,"pvr2_v4l2_open");
 752
 753         if (!pvr2_hdw_dev_ok(hdw)) {
 754                 pvr2_trace(PVR2_TRACE_OPEN_CLOSE,
 755                            "pvr2_v4l2_open: hardware not ready");
 756                 return -EIO;
 757         }
 758
 759         fhp = kmalloc(sizeof(*fhp),GFP_KERNEL);
 760         if (!fhp) {
 761                 return -ENOMEM;
 762         }
 763         memset(fhp,0,sizeof(*fhp));
 764
 765         init_waitqueue_head(&fhp->wait_data);
 766         fhp->dev_info = dip;
 767
 768         pvr2_context_enter(vp->channel.mc_head); do {
 769                 pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr_v4l2_fh id=%p",fhp);
 770                 pvr2_channel_init(&fhp->channel,vp->channel.mc_head);
 771                 fhp->vnext = 0;
 772                 fhp->vprev = vp->vlast;
 773                 if (vp->vlast) {
 774                         vp->vlast->vnext = fhp;
 775                 } else {
 776                         vp->vfirst = fhp;
 777                 }
 778                 vp->vlast = fhp;
 779                 fhp->vhead = vp;
 780         } while (0); pvr2_context_exit(vp->channel.mc_head);
 781
 782         fhp->file = file;
 783         file->private_data = fhp;
 784         v4l2_prio_open(&vp->prio,&fhp->prio);
 785
 786         fhp->fw_mode_flag = pvr2_hdw_cpufw_get_enabled(hdw);
 787
 788         return 0;
 789 }
 790
 791
 792 static void pvr2_v4l2_notify(struct pvr2_v4l2_fh *fhp)
 793 {
 794         wake_up(&fhp->wait_data);
 795 }
 796
 797 static int pvr2_v4l2_iosetup(struct pvr2_v4l2_fh *fh)
 798 {
 799         int ret;
 800         struct pvr2_stream *sp;
 801         struct pvr2_hdw *hdw;
 802         if (fh->rhp) return 0;
 803
 804         /* First read() attempt.  Try to claim the stream and start
 805            it... */
 806         if ((ret = pvr2_channel_claim_stream(&fh->channel,
 807                                              fh->dev_info->stream)) != 0) {
 808                 /* Someone else must already have it */
 809                 return ret;
 810         }
 811
 812         fh->rhp = pvr2_channel_create_mpeg_stream(fh->dev_info->stream);
 813         if (!fh->rhp) {
 814                 pvr2_channel_claim_stream(&fh->channel,0);
 815                 return -ENOMEM;
 816         }
 817
 818         hdw = fh->channel.mc_head->hdw;
 819         sp = fh->dev_info->stream->stream;
 820         pvr2_stream_set_callback(sp,(pvr2_stream_callback)pvr2_v4l2_notify,fh);
 821         pvr2_hdw_set_stream_type(hdw,fh->dev_info->config);
 822         pvr2_hdw_set_streaming(hdw,!0);
 823         ret = pvr2_ioread_set_enabled(fh->rhp,!0);
 824
 825         return ret;
 826 }
 827
 828
 829 static ssize_t pvr2_v4l2_read(struct file *file,
 830                               char __user *buff, size_t count, loff_t *ppos)
 831 {
 832         struct pvr2_v4l2_fh *fh = file->private_data;
 833         int ret;
 834
 835         if (fh->fw_mode_flag) {
 836                 struct pvr2_hdw *hdw = fh->channel.mc_head->hdw;
 837                 char *tbuf;
 838                 int c1,c2;
 839                 int tcnt = 0;
 840                 unsigned int offs = *ppos;
 841
 842                 tbuf = kmalloc(PAGE_SIZE,GFP_KERNEL);
 843                 if (!tbuf) return -ENOMEM;
 844
 845                 while (count) {
 846                         c1 = count;
 847                         if (c1 > PAGE_SIZE) c1 = PAGE_SIZE;
 848                         c2 = pvr2_hdw_cpufw_get(hdw,offs,tbuf,c1);
 849                         if (c2 < 0) {
 850                                 tcnt = c2;
 851                                 break;
 852                         }
 853                         if (!c2) break;
 854                         if (copy_to_user(buff,tbuf,c2)) {
 855                                 tcnt = -EFAULT;
 856                                 break;
 857                         }
 858                         offs += c2;
 859                         tcnt += c2;
 860                         buff += c2;
 861                         count -= c2;
 862                         *ppos += c2;
 863                 }
 864                 kfree(tbuf);
 865                 return tcnt;
 866         }
 867
 868         if (!fh->rhp) {
 869                 ret = pvr2_v4l2_iosetup(fh);
 870                 if (ret) {
 871                         return ret;
 872                 }
 873         }
 874
 875         for (;;) {
 876                 ret = pvr2_ioread_read(fh->rhp,buff,count);
 877                 if (ret >= 0) break;
 878                 if (ret != -EAGAIN) break;
 879                 if (file->f_flags & O_NONBLOCK) break;
 880                 /* Doing blocking I/O.  Wait here. */
 881                 ret = wait_event_interruptible(
 882                         fh->wait_data,
 883                         pvr2_ioread_avail(fh->rhp) >= 0);
 884                 if (ret < 0) break;
 885         }
 886
 887         return ret;
 888 }
 889
 890
 891 static unsigned int pvr2_v4l2_poll(struct file *file, poll_table *wait)
 892 {
 893         unsigned int mask = 0;
 894         struct pvr2_v4l2_fh *fh = file->private_data;
 895         int ret;
 896
 897         if (fh->fw_mode_flag) {
 898                 mask |= POLLIN | POLLRDNORM;
 899                 return mask;
 900         }
 901
 902         if (!fh->rhp) {
 903                 ret = pvr2_v4l2_iosetup(fh);
 904                 if (ret) return POLLERR;
 905         }
 906
 907         poll_wait(file,&fh->wait_data,wait);
 908
 909         if (pvr2_ioread_avail(fh->rhp) >= 0) {
 910                 mask |= POLLIN | POLLRDNORM;
 911         }
 912
 913         return mask;
 914 }
 915
 916
 917 static struct file_operations vdev_fops = {
 918         .owner      = THIS_MODULE,
 919         .open       = pvr2_v4l2_open,
 920         .release    = pvr2_v4l2_release,
 921         .read       = pvr2_v4l2_read,
 922         .ioctl      = pvr2_v4l2_ioctl,
 923         .llseek     = no_llseek,
 924         .poll       = pvr2_v4l2_poll,
 925 };
 926
 927
 928 #define VID_HARDWARE_PVRUSB2    38  /* FIXME : need a good value */
 929
 930 static struct video_device vdev_template = {
 931         .owner      = THIS_MODULE,
 932         .type       = VID_TYPE_CAPTURE | VID_TYPE_TUNER,
 933         .type2      = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VBI_CAPTURE
 934                        | V4L2_CAP_TUNER | V4L2_CAP_AUDIO
 935                        | V4L2_CAP_READWRITE),
 936         .hardware   = VID_HARDWARE_PVRUSB2,
 937         .fops       = &vdev_fops,
 938 };
 939
 940
 941 static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
 942                                struct pvr2_v4l2 *vp,
 943                                enum pvr2_config cfg)
 944 {
 945         int mindevnum;
 946         int unit_number;
 947         int v4l_type;
 948         dip->v4lp = vp;
 949         dip->config = cfg;
 950
 951
 952         switch (cfg) {
 953         case pvr2_config_mpeg:
 954                 v4l_type = VFL_TYPE_GRABBER;
 955                 dip->stream = &vp->channel.mc_head->video_stream;
 956                 break;
 957         case pvr2_config_vbi:
 958                 v4l_type = VFL_TYPE_VBI;
 959                 break;
 960         case pvr2_config_radio:
 961                 v4l_type = VFL_TYPE_RADIO;
 962                 break;
 963         default:
 964                 /* Bail out (this should be impossible) */
 965                 err("Failed to set up pvrusb2 v4l dev"
 966                     " due to unrecognized config");
 967                 return;
 968         }
 969
 970         if (!dip->stream) {
 971                 err("Failed to set up pvrusb2 v4l dev"
 972                     " due to missing stream instance");
 973                 return;
 974         }
 975
 976         dip->vdev = video_device_alloc();
 977         if (!dip->vdev) {
 978                 err("Alloc of pvrusb2 v4l video device failed");
 979                 return;
 980         }
 981
 982         memcpy(dip->vdev,&vdev_template,sizeof(vdev_template));
 983         dip->vdev->release = video_device_release;
 984         mutex_lock(&device_lock);
 985
 986         mindevnum = -1;
 987         unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw);
 988         if ((unit_number >= 0) && (unit_number < PVR_NUM)) {
 989                 mindevnum = video_nr[unit_number];
 990         }
 991         if ((video_register_device(dip->vdev, v4l_type, mindevnum) < 0) &&
 992             (video_register_device(dip->vdev, v4l_type, -1) < 0)) {
 993                 err("Failed to register pvrusb2 v4l video device");
 994         } else {
 995                 pvr2_trace(PVR2_TRACE_INIT,
 996                            "registered device video%d [%s]",
 997                            dip->vdev->minor,pvr2_config_get_name(dip->config));
 998         }
 999
1000         if ((dip->vdev->minor < sizeof(devices)/sizeof(devices[0])) &&
1001             (devices[dip->vdev->minor] == NULL)) {
1002                 dip->ctxt_idx = dip->vdev->minor;
1003                 devices[dip->ctxt_idx] = dip;
1004         }
1005         mutex_unlock(&device_lock);
1006
1007         pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,
1008                                         dip->vdev->minor);
1009 }
1010
1011
1012 struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp)
1013 {
1014         struct pvr2_v4l2 *vp;
1015
1016         vp = kmalloc(sizeof(*vp),GFP_KERNEL);
1017         if (!vp) return vp;
1018         memset(vp,0,sizeof(*vp));
1019         vp->video_dev.ctxt_idx = -1;
1020         pvr2_channel_init(&vp->channel,mnp);
1021         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp);
1022
1023         vp->channel.check_func = pvr2_v4l2_internal_check;
1024
1025         /* register streams */
1026         pvr2_v4l2_dev_init(&vp->video_dev,vp,pvr2_config_mpeg);
1027
1028
1029         return vp;
1030 }
1031
1032 /*
1033   Stuff for Emacs to see, in order to encourage consistent editing style:
1034   *** Local Variables: ***
1035   *** mode: c ***
1036   *** fill-column: 75 ***
1037   *** tab-width: 8 ***
1038   *** c-basic-offset: 8 ***
1039   *** End: ***
1040   */