drivers/media/video/pwc/pwc-v4l.c

   1 /* Linux driver for Philips webcam
   2    USB and Video4Linux interface part.
   3    (C) 1999-2004 Nemosoft Unv.
   4    (C) 2004-2006 Luc Saillard (luc@saillard.org)
   5
   6    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
   7    driver and thus may have bugs that are not present in the original version.
   8    Please send bug reports and support requests to <luc@saillard.org>.
   9    The decompression routines have been implemented by reverse-engineering the
  10    Nemosoft binary pwcx module. Caveat emptor.
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 2 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program; if not, write to the Free Software
  24    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25
  26 */
  27
  28 #include <linux/errno.h>
  29 #include <linux/init.h>
  30 #include <linux/mm.h>
  31 #include <linux/module.h>
  32 #include <linux/poll.h>
  33 #include <linux/vmalloc.h>
  34 #include <asm/io.h>
  35
  36 #include "pwc.h"
  37
  38 static struct v4l2_queryctrl pwc_controls[] = {
  39         {
  40             .id      = V4L2_CID_BRIGHTNESS,
  41             .type    = V4L2_CTRL_TYPE_INTEGER,
  42             .name    = "Brightness",
  43             .minimum = 0,
  44             .maximum = 128,
  45             .step    = 1,
  46             .default_value = 64,
  47         },
  48         {
  49             .id      = V4L2_CID_CONTRAST,
  50             .type    = V4L2_CTRL_TYPE_INTEGER,
  51             .name    = "Contrast",
  52             .minimum = 0,
  53             .maximum = 64,
  54             .step    = 1,
  55             .default_value = 0,
  56         },
  57         {
  58             .id      = V4L2_CID_SATURATION,
  59             .type    = V4L2_CTRL_TYPE_INTEGER,
  60             .name    = "Saturation",
  61             .minimum = -100,
  62             .maximum = 100,
  63             .step    = 1,
  64             .default_value = 0,
  65         },
  66         {
  67             .id      = V4L2_CID_GAMMA,
  68             .type    = V4L2_CTRL_TYPE_INTEGER,
  69             .name    = "Gamma",
  70             .minimum = 0,
  71             .maximum = 32,
  72             .step    = 1,
  73             .default_value = 0,
  74         },
  75         {
  76             .id      = V4L2_CID_RED_BALANCE,
  77             .type    = V4L2_CTRL_TYPE_INTEGER,
  78             .name    = "Red Gain",
  79             .minimum = 0,
  80             .maximum = 256,
  81             .step    = 1,
  82             .default_value = 0,
  83         },
  84         {
  85             .id      = V4L2_CID_BLUE_BALANCE,
  86             .type    = V4L2_CTRL_TYPE_INTEGER,
  87             .name    = "Blue Gain",
  88             .minimum = 0,
  89             .maximum = 256,
  90             .step    = 1,
  91             .default_value = 0,
  92         },
  93         {
  94             .id      = V4L2_CID_AUTO_WHITE_BALANCE,
  95             .type    = V4L2_CTRL_TYPE_BOOLEAN,
  96             .name    = "Auto White Balance",
  97             .minimum = 0,
  98             .maximum = 1,
  99             .step    = 1,
 100             .default_value = 0,
 101         },
 102         {
 103             .id      = V4L2_CID_EXPOSURE,
 104             .type    = V4L2_CTRL_TYPE_INTEGER,
 105             .name    = "Shutter Speed (Exposure)",
 106             .minimum = 0,
 107             .maximum = 256,
 108             .step    = 1,
 109             .default_value = 200,
 110         },
 111         {
 112             .id      = V4L2_CID_AUTOGAIN,
 113             .type    = V4L2_CTRL_TYPE_BOOLEAN,
 114             .name    = "Auto Gain Enabled",
 115             .minimum = 0,
 116             .maximum = 1,
 117             .step    = 1,
 118             .default_value = 1,
 119         },
 120         {
 121             .id      = V4L2_CID_GAIN,
 122             .type    = V4L2_CTRL_TYPE_INTEGER,
 123             .name    = "Gain Level",
 124             .minimum = 0,
 125             .maximum = 256,
 126             .step    = 1,
 127             .default_value = 0,
 128         },
 129         {
 130             .id      = V4L2_CID_PRIVATE_SAVE_USER,
 131             .type    = V4L2_CTRL_TYPE_BUTTON,
 132             .name    = "Save User Settings",
 133             .minimum = 0,
 134             .maximum = 0,
 135             .step    = 0,
 136             .default_value = 0,
 137         },
 138         {
 139             .id      = V4L2_CID_PRIVATE_RESTORE_USER,
 140             .type    = V4L2_CTRL_TYPE_BUTTON,
 141             .name    = "Restore User Settings",
 142             .minimum = 0,
 143             .maximum = 0,
 144             .step    = 0,
 145             .default_value = 0,
 146         },
 147         {
 148             .id      = V4L2_CID_PRIVATE_RESTORE_FACTORY,
 149             .type    = V4L2_CTRL_TYPE_BUTTON,
 150             .name    = "Restore Factory Settings",
 151             .minimum = 0,
 152             .maximum = 0,
 153             .step    = 0,
 154             .default_value = 0,
 155         },
 156         {
 157             .id      = V4L2_CID_PRIVATE_COLOUR_MODE,
 158             .type    = V4L2_CTRL_TYPE_BOOLEAN,
 159             .name    = "Colour mode",
 160             .minimum = 0,
 161             .maximum = 1,
 162             .step    = 1,
 163             .default_value = 0,
 164         },
 165         {
 166             .id      = V4L2_CID_PRIVATE_AUTOCONTOUR,
 167             .type    = V4L2_CTRL_TYPE_BOOLEAN,
 168             .name    = "Auto contour",
 169             .minimum = 0,
 170             .maximum = 1,
 171             .step    = 1,
 172             .default_value = 0,
 173         },
 174         {
 175             .id      = V4L2_CID_PRIVATE_CONTOUR,
 176             .type    = V4L2_CTRL_TYPE_INTEGER,
 177             .name    = "Contour",
 178             .minimum = 0,
 179             .maximum = 63,
 180             .step    = 1,
 181             .default_value = 0,
 182         },
 183         {
 184             .id      = V4L2_CID_PRIVATE_BACKLIGHT,
 185             .type    = V4L2_CTRL_TYPE_BOOLEAN,
 186             .name    = "Backlight compensation",
 187             .minimum = 0,
 188             .maximum = 1,
 189             .step    = 1,
 190             .default_value = 0,
 191         },
 192         {
 193           .id      = V4L2_CID_PRIVATE_FLICKERLESS,
 194             .type    = V4L2_CTRL_TYPE_BOOLEAN,
 195             .name    = "Flickerless",
 196             .minimum = 0,
 197             .maximum = 1,
 198             .step    = 1,
 199             .default_value = 0,
 200         },
 201         {
 202             .id      = V4L2_CID_PRIVATE_NOISE_REDUCTION,
 203             .type    = V4L2_CTRL_TYPE_INTEGER,
 204             .name    = "Noise reduction",
 205             .minimum = 0,
 206             .maximum = 3,
 207             .step    = 1,
 208             .default_value = 0,
 209         },
 210 };
 211
 212
 213 static void pwc_vidioc_fill_fmt(const struct pwc_device *pdev, struct v4l2_format *f)
 214 {
 215         memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
 216         f->fmt.pix.width        = pdev->view.x;
 217         f->fmt.pix.height       = pdev->view.y;
 218         f->fmt.pix.field        = V4L2_FIELD_NONE;
 219         if (pdev->pixfmt == V4L2_PIX_FMT_YUV420) {
 220                 f->fmt.pix.pixelformat  = V4L2_PIX_FMT_YUV420;
 221                 f->fmt.pix.bytesperline = (f->fmt.pix.width * 3)/2;
 222                 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 223         } else {
 224                 /* vbandlength contains 4 lines ...  */
 225                 f->fmt.pix.bytesperline = pdev->vbandlength/4;
 226                 f->fmt.pix.sizeimage = pdev->frame_size + sizeof(struct pwc_raw_frame);
 227                 if (DEVICE_USE_CODEC1(pdev->type))
 228                         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_PWC1;
 229                 else
 230                         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_PWC2;
 231         }
 232         PWC_DEBUG_IOCTL("pwc_vidioc_fill_fmt() "
 233                         "width=%d, height=%d, bytesperline=%d, sizeimage=%d, pixelformat=%c%c%c%c\n",
 234                         f->fmt.pix.width,
 235                         f->fmt.pix.height,
 236                         f->fmt.pix.bytesperline,
 237                         f->fmt.pix.sizeimage,
 238                         (f->fmt.pix.pixelformat)&255,
 239                         (f->fmt.pix.pixelformat>>8)&255,
 240                         (f->fmt.pix.pixelformat>>16)&255,
 241                         (f->fmt.pix.pixelformat>>24)&255);
 242 }
 243
 244 /* ioctl(VIDIOC_TRY_FMT) */
 245 static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
 246 {
 247         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 248                 PWC_DEBUG_IOCTL("Bad video type must be V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
 249                 return -EINVAL;
 250         }
 251
 252         switch (f->fmt.pix.pixelformat) {
 253                 case V4L2_PIX_FMT_YUV420:
 254                         break;
 255                 case V4L2_PIX_FMT_PWC1:
 256                         if (DEVICE_USE_CODEC23(pdev->type)) {
 257                                 PWC_DEBUG_IOCTL("codec1 is only supported for old pwc webcam\n");
 258                                 return -EINVAL;
 259                         }
 260                         break;
 261                 case V4L2_PIX_FMT_PWC2:
 262                         if (DEVICE_USE_CODEC1(pdev->type)) {
 263                                 PWC_DEBUG_IOCTL("codec23 is only supported for new pwc webcam\n");
 264                                 return -EINVAL;
 265                         }
 266                         break;
 267                 default:
 268                         PWC_DEBUG_IOCTL("Unsupported pixel format\n");
 269                         return -EINVAL;
 270
 271         }
 272
 273         if (f->fmt.pix.width > pdev->view_max.x)
 274                 f->fmt.pix.width = pdev->view_max.x;
 275         else if (f->fmt.pix.width < pdev->view_min.x)
 276                 f->fmt.pix.width = pdev->view_min.x;
 277
 278         if (f->fmt.pix.height > pdev->view_max.y)
 279                 f->fmt.pix.height = pdev->view_max.y;
 280         else if (f->fmt.pix.height < pdev->view_min.y)
 281                 f->fmt.pix.height = pdev->view_min.y;
 282
 283         return 0;
 284 }
 285
 286 /* ioctl(VIDIOC_SET_FMT) */
 287 static int pwc_vidioc_set_fmt(struct pwc_device *pdev, struct v4l2_format *f)
 288 {
 289         int ret, fps, snapshot, compression, pixelformat;
 290
 291         ret = pwc_vidioc_try_fmt(pdev, f);
 292         if (ret<0)
 293                 return ret;
 294
 295         pixelformat = f->fmt.pix.pixelformat;
 296         compression = pdev->vcompression;
 297         snapshot = 0;
 298         fps = pdev->vframes;
 299         if (f->fmt.pix.priv) {
 300                 compression = (f->fmt.pix.priv & PWC_QLT_MASK) >> PWC_QLT_SHIFT;
 301                 snapshot = !!(f->fmt.pix.priv & PWC_FPS_SNAPSHOT);
 302                 fps = (f->fmt.pix.priv & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
 303                 if (fps == 0)
 304                         fps = pdev->vframes;
 305         }
 306
 307         if (pixelformat != V4L2_PIX_FMT_YUV420 &&
 308             pixelformat != V4L2_PIX_FMT_PWC1 &&
 309             pixelformat != V4L2_PIX_FMT_PWC2)
 310                 return -EINVAL;
 311
 312         if (pdev->iso_init)
 313                 return -EBUSY;
 314
 315         PWC_DEBUG_IOCTL("Trying to set format to: width=%d height=%d fps=%d "
 316                         "compression=%d snapshot=%d format=%c%c%c%c\n",
 317                         f->fmt.pix.width, f->fmt.pix.height, fps,
 318                         compression, snapshot,
 319                         (pixelformat)&255,
 320                         (pixelformat>>8)&255,
 321                         (pixelformat>>16)&255,
 322                         (pixelformat>>24)&255);
 323
 324         ret = pwc_set_video_mode(pdev,
 325                                  f->fmt.pix.width,
 326                                  f->fmt.pix.height,
 327                                  fps,
 328                                  compression,
 329                                  snapshot);
 330
 331         PWC_DEBUG_IOCTL("pwc_set_video_mode(), return=%d\n", ret);
 332
 333         if (ret)
 334                 return ret;
 335
 336         pdev->pixfmt = pixelformat;
 337
 338         pwc_vidioc_fill_fmt(pdev, f);
 339
 340         return 0;
 341
 342 }
 343
 344 long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 345 {
 346         struct video_device *vdev = video_devdata(file);
 347         struct pwc_device *pdev;
 348         DECLARE_WAITQUEUE(wait, current);
 349
 350         if (vdev == NULL)
 351                 return -EFAULT;
 352         pdev = video_get_drvdata(vdev);
 353         if (pdev == NULL)
 354                 return -EFAULT;
 355
 356 #ifdef CONFIG_USB_PWC_DEBUG
 357         if (PWC_DEBUG_LEVEL_IOCTL & pwc_trace) {
 358                 v4l_printk_ioctl(cmd);
 359                 printk("\n");
 360         }
 361 #endif
 362
 363
 364         switch (cmd) {
 365 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 366                 /* mmap() functions */
 367                 case VIDIOCGMBUF:
 368                 {
 369                         /* Tell the user program how much memory is needed for a mmap() */
 370                         struct video_mbuf *vm = arg;
 371                         int i;
 372
 373                         memset(vm, 0, sizeof(*vm));
 374                         vm->size = pwc_mbufs * pdev->len_per_image;
 375                         vm->frames = pwc_mbufs; /* double buffering should be enough for most applications */
 376                         for (i = 0; i < pwc_mbufs; i++)
 377                                 vm->offsets[i] = i * pdev->len_per_image;
 378                         break;
 379                 }
 380 #endif
 381
 382                 /* V4L2 Layer */
 383                 case VIDIOC_QUERYCAP:
 384                 {
 385                     struct v4l2_capability *cap = arg;
 386
 387                     PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCAP) This application "\
 388                                        "try to use the v4l2 layer\n");
 389                     strcpy(cap->driver,PWC_NAME);
 390                     strlcpy(cap->card, vdev->name, sizeof(cap->card));
 391                     usb_make_path(pdev->udev,cap->bus_info,sizeof(cap->bus_info));
 392                     cap->version = PWC_VERSION_CODE;
 393                     cap->capabilities =
 394                         V4L2_CAP_VIDEO_CAPTURE  |
 395                         V4L2_CAP_STREAMING      |
 396                         V4L2_CAP_READWRITE;
 397                     return 0;
 398                 }
 399
 400                 case VIDIOC_ENUMINPUT:
 401                 {
 402                     struct v4l2_input *i = arg;
 403
 404                     if ( i->index )     /* Only one INPUT is supported */
 405                           return -EINVAL;
 406
 407                     memset(i, 0, sizeof(struct v4l2_input));
 408                     strcpy(i->name, "usb");
 409                     return 0;
 410                 }
 411
 412                 case VIDIOC_G_INPUT:
 413                 {
 414                     int *i = arg;
 415                     *i = 0;     /* Only one INPUT is supported */
 416                     return 0;
 417                 }
 418                 case VIDIOC_S_INPUT:
 419                 {
 420                         int *i = arg;
 421
 422                         if ( *i ) {     /* Only one INPUT is supported */
 423                                 PWC_DEBUG_IOCTL("Only one input source is"\
 424                                         " supported with this webcam.\n");
 425                                 return -EINVAL;
 426                         }
 427                         return 0;
 428                 }
 429
 430                 /* TODO: */
 431                 case VIDIOC_QUERYCTRL:
 432                 {
 433                         struct v4l2_queryctrl *c = arg;
 434                         int i;
 435
 436                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) query id=%d\n", c->id);
 437                         for (i=0; i<sizeof(pwc_controls)/sizeof(struct v4l2_queryctrl); i++) {
 438                                 if (pwc_controls[i].id == c->id) {
 439                                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) found\n");
 440                                         memcpy(c,&pwc_controls[i],sizeof(struct v4l2_queryctrl));
 441                                         return 0;
 442                                 }
 443                         }
 444                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) not found\n");
 445
 446                         return -EINVAL;
 447                 }
 448                 case VIDIOC_G_CTRL:
 449                 {
 450                         struct v4l2_control *c = arg;
 451                         int ret;
 452
 453                         switch (c->id)
 454                         {
 455                                 case V4L2_CID_BRIGHTNESS:
 456                                         c->value = pwc_get_brightness(pdev);
 457                                         if (c->value<0)
 458                                                 return -EINVAL;
 459                                         return 0;
 460                                 case V4L2_CID_CONTRAST:
 461                                         c->value = pwc_get_contrast(pdev);
 462                                         if (c->value<0)
 463                                                 return -EINVAL;
 464                                         return 0;
 465                                 case V4L2_CID_SATURATION:
 466                                         ret = pwc_get_saturation(pdev, &c->value);
 467                                         if (ret<0)
 468                                                 return -EINVAL;
 469                                         return 0;
 470                                 case V4L2_CID_GAMMA:
 471                                         c->value = pwc_get_gamma(pdev);
 472                                         if (c->value<0)
 473                                                 return -EINVAL;
 474                                         return 0;
 475                                 case V4L2_CID_RED_BALANCE:
 476                                         ret = pwc_get_red_gain(pdev, &c->value);
 477                                         if (ret<0)
 478                                                 return -EINVAL;
 479                                         c->value >>= 8;
 480                                         return 0;
 481                                 case V4L2_CID_BLUE_BALANCE:
 482                                         ret = pwc_get_blue_gain(pdev, &c->value);
 483                                         if (ret<0)
 484                                                 return -EINVAL;
 485                                         c->value >>= 8;
 486                                         return 0;
 487                                 case V4L2_CID_AUTO_WHITE_BALANCE:
 488                                         ret = pwc_get_awb(pdev);
 489                                         if (ret<0)
 490                                                 return -EINVAL;
 491                                         c->value = (ret == PWC_WB_MANUAL)?0:1;
 492                                         return 0;
 493                                 case V4L2_CID_GAIN:
 494                                         ret = pwc_get_agc(pdev, &c->value);
 495                                         if (ret<0)
 496                                                 return -EINVAL;
 497                                         c->value >>= 8;
 498                                         return 0;
 499                                 case V4L2_CID_AUTOGAIN:
 500                                         ret = pwc_get_agc(pdev, &c->value);
 501                                         if (ret<0)
 502                                                 return -EINVAL;
 503                                         c->value = (c->value < 0)?1:0;
 504                                         return 0;
 505                                 case V4L2_CID_EXPOSURE:
 506                                         ret = pwc_get_shutter_speed(pdev, &c->value);
 507                                         if (ret<0)
 508                                                 return -EINVAL;
 509                                         return 0;
 510                                 case V4L2_CID_PRIVATE_COLOUR_MODE:
 511                                         ret = pwc_get_colour_mode(pdev, &c->value);
 512                                         if (ret < 0)
 513                                                 return -EINVAL;
 514                                         return 0;
 515                                 case V4L2_CID_PRIVATE_AUTOCONTOUR:
 516                                         ret = pwc_get_contour(pdev, &c->value);
 517                                         if (ret < 0)
 518                                                 return -EINVAL;
 519                                         c->value=(c->value == -1?1:0);
 520                                         return 0;
 521                                 case V4L2_CID_PRIVATE_CONTOUR:
 522                                         ret = pwc_get_contour(pdev, &c->value);
 523                                         if (ret < 0)
 524                                                 return -EINVAL;
 525                                         c->value >>= 10;
 526                                         return 0;
 527                                 case V4L2_CID_PRIVATE_BACKLIGHT:
 528                                         ret = pwc_get_backlight(pdev, &c->value);
 529                                         if (ret < 0)
 530                                                 return -EINVAL;
 531                                         return 0;
 532                                 case V4L2_CID_PRIVATE_FLICKERLESS:
 533                                         ret = pwc_get_flicker(pdev, &c->value);
 534                                         if (ret < 0)
 535                                                 return -EINVAL;
 536                                         c->value=(c->value?1:0);
 537                                         return 0;
 538                                 case V4L2_CID_PRIVATE_NOISE_REDUCTION:
 539                                         ret = pwc_get_dynamic_noise(pdev, &c->value);
 540                                         if (ret < 0)
 541                                                 return -EINVAL;
 542                                         return 0;
 543
 544                                 case V4L2_CID_PRIVATE_SAVE_USER:
 545                                 case V4L2_CID_PRIVATE_RESTORE_USER:
 546                                 case V4L2_CID_PRIVATE_RESTORE_FACTORY:
 547                                         return -EINVAL;
 548                         }
 549                         return -EINVAL;
 550                 }
 551                 case VIDIOC_S_CTRL:
 552                 {
 553                         struct v4l2_control *c = arg;
 554                         int ret;
 555
 556                         switch (c->id)
 557                         {
 558                                 case V4L2_CID_BRIGHTNESS:
 559                                         c->value <<= 9;
 560                                         ret = pwc_set_brightness(pdev, c->value);
 561                                         if (ret<0)
 562                                                 return -EINVAL;
 563                                         return 0;
 564                                 case V4L2_CID_CONTRAST:
 565                                         c->value <<= 10;
 566                                         ret = pwc_set_contrast(pdev, c->value);
 567                                         if (ret<0)
 568                                                 return -EINVAL;
 569                                         return 0;
 570                                 case V4L2_CID_SATURATION:
 571                                         ret = pwc_set_saturation(pdev, c->value);
 572                                         if (ret<0)
 573                                           return -EINVAL;
 574                                         return 0;
 575                                 case V4L2_CID_GAMMA:
 576                                         c->value <<= 11;
 577                                         ret = pwc_set_gamma(pdev, c->value);
 578                                         if (ret<0)
 579                                                 return -EINVAL;
 580                                         return 0;
 581                                 case V4L2_CID_RED_BALANCE:
 582                                         c->value <<= 8;
 583                                         ret = pwc_set_red_gain(pdev, c->value);
 584                                         if (ret<0)
 585                                                 return -EINVAL;
 586                                         return 0;
 587                                 case V4L2_CID_BLUE_BALANCE:
 588                                         c->value <<= 8;
 589                                         ret = pwc_set_blue_gain(pdev, c->value);
 590                                         if (ret<0)
 591                                                 return -EINVAL;
 592                                         return 0;
 593                                 case V4L2_CID_AUTO_WHITE_BALANCE:
 594                                         c->value = (c->value == 0)?PWC_WB_MANUAL:PWC_WB_AUTO;
 595                                         ret = pwc_set_awb(pdev, c->value);
 596                                         if (ret<0)
 597                                                 return -EINVAL;
 598                                         return 0;
 599                                 case V4L2_CID_EXPOSURE:
 600                                         c->value <<= 8;
 601                                         ret = pwc_set_shutter_speed(pdev, c->value?0:1, c->value);
 602                                         if (ret<0)
 603                                                 return -EINVAL;
 604                                         return 0;
 605                                 case V4L2_CID_AUTOGAIN:
 606                                         /* autogain off means nothing without a gain */
 607                                         if (c->value == 0)
 608                                                 return 0;
 609                                         ret = pwc_set_agc(pdev, c->value, 0);
 610                                         if (ret<0)
 611                                                 return -EINVAL;
 612                                         return 0;
 613                                 case V4L2_CID_GAIN:
 614                                         c->value <<= 8;
 615                                         ret = pwc_set_agc(pdev, 0, c->value);
 616                                         if (ret<0)
 617                                                 return -EINVAL;
 618                                         return 0;
 619                                 case V4L2_CID_PRIVATE_SAVE_USER:
 620                                         if (pwc_save_user(pdev))
 621                                                 return -EINVAL;
 622                                         return 0;
 623                                 case V4L2_CID_PRIVATE_RESTORE_USER:
 624                                         if (pwc_restore_user(pdev))
 625                                                 return -EINVAL;
 626                                         return 0;
 627                                 case V4L2_CID_PRIVATE_RESTORE_FACTORY:
 628                                         if (pwc_restore_factory(pdev))
 629                                                 return -EINVAL;
 630                                         return 0;
 631                                 case V4L2_CID_PRIVATE_COLOUR_MODE:
 632                                         ret = pwc_set_colour_mode(pdev, c->value);
 633                                         if (ret < 0)
 634                                           return -EINVAL;
 635                                         return 0;
 636                                 case V4L2_CID_PRIVATE_AUTOCONTOUR:
 637                                   c->value=(c->value == 1)?-1:0;
 638                                   ret = pwc_set_contour(pdev, c->value);
 639                                   if (ret < 0)
 640                                     return -EINVAL;
 641                                   return 0;
 642                                 case V4L2_CID_PRIVATE_CONTOUR:
 643                                   c->value <<= 10;
 644                                   ret = pwc_set_contour(pdev, c->value);
 645                                   if (ret < 0)
 646                                     return -EINVAL;
 647                                   return 0;
 648                                 case V4L2_CID_PRIVATE_BACKLIGHT:
 649                                   ret = pwc_set_backlight(pdev, c->value);
 650                                   if (ret < 0)
 651                                     return -EINVAL;
 652                                   return 0;
 653                                 case V4L2_CID_PRIVATE_FLICKERLESS:
 654                                   ret = pwc_set_flicker(pdev, c->value);
 655                                   if (ret < 0)
 656                                     return -EINVAL;
 657                                 case V4L2_CID_PRIVATE_NOISE_REDUCTION:
 658                                   ret = pwc_set_dynamic_noise(pdev, c->value);
 659                                   if (ret < 0)
 660                                     return -EINVAL;
 661                                   return 0;
 662
 663                         }
 664                         return -EINVAL;
 665                 }
 666
 667                 case VIDIOC_ENUM_FMT:
 668                 {
 669                         struct v4l2_fmtdesc *f = arg;
 670                         int index;
 671
 672                         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 673                               return -EINVAL;
 674
 675                         /* We only support two format: the raw format, and YUV */
 676                         index = f->index;
 677                         memset(f,0,sizeof(struct v4l2_fmtdesc));
 678                         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 679                         f->index = index;
 680                         switch(index)
 681                         {
 682                                 case 0:
 683                                         /* RAW format */
 684                                         f->pixelformat = pdev->type<=646?V4L2_PIX_FMT_PWC1:V4L2_PIX_FMT_PWC2;
 685                                         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 686                                         strlcpy(f->description,"Raw Philips Webcam",sizeof(f->description));
 687                                         break;
 688                                 case 1:
 689                                         f->pixelformat = V4L2_PIX_FMT_YUV420;
 690                                         strlcpy(f->description,"4:2:0, planar, Y-Cb-Cr",sizeof(f->description));
 691                                         break;
 692                                 default:
 693                                         return -EINVAL;
 694                         }
 695                         return 0;
 696                 }
 697
 698                 case VIDIOC_G_FMT:
 699                 {
 700                         struct v4l2_format *f = arg;
 701
 702                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",pdev->image.x,pdev->image.y);
 703                         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 704                               return -EINVAL;
 705
 706                         pwc_vidioc_fill_fmt(pdev, f);
 707
 708                         return 0;
 709                 }
 710
 711                 case VIDIOC_TRY_FMT:
 712                         return pwc_vidioc_try_fmt(pdev, arg);
 713
 714                 case VIDIOC_S_FMT:
 715                         return pwc_vidioc_set_fmt(pdev, arg);
 716
 717                 case VIDIOC_G_STD:
 718                 {
 719                         v4l2_std_id *std = arg;
 720                         *std = V4L2_STD_UNKNOWN;
 721                         return 0;
 722                 }
 723
 724                 case VIDIOC_S_STD:
 725                 {
 726                         v4l2_std_id *std = arg;
 727                         if (*std != V4L2_STD_UNKNOWN)
 728                                 return -EINVAL;
 729                         return 0;
 730                 }
 731
 732                 case VIDIOC_ENUMSTD:
 733                 {
 734                         struct v4l2_standard *std = arg;
 735                         if (std->index != 0)
 736                                 return -EINVAL;
 737                         std->id = V4L2_STD_UNKNOWN;
 738                         strlcpy(std->name, "webcam", sizeof(std->name));
 739                         return 0;
 740                 }
 741
 742                 case VIDIOC_REQBUFS:
 743                 {
 744                         struct v4l2_requestbuffers *rb = arg;
 745                         int nbuffers;
 746
 747                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_REQBUFS) count=%d\n",rb->count);
 748                         if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 749                                 return -EINVAL;
 750                         if (rb->memory != V4L2_MEMORY_MMAP)
 751                                 return -EINVAL;
 752
 753                         nbuffers = rb->count;
 754                         if (nbuffers < 2)
 755                                 nbuffers = 2;
 756                         else if (nbuffers > pwc_mbufs)
 757                                 nbuffers = pwc_mbufs;
 758                         /* Force to use our # of buffers */
 759                         rb->count = pwc_mbufs;
 760                         return 0;
 761                 }
 762
 763                 case VIDIOC_QUERYBUF:
 764                 {
 765                         struct v4l2_buffer *buf = arg;
 766                         int index;
 767
 768                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) index=%d\n",buf->index);
 769                         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 770                                 PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad type\n");
 771                                 return -EINVAL;
 772                         }
 773                         if (buf->memory != V4L2_MEMORY_MMAP) {
 774                                 PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad memory type\n");
 775                                 return -EINVAL;
 776                         }
 777                         index = buf->index;
 778                         if (index < 0 || index >= pwc_mbufs) {
 779                                 PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad index %d\n", buf->index);
 780                                 return -EINVAL;
 781                         }
 782
 783                         memset(buf, 0, sizeof(struct v4l2_buffer));
 784                         buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 785                         buf->index = index;
 786                         buf->m.offset = index * pdev->len_per_image;
 787                         if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
 788                                 buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
 789                         else
 790                                 buf->bytesused = pdev->view.size;
 791                         buf->field = V4L2_FIELD_NONE;
 792                         buf->memory = V4L2_MEMORY_MMAP;
 793                         //buf->flags = V4L2_BUF_FLAG_MAPPED;
 794                         buf->length = pdev->len_per_image;
 795
 796                         PWC_DEBUG_READ("VIDIOC_QUERYBUF: index=%d\n",buf->index);
 797                         PWC_DEBUG_READ("VIDIOC_QUERYBUF: m.offset=%d\n",buf->m.offset);
 798                         PWC_DEBUG_READ("VIDIOC_QUERYBUF: bytesused=%d\n",buf->bytesused);
 799
 800                         return 0;
 801                 }
 802
 803                 case VIDIOC_QBUF:
 804                 {
 805                         struct v4l2_buffer *buf = arg;
 806
 807                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QBUF) index=%d\n",buf->index);
 808                         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 809                                 return -EINVAL;
 810                         if (buf->memory != V4L2_MEMORY_MMAP)
 811                                 return -EINVAL;
 812                         if (buf->index >= pwc_mbufs)
 813                                 return -EINVAL;
 814
 815                         buf->flags |= V4L2_BUF_FLAG_QUEUED;
 816                         buf->flags &= ~V4L2_BUF_FLAG_DONE;
 817
 818                         return 0;
 819                 }
 820
 821                 case VIDIOC_DQBUF:
 822                 {
 823                         struct v4l2_buffer *buf = arg;
 824                         int ret;
 825
 826                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_DQBUF)\n");
 827
 828                         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 829                                 return -EINVAL;
 830
 831                         /* Add ourselves to the frame wait-queue.
 832
 833                            FIXME: needs auditing for safety.
 834                            QUESTION: In what respect? I think that using the
 835                                      frameq is safe now.
 836                          */
 837                         add_wait_queue(&pdev->frameq, &wait);
 838                         while (pdev->full_frames == NULL) {
 839                                 if (pdev->error_status) {
 840                                         remove_wait_queue(&pdev->frameq, &wait);
 841                                         set_current_state(TASK_RUNNING);
 842                                         return -pdev->error_status;
 843                                 }
 844
 845                                 if (signal_pending(current)) {
 846                                         remove_wait_queue(&pdev->frameq, &wait);
 847                                         set_current_state(TASK_RUNNING);
 848                                         return -ERESTARTSYS;
 849                                 }
 850                                 schedule();
 851                                 set_current_state(TASK_INTERRUPTIBLE);
 852                         }
 853                         remove_wait_queue(&pdev->frameq, &wait);
 854                         set_current_state(TASK_RUNNING);
 855
 856                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: frame ready.\n");
 857                         /* Decompress data in pdev->images[pdev->fill_image] */
 858                         ret = pwc_handle_frame(pdev);
 859                         if (ret)
 860                                 return -EFAULT;
 861                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: after pwc_handle_frame\n");
 862
 863                         buf->index = pdev->fill_image;
 864                         if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
 865                                 buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
 866                         else
 867                                 buf->bytesused = pdev->view.size;
 868                         buf->flags = V4L2_BUF_FLAG_MAPPED;
 869                         buf->field = V4L2_FIELD_NONE;
 870                         do_gettimeofday(&buf->timestamp);
 871                         buf->sequence = 0;
 872                         buf->memory = V4L2_MEMORY_MMAP;
 873                         buf->m.offset = pdev->fill_image * pdev->len_per_image;
 874                         buf->length = pdev->len_per_image;
 875                         pwc_next_image(pdev);
 876
 877                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->index=%d\n",buf->index);
 878                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->length=%d\n",buf->length);
 879                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: m.offset=%d\n",buf->m.offset);
 880                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: bytesused=%d\n",buf->bytesused);
 881                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: leaving\n");
 882                         return 0;
 883
 884                 }
 885
 886                 case VIDIOC_STREAMON:
 887                 {
 888                         return pwc_isoc_init(pdev);
 889                 }
 890
 891                 case VIDIOC_STREAMOFF:
 892                 {
 893                         pwc_isoc_cleanup(pdev);
 894                         return 0;
 895                 }
 896
 897                 case VIDIOC_ENUM_FRAMESIZES:
 898                 {
 899                         struct v4l2_frmsizeenum *fsize = arg;
 900                         unsigned int i = 0, index = fsize->index;
 901
 902                         if (fsize->pixel_format == V4L2_PIX_FMT_YUV420) {
 903                                 for (i = 0; i < PSZ_MAX; i++) {
 904                                         if (pdev->image_mask & (1UL << i)) {
 905                                                 if (!index--) {
 906                                                         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 907                                                         fsize->discrete.width = pwc_image_sizes[i].x;
 908                                                         fsize->discrete.height = pwc_image_sizes[i].y;
 909                                                         return 0;
 910                                                 }
 911                                         }
 912                                 }
 913                         } else if (fsize->index == 0 &&
 914                                    ((fsize->pixel_format == V4L2_PIX_FMT_PWC1 && DEVICE_USE_CODEC1(pdev->type)) ||
 915                                     (fsize->pixel_format == V4L2_PIX_FMT_PWC2 && DEVICE_USE_CODEC23(pdev->type)))) {
 916
 917                                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 918                                 fsize->discrete.width = pdev->abs_max.x;
 919                                 fsize->discrete.height = pdev->abs_max.y;
 920                                 return 0;
 921                         }
 922                         return -EINVAL;
 923                 }
 924
 925                 case VIDIOC_ENUM_FRAMEINTERVALS:
 926                 {
 927                         struct v4l2_frmivalenum *fival = arg;
 928                         int size = -1;
 929                         unsigned int i;
 930
 931                         for (i = 0; i < PSZ_MAX; i++) {
 932                                 if (pwc_image_sizes[i].x == fival->width &&
 933                                     pwc_image_sizes[i].y == fival->height) {
 934                                         size = i;
 935                                         break;
 936                                 }
 937                         }
 938
 939                         /* TODO: Support raw format */
 940                         if (size < 0 || fival->pixel_format != V4L2_PIX_FMT_YUV420) {
 941                                 return -EINVAL;
 942                         }
 943
 944                         i = pwc_get_fps(pdev, fival->index, size);
 945                         if (!i)
 946                                 return -EINVAL;
 947
 948                         fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
 949                         fival->discrete.numerator = 1;
 950                         fival->discrete.denominator = i;
 951
 952                         return 0;
 953                 }
 954
 955                 default:
 956                         return pwc_ioctl(pdev, cmd, arg);
 957         } /* ..switch */
 958         return 0;
 959 }
 960
 961 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */