2 * Driver for MT9V022 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/delay.h>
15 #include <linux/log2.h>
17 #include <media/v4l2-common.h>
18 #include <media/v4l2-chip-ident.h>
19 #include <media/soc_camera.h>
21 /* mt9v022 i2c address 0x48, 0x4c, 0x58, 0x5c
22 * The platform has to define i2c_board_info
23 * and call i2c_register_board_info() */
25 static char *sensor_type
;
26 module_param(sensor_type
, charp
, S_IRUGO
);
27 MODULE_PARM_DESC(sensor_type
, "Sensor type: \"colour\" or \"monochrome\"");
29 /* mt9v022 selected register addresses */
30 #define MT9V022_CHIP_VERSION 0x00
31 #define MT9V022_COLUMN_START 0x01
32 #define MT9V022_ROW_START 0x02
33 #define MT9V022_WINDOW_HEIGHT 0x03
34 #define MT9V022_WINDOW_WIDTH 0x04
35 #define MT9V022_HORIZONTAL_BLANKING 0x05
36 #define MT9V022_VERTICAL_BLANKING 0x06
37 #define MT9V022_CHIP_CONTROL 0x07
38 #define MT9V022_SHUTTER_WIDTH1 0x08
39 #define MT9V022_SHUTTER_WIDTH2 0x09
40 #define MT9V022_SHUTTER_WIDTH_CTRL 0x0a
41 #define MT9V022_TOTAL_SHUTTER_WIDTH 0x0b
42 #define MT9V022_RESET 0x0c
43 #define MT9V022_READ_MODE 0x0d
44 #define MT9V022_MONITOR_MODE 0x0e
45 #define MT9V022_PIXEL_OPERATION_MODE 0x0f
46 #define MT9V022_LED_OUT_CONTROL 0x1b
47 #define MT9V022_ADC_MODE_CONTROL 0x1c
48 #define MT9V022_ANALOG_GAIN 0x34
49 #define MT9V022_BLACK_LEVEL_CALIB_CTRL 0x47
50 #define MT9V022_PIXCLK_FV_LV 0x74
51 #define MT9V022_DIGITAL_TEST_PATTERN 0x7f
52 #define MT9V022_AEC_AGC_ENABLE 0xAF
53 #define MT9V022_MAX_TOTAL_SHUTTER_WIDTH 0xBD
55 /* Progressive scan, master, defaults */
56 #define MT9V022_CHIP_CONTROL_DEFAULT 0x188
58 static const struct soc_camera_data_format mt9v022_colour_formats
[] = {
59 /* Order important: first natively supported,
60 * second supported with a GPIO extender */
62 .name
= "Bayer (sRGB) 10 bit",
64 .fourcc
= V4L2_PIX_FMT_SBGGR16
,
65 .colorspace
= V4L2_COLORSPACE_SRGB
,
67 .name
= "Bayer (sRGB) 8 bit",
69 .fourcc
= V4L2_PIX_FMT_SBGGR8
,
70 .colorspace
= V4L2_COLORSPACE_SRGB
,
74 static const struct soc_camera_data_format mt9v022_monochrome_formats
[] = {
75 /* Order important - see above */
77 .name
= "Monochrome 10 bit",
79 .fourcc
= V4L2_PIX_FMT_Y16
,
81 .name
= "Monochrome 8 bit",
83 .fourcc
= V4L2_PIX_FMT_GREY
,
88 struct i2c_client
*client
;
89 struct soc_camera_device icd
;
90 int model
; /* V4L2_IDENT_MT9V022* codes from v4l2-chip-ident.h */
94 static int reg_read(struct i2c_client
*client
, const u8 reg
)
96 s32 data
= i2c_smbus_read_word_data(client
, reg
);
97 return data
< 0 ? data
: swab16(data
);
100 static int reg_write(struct i2c_client
*client
, const u8 reg
,
103 return i2c_smbus_write_word_data(client
, reg
, swab16(data
));
106 static int reg_set(struct i2c_client
*client
, const u8 reg
,
111 ret
= reg_read(client
, reg
);
114 return reg_write(client
, reg
, ret
| data
);
117 static int reg_clear(struct i2c_client
*client
, const u8 reg
,
122 ret
= reg_read(client
, reg
);
125 return reg_write(client
, reg
, ret
& ~data
);
128 static int mt9v022_init(struct soc_camera_device
*icd
)
130 struct i2c_client
*client
= to_i2c_client(icd
->control
);
131 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
132 struct soc_camera_link
*icl
= client
->dev
.platform_data
;
136 ret
= icl
->power(&client
->dev
, 1);
138 dev_err(icd
->vdev
->parent
,
139 "Platform failed to power-on the camera.\n");
145 * The camera could have been already on, we hard-reset it additionally,
146 * if available. Soft reset is done in video_probe().
149 icl
->reset(&client
->dev
);
151 /* Almost the default mode: master, parallel, simultaneous, and an
152 * undocumented bit 0x200, which is present in table 7, but not in 8,
153 * plus snapshot mode to disable scan for now */
154 mt9v022
->chip_control
|= 0x10;
155 ret
= reg_write(client
, MT9V022_CHIP_CONTROL
, mt9v022
->chip_control
);
157 ret
= reg_write(client
, MT9V022_READ_MODE
, 0x300);
162 ret
= reg_set(client
, MT9V022_AEC_AGC_ENABLE
, 0x3);
164 ret
= reg_write(client
, MT9V022_MAX_TOTAL_SHUTTER_WIDTH
, 480);
167 ret
= reg_clear(client
, MT9V022_BLACK_LEVEL_CALIB_CTRL
, 1);
169 ret
= reg_write(client
, MT9V022_DIGITAL_TEST_PATTERN
, 0);
174 static int mt9v022_release(struct soc_camera_device
*icd
)
176 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
177 struct soc_camera_link
*icl
= mt9v022
->client
->dev
.platform_data
;
180 icl
->power(&mt9v022
->client
->dev
, 0);
185 static int mt9v022_start_capture(struct soc_camera_device
*icd
)
187 struct i2c_client
*client
= to_i2c_client(icd
->control
);
188 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
189 /* Switch to master "normal" mode */
190 mt9v022
->chip_control
&= ~0x10;
191 if (reg_write(client
, MT9V022_CHIP_CONTROL
,
192 mt9v022
->chip_control
) < 0)
197 static int mt9v022_stop_capture(struct soc_camera_device
*icd
)
199 struct i2c_client
*client
= to_i2c_client(icd
->control
);
200 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
201 /* Switch to snapshot mode */
202 mt9v022
->chip_control
|= 0x10;
203 if (reg_write(client
, MT9V022_CHIP_CONTROL
,
204 mt9v022
->chip_control
) < 0)
209 static int mt9v022_set_bus_param(struct soc_camera_device
*icd
,
212 struct i2c_client
*client
= to_i2c_client(icd
->control
);
213 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
214 struct soc_camera_link
*icl
= client
->dev
.platform_data
;
215 unsigned int width_flag
= flags
& SOCAM_DATAWIDTH_MASK
;
219 /* Only one width bit may be set */
220 if (!is_power_of_2(width_flag
))
223 if (icl
->set_bus_param
) {
224 ret
= icl
->set_bus_param(icl
, width_flag
);
229 * Without board specific bus width settings we only support the
230 * sensors native bus width
232 if (width_flag
!= SOCAM_DATAWIDTH_10
)
236 flags
= soc_camera_apply_sensor_flags(icl
, flags
);
238 if (flags
& SOCAM_PCLK_SAMPLE_RISING
)
241 if (!(flags
& SOCAM_HSYNC_ACTIVE_HIGH
))
244 if (!(flags
& SOCAM_VSYNC_ACTIVE_HIGH
))
247 ret
= reg_write(client
, MT9V022_PIXCLK_FV_LV
, pixclk
);
251 if (!(flags
& SOCAM_MASTER
))
252 mt9v022
->chip_control
&= ~0x8;
254 ret
= reg_write(client
, MT9V022_CHIP_CONTROL
, mt9v022
->chip_control
);
258 dev_dbg(&icd
->dev
, "Calculated pixclk 0x%x, chip control 0x%x\n",
259 pixclk
, mt9v022
->chip_control
);
264 static unsigned long mt9v022_query_bus_param(struct soc_camera_device
*icd
)
266 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
267 struct soc_camera_link
*icl
= mt9v022
->client
->dev
.platform_data
;
268 unsigned int width_flag
;
270 if (icl
->query_bus_param
)
271 width_flag
= icl
->query_bus_param(icl
) &
272 SOCAM_DATAWIDTH_MASK
;
274 width_flag
= SOCAM_DATAWIDTH_10
;
276 return SOCAM_PCLK_SAMPLE_RISING
| SOCAM_PCLK_SAMPLE_FALLING
|
277 SOCAM_HSYNC_ACTIVE_HIGH
| SOCAM_HSYNC_ACTIVE_LOW
|
278 SOCAM_VSYNC_ACTIVE_HIGH
| SOCAM_VSYNC_ACTIVE_LOW
|
279 SOCAM_DATA_ACTIVE_HIGH
| SOCAM_MASTER
| SOCAM_SLAVE
|
283 static int mt9v022_set_crop(struct soc_camera_device
*icd
,
284 struct v4l2_rect
*rect
)
286 struct i2c_client
*client
= to_i2c_client(icd
->control
);
289 /* Like in example app. Contradicts the datasheet though */
290 ret
= reg_read(client
, MT9V022_AEC_AGC_ENABLE
);
292 if (ret
& 1) /* Autoexposure */
293 ret
= reg_write(client
, MT9V022_MAX_TOTAL_SHUTTER_WIDTH
,
294 rect
->height
+ icd
->y_skip_top
+ 43);
296 ret
= reg_write(client
, MT9V022_TOTAL_SHUTTER_WIDTH
,
297 rect
->height
+ icd
->y_skip_top
+ 43);
299 /* Setup frame format: defaults apart from width and height */
301 ret
= reg_write(client
, MT9V022_COLUMN_START
, rect
->left
);
303 ret
= reg_write(client
, MT9V022_ROW_START
, rect
->top
);
305 /* Default 94, Phytec driver says:
306 * "width + horizontal blank >= 660" */
307 ret
= reg_write(client
, MT9V022_HORIZONTAL_BLANKING
,
308 rect
->width
> 660 - 43 ? 43 :
311 ret
= reg_write(client
, MT9V022_VERTICAL_BLANKING
, 45);
313 ret
= reg_write(client
, MT9V022_WINDOW_WIDTH
, rect
->width
);
315 ret
= reg_write(client
, MT9V022_WINDOW_HEIGHT
,
316 rect
->height
+ icd
->y_skip_top
);
321 dev_dbg(&icd
->dev
, "Frame %ux%u pixel\n", rect
->width
, rect
->height
);
326 static int mt9v022_set_fmt(struct soc_camera_device
*icd
,
327 struct v4l2_format
*f
)
329 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
330 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
331 struct v4l2_rect rect
= {
332 .left
= icd
->x_current
,
333 .top
= icd
->y_current
,
335 .height
= pix
->height
,
338 /* The caller provides a supported format, as verified per call to
339 * icd->try_fmt(), datawidth is from our supported format list */
340 switch (pix
->pixelformat
) {
341 case V4L2_PIX_FMT_GREY
:
342 case V4L2_PIX_FMT_Y16
:
343 if (mt9v022
->model
!= V4L2_IDENT_MT9V022IX7ATM
)
346 case V4L2_PIX_FMT_SBGGR8
:
347 case V4L2_PIX_FMT_SBGGR16
:
348 if (mt9v022
->model
!= V4L2_IDENT_MT9V022IX7ATC
)
352 /* No format change, only geometry */
358 /* No support for scaling on this camera, just crop. */
359 return mt9v022_set_crop(icd
, &rect
);
362 static int mt9v022_try_fmt(struct soc_camera_device
*icd
,
363 struct v4l2_format
*f
)
365 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
367 if (pix
->height
< 32 + icd
->y_skip_top
)
368 pix
->height
= 32 + icd
->y_skip_top
;
369 if (pix
->height
> 480 + icd
->y_skip_top
)
370 pix
->height
= 480 + icd
->y_skip_top
;
373 if (pix
->width
> 752)
375 pix
->width
&= ~0x03; /* ? */
380 static int mt9v022_get_chip_id(struct soc_camera_device
*icd
,
381 struct v4l2_dbg_chip_ident
*id
)
383 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
385 if (id
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
)
388 if (id
->match
.addr
!= mt9v022
->client
->addr
)
391 id
->ident
= mt9v022
->model
;
397 #ifdef CONFIG_VIDEO_ADV_DEBUG
398 static int mt9v022_get_register(struct soc_camera_device
*icd
,
399 struct v4l2_dbg_register
*reg
)
401 struct i2c_client
*client
= to_i2c_client(icd
->control
);
403 if (reg
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
|| reg
->reg
> 0xff)
406 if (reg
->match
.addr
!= client
->addr
)
410 reg
->val
= reg_read(client
, reg
->reg
);
412 if (reg
->val
> 0xffff)
418 static int mt9v022_set_register(struct soc_camera_device
*icd
,
419 struct v4l2_dbg_register
*reg
)
421 struct i2c_client
*client
= to_i2c_client(icd
->control
);
423 if (reg
->match
.type
!= V4L2_CHIP_MATCH_I2C_ADDR
|| reg
->reg
> 0xff)
426 if (reg
->match
.addr
!= client
->addr
)
429 if (reg_write(client
, reg
->reg
, reg
->val
) < 0)
436 static const struct v4l2_queryctrl mt9v022_controls
[] = {
438 .id
= V4L2_CID_VFLIP
,
439 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
440 .name
= "Flip Vertically",
446 .id
= V4L2_CID_HFLIP
,
447 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
448 .name
= "Flip Horizontally",
455 .type
= V4L2_CTRL_TYPE_INTEGER
,
456 .name
= "Analog Gain",
461 .flags
= V4L2_CTRL_FLAG_SLIDER
,
463 .id
= V4L2_CID_EXPOSURE
,
464 .type
= V4L2_CTRL_TYPE_INTEGER
,
469 .default_value
= 255,
470 .flags
= V4L2_CTRL_FLAG_SLIDER
,
472 .id
= V4L2_CID_AUTOGAIN
,
473 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
474 .name
= "Automatic Gain",
480 .id
= V4L2_CID_EXPOSURE_AUTO
,
481 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
482 .name
= "Automatic Exposure",
490 static int mt9v022_video_probe(struct soc_camera_device
*);
491 static void mt9v022_video_remove(struct soc_camera_device
*);
492 static int mt9v022_get_control(struct soc_camera_device
*, struct v4l2_control
*);
493 static int mt9v022_set_control(struct soc_camera_device
*, struct v4l2_control
*);
495 static struct soc_camera_ops mt9v022_ops
= {
496 .owner
= THIS_MODULE
,
497 .probe
= mt9v022_video_probe
,
498 .remove
= mt9v022_video_remove
,
499 .init
= mt9v022_init
,
500 .release
= mt9v022_release
,
501 .start_capture
= mt9v022_start_capture
,
502 .stop_capture
= mt9v022_stop_capture
,
503 .set_crop
= mt9v022_set_crop
,
504 .set_fmt
= mt9v022_set_fmt
,
505 .try_fmt
= mt9v022_try_fmt
,
506 .set_bus_param
= mt9v022_set_bus_param
,
507 .query_bus_param
= mt9v022_query_bus_param
,
508 .controls
= mt9v022_controls
,
509 .num_controls
= ARRAY_SIZE(mt9v022_controls
),
510 .get_control
= mt9v022_get_control
,
511 .set_control
= mt9v022_set_control
,
512 .get_chip_id
= mt9v022_get_chip_id
,
513 #ifdef CONFIG_VIDEO_ADV_DEBUG
514 .get_register
= mt9v022_get_register
,
515 .set_register
= mt9v022_set_register
,
519 static int mt9v022_get_control(struct soc_camera_device
*icd
,
520 struct v4l2_control
*ctrl
)
522 struct i2c_client
*client
= to_i2c_client(icd
->control
);
527 data
= reg_read(client
, MT9V022_READ_MODE
);
530 ctrl
->value
= !!(data
& 0x10);
533 data
= reg_read(client
, MT9V022_READ_MODE
);
536 ctrl
->value
= !!(data
& 0x20);
538 case V4L2_CID_EXPOSURE_AUTO
:
539 data
= reg_read(client
, MT9V022_AEC_AGC_ENABLE
);
542 ctrl
->value
= !!(data
& 0x1);
544 case V4L2_CID_AUTOGAIN
:
545 data
= reg_read(client
, MT9V022_AEC_AGC_ENABLE
);
548 ctrl
->value
= !!(data
& 0x2);
554 static int mt9v022_set_control(struct soc_camera_device
*icd
,
555 struct v4l2_control
*ctrl
)
558 struct i2c_client
*client
= to_i2c_client(icd
->control
);
559 const struct v4l2_queryctrl
*qctrl
;
561 qctrl
= soc_camera_find_qctrl(&mt9v022_ops
, ctrl
->id
);
569 data
= reg_set(client
, MT9V022_READ_MODE
, 0x10);
571 data
= reg_clear(client
, MT9V022_READ_MODE
, 0x10);
577 data
= reg_set(client
, MT9V022_READ_MODE
, 0x20);
579 data
= reg_clear(client
, MT9V022_READ_MODE
, 0x20);
584 /* mt9v022 has minimum == default */
585 if (ctrl
->value
> qctrl
->maximum
|| ctrl
->value
< qctrl
->minimum
)
588 unsigned long range
= qctrl
->maximum
- qctrl
->minimum
;
589 /* Datasheet says 16 to 64. autogain only works properly
590 * after setting gain to maximum 14. Larger values
591 * produce "white fly" noise effect. On the whole,
592 * manually setting analog gain does no good. */
593 unsigned long gain
= ((ctrl
->value
- qctrl
->minimum
) *
594 10 + range
/ 2) / range
+ 4;
597 /* The user wants to set gain manually, hope, she
598 * knows, what she's doing... Switch AGC off. */
600 if (reg_clear(client
, MT9V022_AEC_AGC_ENABLE
, 0x2) < 0)
603 dev_info(&icd
->dev
, "Setting gain from %d to %lu\n",
604 reg_read(client
, MT9V022_ANALOG_GAIN
), gain
);
605 if (reg_write(client
, MT9V022_ANALOG_GAIN
, gain
) < 0)
607 icd
->gain
= ctrl
->value
;
610 case V4L2_CID_EXPOSURE
:
611 /* mt9v022 has maximum == default */
612 if (ctrl
->value
> qctrl
->maximum
|| ctrl
->value
< qctrl
->minimum
)
615 unsigned long range
= qctrl
->maximum
- qctrl
->minimum
;
616 unsigned long shutter
= ((ctrl
->value
- qctrl
->minimum
) *
617 479 + range
/ 2) / range
+ 1;
618 /* The user wants to set shutter width manually, hope,
619 * she knows, what she's doing... Switch AEC off. */
621 if (reg_clear(client
, MT9V022_AEC_AGC_ENABLE
, 0x1) < 0)
624 dev_dbg(&icd
->dev
, "Shutter width from %d to %lu\n",
625 reg_read(client
, MT9V022_TOTAL_SHUTTER_WIDTH
),
627 if (reg_write(client
, MT9V022_TOTAL_SHUTTER_WIDTH
,
630 icd
->exposure
= ctrl
->value
;
633 case V4L2_CID_AUTOGAIN
:
635 data
= reg_set(client
, MT9V022_AEC_AGC_ENABLE
, 0x2);
637 data
= reg_clear(client
, MT9V022_AEC_AGC_ENABLE
, 0x2);
641 case V4L2_CID_EXPOSURE_AUTO
:
643 data
= reg_set(client
, MT9V022_AEC_AGC_ENABLE
, 0x1);
645 data
= reg_clear(client
, MT9V022_AEC_AGC_ENABLE
, 0x1);
653 /* Interface active, can use i2c. If it fails, it can indeed mean, that
654 * this wasn't our capture interface, so, we wait for the right one */
655 static int mt9v022_video_probe(struct soc_camera_device
*icd
)
657 struct i2c_client
*client
= to_i2c_client(icd
->control
);
658 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
659 struct soc_camera_link
*icl
= client
->dev
.platform_data
;
664 if (!icd
->dev
.parent
||
665 to_soc_camera_host(icd
->dev
.parent
)->nr
!= icd
->iface
)
668 /* Read out the chip version register */
669 data
= reg_read(client
, MT9V022_CHIP_VERSION
);
671 /* must be 0x1311 or 0x1313 */
672 if (data
!= 0x1311 && data
!= 0x1313) {
674 dev_info(&icd
->dev
, "No MT9V022 detected, ID register 0x%x\n",
680 ret
= reg_write(client
, MT9V022_RESET
, 1);
683 /* 15 clock cycles */
685 if (reg_read(client
, MT9V022_RESET
)) {
686 dev_err(&icd
->dev
, "Resetting MT9V022 failed!\n");
690 /* Set monochrome or colour sensor type */
691 if (sensor_type
&& (!strcmp("colour", sensor_type
) ||
692 !strcmp("color", sensor_type
))) {
693 ret
= reg_write(client
, MT9V022_PIXEL_OPERATION_MODE
, 4 | 0x11);
694 mt9v022
->model
= V4L2_IDENT_MT9V022IX7ATC
;
695 icd
->formats
= mt9v022_colour_formats
;
697 ret
= reg_write(client
, MT9V022_PIXEL_OPERATION_MODE
, 0x11);
698 mt9v022
->model
= V4L2_IDENT_MT9V022IX7ATM
;
699 icd
->formats
= mt9v022_monochrome_formats
;
705 icd
->num_formats
= 0;
708 * This is a 10bit sensor, so by default we only allow 10bit.
709 * The platform may support different bus widths due to
710 * different routing of the data lines.
712 if (icl
->query_bus_param
)
713 flags
= icl
->query_bus_param(icl
);
715 flags
= SOCAM_DATAWIDTH_10
;
717 if (flags
& SOCAM_DATAWIDTH_10
)
722 if (flags
& SOCAM_DATAWIDTH_8
)
725 ret
= soc_camera_video_start(icd
);
729 dev_info(&icd
->dev
, "Detected a MT9V022 chip ID %x, %s sensor\n",
730 data
, mt9v022
->model
== V4L2_IDENT_MT9V022IX7ATM
?
731 "monochrome" : "colour");
740 static void mt9v022_video_remove(struct soc_camera_device
*icd
)
742 struct mt9v022
*mt9v022
= container_of(icd
, struct mt9v022
, icd
);
743 struct soc_camera_link
*icl
= mt9v022
->client
->dev
.platform_data
;
745 dev_dbg(&icd
->dev
, "Video %x removed: %p, %p\n", mt9v022
->client
->addr
,
746 icd
->dev
.parent
, icd
->vdev
);
747 soc_camera_video_stop(icd
);
752 static int mt9v022_probe(struct i2c_client
*client
,
753 const struct i2c_device_id
*did
)
755 struct mt9v022
*mt9v022
;
756 struct soc_camera_device
*icd
;
757 struct i2c_adapter
*adapter
= to_i2c_adapter(client
->dev
.parent
);
758 struct soc_camera_link
*icl
= client
->dev
.platform_data
;
762 dev_err(&client
->dev
, "MT9V022 driver needs platform data\n");
766 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
767 dev_warn(&adapter
->dev
,
768 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
772 mt9v022
= kzalloc(sizeof(struct mt9v022
), GFP_KERNEL
);
776 mt9v022
->chip_control
= MT9V022_CHIP_CONTROL_DEFAULT
;
777 mt9v022
->client
= client
;
778 i2c_set_clientdata(client
, mt9v022
);
781 icd
->ops
= &mt9v022_ops
;
782 icd
->control
= &client
->dev
;
788 icd
->width_max
= 752;
789 icd
->height_min
= 32;
790 icd
->height_max
= 480;
792 icd
->iface
= icl
->bus_id
;
794 ret
= soc_camera_device_register(icd
);
805 static int mt9v022_remove(struct i2c_client
*client
)
807 struct mt9v022
*mt9v022
= i2c_get_clientdata(client
);
809 soc_camera_device_unregister(&mt9v022
->icd
);
814 static const struct i2c_device_id mt9v022_id
[] = {
818 MODULE_DEVICE_TABLE(i2c
, mt9v022_id
);
820 static struct i2c_driver mt9v022_i2c_driver
= {
824 .probe
= mt9v022_probe
,
825 .remove
= mt9v022_remove
,
826 .id_table
= mt9v022_id
,
829 static int __init
mt9v022_mod_init(void)
831 return i2c_add_driver(&mt9v022_i2c_driver
);
834 static void __exit
mt9v022_mod_exit(void)
836 i2c_del_driver(&mt9v022_i2c_driver
);
839 module_init(mt9v022_mod_init
);
840 module_exit(mt9v022_mod_exit
);
842 MODULE_DESCRIPTION("Micron MT9V022 Camera driver");
843 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
844 MODULE_LICENSE("GPL");