2 * Driver for the s5k4aa 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_s5k4aa.h"
21 static int s5k4aa_get_exposure(struct gspca_dev *gspca_dev, __s32 *val);
22 static int s5k4aa_set_exposure(struct gspca_dev *gspca_dev, __s32 val);
23 static int s5k4aa_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
24 static int s5k4aa_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
25 static int s5k4aa_get_hflip(struct gspca_dev *gspca_dev, __s32 *val);
26 static int s5k4aa_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
27 static int s5k4aa_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
28 static int s5k4aa_set_gain(struct gspca_dev *gspca_dev, __s32 val);
29 static int s5k4aa_get_noise(struct gspca_dev *gspca_dev, __s32 *val);
30 static int s5k4aa_set_noise(struct gspca_dev *gspca_dev, __s32 val);
31 static int s5k4aa_get_brightness(struct gspca_dev *gspca_dev, __s32 *val);
32 static int s5k4aa_set_brightness(struct gspca_dev *gspca_dev, __s32 val);
36 struct dmi_system_id s5k4aa_vflip_dmi_table[] = {
38 .ident = "Fujitsu-Siemens Amilo Xa 2528",
40 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
41 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xa 2528")
44 .ident = "Fujitsu-Siemens Amilo Xi 2550",
46 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
47 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 2550")
52 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
53 DMI_MATCH(DMI_PRODUCT_NAME, "GX700"),
54 DMI_MATCH(DMI_BIOS_DATE, "07/26/2007")
57 .ident = "MSI GX700/GX705/EX700",
59 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
60 DMI_MATCH(DMI_PRODUCT_NAME, "GX700/GX705/EX700")
66 static struct v4l2_pix_format s5k4aa_modes[] = {
75 .colorspace = V4L2_COLORSPACE_SRGB,
80 static const struct ctrl s5k4aa_ctrls[] = {
85 .type = V4L2_CTRL_TYPE_BOOLEAN,
86 .name = "vertical flip",
92 .set = s5k4aa_set_vflip,
93 .get = s5k4aa_get_vflip
99 .type = V4L2_CTRL_TYPE_BOOLEAN,
100 .name = "horizontal flip",
106 .set = s5k4aa_set_hflip,
107 .get = s5k4aa_get_hflip
113 .type = V4L2_CTRL_TYPE_INTEGER,
118 .default_value = S5K4AA_DEFAULT_GAIN,
119 .flags = V4L2_CTRL_FLAG_SLIDER
121 .set = s5k4aa_set_gain,
122 .get = s5k4aa_get_gain
124 #define EXPOSURE_IDX 3
127 .id = V4L2_CID_EXPOSURE,
128 .type = V4L2_CTRL_TYPE_INTEGER,
133 .default_value = 0x100,
134 .flags = V4L2_CTRL_FLAG_SLIDER
136 .set = s5k4aa_set_exposure,
137 .get = s5k4aa_get_exposure
139 #define NOISE_SUPP_IDX 4
142 .id = V4L2_CID_PRIVATE_BASE,
143 .type = V4L2_CTRL_TYPE_BOOLEAN,
144 .name = "Noise suppression (smoothing)",
150 .set = s5k4aa_set_noise,
151 .get = s5k4aa_get_noise
153 #define BRIGHTNESS_IDX 5
156 .id = V4L2_CID_BRIGHTNESS,
157 .type = V4L2_CTRL_TYPE_INTEGER,
158 .name = "Brightness",
162 .default_value = S5K4AA_DEFAULT_BRIGHTNESS,
164 .set = s5k4aa_set_brightness,
165 .get = s5k4aa_get_brightness
170 static void s5k4aa_dump_registers(struct sd *sd);
172 int s5k4aa_probe(struct sd *sd)
174 u8 prod_id[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
175 const u8 expected_prod_id[6] = {0x00, 0x10, 0x00, 0x4b, 0x33, 0x75};
177 s32 *sensor_settings;
180 if (force_sensor == S5K4AA_SENSOR) {
181 info("Forcing a %s sensor", s5k4aa.name);
184 /* If we want to force another sensor, don't try to probe this
189 info("Probing for a s5k4aa sensor");
191 /* Preinit the sensor */
192 for (i = 0; i < ARRAY_SIZE(preinit_s5k4aa) && !err; i++) {
193 u8 data[2] = {0x00, 0x00};
195 switch (preinit_s5k4aa[i][0]) {
197 err = m5602_write_bridge(sd,
198 preinit_s5k4aa[i][1],
199 preinit_s5k4aa[i][2]);
203 data[0] = preinit_s5k4aa[i][2];
204 err = m5602_write_sensor(sd,
205 preinit_s5k4aa[i][1],
210 data[0] = preinit_s5k4aa[i][2];
211 data[1] = preinit_s5k4aa[i][3];
212 err = m5602_write_sensor(sd,
213 preinit_s5k4aa[i][1],
217 info("Invalid stream command, exiting init");
222 /* Test some registers, but we don't know their exact meaning yet */
223 if (m5602_read_sensor(sd, 0x00, prod_id, 2))
225 if (m5602_read_sensor(sd, 0x02, prod_id+2, 2))
227 if (m5602_read_sensor(sd, 0x04, prod_id+4, 2))
230 if (memcmp(prod_id, expected_prod_id, sizeof(prod_id)))
233 info("Detected a s5k4aa sensor");
236 sensor_settings = kmalloc(
237 ARRAY_SIZE(s5k4aa_ctrls) * sizeof(s32), GFP_KERNEL);
238 if (!sensor_settings)
241 sd->gspca_dev.cam.cam_mode = s5k4aa_modes;
242 sd->gspca_dev.cam.nmodes = ARRAY_SIZE(s5k4aa_modes);
243 sd->desc->ctrls = s5k4aa_ctrls;
244 sd->desc->nctrls = ARRAY_SIZE(s5k4aa_ctrls);
246 for (i = 0; i < ARRAY_SIZE(s5k4aa_ctrls); i++)
247 sensor_settings[i] = s5k4aa_ctrls[i].qctrl.default_value;
248 sd->sensor_priv = sensor_settings;
253 int s5k4aa_start(struct sd *sd)
257 struct cam *cam = &sd->gspca_dev.cam;
259 switch (cam->cam_mode[sd->gspca_dev.curr_mode].width) {
261 PDEBUG(D_V4L2, "Configuring camera for VGA mode");
263 for (i = 0; i < ARRAY_SIZE(VGA_s5k4aa); i++) {
264 switch (VGA_s5k4aa[i][0]) {
266 err = m5602_write_bridge(sd,
272 data[0] = VGA_s5k4aa[i][2];
273 err = m5602_write_sensor(sd,
279 data[0] = VGA_s5k4aa[i][2];
280 data[1] = VGA_s5k4aa[i][3];
281 err = m5602_write_sensor(sd,
287 err("Invalid stream command, exiting init");
295 int s5k4aa_init(struct sd *sd)
298 s32 *sensor_settings = sd->sensor_priv;
300 for (i = 0; i < ARRAY_SIZE(init_s5k4aa) && !err; i++) {
301 u8 data[2] = {0x00, 0x00};
303 switch (init_s5k4aa[i][0]) {
305 err = m5602_write_bridge(sd,
311 data[0] = init_s5k4aa[i][2];
312 err = m5602_write_sensor(sd,
313 init_s5k4aa[i][1], data, 1);
317 data[0] = init_s5k4aa[i][2];
318 data[1] = init_s5k4aa[i][3];
319 err = m5602_write_sensor(sd,
320 init_s5k4aa[i][1], data, 2);
323 info("Invalid stream command, exiting init");
329 s5k4aa_dump_registers(sd);
331 err = s5k4aa_set_exposure(&sd->gspca_dev,
332 sensor_settings[EXPOSURE_IDX]);
336 err = s5k4aa_set_gain(&sd->gspca_dev, sensor_settings[GAIN_IDX]);
340 err = s5k4aa_set_brightness(&sd->gspca_dev,
341 sensor_settings[BRIGHTNESS_IDX]);
345 err = s5k4aa_set_noise(&sd->gspca_dev, sensor_settings[NOISE_SUPP_IDX]);
349 err = s5k4aa_set_vflip(&sd->gspca_dev, sensor_settings[VFLIP_IDX]);
353 return s5k4aa_set_hflip(&sd->gspca_dev, sensor_settings[HFLIP_IDX]);
356 static int s5k4aa_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
358 struct sd *sd = (struct sd *) gspca_dev;
359 s32 *sensor_settings = sd->sensor_priv;
361 *val = sensor_settings[EXPOSURE_IDX];
362 PDEBUG(D_V4L2, "Read exposure %d", *val);
367 static int s5k4aa_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
369 struct sd *sd = (struct sd *) gspca_dev;
370 s32 *sensor_settings = sd->sensor_priv;
371 u8 data = S5K4AA_PAGE_MAP_2;
374 sensor_settings[EXPOSURE_IDX] = val;
375 PDEBUG(D_V4L2, "Set exposure to %d", val);
376 err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
379 data = (val >> 8) & 0xff;
380 err = m5602_write_sensor(sd, S5K4AA_EXPOSURE_HI, &data, 1);
384 err = m5602_write_sensor(sd, S5K4AA_EXPOSURE_LO, &data, 1);
389 static int s5k4aa_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
391 struct sd *sd = (struct sd *) gspca_dev;
392 s32 *sensor_settings = sd->sensor_priv;
394 *val = sensor_settings[VFLIP_IDX];
395 PDEBUG(D_V4L2, "Read vertical flip %d", *val);
400 static int s5k4aa_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
402 struct sd *sd = (struct sd *) gspca_dev;
403 s32 *sensor_settings = sd->sensor_priv;
404 u8 data = S5K4AA_PAGE_MAP_2;
407 sensor_settings[VFLIP_IDX] = val;
409 PDEBUG(D_V4L2, "Set vertical flip to %d", val);
410 err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
413 err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
417 err = m5602_read_sensor(sd, S5K4AA_READ_MODE, &data, 1);
421 if (dmi_check_system(s5k4aa_vflip_dmi_table)) {
423 data = (data & 0x3f) |
424 (!sensor_settings[HFLIP_IDX] << 6) |
427 data = (data & 0x3f) |
428 (sensor_settings[HFLIP_IDX] << 6) |
432 err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
437 err = m5602_read_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
442 err = m5602_write_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
444 err = m5602_read_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
449 err = m5602_write_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
454 static int s5k4aa_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
456 struct sd *sd = (struct sd *) gspca_dev;
457 s32 *sensor_settings = sd->sensor_priv;
459 *val = sensor_settings[HFLIP_IDX];
460 PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
465 static int s5k4aa_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
467 struct sd *sd = (struct sd *) gspca_dev;
468 s32 *sensor_settings = sd->sensor_priv;
469 u8 data = S5K4AA_PAGE_MAP_2;
472 sensor_settings[HFLIP_IDX] = val;
474 PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
475 err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
478 err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
482 err = m5602_read_sensor(sd, S5K4AA_READ_MODE, &data, 1);
486 if (dmi_check_system(s5k4aa_vflip_dmi_table)) {
488 data = (data & 0x3f) |
489 (!sensor_settings[VFLIP_IDX] << 7) |
492 data = (data & 0x3f) |
493 (sensor_settings[VFLIP_IDX] << 7) |
497 data = ((data & ~S5K4AA_RM_H_FLIP) | ((val & 0x01) << 6));
498 err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
503 err = m5602_read_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
507 err = m5602_write_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
511 err = m5602_read_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
515 err = m5602_write_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
520 static int s5k4aa_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
522 struct sd *sd = (struct sd *) gspca_dev;
523 s32 *sensor_settings = sd->sensor_priv;
525 *val = sensor_settings[GAIN_IDX];
526 PDEBUG(D_V4L2, "Read gain %d", *val);
530 static int s5k4aa_set_gain(struct gspca_dev *gspca_dev, __s32 val)
532 struct sd *sd = (struct sd *) gspca_dev;
533 s32 *sensor_settings = sd->sensor_priv;
534 u8 data = S5K4AA_PAGE_MAP_2;
537 sensor_settings[GAIN_IDX] = val;
539 PDEBUG(D_V4L2, "Set gain to %d", val);
540 err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
545 err = m5602_write_sensor(sd, S5K4AA_GAIN, &data, 1);
550 static int s5k4aa_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
552 struct sd *sd = (struct sd *) gspca_dev;
553 s32 *sensor_settings = sd->sensor_priv;
555 *val = sensor_settings[BRIGHTNESS_IDX];
556 PDEBUG(D_V4L2, "Read brightness %d", *val);
560 static int s5k4aa_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
562 struct sd *sd = (struct sd *) gspca_dev;
563 s32 *sensor_settings = sd->sensor_priv;
564 u8 data = S5K4AA_PAGE_MAP_2;
567 sensor_settings[BRIGHTNESS_IDX] = val;
569 PDEBUG(D_V4L2, "Set brightness to %d", val);
570 err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
575 return m5602_write_sensor(sd, S5K4AA_BRIGHTNESS, &data, 1);
578 static int s5k4aa_get_noise(struct gspca_dev *gspca_dev, __s32 *val)
580 struct sd *sd = (struct sd *) gspca_dev;
581 s32 *sensor_settings = sd->sensor_priv;
583 *val = sensor_settings[NOISE_SUPP_IDX];
584 PDEBUG(D_V4L2, "Read noise %d", *val);
588 static int s5k4aa_set_noise(struct gspca_dev *gspca_dev, __s32 val)
590 struct sd *sd = (struct sd *) gspca_dev;
591 s32 *sensor_settings = sd->sensor_priv;
592 u8 data = S5K4AA_PAGE_MAP_2;
595 sensor_settings[NOISE_SUPP_IDX] = val;
597 PDEBUG(D_V4L2, "Set noise to %d", val);
598 err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
603 return m5602_write_sensor(sd, S5K4AA_NOISE_SUPP, &data, 1);
606 void s5k4aa_disconnect(struct sd *sd)
609 kfree(sd->sensor_priv);
612 static void s5k4aa_dump_registers(struct sd *sd)
616 m5602_read_sensor(sd, S5K4AA_PAGE_MAP, &old_page, 1);
617 for (page = 0; page < 16; page++) {
618 m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &page, 1);
619 info("Dumping the s5k4aa register state for page 0x%x", page);
620 for (address = 0; address <= 0xff; address++) {
622 m5602_read_sensor(sd, address, &value, 1);
623 info("register 0x%x contains 0x%x",
627 info("s5k4aa register state dump complete");
629 for (page = 0; page < 16; page++) {
630 m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &page, 1);
631 info("Probing for which registers that are "
632 "read/write for page 0x%x", page);
633 for (address = 0; address <= 0xff; address++) {
634 u8 old_value, ctrl_value, test_value = 0xff;
636 m5602_read_sensor(sd, address, &old_value, 1);
637 m5602_write_sensor(sd, address, &test_value, 1);
638 m5602_read_sensor(sd, address, &ctrl_value, 1);
640 if (ctrl_value == test_value)
641 info("register 0x%x is writeable", address);
643 info("register 0x%x is read only", address);
645 /* Restore original value */
646 m5602_write_sensor(sd, address, &old_value, 1);
649 info("Read/write register probing complete");
650 m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &old_page, 1);