projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] b2c2: fix driver's build due to the lack of pci DMA code
[linux-2.6-block.git] / drivers / media / video / gspca / sonixb.c
CommitLineData
6a7eba24
JFM		 1/*
2 * sonix sn9c102 (bayer) library
6a7eba24 3 *
75b79ffc
JFM		 4 * Copyright (C) 2009-2011 Jean-François Moine <http://moinejf.free.fr>
5 * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
6 * Add Pas106 Stefano Mozzi (C) 2004
6a7eba24
JFM		 7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
93627736
HG		 23/* Some documentation on known sonixb registers:
24
25Reg Use
0a76cb8c 26sn9c101 / sn9c102:
93627736
HG		 270x10 high nibble red gain low nibble blue gain
280x11 low nibble green gain
0a76cb8c
HG		 29sn9c103:
300x05 red gain 0-127
310x06 blue gain 0-127
320x07 green gain 0-127
33all:
340x08-0x0f i2c / 3wire registers
93627736
HG		 350x12 hstart
360x13 vstart
370x15 hsize (hsize = register-value * 16)
380x16 vsize (vsize = register-value * 16)
390x17 bit 0 toggle compression quality (according to sn9c102 driver)
400x18 bit 7 enables compression, bit 4-5 set image down scaling:
41 00 scale 1, 01 scale 1/2, 10, scale 1/4
420x19 high-nibble is sensor clock divider, changes exposure on sensors which
43 use a clock generated by the bridge. Some sensors have their own clock.
440x1c auto_exposure area (for avg_lum) startx (startx = register-value * 32)
450x1d auto_exposure area (for avg_lum) starty (starty = register-value * 32)
460x1e auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
470x1f auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
48*/
49
6a7eba24
JFM		 50#define MODULE_NAME "sonixb"
51
f65e93d6 52#include <linux/input.h>
6a7eba24
JFM		 53#include "gspca.h"
54
75b79ffc 55MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
6a7eba24
JFM		 56MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
57MODULE_LICENSE("GPL");
58
59/* specific webcam descriptor */
60struct sd {
61 struct gspca_dev gspca_dev; /* !! must be the first item */
f51a8caa 62
9153ac3b
HG		 63 struct v4l2_ctrl *brightness;
64 struct v4l2_ctrl *plfreq;
f51a8caa 65
dcef3237 66 atomic_t avg_lum;
bf2a2202 67 int prev_avg_lum;
9153ac3b 68 int exposure_knee;
2b3e284a
HG		 69 int header_read;
70 u8 header[12]; /* Header without sof marker */
dcef3237 71
dcef3237 72 unsigned char autogain_ignore_frames;
6af492e5 73 unsigned char frames_to_drop;
6a7eba24 74
f45f06b6
HG		 75 __u8 bridge; /* Type of bridge */
76#define BRIDGE_101 0
77#define BRIDGE_102 0 /* We make no difference between 101 and 102 */
78#define BRIDGE_103 1
79
80 __u8 sensor; /* Type of image sensor chip */
00765f16
HG		 81#define SENSOR_HV7131D 0
82#define SENSOR_HV7131R 1
83#define SENSOR_OV6650 2
84#define SENSOR_OV7630 3
85#define SENSOR_PAS106 4
86#define SENSOR_PAS202 5
87#define SENSOR_TAS5110C 6
88#define SENSOR_TAS5110D 7
89#define SENSOR_TAS5130CXX 8
6af492e5 90 __u8 reg11;
6a7eba24
JFM		 91};
92
f45f06b6
HG		 93typedef const __u8 sensor_init_t[8];
94
95struct sensor_data {
0a76cb8c 96 const __u8 *bridge_init;
f45f06b6
HG		 97 sensor_init_t *sensor_init;
98 int sensor_init_size;
f45f06b6 99 int flags;
f45f06b6
HG		 100 __u8 sensor_addr;
101};
102
103/* sensor_data flags */
9153ac3b 104#define F_SIF 0x01 /* sif or vga */
c437d657
HG		 105
106/* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
107#define MODE_RAW 0x10 /* raw bayer mode */
93627736 108#define MODE_REDUCED_SIF 0x20 /* vga mode (320x240 / 160x120) on sif cam */
f45f06b6 109
6a7eba24
JFM		 110#define COMP 0xc7 /* 0x87 //0x07 */
111#define COMP1 0xc9 /* 0x89 //0x09 */
112
113#define MCK_INIT 0x63
114#define MCK_INIT1 0x20 /*fixme: Bayer - 0x50 for JPEG ??*/
115
116#define SYS_CLK 0x04
117
9153ac3b 118#define SENS(bridge, sensor, _flags, _sensor_addr) \
f45f06b6 119{ \
0a76cb8c 120 .bridge_init = bridge, \
f45f06b6
HG		 121 .sensor_init = sensor, \
122 .sensor_init_size = sizeof(sensor), \
9153ac3b 123 .flags = _flags, .sensor_addr = _sensor_addr \
f45f06b6
HG		 124}
125
dcef3237 126/* We calculate the autogain at the end of the transfer of a frame, at this
26984b09
HG		 127 moment a frame with the old settings is being captured and transmitted. So
128 if we adjust the gain or exposure we must ignore atleast the next frame for
129 the new settings to come into effect before doing any other adjustments. */
130#define AUTOGAIN_IGNORE_FRAMES 1
dcef3237 131
cc611b8a 132static const struct v4l2_pix_format vga_mode[] = {
c437d657
HG		 133 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
134 .bytesperline = 160,
2389b360 135 .sizeimage = 160 * 120,
c437d657
HG		 136 .colorspace = V4L2_COLORSPACE_SRGB,
137 .priv = 2 | MODE_RAW},
c2446b3e
JFM		 138 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
139 .bytesperline = 160,
5c51518d 140 .sizeimage = 160 * 120 * 5 / 4,
c2446b3e
JFM		 141 .colorspace = V4L2_COLORSPACE_SRGB,
142 .priv = 2},
143 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
144 .bytesperline = 320,
5c51518d 145 .sizeimage = 320 * 240 * 5 / 4,
c2446b3e
JFM		 146 .colorspace = V4L2_COLORSPACE_SRGB,
147 .priv = 1},
148 {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
149 .bytesperline = 640,
5c51518d 150 .sizeimage = 640 * 480 * 5 / 4,
c2446b3e
JFM		 151 .colorspace = V4L2_COLORSPACE_SRGB,
152 .priv = 0},
6a7eba24 153};
cc611b8a 154static const struct v4l2_pix_format sif_mode[] = {
93627736
HG		 155 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
156 .bytesperline = 160,
157 .sizeimage = 160 * 120,
158 .colorspace = V4L2_COLORSPACE_SRGB,
159 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
160 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
161 .bytesperline = 160,
162 .sizeimage = 160 * 120 * 5 / 4,
163 .colorspace = V4L2_COLORSPACE_SRGB,
164 .priv = 1 | MODE_REDUCED_SIF},
c437d657
HG		 165 {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
166 .bytesperline = 176,
2389b360 167 .sizeimage = 176 * 144,
c437d657
HG		 168 .colorspace = V4L2_COLORSPACE_SRGB,
169 .priv = 1 | MODE_RAW},
c2446b3e
JFM		 170 {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
171 .bytesperline = 176,
5c51518d 172 .sizeimage = 176 * 144 * 5 / 4,
c2446b3e
JFM		 173 .colorspace = V4L2_COLORSPACE_SRGB,
174 .priv = 1},
93627736
HG		 175 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
176 .bytesperline = 320,
177 .sizeimage = 320 * 240 * 5 / 4,
178 .colorspace = V4L2_COLORSPACE_SRGB,
179 .priv = 0 | MODE_REDUCED_SIF},
c2446b3e
JFM		 180 {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
181 .bytesperline = 352,
5c51518d 182 .sizeimage = 352 * 288 * 5 / 4,
c2446b3e
JFM		 183 .colorspace = V4L2_COLORSPACE_SRGB,
184 .priv = 0},
6a7eba24
JFM		 185};
186
00765f16
HG		 187static const __u8 initHv7131d[] = {
188 0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
189 0x00, 0x00,
190 0x00, 0x00, 0x00, 0x02, 0x02, 0x00,
191 0x28, 0x1e, 0x60, 0x8e, 0x42,
00765f16
HG		 192};
193static const __u8 hv7131d_sensor_init[][8] = {
194 {0xa0, 0x11, 0x01, 0x04, 0x00, 0x00, 0x00, 0x17},
195 {0xa0, 0x11, 0x02, 0x00, 0x00, 0x00, 0x00, 0x17},
196 {0xa0, 0x11, 0x28, 0x00, 0x00, 0x00, 0x00, 0x17},
197 {0xa0, 0x11, 0x30, 0x30, 0x00, 0x00, 0x00, 0x17}, /* reset level */
198 {0xa0, 0x11, 0x34, 0x02, 0x00, 0x00, 0x00, 0x17}, /* pixel bias volt */
199};
200
201static const __u8 initHv7131r[] = {
6a7eba24
JFM		 202 0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
203 0x00, 0x00,
c437d657 204 0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
6a7eba24 205 0x28, 0x1e, 0x60, 0x8a, 0x20,
6a7eba24 206};
00765f16 207static const __u8 hv7131r_sensor_init[][8] = {
6a7eba24
JFM		 208 {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
209 {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
210 {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
211 {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
212 {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
213};
214static const __u8 initOv6650[] = {
215 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
216 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
c437d657 217 0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
0a76cb8c 218 0x10,
6a7eba24 219};
780e3121 220static const __u8 ov6650_sensor_init[][8] = {
af901ca1 221 /* Bright, contrast, etc are set through SCBB interface.
780e3121 222 * AVCAP on win2 do not send any data on this controls. */
6a7eba24 223 /* Anyway, some registers appears to alter bright and constrat */
dcef3237
HG		 224
225 /* Reset sensor */
6a7eba24 226 {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
dcef3237 227 /* Set clock register 0x11 low nibble is clock divider */
6a7eba24 228 {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
dcef3237 229 /* Next some unknown stuff */
6a7eba24
JFM		 230 {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
231/* {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
232 * THIS SET GREEN SCREEN
233 * (pixels could be innverted in decode kind of "brg",
234 * but blue wont be there. Avoid this data ... */
235 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
236 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
1d00d6c1 237 {0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10},
722103e3
HG		 238 /* Enable rgb brightness control */
239 {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
240 /* HDG: Note windows uses the line below, which sets both register 0x60
241 and 0x61 I believe these registers of the ov6650 are identical as
242 those of the ov7630, because if this is true the windows settings
243 add a bit additional red gain and a lot additional blue gain, which
244 matches my findings that the windows settings make blue much too
245 blue and red a little too red.
246 {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
dcef3237 247 /* Some more unknown stuff */
6a7eba24
JFM		 248 {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
249 {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
6a7eba24 250};
dcef3237 251
6a7eba24
JFM		 252static const __u8 initOv7630[] = {
253 0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
254 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
c437d657 255 0x00, 0x01, 0x01, 0x0a, /* r11 .. r14 */
6a7eba24 256 0x28, 0x1e, /* H & V sizes r15 .. r16 */
51fc8e3b 257 0x68, 0x8f, MCK_INIT1, /* r17 .. r19 */
6a7eba24 258};
6af492e5 259static const __u8 ov7630_sensor_init[][8] = {
6a7eba24
JFM		 260 {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
261 {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
262/* {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10}, jfm */
4c775902 263 {0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10}, /* jfm */
6a7eba24
JFM		 264 {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
265 {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
266 {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
267 {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
268 {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
269 {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
270 {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
794af52a
AZ		 271 {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
272/* {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10}, * jfm */
6a7eba24
JFM		 273 {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
274 {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
275 {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
276 {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
277 {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
278 {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
279};
6a7eba24
JFM		 280
281static const __u8 initPas106[] = {
282 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
283 0x00, 0x00,
c437d657 284 0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
f45f06b6 285 0x16, 0x12, 0x24, COMP1, MCK_INIT1,
6a7eba24
JFM		 286};
287/* compression 0x86 mckinit1 0x2b */
421763e7
HG		 288
289/* "Known" PAS106B registers:
290 0x02 clock divider
291 0x03 Variable framerate bits 4-11
292 0x04 Var framerate bits 0-3, one must leave the 4 msb's at 0 !!
293 The variable framerate control must never be set lower then 300,
294 which sets the framerate at 90 / reg02, otherwise vsync is lost.
295 0x05 Shutter Time Line Offset, this can be used as an exposure control:
296 0 = use full frame time, 255 = no exposure at all
297 Note this may never be larger then "var-framerate control" / 2 - 2.
298 When var-framerate control is < 514, no exposure is reached at the max
299 allowed value for the framerate control value, rather then at 255.
300 0x06 Shutter Time Pixel Offset, like reg05 this influences exposure, but
301 only a very little bit, leave at 0xcd
302 0x07 offset sign bit (bit0 1 > negative offset)
303 0x08 offset
304 0x09 Blue Gain
305 0x0a Green1 Gain
306 0x0b Green2 Gain
307 0x0c Red Gain
308 0x0e Global gain
309 0x13 Write 1 to commit settings to sensor
310*/
311
f45f06b6
HG		 312static const __u8 pas106_sensor_init[][8] = {
313 /* Pixel Clock Divider 6 */
314 { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
315 /* Frame Time MSB (also seen as 0x12) */
316 { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
317 /* Frame Time LSB (also seen as 0x05) */
318 { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
319 /* Shutter Time Line Offset (also seen as 0x6d) */
320 { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
321 /* Shutter Time Pixel Offset (also seen as 0xb1) */
322 { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
323 /* Black Level Subtract Sign (also seen 0x00) */
324 { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
325 /* Black Level Subtract Level (also seen 0x01) */
326 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
327 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
328 /* Color Gain B Pixel 5 a */
329 { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
330 /* Color Gain G1 Pixel 1 5 */
331 { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
332 /* Color Gain G2 Pixel 1 0 5 */
333 { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
334 /* Color Gain R Pixel 3 1 */
335 { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
336 /* Color GainH Pixel */
337 { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
338 /* Global Gain */
339 { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
340 /* Contrast */
341 { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
342 /* H&V synchro polarity */
343 { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
344 /* ?default */
345 { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
346 /* DAC scale */
347 { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
348 /* ?default */
349 { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
350 /* Validate Settings */
351 { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
6a7eba24 352};
f45f06b6 353
6a7eba24
JFM		 354static const __u8 initPas202[] = {
355 0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
356 0x00, 0x00,
c437d657 357 0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
82e839c9 358 0x28, 0x1e, 0x20, 0x89, 0x20,
6a7eba24 359};
82e839c9
HG		 360
361/* "Known" PAS202BCB registers:
362 0x02 clock divider
363 0x04 Variable framerate bits 6-11 (*)
364 0x05 Var framerate bits 0-5, one must leave the 2 msb's at 0 !!
365 0x07 Blue Gain
366 0x08 Green Gain
367 0x09 Red Gain
368 0x0b offset sign bit (bit0 1 > negative offset)
369 0x0c offset
370 0x0e Unknown image is slightly brighter when bit 0 is 0, if reg0f is 0 too,
371 leave at 1 otherwise we get a jump in our exposure control
372 0x0f Exposure 0-255, 0 = use full frame time, 255 = no exposure at all
373 0x10 Master gain 0 - 31
374 0x11 write 1 to apply changes
375 (*) The variable framerate control must never be set lower then 500
376 which sets the framerate at 30 / reg02, otherwise vsync is lost.
377*/
6a7eba24 378static const __u8 pas202_sensor_init[][8] = {
82e839c9
HG		 379 /* Set the clock divider to 4 -> 30 / 4 = 7.5 fps, we would like
380 to set it lower, but for some reason the bridge starts missing
381 vsync's then */
382 {0xa0, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x10},
6a7eba24
JFM		 383 {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
384 {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
1d00d6c1 385 {0xd0, 0x40, 0x0c, 0x00, 0x0c, 0x01, 0x32, 0x10},
6a7eba24
JFM		 386 {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
387 {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
388 {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
389 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
390 {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
391 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
6a7eba24
JFM		 392};
393
b10af3f7 394static const __u8 initTas5110c[] = {
6a7eba24
JFM		 395 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
396 0x00, 0x00,
4efcfa0a 397 0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
6a7eba24 398 0x16, 0x12, 0x60, 0x86, 0x2b,
6a7eba24 399};
b10af3f7
HG		 400/* Same as above, except a different hstart */
401static const __u8 initTas5110d[] = {
402 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
403 0x00, 0x00,
4efcfa0a 404 0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
b10af3f7 405 0x16, 0x12, 0x60, 0x86, 0x2b,
b10af3f7 406};
0d0d7ef7
HG		 407/* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */
408static const __u8 tas5110c_sensor_init[][8] = {
6a7eba24
JFM		 409 {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
410 {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
0d0d7ef7
HG		 411};
412/* Known TAS5110D registers
413 * reg02: gain, bit order reversed!! 0 == max gain, 255 == min gain
414 * reg03: bit3: vflip, bit4: ~hflip, bit7: ~gainboost (~ == inverted)
415 * Note: writing reg03 seems to only work when written together with 02
416 */
417static const __u8 tas5110d_sensor_init[][8] = {
418 {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */
6a7eba24
JFM		 419};
420
421static const __u8 initTas5130[] = {
422 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
423 0x00, 0x00,
4efcfa0a 424 0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
6a7eba24 425 0x28, 0x1e, 0x60, COMP, MCK_INIT,
6a7eba24
JFM		 426};
427static const __u8 tas5130_sensor_init[][8] = {
780e3121 428/* {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
6a7eba24
JFM		 429 * shutter 0x47 short exposure? */
430 {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
431 /* shutter 0x01 long exposure */
432 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
433};
434
75b79ffc 435static const struct sensor_data sensor_data[] = {
9153ac3b
HG		 436 SENS(initHv7131d, hv7131d_sensor_init, 0, 0),
437 SENS(initHv7131r, hv7131r_sensor_init, 0, 0),
438 SENS(initOv6650, ov6650_sensor_init, F_SIF, 0x60),
439 SENS(initOv7630, ov7630_sensor_init, 0, 0x21),
440 SENS(initPas106, pas106_sensor_init, F_SIF, 0),
441 SENS(initPas202, pas202_sensor_init, 0, 0),
442 SENS(initTas5110c, tas5110c_sensor_init, F_SIF, 0),
443 SENS(initTas5110d, tas5110d_sensor_init, F_SIF, 0),
444 SENS(initTas5130, tas5130_sensor_init, 0, 0),
f45f06b6
HG		 445};
446
739570bb
JFM		 447/* get one byte in gspca_dev->usb_buf */
448static void reg_r(struct gspca_dev *gspca_dev,
449 __u16 value)
6a7eba24 450{
4848ea77
HG		 451 int res;
452
453 if (gspca_dev->usb_err < 0)
454 return;
455
456 res = usb_control_msg(gspca_dev->dev,
739570bb 457 usb_rcvctrlpipe(gspca_dev->dev, 0),
6a7eba24
JFM		 458 0, /* request */
459 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
460 value,
461 0, /* index */
739570bb 462 gspca_dev->usb_buf, 1,
6a7eba24 463 500);
4848ea77
HG		 464
465 if (res < 0) {
466 dev_err(gspca_dev->v4l2_dev.dev,
467 "Error reading register %02x: %d\n", value, res);
468 gspca_dev->usb_err = res;
469 }
6a7eba24
JFM		 470}
471
739570bb
JFM		 472static void reg_w(struct gspca_dev *gspca_dev,
473 __u16 value,
474 const __u8 *buffer,
475 int len)
6a7eba24 476{
4848ea77
HG		 477 int res;
478
479 if (gspca_dev->usb_err < 0)
0d2a722d 480 return;
4848ea77 481
739570bb 482 memcpy(gspca_dev->usb_buf, buffer, len);
4848ea77 483 res = usb_control_msg(gspca_dev->dev,
739570bb
JFM		 484 usb_sndctrlpipe(gspca_dev->dev, 0),
485 0x08, /* request */
486 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
487 value,
488 0, /* index */
489 gspca_dev->usb_buf, len,
490 500);
4848ea77
HG		 491
492 if (res < 0) {
493 dev_err(gspca_dev->v4l2_dev.dev,
494 "Error writing register %02x: %d\n", value, res);
495 gspca_dev->usb_err = res;
496 }
739570bb
JFM		 497}
498
4848ea77 499static void i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
6a7eba24
JFM		 500{
501 int retry = 60;
6a7eba24 502
4848ea77
HG		 503 if (gspca_dev->usb_err < 0)
504 return;
505
6a7eba24 506 /* is i2c ready */
739570bb 507 reg_w(gspca_dev, 0x08, buffer, 8);
6a7eba24 508 while (retry--) {
4848ea77
HG		 509 if (gspca_dev->usb_err < 0)
510 return;
6a7eba24 511 msleep(10);
739570bb 512 reg_r(gspca_dev, 0x08);
b7474cf9 513 if (gspca_dev->usb_buf[0] & 0x04) {
4848ea77
HG		 514 if (gspca_dev->usb_buf[0] & 0x08) {
515 dev_err(gspca_dev->v4l2_dev.dev,
516 "i2c write error\n");
517 gspca_dev->usb_err = -EIO;
518 }
519 return;
b7474cf9 520 }
6a7eba24 521 }
4848ea77
HG		 522
523 dev_err(gspca_dev->v4l2_dev.dev, "i2c write timeout\n");
524 gspca_dev->usb_err = -EIO;
6a7eba24
JFM		 525}
526
739570bb 527static void i2c_w_vector(struct gspca_dev *gspca_dev,
6a7eba24
JFM		 528 const __u8 buffer[][8], int len)
529{
530 for (;;) {
4848ea77
HG		 531 if (gspca_dev->usb_err < 0)
532 return;
739570bb 533 reg_w(gspca_dev, 0x08, *buffer, 8);
6a7eba24
JFM		 534 len -= 8;
535 if (len <= 0)
536 break;
537 buffer++;
538 }
539}
540
541static void setbrightness(struct gspca_dev *gspca_dev)
542{
543 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24
JFM		 544
545 switch (sd->sensor) {
a975a527 546 case SENSOR_OV6650:
6a7eba24
JFM		 547 case SENSOR_OV7630: {
548 __u8 i2cOV[] =
a975a527 549 {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
6a7eba24
JFM		 550
551 /* change reg 0x06 */
f45f06b6 552 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
9153ac3b 553 i2cOV[3] = sd->brightness->val;
4848ea77 554 i2c_w(gspca_dev, i2cOV);
6a7eba24 555 break;
4848ea77 556 }
421763e7 557 case SENSOR_PAS106:
6a7eba24 558 case SENSOR_PAS202: {
82e839c9
HG		 559 __u8 i2cpbright[] =
560 {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
421763e7 561 __u8 i2cpdoit[] =
82e839c9
HG		 562 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
563
421763e7
HG		 564 /* PAS106 uses reg 7 and 8 instead of b and c */
565 if (sd->sensor == SENSOR_PAS106) {
566 i2cpbright[2] = 7;
567 i2cpdoit[2] = 0x13;
568 }
569
9153ac3b 570 if (sd->brightness->val < 127) {
82e839c9
HG		 571 /* change reg 0x0b, signreg */
572 i2cpbright[3] = 0x01;
573 /* set reg 0x0c, offset */
9153ac3b 574 i2cpbright[4] = 127 - sd->brightness->val;
82e839c9 575 } else
9153ac3b 576 i2cpbright[4] = sd->brightness->val - 127;
82e839c9 577
4848ea77
HG		 578 i2c_w(gspca_dev, i2cpbright);
579 i2c_w(gspca_dev, i2cpdoit);
580 break;
581 }
582 default:
6a7eba24 583 break;
6a7eba24 584 }
6a7eba24 585}
dcef3237 586
9153ac3b 587static void setgain(struct gspca_dev *gspca_dev)
dcef3237
HG		 588{
589 struct sd *sd = (struct sd *) gspca_dev;
9153ac3b 590 u8 gain = gspca_dev->gain->val;
dcef3237
HG		 591
592 switch (sd->sensor) {
00765f16
HG		 593 case SENSOR_HV7131D: {
594 __u8 i2c[] =
595 {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
596
9153ac3b
HG		 597 i2c[3] = 0x3f - gain;
598 i2c[4] = 0x3f - gain;
599 i2c[5] = 0x3f - gain;
dcef3237 600
4848ea77 601 i2c_w(gspca_dev, i2c);
00765f16 602 break;
4848ea77 603 }
4e17cd2e
HG		 604 case SENSOR_TAS5110C:
605 case SENSOR_TAS5130CXX: {
dcef3237
HG		 606 __u8 i2c[] =
607 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
608
a975a527 609 i2c[4] = 255 - gain;
4848ea77 610 i2c_w(gspca_dev, i2c);
51fc8e3b 611 break;
4848ea77 612 }
0d0d7ef7
HG		 613 case SENSOR_TAS5110D: {
614 __u8 i2c[] = {
615 0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
616 gain = 255 - gain;
617 /* The bits in the register are the wrong way around!! */
618 i2c[3] |= (gain & 0x80) >> 7;
619 i2c[3] |= (gain & 0x40) >> 5;
620 i2c[3] |= (gain & 0x20) >> 3;
621 i2c[3] |= (gain & 0x10) >> 1;
622 i2c[3] |= (gain & 0x08) << 1;
623 i2c[3] |= (gain & 0x04) << 3;
624 i2c[3] |= (gain & 0x02) << 5;
625 i2c[3] |= (gain & 0x01) << 7;
4848ea77 626 i2c_w(gspca_dev, i2c);
0d0d7ef7 627 break;
4848ea77 628 }
a975a527 629 case SENSOR_OV6650:
6af492e5 630 case SENSOR_OV7630: {
a975a527 631 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
794af52a 632
8b3a19b1
HG		 633 /*
634 * The ov7630's gain is weird, at 32 the gain drops to the
635 * same level as at 16, so skip 32-47 (of the 0-63 scale).
636 */
637 if (sd->sensor == SENSOR_OV7630 && gain >= 32)
638 gain += 16;
639
f45f06b6 640 i2c[1] = sensor_data[sd->sensor].sensor_addr;
9153ac3b 641 i2c[3] = gain;
4848ea77 642 i2c_w(gspca_dev, i2c);
794af52a 643 break;
4848ea77 644 }
421763e7 645 case SENSOR_PAS106:
82e839c9
HG		 646 case SENSOR_PAS202: {
647 __u8 i2cpgain[] =
421763e7 648 {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
82e839c9
HG		 649 __u8 i2cpcolorgain[] =
650 {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
421763e7
HG		 651 __u8 i2cpdoit[] =
652 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
653
654 /* PAS106 uses different regs (and has split green gains) */
655 if (sd->sensor == SENSOR_PAS106) {
656 i2cpgain[2] = 0x0e;
657 i2cpcolorgain[0] = 0xd0;
658 i2cpcolorgain[2] = 0x09;
659 i2cpdoit[2] = 0x13;
660 }
82e839c9 661
9153ac3b
HG		 662 i2cpgain[3] = gain;
663 i2cpcolorgain[3] = gain >> 1;
664 i2cpcolorgain[4] = gain >> 1;
665 i2cpcolorgain[5] = gain >> 1;
666 i2cpcolorgain[6] = gain >> 1;
82e839c9 667
4848ea77
HG		 668 i2c_w(gspca_dev, i2cpgain);
669 i2c_w(gspca_dev, i2cpcolorgain);
670 i2c_w(gspca_dev, i2cpdoit);
671 break;
672 }
673 default:
9153ac3b
HG		 674 if (sd->bridge == BRIDGE_103) {
675 u8 buf[3] = { gain, gain, gain }; /* R, G, B */
676 reg_w(gspca_dev, 0x05, buf, 3);
677 } else {
678 u8 buf[2];
679 buf[0] = gain << 4 | gain; /* Red and blue */
680 buf[1] = gain; /* Green */
681 reg_w(gspca_dev, 0x10, buf, 2);
682 }
0a76cb8c 683 }
dcef3237
HG		 684}
685
686static void setexposure(struct gspca_dev *gspca_dev)
687{
688 struct sd *sd = (struct sd *) gspca_dev;
dcef3237
HG		 689
690 switch (sd->sensor) {
00765f16
HG		 691 case SENSOR_HV7131D: {
692 /* Note the datasheet wrongly says line mode exposure uses reg
693 0x26 and 0x27, testing has shown 0x25 + 0x26 */
694 __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
9153ac3b 695 u16 reg = gspca_dev->exposure->val;
f51a8caa 696
00765f16
HG		 697 i2c[3] = reg >> 8;
698 i2c[4] = reg & 0xff;
4848ea77 699 i2c_w(gspca_dev, i2c);
00765f16 700 break;
4848ea77 701 }
b10af3f7
HG		 702 case SENSOR_TAS5110C:
703 case SENSOR_TAS5110D: {
dcef3237
HG		 704 /* register 19's high nibble contains the sn9c10x clock divider
705 The high nibble configures the no fps according to the
706 formula: 60 / high_nibble. With a maximum of 30 fps */
9153ac3b 707 u8 reg = gspca_dev->exposure->val;
f51a8caa 708
dcef3237 709 reg = (reg << 4) | 0x0b;
739570bb 710 reg_w(gspca_dev, 0x19, &reg, 1);
51fc8e3b 711 break;
4848ea77 712 }
a975a527 713 case SENSOR_OV6650:
6af492e5 714 case SENSOR_OV7630: {
a975a527
HG		 715 /* The ov6650 / ov7630 have 2 registers which both influence
716 exposure, register 11, whose low nibble sets the nr off fps
f4d52025
HG		 717 according to: fps = 30 / (low_nibble + 1)
718
719 The fps configures the maximum exposure setting, but it is
720 possible to use less exposure then what the fps maximum
721 allows by setting register 10. register 10 configures the
722 actual exposure as quotient of the full exposure, with 0
25985edc 723 being no exposure at all (not very useful) and reg10_max
f4d52025
HG		 724 being max exposure possible at that framerate.
725
726 The code maps our 0 - 510 ms exposure ctrl to these 2
727 registers, trying to keep fps as high as possible.
728 */
6af492e5
HG		 729 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
730 int reg10, reg11, reg10_max;
731
66f35821
HG		 732 /* ov6645 datasheet says reg10_max is 9a, but that uses
733 tline * 2 * reg10 as formula for calculating texpo, the
734 ov6650 probably uses the same formula as the 7730 which uses
735 tline * 4 * reg10, which explains why the reg10max we've
736 found experimentally for the ov6650 is exactly half that of
a975a527 737 the ov6645. The ov7630 datasheet says the max is 0x41. */
6af492e5
HG		 738 if (sd->sensor == SENSOR_OV6650) {
739 reg10_max = 0x4d;
740 i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
741 } else
742 reg10_max = 0x41;
f4d52025 743
9153ac3b 744 reg11 = (15 * gspca_dev->exposure->val + 999) / 1000;
794af52a
AZ		 745 if (reg11 < 1)
746 reg11 = 1;
747 else if (reg11 > 16)
748 reg11 = 16;
749
10bb7530
HG		 750 /* In 640x480, if the reg11 has less than 4, the image is
751 unstable (the bridge goes into a higher compression mode
752 which we have not reverse engineered yet). */
753 if (gspca_dev->width == 640 && reg11 < 4)
754 reg11 = 4;
e2ad2a54 755
794af52a 756 /* frame exposure time in ms = 1000 * reg11 / 30 ->
9153ac3b 757 reg10 = (gspca_dev->exposure->val / 2) * reg10_max
f51a8caa 758 / (1000 * reg11 / 30) */
9153ac3b 759 reg10 = (gspca_dev->exposure->val * 15 * reg10_max)
f51a8caa 760 / (1000 * reg11);
794af52a 761
a975a527
HG		 762 /* Don't allow this to get below 10 when using autogain, the
763 steps become very large (relatively) when below 10 causing
764 the image to oscilate from much too dark, to much too bright
765 and back again. */
9153ac3b 766 if (gspca_dev->autogain->val && reg10 < 10)
a975a527 767 reg10 = 10;
f4d52025
HG		 768 else if (reg10 > reg10_max)
769 reg10 = reg10_max;
770
771 /* Write reg 10 and reg11 low nibble */
f45f06b6 772 i2c[1] = sensor_data[sd->sensor].sensor_addr;
f4d52025
HG		 773 i2c[3] = reg10;
774 i2c[4] |= reg11 - 1;
6af492e5
HG		 775
776 /* If register 11 didn't change, don't change it */
780e3121 777 if (sd->reg11 == reg11)
6af492e5
HG		 778 i2c[0] = 0xa0;
779
4848ea77
HG		 780 i2c_w(gspca_dev, i2c);
781 if (gspca_dev->usb_err == 0)
6af492e5 782 sd->reg11 = reg11;
82e839c9 783 break;
4848ea77 784 }
82e839c9
HG		 785 case SENSOR_PAS202: {
786 __u8 i2cpframerate[] =
787 {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
788 __u8 i2cpexpo[] =
789 {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
790 const __u8 i2cpdoit[] =
791 {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
792 int framerate_ctrl;
793
794 /* The exposure knee for the autogain algorithm is 200
795 (100 ms / 10 fps on other sensors), for values below this
796 use the control for setting the partial frame expose time,
797 above that use variable framerate. This way we run at max
798 framerate (640x480@7.5 fps, 320x240@10fps) until the knee
799 is reached. Using the variable framerate control above 200
800 is better then playing around with both clockdiv + partial
801 frame exposure times (like we are doing with the ov chips),
802 as that sometimes leads to jumps in the exposure control,
803 which are bad for auto exposure. */
9153ac3b
HG		 804 if (gspca_dev->exposure->val < 200) {
805 i2cpexpo[3] = 255 - (gspca_dev->exposure->val * 255)
f51a8caa 806 / 200;
82e839c9
HG		 807 framerate_ctrl = 500;
808 } else {
809 /* The PAS202's exposure control goes from 0 - 4095,
810 but anything below 500 causes vsync issues, so scale
811 our 200-1023 to 500-4095 */
9153ac3b 812 framerate_ctrl = (gspca_dev->exposure->val - 200)
f51a8caa 813 * 1000 / 229 + 500;
82e839c9
HG		 814 }
815
816 i2cpframerate[3] = framerate_ctrl >> 6;
817 i2cpframerate[4] = framerate_ctrl & 0x3f;
4848ea77
HG		 818 i2c_w(gspca_dev, i2cpframerate);
819 i2c_w(gspca_dev, i2cpexpo);
820 i2c_w(gspca_dev, i2cpdoit);
51fc8e3b 821 break;
4848ea77 822 }
421763e7
HG		 823 case SENSOR_PAS106: {
824 __u8 i2cpframerate[] =
825 {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
826 __u8 i2cpexpo[] =
827 {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
828 const __u8 i2cpdoit[] =
829 {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
830 int framerate_ctrl;
831
832 /* For values below 150 use partial frame exposure, above
833 that use framerate ctrl */
9153ac3b
HG		 834 if (gspca_dev->exposure->val < 150) {
835 i2cpexpo[3] = 150 - gspca_dev->exposure->val;
421763e7
HG		 836 framerate_ctrl = 300;
837 } else {
838 /* The PAS106's exposure control goes from 0 - 4095,
839 but anything below 300 causes vsync issues, so scale
840 our 150-1023 to 300-4095 */
9153ac3b 841 framerate_ctrl = (gspca_dev->exposure->val - 150)
f51a8caa 842 * 1000 / 230 + 300;
421763e7
HG		 843 }
844
845 i2cpframerate[3] = framerate_ctrl >> 4;
846 i2cpframerate[4] = framerate_ctrl & 0x0f;
4848ea77
HG		 847 i2c_w(gspca_dev, i2cpframerate);
848 i2c_w(gspca_dev, i2cpexpo);
849 i2c_w(gspca_dev, i2cpdoit);
850 break;
851 }
852 default:
421763e7 853 break;
dcef3237
HG		 854 }
855}
856
66f35821
HG		 857static void setfreq(struct gspca_dev *gspca_dev)
858{
859 struct sd *sd = (struct sd *) gspca_dev;
860
4848ea77 861 if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630) {
66f35821 862 /* Framerate adjust register for artificial light 50 hz flicker
6af492e5
HG		 863 compensation, for the ov6650 this is identical to ov6630
864 0x2b register, see ov6630 datasheet.
865 0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
d87616f5 866 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
9153ac3b 867 switch (sd->plfreq->val) {
66f35821
HG		 868 default:
869/* case 0: * no filter*/
870/* case 2: * 60 hz */
871 i2c[3] = 0;
872 break;
873 case 1: /* 50 hz */
722103e3
HG		 874 i2c[3] = (sd->sensor == SENSOR_OV6650)
875 ? 0x4f : 0x8a;
66f35821
HG		 876 break;
877 }
f45f06b6 878 i2c[1] = sensor_data[sd->sensor].sensor_addr;
4848ea77 879 i2c_w(gspca_dev, i2c);
66f35821
HG		 880 }
881}
882
dcef3237
HG		 883static void do_autogain(struct gspca_dev *gspca_dev)
884{
885 struct sd *sd = (struct sd *) gspca_dev;
9153ac3b 886 int deadzone, desired_avg_lum, avg_lum;
dcef3237 887
9153ac3b
HG		 888 avg_lum = atomic_read(&sd->avg_lum);
889 if (avg_lum == -1)
26984b09
HG		 890 return;
891
892 if (sd->autogain_ignore_frames > 0) {
893 sd->autogain_ignore_frames--;
dcef3237 894 return;
26984b09 895 }
dcef3237 896
5017c7bd
HG		 897 /* SIF / VGA sensors have a different autoexposure area and thus
898 different avg_lum values for the same picture brightness */
899 if (sensor_data[sd->sensor].flags & F_SIF) {
26984b09
HG		 900 deadzone = 500;
901 /* SIF sensors tend to overexpose, so keep this small */
902 desired_avg_lum = 5000;
5017c7bd 903 } else {
26984b09 904 deadzone = 1500;
f913c001 905 desired_avg_lum = 13000;
5017c7bd
HG		 906 }
907
9153ac3b
HG		 908 if (sd->brightness)
909 desired_avg_lum = sd->brightness->val * desired_avg_lum / 127;
910
911 if (gspca_dev->exposure->maximum < 500) {
912 if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
913 desired_avg_lum, deadzone))
914 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
915 } else {
916 int gain_knee = gspca_dev->gain->maximum * 9 / 10;
917 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_avg_lum,
918 deadzone, gain_knee, sd->exposure_knee))
919 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
a975a527 920 }
6a7eba24
JFM		 921}
922
923/* this function is called at probe time */
924static int sd_config(struct gspca_dev *gspca_dev,
925 const struct usb_device_id *id)
926{
927 struct sd *sd = (struct sd *) gspca_dev;
928 struct cam *cam;
65f33396
HG		 929
930 reg_r(gspca_dev, 0x00);
931 if (gspca_dev->usb_buf[0] != 0x10)
932 return -ENODEV;
6a7eba24 933
5da162e7 934 /* copy the webcam info from the device id */
f45f06b6
HG		 935 sd->sensor = id->driver_info >> 8;
936 sd->bridge = id->driver_info & 0xff;
f51a8caa 937
6a7eba24 938 cam = &gspca_dev->cam;
f45f06b6 939 if (!(sensor_data[sd->sensor].flags & F_SIF)) {
6a7eba24 940 cam->cam_mode = vga_mode;
51fc8e3b 941 cam->nmodes = ARRAY_SIZE(vga_mode);
6a7eba24
JFM		 942 } else {
943 cam->cam_mode = sif_mode;
51fc8e3b 944 cam->nmodes = ARRAY_SIZE(sif_mode);
6a7eba24 945 }
49cb6b04
JFM		 946 cam->npkt = 36; /* 36 packets per ISOC message */
947
6a7eba24
JFM		 948 return 0;
949}
950
012d6b02
JFM		 951/* this function is called at probe and resume time */
952static int sd_init(struct gspca_dev *gspca_dev)
6a7eba24 953{
271315a9
HG		 954 const __u8 stop = 0x09; /* Disable stream turn of LED */
955
9153ac3b
HG		 956 reg_w(gspca_dev, 0x01, &stop, 1);
957
958 return gspca_dev->usb_err;
959}
960
961static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
962{
963 struct gspca_dev *gspca_dev =
964 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
965 struct sd *sd = (struct sd *)gspca_dev;
966
967 gspca_dev->usb_err = 0;
968
969 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
970 /* when switching to autogain set defaults to make sure
971 we are on a valid point of the autogain gain /
972 exposure knee graph, and give this change time to
973 take effect before doing autogain. */
974 gspca_dev->gain->val = gspca_dev->gain->default_value;
975 gspca_dev->exposure->val = gspca_dev->exposure->default_value;
976 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
3870ed3a
HG		 977 }
978
9153ac3b
HG		 979 if (!gspca_dev->streaming)
980 return 0;
271315a9 981
9153ac3b
HG		 982 switch (ctrl->id) {
983 case V4L2_CID_BRIGHTNESS:
984 setbrightness(gspca_dev);
985 break;
986 case V4L2_CID_AUTOGAIN:
987 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
988 setexposure(gspca_dev);
989 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
990 setgain(gspca_dev);
991 break;
992 case V4L2_CID_POWER_LINE_FREQUENCY:
993 setfreq(gspca_dev);
994 break;
995 default:
996 return -EINVAL;
997 }
4848ea77 998 return gspca_dev->usb_err;
6a7eba24
JFM		 999}
1000
9153ac3b
HG		 1001static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1002 .s_ctrl = sd_s_ctrl,
1003};
1004
1005/* this function is called at probe time */
1006static int sd_init_controls(struct gspca_dev *gspca_dev)
1007{
1008 struct sd *sd = (struct sd *) gspca_dev;
1009 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1010
1011 gspca_dev->vdev.ctrl_handler = hdl;
1012 v4l2_ctrl_handler_init(hdl, 5);
1013
1014 if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630 ||
1015 sd->sensor == SENSOR_PAS106 || sd->sensor == SENSOR_PAS202)
1016 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1017 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1018
1019 /* Gain range is sensor dependent */
1020 switch (sd->sensor) {
1021 case SENSOR_OV6650:
1022 case SENSOR_PAS106:
1023 case SENSOR_PAS202:
1024 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1025 V4L2_CID_GAIN, 0, 31, 1, 15);
1026 break;
9153ac3b 1027 case SENSOR_OV7630:
8b3a19b1
HG		 1028 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1029 V4L2_CID_GAIN, 0, 47, 1, 31);
1030 break;
1031 case SENSOR_HV7131D:
9153ac3b
HG		 1032 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1033 V4L2_CID_GAIN, 0, 63, 1, 31);
1034 break;
1035 case SENSOR_TAS5110C:
1036 case SENSOR_TAS5110D:
1037 case SENSOR_TAS5130CXX:
1038 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1039 V4L2_CID_GAIN, 0, 255, 1, 127);
1040 break;
1041 default:
1042 if (sd->bridge == BRIDGE_103) {
1043 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1044 V4L2_CID_GAIN, 0, 127, 1, 63);
1045 } else {
1046 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1047 V4L2_CID_GAIN, 0, 15, 1, 7);
1048 }
1049 }
1050
1051 /* Exposure range is sensor dependent, and not all have exposure */
1052 switch (sd->sensor) {
1053 case SENSOR_HV7131D:
1054 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1055 V4L2_CID_EXPOSURE, 0, 8191, 1, 482);
1056 sd->exposure_knee = 964;
1057 break;
1058 case SENSOR_OV6650:
1059 case SENSOR_OV7630:
1060 case SENSOR_PAS106:
1061 case SENSOR_PAS202:
1062 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1063 V4L2_CID_EXPOSURE, 0, 1023, 1, 66);
1064 sd->exposure_knee = 200;
1065 break;
1066 case SENSOR_TAS5110C:
1067 case SENSOR_TAS5110D:
1068 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1069 V4L2_CID_EXPOSURE, 2, 15, 1, 2);
1070 break;
1071 }
1072
1073 if (gspca_dev->exposure) {
1074 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1075 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1076 }
1077
1078 if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630)
1079 sd->plfreq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1080 V4L2_CID_POWER_LINE_FREQUENCY,
1081 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
1082 V4L2_CID_POWER_LINE_FREQUENCY_DISABLED);
1083
1084 if (hdl->error) {
1085 pr_err("Could not initialize controls\n");
1086 return hdl->error;
1087 }
1088
1089 if (gspca_dev->autogain)
1090 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
1091
1092 return 0;
1093}
1094
6a7eba24 1095/* -- start the camera -- */
72ab97ce 1096static int sd_start(struct gspca_dev *gspca_dev)
6a7eba24
JFM		 1097{
1098 struct sd *sd = (struct sd *) gspca_dev;
93627736 1099 struct cam *cam = &gspca_dev->cam;
0a76cb8c
HG		 1100 int i, mode;
1101 __u8 regs[0x31];
6a7eba24 1102
93627736 1103 mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
0a76cb8c
HG		 1104 /* Copy registers 0x01 - 0x19 from the template */
1105 memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1106 /* Set the mode */
1107 regs[0x18] |= mode << 4;
1108
1109 /* Set bridge gain to 1.0 */
1110 if (sd->bridge == BRIDGE_103) {
1111 regs[0x05] = 0x20; /* Red */
1112 regs[0x06] = 0x20; /* Green */
1113 regs[0x07] = 0x20; /* Blue */
1114 } else {
1115 regs[0x10] = 0x00; /* Red and blue */
1116 regs[0x11] = 0x00; /* Green */
1117 }
1118
1119 /* Setup pixel numbers and auto exposure window */
1120 if (sensor_data[sd->sensor].flags & F_SIF) {
1121 regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1122 regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1123 regs[0x1c] = 0x02; /* AE H-start 64 */
1124 regs[0x1d] = 0x02; /* AE V-start 64 */
1125 regs[0x1e] = 0x09; /* AE H-end 288 */
1126 regs[0x1f] = 0x07; /* AE V-end 224 */
1127 } else {
1128 regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1129 regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
f913c001 1130 regs[0x1c] = 0x05; /* AE H-start 160 */
0a76cb8c
HG		 1131 regs[0x1d] = 0x03; /* AE V-start 96 */
1132 regs[0x1e] = 0x0f; /* AE H-end 480 */
1133 regs[0x1f] = 0x0c; /* AE V-end 384 */
1134 }
1135
1136 /* Setup the gamma table (only used with the sn9c103 bridge) */
1137 for (i = 0; i < 16; i++)
1138 regs[0x20 + i] = i * 16;
1139 regs[0x20 + i] = 255;
1140
1141 /* Special cases where some regs depend on mode or bridge */
6a7eba24 1142 switch (sd->sensor) {
f45f06b6 1143 case SENSOR_TAS5130CXX:
0a76cb8c
HG		 1144 /* FIXME / TESTME
1145 probably not mode specific at all most likely the upper
f45f06b6
HG		 1146 nibble of 0x19 is exposure (clock divider) just as with
1147 the tas5110, we need someone to test this. */
0a76cb8c 1148 regs[0x19] = mode ? 0x23 : 0x43;
6a7eba24 1149 break;
0a76cb8c
HG		 1150 case SENSOR_OV7630:
1151 /* FIXME / TESTME for some reason with the 101/102 bridge the
1152 clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1153 Also the hstart needs to go from 1 to 2 when using a 103,
1154 which is likely related. This does not seem right. */
1155 if (sd->bridge == BRIDGE_103) {
1156 regs[0x01] = 0x44; /* Select 24 Mhz clock */
1157 regs[0x12] = 0x02; /* Set hstart to 2 */
1158 }
6a7eba24 1159 }
c437d657 1160 /* Disable compression when the raw bayer format has been selected */
93627736 1161 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
0a76cb8c 1162 regs[0x18] &= ~0x80;
93627736
HG		 1163
1164 /* Vga mode emulation on SIF sensor? */
1165 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
0a76cb8c
HG		 1166 regs[0x12] += 16; /* hstart adjust */
1167 regs[0x13] += 24; /* vstart adjust */
1168 regs[0x15] = 320 / 16; /* hsize */
1169 regs[0x16] = 240 / 16; /* vsize */
93627736 1170 }
6af492e5 1171
6a7eba24 1172 /* reg 0x01 bit 2 video transfert on */
0a76cb8c 1173 reg_w(gspca_dev, 0x01, &regs[0x01], 1);
6a7eba24 1174 /* reg 0x17 SensorClk enable inv Clk 0x60 */
0a76cb8c 1175 reg_w(gspca_dev, 0x17, &regs[0x17], 1);
6a7eba24 1176 /* Set the registers from the template */
0a76cb8c
HG		 1177 reg_w(gspca_dev, 0x01, &regs[0x01],
1178 (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
f45f06b6
HG		 1179
1180 /* Init the sensor */
1181 i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1182 sensor_data[sd->sensor].sensor_init_size);
f45f06b6 1183
0a76cb8c 1184 /* Mode / bridge specific sensor setup */
82e839c9
HG		 1185 switch (sd->sensor) {
1186 case SENSOR_PAS202: {
1187 const __u8 i2cpclockdiv[] =
1188 {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1189 /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1190 if (mode)
1191 i2c_w(gspca_dev, i2cpclockdiv);
0a76cb8c 1192 break;
82e839c9 1193 }
0a76cb8c
HG		 1194 case SENSOR_OV7630:
1195 /* FIXME / TESTME We should be able to handle this identical
1196 for the 101/102 and the 103 case */
1197 if (sd->bridge == BRIDGE_103) {
1198 const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1199 0x80, 0x00, 0x00, 0x00, 0x10 };
1200 i2c_w(gspca_dev, i2c);
1201 }
1202 break;
82e839c9 1203 }
3647fea8 1204 /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
0a76cb8c 1205 reg_w(gspca_dev, 0x15, &regs[0x15], 2);
6a7eba24 1206 /* compression register */
0a76cb8c 1207 reg_w(gspca_dev, 0x18, &regs[0x18], 1);
794af52a 1208 /* H_start */
0a76cb8c 1209 reg_w(gspca_dev, 0x12, &regs[0x12], 1);
794af52a 1210 /* V_START */
0a76cb8c 1211 reg_w(gspca_dev, 0x13, &regs[0x13], 1);
6a7eba24
JFM		 1212 /* reset 0x17 SensorClk enable inv Clk 0x60 */
1213 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
0a76cb8c 1214 reg_w(gspca_dev, 0x17, &regs[0x17], 1);
6a7eba24 1215 /*MCKSIZE ->3 */ /*fixme: not ov7630*/
0a76cb8c 1216 reg_w(gspca_dev, 0x19, &regs[0x19], 1);
6a7eba24 1217 /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
0a76cb8c 1218 reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
6a7eba24 1219 /* Enable video transfert */
0a76cb8c 1220 reg_w(gspca_dev, 0x01, &regs[0x01], 1);
6a7eba24 1221 /* Compression */
0a76cb8c 1222 reg_w(gspca_dev, 0x18, &regs[0x18], 2);
6a7eba24
JFM		 1223 msleep(20);
1224
6af492e5
HG		 1225 sd->reg11 = -1;
1226
dcef3237 1227 setgain(gspca_dev);
6a7eba24 1228 setbrightness(gspca_dev);
dcef3237 1229 setexposure(gspca_dev);
66f35821 1230 setfreq(gspca_dev);
dcef3237 1231
6af492e5 1232 sd->frames_to_drop = 0;
dcef3237 1233 sd->autogain_ignore_frames = 0;
9153ac3b
HG		 1234 gspca_dev->exp_too_high_cnt = 0;
1235 gspca_dev->exp_too_low_cnt = 0;
dcef3237 1236 atomic_set(&sd->avg_lum, -1);
4848ea77 1237 return gspca_dev->usb_err;
6a7eba24
JFM		 1238}
1239
1240static void sd_stopN(struct gspca_dev *gspca_dev)
1241{
f45f06b6 1242 sd_init(gspca_dev);
6a7eba24
JFM		 1243}
1244
2b3e284a 1245static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
6a7eba24 1246{
dcef3237 1247 struct sd *sd = (struct sd *) gspca_dev;
2b3e284a 1248 int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
6a7eba24 1249
c36260ee
HG		 1250 /* frames start with:
1251 * ff ff 00 c4 c4 96 synchro
1252 * 00 (unknown)
1253 * xx (frame sequence / size / compression)
1254 * (xx) (idem - extra byte for sn9c103)
1255 * ll mm brightness sum inside auto exposure
1256 * ll mm brightness sum outside auto exposure
1257 * (xx xx xx xx xx) audio values for snc103
1258 */
2b3e284a
HG		 1259 for (i = 0; i < len; i++) {
1260 switch (sd->header_read) {
1261 case 0:
1262 if (data[i] == 0xff)
1263 sd->header_read++;
1264 break;
1265 case 1:
1266 if (data[i] == 0xff)
1267 sd->header_read++;
1268 else
1269 sd->header_read = 0;
1270 break;
1271 case 2:
1272 if (data[i] == 0x00)
1273 sd->header_read++;
1274 else if (data[i] != 0xff)
1275 sd->header_read = 0;
1276 break;
1277 case 3:
1278 if (data[i] == 0xc4)
1279 sd->header_read++;
1280 else if (data[i] == 0xff)
1281 sd->header_read = 1;
1282 else
1283 sd->header_read = 0;
1284 break;
1285 case 4:
1286 if (data[i] == 0xc4)
1287 sd->header_read++;
1288 else if (data[i] == 0xff)
1289 sd->header_read = 1;
1290 else
1291 sd->header_read = 0;
1292 break;
1293 case 5:
1294 if (data[i] == 0x96)
1295 sd->header_read++;
1296 else if (data[i] == 0xff)
1297 sd->header_read = 1;
1298 else
1299 sd->header_read = 0;
1300 break;
1301 default:
1302 sd->header[sd->header_read - 6] = data[i];
1303 sd->header_read++;
1304 if (sd->header_read == header_size) {
1305 sd->header_read = 0;
1306 return data + i + 1;
6a7eba24
JFM		 1307 }
1308 }
1309 }
2b3e284a
HG		 1310 return NULL;
1311}
1312
1313static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1314 u8 *data, /* isoc packet */
1315 int len) /* iso packet length */
1316{
1317 int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1318 struct sd *sd = (struct sd *) gspca_dev;
1319 struct cam *cam = &gspca_dev->cam;
1320 u8 *sof;
1321
1322 sof = find_sof(gspca_dev, data, len);
1323 if (sof) {
1324 if (sd->bridge == BRIDGE_103) {
1325 fr_h_sz = 18;
1326 lum_offset = 3;
1327 } else {
1328 fr_h_sz = 12;
1329 lum_offset = 2;
1330 }
1331
1332 len_after_sof = len - (sof - data);
1333 len = (sof - data) - fr_h_sz;
1334 if (len < 0)
1335 len = 0;
1336 }
c437d657
HG		 1337
1338 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1339 /* In raw mode we sometimes get some garbage after the frame
1340 ignore this */
76dd272b 1341 int used;
c437d657
HG		 1342 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1343
b192ca98 1344 used = gspca_dev->image_len;
c437d657
HG		 1345 if (used + len > size)
1346 len = size - used;
1347 }
1348
76dd272b 1349 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2b3e284a
HG		 1350
1351 if (sof) {
1352 int lum = sd->header[lum_offset] +
1353 (sd->header[lum_offset + 1] << 8);
1354
1355 /* When exposure changes midway a frame we
1356 get a lum of 0 in this case drop 2 frames
1357 as the frames directly after an exposure
1358 change have an unstable image. Sometimes lum
1359 *really* is 0 (cam used in low light with
1360 low exposure setting), so do not drop frames
1361 if the previous lum was 0 too. */
1362 if (lum == 0 && sd->prev_avg_lum != 0) {
1363 lum = -1;
1364 sd->frames_to_drop = 2;
1365 sd->prev_avg_lum = 0;
1366 } else
1367 sd->prev_avg_lum = lum;
1368 atomic_set(&sd->avg_lum, lum);
1369
1370 if (sd->frames_to_drop)
1371 sd->frames_to_drop--;
1372 else
1373 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1374
1375 gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1376 }
6a7eba24
JFM		 1377}
1378
66f35821
HG		 1379static int sd_querymenu(struct gspca_dev *gspca_dev,
1380 struct v4l2_querymenu *menu)
1381{
1382 switch (menu->id) {
1383 case V4L2_CID_POWER_LINE_FREQUENCY:
1384 switch (menu->index) {
1385 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1386 strcpy((char *) menu->name, "NoFliker");
1387 return 0;
1388 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1389 strcpy((char *) menu->name, "50 Hz");
1390 return 0;
1391 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1392 strcpy((char *) menu->name, "60 Hz");
1393 return 0;
1394 }
1395 break;
1396 }
1397 return -EINVAL;
1398}
1399
2856643e 1400#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
f65e93d6
HG		 1401static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1402 u8 *data, /* interrupt packet data */
1403 int len) /* interrupt packet length */
1404{
1405 int ret = -EINVAL;
1406
1407 if (len == 1 && data[0] == 1) {
1408 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1409 input_sync(gspca_dev->input_dev);
1410 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1411 input_sync(gspca_dev->input_dev);
1412 ret = 0;
1413 }
1414
1415 return ret;
1416}
1417#endif
1418
6a7eba24 1419/* sub-driver description */
dcef3237 1420static const struct sd_desc sd_desc = {
6a7eba24 1421 .name = MODULE_NAME,
6a7eba24 1422 .config = sd_config,
012d6b02 1423 .init = sd_init,
9153ac3b 1424 .init_controls = sd_init_controls,
6a7eba24
JFM		 1425 .start = sd_start,
1426 .stopN = sd_stopN,
6a7eba24 1427 .pkt_scan = sd_pkt_scan,
66f35821 1428 .querymenu = sd_querymenu,
e2ad2a54 1429 .dq_callback = do_autogain,
2856643e 1430#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
f65e93d6
HG		 1431 .int_pkt_scan = sd_int_pkt_scan,
1432#endif
6a7eba24
JFM		 1433};
1434
1435/* -- module initialisation -- */
f45f06b6
HG		 1436#define SB(sensor, bridge) \
1437 .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1438
e2ad2a54 1439
95c967c1 1440static const struct usb_device_id device_table[] = {
b10af3f7
HG		 1441 {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1442 {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
b10af3f7 1443 {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
f45f06b6
HG		 1444 {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1445 {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
f45f06b6 1446 {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
f45f06b6 1447 {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
69ffd254 1448#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
f45f06b6
HG		 1449 {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1450 {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
0e4b91c3 1451#endif
f45f06b6
HG		 1452 {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1453 {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
00765f16
HG		 1454 {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1455 /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
29fbdf3d 1456 {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
f45f06b6 1457 {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
f45f06b6 1458 {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
69ffd254
HG		 1459 /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1460 /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
1461 {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
1462 {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
1463 /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
f45f06b6 1464 {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
69ffd254
HG		 1465 {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
1466 {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
f45f06b6 1467 {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
4cce1655 1468 {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
6a7eba24
JFM		 1469 {}
1470};
1471MODULE_DEVICE_TABLE(usb, device_table);
1472
1473/* -- device connect -- */
95c967c1 1474static int sd_probe(struct usb_interface *intf,
6a7eba24
JFM		 1475 const struct usb_device_id *id)
1476{
1477 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1478 THIS_MODULE);
1479}
1480
1481static struct usb_driver sd_driver = {
1482 .name = MODULE_NAME,
1483 .id_table = device_table,
1484 .probe = sd_probe,
1485 .disconnect = gspca_disconnect,
6a709749
JFM		 1486#ifdef CONFIG_PM
1487 .suspend = gspca_suspend,
1488 .resume = gspca_resume,
8bb58964 1489 .reset_resume = gspca_resume,
6a709749 1490#endif
6a7eba24
JFM		 1491};
1492
ecb3b2b3 1493module_usb_driver(sd_driver);
Linux 6.x block layer and io_uring tree(s)