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