1 /* 2 * Mars MR97310A library 3 * 4 * The original mr97310a driver, which supported the Aiptek Pencam VGA+, is 5 * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com> 6 * 7 * Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+ 8 * and for the routines for detecting and classifying these various cameras, 9 * is Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu> 10 * 11 * Support for the control settings for the CIF cameras is 12 * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com> and 13 * Thomas Kaiser <thomas@kaiser-linux.li> 14 * 15 * Support for the control settings for the VGA cameras is 16 * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu> 17 * 18 * Several previously unsupported cameras are owned and have been tested by 19 * Hans de Goede <hdegoede@redhat.com> and 20 * Thomas Kaiser <thomas@kaiser-linux.li> and 21 * Theodore Kilgore <kilgota@auburn.edu> and 22 * Edmond Rodriguez <erodrig_97@yahoo.com> and 23 * Aurelien Jacobs <aurel@gnuage.org> 24 * 25 * The MR97311A support in gspca/mars.c has been helpful in understanding some 26 * of the registers in these cameras. 27 * 28 * This program is free software; you can redistribute it and/or modify 29 * it under the terms of the GNU General Public License as published by 30 * the Free Software Foundation; either version 2 of the License, or 31 * any later version. 32 * 33 * This program is distributed in the hope that it will be useful, 34 * but WITHOUT ANY WARRANTY; without even the implied warranty of 35 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 36 * GNU General Public License for more details. 37 */ 38 39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 40 41 #define MODULE_NAME "mr97310a" 42 43 #include "gspca.h" 44 45 #define CAM_TYPE_CIF 0 46 #define CAM_TYPE_VGA 1 47 48 #define MR97310A_BRIGHTNESS_DEFAULT 0 49 50 #define MR97310A_EXPOSURE_MIN 0 51 #define MR97310A_EXPOSURE_MAX 4095 52 #define MR97310A_EXPOSURE_DEFAULT 1000 53 54 #define MR97310A_GAIN_MIN 0 55 #define MR97310A_GAIN_MAX 31 56 #define MR97310A_GAIN_DEFAULT 25 57 58 #define MR97310A_CONTRAST_MIN 0 59 #define MR97310A_CONTRAST_MAX 31 60 #define MR97310A_CONTRAST_DEFAULT 23 61 62 #define MR97310A_CS_GAIN_MIN 0 63 #define MR97310A_CS_GAIN_MAX 0x7ff 64 #define MR97310A_CS_GAIN_DEFAULT 0x110 65 66 #define MR97310A_CID_CLOCKDIV (V4L2_CTRL_CLASS_USER + 0x1000) 67 #define MR97310A_MIN_CLOCKDIV_MIN 3 68 #define MR97310A_MIN_CLOCKDIV_MAX 8 69 #define MR97310A_MIN_CLOCKDIV_DEFAULT 3 70 71 MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,Theodore Kilgore <kilgota@auburn.edu>"); 72 MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver"); 73 MODULE_LICENSE("GPL"); 74 75 /* global parameters */ 76 static int force_sensor_type = -1; 77 module_param(force_sensor_type, int, 0644); 78 MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)"); 79 80 /* specific webcam descriptor */ 81 struct sd { 82 struct gspca_dev gspca_dev; /* !! must be the first item */ 83 struct { /* exposure/min_clockdiv control cluster */ 84 struct v4l2_ctrl *exposure; 85 struct v4l2_ctrl *min_clockdiv; 86 }; 87 u8 sof_read; 88 u8 cam_type; /* 0 is CIF and 1 is VGA */ 89 u8 sensor_type; /* We use 0 and 1 here, too. */ 90 u8 do_lcd_stop; 91 u8 adj_colors; 92 }; 93 94 struct sensor_w_data { 95 u8 reg; 96 u8 flags; 97 u8 data[16]; 98 int len; 99 }; 100 101 static void sd_stopN(struct gspca_dev *gspca_dev); 102 103 static const struct v4l2_pix_format vga_mode[] = { 104 {160, 120, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE, 105 .bytesperline = 160, 106 .sizeimage = 160 * 120, 107 .colorspace = V4L2_COLORSPACE_SRGB, 108 .priv = 4}, 109 {176, 144, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE, 110 .bytesperline = 176, 111 .sizeimage = 176 * 144, 112 .colorspace = V4L2_COLORSPACE_SRGB, 113 .priv = 3}, 114 {320, 240, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE, 115 .bytesperline = 320, 116 .sizeimage = 320 * 240, 117 .colorspace = V4L2_COLORSPACE_SRGB, 118 .priv = 2}, 119 {352, 288, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE, 120 .bytesperline = 352, 121 .sizeimage = 352 * 288, 122 .colorspace = V4L2_COLORSPACE_SRGB, 123 .priv = 1}, 124 {640, 480, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE, 125 .bytesperline = 640, 126 .sizeimage = 640 * 480, 127 .colorspace = V4L2_COLORSPACE_SRGB, 128 .priv = 0}, 129 }; 130 131 /* the bytes to write are in gspca_dev->usb_buf */ 132 static int mr_write(struct gspca_dev *gspca_dev, int len) 133 { 134 int rc; 135 136 rc = usb_bulk_msg(gspca_dev->dev, 137 usb_sndbulkpipe(gspca_dev->dev, 4), 138 gspca_dev->usb_buf, len, NULL, 500); 139 if (rc < 0) 140 pr_err("reg write [%02x] error %d\n", 141 gspca_dev->usb_buf[0], rc); 142 return rc; 143 } 144 145 /* the bytes are read into gspca_dev->usb_buf */ 146 static int mr_read(struct gspca_dev *gspca_dev, int len) 147 { 148 int rc; 149 150 rc = usb_bulk_msg(gspca_dev->dev, 151 usb_rcvbulkpipe(gspca_dev->dev, 3), 152 gspca_dev->usb_buf, len, NULL, 500); 153 if (rc < 0) 154 pr_err("reg read [%02x] error %d\n", 155 gspca_dev->usb_buf[0], rc); 156 return rc; 157 } 158 159 static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags, 160 const u8 *data, int len) 161 { 162 gspca_dev->usb_buf[0] = 0x1f; 163 gspca_dev->usb_buf[1] = flags; 164 gspca_dev->usb_buf[2] = reg; 165 memcpy(gspca_dev->usb_buf + 3, data, len); 166 167 return mr_write(gspca_dev, len + 3); 168 } 169 170 static int sensor_write_regs(struct gspca_dev *gspca_dev, 171 const struct sensor_w_data *data, int len) 172 { 173 int i, rc; 174 175 for (i = 0; i < len; i++) { 176 rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags, 177 data[i].data, data[i].len); 178 if (rc < 0) 179 return rc; 180 } 181 182 return 0; 183 } 184 185 static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data) 186 { 187 struct sd *sd = (struct sd *) gspca_dev; 188 u8 buf, confirm_reg; 189 int rc; 190 191 buf = data; 192 if (sd->cam_type == CAM_TYPE_CIF) { 193 rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1); 194 confirm_reg = sd->sensor_type ? 0x13 : 0x11; 195 } else { 196 rc = sensor_write_reg(gspca_dev, reg, 0x00, &buf, 1); 197 confirm_reg = 0x11; 198 } 199 if (rc < 0) 200 return rc; 201 202 buf = 0x01; 203 rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1); 204 if (rc < 0) 205 return rc; 206 207 return 0; 208 } 209 210 static int cam_get_response16(struct gspca_dev *gspca_dev, u8 reg, int verbose) 211 { 212 int err_code; 213 214 gspca_dev->usb_buf[0] = reg; 215 err_code = mr_write(gspca_dev, 1); 216 if (err_code < 0) 217 return err_code; 218 219 err_code = mr_read(gspca_dev, 16); 220 if (err_code < 0) 221 return err_code; 222 223 if (verbose) 224 gspca_dbg(gspca_dev, D_PROBE, "Register: %02x reads %02x%02x%02x\n", 225 reg, 226 gspca_dev->usb_buf[0], 227 gspca_dev->usb_buf[1], 228 gspca_dev->usb_buf[2]); 229 230 return 0; 231 } 232 233 static int zero_the_pointer(struct gspca_dev *gspca_dev) 234 { 235 __u8 *data = gspca_dev->usb_buf; 236 int err_code; 237 u8 status = 0; 238 int tries = 0; 239 240 err_code = cam_get_response16(gspca_dev, 0x21, 0); 241 if (err_code < 0) 242 return err_code; 243 244 data[0] = 0x19; 245 data[1] = 0x51; 246 err_code = mr_write(gspca_dev, 2); 247 if (err_code < 0) 248 return err_code; 249 250 err_code = cam_get_response16(gspca_dev, 0x21, 0); 251 if (err_code < 0) 252 return err_code; 253 254 data[0] = 0x19; 255 data[1] = 0xba; 256 err_code = mr_write(gspca_dev, 2); 257 if (err_code < 0) 258 return err_code; 259 260 err_code = cam_get_response16(gspca_dev, 0x21, 0); 261 if (err_code < 0) 262 return err_code; 263 264 data[0] = 0x19; 265 data[1] = 0x00; 266 err_code = mr_write(gspca_dev, 2); 267 if (err_code < 0) 268 return err_code; 269 270 err_code = cam_get_response16(gspca_dev, 0x21, 0); 271 if (err_code < 0) 272 return err_code; 273 274 data[0] = 0x19; 275 data[1] = 0x00; 276 err_code = mr_write(gspca_dev, 2); 277 if (err_code < 0) 278 return err_code; 279 280 while (status != 0x0a && tries < 256) { 281 err_code = cam_get_response16(gspca_dev, 0x21, 0); 282 status = data[0]; 283 tries++; 284 if (err_code < 0) 285 return err_code; 286 } 287 if (status != 0x0a) 288 gspca_err(gspca_dev, "status is %02x\n", status); 289 290 tries = 0; 291 while (tries < 4) { 292 data[0] = 0x19; 293 data[1] = 0x00; 294 err_code = mr_write(gspca_dev, 2); 295 if (err_code < 0) 296 return err_code; 297 298 err_code = cam_get_response16(gspca_dev, 0x21, 0); 299 status = data[0]; 300 tries++; 301 if (err_code < 0) 302 return err_code; 303 } 304 305 data[0] = 0x19; 306 err_code = mr_write(gspca_dev, 1); 307 if (err_code < 0) 308 return err_code; 309 310 err_code = mr_read(gspca_dev, 16); 311 if (err_code < 0) 312 return err_code; 313 314 return 0; 315 } 316 317 static int stream_start(struct gspca_dev *gspca_dev) 318 { 319 gspca_dev->usb_buf[0] = 0x01; 320 gspca_dev->usb_buf[1] = 0x01; 321 return mr_write(gspca_dev, 2); 322 } 323 324 static void stream_stop(struct gspca_dev *gspca_dev) 325 { 326 gspca_dev->usb_buf[0] = 0x01; 327 gspca_dev->usb_buf[1] = 0x00; 328 if (mr_write(gspca_dev, 2) < 0) 329 gspca_err(gspca_dev, "Stream Stop failed\n"); 330 } 331 332 static void lcd_stop(struct gspca_dev *gspca_dev) 333 { 334 gspca_dev->usb_buf[0] = 0x19; 335 gspca_dev->usb_buf[1] = 0x54; 336 if (mr_write(gspca_dev, 2) < 0) 337 gspca_err(gspca_dev, "LCD Stop failed\n"); 338 } 339 340 static int isoc_enable(struct gspca_dev *gspca_dev) 341 { 342 gspca_dev->usb_buf[0] = 0x00; 343 gspca_dev->usb_buf[1] = 0x4d; /* ISOC transferring enable... */ 344 return mr_write(gspca_dev, 2); 345 } 346 347 /* This function is called at probe time */ 348 static int sd_config(struct gspca_dev *gspca_dev, 349 const struct usb_device_id *id) 350 { 351 struct sd *sd = (struct sd *) gspca_dev; 352 struct cam *cam; 353 int err_code; 354 355 cam = &gspca_dev->cam; 356 cam->cam_mode = vga_mode; 357 cam->nmodes = ARRAY_SIZE(vga_mode); 358 sd->do_lcd_stop = 0; 359 360 /* Several of the supported CIF cameras share the same USB ID but 361 * require different initializations and different control settings. 362 * The same is true of the VGA cameras. Therefore, we are forced 363 * to start the initialization process in order to determine which 364 * camera is present. Some of the supported cameras require the 365 * memory pointer to be set to 0 as the very first item of business 366 * or else they will not stream. So we do that immediately. 367 */ 368 err_code = zero_the_pointer(gspca_dev); 369 if (err_code < 0) 370 return err_code; 371 372 err_code = stream_start(gspca_dev); 373 if (err_code < 0) 374 return err_code; 375 376 /* Now, the query for sensor type. */ 377 err_code = cam_get_response16(gspca_dev, 0x07, 1); 378 if (err_code < 0) 379 return err_code; 380 381 if (id->idProduct == 0x0110 || id->idProduct == 0x010e) { 382 sd->cam_type = CAM_TYPE_CIF; 383 cam->nmodes--; 384 /* 385 * All but one of the known CIF cameras share the same USB ID, 386 * but two different init routines are in use, and the control 387 * settings are different, too. We need to detect which camera 388 * of the two known varieties is connected! 389 * 390 * A list of known CIF cameras follows. They all report either 391 * 0200 for type 0 or 0300 for type 1. 392 * If you have another to report, please do 393 * 394 * Name sd->sensor_type reported by 395 * 396 * Sakar 56379 Spy-shot 0 T. Kilgore 397 * Innovage 0 T. Kilgore 398 * Vivitar Mini 0 H. De Goede 399 * Vivitar Mini 0 E. Rodriguez 400 * Vivitar Mini 1 T. Kilgore 401 * Elta-Media 8212dc 1 T. Kaiser 402 * Philips dig. keych. 1 T. Kilgore 403 * Trust Spyc@m 100 1 A. Jacobs 404 */ 405 switch (gspca_dev->usb_buf[0]) { 406 case 2: 407 sd->sensor_type = 0; 408 break; 409 case 3: 410 sd->sensor_type = 1; 411 break; 412 default: 413 pr_err("Unknown CIF Sensor id : %02x\n", 414 gspca_dev->usb_buf[1]); 415 return -ENODEV; 416 } 417 gspca_dbg(gspca_dev, D_PROBE, "MR97310A CIF camera detected, sensor: %d\n", 418 sd->sensor_type); 419 } else { 420 sd->cam_type = CAM_TYPE_VGA; 421 422 /* 423 * Here is a table of the responses to the query for sensor 424 * type, from the known MR97310A VGA cameras. Six different 425 * cameras of which five share the same USB ID. 426 * 427 * Name gspca_dev->usb_buf[] sd->sensor_type 428 * sd->do_lcd_stop 429 * Aiptek Pencam VGA+ 0300 0 1 430 * ION digital 0300 0 1 431 * Argus DC-1620 0450 1 0 432 * Argus QuickClix 0420 1 1 433 * Sakar 77379 Digital 0350 0 1 434 * Sakar 1638x CyberPix 0120 0 2 435 * 436 * Based upon these results, we assume default settings 437 * and then correct as necessary, as follows. 438 * 439 */ 440 441 sd->sensor_type = 1; 442 sd->do_lcd_stop = 0; 443 sd->adj_colors = 0; 444 if (gspca_dev->usb_buf[0] == 0x01) { 445 sd->sensor_type = 2; 446 } else if ((gspca_dev->usb_buf[0] != 0x03) && 447 (gspca_dev->usb_buf[0] != 0x04)) { 448 pr_err("Unknown VGA Sensor id Byte 0: %02x\n", 449 gspca_dev->usb_buf[0]); 450 pr_err("Defaults assumed, may not work\n"); 451 pr_err("Please report this\n"); 452 } 453 /* Sakar Digital color needs to be adjusted. */ 454 if ((gspca_dev->usb_buf[0] == 0x03) && 455 (gspca_dev->usb_buf[1] == 0x50)) 456 sd->adj_colors = 1; 457 if (gspca_dev->usb_buf[0] == 0x04) { 458 sd->do_lcd_stop = 1; 459 switch (gspca_dev->usb_buf[1]) { 460 case 0x50: 461 sd->sensor_type = 0; 462 gspca_dbg(gspca_dev, D_PROBE, "sensor_type corrected to 0\n"); 463 break; 464 case 0x20: 465 /* Nothing to do here. */ 466 break; 467 default: 468 pr_err("Unknown VGA Sensor id Byte 1: %02x\n", 469 gspca_dev->usb_buf[1]); 470 pr_err("Defaults assumed, may not work\n"); 471 pr_err("Please report this\n"); 472 } 473 } 474 gspca_dbg(gspca_dev, D_PROBE, "MR97310A VGA camera detected, sensor: %d\n", 475 sd->sensor_type); 476 } 477 /* Stop streaming as we've started it only to probe the sensor type. */ 478 sd_stopN(gspca_dev); 479 480 if (force_sensor_type != -1) { 481 sd->sensor_type = !!force_sensor_type; 482 gspca_dbg(gspca_dev, D_PROBE, "Forcing sensor type to: %d\n", 483 sd->sensor_type); 484 } 485 486 return 0; 487 } 488 489 /* this function is called at probe and resume time */ 490 static int sd_init(struct gspca_dev *gspca_dev) 491 { 492 return 0; 493 } 494 495 static int start_cif_cam(struct gspca_dev *gspca_dev) 496 { 497 struct sd *sd = (struct sd *) gspca_dev; 498 __u8 *data = gspca_dev->usb_buf; 499 int err_code; 500 static const __u8 startup_string[] = { 501 0x00, 502 0x0d, 503 0x01, 504 0x00, /* Hsize/8 for 352 or 320 */ 505 0x00, /* Vsize/4 for 288 or 240 */ 506 0x13, /* or 0xbb, depends on sensor */ 507 0x00, /* Hstart, depends on res. */ 508 0x00, /* reserved ? */ 509 0x00, /* Vstart, depends on res. and sensor */ 510 0x50, /* 0x54 to get 176 or 160 */ 511 0xc0 512 }; 513 514 /* Note: Some of the above descriptions guessed from MR97113A driver */ 515 516 memcpy(data, startup_string, 11); 517 if (sd->sensor_type) 518 data[5] = 0xbb; 519 520 switch (gspca_dev->pixfmt.width) { 521 case 160: 522 data[9] |= 0x04; /* reg 8, 2:1 scale down from 320 */ 523 /* fall thru */ 524 case 320: 525 default: 526 data[3] = 0x28; /* reg 2, H size/8 */ 527 data[4] = 0x3c; /* reg 3, V size/4 */ 528 data[6] = 0x14; /* reg 5, H start */ 529 data[8] = 0x1a + sd->sensor_type; /* reg 7, V start */ 530 break; 531 case 176: 532 data[9] |= 0x04; /* reg 8, 2:1 scale down from 352 */ 533 /* fall thru */ 534 case 352: 535 data[3] = 0x2c; /* reg 2, H size/8 */ 536 data[4] = 0x48; /* reg 3, V size/4 */ 537 data[6] = 0x06; /* reg 5, H start */ 538 data[8] = 0x06 - sd->sensor_type; /* reg 7, V start */ 539 break; 540 } 541 err_code = mr_write(gspca_dev, 11); 542 if (err_code < 0) 543 return err_code; 544 545 if (!sd->sensor_type) { 546 static const struct sensor_w_data cif_sensor0_init_data[] = { 547 {0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01, 548 0x0f, 0x14, 0x0f, 0x10}, 8}, 549 {0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5}, 550 {0x12, 0x00, {0x07}, 1}, 551 {0x1f, 0x00, {0x06}, 1}, 552 {0x27, 0x00, {0x04}, 1}, 553 {0x29, 0x00, {0x0c}, 1}, 554 {0x40, 0x00, {0x40, 0x00, 0x04}, 3}, 555 {0x50, 0x00, {0x60}, 1}, 556 {0x60, 0x00, {0x06}, 1}, 557 {0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6}, 558 {0x72, 0x00, {0x1e, 0x56}, 2}, 559 {0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02, 560 0x31, 0x80, 0x00}, 9}, 561 {0x11, 0x00, {0x01}, 1}, 562 {0, 0, {0}, 0} 563 }; 564 err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data, 565 ARRAY_SIZE(cif_sensor0_init_data)); 566 } else { /* sd->sensor_type = 1 */ 567 static const struct sensor_w_data cif_sensor1_init_data[] = { 568 /* Reg 3,4, 7,8 get set by the controls */ 569 {0x02, 0x00, {0x10}, 1}, 570 {0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */ 571 {0x06, 0x01, {0x00}, 1}, 572 {0x09, 0x02, {0x0e}, 1}, 573 {0x0a, 0x02, {0x05}, 1}, 574 {0x0b, 0x02, {0x05}, 1}, 575 {0x0c, 0x02, {0x0f}, 1}, 576 {0x0d, 0x02, {0x07}, 1}, 577 {0x0e, 0x02, {0x0c}, 1}, 578 {0x0f, 0x00, {0x00}, 1}, 579 {0x10, 0x00, {0x06}, 1}, 580 {0x11, 0x00, {0x07}, 1}, 581 {0x12, 0x00, {0x00}, 1}, 582 {0x13, 0x00, {0x01}, 1}, 583 {0, 0, {0}, 0} 584 }; 585 /* Without this command the cam won't work with USB-UHCI */ 586 gspca_dev->usb_buf[0] = 0x0a; 587 gspca_dev->usb_buf[1] = 0x00; 588 err_code = mr_write(gspca_dev, 2); 589 if (err_code < 0) 590 return err_code; 591 err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data, 592 ARRAY_SIZE(cif_sensor1_init_data)); 593 } 594 return err_code; 595 } 596 597 static int start_vga_cam(struct gspca_dev *gspca_dev) 598 { 599 struct sd *sd = (struct sd *) gspca_dev; 600 __u8 *data = gspca_dev->usb_buf; 601 int err_code; 602 static const __u8 startup_string[] = 603 {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00, 604 0x00, 0x50, 0xc0}; 605 /* What some of these mean is explained in start_cif_cam(), above */ 606 607 memcpy(data, startup_string, 11); 608 if (!sd->sensor_type) { 609 data[5] = 0x00; 610 data[10] = 0x91; 611 } 612 if (sd->sensor_type == 2) { 613 data[5] = 0x00; 614 data[10] = 0x18; 615 } 616 617 switch (gspca_dev->pixfmt.width) { 618 case 160: 619 data[9] |= 0x0c; /* reg 8, 4:1 scale down */ 620 /* fall thru */ 621 case 320: 622 data[9] |= 0x04; /* reg 8, 2:1 scale down */ 623 /* fall thru */ 624 case 640: 625 default: 626 data[3] = 0x50; /* reg 2, H size/8 */ 627 data[4] = 0x78; /* reg 3, V size/4 */ 628 data[6] = 0x04; /* reg 5, H start */ 629 data[8] = 0x03; /* reg 7, V start */ 630 if (sd->sensor_type == 2) { 631 data[6] = 2; 632 data[8] = 1; 633 } 634 if (sd->do_lcd_stop) 635 data[8] = 0x04; /* Bayer tile shifted */ 636 break; 637 638 case 176: 639 data[9] |= 0x04; /* reg 8, 2:1 scale down */ 640 /* fall thru */ 641 case 352: 642 data[3] = 0x2c; /* reg 2, H size */ 643 data[4] = 0x48; /* reg 3, V size */ 644 data[6] = 0x94; /* reg 5, H start */ 645 data[8] = 0x63; /* reg 7, V start */ 646 if (sd->do_lcd_stop) 647 data[8] = 0x64; /* Bayer tile shifted */ 648 break; 649 } 650 651 err_code = mr_write(gspca_dev, 11); 652 if (err_code < 0) 653 return err_code; 654 655 if (!sd->sensor_type) { 656 static const struct sensor_w_data vga_sensor0_init_data[] = { 657 {0x01, 0x00, {0x0c, 0x00, 0x04}, 3}, 658 {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4}, 659 {0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4}, 660 {0x25, 0x00, {0x03, 0xa9, 0x80}, 3}, 661 {0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4}, 662 {0, 0, {0}, 0} 663 }; 664 err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data, 665 ARRAY_SIZE(vga_sensor0_init_data)); 666 } else if (sd->sensor_type == 1) { 667 static const struct sensor_w_data color_adj[] = { 668 {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00, 669 /* adjusted blue, green, red gain correct 670 too much blue from the Sakar Digital */ 671 0x05, 0x01, 0x04}, 8} 672 }; 673 674 static const struct sensor_w_data color_no_adj[] = { 675 {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00, 676 /* default blue, green, red gain settings */ 677 0x07, 0x00, 0x01}, 8} 678 }; 679 680 static const struct sensor_w_data vga_sensor1_init_data[] = { 681 {0x11, 0x04, {0x01}, 1}, 682 {0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01, 683 /* These settings may be better for some cameras */ 684 /* {0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01, */ 685 0x00, 0x0a}, 7}, 686 {0x11, 0x04, {0x01}, 1}, 687 {0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6}, 688 {0x11, 0x04, {0x01}, 1}, 689 {0, 0, {0}, 0} 690 }; 691 692 if (sd->adj_colors) 693 err_code = sensor_write_regs(gspca_dev, color_adj, 694 ARRAY_SIZE(color_adj)); 695 else 696 err_code = sensor_write_regs(gspca_dev, color_no_adj, 697 ARRAY_SIZE(color_no_adj)); 698 699 if (err_code < 0) 700 return err_code; 701 702 err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data, 703 ARRAY_SIZE(vga_sensor1_init_data)); 704 } else { /* sensor type == 2 */ 705 static const struct sensor_w_data vga_sensor2_init_data[] = { 706 707 {0x01, 0x00, {0x48}, 1}, 708 {0x02, 0x00, {0x22}, 1}, 709 /* Reg 3 msb and 4 is lsb of the exposure setting*/ 710 {0x05, 0x00, {0x10}, 1}, 711 {0x06, 0x00, {0x00}, 1}, 712 {0x07, 0x00, {0x00}, 1}, 713 {0x08, 0x00, {0x00}, 1}, 714 {0x09, 0x00, {0x00}, 1}, 715 /* The following are used in the gain control 716 * which is BTW completely borked in the OEM driver 717 * The values for each color go from 0 to 0x7ff 718 *{0x0a, 0x00, {0x01}, 1}, green1 gain msb 719 *{0x0b, 0x00, {0x10}, 1}, green1 gain lsb 720 *{0x0c, 0x00, {0x01}, 1}, red gain msb 721 *{0x0d, 0x00, {0x10}, 1}, red gain lsb 722 *{0x0e, 0x00, {0x01}, 1}, blue gain msb 723 *{0x0f, 0x00, {0x10}, 1}, blue gain lsb 724 *{0x10, 0x00, {0x01}, 1}, green2 gain msb 725 *{0x11, 0x00, {0x10}, 1}, green2 gain lsb 726 */ 727 {0x12, 0x00, {0x00}, 1}, 728 {0x13, 0x00, {0x04}, 1}, /* weird effect on colors */ 729 {0x14, 0x00, {0x00}, 1}, 730 {0x15, 0x00, {0x06}, 1}, 731 {0x16, 0x00, {0x01}, 1}, 732 {0x17, 0x00, {0xe2}, 1}, /* vertical alignment */ 733 {0x18, 0x00, {0x02}, 1}, 734 {0x19, 0x00, {0x82}, 1}, /* don't mess with */ 735 {0x1a, 0x00, {0x00}, 1}, 736 {0x1b, 0x00, {0x20}, 1}, 737 /* {0x1c, 0x00, {0x17}, 1}, contrast control */ 738 {0x1d, 0x00, {0x80}, 1}, /* moving causes a mess */ 739 {0x1e, 0x00, {0x08}, 1}, /* moving jams the camera */ 740 {0x1f, 0x00, {0x0c}, 1}, 741 {0x20, 0x00, {0x00}, 1}, 742 {0, 0, {0}, 0} 743 }; 744 err_code = sensor_write_regs(gspca_dev, vga_sensor2_init_data, 745 ARRAY_SIZE(vga_sensor2_init_data)); 746 } 747 return err_code; 748 } 749 750 static int sd_start(struct gspca_dev *gspca_dev) 751 { 752 struct sd *sd = (struct sd *) gspca_dev; 753 int err_code; 754 755 sd->sof_read = 0; 756 757 /* Some of the VGA cameras require the memory pointer 758 * to be set to 0 again. We have been forced to start the 759 * stream in sd_config() to detect the hardware, and closed it. 760 * Thus, we need here to do a completely fresh and clean start. */ 761 err_code = zero_the_pointer(gspca_dev); 762 if (err_code < 0) 763 return err_code; 764 765 err_code = stream_start(gspca_dev); 766 if (err_code < 0) 767 return err_code; 768 769 if (sd->cam_type == CAM_TYPE_CIF) { 770 err_code = start_cif_cam(gspca_dev); 771 } else { 772 err_code = start_vga_cam(gspca_dev); 773 } 774 if (err_code < 0) 775 return err_code; 776 777 return isoc_enable(gspca_dev); 778 } 779 780 static void sd_stopN(struct gspca_dev *gspca_dev) 781 { 782 struct sd *sd = (struct sd *) gspca_dev; 783 784 stream_stop(gspca_dev); 785 /* Not all the cams need this, but even if not, probably a good idea */ 786 zero_the_pointer(gspca_dev); 787 if (sd->do_lcd_stop) 788 lcd_stop(gspca_dev); 789 } 790 791 static void setbrightness(struct gspca_dev *gspca_dev, s32 val) 792 { 793 struct sd *sd = (struct sd *) gspca_dev; 794 u8 sign_reg = 7; /* This reg and the next one used on CIF cams. */ 795 u8 value_reg = 8; /* VGA cams seem to use regs 0x0b and 0x0c */ 796 static const u8 quick_clix_table[] = 797 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */ 798 { 0, 4, 8, 12, 1, 2, 3, 5, 6, 9, 7, 10, 13, 11, 14, 15}; 799 if (sd->cam_type == CAM_TYPE_VGA) { 800 sign_reg += 4; 801 value_reg += 4; 802 } 803 804 /* Note register 7 is also seen as 0x8x or 0xCx in some dumps */ 805 if (val > 0) { 806 sensor_write1(gspca_dev, sign_reg, 0x00); 807 } else { 808 sensor_write1(gspca_dev, sign_reg, 0x01); 809 val = 257 - val; 810 } 811 /* Use lookup table for funky Argus QuickClix brightness */ 812 if (sd->do_lcd_stop) 813 val = quick_clix_table[val]; 814 815 sensor_write1(gspca_dev, value_reg, val); 816 } 817 818 static void setexposure(struct gspca_dev *gspca_dev, s32 expo, s32 min_clockdiv) 819 { 820 struct sd *sd = (struct sd *) gspca_dev; 821 int exposure = MR97310A_EXPOSURE_DEFAULT; 822 u8 buf[2]; 823 824 if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1) { 825 /* This cam does not like exposure settings < 300, 826 so scale 0 - 4095 to 300 - 4095 */ 827 exposure = (expo * 9267) / 10000 + 300; 828 sensor_write1(gspca_dev, 3, exposure >> 4); 829 sensor_write1(gspca_dev, 4, exposure & 0x0f); 830 } else if (sd->sensor_type == 2) { 831 exposure = expo; 832 exposure >>= 3; 833 sensor_write1(gspca_dev, 3, exposure >> 8); 834 sensor_write1(gspca_dev, 4, exposure & 0xff); 835 } else { 836 /* We have both a clock divider and an exposure register. 837 We first calculate the clock divider, as that determines 838 the maximum exposure and then we calculate the exposure 839 register setting (which goes from 0 - 511). 840 841 Note our 0 - 4095 exposure is mapped to 0 - 511 842 milliseconds exposure time */ 843 u8 clockdiv = (60 * expo + 7999) / 8000; 844 845 /* Limit framerate to not exceed usb bandwidth */ 846 if (clockdiv < min_clockdiv && gspca_dev->pixfmt.width >= 320) 847 clockdiv = min_clockdiv; 848 else if (clockdiv < 2) 849 clockdiv = 2; 850 851 if (sd->cam_type == CAM_TYPE_VGA && clockdiv < 4) 852 clockdiv = 4; 853 854 /* Frame exposure time in ms = 1000 * clockdiv / 60 -> 855 exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */ 856 exposure = (60 * 511 * expo) / (8000 * clockdiv); 857 if (exposure > 511) 858 exposure = 511; 859 860 /* exposure register value is reversed! */ 861 exposure = 511 - exposure; 862 863 buf[0] = exposure & 0xff; 864 buf[1] = exposure >> 8; 865 sensor_write_reg(gspca_dev, 0x0e, 0, buf, 2); 866 sensor_write1(gspca_dev, 0x02, clockdiv); 867 } 868 } 869 870 static void setgain(struct gspca_dev *gspca_dev, s32 val) 871 { 872 struct sd *sd = (struct sd *) gspca_dev; 873 u8 gainreg; 874 875 if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1) 876 sensor_write1(gspca_dev, 0x0e, val); 877 else if (sd->cam_type == CAM_TYPE_VGA && sd->sensor_type == 2) 878 for (gainreg = 0x0a; gainreg < 0x11; gainreg += 2) { 879 sensor_write1(gspca_dev, gainreg, val >> 8); 880 sensor_write1(gspca_dev, gainreg + 1, val & 0xff); 881 } 882 else 883 sensor_write1(gspca_dev, 0x10, val); 884 } 885 886 static void setcontrast(struct gspca_dev *gspca_dev, s32 val) 887 { 888 sensor_write1(gspca_dev, 0x1c, val); 889 } 890 891 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 892 { 893 struct gspca_dev *gspca_dev = 894 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 895 struct sd *sd = (struct sd *)gspca_dev; 896 897 gspca_dev->usb_err = 0; 898 899 if (!gspca_dev->streaming) 900 return 0; 901 902 switch (ctrl->id) { 903 case V4L2_CID_BRIGHTNESS: 904 setbrightness(gspca_dev, ctrl->val); 905 break; 906 case V4L2_CID_CONTRAST: 907 setcontrast(gspca_dev, ctrl->val); 908 break; 909 case V4L2_CID_EXPOSURE: 910 setexposure(gspca_dev, sd->exposure->val, 911 sd->min_clockdiv ? sd->min_clockdiv->val : 0); 912 break; 913 case V4L2_CID_GAIN: 914 setgain(gspca_dev, ctrl->val); 915 break; 916 } 917 return gspca_dev->usb_err; 918 } 919 920 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 921 .s_ctrl = sd_s_ctrl, 922 }; 923 924 static int sd_init_controls(struct gspca_dev *gspca_dev) 925 { 926 struct sd *sd = (struct sd *)gspca_dev; 927 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 928 static const struct v4l2_ctrl_config clockdiv = { 929 .ops = &sd_ctrl_ops, 930 .id = MR97310A_CID_CLOCKDIV, 931 .type = V4L2_CTRL_TYPE_INTEGER, 932 .name = "Minimum Clock Divider", 933 .min = MR97310A_MIN_CLOCKDIV_MIN, 934 .max = MR97310A_MIN_CLOCKDIV_MAX, 935 .step = 1, 936 .def = MR97310A_MIN_CLOCKDIV_DEFAULT, 937 }; 938 bool has_brightness = false; 939 bool has_argus_brightness = false; 940 bool has_contrast = false; 941 bool has_gain = false; 942 bool has_cs_gain = false; 943 bool has_exposure = false; 944 bool has_clockdiv = false; 945 946 gspca_dev->vdev.ctrl_handler = hdl; 947 v4l2_ctrl_handler_init(hdl, 4); 948 949 /* Setup controls depending on camera type */ 950 if (sd->cam_type == CAM_TYPE_CIF) { 951 /* No brightness for sensor_type 0 */ 952 if (sd->sensor_type == 0) 953 has_exposure = has_gain = has_clockdiv = true; 954 else 955 has_exposure = has_gain = has_brightness = true; 956 } else { 957 /* All controls need to be disabled if VGA sensor_type is 0 */ 958 if (sd->sensor_type == 0) 959 ; /* no controls! */ 960 else if (sd->sensor_type == 2) 961 has_exposure = has_cs_gain = has_contrast = true; 962 else if (sd->do_lcd_stop) 963 has_exposure = has_gain = has_argus_brightness = 964 has_clockdiv = true; 965 else 966 has_exposure = has_gain = has_brightness = 967 has_clockdiv = true; 968 } 969 970 /* Separate brightness control description for Argus QuickClix as it has 971 * different limits from the other mr97310a cameras, and separate gain 972 * control for Sakar CyberPix camera. */ 973 /* 974 * This control is disabled for CIF type 1 and VGA type 0 cameras. 975 * It does not quite act linearly for the Argus QuickClix camera, 976 * but it does control brightness. The values are 0 - 15 only, and 977 * the table above makes them act consecutively. 978 */ 979 if (has_brightness) 980 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 981 V4L2_CID_BRIGHTNESS, -254, 255, 1, 982 MR97310A_BRIGHTNESS_DEFAULT); 983 else if (has_argus_brightness) 984 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 985 V4L2_CID_BRIGHTNESS, 0, 15, 1, 986 MR97310A_BRIGHTNESS_DEFAULT); 987 if (has_contrast) 988 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 989 V4L2_CID_CONTRAST, MR97310A_CONTRAST_MIN, 990 MR97310A_CONTRAST_MAX, 1, MR97310A_CONTRAST_DEFAULT); 991 if (has_gain) 992 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 993 V4L2_CID_GAIN, MR97310A_GAIN_MIN, MR97310A_GAIN_MAX, 994 1, MR97310A_GAIN_DEFAULT); 995 else if (has_cs_gain) 996 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_GAIN, 997 MR97310A_CS_GAIN_MIN, MR97310A_CS_GAIN_MAX, 998 1, MR97310A_CS_GAIN_DEFAULT); 999 if (has_exposure) 1000 sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1001 V4L2_CID_EXPOSURE, MR97310A_EXPOSURE_MIN, 1002 MR97310A_EXPOSURE_MAX, 1, MR97310A_EXPOSURE_DEFAULT); 1003 if (has_clockdiv) 1004 sd->min_clockdiv = v4l2_ctrl_new_custom(hdl, &clockdiv, NULL); 1005 1006 if (hdl->error) { 1007 pr_err("Could not initialize controls\n"); 1008 return hdl->error; 1009 } 1010 if (has_exposure && has_clockdiv) 1011 v4l2_ctrl_cluster(2, &sd->exposure); 1012 return 0; 1013 } 1014 1015 /* Include pac common sof detection functions */ 1016 #include "pac_common.h" 1017 1018 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 1019 u8 *data, /* isoc packet */ 1020 int len) /* iso packet length */ 1021 { 1022 struct sd *sd = (struct sd *) gspca_dev; 1023 unsigned char *sof; 1024 1025 sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len); 1026 if (sof) { 1027 int n; 1028 1029 /* finish decoding current frame */ 1030 n = sof - data; 1031 if (n > sizeof pac_sof_marker) 1032 n -= sizeof pac_sof_marker; 1033 else 1034 n = 0; 1035 gspca_frame_add(gspca_dev, LAST_PACKET, 1036 data, n); 1037 /* Start next frame. */ 1038 gspca_frame_add(gspca_dev, FIRST_PACKET, 1039 pac_sof_marker, sizeof pac_sof_marker); 1040 len -= sof - data; 1041 data = sof; 1042 } 1043 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 1044 } 1045 1046 /* sub-driver description */ 1047 static const struct sd_desc sd_desc = { 1048 .name = MODULE_NAME, 1049 .config = sd_config, 1050 .init = sd_init, 1051 .init_controls = sd_init_controls, 1052 .start = sd_start, 1053 .stopN = sd_stopN, 1054 .pkt_scan = sd_pkt_scan, 1055 }; 1056 1057 /* -- module initialisation -- */ 1058 static const struct usb_device_id device_table[] = { 1059 {USB_DEVICE(0x08ca, 0x0110)}, /* Trust Spyc@m 100 */ 1060 {USB_DEVICE(0x08ca, 0x0111)}, /* Aiptek Pencam VGA+ */ 1061 {USB_DEVICE(0x093a, 0x010f)}, /* All other known MR97310A VGA cams */ 1062 {USB_DEVICE(0x093a, 0x010e)}, /* All known MR97310A CIF cams */ 1063 {} 1064 }; 1065 MODULE_DEVICE_TABLE(usb, device_table); 1066 1067 /* -- device connect -- */ 1068 static int sd_probe(struct usb_interface *intf, 1069 const struct usb_device_id *id) 1070 { 1071 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 1072 THIS_MODULE); 1073 } 1074 1075 static struct usb_driver sd_driver = { 1076 .name = MODULE_NAME, 1077 .id_table = device_table, 1078 .probe = sd_probe, 1079 .disconnect = gspca_disconnect, 1080 #ifdef CONFIG_PM 1081 .suspend = gspca_suspend, 1082 .resume = gspca_resume, 1083 .reset_resume = gspca_resume, 1084 #endif 1085 }; 1086 1087 module_usb_driver(sd_driver); 1088