1/* 2 * Driver for MT9M001 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/log2.h> 15#include <linux/module.h> 16 17#include <media/soc_camera.h> 18#include <media/soc_mediabus.h> 19#include <media/v4l2-clk.h> 20#include <media/v4l2-subdev.h> 21#include <media/v4l2-ctrls.h> 22 23/* 24 * mt9m001 i2c address 0x5d 25 * The platform has to define struct i2c_board_info objects and link to them 26 * from struct soc_camera_host_desc 27 */ 28 29/* mt9m001 selected register addresses */ 30#define MT9M001_CHIP_VERSION 0x00 31#define MT9M001_ROW_START 0x01 32#define MT9M001_COLUMN_START 0x02 33#define MT9M001_WINDOW_HEIGHT 0x03 34#define MT9M001_WINDOW_WIDTH 0x04 35#define MT9M001_HORIZONTAL_BLANKING 0x05 36#define MT9M001_VERTICAL_BLANKING 0x06 37#define MT9M001_OUTPUT_CONTROL 0x07 38#define MT9M001_SHUTTER_WIDTH 0x09 39#define MT9M001_FRAME_RESTART 0x0b 40#define MT9M001_SHUTTER_DELAY 0x0c 41#define MT9M001_RESET 0x0d 42#define MT9M001_READ_OPTIONS1 0x1e 43#define MT9M001_READ_OPTIONS2 0x20 44#define MT9M001_GLOBAL_GAIN 0x35 45#define MT9M001_CHIP_ENABLE 0xF1 46 47#define MT9M001_MAX_WIDTH 1280 48#define MT9M001_MAX_HEIGHT 1024 49#define MT9M001_MIN_WIDTH 48 50#define MT9M001_MIN_HEIGHT 32 51#define MT9M001_COLUMN_SKIP 20 52#define MT9M001_ROW_SKIP 12 53 54/* MT9M001 has only one fixed colorspace per pixelcode */ 55struct mt9m001_datafmt { 56 u32 code; 57 enum v4l2_colorspace colorspace; 58}; 59 60/* Find a data format by a pixel code in an array */ 61static const struct mt9m001_datafmt *mt9m001_find_datafmt( 62 u32 code, const struct mt9m001_datafmt *fmt, 63 int n) 64{ 65 int i; 66 for (i = 0; i < n; i++) 67 if (fmt[i].code == code) 68 return fmt + i; 69 70 return NULL; 71} 72 73static const struct mt9m001_datafmt mt9m001_colour_fmts[] = { 74 /* 75 * Order important: first natively supported, 76 * second supported with a GPIO extender 77 */ 78 {MEDIA_BUS_FMT_SBGGR10_1X10, V4L2_COLORSPACE_SRGB}, 79 {MEDIA_BUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB}, 80}; 81 82static const struct mt9m001_datafmt mt9m001_monochrome_fmts[] = { 83 /* Order important - see above */ 84 {MEDIA_BUS_FMT_Y10_1X10, V4L2_COLORSPACE_JPEG}, 85 {MEDIA_BUS_FMT_Y8_1X8, V4L2_COLORSPACE_JPEG}, 86}; 87 88struct mt9m001 { 89 struct v4l2_subdev subdev; 90 struct v4l2_ctrl_handler hdl; 91 struct { 92 /* exposure/auto-exposure cluster */ 93 struct v4l2_ctrl *autoexposure; 94 struct v4l2_ctrl *exposure; 95 }; 96 struct v4l2_rect rect; /* Sensor window */ 97 struct v4l2_clk *clk; 98 const struct mt9m001_datafmt *fmt; 99 const struct mt9m001_datafmt *fmts; 100 int num_fmts; 101 unsigned int total_h; 102 unsigned short y_skip_top; /* Lines to skip at the top */ 103}; 104 105static struct mt9m001 *to_mt9m001(const struct i2c_client *client) 106{ 107 return container_of(i2c_get_clientdata(client), struct mt9m001, subdev); 108} 109 110static int reg_read(struct i2c_client *client, const u8 reg) 111{ 112 return i2c_smbus_read_word_swapped(client, reg); 113} 114 115static int reg_write(struct i2c_client *client, const u8 reg, 116 const u16 data) 117{ 118 return i2c_smbus_write_word_swapped(client, reg, data); 119} 120 121static int reg_set(struct i2c_client *client, const u8 reg, 122 const u16 data) 123{ 124 int ret; 125 126 ret = reg_read(client, reg); 127 if (ret < 0) 128 return ret; 129 return reg_write(client, reg, ret | data); 130} 131 132static int reg_clear(struct i2c_client *client, const u8 reg, 133 const u16 data) 134{ 135 int ret; 136 137 ret = reg_read(client, reg); 138 if (ret < 0) 139 return ret; 140 return reg_write(client, reg, ret & ~data); 141} 142 143static int mt9m001_init(struct i2c_client *client) 144{ 145 int ret; 146 147 dev_dbg(&client->dev, "%s\n", __func__); 148 149 /* 150 * We don't know, whether platform provides reset, issue a soft reset 151 * too. This returns all registers to their default values. 152 */ 153 ret = reg_write(client, MT9M001_RESET, 1); 154 if (!ret) 155 ret = reg_write(client, MT9M001_RESET, 0); 156 157 /* Disable chip, synchronous option update */ 158 if (!ret) 159 ret = reg_write(client, MT9M001_OUTPUT_CONTROL, 0); 160 161 return ret; 162} 163 164static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable) 165{ 166 struct i2c_client *client = v4l2_get_subdevdata(sd); 167 168 /* Switch to master "normal" mode or stop sensor readout */ 169 if (reg_write(client, MT9M001_OUTPUT_CONTROL, enable ? 2 : 0) < 0) 170 return -EIO; 171 return 0; 172} 173 174static int mt9m001_s_crop(struct v4l2_subdev *sd, const struct v4l2_crop *a) 175{ 176 struct i2c_client *client = v4l2_get_subdevdata(sd); 177 struct mt9m001 *mt9m001 = to_mt9m001(client); 178 struct v4l2_rect rect = a->c; 179 int ret; 180 const u16 hblank = 9, vblank = 25; 181 182 if (mt9m001->fmts == mt9m001_colour_fmts) 183 /* 184 * Bayer format - even number of rows for simplicity, 185 * but let the user play with the top row. 186 */ 187 rect.height = ALIGN(rect.height, 2); 188 189 /* Datasheet requirement: see register description */ 190 rect.width = ALIGN(rect.width, 2); 191 rect.left = ALIGN(rect.left, 2); 192 193 soc_camera_limit_side(&rect.left, &rect.width, 194 MT9M001_COLUMN_SKIP, MT9M001_MIN_WIDTH, MT9M001_MAX_WIDTH); 195 196 soc_camera_limit_side(&rect.top, &rect.height, 197 MT9M001_ROW_SKIP, MT9M001_MIN_HEIGHT, MT9M001_MAX_HEIGHT); 198 199 mt9m001->total_h = rect.height + mt9m001->y_skip_top + vblank; 200 201 /* Blanking and start values - default... */ 202 ret = reg_write(client, MT9M001_HORIZONTAL_BLANKING, hblank); 203 if (!ret) 204 ret = reg_write(client, MT9M001_VERTICAL_BLANKING, vblank); 205 206 /* 207 * The caller provides a supported format, as verified per 208 * call to .try_mbus_fmt() 209 */ 210 if (!ret) 211 ret = reg_write(client, MT9M001_COLUMN_START, rect.left); 212 if (!ret) 213 ret = reg_write(client, MT9M001_ROW_START, rect.top); 214 if (!ret) 215 ret = reg_write(client, MT9M001_WINDOW_WIDTH, rect.width - 1); 216 if (!ret) 217 ret = reg_write(client, MT9M001_WINDOW_HEIGHT, 218 rect.height + mt9m001->y_skip_top - 1); 219 if (!ret && v4l2_ctrl_g_ctrl(mt9m001->autoexposure) == V4L2_EXPOSURE_AUTO) 220 ret = reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h); 221 222 if (!ret) 223 mt9m001->rect = rect; 224 225 return ret; 226} 227 228static int mt9m001_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *a) 229{ 230 struct i2c_client *client = v4l2_get_subdevdata(sd); 231 struct mt9m001 *mt9m001 = to_mt9m001(client); 232 233 a->c = mt9m001->rect; 234 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 235 236 return 0; 237} 238 239static int mt9m001_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *a) 240{ 241 a->bounds.left = MT9M001_COLUMN_SKIP; 242 a->bounds.top = MT9M001_ROW_SKIP; 243 a->bounds.width = MT9M001_MAX_WIDTH; 244 a->bounds.height = MT9M001_MAX_HEIGHT; 245 a->defrect = a->bounds; 246 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 247 a->pixelaspect.numerator = 1; 248 a->pixelaspect.denominator = 1; 249 250 return 0; 251} 252 253static int mt9m001_g_fmt(struct v4l2_subdev *sd, 254 struct v4l2_mbus_framefmt *mf) 255{ 256 struct i2c_client *client = v4l2_get_subdevdata(sd); 257 struct mt9m001 *mt9m001 = to_mt9m001(client); 258 259 mf->width = mt9m001->rect.width; 260 mf->height = mt9m001->rect.height; 261 mf->code = mt9m001->fmt->code; 262 mf->colorspace = mt9m001->fmt->colorspace; 263 mf->field = V4L2_FIELD_NONE; 264 265 return 0; 266} 267 268static int mt9m001_s_fmt(struct v4l2_subdev *sd, 269 struct v4l2_mbus_framefmt *mf) 270{ 271 struct i2c_client *client = v4l2_get_subdevdata(sd); 272 struct mt9m001 *mt9m001 = to_mt9m001(client); 273 struct v4l2_crop a = { 274 .c = { 275 .left = mt9m001->rect.left, 276 .top = mt9m001->rect.top, 277 .width = mf->width, 278 .height = mf->height, 279 }, 280 }; 281 int ret; 282 283 /* No support for scaling so far, just crop. TODO: use skipping */ 284 ret = mt9m001_s_crop(sd, &a); 285 if (!ret) { 286 mf->width = mt9m001->rect.width; 287 mf->height = mt9m001->rect.height; 288 mt9m001->fmt = mt9m001_find_datafmt(mf->code, 289 mt9m001->fmts, mt9m001->num_fmts); 290 mf->colorspace = mt9m001->fmt->colorspace; 291 } 292 293 return ret; 294} 295 296static int mt9m001_try_fmt(struct v4l2_subdev *sd, 297 struct v4l2_mbus_framefmt *mf) 298{ 299 struct i2c_client *client = v4l2_get_subdevdata(sd); 300 struct mt9m001 *mt9m001 = to_mt9m001(client); 301 const struct mt9m001_datafmt *fmt; 302 303 v4l_bound_align_image(&mf->width, MT9M001_MIN_WIDTH, 304 MT9M001_MAX_WIDTH, 1, 305 &mf->height, MT9M001_MIN_HEIGHT + mt9m001->y_skip_top, 306 MT9M001_MAX_HEIGHT + mt9m001->y_skip_top, 0, 0); 307 308 if (mt9m001->fmts == mt9m001_colour_fmts) 309 mf->height = ALIGN(mf->height - 1, 2); 310 311 fmt = mt9m001_find_datafmt(mf->code, mt9m001->fmts, 312 mt9m001->num_fmts); 313 if (!fmt) { 314 fmt = mt9m001->fmt; 315 mf->code = fmt->code; 316 } 317 318 mf->colorspace = fmt->colorspace; 319 320 return 0; 321} 322 323#ifdef CONFIG_VIDEO_ADV_DEBUG 324static int mt9m001_g_register(struct v4l2_subdev *sd, 325 struct v4l2_dbg_register *reg) 326{ 327 struct i2c_client *client = v4l2_get_subdevdata(sd); 328 329 if (reg->reg > 0xff) 330 return -EINVAL; 331 332 reg->size = 2; 333 reg->val = reg_read(client, reg->reg); 334 335 if (reg->val > 0xffff) 336 return -EIO; 337 338 return 0; 339} 340 341static int mt9m001_s_register(struct v4l2_subdev *sd, 342 const struct v4l2_dbg_register *reg) 343{ 344 struct i2c_client *client = v4l2_get_subdevdata(sd); 345 346 if (reg->reg > 0xff) 347 return -EINVAL; 348 349 if (reg_write(client, reg->reg, reg->val) < 0) 350 return -EIO; 351 352 return 0; 353} 354#endif 355 356static int mt9m001_s_power(struct v4l2_subdev *sd, int on) 357{ 358 struct i2c_client *client = v4l2_get_subdevdata(sd); 359 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client); 360 struct mt9m001 *mt9m001 = to_mt9m001(client); 361 362 return soc_camera_set_power(&client->dev, ssdd, mt9m001->clk, on); 363} 364 365static int mt9m001_g_volatile_ctrl(struct v4l2_ctrl *ctrl) 366{ 367 struct mt9m001 *mt9m001 = container_of(ctrl->handler, 368 struct mt9m001, hdl); 369 s32 min, max; 370 371 switch (ctrl->id) { 372 case V4L2_CID_EXPOSURE_AUTO: 373 min = mt9m001->exposure->minimum; 374 max = mt9m001->exposure->maximum; 375 mt9m001->exposure->val = 376 (524 + (mt9m001->total_h - 1) * (max - min)) / 1048 + min; 377 break; 378 } 379 return 0; 380} 381 382static int mt9m001_s_ctrl(struct v4l2_ctrl *ctrl) 383{ 384 struct mt9m001 *mt9m001 = container_of(ctrl->handler, 385 struct mt9m001, hdl); 386 struct v4l2_subdev *sd = &mt9m001->subdev; 387 struct i2c_client *client = v4l2_get_subdevdata(sd); 388 struct v4l2_ctrl *exp = mt9m001->exposure; 389 int data; 390 391 switch (ctrl->id) { 392 case V4L2_CID_VFLIP: 393 if (ctrl->val) 394 data = reg_set(client, MT9M001_READ_OPTIONS2, 0x8000); 395 else 396 data = reg_clear(client, MT9M001_READ_OPTIONS2, 0x8000); 397 if (data < 0) 398 return -EIO; 399 return 0; 400 401 case V4L2_CID_GAIN: 402 /* See Datasheet Table 7, Gain settings. */ 403 if (ctrl->val <= ctrl->default_value) { 404 /* Pack it into 0..1 step 0.125, register values 0..8 */ 405 unsigned long range = ctrl->default_value - ctrl->minimum; 406 data = ((ctrl->val - (s32)ctrl->minimum) * 8 + range / 2) / range; 407 408 dev_dbg(&client->dev, "Setting gain %d\n", data); 409 data = reg_write(client, MT9M001_GLOBAL_GAIN, data); 410 if (data < 0) 411 return -EIO; 412 } else { 413 /* Pack it into 1.125..15 variable step, register values 9..67 */ 414 /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */ 415 unsigned long range = ctrl->maximum - ctrl->default_value - 1; 416 unsigned long gain = ((ctrl->val - (s32)ctrl->default_value - 1) * 417 111 + range / 2) / range + 9; 418 419 if (gain <= 32) 420 data = gain; 421 else if (gain <= 64) 422 data = ((gain - 32) * 16 + 16) / 32 + 80; 423 else 424 data = ((gain - 64) * 7 + 28) / 56 + 96; 425 426 dev_dbg(&client->dev, "Setting gain from %d to %d\n", 427 reg_read(client, MT9M001_GLOBAL_GAIN), data); 428 data = reg_write(client, MT9M001_GLOBAL_GAIN, data); 429 if (data < 0) 430 return -EIO; 431 } 432 return 0; 433 434 case V4L2_CID_EXPOSURE_AUTO: 435 if (ctrl->val == V4L2_EXPOSURE_MANUAL) { 436 unsigned long range = exp->maximum - exp->minimum; 437 unsigned long shutter = ((exp->val - (s32)exp->minimum) * 1048 + 438 range / 2) / range + 1; 439 440 dev_dbg(&client->dev, 441 "Setting shutter width from %d to %lu\n", 442 reg_read(client, MT9M001_SHUTTER_WIDTH), shutter); 443 if (reg_write(client, MT9M001_SHUTTER_WIDTH, shutter) < 0) 444 return -EIO; 445 } else { 446 const u16 vblank = 25; 447 448 mt9m001->total_h = mt9m001->rect.height + 449 mt9m001->y_skip_top + vblank; 450 if (reg_write(client, MT9M001_SHUTTER_WIDTH, mt9m001->total_h) < 0) 451 return -EIO; 452 } 453 return 0; 454 } 455 return -EINVAL; 456} 457 458/* 459 * Interface active, can use i2c. If it fails, it can indeed mean, that 460 * this wasn't our capture interface, so, we wait for the right one 461 */ 462static int mt9m001_video_probe(struct soc_camera_subdev_desc *ssdd, 463 struct i2c_client *client) 464{ 465 struct mt9m001 *mt9m001 = to_mt9m001(client); 466 s32 data; 467 unsigned long flags; 468 int ret; 469 470 ret = mt9m001_s_power(&mt9m001->subdev, 1); 471 if (ret < 0) 472 return ret; 473 474 /* Enable the chip */ 475 data = reg_write(client, MT9M001_CHIP_ENABLE, 1); 476 dev_dbg(&client->dev, "write: %d\n", data); 477 478 /* Read out the chip version register */ 479 data = reg_read(client, MT9M001_CHIP_VERSION); 480 481 /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */ 482 switch (data) { 483 case 0x8411: 484 case 0x8421: 485 mt9m001->fmts = mt9m001_colour_fmts; 486 break; 487 case 0x8431: 488 mt9m001->fmts = mt9m001_monochrome_fmts; 489 break; 490 default: 491 dev_err(&client->dev, 492 "No MT9M001 chip detected, register read %x\n", data); 493 ret = -ENODEV; 494 goto done; 495 } 496 497 mt9m001->num_fmts = 0; 498 499 /* 500 * This is a 10bit sensor, so by default we only allow 10bit. 501 * The platform may support different bus widths due to 502 * different routing of the data lines. 503 */ 504 if (ssdd->query_bus_param) 505 flags = ssdd->query_bus_param(ssdd); 506 else 507 flags = SOCAM_DATAWIDTH_10; 508 509 if (flags & SOCAM_DATAWIDTH_10) 510 mt9m001->num_fmts++; 511 else 512 mt9m001->fmts++; 513 514 if (flags & SOCAM_DATAWIDTH_8) 515 mt9m001->num_fmts++; 516 517 mt9m001->fmt = &mt9m001->fmts[0]; 518 519 dev_info(&client->dev, "Detected a MT9M001 chip ID %x (%s)\n", data, 520 data == 0x8431 ? "C12STM" : "C12ST"); 521 522 ret = mt9m001_init(client); 523 if (ret < 0) { 524 dev_err(&client->dev, "Failed to initialise the camera\n"); 525 goto done; 526 } 527 528 /* mt9m001_init() has reset the chip, returning registers to defaults */ 529 ret = v4l2_ctrl_handler_setup(&mt9m001->hdl); 530 531done: 532 mt9m001_s_power(&mt9m001->subdev, 0); 533 return ret; 534} 535 536static void mt9m001_video_remove(struct soc_camera_subdev_desc *ssdd) 537{ 538 if (ssdd->free_bus) 539 ssdd->free_bus(ssdd); 540} 541 542static int mt9m001_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines) 543{ 544 struct i2c_client *client = v4l2_get_subdevdata(sd); 545 struct mt9m001 *mt9m001 = to_mt9m001(client); 546 547 *lines = mt9m001->y_skip_top; 548 549 return 0; 550} 551 552static const struct v4l2_ctrl_ops mt9m001_ctrl_ops = { 553 .g_volatile_ctrl = mt9m001_g_volatile_ctrl, 554 .s_ctrl = mt9m001_s_ctrl, 555}; 556 557static struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = { 558#ifdef CONFIG_VIDEO_ADV_DEBUG 559 .g_register = mt9m001_g_register, 560 .s_register = mt9m001_s_register, 561#endif 562 .s_power = mt9m001_s_power, 563}; 564 565static int mt9m001_enum_fmt(struct v4l2_subdev *sd, unsigned int index, 566 u32 *code) 567{ 568 struct i2c_client *client = v4l2_get_subdevdata(sd); 569 struct mt9m001 *mt9m001 = to_mt9m001(client); 570 571 if (index >= mt9m001->num_fmts) 572 return -EINVAL; 573 574 *code = mt9m001->fmts[index].code; 575 return 0; 576} 577 578static int mt9m001_g_mbus_config(struct v4l2_subdev *sd, 579 struct v4l2_mbus_config *cfg) 580{ 581 struct i2c_client *client = v4l2_get_subdevdata(sd); 582 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client); 583 584 /* MT9M001 has all capture_format parameters fixed */ 585 cfg->flags = V4L2_MBUS_PCLK_SAMPLE_FALLING | 586 V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_HIGH | 587 V4L2_MBUS_DATA_ACTIVE_HIGH | V4L2_MBUS_MASTER; 588 cfg->type = V4L2_MBUS_PARALLEL; 589 cfg->flags = soc_camera_apply_board_flags(ssdd, cfg); 590 591 return 0; 592} 593 594static int mt9m001_s_mbus_config(struct v4l2_subdev *sd, 595 const struct v4l2_mbus_config *cfg) 596{ 597 const struct i2c_client *client = v4l2_get_subdevdata(sd); 598 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client); 599 struct mt9m001 *mt9m001 = to_mt9m001(client); 600 unsigned int bps = soc_mbus_get_fmtdesc(mt9m001->fmt->code)->bits_per_sample; 601 602 if (ssdd->set_bus_param) 603 return ssdd->set_bus_param(ssdd, 1 << (bps - 1)); 604 605 /* 606 * Without board specific bus width settings we only support the 607 * sensors native bus width 608 */ 609 return bps == 10 ? 0 : -EINVAL; 610} 611 612static struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = { 613 .s_stream = mt9m001_s_stream, 614 .s_mbus_fmt = mt9m001_s_fmt, 615 .g_mbus_fmt = mt9m001_g_fmt, 616 .try_mbus_fmt = mt9m001_try_fmt, 617 .s_crop = mt9m001_s_crop, 618 .g_crop = mt9m001_g_crop, 619 .cropcap = mt9m001_cropcap, 620 .enum_mbus_fmt = mt9m001_enum_fmt, 621 .g_mbus_config = mt9m001_g_mbus_config, 622 .s_mbus_config = mt9m001_s_mbus_config, 623}; 624 625static struct v4l2_subdev_sensor_ops mt9m001_subdev_sensor_ops = { 626 .g_skip_top_lines = mt9m001_g_skip_top_lines, 627}; 628 629static struct v4l2_subdev_ops mt9m001_subdev_ops = { 630 .core = &mt9m001_subdev_core_ops, 631 .video = &mt9m001_subdev_video_ops, 632 .sensor = &mt9m001_subdev_sensor_ops, 633}; 634 635static int mt9m001_probe(struct i2c_client *client, 636 const struct i2c_device_id *did) 637{ 638 struct mt9m001 *mt9m001; 639 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 640 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client); 641 int ret; 642 643 if (!ssdd) { 644 dev_err(&client->dev, "MT9M001 driver needs platform data\n"); 645 return -EINVAL; 646 } 647 648 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) { 649 dev_warn(&adapter->dev, 650 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n"); 651 return -EIO; 652 } 653 654 mt9m001 = devm_kzalloc(&client->dev, sizeof(struct mt9m001), GFP_KERNEL); 655 if (!mt9m001) 656 return -ENOMEM; 657 658 v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops); 659 v4l2_ctrl_handler_init(&mt9m001->hdl, 4); 660 v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops, 661 V4L2_CID_VFLIP, 0, 1, 1, 0); 662 v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops, 663 V4L2_CID_GAIN, 0, 127, 1, 64); 664 mt9m001->exposure = v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops, 665 V4L2_CID_EXPOSURE, 1, 255, 1, 255); 666 /* 667 * Simulated autoexposure. If enabled, we calculate shutter width 668 * ourselves in the driver based on vertical blanking and frame width 669 */ 670 mt9m001->autoexposure = v4l2_ctrl_new_std_menu(&mt9m001->hdl, 671 &mt9m001_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0, 672 V4L2_EXPOSURE_AUTO); 673 mt9m001->subdev.ctrl_handler = &mt9m001->hdl; 674 if (mt9m001->hdl.error) 675 return mt9m001->hdl.error; 676 677 v4l2_ctrl_auto_cluster(2, &mt9m001->autoexposure, 678 V4L2_EXPOSURE_MANUAL, true); 679 680 /* Second stage probe - when a capture adapter is there */ 681 mt9m001->y_skip_top = 0; 682 mt9m001->rect.left = MT9M001_COLUMN_SKIP; 683 mt9m001->rect.top = MT9M001_ROW_SKIP; 684 mt9m001->rect.width = MT9M001_MAX_WIDTH; 685 mt9m001->rect.height = MT9M001_MAX_HEIGHT; 686 687 mt9m001->clk = v4l2_clk_get(&client->dev, "mclk"); 688 if (IS_ERR(mt9m001->clk)) { 689 ret = PTR_ERR(mt9m001->clk); 690 goto eclkget; 691 } 692 693 ret = mt9m001_video_probe(ssdd, client); 694 if (ret) { 695 v4l2_clk_put(mt9m001->clk); 696eclkget: 697 v4l2_ctrl_handler_free(&mt9m001->hdl); 698 } 699 700 return ret; 701} 702 703static int mt9m001_remove(struct i2c_client *client) 704{ 705 struct mt9m001 *mt9m001 = to_mt9m001(client); 706 struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client); 707 708 v4l2_clk_put(mt9m001->clk); 709 v4l2_device_unregister_subdev(&mt9m001->subdev); 710 v4l2_ctrl_handler_free(&mt9m001->hdl); 711 mt9m001_video_remove(ssdd); 712 713 return 0; 714} 715 716static const struct i2c_device_id mt9m001_id[] = { 717 { "mt9m001", 0 }, 718 { } 719}; 720MODULE_DEVICE_TABLE(i2c, mt9m001_id); 721 722static struct i2c_driver mt9m001_i2c_driver = { 723 .driver = { 724 .name = "mt9m001", 725 }, 726 .probe = mt9m001_probe, 727 .remove = mt9m001_remove, 728 .id_table = mt9m001_id, 729}; 730 731module_i2c_driver(mt9m001_i2c_driver); 732 733MODULE_DESCRIPTION("Micron MT9M001 Camera driver"); 734MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>"); 735MODULE_LICENSE("GPL"); 736