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