linux/drivers/media/usb/gspca/sonixb.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *              sonix sn9c102 (bayer) library
   4 *
   5 * Copyright (C) 2009-2011 Jean-Fran├žois Moine <http://moinejf.free.fr>
   6 * Copyright (C) 2003 2004 Michel Xhaard mxhaard@magic.fr
   7 * Add Pas106 Stefano Mozzi (C) 2004
   8 */
   9
  10/* Some documentation on known sonixb registers:
  11
  12Reg     Use
  13sn9c101 / sn9c102:
  140x10    high nibble red gain low nibble blue gain
  150x11    low nibble green gain
  16sn9c103:
  170x05    red gain 0-127
  180x06    blue gain 0-127
  190x07    green gain 0-127
  20all:
  210x08-0x0f i2c / 3wire registers
  220x12    hstart
  230x13    vstart
  240x15    hsize (hsize = register-value * 16)
  250x16    vsize (vsize = register-value * 16)
  260x17    bit 0 toggle compression quality (according to sn9c102 driver)
  270x18    bit 7 enables compression, bit 4-5 set image down scaling:
  28        00 scale 1, 01 scale 1/2, 10, scale 1/4
  290x19    high-nibble is sensor clock divider, changes exposure on sensors which
  30        use a clock generated by the bridge. Some sensors have their own clock.
  310x1c    auto_exposure area (for avg_lum) startx (startx = register-value * 32)
  320x1d    auto_exposure area (for avg_lum) starty (starty = register-value * 32)
  330x1e    auto_exposure area (for avg_lum) stopx (hsize = (0x1e - 0x1c) * 32)
  340x1f    auto_exposure area (for avg_lum) stopy (vsize = (0x1f - 0x1d) * 32)
  35*/
  36
  37#define MODULE_NAME "sonixb"
  38
  39#include <linux/input.h>
  40#include "gspca.h"
  41
  42MODULE_AUTHOR("Jean-Fran├žois Moine <http://moinejf.free.fr>");
  43MODULE_DESCRIPTION("GSPCA/SN9C102 USB Camera Driver");
  44MODULE_LICENSE("GPL");
  45
  46/* specific webcam descriptor */
  47struct sd {
  48        struct gspca_dev gspca_dev;     /* !! must be the first item */
  49
  50        struct v4l2_ctrl *brightness;
  51        struct v4l2_ctrl *plfreq;
  52
  53        atomic_t avg_lum;
  54        int prev_avg_lum;
  55        int exposure_knee;
  56        int header_read;
  57        u8 header[12]; /* Header without sof marker */
  58
  59        unsigned char autogain_ignore_frames;
  60        unsigned char frames_to_drop;
  61
  62        __u8 bridge;                    /* Type of bridge */
  63#define BRIDGE_101 0
  64#define BRIDGE_102 0 /* We make no difference between 101 and 102 */
  65#define BRIDGE_103 1
  66
  67        __u8 sensor;                    /* Type of image sensor chip */
  68#define SENSOR_HV7131D 0
  69#define SENSOR_HV7131R 1
  70#define SENSOR_OV6650 2
  71#define SENSOR_OV7630 3
  72#define SENSOR_PAS106 4
  73#define SENSOR_PAS202 5
  74#define SENSOR_TAS5110C 6
  75#define SENSOR_TAS5110D 7
  76#define SENSOR_TAS5130CXX 8
  77        __u8 reg11;
  78};
  79
  80typedef const __u8 sensor_init_t[8];
  81
  82struct sensor_data {
  83        const __u8 *bridge_init;
  84        sensor_init_t *sensor_init;
  85        int sensor_init_size;
  86        int flags;
  87        __u8 sensor_addr;
  88};
  89
  90/* sensor_data flags */
  91#define F_SIF           0x01    /* sif or vga */
  92
  93/* priv field of struct v4l2_pix_format flags (do not use low nibble!) */
  94#define MODE_RAW 0x10           /* raw bayer mode */
  95#define MODE_REDUCED_SIF 0x20   /* vga mode (320x240 / 160x120) on sif cam */
  96
  97#define COMP 0xc7               /* 0x87 //0x07 */
  98#define COMP1 0xc9              /* 0x89 //0x09 */
  99
 100#define MCK_INIT 0x63
 101#define MCK_INIT1 0x20          /*fixme: Bayer - 0x50 for JPEG ??*/
 102
 103#define SYS_CLK 0x04
 104
 105#define SENS(bridge, sensor, _flags, _sensor_addr) \
 106{ \
 107        .bridge_init = bridge, \
 108        .sensor_init = sensor, \
 109        .sensor_init_size = sizeof(sensor), \
 110        .flags = _flags, .sensor_addr = _sensor_addr \
 111}
 112
 113/* We calculate the autogain at the end of the transfer of a frame, at this
 114   moment a frame with the old settings is being captured and transmitted. So
 115   if we adjust the gain or exposure we must ignore at least the next frame for
 116   the new settings to come into effect before doing any other adjustments. */
 117#define AUTOGAIN_IGNORE_FRAMES 1
 118
 119static const struct v4l2_pix_format vga_mode[] = {
 120        {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 121                .bytesperline = 160,
 122                .sizeimage = 160 * 120,
 123                .colorspace = V4L2_COLORSPACE_SRGB,
 124                .priv = 2 | MODE_RAW},
 125        {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 126                .bytesperline = 160,
 127                .sizeimage = 160 * 120 * 5 / 4,
 128                .colorspace = V4L2_COLORSPACE_SRGB,
 129                .priv = 2},
 130        {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 131                .bytesperline = 320,
 132                .sizeimage = 320 * 240 * 5 / 4,
 133                .colorspace = V4L2_COLORSPACE_SRGB,
 134                .priv = 1},
 135        {640, 480, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 136                .bytesperline = 640,
 137                .sizeimage = 640 * 480 * 5 / 4,
 138                .colorspace = V4L2_COLORSPACE_SRGB,
 139                .priv = 0},
 140};
 141static const struct v4l2_pix_format sif_mode[] = {
 142        {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 143                .bytesperline = 160,
 144                .sizeimage = 160 * 120,
 145                .colorspace = V4L2_COLORSPACE_SRGB,
 146                .priv = 1 | MODE_RAW | MODE_REDUCED_SIF},
 147        {160, 120, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 148                .bytesperline = 160,
 149                .sizeimage = 160 * 120 * 5 / 4,
 150                .colorspace = V4L2_COLORSPACE_SRGB,
 151                .priv = 1 | MODE_REDUCED_SIF},
 152        {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 153                .bytesperline = 176,
 154                .sizeimage = 176 * 144,
 155                .colorspace = V4L2_COLORSPACE_SRGB,
 156                .priv = 1 | MODE_RAW},
 157        {176, 144, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 158                .bytesperline = 176,
 159                .sizeimage = 176 * 144 * 5 / 4,
 160                .colorspace = V4L2_COLORSPACE_SRGB,
 161                .priv = 1},
 162        {320, 240, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 163                .bytesperline = 320,
 164                .sizeimage = 320 * 240 * 5 / 4,
 165                .colorspace = V4L2_COLORSPACE_SRGB,
 166                .priv = 0 | MODE_REDUCED_SIF},
 167        {352, 288, V4L2_PIX_FMT_SN9C10X, V4L2_FIELD_NONE,
 168                .bytesperline = 352,
 169                .sizeimage = 352 * 288 * 5 / 4,
 170                .colorspace = V4L2_COLORSPACE_SRGB,
 171                .priv = 0},
 172};
 173
 174static const __u8 initHv7131d[] = {
 175        0x04, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
 176        0x00, 0x00,
 177        0x00, 0x00, 0x00, 0x02, 0x02, 0x00,
 178        0x28, 0x1e, 0x60, 0x8e, 0x42,
 179};
 180static const __u8 hv7131d_sensor_init[][8] = {
 181        {0xa0, 0x11, 0x01, 0x04, 0x00, 0x00, 0x00, 0x17},
 182        {0xa0, 0x11, 0x02, 0x00, 0x00, 0x00, 0x00, 0x17},
 183        {0xa0, 0x11, 0x28, 0x00, 0x00, 0x00, 0x00, 0x17},
 184        {0xa0, 0x11, 0x30, 0x30, 0x00, 0x00, 0x00, 0x17}, /* reset level */
 185        {0xa0, 0x11, 0x34, 0x02, 0x00, 0x00, 0x00, 0x17}, /* pixel bias volt */
 186};
 187
 188static const __u8 initHv7131r[] = {
 189        0x46, 0x77, 0x00, 0x04, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00,
 190        0x00, 0x00,
 191        0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
 192        0x28, 0x1e, 0x60, 0x8a, 0x20,
 193};
 194static const __u8 hv7131r_sensor_init[][8] = {
 195        {0xc0, 0x11, 0x31, 0x38, 0x2a, 0x2e, 0x00, 0x10},
 196        {0xa0, 0x11, 0x01, 0x08, 0x2a, 0x2e, 0x00, 0x10},
 197        {0xb0, 0x11, 0x20, 0x00, 0xd0, 0x2e, 0x00, 0x10},
 198        {0xc0, 0x11, 0x25, 0x03, 0x0e, 0x28, 0x00, 0x16},
 199        {0xa0, 0x11, 0x30, 0x10, 0x0e, 0x28, 0x00, 0x15},
 200};
 201static const __u8 initOv6650[] = {
 202        0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
 203        0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 204        0x00, 0x01, 0x01, 0x0a, 0x16, 0x12, 0x68, 0x8b,
 205        0x10,
 206};
 207static const __u8 ov6650_sensor_init[][8] = {
 208        /* Bright, contrast, etc are set through SCBB interface.
 209         * AVCAP on win2 do not send any data on this controls. */
 210        /* Anyway, some registers appears to alter bright and constrat */
 211
 212        /* Reset sensor */
 213        {0xa0, 0x60, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
 214        /* Set clock register 0x11 low nibble is clock divider */
 215        {0xd0, 0x60, 0x11, 0xc0, 0x1b, 0x18, 0xc1, 0x10},
 216        /* Next some unknown stuff */
 217        {0xb0, 0x60, 0x15, 0x00, 0x02, 0x18, 0xc1, 0x10},
 218/*      {0xa0, 0x60, 0x1b, 0x01, 0x02, 0x18, 0xc1, 0x10},
 219                 * THIS SET GREEN SCREEN
 220                 * (pixels could be innverted in decode kind of "brg",
 221                 * but blue wont be there. Avoid this data ... */
 222        {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10}, /* format out? */
 223        {0xd0, 0x60, 0x26, 0x01, 0x14, 0xd8, 0xa4, 0x10},
 224        {0xa0, 0x60, 0x30, 0x3d, 0x0a, 0xd8, 0xa4, 0x10},
 225        /* Enable rgb brightness control */
 226        {0xa0, 0x60, 0x61, 0x08, 0x00, 0x00, 0x00, 0x10},
 227        /* HDG: Note windows uses the line below, which sets both register 0x60
 228           and 0x61 I believe these registers of the ov6650 are identical as
 229           those of the ov7630, because if this is true the windows settings
 230           add a bit additional red gain and a lot additional blue gain, which
 231           matches my findings that the windows settings make blue much too
 232           blue and red a little too red.
 233        {0xb0, 0x60, 0x60, 0x66, 0x68, 0xd8, 0xa4, 0x10}, */
 234        /* Some more unknown stuff */
 235        {0xa0, 0x60, 0x68, 0x04, 0x68, 0xd8, 0xa4, 0x10},
 236        {0xd0, 0x60, 0x17, 0x24, 0xd6, 0x04, 0x94, 0x10}, /* Clipreg */
 237};
 238
 239static const __u8 initOv7630[] = {
 240        0x04, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, /* r01 .. r08 */
 241        0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* r09 .. r10 */
 242        0x00, 0x01, 0x01, 0x0a,                         /* r11 .. r14 */
 243        0x28, 0x1e,                     /* H & V sizes     r15 .. r16 */
 244        0x68, 0x8f, MCK_INIT1,                          /* r17 .. r19 */
 245};
 246static const __u8 ov7630_sensor_init[][8] = {
 247        {0xa0, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10},
 248        {0xb0, 0x21, 0x01, 0x77, 0x3a, 0x00, 0x00, 0x10},
 249/*      {0xd0, 0x21, 0x12, 0x7c, 0x01, 0x80, 0x34, 0x10},          jfm */
 250        {0xd0, 0x21, 0x12, 0x5c, 0x00, 0x80, 0x34, 0x10},       /* jfm */
 251        {0xa0, 0x21, 0x1b, 0x04, 0x00, 0x80, 0x34, 0x10},
 252        {0xa0, 0x21, 0x20, 0x44, 0x00, 0x80, 0x34, 0x10},
 253        {0xa0, 0x21, 0x23, 0xee, 0x00, 0x80, 0x34, 0x10},
 254        {0xd0, 0x21, 0x26, 0xa0, 0x9a, 0xa0, 0x30, 0x10},
 255        {0xb0, 0x21, 0x2a, 0x80, 0x00, 0xa0, 0x30, 0x10},
 256        {0xb0, 0x21, 0x2f, 0x3d, 0x24, 0xa0, 0x30, 0x10},
 257        {0xa0, 0x21, 0x32, 0x86, 0x24, 0xa0, 0x30, 0x10},
 258        {0xb0, 0x21, 0x60, 0xa9, 0x4a, 0xa0, 0x30, 0x10},
 259/*      {0xb0, 0x21, 0x60, 0xa9, 0x42, 0xa0, 0x30, 0x10},        * jfm */
 260        {0xa0, 0x21, 0x65, 0x00, 0x42, 0xa0, 0x30, 0x10},
 261        {0xa0, 0x21, 0x69, 0x38, 0x42, 0xa0, 0x30, 0x10},
 262        {0xc0, 0x21, 0x6f, 0x88, 0x0b, 0x00, 0x30, 0x10},
 263        {0xc0, 0x21, 0x74, 0x21, 0x8e, 0x00, 0x30, 0x10},
 264        {0xa0, 0x21, 0x7d, 0xf7, 0x8e, 0x00, 0x30, 0x10},
 265        {0xd0, 0x21, 0x17, 0x1c, 0xbd, 0x06, 0xf6, 0x10},
 266};
 267
 268static const __u8 initPas106[] = {
 269        0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00, 0x00,
 270        0x00, 0x00,
 271        0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
 272        0x16, 0x12, 0x24, COMP1, MCK_INIT1,
 273};
 274/* compression 0x86 mckinit1 0x2b */
 275
 276/* "Known" PAS106B registers:
 277  0x02 clock divider
 278  0x03 Variable framerate bits 4-11
 279  0x04 Var framerate bits 0-3, one must leave the 4 msb's at 0 !!
 280       The variable framerate control must never be set lower then 300,
 281       which sets the framerate at 90 / reg02, otherwise vsync is lost.
 282  0x05 Shutter Time Line Offset, this can be used as an exposure control:
 283       0 = use full frame time, 255 = no exposure at all
 284       Note this may never be larger then "var-framerate control" / 2 - 2.
 285       When var-framerate control is < 514, no exposure is reached at the max
 286       allowed value for the framerate control value, rather then at 255.
 287  0x06 Shutter Time Pixel Offset, like reg05 this influences exposure, but
 288       only a very little bit, leave at 0xcd
 289  0x07 offset sign bit (bit0 1 > negative offset)
 290  0x08 offset
 291  0x09 Blue Gain
 292  0x0a Green1 Gain
 293  0x0b Green2 Gain
 294  0x0c Red Gain
 295  0x0e Global gain
 296  0x13 Write 1 to commit settings to sensor
 297*/
 298
 299static const __u8 pas106_sensor_init[][8] = {
 300        /* Pixel Clock Divider 6 */
 301        { 0xa1, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14 },
 302        /* Frame Time MSB (also seen as 0x12) */
 303        { 0xa1, 0x40, 0x03, 0x13, 0x00, 0x00, 0x00, 0x14 },
 304        /* Frame Time LSB (also seen as 0x05) */
 305        { 0xa1, 0x40, 0x04, 0x06, 0x00, 0x00, 0x00, 0x14 },
 306        /* Shutter Time Line Offset (also seen as 0x6d) */
 307        { 0xa1, 0x40, 0x05, 0x65, 0x00, 0x00, 0x00, 0x14 },
 308        /* Shutter Time Pixel Offset (also seen as 0xb1) */
 309        { 0xa1, 0x40, 0x06, 0xcd, 0x00, 0x00, 0x00, 0x14 },
 310        /* Black Level Subtract Sign (also seen 0x00) */
 311        { 0xa1, 0x40, 0x07, 0xc1, 0x00, 0x00, 0x00, 0x14 },
 312        /* Black Level Subtract Level (also seen 0x01) */
 313        { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
 314        { 0xa1, 0x40, 0x08, 0x06, 0x00, 0x00, 0x00, 0x14 },
 315        /* Color Gain B Pixel 5 a */
 316        { 0xa1, 0x40, 0x09, 0x05, 0x00, 0x00, 0x00, 0x14 },
 317        /* Color Gain G1 Pixel 1 5 */
 318        { 0xa1, 0x40, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x14 },
 319        /* Color Gain G2 Pixel 1 0 5 */
 320        { 0xa1, 0x40, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x14 },
 321        /* Color Gain R Pixel 3 1 */
 322        { 0xa1, 0x40, 0x0c, 0x05, 0x00, 0x00, 0x00, 0x14 },
 323        /* Color GainH  Pixel */
 324        { 0xa1, 0x40, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x14 },
 325        /* Global Gain */
 326        { 0xa1, 0x40, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x14 },
 327        /* Contrast */
 328        { 0xa1, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x14 },
 329        /* H&V synchro polarity */
 330        { 0xa1, 0x40, 0x10, 0x06, 0x00, 0x00, 0x00, 0x14 },
 331        /* ?default */
 332        { 0xa1, 0x40, 0x11, 0x06, 0x00, 0x00, 0x00, 0x14 },
 333        /* DAC scale */
 334        { 0xa1, 0x40, 0x12, 0x06, 0x00, 0x00, 0x00, 0x14 },
 335        /* ?default */
 336        { 0xa1, 0x40, 0x14, 0x02, 0x00, 0x00, 0x00, 0x14 },
 337        /* Validate Settings */
 338        { 0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14 },
 339};
 340
 341static const __u8 initPas202[] = {
 342        0x44, 0x44, 0x21, 0x30, 0x00, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x00,
 343        0x00, 0x00,
 344        0x00, 0x00, 0x00, 0x06, 0x03, 0x0a,
 345        0x28, 0x1e, 0x20, 0x89, 0x20,
 346};
 347
 348/* "Known" PAS202BCB registers:
 349  0x02 clock divider
 350  0x04 Variable framerate bits 6-11 (*)
 351  0x05 Var framerate  bits 0-5, one must leave the 2 msb's at 0 !!
 352  0x07 Blue Gain
 353  0x08 Green Gain
 354  0x09 Red Gain
 355  0x0b offset sign bit (bit0 1 > negative offset)
 356  0x0c offset
 357  0x0e Unknown image is slightly brighter when bit 0 is 0, if reg0f is 0 too,
 358       leave at 1 otherwise we get a jump in our exposure control
 359  0x0f Exposure 0-255, 0 = use full frame time, 255 = no exposure at all
 360  0x10 Master gain 0 - 31
 361  0x11 write 1 to apply changes
 362  (*) The variable framerate control must never be set lower then 500
 363      which sets the framerate at 30 / reg02, otherwise vsync is lost.
 364*/
 365static const __u8 pas202_sensor_init[][8] = {
 366        /* Set the clock divider to 4 -> 30 / 4 = 7.5 fps, we would like
 367           to set it lower, but for some reason the bridge starts missing
 368           vsync's then */
 369        {0xa0, 0x40, 0x02, 0x04, 0x00, 0x00, 0x00, 0x10},
 370        {0xd0, 0x40, 0x04, 0x07, 0x34, 0x00, 0x09, 0x10},
 371        {0xd0, 0x40, 0x08, 0x01, 0x00, 0x00, 0x01, 0x10},
 372        {0xd0, 0x40, 0x0c, 0x00, 0x0c, 0x01, 0x32, 0x10},
 373        {0xd0, 0x40, 0x10, 0x00, 0x01, 0x00, 0x63, 0x10},
 374        {0xa0, 0x40, 0x15, 0x70, 0x01, 0x00, 0x63, 0x10},
 375        {0xa0, 0x40, 0x18, 0x00, 0x01, 0x00, 0x63, 0x10},
 376        {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
 377        {0xa0, 0x40, 0x03, 0x56, 0x01, 0x00, 0x63, 0x10},
 378        {0xa0, 0x40, 0x11, 0x01, 0x01, 0x00, 0x63, 0x10},
 379};
 380
 381static const __u8 initTas5110c[] = {
 382        0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 383        0x00, 0x00,
 384        0x00, 0x00, 0x00, 0x45, 0x09, 0x0a,
 385        0x16, 0x12, 0x60, 0x86, 0x2b,
 386};
 387/* Same as above, except a different hstart */
 388static const __u8 initTas5110d[] = {
 389        0x44, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 390        0x00, 0x00,
 391        0x00, 0x00, 0x00, 0x41, 0x09, 0x0a,
 392        0x16, 0x12, 0x60, 0x86, 0x2b,
 393};
 394/* tas5110c is 3 wire, tas5110d is 2 wire (regular i2c) */
 395static const __u8 tas5110c_sensor_init[][8] = {
 396        {0x30, 0x11, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x10},
 397        {0x30, 0x11, 0x02, 0x20, 0xa9, 0x00, 0x00, 0x10},
 398};
 399/* Known TAS5110D registers
 400 * reg02: gain, bit order reversed!! 0 == max gain, 255 == min gain
 401 * reg03: bit3: vflip, bit4: ~hflip, bit7: ~gainboost (~ == inverted)
 402 *        Note: writing reg03 seems to only work when written together with 02
 403 */
 404static const __u8 tas5110d_sensor_init[][8] = {
 405        {0xa0, 0x61, 0x9a, 0xca, 0x00, 0x00, 0x00, 0x17}, /* reset */
 406};
 407
 408static const __u8 initTas5130[] = {
 409        0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x00,
 410        0x00, 0x00,
 411        0x00, 0x00, 0x00, 0x68, 0x0c, 0x0a,
 412        0x28, 0x1e, 0x60, COMP, MCK_INIT,
 413};
 414static const __u8 tas5130_sensor_init[][8] = {
 415/*      {0x30, 0x11, 0x00, 0x40, 0x47, 0x00, 0x00, 0x10},
 416                                        * shutter 0x47 short exposure? */
 417        {0x30, 0x11, 0x00, 0x40, 0x01, 0x00, 0x00, 0x10},
 418                                        /* shutter 0x01 long exposure */
 419        {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10},
 420};
 421
 422static const struct sensor_data sensor_data[] = {
 423        SENS(initHv7131d, hv7131d_sensor_init, 0, 0),
 424        SENS(initHv7131r, hv7131r_sensor_init, 0, 0),
 425        SENS(initOv6650, ov6650_sensor_init, F_SIF, 0x60),
 426        SENS(initOv7630, ov7630_sensor_init, 0, 0x21),
 427        SENS(initPas106, pas106_sensor_init, F_SIF, 0),
 428        SENS(initPas202, pas202_sensor_init, 0, 0),
 429        SENS(initTas5110c, tas5110c_sensor_init, F_SIF, 0),
 430        SENS(initTas5110d, tas5110d_sensor_init, F_SIF, 0),
 431        SENS(initTas5130, tas5130_sensor_init, 0, 0),
 432};
 433
 434/* get one byte in gspca_dev->usb_buf */
 435static void reg_r(struct gspca_dev *gspca_dev,
 436                  __u16 value)
 437{
 438        int res;
 439
 440        if (gspca_dev->usb_err < 0)
 441                return;
 442
 443        res = usb_control_msg(gspca_dev->dev,
 444                        usb_rcvctrlpipe(gspca_dev->dev, 0),
 445                        0,                      /* request */
 446                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 447                        value,
 448                        0,                      /* index */
 449                        gspca_dev->usb_buf, 1,
 450                        500);
 451
 452        if (res < 0) {
 453                dev_err(gspca_dev->v4l2_dev.dev,
 454                        "Error reading register %02x: %d\n", value, res);
 455                gspca_dev->usb_err = res;
 456                /*
 457                 * Make sure the result is zeroed to avoid uninitialized
 458                 * values.
 459                 */
 460                gspca_dev->usb_buf[0] = 0;
 461        }
 462}
 463
 464static void reg_w(struct gspca_dev *gspca_dev,
 465                  __u16 value,
 466                  const __u8 *buffer,
 467                  int len)
 468{
 469        int res;
 470
 471        if (gspca_dev->usb_err < 0)
 472                return;
 473
 474        memcpy(gspca_dev->usb_buf, buffer, len);
 475        res = usb_control_msg(gspca_dev->dev,
 476                        usb_sndctrlpipe(gspca_dev->dev, 0),
 477                        0x08,                   /* request */
 478                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 479                        value,
 480                        0,                      /* index */
 481                        gspca_dev->usb_buf, len,
 482                        500);
 483
 484        if (res < 0) {
 485                dev_err(gspca_dev->v4l2_dev.dev,
 486                        "Error writing register %02x: %d\n", value, res);
 487                gspca_dev->usb_err = res;
 488        }
 489}
 490
 491static void i2c_w(struct gspca_dev *gspca_dev, const u8 *buf)
 492{
 493        int retry = 60;
 494
 495        if (gspca_dev->usb_err < 0)
 496                return;
 497
 498        /* is i2c ready */
 499        reg_w(gspca_dev, 0x08, buf, 8);
 500        while (retry--) {
 501                if (gspca_dev->usb_err < 0)
 502                        return;
 503                msleep(1);
 504                reg_r(gspca_dev, 0x08);
 505                if (gspca_dev->usb_buf[0] & 0x04) {
 506                        if (gspca_dev->usb_buf[0] & 0x08) {
 507                                dev_err(gspca_dev->v4l2_dev.dev,
 508                                        "i2c error writing %8ph\n", buf);
 509                                gspca_dev->usb_err = -EIO;
 510                        }
 511                        return;
 512                }
 513        }
 514
 515        dev_err(gspca_dev->v4l2_dev.dev, "i2c write timeout\n");
 516        gspca_dev->usb_err = -EIO;
 517}
 518
 519static void i2c_w_vector(struct gspca_dev *gspca_dev,
 520                        const __u8 buffer[][8], int len)
 521{
 522        for (;;) {
 523                if (gspca_dev->usb_err < 0)
 524                        return;
 525                i2c_w(gspca_dev, *buffer);
 526                len -= 8;
 527                if (len <= 0)
 528                        break;
 529                buffer++;
 530        }
 531}
 532
 533static void setbrightness(struct gspca_dev *gspca_dev)
 534{
 535        struct sd *sd = (struct sd *) gspca_dev;
 536
 537        switch (sd->sensor) {
 538        case  SENSOR_OV6650:
 539        case  SENSOR_OV7630: {
 540                __u8 i2cOV[] =
 541                        {0xa0, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10};
 542
 543                /* change reg 0x06 */
 544                i2cOV[1] = sensor_data[sd->sensor].sensor_addr;
 545                i2cOV[3] = sd->brightness->val;
 546                i2c_w(gspca_dev, i2cOV);
 547                break;
 548        }
 549        case SENSOR_PAS106:
 550        case SENSOR_PAS202: {
 551                __u8 i2cpbright[] =
 552                        {0xb0, 0x40, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x16};
 553                __u8 i2cpdoit[] =
 554                        {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 555
 556                /* PAS106 uses reg 7 and 8 instead of b and c */
 557                if (sd->sensor == SENSOR_PAS106) {
 558                        i2cpbright[2] = 7;
 559                        i2cpdoit[2] = 0x13;
 560                }
 561
 562                if (sd->brightness->val < 127) {
 563                        /* change reg 0x0b, signreg */
 564                        i2cpbright[3] = 0x01;
 565                        /* set reg 0x0c, offset */
 566                        i2cpbright[4] = 127 - sd->brightness->val;
 567                } else
 568                        i2cpbright[4] = sd->brightness->val - 127;
 569
 570                i2c_w(gspca_dev, i2cpbright);
 571                i2c_w(gspca_dev, i2cpdoit);
 572                break;
 573        }
 574        default:
 575                break;
 576        }
 577}
 578
 579static void setgain(struct gspca_dev *gspca_dev)
 580{
 581        struct sd *sd = (struct sd *) gspca_dev;
 582        u8 gain = gspca_dev->gain->val;
 583
 584        switch (sd->sensor) {
 585        case SENSOR_HV7131D: {
 586                __u8 i2c[] =
 587                        {0xc0, 0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17};
 588
 589                i2c[3] = 0x3f - gain;
 590                i2c[4] = 0x3f - gain;
 591                i2c[5] = 0x3f - gain;
 592
 593                i2c_w(gspca_dev, i2c);
 594                break;
 595        }
 596        case SENSOR_TAS5110C:
 597        case SENSOR_TAS5130CXX: {
 598                __u8 i2c[] =
 599                        {0x30, 0x11, 0x02, 0x20, 0x70, 0x00, 0x00, 0x10};
 600
 601                i2c[4] = 255 - gain;
 602                i2c_w(gspca_dev, i2c);
 603                break;
 604        }
 605        case SENSOR_TAS5110D: {
 606                __u8 i2c[] = {
 607                        0xb0, 0x61, 0x02, 0x00, 0x10, 0x00, 0x00, 0x17 };
 608                gain = 255 - gain;
 609                /* The bits in the register are the wrong way around!! */
 610                i2c[3] |= (gain & 0x80) >> 7;
 611                i2c[3] |= (gain & 0x40) >> 5;
 612                i2c[3] |= (gain & 0x20) >> 3;
 613                i2c[3] |= (gain & 0x10) >> 1;
 614                i2c[3] |= (gain & 0x08) << 1;
 615                i2c[3] |= (gain & 0x04) << 3;
 616                i2c[3] |= (gain & 0x02) << 5;
 617                i2c[3] |= (gain & 0x01) << 7;
 618                i2c_w(gspca_dev, i2c);
 619                break;
 620        }
 621        case SENSOR_OV6650:
 622        case SENSOR_OV7630: {
 623                __u8 i2c[] = {0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
 624
 625                /*
 626                 * The ov7630's gain is weird, at 32 the gain drops to the
 627                 * same level as at 16, so skip 32-47 (of the 0-63 scale).
 628                 */
 629                if (sd->sensor == SENSOR_OV7630 && gain >= 32)
 630                        gain += 16;
 631
 632                i2c[1] = sensor_data[sd->sensor].sensor_addr;
 633                i2c[3] = gain;
 634                i2c_w(gspca_dev, i2c);
 635                break;
 636        }
 637        case SENSOR_PAS106:
 638        case SENSOR_PAS202: {
 639                __u8 i2cpgain[] =
 640                        {0xa0, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15};
 641                __u8 i2cpcolorgain[] =
 642                        {0xc0, 0x40, 0x07, 0x00, 0x00, 0x00, 0x00, 0x15};
 643                __u8 i2cpdoit[] =
 644                        {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 645
 646                /* PAS106 uses different regs (and has split green gains) */
 647                if (sd->sensor == SENSOR_PAS106) {
 648                        i2cpgain[2] = 0x0e;
 649                        i2cpcolorgain[0] = 0xd0;
 650                        i2cpcolorgain[2] = 0x09;
 651                        i2cpdoit[2] = 0x13;
 652                }
 653
 654                i2cpgain[3] = gain;
 655                i2cpcolorgain[3] = gain >> 1;
 656                i2cpcolorgain[4] = gain >> 1;
 657                i2cpcolorgain[5] = gain >> 1;
 658                i2cpcolorgain[6] = gain >> 1;
 659
 660                i2c_w(gspca_dev, i2cpgain);
 661                i2c_w(gspca_dev, i2cpcolorgain);
 662                i2c_w(gspca_dev, i2cpdoit);
 663                break;
 664        }
 665        default:
 666                if (sd->bridge == BRIDGE_103) {
 667                        u8 buf[3] = { gain, gain, gain }; /* R, G, B */
 668                        reg_w(gspca_dev, 0x05, buf, 3);
 669                } else {
 670                        u8 buf[2];
 671                        buf[0] = gain << 4 | gain; /* Red and blue */
 672                        buf[1] = gain; /* Green */
 673                        reg_w(gspca_dev, 0x10, buf, 2);
 674                }
 675        }
 676}
 677
 678static void setexposure(struct gspca_dev *gspca_dev)
 679{
 680        struct sd *sd = (struct sd *) gspca_dev;
 681
 682        switch (sd->sensor) {
 683        case SENSOR_HV7131D: {
 684                /* Note the datasheet wrongly says line mode exposure uses reg
 685                   0x26 and 0x27, testing has shown 0x25 + 0x26 */
 686                __u8 i2c[] = {0xc0, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x17};
 687                u16 reg = gspca_dev->exposure->val;
 688
 689                i2c[3] = reg >> 8;
 690                i2c[4] = reg & 0xff;
 691                i2c_w(gspca_dev, i2c);
 692                break;
 693        }
 694        case SENSOR_TAS5110C:
 695        case SENSOR_TAS5110D: {
 696                /* register 19's high nibble contains the sn9c10x clock divider
 697                   The high nibble configures the no fps according to the
 698                   formula: 60 / high_nibble. With a maximum of 30 fps */
 699                u8 reg = gspca_dev->exposure->val;
 700
 701                reg = (reg << 4) | 0x0b;
 702                reg_w(gspca_dev, 0x19, &reg, 1);
 703                break;
 704        }
 705        case SENSOR_OV6650:
 706        case SENSOR_OV7630: {
 707                /* The ov6650 / ov7630 have 2 registers which both influence
 708                   exposure, register 11, whose low nibble sets the nr off fps
 709                   according to: fps = 30 / (low_nibble + 1)
 710
 711                   The fps configures the maximum exposure setting, but it is
 712                   possible to use less exposure then what the fps maximum
 713                   allows by setting register 10. register 10 configures the
 714                   actual exposure as quotient of the full exposure, with 0
 715                   being no exposure at all (not very useful) and reg10_max
 716                   being max exposure possible at that framerate.
 717
 718                   The code maps our 0 - 510 ms exposure ctrl to these 2
 719                   registers, trying to keep fps as high as possible.
 720                */
 721                __u8 i2c[] = {0xb0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10};
 722                int reg10, reg11, reg10_max;
 723
 724                /* ov6645 datasheet says reg10_max is 9a, but that uses
 725                   tline * 2 * reg10 as formula for calculating texpo, the
 726                   ov6650 probably uses the same formula as the 7730 which uses
 727                   tline * 4 * reg10, which explains why the reg10max we've
 728                   found experimentally for the ov6650 is exactly half that of
 729                   the ov6645. The ov7630 datasheet says the max is 0x41. */
 730                if (sd->sensor == SENSOR_OV6650) {
 731                        reg10_max = 0x4d;
 732                        i2c[4] = 0xc0; /* OV6650 needs non default vsync pol */
 733                } else
 734                        reg10_max = 0x41;
 735
 736                reg11 = (15 * gspca_dev->exposure->val + 999) / 1000;
 737                if (reg11 < 1)
 738                        reg11 = 1;
 739                else if (reg11 > 16)
 740                        reg11 = 16;
 741
 742                /* In 640x480, if the reg11 has less than 4, the image is
 743                   unstable (the bridge goes into a higher compression mode
 744                   which we have not reverse engineered yet). */
 745                if (gspca_dev->pixfmt.width == 640 && reg11 < 4)
 746                        reg11 = 4;
 747
 748                /* frame exposure time in ms = 1000 * reg11 / 30    ->
 749                reg10 = (gspca_dev->exposure->val / 2) * reg10_max
 750                                / (1000 * reg11 / 30) */
 751                reg10 = (gspca_dev->exposure->val * 15 * reg10_max)
 752                                / (1000 * reg11);
 753
 754                /* Don't allow this to get below 10 when using autogain, the
 755                   steps become very large (relatively) when below 10 causing
 756                   the image to oscillate from much too dark, to much too bright
 757                   and back again. */
 758                if (gspca_dev->autogain->val && reg10 < 10)
 759                        reg10 = 10;
 760                else if (reg10 > reg10_max)
 761                        reg10 = reg10_max;
 762
 763                /* Write reg 10 and reg11 low nibble */
 764                i2c[1] = sensor_data[sd->sensor].sensor_addr;
 765                i2c[3] = reg10;
 766                i2c[4] |= reg11 - 1;
 767
 768                /* If register 11 didn't change, don't change it */
 769                if (sd->reg11 == reg11)
 770                        i2c[0] = 0xa0;
 771
 772                i2c_w(gspca_dev, i2c);
 773                if (gspca_dev->usb_err == 0)
 774                        sd->reg11 = reg11;
 775                break;
 776        }
 777        case SENSOR_PAS202: {
 778                __u8 i2cpframerate[] =
 779                        {0xb0, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x16};
 780                __u8 i2cpexpo[] =
 781                        {0xa0, 0x40, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x16};
 782                const __u8 i2cpdoit[] =
 783                        {0xa0, 0x40, 0x11, 0x01, 0x00, 0x00, 0x00, 0x16};
 784                int framerate_ctrl;
 785
 786                /* The exposure knee for the autogain algorithm is 200
 787                   (100 ms / 10 fps on other sensors), for values below this
 788                   use the control for setting the partial frame expose time,
 789                   above that use variable framerate. This way we run at max
 790                   framerate (640x480@7.5 fps, 320x240@10fps) until the knee
 791                   is reached. Using the variable framerate control above 200
 792                   is better then playing around with both clockdiv + partial
 793                   frame exposure times (like we are doing with the ov chips),
 794                   as that sometimes leads to jumps in the exposure control,
 795                   which are bad for auto exposure. */
 796                if (gspca_dev->exposure->val < 200) {
 797                        i2cpexpo[3] = 255 - (gspca_dev->exposure->val * 255)
 798                                                / 200;
 799                        framerate_ctrl = 500;
 800                } else {
 801                        /* The PAS202's exposure control goes from 0 - 4095,
 802                           but anything below 500 causes vsync issues, so scale
 803                           our 200-1023 to 500-4095 */
 804                        framerate_ctrl = (gspca_dev->exposure->val - 200)
 805                                                        * 1000 / 229 +  500;
 806                }
 807
 808                i2cpframerate[3] = framerate_ctrl >> 6;
 809                i2cpframerate[4] = framerate_ctrl & 0x3f;
 810                i2c_w(gspca_dev, i2cpframerate);
 811                i2c_w(gspca_dev, i2cpexpo);
 812                i2c_w(gspca_dev, i2cpdoit);
 813                break;
 814        }
 815        case SENSOR_PAS106: {
 816                __u8 i2cpframerate[] =
 817                        {0xb1, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x14};
 818                __u8 i2cpexpo[] =
 819                        {0xa1, 0x40, 0x05, 0x00, 0x00, 0x00, 0x00, 0x14};
 820                const __u8 i2cpdoit[] =
 821                        {0xa1, 0x40, 0x13, 0x01, 0x00, 0x00, 0x00, 0x14};
 822                int framerate_ctrl;
 823
 824                /* For values below 150 use partial frame exposure, above
 825                   that use framerate ctrl */
 826                if (gspca_dev->exposure->val < 150) {
 827                        i2cpexpo[3] = 150 - gspca_dev->exposure->val;
 828                        framerate_ctrl = 300;
 829                } else {
 830                        /* The PAS106's exposure control goes from 0 - 4095,
 831                           but anything below 300 causes vsync issues, so scale
 832                           our 150-1023 to 300-4095 */
 833                        framerate_ctrl = (gspca_dev->exposure->val - 150)
 834                                                * 1000 / 230 + 300;
 835                }
 836
 837                i2cpframerate[3] = framerate_ctrl >> 4;
 838                i2cpframerate[4] = framerate_ctrl & 0x0f;
 839                i2c_w(gspca_dev, i2cpframerate);
 840                i2c_w(gspca_dev, i2cpexpo);
 841                i2c_w(gspca_dev, i2cpdoit);
 842                break;
 843        }
 844        default:
 845                break;
 846        }
 847}
 848
 849static void setfreq(struct gspca_dev *gspca_dev)
 850{
 851        struct sd *sd = (struct sd *) gspca_dev;
 852
 853        if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630) {
 854                /* Framerate adjust register for artificial light 50 hz flicker
 855                   compensation, for the ov6650 this is identical to ov6630
 856                   0x2b register, see ov6630 datasheet.
 857                   0x4f / 0x8a -> (30 fps -> 25 fps), 0x00 -> no adjustment */
 858                __u8 i2c[] = {0xa0, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10};
 859                switch (sd->plfreq->val) {
 860                default:
 861/*              case 0:                  * no filter*/
 862/*              case 2:                  * 60 hz */
 863                        i2c[3] = 0;
 864                        break;
 865                case 1:                 /* 50 hz */
 866                        i2c[3] = (sd->sensor == SENSOR_OV6650)
 867                                        ? 0x4f : 0x8a;
 868                        break;
 869                }
 870                i2c[1] = sensor_data[sd->sensor].sensor_addr;
 871                i2c_w(gspca_dev, i2c);
 872        }
 873}
 874
 875static void do_autogain(struct gspca_dev *gspca_dev)
 876{
 877        struct sd *sd = (struct sd *) gspca_dev;
 878        int deadzone, desired_avg_lum, avg_lum;
 879
 880        avg_lum = atomic_read(&sd->avg_lum);
 881        if (avg_lum == -1)
 882                return;
 883
 884        if (sd->autogain_ignore_frames > 0) {
 885                sd->autogain_ignore_frames--;
 886                return;
 887        }
 888
 889        /* SIF / VGA sensors have a different autoexposure area and thus
 890           different avg_lum values for the same picture brightness */
 891        if (sensor_data[sd->sensor].flags & F_SIF) {
 892                deadzone = 500;
 893                /* SIF sensors tend to overexpose, so keep this small */
 894                desired_avg_lum = 5000;
 895        } else {
 896                deadzone = 1500;
 897                desired_avg_lum = 13000;
 898        }
 899
 900        if (sd->brightness)
 901                desired_avg_lum = sd->brightness->val * desired_avg_lum / 127;
 902
 903        if (gspca_dev->exposure->maximum < 500) {
 904                if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
 905                                desired_avg_lum, deadzone))
 906                        sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 907        } else {
 908                int gain_knee = (s32)gspca_dev->gain->maximum * 9 / 10;
 909                if (gspca_expo_autogain(gspca_dev, avg_lum, desired_avg_lum,
 910                                deadzone, gain_knee, sd->exposure_knee))
 911                        sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 912        }
 913}
 914
 915/* this function is called at probe time */
 916static int sd_config(struct gspca_dev *gspca_dev,
 917                        const struct usb_device_id *id)
 918{
 919        struct sd *sd = (struct sd *) gspca_dev;
 920        struct cam *cam;
 921
 922        reg_r(gspca_dev, 0x00);
 923        if (gspca_dev->usb_buf[0] != 0x10)
 924                return -ENODEV;
 925
 926        /* copy the webcam info from the device id */
 927        sd->sensor = id->driver_info >> 8;
 928        sd->bridge = id->driver_info & 0xff;
 929
 930        cam = &gspca_dev->cam;
 931        if (!(sensor_data[sd->sensor].flags & F_SIF)) {
 932                cam->cam_mode = vga_mode;
 933                cam->nmodes = ARRAY_SIZE(vga_mode);
 934        } else {
 935                cam->cam_mode = sif_mode;
 936                cam->nmodes = ARRAY_SIZE(sif_mode);
 937        }
 938        cam->npkt = 36;                 /* 36 packets per ISOC message */
 939
 940        return 0;
 941}
 942
 943/* this function is called at probe and resume time */
 944static int sd_init(struct gspca_dev *gspca_dev)
 945{
 946        const __u8 stop = 0x09; /* Disable stream turn of LED */
 947
 948        reg_w(gspca_dev, 0x01, &stop, 1);
 949
 950        return gspca_dev->usb_err;
 951}
 952
 953static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 954{
 955        struct gspca_dev *gspca_dev =
 956                container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 957        struct sd *sd = (struct sd *)gspca_dev;
 958
 959        gspca_dev->usb_err = 0;
 960
 961        if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
 962                /* when switching to autogain set defaults to make sure
 963                   we are on a valid point of the autogain gain /
 964                   exposure knee graph, and give this change time to
 965                   take effect before doing autogain. */
 966                gspca_dev->gain->val = gspca_dev->gain->default_value;
 967                gspca_dev->exposure->val = gspca_dev->exposure->default_value;
 968                sd->autogain_ignore_frames = AUTOGAIN_IGNORE_FRAMES;
 969        }
 970
 971        if (!gspca_dev->streaming)
 972                return 0;
 973
 974        switch (ctrl->id) {
 975        case V4L2_CID_BRIGHTNESS:
 976                setbrightness(gspca_dev);
 977                break;
 978        case V4L2_CID_AUTOGAIN:
 979                if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
 980                        setexposure(gspca_dev);
 981                if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
 982                        setgain(gspca_dev);
 983                break;
 984        case V4L2_CID_POWER_LINE_FREQUENCY:
 985                setfreq(gspca_dev);
 986                break;
 987        default:
 988                return -EINVAL;
 989        }
 990        return gspca_dev->usb_err;
 991}
 992
 993static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 994        .s_ctrl = sd_s_ctrl,
 995};
 996
 997/* this function is called at probe time */
 998static int sd_init_controls(struct gspca_dev *gspca_dev)
 999{
1000        struct sd *sd = (struct sd *) gspca_dev;
1001        struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1002
1003        gspca_dev->vdev.ctrl_handler = hdl;
1004        v4l2_ctrl_handler_init(hdl, 5);
1005
1006        if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630 ||
1007            sd->sensor == SENSOR_PAS106 || sd->sensor == SENSOR_PAS202)
1008                sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1009                                        V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1010
1011        /* Gain range is sensor dependent */
1012        switch (sd->sensor) {
1013        case SENSOR_OV6650:
1014        case SENSOR_PAS106:
1015        case SENSOR_PAS202:
1016                gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1017                                        V4L2_CID_GAIN, 0, 31, 1, 15);
1018                break;
1019        case SENSOR_OV7630:
1020                gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1021                                        V4L2_CID_GAIN, 0, 47, 1, 31);
1022                break;
1023        case SENSOR_HV7131D:
1024                gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1025                                        V4L2_CID_GAIN, 0, 63, 1, 31);
1026                break;
1027        case SENSOR_TAS5110C:
1028        case SENSOR_TAS5110D:
1029        case SENSOR_TAS5130CXX:
1030                gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1031                                        V4L2_CID_GAIN, 0, 255, 1, 127);
1032                break;
1033        default:
1034                if (sd->bridge == BRIDGE_103) {
1035                        gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1036                                                V4L2_CID_GAIN, 0, 127, 1, 63);
1037                } else {
1038                        gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1039                                                V4L2_CID_GAIN, 0, 15, 1, 7);
1040                }
1041        }
1042
1043        /* Exposure range is sensor dependent, and not all have exposure */
1044        switch (sd->sensor) {
1045        case SENSOR_HV7131D:
1046                gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1047                                        V4L2_CID_EXPOSURE, 0, 8191, 1, 482);
1048                sd->exposure_knee = 964;
1049                break;
1050        case SENSOR_OV6650:
1051        case SENSOR_OV7630:
1052        case SENSOR_PAS106:
1053        case SENSOR_PAS202:
1054                gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1055                                        V4L2_CID_EXPOSURE, 0, 1023, 1, 66);
1056                sd->exposure_knee = 200;
1057                break;
1058        case SENSOR_TAS5110C:
1059        case SENSOR_TAS5110D:
1060                gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1061                                        V4L2_CID_EXPOSURE, 2, 15, 1, 2);
1062                break;
1063        }
1064
1065        if (gspca_dev->exposure) {
1066                gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1067                                                V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1068        }
1069
1070        if (sd->sensor == SENSOR_OV6650 || sd->sensor == SENSOR_OV7630)
1071                sd->plfreq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1072                        V4L2_CID_POWER_LINE_FREQUENCY,
1073                        V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
1074                        V4L2_CID_POWER_LINE_FREQUENCY_DISABLED);
1075
1076        if (hdl->error) {
1077                pr_err("Could not initialize controls\n");
1078                return hdl->error;
1079        }
1080
1081        if (gspca_dev->autogain)
1082                v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
1083
1084        return 0;
1085}
1086
1087/* -- start the camera -- */
1088static int sd_start(struct gspca_dev *gspca_dev)
1089{
1090        struct sd *sd = (struct sd *) gspca_dev;
1091        struct cam *cam = &gspca_dev->cam;
1092        int i, mode;
1093        __u8 regs[0x31];
1094
1095        mode = cam->cam_mode[gspca_dev->curr_mode].priv & 0x07;
1096        /* Copy registers 0x01 - 0x19 from the template */
1097        memcpy(&regs[0x01], sensor_data[sd->sensor].bridge_init, 0x19);
1098        /* Set the mode */
1099        regs[0x18] |= mode << 4;
1100
1101        /* Set bridge gain to 1.0 */
1102        if (sd->bridge == BRIDGE_103) {
1103                regs[0x05] = 0x20; /* Red */
1104                regs[0x06] = 0x20; /* Green */
1105                regs[0x07] = 0x20; /* Blue */
1106        } else {
1107                regs[0x10] = 0x00; /* Red and blue */
1108                regs[0x11] = 0x00; /* Green */
1109        }
1110
1111        /* Setup pixel numbers and auto exposure window */
1112        if (sensor_data[sd->sensor].flags & F_SIF) {
1113                regs[0x1a] = 0x14; /* HO_SIZE 640, makes no sense */
1114                regs[0x1b] = 0x0a; /* VO_SIZE 320, makes no sense */
1115                regs[0x1c] = 0x02; /* AE H-start 64 */
1116                regs[0x1d] = 0x02; /* AE V-start 64 */
1117                regs[0x1e] = 0x09; /* AE H-end 288 */
1118                regs[0x1f] = 0x07; /* AE V-end 224 */
1119        } else {
1120                regs[0x1a] = 0x1d; /* HO_SIZE 960, makes no sense */
1121                regs[0x1b] = 0x10; /* VO_SIZE 512, makes no sense */
1122                regs[0x1c] = 0x05; /* AE H-start 160 */
1123                regs[0x1d] = 0x03; /* AE V-start 96 */
1124                regs[0x1e] = 0x0f; /* AE H-end 480 */
1125                regs[0x1f] = 0x0c; /* AE V-end 384 */
1126        }
1127
1128        /* Setup the gamma table (only used with the sn9c103 bridge) */
1129        for (i = 0; i < 16; i++)
1130                regs[0x20 + i] = i * 16;
1131        regs[0x20 + i] = 255;
1132
1133        /* Special cases where some regs depend on mode or bridge */
1134        switch (sd->sensor) {
1135        case SENSOR_TAS5130CXX:
1136                /* FIXME / TESTME
1137                   probably not mode specific at all most likely the upper
1138                   nibble of 0x19 is exposure (clock divider) just as with
1139                   the tas5110, we need someone to test this. */
1140                regs[0x19] = mode ? 0x23 : 0x43;
1141                break;
1142        case SENSOR_OV7630:
1143                /* FIXME / TESTME for some reason with the 101/102 bridge the
1144                   clock is set to 12 Mhz (reg1 == 0x04), rather then 24.
1145                   Also the hstart needs to go from 1 to 2 when using a 103,
1146                   which is likely related. This does not seem right. */
1147                if (sd->bridge == BRIDGE_103) {
1148                        regs[0x01] = 0x44; /* Select 24 Mhz clock */
1149                        regs[0x12] = 0x02; /* Set hstart to 2 */
1150                }
1151                break;
1152        case SENSOR_PAS202:
1153                /* For some unknown reason we need to increase hstart by 1 on
1154                   the sn9c103, otherwise we get wrong colors (bayer shift). */
1155                if (sd->bridge == BRIDGE_103)
1156                        regs[0x12] += 1;
1157                break;
1158        }
1159        /* Disable compression when the raw bayer format has been selected */
1160        if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW)
1161                regs[0x18] &= ~0x80;
1162
1163        /* Vga mode emulation on SIF sensor? */
1164        if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_REDUCED_SIF) {
1165                regs[0x12] += 16;       /* hstart adjust */
1166                regs[0x13] += 24;       /* vstart adjust */
1167                regs[0x15]  = 320 / 16; /* hsize */
1168                regs[0x16]  = 240 / 16; /* vsize */
1169        }
1170
1171        /* reg 0x01 bit 2 video transfert on */
1172        reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1173        /* reg 0x17 SensorClk enable inv Clk 0x60 */
1174        reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1175        /* Set the registers from the template */
1176        reg_w(gspca_dev, 0x01, &regs[0x01],
1177              (sd->bridge == BRIDGE_103) ? 0x30 : 0x1f);
1178
1179        /* Init the sensor */
1180        i2c_w_vector(gspca_dev, sensor_data[sd->sensor].sensor_init,
1181                        sensor_data[sd->sensor].sensor_init_size);
1182
1183        /* Mode / bridge specific sensor setup */
1184        switch (sd->sensor) {
1185        case SENSOR_PAS202: {
1186                const __u8 i2cpclockdiv[] =
1187                        {0xa0, 0x40, 0x02, 0x03, 0x00, 0x00, 0x00, 0x10};
1188                /* clockdiv from 4 to 3 (7.5 -> 10 fps) when in low res mode */
1189                if (mode)
1190                        i2c_w(gspca_dev, i2cpclockdiv);
1191                break;
1192            }
1193        case SENSOR_OV7630:
1194                /* FIXME / TESTME We should be able to handle this identical
1195                   for the 101/102 and the 103 case */
1196                if (sd->bridge == BRIDGE_103) {
1197                        const __u8 i2c[] = { 0xa0, 0x21, 0x13,
1198                                             0x80, 0x00, 0x00, 0x00, 0x10 };
1199                        i2c_w(gspca_dev, i2c);
1200                }
1201                break;
1202        }
1203        /* H_size V_size 0x28, 0x1e -> 640x480. 0x16, 0x12 -> 352x288 */
1204        reg_w(gspca_dev, 0x15, &regs[0x15], 2);
1205        /* compression register */
1206        reg_w(gspca_dev, 0x18, &regs[0x18], 1);
1207        /* H_start */
1208        reg_w(gspca_dev, 0x12, &regs[0x12], 1);
1209        /* V_START */
1210        reg_w(gspca_dev, 0x13, &regs[0x13], 1);
1211        /* reset 0x17 SensorClk enable inv Clk 0x60 */
1212                                /*fixme: ov7630 [17]=68 8f (+20 if 102)*/
1213        reg_w(gspca_dev, 0x17, &regs[0x17], 1);
1214        /*MCKSIZE ->3 */        /*fixme: not ov7630*/
1215        reg_w(gspca_dev, 0x19, &regs[0x19], 1);
1216        /* AE_STRX AE_STRY AE_ENDX AE_ENDY */
1217        reg_w(gspca_dev, 0x1c, &regs[0x1c], 4);
1218        /* Enable video transfert */
1219        reg_w(gspca_dev, 0x01, &regs[0x01], 1);
1220        /* Compression */
1221        reg_w(gspca_dev, 0x18, &regs[0x18], 2);
1222        msleep(20);
1223
1224        sd->reg11 = -1;
1225
1226        setgain(gspca_dev);
1227        setbrightness(gspca_dev);
1228        setexposure(gspca_dev);
1229        setfreq(gspca_dev);
1230
1231        sd->frames_to_drop = 0;
1232        sd->autogain_ignore_frames = 0;
1233        gspca_dev->exp_too_high_cnt = 0;
1234        gspca_dev->exp_too_low_cnt = 0;
1235        atomic_set(&sd->avg_lum, -1);
1236        return gspca_dev->usb_err;
1237}
1238
1239static void sd_stopN(struct gspca_dev *gspca_dev)
1240{
1241        sd_init(gspca_dev);
1242}
1243
1244static u8* find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
1245{
1246        struct sd *sd = (struct sd *) gspca_dev;
1247        int i, header_size = (sd->bridge == BRIDGE_103) ? 18 : 12;
1248
1249        /* frames start with:
1250         *      ff ff 00 c4 c4 96       synchro
1251         *      00              (unknown)
1252         *      xx              (frame sequence / size / compression)
1253         *      (xx)            (idem - extra byte for sn9c103)
1254         *      ll mm           brightness sum inside auto exposure
1255         *      ll mm           brightness sum outside auto exposure
1256         *      (xx xx xx xx xx)        audio values for snc103
1257         */
1258        for (i = 0; i < len; i++) {
1259                switch (sd->header_read) {
1260                case 0:
1261                        if (data[i] == 0xff)
1262                                sd->header_read++;
1263                        break;
1264                case 1:
1265                        if (data[i] == 0xff)
1266                                sd->header_read++;
1267                        else
1268                                sd->header_read = 0;
1269                        break;
1270                case 2:
1271                        if (data[i] == 0x00)
1272                                sd->header_read++;
1273                        else if (data[i] != 0xff)
1274                                sd->header_read = 0;
1275                        break;
1276                case 3:
1277                        if (data[i] == 0xc4)
1278                                sd->header_read++;
1279                        else if (data[i] == 0xff)
1280                                sd->header_read = 1;
1281                        else
1282                                sd->header_read = 0;
1283                        break;
1284                case 4:
1285                        if (data[i] == 0xc4)
1286                                sd->header_read++;
1287                        else if (data[i] == 0xff)
1288                                sd->header_read = 1;
1289                        else
1290                                sd->header_read = 0;
1291                        break;
1292                case 5:
1293                        if (data[i] == 0x96)
1294                                sd->header_read++;
1295                        else if (data[i] == 0xff)
1296                                sd->header_read = 1;
1297                        else
1298                                sd->header_read = 0;
1299                        break;
1300                default:
1301                        sd->header[sd->header_read - 6] = data[i];
1302                        sd->header_read++;
1303                        if (sd->header_read == header_size) {
1304                                sd->header_read = 0;
1305                                return data + i + 1;
1306                        }
1307                }
1308        }
1309        return NULL;
1310}
1311
1312static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1313                        u8 *data,                       /* isoc packet */
1314                        int len)                        /* iso packet length */
1315{
1316        int fr_h_sz = 0, lum_offset = 0, len_after_sof = 0;
1317        struct sd *sd = (struct sd *) gspca_dev;
1318        struct cam *cam = &gspca_dev->cam;
1319        u8 *sof;
1320
1321        sof = find_sof(gspca_dev, data, len);
1322        if (sof) {
1323                if (sd->bridge == BRIDGE_103) {
1324                        fr_h_sz = 18;
1325                        lum_offset = 3;
1326                } else {
1327                        fr_h_sz = 12;
1328                        lum_offset = 2;
1329                }
1330
1331                len_after_sof = len - (sof - data);
1332                len = (sof - data) - fr_h_sz;
1333                if (len < 0)
1334                        len = 0;
1335        }
1336
1337        if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
1338                /* In raw mode we sometimes get some garbage after the frame
1339                   ignore this */
1340                int used;
1341                int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
1342
1343                used = gspca_dev->image_len;
1344                if (used + len > size)
1345                        len = size - used;
1346        }
1347
1348        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1349
1350        if (sof) {
1351                int  lum = sd->header[lum_offset] +
1352                          (sd->header[lum_offset + 1] << 8);
1353
1354                /* When exposure changes midway a frame we
1355                   get a lum of 0 in this case drop 2 frames
1356                   as the frames directly after an exposure
1357                   change have an unstable image. Sometimes lum
1358                   *really* is 0 (cam used in low light with
1359                   low exposure setting), so do not drop frames
1360                   if the previous lum was 0 too. */
1361                if (lum == 0 && sd->prev_avg_lum != 0) {
1362                        lum = -1;
1363                        sd->frames_to_drop = 2;
1364                        sd->prev_avg_lum = 0;
1365                } else
1366                        sd->prev_avg_lum = lum;
1367                atomic_set(&sd->avg_lum, lum);
1368
1369                if (sd->frames_to_drop)
1370                        sd->frames_to_drop--;
1371                else
1372                        gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
1373
1374                gspca_frame_add(gspca_dev, FIRST_PACKET, sof, len_after_sof);
1375        }
1376}
1377
1378#if IS_ENABLED(CONFIG_INPUT)
1379static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
1380                        u8 *data,               /* interrupt packet data */
1381                        int len)                /* interrupt packet length */
1382{
1383        int ret = -EINVAL;
1384
1385        if (len == 1 && data[0] == 1) {
1386                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
1387                input_sync(gspca_dev->input_dev);
1388                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1389                input_sync(gspca_dev->input_dev);
1390                ret = 0;
1391        }
1392
1393        return ret;
1394}
1395#endif
1396
1397/* sub-driver description */
1398static const struct sd_desc sd_desc = {
1399        .name = MODULE_NAME,
1400        .config = sd_config,
1401        .init = sd_init,
1402        .init_controls = sd_init_controls,
1403        .start = sd_start,
1404        .stopN = sd_stopN,
1405        .pkt_scan = sd_pkt_scan,
1406        .dq_callback = do_autogain,
1407#if IS_ENABLED(CONFIG_INPUT)
1408        .int_pkt_scan = sd_int_pkt_scan,
1409#endif
1410};
1411
1412/* -- module initialisation -- */
1413#define SB(sensor, bridge) \
1414        .driver_info = (SENSOR_ ## sensor << 8) | BRIDGE_ ## bridge
1415
1416
1417static const struct usb_device_id device_table[] = {
1418        {USB_DEVICE(0x0c45, 0x6001), SB(TAS5110C, 102)}, /* TAS5110C1B */
1419        {USB_DEVICE(0x0c45, 0x6005), SB(TAS5110C, 101)}, /* TAS5110C1B */
1420        {USB_DEVICE(0x0c45, 0x6007), SB(TAS5110D, 101)}, /* TAS5110D */
1421        {USB_DEVICE(0x0c45, 0x6009), SB(PAS106, 101)},
1422        {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
1423        {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
1424        {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
1425        {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
1426        {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
1427        {USB_DEVICE(0x0c45, 0x6027), SB(OV7630, 101)}, /* Genius Eye 310 */
1428        {USB_DEVICE(0x0c45, 0x6028), SB(PAS202, 102)},
1429        {USB_DEVICE(0x0c45, 0x6029), SB(PAS106, 102)},
1430        {USB_DEVICE(0x0c45, 0x602a), SB(HV7131D, 102)},
1431        /* {USB_DEVICE(0x0c45, 0x602b), SB(MI0343, 102)}, */
1432        {USB_DEVICE(0x0c45, 0x602c), SB(OV7630, 102)},
1433        {USB_DEVICE(0x0c45, 0x602d), SB(HV7131R, 102)},
1434        {USB_DEVICE(0x0c45, 0x602e), SB(OV7630, 102)},
1435        /* {USB_DEVICE(0x0c45, 0x6030), SB(MI03XX, 102)}, */ /* MI0343 MI0360 MI0330 */
1436        /* {USB_DEVICE(0x0c45, 0x6082), SB(MI03XX, 103)}, */ /* MI0343 MI0360 */
1437        {USB_DEVICE(0x0c45, 0x6083), SB(HV7131D, 103)},
1438        {USB_DEVICE(0x0c45, 0x608c), SB(HV7131R, 103)},
1439        /* {USB_DEVICE(0x0c45, 0x608e), SB(CISVF10, 103)}, */
1440        {USB_DEVICE(0x0c45, 0x608f), SB(OV7630, 103)},
1441        {USB_DEVICE(0x0c45, 0x60a8), SB(PAS106, 103)},
1442        {USB_DEVICE(0x0c45, 0x60aa), SB(TAS5130CXX, 103)},
1443        {USB_DEVICE(0x0c45, 0x60af), SB(PAS202, 103)},
1444        {USB_DEVICE(0x0c45, 0x60b0), SB(OV7630, 103)},
1445        {}
1446};
1447MODULE_DEVICE_TABLE(usb, device_table);
1448
1449/* -- device connect -- */
1450static int sd_probe(struct usb_interface *intf,
1451                        const struct usb_device_id *id)
1452{
1453        return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1454                                THIS_MODULE);
1455}
1456
1457static struct usb_driver sd_driver = {
1458        .name = MODULE_NAME,
1459        .id_table = device_table,
1460        .probe = sd_probe,
1461        .disconnect = gspca_disconnect,
1462#ifdef CONFIG_PM
1463        .suspend = gspca_suspend,
1464        .resume = gspca_resume,
1465        .reset_resume = gspca_resume,
1466#endif
1467};
1468
1469module_usb_driver(sd_driver);
1470