drivers/media/video/ov7670.c

   1 /*
   2  * A V4L2 driver for OmniVision OV7670 cameras.
   3  *
   4  * Copyright 2006 One Laptop Per Child Association, Inc.  Written
   5  * by Jonathan Corbet with substantial inspiration from Mark
   6  * McClelland's ovcamchip code.
   7  *
   8  * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
   9  *
  10  * This file may be distributed under the terms of the GNU General
  11  * Public License, version 2.
  12  */
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/moduleparam.h>
  16 #include <linux/slab.h>
  17 #include <linux/delay.h>
  18 #include <linux/videodev.h>
  19 #include <media/v4l2-common.h>
  20 #include <media/v4l2-chip-ident.h>
  21 #include <linux/i2c.h>
  22
  23
  24 MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
  25 MODULE_DESCRIPTION("A low-level driver for OmniVision ov7670 sensors");
  26 MODULE_LICENSE("GPL");
  27
  28 /*
  29  * Basic window sizes.  These probably belong somewhere more globally
  30  * useful.
  31  */
  32 #define VGA_WIDTH       640
  33 #define VGA_HEIGHT      480
  34 #define QVGA_WIDTH      320
  35 #define QVGA_HEIGHT     240
  36 #define CIF_WIDTH       352
  37 #define CIF_HEIGHT      288
  38 #define QCIF_WIDTH      176
  39 #define QCIF_HEIGHT     144
  40
  41 /*
  42  * Our nominal (default) frame rate.
  43  */
  44 #define OV7670_FRAME_RATE 30
  45
  46 /*
  47  * The 7670 sits on i2c with ID 0x42
  48  */
  49 #define OV7670_I2C_ADDR 0x42
  50
  51 /* Registers */
  52 #define REG_GAIN        0x00    /* Gain lower 8 bits (rest in vref) */
  53 #define REG_BLUE        0x01    /* blue gain */
  54 #define REG_RED         0x02    /* red gain */
  55 #define REG_VREF        0x03    /* Pieces of GAIN, VSTART, VSTOP */
  56 #define REG_COM1        0x04    /* Control 1 */
  57 #define  COM1_CCIR656     0x40  /* CCIR656 enable */
  58 #define REG_BAVE        0x05    /* U/B Average level */
  59 #define REG_GbAVE       0x06    /* Y/Gb Average level */
  60 #define REG_AECHH       0x07    /* AEC MS 5 bits */
  61 #define REG_RAVE        0x08    /* V/R Average level */
  62 #define REG_COM2        0x09    /* Control 2 */
  63 #define  COM2_SSLEEP      0x10  /* Soft sleep mode */
  64 #define REG_PID         0x0a    /* Product ID MSB */
  65 #define REG_VER         0x0b    /* Product ID LSB */
  66 #define REG_COM3        0x0c    /* Control 3 */
  67 #define  COM3_SWAP        0x40    /* Byte swap */
  68 #define  COM3_SCALEEN     0x08    /* Enable scaling */
  69 #define  COM3_DCWEN       0x04    /* Enable downsamp/crop/window */
  70 #define REG_COM4        0x0d    /* Control 4 */
  71 #define REG_COM5        0x0e    /* All "reserved" */
  72 #define REG_COM6        0x0f    /* Control 6 */
  73 #define REG_AECH        0x10    /* More bits of AEC value */
  74 #define REG_CLKRC       0x11    /* Clocl control */
  75 #define   CLK_EXT         0x40    /* Use external clock directly */
  76 #define   CLK_SCALE       0x3f    /* Mask for internal clock scale */
  77 #define REG_COM7        0x12    /* Control 7 */
  78 #define   COM7_RESET      0x80    /* Register reset */
  79 #define   COM7_FMT_MASK   0x38
  80 #define   COM7_FMT_VGA    0x00
  81 #define   COM7_FMT_CIF    0x20    /* CIF format */
  82 #define   COM7_FMT_QVGA   0x10    /* QVGA format */
  83 #define   COM7_FMT_QCIF   0x08    /* QCIF format */
  84 #define   COM7_RGB        0x04    /* bits 0 and 2 - RGB format */
  85 #define   COM7_YUV        0x00    /* YUV */
  86 #define   COM7_BAYER      0x01    /* Bayer format */
  87 #define   COM7_PBAYER     0x05    /* "Processed bayer" */
  88 #define REG_COM8        0x13    /* Control 8 */
  89 #define   COM8_FASTAEC    0x80    /* Enable fast AGC/AEC */
  90 #define   COM8_AECSTEP    0x40    /* Unlimited AEC step size */
  91 #define   COM8_BFILT      0x20    /* Band filter enable */
  92 #define   COM8_AGC        0x04    /* Auto gain enable */
  93 #define   COM8_AWB        0x02    /* White balance enable */
  94 #define   COM8_AEC        0x01    /* Auto exposure enable */
  95 #define REG_COM9        0x14    /* Control 9  - gain ceiling */
  96 #define REG_COM10       0x15    /* Control 10 */
  97 #define   COM10_HSYNC     0x40    /* HSYNC instead of HREF */
  98 #define   COM10_PCLK_HB   0x20    /* Suppress PCLK on horiz blank */
  99 #define   COM10_HREF_REV  0x08    /* Reverse HREF */
 100 #define   COM10_VS_LEAD   0x04    /* VSYNC on clock leading edge */
 101 #define   COM10_VS_NEG    0x02    /* VSYNC negative */
 102 #define   COM10_HS_NEG    0x01    /* HSYNC negative */
 103 #define REG_HSTART      0x17    /* Horiz start high bits */
 104 #define REG_HSTOP       0x18    /* Horiz stop high bits */
 105 #define REG_VSTART      0x19    /* Vert start high bits */
 106 #define REG_VSTOP       0x1a    /* Vert stop high bits */
 107 #define REG_PSHFT       0x1b    /* Pixel delay after HREF */
 108 #define REG_MIDH        0x1c    /* Manuf. ID high */
 109 #define REG_MIDL        0x1d    /* Manuf. ID low */
 110 #define REG_MVFP        0x1e    /* Mirror / vflip */
 111 #define   MVFP_MIRROR     0x20    /* Mirror image */
 112 #define   MVFP_FLIP       0x10    /* Vertical flip */
 113
 114 #define REG_AEW         0x24    /* AGC upper limit */
 115 #define REG_AEB         0x25    /* AGC lower limit */
 116 #define REG_VPT         0x26    /* AGC/AEC fast mode op region */
 117 #define REG_HSYST       0x30    /* HSYNC rising edge delay */
 118 #define REG_HSYEN       0x31    /* HSYNC falling edge delay */
 119 #define REG_HREF        0x32    /* HREF pieces */
 120 #define REG_TSLB        0x3a    /* lots of stuff */
 121 #define   TSLB_YLAST      0x04    /* UYVY or VYUY - see com13 */
 122 #define REG_COM11       0x3b    /* Control 11 */
 123 #define   COM11_NIGHT     0x80    /* NIght mode enable */
 124 #define   COM11_NMFR      0x60    /* Two bit NM frame rate */
 125 #define   COM11_HZAUTO    0x10    /* Auto detect 50/60 Hz */
 126 #define   COM11_50HZ      0x08    /* Manual 50Hz select */
 127 #define   COM11_EXP       0x02
 128 #define REG_COM12       0x3c    /* Control 12 */
 129 #define   COM12_HREF      0x80    /* HREF always */
 130 #define REG_COM13       0x3d    /* Control 13 */
 131 #define   COM13_GAMMA     0x80    /* Gamma enable */
 132 #define   COM13_UVSAT     0x40    /* UV saturation auto adjustment */
 133 #define   COM13_UVSWAP    0x01    /* V before U - w/TSLB */
 134 #define REG_COM14       0x3e    /* Control 14 */
 135 #define   COM14_DCWEN     0x10    /* DCW/PCLK-scale enable */
 136 #define REG_EDGE        0x3f    /* Edge enhancement factor */
 137 #define REG_COM15       0x40    /* Control 15 */
 138 #define   COM15_R10F0     0x00    /* Data range 10 to F0 */
 139 #define   COM15_R01FE     0x80    /*            01 to FE */
 140 #define   COM15_R00FF     0xc0    /*            00 to FF */
 141 #define   COM15_RGB565    0x10    /* RGB565 output */
 142 #define   COM15_RGB555    0x30    /* RGB555 output */
 143 #define REG_COM16       0x41    /* Control 16 */
 144 #define   COM16_AWBGAIN   0x08    /* AWB gain enable */
 145 #define REG_COM17       0x42    /* Control 17 */
 146 #define   COM17_AECWIN    0xc0    /* AEC window - must match COM4 */
 147 #define   COM17_CBAR      0x08    /* DSP Color bar */
 148
 149 /*
 150  * This matrix defines how the colors are generated, must be
 151  * tweaked to adjust hue and saturation.
 152  *
 153  * Order: v-red, v-green, v-blue, u-red, u-green, u-blue
 154  *
 155  * They are nine-bit signed quantities, with the sign bit
 156  * stored in 0x58.  Sign for v-red is bit 0, and up from there.
 157  */
 158 #define REG_CMATRIX_BASE 0x4f
 159 #define   CMATRIX_LEN 6
 160 #define REG_CMATRIX_SIGN 0x58
 161
 162
 163 #define REG_BRIGHT      0x55    /* Brightness */
 164 #define REG_CONTRAS     0x56    /* Contrast control */
 165
 166 #define REG_GFIX        0x69    /* Fix gain control */
 167
 168 #define REG_RGB444      0x8c    /* RGB 444 control */
 169 #define   R444_ENABLE     0x02    /* Turn on RGB444, overrides 5x5 */
 170 #define   R444_RGBX       0x01    /* Empty nibble at end */
 171
 172 #define REG_HAECC1      0x9f    /* Hist AEC/AGC control 1 */
 173 #define REG_HAECC2      0xa0    /* Hist AEC/AGC control 2 */
 174
 175 #define REG_BD50MAX     0xa5    /* 50hz banding step limit */
 176 #define REG_HAECC3      0xa6    /* Hist AEC/AGC control 3 */
 177 #define REG_HAECC4      0xa7    /* Hist AEC/AGC control 4 */
 178 #define REG_HAECC5      0xa8    /* Hist AEC/AGC control 5 */
 179 #define REG_HAECC6      0xa9    /* Hist AEC/AGC control 6 */
 180 #define REG_HAECC7      0xaa    /* Hist AEC/AGC control 7 */
 181 #define REG_BD60MAX     0xab    /* 60hz banding step limit */
 182
 183
 184 /*
 185  * Information we maintain about a known sensor.
 186  */
 187 struct ov7670_format_struct;  /* coming later */
 188 struct ov7670_info {
 189         struct ov7670_format_struct *fmt;  /* Current format */
 190         unsigned char sat;              /* Saturation value */
 191         int hue;                        /* Hue value */
 192 };
 193
 194
 195
 196
 197 /*
 198  * The default register settings, as obtained from OmniVision.  There
 199  * is really no making sense of most of these - lots of "reserved" values
 200  * and such.
 201  *
 202  * These settings give VGA YUYV.
 203  */
 204
 205 struct regval_list {
 206         unsigned char reg_num;
 207         unsigned char value;
 208 };
 209
 210 static struct regval_list ov7670_default_regs[] = {
 211         { REG_COM7, COM7_RESET },
 212 /*
 213  * Clock scale: 3 = 15fps
 214  *              2 = 20fps
 215  *              1 = 30fps
 216  */
 217         { REG_CLKRC, 0x1 },     /* OV: clock scale (30 fps) */
 218         { REG_TSLB,  0x04 },    /* OV */
 219         { REG_COM7, 0 },        /* VGA */
 220         /*
 221          * Set the hardware window.  These values from OV don't entirely
 222          * make sense - hstop is less than hstart.  But they work...
 223          */
 224         { REG_HSTART, 0x13 },   { REG_HSTOP, 0x01 },
 225         { REG_HREF, 0xb6 },     { REG_VSTART, 0x02 },
 226         { REG_VSTOP, 0x7a },    { REG_VREF, 0x0a },
 227
 228         { REG_COM3, 0 },        { REG_COM14, 0 },
 229         /* Mystery scaling numbers */
 230         { 0x70, 0x3a },         { 0x71, 0x35 },
 231         { 0x72, 0x11 },         { 0x73, 0xf0 },
 232         { 0xa2, 0x02 },         { REG_COM10, 0x0 },
 233
 234         /* Gamma curve values */
 235         { 0x7a, 0x20 },         { 0x7b, 0x10 },
 236         { 0x7c, 0x1e },         { 0x7d, 0x35 },
 237         { 0x7e, 0x5a },         { 0x7f, 0x69 },
 238         { 0x80, 0x76 },         { 0x81, 0x80 },
 239         { 0x82, 0x88 },         { 0x83, 0x8f },
 240         { 0x84, 0x96 },         { 0x85, 0xa3 },
 241         { 0x86, 0xaf },         { 0x87, 0xc4 },
 242         { 0x88, 0xd7 },         { 0x89, 0xe8 },
 243
 244         /* AGC and AEC parameters.  Note we start by disabling those features,
 245            then turn them only after tweaking the values. */
 246         { REG_COM8, COM8_FASTAEC | COM8_AECSTEP | COM8_BFILT },
 247         { REG_GAIN, 0 },        { REG_AECH, 0 },
 248         { REG_COM4, 0x40 }, /* magic reserved bit */
 249         { REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
 250         { REG_BD50MAX, 0x05 },  { REG_BD60MAX, 0x07 },
 251         { REG_AEW, 0x95 },      { REG_AEB, 0x33 },
 252         { REG_VPT, 0xe3 },      { REG_HAECC1, 0x78 },
 253         { REG_HAECC2, 0x68 },   { 0xa1, 0x03 }, /* magic */
 254         { REG_HAECC3, 0xd8 },   { REG_HAECC4, 0xd8 },
 255         { REG_HAECC5, 0xf0 },   { REG_HAECC6, 0x90 },
 256         { REG_HAECC7, 0x94 },
 257         { REG_COM8, COM8_FASTAEC|COM8_AECSTEP|COM8_BFILT|COM8_AGC|COM8_AEC },
 258
 259         /* Almost all of these are magic "reserved" values.  */
 260         { REG_COM5, 0x61 },     { REG_COM6, 0x4b },
 261         { 0x16, 0x02 },         { REG_MVFP, 0x07 },
 262         { 0x21, 0x02 },         { 0x22, 0x91 },
 263         { 0x29, 0x07 },         { 0x33, 0x0b },
 264         { 0x35, 0x0b },         { 0x37, 0x1d },
 265         { 0x38, 0x71 },         { 0x39, 0x2a },
 266         { REG_COM12, 0x78 },    { 0x4d, 0x40 },
 267         { 0x4e, 0x20 },         { REG_GFIX, 0 },
 268         { 0x6b, 0x4a },         { 0x74, 0x10 },
 269         { 0x8d, 0x4f },         { 0x8e, 0 },
 270         { 0x8f, 0 },            { 0x90, 0 },
 271         { 0x91, 0 },            { 0x96, 0 },
 272         { 0x9a, 0 },            { 0xb0, 0x84 },
 273         { 0xb1, 0x0c },         { 0xb2, 0x0e },
 274         { 0xb3, 0x82 },         { 0xb8, 0x0a },
 275
 276         /* More reserved magic, some of which tweaks white balance */
 277         { 0x43, 0x0a },         { 0x44, 0xf0 },
 278         { 0x45, 0x34 },         { 0x46, 0x58 },
 279         { 0x47, 0x28 },         { 0x48, 0x3a },
 280         { 0x59, 0x88 },         { 0x5a, 0x88 },
 281         { 0x5b, 0x44 },         { 0x5c, 0x67 },
 282         { 0x5d, 0x49 },         { 0x5e, 0x0e },
 283         { 0x6c, 0x0a },         { 0x6d, 0x55 },
 284         { 0x6e, 0x11 },         { 0x6f, 0x9f }, /* "9e for advance AWB" */
 285         { 0x6a, 0x40 },         { REG_BLUE, 0x40 },
 286         { REG_RED, 0x60 },
 287         { REG_COM8, COM8_FASTAEC|COM8_AECSTEP|COM8_BFILT|COM8_AGC|COM8_AEC|COM8_AWB },
 288
 289         /* Matrix coefficients */
 290         { 0x4f, 0x80 },         { 0x50, 0x80 },
 291         { 0x51, 0 },            { 0x52, 0x22 },
 292         { 0x53, 0x5e },         { 0x54, 0x80 },
 293         { 0x58, 0x9e },
 294
 295         { REG_COM16, COM16_AWBGAIN },   { REG_EDGE, 0 },
 296         { 0x75, 0x05 },         { 0x76, 0xe1 },
 297         { 0x4c, 0 },            { 0x77, 0x01 },
 298         { REG_COM13, 0xc3 },    { 0x4b, 0x09 },
 299         { 0xc9, 0x60 },         { REG_COM16, 0x38 },
 300         { 0x56, 0x40 },
 301
 302         { 0x34, 0x11 },         { REG_COM11, COM11_EXP|COM11_HZAUTO },
 303         { 0xa4, 0x88 },         { 0x96, 0 },
 304         { 0x97, 0x30 },         { 0x98, 0x20 },
 305         { 0x99, 0x30 },         { 0x9a, 0x84 },
 306         { 0x9b, 0x29 },         { 0x9c, 0x03 },
 307         { 0x9d, 0x4c },         { 0x9e, 0x3f },
 308         { 0x78, 0x04 },
 309
 310         /* Extra-weird stuff.  Some sort of multiplexor register */
 311         { 0x79, 0x01 },         { 0xc8, 0xf0 },
 312         { 0x79, 0x0f },         { 0xc8, 0x00 },
 313         { 0x79, 0x10 },         { 0xc8, 0x7e },
 314         { 0x79, 0x0a },         { 0xc8, 0x80 },
 315         { 0x79, 0x0b },         { 0xc8, 0x01 },
 316         { 0x79, 0x0c },         { 0xc8, 0x0f },
 317         { 0x79, 0x0d },         { 0xc8, 0x20 },
 318         { 0x79, 0x09 },         { 0xc8, 0x80 },
 319         { 0x79, 0x02 },         { 0xc8, 0xc0 },
 320         { 0x79, 0x03 },         { 0xc8, 0x40 },
 321         { 0x79, 0x05 },         { 0xc8, 0x30 },
 322         { 0x79, 0x26 },
 323
 324         { 0xff, 0xff }, /* END MARKER */
 325 };
 326
 327
 328 /*
 329  * Here we'll try to encapsulate the changes for just the output
 330  * video format.
 331  *
 332  * RGB656 and YUV422 come from OV; RGB444 is homebrewed.
 333  *
 334  * IMPORTANT RULE: the first entry must be for COM7, see ov7670_s_fmt for why.
 335  */
 336
 337
 338 static struct regval_list ov7670_fmt_yuv422[] = {
 339         { REG_COM7, 0x0 },  /* Selects YUV mode */
 340         { REG_RGB444, 0 },      /* No RGB444 please */
 341         { REG_COM1, 0 },
 342         { REG_COM15, COM15_R00FF },
 343         { REG_COM9, 0x18 }, /* 4x gain ceiling; 0x8 is reserved bit */
 344         { 0x4f, 0x80 },         /* "matrix coefficient 1" */
 345         { 0x50, 0x80 },         /* "matrix coefficient 2" */
 346         { 0x51, 0    },         /* vb */
 347         { 0x52, 0x22 },         /* "matrix coefficient 4" */
 348         { 0x53, 0x5e },         /* "matrix coefficient 5" */
 349         { 0x54, 0x80 },         /* "matrix coefficient 6" */
 350         { REG_COM13, COM13_GAMMA|COM13_UVSAT },
 351         { 0xff, 0xff },
 352 };
 353
 354 static struct regval_list ov7670_fmt_rgb565[] = {
 355         { REG_COM7, COM7_RGB }, /* Selects RGB mode */
 356         { REG_RGB444, 0 },      /* No RGB444 please */
 357         { REG_COM1, 0x0 },
 358         { REG_COM15, COM15_RGB565 },
 359         { REG_COM9, 0x38 },     /* 16x gain ceiling; 0x8 is reserved bit */
 360         { 0x4f, 0xb3 },         /* "matrix coefficient 1" */
 361         { 0x50, 0xb3 },         /* "matrix coefficient 2" */
 362         { 0x51, 0    },         /* vb */
 363         { 0x52, 0x3d },         /* "matrix coefficient 4" */
 364         { 0x53, 0xa7 },         /* "matrix coefficient 5" */
 365         { 0x54, 0xe4 },         /* "matrix coefficient 6" */
 366         { REG_COM13, COM13_GAMMA|COM13_UVSAT },
 367         { 0xff, 0xff },
 368 };
 369
 370 static struct regval_list ov7670_fmt_rgb444[] = {
 371         { REG_COM7, COM7_RGB }, /* Selects RGB mode */
 372         { REG_RGB444, R444_ENABLE },    /* Enable xxxxrrrr ggggbbbb */
 373         { REG_COM1, 0x40 },     /* Magic reserved bit */
 374         { REG_COM15, COM15_R01FE|COM15_RGB565 }, /* Data range needed? */
 375         { REG_COM9, 0x38 },     /* 16x gain ceiling; 0x8 is reserved bit */
 376         { 0x4f, 0xb3 },         /* "matrix coefficient 1" */
 377         { 0x50, 0xb3 },         /* "matrix coefficient 2" */
 378         { 0x51, 0    },         /* vb */
 379         { 0x52, 0x3d },         /* "matrix coefficient 4" */
 380         { 0x53, 0xa7 },         /* "matrix coefficient 5" */
 381         { 0x54, 0xe4 },         /* "matrix coefficient 6" */
 382         { REG_COM13, COM13_GAMMA|COM13_UVSAT|0x2 },  /* Magic rsvd bit */
 383         { 0xff, 0xff },
 384 };
 385
 386
 387
 388
 389 /*
 390  * Low-level register I/O.
 391  */
 392
 393 static int ov7670_read(struct i2c_client *c, unsigned char reg,
 394                 unsigned char *value)
 395 {
 396         int ret;
 397
 398         ret = i2c_smbus_read_byte_data(c, reg);
 399         if (ret >= 0)
 400                 *value = (unsigned char) ret;
 401         return ret;
 402 }
 403
 404
 405 static int ov7670_write(struct i2c_client *c, unsigned char reg,
 406                 unsigned char value)
 407 {
 408         return i2c_smbus_write_byte_data(c, reg, value);
 409 }
 410
 411
 412 /*
 413  * Write a list of register settings; ff/ff stops the process.
 414  */
 415 static int ov7670_write_array(struct i2c_client *c, struct regval_list *vals)
 416 {
 417         while (vals->reg_num != 0xff || vals->value != 0xff) {
 418                 int ret = ov7670_write(c, vals->reg_num, vals->value);
 419                 if (ret < 0)
 420                         return ret;
 421                 vals++;
 422         }
 423         return 0;
 424 }
 425
 426
 427 /*
 428  * Stuff that knows about the sensor.
 429  */
 430 static void ov7670_reset(struct i2c_client *client)
 431 {
 432         ov7670_write(client, REG_COM7, COM7_RESET);
 433         msleep(1);
 434 }
 435
 436
 437 static int ov7670_init(struct i2c_client *client)
 438 {
 439         return ov7670_write_array(client, ov7670_default_regs);
 440 }
 441
 442
 443
 444 static int ov7670_detect(struct i2c_client *client)
 445 {
 446         unsigned char v;
 447         int ret;
 448
 449         ret = ov7670_init(client);
 450         if (ret < 0)
 451                 return ret;
 452         ret = ov7670_read(client, REG_MIDH, &v);
 453         if (ret < 0)
 454                 return ret;
 455         if (v != 0x7f) /* OV manuf. id. */
 456                 return -ENODEV;
 457         ret = ov7670_read(client, REG_MIDL, &v);
 458         if (ret < 0)
 459                 return ret;
 460         if (v != 0xa2)
 461                 return -ENODEV;
 462         /*
 463          * OK, we know we have an OmniVision chip...but which one?
 464          */
 465         ret = ov7670_read(client, REG_PID, &v);
 466         if (ret < 0)
 467                 return ret;
 468         if (v != 0x76)  /* PID + VER = 0x76 / 0x73 */
 469                 return -ENODEV;
 470         ret = ov7670_read(client, REG_VER, &v);
 471         if (ret < 0)
 472                 return ret;
 473         if (v != 0x73)  /* PID + VER = 0x76 / 0x73 */
 474                 return -ENODEV;
 475         return 0;
 476 }
 477
 478
 479 /*
 480  * Store information about the video data format.  The color matrix
 481  * is deeply tied into the format, so keep the relevant values here.
 482  * The magic matrix nubmers come from OmniVision.
 483  */
 484 static struct ov7670_format_struct {
 485         __u8 *desc;
 486         __u32 pixelformat;
 487         struct regval_list *regs;
 488         int cmatrix[CMATRIX_LEN];
 489 } ov7670_formats[] = {
 490         {
 491                 .desc           = "YUYV 4:2:2",
 492                 .pixelformat    = V4L2_PIX_FMT_YUYV,
 493                 .regs           = ov7670_fmt_yuv422,
 494                 .cmatrix        = { 128, -128, 0, -34, -94, 128 },
 495         },
 496         {
 497                 .desc           = "RGB 444",
 498                 .pixelformat    = V4L2_PIX_FMT_RGB444,
 499                 .regs           = ov7670_fmt_rgb444,
 500                 .cmatrix        = { 179, -179, 0, -61, -176, 228 },
 501         },
 502         {
 503                 .desc           = "RGB 565",
 504                 .pixelformat    = V4L2_PIX_FMT_RGB565,
 505                 .regs           = ov7670_fmt_rgb565,
 506                 .cmatrix        = { 179, -179, 0, -61, -176, 228 },
 507         },
 508 };
 509 #define N_OV7670_FMTS (sizeof(ov7670_formats)/sizeof(ov7670_formats[0]))
 510
 511 /*
 512  * All formats we support are 2 bytes/pixel.
 513  */
 514 #define BYTES_PER_PIXEL 2
 515
 516 /*
 517  * Then there is the issue of window sizes.  Try to capture the info here.
 518  */
 519
 520 /*
 521  * QCIF mode is done (by OV) in a very strange way - it actually looks like
 522  * VGA with weird scaling options - they do *not* use the canned QCIF mode
 523  * which is allegedly provided by the sensor.  So here's the weird register
 524  * settings.
 525  */
 526 static struct regval_list ov7670_qcif_regs[] = {
 527         { REG_COM3, COM3_SCALEEN|COM3_DCWEN },
 528         { REG_COM3, COM3_DCWEN },
 529         { REG_COM14, COM14_DCWEN | 0x01},
 530         { 0x73, 0xf1 },
 531         { 0xa2, 0x52 },
 532         { 0x7b, 0x1c },
 533         { 0x7c, 0x28 },
 534         { 0x7d, 0x3c },
 535         { 0x7f, 0x69 },
 536         { REG_COM9, 0x38 },
 537         { 0xa1, 0x0b },
 538         { 0x74, 0x19 },
 539         { 0x9a, 0x80 },
 540         { 0x43, 0x14 },
 541         { REG_COM13, 0xc0 },
 542         { 0xff, 0xff },
 543 };
 544
 545 static struct ov7670_win_size {
 546         int     width;
 547         int     height;
 548         unsigned char com7_bit;
 549         int     hstart;         /* Start/stop values for the camera.  Note */
 550         int     hstop;          /* that they do not always make complete */
 551         int     vstart;         /* sense to humans, but evidently the sensor */
 552         int     vstop;          /* will do the right thing... */
 553         struct regval_list *regs; /* Regs to tweak */
 554 /* h/vref stuff */
 555 } ov7670_win_sizes[] = {
 556         /* VGA */
 557         {
 558                 .width          = VGA_WIDTH,
 559                 .height         = VGA_HEIGHT,
 560                 .com7_bit       = COM7_FMT_VGA,
 561                 .hstart         = 158,          /* These values from */
 562                 .hstop          =  14,          /* Omnivision */
 563                 .vstart         =  10,
 564                 .vstop          = 490,
 565                 .regs           = NULL,
 566         },
 567         /* CIF */
 568         {
 569                 .width          = CIF_WIDTH,
 570                 .height         = CIF_HEIGHT,
 571                 .com7_bit       = COM7_FMT_CIF,
 572                 .hstart         = 170,          /* Empirically determined */
 573                 .hstop          =  90,
 574                 .vstart         =  14,
 575                 .vstop          = 494,
 576                 .regs           = NULL,
 577         },
 578         /* QVGA */
 579         {
 580                 .width          = QVGA_WIDTH,
 581                 .height         = QVGA_HEIGHT,
 582                 .com7_bit       = COM7_FMT_QVGA,
 583                 .hstart         = 164,          /* Empirically determined */
 584                 .hstop          =  20,
 585                 .vstart         =  14,
 586                 .vstop          = 494,
 587                 .regs           = NULL,
 588         },
 589         /* QCIF */
 590         {
 591                 .width          = QCIF_WIDTH,
 592                 .height         = QCIF_HEIGHT,
 593                 .com7_bit       = COM7_FMT_VGA, /* see comment above */
 594                 .hstart         = 456,          /* Empirically determined */
 595                 .hstop          =  24,
 596                 .vstart         =  14,
 597                 .vstop          = 494,
 598                 .regs           = ov7670_qcif_regs,
 599         },
 600 };
 601
 602 #define N_WIN_SIZES (sizeof(ov7670_win_sizes)/sizeof(ov7670_win_sizes[0]))
 603
 604
 605 /*
 606  * Store a set of start/stop values into the camera.
 607  */
 608 static int ov7670_set_hw(struct i2c_client *client, int hstart, int hstop,
 609                 int vstart, int vstop)
 610 {
 611         int ret;
 612         unsigned char v;
 613 /*
 614  * Horizontal: 11 bits, top 8 live in hstart and hstop.  Bottom 3 of
 615  * hstart are in href[2:0], bottom 3 of hstop in href[5:3].  There is
 616  * a mystery "edge offset" value in the top two bits of href.
 617  */
 618         ret =  ov7670_write(client, REG_HSTART, (hstart >> 3) & 0xff);
 619         ret += ov7670_write(client, REG_HSTOP, (hstop >> 3) & 0xff);
 620         ret += ov7670_read(client, REG_HREF, &v);
 621         v = (v & 0xc0) | ((hstop & 0x7) << 3) | (hstart & 0x7);
 622         msleep(10);
 623         ret += ov7670_write(client, REG_HREF, v);
 624 /*
 625  * Vertical: similar arrangement, but only 10 bits.
 626  */
 627         ret += ov7670_write(client, REG_VSTART, (vstart >> 2) & 0xff);
 628         ret += ov7670_write(client, REG_VSTOP, (vstop >> 2) & 0xff);
 629         ret += ov7670_read(client, REG_VREF, &v);
 630         v = (v & 0xf0) | ((vstop & 0x3) << 2) | (vstart & 0x3);
 631         msleep(10);
 632         ret += ov7670_write(client, REG_VREF, v);
 633         return ret;
 634 }
 635
 636
 637 static int ov7670_enum_fmt(struct i2c_client *c, struct v4l2_fmtdesc *fmt)
 638 {
 639         struct ov7670_format_struct *ofmt;
 640
 641         if (fmt->index >= N_OV7670_FMTS)
 642                 return -EINVAL;
 643
 644         ofmt = ov7670_formats + fmt->index;
 645         fmt->flags = 0;
 646         strcpy(fmt->description, ofmt->desc);
 647         fmt->pixelformat = ofmt->pixelformat;
 648         return 0;
 649 }
 650
 651
 652 static int ov7670_try_fmt(struct i2c_client *c, struct v4l2_format *fmt,
 653                 struct ov7670_format_struct **ret_fmt,
 654                 struct ov7670_win_size **ret_wsize)
 655 {
 656         int index;
 657         struct ov7670_win_size *wsize;
 658         struct v4l2_pix_format *pix = &fmt->fmt.pix;
 659
 660         for (index = 0; index < N_OV7670_FMTS; index++)
 661                 if (ov7670_formats[index].pixelformat == pix->pixelformat)
 662                         break;
 663         if (index >= N_OV7670_FMTS)
 664                 return -EINVAL;
 665         if (ret_fmt != NULL)
 666                 *ret_fmt = ov7670_formats + index;
 667         /*
 668          * Fields: the OV devices claim to be progressive.
 669          */
 670         if (pix->field == V4L2_FIELD_ANY)
 671                 pix->field = V4L2_FIELD_NONE;
 672         else if (pix->field != V4L2_FIELD_NONE)
 673                 return -EINVAL;
 674         /*
 675          * Round requested image size down to the nearest
 676          * we support, but not below the smallest.
 677          */
 678         for (wsize = ov7670_win_sizes; wsize < ov7670_win_sizes + N_WIN_SIZES;
 679              wsize++)
 680                 if (pix->width >= wsize->width && pix->height >= wsize->height)
 681                         break;
 682         if (wsize >= ov7670_win_sizes + N_WIN_SIZES)
 683                 wsize--;   /* Take the smallest one */
 684         if (ret_wsize != NULL)
 685                 *ret_wsize = wsize;
 686         /*
 687          * Note the size we'll actually handle.
 688          */
 689         pix->width = wsize->width;
 690         pix->height = wsize->height;
 691         pix->bytesperline = pix->width*BYTES_PER_PIXEL;
 692         pix->sizeimage = pix->height*pix->bytesperline;
 693         return 0;
 694 }
 695
 696 /*
 697  * Set a format.
 698  */
 699 static int ov7670_s_fmt(struct i2c_client *c, struct v4l2_format *fmt)
 700 {
 701         int ret;
 702         struct ov7670_format_struct *ovfmt;
 703         struct ov7670_win_size *wsize;
 704         struct ov7670_info *info = i2c_get_clientdata(c);
 705         unsigned char com7;
 706
 707         ret = ov7670_try_fmt(c, fmt, &ovfmt, &wsize);
 708         if (ret)
 709                 return ret;
 710         /*
 711          * COM7 is a pain in the ass, it doesn't like to be read then
 712          * quickly written afterward.  But we have everything we need
 713          * to set it absolutely here, as long as the format-specific
 714          * register sets list it first.
 715          */
 716         com7 = ovfmt->regs[0].value;
 717         com7 |= wsize->com7_bit;
 718         ov7670_write(c, REG_COM7, com7);
 719         /*
 720          * Now write the rest of the array.  Also store start/stops
 721          */
 722         ov7670_write_array(c, ovfmt->regs + 1);
 723         ov7670_set_hw(c, wsize->hstart, wsize->hstop, wsize->vstart,
 724                         wsize->vstop);
 725         ret = 0;
 726         if (wsize->regs)
 727                 ret = ov7670_write_array(c, wsize->regs);
 728         info->fmt = ovfmt;
 729         return 0;
 730 }
 731
 732 /*
 733  * Implement G/S_PARM.  There is a "high quality" mode we could try
 734  * to do someday; for now, we just do the frame rate tweak.
 735  */
 736 static int ov7670_g_parm(struct i2c_client *c, struct v4l2_streamparm *parms)
 737 {
 738         struct v4l2_captureparm *cp = &parms->parm.capture;
 739         unsigned char clkrc;
 740         int ret;
 741
 742         if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 743                 return -EINVAL;
 744         ret = ov7670_read(c, REG_CLKRC, &clkrc);
 745         if (ret < 0)
 746                 return ret;
 747         memset(cp, 0, sizeof(struct v4l2_captureparm));
 748         cp->capability = V4L2_CAP_TIMEPERFRAME;
 749         cp->timeperframe.numerator = 1;
 750         cp->timeperframe.denominator = OV7670_FRAME_RATE;
 751         if ((clkrc & CLK_EXT) == 0 && (clkrc & CLK_SCALE) > 1)
 752                 cp->timeperframe.denominator /= (clkrc & CLK_SCALE);
 753         return 0;
 754 }
 755
 756 static int ov7670_s_parm(struct i2c_client *c, struct v4l2_streamparm *parms)
 757 {
 758         struct v4l2_captureparm *cp = &parms->parm.capture;
 759         struct v4l2_fract *tpf = &cp->timeperframe;
 760         unsigned char clkrc;
 761         int ret, div;
 762
 763         if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 764                 return -EINVAL;
 765         if (cp->extendedmode != 0)
 766                 return -EINVAL;
 767         /*
 768          * CLKRC has a reserved bit, so let's preserve it.
 769          */
 770         ret = ov7670_read(c, REG_CLKRC, &clkrc);
 771         if (ret < 0)
 772                 return ret;
 773         if (tpf->numerator == 0 || tpf->denominator == 0)
 774                 div = 1;  /* Reset to full rate */
 775         else
 776                 div = (tpf->numerator*OV7670_FRAME_RATE)/tpf->denominator;
 777         if (div == 0)
 778                 div = 1;
 779         else if (div > CLK_SCALE)
 780                 div = CLK_SCALE;
 781         clkrc = (clkrc & 0x80) | div;
 782         tpf->numerator = 1;
 783         tpf->denominator = OV7670_FRAME_RATE/div;
 784         return ov7670_write(c, REG_CLKRC, clkrc);
 785 }
 786
 787
 788
 789 /*
 790  * Code for dealing with controls.
 791  */
 792
 793
 794
 795
 796
 797 static int ov7670_store_cmatrix(struct i2c_client *client,
 798                 int matrix[CMATRIX_LEN])
 799 {
 800         int i, ret;
 801         unsigned char signbits;
 802
 803         /*
 804          * Weird crap seems to exist in the upper part of
 805          * the sign bits register, so let's preserve it.
 806          */
 807         ret = ov7670_read(client, REG_CMATRIX_SIGN, &signbits);
 808         signbits &= 0xc0;
 809
 810         for (i = 0; i < CMATRIX_LEN; i++) {
 811                 unsigned char raw;
 812
 813                 if (matrix[i] < 0) {
 814                         signbits |= (1 << i);
 815                         if (matrix[i] < -255)
 816                                 raw = 0xff;
 817                         else
 818                                 raw = (-1 * matrix[i]) & 0xff;
 819                 }
 820                 else {
 821                         if (matrix[i] > 255)
 822                                 raw = 0xff;
 823                         else
 824                                 raw = matrix[i] & 0xff;
 825                 }
 826                 ret += ov7670_write(client, REG_CMATRIX_BASE + i, raw);
 827         }
 828         ret += ov7670_write(client, REG_CMATRIX_SIGN, signbits);
 829         return ret;
 830 }
 831
 832
 833 /*
 834  * Hue also requires messing with the color matrix.  It also requires
 835  * trig functions, which tend not to be well supported in the kernel.
 836  * So here is a simple table of sine values, 0-90 degrees, in steps
 837  * of five degrees.  Values are multiplied by 1000.
 838  *
 839  * The following naive approximate trig functions require an argument
 840  * carefully limited to -180 <= theta <= 180.
 841  */
 842 #define SIN_STEP 5
 843 static const int ov7670_sin_table[] = {
 844            0,    87,   173,   258,   342,   422,
 845          499,   573,   642,   707,   766,   819,
 846          866,   906,   939,   965,   984,   996,
 847         1000
 848 };
 849
 850 static int ov7670_sine(int theta)
 851 {
 852         int chs = 1;
 853         int sine;
 854
 855         if (theta < 0) {
 856                 theta = -theta;
 857                 chs = -1;
 858         }
 859         if (theta <= 90)
 860                 sine = ov7670_sin_table[theta/SIN_STEP];
 861         else {
 862                 theta -= 90;
 863                 sine = 1000 - ov7670_sin_table[theta/SIN_STEP];
 864         }
 865         return sine*chs;
 866 }
 867
 868 static int ov7670_cosine(int theta)
 869 {
 870         theta = 90 - theta;
 871         if (theta > 180)
 872                 theta -= 360;
 873         else if (theta < -180)
 874                 theta += 360;
 875         return ov7670_sine(theta);
 876 }
 877
 878
 879
 880
 881 static void ov7670_calc_cmatrix(struct ov7670_info *info,
 882                 int matrix[CMATRIX_LEN])
 883 {
 884         int i;
 885         /*
 886          * Apply the current saturation setting first.
 887          */
 888         for (i = 0; i < CMATRIX_LEN; i++)
 889                 matrix[i] = (info->fmt->cmatrix[i]*info->sat) >> 7;
 890         /*
 891          * Then, if need be, rotate the hue value.
 892          */
 893         if (info->hue != 0) {
 894                 int sinth, costh, tmpmatrix[CMATRIX_LEN];
 895
 896                 memcpy(tmpmatrix, matrix, CMATRIX_LEN*sizeof(int));
 897                 sinth = ov7670_sine(info->hue);
 898                 costh = ov7670_cosine(info->hue);
 899
 900                 matrix[0] = (matrix[3]*sinth + matrix[0]*costh)/1000;
 901                 matrix[1] = (matrix[4]*sinth + matrix[1]*costh)/1000;
 902                 matrix[2] = (matrix[5]*sinth + matrix[2]*costh)/1000;
 903                 matrix[3] = (matrix[3]*costh - matrix[0]*sinth)/1000;
 904                 matrix[4] = (matrix[4]*costh - matrix[1]*sinth)/1000;
 905                 matrix[5] = (matrix[5]*costh - matrix[2]*sinth)/1000;
 906         }
 907 }
 908
 909
 910
 911 static int ov7670_t_sat(struct i2c_client *client, int value)
 912 {
 913         struct ov7670_info *info = i2c_get_clientdata(client);
 914         int matrix[CMATRIX_LEN];
 915         int ret;
 916
 917         info->sat = value;
 918         ov7670_calc_cmatrix(info, matrix);
 919         ret = ov7670_store_cmatrix(client, matrix);
 920         return ret;
 921 }
 922
 923 static int ov7670_q_sat(struct i2c_client *client, __s32 *value)
 924 {
 925         struct ov7670_info *info = i2c_get_clientdata(client);
 926
 927         *value = info->sat;
 928         return 0;
 929 }
 930
 931 static int ov7670_t_hue(struct i2c_client *client, int value)
 932 {
 933         struct ov7670_info *info = i2c_get_clientdata(client);
 934         int matrix[CMATRIX_LEN];
 935         int ret;
 936
 937         if (value < -180 || value > 180)
 938                 return -EINVAL;
 939         info->hue = value;
 940         ov7670_calc_cmatrix(info, matrix);
 941         ret = ov7670_store_cmatrix(client, matrix);
 942         return ret;
 943 }
 944
 945
 946 static int ov7670_q_hue(struct i2c_client *client, __s32 *value)
 947 {
 948         struct ov7670_info *info = i2c_get_clientdata(client);
 949
 950         *value = info->hue;
 951         return 0;
 952 }
 953
 954
 955 /*
 956  * Some weird registers seem to store values in a sign/magnitude format!
 957  */
 958 static unsigned char ov7670_sm_to_abs(unsigned char v)
 959 {
 960         if ((v & 0x80) == 0)
 961                 return v + 128;
 962         else
 963                 return 128 - (v & 0x7f);
 964 }
 965
 966
 967 static unsigned char ov7670_abs_to_sm(unsigned char v)
 968 {
 969         if (v > 127)
 970                 return v & 0x7f;
 971         else
 972                 return (128 - v) | 0x80;
 973 }
 974
 975 static int ov7670_t_brightness(struct i2c_client *client, int value)
 976 {
 977         unsigned char com8, v;
 978         int ret;
 979
 980         ov7670_read(client, REG_COM8, &com8);
 981         com8 &= ~COM8_AEC;
 982         ov7670_write(client, REG_COM8, com8);
 983         v = ov7670_abs_to_sm(value);
 984         ret = ov7670_write(client, REG_BRIGHT, v);
 985         return ret;
 986 }
 987
 988 static int ov7670_q_brightness(struct i2c_client *client, __s32 *value)
 989 {
 990         unsigned char v;
 991         int ret = ov7670_read(client, REG_BRIGHT, &v);
 992
 993         *value = ov7670_sm_to_abs(v);
 994         return ret;
 995 }
 996
 997 static int ov7670_t_contrast(struct i2c_client *client, int value)
 998 {
 999         return ov7670_write(client, REG_CONTRAS, (unsigned char) value);
1000 }
1001
1002 static int ov7670_q_contrast(struct i2c_client *client, __s32 *value)
1003 {
1004         unsigned char v;
1005         int ret = ov7670_read(client, REG_CONTRAS, &v);
1006
1007         *value = v;
1008         return ret;
1009 }
1010
1011 static int ov7670_q_hflip(struct i2c_client *client, __s32 *value)
1012 {
1013         int ret;
1014         unsigned char v;
1015
1016         ret = ov7670_read(client, REG_MVFP, &v);
1017         *value = (v & MVFP_MIRROR) == MVFP_MIRROR;
1018         return ret;
1019 }
1020
1021
1022 static int ov7670_t_hflip(struct i2c_client *client, int value)
1023 {
1024         unsigned char v;
1025         int ret;
1026
1027         ret = ov7670_read(client, REG_MVFP, &v);
1028         if (value)
1029                 v |= MVFP_MIRROR;
1030         else
1031                 v &= ~MVFP_MIRROR;
1032         msleep(10);  /* FIXME */
1033         ret += ov7670_write(client, REG_MVFP, v);
1034         return ret;
1035 }
1036
1037
1038
1039 static int ov7670_q_vflip(struct i2c_client *client, __s32 *value)
1040 {
1041         int ret;
1042         unsigned char v;
1043
1044         ret = ov7670_read(client, REG_MVFP, &v);
1045         *value = (v & MVFP_FLIP) == MVFP_FLIP;
1046         return ret;
1047 }
1048
1049
1050 static int ov7670_t_vflip(struct i2c_client *client, int value)
1051 {
1052         unsigned char v;
1053         int ret;
1054
1055         ret = ov7670_read(client, REG_MVFP, &v);
1056         if (value)
1057                 v |= MVFP_FLIP;
1058         else
1059                 v &= ~MVFP_FLIP;
1060         msleep(10);  /* FIXME */
1061         ret += ov7670_write(client, REG_MVFP, v);
1062         return ret;
1063 }
1064
1065
1066 static struct ov7670_control {
1067         struct v4l2_queryctrl qc;
1068         int (*query)(struct i2c_client *c, __s32 *value);
1069         int (*tweak)(struct i2c_client *c, int value);
1070 } ov7670_controls[] =
1071 {
1072         {
1073                 .qc = {
1074                         .id = V4L2_CID_BRIGHTNESS,
1075                         .type = V4L2_CTRL_TYPE_INTEGER,
1076                         .name = "Brightness",
1077                         .minimum = 0,
1078                         .maximum = 255,
1079                         .step = 1,
1080                         .default_value = 0x80,
1081                         .flags = V4L2_CTRL_FLAG_SLIDER
1082                 },
1083                 .tweak = ov7670_t_brightness,
1084                 .query = ov7670_q_brightness,
1085         },
1086         {
1087                 .qc = {
1088                         .id = V4L2_CID_CONTRAST,
1089                         .type = V4L2_CTRL_TYPE_INTEGER,
1090                         .name = "Contrast",
1091                         .minimum = 0,
1092                         .maximum = 127,
1093                         .step = 1,
1094                         .default_value = 0x40,   /* XXX ov7670 spec */
1095                         .flags = V4L2_CTRL_FLAG_SLIDER
1096                 },
1097                 .tweak = ov7670_t_contrast,
1098                 .query = ov7670_q_contrast,
1099         },
1100         {
1101                 .qc = {
1102                         .id = V4L2_CID_SATURATION,
1103                         .type = V4L2_CTRL_TYPE_INTEGER,
1104                         .name = "Saturation",
1105                         .minimum = 0,
1106                         .maximum = 256,
1107                         .step = 1,
1108                         .default_value = 0x80,
1109                         .flags = V4L2_CTRL_FLAG_SLIDER
1110                 },
1111                 .tweak = ov7670_t_sat,
1112                 .query = ov7670_q_sat,
1113         },
1114         {
1115                 .qc = {
1116                         .id = V4L2_CID_HUE,
1117                         .type = V4L2_CTRL_TYPE_INTEGER,
1118                         .name = "HUE",
1119                         .minimum = -180,
1120                         .maximum = 180,
1121                         .step = 5,
1122                         .default_value = 0,
1123                         .flags = V4L2_CTRL_FLAG_SLIDER
1124                 },
1125                 .tweak = ov7670_t_hue,
1126                 .query = ov7670_q_hue,
1127         },
1128         {
1129                 .qc = {
1130                         .id = V4L2_CID_VFLIP,
1131                         .type = V4L2_CTRL_TYPE_BOOLEAN,
1132                         .name = "Vertical flip",
1133                         .minimum = 0,
1134                         .maximum = 1,
1135                         .step = 1,
1136                         .default_value = 0,
1137                 },
1138                 .tweak = ov7670_t_vflip,
1139                 .query = ov7670_q_vflip,
1140         },
1141         {
1142                 .qc = {
1143                         .id = V4L2_CID_HFLIP,
1144                         .type = V4L2_CTRL_TYPE_BOOLEAN,
1145                         .name = "Horizontal mirror",
1146                         .minimum = 0,
1147                         .maximum = 1,
1148                         .step = 1,
1149                         .default_value = 0,
1150                 },
1151                 .tweak = ov7670_t_hflip,
1152                 .query = ov7670_q_hflip,
1153         },
1154 };
1155 #define N_CONTROLS (sizeof(ov7670_controls)/sizeof(ov7670_controls[0]))
1156
1157 static struct ov7670_control *ov7670_find_control(__u32 id)
1158 {
1159         int i;
1160
1161         for (i = 0; i < N_CONTROLS; i++)
1162                 if (ov7670_controls[i].qc.id == id)
1163                         return ov7670_controls + i;
1164         return NULL;
1165 }
1166
1167
1168 static int ov7670_queryctrl(struct i2c_client *client,
1169                 struct v4l2_queryctrl *qc)
1170 {
1171         struct ov7670_control *ctrl = ov7670_find_control(qc->id);
1172
1173         if (ctrl == NULL)
1174                 return -EINVAL;
1175         *qc = ctrl->qc;
1176         return 0;
1177 }
1178
1179 static int ov7670_g_ctrl(struct i2c_client *client, struct v4l2_control *ctrl)
1180 {
1181         struct ov7670_control *octrl = ov7670_find_control(ctrl->id);
1182         int ret;
1183
1184         if (octrl == NULL)
1185                 return -EINVAL;
1186         ret = octrl->query(client, &ctrl->value);
1187         if (ret >= 0)
1188                 return 0;
1189         return ret;
1190 }
1191
1192 static int ov7670_s_ctrl(struct i2c_client *client, struct v4l2_control *ctrl)
1193 {
1194         struct ov7670_control *octrl = ov7670_find_control(ctrl->id);
1195         int ret;
1196
1197         if (octrl == NULL)
1198                 return -EINVAL;
1199         ret =  octrl->tweak(client, ctrl->value);
1200         if (ret >= 0)
1201                 return 0;
1202         return ret;
1203 }
1204
1205
1206
1207
1208
1209
1210 /*
1211  * Basic i2c stuff.
1212  */
1213 static struct i2c_driver ov7670_driver;
1214
1215 static int ov7670_attach(struct i2c_adapter *adapter)
1216 {
1217         int ret;
1218         struct i2c_client *client;
1219         struct ov7670_info *info;
1220
1221         /*
1222          * For now: only deal with adapters we recognize.
1223          */
1224         if (adapter->id != I2C_HW_SMBUS_CAFE)
1225                 return -ENODEV;
1226
1227         client = kzalloc(sizeof (struct i2c_client), GFP_KERNEL);
1228         if (! client)
1229                 return -ENOMEM;
1230         client->adapter = adapter;
1231         client->addr = OV7670_I2C_ADDR;
1232         client->driver = &ov7670_driver,
1233         strcpy(client->name, "OV7670");
1234         /*
1235          * Set up our info structure.
1236          */
1237         info = kzalloc(sizeof (struct ov7670_info), GFP_KERNEL);
1238         if (! info) {
1239                 ret = -ENOMEM;
1240                 goto out_free;
1241         }
1242         info->fmt = &ov7670_formats[0];
1243         info->sat = 128;        /* Review this */
1244         i2c_set_clientdata(client, info);
1245
1246         /*
1247          * Make sure it's an ov7670
1248          */
1249         ret = ov7670_detect(client);
1250         if (ret)
1251                 goto out_free_info;
1252         i2c_attach_client(client);
1253         return 0;
1254
1255   out_free_info:
1256         kfree(info);
1257   out_free:
1258         kfree(client);
1259         return ret;
1260 }
1261
1262
1263 static int ov7670_detach(struct i2c_client *client)
1264 {
1265         i2c_detach_client(client);
1266         kfree(i2c_get_clientdata(client));
1267         kfree(client);
1268         return 0;
1269 }
1270
1271
1272 static int ov7670_command(struct i2c_client *client, unsigned int cmd,
1273                 void *arg)
1274 {
1275         switch (cmd) {
1276         case VIDIOC_G_CHIP_IDENT:
1277                 return v4l2_chip_ident_i2c_client(client, arg, V4L2_IDENT_OV7670, 0);
1278
1279         case VIDIOC_INT_RESET:
1280                 ov7670_reset(client);
1281                 return 0;
1282
1283         case VIDIOC_INT_INIT:
1284                 return ov7670_init(client);
1285
1286         case VIDIOC_ENUM_FMT:
1287                 return ov7670_enum_fmt(client, (struct v4l2_fmtdesc *) arg);
1288         case VIDIOC_TRY_FMT:
1289                 return ov7670_try_fmt(client, (struct v4l2_format *) arg, NULL, NULL);
1290         case VIDIOC_S_FMT:
1291                 return ov7670_s_fmt(client, (struct v4l2_format *) arg);
1292         case VIDIOC_QUERYCTRL:
1293                 return ov7670_queryctrl(client, (struct v4l2_queryctrl *) arg);
1294         case VIDIOC_S_CTRL:
1295                 return ov7670_s_ctrl(client, (struct v4l2_control *) arg);
1296         case VIDIOC_G_CTRL:
1297                 return ov7670_g_ctrl(client, (struct v4l2_control *) arg);
1298         case VIDIOC_S_PARM:
1299                 return ov7670_s_parm(client, (struct v4l2_streamparm *) arg);
1300         case VIDIOC_G_PARM:
1301                 return ov7670_g_parm(client, (struct v4l2_streamparm *) arg);
1302         }
1303         return -EINVAL;
1304 }
1305
1306
1307
1308 static struct i2c_driver ov7670_driver = {
1309         .driver = {
1310                 .name = "ov7670",
1311         },
1312         .id             = I2C_DRIVERID_OV7670,
1313         .class          = I2C_CLASS_CAM_DIGITAL,
1314         .attach_adapter = ov7670_attach,
1315         .detach_client  = ov7670_detach,
1316         .command        = ov7670_command,
1317 };
1318
1319
1320 /*
1321  * Module initialization
1322  */
1323 static int __init ov7670_mod_init(void)
1324 {
1325         printk(KERN_NOTICE "OmniVision ov7670 sensor driver, at your service\n");
1326         return i2c_add_driver(&ov7670_driver);
1327 }
1328
1329 static void __exit ov7670_mod_exit(void)
1330 {
1331         i2c_del_driver(&ov7670_driver);
1332 }
1333
1334 module_init(ov7670_mod_init);
1335 module_exit(ov7670_mod_exit);