2 * Driver for MT9T031 CMOS Image Sensor from Micron
4 * Copyright (C) 2008, Guennadi Liakhovetski, DENX Software Engineering <lg@denx.de>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/videodev2.h>
12 #include <linux/slab.h>
13 #include <linux/i2c.h>
14 #include <linux/log2.h>
16 #include <media/v4l2-subdev.h>
17 #include <media/v4l2-chip-ident.h>
18 #include <media/soc_camera.h>
20 /* mt9t031 i2c address 0x5d
21 * The platform has to define i2c_board_info and link to it from
22 * struct soc_camera_link */
24 /* mt9t031 selected register addresses */
25 #define MT9T031_CHIP_VERSION 0x00
26 #define MT9T031_ROW_START 0x01
27 #define MT9T031_COLUMN_START 0x02
28 #define MT9T031_WINDOW_HEIGHT 0x03
29 #define MT9T031_WINDOW_WIDTH 0x04
30 #define MT9T031_HORIZONTAL_BLANKING 0x05
31 #define MT9T031_VERTICAL_BLANKING 0x06
32 #define MT9T031_OUTPUT_CONTROL 0x07
33 #define MT9T031_SHUTTER_WIDTH_UPPER 0x08
34 #define MT9T031_SHUTTER_WIDTH 0x09
35 #define MT9T031_PIXEL_CLOCK_CONTROL 0x0a
36 #define MT9T031_FRAME_RESTART 0x0b
37 #define MT9T031_SHUTTER_DELAY 0x0c
38 #define MT9T031_RESET 0x0d
39 #define MT9T031_READ_MODE_1 0x1e
40 #define MT9T031_READ_MODE_2 0x20
41 #define MT9T031_READ_MODE_3 0x21
42 #define MT9T031_ROW_ADDRESS_MODE 0x22
43 #define MT9T031_COLUMN_ADDRESS_MODE 0x23
44 #define MT9T031_GLOBAL_GAIN 0x35
45 #define MT9T031_CHIP_ENABLE 0xF8
47 #define MT9T031_MAX_HEIGHT 1536
48 #define MT9T031_MAX_WIDTH 2048
49 #define MT9T031_MIN_HEIGHT 2
50 #define MT9T031_MIN_WIDTH 2
51 #define MT9T031_HORIZONTAL_BLANK 142
52 #define MT9T031_VERTICAL_BLANK 25
53 #define MT9T031_COLUMN_SKIP 32
54 #define MT9T031_ROW_SKIP 20
56 #define MT9T031_BUS_PARAM (SOCAM_PCLK_SAMPLE_RISING | \
57 SOCAM_PCLK_SAMPLE_FALLING | SOCAM_HSYNC_ACTIVE_HIGH | \
58 SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_DATA_ACTIVE_HIGH | \
59 SOCAM_MASTER | SOCAM_DATAWIDTH_10)
61 static const struct soc_camera_data_format mt9t031_colour_formats[] = {
63 .name = "Bayer (sRGB) 10 bit",
65 .fourcc = V4L2_PIX_FMT_SGRBG10,
66 .colorspace = V4L2_COLORSPACE_SRGB,
71 struct v4l2_subdev subdev;
72 int model; /* V4L2_IDENT_MT9T031* codes from v4l2-chip-ident.h */
73 unsigned char autoexposure;
78 static struct mt9t031 *to_mt9t031(const struct i2c_client *client)
80 return container_of(i2c_get_clientdata(client), struct mt9t031, subdev);
83 static int reg_read(struct i2c_client *client, const u8 reg)
85 s32 data = i2c_smbus_read_word_data(client, reg);
86 return data < 0 ? data : swab16(data);
89 static int reg_write(struct i2c_client *client, const u8 reg,
92 return i2c_smbus_write_word_data(client, reg, swab16(data));
95 static int reg_set(struct i2c_client *client, const u8 reg,
100 ret = reg_read(client, reg);
103 return reg_write(client, reg, ret | data);
106 static int reg_clear(struct i2c_client *client, const u8 reg,
111 ret = reg_read(client, reg);
114 return reg_write(client, reg, ret & ~data);
117 static int set_shutter(struct i2c_client *client, const u32 data)
121 ret = reg_write(client, MT9T031_SHUTTER_WIDTH_UPPER, data >> 16);
124 ret = reg_write(client, MT9T031_SHUTTER_WIDTH, data & 0xffff);
129 static int get_shutter(struct i2c_client *client, u32 *data)
133 ret = reg_read(client, MT9T031_SHUTTER_WIDTH_UPPER);
137 ret = reg_read(client, MT9T031_SHUTTER_WIDTH);
138 *data |= ret & 0xffff;
140 return ret < 0 ? ret : 0;
143 static int mt9t031_idle(struct i2c_client *client)
147 /* Disable chip output, synchronous option update */
148 ret = reg_write(client, MT9T031_RESET, 1);
150 ret = reg_write(client, MT9T031_RESET, 0);
152 ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
154 return ret >= 0 ? 0 : -EIO;
157 static int mt9t031_disable(struct i2c_client *client)
159 /* Disable the chip */
160 reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
165 static int mt9t031_init(struct soc_camera_device *icd)
167 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
169 return mt9t031_idle(client);
172 static int mt9t031_release(struct soc_camera_device *icd)
174 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
176 return mt9t031_disable(client);
179 static int mt9t031_s_stream(struct v4l2_subdev *sd, int enable)
181 struct i2c_client *client = sd->priv;
185 /* Switch to master "normal" mode */
186 ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 2);
188 /* Stop sensor readout */
189 ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 2);
197 static int mt9t031_set_bus_param(struct soc_camera_device *icd,
200 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
202 /* The caller should have queried our parameters, check anyway */
203 if (flags & ~MT9T031_BUS_PARAM)
206 if (flags & SOCAM_PCLK_SAMPLE_FALLING)
207 reg_clear(client, MT9T031_PIXEL_CLOCK_CONTROL, 0x8000);
209 reg_set(client, MT9T031_PIXEL_CLOCK_CONTROL, 0x8000);
214 static unsigned long mt9t031_query_bus_param(struct soc_camera_device *icd)
216 struct soc_camera_link *icl = to_soc_camera_link(icd);
218 return soc_camera_apply_sensor_flags(icl, MT9T031_BUS_PARAM);
221 /* Round up minima and round down maxima */
222 static void recalculate_limits(struct soc_camera_device *icd,
223 u16 xskip, u16 yskip)
225 icd->rect_max.left = (MT9T031_COLUMN_SKIP + xskip - 1) / xskip;
226 icd->rect_max.top = (MT9T031_ROW_SKIP + yskip - 1) / yskip;
227 icd->width_min = (MT9T031_MIN_WIDTH + xskip - 1) / xskip;
228 icd->height_min = (MT9T031_MIN_HEIGHT + yskip - 1) / yskip;
229 icd->rect_max.width = MT9T031_MAX_WIDTH / xskip;
230 icd->rect_max.height = MT9T031_MAX_HEIGHT / yskip;
233 static int mt9t031_set_params(struct soc_camera_device *icd,
234 struct v4l2_rect *rect, u16 xskip, u16 yskip)
236 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
237 struct mt9t031 *mt9t031 = to_mt9t031(client);
239 u16 xbin, ybin, width, height, left, top;
240 const u16 hblank = MT9T031_HORIZONTAL_BLANK,
241 vblank = MT9T031_VERTICAL_BLANK;
243 width = rect->width * xskip;
244 height = rect->height * yskip;
245 left = rect->left * xskip;
246 top = rect->top * yskip;
248 xbin = min(xskip, (u16)3);
249 ybin = min(yskip, (u16)3);
251 dev_dbg(&icd->dev, "xskip %u, width %u/%u, yskip %u, height %u/%u\n",
252 xskip, width, rect->width, yskip, height, rect->height);
254 /* Could just do roundup(rect->left, [xy]bin * 2); but this is cheaper */
257 left = (left + 3) & ~3;
260 left = roundup(left, 6);
265 top = (top + 3) & ~3;
268 top = roundup(top, 6);
271 /* Disable register update, reconfigure atomically */
272 ret = reg_set(client, MT9T031_OUTPUT_CONTROL, 1);
276 /* Blanking and start values - default... */
277 ret = reg_write(client, MT9T031_HORIZONTAL_BLANKING, hblank);
279 ret = reg_write(client, MT9T031_VERTICAL_BLANKING, vblank);
281 if (yskip != mt9t031->yskip || xskip != mt9t031->xskip) {
282 /* Binning, skipping */
284 ret = reg_write(client, MT9T031_COLUMN_ADDRESS_MODE,
285 ((xbin - 1) << 4) | (xskip - 1));
287 ret = reg_write(client, MT9T031_ROW_ADDRESS_MODE,
288 ((ybin - 1) << 4) | (yskip - 1));
290 dev_dbg(&icd->dev, "new physical left %u, top %u\n", left, top);
292 /* The caller provides a supported format, as guaranteed by
293 * icd->try_fmt_cap(), soc_camera_s_crop() and soc_camera_cropcap() */
295 ret = reg_write(client, MT9T031_COLUMN_START, left);
297 ret = reg_write(client, MT9T031_ROW_START, top);
299 ret = reg_write(client, MT9T031_WINDOW_WIDTH, width - 1);
301 ret = reg_write(client, MT9T031_WINDOW_HEIGHT,
302 height + icd->y_skip_top - 1);
303 if (ret >= 0 && mt9t031->autoexposure) {
304 ret = set_shutter(client, height + icd->y_skip_top + vblank);
306 const u32 shutter_max = MT9T031_MAX_HEIGHT + vblank;
307 const struct v4l2_queryctrl *qctrl =
308 soc_camera_find_qctrl(icd->ops,
310 icd->exposure = (shutter_max / 2 + (height +
311 icd->y_skip_top + vblank - 1) *
312 (qctrl->maximum - qctrl->minimum)) /
313 shutter_max + qctrl->minimum;
317 /* Re-enable register update, commit all changes */
319 ret = reg_clear(client, MT9T031_OUTPUT_CONTROL, 1);
321 return ret < 0 ? ret : 0;
324 static int mt9t031_set_crop(struct soc_camera_device *icd,
325 struct v4l2_rect *rect)
327 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
328 struct mt9t031 *mt9t031 = to_mt9t031(client);
330 /* Make sure we don't exceed sensor limits */
331 if (rect->left + rect->width > icd->rect_max.left + icd->rect_max.width)
332 rect->left = icd->rect_max.width + icd->rect_max.left -
335 if (rect->top + rect->height > icd->rect_max.height + icd->rect_max.top)
336 rect->top = icd->rect_max.height + icd->rect_max.top -
339 /* CROP - no change in scaling, or in limits */
340 return mt9t031_set_params(icd, rect, mt9t031->xskip, mt9t031->yskip);
343 static int mt9t031_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
345 struct i2c_client *client = sd->priv;
346 struct mt9t031 *mt9t031 = to_mt9t031(client);
347 struct soc_camera_device *icd = client->dev.platform_data;
350 struct v4l2_rect rect = {
351 .left = icd->rect_current.left,
352 .top = icd->rect_current.top,
353 .width = f->fmt.pix.width,
354 .height = f->fmt.pix.height,
358 * try_fmt has put rectangle within limits.
359 * S_FMT - use binning and skipping for scaling, recalculate
360 * limits, used for cropping
362 /* Is this more optimal than just a division? */
363 for (xskip = 8; xskip > 1; xskip--)
364 if (rect.width * xskip <= MT9T031_MAX_WIDTH)
367 for (yskip = 8; yskip > 1; yskip--)
368 if (rect.height * yskip <= MT9T031_MAX_HEIGHT)
371 recalculate_limits(icd, xskip, yskip);
373 ret = mt9t031_set_params(icd, &rect, xskip, yskip);
375 mt9t031->xskip = xskip;
376 mt9t031->yskip = yskip;
382 static int mt9t031_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
384 struct v4l2_pix_format *pix = &f->fmt.pix;
386 v4l_bound_align_image(
387 &pix->width, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH, 1,
388 &pix->height, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT, 1, 0);
393 static int mt9t031_g_chip_ident(struct v4l2_subdev *sd,
394 struct v4l2_dbg_chip_ident *id)
396 struct i2c_client *client = sd->priv;
397 struct mt9t031 *mt9t031 = to_mt9t031(client);
399 if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
402 if (id->match.addr != client->addr)
405 id->ident = mt9t031->model;
411 #ifdef CONFIG_VIDEO_ADV_DEBUG
412 static int mt9t031_g_register(struct v4l2_subdev *sd,
413 struct v4l2_dbg_register *reg)
415 struct i2c_client *client = sd->priv;
417 if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
420 if (reg->match.addr != client->addr)
423 reg->val = reg_read(client, reg->reg);
425 if (reg->val > 0xffff)
431 static int mt9t031_s_register(struct v4l2_subdev *sd,
432 struct v4l2_dbg_register *reg)
434 struct i2c_client *client = sd->priv;
436 if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
439 if (reg->match.addr != client->addr)
442 if (reg_write(client, reg->reg, reg->val) < 0)
449 static const struct v4l2_queryctrl mt9t031_controls[] = {
451 .id = V4L2_CID_VFLIP,
452 .type = V4L2_CTRL_TYPE_BOOLEAN,
453 .name = "Flip Vertically",
459 .id = V4L2_CID_HFLIP,
460 .type = V4L2_CTRL_TYPE_BOOLEAN,
461 .name = "Flip Horizontally",
468 .type = V4L2_CTRL_TYPE_INTEGER,
474 .flags = V4L2_CTRL_FLAG_SLIDER,
476 .id = V4L2_CID_EXPOSURE,
477 .type = V4L2_CTRL_TYPE_INTEGER,
482 .default_value = 255,
483 .flags = V4L2_CTRL_FLAG_SLIDER,
485 .id = V4L2_CID_EXPOSURE_AUTO,
486 .type = V4L2_CTRL_TYPE_BOOLEAN,
487 .name = "Automatic Exposure",
495 static struct soc_camera_ops mt9t031_ops = {
496 .init = mt9t031_init,
497 .release = mt9t031_release,
498 .set_crop = mt9t031_set_crop,
499 .set_bus_param = mt9t031_set_bus_param,
500 .query_bus_param = mt9t031_query_bus_param,
501 .controls = mt9t031_controls,
502 .num_controls = ARRAY_SIZE(mt9t031_controls),
505 static int mt9t031_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
507 struct i2c_client *client = sd->priv;
508 struct mt9t031 *mt9t031 = to_mt9t031(client);
513 data = reg_read(client, MT9T031_READ_MODE_2);
516 ctrl->value = !!(data & 0x8000);
519 data = reg_read(client, MT9T031_READ_MODE_2);
522 ctrl->value = !!(data & 0x4000);
524 case V4L2_CID_EXPOSURE_AUTO:
525 ctrl->value = mt9t031->autoexposure;
531 static int mt9t031_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
533 struct i2c_client *client = sd->priv;
534 struct mt9t031 *mt9t031 = to_mt9t031(client);
535 struct soc_camera_device *icd = client->dev.platform_data;
536 const struct v4l2_queryctrl *qctrl;
539 qctrl = soc_camera_find_qctrl(&mt9t031_ops, ctrl->id);
547 data = reg_set(client, MT9T031_READ_MODE_2, 0x8000);
549 data = reg_clear(client, MT9T031_READ_MODE_2, 0x8000);
555 data = reg_set(client, MT9T031_READ_MODE_2, 0x4000);
557 data = reg_clear(client, MT9T031_READ_MODE_2, 0x4000);
562 if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum)
564 /* See Datasheet Table 7, Gain settings. */
565 if (ctrl->value <= qctrl->default_value) {
566 /* Pack it into 0..1 step 0.125, register values 0..8 */
567 unsigned long range = qctrl->default_value - qctrl->minimum;
568 data = ((ctrl->value - qctrl->minimum) * 8 + range / 2) / range;
570 dev_dbg(&icd->dev, "Setting gain %d\n", data);
571 data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
575 /* Pack it into 1.125..128 variable step, register values 9..0x7860 */
576 /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
577 unsigned long range = qctrl->maximum - qctrl->default_value - 1;
578 /* calculated gain: map 65..127 to 9..1024 step 0.125 */
579 unsigned long gain = ((ctrl->value - qctrl->default_value - 1) *
580 1015 + range / 2) / range + 9;
582 if (gain <= 32) /* calculated gain 9..32 -> 9..32 */
584 else if (gain <= 64) /* calculated gain 33..64 -> 0x51..0x60 */
585 data = ((gain - 32) * 16 + 16) / 32 + 80;
587 /* calculated gain 65..1024 -> (1..120) << 8 + 0x60 */
588 data = (((gain - 64 + 7) * 32) & 0xff00) | 0x60;
590 dev_dbg(&icd->dev, "Setting gain from 0x%x to 0x%x\n",
591 reg_read(client, MT9T031_GLOBAL_GAIN), data);
592 data = reg_write(client, MT9T031_GLOBAL_GAIN, data);
598 icd->gain = ctrl->value;
600 case V4L2_CID_EXPOSURE:
601 /* mt9t031 has maximum == default */
602 if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum)
605 const unsigned long range = qctrl->maximum - qctrl->minimum;
606 const u32 shutter = ((ctrl->value - qctrl->minimum) * 1048 +
607 range / 2) / range + 1;
610 get_shutter(client, &old);
611 dev_dbg(&icd->dev, "Setting shutter width from %u to %u\n",
613 if (set_shutter(client, shutter) < 0)
615 icd->exposure = ctrl->value;
616 mt9t031->autoexposure = 0;
619 case V4L2_CID_EXPOSURE_AUTO:
621 const u16 vblank = MT9T031_VERTICAL_BLANK;
622 const u32 shutter_max = MT9T031_MAX_HEIGHT + vblank;
623 if (set_shutter(client, icd->rect_current.height +
624 icd->y_skip_top + vblank) < 0)
626 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
627 icd->exposure = (shutter_max / 2 +
628 (icd->rect_current.height +
629 icd->y_skip_top + vblank - 1) *
630 (qctrl->maximum - qctrl->minimum)) /
631 shutter_max + qctrl->minimum;
632 mt9t031->autoexposure = 1;
634 mt9t031->autoexposure = 0;
640 /* Interface active, can use i2c. If it fails, it can indeed mean, that
641 * this wasn't our capture interface, so, we wait for the right one */
642 static int mt9t031_video_probe(struct i2c_client *client)
644 struct soc_camera_device *icd = client->dev.platform_data;
645 struct mt9t031 *mt9t031 = to_mt9t031(client);
648 /* We must have a parent by now. And it cannot be a wrong one.
649 * So this entire test is completely redundant. */
650 if (!icd->dev.parent ||
651 to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
654 /* Enable the chip */
655 data = reg_write(client, MT9T031_CHIP_ENABLE, 1);
656 dev_dbg(&icd->dev, "write: %d\n", data);
658 /* Read out the chip version register */
659 data = reg_read(client, MT9T031_CHIP_VERSION);
663 mt9t031->model = V4L2_IDENT_MT9T031;
664 icd->formats = mt9t031_colour_formats;
665 icd->num_formats = ARRAY_SIZE(mt9t031_colour_formats);
669 "No MT9T031 chip detected, register read %x\n", data);
673 dev_info(&icd->dev, "Detected a MT9T031 chip ID %x\n", data);
678 static struct v4l2_subdev_core_ops mt9t031_subdev_core_ops = {
679 .g_ctrl = mt9t031_g_ctrl,
680 .s_ctrl = mt9t031_s_ctrl,
681 .g_chip_ident = mt9t031_g_chip_ident,
682 #ifdef CONFIG_VIDEO_ADV_DEBUG
683 .g_register = mt9t031_g_register,
684 .s_register = mt9t031_s_register,
688 static struct v4l2_subdev_video_ops mt9t031_subdev_video_ops = {
689 .s_stream = mt9t031_s_stream,
690 .s_fmt = mt9t031_s_fmt,
691 .try_fmt = mt9t031_try_fmt,
694 static struct v4l2_subdev_ops mt9t031_subdev_ops = {
695 .core = &mt9t031_subdev_core_ops,
696 .video = &mt9t031_subdev_video_ops,
699 static int mt9t031_probe(struct i2c_client *client,
700 const struct i2c_device_id *did)
702 struct mt9t031 *mt9t031;
703 struct soc_camera_device *icd = client->dev.platform_data;
704 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
705 struct soc_camera_link *icl;
709 dev_err(&client->dev, "MT9T031: missing soc-camera data!\n");
713 icl = to_soc_camera_link(icd);
715 dev_err(&client->dev, "MT9T031 driver needs platform data\n");
719 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
720 dev_warn(&adapter->dev,
721 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
725 mt9t031 = kzalloc(sizeof(struct mt9t031), GFP_KERNEL);
729 v4l2_i2c_subdev_init(&mt9t031->subdev, client, &mt9t031_subdev_ops);
731 /* Second stage probe - when a capture adapter is there */
732 icd->ops = &mt9t031_ops;
733 icd->rect_max.left = MT9T031_COLUMN_SKIP;
734 icd->rect_max.top = MT9T031_ROW_SKIP;
735 icd->rect_current.left = icd->rect_max.left;
736 icd->rect_current.top = icd->rect_max.top;
737 icd->width_min = MT9T031_MIN_WIDTH;
738 icd->rect_max.width = MT9T031_MAX_WIDTH;
739 icd->height_min = MT9T031_MIN_HEIGHT;
740 icd->rect_max.height = MT9T031_MAX_HEIGHT;
742 /* Simulated autoexposure. If enabled, we calculate shutter width
743 * ourselves in the driver based on vertical blanking and frame width */
744 mt9t031->autoexposure = 1;
749 mt9t031_idle(client);
751 ret = mt9t031_video_probe(client);
753 mt9t031_disable(client);
757 i2c_set_clientdata(client, NULL);
764 static int mt9t031_remove(struct i2c_client *client)
766 struct mt9t031 *mt9t031 = to_mt9t031(client);
767 struct soc_camera_device *icd = client->dev.platform_data;
770 i2c_set_clientdata(client, NULL);
771 client->driver = NULL;
777 static const struct i2c_device_id mt9t031_id[] = {
781 MODULE_DEVICE_TABLE(i2c, mt9t031_id);
783 static struct i2c_driver mt9t031_i2c_driver = {
787 .probe = mt9t031_probe,
788 .remove = mt9t031_remove,
789 .id_table = mt9t031_id,
792 static int __init mt9t031_mod_init(void)
794 return i2c_add_driver(&mt9t031_i2c_driver);
797 static void __exit mt9t031_mod_exit(void)
799 i2c_del_driver(&mt9t031_i2c_driver);
802 module_init(mt9t031_mod_init);
803 module_exit(mt9t031_mod_exit);
805 MODULE_DESCRIPTION("Micron MT9T031 Camera driver");
806 MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
807 MODULE_LICENSE("GPL v2");