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