2 * Driver for MT9M032 CMOS Image Sensor from Micron
4 * Copyright (C) 2010-2011 Lund Engineering
5 * Contact: Gil Lund <gwlund@lundeng.com>
6 * Author: Martin Hostettler <martin@neutronstar.dyndns.org>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 #include <linux/delay.h>
24 #include <linux/i2c.h>
25 #include <linux/init.h>
26 #include <linux/kernel.h>
27 #include <linux/math64.h>
28 #include <linux/module.h>
29 #include <linux/mutex.h>
30 #include <linux/slab.h>
31 #include <linux/v4l2-mediabus.h>
33 #include <media/media-entity.h>
34 #include <media/i2c/mt9m032.h>
35 #include <media/v4l2-ctrls.h>
36 #include <media/v4l2-device.h>
37 #include <media/v4l2-subdev.h>
39 #include "aptina-pll.h"
42 * width and height include active boundary and black parts
44 * column 0- 15 active boundary
45 * column 16-1455 image
46 * column 1456-1471 active boundary
47 * column 1472-1599 black
50 * row 53- 59 active boundary
52 * row 1140-1147 active boundary
56 #define MT9M032_PIXEL_ARRAY_WIDTH 1600
57 #define MT9M032_PIXEL_ARRAY_HEIGHT 1152
59 #define MT9M032_CHIP_VERSION 0x00
60 #define MT9M032_CHIP_VERSION_VALUE 0x1402
61 #define MT9M032_ROW_START 0x01
62 #define MT9M032_ROW_START_MIN 0
63 #define MT9M032_ROW_START_MAX 1152
64 #define MT9M032_ROW_START_DEF 60
65 #define MT9M032_COLUMN_START 0x02
66 #define MT9M032_COLUMN_START_MIN 0
67 #define MT9M032_COLUMN_START_MAX 1600
68 #define MT9M032_COLUMN_START_DEF 16
69 #define MT9M032_ROW_SIZE 0x03
70 #define MT9M032_ROW_SIZE_MIN 32
71 #define MT9M032_ROW_SIZE_MAX 1152
72 #define MT9M032_ROW_SIZE_DEF 1080
73 #define MT9M032_COLUMN_SIZE 0x04
74 #define MT9M032_COLUMN_SIZE_MIN 32
75 #define MT9M032_COLUMN_SIZE_MAX 1600
76 #define MT9M032_COLUMN_SIZE_DEF 1440
77 #define MT9M032_HBLANK 0x05
78 #define MT9M032_VBLANK 0x06
79 #define MT9M032_VBLANK_MAX 0x7ff
80 #define MT9M032_SHUTTER_WIDTH_HIGH 0x08
81 #define MT9M032_SHUTTER_WIDTH_LOW 0x09
82 #define MT9M032_SHUTTER_WIDTH_MIN 1
83 #define MT9M032_SHUTTER_WIDTH_MAX 1048575
84 #define MT9M032_SHUTTER_WIDTH_DEF 1943
85 #define MT9M032_PIX_CLK_CTRL 0x0a
86 #define MT9M032_PIX_CLK_CTRL_INV_PIXCLK 0x8000
87 #define MT9M032_RESTART 0x0b
88 #define MT9M032_RESET 0x0d
89 #define MT9M032_PLL_CONFIG1 0x11
90 #define MT9M032_PLL_CONFIG1_PREDIV_MASK 0x3f
91 #define MT9M032_PLL_CONFIG1_MUL_SHIFT 8
92 #define MT9M032_READ_MODE1 0x1e
93 #define MT9M032_READ_MODE1_OUTPUT_BAD_FRAMES (1 << 13)
94 #define MT9M032_READ_MODE1_MAINTAIN_FRAME_RATE (1 << 12)
95 #define MT9M032_READ_MODE1_XOR_LINE_VALID (1 << 11)
96 #define MT9M032_READ_MODE1_CONT_LINE_VALID (1 << 10)
97 #define MT9M032_READ_MODE1_INVERT_TRIGGER (1 << 9)
98 #define MT9M032_READ_MODE1_SNAPSHOT (1 << 8)
99 #define MT9M032_READ_MODE1_GLOBAL_RESET (1 << 7)
100 #define MT9M032_READ_MODE1_BULB_EXPOSURE (1 << 6)
101 #define MT9M032_READ_MODE1_INVERT_STROBE (1 << 5)
102 #define MT9M032_READ_MODE1_STROBE_ENABLE (1 << 4)
103 #define MT9M032_READ_MODE1_STROBE_START_TRIG1 (0 << 2)
104 #define MT9M032_READ_MODE1_STROBE_START_EXP (1 << 2)
105 #define MT9M032_READ_MODE1_STROBE_START_SHUTTER (2 << 2)
106 #define MT9M032_READ_MODE1_STROBE_START_TRIG2 (3 << 2)
107 #define MT9M032_READ_MODE1_STROBE_END_TRIG1 (0 << 0)
108 #define MT9M032_READ_MODE1_STROBE_END_EXP (1 << 0)
109 #define MT9M032_READ_MODE1_STROBE_END_SHUTTER (2 << 0)
110 #define MT9M032_READ_MODE1_STROBE_END_TRIG2 (3 << 0)
111 #define MT9M032_READ_MODE2 0x20
112 #define MT9M032_READ_MODE2_VFLIP_SHIFT 15
113 #define MT9M032_READ_MODE2_HFLIP_SHIFT 14
114 #define MT9M032_READ_MODE2_ROW_BLC 0x40
115 #define MT9M032_GAIN_GREEN1 0x2b
116 #define MT9M032_GAIN_BLUE 0x2c
117 #define MT9M032_GAIN_RED 0x2d
118 #define MT9M032_GAIN_GREEN2 0x2e
121 #define MT9M032_GAIN_ALL 0x35
122 #define MT9M032_GAIN_DIGITAL_MASK 0x7f
123 #define MT9M032_GAIN_DIGITAL_SHIFT 8
124 #define MT9M032_GAIN_AMUL_SHIFT 6
125 #define MT9M032_GAIN_ANALOG_MASK 0x3f
126 #define MT9M032_FORMATTER1 0x9e
127 #define MT9M032_FORMATTER1_PLL_P1_6 (1 << 8)
128 #define MT9M032_FORMATTER1_PARALLEL (1 << 12)
129 #define MT9M032_FORMATTER2 0x9f
130 #define MT9M032_FORMATTER2_DOUT_EN 0x1000
131 #define MT9M032_FORMATTER2_PIXCLK_EN 0x2000
134 * The available MT9M032 datasheet is missing documentation for register 0x10
135 * MT9P031 seems to be close enough, so use constants from that datasheet for
137 * But keep the name MT9P031 to remind us, that this isn't really confirmed
140 #define MT9P031_PLL_CONTROL 0x10
141 #define MT9P031_PLL_CONTROL_PWROFF 0x0050
142 #define MT9P031_PLL_CONTROL_PWRON 0x0051
143 #define MT9P031_PLL_CONTROL_USEPLL 0x0052
146 struct v4l2_subdev subdev;
147 struct media_pad pad;
148 struct mt9m032_platform_data *pdata;
150 unsigned int pix_clock;
152 struct v4l2_ctrl_handler ctrls;
154 struct v4l2_ctrl *hflip;
155 struct v4l2_ctrl *vflip;
158 struct mutex lock; /* Protects streaming, format, interval and crop */
162 struct v4l2_mbus_framefmt format;
163 struct v4l2_rect crop;
164 struct v4l2_fract frame_interval;
167 #define to_mt9m032(sd) container_of(sd, struct mt9m032, subdev)
168 #define to_dev(sensor) \
169 (&((struct i2c_client *)v4l2_get_subdevdata(&(sensor)->subdev))->dev)
171 static int mt9m032_read(struct i2c_client *client, u8 reg)
173 return i2c_smbus_read_word_swapped(client, reg);
176 static int mt9m032_write(struct i2c_client *client, u8 reg, const u16 data)
178 return i2c_smbus_write_word_swapped(client, reg, data);
181 static u32 mt9m032_row_time(struct mt9m032 *sensor, unsigned int width)
183 unsigned int effective_width;
186 effective_width = width + 716; /* empirical value */
187 ns = div_u64(1000000000ULL * effective_width, sensor->pix_clock);
188 dev_dbg(to_dev(sensor), "MT9M032 line time: %u ns\n", ns);
192 static int mt9m032_update_timing(struct mt9m032 *sensor,
193 struct v4l2_fract *interval)
195 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
196 struct v4l2_rect *crop = &sensor->crop;
197 unsigned int min_vblank;
202 interval = &sensor->frame_interval;
204 row_time = mt9m032_row_time(sensor, crop->width);
206 vblank = div_u64(1000000000ULL * interval->numerator,
207 (u64)row_time * interval->denominator)
210 if (vblank > MT9M032_VBLANK_MAX) {
211 /* hardware limits to 11 bit values */
212 interval->denominator = 1000;
213 interval->numerator =
214 div_u64((crop->height + MT9M032_VBLANK_MAX) *
215 (u64)row_time * interval->denominator,
217 vblank = div_u64(1000000000ULL * interval->numerator,
218 (u64)row_time * interval->denominator)
221 /* enforce minimal 1.6ms blanking time. */
222 min_vblank = 1600000 / row_time;
223 vblank = clamp_t(unsigned int, vblank, min_vblank, MT9M032_VBLANK_MAX);
225 return mt9m032_write(client, MT9M032_VBLANK, vblank);
228 static int mt9m032_update_geom_timing(struct mt9m032 *sensor)
230 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
233 ret = mt9m032_write(client, MT9M032_COLUMN_SIZE,
234 sensor->crop.width - 1);
236 ret = mt9m032_write(client, MT9M032_ROW_SIZE,
237 sensor->crop.height - 1);
239 ret = mt9m032_write(client, MT9M032_COLUMN_START,
242 ret = mt9m032_write(client, MT9M032_ROW_START,
245 ret = mt9m032_update_timing(sensor, NULL);
249 static int update_formatter2(struct mt9m032 *sensor, bool streaming)
251 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
252 u16 reg_val = MT9M032_FORMATTER2_DOUT_EN
253 | 0x0070; /* parts reserved! */
254 /* possibly for changing to 14-bit mode */
257 reg_val |= MT9M032_FORMATTER2_PIXCLK_EN; /* pixclock enable */
259 return mt9m032_write(client, MT9M032_FORMATTER2, reg_val);
262 static int mt9m032_setup_pll(struct mt9m032 *sensor)
264 static const struct aptina_pll_limits limits = {
265 .ext_clock_min = 8000000,
266 .ext_clock_max = 16500000,
267 .int_clock_min = 2000000,
268 .int_clock_max = 24000000,
269 .out_clock_min = 322000000,
270 .out_clock_max = 693000000,
271 .pix_clock_max = 99000000,
280 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
281 struct mt9m032_platform_data *pdata = sensor->pdata;
282 struct aptina_pll pll;
286 pll.ext_clock = pdata->ext_clock;
287 pll.pix_clock = pdata->pix_clock;
289 ret = aptina_pll_calculate(&client->dev, &limits, &pll);
293 sensor->pix_clock = pdata->pix_clock;
295 ret = mt9m032_write(client, MT9M032_PLL_CONFIG1,
296 (pll.m << MT9M032_PLL_CONFIG1_MUL_SHIFT) |
297 ((pll.n - 1) & MT9M032_PLL_CONFIG1_PREDIV_MASK));
299 ret = mt9m032_write(client, MT9P031_PLL_CONTROL,
300 MT9P031_PLL_CONTROL_PWRON |
301 MT9P031_PLL_CONTROL_USEPLL);
302 if (!ret) /* more reserved, Continuous, Master Mode */
303 ret = mt9m032_write(client, MT9M032_READ_MODE1, 0x8000 |
304 MT9M032_READ_MODE1_STROBE_START_EXP |
305 MT9M032_READ_MODE1_STROBE_END_SHUTTER);
307 reg_val = (pll.p1 == 6 ? MT9M032_FORMATTER1_PLL_P1_6 : 0)
308 | MT9M032_FORMATTER1_PARALLEL | 0x001e; /* 14-bit */
309 ret = mt9m032_write(client, MT9M032_FORMATTER1, reg_val);
315 /* -----------------------------------------------------------------------------
316 * Subdev pad operations
319 static int mt9m032_enum_mbus_code(struct v4l2_subdev *subdev,
320 struct v4l2_subdev_pad_config *cfg,
321 struct v4l2_subdev_mbus_code_enum *code)
323 if (code->index != 0)
326 code->code = MEDIA_BUS_FMT_Y8_1X8;
330 static int mt9m032_enum_frame_size(struct v4l2_subdev *subdev,
331 struct v4l2_subdev_pad_config *cfg,
332 struct v4l2_subdev_frame_size_enum *fse)
334 if (fse->index != 0 || fse->code != MEDIA_BUS_FMT_Y8_1X8)
337 fse->min_width = MT9M032_COLUMN_SIZE_DEF;
338 fse->max_width = MT9M032_COLUMN_SIZE_DEF;
339 fse->min_height = MT9M032_ROW_SIZE_DEF;
340 fse->max_height = MT9M032_ROW_SIZE_DEF;
346 * __mt9m032_get_pad_crop() - get crop rect
347 * @sensor: pointer to the sensor struct
348 * @cfg: v4l2_subdev_pad_config for getting the try crop rect from
349 * @which: select try or active crop rect
351 * Returns a pointer the current active or fh relative try crop rect
353 static struct v4l2_rect *
354 __mt9m032_get_pad_crop(struct mt9m032 *sensor, struct v4l2_subdev_pad_config *cfg,
355 enum v4l2_subdev_format_whence which)
358 case V4L2_SUBDEV_FORMAT_TRY:
359 return v4l2_subdev_get_try_crop(&sensor->subdev, cfg, 0);
360 case V4L2_SUBDEV_FORMAT_ACTIVE:
361 return &sensor->crop;
368 * __mt9m032_get_pad_format() - get format
369 * @sensor: pointer to the sensor struct
370 * @cfg: v4l2_subdev_pad_config for getting the try format from
371 * @which: select try or active format
373 * Returns a pointer the current active or fh relative try format
375 static struct v4l2_mbus_framefmt *
376 __mt9m032_get_pad_format(struct mt9m032 *sensor, struct v4l2_subdev_pad_config *cfg,
377 enum v4l2_subdev_format_whence which)
380 case V4L2_SUBDEV_FORMAT_TRY:
381 return v4l2_subdev_get_try_format(&sensor->subdev, cfg, 0);
382 case V4L2_SUBDEV_FORMAT_ACTIVE:
383 return &sensor->format;
389 static int mt9m032_get_pad_format(struct v4l2_subdev *subdev,
390 struct v4l2_subdev_pad_config *cfg,
391 struct v4l2_subdev_format *fmt)
393 struct mt9m032 *sensor = to_mt9m032(subdev);
395 mutex_lock(&sensor->lock);
396 fmt->format = *__mt9m032_get_pad_format(sensor, cfg, fmt->which);
397 mutex_unlock(&sensor->lock);
402 static int mt9m032_set_pad_format(struct v4l2_subdev *subdev,
403 struct v4l2_subdev_pad_config *cfg,
404 struct v4l2_subdev_format *fmt)
406 struct mt9m032 *sensor = to_mt9m032(subdev);
409 mutex_lock(&sensor->lock);
411 if (sensor->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
416 /* Scaling is not supported, the format is thus fixed. */
417 fmt->format = *__mt9m032_get_pad_format(sensor, cfg, fmt->which);
421 mutex_unlock(&sensor->lock);
425 static int mt9m032_get_pad_selection(struct v4l2_subdev *subdev,
426 struct v4l2_subdev_pad_config *cfg,
427 struct v4l2_subdev_selection *sel)
429 struct mt9m032 *sensor = to_mt9m032(subdev);
431 if (sel->target != V4L2_SEL_TGT_CROP)
434 mutex_lock(&sensor->lock);
435 sel->r = *__mt9m032_get_pad_crop(sensor, cfg, sel->which);
436 mutex_unlock(&sensor->lock);
441 static int mt9m032_set_pad_selection(struct v4l2_subdev *subdev,
442 struct v4l2_subdev_pad_config *cfg,
443 struct v4l2_subdev_selection *sel)
445 struct mt9m032 *sensor = to_mt9m032(subdev);
446 struct v4l2_mbus_framefmt *format;
447 struct v4l2_rect *__crop;
448 struct v4l2_rect rect;
451 if (sel->target != V4L2_SEL_TGT_CROP)
454 mutex_lock(&sensor->lock);
456 if (sensor->streaming && sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
461 /* Clamp the crop rectangle boundaries and align them to a multiple of 2
462 * pixels to ensure a GRBG Bayer pattern.
464 rect.left = clamp(ALIGN(sel->r.left, 2), MT9M032_COLUMN_START_MIN,
465 MT9M032_COLUMN_START_MAX);
466 rect.top = clamp(ALIGN(sel->r.top, 2), MT9M032_ROW_START_MIN,
467 MT9M032_ROW_START_MAX);
468 rect.width = clamp_t(unsigned int, ALIGN(sel->r.width, 2),
469 MT9M032_COLUMN_SIZE_MIN, MT9M032_COLUMN_SIZE_MAX);
470 rect.height = clamp_t(unsigned int, ALIGN(sel->r.height, 2),
471 MT9M032_ROW_SIZE_MIN, MT9M032_ROW_SIZE_MAX);
473 rect.width = min_t(unsigned int, rect.width,
474 MT9M032_PIXEL_ARRAY_WIDTH - rect.left);
475 rect.height = min_t(unsigned int, rect.height,
476 MT9M032_PIXEL_ARRAY_HEIGHT - rect.top);
478 __crop = __mt9m032_get_pad_crop(sensor, cfg, sel->which);
480 if (rect.width != __crop->width || rect.height != __crop->height) {
481 /* Reset the output image size if the crop rectangle size has
484 format = __mt9m032_get_pad_format(sensor, cfg, sel->which);
485 format->width = rect.width;
486 format->height = rect.height;
492 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE)
493 ret = mt9m032_update_geom_timing(sensor);
496 mutex_unlock(&sensor->lock);
500 static int mt9m032_get_frame_interval(struct v4l2_subdev *subdev,
501 struct v4l2_subdev_frame_interval *fi)
503 struct mt9m032 *sensor = to_mt9m032(subdev);
505 mutex_lock(&sensor->lock);
506 memset(fi, 0, sizeof(*fi));
507 fi->interval = sensor->frame_interval;
508 mutex_unlock(&sensor->lock);
513 static int mt9m032_set_frame_interval(struct v4l2_subdev *subdev,
514 struct v4l2_subdev_frame_interval *fi)
516 struct mt9m032 *sensor = to_mt9m032(subdev);
519 mutex_lock(&sensor->lock);
521 if (sensor->streaming) {
526 /* Avoid divisions by 0. */
527 if (fi->interval.denominator == 0)
528 fi->interval.denominator = 1;
530 ret = mt9m032_update_timing(sensor, &fi->interval);
532 sensor->frame_interval = fi->interval;
535 mutex_unlock(&sensor->lock);
539 static int mt9m032_s_stream(struct v4l2_subdev *subdev, int streaming)
541 struct mt9m032 *sensor = to_mt9m032(subdev);
544 mutex_lock(&sensor->lock);
545 ret = update_formatter2(sensor, streaming);
547 sensor->streaming = streaming;
548 mutex_unlock(&sensor->lock);
553 /* -----------------------------------------------------------------------------
554 * V4L2 subdev core operations
557 #ifdef CONFIG_VIDEO_ADV_DEBUG
558 static int mt9m032_g_register(struct v4l2_subdev *sd,
559 struct v4l2_dbg_register *reg)
561 struct mt9m032 *sensor = to_mt9m032(sd);
562 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
568 val = mt9m032_read(client, reg->reg);
578 static int mt9m032_s_register(struct v4l2_subdev *sd,
579 const struct v4l2_dbg_register *reg)
581 struct mt9m032 *sensor = to_mt9m032(sd);
582 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
587 return mt9m032_write(client, reg->reg, reg->val);
591 /* -----------------------------------------------------------------------------
592 * V4L2 subdev control operations
595 static int update_read_mode2(struct mt9m032 *sensor, bool vflip, bool hflip)
597 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
598 int reg_val = (vflip << MT9M032_READ_MODE2_VFLIP_SHIFT)
599 | (hflip << MT9M032_READ_MODE2_HFLIP_SHIFT)
600 | MT9M032_READ_MODE2_ROW_BLC
603 return mt9m032_write(client, MT9M032_READ_MODE2, reg_val);
606 static int mt9m032_set_gain(struct mt9m032 *sensor, s32 val)
608 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
609 int digital_gain_val; /* in 1/8th (0..127) */
610 int analog_mul; /* 0 or 1 */
611 int analog_gain_val; /* in 1/16th. (0..63) */
614 digital_gain_val = 51; /* from setup example */
618 analog_gain_val = val;
621 analog_gain_val = val / 2;
624 /* a_gain = (1 + analog_mul) + (analog_gain_val + 1) / 16 */
625 /* overall_gain = a_gain * (1 + digital_gain_val / 8) */
627 reg_val = ((digital_gain_val & MT9M032_GAIN_DIGITAL_MASK)
628 << MT9M032_GAIN_DIGITAL_SHIFT)
629 | ((analog_mul & 1) << MT9M032_GAIN_AMUL_SHIFT)
630 | (analog_gain_val & MT9M032_GAIN_ANALOG_MASK);
632 return mt9m032_write(client, MT9M032_GAIN_ALL, reg_val);
635 static int mt9m032_try_ctrl(struct v4l2_ctrl *ctrl)
637 if (ctrl->id == V4L2_CID_GAIN && ctrl->val >= 63) {
638 /* round because of multiplier used for values >= 63 */
645 static int mt9m032_set_ctrl(struct v4l2_ctrl *ctrl)
647 struct mt9m032 *sensor =
648 container_of(ctrl->handler, struct mt9m032, ctrls);
649 struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
654 return mt9m032_set_gain(sensor, ctrl->val);
657 /* case V4L2_CID_VFLIP: -- In the same cluster */
658 return update_read_mode2(sensor, sensor->vflip->val,
661 case V4L2_CID_EXPOSURE:
662 ret = mt9m032_write(client, MT9M032_SHUTTER_WIDTH_HIGH,
663 (ctrl->val >> 16) & 0xffff);
667 return mt9m032_write(client, MT9M032_SHUTTER_WIDTH_LOW,
674 static struct v4l2_ctrl_ops mt9m032_ctrl_ops = {
675 .s_ctrl = mt9m032_set_ctrl,
676 .try_ctrl = mt9m032_try_ctrl,
679 /* -------------------------------------------------------------------------- */
681 static const struct v4l2_subdev_core_ops mt9m032_core_ops = {
682 #ifdef CONFIG_VIDEO_ADV_DEBUG
683 .g_register = mt9m032_g_register,
684 .s_register = mt9m032_s_register,
688 static const struct v4l2_subdev_video_ops mt9m032_video_ops = {
689 .s_stream = mt9m032_s_stream,
690 .g_frame_interval = mt9m032_get_frame_interval,
691 .s_frame_interval = mt9m032_set_frame_interval,
694 static const struct v4l2_subdev_pad_ops mt9m032_pad_ops = {
695 .enum_mbus_code = mt9m032_enum_mbus_code,
696 .enum_frame_size = mt9m032_enum_frame_size,
697 .get_fmt = mt9m032_get_pad_format,
698 .set_fmt = mt9m032_set_pad_format,
699 .set_selection = mt9m032_set_pad_selection,
700 .get_selection = mt9m032_get_pad_selection,
703 static const struct v4l2_subdev_ops mt9m032_ops = {
704 .core = &mt9m032_core_ops,
705 .video = &mt9m032_video_ops,
706 .pad = &mt9m032_pad_ops,
709 /* -----------------------------------------------------------------------------
710 * Driver initialization and probing
713 static int mt9m032_probe(struct i2c_client *client,
714 const struct i2c_device_id *devid)
716 struct mt9m032_platform_data *pdata = client->dev.platform_data;
717 struct i2c_adapter *adapter = client->adapter;
718 struct mt9m032 *sensor;
723 dev_err(&client->dev, "No platform data\n");
727 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
728 dev_warn(&client->dev,
729 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
733 if (!client->dev.platform_data)
736 sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
740 mutex_init(&sensor->lock);
742 sensor->pdata = pdata;
744 v4l2_i2c_subdev_init(&sensor->subdev, client, &mt9m032_ops);
745 sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
747 chip_version = mt9m032_read(client, MT9M032_CHIP_VERSION);
748 if (chip_version != MT9M032_CHIP_VERSION_VALUE) {
749 dev_err(&client->dev, "MT9M032 not detected, wrong version "
750 "0x%04x\n", chip_version);
755 dev_info(&client->dev, "MT9M032 detected at address 0x%02x\n",
758 sensor->frame_interval.numerator = 1;
759 sensor->frame_interval.denominator = 30;
761 sensor->crop.left = MT9M032_COLUMN_START_DEF;
762 sensor->crop.top = MT9M032_ROW_START_DEF;
763 sensor->crop.width = MT9M032_COLUMN_SIZE_DEF;
764 sensor->crop.height = MT9M032_ROW_SIZE_DEF;
766 sensor->format.width = sensor->crop.width;
767 sensor->format.height = sensor->crop.height;
768 sensor->format.code = MEDIA_BUS_FMT_Y8_1X8;
769 sensor->format.field = V4L2_FIELD_NONE;
770 sensor->format.colorspace = V4L2_COLORSPACE_SRGB;
772 v4l2_ctrl_handler_init(&sensor->ctrls, 5);
774 v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
775 V4L2_CID_GAIN, 0, 127, 1, 64);
777 sensor->hflip = v4l2_ctrl_new_std(&sensor->ctrls,
779 V4L2_CID_HFLIP, 0, 1, 1, 0);
780 sensor->vflip = v4l2_ctrl_new_std(&sensor->ctrls,
782 V4L2_CID_VFLIP, 0, 1, 1, 0);
784 v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
785 V4L2_CID_EXPOSURE, MT9M032_SHUTTER_WIDTH_MIN,
786 MT9M032_SHUTTER_WIDTH_MAX, 1,
787 MT9M032_SHUTTER_WIDTH_DEF);
788 v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
789 V4L2_CID_PIXEL_RATE, pdata->pix_clock,
790 pdata->pix_clock, 1, pdata->pix_clock);
792 if (sensor->ctrls.error) {
793 ret = sensor->ctrls.error;
794 dev_err(&client->dev, "control initialization error %d\n", ret);
798 v4l2_ctrl_cluster(2, &sensor->hflip);
800 sensor->subdev.ctrl_handler = &sensor->ctrls;
801 sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
802 ret = media_entity_init(&sensor->subdev.entity, 1, &sensor->pad, 0);
806 ret = mt9m032_write(client, MT9M032_RESET, 1); /* reset on */
809 ret = mt9m032_write(client, MT9M032_RESET, 0); /* reset off */
813 ret = mt9m032_setup_pll(sensor);
816 usleep_range(10000, 11000);
818 ret = v4l2_ctrl_handler_setup(&sensor->ctrls);
823 ret = mt9m032_update_geom_timing(sensor);
827 ret = mt9m032_write(client, 0x41, 0x0000); /* reserved !!! */
830 ret = mt9m032_write(client, 0x42, 0x0003); /* reserved !!! */
833 ret = mt9m032_write(client, 0x43, 0x0003); /* reserved !!! */
836 ret = mt9m032_write(client, 0x7f, 0x0000); /* reserved !!! */
839 if (sensor->pdata->invert_pixclock) {
840 ret = mt9m032_write(client, MT9M032_PIX_CLK_CTRL,
841 MT9M032_PIX_CLK_CTRL_INV_PIXCLK);
846 ret = mt9m032_write(client, MT9M032_RESTART, 1); /* Restart on */
850 ret = mt9m032_write(client, MT9M032_RESTART, 0); /* Restart off */
854 ret = update_formatter2(sensor, false);
861 media_entity_cleanup(&sensor->subdev.entity);
863 v4l2_ctrl_handler_free(&sensor->ctrls);
865 mutex_destroy(&sensor->lock);
869 static int mt9m032_remove(struct i2c_client *client)
871 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
872 struct mt9m032 *sensor = to_mt9m032(subdev);
874 v4l2_device_unregister_subdev(subdev);
875 v4l2_ctrl_handler_free(&sensor->ctrls);
876 media_entity_cleanup(&subdev->entity);
877 mutex_destroy(&sensor->lock);
881 static const struct i2c_device_id mt9m032_id_table[] = {
886 MODULE_DEVICE_TABLE(i2c, mt9m032_id_table);
888 static struct i2c_driver mt9m032_i2c_driver = {
890 .name = MT9M032_NAME,
892 .probe = mt9m032_probe,
893 .remove = mt9m032_remove,
894 .id_table = mt9m032_id_table,
897 module_i2c_driver(mt9m032_i2c_driver);
899 MODULE_AUTHOR("Martin Hostettler <martin@neutronstar.dyndns.org>");
900 MODULE_DESCRIPTION("MT9M032 camera sensor driver");
901 MODULE_LICENSE("GPL v2");