drivers/media/usb/gspca/m5602/m5602_ov7660.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for the ov7660 sensor
   4  *
   5  * Copyright (C) 2009 Erik Andrén
   6  * Copyright (C) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
   7  * Copyright (C) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
   8  *
   9  * Portions of code to USB interface and ALi driver software,
  10  * Copyright (c) 2006 Willem Duinker
  11  * v4l2 interface modeled after the V4L2 driver
  12  * for SN9C10x PC Camera Controllers
  13  */
  14
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16
  17 #include "m5602_ov7660.h"
  18
  19 static int ov7660_s_ctrl(struct v4l2_ctrl *ctrl);
  20 static void ov7660_dump_registers(struct sd *sd);
  21
  22 static const unsigned char preinit_ov7660[][4] = {
  23         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
  24         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
  25         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
  26         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
  27         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
  28         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0d},
  29         {BRIDGE, M5602_XB_SENSOR_CTRL, 0x00},
  30         {BRIDGE, M5602_XB_GPIO_DIR, 0x03},
  31         {BRIDGE, M5602_XB_GPIO_DIR, 0x03},
  32         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
  33         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
  34
  35         {SENSOR, OV7660_OFON, 0x0c},
  36         {SENSOR, OV7660_COM2, 0x11},
  37         {SENSOR, OV7660_COM7, 0x05},
  38
  39         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
  40         {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
  41         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
  42         {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
  43         {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
  44         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
  45         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
  46         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
  47         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
  48         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
  49         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
  50         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
  51         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
  52         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
  53         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00}
  54 };
  55
  56 static const unsigned char init_ov7660[][4] = {
  57         {BRIDGE, M5602_XB_MCU_CLK_DIV, 0x02},
  58         {BRIDGE, M5602_XB_MCU_CLK_CTRL, 0xb0},
  59         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
  60         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
  61         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
  62         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0d},
  63         {BRIDGE, M5602_XB_SENSOR_CTRL, 0x00},
  64         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
  65         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
  66         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
  67         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
  68         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
  69         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
  70         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
  71         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
  72         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
  73         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
  74         {SENSOR, OV7660_COM7, 0x80},
  75         {SENSOR, OV7660_CLKRC, 0x80},
  76         {SENSOR, OV7660_COM9, 0x4c},
  77         {SENSOR, OV7660_OFON, 0x43},
  78         {SENSOR, OV7660_COM12, 0x28},
  79         {SENSOR, OV7660_COM8, 0x00},
  80         {SENSOR, OV7660_COM10, 0x40},
  81         {SENSOR, OV7660_HSTART, 0x0c},
  82         {SENSOR, OV7660_HSTOP, 0x61},
  83         {SENSOR, OV7660_HREF, 0xa4},
  84         {SENSOR, OV7660_PSHFT, 0x0b},
  85         {SENSOR, OV7660_VSTART, 0x01},
  86         {SENSOR, OV7660_VSTOP, 0x7a},
  87         {SENSOR, OV7660_VSTOP, 0x00},
  88         {SENSOR, OV7660_COM7, 0x05},
  89         {SENSOR, OV7660_COM6, 0x42},
  90         {SENSOR, OV7660_BBIAS, 0x94},
  91         {SENSOR, OV7660_GbBIAS, 0x94},
  92         {SENSOR, OV7660_RSVD29, 0x94},
  93         {SENSOR, OV7660_RBIAS, 0x94},
  94         {SENSOR, OV7660_COM1, 0x00},
  95         {SENSOR, OV7660_AECH, 0x00},
  96         {SENSOR, OV7660_AECHH, 0x00},
  97         {SENSOR, OV7660_ADC, 0x05},
  98         {SENSOR, OV7660_COM13, 0x00},
  99         {SENSOR, OV7660_RSVDA1, 0x23},
 100         {SENSOR, OV7660_TSLB, 0x0d},
 101         {SENSOR, OV7660_HV, 0x80},
 102         {SENSOR, OV7660_LCC1, 0x00},
 103         {SENSOR, OV7660_LCC2, 0x00},
 104         {SENSOR, OV7660_LCC3, 0x10},
 105         {SENSOR, OV7660_LCC4, 0x40},
 106         {SENSOR, OV7660_LCC5, 0x01},
 107
 108         {SENSOR, OV7660_AECH, 0x20},
 109         {SENSOR, OV7660_COM1, 0x00},
 110         {SENSOR, OV7660_OFON, 0x0c},
 111         {SENSOR, OV7660_COM2, 0x11},
 112         {SENSOR, OV7660_COM7, 0x05},
 113         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
 114         {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
 115         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 116         {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
 117         {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
 118         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
 119         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 120         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
 121         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 122         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
 123         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
 124         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
 125         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
 126         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 127         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
 128         {SENSOR, OV7660_AECH, 0x5f},
 129         {SENSOR, OV7660_COM1, 0x03},
 130         {SENSOR, OV7660_OFON, 0x0c},
 131         {SENSOR, OV7660_COM2, 0x11},
 132         {SENSOR, OV7660_COM7, 0x05},
 133         {BRIDGE, M5602_XB_GPIO_DIR, 0x01},
 134         {BRIDGE, M5602_XB_GPIO_DAT, 0x04},
 135         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 136         {BRIDGE, M5602_XB_GPIO_DIR_H, 0x06},
 137         {BRIDGE, M5602_XB_GPIO_DAT_H, 0x00},
 138         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x08},
 139         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 140         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
 141         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 142         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
 143         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
 144         {BRIDGE, M5602_XB_GPIO_DIR, 0x05},
 145         {BRIDGE, M5602_XB_GPIO_DAT, 0x00},
 146         {BRIDGE, M5602_XB_GPIO_EN_H, 0x06},
 147         {BRIDGE, M5602_XB_GPIO_EN_L, 0x00},
 148
 149         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x06},
 150         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 151         {BRIDGE, M5602_XB_ADC_CTRL, 0xc0},
 152         {BRIDGE, M5602_XB_SENSOR_TYPE, 0x0c},
 153         {BRIDGE, M5602_XB_LINE_OF_FRAME_H, 0x81},
 154         {BRIDGE, M5602_XB_PIX_OF_LINE_H, 0x82},
 155         {BRIDGE, M5602_XB_SIG_INI, 0x01},
 156         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 157         {BRIDGE, M5602_XB_VSYNC_PARA, 0x08},
 158         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 159         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 160         {BRIDGE, M5602_XB_VSYNC_PARA, 0x01},
 161         {BRIDGE, M5602_XB_VSYNC_PARA, 0xec},
 162         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 163         {BRIDGE, M5602_XB_VSYNC_PARA, 0x00},
 164         {BRIDGE, M5602_XB_SIG_INI, 0x00},
 165         {BRIDGE, M5602_XB_SIG_INI, 0x02},
 166         {BRIDGE, M5602_XB_HSYNC_PARA, 0x00},
 167         {BRIDGE, M5602_XB_HSYNC_PARA, 0x27},
 168         {BRIDGE, M5602_XB_HSYNC_PARA, 0x02},
 169         {BRIDGE, M5602_XB_HSYNC_PARA, 0xa7},
 170         {BRIDGE, M5602_XB_SIG_INI, 0x00},
 171         {BRIDGE, M5602_XB_SEN_CLK_DIV, 0x00},
 172         {BRIDGE, M5602_XB_SEN_CLK_CTRL, 0xb0},
 173 };
 174
 175 static struct v4l2_pix_format ov7660_modes[] = {
 176         {
 177                 640,
 178                 480,
 179                 V4L2_PIX_FMT_SBGGR8,
 180                 V4L2_FIELD_NONE,
 181                 .sizeimage =
 182                         640 * 480,
 183                 .bytesperline = 640,
 184                 .colorspace = V4L2_COLORSPACE_SRGB,
 185                 .priv = 0
 186         }
 187 };
 188
 189 static const struct v4l2_ctrl_ops ov7660_ctrl_ops = {
 190         .s_ctrl = ov7660_s_ctrl,
 191 };
 192
 193 int ov7660_probe(struct sd *sd)
 194 {
 195         int err = 0, i;
 196         u8 prod_id = 0, ver_id = 0;
 197
 198         if (force_sensor) {
 199                 if (force_sensor == OV7660_SENSOR) {
 200                         pr_info("Forcing an %s sensor\n", ov7660.name);
 201                         goto sensor_found;
 202                 }
 203                 /* If we want to force another sensor,
 204                 don't try to probe this one */
 205                 return -ENODEV;
 206         }
 207
 208         /* Do the preinit */
 209         for (i = 0; i < ARRAY_SIZE(preinit_ov7660) && !err; i++) {
 210                 u8 data[2];
 211
 212                 if (preinit_ov7660[i][0] == BRIDGE) {
 213                         err = m5602_write_bridge(sd,
 214                                 preinit_ov7660[i][1],
 215                                 preinit_ov7660[i][2]);
 216                 } else {
 217                         data[0] = preinit_ov7660[i][2];
 218                         err = m5602_write_sensor(sd,
 219                                 preinit_ov7660[i][1], data, 1);
 220                 }
 221         }
 222         if (err < 0)
 223                 return err;
 224
 225         if (m5602_read_sensor(sd, OV7660_PID, &prod_id, 1))
 226                 return -ENODEV;
 227
 228         if (m5602_read_sensor(sd, OV7660_VER, &ver_id, 1))
 229                 return -ENODEV;
 230
 231         pr_info("Sensor reported 0x%x%x\n", prod_id, ver_id);
 232
 233         if ((prod_id == 0x76) && (ver_id == 0x60)) {
 234                 pr_info("Detected a ov7660 sensor\n");
 235                 goto sensor_found;
 236         }
 237         return -ENODEV;
 238
 239 sensor_found:
 240         sd->gspca_dev.cam.cam_mode = ov7660_modes;
 241         sd->gspca_dev.cam.nmodes = ARRAY_SIZE(ov7660_modes);
 242
 243         return 0;
 244 }
 245
 246 int ov7660_init(struct sd *sd)
 247 {
 248         int i, err;
 249
 250         /* Init the sensor */
 251         for (i = 0; i < ARRAY_SIZE(init_ov7660); i++) {
 252                 u8 data[2];
 253
 254                 if (init_ov7660[i][0] == BRIDGE) {
 255                         err = m5602_write_bridge(sd,
 256                                 init_ov7660[i][1],
 257                                 init_ov7660[i][2]);
 258                 } else {
 259                         data[0] = init_ov7660[i][2];
 260                         err = m5602_write_sensor(sd,
 261                                 init_ov7660[i][1], data, 1);
 262                 }
 263                 if (err < 0)
 264                         return err;
 265         }
 266
 267         if (dump_sensor)
 268                 ov7660_dump_registers(sd);
 269
 270         return 0;
 271 }
 272
 273 int ov7660_init_controls(struct sd *sd)
 274 {
 275         struct v4l2_ctrl_handler *hdl = &sd->gspca_dev.ctrl_handler;
 276
 277         sd->gspca_dev.vdev.ctrl_handler = hdl;
 278         v4l2_ctrl_handler_init(hdl, 6);
 279
 280         v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_AUTO_WHITE_BALANCE,
 281                           0, 1, 1, 1);
 282         v4l2_ctrl_new_std_menu(hdl, &ov7660_ctrl_ops,
 283                           V4L2_CID_EXPOSURE_AUTO, 1, 0, V4L2_EXPOSURE_AUTO);
 284
 285         sd->autogain = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops,
 286                                          V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
 287         sd->gain = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_GAIN, 0,
 288                                      255, 1, OV7660_DEFAULT_GAIN);
 289
 290         sd->hflip = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_HFLIP,
 291                                       0, 1, 1, 0);
 292         sd->vflip = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_VFLIP,
 293                                       0, 1, 1, 0);
 294
 295         if (hdl->error) {
 296                 pr_err("Could not initialize controls\n");
 297                 return hdl->error;
 298         }
 299
 300         v4l2_ctrl_auto_cluster(2, &sd->autogain, 0, false);
 301         v4l2_ctrl_cluster(2, &sd->hflip);
 302
 303         return 0;
 304 }
 305
 306 int ov7660_start(struct sd *sd)
 307 {
 308         return 0;
 309 }
 310
 311 int ov7660_stop(struct sd *sd)
 312 {
 313         return 0;
 314 }
 315
 316 void ov7660_disconnect(struct sd *sd)
 317 {
 318         ov7660_stop(sd);
 319
 320         sd->sensor = NULL;
 321 }
 322
 323 static int ov7660_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 324 {
 325         int err;
 326         u8 i2c_data = val;
 327         struct sd *sd = (struct sd *) gspca_dev;
 328
 329         gspca_dbg(gspca_dev, D_CONF, "Setting gain to %d\n", val);
 330
 331         err = m5602_write_sensor(sd, OV7660_GAIN, &i2c_data, 1);
 332         return err;
 333 }
 334
 335 static int ov7660_set_auto_white_balance(struct gspca_dev *gspca_dev,
 336                                          __s32 val)
 337 {
 338         int err;
 339         u8 i2c_data;
 340         struct sd *sd = (struct sd *) gspca_dev;
 341
 342         gspca_dbg(gspca_dev, D_CONF, "Set auto white balance to %d\n", val);
 343
 344         err = m5602_read_sensor(sd, OV7660_COM8, &i2c_data, 1);
 345         if (err < 0)
 346                 return err;
 347
 348         i2c_data = ((i2c_data & 0xfd) | ((val & 0x01) << 1));
 349         err = m5602_write_sensor(sd, OV7660_COM8, &i2c_data, 1);
 350
 351         return err;
 352 }
 353
 354 static int ov7660_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val)
 355 {
 356         int err;
 357         u8 i2c_data;
 358         struct sd *sd = (struct sd *) gspca_dev;
 359
 360         gspca_dbg(gspca_dev, D_CONF, "Set auto gain control to %d\n", val);
 361
 362         err = m5602_read_sensor(sd, OV7660_COM8, &i2c_data, 1);
 363         if (err < 0)
 364                 return err;
 365
 366         i2c_data = ((i2c_data & 0xfb) | ((val & 0x01) << 2));
 367
 368         return m5602_write_sensor(sd, OV7660_COM8, &i2c_data, 1);
 369 }
 370
 371 static int ov7660_set_auto_exposure(struct gspca_dev *gspca_dev,
 372                                     __s32 val)
 373 {
 374         int err;
 375         u8 i2c_data;
 376         struct sd *sd = (struct sd *) gspca_dev;
 377
 378         gspca_dbg(gspca_dev, D_CONF, "Set auto exposure control to %d\n", val);
 379
 380         err = m5602_read_sensor(sd, OV7660_COM8, &i2c_data, 1);
 381         if (err < 0)
 382                 return err;
 383
 384         val = (val == V4L2_EXPOSURE_AUTO);
 385         i2c_data = ((i2c_data & 0xfe) | ((val & 0x01) << 0));
 386
 387         return m5602_write_sensor(sd, OV7660_COM8, &i2c_data, 1);
 388 }
 389
 390 static int ov7660_set_hvflip(struct gspca_dev *gspca_dev)
 391 {
 392         int err;
 393         u8 i2c_data;
 394         struct sd *sd = (struct sd *) gspca_dev;
 395
 396         gspca_dbg(gspca_dev, D_CONF, "Set hvflip to %d, %d\n",
 397                   sd->hflip->val, sd->vflip->val);
 398
 399         i2c_data = (sd->hflip->val << 5) | (sd->vflip->val << 4);
 400
 401         err = m5602_write_sensor(sd, OV7660_MVFP, &i2c_data, 1);
 402
 403         return err;
 404 }
 405
 406 static int ov7660_s_ctrl(struct v4l2_ctrl *ctrl)
 407 {
 408         struct gspca_dev *gspca_dev =
 409                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 410         struct sd *sd = (struct sd *) gspca_dev;
 411         int err;
 412
 413         if (!gspca_dev->streaming)
 414                 return 0;
 415
 416         switch (ctrl->id) {
 417         case V4L2_CID_AUTO_WHITE_BALANCE:
 418                 err = ov7660_set_auto_white_balance(gspca_dev, ctrl->val);
 419                 break;
 420         case V4L2_CID_EXPOSURE_AUTO:
 421                 err = ov7660_set_auto_exposure(gspca_dev, ctrl->val);
 422                 break;
 423         case V4L2_CID_AUTOGAIN:
 424                 err = ov7660_set_auto_gain(gspca_dev, ctrl->val);
 425                 if (err || ctrl->val)
 426                         return err;
 427                 err = ov7660_set_gain(gspca_dev, sd->gain->val);
 428                 break;
 429         case V4L2_CID_HFLIP:
 430                 err = ov7660_set_hvflip(gspca_dev);
 431                 break;
 432         default:
 433                 return -EINVAL;
 434         }
 435
 436         return err;
 437 }
 438
 439 static void ov7660_dump_registers(struct sd *sd)
 440 {
 441         int address;
 442         pr_info("Dumping the ov7660 register state\n");
 443         for (address = 0; address < 0xa9; address++) {
 444                 u8 value;
 445                 m5602_read_sensor(sd, address, &value, 1);
 446                 pr_info("register 0x%x contains 0x%x\n", address, value);
 447         }
 448
 449         pr_info("ov7660 register state dump complete\n");
 450
 451         pr_info("Probing for which registers that are read/write\n");
 452         for (address = 0; address < 0xff; address++) {
 453                 u8 old_value, ctrl_value;
 454                 u8 test_value[2] = {0xff, 0xff};
 455
 456                 m5602_read_sensor(sd, address, &old_value, 1);
 457                 m5602_write_sensor(sd, address, test_value, 1);
 458                 m5602_read_sensor(sd, address, &ctrl_value, 1);
 459
 460                 if (ctrl_value == test_value[0])
 461                         pr_info("register 0x%x is writeable\n", address);
 462                 else
 463                         pr_info("register 0x%x is read only\n", address);
 464
 465                 /* Restore original value */
 466                 m5602_write_sensor(sd, address, &old_value, 1);
 467         }
 468 }