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