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>
16 #include <media/v4l2-common.h>
17 #include <media/v4l2-chip-ident.h>
18 #include <media/soc_camera.h>
20 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
24 /* mt9m001 i2c address 0x5d
25 * The platform has to define i2c_board_info
26 * and call i2c_register_board_info() */
28 /* mt9m001 selected register addresses */
29 #define MT9M001_CHIP_VERSION 0x00
30 #define MT9M001_ROW_START 0x01
31 #define MT9M001_COLUMN_START 0x02
32 #define MT9M001_WINDOW_HEIGHT 0x03
33 #define MT9M001_WINDOW_WIDTH 0x04
34 #define MT9M001_HORIZONTAL_BLANKING 0x05
35 #define MT9M001_VERTICAL_BLANKING 0x06
36 #define MT9M001_OUTPUT_CONTROL 0x07
37 #define MT9M001_SHUTTER_WIDTH 0x09
38 #define MT9M001_FRAME_RESTART 0x0b
39 #define MT9M001_SHUTTER_DELAY 0x0c
40 #define MT9M001_RESET 0x0d
41 #define MT9M001_READ_OPTIONS1 0x1e
42 #define MT9M001_READ_OPTIONS2 0x20
43 #define MT9M001_GLOBAL_GAIN 0x35
44 #define MT9M001_CHIP_ENABLE 0xF1
46 static const struct soc_camera_data_format mt9m001_colour_formats
[] = {
47 /* Order important: first natively supported,
48 * second supported with a GPIO extender */
50 .name
= "Bayer (sRGB) 10 bit",
52 .fourcc
= V4L2_PIX_FMT_SBGGR16
,
53 .colorspace
= V4L2_COLORSPACE_SRGB
,
55 .name
= "Bayer (sRGB) 8 bit",
57 .fourcc
= V4L2_PIX_FMT_SBGGR8
,
58 .colorspace
= V4L2_COLORSPACE_SRGB
,
62 static const struct soc_camera_data_format mt9m001_monochrome_formats
[] = {
63 /* Order important - see above */
65 .name
= "Monochrome 10 bit",
67 .fourcc
= V4L2_PIX_FMT_Y16
,
69 .name
= "Monochrome 8 bit",
71 .fourcc
= V4L2_PIX_FMT_GREY
,
76 struct i2c_client
*client
;
77 struct soc_camera_device icd
;
78 int model
; /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */
80 unsigned char autoexposure
;
81 unsigned char datawidth
;
84 static int reg_read(struct soc_camera_device
*icd
, const u8 reg
)
86 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
87 struct i2c_client
*client
= mt9m001
->client
;
88 s32 data
= i2c_smbus_read_word_data(client
, reg
);
89 return data
< 0 ? data
: swab16(data
);
92 static int reg_write(struct soc_camera_device
*icd
, const u8 reg
,
95 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
96 return i2c_smbus_write_word_data(mt9m001
->client
, reg
, swab16(data
));
99 static int reg_set(struct soc_camera_device
*icd
, const u8 reg
,
104 ret
= reg_read(icd
, reg
);
107 return reg_write(icd
, reg
, ret
| data
);
110 static int reg_clear(struct soc_camera_device
*icd
, const u8 reg
,
115 ret
= reg_read(icd
, reg
);
118 return reg_write(icd
, reg
, ret
& ~data
);
121 static int mt9m001_init(struct soc_camera_device
*icd
)
125 /* Disable chip, synchronous option update */
126 dev_dbg(icd
->vdev
->dev
, "%s\n", __func__
);
128 ret
= reg_write(icd
, MT9M001_RESET
, 1);
130 ret
= reg_write(icd
, MT9M001_RESET
, 0);
132 ret
= reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 0);
134 return ret
>= 0 ? 0 : -EIO
;
137 static int mt9m001_release(struct soc_camera_device
*icd
)
139 /* Disable the chip */
140 reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 0);
144 static int mt9m001_start_capture(struct soc_camera_device
*icd
)
146 /* Switch to master "normal" mode */
147 if (reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 2) < 0)
152 static int mt9m001_stop_capture(struct soc_camera_device
*icd
)
154 /* Stop sensor readout */
155 if (reg_write(icd
, MT9M001_OUTPUT_CONTROL
, 0) < 0)
160 static int bus_switch_request(struct mt9m001
*mt9m001
,
161 struct soc_camera_link
*icl
)
163 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
165 unsigned int gpio
= icl
->gpio
;
167 if (gpio_is_valid(gpio
)) {
168 /* We have a data bus switch. */
169 ret
= gpio_request(gpio
, "mt9m001");
171 dev_err(&mt9m001
->client
->dev
, "Cannot get GPIO %u\n",
176 ret
= gpio_direction_output(gpio
, 0);
178 dev_err(&mt9m001
->client
->dev
,
179 "Cannot set GPIO %u to output\n", gpio
);
185 mt9m001
->switch_gpio
= gpio
;
187 mt9m001
->switch_gpio
= -EINVAL
;
192 static void bus_switch_release(struct mt9m001
*mt9m001
)
194 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
195 if (gpio_is_valid(mt9m001
->switch_gpio
))
196 gpio_free(mt9m001
->switch_gpio
);
200 static int bus_switch_act(struct mt9m001
*mt9m001
, int go8bit
)
202 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
203 if (!gpio_is_valid(mt9m001
->switch_gpio
))
206 gpio_set_value_cansleep(mt9m001
->switch_gpio
, go8bit
);
213 static int bus_switch_possible(struct mt9m001
*mt9m001
)
215 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
216 return gpio_is_valid(mt9m001
->switch_gpio
);
222 static int mt9m001_set_bus_param(struct soc_camera_device
*icd
,
225 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
226 unsigned int width_flag
= flags
& SOCAM_DATAWIDTH_MASK
;
229 /* Flags validity verified in test_bus_param */
231 if ((mt9m001
->datawidth
!= 10 && (width_flag
== SOCAM_DATAWIDTH_10
)) ||
232 (mt9m001
->datawidth
!= 9 && (width_flag
== SOCAM_DATAWIDTH_9
)) ||
233 (mt9m001
->datawidth
!= 8 && (width_flag
== SOCAM_DATAWIDTH_8
))) {
234 /* Well, we actually only can do 10 or 8 bits... */
235 if (width_flag
== SOCAM_DATAWIDTH_9
)
237 ret
= bus_switch_act(mt9m001
,
238 width_flag
== SOCAM_DATAWIDTH_8
);
242 mt9m001
->datawidth
= width_flag
== SOCAM_DATAWIDTH_8
? 8 : 10;
248 static unsigned long mt9m001_query_bus_param(struct soc_camera_device
*icd
)
250 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
251 unsigned int width_flag
= SOCAM_DATAWIDTH_10
;
253 if (bus_switch_possible(mt9m001
))
254 width_flag
|= SOCAM_DATAWIDTH_8
;
256 /* MT9M001 has all capture_format parameters fixed */
257 return SOCAM_PCLK_SAMPLE_RISING
|
258 SOCAM_HSYNC_ACTIVE_HIGH
|
259 SOCAM_VSYNC_ACTIVE_HIGH
|
264 static int mt9m001_set_fmt_cap(struct soc_camera_device
*icd
,
265 __u32 pixfmt
, struct v4l2_rect
*rect
)
267 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
269 const u16 hblank
= 9, vblank
= 25;
271 /* Blanking and start values - default... */
272 ret
= reg_write(icd
, MT9M001_HORIZONTAL_BLANKING
, hblank
);
274 ret
= reg_write(icd
, MT9M001_VERTICAL_BLANKING
, vblank
);
276 /* The caller provides a supported format, as verified per
277 * call to icd->try_fmt_cap() */
279 ret
= reg_write(icd
, MT9M001_COLUMN_START
, rect
->left
);
281 ret
= reg_write(icd
, MT9M001_ROW_START
, rect
->top
);
283 ret
= reg_write(icd
, MT9M001_WINDOW_WIDTH
, rect
->width
- 1);
285 ret
= reg_write(icd
, MT9M001_WINDOW_HEIGHT
,
286 rect
->height
+ icd
->y_skip_top
- 1);
287 if (ret
>= 0 && mt9m001
->autoexposure
) {
288 ret
= reg_write(icd
, MT9M001_SHUTTER_WIDTH
,
289 rect
->height
+ icd
->y_skip_top
+ vblank
);
291 const struct v4l2_queryctrl
*qctrl
=
292 soc_camera_find_qctrl(icd
->ops
,
294 icd
->exposure
= (524 + (rect
->height
+ icd
->y_skip_top
+
296 (qctrl
->maximum
- qctrl
->minimum
)) /
297 1048 + qctrl
->minimum
;
301 return ret
< 0 ? ret
: 0;
304 static int mt9m001_try_fmt_cap(struct soc_camera_device
*icd
,
305 struct v4l2_format
*f
)
307 if (f
->fmt
.pix
.height
< 32 + icd
->y_skip_top
)
308 f
->fmt
.pix
.height
= 32 + icd
->y_skip_top
;
309 if (f
->fmt
.pix
.height
> 1024 + icd
->y_skip_top
)
310 f
->fmt
.pix
.height
= 1024 + icd
->y_skip_top
;
311 if (f
->fmt
.pix
.width
< 48)
312 f
->fmt
.pix
.width
= 48;
313 if (f
->fmt
.pix
.width
> 1280)
314 f
->fmt
.pix
.width
= 1280;
315 f
->fmt
.pix
.width
&= ~0x01; /* has to be even, unsure why was ~3 */
320 static int mt9m001_get_chip_id(struct soc_camera_device
*icd
,
321 struct v4l2_chip_ident
*id
)
323 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
325 if (id
->match_type
!= V4L2_CHIP_MATCH_I2C_ADDR
)
328 if (id
->match_chip
!= mt9m001
->client
->addr
)
331 id
->ident
= mt9m001
->model
;
337 #ifdef CONFIG_VIDEO_ADV_DEBUG
338 static int mt9m001_get_register(struct soc_camera_device
*icd
,
339 struct v4l2_register
*reg
)
341 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
343 if (reg
->match_type
!= V4L2_CHIP_MATCH_I2C_ADDR
|| reg
->reg
> 0xff)
346 if (reg
->match_chip
!= mt9m001
->client
->addr
)
349 reg
->val
= reg_read(icd
, reg
->reg
);
351 if (reg
->val
> 0xffff)
357 static int mt9m001_set_register(struct soc_camera_device
*icd
,
358 struct v4l2_register
*reg
)
360 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
362 if (reg
->match_type
!= V4L2_CHIP_MATCH_I2C_ADDR
|| reg
->reg
> 0xff)
365 if (reg
->match_chip
!= mt9m001
->client
->addr
)
368 if (reg_write(icd
, reg
->reg
, reg
->val
) < 0)
375 const struct v4l2_queryctrl mt9m001_controls
[] = {
377 .id
= V4L2_CID_VFLIP
,
378 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
379 .name
= "Flip Vertically",
386 .type
= V4L2_CTRL_TYPE_INTEGER
,
392 .flags
= V4L2_CTRL_FLAG_SLIDER
,
394 .id
= V4L2_CID_EXPOSURE
,
395 .type
= V4L2_CTRL_TYPE_INTEGER
,
400 .default_value
= 255,
401 .flags
= V4L2_CTRL_FLAG_SLIDER
,
403 .id
= V4L2_CID_EXPOSURE_AUTO
,
404 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
405 .name
= "Automatic Exposure",
413 static int mt9m001_video_probe(struct soc_camera_device
*);
414 static void mt9m001_video_remove(struct soc_camera_device
*);
415 static int mt9m001_get_control(struct soc_camera_device
*, struct v4l2_control
*);
416 static int mt9m001_set_control(struct soc_camera_device
*, struct v4l2_control
*);
418 static struct soc_camera_ops mt9m001_ops
= {
419 .owner
= THIS_MODULE
,
420 .probe
= mt9m001_video_probe
,
421 .remove
= mt9m001_video_remove
,
422 .init
= mt9m001_init
,
423 .release
= mt9m001_release
,
424 .start_capture
= mt9m001_start_capture
,
425 .stop_capture
= mt9m001_stop_capture
,
426 .set_fmt_cap
= mt9m001_set_fmt_cap
,
427 .try_fmt_cap
= mt9m001_try_fmt_cap
,
428 .set_bus_param
= mt9m001_set_bus_param
,
429 .query_bus_param
= mt9m001_query_bus_param
,
430 .controls
= mt9m001_controls
,
431 .num_controls
= ARRAY_SIZE(mt9m001_controls
),
432 .get_control
= mt9m001_get_control
,
433 .set_control
= mt9m001_set_control
,
434 .get_chip_id
= mt9m001_get_chip_id
,
435 #ifdef CONFIG_VIDEO_ADV_DEBUG
436 .get_register
= mt9m001_get_register
,
437 .set_register
= mt9m001_set_register
,
441 static int mt9m001_get_control(struct soc_camera_device
*icd
, struct v4l2_control
*ctrl
)
443 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
448 data
= reg_read(icd
, MT9M001_READ_OPTIONS2
);
451 ctrl
->value
= !!(data
& 0x8000);
453 case V4L2_CID_EXPOSURE_AUTO
:
454 ctrl
->value
= mt9m001
->autoexposure
;
460 static int mt9m001_set_control(struct soc_camera_device
*icd
, struct v4l2_control
*ctrl
)
462 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
463 const struct v4l2_queryctrl
*qctrl
;
466 qctrl
= soc_camera_find_qctrl(&mt9m001_ops
, ctrl
->id
);
474 data
= reg_set(icd
, MT9M001_READ_OPTIONS2
, 0x8000);
476 data
= reg_clear(icd
, MT9M001_READ_OPTIONS2
, 0x8000);
481 if (ctrl
->value
> qctrl
->maximum
|| ctrl
->value
< qctrl
->minimum
)
483 /* See Datasheet Table 7, Gain settings. */
484 if (ctrl
->value
<= qctrl
->default_value
) {
485 /* Pack it into 0..1 step 0.125, register values 0..8 */
486 unsigned long range
= qctrl
->default_value
- qctrl
->minimum
;
487 data
= ((ctrl
->value
- qctrl
->minimum
) * 8 + range
/ 2) / range
;
489 dev_dbg(&icd
->dev
, "Setting gain %d\n", data
);
490 data
= reg_write(icd
, MT9M001_GLOBAL_GAIN
, data
);
494 /* Pack it into 1.125..15 variable step, register values 9..67 */
495 /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
496 unsigned long range
= qctrl
->maximum
- qctrl
->default_value
- 1;
497 unsigned long gain
= ((ctrl
->value
- qctrl
->default_value
- 1) *
498 111 + range
/ 2) / range
+ 9;
503 data
= ((gain
- 32) * 16 + 16) / 32 + 80;
505 data
= ((gain
- 64) * 7 + 28) / 56 + 96;
507 dev_dbg(&icd
->dev
, "Setting gain from %d to %d\n",
508 reg_read(icd
, MT9M001_GLOBAL_GAIN
), data
);
509 data
= reg_write(icd
, MT9M001_GLOBAL_GAIN
, data
);
515 icd
->gain
= ctrl
->value
;
517 case V4L2_CID_EXPOSURE
:
518 /* mt9m001 has maximum == default */
519 if (ctrl
->value
> qctrl
->maximum
|| ctrl
->value
< qctrl
->minimum
)
522 unsigned long range
= qctrl
->maximum
- qctrl
->minimum
;
523 unsigned long shutter
= ((ctrl
->value
- qctrl
->minimum
) * 1048 +
524 range
/ 2) / range
+ 1;
526 dev_dbg(&icd
->dev
, "Setting shutter width from %d to %lu\n",
527 reg_read(icd
, MT9M001_SHUTTER_WIDTH
), shutter
);
528 if (reg_write(icd
, MT9M001_SHUTTER_WIDTH
, shutter
) < 0)
530 icd
->exposure
= ctrl
->value
;
531 mt9m001
->autoexposure
= 0;
534 case V4L2_CID_EXPOSURE_AUTO
:
536 const u16 vblank
= 25;
537 if (reg_write(icd
, MT9M001_SHUTTER_WIDTH
, icd
->height
+
538 icd
->y_skip_top
+ vblank
) < 0)
540 qctrl
= soc_camera_find_qctrl(icd
->ops
, V4L2_CID_EXPOSURE
);
541 icd
->exposure
= (524 + (icd
->height
+ icd
->y_skip_top
+ vblank
- 1) *
542 (qctrl
->maximum
- qctrl
->minimum
)) /
543 1048 + qctrl
->minimum
;
544 mt9m001
->autoexposure
= 1;
546 mt9m001
->autoexposure
= 0;
552 /* Interface active, can use i2c. If it fails, it can indeed mean, that
553 * this wasn't our capture interface, so, we wait for the right one */
554 static int mt9m001_video_probe(struct soc_camera_device
*icd
)
556 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
560 /* We must have a parent by now. And it cannot be a wrong one.
561 * So this entire test is completely redundant. */
562 if (!icd
->dev
.parent
||
563 to_soc_camera_host(icd
->dev
.parent
)->nr
!= icd
->iface
)
566 /* Enable the chip */
567 data
= reg_write(&mt9m001
->icd
, MT9M001_CHIP_ENABLE
, 1);
568 dev_dbg(&icd
->dev
, "write: %d\n", data
);
570 /* Read out the chip version register */
571 data
= reg_read(icd
, MT9M001_CHIP_VERSION
);
573 /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
577 mt9m001
->model
= V4L2_IDENT_MT9M001C12ST
;
578 icd
->formats
= mt9m001_colour_formats
;
579 if (mt9m001
->client
->dev
.platform_data
)
580 icd
->num_formats
= ARRAY_SIZE(mt9m001_colour_formats
);
582 icd
->num_formats
= 1;
585 mt9m001
->model
= V4L2_IDENT_MT9M001C12STM
;
586 icd
->formats
= mt9m001_monochrome_formats
;
587 if (mt9m001
->client
->dev
.platform_data
)
588 icd
->num_formats
= ARRAY_SIZE(mt9m001_monochrome_formats
);
590 icd
->num_formats
= 1;
595 "No MT9M001 chip detected, register read %x\n", data
);
599 dev_info(&icd
->dev
, "Detected a MT9M001 chip ID %x (%s)\n", data
,
600 data
== 0x8431 ? "C12STM" : "C12ST");
602 /* Now that we know the model, we can start video */
603 ret
= soc_camera_video_start(icd
);
614 static void mt9m001_video_remove(struct soc_camera_device
*icd
)
616 struct mt9m001
*mt9m001
= container_of(icd
, struct mt9m001
, icd
);
618 dev_dbg(&icd
->dev
, "Video %x removed: %p, %p\n", mt9m001
->client
->addr
,
619 mt9m001
->icd
.dev
.parent
, mt9m001
->icd
.vdev
);
620 soc_camera_video_stop(&mt9m001
->icd
);
623 static int mt9m001_probe(struct i2c_client
*client
)
625 struct mt9m001
*mt9m001
;
626 struct soc_camera_device
*icd
;
627 struct i2c_adapter
*adapter
= to_i2c_adapter(client
->dev
.parent
);
628 struct soc_camera_link
*icl
= client
->dev
.platform_data
;
632 dev_err(&client
->dev
, "MT9M001 driver needs platform data\n");
636 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_WORD_DATA
)) {
637 dev_warn(&adapter
->dev
,
638 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
642 mt9m001
= kzalloc(sizeof(struct mt9m001
), GFP_KERNEL
);
646 mt9m001
->client
= client
;
647 i2c_set_clientdata(client
, mt9m001
);
649 /* Second stage probe - when a capture adapter is there */
651 icd
->ops
= &mt9m001_ops
;
652 icd
->control
= &client
->dev
;
658 icd
->width_max
= 1280;
659 icd
->height_min
= 32;
660 icd
->height_max
= 1024;
662 icd
->iface
= icl
->bus_id
;
663 /* Default datawidth - this is the only width this camera (normally)
664 * supports. It is only with extra logic that it can support
665 * other widths. Therefore it seems to be a sensible default. */
666 mt9m001
->datawidth
= 10;
667 /* Simulated autoexposure. If enabled, we calculate shutter width
668 * ourselves in the driver based on vertical blanking and frame width */
669 mt9m001
->autoexposure
= 1;
671 ret
= bus_switch_request(mt9m001
, icl
);
675 ret
= soc_camera_device_register(icd
);
682 bus_switch_release(mt9m001
);
688 static int mt9m001_remove(struct i2c_client
*client
)
690 struct mt9m001
*mt9m001
= i2c_get_clientdata(client
);
692 soc_camera_device_unregister(&mt9m001
->icd
);
693 bus_switch_release(mt9m001
);
699 static struct i2c_driver mt9m001_i2c_driver
= {
703 .probe
= mt9m001_probe
,
704 .remove
= mt9m001_remove
,
707 static int __init
mt9m001_mod_init(void)
709 return i2c_add_driver(&mt9m001_i2c_driver
);
712 static void __exit
mt9m001_mod_exit(void)
714 i2c_del_driver(&mt9m001_i2c_driver
);
717 module_init(mt9m001_mod_init
);
718 module_exit(mt9m001_mod_exit
);
720 MODULE_DESCRIPTION("Micron MT9M001 Camera driver");
721 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
722 MODULE_LICENSE("GPL");