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