Gitiles
Code Review Sign In
review.evervolv.com / android_kernel_htc_msm8960 / 6a7eba24e4f0ff725d33159f6265e3a79d53a833 / . / drivers / media / video / gspca / spca506.c
blob: 614fb3ad77114fd17d54f2bc1ab37fdf674f9201 [file] [log] [blame]
Jean-Francois Moine6a7eba22008-06-30 15:50:11 -0300[diff] [blame^]1/*
2 * SPCA506 chip based cameras function
3 * M Xhaard 15/04/2004 based on different work Mark Taylor and others
4 * and my own snoopy file on a pv-321c donate by a german compagny
5 * "Firma Frank Gmbh" from Saarbruecken
6 *
7 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24#define MODULE_NAME "spca506"
25
26#include "gspca.h"
27
28#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 0)
29static const char version[] = "2.1.0";
30
31MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
32MODULE_DESCRIPTION("GSPCA/SPCA506 USB Camera Driver");
33MODULE_LICENSE("GPL");
34
35/* specific webcam descriptor */
36struct sd {
37 struct gspca_dev gspca_dev; /* !! must be the first item */
38
39 int buflen;
40 unsigned char tmpbuf[640 * 480 * 3]; /* YYUV per line */
41 unsigned char tmpbuf2[640 * 480 * 2]; /* YUYV */
42
43 unsigned char brightness;
44 unsigned char contrast;
45 unsigned char colors;
46 unsigned char hue;
47 char norme;
48 char channel;
49};
50
51/* V4L2 controls supported by the driver */
52static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
53static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
54static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
55static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
56static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
57static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
58static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val);
59static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val);
60
61static struct ctrl sd_ctrls[] = {
62#define SD_BRIGHTNESS 0
63 {
64 {
65 .id = V4L2_CID_BRIGHTNESS,
66 .type = V4L2_CTRL_TYPE_INTEGER,
67 .name = "Brightness",
68 .minimum = 0,
69 .maximum = 0xff,
70 .step = 1,
71 .default_value = 0x80,
72 },
73 .set = sd_setbrightness,
74 .get = sd_getbrightness,
75 },
76#define SD_CONTRAST 1
77 {
78 {
79 .id = V4L2_CID_CONTRAST,
80 .type = V4L2_CTRL_TYPE_INTEGER,
81 .name = "Contrast",
82 .minimum = 0,
83 .maximum = 0xff,
84 .step = 1,
85 .default_value = 0x47,
86 },
87 .set = sd_setcontrast,
88 .get = sd_getcontrast,
89 },
90#define SD_COLOR 2
91 {
92 {
93 .id = V4L2_CID_SATURATION,
94 .type = V4L2_CTRL_TYPE_INTEGER,
95 .name = "Saturation",
96 .minimum = 0,
97 .maximum = 0xff,
98 .step = 1,
99 .default_value = 0x40,
100 },
101 .set = sd_setcolors,
102 .get = sd_getcolors,
103 },
104#define SD_HUE 3
105 {
106 {
107 .id = V4L2_CID_HUE,
108 .type = V4L2_CTRL_TYPE_INTEGER,
109 .name = "Hue",
110 .minimum = 0,
111 .maximum = 0xff,
112 .step = 1,
113 .default_value = 0,
114 },
115 .set = sd_sethue,
116 .get = sd_gethue,
117 },
118};
119
120static struct cam_mode vga_mode[] = {
121 {V4L2_PIX_FMT_YUYV, 160, 120, 5},
122 {V4L2_PIX_FMT_YUYV, 176, 144, 4},
123 {V4L2_PIX_FMT_YUYV, 320, 240, 2},
124 {V4L2_PIX_FMT_YUYV, 352, 288, 1},
125 {V4L2_PIX_FMT_YUYV, 640, 480, 0},
126};
127
128#define SPCA50X_OFFSET_DATA 10
129
130#define SAA7113_bright 0x0a /* defaults 0x80 */
131#define SAA7113_contrast 0x0b /* defaults 0x47 */
132#define SAA7113_saturation 0x0c /* defaults 0x40 */
133#define SAA7113_hue 0x0d /* defaults 0x00 */
134#define SAA7113_I2C_BASE_WRITE 0x4a
135
136static void reg_r(struct usb_device *dev,
137 __u16 req,
138 __u16 index,
139 __u8 *buffer, __u16 length)
140{
141 usb_control_msg(dev,
142 usb_rcvctrlpipe(dev, 0),
143 req,
144 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
145 0, /* value */
146 index, buffer, length,
147 500);
148}
149
150static void reg_w(struct usb_device *dev,
151 __u16 req,
152 __u16 value,
153 __u16 index)
154{
155 usb_control_msg(dev,
156 usb_sndctrlpipe(dev, 0),
157 req,
158 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
159 value, index,
160 NULL, 0, 500);
161}
162
163static void spca506_Initi2c(struct gspca_dev *gspca_dev)
164{
165 reg_w(gspca_dev->dev, 0x07, SAA7113_I2C_BASE_WRITE, 0x0004);
166}
167
168static void spca506_WriteI2c(struct gspca_dev *gspca_dev, __u16 valeur,
169 __u16 reg)
170{
171 int retry = 60;
172 unsigned char Data[2];
173
174 reg_w(gspca_dev->dev, 0x07, reg, 0x0001);
175 reg_w(gspca_dev->dev, 0x07, valeur, 0x0000);
176 while (retry--) {
177 reg_r(gspca_dev->dev, 0x07, 0x0003, Data, 2);
178 if ((Data[0] | Data[1]) == 0x00)
179 break;
180 }
181}
182
183static int spca506_ReadI2c(struct gspca_dev *gspca_dev, __u16 reg)
184{
185 int retry = 60;
186 unsigned char Data[2];
187 unsigned char value;
188
189 reg_w(gspca_dev->dev, 0x07, SAA7113_I2C_BASE_WRITE, 0x0004);
190 reg_w(gspca_dev->dev, 0x07, reg, 0x0001);
191 reg_w(gspca_dev->dev, 0x07, 0x01, 0x0002);
192 while (--retry) {
193 reg_r(gspca_dev->dev, 0x07, 0x0003, Data, 2);
194 if ((Data[0] | Data[1]) == 0x00)
195 break;
196 }
197 if (retry == 0)
198 return -1;
199 reg_r(gspca_dev->dev, 0x07, 0x0000, &value, 1);
200 return value;
201}
202
203static void spca506_SetNormeInput(struct gspca_dev *gspca_dev,
204 __u16 norme,
205 __u16 channel)
206{
207 struct sd *sd = (struct sd *) gspca_dev;
208/* fixme: check if channel == 0..3 and 6..9 (8 values) */
209 __u8 setbit0 = 0x00;
210 __u8 setbit1 = 0x00;
211 __u8 videomask = 0x00;
212
213 PDEBUG(D_STREAM, "** Open Set Norme **");
214 spca506_Initi2c(gspca_dev);
215 /* NTSC bit0 -> 1(525 l) PAL SECAM bit0 -> 0 (625 l) */
216 /* Composite channel bit1 -> 1 S-video bit 1 -> 0 */
217 /* and exclude SAA7113 reserved channel set default 0 otherwise */
218 if (norme & V4L2_STD_NTSC)
219 setbit0 = 0x01;
220 if (channel == 4 || channel == 5 || channel > 9)
221 channel = 0;
222 if (channel < 4)
223 setbit1 = 0x02;
224 videomask = (0x48 | setbit0 | setbit1);
225 reg_w(gspca_dev->dev, 0x08, videomask, 0x0000);
226 spca506_WriteI2c(gspca_dev, (0xc0 | (channel & 0x0F)), 0x02);
227
228 if (norme & V4L2_STD_NTSC)
229 spca506_WriteI2c(gspca_dev, 0x33, 0x0e);
230 /* Chrominance Control NTSC N */
231 else if (norme & V4L2_STD_SECAM)
232 spca506_WriteI2c(gspca_dev, 0x53, 0x0e);
233 /* Chrominance Control SECAM */
234 else
235 spca506_WriteI2c(gspca_dev, 0x03, 0x0e);
236 /* Chrominance Control PAL BGHIV */
237
238 sd->norme = norme;
239 sd->channel = channel;
240 PDEBUG(D_STREAM, "Set Video Byte to 0x%2x", videomask);
241 PDEBUG(D_STREAM, "Set Norme: %08x Channel %d", norme, channel);
242}
243
244static void spca506_GetNormeInput(struct gspca_dev *gspca_dev,
245 __u16 *norme, __u16 *channel)
246{
247 struct sd *sd = (struct sd *) gspca_dev;
248
249 /* Read the register is not so good value change so
250 we use your own copy in spca50x struct */
251 *norme = sd->norme;
252 *channel = sd->channel;
253 PDEBUG(D_STREAM, "Get Norme: %d Channel %d", *norme, *channel);
254}
255
256static void spca506_Setsize(struct gspca_dev *gspca_dev, __u16 code,
257 __u16 xmult, __u16 ymult)
258{
259 struct usb_device *dev = gspca_dev->dev;
260
261 PDEBUG(D_STREAM, "** SetSize **");
262 reg_w(dev, 0x04, (0x18 | (code & 0x07)), 0x0000);
263 /* Soft snap 0x40 Hard 0x41 */
264 reg_w(dev, 0x04, 0x41, 0x0001);
265 reg_w(dev, 0x04, 0x00, 0x0002);
266 /* reserved */
267 reg_w(dev, 0x04, 0x00, 0x0003);
268
269 /* reserved */
270 reg_w(dev, 0x04, 0x00, 0x0004);
271 /* reserved */
272 reg_w(dev, 0x04, 0x01, 0x0005);
273 /* reserced */
274 reg_w(dev, 0x04, xmult, 0x0006);
275 /* reserved */
276 reg_w(dev, 0x04, ymult, 0x0007);
277 /* compression 1 */
278 reg_w(dev, 0x04, 0x00, 0x0008);
279 /* T=64 -> 2 */
280 reg_w(dev, 0x04, 0x00, 0x0009);
281 /* threshold2D */
282 reg_w(dev, 0x04, 0x21, 0x000a);
283 /* quantization */
284 reg_w(dev, 0x04, 0x00, 0x000b);
285}
286
287/* this function is called at probe time */
288static int sd_config(struct gspca_dev *gspca_dev,
289 const struct usb_device_id *id)
290{
291 struct sd *sd = (struct sd *) gspca_dev;
292 struct cam *cam;
293
294 cam = &gspca_dev->cam;
295 cam->dev_name = (char *) id->driver_info;
296 cam->epaddr = 0x01;
297 cam->cam_mode = vga_mode;
298 cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
299 sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
300 sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
301 sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
302 sd->hue = sd_ctrls[SD_HUE].qctrl.default_value;
303 return 0;
304}
305
306/* this function is called at open time */
307static int sd_open(struct gspca_dev *gspca_dev)
308{
309 struct usb_device *dev = gspca_dev->dev;
310
311 reg_w(dev, 0x03, 0x00, 0x0004);
312 reg_w(dev, 0x03, 0xFF, 0x0003);
313 reg_w(dev, 0x03, 0x00, 0x0000);
314 reg_w(dev, 0x03, 0x1c, 0x0001);
315 reg_w(dev, 0x03, 0x18, 0x0001);
316 /* Init on PAL and composite input0 */
317 spca506_SetNormeInput(gspca_dev, 0, 0);
318 reg_w(dev, 0x03, 0x1c, 0x0001);
319 reg_w(dev, 0x03, 0x18, 0x0001);
320 reg_w(dev, 0x05, 0x00, 0x0000);
321 reg_w(dev, 0x05, 0xef, 0x0001);
322 reg_w(dev, 0x05, 0x00, 0x00c1);
323 reg_w(dev, 0x05, 0x00, 0x00c2);
324 reg_w(dev, 0x06, 0x18, 0x0002);
325 reg_w(dev, 0x06, 0xf5, 0x0011);
326 reg_w(dev, 0x06, 0x02, 0x0012);
327 reg_w(dev, 0x06, 0xfb, 0x0013);
328 reg_w(dev, 0x06, 0x00, 0x0014);
329 reg_w(dev, 0x06, 0xa4, 0x0051);
330 reg_w(dev, 0x06, 0x40, 0x0052);
331 reg_w(dev, 0x06, 0x71, 0x0053);
332 reg_w(dev, 0x06, 0x40, 0x0054);
333 /************************************************/
334 reg_w(dev, 0x03, 0x00, 0x0004);
335 reg_w(dev, 0x03, 0x00, 0x0003);
336 reg_w(dev, 0x03, 0x00, 0x0004);
337 reg_w(dev, 0x03, 0xFF, 0x0003);
338 reg_w(dev, 0x02, 0x00, 0x0000);
339 reg_w(dev, 0x03, 0x60, 0x0000);
340 reg_w(dev, 0x03, 0x18, 0x0001);
341 /* for a better reading mx :) */
342 /*sdca506_WriteI2c(value,register) */
343 spca506_Initi2c(gspca_dev);
344 spca506_WriteI2c(gspca_dev, 0x08, 0x01);
345 spca506_WriteI2c(gspca_dev, 0xc0, 0x02);
346 /* input composite video */
347 spca506_WriteI2c(gspca_dev, 0x33, 0x03);
348 spca506_WriteI2c(gspca_dev, 0x00, 0x04);
349 spca506_WriteI2c(gspca_dev, 0x00, 0x05);
350 spca506_WriteI2c(gspca_dev, 0x0d, 0x06);
351 spca506_WriteI2c(gspca_dev, 0xf0, 0x07);
352 spca506_WriteI2c(gspca_dev, 0x98, 0x08);
353 spca506_WriteI2c(gspca_dev, 0x03, 0x09);
354 spca506_WriteI2c(gspca_dev, 0x80, 0x0a);
355 spca506_WriteI2c(gspca_dev, 0x47, 0x0b);
356 spca506_WriteI2c(gspca_dev, 0x48, 0x0c);
357 spca506_WriteI2c(gspca_dev, 0x00, 0x0d);
358 spca506_WriteI2c(gspca_dev, 0x03, 0x0e); /* Chroma Pal adjust */
359 spca506_WriteI2c(gspca_dev, 0x2a, 0x0f);
360 spca506_WriteI2c(gspca_dev, 0x00, 0x10);
361 spca506_WriteI2c(gspca_dev, 0x0c, 0x11);
362 spca506_WriteI2c(gspca_dev, 0xb8, 0x12);
363 spca506_WriteI2c(gspca_dev, 0x01, 0x13);
364 spca506_WriteI2c(gspca_dev, 0x00, 0x14);
365 spca506_WriteI2c(gspca_dev, 0x00, 0x15);
366 spca506_WriteI2c(gspca_dev, 0x00, 0x16);
367 spca506_WriteI2c(gspca_dev, 0x00, 0x17);
368 spca506_WriteI2c(gspca_dev, 0x00, 0x18);
369 spca506_WriteI2c(gspca_dev, 0x00, 0x19);
370 spca506_WriteI2c(gspca_dev, 0x00, 0x1a);
371 spca506_WriteI2c(gspca_dev, 0x00, 0x1b);
372 spca506_WriteI2c(gspca_dev, 0x00, 0x1c);
373 spca506_WriteI2c(gspca_dev, 0x00, 0x1d);
374 spca506_WriteI2c(gspca_dev, 0x00, 0x1e);
375 spca506_WriteI2c(gspca_dev, 0xa1, 0x1f);
376 spca506_WriteI2c(gspca_dev, 0x02, 0x40);
377 spca506_WriteI2c(gspca_dev, 0xff, 0x41);
378 spca506_WriteI2c(gspca_dev, 0xff, 0x42);
379 spca506_WriteI2c(gspca_dev, 0xff, 0x43);
380 spca506_WriteI2c(gspca_dev, 0xff, 0x44);
381 spca506_WriteI2c(gspca_dev, 0xff, 0x45);
382 spca506_WriteI2c(gspca_dev, 0xff, 0x46);
383 spca506_WriteI2c(gspca_dev, 0xff, 0x47);
384 spca506_WriteI2c(gspca_dev, 0xff, 0x48);
385 spca506_WriteI2c(gspca_dev, 0xff, 0x49);
386 spca506_WriteI2c(gspca_dev, 0xff, 0x4a);
387 spca506_WriteI2c(gspca_dev, 0xff, 0x4b);
388 spca506_WriteI2c(gspca_dev, 0xff, 0x4c);
389 spca506_WriteI2c(gspca_dev, 0xff, 0x4d);
390 spca506_WriteI2c(gspca_dev, 0xff, 0x4e);
391 spca506_WriteI2c(gspca_dev, 0xff, 0x4f);
392 spca506_WriteI2c(gspca_dev, 0xff, 0x50);
393 spca506_WriteI2c(gspca_dev, 0xff, 0x51);
394 spca506_WriteI2c(gspca_dev, 0xff, 0x52);
395 spca506_WriteI2c(gspca_dev, 0xff, 0x53);
396 spca506_WriteI2c(gspca_dev, 0xff, 0x54);
397 spca506_WriteI2c(gspca_dev, 0xff, 0x55);
398 spca506_WriteI2c(gspca_dev, 0xff, 0x56);
399 spca506_WriteI2c(gspca_dev, 0xff, 0x57);
400 spca506_WriteI2c(gspca_dev, 0x00, 0x58);
401 spca506_WriteI2c(gspca_dev, 0x54, 0x59);
402 spca506_WriteI2c(gspca_dev, 0x07, 0x5a);
403 spca506_WriteI2c(gspca_dev, 0x83, 0x5b);
404 spca506_WriteI2c(gspca_dev, 0x00, 0x5c);
405 spca506_WriteI2c(gspca_dev, 0x00, 0x5d);
406 spca506_WriteI2c(gspca_dev, 0x00, 0x5e);
407 spca506_WriteI2c(gspca_dev, 0x00, 0x5f);
408 spca506_WriteI2c(gspca_dev, 0x00, 0x60);
409 spca506_WriteI2c(gspca_dev, 0x05, 0x61);
410 spca506_WriteI2c(gspca_dev, 0x9f, 0x62);
411 PDEBUG(D_STREAM, "** Close Init *");
412 return 0;
413}
414
415static void sd_start(struct gspca_dev *gspca_dev)
416{
417 struct usb_device *dev = gspca_dev->dev;
418 __u16 norme;
419 __u16 channel;
420 __u8 Data[2];
421
422 /**************************************/
423 reg_w(dev, 0x03, 0x00, 0x0004);
424 reg_w(dev, 0x03, 0x00, 0x0003);
425 reg_w(dev, 0x03, 0x00, 0x0004);
426 reg_w(dev, 0x03, 0xFF, 0x0003);
427 reg_w(dev, 0x02, 0x00, 0x0000);
428 reg_w(dev, 0x03, 0x60, 0x0000);
429 reg_w(dev, 0x03, 0x18, 0x0001);
430
431 /*sdca506_WriteI2c(value,register) */
432 spca506_Initi2c(gspca_dev);
433 spca506_WriteI2c(gspca_dev, 0x08, 0x01); /* Increment Delay */
434/* spca506_WriteI2c(gspca_dev, 0xc0, 0x02); * Analog Input Control 1 */
435 spca506_WriteI2c(gspca_dev, 0x33, 0x03);
436 /* Analog Input Control 2 */
437 spca506_WriteI2c(gspca_dev, 0x00, 0x04);
438 /* Analog Input Control 3 */
439 spca506_WriteI2c(gspca_dev, 0x00, 0x05);
440 /* Analog Input Control 4 */
441 spca506_WriteI2c(gspca_dev, 0x0d, 0x06);
442 /* Horizontal Sync Start 0xe9-0x0d */
443 spca506_WriteI2c(gspca_dev, 0xf0, 0x07);
444 /* Horizontal Sync Stop 0x0d-0xf0 */
445
446 spca506_WriteI2c(gspca_dev, 0x98, 0x08); /* Sync Control */
447/* Defaults value */
448 spca506_WriteI2c(gspca_dev, 0x03, 0x09); /* Luminance Control */
449 spca506_WriteI2c(gspca_dev, 0x80, 0x0a);
450 /* Luminance Brightness */
451 spca506_WriteI2c(gspca_dev, 0x47, 0x0b); /* Luminance Contrast */
452 spca506_WriteI2c(gspca_dev, 0x48, 0x0c);
453 /* Chrominance Saturation */
454 spca506_WriteI2c(gspca_dev, 0x00, 0x0d);
455 /* Chrominance Hue Control */
456 spca506_WriteI2c(gspca_dev, 0x2a, 0x0f);
457 /* Chrominance Gain Control */
458 /**************************************/
459 spca506_WriteI2c(gspca_dev, 0x00, 0x10);
460 /* Format/Delay Control */
461 spca506_WriteI2c(gspca_dev, 0x0c, 0x11); /* Output Control 1 */
462 spca506_WriteI2c(gspca_dev, 0xb8, 0x12); /* Output Control 2 */
463 spca506_WriteI2c(gspca_dev, 0x01, 0x13); /* Output Control 3 */
464 spca506_WriteI2c(gspca_dev, 0x00, 0x14); /* reserved */
465 spca506_WriteI2c(gspca_dev, 0x00, 0x15); /* VGATE START */
466 spca506_WriteI2c(gspca_dev, 0x00, 0x16); /* VGATE STOP */
467 spca506_WriteI2c(gspca_dev, 0x00, 0x17); /* VGATE Control (MSB) */
468 spca506_WriteI2c(gspca_dev, 0x00, 0x18);
469 spca506_WriteI2c(gspca_dev, 0x00, 0x19);
470 spca506_WriteI2c(gspca_dev, 0x00, 0x1a);
471 spca506_WriteI2c(gspca_dev, 0x00, 0x1b);
472 spca506_WriteI2c(gspca_dev, 0x00, 0x1c);
473 spca506_WriteI2c(gspca_dev, 0x00, 0x1d);
474 spca506_WriteI2c(gspca_dev, 0x00, 0x1e);
475 spca506_WriteI2c(gspca_dev, 0xa1, 0x1f);
476 spca506_WriteI2c(gspca_dev, 0x02, 0x40);
477 spca506_WriteI2c(gspca_dev, 0xff, 0x41);
478 spca506_WriteI2c(gspca_dev, 0xff, 0x42);
479 spca506_WriteI2c(gspca_dev, 0xff, 0x43);
480 spca506_WriteI2c(gspca_dev, 0xff, 0x44);
481 spca506_WriteI2c(gspca_dev, 0xff, 0x45);
482 spca506_WriteI2c(gspca_dev, 0xff, 0x46);
483 spca506_WriteI2c(gspca_dev, 0xff, 0x47);
484 spca506_WriteI2c(gspca_dev, 0xff, 0x48);
485 spca506_WriteI2c(gspca_dev, 0xff, 0x49);
486 spca506_WriteI2c(gspca_dev, 0xff, 0x4a);
487 spca506_WriteI2c(gspca_dev, 0xff, 0x4b);
488 spca506_WriteI2c(gspca_dev, 0xff, 0x4c);
489 spca506_WriteI2c(gspca_dev, 0xff, 0x4d);
490 spca506_WriteI2c(gspca_dev, 0xff, 0x4e);
491 spca506_WriteI2c(gspca_dev, 0xff, 0x4f);
492 spca506_WriteI2c(gspca_dev, 0xff, 0x50);
493 spca506_WriteI2c(gspca_dev, 0xff, 0x51);
494 spca506_WriteI2c(gspca_dev, 0xff, 0x52);
495 spca506_WriteI2c(gspca_dev, 0xff, 0x53);
496 spca506_WriteI2c(gspca_dev, 0xff, 0x54);
497 spca506_WriteI2c(gspca_dev, 0xff, 0x55);
498 spca506_WriteI2c(gspca_dev, 0xff, 0x56);
499 spca506_WriteI2c(gspca_dev, 0xff, 0x57);
500 spca506_WriteI2c(gspca_dev, 0x00, 0x58);
501 spca506_WriteI2c(gspca_dev, 0x54, 0x59);
502 spca506_WriteI2c(gspca_dev, 0x07, 0x5a);
503 spca506_WriteI2c(gspca_dev, 0x83, 0x5b);
504 spca506_WriteI2c(gspca_dev, 0x00, 0x5c);
505 spca506_WriteI2c(gspca_dev, 0x00, 0x5d);
506 spca506_WriteI2c(gspca_dev, 0x00, 0x5e);
507 spca506_WriteI2c(gspca_dev, 0x00, 0x5f);
508 spca506_WriteI2c(gspca_dev, 0x00, 0x60);
509 spca506_WriteI2c(gspca_dev, 0x05, 0x61);
510 spca506_WriteI2c(gspca_dev, 0x9f, 0x62);
511 /**************************************/
512 reg_w(dev, 0x05, 0x00, 0x0003);
513 reg_w(dev, 0x05, 0x00, 0x0004);
514 reg_w(dev, 0x03, 0x10, 0x0001);
515 reg_w(dev, 0x03, 0x78, 0x0000);
516 switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].mode) {
517 case 0:
518 spca506_Setsize(gspca_dev, 0, 0x10, 0x10);
519 break;
520 case 1:
521 spca506_Setsize(gspca_dev, 1, 0x1a, 0x1a);
522 break;
523 case 2:
524 spca506_Setsize(gspca_dev, 2, 0x1c, 0x1c);
525 break;
526 case 4:
527 spca506_Setsize(gspca_dev, 4, 0x34, 0x34);
528 break;
529 default:
530/* case 5: */
531 spca506_Setsize(gspca_dev, 5, 0x40, 0x40);
532 break;
533 }
534
535 /* compress setting and size */
536 /* set i2c luma */
537 reg_w(dev, 0x02, 0x01, 0x0000);
538 reg_w(dev, 0x03, 0x12, 0x000);
539 reg_r(dev, 0x04, 0x0001, Data, 2);
540 PDEBUG(D_STREAM, "webcam started");
541 spca506_GetNormeInput(gspca_dev, &norme, &channel);
542 spca506_SetNormeInput(gspca_dev, norme, channel);
543}
544
545static void sd_stopN(struct gspca_dev *gspca_dev)
546{
547 struct usb_device *dev = gspca_dev->dev;
548
549 reg_w(dev, 0x02, 0x00, 0x0000);
550 reg_w(dev, 0x03, 0x00, 0x0004);
551 reg_w(dev, 0x03, 0x00, 0x0003);
552}
553
554static void sd_stop0(struct gspca_dev *gspca_dev)
555{
556}
557
558static void sd_close(struct gspca_dev *gspca_dev)
559{
560}
561
562/* convert YYUV per line to YUYV (YUV 4:2:2) */
563static void yyuv_decode(unsigned char *out,
564 unsigned char *in,
565 int width,
566 int height)
567{
568 unsigned char *Ui, *Vi, *yi, *yi1;
569 unsigned char *out1;
570 int i, j;
571
572 yi = in;
573 for (i = height / 2; --i >= 0; ) {
574 out1 = out + width * 2; /* next line */
575 yi1 = yi + width;
576 Ui = yi1 + width;
577 Vi = Ui + width / 2;
578 for (j = width / 2; --j >= 0; ) {
579 *out++ = 128 + *yi++;
580 *out++ = 128 + *Ui;
581 *out++ = 128 + *yi++;
582 *out++ = 128 + *Vi;
583
584 *out1++ = 128 + *yi1++;
585 *out1++ = 128 + *Ui++;
586 *out1++ = 128 + *yi1++;
587 *out1++ = 128 + *Vi++;
588 }
589 yi += width * 2;
590 out = out1;
591 }
592}
593
594static void sd_pkt_scan(struct gspca_dev *gspca_dev,
595 struct gspca_frame *frame, /* target */
596 unsigned char *data, /* isoc packet */
597 int len) /* iso packet length */
598{
599 struct sd *sd = (struct sd *) gspca_dev;
600
601 switch (data[0]) {
602 case 0: /* start of frame */
603 if (gspca_dev->last_packet_type == FIRST_PACKET) {
604 yyuv_decode(sd->tmpbuf2, sd->tmpbuf,
605 gspca_dev->width,
606 gspca_dev->height);
607 frame = gspca_frame_add(gspca_dev,
608 LAST_PACKET,
609 frame,
610 sd->tmpbuf2,
611 gspca_dev->width
612 * gspca_dev->height
613 * 2);
614 }
615 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
616 data, 0);
617 data += SPCA50X_OFFSET_DATA;
618 len -= SPCA50X_OFFSET_DATA;
619 if (len > 0)
620 memcpy(sd->tmpbuf, data, len);
621 else
622 len = 0;
623 sd->buflen = len;
624 return;
625 case 0xff: /* drop */
626/* gspca_dev->last_packet_type = DISCARD_PACKET; */
627 return;
628 }
629 data += 1;
630 len -= 1;
631 memcpy(&sd->tmpbuf[sd->buflen], data, len);
632 sd->buflen += len;
633}
634
635static void setbrightness(struct gspca_dev *gspca_dev)
636{
637 struct sd *sd = (struct sd *) gspca_dev;
638
639 spca506_Initi2c(gspca_dev);
640 spca506_WriteI2c(gspca_dev, sd->brightness, SAA7113_bright);
641 spca506_WriteI2c(gspca_dev, 0x01, 0x09);
642}
643
644static void getbrightness(struct gspca_dev *gspca_dev)
645{
646 struct sd *sd = (struct sd *) gspca_dev;
647
648 sd->brightness = spca506_ReadI2c(gspca_dev, SAA7113_bright);
649}
650
651static void setcontrast(struct gspca_dev *gspca_dev)
652{
653 struct sd *sd = (struct sd *) gspca_dev;
654
655 spca506_Initi2c(gspca_dev);
656 spca506_WriteI2c(gspca_dev, sd->contrast, SAA7113_contrast);
657 spca506_WriteI2c(gspca_dev, 0x01, 0x09);
658}
659
660static void getcontrast(struct gspca_dev *gspca_dev)
661{
662 struct sd *sd = (struct sd *) gspca_dev;
663
664 sd->contrast = spca506_ReadI2c(gspca_dev, SAA7113_contrast);
665}
666
667static void setcolors(struct gspca_dev *gspca_dev)
668{
669 struct sd *sd = (struct sd *) gspca_dev;
670
671 spca506_Initi2c(gspca_dev);
672 spca506_WriteI2c(gspca_dev, sd->colors, SAA7113_saturation);
673 spca506_WriteI2c(gspca_dev, 0x01, 0x09);
674}
675
676static void getcolors(struct gspca_dev *gspca_dev)
677{
678 struct sd *sd = (struct sd *) gspca_dev;
679
680 sd->colors = spca506_ReadI2c(gspca_dev, SAA7113_saturation);
681}
682
683static void sethue(struct gspca_dev *gspca_dev)
684{
685 struct sd *sd = (struct sd *) gspca_dev;
686
687 spca506_Initi2c(gspca_dev);
688 spca506_WriteI2c(gspca_dev, sd->hue, SAA7113_hue);
689 spca506_WriteI2c(gspca_dev, 0x01, 0x09);
690}
691
692static void gethue(struct gspca_dev *gspca_dev)
693{
694 struct sd *sd = (struct sd *) gspca_dev;
695
696 sd->hue = spca506_ReadI2c(gspca_dev, SAA7113_hue);
697}
698
699static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
700{
701 struct sd *sd = (struct sd *) gspca_dev;
702
703 sd->brightness = val;
704 if (gspca_dev->streaming)
705 setbrightness(gspca_dev);
706 return 0;
707}
708
709static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
710{
711 struct sd *sd = (struct sd *) gspca_dev;
712
713 getbrightness(gspca_dev);
714 *val = sd->brightness;
715 return 0;
716}
717
718static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
719{
720 struct sd *sd = (struct sd *) gspca_dev;
721
722 sd->contrast = val;
723 if (gspca_dev->streaming)
724 setcontrast(gspca_dev);
725 return 0;
726}
727
728static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
729{
730 struct sd *sd = (struct sd *) gspca_dev;
731
732 getcontrast(gspca_dev);
733 *val = sd->contrast;
734 return 0;
735}
736
737static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
738{
739 struct sd *sd = (struct sd *) gspca_dev;
740
741 sd->colors = val;
742 if (gspca_dev->streaming)
743 setcolors(gspca_dev);
744 return 0;
745}
746
747static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
748{
749 struct sd *sd = (struct sd *) gspca_dev;
750
751 getcolors(gspca_dev);
752 *val = sd->colors;
753 return 0;
754}
755
756static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val)
757{
758 struct sd *sd = (struct sd *) gspca_dev;
759
760 sd->hue = val;
761 if (gspca_dev->streaming)
762 sethue(gspca_dev);
763 return 0;
764}
765
766static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val)
767{
768 struct sd *sd = (struct sd *) gspca_dev;
769
770 gethue(gspca_dev);
771 *val = sd->hue;
772 return 0;
773}
774
775/* sub-driver description */
776static struct sd_desc sd_desc = {
777 .name = MODULE_NAME,
778 .ctrls = sd_ctrls,
779 .nctrls = ARRAY_SIZE(sd_ctrls),
780 .config = sd_config,
781 .open = sd_open,
782 .start = sd_start,
783 .stopN = sd_stopN,
784 .stop0 = sd_stop0,
785 .close = sd_close,
786 .pkt_scan = sd_pkt_scan,
787};
788
789/* -- module initialisation -- */
790#define DVNM(name) .driver_info = (kernel_ulong_t) name
791static __devinitdata struct usb_device_id device_table[] = {
792 {USB_DEVICE(0x06e1, 0xa190), DVNM("ADS Instant VCD")},
793/* {USB_DEVICE(0x0733, 0x0430), DVNM("UsbGrabber PV321c")}, */
794 {USB_DEVICE(0x0734, 0x043b), DVNM("3DeMon USB Capture aka")},
795 {USB_DEVICE(0x99fa, 0x8988), DVNM("Grandtec V.cap")},
796 {}
797};
798MODULE_DEVICE_TABLE(usb, device_table);
799
800/* -- device connect -- */
801static int sd_probe(struct usb_interface *intf,
802 const struct usb_device_id *id)
803{
804 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
805 THIS_MODULE);
806}
807
808static struct usb_driver sd_driver = {
809 .name = MODULE_NAME,
810 .id_table = device_table,
811 .probe = sd_probe,
812 .disconnect = gspca_disconnect,
813};
814
815/* -- module insert / remove -- */
816static int __init sd_mod_init(void)
817{
818 if (usb_register(&sd_driver) < 0)
819 return -1;
820 PDEBUG(D_PROBE, "v%s registered", version);
821 return 0;
822}
823static void __exit sd_mod_exit(void)
824{
825 usb_deregister(&sd_driver);
826 PDEBUG(D_PROBE, "deregistered");
827}
828
829module_init(sd_mod_init);
830module_exit(sd_mod_exit);