2 * Driver for the ov9650 sensor
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>
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
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.
19 #include "m5602_ov9650.h"
21 /* Vertically and horizontally flips the image if matched, needed for machines
22 where the sensor is mounted upside down */
25 struct dmi_system_id ov9650_flip_dmi_table[] = {
29 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
30 DMI_MATCH(DMI_PRODUCT_NAME, "A6VC")
36 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
37 DMI_MATCH(DMI_PRODUCT_NAME, "A6VM")
43 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
44 DMI_MATCH(DMI_PRODUCT_NAME, "A6JC")
50 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
51 DMI_MATCH(DMI_PRODUCT_NAME, "A6J")
57 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
58 DMI_MATCH(DMI_PRODUCT_NAME, "A6Kt")
64 static void ov9650_dump_registers(struct sd *sd);
66 int ov9650_read_sensor(struct sd *sd, const u8 address,
67 u8 *i2c_data, const u8 len)
71 /* The ov9650 registers have a max depth of one byte */
76 err = m5602_read_bridge(sd, M5602_XB_I2C_STATUS, i2c_data);
77 } while ((*i2c_data & I2C_BUSY) && !err);
79 err = m5602_write_bridge(sd, M5602_XB_I2C_DEV_ADDR,
84 err = m5602_write_bridge(sd, M5602_XB_I2C_REG_ADDR, address);
88 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x10 + len);
92 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x08);
94 for (i = 0; (i < len) && !err; i++) {
95 err = m5602_read_bridge(sd, M5602_XB_I2C_DATA, &(i2c_data[i]));
97 PDEBUG(D_CONF, "Reading sensor register "
98 "0x%x containing 0x%x ", address, *i2c_data);
102 return (err < 0) ? err : 0;
105 int ov9650_probe(struct sd *sd)
107 u8 prod_id = 0, ver_id = 0, i;
110 if (force_sensor == OV9650_SENSOR) {
111 info("Forcing an %s sensor", ov9650.name);
114 /* If we want to force another sensor,
115 don't try to probe this one */
119 info("Probing for an ov9650 sensor");
121 /* Run the pre-init to actually probe the unit */
122 for (i = 0; i < ARRAY_SIZE(preinit_ov9650); i++) {
123 u8 data = preinit_ov9650[i][2];
124 if (preinit_ov9650[i][0] == SENSOR)
125 m5602_write_sensor(sd,
126 preinit_ov9650[i][1], &data, 1);
128 m5602_write_bridge(sd, preinit_ov9650[i][1], data);
131 if (ov9650_read_sensor(sd, OV9650_PID, &prod_id, 1))
134 if (ov9650_read_sensor(sd, OV9650_VER, &ver_id, 1))
137 if ((prod_id == 0x96) && (ver_id == 0x52)) {
138 info("Detected an ov9650 sensor");
145 sd->gspca_dev.cam.cam_mode = ov9650.modes;
146 sd->gspca_dev.cam.nmodes = ov9650.nmodes;
147 sd->desc->ctrls = ov9650.ctrls;
148 sd->desc->nctrls = ov9650.nctrls;
152 int ov9650_init(struct sd *sd)
158 ov9650_dump_registers(sd);
160 for (i = 0; i < ARRAY_SIZE(init_ov9650) && !err; i++) {
161 data = init_ov9650[i][2];
162 if (init_ov9650[i][0] == SENSOR)
163 err = m5602_write_sensor(sd, init_ov9650[i][1],
166 err = m5602_write_bridge(sd, init_ov9650[i][1], data);
169 if (dmi_check_system(ov9650_flip_dmi_table) && !err) {
170 info("vflip quirk active");
172 err = m5602_write_sensor(sd, OV9650_MVFP, &data, 1);
178 int ov9650_power_down(struct sd *sd)
181 for (i = 0; i < ARRAY_SIZE(power_down_ov9650) && !err; i++) {
182 u8 data = power_down_ov9650[i][2];
183 if (power_down_ov9650[i][0] == SENSOR)
184 err = m5602_write_sensor(sd,
185 power_down_ov9650[i][1], &data, 1);
187 err = m5602_write_bridge(sd, power_down_ov9650[i][1],
194 int ov9650_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
196 struct sd *sd = (struct sd *) gspca_dev;
200 err = ov9650_read_sensor(sd, OV9650_COM1, &i2c_data, 1);
203 *val = i2c_data & 0x03;
205 err = ov9650_read_sensor(sd, OV9650_AECH, &i2c_data, 1);
208 *val |= (i2c_data << 2);
210 err = ov9650_read_sensor(sd, OV9650_AECHM, &i2c_data, 1);
213 *val |= (i2c_data & 0x3f) << 10;
215 PDEBUG(D_V4L2, "Read exposure %d", *val);
220 int ov9650_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
222 struct sd *sd = (struct sd *) gspca_dev;
226 PDEBUG(D_V4L2, "Set exposure to %d",
230 i2c_data = (val >> 10) & 0x3f;
231 err = m5602_write_sensor(sd, OV9650_AECHM,
236 /* The 8 middle bits */
237 i2c_data = (val >> 2) & 0xff;
238 err = m5602_write_sensor(sd, OV9650_AECH,
244 i2c_data = val & 0x03;
245 err = m5602_write_sensor(sd, OV9650_COM1, &i2c_data, 1);
251 int ov9650_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
255 struct sd *sd = (struct sd *) gspca_dev;
257 ov9650_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
258 *val = (i2c_data & 0x03) << 8;
260 err = ov9650_read_sensor(sd, OV9650_GAIN, &i2c_data, 1);
262 PDEBUG(D_V4L2, "Read gain %d", *val);
266 int ov9650_set_gain(struct gspca_dev *gspca_dev, __s32 val)
270 struct sd *sd = (struct sd *) gspca_dev;
273 /* Read the OV9650_VREF register first to avoid
274 corrupting the VREF high and low bits */
275 ov9650_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
276 /* Mask away all uninteresting bits */
277 i2c_data = ((val & 0x0300) >> 2) |
279 err = m5602_write_sensor(sd, OV9650_VREF, &i2c_data, 1);
282 i2c_data = val & 0xff;
283 err = m5602_write_sensor(sd, OV9650_GAIN, &i2c_data, 1);
287 int ov9650_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
291 struct sd *sd = (struct sd *) gspca_dev;
293 err = ov9650_read_sensor(sd, OV9650_RED, &i2c_data, 1);
296 PDEBUG(D_V4L2, "Read red gain %d", *val);
301 int ov9650_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
305 struct sd *sd = (struct sd *) gspca_dev;
307 PDEBUG(D_V4L2, "Set red gain to %d",
310 i2c_data = val & 0xff;
311 err = m5602_write_sensor(sd, OV9650_RED, &i2c_data, 1);
316 int ov9650_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
320 struct sd *sd = (struct sd *) gspca_dev;
322 err = ov9650_read_sensor(sd, OV9650_BLUE, &i2c_data, 1);
325 PDEBUG(D_V4L2, "Read blue gain %d", *val);
330 int ov9650_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
334 struct sd *sd = (struct sd *) gspca_dev;
336 PDEBUG(D_V4L2, "Set blue gain to %d",
339 i2c_data = val & 0xff;
340 err = m5602_write_sensor(sd, OV9650_BLUE, &i2c_data, 1);
345 int ov9650_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
349 struct sd *sd = (struct sd *) gspca_dev;
351 err = ov9650_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
352 if (dmi_check_system(ov9650_flip_dmi_table))
353 *val = ((i2c_data & OV9650_HFLIP) >> 5) ? 0 : 1;
355 *val = (i2c_data & OV9650_HFLIP) >> 5;
356 PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
361 int ov9650_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
365 struct sd *sd = (struct sd *) gspca_dev;
367 PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
368 err = ov9650_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
372 if (dmi_check_system(ov9650_flip_dmi_table))
373 i2c_data = ((i2c_data & 0xdf) |
374 (((val ? 0 : 1) & 0x01) << 5));
376 i2c_data = ((i2c_data & 0xdf) |
377 ((val & 0x01) << 5));
379 err = m5602_write_sensor(sd, OV9650_MVFP, &i2c_data, 1);
384 int ov9650_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
388 struct sd *sd = (struct sd *) gspca_dev;
390 err = ov9650_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
391 if (dmi_check_system(ov9650_flip_dmi_table))
392 *val = ((i2c_data & 0x10) >> 4) ? 0 : 1;
394 *val = (i2c_data & 0x10) >> 4;
395 PDEBUG(D_V4L2, "Read vertical flip %d", *val);
400 int ov9650_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
404 struct sd *sd = (struct sd *) gspca_dev;
406 PDEBUG(D_V4L2, "Set vertical flip to %d", val);
407 err = ov9650_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
411 if (dmi_check_system(ov9650_flip_dmi_table))
412 i2c_data = ((i2c_data & 0xef) |
413 (((val ? 0 : 1) & 0x01) << 4));
415 i2c_data = ((i2c_data & 0xef) |
416 ((val & 0x01) << 4));
418 err = m5602_write_sensor(sd, OV9650_MVFP, &i2c_data, 1);
423 int ov9650_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
427 struct sd *sd = (struct sd *) gspca_dev;
429 err = ov9650_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
432 *val = (i2c_data & 0x03) << 8;
434 err = ov9650_read_sensor(sd, OV9650_GAIN, &i2c_data, 1);
436 PDEBUG(D_V4L2, "Read gain %d", *val);
441 int ov9650_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
445 struct sd *sd = (struct sd *) gspca_dev;
447 PDEBUG(D_V4L2, "Set gain to %d", val & 0x3ff);
449 /* Read the OV9650_VREF register first to avoid
450 corrupting the VREF high and low bits */
451 err = ov9650_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
455 /* Mask away all uninteresting bits */
456 i2c_data = ((val & 0x0300) >> 2) | (i2c_data & 0x3F);
457 err = m5602_write_sensor(sd, OV9650_VREF, &i2c_data, 1);
462 i2c_data = val & 0xff;
463 err = m5602_write_sensor(sd, OV9650_GAIN, &i2c_data, 1);
469 int ov9650_get_auto_white_balance(struct gspca_dev *gspca_dev, __s32 *val)
473 struct sd *sd = (struct sd *) gspca_dev;
475 err = ov9650_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
476 *val = (i2c_data & OV9650_AWB_EN) >> 1;
477 PDEBUG(D_V4L2, "Read auto white balance %d", *val);
482 int ov9650_set_auto_white_balance(struct gspca_dev *gspca_dev, __s32 val)
486 struct sd *sd = (struct sd *) gspca_dev;
488 PDEBUG(D_V4L2, "Set auto white balance to %d", val);
489 err = ov9650_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
493 i2c_data = ((i2c_data & 0xfd) | ((val & 0x01) << 1));
494 err = m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
499 int ov9650_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val)
503 struct sd *sd = (struct sd *) gspca_dev;
505 err = ov9650_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
506 *val = (i2c_data & OV9650_AGC_EN) >> 2;
507 PDEBUG(D_V4L2, "Read auto gain control %d", *val);
512 int ov9650_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val)
516 struct sd *sd = (struct sd *) gspca_dev;
518 PDEBUG(D_V4L2, "Set auto gain control to %d", val);
519 err = ov9650_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
523 i2c_data = ((i2c_data & 0xfb) | ((val & 0x01) << 2));
524 err = m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
529 static void ov9650_dump_registers(struct sd *sd)
532 info("Dumping the ov9650 register state");
533 for (address = 0; address < 0xa9; address++) {
535 ov9650_read_sensor(sd, address, &value, 1);
536 info("register 0x%x contains 0x%x",
540 info("ov9650 register state dump complete");
542 info("Probing for which registers that are read/write");
543 for (address = 0; address < 0xff; address++) {
544 u8 old_value, ctrl_value;
545 u8 test_value[2] = {0xff, 0xff};
547 ov9650_read_sensor(sd, address, &old_value, 1);
548 m5602_write_sensor(sd, address, test_value, 1);
549 ov9650_read_sensor(sd, address, &ctrl_value, 1);
551 if (ctrl_value == test_value[0])
552 info("register 0x%x is writeable", address);
554 info("register 0x%x is read only", address);
556 /* Restore original value */
557 m5602_write_sensor(sd, address, &old_value, 1);