1 /* 2 * sonix sn9c102 (bayer) library 3 * 4 * Copyright (C) 2009-2011 Jean-François Moine <http://moinejf.free.fr> 5 * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr 6 * Add Pas106 Stefano Mozzi (C) 2004 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 /* Some documentation on known sonixb registers: 24 25 Reg Use 26 sn9c101 / sn9c102: 27 0x10 high nibble red gain low nibble blue gain 28 0x11 low nibble green gain 29 sn9c103: 30 0x05 red gain 0-127 31 0x06 blue gain 0-127 32 0x07 green gain 0-127 33 all: 34 0x08-0x0f i2c / 3wire registers 35 0x12 hstart 36 0x13 vstart 37 0x15 hsize (hsize = register-value * 16) 38 0x16 vsize (vsize = register-value * 16) 39 0x17 bit 0 toggle compression quality (according to sn9c102 driver) 40 0x18 bit 7 enables compression, bit 4-5 set image down scaling: 41 00 scale 1, 01 scale 1/2, 10, scale 1/4 42 0x19 high-nibble is sensor clock divider, changes exposure on sensors which 43 use a clock generated by the bridge. Some sensors have their own clock. 44 0x1c auto_exposure area (for avg_lum) startx (startx = register-value * 32) 45 0x1d auto_exposure area (for avg_lum) starty (starty = register-value * 32) 46 0x1e auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32) 47 0x1f auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32) 48 */ 49 50 #define MODULE_NAME "sonixb" 51 52 #include <linux/input.h> 53 #include "gspca.h" 54 55 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>"); 56 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver"); 57 MODULE_LICENSE("GPL"); 58 59 /* specific webcam descriptor */ 60 struct sd { 61 struct gspca_dev gspca_dev; /* !! must be the first item */ 62 63 struct v4l2_ctrl *brightness; 64 struct v4l2_ctrl *plfreq; 65 66 atomic_t avg_lum; 67 int prev_avg_lum; 68 int exposure_knee; 69 int header_read; 70 u8 header[12]; /* Header without sof marker */ 71 72 unsigned char autogain_ignore_frames; 73 unsigned char frames_to_drop; 74 75 __u8 bridge; /* Type of bridge */ 76 #define BRIDGE_101 0 77 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */ 78 #define BRIDGE_103 1 79 80 __u8 sensor; /* Type of image sensor chip */ 81 #define SENSOR_HV7131D 0 82 #define SENSOR_HV7131R 1 83 #define SENSOR_OV6650 2 84 #define SENSOR_OV7630 3 85 #define SENSOR_PAS106 4 86 #define SENSOR_PAS202 5 87 #define SENSOR_TAS5110C 6 88 #define SENSOR_TAS5110D 7 89 #define SENSOR_TAS5130CXX 8 90 __u8 reg11; 91 }; 92 93 typedef const __u8 sensor_init_t[8]; 94 95 struct sensor_data { 96 const __u8 *bridge_init; 97 sensor_init_t *sensor_init; 98 int sensor_init_size; 99 int flags; 100 __u8 sensor_addr; 101 }; 102 103 /* sensor_data flags */ 104 #define F_SIF 0x01 /* sif or vga */ 105 106 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */ 107 #define MODE_RAW 0x10 /* raw bayer mode */ 108 #define MODE_REDUCED_SIF 0x20 /* vga mode (320x240 / 160x120) on sif cam */ 109 110 #define COMP 0xc7 /* 0x87 //0x07 */ 111 #define COMP1 0xc9 /* 0x89 //0x09 */ 112 113 #define MCK_INIT 0x63 114 #define MCK_INIT1 0x20 /*fixme: Bayer - 0x50 for JPEG ??*/ 115 116 #define SYS_CLK 0x04 117 118 #define SENS(bridge, sensor, _flags, _sensor_addr) \ 119 { \ 120 .bridge_init = bridge, \ 121 .sensor_init = sensor, \ 122 .sensor_init_size = sizeof(sensor), \ 123 .flags = _flags, .sensor_addr = _sensor_addr \ 124 } 125 126 /* We calculate the autogain at the end of the transfer of a frame, at this 127 moment a frame with the old settings is being captured and transmitted. So 128 if we adjust the gain or exposure we must ignore atleast the next frame for 129 the new settings to come into effect before doing any other adjustments. */ 130 #define AUTOGAIN_IGNORE_FRAMES 1 131 132 static const struct v4l2_pix_format vga_mode[] = { 133 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 134 .bytesperline = 160, 135 .sizeimage = 160 * 120, 136 .colorspace = V4L2_COLORSPACE_SRGB, 137 .priv = 2 | MODE_RAW}, 138 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 139 .bytesperline = 160, 140 .sizeimage = 160 * 120 * 5 / 4, 141 .colorspace = V4L2_COLORSPACE_SRGB, 142 .priv = 2}, 143 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 144 .bytesperline = 320, 145 .sizeimage = 320 * 240 * 5 / 4, 146 .colorspace = V4L2_COLORSPACE_SRGB, 147 .priv = 1}, 148 {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 149 .bytesperline = 640, 150 .sizeimage = 640 * 480 * 5 / 4, 151 .colorspace = V4L2_COLORSPACE_SRGB, 152 .priv = 0}, 153 }; 154 static const struct v4l2_pix_format sif_mode[] = { 155 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 156 .bytesperline = 160, 157 .sizeimage = 160 * 120, 158 .colorspace = V4L2_COLORSPACE_SRGB, 159 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF}, 160 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 161 .bytesperline = 160, 162 .sizeimage = 160 * 120 * 5 / 4, 163 .colorspace = V4L2_COLORSPACE_SRGB, 164 .priv = 1 | MODE_REDUCED_SIF}, 165 {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 166 .bytesperline = 176, 167 .sizeimage = 176 * 144, 168 .colorspace = V4L2_COLORSPACE_SRGB, 169 .priv = 1 | MODE_RAW}, 170 {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 171 .bytesperline = 176, 172 .sizeimage = 176 * 144 * 5 / 4, 173 .colorspace = V4L2_COLORSPACE_SRGB, 174 .priv = 1}, 175 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 176 .bytesperline = 320, 177 .sizeimage = 320 * 240 * 5 / 4, 178 .colorspace = V4L2_COLORSPACE_SRGB, 179 .priv = 0 | MODE_REDUCED_SIF}, 180 {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE, 181 .bytesperline = 352, 182 .sizeimage = 352 * 288 * 5 / 4, 183 .colorspace = V4L2_COLORSPACE_SRGB, 184 .priv = 0}, 185 }; 186 187 static const __u8 initHv7131d[] = { 188 0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 189 0x00, 0x00, 190 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 191 0x28, 0x1e, 0x60, 0x8e, 0x42, 192 }; 193 static const __u8 hv7131d_sensor_init[][8] = { 194 {0xa0, 0x11, 0x01, 0x04, 0x00, 0x00, 0x00, 0x17}, 195 {0xa0, 0x11, 0x02, 0x00, 0x00, 0x00, 0x00, 0x17}, 196 {0xa0, 0x11, 0x28, 0x00, 0x00, 0x00, 0x00, 0x17}, 197 {0xa0, 0x11, 0x30, 0x30, 0x00, 0x00, 0x00, 0x17}, /* reset level */ 198 {0xa0, 0x11, 0x34, 0x02, 0x00, 0x00, 0x00, 0x17}, /* pixel bias volt */ 199 }; 200 201 static const __u8 initHv7131r[] = { 202 0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 203 0x00, 0x00, 204 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 205 0x28, 0x1e, 0x60, 0x8a, 0x20, 206 }; 207 static const __u8 hv7131r_sensor_init[][8] = { 208 {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10}, 209 {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10}, 210 {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10}, 211 {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16}, 212 {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15}, 213 }; 214 static const __u8 initOv6650[] = { 215 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 216 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 217 0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b, 218 0x10, 219 }; 220 static const __u8 ov6650_sensor_init[][8] = { 221 /* Bright, contrast, etc are set through SCBB interface. 222 * AVCAP on win2 do not send any data on this controls. */ 223 /* Anyway, some registers appears to alter bright and constrat */ 224 225 /* Reset sensor */ 226 {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, 227 /* Set clock register 0x11 low nibble is clock divider */ 228 {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10}, 229 /* Next some unknown stuff */ 230 {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10}, 231 /* {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10}, 232 * THIS SET GREEN SCREEN 233 * (pixels could be innverted in decode kind of "brg", 234 * but blue wont be there. Avoid this data ... */ 235 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */ 236 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, 237 {0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10}, 238 /* Enable rgb brightness control */ 239 {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10}, 240 /* HDG: Note windows uses the line below, which sets both register 0x60 241 and 0x61 I believe these registers of the ov6650 are identical as 242 those of the ov7630, because if this is true the windows settings 243 add a bit additional red gain and a lot additional blue gain, which 244 matches my findings that the windows settings make blue much too 245 blue and red a little too red. 246 {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */ 247 /* Some more unknown stuff */ 248 {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10}, 249 {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */ 250 }; 251 252 static const __u8 initOv7630[] = { 253 0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */ 254 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */ 255 0x00, 0x01, 0x01, 0x0a, /* r11 .. r14 */ 256 0x28, 0x1e, /* H & V sizes r15 .. r16 */ 257 0x68, 0x8f, MCK_INIT1, /* r17 .. r19 */ 258 }; 259 static const __u8 ov7630_sensor_init[][8] = { 260 {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, 261 {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10}, 262 /* {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10}, jfm */ 263 {0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10}, /* jfm */ 264 {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10}, 265 {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10}, 266 {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10}, 267 {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10}, 268 {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10}, 269 {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10}, 270 {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10}, 271 {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10}, 272 /* {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10}, * jfm */ 273 {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10}, 274 {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10}, 275 {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10}, 276 {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10}, 277 {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10}, 278 {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10}, 279 }; 280 281 static const __u8 initPas106[] = { 282 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00, 283 0x00, 0x00, 284 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 285 0x16, 0x12, 0x24, COMP1, MCK_INIT1, 286 }; 287 /* compression 0x86 mckinit1 0x2b */ 288 289 /* "Known" PAS106B registers: 290 0x02 clock divider 291 0x03 Variable framerate bits 4-11 292 0x04 Var framerate bits 0-3, one must leave the 4 msb's at 0 !! 293 The variable framerate control must never be set lower then 300, 294 which sets the framerate at 90 / reg02, otherwise vsync is lost. 295 0x05 Shutter Time Line Offset, this can be used as an exposure control: 296 0 = use full frame time, 255 = no exposure at all 297 Note this may never be larger then "var-framerate control" / 2 - 2. 298 When var-framerate control is < 514, no exposure is reached at the max 299 allowed value for the framerate control value, rather then at 255. 300 0x06 Shutter Time Pixel Offset, like reg05 this influences exposure, but 301 only a very little bit, leave at 0xcd 302 0x07 offset sign bit (bit0 1 > negative offset) 303 0x08 offset 304 0x09 Blue Gain 305 0x0a Green1 Gain 306 0x0b Green2 Gain 307 0x0c Red Gain 308 0x0e Global gain 309 0x13 Write 1 to commit settings to sensor 310 */ 311 312 static const __u8 pas106_sensor_init[][8] = { 313 /* Pixel Clock Divider 6 */ 314 { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 }, 315 /* Frame Time MSB (also seen as 0x12) */ 316 { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 }, 317 /* Frame Time LSB (also seen as 0x05) */ 318 { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 }, 319 /* Shutter Time Line Offset (also seen as 0x6d) */ 320 { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 }, 321 /* Shutter Time Pixel Offset (also seen as 0xb1) */ 322 { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 }, 323 /* Black Level Subtract Sign (also seen 0x00) */ 324 { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 }, 325 /* Black Level Subtract Level (also seen 0x01) */ 326 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 }, 327 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 }, 328 /* Color Gain B Pixel 5 a */ 329 { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 }, 330 /* Color Gain G1 Pixel 1 5 */ 331 { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 }, 332 /* Color Gain G2 Pixel 1 0 5 */ 333 { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 }, 334 /* Color Gain R Pixel 3 1 */ 335 { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 }, 336 /* Color GainH Pixel */ 337 { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 }, 338 /* Global Gain */ 339 { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 }, 340 /* Contrast */ 341 { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 }, 342 /* H&V synchro polarity */ 343 { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 }, 344 /* ?default */ 345 { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 }, 346 /* DAC scale */ 347 { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 }, 348 /* ?default */ 349 { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 }, 350 /* Validate Settings */ 351 { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 }, 352 }; 353 354 static const __u8 initPas202[] = { 355 0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00, 356 0x00, 0x00, 357 0x00, 0x00, 0x00, 0x06, 0x03, 0x0a, 358 0x28, 0x1e, 0x20, 0x89, 0x20, 359 }; 360 361 /* "Known" PAS202BCB registers: 362 0x02 clock divider 363 0x04 Variable framerate bits 6-11 (*) 364 0x05 Var framerate bits 0-5, one must leave the 2 msb's at 0 !! 365 0x07 Blue Gain 366 0x08 Green Gain 367 0x09 Red Gain 368 0x0b offset sign bit (bit0 1 > negative offset) 369 0x0c offset 370 0x0e Unknown image is slightly brighter when bit 0 is 0, if reg0f is 0 too, 371 leave at 1 otherwise we get a jump in our exposure control 372 0x0f Exposure 0-255, 0 = use full frame time, 255 = no exposure at all 373 0x10 Master gain 0 - 31 374 0x11 write 1 to apply changes 375 (*) The variable framerate control must never be set lower then 500 376 which sets the framerate at 30 / reg02, otherwise vsync is lost. 377 */ 378 static const __u8 pas202_sensor_init[][8] = { 379 /* Set the clock divider to 4 -> 30 / 4 = 7.5 fps, we would like 380 to set it lower, but for some reason the bridge starts missing 381 vsync's then */ 382 {0xa0, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x10}, 383 {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10}, 384 {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10}, 385 {0xd0, 0x40, 0x0c, 0x00, 0x0c, 0x01, 0x32, 0x10}, 386 {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10}, 387 {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10}, 388 {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10}, 389 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10}, 390 {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10}, 391 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10}, 392 }; 393 394 static const __u8 initTas5110c[] = { 395 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00, 396 0x00, 0x00, 397 0x00, 0x00, 0x00, 0x45, 0x09, 0x0a, 398 0x16, 0x12, 0x60, 0x86, 0x2b, 399 }; 400 /* Same as above, except a different hstart */ 401 static const __u8 initTas5110d[] = { 402 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00, 403 0x00, 0x00, 404 0x00, 0x00, 0x00, 0x41, 0x09, 0x0a, 405 0x16, 0x12, 0x60, 0x86, 0x2b, 406 }; 407 /* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */ 408 static const __u8 tas5110c_sensor_init[][8] = { 409 {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10}, 410 {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10}, 411 }; 412 /* Known TAS5110D registers 413 * reg02: gain, bit order reversed!! 0 == max gain, 255 == min gain 414 * reg03: bit3: vflip, bit4: ~hflip, bit7: ~gainboost (~ == inverted) 415 * Note: writing reg03 seems to only work when written together with 02 416 */ 417 static const __u8 tas5110d_sensor_init[][8] = { 418 {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */ 419 }; 420 421 static const __u8 initTas5130[] = { 422 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00, 423 0x00, 0x00, 424 0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a, 425 0x28, 0x1e, 0x60, COMP, MCK_INIT, 426 }; 427 static const __u8 tas5130_sensor_init[][8] = { 428 /* {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10}, 429 * shutter 0x47 short exposure? */ 430 {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10}, 431 /* shutter 0x01 long exposure */ 432 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10}, 433 }; 434 435 static const struct sensor_data sensor_data[] = { 436 SENS(initHv7131d, hv7131d_sensor_init, 0, 0), 437 SENS(initHv7131r, hv7131r_sensor_init, 0, 0), 438 SENS(initOv6650, ov6650_sensor_init, F_SIF, 0x60), 439 SENS(initOv7630, ov7630_sensor_init, 0, 0x21), 440 SENS(initPas106, pas106_sensor_init, F_SIF, 0), 441 SENS(initPas202, pas202_sensor_init, 0, 0), 442 SENS(initTas5110c, tas5110c_sensor_init, F_SIF, 0), 443 SENS(initTas5110d, tas5110d_sensor_init, F_SIF, 0), 444 SENS(initTas5130, tas5130_sensor_init, 0, 0), 445 }; 446 447 /* get one byte in gspca_dev->usb_buf */ 448 static void reg_r(struct gspca_dev *gspca_dev, 449 __u16 value) 450 { 451 int res; 452 453 if (gspca_dev->usb_err < 0) 454 return; 455 456 res = usb_control_msg(gspca_dev->dev, 457 usb_rcvctrlpipe(gspca_dev->dev, 0), 458 0, /* request */ 459 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 460 value, 461 0, /* index */ 462 gspca_dev->usb_buf, 1, 463 500); 464 465 if (res < 0) { 466 dev_err(gspca_dev->v4l2_dev.dev, 467 "Error reading register %02x: %d\n", value, res); 468 gspca_dev->usb_err = res; 469 } 470 } 471 472 static void reg_w(struct gspca_dev *gspca_dev, 473 __u16 value, 474 const __u8 *buffer, 475 int len) 476 { 477 int res; 478 479 if (gspca_dev->usb_err < 0) 480 return; 481 482 memcpy(gspca_dev->usb_buf, buffer, len); 483 res = usb_control_msg(gspca_dev->dev, 484 usb_sndctrlpipe(gspca_dev->dev, 0), 485 0x08, /* request */ 486 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 487 value, 488 0, /* index */ 489 gspca_dev->usb_buf, len, 490 500); 491 492 if (res < 0) { 493 dev_err(gspca_dev->v4l2_dev.dev, 494 "Error writing register %02x: %d\n", value, res); 495 gspca_dev->usb_err = res; 496 } 497 } 498 499 static void i2c_w(struct gspca_dev *gspca_dev, const u8 *buf) 500 { 501 int retry = 60; 502 503 if (gspca_dev->usb_err < 0) 504 return; 505 506 /* is i2c ready */ 507 reg_w(gspca_dev, 0x08, buf, 8); 508 while (retry--) { 509 if (gspca_dev->usb_err < 0) 510 return; 511 msleep(1); 512 reg_r(gspca_dev, 0x08); 513 if (gspca_dev->usb_buf[0] & 0x04) { 514 if (gspca_dev->usb_buf[0] & 0x08) { 515 dev_err(gspca_dev->v4l2_dev.dev, 516 "i2c error writing %02x %02x %02x %02x" 517 " %02x %02x %02x %02x\n", 518 buf[0], buf[1], buf[2], buf[3], 519 buf[4], buf[5], buf[6], buf[7]); 520 gspca_dev->usb_err = -EIO; 521 } 522 return; 523 } 524 } 525 526 dev_err(gspca_dev->v4l2_dev.dev, "i2c write timeout\n"); 527 gspca_dev->usb_err = -EIO; 528 } 529 530 static void i2c_w_vector(struct gspca_dev *gspca_dev, 531 const __u8 buffer[][8], int len) 532 { 533 for (;;) { 534 if (gspca_dev->usb_err < 0) 535 return; 536 i2c_w(gspca_dev, *buffer); 537 len -= 8; 538 if (len <= 0) 539 break; 540 buffer++; 541 } 542 } 543 544 static void setbrightness(struct gspca_dev *gspca_dev) 545 { 546 struct sd *sd = (struct sd *) gspca_dev; 547 548 switch (sd->sensor) { 549 case SENSOR_OV6650: 550 case SENSOR_OV7630: { 551 __u8 i2cOV[] = 552 {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10}; 553 554 /* change reg 0x06 */ 555 i2cOV[1] = sensor_data[sd->sensor].sensor_addr; 556 i2cOV[3] = sd->brightness->val; 557 i2c_w(gspca_dev, i2cOV); 558 break; 559 } 560 case SENSOR_PAS106: 561 case SENSOR_PAS202: { 562 __u8 i2cpbright[] = 563 {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16}; 564 __u8 i2cpdoit[] = 565 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16}; 566 567 /* PAS106 uses reg 7 and 8 instead of b and c */ 568 if (sd->sensor == SENSOR_PAS106) { 569 i2cpbright[2] = 7; 570 i2cpdoit[2] = 0x13; 571 } 572 573 if (sd->brightness->val < 127) { 574 /* change reg 0x0b, signreg */ 575 i2cpbright[3] = 0x01; 576 /* set reg 0x0c, offset */ 577 i2cpbright[4] = 127 - sd->brightness->val; 578 } else 579 i2cpbright[4] = sd->brightness->val - 127; 580 581 i2c_w(gspca_dev, i2cpbright); 582 i2c_w(gspca_dev, i2cpdoit); 583 break; 584 } 585 default: 586 break; 587 } 588 } 589 590 static void setgain(struct gspca_dev *gspca_dev) 591 { 592 struct sd *sd = (struct sd *) gspca_dev; 593 u8 gain = gspca_dev->gain->val; 594 595 switch (sd->sensor) { 596 case SENSOR_HV7131D: { 597 __u8 i2c[] = 598 {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17}; 599 600 i2c[3] = 0x3f - gain; 601 i2c[4] = 0x3f - gain; 602 i2c[5] = 0x3f - gain; 603 604 i2c_w(gspca_dev, i2c); 605 break; 606 } 607 case SENSOR_TAS5110C: 608 case SENSOR_TAS5130CXX: { 609 __u8 i2c[] = 610 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10}; 611 612 i2c[4] = 255 - gain; 613 i2c_w(gspca_dev, i2c); 614 break; 615 } 616 case SENSOR_TAS5110D: { 617 __u8 i2c[] = { 618 0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 }; 619 gain = 255 - gain; 620 /* The bits in the register are the wrong way around!! */ 621 i2c[3] |= (gain & 0x80) >> 7; 622 i2c[3] |= (gain & 0x40) >> 5; 623 i2c[3] |= (gain & 0x20) >> 3; 624 i2c[3] |= (gain & 0x10) >> 1; 625 i2c[3] |= (gain & 0x08) << 1; 626 i2c[3] |= (gain & 0x04) << 3; 627 i2c[3] |= (gain & 0x02) << 5; 628 i2c[3] |= (gain & 0x01) << 7; 629 i2c_w(gspca_dev, i2c); 630 break; 631 } 632 case SENSOR_OV6650: 633 case SENSOR_OV7630: { 634 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; 635 636 /* 637 * The ov7630's gain is weird, at 32 the gain drops to the 638 * same level as at 16, so skip 32-47 (of the 0-63 scale). 639 */ 640 if (sd->sensor == SENSOR_OV7630 && gain >= 32) 641 gain += 16; 642 643 i2c[1] = sensor_data[sd->sensor].sensor_addr; 644 i2c[3] = gain; 645 i2c_w(gspca_dev, i2c); 646 break; 647 } 648 case SENSOR_PAS106: 649 case SENSOR_PAS202: { 650 __u8 i2cpgain[] = 651 {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15}; 652 __u8 i2cpcolorgain[] = 653 {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15}; 654 __u8 i2cpdoit[] = 655 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16}; 656 657 /* PAS106 uses different regs (and has split green gains) */ 658 if (sd->sensor == SENSOR_PAS106) { 659 i2cpgain[2] = 0x0e; 660 i2cpcolorgain[0] = 0xd0; 661 i2cpcolorgain[2] = 0x09; 662 i2cpdoit[2] = 0x13; 663 } 664 665 i2cpgain[3] = gain; 666 i2cpcolorgain[3] = gain >> 1; 667 i2cpcolorgain[4] = gain >> 1; 668 i2cpcolorgain[5] = gain >> 1; 669 i2cpcolorgain[6] = gain >> 1; 670 671 i2c_w(gspca_dev, i2cpgain); 672 i2c_w(gspca_dev, i2cpcolorgain); 673 i2c_w(gspca_dev, i2cpdoit); 674 break; 675 } 676 default: 677 if (sd->bridge == BRIDGE_103) { 678 u8 buf[3] = { gain, gain, gain }; /* R, G, B */ 679 reg_w(gspca_dev, 0x05, buf, 3); 680 } else { 681 u8 buf[2]; 682 buf[0] = gain << 4 | gain; /* Red and blue */ 683 buf[1] = gain; /* Green */ 684 reg_w(gspca_dev, 0x10, buf, 2); 685 } 686 } 687 } 688 689 static void setexposure(struct gspca_dev *gspca_dev) 690 { 691 struct sd *sd = (struct sd *) gspca_dev; 692 693 switch (sd->sensor) { 694 case SENSOR_HV7131D: { 695 /* Note the datasheet wrongly says line mode exposure uses reg 696 0x26 and 0x27, testing has shown 0x25 + 0x26 */ 697 __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17}; 698 u16 reg = gspca_dev->exposure->val; 699 700 i2c[3] = reg >> 8; 701 i2c[4] = reg & 0xff; 702 i2c_w(gspca_dev, i2c); 703 break; 704 } 705 case SENSOR_TAS5110C: 706 case SENSOR_TAS5110D: { 707 /* register 19's high nibble contains the sn9c10x clock divider 708 The high nibble configures the no fps according to the 709 formula: 60 / high_nibble. With a maximum of 30 fps */ 710 u8 reg = gspca_dev->exposure->val; 711 712 reg = (reg << 4) | 0x0b; 713 reg_w(gspca_dev, 0x19, ®, 1); 714 break; 715 } 716 case SENSOR_OV6650: 717 case SENSOR_OV7630: { 718 /* The ov6650 / ov7630 have 2 registers which both influence 719 exposure, register 11, whose low nibble sets the nr off fps 720 according to: fps = 30 / (low_nibble + 1) 721 722 The fps configures the maximum exposure setting, but it is 723 possible to use less exposure then what the fps maximum 724 allows by setting register 10. register 10 configures the 725 actual exposure as quotient of the full exposure, with 0 726 being no exposure at all (not very useful) and reg10_max 727 being max exposure possible at that framerate. 728 729 The code maps our 0 - 510 ms exposure ctrl to these 2 730 registers, trying to keep fps as high as possible. 731 */ 732 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10}; 733 int reg10, reg11, reg10_max; 734 735 /* ov6645 datasheet says reg10_max is 9a, but that uses 736 tline * 2 * reg10 as formula for calculating texpo, the 737 ov6650 probably uses the same formula as the 7730 which uses 738 tline * 4 * reg10, which explains why the reg10max we've 739 found experimentally for the ov6650 is exactly half that of 740 the ov6645. The ov7630 datasheet says the max is 0x41. */ 741 if (sd->sensor == SENSOR_OV6650) { 742 reg10_max = 0x4d; 743 i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */ 744 } else 745 reg10_max = 0x41; 746 747 reg11 = (15 * gspca_dev->exposure->val + 999) / 1000; 748 if (reg11 < 1) 749 reg11 = 1; 750 else if (reg11 > 16) 751 reg11 = 16; 752 753 /* In 640x480, if the reg11 has less than 4, the image is 754 unstable (the bridge goes into a higher compression mode 755 which we have not reverse engineered yet). */ 756 if (gspca_dev->width == 640 && reg11 < 4) 757 reg11 = 4; 758 759 /* frame exposure time in ms = 1000 * reg11 / 30 -> 760 reg10 = (gspca_dev->exposure->val / 2) * reg10_max 761 / (1000 * reg11 / 30) */ 762 reg10 = (gspca_dev->exposure->val * 15 * reg10_max) 763 / (1000 * reg11); 764 765 /* Don't allow this to get below 10 when using autogain, the 766 steps become very large (relatively) when below 10 causing 767 the image to oscilate from much too dark, to much too bright 768 and back again. */ 769 if (gspca_dev->autogain->val && reg10 < 10) 770 reg10 = 10; 771 else if (reg10 > reg10_max) 772 reg10 = reg10_max; 773 774 /* Write reg 10 and reg11 low nibble */ 775 i2c[1] = sensor_data[sd->sensor].sensor_addr; 776 i2c[3] = reg10; 777 i2c[4] |= reg11 - 1; 778 779 /* If register 11 didn't change, don't change it */ 780 if (sd->reg11 == reg11) 781 i2c[0] = 0xa0; 782 783 i2c_w(gspca_dev, i2c); 784 if (gspca_dev->usb_err == 0) 785 sd->reg11 = reg11; 786 break; 787 } 788 case SENSOR_PAS202: { 789 __u8 i2cpframerate[] = 790 {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16}; 791 __u8 i2cpexpo[] = 792 {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16}; 793 const __u8 i2cpdoit[] = 794 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16}; 795 int framerate_ctrl; 796 797 /* The exposure knee for the autogain algorithm is 200 798 (100 ms / 10 fps on other sensors), for values below this 799 use the control for setting the partial frame expose time, 800 above that use variable framerate. This way we run at max 801 framerate (640x480@7.5 fps, 320x240@10fps) until the knee 802 is reached. Using the variable framerate control above 200 803 is better then playing around with both clockdiv + partial 804 frame exposure times (like we are doing with the ov chips), 805 as that sometimes leads to jumps in the exposure control, 806 which are bad for auto exposure. */ 807 if (gspca_dev->exposure->val < 200) { 808 i2cpexpo[3] = 255 - (gspca_dev->exposure->val * 255) 809 / 200; 810 framerate_ctrl = 500; 811 } else { 812 /* The PAS202's exposure control goes from 0 - 4095, 813 but anything below 500 causes vsync issues, so scale 814 our 200-1023 to 500-4095 */ 815 framerate_ctrl = (gspca_dev->exposure->val - 200) 816 * 1000 / 229 + 500; 817 } 818 819 i2cpframerate[3] = framerate_ctrl >> 6; 820 i2cpframerate[4] = framerate_ctrl & 0x3f; 821 i2c_w(gspca_dev, i2cpframerate); 822 i2c_w(gspca_dev, i2cpexpo); 823 i2c_w(gspca_dev, i2cpdoit); 824 break; 825 } 826 case SENSOR_PAS106: { 827 __u8 i2cpframerate[] = 828 {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14}; 829 __u8 i2cpexpo[] = 830 {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14}; 831 const __u8 i2cpdoit[] = 832 {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14}; 833 int framerate_ctrl; 834 835 /* For values below 150 use partial frame exposure, above 836 that use framerate ctrl */ 837 if (gspca_dev->exposure->val < 150) { 838 i2cpexpo[3] = 150 - gspca_dev->exposure->val; 839 framerate_ctrl = 300; 840 } else { 841 /* The PAS106's exposure control goes from 0 - 4095, 842 but anything below 300 causes vsync issues, so scale 843 our 150-1023 to 300-4095 */ 844 framerate_ctrl = (gspca_dev->exposure->val - 150) 845 * 1000 / 230 + 300; 846 } 847 848 i2cpframerate[3] = framerate_ctrl >> 4; 849 i2cpframerate[4] = framerate_ctrl & 0x0f; 850 i2c_w(gspca_dev, i2cpframerate); 851 i2c_w(gspca_dev, i2cpexpo); 852 i2c_w(gspca_dev, i2cpdoit); 853 break; 854 } 855 default: 856 break; 857 } 858 } 859 860 static void setfreq(struct gspca_dev *gspca_dev) 861 { 862 struct sd *sd = (struct sd *) gspca_dev; 863 864 if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630) { 865 /* Framerate adjust register for artificial light 50 hz flicker 866 compensation, for the ov6650 this is identical to ov6630 867 0x2b register, see ov6630 datasheet. 868 0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */ 869 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}; 870 switch (sd->plfreq->val) { 871 default: 872 /* case 0: * no filter*/ 873 /* case 2: * 60 hz */ 874 i2c[3] = 0; 875 break; 876 case 1: /* 50 hz */ 877 i2c[3] = (sd->sensor == SENSOR_OV6650) 878 ? 0x4f : 0x8a; 879 break; 880 } 881 i2c[1] = sensor_data[sd->sensor].sensor_addr; 882 i2c_w(gspca_dev, i2c); 883 } 884 } 885 886 static void do_autogain(struct gspca_dev *gspca_dev) 887 { 888 struct sd *sd = (struct sd *) gspca_dev; 889 int deadzone, desired_avg_lum, avg_lum; 890 891 avg_lum = atomic_read(&sd->avg_lum); 892 if (avg_lum == -1) 893 return; 894 895 if (sd->autogain_ignore_frames > 0) { 896 sd->autogain_ignore_frames--; 897 return; 898 } 899 900 /* SIF / VGA sensors have a different autoexposure area and thus 901 different avg_lum values for the same picture brightness */ 902 if (sensor_data[sd->sensor].flags & F_SIF) { 903 deadzone = 500; 904 /* SIF sensors tend to overexpose, so keep this small */ 905 desired_avg_lum = 5000; 906 } else { 907 deadzone = 1500; 908 desired_avg_lum = 13000; 909 } 910 911 if (sd->brightness) 912 desired_avg_lum = sd->brightness->val * desired_avg_lum / 127; 913 914 if (gspca_dev->exposure->maximum < 500) { 915 if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum, 916 desired_avg_lum, deadzone)) 917 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES; 918 } else { 919 int gain_knee = gspca_dev->gain->maximum * 9 / 10; 920 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_avg_lum, 921 deadzone, gain_knee, sd->exposure_knee)) 922 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES; 923 } 924 } 925 926 /* this function is called at probe time */ 927 static int sd_config(struct gspca_dev *gspca_dev, 928 const struct usb_device_id *id) 929 { 930 struct sd *sd = (struct sd *) gspca_dev; 931 struct cam *cam; 932 933 reg_r(gspca_dev, 0x00); 934 if (gspca_dev->usb_buf[0] != 0x10) 935 return -ENODEV; 936 937 /* copy the webcam info from the device id */ 938 sd->sensor = id->driver_info >> 8; 939 sd->bridge = id->driver_info & 0xff; 940 941 cam = &gspca_dev->cam; 942 if (!(sensor_data[sd->sensor].flags & F_SIF)) { 943 cam->cam_mode = vga_mode; 944 cam->nmodes = ARRAY_SIZE(vga_mode); 945 } else { 946 cam->cam_mode = sif_mode; 947 cam->nmodes = ARRAY_SIZE(sif_mode); 948 } 949 cam->npkt = 36; /* 36 packets per ISOC message */ 950 951 return 0; 952 } 953 954 /* this function is called at probe and resume time */ 955 static int sd_init(struct gspca_dev *gspca_dev) 956 { 957 const __u8 stop = 0x09; /* Disable stream turn of LED */ 958 959 reg_w(gspca_dev, 0x01, &stop, 1); 960 961 return gspca_dev->usb_err; 962 } 963 964 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 965 { 966 struct gspca_dev *gspca_dev = 967 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 968 struct sd *sd = (struct sd *)gspca_dev; 969 970 gspca_dev->usb_err = 0; 971 972 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) { 973 /* when switching to autogain set defaults to make sure 974 we are on a valid point of the autogain gain / 975 exposure knee graph, and give this change time to 976 take effect before doing autogain. */ 977 gspca_dev->gain->val = gspca_dev->gain->default_value; 978 gspca_dev->exposure->val = gspca_dev->exposure->default_value; 979 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES; 980 } 981 982 if (!gspca_dev->streaming) 983 return 0; 984 985 switch (ctrl->id) { 986 case V4L2_CID_BRIGHTNESS: 987 setbrightness(gspca_dev); 988 break; 989 case V4L2_CID_AUTOGAIN: 990 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val)) 991 setexposure(gspca_dev); 992 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val)) 993 setgain(gspca_dev); 994 break; 995 case V4L2_CID_POWER_LINE_FREQUENCY: 996 setfreq(gspca_dev); 997 break; 998 default: 999 return -EINVAL; 1000 } 1001 return gspca_dev->usb_err; 1002 } 1003 1004 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 1005 .s_ctrl = sd_s_ctrl, 1006 }; 1007 1008 /* this function is called at probe time */ 1009 static int sd_init_controls(struct gspca_dev *gspca_dev) 1010 { 1011 struct sd *sd = (struct sd *) gspca_dev; 1012 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 1013 1014 gspca_dev->vdev.ctrl_handler = hdl; 1015 v4l2_ctrl_handler_init(hdl, 5); 1016 1017 if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630 || 1018 sd->sensor == SENSOR_PAS106 || sd->sensor == SENSOR_PAS202) 1019 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1020 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127); 1021 1022 /* Gain range is sensor dependent */ 1023 switch (sd->sensor) { 1024 case SENSOR_OV6650: 1025 case SENSOR_PAS106: 1026 case SENSOR_PAS202: 1027 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1028 V4L2_CID_GAIN, 0, 31, 1, 15); 1029 break; 1030 case SENSOR_OV7630: 1031 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1032 V4L2_CID_GAIN, 0, 47, 1, 31); 1033 break; 1034 case SENSOR_HV7131D: 1035 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1036 V4L2_CID_GAIN, 0, 63, 1, 31); 1037 break; 1038 case SENSOR_TAS5110C: 1039 case SENSOR_TAS5110D: 1040 case SENSOR_TAS5130CXX: 1041 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1042 V4L2_CID_GAIN, 0, 255, 1, 127); 1043 break; 1044 default: 1045 if (sd->bridge == BRIDGE_103) { 1046 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1047 V4L2_CID_GAIN, 0, 127, 1, 63); 1048 } else { 1049 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1050 V4L2_CID_GAIN, 0, 15, 1, 7); 1051 } 1052 } 1053 1054 /* Exposure range is sensor dependent, and not all have exposure */ 1055 switch (sd->sensor) { 1056 case SENSOR_HV7131D: 1057 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1058 V4L2_CID_EXPOSURE, 0, 8191, 1, 482); 1059 sd->exposure_knee = 964; 1060 break; 1061 case SENSOR_OV6650: 1062 case SENSOR_OV7630: 1063 case SENSOR_PAS106: 1064 case SENSOR_PAS202: 1065 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1066 V4L2_CID_EXPOSURE, 0, 1023, 1, 66); 1067 sd->exposure_knee = 200; 1068 break; 1069 case SENSOR_TAS5110C: 1070 case SENSOR_TAS5110D: 1071 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1072 V4L2_CID_EXPOSURE, 2, 15, 1, 2); 1073 break; 1074 } 1075 1076 if (gspca_dev->exposure) { 1077 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1078 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 1079 } 1080 1081 if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630) 1082 sd->plfreq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops, 1083 V4L2_CID_POWER_LINE_FREQUENCY, 1084 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0, 1085 V4L2_CID_POWER_LINE_FREQUENCY_DISABLED); 1086 1087 if (hdl->error) { 1088 pr_err("Could not initialize controls\n"); 1089 return hdl->error; 1090 } 1091 1092 if (gspca_dev->autogain) 1093 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false); 1094 1095 return 0; 1096 } 1097 1098 /* -- start the camera -- */ 1099 static int sd_start(struct gspca_dev *gspca_dev) 1100 { 1101 struct sd *sd = (struct sd *) gspca_dev; 1102 struct cam *cam = &gspca_dev->cam; 1103 int i, mode; 1104 __u8 regs[0x31]; 1105 1106 mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07; 1107 /* Copy registers 0x01 - 0x19 from the template */ 1108 memcpy(®s[0x01], sensor_data[sd->sensor].bridge_init, 0x19); 1109 /* Set the mode */ 1110 regs[0x18] |= mode << 4; 1111 1112 /* Set bridge gain to 1.0 */ 1113 if (sd->bridge == BRIDGE_103) { 1114 regs[0x05] = 0x20; /* Red */ 1115 regs[0x06] = 0x20; /* Green */ 1116 regs[0x07] = 0x20; /* Blue */ 1117 } else { 1118 regs[0x10] = 0x00; /* Red and blue */ 1119 regs[0x11] = 0x00; /* Green */ 1120 } 1121 1122 /* Setup pixel numbers and auto exposure window */ 1123 if (sensor_data[sd->sensor].flags & F_SIF) { 1124 regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */ 1125 regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */ 1126 regs[0x1c] = 0x02; /* AE H-start 64 */ 1127 regs[0x1d] = 0x02; /* AE V-start 64 */ 1128 regs[0x1e] = 0x09; /* AE H-end 288 */ 1129 regs[0x1f] = 0x07; /* AE V-end 224 */ 1130 } else { 1131 regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */ 1132 regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */ 1133 regs[0x1c] = 0x05; /* AE H-start 160 */ 1134 regs[0x1d] = 0x03; /* AE V-start 96 */ 1135 regs[0x1e] = 0x0f; /* AE H-end 480 */ 1136 regs[0x1f] = 0x0c; /* AE V-end 384 */ 1137 } 1138 1139 /* Setup the gamma table (only used with the sn9c103 bridge) */ 1140 for (i = 0; i < 16; i++) 1141 regs[0x20 + i] = i * 16; 1142 regs[0x20 + i] = 255; 1143 1144 /* Special cases where some regs depend on mode or bridge */ 1145 switch (sd->sensor) { 1146 case SENSOR_TAS5130CXX: 1147 /* FIXME / TESTME 1148 probably not mode specific at all most likely the upper 1149 nibble of 0x19 is exposure (clock divider) just as with 1150 the tas5110, we need someone to test this. */ 1151 regs[0x19] = mode ? 0x23 : 0x43; 1152 break; 1153 case SENSOR_OV7630: 1154 /* FIXME / TESTME for some reason with the 101/102 bridge the 1155 clock is set to 12 Mhz (reg1 == 0x04), rather then 24. 1156 Also the hstart needs to go from 1 to 2 when using a 103, 1157 which is likely related. This does not seem right. */ 1158 if (sd->bridge == BRIDGE_103) { 1159 regs[0x01] = 0x44; /* Select 24 Mhz clock */ 1160 regs[0x12] = 0x02; /* Set hstart to 2 */ 1161 } 1162 break; 1163 case SENSOR_PAS202: 1164 /* For some unknown reason we need to increase hstart by 1 on 1165 the sn9c103, otherwise we get wrong colors (bayer shift). */ 1166 if (sd->bridge == BRIDGE_103) 1167 regs[0x12] += 1; 1168 break; 1169 } 1170 /* Disable compression when the raw bayer format has been selected */ 1171 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) 1172 regs[0x18] &= ~0x80; 1173 1174 /* Vga mode emulation on SIF sensor? */ 1175 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) { 1176 regs[0x12] += 16; /* hstart adjust */ 1177 regs[0x13] += 24; /* vstart adjust */ 1178 regs[0x15] = 320 / 16; /* hsize */ 1179 regs[0x16] = 240 / 16; /* vsize */ 1180 } 1181 1182 /* reg 0x01 bit 2 video transfert on */ 1183 reg_w(gspca_dev, 0x01, ®s[0x01], 1); 1184 /* reg 0x17 SensorClk enable inv Clk 0x60 */ 1185 reg_w(gspca_dev, 0x17, ®s[0x17], 1); 1186 /* Set the registers from the template */ 1187 reg_w(gspca_dev, 0x01, ®s[0x01], 1188 (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f); 1189 1190 /* Init the sensor */ 1191 i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init, 1192 sensor_data[sd->sensor].sensor_init_size); 1193 1194 /* Mode / bridge specific sensor setup */ 1195 switch (sd->sensor) { 1196 case SENSOR_PAS202: { 1197 const __u8 i2cpclockdiv[] = 1198 {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10}; 1199 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */ 1200 if (mode) 1201 i2c_w(gspca_dev, i2cpclockdiv); 1202 break; 1203 } 1204 case SENSOR_OV7630: 1205 /* FIXME / TESTME We should be able to handle this identical 1206 for the 101/102 and the 103 case */ 1207 if (sd->bridge == BRIDGE_103) { 1208 const __u8 i2c[] = { 0xa0, 0x21, 0x13, 1209 0x80, 0x00, 0x00, 0x00, 0x10 }; 1210 i2c_w(gspca_dev, i2c); 1211 } 1212 break; 1213 } 1214 /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */ 1215 reg_w(gspca_dev, 0x15, ®s[0x15], 2); 1216 /* compression register */ 1217 reg_w(gspca_dev, 0x18, ®s[0x18], 1); 1218 /* H_start */ 1219 reg_w(gspca_dev, 0x12, ®s[0x12], 1); 1220 /* V_START */ 1221 reg_w(gspca_dev, 0x13, ®s[0x13], 1); 1222 /* reset 0x17 SensorClk enable inv Clk 0x60 */ 1223 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/ 1224 reg_w(gspca_dev, 0x17, ®s[0x17], 1); 1225 /*MCKSIZE ->3 */ /*fixme: not ov7630*/ 1226 reg_w(gspca_dev, 0x19, ®s[0x19], 1); 1227 /* AE_STRX AE_STRY AE_ENDX AE_ENDY */ 1228 reg_w(gspca_dev, 0x1c, ®s[0x1c], 4); 1229 /* Enable video transfert */ 1230 reg_w(gspca_dev, 0x01, ®s[0x01], 1); 1231 /* Compression */ 1232 reg_w(gspca_dev, 0x18, ®s[0x18], 2); 1233 msleep(20); 1234 1235 sd->reg11 = -1; 1236 1237 setgain(gspca_dev); 1238 setbrightness(gspca_dev); 1239 setexposure(gspca_dev); 1240 setfreq(gspca_dev); 1241 1242 sd->frames_to_drop = 0; 1243 sd->autogain_ignore_frames = 0; 1244 gspca_dev->exp_too_high_cnt = 0; 1245 gspca_dev->exp_too_low_cnt = 0; 1246 atomic_set(&sd->avg_lum, -1); 1247 return gspca_dev->usb_err; 1248 } 1249 1250 static void sd_stopN(struct gspca_dev *gspca_dev) 1251 { 1252 sd_init(gspca_dev); 1253 } 1254 1255 static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len) 1256 { 1257 struct sd *sd = (struct sd *) gspca_dev; 1258 int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12; 1259 1260 /* frames start with: 1261 * ff ff 00 c4 c4 96 synchro 1262 * 00 (unknown) 1263 * xx (frame sequence / size / compression) 1264 * (xx) (idem - extra byte for sn9c103) 1265 * ll mm brightness sum inside auto exposure 1266 * ll mm brightness sum outside auto exposure 1267 * (xx xx xx xx xx) audio values for snc103 1268 */ 1269 for (i = 0; i < len; i++) { 1270 switch (sd->header_read) { 1271 case 0: 1272 if (data[i] == 0xff) 1273 sd->header_read++; 1274 break; 1275 case 1: 1276 if (data[i] == 0xff) 1277 sd->header_read++; 1278 else 1279 sd->header_read = 0; 1280 break; 1281 case 2: 1282 if (data[i] == 0x00) 1283 sd->header_read++; 1284 else if (data[i] != 0xff) 1285 sd->header_read = 0; 1286 break; 1287 case 3: 1288 if (data[i] == 0xc4) 1289 sd->header_read++; 1290 else if (data[i] == 0xff) 1291 sd->header_read = 1; 1292 else 1293 sd->header_read = 0; 1294 break; 1295 case 4: 1296 if (data[i] == 0xc4) 1297 sd->header_read++; 1298 else if (data[i] == 0xff) 1299 sd->header_read = 1; 1300 else 1301 sd->header_read = 0; 1302 break; 1303 case 5: 1304 if (data[i] == 0x96) 1305 sd->header_read++; 1306 else if (data[i] == 0xff) 1307 sd->header_read = 1; 1308 else 1309 sd->header_read = 0; 1310 break; 1311 default: 1312 sd->header[sd->header_read - 6] = data[i]; 1313 sd->header_read++; 1314 if (sd->header_read == header_size) { 1315 sd->header_read = 0; 1316 return data + i + 1; 1317 } 1318 } 1319 } 1320 return NULL; 1321 } 1322 1323 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 1324 u8 *data, /* isoc packet */ 1325 int len) /* iso packet length */ 1326 { 1327 int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0; 1328 struct sd *sd = (struct sd *) gspca_dev; 1329 struct cam *cam = &gspca_dev->cam; 1330 u8 *sof; 1331 1332 sof = find_sof(gspca_dev, data, len); 1333 if (sof) { 1334 if (sd->bridge == BRIDGE_103) { 1335 fr_h_sz = 18; 1336 lum_offset = 3; 1337 } else { 1338 fr_h_sz = 12; 1339 lum_offset = 2; 1340 } 1341 1342 len_after_sof = len - (sof - data); 1343 len = (sof - data) - fr_h_sz; 1344 if (len < 0) 1345 len = 0; 1346 } 1347 1348 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) { 1349 /* In raw mode we sometimes get some garbage after the frame 1350 ignore this */ 1351 int used; 1352 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage; 1353 1354 used = gspca_dev->image_len; 1355 if (used + len > size) 1356 len = size - used; 1357 } 1358 1359 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 1360 1361 if (sof) { 1362 int lum = sd->header[lum_offset] + 1363 (sd->header[lum_offset + 1] << 8); 1364 1365 /* When exposure changes midway a frame we 1366 get a lum of 0 in this case drop 2 frames 1367 as the frames directly after an exposure 1368 change have an unstable image. Sometimes lum 1369 *really* is 0 (cam used in low light with 1370 low exposure setting), so do not drop frames 1371 if the previous lum was 0 too. */ 1372 if (lum == 0 && sd->prev_avg_lum != 0) { 1373 lum = -1; 1374 sd->frames_to_drop = 2; 1375 sd->prev_avg_lum = 0; 1376 } else 1377 sd->prev_avg_lum = lum; 1378 atomic_set(&sd->avg_lum, lum); 1379 1380 if (sd->frames_to_drop) 1381 sd->frames_to_drop--; 1382 else 1383 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 1384 1385 gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof); 1386 } 1387 } 1388 1389 #if IS_ENABLED(CONFIG_INPUT) 1390 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, 1391 u8 *data, /* interrupt packet data */ 1392 int len) /* interrupt packet length */ 1393 { 1394 int ret = -EINVAL; 1395 1396 if (len == 1 && data[0] == 1) { 1397 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 1398 input_sync(gspca_dev->input_dev); 1399 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 1400 input_sync(gspca_dev->input_dev); 1401 ret = 0; 1402 } 1403 1404 return ret; 1405 } 1406 #endif 1407 1408 /* sub-driver description */ 1409 static const struct sd_desc sd_desc = { 1410 .name = MODULE_NAME, 1411 .config = sd_config, 1412 .init = sd_init, 1413 .init_controls = sd_init_controls, 1414 .start = sd_start, 1415 .stopN = sd_stopN, 1416 .pkt_scan = sd_pkt_scan, 1417 .dq_callback = do_autogain, 1418 #if IS_ENABLED(CONFIG_INPUT) 1419 .int_pkt_scan = sd_int_pkt_scan, 1420 #endif 1421 }; 1422 1423 /* -- module initialisation -- */ 1424 #define SB(sensor, bridge) \ 1425 .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge 1426 1427 1428 static const struct usb_device_id device_table[] = { 1429 {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */ 1430 {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */ 1431 {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */ 1432 {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)}, 1433 {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)}, 1434 {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)}, 1435 {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)}, 1436 #if !IS_ENABLED(CONFIG_USB_SN9C102) 1437 {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)}, 1438 {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)}, 1439 #endif 1440 {USB_DEVICE(0x0c45, 0x6027), SB(OV7630, 101)}, /* Genius Eye 310 */ 1441 {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)}, 1442 {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)}, 1443 {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)}, 1444 /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */ 1445 {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)}, 1446 {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)}, 1447 {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)}, 1448 /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */ 1449 /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */ 1450 {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)}, 1451 {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)}, 1452 /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */ 1453 {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)}, 1454 {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)}, 1455 {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)}, 1456 {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)}, 1457 {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)}, 1458 {} 1459 }; 1460 MODULE_DEVICE_TABLE(usb, device_table); 1461 1462 /* -- device connect -- */ 1463 static int sd_probe(struct usb_interface *intf, 1464 const struct usb_device_id *id) 1465 { 1466 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 1467 THIS_MODULE); 1468 } 1469 1470 static struct usb_driver sd_driver = { 1471 .name = MODULE_NAME, 1472 .id_table = device_table, 1473 .probe = sd_probe, 1474 .disconnect = gspca_disconnect, 1475 #ifdef CONFIG_PM 1476 .suspend = gspca_suspend, 1477 .resume = gspca_resume, 1478 .reset_resume = gspca_resume, 1479 #endif 1480 }; 1481 1482 module_usb_driver(sd_driver); 1483