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