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