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