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