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