xref: /openbmc/linux/drivers/media/usb/gspca/sonixb.c (revision e23feb16)
1 /*
2  *		sonix sn9c102 (bayer) library
3  *
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
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 
23 /* Some documentation on known sonixb registers:
24 
25 Reg	Use
26 sn9c101 / sn9c102:
27 0x10	high nibble red gain low nibble blue gain
28 0x11	low nibble green gain
29 sn9c103:
30 0x05	red gain 0-127
31 0x06	blue gain 0-127
32 0x07	green gain 0-127
33 all:
34 0x08-0x0f i2c / 3wire registers
35 0x12	hstart
36 0x13	vstart
37 0x15	hsize (hsize = register-value * 16)
38 0x16	vsize (vsize = register-value * 16)
39 0x17	bit 0 toggle compression quality (according to sn9c102 driver)
40 0x18	bit 7 enables compression, bit 4-5 set image down scaling:
41 	00 scale 1, 01 scale 1/2, 10, scale 1/4
42 0x19	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.
44 0x1c	auto_exposure area (for avg_lum) startx (startx = register-value * 32)
45 0x1d	auto_exposure area (for avg_lum) starty (starty = register-value * 32)
46 0x1e	auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
47 0x1f	auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
48 */
49 
50 #define MODULE_NAME "sonixb"
51 
52 #include <linux/input.h>
53 #include "gspca.h"
54 
55 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
56 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
57 MODULE_LICENSE("GPL");
58 
59 /* specific webcam descriptor */
60 struct sd {
61 	struct gspca_dev gspca_dev;	/* !! must be the first item */
62 
63 	struct v4l2_ctrl *brightness;
64 	struct v4l2_ctrl *plfreq;
65 
66 	atomic_t avg_lum;
67 	int prev_avg_lum;
68 	int exposure_knee;
69 	int header_read;
70 	u8 header[12]; /* Header without sof marker */
71 
72 	unsigned char autogain_ignore_frames;
73 	unsigned char frames_to_drop;
74 
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 */
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
90 	__u8 reg11;
91 };
92 
93 typedef const __u8 sensor_init_t[8];
94 
95 struct sensor_data {
96 	const __u8 *bridge_init;
97 	sensor_init_t *sensor_init;
98 	int sensor_init_size;
99 	int flags;
100 	__u8 sensor_addr;
101 };
102 
103 /* sensor_data flags */
104 #define F_SIF		0x01	/* sif or vga */
105 
106 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
107 #define MODE_RAW 0x10		/* raw bayer mode */
108 #define MODE_REDUCED_SIF 0x20	/* vga mode (320x240 / 160x120) on sif cam */
109 
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 
118 #define SENS(bridge, sensor, _flags, _sensor_addr) \
119 { \
120 	.bridge_init = bridge, \
121 	.sensor_init = sensor, \
122 	.sensor_init_size = sizeof(sensor), \
123 	.flags = _flags, .sensor_addr = _sensor_addr \
124 }
125 
126 /* We calculate the autogain at the end of the transfer of a frame, at this
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
131 
132 static const struct v4l2_pix_format vga_mode[] = {
133 	{160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
134 		.bytesperline = 160,
135 		.sizeimage = 160 * 120,
136 		.colorspace = V4L2_COLORSPACE_SRGB,
137 		.priv = 2 | MODE_RAW},
138 	{160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
139 		.bytesperline = 160,
140 		.sizeimage = 160 * 120 * 5 / 4,
141 		.colorspace = V4L2_COLORSPACE_SRGB,
142 		.priv = 2},
143 	{320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
144 		.bytesperline = 320,
145 		.sizeimage = 320 * 240 * 5 / 4,
146 		.colorspace = V4L2_COLORSPACE_SRGB,
147 		.priv = 1},
148 	{640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
149 		.bytesperline = 640,
150 		.sizeimage = 640 * 480 * 5 / 4,
151 		.colorspace = V4L2_COLORSPACE_SRGB,
152 		.priv = 0},
153 };
154 static const struct v4l2_pix_format sif_mode[] = {
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},
165 	{176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
166 		.bytesperline = 176,
167 		.sizeimage = 176 * 144,
168 		.colorspace = V4L2_COLORSPACE_SRGB,
169 		.priv = 1 | MODE_RAW},
170 	{176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
171 		.bytesperline = 176,
172 		.sizeimage = 176 * 144 * 5 / 4,
173 		.colorspace = V4L2_COLORSPACE_SRGB,
174 		.priv = 1},
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},
180 	{352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
181 		.bytesperline = 352,
182 		.sizeimage = 352 * 288 * 5 / 4,
183 		.colorspace = V4L2_COLORSPACE_SRGB,
184 		.priv = 0},
185 };
186 
187 static 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,
192 };
193 static 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 
201 static const __u8 initHv7131r[] = {
202 	0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
203 	0x00, 0x00,
204 	0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
205 	0x28, 0x1e, 0x60, 0x8a, 0x20,
206 };
207 static const __u8 hv7131r_sensor_init[][8] = {
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 };
214 static const __u8 initOv6650[] = {
215 	0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
216 	0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
217 	0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
218 	0x10,
219 };
220 static const __u8 ov6650_sensor_init[][8] = {
221 	/* Bright, contrast, etc are set through SCBB interface.
222 	 * AVCAP on win2 do not send any data on this controls. */
223 	/* Anyway, some registers appears to alter bright and constrat */
224 
225 	/* Reset sensor */
226 	{0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
227 	/* Set clock register 0x11 low nibble is clock divider */
228 	{0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
229 	/* Next some unknown stuff */
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},
237 	{0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10},
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}, */
247 	/* Some more unknown stuff */
248 	{0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
249 	{0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
250 };
251 
252 static 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 */
255 	0x00, 0x01, 0x01, 0x0a,				/* r11 .. r14 */
256 	0x28, 0x1e,			/* H & V sizes     r15 .. r16 */
257 	0x68, 0x8f, MCK_INIT1,				/* r17 .. r19 */
258 };
259 static const __u8 ov7630_sensor_init[][8] = {
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 */
263 	{0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10},	/* 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},
271 	{0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
272 /*	{0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10},	 * 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 };
280 
281 static const __u8 initPas106[] = {
282 	0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
283 	0x00, 0x00,
284 	0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
285 	0x16, 0x12, 0x24, COMP1, MCK_INIT1,
286 };
287 /* compression 0x86 mckinit1 0x2b */
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 
312 static 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 },
352 };
353 
354 static const __u8 initPas202[] = {
355 	0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
356 	0x00, 0x00,
357 	0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
358 	0x28, 0x1e, 0x20, 0x89, 0x20,
359 };
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 */
378 static const __u8 pas202_sensor_init[][8] = {
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},
383 	{0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
384 	{0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
385 	{0xd0, 0x40, 0x0c, 0x00, 0x0c, 0x01, 0x32, 0x10},
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},
392 };
393 
394 static const __u8 initTas5110c[] = {
395 	0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
396 	0x00, 0x00,
397 	0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
398 	0x16, 0x12, 0x60, 0x86, 0x2b,
399 };
400 /* Same as above, except a different hstart */
401 static const __u8 initTas5110d[] = {
402 	0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
403 	0x00, 0x00,
404 	0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
405 	0x16, 0x12, 0x60, 0x86, 0x2b,
406 };
407 /* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */
408 static const __u8 tas5110c_sensor_init[][8] = {
409 	{0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
410 	{0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
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  */
417 static const __u8 tas5110d_sensor_init[][8] = {
418 	{0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */
419 };
420 
421 static const __u8 initTas5130[] = {
422 	0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
423 	0x00, 0x00,
424 	0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
425 	0x28, 0x1e, 0x60, COMP, MCK_INIT,
426 };
427 static const __u8 tas5130_sensor_init[][8] = {
428 /*	{0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
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 
435 static const struct sensor_data sensor_data[] = {
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),
445 };
446 
447 /* get one byte in gspca_dev->usb_buf */
448 static void reg_r(struct gspca_dev *gspca_dev,
449 		  __u16 value)
450 {
451 	int res;
452 
453 	if (gspca_dev->usb_err < 0)
454 		return;
455 
456 	res = usb_control_msg(gspca_dev->dev,
457 			usb_rcvctrlpipe(gspca_dev->dev, 0),
458 			0,			/* request */
459 			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
460 			value,
461 			0,			/* index */
462 			gspca_dev->usb_buf, 1,
463 			500);
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 	}
470 }
471 
472 static void reg_w(struct gspca_dev *gspca_dev,
473 		  __u16 value,
474 		  const __u8 *buffer,
475 		  int len)
476 {
477 	int res;
478 
479 	if (gspca_dev->usb_err < 0)
480 		return;
481 
482 	memcpy(gspca_dev->usb_buf, buffer, len);
483 	res = usb_control_msg(gspca_dev->dev,
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);
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 	}
497 }
498 
499 static void i2c_w(struct gspca_dev *gspca_dev, const u8 *buf)
500 {
501 	int retry = 60;
502 
503 	if (gspca_dev->usb_err < 0)
504 		return;
505 
506 	/* is i2c ready */
507 	reg_w(gspca_dev, 0x08, buf, 8);
508 	while (retry--) {
509 		if (gspca_dev->usb_err < 0)
510 			return;
511 		msleep(1);
512 		reg_r(gspca_dev, 0x08);
513 		if (gspca_dev->usb_buf[0] & 0x04) {
514 			if (gspca_dev->usb_buf[0] & 0x08) {
515 				dev_err(gspca_dev->v4l2_dev.dev,
516 					"i2c error writing %02x %02x %02x %02x"
517 					" %02x %02x %02x %02x\n",
518 					buf[0], buf[1], buf[2], buf[3],
519 					buf[4], buf[5], buf[6], buf[7]);
520 				gspca_dev->usb_err = -EIO;
521 			}
522 			return;
523 		}
524 	}
525 
526 	dev_err(gspca_dev->v4l2_dev.dev, "i2c write timeout\n");
527 	gspca_dev->usb_err = -EIO;
528 }
529 
530 static void i2c_w_vector(struct gspca_dev *gspca_dev,
531 			const __u8 buffer[][8], int len)
532 {
533 	for (;;) {
534 		if (gspca_dev->usb_err < 0)
535 			return;
536 		i2c_w(gspca_dev, *buffer);
537 		len -= 8;
538 		if (len <= 0)
539 			break;
540 		buffer++;
541 	}
542 }
543 
544 static void setbrightness(struct gspca_dev *gspca_dev)
545 {
546 	struct sd *sd = (struct sd *) gspca_dev;
547 
548 	switch (sd->sensor) {
549 	case  SENSOR_OV6650:
550 	case  SENSOR_OV7630: {
551 		__u8 i2cOV[] =
552 			{0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
553 
554 		/* change reg 0x06 */
555 		i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
556 		i2cOV[3] = sd->brightness->val;
557 		i2c_w(gspca_dev, i2cOV);
558 		break;
559 	}
560 	case SENSOR_PAS106:
561 	case SENSOR_PAS202: {
562 		__u8 i2cpbright[] =
563 			{0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
564 		__u8 i2cpdoit[] =
565 			{0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
566 
567 		/* PAS106 uses reg 7 and 8 instead of b and c */
568 		if (sd->sensor == SENSOR_PAS106) {
569 			i2cpbright[2] = 7;
570 			i2cpdoit[2] = 0x13;
571 		}
572 
573 		if (sd->brightness->val < 127) {
574 			/* change reg 0x0b, signreg */
575 			i2cpbright[3] = 0x01;
576 			/* set reg 0x0c, offset */
577 			i2cpbright[4] = 127 - sd->brightness->val;
578 		} else
579 			i2cpbright[4] = sd->brightness->val - 127;
580 
581 		i2c_w(gspca_dev, i2cpbright);
582 		i2c_w(gspca_dev, i2cpdoit);
583 		break;
584 	}
585 	default:
586 		break;
587 	}
588 }
589 
590 static void setgain(struct gspca_dev *gspca_dev)
591 {
592 	struct sd *sd = (struct sd *) gspca_dev;
593 	u8 gain = gspca_dev->gain->val;
594 
595 	switch (sd->sensor) {
596 	case SENSOR_HV7131D: {
597 		__u8 i2c[] =
598 			{0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
599 
600 		i2c[3] = 0x3f - gain;
601 		i2c[4] = 0x3f - gain;
602 		i2c[5] = 0x3f - gain;
603 
604 		i2c_w(gspca_dev, i2c);
605 		break;
606 	}
607 	case SENSOR_TAS5110C:
608 	case SENSOR_TAS5130CXX: {
609 		__u8 i2c[] =
610 			{0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
611 
612 		i2c[4] = 255 - gain;
613 		i2c_w(gspca_dev, i2c);
614 		break;
615 	}
616 	case SENSOR_TAS5110D: {
617 		__u8 i2c[] = {
618 			0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
619 		gain = 255 - gain;
620 		/* The bits in the register are the wrong way around!! */
621 		i2c[3] |= (gain & 0x80) >> 7;
622 		i2c[3] |= (gain & 0x40) >> 5;
623 		i2c[3] |= (gain & 0x20) >> 3;
624 		i2c[3] |= (gain & 0x10) >> 1;
625 		i2c[3] |= (gain & 0x08) << 1;
626 		i2c[3] |= (gain & 0x04) << 3;
627 		i2c[3] |= (gain & 0x02) << 5;
628 		i2c[3] |= (gain & 0x01) << 7;
629 		i2c_w(gspca_dev, i2c);
630 		break;
631 	}
632 	case SENSOR_OV6650:
633 	case SENSOR_OV7630: {
634 		__u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
635 
636 		/*
637 		 * The ov7630's gain is weird, at 32 the gain drops to the
638 		 * same level as at 16, so skip 32-47 (of the 0-63 scale).
639 		 */
640 		if (sd->sensor == SENSOR_OV7630 && gain >= 32)
641 			gain += 16;
642 
643 		i2c[1] = sensor_data[sd->sensor].sensor_addr;
644 		i2c[3] = gain;
645 		i2c_w(gspca_dev, i2c);
646 		break;
647 	}
648 	case SENSOR_PAS106:
649 	case SENSOR_PAS202: {
650 		__u8 i2cpgain[] =
651 			{0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
652 		__u8 i2cpcolorgain[] =
653 			{0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
654 		__u8 i2cpdoit[] =
655 			{0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
656 
657 		/* PAS106 uses different regs (and has split green gains) */
658 		if (sd->sensor == SENSOR_PAS106) {
659 			i2cpgain[2] = 0x0e;
660 			i2cpcolorgain[0] = 0xd0;
661 			i2cpcolorgain[2] = 0x09;
662 			i2cpdoit[2] = 0x13;
663 		}
664 
665 		i2cpgain[3] = gain;
666 		i2cpcolorgain[3] = gain >> 1;
667 		i2cpcolorgain[4] = gain >> 1;
668 		i2cpcolorgain[5] = gain >> 1;
669 		i2cpcolorgain[6] = gain >> 1;
670 
671 		i2c_w(gspca_dev, i2cpgain);
672 		i2c_w(gspca_dev, i2cpcolorgain);
673 		i2c_w(gspca_dev, i2cpdoit);
674 		break;
675 	}
676 	default:
677 		if (sd->bridge == BRIDGE_103) {
678 			u8 buf[3] = { gain, gain, gain }; /* R, G, B */
679 			reg_w(gspca_dev, 0x05, buf, 3);
680 		} else {
681 			u8 buf[2];
682 			buf[0] = gain << 4 | gain; /* Red and blue */
683 			buf[1] = gain; /* Green */
684 			reg_w(gspca_dev, 0x10, buf, 2);
685 		}
686 	}
687 }
688 
689 static void setexposure(struct gspca_dev *gspca_dev)
690 {
691 	struct sd *sd = (struct sd *) gspca_dev;
692 
693 	switch (sd->sensor) {
694 	case SENSOR_HV7131D: {
695 		/* Note the datasheet wrongly says line mode exposure uses reg
696 		   0x26 and 0x27, testing has shown 0x25 + 0x26 */
697 		__u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
698 		u16 reg = gspca_dev->exposure->val;
699 
700 		i2c[3] = reg >> 8;
701 		i2c[4] = reg & 0xff;
702 		i2c_w(gspca_dev, i2c);
703 		break;
704 	}
705 	case SENSOR_TAS5110C:
706 	case SENSOR_TAS5110D: {
707 		/* register 19's high nibble contains the sn9c10x clock divider
708 		   The high nibble configures the no fps according to the
709 		   formula: 60 / high_nibble. With a maximum of 30 fps */
710 		u8 reg = gspca_dev->exposure->val;
711 
712 		reg = (reg << 4) | 0x0b;
713 		reg_w(gspca_dev, 0x19, &reg, 1);
714 		break;
715 	}
716 	case SENSOR_OV6650:
717 	case SENSOR_OV7630: {
718 		/* The ov6650 / ov7630 have 2 registers which both influence
719 		   exposure, register 11, whose low nibble sets the nr off fps
720 		   according to: fps = 30 / (low_nibble + 1)
721 
722 		   The fps configures the maximum exposure setting, but it is
723 		   possible to use less exposure then what the fps maximum
724 		   allows by setting register 10. register 10 configures the
725 		   actual exposure as quotient of the full exposure, with 0
726 		   being no exposure at all (not very useful) and reg10_max
727 		   being max exposure possible at that framerate.
728 
729 		   The code maps our 0 - 510 ms exposure ctrl to these 2
730 		   registers, trying to keep fps as high as possible.
731 		*/
732 		__u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
733 		int reg10, reg11, reg10_max;
734 
735 		/* ov6645 datasheet says reg10_max is 9a, but that uses
736 		   tline * 2 * reg10 as formula for calculating texpo, the
737 		   ov6650 probably uses the same formula as the 7730 which uses
738 		   tline * 4 * reg10, which explains why the reg10max we've
739 		   found experimentally for the ov6650 is exactly half that of
740 		   the ov6645. The ov7630 datasheet says the max is 0x41. */
741 		if (sd->sensor == SENSOR_OV6650) {
742 			reg10_max = 0x4d;
743 			i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
744 		} else
745 			reg10_max = 0x41;
746 
747 		reg11 = (15 * gspca_dev->exposure->val + 999) / 1000;
748 		if (reg11 < 1)
749 			reg11 = 1;
750 		else if (reg11 > 16)
751 			reg11 = 16;
752 
753 		/* In 640x480, if the reg11 has less than 4, the image is
754 		   unstable (the bridge goes into a higher compression mode
755 		   which we have not reverse engineered yet). */
756 		if (gspca_dev->width == 640 && reg11 < 4)
757 			reg11 = 4;
758 
759 		/* frame exposure time in ms = 1000 * reg11 / 30    ->
760 		reg10 = (gspca_dev->exposure->val / 2) * reg10_max
761 				/ (1000 * reg11 / 30) */
762 		reg10 = (gspca_dev->exposure->val * 15 * reg10_max)
763 				/ (1000 * reg11);
764 
765 		/* Don't allow this to get below 10 when using autogain, the
766 		   steps become very large (relatively) when below 10 causing
767 		   the image to oscilate from much too dark, to much too bright
768 		   and back again. */
769 		if (gspca_dev->autogain->val && reg10 < 10)
770 			reg10 = 10;
771 		else if (reg10 > reg10_max)
772 			reg10 = reg10_max;
773 
774 		/* Write reg 10 and reg11 low nibble */
775 		i2c[1] = sensor_data[sd->sensor].sensor_addr;
776 		i2c[3] = reg10;
777 		i2c[4] |= reg11 - 1;
778 
779 		/* If register 11 didn't change, don't change it */
780 		if (sd->reg11 == reg11)
781 			i2c[0] = 0xa0;
782 
783 		i2c_w(gspca_dev, i2c);
784 		if (gspca_dev->usb_err == 0)
785 			sd->reg11 = reg11;
786 		break;
787 	}
788 	case SENSOR_PAS202: {
789 		__u8 i2cpframerate[] =
790 			{0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
791 		__u8 i2cpexpo[] =
792 			{0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
793 		const __u8 i2cpdoit[] =
794 			{0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
795 		int framerate_ctrl;
796 
797 		/* The exposure knee for the autogain algorithm is 200
798 		   (100 ms / 10 fps on other sensors), for values below this
799 		   use the control for setting the partial frame expose time,
800 		   above that use variable framerate. This way we run at max
801 		   framerate (640x480@7.5 fps, 320x240@10fps) until the knee
802 		   is reached. Using the variable framerate control above 200
803 		   is better then playing around with both clockdiv + partial
804 		   frame exposure times (like we are doing with the ov chips),
805 		   as that sometimes leads to jumps in the exposure control,
806 		   which are bad for auto exposure. */
807 		if (gspca_dev->exposure->val < 200) {
808 			i2cpexpo[3] = 255 - (gspca_dev->exposure->val * 255)
809 						/ 200;
810 			framerate_ctrl = 500;
811 		} else {
812 			/* The PAS202's exposure control goes from 0 - 4095,
813 			   but anything below 500 causes vsync issues, so scale
814 			   our 200-1023 to 500-4095 */
815 			framerate_ctrl = (gspca_dev->exposure->val - 200)
816 							* 1000 / 229 +  500;
817 		}
818 
819 		i2cpframerate[3] = framerate_ctrl >> 6;
820 		i2cpframerate[4] = framerate_ctrl & 0x3f;
821 		i2c_w(gspca_dev, i2cpframerate);
822 		i2c_w(gspca_dev, i2cpexpo);
823 		i2c_w(gspca_dev, i2cpdoit);
824 		break;
825 	}
826 	case SENSOR_PAS106: {
827 		__u8 i2cpframerate[] =
828 			{0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
829 		__u8 i2cpexpo[] =
830 			{0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
831 		const __u8 i2cpdoit[] =
832 			{0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
833 		int framerate_ctrl;
834 
835 		/* For values below 150 use partial frame exposure, above
836 		   that use framerate ctrl */
837 		if (gspca_dev->exposure->val < 150) {
838 			i2cpexpo[3] = 150 - gspca_dev->exposure->val;
839 			framerate_ctrl = 300;
840 		} else {
841 			/* The PAS106's exposure control goes from 0 - 4095,
842 			   but anything below 300 causes vsync issues, so scale
843 			   our 150-1023 to 300-4095 */
844 			framerate_ctrl = (gspca_dev->exposure->val - 150)
845 						* 1000 / 230 + 300;
846 		}
847 
848 		i2cpframerate[3] = framerate_ctrl >> 4;
849 		i2cpframerate[4] = framerate_ctrl & 0x0f;
850 		i2c_w(gspca_dev, i2cpframerate);
851 		i2c_w(gspca_dev, i2cpexpo);
852 		i2c_w(gspca_dev, i2cpdoit);
853 		break;
854 	}
855 	default:
856 		break;
857 	}
858 }
859 
860 static void setfreq(struct gspca_dev *gspca_dev)
861 {
862 	struct sd *sd = (struct sd *) gspca_dev;
863 
864 	if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630) {
865 		/* Framerate adjust register for artificial light 50 hz flicker
866 		   compensation, for the ov6650 this is identical to ov6630
867 		   0x2b register, see ov6630 datasheet.
868 		   0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
869 		__u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
870 		switch (sd->plfreq->val) {
871 		default:
872 /*		case 0:			 * no filter*/
873 /*		case 2:			 * 60 hz */
874 			i2c[3] = 0;
875 			break;
876 		case 1:			/* 50 hz */
877 			i2c[3] = (sd->sensor == SENSOR_OV6650)
878 					? 0x4f : 0x8a;
879 			break;
880 		}
881 		i2c[1] = sensor_data[sd->sensor].sensor_addr;
882 		i2c_w(gspca_dev, i2c);
883 	}
884 }
885 
886 static void do_autogain(struct gspca_dev *gspca_dev)
887 {
888 	struct sd *sd = (struct sd *) gspca_dev;
889 	int deadzone, desired_avg_lum, avg_lum;
890 
891 	avg_lum = atomic_read(&sd->avg_lum);
892 	if (avg_lum == -1)
893 		return;
894 
895 	if (sd->autogain_ignore_frames > 0) {
896 		sd->autogain_ignore_frames--;
897 		return;
898 	}
899 
900 	/* SIF / VGA sensors have a different autoexposure area and thus
901 	   different avg_lum values for the same picture brightness */
902 	if (sensor_data[sd->sensor].flags & F_SIF) {
903 		deadzone = 500;
904 		/* SIF sensors tend to overexpose, so keep this small */
905 		desired_avg_lum = 5000;
906 	} else {
907 		deadzone = 1500;
908 		desired_avg_lum = 13000;
909 	}
910 
911 	if (sd->brightness)
912 		desired_avg_lum = sd->brightness->val * desired_avg_lum / 127;
913 
914 	if (gspca_dev->exposure->maximum < 500) {
915 		if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
916 				desired_avg_lum, deadzone))
917 			sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
918 	} else {
919 		int gain_knee = gspca_dev->gain->maximum * 9 / 10;
920 		if (gspca_expo_autogain(gspca_dev, avg_lum, desired_avg_lum,
921 				deadzone, gain_knee, sd->exposure_knee))
922 			sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
923 	}
924 }
925 
926 /* this function is called at probe time */
927 static int sd_config(struct gspca_dev *gspca_dev,
928 			const struct usb_device_id *id)
929 {
930 	struct sd *sd = (struct sd *) gspca_dev;
931 	struct cam *cam;
932 
933 	reg_r(gspca_dev, 0x00);
934 	if (gspca_dev->usb_buf[0] != 0x10)
935 		return -ENODEV;
936 
937 	/* copy the webcam info from the device id */
938 	sd->sensor = id->driver_info >> 8;
939 	sd->bridge = id->driver_info & 0xff;
940 
941 	cam = &gspca_dev->cam;
942 	if (!(sensor_data[sd->sensor].flags & F_SIF)) {
943 		cam->cam_mode = vga_mode;
944 		cam->nmodes = ARRAY_SIZE(vga_mode);
945 	} else {
946 		cam->cam_mode = sif_mode;
947 		cam->nmodes = ARRAY_SIZE(sif_mode);
948 	}
949 	cam->npkt = 36;			/* 36 packets per ISOC message */
950 
951 	return 0;
952 }
953 
954 /* this function is called at probe and resume time */
955 static int sd_init(struct gspca_dev *gspca_dev)
956 {
957 	const __u8 stop = 0x09; /* Disable stream turn of LED */
958 
959 	reg_w(gspca_dev, 0x01, &stop, 1);
960 
961 	return gspca_dev->usb_err;
962 }
963 
964 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
965 {
966 	struct gspca_dev *gspca_dev =
967 		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
968 	struct sd *sd = (struct sd *)gspca_dev;
969 
970 	gspca_dev->usb_err = 0;
971 
972 	if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
973 		/* when switching to autogain set defaults to make sure
974 		   we are on a valid point of the autogain gain /
975 		   exposure knee graph, and give this change time to
976 		   take effect before doing autogain. */
977 		gspca_dev->gain->val = gspca_dev->gain->default_value;
978 		gspca_dev->exposure->val = gspca_dev->exposure->default_value;
979 		sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
980 	}
981 
982 	if (!gspca_dev->streaming)
983 		return 0;
984 
985 	switch (ctrl->id) {
986 	case V4L2_CID_BRIGHTNESS:
987 		setbrightness(gspca_dev);
988 		break;
989 	case V4L2_CID_AUTOGAIN:
990 		if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
991 			setexposure(gspca_dev);
992 		if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
993 			setgain(gspca_dev);
994 		break;
995 	case V4L2_CID_POWER_LINE_FREQUENCY:
996 		setfreq(gspca_dev);
997 		break;
998 	default:
999 		return -EINVAL;
1000 	}
1001 	return gspca_dev->usb_err;
1002 }
1003 
1004 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1005 	.s_ctrl = sd_s_ctrl,
1006 };
1007 
1008 /* this function is called at probe time */
1009 static int sd_init_controls(struct gspca_dev *gspca_dev)
1010 {
1011 	struct sd *sd = (struct sd *) gspca_dev;
1012 	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1013 
1014 	gspca_dev->vdev.ctrl_handler = hdl;
1015 	v4l2_ctrl_handler_init(hdl, 5);
1016 
1017 	if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630 ||
1018 	    sd->sensor == SENSOR_PAS106 || sd->sensor == SENSOR_PAS202)
1019 		sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1020 					V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1021 
1022 	/* Gain range is sensor dependent */
1023 	switch (sd->sensor) {
1024 	case SENSOR_OV6650:
1025 	case SENSOR_PAS106:
1026 	case SENSOR_PAS202:
1027 		gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1028 					V4L2_CID_GAIN, 0, 31, 1, 15);
1029 		break;
1030 	case SENSOR_OV7630:
1031 		gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1032 					V4L2_CID_GAIN, 0, 47, 1, 31);
1033 		break;
1034 	case SENSOR_HV7131D:
1035 		gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1036 					V4L2_CID_GAIN, 0, 63, 1, 31);
1037 		break;
1038 	case SENSOR_TAS5110C:
1039 	case SENSOR_TAS5110D:
1040 	case SENSOR_TAS5130CXX:
1041 		gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1042 					V4L2_CID_GAIN, 0, 255, 1, 127);
1043 		break;
1044 	default:
1045 		if (sd->bridge == BRIDGE_103) {
1046 			gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1047 						V4L2_CID_GAIN, 0, 127, 1, 63);
1048 		} else {
1049 			gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1050 						V4L2_CID_GAIN, 0, 15, 1, 7);
1051 		}
1052 	}
1053 
1054 	/* Exposure range is sensor dependent, and not all have exposure */
1055 	switch (sd->sensor) {
1056 	case SENSOR_HV7131D:
1057 		gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1058 					V4L2_CID_EXPOSURE, 0, 8191, 1, 482);
1059 		sd->exposure_knee = 964;
1060 		break;
1061 	case SENSOR_OV6650:
1062 	case SENSOR_OV7630:
1063 	case SENSOR_PAS106:
1064 	case SENSOR_PAS202:
1065 		gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1066 					V4L2_CID_EXPOSURE, 0, 1023, 1, 66);
1067 		sd->exposure_knee = 200;
1068 		break;
1069 	case SENSOR_TAS5110C:
1070 	case SENSOR_TAS5110D:
1071 		gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1072 					V4L2_CID_EXPOSURE, 2, 15, 1, 2);
1073 		break;
1074 	}
1075 
1076 	if (gspca_dev->exposure) {
1077 		gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1078 						V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1079 	}
1080 
1081 	if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630)
1082 		sd->plfreq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1083 			V4L2_CID_POWER_LINE_FREQUENCY,
1084 			V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
1085 			V4L2_CID_POWER_LINE_FREQUENCY_DISABLED);
1086 
1087 	if (hdl->error) {
1088 		pr_err("Could not initialize controls\n");
1089 		return hdl->error;
1090 	}
1091 
1092 	if (gspca_dev->autogain)
1093 		v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
1094 
1095 	return 0;
1096 }
1097 
1098 /* -- start the camera -- */
1099 static int sd_start(struct gspca_dev *gspca_dev)
1100 {
1101 	struct sd *sd = (struct sd *) gspca_dev;
1102 	struct cam *cam = &gspca_dev->cam;
1103 	int i, mode;
1104 	__u8 regs[0x31];
1105 
1106 	mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
1107 	/* Copy registers 0x01 - 0x19 from the template */
1108 	memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1109 	/* Set the mode */
1110 	regs[0x18] |= mode << 4;
1111 
1112 	/* Set bridge gain to 1.0 */
1113 	if (sd->bridge == BRIDGE_103) {
1114 		regs[0x05] = 0x20; /* Red */
1115 		regs[0x06] = 0x20; /* Green */
1116 		regs[0x07] = 0x20; /* Blue */
1117 	} else {
1118 		regs[0x10] = 0x00; /* Red and blue */
1119 		regs[0x11] = 0x00; /* Green */
1120 	}
1121 
1122 	/* Setup pixel numbers and auto exposure window */
1123 	if (sensor_data[sd->sensor].flags & F_SIF) {
1124 		regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1125 		regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1126 		regs[0x1c] = 0x02; /* AE H-start 64 */
1127 		regs[0x1d] = 0x02; /* AE V-start 64 */
1128 		regs[0x1e] = 0x09; /* AE H-end 288 */
1129 		regs[0x1f] = 0x07; /* AE V-end 224 */
1130 	} else {
1131 		regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1132 		regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
1133 		regs[0x1c] = 0x05; /* AE H-start 160 */
1134 		regs[0x1d] = 0x03; /* AE V-start 96 */
1135 		regs[0x1e] = 0x0f; /* AE H-end 480 */
1136 		regs[0x1f] = 0x0c; /* AE V-end 384 */
1137 	}
1138 
1139 	/* Setup the gamma table (only used with the sn9c103 bridge) */
1140 	for (i = 0; i < 16; i++)
1141 		regs[0x20 + i] = i * 16;
1142 	regs[0x20 + i] = 255;
1143 
1144 	/* Special cases where some regs depend on mode or bridge */
1145 	switch (sd->sensor) {
1146 	case SENSOR_TAS5130CXX:
1147 		/* FIXME / TESTME
1148 		   probably not mode specific at all most likely the upper
1149 		   nibble of 0x19 is exposure (clock divider) just as with
1150 		   the tas5110, we need someone to test this. */
1151 		regs[0x19] = mode ? 0x23 : 0x43;
1152 		break;
1153 	case SENSOR_OV7630:
1154 		/* FIXME / TESTME for some reason with the 101/102 bridge the
1155 		   clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1156 		   Also the hstart needs to go from 1 to 2 when using a 103,
1157 		   which is likely related. This does not seem right. */
1158 		if (sd->bridge == BRIDGE_103) {
1159 			regs[0x01] = 0x44; /* Select 24 Mhz clock */
1160 			regs[0x12] = 0x02; /* Set hstart to 2 */
1161 		}
1162 		break;
1163 	case SENSOR_PAS202:
1164 		/* For some unknown reason we need to increase hstart by 1 on
1165 		   the sn9c103, otherwise we get wrong colors (bayer shift). */
1166 		if (sd->bridge == BRIDGE_103)
1167 			regs[0x12] += 1;
1168 		break;
1169 	}
1170 	/* Disable compression when the raw bayer format has been selected */
1171 	if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
1172 		regs[0x18] &= ~0x80;
1173 
1174 	/* Vga mode emulation on SIF sensor? */
1175 	if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
1176 		regs[0x12] += 16;	/* hstart adjust */
1177 		regs[0x13] += 24;	/* vstart adjust */
1178 		regs[0x15]  = 320 / 16; /* hsize */
1179 		regs[0x16]  = 240 / 16; /* vsize */
1180 	}
1181 
1182 	/* reg 0x01 bit 2 video transfert on */
1183 	reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1184 	/* reg 0x17 SensorClk enable inv Clk 0x60 */
1185 	reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1186 	/* Set the registers from the template */
1187 	reg_w(gspca_dev, 0x01, &regs[0x01],
1188 	      (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
1189 
1190 	/* Init the sensor */
1191 	i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1192 			sensor_data[sd->sensor].sensor_init_size);
1193 
1194 	/* Mode / bridge specific sensor setup */
1195 	switch (sd->sensor) {
1196 	case SENSOR_PAS202: {
1197 		const __u8 i2cpclockdiv[] =
1198 			{0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1199 		/* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1200 		if (mode)
1201 			i2c_w(gspca_dev, i2cpclockdiv);
1202 		break;
1203 	    }
1204 	case SENSOR_OV7630:
1205 		/* FIXME / TESTME We should be able to handle this identical
1206 		   for the 101/102 and the 103 case */
1207 		if (sd->bridge == BRIDGE_103) {
1208 			const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1209 					     0x80, 0x00, 0x00, 0x00, 0x10 };
1210 			i2c_w(gspca_dev, i2c);
1211 		}
1212 		break;
1213 	}
1214 	/* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
1215 	reg_w(gspca_dev, 0x15, &regs[0x15], 2);
1216 	/* compression register */
1217 	reg_w(gspca_dev, 0x18, &regs[0x18], 1);
1218 	/* H_start */
1219 	reg_w(gspca_dev, 0x12, &regs[0x12], 1);
1220 	/* V_START */
1221 	reg_w(gspca_dev, 0x13, &regs[0x13], 1);
1222 	/* reset 0x17 SensorClk enable inv Clk 0x60 */
1223 				/*fixme: ov7630 [17]=68 8f (+20 if 102)*/
1224 	reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1225 	/*MCKSIZE ->3 */	/*fixme: not ov7630*/
1226 	reg_w(gspca_dev, 0x19, &regs[0x19], 1);
1227 	/* AE_STRX AE_STRY AE_ENDX AE_ENDY */
1228 	reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
1229 	/* Enable video transfert */
1230 	reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1231 	/* Compression */
1232 	reg_w(gspca_dev, 0x18, &regs[0x18], 2);
1233 	msleep(20);
1234 
1235 	sd->reg11 = -1;
1236 
1237 	setgain(gspca_dev);
1238 	setbrightness(gspca_dev);
1239 	setexposure(gspca_dev);
1240 	setfreq(gspca_dev);
1241 
1242 	sd->frames_to_drop = 0;
1243 	sd->autogain_ignore_frames = 0;
1244 	gspca_dev->exp_too_high_cnt = 0;
1245 	gspca_dev->exp_too_low_cnt = 0;
1246 	atomic_set(&sd->avg_lum, -1);
1247 	return gspca_dev->usb_err;
1248 }
1249 
1250 static void sd_stopN(struct gspca_dev *gspca_dev)
1251 {
1252 	sd_init(gspca_dev);
1253 }
1254 
1255 static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
1256 {
1257 	struct sd *sd = (struct sd *) gspca_dev;
1258 	int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
1259 
1260 	/* frames start with:
1261 	 *	ff ff 00 c4 c4 96	synchro
1262 	 *	00		(unknown)
1263 	 *	xx		(frame sequence / size / compression)
1264 	 *	(xx)		(idem - extra byte for sn9c103)
1265 	 *	ll mm		brightness sum inside auto exposure
1266 	 *	ll mm		brightness sum outside auto exposure
1267 	 *	(xx xx xx xx xx)	audio values for snc103
1268 	 */
1269 	for (i = 0; i < len; i++) {
1270 		switch (sd->header_read) {
1271 		case 0:
1272 			if (data[i] == 0xff)
1273 				sd->header_read++;
1274 			break;
1275 		case 1:
1276 			if (data[i] == 0xff)
1277 				sd->header_read++;
1278 			else
1279 				sd->header_read = 0;
1280 			break;
1281 		case 2:
1282 			if (data[i] == 0x00)
1283 				sd->header_read++;
1284 			else if (data[i] != 0xff)
1285 				sd->header_read = 0;
1286 			break;
1287 		case 3:
1288 			if (data[i] == 0xc4)
1289 				sd->header_read++;
1290 			else if (data[i] == 0xff)
1291 				sd->header_read = 1;
1292 			else
1293 				sd->header_read = 0;
1294 			break;
1295 		case 4:
1296 			if (data[i] == 0xc4)
1297 				sd->header_read++;
1298 			else if (data[i] == 0xff)
1299 				sd->header_read = 1;
1300 			else
1301 				sd->header_read = 0;
1302 			break;
1303 		case 5:
1304 			if (data[i] == 0x96)
1305 				sd->header_read++;
1306 			else if (data[i] == 0xff)
1307 				sd->header_read = 1;
1308 			else
1309 				sd->header_read = 0;
1310 			break;
1311 		default:
1312 			sd->header[sd->header_read - 6] = data[i];
1313 			sd->header_read++;
1314 			if (sd->header_read == header_size) {
1315 				sd->header_read = 0;
1316 				return data + i + 1;
1317 			}
1318 		}
1319 	}
1320 	return NULL;
1321 }
1322 
1323 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1324 			u8 *data,			/* isoc packet */
1325 			int len)			/* iso packet length */
1326 {
1327 	int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1328 	struct sd *sd = (struct sd *) gspca_dev;
1329 	struct cam *cam = &gspca_dev->cam;
1330 	u8 *sof;
1331 
1332 	sof = find_sof(gspca_dev, data, len);
1333 	if (sof) {
1334 		if (sd->bridge == BRIDGE_103) {
1335 			fr_h_sz = 18;
1336 			lum_offset = 3;
1337 		} else {
1338 			fr_h_sz = 12;
1339 			lum_offset = 2;
1340 		}
1341 
1342 		len_after_sof = len - (sof - data);
1343 		len = (sof - data) - fr_h_sz;
1344 		if (len < 0)
1345 			len = 0;
1346 	}
1347 
1348 	if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1349 		/* In raw mode we sometimes get some garbage after the frame
1350 		   ignore this */
1351 		int used;
1352 		int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1353 
1354 		used = gspca_dev->image_len;
1355 		if (used + len > size)
1356 			len = size - used;
1357 	}
1358 
1359 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1360 
1361 	if (sof) {
1362 		int  lum = sd->header[lum_offset] +
1363 			  (sd->header[lum_offset + 1] << 8);
1364 
1365 		/* When exposure changes midway a frame we
1366 		   get a lum of 0 in this case drop 2 frames
1367 		   as the frames directly after an exposure
1368 		   change have an unstable image. Sometimes lum
1369 		   *really* is 0 (cam used in low light with
1370 		   low exposure setting), so do not drop frames
1371 		   if the previous lum was 0 too. */
1372 		if (lum == 0 && sd->prev_avg_lum != 0) {
1373 			lum = -1;
1374 			sd->frames_to_drop = 2;
1375 			sd->prev_avg_lum = 0;
1376 		} else
1377 			sd->prev_avg_lum = lum;
1378 		atomic_set(&sd->avg_lum, lum);
1379 
1380 		if (sd->frames_to_drop)
1381 			sd->frames_to_drop--;
1382 		else
1383 			gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1384 
1385 		gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1386 	}
1387 }
1388 
1389 #if IS_ENABLED(CONFIG_INPUT)
1390 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1391 			u8 *data,		/* interrupt packet data */
1392 			int len)		/* interrupt packet length */
1393 {
1394 	int ret = -EINVAL;
1395 
1396 	if (len == 1 && data[0] == 1) {
1397 		input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1398 		input_sync(gspca_dev->input_dev);
1399 		input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1400 		input_sync(gspca_dev->input_dev);
1401 		ret = 0;
1402 	}
1403 
1404 	return ret;
1405 }
1406 #endif
1407 
1408 /* sub-driver description */
1409 static const struct sd_desc sd_desc = {
1410 	.name = MODULE_NAME,
1411 	.config = sd_config,
1412 	.init = sd_init,
1413 	.init_controls = sd_init_controls,
1414 	.start = sd_start,
1415 	.stopN = sd_stopN,
1416 	.pkt_scan = sd_pkt_scan,
1417 	.dq_callback = do_autogain,
1418 #if IS_ENABLED(CONFIG_INPUT)
1419 	.int_pkt_scan = sd_int_pkt_scan,
1420 #endif
1421 };
1422 
1423 /* -- module initialisation -- */
1424 #define SB(sensor, bridge) \
1425 	.driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1426 
1427 
1428 static const struct usb_device_id device_table[] = {
1429 	{USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1430 	{USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1431 	{USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1432 	{USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1433 	{USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1434 	{USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1435 	{USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1436 #if !IS_ENABLED(CONFIG_USB_SN9C102)
1437 	{USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1438 	{USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1439 #endif
1440 	{USB_DEVICE(0x0c45, 0x6027), SB(OV7630, 101)}, /* Genius Eye 310 */
1441 	{USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1442 	{USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1443 	{USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1444 	/* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
1445 	{USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1446 	{USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1447 	{USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1448 	/* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1449 	/* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
1450 	{USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
1451 	{USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
1452 	/* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
1453 	{USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1454 	{USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
1455 	{USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
1456 	{USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1457 	{USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1458 	{}
1459 };
1460 MODULE_DEVICE_TABLE(usb, device_table);
1461 
1462 /* -- device connect -- */
1463 static int sd_probe(struct usb_interface *intf,
1464 			const struct usb_device_id *id)
1465 {
1466 	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1467 				THIS_MODULE);
1468 }
1469 
1470 static struct usb_driver sd_driver = {
1471 	.name = MODULE_NAME,
1472 	.id_table = device_table,
1473 	.probe = sd_probe,
1474 	.disconnect = gspca_disconnect,
1475 #ifdef CONFIG_PM
1476 	.suspend = gspca_suspend,
1477 	.resume = gspca_resume,
1478 	.reset_resume = gspca_resume,
1479 #endif
1480 };
1481 
1482 module_usb_driver(sd_driver);
1483