]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/media/usb/gspca/spca561.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'media/v4.11-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[mirror_ubuntu-hirsute-kernel.git] / drivers / media / usb / gspca / spca561.c
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 PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value);
294 if (ret < 0)
295 pr_err("reg write: error %d\n", ret);
296 }
297
298 static void write_vector(struct gspca_dev *gspca_dev,
299 const __u16 data[][2])
300 {
301 int i;
302
303 i = 0;
304 while (data[i][1] != 0) {
305 reg_w_val(gspca_dev, data[i][1], data[i][0]);
306 i++;
307 }
308 }
309
310 /* read 'len' bytes to gspca_dev->usb_buf */
311 static void reg_r(struct gspca_dev *gspca_dev,
312 __u16 index, __u16 length)
313 {
314 usb_control_msg(gspca_dev->dev,
315 usb_rcvctrlpipe(gspca_dev->dev, 0),
316 0, /* request */
317 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
318 0, /* value */
319 index, gspca_dev->usb_buf, length, 500);
320 }
321
322 /* write 'len' bytes from gspca_dev->usb_buf */
323 static void reg_w_buf(struct gspca_dev *gspca_dev,
324 __u16 index, __u16 len)
325 {
326 usb_control_msg(gspca_dev->dev,
327 usb_sndctrlpipe(gspca_dev->dev, 0),
328 0, /* request */
329 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
330 0, /* value */
331 index, gspca_dev->usb_buf, len, 500);
332 }
333
334 static void i2c_write(struct gspca_dev *gspca_dev, __u16 value, __u16 reg)
335 {
336 int retry = 60;
337
338 reg_w_val(gspca_dev, 0x8801, reg);
339 reg_w_val(gspca_dev, 0x8805, value);
340 reg_w_val(gspca_dev, 0x8800, value >> 8);
341 do {
342 reg_r(gspca_dev, 0x8803, 1);
343 if (!gspca_dev->usb_buf[0])
344 return;
345 msleep(10);
346 } while (--retry);
347 }
348
349 static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
350 {
351 int retry = 60;
352 __u8 value;
353
354 reg_w_val(gspca_dev, 0x8804, 0x92);
355 reg_w_val(gspca_dev, 0x8801, reg);
356 reg_w_val(gspca_dev, 0x8802, mode | 0x01);
357 do {
358 reg_r(gspca_dev, 0x8803, 1);
359 if (!gspca_dev->usb_buf[0]) {
360 reg_r(gspca_dev, 0x8800, 1);
361 value = gspca_dev->usb_buf[0];
362 reg_r(gspca_dev, 0x8805, 1);
363 return ((int) value << 8) | gspca_dev->usb_buf[0];
364 }
365 msleep(10);
366 } while (--retry);
367 return -1;
368 }
369
370 static void sensor_mapwrite(struct gspca_dev *gspca_dev,
371 const __u16 (*sensormap)[2])
372 {
373 while ((*sensormap)[0]) {
374 gspca_dev->usb_buf[0] = (*sensormap)[1];
375 gspca_dev->usb_buf[1] = (*sensormap)[1] >> 8;
376 reg_w_buf(gspca_dev, (*sensormap)[0], 2);
377 sensormap++;
378 }
379 }
380
381 static void write_sensor_72a(struct gspca_dev *gspca_dev,
382 const __u16 (*sensor)[2])
383 {
384 while ((*sensor)[0]) {
385 i2c_write(gspca_dev, (*sensor)[1], (*sensor)[0]);
386 sensor++;
387 }
388 }
389
390 static void init_161rev12A(struct gspca_dev *gspca_dev)
391 {
392 write_vector(gspca_dev, spca561_161rev12A_data1);
393 sensor_mapwrite(gspca_dev, Pb100_1map8300);
394 /*fixme: should be in sd_start*/
395 write_vector(gspca_dev, spca561_161rev12A_data2);
396 sensor_mapwrite(gspca_dev, Pb100_2map8300);
397 }
398
399 /* this function is called at probe time */
400 static int sd_config(struct gspca_dev *gspca_dev,
401 const struct usb_device_id *id)
402 {
403 struct sd *sd = (struct sd *) gspca_dev;
404 struct cam *cam;
405 __u16 vendor, product;
406 __u8 data1, data2;
407
408 /* Read frm global register the USB product and vendor IDs, just to
409 * prove that we can communicate with the device. This works, which
410 * confirms at we are communicating properly and that the device
411 * is a 561. */
412 reg_r(gspca_dev, 0x8104, 1);
413 data1 = gspca_dev->usb_buf[0];
414 reg_r(gspca_dev, 0x8105, 1);
415 data2 = gspca_dev->usb_buf[0];
416 vendor = (data2 << 8) | data1;
417 reg_r(gspca_dev, 0x8106, 1);
418 data1 = gspca_dev->usb_buf[0];
419 reg_r(gspca_dev, 0x8107, 1);
420 data2 = gspca_dev->usb_buf[0];
421 product = (data2 << 8) | data1;
422 if (vendor != id->idVendor || product != id->idProduct) {
423 PDEBUG(D_PROBE, "Bad vendor / product from device");
424 return -EINVAL;
425 }
426
427 cam = &gspca_dev->cam;
428 cam->needs_full_bandwidth = 1;
429
430 sd->chip_revision = id->driver_info;
431 if (sd->chip_revision == Rev012A) {
432 cam->cam_mode = sif_012a_mode;
433 cam->nmodes = ARRAY_SIZE(sif_012a_mode);
434 } else {
435 cam->cam_mode = sif_072a_mode;
436 cam->nmodes = ARRAY_SIZE(sif_072a_mode);
437 }
438 sd->expo12a = EXPO12A_DEF;
439 return 0;
440 }
441
442 /* this function is called at probe and resume time */
443 static int sd_init_12a(struct gspca_dev *gspca_dev)
444 {
445 PDEBUG(D_STREAM, "Chip revision: 012a");
446 init_161rev12A(gspca_dev);
447 return 0;
448 }
449 static int sd_init_72a(struct gspca_dev *gspca_dev)
450 {
451 PDEBUG(D_STREAM, "Chip revision: 072a");
452 write_vector(gspca_dev, rev72a_reset);
453 msleep(200);
454 write_vector(gspca_dev, rev72a_init_data1);
455 write_sensor_72a(gspca_dev, rev72a_init_sensor1);
456 write_vector(gspca_dev, rev72a_init_data2);
457 write_sensor_72a(gspca_dev, rev72a_init_sensor2);
458 reg_w_val(gspca_dev, 0x8112, 0x30);
459 return 0;
460 }
461
462 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
463 {
464 struct sd *sd = (struct sd *) gspca_dev;
465 __u16 reg;
466
467 if (sd->chip_revision == Rev012A)
468 reg = 0x8610;
469 else
470 reg = 0x8611;
471
472 reg_w_val(gspca_dev, reg + 0, val); /* R */
473 reg_w_val(gspca_dev, reg + 1, val); /* Gr */
474 reg_w_val(gspca_dev, reg + 2, val); /* B */
475 reg_w_val(gspca_dev, reg + 3, val); /* Gb */
476 }
477
478 static void setwhite(struct gspca_dev *gspca_dev, s32 white, s32 contrast)
479 {
480 struct sd *sd = (struct sd *) gspca_dev;
481 __u8 blue, red;
482 __u16 reg;
483
484 /* try to emulate MS-win as possible */
485 red = 0x20 + white * 3 / 8;
486 blue = 0x90 - white * 5 / 8;
487 if (sd->chip_revision == Rev012A) {
488 reg = 0x8614;
489 } else {
490 reg = 0x8651;
491 red += contrast - 0x20;
492 blue += contrast - 0x20;
493 reg_w_val(gspca_dev, 0x8652, contrast + 0x20); /* Gr */
494 reg_w_val(gspca_dev, 0x8654, contrast + 0x20); /* Gb */
495 }
496 reg_w_val(gspca_dev, reg, red);
497 reg_w_val(gspca_dev, reg + 2, blue);
498 }
499
500 /* rev 12a only */
501 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
502 {
503 int i, expo = 0;
504
505 /* Register 0x8309 controls exposure for the spca561,
506 the basic exposure setting goes from 1-2047, where 1 is completely
507 dark and 2047 is very bright. It not only influences exposure but
508 also the framerate (to allow for longer exposure) from 1 - 300 it
509 only raises the exposure time then from 300 - 600 it halves the
510 framerate to be able to further raise the exposure time and for every
511 300 more it halves the framerate again. This allows for a maximum
512 exposure time of circa 0.2 - 0.25 seconds (30 / (2000/3000) fps).
513 Sometimes this is not enough, the 1-2047 uses bits 0-10, bits 11-12
514 configure a divider for the base framerate which us used at the
515 exposure setting of 1-300. These bits configure the base framerate
516 according to the following formula: fps = 60 / (value + 2) */
517
518 /* We choose to use the high bits setting the fixed framerate divisor
519 asap, as setting high basic exposure setting without the fixed
520 divider in combination with high gains makes the cam stop */
521 int table[] = { 0, 450, 550, 625, EXPOSURE_MAX };
522
523 for (i = 0; i < ARRAY_SIZE(table) - 1; i++) {
524 if (val <= table[i + 1]) {
525 expo = val - table[i];
526 if (i)
527 expo += 300;
528 expo |= i << 11;
529 break;
530 }
531 }
532
533 gspca_dev->usb_buf[0] = expo;
534 gspca_dev->usb_buf[1] = expo >> 8;
535 reg_w_buf(gspca_dev, 0x8309, 2);
536 }
537
538 /* rev 12a only */
539 static void setgain(struct gspca_dev *gspca_dev, s32 val)
540 {
541 /* gain reg low 6 bits 0-63 gain, bit 6 and 7, both double the
542 sensitivity when set, so 31 + one of them set == 63, and 15
543 with both of them set == 63 */
544 if (val < 64)
545 gspca_dev->usb_buf[0] = val;
546 else if (val < 128)
547 gspca_dev->usb_buf[0] = (val / 2) | 0x40;
548 else
549 gspca_dev->usb_buf[0] = (val / 4) | 0xc0;
550
551 gspca_dev->usb_buf[1] = 0;
552 reg_w_buf(gspca_dev, 0x8335, 2);
553 }
554
555 static void setautogain(struct gspca_dev *gspca_dev, s32 val)
556 {
557 struct sd *sd = (struct sd *) gspca_dev;
558
559 if (val)
560 sd->ag_cnt = AG_CNT_START;
561 else
562 sd->ag_cnt = -1;
563 }
564
565 static int sd_start_12a(struct gspca_dev *gspca_dev)
566 {
567 int mode;
568 static const __u8 Reg8391[8] =
569 {0x92, 0x30, 0x20, 0x00, 0x0c, 0x00, 0x00, 0x00};
570
571 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
572 if (mode <= 1) {
573 /* Use compression on 320x240 and above */
574 reg_w_val(gspca_dev, 0x8500, 0x10 | mode);
575 } else {
576 /* I couldn't get the compression to work below 320x240
577 * Fortunately at these resolutions the bandwidth
578 * is sufficient to push raw frames at ~20fps */
579 reg_w_val(gspca_dev, 0x8500, mode);
580 } /* -- qq@kuku.eu.org */
581
582 gspca_dev->usb_buf[0] = 0xaa;
583 gspca_dev->usb_buf[1] = 0x00;
584 reg_w_buf(gspca_dev, 0x8307, 2);
585 /* clock - lower 0x8X values lead to fps > 30 */
586 reg_w_val(gspca_dev, 0x8700, 0x8a);
587 /* 0x8f 0x85 0x27 clock */
588 reg_w_val(gspca_dev, 0x8112, 0x1e | 0x20);
589 reg_w_val(gspca_dev, 0x850b, 0x03);
590 memcpy(gspca_dev->usb_buf, Reg8391, 8);
591 reg_w_buf(gspca_dev, 0x8391, 8);
592 reg_w_buf(gspca_dev, 0x8390, 8);
593
594 /* Led ON (bit 3 -> 0 */
595 reg_w_val(gspca_dev, 0x8114, 0x00);
596 return 0;
597 }
598 static int sd_start_72a(struct gspca_dev *gspca_dev)
599 {
600 struct sd *sd = (struct sd *) gspca_dev;
601 int Clck;
602 int mode;
603
604 write_vector(gspca_dev, rev72a_reset);
605 msleep(200);
606 write_vector(gspca_dev, rev72a_init_data1);
607 write_sensor_72a(gspca_dev, rev72a_init_sensor1);
608
609 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
610 switch (mode) {
611 default:
612 case 0:
613 Clck = 0x27; /* ms-win 0x87 */
614 break;
615 case 1:
616 Clck = 0x25;
617 break;
618 case 2:
619 Clck = 0x22;
620 break;
621 case 3:
622 Clck = 0x21;
623 break;
624 }
625 reg_w_val(gspca_dev, 0x8700, Clck); /* 0x27 clock */
626 reg_w_val(gspca_dev, 0x8702, 0x81);
627 reg_w_val(gspca_dev, 0x8500, mode); /* mode */
628 write_sensor_72a(gspca_dev, rev72a_init_sensor2);
629 setwhite(gspca_dev, v4l2_ctrl_g_ctrl(sd->hue),
630 v4l2_ctrl_g_ctrl(sd->contrast));
631 /* setbrightness(gspca_dev); * fixme: bad values */
632 setautogain(gspca_dev, v4l2_ctrl_g_ctrl(sd->autogain));
633 reg_w_val(gspca_dev, 0x8112, 0x10 | 0x20);
634 return 0;
635 }
636
637 static void sd_stopN(struct gspca_dev *gspca_dev)
638 {
639 struct sd *sd = (struct sd *) gspca_dev;
640
641 if (sd->chip_revision == Rev012A) {
642 reg_w_val(gspca_dev, 0x8112, 0x0e);
643 /* Led Off (bit 3 -> 1 */
644 reg_w_val(gspca_dev, 0x8114, 0x08);
645 } else {
646 reg_w_val(gspca_dev, 0x8112, 0x20);
647 /* reg_w_val(gspca_dev, 0x8102, 0x00); ?? */
648 }
649 }
650
651 static void do_autogain(struct gspca_dev *gspca_dev)
652 {
653 struct sd *sd = (struct sd *) gspca_dev;
654 int expotimes;
655 int pixelclk;
656 int gainG;
657 __u8 R, Gr, Gb, B;
658 int y;
659 __u8 luma_mean = 110;
660 __u8 luma_delta = 20;
661 __u8 spring = 4;
662
663 if (sd->ag_cnt < 0)
664 return;
665 if (--sd->ag_cnt >= 0)
666 return;
667 sd->ag_cnt = AG_CNT_START;
668
669 switch (sd->chip_revision) {
670 case Rev072A:
671 reg_r(gspca_dev, 0x8621, 1);
672 Gr = gspca_dev->usb_buf[0];
673 reg_r(gspca_dev, 0x8622, 1);
674 R = gspca_dev->usb_buf[0];
675 reg_r(gspca_dev, 0x8623, 1);
676 B = gspca_dev->usb_buf[0];
677 reg_r(gspca_dev, 0x8624, 1);
678 Gb = gspca_dev->usb_buf[0];
679 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
680 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
681 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
682 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */
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 /* PDEBUG(D_PACK,
690 "Exposition Times 0x%03X Clock 0x%04X ",
691 expotimes,pixelclk); */
692 gainG = i2c_read(gspca_dev, 0x35, 0x10);
693 /* PDEBUG(D_PACK,
694 "reading Gain register %d", gainG); */
695
696 expotimes += (luma_mean - y) >> spring;
697 gainG += (luma_mean - y) / 50;
698 /* PDEBUG(D_PACK,
699 "compute expotimes %d gain %d",
700 expotimes,gainG); */
701
702 if (gainG > 0x3f)
703 gainG = 0x3f;
704 else if (gainG < 3)
705 gainG = 3;
706 i2c_write(gspca_dev, gainG, 0x35);
707
708 if (expotimes > 0x0256)
709 expotimes = 0x0256;
710 else if (expotimes < 3)
711 expotimes = 3;
712 i2c_write(gspca_dev, expotimes | pixelclk, 0x09);
713 }
714 break;
715 }
716 }
717
718 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
719 u8 *data, /* isoc packet */
720 int len) /* iso packet length */
721 {
722 struct sd *sd = (struct sd *) gspca_dev;
723
724 len--;
725 switch (*data++) { /* sequence number */
726 case 0: /* start of frame */
727 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
728
729 /* This should never happen */
730 if (len < 2) {
731 PERR("Short SOF packet, ignoring");
732 gspca_dev->last_packet_type = DISCARD_PACKET;
733 return;
734 }
735
736 #if IS_ENABLED(CONFIG_INPUT)
737 if (data[0] & 0x20) {
738 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
739 input_sync(gspca_dev->input_dev);
740 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
741 input_sync(gspca_dev->input_dev);
742 }
743 #endif
744
745 if (data[1] & 0x10) {
746 /* compressed bayer */
747 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
748 } else {
749 /* raw bayer (with a header, which we skip) */
750 if (sd->chip_revision == Rev012A) {
751 data += 20;
752 len -= 20;
753 } else {
754 data += 16;
755 len -= 16;
756 }
757 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
758 }
759 return;
760 case 0xff: /* drop (empty mpackets) */
761 return;
762 }
763 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
764 }
765
766 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
767 {
768 struct gspca_dev *gspca_dev =
769 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
770 struct sd *sd = (struct sd *)gspca_dev;
771
772 gspca_dev->usb_err = 0;
773
774 if (!gspca_dev->streaming)
775 return 0;
776
777 switch (ctrl->id) {
778 case V4L2_CID_BRIGHTNESS:
779 setbrightness(gspca_dev, ctrl->val);
780 break;
781 case V4L2_CID_CONTRAST:
782 /* hue/contrast control cluster for 72a */
783 setwhite(gspca_dev, sd->hue->val, ctrl->val);
784 break;
785 case V4L2_CID_HUE:
786 /* just plain hue control for 12a */
787 setwhite(gspca_dev, ctrl->val, 0);
788 break;
789 case V4L2_CID_EXPOSURE:
790 setexposure(gspca_dev, ctrl->val);
791 break;
792 case V4L2_CID_GAIN:
793 setgain(gspca_dev, ctrl->val);
794 break;
795 case V4L2_CID_AUTOGAIN:
796 setautogain(gspca_dev, ctrl->val);
797 break;
798 }
799 return gspca_dev->usb_err;
800 }
801
802 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
803 .s_ctrl = sd_s_ctrl,
804 };
805
806 static int sd_init_controls_12a(struct gspca_dev *gspca_dev)
807 {
808 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
809
810 gspca_dev->vdev.ctrl_handler = hdl;
811 v4l2_ctrl_handler_init(hdl, 3);
812 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
813 V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
814 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
815 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
816 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
817 V4L2_CID_EXPOSURE, 1, EXPOSURE_MAX, 1, 700);
818 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
819 V4L2_CID_GAIN, 0, 255, 1, 63);
820
821 if (hdl->error) {
822 pr_err("Could not initialize controls\n");
823 return hdl->error;
824 }
825 return 0;
826 }
827
828 static int sd_init_controls_72a(struct gspca_dev *gspca_dev)
829 {
830 struct sd *sd = (struct sd *)gspca_dev;
831 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
832
833 gspca_dev->vdev.ctrl_handler = hdl;
834 v4l2_ctrl_handler_init(hdl, 4);
835 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
836 V4L2_CID_CONTRAST, 0, 0x3f, 1, 0x20);
837 sd->hue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
838 V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
839 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
840 V4L2_CID_BRIGHTNESS, 0, 0x3f, 1, 0x20);
841 sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
842 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
843
844 if (hdl->error) {
845 pr_err("Could not initialize controls\n");
846 return hdl->error;
847 }
848 v4l2_ctrl_cluster(2, &sd->contrast);
849 return 0;
850 }
851
852 /* sub-driver description */
853 static const struct sd_desc sd_desc_12a = {
854 .name = MODULE_NAME,
855 .init_controls = sd_init_controls_12a,
856 .config = sd_config,
857 .init = sd_init_12a,
858 .start = sd_start_12a,
859 .stopN = sd_stopN,
860 .pkt_scan = sd_pkt_scan,
861 #if IS_ENABLED(CONFIG_INPUT)
862 .other_input = 1,
863 #endif
864 };
865 static const struct sd_desc sd_desc_72a = {
866 .name = MODULE_NAME,
867 .init_controls = sd_init_controls_72a,
868 .config = sd_config,
869 .init = sd_init_72a,
870 .start = sd_start_72a,
871 .stopN = sd_stopN,
872 .pkt_scan = sd_pkt_scan,
873 .dq_callback = do_autogain,
874 #if IS_ENABLED(CONFIG_INPUT)
875 .other_input = 1,
876 #endif
877 };
878 static const struct sd_desc *sd_desc[2] = {
879 &sd_desc_12a,
880 &sd_desc_72a
881 };
882
883 /* -- module initialisation -- */
884 static const struct usb_device_id device_table[] = {
885 {USB_DEVICE(0x041e, 0x401a), .driver_info = Rev072A},
886 {USB_DEVICE(0x041e, 0x403b), .driver_info = Rev012A},
887 {USB_DEVICE(0x0458, 0x7004), .driver_info = Rev072A},
888 {USB_DEVICE(0x0461, 0x0815), .driver_info = Rev072A},
889 {USB_DEVICE(0x046d, 0x0928), .driver_info = Rev012A},
890 {USB_DEVICE(0x046d, 0x0929), .driver_info = Rev012A},
891 {USB_DEVICE(0x046d, 0x092a), .driver_info = Rev012A},
892 {USB_DEVICE(0x046d, 0x092b), .driver_info = Rev012A},
893 {USB_DEVICE(0x046d, 0x092c), .driver_info = Rev012A},
894 {USB_DEVICE(0x046d, 0x092d), .driver_info = Rev012A},
895 {USB_DEVICE(0x046d, 0x092e), .driver_info = Rev012A},
896 {USB_DEVICE(0x046d, 0x092f), .driver_info = Rev012A},
897 {USB_DEVICE(0x04fc, 0x0561), .driver_info = Rev072A},
898 {USB_DEVICE(0x060b, 0xa001), .driver_info = Rev072A},
899 {USB_DEVICE(0x10fd, 0x7e50), .driver_info = Rev072A},
900 {USB_DEVICE(0xabcd, 0xcdee), .driver_info = Rev072A},
901 {}
902 };
903
904 MODULE_DEVICE_TABLE(usb, device_table);
905
906 /* -- device connect -- */
907 static int sd_probe(struct usb_interface *intf,
908 const struct usb_device_id *id)
909 {
910 return gspca_dev_probe(intf, id,
911 sd_desc[id->driver_info],
912 sizeof(struct sd),
913 THIS_MODULE);
914 }
915
916 static struct usb_driver sd_driver = {
917 .name = MODULE_NAME,
918 .id_table = device_table,
919 .probe = sd_probe,
920 .disconnect = gspca_disconnect,
921 #ifdef CONFIG_PM
922 .suspend = gspca_suspend,
923 .resume = gspca_resume,
924 .reset_resume = gspca_resume,
925 #endif
926 };
927
928 module_usb_driver(sd_driver);
Ubuntu Hirsute Linux kernel mirror