projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.dk/linux-block
[deliverable/linux.git] / drivers / media / video / gspca / t613.c
1 /*
2 * T613 subdriver
3 *
4 * Copyright (C) 2010 Jean-Francois Moine (http://moinejf.free.fr)
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 *Notes: * t613 + tas5130A
21 * * Focus to light do not balance well as in win.
22 * Quality in win is not good, but its kinda better.
23 * * Fix some "extraneous bytes", most of apps will show the image anyway
24 * * Gamma table, is there, but its really doing something?
25 * * 7~8 Fps, its ok, max on win its 10.
26 * Costantino Leandro
27 */
28
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31 #define MODULE_NAME "t613"
32
33 #include <linux/input.h>
34 #include <linux/slab.h>
35 #include "gspca.h"
36
37 #define V4L2_CID_EFFECTS (V4L2_CID_PRIVATE_BASE + 0)
38
39 MODULE_AUTHOR("Leandro Costantino <le_costantino@pixartargentina.com.ar>");
40 MODULE_DESCRIPTION("GSPCA/T613 (JPEG Compliance) USB Camera Driver");
41 MODULE_LICENSE("GPL");
42
43 struct sd {
44 struct gspca_dev gspca_dev; /* !! must be the first item */
45
46 u8 brightness;
47 u8 contrast;
48 u8 colors;
49 u8 autogain;
50 u8 gamma;
51 u8 sharpness;
52 u8 freq;
53 u8 red_gain;
54 u8 blue_gain;
55 u8 green_gain;
56 u8 awb; /* set default r/g/b and activate */
57 u8 mirror;
58 u8 effect;
59
60 u8 sensor;
61 u8 button_pressed;
62 };
63 enum sensors {
64 SENSOR_OM6802,
65 SENSOR_OTHER,
66 SENSOR_TAS5130A,
67 SENSOR_LT168G, /* must verify if this is the actual model */
68 };
69
70 /* V4L2 controls supported by the driver */
71 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
72 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
73 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
74 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
75 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
76 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
77 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val);
78 static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val);
79 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
80 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
81 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
82 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
83 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
84 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
85
86 static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val);
87 static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val);
88 static int sd_setblue_gain(struct gspca_dev *gspca_dev, __s32 val);
89 static int sd_getblue_gain(struct gspca_dev *gspca_dev, __s32 *val);
90 static int sd_setred_gain(struct gspca_dev *gspca_dev, __s32 val);
91 static int sd_getred_gain(struct gspca_dev *gspca_dev, __s32 *val);
92 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
93 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
94
95 static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val);
96 static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val);
97 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
98 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
99
100 static const struct ctrl sd_ctrls[] = {
101 {
102 {
103 .id = V4L2_CID_BRIGHTNESS,
104 .type = V4L2_CTRL_TYPE_INTEGER,
105 .name = "Brightness",
106 .minimum = 0,
107 .maximum = 14,
108 .step = 1,
109 #define BRIGHTNESS_DEF 8
110 .default_value = BRIGHTNESS_DEF,
111 },
112 .set = sd_setbrightness,
113 .get = sd_getbrightness,
114 },
115 {
116 {
117 .id = V4L2_CID_CONTRAST,
118 .type = V4L2_CTRL_TYPE_INTEGER,
119 .name = "Contrast",
120 .minimum = 0,
121 .maximum = 0x0d,
122 .step = 1,
123 #define CONTRAST_DEF 0x07
124 .default_value = CONTRAST_DEF,
125 },
126 .set = sd_setcontrast,
127 .get = sd_getcontrast,
128 },
129 {
130 {
131 .id = V4L2_CID_SATURATION,
132 .type = V4L2_CTRL_TYPE_INTEGER,
133 .name = "Color",
134 .minimum = 0,
135 .maximum = 0x0f,
136 .step = 1,
137 #define COLORS_DEF 0x05
138 .default_value = COLORS_DEF,
139 },
140 .set = sd_setcolors,
141 .get = sd_getcolors,
142 },
143 #define GAMMA_MAX 16
144 #define GAMMA_DEF 10
145 {
146 {
147 .id = V4L2_CID_GAMMA, /* (gamma on win) */
148 .type = V4L2_CTRL_TYPE_INTEGER,
149 .name = "Gamma",
150 .minimum = 0,
151 .maximum = GAMMA_MAX - 1,
152 .step = 1,
153 .default_value = GAMMA_DEF,
154 },
155 .set = sd_setgamma,
156 .get = sd_getgamma,
157 },
158 {
159 {
160 .id = V4L2_CID_BACKLIGHT_COMPENSATION, /* Activa lowlight,
161 * some apps dont bring up the
162 * backligth_compensation control) */
163 .type = V4L2_CTRL_TYPE_INTEGER,
164 .name = "Low Light",
165 .minimum = 0,
166 .maximum = 1,
167 .step = 1,
168 #define AUTOGAIN_DEF 0x01
169 .default_value = AUTOGAIN_DEF,
170 },
171 .set = sd_setlowlight,
172 .get = sd_getlowlight,
173 },
174 {
175 {
176 .id = V4L2_CID_HFLIP,
177 .type = V4L2_CTRL_TYPE_BOOLEAN,
178 .name = "Mirror Image",
179 .minimum = 0,
180 .maximum = 1,
181 .step = 1,
182 #define MIRROR_DEF 0
183 .default_value = MIRROR_DEF,
184 },
185 .set = sd_setmirror,
186 .get = sd_getmirror
187 },
188 {
189 {
190 .id = V4L2_CID_POWER_LINE_FREQUENCY,
191 .type = V4L2_CTRL_TYPE_MENU,
192 .name = "Light Frequency Filter",
193 .minimum = 1, /* 1 -> 0x50, 2->0x60 */
194 .maximum = 2,
195 .step = 1,
196 #define FREQ_DEF 1
197 .default_value = FREQ_DEF,
198 },
199 .set = sd_setfreq,
200 .get = sd_getfreq},
201
202 {
203 {
204 .id = V4L2_CID_AUTO_WHITE_BALANCE,
205 .type = V4L2_CTRL_TYPE_INTEGER,
206 .name = "Auto White Balance",
207 .minimum = 0,
208 .maximum = 1,
209 .step = 1,
210 #define AWB_DEF 0
211 .default_value = AWB_DEF,
212 },
213 .set = sd_setawb,
214 .get = sd_getawb
215 },
216 {
217 {
218 .id = V4L2_CID_SHARPNESS,
219 .type = V4L2_CTRL_TYPE_INTEGER,
220 .name = "Sharpness",
221 .minimum = 0,
222 .maximum = 15,
223 .step = 1,
224 #define SHARPNESS_DEF 0x06
225 .default_value = SHARPNESS_DEF,
226 },
227 .set = sd_setsharpness,
228 .get = sd_getsharpness,
229 },
230 {
231 {
232 .id = V4L2_CID_EFFECTS,
233 .type = V4L2_CTRL_TYPE_MENU,
234 .name = "Webcam Effects",
235 .minimum = 0,
236 .maximum = 4,
237 .step = 1,
238 #define EFFECTS_DEF 0
239 .default_value = EFFECTS_DEF,
240 },
241 .set = sd_seteffect,
242 .get = sd_geteffect
243 },
244 {
245 {
246 .id = V4L2_CID_BLUE_BALANCE,
247 .type = V4L2_CTRL_TYPE_INTEGER,
248 .name = "Blue Balance",
249 .minimum = 0x10,
250 .maximum = 0x40,
251 .step = 1,
252 #define BLUE_GAIN_DEF 0x20
253 .default_value = BLUE_GAIN_DEF,
254 },
255 .set = sd_setblue_gain,
256 .get = sd_getblue_gain,
257 },
258 {
259 {
260 .id = V4L2_CID_RED_BALANCE,
261 .type = V4L2_CTRL_TYPE_INTEGER,
262 .name = "Red Balance",
263 .minimum = 0x10,
264 .maximum = 0x40,
265 .step = 1,
266 #define RED_GAIN_DEF 0x20
267 .default_value = RED_GAIN_DEF,
268 },
269 .set = sd_setred_gain,
270 .get = sd_getred_gain,
271 },
272 {
273 {
274 .id = V4L2_CID_GAIN,
275 .type = V4L2_CTRL_TYPE_INTEGER,
276 .name = "Gain",
277 .minimum = 0x10,
278 .maximum = 0x40,
279 .step = 1,
280 #define GAIN_DEF 0x20
281 .default_value = GAIN_DEF,
282 },
283 .set = sd_setgain,
284 .get = sd_getgain,
285 },
286 };
287
288 static const struct v4l2_pix_format vga_mode_t16[] = {
289 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
290 .bytesperline = 160,
291 .sizeimage = 160 * 120 * 4 / 8 + 590,
292 .colorspace = V4L2_COLORSPACE_JPEG,
293 .priv = 4},
294 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
295 .bytesperline = 176,
296 .sizeimage = 176 * 144 * 3 / 8 + 590,
297 .colorspace = V4L2_COLORSPACE_JPEG,
298 .priv = 3},
299 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
300 .bytesperline = 320,
301 .sizeimage = 320 * 240 * 3 / 8 + 590,
302 .colorspace = V4L2_COLORSPACE_JPEG,
303 .priv = 2},
304 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
305 .bytesperline = 352,
306 .sizeimage = 352 * 288 * 3 / 8 + 590,
307 .colorspace = V4L2_COLORSPACE_JPEG,
308 .priv = 1},
309 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
310 .bytesperline = 640,
311 .sizeimage = 640 * 480 * 3 / 8 + 590,
312 .colorspace = V4L2_COLORSPACE_JPEG,
313 .priv = 0},
314 };
315
316 /* sensor specific data */
317 struct additional_sensor_data {
318 const u8 n3[6];
319 const u8 *n4, n4sz;
320 const u8 reg80, reg8e;
321 const u8 nset8[6];
322 const u8 data1[10];
323 const u8 data2[9];
324 const u8 data3[9];
325 const u8 data5[6];
326 const u8 stream[4];
327 };
328
329 static const u8 n4_om6802[] = {
330 0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
331 0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
332 0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
333 0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8,
334 0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48,
335 0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0,
336 0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
337 0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
338 0xac, 0x84, 0xad, 0x86, 0xaf, 0x46
339 };
340 static const u8 n4_other[] = {
341 0x66, 0x00, 0x7f, 0x00, 0x80, 0xac, 0x81, 0x69,
342 0x84, 0x40, 0x85, 0x70, 0x86, 0x20, 0x8a, 0x68,
343 0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xff, 0x8e, 0xb8,
344 0x8f, 0x28, 0xa2, 0x60, 0xa5, 0x40, 0xa8, 0xa8,
345 0xac, 0x84, 0xad, 0x84, 0xae, 0x24, 0xaf, 0x56,
346 0xb0, 0x68, 0xb1, 0x00, 0xb2, 0x88, 0xbb, 0xc5,
347 0xbc, 0x4a, 0xbe, 0x36, 0xc2, 0x88, 0xc5, 0xc0,
348 0xc6, 0xda, 0xe9, 0x26, 0xeb, 0x00
349 };
350 static const u8 n4_tas5130a[] = {
351 0x80, 0x3c, 0x81, 0x68, 0x83, 0xa0, 0x84, 0x20,
352 0x8a, 0x68, 0x8b, 0x58, 0x8c, 0x88, 0x8e, 0xb4,
353 0x8f, 0x24, 0xa1, 0xb1, 0xa2, 0x30, 0xa5, 0x10,
354 0xa6, 0x4a, 0xae, 0x03, 0xb1, 0x44, 0xb2, 0x08,
355 0xb7, 0x06, 0xb9, 0xe7, 0xbb, 0xc4, 0xbc, 0x4a,
356 0xbe, 0x36, 0xbf, 0xff, 0xc2, 0x88, 0xc5, 0xc8,
357 0xc6, 0xda
358 };
359 static const u8 n4_lt168g[] = {
360 0x66, 0x01, 0x7f, 0x00, 0x80, 0x7c, 0x81, 0x28,
361 0x83, 0x44, 0x84, 0x20, 0x86, 0x20, 0x8a, 0x70,
362 0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xa0, 0x8e, 0xb3,
363 0x8f, 0x24, 0xa1, 0xb0, 0xa2, 0x38, 0xa5, 0x20,
364 0xa6, 0x4a, 0xa8, 0xe8, 0xaf, 0x38, 0xb0, 0x68,
365 0xb1, 0x44, 0xb2, 0x88, 0xbb, 0x86, 0xbd, 0x40,
366 0xbe, 0x26, 0xc1, 0x05, 0xc2, 0x88, 0xc5, 0xc0,
367 0xda, 0x8e, 0xdb, 0xca, 0xdc, 0xa8, 0xdd, 0x8c,
368 0xde, 0x44, 0xdf, 0x0c, 0xe9, 0x80
369 };
370
371 static const struct additional_sensor_data sensor_data[] = {
372 [SENSOR_OM6802] = {
373 .n3 =
374 {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04},
375 .n4 = n4_om6802,
376 .n4sz = sizeof n4_om6802,
377 .reg80 = 0x3c,
378 .reg8e = 0x33,
379 .nset8 = {0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00},
380 .data1 =
381 {0xc2, 0x28, 0x0f, 0x22, 0xcd, 0x27, 0x2c, 0x06,
382 0xb3, 0xfc},
383 .data2 =
384 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,
385 0xff},
386 .data3 =
387 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff,
388 0xff},
389 .data5 = /* this could be removed later */
390 {0x0c, 0x03, 0xab, 0x13, 0x81, 0x23},
391 .stream =
392 {0x0b, 0x04, 0x0a, 0x78},
393 },
394 [SENSOR_OTHER] = {
395 .n3 =
396 {0x61, 0xc2, 0x65, 0x88, 0x60, 0x00},
397 .n4 = n4_other,
398 .n4sz = sizeof n4_other,
399 .reg80 = 0xac,
400 .reg8e = 0xb8,
401 .nset8 = {0xa8, 0xa8, 0xc6, 0xda, 0xc0, 0x00},
402 .data1 =
403 {0xc1, 0x48, 0x04, 0x1b, 0xca, 0x2e, 0x33, 0x3a,
404 0xe8, 0xfc},
405 .data2 =
406 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
407 0xd9},
408 .data3 =
409 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96,
410 0xd9},
411 .data5 =
412 {0x0c, 0x03, 0xab, 0x29, 0x81, 0x69},
413 .stream =
414 {0x0b, 0x04, 0x0a, 0x00},
415 },
416 [SENSOR_TAS5130A] = {
417 .n3 =
418 {0x61, 0xc2, 0x65, 0x0d, 0x60, 0x08},
419 .n4 = n4_tas5130a,
420 .n4sz = sizeof n4_tas5130a,
421 .reg80 = 0x3c,
422 .reg8e = 0xb4,
423 .nset8 = {0xa8, 0xf0, 0xc6, 0xda, 0xc0, 0x00},
424 .data1 =
425 {0xbb, 0x28, 0x10, 0x10, 0xbb, 0x28, 0x1e, 0x27,
426 0xc8, 0xfc},
427 .data2 =
428 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
429 0xe0},
430 .data3 =
431 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8,
432 0xe0},
433 .data5 =
434 {0x0c, 0x03, 0xab, 0x10, 0x81, 0x20},
435 .stream =
436 {0x0b, 0x04, 0x0a, 0x40},
437 },
438 [SENSOR_LT168G] = {
439 .n3 = {0x61, 0xc2, 0x65, 0x68, 0x60, 0x00},
440 .n4 = n4_lt168g,
441 .n4sz = sizeof n4_lt168g,
442 .reg80 = 0x7c,
443 .reg8e = 0xb3,
444 .nset8 = {0xa8, 0xf0, 0xc6, 0xba, 0xc0, 0x00},
445 .data1 = {0xc0, 0x38, 0x08, 0x10, 0xc0, 0x30, 0x10, 0x40,
446 0xb0, 0xf4},
447 .data2 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
448 0xff},
449 .data3 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6,
450 0xff},
451 .data5 = {0x0c, 0x03, 0xab, 0x4b, 0x81, 0x2b},
452 .stream = {0x0b, 0x04, 0x0a, 0x28},
453 },
454 };
455
456 #define MAX_EFFECTS 7
457 /* easily done by soft, this table could be removed,
458 * i keep it here just in case */
459 static char *effects_control[MAX_EFFECTS] = {
460 "Normal",
461 "Emboss", /* disabled */
462 "Monochrome",
463 "Sepia",
464 "Sketch",
465 "Sun Effect", /* disabled */
466 "Negative",
467 };
468 static const u8 effects_table[MAX_EFFECTS][6] = {
469 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00}, /* Normal */
470 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04}, /* Repujar */
471 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x20}, /* Monochrome */
472 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x80}, /* Sepia */
473 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x02}, /* Croquis */
474 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x10}, /* Sun Effect */
475 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40}, /* Negative */
476 };
477
478 static const u8 gamma_table[GAMMA_MAX][17] = {
479 /* gamma table from cam1690.ini */
480 {0x00, 0x00, 0x01, 0x04, 0x08, 0x0e, 0x16, 0x21, /* 0 */
481 0x2e, 0x3d, 0x50, 0x65, 0x7d, 0x99, 0xb8, 0xdb,
482 0xff},
483 {0x00, 0x01, 0x03, 0x08, 0x0e, 0x16, 0x21, 0x2d, /* 1 */
484 0x3c, 0x4d, 0x60, 0x75, 0x8d, 0xa6, 0xc2, 0xe1,
485 0xff},
486 {0x00, 0x01, 0x05, 0x0b, 0x12, 0x1c, 0x28, 0x35, /* 2 */
487 0x45, 0x56, 0x69, 0x7e, 0x95, 0xad, 0xc7, 0xe3,
488 0xff},
489 {0x00, 0x02, 0x07, 0x0f, 0x18, 0x24, 0x30, 0x3f, /* 3 */
490 0x4f, 0x61, 0x73, 0x88, 0x9d, 0xb4, 0xcd, 0xe6,
491 0xff},
492 {0x00, 0x04, 0x0b, 0x15, 0x20, 0x2d, 0x3b, 0x4a, /* 4 */
493 0x5b, 0x6c, 0x7f, 0x92, 0xa7, 0xbc, 0xd2, 0xe9,
494 0xff},
495 {0x00, 0x07, 0x11, 0x15, 0x20, 0x2d, 0x48, 0x58, /* 5 */
496 0x68, 0x79, 0x8b, 0x9d, 0xb0, 0xc4, 0xd7, 0xec,
497 0xff},
498 {0x00, 0x0c, 0x1a, 0x29, 0x38, 0x47, 0x57, 0x67, /* 6 */
499 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
500 0xff},
501 {0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, /* 7 */
502 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,
503 0xff},
504 {0x00, 0x15, 0x27, 0x38, 0x49, 0x59, 0x69, 0x79, /* 8 */
505 0x88, 0x97, 0xa7, 0xb6, 0xc4, 0xd3, 0xe2, 0xf0,
506 0xff},
507 {0x00, 0x1c, 0x30, 0x43, 0x54, 0x65, 0x75, 0x84, /* 9 */
508 0x93, 0xa1, 0xb0, 0xbd, 0xca, 0xd8, 0xe5, 0xf2,
509 0xff},
510 {0x00, 0x24, 0x3b, 0x4f, 0x60, 0x70, 0x80, 0x8e, /* 10 */
511 0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xdc, 0xe8, 0xf3,
512 0xff},
513 {0x00, 0x2a, 0x3c, 0x5d, 0x6e, 0x7e, 0x8d, 0x9b, /* 11 */
514 0xa8, 0xb4, 0xc0, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5,
515 0xff},
516 {0x00, 0x3f, 0x5a, 0x6e, 0x7f, 0x8e, 0x9c, 0xa8, /* 12 */
517 0xb4, 0xbf, 0xc9, 0xd3, 0xdc, 0xe5, 0xee, 0xf6,
518 0xff},
519 {0x00, 0x54, 0x6f, 0x83, 0x93, 0xa0, 0xad, 0xb7, /* 13 */
520 0xc2, 0xcb, 0xd4, 0xdc, 0xe4, 0xeb, 0xf2, 0xf9,
521 0xff},
522 {0x00, 0x6e, 0x88, 0x9a, 0xa8, 0xb3, 0xbd, 0xc6, /* 14 */
523 0xcf, 0xd6, 0xdd, 0xe3, 0xe9, 0xef, 0xf4, 0xfa,
524 0xff},
525 {0x00, 0x93, 0xa8, 0xb7, 0xc1, 0xca, 0xd2, 0xd8, /* 15 */
526 0xde, 0xe3, 0xe8, 0xed, 0xf1, 0xf5, 0xf8, 0xfc,
527 0xff}
528 };
529
530 static const u8 tas5130a_sensor_init[][8] = {
531 {0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09},
532 {0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09},
533 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
534 };
535
536 static u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07};
537
538 /* read 1 byte */
539 static u8 reg_r(struct gspca_dev *gspca_dev,
540 u16 index)
541 {
542 usb_control_msg(gspca_dev->dev,
543 usb_rcvctrlpipe(gspca_dev->dev, 0),
544 0, /* request */
545 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
546 0, /* value */
547 index,
548 gspca_dev->usb_buf, 1, 500);
549 return gspca_dev->usb_buf[0];
550 }
551
552 static void reg_w(struct gspca_dev *gspca_dev,
553 u16 index)
554 {
555 usb_control_msg(gspca_dev->dev,
556 usb_sndctrlpipe(gspca_dev->dev, 0),
557 0,
558 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
559 0, index,
560 NULL, 0, 500);
561 }
562
563 static void reg_w_buf(struct gspca_dev *gspca_dev,
564 const u8 *buffer, u16 len)
565 {
566 if (len <= USB_BUF_SZ) {
567 memcpy(gspca_dev->usb_buf, buffer, len);
568 usb_control_msg(gspca_dev->dev,
569 usb_sndctrlpipe(gspca_dev->dev, 0),
570 0,
571 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
572 0x01, 0,
573 gspca_dev->usb_buf, len, 500);
574 } else {
575 u8 *tmpbuf;
576
577 tmpbuf = kmemdup(buffer, len, GFP_KERNEL);
578 if (!tmpbuf) {
579 pr_err("Out of memory\n");
580 return;
581 }
582 usb_control_msg(gspca_dev->dev,
583 usb_sndctrlpipe(gspca_dev->dev, 0),
584 0,
585 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
586 0x01, 0,
587 tmpbuf, len, 500);
588 kfree(tmpbuf);
589 }
590 }
591
592 /* write values to consecutive registers */
593 static void reg_w_ixbuf(struct gspca_dev *gspca_dev,
594 u8 reg,
595 const u8 *buffer, u16 len)
596 {
597 int i;
598 u8 *p, *tmpbuf;
599
600 if (len * 2 <= USB_BUF_SZ) {
601 p = tmpbuf = gspca_dev->usb_buf;
602 } else {
603 p = tmpbuf = kmalloc(len * 2, GFP_KERNEL);
604 if (!tmpbuf) {
605 pr_err("Out of memory\n");
606 return;
607 }
608 }
609 i = len;
610 while (--i >= 0) {
611 *p++ = reg++;
612 *p++ = *buffer++;
613 }
614 usb_control_msg(gspca_dev->dev,
615 usb_sndctrlpipe(gspca_dev->dev, 0),
616 0,
617 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
618 0x01, 0,
619 tmpbuf, len * 2, 500);
620 if (len * 2 > USB_BUF_SZ)
621 kfree(tmpbuf);
622 }
623
624 static void om6802_sensor_init(struct gspca_dev *gspca_dev)
625 {
626 int i;
627 const u8 *p;
628 u8 byte;
629 u8 val[6] = {0x62, 0, 0x64, 0, 0x60, 0x05};
630 static const u8 sensor_init[] = {
631 0xdf, 0x6d,
632 0xdd, 0x18,
633 0x5a, 0xe0,
634 0x5c, 0x07,
635 0x5d, 0xb0,
636 0x5e, 0x1e,
637 0x60, 0x71,
638 0xef, 0x00,
639 0xe9, 0x00,
640 0xea, 0x00,
641 0x90, 0x24,
642 0x91, 0xb2,
643 0x82, 0x32,
644 0xfd, 0x41,
645 0x00 /* table end */
646 };
647
648 reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset);
649 msleep(100);
650 i = 4;
651 while (--i > 0) {
652 byte = reg_r(gspca_dev, 0x0060);
653 if (!(byte & 0x01))
654 break;
655 msleep(100);
656 }
657 byte = reg_r(gspca_dev, 0x0063);
658 if (byte != 0x17) {
659 pr_err("Bad sensor reset %02x\n", byte);
660 /* continue? */
661 }
662
663 p = sensor_init;
664 while (*p != 0) {
665 val[1] = *p++;
666 val[3] = *p++;
667 if (*p == 0)
668 reg_w(gspca_dev, 0x3c80);
669 reg_w_buf(gspca_dev, val, sizeof val);
670 i = 4;
671 while (--i >= 0) {
672 msleep(15);
673 byte = reg_r(gspca_dev, 0x60);
674 if (!(byte & 0x01))
675 break;
676 }
677 }
678 msleep(15);
679 reg_w(gspca_dev, 0x3c80);
680 }
681
682 /* this function is called at probe time */
683 static int sd_config(struct gspca_dev *gspca_dev,
684 const struct usb_device_id *id)
685 {
686 struct sd *sd = (struct sd *) gspca_dev;
687 struct cam *cam;
688
689 cam = &gspca_dev->cam;
690
691 cam->cam_mode = vga_mode_t16;
692 cam->nmodes = ARRAY_SIZE(vga_mode_t16);
693
694 sd->brightness = BRIGHTNESS_DEF;
695 sd->contrast = CONTRAST_DEF;
696 sd->colors = COLORS_DEF;
697 sd->gamma = GAMMA_DEF;
698 sd->autogain = AUTOGAIN_DEF;
699 sd->mirror = MIRROR_DEF;
700 sd->freq = FREQ_DEF;
701 sd->awb = AWB_DEF;
702 sd->sharpness = SHARPNESS_DEF;
703 sd->effect = EFFECTS_DEF;
704 sd->red_gain = RED_GAIN_DEF;
705 sd->blue_gain = BLUE_GAIN_DEF;
706 sd->green_gain = GAIN_DEF * 3 - RED_GAIN_DEF - BLUE_GAIN_DEF;
707
708 return 0;
709 }
710
711 static void setbrightness(struct gspca_dev *gspca_dev)
712 {
713 struct sd *sd = (struct sd *) gspca_dev;
714 unsigned int brightness;
715 u8 set6[4] = { 0x8f, 0x24, 0xc3, 0x00 };
716
717 brightness = sd->brightness;
718 if (brightness < 7) {
719 set6[1] = 0x26;
720 set6[3] = 0x70 - brightness * 0x10;
721 } else {
722 set6[3] = 0x00 + ((brightness - 7) * 0x10);
723 }
724
725 reg_w_buf(gspca_dev, set6, sizeof set6);
726 }
727
728 static void setcontrast(struct gspca_dev *gspca_dev)
729 {
730 struct sd *sd = (struct sd *) gspca_dev;
731 unsigned int contrast = sd->contrast;
732 u16 reg_to_write;
733
734 if (contrast < 7)
735 reg_to_write = 0x8ea9 - contrast * 0x200;
736 else
737 reg_to_write = 0x00a9 + (contrast - 7) * 0x200;
738
739 reg_w(gspca_dev, reg_to_write);
740 }
741
742 static void setcolors(struct gspca_dev *gspca_dev)
743 {
744 struct sd *sd = (struct sd *) gspca_dev;
745 u16 reg_to_write;
746
747 reg_to_write = 0x80bb + sd->colors * 0x100; /* was 0xc0 */
748 reg_w(gspca_dev, reg_to_write);
749 }
750
751 static void setgamma(struct gspca_dev *gspca_dev)
752 {
753 struct sd *sd = (struct sd *) gspca_dev;
754
755 PDEBUG(D_CONF, "Gamma: %d", sd->gamma);
756 reg_w_ixbuf(gspca_dev, 0x90,
757 gamma_table[sd->gamma], sizeof gamma_table[0]);
758 }
759
760 static void setRGB(struct gspca_dev *gspca_dev)
761 {
762 struct sd *sd = (struct sd *) gspca_dev;
763 u8 all_gain_reg[6] =
764 {0x87, 0x00, 0x88, 0x00, 0x89, 0x00};
765
766 all_gain_reg[1] = sd->red_gain;
767 all_gain_reg[3] = sd->blue_gain;
768 all_gain_reg[5] = sd->green_gain;
769 reg_w_buf(gspca_dev, all_gain_reg, sizeof all_gain_reg);
770 }
771
772 /* Generic fnc for r/b balance, exposure and awb */
773 static void setawb(struct gspca_dev *gspca_dev)
774 {
775 struct sd *sd = (struct sd *) gspca_dev;
776 u16 reg80;
777
778 reg80 = (sensor_data[sd->sensor].reg80 << 8) | 0x80;
779
780 /* on awb leave defaults values */
781 if (!sd->awb) {
782 /* shoud we wait here.. */
783 /* update and reset RGB gains with webcam values */
784 sd->red_gain = reg_r(gspca_dev, 0x0087);
785 sd->blue_gain = reg_r(gspca_dev, 0x0088);
786 sd->green_gain = reg_r(gspca_dev, 0x0089);
787 reg80 &= ~0x0400; /* AWB off */
788 }
789 reg_w(gspca_dev, reg80);
790 reg_w(gspca_dev, reg80);
791 }
792
793 static void init_gains(struct gspca_dev *gspca_dev)
794 {
795 struct sd *sd = (struct sd *) gspca_dev;
796 u16 reg80;
797 u8 all_gain_reg[8] =
798 {0x87, 0x00, 0x88, 0x00, 0x89, 0x00, 0x80, 0x00};
799
800 all_gain_reg[1] = sd->red_gain;
801 all_gain_reg[3] = sd->blue_gain;
802 all_gain_reg[5] = sd->green_gain;
803 reg80 = sensor_data[sd->sensor].reg80;
804 if (!sd->awb)
805 reg80 &= ~0x04;
806 all_gain_reg[7] = reg80;
807 reg_w_buf(gspca_dev, all_gain_reg, sizeof all_gain_reg);
808
809 reg_w(gspca_dev, (sd->red_gain << 8) + 0x87);
810 reg_w(gspca_dev, (sd->blue_gain << 8) + 0x88);
811 reg_w(gspca_dev, (sd->green_gain << 8) + 0x89);
812 }
813
814 static void setsharpness(struct gspca_dev *gspca_dev)
815 {
816 struct sd *sd = (struct sd *) gspca_dev;
817 u16 reg_to_write;
818
819 reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
820
821 reg_w(gspca_dev, reg_to_write);
822 }
823
824 static void setfreq(struct gspca_dev *gspca_dev)
825 {
826 struct sd *sd = (struct sd *) gspca_dev;
827 u8 reg66;
828 u8 freq[4] = { 0x66, 0x00, 0xa8, 0xe8 };
829
830 switch (sd->sensor) {
831 case SENSOR_LT168G:
832 if (sd->freq != 0)
833 freq[3] = 0xa8;
834 reg66 = 0x41;
835 break;
836 case SENSOR_OM6802:
837 reg66 = 0xca;
838 break;
839 default:
840 reg66 = 0x40;
841 break;
842 }
843 switch (sd->freq) {
844 case 0: /* no flicker */
845 freq[3] = 0xf0;
846 break;
847 case 2: /* 60Hz */
848 reg66 &= ~0x40;
849 break;
850 }
851 freq[1] = reg66;
852
853 reg_w_buf(gspca_dev, freq, sizeof freq);
854 }
855
856 /* this function is called at probe and resume time */
857 static int sd_init(struct gspca_dev *gspca_dev)
858 {
859 /* some of this registers are not really neded, because
860 * they are overriden by setbrigthness, setcontrast, etc,
861 * but wont hurt anyway, and can help someone with similar webcam
862 * to see the initial parameters.*/
863 struct sd *sd = (struct sd *) gspca_dev;
864 const struct additional_sensor_data *sensor;
865 int i;
866 u16 sensor_id;
867 u8 test_byte = 0;
868
869 static const u8 read_indexs[] =
870 { 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5,
871 0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00 };
872 static const u8 n1[] =
873 {0x08, 0x03, 0x09, 0x03, 0x12, 0x04};
874 static const u8 n2[] =
875 {0x08, 0x00};
876
877 sensor_id = (reg_r(gspca_dev, 0x06) << 8)
878 | reg_r(gspca_dev, 0x07);
879 switch (sensor_id & 0xff0f) {
880 case 0x0801:
881 PDEBUG(D_PROBE, "sensor tas5130a");
882 sd->sensor = SENSOR_TAS5130A;
883 break;
884 case 0x0802:
885 PDEBUG(D_PROBE, "sensor lt168g");
886 sd->sensor = SENSOR_LT168G;
887 break;
888 case 0x0803:
889 PDEBUG(D_PROBE, "sensor 'other'");
890 sd->sensor = SENSOR_OTHER;
891 break;
892 case 0x0807:
893 PDEBUG(D_PROBE, "sensor om6802");
894 sd->sensor = SENSOR_OM6802;
895 break;
896 default:
897 pr_err("unknown sensor %04x\n", sensor_id);
898 return -EINVAL;
899 }
900
901 if (sd->sensor == SENSOR_OM6802) {
902 reg_w_buf(gspca_dev, n1, sizeof n1);
903 i = 5;
904 while (--i >= 0) {
905 reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset);
906 test_byte = reg_r(gspca_dev, 0x0063);
907 msleep(100);
908 if (test_byte == 0x17)
909 break; /* OK */
910 }
911 if (i < 0) {
912 pr_err("Bad sensor reset %02x\n", test_byte);
913 return -EIO;
914 }
915 reg_w_buf(gspca_dev, n2, sizeof n2);
916 }
917
918 i = 0;
919 while (read_indexs[i] != 0x00) {
920 test_byte = reg_r(gspca_dev, read_indexs[i]);
921 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", read_indexs[i],
922 test_byte);
923 i++;
924 }
925
926 sensor = &sensor_data[sd->sensor];
927 reg_w_buf(gspca_dev, sensor->n3, sizeof sensor->n3);
928 reg_w_buf(gspca_dev, sensor->n4, sensor->n4sz);
929
930 if (sd->sensor == SENSOR_LT168G) {
931 test_byte = reg_r(gspca_dev, 0x80);
932 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80,
933 test_byte);
934 reg_w(gspca_dev, 0x6c80);
935 }
936
937 reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
938 reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
939 reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
940
941 reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80);
942 reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80);
943 reg_w(gspca_dev, (sensor->reg8e << 8) + 0x8e);
944
945 setbrightness(gspca_dev);
946 setcontrast(gspca_dev);
947 setgamma(gspca_dev);
948 setcolors(gspca_dev);
949 setsharpness(gspca_dev);
950 init_gains(gspca_dev);
951 setfreq(gspca_dev);
952
953 reg_w_buf(gspca_dev, sensor->data5, sizeof sensor->data5);
954 reg_w_buf(gspca_dev, sensor->nset8, sizeof sensor->nset8);
955 reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
956
957 if (sd->sensor == SENSOR_LT168G) {
958 test_byte = reg_r(gspca_dev, 0x80);
959 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80,
960 test_byte);
961 reg_w(gspca_dev, 0x6c80);
962 }
963
964 reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1);
965 reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2);
966 reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3);
967
968 return 0;
969 }
970
971 static void setmirror(struct gspca_dev *gspca_dev)
972 {
973 struct sd *sd = (struct sd *) gspca_dev;
974 u8 hflipcmd[8] =
975 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09};
976
977 if (sd->mirror)
978 hflipcmd[3] = 0x01;
979
980 reg_w_buf(gspca_dev, hflipcmd, sizeof hflipcmd);
981 }
982
983 static void seteffect(struct gspca_dev *gspca_dev)
984 {
985 struct sd *sd = (struct sd *) gspca_dev;
986
987 reg_w_buf(gspca_dev, effects_table[sd->effect],
988 sizeof effects_table[0]);
989 if (sd->effect == 1 || sd->effect == 5) {
990 PDEBUG(D_CONF,
991 "This effect have been disabled for webcam \"safety\"");
992 return;
993 }
994
995 if (sd->effect == 1 || sd->effect == 4)
996 reg_w(gspca_dev, 0x4aa6);
997 else
998 reg_w(gspca_dev, 0xfaa6);
999 }
1000
1001 /* Is this really needed?
1002 * i added some module parameters for test with some users */
1003 static void poll_sensor(struct gspca_dev *gspca_dev)
1004 {
1005 static const u8 poll1[] =
1006 {0x67, 0x05, 0x68, 0x81, 0x69, 0x80, 0x6a, 0x82,
1007 0x6b, 0x68, 0x6c, 0x69, 0x72, 0xd9, 0x73, 0x34,
1008 0x74, 0x32, 0x75, 0x92, 0x76, 0x00, 0x09, 0x01,
1009 0x60, 0x14};
1010 static const u8 poll2[] =
1011 {0x67, 0x02, 0x68, 0x71, 0x69, 0x72, 0x72, 0xa9,
1012 0x73, 0x02, 0x73, 0x02, 0x60, 0x14};
1013 static const u8 noise03[] = /* (some differences / ms-drv) */
1014 {0xa6, 0x0a, 0xea, 0xcf, 0xbe, 0x26, 0xb1, 0x5f,
1015 0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c,
1016 0xc2, 0x80, 0xc3, 0x10};
1017
1018 PDEBUG(D_STREAM, "[Sensor requires polling]");
1019 reg_w_buf(gspca_dev, poll1, sizeof poll1);
1020 reg_w_buf(gspca_dev, poll2, sizeof poll2);
1021 reg_w_buf(gspca_dev, noise03, sizeof noise03);
1022 }
1023
1024 static int sd_start(struct gspca_dev *gspca_dev)
1025 {
1026 struct sd *sd = (struct sd *) gspca_dev;
1027 const struct additional_sensor_data *sensor;
1028 int i, mode;
1029 u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
1030 static const u8 t3[] =
1031 { 0x07, 0x00, 0x88, 0x02, 0x06, 0x00, 0xe7, 0x01 };
1032
1033 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1034 switch (mode) {
1035 case 0: /* 640x480 (0x00) */
1036 break;
1037 case 1: /* 352x288 */
1038 t2[1] = 0x40;
1039 break;
1040 case 2: /* 320x240 */
1041 t2[1] = 0x10;
1042 break;
1043 case 3: /* 176x144 */
1044 t2[1] = 0x50;
1045 break;
1046 default:
1047 /* case 4: * 160x120 */
1048 t2[1] = 0x20;
1049 break;
1050 }
1051
1052 switch (sd->sensor) {
1053 case SENSOR_OM6802:
1054 om6802_sensor_init(gspca_dev);
1055 break;
1056 case SENSOR_TAS5130A:
1057 i = 0;
1058 for (;;) {
1059 reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
1060 sizeof tas5130a_sensor_init[0]);
1061 if (i >= ARRAY_SIZE(tas5130a_sensor_init) - 1)
1062 break;
1063 i++;
1064 }
1065 reg_w(gspca_dev, 0x3c80);
1066 /* just in case and to keep sync with logs (for mine) */
1067 reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
1068 sizeof tas5130a_sensor_init[0]);
1069 reg_w(gspca_dev, 0x3c80);
1070 break;
1071 }
1072 sensor = &sensor_data[sd->sensor];
1073 setfreq(gspca_dev);
1074 reg_r(gspca_dev, 0x0012);
1075 reg_w_buf(gspca_dev, t2, sizeof t2);
1076 reg_w_ixbuf(gspca_dev, 0xb3, t3, sizeof t3);
1077 reg_w(gspca_dev, 0x0013);
1078 msleep(15);
1079 reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
1080 reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream);
1081
1082 if (sd->sensor == SENSOR_OM6802)
1083 poll_sensor(gspca_dev);
1084
1085 return 0;
1086 }
1087
1088 static void sd_stopN(struct gspca_dev *gspca_dev)
1089 {
1090 struct sd *sd = (struct sd *) gspca_dev;
1091
1092 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
1093 sizeof sensor_data[sd->sensor].stream);
1094 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
1095 sizeof sensor_data[sd->sensor].stream);
1096 if (sd->sensor == SENSOR_OM6802) {
1097 msleep(20);
1098 reg_w(gspca_dev, 0x0309);
1099 }
1100 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1101 /* If the last button state is pressed, release it now! */
1102 if (sd->button_pressed) {
1103 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1104 input_sync(gspca_dev->input_dev);
1105 sd->button_pressed = 0;
1106 }
1107 #endif
1108 }
1109
1110 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1111 u8 *data, /* isoc packet */
1112 int len) /* iso packet length */
1113 {
1114 struct sd *sd = (struct sd *) gspca_dev;
1115 int pkt_type;
1116
1117 if (data[0] == 0x5a) {
1118 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1119 if (len > 20) {
1120 u8 state = (data[20] & 0x80) ? 1 : 0;
1121 if (sd->button_pressed != state) {
1122 input_report_key(gspca_dev->input_dev,
1123 KEY_CAMERA, state);
1124 input_sync(gspca_dev->input_dev);
1125 sd->button_pressed = state;
1126 }
1127 }
1128 #endif
1129 /* Control Packet, after this came the header again,
1130 * but extra bytes came in the packet before this,
1131 * sometimes an EOF arrives, sometimes not... */
1132 return;
1133 }
1134 data += 2;
1135 len -= 2;
1136 if (data[0] == 0xff && data[1] == 0xd8)
1137 pkt_type = FIRST_PACKET;
1138 else if (data[len - 2] == 0xff && data[len - 1] == 0xd9)
1139 pkt_type = LAST_PACKET;
1140 else
1141 pkt_type = INTER_PACKET;
1142 gspca_frame_add(gspca_dev, pkt_type, data, len);
1143 }
1144
1145 static int sd_setblue_gain(struct gspca_dev *gspca_dev, __s32 val)
1146 {
1147 struct sd *sd = (struct sd *) gspca_dev;
1148
1149 sd->blue_gain = val;
1150 if (gspca_dev->streaming)
1151 reg_w(gspca_dev, (val << 8) + 0x88);
1152 return 0;
1153 }
1154
1155 static int sd_getblue_gain(struct gspca_dev *gspca_dev, __s32 *val)
1156 {
1157 struct sd *sd = (struct sd *) gspca_dev;
1158
1159 *val = sd->blue_gain;
1160 return 0;
1161 }
1162
1163 static int sd_setred_gain(struct gspca_dev *gspca_dev, __s32 val)
1164 {
1165 struct sd *sd = (struct sd *) gspca_dev;
1166
1167 sd->red_gain = val;
1168 if (gspca_dev->streaming)
1169 reg_w(gspca_dev, (val << 8) + 0x87);
1170
1171 return 0;
1172 }
1173
1174 static int sd_getred_gain(struct gspca_dev *gspca_dev, __s32 *val)
1175 {
1176 struct sd *sd = (struct sd *) gspca_dev;
1177
1178 *val = sd->red_gain;
1179 return 0;
1180 }
1181
1182 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
1183 {
1184 struct sd *sd = (struct sd *) gspca_dev;
1185 u16 psg, nsg;
1186
1187 psg = sd->red_gain + sd->blue_gain + sd->green_gain;
1188 nsg = val * 3;
1189 sd->red_gain = sd->red_gain * nsg / psg;
1190 if (sd->red_gain > 0x40)
1191 sd->red_gain = 0x40;
1192 else if (sd->red_gain < 0x10)
1193 sd->red_gain = 0x10;
1194 sd->blue_gain = sd->blue_gain * nsg / psg;
1195 if (sd->blue_gain > 0x40)
1196 sd->blue_gain = 0x40;
1197 else if (sd->blue_gain < 0x10)
1198 sd->blue_gain = 0x10;
1199 sd->green_gain = sd->green_gain * nsg / psg;
1200 if (sd->green_gain > 0x40)
1201 sd->green_gain = 0x40;
1202 else if (sd->green_gain < 0x10)
1203 sd->green_gain = 0x10;
1204
1205 if (gspca_dev->streaming)
1206 setRGB(gspca_dev);
1207 return 0;
1208 }
1209
1210 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
1211 {
1212 struct sd *sd = (struct sd *) gspca_dev;
1213
1214 *val = (sd->red_gain + sd->blue_gain + sd->green_gain) / 3;
1215 return 0;
1216 }
1217
1218 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1219 {
1220 struct sd *sd = (struct sd *) gspca_dev;
1221
1222 sd->brightness = val;
1223 if (gspca_dev->streaming)
1224 setbrightness(gspca_dev);
1225 return 0;
1226 }
1227
1228 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1229 {
1230 struct sd *sd = (struct sd *) gspca_dev;
1231
1232 *val = sd->brightness;
1233 return *val;
1234 }
1235
1236 static int sd_setawb(struct gspca_dev *gspca_dev, __s32 val)
1237 {
1238 struct sd *sd = (struct sd *) gspca_dev;
1239
1240 sd->awb = val;
1241 if (gspca_dev->streaming)
1242 setawb(gspca_dev);
1243 return 0;
1244 }
1245
1246 static int sd_getawb(struct gspca_dev *gspca_dev, __s32 *val)
1247 {
1248 struct sd *sd = (struct sd *) gspca_dev;
1249
1250 *val = sd->awb;
1251 return *val;
1252 }
1253
1254 static int sd_setmirror(struct gspca_dev *gspca_dev, __s32 val)
1255 {
1256 struct sd *sd = (struct sd *) gspca_dev;
1257
1258 sd->mirror = val;
1259 if (gspca_dev->streaming)
1260 setmirror(gspca_dev);
1261 return 0;
1262 }
1263
1264 static int sd_getmirror(struct gspca_dev *gspca_dev, __s32 *val)
1265 {
1266 struct sd *sd = (struct sd *) gspca_dev;
1267
1268 *val = sd->mirror;
1269 return *val;
1270 }
1271
1272 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val)
1273 {
1274 struct sd *sd = (struct sd *) gspca_dev;
1275
1276 sd->effect = val;
1277 if (gspca_dev->streaming)
1278 seteffect(gspca_dev);
1279 return 0;
1280 }
1281
1282 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val)
1283 {
1284 struct sd *sd = (struct sd *) gspca_dev;
1285
1286 *val = sd->effect;
1287 return *val;
1288 }
1289
1290 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1291 {
1292 struct sd *sd = (struct sd *) gspca_dev;
1293
1294 sd->contrast = val;
1295 if (gspca_dev->streaming)
1296 setcontrast(gspca_dev);
1297 return 0;
1298 }
1299
1300 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1301 {
1302 struct sd *sd = (struct sd *) gspca_dev;
1303
1304 *val = sd->contrast;
1305 return *val;
1306 }
1307
1308 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1309 {
1310 struct sd *sd = (struct sd *) gspca_dev;
1311
1312 sd->colors = val;
1313 if (gspca_dev->streaming)
1314 setcolors(gspca_dev);
1315 return 0;
1316 }
1317
1318 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1319 {
1320 struct sd *sd = (struct sd *) gspca_dev;
1321
1322 *val = sd->colors;
1323 return 0;
1324 }
1325
1326 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
1327 {
1328 struct sd *sd = (struct sd *) gspca_dev;
1329
1330 sd->gamma = val;
1331 if (gspca_dev->streaming)
1332 setgamma(gspca_dev);
1333 return 0;
1334 }
1335
1336 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
1337 {
1338 struct sd *sd = (struct sd *) gspca_dev;
1339
1340 *val = sd->gamma;
1341 return 0;
1342 }
1343
1344 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1345 {
1346 struct sd *sd = (struct sd *) gspca_dev;
1347
1348 sd->freq = val;
1349 if (gspca_dev->streaming)
1350 setfreq(gspca_dev);
1351 return 0;
1352 }
1353
1354 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1355 {
1356 struct sd *sd = (struct sd *) gspca_dev;
1357
1358 *val = sd->freq;
1359 return 0;
1360 }
1361
1362 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
1363 {
1364 struct sd *sd = (struct sd *) gspca_dev;
1365
1366 sd->sharpness = val;
1367 if (gspca_dev->streaming)
1368 setsharpness(gspca_dev);
1369 return 0;
1370 }
1371
1372 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
1373 {
1374 struct sd *sd = (struct sd *) gspca_dev;
1375
1376 *val = sd->sharpness;
1377 return 0;
1378 }
1379
1380 /* Low Light set here......*/
1381 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val)
1382 {
1383 struct sd *sd = (struct sd *) gspca_dev;
1384
1385 sd->autogain = val;
1386 if (val != 0)
1387 reg_w(gspca_dev, 0xf48e);
1388 else
1389 reg_w(gspca_dev, 0xb48e);
1390 return 0;
1391 }
1392
1393 static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
1394 {
1395 struct sd *sd = (struct sd *) gspca_dev;
1396
1397 *val = sd->autogain;
1398 return 0;
1399 }
1400
1401 static int sd_querymenu(struct gspca_dev *gspca_dev,
1402 struct v4l2_querymenu *menu)
1403 {
1404 static const char *freq_nm[3] = {"NoFliker", "50 Hz", "60 Hz"};
1405
1406 switch (menu->id) {
1407 case V4L2_CID_POWER_LINE_FREQUENCY:
1408 if ((unsigned) menu->index >= ARRAY_SIZE(freq_nm))
1409 break;
1410 strcpy((char *) menu->name, freq_nm[menu->index]);
1411 return 0;
1412 case V4L2_CID_EFFECTS:
1413 if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
1414 strlcpy((char *) menu->name,
1415 effects_control[menu->index],
1416 sizeof menu->name);
1417 return 0;
1418 }
1419 break;
1420 }
1421 return -EINVAL;
1422 }
1423
1424 /* sub-driver description */
1425 static const struct sd_desc sd_desc = {
1426 .name = MODULE_NAME,
1427 .ctrls = sd_ctrls,
1428 .nctrls = ARRAY_SIZE(sd_ctrls),
1429 .config = sd_config,
1430 .init = sd_init,
1431 .start = sd_start,
1432 .stopN = sd_stopN,
1433 .pkt_scan = sd_pkt_scan,
1434 .querymenu = sd_querymenu,
1435 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1436 .other_input = 1,
1437 #endif
1438 };
1439
1440 /* -- module initialisation -- */
1441 static const struct usb_device_id device_table[] = {
1442 {USB_DEVICE(0x17a1, 0x0128)},
1443 {}
1444 };
1445 MODULE_DEVICE_TABLE(usb, device_table);
1446
1447 /* -- device connect -- */
1448 static int sd_probe(struct usb_interface *intf,
1449 const struct usb_device_id *id)
1450 {
1451 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1452 THIS_MODULE);
1453 }
1454
1455 static struct usb_driver sd_driver = {
1456 .name = MODULE_NAME,
1457 .id_table = device_table,
1458 .probe = sd_probe,
1459 .disconnect = gspca_disconnect,
1460 #ifdef CONFIG_PM
1461 .suspend = gspca_suspend,
1462 .resume = gspca_resume,
1463 #endif
1464 };
1465
1466 module_usb_driver(sd_driver);
Linux kernel - Deliverables
This page took 0.091094 seconds and 5 git commands to generate.