1 /* 2 * Sonix sn9c201 sn9c202 library 3 * 4 * Copyright (C) 2012 Jean-Francois Moine <http://moinejf.free.fr> 5 * Copyright (C) 2008-2009 microdia project <microdia@googlegroups.com> 6 * Copyright (C) 2009 Brian Johnson <brijohn@gmail.com> 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 25 #include <linux/input.h> 26 27 #include "gspca.h" 28 #include "jpeg.h" 29 30 #include <media/v4l2-chip-ident.h> 31 #include <linux/dmi.h> 32 33 MODULE_AUTHOR("Brian Johnson <brijohn@gmail.com>, " 34 "microdia project <microdia@googlegroups.com>"); 35 MODULE_DESCRIPTION("GSPCA/SN9C20X USB Camera Driver"); 36 MODULE_LICENSE("GPL"); 37 38 /* 39 * Pixel format private data 40 */ 41 #define SCALE_MASK 0x0f 42 #define SCALE_160x120 0 43 #define SCALE_320x240 1 44 #define SCALE_640x480 2 45 #define SCALE_1280x1024 3 46 #define MODE_RAW 0x10 47 #define MODE_JPEG 0x20 48 #define MODE_SXGA 0x80 49 50 #define SENSOR_OV9650 0 51 #define SENSOR_OV9655 1 52 #define SENSOR_SOI968 2 53 #define SENSOR_OV7660 3 54 #define SENSOR_OV7670 4 55 #define SENSOR_MT9V011 5 56 #define SENSOR_MT9V111 6 57 #define SENSOR_MT9V112 7 58 #define SENSOR_MT9M001 8 59 #define SENSOR_MT9M111 9 60 #define SENSOR_MT9M112 10 61 #define SENSOR_HV7131R 11 62 #define SENSOR_MT9VPRB 12 63 64 /* camera flags */ 65 #define HAS_NO_BUTTON 0x1 66 #define LED_REVERSE 0x2 /* some cameras unset gpio to turn on leds */ 67 #define FLIP_DETECT 0x4 68 69 /* specific webcam descriptor */ 70 struct sd { 71 struct gspca_dev gspca_dev; 72 73 struct { /* color control cluster */ 74 struct v4l2_ctrl *brightness; 75 struct v4l2_ctrl *contrast; 76 struct v4l2_ctrl *saturation; 77 struct v4l2_ctrl *hue; 78 }; 79 struct { /* blue/red balance control cluster */ 80 struct v4l2_ctrl *blue; 81 struct v4l2_ctrl *red; 82 }; 83 struct { /* h/vflip control cluster */ 84 struct v4l2_ctrl *hflip; 85 struct v4l2_ctrl *vflip; 86 }; 87 struct v4l2_ctrl *gamma; 88 struct { /* autogain and exposure or gain control cluster */ 89 struct v4l2_ctrl *autogain; 90 struct v4l2_ctrl *exposure; 91 struct v4l2_ctrl *gain; 92 }; 93 struct v4l2_ctrl *jpegqual; 94 95 struct work_struct work; 96 struct workqueue_struct *work_thread; 97 98 u32 pktsz; /* (used by pkt_scan) */ 99 u16 npkt; 100 s8 nchg; 101 u8 fmt; /* (used for JPEG QTAB update */ 102 103 #define MIN_AVG_LUM 80 104 #define MAX_AVG_LUM 130 105 atomic_t avg_lum; 106 u8 old_step; 107 u8 older_step; 108 u8 exposure_step; 109 110 u8 i2c_addr; 111 u8 i2c_intf; 112 u8 sensor; 113 u8 hstart; 114 u8 vstart; 115 116 u8 jpeg_hdr[JPEG_HDR_SZ]; 117 118 u8 flags; 119 }; 120 121 static void qual_upd(struct work_struct *work); 122 123 struct i2c_reg_u8 { 124 u8 reg; 125 u8 val; 126 }; 127 128 struct i2c_reg_u16 { 129 u8 reg; 130 u16 val; 131 }; 132 133 static const struct dmi_system_id flip_dmi_table[] = { 134 { 135 .ident = "MSI MS-1034", 136 .matches = { 137 DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT'L CO.,LTD."), 138 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1034"), 139 DMI_MATCH(DMI_PRODUCT_VERSION, "0341") 140 } 141 }, 142 { 143 .ident = "MSI MS-1632", 144 .matches = { 145 DMI_MATCH(DMI_BOARD_VENDOR, "MSI"), 146 DMI_MATCH(DMI_BOARD_NAME, "MS-1632") 147 } 148 }, 149 { 150 .ident = "MSI MS-1633X", 151 .matches = { 152 DMI_MATCH(DMI_BOARD_VENDOR, "MSI"), 153 DMI_MATCH(DMI_BOARD_NAME, "MS-1633X") 154 } 155 }, 156 { 157 .ident = "MSI MS-1635X", 158 .matches = { 159 DMI_MATCH(DMI_BOARD_VENDOR, "MSI"), 160 DMI_MATCH(DMI_BOARD_NAME, "MS-1635X") 161 } 162 }, 163 { 164 .ident = "ASUSTeK W7J", 165 .matches = { 166 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."), 167 DMI_MATCH(DMI_BOARD_NAME, "W7J ") 168 } 169 }, 170 {} 171 }; 172 173 static const struct v4l2_pix_format vga_mode[] = { 174 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 175 .bytesperline = 160, 176 .sizeimage = 160 * 120 * 4 / 8 + 590, 177 .colorspace = V4L2_COLORSPACE_JPEG, 178 .priv = SCALE_160x120 | MODE_JPEG}, 179 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 180 .bytesperline = 160, 181 .sizeimage = 160 * 120, 182 .colorspace = V4L2_COLORSPACE_SRGB, 183 .priv = SCALE_160x120 | MODE_RAW}, 184 {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE, 185 .bytesperline = 160, 186 .sizeimage = 240 * 120, 187 .colorspace = V4L2_COLORSPACE_SRGB, 188 .priv = SCALE_160x120}, 189 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 190 .bytesperline = 320, 191 .sizeimage = 320 * 240 * 4 / 8 + 590, 192 .colorspace = V4L2_COLORSPACE_JPEG, 193 .priv = SCALE_320x240 | MODE_JPEG}, 194 {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 195 .bytesperline = 320, 196 .sizeimage = 320 * 240 , 197 .colorspace = V4L2_COLORSPACE_SRGB, 198 .priv = SCALE_320x240 | MODE_RAW}, 199 {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE, 200 .bytesperline = 320, 201 .sizeimage = 480 * 240 , 202 .colorspace = V4L2_COLORSPACE_SRGB, 203 .priv = SCALE_320x240}, 204 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 205 .bytesperline = 640, 206 .sizeimage = 640 * 480 * 4 / 8 + 590, 207 .colorspace = V4L2_COLORSPACE_JPEG, 208 .priv = SCALE_640x480 | MODE_JPEG}, 209 {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 210 .bytesperline = 640, 211 .sizeimage = 640 * 480, 212 .colorspace = V4L2_COLORSPACE_SRGB, 213 .priv = SCALE_640x480 | MODE_RAW}, 214 {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE, 215 .bytesperline = 640, 216 .sizeimage = 960 * 480, 217 .colorspace = V4L2_COLORSPACE_SRGB, 218 .priv = SCALE_640x480}, 219 }; 220 221 static const struct v4l2_pix_format sxga_mode[] = { 222 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 223 .bytesperline = 160, 224 .sizeimage = 160 * 120 * 4 / 8 + 590, 225 .colorspace = V4L2_COLORSPACE_JPEG, 226 .priv = SCALE_160x120 | MODE_JPEG}, 227 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 228 .bytesperline = 160, 229 .sizeimage = 160 * 120, 230 .colorspace = V4L2_COLORSPACE_SRGB, 231 .priv = SCALE_160x120 | MODE_RAW}, 232 {160, 120, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE, 233 .bytesperline = 160, 234 .sizeimage = 240 * 120, 235 .colorspace = V4L2_COLORSPACE_SRGB, 236 .priv = SCALE_160x120}, 237 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 238 .bytesperline = 320, 239 .sizeimage = 320 * 240 * 4 / 8 + 590, 240 .colorspace = V4L2_COLORSPACE_JPEG, 241 .priv = SCALE_320x240 | MODE_JPEG}, 242 {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 243 .bytesperline = 320, 244 .sizeimage = 320 * 240 , 245 .colorspace = V4L2_COLORSPACE_SRGB, 246 .priv = SCALE_320x240 | MODE_RAW}, 247 {320, 240, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE, 248 .bytesperline = 320, 249 .sizeimage = 480 * 240 , 250 .colorspace = V4L2_COLORSPACE_SRGB, 251 .priv = SCALE_320x240}, 252 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 253 .bytesperline = 640, 254 .sizeimage = 640 * 480 * 4 / 8 + 590, 255 .colorspace = V4L2_COLORSPACE_JPEG, 256 .priv = SCALE_640x480 | MODE_JPEG}, 257 {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 258 .bytesperline = 640, 259 .sizeimage = 640 * 480, 260 .colorspace = V4L2_COLORSPACE_SRGB, 261 .priv = SCALE_640x480 | MODE_RAW}, 262 {640, 480, V4L2_PIX_FMT_SN9C20X_I420, V4L2_FIELD_NONE, 263 .bytesperline = 640, 264 .sizeimage = 960 * 480, 265 .colorspace = V4L2_COLORSPACE_SRGB, 266 .priv = SCALE_640x480}, 267 {1280, 1024, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, 268 .bytesperline = 1280, 269 .sizeimage = 1280 * 1024, 270 .colorspace = V4L2_COLORSPACE_SRGB, 271 .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA}, 272 }; 273 274 static const struct v4l2_pix_format mono_mode[] = { 275 {160, 120, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE, 276 .bytesperline = 160, 277 .sizeimage = 160 * 120, 278 .colorspace = V4L2_COLORSPACE_SRGB, 279 .priv = SCALE_160x120 | MODE_RAW}, 280 {320, 240, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE, 281 .bytesperline = 320, 282 .sizeimage = 320 * 240 , 283 .colorspace = V4L2_COLORSPACE_SRGB, 284 .priv = SCALE_320x240 | MODE_RAW}, 285 {640, 480, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE, 286 .bytesperline = 640, 287 .sizeimage = 640 * 480, 288 .colorspace = V4L2_COLORSPACE_SRGB, 289 .priv = SCALE_640x480 | MODE_RAW}, 290 {1280, 1024, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE, 291 .bytesperline = 1280, 292 .sizeimage = 1280 * 1024, 293 .colorspace = V4L2_COLORSPACE_SRGB, 294 .priv = SCALE_1280x1024 | MODE_RAW | MODE_SXGA}, 295 }; 296 297 static const s16 hsv_red_x[] = { 298 41, 44, 46, 48, 50, 52, 54, 56, 299 58, 60, 62, 64, 66, 68, 70, 72, 300 74, 76, 78, 80, 81, 83, 85, 87, 301 88, 90, 92, 93, 95, 97, 98, 100, 302 101, 102, 104, 105, 107, 108, 109, 110, 303 112, 113, 114, 115, 116, 117, 118, 119, 304 120, 121, 122, 123, 123, 124, 125, 125, 305 126, 127, 127, 128, 128, 129, 129, 129, 306 130, 130, 130, 130, 131, 131, 131, 131, 307 131, 131, 131, 131, 130, 130, 130, 130, 308 129, 129, 129, 128, 128, 127, 127, 126, 309 125, 125, 124, 123, 122, 122, 121, 120, 310 119, 118, 117, 116, 115, 114, 112, 111, 311 110, 109, 107, 106, 105, 103, 102, 101, 312 99, 98, 96, 94, 93, 91, 90, 88, 313 86, 84, 83, 81, 79, 77, 75, 74, 314 72, 70, 68, 66, 64, 62, 60, 58, 315 56, 54, 52, 49, 47, 45, 43, 41, 316 39, 36, 34, 32, 30, 28, 25, 23, 317 21, 19, 16, 14, 12, 9, 7, 5, 318 3, 0, -1, -3, -6, -8, -10, -12, 319 -15, -17, -19, -22, -24, -26, -28, -30, 320 -33, -35, -37, -39, -41, -44, -46, -48, 321 -50, -52, -54, -56, -58, -60, -62, -64, 322 -66, -68, -70, -72, -74, -76, -78, -80, 323 -81, -83, -85, -87, -88, -90, -92, -93, 324 -95, -97, -98, -100, -101, -102, -104, -105, 325 -107, -108, -109, -110, -112, -113, -114, -115, 326 -116, -117, -118, -119, -120, -121, -122, -123, 327 -123, -124, -125, -125, -126, -127, -127, -128, 328 -128, -128, -128, -128, -128, -128, -128, -128, 329 -128, -128, -128, -128, -128, -128, -128, -128, 330 -128, -128, -128, -128, -128, -128, -128, -128, 331 -128, -127, -127, -126, -125, -125, -124, -123, 332 -122, -122, -121, -120, -119, -118, -117, -116, 333 -115, -114, -112, -111, -110, -109, -107, -106, 334 -105, -103, -102, -101, -99, -98, -96, -94, 335 -93, -91, -90, -88, -86, -84, -83, -81, 336 -79, -77, -75, -74, -72, -70, -68, -66, 337 -64, -62, -60, -58, -56, -54, -52, -49, 338 -47, -45, -43, -41, -39, -36, -34, -32, 339 -30, -28, -25, -23, -21, -19, -16, -14, 340 -12, -9, -7, -5, -3, 0, 1, 3, 341 6, 8, 10, 12, 15, 17, 19, 22, 342 24, 26, 28, 30, 33, 35, 37, 39, 41 343 }; 344 345 static const s16 hsv_red_y[] = { 346 82, 80, 78, 76, 74, 73, 71, 69, 347 67, 65, 63, 61, 58, 56, 54, 52, 348 50, 48, 46, 44, 41, 39, 37, 35, 349 32, 30, 28, 26, 23, 21, 19, 16, 350 14, 12, 10, 7, 5, 3, 0, -1, 351 -3, -6, -8, -10, -13, -15, -17, -19, 352 -22, -24, -26, -29, -31, -33, -35, -38, 353 -40, -42, -44, -46, -48, -51, -53, -55, 354 -57, -59, -61, -63, -65, -67, -69, -71, 355 -73, -75, -77, -79, -81, -82, -84, -86, 356 -88, -89, -91, -93, -94, -96, -98, -99, 357 -101, -102, -104, -105, -106, -108, -109, -110, 358 -112, -113, -114, -115, -116, -117, -119, -120, 359 -120, -121, -122, -123, -124, -125, -126, -126, 360 -127, -128, -128, -128, -128, -128, -128, -128, 361 -128, -128, -128, -128, -128, -128, -128, -128, 362 -128, -128, -128, -128, -128, -128, -128, -128, 363 -128, -128, -128, -128, -128, -128, -128, -128, 364 -127, -127, -126, -125, -125, -124, -123, -122, 365 -121, -120, -119, -118, -117, -116, -115, -114, 366 -113, -111, -110, -109, -107, -106, -105, -103, 367 -102, -100, -99, -97, -96, -94, -92, -91, 368 -89, -87, -85, -84, -82, -80, -78, -76, 369 -74, -73, -71, -69, -67, -65, -63, -61, 370 -58, -56, -54, -52, -50, -48, -46, -44, 371 -41, -39, -37, -35, -32, -30, -28, -26, 372 -23, -21, -19, -16, -14, -12, -10, -7, 373 -5, -3, 0, 1, 3, 6, 8, 10, 374 13, 15, 17, 19, 22, 24, 26, 29, 375 31, 33, 35, 38, 40, 42, 44, 46, 376 48, 51, 53, 55, 57, 59, 61, 63, 377 65, 67, 69, 71, 73, 75, 77, 79, 378 81, 82, 84, 86, 88, 89, 91, 93, 379 94, 96, 98, 99, 101, 102, 104, 105, 380 106, 108, 109, 110, 112, 113, 114, 115, 381 116, 117, 119, 120, 120, 121, 122, 123, 382 124, 125, 126, 126, 127, 128, 128, 129, 383 129, 130, 130, 131, 131, 131, 131, 132, 384 132, 132, 132, 132, 132, 132, 132, 132, 385 132, 132, 132, 131, 131, 131, 130, 130, 386 130, 129, 129, 128, 127, 127, 126, 125, 387 125, 124, 123, 122, 121, 120, 119, 118, 388 117, 116, 115, 114, 113, 111, 110, 109, 389 107, 106, 105, 103, 102, 100, 99, 97, 390 96, 94, 92, 91, 89, 87, 85, 84, 82 391 }; 392 393 static const s16 hsv_green_x[] = { 394 -124, -124, -125, -125, -125, -125, -125, -125, 395 -125, -126, -126, -125, -125, -125, -125, -125, 396 -125, -124, -124, -124, -123, -123, -122, -122, 397 -121, -121, -120, -120, -119, -118, -117, -117, 398 -116, -115, -114, -113, -112, -111, -110, -109, 399 -108, -107, -105, -104, -103, -102, -100, -99, 400 -98, -96, -95, -93, -92, -91, -89, -87, 401 -86, -84, -83, -81, -79, -77, -76, -74, 402 -72, -70, -69, -67, -65, -63, -61, -59, 403 -57, -55, -53, -51, -49, -47, -45, -43, 404 -41, -39, -37, -35, -33, -30, -28, -26, 405 -24, -22, -20, -18, -15, -13, -11, -9, 406 -7, -4, -2, 0, 1, 3, 6, 8, 407 10, 12, 14, 17, 19, 21, 23, 25, 408 27, 29, 32, 34, 36, 38, 40, 42, 409 44, 46, 48, 50, 52, 54, 56, 58, 410 60, 62, 64, 66, 68, 70, 71, 73, 411 75, 77, 78, 80, 82, 83, 85, 87, 412 88, 90, 91, 93, 94, 96, 97, 98, 413 100, 101, 102, 104, 105, 106, 107, 108, 414 109, 111, 112, 113, 113, 114, 115, 116, 415 117, 118, 118, 119, 120, 120, 121, 122, 416 122, 123, 123, 124, 124, 124, 125, 125, 417 125, 125, 125, 125, 125, 126, 126, 125, 418 125, 125, 125, 125, 125, 124, 124, 124, 419 123, 123, 122, 122, 121, 121, 120, 120, 420 119, 118, 117, 117, 116, 115, 114, 113, 421 112, 111, 110, 109, 108, 107, 105, 104, 422 103, 102, 100, 99, 98, 96, 95, 93, 423 92, 91, 89, 87, 86, 84, 83, 81, 424 79, 77, 76, 74, 72, 70, 69, 67, 425 65, 63, 61, 59, 57, 55, 53, 51, 426 49, 47, 45, 43, 41, 39, 37, 35, 427 33, 30, 28, 26, 24, 22, 20, 18, 428 15, 13, 11, 9, 7, 4, 2, 0, 429 -1, -3, -6, -8, -10, -12, -14, -17, 430 -19, -21, -23, -25, -27, -29, -32, -34, 431 -36, -38, -40, -42, -44, -46, -48, -50, 432 -52, -54, -56, -58, -60, -62, -64, -66, 433 -68, -70, -71, -73, -75, -77, -78, -80, 434 -82, -83, -85, -87, -88, -90, -91, -93, 435 -94, -96, -97, -98, -100, -101, -102, -104, 436 -105, -106, -107, -108, -109, -111, -112, -113, 437 -113, -114, -115, -116, -117, -118, -118, -119, 438 -120, -120, -121, -122, -122, -123, -123, -124, -124 439 }; 440 441 static const s16 hsv_green_y[] = { 442 -100, -99, -98, -97, -95, -94, -93, -91, 443 -90, -89, -87, -86, -84, -83, -81, -80, 444 -78, -76, -75, -73, -71, -70, -68, -66, 445 -64, -63, -61, -59, -57, -55, -53, -51, 446 -49, -48, -46, -44, -42, -40, -38, -36, 447 -34, -32, -30, -27, -25, -23, -21, -19, 448 -17, -15, -13, -11, -9, -7, -4, -2, 449 0, 1, 3, 5, 7, 9, 11, 14, 450 16, 18, 20, 22, 24, 26, 28, 30, 451 32, 34, 36, 38, 40, 42, 44, 46, 452 48, 50, 52, 54, 56, 58, 59, 61, 453 63, 65, 67, 68, 70, 72, 74, 75, 454 77, 78, 80, 82, 83, 85, 86, 88, 455 89, 90, 92, 93, 95, 96, 97, 98, 456 100, 101, 102, 103, 104, 105, 106, 107, 457 108, 109, 110, 111, 112, 112, 113, 114, 458 115, 115, 116, 116, 117, 117, 118, 118, 459 119, 119, 119, 120, 120, 120, 120, 120, 460 121, 121, 121, 121, 121, 121, 120, 120, 461 120, 120, 120, 119, 119, 119, 118, 118, 462 117, 117, 116, 116, 115, 114, 114, 113, 463 112, 111, 111, 110, 109, 108, 107, 106, 464 105, 104, 103, 102, 100, 99, 98, 97, 465 95, 94, 93, 91, 90, 89, 87, 86, 466 84, 83, 81, 80, 78, 76, 75, 73, 467 71, 70, 68, 66, 64, 63, 61, 59, 468 57, 55, 53, 51, 49, 48, 46, 44, 469 42, 40, 38, 36, 34, 32, 30, 27, 470 25, 23, 21, 19, 17, 15, 13, 11, 471 9, 7, 4, 2, 0, -1, -3, -5, 472 -7, -9, -11, -14, -16, -18, -20, -22, 473 -24, -26, -28, -30, -32, -34, -36, -38, 474 -40, -42, -44, -46, -48, -50, -52, -54, 475 -56, -58, -59, -61, -63, -65, -67, -68, 476 -70, -72, -74, -75, -77, -78, -80, -82, 477 -83, -85, -86, -88, -89, -90, -92, -93, 478 -95, -96, -97, -98, -100, -101, -102, -103, 479 -104, -105, -106, -107, -108, -109, -110, -111, 480 -112, -112, -113, -114, -115, -115, -116, -116, 481 -117, -117, -118, -118, -119, -119, -119, -120, 482 -120, -120, -120, -120, -121, -121, -121, -121, 483 -121, -121, -120, -120, -120, -120, -120, -119, 484 -119, -119, -118, -118, -117, -117, -116, -116, 485 -115, -114, -114, -113, -112, -111, -111, -110, 486 -109, -108, -107, -106, -105, -104, -103, -102, -100 487 }; 488 489 static const s16 hsv_blue_x[] = { 490 112, 113, 114, 114, 115, 116, 117, 117, 491 118, 118, 119, 119, 120, 120, 120, 121, 492 121, 121, 122, 122, 122, 122, 122, 122, 493 122, 122, 122, 122, 122, 122, 121, 121, 494 121, 120, 120, 120, 119, 119, 118, 118, 495 117, 116, 116, 115, 114, 113, 113, 112, 496 111, 110, 109, 108, 107, 106, 105, 104, 497 103, 102, 100, 99, 98, 97, 95, 94, 498 93, 91, 90, 88, 87, 85, 84, 82, 499 80, 79, 77, 76, 74, 72, 70, 69, 500 67, 65, 63, 61, 60, 58, 56, 54, 501 52, 50, 48, 46, 44, 42, 40, 38, 502 36, 34, 32, 30, 28, 26, 24, 22, 503 19, 17, 15, 13, 11, 9, 7, 5, 504 2, 0, -1, -3, -5, -7, -9, -12, 505 -14, -16, -18, -20, -22, -24, -26, -28, 506 -31, -33, -35, -37, -39, -41, -43, -45, 507 -47, -49, -51, -53, -54, -56, -58, -60, 508 -62, -64, -66, -67, -69, -71, -73, -74, 509 -76, -78, -79, -81, -83, -84, -86, -87, 510 -89, -90, -92, -93, -94, -96, -97, -98, 511 -99, -101, -102, -103, -104, -105, -106, -107, 512 -108, -109, -110, -111, -112, -113, -114, -114, 513 -115, -116, -117, -117, -118, -118, -119, -119, 514 -120, -120, -120, -121, -121, -121, -122, -122, 515 -122, -122, -122, -122, -122, -122, -122, -122, 516 -122, -122, -121, -121, -121, -120, -120, -120, 517 -119, -119, -118, -118, -117, -116, -116, -115, 518 -114, -113, -113, -112, -111, -110, -109, -108, 519 -107, -106, -105, -104, -103, -102, -100, -99, 520 -98, -97, -95, -94, -93, -91, -90, -88, 521 -87, -85, -84, -82, -80, -79, -77, -76, 522 -74, -72, -70, -69, -67, -65, -63, -61, 523 -60, -58, -56, -54, -52, -50, -48, -46, 524 -44, -42, -40, -38, -36, -34, -32, -30, 525 -28, -26, -24, -22, -19, -17, -15, -13, 526 -11, -9, -7, -5, -2, 0, 1, 3, 527 5, 7, 9, 12, 14, 16, 18, 20, 528 22, 24, 26, 28, 31, 33, 35, 37, 529 39, 41, 43, 45, 47, 49, 51, 53, 530 54, 56, 58, 60, 62, 64, 66, 67, 531 69, 71, 73, 74, 76, 78, 79, 81, 532 83, 84, 86, 87, 89, 90, 92, 93, 533 94, 96, 97, 98, 99, 101, 102, 103, 534 104, 105, 106, 107, 108, 109, 110, 111, 112 535 }; 536 537 static const s16 hsv_blue_y[] = { 538 -11, -13, -15, -17, -19, -21, -23, -25, 539 -27, -29, -31, -33, -35, -37, -39, -41, 540 -43, -45, -46, -48, -50, -52, -54, -55, 541 -57, -59, -61, -62, -64, -66, -67, -69, 542 -71, -72, -74, -75, -77, -78, -80, -81, 543 -83, -84, -86, -87, -88, -90, -91, -92, 544 -93, -95, -96, -97, -98, -99, -100, -101, 545 -102, -103, -104, -105, -106, -106, -107, -108, 546 -109, -109, -110, -111, -111, -112, -112, -113, 547 -113, -114, -114, -114, -115, -115, -115, -115, 548 -116, -116, -116, -116, -116, -116, -116, -116, 549 -116, -115, -115, -115, -115, -114, -114, -114, 550 -113, -113, -112, -112, -111, -111, -110, -110, 551 -109, -108, -108, -107, -106, -105, -104, -103, 552 -102, -101, -100, -99, -98, -97, -96, -95, 553 -94, -93, -91, -90, -89, -88, -86, -85, 554 -84, -82, -81, -79, -78, -76, -75, -73, 555 -71, -70, -68, -67, -65, -63, -62, -60, 556 -58, -56, -55, -53, -51, -49, -47, -45, 557 -44, -42, -40, -38, -36, -34, -32, -30, 558 -28, -26, -24, -22, -20, -18, -16, -14, 559 -12, -10, -8, -6, -4, -2, 0, 1, 560 3, 5, 7, 9, 11, 13, 15, 17, 561 19, 21, 23, 25, 27, 29, 31, 33, 562 35, 37, 39, 41, 43, 45, 46, 48, 563 50, 52, 54, 55, 57, 59, 61, 62, 564 64, 66, 67, 69, 71, 72, 74, 75, 565 77, 78, 80, 81, 83, 84, 86, 87, 566 88, 90, 91, 92, 93, 95, 96, 97, 567 98, 99, 100, 101, 102, 103, 104, 105, 568 106, 106, 107, 108, 109, 109, 110, 111, 569 111, 112, 112, 113, 113, 114, 114, 114, 570 115, 115, 115, 115, 116, 116, 116, 116, 571 116, 116, 116, 116, 116, 115, 115, 115, 572 115, 114, 114, 114, 113, 113, 112, 112, 573 111, 111, 110, 110, 109, 108, 108, 107, 574 106, 105, 104, 103, 102, 101, 100, 99, 575 98, 97, 96, 95, 94, 93, 91, 90, 576 89, 88, 86, 85, 84, 82, 81, 79, 577 78, 76, 75, 73, 71, 70, 68, 67, 578 65, 63, 62, 60, 58, 56, 55, 53, 579 51, 49, 47, 45, 44, 42, 40, 38, 580 36, 34, 32, 30, 28, 26, 24, 22, 581 20, 18, 16, 14, 12, 10, 8, 6, 582 4, 2, 0, -1, -3, -5, -7, -9, -11 583 }; 584 585 static const u16 i2c_ident[] = { 586 V4L2_IDENT_OV9650, 587 V4L2_IDENT_OV9655, 588 V4L2_IDENT_SOI968, 589 V4L2_IDENT_OV7660, 590 V4L2_IDENT_OV7670, 591 V4L2_IDENT_MT9V011, 592 V4L2_IDENT_MT9V111, 593 V4L2_IDENT_MT9V112, 594 V4L2_IDENT_MT9M001C12ST, 595 V4L2_IDENT_MT9M111, 596 V4L2_IDENT_MT9M112, 597 V4L2_IDENT_HV7131R, 598 [SENSOR_MT9VPRB] = V4L2_IDENT_UNKNOWN, 599 }; 600 601 static const u16 bridge_init[][2] = { 602 {0x1000, 0x78}, {0x1001, 0x40}, {0x1002, 0x1c}, 603 {0x1020, 0x80}, {0x1061, 0x01}, {0x1067, 0x40}, 604 {0x1068, 0x30}, {0x1069, 0x20}, {0x106a, 0x10}, 605 {0x106b, 0x08}, {0x1188, 0x87}, {0x11a1, 0x00}, 606 {0x11a2, 0x00}, {0x11a3, 0x6a}, {0x11a4, 0x50}, 607 {0x11ab, 0x00}, {0x11ac, 0x00}, {0x11ad, 0x50}, 608 {0x11ae, 0x3c}, {0x118a, 0x04}, {0x0395, 0x04}, 609 {0x11b8, 0x3a}, {0x118b, 0x0e}, {0x10f7, 0x05}, 610 {0x10f8, 0x14}, {0x10fa, 0xff}, {0x10f9, 0x00}, 611 {0x11ba, 0x0a}, {0x11a5, 0x2d}, {0x11a6, 0x2d}, 612 {0x11a7, 0x3a}, {0x11a8, 0x05}, {0x11a9, 0x04}, 613 {0x11aa, 0x3f}, {0x11af, 0x28}, {0x11b0, 0xd8}, 614 {0x11b1, 0x14}, {0x11b2, 0xec}, {0x11b3, 0x32}, 615 {0x11b4, 0xdd}, {0x11b5, 0x32}, {0x11b6, 0xdd}, 616 {0x10e0, 0x2c}, {0x11bc, 0x40}, {0x11bd, 0x01}, 617 {0x11be, 0xf0}, {0x11bf, 0x00}, {0x118c, 0x1f}, 618 {0x118d, 0x1f}, {0x118e, 0x1f}, {0x118f, 0x1f}, 619 {0x1180, 0x01}, {0x1181, 0x00}, {0x1182, 0x01}, 620 {0x1183, 0x00}, {0x1184, 0x50}, {0x1185, 0x80}, 621 {0x1007, 0x00} 622 }; 623 624 /* Gain = (bit[3:0] / 16 + 1) * (bit[4] + 1) * (bit[5] + 1) * (bit[6] + 1) */ 625 static const u8 ov_gain[] = { 626 0x00 /* 1x */, 0x04 /* 1.25x */, 0x08 /* 1.5x */, 0x0c /* 1.75x */, 627 0x10 /* 2x */, 0x12 /* 2.25x */, 0x14 /* 2.5x */, 0x16 /* 2.75x */, 628 0x18 /* 3x */, 0x1a /* 3.25x */, 0x1c /* 3.5x */, 0x1e /* 3.75x */, 629 0x30 /* 4x */, 0x31 /* 4.25x */, 0x32 /* 4.5x */, 0x33 /* 4.75x */, 630 0x34 /* 5x */, 0x35 /* 5.25x */, 0x36 /* 5.5x */, 0x37 /* 5.75x */, 631 0x38 /* 6x */, 0x39 /* 6.25x */, 0x3a /* 6.5x */, 0x3b /* 6.75x */, 632 0x3c /* 7x */, 0x3d /* 7.25x */, 0x3e /* 7.5x */, 0x3f /* 7.75x */, 633 0x70 /* 8x */ 634 }; 635 636 /* Gain = (bit[8] + 1) * (bit[7] + 1) * (bit[6:0] * 0.03125) */ 637 static const u16 micron1_gain[] = { 638 /* 1x 1.25x 1.5x 1.75x */ 639 0x0020, 0x0028, 0x0030, 0x0038, 640 /* 2x 2.25x 2.5x 2.75x */ 641 0x00a0, 0x00a4, 0x00a8, 0x00ac, 642 /* 3x 3.25x 3.5x 3.75x */ 643 0x00b0, 0x00b4, 0x00b8, 0x00bc, 644 /* 4x 4.25x 4.5x 4.75x */ 645 0x00c0, 0x00c4, 0x00c8, 0x00cc, 646 /* 5x 5.25x 5.5x 5.75x */ 647 0x00d0, 0x00d4, 0x00d8, 0x00dc, 648 /* 6x 6.25x 6.5x 6.75x */ 649 0x00e0, 0x00e4, 0x00e8, 0x00ec, 650 /* 7x 7.25x 7.5x 7.75x */ 651 0x00f0, 0x00f4, 0x00f8, 0x00fc, 652 /* 8x */ 653 0x01c0 654 }; 655 656 /* mt9m001 sensor uses a different gain formula then other micron sensors */ 657 /* Gain = (bit[6] + 1) * (bit[5-0] * 0.125) */ 658 static const u16 micron2_gain[] = { 659 /* 1x 1.25x 1.5x 1.75x */ 660 0x0008, 0x000a, 0x000c, 0x000e, 661 /* 2x 2.25x 2.5x 2.75x */ 662 0x0010, 0x0012, 0x0014, 0x0016, 663 /* 3x 3.25x 3.5x 3.75x */ 664 0x0018, 0x001a, 0x001c, 0x001e, 665 /* 4x 4.25x 4.5x 4.75x */ 666 0x0020, 0x0051, 0x0052, 0x0053, 667 /* 5x 5.25x 5.5x 5.75x */ 668 0x0054, 0x0055, 0x0056, 0x0057, 669 /* 6x 6.25x 6.5x 6.75x */ 670 0x0058, 0x0059, 0x005a, 0x005b, 671 /* 7x 7.25x 7.5x 7.75x */ 672 0x005c, 0x005d, 0x005e, 0x005f, 673 /* 8x */ 674 0x0060 675 }; 676 677 /* Gain = .5 + bit[7:0] / 16 */ 678 static const u8 hv7131r_gain[] = { 679 0x08 /* 1x */, 0x0c /* 1.25x */, 0x10 /* 1.5x */, 0x14 /* 1.75x */, 680 0x18 /* 2x */, 0x1c /* 2.25x */, 0x20 /* 2.5x */, 0x24 /* 2.75x */, 681 0x28 /* 3x */, 0x2c /* 3.25x */, 0x30 /* 3.5x */, 0x34 /* 3.75x */, 682 0x38 /* 4x */, 0x3c /* 4.25x */, 0x40 /* 4.5x */, 0x44 /* 4.75x */, 683 0x48 /* 5x */, 0x4c /* 5.25x */, 0x50 /* 5.5x */, 0x54 /* 5.75x */, 684 0x58 /* 6x */, 0x5c /* 6.25x */, 0x60 /* 6.5x */, 0x64 /* 6.75x */, 685 0x68 /* 7x */, 0x6c /* 7.25x */, 0x70 /* 7.5x */, 0x74 /* 7.75x */, 686 0x78 /* 8x */ 687 }; 688 689 static const struct i2c_reg_u8 soi968_init[] = { 690 {0x0c, 0x00}, {0x0f, 0x1f}, 691 {0x11, 0x80}, {0x38, 0x52}, {0x1e, 0x00}, 692 {0x33, 0x08}, {0x35, 0x8c}, {0x36, 0x0c}, 693 {0x37, 0x04}, {0x45, 0x04}, {0x47, 0xff}, 694 {0x3e, 0x00}, {0x3f, 0x00}, {0x3b, 0x20}, 695 {0x3a, 0x96}, {0x3d, 0x0a}, {0x14, 0x8e}, 696 {0x13, 0x8b}, {0x12, 0x40}, {0x17, 0x13}, 697 {0x18, 0x63}, {0x19, 0x01}, {0x1a, 0x79}, 698 {0x32, 0x24}, {0x03, 0x00}, {0x11, 0x40}, 699 {0x2a, 0x10}, {0x2b, 0xe0}, {0x10, 0x32}, 700 {0x00, 0x00}, {0x01, 0x80}, {0x02, 0x80}, 701 }; 702 703 static const struct i2c_reg_u8 ov7660_init[] = { 704 {0x0e, 0x80}, {0x0d, 0x08}, {0x0f, 0xc3}, 705 {0x04, 0xc3}, {0x10, 0x40}, {0x11, 0x40}, 706 {0x12, 0x05}, {0x13, 0xba}, {0x14, 0x2a}, 707 /* HDG Set hstart and hstop, datasheet default 0x11, 0x61, using 708 0x10, 0x61 and sd->hstart, vstart = 3, fixes ugly colored borders */ 709 {0x17, 0x10}, {0x18, 0x61}, 710 {0x37, 0x0f}, {0x38, 0x02}, {0x39, 0x43}, 711 {0x3a, 0x00}, {0x69, 0x90}, {0x2d, 0x00}, 712 {0x2e, 0x00}, {0x01, 0x78}, {0x02, 0x50}, 713 }; 714 715 static const struct i2c_reg_u8 ov7670_init[] = { 716 {0x11, 0x80}, {0x3a, 0x04}, {0x12, 0x01}, 717 {0x32, 0xb6}, {0x03, 0x0a}, {0x0c, 0x00}, {0x3e, 0x00}, 718 {0x70, 0x3a}, {0x71, 0x35}, {0x72, 0x11}, {0x73, 0xf0}, 719 {0xa2, 0x02}, {0x13, 0xe0}, {0x00, 0x00}, {0x10, 0x00}, 720 {0x0d, 0x40}, {0x14, 0x28}, {0xa5, 0x05}, {0xab, 0x07}, 721 {0x24, 0x95}, {0x25, 0x33}, {0x26, 0xe3}, {0x9f, 0x75}, 722 {0xa0, 0x65}, {0xa1, 0x0b}, {0xa6, 0xd8}, {0xa7, 0xd8}, 723 {0xa8, 0xf0}, {0xa9, 0x90}, {0xaa, 0x94}, {0x13, 0xe5}, 724 {0x0e, 0x61}, {0x0f, 0x4b}, {0x16, 0x02}, {0x1e, 0x27}, 725 {0x21, 0x02}, {0x22, 0x91}, {0x29, 0x07}, {0x33, 0x0b}, 726 {0x35, 0x0b}, {0x37, 0x1d}, {0x38, 0x71}, {0x39, 0x2a}, 727 {0x3c, 0x78}, {0x4d, 0x40}, {0x4e, 0x20}, {0x69, 0x00}, 728 {0x74, 0x19}, {0x8d, 0x4f}, {0x8e, 0x00}, {0x8f, 0x00}, 729 {0x90, 0x00}, {0x91, 0x00}, {0x96, 0x00}, {0x9a, 0x80}, 730 {0xb0, 0x84}, {0xb1, 0x0c}, {0xb2, 0x0e}, {0xb3, 0x82}, 731 {0xb8, 0x0a}, {0x43, 0x0a}, {0x44, 0xf0}, {0x45, 0x20}, 732 {0x46, 0x7d}, {0x47, 0x29}, {0x48, 0x4a}, {0x59, 0x8c}, 733 {0x5a, 0xa5}, {0x5b, 0xde}, {0x5c, 0x96}, {0x5d, 0x66}, 734 {0x5e, 0x10}, {0x6c, 0x0a}, {0x6d, 0x55}, {0x6e, 0x11}, 735 {0x6f, 0x9e}, {0x6a, 0x40}, {0x01, 0x40}, {0x02, 0x40}, 736 {0x13, 0xe7}, {0x4f, 0x6e}, {0x50, 0x70}, {0x51, 0x02}, 737 {0x52, 0x1d}, {0x53, 0x56}, {0x54, 0x73}, {0x55, 0x0a}, 738 {0x56, 0x55}, {0x57, 0x80}, {0x58, 0x9e}, {0x41, 0x08}, 739 {0x3f, 0x02}, {0x75, 0x03}, {0x76, 0x63}, {0x4c, 0x04}, 740 {0x77, 0x06}, {0x3d, 0x02}, {0x4b, 0x09}, {0xc9, 0x30}, 741 {0x41, 0x08}, {0x56, 0x48}, {0x34, 0x11}, {0xa4, 0x88}, 742 {0x96, 0x00}, {0x97, 0x30}, {0x98, 0x20}, {0x99, 0x30}, 743 {0x9a, 0x84}, {0x9b, 0x29}, {0x9c, 0x03}, {0x9d, 0x99}, 744 {0x9e, 0x7f}, {0x78, 0x04}, {0x79, 0x01}, {0xc8, 0xf0}, 745 {0x79, 0x0f}, {0xc8, 0x00}, {0x79, 0x10}, {0xc8, 0x7e}, 746 {0x79, 0x0a}, {0xc8, 0x80}, {0x79, 0x0b}, {0xc8, 0x01}, 747 {0x79, 0x0c}, {0xc8, 0x0f}, {0x79, 0x0d}, {0xc8, 0x20}, 748 {0x79, 0x09}, {0xc8, 0x80}, {0x79, 0x02}, {0xc8, 0xc0}, 749 {0x79, 0x03}, {0xc8, 0x40}, {0x79, 0x05}, {0xc8, 0x30}, 750 {0x79, 0x26}, {0x62, 0x20}, {0x63, 0x00}, {0x64, 0x06}, 751 {0x65, 0x00}, {0x66, 0x05}, {0x94, 0x05}, {0x95, 0x0a}, 752 {0x17, 0x13}, {0x18, 0x01}, {0x19, 0x02}, {0x1a, 0x7a}, 753 {0x46, 0x59}, {0x47, 0x30}, {0x58, 0x9a}, {0x59, 0x84}, 754 {0x5a, 0x91}, {0x5b, 0x57}, {0x5c, 0x75}, {0x5d, 0x6d}, 755 {0x5e, 0x13}, {0x64, 0x07}, {0x94, 0x07}, {0x95, 0x0d}, 756 {0xa6, 0xdf}, {0xa7, 0xdf}, {0x48, 0x4d}, {0x51, 0x00}, 757 {0x6b, 0x0a}, {0x11, 0x80}, {0x2a, 0x00}, {0x2b, 0x00}, 758 {0x92, 0x00}, {0x93, 0x00}, {0x55, 0x0a}, {0x56, 0x60}, 759 {0x4f, 0x6e}, {0x50, 0x70}, {0x51, 0x00}, {0x52, 0x1d}, 760 {0x53, 0x56}, {0x54, 0x73}, {0x58, 0x9a}, {0x4f, 0x6e}, 761 {0x50, 0x70}, {0x51, 0x00}, {0x52, 0x1d}, {0x53, 0x56}, 762 {0x54, 0x73}, {0x58, 0x9a}, {0x3f, 0x01}, {0x7b, 0x03}, 763 {0x7c, 0x09}, {0x7d, 0x16}, {0x7e, 0x38}, {0x7f, 0x47}, 764 {0x80, 0x53}, {0x81, 0x5e}, {0x82, 0x6a}, {0x83, 0x74}, 765 {0x84, 0x80}, {0x85, 0x8c}, {0x86, 0x9b}, {0x87, 0xb2}, 766 {0x88, 0xcc}, {0x89, 0xe5}, {0x7a, 0x24}, {0x3b, 0x00}, 767 {0x9f, 0x76}, {0xa0, 0x65}, {0x13, 0xe2}, {0x6b, 0x0a}, 768 {0x11, 0x80}, {0x2a, 0x00}, {0x2b, 0x00}, {0x92, 0x00}, 769 {0x93, 0x00}, 770 }; 771 772 static const struct i2c_reg_u8 ov9650_init[] = { 773 {0x00, 0x00}, {0x01, 0x78}, 774 {0x02, 0x78}, {0x03, 0x36}, {0x04, 0x03}, 775 {0x05, 0x00}, {0x06, 0x00}, {0x08, 0x00}, 776 {0x09, 0x01}, {0x0c, 0x00}, {0x0d, 0x00}, 777 {0x0e, 0xa0}, {0x0f, 0x52}, {0x10, 0x7c}, 778 {0x11, 0x80}, {0x12, 0x45}, {0x13, 0xc2}, 779 {0x14, 0x2e}, {0x15, 0x00}, {0x16, 0x07}, 780 {0x17, 0x24}, {0x18, 0xc5}, {0x19, 0x00}, 781 {0x1a, 0x3c}, {0x1b, 0x00}, {0x1e, 0x04}, 782 {0x1f, 0x00}, {0x24, 0x78}, {0x25, 0x68}, 783 {0x26, 0xd4}, {0x27, 0x80}, {0x28, 0x80}, 784 {0x29, 0x30}, {0x2a, 0x00}, {0x2b, 0x00}, 785 {0x2c, 0x80}, {0x2d, 0x00}, {0x2e, 0x00}, 786 {0x2f, 0x00}, {0x30, 0x08}, {0x31, 0x30}, 787 {0x32, 0x84}, {0x33, 0xe2}, {0x34, 0xbf}, 788 {0x35, 0x81}, {0x36, 0xf9}, {0x37, 0x00}, 789 {0x38, 0x93}, {0x39, 0x50}, {0x3a, 0x01}, 790 {0x3b, 0x01}, {0x3c, 0x73}, {0x3d, 0x19}, 791 {0x3e, 0x0b}, {0x3f, 0x80}, {0x40, 0xc1}, 792 {0x41, 0x00}, {0x42, 0x08}, {0x67, 0x80}, 793 {0x68, 0x80}, {0x69, 0x40}, {0x6a, 0x00}, 794 {0x6b, 0x0a}, {0x8b, 0x06}, {0x8c, 0x20}, 795 {0x8d, 0x00}, {0x8e, 0x00}, {0x8f, 0xdf}, 796 {0x92, 0x00}, {0x93, 0x00}, {0x94, 0x88}, 797 {0x95, 0x88}, {0x96, 0x04}, {0xa1, 0x00}, 798 {0xa5, 0x80}, {0xa8, 0x80}, {0xa9, 0xb8}, 799 {0xaa, 0x92}, {0xab, 0x0a}, 800 }; 801 802 static const struct i2c_reg_u8 ov9655_init[] = { 803 {0x0e, 0x61}, {0x11, 0x80}, {0x13, 0xba}, 804 {0x14, 0x2e}, {0x16, 0x24}, {0x1e, 0x04}, {0x27, 0x08}, 805 {0x28, 0x08}, {0x29, 0x15}, {0x2c, 0x08}, {0x34, 0x3d}, 806 {0x35, 0x00}, {0x38, 0x12}, {0x0f, 0x42}, {0x39, 0x57}, 807 {0x3a, 0x00}, {0x3b, 0xcc}, {0x3c, 0x0c}, {0x3d, 0x19}, 808 {0x3e, 0x0c}, {0x3f, 0x01}, {0x41, 0x40}, {0x42, 0x80}, 809 {0x45, 0x46}, {0x46, 0x62}, {0x47, 0x2a}, {0x48, 0x3c}, 810 {0x4a, 0xf0}, {0x4b, 0xdc}, {0x4c, 0xdc}, {0x4d, 0xdc}, 811 {0x4e, 0xdc}, {0x6c, 0x04}, {0x6f, 0x9e}, {0x70, 0x05}, 812 {0x71, 0x78}, {0x77, 0x02}, {0x8a, 0x23}, {0x90, 0x7e}, 813 {0x91, 0x7c}, {0x9f, 0x6e}, {0xa0, 0x6e}, {0xa5, 0x68}, 814 {0xa6, 0x60}, {0xa8, 0xc1}, {0xa9, 0xfa}, {0xaa, 0x92}, 815 {0xab, 0x04}, {0xac, 0x80}, {0xad, 0x80}, {0xae, 0x80}, 816 {0xaf, 0x80}, {0xb2, 0xf2}, {0xb3, 0x20}, {0xb5, 0x00}, 817 {0xb6, 0xaf}, {0xbb, 0xae}, {0xbc, 0x44}, {0xbd, 0x44}, 818 {0xbe, 0x3b}, {0xbf, 0x3a}, {0xc1, 0xc8}, {0xc2, 0x01}, 819 {0xc4, 0x00}, {0xc6, 0x85}, {0xc7, 0x81}, {0xc9, 0xe0}, 820 {0xca, 0xe8}, {0xcc, 0xd8}, {0xcd, 0x93}, {0x2d, 0x00}, 821 {0x2e, 0x00}, {0x01, 0x80}, {0x02, 0x80}, {0x12, 0x61}, 822 {0x36, 0xfa}, {0x8c, 0x8d}, {0xc0, 0xaa}, {0x69, 0x0a}, 823 {0x03, 0x09}, {0x17, 0x16}, {0x18, 0x6e}, {0x19, 0x01}, 824 {0x1a, 0x3e}, {0x32, 0x09}, {0x2a, 0x10}, {0x2b, 0x0a}, 825 {0x92, 0x00}, {0x93, 0x00}, {0xa1, 0x00}, {0x10, 0x7c}, 826 {0x04, 0x03}, {0x00, 0x13}, 827 }; 828 829 static const struct i2c_reg_u16 mt9v112_init[] = { 830 {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0020}, 831 {0x34, 0xc019}, {0x0a, 0x0011}, {0x0b, 0x000b}, 832 {0x20, 0x0703}, {0x35, 0x2022}, {0xf0, 0x0001}, 833 {0x05, 0x0000}, {0x06, 0x340c}, {0x3b, 0x042a}, 834 {0x3c, 0x0400}, {0xf0, 0x0002}, {0x2e, 0x0c58}, 835 {0x5b, 0x0001}, {0xc8, 0x9f0b}, {0xf0, 0x0001}, 836 {0x9b, 0x5300}, {0xf0, 0x0000}, {0x2b, 0x0020}, 837 {0x2c, 0x002a}, {0x2d, 0x0032}, {0x2e, 0x0020}, 838 {0x09, 0x01dc}, {0x01, 0x000c}, {0x02, 0x0020}, 839 {0x03, 0x01e0}, {0x04, 0x0280}, {0x06, 0x000c}, 840 {0x05, 0x0098}, {0x20, 0x0703}, {0x09, 0x01f2}, 841 {0x2b, 0x00a0}, {0x2c, 0x00a0}, {0x2d, 0x00a0}, 842 {0x2e, 0x00a0}, {0x01, 0x000c}, {0x02, 0x0020}, 843 {0x03, 0x01e0}, {0x04, 0x0280}, {0x06, 0x000c}, 844 {0x05, 0x0098}, {0x09, 0x01c1}, {0x2b, 0x00ae}, 845 {0x2c, 0x00ae}, {0x2d, 0x00ae}, {0x2e, 0x00ae}, 846 }; 847 848 static const struct i2c_reg_u16 mt9v111_init[] = { 849 {0x01, 0x0004}, {0x0d, 0x0001}, {0x0d, 0x0000}, 850 {0x01, 0x0001}, {0x05, 0x0004}, {0x2d, 0xe0a0}, 851 {0x2e, 0x0c64}, {0x2f, 0x0064}, {0x06, 0x600e}, 852 {0x08, 0x0480}, {0x01, 0x0004}, {0x02, 0x0016}, 853 {0x03, 0x01e7}, {0x04, 0x0287}, {0x05, 0x0004}, 854 {0x06, 0x002d}, {0x07, 0x3002}, {0x08, 0x0008}, 855 {0x0e, 0x0008}, {0x20, 0x0000} 856 }; 857 858 static const struct i2c_reg_u16 mt9v011_init[] = { 859 {0x07, 0x0002}, {0x0d, 0x0001}, {0x0d, 0x0000}, 860 {0x01, 0x0008}, {0x02, 0x0016}, {0x03, 0x01e1}, 861 {0x04, 0x0281}, {0x05, 0x0083}, {0x06, 0x0006}, 862 {0x0d, 0x0002}, {0x0a, 0x0000}, {0x0b, 0x0000}, 863 {0x0c, 0x0000}, {0x0d, 0x0000}, {0x0e, 0x0000}, 864 {0x0f, 0x0000}, {0x10, 0x0000}, {0x11, 0x0000}, 865 {0x12, 0x0000}, {0x13, 0x0000}, {0x14, 0x0000}, 866 {0x15, 0x0000}, {0x16, 0x0000}, {0x17, 0x0000}, 867 {0x18, 0x0000}, {0x19, 0x0000}, {0x1a, 0x0000}, 868 {0x1b, 0x0000}, {0x1c, 0x0000}, {0x1d, 0x0000}, 869 {0x32, 0x0000}, {0x20, 0x1101}, {0x21, 0x0000}, 870 {0x22, 0x0000}, {0x23, 0x0000}, {0x24, 0x0000}, 871 {0x25, 0x0000}, {0x26, 0x0000}, {0x27, 0x0024}, 872 {0x2f, 0xf7b0}, {0x30, 0x0005}, {0x31, 0x0000}, 873 {0x32, 0x0000}, {0x33, 0x0000}, {0x34, 0x0100}, 874 {0x3d, 0x068f}, {0x40, 0x01e0}, {0x41, 0x00d1}, 875 {0x44, 0x0082}, {0x5a, 0x0000}, {0x5b, 0x0000}, 876 {0x5c, 0x0000}, {0x5d, 0x0000}, {0x5e, 0x0000}, 877 {0x5f, 0xa31d}, {0x62, 0x0611}, {0x0a, 0x0000}, 878 {0x06, 0x0029}, {0x05, 0x0009}, {0x20, 0x1101}, 879 {0x20, 0x1101}, {0x09, 0x0064}, {0x07, 0x0003}, 880 {0x2b, 0x0033}, {0x2c, 0x00a0}, {0x2d, 0x00a0}, 881 {0x2e, 0x0033}, {0x07, 0x0002}, {0x06, 0x0000}, 882 {0x06, 0x0029}, {0x05, 0x0009}, 883 }; 884 885 static const struct i2c_reg_u16 mt9m001_init[] = { 886 {0x0d, 0x0001}, 887 {0x0d, 0x0000}, 888 {0x04, 0x0500}, /* hres = 1280 */ 889 {0x03, 0x0400}, /* vres = 1024 */ 890 {0x20, 0x1100}, 891 {0x06, 0x0010}, 892 {0x2b, 0x0024}, 893 {0x2e, 0x0024}, 894 {0x35, 0x0024}, 895 {0x2d, 0x0020}, 896 {0x2c, 0x0020}, 897 {0x09, 0x0ad4}, 898 {0x35, 0x0057}, 899 }; 900 901 static const struct i2c_reg_u16 mt9m111_init[] = { 902 {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008}, 903 {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300}, 904 {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e}, 905 {0xf0, 0x0000}, 906 }; 907 908 static const struct i2c_reg_u16 mt9m112_init[] = { 909 {0xf0, 0x0000}, {0x0d, 0x0021}, {0x0d, 0x0008}, 910 {0xf0, 0x0001}, {0x3a, 0x4300}, {0x9b, 0x4300}, 911 {0x06, 0x708e}, {0xf0, 0x0002}, {0x2e, 0x0a1e}, 912 {0xf0, 0x0000}, 913 }; 914 915 static const struct i2c_reg_u8 hv7131r_init[] = { 916 {0x02, 0x08}, {0x02, 0x00}, {0x01, 0x08}, 917 {0x02, 0x00}, {0x20, 0x00}, {0x21, 0xd0}, 918 {0x22, 0x00}, {0x23, 0x09}, {0x01, 0x08}, 919 {0x01, 0x08}, {0x01, 0x08}, {0x25, 0x07}, 920 {0x26, 0xc3}, {0x27, 0x50}, {0x30, 0x62}, 921 {0x31, 0x10}, {0x32, 0x06}, {0x33, 0x10}, 922 {0x20, 0x00}, {0x21, 0xd0}, {0x22, 0x00}, 923 {0x23, 0x09}, {0x01, 0x08}, 924 }; 925 926 static void reg_r(struct gspca_dev *gspca_dev, u16 reg, u16 length) 927 { 928 struct usb_device *dev = gspca_dev->dev; 929 int result; 930 931 if (gspca_dev->usb_err < 0) 932 return; 933 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 934 0x00, 935 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 936 reg, 937 0x00, 938 gspca_dev->usb_buf, 939 length, 940 500); 941 if (unlikely(result < 0 || result != length)) { 942 pr_err("Read register %02x failed %d\n", reg, result); 943 gspca_dev->usb_err = result; 944 } 945 } 946 947 static void reg_w(struct gspca_dev *gspca_dev, u16 reg, 948 const u8 *buffer, int length) 949 { 950 struct usb_device *dev = gspca_dev->dev; 951 int result; 952 953 if (gspca_dev->usb_err < 0) 954 return; 955 memcpy(gspca_dev->usb_buf, buffer, length); 956 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 957 0x08, 958 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE, 959 reg, 960 0x00, 961 gspca_dev->usb_buf, 962 length, 963 500); 964 if (unlikely(result < 0 || result != length)) { 965 pr_err("Write register %02x failed %d\n", reg, result); 966 gspca_dev->usb_err = result; 967 } 968 } 969 970 static void reg_w1(struct gspca_dev *gspca_dev, u16 reg, const u8 value) 971 { 972 reg_w(gspca_dev, reg, &value, 1); 973 } 974 975 static void i2c_w(struct gspca_dev *gspca_dev, const u8 *buffer) 976 { 977 int i; 978 979 reg_w(gspca_dev, 0x10c0, buffer, 8); 980 for (i = 0; i < 5; i++) { 981 reg_r(gspca_dev, 0x10c0, 1); 982 if (gspca_dev->usb_err < 0) 983 return; 984 if (gspca_dev->usb_buf[0] & 0x04) { 985 if (gspca_dev->usb_buf[0] & 0x08) { 986 pr_err("i2c_w error\n"); 987 gspca_dev->usb_err = -EIO; 988 } 989 return; 990 } 991 msleep(10); 992 } 993 pr_err("i2c_w reg %02x no response\n", buffer[2]); 994 /* gspca_dev->usb_err = -EIO; fixme: may occur */ 995 } 996 997 static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val) 998 { 999 struct sd *sd = (struct sd *) gspca_dev; 1000 u8 row[8]; 1001 1002 /* 1003 * from the point of view of the bridge, the length 1004 * includes the address 1005 */ 1006 row[0] = sd->i2c_intf | (2 << 4); 1007 row[1] = sd->i2c_addr; 1008 row[2] = reg; 1009 row[3] = val; 1010 row[4] = 0x00; 1011 row[5] = 0x00; 1012 row[6] = 0x00; 1013 row[7] = 0x10; 1014 1015 i2c_w(gspca_dev, row); 1016 } 1017 1018 static void i2c_w1_buf(struct gspca_dev *gspca_dev, 1019 const struct i2c_reg_u8 *buf, int sz) 1020 { 1021 while (--sz >= 0) { 1022 i2c_w1(gspca_dev, buf->reg, buf->val); 1023 buf++; 1024 } 1025 } 1026 1027 static void i2c_w2(struct gspca_dev *gspca_dev, u8 reg, u16 val) 1028 { 1029 struct sd *sd = (struct sd *) gspca_dev; 1030 u8 row[8]; 1031 1032 /* 1033 * from the point of view of the bridge, the length 1034 * includes the address 1035 */ 1036 row[0] = sd->i2c_intf | (3 << 4); 1037 row[1] = sd->i2c_addr; 1038 row[2] = reg; 1039 row[3] = val >> 8; 1040 row[4] = val; 1041 row[5] = 0x00; 1042 row[6] = 0x00; 1043 row[7] = 0x10; 1044 1045 i2c_w(gspca_dev, row); 1046 } 1047 1048 static void i2c_w2_buf(struct gspca_dev *gspca_dev, 1049 const struct i2c_reg_u16 *buf, int sz) 1050 { 1051 while (--sz >= 0) { 1052 i2c_w2(gspca_dev, buf->reg, buf->val); 1053 buf++; 1054 } 1055 } 1056 1057 static void i2c_r1(struct gspca_dev *gspca_dev, u8 reg, u8 *val) 1058 { 1059 struct sd *sd = (struct sd *) gspca_dev; 1060 u8 row[8]; 1061 1062 row[0] = sd->i2c_intf | (1 << 4); 1063 row[1] = sd->i2c_addr; 1064 row[2] = reg; 1065 row[3] = 0; 1066 row[4] = 0; 1067 row[5] = 0; 1068 row[6] = 0; 1069 row[7] = 0x10; 1070 i2c_w(gspca_dev, row); 1071 row[0] = sd->i2c_intf | (1 << 4) | 0x02; 1072 row[2] = 0; 1073 i2c_w(gspca_dev, row); 1074 reg_r(gspca_dev, 0x10c2, 5); 1075 *val = gspca_dev->usb_buf[4]; 1076 } 1077 1078 static void i2c_r2(struct gspca_dev *gspca_dev, u8 reg, u16 *val) 1079 { 1080 struct sd *sd = (struct sd *) gspca_dev; 1081 u8 row[8]; 1082 1083 row[0] = sd->i2c_intf | (1 << 4); 1084 row[1] = sd->i2c_addr; 1085 row[2] = reg; 1086 row[3] = 0; 1087 row[4] = 0; 1088 row[5] = 0; 1089 row[6] = 0; 1090 row[7] = 0x10; 1091 i2c_w(gspca_dev, row); 1092 row[0] = sd->i2c_intf | (2 << 4) | 0x02; 1093 row[2] = 0; 1094 i2c_w(gspca_dev, row); 1095 reg_r(gspca_dev, 0x10c2, 5); 1096 *val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4]; 1097 } 1098 1099 static void ov9650_init_sensor(struct gspca_dev *gspca_dev) 1100 { 1101 u16 id; 1102 struct sd *sd = (struct sd *) gspca_dev; 1103 1104 i2c_r2(gspca_dev, 0x1c, &id); 1105 if (gspca_dev->usb_err < 0) 1106 return; 1107 1108 if (id != 0x7fa2) { 1109 pr_err("sensor id for ov9650 doesn't match (0x%04x)\n", id); 1110 gspca_dev->usb_err = -ENODEV; 1111 return; 1112 } 1113 1114 i2c_w1(gspca_dev, 0x12, 0x80); /* sensor reset */ 1115 msleep(200); 1116 i2c_w1_buf(gspca_dev, ov9650_init, ARRAY_SIZE(ov9650_init)); 1117 if (gspca_dev->usb_err < 0) 1118 pr_err("OV9650 sensor initialization failed\n"); 1119 sd->hstart = 1; 1120 sd->vstart = 7; 1121 } 1122 1123 static void ov9655_init_sensor(struct gspca_dev *gspca_dev) 1124 { 1125 struct sd *sd = (struct sd *) gspca_dev; 1126 1127 i2c_w1(gspca_dev, 0x12, 0x80); /* sensor reset */ 1128 msleep(200); 1129 i2c_w1_buf(gspca_dev, ov9655_init, ARRAY_SIZE(ov9655_init)); 1130 if (gspca_dev->usb_err < 0) 1131 pr_err("OV9655 sensor initialization failed\n"); 1132 1133 sd->hstart = 1; 1134 sd->vstart = 2; 1135 } 1136 1137 static void soi968_init_sensor(struct gspca_dev *gspca_dev) 1138 { 1139 struct sd *sd = (struct sd *) gspca_dev; 1140 1141 i2c_w1(gspca_dev, 0x12, 0x80); /* sensor reset */ 1142 msleep(200); 1143 i2c_w1_buf(gspca_dev, soi968_init, ARRAY_SIZE(soi968_init)); 1144 if (gspca_dev->usb_err < 0) 1145 pr_err("SOI968 sensor initialization failed\n"); 1146 1147 sd->hstart = 60; 1148 sd->vstart = 11; 1149 } 1150 1151 static void ov7660_init_sensor(struct gspca_dev *gspca_dev) 1152 { 1153 struct sd *sd = (struct sd *) gspca_dev; 1154 1155 i2c_w1(gspca_dev, 0x12, 0x80); /* sensor reset */ 1156 msleep(200); 1157 i2c_w1_buf(gspca_dev, ov7660_init, ARRAY_SIZE(ov7660_init)); 1158 if (gspca_dev->usb_err < 0) 1159 pr_err("OV7660 sensor initialization failed\n"); 1160 sd->hstart = 3; 1161 sd->vstart = 3; 1162 } 1163 1164 static void ov7670_init_sensor(struct gspca_dev *gspca_dev) 1165 { 1166 struct sd *sd = (struct sd *) gspca_dev; 1167 1168 i2c_w1(gspca_dev, 0x12, 0x80); /* sensor reset */ 1169 msleep(200); 1170 i2c_w1_buf(gspca_dev, ov7670_init, ARRAY_SIZE(ov7670_init)); 1171 if (gspca_dev->usb_err < 0) 1172 pr_err("OV7670 sensor initialization failed\n"); 1173 1174 sd->hstart = 0; 1175 sd->vstart = 1; 1176 } 1177 1178 static void mt9v_init_sensor(struct gspca_dev *gspca_dev) 1179 { 1180 struct sd *sd = (struct sd *) gspca_dev; 1181 u16 value; 1182 1183 sd->i2c_addr = 0x5d; 1184 i2c_r2(gspca_dev, 0xff, &value); 1185 if (gspca_dev->usb_err >= 0 1186 && value == 0x8243) { 1187 i2c_w2_buf(gspca_dev, mt9v011_init, ARRAY_SIZE(mt9v011_init)); 1188 if (gspca_dev->usb_err < 0) { 1189 pr_err("MT9V011 sensor initialization failed\n"); 1190 return; 1191 } 1192 sd->hstart = 2; 1193 sd->vstart = 2; 1194 sd->sensor = SENSOR_MT9V011; 1195 pr_info("MT9V011 sensor detected\n"); 1196 return; 1197 } 1198 1199 gspca_dev->usb_err = 0; 1200 sd->i2c_addr = 0x5c; 1201 i2c_w2(gspca_dev, 0x01, 0x0004); 1202 i2c_r2(gspca_dev, 0xff, &value); 1203 if (gspca_dev->usb_err >= 0 1204 && value == 0x823a) { 1205 i2c_w2_buf(gspca_dev, mt9v111_init, ARRAY_SIZE(mt9v111_init)); 1206 if (gspca_dev->usb_err < 0) { 1207 pr_err("MT9V111 sensor initialization failed\n"); 1208 return; 1209 } 1210 sd->hstart = 2; 1211 sd->vstart = 2; 1212 sd->sensor = SENSOR_MT9V111; 1213 pr_info("MT9V111 sensor detected\n"); 1214 return; 1215 } 1216 1217 gspca_dev->usb_err = 0; 1218 sd->i2c_addr = 0x5d; 1219 i2c_w2(gspca_dev, 0xf0, 0x0000); 1220 if (gspca_dev->usb_err < 0) { 1221 gspca_dev->usb_err = 0; 1222 sd->i2c_addr = 0x48; 1223 i2c_w2(gspca_dev, 0xf0, 0x0000); 1224 } 1225 i2c_r2(gspca_dev, 0x00, &value); 1226 if (gspca_dev->usb_err >= 0 1227 && value == 0x1229) { 1228 i2c_w2_buf(gspca_dev, mt9v112_init, ARRAY_SIZE(mt9v112_init)); 1229 if (gspca_dev->usb_err < 0) { 1230 pr_err("MT9V112 sensor initialization failed\n"); 1231 return; 1232 } 1233 sd->hstart = 6; 1234 sd->vstart = 2; 1235 sd->sensor = SENSOR_MT9V112; 1236 pr_info("MT9V112 sensor detected\n"); 1237 return; 1238 } 1239 1240 gspca_dev->usb_err = -ENODEV; 1241 } 1242 1243 static void mt9m112_init_sensor(struct gspca_dev *gspca_dev) 1244 { 1245 struct sd *sd = (struct sd *) gspca_dev; 1246 1247 i2c_w2_buf(gspca_dev, mt9m112_init, ARRAY_SIZE(mt9m112_init)); 1248 if (gspca_dev->usb_err < 0) 1249 pr_err("MT9M112 sensor initialization failed\n"); 1250 1251 sd->hstart = 0; 1252 sd->vstart = 2; 1253 } 1254 1255 static void mt9m111_init_sensor(struct gspca_dev *gspca_dev) 1256 { 1257 struct sd *sd = (struct sd *) gspca_dev; 1258 1259 i2c_w2_buf(gspca_dev, mt9m111_init, ARRAY_SIZE(mt9m111_init)); 1260 if (gspca_dev->usb_err < 0) 1261 pr_err("MT9M111 sensor initialization failed\n"); 1262 1263 sd->hstart = 0; 1264 sd->vstart = 2; 1265 } 1266 1267 static void mt9m001_init_sensor(struct gspca_dev *gspca_dev) 1268 { 1269 struct sd *sd = (struct sd *) gspca_dev; 1270 u16 id; 1271 1272 i2c_r2(gspca_dev, 0x00, &id); 1273 if (gspca_dev->usb_err < 0) 1274 return; 1275 1276 /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */ 1277 switch (id) { 1278 case 0x8411: 1279 case 0x8421: 1280 pr_info("MT9M001 color sensor detected\n"); 1281 break; 1282 case 0x8431: 1283 pr_info("MT9M001 mono sensor detected\n"); 1284 break; 1285 default: 1286 pr_err("No MT9M001 chip detected, ID = %x\n\n", id); 1287 gspca_dev->usb_err = -ENODEV; 1288 return; 1289 } 1290 1291 i2c_w2_buf(gspca_dev, mt9m001_init, ARRAY_SIZE(mt9m001_init)); 1292 if (gspca_dev->usb_err < 0) 1293 pr_err("MT9M001 sensor initialization failed\n"); 1294 1295 sd->hstart = 1; 1296 sd->vstart = 1; 1297 } 1298 1299 static void hv7131r_init_sensor(struct gspca_dev *gspca_dev) 1300 { 1301 struct sd *sd = (struct sd *) gspca_dev; 1302 1303 i2c_w1_buf(gspca_dev, hv7131r_init, ARRAY_SIZE(hv7131r_init)); 1304 if (gspca_dev->usb_err < 0) 1305 pr_err("HV7131R Sensor initialization failed\n"); 1306 1307 sd->hstart = 0; 1308 sd->vstart = 1; 1309 } 1310 1311 static void set_cmatrix(struct gspca_dev *gspca_dev, 1312 s32 brightness, s32 contrast, s32 satur, s32 hue) 1313 { 1314 s32 hue_coord, hue_index = 180 + hue; 1315 u8 cmatrix[21]; 1316 1317 memset(cmatrix, 0, sizeof cmatrix); 1318 cmatrix[2] = (contrast * 0x25 / 0x100) + 0x26; 1319 cmatrix[0] = 0x13 + (cmatrix[2] - 0x26) * 0x13 / 0x25; 1320 cmatrix[4] = 0x07 + (cmatrix[2] - 0x26) * 0x07 / 0x25; 1321 cmatrix[18] = brightness - 0x80; 1322 1323 hue_coord = (hsv_red_x[hue_index] * satur) >> 8; 1324 cmatrix[6] = hue_coord; 1325 cmatrix[7] = (hue_coord >> 8) & 0x0f; 1326 1327 hue_coord = (hsv_red_y[hue_index] * satur) >> 8; 1328 cmatrix[8] = hue_coord; 1329 cmatrix[9] = (hue_coord >> 8) & 0x0f; 1330 1331 hue_coord = (hsv_green_x[hue_index] * satur) >> 8; 1332 cmatrix[10] = hue_coord; 1333 cmatrix[11] = (hue_coord >> 8) & 0x0f; 1334 1335 hue_coord = (hsv_green_y[hue_index] * satur) >> 8; 1336 cmatrix[12] = hue_coord; 1337 cmatrix[13] = (hue_coord >> 8) & 0x0f; 1338 1339 hue_coord = (hsv_blue_x[hue_index] * satur) >> 8; 1340 cmatrix[14] = hue_coord; 1341 cmatrix[15] = (hue_coord >> 8) & 0x0f; 1342 1343 hue_coord = (hsv_blue_y[hue_index] * satur) >> 8; 1344 cmatrix[16] = hue_coord; 1345 cmatrix[17] = (hue_coord >> 8) & 0x0f; 1346 1347 reg_w(gspca_dev, 0x10e1, cmatrix, 21); 1348 } 1349 1350 static void set_gamma(struct gspca_dev *gspca_dev, s32 val) 1351 { 1352 u8 gamma[17]; 1353 u8 gval = val * 0xb8 / 0x100; 1354 1355 gamma[0] = 0x0a; 1356 gamma[1] = 0x13 + (gval * (0xcb - 0x13) / 0xb8); 1357 gamma[2] = 0x25 + (gval * (0xee - 0x25) / 0xb8); 1358 gamma[3] = 0x37 + (gval * (0xfa - 0x37) / 0xb8); 1359 gamma[4] = 0x45 + (gval * (0xfc - 0x45) / 0xb8); 1360 gamma[5] = 0x55 + (gval * (0xfb - 0x55) / 0xb8); 1361 gamma[6] = 0x65 + (gval * (0xfc - 0x65) / 0xb8); 1362 gamma[7] = 0x74 + (gval * (0xfd - 0x74) / 0xb8); 1363 gamma[8] = 0x83 + (gval * (0xfe - 0x83) / 0xb8); 1364 gamma[9] = 0x92 + (gval * (0xfc - 0x92) / 0xb8); 1365 gamma[10] = 0xa1 + (gval * (0xfc - 0xa1) / 0xb8); 1366 gamma[11] = 0xb0 + (gval * (0xfc - 0xb0) / 0xb8); 1367 gamma[12] = 0xbf + (gval * (0xfb - 0xbf) / 0xb8); 1368 gamma[13] = 0xce + (gval * (0xfb - 0xce) / 0xb8); 1369 gamma[14] = 0xdf + (gval * (0xfd - 0xdf) / 0xb8); 1370 gamma[15] = 0xea + (gval * (0xf9 - 0xea) / 0xb8); 1371 gamma[16] = 0xf5; 1372 1373 reg_w(gspca_dev, 0x1190, gamma, 17); 1374 } 1375 1376 static void set_redblue(struct gspca_dev *gspca_dev, s32 blue, s32 red) 1377 { 1378 reg_w1(gspca_dev, 0x118c, red); 1379 reg_w1(gspca_dev, 0x118f, blue); 1380 } 1381 1382 static void set_hvflip(struct gspca_dev *gspca_dev, s32 hflip, s32 vflip) 1383 { 1384 u8 value, tslb; 1385 u16 value2; 1386 struct sd *sd = (struct sd *) gspca_dev; 1387 1388 if ((sd->flags & FLIP_DETECT) && dmi_check_system(flip_dmi_table)) { 1389 hflip = !hflip; 1390 vflip = !vflip; 1391 } 1392 1393 switch (sd->sensor) { 1394 case SENSOR_OV7660: 1395 value = 0x01; 1396 if (hflip) 1397 value |= 0x20; 1398 if (vflip) { 1399 value |= 0x10; 1400 sd->vstart = 2; 1401 } else { 1402 sd->vstart = 3; 1403 } 1404 reg_w1(gspca_dev, 0x1182, sd->vstart); 1405 i2c_w1(gspca_dev, 0x1e, value); 1406 break; 1407 case SENSOR_OV9650: 1408 i2c_r1(gspca_dev, 0x1e, &value); 1409 value &= ~0x30; 1410 tslb = 0x01; 1411 if (hflip) 1412 value |= 0x20; 1413 if (vflip) { 1414 value |= 0x10; 1415 tslb = 0x49; 1416 } 1417 i2c_w1(gspca_dev, 0x1e, value); 1418 i2c_w1(gspca_dev, 0x3a, tslb); 1419 break; 1420 case SENSOR_MT9V111: 1421 case SENSOR_MT9V011: 1422 i2c_r2(gspca_dev, 0x20, &value2); 1423 value2 &= ~0xc0a0; 1424 if (hflip) 1425 value2 |= 0x8080; 1426 if (vflip) 1427 value2 |= 0x4020; 1428 i2c_w2(gspca_dev, 0x20, value2); 1429 break; 1430 case SENSOR_MT9M112: 1431 case SENSOR_MT9M111: 1432 case SENSOR_MT9V112: 1433 i2c_r2(gspca_dev, 0x20, &value2); 1434 value2 &= ~0x0003; 1435 if (hflip) 1436 value2 |= 0x0002; 1437 if (vflip) 1438 value2 |= 0x0001; 1439 i2c_w2(gspca_dev, 0x20, value2); 1440 break; 1441 case SENSOR_HV7131R: 1442 i2c_r1(gspca_dev, 0x01, &value); 1443 value &= ~0x03; 1444 if (vflip) 1445 value |= 0x01; 1446 if (hflip) 1447 value |= 0x02; 1448 i2c_w1(gspca_dev, 0x01, value); 1449 break; 1450 } 1451 } 1452 1453 static void set_exposure(struct gspca_dev *gspca_dev, s32 expo) 1454 { 1455 struct sd *sd = (struct sd *) gspca_dev; 1456 u8 exp[8] = {sd->i2c_intf, sd->i2c_addr, 1457 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; 1458 int expo2; 1459 1460 if (gspca_dev->streaming) 1461 exp[7] = 0x1e; 1462 1463 switch (sd->sensor) { 1464 case SENSOR_OV7660: 1465 case SENSOR_OV7670: 1466 case SENSOR_OV9655: 1467 case SENSOR_OV9650: 1468 if (expo > 547) 1469 expo2 = 547; 1470 else 1471 expo2 = expo; 1472 exp[0] |= (2 << 4); 1473 exp[2] = 0x10; /* AECH */ 1474 exp[3] = expo2 >> 2; 1475 exp[7] = 0x10; 1476 i2c_w(gspca_dev, exp); 1477 exp[2] = 0x04; /* COM1 */ 1478 exp[3] = expo2 & 0x0003; 1479 exp[7] = 0x10; 1480 i2c_w(gspca_dev, exp); 1481 expo -= expo2; 1482 exp[7] = 0x1e; 1483 exp[0] |= (3 << 4); 1484 exp[2] = 0x2d; /* ADVFL & ADVFH */ 1485 exp[3] = expo; 1486 exp[4] = expo >> 8; 1487 break; 1488 case SENSOR_MT9M001: 1489 case SENSOR_MT9V112: 1490 case SENSOR_MT9V011: 1491 exp[0] |= (3 << 4); 1492 exp[2] = 0x09; 1493 exp[3] = expo >> 8; 1494 exp[4] = expo; 1495 break; 1496 case SENSOR_HV7131R: 1497 exp[0] |= (4 << 4); 1498 exp[2] = 0x25; 1499 exp[3] = expo >> 5; 1500 exp[4] = expo << 3; 1501 exp[5] = 0; 1502 break; 1503 default: 1504 return; 1505 } 1506 i2c_w(gspca_dev, exp); 1507 } 1508 1509 static void set_gain(struct gspca_dev *gspca_dev, s32 g) 1510 { 1511 struct sd *sd = (struct sd *) gspca_dev; 1512 u8 gain[8] = {sd->i2c_intf, sd->i2c_addr, 1513 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; 1514 1515 if (gspca_dev->streaming) 1516 gain[7] = 0x15; /* or 1d ? */ 1517 1518 switch (sd->sensor) { 1519 case SENSOR_OV7660: 1520 case SENSOR_OV7670: 1521 case SENSOR_SOI968: 1522 case SENSOR_OV9655: 1523 case SENSOR_OV9650: 1524 gain[0] |= (2 << 4); 1525 gain[3] = ov_gain[g]; 1526 break; 1527 case SENSOR_MT9V011: 1528 gain[0] |= (3 << 4); 1529 gain[2] = 0x35; 1530 gain[3] = micron1_gain[g] >> 8; 1531 gain[4] = micron1_gain[g]; 1532 break; 1533 case SENSOR_MT9V112: 1534 gain[0] |= (3 << 4); 1535 gain[2] = 0x2f; 1536 gain[3] = micron1_gain[g] >> 8; 1537 gain[4] = micron1_gain[g]; 1538 break; 1539 case SENSOR_MT9M001: 1540 gain[0] |= (3 << 4); 1541 gain[2] = 0x2f; 1542 gain[3] = micron2_gain[g] >> 8; 1543 gain[4] = micron2_gain[g]; 1544 break; 1545 case SENSOR_HV7131R: 1546 gain[0] |= (2 << 4); 1547 gain[2] = 0x30; 1548 gain[3] = hv7131r_gain[g]; 1549 break; 1550 default: 1551 return; 1552 } 1553 i2c_w(gspca_dev, gain); 1554 } 1555 1556 static void set_quality(struct gspca_dev *gspca_dev, s32 val) 1557 { 1558 struct sd *sd = (struct sd *) gspca_dev; 1559 1560 jpeg_set_qual(sd->jpeg_hdr, val); 1561 reg_w1(gspca_dev, 0x1061, 0x01); /* stop transfer */ 1562 reg_w1(gspca_dev, 0x10e0, sd->fmt | 0x20); /* write QTAB */ 1563 reg_w(gspca_dev, 0x1100, &sd->jpeg_hdr[JPEG_QT0_OFFSET], 64); 1564 reg_w(gspca_dev, 0x1140, &sd->jpeg_hdr[JPEG_QT1_OFFSET], 64); 1565 reg_w1(gspca_dev, 0x1061, 0x03); /* restart transfer */ 1566 reg_w1(gspca_dev, 0x10e0, sd->fmt); 1567 sd->fmt ^= 0x0c; /* invert QTAB use + write */ 1568 reg_w1(gspca_dev, 0x10e0, sd->fmt); 1569 } 1570 1571 #ifdef CONFIG_VIDEO_ADV_DEBUG 1572 static int sd_dbg_g_register(struct gspca_dev *gspca_dev, 1573 struct v4l2_dbg_register *reg) 1574 { 1575 struct sd *sd = (struct sd *) gspca_dev; 1576 1577 switch (reg->match.type) { 1578 case V4L2_CHIP_MATCH_HOST: 1579 if (reg->match.addr != 0) 1580 return -EINVAL; 1581 if (reg->reg < 0x1000 || reg->reg > 0x11ff) 1582 return -EINVAL; 1583 reg_r(gspca_dev, reg->reg, 1); 1584 reg->val = gspca_dev->usb_buf[0]; 1585 return gspca_dev->usb_err; 1586 case V4L2_CHIP_MATCH_I2C_ADDR: 1587 if (reg->match.addr != sd->i2c_addr) 1588 return -EINVAL; 1589 if (sd->sensor >= SENSOR_MT9V011 && 1590 sd->sensor <= SENSOR_MT9M112) { 1591 i2c_r2(gspca_dev, reg->reg, (u16 *) ®->val); 1592 } else { 1593 i2c_r1(gspca_dev, reg->reg, (u8 *) ®->val); 1594 } 1595 return gspca_dev->usb_err; 1596 } 1597 return -EINVAL; 1598 } 1599 1600 static int sd_dbg_s_register(struct gspca_dev *gspca_dev, 1601 const struct v4l2_dbg_register *reg) 1602 { 1603 struct sd *sd = (struct sd *) gspca_dev; 1604 1605 switch (reg->match.type) { 1606 case V4L2_CHIP_MATCH_HOST: 1607 if (reg->match.addr != 0) 1608 return -EINVAL; 1609 if (reg->reg < 0x1000 || reg->reg > 0x11ff) 1610 return -EINVAL; 1611 reg_w1(gspca_dev, reg->reg, reg->val); 1612 return gspca_dev->usb_err; 1613 case V4L2_CHIP_MATCH_I2C_ADDR: 1614 if (reg->match.addr != sd->i2c_addr) 1615 return -EINVAL; 1616 if (sd->sensor >= SENSOR_MT9V011 && 1617 sd->sensor <= SENSOR_MT9M112) { 1618 i2c_w2(gspca_dev, reg->reg, reg->val); 1619 } else { 1620 i2c_w1(gspca_dev, reg->reg, reg->val); 1621 } 1622 return gspca_dev->usb_err; 1623 } 1624 return -EINVAL; 1625 } 1626 #endif 1627 1628 static int sd_chip_ident(struct gspca_dev *gspca_dev, 1629 struct v4l2_dbg_chip_ident *chip) 1630 { 1631 struct sd *sd = (struct sd *) gspca_dev; 1632 1633 switch (chip->match.type) { 1634 case V4L2_CHIP_MATCH_HOST: 1635 if (chip->match.addr != 0) 1636 return -EINVAL; 1637 chip->revision = 0; 1638 chip->ident = V4L2_IDENT_SN9C20X; 1639 return 0; 1640 case V4L2_CHIP_MATCH_I2C_ADDR: 1641 if (chip->match.addr != sd->i2c_addr) 1642 return -EINVAL; 1643 chip->revision = 0; 1644 chip->ident = i2c_ident[sd->sensor]; 1645 return 0; 1646 } 1647 return -EINVAL; 1648 } 1649 1650 static int sd_config(struct gspca_dev *gspca_dev, 1651 const struct usb_device_id *id) 1652 { 1653 struct sd *sd = (struct sd *) gspca_dev; 1654 struct cam *cam; 1655 1656 cam = &gspca_dev->cam; 1657 cam->needs_full_bandwidth = 1; 1658 1659 sd->sensor = id->driver_info >> 8; 1660 sd->i2c_addr = id->driver_info; 1661 sd->flags = id->driver_info >> 16; 1662 sd->i2c_intf = 0x80; /* i2c 100 Kb/s */ 1663 1664 switch (sd->sensor) { 1665 case SENSOR_MT9M112: 1666 case SENSOR_MT9M111: 1667 case SENSOR_OV9650: 1668 case SENSOR_SOI968: 1669 cam->cam_mode = sxga_mode; 1670 cam->nmodes = ARRAY_SIZE(sxga_mode); 1671 break; 1672 case SENSOR_MT9M001: 1673 cam->cam_mode = mono_mode; 1674 cam->nmodes = ARRAY_SIZE(mono_mode); 1675 break; 1676 case SENSOR_HV7131R: 1677 sd->i2c_intf = 0x81; /* i2c 400 Kb/s */ 1678 /* fall thru */ 1679 default: 1680 cam->cam_mode = vga_mode; 1681 cam->nmodes = ARRAY_SIZE(vga_mode); 1682 break; 1683 } 1684 1685 sd->old_step = 0; 1686 sd->older_step = 0; 1687 sd->exposure_step = 16; 1688 1689 INIT_WORK(&sd->work, qual_upd); 1690 1691 return 0; 1692 } 1693 1694 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 1695 { 1696 struct gspca_dev *gspca_dev = 1697 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 1698 struct sd *sd = (struct sd *)gspca_dev; 1699 1700 gspca_dev->usb_err = 0; 1701 1702 if (!gspca_dev->streaming) 1703 return 0; 1704 1705 switch (ctrl->id) { 1706 /* color control cluster */ 1707 case V4L2_CID_BRIGHTNESS: 1708 set_cmatrix(gspca_dev, sd->brightness->val, 1709 sd->contrast->val, sd->saturation->val, sd->hue->val); 1710 break; 1711 case V4L2_CID_GAMMA: 1712 set_gamma(gspca_dev, ctrl->val); 1713 break; 1714 /* blue/red balance cluster */ 1715 case V4L2_CID_BLUE_BALANCE: 1716 set_redblue(gspca_dev, sd->blue->val, sd->red->val); 1717 break; 1718 /* h/vflip cluster */ 1719 case V4L2_CID_HFLIP: 1720 set_hvflip(gspca_dev, sd->hflip->val, sd->vflip->val); 1721 break; 1722 /* standalone exposure control */ 1723 case V4L2_CID_EXPOSURE: 1724 set_exposure(gspca_dev, ctrl->val); 1725 break; 1726 /* standalone gain control */ 1727 case V4L2_CID_GAIN: 1728 set_gain(gspca_dev, ctrl->val); 1729 break; 1730 /* autogain + exposure or gain control cluster */ 1731 case V4L2_CID_AUTOGAIN: 1732 if (sd->sensor == SENSOR_SOI968) 1733 set_gain(gspca_dev, sd->gain->val); 1734 else 1735 set_exposure(gspca_dev, sd->exposure->val); 1736 break; 1737 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 1738 set_quality(gspca_dev, ctrl->val); 1739 break; 1740 } 1741 return gspca_dev->usb_err; 1742 } 1743 1744 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 1745 .s_ctrl = sd_s_ctrl, 1746 }; 1747 1748 static int sd_init_controls(struct gspca_dev *gspca_dev) 1749 { 1750 struct sd *sd = (struct sd *) gspca_dev; 1751 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 1752 1753 gspca_dev->vdev.ctrl_handler = hdl; 1754 v4l2_ctrl_handler_init(hdl, 13); 1755 1756 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1757 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127); 1758 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1759 V4L2_CID_CONTRAST, 0, 255, 1, 127); 1760 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1761 V4L2_CID_SATURATION, 0, 255, 1, 127); 1762 sd->hue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1763 V4L2_CID_HUE, -180, 180, 1, 0); 1764 1765 sd->gamma = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1766 V4L2_CID_GAMMA, 0, 255, 1, 0x10); 1767 1768 sd->blue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1769 V4L2_CID_BLUE_BALANCE, 0, 127, 1, 0x28); 1770 sd->red = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1771 V4L2_CID_RED_BALANCE, 0, 127, 1, 0x28); 1772 1773 if (sd->sensor != SENSOR_OV9655 && sd->sensor != SENSOR_SOI968 && 1774 sd->sensor != SENSOR_OV7670 && sd->sensor != SENSOR_MT9M001 && 1775 sd->sensor != SENSOR_MT9VPRB) { 1776 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1777 V4L2_CID_HFLIP, 0, 1, 1, 0); 1778 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1779 V4L2_CID_VFLIP, 0, 1, 1, 0); 1780 } 1781 1782 if (sd->sensor != SENSOR_SOI968 && sd->sensor != SENSOR_MT9VPRB && 1783 sd->sensor != SENSOR_MT9M112 && sd->sensor != SENSOR_MT9M111 && 1784 sd->sensor != SENSOR_MT9V111) 1785 sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1786 V4L2_CID_EXPOSURE, 0, 0x1780, 1, 0x33); 1787 1788 if (sd->sensor != SENSOR_MT9VPRB && sd->sensor != SENSOR_MT9M112 && 1789 sd->sensor != SENSOR_MT9M111 && sd->sensor != SENSOR_MT9V111) { 1790 sd->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1791 V4L2_CID_GAIN, 0, 28, 1, 0); 1792 sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1793 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 1794 } 1795 1796 sd->jpegqual = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 1797 V4L2_CID_JPEG_COMPRESSION_QUALITY, 50, 90, 1, 80); 1798 if (hdl->error) { 1799 pr_err("Could not initialize controls\n"); 1800 return hdl->error; 1801 } 1802 1803 v4l2_ctrl_cluster(4, &sd->brightness); 1804 v4l2_ctrl_cluster(2, &sd->blue); 1805 if (sd->hflip) 1806 v4l2_ctrl_cluster(2, &sd->hflip); 1807 if (sd->autogain) { 1808 if (sd->sensor == SENSOR_SOI968) 1809 /* this sensor doesn't have the exposure control and 1810 autogain is clustered with gain instead. This works 1811 because sd->exposure == NULL. */ 1812 v4l2_ctrl_auto_cluster(3, &sd->autogain, 0, false); 1813 else 1814 /* Otherwise autogain is clustered with exposure. */ 1815 v4l2_ctrl_auto_cluster(2, &sd->autogain, 0, false); 1816 } 1817 return 0; 1818 } 1819 1820 static int sd_init(struct gspca_dev *gspca_dev) 1821 { 1822 struct sd *sd = (struct sd *) gspca_dev; 1823 int i; 1824 u8 value; 1825 u8 i2c_init[9] = 1826 {0x80, sd->i2c_addr, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}; 1827 1828 for (i = 0; i < ARRAY_SIZE(bridge_init); i++) { 1829 value = bridge_init[i][1]; 1830 reg_w(gspca_dev, bridge_init[i][0], &value, 1); 1831 if (gspca_dev->usb_err < 0) { 1832 pr_err("Device initialization failed\n"); 1833 return gspca_dev->usb_err; 1834 } 1835 } 1836 1837 if (sd->flags & LED_REVERSE) 1838 reg_w1(gspca_dev, 0x1006, 0x00); 1839 else 1840 reg_w1(gspca_dev, 0x1006, 0x20); 1841 1842 reg_w(gspca_dev, 0x10c0, i2c_init, 9); 1843 if (gspca_dev->usb_err < 0) { 1844 pr_err("Device initialization failed\n"); 1845 return gspca_dev->usb_err; 1846 } 1847 1848 switch (sd->sensor) { 1849 case SENSOR_OV9650: 1850 ov9650_init_sensor(gspca_dev); 1851 if (gspca_dev->usb_err < 0) 1852 break; 1853 pr_info("OV9650 sensor detected\n"); 1854 break; 1855 case SENSOR_OV9655: 1856 ov9655_init_sensor(gspca_dev); 1857 if (gspca_dev->usb_err < 0) 1858 break; 1859 pr_info("OV9655 sensor detected\n"); 1860 break; 1861 case SENSOR_SOI968: 1862 soi968_init_sensor(gspca_dev); 1863 if (gspca_dev->usb_err < 0) 1864 break; 1865 pr_info("SOI968 sensor detected\n"); 1866 break; 1867 case SENSOR_OV7660: 1868 ov7660_init_sensor(gspca_dev); 1869 if (gspca_dev->usb_err < 0) 1870 break; 1871 pr_info("OV7660 sensor detected\n"); 1872 break; 1873 case SENSOR_OV7670: 1874 ov7670_init_sensor(gspca_dev); 1875 if (gspca_dev->usb_err < 0) 1876 break; 1877 pr_info("OV7670 sensor detected\n"); 1878 break; 1879 case SENSOR_MT9VPRB: 1880 mt9v_init_sensor(gspca_dev); 1881 if (gspca_dev->usb_err < 0) 1882 break; 1883 pr_info("MT9VPRB sensor detected\n"); 1884 break; 1885 case SENSOR_MT9M111: 1886 mt9m111_init_sensor(gspca_dev); 1887 if (gspca_dev->usb_err < 0) 1888 break; 1889 pr_info("MT9M111 sensor detected\n"); 1890 break; 1891 case SENSOR_MT9M112: 1892 mt9m112_init_sensor(gspca_dev); 1893 if (gspca_dev->usb_err < 0) 1894 break; 1895 pr_info("MT9M112 sensor detected\n"); 1896 break; 1897 case SENSOR_MT9M001: 1898 mt9m001_init_sensor(gspca_dev); 1899 if (gspca_dev->usb_err < 0) 1900 break; 1901 break; 1902 case SENSOR_HV7131R: 1903 hv7131r_init_sensor(gspca_dev); 1904 if (gspca_dev->usb_err < 0) 1905 break; 1906 pr_info("HV7131R sensor detected\n"); 1907 break; 1908 default: 1909 pr_err("Unsupported sensor\n"); 1910 gspca_dev->usb_err = -ENODEV; 1911 } 1912 return gspca_dev->usb_err; 1913 } 1914 1915 static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode) 1916 { 1917 struct sd *sd = (struct sd *) gspca_dev; 1918 u8 value; 1919 1920 switch (sd->sensor) { 1921 case SENSOR_SOI968: 1922 if (mode & MODE_SXGA) { 1923 i2c_w1(gspca_dev, 0x17, 0x1d); 1924 i2c_w1(gspca_dev, 0x18, 0xbd); 1925 i2c_w1(gspca_dev, 0x19, 0x01); 1926 i2c_w1(gspca_dev, 0x1a, 0x81); 1927 i2c_w1(gspca_dev, 0x12, 0x00); 1928 sd->hstart = 140; 1929 sd->vstart = 19; 1930 } else { 1931 i2c_w1(gspca_dev, 0x17, 0x13); 1932 i2c_w1(gspca_dev, 0x18, 0x63); 1933 i2c_w1(gspca_dev, 0x19, 0x01); 1934 i2c_w1(gspca_dev, 0x1a, 0x79); 1935 i2c_w1(gspca_dev, 0x12, 0x40); 1936 sd->hstart = 60; 1937 sd->vstart = 11; 1938 } 1939 break; 1940 case SENSOR_OV9650: 1941 if (mode & MODE_SXGA) { 1942 i2c_w1(gspca_dev, 0x17, 0x1b); 1943 i2c_w1(gspca_dev, 0x18, 0xbc); 1944 i2c_w1(gspca_dev, 0x19, 0x01); 1945 i2c_w1(gspca_dev, 0x1a, 0x82); 1946 i2c_r1(gspca_dev, 0x12, &value); 1947 i2c_w1(gspca_dev, 0x12, value & 0x07); 1948 } else { 1949 i2c_w1(gspca_dev, 0x17, 0x24); 1950 i2c_w1(gspca_dev, 0x18, 0xc5); 1951 i2c_w1(gspca_dev, 0x19, 0x00); 1952 i2c_w1(gspca_dev, 0x1a, 0x3c); 1953 i2c_r1(gspca_dev, 0x12, &value); 1954 i2c_w1(gspca_dev, 0x12, (value & 0x7) | 0x40); 1955 } 1956 break; 1957 case SENSOR_MT9M112: 1958 case SENSOR_MT9M111: 1959 if (mode & MODE_SXGA) { 1960 i2c_w2(gspca_dev, 0xf0, 0x0002); 1961 i2c_w2(gspca_dev, 0xc8, 0x970b); 1962 i2c_w2(gspca_dev, 0xf0, 0x0000); 1963 } else { 1964 i2c_w2(gspca_dev, 0xf0, 0x0002); 1965 i2c_w2(gspca_dev, 0xc8, 0x8000); 1966 i2c_w2(gspca_dev, 0xf0, 0x0000); 1967 } 1968 break; 1969 } 1970 } 1971 1972 static int sd_isoc_init(struct gspca_dev *gspca_dev) 1973 { 1974 struct usb_interface *intf; 1975 u32 flags = gspca_dev->cam.cam_mode[(int)gspca_dev->curr_mode].priv; 1976 1977 /* 1978 * When using the SN9C20X_I420 fmt the sn9c20x needs more bandwidth 1979 * than our regular bandwidth calculations reserve, so we force the 1980 * use of a specific altsetting when using the SN9C20X_I420 fmt. 1981 */ 1982 if (!(flags & (MODE_RAW | MODE_JPEG))) { 1983 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface); 1984 1985 if (intf->num_altsetting != 9) { 1986 pr_warn("sn9c20x camera with unknown number of alt " 1987 "settings (%d), please report!\n", 1988 intf->num_altsetting); 1989 gspca_dev->alt = intf->num_altsetting; 1990 return 0; 1991 } 1992 1993 switch (gspca_dev->width) { 1994 case 160: /* 160x120 */ 1995 gspca_dev->alt = 2; 1996 break; 1997 case 320: /* 320x240 */ 1998 gspca_dev->alt = 6; 1999 break; 2000 default: /* >= 640x480 */ 2001 gspca_dev->alt = 9; 2002 break; 2003 } 2004 } 2005 2006 return 0; 2007 } 2008 2009 #define HW_WIN(mode, hstart, vstart) \ 2010 ((const u8 []){hstart, 0, vstart, 0, \ 2011 (mode & MODE_SXGA ? 1280 >> 4 : 640 >> 4), \ 2012 (mode & MODE_SXGA ? 1024 >> 3 : 480 >> 3)}) 2013 2014 #define CLR_WIN(width, height) \ 2015 ((const u8 [])\ 2016 {0, width >> 2, 0, height >> 1,\ 2017 ((width >> 10) & 0x01) | ((height >> 8) & 0x6)}) 2018 2019 static int sd_start(struct gspca_dev *gspca_dev) 2020 { 2021 struct sd *sd = (struct sd *) gspca_dev; 2022 int mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv; 2023 int width = gspca_dev->width; 2024 int height = gspca_dev->height; 2025 u8 fmt, scale = 0; 2026 2027 jpeg_define(sd->jpeg_hdr, height, width, 2028 0x21); 2029 jpeg_set_qual(sd->jpeg_hdr, v4l2_ctrl_g_ctrl(sd->jpegqual)); 2030 2031 if (mode & MODE_RAW) 2032 fmt = 0x2d; 2033 else if (mode & MODE_JPEG) 2034 fmt = 0x24; 2035 else 2036 fmt = 0x2f; /* YUV 420 */ 2037 sd->fmt = fmt; 2038 2039 switch (mode & SCALE_MASK) { 2040 case SCALE_1280x1024: 2041 scale = 0xc0; 2042 pr_info("Set 1280x1024\n"); 2043 break; 2044 case SCALE_640x480: 2045 scale = 0x80; 2046 pr_info("Set 640x480\n"); 2047 break; 2048 case SCALE_320x240: 2049 scale = 0x90; 2050 pr_info("Set 320x240\n"); 2051 break; 2052 case SCALE_160x120: 2053 scale = 0xa0; 2054 pr_info("Set 160x120\n"); 2055 break; 2056 } 2057 2058 configure_sensor_output(gspca_dev, mode); 2059 reg_w(gspca_dev, 0x1100, &sd->jpeg_hdr[JPEG_QT0_OFFSET], 64); 2060 reg_w(gspca_dev, 0x1140, &sd->jpeg_hdr[JPEG_QT1_OFFSET], 64); 2061 reg_w(gspca_dev, 0x10fb, CLR_WIN(width, height), 5); 2062 reg_w(gspca_dev, 0x1180, HW_WIN(mode, sd->hstart, sd->vstart), 6); 2063 reg_w1(gspca_dev, 0x1189, scale); 2064 reg_w1(gspca_dev, 0x10e0, fmt); 2065 2066 set_cmatrix(gspca_dev, v4l2_ctrl_g_ctrl(sd->brightness), 2067 v4l2_ctrl_g_ctrl(sd->contrast), 2068 v4l2_ctrl_g_ctrl(sd->saturation), 2069 v4l2_ctrl_g_ctrl(sd->hue)); 2070 set_gamma(gspca_dev, v4l2_ctrl_g_ctrl(sd->gamma)); 2071 set_redblue(gspca_dev, v4l2_ctrl_g_ctrl(sd->blue), 2072 v4l2_ctrl_g_ctrl(sd->red)); 2073 if (sd->gain) 2074 set_gain(gspca_dev, v4l2_ctrl_g_ctrl(sd->gain)); 2075 if (sd->exposure) 2076 set_exposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure)); 2077 if (sd->hflip) 2078 set_hvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip), 2079 v4l2_ctrl_g_ctrl(sd->vflip)); 2080 2081 reg_w1(gspca_dev, 0x1007, 0x20); 2082 reg_w1(gspca_dev, 0x1061, 0x03); 2083 2084 /* if JPEG, prepare the compression quality update */ 2085 if (mode & MODE_JPEG) { 2086 sd->pktsz = sd->npkt = 0; 2087 sd->nchg = 0; 2088 sd->work_thread = 2089 create_singlethread_workqueue(KBUILD_MODNAME); 2090 } 2091 2092 return gspca_dev->usb_err; 2093 } 2094 2095 static void sd_stopN(struct gspca_dev *gspca_dev) 2096 { 2097 reg_w1(gspca_dev, 0x1007, 0x00); 2098 reg_w1(gspca_dev, 0x1061, 0x01); 2099 } 2100 2101 /* called on streamoff with alt==0 and on disconnect */ 2102 /* the usb_lock is held at entry - restore on exit */ 2103 static void sd_stop0(struct gspca_dev *gspca_dev) 2104 { 2105 struct sd *sd = (struct sd *) gspca_dev; 2106 2107 if (sd->work_thread != NULL) { 2108 mutex_unlock(&gspca_dev->usb_lock); 2109 destroy_workqueue(sd->work_thread); 2110 mutex_lock(&gspca_dev->usb_lock); 2111 sd->work_thread = NULL; 2112 } 2113 } 2114 2115 static void do_autoexposure(struct gspca_dev *gspca_dev, u16 avg_lum) 2116 { 2117 struct sd *sd = (struct sd *) gspca_dev; 2118 s32 cur_exp = v4l2_ctrl_g_ctrl(sd->exposure); 2119 s32 max = sd->exposure->maximum - sd->exposure_step; 2120 s32 min = sd->exposure->minimum + sd->exposure_step; 2121 s16 new_exp; 2122 2123 /* 2124 * some hardcoded values are present 2125 * like those for maximal/minimal exposure 2126 * and exposure steps 2127 */ 2128 if (avg_lum < MIN_AVG_LUM) { 2129 if (cur_exp > max) 2130 return; 2131 2132 new_exp = cur_exp + sd->exposure_step; 2133 if (new_exp > max) 2134 new_exp = max; 2135 if (new_exp < min) 2136 new_exp = min; 2137 v4l2_ctrl_s_ctrl(sd->exposure, new_exp); 2138 2139 sd->older_step = sd->old_step; 2140 sd->old_step = 1; 2141 2142 if (sd->old_step ^ sd->older_step) 2143 sd->exposure_step /= 2; 2144 else 2145 sd->exposure_step += 2; 2146 } 2147 if (avg_lum > MAX_AVG_LUM) { 2148 if (cur_exp < min) 2149 return; 2150 new_exp = cur_exp - sd->exposure_step; 2151 if (new_exp > max) 2152 new_exp = max; 2153 if (new_exp < min) 2154 new_exp = min; 2155 v4l2_ctrl_s_ctrl(sd->exposure, new_exp); 2156 sd->older_step = sd->old_step; 2157 sd->old_step = 0; 2158 2159 if (sd->old_step ^ sd->older_step) 2160 sd->exposure_step /= 2; 2161 else 2162 sd->exposure_step += 2; 2163 } 2164 } 2165 2166 static void do_autogain(struct gspca_dev *gspca_dev, u16 avg_lum) 2167 { 2168 struct sd *sd = (struct sd *) gspca_dev; 2169 s32 cur_gain = v4l2_ctrl_g_ctrl(sd->gain); 2170 2171 if (avg_lum < MIN_AVG_LUM && cur_gain < sd->gain->maximum) 2172 v4l2_ctrl_s_ctrl(sd->gain, cur_gain + 1); 2173 if (avg_lum > MAX_AVG_LUM && cur_gain > sd->gain->minimum) 2174 v4l2_ctrl_s_ctrl(sd->gain, cur_gain - 1); 2175 } 2176 2177 static void sd_dqcallback(struct gspca_dev *gspca_dev) 2178 { 2179 struct sd *sd = (struct sd *) gspca_dev; 2180 int avg_lum; 2181 2182 if (sd->autogain == NULL || !v4l2_ctrl_g_ctrl(sd->autogain)) 2183 return; 2184 2185 avg_lum = atomic_read(&sd->avg_lum); 2186 if (sd->sensor == SENSOR_SOI968) 2187 do_autogain(gspca_dev, avg_lum); 2188 else 2189 do_autoexposure(gspca_dev, avg_lum); 2190 } 2191 2192 /* JPEG quality update */ 2193 /* This function is executed from a work queue. */ 2194 static void qual_upd(struct work_struct *work) 2195 { 2196 struct sd *sd = container_of(work, struct sd, work); 2197 struct gspca_dev *gspca_dev = &sd->gspca_dev; 2198 s32 qual = v4l2_ctrl_g_ctrl(sd->jpegqual); 2199 2200 /* To protect gspca_dev->usb_buf and gspca_dev->usb_err */ 2201 mutex_lock(&gspca_dev->usb_lock); 2202 PDEBUG(D_STREAM, "qual_upd %d%%", qual); 2203 gspca_dev->usb_err = 0; 2204 set_quality(gspca_dev, qual); 2205 mutex_unlock(&gspca_dev->usb_lock); 2206 } 2207 2208 #if IS_ENABLED(CONFIG_INPUT) 2209 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, 2210 u8 *data, /* interrupt packet */ 2211 int len) /* interrupt packet length */ 2212 { 2213 struct sd *sd = (struct sd *) gspca_dev; 2214 2215 if (!(sd->flags & HAS_NO_BUTTON) && len == 1) { 2216 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1); 2217 input_sync(gspca_dev->input_dev); 2218 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 2219 input_sync(gspca_dev->input_dev); 2220 return 0; 2221 } 2222 return -EINVAL; 2223 } 2224 #endif 2225 2226 /* check the JPEG compression */ 2227 static void transfer_check(struct gspca_dev *gspca_dev, 2228 u8 *data) 2229 { 2230 struct sd *sd = (struct sd *) gspca_dev; 2231 int new_qual, r; 2232 2233 new_qual = 0; 2234 2235 /* if USB error, discard the frame and decrease the quality */ 2236 if (data[6] & 0x08) { /* USB FIFO full */ 2237 gspca_dev->last_packet_type = DISCARD_PACKET; 2238 new_qual = -5; 2239 } else { 2240 2241 /* else, compute the filling rate and a new JPEG quality */ 2242 r = (sd->pktsz * 100) / 2243 (sd->npkt * 2244 gspca_dev->urb[0]->iso_frame_desc[0].length); 2245 if (r >= 85) 2246 new_qual = -3; 2247 else if (r < 75) 2248 new_qual = 2; 2249 } 2250 if (new_qual != 0) { 2251 sd->nchg += new_qual; 2252 if (sd->nchg < -6 || sd->nchg >= 12) { 2253 /* Note: we are in interrupt context, so we can't 2254 use v4l2_ctrl_g/s_ctrl here. Access the value 2255 directly instead. */ 2256 s32 curqual = sd->jpegqual->cur.val; 2257 sd->nchg = 0; 2258 new_qual += curqual; 2259 if (new_qual < sd->jpegqual->minimum) 2260 new_qual = sd->jpegqual->minimum; 2261 else if (new_qual > sd->jpegqual->maximum) 2262 new_qual = sd->jpegqual->maximum; 2263 if (new_qual != curqual) { 2264 sd->jpegqual->cur.val = new_qual; 2265 queue_work(sd->work_thread, &sd->work); 2266 } 2267 } 2268 } else { 2269 sd->nchg = 0; 2270 } 2271 sd->pktsz = sd->npkt = 0; 2272 } 2273 2274 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 2275 u8 *data, /* isoc packet */ 2276 int len) /* iso packet length */ 2277 { 2278 struct sd *sd = (struct sd *) gspca_dev; 2279 int avg_lum, is_jpeg; 2280 static const u8 frame_header[] = 2281 {0xff, 0xff, 0x00, 0xc4, 0xc4, 0x96}; 2282 2283 is_jpeg = (sd->fmt & 0x03) == 0; 2284 if (len >= 64 && memcmp(data, frame_header, 6) == 0) { 2285 avg_lum = ((data[35] >> 2) & 3) | 2286 (data[20] << 2) | 2287 (data[19] << 10); 2288 avg_lum += ((data[35] >> 4) & 3) | 2289 (data[22] << 2) | 2290 (data[21] << 10); 2291 avg_lum += ((data[35] >> 6) & 3) | 2292 (data[24] << 2) | 2293 (data[23] << 10); 2294 avg_lum += (data[36] & 3) | 2295 (data[26] << 2) | 2296 (data[25] << 10); 2297 avg_lum += ((data[36] >> 2) & 3) | 2298 (data[28] << 2) | 2299 (data[27] << 10); 2300 avg_lum += ((data[36] >> 4) & 3) | 2301 (data[30] << 2) | 2302 (data[29] << 10); 2303 avg_lum += ((data[36] >> 6) & 3) | 2304 (data[32] << 2) | 2305 (data[31] << 10); 2306 avg_lum += ((data[44] >> 4) & 3) | 2307 (data[34] << 2) | 2308 (data[33] << 10); 2309 avg_lum >>= 9; 2310 atomic_set(&sd->avg_lum, avg_lum); 2311 2312 if (is_jpeg) 2313 transfer_check(gspca_dev, data); 2314 2315 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0); 2316 len -= 64; 2317 if (len == 0) 2318 return; 2319 data += 64; 2320 } 2321 if (gspca_dev->last_packet_type == LAST_PACKET) { 2322 if (is_jpeg) { 2323 gspca_frame_add(gspca_dev, FIRST_PACKET, 2324 sd->jpeg_hdr, JPEG_HDR_SZ); 2325 gspca_frame_add(gspca_dev, INTER_PACKET, 2326 data, len); 2327 } else { 2328 gspca_frame_add(gspca_dev, FIRST_PACKET, 2329 data, len); 2330 } 2331 } else { 2332 /* if JPEG, count the packets and their size */ 2333 if (is_jpeg) { 2334 sd->npkt++; 2335 sd->pktsz += len; 2336 } 2337 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 2338 } 2339 } 2340 2341 /* sub-driver description */ 2342 static const struct sd_desc sd_desc = { 2343 .name = KBUILD_MODNAME, 2344 .config = sd_config, 2345 .init = sd_init, 2346 .init_controls = sd_init_controls, 2347 .isoc_init = sd_isoc_init, 2348 .start = sd_start, 2349 .stopN = sd_stopN, 2350 .stop0 = sd_stop0, 2351 .pkt_scan = sd_pkt_scan, 2352 #if IS_ENABLED(CONFIG_INPUT) 2353 .int_pkt_scan = sd_int_pkt_scan, 2354 #endif 2355 .dq_callback = sd_dqcallback, 2356 #ifdef CONFIG_VIDEO_ADV_DEBUG 2357 .set_register = sd_dbg_s_register, 2358 .get_register = sd_dbg_g_register, 2359 #endif 2360 .get_chip_ident = sd_chip_ident, 2361 }; 2362 2363 #define SN9C20X(sensor, i2c_addr, flags) \ 2364 .driver_info = ((flags & 0xff) << 16) \ 2365 | (SENSOR_ ## sensor << 8) \ 2366 | (i2c_addr) 2367 2368 static const struct usb_device_id device_table[] = { 2369 {USB_DEVICE(0x0c45, 0x6240), SN9C20X(MT9M001, 0x5d, 0)}, 2370 {USB_DEVICE(0x0c45, 0x6242), SN9C20X(MT9M111, 0x5d, 0)}, 2371 {USB_DEVICE(0x0c45, 0x6248), SN9C20X(OV9655, 0x30, 0)}, 2372 {USB_DEVICE(0x0c45, 0x624c), SN9C20X(MT9M112, 0x5d, 0)}, 2373 {USB_DEVICE(0x0c45, 0x624e), SN9C20X(SOI968, 0x30, LED_REVERSE)}, 2374 {USB_DEVICE(0x0c45, 0x624f), SN9C20X(OV9650, 0x30, 2375 (FLIP_DETECT | HAS_NO_BUTTON))}, 2376 {USB_DEVICE(0x0c45, 0x6251), SN9C20X(OV9650, 0x30, 0)}, 2377 {USB_DEVICE(0x0c45, 0x6253), SN9C20X(OV9650, 0x30, 0)}, 2378 {USB_DEVICE(0x0c45, 0x6260), SN9C20X(OV7670, 0x21, 0)}, 2379 {USB_DEVICE(0x0c45, 0x6270), SN9C20X(MT9VPRB, 0x00, 0)}, 2380 {USB_DEVICE(0x0c45, 0x627b), SN9C20X(OV7660, 0x21, FLIP_DETECT)}, 2381 {USB_DEVICE(0x0c45, 0x627c), SN9C20X(HV7131R, 0x11, 0)}, 2382 {USB_DEVICE(0x0c45, 0x627f), SN9C20X(OV9650, 0x30, 0)}, 2383 {USB_DEVICE(0x0c45, 0x6280), SN9C20X(MT9M001, 0x5d, 0)}, 2384 {USB_DEVICE(0x0c45, 0x6282), SN9C20X(MT9M111, 0x5d, 0)}, 2385 {USB_DEVICE(0x0c45, 0x6288), SN9C20X(OV9655, 0x30, 0)}, 2386 {USB_DEVICE(0x0c45, 0x628c), SN9C20X(MT9M112, 0x5d, 0)}, 2387 {USB_DEVICE(0x0c45, 0x628e), SN9C20X(SOI968, 0x30, 0)}, 2388 {USB_DEVICE(0x0c45, 0x628f), SN9C20X(OV9650, 0x30, 0)}, 2389 {USB_DEVICE(0x0c45, 0x62a0), SN9C20X(OV7670, 0x21, 0)}, 2390 {USB_DEVICE(0x0c45, 0x62b0), SN9C20X(MT9VPRB, 0x00, 0)}, 2391 {USB_DEVICE(0x0c45, 0x62b3), SN9C20X(OV9655, 0x30, LED_REVERSE)}, 2392 {USB_DEVICE(0x0c45, 0x62bb), SN9C20X(OV7660, 0x21, LED_REVERSE)}, 2393 {USB_DEVICE(0x0c45, 0x62bc), SN9C20X(HV7131R, 0x11, 0)}, 2394 {USB_DEVICE(0x045e, 0x00f4), SN9C20X(OV9650, 0x30, 0)}, 2395 {USB_DEVICE(0x145f, 0x013d), SN9C20X(OV7660, 0x21, 0)}, 2396 {USB_DEVICE(0x0458, 0x7029), SN9C20X(HV7131R, 0x11, 0)}, 2397 {USB_DEVICE(0x0458, 0x704a), SN9C20X(MT9M112, 0x5d, 0)}, 2398 {USB_DEVICE(0x0458, 0x704c), SN9C20X(MT9M112, 0x5d, 0)}, 2399 {USB_DEVICE(0xa168, 0x0610), SN9C20X(HV7131R, 0x11, 0)}, 2400 {USB_DEVICE(0xa168, 0x0611), SN9C20X(HV7131R, 0x11, 0)}, 2401 {USB_DEVICE(0xa168, 0x0613), SN9C20X(HV7131R, 0x11, 0)}, 2402 {USB_DEVICE(0xa168, 0x0618), SN9C20X(HV7131R, 0x11, 0)}, 2403 {USB_DEVICE(0xa168, 0x0614), SN9C20X(MT9M111, 0x5d, 0)}, 2404 {USB_DEVICE(0xa168, 0x0615), SN9C20X(MT9M111, 0x5d, 0)}, 2405 {USB_DEVICE(0xa168, 0x0617), SN9C20X(MT9M111, 0x5d, 0)}, 2406 {} 2407 }; 2408 MODULE_DEVICE_TABLE(usb, device_table); 2409 2410 /* -- device connect -- */ 2411 static int sd_probe(struct usb_interface *intf, 2412 const struct usb_device_id *id) 2413 { 2414 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 2415 THIS_MODULE); 2416 } 2417 2418 static struct usb_driver sd_driver = { 2419 .name = KBUILD_MODNAME, 2420 .id_table = device_table, 2421 .probe = sd_probe, 2422 .disconnect = gspca_disconnect, 2423 #ifdef CONFIG_PM 2424 .suspend = gspca_suspend, 2425 .resume = gspca_resume, 2426 .reset_resume = gspca_resume, 2427 #endif 2428 }; 2429 2430 module_usb_driver(sd_driver); 2431