?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / media / usb / gspca / spca561.c
blobf389a8d0937d8fe90acebf2858639775e679ac1c
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
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21 #define MODULE_NAME "spca561"
22
23 #include <linux/input.h>
24 #include "gspca.h"
25
26 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
27 MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
28 MODULE_LICENSE("GPL");
29
30 #define EXPOSURE_MAX (2047 + 325)
31
32 /* specific webcam descriptor */
33 struct sd {
34 struct gspca_dev gspca_dev; /* !! must be the first item */
35
36 struct { /* hue/contrast control cluster */
37 struct v4l2_ctrl *contrast;
38 struct v4l2_ctrl *hue;
39 };
40 struct v4l2_ctrl *autogain;
41
42 #define EXPO12A_DEF 3
43 __u8 expo12a; /* expo/gain? for rev 12a */
44
45 __u8 chip_revision;
46 #define Rev012A 0
47 #define Rev072A 1
48
49 signed char ag_cnt;
50 #define AG_CNT_START 13
51 };
52
53 static const struct v4l2_pix_format sif_012a_mode[] = {
54 {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
55 .bytesperline = 160,
56 .sizeimage = 160 * 120,
57 .colorspace = V4L2_COLORSPACE_SRGB,
58 .priv = 3},
59 {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
60 .bytesperline = 176,
61 .sizeimage = 176 * 144,
62 .colorspace = V4L2_COLORSPACE_SRGB,
63 .priv = 2},
64 {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
65 .bytesperline = 320,
66 .sizeimage = 320 * 240 * 4 / 8,
67 .colorspace = V4L2_COLORSPACE_SRGB,
68 .priv = 1},
69 {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
70 .bytesperline = 352,
71 .sizeimage = 352 * 288 * 4 / 8,
72 .colorspace = V4L2_COLORSPACE_SRGB,
73 .priv = 0},
74 };
75
76 static const struct v4l2_pix_format sif_072a_mode[] = {
77 {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
78 .bytesperline = 160,
79 .sizeimage = 160 * 120,
80 .colorspace = V4L2_COLORSPACE_SRGB,
81 .priv = 3},
82 {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
83 .bytesperline = 176,
84 .sizeimage = 176 * 144,
85 .colorspace = V4L2_COLORSPACE_SRGB,
86 .priv = 2},
87 {320, 240, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
88 .bytesperline = 320,
89 .sizeimage = 320 * 240,
90 .colorspace = V4L2_COLORSPACE_SRGB,
91 .priv = 1},
92 {352, 288, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
93 .bytesperline = 352,
94 .sizeimage = 352 * 288,
95 .colorspace = V4L2_COLORSPACE_SRGB,
96 .priv = 0},
97 };
98
99 /*
100 * Initialization data
101 * I'm not very sure how to split initialization from open data
102 * chunks. For now, we'll consider everything as initialization
103 */
104 /* Frame packet header offsets for the spca561 */
105 #define SPCA561_OFFSET_SNAP 1
106 #define SPCA561_OFFSET_TYPE 2
107 #define SPCA561_OFFSET_COMPRESS 3
108 #define SPCA561_OFFSET_FRAMSEQ 4
109 #define SPCA561_OFFSET_GPIO 5
110 #define SPCA561_OFFSET_USBBUFF 6
111 #define SPCA561_OFFSET_WIN2GRAVE 7
112 #define SPCA561_OFFSET_WIN2RAVE 8
113 #define SPCA561_OFFSET_WIN2BAVE 9
114 #define SPCA561_OFFSET_WIN2GBAVE 10
115 #define SPCA561_OFFSET_WIN1GRAVE 11
116 #define SPCA561_OFFSET_WIN1RAVE 12
117 #define SPCA561_OFFSET_WIN1BAVE 13
118 #define SPCA561_OFFSET_WIN1GBAVE 14
119 #define SPCA561_OFFSET_FREQ 15
120 #define SPCA561_OFFSET_VSYNC 16
121 #define SPCA561_INDEX_I2C_BASE 0x8800
122 #define SPCA561_SNAPBIT 0x20
123 #define SPCA561_SNAPCTRL 0x40
124
125 static const u16 rev72a_reset[][2] = {
126 {0x0000, 0x8114}, /* Software GPIO output data */
127 {0x0001, 0x8114}, /* Software GPIO output data */
128 {0x0000, 0x8112}, /* Some kind of reset */
129 {}
130 };
131 static const __u16 rev72a_init_data1[][2] = {
132 {0x0003, 0x8701}, /* PCLK clock delay adjustment */
133 {0x0001, 0x8703}, /* HSYNC from cmos inverted */
134 {0x0011, 0x8118}, /* Enable and conf sensor */
135 {0x0001, 0x8118}, /* Conf sensor */
136 {0x0092, 0x8804}, /* I know nothing about these */
137 {0x0010, 0x8802}, /* 0x88xx registers, so I won't */
138 {}
139 };
140 static const u16 rev72a_init_sensor1[][2] = {
141 {0x0001, 0x000d},
142 {0x0002, 0x0018},
143 {0x0004, 0x0165},
144 {0x0005, 0x0021},
145 {0x0007, 0x00aa},
146 {0x0020, 0x1504},
147 {0x0039, 0x0002},
148 {0x0035, 0x0010},
149 {0x0009, 0x1049},
150 {0x0028, 0x000b},
151 {0x003b, 0x000f},
152 {0x003c, 0x0000},
153 {}
154 };
155 static const __u16 rev72a_init_data2[][2] = {
156 {0x0018, 0x8601}, /* Pixel/line selection for color separation */
157 {0x0000, 0x8602}, /* Optical black level for user setting */
158 {0x0060, 0x8604}, /* Optical black horizontal offset */
159 {0x0002, 0x8605}, /* Optical black vertical offset */
160 {0x0000, 0x8603}, /* Non-automatic optical black level */
161 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */
162 {0x0000, 0x865f}, /* Vertical valid pixels window (x2) */
163 {0x00b0, 0x865d}, /* Horizontal valid pixels window (x2) */
164 {0x0090, 0x865e}, /* Vertical valid lines window (x2) */
165 {0x00e0, 0x8406}, /* Memory buffer threshold */
166 {0x0000, 0x8660}, /* Compensation memory stuff */
167 {0x0002, 0x8201}, /* Output address for r/w serial EEPROM */
168 {0x0008, 0x8200}, /* Clear valid bit for serial EEPROM */
169 {0x0001, 0x8200}, /* OprMode to be executed by hardware */
170 /* from ms-win */
171 {0x0000, 0x8611}, /* R offset for white balance */
172 {0x00fd, 0x8612}, /* Gr offset for white balance */
173 {0x0003, 0x8613}, /* B offset for white balance */
174 {0x0000, 0x8614}, /* Gb offset for white balance */
175 /* from ms-win */
176 {0x0035, 0x8651}, /* R gain for white balance */
177 {0x0040, 0x8652}, /* Gr gain for white balance */
178 {0x005f, 0x8653}, /* B gain for white balance */
179 {0x0040, 0x8654}, /* Gb gain for white balance */
180 {0x0002, 0x8502}, /* Maximum average bit rate stuff */
181 {0x0011, 0x8802},
182
183 {0x0087, 0x8700}, /* Set master clock (96Mhz????) */
184 {0x0081, 0x8702}, /* Master clock output enable */
185
186 {0x0000, 0x8500}, /* Set image type (352x288 no compression) */
187 /* Originally was 0x0010 (352x288 compression) */
188
189 {0x0002, 0x865b}, /* Horizontal offset for valid pixels */
190 {0x0003, 0x865c}, /* Vertical offset for valid lines */
191 {}
192 };
193 static const u16 rev72a_init_sensor2[][2] = {
194 {0x0003, 0x0121},
195 {0x0004, 0x0165},
196 {0x0005, 0x002f}, /* blanking control column */
197 {0x0006, 0x0000}, /* blanking mode row*/
198 {0x000a, 0x0002},
199 {0x0009, 0x1061}, /* setexposure times && pixel clock
200 * 0001 0 | 000 0110 0001 */
201 {0x0035, 0x0014},
202 {}
203 };
204
205 /******************** QC Express etch2 stuff ********************/
206 static const __u16 Pb100_1map8300[][2] = {
207 /* reg, value */
208 {0x8320, 0x3304},
209
210 {0x8303, 0x0125}, /* image area */
211 {0x8304, 0x0169},
212 {0x8328, 0x000b},
213 {0x833c, 0x0001}, /*fixme: win:07*/
214
215 {0x832f, 0x1904}, /*fixme: was 0419*/
216 {0x8307, 0x00aa},
217 {0x8301, 0x0003},
218 {0x8302, 0x000e},
219 {}
220 };
221 static const __u16 Pb100_2map8300[][2] = {
222 /* reg, value */
223 {0x8339, 0x0000},
224 {0x8307, 0x00aa},
225 {}
226 };
227
228 static const __u16 spca561_161rev12A_data1[][2] = {
229 {0x29, 0x8118}, /* Control register (various enable bits) */
230 {0x08, 0x8114}, /* GPIO: Led off */
231 {0x0e, 0x8112}, /* 0x0e stream off 0x3e stream on */
232 {0x00, 0x8102}, /* white balance - new */
233 {0x92, 0x8804},
234 {0x04, 0x8802}, /* windows uses 08 */
235 {}
236 };
237 static const __u16 spca561_161rev12A_data2[][2] = {
238 {0x21, 0x8118},
239 {0x10, 0x8500},
240 {0x07, 0x8601},
241 {0x07, 0x8602},
242 {0x04, 0x8501},
243
244 {0x07, 0x8201}, /* windows uses 02 */
245 {0x08, 0x8200},
246 {0x01, 0x8200},
247
248 {0x90, 0x8604},
249 {0x00, 0x8605},
250 {0xb0, 0x8603},
251
252 /* sensor gains */
253 {0x07, 0x8601}, /* white balance - new */
254 {0x07, 0x8602}, /* white balance - new */
255 {0x00, 0x8610}, /* *red */
256 {0x00, 0x8611}, /* 3f *green */
257 {0x00, 0x8612}, /* green *blue */
258 {0x00, 0x8613}, /* blue *green */
259 {0x43, 0x8614}, /* green *red - white balance - was 0x35 */
260 {0x40, 0x8615}, /* 40 *green - white balance - was 0x35 */
261 {0x71, 0x8616}, /* 7a *blue - white balance - was 0x35 */
262 {0x40, 0x8617}, /* 40 *green - white balance - was 0x35 */
263
264 {0x0c, 0x8620}, /* 0c */
265 {0xc8, 0x8631}, /* c8 */
266 {0xc8, 0x8634}, /* c8 */
267 {0x23, 0x8635}, /* 23 */
268 {0x1f, 0x8636}, /* 1f */
269 {0xdd, 0x8637}, /* dd */
270 {0xe1, 0x8638}, /* e1 */
271 {0x1d, 0x8639}, /* 1d */
272 {0x21, 0x863a}, /* 21 */
273 {0xe3, 0x863b}, /* e3 */
274 {0xdf, 0x863c}, /* df */
275 {0xf0, 0x8505},
276 {0x32, 0x850a},
277 /* {0x99, 0x8700}, * - white balance - new (removed) */
278 /* HDG we used to do this in stop0, making the init state and the state
279 after a start / stop different, so do this here instead. */
280 {0x29, 0x8118},
281 {}
282 };
283
284 static void reg_w_val(struct gspca_dev *gspca_dev, __u16 index, __u8 value)
285 {
286 int ret;
287 struct usb_device *dev = gspca_dev->dev;
288
289 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
290 0, /* request */
291 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
292 value, index, NULL, 0, 500);
293 gspca_dbg(gspca_dev, D_USBO, "reg write: 0x%02x:0x%02x\n",
294 index, value);
295 if (ret < 0)
296 pr_err("reg write: error %d\n", ret);
297 }
298
299 static void write_vector(struct gspca_dev *gspca_dev,
300 const __u16 data[][2])
301 {
302 int i;
303
304 i = 0;
305 while (data[i][1] != 0) {
306 reg_w_val(gspca_dev, data[i][1], data[i][0]);
307 i++;
308 }
309 }
310
311 /* read 'len' bytes to gspca_dev->usb_buf */
312 static void reg_r(struct gspca_dev *gspca_dev,
313 __u16 index, __u16 length)
314 {
315 usb_control_msg(gspca_dev->dev,
316 usb_rcvctrlpipe(gspca_dev->dev, 0),
317 0, /* request */
318 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
319 0, /* value */
320 index, gspca_dev->usb_buf, length, 500);
321 }
322
323 /* write 'len' bytes from gspca_dev->usb_buf */
324 static void reg_w_buf(struct gspca_dev *gspca_dev,
325 __u16 index, __u16 len)
326 {
327 usb_control_msg(gspca_dev->dev,
328 usb_sndctrlpipe(gspca_dev->dev, 0),
329 0, /* request */
330 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
331 0, /* value */
332 index, gspca_dev->usb_buf, len, 500);
333 }
334
335 static void i2c_write(struct gspca_dev *gspca_dev, __u16 value, __u16 reg)
336 {
337 int retry = 60;
338
339 reg_w_val(gspca_dev, 0x8801, reg);
340 reg_w_val(gspca_dev, 0x8805, value);
341 reg_w_val(gspca_dev, 0x8800, value >> 8);
342 do {
343 reg_r(gspca_dev, 0x8803, 1);
344 if (!gspca_dev->usb_buf[0])
345 return;
346 msleep(10);
347 } while (--retry);
348 }
349
350 static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
351 {
352 int retry = 60;
353 __u8 value;
354
355 reg_w_val(gspca_dev, 0x8804, 0x92);
356 reg_w_val(gspca_dev, 0x8801, reg);
357 reg_w_val(gspca_dev, 0x8802, mode | 0x01);
358 do {
359 reg_r(gspca_dev, 0x8803, 1);
360 if (!gspca_dev->usb_buf[0]) {
361 reg_r(gspca_dev, 0x8800, 1);
362 value = gspca_dev->usb_buf[0];
363 reg_r(gspca_dev, 0x8805, 1);
364 return ((int) value << 8) | gspca_dev->usb_buf[0];
365 }
366 msleep(10);
367 } while (--retry);
368 return -1;
369 }
370
371 static void sensor_mapwrite(struct gspca_dev *gspca_dev,
372 const __u16 (*sensormap)[2])
373 {
374 while ((*sensormap)[0]) {
375 gspca_dev->usb_buf[0] = (*sensormap)[1];
376 gspca_dev->usb_buf[1] = (*sensormap)[1] >> 8;
377 reg_w_buf(gspca_dev, (*sensormap)[0], 2);
378 sensormap++;
379 }
380 }
381
382 static void write_sensor_72a(struct gspca_dev *gspca_dev,
383 const __u16 (*sensor)[2])
384 {
385 while ((*sensor)[0]) {
386 i2c_write(gspca_dev, (*sensor)[1], (*sensor)[0]);
387 sensor++;
388 }
389 }
390
391 static void init_161rev12A(struct gspca_dev *gspca_dev)
392 {
393 write_vector(gspca_dev, spca561_161rev12A_data1);
394 sensor_mapwrite(gspca_dev, Pb100_1map8300);
395 /*fixme: should be in sd_start*/
396 write_vector(gspca_dev, spca561_161rev12A_data2);
397 sensor_mapwrite(gspca_dev, Pb100_2map8300);
398 }
399
400 /* this function is called at probe time */
401 static int sd_config(struct gspca_dev *gspca_dev,
402 const struct usb_device_id *id)
403 {
404 struct sd *sd = (struct sd *) gspca_dev;
405 struct cam *cam;
406 __u16 vendor, product;
407 __u8 data1, data2;
408
409 /* Read frm global register the USB product and vendor IDs, just to
410 * prove that we can communicate with the device. This works, which
411 * confirms at we are communicating properly and that the device
412 * is a 561. */
413 reg_r(gspca_dev, 0x8104, 1);
414 data1 = gspca_dev->usb_buf[0];
415 reg_r(gspca_dev, 0x8105, 1);
416 data2 = gspca_dev->usb_buf[0];
417 vendor = (data2 << 8) | data1;
418 reg_r(gspca_dev, 0x8106, 1);
419 data1 = gspca_dev->usb_buf[0];
420 reg_r(gspca_dev, 0x8107, 1);
421 data2 = gspca_dev->usb_buf[0];
422 product = (data2 << 8) | data1;
423 if (vendor != id->idVendor || product != id->idProduct) {
424 gspca_dbg(gspca_dev, D_PROBE, "Bad vendor / product from device\n");
425 return -EINVAL;
426 }
427
428 cam = &gspca_dev->cam;
429 cam->needs_full_bandwidth = 1;
430
431 sd->chip_revision = id->driver_info;
432 if (sd->chip_revision == Rev012A) {
433 cam->cam_mode = sif_012a_mode;
434 cam->nmodes = ARRAY_SIZE(sif_012a_mode);
435 } else {
436 cam->cam_mode = sif_072a_mode;
437 cam->nmodes = ARRAY_SIZE(sif_072a_mode);
438 }
439 sd->expo12a = EXPO12A_DEF;
440 return 0;
441 }
442
443 /* this function is called at probe and resume time */
444 static int sd_init_12a(struct gspca_dev *gspca_dev)
445 {
446 gspca_dbg(gspca_dev, D_STREAM, "Chip revision: 012a\n");
447 init_161rev12A(gspca_dev);
448 return 0;
449 }
450 static int sd_init_72a(struct gspca_dev *gspca_dev)
451 {
452 gspca_dbg(gspca_dev, D_STREAM, "Chip revision: 072a\n");
453 write_vector(gspca_dev, rev72a_reset);
454 msleep(200);
455 write_vector(gspca_dev, rev72a_init_data1);
456 write_sensor_72a(gspca_dev, rev72a_init_sensor1);
457 write_vector(gspca_dev, rev72a_init_data2);
458 write_sensor_72a(gspca_dev, rev72a_init_sensor2);
459 reg_w_val(gspca_dev, 0x8112, 0x30);
460 return 0;
461 }
462
463 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
464 {
465 struct sd *sd = (struct sd *) gspca_dev;
466 __u16 reg;
467
468 if (sd->chip_revision == Rev012A)
469 reg = 0x8610;
470 else
471 reg = 0x8611;
472
473 reg_w_val(gspca_dev, reg + 0, val); /* R */
474 reg_w_val(gspca_dev, reg + 1, val); /* Gr */
475 reg_w_val(gspca_dev, reg + 2, val); /* B */
476 reg_w_val(gspca_dev, reg + 3, val); /* Gb */
477 }
478
479 static void setwhite(struct gspca_dev *gspca_dev, s32 white, s32 contrast)
480 {
481 struct sd *sd = (struct sd *) gspca_dev;
482 __u8 blue, red;
483 __u16 reg;
484
485 /* try to emulate MS-win as possible */
486 red = 0x20 + white * 3 / 8;
487 blue = 0x90 - white * 5 / 8;
488 if (sd->chip_revision == Rev012A) {
489 reg = 0x8614;
490 } else {
491 reg = 0x8651;
492 red += contrast - 0x20;
493 blue += contrast - 0x20;
494 reg_w_val(gspca_dev, 0x8652, contrast + 0x20); /* Gr */
495 reg_w_val(gspca_dev, 0x8654, contrast + 0x20); /* Gb */
496 }
497 reg_w_val(gspca_dev, reg, red);
498 reg_w_val(gspca_dev, reg + 2, blue);
499 }
500
501 /* rev 12a only */
502 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
503 {
504 int i, expo = 0;
505
506 /* Register 0x8309 controls exposure for the spca561,
507 the basic exposure setting goes from 1-2047, where 1 is completely
508 dark and 2047 is very bright. It not only influences exposure but
509 also the framerate (to allow for longer exposure) from 1 - 300 it
510 only raises the exposure time then from 300 - 600 it halves the
511 framerate to be able to further raise the exposure time and for every
512 300 more it halves the framerate again. This allows for a maximum
513 exposure time of circa 0.2 - 0.25 seconds (30 / (2000/3000) fps).
514 Sometimes this is not enough, the 1-2047 uses bits 0-10, bits 11-12
515 configure a divider for the base framerate which us used at the
516 exposure setting of 1-300. These bits configure the base framerate
517 according to the following formula: fps = 60 / (value + 2) */
518
519 /* We choose to use the high bits setting the fixed framerate divisor
520 asap, as setting high basic exposure setting without the fixed
521 divider in combination with high gains makes the cam stop */
522 int table[] = { 0, 450, 550, 625, EXPOSURE_MAX };
523
524 for (i = 0; i < ARRAY_SIZE(table) - 1; i++) {
525 if (val <= table[i + 1]) {
526 expo = val - table[i];
527 if (i)
528 expo += 300;
529 expo |= i << 11;
530 break;
531 }
532 }
533
534 gspca_dev->usb_buf[0] = expo;
535 gspca_dev->usb_buf[1] = expo >> 8;
536 reg_w_buf(gspca_dev, 0x8309, 2);
537 }
538
539 /* rev 12a only */
540 static void setgain(struct gspca_dev *gspca_dev, s32 val)
541 {
542 /* gain reg low 6 bits 0-63 gain, bit 6 and 7, both double the
543 sensitivity when set, so 31 + one of them set == 63, and 15
544 with both of them set == 63 */
545 if (val < 64)
546 gspca_dev->usb_buf[0] = val;
547 else if (val < 128)
548 gspca_dev->usb_buf[0] = (val / 2) | 0x40;
549 else
550 gspca_dev->usb_buf[0] = (val / 4) | 0xc0;
551
552 gspca_dev->usb_buf[1] = 0;
553 reg_w_buf(gspca_dev, 0x8335, 2);
554 }
555
556 static void setautogain(struct gspca_dev *gspca_dev, s32 val)
557 {
558 struct sd *sd = (struct sd *) gspca_dev;
559
560 if (val)
561 sd->ag_cnt = AG_CNT_START;
562 else
563 sd->ag_cnt = -1;
564 }
565
566 static int sd_start_12a(struct gspca_dev *gspca_dev)
567 {
568 int mode;
569 static const __u8 Reg8391[8] =
570 {0x92, 0x30, 0x20, 0x00, 0x0c, 0x00, 0x00, 0x00};
571
572 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
573 if (mode <= 1) {
574 /* Use compression on 320x240 and above */
575 reg_w_val(gspca_dev, 0x8500, 0x10 | mode);
576 } else {
577 /* I couldn't get the compression to work below 320x240
578 * Fortunately at these resolutions the bandwidth
579 * is sufficient to push raw frames at ~20fps */
580 reg_w_val(gspca_dev, 0x8500, mode);
581 } /* -- qq@kuku.eu.org */
582
583 gspca_dev->usb_buf[0] = 0xaa;
584 gspca_dev->usb_buf[1] = 0x00;
585 reg_w_buf(gspca_dev, 0x8307, 2);
586 /* clock - lower 0x8X values lead to fps > 30 */
587 reg_w_val(gspca_dev, 0x8700, 0x8a);
588 /* 0x8f 0x85 0x27 clock */
589 reg_w_val(gspca_dev, 0x8112, 0x1e | 0x20);
590 reg_w_val(gspca_dev, 0x850b, 0x03);
591 memcpy(gspca_dev->usb_buf, Reg8391, 8);
592 reg_w_buf(gspca_dev, 0x8391, 8);
593 reg_w_buf(gspca_dev, 0x8390, 8);
594
595 /* Led ON (bit 3 -> 0 */
596 reg_w_val(gspca_dev, 0x8114, 0x00);
597 return 0;
598 }
599 static int sd_start_72a(struct gspca_dev *gspca_dev)
600 {
601 struct sd *sd = (struct sd *) gspca_dev;
602 int Clck;
603 int mode;
604
605 write_vector(gspca_dev, rev72a_reset);
606 msleep(200);
607 write_vector(gspca_dev, rev72a_init_data1);
608 write_sensor_72a(gspca_dev, rev72a_init_sensor1);
609
610 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
611 switch (mode) {
612 default:
613 case 0:
614 Clck = 0x27; /* ms-win 0x87 */
615 break;
616 case 1:
617 Clck = 0x25;
618 break;
619 case 2:
620 Clck = 0x22;
621 break;
622 case 3:
623 Clck = 0x21;
624 break;
625 }
626 reg_w_val(gspca_dev, 0x8700, Clck); /* 0x27 clock */
627 reg_w_val(gspca_dev, 0x8702, 0x81);
628 reg_w_val(gspca_dev, 0x8500, mode); /* mode */
629 write_sensor_72a(gspca_dev, rev72a_init_sensor2);
630 setwhite(gspca_dev, v4l2_ctrl_g_ctrl(sd->hue),
631 v4l2_ctrl_g_ctrl(sd->contrast));
632 /* setbrightness(gspca_dev); * fixme: bad values */
633 setautogain(gspca_dev, v4l2_ctrl_g_ctrl(sd->autogain));
634 reg_w_val(gspca_dev, 0x8112, 0x10 | 0x20);
635 return 0;
636 }
637
638 static void sd_stopN(struct gspca_dev *gspca_dev)
639 {
640 struct sd *sd = (struct sd *) gspca_dev;
641
642 if (sd->chip_revision == Rev012A) {
643 reg_w_val(gspca_dev, 0x8112, 0x0e);
644 /* Led Off (bit 3 -> 1 */
645 reg_w_val(gspca_dev, 0x8114, 0x08);
646 } else {
647 reg_w_val(gspca_dev, 0x8112, 0x20);
648 /* reg_w_val(gspca_dev, 0x8102, 0x00); ?? */
649 }
650 }
651
652 static void do_autogain(struct gspca_dev *gspca_dev)
653 {
654 struct sd *sd = (struct sd *) gspca_dev;
655 int expotimes;
656 int pixelclk;
657 int gainG;
658 __u8 R, Gr, Gb, B;
659 int y;
660 __u8 luma_mean = 110;
661 __u8 luma_delta = 20;
662 __u8 spring = 4;
663
664 if (sd->ag_cnt < 0)
665 return;
666 if (--sd->ag_cnt >= 0)
667 return;
668 sd->ag_cnt = AG_CNT_START;
669
670 switch (sd->chip_revision) {
671 case Rev072A:
672 reg_r(gspca_dev, 0x8621, 1);
673 Gr = gspca_dev->usb_buf[0];
674 reg_r(gspca_dev, 0x8622, 1);
675 R = gspca_dev->usb_buf[0];
676 reg_r(gspca_dev, 0x8623, 1);
677 B = gspca_dev->usb_buf[0];
678 reg_r(gspca_dev, 0x8624, 1);
679 Gb = gspca_dev->usb_buf[0];
680 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
681 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
682 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
683
684 if (y < luma_mean - luma_delta ||
685 y > luma_mean + luma_delta) {
686 expotimes = i2c_read(gspca_dev, 0x09, 0x10);
687 pixelclk = 0x0800;
688 expotimes = expotimes & 0x07ff;
689 gainG = i2c_read(gspca_dev, 0x35, 0x10);
690
691 expotimes += (luma_mean - y) >> spring;
692 gainG += (luma_mean - y) / 50;
693
694 if (gainG > 0x3f)
695 gainG = 0x3f;
696 else if (gainG < 3)
697 gainG = 3;
698 i2c_write(gspca_dev, gainG, 0x35);
699
700 if (expotimes > 0x0256)
701 expotimes = 0x0256;
702 else if (expotimes < 3)
703 expotimes = 3;
704 i2c_write(gspca_dev, expotimes | pixelclk, 0x09);
705 }
706 break;
707 }
708 }
709
710 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
711 u8 *data, /* isoc packet */
712 int len) /* iso packet length */
713 {
714 struct sd *sd = (struct sd *) gspca_dev;
715
716 len--;
717 switch (*data++) { /* sequence number */
718 case 0: /* start of frame */
719 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
720
721 /* This should never happen */
722 if (len < 2) {
723 gspca_err(gspca_dev, "Short SOF packet, ignoring\n\n\n\n\n");
724 gspca_dev->last_packet_type = DISCARD_PACKET;
725 return;
726 }
727
728 #if IS_ENABLED(CONFIG_INPUT)
729 if (data[0] & 0x20) {
730 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
731 input_sync(gspca_dev->input_dev);
732 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
733 input_sync(gspca_dev->input_dev);
734 }
735 #endif
736
737 if (data[1] & 0x10) {
738 /* compressed bayer */
739 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
740 } else {
741 /* raw bayer (with a header, which we skip) */
742 if (sd->chip_revision == Rev012A) {
743 data += 20;
744 len -= 20;
745 } else {
746 data += 16;
747 len -= 16;
748 }
749 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
750 }
751 return;
752 case 0xff: /* drop (empty mpackets) */
753 return;
754 }
755 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
756 }
757
758 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
759 {
760 struct gspca_dev *gspca_dev =
761 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
762 struct sd *sd = (struct sd *)gspca_dev;
763
764 gspca_dev->usb_err = 0;
765
766 if (!gspca_dev->streaming)
767 return 0;
768
769 switch (ctrl->id) {
770 case V4L2_CID_BRIGHTNESS:
771 setbrightness(gspca_dev, ctrl->val);
772 break;
773 case V4L2_CID_CONTRAST:
774 /* hue/contrast control cluster for 72a */
775 setwhite(gspca_dev, sd->hue->val, ctrl->val);
776 break;
777 case V4L2_CID_HUE:
778 /* just plain hue control for 12a */
779 setwhite(gspca_dev, ctrl->val, 0);
780 break;
781 case V4L2_CID_EXPOSURE:
782 setexposure(gspca_dev, ctrl->val);
783 break;
784 case V4L2_CID_GAIN:
785 setgain(gspca_dev, ctrl->val);
786 break;
787 case V4L2_CID_AUTOGAIN:
788 setautogain(gspca_dev, ctrl->val);
789 break;
790 }
791 return gspca_dev->usb_err;
792 }
793
794 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
795 .s_ctrl = sd_s_ctrl,
796 };
797
798 static int sd_init_controls_12a(struct gspca_dev *gspca_dev)
799 {
800 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
801
802 gspca_dev->vdev.ctrl_handler = hdl;
803 v4l2_ctrl_handler_init(hdl, 3);
804 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
805 V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
806 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
807 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
808 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
809 V4L2_CID_EXPOSURE, 1, EXPOSURE_MAX, 1, 700);
810 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
811 V4L2_CID_GAIN, 0, 255, 1, 63);
812
813 if (hdl->error) {
814 pr_err("Could not initialize controls\n");
815 return hdl->error;
816 }
817 return 0;
818 }
819
820 static int sd_init_controls_72a(struct gspca_dev *gspca_dev)
821 {
822 struct sd *sd = (struct sd *)gspca_dev;
823 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
824
825 gspca_dev->vdev.ctrl_handler = hdl;
826 v4l2_ctrl_handler_init(hdl, 4);
827 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
828 V4L2_CID_CONTRAST, 0, 0x3f, 1, 0x20);
829 sd->hue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
830 V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
831 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
832 V4L2_CID_BRIGHTNESS, 0, 0x3f, 1, 0x20);
833 sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
834 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
835
836 if (hdl->error) {
837 pr_err("Could not initialize controls\n");
838 return hdl->error;
839 }
840 v4l2_ctrl_cluster(2, &sd->contrast);
841 return 0;
842 }
843
844 /* sub-driver description */
845 static const struct sd_desc sd_desc_12a = {
846 .name = MODULE_NAME,
847 .init_controls = sd_init_controls_12a,
848 .config = sd_config,
849 .init = sd_init_12a,
850 .start = sd_start_12a,
851 .stopN = sd_stopN,
852 .pkt_scan = sd_pkt_scan,
853 #if IS_ENABLED(CONFIG_INPUT)
854 .other_input = 1,
855 #endif
856 };
857 static const struct sd_desc sd_desc_72a = {
858 .name = MODULE_NAME,
859 .init_controls = sd_init_controls_72a,
860 .config = sd_config,
861 .init = sd_init_72a,
862 .start = sd_start_72a,
863 .stopN = sd_stopN,
864 .pkt_scan = sd_pkt_scan,
865 .dq_callback = do_autogain,
866 #if IS_ENABLED(CONFIG_INPUT)
867 .other_input = 1,
868 #endif
869 };
870 static const struct sd_desc *sd_desc[2] = {
871 &sd_desc_12a,
872 &sd_desc_72a
873 };
874
875 /* -- module initialisation -- */
876 static const struct usb_device_id device_table[] = {
877 {USB_DEVICE(0x041e, 0x401a), .driver_info = Rev072A},
878 {USB_DEVICE(0x041e, 0x403b), .driver_info = Rev012A},
879 {USB_DEVICE(0x0458, 0x7004), .driver_info = Rev072A},
880 {USB_DEVICE(0x0461, 0x0815), .driver_info = Rev072A},
881 {USB_DEVICE(0x046d, 0x0928), .driver_info = Rev012A},
882 {USB_DEVICE(0x046d, 0x0929), .driver_info = Rev012A},
883 {USB_DEVICE(0x046d, 0x092a), .driver_info = Rev012A},
884 {USB_DEVICE(0x046d, 0x092b), .driver_info = Rev012A},
885 {USB_DEVICE(0x046d, 0x092c), .driver_info = Rev012A},
886 {USB_DEVICE(0x046d, 0x092d), .driver_info = Rev012A},
887 {USB_DEVICE(0x046d, 0x092e), .driver_info = Rev012A},
888 {USB_DEVICE(0x046d, 0x092f), .driver_info = Rev012A},
889 {USB_DEVICE(0x04fc, 0x0561), .driver_info = Rev072A},
890 {USB_DEVICE(0x060b, 0xa001), .driver_info = Rev072A},
891 {USB_DEVICE(0x10fd, 0x7e50), .driver_info = Rev072A},
892 {USB_DEVICE(0xabcd, 0xcdee), .driver_info = Rev072A},
893 {}
894 };
895
896 MODULE_DEVICE_TABLE(usb, device_table);
897
898 /* -- device connect -- */
899 static int sd_probe(struct usb_interface *intf,
900 const struct usb_device_id *id)
901 {
902 return gspca_dev_probe(intf, id,
903 sd_desc[id->driver_info],
904 sizeof(struct sd),
905 THIS_MODULE);
906 }
907
908 static struct usb_driver sd_driver = {
909 .name = MODULE_NAME,
910 .id_table = device_table,
911 .probe = sd_probe,
912 .disconnect = gspca_disconnect,
913 #ifdef CONFIG_PM
914 .suspend = gspca_suspend,
915 .resume = gspca_resume,
916 .reset_resume = gspca_resume,
917 #endif
918 };
919
920 module_usb_driver(sd_driver);
Linux with added FPC-III support