Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

V4L/DVB (7174): Add support for the MT9V022 camera

This driver supports Micron MT9V022 colour camera.

Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

authored by

Guennadi Liakhovetski and committed by
Mauro Carvalho Chehab
7397bfbe f523dd0d

+819
+14
drivers/media/video/Kconfig
··· 860 860 Select this if your MT9M001 camera uses a PCA9536 I2C GPIO 861 861 extender to switch between 8 and 10 bit datawidth modes 862 862 863 + config SOC_CAMERA_MT9V022 864 + tristate "mt9v022 support" 865 + depends on SOC_CAMERA && GENERIC_GPIO 866 + select GPIO_PCA953X if MT9V022_PCA9536_SWITCH 867 + help 868 + This driver supports MT9V022 cameras from Micron 869 + 870 + config MT9V022_PCA9536_SWITCH 871 + bool "pca9536 datawidth switch for mt9v022" 872 + depends on SOC_CAMERA_MT9V022 873 + help 874 + Select this if your MT9V022 camera uses a PCA9536 I2C GPIO 875 + extender to switch between 8 and 10 bit datawidth modes 876 + 863 877 config VIDEO_PXA27x 864 878 tristate "PXA27x Quick Capture Interface driver" 865 879 depends on VIDEO_DEV && PXA27x
+1
drivers/media/video/Makefile
··· 139 139 obj-$(CONFIG_VIDEO_PXA27x) += pxa_camera.o 140 140 obj-$(CONFIG_SOC_CAMERA) += soc_camera.o 141 141 obj-$(CONFIG_SOC_CAMERA_MT9M001) += mt9m001.o 142 + obj-$(CONFIG_SOC_CAMERA_MT9V022) += mt9v022.o 142 143 143 144 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core 144 145 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+804
drivers/media/video/mt9v022.c
··· 1 + /* 2 + * Driver for MT9V022 CMOS Image Sensor from Micron 3 + * 4 + * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de> 5 + * 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. 9 + */ 10 + 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> 16 + 17 + #include <media/v4l2-common.h> 18 + #include <media/v4l2-chip-ident.h> 19 + #include <media/soc_camera.h> 20 + 21 + #include <asm/gpio.h> 22 + 23 + /* mt9v022 i2c address 0x48, 0x4c, 0x58, 0x5c 24 + * The platform has to define i2c_board_info 25 + * and call i2c_register_board_info() */ 26 + 27 + static char *sensor_type; 28 + module_param(sensor_type, charp, S_IRUGO); 29 + MODULE_PARM_DESC(sensor_type, "Sensor type: \"colour\" or \"monochrome\"\n"); 30 + 31 + /* mt9v022 selected register addresses */ 32 + #define MT9V022_CHIP_VERSION 0x00 33 + #define MT9V022_COLUMN_START 0x01 34 + #define MT9V022_ROW_START 0x02 35 + #define MT9V022_WINDOW_HEIGHT 0x03 36 + #define MT9V022_WINDOW_WIDTH 0x04 37 + #define MT9V022_HORIZONTAL_BLANKING 0x05 38 + #define MT9V022_VERTICAL_BLANKING 0x06 39 + #define MT9V022_CHIP_CONTROL 0x07 40 + #define MT9V022_SHUTTER_WIDTH1 0x08 41 + #define MT9V022_SHUTTER_WIDTH2 0x09 42 + #define MT9V022_SHUTTER_WIDTH_CTRL 0x0a 43 + #define MT9V022_TOTAL_SHUTTER_WIDTH 0x0b 44 + #define MT9V022_RESET 0x0c 45 + #define MT9V022_READ_MODE 0x0d 46 + #define MT9V022_MONITOR_MODE 0x0e 47 + #define MT9V022_PIXEL_OPERATION_MODE 0x0f 48 + #define MT9V022_LED_OUT_CONTROL 0x1b 49 + #define MT9V022_ADC_MODE_CONTROL 0x1c 50 + #define MT9V022_ANALOG_GAIN 0x34 51 + #define MT9V022_BLACK_LEVEL_CALIB_CTRL 0x47 52 + #define MT9V022_PIXCLK_FV_LV 0x74 53 + #define MT9V022_DIGITAL_TEST_PATTERN 0x7f 54 + #define MT9V022_AEC_AGC_ENABLE 0xAF 55 + #define MT9V022_MAX_TOTAL_SHUTTER_WIDTH 0xBD 56 + 57 + /* Progressive scan, master, defaults */ 58 + #define MT9V022_CHIP_CONTROL_DEFAULT 0x188 59 + 60 + static const struct soc_camera_data_format mt9v022_formats[] = { 61 + { 62 + .name = "RGB Bayer (sRGB)", 63 + .depth = 8, 64 + .fourcc = V4L2_PIX_FMT_SBGGR8, 65 + .colorspace = V4L2_COLORSPACE_SRGB, 66 + }, { 67 + .name = "RGB Bayer (sRGB)", 68 + .depth = 10, 69 + .fourcc = V4L2_PIX_FMT_SBGGR16, 70 + .colorspace = V4L2_COLORSPACE_SRGB, 71 + }, { 72 + .name = "Monochrome 10 bit", 73 + .depth = 10, 74 + .fourcc = V4L2_PIX_FMT_Y16, 75 + }, { 76 + .name = "Monochrome 8 bit", 77 + .depth = 8, 78 + .fourcc = V4L2_PIX_FMT_GREY, 79 + }, 80 + }; 81 + 82 + struct mt9v022 { 83 + struct i2c_client *client; 84 + struct soc_camera_device icd; 85 + int model; /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */ 86 + int switch_gpio; 87 + u16 chip_control; 88 + unsigned char datawidth; 89 + }; 90 + 91 + static int reg_read(struct soc_camera_device *icd, const u8 reg) 92 + { 93 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 94 + struct i2c_client *client = mt9v022->client; 95 + s32 data = i2c_smbus_read_word_data(client, reg); 96 + return data < 0 ? data : swab16(data); 97 + } 98 + 99 + static int reg_write(struct soc_camera_device *icd, const u8 reg, 100 + const u16 data) 101 + { 102 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 103 + return i2c_smbus_write_word_data(mt9v022->client, reg, swab16(data)); 104 + } 105 + 106 + static int reg_set(struct soc_camera_device *icd, const u8 reg, 107 + const u16 data) 108 + { 109 + int ret; 110 + 111 + ret = reg_read(icd, reg); 112 + if (ret < 0) 113 + return ret; 114 + return reg_write(icd, reg, ret | data); 115 + } 116 + 117 + static int reg_clear(struct soc_camera_device *icd, const u8 reg, 118 + const u16 data) 119 + { 120 + int ret; 121 + 122 + ret = reg_read(icd, reg); 123 + if (ret < 0) 124 + return ret; 125 + return reg_write(icd, reg, ret & ~data); 126 + } 127 + 128 + static int mt9v022_init(struct soc_camera_device *icd) 129 + { 130 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 131 + int ret; 132 + 133 + /* Almost the default mode: master, parallel, simultaneous, and an 134 + * undocumented bit 0x200, which is present in table 7, but not in 8, 135 + * plus snapshot mode to disable scan for now */ 136 + mt9v022->chip_control |= 0x10; 137 + ret = reg_write(icd, MT9V022_CHIP_CONTROL, mt9v022->chip_control); 138 + if (ret >= 0) 139 + reg_write(icd, MT9V022_READ_MODE, 0x300); 140 + 141 + /* All defaults */ 142 + if (ret >= 0) 143 + /* AEC, AGC on */ 144 + ret = reg_set(icd, MT9V022_AEC_AGC_ENABLE, 0x3); 145 + if (ret >= 0) 146 + ret = reg_write(icd, MT9V022_MAX_TOTAL_SHUTTER_WIDTH, 480); 147 + if (ret >= 0) 148 + /* default - auto */ 149 + ret = reg_clear(icd, MT9V022_BLACK_LEVEL_CALIB_CTRL, 1); 150 + if (ret >= 0) 151 + ret = reg_write(icd, MT9V022_DIGITAL_TEST_PATTERN, 0); 152 + 153 + return ret >= 0 ? 0 : -EIO; 154 + } 155 + 156 + static int mt9v022_release(struct soc_camera_device *icd) 157 + { 158 + /* Nothing? */ 159 + return 0; 160 + } 161 + 162 + static int mt9v022_start_capture(struct soc_camera_device *icd) 163 + { 164 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 165 + /* Switch to master "normal" mode */ 166 + mt9v022->chip_control &= ~0x10; 167 + if (reg_write(icd, MT9V022_CHIP_CONTROL, 168 + mt9v022->chip_control) < 0) 169 + return -EIO; 170 + return 0; 171 + } 172 + 173 + static int mt9v022_stop_capture(struct soc_camera_device *icd) 174 + { 175 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 176 + /* Switch to snapshot mode */ 177 + mt9v022->chip_control |= 0x10; 178 + if (reg_write(icd, MT9V022_CHIP_CONTROL, 179 + mt9v022->chip_control) < 0) 180 + return -EIO; 181 + return 0; 182 + } 183 + 184 + static int bus_switch_request(struct mt9v022 *mt9v022, struct soc_camera_link *icl) 185 + { 186 + #ifdef CONFIG_MT9V022_PCA9536_SWITCH 187 + int ret; 188 + unsigned int gpio = icl->gpio; 189 + 190 + if (gpio != NO_GPIO) { 191 + /* We have a data bus switch. */ 192 + ret = gpio_request(gpio, "mt9v022"); 193 + if (ret < 0) { 194 + dev_err(&mt9v022->client->dev, "Cannot get GPIO %u\n", gpio); 195 + return ret; 196 + } 197 + 198 + ret = gpio_direction_output(gpio, 0); 199 + if (ret < 0) { 200 + dev_err(&mt9v022->client->dev, 201 + "Cannot set GPIO %u to output\n", gpio); 202 + gpio_free(gpio); 203 + return ret; 204 + } 205 + } 206 + 207 + mt9v022->switch_gpio = gpio; 208 + #else 209 + mt9v022->switch_gpio = NO_GPIO; 210 + #endif 211 + return 0; 212 + } 213 + 214 + static void bus_switch_release(struct mt9v022 *mt9v022) 215 + { 216 + #ifdef CONFIG_MT9V022_PCA9536_SWITCH 217 + if (mt9v022->switch_gpio != NO_GPIO) 218 + gpio_free(mt9v022->switch_gpio); 219 + #endif 220 + } 221 + 222 + static int bus_switch_act(struct mt9v022 *mt9v022, int go8bit) 223 + { 224 + #ifdef CONFIG_MT9V022_PCA9536_SWITCH 225 + if (mt9v022->switch_gpio == NO_GPIO) 226 + return -ENODEV; 227 + 228 + gpio_set_value_cansleep(mt9v022->switch_gpio, go8bit); 229 + return 0; 230 + #else 231 + return -ENODEV; 232 + #endif 233 + } 234 + 235 + static int mt9v022_set_capture_format(struct soc_camera_device *icd, 236 + __u32 pixfmt, struct v4l2_rect *rect, unsigned int flags) 237 + { 238 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 239 + unsigned int width_flag = flags & (IS_DATAWIDTH_10 | IS_DATAWIDTH_9 | 240 + IS_DATAWIDTH_8); 241 + u16 pixclk = 0; 242 + int ret; 243 + 244 + /* Only one width bit may be set */ 245 + if (!is_power_of_2(width_flag)) 246 + return -EINVAL; 247 + 248 + /* The caller provides a supported format, as verified per call to 249 + * icd->try_fmt_cap(), datawidth is from our supported format list */ 250 + switch (pixfmt) { 251 + case V4L2_PIX_FMT_GREY: 252 + case V4L2_PIX_FMT_Y16: 253 + if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATM) 254 + return -EINVAL; 255 + break; 256 + case V4L2_PIX_FMT_SBGGR8: 257 + case V4L2_PIX_FMT_SBGGR16: 258 + if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATC) 259 + return -EINVAL; 260 + break; 261 + case 0: 262 + /* No format change, only geometry */ 263 + break; 264 + default: 265 + return -EINVAL; 266 + } 267 + 268 + /* Like in example app. Contradicts the datasheet though */ 269 + ret = reg_read(icd, MT9V022_AEC_AGC_ENABLE); 270 + if (ret >= 0) { 271 + if (ret & 1) /* Autoexposure */ 272 + ret = reg_write(icd, MT9V022_MAX_TOTAL_SHUTTER_WIDTH, 273 + rect->height + icd->y_skip_top + 43); 274 + else 275 + ret = reg_write(icd, MT9V022_TOTAL_SHUTTER_WIDTH, 276 + rect->height + icd->y_skip_top + 43); 277 + } 278 + /* Setup frame format: defaults apart from width and height */ 279 + if (ret >= 0) 280 + ret = reg_write(icd, MT9V022_COLUMN_START, rect->left); 281 + if (ret >= 0) 282 + ret = reg_write(icd, MT9V022_ROW_START, rect->top); 283 + if (ret >= 0) 284 + /* Default 94, Phytec driver says: 285 + * "width + horizontal blank >= 660" */ 286 + ret = reg_write(icd, MT9V022_HORIZONTAL_BLANKING, 287 + rect->width > 660 - 43 ? 43 : 288 + 660 - rect->width); 289 + if (ret >= 0) 290 + ret = reg_write(icd, MT9V022_VERTICAL_BLANKING, 45); 291 + if (ret >= 0) 292 + ret = reg_write(icd, MT9V022_WINDOW_WIDTH, rect->width); 293 + if (ret >= 0) 294 + ret = reg_write(icd, MT9V022_WINDOW_HEIGHT, 295 + rect->height + icd->y_skip_top); 296 + 297 + if (ret < 0) 298 + return ret; 299 + 300 + dev_dbg(&icd->dev, "Frame %ux%u pixel\n", rect->width, rect->height); 301 + 302 + if ((mt9v022->datawidth != 10 && (width_flag == IS_DATAWIDTH_10)) || 303 + (mt9v022->datawidth != 9 && (width_flag == IS_DATAWIDTH_9)) || 304 + (mt9v022->datawidth != 8 && (width_flag == IS_DATAWIDTH_8))) { 305 + /* data width switch requested */ 306 + if (mt9v022->switch_gpio == NO_GPIO) 307 + return -EINVAL; 308 + 309 + /* Well, we actually only can do 10 or 8 bits... */ 310 + if (width_flag == IS_DATAWIDTH_9) 311 + return -EINVAL; 312 + 313 + ret = bus_switch_act(mt9v022, 314 + width_flag == IS_DATAWIDTH_8); 315 + if (ret < 0) 316 + return ret; 317 + 318 + mt9v022->datawidth = width_flag == IS_DATAWIDTH_8 ? 8 : 10; 319 + } 320 + 321 + if (flags & IS_PCLK_SAMPLE_RISING) 322 + pixclk |= 0x10; 323 + 324 + if (!(flags & IS_HSYNC_ACTIVE_HIGH)) 325 + pixclk |= 0x1; 326 + 327 + if (!(flags & IS_VSYNC_ACTIVE_HIGH)) 328 + pixclk |= 0x2; 329 + 330 + ret = reg_write(icd, MT9V022_PIXCLK_FV_LV, pixclk); 331 + if (ret < 0) 332 + return ret; 333 + 334 + if (!(flags & IS_MASTER)) 335 + mt9v022->chip_control &= ~0x8; 336 + 337 + ret = reg_write(icd, MT9V022_CHIP_CONTROL, mt9v022->chip_control); 338 + if (ret < 0) 339 + return ret; 340 + 341 + dev_dbg(&icd->dev, "Calculated pixclk 0x%x, chip control 0x%x\n", 342 + pixclk, mt9v022->chip_control); 343 + 344 + return 0; 345 + } 346 + 347 + static int mt9v022_try_fmt_cap(struct soc_camera_device *icd, 348 + struct v4l2_format *f) 349 + { 350 + if (f->fmt.pix.height < 32 + icd->y_skip_top) 351 + f->fmt.pix.height = 32 + icd->y_skip_top; 352 + if (f->fmt.pix.height > 480 + icd->y_skip_top) 353 + f->fmt.pix.height = 480 + icd->y_skip_top; 354 + if (f->fmt.pix.width < 48) 355 + f->fmt.pix.width = 48; 356 + if (f->fmt.pix.width > 752) 357 + f->fmt.pix.width = 752; 358 + f->fmt.pix.width &= ~0x03; /* ? */ 359 + 360 + return 0; 361 + } 362 + 363 + static int mt9v022_get_chip_id(struct soc_camera_device *icd, 364 + struct v4l2_chip_ident *id) 365 + { 366 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 367 + 368 + if (id->match_type != V4L2_CHIP_MATCH_I2C_ADDR) 369 + return -EINVAL; 370 + 371 + if (id->match_chip != mt9v022->client->addr) 372 + return -ENODEV; 373 + 374 + id->ident = mt9v022->model; 375 + id->revision = 0; 376 + 377 + return 0; 378 + } 379 + 380 + #ifdef CONFIG_VIDEO_ADV_DEBUG 381 + static int mt9v022_get_register(struct soc_camera_device *icd, 382 + struct v4l2_register *reg) 383 + { 384 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 385 + 386 + if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff) 387 + return -EINVAL; 388 + 389 + if (reg->match_chip != mt9v022->client->addr) 390 + return -ENODEV; 391 + 392 + reg->val = reg_read(icd, reg->reg); 393 + 394 + if (reg->val > 0xffff) 395 + return -EIO; 396 + 397 + return 0; 398 + } 399 + 400 + static int mt9v022_set_register(struct soc_camera_device *icd, 401 + struct v4l2_register *reg) 402 + { 403 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 404 + 405 + if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff) 406 + return -EINVAL; 407 + 408 + if (reg->match_chip != mt9v022->client->addr) 409 + return -ENODEV; 410 + 411 + if (reg_write(icd, reg->reg, reg->val) < 0) 412 + return -EIO; 413 + 414 + return 0; 415 + } 416 + #endif 417 + 418 + static unsigned int mt9v022_get_datawidth(struct soc_camera_device *icd) 419 + { 420 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 421 + return mt9v022->datawidth; 422 + } 423 + 424 + const struct v4l2_queryctrl mt9v022_controls[] = { 425 + { 426 + .id = V4L2_CID_VFLIP, 427 + .type = V4L2_CTRL_TYPE_BOOLEAN, 428 + .name = "Flip Vertically", 429 + .minimum = 0, 430 + .maximum = 1, 431 + .step = 1, 432 + .default_value = 0, 433 + }, { 434 + .id = V4L2_CID_HFLIP, 435 + .type = V4L2_CTRL_TYPE_BOOLEAN, 436 + .name = "Flip Horizontally", 437 + .minimum = 0, 438 + .maximum = 1, 439 + .step = 1, 440 + .default_value = 0, 441 + }, { 442 + .id = V4L2_CID_GAIN, 443 + .type = V4L2_CTRL_TYPE_INTEGER, 444 + .name = "Analog Gain", 445 + .minimum = 64, 446 + .maximum = 127, 447 + .step = 1, 448 + .default_value = 64, 449 + .flags = V4L2_CTRL_FLAG_SLIDER, 450 + }, { 451 + .id = V4L2_CID_EXPOSURE, 452 + .type = V4L2_CTRL_TYPE_INTEGER, 453 + .name = "Exposure", 454 + .minimum = 1, 455 + .maximum = 255, 456 + .step = 1, 457 + .default_value = 255, 458 + .flags = V4L2_CTRL_FLAG_SLIDER, 459 + }, { 460 + .id = V4L2_CID_AUTOGAIN, 461 + .type = V4L2_CTRL_TYPE_BOOLEAN, 462 + .name = "Automatic Gain", 463 + .minimum = 0, 464 + .maximum = 1, 465 + .step = 1, 466 + .default_value = 1, 467 + }, { 468 + .id = V4L2_CID_EXPOSURE_AUTO, 469 + .type = V4L2_CTRL_TYPE_BOOLEAN, 470 + .name = "Automatic Exposure", 471 + .minimum = 0, 472 + .maximum = 1, 473 + .step = 1, 474 + .default_value = 1, 475 + } 476 + }; 477 + 478 + static int mt9v022_get_control(struct soc_camera_device *icd, 479 + struct v4l2_control *ctrl); 480 + static int mt9v022_set_control(struct soc_camera_device *icd, 481 + struct v4l2_control *ctrl); 482 + 483 + static struct soc_camera_ops mt9v022_ops = { 484 + .owner = THIS_MODULE, 485 + .init = mt9v022_init, 486 + .release = mt9v022_release, 487 + .start_capture = mt9v022_start_capture, 488 + .stop_capture = mt9v022_stop_capture, 489 + .set_capture_format = mt9v022_set_capture_format, 490 + .try_fmt_cap = mt9v022_try_fmt_cap, 491 + .formats = mt9v022_formats, 492 + .num_formats = ARRAY_SIZE(mt9v022_formats), 493 + .get_datawidth = mt9v022_get_datawidth, 494 + .controls = mt9v022_controls, 495 + .num_controls = ARRAY_SIZE(mt9v022_controls), 496 + .get_control = mt9v022_get_control, 497 + .set_control = mt9v022_set_control, 498 + .get_chip_id = mt9v022_get_chip_id, 499 + #ifdef CONFIG_VIDEO_ADV_DEBUG 500 + .get_register = mt9v022_get_register, 501 + .set_register = mt9v022_set_register, 502 + #endif 503 + }; 504 + 505 + static int mt9v022_get_control(struct soc_camera_device *icd, 506 + struct v4l2_control *ctrl) 507 + { 508 + int data; 509 + 510 + switch (ctrl->id) { 511 + case V4L2_CID_VFLIP: 512 + data = reg_read(icd, MT9V022_READ_MODE); 513 + if (data < 0) 514 + return -EIO; 515 + ctrl->value = !!(data & 0x10); 516 + break; 517 + case V4L2_CID_HFLIP: 518 + data = reg_read(icd, MT9V022_READ_MODE); 519 + if (data < 0) 520 + return -EIO; 521 + ctrl->value = !!(data & 0x20); 522 + break; 523 + case V4L2_CID_EXPOSURE_AUTO: 524 + data = reg_read(icd, MT9V022_AEC_AGC_ENABLE); 525 + if (data < 0) 526 + return -EIO; 527 + ctrl->value = !!(data & 0x1); 528 + break; 529 + case V4L2_CID_AUTOGAIN: 530 + data = reg_read(icd, MT9V022_AEC_AGC_ENABLE); 531 + if (data < 0) 532 + return -EIO; 533 + ctrl->value = !!(data & 0x2); 534 + break; 535 + } 536 + return 0; 537 + } 538 + 539 + static int mt9v022_set_control(struct soc_camera_device *icd, 540 + struct v4l2_control *ctrl) 541 + { 542 + int data; 543 + const struct v4l2_queryctrl *qctrl; 544 + 545 + qctrl = soc_camera_find_qctrl(&mt9v022_ops, ctrl->id); 546 + 547 + if (!qctrl) 548 + return -EINVAL; 549 + 550 + switch (ctrl->id) { 551 + case V4L2_CID_VFLIP: 552 + if (ctrl->value) 553 + data = reg_set(icd, MT9V022_READ_MODE, 0x10); 554 + else 555 + data = reg_clear(icd, MT9V022_READ_MODE, 0x10); 556 + if (data < 0) 557 + return -EIO; 558 + break; 559 + case V4L2_CID_HFLIP: 560 + if (ctrl->value) 561 + data = reg_set(icd, MT9V022_READ_MODE, 0x20); 562 + else 563 + data = reg_clear(icd, MT9V022_READ_MODE, 0x20); 564 + if (data < 0) 565 + return -EIO; 566 + break; 567 + case V4L2_CID_GAIN: 568 + /* mt9v022 has minimum == default */ 569 + if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum) 570 + return -EINVAL; 571 + else { 572 + unsigned long range = qctrl->maximum - qctrl->minimum; 573 + /* Datasheet says 16 to 64. autogain only works properly 574 + * after setting gain to maximum 14. Larger values 575 + * produce "white fly" noise effect. On the whole, 576 + * manually setting analog gain does no good. */ 577 + unsigned long gain = ((ctrl->value - qctrl->minimum) * 578 + 10 + range / 2) / range + 4; 579 + if (gain >= 32) 580 + gain &= ~1; 581 + /* The user wants to set gain manually, hope, she 582 + * knows, what she's doing... Switch AGC off. */ 583 + 584 + if (reg_clear(icd, MT9V022_AEC_AGC_ENABLE, 0x2) < 0) 585 + return -EIO; 586 + 587 + dev_info(&icd->dev, "Setting gain from %d to %lu\n", 588 + reg_read(icd, MT9V022_ANALOG_GAIN), gain); 589 + if (reg_write(icd, MT9V022_ANALOG_GAIN, gain) < 0) 590 + return -EIO; 591 + icd->gain = ctrl->value; 592 + } 593 + break; 594 + case V4L2_CID_EXPOSURE: 595 + /* mt9v022 has maximum == default */ 596 + if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum) 597 + return -EINVAL; 598 + else { 599 + unsigned long range = qctrl->maximum - qctrl->minimum; 600 + unsigned long shutter = ((ctrl->value - qctrl->minimum) * 601 + 479 + range / 2) / range + 1; 602 + /* The user wants to set shutter width manually, hope, 603 + * she knows, what she's doing... Switch AEC off. */ 604 + 605 + if (reg_clear(icd, MT9V022_AEC_AGC_ENABLE, 0x1) < 0) 606 + return -EIO; 607 + 608 + dev_dbg(&icd->dev, "Shutter width from %d to %lu\n", 609 + reg_read(icd, MT9V022_TOTAL_SHUTTER_WIDTH), 610 + shutter); 611 + if (reg_write(icd, MT9V022_TOTAL_SHUTTER_WIDTH, 612 + shutter) < 0) 613 + return -EIO; 614 + icd->exposure = ctrl->value; 615 + } 616 + break; 617 + case V4L2_CID_AUTOGAIN: 618 + if (ctrl->value) 619 + data = reg_set(icd, MT9V022_AEC_AGC_ENABLE, 0x2); 620 + else 621 + data = reg_clear(icd, MT9V022_AEC_AGC_ENABLE, 0x2); 622 + if (data < 0) 623 + return -EIO; 624 + break; 625 + case V4L2_CID_EXPOSURE_AUTO: 626 + if (ctrl->value) 627 + data = reg_set(icd, MT9V022_AEC_AGC_ENABLE, 0x1); 628 + else 629 + data = reg_clear(icd, MT9V022_AEC_AGC_ENABLE, 0x1); 630 + if (data < 0) 631 + return -EIO; 632 + break; 633 + } 634 + return 0; 635 + } 636 + 637 + /* Interface active, can use i2c. If it fails, it can indeed mean, that 638 + * this wasn't our capture interface, so, we wait for the right one */ 639 + static int mt9v022_video_probe(struct soc_camera_device *icd) 640 + { 641 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 642 + s32 data; 643 + int ret; 644 + 645 + if (!icd->dev.parent || 646 + to_soc_camera_host(icd->dev.parent)->nr != icd->iface) 647 + return -ENODEV; 648 + 649 + /* Read out the chip version register */ 650 + data = reg_read(icd, MT9V022_CHIP_VERSION); 651 + 652 + /* must be 0x1311 or 0x1313 */ 653 + if (data != 0x1311 && data != 0x1313) { 654 + ret = -ENODEV; 655 + dev_info(&icd->dev, "No MT9V022 detected, ID register 0x%x\n", 656 + data); 657 + goto ei2c; 658 + } 659 + 660 + /* Soft reset */ 661 + ret = reg_write(icd, MT9V022_RESET, 1); 662 + if (ret < 0) 663 + goto ei2c; 664 + /* 15 clock cycles */ 665 + udelay(200); 666 + if (reg_read(icd, MT9V022_RESET)) { 667 + dev_err(&icd->dev, "Resetting MT9V022 failed!\n"); 668 + goto ei2c; 669 + } 670 + 671 + /* Set monochrome or colour sensor type */ 672 + if (sensor_type && (!strcmp("colour", sensor_type) || 673 + !strcmp("color", sensor_type))) { 674 + ret = reg_write(icd, MT9V022_PIXEL_OPERATION_MODE, 4 | 0x11); 675 + mt9v022->model = V4L2_IDENT_MT9V022IX7ATC; 676 + } else { 677 + ret = reg_write(icd, MT9V022_PIXEL_OPERATION_MODE, 0x11); 678 + mt9v022->model = V4L2_IDENT_MT9V022IX7ATM; 679 + } 680 + 681 + if (ret >= 0) 682 + ret = soc_camera_video_start(icd); 683 + if (ret < 0) 684 + goto eisis; 685 + 686 + dev_info(&icd->dev, "Detected a MT9V022 chip ID %x, %s sensor\n", 687 + data, mt9v022->model == V4L2_IDENT_MT9V022IX7ATM ? 688 + "monochrome" : "colour"); 689 + 690 + return 0; 691 + 692 + eisis: 693 + ei2c: 694 + return ret; 695 + } 696 + 697 + static void mt9v022_video_remove(struct soc_camera_device *icd) 698 + { 699 + struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd); 700 + 701 + dev_dbg(&icd->dev, "Video %x removed: %p, %p\n", mt9v022->client->addr, 702 + mt9v022->icd.dev.parent, mt9v022->icd.vdev); 703 + soc_camera_video_stop(&mt9v022->icd); 704 + } 705 + 706 + static int mt9v022_probe(struct i2c_client *client) 707 + { 708 + struct mt9v022 *mt9v022; 709 + struct soc_camera_device *icd; 710 + struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 711 + struct soc_camera_link *icl = client->dev.platform_data; 712 + int ret; 713 + 714 + if (!icl) { 715 + dev_err(&client->dev, "MT9V022 driver needs platform data\n"); 716 + return -EINVAL; 717 + } 718 + 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"); 722 + return -EIO; 723 + } 724 + 725 + mt9v022 = kzalloc(sizeof(struct mt9v022), GFP_KERNEL); 726 + if (!mt9v022) 727 + return -ENOMEM; 728 + 729 + mt9v022->chip_control = MT9V022_CHIP_CONTROL_DEFAULT; 730 + mt9v022->client = client; 731 + i2c_set_clientdata(client, mt9v022); 732 + 733 + icd = &mt9v022->icd; 734 + icd->probe = mt9v022_video_probe; 735 + icd->remove = mt9v022_video_remove; 736 + icd->ops = &mt9v022_ops; 737 + icd->control = &client->dev; 738 + icd->x_min = 1; 739 + icd->y_min = 4; 740 + icd->x_current = 1; 741 + icd->y_current = 4; 742 + icd->width_min = 48; 743 + icd->width_max = 752; 744 + icd->height_min = 32; 745 + icd->height_max = 480; 746 + icd->y_skip_top = 1; 747 + icd->iface = icl->bus_id; 748 + /* Default datawidth - this is the only width this camera (normally) 749 + * supports. It is only with extra logic that it can support 750 + * other widths. Therefore it seems to be a sensible default. */ 751 + mt9v022->datawidth = 10; 752 + 753 + ret = bus_switch_request(mt9v022, icl); 754 + if (ret) 755 + goto eswinit; 756 + 757 + ret = soc_camera_device_register(icd); 758 + if (ret) 759 + goto eisdr; 760 + 761 + return 0; 762 + 763 + eisdr: 764 + bus_switch_release(mt9v022); 765 + eswinit: 766 + kfree(mt9v022); 767 + return ret; 768 + } 769 + 770 + static int mt9v022_remove(struct i2c_client *client) 771 + { 772 + struct mt9v022 *mt9v022 = i2c_get_clientdata(client); 773 + 774 + soc_camera_device_unregister(&mt9v022->icd); 775 + bus_switch_release(mt9v022); 776 + kfree(mt9v022); 777 + 778 + return 0; 779 + } 780 + 781 + static struct i2c_driver mt9v022_i2c_driver = { 782 + .driver = { 783 + .name = "mt9v022", 784 + }, 785 + .probe = mt9v022_probe, 786 + .remove = mt9v022_remove, 787 + }; 788 + 789 + static int __init mt9v022_mod_init(void) 790 + { 791 + return i2c_add_driver(&mt9v022_i2c_driver); 792 + } 793 + 794 + static void __exit mt9v022_mod_exit(void) 795 + { 796 + i2c_del_driver(&mt9v022_i2c_driver); 797 + } 798 + 799 + module_init(mt9v022_mod_init); 800 + module_exit(mt9v022_mod_exit); 801 + 802 + MODULE_DESCRIPTION("Micron MT9V022 Camera driver"); 803 + MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>"); 804 + MODULE_LICENSE("GPL");