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