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