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