Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/media/usb/gspca/se401.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us