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