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  * 0x01         Red balance control
  33  * 0x02         Green balance control
  34  * 0x03         Blue balance control
  35  *                   The Windows driver uses a quadratic approach to map
  36  *                   the settable values (0-200) on register values:
  37  *                   min=0x20, default=0x40, max=0x80
  38  * 0x0f-0x20    Color and saturation control
  39  * 0xa2-0xab    Brightness, contrast and gamma control
  40  * 0xb6         Sharpness control (bits 0-4)
  41  *
  42  * Register page 1:
  43  *
  44  * Address      Description
  45  * 0x78         Global control, bit 6 controls the LED (inverted)
  46  * 0x80         Compression balance, 2 interesting settings:
  47  *              0x0f Default
  48  *              0x50 Values >= this switch the camera to a lower compression,
  49  *                   using the same table for both luminance and chrominance.
  50  *                   This gives a sharper picture. Only usable when running
  51  *                   at < 15 fps! Note currently the driver does not use this
  52  *                   as the quality gain is small and the generated JPG-s are
  53  *                   only understood by v4l-utils >= 0.8.9
  54  *
  55  * Register page 3:
  56  *
  57  * Address      Description
  58  * 0x02         Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on
  59  *              the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
  60  * 0x03         Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps
  61  * 0x04         Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps,
  62  *              63 -> ~27 fps, the 2 msb's must always be 1 !!
  63  * 0x05         Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0:
  64  *              1 -> ~30 fps, 2 -> ~20 fps
  65  * 0x0e         Exposure bits 0-7, 0-448, 0 = use full frame time
  66  * 0x0f         Exposure bit 8, 0-448, 448 = no exposure at all
  67  * 0x10         Gain 0-31
  68  * 0x12         Another gain 0-31, unlike 0x10 this one seems to start with an
  69  *              amplification value of 1 rather then 0 at its lowest setting
  70  * 0x21         Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
  71  * 0x80         Another framerate control, best left at 1, moving it from 1 to
  72  *              2 causes the framerate to become 3/4th of what it was, and
  73  *              also seems to cause pixel averaging, resulting in an effective
  74  *              resolution of 320x240 and thus a much blockier image
  75  *
  76  * The registers are accessed in the following functions:
  77  *
  78  * Page | Register   | Function
  79  * -----+------------+---------------------------------------------------
  80  *  0   | 0x01       | setredbalance()
  81  *  0   | 0x03       | setbluebalance()
  82  *  0   | 0x0f..0x20 | setcolors()
  83  *  0   | 0xa2..0xab | setbrightcont()
  84  *  0   | 0xb6       | setsharpness()
  85  *  0   | 0xc6       | setwhitebalance()
  86  *  0   | 0xdc       | setbrightcont(), setcolors()
  87  *  3   | 0x02       | setexposure()
  88  *  3   | 0x10, 0x12 | setgain()
  89  *  3   | 0x11       | setcolors(), setgain(), setexposure(), sethvflip()
  90  *  3   | 0x21       | sethvflip()
  91  */
  92
  93 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  94
  95 #include <linux/input.h>
  96 #include "gspca.h"
  97 /* Include pac common sof detection functions */
  98 #include "pac_common.h"
  99
 100 #define PAC7302_RGB_BALANCE_MIN           0
 101 #define PAC7302_RGB_BALANCE_MAX         200
 102 #define PAC7302_RGB_BALANCE_DEFAULT     100
 103 #define PAC7302_GAIN_DEFAULT             15
 104 #define PAC7302_GAIN_KNEE                42
 105 #define PAC7302_EXPOSURE_DEFAULT         66 /* 33 ms / 30 fps */
 106 #define PAC7302_EXPOSURE_KNEE           133 /* 66 ms / 15 fps */
 107
 108 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, 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                         if (len > USB_BUF_SZ) {
 346                                 PERR("Incorrect variable sequence");
 347                                 return;
 348                         }
 349                         while (len > 0) {
 350                                 if (len < 8) {
 351                                         reg_w_buf(gspca_dev,
 352                                                 index, seq, len);
 353                                         seq += len;
 354                                         break;
 355                                 }
 356                                 reg_w_buf(gspca_dev, index, seq, 8);
 357                                 seq += 8;
 358                                 index += 8;
 359                                 len -= 8;
 360                         }
 361                 }
 362         }
 363         /* not reached */
 364 }
 365
 366 /* this function is called at probe time for pac7302 */
 367 static int sd_config(struct gspca_dev *gspca_dev,
 368                         const struct usb_device_id *id)
 369 {
 370         struct sd *sd = (struct sd *) gspca_dev;
 371         struct cam *cam;
 372
 373         cam = &gspca_dev->cam;
 374
 375         cam->cam_mode = vga_mode;       /* only 640x480 */
 376         cam->nmodes = ARRAY_SIZE(vga_mode);
 377
 378         sd->flags = id->driver_info;
 379         return 0;
 380 }
 381
 382 static void setbrightcont(struct gspca_dev *gspca_dev)
 383 {
 384         struct sd *sd = (struct sd *) gspca_dev;
 385         int i, v;
 386         static const u8 max[10] =
 387                 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
 388                  0xd4, 0xec};
 389         static const u8 delta[10] =
 390                 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
 391                  0x11, 0x0b};
 392
 393         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 394         for (i = 0; i < 10; i++) {
 395                 v = max[i];
 396                 v += (sd->brightness->val - (s32)sd->brightness->maximum)
 397                         * 150 / (s32)sd->brightness->maximum; /* 200 ? */
 398                 v -= delta[i] * sd->contrast->val / (s32)sd->contrast->maximum;
 399                 if (v < 0)
 400                         v = 0;
 401                 else if (v > 0xff)
 402                         v = 0xff;
 403                 reg_w(gspca_dev, 0xa2 + i, v);
 404         }
 405         reg_w(gspca_dev, 0xdc, 0x01);
 406 }
 407
 408 static void setcolors(struct gspca_dev *gspca_dev)
 409 {
 410         struct sd *sd = (struct sd *) gspca_dev;
 411         int i, v;
 412         static const int a[9] =
 413                 {217, -212, 0, -101, 170, -67, -38, -315, 355};
 414         static const int b[9] =
 415                 {19, 106, 0, 19, 106, 1, 19, 106, 1};
 416
 417         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 418         reg_w(gspca_dev, 0x11, 0x01);
 419         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 420         for (i = 0; i < 9; i++) {
 421                 v = a[i] * sd->saturation->val / (s32)sd->saturation->maximum;
 422                 v += b[i];
 423                 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
 424                 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
 425         }
 426         reg_w(gspca_dev, 0xdc, 0x01);
 427 }
 428
 429 static void setwhitebalance(struct gspca_dev *gspca_dev)
 430 {
 431         struct sd *sd = (struct sd *) gspca_dev;
 432
 433         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 434         reg_w(gspca_dev, 0xc6, sd->white_balance->val);
 435
 436         reg_w(gspca_dev, 0xdc, 0x01);
 437 }
 438
 439 static u8 rgbbalance_ctrl_to_reg_value(s32 rgb_ctrl_val)
 440 {
 441         const unsigned int k = 1000;    /* precision factor */
 442         unsigned int norm;
 443
 444         /* Normed value [0...k] */
 445         norm = k * (rgb_ctrl_val - PAC7302_RGB_BALANCE_MIN)
 446                     / (PAC7302_RGB_BALANCE_MAX - PAC7302_RGB_BALANCE_MIN);
 447         /* Qudratic apporach improves control at small (register) values: */
 448         return 64 * norm * norm / (k*k)  +  32 * norm / k  +  32;
 449         /* Y = 64*X*X + 32*X + 32
 450          * => register values 0x20-0x80; Windows driver uses these limits */
 451
 452         /* NOTE: for full value range (0x00-0xff) use
 453          *         Y = 254*X*X + X
 454          *         => 254 * norm * norm / (k*k)  +  1 * norm / k        */
 455 }
 456
 457 static void setredbalance(struct gspca_dev *gspca_dev)
 458 {
 459         struct sd *sd = (struct sd *) gspca_dev;
 460
 461         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 462         reg_w(gspca_dev, 0x01,
 463               rgbbalance_ctrl_to_reg_value(sd->red_balance->val));
 464
 465         reg_w(gspca_dev, 0xdc, 0x01);
 466 }
 467
 468 static void setbluebalance(struct gspca_dev *gspca_dev)
 469 {
 470         struct sd *sd = (struct sd *) gspca_dev;
 471
 472         reg_w(gspca_dev, 0xff, 0x00);                   /* page 0 */
 473         reg_w(gspca_dev, 0x03,
 474               rgbbalance_ctrl_to_reg_value(sd->blue_balance->val));
 475
 476         reg_w(gspca_dev, 0xdc, 0x01);
 477 }
 478
 479 static void setgain(struct gspca_dev *gspca_dev)
 480 {
 481         u8 reg10, reg12;
 482
 483         if (gspca_dev->gain->val < 32) {
 484                 reg10 = gspca_dev->gain->val;
 485                 reg12 = 0;
 486         } else {
 487                 reg10 = 31;
 488                 reg12 = gspca_dev->gain->val - 31;
 489         }
 490
 491         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 492         reg_w(gspca_dev, 0x10, reg10);
 493         reg_w(gspca_dev, 0x12, reg12);
 494
 495         /* load registers to sensor (Bit 0, auto clear) */
 496         reg_w(gspca_dev, 0x11, 0x01);
 497 }
 498
 499 static void setexposure(struct gspca_dev *gspca_dev)
 500 {
 501         u8 clockdiv;
 502         u16 exposure;
 503
 504         /*
 505          * Register 2 of frame 3 contains the clock divider configuring the
 506          * no fps according to the formula: 90 / reg. sd->exposure is the
 507          * desired exposure time in 0.5 ms.
 508          */
 509         clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000;
 510
 511         /*
 512          * Note clockdiv = 3 also works, but when running at 30 fps, depending
 513          * on the scene being recorded, the camera switches to another
 514          * quantization table for certain JPEG blocks, and we don't know how
 515          * to decompress these blocks. So we cap the framerate at 15 fps.
 516          */
 517         if (clockdiv < 6)
 518                 clockdiv = 6;
 519         else if (clockdiv > 63)
 520                 clockdiv = 63;
 521
 522         /*
 523          * Register 2 MUST be a multiple of 3, except when between 6 and 12?
 524          * Always round up, otherwise we cannot get the desired frametime
 525          * using the partial frame time exposure control.
 526          */
 527         if (clockdiv < 6 || clockdiv > 12)
 528                 clockdiv = ((clockdiv + 2) / 3) * 3;
 529
 530         /*
 531          * frame exposure time in ms = 1000 * clockdiv / 90    ->
 532          * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90)
 533          */
 534         exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv);
 535         /* 0 = use full frametime, 448 = no exposure, reverse it */
 536         exposure = 448 - exposure;
 537
 538         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 539         reg_w(gspca_dev, 0x02, clockdiv);
 540         reg_w(gspca_dev, 0x0e, exposure & 0xff);
 541         reg_w(gspca_dev, 0x0f, exposure >> 8);
 542
 543         /* load registers to sensor (Bit 0, auto clear) */
 544         reg_w(gspca_dev, 0x11, 0x01);
 545 }
 546
 547 static void sethvflip(struct gspca_dev *gspca_dev)
 548 {
 549         struct sd *sd = (struct sd *) gspca_dev;
 550         u8 data, hflip, vflip;
 551
 552         hflip = sd->hflip->val;
 553         if (sd->flags & FL_HFLIP)
 554                 hflip = !hflip;
 555         vflip = sd->vflip->val;
 556         if (sd->flags & FL_VFLIP)
 557                 vflip = !vflip;
 558
 559         reg_w(gspca_dev, 0xff, 0x03);                   /* page 3 */
 560         data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
 561         reg_w(gspca_dev, 0x21, data);
 562
 563         /* load registers to sensor (Bit 0, auto clear) */
 564         reg_w(gspca_dev, 0x11, 0x01);
 565 }
 566
 567 static void setsharpness(struct gspca_dev *gspca_dev)
 568 {
 569         struct sd *sd = (struct sd *) gspca_dev;
 570
 571         reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 572         reg_w(gspca_dev, 0xb6, sd->sharpness->val);
 573
 574         reg_w(gspca_dev, 0xdc, 0x01);
 575 }
 576
 577 /* this function is called at probe and resume time for pac7302 */
 578 static int sd_init(struct gspca_dev *gspca_dev)
 579 {
 580         reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
 581         return gspca_dev->usb_err;
 582 }
 583
 584 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 585 {
 586         struct gspca_dev *gspca_dev =
 587                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 588         struct sd *sd = (struct sd *)gspca_dev;
 589
 590         gspca_dev->usb_err = 0;
 591
 592         if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
 593                 /* when switching to autogain set defaults to make sure
 594                    we are on a valid point of the autogain gain /
 595                    exposure knee graph, and give this change time to
 596                    take effect before doing autogain. */
 597                 gspca_dev->exposure->val    = PAC7302_EXPOSURE_DEFAULT;
 598                 gspca_dev->gain->val        = PAC7302_GAIN_DEFAULT;
 599                 sd->autogain_ignore_frames  = PAC_AUTOGAIN_IGNORE_FRAMES;
 600         }
 601
 602         if (!gspca_dev->streaming)
 603                 return 0;
 604
 605         switch (ctrl->id) {
 606         case V4L2_CID_BRIGHTNESS:
 607                 setbrightcont(gspca_dev);
 608                 break;
 609         case V4L2_CID_SATURATION:
 610                 setcolors(gspca_dev);
 611                 break;
 612         case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
 613                 setwhitebalance(gspca_dev);
 614                 break;
 615         case V4L2_CID_RED_BALANCE:
 616                 setredbalance(gspca_dev);
 617                 break;
 618         case V4L2_CID_BLUE_BALANCE:
 619                 setbluebalance(gspca_dev);
 620                 break;
 621         case V4L2_CID_AUTOGAIN:
 622                 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
 623                         setexposure(gspca_dev);
 624                 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
 625                         setgain(gspca_dev);
 626                 break;
 627         case V4L2_CID_HFLIP:
 628                 sethvflip(gspca_dev);
 629                 break;
 630         case V4L2_CID_SHARPNESS:
 631                 setsharpness(gspca_dev);
 632                 break;
 633         default:
 634                 return -EINVAL;
 635         }
 636         return gspca_dev->usb_err;
 637 }
 638
 639 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 640         .s_ctrl = sd_s_ctrl,
 641 };
 642
 643 /* this function is called at probe time */
 644 static int sd_init_controls(struct gspca_dev *gspca_dev)
 645 {
 646         struct sd *sd = (struct sd *) gspca_dev;
 647         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 648
 649         gspca_dev->vdev.ctrl_handler = hdl;
 650         v4l2_ctrl_handler_init(hdl, 12);
 651
 652         sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 653                                         V4L2_CID_BRIGHTNESS, 0, 32, 1, 16);
 654         sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 655                                         V4L2_CID_CONTRAST, 0, 255, 1, 127);
 656
 657         sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 658                                         V4L2_CID_SATURATION, 0, 255, 1, 127);
 659         sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 660                                         V4L2_CID_WHITE_BALANCE_TEMPERATURE,
 661                                         0, 255, 1, 55);
 662         sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 663                                         V4L2_CID_RED_BALANCE,
 664                                         PAC7302_RGB_BALANCE_MIN,
 665                                         PAC7302_RGB_BALANCE_MAX,
 666                                         1, PAC7302_RGB_BALANCE_DEFAULT);
 667         sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 668                                         V4L2_CID_BLUE_BALANCE,
 669                                         PAC7302_RGB_BALANCE_MIN,
 670                                         PAC7302_RGB_BALANCE_MAX,
 671                                         1, PAC7302_RGB_BALANCE_DEFAULT);
 672
 673         gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 674                                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
 675         gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 676                                         V4L2_CID_EXPOSURE, 0, 1023, 1,
 677                                         PAC7302_EXPOSURE_DEFAULT);
 678         gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 679                                         V4L2_CID_GAIN, 0, 62, 1,
 680                                         PAC7302_GAIN_DEFAULT);
 681
 682         sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 683                 V4L2_CID_HFLIP, 0, 1, 1, 0);
 684         sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 685                 V4L2_CID_VFLIP, 0, 1, 1, 0);
 686
 687         sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 688                                         V4L2_CID_SHARPNESS, 0, 15, 1, 8);
 689
 690         if (hdl->error) {
 691                 pr_err("Could not initialize controls\n");
 692                 return hdl->error;
 693         }
 694
 695         v4l2_ctrl_cluster(2, &sd->brightness);
 696         v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
 697         v4l2_ctrl_cluster(2, &sd->hflip);
 698         return 0;
 699 }
 700
 701 /* -- start the camera -- */
 702 static int sd_start(struct gspca_dev *gspca_dev)
 703 {
 704         struct sd *sd = (struct sd *) gspca_dev;
 705
 706         reg_w_var(gspca_dev, start_7302,
 707                 page3_7302, sizeof(page3_7302));
 708
 709         sd->sof_read = 0;
 710         sd->autogain_ignore_frames = 0;
 711         atomic_set(&sd->avg_lum, 270 + sd->brightness->val);
 712
 713         /* start stream */
 714         reg_w(gspca_dev, 0xff, 0x01);
 715         reg_w(gspca_dev, 0x78, 0x01);
 716
 717         return gspca_dev->usb_err;
 718 }
 719
 720 static void sd_stopN(struct gspca_dev *gspca_dev)
 721 {
 722
 723         /* stop stream */
 724         reg_w(gspca_dev, 0xff, 0x01);
 725         reg_w(gspca_dev, 0x78, 0x00);
 726 }
 727
 728 /* called on streamoff with alt 0 and on disconnect for pac7302 */
 729 static void sd_stop0(struct gspca_dev *gspca_dev)
 730 {
 731         if (!gspca_dev->present)
 732                 return;
 733         reg_w(gspca_dev, 0xff, 0x01);
 734         reg_w(gspca_dev, 0x78, 0x40);
 735 }
 736
 737 static void do_autogain(struct gspca_dev *gspca_dev)
 738 {
 739         struct sd *sd = (struct sd *) gspca_dev;
 740         int avg_lum = atomic_read(&sd->avg_lum);
 741         int desired_lum;
 742         const int deadzone = 30;
 743
 744         if (sd->autogain_ignore_frames < 0)
 745                 return;
 746
 747         if (sd->autogain_ignore_frames > 0) {
 748                 sd->autogain_ignore_frames--;
 749         } else {
 750                 desired_lum = 270 + sd->brightness->val;
 751
 752                 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum,
 753                                         deadzone, PAC7302_GAIN_KNEE,
 754                                         PAC7302_EXPOSURE_KNEE))
 755                         sd->autogain_ignore_frames =
 756                                                 PAC_AUTOGAIN_IGNORE_FRAMES;
 757         }
 758 }
 759
 760 /* JPEG header */
 761 static const u8 jpeg_header[] = {
 762         0xff, 0xd8,     /* SOI: Start of Image */
 763
 764         0xff, 0xc0,     /* SOF0: Start of Frame (Baseline DCT) */
 765         0x00, 0x11,     /* length = 17 bytes (including this length field) */
 766         0x08,           /* Precision: 8 */
 767         0x02, 0x80,     /* height = 640 (image rotated) */
 768         0x01, 0xe0,     /* width = 480 */
 769         0x03,           /* Number of image components: 3 */
 770         0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
 771         0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
 772         0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
 773
 774         0xff, 0xda,     /* SOS: Start Of Scan */
 775         0x00, 0x0c,     /* length = 12 bytes (including this length field) */
 776         0x03,           /* number of components: 3 */
 777         0x01, 0x00,     /* selector 1, table 0x00 */
 778         0x02, 0x11,     /* selector 2, table 0x11 */
 779         0x03, 0x11,     /* selector 3, table 0x11 */
 780         0x00, 0x3f,     /* Spectral selection: 0 .. 63 */
 781         0x00            /* Successive approximation: 0 */
 782 };
 783
 784 /* this function is run at interrupt level */
 785 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 786                         u8 *data,                       /* isoc packet */
 787                         int len)                        /* iso packet length */
 788 {
 789         struct sd *sd = (struct sd *) gspca_dev;
 790         u8 *image;
 791         u8 *sof;
 792
 793         sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
 794         if (sof) {
 795                 int n, lum_offset, footer_length;
 796
 797                 /*
 798                  * 6 bytes after the FF D9 EOF marker a number of lumination
 799                  * bytes are send corresponding to different parts of the
 800                  * image, the 14th and 15th byte after the EOF seem to
 801                  * correspond to the center of the image.
 802                  */
 803                 lum_offset = 61 + sizeof pac_sof_marker;
 804                 footer_length = 74;
 805
 806                 /* Finish decoding current frame */
 807                 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
 808                 if (n < 0) {
 809                         gspca_dev->image_len += n;
 810                         n = 0;
 811                 } else {
 812                         gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
 813                 }
 814
 815                 image = gspca_dev->image;
 816                 if (image != NULL
 817                  && image[gspca_dev->image_len - 2] == 0xff
 818                  && image[gspca_dev->image_len - 1] == 0xd9)
 819                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 820
 821                 n = sof - data;
 822                 len -= n;
 823                 data = sof;
 824
 825                 /* Get average lumination */
 826                 if (gspca_dev->last_packet_type == LAST_PACKET &&
 827                                 n >= lum_offset)
 828                         atomic_set(&sd->avg_lum, data[-lum_offset] +
 829                                                 data[-lum_offset + 1]);
 830
 831                 /* Start the new frame with the jpeg header */
 832                 /* The PAC7302 has the image rotated 90 degrees */
 833                 gspca_frame_add(gspca_dev, FIRST_PACKET,
 834                                 jpeg_header, sizeof jpeg_header);
 835         }
 836         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 837 }
 838
 839 #ifdef CONFIG_VIDEO_ADV_DEBUG
 840 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
 841                         const struct v4l2_dbg_register *reg)
 842 {
 843         u8 index;
 844         u8 value;
 845
 846         /*
 847          * reg->reg: bit0..15: reserved for register index (wIndex is 16bit
 848          *                     long on the USB bus)
 849          */
 850         if (reg->match.addr == 0 &&
 851             (reg->reg < 0x000000ff) &&
 852             (reg->val <= 0x000000ff)
 853         ) {
 854                 /* Currently writing to page 0 is only supported. */
 855                 /* reg_w() only supports 8bit index */
 856                 index = reg->reg;
 857                 value = reg->val;
 858
 859                 /*
 860                  * Note that there shall be no access to other page
 861                  * by any other function between the page switch and
 862                  * the actual register write.
 863                  */
 864                 reg_w(gspca_dev, 0xff, 0x00);           /* page 0 */
 865                 reg_w(gspca_dev, index, value);
 866
 867                 reg_w(gspca_dev, 0xdc, 0x01);
 868         }
 869         return gspca_dev->usb_err;
 870 }
 871 #endif
 872
 873 #if IS_ENABLED(CONFIG_INPUT)
 874 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
 875                         u8 *data,               /* interrupt packet data */
 876                         int len)                /* interrupt packet length */
 877 {
 878         int ret = -EINVAL;
 879         u8 data0, data1;
 880
 881         if (len == 2) {
 882                 data0 = data[0];
 883                 data1 = data[1];
 884                 if ((data0 == 0x00 && data1 == 0x11) ||
 885                     (data0 == 0x22 && data1 == 0x33) ||
 886                     (data0 == 0x44 && data1 == 0x55) ||
 887                     (data0 == 0x66 && data1 == 0x77) ||
 888                     (data0 == 0x88 && data1 == 0x99) ||
 889                     (data0 == 0xaa && data1 == 0xbb) ||
 890                     (data0 == 0xcc && data1 == 0xdd) ||
 891                     (data0 == 0xee && data1 == 0xff)) {
 892                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
 893                         input_sync(gspca_dev->input_dev);
 894                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
 895                         input_sync(gspca_dev->input_dev);
 896                         ret = 0;
 897                 }
 898         }
 899
 900         return ret;
 901 }
 902 #endif
 903
 904 /* sub-driver description for pac7302 */
 905 static const struct sd_desc sd_desc = {
 906         .name = KBUILD_MODNAME,
 907         .config = sd_config,
 908         .init = sd_init,
 909         .init_controls = sd_init_controls,
 910         .start = sd_start,
 911         .stopN = sd_stopN,
 912         .stop0 = sd_stop0,
 913         .pkt_scan = sd_pkt_scan,
 914         .dq_callback = do_autogain,
 915 #ifdef CONFIG_VIDEO_ADV_DEBUG
 916         .set_register = sd_dbg_s_register,
 917 #endif
 918 #if IS_ENABLED(CONFIG_INPUT)
 919         .int_pkt_scan = sd_int_pkt_scan,
 920 #endif
 921 };
 922
 923 /* -- module initialisation -- */
 924 static const struct usb_device_id device_table[] = {
 925         {USB_DEVICE(0x06f8, 0x3009)},
 926         {USB_DEVICE(0x06f8, 0x301b)},
 927         {USB_DEVICE(0x093a, 0x2620)},
 928         {USB_DEVICE(0x093a, 0x2621)},
 929         {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
 930         {USB_DEVICE(0x093a, 0x2623), .driver_info = FL_VFLIP},
 931         {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
 932         {USB_DEVICE(0x093a, 0x2625)},
 933         {USB_DEVICE(0x093a, 0x2626)},
 934         {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP},
 935         {USB_DEVICE(0x093a, 0x2628)},
 936         {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
 937         {USB_DEVICE(0x093a, 0x262a)},
 938         {USB_DEVICE(0x093a, 0x262c)},
 939         {USB_DEVICE(0x145f, 0x013c)},
 940         {USB_DEVICE(0x1ae7, 0x2001)}, /* SpeedLink Snappy Mic SL-6825-SBK */
 941         {}
 942 };
 943 MODULE_DEVICE_TABLE(usb, device_table);
 944
 945 /* -- device connect -- */
 946 static int sd_probe(struct usb_interface *intf,
 947                         const struct usb_device_id *id)
 948 {
 949         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 950                                 THIS_MODULE);
 951 }
 952
 953 static struct usb_driver sd_driver = {
 954         .name = KBUILD_MODNAME,
 955         .id_table = device_table,
 956         .probe = sd_probe,
 957         .disconnect = gspca_disconnect,
 958 #ifdef CONFIG_PM
 959         .suspend = gspca_suspend,
 960         .resume = gspca_resume,
 961         .reset_resume = gspca_resume,
 962 #endif
 963 };
 964
 965 module_usb_driver(sd_driver);