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