2 * Driver for the mt9m111 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 #include "m5602_mt9m111.h"
23 static int mt9m111_s_ctrl(struct v4l2_ctrl
*ctrl
);
24 static void mt9m111_dump_registers(struct sd
*sd
);
26 static const unsigned char preinit_mt9m111
[][4] = {
27 {BRIDGE
, M5602_XB_MCU_CLK_DIV
, 0x02, 0x00},
28 {BRIDGE
, M5602_XB_MCU_CLK_CTRL
, 0xb0, 0x00},
29 {BRIDGE
, M5602_XB_SEN_CLK_DIV
, 0x00, 0x00},
30 {BRIDGE
, M5602_XB_SEN_CLK_CTRL
, 0xb0, 0x00},
31 {BRIDGE
, M5602_XB_SENSOR_TYPE
, 0x0d, 0x00},
32 {BRIDGE
, M5602_XB_SENSOR_CTRL
, 0x00, 0x00},
33 {BRIDGE
, M5602_XB_ADC_CTRL
, 0xc0, 0x00},
34 {BRIDGE
, M5602_XB_SENSOR_TYPE
, 0x09, 0x00},
36 {SENSOR
, MT9M111_PAGE_MAP
, 0x00, 0x00},
37 {SENSOR
, MT9M111_SC_RESET
,
40 MT9M111_ANALOG_STANDBY
|
42 MT9M111_SHOW_BAD_FRAMES
|
43 MT9M111_RESTART_BAD_FRAMES
|
44 MT9M111_SYNCHRONIZE_CHANGES
},
46 {BRIDGE
, M5602_XB_GPIO_DIR
, 0x05, 0x00},
47 {BRIDGE
, M5602_XB_GPIO_DAT
, 0x04, 0x00},
48 {BRIDGE
, M5602_XB_GPIO_EN_H
, 0x3e, 0x00},
49 {BRIDGE
, M5602_XB_GPIO_DIR_H
, 0x3e, 0x00},
50 {BRIDGE
, M5602_XB_GPIO_DAT_H
, 0x02, 0x00},
51 {BRIDGE
, M5602_XB_GPIO_EN_L
, 0xff, 0x00},
52 {BRIDGE
, M5602_XB_GPIO_DIR_L
, 0xff, 0x00},
53 {BRIDGE
, M5602_XB_GPIO_DAT_L
, 0x00, 0x00},
55 {BRIDGE
, M5602_XB_SEN_CLK_DIV
, 0x00, 0x00},
56 {BRIDGE
, M5602_XB_SEN_CLK_CTRL
, 0xb0, 0x00},
57 {BRIDGE
, M5602_XB_GPIO_DIR
, 0x07, 0x00},
58 {BRIDGE
, M5602_XB_GPIO_DAT
, 0x0b, 0x00},
59 {BRIDGE
, M5602_XB_GPIO_EN_H
, 0x06, 0x00},
60 {BRIDGE
, M5602_XB_GPIO_EN_L
, 0x00, 0x00},
62 {BRIDGE
, M5602_XB_I2C_CLK_DIV
, 0x0a, 0x00}
65 static const unsigned char init_mt9m111
[][4] = {
66 {BRIDGE
, M5602_XB_MCU_CLK_DIV
, 0x02, 0x00},
67 {BRIDGE
, M5602_XB_MCU_CLK_CTRL
, 0xb0, 0x00},
68 {BRIDGE
, M5602_XB_SEN_CLK_DIV
, 0x00, 0x00},
69 {BRIDGE
, M5602_XB_SEN_CLK_CTRL
, 0xb0, 0x00},
70 {BRIDGE
, M5602_XB_ADC_CTRL
, 0xc0, 0x00},
71 {BRIDGE
, M5602_XB_SENSOR_TYPE
, 0x09, 0x00},
73 {BRIDGE
, M5602_XB_GPIO_EN_H
, 0x06, 0x00},
74 {BRIDGE
, M5602_XB_GPIO_EN_L
, 0x00, 0x00},
75 {BRIDGE
, M5602_XB_GPIO_DAT
, 0x04, 0x00},
76 {BRIDGE
, M5602_XB_GPIO_DIR_H
, 0x3e, 0x00},
77 {BRIDGE
, M5602_XB_GPIO_DIR_L
, 0xff, 0x00},
78 {BRIDGE
, M5602_XB_GPIO_DAT_H
, 0x02, 0x00},
79 {BRIDGE
, M5602_XB_GPIO_DAT_L
, 0x00, 0x00},
80 {BRIDGE
, M5602_XB_GPIO_DIR
, 0x07, 0x00},
81 {BRIDGE
, M5602_XB_GPIO_DAT
, 0x0b, 0x00},
82 {BRIDGE
, M5602_XB_I2C_CLK_DIV
, 0x0a, 0x00},
84 {SENSOR
, MT9M111_SC_RESET
, 0x00, 0x29},
85 {SENSOR
, MT9M111_PAGE_MAP
, 0x00, 0x00},
86 {SENSOR
, MT9M111_SC_RESET
, 0x00, 0x08},
87 {SENSOR
, MT9M111_PAGE_MAP
, 0x00, 0x01},
88 {SENSOR
, MT9M111_CP_OPERATING_MODE_CTL
, 0x00,
89 MT9M111_CP_OPERATING_MODE_CTL
},
90 {SENSOR
, MT9M111_CP_LENS_CORRECTION_1
, 0x04, 0x2a},
91 {SENSOR
, MT9M111_CP_DEFECT_CORR_CONTEXT_A
, 0x00,
92 MT9M111_2D_DEFECT_CORRECTION_ENABLE
},
93 {SENSOR
, MT9M111_CP_DEFECT_CORR_CONTEXT_B
, 0x00,
94 MT9M111_2D_DEFECT_CORRECTION_ENABLE
},
95 {SENSOR
, MT9M111_CP_LUMA_OFFSET
, 0x00, 0x00},
96 {SENSOR
, MT9M111_CP_LUMA_CLIP
, 0xff, 0x00},
97 {SENSOR
, MT9M111_CP_OUTPUT_FORMAT_CTL2_CONTEXT_A
, 0x14, 0x00},
98 {SENSOR
, MT9M111_CP_OUTPUT_FORMAT_CTL2_CONTEXT_B
, 0x14, 0x00},
99 {SENSOR
, 0xcd, 0x00, 0x0e},
100 {SENSOR
, 0xd0, 0x00, 0x40},
102 {SENSOR
, MT9M111_PAGE_MAP
, 0x00, 0x02},
103 {SENSOR
, MT9M111_CC_AUTO_EXPOSURE_PARAMETER_18
, 0x00, 0x00},
104 {SENSOR
, MT9M111_CC_AWB_PARAMETER_7
, 0xef, 0x03},
106 {SENSOR
, MT9M111_PAGE_MAP
, 0x00, 0x00},
107 {SENSOR
, 0x33, 0x03, 0x49},
108 {SENSOR
, 0x34, 0xc0, 0x19},
109 {SENSOR
, 0x3f, 0x20, 0x20},
110 {SENSOR
, 0x40, 0x20, 0x20},
111 {SENSOR
, 0x5a, 0xc0, 0x0a},
112 {SENSOR
, 0x70, 0x7b, 0x0a},
113 {SENSOR
, 0x71, 0xff, 0x00},
114 {SENSOR
, 0x72, 0x19, 0x0e},
115 {SENSOR
, 0x73, 0x18, 0x0f},
116 {SENSOR
, 0x74, 0x57, 0x32},
117 {SENSOR
, 0x75, 0x56, 0x34},
118 {SENSOR
, 0x76, 0x73, 0x35},
119 {SENSOR
, 0x77, 0x30, 0x12},
120 {SENSOR
, 0x78, 0x79, 0x02},
121 {SENSOR
, 0x79, 0x75, 0x06},
122 {SENSOR
, 0x7a, 0x77, 0x0a},
123 {SENSOR
, 0x7b, 0x78, 0x09},
124 {SENSOR
, 0x7c, 0x7d, 0x06},
125 {SENSOR
, 0x7d, 0x31, 0x10},
126 {SENSOR
, 0x7e, 0x00, 0x7e},
127 {SENSOR
, 0x80, 0x59, 0x04},
128 {SENSOR
, 0x81, 0x59, 0x04},
129 {SENSOR
, 0x82, 0x57, 0x0a},
130 {SENSOR
, 0x83, 0x58, 0x0b},
131 {SENSOR
, 0x84, 0x47, 0x0c},
132 {SENSOR
, 0x85, 0x48, 0x0e},
133 {SENSOR
, 0x86, 0x5b, 0x02},
134 {SENSOR
, 0x87, 0x00, 0x5c},
135 {SENSOR
, MT9M111_CONTEXT_CONTROL
, 0x00, MT9M111_SEL_CONTEXT_B
},
136 {SENSOR
, 0x60, 0x00, 0x80},
137 {SENSOR
, 0x61, 0x00, 0x00},
138 {SENSOR
, 0x62, 0x00, 0x00},
139 {SENSOR
, 0x63, 0x00, 0x00},
140 {SENSOR
, 0x64, 0x00, 0x00},
142 {SENSOR
, MT9M111_SC_ROWSTART
, 0x00, 0x0d}, /* 13 */
143 {SENSOR
, MT9M111_SC_COLSTART
, 0x00, 0x12}, /* 18 */
144 {SENSOR
, MT9M111_SC_WINDOW_HEIGHT
, 0x04, 0x00}, /* 1024 */
145 {SENSOR
, MT9M111_SC_WINDOW_WIDTH
, 0x05, 0x10}, /* 1296 */
146 {SENSOR
, MT9M111_SC_HBLANK_CONTEXT_B
, 0x01, 0x60}, /* 352 */
147 {SENSOR
, MT9M111_SC_VBLANK_CONTEXT_B
, 0x00, 0x11}, /* 17 */
148 {SENSOR
, MT9M111_SC_HBLANK_CONTEXT_A
, 0x01, 0x60}, /* 352 */
149 {SENSOR
, MT9M111_SC_VBLANK_CONTEXT_A
, 0x00, 0x11}, /* 17 */
150 {SENSOR
, MT9M111_SC_R_MODE_CONTEXT_A
, 0x01, 0x0f}, /* 271 */
151 {SENSOR
, 0x30, 0x04, 0x00},
152 /* Set number of blank rows chosen to 400 */
153 {SENSOR
, MT9M111_SC_SHUTTER_WIDTH
, 0x01, 0x90},
156 static const unsigned char start_mt9m111
[][4] = {
157 {BRIDGE
, M5602_XB_SEN_CLK_DIV
, 0x06, 0x00},
158 {BRIDGE
, M5602_XB_SEN_CLK_CTRL
, 0xb0, 0x00},
159 {BRIDGE
, M5602_XB_ADC_CTRL
, 0xc0, 0x00},
160 {BRIDGE
, M5602_XB_SENSOR_TYPE
, 0x09, 0x00},
161 {BRIDGE
, M5602_XB_LINE_OF_FRAME_H
, 0x81, 0x00},
162 {BRIDGE
, M5602_XB_PIX_OF_LINE_H
, 0x82, 0x00},
163 {BRIDGE
, M5602_XB_SIG_INI
, 0x01, 0x00},
164 {BRIDGE
, M5602_XB_VSYNC_PARA
, 0x00, 0x00},
165 {BRIDGE
, M5602_XB_VSYNC_PARA
, 0x00, 0x00},
166 {BRIDGE
, M5602_XB_VSYNC_PARA
, 0x00, 0x00},
167 {BRIDGE
, M5602_XB_VSYNC_PARA
, 0x00, 0x00},
170 static struct v4l2_pix_format mt9m111_modes
[] = {
176 .sizeimage
= 640 * 480,
178 .colorspace
= V4L2_COLORSPACE_SRGB
,
183 static const struct v4l2_ctrl_ops mt9m111_ctrl_ops
= {
184 .s_ctrl
= mt9m111_s_ctrl
,
187 static const struct v4l2_ctrl_config mt9m111_greenbal_cfg
= {
188 .ops
= &mt9m111_ctrl_ops
,
189 .id
= M5602_V4L2_CID_GREEN_BALANCE
,
190 .name
= "Green Balance",
191 .type
= V4L2_CTRL_TYPE_INTEGER
,
195 .def
= MT9M111_GREEN_GAIN_DEFAULT
,
196 .flags
= V4L2_CTRL_FLAG_SLIDER
,
199 int mt9m111_probe(struct sd
*sd
)
201 u8 data
[2] = {0x00, 0x00};
203 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*)sd
;
206 if (force_sensor
== MT9M111_SENSOR
) {
207 pr_info("Forcing a %s sensor\n", mt9m111
.name
);
210 /* If we want to force another sensor, don't try to probe this
215 gspca_dbg(gspca_dev
, D_PROBE
, "Probing for a mt9m111 sensor\n");
218 for (i
= 0; i
< ARRAY_SIZE(preinit_mt9m111
); i
++) {
219 if (preinit_mt9m111
[i
][0] == BRIDGE
) {
220 rc
|= m5602_write_bridge(sd
,
221 preinit_mt9m111
[i
][1],
222 preinit_mt9m111
[i
][2]);
224 data
[0] = preinit_mt9m111
[i
][2];
225 data
[1] = preinit_mt9m111
[i
][3];
226 rc
|= m5602_write_sensor(sd
,
227 preinit_mt9m111
[i
][1], data
, 2);
233 if (m5602_read_sensor(sd
, MT9M111_SC_CHIPVER
, data
, 2))
236 if ((data
[0] == 0x14) && (data
[1] == 0x3a)) {
237 pr_info("Detected a mt9m111 sensor\n");
244 sd
->gspca_dev
.cam
.cam_mode
= mt9m111_modes
;
245 sd
->gspca_dev
.cam
.nmodes
= ARRAY_SIZE(mt9m111_modes
);
250 int mt9m111_init(struct sd
*sd
)
254 /* Init the sensor */
255 for (i
= 0; i
< ARRAY_SIZE(init_mt9m111
) && !err
; i
++) {
258 if (init_mt9m111
[i
][0] == BRIDGE
) {
259 err
= m5602_write_bridge(sd
,
263 data
[0] = init_mt9m111
[i
][2];
264 data
[1] = init_mt9m111
[i
][3];
265 err
= m5602_write_sensor(sd
,
266 init_mt9m111
[i
][1], data
, 2);
271 mt9m111_dump_registers(sd
);
276 int mt9m111_init_controls(struct sd
*sd
)
278 struct v4l2_ctrl_handler
*hdl
= &sd
->gspca_dev
.ctrl_handler
;
280 sd
->gspca_dev
.vdev
.ctrl_handler
= hdl
;
281 v4l2_ctrl_handler_init(hdl
, 7);
283 sd
->auto_white_bal
= v4l2_ctrl_new_std(hdl
, &mt9m111_ctrl_ops
,
284 V4L2_CID_AUTO_WHITE_BALANCE
,
286 sd
->green_bal
= v4l2_ctrl_new_custom(hdl
, &mt9m111_greenbal_cfg
, NULL
);
287 sd
->red_bal
= v4l2_ctrl_new_std(hdl
, &mt9m111_ctrl_ops
,
288 V4L2_CID_RED_BALANCE
, 0, 0x7ff, 1,
289 MT9M111_RED_GAIN_DEFAULT
);
290 sd
->blue_bal
= v4l2_ctrl_new_std(hdl
, &mt9m111_ctrl_ops
,
291 V4L2_CID_BLUE_BALANCE
, 0, 0x7ff, 1,
292 MT9M111_BLUE_GAIN_DEFAULT
);
294 v4l2_ctrl_new_std(hdl
, &mt9m111_ctrl_ops
, V4L2_CID_GAIN
, 0,
295 (INITIAL_MAX_GAIN
- 1) * 2 * 2 * 2, 1,
296 MT9M111_DEFAULT_GAIN
);
298 sd
->hflip
= v4l2_ctrl_new_std(hdl
, &mt9m111_ctrl_ops
, V4L2_CID_HFLIP
,
300 sd
->vflip
= v4l2_ctrl_new_std(hdl
, &mt9m111_ctrl_ops
, V4L2_CID_VFLIP
,
304 pr_err("Could not initialize controls\n");
308 v4l2_ctrl_auto_cluster(4, &sd
->auto_white_bal
, 0, false);
309 v4l2_ctrl_cluster(2, &sd
->hflip
);
314 int mt9m111_start(struct sd
*sd
)
318 struct cam
*cam
= &sd
->gspca_dev
.cam
;
319 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*)sd
;
321 int width
= cam
->cam_mode
[sd
->gspca_dev
.curr_mode
].width
- 1;
322 int height
= cam
->cam_mode
[sd
->gspca_dev
.curr_mode
].height
;
324 for (i
= 0; i
< ARRAY_SIZE(start_mt9m111
) && !err
; i
++) {
325 if (start_mt9m111
[i
][0] == BRIDGE
) {
326 err
= m5602_write_bridge(sd
,
328 start_mt9m111
[i
][2]);
330 data
[0] = start_mt9m111
[i
][2];
331 data
[1] = start_mt9m111
[i
][3];
332 err
= m5602_write_sensor(sd
,
333 start_mt9m111
[i
][1], data
, 2);
339 err
= m5602_write_bridge(sd
, M5602_XB_VSYNC_PARA
, (height
>> 8) & 0xff);
343 err
= m5602_write_bridge(sd
, M5602_XB_VSYNC_PARA
, (height
& 0xff));
347 for (i
= 0; i
< 2 && !err
; i
++)
348 err
= m5602_write_bridge(sd
, M5602_XB_VSYNC_PARA
, 0);
352 err
= m5602_write_bridge(sd
, M5602_XB_SIG_INI
, 0);
356 err
= m5602_write_bridge(sd
, M5602_XB_SIG_INI
, 2);
360 for (i
= 0; i
< 2 && !err
; i
++)
361 err
= m5602_write_bridge(sd
, M5602_XB_HSYNC_PARA
, 0);
365 err
= m5602_write_bridge(sd
, M5602_XB_HSYNC_PARA
,
366 (width
>> 8) & 0xff);
370 err
= m5602_write_bridge(sd
, M5602_XB_HSYNC_PARA
, width
& 0xff);
374 err
= m5602_write_bridge(sd
, M5602_XB_SIG_INI
, 0);
380 gspca_dbg(gspca_dev
, D_CONF
, "Configuring camera for VGA mode\n");
384 gspca_dbg(gspca_dev
, D_CONF
, "Configuring camera for QVGA mode\n");
390 void mt9m111_disconnect(struct sd
*sd
)
395 static int mt9m111_set_hvflip(struct gspca_dev
*gspca_dev
)
398 u8 data
[2] = {0x00, 0x00};
399 struct sd
*sd
= (struct sd
*) gspca_dev
;
403 gspca_dbg(gspca_dev
, D_CONF
, "Set hvflip to %d %d\n",
404 sd
->hflip
->val
, sd
->vflip
->val
);
406 /* The mt9m111 is flipped by default */
407 hflip
= !sd
->hflip
->val
;
408 vflip
= !sd
->vflip
->val
;
410 /* Set the correct page map */
411 err
= m5602_write_sensor(sd
, MT9M111_PAGE_MAP
, data
, 2);
415 data
[0] = MT9M111_RMB_OVER_SIZED
;
416 if (gspca_dev
->pixfmt
.width
== 640) {
417 data
[1] = MT9M111_RMB_ROW_SKIP_2X
|
418 MT9M111_RMB_COLUMN_SKIP_2X
|
419 (hflip
<< 1) | vflip
;
421 data
[1] = MT9M111_RMB_ROW_SKIP_4X
|
422 MT9M111_RMB_COLUMN_SKIP_4X
|
423 (hflip
<< 1) | vflip
;
425 err
= m5602_write_sensor(sd
, MT9M111_SC_R_MODE_CONTEXT_B
,
430 static int mt9m111_set_auto_white_balance(struct gspca_dev
*gspca_dev
,
433 struct sd
*sd
= (struct sd
*) gspca_dev
;
437 err
= m5602_read_sensor(sd
, MT9M111_CP_OPERATING_MODE_CTL
, data
, 2);
441 data
[1] = ((data
[1] & 0xfd) | ((val
& 0x01) << 1));
443 err
= m5602_write_sensor(sd
, MT9M111_CP_OPERATING_MODE_CTL
, data
, 2);
445 gspca_dbg(gspca_dev
, D_CONF
, "Set auto white balance %d\n", val
);
449 static int mt9m111_set_gain(struct gspca_dev
*gspca_dev
, __s32 val
)
452 u8 data
[2] = {0x00, 0x00};
453 struct sd
*sd
= (struct sd
*) gspca_dev
;
455 /* Set the correct page map */
456 err
= m5602_write_sensor(sd
, MT9M111_PAGE_MAP
, data
, 2);
460 if (val
>= INITIAL_MAX_GAIN
* 2 * 2 * 2)
463 if ((val
>= INITIAL_MAX_GAIN
* 2 * 2) &&
464 (val
< (INITIAL_MAX_GAIN
- 1) * 2 * 2 * 2))
465 tmp
= (1 << 10) | (val
<< 9) |
466 (val
<< 8) | (val
/ 8);
467 else if ((val
>= INITIAL_MAX_GAIN
* 2) &&
468 (val
< INITIAL_MAX_GAIN
* 2 * 2))
469 tmp
= (1 << 9) | (1 << 8) | (val
/ 4);
470 else if ((val
>= INITIAL_MAX_GAIN
) &&
471 (val
< INITIAL_MAX_GAIN
* 2))
472 tmp
= (1 << 8) | (val
/ 2);
476 data
[1] = (tmp
& 0xff);
477 data
[0] = (tmp
& 0xff00) >> 8;
478 gspca_dbg(gspca_dev
, D_CONF
, "tmp=%d, data[1]=%d, data[0]=%d\n", tmp
,
481 err
= m5602_write_sensor(sd
, MT9M111_SC_GLOBAL_GAIN
,
487 static int mt9m111_set_green_balance(struct gspca_dev
*gspca_dev
, __s32 val
)
491 struct sd
*sd
= (struct sd
*) gspca_dev
;
493 data
[1] = (val
& 0xff);
494 data
[0] = (val
& 0xff00) >> 8;
496 gspca_dbg(gspca_dev
, D_CONF
, "Set green balance %d\n", val
);
497 err
= m5602_write_sensor(sd
, MT9M111_SC_GREEN_1_GAIN
,
502 return m5602_write_sensor(sd
, MT9M111_SC_GREEN_2_GAIN
,
506 static int mt9m111_set_blue_balance(struct gspca_dev
*gspca_dev
, __s32 val
)
509 struct sd
*sd
= (struct sd
*) gspca_dev
;
511 data
[1] = (val
& 0xff);
512 data
[0] = (val
& 0xff00) >> 8;
514 gspca_dbg(gspca_dev
, D_CONF
, "Set blue balance %d\n", val
);
516 return m5602_write_sensor(sd
, MT9M111_SC_BLUE_GAIN
,
520 static int mt9m111_set_red_balance(struct gspca_dev
*gspca_dev
, __s32 val
)
523 struct sd
*sd
= (struct sd
*) gspca_dev
;
525 data
[1] = (val
& 0xff);
526 data
[0] = (val
& 0xff00) >> 8;
528 gspca_dbg(gspca_dev
, D_CONF
, "Set red balance %d\n", val
);
530 return m5602_write_sensor(sd
, MT9M111_SC_RED_GAIN
,
534 static int mt9m111_s_ctrl(struct v4l2_ctrl
*ctrl
)
536 struct gspca_dev
*gspca_dev
=
537 container_of(ctrl
->handler
, struct gspca_dev
, ctrl_handler
);
538 struct sd
*sd
= (struct sd
*) gspca_dev
;
541 if (!gspca_dev
->streaming
)
545 case V4L2_CID_AUTO_WHITE_BALANCE
:
546 err
= mt9m111_set_auto_white_balance(gspca_dev
, ctrl
->val
);
547 if (err
|| ctrl
->val
)
549 err
= mt9m111_set_green_balance(gspca_dev
, sd
->green_bal
->val
);
552 err
= mt9m111_set_red_balance(gspca_dev
, sd
->red_bal
->val
);
555 err
= mt9m111_set_blue_balance(gspca_dev
, sd
->blue_bal
->val
);
558 err
= mt9m111_set_gain(gspca_dev
, ctrl
->val
);
561 err
= mt9m111_set_hvflip(gspca_dev
);
570 static void mt9m111_dump_registers(struct sd
*sd
)
572 u8 address
, value
[2] = {0x00, 0x00};
574 pr_info("Dumping the mt9m111 register state\n");
576 pr_info("Dumping the mt9m111 sensor core registers\n");
577 value
[1] = MT9M111_SENSOR_CORE
;
578 m5602_write_sensor(sd
, MT9M111_PAGE_MAP
, value
, 2);
579 for (address
= 0; address
< 0xff; address
++) {
580 m5602_read_sensor(sd
, address
, value
, 2);
581 pr_info("register 0x%x contains 0x%x%x\n",
582 address
, value
[0], value
[1]);
585 pr_info("Dumping the mt9m111 color pipeline registers\n");
586 value
[1] = MT9M111_COLORPIPE
;
587 m5602_write_sensor(sd
, MT9M111_PAGE_MAP
, value
, 2);
588 for (address
= 0; address
< 0xff; address
++) {
589 m5602_read_sensor(sd
, address
, value
, 2);
590 pr_info("register 0x%x contains 0x%x%x\n",
591 address
, value
[0], value
[1]);
594 pr_info("Dumping the mt9m111 camera control registers\n");
595 value
[1] = MT9M111_CAMERA_CONTROL
;
596 m5602_write_sensor(sd
, MT9M111_PAGE_MAP
, value
, 2);
597 for (address
= 0; address
< 0xff; address
++) {
598 m5602_read_sensor(sd
, address
, value
, 2);
599 pr_info("register 0x%x contains 0x%x%x\n",
600 address
, value
[0], value
[1]);
603 pr_info("mt9m111 register state dump complete\n");