2 * Driver for MT9M001 CMOS Image Sensor from Micron
4 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.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>
15 #include <linux/gpio.h>
17 #include <media/v4l2-common.h>
18 #include <media/v4l2-chip-ident.h>
19 #include <media/soc_camera.h>
21 /* mt9m001 i2c address 0x5d
22 * The platform has to define i2c_board_info
23 * and call i2c_register_board_info() */
25 /* mt9m001 selected register addresses */
26 #define MT9M001_CHIP_VERSION 0x00
27 #define MT9M001_ROW_START 0x01
28 #define MT9M001_COLUMN_START 0x02
29 #define MT9M001_WINDOW_HEIGHT 0x03
30 #define MT9M001_WINDOW_WIDTH 0x04
31 #define MT9M001_HORIZONTAL_BLANKING 0x05
32 #define MT9M001_VERTICAL_BLANKING 0x06
33 #define MT9M001_OUTPUT_CONTROL 0x07
34 #define MT9M001_SHUTTER_WIDTH 0x09
35 #define MT9M001_FRAME_RESTART 0x0b
36 #define MT9M001_SHUTTER_DELAY 0x0c
37 #define MT9M001_RESET 0x0d
38 #define MT9M001_READ_OPTIONS1 0x1e
39 #define MT9M001_READ_OPTIONS2 0x20
40 #define MT9M001_GLOBAL_GAIN 0x35
41 #define MT9M001_CHIP_ENABLE 0xF1
43 static const struct soc_camera_data_format mt9m001_colour_formats
[] = {
44 /* Order important: first natively supported,
45 * second supported with a GPIO extender */
47 .name
= "Bayer (sRGB) 10 bit",
49 .fourcc
= V4L2_PIX_FMT_SBGGR16
,
50 .colorspace
= V4L2_COLORSPACE_SRGB
,
52 .name
= "Bayer (sRGB) 8 bit",
54 .fourcc
= V4L2_PIX_FMT_SBGGR8
,
55 .colorspace
= V4L2_COLORSPACE_SRGB
,
59 static const struct soc_camera_data_format mt9m001_monochrome_formats
[] = {
60 /* Order important - see above */
62 .name
= "Monochrome 10 bit",
64 .fourcc
= V4L2_PIX_FMT_Y16
,
66 .name
= "Monochrome 8 bit",
68 .fourcc
= V4L2_PIX_FMT_GREY
,
73 struct i2c_client
*client
;
74 struct soc_camera_device icd
;
75 int model
; /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */
77 unsigned char autoexposure
;
78 unsigned char datawidth
;
81 static int reg_read(struct soc_camera_device
*icd
, const u8 reg
)
83 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
84 struct i2c_client
*client
= mt9m001
->client
;
85 s32 data
= i2c_smbus_read_word_data(client
, reg
);
86 return data
< 0 ? data
: swab16(data
);
89 static int reg_write(struct soc_camera_device
*icd
, const u8 reg
,
92 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
93 return i2c_smbus_write_word_data(mt9m001
->client
, reg
, swab16(data
));
96 static int reg_set(struct soc_camera_device
*icd
, const u8 reg
,
101 ret
= reg_read(icd
, reg
);
104 return reg_write(icd
, reg
, ret
| data
);
107 static int reg_clear(struct soc_camera_device
*icd
, const u8 reg
,
112 ret
= reg_read(icd
, reg
);
115 return reg_write(icd
, reg
, ret
& ~data
);
118 static int mt9m001_init(struct soc_camera_device
*icd
)
120 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
121 struct soc_camera_link
*icl
= mt9m001
->client
->dev
.platform_data
;
124 dev_dbg(icd
->vdev
->parent
, "%s\n", __func__
);
127 ret
= icl
->power(&mt9m001
->client
->dev
, 1);
129 dev_err(icd
->vdev
->parent
,
130 "Platform failed to power-on the camera.\n");
135 /* The camera could have been already on, we reset it additionally */
137 ret
= icl
->reset(&mt9m001
->client
->dev
);
142 /* Either no platform reset, or platform reset failed */
143 ret
= reg_write(icd
, MT9M001_RESET
, 1);
145 ret
= reg_write(icd
, MT9M001_RESET
, 0);
147 /* Disable chip, synchronous option update */
149 ret
= reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 0);
154 static int mt9m001_release(struct soc_camera_device
*icd
)
156 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
157 struct soc_camera_link
*icl
= mt9m001
->client
->dev
.platform_data
;
159 /* Disable the chip */
160 reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 0);
163 icl
->power(&mt9m001
->client
->dev
, 0);
168 static int mt9m001_start_capture(struct soc_camera_device
*icd
)
170 /* Switch to master "normal" mode */
171 if (reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 2) < 0)
176 static int mt9m001_stop_capture(struct soc_camera_device
*icd
)
178 /* Stop sensor readout */
179 if (reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 0) < 0)
184 static int bus_switch_request(struct mt9m001
*mt9m001
,
185 struct soc_camera_link
*icl
)
187 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
189 unsigned int gpio
= icl
->gpio
;
191 if (gpio_is_valid(gpio
)) {
192 /* We have a data bus switch. */
193 ret
= gpio_request(gpio
, "mt9m001");
195 dev_err(&mt9m001
->client
->dev
, "Cannot get GPIO %u\n",
200 ret
= gpio_direction_output(gpio
, 0);
202 dev_err(&mt9m001
->client
->dev
,
203 "Cannot set GPIO %u to output\n", gpio
);
209 mt9m001
->switch_gpio
= gpio
;
211 mt9m001
->switch_gpio
= -EINVAL
;
216 static void bus_switch_release(struct mt9m001
*mt9m001
)
218 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
219 if (gpio_is_valid(mt9m001
->switch_gpio
))
220 gpio_free(mt9m001
->switch_gpio
);
224 static int bus_switch_act(struct mt9m001
*mt9m001
, int go8bit
)
226 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
227 if (!gpio_is_valid(mt9m001
->switch_gpio
))
230 gpio_set_value_cansleep(mt9m001
->switch_gpio
, go8bit
);
237 static int bus_switch_possible(struct mt9m001
*mt9m001
)
239 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
240 return gpio_is_valid(mt9m001
->switch_gpio
);
246 static int mt9m001_set_bus_param(struct soc_camera_device
*icd
,
249 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
250 unsigned int width_flag
= flags
& SOCAM_DATAWIDTH_MASK
;
253 /* Flags validity verified in test_bus_param */
255 if ((mt9m001
->datawidth
!= 10 && (width_flag
== SOCAM_DATAWIDTH_10
)) ||
256 (mt9m001
->datawidth
!= 9 && (width_flag
== SOCAM_DATAWIDTH_9
)) ||
257 (mt9m001
->datawidth
!= 8 && (width_flag
== SOCAM_DATAWIDTH_8
))) {
258 /* Well, we actually only can do 10 or 8 bits... */
259 if (width_flag
== SOCAM_DATAWIDTH_9
)
261 ret
= bus_switch_act(mt9m001
,
262 width_flag
== SOCAM_DATAWIDTH_8
);
266 mt9m001
->datawidth
= width_flag
== SOCAM_DATAWIDTH_8
? 8 : 10;
272 static unsigned long mt9m001_query_bus_param(struct soc_camera_device
*icd
)
274 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
275 struct soc_camera_link
*icl
= mt9m001
->client
->dev
.platform_data
;
276 /* MT9M001 has all capture_format parameters fixed */
277 unsigned long flags
= SOCAM_DATAWIDTH_10
| SOCAM_PCLK_SAMPLE_RISING
|
278 SOCAM_HSYNC_ACTIVE_HIGH
| SOCAM_VSYNC_ACTIVE_HIGH
|
279 SOCAM_DATA_ACTIVE_HIGH
| SOCAM_MASTER
;
281 if (bus_switch_possible(mt9m001
))
282 flags
|= SOCAM_DATAWIDTH_8
;
284 return soc_camera_apply_sensor_flags(icl
, flags
);
287 static int mt9m001_set_crop(struct soc_camera_device
*icd
,
288 struct v4l2_rect
*rect
)
290 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
292 const u16 hblank
= 9, vblank
= 25;
294 /* Blanking and start values - default... */
295 ret
= reg_write(icd
, MT9M001_HORIZONTAL_BLANKING
, hblank
);
297 ret
= reg_write(icd
, MT9M001_VERTICAL_BLANKING
, vblank
);
299 /* The caller provides a supported format, as verified per
300 * call to icd->try_fmt() */
302 ret
= reg_write(icd
, MT9M001_COLUMN_START
, rect
->left
);
304 ret
= reg_write(icd
, MT9M001_ROW_START
, rect
->top
);
306 ret
= reg_write(icd
, MT9M001_WINDOW_WIDTH
, rect
->width
- 1);
308 ret
= reg_write(icd
, MT9M001_WINDOW_HEIGHT
,
309 rect
->height
+ icd
->y_skip_top
- 1);
310 if (!ret
&& mt9m001
->autoexposure
) {
311 ret
= reg_write(icd
, MT9M001_SHUTTER_WIDTH
,
312 rect
->height
+ icd
->y_skip_top
+ vblank
);
314 const struct v4l2_queryctrl
*qctrl
=
315 soc_camera_find_qctrl(icd
->ops
,
317 icd
->exposure
= (524 + (rect
->height
+ icd
->y_skip_top
+
319 (qctrl
->maximum
- qctrl
->minimum
)) /
320 1048 + qctrl
->minimum
;
327 static int mt9m001_set_fmt(struct soc_camera_device
*icd
,
328 struct v4l2_format
*f
)
330 struct v4l2_rect rect
= {
331 .left
= icd
->x_current
,
332 .top
= icd
->y_current
,
333 .width
= f
->fmt
.pix
.width
,
334 .height
= f
->fmt
.pix
.height
,
337 /* No support for scaling so far, just crop. TODO: use skipping */
338 return mt9m001_set_crop(icd
, &rect
);
341 static int mt9m001_try_fmt(struct soc_camera_device
*icd
,
342 struct v4l2_format
*f
)
344 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
346 if (pix
->height
< 32 + icd
->y_skip_top
)
347 pix
->height
= 32 + icd
->y_skip_top
;
348 if (pix
->height
> 1024 + icd
->y_skip_top
)
349 pix
->height
= 1024 + icd
->y_skip_top
;
352 if (pix
->width
> 1280)
354 pix
->width
&= ~0x01; /* has to be even, unsure why was ~3 */
359 static int mt9m001_get_chip_id(struct soc_camera_device
*icd
,
360 struct v4l2_dbg_chip_ident
*id
)
362 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
364 if (id
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
)
367 if (id
->match
.addr
!= mt9m001
->client
->addr
)
370 id
->ident
= mt9m001
->model
;
376 #ifdef CONFIG_VIDEO_ADV_DEBUG
377 static int mt9m001_get_register(struct soc_camera_device
*icd
,
378 struct v4l2_dbg_register
*reg
)
380 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
382 if (reg
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
|| reg
->reg
> 0xff)
385 if (reg
->match
.addr
!= mt9m001
->client
->addr
)
389 reg
->val
= reg_read(icd
, reg
->reg
);
391 if (reg
->val
> 0xffff)
397 static int mt9m001_set_register(struct soc_camera_device
*icd
,
398 struct v4l2_dbg_register
*reg
)
400 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
402 if (reg
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
|| reg
->reg
> 0xff)
405 if (reg
->match
.addr
!= mt9m001
->client
->addr
)
408 if (reg_write(icd
, reg
->reg
, reg
->val
) < 0)
415 static const struct v4l2_queryctrl mt9m001_controls
[] = {
417 .id
= V4L2_CID_VFLIP
,
418 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
419 .name
= "Flip Vertically",
426 .type
= V4L2_CTRL_TYPE_INTEGER
,
432 .flags
= V4L2_CTRL_FLAG_SLIDER
,
434 .id
= V4L2_CID_EXPOSURE
,
435 .type
= V4L2_CTRL_TYPE_INTEGER
,
440 .default_value
= 255,
441 .flags
= V4L2_CTRL_FLAG_SLIDER
,
443 .id
= V4L2_CID_EXPOSURE_AUTO
,
444 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
445 .name
= "Automatic Exposure",
453 static int mt9m001_video_probe(struct soc_camera_device
*);
454 static void mt9m001_video_remove(struct soc_camera_device
*);
455 static int mt9m001_get_control(struct soc_camera_device
*, struct v4l2_control
*);
456 static int mt9m001_set_control(struct soc_camera_device
*, struct v4l2_control
*);
458 static struct soc_camera_ops mt9m001_ops
= {
459 .owner
= THIS_MODULE
,
460 .probe
= mt9m001_video_probe
,
461 .remove
= mt9m001_video_remove
,
462 .init
= mt9m001_init
,
463 .release
= mt9m001_release
,
464 .start_capture
= mt9m001_start_capture
,
465 .stop_capture
= mt9m001_stop_capture
,
466 .set_crop
= mt9m001_set_crop
,
467 .set_fmt
= mt9m001_set_fmt
,
468 .try_fmt
= mt9m001_try_fmt
,
469 .set_bus_param
= mt9m001_set_bus_param
,
470 .query_bus_param
= mt9m001_query_bus_param
,
471 .controls
= mt9m001_controls
,
472 .num_controls
= ARRAY_SIZE(mt9m001_controls
),
473 .get_control
= mt9m001_get_control
,
474 .set_control
= mt9m001_set_control
,
475 .get_chip_id
= mt9m001_get_chip_id
,
476 #ifdef CONFIG_VIDEO_ADV_DEBUG
477 .get_register
= mt9m001_get_register
,
478 .set_register
= mt9m001_set_register
,
482 static int mt9m001_get_control(struct soc_camera_device
*icd
, struct v4l2_control
*ctrl
)
484 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
489 data
= reg_read(icd
, MT9M001_READ_OPTIONS2
);
492 ctrl
->value
= !!(data
& 0x8000);
494 case V4L2_CID_EXPOSURE_AUTO
:
495 ctrl
->value
= mt9m001
->autoexposure
;
501 static int mt9m001_set_control(struct soc_camera_device
*icd
, struct v4l2_control
*ctrl
)
503 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
504 const struct v4l2_queryctrl
*qctrl
;
507 qctrl
= soc_camera_find_qctrl(&mt9m001_ops
, ctrl
->id
);
515 data
= reg_set(icd
, MT9M001_READ_OPTIONS2
, 0x8000);
517 data
= reg_clear(icd
, MT9M001_READ_OPTIONS2
, 0x8000);
522 if (ctrl
->value
> qctrl
->maximum
|| ctrl
->value
< qctrl
->minimum
)
524 /* See Datasheet Table 7, Gain settings. */
525 if (ctrl
->value
<= qctrl
->default_value
) {
526 /* Pack it into 0..1 step 0.125, register values 0..8 */
527 unsigned long range
= qctrl
->default_value
- qctrl
->minimum
;
528 data
= ((ctrl
->value
- qctrl
->minimum
) * 8 + range
/ 2) / range
;
530 dev_dbg(&icd
->dev
, "Setting gain %d\n", data
);
531 data
= reg_write(icd
, MT9M001_GLOBAL_GAIN
, data
);
535 /* Pack it into 1.125..15 variable step, register values 9..67 */
536 /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
537 unsigned long range
= qctrl
->maximum
- qctrl
->default_value
- 1;
538 unsigned long gain
= ((ctrl
->value
- qctrl
->default_value
- 1) *
539 111 + range
/ 2) / range
+ 9;
544 data
= ((gain
- 32) * 16 + 16) / 32 + 80;
546 data
= ((gain
- 64) * 7 + 28) / 56 + 96;
548 dev_dbg(&icd
->dev
, "Setting gain from %d to %d\n",
549 reg_read(icd
, MT9M001_GLOBAL_GAIN
), data
);
550 data
= reg_write(icd
, MT9M001_GLOBAL_GAIN
, data
);
556 icd
->gain
= ctrl
->value
;
558 case V4L2_CID_EXPOSURE
:
559 /* mt9m001 has maximum == default */
560 if (ctrl
->value
> qctrl
->maximum
|| ctrl
->value
< qctrl
->minimum
)
563 unsigned long range
= qctrl
->maximum
- qctrl
->minimum
;
564 unsigned long shutter
= ((ctrl
->value
- qctrl
->minimum
) * 1048 +
565 range
/ 2) / range
+ 1;
567 dev_dbg(&icd
->dev
, "Setting shutter width from %d to %lu\n",
568 reg_read(icd
, MT9M001_SHUTTER_WIDTH
), shutter
);
569 if (reg_write(icd
, MT9M001_SHUTTER_WIDTH
, shutter
) < 0)
571 icd
->exposure
= ctrl
->value
;
572 mt9m001
->autoexposure
= 0;
575 case V4L2_CID_EXPOSURE_AUTO
:
577 const u16 vblank
= 25;
578 if (reg_write(icd
, MT9M001_SHUTTER_WIDTH
, icd
->height
+
579 icd
->y_skip_top
+ vblank
) < 0)
581 qctrl
= soc_camera_find_qctrl(icd
->ops
, V4L2_CID_EXPOSURE
);
582 icd
->exposure
= (524 + (icd
->height
+ icd
->y_skip_top
+ vblank
- 1) *
583 (qctrl
->maximum
- qctrl
->minimum
)) /
584 1048 + qctrl
->minimum
;
585 mt9m001
->autoexposure
= 1;
587 mt9m001
->autoexposure
= 0;
593 /* Interface active, can use i2c. If it fails, it can indeed mean, that
594 * this wasn't our capture interface, so, we wait for the right one */
595 static int mt9m001_video_probe(struct soc_camera_device
*icd
)
597 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
598 struct soc_camera_link
*icl
= mt9m001
->client
->dev
.platform_data
;
602 /* We must have a parent by now. And it cannot be a wrong one.
603 * So this entire test is completely redundant. */
604 if (!icd
->dev
.parent
||
605 to_soc_camera_host(icd
->dev
.parent
)->nr
!= icd
->iface
)
608 /* Enable the chip */
609 data
= reg_write(icd
, MT9M001_CHIP_ENABLE
, 1);
610 dev_dbg(&icd
->dev
, "write: %d\n", data
);
612 /* Read out the chip version register */
613 data
= reg_read(icd
, MT9M001_CHIP_VERSION
);
615 /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
619 mt9m001
->model
= V4L2_IDENT_MT9M001C12ST
;
620 icd
->formats
= mt9m001_colour_formats
;
621 if (gpio_is_valid(icl
->gpio
))
622 icd
->num_formats
= ARRAY_SIZE(mt9m001_colour_formats
);
624 icd
->num_formats
= 1;
627 mt9m001
->model
= V4L2_IDENT_MT9M001C12STM
;
628 icd
->formats
= mt9m001_monochrome_formats
;
629 if (gpio_is_valid(icl
->gpio
))
630 icd
->num_formats
= ARRAY_SIZE(mt9m001_monochrome_formats
);
632 icd
->num_formats
= 1;
637 "No MT9M001 chip detected, register read %x\n", data
);
641 dev_info(&icd
->dev
, "Detected a MT9M001 chip ID %x (%s)\n", data
,
642 data
== 0x8431 ? "C12STM" : "C12ST");
644 /* Now that we know the model, we can start video */
645 ret
= soc_camera_video_start(icd
);
656 static void mt9m001_video_remove(struct soc_camera_device
*icd
)
658 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
660 dev_dbg(&icd
->dev
, "Video %x removed: %p, %p\n", mt9m001
->client
->addr
,
661 icd
->dev
.parent
, icd
->vdev
);
662 soc_camera_video_stop(icd
);
665 static int mt9m001_probe(struct i2c_client
*client
,
666 const struct i2c_device_id
*did
)
668 struct mt9m001
*mt9m001
;
669 struct soc_camera_device
*icd
;
670 struct i2c_adapter
*adapter
= to_i2c_adapter(client
->dev
.parent
);
671 struct soc_camera_link
*icl
= client
->dev
.platform_data
;
675 dev_err(&client
->dev
, "MT9M001 driver needs platform data\n");
679 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
680 dev_warn(&adapter
->dev
,
681 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
685 mt9m001
= kzalloc(sizeof(struct mt9m001
), GFP_KERNEL
);
689 mt9m001
->client
= client
;
690 i2c_set_clientdata(client
, mt9m001
);
692 /* Second stage probe - when a capture adapter is there */
694 icd
->ops
= &mt9m001_ops
;
695 icd
->control
= &client
->dev
;
701 icd
->width_max
= 1280;
702 icd
->height_min
= 32;
703 icd
->height_max
= 1024;
705 icd
->iface
= icl
->bus_id
;
706 /* Default datawidth - this is the only width this camera (normally)
707 * supports. It is only with extra logic that it can support
708 * other widths. Therefore it seems to be a sensible default. */
709 mt9m001
->datawidth
= 10;
710 /* Simulated autoexposure. If enabled, we calculate shutter width
711 * ourselves in the driver based on vertical blanking and frame width */
712 mt9m001
->autoexposure
= 1;
714 ret
= bus_switch_request(mt9m001
, icl
);
718 ret
= soc_camera_device_register(icd
);
725 bus_switch_release(mt9m001
);
731 static int mt9m001_remove(struct i2c_client
*client
)
733 struct mt9m001
*mt9m001
= i2c_get_clientdata(client
);
735 soc_camera_device_unregister(&mt9m001
->icd
);
736 bus_switch_release(mt9m001
);
742 static const struct i2c_device_id mt9m001_id
[] = {
746 MODULE_DEVICE_TABLE(i2c
, mt9m001_id
);
748 static struct i2c_driver mt9m001_i2c_driver
= {
752 .probe
= mt9m001_probe
,
753 .remove
= mt9m001_remove
,
754 .id_table
= mt9m001_id
,
757 static int __init
mt9m001_mod_init(void)
759 return i2c_add_driver(&mt9m001_i2c_driver
);
762 static void __exit
mt9m001_mod_exit(void)
764 i2c_del_driver(&mt9m001_i2c_driver
);
767 module_init(mt9m001_mod_init
);
768 module_exit(mt9m001_mod_exit
);
770 MODULE_DESCRIPTION("Micron MT9M001 Camera driver");
771 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
772 MODULE_LICENSE("GPL");