?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB: gspca_sonixb: Add support for camera button
[firewire-audio.git] / drivers / media / video / gspca / sonixb.c
blob28843a6a6fea0d7ee78185a2738097059242fbed
1 /*
2 * sonix sn9c102 (bayer) library
3 * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
4 * Add Pas106 Stefano Mozzi (C) 2004
5 *
6 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
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 0x10 high nibble red gain low nibble blue gain
27 0x11 low nibble green gain
28 0x12 hstart
29 0x13 vstart
30 0x15 hsize (hsize = register-value * 16)
31 0x16 vsize (vsize = register-value * 16)
32 0x17 bit 0 toggle compression quality (according to sn9c102 driver)
33 0x18 bit 7 enables compression, bit 4-5 set image down scaling:
34 00 scale 1, 01 scale 1/2, 10, scale 1/4
35 0x19 high-nibble is sensor clock divider, changes exposure on sensors which
36 use a clock generated by the bridge. Some sensors have their own clock.
37 0x1c auto_exposure area (for avg_lum) startx (startx = register-value * 32)
38 0x1d auto_exposure area (for avg_lum) starty (starty = register-value * 32)
39 0x1e auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
40 0x1f auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
41 */
42
43 #define MODULE_NAME "sonixb"
44
45 #include <linux/input.h>
46 #include "gspca.h"
47
48 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
49 MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
50 MODULE_LICENSE("GPL");
51
52 /* specific webcam descriptor */
53 struct sd {
54 struct gspca_dev gspca_dev; /* !! must be the first item */
55 atomic_t avg_lum;
56 int prev_avg_lum;
57
58 unsigned char gain;
59 unsigned char exposure;
60 unsigned char brightness;
61 unsigned char autogain;
62 unsigned char autogain_ignore_frames;
63 unsigned char frames_to_drop;
64 unsigned char freq; /* light freq filter setting */
65
66 __u8 bridge; /* Type of bridge */
67 #define BRIDGE_101 0
68 #define BRIDGE_102 0 /* We make no difference between 101 and 102 */
69 #define BRIDGE_103 1
70
71 __u8 sensor; /* Type of image sensor chip */
72 #define SENSOR_HV7131R 0
73 #define SENSOR_OV6650 1
74 #define SENSOR_OV7630 2
75 #define SENSOR_PAS106 3
76 #define SENSOR_PAS202 4
77 #define SENSOR_TAS5110C 5
78 #define SENSOR_TAS5110D 6
79 #define SENSOR_TAS5130CXX 7
80 __u8 reg11;
81 };
82
83 typedef const __u8 sensor_init_t[8];
84
85 struct sensor_data {
86 const __u8 *bridge_init[2];
87 int bridge_init_size[2];
88 sensor_init_t *sensor_init;
89 int sensor_init_size;
90 sensor_init_t *sensor_bridge_init[2];
91 int sensor_bridge_init_size[2];
92 int flags;
93 unsigned ctrl_dis;
94 __u8 sensor_addr;
95 };
96
97 /* sensor_data flags */
98 #define F_GAIN 0x01 /* has gain */
99 #define F_SIF 0x02 /* sif or vga */
100
101 /* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
102 #define MODE_RAW 0x10 /* raw bayer mode */
103 #define MODE_REDUCED_SIF 0x20 /* vga mode (320x240 / 160x120) on sif cam */
104
105 /* ctrl_dis helper macros */
106 #define NO_EXPO ((1 << EXPOSURE_IDX) | (1 << AUTOGAIN_IDX))
107 #define NO_FREQ (1 << FREQ_IDX)
108 #define NO_BRIGHTNESS (1 << BRIGHTNESS_IDX)
109
110 #define COMP2 0x8f
111 #define COMP 0xc7 /* 0x87 //0x07 */
112 #define COMP1 0xc9 /* 0x89 //0x09 */
113
114 #define MCK_INIT 0x63
115 #define MCK_INIT1 0x20 /*fixme: Bayer - 0x50 for JPEG ??*/
116
117 #define SYS_CLK 0x04
118
119 #define SENS(bridge_1, bridge_3, sensor, sensor_1, \
120 sensor_3, _flags, _ctrl_dis, _sensor_addr) \
121 { \
122 .bridge_init = { bridge_1, bridge_3 }, \
123 .bridge_init_size = { sizeof(bridge_1), sizeof(bridge_3) }, \
124 .sensor_init = sensor, \
125 .sensor_init_size = sizeof(sensor), \
126 .sensor_bridge_init = { sensor_1, sensor_3,}, \
127 .sensor_bridge_init_size = { sizeof(sensor_1), sizeof(sensor_3)}, \
128 .flags = _flags, .ctrl_dis = _ctrl_dis, .sensor_addr = _sensor_addr \
129 }
130
131 /* We calculate the autogain at the end of the transfer of a frame, at this
132 moment a frame with the old settings is being transmitted, and a frame is
133 being captured with the old settings. So if we adjust the autogain we must
134 ignore atleast the 2 next frames for the new settings to come into effect
135 before doing any other adjustments */
136 #define AUTOGAIN_IGNORE_FRAMES 3
137
138 /* V4L2 controls supported by the driver */
139 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
140 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
141 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
142 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
143 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
144 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
145 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
146 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
147 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
148 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
149
150 static const struct ctrl sd_ctrls[] = {
151 #define BRIGHTNESS_IDX 0
152 {
153 {
154 .id = V4L2_CID_BRIGHTNESS,
155 .type = V4L2_CTRL_TYPE_INTEGER,
156 .name = "Brightness",
157 .minimum = 0,
158 .maximum = 255,
159 .step = 1,
160 #define BRIGHTNESS_DEF 127
161 .default_value = BRIGHTNESS_DEF,
162 },
163 .set = sd_setbrightness,
164 .get = sd_getbrightness,
165 },
166 #define GAIN_IDX 1
167 {
168 {
169 .id = V4L2_CID_GAIN,
170 .type = V4L2_CTRL_TYPE_INTEGER,
171 .name = "Gain",
172 .minimum = 0,
173 .maximum = 255,
174 .step = 1,
175 #define GAIN_DEF 127
176 #define GAIN_KNEE 200
177 .default_value = GAIN_DEF,
178 },
179 .set = sd_setgain,
180 .get = sd_getgain,
181 },
182 #define EXPOSURE_IDX 2
183 {
184 {
185 .id = V4L2_CID_EXPOSURE,
186 .type = V4L2_CTRL_TYPE_INTEGER,
187 .name = "Exposure",
188 #define EXPOSURE_DEF 16 /* 32 ms / 30 fps */
189 #define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
190 .minimum = 0,
191 .maximum = 255,
192 .step = 1,
193 .default_value = EXPOSURE_DEF,
194 .flags = 0,
195 },
196 .set = sd_setexposure,
197 .get = sd_getexposure,
198 },
199 #define AUTOGAIN_IDX 3
200 {
201 {
202 .id = V4L2_CID_AUTOGAIN,
203 .type = V4L2_CTRL_TYPE_BOOLEAN,
204 .name = "Automatic Gain (and Exposure)",
205 .minimum = 0,
206 .maximum = 1,
207 .step = 1,
208 #define AUTOGAIN_DEF 1
209 .default_value = AUTOGAIN_DEF,
210 .flags = 0,
211 },
212 .set = sd_setautogain,
213 .get = sd_getautogain,
214 },
215 #define FREQ_IDX 4
216 {
217 {
218 .id = V4L2_CID_POWER_LINE_FREQUENCY,
219 .type = V4L2_CTRL_TYPE_MENU,
220 .name = "Light frequency filter",
221 .minimum = 0,
222 .maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
223 .step = 1,
224 #define FREQ_DEF 1
225 .default_value = FREQ_DEF,
226 },
227 .set = sd_setfreq,
228 .get = sd_getfreq,
229 },
230 };
231
232 static const struct v4l2_pix_format vga_mode[] = {
233 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
234 .bytesperline = 160,
235 .sizeimage = 160 * 120,
236 .colorspace = V4L2_COLORSPACE_SRGB,
237 .priv = 2 | MODE_RAW},
238 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
239 .bytesperline = 160,
240 .sizeimage = 160 * 120 * 5 / 4,
241 .colorspace = V4L2_COLORSPACE_SRGB,
242 .priv = 2},
243 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
244 .bytesperline = 320,
245 .sizeimage = 320 * 240 * 5 / 4,
246 .colorspace = V4L2_COLORSPACE_SRGB,
247 .priv = 1},
248 {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
249 .bytesperline = 640,
250 .sizeimage = 640 * 480 * 5 / 4,
251 .colorspace = V4L2_COLORSPACE_SRGB,
252 .priv = 0},
253 };
254 static const struct v4l2_pix_format sif_mode[] = {
255 {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
256 .bytesperline = 160,
257 .sizeimage = 160 * 120,
258 .colorspace = V4L2_COLORSPACE_SRGB,
259 .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
260 {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
261 .bytesperline = 160,
262 .sizeimage = 160 * 120 * 5 / 4,
263 .colorspace = V4L2_COLORSPACE_SRGB,
264 .priv = 1 | MODE_REDUCED_SIF},
265 {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
266 .bytesperline = 176,
267 .sizeimage = 176 * 144,
268 .colorspace = V4L2_COLORSPACE_SRGB,
269 .priv = 1 | MODE_RAW},
270 {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
271 .bytesperline = 176,
272 .sizeimage = 176 * 144 * 5 / 4,
273 .colorspace = V4L2_COLORSPACE_SRGB,
274 .priv = 1},
275 {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
276 .bytesperline = 320,
277 .sizeimage = 320 * 240 * 5 / 4,
278 .colorspace = V4L2_COLORSPACE_SRGB,
279 .priv = 0 | MODE_REDUCED_SIF},
280 {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
281 .bytesperline = 352,
282 .sizeimage = 352 * 288 * 5 / 4,
283 .colorspace = V4L2_COLORSPACE_SRGB,
284 .priv = 0},
285 };
286
287 static const __u8 initHv7131[] = {
288 0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
289 0x00, 0x00,
290 0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
291 0x28, 0x1e, 0x60, 0x8a, 0x20,
292 0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c
293 };
294 static const __u8 hv7131_sensor_init[][8] = {
295 {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
296 {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
297 {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
298 {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
299 {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
300 };
301 static const __u8 initOv6650[] = {
302 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
303 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
304 0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
305 0x10, 0x1d, 0x10, 0x02, 0x02, 0x09, 0x07
306 };
307 static const __u8 ov6650_sensor_init[][8] =
308 {
309 /* Bright, contrast, etc are set through SCBB interface.
310 * AVCAP on win2 do not send any data on this controls. */
311 /* Anyway, some registers appears to alter bright and constrat */
312
313 /* Reset sensor */
314 {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
315 /* Set clock register 0x11 low nibble is clock divider */
316 {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
317 /* Next some unknown stuff */
318 {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
319 /* {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
320 * THIS SET GREEN SCREEN
321 * (pixels could be innverted in decode kind of "brg",
322 * but blue wont be there. Avoid this data ... */
323 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
324 {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
325 {0xa0, 0x60, 0x30, 0x3d, 0x0A, 0xd8, 0xa4, 0x10},
326 /* Enable rgb brightness control */
327 {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
328 /* HDG: Note windows uses the line below, which sets both register 0x60
329 and 0x61 I believe these registers of the ov6650 are identical as
330 those of the ov7630, because if this is true the windows settings
331 add a bit additional red gain and a lot additional blue gain, which
332 matches my findings that the windows settings make blue much too
333 blue and red a little too red.
334 {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
335 /* Some more unknown stuff */
336 {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
337 {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
338 };
339
340 static const __u8 initOv7630[] = {
341 0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
342 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
343 0x00, 0x01, 0x01, 0x0a, /* r11 .. r14 */
344 0x28, 0x1e, /* H & V sizes r15 .. r16 */
345 0x68, COMP2, MCK_INIT1, /* r17 .. r19 */
346 0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c /* r1a .. r1f */
347 };
348 static const __u8 initOv7630_3[] = {
349 0x44, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0x80, /* r01 .. r08 */
350 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, /* r09 .. r10 */
351 0x00, 0x02, 0x01, 0x0a, /* r11 .. r14 */
352 0x28, 0x1e, /* H & V sizes r15 .. r16 */
353 0x68, 0x8f, MCK_INIT1, /* r17 .. r19 */
354 0x1d, 0x10, 0x02, 0x03, 0x0f, 0x0c, 0x00, /* r1a .. r20 */
355 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, /* r21 .. r28 */
356 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xff /* r29 .. r30 */
357 };
358 static const __u8 ov7630_sensor_init[][8] = {
359 {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
360 {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
361 /* {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10}, jfm */
362 {0xd0, 0x21, 0x12, 0x1c, 0x00, 0x80, 0x34, 0x10}, /* jfm */
363 {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
364 {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
365 {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
366 {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
367 {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
368 {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
369 {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
370 {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
371 /* {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10}, * jfm */
372 {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
373 {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
374 {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
375 {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
376 {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
377 {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
378 };
379
380 static const __u8 ov7630_sensor_init_3[][8] = {
381 {0xa0, 0x21, 0x13, 0x80, 0x00, 0x00, 0x00, 0x10},
382 };
383
384 static const __u8 initPas106[] = {
385 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
386 0x00, 0x00,
387 0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
388 0x16, 0x12, 0x24, COMP1, MCK_INIT1,
389 0x18, 0x10, 0x02, 0x02, 0x09, 0x07
390 };
391 /* compression 0x86 mckinit1 0x2b */
392 static const __u8 pas106_sensor_init[][8] = {
393 /* Pixel Clock Divider 6 */
394 { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
395 /* Frame Time MSB (also seen as 0x12) */
396 { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
397 /* Frame Time LSB (also seen as 0x05) */
398 { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
399 /* Shutter Time Line Offset (also seen as 0x6d) */
400 { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
401 /* Shutter Time Pixel Offset (also seen as 0xb1) */
402 { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
403 /* Black Level Subtract Sign (also seen 0x00) */
404 { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
405 /* Black Level Subtract Level (also seen 0x01) */
406 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
407 { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
408 /* Color Gain B Pixel 5 a */
409 { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
410 /* Color Gain G1 Pixel 1 5 */
411 { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
412 /* Color Gain G2 Pixel 1 0 5 */
413 { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
414 /* Color Gain R Pixel 3 1 */
415 { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
416 /* Color GainH Pixel */
417 { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
418 /* Global Gain */
419 { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
420 /* Contrast */
421 { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
422 /* H&V synchro polarity */
423 { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
424 /* ?default */
425 { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
426 /* DAC scale */
427 { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
428 /* ?default */
429 { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
430 /* Validate Settings */
431 { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
432 };
433
434 static const __u8 initPas202[] = {
435 0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
436 0x00, 0x00,
437 0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
438 0x28, 0x1e, 0x28, 0x89, 0x20,
439 0x00, 0x00, 0x02, 0x03, 0x0f, 0x0c
440 };
441 static const __u8 pas202_sensor_init[][8] = {
442 {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10},
443 {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
444 {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
445 {0xd0, 0x40, 0x0C, 0x00, 0x0C, 0x00, 0x32, 0x10},
446 {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
447 {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
448 {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
449 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
450 {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
451 {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
452 {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x10},
453 {0xb0, 0x40, 0x0e, 0x00, 0x3d, 0x00, 0x63, 0x10},
454
455 {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
456 {0xa0, 0x40, 0x10, 0x08, 0x3d, 0x00, 0x63, 0x15},
457 {0xa0, 0x40, 0x02, 0x04, 0x3d, 0x00, 0x63, 0x16},
458 {0xa0, 0x40, 0x11, 0x01, 0x3d, 0x00, 0x63, 0x16},
459 {0xb0, 0x40, 0x0e, 0x00, 0x31, 0x00, 0x63, 0x16},
460 {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
461 {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15},
462 {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16},
463 };
464
465 static const __u8 initTas5110c[] = {
466 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
467 0x00, 0x00,
468 0x00, 0x01, 0x00, 0x45, 0x09, 0x0a,
469 0x16, 0x12, 0x60, 0x86, 0x2b,
470 0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
471 };
472 /* Same as above, except a different hstart */
473 static const __u8 initTas5110d[] = {
474 0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
475 0x00, 0x00,
476 0x00, 0x01, 0x00, 0x41, 0x09, 0x0a,
477 0x16, 0x12, 0x60, 0x86, 0x2b,
478 0x14, 0x0a, 0x02, 0x02, 0x09, 0x07
479 };
480 static const __u8 tas5110_sensor_init[][8] = {
481 {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
482 {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
483 {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17},
484 };
485
486 static const __u8 initTas5130[] = {
487 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
488 0x00, 0x00,
489 0x00, 0x01, 0x00, 0x68, 0x0c, 0x0a,
490 0x28, 0x1e, 0x60, COMP, MCK_INIT,
491 0x18, 0x10, 0x04, 0x03, 0x11, 0x0c
492 };
493 static const __u8 tas5130_sensor_init[][8] = {
494 /* {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
495 * shutter 0x47 short exposure? */
496 {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
497 /* shutter 0x01 long exposure */
498 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
499 };
500
501 static struct sensor_data sensor_data[] = {
502 SENS(initHv7131, NULL, hv7131_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ, 0),
503 SENS(initOv6650, NULL, ov6650_sensor_init, NULL, NULL, F_GAIN|F_SIF, 0, 0x60),
504 SENS(initOv7630, initOv7630_3, ov7630_sensor_init, NULL, ov7630_sensor_init_3,
505 F_GAIN, 0, 0x21),
506 SENS(initPas106, NULL, pas106_sensor_init, NULL, NULL, F_SIF, NO_EXPO|NO_FREQ,
507 0),
508 SENS(initPas202, initPas202, pas202_sensor_init, NULL, NULL, 0,
509 NO_EXPO|NO_FREQ, 0),
510 SENS(initTas5110c, NULL, tas5110_sensor_init, NULL, NULL, F_GAIN|F_SIF,
511 NO_BRIGHTNESS|NO_FREQ, 0),
512 SENS(initTas5110d, NULL, tas5110_sensor_init, NULL, NULL, F_GAIN|F_SIF,
513 NO_BRIGHTNESS|NO_FREQ, 0),
514 SENS(initTas5130, NULL, tas5130_sensor_init, NULL, NULL, 0, NO_EXPO|NO_FREQ,
515 0),
516 };
517
518 /* get one byte in gspca_dev->usb_buf */
519 static void reg_r(struct gspca_dev *gspca_dev,
520 __u16 value)
521 {
522 usb_control_msg(gspca_dev->dev,
523 usb_rcvctrlpipe(gspca_dev->dev, 0),
524 0, /* request */
525 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
526 value,
527 0, /* index */
528 gspca_dev->usb_buf, 1,
529 500);
530 }
531
532 static void reg_w(struct gspca_dev *gspca_dev,
533 __u16 value,
534 const __u8 *buffer,
535 int len)
536 {
537 #ifdef GSPCA_DEBUG
538 if (len > USB_BUF_SZ) {
539 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
540 return;
541 }
542 #endif
543 memcpy(gspca_dev->usb_buf, buffer, len);
544 usb_control_msg(gspca_dev->dev,
545 usb_sndctrlpipe(gspca_dev->dev, 0),
546 0x08, /* request */
547 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
548 value,
549 0, /* index */
550 gspca_dev->usb_buf, len,
551 500);
552 }
553
554 static int i2c_w(struct gspca_dev *gspca_dev, const __u8 *buffer)
555 {
556 int retry = 60;
557
558 /* is i2c ready */
559 reg_w(gspca_dev, 0x08, buffer, 8);
560 while (retry--) {
561 msleep(10);
562 reg_r(gspca_dev, 0x08);
563 if (gspca_dev->usb_buf[0] & 0x04) {
564 if (gspca_dev->usb_buf[0] & 0x08)
565 return -1;
566 return 0;
567 }
568 }
569 return -1;
570 }
571
572 static void i2c_w_vector(struct gspca_dev *gspca_dev,
573 const __u8 buffer[][8], int len)
574 {
575 for (;;) {
576 reg_w(gspca_dev, 0x08, *buffer, 8);
577 len -= 8;
578 if (len <= 0)
579 break;
580 buffer++;
581 }
582 }
583
584 static void setbrightness(struct gspca_dev *gspca_dev)
585 {
586 struct sd *sd = (struct sd *) gspca_dev;
587 __u8 value;
588
589 switch (sd->sensor) {
590 case SENSOR_OV6650:
591 case SENSOR_OV7630: {
592 __u8 i2cOV[] =
593 {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
594
595 /* change reg 0x06 */
596 i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
597 i2cOV[3] = sd->brightness;
598 if (i2c_w(gspca_dev, i2cOV) < 0)
599 goto err;
600 break;
601 }
602 case SENSOR_PAS106: {
603 __u8 i2c1[] =
604 {0xa1, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14};
605
606 i2c1[3] = sd->brightness >> 3;
607 i2c1[2] = 0x0e;
608 if (i2c_w(gspca_dev, i2c1) < 0)
609 goto err;
610 i2c1[3] = 0x01;
611 i2c1[2] = 0x13;
612 if (i2c_w(gspca_dev, i2c1) < 0)
613 goto err;
614 break;
615 }
616 case SENSOR_PAS202: {
617 /* __u8 i2cpexpo1[] =
618 {0xb0, 0x40, 0x04, 0x07, 0x2a, 0x00, 0x63, 0x16}; */
619 __u8 i2cpexpo[] =
620 {0xb0, 0x40, 0x0e, 0x01, 0xab, 0x00, 0x63, 0x16};
621 __u8 i2cp202[] =
622 {0xa0, 0x40, 0x10, 0x0e, 0x31, 0x00, 0x63, 0x15};
623 static __u8 i2cpdoit[] =
624 {0xa0, 0x40, 0x11, 0x01, 0x31, 0x00, 0x63, 0x16};
625
626 /* change reg 0x10 */
627 i2cpexpo[4] = 0xff - sd->brightness;
628 /* if(i2c_w(gspca_dev,i2cpexpo1) < 0)
629 goto err; */
630 /* if(i2c_w(gspca_dev,i2cpdoit) < 0)
631 goto err; */
632 if (i2c_w(gspca_dev, i2cpexpo) < 0)
633 goto err;
634 if (i2c_w(gspca_dev, i2cpdoit) < 0)
635 goto err;
636 i2cp202[3] = sd->brightness >> 3;
637 if (i2c_w(gspca_dev, i2cp202) < 0)
638 goto err;
639 if (i2c_w(gspca_dev, i2cpdoit) < 0)
640 goto err;
641 break;
642 }
643 case SENSOR_TAS5130CXX: {
644 __u8 i2c[] =
645 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
646
647 value = 0xff - sd->brightness;
648 i2c[4] = value;
649 PDEBUG(D_CONF, "brightness %d : %d", value, i2c[4]);
650 if (i2c_w(gspca_dev, i2c) < 0)
651 goto err;
652 break;
653 }
654 }
655 return;
656 err:
657 PDEBUG(D_ERR, "i2c error brightness");
658 }
659
660 static void setsensorgain(struct gspca_dev *gspca_dev)
661 {
662 struct sd *sd = (struct sd *) gspca_dev;
663 unsigned char gain = sd->gain;
664
665 switch (sd->sensor) {
666
667 case SENSOR_TAS5110C:
668 case SENSOR_TAS5110D: {
669 __u8 i2c[] =
670 {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
671
672 i2c[4] = 255 - gain;
673 if (i2c_w(gspca_dev, i2c) < 0)
674 goto err;
675 break;
676 }
677
678 case SENSOR_OV6650:
679 gain >>= 1;
680 /* fall thru */
681 case SENSOR_OV7630: {
682 __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
683
684 i2c[1] = sensor_data[sd->sensor].sensor_addr;
685 i2c[3] = gain >> 2;
686 if (i2c_w(gspca_dev, i2c) < 0)
687 goto err;
688 break;
689 }
690 }
691 return;
692 err:
693 PDEBUG(D_ERR, "i2c error gain");
694 }
695
696 static void setgain(struct gspca_dev *gspca_dev)
697 {
698 struct sd *sd = (struct sd *) gspca_dev;
699 __u8 gain;
700 __u8 rgb_value;
701
702 gain = sd->gain >> 4;
703
704 /* red and blue gain */
705 rgb_value = gain << 4 | gain;
706 reg_w(gspca_dev, 0x10, &rgb_value, 1);
707 /* green gain */
708 rgb_value = gain;
709 reg_w(gspca_dev, 0x11, &rgb_value, 1);
710
711 if (sensor_data[sd->sensor].flags & F_GAIN)
712 setsensorgain(gspca_dev);
713 }
714
715 static void setexposure(struct gspca_dev *gspca_dev)
716 {
717 struct sd *sd = (struct sd *) gspca_dev;
718
719 switch (sd->sensor) {
720 case SENSOR_TAS5110C:
721 case SENSOR_TAS5110D: {
722 __u8 reg;
723
724 /* register 19's high nibble contains the sn9c10x clock divider
725 The high nibble configures the no fps according to the
726 formula: 60 / high_nibble. With a maximum of 30 fps */
727 reg = 120 * sd->exposure / 1000;
728 if (reg < 2)
729 reg = 2;
730 else if (reg > 15)
731 reg = 15;
732 reg = (reg << 4) | 0x0b;
733 reg_w(gspca_dev, 0x19, &reg, 1);
734 break;
735 }
736 case SENSOR_OV6650:
737 case SENSOR_OV7630: {
738 /* The ov6650 / ov7630 have 2 registers which both influence
739 exposure, register 11, whose low nibble sets the nr off fps
740 according to: fps = 30 / (low_nibble + 1)
741
742 The fps configures the maximum exposure setting, but it is
743 possible to use less exposure then what the fps maximum
744 allows by setting register 10. register 10 configures the
745 actual exposure as quotient of the full exposure, with 0
746 being no exposure at all (not very usefull) and reg10_max
747 being max exposure possible at that framerate.
748
749 The code maps our 0 - 510 ms exposure ctrl to these 2
750 registers, trying to keep fps as high as possible.
751 */
752 __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
753 int reg10, reg11, reg10_max;
754
755 /* ov6645 datasheet says reg10_max is 9a, but that uses
756 tline * 2 * reg10 as formula for calculating texpo, the
757 ov6650 probably uses the same formula as the 7730 which uses
758 tline * 4 * reg10, which explains why the reg10max we've
759 found experimentally for the ov6650 is exactly half that of
760 the ov6645. The ov7630 datasheet says the max is 0x41. */
761 if (sd->sensor == SENSOR_OV6650) {
762 reg10_max = 0x4d;
763 i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
764 } else
765 reg10_max = 0x41;
766
767 reg11 = (60 * sd->exposure + 999) / 1000;
768 if (reg11 < 1)
769 reg11 = 1;
770 else if (reg11 > 16)
771 reg11 = 16;
772
773 /* In 640x480, if the reg11 has less than 3, the image is
774 unstable (not enough bandwidth). */
775 if (gspca_dev->width == 640 && reg11 < 3)
776 reg11 = 3;
777
778 /* frame exposure time in ms = 1000 * reg11 / 30 ->
779 reg10 = sd->exposure * 2 * reg10_max / (1000 * reg11 / 30) */
780 reg10 = (sd->exposure * 60 * reg10_max) / (1000 * reg11);
781
782 /* Don't allow this to get below 10 when using autogain, the
783 steps become very large (relatively) when below 10 causing
784 the image to oscilate from much too dark, to much too bright
785 and back again. */
786 if (sd->autogain && reg10 < 10)
787 reg10 = 10;
788 else if (reg10 > reg10_max)
789 reg10 = reg10_max;
790
791 /* Write reg 10 and reg11 low nibble */
792 i2c[1] = sensor_data[sd->sensor].sensor_addr;
793 i2c[3] = reg10;
794 i2c[4] |= reg11 - 1;
795
796 /* If register 11 didn't change, don't change it */
797 if (sd->reg11 == reg11 )
798 i2c[0] = 0xa0;
799
800 if (i2c_w(gspca_dev, i2c) == 0)
801 sd->reg11 = reg11;
802 else
803 PDEBUG(D_ERR, "i2c error exposure");
804 break;
805 }
806 }
807 }
808
809 static void setfreq(struct gspca_dev *gspca_dev)
810 {
811 struct sd *sd = (struct sd *) gspca_dev;
812
813 switch (sd->sensor) {
814 case SENSOR_OV6650:
815 case SENSOR_OV7630: {
816 /* Framerate adjust register for artificial light 50 hz flicker
817 compensation, for the ov6650 this is identical to ov6630
818 0x2b register, see ov6630 datasheet.
819 0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
820 __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
821 switch (sd->freq) {
822 default:
823 /* case 0: * no filter*/
824 /* case 2: * 60 hz */
825 i2c[3] = 0;
826 break;
827 case 1: /* 50 hz */
828 i2c[3] = (sd->sensor == SENSOR_OV6650)
829 ? 0x4f : 0x8a;
830 break;
831 }
832 i2c[1] = sensor_data[sd->sensor].sensor_addr;
833 if (i2c_w(gspca_dev, i2c) < 0)
834 PDEBUG(D_ERR, "i2c error setfreq");
835 break;
836 }
837 }
838 }
839
840 static void do_autogain(struct gspca_dev *gspca_dev)
841 {
842 int deadzone, desired_avg_lum;
843 struct sd *sd = (struct sd *) gspca_dev;
844 int avg_lum = atomic_read(&sd->avg_lum);
845
846 if (avg_lum == -1)
847 return;
848
849 /* SIF / VGA sensors have a different autoexposure area and thus
850 different avg_lum values for the same picture brightness */
851 if (sensor_data[sd->sensor].flags & F_SIF) {
852 deadzone = 1000;
853 desired_avg_lum = 7000;
854 } else {
855 deadzone = 3000;
856 desired_avg_lum = 23000;
857 }
858
859 if (sd->autogain_ignore_frames > 0)
860 sd->autogain_ignore_frames--;
861 else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
862 sd->brightness * desired_avg_lum / 127,
863 deadzone, GAIN_KNEE, EXPOSURE_KNEE)) {
864 PDEBUG(D_FRAM, "autogain: gain changed: gain: %d expo: %d",
865 (int)sd->gain, (int)sd->exposure);
866 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
867 }
868 }
869
870 /* this function is called at probe time */
871 static int sd_config(struct gspca_dev *gspca_dev,
872 const struct usb_device_id *id)
873 {
874 struct sd *sd = (struct sd *) gspca_dev;
875 struct cam *cam;
876
877 reg_r(gspca_dev, 0x00);
878 if (gspca_dev->usb_buf[0] != 0x10)
879 return -ENODEV;
880
881 /* copy the webcam info from the device id */
882 sd->sensor = id->driver_info >> 8;
883 sd->bridge = id->driver_info & 0xff;
884 gspca_dev->ctrl_dis = sensor_data[sd->sensor].ctrl_dis;
885
886 cam = &gspca_dev->cam;
887 if (!(sensor_data[sd->sensor].flags & F_SIF)) {
888 cam->cam_mode = vga_mode;
889 cam->nmodes = ARRAY_SIZE(vga_mode);
890 } else {
891 cam->cam_mode = sif_mode;
892 cam->nmodes = ARRAY_SIZE(sif_mode);
893 }
894 cam->npkt = 36; /* 36 packets per ISOC message */
895
896 sd->brightness = BRIGHTNESS_DEF;
897 sd->gain = GAIN_DEF;
898 sd->exposure = EXPOSURE_DEF;
899 if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
900 sd->autogain = 0; /* Disable do_autogain callback */
901 else
902 sd->autogain = AUTOGAIN_DEF;
903 sd->freq = FREQ_DEF;
904
905 return 0;
906 }
907
908 /* this function is called at probe and resume time */
909 static int sd_init(struct gspca_dev *gspca_dev)
910 {
911 const __u8 stop = 0x09; /* Disable stream turn of LED */
912
913 reg_w(gspca_dev, 0x01, &stop, 1);
914
915 return 0;
916 }
917
918 /* -- start the camera -- */
919 static int sd_start(struct gspca_dev *gspca_dev)
920 {
921 struct sd *sd = (struct sd *) gspca_dev;
922 struct cam *cam = &gspca_dev->cam;
923 int mode, l;
924 const __u8 *sn9c10x;
925 __u8 reg12_19[8];
926
927 mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
928 sn9c10x = sensor_data[sd->sensor].bridge_init[sd->bridge];
929 l = sensor_data[sd->sensor].bridge_init_size[sd->bridge];
930 memcpy(reg12_19, &sn9c10x[0x12 - 1], 8);
931 reg12_19[6] = sn9c10x[0x18 - 1] | (mode << 4);
932 /* Special cases where reg 17 and or 19 value depends on mode */
933 switch (sd->sensor) {
934 case SENSOR_PAS202:
935 reg12_19[5] = mode ? 0x24 : 0x20;
936 break;
937 case SENSOR_TAS5130CXX:
938 /* probably not mode specific at all most likely the upper
939 nibble of 0x19 is exposure (clock divider) just as with
940 the tas5110, we need someone to test this. */
941 reg12_19[7] = mode ? 0x23 : 0x43;
942 break;
943 }
944 /* Disable compression when the raw bayer format has been selected */
945 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
946 reg12_19[6] &= ~0x80;
947
948 /* Vga mode emulation on SIF sensor? */
949 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
950 reg12_19[0] += 16; /* 0x12: hstart adjust */
951 reg12_19[1] += 24; /* 0x13: vstart adjust */
952 reg12_19[3] = 320 / 16; /* 0x15: hsize */
953 reg12_19[4] = 240 / 16; /* 0x16: vsize */
954 }
955
956 /* reg 0x01 bit 2 video transfert on */
957 reg_w(gspca_dev, 0x01, &sn9c10x[0x01 - 1], 1);
958 /* reg 0x17 SensorClk enable inv Clk 0x60 */
959 reg_w(gspca_dev, 0x17, &sn9c10x[0x17 - 1], 1);
960 /* Set the registers from the template */
961 reg_w(gspca_dev, 0x01, sn9c10x, l);
962
963 /* Init the sensor */
964 i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
965 sensor_data[sd->sensor].sensor_init_size);
966 if (sensor_data[sd->sensor].sensor_bridge_init[sd->bridge])
967 i2c_w_vector(gspca_dev,
968 sensor_data[sd->sensor].sensor_bridge_init[sd->bridge],
969 sensor_data[sd->sensor].sensor_bridge_init_size[
970 sd->bridge]);
971
972 /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
973 reg_w(gspca_dev, 0x15, &reg12_19[3], 2);
974 /* compression register */
975 reg_w(gspca_dev, 0x18, &reg12_19[6], 1);
976 /* H_start */
977 reg_w(gspca_dev, 0x12, &reg12_19[0], 1);
978 /* V_START */
979 reg_w(gspca_dev, 0x13, &reg12_19[1], 1);
980 /* reset 0x17 SensorClk enable inv Clk 0x60 */
981 /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
982 reg_w(gspca_dev, 0x17, &reg12_19[5], 1);
983 /*MCKSIZE ->3 */ /*fixme: not ov7630*/
984 reg_w(gspca_dev, 0x19, &reg12_19[7], 1);
985 /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
986 reg_w(gspca_dev, 0x1c, &sn9c10x[0x1c - 1], 4);
987 /* Enable video transfert */
988 reg_w(gspca_dev, 0x01, &sn9c10x[0], 1);
989 /* Compression */
990 reg_w(gspca_dev, 0x18, &reg12_19[6], 2);
991 msleep(20);
992
993 sd->reg11 = -1;
994
995 setgain(gspca_dev);
996 setbrightness(gspca_dev);
997 setexposure(gspca_dev);
998 setfreq(gspca_dev);
999
1000 sd->frames_to_drop = 0;
1001 sd->autogain_ignore_frames = 0;
1002 atomic_set(&sd->avg_lum, -1);
1003 return 0;
1004 }
1005
1006 static void sd_stopN(struct gspca_dev *gspca_dev)
1007 {
1008 sd_init(gspca_dev);
1009 }
1010
1011 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1012 u8 *data, /* isoc packet */
1013 int len) /* iso packet length */
1014 {
1015 int i;
1016 struct sd *sd = (struct sd *) gspca_dev;
1017 struct cam *cam = &gspca_dev->cam;
1018
1019 /* frames start with:
1020 * ff ff 00 c4 c4 96 synchro
1021 * 00 (unknown)
1022 * xx (frame sequence / size / compression)
1023 * (xx) (idem - extra byte for sn9c103)
1024 * ll mm brightness sum inside auto exposure
1025 * ll mm brightness sum outside auto exposure
1026 * (xx xx xx xx xx) audio values for snc103
1027 */
1028 if (len > 6 && len < 24) {
1029 for (i = 0; i < len - 6; i++) {
1030 if (data[0 + i] == 0xff
1031 && data[1 + i] == 0xff
1032 && data[2 + i] == 0x00
1033 && data[3 + i] == 0xc4
1034 && data[4 + i] == 0xc4
1035 && data[5 + i] == 0x96) { /* start of frame */
1036 int lum = -1;
1037 int pkt_type = LAST_PACKET;
1038 int fr_h_sz = (sd->bridge == BRIDGE_103) ?
1039 18 : 12;
1040
1041 if (len - i < fr_h_sz) {
1042 PDEBUG(D_STREAM, "packet too short to"
1043 " get avg brightness");
1044 } else if (sd->bridge == BRIDGE_103) {
1045 lum = data[i + 9] +
1046 (data[i + 10] << 8);
1047 } else {
1048 lum = data[i + 8] + (data[i + 9] << 8);
1049 }
1050 /* When exposure changes midway a frame we
1051 get a lum of 0 in this case drop 2 frames
1052 as the frames directly after an exposure
1053 change have an unstable image. Sometimes lum
1054 *really* is 0 (cam used in low light with
1055 low exposure setting), so do not drop frames
1056 if the previous lum was 0 too. */
1057 if (lum == 0 && sd->prev_avg_lum != 0) {
1058 lum = -1;
1059 sd->frames_to_drop = 2;
1060 sd->prev_avg_lum = 0;
1061 } else
1062 sd->prev_avg_lum = lum;
1063 atomic_set(&sd->avg_lum, lum);
1064
1065 if (sd->frames_to_drop) {
1066 sd->frames_to_drop--;
1067 pkt_type = DISCARD_PACKET;
1068 }
1069
1070 gspca_frame_add(gspca_dev, pkt_type,
1071 NULL, 0);
1072 data += i + fr_h_sz;
1073 len -= i + fr_h_sz;
1074 gspca_frame_add(gspca_dev, FIRST_PACKET,
1075 data, len);
1076 return;
1077 }
1078 }
1079 }
1080
1081 if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1082 /* In raw mode we sometimes get some garbage after the frame
1083 ignore this */
1084 struct gspca_frame *frame;
1085 int used;
1086 int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1087
1088 frame = gspca_get_i_frame(gspca_dev);
1089 if (frame == NULL) {
1090 gspca_dev->last_packet_type = DISCARD_PACKET;
1091 return;
1092 }
1093 used = frame->data_end - frame->data;
1094 if (used + len > size)
1095 len = size - used;
1096 }
1097
1098 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1099 }
1100
1101 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1102 {
1103 struct sd *sd = (struct sd *) gspca_dev;
1104
1105 sd->brightness = val;
1106 if (gspca_dev->streaming)
1107 setbrightness(gspca_dev);
1108 return 0;
1109 }
1110
1111 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1112 {
1113 struct sd *sd = (struct sd *) gspca_dev;
1114
1115 *val = sd->brightness;
1116 return 0;
1117 }
1118
1119 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1120 {
1121 struct sd *sd = (struct sd *) gspca_dev;
1122
1123 sd->gain = val;
1124 if (gspca_dev->streaming)
1125 setgain(gspca_dev);
1126 return 0;
1127 }
1128
1129 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1130 {
1131 struct sd *sd = (struct sd *) gspca_dev;
1132
1133 *val = sd->gain;
1134 return 0;
1135 }
1136
1137 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
1138 {
1139 struct sd *sd = (struct sd *) gspca_dev;
1140
1141 sd->exposure = val;
1142 if (gspca_dev->streaming)
1143 setexposure(gspca_dev);
1144 return 0;
1145 }
1146
1147 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
1148 {
1149 struct sd *sd = (struct sd *) gspca_dev;
1150
1151 *val = sd->exposure;
1152 return 0;
1153 }
1154
1155 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1156 {
1157 struct sd *sd = (struct sd *) gspca_dev;
1158
1159 sd->autogain = val;
1160 /* when switching to autogain set defaults to make sure
1161 we are on a valid point of the autogain gain /
1162 exposure knee graph, and give this change time to
1163 take effect before doing autogain. */
1164 if (sd->autogain) {
1165 sd->exposure = EXPOSURE_DEF;
1166 sd->gain = GAIN_DEF;
1167 if (gspca_dev->streaming) {
1168 sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
1169 setexposure(gspca_dev);
1170 setgain(gspca_dev);
1171 }
1172 }
1173
1174 return 0;
1175 }
1176
1177 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1178 {
1179 struct sd *sd = (struct sd *) gspca_dev;
1180
1181 *val = sd->autogain;
1182 return 0;
1183 }
1184
1185 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1186 {
1187 struct sd *sd = (struct sd *) gspca_dev;
1188
1189 sd->freq = val;
1190 if (gspca_dev->streaming)
1191 setfreq(gspca_dev);
1192 return 0;
1193 }
1194
1195 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1196 {
1197 struct sd *sd = (struct sd *) gspca_dev;
1198
1199 *val = sd->freq;
1200 return 0;
1201 }
1202
1203 static int sd_querymenu(struct gspca_dev *gspca_dev,
1204 struct v4l2_querymenu *menu)
1205 {
1206 switch (menu->id) {
1207 case V4L2_CID_POWER_LINE_FREQUENCY:
1208 switch (menu->index) {
1209 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1210 strcpy((char *) menu->name, "NoFliker");
1211 return 0;
1212 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1213 strcpy((char *) menu->name, "50 Hz");
1214 return 0;
1215 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1216 strcpy((char *) menu->name, "60 Hz");
1217 return 0;
1218 }
1219 break;
1220 }
1221 return -EINVAL;
1222 }
1223
1224 #ifdef CONFIG_INPUT
1225 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1226 u8 *data, /* interrupt packet data */
1227 int len) /* interrupt packet length */
1228 {
1229 int ret = -EINVAL;
1230
1231 if (len == 1 && data[0] == 1) {
1232 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1233 input_sync(gspca_dev->input_dev);
1234 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1235 input_sync(gspca_dev->input_dev);
1236 ret = 0;
1237 }
1238
1239 return ret;
1240 }
1241 #endif
1242
1243 /* sub-driver description */
1244 static const struct sd_desc sd_desc = {
1245 .name = MODULE_NAME,
1246 .ctrls = sd_ctrls,
1247 .nctrls = ARRAY_SIZE(sd_ctrls),
1248 .config = sd_config,
1249 .init = sd_init,
1250 .start = sd_start,
1251 .stopN = sd_stopN,
1252 .pkt_scan = sd_pkt_scan,
1253 .querymenu = sd_querymenu,
1254 .dq_callback = do_autogain,
1255 #ifdef CONFIG_INPUT
1256 .int_pkt_scan = sd_int_pkt_scan,
1257 #endif
1258 };
1259
1260 /* -- module initialisation -- */
1261 #define SB(sensor, bridge) \
1262 .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1263
1264
1265 static const struct usb_device_id device_table[] __devinitconst = {
1266 {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1267 {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1268 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1269 {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1270 {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1271 {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1272 #endif
1273 {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1274 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1275 {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1276 {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1277 {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1278 {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1279 {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1280 #endif
1281 {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1282 {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1283 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1284 {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1285 #endif
1286 {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1287 #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
1288 {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1289 #endif
1290 {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1291 {}
1292 };
1293 MODULE_DEVICE_TABLE(usb, device_table);
1294
1295 /* -- device connect -- */
1296 static int __devinit sd_probe(struct usb_interface *intf,
1297 const struct usb_device_id *id)
1298 {
1299 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1300 THIS_MODULE);
1301 }
1302
1303 static struct usb_driver sd_driver = {
1304 .name = MODULE_NAME,
1305 .id_table = device_table,
1306 .probe = sd_probe,
1307 .disconnect = gspca_disconnect,
1308 #ifdef CONFIG_PM
1309 .suspend = gspca_suspend,
1310 .resume = gspca_resume,
1311 #endif
1312 };
1313
1314 /* -- module insert / remove -- */
1315 static int __init sd_mod_init(void)
1316 {
1317 int ret;
1318 ret = usb_register(&sd_driver);
1319 if (ret < 0)
1320 return ret;
1321 PDEBUG(D_PROBE, "registered");
1322 return 0;
1323 }
1324 static void __exit sd_mod_exit(void)
1325 {
1326 usb_deregister(&sd_driver);
1327 PDEBUG(D_PROBE, "deregistered");
1328 }
1329
1330 module_init(sd_mod_init);
1331 module_exit(sd_mod_exit);
AMDTP streaming driver for the Linux FireWire stack (Juju)