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 static int ov9650_set_exposure(struct gspca_dev *gspca_dev, __s32 val);
22 static int ov9650_get_exposure(struct gspca_dev *gspca_dev, __s32 *val);
23 static int ov9650_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
24 static int ov9650_set_gain(struct gspca_dev *gspca_dev, __s32 val);
25 static int ov9650_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val);
26 static int ov9650_set_red_balance(struct gspca_dev *gspca_dev, __s32 val);
27 static int ov9650_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val);
28 static int ov9650_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val);
29 static int ov9650_get_hflip(struct gspca_dev *gspca_dev, __s32 *val);
30 static int ov9650_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
31 static int ov9650_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
32 static int ov9650_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
33 static int ov9650_get_auto_white_balance(struct gspca_dev *gspca_dev,
35 static int ov9650_set_auto_white_balance(struct gspca_dev *gspca_dev,
37 static int ov9650_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val);
38 static int ov9650_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val);
39 static int ov9650_get_auto_exposure(struct gspca_dev *gspca_dev, __s32 *val);
40 static int ov9650_set_auto_exposure(struct gspca_dev *gspca_dev, __s32 val);
42 /* Vertically and horizontally flips the image if matched, needed for machines
43 where the sensor is mounted upside down */
46 struct dmi_system_id ov9650_flip_dmi_table[] = {
50 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
51 DMI_MATCH(DMI_PRODUCT_NAME, "A6VA")
58 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
59 DMI_MATCH(DMI_PRODUCT_NAME, "A6VC")
65 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
66 DMI_MATCH(DMI_PRODUCT_NAME, "A6VM")
72 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
73 DMI_MATCH(DMI_PRODUCT_NAME, "A6JC")
79 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
80 DMI_MATCH(DMI_PRODUCT_NAME, "A6J")
86 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
87 DMI_MATCH(DMI_PRODUCT_NAME, "A6Kt")
91 .ident = "Alienware Aurora m9700",
93 DMI_MATCH(DMI_SYS_VENDOR, "alienware"),
94 DMI_MATCH(DMI_PRODUCT_NAME, "Aurora m9700")
100 static const struct ctrl ov9650_ctrls[] = {
101 #define EXPOSURE_IDX 0
104 .id = V4L2_CID_EXPOSURE,
105 .type = V4L2_CTRL_TYPE_INTEGER,
110 .default_value = EXPOSURE_DEFAULT,
111 .flags = V4L2_CTRL_FLAG_SLIDER
113 .set = ov9650_set_exposure,
114 .get = ov9650_get_exposure
120 .type = V4L2_CTRL_TYPE_INTEGER,
125 .default_value = GAIN_DEFAULT,
126 .flags = V4L2_CTRL_FLAG_SLIDER
128 .set = ov9650_set_gain,
129 .get = ov9650_get_gain
131 #define RED_BALANCE_IDX 2
134 .type = V4L2_CTRL_TYPE_INTEGER,
135 .name = "red balance",
139 .default_value = RED_GAIN_DEFAULT,
140 .flags = V4L2_CTRL_FLAG_SLIDER
142 .set = ov9650_set_red_balance,
143 .get = ov9650_get_red_balance
145 #define BLUE_BALANCE_IDX 3
148 .type = V4L2_CTRL_TYPE_INTEGER,
149 .name = "blue balance",
153 .default_value = BLUE_GAIN_DEFAULT,
154 .flags = V4L2_CTRL_FLAG_SLIDER
156 .set = ov9650_set_blue_balance,
157 .get = ov9650_get_blue_balance
162 .id = V4L2_CID_HFLIP,
163 .type = V4L2_CTRL_TYPE_BOOLEAN,
164 .name = "horizontal flip",
170 .set = ov9650_set_hflip,
171 .get = ov9650_get_hflip
176 .id = V4L2_CID_VFLIP,
177 .type = V4L2_CTRL_TYPE_BOOLEAN,
178 .name = "vertical flip",
184 .set = ov9650_set_vflip,
185 .get = ov9650_get_vflip
187 #define AUTO_WHITE_BALANCE_IDX 6
190 .id = V4L2_CID_AUTO_WHITE_BALANCE,
191 .type = V4L2_CTRL_TYPE_BOOLEAN,
192 .name = "auto white balance",
198 .set = ov9650_set_auto_white_balance,
199 .get = ov9650_get_auto_white_balance
201 #define AUTO_GAIN_CTRL_IDX 7
204 .id = V4L2_CID_AUTOGAIN,
205 .type = V4L2_CTRL_TYPE_BOOLEAN,
206 .name = "auto gain control",
212 .set = ov9650_set_auto_gain,
213 .get = ov9650_get_auto_gain
215 #define AUTO_EXPOSURE_IDX 8
218 .id = V4L2_CID_EXPOSURE_AUTO,
219 .type = V4L2_CTRL_TYPE_BOOLEAN,
220 .name = "auto exposure",
226 .set = ov9650_set_auto_exposure,
227 .get = ov9650_get_auto_exposure
232 static struct v4l2_pix_format ov9650_modes[] = {
241 .colorspace = V4L2_COLORSPACE_SRGB,
251 .colorspace = V4L2_COLORSPACE_SRGB,
261 .colorspace = V4L2_COLORSPACE_SRGB,
271 .colorspace = V4L2_COLORSPACE_SRGB,
276 static void ov9650_dump_registers(struct sd *sd);
278 int ov9650_probe(struct sd *sd)
281 u8 prod_id = 0, ver_id = 0, i;
282 s32 *sensor_settings;
285 if (force_sensor == OV9650_SENSOR) {
286 info("Forcing an %s sensor", ov9650.name);
289 /* If we want to force another sensor,
290 don't try to probe this one */
294 info("Probing for an ov9650 sensor");
296 /* Run the pre-init before probing the sensor */
297 for (i = 0; i < ARRAY_SIZE(preinit_ov9650) && !err; i++) {
298 u8 data = preinit_ov9650[i][2];
299 if (preinit_ov9650[i][0] == SENSOR)
300 err = m5602_write_sensor(sd,
301 preinit_ov9650[i][1], &data, 1);
303 err = m5602_write_bridge(sd,
304 preinit_ov9650[i][1], data);
310 if (m5602_read_sensor(sd, OV9650_PID, &prod_id, 1))
313 if (m5602_read_sensor(sd, OV9650_VER, &ver_id, 1))
316 if ((prod_id == 0x96) && (ver_id == 0x52)) {
317 info("Detected an ov9650 sensor");
323 sensor_settings = kmalloc(
324 ARRAY_SIZE(ov9650_ctrls) * sizeof(s32), GFP_KERNEL);
325 if (!sensor_settings)
328 sd->gspca_dev.cam.cam_mode = ov9650_modes;
329 sd->gspca_dev.cam.nmodes = ARRAY_SIZE(ov9650_modes);
330 sd->desc->ctrls = ov9650_ctrls;
331 sd->desc->nctrls = ARRAY_SIZE(ov9650_ctrls);
333 for (i = 0; i < ARRAY_SIZE(ov9650_ctrls); i++)
334 sensor_settings[i] = ov9650_ctrls[i].qctrl.default_value;
335 sd->sensor_priv = sensor_settings;
339 int ov9650_init(struct sd *sd)
343 s32 *sensor_settings = sd->sensor_priv;
346 ov9650_dump_registers(sd);
348 for (i = 0; i < ARRAY_SIZE(init_ov9650) && !err; i++) {
349 data = init_ov9650[i][2];
350 if (init_ov9650[i][0] == SENSOR)
351 err = m5602_write_sensor(sd, init_ov9650[i][1],
354 err = m5602_write_bridge(sd, init_ov9650[i][1], data);
357 err = ov9650_set_exposure(&sd->gspca_dev,
358 sensor_settings[EXPOSURE_IDX]);
362 err = ov9650_set_gain(&sd->gspca_dev, sensor_settings[GAIN_IDX]);
366 err = ov9650_set_red_balance(&sd->gspca_dev,
367 sensor_settings[RED_BALANCE_IDX]);
371 err = ov9650_set_blue_balance(&sd->gspca_dev,
372 sensor_settings[BLUE_BALANCE_IDX]);
376 err = ov9650_set_hflip(&sd->gspca_dev, sensor_settings[HFLIP_IDX]);
380 err = ov9650_set_vflip(&sd->gspca_dev, sensor_settings[VFLIP_IDX]);
384 err = ov9650_set_auto_exposure(&sd->gspca_dev,
385 sensor_settings[AUTO_EXPOSURE_IDX]);
389 err = ov9650_set_auto_white_balance(&sd->gspca_dev,
390 sensor_settings[AUTO_WHITE_BALANCE_IDX]);
394 err = ov9650_set_auto_gain(&sd->gspca_dev,
395 sensor_settings[AUTO_GAIN_CTRL_IDX]);
399 int ov9650_start(struct sd *sd)
403 struct cam *cam = &sd->gspca_dev.cam;
404 s32 *sensor_settings = sd->sensor_priv;
406 int width = cam->cam_mode[sd->gspca_dev.curr_mode].width;
407 int height = cam->cam_mode[sd->gspca_dev.curr_mode].height;
408 int ver_offs = cam->cam_mode[sd->gspca_dev.curr_mode].priv;
409 int hor_offs = OV9650_LEFT_OFFSET;
411 if ((!dmi_check_system(ov9650_flip_dmi_table) &&
412 sensor_settings[VFLIP_IDX]) ||
413 (dmi_check_system(ov9650_flip_dmi_table) &&
414 !sensor_settings[VFLIP_IDX]))
420 /* Synthesize the vsync/hsync setup */
421 for (i = 0; i < ARRAY_SIZE(res_init_ov9650) && !err; i++) {
422 if (res_init_ov9650[i][0] == BRIDGE)
423 err = m5602_write_bridge(sd, res_init_ov9650[i][1],
424 res_init_ov9650[i][2]);
425 else if (res_init_ov9650[i][0] == SENSOR) {
426 u8 data = res_init_ov9650[i][2];
427 err = m5602_write_sensor(sd,
428 res_init_ov9650[i][1], &data, 1);
434 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA,
435 ((ver_offs >> 8) & 0xff));
439 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, (ver_offs & 0xff));
443 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, 0);
447 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, (height >> 8) & 0xff);
451 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, (height & 0xff));
455 for (i = 0; i < 2 && !err; i++)
456 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, 0);
460 err = m5602_write_bridge(sd, M5602_XB_SIG_INI, 0);
464 err = m5602_write_bridge(sd, M5602_XB_SIG_INI, 2);
468 err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA,
469 (hor_offs >> 8) & 0xff);
473 err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA, hor_offs & 0xff);
477 err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA,
478 ((width + hor_offs) >> 8) & 0xff);
482 err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA,
483 ((width + hor_offs) & 0xff));
487 err = m5602_write_bridge(sd, M5602_XB_SIG_INI, 0);
493 PDEBUG(D_V4L2, "Configuring camera for VGA mode");
495 data = OV9650_VGA_SELECT | OV9650_RGB_SELECT |
496 OV9650_RAW_RGB_SELECT;
497 err = m5602_write_sensor(sd, OV9650_COM7, &data, 1);
501 PDEBUG(D_V4L2, "Configuring camera for CIF mode");
503 data = OV9650_CIF_SELECT | OV9650_RGB_SELECT |
504 OV9650_RAW_RGB_SELECT;
505 err = m5602_write_sensor(sd, OV9650_COM7, &data, 1);
509 PDEBUG(D_V4L2, "Configuring camera for QVGA mode");
511 data = OV9650_QVGA_SELECT | OV9650_RGB_SELECT |
512 OV9650_RAW_RGB_SELECT;
513 err = m5602_write_sensor(sd, OV9650_COM7, &data, 1);
517 PDEBUG(D_V4L2, "Configuring camera for QCIF mode");
519 data = OV9650_QCIF_SELECT | OV9650_RGB_SELECT |
520 OV9650_RAW_RGB_SELECT;
521 err = m5602_write_sensor(sd, OV9650_COM7, &data, 1);
527 int ov9650_stop(struct sd *sd)
529 u8 data = OV9650_SOFT_SLEEP | OV9650_OUTPUT_DRIVE_2X;
530 return m5602_write_sensor(sd, OV9650_COM2, &data, 1);
533 void ov9650_disconnect(struct sd *sd)
538 kfree(sd->sensor_priv);
541 static int ov9650_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
543 struct sd *sd = (struct sd *) gspca_dev;
544 s32 *sensor_settings = sd->sensor_priv;
546 *val = sensor_settings[EXPOSURE_IDX];
547 PDEBUG(D_V4L2, "Read exposure %d", *val);
551 static int ov9650_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
553 struct sd *sd = (struct sd *) gspca_dev;
554 s32 *sensor_settings = sd->sensor_priv;
558 PDEBUG(D_V4L2, "Set exposure to %d", val);
560 sensor_settings[EXPOSURE_IDX] = val;
562 i2c_data = (val >> 10) & 0x3f;
563 err = m5602_write_sensor(sd, OV9650_AECHM,
568 /* The 8 middle bits */
569 i2c_data = (val >> 2) & 0xff;
570 err = m5602_write_sensor(sd, OV9650_AECH,
576 i2c_data = val & 0x03;
577 err = m5602_write_sensor(sd, OV9650_COM1, &i2c_data, 1);
581 static int ov9650_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
583 struct sd *sd = (struct sd *) gspca_dev;
584 s32 *sensor_settings = sd->sensor_priv;
586 *val = sensor_settings[GAIN_IDX];
587 PDEBUG(D_V4L2, "Read gain %d", *val);
591 static int ov9650_set_gain(struct gspca_dev *gspca_dev, __s32 val)
595 struct sd *sd = (struct sd *) gspca_dev;
596 s32 *sensor_settings = sd->sensor_priv;
598 PDEBUG(D_V4L2, "Setting gain to %d", val);
600 sensor_settings[GAIN_IDX] = val;
603 /* Read the OV9650_VREF register first to avoid
604 corrupting the VREF high and low bits */
605 err = m5602_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
609 /* Mask away all uninteresting bits */
610 i2c_data = ((val & 0x0300) >> 2) |
612 err = m5602_write_sensor(sd, OV9650_VREF, &i2c_data, 1);
617 i2c_data = val & 0xff;
618 err = m5602_write_sensor(sd, OV9650_GAIN, &i2c_data, 1);
622 static int ov9650_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
624 struct sd *sd = (struct sd *) gspca_dev;
625 s32 *sensor_settings = sd->sensor_priv;
627 *val = sensor_settings[RED_BALANCE_IDX];
628 PDEBUG(D_V4L2, "Read red gain %d", *val);
632 static int ov9650_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
636 struct sd *sd = (struct sd *) gspca_dev;
637 s32 *sensor_settings = sd->sensor_priv;
639 PDEBUG(D_V4L2, "Set red gain to %d", val);
641 sensor_settings[RED_BALANCE_IDX] = val;
643 i2c_data = val & 0xff;
644 err = m5602_write_sensor(sd, OV9650_RED, &i2c_data, 1);
648 static int ov9650_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
650 struct sd *sd = (struct sd *) gspca_dev;
651 s32 *sensor_settings = sd->sensor_priv;
653 *val = sensor_settings[BLUE_BALANCE_IDX];
654 PDEBUG(D_V4L2, "Read blue gain %d", *val);
659 static int ov9650_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
663 struct sd *sd = (struct sd *) gspca_dev;
664 s32 *sensor_settings = sd->sensor_priv;
666 PDEBUG(D_V4L2, "Set blue gain to %d", val);
668 sensor_settings[BLUE_BALANCE_IDX] = val;
670 i2c_data = val & 0xff;
671 err = m5602_write_sensor(sd, OV9650_BLUE, &i2c_data, 1);
675 static int ov9650_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
677 struct sd *sd = (struct sd *) gspca_dev;
678 s32 *sensor_settings = sd->sensor_priv;
680 *val = sensor_settings[HFLIP_IDX];
681 PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
685 static int ov9650_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
689 struct sd *sd = (struct sd *) gspca_dev;
690 s32 *sensor_settings = sd->sensor_priv;
692 PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
694 sensor_settings[HFLIP_IDX] = val;
696 if (!dmi_check_system(ov9650_flip_dmi_table))
697 i2c_data = ((val & 0x01) << 5) |
698 (sensor_settings[VFLIP_IDX] << 4);
700 i2c_data = ((val & 0x01) << 5) |
701 (!sensor_settings[VFLIP_IDX] << 4);
703 err = m5602_write_sensor(sd, OV9650_MVFP, &i2c_data, 1);
708 static int ov9650_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
710 struct sd *sd = (struct sd *) gspca_dev;
711 s32 *sensor_settings = sd->sensor_priv;
713 *val = sensor_settings[VFLIP_IDX];
714 PDEBUG(D_V4L2, "Read vertical flip %d", *val);
719 static int ov9650_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
723 struct sd *sd = (struct sd *) gspca_dev;
724 s32 *sensor_settings = sd->sensor_priv;
726 PDEBUG(D_V4L2, "Set vertical flip to %d", val);
727 sensor_settings[VFLIP_IDX] = val;
729 if (dmi_check_system(ov9650_flip_dmi_table))
732 i2c_data = ((val & 0x01) << 4) | (sensor_settings[VFLIP_IDX] << 5);
733 err = m5602_write_sensor(sd, OV9650_MVFP, &i2c_data, 1);
737 /* When vflip is toggled we need to readjust the bridge hsync/vsync */
738 if (gspca_dev->streaming)
739 err = ov9650_start(sd);
744 static int ov9650_get_auto_exposure(struct gspca_dev *gspca_dev, __s32 *val)
746 struct sd *sd = (struct sd *) gspca_dev;
747 s32 *sensor_settings = sd->sensor_priv;
749 *val = sensor_settings[AUTO_EXPOSURE_IDX];
750 PDEBUG(D_V4L2, "Read auto exposure control %d", *val);
754 static int ov9650_set_auto_exposure(struct gspca_dev *gspca_dev,
759 struct sd *sd = (struct sd *) gspca_dev;
760 s32 *sensor_settings = sd->sensor_priv;
762 PDEBUG(D_V4L2, "Set auto exposure control to %d", val);
764 sensor_settings[AUTO_EXPOSURE_IDX] = val;
765 err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
769 i2c_data = ((i2c_data & 0xfe) | ((val & 0x01) << 0));
771 return m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
774 static int ov9650_get_auto_white_balance(struct gspca_dev *gspca_dev,
777 struct sd *sd = (struct sd *) gspca_dev;
778 s32 *sensor_settings = sd->sensor_priv;
780 *val = sensor_settings[AUTO_WHITE_BALANCE_IDX];
784 static int ov9650_set_auto_white_balance(struct gspca_dev *gspca_dev,
789 struct sd *sd = (struct sd *) gspca_dev;
790 s32 *sensor_settings = sd->sensor_priv;
792 PDEBUG(D_V4L2, "Set auto white balance to %d", val);
794 sensor_settings[AUTO_WHITE_BALANCE_IDX] = val;
795 err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
799 i2c_data = ((i2c_data & 0xfd) | ((val & 0x01) << 1));
800 err = m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
805 static int ov9650_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val)
807 struct sd *sd = (struct sd *) gspca_dev;
808 s32 *sensor_settings = sd->sensor_priv;
810 *val = sensor_settings[AUTO_GAIN_CTRL_IDX];
811 PDEBUG(D_V4L2, "Read auto gain control %d", *val);
815 static int ov9650_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val)
819 struct sd *sd = (struct sd *) gspca_dev;
820 s32 *sensor_settings = sd->sensor_priv;
822 PDEBUG(D_V4L2, "Set auto gain control to %d", val);
824 sensor_settings[AUTO_GAIN_CTRL_IDX] = val;
825 err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
829 i2c_data = ((i2c_data & 0xfb) | ((val & 0x01) << 2));
831 return m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
834 static void ov9650_dump_registers(struct sd *sd)
837 info("Dumping the ov9650 register state");
838 for (address = 0; address < 0xa9; address++) {
840 m5602_read_sensor(sd, address, &value, 1);
841 info("register 0x%x contains 0x%x",
845 info("ov9650 register state dump complete");
847 info("Probing for which registers that are read/write");
848 for (address = 0; address < 0xff; address++) {
849 u8 old_value, ctrl_value;
850 u8 test_value[2] = {0xff, 0xff};
852 m5602_read_sensor(sd, address, &old_value, 1);
853 m5602_write_sensor(sd, address, test_value, 1);
854 m5602_read_sensor(sd, address, &ctrl_value, 1);
856 if (ctrl_value == test_value[0])
857 info("register 0x%x is writeable", address);
859 info("register 0x%x is read only", address);
861 /* Restore original value */
862 m5602_write_sensor(sd, address, &old_value, 1);