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

DEFINITIONS

1. se401_write_req
2. se401_read_req
3. se401_set_feature
4. se401_get_feature
5. setbrightness
6. setgain
7. setexposure
8. sd_config
9. sd_init
10. sd_isoc_init
11. sd_start
12. sd_stopN
13. sd_dq_callback
14. sd_complete_frame
15. sd_pkt_scan_janggu
16. sd_pkt_scan_bayer
17. sd_pkt_scan
18. sd_int_pkt_scan
19. sd_s_ctrl
20. sd_init_controls
21. sd_probe
22. sd_pre_reset
23. sd_post_reset

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