aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/gspca/spca561.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/gspca/spca561.c')
-rw-r--r--drivers/media/video/gspca/spca561.c1052
1 files changed, 1052 insertions, 0 deletions
diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c
new file mode 100644
index 000000000000..b659bd0f788d
--- /dev/null
+++ b/drivers/media/video/gspca/spca561.c
@@ -0,0 +1,1052 @@
1/*
2 * Sunplus spca561 subdriver
3 *
4 * Copyright (C) 2004 Michel Xhaard mxhaard@magic.fr
5 *
6 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23#define MODULE_NAME "spca561"
24
25#include "gspca.h"
26
27#define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 7)
28static const char version[] = "2.1.7";
29
30MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
31MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
32MODULE_LICENSE("GPL");
33
34/* specific webcam descriptor */
35struct sd {
36 struct gspca_dev gspca_dev; /* !! must be the first item */
37
38 unsigned short contrast;
39 __u8 brightness;
40 __u8 autogain;
41
42 __u8 chip_revision;
43 signed char ag_cnt;
44#define AG_CNT_START 13
45};
46
47/* V4L2 controls supported by the driver */
48static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
49static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
50static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
51static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
52static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
53static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
54
55static struct ctrl sd_ctrls[] = {
56#define SD_BRIGHTNESS 0
57 {
58 {
59 .id = V4L2_CID_BRIGHTNESS,
60 .type = V4L2_CTRL_TYPE_INTEGER,
61 .name = "Brightness",
62 .minimum = 0,
63 .maximum = 63,
64 .step = 1,
65 .default_value = 32,
66 },
67 .set = sd_setbrightness,
68 .get = sd_getbrightness,
69 },
70#define SD_CONTRAST 1
71 {
72 {
73 .id = V4L2_CID_CONTRAST,
74 .type = V4L2_CTRL_TYPE_INTEGER,
75 .name = "Contrast",
76 .minimum = 0,
77 .maximum = 0x3fff,
78 .step = 1,
79 .default_value = 0x2000,
80 },
81 .set = sd_setcontrast,
82 .get = sd_getcontrast,
83 },
84#define SD_AUTOGAIN 2
85 {
86 {
87 .id = V4L2_CID_AUTOGAIN,
88 .type = V4L2_CTRL_TYPE_BOOLEAN,
89 .name = "Auto Gain",
90 .minimum = 0,
91 .maximum = 1,
92 .step = 1,
93 .default_value = 1,
94 },
95 .set = sd_setautogain,
96 .get = sd_getautogain,
97 },
98};
99
100static struct v4l2_pix_format sif_mode[] = {
101 {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
102 .bytesperline = 160,
103 .sizeimage = 160 * 120,
104 .colorspace = V4L2_COLORSPACE_SRGB,
105 .priv = 3},
106 {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
107 .bytesperline = 176,
108 .sizeimage = 176 * 144,
109 .colorspace = V4L2_COLORSPACE_SRGB,
110 .priv = 2},
111 {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
112 .bytesperline = 320,
113 .sizeimage = 320 * 240 * 4 / 8,
114 .colorspace = V4L2_COLORSPACE_SRGB,
115 .priv = 1},
116 {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
117 .bytesperline = 352,
118 .sizeimage = 352 * 288 * 4 / 8,
119 .colorspace = V4L2_COLORSPACE_SRGB,
120 .priv = 0},
121};
122
123/*
124 * Initialization data
125 * I'm not very sure how to split initialization from open data
126 * chunks. For now, we'll consider everything as initialization
127 */
128/* Frame packet header offsets for the spca561 */
129#define SPCA561_OFFSET_SNAP 1
130#define SPCA561_OFFSET_TYPE 2
131#define SPCA561_OFFSET_COMPRESS 3
132#define SPCA561_OFFSET_FRAMSEQ 4
133#define SPCA561_OFFSET_GPIO 5
134#define SPCA561_OFFSET_USBBUFF 6
135#define SPCA561_OFFSET_WIN2GRAVE 7
136#define SPCA561_OFFSET_WIN2RAVE 8
137#define SPCA561_OFFSET_WIN2BAVE 9
138#define SPCA561_OFFSET_WIN2GBAVE 10
139#define SPCA561_OFFSET_WIN1GRAVE 11
140#define SPCA561_OFFSET_WIN1RAVE 12
141#define SPCA561_OFFSET_WIN1BAVE 13
142#define SPCA561_OFFSET_WIN1GBAVE 14
143#define SPCA561_OFFSET_FREQ 15
144#define SPCA561_OFFSET_VSYNC 16
145#define SPCA561_OFFSET_DATA 1
146#define SPCA561_INDEX_I2C_BASE 0x8800
147#define SPCA561_SNAPBIT 0x20
148#define SPCA561_SNAPCTRL 0x40
149enum {
150 Rev072A = 0,
151 Rev012A,
152};
153
154static void reg_w_val(struct usb_device *dev, __u16 index, __u16 value)
155{
156 int ret;
157
158 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
159 0, /* request */
160 USB_TYPE_VENDOR | USB_RECIP_DEVICE,
161 value, index, NULL, 0, 500);
162 PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value);
163 if (ret < 0)
164 PDEBUG(D_ERR, "reg write: error %d", ret);
165}
166
167static void write_vector(struct gspca_dev *gspca_dev,
168 const __u16 data[][2])
169{
170 struct usb_device *dev = gspca_dev->dev;
171 int i;
172
173 i = 0;
174 while (data[i][1] != 0) {
175 reg_w_val(dev, data[i][1], data[i][0]);
176 i++;
177 }
178}
179
180/* read 'len' bytes to gspca_dev->usb_buf */
181static void reg_r(struct gspca_dev *gspca_dev,
182 __u16 index, __u16 length)
183{
184 usb_control_msg(gspca_dev->dev,
185 usb_rcvctrlpipe(gspca_dev->dev, 0),
186 0, /* request */
187 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
188 0, /* value */
189 index, gspca_dev->usb_buf, length, 500);
190}
191
192static void reg_w_buf(struct gspca_dev *gspca_dev,
193 __u16 index, const __u8 *buffer, __u16 len)
194{
195 memcpy(gspca_dev->usb_buf, buffer, len);
196 usb_control_msg(gspca_dev->dev,
197 usb_sndctrlpipe(gspca_dev->dev, 0),
198 0, /* request */
199 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
200 0, /* value */
201 index, gspca_dev->usb_buf, len, 500);
202}
203
204static void i2c_init(struct gspca_dev *gspca_dev, __u8 mode)
205{
206 reg_w_val(gspca_dev->dev, 0x92, 0x8804);
207 reg_w_val(gspca_dev->dev, mode, 0x8802);
208}
209
210static void i2c_write(struct gspca_dev *gspca_dev, __u16 valeur, __u16 reg)
211{
212 int retry = 60;
213 __u8 DataLow;
214 __u8 DataHight;
215
216 DataLow = valeur;
217 DataHight = valeur >> 8;
218 reg_w_val(gspca_dev->dev, reg, 0x8801);
219 reg_w_val(gspca_dev->dev, DataLow, 0x8805);
220 reg_w_val(gspca_dev->dev, DataHight, 0x8800);
221 while (retry--) {
222 reg_r(gspca_dev, 0x8803, 1);
223 if (!gspca_dev->usb_buf[0])
224 break;
225 }
226}
227
228static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
229{
230 int retry = 60;
231 __u8 value;
232 __u8 vallsb;
233
234 reg_w_val(gspca_dev->dev, 0x92, 0x8804);
235 reg_w_val(gspca_dev->dev, reg, 0x8801);
236 reg_w_val(gspca_dev->dev, (mode | 0x01), 0x8802);
237 while (retry--) {
238 reg_r(gspca_dev, 0x8803, 1);
239 if (!gspca_dev->usb_buf)
240 break;
241 }
242 if (retry == 0)
243 return -1;
244 reg_r(gspca_dev, 0x8800, 1);
245 value = gspca_dev->usb_buf[0];
246 reg_r(gspca_dev, 0x8805, 1);
247 vallsb = gspca_dev->usb_buf[0];
248 return ((int) value << 8) | vallsb;
249}
250
251static const __u16 spca561_init_data[][2] = {
252 {0x0000, 0x8114}, /* Software GPIO output data */
253 {0x0001, 0x8114}, /* Software GPIO output data */
254 {0x0000, 0x8112}, /* Some kind of reset */
255 {0x0003, 0x8701}, /* PCLK clock delay adjustment */
256 {0x0001, 0x8703}, /* HSYNC from cmos inverted */
257 {0x0011, 0x8118}, /* Enable and conf sensor */
258 {0x0001, 0x8118}, /* Conf sensor */
259 {0x0092, 0x8804}, /* I know nothing about these */
260 {0x0010, 0x8802}, /* 0x88xx registers, so I won't */
261 /***************/
262 {0x000d, 0x8805}, /* sensor default setting */
263 {0x0001, 0x8801}, /* 1 <- 0x0d */
264 {0x0000, 0x8800},
265 {0x0018, 0x8805},
266 {0x0002, 0x8801}, /* 2 <- 0x18 */
267 {0x0000, 0x8800},
268 {0x0065, 0x8805},
269 {0x0004, 0x8801}, /* 4 <- 0x01 0x65 */
270 {0x0001, 0x8800},
271 {0x0021, 0x8805},
272 {0x0005, 0x8801}, /* 5 <- 0x21 */
273 {0x0000, 0x8800},
274 {0x00aa, 0x8805},
275 {0x0007, 0x8801}, /* 7 <- 0xaa */
276 {0x0000, 0x8800},
277 {0x0004, 0x8805},
278 {0x0020, 0x8801}, /* 0x20 <- 0x15 0x04 */
279 {0x0015, 0x8800},
280 {0x0002, 0x8805},
281 {0x0039, 0x8801}, /* 0x39 <- 0x02 */
282 {0x0000, 0x8800},
283 {0x0010, 0x8805},
284 {0x0035, 0x8801}, /* 0x35 <- 0x10 */
285 {0x0000, 0x8800},
286 {0x0049, 0x8805},
287 {0x0009, 0x8801}, /* 0x09 <- 0x10 0x49 */
288 {0x0010, 0x8800},
289 {0x000b, 0x8805},
290 {0x0028, 0x8801}, /* 0x28 <- 0x0b */
291 {0x0000, 0x8800},
292 {0x000f, 0x8805},
293 {0x003b, 0x8801}, /* 0x3b <- 0x0f */
294 {0x0000, 0x8800},
295 {0x0000, 0x8805},
296 {0x003c, 0x8801}, /* 0x3c <- 0x00 */
297 {0x0000, 0x8800},
298 /***************/
299 {0x0018, 0x8601}, /* Pixel/line selection for color separation */
300 {0x0000, 0x8602}, /* Optical black level for user setting */
301 {0x0060, 0x8604}, /* Optical black horizontal offset */
302 {0x0002, 0x8605}, /* Optical black vertical offset */
303 {0x0000, 0x8603}, /* Non-automatic optical black level */
304 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */
305 {0x0000, 0x865f}, /* Vertical valid pixels window (x2) */
306 {0x00b0, 0x865d}, /* Horizontal valid pixels window (x2) */
307 {0x0090, 0x865e}, /* Vertical valid lines window (x2) */
308 {0x00e0, 0x8406}, /* Memory buffer threshold */
309 {0x0000, 0x8660}, /* Compensation memory stuff */
310 {0x0002, 0x8201}, /* Output address for r/w serial EEPROM */
311 {0x0008, 0x8200}, /* Clear valid bit for serial EEPROM */
312 {0x0001, 0x8200}, /* OprMode to be executed by hardware */
313 {0x0007, 0x8201}, /* Output address for r/w serial EEPROM */
314 {0x0008, 0x8200}, /* Clear valid bit for serial EEPROM */
315 {0x0001, 0x8200}, /* OprMode to be executed by hardware */
316 {0x0010, 0x8660}, /* Compensation memory stuff */
317 {0x0018, 0x8660}, /* Compensation memory stuff */
318
319 {0x0004, 0x8611}, /* R offset for white balance */
320 {0x0004, 0x8612}, /* Gr offset for white balance */
321 {0x0007, 0x8613}, /* B offset for white balance */
322 {0x0000, 0x8614}, /* Gb offset for white balance */
323 {0x008c, 0x8651}, /* R gain for white balance */
324 {0x008c, 0x8652}, /* Gr gain for white balance */
325 {0x00b5, 0x8653}, /* B gain for white balance */
326 {0x008c, 0x8654}, /* Gb gain for white balance */
327 {0x0002, 0x8502}, /* Maximum average bit rate stuff */
328
329 {0x0011, 0x8802},
330 {0x0087, 0x8700}, /* Set master clock (96Mhz????) */
331 {0x0081, 0x8702}, /* Master clock output enable */
332
333 {0x0000, 0x8500}, /* Set image type (352x288 no compression) */
334 /* Originally was 0x0010 (352x288 compression) */
335
336 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */
337 {0x0003, 0x865c}, /* Vertical offset for valid lines */
338 /***************//* sensor active */
339 {0x0003, 0x8801}, /* 0x03 <- 0x01 0x21 //289 */
340 {0x0021, 0x8805},
341 {0x0001, 0x8800},
342 {0x0004, 0x8801}, /* 0x04 <- 0x01 0x65 //357 */
343 {0x0065, 0x8805},
344 {0x0001, 0x8800},
345 {0x0005, 0x8801}, /* 0x05 <- 0x2f */
346 {0x002f, 0x8805},
347 {0x0000, 0x8800},
348 {0x0006, 0x8801}, /* 0x06 <- 0 */
349 {0x0000, 0x8805},
350 {0x0000, 0x8800},
351 {0x000a, 0x8801}, /* 0x0a <- 2 */
352 {0x0002, 0x8805},
353 {0x0000, 0x8800},
354 {0x0009, 0x8801}, /* 0x09 <- 0x1061 */
355 {0x0061, 0x8805},
356 {0x0010, 0x8800},
357 {0x0035, 0x8801}, /* 0x35 <-0x14 */
358 {0x0014, 0x8805},
359 {0x0000, 0x8800},
360 {0x0030, 0x8112}, /* ISO and drop packet enable */
361 {0x0000, 0x8112}, /* Some kind of reset ???? */
362 {0x0009, 0x8118}, /* Enable sensor and set standby */
363 {0x0000, 0x8114}, /* Software GPIO output data */
364 {0x0000, 0x8114}, /* Software GPIO output data */
365 {0x0001, 0x8114}, /* Software GPIO output data */
366 {0x0000, 0x8112}, /* Some kind of reset ??? */
367 {0x0003, 0x8701},
368 {0x0001, 0x8703},
369 {0x0011, 0x8118},
370 {0x0001, 0x8118},
371 /***************/
372 {0x0092, 0x8804},
373 {0x0010, 0x8802},
374 {0x000d, 0x8805},
375 {0x0001, 0x8801},
376 {0x0000, 0x8800},
377 {0x0018, 0x8805},
378 {0x0002, 0x8801},
379 {0x0000, 0x8800},
380 {0x0065, 0x8805},
381 {0x0004, 0x8801},
382 {0x0001, 0x8800},
383 {0x0021, 0x8805},
384 {0x0005, 0x8801},
385 {0x0000, 0x8800},
386 {0x00aa, 0x8805},
387 {0x0007, 0x8801}, /* mode 0xaa */
388 {0x0000, 0x8800},
389 {0x0004, 0x8805},
390 {0x0020, 0x8801},
391 {0x0015, 0x8800}, /* mode 0x0415 */
392 {0x0002, 0x8805},
393 {0x0039, 0x8801},
394 {0x0000, 0x8800},
395 {0x0010, 0x8805},
396 {0x0035, 0x8801},
397 {0x0000, 0x8800},
398 {0x0049, 0x8805},
399 {0x0009, 0x8801},
400 {0x0010, 0x8800},
401 {0x000b, 0x8805},
402 {0x0028, 0x8801},
403 {0x0000, 0x8800},
404 {0x000f, 0x8805},
405 {0x003b, 0x8801},
406 {0x0000, 0x8800},
407 {0x0000, 0x8805},
408 {0x003c, 0x8801},
409 {0x0000, 0x8800},
410 {0x0002, 0x8502},
411 {0x0039, 0x8801},
412 {0x0000, 0x8805},
413 {0x0000, 0x8800},
414
415 {0x0087, 0x8700}, /* overwrite by start */
416 {0x0081, 0x8702},
417 {0x0000, 0x8500},
418/* {0x0010, 0x8500}, -- Previous line was this */
419 {0x0002, 0x865b},
420 {0x0003, 0x865c},
421 /***************/
422 {0x0003, 0x8801}, /* 0x121-> 289 */
423 {0x0021, 0x8805},
424 {0x0001, 0x8800},
425 {0x0004, 0x8801}, /* 0x165 -> 357 */
426 {0x0065, 0x8805},
427 {0x0001, 0x8800},
428 {0x0005, 0x8801}, /* 0x2f //blanking control colonne */
429 {0x002f, 0x8805},
430 {0x0000, 0x8800},
431 {0x0006, 0x8801}, /* 0x00 //blanking mode row */
432 {0x0000, 0x8805},
433 {0x0000, 0x8800},
434 {0x000a, 0x8801}, /* 0x01 //0x02 */
435 {0x0001, 0x8805},
436 {0x0000, 0x8800},
437 {0x0009, 0x8801}, /* 0x1061 - setexposure times && pixel clock
438 * 0001 0 | 000 0110 0001 */
439 {0x0061, 0x8805}, /* 61 31 */
440 {0x0008, 0x8800}, /* 08 */
441 {0x0035, 0x8801}, /* 0x14 - set gain general */
442 {0x001f, 0x8805}, /* 0x14 */
443 {0x0000, 0x8800},
444 {0x0030, 0x8112},
445 {}
446};
447
448static void sensor_reset(struct gspca_dev *gspca_dev)
449{
450 reg_w_val(gspca_dev->dev, 0x8631, 0xc8);
451 reg_w_val(gspca_dev->dev, 0x8634, 0xc8);
452 reg_w_val(gspca_dev->dev, 0x8112, 0x00);
453 reg_w_val(gspca_dev->dev, 0x8114, 0x00);
454 reg_w_val(gspca_dev->dev, 0x8118, 0x21);
455 i2c_init(gspca_dev, 0x14);
456 i2c_write(gspca_dev, 1, 0x0d);
457 i2c_write(gspca_dev, 0, 0x0d);
458}
459
460/******************** QC Express etch2 stuff ********************/
461static const __u16 Pb100_1map8300[][2] = {
462 /* reg, value */
463 {0x8320, 0x3304},
464
465 {0x8303, 0x0125}, /* image area */
466 {0x8304, 0x0169},
467 {0x8328, 0x000b},
468 {0x833c, 0x0001},
469
470 {0x832f, 0x0419},
471 {0x8307, 0x00aa},
472 {0x8301, 0x0003},
473 {0x8302, 0x000e},
474 {}
475};
476static const __u16 Pb100_2map8300[][2] = {
477 /* reg, value */
478 {0x8339, 0x0000},
479 {0x8307, 0x00aa},
480 {}
481};
482
483static const __u16 spca561_161rev12A_data1[][2] = {
484 {0x21, 0x8118},
485 {0x01, 0x8114},
486 {0x00, 0x8112},
487 {0x92, 0x8804},
488 {0x04, 0x8802}, /* windows uses 08 */
489 {}
490};
491static const __u16 spca561_161rev12A_data2[][2] = {
492 {0x21, 0x8118},
493 {0x10, 0x8500},
494 {0x07, 0x8601},
495 {0x07, 0x8602},
496 {0x04, 0x8501},
497 {0x21, 0x8118},
498
499 {0x07, 0x8201}, /* windows uses 02 */
500 {0x08, 0x8200},
501 {0x01, 0x8200},
502
503 {0x00, 0x8114},
504 {0x01, 0x8114}, /* windows uses 00 */
505
506 {0x90, 0x8604},
507 {0x00, 0x8605},
508 {0xb0, 0x8603},
509
510 /* sensor gains */
511 {0x00, 0x8610}, /* *red */
512 {0x00, 0x8611}, /* 3f *green */
513 {0x00, 0x8612}, /* green *blue */
514 {0x00, 0x8613}, /* blue *green */
515 {0x35, 0x8614}, /* green *red */
516 {0x35, 0x8615}, /* 40 *green */
517 {0x35, 0x8616}, /* 7a *blue */
518 {0x35, 0x8617}, /* 40 *green */
519
520 {0x0c, 0x8620}, /* 0c */
521 {0xc8, 0x8631}, /* c8 */
522 {0xc8, 0x8634}, /* c8 */
523 {0x23, 0x8635}, /* 23 */
524 {0x1f, 0x8636}, /* 1f */
525 {0xdd, 0x8637}, /* dd */
526 {0xe1, 0x8638}, /* e1 */
527 {0x1d, 0x8639}, /* 1d */
528 {0x21, 0x863a}, /* 21 */
529 {0xe3, 0x863b}, /* e3 */
530 {0xdf, 0x863c}, /* df */
531 {0xf0, 0x8505},
532 {0x32, 0x850a},
533 {}
534};
535
536static void sensor_mapwrite(struct gspca_dev *gspca_dev,
537 const __u16 sensormap[][2])
538{
539 int i = 0;
540 __u8 usbval[2];
541
542 while (sensormap[i][0]) {
543 usbval[0] = sensormap[i][1];
544 usbval[1] = sensormap[i][1] >> 8;
545 reg_w_buf(gspca_dev, sensormap[i][0], usbval, 2);
546 i++;
547 }
548}
549static void init_161rev12A(struct gspca_dev *gspca_dev)
550{
551 sensor_reset(gspca_dev);
552 write_vector(gspca_dev, spca561_161rev12A_data1);
553 sensor_mapwrite(gspca_dev, Pb100_1map8300);
554 write_vector(gspca_dev, spca561_161rev12A_data2);
555 sensor_mapwrite(gspca_dev, Pb100_2map8300);
556}
557
558/* this function is called at probe time */
559static int sd_config(struct gspca_dev *gspca_dev,
560 const struct usb_device_id *id)
561{
562 struct sd *sd = (struct sd *) gspca_dev;
563 struct cam *cam;
564 __u16 vendor, product;
565 __u8 data1, data2;
566
567 /* Read frm global register the USB product and vendor IDs, just to
568 * prove that we can communicate with the device. This works, which
569 * confirms at we are communicating properly and that the device
570 * is a 561. */
571 reg_r(gspca_dev, 0x8104, 1);
572 data1 = gspca_dev->usb_buf[0];
573 reg_r(gspca_dev, 0x8105, 1);
574 data2 = gspca_dev->usb_buf[0];
575 vendor = (data2 << 8) | data1;
576 reg_r(gspca_dev, 0x8106, 1);
577 data1 = gspca_dev->usb_buf[0];
578 reg_r(gspca_dev, 0x8107, 1);
579 data2 = gspca_dev->usb_buf[0];
580 product = (data2 << 8) | data1;
581 if (vendor != id->idVendor || product != id->idProduct) {
582 PDEBUG(D_PROBE, "Bad vendor / product from device");
583 return -EINVAL;
584 }
585 switch (product) {
586 case 0x0928:
587 case 0x0929:
588 case 0x092a:
589 case 0x092b:
590 case 0x092c:
591 case 0x092d:
592 case 0x092e:
593 case 0x092f:
594 case 0x403b:
595 sd->chip_revision = Rev012A;
596 break;
597 default:
598/* case 0x0561:
599 case 0x0815: * ?? in spca508.c
600 case 0x401a:
601 case 0x7004:
602 case 0x7e50:
603 case 0xa001:
604 case 0xcdee: */
605 sd->chip_revision = Rev072A;
606 break;
607 }
608 cam = &gspca_dev->cam;
609 cam->dev_name = (char *) id->driver_info;
610 cam->epaddr = 0x01;
611 gspca_dev->nbalt = 7 + 1; /* choose alternate 7 first */
612 cam->cam_mode = sif_mode;
613 cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
614 sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
615 sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
616 sd->autogain = sd_ctrls[SD_AUTOGAIN].qctrl.default_value;
617 return 0;
618}
619
620/* this function is called at open time */
621static int sd_open(struct gspca_dev *gspca_dev)
622{
623 struct sd *sd = (struct sd *) gspca_dev;
624
625 switch (sd->chip_revision) {
626 case Rev072A:
627 PDEBUG(D_STREAM, "Chip revision id: 072a");
628 write_vector(gspca_dev, spca561_init_data);
629 break;
630 default:
631/* case Rev012A: */
632 PDEBUG(D_STREAM, "Chip revision id: 012a");
633 init_161rev12A(gspca_dev);
634 break;
635 }
636 return 0;
637}
638
639static void setcontrast(struct gspca_dev *gspca_dev)
640{
641 struct sd *sd = (struct sd *) gspca_dev;
642 struct usb_device *dev = gspca_dev->dev;
643 __u8 lowb;
644 int expotimes;
645
646 switch (sd->chip_revision) {
647 case Rev072A:
648 lowb = sd->contrast >> 8;
649 reg_w_val(dev, lowb, 0x8651);
650 reg_w_val(dev, lowb, 0x8652);
651 reg_w_val(dev, lowb, 0x8653);
652 reg_w_val(dev, lowb, 0x8654);
653 break;
654 case Rev012A: {
655 __u8 Reg8391[] =
656 { 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00 };
657
658 /* Write camera sensor settings */
659 expotimes = (sd->contrast >> 5) & 0x07ff;
660 Reg8391[0] = expotimes & 0xff; /* exposure */
661 Reg8391[1] = 0x18 | (expotimes >> 8);
662 Reg8391[2] = sd->brightness; /* gain */
663 reg_w_buf(gspca_dev, 0x8391, Reg8391, 8);
664 reg_w_buf(gspca_dev, 0x8390, Reg8391, 8);
665 break;
666 }
667 }
668}
669
670static void sd_start(struct gspca_dev *gspca_dev)
671{
672 struct sd *sd = (struct sd *) gspca_dev;
673 struct usb_device *dev = gspca_dev->dev;
674 int Clck;
675 __u8 Reg8307[] = { 0xaa, 0x00 };
676 int mode;
677
678 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
679 switch (sd->chip_revision) {
680 case Rev072A:
681 switch (mode) {
682 default:
683/* case 0:
684 case 1: */
685 Clck = 0x25;
686 break;
687 case 2:
688 Clck = 0x22;
689 break;
690 case 3:
691 Clck = 0x21;
692 break;
693 }
694 reg_w_val(dev, 0x8500, mode); /* mode */
695 reg_w_val(dev, 0x8700, Clck); /* 0x27 clock */
696 reg_w_val(dev, 0x8112, 0x10 | 0x20);
697 break;
698 default:
699/* case Rev012A: */
700 switch (mode) {
701 case 0:
702 case 1:
703 Clck = 0x8a;
704 break;
705 case 2:
706 Clck = 0x85;
707 break;
708 default:
709 Clck = 0x83;
710 break;
711 }
712 if (mode <= 1) {
713 /* Use compression on 320x240 and above */
714 reg_w_val(dev, 0x8500, 0x10 | mode);
715 } else {
716 /* I couldn't get the compression to work below 320x240
717 * Fortunately at these resolutions the bandwidth
718 * is sufficient to push raw frames at ~20fps */
719 reg_w_val(dev, 0x8500, mode);
720 } /* -- qq@kuku.eu.org */
721 reg_w_buf(gspca_dev, 0x8307, Reg8307, 2);
722 reg_w_val(gspca_dev->dev, 0x8700, Clck);
723 /* 0x8f 0x85 0x27 clock */
724 reg_w_val(gspca_dev->dev, 0x8112, 0x1e | 0x20);
725 reg_w_val(gspca_dev->dev, 0x850b, 0x03);
726 setcontrast(gspca_dev);
727 break;
728 }
729}
730
731static void sd_stopN(struct gspca_dev *gspca_dev)
732{
733 reg_w_val(gspca_dev->dev, 0x8112, 0x20);
734}
735
736static void sd_stop0(struct gspca_dev *gspca_dev)
737{
738}
739
740/* this function is called at close time */
741static void sd_close(struct gspca_dev *gspca_dev)
742{
743 reg_w_val(gspca_dev->dev, 0x8114, 0);
744}
745
746static void setautogain(struct gspca_dev *gspca_dev)
747{
748 struct sd *sd = (struct sd *) gspca_dev;
749 int expotimes = 0;
750 int pixelclk = 0;
751 int gainG = 0;
752 __u8 R, Gr, Gb, B;
753 int y;
754 __u8 luma_mean = 110;
755 __u8 luma_delta = 20;
756 __u8 spring = 4;
757
758 switch (sd->chip_revision) {
759 case Rev072A:
760 reg_r(gspca_dev, 0x8621, 1);
761 Gr = gspca_dev->usb_buf[0];
762 reg_r(gspca_dev, 0x8622, 1);
763 R = gspca_dev->usb_buf[0];
764 reg_r(gspca_dev, 0x8623, 1);
765 B = gspca_dev->usb_buf[0];
766 reg_r(gspca_dev, 0x8624, 1);
767 Gb = gspca_dev->usb_buf[0];
768 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
769 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
770 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
771 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */
772
773 if (y < luma_mean - luma_delta ||
774 y > luma_mean + luma_delta) {
775 expotimes = i2c_read(gspca_dev, 0x09, 0x10);
776 pixelclk = 0x0800;
777 expotimes = expotimes & 0x07ff;
778 /* PDEBUG(D_PACK,
779 "Exposition Times 0x%03X Clock 0x%04X ",
780 expotimes,pixelclk); */
781 gainG = i2c_read(gspca_dev, 0x35, 0x10);
782 /* PDEBUG(D_PACK,
783 "reading Gain register %d", gainG); */
784
785 expotimes += (luma_mean - y) >> spring;
786 gainG += (luma_mean - y) / 50;
787 /* PDEBUG(D_PACK,
788 "compute expotimes %d gain %d",
789 expotimes,gainG); */
790
791 if (gainG > 0x3f)
792 gainG = 0x3f;
793 else if (gainG < 4)
794 gainG = 3;
795 i2c_write(gspca_dev, gainG, 0x35);
796
797 if (expotimes >= 0x0256)
798 expotimes = 0x0256;
799 else if (expotimes < 4)
800 expotimes = 3;
801 i2c_write(gspca_dev, expotimes | pixelclk, 0x09);
802 }
803 break;
804 case Rev012A:
805 /* sensor registers is access and memory mapped to 0x8300 */
806 /* readind all 0x83xx block the sensor */
807 /*
808 * The data from the header seem wrong where is the luma
809 * and chroma mean value
810 * at the moment set exposure in contrast set
811 */
812 break;
813 }
814}
815
816static void sd_pkt_scan(struct gspca_dev *gspca_dev,
817 struct gspca_frame *frame, /* target */
818 __u8 *data, /* isoc packet */
819 int len) /* iso packet length */
820{
821 struct sd *sd = (struct sd *) gspca_dev;
822
823 switch (data[0]) {
824 case 0: /* start of frame */
825 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
826 data, 0);
827 if (sd->ag_cnt >= 0) {
828 if (--sd->ag_cnt < 0) {
829 sd->ag_cnt = AG_CNT_START;
830 setautogain(gspca_dev);
831 }
832 }
833 data += SPCA561_OFFSET_DATA;
834 len -= SPCA561_OFFSET_DATA;
835 if (data[1] & 0x10) {
836 /* compressed bayer */
837 gspca_frame_add(gspca_dev, FIRST_PACKET,
838 frame, data, len);
839 } else {
840 /* raw bayer (with a header, which we skip) */
841 data += 20;
842 len -= 20;
843 gspca_frame_add(gspca_dev, FIRST_PACKET,
844 frame, data, len);
845 }
846 return;
847 case 0xff: /* drop */
848/* gspca_dev->last_packet_type = DISCARD_PACKET; */
849 return;
850 }
851 data++;
852 len--;
853 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
854}
855
856static void setbrightness(struct gspca_dev *gspca_dev)
857{
858 struct sd *sd = (struct sd *) gspca_dev;
859 __u8 value;
860
861 switch (sd->chip_revision) {
862 case Rev072A:
863 value = sd->brightness;
864 reg_w_val(gspca_dev->dev, value, 0x8611);
865 reg_w_val(gspca_dev->dev, value, 0x8612);
866 reg_w_val(gspca_dev->dev, value, 0x8613);
867 reg_w_val(gspca_dev->dev, value, 0x8614);
868 break;
869 default:
870/* case Rev012A: */
871 setcontrast(gspca_dev);
872 break;
873 }
874}
875
876static void getbrightness(struct gspca_dev *gspca_dev)
877{
878 struct sd *sd = (struct sd *) gspca_dev;
879 __u16 tot;
880
881 switch (sd->chip_revision) {
882 case Rev072A:
883 tot = 0;
884 reg_r(gspca_dev, 0x8611, 1);
885 tot += gspca_dev->usb_buf[0];
886 reg_r(gspca_dev, 0x8612, 1);
887 tot += gspca_dev->usb_buf[0];
888 reg_r(gspca_dev, 0x8613, 1);
889 tot += gspca_dev->usb_buf[0];
890 reg_r(gspca_dev, 0x8614, 1);
891 tot += gspca_dev->usb_buf[0];
892 sd->brightness = tot >> 2;
893 break;
894 default:
895/* case Rev012A: */
896 /* no way to read sensor settings */
897 break;
898 }
899}
900
901static void getcontrast(struct gspca_dev *gspca_dev)
902{
903 struct sd *sd = (struct sd *) gspca_dev;
904 __u16 tot;
905
906 switch (sd->chip_revision) {
907 case Rev072A:
908 tot = 0;
909 reg_r(gspca_dev, 0x8651, 1);
910 tot += gspca_dev->usb_buf[0];
911 reg_r(gspca_dev, 0x8652, 1);
912 tot += gspca_dev->usb_buf[0];
913 reg_r(gspca_dev, 0x8653, 1);
914 tot += gspca_dev->usb_buf[0];
915 reg_r(gspca_dev, 0x8654, 1);
916 tot += gspca_dev->usb_buf[0];
917 sd->contrast = tot << 6;
918 break;
919 default:
920/* case Rev012A: */
921 /* no way to read sensor settings */
922 break;
923 }
924 PDEBUG(D_CONF, "get contrast %d", sd->contrast);
925}
926
927static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
928{
929 struct sd *sd = (struct sd *) gspca_dev;
930
931 sd->brightness = val;
932 if (gspca_dev->streaming)
933 setbrightness(gspca_dev);
934 return 0;
935}
936
937static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
938{
939 struct sd *sd = (struct sd *) gspca_dev;
940
941 getbrightness(gspca_dev);
942 *val = sd->brightness;
943 return 0;
944}
945
946static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
947{
948 struct sd *sd = (struct sd *) gspca_dev;
949
950 sd->contrast = val;
951 if (gspca_dev->streaming)
952 setcontrast(gspca_dev);
953 return 0;
954}
955
956static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
957{
958 struct sd *sd = (struct sd *) gspca_dev;
959
960 getcontrast(gspca_dev);
961 *val = sd->contrast;
962 return 0;
963}
964
965static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
966{
967 struct sd *sd = (struct sd *) gspca_dev;
968
969 sd->autogain = val;
970 if (val)
971 sd->ag_cnt = AG_CNT_START;
972 else
973 sd->ag_cnt = -1;
974 return 0;
975}
976
977static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
978{
979 struct sd *sd = (struct sd *) gspca_dev;
980
981 *val = sd->autogain;
982 return 0;
983}
984
985/* sub-driver description */
986static const struct sd_desc sd_desc = {
987 .name = MODULE_NAME,
988 .ctrls = sd_ctrls,
989 .nctrls = ARRAY_SIZE(sd_ctrls),
990 .config = sd_config,
991 .open = sd_open,
992 .start = sd_start,
993 .stopN = sd_stopN,
994 .stop0 = sd_stop0,
995 .close = sd_close,
996 .pkt_scan = sd_pkt_scan,
997};
998
999/* -- module initialisation -- */
1000#define DVNM(name) .driver_info = (kernel_ulong_t) name
1001static const __devinitdata struct usb_device_id device_table[] = {
1002 {USB_DEVICE(0x041e, 0x401a), DVNM("Creative Webcam Vista (PD1100)")},
1003 {USB_DEVICE(0x041e, 0x403b), DVNM("Creative Webcam Vista (VF0010)")},
1004 {USB_DEVICE(0x0458, 0x7004), DVNM("Genius VideoCAM Express V2")},
1005 {USB_DEVICE(0x046d, 0x0928), DVNM("Logitech QC Express Etch2")},
1006 {USB_DEVICE(0x046d, 0x0929), DVNM("Labtec Webcam Elch2")},
1007 {USB_DEVICE(0x046d, 0x092a), DVNM("Logitech QC for Notebook")},
1008 {USB_DEVICE(0x046d, 0x092b), DVNM("Labtec Webcam Plus")},
1009 {USB_DEVICE(0x046d, 0x092c), DVNM("Logitech QC chat Elch2")},
1010 {USB_DEVICE(0x046d, 0x092d), DVNM("Logitech QC Elch2")},
1011 {USB_DEVICE(0x046d, 0x092e), DVNM("Logitech QC Elch2")},
1012 {USB_DEVICE(0x046d, 0x092f), DVNM("Logitech QC Elch2")},
1013 {USB_DEVICE(0x04fc, 0x0561), DVNM("Flexcam 100")},
1014 {USB_DEVICE(0x060b, 0xa001), DVNM("Maxell Compact Pc PM3")},
1015 {USB_DEVICE(0x10fd, 0x7e50), DVNM("FlyCam Usb 100")},
1016 {USB_DEVICE(0xabcd, 0xcdee), DVNM("Petcam")},
1017 {}
1018};
1019
1020MODULE_DEVICE_TABLE(usb, device_table);
1021
1022/* -- device connect -- */
1023static int sd_probe(struct usb_interface *intf,
1024 const struct usb_device_id *id)
1025{
1026 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1027 THIS_MODULE);
1028}
1029
1030static struct usb_driver sd_driver = {
1031 .name = MODULE_NAME,
1032 .id_table = device_table,
1033 .probe = sd_probe,
1034 .disconnect = gspca_disconnect,
1035};
1036
1037/* -- module insert / remove -- */
1038static int __init sd_mod_init(void)
1039{
1040 if (usb_register(&sd_driver) < 0)
1041 return -1;
1042 PDEBUG(D_PROBE, "v%s registered", version);
1043 return 0;
1044}
1045static void __exit sd_mod_exit(void)
1046{
1047 usb_deregister(&sd_driver);
1048 PDEBUG(D_PROBE, "deregistered");
1049}
1050
1051module_init(sd_mod_init);
1052module_exit(sd_mod_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-24 01:30:08 -0500