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