1 /* 2 * Pixart PAC7302 driver 3 * 4 * Copyright (C) 2008-2012 Jean-Francois Moine <http://moinejf.free.fr> 5 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li 6 * 7 * Separated from Pixart PAC7311 library by Márton Németh 8 * Camera button input handling by Márton Németh <nm127@freemail.hu> 9 * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 24 */ 25 26 /* 27 * Some documentation about various registers as determined by trial and error. 28 * 29 * Register page 0: 30 * 31 * Address Description 32 * 0x01 Red balance control 33 * 0x02 Green balance control 34 * 0x03 Blue balance control 35 * The Windows driver uses a quadratic approach to map 36 * the settable values (0-200) on register values: 37 * min=0x20, default=0x40, max=0x80 38 * 0x0f-0x20 Color and saturation control 39 * 0xa2-0xab Brightness, contrast and gamma control 40 * 0xb6 Sharpness control (bits 0-4) 41 * 42 * Register page 1: 43 * 44 * Address Description 45 * 0x78 Global control, bit 6 controls the LED (inverted) 46 * 0x80 Compression balance, 2 interesting settings: 47 * 0x0f Default 48 * 0x50 Values >= this switch the camera to a lower compression, 49 * using the same table for both luminance and chrominance. 50 * This gives a sharper picture. Only usable when running 51 * at < 15 fps! Note currently the driver does not use this 52 * as the quality gain is small and the generated JPG-s are 53 * only understood by v4l-utils >= 0.8.9 54 * 55 * Register page 3: 56 * 57 * Address Description 58 * 0x02 Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on 59 * the 7302, so one of 3, 6, 9, ..., except when between 6 and 12? 60 * 0x03 Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps 61 * 0x04 Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps, 62 * 63 -> ~27 fps, the 2 msb's must always be 1 !! 63 * 0x05 Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0: 64 * 1 -> ~30 fps, 2 -> ~20 fps 65 * 0x0e Exposure bits 0-7, 0-448, 0 = use full frame time 66 * 0x0f Exposure bit 8, 0-448, 448 = no exposure at all 67 * 0x10 Gain 0-31 68 * 0x12 Another gain 0-31, unlike 0x10 this one seems to start with an 69 * amplification value of 1 rather then 0 at its lowest setting 70 * 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused 71 * 0x80 Another framerate control, best left at 1, moving it from 1 to 72 * 2 causes the framerate to become 3/4th of what it was, and 73 * also seems to cause pixel averaging, resulting in an effective 74 * resolution of 320x240 and thus a much blockier image 75 * 76 * The registers are accessed in the following functions: 77 * 78 * Page | Register | Function 79 * -----+------------+--------------------------------------------------- 80 * 0 | 0x01 | setredbalance() 81 * 0 | 0x03 | setbluebalance() 82 * 0 | 0x0f..0x20 | setcolors() 83 * 0 | 0xa2..0xab | setbrightcont() 84 * 0 | 0xb6 | setsharpness() 85 * 0 | 0xc6 | setwhitebalance() 86 * 0 | 0xdc | setbrightcont(), setcolors() 87 * 3 | 0x02 | setexposure() 88 * 3 | 0x10, 0x12 | setgain() 89 * 3 | 0x11 | setcolors(), setgain(), setexposure(), sethvflip() 90 * 3 | 0x21 | sethvflip() 91 */ 92 93 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 94 95 #include <linux/input.h> 96 #include <media/v4l2-chip-ident.h> 97 #include "gspca.h" 98 /* Include pac common sof detection functions */ 99 #include "pac_common.h" 100 101 #define PAC7302_RGB_BALANCE_MIN 0 102 #define PAC7302_RGB_BALANCE_MAX 200 103 #define PAC7302_RGB_BALANCE_DEFAULT 100 104 #define PAC7302_GAIN_DEFAULT 15 105 #define PAC7302_GAIN_KNEE 42 106 #define PAC7302_EXPOSURE_DEFAULT 66 /* 33 ms / 30 fps */ 107 #define PAC7302_EXPOSURE_KNEE 133 /* 66 ms / 15 fps */ 108 109 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, " 110 "Thomas Kaiser thomas@kaiser-linux.li"); 111 MODULE_DESCRIPTION("Pixart PAC7302"); 112 MODULE_LICENSE("GPL"); 113 114 struct sd { 115 struct gspca_dev gspca_dev; /* !! must be the first item */ 116 117 struct { /* brightness / contrast cluster */ 118 struct v4l2_ctrl *brightness; 119 struct v4l2_ctrl *contrast; 120 }; 121 struct v4l2_ctrl *saturation; 122 struct v4l2_ctrl *white_balance; 123 struct v4l2_ctrl *red_balance; 124 struct v4l2_ctrl *blue_balance; 125 struct { /* flip cluster */ 126 struct v4l2_ctrl *hflip; 127 struct v4l2_ctrl *vflip; 128 }; 129 struct v4l2_ctrl *sharpness; 130 u8 flags; 131 #define FL_HFLIP 0x01 /* mirrored by default */ 132 #define FL_VFLIP 0x02 /* vertical flipped by default */ 133 134 u8 sof_read; 135 s8 autogain_ignore_frames; 136 137 atomic_t avg_lum; 138 }; 139 140 static const struct v4l2_pix_format vga_mode[] = { 141 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE, 142 .bytesperline = 640, 143 .sizeimage = 640 * 480 * 3 / 8 + 590, 144 .colorspace = V4L2_COLORSPACE_JPEG, 145 }, 146 }; 147 148 #define LOAD_PAGE3 255 149 #define END_OF_SEQUENCE 0 150 151 static const u8 init_7302[] = { 152 /* index,value */ 153 0xff, 0x01, /* page 1 */ 154 0x78, 0x00, /* deactivate */ 155 0xff, 0x01, 156 0x78, 0x40, /* led off */ 157 }; 158 static const u8 start_7302[] = { 159 /* index, len, [value]* */ 160 0xff, 1, 0x00, /* page 0 */ 161 0x00, 12, 0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80, 162 0x00, 0x00, 0x00, 0x00, 163 0x0d, 24, 0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00, 164 0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7, 165 0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11, 166 0x26, 2, 0xaa, 0xaa, 167 0x2e, 1, 0x31, 168 0x38, 1, 0x01, 169 0x3a, 3, 0x14, 0xff, 0x5a, 170 0x43, 11, 0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11, 171 0x00, 0x54, 0x11, 172 0x55, 1, 0x00, 173 0x62, 4, 0x10, 0x1e, 0x1e, 0x18, 174 0x6b, 1, 0x00, 175 0x6e, 3, 0x08, 0x06, 0x00, 176 0x72, 3, 0x00, 0xff, 0x00, 177 0x7d, 23, 0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c, 178 0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50, 179 0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00, 180 0xa2, 10, 0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9, 181 0xd2, 0xeb, 182 0xaf, 1, 0x02, 183 0xb5, 2, 0x08, 0x08, 184 0xb8, 2, 0x08, 0x88, 185 0xc4, 4, 0xae, 0x01, 0x04, 0x01, 186 0xcc, 1, 0x00, 187 0xd1, 11, 0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9, 188 0xc1, 0xd7, 0xec, 189 0xdc, 1, 0x01, 190 0xff, 1, 0x01, /* page 1 */ 191 0x12, 3, 0x02, 0x00, 0x01, 192 0x3e, 2, 0x00, 0x00, 193 0x76, 5, 0x01, 0x20, 0x40, 0x00, 0xf2, 194 0x7c, 1, 0x00, 195 0x7f, 10, 0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20, 196 0x02, 0x00, 197 0x96, 5, 0x01, 0x10, 0x04, 0x01, 0x04, 198 0xc8, 14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 199 0x07, 0x00, 0x01, 0x07, 0x04, 0x01, 200 0xd8, 1, 0x01, 201 0xdb, 2, 0x00, 0x01, 202 0xde, 7, 0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00, 203 0xe6, 4, 0x00, 0x00, 0x00, 0x01, 204 0xeb, 1, 0x00, 205 0xff, 1, 0x02, /* page 2 */ 206 0x22, 1, 0x00, 207 0xff, 1, 0x03, /* page 3 */ 208 0, LOAD_PAGE3, /* load the page 3 */ 209 0x11, 1, 0x01, 210 0xff, 1, 0x02, /* page 2 */ 211 0x13, 1, 0x00, 212 0x22, 4, 0x1f, 0xa4, 0xf0, 0x96, 213 0x27, 2, 0x14, 0x0c, 214 0x2a, 5, 0xc8, 0x00, 0x18, 0x12, 0x22, 215 0x64, 8, 0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44, 216 0x6e, 1, 0x08, 217 0xff, 1, 0x01, /* page 1 */ 218 0x78, 1, 0x00, 219 0, END_OF_SEQUENCE /* end of sequence */ 220 }; 221 222 #define SKIP 0xaa 223 /* page 3 - the value SKIP says skip the index - see reg_w_page() */ 224 static const u8 page3_7302[] = { 225 0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16, 226 0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00, 227 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 228 0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00, 229 0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21, 230 0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54, 231 0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00, 232 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 233 0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00, 234 SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00, 235 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 236 0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00, 237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 238 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8, 239 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 240 0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00, 241 0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00, 242 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 243 0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00, 244 0x00 245 }; 246 247 static void reg_w_buf(struct gspca_dev *gspca_dev, 248 u8 index, 249 const u8 *buffer, int len) 250 { 251 int ret; 252 253 if (gspca_dev->usb_err < 0) 254 return; 255 memcpy(gspca_dev->usb_buf, buffer, len); 256 ret = usb_control_msg(gspca_dev->dev, 257 usb_sndctrlpipe(gspca_dev->dev, 0), 258 0, /* request */ 259 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 260 0, /* value */ 261 index, gspca_dev->usb_buf, len, 262 500); 263 if (ret < 0) { 264 pr_err("reg_w_buf failed i: %02x error %d\n", 265 index, ret); 266 gspca_dev->usb_err = ret; 267 } 268 } 269 270 271 static void reg_w(struct gspca_dev *gspca_dev, 272 u8 index, 273 u8 value) 274 { 275 int ret; 276 277 if (gspca_dev->usb_err < 0) 278 return; 279 gspca_dev->usb_buf[0] = value; 280 ret = usb_control_msg(gspca_dev->dev, 281 usb_sndctrlpipe(gspca_dev->dev, 0), 282 0, /* request */ 283 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 284 0, index, gspca_dev->usb_buf, 1, 285 500); 286 if (ret < 0) { 287 pr_err("reg_w() failed i: %02x v: %02x error %d\n", 288 index, value, ret); 289 gspca_dev->usb_err = ret; 290 } 291 } 292 293 static void reg_w_seq(struct gspca_dev *gspca_dev, 294 const u8 *seq, int len) 295 { 296 while (--len >= 0) { 297 reg_w(gspca_dev, seq[0], seq[1]); 298 seq += 2; 299 } 300 } 301 302 /* load the beginning of a page */ 303 static void reg_w_page(struct gspca_dev *gspca_dev, 304 const u8 *page, int len) 305 { 306 int index; 307 int ret = 0; 308 309 if (gspca_dev->usb_err < 0) 310 return; 311 for (index = 0; index < len; index++) { 312 if (page[index] == SKIP) /* skip this index */ 313 continue; 314 gspca_dev->usb_buf[0] = page[index]; 315 ret = usb_control_msg(gspca_dev->dev, 316 usb_sndctrlpipe(gspca_dev->dev, 0), 317 0, /* request */ 318 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 319 0, index, gspca_dev->usb_buf, 1, 320 500); 321 if (ret < 0) { 322 pr_err("reg_w_page() failed i: %02x v: %02x error %d\n", 323 index, page[index], ret); 324 gspca_dev->usb_err = ret; 325 break; 326 } 327 } 328 } 329 330 /* output a variable sequence */ 331 static void reg_w_var(struct gspca_dev *gspca_dev, 332 const u8 *seq, 333 const u8 *page3, unsigned int page3_len) 334 { 335 int index, len; 336 337 for (;;) { 338 index = *seq++; 339 len = *seq++; 340 switch (len) { 341 case END_OF_SEQUENCE: 342 return; 343 case LOAD_PAGE3: 344 reg_w_page(gspca_dev, page3, page3_len); 345 break; 346 default: 347 #ifdef GSPCA_DEBUG 348 if (len > USB_BUF_SZ) { 349 PDEBUG(D_ERR|D_STREAM, 350 "Incorrect variable sequence"); 351 return; 352 } 353 #endif 354 while (len > 0) { 355 if (len < 8) { 356 reg_w_buf(gspca_dev, 357 index, seq, len); 358 seq += len; 359 break; 360 } 361 reg_w_buf(gspca_dev, index, seq, 8); 362 seq += 8; 363 index += 8; 364 len -= 8; 365 } 366 } 367 } 368 /* not reached */ 369 } 370 371 /* this function is called at probe time for pac7302 */ 372 static int sd_config(struct gspca_dev *gspca_dev, 373 const struct usb_device_id *id) 374 { 375 struct sd *sd = (struct sd *) gspca_dev; 376 struct cam *cam; 377 378 cam = &gspca_dev->cam; 379 380 cam->cam_mode = vga_mode; /* only 640x480 */ 381 cam->nmodes = ARRAY_SIZE(vga_mode); 382 383 sd->flags = id->driver_info; 384 return 0; 385 } 386 387 static void setbrightcont(struct gspca_dev *gspca_dev) 388 { 389 struct sd *sd = (struct sd *) gspca_dev; 390 int i, v; 391 static const u8 max[10] = 392 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb, 393 0xd4, 0xec}; 394 static const u8 delta[10] = 395 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17, 396 0x11, 0x0b}; 397 398 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 399 for (i = 0; i < 10; i++) { 400 v = max[i]; 401 v += (sd->brightness->val - sd->brightness->maximum) 402 * 150 / sd->brightness->maximum; /* 200 ? */ 403 v -= delta[i] * sd->contrast->val / sd->contrast->maximum; 404 if (v < 0) 405 v = 0; 406 else if (v > 0xff) 407 v = 0xff; 408 reg_w(gspca_dev, 0xa2 + i, v); 409 } 410 reg_w(gspca_dev, 0xdc, 0x01); 411 } 412 413 static void setcolors(struct gspca_dev *gspca_dev) 414 { 415 struct sd *sd = (struct sd *) gspca_dev; 416 int i, v; 417 static const int a[9] = 418 {217, -212, 0, -101, 170, -67, -38, -315, 355}; 419 static const int b[9] = 420 {19, 106, 0, 19, 106, 1, 19, 106, 1}; 421 422 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 423 reg_w(gspca_dev, 0x11, 0x01); 424 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 425 for (i = 0; i < 9; i++) { 426 v = a[i] * sd->saturation->val / sd->saturation->maximum; 427 v += b[i]; 428 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07); 429 reg_w(gspca_dev, 0x0f + 2 * i + 1, v); 430 } 431 reg_w(gspca_dev, 0xdc, 0x01); 432 } 433 434 static void setwhitebalance(struct gspca_dev *gspca_dev) 435 { 436 struct sd *sd = (struct sd *) gspca_dev; 437 438 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 439 reg_w(gspca_dev, 0xc6, sd->white_balance->val); 440 441 reg_w(gspca_dev, 0xdc, 0x01); 442 } 443 444 static u8 rgbbalance_ctrl_to_reg_value(s32 rgb_ctrl_val) 445 { 446 const unsigned int k = 1000; /* precision factor */ 447 unsigned int norm; 448 449 /* Normed value [0...k] */ 450 norm = k * (rgb_ctrl_val - PAC7302_RGB_BALANCE_MIN) 451 / (PAC7302_RGB_BALANCE_MAX - PAC7302_RGB_BALANCE_MIN); 452 /* Qudratic apporach improves control at small (register) values: */ 453 return 64 * norm * norm / (k*k) + 32 * norm / k + 32; 454 /* Y = 64*X*X + 32*X + 32 455 * => register values 0x20-0x80; Windows driver uses these limits */ 456 457 /* NOTE: for full value range (0x00-0xff) use 458 * Y = 254*X*X + X 459 * => 254 * norm * norm / (k*k) + 1 * norm / k */ 460 } 461 462 static void setredbalance(struct gspca_dev *gspca_dev) 463 { 464 struct sd *sd = (struct sd *) gspca_dev; 465 466 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 467 reg_w(gspca_dev, 0x01, 468 rgbbalance_ctrl_to_reg_value(sd->red_balance->val)); 469 470 reg_w(gspca_dev, 0xdc, 0x01); 471 } 472 473 static void setbluebalance(struct gspca_dev *gspca_dev) 474 { 475 struct sd *sd = (struct sd *) gspca_dev; 476 477 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 478 reg_w(gspca_dev, 0x03, 479 rgbbalance_ctrl_to_reg_value(sd->blue_balance->val)); 480 481 reg_w(gspca_dev, 0xdc, 0x01); 482 } 483 484 static void setgain(struct gspca_dev *gspca_dev) 485 { 486 u8 reg10, reg12; 487 488 if (gspca_dev->gain->val < 32) { 489 reg10 = gspca_dev->gain->val; 490 reg12 = 0; 491 } else { 492 reg10 = 31; 493 reg12 = gspca_dev->gain->val - 31; 494 } 495 496 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 497 reg_w(gspca_dev, 0x10, reg10); 498 reg_w(gspca_dev, 0x12, reg12); 499 500 /* load registers to sensor (Bit 0, auto clear) */ 501 reg_w(gspca_dev, 0x11, 0x01); 502 } 503 504 static void setexposure(struct gspca_dev *gspca_dev) 505 { 506 u8 clockdiv; 507 u16 exposure; 508 509 /* 510 * Register 2 of frame 3 contains the clock divider configuring the 511 * no fps according to the formula: 90 / reg. sd->exposure is the 512 * desired exposure time in 0.5 ms. 513 */ 514 clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000; 515 516 /* 517 * Note clockdiv = 3 also works, but when running at 30 fps, depending 518 * on the scene being recorded, the camera switches to another 519 * quantization table for certain JPEG blocks, and we don't know how 520 * to decompress these blocks. So we cap the framerate at 15 fps. 521 */ 522 if (clockdiv < 6) 523 clockdiv = 6; 524 else if (clockdiv > 63) 525 clockdiv = 63; 526 527 /* 528 * Register 2 MUST be a multiple of 3, except when between 6 and 12? 529 * Always round up, otherwise we cannot get the desired frametime 530 * using the partial frame time exposure control. 531 */ 532 if (clockdiv < 6 || clockdiv > 12) 533 clockdiv = ((clockdiv + 2) / 3) * 3; 534 535 /* 536 * frame exposure time in ms = 1000 * clockdiv / 90 -> 537 * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90) 538 */ 539 exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv); 540 /* 0 = use full frametime, 448 = no exposure, reverse it */ 541 exposure = 448 - exposure; 542 543 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 544 reg_w(gspca_dev, 0x02, clockdiv); 545 reg_w(gspca_dev, 0x0e, exposure & 0xff); 546 reg_w(gspca_dev, 0x0f, exposure >> 8); 547 548 /* load registers to sensor (Bit 0, auto clear) */ 549 reg_w(gspca_dev, 0x11, 0x01); 550 } 551 552 static void sethvflip(struct gspca_dev *gspca_dev) 553 { 554 struct sd *sd = (struct sd *) gspca_dev; 555 u8 data, hflip, vflip; 556 557 hflip = sd->hflip->val; 558 if (sd->flags & FL_HFLIP) 559 hflip = !hflip; 560 vflip = sd->vflip->val; 561 if (sd->flags & FL_VFLIP) 562 vflip = !vflip; 563 564 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 565 data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00); 566 reg_w(gspca_dev, 0x21, data); 567 568 /* load registers to sensor (Bit 0, auto clear) */ 569 reg_w(gspca_dev, 0x11, 0x01); 570 } 571 572 static void setsharpness(struct gspca_dev *gspca_dev) 573 { 574 struct sd *sd = (struct sd *) gspca_dev; 575 576 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 577 reg_w(gspca_dev, 0xb6, sd->sharpness->val); 578 579 reg_w(gspca_dev, 0xdc, 0x01); 580 } 581 582 /* this function is called at probe and resume time for pac7302 */ 583 static int sd_init(struct gspca_dev *gspca_dev) 584 { 585 reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2); 586 return gspca_dev->usb_err; 587 } 588 589 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 590 { 591 struct gspca_dev *gspca_dev = 592 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 593 struct sd *sd = (struct sd *)gspca_dev; 594 595 gspca_dev->usb_err = 0; 596 597 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) { 598 /* when switching to autogain set defaults to make sure 599 we are on a valid point of the autogain gain / 600 exposure knee graph, and give this change time to 601 take effect before doing autogain. */ 602 gspca_dev->exposure->val = PAC7302_EXPOSURE_DEFAULT; 603 gspca_dev->gain->val = PAC7302_GAIN_DEFAULT; 604 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES; 605 } 606 607 if (!gspca_dev->streaming) 608 return 0; 609 610 switch (ctrl->id) { 611 case V4L2_CID_BRIGHTNESS: 612 setbrightcont(gspca_dev); 613 break; 614 case V4L2_CID_SATURATION: 615 setcolors(gspca_dev); 616 break; 617 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: 618 setwhitebalance(gspca_dev); 619 break; 620 case V4L2_CID_RED_BALANCE: 621 setredbalance(gspca_dev); 622 break; 623 case V4L2_CID_BLUE_BALANCE: 624 setbluebalance(gspca_dev); 625 break; 626 case V4L2_CID_AUTOGAIN: 627 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val)) 628 setexposure(gspca_dev); 629 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val)) 630 setgain(gspca_dev); 631 break; 632 case V4L2_CID_HFLIP: 633 sethvflip(gspca_dev); 634 break; 635 case V4L2_CID_SHARPNESS: 636 setsharpness(gspca_dev); 637 break; 638 default: 639 return -EINVAL; 640 } 641 return gspca_dev->usb_err; 642 } 643 644 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 645 .s_ctrl = sd_s_ctrl, 646 }; 647 648 /* this function is called at probe time */ 649 static int sd_init_controls(struct gspca_dev *gspca_dev) 650 { 651 struct sd *sd = (struct sd *) gspca_dev; 652 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 653 654 gspca_dev->vdev.ctrl_handler = hdl; 655 v4l2_ctrl_handler_init(hdl, 12); 656 657 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 658 V4L2_CID_BRIGHTNESS, 0, 32, 1, 16); 659 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 660 V4L2_CID_CONTRAST, 0, 255, 1, 127); 661 662 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 663 V4L2_CID_SATURATION, 0, 255, 1, 127); 664 sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 665 V4L2_CID_WHITE_BALANCE_TEMPERATURE, 666 0, 255, 1, 55); 667 sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 668 V4L2_CID_RED_BALANCE, 669 PAC7302_RGB_BALANCE_MIN, 670 PAC7302_RGB_BALANCE_MAX, 671 1, PAC7302_RGB_BALANCE_DEFAULT); 672 sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 673 V4L2_CID_BLUE_BALANCE, 674 PAC7302_RGB_BALANCE_MIN, 675 PAC7302_RGB_BALANCE_MAX, 676 1, PAC7302_RGB_BALANCE_DEFAULT); 677 678 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 679 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 680 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 681 V4L2_CID_EXPOSURE, 0, 1023, 1, 682 PAC7302_EXPOSURE_DEFAULT); 683 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 684 V4L2_CID_GAIN, 0, 62, 1, 685 PAC7302_GAIN_DEFAULT); 686 687 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 688 V4L2_CID_HFLIP, 0, 1, 1, 0); 689 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 690 V4L2_CID_VFLIP, 0, 1, 1, 0); 691 692 sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 693 V4L2_CID_SHARPNESS, 0, 15, 1, 8); 694 695 if (hdl->error) { 696 pr_err("Could not initialize controls\n"); 697 return hdl->error; 698 } 699 700 v4l2_ctrl_cluster(2, &sd->brightness); 701 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false); 702 v4l2_ctrl_cluster(2, &sd->hflip); 703 return 0; 704 } 705 706 /* -- start the camera -- */ 707 static int sd_start(struct gspca_dev *gspca_dev) 708 { 709 struct sd *sd = (struct sd *) gspca_dev; 710 711 reg_w_var(gspca_dev, start_7302, 712 page3_7302, sizeof(page3_7302)); 713 714 sd->sof_read = 0; 715 sd->autogain_ignore_frames = 0; 716 atomic_set(&sd->avg_lum, 270 + sd->brightness->val); 717 718 /* start stream */ 719 reg_w(gspca_dev, 0xff, 0x01); 720 reg_w(gspca_dev, 0x78, 0x01); 721 722 return gspca_dev->usb_err; 723 } 724 725 static void sd_stopN(struct gspca_dev *gspca_dev) 726 { 727 728 /* stop stream */ 729 reg_w(gspca_dev, 0xff, 0x01); 730 reg_w(gspca_dev, 0x78, 0x00); 731 } 732 733 /* called on streamoff with alt 0 and on disconnect for pac7302 */ 734 static void sd_stop0(struct gspca_dev *gspca_dev) 735 { 736 if (!gspca_dev->present) 737 return; 738 reg_w(gspca_dev, 0xff, 0x01); 739 reg_w(gspca_dev, 0x78, 0x40); 740 } 741 742 static void do_autogain(struct gspca_dev *gspca_dev) 743 { 744 struct sd *sd = (struct sd *) gspca_dev; 745 int avg_lum = atomic_read(&sd->avg_lum); 746 int desired_lum; 747 const int deadzone = 30; 748 749 if (sd->autogain_ignore_frames < 0) 750 return; 751 752 if (sd->autogain_ignore_frames > 0) { 753 sd->autogain_ignore_frames--; 754 } else { 755 desired_lum = 270 + sd->brightness->val; 756 757 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum, 758 deadzone, PAC7302_GAIN_KNEE, 759 PAC7302_EXPOSURE_KNEE)) 760 sd->autogain_ignore_frames = 761 PAC_AUTOGAIN_IGNORE_FRAMES; 762 } 763 } 764 765 /* JPEG header */ 766 static const u8 jpeg_header[] = { 767 0xff, 0xd8, /* SOI: Start of Image */ 768 769 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */ 770 0x00, 0x11, /* length = 17 bytes (including this length field) */ 771 0x08, /* Precision: 8 */ 772 0x02, 0x80, /* height = 640 (image rotated) */ 773 0x01, 0xe0, /* width = 480 */ 774 0x03, /* Number of image components: 3 */ 775 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */ 776 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */ 777 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */ 778 779 0xff, 0xda, /* SOS: Start Of Scan */ 780 0x00, 0x0c, /* length = 12 bytes (including this length field) */ 781 0x03, /* number of components: 3 */ 782 0x01, 0x00, /* selector 1, table 0x00 */ 783 0x02, 0x11, /* selector 2, table 0x11 */ 784 0x03, 0x11, /* selector 3, table 0x11 */ 785 0x00, 0x3f, /* Spectral selection: 0 .. 63 */ 786 0x00 /* Successive approximation: 0 */ 787 }; 788 789 /* this function is run at interrupt level */ 790 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 791 u8 *data, /* isoc packet */ 792 int len) /* iso packet length */ 793 { 794 struct sd *sd = (struct sd *) gspca_dev; 795 u8 *image; 796 u8 *sof; 797 798 sof = pac_find_sof(&sd->sof_read, data, len); 799 if (sof) { 800 int n, lum_offset, footer_length; 801 802 /* 803 * 6 bytes after the FF D9 EOF marker a number of lumination 804 * bytes are send corresponding to different parts of the 805 * image, the 14th and 15th byte after the EOF seem to 806 * correspond to the center of the image. 807 */ 808 lum_offset = 61 + sizeof pac_sof_marker; 809 footer_length = 74; 810 811 /* Finish decoding current frame */ 812 n = (sof - data) - (footer_length + sizeof pac_sof_marker); 813 if (n < 0) { 814 gspca_dev->image_len += n; 815 n = 0; 816 } else { 817 gspca_frame_add(gspca_dev, INTER_PACKET, data, n); 818 } 819 820 image = gspca_dev->image; 821 if (image != NULL 822 && image[gspca_dev->image_len - 2] == 0xff 823 && image[gspca_dev->image_len - 1] == 0xd9) 824 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 825 826 n = sof - data; 827 len -= n; 828 data = sof; 829 830 /* Get average lumination */ 831 if (gspca_dev->last_packet_type == LAST_PACKET && 832 n >= lum_offset) 833 atomic_set(&sd->avg_lum, data[-lum_offset] + 834 data[-lum_offset + 1]); 835 836 /* Start the new frame with the jpeg header */ 837 /* The PAC7302 has the image rotated 90 degrees */ 838 gspca_frame_add(gspca_dev, FIRST_PACKET, 839 jpeg_header, sizeof jpeg_header); 840 } 841 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 842 } 843 844 #ifdef CONFIG_VIDEO_ADV_DEBUG 845 static int sd_dbg_s_register(struct gspca_dev *gspca_dev, 846 struct v4l2_dbg_register *reg) 847 { 848 u8 index; 849 u8 value; 850 851 /* 852 * reg->reg: bit0..15: reserved for register index (wIndex is 16bit 853 * long on the USB bus) 854 */ 855 if (reg->match.type == V4L2_CHIP_MATCH_HOST && 856 reg->match.addr == 0 && 857 (reg->reg < 0x000000ff) && 858 (reg->val <= 0x000000ff) 859 ) { 860 /* Currently writing to page 0 is only supported. */ 861 /* reg_w() only supports 8bit index */ 862 index = reg->reg; 863 value = reg->val; 864 865 /* 866 * Note that there shall be no access to other page 867 * by any other function between the page switch and 868 * the actual register write. 869 */ 870 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 871 reg_w(gspca_dev, index, value); 872 873 reg_w(gspca_dev, 0xdc, 0x01); 874 } 875 return gspca_dev->usb_err; 876 } 877 878 static int sd_chip_ident(struct gspca_dev *gspca_dev, 879 struct v4l2_dbg_chip_ident *chip) 880 { 881 int ret = -EINVAL; 882 883 if (chip->match.type == V4L2_CHIP_MATCH_HOST && 884 chip->match.addr == 0) { 885 chip->revision = 0; 886 chip->ident = V4L2_IDENT_UNKNOWN; 887 ret = 0; 888 } 889 return ret; 890 } 891 #endif 892 893 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 894 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, 895 u8 *data, /* interrupt packet data */ 896 int len) /* interrput packet length */ 897 { 898 int ret = -EINVAL; 899 u8 data0, data1; 900 901 if (len == 2) { 902 data0 = data[0]; 903 data1 = data[1]; 904 if ((data0 == 0x00 && data1 == 0x11) || 905 (data0 == 0x22 && data1 == 0x33) || 906 (data0 == 0x44 && data1 == 0x55) || 907 (data0 == 0x66 && data1 == 0x77) || 908 (data0 == 0x88 && data1 == 0x99) || 909 (data0 == 0xaa && data1 == 0xbb) || 910 (data0 == 0xcc && data1 == 0xdd) || 911 (data0 == 0xee && data1 == 0xff)) { 912 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 913 input_sync(gspca_dev->input_dev); 914 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 915 input_sync(gspca_dev->input_dev); 916 ret = 0; 917 } 918 } 919 920 return ret; 921 } 922 #endif 923 924 /* sub-driver description for pac7302 */ 925 static const struct sd_desc sd_desc = { 926 .name = KBUILD_MODNAME, 927 .config = sd_config, 928 .init = sd_init, 929 .init_controls = sd_init_controls, 930 .start = sd_start, 931 .stopN = sd_stopN, 932 .stop0 = sd_stop0, 933 .pkt_scan = sd_pkt_scan, 934 .dq_callback = do_autogain, 935 #ifdef CONFIG_VIDEO_ADV_DEBUG 936 .set_register = sd_dbg_s_register, 937 .get_chip_ident = sd_chip_ident, 938 #endif 939 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 940 .int_pkt_scan = sd_int_pkt_scan, 941 #endif 942 }; 943 944 /* -- module initialisation -- */ 945 static const struct usb_device_id device_table[] = { 946 {USB_DEVICE(0x06f8, 0x3009)}, 947 {USB_DEVICE(0x06f8, 0x301b)}, 948 {USB_DEVICE(0x093a, 0x2620)}, 949 {USB_DEVICE(0x093a, 0x2621)}, 950 {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP}, 951 {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP}, 952 {USB_DEVICE(0x093a, 0x2625)}, 953 {USB_DEVICE(0x093a, 0x2626)}, 954 {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP}, 955 {USB_DEVICE(0x093a, 0x2628)}, 956 {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP}, 957 {USB_DEVICE(0x093a, 0x262a)}, 958 {USB_DEVICE(0x093a, 0x262c)}, 959 {USB_DEVICE(0x145f, 0x013c)}, 960 {USB_DEVICE(0x1ae7, 0x2001)}, /* SpeedLink Snappy Mic SL-6825-SBK */ 961 {} 962 }; 963 MODULE_DEVICE_TABLE(usb, device_table); 964 965 /* -- device connect -- */ 966 static int sd_probe(struct usb_interface *intf, 967 const struct usb_device_id *id) 968 { 969 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 970 THIS_MODULE); 971 } 972 973 static struct usb_driver sd_driver = { 974 .name = KBUILD_MODNAME, 975 .id_table = device_table, 976 .probe = sd_probe, 977 .disconnect = gspca_disconnect, 978 #ifdef CONFIG_PM 979 .suspend = gspca_suspend, 980 .resume = gspca_resume, 981 .reset_resume = gspca_resume, 982 #endif 983 }; 984 985 module_usb_driver(sd_driver); 986