1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
26MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
27MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
28MODULE_LICENSE("GPL");
29
30#define EXPOSURE_MAX (2047 + 325)
31
32
33struct sd {
34 struct gspca_dev gspca_dev;
35
36 struct {
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;
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
53static 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
76static 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
101
102
103
104
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
125static const u16 rev72a_reset[][2] = {
126 {0x0000, 0x8114},
127 {0x0001, 0x8114},
128 {0x0000, 0x8112},
129 {}
130};
131static const __u16 rev72a_init_data1[][2] = {
132 {0x0003, 0x8701},
133 {0x0001, 0x8703},
134 {0x0011, 0x8118},
135 {0x0001, 0x8118},
136 {0x0092, 0x8804},
137 {0x0010, 0x8802},
138 {}
139};
140static 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};
155static const __u16 rev72a_init_data2[][2] = {
156 {0x0018, 0x8601},
157 {0x0000, 0x8602},
158 {0x0060, 0x8604},
159 {0x0002, 0x8605},
160 {0x0000, 0x8603},
161 {0x0002, 0x865b},
162 {0x0000, 0x865f},
163 {0x00b0, 0x865d},
164 {0x0090, 0x865e},
165 {0x00e0, 0x8406},
166 {0x0000, 0x8660},
167 {0x0002, 0x8201},
168 {0x0008, 0x8200},
169 {0x0001, 0x8200},
170
171 {0x0000, 0x8611},
172 {0x00fd, 0x8612},
173 {0x0003, 0x8613},
174 {0x0000, 0x8614},
175
176 {0x0035, 0x8651},
177 {0x0040, 0x8652},
178 {0x005f, 0x8653},
179 {0x0040, 0x8654},
180 {0x0002, 0x8502},
181 {0x0011, 0x8802},
182
183 {0x0087, 0x8700},
184 {0x0081, 0x8702},
185
186 {0x0000, 0x8500},
187
188
189 {0x0002, 0x865b},
190 {0x0003, 0x865c},
191 {}
192};
193static const u16 rev72a_init_sensor2[][2] = {
194 {0x0003, 0x0121},
195 {0x0004, 0x0165},
196 {0x0005, 0x002f},
197 {0x0006, 0x0000},
198 {0x000a, 0x0002},
199 {0x0009, 0x1061},
200
201 {0x0035, 0x0014},
202 {}
203};
204
205
206static const __u16 Pb100_1map8300[][2] = {
207
208 {0x8320, 0x3304},
209
210 {0x8303, 0x0125},
211 {0x8304, 0x0169},
212 {0x8328, 0x000b},
213 {0x833c, 0x0001},
214
215 {0x832f, 0x1904},
216 {0x8307, 0x00aa},
217 {0x8301, 0x0003},
218 {0x8302, 0x000e},
219 {}
220};
221static const __u16 Pb100_2map8300[][2] = {
222
223 {0x8339, 0x0000},
224 {0x8307, 0x00aa},
225 {}
226};
227
228static const __u16 spca561_161rev12A_data1[][2] = {
229 {0x29, 0x8118},
230 {0x08, 0x8114},
231 {0x0e, 0x8112},
232 {0x00, 0x8102},
233 {0x92, 0x8804},
234 {0x04, 0x8802},
235 {}
236};
237static 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},
245 {0x08, 0x8200},
246 {0x01, 0x8200},
247
248 {0x90, 0x8604},
249 {0x00, 0x8605},
250 {0xb0, 0x8603},
251
252
253 {0x07, 0x8601},
254 {0x07, 0x8602},
255 {0x00, 0x8610},
256 {0x00, 0x8611},
257 {0x00, 0x8612},
258 {0x00, 0x8613},
259 {0x43, 0x8614},
260 {0x40, 0x8615},
261 {0x71, 0x8616},
262 {0x40, 0x8617},
263
264 {0x0c, 0x8620},
265 {0xc8, 0x8631},
266 {0xc8, 0x8634},
267 {0x23, 0x8635},
268 {0x1f, 0x8636},
269 {0xdd, 0x8637},
270 {0xe1, 0x8638},
271 {0x1d, 0x8639},
272 {0x21, 0x863a},
273 {0xe3, 0x863b},
274 {0xdf, 0x863c},
275 {0xf0, 0x8505},
276 {0x32, 0x850a},
277
278
279
280 {0x29, 0x8118},
281 {}
282};
283
284static 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,
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
299static 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
312static 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,
318 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
319 0,
320 index, gspca_dev->usb_buf, length, 500);
321}
322
323
324static 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,
330 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
331 0,
332 index, gspca_dev->usb_buf, len, 500);
333}
334
335static 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
350static 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
371static 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
382static 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
391static 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
396 write_vector(gspca_dev, spca561_161rev12A_data2);
397 sensor_mapwrite(gspca_dev, Pb100_2map8300);
398}
399
400
401static 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
410
411
412
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
444static 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}
450static 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
463static 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);
474 reg_w_val(gspca_dev, reg + 1, val);
475 reg_w_val(gspca_dev, reg + 2, val);
476 reg_w_val(gspca_dev, reg + 3, val);
477}
478
479static 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
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);
495 reg_w_val(gspca_dev, 0x8654, contrast + 0x20);
496 }
497 reg_w_val(gspca_dev, reg, red);
498 reg_w_val(gspca_dev, reg + 2, blue);
499}
500
501
502static void setexposure(struct gspca_dev *gspca_dev, s32 val)
503{
504 int i, expo = 0;
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
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
540static void setgain(struct gspca_dev *gspca_dev, s32 val)
541{
542
543
544
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
556static 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
566static 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
575 reg_w_val(gspca_dev, 0x8500, 0x10 | mode);
576 } else {
577
578
579
580 reg_w_val(gspca_dev, 0x8500, mode);
581 }
582
583 gspca_dev->usb_buf[0] = 0xaa;
584 gspca_dev->usb_buf[1] = 0x00;
585 reg_w_buf(gspca_dev, 0x8307, 2);
586
587 reg_w_val(gspca_dev, 0x8700, 0x8a);
588
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
596 reg_w_val(gspca_dev, 0x8114, 0x00);
597 return 0;
598}
599static 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;
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);
627 reg_w_val(gspca_dev, 0x8702, 0x81);
628 reg_w_val(gspca_dev, 0x8500, 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
633 setautogain(gspca_dev, v4l2_ctrl_g_ctrl(sd->autogain));
634 reg_w_val(gspca_dev, 0x8112, 0x10 | 0x20);
635 return 0;
636}
637
638static 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
645 reg_w_val(gspca_dev, 0x8114, 0x08);
646 } else {
647 reg_w_val(gspca_dev, 0x8112, 0x20);
648
649 }
650}
651
652static 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
682
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
710static void sd_pkt_scan(struct gspca_dev *gspca_dev,
711 u8 *data,
712 int len)
713{
714 struct sd *sd = (struct sd *) gspca_dev;
715
716 len--;
717 switch (*data++) {
718 case 0:
719 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
720
721
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
739 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
740 } else {
741
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:
753 return;
754 }
755 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
756}
757
758static 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
775 setwhite(gspca_dev, sd->hue->val, ctrl->val);
776 break;
777 case V4L2_CID_HUE:
778
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
794static const struct v4l2_ctrl_ops sd_ctrl_ops = {
795 .s_ctrl = sd_s_ctrl,
796};
797
798static 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
820static 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
845static 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};
857static 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};
870static const struct sd_desc *sd_desc[2] = {
871 &sd_desc_12a,
872 &sd_desc_72a
873};
874
875
876static 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
896MODULE_DEVICE_TABLE(usb, device_table);
897
898
899static 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
908static 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
920module_usb_driver(sd_driver);
921