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