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