?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
allow coexistance of N build and AC build.
[tomato.git] / release / src-rt-6.x / linux / linux-2.6 / drivers / media / video / gspca / sunplus.c
blob28b4625bc1a8f7443b34e1670a7cfb9440ae4825
1 /*
2 * Sunplus spca504(abc) spca533 spca536 library
3 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #define MODULE_NAME "sunplus"
23
24 #include "gspca.h"
25 #include "jpeg.h"
26
27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
28 MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver");
29 MODULE_LICENSE("GPL");
30
31 /* specific webcam descriptor */
32 struct sd {
33 struct gspca_dev gspca_dev; /* !! must be the first item */
34
35 s8 brightness;
36 u8 contrast;
37 u8 colors;
38 u8 autogain;
39 u8 quality;
40 #define QUALITY_MIN 70
41 #define QUALITY_MAX 95
42 #define QUALITY_DEF 85
43
44 u8 bridge;
45 #define BRIDGE_SPCA504 0
46 #define BRIDGE_SPCA504B 1
47 #define BRIDGE_SPCA504C 2
48 #define BRIDGE_SPCA533 3
49 #define BRIDGE_SPCA536 4
50 u8 subtype;
51 #define AiptekMiniPenCam13 1
52 #define LogitechClickSmart420 2
53 #define LogitechClickSmart820 3
54 #define MegapixV4 4
55 #define MegaImageVI 5
56
57 u8 *jpeg_hdr;
58 };
59
60 /* V4L2 controls supported by the driver */
61 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
62 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
63 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
64 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
65 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
66 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
67 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
68 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
69
70 static struct ctrl sd_ctrls[] = {
71 {
72 {
73 .id = V4L2_CID_BRIGHTNESS,
74 .type = V4L2_CTRL_TYPE_INTEGER,
75 .name = "Brightness",
76 .minimum = -128,
77 .maximum = 127,
78 .step = 1,
79 #define BRIGHTNESS_DEF 0
80 .default_value = BRIGHTNESS_DEF,
81 },
82 .set = sd_setbrightness,
83 .get = sd_getbrightness,
84 },
85 {
86 {
87 .id = V4L2_CID_CONTRAST,
88 .type = V4L2_CTRL_TYPE_INTEGER,
89 .name = "Contrast",
90 .minimum = 0,
91 .maximum = 0xff,
92 .step = 1,
93 #define CONTRAST_DEF 0x20
94 .default_value = CONTRAST_DEF,
95 },
96 .set = sd_setcontrast,
97 .get = sd_getcontrast,
98 },
99 {
100 {
101 .id = V4L2_CID_SATURATION,
102 .type = V4L2_CTRL_TYPE_INTEGER,
103 .name = "Color",
104 .minimum = 0,
105 .maximum = 0xff,
106 .step = 1,
107 #define COLOR_DEF 0x1a
108 .default_value = COLOR_DEF,
109 },
110 .set = sd_setcolors,
111 .get = sd_getcolors,
112 },
113 {
114 {
115 .id = V4L2_CID_AUTOGAIN,
116 .type = V4L2_CTRL_TYPE_BOOLEAN,
117 .name = "Auto Gain",
118 .minimum = 0,
119 .maximum = 1,
120 .step = 1,
121 #define AUTOGAIN_DEF 1
122 .default_value = AUTOGAIN_DEF,
123 },
124 .set = sd_setautogain,
125 .get = sd_getautogain,
126 },
127 };
128
129 static const struct v4l2_pix_format vga_mode[] = {
130 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
131 .bytesperline = 320,
132 .sizeimage = 320 * 240 * 3 / 8 + 590,
133 .colorspace = V4L2_COLORSPACE_JPEG,
134 .priv = 2},
135 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
136 .bytesperline = 640,
137 .sizeimage = 640 * 480 * 3 / 8 + 590,
138 .colorspace = V4L2_COLORSPACE_JPEG,
139 .priv = 1},
140 };
141
142 static const struct v4l2_pix_format custom_mode[] = {
143 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
144 .bytesperline = 320,
145 .sizeimage = 320 * 240 * 3 / 8 + 590,
146 .colorspace = V4L2_COLORSPACE_JPEG,
147 .priv = 2},
148 {464, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
149 .bytesperline = 464,
150 .sizeimage = 464 * 480 * 3 / 8 + 590,
151 .colorspace = V4L2_COLORSPACE_JPEG,
152 .priv = 1},
153 };
154
155 static const struct v4l2_pix_format vga_mode2[] = {
156 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
157 .bytesperline = 176,
158 .sizeimage = 176 * 144 * 3 / 8 + 590,
159 .colorspace = V4L2_COLORSPACE_JPEG,
160 .priv = 4},
161 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
162 .bytesperline = 320,
163 .sizeimage = 320 * 240 * 3 / 8 + 590,
164 .colorspace = V4L2_COLORSPACE_JPEG,
165 .priv = 3},
166 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
167 .bytesperline = 352,
168 .sizeimage = 352 * 288 * 3 / 8 + 590,
169 .colorspace = V4L2_COLORSPACE_JPEG,
170 .priv = 2},
171 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
172 .bytesperline = 640,
173 .sizeimage = 640 * 480 * 3 / 8 + 590,
174 .colorspace = V4L2_COLORSPACE_JPEG,
175 .priv = 1},
176 };
177
178 #define SPCA50X_OFFSET_DATA 10
179 #define SPCA504_PCCAM600_OFFSET_SNAPSHOT 3
180 #define SPCA504_PCCAM600_OFFSET_COMPRESS 4
181 #define SPCA504_PCCAM600_OFFSET_MODE 5
182 #define SPCA504_PCCAM600_OFFSET_DATA 14
183 /* Frame packet header offsets for the spca533 */
184 #define SPCA533_OFFSET_DATA 16
185 #define SPCA533_OFFSET_FRAMSEQ 15
186 /* Frame packet header offsets for the spca536 */
187 #define SPCA536_OFFSET_DATA 4
188 #define SPCA536_OFFSET_FRAMSEQ 1
189
190 struct cmd {
191 u8 req;
192 u16 val;
193 u16 idx;
194 };
195
196 /* Initialisation data for the Creative PC-CAM 600 */
197 static const struct cmd spca504_pccam600_init_data[] = {
198 /* {0xa0, 0x0000, 0x0503}, * capture mode */
199 {0x00, 0x0000, 0x2000},
200 {0x00, 0x0013, 0x2301},
201 {0x00, 0x0003, 0x2000},
202 {0x00, 0x0001, 0x21ac},
203 {0x00, 0x0001, 0x21a6},
204 {0x00, 0x0000, 0x21a7}, /* brightness */
205 {0x00, 0x0020, 0x21a8}, /* contrast */
206 {0x00, 0x0001, 0x21ac}, /* sat/hue */
207 {0x00, 0x0000, 0x21ad}, /* hue */
208 {0x00, 0x001a, 0x21ae}, /* saturation */
209 {0x00, 0x0002, 0x21a3}, /* gamma */
210 {0x30, 0x0154, 0x0008},
211 {0x30, 0x0004, 0x0006},
212 {0x30, 0x0258, 0x0009},
213 {0x30, 0x0004, 0x0000},
214 {0x30, 0x0093, 0x0004},
215 {0x30, 0x0066, 0x0005},
216 {0x00, 0x0000, 0x2000},
217 {0x00, 0x0013, 0x2301},
218 {0x00, 0x0003, 0x2000},
219 {0x00, 0x0013, 0x2301},
220 {0x00, 0x0003, 0x2000},
221 };
222
223 /* Creative PC-CAM 600 specific open data, sent before using the
224 * generic initialisation data from spca504_open_data.
225 */
226 static const struct cmd spca504_pccam600_open_data[] = {
227 {0x00, 0x0001, 0x2501},
228 {0x20, 0x0500, 0x0001}, /* snapshot mode */
229 {0x00, 0x0003, 0x2880},
230 {0x00, 0x0001, 0x2881},
231 };
232
233 /* Initialisation data for the logitech clicksmart 420 */
234 static const struct cmd spca504A_clicksmart420_init_data[] = {
235 /* {0xa0, 0x0000, 0x0503}, * capture mode */
236 {0x00, 0x0000, 0x2000},
237 {0x00, 0x0013, 0x2301},
238 {0x00, 0x0003, 0x2000},
239 {0x00, 0x0001, 0x21ac},
240 {0x00, 0x0001, 0x21a6},
241 {0x00, 0x0000, 0x21a7}, /* brightness */
242 {0x00, 0x0020, 0x21a8}, /* contrast */
243 {0x00, 0x0001, 0x21ac}, /* sat/hue */
244 {0x00, 0x0000, 0x21ad}, /* hue */
245 {0x00, 0x001a, 0x21ae}, /* saturation */
246 {0x00, 0x0002, 0x21a3}, /* gamma */
247 {0x30, 0x0004, 0x000a},
248 {0xb0, 0x0001, 0x0000},
249
250
251 {0xa1, 0x0080, 0x0001},
252 {0x30, 0x0049, 0x0000},
253 {0x30, 0x0060, 0x0005},
254 {0x0c, 0x0004, 0x0000},
255 {0x00, 0x0000, 0x0000},
256 {0x00, 0x0000, 0x2000},
257 {0x00, 0x0013, 0x2301},
258 {0x00, 0x0003, 0x2000},
259 {0x00, 0x0000, 0x2000},
260
261 };
262
263 /* clicksmart 420 open data ? */
264 static const struct cmd spca504A_clicksmart420_open_data[] = {
265 {0x00, 0x0001, 0x2501},
266 {0x20, 0x0502, 0x0000},
267 {0x06, 0x0000, 0x0000},
268 {0x00, 0x0004, 0x2880},
269 {0x00, 0x0001, 0x2881},
270 /* look like setting a qTable */
271 {0x00, 0x0006, 0x2800},
272 {0x00, 0x0004, 0x2801},
273 {0x00, 0x0004, 0x2802},
274 {0x00, 0x0006, 0x2803},
275 {0x00, 0x000a, 0x2804},
276 {0x00, 0x0010, 0x2805},
277 {0x00, 0x0014, 0x2806},
278 {0x00, 0x0018, 0x2807},
279 {0x00, 0x0005, 0x2808},
280 {0x00, 0x0005, 0x2809},
281 {0x00, 0x0006, 0x280a},
282 {0x00, 0x0008, 0x280b},
283 {0x00, 0x000a, 0x280c},
284 {0x00, 0x0017, 0x280d},
285 {0x00, 0x0018, 0x280e},
286 {0x00, 0x0016, 0x280f},
287
288 {0x00, 0x0006, 0x2810},
289 {0x00, 0x0005, 0x2811},
290 {0x00, 0x0006, 0x2812},
291 {0x00, 0x000a, 0x2813},
292 {0x00, 0x0010, 0x2814},
293 {0x00, 0x0017, 0x2815},
294 {0x00, 0x001c, 0x2816},
295 {0x00, 0x0016, 0x2817},
296 {0x00, 0x0006, 0x2818},
297 {0x00, 0x0007, 0x2819},
298 {0x00, 0x0009, 0x281a},
299 {0x00, 0x000c, 0x281b},
300 {0x00, 0x0014, 0x281c},
301 {0x00, 0x0023, 0x281d},
302 {0x00, 0x0020, 0x281e},
303 {0x00, 0x0019, 0x281f},
304
305 {0x00, 0x0007, 0x2820},
306 {0x00, 0x0009, 0x2821},
307 {0x00, 0x000f, 0x2822},
308 {0x00, 0x0016, 0x2823},
309 {0x00, 0x001b, 0x2824},
310 {0x00, 0x002c, 0x2825},
311 {0x00, 0x0029, 0x2826},
312 {0x00, 0x001f, 0x2827},
313 {0x00, 0x000a, 0x2828},
314 {0x00, 0x000e, 0x2829},
315 {0x00, 0x0016, 0x282a},
316 {0x00, 0x001a, 0x282b},
317 {0x00, 0x0020, 0x282c},
318 {0x00, 0x002a, 0x282d},
319 {0x00, 0x002d, 0x282e},
320 {0x00, 0x0025, 0x282f},
321
322 {0x00, 0x0014, 0x2830},
323 {0x00, 0x001a, 0x2831},
324 {0x00, 0x001f, 0x2832},
325 {0x00, 0x0023, 0x2833},
326 {0x00, 0x0029, 0x2834},
327 {0x00, 0x0030, 0x2835},
328 {0x00, 0x0030, 0x2836},
329 {0x00, 0x0028, 0x2837},
330 {0x00, 0x001d, 0x2838},
331 {0x00, 0x0025, 0x2839},
332 {0x00, 0x0026, 0x283a},
333 {0x00, 0x0027, 0x283b},
334 {0x00, 0x002d, 0x283c},
335 {0x00, 0x0028, 0x283d},
336 {0x00, 0x0029, 0x283e},
337 {0x00, 0x0028, 0x283f},
338
339 {0x00, 0x0007, 0x2840},
340 {0x00, 0x0007, 0x2841},
341 {0x00, 0x000a, 0x2842},
342 {0x00, 0x0013, 0x2843},
343 {0x00, 0x0028, 0x2844},
344 {0x00, 0x0028, 0x2845},
345 {0x00, 0x0028, 0x2846},
346 {0x00, 0x0028, 0x2847},
347 {0x00, 0x0007, 0x2848},
348 {0x00, 0x0008, 0x2849},
349 {0x00, 0x000a, 0x284a},
350 {0x00, 0x001a, 0x284b},
351 {0x00, 0x0028, 0x284c},
352 {0x00, 0x0028, 0x284d},
353 {0x00, 0x0028, 0x284e},
354 {0x00, 0x0028, 0x284f},
355
356 {0x00, 0x000a, 0x2850},
357 {0x00, 0x000a, 0x2851},
358 {0x00, 0x0016, 0x2852},
359 {0x00, 0x0028, 0x2853},
360 {0x00, 0x0028, 0x2854},
361 {0x00, 0x0028, 0x2855},
362 {0x00, 0x0028, 0x2856},
363 {0x00, 0x0028, 0x2857},
364 {0x00, 0x0013, 0x2858},
365 {0x00, 0x001a, 0x2859},
366 {0x00, 0x0028, 0x285a},
367 {0x00, 0x0028, 0x285b},
368 {0x00, 0x0028, 0x285c},
369 {0x00, 0x0028, 0x285d},
370 {0x00, 0x0028, 0x285e},
371 {0x00, 0x0028, 0x285f},
372
373 {0x00, 0x0028, 0x2860},
374 {0x00, 0x0028, 0x2861},
375 {0x00, 0x0028, 0x2862},
376 {0x00, 0x0028, 0x2863},
377 {0x00, 0x0028, 0x2864},
378 {0x00, 0x0028, 0x2865},
379 {0x00, 0x0028, 0x2866},
380 {0x00, 0x0028, 0x2867},
381 {0x00, 0x0028, 0x2868},
382 {0x00, 0x0028, 0x2869},
383 {0x00, 0x0028, 0x286a},
384 {0x00, 0x0028, 0x286b},
385 {0x00, 0x0028, 0x286c},
386 {0x00, 0x0028, 0x286d},
387 {0x00, 0x0028, 0x286e},
388 {0x00, 0x0028, 0x286f},
389
390 {0x00, 0x0028, 0x2870},
391 {0x00, 0x0028, 0x2871},
392 {0x00, 0x0028, 0x2872},
393 {0x00, 0x0028, 0x2873},
394 {0x00, 0x0028, 0x2874},
395 {0x00, 0x0028, 0x2875},
396 {0x00, 0x0028, 0x2876},
397 {0x00, 0x0028, 0x2877},
398 {0x00, 0x0028, 0x2878},
399 {0x00, 0x0028, 0x2879},
400 {0x00, 0x0028, 0x287a},
401 {0x00, 0x0028, 0x287b},
402 {0x00, 0x0028, 0x287c},
403 {0x00, 0x0028, 0x287d},
404 {0x00, 0x0028, 0x287e},
405 {0x00, 0x0028, 0x287f},
406
407 {0xa0, 0x0000, 0x0503},
408 };
409
410 static const u8 qtable_creative_pccam[2][64] = {
411 { /* Q-table Y-components */
412 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
413 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
414 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
415 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
416 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
417 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
418 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
419 0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
420 { /* Q-table C-components */
421 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
422 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
423 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
424 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
425 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
426 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
427 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
428 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
429 };
430
431 /* FIXME: This Q-table is identical to the Creative PC-CAM one,
432 * except for one byte. Possibly a typo?
433 * NWG: 18/05/2003.
434 */
435 static const u8 qtable_spca504_default[2][64] = {
436 { /* Q-table Y-components */
437 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
438 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
439 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
440 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
441 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
442 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
443 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
444 0x16, 0x1c, 0x1d, 0x1d, 0x1d /* 0x22 */ , 0x1e, 0x1f, 0x1e,
445 },
446 { /* Q-table C-components */
447 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
448 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
449 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
450 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
451 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
452 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
453 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
454 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
455 };
456
457 /* read <len> bytes to gspca_dev->usb_buf */
458 static void reg_r(struct gspca_dev *gspca_dev,
459 u8 req,
460 u16 index,
461 u16 len)
462 {
463 #ifdef GSPCA_DEBUG
464 if (len > USB_BUF_SZ) {
465 err("reg_r: buffer overflow");
466 return;
467 }
468 #endif
469 usb_control_msg(gspca_dev->dev,
470 usb_rcvctrlpipe(gspca_dev->dev, 0),
471 req,
472 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
473 0, /* value */
474 index,
475 len ? gspca_dev->usb_buf : NULL, len,
476 500);
477 }
478
479 /* write one byte */
480 static void reg_w_1(struct gspca_dev *gspca_dev,
481 u8 req,
482 u16 value,
483 u16 index,
484 u16 byte)
485 {
486 gspca_dev->usb_buf[0] = byte;
487 usb_control_msg(gspca_dev->dev,
488 usb_sndctrlpipe(gspca_dev->dev, 0),
489 req,
490 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
491 value, index,
492 gspca_dev->usb_buf, 1,
493 500);
494 }
495
496 /* write req / index / value */
497 static int reg_w_riv(struct usb_device *dev,
498 u8 req, u16 index, u16 value)
499 {
500 int ret;
501
502 ret = usb_control_msg(dev,
503 usb_sndctrlpipe(dev, 0),
504 req,
505 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
506 value, index, NULL, 0, 500);
507 PDEBUG(D_USBO, "reg write: 0x%02x,0x%02x:0x%02x, %d",
508 req, index, value, ret);
509 if (ret < 0)
510 PDEBUG(D_ERR, "reg write: error %d", ret);
511 return ret;
512 }
513
514 /* read 1 byte */
515 static int reg_r_1(struct gspca_dev *gspca_dev,
516 u16 value) /* wValue */
517 {
518 int ret;
519
520 ret = usb_control_msg(gspca_dev->dev,
521 usb_rcvctrlpipe(gspca_dev->dev, 0),
522 0x20, /* request */
523 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
524 value,
525 0, /* index */
526 gspca_dev->usb_buf, 1,
527 500); /* timeout */
528 if (ret < 0) {
529 PDEBUG(D_ERR, "reg_r_1 err %d", ret);
530 return 0;
531 }
532 return gspca_dev->usb_buf[0];
533 }
534
535 /* read 1 or 2 bytes - returns < 0 if error */
536 static int reg_r_12(struct gspca_dev *gspca_dev,
537 u8 req, /* bRequest */
538 u16 index, /* wIndex */
539 u16 length) /* wLength (1 or 2 only) */
540 {
541 int ret;
542
543 gspca_dev->usb_buf[1] = 0;
544 ret = usb_control_msg(gspca_dev->dev,
545 usb_rcvctrlpipe(gspca_dev->dev, 0),
546 req,
547 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
548 0, /* value */
549 index,
550 gspca_dev->usb_buf, length,
551 500);
552 if (ret < 0) {
553 PDEBUG(D_ERR, "reg_read err %d", ret);
554 return -1;
555 }
556 return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
557 }
558
559 static int write_vector(struct gspca_dev *gspca_dev,
560 const struct cmd *data, int ncmds)
561 {
562 struct usb_device *dev = gspca_dev->dev;
563 int ret;
564
565 while (--ncmds >= 0) {
566 ret = reg_w_riv(dev, data->req, data->idx, data->val);
567 if (ret < 0) {
568 PDEBUG(D_ERR,
569 "Register write failed for 0x%02x, 0x%04x, 0x%04x",
570 data->req, data->val, data->idx);
571 return ret;
572 }
573 data++;
574 }
575 return 0;
576 }
577
578 static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
579 const u8 qtable[2][64])
580 {
581 struct usb_device *dev = gspca_dev->dev;
582 int i, err;
583
584 /* loop over y components */
585 for (i = 0; i < 64; i++) {
586 err = reg_w_riv(dev, 0x00, 0x2800 + i, qtable[0][i]);
587 if (err < 0)
588 return err;
589 }
590
591 /* loop over c components */
592 for (i = 0; i < 64; i++) {
593 err = reg_w_riv(dev, 0x00, 0x2840 + i, qtable[1][i]);
594 if (err < 0)
595 return err;
596 }
597 return 0;
598 }
599
600 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev,
601 u8 req, u16 idx, u16 val)
602 {
603 struct usb_device *dev = gspca_dev->dev;
604 int notdone;
605
606 reg_w_riv(dev, req, idx, val);
607 notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
608 reg_w_riv(dev, req, idx, val);
609
610 PDEBUG(D_FRAM, "before wait 0x%04x", notdone);
611
612 msleep(200);
613 notdone = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
614 PDEBUG(D_FRAM, "after wait 0x%04x", notdone);
615 }
616
617 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev,
618 u8 req,
619 u16 idx, u16 val, u8 stat, u8 count)
620 {
621 struct usb_device *dev = gspca_dev->dev;
622 int status;
623 u8 endcode;
624
625 reg_w_riv(dev, req, idx, val);
626 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
627 endcode = stat;
628 PDEBUG(D_FRAM, "Status 0x%x Need 0x%04x", status, stat);
629 if (!count)
630 return;
631 count = 200;
632 while (--count > 0) {
633 msleep(10);
634 /* gsmart mini2 write a each wait setting 1 ms is enought */
635 /* reg_w_riv(dev, req, idx, val); */
636 status = reg_r_12(gspca_dev, 0x01, 0x0001, 1);
637 if (status == endcode) {
638 PDEBUG(D_FRAM, "status 0x%04x after wait %d",
639 status, 200 - count);
640 break;
641 }
642 }
643 }
644
645 static int spca504B_PollingDataReady(struct gspca_dev *gspca_dev)
646 {
647 int count = 10;
648
649 while (--count > 0) {
650 reg_r(gspca_dev, 0x21, 0, 1);
651 if ((gspca_dev->usb_buf[0] & 0x01) == 0)
652 break;
653 msleep(10);
654 }
655 return gspca_dev->usb_buf[0];
656 }
657
658 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev)
659 {
660 int count = 50;
661
662 while (--count > 0) {
663 reg_r(gspca_dev, 0x21, 1, 1);
664 if (gspca_dev->usb_buf[0] != 0) {
665 reg_w_1(gspca_dev, 0x21, 0, 1, 0);
666 reg_r(gspca_dev, 0x21, 1, 1);
667 spca504B_PollingDataReady(gspca_dev);
668 break;
669 }
670 msleep(10);
671 }
672 }
673
674 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev)
675 {
676 u8 *data;
677
678 data = gspca_dev->usb_buf;
679 reg_r(gspca_dev, 0x20, 0, 5);
680 PDEBUG(D_STREAM, "FirmWare : %d %d %d %d %d ",
681 data[0], data[1], data[2], data[3], data[4]);
682 reg_r(gspca_dev, 0x23, 0, 64);
683 reg_r(gspca_dev, 0x23, 1, 64);
684 }
685
686 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev)
687 {
688 struct sd *sd = (struct sd *) gspca_dev;
689 struct usb_device *dev = gspca_dev->dev;
690 u8 Size;
691 int rc;
692
693 Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
694 switch (sd->bridge) {
695 case BRIDGE_SPCA533:
696 reg_w_riv(dev, 0x31, 0, 0);
697 spca504B_WaitCmdStatus(gspca_dev);
698 rc = spca504B_PollingDataReady(gspca_dev);
699 spca50x_GetFirmware(gspca_dev);
700 reg_w_1(gspca_dev, 0x24, 0, 8, 2); /* type */
701 reg_r(gspca_dev, 0x24, 8, 1);
702
703 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
704 reg_r(gspca_dev, 0x25, 4, 1); /* size */
705 rc = spca504B_PollingDataReady(gspca_dev);
706
707 /* Init the cam width height with some values get on init ? */
708 reg_w_riv(dev, 0x31, 0x04, 0);
709 spca504B_WaitCmdStatus(gspca_dev);
710 rc = spca504B_PollingDataReady(gspca_dev);
711 break;
712 default:
713 /* case BRIDGE_SPCA504B: */
714 /* case BRIDGE_SPCA536: */
715 reg_w_1(gspca_dev, 0x25, 0, 4, Size);
716 reg_r(gspca_dev, 0x25, 4, 1); /* size */
717 reg_w_1(gspca_dev, 0x27, 0, 0, 6);
718 reg_r(gspca_dev, 0x27, 0, 1); /* type */
719 rc = spca504B_PollingDataReady(gspca_dev);
720 break;
721 case BRIDGE_SPCA504:
722 Size += 3;
723 if (sd->subtype == AiptekMiniPenCam13) {
724 /* spca504a aiptek */
725 spca504A_acknowledged_command(gspca_dev,
726 0x08, Size, 0,
727 0x80 | (Size & 0x0f), 1);
728 spca504A_acknowledged_command(gspca_dev,
729 1, 3, 0, 0x9f, 0);
730 } else {
731 spca504_acknowledged_command(gspca_dev, 0x08, Size, 0);
732 }
733 break;
734 case BRIDGE_SPCA504C:
735 /* capture mode */
736 reg_w_riv(dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00);
737 reg_w_riv(dev, 0x20, 0x01, 0x0500 | (Size & 0x0f));
738 break;
739 }
740 }
741
742 static void spca504_wait_status(struct gspca_dev *gspca_dev)
743 {
744 int cnt;
745
746 cnt = 256;
747 while (--cnt > 0) {
748 /* With this we get the status, when return 0 it's all ok */
749 if (reg_r_12(gspca_dev, 0x06, 0x00, 1) == 0)
750 return;
751 msleep(10);
752 }
753 }
754
755 static void spca504B_setQtable(struct gspca_dev *gspca_dev)
756 {
757 reg_w_1(gspca_dev, 0x26, 0, 0, 3);
758 reg_r(gspca_dev, 0x26, 0, 1);
759 spca504B_PollingDataReady(gspca_dev);
760 }
761
762 static void setbrightness(struct gspca_dev *gspca_dev)
763 {
764 struct sd *sd = (struct sd *) gspca_dev;
765 struct usb_device *dev = gspca_dev->dev;
766 u16 reg;
767
768 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7;
769 reg_w_riv(dev, 0x00, reg, sd->brightness);
770 }
771
772 static void setcontrast(struct gspca_dev *gspca_dev)
773 {
774 struct sd *sd = (struct sd *) gspca_dev;
775 struct usb_device *dev = gspca_dev->dev;
776 u16 reg;
777
778 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8;
779 reg_w_riv(dev, 0x00, reg, sd->contrast);
780 }
781
782 static void setcolors(struct gspca_dev *gspca_dev)
783 {
784 struct sd *sd = (struct sd *) gspca_dev;
785 struct usb_device *dev = gspca_dev->dev;
786 u16 reg;
787
788 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae;
789 reg_w_riv(dev, 0x00, reg, sd->colors);
790 }
791
792 static void init_ctl_reg(struct gspca_dev *gspca_dev)
793 {
794 struct sd *sd = (struct sd *) gspca_dev;
795 struct usb_device *dev = gspca_dev->dev;
796 int pollreg = 1;
797
798 setbrightness(gspca_dev);
799 setcontrast(gspca_dev);
800 setcolors(gspca_dev);
801
802 switch (sd->bridge) {
803 case BRIDGE_SPCA504:
804 case BRIDGE_SPCA504C:
805 pollreg = 0;
806 /* fall thru */
807 default:
808 /* case BRIDGE_SPCA533: */
809 /* case BRIDGE_SPCA504B: */
810 reg_w_riv(dev, 0, 0x21ad, 0x00); /* hue */
811 reg_w_riv(dev, 0, 0x21ac, 0x01); /* sat/hue */
812 reg_w_riv(dev, 0, 0x21a3, 0x00); /* gamma */
813 break;
814 case BRIDGE_SPCA536:
815 reg_w_riv(dev, 0, 0x20f5, 0x40);
816 reg_w_riv(dev, 0, 0x20f4, 0x01);
817 reg_w_riv(dev, 0, 0x2089, 0x00);
818 break;
819 }
820 if (pollreg)
821 spca504B_PollingDataReady(gspca_dev);
822 }
823
824 /* this function is called at probe time */
825 static int sd_config(struct gspca_dev *gspca_dev,
826 const struct usb_device_id *id)
827 {
828 struct sd *sd = (struct sd *) gspca_dev;
829 struct cam *cam;
830
831 cam = &gspca_dev->cam;
832
833 sd->bridge = id->driver_info >> 8;
834 sd->subtype = id->driver_info;
835
836 if (sd->subtype == AiptekMiniPenCam13) {
837 /* try to get the firmware as some cam answer 2.0.1.2.2
838 * and should be a spca504b then overwrite that setting */
839 reg_r(gspca_dev, 0x20, 0, 1);
840 switch (gspca_dev->usb_buf[0]) {
841 case 1:
842 break; /* (right bridge/subtype) */
843 case 2:
844 sd->bridge = BRIDGE_SPCA504B;
845 sd->subtype = 0;
846 break;
847 default:
848 return -ENODEV;
849 }
850 }
851
852 switch (sd->bridge) {
853 default:
854 /* case BRIDGE_SPCA504B: */
855 /* case BRIDGE_SPCA504: */
856 /* case BRIDGE_SPCA536: */
857 cam->cam_mode = vga_mode;
858 cam->nmodes =ARRAY_SIZE(vga_mode);
859 break;
860 case BRIDGE_SPCA533:
861 cam->cam_mode = custom_mode;
862 if (sd->subtype == MegaImageVI) /* 320x240 only */
863 cam->nmodes = ARRAY_SIZE(custom_mode) - 1;
864 else
865 cam->nmodes = ARRAY_SIZE(custom_mode);
866 break;
867 case BRIDGE_SPCA504C:
868 cam->cam_mode = vga_mode2;
869 cam->nmodes = ARRAY_SIZE(vga_mode2);
870 break;
871 }
872 sd->brightness = BRIGHTNESS_DEF;
873 sd->contrast = CONTRAST_DEF;
874 sd->colors = COLOR_DEF;
875 sd->autogain = AUTOGAIN_DEF;
876 sd->quality = QUALITY_DEF;
877 return 0;
878 }
879
880 /* this function is called at probe and resume time */
881 static int sd_init(struct gspca_dev *gspca_dev)
882 {
883 struct sd *sd = (struct sd *) gspca_dev;
884 struct usb_device *dev = gspca_dev->dev;
885 int i, err_code;
886 u8 info[6];
887
888 switch (sd->bridge) {
889 case BRIDGE_SPCA504B:
890 reg_w_riv(dev, 0x1d, 0x00, 0);
891 reg_w_riv(dev, 0, 0x2306, 0x01);
892 reg_w_riv(dev, 0, 0x0d04, 0x00);
893 reg_w_riv(dev, 0, 0x2000, 0x00);
894 reg_w_riv(dev, 0, 0x2301, 0x13);
895 reg_w_riv(dev, 0, 0x2306, 0x00);
896 /* fall thru */
897 case BRIDGE_SPCA533:
898 spca504B_PollingDataReady(gspca_dev);
899 spca50x_GetFirmware(gspca_dev);
900 break;
901 case BRIDGE_SPCA536:
902 spca50x_GetFirmware(gspca_dev);
903 reg_r(gspca_dev, 0x00, 0x5002, 1);
904 reg_w_1(gspca_dev, 0x24, 0, 0, 0);
905 reg_r(gspca_dev, 0x24, 0, 1);
906 spca504B_PollingDataReady(gspca_dev);
907 reg_w_riv(dev, 0x34, 0, 0);
908 spca504B_WaitCmdStatus(gspca_dev);
909 break;
910 case BRIDGE_SPCA504C: /* pccam600 */
911 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)");
912 reg_w_riv(dev, 0xe0, 0x0000, 0x0000);
913 reg_w_riv(dev, 0xe0, 0x0000, 0x0001); /* reset */
914 spca504_wait_status(gspca_dev);
915 if (sd->subtype == LogitechClickSmart420)
916 write_vector(gspca_dev,
917 spca504A_clicksmart420_open_data,
918 ARRAY_SIZE(spca504A_clicksmart420_open_data));
919 else
920 write_vector(gspca_dev, spca504_pccam600_open_data,
921 ARRAY_SIZE(spca504_pccam600_open_data));
922 err_code = spca50x_setup_qtable(gspca_dev,
923 qtable_creative_pccam);
924 if (err_code < 0) {
925 PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed");
926 return err_code;
927 }
928 break;
929 default:
930 /* case BRIDGE_SPCA504: */
931 PDEBUG(D_STREAM, "Opening SPCA504");
932 if (sd->subtype == AiptekMiniPenCam13) {
933 /*****************************/
934 for (i = 0; i < 6; i++)
935 info[i] = reg_r_1(gspca_dev, i);
936 PDEBUG(D_STREAM,
937 "Read info: %d %d %d %d %d %d."
938 " Should be 1,0,2,2,0,0",
939 info[0], info[1], info[2],
940 info[3], info[4], info[5]);
941 /* spca504a aiptek */
942 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
943 spca504A_acknowledged_command(gspca_dev, 0x24,
944 8, 3, 0x9e, 1);
945 /* Twice sequencial need status 0xff->0x9e->0x9d */
946 spca504A_acknowledged_command(gspca_dev, 0x24,
947 8, 3, 0x9e, 0);
948
949 spca504A_acknowledged_command(gspca_dev, 0x24,
950 0, 0, 0x9d, 1);
951 /******************************/
952 /* spca504a aiptek */
953 spca504A_acknowledged_command(gspca_dev, 0x08,
954 6, 0, 0x86, 1);
955 /* reg_write (dev, 0, 0x2000, 0); */
956 /* reg_write (dev, 0, 0x2883, 1); */
957 /* spca504A_acknowledged_command (gspca_dev, 0x08,
958 6, 0, 0x86, 1); */
959 /* spca504A_acknowledged_command (gspca_dev, 0x24,
960 0, 0, 0x9D, 1); */
961 reg_w_riv(dev, 0x00, 0x270c, 0x05); /* L92 sno1t.txt */
962 reg_w_riv(dev, 0x00, 0x2310, 0x05);
963 spca504A_acknowledged_command(gspca_dev, 0x01,
964 0x0f, 0, 0xff, 0);
965 }
966 /* setup qtable */
967 reg_w_riv(dev, 0, 0x2000, 0);
968 reg_w_riv(dev, 0, 0x2883, 1);
969 err_code = spca50x_setup_qtable(gspca_dev,
970 qtable_spca504_default);
971 if (err_code < 0) {
972 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
973 return err_code;
974 }
975 break;
976 }
977 return 0;
978 }
979
980 static int sd_start(struct gspca_dev *gspca_dev)
981 {
982 struct sd *sd = (struct sd *) gspca_dev;
983 struct usb_device *dev = gspca_dev->dev;
984 int enable;
985 int i;
986 u8 info[6];
987
988 /* create the JPEG header */
989 sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
990 if (!sd->jpeg_hdr)
991 return -ENOMEM;
992 jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
993 0x22); /* JPEG 411 */
994 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
995
996 if (sd->bridge == BRIDGE_SPCA504B)
997 spca504B_setQtable(gspca_dev);
998 spca504B_SetSizeType(gspca_dev);
999 switch (sd->bridge) {
1000 default:
1001 /* case BRIDGE_SPCA504B: */
1002 /* case BRIDGE_SPCA533: */
1003 /* case BRIDGE_SPCA536: */
1004 switch (sd->subtype) {
1005 case MegapixV4:
1006 case LogitechClickSmart820:
1007 case MegaImageVI:
1008 reg_w_riv(dev, 0xf0, 0, 0);
1009 spca504B_WaitCmdStatus(gspca_dev);
1010 reg_r(gspca_dev, 0xf0, 4, 0);
1011 spca504B_WaitCmdStatus(gspca_dev);
1012 break;
1013 default:
1014 reg_w_riv(dev, 0x31, 0x04, 0);
1015 spca504B_WaitCmdStatus(gspca_dev);
1016 spca504B_PollingDataReady(gspca_dev);
1017 break;
1018 }
1019 break;
1020 case BRIDGE_SPCA504:
1021 if (sd->subtype == AiptekMiniPenCam13) {
1022 for (i = 0; i < 6; i++)
1023 info[i] = reg_r_1(gspca_dev, i);
1024 PDEBUG(D_STREAM,
1025 "Read info: %d %d %d %d %d %d."
1026 " Should be 1,0,2,2,0,0",
1027 info[0], info[1], info[2],
1028 info[3], info[4], info[5]);
1029 /* spca504a aiptek */
1030 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */
1031 spca504A_acknowledged_command(gspca_dev, 0x24,
1032 8, 3, 0x9e, 1);
1033 /* Twice sequencial need status 0xff->0x9e->0x9d */
1034 spca504A_acknowledged_command(gspca_dev, 0x24,
1035 8, 3, 0x9e, 0);
1036 spca504A_acknowledged_command(gspca_dev, 0x24,
1037 0, 0, 0x9d, 1);
1038 } else {
1039 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
1040 for (i = 0; i < 6; i++)
1041 info[i] = reg_r_1(gspca_dev, i);
1042 PDEBUG(D_STREAM,
1043 "Read info: %d %d %d %d %d %d."
1044 " Should be 1,0,2,2,0,0",
1045 info[0], info[1], info[2],
1046 info[3], info[4], info[5]);
1047 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3);
1048 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
1049 }
1050 spca504B_SetSizeType(gspca_dev);
1051 reg_w_riv(dev, 0x00, 0x270c, 0x05); /* L92 sno1t.txt */
1052 reg_w_riv(dev, 0x00, 0x2310, 0x05);
1053 break;
1054 case BRIDGE_SPCA504C:
1055 if (sd->subtype == LogitechClickSmart420) {
1056 write_vector(gspca_dev,
1057 spca504A_clicksmart420_init_data,
1058 ARRAY_SIZE(spca504A_clicksmart420_init_data));
1059 } else {
1060 write_vector(gspca_dev, spca504_pccam600_init_data,
1061 ARRAY_SIZE(spca504_pccam600_init_data));
1062 }
1063 enable = (sd->autogain ? 0x04 : 0x01);
1064 reg_w_riv(dev, 0x0c, 0x0000, enable); /* auto exposure */
1065 reg_w_riv(dev, 0xb0, 0x0000, enable); /* auto whiteness */
1066
1067 /* set default exposure compensation and whiteness balance */
1068 reg_w_riv(dev, 0x30, 0x0001, 800); /* ~ 20 fps */
1069 reg_w_riv(dev, 0x30, 0x0002, 1600);
1070 spca504B_SetSizeType(gspca_dev);
1071 break;
1072 }
1073 init_ctl_reg(gspca_dev);
1074 return 0;
1075 }
1076
1077 static void sd_stopN(struct gspca_dev *gspca_dev)
1078 {
1079 struct sd *sd = (struct sd *) gspca_dev;
1080 struct usb_device *dev = gspca_dev->dev;
1081
1082 switch (sd->bridge) {
1083 default:
1084 /* case BRIDGE_SPCA533: */
1085 /* case BRIDGE_SPCA536: */
1086 /* case BRIDGE_SPCA504B: */
1087 reg_w_riv(dev, 0x31, 0, 0);
1088 spca504B_WaitCmdStatus(gspca_dev);
1089 spca504B_PollingDataReady(gspca_dev);
1090 break;
1091 case BRIDGE_SPCA504:
1092 case BRIDGE_SPCA504C:
1093 reg_w_riv(dev, 0x00, 0x2000, 0x0000);
1094
1095 if (sd->subtype == AiptekMiniPenCam13) {
1096 /* spca504a aiptek */
1097 /* spca504A_acknowledged_command(gspca_dev, 0x08,
1098 6, 0, 0x86, 1); */
1099 spca504A_acknowledged_command(gspca_dev, 0x24,
1100 0x00, 0x00, 0x9d, 1);
1101 spca504A_acknowledged_command(gspca_dev, 0x01,
1102 0x0f, 0x00, 0xff, 1);
1103 } else {
1104 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0);
1105 reg_w_riv(dev, 0x01, 0x000f, 0x0000);
1106 }
1107 break;
1108 }
1109 }
1110
1111 static void sd_stop0(struct gspca_dev *gspca_dev)
1112 {
1113 struct sd *sd = (struct sd *) gspca_dev;
1114
1115 kfree(sd->jpeg_hdr);
1116 }
1117
1118 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1119 struct gspca_frame *frame, /* target */
1120 u8 *data, /* isoc packet */
1121 int len) /* iso packet length */
1122 {
1123 struct sd *sd = (struct sd *) gspca_dev;
1124 int i, sof = 0;
1125 static u8 ffd9[] = {0xff, 0xd9};
1126
1127 /* frames are jpeg 4.1.1 without 0xff escape */
1128 switch (sd->bridge) {
1129 case BRIDGE_SPCA533:
1130 if (data[0] == 0xff) {
1131 if (data[1] != 0x01) { /* drop packet */
1132 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
1133 return;
1134 }
1135 sof = 1;
1136 data += SPCA533_OFFSET_DATA;
1137 len -= SPCA533_OFFSET_DATA;
1138 } else {
1139 data += 1;
1140 len -= 1;
1141 }
1142 break;
1143 case BRIDGE_SPCA536:
1144 if (data[0] == 0xff) {
1145 sof = 1;
1146 data += SPCA536_OFFSET_DATA;
1147 len -= SPCA536_OFFSET_DATA;
1148 } else {
1149 data += 2;
1150 len -= 2;
1151 }
1152 break;
1153 default:
1154 /* case BRIDGE_SPCA504: */
1155 /* case BRIDGE_SPCA504B: */
1156 switch (data[0]) {
1157 case 0xfe: /* start of frame */
1158 sof = 1;
1159 data += SPCA50X_OFFSET_DATA;
1160 len -= SPCA50X_OFFSET_DATA;
1161 break;
1162 case 0xff: /* drop packet */
1163 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
1164 return;
1165 default:
1166 data += 1;
1167 len -= 1;
1168 break;
1169 }
1170 break;
1171 case BRIDGE_SPCA504C:
1172 switch (data[0]) {
1173 case 0xfe: /* start of frame */
1174 sof = 1;
1175 data += SPCA504_PCCAM600_OFFSET_DATA;
1176 len -= SPCA504_PCCAM600_OFFSET_DATA;
1177 break;
1178 case 0xff: /* drop packet */
1179 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
1180 return;
1181 default:
1182 data += 1;
1183 len -= 1;
1184 break;
1185 }
1186 break;
1187 }
1188 if (sof) { /* start of frame */
1189 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
1190 ffd9, 2);
1191
1192 /* put the JPEG header in the new frame */
1193 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
1194 sd->jpeg_hdr, JPEG_HDR_SZ);
1195 }
1196
1197 /* add 0x00 after 0xff */
1198 i = 0;
1199 do {
1200 if (data[i] == 0xff) {
1201 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
1202 data, i + 1);
1203 len -= i;
1204 data += i;
1205 *data = 0x00;
1206 i = 0;
1207 }
1208 i++;
1209 } while (i < len);
1210 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
1211 }
1212
1213 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1214 {
1215 struct sd *sd = (struct sd *) gspca_dev;
1216
1217 sd->brightness = val;
1218 if (gspca_dev->streaming)
1219 setbrightness(gspca_dev);
1220 return 0;
1221 }
1222
1223 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1224 {
1225 struct sd *sd = (struct sd *) gspca_dev;
1226
1227 *val = sd->brightness;
1228 return 0;
1229 }
1230
1231 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1232 {
1233 struct sd *sd = (struct sd *) gspca_dev;
1234
1235 sd->contrast = val;
1236 if (gspca_dev->streaming)
1237 setcontrast(gspca_dev);
1238 return 0;
1239 }
1240
1241 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1242 {
1243 struct sd *sd = (struct sd *) gspca_dev;
1244
1245 *val = sd->contrast;
1246 return 0;
1247 }
1248
1249 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1250 {
1251 struct sd *sd = (struct sd *) gspca_dev;
1252
1253 sd->colors = val;
1254 if (gspca_dev->streaming)
1255 setcolors(gspca_dev);
1256 return 0;
1257 }
1258
1259 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1260 {
1261 struct sd *sd = (struct sd *) gspca_dev;
1262
1263 *val = sd->colors;
1264 return 0;
1265 }
1266
1267 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
1268 {
1269 struct sd *sd = (struct sd *) gspca_dev;
1270
1271 sd->autogain = val;
1272 return 0;
1273 }
1274
1275 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
1276 {
1277 struct sd *sd = (struct sd *) gspca_dev;
1278
1279 *val = sd->autogain;
1280 return 0;
1281 }
1282
1283 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
1284 struct v4l2_jpegcompression *jcomp)
1285 {
1286 struct sd *sd = (struct sd *) gspca_dev;
1287
1288 if (jcomp->quality < QUALITY_MIN)
1289 sd->quality = QUALITY_MIN;
1290 else if (jcomp->quality > QUALITY_MAX)
1291 sd->quality = QUALITY_MAX;
1292 else
1293 sd->quality = jcomp->quality;
1294 if (gspca_dev->streaming)
1295 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
1296 return 0;
1297 }
1298
1299 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
1300 struct v4l2_jpegcompression *jcomp)
1301 {
1302 struct sd *sd = (struct sd *) gspca_dev;
1303
1304 memset(jcomp, 0, sizeof *jcomp);
1305 jcomp->quality = sd->quality;
1306 jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
1307 | V4L2_JPEG_MARKER_DQT;
1308 return 0;
1309 }
1310
1311 /* sub-driver description */
1312 static const struct sd_desc sd_desc = {
1313 .name = MODULE_NAME,
1314 .ctrls = sd_ctrls,
1315 .nctrls = ARRAY_SIZE(sd_ctrls),
1316 .config = sd_config,
1317 .init = sd_init,
1318 .start = sd_start,
1319 .stopN = sd_stopN,
1320 .stop0 = sd_stop0,
1321 .pkt_scan = sd_pkt_scan,
1322 .get_jcomp = sd_get_jcomp,
1323 .set_jcomp = sd_set_jcomp,
1324 };
1325
1326 /* -- module initialisation -- */
1327 #define BS(bridge, subtype) \
1328 .driver_info = (BRIDGE_ ## bridge << 8) \
1329 | (subtype)
1330 static const __devinitdata struct usb_device_id device_table[] = {
1331 {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)},
1332 {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)},
1333 {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)},
1334 {USB_DEVICE(0x0458, 0x7006), BS(SPCA504B, 0)},
1335 {USB_DEVICE(0x0461, 0x0821), BS(SPCA533, 0)},
1336 {USB_DEVICE(0x046d, 0x0905), BS(SPCA533, LogitechClickSmart820)},
1337 {USB_DEVICE(0x046d, 0x0960), BS(SPCA504C, LogitechClickSmart420)},
1338 {USB_DEVICE(0x0471, 0x0322), BS(SPCA504B, 0)},
1339 {USB_DEVICE(0x04a5, 0x3003), BS(SPCA504B, 0)},
1340 {USB_DEVICE(0x04a5, 0x3008), BS(SPCA533, 0)},
1341 {USB_DEVICE(0x04a5, 0x300a), BS(SPCA533, 0)},
1342 {USB_DEVICE(0x04f1, 0x1001), BS(SPCA504B, 0)},
1343 {USB_DEVICE(0x04fc, 0x500c), BS(SPCA504B, 0)},
1344 {USB_DEVICE(0x04fc, 0x504a), BS(SPCA504, AiptekMiniPenCam13)},
1345 {USB_DEVICE(0x04fc, 0x504b), BS(SPCA504B, 0)},
1346 {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)},
1347 {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)},
1348 {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)},
1349 {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)},
1350 {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)},
1351 {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)},
1352 {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)},
1353 {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)},
1354 {USB_DEVICE(0x055f, 0xc211), BS(SPCA536, 0)},
1355 {USB_DEVICE(0x055f, 0xc230), BS(SPCA533, 0)},
1356 {USB_DEVICE(0x055f, 0xc232), BS(SPCA533, 0)},
1357 {USB_DEVICE(0x055f, 0xc360), BS(SPCA536, 0)},
1358 {USB_DEVICE(0x055f, 0xc420), BS(SPCA504, 0)},
1359 {USB_DEVICE(0x055f, 0xc430), BS(SPCA533, 0)},
1360 {USB_DEVICE(0x055f, 0xc440), BS(SPCA533, 0)},
1361 {USB_DEVICE(0x055f, 0xc520), BS(SPCA504, 0)},
1362 {USB_DEVICE(0x055f, 0xc530), BS(SPCA533, 0)},
1363 {USB_DEVICE(0x055f, 0xc540), BS(SPCA533, 0)},
1364 {USB_DEVICE(0x055f, 0xc630), BS(SPCA533, 0)},
1365 {USB_DEVICE(0x055f, 0xc650), BS(SPCA533, 0)},
1366 {USB_DEVICE(0x05da, 0x1018), BS(SPCA504B, 0)},
1367 {USB_DEVICE(0x06d6, 0x0031), BS(SPCA533, 0)},
1368 {USB_DEVICE(0x0733, 0x1311), BS(SPCA533, 0)},
1369 {USB_DEVICE(0x0733, 0x1314), BS(SPCA533, 0)},
1370 {USB_DEVICE(0x0733, 0x2211), BS(SPCA533, 0)},
1371 {USB_DEVICE(0x0733, 0x2221), BS(SPCA533, 0)},
1372 {USB_DEVICE(0x0733, 0x3261), BS(SPCA536, 0)},
1373 {USB_DEVICE(0x0733, 0x3281), BS(SPCA536, 0)},
1374 {USB_DEVICE(0x08ca, 0x0104), BS(SPCA533, 0)},
1375 {USB_DEVICE(0x08ca, 0x0106), BS(SPCA533, 0)},
1376 {USB_DEVICE(0x08ca, 0x2008), BS(SPCA504B, 0)},
1377 {USB_DEVICE(0x08ca, 0x2010), BS(SPCA533, 0)},
1378 {USB_DEVICE(0x08ca, 0x2016), BS(SPCA504B, 0)},
1379 {USB_DEVICE(0x08ca, 0x2018), BS(SPCA504B, 0)},
1380 {USB_DEVICE(0x08ca, 0x2020), BS(SPCA533, 0)},
1381 {USB_DEVICE(0x08ca, 0x2022), BS(SPCA533, 0)},
1382 {USB_DEVICE(0x08ca, 0x2024), BS(SPCA536, 0)},
1383 {USB_DEVICE(0x08ca, 0x2028), BS(SPCA533, 0)},
1384 {USB_DEVICE(0x08ca, 0x2040), BS(SPCA536, 0)},
1385 {USB_DEVICE(0x08ca, 0x2042), BS(SPCA536, 0)},
1386 {USB_DEVICE(0x08ca, 0x2050), BS(SPCA536, 0)},
1387 {USB_DEVICE(0x08ca, 0x2060), BS(SPCA536, 0)},
1388 {USB_DEVICE(0x0d64, 0x0303), BS(SPCA536, 0)},
1389 {}
1390 };
1391 MODULE_DEVICE_TABLE(usb, device_table);
1392
1393 /* -- device connect -- */
1394 static int sd_probe(struct usb_interface *intf,
1395 const struct usb_device_id *id)
1396 {
1397 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1398 THIS_MODULE);
1399 }
1400
1401 static struct usb_driver sd_driver = {
1402 .name = MODULE_NAME,
1403 .id_table = device_table,
1404 .probe = sd_probe,
1405 .disconnect = gspca_disconnect,
1406 #ifdef CONFIG_PM
1407 .suspend = gspca_suspend,
1408 .resume = gspca_resume,
1409 #endif
1410 };
1411
1412 /* -- module insert / remove -- */
1413 static int __init sd_mod_init(void)
1414 {
1415 int ret;
1416 ret = usb_register(&sd_driver);
1417 if (ret < 0)
1418 return ret;
1419 PDEBUG(D_PROBE, "registered");
1420 return 0;
1421 }
1422 static void __exit sd_mod_exit(void)
1423 {
1424 usb_deregister(&sd_driver);
1425 PDEBUG(D_PROBE, "deregistered");
1426 }
1427
1428 module_init(sd_mod_init);
1429 module_exit(sd_mod_exit);
Tomato firmware and modifications.