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