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