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 * 24 * Register page 1: 25 * 26 * Address Description 27 * 0x08 Unknown compressor related, must always be 8 except when not 28 * in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 ! 29 * 0x1b Auto white balance related, bit 0 is AWB enable (inverted) 30 * bits 345 seem to toggle per color gains on/off (inverted) 31 * 0x78 Global control, bit 6 controls the LED (inverted) 32 * 0x80 Compression balance, interesting settings: 33 * 0x01 Use this to allow the camera to switch to higher compr. 34 * on the fly. Needed to stay within bandwidth @ 640x480@30 35 * 0x1c From usb captures under Windows for 640x480 36 * 0x2a Values >= this switch the camera to a lower compression, 37 * using the same table for both luminance and chrominance. 38 * This gives a sharper picture. Usable only at 640x480@ < 39 * 15 fps or 320x240 / 160x120. Note currently the driver 40 * does not use this as the quality gain is small and the 41 * generated JPG-s are only understood by v4l-utils >= 0.8.9 42 * 0x3f From usb captures under Windows for 320x240 43 * 0x69 From usb captures under Windows for 160x120 44 * 45 * Register page 4: 46 * 47 * Address Description 48 * 0x02 Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on 49 * the 7302, so one of 3, 6, 9, ..., except when between 6 and 12? 50 * 0x0f Master gain 1-245, low value = high gain 51 * 0x10 Another gain 0-15, limited influence (1-2x gain I guess) 52 * 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused 53 * Note setting vflip disabled leads to a much lower image quality, 54 * so we always vflip, and tell userspace to flip it back 55 * 0x27 Seems to toggle various gains on / off, Setting bit 7 seems to 56 * completely disable the analog amplification block. Set to 0x68 57 * for max gain, 0x14 for minimal gain. 58 */ 59 60 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 61 62 #define MODULE_NAME "pac7311" 63 64 #include <linux/input.h> 65 #include "gspca.h" 66 /* Include pac common sof detection functions */ 67 #include "pac_common.h" 68 69 #define PAC7311_GAIN_DEFAULT 122 70 #define PAC7311_EXPOSURE_DEFAULT 3 /* 20 fps, avoid using high compr. */ 71 72 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li"); 73 MODULE_DESCRIPTION("Pixart PAC7311"); 74 MODULE_LICENSE("GPL"); 75 76 struct sd { 77 struct gspca_dev gspca_dev; /* !! must be the first item */ 78 79 struct v4l2_ctrl *contrast; 80 struct v4l2_ctrl *hflip; 81 82 u8 sof_read; 83 u8 autogain_ignore_frames; 84 85 atomic_t avg_lum; 86 }; 87 88 static const struct v4l2_pix_format vga_mode[] = { 89 {160, 120, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 90 .bytesperline = 160, 91 .sizeimage = 160 * 120 * 3 / 8 + 590, 92 .colorspace = V4L2_COLORSPACE_JPEG, 93 .priv = 2}, 94 {320, 240, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 95 .bytesperline = 320, 96 .sizeimage = 320 * 240 * 3 / 8 + 590, 97 .colorspace = V4L2_COLORSPACE_JPEG, 98 .priv = 1}, 99 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 100 .bytesperline = 640, 101 .sizeimage = 640 * 480 * 3 / 8 + 590, 102 .colorspace = V4L2_COLORSPACE_JPEG, 103 .priv = 0}, 104 }; 105 106 #define LOAD_PAGE4 254 107 #define END_OF_SEQUENCE 0 108 109 static const __u8 init_7311[] = { 110 0xff, 0x01, 111 0x78, 0x40, /* Bit_0=start stream, Bit_6=LED */ 112 0x78, 0x40, /* Bit_0=start stream, Bit_6=LED */ 113 0x78, 0x44, /* Bit_0=start stream, Bit_6=LED */ 114 0xff, 0x04, 115 0x27, 0x80, 116 0x28, 0xca, 117 0x29, 0x53, 118 0x2a, 0x0e, 119 0xff, 0x01, 120 0x3e, 0x20, 121 }; 122 123 static const __u8 start_7311[] = { 124 /* index, len, [value]* */ 125 0xff, 1, 0x01, /* page 1 */ 126 0x02, 43, 0x48, 0x0a, 0x40, 0x08, 0x00, 0x00, 0x08, 0x00, 127 0x06, 0xff, 0x11, 0xff, 0x5a, 0x30, 0x90, 0x4c, 128 0x00, 0x07, 0x00, 0x0a, 0x10, 0x00, 0xa0, 0x10, 129 0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x00, 130 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 131 0x00, 0x00, 0x00, 132 0x3e, 42, 0x00, 0x00, 0x78, 0x52, 0x4a, 0x52, 0x78, 0x6e, 133 0x48, 0x46, 0x48, 0x6e, 0x5f, 0x49, 0x42, 0x49, 134 0x5f, 0x5f, 0x49, 0x42, 0x49, 0x5f, 0x6e, 0x48, 135 0x46, 0x48, 0x6e, 0x78, 0x52, 0x4a, 0x52, 0x78, 136 0x00, 0x00, 0x09, 0x1b, 0x34, 0x49, 0x5c, 0x9b, 137 0xd0, 0xff, 138 0x78, 6, 0x44, 0x00, 0xf2, 0x01, 0x01, 0x80, 139 0x7f, 18, 0x2a, 0x1c, 0x00, 0xc8, 0x02, 0x58, 0x03, 0x84, 140 0x12, 0x00, 0x1a, 0x04, 0x08, 0x0c, 0x10, 0x14, 141 0x18, 0x20, 142 0x96, 3, 0x01, 0x08, 0x04, 143 0xa0, 4, 0x44, 0x44, 0x44, 0x04, 144 0xf0, 13, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0x00, 145 0x3f, 0x00, 0x0a, 0x01, 0x00, 146 0xff, 1, 0x04, /* page 4 */ 147 0, LOAD_PAGE4, /* load the page 4 */ 148 0x11, 1, 0x01, 149 0, END_OF_SEQUENCE /* end of sequence */ 150 }; 151 152 #define SKIP 0xaa 153 /* page 4 - the value SKIP says skip the index - see reg_w_page() */ 154 static const __u8 page4_7311[] = { 155 SKIP, SKIP, 0x04, 0x54, 0x07, 0x2b, 0x09, 0x0f, 156 0x09, 0x00, SKIP, SKIP, 0x07, 0x00, 0x00, 0x62, 157 0x08, SKIP, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 158 0x00, 0x00, 0x00, 0x03, 0xa0, 0x01, 0xf4, SKIP, 159 SKIP, 0x00, 0x08, SKIP, 0x03, SKIP, 0x00, 0x68, 160 0xca, 0x10, 0x06, 0x78, 0x00, 0x00, 0x00, 0x00, 161 0x23, 0x28, 0x04, 0x11, 0x00, 0x00 162 }; 163 164 static void reg_w_buf(struct gspca_dev *gspca_dev, 165 __u8 index, 166 const u8 *buffer, int len) 167 { 168 int ret; 169 170 if (gspca_dev->usb_err < 0) 171 return; 172 memcpy(gspca_dev->usb_buf, buffer, len); 173 ret = usb_control_msg(gspca_dev->dev, 174 usb_sndctrlpipe(gspca_dev->dev, 0), 175 0, /* request */ 176 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 177 0, /* value */ 178 index, gspca_dev->usb_buf, len, 179 500); 180 if (ret < 0) { 181 pr_err("reg_w_buf() failed index 0x%02x, error %d\n", 182 index, ret); 183 gspca_dev->usb_err = ret; 184 } 185 } 186 187 188 static void reg_w(struct gspca_dev *gspca_dev, 189 __u8 index, 190 __u8 value) 191 { 192 int ret; 193 194 if (gspca_dev->usb_err < 0) 195 return; 196 gspca_dev->usb_buf[0] = value; 197 ret = usb_control_msg(gspca_dev->dev, 198 usb_sndctrlpipe(gspca_dev->dev, 0), 199 0, /* request */ 200 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 201 0, index, gspca_dev->usb_buf, 1, 202 500); 203 if (ret < 0) { 204 pr_err("reg_w() failed index 0x%02x, value 0x%02x, error %d\n", 205 index, value, ret); 206 gspca_dev->usb_err = ret; 207 } 208 } 209 210 static void reg_w_seq(struct gspca_dev *gspca_dev, 211 const __u8 *seq, int len) 212 { 213 while (--len >= 0) { 214 reg_w(gspca_dev, seq[0], seq[1]); 215 seq += 2; 216 } 217 } 218 219 /* load the beginning of a page */ 220 static void reg_w_page(struct gspca_dev *gspca_dev, 221 const __u8 *page, int len) 222 { 223 int index; 224 int ret = 0; 225 226 if (gspca_dev->usb_err < 0) 227 return; 228 for (index = 0; index < len; index++) { 229 if (page[index] == SKIP) /* skip this index */ 230 continue; 231 gspca_dev->usb_buf[0] = page[index]; 232 ret = usb_control_msg(gspca_dev->dev, 233 usb_sndctrlpipe(gspca_dev->dev, 0), 234 0, /* request */ 235 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 236 0, index, gspca_dev->usb_buf, 1, 237 500); 238 if (ret < 0) { 239 pr_err("reg_w_page() failed index 0x%02x, value 0x%02x, error %d\n", 240 index, page[index], ret); 241 gspca_dev->usb_err = ret; 242 break; 243 } 244 } 245 } 246 247 /* output a variable sequence */ 248 static void reg_w_var(struct gspca_dev *gspca_dev, 249 const __u8 *seq, 250 const __u8 *page4, unsigned int page4_len) 251 { 252 int index, len; 253 254 for (;;) { 255 index = *seq++; 256 len = *seq++; 257 switch (len) { 258 case END_OF_SEQUENCE: 259 return; 260 case LOAD_PAGE4: 261 reg_w_page(gspca_dev, page4, page4_len); 262 break; 263 default: 264 if (len > USB_BUF_SZ) { 265 PERR("Incorrect variable sequence"); 266 return; 267 } 268 while (len > 0) { 269 if (len < 8) { 270 reg_w_buf(gspca_dev, 271 index, seq, len); 272 seq += len; 273 break; 274 } 275 reg_w_buf(gspca_dev, index, seq, 8); 276 seq += 8; 277 index += 8; 278 len -= 8; 279 } 280 } 281 } 282 /* not reached */ 283 } 284 285 /* this function is called at probe time for pac7311 */ 286 static int sd_config(struct gspca_dev *gspca_dev, 287 const struct usb_device_id *id) 288 { 289 struct cam *cam = &gspca_dev->cam; 290 291 cam->cam_mode = vga_mode; 292 cam->nmodes = ARRAY_SIZE(vga_mode); 293 cam->input_flags = V4L2_IN_ST_VFLIP; 294 295 return 0; 296 } 297 298 static void setcontrast(struct gspca_dev *gspca_dev, s32 val) 299 { 300 reg_w(gspca_dev, 0xff, 0x04); 301 reg_w(gspca_dev, 0x10, val); 302 /* load registers to sensor (Bit 0, auto clear) */ 303 reg_w(gspca_dev, 0x11, 0x01); 304 } 305 306 static void setgain(struct gspca_dev *gspca_dev, s32 val) 307 { 308 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */ 309 reg_w(gspca_dev, 0x0e, 0x00); 310 reg_w(gspca_dev, 0x0f, gspca_dev->gain->maximum - val + 1); 311 312 /* load registers to sensor (Bit 0, auto clear) */ 313 reg_w(gspca_dev, 0x11, 0x01); 314 } 315 316 static void setexposure(struct gspca_dev *gspca_dev, s32 val) 317 { 318 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */ 319 reg_w(gspca_dev, 0x02, val); 320 321 /* load registers to sensor (Bit 0, auto clear) */ 322 reg_w(gspca_dev, 0x11, 0x01); 323 324 /* 325 * Page 1 register 8 must always be 0x08 except when not in 326 * 640x480 mode and page 4 reg 2 <= 3 then it must be 9 327 */ 328 reg_w(gspca_dev, 0xff, 0x01); 329 if (gspca_dev->pixfmt.width != 640 && val <= 3) 330 reg_w(gspca_dev, 0x08, 0x09); 331 else 332 reg_w(gspca_dev, 0x08, 0x08); 333 334 /* 335 * Page1 register 80 sets the compression balance, normally we 336 * want / use 0x1c, but for 640x480@30fps we must allow the 337 * camera to use higher compression or we may run out of 338 * bandwidth. 339 */ 340 if (gspca_dev->pixfmt.width == 640 && val == 2) 341 reg_w(gspca_dev, 0x80, 0x01); 342 else 343 reg_w(gspca_dev, 0x80, 0x1c); 344 345 /* load registers to sensor (Bit 0, auto clear) */ 346 reg_w(gspca_dev, 0x11, 0x01); 347 } 348 349 static void sethvflip(struct gspca_dev *gspca_dev, s32 hflip, s32 vflip) 350 { 351 __u8 data; 352 353 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */ 354 data = (hflip ? 0x04 : 0x00) | 355 (vflip ? 0x08 : 0x00); 356 reg_w(gspca_dev, 0x21, data); 357 358 /* load registers to sensor (Bit 0, auto clear) */ 359 reg_w(gspca_dev, 0x11, 0x01); 360 } 361 362 /* this function is called at probe and resume time for pac7311 */ 363 static int sd_init(struct gspca_dev *gspca_dev) 364 { 365 reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2); 366 return gspca_dev->usb_err; 367 } 368 369 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 370 { 371 struct gspca_dev *gspca_dev = 372 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 373 struct sd *sd = (struct sd *)gspca_dev; 374 375 gspca_dev->usb_err = 0; 376 377 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) { 378 /* when switching to autogain set defaults to make sure 379 we are on a valid point of the autogain gain / 380 exposure knee graph, and give this change time to 381 take effect before doing autogain. */ 382 gspca_dev->exposure->val = PAC7311_EXPOSURE_DEFAULT; 383 gspca_dev->gain->val = PAC7311_GAIN_DEFAULT; 384 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES; 385 } 386 387 if (!gspca_dev->streaming) 388 return 0; 389 390 switch (ctrl->id) { 391 case V4L2_CID_CONTRAST: 392 setcontrast(gspca_dev, ctrl->val); 393 break; 394 case V4L2_CID_AUTOGAIN: 395 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val)) 396 setexposure(gspca_dev, gspca_dev->exposure->val); 397 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val)) 398 setgain(gspca_dev, gspca_dev->gain->val); 399 break; 400 case V4L2_CID_HFLIP: 401 sethvflip(gspca_dev, sd->hflip->val, 1); 402 break; 403 default: 404 return -EINVAL; 405 } 406 return gspca_dev->usb_err; 407 } 408 409 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 410 .s_ctrl = sd_s_ctrl, 411 }; 412 413 /* this function is called at probe time */ 414 static int sd_init_controls(struct gspca_dev *gspca_dev) 415 { 416 struct sd *sd = (struct sd *) gspca_dev; 417 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 418 419 gspca_dev->vdev.ctrl_handler = hdl; 420 v4l2_ctrl_handler_init(hdl, 5); 421 422 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 423 V4L2_CID_CONTRAST, 0, 15, 1, 7); 424 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 425 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 426 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 427 V4L2_CID_EXPOSURE, 2, 63, 1, 428 PAC7311_EXPOSURE_DEFAULT); 429 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 430 V4L2_CID_GAIN, 0, 244, 1, 431 PAC7311_GAIN_DEFAULT); 432 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 433 V4L2_CID_HFLIP, 0, 1, 1, 0); 434 435 if (hdl->error) { 436 pr_err("Could not initialize controls\n"); 437 return hdl->error; 438 } 439 440 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false); 441 return 0; 442 } 443 444 /* -- start the camera -- */ 445 static int sd_start(struct gspca_dev *gspca_dev) 446 { 447 struct sd *sd = (struct sd *) gspca_dev; 448 449 sd->sof_read = 0; 450 451 reg_w_var(gspca_dev, start_7311, 452 page4_7311, sizeof(page4_7311)); 453 setcontrast(gspca_dev, v4l2_ctrl_g_ctrl(sd->contrast)); 454 setgain(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->gain)); 455 setexposure(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->exposure)); 456 sethvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip), 1); 457 458 /* set correct resolution */ 459 switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) { 460 case 2: /* 160x120 */ 461 reg_w(gspca_dev, 0xff, 0x01); 462 reg_w(gspca_dev, 0x17, 0x20); 463 reg_w(gspca_dev, 0x87, 0x10); 464 break; 465 case 1: /* 320x240 */ 466 reg_w(gspca_dev, 0xff, 0x01); 467 reg_w(gspca_dev, 0x17, 0x30); 468 reg_w(gspca_dev, 0x87, 0x11); 469 break; 470 case 0: /* 640x480 */ 471 reg_w(gspca_dev, 0xff, 0x01); 472 reg_w(gspca_dev, 0x17, 0x00); 473 reg_w(gspca_dev, 0x87, 0x12); 474 break; 475 } 476 477 sd->sof_read = 0; 478 sd->autogain_ignore_frames = 0; 479 atomic_set(&sd->avg_lum, -1); 480 481 /* start stream */ 482 reg_w(gspca_dev, 0xff, 0x01); 483 reg_w(gspca_dev, 0x78, 0x05); 484 485 return gspca_dev->usb_err; 486 } 487 488 static void sd_stopN(struct gspca_dev *gspca_dev) 489 { 490 reg_w(gspca_dev, 0xff, 0x04); 491 reg_w(gspca_dev, 0x27, 0x80); 492 reg_w(gspca_dev, 0x28, 0xca); 493 reg_w(gspca_dev, 0x29, 0x53); 494 reg_w(gspca_dev, 0x2a, 0x0e); 495 reg_w(gspca_dev, 0xff, 0x01); 496 reg_w(gspca_dev, 0x3e, 0x20); 497 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */ 498 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */ 499 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */ 500 } 501 502 static void do_autogain(struct gspca_dev *gspca_dev) 503 { 504 struct sd *sd = (struct sd *) gspca_dev; 505 int avg_lum = atomic_read(&sd->avg_lum); 506 int desired_lum, deadzone; 507 508 if (avg_lum == -1) 509 return; 510 511 desired_lum = 170; 512 deadzone = 20; 513 514 if (sd->autogain_ignore_frames > 0) 515 sd->autogain_ignore_frames--; 516 else if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum, 517 desired_lum, deadzone)) 518 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES; 519 } 520 521 /* JPEG header, part 1 */ 522 static const unsigned char pac_jpeg_header1[] = { 523 0xff, 0xd8, /* SOI: Start of Image */ 524 525 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */ 526 0x00, 0x11, /* length = 17 bytes (including this length field) */ 527 0x08 /* Precision: 8 */ 528 /* 2 bytes is placed here: number of image lines */ 529 /* 2 bytes is placed here: samples per line */ 530 }; 531 532 /* JPEG header, continued */ 533 static const unsigned char pac_jpeg_header2[] = { 534 0x03, /* Number of image components: 3 */ 535 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */ 536 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */ 537 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */ 538 539 0xff, 0xda, /* SOS: Start Of Scan */ 540 0x00, 0x0c, /* length = 12 bytes (including this length field) */ 541 0x03, /* number of components: 3 */ 542 0x01, 0x00, /* selector 1, table 0x00 */ 543 0x02, 0x11, /* selector 2, table 0x11 */ 544 0x03, 0x11, /* selector 3, table 0x11 */ 545 0x00, 0x3f, /* Spectral selection: 0 .. 63 */ 546 0x00 /* Successive approximation: 0 */ 547 }; 548 549 static void pac_start_frame(struct gspca_dev *gspca_dev, 550 __u16 lines, __u16 samples_per_line) 551 { 552 unsigned char tmpbuf[4]; 553 554 gspca_frame_add(gspca_dev, FIRST_PACKET, 555 pac_jpeg_header1, sizeof(pac_jpeg_header1)); 556 557 tmpbuf[0] = lines >> 8; 558 tmpbuf[1] = lines & 0xff; 559 tmpbuf[2] = samples_per_line >> 8; 560 tmpbuf[3] = samples_per_line & 0xff; 561 562 gspca_frame_add(gspca_dev, INTER_PACKET, 563 tmpbuf, sizeof(tmpbuf)); 564 gspca_frame_add(gspca_dev, INTER_PACKET, 565 pac_jpeg_header2, sizeof(pac_jpeg_header2)); 566 } 567 568 /* this function is run at interrupt level */ 569 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 570 u8 *data, /* isoc packet */ 571 int len) /* iso packet length */ 572 { 573 struct sd *sd = (struct sd *) gspca_dev; 574 u8 *image; 575 unsigned char *sof; 576 577 sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len); 578 if (sof) { 579 int n, lum_offset, footer_length; 580 581 /* 582 * 6 bytes after the FF D9 EOF marker a number of lumination 583 * bytes are send corresponding to different parts of the 584 * image, the 14th and 15th byte after the EOF seem to 585 * correspond to the center of the image. 586 */ 587 lum_offset = 24 + sizeof pac_sof_marker; 588 footer_length = 26; 589 590 /* Finish decoding current frame */ 591 n = (sof - data) - (footer_length + sizeof pac_sof_marker); 592 if (n < 0) { 593 gspca_dev->image_len += n; 594 n = 0; 595 } else { 596 gspca_frame_add(gspca_dev, INTER_PACKET, data, n); 597 } 598 image = gspca_dev->image; 599 if (image != NULL 600 && image[gspca_dev->image_len - 2] == 0xff 601 && image[gspca_dev->image_len - 1] == 0xd9) 602 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 603 604 n = sof - data; 605 len -= n; 606 data = sof; 607 608 /* Get average lumination */ 609 if (gspca_dev->last_packet_type == LAST_PACKET && 610 n >= lum_offset) 611 atomic_set(&sd->avg_lum, data[-lum_offset] + 612 data[-lum_offset + 1]); 613 else 614 atomic_set(&sd->avg_lum, -1); 615 616 /* Start the new frame with the jpeg header */ 617 pac_start_frame(gspca_dev, 618 gspca_dev->pixfmt.height, gspca_dev->pixfmt.width); 619 } 620 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 621 } 622 623 #if IS_ENABLED(CONFIG_INPUT) 624 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, 625 u8 *data, /* interrupt packet data */ 626 int len) /* interrupt packet length */ 627 { 628 int ret = -EINVAL; 629 u8 data0, data1; 630 631 if (len == 2) { 632 data0 = data[0]; 633 data1 = data[1]; 634 if ((data0 == 0x00 && data1 == 0x11) || 635 (data0 == 0x22 && data1 == 0x33) || 636 (data0 == 0x44 && data1 == 0x55) || 637 (data0 == 0x66 && data1 == 0x77) || 638 (data0 == 0x88 && data1 == 0x99) || 639 (data0 == 0xaa && data1 == 0xbb) || 640 (data0 == 0xcc && data1 == 0xdd) || 641 (data0 == 0xee && data1 == 0xff)) { 642 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 643 input_sync(gspca_dev->input_dev); 644 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 645 input_sync(gspca_dev->input_dev); 646 ret = 0; 647 } 648 } 649 650 return ret; 651 } 652 #endif 653 654 static const struct sd_desc sd_desc = { 655 .name = MODULE_NAME, 656 .config = sd_config, 657 .init = sd_init, 658 .init_controls = sd_init_controls, 659 .start = sd_start, 660 .stopN = sd_stopN, 661 .pkt_scan = sd_pkt_scan, 662 .dq_callback = do_autogain, 663 #if IS_ENABLED(CONFIG_INPUT) 664 .int_pkt_scan = sd_int_pkt_scan, 665 #endif 666 }; 667 668 /* -- module initialisation -- */ 669 static const struct usb_device_id device_table[] = { 670 {USB_DEVICE(0x093a, 0x2600)}, 671 {USB_DEVICE(0x093a, 0x2601)}, 672 {USB_DEVICE(0x093a, 0x2603)}, 673 {USB_DEVICE(0x093a, 0x2608)}, 674 {USB_DEVICE(0x093a, 0x260e)}, 675 {USB_DEVICE(0x093a, 0x260f)}, 676 {} 677 }; 678 MODULE_DEVICE_TABLE(usb, device_table); 679 680 /* -- device connect -- */ 681 static int sd_probe(struct usb_interface *intf, 682 const struct usb_device_id *id) 683 { 684 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 685 THIS_MODULE); 686 } 687 688 static struct usb_driver sd_driver = { 689 .name = MODULE_NAME, 690 .id_table = device_table, 691 .probe = sd_probe, 692 .disconnect = gspca_disconnect, 693 #ifdef CONFIG_PM 694 .suspend = gspca_suspend, 695 .resume = gspca_resume, 696 .reset_resume = gspca_resume, 697 #endif 698 }; 699 700 module_usb_driver(sd_driver); 701