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