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 if (len > USB_BUF_SZ) { 348 PERR("Incorrect variable sequence"); 349 return; 350 } 351 while (len > 0) { 352 if (len < 8) { 353 reg_w_buf(gspca_dev, 354 index, seq, len); 355 seq += len; 356 break; 357 } 358 reg_w_buf(gspca_dev, index, seq, 8); 359 seq += 8; 360 index += 8; 361 len -= 8; 362 } 363 } 364 } 365 /* not reached */ 366 } 367 368 /* this function is called at probe time for pac7302 */ 369 static int sd_config(struct gspca_dev *gspca_dev, 370 const struct usb_device_id *id) 371 { 372 struct sd *sd = (struct sd *) gspca_dev; 373 struct cam *cam; 374 375 cam = &gspca_dev->cam; 376 377 cam->cam_mode = vga_mode; /* only 640x480 */ 378 cam->nmodes = ARRAY_SIZE(vga_mode); 379 380 sd->flags = id->driver_info; 381 return 0; 382 } 383 384 static void setbrightcont(struct gspca_dev *gspca_dev) 385 { 386 struct sd *sd = (struct sd *) gspca_dev; 387 int i, v; 388 static const u8 max[10] = 389 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb, 390 0xd4, 0xec}; 391 static const u8 delta[10] = 392 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17, 393 0x11, 0x0b}; 394 395 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 396 for (i = 0; i < 10; i++) { 397 v = max[i]; 398 v += (sd->brightness->val - sd->brightness->maximum) 399 * 150 / sd->brightness->maximum; /* 200 ? */ 400 v -= delta[i] * sd->contrast->val / sd->contrast->maximum; 401 if (v < 0) 402 v = 0; 403 else if (v > 0xff) 404 v = 0xff; 405 reg_w(gspca_dev, 0xa2 + i, v); 406 } 407 reg_w(gspca_dev, 0xdc, 0x01); 408 } 409 410 static void setcolors(struct gspca_dev *gspca_dev) 411 { 412 struct sd *sd = (struct sd *) gspca_dev; 413 int i, v; 414 static const int a[9] = 415 {217, -212, 0, -101, 170, -67, -38, -315, 355}; 416 static const int b[9] = 417 {19, 106, 0, 19, 106, 1, 19, 106, 1}; 418 419 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 420 reg_w(gspca_dev, 0x11, 0x01); 421 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 422 for (i = 0; i < 9; i++) { 423 v = a[i] * sd->saturation->val / sd->saturation->maximum; 424 v += b[i]; 425 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07); 426 reg_w(gspca_dev, 0x0f + 2 * i + 1, v); 427 } 428 reg_w(gspca_dev, 0xdc, 0x01); 429 } 430 431 static void setwhitebalance(struct gspca_dev *gspca_dev) 432 { 433 struct sd *sd = (struct sd *) gspca_dev; 434 435 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 436 reg_w(gspca_dev, 0xc6, sd->white_balance->val); 437 438 reg_w(gspca_dev, 0xdc, 0x01); 439 } 440 441 static u8 rgbbalance_ctrl_to_reg_value(s32 rgb_ctrl_val) 442 { 443 const unsigned int k = 1000; /* precision factor */ 444 unsigned int norm; 445 446 /* Normed value [0...k] */ 447 norm = k * (rgb_ctrl_val - PAC7302_RGB_BALANCE_MIN) 448 / (PAC7302_RGB_BALANCE_MAX - PAC7302_RGB_BALANCE_MIN); 449 /* Qudratic apporach improves control at small (register) values: */ 450 return 64 * norm * norm / (k*k) + 32 * norm / k + 32; 451 /* Y = 64*X*X + 32*X + 32 452 * => register values 0x20-0x80; Windows driver uses these limits */ 453 454 /* NOTE: for full value range (0x00-0xff) use 455 * Y = 254*X*X + X 456 * => 254 * norm * norm / (k*k) + 1 * norm / k */ 457 } 458 459 static void setredbalance(struct gspca_dev *gspca_dev) 460 { 461 struct sd *sd = (struct sd *) gspca_dev; 462 463 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 464 reg_w(gspca_dev, 0x01, 465 rgbbalance_ctrl_to_reg_value(sd->red_balance->val)); 466 467 reg_w(gspca_dev, 0xdc, 0x01); 468 } 469 470 static void setbluebalance(struct gspca_dev *gspca_dev) 471 { 472 struct sd *sd = (struct sd *) gspca_dev; 473 474 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 475 reg_w(gspca_dev, 0x03, 476 rgbbalance_ctrl_to_reg_value(sd->blue_balance->val)); 477 478 reg_w(gspca_dev, 0xdc, 0x01); 479 } 480 481 static void setgain(struct gspca_dev *gspca_dev) 482 { 483 u8 reg10, reg12; 484 485 if (gspca_dev->gain->val < 32) { 486 reg10 = gspca_dev->gain->val; 487 reg12 = 0; 488 } else { 489 reg10 = 31; 490 reg12 = gspca_dev->gain->val - 31; 491 } 492 493 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 494 reg_w(gspca_dev, 0x10, reg10); 495 reg_w(gspca_dev, 0x12, reg12); 496 497 /* load registers to sensor (Bit 0, auto clear) */ 498 reg_w(gspca_dev, 0x11, 0x01); 499 } 500 501 static void setexposure(struct gspca_dev *gspca_dev) 502 { 503 u8 clockdiv; 504 u16 exposure; 505 506 /* 507 * Register 2 of frame 3 contains the clock divider configuring the 508 * no fps according to the formula: 90 / reg. sd->exposure is the 509 * desired exposure time in 0.5 ms. 510 */ 511 clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000; 512 513 /* 514 * Note clockdiv = 3 also works, but when running at 30 fps, depending 515 * on the scene being recorded, the camera switches to another 516 * quantization table for certain JPEG blocks, and we don't know how 517 * to decompress these blocks. So we cap the framerate at 15 fps. 518 */ 519 if (clockdiv < 6) 520 clockdiv = 6; 521 else if (clockdiv > 63) 522 clockdiv = 63; 523 524 /* 525 * Register 2 MUST be a multiple of 3, except when between 6 and 12? 526 * Always round up, otherwise we cannot get the desired frametime 527 * using the partial frame time exposure control. 528 */ 529 if (clockdiv < 6 || clockdiv > 12) 530 clockdiv = ((clockdiv + 2) / 3) * 3; 531 532 /* 533 * frame exposure time in ms = 1000 * clockdiv / 90 -> 534 * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90) 535 */ 536 exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv); 537 /* 0 = use full frametime, 448 = no exposure, reverse it */ 538 exposure = 448 - exposure; 539 540 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 541 reg_w(gspca_dev, 0x02, clockdiv); 542 reg_w(gspca_dev, 0x0e, exposure & 0xff); 543 reg_w(gspca_dev, 0x0f, exposure >> 8); 544 545 /* load registers to sensor (Bit 0, auto clear) */ 546 reg_w(gspca_dev, 0x11, 0x01); 547 } 548 549 static void sethvflip(struct gspca_dev *gspca_dev) 550 { 551 struct sd *sd = (struct sd *) gspca_dev; 552 u8 data, hflip, vflip; 553 554 hflip = sd->hflip->val; 555 if (sd->flags & FL_HFLIP) 556 hflip = !hflip; 557 vflip = sd->vflip->val; 558 if (sd->flags & FL_VFLIP) 559 vflip = !vflip; 560 561 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */ 562 data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00); 563 reg_w(gspca_dev, 0x21, data); 564 565 /* load registers to sensor (Bit 0, auto clear) */ 566 reg_w(gspca_dev, 0x11, 0x01); 567 } 568 569 static void setsharpness(struct gspca_dev *gspca_dev) 570 { 571 struct sd *sd = (struct sd *) gspca_dev; 572 573 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 574 reg_w(gspca_dev, 0xb6, sd->sharpness->val); 575 576 reg_w(gspca_dev, 0xdc, 0x01); 577 } 578 579 /* this function is called at probe and resume time for pac7302 */ 580 static int sd_init(struct gspca_dev *gspca_dev) 581 { 582 reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2); 583 return gspca_dev->usb_err; 584 } 585 586 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 587 { 588 struct gspca_dev *gspca_dev = 589 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 590 struct sd *sd = (struct sd *)gspca_dev; 591 592 gspca_dev->usb_err = 0; 593 594 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) { 595 /* when switching to autogain set defaults to make sure 596 we are on a valid point of the autogain gain / 597 exposure knee graph, and give this change time to 598 take effect before doing autogain. */ 599 gspca_dev->exposure->val = PAC7302_EXPOSURE_DEFAULT; 600 gspca_dev->gain->val = PAC7302_GAIN_DEFAULT; 601 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES; 602 } 603 604 if (!gspca_dev->streaming) 605 return 0; 606 607 switch (ctrl->id) { 608 case V4L2_CID_BRIGHTNESS: 609 setbrightcont(gspca_dev); 610 break; 611 case V4L2_CID_SATURATION: 612 setcolors(gspca_dev); 613 break; 614 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: 615 setwhitebalance(gspca_dev); 616 break; 617 case V4L2_CID_RED_BALANCE: 618 setredbalance(gspca_dev); 619 break; 620 case V4L2_CID_BLUE_BALANCE: 621 setbluebalance(gspca_dev); 622 break; 623 case V4L2_CID_AUTOGAIN: 624 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val)) 625 setexposure(gspca_dev); 626 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val)) 627 setgain(gspca_dev); 628 break; 629 case V4L2_CID_HFLIP: 630 sethvflip(gspca_dev); 631 break; 632 case V4L2_CID_SHARPNESS: 633 setsharpness(gspca_dev); 634 break; 635 default: 636 return -EINVAL; 637 } 638 return gspca_dev->usb_err; 639 } 640 641 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 642 .s_ctrl = sd_s_ctrl, 643 }; 644 645 /* this function is called at probe time */ 646 static int sd_init_controls(struct gspca_dev *gspca_dev) 647 { 648 struct sd *sd = (struct sd *) gspca_dev; 649 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 650 651 gspca_dev->vdev.ctrl_handler = hdl; 652 v4l2_ctrl_handler_init(hdl, 12); 653 654 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 655 V4L2_CID_BRIGHTNESS, 0, 32, 1, 16); 656 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 657 V4L2_CID_CONTRAST, 0, 255, 1, 127); 658 659 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 660 V4L2_CID_SATURATION, 0, 255, 1, 127); 661 sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 662 V4L2_CID_WHITE_BALANCE_TEMPERATURE, 663 0, 255, 1, 55); 664 sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 665 V4L2_CID_RED_BALANCE, 666 PAC7302_RGB_BALANCE_MIN, 667 PAC7302_RGB_BALANCE_MAX, 668 1, PAC7302_RGB_BALANCE_DEFAULT); 669 sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 670 V4L2_CID_BLUE_BALANCE, 671 PAC7302_RGB_BALANCE_MIN, 672 PAC7302_RGB_BALANCE_MAX, 673 1, PAC7302_RGB_BALANCE_DEFAULT); 674 675 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 676 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 677 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 678 V4L2_CID_EXPOSURE, 0, 1023, 1, 679 PAC7302_EXPOSURE_DEFAULT); 680 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 681 V4L2_CID_GAIN, 0, 62, 1, 682 PAC7302_GAIN_DEFAULT); 683 684 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 685 V4L2_CID_HFLIP, 0, 1, 1, 0); 686 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 687 V4L2_CID_VFLIP, 0, 1, 1, 0); 688 689 sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 690 V4L2_CID_SHARPNESS, 0, 15, 1, 8); 691 692 if (hdl->error) { 693 pr_err("Could not initialize controls\n"); 694 return hdl->error; 695 } 696 697 v4l2_ctrl_cluster(2, &sd->brightness); 698 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false); 699 v4l2_ctrl_cluster(2, &sd->hflip); 700 return 0; 701 } 702 703 /* -- start the camera -- */ 704 static int sd_start(struct gspca_dev *gspca_dev) 705 { 706 struct sd *sd = (struct sd *) gspca_dev; 707 708 reg_w_var(gspca_dev, start_7302, 709 page3_7302, sizeof(page3_7302)); 710 711 sd->sof_read = 0; 712 sd->autogain_ignore_frames = 0; 713 atomic_set(&sd->avg_lum, 270 + sd->brightness->val); 714 715 /* start stream */ 716 reg_w(gspca_dev, 0xff, 0x01); 717 reg_w(gspca_dev, 0x78, 0x01); 718 719 return gspca_dev->usb_err; 720 } 721 722 static void sd_stopN(struct gspca_dev *gspca_dev) 723 { 724 725 /* stop stream */ 726 reg_w(gspca_dev, 0xff, 0x01); 727 reg_w(gspca_dev, 0x78, 0x00); 728 } 729 730 /* called on streamoff with alt 0 and on disconnect for pac7302 */ 731 static void sd_stop0(struct gspca_dev *gspca_dev) 732 { 733 if (!gspca_dev->present) 734 return; 735 reg_w(gspca_dev, 0xff, 0x01); 736 reg_w(gspca_dev, 0x78, 0x40); 737 } 738 739 static void do_autogain(struct gspca_dev *gspca_dev) 740 { 741 struct sd *sd = (struct sd *) gspca_dev; 742 int avg_lum = atomic_read(&sd->avg_lum); 743 int desired_lum; 744 const int deadzone = 30; 745 746 if (sd->autogain_ignore_frames < 0) 747 return; 748 749 if (sd->autogain_ignore_frames > 0) { 750 sd->autogain_ignore_frames--; 751 } else { 752 desired_lum = 270 + sd->brightness->val; 753 754 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum, 755 deadzone, PAC7302_GAIN_KNEE, 756 PAC7302_EXPOSURE_KNEE)) 757 sd->autogain_ignore_frames = 758 PAC_AUTOGAIN_IGNORE_FRAMES; 759 } 760 } 761 762 /* JPEG header */ 763 static const u8 jpeg_header[] = { 764 0xff, 0xd8, /* SOI: Start of Image */ 765 766 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */ 767 0x00, 0x11, /* length = 17 bytes (including this length field) */ 768 0x08, /* Precision: 8 */ 769 0x02, 0x80, /* height = 640 (image rotated) */ 770 0x01, 0xe0, /* width = 480 */ 771 0x03, /* Number of image components: 3 */ 772 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */ 773 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */ 774 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */ 775 776 0xff, 0xda, /* SOS: Start Of Scan */ 777 0x00, 0x0c, /* length = 12 bytes (including this length field) */ 778 0x03, /* number of components: 3 */ 779 0x01, 0x00, /* selector 1, table 0x00 */ 780 0x02, 0x11, /* selector 2, table 0x11 */ 781 0x03, 0x11, /* selector 3, table 0x11 */ 782 0x00, 0x3f, /* Spectral selection: 0 .. 63 */ 783 0x00 /* Successive approximation: 0 */ 784 }; 785 786 /* this function is run at interrupt level */ 787 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 788 u8 *data, /* isoc packet */ 789 int len) /* iso packet length */ 790 { 791 struct sd *sd = (struct sd *) gspca_dev; 792 u8 *image; 793 u8 *sof; 794 795 sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len); 796 if (sof) { 797 int n, lum_offset, footer_length; 798 799 /* 800 * 6 bytes after the FF D9 EOF marker a number of lumination 801 * bytes are send corresponding to different parts of the 802 * image, the 14th and 15th byte after the EOF seem to 803 * correspond to the center of the image. 804 */ 805 lum_offset = 61 + sizeof pac_sof_marker; 806 footer_length = 74; 807 808 /* Finish decoding current frame */ 809 n = (sof - data) - (footer_length + sizeof pac_sof_marker); 810 if (n < 0) { 811 gspca_dev->image_len += n; 812 n = 0; 813 } else { 814 gspca_frame_add(gspca_dev, INTER_PACKET, data, n); 815 } 816 817 image = gspca_dev->image; 818 if (image != NULL 819 && image[gspca_dev->image_len - 2] == 0xff 820 && image[gspca_dev->image_len - 1] == 0xd9) 821 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 822 823 n = sof - data; 824 len -= n; 825 data = sof; 826 827 /* Get average lumination */ 828 if (gspca_dev->last_packet_type == LAST_PACKET && 829 n >= lum_offset) 830 atomic_set(&sd->avg_lum, data[-lum_offset] + 831 data[-lum_offset + 1]); 832 833 /* Start the new frame with the jpeg header */ 834 /* The PAC7302 has the image rotated 90 degrees */ 835 gspca_frame_add(gspca_dev, FIRST_PACKET, 836 jpeg_header, sizeof jpeg_header); 837 } 838 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 839 } 840 841 #ifdef CONFIG_VIDEO_ADV_DEBUG 842 static int sd_dbg_s_register(struct gspca_dev *gspca_dev, 843 const struct v4l2_dbg_register *reg) 844 { 845 u8 index; 846 u8 value; 847 848 /* 849 * reg->reg: bit0..15: reserved for register index (wIndex is 16bit 850 * long on the USB bus) 851 */ 852 if (reg->match.type == V4L2_CHIP_MATCH_HOST && 853 reg->match.addr == 0 && 854 (reg->reg < 0x000000ff) && 855 (reg->val <= 0x000000ff) 856 ) { 857 /* Currently writing to page 0 is only supported. */ 858 /* reg_w() only supports 8bit index */ 859 index = reg->reg; 860 value = reg->val; 861 862 /* 863 * Note that there shall be no access to other page 864 * by any other function between the page switch and 865 * the actual register write. 866 */ 867 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */ 868 reg_w(gspca_dev, index, value); 869 870 reg_w(gspca_dev, 0xdc, 0x01); 871 } 872 return gspca_dev->usb_err; 873 } 874 875 static int sd_chip_ident(struct gspca_dev *gspca_dev, 876 struct v4l2_dbg_chip_ident *chip) 877 { 878 int ret = -EINVAL; 879 880 if (chip->match.type == V4L2_CHIP_MATCH_HOST && 881 chip->match.addr == 0) { 882 chip->revision = 0; 883 chip->ident = V4L2_IDENT_UNKNOWN; 884 ret = 0; 885 } 886 return ret; 887 } 888 #endif 889 890 #if IS_ENABLED(CONFIG_INPUT) 891 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, 892 u8 *data, /* interrupt packet data */ 893 int len) /* interrput packet length */ 894 { 895 int ret = -EINVAL; 896 u8 data0, data1; 897 898 if (len == 2) { 899 data0 = data[0]; 900 data1 = data[1]; 901 if ((data0 == 0x00 && data1 == 0x11) || 902 (data0 == 0x22 && data1 == 0x33) || 903 (data0 == 0x44 && data1 == 0x55) || 904 (data0 == 0x66 && data1 == 0x77) || 905 (data0 == 0x88 && data1 == 0x99) || 906 (data0 == 0xaa && data1 == 0xbb) || 907 (data0 == 0xcc && data1 == 0xdd) || 908 (data0 == 0xee && data1 == 0xff)) { 909 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 910 input_sync(gspca_dev->input_dev); 911 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 912 input_sync(gspca_dev->input_dev); 913 ret = 0; 914 } 915 } 916 917 return ret; 918 } 919 #endif 920 921 /* sub-driver description for pac7302 */ 922 static const struct sd_desc sd_desc = { 923 .name = KBUILD_MODNAME, 924 .config = sd_config, 925 .init = sd_init, 926 .init_controls = sd_init_controls, 927 .start = sd_start, 928 .stopN = sd_stopN, 929 .stop0 = sd_stop0, 930 .pkt_scan = sd_pkt_scan, 931 .dq_callback = do_autogain, 932 #ifdef CONFIG_VIDEO_ADV_DEBUG 933 .set_register = sd_dbg_s_register, 934 .get_chip_ident = sd_chip_ident, 935 #endif 936 #if IS_ENABLED(CONFIG_INPUT) 937 .int_pkt_scan = sd_int_pkt_scan, 938 #endif 939 }; 940 941 /* -- module initialisation -- */ 942 static const struct usb_device_id device_table[] = { 943 {USB_DEVICE(0x06f8, 0x3009)}, 944 {USB_DEVICE(0x06f8, 0x301b)}, 945 {USB_DEVICE(0x093a, 0x2620)}, 946 {USB_DEVICE(0x093a, 0x2621)}, 947 {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP}, 948 {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP}, 949 {USB_DEVICE(0x093a, 0x2625)}, 950 {USB_DEVICE(0x093a, 0x2626)}, 951 {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP}, 952 {USB_DEVICE(0x093a, 0x2628)}, 953 {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP}, 954 {USB_DEVICE(0x093a, 0x262a)}, 955 {USB_DEVICE(0x093a, 0x262c)}, 956 {USB_DEVICE(0x145f, 0x013c)}, 957 {USB_DEVICE(0x1ae7, 0x2001)}, /* SpeedLink Snappy Mic SL-6825-SBK */ 958 {} 959 }; 960 MODULE_DEVICE_TABLE(usb, device_table); 961 962 /* -- device connect -- */ 963 static int sd_probe(struct usb_interface *intf, 964 const struct usb_device_id *id) 965 { 966 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 967 THIS_MODULE); 968 } 969 970 static struct usb_driver sd_driver = { 971 .name = KBUILD_MODNAME, 972 .id_table = device_table, 973 .probe = sd_probe, 974 .disconnect = gspca_disconnect, 975 #ifdef CONFIG_PM 976 .suspend = gspca_suspend, 977 .resume = gspca_resume, 978 .reset_resume = gspca_resume, 979 #endif 980 }; 981 982 module_usb_driver(sd_driver); 983