1/* 2 * Pixart PAC7311 library 3 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li 4 * 5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22/* Some documentation about various registers as determined by trial and error. 23 When the register addresses differ between the 7202 and the 7311 the 2 24 different addresses are written as 7302addr/7311addr, when one of the 2 25 addresses is a - sign that register description is not valid for the 26 matching IC. 27 28 Register page 1: 29 30 Address Description 31 -/0x08 Unknown compressor related, must always be 8 except when not 32 in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 ! 33 -/0x1b Auto white balance related, bit 0 is AWB enable (inverted) 34 bits 345 seem to toggle per color gains on/off (inverted) 35 0x78 Global control, bit 6 controls the LED (inverted) 36 -/0x80 JPEG compression ratio ? Best not touched 37 38 Register page 3/4: 39 40 Address Description 41 0x02 Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on 42 the 7302, so one of 3, 6, 9, ..., except when between 6 and 12? 43 -/0x0f Master gain 1-245, low value = high gain 44 0x10/- Master gain 0-31 45 -/0x10 Another gain 0-15, limited influence (1-2x gain I guess) 46 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused 47 -/0x27 Seems to toggle various gains on / off, Setting bit 7 seems to 48 completely disable the analog amplification block. Set to 0x68 49 for max gain, 0x14 for minimal gain. 50*/ 51 52#define MODULE_NAME "pac7311" 53 54#include <linux/input.h> 55#include "gspca.h" 56 57MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li"); 58MODULE_DESCRIPTION("Pixart PAC7311"); 59MODULE_LICENSE("GPL"); 60 61/* specific webcam descriptor for pac7311 */ 62struct sd { 63 struct gspca_dev gspca_dev; /* !! must be the first item */ 64 65 unsigned char contrast; 66 unsigned char gain; 67 unsigned char exposure; 68 unsigned char autogain; 69 __u8 hflip; 70 __u8 vflip; 71 72 u8 sof_read; 73 u8 autogain_ignore_frames; 74 75 atomic_t avg_lum; 76}; 77 78/* V4L2 controls supported by the driver */ 79static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val); 80static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val); 81static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val); 82static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val); 83static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val); 84static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val); 85static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val); 86static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val); 87static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val); 88static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val); 89static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val); 90static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val); 91 92static const struct ctrl sd_ctrls[] = { 93/* This control is for both the 7302 and the 7311 */ 94 { 95 { 96 .id = V4L2_CID_CONTRAST, 97 .type = V4L2_CTRL_TYPE_INTEGER, 98 .name = "Contrast", 99 .minimum = 0, 100#define CONTRAST_MAX 255 101 .maximum = CONTRAST_MAX, 102 .step = 1, 103#define CONTRAST_DEF 127 104 .default_value = CONTRAST_DEF, 105 }, 106 .set = sd_setcontrast, 107 .get = sd_getcontrast, 108 }, 109/* All controls below are for both the 7302 and the 7311 */ 110 { 111 { 112 .id = V4L2_CID_GAIN, 113 .type = V4L2_CTRL_TYPE_INTEGER, 114 .name = "Gain", 115 .minimum = 0, 116#define GAIN_MAX 255 117 .maximum = GAIN_MAX, 118 .step = 1, 119#define GAIN_DEF 127 120#define GAIN_KNEE 255 /* Gain seems to cause little noise on the pac73xx */ 121 .default_value = GAIN_DEF, 122 }, 123 .set = sd_setgain, 124 .get = sd_getgain, 125 }, 126 { 127 { 128 .id = V4L2_CID_EXPOSURE, 129 .type = V4L2_CTRL_TYPE_INTEGER, 130 .name = "Exposure", 131 .minimum = 0, 132#define EXPOSURE_MAX 255 133 .maximum = EXPOSURE_MAX, 134 .step = 1, 135#define EXPOSURE_DEF 16 /* 32 ms / 30 fps */ 136#define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */ 137 .default_value = EXPOSURE_DEF, 138 }, 139 .set = sd_setexposure, 140 .get = sd_getexposure, 141 }, 142 { 143 { 144 .id = V4L2_CID_AUTOGAIN, 145 .type = V4L2_CTRL_TYPE_BOOLEAN, 146 .name = "Auto Gain", 147 .minimum = 0, 148 .maximum = 1, 149 .step = 1, 150#define AUTOGAIN_DEF 1 151 .default_value = AUTOGAIN_DEF, 152 }, 153 .set = sd_setautogain, 154 .get = sd_getautogain, 155 }, 156 { 157 { 158 .id = V4L2_CID_HFLIP, 159 .type = V4L2_CTRL_TYPE_BOOLEAN, 160 .name = "Mirror", 161 .minimum = 0, 162 .maximum = 1, 163 .step = 1, 164#define HFLIP_DEF 0 165 .default_value = HFLIP_DEF, 166 }, 167 .set = sd_sethflip, 168 .get = sd_gethflip, 169 }, 170 { 171 { 172 .id = V4L2_CID_VFLIP, 173 .type = V4L2_CTRL_TYPE_BOOLEAN, 174 .name = "Vflip", 175 .minimum = 0, 176 .maximum = 1, 177 .step = 1, 178#define VFLIP_DEF 0 179 .default_value = VFLIP_DEF, 180 }, 181 .set = sd_setvflip, 182 .get = sd_getvflip, 183 }, 184}; 185 186static const struct v4l2_pix_format vga_mode[] = { 187 {160, 120, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 188 .bytesperline = 160, 189 .sizeimage = 160 * 120 * 3 / 8 + 590, 190 .colorspace = V4L2_COLORSPACE_JPEG, 191 .priv = 2}, 192 {320, 240, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 193 .bytesperline = 320, 194 .sizeimage = 320 * 240 * 3 / 8 + 590, 195 .colorspace = V4L2_COLORSPACE_JPEG, 196 .priv = 1}, 197 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 198 .bytesperline = 640, 199 .sizeimage = 640 * 480 * 3 / 8 + 590, 200 .colorspace = V4L2_COLORSPACE_JPEG, 201 .priv = 0}, 202}; 203 204#define LOAD_PAGE4 254 205#define END_OF_SEQUENCE 0 206 207/* pac 7311 */ 208static const __u8 init_7311[] = { 209 0x78, 0x40, /* Bit_0=start stream, Bit_6=LED */ 210 0x78, 0x40, /* Bit_0=start stream, Bit_6=LED */ 211 0x78, 0x44, /* Bit_0=start stream, Bit_6=LED */ 212 0xff, 0x04, 213 0x27, 0x80, 214 0x28, 0xca, 215 0x29, 0x53, 216 0x2a, 0x0e, 217 0xff, 0x01, 218 0x3e, 0x20, 219}; 220 221static const __u8 start_7311[] = { 222/* index, len, [value]* */ 223 0xff, 1, 0x01, /* page 1 */ 224 0x02, 43, 0x48, 0x0a, 0x40, 0x08, 0x00, 0x00, 0x08, 0x00, 225 0x06, 0xff, 0x11, 0xff, 0x5a, 0x30, 0x90, 0x4c, 226 0x00, 0x07, 0x00, 0x0a, 0x10, 0x00, 0xa0, 0x10, 227 0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x00, 228 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 229 0x00, 0x00, 0x00, 230 0x3e, 42, 0x00, 0x00, 0x78, 0x52, 0x4a, 0x52, 0x78, 0x6e, 231 0x48, 0x46, 0x48, 0x6e, 0x5f, 0x49, 0x42, 0x49, 232 0x5f, 0x5f, 0x49, 0x42, 0x49, 0x5f, 0x6e, 0x48, 233 0x46, 0x48, 0x6e, 0x78, 0x52, 0x4a, 0x52, 0x78, 234 0x00, 0x00, 0x09, 0x1b, 0x34, 0x49, 0x5c, 0x9b, 235 0xd0, 0xff, 236 0x78, 6, 0x44, 0x00, 0xf2, 0x01, 0x01, 0x80, 237 0x7f, 18, 0x2a, 0x1c, 0x00, 0xc8, 0x02, 0x58, 0x03, 0x84, 238 0x12, 0x00, 0x1a, 0x04, 0x08, 0x0c, 0x10, 0x14, 239 0x18, 0x20, 240 0x96, 3, 0x01, 0x08, 0x04, 241 0xa0, 4, 0x44, 0x44, 0x44, 0x04, 242 0xf0, 13, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0x00, 243 0x3f, 0x00, 0x0a, 0x01, 0x00, 244 0xff, 1, 0x04, /* page 4 */ 245 0, LOAD_PAGE4, /* load the page 4 */ 246 0x11, 1, 0x01, 247 0, END_OF_SEQUENCE /* end of sequence */ 248}; 249 250#define SKIP 0xaa 251/* page 4 - the value SKIP says skip the index - see reg_w_page() */ 252static const __u8 page4_7311[] = { 253 SKIP, SKIP, 0x04, 0x54, 0x07, 0x2b, 0x09, 0x0f, 254 0x09, 0x00, SKIP, SKIP, 0x07, 0x00, 0x00, 0x62, 255 0x08, SKIP, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 256 0x00, 0x00, 0x00, 0x03, 0xa0, 0x01, 0xf4, SKIP, 257 SKIP, 0x00, 0x08, SKIP, 0x03, SKIP, 0x00, 0x68, 258 0xca, 0x10, 0x06, 0x78, 0x00, 0x00, 0x00, 0x00, 259 0x23, 0x28, 0x04, 0x11, 0x00, 0x00 260}; 261 262static void reg_w_buf(struct gspca_dev *gspca_dev, 263 __u8 index, 264 const char *buffer, int len) 265{ 266 int ret; 267 268 if (gspca_dev->usb_err < 0) 269 return; 270 memcpy(gspca_dev->usb_buf, buffer, len); 271 ret = usb_control_msg(gspca_dev->dev, 272 usb_sndctrlpipe(gspca_dev->dev, 0), 273 0, /* request */ 274 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 275 0, /* value */ 276 index, gspca_dev->usb_buf, len, 277 500); 278 if (ret < 0) { 279 PDEBUG(D_ERR, "reg_w_buf(): " 280 "Failed to write registers to index 0x%x, error %i", 281 index, ret); 282 gspca_dev->usb_err = ret; 283 } 284} 285 286 287static void reg_w(struct gspca_dev *gspca_dev, 288 __u8 index, 289 __u8 value) 290{ 291 int ret; 292 293 if (gspca_dev->usb_err < 0) 294 return; 295 gspca_dev->usb_buf[0] = value; 296 ret = usb_control_msg(gspca_dev->dev, 297 usb_sndctrlpipe(gspca_dev->dev, 0), 298 0, /* request */ 299 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 300 0, index, gspca_dev->usb_buf, 1, 301 500); 302 if (ret < 0) { 303 PDEBUG(D_ERR, "reg_w(): " 304 "Failed to write register to index 0x%x, value 0x%x, error %i", 305 index, value, ret); 306 gspca_dev->usb_err = ret; 307 } 308} 309 310static void reg_w_seq(struct gspca_dev *gspca_dev, 311 const __u8 *seq, int len) 312{ 313 while (--len >= 0) { 314 reg_w(gspca_dev, seq[0], seq[1]); 315 seq += 2; 316 } 317} 318 319/* load the beginning of a page */ 320static void reg_w_page(struct gspca_dev *gspca_dev, 321 const __u8 *page, int len) 322{ 323 int index; 324 int ret = 0; 325 326 if (gspca_dev->usb_err < 0) 327 return; 328 for (index = 0; index < len; index++) { 329 if (page[index] == SKIP) /* skip this index */ 330 continue; 331 gspca_dev->usb_buf[0] = page[index]; 332 ret = usb_control_msg(gspca_dev->dev, 333 usb_sndctrlpipe(gspca_dev->dev, 0), 334 0, /* request */ 335 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 336 0, index, gspca_dev->usb_buf, 1, 337 500); 338 if (ret < 0) { 339 PDEBUG(D_ERR, "reg_w_page(): " 340 "Failed to write register to index 0x%x, " 341 "value 0x%x, error %i", 342 index, page[index], ret); 343 gspca_dev->usb_err = ret; 344 break; 345 } 346 } 347} 348 349/* output a variable sequence */ 350static void reg_w_var(struct gspca_dev *gspca_dev, 351 const __u8 *seq, 352 const __u8 *page4, unsigned int page4_len) 353{ 354 int index, len; 355 356 for (;;) { 357 index = *seq++; 358 len = *seq++; 359 switch (len) { 360 case END_OF_SEQUENCE: 361 return; 362 case LOAD_PAGE4: 363 reg_w_page(gspca_dev, page4, page4_len); 364 break; 365 default: 366 if (len > USB_BUF_SZ) { 367 PDEBUG(D_ERR|D_STREAM, 368 "Incorrect variable sequence"); 369 return; 370 } 371 while (len > 0) { 372 if (len < 8) { 373 reg_w_buf(gspca_dev, 374 index, seq, len); 375 seq += len; 376 break; 377 } 378 reg_w_buf(gspca_dev, index, seq, 8); 379 seq += 8; 380 index += 8; 381 len -= 8; 382 } 383 } 384 } 385 /* not reached */ 386} 387 388/* this function is called at probe time for pac7311 */ 389static int sd_config(struct gspca_dev *gspca_dev, 390 const struct usb_device_id *id) 391{ 392 struct sd *sd = (struct sd *) gspca_dev; 393 struct cam *cam; 394 395 cam = &gspca_dev->cam; 396 397 PDEBUG(D_CONF, "Find Sensor PAC7311"); 398 cam->cam_mode = vga_mode; 399 cam->nmodes = ARRAY_SIZE(vga_mode); 400 401 sd->contrast = CONTRAST_DEF; 402 sd->gain = GAIN_DEF; 403 sd->exposure = EXPOSURE_DEF; 404 sd->autogain = AUTOGAIN_DEF; 405 sd->hflip = HFLIP_DEF; 406 sd->vflip = VFLIP_DEF; 407 return 0; 408} 409 410/* This function is used by pac7311 only */ 411static void setcontrast(struct gspca_dev *gspca_dev) 412{ 413 struct sd *sd = (struct sd *) gspca_dev; 414 415 reg_w(gspca_dev, 0xff, 0x04); 416 reg_w(gspca_dev, 0x10, sd->contrast >> 4); 417 /* load registers to sensor (Bit 0, auto clear) */ 418 reg_w(gspca_dev, 0x11, 0x01); 419} 420 421static void setgain(struct gspca_dev *gspca_dev) 422{ 423 struct sd *sd = (struct sd *) gspca_dev; 424 int gain = GAIN_MAX - sd->gain; 425 426 if (gain < 1) 427 gain = 1; 428 else if (gain > 245) 429 gain = 245; 430 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */ 431 reg_w(gspca_dev, 0x0e, 0x00); 432 reg_w(gspca_dev, 0x0f, gain); 433 434 /* load registers to sensor (Bit 0, auto clear) */ 435 reg_w(gspca_dev, 0x11, 0x01); 436} 437 438static void setexposure(struct gspca_dev *gspca_dev) 439{ 440 struct sd *sd = (struct sd *) gspca_dev; 441 __u8 reg; 442 443 /* register 2 of frame 3/4 contains the clock divider configuring the 444 no fps according to the formula: 60 / reg. sd->exposure is the 445 desired exposure time in ms. */ 446 reg = 120 * sd->exposure / 1000; 447 if (reg < 2) 448 reg = 2; 449 else if (reg > 63) 450 reg = 63; 451 452 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */ 453 reg_w(gspca_dev, 0x02, reg); 454 455 /* Page 1 register 8 must always be 0x08 except when not in 456 640x480 mode and Page3/4 reg 2 <= 3 then it must be 9 */ 457 reg_w(gspca_dev, 0xff, 0x01); 458 if (gspca_dev->cam.cam_mode[(int)gspca_dev->curr_mode].priv && 459 reg <= 3) { 460 reg_w(gspca_dev, 0x08, 0x09); 461 } else { 462 reg_w(gspca_dev, 0x08, 0x08); 463 } 464 465 /* load registers to sensor (Bit 0, auto clear) */ 466 reg_w(gspca_dev, 0x11, 0x01); 467} 468 469static void sethvflip(struct gspca_dev *gspca_dev) 470{ 471 struct sd *sd = (struct sd *) gspca_dev; 472 __u8 data; 473 474 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */ 475 data = (sd->hflip ? 0x04 : 0x00) | (sd->vflip ? 0x08 : 0x00); 476 reg_w(gspca_dev, 0x21, data); 477 478 /* load registers to sensor (Bit 0, auto clear) */ 479 reg_w(gspca_dev, 0x11, 0x01); 480} 481 482/* this function is called at probe and resume time for pac7311 */ 483static int sd_init(struct gspca_dev *gspca_dev) 484{ 485 reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2); 486 return gspca_dev->usb_err; 487} 488 489static int sd_start(struct gspca_dev *gspca_dev) 490{ 491 struct sd *sd = (struct sd *) gspca_dev; 492 493 sd->sof_read = 0; 494 495 reg_w_var(gspca_dev, start_7311, 496 page4_7311, sizeof(page4_7311)); 497 setcontrast(gspca_dev); 498 setgain(gspca_dev); 499 setexposure(gspca_dev); 500 sethvflip(gspca_dev); 501 502 /* set correct resolution */ 503 switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { 504 case 2: /* 160x120 pac7311 */ 505 reg_w(gspca_dev, 0xff, 0x01); 506 reg_w(gspca_dev, 0x17, 0x20); 507 reg_w(gspca_dev, 0x87, 0x10); 508 break; 509 case 1: /* 320x240 pac7311 */ 510 reg_w(gspca_dev, 0xff, 0x01); 511 reg_w(gspca_dev, 0x17, 0x30); 512 reg_w(gspca_dev, 0x87, 0x11); 513 break; 514 case 0: /* 640x480 */ 515 reg_w(gspca_dev, 0xff, 0x01); 516 reg_w(gspca_dev, 0x17, 0x00); 517 reg_w(gspca_dev, 0x87, 0x12); 518 break; 519 } 520 521 sd->sof_read = 0; 522 sd->autogain_ignore_frames = 0; 523 atomic_set(&sd->avg_lum, -1); 524 525 /* start stream */ 526 reg_w(gspca_dev, 0xff, 0x01); 527 reg_w(gspca_dev, 0x78, 0x05); 528 529 return gspca_dev->usb_err; 530} 531 532static void sd_stopN(struct gspca_dev *gspca_dev) 533{ 534 reg_w(gspca_dev, 0xff, 0x04); 535 reg_w(gspca_dev, 0x27, 0x80); 536 reg_w(gspca_dev, 0x28, 0xca); 537 reg_w(gspca_dev, 0x29, 0x53); 538 reg_w(gspca_dev, 0x2a, 0x0e); 539 reg_w(gspca_dev, 0xff, 0x01); 540 reg_w(gspca_dev, 0x3e, 0x20); 541 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */ 542 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */ 543 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */ 544} 545 546/* called on streamoff with alt 0 and on disconnect for 7311 */ 547static void sd_stop0(struct gspca_dev *gspca_dev) 548{ 549} 550 551/* Include pac common sof detection functions */ 552#include "pac_common.h" 553 554static void do_autogain(struct gspca_dev *gspca_dev) 555{ 556 struct sd *sd = (struct sd *) gspca_dev; 557 int avg_lum = atomic_read(&sd->avg_lum); 558 int desired_lum, deadzone; 559 560 if (avg_lum == -1) 561 return; 562 563 desired_lum = 200; 564 deadzone = 20; 565 566 if (sd->autogain_ignore_frames > 0) 567 sd->autogain_ignore_frames--; 568 else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum, desired_lum, 569 deadzone, GAIN_KNEE, EXPOSURE_KNEE)) 570 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES; 571} 572 573/* JPEG header, part 1 */ 574static const unsigned char pac_jpeg_header1[] = { 575 0xff, 0xd8, /* SOI: Start of Image */ 576 577 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */ 578 0x00, 0x11, /* length = 17 bytes (including this length field) */ 579 0x08 /* Precision: 8 */ 580 /* 2 bytes is placed here: number of image lines */ 581 /* 2 bytes is placed here: samples per line */ 582}; 583 584/* JPEG header, continued */ 585static const unsigned char pac_jpeg_header2[] = { 586 0x03, /* Number of image components: 3 */ 587 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */ 588 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */ 589 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */ 590 591 0xff, 0xda, /* SOS: Start Of Scan */ 592 0x00, 0x0c, /* length = 12 bytes (including this length field) */ 593 0x03, /* number of components: 3 */ 594 0x01, 0x00, /* selector 1, table 0x00 */ 595 0x02, 0x11, /* selector 2, table 0x11 */ 596 0x03, 0x11, /* selector 3, table 0x11 */ 597 0x00, 0x3f, /* Spectral selection: 0 .. 63 */ 598 0x00 /* Successive approximation: 0 */ 599}; 600 601static void pac_start_frame(struct gspca_dev *gspca_dev, 602 __u16 lines, __u16 samples_per_line) 603{ 604 unsigned char tmpbuf[4]; 605 606 gspca_frame_add(gspca_dev, FIRST_PACKET, 607 pac_jpeg_header1, sizeof(pac_jpeg_header1)); 608 609 tmpbuf[0] = lines >> 8; 610 tmpbuf[1] = lines & 0xff; 611 tmpbuf[2] = samples_per_line >> 8; 612 tmpbuf[3] = samples_per_line & 0xff; 613 614 gspca_frame_add(gspca_dev, INTER_PACKET, 615 tmpbuf, sizeof(tmpbuf)); 616 gspca_frame_add(gspca_dev, INTER_PACKET, 617 pac_jpeg_header2, sizeof(pac_jpeg_header2)); 618} 619 620/* this function is run at interrupt level */ 621static void sd_pkt_scan(struct gspca_dev *gspca_dev, 622 u8 *data, /* isoc packet */ 623 int len) /* iso packet length */ 624{ 625 struct sd *sd = (struct sd *) gspca_dev; 626 u8 *image; 627 unsigned char *sof; 628 629 sof = pac_find_sof(&sd->sof_read, data, len); 630 if (sof) { 631 int n, lum_offset, footer_length; 632 633 /* 6 bytes after the FF D9 EOF marker a number of lumination 634 bytes are send corresponding to different parts of the 635 image, the 14th and 15th byte after the EOF seem to 636 correspond to the center of the image */ 637 lum_offset = 24 + sizeof pac_sof_marker; 638 footer_length = 26; 639 640 /* Finish decoding current frame */ 641 n = (sof - data) - (footer_length + sizeof pac_sof_marker); 642 if (n < 0) { 643 gspca_dev->image_len += n; 644 n = 0; 645 } else { 646 gspca_frame_add(gspca_dev, INTER_PACKET, data, n); 647 } 648 image = gspca_dev->image; 649 if (image != NULL 650 && image[gspca_dev->image_len - 2] == 0xff 651 && image[gspca_dev->image_len - 1] == 0xd9) 652 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 653 654 n = sof - data; 655 len -= n; 656 data = sof; 657 658 /* Get average lumination */ 659 if (gspca_dev->last_packet_type == LAST_PACKET && 660 n >= lum_offset) 661 atomic_set(&sd->avg_lum, data[-lum_offset] + 662 data[-lum_offset + 1]); 663 else 664 atomic_set(&sd->avg_lum, -1); 665 666 /* Start the new frame with the jpeg header */ 667 pac_start_frame(gspca_dev, 668 gspca_dev->height, gspca_dev->width); 669 } 670 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 671} 672 673static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val) 674{ 675 struct sd *sd = (struct sd *) gspca_dev; 676 677 sd->contrast = val; 678 if (gspca_dev->streaming) { 679 setcontrast(gspca_dev); 680 } 681 return gspca_dev->usb_err; 682} 683 684static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val) 685{ 686 struct sd *sd = (struct sd *) gspca_dev; 687 688 *val = sd->contrast; 689 return 0; 690} 691 692static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val) 693{ 694 struct sd *sd = (struct sd *) gspca_dev; 695 696 sd->gain = val; 697 if (gspca_dev->streaming) 698 setgain(gspca_dev); 699 return gspca_dev->usb_err; 700} 701 702static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val) 703{ 704 struct sd *sd = (struct sd *) gspca_dev; 705 706 *val = sd->gain; 707 return 0; 708} 709 710static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val) 711{ 712 struct sd *sd = (struct sd *) gspca_dev; 713 714 sd->exposure = val; 715 if (gspca_dev->streaming) 716 setexposure(gspca_dev); 717 return gspca_dev->usb_err; 718} 719 720static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val) 721{ 722 struct sd *sd = (struct sd *) gspca_dev; 723 724 *val = sd->exposure; 725 return 0; 726} 727 728static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val) 729{ 730 struct sd *sd = (struct sd *) gspca_dev; 731 732 sd->autogain = val; 733 /* when switching to autogain set defaults to make sure 734 we are on a valid point of the autogain gain / 735 exposure knee graph, and give this change time to 736 take effect before doing autogain. */ 737 if (sd->autogain) { 738 sd->exposure = EXPOSURE_DEF; 739 sd->gain = GAIN_DEF; 740 if (gspca_dev->streaming) { 741 sd->autogain_ignore_frames = 742 PAC_AUTOGAIN_IGNORE_FRAMES; 743 setexposure(gspca_dev); 744 setgain(gspca_dev); 745 } 746 } 747 748 return gspca_dev->usb_err; 749} 750 751static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val) 752{ 753 struct sd *sd = (struct sd *) gspca_dev; 754 755 *val = sd->autogain; 756 return 0; 757} 758 759static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val) 760{ 761 struct sd *sd = (struct sd *) gspca_dev; 762 763 sd->hflip = val; 764 if (gspca_dev->streaming) 765 sethvflip(gspca_dev); 766 return gspca_dev->usb_err; 767} 768 769static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val) 770{ 771 struct sd *sd = (struct sd *) gspca_dev; 772 773 *val = sd->hflip; 774 return 0; 775} 776 777static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val) 778{ 779 struct sd *sd = (struct sd *) gspca_dev; 780 781 sd->vflip = val; 782 if (gspca_dev->streaming) 783 sethvflip(gspca_dev); 784 return gspca_dev->usb_err; 785} 786 787static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val) 788{ 789 struct sd *sd = (struct sd *) gspca_dev; 790 791 *val = sd->vflip; 792 return 0; 793} 794 795#ifdef CONFIG_INPUT 796static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, 797 u8 *data, /* interrupt packet data */ 798 int len) /* interrupt packet length */ 799{ 800 int ret = -EINVAL; 801 u8 data0, data1; 802 803 if (len == 2) { 804 data0 = data[0]; 805 data1 = data[1]; 806 if ((data0 == 0x00 && data1 == 0x11) || 807 (data0 == 0x22 && data1 == 0x33) || 808 (data0 == 0x44 && data1 == 0x55) || 809 (data0 == 0x66 && data1 == 0x77) || 810 (data0 == 0x88 && data1 == 0x99) || 811 (data0 == 0xaa && data1 == 0xbb) || 812 (data0 == 0xcc && data1 == 0xdd) || 813 (data0 == 0xee && data1 == 0xff)) { 814 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 815 input_sync(gspca_dev->input_dev); 816 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 817 input_sync(gspca_dev->input_dev); 818 ret = 0; 819 } 820 } 821 822 return ret; 823} 824#endif 825 826/* sub-driver description for pac7311 */ 827static const struct sd_desc sd_desc = { 828 .name = MODULE_NAME, 829 .ctrls = sd_ctrls, 830 .nctrls = ARRAY_SIZE(sd_ctrls), 831 .config = sd_config, 832 .init = sd_init, 833 .start = sd_start, 834 .stopN = sd_stopN, 835 .stop0 = sd_stop0, 836 .pkt_scan = sd_pkt_scan, 837 .dq_callback = do_autogain, 838#ifdef CONFIG_INPUT 839 .int_pkt_scan = sd_int_pkt_scan, 840#endif 841}; 842 843/* -- module initialisation -- */ 844static const struct usb_device_id device_table[] __devinitconst = { 845 {USB_DEVICE(0x093a, 0x2600)}, 846 {USB_DEVICE(0x093a, 0x2601)}, 847 {USB_DEVICE(0x093a, 0x2603)}, 848 {USB_DEVICE(0x093a, 0x2608)}, 849 {USB_DEVICE(0x093a, 0x260e)}, 850 {USB_DEVICE(0x093a, 0x260f)}, 851 {} 852}; 853MODULE_DEVICE_TABLE(usb, device_table); 854 855/* -- device connect -- */ 856static int __devinit sd_probe(struct usb_interface *intf, 857 const struct usb_device_id *id) 858{ 859 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 860 THIS_MODULE); 861} 862 863static struct usb_driver sd_driver = { 864 .name = MODULE_NAME, 865 .id_table = device_table, 866 .probe = sd_probe, 867 .disconnect = gspca_disconnect, 868#ifdef CONFIG_PM 869 .suspend = gspca_suspend, 870 .resume = gspca_resume, 871#endif 872}; 873 874/* -- module insert / remove -- */ 875static int __init sd_mod_init(void) 876{ 877 int ret; 878 ret = usb_register(&sd_driver); 879 if (ret < 0) 880 return ret; 881 PDEBUG(D_PROBE, "registered"); 882 return 0; 883} 884static void __exit sd_mod_exit(void) 885{ 886 usb_deregister(&sd_driver); 887 PDEBUG(D_PROBE, "deregistered"); 888} 889 890module_init(sd_mod_init); 891module_exit(sd_mod_exit); 892