drivers/media/video/gspca/ov534.c

   1 /*
   2  * ov534-ov7xxx gspca driver
   3  *
   4  * Copyright (C) 2008 Antonio Ospite <ospite@studenti.unina.it>
   5  * Copyright (C) 2008 Jim Paris <jim@jtan.com>
   6  * Copyright (C) 2009 Jean-Francois Moine http://moinejf.free.fr
   7  *
   8  * Based on a prototype written by Mark Ferrell <majortrips@gmail.com>
   9  * USB protocol reverse engineered by Jim Paris <jim@jtan.com>
  10  * https://jim.sh/svn/jim/devl/playstation/ps3/eye/test/
  11  *
  12  * PS3 Eye camera enhanced by Richard Kaswy http://kaswy.free.fr
  13  * PS3 Eye camera - brightness, contrast, awb, agc, aec controls
  14  *                  added by Max Thrun <bear24rw@gmail.com>
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29  */
  30
  31 #define MODULE_NAME "ov534"
  32
  33 #include "gspca.h"
  34
  35 #define OV534_REG_ADDRESS       0xf1    /* sensor address */
  36 #define OV534_REG_SUBADDR       0xf2
  37 #define OV534_REG_WRITE         0xf3
  38 #define OV534_REG_READ          0xf4
  39 #define OV534_REG_OPERATION     0xf5
  40 #define OV534_REG_STATUS        0xf6
  41
  42 #define OV534_OP_WRITE_3        0x37
  43 #define OV534_OP_WRITE_2        0x33
  44 #define OV534_OP_READ_2         0xf9
  45
  46 #define CTRL_TIMEOUT 500
  47
  48 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
  49 MODULE_DESCRIPTION("GSPCA/OV534 USB Camera Driver");
  50 MODULE_LICENSE("GPL");
  51
  52 /* controls */
  53 enum e_ctrl {
  54         BRIGHTNESS,
  55         CONTRAST,
  56         GAIN,
  57         EXPOSURE,
  58         AGC,
  59         AWB,
  60         AEC,
  61         SHARPNESS,
  62         HFLIP,
  63         VFLIP,
  64         COLORS,
  65         LIGHTFREQ,
  66         NCTRLS          /* number of controls */
  67 };
  68
  69 /* specific webcam descriptor */
  70 struct sd {
  71         struct gspca_dev gspca_dev;     /* !! must be the first item */
  72
  73         struct gspca_ctrl ctrls[NCTRLS];
  74
  75         __u32 last_pts;
  76         u16 last_fid;
  77         u8 frame_rate;
  78
  79         u8 sensor;
  80 };
  81 enum sensors {
  82         SENSOR_OV767x,
  83         SENSOR_OV772x,
  84         NSENSORS
  85 };
  86
  87 /* V4L2 controls supported by the driver */
  88 static void setbrightness(struct gspca_dev *gspca_dev);
  89 static void setcontrast(struct gspca_dev *gspca_dev);
  90 static void setgain(struct gspca_dev *gspca_dev);
  91 static void setexposure(struct gspca_dev *gspca_dev);
  92 static int sd_setagc(struct gspca_dev *gspca_dev, __s32 val);
  93 static void setawb(struct gspca_dev *gspca_dev);
  94 static void setaec(struct gspca_dev *gspca_dev);
  95 static void setsharpness(struct gspca_dev *gspca_dev);
  96 static void sethvflip(struct gspca_dev *gspca_dev);
  97 static void setcolors(struct gspca_dev *gspca_dev);
  98 static void setlightfreq(struct gspca_dev *gspca_dev);
  99
 100 static int sd_start(struct gspca_dev *gspca_dev);
 101 static void sd_stopN(struct gspca_dev *gspca_dev);
 102
 103 static const struct ctrl sd_ctrls[] = {
 104 [BRIGHTNESS] = {
 105                 {
 106                         .id      = V4L2_CID_BRIGHTNESS,
 107                         .type    = V4L2_CTRL_TYPE_INTEGER,
 108                         .name    = "Brightness",
 109                         .minimum = 0,
 110                         .maximum = 255,
 111                         .step    = 1,
 112                         .default_value = 0,
 113                 },
 114                 .set_control = setbrightness
 115         },
 116 [CONTRAST] = {
 117                 {
 118                         .id      = V4L2_CID_CONTRAST,
 119                         .type    = V4L2_CTRL_TYPE_INTEGER,
 120                         .name    = "Contrast",
 121                         .minimum = 0,
 122                         .maximum = 255,
 123                         .step    = 1,
 124                         .default_value = 32,
 125                 },
 126                 .set_control = setcontrast
 127         },
 128 [GAIN] = {
 129                 {
 130                         .id      = V4L2_CID_GAIN,
 131                         .type    = V4L2_CTRL_TYPE_INTEGER,
 132                         .name    = "Main Gain",
 133                         .minimum = 0,
 134                         .maximum = 63,
 135                         .step    = 1,
 136                         .default_value = 20,
 137                 },
 138                 .set_control = setgain
 139         },
 140 [EXPOSURE] = {
 141                 {
 142                         .id      = V4L2_CID_EXPOSURE,
 143                         .type    = V4L2_CTRL_TYPE_INTEGER,
 144                         .name    = "Exposure",
 145                         .minimum = 0,
 146                         .maximum = 255,
 147                         .step    = 1,
 148                         .default_value = 120,
 149                 },
 150                 .set_control = setexposure
 151         },
 152 [AGC] = {
 153                 {
 154                         .id      = V4L2_CID_AUTOGAIN,
 155                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
 156                         .name    = "Auto Gain",
 157                         .minimum = 0,
 158                         .maximum = 1,
 159                         .step    = 1,
 160                         .default_value = 1,
 161                 },
 162                 .set = sd_setagc
 163         },
 164 [AWB] = {
 165                 {
 166                         .id      = V4L2_CID_AUTO_WHITE_BALANCE,
 167                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
 168                         .name    = "Auto White Balance",
 169                         .minimum = 0,
 170                         .maximum = 1,
 171                         .step    = 1,
 172                         .default_value = 1,
 173                 },
 174                 .set_control = setawb
 175         },
 176 [AEC] = {
 177                 {
 178                         .id      = V4L2_CID_EXPOSURE_AUTO,
 179                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
 180                         .name    = "Auto Exposure",
 181                         .minimum = 0,
 182                         .maximum = 1,
 183                         .step    = 1,
 184                         .default_value = 1,
 185                 },
 186                 .set_control = setaec
 187         },
 188 [SHARPNESS] = {
 189                 {
 190                         .id      = V4L2_CID_SHARPNESS,
 191                         .type    = V4L2_CTRL_TYPE_INTEGER,
 192                         .name    = "Sharpness",
 193                         .minimum = 0,
 194                         .maximum = 63,
 195                         .step    = 1,
 196                         .default_value = 0,
 197                 },
 198                 .set_control = setsharpness
 199         },
 200 [HFLIP] = {
 201                 {
 202                         .id      = V4L2_CID_HFLIP,
 203                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
 204                         .name    = "HFlip",
 205                         .minimum = 0,
 206                         .maximum = 1,
 207                         .step    = 1,
 208                         .default_value = 0,
 209                 },
 210                 .set_control = sethvflip
 211         },
 212 [VFLIP] = {
 213                 {
 214                         .id      = V4L2_CID_VFLIP,
 215                         .type    = V4L2_CTRL_TYPE_BOOLEAN,
 216                         .name    = "VFlip",
 217                         .minimum = 0,
 218                         .maximum = 1,
 219                         .step    = 1,
 220                         .default_value = 0,
 221                 },
 222                 .set_control = sethvflip
 223         },
 224 [COLORS] = {
 225                 {
 226                         .id      = V4L2_CID_SATURATION,
 227                         .type    = V4L2_CTRL_TYPE_INTEGER,
 228                         .name    = "Saturation",
 229                         .minimum = 0,
 230                         .maximum = 6,
 231                         .step    = 1,
 232                         .default_value = 3,
 233                 },
 234                 .set_control = setcolors
 235         },
 236 [LIGHTFREQ] = {
 237                 {
 238                         .id      = V4L2_CID_POWER_LINE_FREQUENCY,
 239                         .type    = V4L2_CTRL_TYPE_MENU,
 240                         .name    = "Light Frequency Filter",
 241                         .minimum = 0,
 242                         .maximum = 1,
 243                         .step    = 1,
 244                         .default_value = 0,
 245                 },
 246                 .set_control = setlightfreq
 247         },
 248 };
 249
 250 static const struct v4l2_pix_format ov772x_mode[] = {
 251         {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
 252          .bytesperline = 320 * 2,
 253          .sizeimage = 320 * 240 * 2,
 254          .colorspace = V4L2_COLORSPACE_SRGB,
 255          .priv = 1},
 256         {640, 480, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
 257          .bytesperline = 640 * 2,
 258          .sizeimage = 640 * 480 * 2,
 259          .colorspace = V4L2_COLORSPACE_SRGB,
 260          .priv = 0},
 261 };
 262 static const struct v4l2_pix_format ov767x_mode[] = {
 263         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 264                 .bytesperline = 320,
 265                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 266                 .colorspace = V4L2_COLORSPACE_JPEG},
 267         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 268                 .bytesperline = 640,
 269                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 270                 .colorspace = V4L2_COLORSPACE_JPEG},
 271 };
 272
 273 static const u8 qvga_rates[] = {125, 100, 75, 60, 50, 40, 30};
 274 static const u8 vga_rates[] = {60, 50, 40, 30, 15};
 275
 276 static const struct framerates ov772x_framerates[] = {
 277         { /* 320x240 */
 278                 .rates = qvga_rates,
 279                 .nrates = ARRAY_SIZE(qvga_rates),
 280         },
 281         { /* 640x480 */
 282                 .rates = vga_rates,
 283                 .nrates = ARRAY_SIZE(vga_rates),
 284         },
 285 };
 286
 287 struct reg_array {
 288         const u8 (*val)[2];
 289         int len;
 290 };
 291
 292 static const u8 bridge_init_767x[][2] = {
 293 /* comments from the ms-win file apollo7670.set */
 294 /* str1 */
 295         {0xf1, 0x42},
 296         {0x88, 0xf8},
 297         {0x89, 0xff},
 298         {0x76, 0x03},
 299         {0x92, 0x03},
 300         {0x95, 0x10},
 301         {0xe2, 0x00},
 302         {0xe7, 0x3e},
 303         {0x8d, 0x1c},
 304         {0x8e, 0x00},
 305         {0x8f, 0x00},
 306         {0x1f, 0x00},
 307         {0xc3, 0xf9},
 308         {0x89, 0xff},
 309         {0x88, 0xf8},
 310         {0x76, 0x03},
 311         {0x92, 0x01},
 312         {0x93, 0x18},
 313         {0x1c, 0x00},
 314         {0x1d, 0x48},
 315         {0x1d, 0x00},
 316         {0x1d, 0xff},
 317         {0x1d, 0x02},
 318         {0x1d, 0x58},
 319         {0x1d, 0x00},
 320         {0x1c, 0x0a},
 321         {0x1d, 0x0a},
 322         {0x1d, 0x0e},
 323         {0xc0, 0x50},   /* HSize 640 */
 324         {0xc1, 0x3c},   /* VSize 480 */
 325         {0x34, 0x05},   /* enable Audio Suspend mode */
 326         {0xc2, 0x0c},   /* Input YUV */
 327         {0xc3, 0xf9},   /* enable PRE */
 328         {0x34, 0x05},   /* enable Audio Suspend mode */
 329         {0xe7, 0x2e},   /* this solves failure of "SuspendResumeTest" */
 330         {0x31, 0xf9},   /* enable 1.8V Suspend */
 331         {0x35, 0x02},   /* turn on JPEG */
 332         {0xd9, 0x10},
 333         {0x25, 0x42},   /* GPIO[8]:Input */
 334         {0x94, 0x11},   /* If the default setting is loaded when
 335                          * system boots up, this flag is closed here */
 336 };
 337 static const u8 sensor_init_767x[][2] = {
 338         {0x12, 0x80},
 339         {0x11, 0x03},
 340         {0x3a, 0x04},
 341         {0x12, 0x00},
 342         {0x17, 0x13},
 343         {0x18, 0x01},
 344         {0x32, 0xb6},
 345         {0x19, 0x02},
 346         {0x1a, 0x7a},
 347         {0x03, 0x0a},
 348         {0x0c, 0x00},
 349         {0x3e, 0x00},
 350         {0x70, 0x3a},
 351         {0x71, 0x35},
 352         {0x72, 0x11},
 353         {0x73, 0xf0},
 354         {0xa2, 0x02},
 355         {0x7a, 0x2a},   /* set Gamma=1.6 below */
 356         {0x7b, 0x12},
 357         {0x7c, 0x1d},
 358         {0x7d, 0x2d},
 359         {0x7e, 0x45},
 360         {0x7f, 0x50},
 361         {0x80, 0x59},
 362         {0x81, 0x62},
 363         {0x82, 0x6b},
 364         {0x83, 0x73},
 365         {0x84, 0x7b},
 366         {0x85, 0x8a},
 367         {0x86, 0x98},
 368         {0x87, 0xb2},
 369         {0x88, 0xca},
 370         {0x89, 0xe0},
 371         {0x13, 0xe0},
 372         {0x00, 0x00},
 373         {0x10, 0x00},
 374         {0x0d, 0x40},
 375         {0x14, 0x38},   /* gain max 16x */
 376         {0xa5, 0x05},
 377         {0xab, 0x07},
 378         {0x24, 0x95},
 379         {0x25, 0x33},
 380         {0x26, 0xe3},
 381         {0x9f, 0x78},
 382         {0xa0, 0x68},
 383         {0xa1, 0x03},
 384         {0xa6, 0xd8},
 385         {0xa7, 0xd8},
 386         {0xa8, 0xf0},
 387         {0xa9, 0x90},
 388         {0xaa, 0x94},
 389         {0x13, 0xe5},
 390         {0x0e, 0x61},
 391         {0x0f, 0x4b},
 392         {0x16, 0x02},
 393         {0x21, 0x02},
 394         {0x22, 0x91},
 395         {0x29, 0x07},
 396         {0x33, 0x0b},
 397         {0x35, 0x0b},
 398         {0x37, 0x1d},
 399         {0x38, 0x71},
 400         {0x39, 0x2a},
 401         {0x3c, 0x78},
 402         {0x4d, 0x40},
 403         {0x4e, 0x20},
 404         {0x69, 0x00},
 405         {0x6b, 0x4a},
 406         {0x74, 0x10},
 407         {0x8d, 0x4f},
 408         {0x8e, 0x00},
 409         {0x8f, 0x00},
 410         {0x90, 0x00},
 411         {0x91, 0x00},
 412         {0x96, 0x00},
 413         {0x9a, 0x80},
 414         {0xb0, 0x84},
 415         {0xb1, 0x0c},
 416         {0xb2, 0x0e},
 417         {0xb3, 0x82},
 418         {0xb8, 0x0a},
 419         {0x43, 0x0a},
 420         {0x44, 0xf0},
 421         {0x45, 0x34},
 422         {0x46, 0x58},
 423         {0x47, 0x28},
 424         {0x48, 0x3a},
 425         {0x59, 0x88},
 426         {0x5a, 0x88},
 427         {0x5b, 0x44},
 428         {0x5c, 0x67},
 429         {0x5d, 0x49},
 430         {0x5e, 0x0e},
 431         {0x6c, 0x0a},
 432         {0x6d, 0x55},
 433         {0x6e, 0x11},
 434         {0x6f, 0x9f},
 435         {0x6a, 0x40},
 436         {0x01, 0x40},
 437         {0x02, 0x40},
 438         {0x13, 0xe7},
 439         {0x4f, 0x80},
 440         {0x50, 0x80},
 441         {0x51, 0x00},
 442         {0x52, 0x22},
 443         {0x53, 0x5e},
 444         {0x54, 0x80},
 445         {0x58, 0x9e},
 446         {0x41, 0x08},
 447         {0x3f, 0x00},
 448         {0x75, 0x04},
 449         {0x76, 0xe1},
 450         {0x4c, 0x00},
 451         {0x77, 0x01},
 452         {0x3d, 0xc2},
 453         {0x4b, 0x09},
 454         {0xc9, 0x60},
 455         {0x41, 0x38},   /* jfm: auto sharpness + auto de-noise  */
 456         {0x56, 0x40},
 457         {0x34, 0x11},
 458         {0x3b, 0xc2},
 459         {0xa4, 0x8a},   /* Night mode trigger point */
 460         {0x96, 0x00},
 461         {0x97, 0x30},
 462         {0x98, 0x20},
 463         {0x99, 0x20},
 464         {0x9a, 0x84},
 465         {0x9b, 0x29},
 466         {0x9c, 0x03},
 467         {0x9d, 0x4c},
 468         {0x9e, 0x3f},
 469         {0x78, 0x04},
 470         {0x79, 0x01},
 471         {0xc8, 0xf0},
 472         {0x79, 0x0f},
 473         {0xc8, 0x00},
 474         {0x79, 0x10},
 475         {0xc8, 0x7e},
 476         {0x79, 0x0a},
 477         {0xc8, 0x80},
 478         {0x79, 0x0b},
 479         {0xc8, 0x01},
 480         {0x79, 0x0c},
 481         {0xc8, 0x0f},
 482         {0x79, 0x0d},
 483         {0xc8, 0x20},
 484         {0x79, 0x09},
 485         {0xc8, 0x80},
 486         {0x79, 0x02},
 487         {0xc8, 0xc0},
 488         {0x79, 0x03},
 489         {0xc8, 0x20},
 490         {0x79, 0x26},
 491 };
 492 static const u8 bridge_start_vga_767x[][2] = {
 493 /* str59 JPG */
 494         {0x94, 0xaa},
 495         {0xf1, 0x42},
 496         {0xe5, 0x04},
 497         {0xc0, 0x50},
 498         {0xc1, 0x3c},
 499         {0xc2, 0x0c},
 500         {0x35, 0x02},   /* turn on JPEG */
 501         {0xd9, 0x10},
 502         {0xda, 0x00},   /* for higher clock rate(30fps) */
 503         {0x34, 0x05},   /* enable Audio Suspend mode */
 504         {0xc3, 0xf9},   /* enable PRE */
 505         {0x8c, 0x00},   /* CIF VSize LSB[2:0] */
 506         {0x8d, 0x1c},   /* output YUV */
 507 /*      {0x34, 0x05},    * enable Audio Suspend mode (?) */
 508         {0x50, 0x00},   /* H/V divider=0 */
 509         {0x51, 0xa0},   /* input H=640/4 */
 510         {0x52, 0x3c},   /* input V=480/4 */
 511         {0x53, 0x00},   /* offset X=0 */
 512         {0x54, 0x00},   /* offset Y=0 */
 513         {0x55, 0x00},   /* H/V size[8]=0 */
 514         {0x57, 0x00},   /* H-size[9]=0 */
 515         {0x5c, 0x00},   /* output size[9:8]=0 */
 516         {0x5a, 0xa0},   /* output H=640/4 */
 517         {0x5b, 0x78},   /* output V=480/4 */
 518         {0x1c, 0x0a},
 519         {0x1d, 0x0a},
 520         {0x94, 0x11},
 521 };
 522 static const u8 sensor_start_vga_767x[][2] = {
 523         {0x11, 0x01},
 524         {0x1e, 0x04},
 525         {0x19, 0x02},
 526         {0x1a, 0x7a},
 527 };
 528 static const u8 bridge_start_qvga_767x[][2] = {
 529 /* str86 JPG */
 530         {0x94, 0xaa},
 531         {0xf1, 0x42},
 532         {0xe5, 0x04},
 533         {0xc0, 0x80},
 534         {0xc1, 0x60},
 535         {0xc2, 0x0c},
 536         {0x35, 0x02},   /* turn on JPEG */
 537         {0xd9, 0x10},
 538         {0xc0, 0x50},   /* CIF HSize 640 */
 539         {0xc1, 0x3c},   /* CIF VSize 480 */
 540         {0x8c, 0x00},   /* CIF VSize LSB[2:0] */
 541         {0x8d, 0x1c},   /* output YUV */
 542         {0x34, 0x05},   /* enable Audio Suspend mode */
 543         {0xc2, 0x4c},   /* output YUV and Enable DCW */
 544         {0xc3, 0xf9},   /* enable PRE */
 545         {0x1c, 0x00},   /* indirect addressing */
 546         {0x1d, 0x48},   /* output YUV422 */
 547         {0x50, 0x89},   /* H/V divider=/2; plus DCW AVG */
 548         {0x51, 0xa0},   /* DCW input H=640/4 */
 549         {0x52, 0x78},   /* DCW input V=480/4 */
 550         {0x53, 0x00},   /* offset X=0 */
 551         {0x54, 0x00},   /* offset Y=0 */
 552         {0x55, 0x00},   /* H/V size[8]=0 */
 553         {0x57, 0x00},   /* H-size[9]=0 */
 554         {0x5c, 0x00},   /* DCW output size[9:8]=0 */
 555         {0x5a, 0x50},   /* DCW output H=320/4 */
 556         {0x5b, 0x3c},   /* DCW output V=240/4 */
 557         {0x1c, 0x0a},
 558         {0x1d, 0x0a},
 559         {0x94, 0x11},
 560 };
 561 static const u8 sensor_start_qvga_767x[][2] = {
 562         {0x11, 0x01},
 563         {0x1e, 0x04},
 564         {0x19, 0x02},
 565         {0x1a, 0x7a},
 566 };
 567
 568 static const u8 bridge_init_772x[][2] = {
 569         { 0xc2, 0x0c },
 570         { 0x88, 0xf8 },
 571         { 0xc3, 0x69 },
 572         { 0x89, 0xff },
 573         { 0x76, 0x03 },
 574         { 0x92, 0x01 },
 575         { 0x93, 0x18 },
 576         { 0x94, 0x10 },
 577         { 0x95, 0x10 },
 578         { 0xe2, 0x00 },
 579         { 0xe7, 0x3e },
 580
 581         { 0x96, 0x00 },
 582
 583         { 0x97, 0x20 },
 584         { 0x97, 0x20 },
 585         { 0x97, 0x20 },
 586         { 0x97, 0x0a },
 587         { 0x97, 0x3f },
 588         { 0x97, 0x4a },
 589         { 0x97, 0x20 },
 590         { 0x97, 0x15 },
 591         { 0x97, 0x0b },
 592
 593         { 0x8e, 0x40 },
 594         { 0x1f, 0x81 },
 595         { 0x34, 0x05 },
 596         { 0xe3, 0x04 },
 597         { 0x88, 0x00 },
 598         { 0x89, 0x00 },
 599         { 0x76, 0x00 },
 600         { 0xe7, 0x2e },
 601         { 0x31, 0xf9 },
 602         { 0x25, 0x42 },
 603         { 0x21, 0xf0 },
 604
 605         { 0x1c, 0x00 },
 606         { 0x1d, 0x40 },
 607         { 0x1d, 0x02 }, /* payload size 0x0200 * 4 = 2048 bytes */
 608         { 0x1d, 0x00 }, /* payload size */
 609
 610         { 0x1d, 0x02 }, /* frame size 0x025800 * 4 = 614400 */
 611         { 0x1d, 0x58 }, /* frame size */
 612         { 0x1d, 0x00 }, /* frame size */
 613
 614         { 0x1c, 0x0a },
 615         { 0x1d, 0x08 }, /* turn on UVC header */
 616         { 0x1d, 0x0e }, /* .. */
 617
 618         { 0x8d, 0x1c },
 619         { 0x8e, 0x80 },
 620         { 0xe5, 0x04 },
 621
 622         { 0xc0, 0x50 },
 623         { 0xc1, 0x3c },
 624         { 0xc2, 0x0c },
 625 };
 626 static const u8 sensor_init_772x[][2] = {
 627         { 0x12, 0x80 },
 628         { 0x11, 0x01 },
 629 /*fixme: better have a delay?*/
 630         { 0x11, 0x01 },
 631         { 0x11, 0x01 },
 632         { 0x11, 0x01 },
 633         { 0x11, 0x01 },
 634         { 0x11, 0x01 },
 635         { 0x11, 0x01 },
 636         { 0x11, 0x01 },
 637         { 0x11, 0x01 },
 638         { 0x11, 0x01 },
 639         { 0x11, 0x01 },
 640
 641         { 0x3d, 0x03 },
 642         { 0x17, 0x26 },
 643         { 0x18, 0xa0 },
 644         { 0x19, 0x07 },
 645         { 0x1a, 0xf0 },
 646         { 0x32, 0x00 },
 647         { 0x29, 0xa0 },
 648         { 0x2c, 0xf0 },
 649         { 0x65, 0x20 },
 650         { 0x11, 0x01 },
 651         { 0x42, 0x7f },
 652         { 0x63, 0xaa },         /* AWB - was e0 */
 653         { 0x64, 0xff },
 654         { 0x66, 0x00 },
 655         { 0x13, 0xf0 },         /* com8 */
 656         { 0x0d, 0x41 },
 657         { 0x0f, 0xc5 },
 658         { 0x14, 0x11 },
 659
 660         { 0x22, 0x7f },
 661         { 0x23, 0x03 },
 662         { 0x24, 0x40 },
 663         { 0x25, 0x30 },
 664         { 0x26, 0xa1 },
 665         { 0x2a, 0x00 },
 666         { 0x2b, 0x00 },
 667         { 0x6b, 0xaa },
 668         { 0x13, 0xff },         /* AWB */
 669
 670         { 0x90, 0x05 },
 671         { 0x91, 0x01 },
 672         { 0x92, 0x03 },
 673         { 0x93, 0x00 },
 674         { 0x94, 0x60 },
 675         { 0x95, 0x3c },
 676         { 0x96, 0x24 },
 677         { 0x97, 0x1e },
 678         { 0x98, 0x62 },
 679         { 0x99, 0x80 },
 680         { 0x9a, 0x1e },
 681         { 0x9b, 0x08 },
 682         { 0x9c, 0x20 },
 683         { 0x9e, 0x81 },
 684
 685         { 0xa6, 0x04 },
 686         { 0x7e, 0x0c },
 687         { 0x7f, 0x16 },
 688         { 0x80, 0x2a },
 689         { 0x81, 0x4e },
 690         { 0x82, 0x61 },
 691         { 0x83, 0x6f },
 692         { 0x84, 0x7b },
 693         { 0x85, 0x86 },
 694         { 0x86, 0x8e },
 695         { 0x87, 0x97 },
 696         { 0x88, 0xa4 },
 697         { 0x89, 0xaf },
 698         { 0x8a, 0xc5 },
 699         { 0x8b, 0xd7 },
 700         { 0x8c, 0xe8 },
 701         { 0x8d, 0x20 },
 702
 703         { 0x0c, 0x90 },
 704
 705         { 0x2b, 0x00 },
 706         { 0x22, 0x7f },
 707         { 0x23, 0x03 },
 708         { 0x11, 0x01 },
 709         { 0x0c, 0xd0 },
 710         { 0x64, 0xff },
 711         { 0x0d, 0x41 },
 712
 713         { 0x14, 0x41 },
 714         { 0x0e, 0xcd },
 715         { 0xac, 0xbf },
 716         { 0x8e, 0x00 },         /* De-noise threshold */
 717         { 0x0c, 0xd0 }
 718 };
 719 static const u8 bridge_start_vga_772x[][2] = {
 720         {0x1c, 0x00},
 721         {0x1d, 0x40},
 722         {0x1d, 0x02},
 723         {0x1d, 0x00},
 724         {0x1d, 0x02},
 725         {0x1d, 0x58},
 726         {0x1d, 0x00},
 727         {0xc0, 0x50},
 728         {0xc1, 0x3c},
 729 };
 730 static const u8 sensor_start_vga_772x[][2] = {
 731         {0x12, 0x00},
 732         {0x17, 0x26},
 733         {0x18, 0xa0},
 734         {0x19, 0x07},
 735         {0x1a, 0xf0},
 736         {0x29, 0xa0},
 737         {0x2c, 0xf0},
 738         {0x65, 0x20},
 739 };
 740 static const u8 bridge_start_qvga_772x[][2] = {
 741         {0x1c, 0x00},
 742         {0x1d, 0x40},
 743         {0x1d, 0x02},
 744         {0x1d, 0x00},
 745         {0x1d, 0x01},
 746         {0x1d, 0x4b},
 747         {0x1d, 0x00},
 748         {0xc0, 0x28},
 749         {0xc1, 0x1e},
 750 };
 751 static const u8 sensor_start_qvga_772x[][2] = {
 752         {0x12, 0x40},
 753         {0x17, 0x3f},
 754         {0x18, 0x50},
 755         {0x19, 0x03},
 756         {0x1a, 0x78},
 757         {0x29, 0x50},
 758         {0x2c, 0x78},
 759         {0x65, 0x2f},
 760 };
 761
 762 static void ov534_reg_write(struct gspca_dev *gspca_dev, u16 reg, u8 val)
 763 {
 764         struct usb_device *udev = gspca_dev->dev;
 765         int ret;
 766
 767         if (gspca_dev->usb_err < 0)
 768                 return;
 769
 770         PDEBUG(D_USBO, "SET 01 0000 %04x %02x", reg, val);
 771         gspca_dev->usb_buf[0] = val;
 772         ret = usb_control_msg(udev,
 773                               usb_sndctrlpipe(udev, 0),
 774                               0x01,
 775                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 776                               0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
 777         if (ret < 0) {
 778                 err("write failed %d", ret);
 779                 gspca_dev->usb_err = ret;
 780         }
 781 }
 782
 783 static u8 ov534_reg_read(struct gspca_dev *gspca_dev, u16 reg)
 784 {
 785         struct usb_device *udev = gspca_dev->dev;
 786         int ret;
 787
 788         if (gspca_dev->usb_err < 0)
 789                 return 0;
 790         ret = usb_control_msg(udev,
 791                               usb_rcvctrlpipe(udev, 0),
 792                               0x01,
 793                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 794                               0x00, reg, gspca_dev->usb_buf, 1, CTRL_TIMEOUT);
 795         PDEBUG(D_USBI, "GET 01 0000 %04x %02x", reg, gspca_dev->usb_buf[0]);
 796         if (ret < 0) {
 797                 err("read failed %d", ret);
 798                 gspca_dev->usb_err = ret;
 799         }
 800         return gspca_dev->usb_buf[0];
 801 }
 802
 803 /* Two bits control LED: 0x21 bit 7 and 0x23 bit 7.
 804  * (direction and output)? */
 805 static void ov534_set_led(struct gspca_dev *gspca_dev, int status)
 806 {
 807         u8 data;
 808
 809         PDEBUG(D_CONF, "led status: %d", status);
 810
 811         data = ov534_reg_read(gspca_dev, 0x21);
 812         data |= 0x80;
 813         ov534_reg_write(gspca_dev, 0x21, data);
 814
 815         data = ov534_reg_read(gspca_dev, 0x23);
 816         if (status)
 817                 data |= 0x80;
 818         else
 819                 data &= ~0x80;
 820
 821         ov534_reg_write(gspca_dev, 0x23, data);
 822
 823         if (!status) {
 824                 data = ov534_reg_read(gspca_dev, 0x21);
 825                 data &= ~0x80;
 826                 ov534_reg_write(gspca_dev, 0x21, data);
 827         }
 828 }
 829
 830 static int sccb_check_status(struct gspca_dev *gspca_dev)
 831 {
 832         u8 data;
 833         int i;
 834
 835         for (i = 0; i < 5; i++) {
 836                 data = ov534_reg_read(gspca_dev, OV534_REG_STATUS);
 837
 838                 switch (data) {
 839                 case 0x00:
 840                         return 1;
 841                 case 0x04:
 842                         return 0;
 843                 case 0x03:
 844                         break;
 845                 default:
 846                         PDEBUG(D_ERR, "sccb status 0x%02x, attempt %d/5",
 847                                data, i + 1);
 848                 }
 849         }
 850         return 0;
 851 }
 852
 853 static void sccb_reg_write(struct gspca_dev *gspca_dev, u8 reg, u8 val)
 854 {
 855         PDEBUG(D_USBO, "sccb write: %02x %02x", reg, val);
 856         ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
 857         ov534_reg_write(gspca_dev, OV534_REG_WRITE, val);
 858         ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_3);
 859
 860         if (!sccb_check_status(gspca_dev)) {
 861                 err("sccb_reg_write failed");
 862                 gspca_dev->usb_err = -EIO;
 863         }
 864 }
 865
 866 static u8 sccb_reg_read(struct gspca_dev *gspca_dev, u16 reg)
 867 {
 868         ov534_reg_write(gspca_dev, OV534_REG_SUBADDR, reg);
 869         ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_WRITE_2);
 870         if (!sccb_check_status(gspca_dev))
 871                 err("sccb_reg_read failed 1");
 872
 873         ov534_reg_write(gspca_dev, OV534_REG_OPERATION, OV534_OP_READ_2);
 874         if (!sccb_check_status(gspca_dev))
 875                 err("sccb_reg_read failed 2");
 876
 877         return ov534_reg_read(gspca_dev, OV534_REG_READ);
 878 }
 879
 880 /* output a bridge sequence (reg - val) */
 881 static void reg_w_array(struct gspca_dev *gspca_dev,
 882                         const u8 (*data)[2], int len)
 883 {
 884         while (--len >= 0) {
 885                 ov534_reg_write(gspca_dev, (*data)[0], (*data)[1]);
 886                 data++;
 887         }
 888 }
 889
 890 /* output a sensor sequence (reg - val) */
 891 static void sccb_w_array(struct gspca_dev *gspca_dev,
 892                         const u8 (*data)[2], int len)
 893 {
 894         while (--len >= 0) {
 895                 if ((*data)[0] != 0xff) {
 896                         sccb_reg_write(gspca_dev, (*data)[0], (*data)[1]);
 897                 } else {
 898                         sccb_reg_read(gspca_dev, (*data)[1]);
 899                         sccb_reg_write(gspca_dev, 0xff, 0x00);
 900                 }
 901                 data++;
 902         }
 903 }
 904
 905 /* ov772x specific controls */
 906 static void set_frame_rate(struct gspca_dev *gspca_dev)
 907 {
 908         struct sd *sd = (struct sd *) gspca_dev;
 909         int i;
 910         struct rate_s {
 911                 u8 fps;
 912                 u8 r11;
 913                 u8 r0d;
 914                 u8 re5;
 915         };
 916         const struct rate_s *r;
 917         static const struct rate_s rate_0[] = { /* 640x480 */
 918                 {60, 0x01, 0xc1, 0x04},
 919                 {50, 0x01, 0x41, 0x02},
 920                 {40, 0x02, 0xc1, 0x04},
 921                 {30, 0x04, 0x81, 0x02},
 922                 {15, 0x03, 0x41, 0x04},
 923         };
 924         static const struct rate_s rate_1[] = { /* 320x240 */
 925                 {125, 0x02, 0x81, 0x02},
 926                 {100, 0x02, 0xc1, 0x04},
 927                 {75, 0x03, 0xc1, 0x04},
 928                 {60, 0x04, 0xc1, 0x04},
 929                 {50, 0x02, 0x41, 0x04},
 930                 {40, 0x03, 0x41, 0x04},
 931                 {30, 0x04, 0x41, 0x04},
 932         };
 933
 934         if (sd->sensor != SENSOR_OV772x)
 935                 return;
 936         if (gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv == 0) {
 937                 r = rate_0;
 938                 i = ARRAY_SIZE(rate_0);
 939         } else {
 940                 r = rate_1;
 941                 i = ARRAY_SIZE(rate_1);
 942         }
 943         while (--i > 0) {
 944                 if (sd->frame_rate >= r->fps)
 945                         break;
 946                 r++;
 947         }
 948
 949         sccb_reg_write(gspca_dev, 0x11, r->r11);
 950         sccb_reg_write(gspca_dev, 0x0d, r->r0d);
 951         ov534_reg_write(gspca_dev, 0xe5, r->re5);
 952
 953         PDEBUG(D_PROBE, "frame_rate: %d", r->fps);
 954 }
 955
 956 static void setbrightness(struct gspca_dev *gspca_dev)
 957 {
 958         struct sd *sd = (struct sd *) gspca_dev;
 959         int val;
 960
 961         val = sd->ctrls[BRIGHTNESS].val;
 962         if (sd->sensor == SENSOR_OV767x) {
 963                 if (val < 0)
 964                         val = 0x80 - val;
 965                 sccb_reg_write(gspca_dev, 0x55, val);   /* bright */
 966         } else {
 967                 sccb_reg_write(gspca_dev, 0x9b, val);
 968         }
 969 }
 970
 971 static void setcontrast(struct gspca_dev *gspca_dev)
 972 {
 973         struct sd *sd = (struct sd *) gspca_dev;
 974         u8 val;
 975
 976         val = sd->ctrls[CONTRAST].val;
 977         if (sd->sensor == SENSOR_OV767x)
 978                 sccb_reg_write(gspca_dev, 0x56, val);   /* contras */
 979         else
 980                 sccb_reg_write(gspca_dev, 0x9c, val);
 981 }
 982
 983 static void setgain(struct gspca_dev *gspca_dev)
 984 {
 985         struct sd *sd = (struct sd *) gspca_dev;
 986         u8 val;
 987
 988         if (sd->ctrls[AGC].val)
 989                 return;
 990
 991         val = sd->ctrls[GAIN].val;
 992         switch (val & 0x30) {
 993         case 0x00:
 994                 val &= 0x0f;
 995                 break;
 996         case 0x10:
 997                 val &= 0x0f;
 998                 val |= 0x30;
 999                 break;
1000         case 0x20:
1001                 val &= 0x0f;
1002                 val |= 0x70;
1003                 break;
1004         default:
1005 /*      case 0x30: */
1006                 val &= 0x0f;
1007                 val |= 0xf0;
1008                 break;
1009         }
1010         sccb_reg_write(gspca_dev, 0x00, val);
1011 }
1012
1013 static void setexposure(struct gspca_dev *gspca_dev)
1014 {
1015         struct sd *sd = (struct sd *) gspca_dev;
1016         u8 val;
1017
1018         if (sd->ctrls[AEC].val)
1019                 return;
1020
1021         val = sd->ctrls[EXPOSURE].val;
1022         if (sd->sensor == SENSOR_OV767x) {
1023
1024                 /* set only aec[9:2] */
1025                 sccb_reg_write(gspca_dev, 0x10, val);   /* aech */
1026         } else {
1027
1028                 /* 'val' is one byte and represents half of the exposure value
1029                  * we are going to set into registers, a two bytes value:
1030                  *
1031                  *    MSB: ((u16) val << 1) >> 8   == val >> 7
1032                  *    LSB: ((u16) val << 1) & 0xff == val << 1
1033                  */
1034                 sccb_reg_write(gspca_dev, 0x08, val >> 7);
1035                 sccb_reg_write(gspca_dev, 0x10, val << 1);
1036         }
1037 }
1038
1039 static void setagc(struct gspca_dev *gspca_dev)
1040 {
1041         struct sd *sd = (struct sd *) gspca_dev;
1042
1043         if (sd->ctrls[AGC].val) {
1044                 sccb_reg_write(gspca_dev, 0x13,
1045                                 sccb_reg_read(gspca_dev, 0x13) | 0x04);
1046                 sccb_reg_write(gspca_dev, 0x64,
1047                                 sccb_reg_read(gspca_dev, 0x64) | 0x03);
1048         } else {
1049                 sccb_reg_write(gspca_dev, 0x13,
1050                                 sccb_reg_read(gspca_dev, 0x13) & ~0x04);
1051                 sccb_reg_write(gspca_dev, 0x64,
1052                                 sccb_reg_read(gspca_dev, 0x64) & ~0x03);
1053
1054                 setgain(gspca_dev);
1055         }
1056 }
1057
1058 static void setawb(struct gspca_dev *gspca_dev)
1059 {
1060         struct sd *sd = (struct sd *) gspca_dev;
1061
1062         if (sd->ctrls[AWB].val) {
1063                 sccb_reg_write(gspca_dev, 0x13,
1064                                 sccb_reg_read(gspca_dev, 0x13) | 0x02);
1065                 if (sd->sensor == SENSOR_OV772x)
1066                         sccb_reg_write(gspca_dev, 0x63,
1067                                 sccb_reg_read(gspca_dev, 0x63) | 0xc0);
1068         } else {
1069                 sccb_reg_write(gspca_dev, 0x13,
1070                                 sccb_reg_read(gspca_dev, 0x13) & ~0x02);
1071                 if (sd->sensor == SENSOR_OV772x)
1072                         sccb_reg_write(gspca_dev, 0x63,
1073                                 sccb_reg_read(gspca_dev, 0x63) & ~0xc0);
1074         }
1075 }
1076
1077 static void setaec(struct gspca_dev *gspca_dev)
1078 {
1079         struct sd *sd = (struct sd *) gspca_dev;
1080         u8 data;
1081
1082         data = sd->sensor == SENSOR_OV767x ?
1083                         0x05 :          /* agc + aec */
1084                         0x01;           /* agc */
1085         if (sd->ctrls[AEC].val)
1086                 sccb_reg_write(gspca_dev, 0x13,
1087                                 sccb_reg_read(gspca_dev, 0x13) | data);
1088         else {
1089                 sccb_reg_write(gspca_dev, 0x13,
1090                                 sccb_reg_read(gspca_dev, 0x13) & ~data);
1091                 if (sd->sensor == SENSOR_OV767x)
1092                         sd->ctrls[EXPOSURE].val =
1093                                 sccb_reg_read(gspca_dev, 10);   /* aech */
1094                 else
1095                         setexposure(gspca_dev);
1096         }
1097 }
1098
1099 static void setsharpness(struct gspca_dev *gspca_dev)
1100 {
1101         struct sd *sd = (struct sd *) gspca_dev;
1102         u8 val;
1103
1104         val = sd->ctrls[SHARPNESS].val;
1105         sccb_reg_write(gspca_dev, 0x91, val);   /* Auto de-noise threshold */
1106         sccb_reg_write(gspca_dev, 0x8e, val);   /* De-noise threshold */
1107 }
1108
1109 static void sethvflip(struct gspca_dev *gspca_dev)
1110 {
1111         struct sd *sd = (struct sd *) gspca_dev;
1112         u8 val;
1113
1114         if (sd->sensor == SENSOR_OV767x) {
1115                 val = sccb_reg_read(gspca_dev, 0x1e);   /* mvfp */
1116                 val &= ~0x30;
1117                 if (sd->ctrls[HFLIP].val)
1118                         val |= 0x20;
1119                 if (sd->ctrls[VFLIP].val)
1120                         val |= 0x10;
1121                 sccb_reg_write(gspca_dev, 0x1e, val);
1122         } else {
1123                 val = sccb_reg_read(gspca_dev, 0x0c);
1124                 val &= ~0xc0;
1125                 if (sd->ctrls[HFLIP].val == 0)
1126                         val |= 0x40;
1127                 if (sd->ctrls[VFLIP].val == 0)
1128                         val |= 0x80;
1129                 sccb_reg_write(gspca_dev, 0x0c, val);
1130         }
1131 }
1132
1133 static void setcolors(struct gspca_dev *gspca_dev)
1134 {
1135         struct sd *sd = (struct sd *) gspca_dev;
1136         u8 val;
1137         int i;
1138         static u8 color_tb[][6] = {
1139                 {0x42, 0x42, 0x00, 0x11, 0x30, 0x41},
1140                 {0x52, 0x52, 0x00, 0x16, 0x3c, 0x52},
1141                 {0x66, 0x66, 0x00, 0x1b, 0x4b, 0x66},
1142                 {0x80, 0x80, 0x00, 0x22, 0x5e, 0x80},
1143                 {0x9a, 0x9a, 0x00, 0x29, 0x71, 0x9a},
1144                 {0xb8, 0xb8, 0x00, 0x31, 0x87, 0xb8},
1145                 {0xdd, 0xdd, 0x00, 0x3b, 0xa2, 0xdd},
1146         };
1147
1148         val = sd->ctrls[COLORS].val;
1149         for (i = 0; i < ARRAY_SIZE(color_tb[0]); i++)
1150                 sccb_reg_write(gspca_dev, 0x4f + i, color_tb[val][i]);
1151 }
1152
1153 static void setlightfreq(struct gspca_dev *gspca_dev)
1154 {
1155         struct sd *sd = (struct sd *) gspca_dev;
1156         u8 val;
1157
1158         val = sd->ctrls[LIGHTFREQ].val ? 0x9e : 0x00;
1159         if (sd->sensor == SENSOR_OV767x) {
1160                 sccb_reg_write(gspca_dev, 0x2a, 0x00);
1161                 if (val)
1162                         val = 0x9d;     /* insert dummy to 25fps for 50Hz */
1163         }
1164         sccb_reg_write(gspca_dev, 0x2b, val);
1165 }
1166
1167
1168 /* this function is called at probe time */
1169 static int sd_config(struct gspca_dev *gspca_dev,
1170                      const struct usb_device_id *id)
1171 {
1172         struct sd *sd = (struct sd *) gspca_dev;
1173         struct cam *cam;
1174
1175         cam = &gspca_dev->cam;
1176
1177         cam->ctrls = sd->ctrls;
1178
1179         /* the auto white balance control works only when auto gain is set */
1180         if (sd_ctrls[AGC].qctrl.default_value == 0)
1181                 gspca_dev->ctrl_inac |= (1 << AWB);
1182
1183         cam->cam_mode = ov772x_mode;
1184         cam->nmodes = ARRAY_SIZE(ov772x_mode);
1185
1186         sd->frame_rate = 30;
1187
1188         return 0;
1189 }
1190
1191 /* this function is called at probe and resume time */
1192 static int sd_init(struct gspca_dev *gspca_dev)
1193 {
1194         struct sd *sd = (struct sd *) gspca_dev;
1195         u16 sensor_id;
1196         static const struct reg_array bridge_init[NSENSORS] = {
1197         [SENSOR_OV767x] = {bridge_init_767x, ARRAY_SIZE(bridge_init_767x)},
1198         [SENSOR_OV772x] = {bridge_init_772x, ARRAY_SIZE(bridge_init_772x)},
1199         };
1200         static const struct reg_array sensor_init[NSENSORS] = {
1201         [SENSOR_OV767x] = {sensor_init_767x, ARRAY_SIZE(sensor_init_767x)},
1202         [SENSOR_OV772x] = {sensor_init_772x, ARRAY_SIZE(sensor_init_772x)},
1203         };
1204
1205         /* reset bridge */
1206         ov534_reg_write(gspca_dev, 0xe7, 0x3a);
1207         ov534_reg_write(gspca_dev, 0xe0, 0x08);
1208         msleep(100);
1209
1210         /* initialize the sensor address */
1211         ov534_reg_write(gspca_dev, OV534_REG_ADDRESS, 0x42);
1212
1213         /* reset sensor */
1214         sccb_reg_write(gspca_dev, 0x12, 0x80);
1215         msleep(10);
1216
1217         /* probe the sensor */
1218         sccb_reg_read(gspca_dev, 0x0a);
1219         sensor_id = sccb_reg_read(gspca_dev, 0x0a) << 8;
1220         sccb_reg_read(gspca_dev, 0x0b);
1221         sensor_id |= sccb_reg_read(gspca_dev, 0x0b);
1222         PDEBUG(D_PROBE, "Sensor ID: %04x", sensor_id);
1223
1224         if ((sensor_id & 0xfff0) == 0x7670) {
1225                 sd->sensor = SENSOR_OV767x;
1226                 gspca_dev->ctrl_dis = (1 << GAIN) |
1227                                         (1 << AGC) |
1228                                         (1 << SHARPNESS);       /* auto */
1229                 sd->ctrls[BRIGHTNESS].min = -127;
1230                 sd->ctrls[BRIGHTNESS].max = 127;
1231                 sd->ctrls[BRIGHTNESS].def = 0;
1232                 sd->ctrls[CONTRAST].max = 0x80;
1233                 sd->ctrls[CONTRAST].def = 0x40;
1234                 sd->ctrls[EXPOSURE].min = 0x08;
1235                 sd->ctrls[EXPOSURE].max = 0x60;
1236                 sd->ctrls[EXPOSURE].def = 0x13;
1237                 sd->ctrls[SHARPNESS].max = 9;
1238                 sd->ctrls[SHARPNESS].def = 4;
1239                 sd->ctrls[HFLIP].def = 1;
1240                 gspca_dev->cam.cam_mode = ov767x_mode;
1241                 gspca_dev->cam.nmodes = ARRAY_SIZE(ov767x_mode);
1242         } else {
1243                 sd->sensor = SENSOR_OV772x;
1244                 gspca_dev->ctrl_dis = (1 << COLORS);
1245                 gspca_dev->cam.bulk = 1;
1246                 gspca_dev->cam.bulk_size = 16384;
1247                 gspca_dev->cam.bulk_nurbs = 2;
1248                 gspca_dev->cam.mode_framerates = ov772x_framerates;
1249         }
1250
1251         /* initialize */
1252         reg_w_array(gspca_dev, bridge_init[sd->sensor].val,
1253                         bridge_init[sd->sensor].len);
1254         ov534_set_led(gspca_dev, 1);
1255         sccb_w_array(gspca_dev, sensor_init[sd->sensor].val,
1256                         sensor_init[sd->sensor].len);
1257         if (sd->sensor == SENSOR_OV767x)
1258                 sd_start(gspca_dev);
1259         sd_stopN(gspca_dev);
1260 /*      set_frame_rate(gspca_dev);      */
1261
1262         return gspca_dev->usb_err;
1263 }
1264
1265 static int sd_start(struct gspca_dev *gspca_dev)
1266 {
1267         struct sd *sd = (struct sd *) gspca_dev;
1268         int mode;
1269         static const struct reg_array bridge_start[NSENSORS][2] = {
1270         [SENSOR_OV767x] = {{bridge_start_qvga_767x,
1271                                         ARRAY_SIZE(bridge_start_qvga_767x)},
1272                         {bridge_start_vga_767x,
1273                                         ARRAY_SIZE(bridge_start_vga_767x)}},
1274         [SENSOR_OV772x] = {{bridge_start_qvga_772x,
1275                                         ARRAY_SIZE(bridge_start_qvga_772x)},
1276                         {bridge_start_vga_772x,
1277                                         ARRAY_SIZE(bridge_start_vga_772x)}},
1278         };
1279         static const struct reg_array sensor_start[NSENSORS][2] = {
1280         [SENSOR_OV767x] = {{sensor_start_qvga_767x,
1281                                         ARRAY_SIZE(sensor_start_qvga_767x)},
1282                         {sensor_start_vga_767x,
1283                                         ARRAY_SIZE(sensor_start_vga_767x)}},
1284         [SENSOR_OV772x] = {{sensor_start_qvga_772x,
1285                                         ARRAY_SIZE(sensor_start_qvga_772x)},
1286                         {sensor_start_vga_772x,
1287                                         ARRAY_SIZE(sensor_start_vga_772x)}},
1288         };
1289
1290         /* (from ms-win trace) */
1291         if (sd->sensor == SENSOR_OV767x)
1292                 sccb_reg_write(gspca_dev, 0x1e, 0x04);
1293                                         /* black sun enable ? */
1294
1295         mode = gspca_dev->curr_mode;    /* 0: 320x240, 1: 640x480 */
1296         reg_w_array(gspca_dev, bridge_start[sd->sensor][mode].val,
1297                                 bridge_start[sd->sensor][mode].len);
1298         sccb_w_array(gspca_dev, sensor_start[sd->sensor][mode].val,
1299                                 sensor_start[sd->sensor][mode].len);
1300
1301         set_frame_rate(gspca_dev);
1302
1303         if (!(gspca_dev->ctrl_dis & (1 << AGC)))
1304                 setagc(gspca_dev);
1305         setawb(gspca_dev);
1306         setaec(gspca_dev);
1307         if (!(gspca_dev->ctrl_dis & (1 << GAIN)))
1308                 setgain(gspca_dev);
1309         setexposure(gspca_dev);
1310         setbrightness(gspca_dev);
1311         setcontrast(gspca_dev);
1312         if (!(gspca_dev->ctrl_dis & (1 << SHARPNESS)))
1313                 setsharpness(gspca_dev);
1314         sethvflip(gspca_dev);
1315         if (!(gspca_dev->ctrl_dis & (1 << COLORS)))
1316                 setcolors(gspca_dev);
1317         setlightfreq(gspca_dev);
1318
1319         ov534_set_led(gspca_dev, 1);
1320         ov534_reg_write(gspca_dev, 0xe0, 0x00);
1321         return gspca_dev->usb_err;
1322 }
1323
1324 static void sd_stopN(struct gspca_dev *gspca_dev)
1325 {
1326         ov534_reg_write(gspca_dev, 0xe0, 0x09);
1327         ov534_set_led(gspca_dev, 0);
1328 }
1329
1330 /* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
1331 #define UVC_STREAM_EOH  (1 << 7)
1332 #define UVC_STREAM_ERR  (1 << 6)
1333 #define UVC_STREAM_STI  (1 << 5)
1334 #define UVC_STREAM_RES  (1 << 4)
1335 #define UVC_STREAM_SCR  (1 << 3)
1336 #define UVC_STREAM_PTS  (1 << 2)
1337 #define UVC_STREAM_EOF  (1 << 1)
1338 #define UVC_STREAM_FID  (1 << 0)
1339
1340 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1341                         u8 *data, int len)
1342 {
1343         struct sd *sd = (struct sd *) gspca_dev;
1344         __u32 this_pts;
1345         u16 this_fid;
1346         int remaining_len = len;
1347         int payload_len;
1348
1349         payload_len = gspca_dev->cam.bulk ? 2048 : 2040;
1350         do {
1351                 len = min(remaining_len, payload_len);
1352
1353                 /* Payloads are prefixed with a UVC-style header.  We
1354                    consider a frame to start when the FID toggles, or the PTS
1355                    changes.  A frame ends when EOF is set, and we've received
1356                    the correct number of bytes. */
1357
1358                 /* Verify UVC header.  Header length is always 12 */
1359                 if (data[0] != 12 || len < 12) {
1360                         PDEBUG(D_PACK, "bad header");
1361                         goto discard;
1362                 }
1363
1364                 /* Check errors */
1365                 if (data[1] & UVC_STREAM_ERR) {
1366                         PDEBUG(D_PACK, "payload error");
1367                         goto discard;
1368                 }
1369
1370                 /* Extract PTS and FID */
1371                 if (!(data[1] & UVC_STREAM_PTS)) {
1372                         PDEBUG(D_PACK, "PTS not present");
1373                         goto discard;
1374                 }
1375                 this_pts = (data[5] << 24) | (data[4] << 16)
1376                                                 | (data[3] << 8) | data[2];
1377                 this_fid = (data[1] & UVC_STREAM_FID) ? 1 : 0;
1378
1379                 /* If PTS or FID has changed, start a new frame. */
1380                 if (this_pts != sd->last_pts || this_fid != sd->last_fid) {
1381                         if (gspca_dev->last_packet_type == INTER_PACKET)
1382                                 gspca_frame_add(gspca_dev, LAST_PACKET,
1383                                                 NULL, 0);
1384                         sd->last_pts = this_pts;
1385                         sd->last_fid = this_fid;
1386                         gspca_frame_add(gspca_dev, FIRST_PACKET,
1387                                         data + 12, len - 12);
1388                 /* If this packet is marked as EOF, end the frame */
1389                 } else if (data[1] & UVC_STREAM_EOF) {
1390                         sd->last_pts = 0;
1391                         if (gspca_dev->pixfmt == V4L2_PIX_FMT_YUYV
1392                          && gspca_dev->image_len + len - 12 !=
1393                                    gspca_dev->width * gspca_dev->height * 2) {
1394                                 PDEBUG(D_PACK, "wrong sized frame");
1395                                 goto discard;
1396                         }
1397                         gspca_frame_add(gspca_dev, LAST_PACKET,
1398                                         data + 12, len - 12);
1399                 } else {
1400
1401                         /* Add the data from this payload */
1402                         gspca_frame_add(gspca_dev, INTER_PACKET,
1403                                         data + 12, len - 12);
1404                 }
1405
1406                 /* Done this payload */
1407                 goto scan_next;
1408
1409 discard:
1410                 /* Discard data until a new frame starts. */
1411                 gspca_dev->last_packet_type = DISCARD_PACKET;
1412
1413 scan_next:
1414                 remaining_len -= len;
1415                 data += len;
1416         } while (remaining_len > 0);
1417 }
1418
1419 static int sd_setagc(struct gspca_dev *gspca_dev, __s32 val)
1420 {
1421         struct sd *sd = (struct sd *) gspca_dev;
1422
1423         sd->ctrls[AGC].val = val;
1424
1425         /* the auto white balance control works only
1426          * when auto gain is set */
1427         if (val) {
1428                 gspca_dev->ctrl_inac &= ~(1 << AWB);
1429         } else {
1430                 gspca_dev->ctrl_inac |= (1 << AWB);
1431                 if (sd->ctrls[AWB].val) {
1432                         sd->ctrls[AWB].val = 0;
1433                         if (gspca_dev->streaming)
1434                                 setawb(gspca_dev);
1435                 }
1436         }
1437         if (gspca_dev->streaming)
1438                 setagc(gspca_dev);
1439         return gspca_dev->usb_err;
1440 }
1441
1442 static int sd_querymenu(struct gspca_dev *gspca_dev,
1443                 struct v4l2_querymenu *menu)
1444 {
1445         switch (menu->id) {
1446         case V4L2_CID_POWER_LINE_FREQUENCY:
1447                 switch (menu->index) {
1448                 case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1449                         strcpy((char *) menu->name, "Disabled");
1450                         return 0;
1451                 case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1452                         strcpy((char *) menu->name, "50 Hz");
1453                         return 0;
1454                 }
1455                 break;
1456         }
1457
1458         return -EINVAL;
1459 }
1460
1461 /* get stream parameters (framerate) */
1462 static void sd_get_streamparm(struct gspca_dev *gspca_dev,
1463                              struct v4l2_streamparm *parm)
1464 {
1465         struct v4l2_captureparm *cp = &parm->parm.capture;
1466         struct v4l2_fract *tpf = &cp->timeperframe;
1467         struct sd *sd = (struct sd *) gspca_dev;
1468
1469         cp->capability |= V4L2_CAP_TIMEPERFRAME;
1470         tpf->numerator = 1;
1471         tpf->denominator = sd->frame_rate;
1472 }
1473
1474 /* set stream parameters (framerate) */
1475 static void sd_set_streamparm(struct gspca_dev *gspca_dev,
1476                              struct v4l2_streamparm *parm)
1477 {
1478         struct v4l2_captureparm *cp = &parm->parm.capture;
1479         struct v4l2_fract *tpf = &cp->timeperframe;
1480         struct sd *sd = (struct sd *) gspca_dev;
1481
1482         /* Set requested framerate */
1483         sd->frame_rate = tpf->denominator / tpf->numerator;
1484         if (gspca_dev->streaming)
1485                 set_frame_rate(gspca_dev);
1486
1487         /* Return the actual framerate */
1488         tpf->numerator = 1;
1489         tpf->denominator = sd->frame_rate;
1490 }
1491
1492 /* sub-driver description */
1493 static const struct sd_desc sd_desc = {
1494         .name     = MODULE_NAME,
1495         .ctrls    = sd_ctrls,
1496         .nctrls   = ARRAY_SIZE(sd_ctrls),
1497         .config   = sd_config,
1498         .init     = sd_init,
1499         .start    = sd_start,
1500         .stopN    = sd_stopN,
1501         .pkt_scan = sd_pkt_scan,
1502         .querymenu = sd_querymenu,
1503         .get_streamparm = sd_get_streamparm,
1504         .set_streamparm = sd_set_streamparm,
1505 };
1506
1507 /* -- module initialisation -- */
1508 static const struct usb_device_id device_table[] = {
1509         {USB_DEVICE(0x1415, 0x2000)},
1510         {USB_DEVICE(0x06f8, 0x3002)},
1511         {}
1512 };
1513
1514 MODULE_DEVICE_TABLE(usb, device_table);
1515
1516 /* -- device connect -- */
1517 static int sd_probe(struct usb_interface *intf, const struct usb_device_id *id)
1518 {
1519         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1520                                 THIS_MODULE);
1521 }
1522
1523 static struct usb_driver sd_driver = {
1524         .name       = MODULE_NAME,
1525         .id_table   = device_table,
1526         .probe      = sd_probe,
1527         .disconnect = gspca_disconnect,
1528 #ifdef CONFIG_PM
1529         .suspend    = gspca_suspend,
1530         .resume     = gspca_resume,
1531 #endif
1532 };
1533
1534 /* -- module insert / remove -- */
1535 static int __init sd_mod_init(void)
1536 {
1537         return usb_register(&sd_driver);
1538 }
1539
1540 static void __exit sd_mod_exit(void)
1541 {
1542         usb_deregister(&sd_driver);
1543 }
1544
1545 module_init(sd_mod_init);
1546 module_exit(sd_mod_exit);