1 /* Shared Code for OmniVision Camera Chip Drivers
3 * Copyright (c) 2004 Mark McClelland <mark@alpha.dyndns.org>
4 * http://alpha.dyndns.org/ov511/
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.
14 #include <linux/init.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/delay.h>
18 #include "ovcamchip_priv.h"
20 #define DRIVER_VERSION "v2.27 for Linux 2.6"
21 #define DRIVER_AUTHOR "Mark McClelland <mark@alpha.dyndns.org>"
22 #define DRIVER_DESC "OV camera chip I2C driver"
24 #define PINFO(fmt, args...) printk(KERN_INFO "ovcamchip: " fmt "\n" , ## args);
25 #define PERROR(fmt, args...) printk(KERN_ERR "ovcamchip: " fmt "\n" , ## args);
28 int ovcamchip_debug
= 0;
30 module_param(debug
, int, 0);
31 MODULE_PARM_DESC(debug
,
32 "Debug level: 0=none, 1=inits, 2=warning, 3=config, 4=functions, 5=all");
35 /* By default, let bridge driver tell us if chip is monochrome. mono=0
36 * will ignore that and always treat chips as color. mono=1 will force
37 * monochrome mode for all chips. */
39 module_param(mono
, int, 0);
40 MODULE_PARM_DESC(mono
,
41 "1=chips are monochrome (OVx1xx), 0=force color, -1=autodetect (default)");
43 MODULE_AUTHOR(DRIVER_AUTHOR
);
44 MODULE_DESCRIPTION(DRIVER_DESC
);
45 MODULE_LICENSE("GPL");
47 /* Registers common to all chips, that are needed for detection */
48 #define GENERIC_REG_ID_HIGH 0x1C /* manufacturer ID MSB */
49 #define GENERIC_REG_ID_LOW 0x1D /* manufacturer ID LSB */
50 #define GENERIC_REG_COM_I 0x29 /* misc ID bits */
52 static char *chip_names
[NUM_CC_TYPES
] = {
53 [CC_UNKNOWN
] = "Unknown chip",
54 [CC_OV76BE
] = "OV76BE",
55 [CC_OV7610
] = "OV7610",
56 [CC_OV7620
] = "OV7620",
57 [CC_OV7620AE
] = "OV7620AE",
58 [CC_OV6620
] = "OV6620",
59 [CC_OV6630
] = "OV6630",
60 [CC_OV6630AE
] = "OV6630AE",
61 [CC_OV6630AF
] = "OV6630AF",
64 /* Forward declarations */
65 static struct i2c_driver driver
;
66 static struct i2c_client client_template
;
68 /* ----------------------------------------------------------------------- */
70 int ov_write_regvals(struct i2c_client
*c
, struct ovcamchip_regvals
*rvals
)
74 while (rvals
->reg
!= 0xff) {
75 rc
= ov_write(c
, rvals
->reg
, rvals
->val
);
84 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
85 * the same position as 1's in "mask" are cleared and set to "value". Bits
86 * that are in the same position as 0's in "mask" are preserved, regardless
87 * of their respective state in "value".
89 int ov_write_mask(struct i2c_client
*c
,
95 unsigned char oldval
, newval
;
100 rc
= ov_read(c
, reg
, &oldval
);
104 oldval
&= (~mask
); /* Clear the masked bits */
105 value
&= mask
; /* Enforce mask on value */
106 newval
= oldval
| value
; /* Set the desired bits */
109 return ov_write(c
, reg
, newval
);
112 /* ----------------------------------------------------------------------- */
114 /* Reset the chip and ensure that I2C is synchronized. Returns <0 if failure.
116 static int init_camchip(struct i2c_client
*c
)
119 unsigned char high
, low
;
122 ov_write(c
, 0x12, 0x80);
124 /* Wait for it to initialize */
127 for (i
= 0, success
= 0; i
< I2C_DETECT_RETRIES
&& !success
; i
++) {
128 if (ov_read(c
, GENERIC_REG_ID_HIGH
, &high
) >= 0) {
129 if (ov_read(c
, GENERIC_REG_ID_LOW
, &low
) >= 0) {
130 if (high
== 0x7F && low
== 0xA2) {
138 ov_write(c
, 0x12, 0x80);
140 /* Wait for it to initialize */
143 /* Dummy read to sync I2C */
144 ov_read(c
, 0x00, &low
);
150 PDEBUG(1, "I2C synced in %d attempt(s)", i
);
155 /* This detects the OV7610, OV7620, or OV76BE chip. */
156 static int ov7xx0_detect(struct i2c_client
*c
)
158 struct ovcamchip
*ov
= i2c_get_clientdata(c
);
164 /* Detect chip (sub)type */
165 rc
= ov_read(c
, GENERIC_REG_COM_I
, &val
);
167 PERROR("Error detecting ov7xx0 type");
171 if ((val
& 3) == 3) {
172 PINFO("Camera chip is an OV7610");
173 ov
->subtype
= CC_OV7610
;
174 } else if ((val
& 3) == 1) {
175 rc
= ov_read(c
, 0x15, &val
);
177 PERROR("Error detecting ov7xx0 type");
182 PINFO("Camera chip is an OV7620AE");
183 /* OV7620 is a close enough match for now. There are
184 * some definite differences though, so this should be
186 ov
->subtype
= CC_OV7620
;
188 PINFO("Camera chip is an OV76BE");
189 ov
->subtype
= CC_OV76BE
;
191 } else if ((val
& 3) == 0) {
192 PINFO("Camera chip is an OV7620");
193 ov
->subtype
= CC_OV7620
;
195 PERROR("Unknown camera chip version: %d", val
& 3);
199 if (ov
->subtype
== CC_OV76BE
)
200 ov
->sops
= &ov76be_ops
;
201 else if (ov
->subtype
== CC_OV7620
)
202 ov
->sops
= &ov7x20_ops
;
204 ov
->sops
= &ov7x10_ops
;
209 /* This detects the OV6620, OV6630, OV6630AE, or OV6630AF chip. */
210 static int ov6xx0_detect(struct i2c_client
*c
)
212 struct ovcamchip
*ov
= i2c_get_clientdata(c
);
218 /* Detect chip (sub)type */
219 rc
= ov_read(c
, GENERIC_REG_COM_I
, &val
);
221 PERROR("Error detecting ov6xx0 type");
225 if ((val
& 3) == 0) {
226 ov
->subtype
= CC_OV6630
;
227 PINFO("Camera chip is an OV6630");
228 } else if ((val
& 3) == 1) {
229 ov
->subtype
= CC_OV6620
;
230 PINFO("Camera chip is an OV6620");
231 } else if ((val
& 3) == 2) {
232 ov
->subtype
= CC_OV6630
;
233 PINFO("Camera chip is an OV6630AE");
234 } else if ((val
& 3) == 3) {
235 ov
->subtype
= CC_OV6630
;
236 PINFO("Camera chip is an OV6630AF");
239 if (ov
->subtype
== CC_OV6620
)
240 ov
->sops
= &ov6x20_ops
;
242 ov
->sops
= &ov6x30_ops
;
247 static int ovcamchip_detect(struct i2c_client
*c
)
249 /* Ideally we would just try a single register write and see if it NAKs.
250 * That isn't possible since the OV518 can't report I2C transaction
251 * failures. So, we have to try to initialize the chip (i.e. reset it
252 * and check the ID registers) to detect its presence. */
255 PDEBUG(3, "Testing for 0V7xx0");
256 c
->addr
= OV7xx0_SID
;
257 if (init_camchip(c
) < 0) {
259 PDEBUG(3, "Testing for 0V6xx0");
260 c
->addr
= OV6xx0_SID
;
261 if (init_camchip(c
) < 0) {
264 if (ov6xx0_detect(c
) < 0) {
265 PERROR("Failed to init OV6xx0");
270 if (ov7xx0_detect(c
) < 0) {
271 PERROR("Failed to init OV7xx0");
279 /* ----------------------------------------------------------------------- */
281 static int ovcamchip_attach(struct i2c_adapter
*adap
)
284 struct ovcamchip
*ov
;
285 struct i2c_client
*c
;
287 /* I2C is not a PnP bus, so we can never be certain that we're talking
288 * to the right chip. To prevent damage to EEPROMS and such, only
289 * attach to adapters that are known to contain OV camera chips. */
292 case I2C_HW_SMBUS_OV511
:
293 case I2C_HW_SMBUS_OV518
:
294 case I2C_HW_SMBUS_W9968CF
:
295 PDEBUG(1, "Adapter ID 0x%06x accepted", adap
->id
);
298 PDEBUG(1, "Adapter ID 0x%06x rejected", adap
->id
);
302 c
= kmalloc(sizeof *c
, GFP_KERNEL
);
307 memcpy(c
, &client_template
, sizeof *c
);
309 strcpy(c
->name
, "OV????");
311 ov
= kzalloc(sizeof *ov
, GFP_KERNEL
);
316 i2c_set_clientdata(c
, ov
);
318 rc
= ovcamchip_detect(c
);
322 strcpy(c
->name
, chip_names
[ov
->subtype
]);
324 PDEBUG(1, "Camera chip detection complete");
326 i2c_attach_client(c
);
334 PDEBUG(1, "returning %d", rc
);
338 static int ovcamchip_detach(struct i2c_client
*c
)
340 struct ovcamchip
*ov
= i2c_get_clientdata(c
);
343 rc
= ov
->sops
->free(c
);
347 i2c_detach_client(c
);
354 static int ovcamchip_command(struct i2c_client
*c
, unsigned int cmd
, void *arg
)
356 struct ovcamchip
*ov
= i2c_get_clientdata(c
);
358 if (!ov
->initialized
&&
359 cmd
!= OVCAMCHIP_CMD_Q_SUBTYPE
&&
360 cmd
!= OVCAMCHIP_CMD_INITIALIZE
) {
361 dev_err(&c
->dev
, "ERROR: Camera chip not initialized yet!\n");
366 case OVCAMCHIP_CMD_Q_SUBTYPE
:
368 *(int *)arg
= ov
->subtype
;
371 case OVCAMCHIP_CMD_INITIALIZE
:
376 ov
->mono
= *(int *)arg
;
381 if (ov
->subtype
!= CC_OV7620
)
382 dev_warn(&c
->dev
, "Warning: Monochrome not "
383 "implemented for this chip\n");
385 dev_info(&c
->dev
, "Initializing chip as "
389 rc
= ov
->sops
->init(c
);
397 return ov
->sops
->command(c
, cmd
, arg
);
401 /* ----------------------------------------------------------------------- */
403 static struct i2c_driver driver
= {
407 .id
= I2C_DRIVERID_OVCAMCHIP
,
408 .attach_adapter
= ovcamchip_attach
,
409 .detach_client
= ovcamchip_detach
,
410 .command
= ovcamchip_command
,
413 static struct i2c_client client_template
= {
418 static int __init
ovcamchip_init(void)
421 ovcamchip_debug
= debug
;
424 PINFO(DRIVER_VERSION
" : " DRIVER_DESC
);
425 return i2c_add_driver(&driver
);
428 static void __exit
ovcamchip_exit(void)
430 i2c_del_driver(&driver
);
433 module_init(ovcamchip_init
);
434 module_exit(ovcamchip_exit
);