1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * USB IBM C-It Video Camera driver 4 * 5 * Supports Xirlink C-It Video Camera, IBM PC Camera, 6 * IBM NetCamera and Veo Stingray. 7 * 8 * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com> 9 * 10 * This driver is based on earlier work of: 11 * 12 * (C) Copyright 1999 Johannes Erdfelt 13 * (C) Copyright 1999 Randy Dunlap 14 */ 15 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 17 18 #define MODULE_NAME "xirlink-cit" 19 20 #include <linux/input.h> 21 #include "gspca.h" 22 23 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 24 MODULE_DESCRIPTION("Xirlink C-IT"); 25 MODULE_LICENSE("GPL"); 26 27 /* FIXME we should autodetect this */ 28 static int ibm_netcam_pro; 29 module_param(ibm_netcam_pro, int, 0); 30 MODULE_PARM_DESC(ibm_netcam_pro, 31 "Use IBM Netcamera Pro init sequences for Model 3 cams"); 32 33 /* FIXME this should be handled through the V4L2 input selection API */ 34 static int rca_input; 35 module_param(rca_input, int, 0644); 36 MODULE_PARM_DESC(rca_input, 37 "Use rca input instead of ccd sensor on Model 3 cams"); 38 39 /* specific webcam descriptor */ 40 struct sd { 41 struct gspca_dev gspca_dev; /* !! must be the first item */ 42 struct v4l2_ctrl *lighting; 43 u8 model; 44 #define CIT_MODEL0 0 /* bcd version 0.01 cams ie the xvp-500 */ 45 #define CIT_MODEL1 1 /* The model 1 - 4 nomenclature comes from the old */ 46 #define CIT_MODEL2 2 /* ibmcam driver */ 47 #define CIT_MODEL3 3 48 #define CIT_MODEL4 4 49 #define CIT_IBM_NETCAM_PRO 5 50 u8 input_index; 51 u8 button_state; 52 u8 stop_on_control_change; 53 u8 sof_read; 54 u8 sof_len; 55 }; 56 57 static void sd_stop0(struct gspca_dev *gspca_dev); 58 59 static const struct v4l2_pix_format cif_yuv_mode[] = { 60 {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 61 .bytesperline = 176, 62 .sizeimage = 176 * 144 * 3 / 2 + 4, 63 .colorspace = V4L2_COLORSPACE_SRGB}, 64 {352, 288, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 65 .bytesperline = 352, 66 .sizeimage = 352 * 288 * 3 / 2 + 4, 67 .colorspace = V4L2_COLORSPACE_SRGB}, 68 }; 69 70 static const struct v4l2_pix_format vga_yuv_mode[] = { 71 {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 72 .bytesperline = 160, 73 .sizeimage = 160 * 120 * 3 / 2 + 4, 74 .colorspace = V4L2_COLORSPACE_SRGB}, 75 {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 76 .bytesperline = 320, 77 .sizeimage = 320 * 240 * 3 / 2 + 4, 78 .colorspace = V4L2_COLORSPACE_SRGB}, 79 {640, 480, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 80 .bytesperline = 640, 81 .sizeimage = 640 * 480 * 3 / 2 + 4, 82 .colorspace = V4L2_COLORSPACE_SRGB}, 83 }; 84 85 static const struct v4l2_pix_format model0_mode[] = { 86 {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 87 .bytesperline = 160, 88 .sizeimage = 160 * 120 * 3 / 2 + 4, 89 .colorspace = V4L2_COLORSPACE_SRGB}, 90 {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 91 .bytesperline = 176, 92 .sizeimage = 176 * 144 * 3 / 2 + 4, 93 .colorspace = V4L2_COLORSPACE_SRGB}, 94 {320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 95 .bytesperline = 320, 96 .sizeimage = 320 * 240 * 3 / 2 + 4, 97 .colorspace = V4L2_COLORSPACE_SRGB}, 98 }; 99 100 static const struct v4l2_pix_format model2_mode[] = { 101 {160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 102 .bytesperline = 160, 103 .sizeimage = 160 * 120 * 3 / 2 + 4, 104 .colorspace = V4L2_COLORSPACE_SRGB}, 105 {176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE, 106 .bytesperline = 176, 107 .sizeimage = 176 * 144 * 3 / 2 + 4, 108 .colorspace = V4L2_COLORSPACE_SRGB}, 109 {320, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 110 .bytesperline = 320, 111 .sizeimage = 320 * 240 + 4, 112 .colorspace = V4L2_COLORSPACE_SRGB}, 113 {352, 288, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE, 114 .bytesperline = 352, 115 .sizeimage = 352 * 288 + 4, 116 .colorspace = V4L2_COLORSPACE_SRGB}, 117 }; 118 119 /* 120 * 01.01.08 - Added for RCA video in support -LO 121 * This struct is used to init the Model3 cam to use the RCA video in port 122 * instead of the CCD sensor. 123 */ 124 static const u16 rca_initdata[][3] = { 125 {0, 0x0000, 0x010c}, 126 {0, 0x0006, 0x012c}, 127 {0, 0x0078, 0x012d}, 128 {0, 0x0046, 0x012f}, 129 {0, 0xd141, 0x0124}, 130 {0, 0x0000, 0x0127}, 131 {0, 0xfea8, 0x0124}, 132 {1, 0x0000, 0x0116}, 133 {0, 0x0064, 0x0116}, 134 {1, 0x0000, 0x0115}, 135 {0, 0x0003, 0x0115}, 136 {0, 0x0008, 0x0123}, 137 {0, 0x0000, 0x0117}, 138 {0, 0x0000, 0x0112}, 139 {0, 0x0080, 0x0100}, 140 {0, 0x0000, 0x0100}, 141 {1, 0x0000, 0x0116}, 142 {0, 0x0060, 0x0116}, 143 {0, 0x0002, 0x0112}, 144 {0, 0x0000, 0x0123}, 145 {0, 0x0001, 0x0117}, 146 {0, 0x0040, 0x0108}, 147 {0, 0x0019, 0x012c}, 148 {0, 0x0040, 0x0116}, 149 {0, 0x000a, 0x0115}, 150 {0, 0x000b, 0x0115}, 151 {0, 0x0078, 0x012d}, 152 {0, 0x0046, 0x012f}, 153 {0, 0xd141, 0x0124}, 154 {0, 0x0000, 0x0127}, 155 {0, 0xfea8, 0x0124}, 156 {0, 0x0064, 0x0116}, 157 {0, 0x0000, 0x0115}, 158 {0, 0x0001, 0x0115}, 159 {0, 0xffff, 0x0124}, 160 {0, 0xfff9, 0x0124}, 161 {0, 0x0086, 0x0127}, 162 {0, 0xfff8, 0x0124}, 163 {0, 0xfffd, 0x0124}, 164 {0, 0x00aa, 0x0127}, 165 {0, 0xfff8, 0x0124}, 166 {0, 0xfffd, 0x0124}, 167 {0, 0x0000, 0x0127}, 168 {0, 0xfff8, 0x0124}, 169 {0, 0xfffd, 0x0124}, 170 {0, 0xfffa, 0x0124}, 171 {0, 0xffff, 0x0124}, 172 {0, 0xfff9, 0x0124}, 173 {0, 0x0086, 0x0127}, 174 {0, 0xfff8, 0x0124}, 175 {0, 0xfffd, 0x0124}, 176 {0, 0x00f2, 0x0127}, 177 {0, 0xfff8, 0x0124}, 178 {0, 0xfffd, 0x0124}, 179 {0, 0x000f, 0x0127}, 180 {0, 0xfff8, 0x0124}, 181 {0, 0xfffd, 0x0124}, 182 {0, 0xfffa, 0x0124}, 183 {0, 0xffff, 0x0124}, 184 {0, 0xfff9, 0x0124}, 185 {0, 0x0086, 0x0127}, 186 {0, 0xfff8, 0x0124}, 187 {0, 0xfffd, 0x0124}, 188 {0, 0x00f8, 0x0127}, 189 {0, 0xfff8, 0x0124}, 190 {0, 0xfffd, 0x0124}, 191 {0, 0x00fc, 0x0127}, 192 {0, 0xfff8, 0x0124}, 193 {0, 0xfffd, 0x0124}, 194 {0, 0xfffa, 0x0124}, 195 {0, 0xffff, 0x0124}, 196 {0, 0xfff9, 0x0124}, 197 {0, 0x0086, 0x0127}, 198 {0, 0xfff8, 0x0124}, 199 {0, 0xfffd, 0x0124}, 200 {0, 0x00f9, 0x0127}, 201 {0, 0xfff8, 0x0124}, 202 {0, 0xfffd, 0x0124}, 203 {0, 0x003c, 0x0127}, 204 {0, 0xfff8, 0x0124}, 205 {0, 0xfffd, 0x0124}, 206 {0, 0xfffa, 0x0124}, 207 {0, 0xffff, 0x0124}, 208 {0, 0xfff9, 0x0124}, 209 {0, 0x0086, 0x0127}, 210 {0, 0xfff8, 0x0124}, 211 {0, 0xfffd, 0x0124}, 212 {0, 0x0027, 0x0127}, 213 {0, 0xfff8, 0x0124}, 214 {0, 0xfffd, 0x0124}, 215 {0, 0x0019, 0x0127}, 216 {0, 0xfff8, 0x0124}, 217 {0, 0xfffd, 0x0124}, 218 {0, 0xfffa, 0x0124}, 219 {0, 0xfff9, 0x0124}, 220 {0, 0x0086, 0x0127}, 221 {0, 0xfff8, 0x0124}, 222 {0, 0xfffd, 0x0124}, 223 {0, 0x0037, 0x0127}, 224 {0, 0xfff8, 0x0124}, 225 {0, 0xfffd, 0x0124}, 226 {0, 0x0000, 0x0127}, 227 {0, 0xfff8, 0x0124}, 228 {0, 0xfffd, 0x0124}, 229 {0, 0x0021, 0x0127}, 230 {0, 0xfff8, 0x0124}, 231 {0, 0xfffd, 0x0124}, 232 {0, 0xfffa, 0x0124}, 233 {0, 0xfff9, 0x0124}, 234 {0, 0x0086, 0x0127}, 235 {0, 0xfff8, 0x0124}, 236 {0, 0xfffd, 0x0124}, 237 {0, 0x0038, 0x0127}, 238 {0, 0xfff8, 0x0124}, 239 {0, 0xfffd, 0x0124}, 240 {0, 0x0006, 0x0127}, 241 {0, 0xfff8, 0x0124}, 242 {0, 0xfffd, 0x0124}, 243 {0, 0x0045, 0x0127}, 244 {0, 0xfff8, 0x0124}, 245 {0, 0xfffd, 0x0124}, 246 {0, 0xfffa, 0x0124}, 247 {0, 0xfff9, 0x0124}, 248 {0, 0x0086, 0x0127}, 249 {0, 0xfff8, 0x0124}, 250 {0, 0xfffd, 0x0124}, 251 {0, 0x0037, 0x0127}, 252 {0, 0xfff8, 0x0124}, 253 {0, 0xfffd, 0x0124}, 254 {0, 0x0001, 0x0127}, 255 {0, 0xfff8, 0x0124}, 256 {0, 0xfffd, 0x0124}, 257 {0, 0x002a, 0x0127}, 258 {0, 0xfff8, 0x0124}, 259 {0, 0xfffd, 0x0124}, 260 {0, 0xfffa, 0x0124}, 261 {0, 0xfff9, 0x0124}, 262 {0, 0x0086, 0x0127}, 263 {0, 0xfff8, 0x0124}, 264 {0, 0xfffd, 0x0124}, 265 {0, 0x0038, 0x0127}, 266 {0, 0xfff8, 0x0124}, 267 {0, 0xfffd, 0x0124}, 268 {0, 0x0000, 0x0127}, 269 {0, 0xfff8, 0x0124}, 270 {0, 0xfffd, 0x0124}, 271 {0, 0x000e, 0x0127}, 272 {0, 0xfff8, 0x0124}, 273 {0, 0xfffd, 0x0124}, 274 {0, 0xfffa, 0x0124}, 275 {0, 0xfff9, 0x0124}, 276 {0, 0x0086, 0x0127}, 277 {0, 0xfff8, 0x0124}, 278 {0, 0xfffd, 0x0124}, 279 {0, 0x0037, 0x0127}, 280 {0, 0xfff8, 0x0124}, 281 {0, 0xfffd, 0x0124}, 282 {0, 0x0001, 0x0127}, 283 {0, 0xfff8, 0x0124}, 284 {0, 0xfffd, 0x0124}, 285 {0, 0x002b, 0x0127}, 286 {0, 0xfff8, 0x0124}, 287 {0, 0xfffd, 0x0124}, 288 {0, 0xfffa, 0x0124}, 289 {0, 0xfff9, 0x0124}, 290 {0, 0x0086, 0x0127}, 291 {0, 0xfff8, 0x0124}, 292 {0, 0xfffd, 0x0124}, 293 {0, 0x0038, 0x0127}, 294 {0, 0xfff8, 0x0124}, 295 {0, 0xfffd, 0x0124}, 296 {0, 0x0001, 0x0127}, 297 {0, 0xfff8, 0x0124}, 298 {0, 0xfffd, 0x0124}, 299 {0, 0x00f4, 0x0127}, 300 {0, 0xfff8, 0x0124}, 301 {0, 0xfffd, 0x0124}, 302 {0, 0xfffa, 0x0124}, 303 {0, 0xfff9, 0x0124}, 304 {0, 0x0086, 0x0127}, 305 {0, 0xfff8, 0x0124}, 306 {0, 0xfffd, 0x0124}, 307 {0, 0x0037, 0x0127}, 308 {0, 0xfff8, 0x0124}, 309 {0, 0xfffd, 0x0124}, 310 {0, 0x0001, 0x0127}, 311 {0, 0xfff8, 0x0124}, 312 {0, 0xfffd, 0x0124}, 313 {0, 0x002c, 0x0127}, 314 {0, 0xfff8, 0x0124}, 315 {0, 0xfffd, 0x0124}, 316 {0, 0xfffa, 0x0124}, 317 {0, 0xfff9, 0x0124}, 318 {0, 0x0086, 0x0127}, 319 {0, 0xfff8, 0x0124}, 320 {0, 0xfffd, 0x0124}, 321 {0, 0x0038, 0x0127}, 322 {0, 0xfff8, 0x0124}, 323 {0, 0xfffd, 0x0124}, 324 {0, 0x0001, 0x0127}, 325 {0, 0xfff8, 0x0124}, 326 {0, 0xfffd, 0x0124}, 327 {0, 0x0004, 0x0127}, 328 {0, 0xfff8, 0x0124}, 329 {0, 0xfffd, 0x0124}, 330 {0, 0xfffa, 0x0124}, 331 {0, 0xfff9, 0x0124}, 332 {0, 0x0086, 0x0127}, 333 {0, 0xfff8, 0x0124}, 334 {0, 0xfffd, 0x0124}, 335 {0, 0x0037, 0x0127}, 336 {0, 0xfff8, 0x0124}, 337 {0, 0xfffd, 0x0124}, 338 {0, 0x0001, 0x0127}, 339 {0, 0xfff8, 0x0124}, 340 {0, 0xfffd, 0x0124}, 341 {0, 0x002d, 0x0127}, 342 {0, 0xfff8, 0x0124}, 343 {0, 0xfffd, 0x0124}, 344 {0, 0xfffa, 0x0124}, 345 {0, 0xfff9, 0x0124}, 346 {0, 0x0086, 0x0127}, 347 {0, 0xfff8, 0x0124}, 348 {0, 0xfffd, 0x0124}, 349 {0, 0x0038, 0x0127}, 350 {0, 0xfff8, 0x0124}, 351 {0, 0xfffd, 0x0124}, 352 {0, 0x0000, 0x0127}, 353 {0, 0xfff8, 0x0124}, 354 {0, 0xfffd, 0x0124}, 355 {0, 0x0014, 0x0127}, 356 {0, 0xfff8, 0x0124}, 357 {0, 0xfffd, 0x0124}, 358 {0, 0xfffa, 0x0124}, 359 {0, 0xfff9, 0x0124}, 360 {0, 0x0086, 0x0127}, 361 {0, 0xfff8, 0x0124}, 362 {0, 0xfffd, 0x0124}, 363 {0, 0x0037, 0x0127}, 364 {0, 0xfff8, 0x0124}, 365 {0, 0xfffd, 0x0124}, 366 {0, 0x0001, 0x0127}, 367 {0, 0xfff8, 0x0124}, 368 {0, 0xfffd, 0x0124}, 369 {0, 0x002e, 0x0127}, 370 {0, 0xfff8, 0x0124}, 371 {0, 0xfffd, 0x0124}, 372 {0, 0xfffa, 0x0124}, 373 {0, 0xfff9, 0x0124}, 374 {0, 0x0086, 0x0127}, 375 {0, 0xfff8, 0x0124}, 376 {0, 0xfffd, 0x0124}, 377 {0, 0x0038, 0x0127}, 378 {0, 0xfff8, 0x0124}, 379 {0, 0xfffd, 0x0124}, 380 {0, 0x0003, 0x0127}, 381 {0, 0xfff8, 0x0124}, 382 {0, 0xfffd, 0x0124}, 383 {0, 0x0000, 0x0127}, 384 {0, 0xfff8, 0x0124}, 385 {0, 0xfffd, 0x0124}, 386 {0, 0xfffa, 0x0124}, 387 {0, 0xfff9, 0x0124}, 388 {0, 0x0086, 0x0127}, 389 {0, 0xfff8, 0x0124}, 390 {0, 0xfffd, 0x0124}, 391 {0, 0x0037, 0x0127}, 392 {0, 0xfff8, 0x0124}, 393 {0, 0xfffd, 0x0124}, 394 {0, 0x0001, 0x0127}, 395 {0, 0xfff8, 0x0124}, 396 {0, 0xfffd, 0x0124}, 397 {0, 0x002f, 0x0127}, 398 {0, 0xfff8, 0x0124}, 399 {0, 0xfffd, 0x0124}, 400 {0, 0xfffa, 0x0124}, 401 {0, 0xfff9, 0x0124}, 402 {0, 0x0086, 0x0127}, 403 {0, 0xfff8, 0x0124}, 404 {0, 0xfffd, 0x0124}, 405 {0, 0x0038, 0x0127}, 406 {0, 0xfff8, 0x0124}, 407 {0, 0xfffd, 0x0124}, 408 {0, 0x0003, 0x0127}, 409 {0, 0xfff8, 0x0124}, 410 {0, 0xfffd, 0x0124}, 411 {0, 0x0014, 0x0127}, 412 {0, 0xfff8, 0x0124}, 413 {0, 0xfffd, 0x0124}, 414 {0, 0xfffa, 0x0124}, 415 {0, 0xfff9, 0x0124}, 416 {0, 0x0086, 0x0127}, 417 {0, 0xfff8, 0x0124}, 418 {0, 0xfffd, 0x0124}, 419 {0, 0x0037, 0x0127}, 420 {0, 0xfff8, 0x0124}, 421 {0, 0xfffd, 0x0124}, 422 {0, 0x0001, 0x0127}, 423 {0, 0xfff8, 0x0124}, 424 {0, 0xfffd, 0x0124}, 425 {0, 0x0040, 0x0127}, 426 {0, 0xfff8, 0x0124}, 427 {0, 0xfffd, 0x0124}, 428 {0, 0xfffa, 0x0124}, 429 {0, 0xfff9, 0x0124}, 430 {0, 0x0086, 0x0127}, 431 {0, 0xfff8, 0x0124}, 432 {0, 0xfffd, 0x0124}, 433 {0, 0x0038, 0x0127}, 434 {0, 0xfff8, 0x0124}, 435 {0, 0xfffd, 0x0124}, 436 {0, 0x0000, 0x0127}, 437 {0, 0xfff8, 0x0124}, 438 {0, 0xfffd, 0x0124}, 439 {0, 0x0040, 0x0127}, 440 {0, 0xfff8, 0x0124}, 441 {0, 0xfffd, 0x0124}, 442 {0, 0xfffa, 0x0124}, 443 {0, 0xfff9, 0x0124}, 444 {0, 0x0086, 0x0127}, 445 {0, 0xfff8, 0x0124}, 446 {0, 0xfffd, 0x0124}, 447 {0, 0x0037, 0x0127}, 448 {0, 0xfff8, 0x0124}, 449 {0, 0xfffd, 0x0124}, 450 {0, 0x0001, 0x0127}, 451 {0, 0xfff8, 0x0124}, 452 {0, 0xfffd, 0x0124}, 453 {0, 0x0053, 0x0127}, 454 {0, 0xfff8, 0x0124}, 455 {0, 0xfffd, 0x0124}, 456 {0, 0xfffa, 0x0124}, 457 {0, 0xfff9, 0x0124}, 458 {0, 0x0086, 0x0127}, 459 {0, 0xfff8, 0x0124}, 460 {0, 0xfffd, 0x0124}, 461 {0, 0x0038, 0x0127}, 462 {0, 0xfff8, 0x0124}, 463 {0, 0xfffd, 0x0124}, 464 {0, 0x0000, 0x0127}, 465 {0, 0xfff8, 0x0124}, 466 {0, 0xfffd, 0x0124}, 467 {0, 0x0038, 0x0127}, 468 {0, 0xfff8, 0x0124}, 469 {0, 0xfffd, 0x0124}, 470 {0, 0xfffa, 0x0124}, 471 {0, 0x0000, 0x0101}, 472 {0, 0x00a0, 0x0103}, 473 {0, 0x0078, 0x0105}, 474 {0, 0x0000, 0x010a}, 475 {0, 0x0024, 0x010b}, 476 {0, 0x0028, 0x0119}, 477 {0, 0x0088, 0x011b}, 478 {0, 0x0002, 0x011d}, 479 {0, 0x0003, 0x011e}, 480 {0, 0x0000, 0x0129}, 481 {0, 0x00fc, 0x012b}, 482 {0, 0x0008, 0x0102}, 483 {0, 0x0000, 0x0104}, 484 {0, 0x0008, 0x011a}, 485 {0, 0x0028, 0x011c}, 486 {0, 0x0021, 0x012a}, 487 {0, 0x0000, 0x0118}, 488 {0, 0x0000, 0x0132}, 489 {0, 0x0000, 0x0109}, 490 {0, 0xfff9, 0x0124}, 491 {0, 0x0086, 0x0127}, 492 {0, 0xfff8, 0x0124}, 493 {0, 0xfffd, 0x0124}, 494 {0, 0x0037, 0x0127}, 495 {0, 0xfff8, 0x0124}, 496 {0, 0xfffd, 0x0124}, 497 {0, 0x0001, 0x0127}, 498 {0, 0xfff8, 0x0124}, 499 {0, 0xfffd, 0x0124}, 500 {0, 0x0031, 0x0127}, 501 {0, 0xfff8, 0x0124}, 502 {0, 0xfffd, 0x0124}, 503 {0, 0xfffa, 0x0124}, 504 {0, 0xfff9, 0x0124}, 505 {0, 0x0086, 0x0127}, 506 {0, 0xfff8, 0x0124}, 507 {0, 0xfffd, 0x0124}, 508 {0, 0x0038, 0x0127}, 509 {0, 0xfff8, 0x0124}, 510 {0, 0xfffd, 0x0124}, 511 {0, 0x0000, 0x0127}, 512 {0, 0xfff8, 0x0124}, 513 {0, 0xfffd, 0x0124}, 514 {0, 0x0000, 0x0127}, 515 {0, 0xfff8, 0x0124}, 516 {0, 0xfffd, 0x0124}, 517 {0, 0xfffa, 0x0124}, 518 {0, 0xfff9, 0x0124}, 519 {0, 0x0086, 0x0127}, 520 {0, 0xfff8, 0x0124}, 521 {0, 0xfffd, 0x0124}, 522 {0, 0x0037, 0x0127}, 523 {0, 0xfff8, 0x0124}, 524 {0, 0xfffd, 0x0124}, 525 {0, 0x0001, 0x0127}, 526 {0, 0xfff8, 0x0124}, 527 {0, 0xfffd, 0x0124}, 528 {0, 0x0040, 0x0127}, 529 {0, 0xfff8, 0x0124}, 530 {0, 0xfffd, 0x0124}, 531 {0, 0xfffa, 0x0124}, 532 {0, 0xfff9, 0x0124}, 533 {0, 0x0086, 0x0127}, 534 {0, 0xfff8, 0x0124}, 535 {0, 0xfffd, 0x0124}, 536 {0, 0x0038, 0x0127}, 537 {0, 0xfff8, 0x0124}, 538 {0, 0xfffd, 0x0124}, 539 {0, 0x0000, 0x0127}, 540 {0, 0xfff8, 0x0124}, 541 {0, 0xfffd, 0x0124}, 542 {0, 0x0040, 0x0127}, 543 {0, 0xfff8, 0x0124}, 544 {0, 0xfffd, 0x0124}, 545 {0, 0xfffa, 0x0124}, 546 {0, 0xfff9, 0x0124}, 547 {0, 0x0086, 0x0127}, 548 {0, 0xfff8, 0x0124}, 549 {0, 0xfffd, 0x0124}, 550 {0, 0x0037, 0x0127}, 551 {0, 0xfff8, 0x0124}, 552 {0, 0xfffd, 0x0124}, 553 {0, 0x0000, 0x0127}, 554 {0, 0xfff8, 0x0124}, 555 {0, 0xfffd, 0x0124}, 556 {0, 0x00dc, 0x0127}, 557 {0, 0xfff8, 0x0124}, 558 {0, 0xfffd, 0x0124}, 559 {0, 0xfffa, 0x0124}, 560 {0, 0xfff9, 0x0124}, 561 {0, 0x0086, 0x0127}, 562 {0, 0xfff8, 0x0124}, 563 {0, 0xfffd, 0x0124}, 564 {0, 0x0038, 0x0127}, 565 {0, 0xfff8, 0x0124}, 566 {0, 0xfffd, 0x0124}, 567 {0, 0x0000, 0x0127}, 568 {0, 0xfff8, 0x0124}, 569 {0, 0xfffd, 0x0124}, 570 {0, 0x0000, 0x0127}, 571 {0, 0xfff8, 0x0124}, 572 {0, 0xfffd, 0x0124}, 573 {0, 0xfffa, 0x0124}, 574 {0, 0xfff9, 0x0124}, 575 {0, 0x0086, 0x0127}, 576 {0, 0xfff8, 0x0124}, 577 {0, 0xfffd, 0x0124}, 578 {0, 0x0037, 0x0127}, 579 {0, 0xfff8, 0x0124}, 580 {0, 0xfffd, 0x0124}, 581 {0, 0x0001, 0x0127}, 582 {0, 0xfff8, 0x0124}, 583 {0, 0xfffd, 0x0124}, 584 {0, 0x0032, 0x0127}, 585 {0, 0xfff8, 0x0124}, 586 {0, 0xfffd, 0x0124}, 587 {0, 0xfffa, 0x0124}, 588 {0, 0xfff9, 0x0124}, 589 {0, 0x0086, 0x0127}, 590 {0, 0xfff8, 0x0124}, 591 {0, 0xfffd, 0x0124}, 592 {0, 0x0038, 0x0127}, 593 {0, 0xfff8, 0x0124}, 594 {0, 0xfffd, 0x0124}, 595 {0, 0x0001, 0x0127}, 596 {0, 0xfff8, 0x0124}, 597 {0, 0xfffd, 0x0124}, 598 {0, 0x0020, 0x0127}, 599 {0, 0xfff8, 0x0124}, 600 {0, 0xfffd, 0x0124}, 601 {0, 0xfffa, 0x0124}, 602 {0, 0xfff9, 0x0124}, 603 {0, 0x0086, 0x0127}, 604 {0, 0xfff8, 0x0124}, 605 {0, 0xfffd, 0x0124}, 606 {0, 0x0037, 0x0127}, 607 {0, 0xfff8, 0x0124}, 608 {0, 0xfffd, 0x0124}, 609 {0, 0x0001, 0x0127}, 610 {0, 0xfff8, 0x0124}, 611 {0, 0xfffd, 0x0124}, 612 {0, 0x0040, 0x0127}, 613 {0, 0xfff8, 0x0124}, 614 {0, 0xfffd, 0x0124}, 615 {0, 0xfffa, 0x0124}, 616 {0, 0xfff9, 0x0124}, 617 {0, 0x0086, 0x0127}, 618 {0, 0xfff8, 0x0124}, 619 {0, 0xfffd, 0x0124}, 620 {0, 0x0038, 0x0127}, 621 {0, 0xfff8, 0x0124}, 622 {0, 0xfffd, 0x0124}, 623 {0, 0x0000, 0x0127}, 624 {0, 0xfff8, 0x0124}, 625 {0, 0xfffd, 0x0124}, 626 {0, 0x0040, 0x0127}, 627 {0, 0xfff8, 0x0124}, 628 {0, 0xfffd, 0x0124}, 629 {0, 0xfffa, 0x0124}, 630 {0, 0xfff9, 0x0124}, 631 {0, 0x0086, 0x0127}, 632 {0, 0xfff8, 0x0124}, 633 {0, 0xfffd, 0x0124}, 634 {0, 0x0037, 0x0127}, 635 {0, 0xfff8, 0x0124}, 636 {0, 0xfffd, 0x0124}, 637 {0, 0x0000, 0x0127}, 638 {0, 0xfff8, 0x0124}, 639 {0, 0xfffd, 0x0124}, 640 {0, 0x0030, 0x0127}, 641 {0, 0xfff8, 0x0124}, 642 {0, 0xfffd, 0x0124}, 643 {0, 0xfffa, 0x0124}, 644 {0, 0xfff9, 0x0124}, 645 {0, 0x0086, 0x0127}, 646 {0, 0xfff8, 0x0124}, 647 {0, 0xfffd, 0x0124}, 648 {0, 0x0038, 0x0127}, 649 {0, 0xfff8, 0x0124}, 650 {0, 0xfffd, 0x0124}, 651 {0, 0x0008, 0x0127}, 652 {0, 0xfff8, 0x0124}, 653 {0, 0xfffd, 0x0124}, 654 {0, 0x0000, 0x0127}, 655 {0, 0xfff8, 0x0124}, 656 {0, 0xfffd, 0x0124}, 657 {0, 0xfffa, 0x0124}, 658 {0, 0x0003, 0x0111}, 659 }; 660 661 /* TESTME the old ibmcam driver repeats certain commands to Model1 cameras, we 662 do the same for now (testing needed to see if this is really necessary) */ 663 static const int cit_model1_ntries = 5; 664 static const int cit_model1_ntries2 = 2; 665 666 static int cit_write_reg(struct gspca_dev *gspca_dev, u16 value, u16 index) 667 { 668 struct usb_device *udev = gspca_dev->dev; 669 int err; 670 671 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00, 672 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT, 673 value, index, NULL, 0, 1000); 674 if (err < 0) 675 pr_err("Failed to write a register (index 0x%04X, value 0x%02X, error %d)\n", 676 index, value, err); 677 678 return 0; 679 } 680 681 static int cit_read_reg(struct gspca_dev *gspca_dev, u16 index, int verbose) 682 { 683 struct usb_device *udev = gspca_dev->dev; 684 __u8 *buf = gspca_dev->usb_buf; 685 int res; 686 687 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01, 688 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT, 689 0x00, index, buf, 8, 1000); 690 if (res < 0) { 691 pr_err("Failed to read a register (index 0x%04X, error %d)\n", 692 index, res); 693 return res; 694 } 695 696 if (verbose) 697 gspca_dbg(gspca_dev, D_PROBE, "Register %04x value: %02x\n", 698 index, buf[0]); 699 700 return 0; 701 } 702 703 /* 704 * cit_send_FF_04_02() 705 * 706 * This procedure sends magic 3-command prefix to the camera. 707 * The purpose of this prefix is not known. 708 * 709 * History: 710 * 1/2/00 Created. 711 */ 712 static void cit_send_FF_04_02(struct gspca_dev *gspca_dev) 713 { 714 cit_write_reg(gspca_dev, 0x00FF, 0x0127); 715 cit_write_reg(gspca_dev, 0x0004, 0x0124); 716 cit_write_reg(gspca_dev, 0x0002, 0x0124); 717 } 718 719 static void cit_send_00_04_06(struct gspca_dev *gspca_dev) 720 { 721 cit_write_reg(gspca_dev, 0x0000, 0x0127); 722 cit_write_reg(gspca_dev, 0x0004, 0x0124); 723 cit_write_reg(gspca_dev, 0x0006, 0x0124); 724 } 725 726 static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x) 727 { 728 cit_write_reg(gspca_dev, x, 0x0127); 729 cit_write_reg(gspca_dev, 0x0000, 0x0124); 730 } 731 732 static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x) 733 { 734 cit_send_x_00(gspca_dev, x); 735 cit_write_reg(gspca_dev, 0x0005, 0x0124); 736 } 737 738 static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x) 739 { 740 cit_write_reg(gspca_dev, x, 0x0127); 741 cit_write_reg(gspca_dev, 0x0000, 0x0124); 742 cit_write_reg(gspca_dev, 0x0005, 0x0124); 743 cit_write_reg(gspca_dev, 0x0002, 0x0124); 744 } 745 746 static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x) 747 { 748 cit_write_reg(gspca_dev, x, 0x0127); 749 cit_write_reg(gspca_dev, 0x0001, 0x0124); 750 cit_write_reg(gspca_dev, 0x0000, 0x0124); 751 cit_write_reg(gspca_dev, 0x0005, 0x0124); 752 } 753 754 static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x) 755 { 756 cit_write_reg(gspca_dev, x, 0x0127); 757 cit_write_reg(gspca_dev, 0x0000, 0x0124); 758 cit_write_reg(gspca_dev, 0x0005, 0x0124); 759 cit_write_reg(gspca_dev, 0x0002, 0x0124); 760 cit_write_reg(gspca_dev, 0x0001, 0x0124); 761 } 762 763 static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x) 764 { 765 cit_write_reg(gspca_dev, x, 0x0127); 766 cit_write_reg(gspca_dev, 0x0000, 0x0124); 767 cit_write_reg(gspca_dev, 0x0005, 0x0124); 768 cit_write_reg(gspca_dev, 0x0002, 0x0124); 769 cit_write_reg(gspca_dev, 0x0008, 0x0124); 770 cit_write_reg(gspca_dev, 0x0001, 0x0124); 771 } 772 773 static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val) 774 { 775 cit_send_x_01_00_05(gspca_dev, 0x0088); 776 cit_send_x_00_05(gspca_dev, fkey); 777 cit_send_x_00_05_02_08_01(gspca_dev, val); 778 cit_send_x_00_05(gspca_dev, 0x0088); 779 cit_send_x_00_05_02_01(gspca_dev, fkey); 780 cit_send_x_00_05(gspca_dev, 0x0089); 781 cit_send_x_00(gspca_dev, fkey); 782 cit_send_00_04_06(gspca_dev); 783 cit_read_reg(gspca_dev, 0x0126, 0); 784 cit_send_FF_04_02(gspca_dev); 785 } 786 787 static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val) 788 { 789 cit_send_x_01_00_05(gspca_dev, 0x0088); 790 cit_send_x_00_05(gspca_dev, fkey); 791 cit_send_x_00_05_02(gspca_dev, val); 792 } 793 794 static void cit_model2_Packet2(struct gspca_dev *gspca_dev) 795 { 796 cit_write_reg(gspca_dev, 0x00ff, 0x012d); 797 cit_write_reg(gspca_dev, 0xfea3, 0x0124); 798 } 799 800 static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2) 801 { 802 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 803 cit_write_reg(gspca_dev, 0x00ff, 0x012e); 804 cit_write_reg(gspca_dev, v1, 0x012f); 805 cit_write_reg(gspca_dev, 0x00ff, 0x0130); 806 cit_write_reg(gspca_dev, 0xc719, 0x0124); 807 cit_write_reg(gspca_dev, v2, 0x0127); 808 809 cit_model2_Packet2(gspca_dev); 810 } 811 812 /* 813 * cit_model3_Packet1() 814 * 815 * 00_0078_012d 816 * 00_0097_012f 817 * 00_d141_0124 818 * 00_0096_0127 819 * 00_fea8_0124 820 */ 821 static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2) 822 { 823 cit_write_reg(gspca_dev, 0x0078, 0x012d); 824 cit_write_reg(gspca_dev, v1, 0x012f); 825 cit_write_reg(gspca_dev, 0xd141, 0x0124); 826 cit_write_reg(gspca_dev, v2, 0x0127); 827 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 828 } 829 830 static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2) 831 { 832 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 833 cit_write_reg(gspca_dev, v1, 0x012f); 834 cit_write_reg(gspca_dev, 0xd141, 0x0124); 835 cit_write_reg(gspca_dev, v2, 0x0127); 836 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 837 } 838 839 static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val) 840 { 841 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 842 cit_write_reg(gspca_dev, 0x0026, 0x012f); 843 cit_write_reg(gspca_dev, 0xd141, 0x0124); 844 cit_write_reg(gspca_dev, val, 0x0127); 845 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 846 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 847 cit_write_reg(gspca_dev, 0x0038, 0x012d); 848 cit_write_reg(gspca_dev, 0x0004, 0x012f); 849 cit_write_reg(gspca_dev, 0xd145, 0x0124); 850 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 851 } 852 853 /* this function is called at probe time */ 854 static int sd_config(struct gspca_dev *gspca_dev, 855 const struct usb_device_id *id) 856 { 857 struct sd *sd = (struct sd *) gspca_dev; 858 struct cam *cam; 859 860 sd->model = id->driver_info; 861 if (sd->model == CIT_MODEL3 && ibm_netcam_pro) 862 sd->model = CIT_IBM_NETCAM_PRO; 863 864 cam = &gspca_dev->cam; 865 switch (sd->model) { 866 case CIT_MODEL0: 867 cam->cam_mode = model0_mode; 868 cam->nmodes = ARRAY_SIZE(model0_mode); 869 sd->sof_len = 4; 870 break; 871 case CIT_MODEL1: 872 cam->cam_mode = cif_yuv_mode; 873 cam->nmodes = ARRAY_SIZE(cif_yuv_mode); 874 sd->sof_len = 4; 875 break; 876 case CIT_MODEL2: 877 cam->cam_mode = model2_mode + 1; /* no 160x120 */ 878 cam->nmodes = 3; 879 break; 880 case CIT_MODEL3: 881 cam->cam_mode = vga_yuv_mode; 882 cam->nmodes = ARRAY_SIZE(vga_yuv_mode); 883 sd->stop_on_control_change = 1; 884 sd->sof_len = 4; 885 break; 886 case CIT_MODEL4: 887 cam->cam_mode = model2_mode; 888 cam->nmodes = ARRAY_SIZE(model2_mode); 889 break; 890 case CIT_IBM_NETCAM_PRO: 891 cam->cam_mode = vga_yuv_mode; 892 cam->nmodes = 2; /* no 640 x 480 */ 893 cam->input_flags = V4L2_IN_ST_VFLIP; 894 sd->stop_on_control_change = 1; 895 sd->sof_len = 4; 896 break; 897 } 898 899 return 0; 900 } 901 902 static int cit_init_model0(struct gspca_dev *gspca_dev) 903 { 904 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */ 905 cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */ 906 cit_write_reg(gspca_dev, 0x0000, 0x0400); 907 cit_write_reg(gspca_dev, 0x0001, 0x0400); 908 cit_write_reg(gspca_dev, 0x0000, 0x0420); 909 cit_write_reg(gspca_dev, 0x0001, 0x0420); 910 cit_write_reg(gspca_dev, 0x000d, 0x0409); 911 cit_write_reg(gspca_dev, 0x0002, 0x040a); 912 cit_write_reg(gspca_dev, 0x0018, 0x0405); 913 cit_write_reg(gspca_dev, 0x0008, 0x0435); 914 cit_write_reg(gspca_dev, 0x0026, 0x040b); 915 cit_write_reg(gspca_dev, 0x0007, 0x0437); 916 cit_write_reg(gspca_dev, 0x0015, 0x042f); 917 cit_write_reg(gspca_dev, 0x002b, 0x0439); 918 cit_write_reg(gspca_dev, 0x0026, 0x043a); 919 cit_write_reg(gspca_dev, 0x0008, 0x0438); 920 cit_write_reg(gspca_dev, 0x001e, 0x042b); 921 cit_write_reg(gspca_dev, 0x0041, 0x042c); 922 923 return 0; 924 } 925 926 static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev) 927 { 928 cit_read_reg(gspca_dev, 0x128, 1); 929 cit_write_reg(gspca_dev, 0x0003, 0x0133); 930 cit_write_reg(gspca_dev, 0x0000, 0x0117); 931 cit_write_reg(gspca_dev, 0x0008, 0x0123); 932 cit_write_reg(gspca_dev, 0x0000, 0x0100); 933 cit_read_reg(gspca_dev, 0x0116, 0); 934 cit_write_reg(gspca_dev, 0x0060, 0x0116); 935 cit_write_reg(gspca_dev, 0x0002, 0x0112); 936 cit_write_reg(gspca_dev, 0x0000, 0x0133); 937 cit_write_reg(gspca_dev, 0x0000, 0x0123); 938 cit_write_reg(gspca_dev, 0x0001, 0x0117); 939 cit_write_reg(gspca_dev, 0x0040, 0x0108); 940 cit_write_reg(gspca_dev, 0x0019, 0x012c); 941 cit_write_reg(gspca_dev, 0x0060, 0x0116); 942 cit_write_reg(gspca_dev, 0x0002, 0x0115); 943 cit_write_reg(gspca_dev, 0x000b, 0x0115); 944 945 cit_write_reg(gspca_dev, 0x0078, 0x012d); 946 cit_write_reg(gspca_dev, 0x0001, 0x012f); 947 cit_write_reg(gspca_dev, 0xd141, 0x0124); 948 cit_write_reg(gspca_dev, 0x0079, 0x012d); 949 cit_write_reg(gspca_dev, 0x00ff, 0x0130); 950 cit_write_reg(gspca_dev, 0xcd41, 0x0124); 951 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 952 cit_read_reg(gspca_dev, 0x0126, 1); 953 954 cit_model3_Packet1(gspca_dev, 0x0000, 0x0000); 955 cit_model3_Packet1(gspca_dev, 0x0000, 0x0001); 956 cit_model3_Packet1(gspca_dev, 0x000b, 0x0000); 957 cit_model3_Packet1(gspca_dev, 0x000c, 0x0008); 958 cit_model3_Packet1(gspca_dev, 0x000d, 0x003a); 959 cit_model3_Packet1(gspca_dev, 0x000e, 0x0060); 960 cit_model3_Packet1(gspca_dev, 0x000f, 0x0060); 961 cit_model3_Packet1(gspca_dev, 0x0010, 0x0008); 962 cit_model3_Packet1(gspca_dev, 0x0011, 0x0004); 963 cit_model3_Packet1(gspca_dev, 0x0012, 0x0028); 964 cit_model3_Packet1(gspca_dev, 0x0013, 0x0002); 965 cit_model3_Packet1(gspca_dev, 0x0014, 0x0000); 966 cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb); 967 cit_model3_Packet1(gspca_dev, 0x0016, 0x0002); 968 cit_model3_Packet1(gspca_dev, 0x0017, 0x0037); 969 cit_model3_Packet1(gspca_dev, 0x0018, 0x0036); 970 cit_model3_Packet1(gspca_dev, 0x001e, 0x0000); 971 cit_model3_Packet1(gspca_dev, 0x001f, 0x0008); 972 cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1); 973 cit_model3_Packet1(gspca_dev, 0x0021, 0x0034); 974 cit_model3_Packet1(gspca_dev, 0x0022, 0x0034); 975 cit_model3_Packet1(gspca_dev, 0x0025, 0x0002); 976 cit_model3_Packet1(gspca_dev, 0x0028, 0x0022); 977 cit_model3_Packet1(gspca_dev, 0x0029, 0x000a); 978 cit_model3_Packet1(gspca_dev, 0x002b, 0x0000); 979 cit_model3_Packet1(gspca_dev, 0x002c, 0x0000); 980 cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff); 981 cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff); 982 cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff); 983 cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff); 984 cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff); 985 cit_model3_Packet1(gspca_dev, 0x0032, 0x0007); 986 cit_model3_Packet1(gspca_dev, 0x0033, 0x0005); 987 cit_model3_Packet1(gspca_dev, 0x0037, 0x0040); 988 cit_model3_Packet1(gspca_dev, 0x0039, 0x0000); 989 cit_model3_Packet1(gspca_dev, 0x003a, 0x0000); 990 cit_model3_Packet1(gspca_dev, 0x003b, 0x0001); 991 cit_model3_Packet1(gspca_dev, 0x003c, 0x0000); 992 cit_model3_Packet1(gspca_dev, 0x0040, 0x000c); 993 cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb); 994 cit_model3_Packet1(gspca_dev, 0x0042, 0x0002); 995 cit_model3_Packet1(gspca_dev, 0x0043, 0x0000); 996 cit_model3_Packet1(gspca_dev, 0x0045, 0x0000); 997 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000); 998 cit_model3_Packet1(gspca_dev, 0x0047, 0x0000); 999 cit_model3_Packet1(gspca_dev, 0x0048, 0x0000); 1000 cit_model3_Packet1(gspca_dev, 0x0049, 0x0000); 1001 cit_model3_Packet1(gspca_dev, 0x004a, 0x00ff); 1002 cit_model3_Packet1(gspca_dev, 0x004b, 0x00ff); 1003 cit_model3_Packet1(gspca_dev, 0x004c, 0x00ff); 1004 cit_model3_Packet1(gspca_dev, 0x004f, 0x0000); 1005 cit_model3_Packet1(gspca_dev, 0x0050, 0x0000); 1006 cit_model3_Packet1(gspca_dev, 0x0051, 0x0002); 1007 cit_model3_Packet1(gspca_dev, 0x0055, 0x0000); 1008 cit_model3_Packet1(gspca_dev, 0x0056, 0x0000); 1009 cit_model3_Packet1(gspca_dev, 0x0057, 0x0000); 1010 cit_model3_Packet1(gspca_dev, 0x0058, 0x0002); 1011 cit_model3_Packet1(gspca_dev, 0x0059, 0x0000); 1012 cit_model3_Packet1(gspca_dev, 0x005c, 0x0016); 1013 cit_model3_Packet1(gspca_dev, 0x005d, 0x0022); 1014 cit_model3_Packet1(gspca_dev, 0x005e, 0x003c); 1015 cit_model3_Packet1(gspca_dev, 0x005f, 0x0050); 1016 cit_model3_Packet1(gspca_dev, 0x0060, 0x0044); 1017 cit_model3_Packet1(gspca_dev, 0x0061, 0x0005); 1018 cit_model3_Packet1(gspca_dev, 0x006a, 0x007e); 1019 cit_model3_Packet1(gspca_dev, 0x006f, 0x0000); 1020 cit_model3_Packet1(gspca_dev, 0x0072, 0x001b); 1021 cit_model3_Packet1(gspca_dev, 0x0073, 0x0005); 1022 cit_model3_Packet1(gspca_dev, 0x0074, 0x000a); 1023 cit_model3_Packet1(gspca_dev, 0x0075, 0x001b); 1024 cit_model3_Packet1(gspca_dev, 0x0076, 0x002a); 1025 cit_model3_Packet1(gspca_dev, 0x0077, 0x003c); 1026 cit_model3_Packet1(gspca_dev, 0x0078, 0x0050); 1027 cit_model3_Packet1(gspca_dev, 0x007b, 0x0000); 1028 cit_model3_Packet1(gspca_dev, 0x007c, 0x0011); 1029 cit_model3_Packet1(gspca_dev, 0x007d, 0x0024); 1030 cit_model3_Packet1(gspca_dev, 0x007e, 0x0043); 1031 cit_model3_Packet1(gspca_dev, 0x007f, 0x005a); 1032 cit_model3_Packet1(gspca_dev, 0x0084, 0x0020); 1033 cit_model3_Packet1(gspca_dev, 0x0085, 0x0033); 1034 cit_model3_Packet1(gspca_dev, 0x0086, 0x000a); 1035 cit_model3_Packet1(gspca_dev, 0x0087, 0x0030); 1036 cit_model3_Packet1(gspca_dev, 0x0088, 0x0070); 1037 cit_model3_Packet1(gspca_dev, 0x008b, 0x0008); 1038 cit_model3_Packet1(gspca_dev, 0x008f, 0x0000); 1039 cit_model3_Packet1(gspca_dev, 0x0090, 0x0006); 1040 cit_model3_Packet1(gspca_dev, 0x0091, 0x0028); 1041 cit_model3_Packet1(gspca_dev, 0x0092, 0x005a); 1042 cit_model3_Packet1(gspca_dev, 0x0093, 0x0082); 1043 cit_model3_Packet1(gspca_dev, 0x0096, 0x0014); 1044 cit_model3_Packet1(gspca_dev, 0x0097, 0x0020); 1045 cit_model3_Packet1(gspca_dev, 0x0098, 0x0000); 1046 cit_model3_Packet1(gspca_dev, 0x00b0, 0x0046); 1047 cit_model3_Packet1(gspca_dev, 0x00b1, 0x0000); 1048 cit_model3_Packet1(gspca_dev, 0x00b2, 0x0000); 1049 cit_model3_Packet1(gspca_dev, 0x00b3, 0x0004); 1050 cit_model3_Packet1(gspca_dev, 0x00b4, 0x0007); 1051 cit_model3_Packet1(gspca_dev, 0x00b6, 0x0002); 1052 cit_model3_Packet1(gspca_dev, 0x00b7, 0x0004); 1053 cit_model3_Packet1(gspca_dev, 0x00bb, 0x0000); 1054 cit_model3_Packet1(gspca_dev, 0x00bc, 0x0001); 1055 cit_model3_Packet1(gspca_dev, 0x00bd, 0x0000); 1056 cit_model3_Packet1(gspca_dev, 0x00bf, 0x0000); 1057 cit_model3_Packet1(gspca_dev, 0x00c0, 0x00c8); 1058 cit_model3_Packet1(gspca_dev, 0x00c1, 0x0014); 1059 cit_model3_Packet1(gspca_dev, 0x00c2, 0x0001); 1060 cit_model3_Packet1(gspca_dev, 0x00c3, 0x0000); 1061 cit_model3_Packet1(gspca_dev, 0x00c4, 0x0004); 1062 cit_model3_Packet1(gspca_dev, 0x00cb, 0x00bf); 1063 cit_model3_Packet1(gspca_dev, 0x00cc, 0x00bf); 1064 cit_model3_Packet1(gspca_dev, 0x00cd, 0x00bf); 1065 cit_model3_Packet1(gspca_dev, 0x00ce, 0x0000); 1066 cit_model3_Packet1(gspca_dev, 0x00cf, 0x0020); 1067 cit_model3_Packet1(gspca_dev, 0x00d0, 0x0040); 1068 cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf); 1069 cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf); 1070 cit_model3_Packet1(gspca_dev, 0x00d2, 0x00bf); 1071 cit_model3_Packet1(gspca_dev, 0x00d3, 0x00bf); 1072 cit_model3_Packet1(gspca_dev, 0x00ea, 0x0008); 1073 cit_model3_Packet1(gspca_dev, 0x00eb, 0x0000); 1074 cit_model3_Packet1(gspca_dev, 0x00ec, 0x00e8); 1075 cit_model3_Packet1(gspca_dev, 0x00ed, 0x0001); 1076 cit_model3_Packet1(gspca_dev, 0x00ef, 0x0022); 1077 cit_model3_Packet1(gspca_dev, 0x00f0, 0x0000); 1078 cit_model3_Packet1(gspca_dev, 0x00f2, 0x0028); 1079 cit_model3_Packet1(gspca_dev, 0x00f4, 0x0002); 1080 cit_model3_Packet1(gspca_dev, 0x00f5, 0x0000); 1081 cit_model3_Packet1(gspca_dev, 0x00fa, 0x0000); 1082 cit_model3_Packet1(gspca_dev, 0x00fb, 0x0001); 1083 cit_model3_Packet1(gspca_dev, 0x00fc, 0x0000); 1084 cit_model3_Packet1(gspca_dev, 0x00fd, 0x0000); 1085 cit_model3_Packet1(gspca_dev, 0x00fe, 0x0000); 1086 cit_model3_Packet1(gspca_dev, 0x00ff, 0x0000); 1087 1088 cit_model3_Packet1(gspca_dev, 0x00be, 0x0003); 1089 cit_model3_Packet1(gspca_dev, 0x00c8, 0x0000); 1090 cit_model3_Packet1(gspca_dev, 0x00c9, 0x0020); 1091 cit_model3_Packet1(gspca_dev, 0x00ca, 0x0040); 1092 cit_model3_Packet1(gspca_dev, 0x0053, 0x0001); 1093 cit_model3_Packet1(gspca_dev, 0x0082, 0x000e); 1094 cit_model3_Packet1(gspca_dev, 0x0083, 0x0020); 1095 cit_model3_Packet1(gspca_dev, 0x0034, 0x003c); 1096 cit_model3_Packet1(gspca_dev, 0x006e, 0x0055); 1097 cit_model3_Packet1(gspca_dev, 0x0062, 0x0005); 1098 cit_model3_Packet1(gspca_dev, 0x0063, 0x0008); 1099 cit_model3_Packet1(gspca_dev, 0x0066, 0x000a); 1100 cit_model3_Packet1(gspca_dev, 0x0067, 0x0006); 1101 cit_model3_Packet1(gspca_dev, 0x006b, 0x0010); 1102 cit_model3_Packet1(gspca_dev, 0x005a, 0x0001); 1103 cit_model3_Packet1(gspca_dev, 0x005b, 0x000a); 1104 cit_model3_Packet1(gspca_dev, 0x0023, 0x0006); 1105 cit_model3_Packet1(gspca_dev, 0x0026, 0x0004); 1106 cit_model3_Packet1(gspca_dev, 0x0036, 0x0069); 1107 cit_model3_Packet1(gspca_dev, 0x0038, 0x0064); 1108 cit_model3_Packet1(gspca_dev, 0x003d, 0x0003); 1109 cit_model3_Packet1(gspca_dev, 0x003e, 0x0001); 1110 cit_model3_Packet1(gspca_dev, 0x00b8, 0x0014); 1111 cit_model3_Packet1(gspca_dev, 0x00b9, 0x0014); 1112 cit_model3_Packet1(gspca_dev, 0x00e6, 0x0004); 1113 cit_model3_Packet1(gspca_dev, 0x00e8, 0x0001); 1114 1115 return 0; 1116 } 1117 1118 /* this function is called at probe and resume time */ 1119 static int sd_init(struct gspca_dev *gspca_dev) 1120 { 1121 struct sd *sd = (struct sd *) gspca_dev; 1122 1123 switch (sd->model) { 1124 case CIT_MODEL0: 1125 cit_init_model0(gspca_dev); 1126 sd_stop0(gspca_dev); 1127 break; 1128 case CIT_MODEL1: 1129 case CIT_MODEL2: 1130 case CIT_MODEL3: 1131 case CIT_MODEL4: 1132 break; /* All is done in sd_start */ 1133 case CIT_IBM_NETCAM_PRO: 1134 cit_init_ibm_netcam_pro(gspca_dev); 1135 sd_stop0(gspca_dev); 1136 break; 1137 } 1138 return 0; 1139 } 1140 1141 static int cit_set_brightness(struct gspca_dev *gspca_dev, s32 val) 1142 { 1143 struct sd *sd = (struct sd *) gspca_dev; 1144 int i; 1145 1146 switch (sd->model) { 1147 case CIT_MODEL0: 1148 case CIT_IBM_NETCAM_PRO: 1149 /* No (known) brightness control for these */ 1150 break; 1151 case CIT_MODEL1: 1152 /* Model 1: Brightness range 0 - 63 */ 1153 cit_Packet_Format1(gspca_dev, 0x0031, val); 1154 cit_Packet_Format1(gspca_dev, 0x0032, val); 1155 cit_Packet_Format1(gspca_dev, 0x0033, val); 1156 break; 1157 case CIT_MODEL2: 1158 /* Model 2: Brightness range 0x60 - 0xee */ 1159 /* Scale 0 - 63 to 0x60 - 0xee */ 1160 i = 0x60 + val * 2254 / 1000; 1161 cit_model2_Packet1(gspca_dev, 0x001a, i); 1162 break; 1163 case CIT_MODEL3: 1164 /* Model 3: Brightness range 'i' in [0x0C..0x3F] */ 1165 i = val; 1166 if (i < 0x0c) 1167 i = 0x0c; 1168 cit_model3_Packet1(gspca_dev, 0x0036, i); 1169 break; 1170 case CIT_MODEL4: 1171 /* Model 4: Brightness range 'i' in [0x04..0xb4] */ 1172 /* Scale 0 - 63 to 0x04 - 0xb4 */ 1173 i = 0x04 + val * 2794 / 1000; 1174 cit_model4_BrightnessPacket(gspca_dev, i); 1175 break; 1176 } 1177 1178 return 0; 1179 } 1180 1181 static int cit_set_contrast(struct gspca_dev *gspca_dev, s32 val) 1182 { 1183 struct sd *sd = (struct sd *) gspca_dev; 1184 1185 switch (sd->model) { 1186 case CIT_MODEL0: { 1187 int i; 1188 /* gain 0-15, 0-20 -> 0-15 */ 1189 i = val * 1000 / 1333; 1190 cit_write_reg(gspca_dev, i, 0x0422); 1191 /* gain 0-31, may not be lower then 0x0422, 0-20 -> 0-31 */ 1192 i = val * 2000 / 1333; 1193 cit_write_reg(gspca_dev, i, 0x0423); 1194 /* gain 0-127, may not be lower then 0x0423, 0-20 -> 0-63 */ 1195 i = val * 4000 / 1333; 1196 cit_write_reg(gspca_dev, i, 0x0424); 1197 /* gain 0-127, may not be lower then 0x0424, , 0-20 -> 0-127 */ 1198 i = val * 8000 / 1333; 1199 cit_write_reg(gspca_dev, i, 0x0425); 1200 break; 1201 } 1202 case CIT_MODEL2: 1203 case CIT_MODEL4: 1204 /* These models do not have this control. */ 1205 break; 1206 case CIT_MODEL1: 1207 { 1208 /* Scale 0 - 20 to 15 - 0 */ 1209 int i, new_contrast = (20 - val) * 1000 / 1333; 1210 for (i = 0; i < cit_model1_ntries; i++) { 1211 cit_Packet_Format1(gspca_dev, 0x0014, new_contrast); 1212 cit_send_FF_04_02(gspca_dev); 1213 } 1214 break; 1215 } 1216 case CIT_MODEL3: 1217 { /* Preset hardware values */ 1218 static const struct { 1219 unsigned short cv1; 1220 unsigned short cv2; 1221 unsigned short cv3; 1222 } cv[7] = { 1223 { 0x05, 0x05, 0x0f }, /* Minimum */ 1224 { 0x04, 0x04, 0x16 }, 1225 { 0x02, 0x03, 0x16 }, 1226 { 0x02, 0x08, 0x16 }, 1227 { 0x01, 0x0c, 0x16 }, 1228 { 0x01, 0x0e, 0x16 }, 1229 { 0x01, 0x10, 0x16 } /* Maximum */ 1230 }; 1231 int i = val / 3; 1232 cit_model3_Packet1(gspca_dev, 0x0067, cv[i].cv1); 1233 cit_model3_Packet1(gspca_dev, 0x005b, cv[i].cv2); 1234 cit_model3_Packet1(gspca_dev, 0x005c, cv[i].cv3); 1235 break; 1236 } 1237 case CIT_IBM_NETCAM_PRO: 1238 cit_model3_Packet1(gspca_dev, 0x005b, val + 1); 1239 break; 1240 } 1241 return 0; 1242 } 1243 1244 static int cit_set_hue(struct gspca_dev *gspca_dev, s32 val) 1245 { 1246 struct sd *sd = (struct sd *) gspca_dev; 1247 1248 switch (sd->model) { 1249 case CIT_MODEL0: 1250 case CIT_MODEL1: 1251 case CIT_IBM_NETCAM_PRO: 1252 /* No hue control for these models */ 1253 break; 1254 case CIT_MODEL2: 1255 cit_model2_Packet1(gspca_dev, 0x0024, val); 1256 /* cit_model2_Packet1(gspca_dev, 0x0020, sat); */ 1257 break; 1258 case CIT_MODEL3: { 1259 /* Model 3: Brightness range 'i' in [0x05..0x37] */ 1260 /* TESTME according to the ibmcam driver this does not work */ 1261 if (0) { 1262 /* Scale 0 - 127 to 0x05 - 0x37 */ 1263 int i = 0x05 + val * 1000 / 2540; 1264 cit_model3_Packet1(gspca_dev, 0x007e, i); 1265 } 1266 break; 1267 } 1268 case CIT_MODEL4: 1269 /* HDG: taken from ibmcam, setting the color gains does not 1270 * really belong here. 1271 * 1272 * I am not sure r/g/b_gain variables exactly control gain 1273 * of those channels. Most likely they subtly change some 1274 * very internal image processing settings in the camera. 1275 * In any case, here is what they do, and feel free to tweak: 1276 * 1277 * r_gain: seriously affects red gain 1278 * g_gain: seriously affects green gain 1279 * b_gain: seriously affects blue gain 1280 * hue: changes average color from violet (0) to red (0xFF) 1281 */ 1282 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 1283 cit_write_reg(gspca_dev, 0x001e, 0x012f); 1284 cit_write_reg(gspca_dev, 0xd141, 0x0124); 1285 cit_write_reg(gspca_dev, 160, 0x0127); /* Green gain */ 1286 cit_write_reg(gspca_dev, 160, 0x012e); /* Red gain */ 1287 cit_write_reg(gspca_dev, 160, 0x0130); /* Blue gain */ 1288 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 1289 cit_write_reg(gspca_dev, val, 0x012d); /* Hue */ 1290 cit_write_reg(gspca_dev, 0xf545, 0x0124); 1291 break; 1292 } 1293 return 0; 1294 } 1295 1296 static int cit_set_sharpness(struct gspca_dev *gspca_dev, s32 val) 1297 { 1298 struct sd *sd = (struct sd *) gspca_dev; 1299 1300 switch (sd->model) { 1301 case CIT_MODEL0: 1302 case CIT_MODEL2: 1303 case CIT_MODEL4: 1304 case CIT_IBM_NETCAM_PRO: 1305 /* These models do not have this control */ 1306 break; 1307 case CIT_MODEL1: { 1308 int i; 1309 static const unsigned short sa[] = { 1310 0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a }; 1311 1312 for (i = 0; i < cit_model1_ntries; i++) 1313 cit_PacketFormat2(gspca_dev, 0x0013, sa[val]); 1314 break; 1315 } 1316 case CIT_MODEL3: 1317 { /* 1318 * "Use a table of magic numbers. 1319 * This setting doesn't really change much. 1320 * But that's how Windows does it." 1321 */ 1322 static const struct { 1323 unsigned short sv1; 1324 unsigned short sv2; 1325 unsigned short sv3; 1326 unsigned short sv4; 1327 } sv[7] = { 1328 { 0x00, 0x00, 0x05, 0x14 }, /* Smoothest */ 1329 { 0x01, 0x04, 0x05, 0x14 }, 1330 { 0x02, 0x04, 0x05, 0x14 }, 1331 { 0x03, 0x04, 0x05, 0x14 }, 1332 { 0x03, 0x05, 0x05, 0x14 }, 1333 { 0x03, 0x06, 0x05, 0x14 }, 1334 { 0x03, 0x07, 0x05, 0x14 } /* Sharpest */ 1335 }; 1336 cit_model3_Packet1(gspca_dev, 0x0060, sv[val].sv1); 1337 cit_model3_Packet1(gspca_dev, 0x0061, sv[val].sv2); 1338 cit_model3_Packet1(gspca_dev, 0x0062, sv[val].sv3); 1339 cit_model3_Packet1(gspca_dev, 0x0063, sv[val].sv4); 1340 break; 1341 } 1342 } 1343 return 0; 1344 } 1345 1346 /* 1347 * cit_set_lighting() 1348 * 1349 * Camera model 1: 1350 * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low. 1351 * 1352 * Camera model 2: 1353 * We have 16 levels of lighting, 0 for bright light and up to 15 for 1354 * low light. But values above 5 or so are useless because camera is 1355 * not really capable to produce anything worth viewing at such light. 1356 * This setting may be altered only in certain camera state. 1357 * 1358 * Low lighting forces slower FPS. 1359 * 1360 * History: 1361 * 1/5/00 Created. 1362 * 2/20/00 Added support for Model 2 cameras. 1363 */ 1364 static void cit_set_lighting(struct gspca_dev *gspca_dev, s32 val) 1365 { 1366 struct sd *sd = (struct sd *) gspca_dev; 1367 1368 switch (sd->model) { 1369 case CIT_MODEL0: 1370 case CIT_MODEL2: 1371 case CIT_MODEL3: 1372 case CIT_MODEL4: 1373 case CIT_IBM_NETCAM_PRO: 1374 break; 1375 case CIT_MODEL1: { 1376 int i; 1377 for (i = 0; i < cit_model1_ntries; i++) 1378 cit_Packet_Format1(gspca_dev, 0x0027, val); 1379 break; 1380 } 1381 } 1382 } 1383 1384 static void cit_set_hflip(struct gspca_dev *gspca_dev, s32 val) 1385 { 1386 struct sd *sd = (struct sd *) gspca_dev; 1387 1388 switch (sd->model) { 1389 case CIT_MODEL0: 1390 if (val) 1391 cit_write_reg(gspca_dev, 0x0020, 0x0115); 1392 else 1393 cit_write_reg(gspca_dev, 0x0040, 0x0115); 1394 break; 1395 case CIT_MODEL1: 1396 case CIT_MODEL2: 1397 case CIT_MODEL3: 1398 case CIT_MODEL4: 1399 case CIT_IBM_NETCAM_PRO: 1400 break; 1401 } 1402 } 1403 1404 static int cit_restart_stream(struct gspca_dev *gspca_dev) 1405 { 1406 struct sd *sd = (struct sd *) gspca_dev; 1407 1408 switch (sd->model) { 1409 case CIT_MODEL0: 1410 case CIT_MODEL1: 1411 cit_write_reg(gspca_dev, 0x0001, 0x0114); 1412 /* Fall through */ 1413 case CIT_MODEL2: 1414 case CIT_MODEL4: 1415 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */ 1416 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe); 1417 break; 1418 case CIT_MODEL3: 1419 case CIT_IBM_NETCAM_PRO: 1420 cit_write_reg(gspca_dev, 0x0001, 0x0114); 1421 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */ 1422 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe); 1423 /* Clear button events from while we were not streaming */ 1424 cit_write_reg(gspca_dev, 0x0001, 0x0113); 1425 break; 1426 } 1427 1428 sd->sof_read = 0; 1429 1430 return 0; 1431 } 1432 1433 static int cit_get_packet_size(struct gspca_dev *gspca_dev) 1434 { 1435 struct usb_host_interface *alt; 1436 struct usb_interface *intf; 1437 1438 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface); 1439 alt = usb_altnum_to_altsetting(intf, gspca_dev->alt); 1440 if (!alt) { 1441 pr_err("Couldn't get altsetting\n"); 1442 return -EIO; 1443 } 1444 1445 return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); 1446 } 1447 1448 /* Calculate the clockdiv giving us max fps given the available bandwidth */ 1449 static int cit_get_clock_div(struct gspca_dev *gspca_dev) 1450 { 1451 int clock_div = 7; /* 0=30 1=25 2=20 3=15 4=12 5=7.5 6=6 7=3fps ?? */ 1452 int fps[8] = { 30, 25, 20, 15, 12, 8, 6, 3 }; 1453 int packet_size; 1454 1455 packet_size = cit_get_packet_size(gspca_dev); 1456 if (packet_size < 0) 1457 return packet_size; 1458 1459 while (clock_div > 3 && 1460 1000 * packet_size > 1461 gspca_dev->pixfmt.width * gspca_dev->pixfmt.height * 1462 fps[clock_div - 1] * 3 / 2) 1463 clock_div--; 1464 1465 gspca_dbg(gspca_dev, D_PROBE, 1466 "PacketSize: %d, res: %dx%d -> using clockdiv: %d (%d fps)\n", 1467 packet_size, 1468 gspca_dev->pixfmt.width, gspca_dev->pixfmt.height, 1469 clock_div, fps[clock_div]); 1470 1471 return clock_div; 1472 } 1473 1474 static int cit_start_model0(struct gspca_dev *gspca_dev) 1475 { 1476 const unsigned short compression = 0; /* 0=none, 7=best frame rate */ 1477 int clock_div; 1478 1479 clock_div = cit_get_clock_div(gspca_dev); 1480 if (clock_div < 0) 1481 return clock_div; 1482 1483 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */ 1484 cit_write_reg(gspca_dev, 0x0003, 0x0438); 1485 cit_write_reg(gspca_dev, 0x001e, 0x042b); 1486 cit_write_reg(gspca_dev, 0x0041, 0x042c); 1487 cit_write_reg(gspca_dev, 0x0008, 0x0436); 1488 cit_write_reg(gspca_dev, 0x0024, 0x0403); 1489 cit_write_reg(gspca_dev, 0x002c, 0x0404); 1490 cit_write_reg(gspca_dev, 0x0002, 0x0426); 1491 cit_write_reg(gspca_dev, 0x0014, 0x0427); 1492 1493 switch (gspca_dev->pixfmt.width) { 1494 case 160: /* 160x120 */ 1495 cit_write_reg(gspca_dev, 0x0004, 0x010b); 1496 cit_write_reg(gspca_dev, 0x0001, 0x010a); 1497 cit_write_reg(gspca_dev, 0x0010, 0x0102); 1498 cit_write_reg(gspca_dev, 0x00a0, 0x0103); 1499 cit_write_reg(gspca_dev, 0x0000, 0x0104); 1500 cit_write_reg(gspca_dev, 0x0078, 0x0105); 1501 break; 1502 1503 case 176: /* 176x144 */ 1504 cit_write_reg(gspca_dev, 0x0006, 0x010b); 1505 cit_write_reg(gspca_dev, 0x0000, 0x010a); 1506 cit_write_reg(gspca_dev, 0x0005, 0x0102); 1507 cit_write_reg(gspca_dev, 0x00b0, 0x0103); 1508 cit_write_reg(gspca_dev, 0x0000, 0x0104); 1509 cit_write_reg(gspca_dev, 0x0090, 0x0105); 1510 break; 1511 1512 case 320: /* 320x240 */ 1513 cit_write_reg(gspca_dev, 0x0008, 0x010b); 1514 cit_write_reg(gspca_dev, 0x0004, 0x010a); 1515 cit_write_reg(gspca_dev, 0x0005, 0x0102); 1516 cit_write_reg(gspca_dev, 0x00a0, 0x0103); 1517 cit_write_reg(gspca_dev, 0x0010, 0x0104); 1518 cit_write_reg(gspca_dev, 0x0078, 0x0105); 1519 break; 1520 } 1521 1522 cit_write_reg(gspca_dev, compression, 0x0109); 1523 cit_write_reg(gspca_dev, clock_div, 0x0111); 1524 1525 return 0; 1526 } 1527 1528 static int cit_start_model1(struct gspca_dev *gspca_dev) 1529 { 1530 struct sd *sd = (struct sd *) gspca_dev; 1531 int i, clock_div; 1532 1533 clock_div = cit_get_clock_div(gspca_dev); 1534 if (clock_div < 0) 1535 return clock_div; 1536 1537 cit_read_reg(gspca_dev, 0x0128, 1); 1538 cit_read_reg(gspca_dev, 0x0100, 0); 1539 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */ 1540 cit_read_reg(gspca_dev, 0x0100, 0); 1541 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */ 1542 cit_read_reg(gspca_dev, 0x0100, 0); 1543 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */ 1544 cit_write_reg(gspca_dev, 0x01, 0x0108); 1545 1546 cit_write_reg(gspca_dev, 0x03, 0x0112); 1547 cit_read_reg(gspca_dev, 0x0115, 0); 1548 cit_write_reg(gspca_dev, 0x06, 0x0115); 1549 cit_read_reg(gspca_dev, 0x0116, 0); 1550 cit_write_reg(gspca_dev, 0x44, 0x0116); 1551 cit_read_reg(gspca_dev, 0x0116, 0); 1552 cit_write_reg(gspca_dev, 0x40, 0x0116); 1553 cit_read_reg(gspca_dev, 0x0115, 0); 1554 cit_write_reg(gspca_dev, 0x0e, 0x0115); 1555 cit_write_reg(gspca_dev, 0x19, 0x012c); 1556 1557 cit_Packet_Format1(gspca_dev, 0x00, 0x1e); 1558 cit_Packet_Format1(gspca_dev, 0x39, 0x0d); 1559 cit_Packet_Format1(gspca_dev, 0x39, 0x09); 1560 cit_Packet_Format1(gspca_dev, 0x3b, 0x00); 1561 cit_Packet_Format1(gspca_dev, 0x28, 0x22); 1562 cit_Packet_Format1(gspca_dev, 0x27, 0x00); 1563 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f); 1564 cit_Packet_Format1(gspca_dev, 0x39, 0x08); 1565 1566 for (i = 0; i < cit_model1_ntries; i++) 1567 cit_Packet_Format1(gspca_dev, 0x2c, 0x00); 1568 1569 for (i = 0; i < cit_model1_ntries; i++) 1570 cit_Packet_Format1(gspca_dev, 0x30, 0x14); 1571 1572 cit_PacketFormat2(gspca_dev, 0x39, 0x02); 1573 cit_PacketFormat2(gspca_dev, 0x01, 0xe1); 1574 cit_PacketFormat2(gspca_dev, 0x02, 0xcd); 1575 cit_PacketFormat2(gspca_dev, 0x03, 0xcd); 1576 cit_PacketFormat2(gspca_dev, 0x04, 0xfa); 1577 cit_PacketFormat2(gspca_dev, 0x3f, 0xff); 1578 cit_PacketFormat2(gspca_dev, 0x39, 0x00); 1579 1580 cit_PacketFormat2(gspca_dev, 0x39, 0x02); 1581 cit_PacketFormat2(gspca_dev, 0x0a, 0x37); 1582 cit_PacketFormat2(gspca_dev, 0x0b, 0xb8); 1583 cit_PacketFormat2(gspca_dev, 0x0c, 0xf3); 1584 cit_PacketFormat2(gspca_dev, 0x0d, 0xe3); 1585 cit_PacketFormat2(gspca_dev, 0x0e, 0x0d); 1586 cit_PacketFormat2(gspca_dev, 0x0f, 0xf2); 1587 cit_PacketFormat2(gspca_dev, 0x10, 0xd5); 1588 cit_PacketFormat2(gspca_dev, 0x11, 0xba); 1589 cit_PacketFormat2(gspca_dev, 0x12, 0x53); 1590 cit_PacketFormat2(gspca_dev, 0x3f, 0xff); 1591 cit_PacketFormat2(gspca_dev, 0x39, 0x00); 1592 1593 cit_PacketFormat2(gspca_dev, 0x39, 0x02); 1594 cit_PacketFormat2(gspca_dev, 0x16, 0x00); 1595 cit_PacketFormat2(gspca_dev, 0x17, 0x28); 1596 cit_PacketFormat2(gspca_dev, 0x18, 0x7d); 1597 cit_PacketFormat2(gspca_dev, 0x19, 0xbe); 1598 cit_PacketFormat2(gspca_dev, 0x3f, 0xff); 1599 cit_PacketFormat2(gspca_dev, 0x39, 0x00); 1600 1601 for (i = 0; i < cit_model1_ntries; i++) 1602 cit_Packet_Format1(gspca_dev, 0x00, 0x18); 1603 for (i = 0; i < cit_model1_ntries; i++) 1604 cit_Packet_Format1(gspca_dev, 0x13, 0x18); 1605 for (i = 0; i < cit_model1_ntries; i++) 1606 cit_Packet_Format1(gspca_dev, 0x14, 0x06); 1607 1608 /* TESTME These are handled through controls 1609 KEEP until someone can test leaving this out is ok */ 1610 if (0) { 1611 /* This is default brightness */ 1612 for (i = 0; i < cit_model1_ntries; i++) 1613 cit_Packet_Format1(gspca_dev, 0x31, 0x37); 1614 for (i = 0; i < cit_model1_ntries; i++) 1615 cit_Packet_Format1(gspca_dev, 0x32, 0x46); 1616 for (i = 0; i < cit_model1_ntries; i++) 1617 cit_Packet_Format1(gspca_dev, 0x33, 0x55); 1618 } 1619 1620 cit_Packet_Format1(gspca_dev, 0x2e, 0x04); 1621 for (i = 0; i < cit_model1_ntries; i++) 1622 cit_Packet_Format1(gspca_dev, 0x2d, 0x04); 1623 for (i = 0; i < cit_model1_ntries; i++) 1624 cit_Packet_Format1(gspca_dev, 0x29, 0x80); 1625 cit_Packet_Format1(gspca_dev, 0x2c, 0x01); 1626 cit_Packet_Format1(gspca_dev, 0x30, 0x17); 1627 cit_Packet_Format1(gspca_dev, 0x39, 0x08); 1628 for (i = 0; i < cit_model1_ntries; i++) 1629 cit_Packet_Format1(gspca_dev, 0x34, 0x00); 1630 1631 cit_write_reg(gspca_dev, 0x00, 0x0101); 1632 cit_write_reg(gspca_dev, 0x00, 0x010a); 1633 1634 switch (gspca_dev->pixfmt.width) { 1635 case 128: /* 128x96 */ 1636 cit_write_reg(gspca_dev, 0x80, 0x0103); 1637 cit_write_reg(gspca_dev, 0x60, 0x0105); 1638 cit_write_reg(gspca_dev, 0x0c, 0x010b); 1639 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */ 1640 cit_write_reg(gspca_dev, 0x0b, 0x011d); 1641 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */ 1642 cit_write_reg(gspca_dev, 0x00, 0x0129); 1643 break; 1644 case 176: /* 176x144 */ 1645 cit_write_reg(gspca_dev, 0xb0, 0x0103); 1646 cit_write_reg(gspca_dev, 0x8f, 0x0105); 1647 cit_write_reg(gspca_dev, 0x06, 0x010b); 1648 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */ 1649 cit_write_reg(gspca_dev, 0x0d, 0x011d); 1650 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */ 1651 cit_write_reg(gspca_dev, 0x03, 0x0129); 1652 break; 1653 case 352: /* 352x288 */ 1654 cit_write_reg(gspca_dev, 0xb0, 0x0103); 1655 cit_write_reg(gspca_dev, 0x90, 0x0105); 1656 cit_write_reg(gspca_dev, 0x02, 0x010b); 1657 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */ 1658 cit_write_reg(gspca_dev, 0x05, 0x011d); 1659 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */ 1660 cit_write_reg(gspca_dev, 0x00, 0x0129); 1661 break; 1662 } 1663 1664 cit_write_reg(gspca_dev, 0xff, 0x012b); 1665 1666 /* TESTME These are handled through controls 1667 KEEP until someone can test leaving this out is ok */ 1668 if (0) { 1669 /* This is another brightness - don't know why */ 1670 for (i = 0; i < cit_model1_ntries; i++) 1671 cit_Packet_Format1(gspca_dev, 0x31, 0xc3); 1672 for (i = 0; i < cit_model1_ntries; i++) 1673 cit_Packet_Format1(gspca_dev, 0x32, 0xd2); 1674 for (i = 0; i < cit_model1_ntries; i++) 1675 cit_Packet_Format1(gspca_dev, 0x33, 0xe1); 1676 1677 /* Default contrast */ 1678 for (i = 0; i < cit_model1_ntries; i++) 1679 cit_Packet_Format1(gspca_dev, 0x14, 0x0a); 1680 1681 /* Default sharpness */ 1682 for (i = 0; i < cit_model1_ntries2; i++) 1683 cit_PacketFormat2(gspca_dev, 0x13, 0x1a); 1684 1685 /* Default lighting conditions */ 1686 cit_Packet_Format1(gspca_dev, 0x0027, 1687 v4l2_ctrl_g_ctrl(sd->lighting)); 1688 } 1689 1690 /* Assorted init */ 1691 switch (gspca_dev->pixfmt.width) { 1692 case 128: /* 128x96 */ 1693 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e); 1694 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */ 1695 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */ 1696 cit_write_reg(gspca_dev, 0x36, 0x0102); 1697 cit_write_reg(gspca_dev, 0x1a, 0x0104); 1698 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */ 1699 cit_write_reg(gspca_dev, 0x2b, 0x011c); 1700 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */ 1701 break; 1702 case 176: /* 176x144 */ 1703 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e); 1704 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */ 1705 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */ 1706 cit_write_reg(gspca_dev, 0x04, 0x0102); 1707 cit_write_reg(gspca_dev, 0x02, 0x0104); 1708 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */ 1709 cit_write_reg(gspca_dev, 0x2b, 0x011c); 1710 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */ 1711 break; 1712 case 352: /* 352x288 */ 1713 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f); 1714 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */ 1715 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */ 1716 cit_write_reg(gspca_dev, 0x08, 0x0102); 1717 cit_write_reg(gspca_dev, 0x01, 0x0104); 1718 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */ 1719 cit_write_reg(gspca_dev, 0x2f, 0x011c); 1720 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */ 1721 break; 1722 } 1723 1724 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */ 1725 cit_write_reg(gspca_dev, clock_div, 0x0111); 1726 1727 return 0; 1728 } 1729 1730 static int cit_start_model2(struct gspca_dev *gspca_dev) 1731 { 1732 struct sd *sd = (struct sd *) gspca_dev; 1733 int clock_div = 0; 1734 1735 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* LED on */ 1736 cit_read_reg(gspca_dev, 0x0116, 0); 1737 cit_write_reg(gspca_dev, 0x0060, 0x0116); 1738 cit_write_reg(gspca_dev, 0x0002, 0x0112); 1739 cit_write_reg(gspca_dev, 0x00bc, 0x012c); 1740 cit_write_reg(gspca_dev, 0x0008, 0x012b); 1741 cit_write_reg(gspca_dev, 0x0000, 0x0108); 1742 cit_write_reg(gspca_dev, 0x0001, 0x0133); 1743 cit_write_reg(gspca_dev, 0x0001, 0x0102); 1744 switch (gspca_dev->pixfmt.width) { 1745 case 176: /* 176x144 */ 1746 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */ 1747 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */ 1748 cit_write_reg(gspca_dev, 0x0024, 0x0105); /* 176x144, 352x288 */ 1749 cit_write_reg(gspca_dev, 0x00b9, 0x010a); /* Unique to this mode */ 1750 cit_write_reg(gspca_dev, 0x0038, 0x0119); /* Unique to this mode */ 1751 /* TESTME HDG: this does not seem right 1752 (it is 2 for all other resolutions) */ 1753 sd->sof_len = 10; 1754 break; 1755 case 320: /* 320x240 */ 1756 cit_write_reg(gspca_dev, 0x0028, 0x0103); /* Unique to this mode */ 1757 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */ 1758 cit_write_reg(gspca_dev, 0x001e, 0x0105); /* 320x240, 352x240 */ 1759 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */ 1760 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */ 1761 sd->sof_len = 2; 1762 break; 1763 #if 0 1764 case VIDEOSIZE_352x240: 1765 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */ 1766 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */ 1767 cit_write_reg(gspca_dev, 0x001e, 0x0105); /* 320x240, 352x240 */ 1768 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */ 1769 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */ 1770 sd->sof_len = 2; 1771 break; 1772 #endif 1773 case 352: /* 352x288 */ 1774 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */ 1775 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */ 1776 cit_write_reg(gspca_dev, 0x0024, 0x0105); /* 176x144, 352x288 */ 1777 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */ 1778 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */ 1779 sd->sof_len = 2; 1780 break; 1781 } 1782 1783 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* LED on */ 1784 1785 switch (gspca_dev->pixfmt.width) { 1786 case 176: /* 176x144 */ 1787 cit_write_reg(gspca_dev, 0x0050, 0x0111); 1788 cit_write_reg(gspca_dev, 0x00d0, 0x0111); 1789 break; 1790 case 320: /* 320x240 */ 1791 case 352: /* 352x288 */ 1792 cit_write_reg(gspca_dev, 0x0040, 0x0111); 1793 cit_write_reg(gspca_dev, 0x00c0, 0x0111); 1794 break; 1795 } 1796 cit_write_reg(gspca_dev, 0x009b, 0x010f); 1797 cit_write_reg(gspca_dev, 0x00bb, 0x010f); 1798 1799 /* 1800 * Hardware settings, may affect CMOS sensor; not user controls! 1801 * ------------------------------------------------------------- 1802 * 0x0004: no effect 1803 * 0x0006: hardware effect 1804 * 0x0008: no effect 1805 * 0x000a: stops video stream, probably important h/w setting 1806 * 0x000c: changes color in hardware manner (not user setting) 1807 * 0x0012: changes number of colors (does not affect speed) 1808 * 0x002a: no effect 1809 * 0x002c: hardware setting (related to scan lines) 1810 * 0x002e: stops video stream, probably important h/w setting 1811 */ 1812 cit_model2_Packet1(gspca_dev, 0x000a, 0x005c); 1813 cit_model2_Packet1(gspca_dev, 0x0004, 0x0000); 1814 cit_model2_Packet1(gspca_dev, 0x0006, 0x00fb); 1815 cit_model2_Packet1(gspca_dev, 0x0008, 0x0000); 1816 cit_model2_Packet1(gspca_dev, 0x000c, 0x0009); 1817 cit_model2_Packet1(gspca_dev, 0x0012, 0x000a); 1818 cit_model2_Packet1(gspca_dev, 0x002a, 0x0000); 1819 cit_model2_Packet1(gspca_dev, 0x002c, 0x0000); 1820 cit_model2_Packet1(gspca_dev, 0x002e, 0x0008); 1821 1822 /* 1823 * Function 0x0030 pops up all over the place. Apparently 1824 * it is a hardware control register, with every bit assigned to 1825 * do something. 1826 */ 1827 cit_model2_Packet1(gspca_dev, 0x0030, 0x0000); 1828 1829 /* 1830 * Magic control of CMOS sensor. Only lower values like 1831 * 0-3 work, and picture shifts left or right. Don't change. 1832 */ 1833 switch (gspca_dev->pixfmt.width) { 1834 case 176: /* 176x144 */ 1835 cit_model2_Packet1(gspca_dev, 0x0014, 0x0002); 1836 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */ 1837 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */ 1838 clock_div = 6; 1839 break; 1840 case 320: /* 320x240 */ 1841 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); 1842 cit_model2_Packet1(gspca_dev, 0x0016, 0x0005); /* Horizontal shift */ 1843 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Another hardware setting */ 1844 clock_div = 8; 1845 break; 1846 #if 0 1847 case VIDEOSIZE_352x240: 1848 /* This mode doesn't work as Windows programs it; changed to work */ 1849 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); /* Windows sets this to 8 */ 1850 cit_model2_Packet1(gspca_dev, 0x0016, 0x0003); /* Horizontal shift */ 1851 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Windows sets this to 0x0045 */ 1852 clock_div = 10; 1853 break; 1854 #endif 1855 case 352: /* 352x288 */ 1856 cit_model2_Packet1(gspca_dev, 0x0014, 0x0003); 1857 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */ 1858 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */ 1859 clock_div = 16; 1860 break; 1861 } 1862 1863 /* TESTME These are handled through controls 1864 KEEP until someone can test leaving this out is ok */ 1865 if (0) 1866 cit_model2_Packet1(gspca_dev, 0x001a, 0x005a); 1867 1868 /* 1869 * We have our own frame rate setting varying from 0 (slowest) to 6 1870 * (fastest). The camera model 2 allows frame rate in range [0..0x1F] 1871 # where 0 is also the slowest setting. However for all practical 1872 # reasons high settings make no sense because USB is not fast enough 1873 # to support high FPS. Be aware that the picture datastream will be 1874 # severely disrupted if you ask for frame rate faster than allowed 1875 # for the video size - see below: 1876 * 1877 * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz): 1878 * ----------------------------------------------------------------- 1879 * 176x144: [6..31] 1880 * 320x240: [8..31] 1881 * 352x240: [10..31] 1882 * 352x288: [16..31] I have to raise lower threshold for stability... 1883 * 1884 * As usual, slower FPS provides better sensitivity. 1885 */ 1886 cit_model2_Packet1(gspca_dev, 0x001c, clock_div); 1887 1888 /* 1889 * This setting does not visibly affect pictures; left it here 1890 * because it was present in Windows USB data stream. This function 1891 * does not allow arbitrary values and apparently is a bit mask, to 1892 * be activated only at appropriate time. Don't change it randomly! 1893 */ 1894 switch (gspca_dev->pixfmt.width) { 1895 case 176: /* 176x144 */ 1896 cit_model2_Packet1(gspca_dev, 0x0026, 0x00c2); 1897 break; 1898 case 320: /* 320x240 */ 1899 cit_model2_Packet1(gspca_dev, 0x0026, 0x0044); 1900 break; 1901 #if 0 1902 case VIDEOSIZE_352x240: 1903 cit_model2_Packet1(gspca_dev, 0x0026, 0x0046); 1904 break; 1905 #endif 1906 case 352: /* 352x288 */ 1907 cit_model2_Packet1(gspca_dev, 0x0026, 0x0048); 1908 break; 1909 } 1910 1911 cit_model2_Packet1(gspca_dev, 0x0028, v4l2_ctrl_g_ctrl(sd->lighting)); 1912 /* model2 cannot change the backlight compensation while streaming */ 1913 v4l2_ctrl_grab(sd->lighting, true); 1914 1915 /* color balance rg2 */ 1916 cit_model2_Packet1(gspca_dev, 0x001e, 0x002f); 1917 /* saturation */ 1918 cit_model2_Packet1(gspca_dev, 0x0020, 0x0034); 1919 /* color balance yb */ 1920 cit_model2_Packet1(gspca_dev, 0x0022, 0x00a0); 1921 1922 /* Hardware control command */ 1923 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004); 1924 1925 return 0; 1926 } 1927 1928 static int cit_start_model3(struct gspca_dev *gspca_dev) 1929 { 1930 const unsigned short compression = 0; /* 0=none, 7=best frame rate */ 1931 int i, clock_div = 0; 1932 1933 /* HDG not in ibmcam driver, added to see if it helps with 1934 auto-detecting between model3 and ibm netcamera pro */ 1935 cit_read_reg(gspca_dev, 0x128, 1); 1936 1937 cit_write_reg(gspca_dev, 0x0000, 0x0100); 1938 cit_read_reg(gspca_dev, 0x0116, 0); 1939 cit_write_reg(gspca_dev, 0x0060, 0x0116); 1940 cit_write_reg(gspca_dev, 0x0002, 0x0112); 1941 cit_write_reg(gspca_dev, 0x0000, 0x0123); 1942 cit_write_reg(gspca_dev, 0x0001, 0x0117); 1943 cit_write_reg(gspca_dev, 0x0040, 0x0108); 1944 cit_write_reg(gspca_dev, 0x0019, 0x012c); 1945 cit_write_reg(gspca_dev, 0x0060, 0x0116); 1946 cit_write_reg(gspca_dev, 0x0002, 0x0115); 1947 cit_write_reg(gspca_dev, 0x0003, 0x0115); 1948 cit_read_reg(gspca_dev, 0x0115, 0); 1949 cit_write_reg(gspca_dev, 0x000b, 0x0115); 1950 1951 /* TESTME HDG not in ibmcam driver, added to see if it helps with 1952 auto-detecting between model3 and ibm netcamera pro */ 1953 if (0) { 1954 cit_write_reg(gspca_dev, 0x0078, 0x012d); 1955 cit_write_reg(gspca_dev, 0x0001, 0x012f); 1956 cit_write_reg(gspca_dev, 0xd141, 0x0124); 1957 cit_write_reg(gspca_dev, 0x0079, 0x012d); 1958 cit_write_reg(gspca_dev, 0x00ff, 0x0130); 1959 cit_write_reg(gspca_dev, 0xcd41, 0x0124); 1960 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 1961 cit_read_reg(gspca_dev, 0x0126, 1); 1962 } 1963 1964 cit_model3_Packet1(gspca_dev, 0x000a, 0x0040); 1965 cit_model3_Packet1(gspca_dev, 0x000b, 0x00f6); 1966 cit_model3_Packet1(gspca_dev, 0x000c, 0x0002); 1967 cit_model3_Packet1(gspca_dev, 0x000d, 0x0020); 1968 cit_model3_Packet1(gspca_dev, 0x000e, 0x0033); 1969 cit_model3_Packet1(gspca_dev, 0x000f, 0x0007); 1970 cit_model3_Packet1(gspca_dev, 0x0010, 0x0000); 1971 cit_model3_Packet1(gspca_dev, 0x0011, 0x0070); 1972 cit_model3_Packet1(gspca_dev, 0x0012, 0x0030); 1973 cit_model3_Packet1(gspca_dev, 0x0013, 0x0000); 1974 cit_model3_Packet1(gspca_dev, 0x0014, 0x0001); 1975 cit_model3_Packet1(gspca_dev, 0x0015, 0x0001); 1976 cit_model3_Packet1(gspca_dev, 0x0016, 0x0001); 1977 cit_model3_Packet1(gspca_dev, 0x0017, 0x0001); 1978 cit_model3_Packet1(gspca_dev, 0x0018, 0x0000); 1979 cit_model3_Packet1(gspca_dev, 0x001e, 0x00c3); 1980 cit_model3_Packet1(gspca_dev, 0x0020, 0x0000); 1981 cit_model3_Packet1(gspca_dev, 0x0028, 0x0010); 1982 cit_model3_Packet1(gspca_dev, 0x0029, 0x0054); 1983 cit_model3_Packet1(gspca_dev, 0x002a, 0x0013); 1984 cit_model3_Packet1(gspca_dev, 0x002b, 0x0007); 1985 cit_model3_Packet1(gspca_dev, 0x002d, 0x0028); 1986 cit_model3_Packet1(gspca_dev, 0x002e, 0x0000); 1987 cit_model3_Packet1(gspca_dev, 0x0031, 0x0000); 1988 cit_model3_Packet1(gspca_dev, 0x0032, 0x0000); 1989 cit_model3_Packet1(gspca_dev, 0x0033, 0x0000); 1990 cit_model3_Packet1(gspca_dev, 0x0034, 0x0000); 1991 cit_model3_Packet1(gspca_dev, 0x0035, 0x0038); 1992 cit_model3_Packet1(gspca_dev, 0x003a, 0x0001); 1993 cit_model3_Packet1(gspca_dev, 0x003c, 0x001e); 1994 cit_model3_Packet1(gspca_dev, 0x003f, 0x000a); 1995 cit_model3_Packet1(gspca_dev, 0x0041, 0x0000); 1996 cit_model3_Packet1(gspca_dev, 0x0046, 0x003f); 1997 cit_model3_Packet1(gspca_dev, 0x0047, 0x0000); 1998 cit_model3_Packet1(gspca_dev, 0x0050, 0x0005); 1999 cit_model3_Packet1(gspca_dev, 0x0052, 0x001a); 2000 cit_model3_Packet1(gspca_dev, 0x0053, 0x0003); 2001 cit_model3_Packet1(gspca_dev, 0x005a, 0x006b); 2002 cit_model3_Packet1(gspca_dev, 0x005d, 0x001e); 2003 cit_model3_Packet1(gspca_dev, 0x005e, 0x0030); 2004 cit_model3_Packet1(gspca_dev, 0x005f, 0x0041); 2005 cit_model3_Packet1(gspca_dev, 0x0064, 0x0008); 2006 cit_model3_Packet1(gspca_dev, 0x0065, 0x0015); 2007 cit_model3_Packet1(gspca_dev, 0x0068, 0x000f); 2008 cit_model3_Packet1(gspca_dev, 0x0079, 0x0000); 2009 cit_model3_Packet1(gspca_dev, 0x007a, 0x0000); 2010 cit_model3_Packet1(gspca_dev, 0x007c, 0x003f); 2011 cit_model3_Packet1(gspca_dev, 0x0082, 0x000f); 2012 cit_model3_Packet1(gspca_dev, 0x0085, 0x0000); 2013 cit_model3_Packet1(gspca_dev, 0x0099, 0x0000); 2014 cit_model3_Packet1(gspca_dev, 0x009b, 0x0023); 2015 cit_model3_Packet1(gspca_dev, 0x009c, 0x0022); 2016 cit_model3_Packet1(gspca_dev, 0x009d, 0x0096); 2017 cit_model3_Packet1(gspca_dev, 0x009e, 0x0096); 2018 cit_model3_Packet1(gspca_dev, 0x009f, 0x000a); 2019 2020 switch (gspca_dev->pixfmt.width) { 2021 case 160: 2022 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */ 2023 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */ 2024 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */ 2025 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */ 2026 cit_write_reg(gspca_dev, 0x0024, 0x010b); /* Differs everywhere */ 2027 cit_write_reg(gspca_dev, 0x00a9, 0x0119); 2028 cit_write_reg(gspca_dev, 0x0016, 0x011b); 2029 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */ 2030 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */ 2031 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */ 2032 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */ 2033 cit_write_reg(gspca_dev, 0x0018, 0x0102); 2034 cit_write_reg(gspca_dev, 0x0004, 0x0104); 2035 cit_write_reg(gspca_dev, 0x0004, 0x011a); 2036 cit_write_reg(gspca_dev, 0x0028, 0x011c); 2037 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */ 2038 cit_write_reg(gspca_dev, 0x0000, 0x0118); 2039 cit_write_reg(gspca_dev, 0x0000, 0x0132); 2040 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */ 2041 cit_write_reg(gspca_dev, compression, 0x0109); 2042 clock_div = 3; 2043 break; 2044 case 320: 2045 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */ 2046 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */ 2047 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */ 2048 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */ 2049 cit_write_reg(gspca_dev, 0x0028, 0x010b); /* Differs everywhere */ 2050 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same */ 2051 cit_write_reg(gspca_dev, 0x0000, 0x011e); 2052 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */ 2053 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */ 2054 /* 4 commands from 160x120 skipped */ 2055 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */ 2056 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */ 2057 cit_write_reg(gspca_dev, compression, 0x0109); 2058 cit_write_reg(gspca_dev, 0x00d9, 0x0119); 2059 cit_write_reg(gspca_dev, 0x0006, 0x011b); 2060 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */ 2061 cit_write_reg(gspca_dev, 0x0010, 0x0104); 2062 cit_write_reg(gspca_dev, 0x0004, 0x011a); 2063 cit_write_reg(gspca_dev, 0x003f, 0x011c); 2064 cit_write_reg(gspca_dev, 0x001c, 0x0118); 2065 cit_write_reg(gspca_dev, 0x0000, 0x0132); 2066 clock_div = 5; 2067 break; 2068 case 640: 2069 cit_write_reg(gspca_dev, 0x00f0, 0x0105); 2070 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */ 2071 cit_write_reg(gspca_dev, 0x0038, 0x010b); /* Differs everywhere */ 2072 cit_write_reg(gspca_dev, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */ 2073 cit_write_reg(gspca_dev, 0x0006, 0x011b); /* Same on 320x240, 640x480 */ 2074 cit_write_reg(gspca_dev, 0x0004, 0x011d); /* NC */ 2075 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */ 2076 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */ 2077 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */ 2078 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */ 2079 cit_write_reg(gspca_dev, 0x0016, 0x0104); /* NC */ 2080 cit_write_reg(gspca_dev, 0x0004, 0x011a); /* Same on 320x240, 640x480 */ 2081 cit_write_reg(gspca_dev, 0x003f, 0x011c); /* Same on 320x240, 640x480 */ 2082 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */ 2083 cit_write_reg(gspca_dev, 0x001c, 0x0118); /* Same on 320x240, 640x480 */ 2084 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */ 2085 cit_write_reg(gspca_dev, compression, 0x0109); 2086 cit_write_reg(gspca_dev, 0x0040, 0x0101); 2087 cit_write_reg(gspca_dev, 0x0040, 0x0103); 2088 cit_write_reg(gspca_dev, 0x0000, 0x0132); /* Same on 320x240, 640x480 */ 2089 clock_div = 7; 2090 break; 2091 } 2092 2093 cit_model3_Packet1(gspca_dev, 0x007e, 0x000e); /* Hue */ 2094 cit_model3_Packet1(gspca_dev, 0x0036, 0x0011); /* Brightness */ 2095 cit_model3_Packet1(gspca_dev, 0x0060, 0x0002); /* Sharpness */ 2096 cit_model3_Packet1(gspca_dev, 0x0061, 0x0004); /* Sharpness */ 2097 cit_model3_Packet1(gspca_dev, 0x0062, 0x0005); /* Sharpness */ 2098 cit_model3_Packet1(gspca_dev, 0x0063, 0x0014); /* Sharpness */ 2099 cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0); /* Red sharpness */ 2100 cit_model3_Packet1(gspca_dev, 0x0097, 0x0096); /* Blue sharpness */ 2101 cit_model3_Packet1(gspca_dev, 0x0067, 0x0001); /* Contrast */ 2102 cit_model3_Packet1(gspca_dev, 0x005b, 0x000c); /* Contrast */ 2103 cit_model3_Packet1(gspca_dev, 0x005c, 0x0016); /* Contrast */ 2104 cit_model3_Packet1(gspca_dev, 0x0098, 0x000b); 2105 cit_model3_Packet1(gspca_dev, 0x002c, 0x0003); /* Was 1, broke 640x480 */ 2106 cit_model3_Packet1(gspca_dev, 0x002f, 0x002a); 2107 cit_model3_Packet1(gspca_dev, 0x0030, 0x0029); 2108 cit_model3_Packet1(gspca_dev, 0x0037, 0x0002); 2109 cit_model3_Packet1(gspca_dev, 0x0038, 0x0059); 2110 cit_model3_Packet1(gspca_dev, 0x003d, 0x002e); 2111 cit_model3_Packet1(gspca_dev, 0x003e, 0x0028); 2112 cit_model3_Packet1(gspca_dev, 0x0078, 0x0005); 2113 cit_model3_Packet1(gspca_dev, 0x007b, 0x0011); 2114 cit_model3_Packet1(gspca_dev, 0x007d, 0x004b); 2115 cit_model3_Packet1(gspca_dev, 0x007f, 0x0022); 2116 cit_model3_Packet1(gspca_dev, 0x0080, 0x000c); 2117 cit_model3_Packet1(gspca_dev, 0x0081, 0x000b); 2118 cit_model3_Packet1(gspca_dev, 0x0083, 0x00fd); 2119 cit_model3_Packet1(gspca_dev, 0x0086, 0x000b); 2120 cit_model3_Packet1(gspca_dev, 0x0087, 0x000b); 2121 cit_model3_Packet1(gspca_dev, 0x007e, 0x000e); 2122 cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0); /* Red sharpness */ 2123 cit_model3_Packet1(gspca_dev, 0x0097, 0x0096); /* Blue sharpness */ 2124 cit_model3_Packet1(gspca_dev, 0x0098, 0x000b); 2125 2126 /* FIXME we should probably use cit_get_clock_div() here (in 2127 combination with isoc negotiation using the programmable isoc size) 2128 like with the IBM netcam pro). */ 2129 cit_write_reg(gspca_dev, clock_div, 0x0111); /* Clock Divider */ 2130 2131 switch (gspca_dev->pixfmt.width) { 2132 case 160: 2133 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */ 2134 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */ 2135 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */ 2136 cit_model3_Packet1(gspca_dev, 0x0040, 0x000a); 2137 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a); 2138 break; 2139 case 320: 2140 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */ 2141 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */ 2142 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */ 2143 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008); 2144 cit_model3_Packet1(gspca_dev, 0x0051, 0x000b); 2145 break; 2146 case 640: 2147 cit_model3_Packet1(gspca_dev, 0x001f, 0x0002); /* !Same */ 2148 cit_model3_Packet1(gspca_dev, 0x0039, 0x003e); /* !Same */ 2149 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008); 2150 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a); 2151 break; 2152 } 2153 2154 /* if (sd->input_index) { */ 2155 if (rca_input) { 2156 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) { 2157 if (rca_initdata[i][0]) 2158 cit_read_reg(gspca_dev, rca_initdata[i][2], 0); 2159 else 2160 cit_write_reg(gspca_dev, rca_initdata[i][1], 2161 rca_initdata[i][2]); 2162 } 2163 } 2164 2165 return 0; 2166 } 2167 2168 static int cit_start_model4(struct gspca_dev *gspca_dev) 2169 { 2170 struct sd *sd = (struct sd *) gspca_dev; 2171 2172 cit_write_reg(gspca_dev, 0x0000, 0x0100); 2173 cit_write_reg(gspca_dev, 0x00c0, 0x0111); 2174 cit_write_reg(gspca_dev, 0x00bc, 0x012c); 2175 cit_write_reg(gspca_dev, 0x0080, 0x012b); 2176 cit_write_reg(gspca_dev, 0x0000, 0x0108); 2177 cit_write_reg(gspca_dev, 0x0001, 0x0133); 2178 cit_write_reg(gspca_dev, 0x009b, 0x010f); 2179 cit_write_reg(gspca_dev, 0x00bb, 0x010f); 2180 cit_model4_Packet1(gspca_dev, 0x0038, 0x0000); 2181 cit_model4_Packet1(gspca_dev, 0x000a, 0x005c); 2182 2183 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2184 cit_write_reg(gspca_dev, 0x0004, 0x012f); 2185 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2186 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2187 cit_write_reg(gspca_dev, 0x00fb, 0x012e); 2188 cit_write_reg(gspca_dev, 0x0000, 0x0130); 2189 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2190 cit_write_reg(gspca_dev, 0x00aa, 0x012f); 2191 cit_write_reg(gspca_dev, 0xd055, 0x0124); 2192 cit_write_reg(gspca_dev, 0x000c, 0x0127); 2193 cit_write_reg(gspca_dev, 0x0009, 0x012e); 2194 cit_write_reg(gspca_dev, 0xaa28, 0x0124); 2195 2196 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2197 cit_write_reg(gspca_dev, 0x0012, 0x012f); 2198 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2199 cit_write_reg(gspca_dev, 0x0008, 0x0127); 2200 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2201 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2202 cit_write_reg(gspca_dev, 0x002a, 0x012d); 2203 cit_write_reg(gspca_dev, 0x0000, 0x012f); 2204 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2205 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 2206 cit_model4_Packet1(gspca_dev, 0x0034, 0x0000); 2207 2208 switch (gspca_dev->pixfmt.width) { 2209 case 128: /* 128x96 */ 2210 cit_write_reg(gspca_dev, 0x0070, 0x0119); 2211 cit_write_reg(gspca_dev, 0x00d0, 0x0111); 2212 cit_write_reg(gspca_dev, 0x0039, 0x010a); 2213 cit_write_reg(gspca_dev, 0x0001, 0x0102); 2214 cit_write_reg(gspca_dev, 0x0028, 0x0103); 2215 cit_write_reg(gspca_dev, 0x0000, 0x0104); 2216 cit_write_reg(gspca_dev, 0x001e, 0x0105); 2217 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2218 cit_write_reg(gspca_dev, 0x0016, 0x012f); 2219 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2220 cit_write_reg(gspca_dev, 0x000a, 0x0127); 2221 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2222 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2223 cit_write_reg(gspca_dev, 0x0014, 0x012d); 2224 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2225 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2226 cit_write_reg(gspca_dev, 0x00aa, 0x012e); 2227 cit_write_reg(gspca_dev, 0x001a, 0x0130); 2228 cit_write_reg(gspca_dev, 0x8a0a, 0x0124); 2229 cit_write_reg(gspca_dev, 0x005a, 0x012d); 2230 cit_write_reg(gspca_dev, 0x9545, 0x0124); 2231 cit_write_reg(gspca_dev, 0x00aa, 0x0127); 2232 cit_write_reg(gspca_dev, 0x0018, 0x012e); 2233 cit_write_reg(gspca_dev, 0x0043, 0x0130); 2234 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2235 cit_write_reg(gspca_dev, 0x00aa, 0x012f); 2236 cit_write_reg(gspca_dev, 0xd055, 0x0124); 2237 cit_write_reg(gspca_dev, 0x001c, 0x0127); 2238 cit_write_reg(gspca_dev, 0x00eb, 0x012e); 2239 cit_write_reg(gspca_dev, 0xaa28, 0x0124); 2240 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2241 cit_write_reg(gspca_dev, 0x0032, 0x012f); 2242 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2243 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2244 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2245 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2246 cit_write_reg(gspca_dev, 0x0036, 0x012d); 2247 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2248 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2249 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 2250 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2251 cit_write_reg(gspca_dev, 0x001e, 0x012f); 2252 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2253 cit_write_reg(gspca_dev, 0x0017, 0x0127); 2254 cit_write_reg(gspca_dev, 0x0013, 0x012e); 2255 cit_write_reg(gspca_dev, 0x0031, 0x0130); 2256 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2257 cit_write_reg(gspca_dev, 0x0017, 0x012d); 2258 cit_write_reg(gspca_dev, 0x0078, 0x012f); 2259 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2260 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2261 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 2262 sd->sof_len = 2; 2263 break; 2264 case 160: /* 160x120 */ 2265 cit_write_reg(gspca_dev, 0x0038, 0x0119); 2266 cit_write_reg(gspca_dev, 0x00d0, 0x0111); 2267 cit_write_reg(gspca_dev, 0x00b9, 0x010a); 2268 cit_write_reg(gspca_dev, 0x0001, 0x0102); 2269 cit_write_reg(gspca_dev, 0x0028, 0x0103); 2270 cit_write_reg(gspca_dev, 0x0000, 0x0104); 2271 cit_write_reg(gspca_dev, 0x001e, 0x0105); 2272 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2273 cit_write_reg(gspca_dev, 0x0016, 0x012f); 2274 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2275 cit_write_reg(gspca_dev, 0x000b, 0x0127); 2276 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2277 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2278 cit_write_reg(gspca_dev, 0x0014, 0x012d); 2279 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2280 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2281 cit_write_reg(gspca_dev, 0x00aa, 0x012e); 2282 cit_write_reg(gspca_dev, 0x001a, 0x0130); 2283 cit_write_reg(gspca_dev, 0x8a0a, 0x0124); 2284 cit_write_reg(gspca_dev, 0x005a, 0x012d); 2285 cit_write_reg(gspca_dev, 0x9545, 0x0124); 2286 cit_write_reg(gspca_dev, 0x00aa, 0x0127); 2287 cit_write_reg(gspca_dev, 0x0018, 0x012e); 2288 cit_write_reg(gspca_dev, 0x0043, 0x0130); 2289 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2290 cit_write_reg(gspca_dev, 0x00aa, 0x012f); 2291 cit_write_reg(gspca_dev, 0xd055, 0x0124); 2292 cit_write_reg(gspca_dev, 0x001c, 0x0127); 2293 cit_write_reg(gspca_dev, 0x00c7, 0x012e); 2294 cit_write_reg(gspca_dev, 0xaa28, 0x0124); 2295 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2296 cit_write_reg(gspca_dev, 0x0032, 0x012f); 2297 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2298 cit_write_reg(gspca_dev, 0x0025, 0x0127); 2299 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2300 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2301 cit_write_reg(gspca_dev, 0x0036, 0x012d); 2302 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2303 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2304 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 2305 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2306 cit_write_reg(gspca_dev, 0x001e, 0x012f); 2307 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2308 cit_write_reg(gspca_dev, 0x0048, 0x0127); 2309 cit_write_reg(gspca_dev, 0x0035, 0x012e); 2310 cit_write_reg(gspca_dev, 0x00d0, 0x0130); 2311 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2312 cit_write_reg(gspca_dev, 0x0048, 0x012d); 2313 cit_write_reg(gspca_dev, 0x0090, 0x012f); 2314 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2315 cit_write_reg(gspca_dev, 0x0001, 0x0127); 2316 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 2317 sd->sof_len = 2; 2318 break; 2319 case 176: /* 176x144 */ 2320 cit_write_reg(gspca_dev, 0x0038, 0x0119); 2321 cit_write_reg(gspca_dev, 0x00d0, 0x0111); 2322 cit_write_reg(gspca_dev, 0x00b9, 0x010a); 2323 cit_write_reg(gspca_dev, 0x0001, 0x0102); 2324 cit_write_reg(gspca_dev, 0x002c, 0x0103); 2325 cit_write_reg(gspca_dev, 0x0000, 0x0104); 2326 cit_write_reg(gspca_dev, 0x0024, 0x0105); 2327 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2328 cit_write_reg(gspca_dev, 0x0016, 0x012f); 2329 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2330 cit_write_reg(gspca_dev, 0x0007, 0x0127); 2331 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2332 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2333 cit_write_reg(gspca_dev, 0x0014, 0x012d); 2334 cit_write_reg(gspca_dev, 0x0001, 0x012f); 2335 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2336 cit_write_reg(gspca_dev, 0x00aa, 0x012e); 2337 cit_write_reg(gspca_dev, 0x001a, 0x0130); 2338 cit_write_reg(gspca_dev, 0x8a0a, 0x0124); 2339 cit_write_reg(gspca_dev, 0x005e, 0x012d); 2340 cit_write_reg(gspca_dev, 0x9545, 0x0124); 2341 cit_write_reg(gspca_dev, 0x00aa, 0x0127); 2342 cit_write_reg(gspca_dev, 0x0018, 0x012e); 2343 cit_write_reg(gspca_dev, 0x0049, 0x0130); 2344 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2345 cit_write_reg(gspca_dev, 0x00aa, 0x012f); 2346 cit_write_reg(gspca_dev, 0xd055, 0x0124); 2347 cit_write_reg(gspca_dev, 0x001c, 0x0127); 2348 cit_write_reg(gspca_dev, 0x00c7, 0x012e); 2349 cit_write_reg(gspca_dev, 0xaa28, 0x0124); 2350 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2351 cit_write_reg(gspca_dev, 0x0032, 0x012f); 2352 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2353 cit_write_reg(gspca_dev, 0x0028, 0x0127); 2354 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2355 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2356 cit_write_reg(gspca_dev, 0x0036, 0x012d); 2357 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2358 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2359 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 2360 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2361 cit_write_reg(gspca_dev, 0x001e, 0x012f); 2362 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2363 cit_write_reg(gspca_dev, 0x0010, 0x0127); 2364 cit_write_reg(gspca_dev, 0x0013, 0x012e); 2365 cit_write_reg(gspca_dev, 0x002a, 0x0130); 2366 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2367 cit_write_reg(gspca_dev, 0x0010, 0x012d); 2368 cit_write_reg(gspca_dev, 0x006d, 0x012f); 2369 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2370 cit_write_reg(gspca_dev, 0x0001, 0x0127); 2371 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 2372 /* TESTME HDG: this does not seem right 2373 (it is 2 for all other resolutions) */ 2374 sd->sof_len = 10; 2375 break; 2376 case 320: /* 320x240 */ 2377 cit_write_reg(gspca_dev, 0x0070, 0x0119); 2378 cit_write_reg(gspca_dev, 0x00d0, 0x0111); 2379 cit_write_reg(gspca_dev, 0x0039, 0x010a); 2380 cit_write_reg(gspca_dev, 0x0001, 0x0102); 2381 cit_write_reg(gspca_dev, 0x0028, 0x0103); 2382 cit_write_reg(gspca_dev, 0x0000, 0x0104); 2383 cit_write_reg(gspca_dev, 0x001e, 0x0105); 2384 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2385 cit_write_reg(gspca_dev, 0x0016, 0x012f); 2386 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2387 cit_write_reg(gspca_dev, 0x000a, 0x0127); 2388 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2389 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2390 cit_write_reg(gspca_dev, 0x0014, 0x012d); 2391 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2392 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2393 cit_write_reg(gspca_dev, 0x00aa, 0x012e); 2394 cit_write_reg(gspca_dev, 0x001a, 0x0130); 2395 cit_write_reg(gspca_dev, 0x8a0a, 0x0124); 2396 cit_write_reg(gspca_dev, 0x005a, 0x012d); 2397 cit_write_reg(gspca_dev, 0x9545, 0x0124); 2398 cit_write_reg(gspca_dev, 0x00aa, 0x0127); 2399 cit_write_reg(gspca_dev, 0x0018, 0x012e); 2400 cit_write_reg(gspca_dev, 0x0043, 0x0130); 2401 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2402 cit_write_reg(gspca_dev, 0x00aa, 0x012f); 2403 cit_write_reg(gspca_dev, 0xd055, 0x0124); 2404 cit_write_reg(gspca_dev, 0x001c, 0x0127); 2405 cit_write_reg(gspca_dev, 0x00eb, 0x012e); 2406 cit_write_reg(gspca_dev, 0xaa28, 0x0124); 2407 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2408 cit_write_reg(gspca_dev, 0x0032, 0x012f); 2409 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2410 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2411 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2412 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2413 cit_write_reg(gspca_dev, 0x0036, 0x012d); 2414 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2415 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2416 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 2417 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2418 cit_write_reg(gspca_dev, 0x001e, 0x012f); 2419 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2420 cit_write_reg(gspca_dev, 0x0017, 0x0127); 2421 cit_write_reg(gspca_dev, 0x0013, 0x012e); 2422 cit_write_reg(gspca_dev, 0x0031, 0x0130); 2423 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2424 cit_write_reg(gspca_dev, 0x0017, 0x012d); 2425 cit_write_reg(gspca_dev, 0x0078, 0x012f); 2426 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2427 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2428 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 2429 sd->sof_len = 2; 2430 break; 2431 case 352: /* 352x288 */ 2432 cit_write_reg(gspca_dev, 0x0070, 0x0119); 2433 cit_write_reg(gspca_dev, 0x00c0, 0x0111); 2434 cit_write_reg(gspca_dev, 0x0039, 0x010a); 2435 cit_write_reg(gspca_dev, 0x0001, 0x0102); 2436 cit_write_reg(gspca_dev, 0x002c, 0x0103); 2437 cit_write_reg(gspca_dev, 0x0000, 0x0104); 2438 cit_write_reg(gspca_dev, 0x0024, 0x0105); 2439 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2440 cit_write_reg(gspca_dev, 0x0016, 0x012f); 2441 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2442 cit_write_reg(gspca_dev, 0x0006, 0x0127); 2443 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2444 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2445 cit_write_reg(gspca_dev, 0x0014, 0x012d); 2446 cit_write_reg(gspca_dev, 0x0002, 0x012f); 2447 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2448 cit_write_reg(gspca_dev, 0x00aa, 0x012e); 2449 cit_write_reg(gspca_dev, 0x001a, 0x0130); 2450 cit_write_reg(gspca_dev, 0x8a0a, 0x0124); 2451 cit_write_reg(gspca_dev, 0x005e, 0x012d); 2452 cit_write_reg(gspca_dev, 0x9545, 0x0124); 2453 cit_write_reg(gspca_dev, 0x00aa, 0x0127); 2454 cit_write_reg(gspca_dev, 0x0018, 0x012e); 2455 cit_write_reg(gspca_dev, 0x0049, 0x0130); 2456 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2457 cit_write_reg(gspca_dev, 0x00aa, 0x012f); 2458 cit_write_reg(gspca_dev, 0xd055, 0x0124); 2459 cit_write_reg(gspca_dev, 0x001c, 0x0127); 2460 cit_write_reg(gspca_dev, 0x00cf, 0x012e); 2461 cit_write_reg(gspca_dev, 0xaa28, 0x0124); 2462 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2463 cit_write_reg(gspca_dev, 0x0032, 0x012f); 2464 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2465 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2466 cit_write_reg(gspca_dev, 0x00aa, 0x0130); 2467 cit_write_reg(gspca_dev, 0x82a8, 0x0124); 2468 cit_write_reg(gspca_dev, 0x0036, 0x012d); 2469 cit_write_reg(gspca_dev, 0x0008, 0x012f); 2470 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2471 cit_write_reg(gspca_dev, 0xfffa, 0x0124); 2472 cit_write_reg(gspca_dev, 0x00aa, 0x012d); 2473 cit_write_reg(gspca_dev, 0x001e, 0x012f); 2474 cit_write_reg(gspca_dev, 0xd141, 0x0124); 2475 cit_write_reg(gspca_dev, 0x0010, 0x0127); 2476 cit_write_reg(gspca_dev, 0x0013, 0x012e); 2477 cit_write_reg(gspca_dev, 0x0025, 0x0130); 2478 cit_write_reg(gspca_dev, 0x8a28, 0x0124); 2479 cit_write_reg(gspca_dev, 0x0010, 0x012d); 2480 cit_write_reg(gspca_dev, 0x0048, 0x012f); 2481 cit_write_reg(gspca_dev, 0xd145, 0x0124); 2482 cit_write_reg(gspca_dev, 0x0000, 0x0127); 2483 cit_write_reg(gspca_dev, 0xfea8, 0x0124); 2484 sd->sof_len = 2; 2485 break; 2486 } 2487 2488 cit_model4_Packet1(gspca_dev, 0x0038, 0x0004); 2489 2490 return 0; 2491 } 2492 2493 static int cit_start_ibm_netcam_pro(struct gspca_dev *gspca_dev) 2494 { 2495 const unsigned short compression = 0; /* 0=none, 7=best frame rate */ 2496 int i, clock_div; 2497 2498 clock_div = cit_get_clock_div(gspca_dev); 2499 if (clock_div < 0) 2500 return clock_div; 2501 2502 cit_write_reg(gspca_dev, 0x0003, 0x0133); 2503 cit_write_reg(gspca_dev, 0x0000, 0x0117); 2504 cit_write_reg(gspca_dev, 0x0008, 0x0123); 2505 cit_write_reg(gspca_dev, 0x0000, 0x0100); 2506 cit_write_reg(gspca_dev, 0x0060, 0x0116); 2507 /* cit_write_reg(gspca_dev, 0x0002, 0x0112); see sd_stop0 */ 2508 cit_write_reg(gspca_dev, 0x0000, 0x0133); 2509 cit_write_reg(gspca_dev, 0x0000, 0x0123); 2510 cit_write_reg(gspca_dev, 0x0001, 0x0117); 2511 cit_write_reg(gspca_dev, 0x0040, 0x0108); 2512 cit_write_reg(gspca_dev, 0x0019, 0x012c); 2513 cit_write_reg(gspca_dev, 0x0060, 0x0116); 2514 /* cit_write_reg(gspca_dev, 0x000b, 0x0115); see sd_stop0 */ 2515 2516 cit_model3_Packet1(gspca_dev, 0x0049, 0x0000); 2517 2518 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */ 2519 cit_write_reg(gspca_dev, 0x003a, 0x0102); /* Hstart */ 2520 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */ 2521 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */ 2522 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */ 2523 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */ 2524 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */ 2525 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */ 2526 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */ 2527 2528 switch (gspca_dev->pixfmt.width) { 2529 case 160: /* 160x120 */ 2530 cit_write_reg(gspca_dev, 0x0024, 0x010b); 2531 cit_write_reg(gspca_dev, 0x0089, 0x0119); 2532 cit_write_reg(gspca_dev, 0x000a, 0x011b); 2533 cit_write_reg(gspca_dev, 0x0003, 0x011e); 2534 cit_write_reg(gspca_dev, 0x0007, 0x0104); 2535 cit_write_reg(gspca_dev, 0x0009, 0x011a); 2536 cit_write_reg(gspca_dev, 0x008b, 0x011c); 2537 cit_write_reg(gspca_dev, 0x0008, 0x0118); 2538 cit_write_reg(gspca_dev, 0x0000, 0x0132); 2539 break; 2540 case 320: /* 320x240 */ 2541 cit_write_reg(gspca_dev, 0x0028, 0x010b); 2542 cit_write_reg(gspca_dev, 0x00d9, 0x0119); 2543 cit_write_reg(gspca_dev, 0x0006, 0x011b); 2544 cit_write_reg(gspca_dev, 0x0000, 0x011e); 2545 cit_write_reg(gspca_dev, 0x000e, 0x0104); 2546 cit_write_reg(gspca_dev, 0x0004, 0x011a); 2547 cit_write_reg(gspca_dev, 0x003f, 0x011c); 2548 cit_write_reg(gspca_dev, 0x000c, 0x0118); 2549 cit_write_reg(gspca_dev, 0x0000, 0x0132); 2550 break; 2551 } 2552 2553 cit_model3_Packet1(gspca_dev, 0x0019, 0x0031); 2554 cit_model3_Packet1(gspca_dev, 0x001a, 0x0003); 2555 cit_model3_Packet1(gspca_dev, 0x001b, 0x0038); 2556 cit_model3_Packet1(gspca_dev, 0x001c, 0x0000); 2557 cit_model3_Packet1(gspca_dev, 0x0024, 0x0001); 2558 cit_model3_Packet1(gspca_dev, 0x0027, 0x0001); 2559 cit_model3_Packet1(gspca_dev, 0x002a, 0x0004); 2560 cit_model3_Packet1(gspca_dev, 0x0035, 0x000b); 2561 cit_model3_Packet1(gspca_dev, 0x003f, 0x0001); 2562 cit_model3_Packet1(gspca_dev, 0x0044, 0x0000); 2563 cit_model3_Packet1(gspca_dev, 0x0054, 0x0000); 2564 cit_model3_Packet1(gspca_dev, 0x00c4, 0x0000); 2565 cit_model3_Packet1(gspca_dev, 0x00e7, 0x0001); 2566 cit_model3_Packet1(gspca_dev, 0x00e9, 0x0001); 2567 cit_model3_Packet1(gspca_dev, 0x00ee, 0x0000); 2568 cit_model3_Packet1(gspca_dev, 0x00f3, 0x00c0); 2569 2570 cit_write_reg(gspca_dev, compression, 0x0109); 2571 cit_write_reg(gspca_dev, clock_div, 0x0111); 2572 2573 /* if (sd->input_index) { */ 2574 if (rca_input) { 2575 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) { 2576 if (rca_initdata[i][0]) 2577 cit_read_reg(gspca_dev, rca_initdata[i][2], 0); 2578 else 2579 cit_write_reg(gspca_dev, rca_initdata[i][1], 2580 rca_initdata[i][2]); 2581 } 2582 } 2583 2584 return 0; 2585 } 2586 2587 /* -- start the camera -- */ 2588 static int sd_start(struct gspca_dev *gspca_dev) 2589 { 2590 struct sd *sd = (struct sd *) gspca_dev; 2591 int packet_size; 2592 2593 packet_size = cit_get_packet_size(gspca_dev); 2594 if (packet_size < 0) 2595 return packet_size; 2596 2597 switch (sd->model) { 2598 case CIT_MODEL0: 2599 cit_start_model0(gspca_dev); 2600 break; 2601 case CIT_MODEL1: 2602 cit_start_model1(gspca_dev); 2603 break; 2604 case CIT_MODEL2: 2605 cit_start_model2(gspca_dev); 2606 break; 2607 case CIT_MODEL3: 2608 cit_start_model3(gspca_dev); 2609 break; 2610 case CIT_MODEL4: 2611 cit_start_model4(gspca_dev); 2612 break; 2613 case CIT_IBM_NETCAM_PRO: 2614 cit_start_ibm_netcam_pro(gspca_dev); 2615 break; 2616 } 2617 2618 /* Program max isoc packet size */ 2619 cit_write_reg(gspca_dev, packet_size >> 8, 0x0106); 2620 cit_write_reg(gspca_dev, packet_size & 0xff, 0x0107); 2621 2622 cit_restart_stream(gspca_dev); 2623 2624 return 0; 2625 } 2626 2627 static int sd_isoc_init(struct gspca_dev *gspca_dev) 2628 { 2629 struct usb_host_interface *alt; 2630 int max_packet_size; 2631 2632 switch (gspca_dev->pixfmt.width) { 2633 case 160: 2634 max_packet_size = 450; 2635 break; 2636 case 176: 2637 max_packet_size = 600; 2638 break; 2639 default: 2640 max_packet_size = 1022; 2641 break; 2642 } 2643 2644 /* Start isoc bandwidth "negotiation" at max isoc bandwidth */ 2645 alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1]; 2646 alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size); 2647 2648 return 0; 2649 } 2650 2651 static int sd_isoc_nego(struct gspca_dev *gspca_dev) 2652 { 2653 int ret, packet_size, min_packet_size; 2654 struct usb_host_interface *alt; 2655 2656 switch (gspca_dev->pixfmt.width) { 2657 case 160: 2658 min_packet_size = 200; 2659 break; 2660 case 176: 2661 min_packet_size = 266; 2662 break; 2663 default: 2664 min_packet_size = 400; 2665 break; 2666 } 2667 2668 alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1]; 2669 packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize); 2670 if (packet_size <= min_packet_size) 2671 return -EIO; 2672 2673 packet_size -= 100; 2674 if (packet_size < min_packet_size) 2675 packet_size = min_packet_size; 2676 alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size); 2677 2678 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1); 2679 if (ret < 0) 2680 pr_err("set alt 1 err %d\n", ret); 2681 2682 return ret; 2683 } 2684 2685 static void sd_stopN(struct gspca_dev *gspca_dev) 2686 { 2687 cit_write_reg(gspca_dev, 0x0000, 0x010c); 2688 } 2689 2690 static void sd_stop0(struct gspca_dev *gspca_dev) 2691 { 2692 struct sd *sd = (struct sd *) gspca_dev; 2693 2694 if (!gspca_dev->present) 2695 return; 2696 2697 switch (sd->model) { 2698 case CIT_MODEL0: 2699 /* HDG windows does this, but it causes the cams autogain to 2700 restart from a gain of 0, which does not look good when 2701 changing resolutions. */ 2702 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */ 2703 cit_write_reg(gspca_dev, 0x00c0, 0x0100); /* LED Off */ 2704 break; 2705 case CIT_MODEL1: 2706 cit_send_FF_04_02(gspca_dev); 2707 cit_read_reg(gspca_dev, 0x0100, 0); 2708 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */ 2709 break; 2710 case CIT_MODEL2: 2711 v4l2_ctrl_grab(sd->lighting, false); 2712 /* Fall through! */ 2713 case CIT_MODEL4: 2714 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004); 2715 2716 cit_write_reg(gspca_dev, 0x0080, 0x0100); /* LED Off */ 2717 cit_write_reg(gspca_dev, 0x0020, 0x0111); 2718 cit_write_reg(gspca_dev, 0x00a0, 0x0111); 2719 2720 cit_model2_Packet1(gspca_dev, 0x0030, 0x0002); 2721 2722 cit_write_reg(gspca_dev, 0x0020, 0x0111); 2723 cit_write_reg(gspca_dev, 0x0000, 0x0112); 2724 break; 2725 case CIT_MODEL3: 2726 cit_write_reg(gspca_dev, 0x0006, 0x012c); 2727 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000); 2728 cit_read_reg(gspca_dev, 0x0116, 0); 2729 cit_write_reg(gspca_dev, 0x0064, 0x0116); 2730 cit_read_reg(gspca_dev, 0x0115, 0); 2731 cit_write_reg(gspca_dev, 0x0003, 0x0115); 2732 cit_write_reg(gspca_dev, 0x0008, 0x0123); 2733 cit_write_reg(gspca_dev, 0x0000, 0x0117); 2734 cit_write_reg(gspca_dev, 0x0000, 0x0112); 2735 cit_write_reg(gspca_dev, 0x0080, 0x0100); 2736 break; 2737 case CIT_IBM_NETCAM_PRO: 2738 cit_model3_Packet1(gspca_dev, 0x0049, 0x00ff); 2739 cit_write_reg(gspca_dev, 0x0006, 0x012c); 2740 cit_write_reg(gspca_dev, 0x0000, 0x0116); 2741 /* HDG windows does this, but I cannot get the camera 2742 to restart with this without redoing the entire init 2743 sequence which makes switching modes really slow */ 2744 /* cit_write_reg(gspca_dev, 0x0006, 0x0115); */ 2745 cit_write_reg(gspca_dev, 0x0008, 0x0123); 2746 cit_write_reg(gspca_dev, 0x0000, 0x0117); 2747 cit_write_reg(gspca_dev, 0x0003, 0x0133); 2748 cit_write_reg(gspca_dev, 0x0000, 0x0111); 2749 /* HDG windows does this, but I get a green picture when 2750 restarting the stream after this */ 2751 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */ 2752 cit_write_reg(gspca_dev, 0x00c0, 0x0100); 2753 break; 2754 } 2755 2756 #if IS_ENABLED(CONFIG_INPUT) 2757 /* If the last button state is pressed, release it now! */ 2758 if (sd->button_state) { 2759 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 2760 input_sync(gspca_dev->input_dev); 2761 sd->button_state = 0; 2762 } 2763 #endif 2764 } 2765 2766 static u8 *cit_find_sof(struct gspca_dev *gspca_dev, u8 *data, int len) 2767 { 2768 struct sd *sd = (struct sd *) gspca_dev; 2769 u8 byte3 = 0, byte4 = 0; 2770 int i; 2771 2772 switch (sd->model) { 2773 case CIT_MODEL0: 2774 case CIT_MODEL1: 2775 case CIT_MODEL3: 2776 case CIT_IBM_NETCAM_PRO: 2777 switch (gspca_dev->pixfmt.width) { 2778 case 160: /* 160x120 */ 2779 byte3 = 0x02; 2780 byte4 = 0x0a; 2781 break; 2782 case 176: /* 176x144 */ 2783 byte3 = 0x02; 2784 byte4 = 0x0e; 2785 break; 2786 case 320: /* 320x240 */ 2787 byte3 = 0x02; 2788 byte4 = 0x08; 2789 break; 2790 case 352: /* 352x288 */ 2791 byte3 = 0x02; 2792 byte4 = 0x00; 2793 break; 2794 case 640: 2795 byte3 = 0x03; 2796 byte4 = 0x08; 2797 break; 2798 } 2799 2800 /* These have a different byte3 */ 2801 if (sd->model <= CIT_MODEL1) 2802 byte3 = 0x00; 2803 2804 for (i = 0; i < len; i++) { 2805 /* For this model the SOF always starts at offset 0 2806 so no need to search the entire frame */ 2807 if (sd->model == CIT_MODEL0 && sd->sof_read != i) 2808 break; 2809 2810 switch (sd->sof_read) { 2811 case 0: 2812 if (data[i] == 0x00) 2813 sd->sof_read++; 2814 break; 2815 case 1: 2816 if (data[i] == 0xff) 2817 sd->sof_read++; 2818 else if (data[i] == 0x00) 2819 sd->sof_read = 1; 2820 else 2821 sd->sof_read = 0; 2822 break; 2823 case 2: 2824 if (data[i] == byte3) 2825 sd->sof_read++; 2826 else if (data[i] == 0x00) 2827 sd->sof_read = 1; 2828 else 2829 sd->sof_read = 0; 2830 break; 2831 case 3: 2832 if (data[i] == byte4) { 2833 sd->sof_read = 0; 2834 return data + i + (sd->sof_len - 3); 2835 } 2836 if (byte3 == 0x00 && data[i] == 0xff) 2837 sd->sof_read = 2; 2838 else if (data[i] == 0x00) 2839 sd->sof_read = 1; 2840 else 2841 sd->sof_read = 0; 2842 break; 2843 } 2844 } 2845 break; 2846 case CIT_MODEL2: 2847 case CIT_MODEL4: 2848 /* TESTME we need to find a longer sof signature to avoid 2849 false positives */ 2850 for (i = 0; i < len; i++) { 2851 switch (sd->sof_read) { 2852 case 0: 2853 if (data[i] == 0x00) 2854 sd->sof_read++; 2855 break; 2856 case 1: 2857 sd->sof_read = 0; 2858 if (data[i] == 0xff) { 2859 if (i >= 4) 2860 gspca_dbg(gspca_dev, D_FRAM, 2861 "header found at offset: %d: %02x %02x 00 %3ph\n\n", 2862 i - 1, 2863 data[i - 4], 2864 data[i - 3], 2865 &data[i]); 2866 else 2867 gspca_dbg(gspca_dev, D_FRAM, 2868 "header found at offset: %d: 00 %3ph\n\n", 2869 i - 1, 2870 &data[i]); 2871 return data + i + (sd->sof_len - 1); 2872 } 2873 break; 2874 } 2875 } 2876 break; 2877 } 2878 return NULL; 2879 } 2880 2881 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 2882 u8 *data, int len) 2883 { 2884 struct sd *sd = (struct sd *) gspca_dev; 2885 unsigned char *sof; 2886 2887 sof = cit_find_sof(gspca_dev, data, len); 2888 if (sof) { 2889 int n; 2890 2891 /* finish decoding current frame */ 2892 n = sof - data; 2893 if (n > sd->sof_len) 2894 n -= sd->sof_len; 2895 else 2896 n = 0; 2897 gspca_frame_add(gspca_dev, LAST_PACKET, 2898 data, n); 2899 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0); 2900 len -= sof - data; 2901 data = sof; 2902 } 2903 2904 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 2905 } 2906 2907 #if IS_ENABLED(CONFIG_INPUT) 2908 static void cit_check_button(struct gspca_dev *gspca_dev) 2909 { 2910 int new_button_state; 2911 struct sd *sd = (struct sd *)gspca_dev; 2912 2913 switch (sd->model) { 2914 case CIT_MODEL3: 2915 case CIT_IBM_NETCAM_PRO: 2916 break; 2917 default: /* TEST ME unknown if this works on other models too */ 2918 return; 2919 } 2920 2921 /* Read the button state */ 2922 cit_read_reg(gspca_dev, 0x0113, 0); 2923 new_button_state = !gspca_dev->usb_buf[0]; 2924 2925 /* Tell the cam we've seen the button press, notice that this 2926 is a nop (iow the cam keeps reporting pressed) until the 2927 button is actually released. */ 2928 if (new_button_state) 2929 cit_write_reg(gspca_dev, 0x01, 0x0113); 2930 2931 if (sd->button_state != new_button_state) { 2932 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 2933 new_button_state); 2934 input_sync(gspca_dev->input_dev); 2935 sd->button_state = new_button_state; 2936 } 2937 } 2938 #endif 2939 2940 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 2941 { 2942 struct gspca_dev *gspca_dev = 2943 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 2944 struct sd *sd = (struct sd *)gspca_dev; 2945 2946 gspca_dev->usb_err = 0; 2947 2948 if (!gspca_dev->streaming) 2949 return 0; 2950 2951 if (sd->stop_on_control_change) 2952 sd_stopN(gspca_dev); 2953 switch (ctrl->id) { 2954 case V4L2_CID_BRIGHTNESS: 2955 cit_set_brightness(gspca_dev, ctrl->val); 2956 break; 2957 case V4L2_CID_CONTRAST: 2958 cit_set_contrast(gspca_dev, ctrl->val); 2959 break; 2960 case V4L2_CID_HUE: 2961 cit_set_hue(gspca_dev, ctrl->val); 2962 break; 2963 case V4L2_CID_HFLIP: 2964 cit_set_hflip(gspca_dev, ctrl->val); 2965 break; 2966 case V4L2_CID_SHARPNESS: 2967 cit_set_sharpness(gspca_dev, ctrl->val); 2968 break; 2969 case V4L2_CID_BACKLIGHT_COMPENSATION: 2970 cit_set_lighting(gspca_dev, ctrl->val); 2971 break; 2972 } 2973 if (sd->stop_on_control_change) 2974 cit_restart_stream(gspca_dev); 2975 return gspca_dev->usb_err; 2976 } 2977 2978 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 2979 .s_ctrl = sd_s_ctrl, 2980 }; 2981 2982 static int sd_init_controls(struct gspca_dev *gspca_dev) 2983 { 2984 struct sd *sd = (struct sd *)gspca_dev; 2985 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 2986 bool has_brightness; 2987 bool has_contrast; 2988 bool has_hue; 2989 bool has_sharpness; 2990 bool has_lighting; 2991 bool has_hflip; 2992 2993 has_brightness = has_contrast = has_hue = 2994 has_sharpness = has_hflip = has_lighting = false; 2995 switch (sd->model) { 2996 case CIT_MODEL0: 2997 has_contrast = has_hflip = true; 2998 break; 2999 case CIT_MODEL1: 3000 has_brightness = has_contrast = 3001 has_sharpness = has_lighting = true; 3002 break; 3003 case CIT_MODEL2: 3004 has_brightness = has_hue = has_lighting = true; 3005 break; 3006 case CIT_MODEL3: 3007 has_brightness = has_contrast = has_sharpness = true; 3008 break; 3009 case CIT_MODEL4: 3010 has_brightness = has_hue = true; 3011 break; 3012 case CIT_IBM_NETCAM_PRO: 3013 has_brightness = has_hue = 3014 has_sharpness = has_hflip = has_lighting = true; 3015 break; 3016 } 3017 gspca_dev->vdev.ctrl_handler = hdl; 3018 v4l2_ctrl_handler_init(hdl, 5); 3019 if (has_brightness) 3020 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 3021 V4L2_CID_BRIGHTNESS, 0, 63, 1, 32); 3022 if (has_contrast) 3023 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 3024 V4L2_CID_CONTRAST, 0, 20, 1, 10); 3025 if (has_hue) 3026 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 3027 V4L2_CID_HUE, 0, 127, 1, 63); 3028 if (has_sharpness) 3029 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 3030 V4L2_CID_SHARPNESS, 0, 6, 1, 3); 3031 if (has_lighting) 3032 sd->lighting = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 3033 V4L2_CID_BACKLIGHT_COMPENSATION, 0, 2, 1, 1); 3034 if (has_hflip) 3035 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 3036 V4L2_CID_HFLIP, 0, 1, 1, 0); 3037 3038 if (hdl->error) { 3039 pr_err("Could not initialize controls\n"); 3040 return hdl->error; 3041 } 3042 return 0; 3043 } 3044 3045 /* sub-driver description */ 3046 static const struct sd_desc sd_desc = { 3047 .name = MODULE_NAME, 3048 .config = sd_config, 3049 .init = sd_init, 3050 .init_controls = sd_init_controls, 3051 .start = sd_start, 3052 .stopN = sd_stopN, 3053 .stop0 = sd_stop0, 3054 .pkt_scan = sd_pkt_scan, 3055 #if IS_ENABLED(CONFIG_INPUT) 3056 .dq_callback = cit_check_button, 3057 .other_input = 1, 3058 #endif 3059 }; 3060 3061 static const struct sd_desc sd_desc_isoc_nego = { 3062 .name = MODULE_NAME, 3063 .config = sd_config, 3064 .init = sd_init, 3065 .init_controls = sd_init_controls, 3066 .start = sd_start, 3067 .isoc_init = sd_isoc_init, 3068 .isoc_nego = sd_isoc_nego, 3069 .stopN = sd_stopN, 3070 .stop0 = sd_stop0, 3071 .pkt_scan = sd_pkt_scan, 3072 #if IS_ENABLED(CONFIG_INPUT) 3073 .dq_callback = cit_check_button, 3074 .other_input = 1, 3075 #endif 3076 }; 3077 3078 /* -- module initialisation -- */ 3079 static const struct usb_device_id device_table[] = { 3080 { USB_DEVICE_VER(0x0545, 0x8080, 0x0001, 0x0001), .driver_info = CIT_MODEL0 }, 3081 { USB_DEVICE_VER(0x0545, 0x8080, 0x0002, 0x0002), .driver_info = CIT_MODEL1 }, 3082 { USB_DEVICE_VER(0x0545, 0x8080, 0x030a, 0x030a), .driver_info = CIT_MODEL2 }, 3083 { USB_DEVICE_VER(0x0545, 0x8080, 0x0301, 0x0301), .driver_info = CIT_MODEL3 }, 3084 { USB_DEVICE_VER(0x0545, 0x8002, 0x030a, 0x030a), .driver_info = CIT_MODEL4 }, 3085 { USB_DEVICE_VER(0x0545, 0x800c, 0x030a, 0x030a), .driver_info = CIT_MODEL2 }, 3086 { USB_DEVICE_VER(0x0545, 0x800d, 0x030a, 0x030a), .driver_info = CIT_MODEL4 }, 3087 {} 3088 }; 3089 MODULE_DEVICE_TABLE(usb, device_table); 3090 3091 /* -- device connect -- */ 3092 static int sd_probe(struct usb_interface *intf, 3093 const struct usb_device_id *id) 3094 { 3095 const struct sd_desc *desc = &sd_desc; 3096 3097 switch (id->driver_info) { 3098 case CIT_MODEL0: 3099 case CIT_MODEL1: 3100 if (intf->cur_altsetting->desc.bInterfaceNumber != 2) 3101 return -ENODEV; 3102 break; 3103 case CIT_MODEL2: 3104 case CIT_MODEL4: 3105 if (intf->cur_altsetting->desc.bInterfaceNumber != 0) 3106 return -ENODEV; 3107 break; 3108 case CIT_MODEL3: 3109 if (intf->cur_altsetting->desc.bInterfaceNumber != 0) 3110 return -ENODEV; 3111 /* FIXME this likely applies to all model3 cams and probably 3112 to other models too. */ 3113 if (ibm_netcam_pro) 3114 desc = &sd_desc_isoc_nego; 3115 break; 3116 } 3117 3118 return gspca_dev_probe2(intf, id, desc, sizeof(struct sd), THIS_MODULE); 3119 } 3120 3121 static struct usb_driver sd_driver = { 3122 .name = MODULE_NAME, 3123 .id_table = device_table, 3124 .probe = sd_probe, 3125 .disconnect = gspca_disconnect, 3126 #ifdef CONFIG_PM 3127 .suspend = gspca_suspend, 3128 .resume = gspca_resume, 3129 .reset_resume = gspca_resume, 3130 #endif 3131 }; 3132 3133 module_usb_driver(sd_driver); 3134