1 /* 2 * Sunplus spca561 subdriver 3 * 4 * Copyright (C) 2004 Michel Xhaard mxhaard@magic.fr 5 * 6 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 25 #define MODULE_NAME "spca561" 26 27 #include <linux/input.h> 28 #include "gspca.h" 29 30 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>"); 31 MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver"); 32 MODULE_LICENSE("GPL"); 33 34 #define EXPOSURE_MAX (2047 + 325) 35 36 /* specific webcam descriptor */ 37 struct sd { 38 struct gspca_dev gspca_dev; /* !! must be the first item */ 39 40 struct { /* hue/contrast control cluster */ 41 struct v4l2_ctrl *contrast; 42 struct v4l2_ctrl *hue; 43 }; 44 struct v4l2_ctrl *autogain; 45 46 #define EXPO12A_DEF 3 47 __u8 expo12a; /* expo/gain? for rev 12a */ 48 49 __u8 chip_revision; 50 #define Rev012A 0 51 #define Rev072A 1 52 53 signed char ag_cnt; 54 #define AG_CNT_START 13 55 }; 56 57 static const struct v4l2_pix_format sif_012a_mode[] = { 58 {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, 59 .bytesperline = 160, 60 .sizeimage = 160 * 120, 61 .colorspace = V4L2_COLORSPACE_SRGB, 62 .priv = 3}, 63 {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, 64 .bytesperline = 176, 65 .sizeimage = 176 * 144, 66 .colorspace = V4L2_COLORSPACE_SRGB, 67 .priv = 2}, 68 {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE, 69 .bytesperline = 320, 70 .sizeimage = 320 * 240 * 4 / 8, 71 .colorspace = V4L2_COLORSPACE_SRGB, 72 .priv = 1}, 73 {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE, 74 .bytesperline = 352, 75 .sizeimage = 352 * 288 * 4 / 8, 76 .colorspace = V4L2_COLORSPACE_SRGB, 77 .priv = 0}, 78 }; 79 80 static const struct v4l2_pix_format sif_072a_mode[] = { 81 {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, 82 .bytesperline = 160, 83 .sizeimage = 160 * 120, 84 .colorspace = V4L2_COLORSPACE_SRGB, 85 .priv = 3}, 86 {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, 87 .bytesperline = 176, 88 .sizeimage = 176 * 144, 89 .colorspace = V4L2_COLORSPACE_SRGB, 90 .priv = 2}, 91 {320, 240, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, 92 .bytesperline = 320, 93 .sizeimage = 320 * 240, 94 .colorspace = V4L2_COLORSPACE_SRGB, 95 .priv = 1}, 96 {352, 288, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE, 97 .bytesperline = 352, 98 .sizeimage = 352 * 288, 99 .colorspace = V4L2_COLORSPACE_SRGB, 100 .priv = 0}, 101 }; 102 103 /* 104 * Initialization data 105 * I'm not very sure how to split initialization from open data 106 * chunks. For now, we'll consider everything as initialization 107 */ 108 /* Frame packet header offsets for the spca561 */ 109 #define SPCA561_OFFSET_SNAP 1 110 #define SPCA561_OFFSET_TYPE 2 111 #define SPCA561_OFFSET_COMPRESS 3 112 #define SPCA561_OFFSET_FRAMSEQ 4 113 #define SPCA561_OFFSET_GPIO 5 114 #define SPCA561_OFFSET_USBBUFF 6 115 #define SPCA561_OFFSET_WIN2GRAVE 7 116 #define SPCA561_OFFSET_WIN2RAVE 8 117 #define SPCA561_OFFSET_WIN2BAVE 9 118 #define SPCA561_OFFSET_WIN2GBAVE 10 119 #define SPCA561_OFFSET_WIN1GRAVE 11 120 #define SPCA561_OFFSET_WIN1RAVE 12 121 #define SPCA561_OFFSET_WIN1BAVE 13 122 #define SPCA561_OFFSET_WIN1GBAVE 14 123 #define SPCA561_OFFSET_FREQ 15 124 #define SPCA561_OFFSET_VSYNC 16 125 #define SPCA561_INDEX_I2C_BASE 0x8800 126 #define SPCA561_SNAPBIT 0x20 127 #define SPCA561_SNAPCTRL 0x40 128 129 static const u16 rev72a_reset[][2] = { 130 {0x0000, 0x8114}, /* Software GPIO output data */ 131 {0x0001, 0x8114}, /* Software GPIO output data */ 132 {0x0000, 0x8112}, /* Some kind of reset */ 133 {} 134 }; 135 static const __u16 rev72a_init_data1[][2] = { 136 {0x0003, 0x8701}, /* PCLK clock delay adjustment */ 137 {0x0001, 0x8703}, /* HSYNC from cmos inverted */ 138 {0x0011, 0x8118}, /* Enable and conf sensor */ 139 {0x0001, 0x8118}, /* Conf sensor */ 140 {0x0092, 0x8804}, /* I know nothing about these */ 141 {0x0010, 0x8802}, /* 0x88xx registers, so I won't */ 142 {} 143 }; 144 static const u16 rev72a_init_sensor1[][2] = { 145 {0x0001, 0x000d}, 146 {0x0002, 0x0018}, 147 {0x0004, 0x0165}, 148 {0x0005, 0x0021}, 149 {0x0007, 0x00aa}, 150 {0x0020, 0x1504}, 151 {0x0039, 0x0002}, 152 {0x0035, 0x0010}, 153 {0x0009, 0x1049}, 154 {0x0028, 0x000b}, 155 {0x003b, 0x000f}, 156 {0x003c, 0x0000}, 157 {} 158 }; 159 static const __u16 rev72a_init_data2[][2] = { 160 {0x0018, 0x8601}, /* Pixel/line selection for color separation */ 161 {0x0000, 0x8602}, /* Optical black level for user setting */ 162 {0x0060, 0x8604}, /* Optical black horizontal offset */ 163 {0x0002, 0x8605}, /* Optical black vertical offset */ 164 {0x0000, 0x8603}, /* Non-automatic optical black level */ 165 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */ 166 {0x0000, 0x865f}, /* Vertical valid pixels window (x2) */ 167 {0x00b0, 0x865d}, /* Horizontal valid pixels window (x2) */ 168 {0x0090, 0x865e}, /* Vertical valid lines window (x2) */ 169 {0x00e0, 0x8406}, /* Memory buffer threshold */ 170 {0x0000, 0x8660}, /* Compensation memory stuff */ 171 {0x0002, 0x8201}, /* Output address for r/w serial EEPROM */ 172 {0x0008, 0x8200}, /* Clear valid bit for serial EEPROM */ 173 {0x0001, 0x8200}, /* OprMode to be executed by hardware */ 174 /* from ms-win */ 175 {0x0000, 0x8611}, /* R offset for white balance */ 176 {0x00fd, 0x8612}, /* Gr offset for white balance */ 177 {0x0003, 0x8613}, /* B offset for white balance */ 178 {0x0000, 0x8614}, /* Gb offset for white balance */ 179 /* from ms-win */ 180 {0x0035, 0x8651}, /* R gain for white balance */ 181 {0x0040, 0x8652}, /* Gr gain for white balance */ 182 {0x005f, 0x8653}, /* B gain for white balance */ 183 {0x0040, 0x8654}, /* Gb gain for white balance */ 184 {0x0002, 0x8502}, /* Maximum average bit rate stuff */ 185 {0x0011, 0x8802}, 186 187 {0x0087, 0x8700}, /* Set master clock (96Mhz????) */ 188 {0x0081, 0x8702}, /* Master clock output enable */ 189 190 {0x0000, 0x8500}, /* Set image type (352x288 no compression) */ 191 /* Originally was 0x0010 (352x288 compression) */ 192 193 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */ 194 {0x0003, 0x865c}, /* Vertical offset for valid lines */ 195 {} 196 }; 197 static const u16 rev72a_init_sensor2[][2] = { 198 {0x0003, 0x0121}, 199 {0x0004, 0x0165}, 200 {0x0005, 0x002f}, /* blanking control column */ 201 {0x0006, 0x0000}, /* blanking mode row*/ 202 {0x000a, 0x0002}, 203 {0x0009, 0x1061}, /* setexposure times && pixel clock 204 * 0001 0 | 000 0110 0001 */ 205 {0x0035, 0x0014}, 206 {} 207 }; 208 209 /******************** QC Express etch2 stuff ********************/ 210 static const __u16 Pb100_1map8300[][2] = { 211 /* reg, value */ 212 {0x8320, 0x3304}, 213 214 {0x8303, 0x0125}, /* image area */ 215 {0x8304, 0x0169}, 216 {0x8328, 0x000b}, 217 {0x833c, 0x0001}, /*fixme: win:07*/ 218 219 {0x832f, 0x1904}, /*fixme: was 0419*/ 220 {0x8307, 0x00aa}, 221 {0x8301, 0x0003}, 222 {0x8302, 0x000e}, 223 {} 224 }; 225 static const __u16 Pb100_2map8300[][2] = { 226 /* reg, value */ 227 {0x8339, 0x0000}, 228 {0x8307, 0x00aa}, 229 {} 230 }; 231 232 static const __u16 spca561_161rev12A_data1[][2] = { 233 {0x29, 0x8118}, /* Control register (various enable bits) */ 234 {0x08, 0x8114}, /* GPIO: Led off */ 235 {0x0e, 0x8112}, /* 0x0e stream off 0x3e stream on */ 236 {0x00, 0x8102}, /* white balance - new */ 237 {0x92, 0x8804}, 238 {0x04, 0x8802}, /* windows uses 08 */ 239 {} 240 }; 241 static const __u16 spca561_161rev12A_data2[][2] = { 242 {0x21, 0x8118}, 243 {0x10, 0x8500}, 244 {0x07, 0x8601}, 245 {0x07, 0x8602}, 246 {0x04, 0x8501}, 247 248 {0x07, 0x8201}, /* windows uses 02 */ 249 {0x08, 0x8200}, 250 {0x01, 0x8200}, 251 252 {0x90, 0x8604}, 253 {0x00, 0x8605}, 254 {0xb0, 0x8603}, 255 256 /* sensor gains */ 257 {0x07, 0x8601}, /* white balance - new */ 258 {0x07, 0x8602}, /* white balance - new */ 259 {0x00, 0x8610}, /* *red */ 260 {0x00, 0x8611}, /* 3f *green */ 261 {0x00, 0x8612}, /* green *blue */ 262 {0x00, 0x8613}, /* blue *green */ 263 {0x43, 0x8614}, /* green *red - white balance - was 0x35 */ 264 {0x40, 0x8615}, /* 40 *green - white balance - was 0x35 */ 265 {0x71, 0x8616}, /* 7a *blue - white balance - was 0x35 */ 266 {0x40, 0x8617}, /* 40 *green - white balance - was 0x35 */ 267 268 {0x0c, 0x8620}, /* 0c */ 269 {0xc8, 0x8631}, /* c8 */ 270 {0xc8, 0x8634}, /* c8 */ 271 {0x23, 0x8635}, /* 23 */ 272 {0x1f, 0x8636}, /* 1f */ 273 {0xdd, 0x8637}, /* dd */ 274 {0xe1, 0x8638}, /* e1 */ 275 {0x1d, 0x8639}, /* 1d */ 276 {0x21, 0x863a}, /* 21 */ 277 {0xe3, 0x863b}, /* e3 */ 278 {0xdf, 0x863c}, /* df */ 279 {0xf0, 0x8505}, 280 {0x32, 0x850a}, 281 /* {0x99, 0x8700}, * - white balance - new (removed) */ 282 /* HDG we used to do this in stop0, making the init state and the state 283 after a start / stop different, so do this here instead. */ 284 {0x29, 0x8118}, 285 {} 286 }; 287 288 static void reg_w_val(struct usb_device *dev, __u16 index, __u8 value) 289 { 290 int ret; 291 292 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 293 0, /* request */ 294 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 295 value, index, NULL, 0, 500); 296 PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value); 297 if (ret < 0) 298 pr_err("reg write: error %d\n", ret); 299 } 300 301 static void write_vector(struct gspca_dev *gspca_dev, 302 const __u16 data[][2]) 303 { 304 struct usb_device *dev = gspca_dev->dev; 305 int i; 306 307 i = 0; 308 while (data[i][1] != 0) { 309 reg_w_val(dev, data[i][1], data[i][0]); 310 i++; 311 } 312 } 313 314 /* read 'len' bytes to gspca_dev->usb_buf */ 315 static void reg_r(struct gspca_dev *gspca_dev, 316 __u16 index, __u16 length) 317 { 318 usb_control_msg(gspca_dev->dev, 319 usb_rcvctrlpipe(gspca_dev->dev, 0), 320 0, /* request */ 321 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 322 0, /* value */ 323 index, gspca_dev->usb_buf, length, 500); 324 } 325 326 /* write 'len' bytes from gspca_dev->usb_buf */ 327 static void reg_w_buf(struct gspca_dev *gspca_dev, 328 __u16 index, __u16 len) 329 { 330 usb_control_msg(gspca_dev->dev, 331 usb_sndctrlpipe(gspca_dev->dev, 0), 332 0, /* request */ 333 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 334 0, /* value */ 335 index, gspca_dev->usb_buf, len, 500); 336 } 337 338 static void i2c_write(struct gspca_dev *gspca_dev, __u16 value, __u16 reg) 339 { 340 int retry = 60; 341 342 reg_w_val(gspca_dev->dev, 0x8801, reg); 343 reg_w_val(gspca_dev->dev, 0x8805, value); 344 reg_w_val(gspca_dev->dev, 0x8800, value >> 8); 345 do { 346 reg_r(gspca_dev, 0x8803, 1); 347 if (!gspca_dev->usb_buf[0]) 348 return; 349 msleep(10); 350 } while (--retry); 351 } 352 353 static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode) 354 { 355 int retry = 60; 356 __u8 value; 357 358 reg_w_val(gspca_dev->dev, 0x8804, 0x92); 359 reg_w_val(gspca_dev->dev, 0x8801, reg); 360 reg_w_val(gspca_dev->dev, 0x8802, mode | 0x01); 361 do { 362 reg_r(gspca_dev, 0x8803, 1); 363 if (!gspca_dev->usb_buf[0]) { 364 reg_r(gspca_dev, 0x8800, 1); 365 value = gspca_dev->usb_buf[0]; 366 reg_r(gspca_dev, 0x8805, 1); 367 return ((int) value << 8) | gspca_dev->usb_buf[0]; 368 } 369 msleep(10); 370 } while (--retry); 371 return -1; 372 } 373 374 static void sensor_mapwrite(struct gspca_dev *gspca_dev, 375 const __u16 (*sensormap)[2]) 376 { 377 while ((*sensormap)[0]) { 378 gspca_dev->usb_buf[0] = (*sensormap)[1]; 379 gspca_dev->usb_buf[1] = (*sensormap)[1] >> 8; 380 reg_w_buf(gspca_dev, (*sensormap)[0], 2); 381 sensormap++; 382 } 383 } 384 385 static void write_sensor_72a(struct gspca_dev *gspca_dev, 386 const __u16 (*sensor)[2]) 387 { 388 while ((*sensor)[0]) { 389 i2c_write(gspca_dev, (*sensor)[1], (*sensor)[0]); 390 sensor++; 391 } 392 } 393 394 static void init_161rev12A(struct gspca_dev *gspca_dev) 395 { 396 write_vector(gspca_dev, spca561_161rev12A_data1); 397 sensor_mapwrite(gspca_dev, Pb100_1map8300); 398 /*fixme: should be in sd_start*/ 399 write_vector(gspca_dev, spca561_161rev12A_data2); 400 sensor_mapwrite(gspca_dev, Pb100_2map8300); 401 } 402 403 /* this function is called at probe time */ 404 static int sd_config(struct gspca_dev *gspca_dev, 405 const struct usb_device_id *id) 406 { 407 struct sd *sd = (struct sd *) gspca_dev; 408 struct cam *cam; 409 __u16 vendor, product; 410 __u8 data1, data2; 411 412 /* Read frm global register the USB product and vendor IDs, just to 413 * prove that we can communicate with the device. This works, which 414 * confirms at we are communicating properly and that the device 415 * is a 561. */ 416 reg_r(gspca_dev, 0x8104, 1); 417 data1 = gspca_dev->usb_buf[0]; 418 reg_r(gspca_dev, 0x8105, 1); 419 data2 = gspca_dev->usb_buf[0]; 420 vendor = (data2 << 8) | data1; 421 reg_r(gspca_dev, 0x8106, 1); 422 data1 = gspca_dev->usb_buf[0]; 423 reg_r(gspca_dev, 0x8107, 1); 424 data2 = gspca_dev->usb_buf[0]; 425 product = (data2 << 8) | data1; 426 if (vendor != id->idVendor || product != id->idProduct) { 427 PDEBUG(D_PROBE, "Bad vendor / product from device"); 428 return -EINVAL; 429 } 430 431 cam = &gspca_dev->cam; 432 cam->needs_full_bandwidth = 1; 433 434 sd->chip_revision = id->driver_info; 435 if (sd->chip_revision == Rev012A) { 436 cam->cam_mode = sif_012a_mode; 437 cam->nmodes = ARRAY_SIZE(sif_012a_mode); 438 } else { 439 cam->cam_mode = sif_072a_mode; 440 cam->nmodes = ARRAY_SIZE(sif_072a_mode); 441 } 442 sd->expo12a = EXPO12A_DEF; 443 return 0; 444 } 445 446 /* this function is called at probe and resume time */ 447 static int sd_init_12a(struct gspca_dev *gspca_dev) 448 { 449 PDEBUG(D_STREAM, "Chip revision: 012a"); 450 init_161rev12A(gspca_dev); 451 return 0; 452 } 453 static int sd_init_72a(struct gspca_dev *gspca_dev) 454 { 455 PDEBUG(D_STREAM, "Chip revision: 072a"); 456 write_vector(gspca_dev, rev72a_reset); 457 msleep(200); 458 write_vector(gspca_dev, rev72a_init_data1); 459 write_sensor_72a(gspca_dev, rev72a_init_sensor1); 460 write_vector(gspca_dev, rev72a_init_data2); 461 write_sensor_72a(gspca_dev, rev72a_init_sensor2); 462 reg_w_val(gspca_dev->dev, 0x8112, 0x30); 463 return 0; 464 } 465 466 static void setbrightness(struct gspca_dev *gspca_dev, s32 val) 467 { 468 struct sd *sd = (struct sd *) gspca_dev; 469 struct usb_device *dev = gspca_dev->dev; 470 __u16 reg; 471 472 if (sd->chip_revision == Rev012A) 473 reg = 0x8610; 474 else 475 reg = 0x8611; 476 477 reg_w_val(dev, reg + 0, val); /* R */ 478 reg_w_val(dev, reg + 1, val); /* Gr */ 479 reg_w_val(dev, reg + 2, val); /* B */ 480 reg_w_val(dev, reg + 3, val); /* Gb */ 481 } 482 483 static void setwhite(struct gspca_dev *gspca_dev, s32 white, s32 contrast) 484 { 485 struct sd *sd = (struct sd *) gspca_dev; 486 struct usb_device *dev = gspca_dev->dev; 487 __u8 blue, red; 488 __u16 reg; 489 490 /* try to emulate MS-win as possible */ 491 red = 0x20 + white * 3 / 8; 492 blue = 0x90 - white * 5 / 8; 493 if (sd->chip_revision == Rev012A) { 494 reg = 0x8614; 495 } else { 496 reg = 0x8651; 497 red += contrast - 0x20; 498 blue += contrast - 0x20; 499 reg_w_val(dev, 0x8652, contrast + 0x20); /* Gr */ 500 reg_w_val(dev, 0x8654, contrast + 0x20); /* Gb */ 501 } 502 reg_w_val(dev, reg, red); 503 reg_w_val(dev, reg + 2, blue); 504 } 505 506 /* rev 12a only */ 507 static void setexposure(struct gspca_dev *gspca_dev, s32 val) 508 { 509 int i, expo = 0; 510 511 /* Register 0x8309 controls exposure for the spca561, 512 the basic exposure setting goes from 1-2047, where 1 is completely 513 dark and 2047 is very bright. It not only influences exposure but 514 also the framerate (to allow for longer exposure) from 1 - 300 it 515 only raises the exposure time then from 300 - 600 it halves the 516 framerate to be able to further raise the exposure time and for every 517 300 more it halves the framerate again. This allows for a maximum 518 exposure time of circa 0.2 - 0.25 seconds (30 / (2000/3000) fps). 519 Sometimes this is not enough, the 1-2047 uses bits 0-10, bits 11-12 520 configure a divider for the base framerate which us used at the 521 exposure setting of 1-300. These bits configure the base framerate 522 according to the following formula: fps = 60 / (value + 2) */ 523 524 /* We choose to use the high bits setting the fixed framerate divisor 525 asap, as setting high basic exposure setting without the fixed 526 divider in combination with high gains makes the cam stop */ 527 int table[] = { 0, 450, 550, 625, EXPOSURE_MAX }; 528 529 for (i = 0; i < ARRAY_SIZE(table) - 1; i++) { 530 if (val <= table[i + 1]) { 531 expo = val - table[i]; 532 if (i) 533 expo += 300; 534 expo |= i << 11; 535 break; 536 } 537 } 538 539 gspca_dev->usb_buf[0] = expo; 540 gspca_dev->usb_buf[1] = expo >> 8; 541 reg_w_buf(gspca_dev, 0x8309, 2); 542 } 543 544 /* rev 12a only */ 545 static void setgain(struct gspca_dev *gspca_dev, s32 val) 546 { 547 /* gain reg low 6 bits 0-63 gain, bit 6 and 7, both double the 548 sensitivity when set, so 31 + one of them set == 63, and 15 549 with both of them set == 63 */ 550 if (val < 64) 551 gspca_dev->usb_buf[0] = val; 552 else if (val < 128) 553 gspca_dev->usb_buf[0] = (val / 2) | 0x40; 554 else 555 gspca_dev->usb_buf[0] = (val / 4) | 0xc0; 556 557 gspca_dev->usb_buf[1] = 0; 558 reg_w_buf(gspca_dev, 0x8335, 2); 559 } 560 561 static void setautogain(struct gspca_dev *gspca_dev, s32 val) 562 { 563 struct sd *sd = (struct sd *) gspca_dev; 564 565 if (val) 566 sd->ag_cnt = AG_CNT_START; 567 else 568 sd->ag_cnt = -1; 569 } 570 571 static int sd_start_12a(struct gspca_dev *gspca_dev) 572 { 573 struct usb_device *dev = gspca_dev->dev; 574 int mode; 575 static const __u8 Reg8391[8] = 576 {0x92, 0x30, 0x20, 0x00, 0x0c, 0x00, 0x00, 0x00}; 577 578 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; 579 if (mode <= 1) { 580 /* Use compression on 320x240 and above */ 581 reg_w_val(dev, 0x8500, 0x10 | mode); 582 } else { 583 /* I couldn't get the compression to work below 320x240 584 * Fortunately at these resolutions the bandwidth 585 * is sufficient to push raw frames at ~20fps */ 586 reg_w_val(dev, 0x8500, mode); 587 } /* -- qq@kuku.eu.org */ 588 589 gspca_dev->usb_buf[0] = 0xaa; 590 gspca_dev->usb_buf[1] = 0x00; 591 reg_w_buf(gspca_dev, 0x8307, 2); 592 /* clock - lower 0x8X values lead to fps > 30 */ 593 reg_w_val(gspca_dev->dev, 0x8700, 0x8a); 594 /* 0x8f 0x85 0x27 clock */ 595 reg_w_val(gspca_dev->dev, 0x8112, 0x1e | 0x20); 596 reg_w_val(gspca_dev->dev, 0x850b, 0x03); 597 memcpy(gspca_dev->usb_buf, Reg8391, 8); 598 reg_w_buf(gspca_dev, 0x8391, 8); 599 reg_w_buf(gspca_dev, 0x8390, 8); 600 601 /* Led ON (bit 3 -> 0 */ 602 reg_w_val(gspca_dev->dev, 0x8114, 0x00); 603 return 0; 604 } 605 static int sd_start_72a(struct gspca_dev *gspca_dev) 606 { 607 struct sd *sd = (struct sd *) gspca_dev; 608 struct usb_device *dev = gspca_dev->dev; 609 int Clck; 610 int mode; 611 612 write_vector(gspca_dev, rev72a_reset); 613 msleep(200); 614 write_vector(gspca_dev, rev72a_init_data1); 615 write_sensor_72a(gspca_dev, rev72a_init_sensor1); 616 617 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; 618 switch (mode) { 619 default: 620 case 0: 621 Clck = 0x27; /* ms-win 0x87 */ 622 break; 623 case 1: 624 Clck = 0x25; 625 break; 626 case 2: 627 Clck = 0x22; 628 break; 629 case 3: 630 Clck = 0x21; 631 break; 632 } 633 reg_w_val(dev, 0x8700, Clck); /* 0x27 clock */ 634 reg_w_val(dev, 0x8702, 0x81); 635 reg_w_val(dev, 0x8500, mode); /* mode */ 636 write_sensor_72a(gspca_dev, rev72a_init_sensor2); 637 setwhite(gspca_dev, v4l2_ctrl_g_ctrl(sd->hue), 638 v4l2_ctrl_g_ctrl(sd->contrast)); 639 /* setbrightness(gspca_dev); * fixme: bad values */ 640 setautogain(gspca_dev, v4l2_ctrl_g_ctrl(sd->autogain)); 641 reg_w_val(dev, 0x8112, 0x10 | 0x20); 642 return 0; 643 } 644 645 static void sd_stopN(struct gspca_dev *gspca_dev) 646 { 647 struct sd *sd = (struct sd *) gspca_dev; 648 649 if (sd->chip_revision == Rev012A) { 650 reg_w_val(gspca_dev->dev, 0x8112, 0x0e); 651 /* Led Off (bit 3 -> 1 */ 652 reg_w_val(gspca_dev->dev, 0x8114, 0x08); 653 } else { 654 reg_w_val(gspca_dev->dev, 0x8112, 0x20); 655 /* reg_w_val(gspca_dev->dev, 0x8102, 0x00); ?? */ 656 } 657 } 658 659 static void do_autogain(struct gspca_dev *gspca_dev) 660 { 661 struct sd *sd = (struct sd *) gspca_dev; 662 int expotimes; 663 int pixelclk; 664 int gainG; 665 __u8 R, Gr, Gb, B; 666 int y; 667 __u8 luma_mean = 110; 668 __u8 luma_delta = 20; 669 __u8 spring = 4; 670 671 if (sd->ag_cnt < 0) 672 return; 673 if (--sd->ag_cnt >= 0) 674 return; 675 sd->ag_cnt = AG_CNT_START; 676 677 switch (sd->chip_revision) { 678 case Rev072A: 679 reg_r(gspca_dev, 0x8621, 1); 680 Gr = gspca_dev->usb_buf[0]; 681 reg_r(gspca_dev, 0x8622, 1); 682 R = gspca_dev->usb_buf[0]; 683 reg_r(gspca_dev, 0x8623, 1); 684 B = gspca_dev->usb_buf[0]; 685 reg_r(gspca_dev, 0x8624, 1); 686 Gb = gspca_dev->usb_buf[0]; 687 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8; 688 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */ 689 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */ 690 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */ 691 692 if (y < luma_mean - luma_delta || 693 y > luma_mean + luma_delta) { 694 expotimes = i2c_read(gspca_dev, 0x09, 0x10); 695 pixelclk = 0x0800; 696 expotimes = expotimes & 0x07ff; 697 /* PDEBUG(D_PACK, 698 "Exposition Times 0x%03X Clock 0x%04X ", 699 expotimes,pixelclk); */ 700 gainG = i2c_read(gspca_dev, 0x35, 0x10); 701 /* PDEBUG(D_PACK, 702 "reading Gain register %d", gainG); */ 703 704 expotimes += (luma_mean - y) >> spring; 705 gainG += (luma_mean - y) / 50; 706 /* PDEBUG(D_PACK, 707 "compute expotimes %d gain %d", 708 expotimes,gainG); */ 709 710 if (gainG > 0x3f) 711 gainG = 0x3f; 712 else if (gainG < 3) 713 gainG = 3; 714 i2c_write(gspca_dev, gainG, 0x35); 715 716 if (expotimes > 0x0256) 717 expotimes = 0x0256; 718 else if (expotimes < 3) 719 expotimes = 3; 720 i2c_write(gspca_dev, expotimes | pixelclk, 0x09); 721 } 722 break; 723 } 724 } 725 726 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 727 u8 *data, /* isoc packet */ 728 int len) /* iso packet length */ 729 { 730 struct sd *sd = (struct sd *) gspca_dev; 731 732 len--; 733 switch (*data++) { /* sequence number */ 734 case 0: /* start of frame */ 735 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 736 737 /* This should never happen */ 738 if (len < 2) { 739 PDEBUG(D_ERR, "Short SOF packet, ignoring"); 740 gspca_dev->last_packet_type = DISCARD_PACKET; 741 return; 742 } 743 744 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 745 if (data[0] & 0x20) { 746 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 747 input_sync(gspca_dev->input_dev); 748 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 749 input_sync(gspca_dev->input_dev); 750 } 751 #endif 752 753 if (data[1] & 0x10) { 754 /* compressed bayer */ 755 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len); 756 } else { 757 /* raw bayer (with a header, which we skip) */ 758 if (sd->chip_revision == Rev012A) { 759 data += 20; 760 len -= 20; 761 } else { 762 data += 16; 763 len -= 16; 764 } 765 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len); 766 } 767 return; 768 case 0xff: /* drop (empty mpackets) */ 769 return; 770 } 771 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 772 } 773 774 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 775 { 776 struct gspca_dev *gspca_dev = 777 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 778 struct sd *sd = (struct sd *)gspca_dev; 779 780 gspca_dev->usb_err = 0; 781 782 if (!gspca_dev->streaming) 783 return 0; 784 785 switch (ctrl->id) { 786 case V4L2_CID_BRIGHTNESS: 787 setbrightness(gspca_dev, ctrl->val); 788 break; 789 case V4L2_CID_CONTRAST: 790 /* hue/contrast control cluster for 72a */ 791 setwhite(gspca_dev, sd->hue->val, ctrl->val); 792 break; 793 case V4L2_CID_HUE: 794 /* just plain hue control for 12a */ 795 setwhite(gspca_dev, ctrl->val, 0); 796 break; 797 case V4L2_CID_EXPOSURE: 798 setexposure(gspca_dev, ctrl->val); 799 break; 800 case V4L2_CID_GAIN: 801 setgain(gspca_dev, ctrl->val); 802 break; 803 case V4L2_CID_AUTOGAIN: 804 setautogain(gspca_dev, ctrl->val); 805 break; 806 } 807 return gspca_dev->usb_err; 808 } 809 810 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 811 .s_ctrl = sd_s_ctrl, 812 }; 813 814 static int sd_init_controls_12a(struct gspca_dev *gspca_dev) 815 { 816 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 817 818 gspca_dev->vdev.ctrl_handler = hdl; 819 v4l2_ctrl_handler_init(hdl, 3); 820 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 821 V4L2_CID_HUE, 1, 0x7f, 1, 0x40); 822 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 823 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0); 824 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 825 V4L2_CID_EXPOSURE, 1, EXPOSURE_MAX, 1, 700); 826 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 827 V4L2_CID_GAIN, 0, 255, 1, 63); 828 829 if (hdl->error) { 830 pr_err("Could not initialize controls\n"); 831 return hdl->error; 832 } 833 return 0; 834 } 835 836 static int sd_init_controls_72a(struct gspca_dev *gspca_dev) 837 { 838 struct sd *sd = (struct sd *)gspca_dev; 839 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 840 841 gspca_dev->vdev.ctrl_handler = hdl; 842 v4l2_ctrl_handler_init(hdl, 4); 843 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 844 V4L2_CID_CONTRAST, 0, 0x3f, 1, 0x20); 845 sd->hue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 846 V4L2_CID_HUE, 1, 0x7f, 1, 0x40); 847 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 848 V4L2_CID_BRIGHTNESS, 0, 0x3f, 1, 0x20); 849 sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 850 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 851 852 if (hdl->error) { 853 pr_err("Could not initialize controls\n"); 854 return hdl->error; 855 } 856 v4l2_ctrl_cluster(2, &sd->contrast); 857 return 0; 858 } 859 860 /* sub-driver description */ 861 static const struct sd_desc sd_desc_12a = { 862 .name = MODULE_NAME, 863 .init_controls = sd_init_controls_12a, 864 .config = sd_config, 865 .init = sd_init_12a, 866 .start = sd_start_12a, 867 .stopN = sd_stopN, 868 .pkt_scan = sd_pkt_scan, 869 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 870 .other_input = 1, 871 #endif 872 }; 873 static const struct sd_desc sd_desc_72a = { 874 .name = MODULE_NAME, 875 .init_controls = sd_init_controls_72a, 876 .config = sd_config, 877 .init = sd_init_72a, 878 .start = sd_start_72a, 879 .stopN = sd_stopN, 880 .pkt_scan = sd_pkt_scan, 881 .dq_callback = do_autogain, 882 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 883 .other_input = 1, 884 #endif 885 }; 886 static const struct sd_desc *sd_desc[2] = { 887 &sd_desc_12a, 888 &sd_desc_72a 889 }; 890 891 /* -- module initialisation -- */ 892 static const struct usb_device_id device_table[] = { 893 {USB_DEVICE(0x041e, 0x401a), .driver_info = Rev072A}, 894 {USB_DEVICE(0x041e, 0x403b), .driver_info = Rev012A}, 895 {USB_DEVICE(0x0458, 0x7004), .driver_info = Rev072A}, 896 {USB_DEVICE(0x0461, 0x0815), .driver_info = Rev072A}, 897 {USB_DEVICE(0x046d, 0x0928), .driver_info = Rev012A}, 898 {USB_DEVICE(0x046d, 0x0929), .driver_info = Rev012A}, 899 {USB_DEVICE(0x046d, 0x092a), .driver_info = Rev012A}, 900 {USB_DEVICE(0x046d, 0x092b), .driver_info = Rev012A}, 901 {USB_DEVICE(0x046d, 0x092c), .driver_info = Rev012A}, 902 {USB_DEVICE(0x046d, 0x092d), .driver_info = Rev012A}, 903 {USB_DEVICE(0x046d, 0x092e), .driver_info = Rev012A}, 904 {USB_DEVICE(0x046d, 0x092f), .driver_info = Rev012A}, 905 {USB_DEVICE(0x04fc, 0x0561), .driver_info = Rev072A}, 906 {USB_DEVICE(0x060b, 0xa001), .driver_info = Rev072A}, 907 {USB_DEVICE(0x10fd, 0x7e50), .driver_info = Rev072A}, 908 {USB_DEVICE(0xabcd, 0xcdee), .driver_info = Rev072A}, 909 {} 910 }; 911 912 MODULE_DEVICE_TABLE(usb, device_table); 913 914 /* -- device connect -- */ 915 static int sd_probe(struct usb_interface *intf, 916 const struct usb_device_id *id) 917 { 918 return gspca_dev_probe(intf, id, 919 sd_desc[id->driver_info], 920 sizeof(struct sd), 921 THIS_MODULE); 922 } 923 924 static struct usb_driver sd_driver = { 925 .name = MODULE_NAME, 926 .id_table = device_table, 927 .probe = sd_probe, 928 .disconnect = gspca_disconnect, 929 #ifdef CONFIG_PM 930 .suspend = gspca_suspend, 931 .resume = gspca_resume, 932 .reset_resume = gspca_resume, 933 #endif 934 }; 935 936 module_usb_driver(sd_driver); 937