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