Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* Shared Code for OmniVision Camera Chip Drivers |
| 2 | * |
| 3 | * Copyright (c) 2004 Mark McClelland <mark@alpha.dyndns.org> |
| 4 | * http://alpha.dyndns.org/ov511/ |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms of the GNU General Public License as published by the |
| 8 | * Free Software Foundation; either version 2 of the License, or (at your |
| 9 | * option) any later version. NO WARRANTY OF ANY KIND is expressed or implied. |
| 10 | */ |
| 11 | |
| 12 | #define DEBUG |
| 13 | |
| 14 | #include <linux/init.h> |
| 15 | #include <linux/module.h> |
| 16 | #include <linux/moduleparam.h> |
| 17 | #include <linux/slab.h> |
| 18 | #include <linux/delay.h> |
| 19 | #include "ovcamchip_priv.h" |
| 20 | |
| 21 | #define DRIVER_VERSION "v2.27 for Linux 2.6" |
| 22 | #define DRIVER_AUTHOR "Mark McClelland <mark@alpha.dyndns.org>" |
| 23 | #define DRIVER_DESC "OV camera chip I2C driver" |
| 24 | |
| 25 | #define PINFO(fmt, args...) printk(KERN_INFO "ovcamchip: " fmt "\n" , ## args); |
| 26 | #define PERROR(fmt, args...) printk(KERN_ERR "ovcamchip: " fmt "\n" , ## args); |
| 27 | |
| 28 | #ifdef DEBUG |
| 29 | int ovcamchip_debug = 0; |
| 30 | static int debug; |
| 31 | module_param(debug, int, 0); |
| 32 | MODULE_PARM_DESC(debug, |
| 33 | "Debug level: 0=none, 1=inits, 2=warning, 3=config, 4=functions, 5=all"); |
| 34 | #endif |
| 35 | |
| 36 | /* By default, let bridge driver tell us if chip is monochrome. mono=0 |
| 37 | * will ignore that and always treat chips as color. mono=1 will force |
| 38 | * monochrome mode for all chips. */ |
| 39 | static int mono = -1; |
| 40 | module_param(mono, int, 0); |
| 41 | MODULE_PARM_DESC(mono, |
| 42 | "1=chips are monochrome (OVx1xx), 0=force color, -1=autodetect (default)"); |
| 43 | |
| 44 | MODULE_AUTHOR(DRIVER_AUTHOR); |
| 45 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 46 | MODULE_LICENSE("GPL"); |
| 47 | |
| 48 | /* Registers common to all chips, that are needed for detection */ |
| 49 | #define GENERIC_REG_ID_HIGH 0x1C /* manufacturer ID MSB */ |
| 50 | #define GENERIC_REG_ID_LOW 0x1D /* manufacturer ID LSB */ |
| 51 | #define GENERIC_REG_COM_I 0x29 /* misc ID bits */ |
| 52 | |
| 53 | extern struct ovcamchip_ops ov6x20_ops; |
| 54 | extern struct ovcamchip_ops ov6x30_ops; |
| 55 | extern struct ovcamchip_ops ov7x10_ops; |
| 56 | extern struct ovcamchip_ops ov7x20_ops; |
| 57 | extern struct ovcamchip_ops ov76be_ops; |
| 58 | |
| 59 | static char *chip_names[NUM_CC_TYPES] = { |
| 60 | [CC_UNKNOWN] = "Unknown chip", |
| 61 | [CC_OV76BE] = "OV76BE", |
| 62 | [CC_OV7610] = "OV7610", |
| 63 | [CC_OV7620] = "OV7620", |
| 64 | [CC_OV7620AE] = "OV7620AE", |
| 65 | [CC_OV6620] = "OV6620", |
| 66 | [CC_OV6630] = "OV6630", |
| 67 | [CC_OV6630AE] = "OV6630AE", |
| 68 | [CC_OV6630AF] = "OV6630AF", |
| 69 | }; |
| 70 | |
| 71 | /* Forward declarations */ |
| 72 | static struct i2c_driver driver; |
| 73 | static struct i2c_client client_template; |
| 74 | |
| 75 | /* ----------------------------------------------------------------------- */ |
| 76 | |
| 77 | int ov_write_regvals(struct i2c_client *c, struct ovcamchip_regvals *rvals) |
| 78 | { |
| 79 | int rc; |
| 80 | |
| 81 | while (rvals->reg != 0xff) { |
| 82 | rc = ov_write(c, rvals->reg, rvals->val); |
| 83 | if (rc < 0) |
| 84 | return rc; |
| 85 | rvals++; |
| 86 | } |
| 87 | |
| 88 | return 0; |
| 89 | } |
| 90 | |
| 91 | /* Writes bits at positions specified by mask to an I2C reg. Bits that are in |
| 92 | * the same position as 1's in "mask" are cleared and set to "value". Bits |
| 93 | * that are in the same position as 0's in "mask" are preserved, regardless |
| 94 | * of their respective state in "value". |
| 95 | */ |
| 96 | int ov_write_mask(struct i2c_client *c, |
| 97 | unsigned char reg, |
| 98 | unsigned char value, |
| 99 | unsigned char mask) |
| 100 | { |
| 101 | int rc; |
| 102 | unsigned char oldval, newval; |
| 103 | |
| 104 | if (mask == 0xff) { |
| 105 | newval = value; |
| 106 | } else { |
| 107 | rc = ov_read(c, reg, &oldval); |
| 108 | if (rc < 0) |
| 109 | return rc; |
| 110 | |
| 111 | oldval &= (~mask); /* Clear the masked bits */ |
| 112 | value &= mask; /* Enforce mask on value */ |
| 113 | newval = oldval | value; /* Set the desired bits */ |
| 114 | } |
| 115 | |
| 116 | return ov_write(c, reg, newval); |
| 117 | } |
| 118 | |
| 119 | /* ----------------------------------------------------------------------- */ |
| 120 | |
| 121 | /* Reset the chip and ensure that I2C is synchronized. Returns <0 if failure. |
| 122 | */ |
| 123 | static int init_camchip(struct i2c_client *c) |
| 124 | { |
| 125 | int i, success; |
| 126 | unsigned char high, low; |
| 127 | |
| 128 | /* Reset the chip */ |
| 129 | ov_write(c, 0x12, 0x80); |
| 130 | |
| 131 | /* Wait for it to initialize */ |
| 132 | msleep(150); |
| 133 | |
| 134 | for (i = 0, success = 0; i < I2C_DETECT_RETRIES && !success; i++) { |
| 135 | if (ov_read(c, GENERIC_REG_ID_HIGH, &high) >= 0) { |
| 136 | if (ov_read(c, GENERIC_REG_ID_LOW, &low) >= 0) { |
| 137 | if (high == 0x7F && low == 0xA2) { |
| 138 | success = 1; |
| 139 | continue; |
| 140 | } |
| 141 | } |
| 142 | } |
| 143 | |
| 144 | /* Reset the chip */ |
| 145 | ov_write(c, 0x12, 0x80); |
| 146 | |
| 147 | /* Wait for it to initialize */ |
| 148 | msleep(150); |
| 149 | |
| 150 | /* Dummy read to sync I2C */ |
| 151 | ov_read(c, 0x00, &low); |
| 152 | } |
| 153 | |
| 154 | if (!success) |
| 155 | return -EIO; |
| 156 | |
| 157 | PDEBUG(1, "I2C synced in %d attempt(s)", i); |
| 158 | |
| 159 | return 0; |
| 160 | } |
| 161 | |
| 162 | /* This detects the OV7610, OV7620, or OV76BE chip. */ |
| 163 | static int ov7xx0_detect(struct i2c_client *c) |
| 164 | { |
| 165 | struct ovcamchip *ov = i2c_get_clientdata(c); |
| 166 | int rc; |
| 167 | unsigned char val; |
| 168 | |
| 169 | PDEBUG(4, ""); |
| 170 | |
| 171 | /* Detect chip (sub)type */ |
| 172 | rc = ov_read(c, GENERIC_REG_COM_I, &val); |
| 173 | if (rc < 0) { |
| 174 | PERROR("Error detecting ov7xx0 type"); |
| 175 | return rc; |
| 176 | } |
| 177 | |
| 178 | if ((val & 3) == 3) { |
| 179 | PINFO("Camera chip is an OV7610"); |
| 180 | ov->subtype = CC_OV7610; |
| 181 | } else if ((val & 3) == 1) { |
| 182 | rc = ov_read(c, 0x15, &val); |
| 183 | if (rc < 0) { |
| 184 | PERROR("Error detecting ov7xx0 type"); |
| 185 | return rc; |
| 186 | } |
| 187 | |
| 188 | if (val & 1) { |
| 189 | PINFO("Camera chip is an OV7620AE"); |
| 190 | /* OV7620 is a close enough match for now. There are |
| 191 | * some definite differences though, so this should be |
| 192 | * fixed */ |
| 193 | ov->subtype = CC_OV7620; |
| 194 | } else { |
| 195 | PINFO("Camera chip is an OV76BE"); |
| 196 | ov->subtype = CC_OV76BE; |
| 197 | } |
| 198 | } else if ((val & 3) == 0) { |
| 199 | PINFO("Camera chip is an OV7620"); |
| 200 | ov->subtype = CC_OV7620; |
| 201 | } else { |
| 202 | PERROR("Unknown camera chip version: %d", val & 3); |
| 203 | return -ENOSYS; |
| 204 | } |
| 205 | |
| 206 | if (ov->subtype == CC_OV76BE) |
| 207 | ov->sops = &ov76be_ops; |
| 208 | else if (ov->subtype == CC_OV7620) |
| 209 | ov->sops = &ov7x20_ops; |
| 210 | else |
| 211 | ov->sops = &ov7x10_ops; |
| 212 | |
| 213 | return 0; |
| 214 | } |
| 215 | |
| 216 | /* This detects the OV6620, OV6630, OV6630AE, or OV6630AF chip. */ |
| 217 | static int ov6xx0_detect(struct i2c_client *c) |
| 218 | { |
| 219 | struct ovcamchip *ov = i2c_get_clientdata(c); |
| 220 | int rc; |
| 221 | unsigned char val; |
| 222 | |
| 223 | PDEBUG(4, ""); |
| 224 | |
| 225 | /* Detect chip (sub)type */ |
| 226 | rc = ov_read(c, GENERIC_REG_COM_I, &val); |
| 227 | if (rc < 0) { |
| 228 | PERROR("Error detecting ov6xx0 type"); |
| 229 | return -1; |
| 230 | } |
| 231 | |
| 232 | if ((val & 3) == 0) { |
| 233 | ov->subtype = CC_OV6630; |
| 234 | PINFO("Camera chip is an OV6630"); |
| 235 | } else if ((val & 3) == 1) { |
| 236 | ov->subtype = CC_OV6620; |
| 237 | PINFO("Camera chip is an OV6620"); |
| 238 | } else if ((val & 3) == 2) { |
| 239 | ov->subtype = CC_OV6630; |
| 240 | PINFO("Camera chip is an OV6630AE"); |
| 241 | } else if ((val & 3) == 3) { |
| 242 | ov->subtype = CC_OV6630; |
| 243 | PINFO("Camera chip is an OV6630AF"); |
| 244 | } |
| 245 | |
| 246 | if (ov->subtype == CC_OV6620) |
| 247 | ov->sops = &ov6x20_ops; |
| 248 | else |
| 249 | ov->sops = &ov6x30_ops; |
| 250 | |
| 251 | return 0; |
| 252 | } |
| 253 | |
| 254 | static int ovcamchip_detect(struct i2c_client *c) |
| 255 | { |
| 256 | /* Ideally we would just try a single register write and see if it NAKs. |
| 257 | * That isn't possible since the OV518 can't report I2C transaction |
| 258 | * failures. So, we have to try to initialize the chip (i.e. reset it |
| 259 | * and check the ID registers) to detect its presence. */ |
| 260 | |
| 261 | /* Test for 7xx0 */ |
| 262 | PDEBUG(3, "Testing for 0V7xx0"); |
| 263 | c->addr = OV7xx0_SID; |
| 264 | if (init_camchip(c) < 0) { |
| 265 | /* Test for 6xx0 */ |
| 266 | PDEBUG(3, "Testing for 0V6xx0"); |
| 267 | c->addr = OV6xx0_SID; |
| 268 | if (init_camchip(c) < 0) { |
Mauro Carvalho Chehab | d56410e | 2006-03-25 09:19:53 -0300 | [diff] [blame] | 269 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | } else { |
| 271 | if (ov6xx0_detect(c) < 0) { |
| 272 | PERROR("Failed to init OV6xx0"); |
Mauro Carvalho Chehab | d56410e | 2006-03-25 09:19:53 -0300 | [diff] [blame] | 273 | return -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | } |
| 275 | } |
| 276 | } else { |
| 277 | if (ov7xx0_detect(c) < 0) { |
| 278 | PERROR("Failed to init OV7xx0"); |
Mauro Carvalho Chehab | d56410e | 2006-03-25 09:19:53 -0300 | [diff] [blame] | 279 | return -EIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | } |
| 281 | } |
| 282 | |
| 283 | return 0; |
| 284 | } |
| 285 | |
| 286 | /* ----------------------------------------------------------------------- */ |
| 287 | |
| 288 | static int ovcamchip_attach(struct i2c_adapter *adap) |
| 289 | { |
| 290 | int rc = 0; |
| 291 | struct ovcamchip *ov; |
| 292 | struct i2c_client *c; |
| 293 | |
| 294 | /* I2C is not a PnP bus, so we can never be certain that we're talking |
| 295 | * to the right chip. To prevent damage to EEPROMS and such, only |
| 296 | * attach to adapters that are known to contain OV camera chips. */ |
| 297 | |
| 298 | switch (adap->id) { |
Jean Delvare | c7a4653 | 2005-08-11 23:41:56 +0200 | [diff] [blame] | 299 | case I2C_HW_SMBUS_OV511: |
| 300 | case I2C_HW_SMBUS_OV518: |
| 301 | case I2C_HW_SMBUS_OVFX2: |
| 302 | case I2C_HW_SMBUS_W9968CF: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | PDEBUG(1, "Adapter ID 0x%06x accepted", adap->id); |
| 304 | break; |
| 305 | default: |
| 306 | PDEBUG(1, "Adapter ID 0x%06x rejected", adap->id); |
| 307 | return -ENODEV; |
| 308 | } |
| 309 | |
| 310 | c = kmalloc(sizeof *c, GFP_KERNEL); |
| 311 | if (!c) { |
| 312 | rc = -ENOMEM; |
| 313 | goto no_client; |
| 314 | } |
| 315 | memcpy(c, &client_template, sizeof *c); |
| 316 | c->adapter = adap; |
Jean Delvare | fae91e7 | 2005-08-15 19:57:04 +0200 | [diff] [blame] | 317 | strcpy(c->name, "OV????"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | |
Panagiotis Issaris | 7408187 | 2006-01-11 19:40:56 -0200 | [diff] [blame] | 319 | ov = kzalloc(sizeof *ov, GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | if (!ov) { |
| 321 | rc = -ENOMEM; |
| 322 | goto no_ov; |
| 323 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | i2c_set_clientdata(c, ov); |
| 325 | |
| 326 | rc = ovcamchip_detect(c); |
| 327 | if (rc < 0) |
| 328 | goto error; |
| 329 | |
Jean Delvare | fae91e7 | 2005-08-15 19:57:04 +0200 | [diff] [blame] | 330 | strcpy(c->name, chip_names[ov->subtype]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | |
| 332 | PDEBUG(1, "Camera chip detection complete"); |
| 333 | |
| 334 | i2c_attach_client(c); |
| 335 | |
| 336 | return rc; |
| 337 | error: |
| 338 | kfree(ov); |
| 339 | no_ov: |
| 340 | kfree(c); |
| 341 | no_client: |
| 342 | PDEBUG(1, "returning %d", rc); |
| 343 | return rc; |
| 344 | } |
| 345 | |
| 346 | static int ovcamchip_detach(struct i2c_client *c) |
| 347 | { |
| 348 | struct ovcamchip *ov = i2c_get_clientdata(c); |
| 349 | int rc; |
| 350 | |
| 351 | rc = ov->sops->free(c); |
| 352 | if (rc < 0) |
| 353 | return rc; |
| 354 | |
| 355 | i2c_detach_client(c); |
| 356 | |
| 357 | kfree(ov); |
| 358 | kfree(c); |
| 359 | return 0; |
| 360 | } |
| 361 | |
| 362 | static int ovcamchip_command(struct i2c_client *c, unsigned int cmd, void *arg) |
| 363 | { |
| 364 | struct ovcamchip *ov = i2c_get_clientdata(c); |
| 365 | |
| 366 | if (!ov->initialized && |
| 367 | cmd != OVCAMCHIP_CMD_Q_SUBTYPE && |
| 368 | cmd != OVCAMCHIP_CMD_INITIALIZE) { |
| 369 | dev_err(&c->dev, "ERROR: Camera chip not initialized yet!\n"); |
| 370 | return -EPERM; |
| 371 | } |
| 372 | |
| 373 | switch (cmd) { |
| 374 | case OVCAMCHIP_CMD_Q_SUBTYPE: |
| 375 | { |
| 376 | *(int *)arg = ov->subtype; |
| 377 | return 0; |
| 378 | } |
| 379 | case OVCAMCHIP_CMD_INITIALIZE: |
| 380 | { |
| 381 | int rc; |
| 382 | |
| 383 | if (mono == -1) |
| 384 | ov->mono = *(int *)arg; |
| 385 | else |
| 386 | ov->mono = mono; |
| 387 | |
| 388 | if (ov->mono) { |
| 389 | if (ov->subtype != CC_OV7620) |
| 390 | dev_warn(&c->dev, "Warning: Monochrome not " |
| 391 | "implemented for this chip\n"); |
| 392 | else |
| 393 | dev_info(&c->dev, "Initializing chip as " |
| 394 | "monochrome\n"); |
| 395 | } |
| 396 | |
| 397 | rc = ov->sops->init(c); |
| 398 | if (rc < 0) |
| 399 | return rc; |
| 400 | |
| 401 | ov->initialized = 1; |
| 402 | return 0; |
| 403 | } |
| 404 | default: |
| 405 | return ov->sops->command(c, cmd, arg); |
| 406 | } |
| 407 | } |
| 408 | |
| 409 | /* ----------------------------------------------------------------------- */ |
| 410 | |
| 411 | static struct i2c_driver driver = { |
Laurent Riffard | 604f28e | 2005-11-26 20:43:39 +0100 | [diff] [blame] | 412 | .driver = { |
Laurent Riffard | 604f28e | 2005-11-26 20:43:39 +0100 | [diff] [blame] | 413 | .name = "ovcamchip", |
| 414 | }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | .id = I2C_DRIVERID_OVCAMCHIP, |
| 416 | .class = I2C_CLASS_CAM_DIGITAL, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 417 | .attach_adapter = ovcamchip_attach, |
| 418 | .detach_client = ovcamchip_detach, |
| 419 | .command = ovcamchip_command, |
| 420 | }; |
| 421 | |
| 422 | static struct i2c_client client_template = { |
Jean Delvare | fae91e7 | 2005-08-15 19:57:04 +0200 | [diff] [blame] | 423 | .name = "(unset)", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | .driver = &driver, |
| 425 | }; |
| 426 | |
| 427 | static int __init ovcamchip_init(void) |
| 428 | { |
| 429 | #ifdef DEBUG |
| 430 | ovcamchip_debug = debug; |
| 431 | #endif |
| 432 | |
| 433 | PINFO(DRIVER_VERSION " : " DRIVER_DESC); |
| 434 | return i2c_add_driver(&driver); |
| 435 | } |
| 436 | |
| 437 | static void __exit ovcamchip_exit(void) |
| 438 | { |
| 439 | i2c_del_driver(&driver); |
| 440 | } |
| 441 | |
| 442 | module_init(ovcamchip_init); |
| 443 | module_exit(ovcamchip_exit); |