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