kernel/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);