Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 1 | /* |
| 2 | * Driver for the s5k4aa sensor |
| 3 | * |
Erik Andren | 0c505e68 | 2008-10-16 16:43:16 -0300 | [diff] [blame] | 4 | * Copyright (C) 2008 Erik Andrén |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 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> |
| 7 | * |
| 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 |
| 12 | * |
| 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. |
| 16 | * |
| 17 | */ |
| 18 | |
| 19 | #include "m5602_s5k4aa.h" |
| 20 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 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); |
Erik Andr?n | 3290d40 | 2009-01-13 16:40:28 -0300 | [diff] [blame] | 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); |
Erik Andr?n | 7ee4629 | 2009-01-14 03:37:03 -0300 | [diff] [blame] | 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); |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 33 | |
Erik Andrén | 579ef87 | 2008-11-18 14:38:10 -0300 | [diff] [blame] | 34 | static |
| 35 | const |
| 36 | struct dmi_system_id s5k4aa_vflip_dmi_table[] = { |
| 37 | { |
| 38 | .ident = "Fujitsu-Siemens Amilo Xa 2528", |
| 39 | .matches = { |
| 40 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), |
| 41 | DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xa 2528") |
| 42 | } |
| 43 | }, { |
| 44 | .ident = "Fujitsu-Siemens Amilo Xi 2550", |
| 45 | .matches = { |
| 46 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), |
| 47 | DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 2550") |
| 48 | } |
| 49 | }, { |
Erik Andrén | 9760677 | 2009-07-01 02:49:23 -0300 | [diff] [blame] | 50 | .ident = "Fujitsu-Siemens Amilo Pa 2548", |
| 51 | .matches = { |
| 52 | DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), |
| 53 | DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pa 2548") |
| 54 | } |
| 55 | }, { |
Erik Andrén | 579ef87 | 2008-11-18 14:38:10 -0300 | [diff] [blame] | 56 | .ident = "MSI GX700", |
| 57 | .matches = { |
| 58 | DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), |
| 59 | DMI_MATCH(DMI_PRODUCT_NAME, "GX700"), |
| 60 | DMI_MATCH(DMI_BIOS_DATE, "07/26/2007") |
| 61 | } |
| 62 | }, { |
Brian Kloppenborg | 95e6dcd | 2009-08-30 09:43:40 -0300 | [diff] [blame] | 63 | .ident = "MSI GX700", |
| 64 | .matches = { |
| 65 | DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), |
| 66 | DMI_MATCH(DMI_PRODUCT_NAME, "GX700"), |
| 67 | DMI_MATCH(DMI_BIOS_DATE, "07/19/2007") |
| 68 | } |
| 69 | }, { |
Erik Andrén | 579ef87 | 2008-11-18 14:38:10 -0300 | [diff] [blame] | 70 | .ident = "MSI GX700/GX705/EX700", |
| 71 | .matches = { |
| 72 | DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), |
| 73 | DMI_MATCH(DMI_PRODUCT_NAME, "GX700/GX705/EX700") |
| 74 | } |
Erik Andrén | 79c3576 | 2009-02-12 16:36:05 -0300 | [diff] [blame] | 75 | }, { |
| 76 | .ident = "MSI L735", |
| 77 | .matches = { |
| 78 | DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), |
| 79 | DMI_MATCH(DMI_PRODUCT_NAME, "MS-1717X") |
| 80 | } |
Erik Andrén | f02c394 | 2009-05-06 17:44:45 -0300 | [diff] [blame] | 81 | }, { |
| 82 | .ident = "Lenovo Y300", |
| 83 | .matches = { |
| 84 | DMI_MATCH(DMI_SYS_VENDOR, "L3000 Y300"), |
| 85 | DMI_MATCH(DMI_PRODUCT_NAME, "Y300") |
| 86 | } |
Erik Andrén | 579ef87 | 2008-11-18 14:38:10 -0300 | [diff] [blame] | 87 | }, |
| 88 | { } |
| 89 | }; |
| 90 | |
Erik Andr?n | 74cadfe | 2008-12-30 16:48:42 -0300 | [diff] [blame] | 91 | static struct v4l2_pix_format s5k4aa_modes[] = { |
| 92 | { |
| 93 | 640, |
| 94 | 480, |
| 95 | V4L2_PIX_FMT_SBGGR8, |
| 96 | V4L2_FIELD_NONE, |
| 97 | .sizeimage = |
| 98 | 640 * 480, |
| 99 | .bytesperline = 640, |
| 100 | .colorspace = V4L2_COLORSPACE_SRGB, |
| 101 | .priv = 0 |
Grégory Lardière | 60d52ce | 2009-02-12 03:32:52 -0300 | [diff] [blame] | 102 | }, |
| 103 | { |
| 104 | 1280, |
| 105 | 1024, |
| 106 | V4L2_PIX_FMT_SBGGR8, |
| 107 | V4L2_FIELD_NONE, |
| 108 | .sizeimage = |
| 109 | 1280 * 1024, |
| 110 | .bytesperline = 1280, |
| 111 | .colorspace = V4L2_COLORSPACE_SRGB, |
| 112 | .priv = 0 |
Erik Andr?n | 74cadfe | 2008-12-30 16:48:42 -0300 | [diff] [blame] | 113 | } |
| 114 | }; |
| 115 | |
Tobias Klauser | 2e03669 | 2009-04-26 09:30:18 -0300 | [diff] [blame] | 116 | static const struct ctrl s5k4aa_ctrls[] = { |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 117 | #define VFLIP_IDX 0 |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 118 | { |
| 119 | { |
| 120 | .id = V4L2_CID_VFLIP, |
| 121 | .type = V4L2_CTRL_TYPE_BOOLEAN, |
| 122 | .name = "vertical flip", |
| 123 | .minimum = 0, |
| 124 | .maximum = 1, |
| 125 | .step = 1, |
| 126 | .default_value = 0 |
| 127 | }, |
| 128 | .set = s5k4aa_set_vflip, |
| 129 | .get = s5k4aa_get_vflip |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 130 | }, |
| 131 | #define HFLIP_IDX 1 |
| 132 | { |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 133 | { |
| 134 | .id = V4L2_CID_HFLIP, |
| 135 | .type = V4L2_CTRL_TYPE_BOOLEAN, |
| 136 | .name = "horizontal flip", |
| 137 | .minimum = 0, |
| 138 | .maximum = 1, |
| 139 | .step = 1, |
| 140 | .default_value = 0 |
| 141 | }, |
| 142 | .set = s5k4aa_set_hflip, |
| 143 | .get = s5k4aa_get_hflip |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 144 | }, |
| 145 | #define GAIN_IDX 2 |
| 146 | { |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 147 | { |
| 148 | .id = V4L2_CID_GAIN, |
| 149 | .type = V4L2_CTRL_TYPE_INTEGER, |
| 150 | .name = "Gain", |
| 151 | .minimum = 0, |
| 152 | .maximum = 127, |
| 153 | .step = 1, |
Erik Andr?n | 7ee4629 | 2009-01-14 03:37:03 -0300 | [diff] [blame] | 154 | .default_value = S5K4AA_DEFAULT_GAIN, |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 155 | .flags = V4L2_CTRL_FLAG_SLIDER |
| 156 | }, |
| 157 | .set = s5k4aa_set_gain, |
| 158 | .get = s5k4aa_get_gain |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 159 | }, |
| 160 | #define EXPOSURE_IDX 3 |
| 161 | { |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 162 | { |
| 163 | .id = V4L2_CID_EXPOSURE, |
| 164 | .type = V4L2_CTRL_TYPE_INTEGER, |
| 165 | .name = "Exposure", |
| 166 | .minimum = 13, |
| 167 | .maximum = 0xfff, |
| 168 | .step = 1, |
| 169 | .default_value = 0x100, |
| 170 | .flags = V4L2_CTRL_FLAG_SLIDER |
| 171 | }, |
| 172 | .set = s5k4aa_set_exposure, |
| 173 | .get = s5k4aa_get_exposure |
Erik Andr?n | 3290d40 | 2009-01-13 16:40:28 -0300 | [diff] [blame] | 174 | }, |
| 175 | #define NOISE_SUPP_IDX 4 |
| 176 | { |
| 177 | { |
| 178 | .id = V4L2_CID_PRIVATE_BASE, |
| 179 | .type = V4L2_CTRL_TYPE_BOOLEAN, |
| 180 | .name = "Noise suppression (smoothing)", |
| 181 | .minimum = 0, |
| 182 | .maximum = 1, |
| 183 | .step = 1, |
| 184 | .default_value = 1, |
| 185 | }, |
| 186 | .set = s5k4aa_set_noise, |
| 187 | .get = s5k4aa_get_noise |
| 188 | }, |
Erik Andr?n | 7ee4629 | 2009-01-14 03:37:03 -0300 | [diff] [blame] | 189 | #define BRIGHTNESS_IDX 5 |
| 190 | { |
| 191 | { |
| 192 | .id = V4L2_CID_BRIGHTNESS, |
| 193 | .type = V4L2_CTRL_TYPE_INTEGER, |
| 194 | .name = "Brightness", |
| 195 | .minimum = 0, |
| 196 | .maximum = 0x1f, |
| 197 | .step = 1, |
| 198 | .default_value = S5K4AA_DEFAULT_BRIGHTNESS, |
| 199 | }, |
| 200 | .set = s5k4aa_set_brightness, |
| 201 | .get = s5k4aa_get_brightness |
| 202 | }, |
| 203 | |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 204 | }; |
| 205 | |
Erik Andrén | 658efb6 | 2008-11-24 14:21:29 -0300 | [diff] [blame] | 206 | static void s5k4aa_dump_registers(struct sd *sd); |
Erik Andrén | 579ef87 | 2008-11-18 14:38:10 -0300 | [diff] [blame] | 207 | |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 208 | int s5k4aa_probe(struct sd *sd) |
| 209 | { |
| 210 | u8 prod_id[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
| 211 | const u8 expected_prod_id[6] = {0x00, 0x10, 0x00, 0x4b, 0x33, 0x75}; |
| 212 | int i, err = 0; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 213 | s32 *sensor_settings; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 214 | |
| 215 | if (force_sensor) { |
| 216 | if (force_sensor == S5K4AA_SENSOR) { |
| 217 | info("Forcing a %s sensor", s5k4aa.name); |
| 218 | goto sensor_found; |
| 219 | } |
| 220 | /* If we want to force another sensor, don't try to probe this |
| 221 | * one */ |
| 222 | return -ENODEV; |
| 223 | } |
| 224 | |
| 225 | info("Probing for a s5k4aa sensor"); |
| 226 | |
| 227 | /* Preinit the sensor */ |
| 228 | for (i = 0; i < ARRAY_SIZE(preinit_s5k4aa) && !err; i++) { |
| 229 | u8 data[2] = {0x00, 0x00}; |
| 230 | |
| 231 | switch (preinit_s5k4aa[i][0]) { |
| 232 | case BRIDGE: |
| 233 | err = m5602_write_bridge(sd, |
| 234 | preinit_s5k4aa[i][1], |
| 235 | preinit_s5k4aa[i][2]); |
| 236 | break; |
| 237 | |
| 238 | case SENSOR: |
| 239 | data[0] = preinit_s5k4aa[i][2]; |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 240 | err = m5602_write_sensor(sd, |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 241 | preinit_s5k4aa[i][1], |
| 242 | data, 1); |
| 243 | break; |
| 244 | |
| 245 | case SENSOR_LONG: |
| 246 | data[0] = preinit_s5k4aa[i][2]; |
| 247 | data[1] = preinit_s5k4aa[i][3]; |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 248 | err = m5602_write_sensor(sd, |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 249 | preinit_s5k4aa[i][1], |
| 250 | data, 2); |
| 251 | break; |
| 252 | default: |
| 253 | info("Invalid stream command, exiting init"); |
| 254 | return -EINVAL; |
| 255 | } |
| 256 | } |
| 257 | |
| 258 | /* Test some registers, but we don't know their exact meaning yet */ |
Gregory Lardiere | d2c4523 | 2009-02-22 17:54:11 -0300 | [diff] [blame] | 259 | if (m5602_read_sensor(sd, 0x00, prod_id, 2)) |
| 260 | return -ENODEV; |
| 261 | if (m5602_read_sensor(sd, 0x02, prod_id+2, 2)) |
| 262 | return -ENODEV; |
| 263 | if (m5602_read_sensor(sd, 0x04, prod_id+4, 2)) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 264 | return -ENODEV; |
| 265 | |
| 266 | if (memcmp(prod_id, expected_prod_id, sizeof(prod_id))) |
| 267 | return -ENODEV; |
| 268 | else |
| 269 | info("Detected a s5k4aa sensor"); |
Erik Andrén | 3250070 | 2008-11-20 04:02:44 -0300 | [diff] [blame] | 270 | |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 271 | sensor_found: |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 272 | sensor_settings = kmalloc( |
| 273 | ARRAY_SIZE(s5k4aa_ctrls) * sizeof(s32), GFP_KERNEL); |
| 274 | if (!sensor_settings) |
| 275 | return -ENOMEM; |
| 276 | |
Erik Andr?n | 74cadfe | 2008-12-30 16:48:42 -0300 | [diff] [blame] | 277 | sd->gspca_dev.cam.cam_mode = s5k4aa_modes; |
| 278 | sd->gspca_dev.cam.nmodes = ARRAY_SIZE(s5k4aa_modes); |
Erik Andr?n | e17cc08 | 2008-12-30 17:06:55 -0300 | [diff] [blame] | 279 | sd->desc->ctrls = s5k4aa_ctrls; |
Erik Andr?n | e4cc4fc | 2008-12-30 15:27:17 -0300 | [diff] [blame] | 280 | sd->desc->nctrls = ARRAY_SIZE(s5k4aa_ctrls); |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 281 | |
| 282 | for (i = 0; i < ARRAY_SIZE(s5k4aa_ctrls); i++) |
| 283 | sensor_settings[i] = s5k4aa_ctrls[i].qctrl.default_value; |
| 284 | sd->sensor_priv = sensor_settings; |
Erik Andr?n | d4a389a | 2009-01-09 03:30:54 -0300 | [diff] [blame] | 285 | |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 286 | return 0; |
| 287 | } |
| 288 | |
Erik Andr?n | ad567ec | 2008-12-26 12:57:42 -0300 | [diff] [blame] | 289 | int s5k4aa_start(struct sd *sd) |
| 290 | { |
| 291 | int i, err = 0; |
| 292 | u8 data[2]; |
| 293 | struct cam *cam = &sd->gspca_dev.cam; |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 294 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andr?n | ad567ec | 2008-12-26 12:57:42 -0300 | [diff] [blame] | 295 | |
Erik Andr?n | d4a389a | 2009-01-09 03:30:54 -0300 | [diff] [blame] | 296 | switch (cam->cam_mode[sd->gspca_dev.curr_mode].width) { |
Erik Andrén | 4fcec14 | 2009-01-29 13:34:41 -0300 | [diff] [blame] | 297 | case 1280: |
| 298 | PDEBUG(D_V4L2, "Configuring camera for SXGA mode"); |
| 299 | |
| 300 | for (i = 0; i < ARRAY_SIZE(SXGA_s5k4aa); i++) { |
| 301 | switch (SXGA_s5k4aa[i][0]) { |
| 302 | case BRIDGE: |
| 303 | err = m5602_write_bridge(sd, |
| 304 | SXGA_s5k4aa[i][1], |
| 305 | SXGA_s5k4aa[i][2]); |
| 306 | break; |
| 307 | |
| 308 | case SENSOR: |
| 309 | data[0] = SXGA_s5k4aa[i][2]; |
| 310 | err = m5602_write_sensor(sd, |
| 311 | SXGA_s5k4aa[i][1], |
| 312 | data, 1); |
| 313 | break; |
| 314 | |
| 315 | case SENSOR_LONG: |
| 316 | data[0] = SXGA_s5k4aa[i][2]; |
| 317 | data[1] = SXGA_s5k4aa[i][3]; |
| 318 | err = m5602_write_sensor(sd, |
| 319 | SXGA_s5k4aa[i][1], |
| 320 | data, 2); |
| 321 | break; |
| 322 | |
| 323 | default: |
| 324 | err("Invalid stream command, exiting init"); |
| 325 | return -EINVAL; |
| 326 | } |
| 327 | } |
Grégory Lardière | 60d52ce | 2009-02-12 03:32:52 -0300 | [diff] [blame] | 328 | err = s5k4aa_set_noise(&sd->gspca_dev, 0); |
| 329 | if (err < 0) |
| 330 | return err; |
| 331 | break; |
Erik Andrén | 4fcec14 | 2009-01-29 13:34:41 -0300 | [diff] [blame] | 332 | |
Erik Andr?n | ad567ec | 2008-12-26 12:57:42 -0300 | [diff] [blame] | 333 | case 640: |
| 334 | PDEBUG(D_V4L2, "Configuring camera for VGA mode"); |
| 335 | |
| 336 | for (i = 0; i < ARRAY_SIZE(VGA_s5k4aa); i++) { |
| 337 | switch (VGA_s5k4aa[i][0]) { |
| 338 | case BRIDGE: |
| 339 | err = m5602_write_bridge(sd, |
| 340 | VGA_s5k4aa[i][1], |
| 341 | VGA_s5k4aa[i][2]); |
| 342 | break; |
| 343 | |
| 344 | case SENSOR: |
| 345 | data[0] = VGA_s5k4aa[i][2]; |
| 346 | err = m5602_write_sensor(sd, |
| 347 | VGA_s5k4aa[i][1], |
| 348 | data, 1); |
| 349 | break; |
| 350 | |
| 351 | case SENSOR_LONG: |
| 352 | data[0] = VGA_s5k4aa[i][2]; |
| 353 | data[1] = VGA_s5k4aa[i][3]; |
| 354 | err = m5602_write_sensor(sd, |
| 355 | VGA_s5k4aa[i][1], |
| 356 | data, 2); |
| 357 | break; |
| 358 | |
| 359 | default: |
| 360 | err("Invalid stream command, exiting init"); |
| 361 | return -EINVAL; |
| 362 | } |
| 363 | } |
Grégory Lardière | 60d52ce | 2009-02-12 03:32:52 -0300 | [diff] [blame] | 364 | err = s5k4aa_set_noise(&sd->gspca_dev, 1); |
| 365 | if (err < 0) |
| 366 | return err; |
| 367 | break; |
Erik Andr?n | ad567ec | 2008-12-26 12:57:42 -0300 | [diff] [blame] | 368 | } |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 369 | if (err < 0) |
| 370 | return err; |
| 371 | |
| 372 | err = s5k4aa_set_exposure(&sd->gspca_dev, |
| 373 | sensor_settings[EXPOSURE_IDX]); |
| 374 | if (err < 0) |
| 375 | return err; |
| 376 | |
| 377 | err = s5k4aa_set_gain(&sd->gspca_dev, sensor_settings[GAIN_IDX]); |
| 378 | if (err < 0) |
| 379 | return err; |
| 380 | |
| 381 | err = s5k4aa_set_brightness(&sd->gspca_dev, |
| 382 | sensor_settings[BRIGHTNESS_IDX]); |
| 383 | if (err < 0) |
| 384 | return err; |
| 385 | |
| 386 | err = s5k4aa_set_noise(&sd->gspca_dev, sensor_settings[NOISE_SUPP_IDX]); |
| 387 | if (err < 0) |
| 388 | return err; |
| 389 | |
| 390 | err = s5k4aa_set_vflip(&sd->gspca_dev, sensor_settings[VFLIP_IDX]); |
| 391 | if (err < 0) |
| 392 | return err; |
| 393 | |
| 394 | return s5k4aa_set_hflip(&sd->gspca_dev, sensor_settings[HFLIP_IDX]); |
Erik Andr?n | ad567ec | 2008-12-26 12:57:42 -0300 | [diff] [blame] | 395 | } |
| 396 | |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 397 | int s5k4aa_init(struct sd *sd) |
| 398 | { |
| 399 | int i, err = 0; |
| 400 | |
| 401 | for (i = 0; i < ARRAY_SIZE(init_s5k4aa) && !err; i++) { |
| 402 | u8 data[2] = {0x00, 0x00}; |
| 403 | |
| 404 | switch (init_s5k4aa[i][0]) { |
| 405 | case BRIDGE: |
| 406 | err = m5602_write_bridge(sd, |
| 407 | init_s5k4aa[i][1], |
| 408 | init_s5k4aa[i][2]); |
| 409 | break; |
| 410 | |
| 411 | case SENSOR: |
| 412 | data[0] = init_s5k4aa[i][2]; |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 413 | err = m5602_write_sensor(sd, |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 414 | init_s5k4aa[i][1], data, 1); |
| 415 | break; |
| 416 | |
| 417 | case SENSOR_LONG: |
| 418 | data[0] = init_s5k4aa[i][2]; |
| 419 | data[1] = init_s5k4aa[i][3]; |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 420 | err = m5602_write_sensor(sd, |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 421 | init_s5k4aa[i][1], data, 2); |
| 422 | break; |
| 423 | default: |
| 424 | info("Invalid stream command, exiting init"); |
| 425 | return -EINVAL; |
| 426 | } |
| 427 | } |
| 428 | |
Erik Andr?n | 36e756c | 2009-01-09 13:35:00 -0300 | [diff] [blame] | 429 | if (dump_sensor) |
| 430 | s5k4aa_dump_registers(sd); |
| 431 | |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 432 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 433 | } |
| 434 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 435 | static int s5k4aa_get_exposure(struct gspca_dev *gspca_dev, __s32 *val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 436 | { |
| 437 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 438 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 439 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 440 | *val = sensor_settings[EXPOSURE_IDX]; |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 441 | PDEBUG(D_V4L2, "Read exposure %d", *val); |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 442 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 443 | return 0; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 444 | } |
| 445 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 446 | static int s5k4aa_set_exposure(struct gspca_dev *gspca_dev, __s32 val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 447 | { |
| 448 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 449 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 450 | u8 data = S5K4AA_PAGE_MAP_2; |
| 451 | int err; |
| 452 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 453 | sensor_settings[EXPOSURE_IDX] = val; |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 454 | PDEBUG(D_V4L2, "Set exposure to %d", val); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 455 | err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 456 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 457 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 458 | data = (val >> 8) & 0xff; |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 459 | err = m5602_write_sensor(sd, S5K4AA_EXPOSURE_HI, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 460 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 461 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 462 | data = val & 0xff; |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 463 | err = m5602_write_sensor(sd, S5K4AA_EXPOSURE_LO, &data, 1); |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 464 | |
Erik Andrén | 3250070 | 2008-11-20 04:02:44 -0300 | [diff] [blame] | 465 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 466 | } |
| 467 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 468 | static int s5k4aa_get_vflip(struct gspca_dev *gspca_dev, __s32 *val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 469 | { |
| 470 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 471 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 472 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 473 | *val = sensor_settings[VFLIP_IDX]; |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 474 | PDEBUG(D_V4L2, "Read vertical flip %d", *val); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 475 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 476 | return 0; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 477 | } |
| 478 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 479 | static int s5k4aa_set_vflip(struct gspca_dev *gspca_dev, __s32 val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 480 | { |
| 481 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 482 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 483 | u8 data = S5K4AA_PAGE_MAP_2; |
| 484 | int err; |
| 485 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 486 | sensor_settings[VFLIP_IDX] = val; |
| 487 | |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 488 | PDEBUG(D_V4L2, "Set vertical flip to %d", val); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 489 | err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 490 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 491 | return err; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 492 | |
Erik Andr?n | a68985d | 2009-01-13 15:44:03 -0300 | [diff] [blame] | 493 | err = m5602_read_sensor(sd, S5K4AA_READ_MODE, &data, 1); |
| 494 | if (err < 0) |
| 495 | return err; |
| 496 | |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 497 | if (dmi_check_system(s5k4aa_vflip_dmi_table)) |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 498 | val = !val; |
| 499 | |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 500 | data = ((data & ~S5K4AA_RM_V_FLIP) | ((val & 0x01) << 7)); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 501 | err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 502 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 503 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 504 | |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 505 | err = m5602_read_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1); |
| 506 | if (err < 0) |
| 507 | return err; |
| 508 | data = (data & 0xfe) | !val; |
| 509 | err = m5602_write_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1); |
Erik Andrén | 3250070 | 2008-11-20 04:02:44 -0300 | [diff] [blame] | 510 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 511 | } |
| 512 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 513 | static int s5k4aa_get_hflip(struct gspca_dev *gspca_dev, __s32 *val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 514 | { |
| 515 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 516 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 517 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 518 | *val = sensor_settings[HFLIP_IDX]; |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 519 | PDEBUG(D_V4L2, "Read horizontal flip %d", *val); |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 520 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 521 | return 0; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 522 | } |
| 523 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 524 | static int s5k4aa_set_hflip(struct gspca_dev *gspca_dev, __s32 val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 525 | { |
| 526 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 527 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 528 | u8 data = S5K4AA_PAGE_MAP_2; |
| 529 | int err; |
| 530 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 531 | sensor_settings[HFLIP_IDX] = val; |
| 532 | |
| 533 | PDEBUG(D_V4L2, "Set horizontal flip to %d", val); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 534 | err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 535 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 536 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 537 | |
Erik Andr?n | a68985d | 2009-01-13 15:44:03 -0300 | [diff] [blame] | 538 | err = m5602_read_sensor(sd, S5K4AA_READ_MODE, &data, 1); |
| 539 | if (err < 0) |
| 540 | return err; |
| 541 | |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 542 | if (dmi_check_system(s5k4aa_vflip_dmi_table)) |
Erik Andrén | 2f17e1a | 2009-01-22 03:51:40 -0300 | [diff] [blame] | 543 | val = !val; |
Erik Andrén | 2f17e1a | 2009-01-22 03:51:40 -0300 | [diff] [blame] | 544 | |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 545 | data = ((data & ~S5K4AA_RM_H_FLIP) | ((val & 0x01) << 6)); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 546 | err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 547 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 548 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 549 | |
Grégory Lardière | 9bc738f | 2009-02-12 03:40:29 -0300 | [diff] [blame] | 550 | err = m5602_read_sensor(sd, S5K4AA_COLSTART_LO, &data, 1); |
| 551 | if (err < 0) |
| 552 | return err; |
| 553 | data = (data & 0xfe) | !val; |
| 554 | err = m5602_write_sensor(sd, S5K4AA_COLSTART_LO, &data, 1); |
Erik Andrén | 3250070 | 2008-11-20 04:02:44 -0300 | [diff] [blame] | 555 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 556 | } |
| 557 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 558 | static int s5k4aa_get_gain(struct gspca_dev *gspca_dev, __s32 *val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 559 | { |
| 560 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 561 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 562 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 563 | *val = sensor_settings[GAIN_IDX]; |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 564 | PDEBUG(D_V4L2, "Read gain %d", *val); |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 565 | return 0; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 566 | } |
| 567 | |
Erik Andr?n | cf811d5 | 2009-04-03 02:49:10 -0300 | [diff] [blame] | 568 | static int s5k4aa_set_gain(struct gspca_dev *gspca_dev, __s32 val) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 569 | { |
| 570 | struct sd *sd = (struct sd *) gspca_dev; |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 571 | s32 *sensor_settings = sd->sensor_priv; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 572 | u8 data = S5K4AA_PAGE_MAP_2; |
| 573 | int err; |
| 574 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 575 | sensor_settings[GAIN_IDX] = val; |
| 576 | |
Erik Andren | 17ea88a | 2008-10-16 16:46:07 -0300 | [diff] [blame] | 577 | PDEBUG(D_V4L2, "Set gain to %d", val); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 578 | err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 579 | if (err < 0) |
Erik Andr?n | 051781b | 2008-12-27 12:28:00 -0300 | [diff] [blame] | 580 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 581 | |
| 582 | data = val & 0xff; |
Erik Andr?n | 7ee4629 | 2009-01-14 03:37:03 -0300 | [diff] [blame] | 583 | err = m5602_write_sensor(sd, S5K4AA_GAIN, &data, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 584 | |
Erik Andrén | 3250070 | 2008-11-20 04:02:44 -0300 | [diff] [blame] | 585 | return err; |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 586 | } |
| 587 | |
Erik Andr?n | 7ee4629 | 2009-01-14 03:37:03 -0300 | [diff] [blame] | 588 | static int s5k4aa_get_brightness(struct gspca_dev *gspca_dev, __s32 *val) |
| 589 | { |
| 590 | struct sd *sd = (struct sd *) gspca_dev; |
| 591 | s32 *sensor_settings = sd->sensor_priv; |
| 592 | |
| 593 | *val = sensor_settings[BRIGHTNESS_IDX]; |
| 594 | PDEBUG(D_V4L2, "Read brightness %d", *val); |
| 595 | return 0; |
| 596 | } |
| 597 | |
| 598 | static int s5k4aa_set_brightness(struct gspca_dev *gspca_dev, __s32 val) |
| 599 | { |
| 600 | struct sd *sd = (struct sd *) gspca_dev; |
| 601 | s32 *sensor_settings = sd->sensor_priv; |
| 602 | u8 data = S5K4AA_PAGE_MAP_2; |
| 603 | int err; |
| 604 | |
| 605 | sensor_settings[BRIGHTNESS_IDX] = val; |
| 606 | |
| 607 | PDEBUG(D_V4L2, "Set brightness to %d", val); |
| 608 | err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1); |
| 609 | if (err < 0) |
| 610 | return err; |
| 611 | |
| 612 | data = val & 0xff; |
| 613 | return m5602_write_sensor(sd, S5K4AA_BRIGHTNESS, &data, 1); |
| 614 | } |
| 615 | |
Erik Andr?n | 3290d40 | 2009-01-13 16:40:28 -0300 | [diff] [blame] | 616 | static int s5k4aa_get_noise(struct gspca_dev *gspca_dev, __s32 *val) |
| 617 | { |
| 618 | struct sd *sd = (struct sd *) gspca_dev; |
| 619 | s32 *sensor_settings = sd->sensor_priv; |
| 620 | |
| 621 | *val = sensor_settings[NOISE_SUPP_IDX]; |
| 622 | PDEBUG(D_V4L2, "Read noise %d", *val); |
| 623 | return 0; |
| 624 | } |
| 625 | |
| 626 | static int s5k4aa_set_noise(struct gspca_dev *gspca_dev, __s32 val) |
| 627 | { |
| 628 | struct sd *sd = (struct sd *) gspca_dev; |
| 629 | s32 *sensor_settings = sd->sensor_priv; |
| 630 | u8 data = S5K4AA_PAGE_MAP_2; |
| 631 | int err; |
| 632 | |
| 633 | sensor_settings[NOISE_SUPP_IDX] = val; |
| 634 | |
| 635 | PDEBUG(D_V4L2, "Set noise to %d", val); |
| 636 | err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1); |
| 637 | if (err < 0) |
| 638 | return err; |
| 639 | |
| 640 | data = val & 0x01; |
| 641 | return m5602_write_sensor(sd, S5K4AA_NOISE_SUPP, &data, 1); |
| 642 | } |
| 643 | |
Erik Andr?n | a594fb4 | 2009-01-06 11:37:03 -0300 | [diff] [blame] | 644 | void s5k4aa_disconnect(struct sd *sd) |
| 645 | { |
| 646 | sd->sensor = NULL; |
| 647 | kfree(sd->sensor_priv); |
| 648 | } |
| 649 | |
Erik Andrén | 658efb6 | 2008-11-24 14:21:29 -0300 | [diff] [blame] | 650 | static void s5k4aa_dump_registers(struct sd *sd) |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 651 | { |
| 652 | int address; |
| 653 | u8 page, old_page; |
Erik Andrén | 4feb24f | 2008-11-27 13:51:11 -0300 | [diff] [blame] | 654 | m5602_read_sensor(sd, S5K4AA_PAGE_MAP, &old_page, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 655 | for (page = 0; page < 16; page++) { |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 656 | m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &page, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 657 | info("Dumping the s5k4aa register state for page 0x%x", page); |
| 658 | for (address = 0; address <= 0xff; address++) { |
| 659 | u8 value = 0; |
Erik Andrén | 4feb24f | 2008-11-27 13:51:11 -0300 | [diff] [blame] | 660 | m5602_read_sensor(sd, address, &value, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 661 | info("register 0x%x contains 0x%x", |
| 662 | address, value); |
| 663 | } |
| 664 | } |
| 665 | info("s5k4aa register state dump complete"); |
| 666 | |
| 667 | for (page = 0; page < 16; page++) { |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 668 | m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &page, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 669 | info("Probing for which registers that are " |
| 670 | "read/write for page 0x%x", page); |
| 671 | for (address = 0; address <= 0xff; address++) { |
| 672 | u8 old_value, ctrl_value, test_value = 0xff; |
| 673 | |
Erik Andrén | 4feb24f | 2008-11-27 13:51:11 -0300 | [diff] [blame] | 674 | m5602_read_sensor(sd, address, &old_value, 1); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 675 | m5602_write_sensor(sd, address, &test_value, 1); |
Erik Andrén | 4feb24f | 2008-11-27 13:51:11 -0300 | [diff] [blame] | 676 | m5602_read_sensor(sd, address, &ctrl_value, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 677 | |
| 678 | if (ctrl_value == test_value) |
| 679 | info("register 0x%x is writeable", address); |
| 680 | else |
| 681 | info("register 0x%x is read only", address); |
| 682 | |
| 683 | /* Restore original value */ |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 684 | m5602_write_sensor(sd, address, &old_value, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 685 | } |
| 686 | } |
| 687 | info("Read/write register probing complete"); |
Erik Andrén | 6dc4cff | 2008-11-26 04:08:10 -0300 | [diff] [blame] | 688 | m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &old_page, 1); |
Erik Andren | c109f81 | 2008-10-01 04:51:53 -0300 | [diff] [blame] | 689 | } |