ov965x.c

   1 /**
   2  * @file ov965x.c
   3  * @author Brian Johnson
   4  * @date 2008-08-06
   5  *
   6  * @brief Common functions and data for the Omnivision OV965x sensor series.
   7  *
   8  * @note Copyright (C) Brian Johnson
   9  *
  10  * @par Licences
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  25  */
  26
  27 #include "microdia.h"
  28 #include "sn9c20x.h"
  29 #include "ov965x.h"
  30
  31 /**
  32  * @var ov965x_init
  33  * @brief Addresses and values for the initialization of ov965x sensors
  34  *
  35  */
  36 static __u8 ov965x_init[][2] = {
  37         {OV965X_CTL_COM7, OV965X_COM7_SCCB_RESET},
  38         {OV965X_CTL_GAIN, 0x00},
  39         {OV965X_CTL_BLUE, 0x78},
  40         {OV965X_CTL_RED, 0x78},
  41         {OV965X_CTL_VREF, OV965X_VREF_VSTOP_LOW3(0x06) |
  42                           OV965X_VREF_VSTART_LOW3(0x06)},
  43         {OV965X_CTL_COM1, 0x03},
  44         {OV965X_CTL_BAVE, 0x00}, /* default */
  45         {OV965X_CTL_GEAVE, 0x00}, /* default */
  46         {OV965X_CTL_RAVE, 0x00}, /* default */
  47         {OV965X_CTL_COM2, OV965X_COM2_OUTPUT_DRIVE_CAP_2X},
  48         {OV965X_CTL_COM3, 0x00},
  49         {OV965X_CTL_COM4, 0x00},
  50         {OV965X_CTL_COM5, OV965X_COM5_15FPS_48MHZ_RGB | 0x20},
  51         {OV965X_CTL_COM6, OV965X_COM6_TIMING_RESET_ON_FMT_CHANGE | 0x50},
  52         {OV965X_CTL_AECH, 0x7c},
  53         {OV965X_CTL_CLKRC, OV965X_CLKRC_DBL_CLK_ENABLE},
  54         {OV965X_CTL_COM7, OV965X_COM7_OUTPUT_VGA | OV965X_COM7_OUTPUT_RAW_RGB},
  55         {OV965X_CTL_COM8, OV965X_COM8_FAST_AGC_AEC |
  56                           OV965X_COM8_AEC_STEP_SIZE_NOLIMIT |
  57                           OV965X_COM8_AGC_ENABLE |
  58                           OV965X_COM8_AEC_ENABLE |
  59                           OV965X_COM8_AWB_ENABLE},
  60         {OV965X_CTL_COM9, OV965X_COM9_MAX_AGC_8X |
  61                           OV965X_COM9_RELAX_EXPOSURE_TIMING |
  62                           OV965X_COM9_DROP_VSYNC_ON_FRAME_DROP |
  63                           OV965X_COM9_DROP_FRAME_ON_BIG_AEC},
  64         {OV965X_CTL_COM10, 0x00},
  65         {0x16, 0x07}, /* reserved */
  66         {OV965X_CTL_HSTART, 0x24},
  67         {OV965X_CTL_HSTOP, 0xc5},
  68         {OV965X_CTL_VSTRT, 0x00},
  69         {OV965X_CTL_VSTOP, 0x3c},
  70         {OV965X_CTL_PSHIFT, 0x00}, /* default */
  71         {OV965X_CTL_MVFP, 0x04},
  72         {OV965X_CTL_LAEC, 0x00}, /* reserved */
  73         {OV965X_CTL_AEW, 0x78}, /* default */
  74         {OV965X_CTL_AEB, 0x68}, /* default */
  75         {OV965X_CTL_VPT, 0xd4}, /* default */
  76         {OV965X_CTL_BBIAS, OV965X_BIAS_SUBTRACT}, /* default */
  77         {OV965X_CTL_GbBIAS, OV965X_BIAS_SUBTRACT}, /* default */
  78         {OV965X_CTL_Gr_COM, OV965X_Gr_COM_BYPASS_ANALOG_BLC |
  79                             OV965X_Gr_COM_BYPASS_REGULATOR},
  80         {OV965X_CTL_EXHCH, 0x00}, /* default */
  81         {OV965X_CTL_EXHCL, 0x00}, /* default */
  82         {OV965X_CTL_RBIAS, OV965X_BIAS_SUBTRACT}, /* default */
  83         {OV965X_CTL_ADVFL, 0x00}, /* default */
  84         {OV965X_CTL_ADVFH, 0x00}, /* default */
  85         {OV965X_CTL_YAVE, 0x00}, /* default */
  86         {OV965X_CTL_HSYST, 0x08}, /* default */
  87         {OV965X_CTL_HSYEN, 0x30}, /* default */
  88         {OV965X_CTL_HREF, OV965X_HREF_EDGE_OFT_TO_DATA_OUT(2) |
  89                           OV965X_HREF_HSTOP_LOW3(0) |
  90                           OV965X_HREF_HSTART_LOW3(4)},
  91         {OV965X_CTL_CHLF, 0xe2}, /* reserved */
  92         {OV965X_CTL_ARBLM, 0xbf}, /* reserved */
  93         {0x35, 0x81}, /* reserved */
  94         {0x36, 0xf9}, /* reserved */
  95         {OV965X_CTL_ADC, 0x00}, /* reserved */
  96         {OV965X_CTL_ACOM, 0x93}, /* reserved */
  97         {OV965X_CTL_OFON, 0x50},
  98         {OV965X_CTL_TSLB, OV965X_TSLB_OUTPUT_SEQ_UYVY |
  99                           OV965X_TSLB_DIGITAL_BLC_ENABLE},
 100         {OV965X_CTL_COM11, OV965X_COM11_MANUAL_BANDING_FILTER},
 101         {OV965X_CTL_COM12, 0x73},
 102         {OV965X_CTL_COM13, OV965X_COM13_ENABLE_COLOR_MATRIX |
 103                            OV965X_COM13_DELAY_Y_CHANNEL |
 104                            OV965X_COM13_OUTPUT_DELAY(1)},
 105         {OV965X_CTL_COM14, OV965X_COM14_YUV_EDGE_ENHANCE |
 106                            OV965X_COM14_EDGE_ENHANCE_FACTOR_DBL | 0x0b},
 107         {OV965X_CTL_EDGE, OV965X_EDGE_EDGE_ENHANCE_LOW4(8) |
 108                           OV965X_EDGE_EDGE_ENHANCE_FACTOR(8)},
 109         {OV965X_CTL_COM15, OV965X_COM15_OUTPUT_RANGE_O0_TO_FF | 0x01},
 110         {OV965X_CTL_COM16, 0x00},
 111         {OV965X_CTL_COM17, 0x08},
 112         {OV965X_CTL_MANU, 0x80}, /* default */
 113         {OV965X_CTL_MANV, 0x80}, /* default */
 114         {OV965X_CTL_HV, 0x40},
 115         {OV965X_CTL_MBD, 0x00}, /* default */
 116         {OV965X_CTL_DBLV, 0x0a}, /* reserved */
 117         {OV965X_CTL_COM21, 0x06}, /* reserved */
 118         {OV965X_CTL_COM22, 0x20},
 119         {OV965X_CTL_COM23, 0x00}, /* default */
 120         {OV965X_CTL_COM24, 0x00}, /* reserved */
 121         {OV965X_CTL_DBLC1, 0xdf},
 122         {OV965X_CTL_DM_LNL, 0x00}, /* default */
 123         {OV965X_CTL_DM_LNH, 0x00}, /* default */
 124         {0x94, 0x88}, /* reserved */
 125         {0x95, 0x88}, /* reserved */
 126         {0x96, 0x04}, /* reserved */
 127         {OV965X_CTL_AECHM, 0x00},
 128         {OV965X_CTL_COM26, 0x80}, /* reserved */
 129         {0xa8, 0x80}, /* reserved */
 130         {0xa9, 0xb8}, /* reserved */
 131         {0xaa, 0x92}, /* reserved */
 132         {0xab, 0x0a}, /* reserved */
 133 };
 134
 135 /**
 136  * @brief Initialize ov965x sensors
 137  *
 138  * @param dev Pointer to device structure
 139  *
 140  * @return 0 or negative error code
 141  *
 142  * This function applies the default settings from #ov965x_init to
 143  * the ov965x sensor
 144  *
 145  */
 146 int ov965x_initialize(struct usb_microdia *dev)
 147 {
 148         int ret, i;
 149         __u8 value, reg;
 150
 151         for (i = 0; i < ARRAY_SIZE(ov965x_init); i++) {
 152                 reg = ov965x_init[i][0];
 153                 value = ov965x_init[i][1];
 154                 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
 155                                              reg, dev->sensor_flags, &value);
 156                 if (ret < 0) {
 157                         UDIA_INFO("Sensor Init Error (%d). line %d\n", ret, i);
 158                         break;
 159                 }
 160         }
 161
 162         return ret;
 163
 164 }
 165
 166 /**
 167  * @var soi968_init
 168  * @brief Addresses and values for the initialization of SOI968 sensors
 169  * @author GWater
 170  *
 171  */
 172 static __u8 soi968_init[][2] = {
 173         /* reset all registers */
 174         {0x12, 0x80},
 175         /* stop resetting */
 176         {0x12, 0x00},
 177
 178         /* snapshot mode: off */
 179         {0x0c, 0x00},
 180
 181         /* enable offset adjustment,
 182          * full data range,
 183          * analogue2digital control black-level calibration
 184          */
 185         {0x0f, 0x1f},
 186
 187         /* Clock: internal PLL on */
 188         {0x11, 0x80},
 189
 190
 191         /* Analoge Black-level calibration off , no anaolgue gain */
 192         {0x38, 0x52},
 193
 194         /* reserved */
 195         {0x1e, 0x00},
 196
 197         /* special system settings (voltage, analogue2digital, ...) */
 198         {0x33, 0x08},
 199         {0x35, 0x8c},
 200         {0x36, 0x0c},
 201         {0x37, 0x04},
 202
 203         /*  next 7 are unknown/reserved */
 204         {0x45, 0x04},
 205         {0x47, 0xff},
 206         {0x3e, 0x00},
 207         {0x3f, 0x00},
 208         {0x3b, 0x20},
 209         {0x3a, 0x96},
 210         {0x3d, 0x0a},
 211
 212         /* disable banding filter in dark environment,
 213          * VSYNC is dropped when framerate is dropped,
 214          * drop frmaes when exposure out of tolerance,
 215          * unfreeze exposure and gain values
 216          */
 217         {0x14, 0x4e},
 218
 219         /* AEC, AGC, AWB disabled; fast AEC */
 220         {0x13, 0x88},
 221
 222         /* output: VGA, master mode */
 223         {0x12, 0x40},
 224
 225         /* set HSTART, HSTOP, VSTART and VSTOP */
 226         {0x17, 0x13},
 227         {0x18, 0x63},
 228         {0x19, 0x01},
 229         {0x1a, 0x79},
 230         {0x32, 0x24}, /* LSB for all four */
 231
 232         /* this register contains the product ID, it is read-only
 233         {0x1b, 0x00}, */
 234
 235         /* AWB update threshold,
 236          * blue and red gain LSB
 237          */
 238         {0x03, 0x00},
 239
 240         /* CLock: internal PLL off */
 241         {0x11, 0x40},
 242
 243         /* Line interval adjustment */
 244         {0x2a, 0x10},
 245         {0x2b, 0xe0},
 246
 247         /* AEC MSB */
 248         {0x10, 0x32},
 249
 250         /* gain - default*/
 251         {0x00, 0x00},
 252
 253         /* blue and red gain - default*/
 254         {0x01, 0x80},
 255         {0x02, 0x80}
 256 };
 257
 258 /**
 259  * @brief Initialize SOI968 sensors
 260  *
 261  * @param dev Pointer to device structure
 262  *
 263  * @return 0 or negative error code
 264  *
 265  * @author GWater
 266  *
 267  * This function applies the default settings from #soi968_init to
 268  * the SOI968 sensor
 269  *
 270  */
 271 int soi968_initialize(struct usb_microdia *dev)
 272 {
 273         int ret, i;
 274         __u8 value, reg;
 275
 276         for (i = 0; i < ARRAY_SIZE(soi968_init); i++) {
 277                 reg = soi968_init[i][0];
 278                 value = soi968_init[i][1];
 279                 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
 280                                              reg, dev->sensor_flags, &value);
 281                 if (ret < 0) {
 282                         UDIA_INFO("Sensor Init Error (%d). line %d\n", ret, i);
 283                         break;
 284                 }
 285         }
 286
 287         return ret;
 288
 289 }
 290
 291 /**
 292  * @brief Set hflip and vflip in ov965x sensors
 293  *
 294  * @param dev Pointer to device structure
 295  *
 296  * @returns 0 or negative error code
 297  *
 298  */
 299 int ov965x_set_hvflip(struct usb_microdia *dev)
 300 {
 301         int ret;
 302         __u8 value;
 303         /**
 304          * Changing hstop value seems to be necessary to keep correct
 305          * colors during a vflip. The values don't seem to make much
 306          * sense since to keep the correct color value i'm setting hstop
 307          * to the same value as hstart is set for.
 308          */
 309         __u8 hstop = 0xc5;
 310         ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
 311                         OV965X_CTL_MVFP, dev->sensor_flags, &value);
 312         if (ret < 0)
 313                 return ret;
 314
 315         if (dev->vsettings.hflip)
 316                 value |= OV965X_MVFP_MIRROR;
 317         else
 318                 value &= ~OV965X_MVFP_MIRROR;
 319
 320         if (dev->vsettings.vflip) {
 321                 hstop = 0x24;
 322                 value |= OV965X_MVFP_VFLIP;
 323         } else {
 324                 value &= ~OV965X_MVFP_VFLIP;
 325         }
 326
 327         ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
 328                         OV965X_CTL_HSTOP, dev->sensor_flags, &hstop);
 329
 330         ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
 331                         OV965X_CTL_MVFP, dev->sensor_flags, &value);
 332
 333         return ret;
 334 }
 335
 336 /**
 337  * @brief Set exposure for ov965x sensors
 338  *
 339  * @param dev
 340  *
 341  * @returns 0 or negative error value
 342  *
 343  * The used registers do not show up the datasheets.
 344  *
 345  */
 346 int ov965x_set_exposure(struct usb_microdia *dev)
 347 {
 348         int ret = 0;
 349         __u8 v1 = (dev->vsettings.exposure >> 4) & 0xff;
 350         __u8 v2 = dev->vsettings.exposure >> 12;
 351
 352         ret |= sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, 0x2d,
 353                 dev->sensor_flags, &v1);
 354
 355         ret |= sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, 0x2e,
 356                 dev->sensor_flags, &v2);
 357
 358         return ret;
 359 }
 360
 361 /**
 362  * @brief Set autoexposure for ov96xx sensors
 363  *
 364  * @param dev
 365  *
 366  * @returns 0 or negative error value
 367  *
 368  * @author GWater
 369  *
 370  * For all OV965x and SOI968 sensors.
 371  */
 372 int ov965x_set_autoexposure(struct usb_microdia *dev)
 373 {
 374         __u8 buf[1];
 375         int ret = 0;
 376
 377         /* Read current value of the I2C-register
 378          * controlling AutoExposureControl:
 379          */
 380         ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address,
 381                 1, 0x13, dev->sensor_flags, buf);
 382         if (ret < 0) {
 383                 UDIA_ERROR("Error: setting of auto exposure failed: "
 384                         "error while reading from I2C-register 0x13");
 385                 return ret;
 386         }
 387
 388         /* Determine new value for register 0x13: */
 389         if (dev->vsettings.auto_exposure == 1) {
 390                 /* Enable automatic exposure: */
 391                 buf[0] |= 0x01;
 392         } else if (dev->vsettings.auto_exposure == 0) {
 393                 /* Disable automatic exposure: */
 394                 buf[0] &= ~0x01;
 395         } else
 396                 return -EINVAL;
 397
 398         /* Write new value to I2C-register 0x13: */
 399         ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address,
 400                 1, 0x13, dev->sensor_flags, buf);
 401         if (ret < 0) {
 402                 UDIA_ERROR("Error: setting of auto exposure failed: "
 403                         "error while writing to I2C-register 0x13");
 404                 return ret;
 405         }
 406         return 0;
 407 }
 408
 409 /**
 410  * @brief Set exposure for SOI968 sensors
 411  *
 412  * @param dev
 413  *
 414  * @returns 0 or negative error value
 415  *
 416  * @author GWater
 417  *
 418  * For SOI968 sensors.
 419  */
 420 int soi968_set_exposure(struct usb_microdia *dev)
 421 {
 422         int value, ret;
 423         int exposure = dev->vsettings.exposure;
 424         __u8 buf1, buf2, buf3;
 425
 426         /* Read current value of the I2C-register
 427          * containing exposure LSB:
 428          */
 429         ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address,
 430                 1, 0x04, dev->sensor_flags, &buf1);
 431         if (ret < 0) {
 432                 UDIA_ERROR("Error: setting exposure failed: "
 433                         "error while reading from I2C-register 0x04");
 434                 return ret;
 435         }
 436
 437         value = (exposure  * 0x07ff / 0xffff) & 0x07ff;
 438         buf2 = ((__u8) (value & 0x07)) | (buf1 & ~0x07);
 439         buf3 = (__u8) (value >> 3) & 0xff;
 440
 441         /* Write new value to I2C-register 0x04: */
 442         ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address,
 443                 1, 0x04, dev->sensor_flags, &buf2);
 444         if (ret < 0) {
 445                 UDIA_ERROR("Error: setting exposure failed: "
 446                         "error while writing to I2C-register 0x04");
 447                 return ret;
 448         }
 449
 450         /* Write new value to I2C-register 0x10: */
 451         ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address,
 452                 1, 0x10, dev->sensor_flags, &buf3);
 453         if (ret < 0) {
 454                 UDIA_ERROR("Error: setting exposure failed: "
 455                         "error while writing to I2C-register 0x10");
 456                 return ret;
 457         }
 458
 459         return 0;
 460 }