drivers/media/video/gspca/m5602/m5602_ov9650.h

   1 /*
   2  * Driver for the ov9650 sensor
   3  *
   4  * Copyright (C) 2008 Erik Andrén
   5  * Copyright (C) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
   6  * Copyright (C) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
   7  *
   8  * Portions of code to USB interface and ALi driver software,
   9  * Copyright (c) 2006 Willem Duinker
  10  * v4l2 interface modeled after the V4L2 driver
  11  * for SN9C10x PC Camera Controllers
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation, version 2.
  16  *
  17  */
  18
  19 #ifndef M5602_OV9650_H_
  20 #define M5602_OV9650_H_
  21
  22 #include <linux/dmi.h>
  23 #include "m5602_sensor.h"
  24
  25 /*****************************************************************************/
  26
  27 #define OV9650_GAIN                     0x00
  28 #define OV9650_BLUE                     0x01
  29 #define OV9650_RED                      0x02
  30 #define OV9650_VREF                     0x03
  31 #define OV9650_COM1                     0x04
  32 #define OV9650_BAVE                     0x05
  33 #define OV9650_GEAVE                    0x06
  34 #define OV9650_RSVD7                    0x07
  35 #define OV9650_PID                      0x0a
  36 #define OV9650_VER                      0x0b
  37 #define OV9650_COM3                     0x0c
  38 #define OV9650_COM4                     0x0d
  39 #define OV9650_COM5                     0x0e
  40 #define OV9650_COM6                     0x0f
  41 #define OV9650_AECH                     0x10
  42 #define OV9650_CLKRC                    0x11
  43 #define OV9650_COM7                     0x12
  44 #define OV9650_COM8                     0x13
  45 #define OV9650_COM9                     0x14
  46 #define OV9650_COM10                    0x15
  47 #define OV9650_RSVD16                   0x16
  48 #define OV9650_HSTART                   0x17
  49 #define OV9650_HSTOP                    0x18
  50 #define OV9650_VSTRT                    0x19
  51 #define OV9650_VSTOP                    0x1a
  52 #define OV9650_PSHFT                    0x1b
  53 #define OV9650_MVFP                     0x1e
  54 #define OV9650_AEW                      0x24
  55 #define OV9650_AEB                      0x25
  56 #define OV9650_VPT                      0x26
  57 #define OV9650_BBIAS                    0x27
  58 #define OV9650_GbBIAS                   0x28
  59 #define OV9650_Gr_COM                   0x29
  60 #define OV9650_RBIAS                    0x2c
  61 #define OV9650_HREF                     0x32
  62 #define OV9650_CHLF                     0x33
  63 #define OV9650_ARBLM                    0x34
  64 #define OV9650_RSVD35                   0x35
  65 #define OV9650_RSVD36                   0x36
  66 #define OV9650_ADC                      0x37
  67 #define OV9650_ACOM38                   0x38
  68 #define OV9650_OFON                     0x39
  69 #define OV9650_TSLB                     0x3a
  70 #define OV9650_COM12                    0x3c
  71 #define OV9650_COM13                    0x3d
  72 #define OV9650_COM15                    0x40
  73 #define OV9650_COM16                    0x41
  74 #define OV9650_LCC1                     0x62
  75 #define OV9650_LCC2                     0x63
  76 #define OV9650_LCC3                     0x64
  77 #define OV9650_LCC4                     0x65
  78 #define OV9650_LCC5                     0x66
  79 #define OV9650_HV                       0x69
  80 #define OV9650_DBLV                     0x6b
  81 #define OV9650_COM21                    0x8b
  82 #define OV9650_COM22                    0x8c
  83 #define OV9650_COM24                    0x8e
  84 #define OV9650_DBLC1                    0x8f
  85 #define OV9650_RSVD94                   0x94
  86 #define OV9650_RSVD95                   0x95
  87 #define OV9650_RSVD96                   0x96
  88 #define OV9650_LCCFB                    0x9d
  89 #define OV9650_LCCFR                    0x9e
  90 #define OV9650_AECHM                    0xa1
  91 #define OV9650_COM26                    0xa5
  92 #define OV9650_ACOMA8                   0xa8
  93 #define OV9650_ACOMA9                   0xa9
  94
  95 #define OV9650_REGISTER_RESET           (1 << 7)
  96 #define OV9650_VGA_SELECT               (1 << 6)
  97 #define OV9650_CIF_SELECT               (1 << 5)
  98 #define OV9650_QVGA_SELECT              (1 << 4)
  99 #define OV9650_RGB_SELECT               (1 << 2)
 100 #define OV9650_RAW_RGB_SELECT           (1 << 0)
 101
 102 #define OV9650_FAST_AGC_AEC             (1 << 7)
 103 #define OV9650_AEC_UNLIM_STEP_SIZE      (1 << 6)
 104 #define OV9650_BANDING                  (1 << 5)
 105 #define OV9650_AGC_EN                   (1 << 2)
 106 #define OV9650_AWB_EN                   (1 << 1)
 107 #define OV9650_AEC_EN                   (1 << 0)
 108
 109 #define OV9650_VARIOPIXEL               (1 << 2)
 110 #define OV9650_SYSTEM_CLK_SEL           (1 << 7)
 111 #define OV9650_SLAM_MODE                (1 << 4)
 112
 113 #define OV9650_QVGA_VARIOPIXEL          (1 << 7)
 114
 115 #define OV9650_VFLIP                    (1 << 4)
 116 #define OV9650_HFLIP                    (1 << 5)
 117
 118 #define GAIN_DEFAULT                    0x14
 119 #define RED_GAIN_DEFAULT                0x70
 120 #define BLUE_GAIN_DEFAULT               0x20
 121 #define EXPOSURE_DEFAULT                0x5003
 122
 123 /*****************************************************************************/
 124
 125 /* Kernel module parameters */
 126 extern int force_sensor;
 127 extern int dump_sensor;
 128
 129 int ov9650_probe(struct sd *sd);
 130 int ov9650_init(struct sd *sd);
 131 int ov9650_start(struct sd *sd);
 132 int ov9650_power_down(struct sd *sd);
 133
 134 int ov9650_set_exposure(struct gspca_dev *gspca_dev, __s32 val);
 135 int ov9650_get_exposure(struct gspca_dev *gspca_dev, __s32 *val);
 136 int ov9650_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
 137 int ov9650_set_gain(struct gspca_dev *gspca_dev, __s32 val);
 138 int ov9650_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val);
 139 int ov9650_set_red_balance(struct gspca_dev *gspca_dev, __s32 val);
 140 int ov9650_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val);
 141 int ov9650_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val);
 142 int ov9650_get_hflip(struct gspca_dev *gspca_dev, __s32 *val);
 143 int ov9650_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
 144 int ov9650_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
 145 int ov9650_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
 146 int ov9650_get_brightness(struct gspca_dev *gspca_dev, __s32 *val);
 147 int ov9650_set_brightness(struct gspca_dev *gspca_dev, __s32 val);
 148 int ov9650_get_auto_white_balance(struct gspca_dev *gspca_dev, __s32 *val);
 149 int ov9650_set_auto_white_balance(struct gspca_dev *gspca_dev, __s32 val);
 150 int ov9650_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val);
 151 int ov9650_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val);
 152
 153 static struct m5602_sensor ov9650 = {
 154         .name = "OV9650",
 155         .i2c_slave_id = 0x60,
 156         .i2c_regW = 1,
 157         .probe = ov9650_probe,
 158         .init = ov9650_init,
 159         .start = ov9650_start,
 160         .power_down = ov9650_power_down,
 161
 162         .nctrls = 8,
 163         .ctrls = {
 164         {
 165                 {
 166                         .id             = V4L2_CID_EXPOSURE,
 167                         .type           = V4L2_CTRL_TYPE_INTEGER,
 168                         .name           = "exposure",
 169                         .minimum        = 0x00,
 170                         .maximum        = 0xffff,
 171                         .step           = 0x1,
 172                         .default_value  = EXPOSURE_DEFAULT,
 173                         .flags          = V4L2_CTRL_FLAG_SLIDER
 174                 },
 175                 .set = ov9650_set_exposure,
 176                 .get = ov9650_get_exposure
 177         }, {
 178                 {
 179                         .id             = V4L2_CID_GAIN,
 180                         .type           = V4L2_CTRL_TYPE_INTEGER,
 181                         .name           = "gain",
 182                         .minimum        = 0x00,
 183                         .maximum        = 0x3ff,
 184                         .step           = 0x1,
 185                         .default_value  = GAIN_DEFAULT,
 186                         .flags          = V4L2_CTRL_FLAG_SLIDER
 187                 },
 188                 .set = ov9650_set_gain,
 189                 .get = ov9650_get_gain
 190         }, {
 191                 {
 192                         .type           = V4L2_CTRL_TYPE_INTEGER,
 193                         .name           = "red balance",
 194                         .minimum        = 0x00,
 195                         .maximum        = 0xff,
 196                         .step           = 0x1,
 197                         .default_value  = RED_GAIN_DEFAULT,
 198                         .flags          = V4L2_CTRL_FLAG_SLIDER
 199                 },
 200                 .set = ov9650_set_red_balance,
 201                 .get = ov9650_get_red_balance
 202         }, {
 203                 {
 204                         .type           = V4L2_CTRL_TYPE_INTEGER,
 205                         .name           = "blue balance",
 206                         .minimum        = 0x00,
 207                         .maximum        = 0xff,
 208                         .step           = 0x1,
 209                         .default_value  = BLUE_GAIN_DEFAULT,
 210                         .flags          = V4L2_CTRL_FLAG_SLIDER
 211                 },
 212                 .set = ov9650_set_blue_balance,
 213                 .get = ov9650_get_blue_balance
 214         }, {
 215                 {
 216                         .id             = V4L2_CID_HFLIP,
 217                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
 218                         .name           = "horizontal flip",
 219                         .minimum        = 0,
 220                         .maximum        = 1,
 221                         .step           = 1,
 222                         .default_value  = 0
 223                 },
 224                 .set = ov9650_set_hflip,
 225                 .get = ov9650_get_hflip
 226         }, {
 227                 {
 228                         .id             = V4L2_CID_VFLIP,
 229                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
 230                         .name           = "vertical flip",
 231                         .minimum        = 0,
 232                         .maximum        = 1,
 233                         .step           = 1,
 234                         .default_value  = 0
 235                 },
 236                 .set = ov9650_set_vflip,
 237                 .get = ov9650_get_vflip
 238         }, {
 239                 {
 240                         .id             = V4L2_CID_AUTO_WHITE_BALANCE,
 241                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
 242                         .name           = "auto white balance",
 243                         .minimum        = 0,
 244                         .maximum        = 1,
 245                         .step           = 1,
 246                         .default_value  = 0
 247                 },
 248                 .set = ov9650_set_auto_white_balance,
 249                 .get = ov9650_get_auto_white_balance
 250         }, {
 251                 {
 252                         .id             = V4L2_CID_AUTOGAIN,
 253                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
 254                         .name           = "auto gain control",
 255                         .minimum        = 0,
 256                         .maximum        = 1,
 257                         .step           = 1,
 258                         .default_value  = 0
 259                 },
 260                 .set = ov9650_set_auto_gain,
 261                 .get = ov9650_get_auto_gain
 262         }
 263         },
 264
 265         .nmodes = 3,
 266         .modes = {
 267         {
 268                 320,
 269                 240,
 270                 V4L2_PIX_FMT_SBGGR8,
 271                 V4L2_FIELD_NONE,
 272                 .sizeimage =
 273                         320 * 240,
 274                 .bytesperline = 320,
 275                 .colorspace = V4L2_COLORSPACE_SRGB,
 276                 .priv = 0
 277         }, {
 278                 352,
 279                 288,
 280                 V4L2_PIX_FMT_SBGGR8,
 281                 V4L2_FIELD_NONE,
 282                 .sizeimage =
 283                         352 * 288,
 284                 .bytesperline = 352,
 285                 .colorspace = V4L2_COLORSPACE_SRGB,
 286                 .priv = 0
 287         }, {
 288                 640,
 289                 480,
 290                 V4L2_PIX_FMT_SBGGR8,
 291                 V4L2_FIELD_NONE,
 292                 .sizeimage =
 293                         640 * 480,
 294                 .bytesperline = 640,
 295                 .colorspace = V4L2_COLORSPACE_SRGB,
 296                 .priv = 0
 297         }
 298         }
 299 };
 300
 301 static const unsigned char preinit_ov9650[][3] =
 302 {
 303         /* [INITCAM] */
 304         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
 305         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
 306         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
 307         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 308         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
 309         {BRIDGE, M5602_XB_SENSOR_CTRL, 0x00},
 310
 311         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x08},
 312         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
 313         {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
 314         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 315         {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
 316         {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
 317         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
 318         {BRIDGE, M5602_XB_I2C_CLK_DIV, 0x0a},
 319         /* Reset chip */
 320         {SENSOR, OV9650_COM7, OV9650_REGISTER_RESET},
 321         /* Enable double clock */
 322         {SENSOR, OV9650_CLKRC, 0x80},
 323         /* Do something out of spec with the power */
 324         {SENSOR, OV9650_OFON, 0x40}
 325 };
 326
 327 static const unsigned char init_ov9650[][3] =
 328 {
 329         /* [INITCAM] */
 330         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
 331         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
 332         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
 333         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 334         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
 335         {BRIDGE, M5602_XB_SENSOR_CTRL, 0x00},
 336
 337         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x08},
 338         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
 339         {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
 340         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 341         {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
 342         {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
 343         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
 344         {BRIDGE, M5602_XB_I2C_CLK_DIV, 0x0a},
 345
 346         /* Reset chip */
 347         {SENSOR, OV9650_COM7, OV9650_REGISTER_RESET},
 348         /* Enable double clock */
 349         {SENSOR, OV9650_CLKRC, 0x80},
 350         /* Do something out of spec with the power */
 351         {SENSOR, OV9650_OFON, 0x40},
 352
 353         /* Set fast AGC/AEC algorithm with unlimited step size */
 354         {SENSOR, OV9650_COM8, OV9650_FAST_AGC_AEC |
 355                               OV9650_AEC_UNLIM_STEP_SIZE |
 356                               OV9650_AWB_EN | OV9650_AGC_EN},
 357
 358         {SENSOR, OV9650_CHLF, 0x10},
 359         {SENSOR, OV9650_ARBLM, 0xbf},
 360         {SENSOR, OV9650_ACOM38, 0x81},
 361         /* Turn off color matrix coefficient double option */
 362         {SENSOR, OV9650_COM16, 0x00},
 363         /* Enable color matrix for RGB/YUV, Delay Y channel,
 364         set output Y/UV delay to 1 */
 365         {SENSOR, OV9650_COM13, 0x19},
 366         /* Enable digital BLC, Set output mode to U Y V Y */
 367         {SENSOR, OV9650_TSLB, 0x0c},
 368         /* Limit the AGC/AEC stable upper region */
 369         {SENSOR, OV9650_COM24, 0x00},
 370         /* Enable HREF and some out of spec things */
 371         {SENSOR, OV9650_COM12, 0x73},
 372         /* Set all DBLC offset signs to positive and
 373         do some out of spec stuff */
 374         {SENSOR, OV9650_DBLC1, 0xdf},
 375         {SENSOR, OV9650_COM21, 0x06},
 376         {SENSOR, OV9650_RSVD35, 0x91},
 377         /* Necessary, no camera stream without it */
 378         {SENSOR, OV9650_RSVD16, 0x06},
 379         {SENSOR, OV9650_RSVD94, 0x99},
 380         {SENSOR, OV9650_RSVD95, 0x99},
 381         {SENSOR, OV9650_RSVD96, 0x04},
 382         /* Enable full range output */
 383         {SENSOR, OV9650_COM15, 0x0},
 384         /* Enable HREF at optical black, enable ADBLC bias,
 385         enable ADBLC, reset timings at format change */
 386         {SENSOR, OV9650_COM6, 0x4b},
 387         /* Subtract 32 from the B channel bias */
 388         {SENSOR, OV9650_BBIAS, 0xa0},
 389         /* Subtract 32 from the Gb channel bias */
 390         {SENSOR, OV9650_GbBIAS, 0xa0},
 391         /* Do not bypass the analog BLC and to some out of spec stuff */
 392         {SENSOR, OV9650_Gr_COM, 0x00},
 393         /* Subtract 32 from the R channel bias */
 394         {SENSOR, OV9650_RBIAS, 0xa0},
 395         /* Subtract 32 from the R channel bias */
 396         {SENSOR, OV9650_RBIAS, 0x0},
 397         {SENSOR, OV9650_COM26, 0x80},
 398         {SENSOR, OV9650_ACOMA9, 0x98},
 399         /* Set the AGC/AEC stable region upper limit */
 400         {SENSOR, OV9650_AEW, 0x68},
 401         /* Set the AGC/AEC stable region lower limit */
 402         {SENSOR, OV9650_AEB, 0x5c},
 403         /* Set the high and low limit nibbles to 3 */
 404         {SENSOR, OV9650_VPT, 0xc3},
 405         /* Set the Automatic Gain Ceiling (AGC) to 128x,
 406         drop VSYNC at frame drop,
 407         limit exposure timing,
 408         drop frame when the AEC step is larger than the exposure gap */
 409         {SENSOR, OV9650_COM9, 0x6e},
 410         /* Set VSYNC negative, Set RESET to SLHS (slave mode horizontal sync)
 411         and set PWDN to SLVS (slave mode vertical sync) */
 412         {SENSOR, OV9650_COM10, 0x42},
 413         /* Set horizontal column start high to default value */
 414         {SENSOR, OV9650_HSTART, 0x1a}, /* 210 */
 415         /* Set horizontal column end */
 416         {SENSOR, OV9650_HSTOP, 0xbf}, /* 1534 */
 417         /* Complementing register to the two writes above */
 418         {SENSOR, OV9650_HREF, 0xb2},
 419         /* Set vertical row start high bits */
 420         {SENSOR, OV9650_VSTRT, 0x02},
 421         /* Set vertical row end low bits */
 422         {SENSOR, OV9650_VSTOP, 0x7e},
 423         /* Set complementing vertical frame control */
 424         {SENSOR, OV9650_VREF, 0x10},
 425         {SENSOR, OV9650_ADC, 0x04},
 426         {SENSOR, OV9650_HV, 0x40},
 427         /* Enable denoise, and white-pixel erase */
 428         {SENSOR, OV9650_COM22, 0x23},
 429
 430         /* Set the high bits of the exposure value */
 431         {SENSOR, OV9650_AECH, ((EXPOSURE_DEFAULT & 0xff00) >> 8)},
 432
 433         /* Enable VARIOPIXEL */
 434         {SENSOR, OV9650_COM3, OV9650_VARIOPIXEL},
 435         {SENSOR, OV9650_COM4, OV9650_QVGA_VARIOPIXEL},
 436
 437         /* Set the low bits of the exposure value */
 438         {SENSOR, OV9650_COM1, (EXPOSURE_DEFAULT & 0xff)},
 439         {SENSOR, OV9650_GAIN, GAIN_DEFAULT},
 440         {SENSOR, OV9650_BLUE, BLUE_GAIN_DEFAULT},
 441         {SENSOR, OV9650_RED, RED_GAIN_DEFAULT},
 442 };
 443
 444 static const unsigned char power_down_ov9650[][3] =
 445 {
 446         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x04},
 447         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 448         {SENSOR, OV9650_COM7, 0x80},
 449         {SENSOR, OV9650_OFON, 0xf4},
 450         {SENSOR, OV9650_MVFP, 0x80},
 451         {SENSOR, OV9650_DBLV, 0x3f},
 452         {SENSOR, OV9650_RSVD36, 0x49},
 453         {SENSOR, OV9650_COM7, 0x05},
 454
 455         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
 456         {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
 457         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 458         {BRIDGE, M5602_XB_GPIO_EN_L, 0x06},
 459         {BRIDGE, M5602_XB_GPIO_DAT_H, 0x02},
 460         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x04},
 461         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 462 };
 463
 464 static const unsigned char res_init_ov9650[][2] =
 465 {
 466         {M5602_XB_LINE_OF_FRAME_H, 0x82},
 467         {M5602_XB_LINE_OF_FRAME_L, 0x00},
 468         {M5602_XB_PIX_OF_LINE_H, 0x82},
 469         {M5602_XB_PIX_OF_LINE_L, 0x00},
 470         {M5602_XB_SIG_INI, 0x01}
 471 };
 472
 473 static const unsigned char VGA_ov9650[][3] =
 474 {
 475         /* Moves the view window in a vertical orientation */
 476         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 477         {BRIDGE, M5602_XB_VSYNC_PARA, 0x09},
 478         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 479         {BRIDGE, M5602_XB_VSYNC_PARA, 0x01},
 480         {BRIDGE, M5602_XB_VSYNC_PARA, 0xe0}, /* 480 */
 481         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 482         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 483         {BRIDGE, M5602_XB_HSYNC_PARA, 0x00},
 484         {BRIDGE, M5602_XB_HSYNC_PARA, 0x62}, /* 98 */
 485         {BRIDGE, M5602_XB_HSYNC_PARA, 0x02}, /* 640 + 98 */
 486         {BRIDGE, M5602_XB_HSYNC_PARA, 0xe2},
 487
 488         {SENSOR, OV9650_COM7, OV9650_VGA_SELECT |
 489                               OV9650_RGB_SELECT |
 490                               OV9650_RAW_RGB_SELECT},
 491 };
 492
 493 static const unsigned char CIF_ov9650[][3] =
 494 {
 495         /* Moves the view window in a vertical orientation */
 496         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 497         {BRIDGE, M5602_XB_VSYNC_PARA, 0x09},
 498         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 499         {BRIDGE, M5602_XB_VSYNC_PARA, 0x01},
 500         {BRIDGE, M5602_XB_VSYNC_PARA, 0x20}, /* 288 */
 501         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 502         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 503         {BRIDGE, M5602_XB_HSYNC_PARA, 0x00},
 504         {BRIDGE, M5602_XB_HSYNC_PARA, 0x62}, /* 98 */
 505         {BRIDGE, M5602_XB_HSYNC_PARA, 0x01}, /* 352 + 98 */
 506         {BRIDGE, M5602_XB_HSYNC_PARA, 0xc2},
 507
 508         {SENSOR, OV9650_COM7, OV9650_CIF_SELECT |
 509                               OV9650_RGB_SELECT |
 510                               OV9650_RAW_RGB_SELECT},
 511 };
 512
 513 static const unsigned char QVGA_ov9650[][3] =
 514 {
 515         /* Moves the view window in a vertical orientation */
 516         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 517         {BRIDGE, M5602_XB_VSYNC_PARA, 0x08},
 518         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 519         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 520         {BRIDGE, M5602_XB_VSYNC_PARA, 0xf0}, /* 240 */
 521         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 522         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 523         {BRIDGE, M5602_XB_HSYNC_PARA, 0x00},
 524         {BRIDGE, M5602_XB_HSYNC_PARA, 0x31}, /* 50 */
 525         {BRIDGE, M5602_XB_HSYNC_PARA, 0x01}, /* 320 + 50 */
 526         {BRIDGE, M5602_XB_HSYNC_PARA, 0x71},
 527
 528         {SENSOR, OV9650_COM7, OV9650_QVGA_SELECT |
 529                               OV9650_RGB_SELECT |
 530                               OV9650_RAW_RGB_SELECT},
 531 };
 532
 533 #endif