2 * Driver for MT9T001 CMOS Image Sensor from Aptina (Micron)
4 * Copyright (C) 2010-2011, Laurent Pinchart <laurent.pinchart@ideasonboard.com>
6 * Based on the MT9M001 driver,
8 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/i2c.h>
16 #include <linux/module.h>
17 #include <linux/log2.h>
18 #include <linux/slab.h>
19 #include <linux/videodev2.h>
20 #include <linux/v4l2-mediabus.h>
22 #include <media/mt9t001.h>
23 #include <media/v4l2-ctrls.h>
24 #include <media/v4l2-device.h>
25 #include <media/v4l2-subdev.h>
27 #define MT9T001_PIXEL_ARRAY_HEIGHT 1568
28 #define MT9T001_PIXEL_ARRAY_WIDTH 2112
30 #define MT9T001_CHIP_VERSION 0x00
31 #define MT9T001_CHIP_ID 0x1621
32 #define MT9T001_ROW_START 0x01
33 #define MT9T001_ROW_START_MIN 0
34 #define MT9T001_ROW_START_DEF 20
35 #define MT9T001_ROW_START_MAX 1534
36 #define MT9T001_COLUMN_START 0x02
37 #define MT9T001_COLUMN_START_MIN 0
38 #define MT9T001_COLUMN_START_DEF 32
39 #define MT9T001_COLUMN_START_MAX 2046
40 #define MT9T001_WINDOW_HEIGHT 0x03
41 #define MT9T001_WINDOW_HEIGHT_MIN 1
42 #define MT9T001_WINDOW_HEIGHT_DEF 1535
43 #define MT9T001_WINDOW_HEIGHT_MAX 1567
44 #define MT9T001_WINDOW_WIDTH 0x04
45 #define MT9T001_WINDOW_WIDTH_MIN 1
46 #define MT9T001_WINDOW_WIDTH_DEF 2047
47 #define MT9T001_WINDOW_WIDTH_MAX 2111
48 #define MT9T001_HORIZONTAL_BLANKING 0x05
49 #define MT9T001_HORIZONTAL_BLANKING_MIN 21
50 #define MT9T001_HORIZONTAL_BLANKING_MAX 1023
51 #define MT9T001_VERTICAL_BLANKING 0x06
52 #define MT9T001_VERTICAL_BLANKING_MIN 3
53 #define MT9T001_VERTICAL_BLANKING_MAX 1023
54 #define MT9T001_OUTPUT_CONTROL 0x07
55 #define MT9T001_OUTPUT_CONTROL_SYNC (1 << 0)
56 #define MT9T001_OUTPUT_CONTROL_CHIP_ENABLE (1 << 1)
57 #define MT9T001_OUTPUT_CONTROL_TEST_DATA (1 << 6)
58 #define MT9T001_SHUTTER_WIDTH_HIGH 0x08
59 #define MT9T001_SHUTTER_WIDTH_LOW 0x09
60 #define MT9T001_SHUTTER_WIDTH_MIN 1
61 #define MT9T001_SHUTTER_WIDTH_DEF 1561
62 #define MT9T001_SHUTTER_WIDTH_MAX (1024 * 1024)
63 #define MT9T001_PIXEL_CLOCK 0x0a
64 #define MT9T001_PIXEL_CLOCK_INVERT (1 << 15)
65 #define MT9T001_PIXEL_CLOCK_SHIFT_MASK (7 << 8)
66 #define MT9T001_PIXEL_CLOCK_SHIFT_SHIFT 8
67 #define MT9T001_PIXEL_CLOCK_DIVIDE_MASK (0x7f << 0)
68 #define MT9T001_FRAME_RESTART 0x0b
69 #define MT9T001_SHUTTER_DELAY 0x0c
70 #define MT9T001_SHUTTER_DELAY_MAX 2047
71 #define MT9T001_RESET 0x0d
72 #define MT9T001_READ_MODE1 0x1e
73 #define MT9T001_READ_MODE_SNAPSHOT (1 << 8)
74 #define MT9T001_READ_MODE_STROBE_ENABLE (1 << 9)
75 #define MT9T001_READ_MODE_STROBE_WIDTH (1 << 10)
76 #define MT9T001_READ_MODE_STROBE_OVERRIDE (1 << 11)
77 #define MT9T001_READ_MODE2 0x20
78 #define MT9T001_READ_MODE_BAD_FRAMES (1 << 0)
79 #define MT9T001_READ_MODE_LINE_VALID_CONTINUOUS (1 << 9)
80 #define MT9T001_READ_MODE_LINE_VALID_FRAME (1 << 10)
81 #define MT9T001_READ_MODE3 0x21
82 #define MT9T001_READ_MODE_GLOBAL_RESET (1 << 0)
83 #define MT9T001_READ_MODE_GHST_CTL (1 << 1)
84 #define MT9T001_ROW_ADDRESS_MODE 0x22
85 #define MT9T001_ROW_SKIP_MASK (7 << 0)
86 #define MT9T001_ROW_BIN_MASK (3 << 3)
87 #define MT9T001_ROW_BIN_SHIFT 3
88 #define MT9T001_COLUMN_ADDRESS_MODE 0x23
89 #define MT9T001_COLUMN_SKIP_MASK (7 << 0)
90 #define MT9T001_COLUMN_BIN_MASK (3 << 3)
91 #define MT9T001_COLUMN_BIN_SHIFT 3
92 #define MT9T001_GREEN1_GAIN 0x2b
93 #define MT9T001_BLUE_GAIN 0x2c
94 #define MT9T001_RED_GAIN 0x2d
95 #define MT9T001_GREEN2_GAIN 0x2e
96 #define MT9T001_TEST_DATA 0x32
97 #define MT9T001_GLOBAL_GAIN 0x35
98 #define MT9T001_GLOBAL_GAIN_MIN 8
99 #define MT9T001_GLOBAL_GAIN_MAX 1024
100 #define MT9T001_BLACK_LEVEL 0x49
101 #define MT9T001_ROW_BLACK_DEFAULT_OFFSET 0x4b
102 #define MT9T001_BLC_DELTA_THRESHOLDS 0x5d
103 #define MT9T001_CAL_THRESHOLDS 0x5f
104 #define MT9T001_GREEN1_OFFSET 0x60
105 #define MT9T001_GREEN2_OFFSET 0x61
106 #define MT9T001_BLACK_LEVEL_CALIBRATION 0x62
107 #define MT9T001_BLACK_LEVEL_OVERRIDE (1 << 0)
108 #define MT9T001_BLACK_LEVEL_DISABLE_OFFSET (1 << 1)
109 #define MT9T001_BLACK_LEVEL_RECALCULATE (1 << 12)
110 #define MT9T001_BLACK_LEVEL_LOCK_RED_BLUE (1 << 13)
111 #define MT9T001_BLACK_LEVEL_LOCK_GREEN (1 << 14)
112 #define MT9T001_RED_OFFSET 0x63
113 #define MT9T001_BLUE_OFFSET 0x64
116 struct v4l2_subdev subdev
;
117 struct media_pad pad
;
119 struct v4l2_mbus_framefmt format
;
120 struct v4l2_rect crop
;
122 struct v4l2_ctrl_handler ctrls
;
123 struct v4l2_ctrl
*gains
[4];
129 static inline struct mt9t001
*to_mt9t001(struct v4l2_subdev
*sd
)
131 return container_of(sd
, struct mt9t001
, subdev
);
134 static int mt9t001_read(struct i2c_client
*client
, u8 reg
)
136 s32 data
= i2c_smbus_read_word_data(client
, reg
);
137 return data
< 0 ? data
: be16_to_cpu(data
);
140 static int mt9t001_write(struct i2c_client
*client
, u8 reg
, u16 data
)
142 return i2c_smbus_write_word_data(client
, reg
, cpu_to_be16(data
));
145 static int mt9t001_set_output_control(struct mt9t001
*mt9t001
, u16 clear
,
148 struct i2c_client
*client
= v4l2_get_subdevdata(&mt9t001
->subdev
);
149 u16 value
= (mt9t001
->output_control
& ~clear
) | set
;
152 if (value
== mt9t001
->output_control
)
155 ret
= mt9t001_write(client
, MT9T001_OUTPUT_CONTROL
, value
);
159 mt9t001
->output_control
= value
;
163 /* -----------------------------------------------------------------------------
164 * V4L2 subdev video operations
167 static struct v4l2_mbus_framefmt
*
168 __mt9t001_get_pad_format(struct mt9t001
*mt9t001
, struct v4l2_subdev_fh
*fh
,
169 unsigned int pad
, enum v4l2_subdev_format_whence which
)
172 case V4L2_SUBDEV_FORMAT_TRY
:
173 return v4l2_subdev_get_try_format(fh
, pad
);
174 case V4L2_SUBDEV_FORMAT_ACTIVE
:
175 return &mt9t001
->format
;
181 static struct v4l2_rect
*
182 __mt9t001_get_pad_crop(struct mt9t001
*mt9t001
, struct v4l2_subdev_fh
*fh
,
183 unsigned int pad
, enum v4l2_subdev_format_whence which
)
186 case V4L2_SUBDEV_FORMAT_TRY
:
187 return v4l2_subdev_get_try_crop(fh
, pad
);
188 case V4L2_SUBDEV_FORMAT_ACTIVE
:
189 return &mt9t001
->crop
;
195 static int mt9t001_s_stream(struct v4l2_subdev
*subdev
, int enable
)
197 const u16 mode
= MT9T001_OUTPUT_CONTROL_CHIP_ENABLE
;
198 struct i2c_client
*client
= v4l2_get_subdevdata(subdev
);
199 struct mt9t001
*mt9t001
= to_mt9t001(subdev
);
200 struct v4l2_mbus_framefmt
*format
= &mt9t001
->format
;
201 struct v4l2_rect
*crop
= &mt9t001
->crop
;
207 return mt9t001_set_output_control(mt9t001
, mode
, 0);
209 /* Configure the window size and row/column bin */
210 hratio
= DIV_ROUND_CLOSEST(crop
->width
, format
->width
);
211 vratio
= DIV_ROUND_CLOSEST(crop
->height
, format
->height
);
213 ret
= mt9t001_write(client
, MT9T001_ROW_ADDRESS_MODE
, hratio
- 1);
217 ret
= mt9t001_write(client
, MT9T001_COLUMN_ADDRESS_MODE
, vratio
- 1);
221 ret
= mt9t001_write(client
, MT9T001_COLUMN_START
, crop
->left
);
225 ret
= mt9t001_write(client
, MT9T001_ROW_START
, crop
->top
);
229 ret
= mt9t001_write(client
, MT9T001_WINDOW_WIDTH
, crop
->width
- 1);
233 ret
= mt9t001_write(client
, MT9T001_WINDOW_HEIGHT
, crop
->height
- 1);
237 /* Switch to master "normal" mode */
238 return mt9t001_set_output_control(mt9t001
, 0, mode
);
241 static int mt9t001_enum_mbus_code(struct v4l2_subdev
*subdev
,
242 struct v4l2_subdev_fh
*fh
,
243 struct v4l2_subdev_mbus_code_enum
*code
)
248 code
->code
= V4L2_MBUS_FMT_SGRBG10_1X10
;
252 static int mt9t001_enum_frame_size(struct v4l2_subdev
*subdev
,
253 struct v4l2_subdev_fh
*fh
,
254 struct v4l2_subdev_frame_size_enum
*fse
)
256 if (fse
->index
>= 8 || fse
->code
!= V4L2_MBUS_FMT_SGRBG10_1X10
)
259 fse
->min_width
= (MT9T001_WINDOW_WIDTH_DEF
+ 1) / fse
->index
;
260 fse
->max_width
= fse
->min_width
;
261 fse
->min_height
= (MT9T001_WINDOW_HEIGHT_DEF
+ 1) / fse
->index
;
262 fse
->max_height
= fse
->min_height
;
267 static int mt9t001_get_format(struct v4l2_subdev
*subdev
,
268 struct v4l2_subdev_fh
*fh
,
269 struct v4l2_subdev_format
*format
)
271 struct mt9t001
*mt9t001
= to_mt9t001(subdev
);
273 format
->format
= *__mt9t001_get_pad_format(mt9t001
, fh
, format
->pad
,
278 static int mt9t001_set_format(struct v4l2_subdev
*subdev
,
279 struct v4l2_subdev_fh
*fh
,
280 struct v4l2_subdev_format
*format
)
282 struct mt9t001
*mt9t001
= to_mt9t001(subdev
);
283 struct v4l2_mbus_framefmt
*__format
;
284 struct v4l2_rect
*__crop
;
290 __crop
= __mt9t001_get_pad_crop(mt9t001
, fh
, format
->pad
,
293 /* Clamp the width and height to avoid dividing by zero. */
294 width
= clamp_t(unsigned int, ALIGN(format
->format
.width
, 2),
295 max(__crop
->width
/ 8, MT9T001_WINDOW_HEIGHT_MIN
+ 1),
297 height
= clamp_t(unsigned int, ALIGN(format
->format
.height
, 2),
298 max(__crop
->height
/ 8, MT9T001_WINDOW_HEIGHT_MIN
+ 1),
301 hratio
= DIV_ROUND_CLOSEST(__crop
->width
, width
);
302 vratio
= DIV_ROUND_CLOSEST(__crop
->height
, height
);
304 __format
= __mt9t001_get_pad_format(mt9t001
, fh
, format
->pad
,
306 __format
->width
= __crop
->width
/ hratio
;
307 __format
->height
= __crop
->height
/ vratio
;
309 format
->format
= *__format
;
314 static int mt9t001_get_crop(struct v4l2_subdev
*subdev
,
315 struct v4l2_subdev_fh
*fh
,
316 struct v4l2_subdev_crop
*crop
)
318 struct mt9t001
*mt9t001
= to_mt9t001(subdev
);
320 crop
->rect
= *__mt9t001_get_pad_crop(mt9t001
, fh
, crop
->pad
,
325 static int mt9t001_set_crop(struct v4l2_subdev
*subdev
,
326 struct v4l2_subdev_fh
*fh
,
327 struct v4l2_subdev_crop
*crop
)
329 struct mt9t001
*mt9t001
= to_mt9t001(subdev
);
330 struct v4l2_mbus_framefmt
*__format
;
331 struct v4l2_rect
*__crop
;
332 struct v4l2_rect rect
;
334 /* Clamp the crop rectangle boundaries and align them to a multiple of 2
337 rect
.left
= clamp(ALIGN(crop
->rect
.left
, 2),
338 MT9T001_COLUMN_START_MIN
,
339 MT9T001_COLUMN_START_MAX
);
340 rect
.top
= clamp(ALIGN(crop
->rect
.top
, 2),
341 MT9T001_ROW_START_MIN
,
342 MT9T001_ROW_START_MAX
);
343 rect
.width
= clamp(ALIGN(crop
->rect
.width
, 2),
344 MT9T001_WINDOW_WIDTH_MIN
+ 1,
345 MT9T001_WINDOW_WIDTH_MAX
+ 1);
346 rect
.height
= clamp(ALIGN(crop
->rect
.height
, 2),
347 MT9T001_WINDOW_HEIGHT_MIN
+ 1,
348 MT9T001_WINDOW_HEIGHT_MAX
+ 1);
350 rect
.width
= min(rect
.width
, MT9T001_PIXEL_ARRAY_WIDTH
- rect
.left
);
351 rect
.height
= min(rect
.height
, MT9T001_PIXEL_ARRAY_HEIGHT
- rect
.top
);
353 __crop
= __mt9t001_get_pad_crop(mt9t001
, fh
, crop
->pad
, crop
->which
);
355 if (rect
.width
!= __crop
->width
|| rect
.height
!= __crop
->height
) {
356 /* Reset the output image size if the crop rectangle size has
359 __format
= __mt9t001_get_pad_format(mt9t001
, fh
, crop
->pad
,
361 __format
->width
= rect
.width
;
362 __format
->height
= rect
.height
;
371 /* -----------------------------------------------------------------------------
372 * V4L2 subdev control operations
375 #define V4L2_CID_TEST_PATTERN (V4L2_CID_USER_BASE | 0x1001)
376 #define V4L2_CID_BLACK_LEVEL_AUTO (V4L2_CID_USER_BASE | 0x1002)
377 #define V4L2_CID_BLACK_LEVEL_OFFSET (V4L2_CID_USER_BASE | 0x1003)
378 #define V4L2_CID_BLACK_LEVEL_CALIBRATE (V4L2_CID_USER_BASE | 0x1004)
380 #define V4L2_CID_GAIN_RED (V4L2_CTRL_CLASS_CAMERA | 0x1001)
381 #define V4L2_CID_GAIN_GREEN_RED (V4L2_CTRL_CLASS_CAMERA | 0x1002)
382 #define V4L2_CID_GAIN_GREEN_BLUE (V4L2_CTRL_CLASS_CAMERA | 0x1003)
383 #define V4L2_CID_GAIN_BLUE (V4L2_CTRL_CLASS_CAMERA | 0x1004)
385 static u16
mt9t001_gain_value(s32
*gain
)
387 /* Gain is controlled by 2 analog stages and a digital stage. Valid
388 * values for the 3 stages are
391 * ------------------------------------------
392 * First analog stage x1 x2 1
393 * Second analog stage x1 x4 0.125
394 * Digital stage x1 x16 0.125
396 * To minimize noise, the gain stages should be used in the second
397 * analog stage, first analog stage, digital stage order. Gain from a
398 * previous stage should be pushed to its maximum value before the next
406 return (1 << 6) | (*gain
>> 1);
410 return ((*gain
- 64) << 5) | (1 << 6) | 32;
413 static int mt9t001_ctrl_freeze(struct mt9t001
*mt9t001
, bool freeze
)
415 return mt9t001_set_output_control(mt9t001
,
416 freeze
? 0 : MT9T001_OUTPUT_CONTROL_SYNC
,
417 freeze
? MT9T001_OUTPUT_CONTROL_SYNC
: 0);
420 static int mt9t001_s_ctrl(struct v4l2_ctrl
*ctrl
)
422 static const u8 gains
[4] = {
423 MT9T001_RED_GAIN
, MT9T001_GREEN1_GAIN
,
424 MT9T001_GREEN2_GAIN
, MT9T001_BLUE_GAIN
427 struct mt9t001
*mt9t001
=
428 container_of(ctrl
->handler
, struct mt9t001
, ctrls
);
429 struct i2c_client
*client
= v4l2_get_subdevdata(&mt9t001
->subdev
);
436 case V4L2_CID_GAIN_RED
:
437 case V4L2_CID_GAIN_GREEN_RED
:
438 case V4L2_CID_GAIN_GREEN_BLUE
:
439 case V4L2_CID_GAIN_BLUE
:
441 /* Disable control updates if more than one control has changed
444 for (i
= 0, count
= 0; i
< 4; ++i
) {
445 struct v4l2_ctrl
*gain
= mt9t001
->gains
[i
];
447 if (gain
->val
!= gain
->cur
.val
)
452 ret
= mt9t001_ctrl_freeze(mt9t001
, true);
457 /* Update the gain controls. */
458 for (i
= 0; i
< 4; ++i
) {
459 struct v4l2_ctrl
*gain
= mt9t001
->gains
[i
];
461 if (gain
->val
== gain
->cur
.val
)
464 value
= mt9t001_gain_value(&gain
->val
);
465 ret
= mt9t001_write(client
, gains
[i
], value
);
467 mt9t001_ctrl_freeze(mt9t001
, false);
472 /* Enable control updates. */
474 ret
= mt9t001_ctrl_freeze(mt9t001
, false);
481 case V4L2_CID_EXPOSURE
:
482 ret
= mt9t001_write(client
, MT9T001_SHUTTER_WIDTH_LOW
,
487 return mt9t001_write(client
, MT9T001_SHUTTER_WIDTH_HIGH
,
490 case V4L2_CID_TEST_PATTERN
:
491 ret
= mt9t001_set_output_control(mt9t001
,
492 ctrl
->val
? 0 : MT9T001_OUTPUT_CONTROL_TEST_DATA
,
493 ctrl
->val
? MT9T001_OUTPUT_CONTROL_TEST_DATA
: 0);
497 return mt9t001_write(client
, MT9T001_TEST_DATA
, ctrl
->val
<< 2);
499 case V4L2_CID_BLACK_LEVEL_AUTO
:
500 value
= ctrl
->val
? 0 : MT9T001_BLACK_LEVEL_OVERRIDE
;
501 ret
= mt9t001_write(client
, MT9T001_BLACK_LEVEL_CALIBRATION
,
506 mt9t001
->black_level
= value
;
509 case V4L2_CID_BLACK_LEVEL_OFFSET
:
510 ret
= mt9t001_write(client
, MT9T001_GREEN1_OFFSET
, ctrl
->val
);
514 ret
= mt9t001_write(client
, MT9T001_GREEN2_OFFSET
, ctrl
->val
);
518 ret
= mt9t001_write(client
, MT9T001_RED_OFFSET
, ctrl
->val
);
522 return mt9t001_write(client
, MT9T001_BLUE_OFFSET
, ctrl
->val
);
524 case V4L2_CID_BLACK_LEVEL_CALIBRATE
:
525 return mt9t001_write(client
, MT9T001_BLACK_LEVEL_CALIBRATION
,
526 MT9T001_BLACK_LEVEL_RECALCULATE
|
527 mt9t001
->black_level
);
533 static struct v4l2_ctrl_ops mt9t001_ctrl_ops
= {
534 .s_ctrl
= mt9t001_s_ctrl
,
537 static const struct v4l2_ctrl_config mt9t001_ctrls
[] = {
539 .ops
= &mt9t001_ctrl_ops
,
540 .id
= V4L2_CID_TEST_PATTERN
,
541 .type
= V4L2_CTRL_TYPE_INTEGER
,
542 .name
= "Test pattern",
549 .ops
= &mt9t001_ctrl_ops
,
550 .id
= V4L2_CID_BLACK_LEVEL_AUTO
,
551 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
552 .name
= "Black Level, Auto",
559 .ops
= &mt9t001_ctrl_ops
,
560 .id
= V4L2_CID_BLACK_LEVEL_OFFSET
,
561 .type
= V4L2_CTRL_TYPE_INTEGER
,
562 .name
= "Black Level, Offset",
569 .ops
= &mt9t001_ctrl_ops
,
570 .id
= V4L2_CID_BLACK_LEVEL_CALIBRATE
,
571 .type
= V4L2_CTRL_TYPE_BUTTON
,
572 .name
= "Black Level, Calibrate",
577 .flags
= V4L2_CTRL_FLAG_WRITE_ONLY
,
581 static const struct v4l2_ctrl_config mt9t001_gains
[] = {
583 .ops
= &mt9t001_ctrl_ops
,
584 .id
= V4L2_CID_GAIN_RED
,
585 .type
= V4L2_CTRL_TYPE_INTEGER
,
587 .min
= MT9T001_GLOBAL_GAIN_MIN
,
588 .max
= MT9T001_GLOBAL_GAIN_MAX
,
590 .def
= MT9T001_GLOBAL_GAIN_MIN
,
593 .ops
= &mt9t001_ctrl_ops
,
594 .id
= V4L2_CID_GAIN_GREEN_RED
,
595 .type
= V4L2_CTRL_TYPE_INTEGER
,
596 .name
= "Gain, Green (R)",
597 .min
= MT9T001_GLOBAL_GAIN_MIN
,
598 .max
= MT9T001_GLOBAL_GAIN_MAX
,
600 .def
= MT9T001_GLOBAL_GAIN_MIN
,
603 .ops
= &mt9t001_ctrl_ops
,
604 .id
= V4L2_CID_GAIN_GREEN_BLUE
,
605 .type
= V4L2_CTRL_TYPE_INTEGER
,
606 .name
= "Gain, Green (B)",
607 .min
= MT9T001_GLOBAL_GAIN_MIN
,
608 .max
= MT9T001_GLOBAL_GAIN_MAX
,
610 .def
= MT9T001_GLOBAL_GAIN_MIN
,
613 .ops
= &mt9t001_ctrl_ops
,
614 .id
= V4L2_CID_GAIN_BLUE
,
615 .type
= V4L2_CTRL_TYPE_INTEGER
,
616 .name
= "Gain, Blue",
617 .min
= MT9T001_GLOBAL_GAIN_MIN
,
618 .max
= MT9T001_GLOBAL_GAIN_MAX
,
620 .def
= MT9T001_GLOBAL_GAIN_MIN
,
625 /* -----------------------------------------------------------------------------
626 * V4L2 subdev internal operations
629 static int mt9t001_open(struct v4l2_subdev
*subdev
, struct v4l2_subdev_fh
*fh
)
631 struct v4l2_mbus_framefmt
*format
;
632 struct v4l2_rect
*crop
;
634 crop
= v4l2_subdev_get_try_crop(fh
, 0);
635 crop
->left
= MT9T001_COLUMN_START_DEF
;
636 crop
->top
= MT9T001_ROW_START_DEF
;
637 crop
->width
= MT9T001_WINDOW_WIDTH_DEF
+ 1;
638 crop
->height
= MT9T001_WINDOW_HEIGHT_DEF
+ 1;
640 format
= v4l2_subdev_get_try_format(fh
, 0);
641 format
->code
= V4L2_MBUS_FMT_SGRBG10_1X10
;
642 format
->width
= MT9T001_WINDOW_WIDTH_DEF
+ 1;
643 format
->height
= MT9T001_WINDOW_HEIGHT_DEF
+ 1;
644 format
->field
= V4L2_FIELD_NONE
;
645 format
->colorspace
= V4L2_COLORSPACE_SRGB
;
650 static struct v4l2_subdev_video_ops mt9t001_subdev_video_ops
= {
651 .s_stream
= mt9t001_s_stream
,
654 static struct v4l2_subdev_pad_ops mt9t001_subdev_pad_ops
= {
655 .enum_mbus_code
= mt9t001_enum_mbus_code
,
656 .enum_frame_size
= mt9t001_enum_frame_size
,
657 .get_fmt
= mt9t001_get_format
,
658 .set_fmt
= mt9t001_set_format
,
659 .get_crop
= mt9t001_get_crop
,
660 .set_crop
= mt9t001_set_crop
,
663 static struct v4l2_subdev_ops mt9t001_subdev_ops
= {
664 .video
= &mt9t001_subdev_video_ops
,
665 .pad
= &mt9t001_subdev_pad_ops
,
668 static struct v4l2_subdev_internal_ops mt9t001_subdev_internal_ops
= {
669 .open
= mt9t001_open
,
672 static int mt9t001_video_probe(struct i2c_client
*client
)
674 struct mt9t001_platform_data
*pdata
= client
->dev
.platform_data
;
678 dev_info(&client
->dev
, "Probing MT9T001 at address 0x%02x\n",
681 /* Reset the chip and stop data read out */
682 ret
= mt9t001_write(client
, MT9T001_RESET
, 1);
686 ret
= mt9t001_write(client
, MT9T001_RESET
, 0);
690 ret
= mt9t001_write(client
, MT9T001_OUTPUT_CONTROL
, 0);
694 /* Configure the pixel clock polarity */
695 if (pdata
&& pdata
->clk_pol
) {
696 ret
= mt9t001_write(client
, MT9T001_PIXEL_CLOCK
,
697 MT9T001_PIXEL_CLOCK_INVERT
);
702 /* Read and check the sensor version */
703 data
= mt9t001_read(client
, MT9T001_CHIP_VERSION
);
704 if (data
!= MT9T001_CHIP_ID
) {
705 dev_err(&client
->dev
, "MT9T001 not detected, wrong version "
710 dev_info(&client
->dev
, "MT9T001 detected at address 0x%02x\n",
716 static int mt9t001_probe(struct i2c_client
*client
,
717 const struct i2c_device_id
*did
)
719 struct mt9t001
*mt9t001
;
723 if (!i2c_check_functionality(client
->adapter
,
724 I2C_FUNC_SMBUS_WORD_DATA
)) {
725 dev_warn(&client
->adapter
->dev
,
726 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
730 ret
= mt9t001_video_probe(client
);
734 mt9t001
= kzalloc(sizeof(*mt9t001
), GFP_KERNEL
);
738 v4l2_ctrl_handler_init(&mt9t001
->ctrls
, ARRAY_SIZE(mt9t001_ctrls
) +
739 ARRAY_SIZE(mt9t001_gains
) + 2);
741 v4l2_ctrl_new_std(&mt9t001
->ctrls
, &mt9t001_ctrl_ops
,
742 V4L2_CID_EXPOSURE
, MT9T001_SHUTTER_WIDTH_MIN
,
743 MT9T001_SHUTTER_WIDTH_MAX
, 1,
744 MT9T001_SHUTTER_WIDTH_DEF
);
745 v4l2_ctrl_new_std(&mt9t001
->ctrls
, &mt9t001_ctrl_ops
,
746 V4L2_CID_BLACK_LEVEL
, 1, 1, 1, 1);
748 for (i
= 0; i
< ARRAY_SIZE(mt9t001_ctrls
); ++i
)
749 v4l2_ctrl_new_custom(&mt9t001
->ctrls
, &mt9t001_ctrls
[i
], NULL
);
751 for (i
= 0; i
< ARRAY_SIZE(mt9t001_gains
); ++i
)
752 mt9t001
->gains
[i
] = v4l2_ctrl_new_custom(&mt9t001
->ctrls
,
753 &mt9t001_gains
[i
], NULL
);
755 v4l2_ctrl_cluster(ARRAY_SIZE(mt9t001_gains
), mt9t001
->gains
);
757 mt9t001
->subdev
.ctrl_handler
= &mt9t001
->ctrls
;
759 if (mt9t001
->ctrls
.error
) {
760 printk(KERN_INFO
"%s: control initialization error %d\n",
761 __func__
, mt9t001
->ctrls
.error
);
766 mt9t001
->crop
.left
= MT9T001_COLUMN_START_DEF
;
767 mt9t001
->crop
.top
= MT9T001_ROW_START_DEF
;
768 mt9t001
->crop
.width
= MT9T001_WINDOW_WIDTH_DEF
+ 1;
769 mt9t001
->crop
.height
= MT9T001_WINDOW_HEIGHT_DEF
+ 1;
771 mt9t001
->format
.code
= V4L2_MBUS_FMT_SGRBG10_1X10
;
772 mt9t001
->format
.width
= MT9T001_WINDOW_WIDTH_DEF
+ 1;
773 mt9t001
->format
.height
= MT9T001_WINDOW_HEIGHT_DEF
+ 1;
774 mt9t001
->format
.field
= V4L2_FIELD_NONE
;
775 mt9t001
->format
.colorspace
= V4L2_COLORSPACE_SRGB
;
777 v4l2_i2c_subdev_init(&mt9t001
->subdev
, client
, &mt9t001_subdev_ops
);
778 mt9t001
->subdev
.internal_ops
= &mt9t001_subdev_internal_ops
;
779 mt9t001
->subdev
.flags
|= V4L2_SUBDEV_FL_HAS_DEVNODE
;
781 mt9t001
->pad
.flags
= MEDIA_PAD_FL_SOURCE
;
782 ret
= media_entity_init(&mt9t001
->subdev
.entity
, 1, &mt9t001
->pad
, 0);
786 v4l2_ctrl_handler_free(&mt9t001
->ctrls
);
787 media_entity_cleanup(&mt9t001
->subdev
.entity
);
794 static int mt9t001_remove(struct i2c_client
*client
)
796 struct v4l2_subdev
*subdev
= i2c_get_clientdata(client
);
797 struct mt9t001
*mt9t001
= to_mt9t001(subdev
);
799 v4l2_ctrl_handler_free(&mt9t001
->ctrls
);
800 v4l2_device_unregister_subdev(subdev
);
801 media_entity_cleanup(&subdev
->entity
);
806 static const struct i2c_device_id mt9t001_id
[] = {
810 MODULE_DEVICE_TABLE(i2c
, mt9t001_id
);
812 static struct i2c_driver mt9t001_driver
= {
816 .probe
= mt9t001_probe
,
817 .remove
= mt9t001_remove
,
818 .id_table
= mt9t001_id
,
821 static int __init
mt9t001_init(void)
823 return i2c_add_driver(&mt9t001_driver
);
826 static void __exit
mt9t001_exit(void)
828 i2c_del_driver(&mt9t001_driver
);
831 module_init(mt9t001_init
);
832 module_exit(mt9t001_exit
);
834 MODULE_DESCRIPTION("Aptina (Micron) MT9T001 Camera driver");
835 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
836 MODULE_LICENSE("GPL");