drivers/media/usb/gspca/pac7302.c

   1 /*
   2  * Pixart PAC7302 driver
   3  *
   4  * Copyright (C) 2008-2012 Jean-Francois Moine <http://moinejf.free.fr>
   5  * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
   6  *
   7  * Separated from Pixart PAC7311 library by Márton Németh
   8  * Camera button input handling by Márton Németh <nm127@freemail.hu>
   9  * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24  */
  25
  26 /*
  27  * Some documentation about various registers as determined by trial and error.
  28  *
  29  * Register page 0:
  30  *
  31  * Address      Description
  32  * 0x02         Red balance control
  33  * 0x03         Green balance control
  34  * 0x04         Blue balance control
  35  *                   Valus are inverted (0=max, 255=min).
  36  *                   The Windows driver uses a quadratic approach to map
  37  *                   the settable values (0-200) on register values:
  38  *                   min=0x80, default=0x40, max=0x20
  39  * 0x0f-0x20    Colors, saturation and exposure control
  40  * 0xa2-0xab    Brightness, contrast and gamma control
  41  * 0xb6         Sharpness control (bits 0-4)
  42  *
  43  * Register page 1:
  44  *
  45  * Address      Description
  46  * 0x78         Global control, bit 6 controls the LED (inverted)
  47  * 0x80         Compression balance, 2 interesting settings:
  48  *              0x0f Default
  49  *              0x50 Values >= this switch the camera to a lower compression,
  50  *                   using the same table for both luminance and chrominance.
  51  *                   This gives a sharper picture. Only usable when running
  52  *                   at < 15 fps! Note currently the driver does not use this
  53  *                   as the quality gain is small and the generated JPG-s are
  54  *                   only understood by v4l-utils >= 0.8.9
  55  *
  56  * Register page 3:
  57  *
  58  * Address      Description
  59  * 0x02         Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on
  60  *              the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
  61  * 0x03         Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps
  62  * 0x04         Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps,
  63  *              63 -> ~27 fps, the 2 msb's must always be 1 !!
  64  * 0x05         Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0:
  65  *              1 -> ~30 fps, 2 -> ~20 fps
  66  * 0x0e         Exposure bits 0-7, 0-448, 0 = use full frame time
  67  * 0x0f         Exposure bit 8, 0-448, 448 = no exposure at all
  68  * 0x10         Gain 0-31
  69  * 0x12         Another gain 0-31, unlike 0x10 this one seems to start with an
  70  *              amplification value of 1 rather then 0 at its lowest setting
  71  * 0x21         Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
  72  * 0x80         Another framerate control, best left at 1, moving it from 1 to
  73  *              2 causes the framerate to become 3/4th of what it was, and
  74  *              also seems to cause pixel averaging, resulting in an effective
  75  *              resolution of 320x240 and thus a much blockier image
  76  *
  77  * The registers are accessed in the following functions:
  78  *
  79  * Page | Register   | Function
  80  * -----+------------+---------------------------------------------------
  81  *  0   | 0x0f..0x20 | setcolors()
  82  *  0   | 0xa2..0xab | setbrightcont()
  83  *  0   | 0xb6       | setsharpness()
  84  *  0   | 0xc5       | setredbalance()
  85  *  0   | 0xc6       | setwhitebalance()
  86  *  0   | 0xc7       | setbluebalance()
  87  *  0   | 0xdc       | setbrightcont(), setcolors()
  88  *  3   | 0x02       | setexposure()
  89  *  3   | 0x10, 0x12 | setgain()
  90  *  3   | 0x11       | setcolors(), setgain(), setexposure(), sethvflip()
  91  *  3   | 0x21       | sethvflip()
  92  */
  93
  94 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  95
  96 #include <linux/input.h>
  97 #include <media/v4l2-chip-ident.h>
  98 #include "gspca.h"
  99 /* Include pac common sof detection functions */
 100 #include "pac_common.h"
 101
 102 #define PAC7302_GAIN_DEFAULT      15
 103 #define PAC7302_GAIN_KNEE         42
 104 #define PAC7302_EXPOSURE_DEFAULT  66 /* 33 ms / 30 fps */
 105 #define PAC7302_EXPOSURE_KNEE    133 /* 66 ms / 15 fps */
 106
 107 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, "
 108                 "Thomas Kaiser thomas@kaiser-linux.li");
 109 MODULE_DESCRIPTION("Pixart PAC7302");
 110 MODULE_LICENSE("GPL");
 111
 112 struct sd {
 113         struct gspca_dev gspca_dev;             /* !! must be the first item */
 114
 115         struct { /* brightness / contrast cluster */
 116                 struct v4l2_ctrl *brightness;
 117                 struct v4l2_ctrl *contrast;
 118         };
 119         struct v4l2_ctrl *saturation;
 120         struct v4l2_ctrl *white_balance;
 121         struct v4l2_ctrl *red_balance;
 122         struct v4l2_ctrl *blue_balance;
 123         struct { /* flip cluster */
 124                 struct v4l2_ctrl *hflip;
 125                 struct v4l2_ctrl *vflip;
 126         };
 127         struct v4l2_ctrl *sharpness;
 128         u8 flags;
 129 #define FL_HFLIP 0x01           /* mirrored by default */
 130 #define FL_VFLIP 0x02           /* vertical flipped by default */
 131
 132         u8 sof_read;
 133         s8 autogain_ignore_frames;
 134
 135         atomic_t avg_lum;
 136 };
 137
 138 static const struct v4l2_pix_format vga_mode[] = {
 139         {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
 140                 .bytesperline = 640,
 141                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 142                 .colorspace = V4L2_COLORSPACE_JPEG,
 143         },
 144 };
 145
 146 #define LOAD_PAGE3              255
 147 #define END_OF_SEQUENCE         0
 148
 149 static const u8 init_7302[] = {
 150 /*      index,value */
 151         0xff, 0x01,             /* page 1 */
 152         0x78, 0x00,             /* deactivate */
 153         0xff, 0x01,
 154         0x78, 0x40,             /* led off */
 155 };
 156 static const u8 start_7302[] = {
 157 /*      index, len, [value]* */
 158         0xff, 1,        0x00,           /* page 0 */
 159         0x00, 12,       0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80,
 160                         0x00, 0x00, 0x00, 0x00,
 161         0x0d, 24,       0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00,
 162                         0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7,
 163                         0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11,
 164         0x26, 2,        0xaa, 0xaa,
 165         0x2e, 1,        0x31,
 166         0x38, 1,        0x01,
 167         0x3a, 3,        0x14, 0xff, 0x5a,
 168         0x43, 11,       0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11,
 169                         0x00, 0x54, 0x11,
 170         0x55, 1,        0x00,
 171         0x62, 4,        0x10, 0x1e, 0x1e, 0x18,
 172         0x6b, 1,        0x00,
 173         0x6e, 3,        0x08, 0x06, 0x00,
 174         0x72, 3,        0x00, 0xff, 0x00,
 175         0x7d, 23,       0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c,
 176                         0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50,
 177                         0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00,
 178         0xa2, 10,       0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9,
 179                         0xd2, 0xeb,
 180         0xaf, 1,        0x02,
 181         0xb5, 2,        0x08, 0x08,
 182         0xb8, 2,        0x08, 0x88,
 183         0xc4, 4,        0xae, 0x01, 0x04, 0x01,
 184         0xcc, 1,        0x00,
 185         0xd1, 11,       0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9,
 186                         0xc1, 0xd7, 0xec,
 187         0xdc, 1,        0x01,
 188         0xff, 1,        0x01,           /* page 1 */
 189         0x12, 3,        0x02, 0x00, 0x01,
 190         0x3e, 2,        0x00, 0x00,
 191         0x76, 5,        0x01, 0x20, 0x40, 0x00, 0xf2,
 192         0x7c, 1,        0x00,
 193         0x7f, 10,       0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20,
 194                         0x02, 0x00,
 195         0x96, 5,        0x01, 0x10, 0x04, 0x01, 0x04,
 196         0xc8, 14,       0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
 197                         0x07, 0x00, 0x01, 0x07, 0x04, 0x01,
 198         0xd8, 1,        0x01,
 199         0xdb, 2,        0x00, 0x01,
 200         0xde, 7,        0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
 201         0xe6, 4,        0x00, 0x00, 0x00, 0x01,
 202         0xeb, 1,        0x00,
 203         0xff, 1,        0x02,           /* page 2 */
 204         0x22, 1,        0x00,
 205         0xff, 1,        0x03,           /* page 3 */
 206         0, LOAD_PAGE3,                  /* load the page 3 */
 207         0x11, 1,        0x01,
 208         0xff, 1,        0x02,           /* page 2 */
 209         0x13, 1,        0x00,
 210         0x22, 4,        0x1f, 0xa4, 0xf0, 0x96,
 211         0x27, 2,        0x14, 0x0c,
 212         0x2a, 5,        0xc8, 0x00, 0x18, 0x12, 0x22,
 213         0x64, 8,        0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44,
 214         0x6e, 1,        0x08,
 215         0xff, 1,        0x01,           /* page 1 */
 216         0x78, 1,        0x00,
 217         0, END_OF_SEQUENCE              /* end of sequence */
 218 };
 219
 220 #define SKIP            0xaa
 221 /* page 3 - the value SKIP says skip the index - see reg_w_page() */
 222 static const u8 page3_7302[] = {
 223         0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16,
 224         0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
 225         0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 226         0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
 227         0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21,
 228         0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54,
 229         0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
 230         0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 231         0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
 232         SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
 233         0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 234         0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
 235         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 236         0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8,
 237         0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,
 238         0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00,
 239         0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00,
 240         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 241         0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00,
 242         0x00
 243 };
 244
 245 static void reg_w_buf(struct gspca_dev *gspca_dev,
 246                 u8 index,
 247                   const u8 *buffer, int len)
 248 {
 249         int ret;
 250
 251         if (gspca_dev->usb_err < 0)
 252                 return;
 253         memcpy(gspca_dev->usb_buf, buffer, len);
 254         ret = usb_control_msg(gspca_dev->dev,
 255                         usb_sndctrlpipe(gspca_dev->dev, 0),
 256                         0,              /* request */
 257                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 258                         0,              /* value */
 259                         index, gspca_dev->usb_buf, len,
 260                         500);
 261         if (ret < 0) {
 262                 pr_err("reg_w_buf failed i: %02x error %d\n",
 263                        index, ret);
 264                 gspca_dev->usb_err = ret;
 265         }
 266 }
 267
 268
 269 static void reg_w(struct gspca_dev *gspca_dev,
 270                 u8 index,
 271                 u8 value)
 272 {
 273         int ret;
 274
 275         if (gspca_dev->usb_err < 0)
 276                 return;
 277         gspca_dev->usb_buf[0] = value;
 278         ret = usb_control_msg(gspca_dev->dev,
 279                         usb_sndctrlpipe(gspca_dev->dev, 0),
 280                         0,                      /* request */
 281                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 282                         0, index, gspca_dev->usb_buf, 1,
 283                         500);
 284         if (ret < 0) {
 285                 pr_err("reg_w() failed i: %02x v: %02x error %d\n",
 286                        index, value, ret);
 287                 gspca_dev->usb_err = ret;
 288         }
 289 }
 290
 291 static void reg_w_seq(struct gspca_dev *gspca_dev,
 292                 const u8 *seq, int len)
 293 {
 294         while (--len >= 0) {
 295                 reg_w(gspca_dev, seq[0], seq[1]);
 296                 seq += 2;
 297         }
 298 }
 299
 300 /* load the beginning of a page */
 301 static void reg_w_page(struct gspca_dev *gspca_dev,
 302                         const u8 *page, int len)
 303 {
 304         int index;
 305         int ret = 0;
 306
 307         if (gspca_dev->usb_err < 0)
 308                 return;
 309         for (index = 0; index < len; index++) {
 310                 if (page[index] == SKIP)                /* skip this index */
 311                         continue;
 312                 gspca_dev->usb_buf[0] = page[index];
 313                 ret = usb_control_msg(gspca_dev->dev,
 314                                 usb_sndctrlpipe(gspca_dev->dev, 0),
 315                                 0,                      /* request */
 316                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 317                                 0, index, gspca_dev->usb_buf, 1,
 318                                 500);
 319                 if (ret < 0) {
 320                         pr_err("reg_w_page() failed i: %02x v: %02x error %d\n",
 321                                index, page[index], ret);
 322                         gspca_dev->usb_err = ret;
 323                         break;
 324                 }
 325         }
 326 }
 327
 328 /* output a variable sequence */
 329 static void reg_w_var(struct gspca_dev *gspca_dev,
 330                         const u8 *seq,
 331                         const u8 *page3, unsigned int page3_len)
 332 {
 333         int index, len;
 334
 335         for (;;) {
 336                 index = *seq++;
 337                 len = *seq++;
 338                 switch (len) {
 339                 case END_OF_SEQUENCE:
 340                         return;
 341                 case LOAD_PAGE3:
 342                         reg_w_page(gspca_dev, page3, page3_len);
 343                         break;
 344                 default:
 345 #ifdef GSPCA_DEBUG
 346                         if (len > USB_BUF_SZ) {
 347                                 PDEBUG(D_ERR|D_STREAM,
 348                                         "Incorrect variable sequence");
 349                                 return;
 350                         }
 351 #endif
 352                         while (len > 0) {
 353                                 if (len < 8) {
 354                                         reg_w_buf(gspca_dev,
 355                                                 index, seq, len);
 356                                         seq += len;
 357                                         break;
 358                                 }
 359                                 reg_w_buf(gspca_dev, index, seq, 8);
 360                                 seq += 8;
 361                                 index += 8;
 362                                 len -= 8;
 363                         }
 364                 }
 365         }
 366         /* not reached */
 367 }
 368
 369 /* this function is called at probe time for pac7302 */
 370 static int sd_config(struct gspca_dev *gspca_dev,
 371                         const struct usb_device_id *id)
 372 {
 373         struct sd *sd = (struct sd *) gspca_dev;
 374         struct cam *cam;
 375
 376         cam = &gspca_dev->cam;
 377
 378         cam->cam_mode = vga_mode;       /* only 640x480 */
 379         cam->nmodes = ARRAY_SIZE(vga_mode);
 380
 381         sd->flags = id->driver_info;
 382         return 0;
 383 }
 384
 385 static void setbrightcont(struct gspca_dev *gspca_dev)
 386 {
 387         struct sd *sd = (struct sd *) gspca_dev;
 388         int i, v;
 389         static const u8 max[10] =
 390                 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
 391                  0xd4, 0xec};
 392         static const u8 delta[10] =
 393                 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
 394                  0x11, 0x0b};
 395
 396         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 397         for (i = 0; i < 10; i++) {
 398                 v = max[i];
 399                 v += (sd->brightness->val - sd->brightness->maximum)
 400                         * 150 / sd->brightness->maximum; /* 200 ? */
 401                 v -= delta[i] * sd->contrast->val / sd->contrast->maximum;
 402                 if (v < 0)
 403                         v = 0;
 404                 else if (v > 0xff)
 405                         v = 0xff;
 406                 reg_w(gspca_dev, 0xa2 + i, v);
 407         }
 408         reg_w(gspca_dev, 0xdc, 0x01);
 409 }
 410
 411 static void setcolors(struct gspca_dev *gspca_dev)
 412 {
 413         struct sd *sd = (struct sd *) gspca_dev;
 414         int i, v;
 415         static const int a[9] =
 416                 {217, -212, 0, -101, 170, -67, -38, -315, 355};
 417         static const int b[9] =
 418                 {19, 106, 0, 19, 106, 1, 19, 106, 1};
 419
 420         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 421         reg_w(gspca_dev, 0x11, 0x01);
 422         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 423         for (i = 0; i < 9; i++) {
 424                 v = a[i] * sd->saturation->val / sd->saturation->maximum;
 425                 v += b[i];
 426                 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
 427                 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
 428         }
 429         reg_w(gspca_dev, 0xdc, 0x01);
 430 }
 431
 432 static void setwhitebalance(struct gspca_dev *gspca_dev)
 433 {
 434         struct sd *sd = (struct sd *) gspca_dev;
 435
 436         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 437         reg_w(gspca_dev, 0xc6, sd->white_balance->val);
 438
 439         reg_w(gspca_dev, 0xdc, 0x01);
 440 }
 441
 442 static void setredbalance(struct gspca_dev *gspca_dev)
 443 {
 444         struct sd *sd = (struct sd *) gspca_dev;
 445
 446         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 447         reg_w(gspca_dev, 0xc5, sd->red_balance->val);
 448
 449         reg_w(gspca_dev, 0xdc, 0x01);
 450 }
 451
 452 static void setbluebalance(struct gspca_dev *gspca_dev)
 453 {
 454         struct sd *sd = (struct sd *) gspca_dev;
 455
 456         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 457         reg_w(gspca_dev, 0xc7, sd->blue_balance->val);
 458
 459         reg_w(gspca_dev, 0xdc, 0x01);
 460 }
 461
 462 static void setgain(struct gspca_dev *gspca_dev)
 463 {
 464         u8 reg10, reg12;
 465
 466         if (gspca_dev->gain->val < 32) {
 467                 reg10 = gspca_dev->gain->val;
 468                 reg12 = 0;
 469         } else {
 470                 reg10 = 31;
 471                 reg12 = gspca_dev->gain->val - 31;
 472         }
 473
 474         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 475         reg_w(gspca_dev, 0x10, reg10);
 476         reg_w(gspca_dev, 0x12, reg12);
 477
 478         /* load registers to sensor (Bit 0, auto clear) */
 479         reg_w(gspca_dev, 0x11, 0x01);
 480 }
 481
 482 static void setexposure(struct gspca_dev *gspca_dev)
 483 {
 484         u8 clockdiv;
 485         u16 exposure;
 486
 487         /*
 488          * Register 2 of frame 3 contains the clock divider configuring the
 489          * no fps according to the formula: 90 / reg. sd->exposure is the
 490          * desired exposure time in 0.5 ms.
 491          */
 492         clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000;
 493
 494         /*
 495          * Note clockdiv = 3 also works, but when running at 30 fps, depending
 496          * on the scene being recorded, the camera switches to another
 497          * quantization table for certain JPEG blocks, and we don't know how
 498          * to decompress these blocks. So we cap the framerate at 15 fps.
 499          */
 500         if (clockdiv < 6)
 501                 clockdiv = 6;
 502         else if (clockdiv > 63)
 503                 clockdiv = 63;
 504
 505         /*
 506          * Register 2 MUST be a multiple of 3, except when between 6 and 12?
 507          * Always round up, otherwise we cannot get the desired frametime
 508          * using the partial frame time exposure control.
 509          */
 510         if (clockdiv < 6 || clockdiv > 12)
 511                 clockdiv = ((clockdiv + 2) / 3) * 3;
 512
 513         /*
 514          * frame exposure time in ms = 1000 * clockdiv / 90    ->
 515          * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90)
 516          */
 517         exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv);
 518         /* 0 = use full frametime, 448 = no exposure, reverse it */
 519         exposure = 448 - exposure;
 520
 521         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 522         reg_w(gspca_dev, 0x02, clockdiv);
 523         reg_w(gspca_dev, 0x0e, exposure & 0xff);
 524         reg_w(gspca_dev, 0x0f, exposure >> 8);
 525
 526         /* load registers to sensor (Bit 0, auto clear) */
 527         reg_w(gspca_dev, 0x11, 0x01);
 528 }
 529
 530 static void sethvflip(struct gspca_dev *gspca_dev)
 531 {
 532         struct sd *sd = (struct sd *) gspca_dev;
 533         u8 data, hflip, vflip;
 534
 535         hflip = sd->hflip->val;
 536         if (sd->flags & FL_HFLIP)
 537                 hflip = !hflip;
 538         vflip = sd->vflip->val;
 539         if (sd->flags & FL_VFLIP)
 540                 vflip = !vflip;
 541
 542         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 543         data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
 544         reg_w(gspca_dev, 0x21, data);
 545
 546         /* load registers to sensor (Bit 0, auto clear) */
 547         reg_w(gspca_dev, 0x11, 0x01);
 548 }
 549
 550 static void setsharpness(struct gspca_dev *gspca_dev)
 551 {
 552         struct sd *sd = (struct sd *) gspca_dev;
 553
 554         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 555         reg_w(gspca_dev, 0xb6, sd->sharpness->val);
 556
 557         reg_w(gspca_dev, 0xdc, 0x01);
 558 }
 559
 560 /* this function is called at probe and resume time for pac7302 */
 561 static int sd_init(struct gspca_dev *gspca_dev)
 562 {
 563         reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
 564         return gspca_dev->usb_err;
 565 }
 566
 567 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 568 {
 569         struct gspca_dev *gspca_dev =
 570                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 571         struct sd *sd = (struct sd *)gspca_dev;
 572
 573         gspca_dev->usb_err = 0;
 574
 575         if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
 576                 /* when switching to autogain set defaults to make sure
 577                    we are on a valid point of the autogain gain /
 578                    exposure knee graph, and give this change time to
 579                    take effect before doing autogain. */
 580                 gspca_dev->exposure->val    = PAC7302_EXPOSURE_DEFAULT;
 581                 gspca_dev->gain->val        = PAC7302_GAIN_DEFAULT;
 582                 sd->autogain_ignore_frames  = PAC_AUTOGAIN_IGNORE_FRAMES;
 583         }
 584
 585         if (!gspca_dev->streaming)
 586                 return 0;
 587
 588         switch (ctrl->id) {
 589         case V4L2_CID_BRIGHTNESS:
 590                 setbrightcont(gspca_dev);
 591                 break;
 592         case V4L2_CID_SATURATION:
 593                 setcolors(gspca_dev);
 594                 break;
 595         case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
 596                 setwhitebalance(gspca_dev);
 597                 break;
 598         case V4L2_CID_RED_BALANCE:
 599                 setredbalance(gspca_dev);
 600                 break;
 601         case V4L2_CID_BLUE_BALANCE:
 602                 setbluebalance(gspca_dev);
 603                 break;
 604         case V4L2_CID_AUTOGAIN:
 605                 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
 606                         setexposure(gspca_dev);
 607                 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
 608                         setgain(gspca_dev);
 609                 break;
 610         case V4L2_CID_HFLIP:
 611                 sethvflip(gspca_dev);
 612                 break;
 613         case V4L2_CID_SHARPNESS:
 614                 setsharpness(gspca_dev);
 615                 break;
 616         default:
 617                 return -EINVAL;
 618         }
 619         return gspca_dev->usb_err;
 620 }
 621
 622 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 623         .s_ctrl = sd_s_ctrl,
 624 };
 625
 626 /* this function is called at probe time */
 627 static int sd_init_controls(struct gspca_dev *gspca_dev)
 628 {
 629         struct sd *sd = (struct sd *) gspca_dev;
 630         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 631
 632         gspca_dev->vdev.ctrl_handler = hdl;
 633         v4l2_ctrl_handler_init(hdl, 12);
 634
 635         sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 636                                         V4L2_CID_BRIGHTNESS, 0, 32, 1, 16);
 637         sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 638                                         V4L2_CID_CONTRAST, 0, 255, 1, 127);
 639
 640         sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 641                                         V4L2_CID_SATURATION, 0, 255, 1, 127);
 642         sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 643                                         V4L2_CID_WHITE_BALANCE_TEMPERATURE,
 644                                         0, 255, 1, 55);
 645         sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 646                                         V4L2_CID_RED_BALANCE, 0, 3, 1, 1);
 647         sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 648                                         V4L2_CID_BLUE_BALANCE, 0, 3, 1, 1);
 649
 650         gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 651                                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
 652         gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 653                                         V4L2_CID_EXPOSURE, 0, 1023, 1,
 654                                         PAC7302_EXPOSURE_DEFAULT);
 655         gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 656                                         V4L2_CID_GAIN, 0, 62, 1,
 657                                         PAC7302_GAIN_DEFAULT);
 658
 659         sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 660                 V4L2_CID_HFLIP, 0, 1, 1, 0);
 661         sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 662                 V4L2_CID_VFLIP, 0, 1, 1, 0);
 663
 664         sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 665                                         V4L2_CID_SHARPNESS, 0, 15, 1, 8);
 666
 667         if (hdl->error) {
 668                 pr_err("Could not initialize controls\n");
 669                 return hdl->error;
 670         }
 671
 672         v4l2_ctrl_cluster(2, &sd->brightness);
 673         v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
 674         v4l2_ctrl_cluster(2, &sd->hflip);
 675         return 0;
 676 }
 677
 678 /* -- start the camera -- */
 679 static int sd_start(struct gspca_dev *gspca_dev)
 680 {
 681         struct sd *sd = (struct sd *) gspca_dev;
 682
 683         reg_w_var(gspca_dev, start_7302,
 684                 page3_7302, sizeof(page3_7302));
 685
 686         sd->sof_read = 0;
 687         sd->autogain_ignore_frames = 0;
 688         atomic_set(&sd->avg_lum, 270 + sd->brightness->val);
 689
 690         /* start stream */
 691         reg_w(gspca_dev, 0xff, 0x01);
 692         reg_w(gspca_dev, 0x78, 0x01);
 693
 694         return gspca_dev->usb_err;
 695 }
 696
 697 static void sd_stopN(struct gspca_dev *gspca_dev)
 698 {
 699
 700         /* stop stream */
 701         reg_w(gspca_dev, 0xff, 0x01);
 702         reg_w(gspca_dev, 0x78, 0x00);
 703 }
 704
 705 /* called on streamoff with alt 0 and on disconnect for pac7302 */
 706 static void sd_stop0(struct gspca_dev *gspca_dev)
 707 {
 708         if (!gspca_dev->present)
 709                 return;
 710         reg_w(gspca_dev, 0xff, 0x01);
 711         reg_w(gspca_dev, 0x78, 0x40);
 712 }
 713
 714 static void do_autogain(struct gspca_dev *gspca_dev)
 715 {
 716         struct sd *sd = (struct sd *) gspca_dev;
 717         int avg_lum = atomic_read(&sd->avg_lum);
 718         int desired_lum;
 719         const int deadzone = 30;
 720
 721         if (sd->autogain_ignore_frames < 0)
 722                 return;
 723
 724         if (sd->autogain_ignore_frames > 0) {
 725                 sd->autogain_ignore_frames--;
 726         } else {
 727                 desired_lum = 270 + sd->brightness->val;
 728
 729                 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum,
 730                                         deadzone, PAC7302_GAIN_KNEE,
 731                                         PAC7302_EXPOSURE_KNEE))
 732                         sd->autogain_ignore_frames =
 733                                                 PAC_AUTOGAIN_IGNORE_FRAMES;
 734         }
 735 }
 736
 737 /* JPEG header */
 738 static const u8 jpeg_header[] = {
 739         0xff, 0xd8,     /* SOI: Start of Image */
 740
 741         0xff, 0xc0,     /* SOF0: Start of Frame (Baseline DCT) */
 742         0x00, 0x11,     /* length = 17 bytes (including this length field) */
 743         0x08,           /* Precision: 8 */
 744         0x02, 0x80,     /* height = 640 (image rotated) */
 745         0x01, 0xe0,     /* width = 480 */
 746         0x03,           /* Number of image components: 3 */
 747         0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
 748         0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
 749         0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
 750
 751         0xff, 0xda,     /* SOS: Start Of Scan */
 752         0x00, 0x0c,     /* length = 12 bytes (including this length field) */
 753         0x03,           /* number of components: 3 */
 754         0x01, 0x00,     /* selector 1, table 0x00 */
 755         0x02, 0x11,     /* selector 2, table 0x11 */
 756         0x03, 0x11,     /* selector 3, table 0x11 */
 757         0x00, 0x3f,     /* Spectral selection: 0 .. 63 */
 758         0x00            /* Successive approximation: 0 */
 759 };
 760
 761 /* this function is run at interrupt level */
 762 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 763                         u8 *data,                       /* isoc packet */
 764                         int len)                        /* iso packet length */
 765 {
 766         struct sd *sd = (struct sd *) gspca_dev;
 767         u8 *image;
 768         u8 *sof;
 769
 770         sof = pac_find_sof(&sd->sof_read, data, len);
 771         if (sof) {
 772                 int n, lum_offset, footer_length;
 773
 774                 /*
 775                  * 6 bytes after the FF D9 EOF marker a number of lumination
 776                  * bytes are send corresponding to different parts of the
 777                  * image, the 14th and 15th byte after the EOF seem to
 778                  * correspond to the center of the image.
 779                  */
 780                 lum_offset = 61 + sizeof pac_sof_marker;
 781                 footer_length = 74;
 782
 783                 /* Finish decoding current frame */
 784                 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
 785                 if (n < 0) {
 786                         gspca_dev->image_len += n;
 787                         n = 0;
 788                 } else {
 789                         gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
 790                 }
 791
 792                 image = gspca_dev->image;
 793                 if (image != NULL
 794                  && image[gspca_dev->image_len - 2] == 0xff
 795                  && image[gspca_dev->image_len - 1] == 0xd9)
 796                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 797
 798                 n = sof - data;
 799                 len -= n;
 800                 data = sof;
 801
 802                 /* Get average lumination */
 803                 if (gspca_dev->last_packet_type == LAST_PACKET &&
 804                                 n >= lum_offset)
 805                         atomic_set(&sd->avg_lum, data[-lum_offset] +
 806                                                 data[-lum_offset + 1]);
 807
 808                 /* Start the new frame with the jpeg header */
 809                 /* The PAC7302 has the image rotated 90 degrees */
 810                 gspca_frame_add(gspca_dev, FIRST_PACKET,
 811                                 jpeg_header, sizeof jpeg_header);
 812         }
 813         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 814 }
 815
 816 #ifdef CONFIG_VIDEO_ADV_DEBUG
 817 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
 818                         struct v4l2_dbg_register *reg)
 819 {
 820         u8 index;
 821         u8 value;
 822
 823         /*
 824          * reg->reg: bit0..15: reserved for register index (wIndex is 16bit
 825          *                     long on the USB bus)
 826          */
 827         if (reg->match.type == V4L2_CHIP_MATCH_HOST &&
 828             reg->match.addr == 0 &&
 829             (reg->reg < 0x000000ff) &&
 830             (reg->val <= 0x000000ff)
 831         ) {
 832                 /* Currently writing to page 0 is only supported. */
 833                 /* reg_w() only supports 8bit index */
 834                 index = reg->reg;
 835                 value = reg->val;
 836
 837                 /*
 838                  * Note that there shall be no access to other page
 839                  * by any other function between the page switch and
 840                  * the actual register write.
 841                  */
 842                 reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 843                 reg_w(gspca_dev, index, value);
 844
 845                 reg_w(gspca_dev, 0xdc, 0x01);
 846         }
 847         return gspca_dev->usb_err;
 848 }
 849
 850 static int sd_chip_ident(struct gspca_dev *gspca_dev,
 851                         struct v4l2_dbg_chip_ident *chip)
 852 {
 853         int ret = -EINVAL;
 854
 855         if (chip->match.type == V4L2_CHIP_MATCH_HOST &&
 856             chip->match.addr == 0) {
 857                 chip->revision = 0;
 858                 chip->ident = V4L2_IDENT_UNKNOWN;
 859                 ret = 0;
 860         }
 861         return ret;
 862 }
 863 #endif
 864
 865 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 866 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
 867                         u8 *data,               /* interrupt packet data */
 868                         int len)                /* interrput packet length */
 869 {
 870         int ret = -EINVAL;
 871         u8 data0, data1;
 872
 873         if (len == 2) {
 874                 data0 = data[0];
 875                 data1 = data[1];
 876                 if ((data0 == 0x00 && data1 == 0x11) ||
 877                     (data0 == 0x22 && data1 == 0x33) ||
 878                     (data0 == 0x44 && data1 == 0x55) ||
 879                     (data0 == 0x66 && data1 == 0x77) ||
 880                     (data0 == 0x88 && data1 == 0x99) ||
 881                     (data0 == 0xaa && data1 == 0xbb) ||
 882                     (data0 == 0xcc && data1 == 0xdd) ||
 883                     (data0 == 0xee && data1 == 0xff)) {
 884                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
 885                         input_sync(gspca_dev->input_dev);
 886                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
 887                         input_sync(gspca_dev->input_dev);
 888                         ret = 0;
 889                 }
 890         }
 891
 892         return ret;
 893 }
 894 #endif
 895
 896 /* sub-driver description for pac7302 */
 897 static const struct sd_desc sd_desc = {
 898         .name = KBUILD_MODNAME,
 899         .config = sd_config,
 900         .init = sd_init,
 901         .init_controls = sd_init_controls,
 902         .start = sd_start,
 903         .stopN = sd_stopN,
 904         .stop0 = sd_stop0,
 905         .pkt_scan = sd_pkt_scan,
 906         .dq_callback = do_autogain,
 907 #ifdef CONFIG_VIDEO_ADV_DEBUG
 908         .set_register = sd_dbg_s_register,
 909         .get_chip_ident = sd_chip_ident,
 910 #endif
 911 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
 912         .int_pkt_scan = sd_int_pkt_scan,
 913 #endif
 914 };
 915
 916 /* -- module initialisation -- */
 917 static const struct usb_device_id device_table[] = {
 918         {USB_DEVICE(0x06f8, 0x3009)},
 919         {USB_DEVICE(0x06f8, 0x301b)},
 920         {USB_DEVICE(0x093a, 0x2620)},
 921         {USB_DEVICE(0x093a, 0x2621)},
 922         {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
 923         {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
 924         {USB_DEVICE(0x093a, 0x2625)},
 925         {USB_DEVICE(0x093a, 0x2626)},
 926         {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP},
 927         {USB_DEVICE(0x093a, 0x2628)},
 928         {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
 929         {USB_DEVICE(0x093a, 0x262a)},
 930         {USB_DEVICE(0x093a, 0x262c)},
 931         {USB_DEVICE(0x145f, 0x013c)},
 932         {USB_DEVICE(0x1ae7, 0x2001)}, /* SpeedLink Snappy Mic SL-6825-SBK */
 933         {}
 934 };
 935 MODULE_DEVICE_TABLE(usb, device_table);
 936
 937 /* -- device connect -- */
 938 static int sd_probe(struct usb_interface *intf,
 939                         const struct usb_device_id *id)
 940 {
 941         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 942                                 THIS_MODULE);
 943 }
 944
 945 static struct usb_driver sd_driver = {
 946         .name = KBUILD_MODNAME,
 947         .id_table = device_table,
 948         .probe = sd_probe,
 949         .disconnect = gspca_disconnect,
 950 #ifdef CONFIG_PM
 951         .suspend = gspca_suspend,
 952         .resume = gspca_resume,
 953         .reset_resume = gspca_resume,
 954 #endif
 955 };
 956
 957 module_usb_driver(sd_driver);