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         PWC_DEBUG_IOCTL("Try to change format to: width=%d height=%d fps=%d "
 313                         "compression=%d snapshot=%d format=%c%c%c%c\n",
 314                         f->fmt.pix.width, f->fmt.pix.height, fps,
 315                         compression, snapshot,
 316                         (pixelformat)&255,
 317                         (pixelformat>>8)&255,
 318                         (pixelformat>>16)&255,
 319                         (pixelformat>>24)&255);
 320
 321         ret = pwc_try_video_mode(pdev,
 322                                  f->fmt.pix.width,
 323                                  f->fmt.pix.height,
 324                                  fps,
 325                                  compression,
 326                                  snapshot);
 327
 328         PWC_DEBUG_IOCTL("pwc_try_video_mode(), return=%d\n", ret);
 329
 330         if (ret)
 331                 return ret;
 332
 333         pdev->pixfmt = pixelformat;
 334
 335         pwc_vidioc_fill_fmt(pdev, f);
 336
 337         return 0;
 338
 339 }
 340
 341 long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 342 {
 343         struct video_device *vdev = video_devdata(file);
 344         struct pwc_device *pdev;
 345         DECLARE_WAITQUEUE(wait, current);
 346
 347         if (vdev == NULL)
 348                 return -EFAULT;
 349         pdev = video_get_drvdata(vdev);
 350         if (pdev == NULL)
 351                 return -EFAULT;
 352
 353 #ifdef CONFIG_USB_PWC_DEBUG
 354         if (PWC_DEBUG_LEVEL_IOCTL & pwc_trace) {
 355                 v4l_printk_ioctl(cmd);
 356                 printk("\n");
 357         }
 358 #endif
 359
 360
 361         switch (cmd) {
 362 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 363                 /* mmap() functions */
 364                 case VIDIOCGMBUF:
 365                 {
 366                         /* Tell the user program how much memory is needed for a mmap() */
 367                         struct video_mbuf *vm = arg;
 368                         int i;
 369
 370                         memset(vm, 0, sizeof(*vm));
 371                         vm->size = pwc_mbufs * pdev->len_per_image;
 372                         vm->frames = pwc_mbufs; /* double buffering should be enough for most applications */
 373                         for (i = 0; i < pwc_mbufs; i++)
 374                                 vm->offsets[i] = i * pdev->len_per_image;
 375                         break;
 376                 }
 377 #endif
 378
 379                 /* V4L2 Layer */
 380                 case VIDIOC_QUERYCAP:
 381                 {
 382                     struct v4l2_capability *cap = arg;
 383
 384                     PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCAP) This application "\
 385                                        "try to use the v4l2 layer\n");
 386                     strcpy(cap->driver,PWC_NAME);
 387                     strlcpy(cap->card, vdev->name, sizeof(cap->card));
 388                     usb_make_path(pdev->udev,cap->bus_info,sizeof(cap->bus_info));
 389                     cap->version = PWC_VERSION_CODE;
 390                     cap->capabilities =
 391                         V4L2_CAP_VIDEO_CAPTURE  |
 392                         V4L2_CAP_STREAMING      |
 393                         V4L2_CAP_READWRITE;
 394                     return 0;
 395                 }
 396
 397                 case VIDIOC_ENUMINPUT:
 398                 {
 399                     struct v4l2_input *i = arg;
 400
 401                     if ( i->index )     /* Only one INPUT is supported */
 402                           return -EINVAL;
 403
 404                     memset(i, 0, sizeof(struct v4l2_input));
 405                     strcpy(i->name, "usb");
 406                     return 0;
 407                 }
 408
 409                 case VIDIOC_G_INPUT:
 410                 {
 411                     int *i = arg;
 412                     *i = 0;     /* Only one INPUT is supported */
 413                     return 0;
 414                 }
 415                 case VIDIOC_S_INPUT:
 416                 {
 417                         int *i = arg;
 418
 419                         if ( *i ) {     /* Only one INPUT is supported */
 420                                 PWC_DEBUG_IOCTL("Only one input source is"\
 421                                         " supported with this webcam.\n");
 422                                 return -EINVAL;
 423                         }
 424                         return 0;
 425                 }
 426
 427                 /* TODO: */
 428                 case VIDIOC_QUERYCTRL:
 429                 {
 430                         struct v4l2_queryctrl *c = arg;
 431                         int i;
 432
 433                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) query id=%d\n", c->id);
 434                         for (i=0; i<sizeof(pwc_controls)/sizeof(struct v4l2_queryctrl); i++) {
 435                                 if (pwc_controls[i].id == c->id) {
 436                                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) found\n");
 437                                         memcpy(c,&pwc_controls[i],sizeof(struct v4l2_queryctrl));
 438                                         return 0;
 439                                 }
 440                         }
 441                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) not found\n");
 442
 443                         return -EINVAL;
 444                 }
 445                 case VIDIOC_G_CTRL:
 446                 {
 447                         struct v4l2_control *c = arg;
 448                         int ret;
 449
 450                         switch (c->id)
 451                         {
 452                                 case V4L2_CID_BRIGHTNESS:
 453                                         c->value = pwc_get_brightness(pdev);
 454                                         if (c->value<0)
 455                                                 return -EINVAL;
 456                                         return 0;
 457                                 case V4L2_CID_CONTRAST:
 458                                         c->value = pwc_get_contrast(pdev);
 459                                         if (c->value<0)
 460                                                 return -EINVAL;
 461                                         return 0;
 462                                 case V4L2_CID_SATURATION:
 463                                         ret = pwc_get_saturation(pdev, &c->value);
 464                                         if (ret<0)
 465                                                 return -EINVAL;
 466                                         return 0;
 467                                 case V4L2_CID_GAMMA:
 468                                         c->value = pwc_get_gamma(pdev);
 469                                         if (c->value<0)
 470                                                 return -EINVAL;
 471                                         return 0;
 472                                 case V4L2_CID_RED_BALANCE:
 473                                         ret = pwc_get_red_gain(pdev, &c->value);
 474                                         if (ret<0)
 475                                                 return -EINVAL;
 476                                         c->value >>= 8;
 477                                         return 0;
 478                                 case V4L2_CID_BLUE_BALANCE:
 479                                         ret = pwc_get_blue_gain(pdev, &c->value);
 480                                         if (ret<0)
 481                                                 return -EINVAL;
 482                                         c->value >>= 8;
 483                                         return 0;
 484                                 case V4L2_CID_AUTO_WHITE_BALANCE:
 485                                         ret = pwc_get_awb(pdev);
 486                                         if (ret<0)
 487                                                 return -EINVAL;
 488                                         c->value = (ret == PWC_WB_MANUAL)?0:1;
 489                                         return 0;
 490                                 case V4L2_CID_GAIN:
 491                                         ret = pwc_get_agc(pdev, &c->value);
 492                                         if (ret<0)
 493                                                 return -EINVAL;
 494                                         c->value >>= 8;
 495                                         return 0;
 496                                 case V4L2_CID_AUTOGAIN:
 497                                         ret = pwc_get_agc(pdev, &c->value);
 498                                         if (ret<0)
 499                                                 return -EINVAL;
 500                                         c->value = (c->value < 0)?1:0;
 501                                         return 0;
 502                                 case V4L2_CID_EXPOSURE:
 503                                         ret = pwc_get_shutter_speed(pdev, &c->value);
 504                                         if (ret<0)
 505                                                 return -EINVAL;
 506                                         return 0;
 507                                 case V4L2_CID_PRIVATE_COLOUR_MODE:
 508                                         ret = pwc_get_colour_mode(pdev, &c->value);
 509                                         if (ret < 0)
 510                                                 return -EINVAL;
 511                                         return 0;
 512                                 case V4L2_CID_PRIVATE_AUTOCONTOUR:
 513                                         ret = pwc_get_contour(pdev, &c->value);
 514                                         if (ret < 0)
 515                                                 return -EINVAL;
 516                                         c->value=(c->value == -1?1:0);
 517                                         return 0;
 518                                 case V4L2_CID_PRIVATE_CONTOUR:
 519                                         ret = pwc_get_contour(pdev, &c->value);
 520                                         if (ret < 0)
 521                                                 return -EINVAL;
 522                                         c->value >>= 10;
 523                                         return 0;
 524                                 case V4L2_CID_PRIVATE_BACKLIGHT:
 525                                         ret = pwc_get_backlight(pdev, &c->value);
 526                                         if (ret < 0)
 527                                                 return -EINVAL;
 528                                         return 0;
 529                                 case V4L2_CID_PRIVATE_FLICKERLESS:
 530                                         ret = pwc_get_flicker(pdev, &c->value);
 531                                         if (ret < 0)
 532                                                 return -EINVAL;
 533                                         c->value=(c->value?1:0);
 534                                         return 0;
 535                                 case V4L2_CID_PRIVATE_NOISE_REDUCTION:
 536                                         ret = pwc_get_dynamic_noise(pdev, &c->value);
 537                                         if (ret < 0)
 538                                                 return -EINVAL;
 539                                         return 0;
 540
 541                                 case V4L2_CID_PRIVATE_SAVE_USER:
 542                                 case V4L2_CID_PRIVATE_RESTORE_USER:
 543                                 case V4L2_CID_PRIVATE_RESTORE_FACTORY:
 544                                         return -EINVAL;
 545                         }
 546                         return -EINVAL;
 547                 }
 548                 case VIDIOC_S_CTRL:
 549                 {
 550                         struct v4l2_control *c = arg;
 551                         int ret;
 552
 553                         switch (c->id)
 554                         {
 555                                 case V4L2_CID_BRIGHTNESS:
 556                                         c->value <<= 9;
 557                                         ret = pwc_set_brightness(pdev, c->value);
 558                                         if (ret<0)
 559                                                 return -EINVAL;
 560                                         return 0;
 561                                 case V4L2_CID_CONTRAST:
 562                                         c->value <<= 10;
 563                                         ret = pwc_set_contrast(pdev, c->value);
 564                                         if (ret<0)
 565                                                 return -EINVAL;
 566                                         return 0;
 567                                 case V4L2_CID_SATURATION:
 568                                         ret = pwc_set_saturation(pdev, c->value);
 569                                         if (ret<0)
 570                                           return -EINVAL;
 571                                         return 0;
 572                                 case V4L2_CID_GAMMA:
 573                                         c->value <<= 11;
 574                                         ret = pwc_set_gamma(pdev, c->value);
 575                                         if (ret<0)
 576                                                 return -EINVAL;
 577                                         return 0;
 578                                 case V4L2_CID_RED_BALANCE:
 579                                         c->value <<= 8;
 580                                         ret = pwc_set_red_gain(pdev, c->value);
 581                                         if (ret<0)
 582                                                 return -EINVAL;
 583                                         return 0;
 584                                 case V4L2_CID_BLUE_BALANCE:
 585                                         c->value <<= 8;
 586                                         ret = pwc_set_blue_gain(pdev, c->value);
 587                                         if (ret<0)
 588                                                 return -EINVAL;
 589                                         return 0;
 590                                 case V4L2_CID_AUTO_WHITE_BALANCE:
 591                                         c->value = (c->value == 0)?PWC_WB_MANUAL:PWC_WB_AUTO;
 592                                         ret = pwc_set_awb(pdev, c->value);
 593                                         if (ret<0)
 594                                                 return -EINVAL;
 595                                         return 0;
 596                                 case V4L2_CID_EXPOSURE:
 597                                         c->value <<= 8;
 598                                         ret = pwc_set_shutter_speed(pdev, c->value?0:1, c->value);
 599                                         if (ret<0)
 600                                                 return -EINVAL;
 601                                         return 0;
 602                                 case V4L2_CID_AUTOGAIN:
 603                                         /* autogain off means nothing without a gain */
 604                                         if (c->value == 0)
 605                                                 return 0;
 606                                         ret = pwc_set_agc(pdev, c->value, 0);
 607                                         if (ret<0)
 608                                                 return -EINVAL;
 609                                         return 0;
 610                                 case V4L2_CID_GAIN:
 611                                         c->value <<= 8;
 612                                         ret = pwc_set_agc(pdev, 0, c->value);
 613                                         if (ret<0)
 614                                                 return -EINVAL;
 615                                         return 0;
 616                                 case V4L2_CID_PRIVATE_SAVE_USER:
 617                                         if (pwc_save_user(pdev))
 618                                                 return -EINVAL;
 619                                         return 0;
 620                                 case V4L2_CID_PRIVATE_RESTORE_USER:
 621                                         if (pwc_restore_user(pdev))
 622                                                 return -EINVAL;
 623                                         return 0;
 624                                 case V4L2_CID_PRIVATE_RESTORE_FACTORY:
 625                                         if (pwc_restore_factory(pdev))
 626                                                 return -EINVAL;
 627                                         return 0;
 628                                 case V4L2_CID_PRIVATE_COLOUR_MODE:
 629                                         ret = pwc_set_colour_mode(pdev, c->value);
 630                                         if (ret < 0)
 631                                           return -EINVAL;
 632                                         return 0;
 633                                 case V4L2_CID_PRIVATE_AUTOCONTOUR:
 634                                   c->value=(c->value == 1)?-1:0;
 635                                   ret = pwc_set_contour(pdev, c->value);
 636                                   if (ret < 0)
 637                                     return -EINVAL;
 638                                   return 0;
 639                                 case V4L2_CID_PRIVATE_CONTOUR:
 640                                   c->value <<= 10;
 641                                   ret = pwc_set_contour(pdev, c->value);
 642                                   if (ret < 0)
 643                                     return -EINVAL;
 644                                   return 0;
 645                                 case V4L2_CID_PRIVATE_BACKLIGHT:
 646                                   ret = pwc_set_backlight(pdev, c->value);
 647                                   if (ret < 0)
 648                                     return -EINVAL;
 649                                   return 0;
 650                                 case V4L2_CID_PRIVATE_FLICKERLESS:
 651                                   ret = pwc_set_flicker(pdev, c->value);
 652                                   if (ret < 0)
 653                                     return -EINVAL;
 654                                 case V4L2_CID_PRIVATE_NOISE_REDUCTION:
 655                                   ret = pwc_set_dynamic_noise(pdev, c->value);
 656                                   if (ret < 0)
 657                                     return -EINVAL;
 658                                   return 0;
 659
 660                         }
 661                         return -EINVAL;
 662                 }
 663
 664                 case VIDIOC_ENUM_FMT:
 665                 {
 666                         struct v4l2_fmtdesc *f = arg;
 667                         int index;
 668
 669                         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 670                               return -EINVAL;
 671
 672                         /* We only support two format: the raw format, and YUV */
 673                         index = f->index;
 674                         memset(f,0,sizeof(struct v4l2_fmtdesc));
 675                         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 676                         f->index = index;
 677                         switch(index)
 678                         {
 679                                 case 0:
 680                                         /* RAW format */
 681                                         f->pixelformat = pdev->type<=646?V4L2_PIX_FMT_PWC1:V4L2_PIX_FMT_PWC2;
 682                                         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 683                                         strlcpy(f->description,"Raw Philips Webcam",sizeof(f->description));
 684                                         break;
 685                                 case 1:
 686                                         f->pixelformat = V4L2_PIX_FMT_YUV420;
 687                                         strlcpy(f->description,"4:2:0, planar, Y-Cb-Cr",sizeof(f->description));
 688                                         break;
 689                                 default:
 690                                         return -EINVAL;
 691                         }
 692                         return 0;
 693                 }
 694
 695                 case VIDIOC_G_FMT:
 696                 {
 697                         struct v4l2_format *f = arg;
 698
 699                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",pdev->image.x,pdev->image.y);
 700                         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 701                               return -EINVAL;
 702
 703                         pwc_vidioc_fill_fmt(pdev, f);
 704
 705                         return 0;
 706                 }
 707
 708                 case VIDIOC_TRY_FMT:
 709                         return pwc_vidioc_try_fmt(pdev, arg);
 710
 711                 case VIDIOC_S_FMT:
 712                         return pwc_vidioc_set_fmt(pdev, arg);
 713
 714                 case VIDIOC_G_STD:
 715                 {
 716                         v4l2_std_id *std = arg;
 717                         *std = V4L2_STD_UNKNOWN;
 718                         return 0;
 719                 }
 720
 721                 case VIDIOC_S_STD:
 722                 {
 723                         v4l2_std_id *std = arg;
 724                         if (*std != V4L2_STD_UNKNOWN)
 725                                 return -EINVAL;
 726                         return 0;
 727                 }
 728
 729                 case VIDIOC_ENUMSTD:
 730                 {
 731                         struct v4l2_standard *std = arg;
 732                         if (std->index != 0)
 733                                 return -EINVAL;
 734                         std->id = V4L2_STD_UNKNOWN;
 735                         strlcpy(std->name, "webcam", sizeof(std->name));
 736                         return 0;
 737                 }
 738
 739                 case VIDIOC_REQBUFS:
 740                 {
 741                         struct v4l2_requestbuffers *rb = arg;
 742                         int nbuffers;
 743
 744                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_REQBUFS) count=%d\n",rb->count);
 745                         if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 746                                 return -EINVAL;
 747                         if (rb->memory != V4L2_MEMORY_MMAP)
 748                                 return -EINVAL;
 749
 750                         nbuffers = rb->count;
 751                         if (nbuffers < 2)
 752                                 nbuffers = 2;
 753                         else if (nbuffers > pwc_mbufs)
 754                                 nbuffers = pwc_mbufs;
 755                         /* Force to use our # of buffers */
 756                         rb->count = pwc_mbufs;
 757                         return 0;
 758                 }
 759
 760                 case VIDIOC_QUERYBUF:
 761                 {
 762                         struct v4l2_buffer *buf = arg;
 763                         int index;
 764
 765                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) index=%d\n",buf->index);
 766                         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 767                                 PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad type\n");
 768                                 return -EINVAL;
 769                         }
 770                         if (buf->memory != V4L2_MEMORY_MMAP) {
 771                                 PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad memory type\n");
 772                                 return -EINVAL;
 773                         }
 774                         index = buf->index;
 775                         if (index < 0 || index >= pwc_mbufs) {
 776                                 PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad index %d\n", buf->index);
 777                                 return -EINVAL;
 778                         }
 779
 780                         memset(buf, 0, sizeof(struct v4l2_buffer));
 781                         buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 782                         buf->index = index;
 783                         buf->m.offset = index * pdev->len_per_image;
 784                         if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
 785                                 buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
 786                         else
 787                                 buf->bytesused = pdev->view.size;
 788                         buf->field = V4L2_FIELD_NONE;
 789                         buf->memory = V4L2_MEMORY_MMAP;
 790                         //buf->flags = V4L2_BUF_FLAG_MAPPED;
 791                         buf->length = pdev->len_per_image;
 792
 793                         PWC_DEBUG_READ("VIDIOC_QUERYBUF: index=%d\n",buf->index);
 794                         PWC_DEBUG_READ("VIDIOC_QUERYBUF: m.offset=%d\n",buf->m.offset);
 795                         PWC_DEBUG_READ("VIDIOC_QUERYBUF: bytesused=%d\n",buf->bytesused);
 796
 797                         return 0;
 798                 }
 799
 800                 case VIDIOC_QBUF:
 801                 {
 802                         struct v4l2_buffer *buf = arg;
 803
 804                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_QBUF) index=%d\n",buf->index);
 805                         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 806                                 return -EINVAL;
 807                         if (buf->memory != V4L2_MEMORY_MMAP)
 808                                 return -EINVAL;
 809                         if (buf->index >= pwc_mbufs)
 810                                 return -EINVAL;
 811
 812                         buf->flags |= V4L2_BUF_FLAG_QUEUED;
 813                         buf->flags &= ~V4L2_BUF_FLAG_DONE;
 814
 815                         return 0;
 816                 }
 817
 818                 case VIDIOC_DQBUF:
 819                 {
 820                         struct v4l2_buffer *buf = arg;
 821                         int ret;
 822
 823                         PWC_DEBUG_IOCTL("ioctl(VIDIOC_DQBUF)\n");
 824
 825                         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 826                                 return -EINVAL;
 827
 828                         /* Add ourselves to the frame wait-queue.
 829
 830                            FIXME: needs auditing for safety.
 831                            QUESTION: In what respect? I think that using the
 832                                      frameq is safe now.
 833                          */
 834                         add_wait_queue(&pdev->frameq, &wait);
 835                         while (pdev->full_frames == NULL) {
 836                                 if (pdev->error_status) {
 837                                         remove_wait_queue(&pdev->frameq, &wait);
 838                                         set_current_state(TASK_RUNNING);
 839                                         return -pdev->error_status;
 840                                 }
 841
 842                                 if (signal_pending(current)) {
 843                                         remove_wait_queue(&pdev->frameq, &wait);
 844                                         set_current_state(TASK_RUNNING);
 845                                         return -ERESTARTSYS;
 846                                 }
 847                                 schedule();
 848                                 set_current_state(TASK_INTERRUPTIBLE);
 849                         }
 850                         remove_wait_queue(&pdev->frameq, &wait);
 851                         set_current_state(TASK_RUNNING);
 852
 853                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: frame ready.\n");
 854                         /* Decompress data in pdev->images[pdev->fill_image] */
 855                         ret = pwc_handle_frame(pdev);
 856                         if (ret)
 857                                 return -EFAULT;
 858                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: after pwc_handle_frame\n");
 859
 860                         buf->index = pdev->fill_image;
 861                         if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
 862                                 buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
 863                         else
 864                                 buf->bytesused = pdev->view.size;
 865                         buf->flags = V4L2_BUF_FLAG_MAPPED;
 866                         buf->field = V4L2_FIELD_NONE;
 867                         do_gettimeofday(&buf->timestamp);
 868                         buf->sequence = 0;
 869                         buf->memory = V4L2_MEMORY_MMAP;
 870                         buf->m.offset = pdev->fill_image * pdev->len_per_image;
 871                         buf->length = pdev->len_per_image;
 872                         pwc_next_image(pdev);
 873
 874                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->index=%d\n",buf->index);
 875                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->length=%d\n",buf->length);
 876                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: m.offset=%d\n",buf->m.offset);
 877                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: bytesused=%d\n",buf->bytesused);
 878                         PWC_DEBUG_IOCTL("VIDIOC_DQBUF: leaving\n");
 879                         return 0;
 880
 881                 }
 882
 883                 case VIDIOC_STREAMON:
 884                 {
 885                         /* WARNING: pwc_try_video_mode() called pwc_isoc_init */
 886                         pwc_isoc_init(pdev);
 887                         return 0;
 888                 }
 889
 890                 case VIDIOC_STREAMOFF:
 891                 {
 892                         pwc_isoc_cleanup(pdev);
 893                         return 0;
 894                 }
 895
 896                 case VIDIOC_ENUM_FRAMESIZES:
 897                 {
 898                         struct v4l2_frmsizeenum *fsize = arg;
 899                         unsigned int i = 0, index = fsize->index;
 900
 901                         if (fsize->pixel_format == V4L2_PIX_FMT_YUV420) {
 902                                 for (i = 0; i < PSZ_MAX; i++) {
 903                                         if (pdev->image_mask & (1UL << i)) {
 904                                                 if (!index--) {
 905                                                         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 906                                                         fsize->discrete.width = pwc_image_sizes[i].x;
 907                                                         fsize->discrete.height = pwc_image_sizes[i].y;
 908                                                         return 0;
 909                                                 }
 910                                         }
 911                                 }
 912                         } else if (fsize->index == 0 &&
 913                                    ((fsize->pixel_format == V4L2_PIX_FMT_PWC1 && DEVICE_USE_CODEC1(pdev->type)) ||
 914                                     (fsize->pixel_format == V4L2_PIX_FMT_PWC2 && DEVICE_USE_CODEC23(pdev->type)))) {
 915
 916                                 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 917                                 fsize->discrete.width = pdev->abs_max.x;
 918                                 fsize->discrete.height = pdev->abs_max.y;
 919                                 return 0;
 920                         }
 921                         return -EINVAL;
 922                 }
 923
 924                 case VIDIOC_ENUM_FRAMEINTERVALS:
 925                 {
 926                         struct v4l2_frmivalenum *fival = arg;
 927                         int size = -1;
 928                         unsigned int i;
 929
 930                         for (i = 0; i < PSZ_MAX; i++) {
 931                                 if (pwc_image_sizes[i].x == fival->width &&
 932                                     pwc_image_sizes[i].y == fival->height) {
 933                                         size = i;
 934                                         break;
 935                                 }
 936                         }
 937
 938                         /* TODO: Support raw format */
 939                         if (size < 0 || fival->pixel_format != V4L2_PIX_FMT_YUV420) {
 940                                 return -EINVAL;
 941                         }
 942
 943                         i = pwc_get_fps(pdev, fival->index, size);
 944                         if (!i)
 945                                 return -EINVAL;
 946
 947                         fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
 948                         fival->discrete.numerator = 1;
 949                         fival->discrete.denominator = i;
 950
 951                         return 0;
 952                 }
 953
 954                 default:
 955                         return pwc_ioctl(pdev, cmd, arg);
 956         } /* ..switch */
 957         return 0;
 958 }
 959
 960 /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */