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