?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
media: gspca: zero usb_buf on error
[linux/fpc-iii.git] / drivers / media / usb / gspca / se401.c
blobe087cfb5980b0e4bdb2217acf45637e451d0b47b
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * GSPCA Endpoints (formerly known as AOX) se401 USB Camera sub Driver
4 *
5 * Copyright (C) 2011 Hans de Goede <hdegoede@redhat.com>
6 *
7 * Based on the v4l1 se401 driver which is:
8 *
9 * Copyright (c) 2000 Jeroen B. Vreeken (pe1rxq@amsat.org)
10 */
11
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14 #define MODULE_NAME "se401"
15
16 #define BULK_SIZE 4096
17 #define PACKET_SIZE 1024
18 #define READ_REQ_SIZE 64
19 #define MAX_MODES ((READ_REQ_SIZE - 6) / 4)
20 /* The se401 compression algorithm uses a fixed quant factor, which
21 can be configured by setting the high nibble of the SE401_OPERATINGMODE
22 feature. This needs to exactly match what is in libv4l! */
23 #define SE401_QUANT_FACT 8
24
25 #include <linux/input.h>
26 #include <linux/slab.h>
27 #include "gspca.h"
28 #include "se401.h"
29
30 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
31 MODULE_DESCRIPTION("Endpoints se401");
32 MODULE_LICENSE("GPL");
33
34 /* exposure change state machine states */
35 enum {
36 EXPO_CHANGED,
37 EXPO_DROP_FRAME,
38 EXPO_NO_CHANGE,
39 };
40
41 /* specific webcam descriptor */
42 struct sd {
43 struct gspca_dev gspca_dev; /* !! must be the first item */
44 struct { /* exposure/freq control cluster */
45 struct v4l2_ctrl *exposure;
46 struct v4l2_ctrl *freq;
47 };
48 bool has_brightness;
49 struct v4l2_pix_format fmts[MAX_MODES];
50 int pixels_read;
51 int packet_read;
52 u8 packet[PACKET_SIZE];
53 u8 restart_stream;
54 u8 button_state;
55 u8 resetlevel;
56 u8 resetlevel_frame_count;
57 int resetlevel_adjust_dir;
58 int expo_change_state;
59 };
60
61
62 static void se401_write_req(struct gspca_dev *gspca_dev, u16 req, u16 value,
63 int silent)
64 {
65 int err;
66
67 if (gspca_dev->usb_err < 0)
68 return;
69
70 err = usb_control_msg(gspca_dev->dev,
71 usb_sndctrlpipe(gspca_dev->dev, 0), req,
72 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
73 value, 0, NULL, 0, 1000);
74 if (err < 0) {
75 if (!silent)
76 pr_err("write req failed req %#04x val %#04x error %d\n",
77 req, value, err);
78 gspca_dev->usb_err = err;
79 }
80 }
81
82 static void se401_read_req(struct gspca_dev *gspca_dev, u16 req, int silent)
83 {
84 int err;
85
86 if (gspca_dev->usb_err < 0)
87 return;
88
89 if (USB_BUF_SZ < READ_REQ_SIZE) {
90 pr_err("USB_BUF_SZ too small!!\n");
91 gspca_dev->usb_err = -ENOBUFS;
92 return;
93 }
94
95 err = usb_control_msg(gspca_dev->dev,
96 usb_rcvctrlpipe(gspca_dev->dev, 0), req,
97 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
98 0, 0, gspca_dev->usb_buf, READ_REQ_SIZE, 1000);
99 if (err < 0) {
100 if (!silent)
101 pr_err("read req failed req %#04x error %d\n",
102 req, err);
103 gspca_dev->usb_err = err;
104 /*
105 * Make sure the buffer is zeroed to avoid uninitialized
106 * values.
107 */
108 memset(gspca_dev->usb_buf, 0, READ_REQ_SIZE);
109 }
110 }
111
112 static void se401_set_feature(struct gspca_dev *gspca_dev,
113 u16 selector, u16 param)
114 {
115 int err;
116
117 if (gspca_dev->usb_err < 0)
118 return;
119
120 err = usb_control_msg(gspca_dev->dev,
121 usb_sndctrlpipe(gspca_dev->dev, 0),
122 SE401_REQ_SET_EXT_FEATURE,
123 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
124 param, selector, NULL, 0, 1000);
125 if (err < 0) {
126 pr_err("set feature failed sel %#04x param %#04x error %d\n",
127 selector, param, err);
128 gspca_dev->usb_err = err;
129 }
130 }
131
132 static int se401_get_feature(struct gspca_dev *gspca_dev, u16 selector)
133 {
134 int err;
135
136 if (gspca_dev->usb_err < 0)
137 return gspca_dev->usb_err;
138
139 if (USB_BUF_SZ < 2) {
140 pr_err("USB_BUF_SZ too small!!\n");
141 gspca_dev->usb_err = -ENOBUFS;
142 return gspca_dev->usb_err;
143 }
144
145 err = usb_control_msg(gspca_dev->dev,
146 usb_rcvctrlpipe(gspca_dev->dev, 0),
147 SE401_REQ_GET_EXT_FEATURE,
148 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
149 0, selector, gspca_dev->usb_buf, 2, 1000);
150 if (err < 0) {
151 pr_err("get feature failed sel %#04x error %d\n",
152 selector, err);
153 gspca_dev->usb_err = err;
154 return err;
155 }
156 return gspca_dev->usb_buf[0] | (gspca_dev->usb_buf[1] << 8);
157 }
158
159 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
160 {
161 /* HDG: this does not seem to do anything on my cam */
162 se401_write_req(gspca_dev, SE401_REQ_SET_BRT, val, 0);
163 }
164
165 static void setgain(struct gspca_dev *gspca_dev, s32 val)
166 {
167 u16 gain = 63 - val;
168
169 /* red color gain */
170 se401_set_feature(gspca_dev, HV7131_REG_ARCG, gain);
171 /* green color gain */
172 se401_set_feature(gspca_dev, HV7131_REG_AGCG, gain);
173 /* blue color gain */
174 se401_set_feature(gspca_dev, HV7131_REG_ABCG, gain);
175 }
176
177 static void setexposure(struct gspca_dev *gspca_dev, s32 val, s32 freq)
178 {
179 struct sd *sd = (struct sd *) gspca_dev;
180 int integration = val << 6;
181 u8 expose_h, expose_m, expose_l;
182
183 /* Do this before the set_feature calls, for proper timing wrt
184 the interrupt driven pkt_scan. Note we may still race but that
185 is not a big issue, the expo change state machine is merely for
186 avoiding underexposed frames getting send out, if one sneaks
187 through so be it */
188 sd->expo_change_state = EXPO_CHANGED;
189
190 if (freq == V4L2_CID_POWER_LINE_FREQUENCY_50HZ)
191 integration = integration - integration % 106667;
192 if (freq == V4L2_CID_POWER_LINE_FREQUENCY_60HZ)
193 integration = integration - integration % 88889;
194
195 expose_h = (integration >> 16);
196 expose_m = (integration >> 8);
197 expose_l = integration;
198
199 /* integration time low */
200 se401_set_feature(gspca_dev, HV7131_REG_TITL, expose_l);
201 /* integration time mid */
202 se401_set_feature(gspca_dev, HV7131_REG_TITM, expose_m);
203 /* integration time high */
204 se401_set_feature(gspca_dev, HV7131_REG_TITU, expose_h);
205 }
206
207 static int sd_config(struct gspca_dev *gspca_dev,
208 const struct usb_device_id *id)
209 {
210 struct sd *sd = (struct sd *)gspca_dev;
211 struct cam *cam = &gspca_dev->cam;
212 u8 *cd = gspca_dev->usb_buf;
213 int i, j, n;
214 int widths[MAX_MODES], heights[MAX_MODES];
215
216 /* Read the camera descriptor */
217 se401_read_req(gspca_dev, SE401_REQ_GET_CAMERA_DESCRIPTOR, 1);
218 if (gspca_dev->usb_err) {
219 /* Sometimes after being idle for a while the se401 won't
220 respond and needs a good kicking */
221 usb_reset_device(gspca_dev->dev);
222 gspca_dev->usb_err = 0;
223 se401_read_req(gspca_dev, SE401_REQ_GET_CAMERA_DESCRIPTOR, 0);
224 }
225
226 /* Some cameras start with their LED on */
227 se401_write_req(gspca_dev, SE401_REQ_LED_CONTROL, 0, 0);
228 if (gspca_dev->usb_err)
229 return gspca_dev->usb_err;
230
231 if (cd[1] != 0x41) {
232 pr_err("Wrong descriptor type\n");
233 return -ENODEV;
234 }
235
236 if (!(cd[2] & SE401_FORMAT_BAYER)) {
237 pr_err("Bayer format not supported!\n");
238 return -ENODEV;
239 }
240
241 if (cd[3])
242 pr_info("ExtraFeatures: %d\n", cd[3]);
243
244 n = cd[4] | (cd[5] << 8);
245 if (n > MAX_MODES) {
246 pr_err("Too many frame sizes\n");
247 return -ENODEV;
248 }
249
250 for (i = 0; i < n ; i++) {
251 widths[i] = cd[6 + i * 4 + 0] | (cd[6 + i * 4 + 1] << 8);
252 heights[i] = cd[6 + i * 4 + 2] | (cd[6 + i * 4 + 3] << 8);
253 }
254
255 for (i = 0; i < n ; i++) {
256 sd->fmts[i].width = widths[i];
257 sd->fmts[i].height = heights[i];
258 sd->fmts[i].field = V4L2_FIELD_NONE;
259 sd->fmts[i].colorspace = V4L2_COLORSPACE_SRGB;
260 sd->fmts[i].priv = 1;
261
262 /* janggu compression only works for 1/4th or 1/16th res */
263 for (j = 0; j < n; j++) {
264 if (widths[j] / 2 == widths[i] &&
265 heights[j] / 2 == heights[i]) {
266 sd->fmts[i].priv = 2;
267 break;
268 }
269 }
270 /* 1/16th if available too is better then 1/4th, because
271 we then use a larger area of the sensor */
272 for (j = 0; j < n; j++) {
273 if (widths[j] / 4 == widths[i] &&
274 heights[j] / 4 == heights[i]) {
275 sd->fmts[i].priv = 4;
276 break;
277 }
278 }
279
280 if (sd->fmts[i].priv == 1) {
281 /* Not a 1/4th or 1/16th res, use bayer */
282 sd->fmts[i].pixelformat = V4L2_PIX_FMT_SBGGR8;
283 sd->fmts[i].bytesperline = widths[i];
284 sd->fmts[i].sizeimage = widths[i] * heights[i];
285 pr_info("Frame size: %dx%d bayer\n",
286 widths[i], heights[i]);
287 } else {
288 /* Found a match use janggu compression */
289 sd->fmts[i].pixelformat = V4L2_PIX_FMT_SE401;
290 sd->fmts[i].bytesperline = 0;
291 sd->fmts[i].sizeimage = widths[i] * heights[i] * 3;
292 pr_info("Frame size: %dx%d 1/%dth janggu\n",
293 widths[i], heights[i],
294 sd->fmts[i].priv * sd->fmts[i].priv);
295 }
296 }
297
298 cam->cam_mode = sd->fmts;
299 cam->nmodes = n;
300 cam->bulk = 1;
301 cam->bulk_size = BULK_SIZE;
302 cam->bulk_nurbs = 4;
303 sd->resetlevel = 0x2d; /* Set initial resetlevel */
304
305 /* See if the camera supports brightness */
306 se401_read_req(gspca_dev, SE401_REQ_GET_BRT, 1);
307 sd->has_brightness = !!gspca_dev->usb_err;
308 gspca_dev->usb_err = 0;
309
310 return 0;
311 }
312
313 /* this function is called at probe and resume time */
314 static int sd_init(struct gspca_dev *gspca_dev)
315 {
316 return 0;
317 }
318
319 /* function called at start time before URB creation */
320 static int sd_isoc_init(struct gspca_dev *gspca_dev)
321 {
322 gspca_dev->alt = 1; /* Ignore the bogus isoc alt settings */
323
324 return gspca_dev->usb_err;
325 }
326
327 /* -- start the camera -- */
328 static int sd_start(struct gspca_dev *gspca_dev)
329 {
330 struct sd *sd = (struct sd *)gspca_dev;
331 int mult = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
332 int mode = 0;
333
334 se401_write_req(gspca_dev, SE401_REQ_CAMERA_POWER, 1, 1);
335 if (gspca_dev->usb_err) {
336 /* Sometimes after being idle for a while the se401 won't
337 respond and needs a good kicking */
338 usb_reset_device(gspca_dev->dev);
339 gspca_dev->usb_err = 0;
340 se401_write_req(gspca_dev, SE401_REQ_CAMERA_POWER, 1, 0);
341 }
342 se401_write_req(gspca_dev, SE401_REQ_LED_CONTROL, 1, 0);
343
344 se401_set_feature(gspca_dev, HV7131_REG_MODE_B, 0x05);
345
346 /* set size + mode */
347 se401_write_req(gspca_dev, SE401_REQ_SET_WIDTH,
348 gspca_dev->pixfmt.width * mult, 0);
349 se401_write_req(gspca_dev, SE401_REQ_SET_HEIGHT,
350 gspca_dev->pixfmt.height * mult, 0);
351 /*
352 * HDG: disabled this as it does not seem to do anything
353 * se401_write_req(gspca_dev, SE401_REQ_SET_OUTPUT_MODE,
354 * SE401_FORMAT_BAYER, 0);
355 */
356
357 switch (mult) {
358 case 1: /* Raw bayer */
359 mode = 0x03; break;
360 case 2: /* 1/4th janggu */
361 mode = SE401_QUANT_FACT << 4; break;
362 case 4: /* 1/16th janggu */
363 mode = (SE401_QUANT_FACT << 4) | 0x02; break;
364 }
365 se401_set_feature(gspca_dev, SE401_OPERATINGMODE, mode);
366
367 se401_set_feature(gspca_dev, HV7131_REG_ARLV, sd->resetlevel);
368
369 sd->packet_read = 0;
370 sd->pixels_read = 0;
371 sd->restart_stream = 0;
372 sd->resetlevel_frame_count = 0;
373 sd->resetlevel_adjust_dir = 0;
374 sd->expo_change_state = EXPO_NO_CHANGE;
375
376 se401_write_req(gspca_dev, SE401_REQ_START_CONTINUOUS_CAPTURE, 0, 0);
377
378 return gspca_dev->usb_err;
379 }
380
381 static void sd_stopN(struct gspca_dev *gspca_dev)
382 {
383 se401_write_req(gspca_dev, SE401_REQ_STOP_CONTINUOUS_CAPTURE, 0, 0);
384 se401_write_req(gspca_dev, SE401_REQ_LED_CONTROL, 0, 0);
385 se401_write_req(gspca_dev, SE401_REQ_CAMERA_POWER, 0, 0);
386 }
387
388 static void sd_dq_callback(struct gspca_dev *gspca_dev)
389 {
390 struct sd *sd = (struct sd *)gspca_dev;
391 unsigned int ahrc, alrc;
392 int oldreset, adjust_dir;
393
394 /* Restart the stream if requested do so by pkt_scan */
395 if (sd->restart_stream) {
396 sd_stopN(gspca_dev);
397 sd_start(gspca_dev);
398 sd->restart_stream = 0;
399 }
400
401 /* Automatically adjust sensor reset level
402 Hyundai have some really nice docs about this and other sensor
403 related stuff on their homepage: www.hei.co.kr */
404 sd->resetlevel_frame_count++;
405 if (sd->resetlevel_frame_count < 20)
406 return;
407
408 /* For some reason this normally read-only register doesn't get reset
409 to zero after reading them just once... */
410 se401_get_feature(gspca_dev, HV7131_REG_HIREFNOH);
411 se401_get_feature(gspca_dev, HV7131_REG_HIREFNOL);
412 se401_get_feature(gspca_dev, HV7131_REG_LOREFNOH);
413 se401_get_feature(gspca_dev, HV7131_REG_LOREFNOL);
414 ahrc = 256*se401_get_feature(gspca_dev, HV7131_REG_HIREFNOH) +
415 se401_get_feature(gspca_dev, HV7131_REG_HIREFNOL);
416 alrc = 256*se401_get_feature(gspca_dev, HV7131_REG_LOREFNOH) +
417 se401_get_feature(gspca_dev, HV7131_REG_LOREFNOL);
418
419 /* Not an exact science, but it seems to work pretty well... */
420 oldreset = sd->resetlevel;
421 if (alrc > 10) {
422 while (alrc >= 10 && sd->resetlevel < 63) {
423 sd->resetlevel++;
424 alrc /= 2;
425 }
426 } else if (ahrc > 20) {
427 while (ahrc >= 20 && sd->resetlevel > 0) {
428 sd->resetlevel--;
429 ahrc /= 2;
430 }
431 }
432 /* Detect ping-pong-ing and halve adjustment to avoid overshoot */
433 if (sd->resetlevel > oldreset)
434 adjust_dir = 1;
435 else
436 adjust_dir = -1;
437 if (sd->resetlevel_adjust_dir &&
438 sd->resetlevel_adjust_dir != adjust_dir)
439 sd->resetlevel = oldreset + (sd->resetlevel - oldreset) / 2;
440
441 if (sd->resetlevel != oldreset) {
442 sd->resetlevel_adjust_dir = adjust_dir;
443 se401_set_feature(gspca_dev, HV7131_REG_ARLV, sd->resetlevel);
444 }
445
446 sd->resetlevel_frame_count = 0;
447 }
448
449 static void sd_complete_frame(struct gspca_dev *gspca_dev, u8 *data, int len)
450 {
451 struct sd *sd = (struct sd *)gspca_dev;
452
453 switch (sd->expo_change_state) {
454 case EXPO_CHANGED:
455 /* The exposure was changed while this frame
456 was being send, so this frame is ok */
457 sd->expo_change_state = EXPO_DROP_FRAME;
458 break;
459 case EXPO_DROP_FRAME:
460 /* The exposure was changed while this frame
461 was being captured, drop it! */
462 gspca_dev->last_packet_type = DISCARD_PACKET;
463 sd->expo_change_state = EXPO_NO_CHANGE;
464 break;
465 case EXPO_NO_CHANGE:
466 break;
467 }
468 gspca_frame_add(gspca_dev, LAST_PACKET, data, len);
469 }
470
471 static void sd_pkt_scan_janggu(struct gspca_dev *gspca_dev, u8 *data, int len)
472 {
473 struct sd *sd = (struct sd *)gspca_dev;
474 int imagesize = gspca_dev->pixfmt.width * gspca_dev->pixfmt.height;
475 int i, plen, bits, pixels, info, count;
476
477 if (sd->restart_stream)
478 return;
479
480 /* Sometimes a 1024 bytes garbage bulk packet is send between frames */
481 if (gspca_dev->last_packet_type == LAST_PACKET && len == 1024) {
482 gspca_dev->last_packet_type = DISCARD_PACKET;
483 return;
484 }
485
486 i = 0;
487 while (i < len) {
488 /* Read header if not already be present from prev bulk pkt */
489 if (sd->packet_read < 4) {
490 count = 4 - sd->packet_read;
491 if (count > len - i)
492 count = len - i;
493 memcpy(&sd->packet[sd->packet_read], &data[i], count);
494 sd->packet_read += count;
495 i += count;
496 if (sd->packet_read < 4)
497 break;
498 }
499 bits = sd->packet[3] + (sd->packet[2] << 8);
500 pixels = sd->packet[1] + ((sd->packet[0] & 0x3f) << 8);
501 info = (sd->packet[0] & 0xc0) >> 6;
502 plen = ((bits + 47) >> 4) << 1;
503 /* Sanity checks */
504 if (plen > 1024) {
505 pr_err("invalid packet len %d restarting stream\n",
506 plen);
507 goto error;
508 }
509 if (info == 3) {
510 pr_err("unknown frame info value restarting stream\n");
511 goto error;
512 }
513
514 /* Read (remainder of) packet contents */
515 count = plen - sd->packet_read;
516 if (count > len - i)
517 count = len - i;
518 memcpy(&sd->packet[sd->packet_read], &data[i], count);
519 sd->packet_read += count;
520 i += count;
521 if (sd->packet_read < plen)
522 break;
523
524 sd->pixels_read += pixels;
525 sd->packet_read = 0;
526
527 switch (info) {
528 case 0: /* Frame data */
529 gspca_frame_add(gspca_dev, INTER_PACKET, sd->packet,
530 plen);
531 break;
532 case 1: /* EOF */
533 if (sd->pixels_read != imagesize) {
534 pr_err("frame size %d expected %d\n",
535 sd->pixels_read, imagesize);
536 goto error;
537 }
538 sd_complete_frame(gspca_dev, sd->packet, plen);
539 return; /* Discard the rest of the bulk packet !! */
540 case 2: /* SOF */
541 gspca_frame_add(gspca_dev, FIRST_PACKET, sd->packet,
542 plen);
543 sd->pixels_read = pixels;
544 break;
545 }
546 }
547 return;
548
549 error:
550 sd->restart_stream = 1;
551 /* Give userspace a 0 bytes frame, so our dq callback gets
552 called and it can restart the stream */
553 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
554 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
555 }
556
557 static void sd_pkt_scan_bayer(struct gspca_dev *gspca_dev, u8 *data, int len)
558 {
559 struct cam *cam = &gspca_dev->cam;
560 int imagesize = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
561
562 if (gspca_dev->image_len == 0) {
563 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
564 return;
565 }
566
567 if (gspca_dev->image_len + len >= imagesize) {
568 sd_complete_frame(gspca_dev, data, len);
569 return;
570 }
571
572 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
573 }
574
575 static void sd_pkt_scan(struct gspca_dev *gspca_dev, u8 *data, int len)
576 {
577 int mult = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
578
579 if (len == 0)
580 return;
581
582 if (mult == 1) /* mult == 1 means raw bayer */
583 sd_pkt_scan_bayer(gspca_dev, data, len);
584 else
585 sd_pkt_scan_janggu(gspca_dev, data, len);
586 }
587
588 #if IS_ENABLED(CONFIG_INPUT)
589 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, u8 *data, int len)
590 {
591 struct sd *sd = (struct sd *)gspca_dev;
592 u8 state;
593
594 if (len != 2)
595 return -EINVAL;
596
597 switch (data[0]) {
598 case 0:
599 case 1:
600 state = data[0];
601 break;
602 default:
603 return -EINVAL;
604 }
605 if (sd->button_state != state) {
606 input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
607 input_sync(gspca_dev->input_dev);
608 sd->button_state = state;
609 }
610
611 return 0;
612 }
613 #endif
614
615 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
616 {
617 struct gspca_dev *gspca_dev =
618 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
619 struct sd *sd = (struct sd *)gspca_dev;
620
621 gspca_dev->usb_err = 0;
622
623 if (!gspca_dev->streaming)
624 return 0;
625
626 switch (ctrl->id) {
627 case V4L2_CID_BRIGHTNESS:
628 setbrightness(gspca_dev, ctrl->val);
629 break;
630 case V4L2_CID_GAIN:
631 setgain(gspca_dev, ctrl->val);
632 break;
633 case V4L2_CID_EXPOSURE:
634 setexposure(gspca_dev, ctrl->val, sd->freq->val);
635 break;
636 }
637 return gspca_dev->usb_err;
638 }
639
640 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
641 .s_ctrl = sd_s_ctrl,
642 };
643
644 static int sd_init_controls(struct gspca_dev *gspca_dev)
645 {
646 struct sd *sd = (struct sd *)gspca_dev;
647 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
648
649 gspca_dev->vdev.ctrl_handler = hdl;
650 v4l2_ctrl_handler_init(hdl, 4);
651 if (sd->has_brightness)
652 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
653 V4L2_CID_BRIGHTNESS, 0, 255, 1, 15);
654 /* max is really 63 but > 50 is not pretty */
655 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
656 V4L2_CID_GAIN, 0, 50, 1, 25);
657 sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
658 V4L2_CID_EXPOSURE, 0, 32767, 1, 15000);
659 sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
660 V4L2_CID_POWER_LINE_FREQUENCY,
661 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0, 0);
662
663 if (hdl->error) {
664 pr_err("Could not initialize controls\n");
665 return hdl->error;
666 }
667 v4l2_ctrl_cluster(2, &sd->exposure);
668 return 0;
669 }
670
671 /* sub-driver description */
672 static const struct sd_desc sd_desc = {
673 .name = MODULE_NAME,
674 .config = sd_config,
675 .init = sd_init,
676 .init_controls = sd_init_controls,
677 .isoc_init = sd_isoc_init,
678 .start = sd_start,
679 .stopN = sd_stopN,
680 .dq_callback = sd_dq_callback,
681 .pkt_scan = sd_pkt_scan,
682 #if IS_ENABLED(CONFIG_INPUT)
683 .int_pkt_scan = sd_int_pkt_scan,
684 #endif
685 };
686
687 /* -- module initialisation -- */
688 static const struct usb_device_id device_table[] = {
689 {USB_DEVICE(0x03e8, 0x0004)}, /* Endpoints/Aox SE401 */
690 {USB_DEVICE(0x0471, 0x030b)}, /* Philips PCVC665K */
691 {USB_DEVICE(0x047d, 0x5001)}, /* Kensington 67014 */
692 {USB_DEVICE(0x047d, 0x5002)}, /* Kensington 6701(5/7) */
693 {USB_DEVICE(0x047d, 0x5003)}, /* Kensington 67016 */
694 {}
695 };
696 MODULE_DEVICE_TABLE(usb, device_table);
697
698 /* -- device connect -- */
699 static int sd_probe(struct usb_interface *intf,
700 const struct usb_device_id *id)
701 {
702 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
703 THIS_MODULE);
704 }
705
706 static int sd_pre_reset(struct usb_interface *intf)
707 {
708 return 0;
709 }
710
711 static int sd_post_reset(struct usb_interface *intf)
712 {
713 return 0;
714 }
715
716 static struct usb_driver sd_driver = {
717 .name = MODULE_NAME,
718 .id_table = device_table,
719 .probe = sd_probe,
720 .disconnect = gspca_disconnect,
721 #ifdef CONFIG_PM
722 .suspend = gspca_suspend,
723 .resume = gspca_resume,
724 .reset_resume = gspca_resume,
725 #endif
726 .pre_reset = sd_pre_reset,
727 .post_reset = sd_post_reset,
728 };
729
730 module_usb_driver(sd_driver);
Linux with added FPC-III support