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