linux/drivers/media/usb/gspca/se401.c
<<
>>
Prefs
   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
  44MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
  45MODULE_DESCRIPTION("Endpoints se401");
  46MODULE_LICENSE("GPL");
  47
  48/* exposure change state machine states */
  49enum {
  50        EXPO_CHANGED,
  51        EXPO_DROP_FRAME,
  52        EXPO_NO_CHANGE,
  53};
  54
  55/* specific webcam descriptor */
  56struct 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
  76static 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
  96static 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
 121static 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
 141static 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
 168static 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
 174static 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
 186static 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
 216static 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 */
 323static int sd_init(struct gspca_dev *gspca_dev)
 324{
 325        return 0;
 326}
 327
 328/* function called at start time before URB creation */
 329static 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 -- */
 337static 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
 390static 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
 397static 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
 458static 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
 480static 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
 558error:
 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
 566static 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
 584static 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)
 598static 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
 624static 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
 649static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 650        .s_ctrl = sd_s_ctrl,
 651};
 652
 653static 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 */
 681static 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 -- */
 697static 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};
 705MODULE_DEVICE_TABLE(usb, device_table);
 706
 707/* -- device connect -- */
 708static 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
 715static int sd_pre_reset(struct usb_interface *intf)
 716{
 717        return 0;
 718}
 719
 720static int sd_post_reset(struct usb_interface *intf)
 721{
 722        return 0;
 723}
 724
 725static 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
 739module_usb_driver(sd_driver);
 740