Pileus Git - ~andy/linux/blob - drivers/media/video/pwc/pwc-ctrl.c

   1 /* Driver for Philips webcam
   2    Functions that send various control messages to the webcam, including
   3    video modes.
   4    (C) 1999-2003 Nemosoft Unv.
   5    (C) 2004-2006 Luc Saillard (luc@saillard.org)
   6    (C) 2011 Hans de Goede <hdegoede@redhat.com>
   7
   8    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
   9    driver and thus may have bugs that are not present in the original version.
  10    Please send bug reports and support requests to <luc@saillard.org>.
  11
  12    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
  13    driver and thus may have bugs that are not present in the original version.
  14    Please send bug reports and support requests to <luc@saillard.org>.
  15    The decompression routines have been implemented by reverse-engineering the
  16    Nemosoft binary pwcx module. Caveat emptor.
  17
  18    This program is free software; you can redistribute it and/or modify
  19    it under the terms of the GNU General Public License as published by
  20    the Free Software Foundation; either version 2 of the License, or
  21    (at your option) any later version.
  22
  23    This program is distributed in the hope that it will be useful,
  24    but WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26    GNU General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program; if not, write to the Free Software
  30    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  31 */
  32
  33 /*
  34    Changes
  35    2001/08/03  Alvarado   Added methods for changing white balance and
  36                           red/green gains
  37  */
  38
  39 /* Control functions for the cam; brightness, contrast, video mode, etc. */
  40
  41 #ifdef __KERNEL__
  42 #include <asm/uaccess.h>
  43 #endif
  44 #include <asm/errno.h>
  45
  46 #include "pwc.h"
  47 #include "pwc-kiara.h"
  48 #include "pwc-timon.h"
  49 #include "pwc-dec1.h"
  50 #include "pwc-dec23.h"
  51
  52 /* Selectors for status controls used only in this file */
  53 #define GET_STATUS_B00                          0x0B00
  54 #define SENSOR_TYPE_FORMATTER1                  0x0C00
  55 #define GET_STATUS_3000                         0x3000
  56 #define READ_RAW_Y_MEAN_FORMATTER               0x3100
  57 #define SET_POWER_SAVE_MODE_FORMATTER           0x3200
  58 #define MIRROR_IMAGE_FORMATTER                  0x3300
  59 #define LED_FORMATTER                           0x3400
  60 #define LOWLIGHT                                0x3500
  61 #define GET_STATUS_3600                         0x3600
  62 #define SENSOR_TYPE_FORMATTER2                  0x3700
  63 #define GET_STATUS_3800                         0x3800
  64 #define GET_STATUS_4000                         0x4000
  65 #define GET_STATUS_4100                         0x4100  /* Get */
  66 #define CTL_STATUS_4200                         0x4200  /* [GS] 1 */
  67
  68 /* Formatters for the Video Endpoint controls [GS]ET_EP_STREAM_CTL */
  69 #define VIDEO_OUTPUT_CONTROL_FORMATTER          0x0100
  70
  71 static const char *size2name[PSZ_MAX] =
  72 {
  73         "subQCIF",
  74         "QSIF",
  75         "QCIF",
  76         "SIF",
  77         "CIF",
  78         "VGA",
  79 };
  80
  81 /********/
  82
  83 /* Entries for the Nala (645/646) camera; the Nala doesn't have compression
  84    preferences, so you either get compressed or non-compressed streams.
  85
  86    An alternate value of 0 means this mode is not available at all.
  87  */
  88
  89 #define PWC_FPS_MAX_NALA 8
  90
  91 struct Nala_table_entry {
  92         char alternate;                 /* USB alternate setting */
  93         int compressed;                 /* Compressed yes/no */
  94
  95         unsigned char mode[3];          /* precomputed mode table */
  96 };
  97
  98 static unsigned int Nala_fps_vector[PWC_FPS_MAX_NALA] = { 4, 5, 7, 10, 12, 15, 20, 24 };
  99
 100 static struct Nala_table_entry Nala_table[PSZ_MAX][PWC_FPS_MAX_NALA] =
 101 {
 102 #include "pwc-nala.h"
 103 };
 104
 105 /****************************************************************************/
 106
 107 static int _send_control_msg(struct pwc_device *pdev,
 108         u8 request, u16 value, int index, void *buf, int buflen)
 109 {
 110         int rc;
 111         void *kbuf = NULL;
 112
 113         if (buflen) {
 114                 kbuf = kmemdup(buf, buflen, GFP_KERNEL); /* not allowed on stack */
 115                 if (kbuf == NULL)
 116                         return -ENOMEM;
 117         }
 118
 119         rc = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
 120                 request,
 121                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 122                 value,
 123                 index,
 124                 kbuf, buflen, USB_CTRL_SET_TIMEOUT);
 125
 126         kfree(kbuf);
 127         return rc;
 128 }
 129
 130 static int recv_control_msg(struct pwc_device *pdev,
 131         u8 request, u16 value, void *buf, int buflen)
 132 {
 133         int rc;
 134         void *kbuf = kmalloc(buflen, GFP_KERNEL); /* not allowed on stack */
 135
 136         if (kbuf == NULL)
 137                 return -ENOMEM;
 138
 139         rc = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
 140                 request,
 141                 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 142                 value,
 143                 pdev->vcinterface,
 144                 kbuf, buflen, USB_CTRL_GET_TIMEOUT);
 145         memcpy(buf, kbuf, buflen);
 146         kfree(kbuf);
 147
 148         if (rc < 0)
 149                 PWC_ERROR("recv_control_msg error %d req %02x val %04x\n",
 150                           rc, request, value);
 151         return rc;
 152 }
 153
 154 static inline int send_video_command(struct pwc_device *pdev,
 155         int index, void *buf, int buflen)
 156 {
 157         return _send_control_msg(pdev,
 158                 SET_EP_STREAM_CTL,
 159                 VIDEO_OUTPUT_CONTROL_FORMATTER,
 160                 index,
 161                 buf, buflen);
 162 }
 163
 164 int send_control_msg(struct pwc_device *pdev,
 165         u8 request, u16 value, void *buf, int buflen)
 166 {
 167         return _send_control_msg(pdev,
 168                 request, value, pdev->vcinterface, buf, buflen);
 169 }
 170
 171 static int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames,
 172                                int *compression)
 173 {
 174         unsigned char buf[3];
 175         int ret, fps;
 176         struct Nala_table_entry *pEntry;
 177         int frames2frames[31] =
 178         { /* closest match of framerate */
 179            0,  0,  0,  0,  4,  /*  0-4  */
 180            5,  5,  7,  7, 10,  /*  5-9  */
 181           10, 10, 12, 12, 15,  /* 10-14 */
 182           15, 15, 15, 20, 20,  /* 15-19 */
 183           20, 20, 20, 24, 24,  /* 20-24 */
 184           24, 24, 24, 24, 24,  /* 25-29 */
 185           24                   /* 30    */
 186         };
 187         int frames2table[31] =
 188         { 0, 0, 0, 0, 0, /*  0-4  */
 189           1, 1, 1, 2, 2, /*  5-9  */
 190           3, 3, 4, 4, 4, /* 10-14 */
 191           5, 5, 5, 5, 5, /* 15-19 */
 192           6, 6, 6, 6, 7, /* 20-24 */
 193           7, 7, 7, 7, 7, /* 25-29 */
 194           7              /* 30    */
 195         };
 196
 197         if (size < 0 || size > PSZ_CIF)
 198                 return -EINVAL;
 199         if (frames < 4)
 200                 frames = 4;
 201         else if (frames > 25)
 202                 frames = 25;
 203         frames = frames2frames[frames];
 204         fps = frames2table[frames];
 205         pEntry = &Nala_table[size][fps];
 206         if (pEntry->alternate == 0)
 207                 return -EINVAL;
 208
 209         memcpy(buf, pEntry->mode, 3);
 210         ret = send_video_command(pdev, pdev->vendpoint, buf, 3);
 211         if (ret < 0) {
 212                 PWC_DEBUG_MODULE("Failed to send video command... %d\n", ret);
 213                 return ret;
 214         }
 215         if (pEntry->compressed && pdev->pixfmt == V4L2_PIX_FMT_YUV420) {
 216                 pwc_dec1_init(pdev, buf);
 217         }
 218
 219         pdev->cmd_len = 3;
 220         memcpy(pdev->cmd_buf, buf, 3);
 221
 222         /* Set various parameters */
 223         pdev->vframes = frames;
 224         pdev->valternate = pEntry->alternate;
 225         pdev->width  = pwc_image_sizes[size][0];
 226         pdev->height = pwc_image_sizes[size][1];
 227         pdev->frame_size = (pdev->width * pdev->height * 3) / 2;
 228         if (pEntry->compressed) {
 229                 if (pdev->release < 5) { /* 4 fold compression */
 230                         pdev->vbandlength = 528;
 231                         pdev->frame_size /= 4;
 232                 }
 233                 else {
 234                         pdev->vbandlength = 704;
 235                         pdev->frame_size /= 3;
 236                 }
 237         }
 238         else
 239                 pdev->vbandlength = 0;
 240
 241         /* Let pwc-if.c:isoc_init know we don't support higher compression */
 242         *compression = 3;
 243
 244         return 0;
 245 }
 246
 247
 248 static int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames,
 249         int *compression)
 250 {
 251         unsigned char buf[13];
 252         const struct Timon_table_entry *pChoose;
 253         int ret, fps;
 254
 255         if (size >= PSZ_MAX || *compression < 0 || *compression > 3)
 256                 return -EINVAL;
 257         if (frames < 5)
 258                 frames = 5;
 259         else if (size == PSZ_VGA && frames > 15)
 260                 frames = 15;
 261         else if (frames > 30)
 262                 frames = 30;
 263         fps = (frames / 5) - 1;
 264
 265         /* Find a supported framerate with progressively higher compression */
 266         pChoose = NULL;
 267         while (*compression <= 3) {
 268                 pChoose = &Timon_table[size][fps][*compression];
 269                 if (pChoose->alternate != 0)
 270                         break;
 271                 (*compression)++;
 272         }
 273         if (pChoose == NULL || pChoose->alternate == 0)
 274                 return -ENOENT; /* Not supported. */
 275
 276         memcpy(buf, pChoose->mode, 13);
 277         ret = send_video_command(pdev, pdev->vendpoint, buf, 13);
 278         if (ret < 0)
 279                 return ret;
 280
 281         if (pChoose->bandlength > 0 && pdev->pixfmt == V4L2_PIX_FMT_YUV420) {
 282                 pwc_dec23_init(pdev, buf);
 283         }
 284
 285         pdev->cmd_len = 13;
 286         memcpy(pdev->cmd_buf, buf, 13);
 287
 288         /* Set various parameters */
 289         pdev->vframes = (fps + 1) * 5;
 290         pdev->valternate = pChoose->alternate;
 291         pdev->width  = pwc_image_sizes[size][0];
 292         pdev->height = pwc_image_sizes[size][1];
 293         pdev->vbandlength = pChoose->bandlength;
 294         if (pChoose->bandlength > 0)
 295                 pdev->frame_size = (pChoose->bandlength * pdev->height) / 4;
 296         else
 297                 pdev->frame_size = (pdev->width * pdev->height * 12) / 8;
 298         return 0;
 299 }
 300
 301
 302 static int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames,
 303         int *compression)
 304 {
 305         const struct Kiara_table_entry *pChoose = NULL;
 306         int fps, ret;
 307         unsigned char buf[12];
 308
 309         if (size >= PSZ_MAX || *compression < 0 || *compression > 3)
 310                 return -EINVAL;
 311         if (frames < 5)
 312                 frames = 5;
 313         else if (size == PSZ_VGA && frames > 15)
 314                 frames = 15;
 315         else if (frames > 30)
 316                 frames = 30;
 317         fps = (frames / 5) - 1;
 318
 319         /* Find a supported framerate with progressively higher compression */
 320         while (*compression <= 3) {
 321                 pChoose = &Kiara_table[size][fps][*compression];
 322                 if (pChoose->alternate != 0)
 323                         break;
 324                 (*compression)++;
 325         }
 326         if (pChoose == NULL || pChoose->alternate == 0)
 327                 return -ENOENT; /* Not supported. */
 328
 329         PWC_TRACE("Using alternate setting %d.\n", pChoose->alternate);
 330
 331         /* usb_control_msg won't take staticly allocated arrays as argument?? */
 332         memcpy(buf, pChoose->mode, 12);
 333
 334         /* Firmware bug: video endpoint is 5, but commands are sent to endpoint 4 */
 335         ret = send_video_command(pdev, 4 /* pdev->vendpoint */, buf, 12);
 336         if (ret < 0)
 337                 return ret;
 338
 339         if (pChoose->bandlength > 0 && pdev->pixfmt == V4L2_PIX_FMT_YUV420) {
 340                 pwc_dec23_init(pdev, buf);
 341         }
 342
 343         pdev->cmd_len = 12;
 344         memcpy(pdev->cmd_buf, buf, 12);
 345         /* All set and go */
 346         pdev->vframes = (fps + 1) * 5;
 347         pdev->valternate = pChoose->alternate;
 348         pdev->width  = pwc_image_sizes[size][0];
 349         pdev->height = pwc_image_sizes[size][1];
 350         pdev->vbandlength = pChoose->bandlength;
 351         if (pdev->vbandlength > 0)
 352                 pdev->frame_size = (pdev->vbandlength * pdev->height) / 4;
 353         else
 354                 pdev->frame_size = (pdev->width * pdev->height * 12) / 8;
 355         PWC_TRACE("frame_size=%d, vframes=%d, vsize=%d, vbandlength=%d\n",
 356             pdev->frame_size, pdev->vframes, size, pdev->vbandlength);
 357         return 0;
 358 }
 359
 360 int pwc_set_video_mode(struct pwc_device *pdev, int width, int height,
 361         int frames, int *compression)
 362 {
 363         int ret, size;
 364
 365         PWC_DEBUG_FLOW("set_video_mode(%dx%d @ %d, pixfmt %08x).\n",
 366                        width, height, frames, pdev->pixfmt);
 367         size = pwc_get_size(pdev, width, height);
 368         PWC_TRACE("decode_size = %d.\n", size);
 369
 370         if (DEVICE_USE_CODEC1(pdev->type)) {
 371                 ret = set_video_mode_Nala(pdev, size, frames, compression);
 372
 373         } else if (DEVICE_USE_CODEC3(pdev->type)) {
 374                 ret = set_video_mode_Kiara(pdev, size, frames, compression);
 375
 376         } else {
 377                 ret = set_video_mode_Timon(pdev, size, frames, compression);
 378         }
 379         if (ret < 0) {
 380                 PWC_ERROR("Failed to set video mode %s@%d fps; return code = %d\n", size2name[size], frames, ret);
 381                 return ret;
 382         }
 383         pdev->frame_total_size = pdev->frame_size + pdev->frame_header_size + pdev->frame_trailer_size;
 384         PWC_DEBUG_SIZE("Set resolution to %dx%d\n", pdev->width, pdev->height);
 385         return 0;
 386 }
 387
 388 static unsigned int pwc_get_fps_Nala(struct pwc_device *pdev, unsigned int index, unsigned int size)
 389 {
 390         unsigned int i;
 391
 392         for (i = 0; i < PWC_FPS_MAX_NALA; i++) {
 393                 if (Nala_table[size][i].alternate) {
 394                         if (index--==0) return Nala_fps_vector[i];
 395                 }
 396         }
 397         return 0;
 398 }
 399
 400 static unsigned int pwc_get_fps_Kiara(struct pwc_device *pdev, unsigned int index, unsigned int size)
 401 {
 402         unsigned int i;
 403
 404         for (i = 0; i < PWC_FPS_MAX_KIARA; i++) {
 405                 if (Kiara_table[size][i][3].alternate) {
 406                         if (index--==0) return Kiara_fps_vector[i];
 407                 }
 408         }
 409         return 0;
 410 }
 411
 412 static unsigned int pwc_get_fps_Timon(struct pwc_device *pdev, unsigned int index, unsigned int size)
 413 {
 414         unsigned int i;
 415
 416         for (i=0; i < PWC_FPS_MAX_TIMON; i++) {
 417                 if (Timon_table[size][i][3].alternate) {
 418                         if (index--==0) return Timon_fps_vector[i];
 419                 }
 420         }
 421         return 0;
 422 }
 423
 424 unsigned int pwc_get_fps(struct pwc_device *pdev, unsigned int index, unsigned int size)
 425 {
 426         unsigned int ret;
 427
 428         if (DEVICE_USE_CODEC1(pdev->type)) {
 429                 ret = pwc_get_fps_Nala(pdev, index, size);
 430
 431         } else if (DEVICE_USE_CODEC3(pdev->type)) {
 432                 ret = pwc_get_fps_Kiara(pdev, index, size);
 433
 434         } else {
 435                 ret = pwc_get_fps_Timon(pdev, index, size);
 436         }
 437
 438         return ret;
 439 }
 440
 441 int pwc_get_u8_ctrl(struct pwc_device *pdev, u8 request, u16 value, int *data)
 442 {
 443         int ret;
 444         u8 buf;
 445
 446         ret = recv_control_msg(pdev, request, value, &buf, sizeof(buf));
 447         if (ret < 0)
 448                 return ret;
 449
 450         *data = buf;
 451         return 0;
 452 }
 453
 454 int pwc_set_u8_ctrl(struct pwc_device *pdev, u8 request, u16 value, u8 data)
 455 {
 456         int ret;
 457
 458         ret = send_control_msg(pdev, request, value, &data, sizeof(data));
 459         if (ret < 0)
 460                 return ret;
 461
 462         return 0;
 463 }
 464
 465 int pwc_get_s8_ctrl(struct pwc_device *pdev, u8 request, u16 value, int *data)
 466 {
 467         int ret;
 468         s8 buf;
 469
 470         ret = recv_control_msg(pdev, request, value, &buf, sizeof(buf));
 471         if (ret < 0)
 472                 return ret;
 473
 474         *data = buf;
 475         return 0;
 476 }
 477
 478 int pwc_get_u16_ctrl(struct pwc_device *pdev, u8 request, u16 value, int *data)
 479 {
 480         int ret;
 481         u8 buf[2];
 482
 483         ret = recv_control_msg(pdev, request, value, buf, sizeof(buf));
 484         if (ret < 0)
 485                 return ret;
 486
 487         *data = (buf[1] << 8) | buf[0];
 488         return 0;
 489 }
 490
 491 int pwc_set_u16_ctrl(struct pwc_device *pdev, u8 request, u16 value, u16 data)
 492 {
 493         int ret;
 494         u8 buf[2];
 495
 496         buf[0] = data & 0xff;
 497         buf[1] = data >> 8;
 498         ret = send_control_msg(pdev, request, value, buf, sizeof(buf));
 499         if (ret < 0)
 500                 return ret;
 501
 502         return 0;
 503 }
 504
 505 int pwc_button_ctrl(struct pwc_device *pdev, u16 value)
 506 {
 507         int ret;
 508
 509         ret = send_control_msg(pdev, SET_STATUS_CTL, value, NULL, 0);
 510         if (ret < 0)
 511                 return ret;
 512
 513         return 0;
 514 }
 515
 516 /* POWER */
 517 void pwc_camera_power(struct pwc_device *pdev, int power)
 518 {
 519         char buf;
 520         int r;
 521
 522         if (!pdev->power_save)
 523                 return;
 524
 525         if (pdev->type < 675 || (pdev->type < 730 && pdev->release < 6))
 526                 return; /* Not supported by Nala or Timon < release 6 */
 527
 528         if (power)
 529                 buf = 0x00; /* active */
 530         else
 531                 buf = 0xFF; /* power save */
 532         r = send_control_msg(pdev,
 533                 SET_STATUS_CTL, SET_POWER_SAVE_MODE_FORMATTER,
 534                 &buf, sizeof(buf));
 535
 536         if (r < 0)
 537                 PWC_ERROR("Failed to power %s camera (%d)\n",
 538                           power ? "on" : "off", r);
 539 }
 540
 541 int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value)
 542 {
 543         unsigned char buf[2];
 544         int r;
 545
 546         if (pdev->type < 730)
 547                 return 0;
 548         on_value /= 100;
 549         off_value /= 100;
 550         if (on_value < 0)
 551                 on_value = 0;
 552         if (on_value > 0xff)
 553                 on_value = 0xff;
 554         if (off_value < 0)
 555                 off_value = 0;
 556         if (off_value > 0xff)
 557                 off_value = 0xff;
 558
 559         buf[0] = on_value;
 560         buf[1] = off_value;
 561
 562         r = send_control_msg(pdev,
 563                 SET_STATUS_CTL, LED_FORMATTER, &buf, sizeof(buf));
 564         if (r < 0)
 565                 PWC_ERROR("Failed to set LED on/off time (%d)\n", r);
 566
 567         return r;
 568 }
 569
 570 #ifdef CONFIG_USB_PWC_DEBUG
 571 int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor)
 572 {
 573         unsigned char buf;
 574         int ret = -1, request;
 575
 576         if (pdev->type < 675)
 577                 request = SENSOR_TYPE_FORMATTER1;
 578         else if (pdev->type < 730)
 579                 return -1; /* The Vesta series doesn't have this call */
 580         else
 581                 request = SENSOR_TYPE_FORMATTER2;
 582
 583         ret = recv_control_msg(pdev,
 584                 GET_STATUS_CTL, request, &buf, sizeof(buf));
 585         if (ret < 0)
 586                 return ret;
 587         if (pdev->type < 675)
 588                 *sensor = buf | 0x100;
 589         else
 590                 *sensor = buf;
 591         return 0;
 592 }
 593 #endif