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