888 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Driver for MT9M001 CMOS Image Sensor from Micron4 *5 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>6 */7 8#include <linux/clk.h>9#include <linux/delay.h>10#include <linux/gpio/consumer.h>11#include <linux/i2c.h>12#include <linux/log2.h>13#include <linux/module.h>14#include <linux/pm_runtime.h>15#include <linux/slab.h>16#include <linux/videodev2.h>17 18#include <media/v4l2-ctrls.h>19#include <media/v4l2-device.h>20#include <media/v4l2-event.h>21#include <media/v4l2-subdev.h>22 23/*24 * mt9m001 i2c address 0x5d25 */26 27/* mt9m001 selected register addresses */28#define MT9M001_CHIP_VERSION 0x0029#define MT9M001_ROW_START 0x0130#define MT9M001_COLUMN_START 0x0231#define MT9M001_WINDOW_HEIGHT 0x0332#define MT9M001_WINDOW_WIDTH 0x0433#define MT9M001_HORIZONTAL_BLANKING 0x0534#define MT9M001_VERTICAL_BLANKING 0x0635#define MT9M001_OUTPUT_CONTROL 0x0736#define MT9M001_SHUTTER_WIDTH 0x0937#define MT9M001_FRAME_RESTART 0x0b38#define MT9M001_SHUTTER_DELAY 0x0c39#define MT9M001_RESET 0x0d40#define MT9M001_READ_OPTIONS1 0x1e41#define MT9M001_READ_OPTIONS2 0x2042#define MT9M001_GLOBAL_GAIN 0x3543#define MT9M001_CHIP_ENABLE 0xF144 45#define MT9M001_MAX_WIDTH 128046#define MT9M001_MAX_HEIGHT 102447#define MT9M001_MIN_WIDTH 4848#define MT9M001_MIN_HEIGHT 3249#define MT9M001_COLUMN_SKIP 2050#define MT9M001_ROW_SKIP 1251#define MT9M001_DEFAULT_HBLANK 952#define MT9M001_DEFAULT_VBLANK 2553 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 extender77 */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 mutex mutex;97 struct v4l2_rect rect; /* Sensor window */98 struct clk *clk;99 struct gpio_desc *standby_gpio;100 struct gpio_desc *reset_gpio;101 const struct mt9m001_datafmt *fmt;102 const struct mt9m001_datafmt *fmts;103 int num_fmts;104 unsigned int total_h;105 unsigned short y_skip_top; /* Lines to skip at the top */106 struct media_pad pad;107};108 109static struct mt9m001 *to_mt9m001(const struct i2c_client *client)110{111 return container_of(i2c_get_clientdata(client), struct mt9m001, subdev);112}113 114static int reg_read(struct i2c_client *client, const u8 reg)115{116 return i2c_smbus_read_word_swapped(client, reg);117}118 119static int reg_write(struct i2c_client *client, const u8 reg,120 const u16 data)121{122 return i2c_smbus_write_word_swapped(client, reg, data);123}124 125static int reg_set(struct i2c_client *client, const u8 reg,126 const u16 data)127{128 int ret;129 130 ret = reg_read(client, reg);131 if (ret < 0)132 return ret;133 return reg_write(client, reg, ret | data);134}135 136static int reg_clear(struct i2c_client *client, const u8 reg,137 const u16 data)138{139 int ret;140 141 ret = reg_read(client, reg);142 if (ret < 0)143 return ret;144 return reg_write(client, reg, ret & ~data);145}146 147struct mt9m001_reg {148 u8 reg;149 u16 data;150};151 152static int multi_reg_write(struct i2c_client *client,153 const struct mt9m001_reg *regs, int num)154{155 int i;156 157 for (i = 0; i < num; i++) {158 int ret = reg_write(client, regs[i].reg, regs[i].data);159 160 if (ret)161 return ret;162 }163 164 return 0;165}166 167static int mt9m001_init(struct i2c_client *client)168{169 static const struct mt9m001_reg init_regs[] = {170 /*171 * Issue a soft reset. This returns all registers to their172 * default values.173 */174 { MT9M001_RESET, 1 },175 { MT9M001_RESET, 0 },176 /* Disable chip, synchronous option update */177 { MT9M001_OUTPUT_CONTROL, 0 }178 };179 180 dev_dbg(&client->dev, "%s\n", __func__);181 182 return multi_reg_write(client, init_regs, ARRAY_SIZE(init_regs));183}184 185static int mt9m001_apply_selection(struct v4l2_subdev *sd)186{187 struct i2c_client *client = v4l2_get_subdevdata(sd);188 struct mt9m001 *mt9m001 = to_mt9m001(client);189 const struct mt9m001_reg regs[] = {190 /* Blanking and start values - default... */191 { MT9M001_HORIZONTAL_BLANKING, MT9M001_DEFAULT_HBLANK },192 { MT9M001_VERTICAL_BLANKING, MT9M001_DEFAULT_VBLANK },193 /*194 * The caller provides a supported format, as verified per195 * call to .set_fmt(FORMAT_TRY).196 */197 { MT9M001_COLUMN_START, mt9m001->rect.left },198 { MT9M001_ROW_START, mt9m001->rect.top },199 { MT9M001_WINDOW_WIDTH, mt9m001->rect.width - 1 },200 { MT9M001_WINDOW_HEIGHT,201 mt9m001->rect.height + mt9m001->y_skip_top - 1 },202 };203 204 return multi_reg_write(client, regs, ARRAY_SIZE(regs));205}206 207static int mt9m001_s_stream(struct v4l2_subdev *sd, int enable)208{209 struct i2c_client *client = v4l2_get_subdevdata(sd);210 struct mt9m001 *mt9m001 = to_mt9m001(client);211 int ret = 0;212 213 mutex_lock(&mt9m001->mutex);214 215 if (enable) {216 ret = pm_runtime_resume_and_get(&client->dev);217 if (ret < 0)218 goto unlock;219 220 ret = mt9m001_apply_selection(sd);221 if (ret)222 goto put_unlock;223 224 ret = __v4l2_ctrl_handler_setup(&mt9m001->hdl);225 if (ret)226 goto put_unlock;227 228 /* Switch to master "normal" mode */229 ret = reg_write(client, MT9M001_OUTPUT_CONTROL, 2);230 if (ret < 0)231 goto put_unlock;232 } else {233 /* Switch to master stop sensor readout */234 reg_write(client, MT9M001_OUTPUT_CONTROL, 0);235 pm_runtime_put(&client->dev);236 }237 238 mutex_unlock(&mt9m001->mutex);239 240 return 0;241 242put_unlock:243 pm_runtime_put(&client->dev);244unlock:245 mutex_unlock(&mt9m001->mutex);246 247 return ret;248}249 250static int mt9m001_set_selection(struct v4l2_subdev *sd,251 struct v4l2_subdev_state *sd_state,252 struct v4l2_subdev_selection *sel)253{254 struct i2c_client *client = v4l2_get_subdevdata(sd);255 struct mt9m001 *mt9m001 = to_mt9m001(client);256 struct v4l2_rect rect = sel->r;257 258 if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||259 sel->target != V4L2_SEL_TGT_CROP)260 return -EINVAL;261 262 if (mt9m001->fmts == mt9m001_colour_fmts)263 /*264 * Bayer format - even number of rows for simplicity,265 * but let the user play with the top row.266 */267 rect.height = ALIGN(rect.height, 2);268 269 /* Datasheet requirement: see register description */270 rect.width = ALIGN(rect.width, 2);271 rect.left = ALIGN(rect.left, 2);272 273 rect.width = clamp_t(u32, rect.width, MT9M001_MIN_WIDTH,274 MT9M001_MAX_WIDTH);275 rect.left = clamp_t(u32, rect.left, MT9M001_COLUMN_SKIP,276 MT9M001_COLUMN_SKIP + MT9M001_MAX_WIDTH - rect.width);277 278 rect.height = clamp_t(u32, rect.height, MT9M001_MIN_HEIGHT,279 MT9M001_MAX_HEIGHT);280 rect.top = clamp_t(u32, rect.top, MT9M001_ROW_SKIP,281 MT9M001_ROW_SKIP + MT9M001_MAX_HEIGHT - rect.height);282 283 mt9m001->total_h = rect.height + mt9m001->y_skip_top +284 MT9M001_DEFAULT_VBLANK;285 286 mt9m001->rect = rect;287 288 return 0;289}290 291static int mt9m001_get_selection(struct v4l2_subdev *sd,292 struct v4l2_subdev_state *sd_state,293 struct v4l2_subdev_selection *sel)294{295 struct i2c_client *client = v4l2_get_subdevdata(sd);296 struct mt9m001 *mt9m001 = to_mt9m001(client);297 298 if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)299 return -EINVAL;300 301 switch (sel->target) {302 case V4L2_SEL_TGT_CROP_BOUNDS:303 sel->r.left = MT9M001_COLUMN_SKIP;304 sel->r.top = MT9M001_ROW_SKIP;305 sel->r.width = MT9M001_MAX_WIDTH;306 sel->r.height = MT9M001_MAX_HEIGHT;307 return 0;308 case V4L2_SEL_TGT_CROP:309 sel->r = mt9m001->rect;310 return 0;311 default:312 return -EINVAL;313 }314}315 316static int mt9m001_get_fmt(struct v4l2_subdev *sd,317 struct v4l2_subdev_state *sd_state,318 struct v4l2_subdev_format *format)319{320 struct i2c_client *client = v4l2_get_subdevdata(sd);321 struct mt9m001 *mt9m001 = to_mt9m001(client);322 struct v4l2_mbus_framefmt *mf = &format->format;323 324 if (format->pad)325 return -EINVAL;326 327 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {328 mf = v4l2_subdev_state_get_format(sd_state, 0);329 format->format = *mf;330 return 0;331 }332 333 mf->width = mt9m001->rect.width;334 mf->height = mt9m001->rect.height;335 mf->code = mt9m001->fmt->code;336 mf->colorspace = mt9m001->fmt->colorspace;337 mf->field = V4L2_FIELD_NONE;338 mf->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;339 mf->quantization = V4L2_QUANTIZATION_DEFAULT;340 mf->xfer_func = V4L2_XFER_FUNC_DEFAULT;341 342 return 0;343}344 345static int mt9m001_s_fmt(struct v4l2_subdev *sd,346 const struct mt9m001_datafmt *fmt,347 struct v4l2_mbus_framefmt *mf)348{349 struct i2c_client *client = v4l2_get_subdevdata(sd);350 struct mt9m001 *mt9m001 = to_mt9m001(client);351 struct v4l2_subdev_selection sel = {352 .which = V4L2_SUBDEV_FORMAT_ACTIVE,353 .target = V4L2_SEL_TGT_CROP,354 .r.left = mt9m001->rect.left,355 .r.top = mt9m001->rect.top,356 .r.width = mf->width,357 .r.height = mf->height,358 };359 int ret;360 361 /* No support for scaling so far, just crop. TODO: use skipping */362 ret = mt9m001_set_selection(sd, NULL, &sel);363 if (!ret) {364 mf->width = mt9m001->rect.width;365 mf->height = mt9m001->rect.height;366 mt9m001->fmt = fmt;367 mf->colorspace = fmt->colorspace;368 }369 370 return ret;371}372 373static int mt9m001_set_fmt(struct v4l2_subdev *sd,374 struct v4l2_subdev_state *sd_state,375 struct v4l2_subdev_format *format)376{377 struct v4l2_mbus_framefmt *mf = &format->format;378 struct i2c_client *client = v4l2_get_subdevdata(sd);379 struct mt9m001 *mt9m001 = to_mt9m001(client);380 const struct mt9m001_datafmt *fmt;381 382 if (format->pad)383 return -EINVAL;384 385 v4l_bound_align_image(&mf->width, MT9M001_MIN_WIDTH,386 MT9M001_MAX_WIDTH, 1,387 &mf->height, MT9M001_MIN_HEIGHT + mt9m001->y_skip_top,388 MT9M001_MAX_HEIGHT + mt9m001->y_skip_top, 0, 0);389 390 if (mt9m001->fmts == mt9m001_colour_fmts)391 mf->height = ALIGN(mf->height - 1, 2);392 393 fmt = mt9m001_find_datafmt(mf->code, mt9m001->fmts,394 mt9m001->num_fmts);395 if (!fmt) {396 fmt = mt9m001->fmt;397 mf->code = fmt->code;398 }399 400 mf->colorspace = fmt->colorspace;401 mf->field = V4L2_FIELD_NONE;402 mf->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;403 mf->quantization = V4L2_QUANTIZATION_DEFAULT;404 mf->xfer_func = V4L2_XFER_FUNC_DEFAULT;405 406 if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE)407 return mt9m001_s_fmt(sd, fmt, mf);408 *v4l2_subdev_state_get_format(sd_state, 0) = *mf;409 return 0;410}411 412#ifdef CONFIG_VIDEO_ADV_DEBUG413static int mt9m001_g_register(struct v4l2_subdev *sd,414 struct v4l2_dbg_register *reg)415{416 struct i2c_client *client = v4l2_get_subdevdata(sd);417 418 if (reg->reg > 0xff)419 return -EINVAL;420 421 reg->size = 2;422 reg->val = reg_read(client, reg->reg);423 424 if (reg->val > 0xffff)425 return -EIO;426 427 return 0;428}429 430static int mt9m001_s_register(struct v4l2_subdev *sd,431 const struct v4l2_dbg_register *reg)432{433 struct i2c_client *client = v4l2_get_subdevdata(sd);434 435 if (reg->reg > 0xff)436 return -EINVAL;437 438 if (reg_write(client, reg->reg, reg->val) < 0)439 return -EIO;440 441 return 0;442}443#endif444 445static int mt9m001_power_on(struct device *dev)446{447 struct i2c_client *client = to_i2c_client(dev);448 struct mt9m001 *mt9m001 = to_mt9m001(client);449 int ret;450 451 ret = clk_prepare_enable(mt9m001->clk);452 if (ret)453 return ret;454 455 if (mt9m001->standby_gpio) {456 gpiod_set_value_cansleep(mt9m001->standby_gpio, 0);457 usleep_range(1000, 2000);458 }459 460 if (mt9m001->reset_gpio) {461 gpiod_set_value_cansleep(mt9m001->reset_gpio, 1);462 usleep_range(1000, 2000);463 gpiod_set_value_cansleep(mt9m001->reset_gpio, 0);464 usleep_range(1000, 2000);465 }466 467 return 0;468}469 470static int mt9m001_power_off(struct device *dev)471{472 struct i2c_client *client = to_i2c_client(dev);473 struct mt9m001 *mt9m001 = to_mt9m001(client);474 475 gpiod_set_value_cansleep(mt9m001->standby_gpio, 1);476 clk_disable_unprepare(mt9m001->clk);477 478 return 0;479}480 481static int mt9m001_g_volatile_ctrl(struct v4l2_ctrl *ctrl)482{483 struct mt9m001 *mt9m001 = container_of(ctrl->handler,484 struct mt9m001, hdl);485 s32 min, max;486 487 switch (ctrl->id) {488 case V4L2_CID_EXPOSURE_AUTO:489 min = mt9m001->exposure->minimum;490 max = mt9m001->exposure->maximum;491 mt9m001->exposure->val =492 (524 + (mt9m001->total_h - 1) * (max - min)) / 1048 + min;493 break;494 }495 return 0;496}497 498static int mt9m001_s_ctrl(struct v4l2_ctrl *ctrl)499{500 struct mt9m001 *mt9m001 = container_of(ctrl->handler,501 struct mt9m001, hdl);502 struct v4l2_subdev *sd = &mt9m001->subdev;503 struct i2c_client *client = v4l2_get_subdevdata(sd);504 struct v4l2_ctrl *exp = mt9m001->exposure;505 int data;506 int ret;507 508 if (!pm_runtime_get_if_in_use(&client->dev))509 return 0;510 511 switch (ctrl->id) {512 case V4L2_CID_VFLIP:513 if (ctrl->val)514 ret = reg_set(client, MT9M001_READ_OPTIONS2, 0x8000);515 else516 ret = reg_clear(client, MT9M001_READ_OPTIONS2, 0x8000);517 break;518 519 case V4L2_CID_GAIN:520 /* See Datasheet Table 7, Gain settings. */521 if (ctrl->val <= ctrl->default_value) {522 /* Pack it into 0..1 step 0.125, register values 0..8 */523 unsigned long range = ctrl->default_value - ctrl->minimum;524 data = ((ctrl->val - (s32)ctrl->minimum) * 8 + range / 2) / range;525 526 dev_dbg(&client->dev, "Setting gain %d\n", data);527 ret = reg_write(client, MT9M001_GLOBAL_GAIN, data);528 } else {529 /* Pack it into 1.125..15 variable step, register values 9..67 */530 /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */531 unsigned long range = ctrl->maximum - ctrl->default_value - 1;532 unsigned long gain = ((ctrl->val - (s32)ctrl->default_value - 1) *533 111 + range / 2) / range + 9;534 535 if (gain <= 32)536 data = gain;537 else if (gain <= 64)538 data = ((gain - 32) * 16 + 16) / 32 + 80;539 else540 data = ((gain - 64) * 7 + 28) / 56 + 96;541 542 dev_dbg(&client->dev, "Setting gain from %d to %d\n",543 reg_read(client, MT9M001_GLOBAL_GAIN), data);544 ret = reg_write(client, MT9M001_GLOBAL_GAIN, data);545 }546 break;547 548 case V4L2_CID_EXPOSURE_AUTO:549 if (ctrl->val == V4L2_EXPOSURE_MANUAL) {550 unsigned long range = exp->maximum - exp->minimum;551 unsigned long shutter = ((exp->val - (s32)exp->minimum) * 1048 +552 range / 2) / range + 1;553 554 dev_dbg(&client->dev,555 "Setting shutter width from %d to %lu\n",556 reg_read(client, MT9M001_SHUTTER_WIDTH), shutter);557 ret = reg_write(client, MT9M001_SHUTTER_WIDTH, shutter);558 } else {559 mt9m001->total_h = mt9m001->rect.height +560 mt9m001->y_skip_top + MT9M001_DEFAULT_VBLANK;561 ret = reg_write(client, MT9M001_SHUTTER_WIDTH,562 mt9m001->total_h);563 }564 break;565 default:566 ret = -EINVAL;567 break;568 }569 570 pm_runtime_put(&client->dev);571 572 return ret;573}574 575/*576 * Interface active, can use i2c. If it fails, it can indeed mean, that577 * this wasn't our capture interface, so, we wait for the right one578 */579static int mt9m001_video_probe(struct i2c_client *client)580{581 struct mt9m001 *mt9m001 = to_mt9m001(client);582 s32 data;583 int ret;584 585 /* Enable the chip */586 data = reg_write(client, MT9M001_CHIP_ENABLE, 1);587 dev_dbg(&client->dev, "write: %d\n", data);588 589 /* Read out the chip version register */590 data = reg_read(client, MT9M001_CHIP_VERSION);591 592 /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */593 switch (data) {594 case 0x8411:595 case 0x8421:596 mt9m001->fmts = mt9m001_colour_fmts;597 mt9m001->num_fmts = ARRAY_SIZE(mt9m001_colour_fmts);598 break;599 case 0x8431:600 mt9m001->fmts = mt9m001_monochrome_fmts;601 mt9m001->num_fmts = ARRAY_SIZE(mt9m001_monochrome_fmts);602 break;603 default:604 dev_err(&client->dev,605 "No MT9M001 chip detected, register read %x\n", data);606 ret = -ENODEV;607 goto done;608 }609 610 mt9m001->fmt = &mt9m001->fmts[0];611 612 dev_info(&client->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,613 data == 0x8431 ? "C12STM" : "C12ST");614 615 ret = mt9m001_init(client);616 if (ret < 0) {617 dev_err(&client->dev, "Failed to initialise the camera\n");618 goto done;619 }620 621 /* mt9m001_init() has reset the chip, returning registers to defaults */622 ret = v4l2_ctrl_handler_setup(&mt9m001->hdl);623 624done:625 return ret;626}627 628static int mt9m001_g_skip_top_lines(struct v4l2_subdev *sd, u32 *lines)629{630 struct i2c_client *client = v4l2_get_subdevdata(sd);631 struct mt9m001 *mt9m001 = to_mt9m001(client);632 633 *lines = mt9m001->y_skip_top;634 635 return 0;636}637 638static const struct v4l2_ctrl_ops mt9m001_ctrl_ops = {639 .g_volatile_ctrl = mt9m001_g_volatile_ctrl,640 .s_ctrl = mt9m001_s_ctrl,641};642 643static const struct v4l2_subdev_core_ops mt9m001_subdev_core_ops = {644 .log_status = v4l2_ctrl_subdev_log_status,645 .subscribe_event = v4l2_ctrl_subdev_subscribe_event,646 .unsubscribe_event = v4l2_event_subdev_unsubscribe,647#ifdef CONFIG_VIDEO_ADV_DEBUG648 .g_register = mt9m001_g_register,649 .s_register = mt9m001_s_register,650#endif651};652 653static int mt9m001_init_state(struct v4l2_subdev *sd,654 struct v4l2_subdev_state *sd_state)655{656 struct i2c_client *client = v4l2_get_subdevdata(sd);657 struct mt9m001 *mt9m001 = to_mt9m001(client);658 struct v4l2_mbus_framefmt *try_fmt =659 v4l2_subdev_state_get_format(sd_state, 0);660 661 try_fmt->width = MT9M001_MAX_WIDTH;662 try_fmt->height = MT9M001_MAX_HEIGHT;663 try_fmt->code = mt9m001->fmts[0].code;664 try_fmt->colorspace = mt9m001->fmts[0].colorspace;665 try_fmt->field = V4L2_FIELD_NONE;666 try_fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;667 try_fmt->quantization = V4L2_QUANTIZATION_DEFAULT;668 try_fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT;669 670 return 0;671}672 673static int mt9m001_enum_mbus_code(struct v4l2_subdev *sd,674 struct v4l2_subdev_state *sd_state,675 struct v4l2_subdev_mbus_code_enum *code)676{677 struct i2c_client *client = v4l2_get_subdevdata(sd);678 struct mt9m001 *mt9m001 = to_mt9m001(client);679 680 if (code->pad || code->index >= mt9m001->num_fmts)681 return -EINVAL;682 683 code->code = mt9m001->fmts[code->index].code;684 return 0;685}686 687static int mt9m001_get_mbus_config(struct v4l2_subdev *sd,688 unsigned int pad,689 struct v4l2_mbus_config *cfg)690{691 /* MT9M001 has all capture_format parameters fixed */692 cfg->type = V4L2_MBUS_PARALLEL;693 cfg->bus.parallel.flags = V4L2_MBUS_PCLK_SAMPLE_FALLING |694 V4L2_MBUS_HSYNC_ACTIVE_HIGH |695 V4L2_MBUS_VSYNC_ACTIVE_HIGH |696 V4L2_MBUS_DATA_ACTIVE_HIGH |697 V4L2_MBUS_MASTER;698 699 return 0;700}701 702static const struct v4l2_subdev_video_ops mt9m001_subdev_video_ops = {703 .s_stream = mt9m001_s_stream,704};705 706static const struct v4l2_subdev_sensor_ops mt9m001_subdev_sensor_ops = {707 .g_skip_top_lines = mt9m001_g_skip_top_lines,708};709 710static const struct v4l2_subdev_pad_ops mt9m001_subdev_pad_ops = {711 .enum_mbus_code = mt9m001_enum_mbus_code,712 .get_selection = mt9m001_get_selection,713 .set_selection = mt9m001_set_selection,714 .get_fmt = mt9m001_get_fmt,715 .set_fmt = mt9m001_set_fmt,716 .get_mbus_config = mt9m001_get_mbus_config,717};718 719static const struct v4l2_subdev_ops mt9m001_subdev_ops = {720 .core = &mt9m001_subdev_core_ops,721 .video = &mt9m001_subdev_video_ops,722 .sensor = &mt9m001_subdev_sensor_ops,723 .pad = &mt9m001_subdev_pad_ops,724};725 726static const struct v4l2_subdev_internal_ops mt9m001_internal_ops = {727 .init_state = mt9m001_init_state,728};729 730static int mt9m001_probe(struct i2c_client *client)731{732 struct mt9m001 *mt9m001;733 struct i2c_adapter *adapter = client->adapter;734 int ret;735 736 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {737 dev_warn(&adapter->dev,738 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");739 return -EIO;740 }741 742 mt9m001 = devm_kzalloc(&client->dev, sizeof(*mt9m001), GFP_KERNEL);743 if (!mt9m001)744 return -ENOMEM;745 746 mt9m001->clk = devm_clk_get(&client->dev, NULL);747 if (IS_ERR(mt9m001->clk))748 return PTR_ERR(mt9m001->clk);749 750 mt9m001->standby_gpio = devm_gpiod_get_optional(&client->dev, "standby",751 GPIOD_OUT_LOW);752 if (IS_ERR(mt9m001->standby_gpio))753 return PTR_ERR(mt9m001->standby_gpio);754 755 mt9m001->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",756 GPIOD_OUT_LOW);757 if (IS_ERR(mt9m001->reset_gpio))758 return PTR_ERR(mt9m001->reset_gpio);759 760 v4l2_i2c_subdev_init(&mt9m001->subdev, client, &mt9m001_subdev_ops);761 mt9m001->subdev.internal_ops = &mt9m001_internal_ops;762 mt9m001->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |763 V4L2_SUBDEV_FL_HAS_EVENTS;764 v4l2_ctrl_handler_init(&mt9m001->hdl, 4);765 v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,766 V4L2_CID_VFLIP, 0, 1, 1, 0);767 v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,768 V4L2_CID_GAIN, 0, 127, 1, 64);769 mt9m001->exposure = v4l2_ctrl_new_std(&mt9m001->hdl, &mt9m001_ctrl_ops,770 V4L2_CID_EXPOSURE, 1, 255, 1, 255);771 /*772 * Simulated autoexposure. If enabled, we calculate shutter width773 * ourselves in the driver based on vertical blanking and frame width774 */775 mt9m001->autoexposure = v4l2_ctrl_new_std_menu(&mt9m001->hdl,776 &mt9m001_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,777 V4L2_EXPOSURE_AUTO);778 mt9m001->subdev.ctrl_handler = &mt9m001->hdl;779 if (mt9m001->hdl.error)780 return mt9m001->hdl.error;781 782 v4l2_ctrl_auto_cluster(2, &mt9m001->autoexposure,783 V4L2_EXPOSURE_MANUAL, true);784 785 mutex_init(&mt9m001->mutex);786 mt9m001->hdl.lock = &mt9m001->mutex;787 788 /* Second stage probe - when a capture adapter is there */789 mt9m001->y_skip_top = 0;790 mt9m001->rect.left = MT9M001_COLUMN_SKIP;791 mt9m001->rect.top = MT9M001_ROW_SKIP;792 mt9m001->rect.width = MT9M001_MAX_WIDTH;793 mt9m001->rect.height = MT9M001_MAX_HEIGHT;794 795 ret = mt9m001_power_on(&client->dev);796 if (ret)797 goto error_hdl_free;798 799 pm_runtime_set_active(&client->dev);800 pm_runtime_enable(&client->dev);801 802 ret = mt9m001_video_probe(client);803 if (ret)804 goto error_power_off;805 806 mt9m001->pad.flags = MEDIA_PAD_FL_SOURCE;807 mt9m001->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR;808 ret = media_entity_pads_init(&mt9m001->subdev.entity, 1, &mt9m001->pad);809 if (ret)810 goto error_power_off;811 812 ret = v4l2_async_register_subdev(&mt9m001->subdev);813 if (ret)814 goto error_entity_cleanup;815 816 pm_runtime_idle(&client->dev);817 818 return 0;819 820error_entity_cleanup:821 media_entity_cleanup(&mt9m001->subdev.entity);822error_power_off:823 pm_runtime_disable(&client->dev);824 pm_runtime_set_suspended(&client->dev);825 mt9m001_power_off(&client->dev);826 827error_hdl_free:828 v4l2_ctrl_handler_free(&mt9m001->hdl);829 mutex_destroy(&mt9m001->mutex);830 831 return ret;832}833 834static void mt9m001_remove(struct i2c_client *client)835{836 struct mt9m001 *mt9m001 = to_mt9m001(client);837 838 /*839 * As it increments RPM usage_count even on errors, we don't need to840 * check the returned code here.841 */842 pm_runtime_get_sync(&client->dev);843 844 v4l2_async_unregister_subdev(&mt9m001->subdev);845 media_entity_cleanup(&mt9m001->subdev.entity);846 847 pm_runtime_disable(&client->dev);848 pm_runtime_set_suspended(&client->dev);849 pm_runtime_put_noidle(&client->dev);850 mt9m001_power_off(&client->dev);851 852 v4l2_ctrl_handler_free(&mt9m001->hdl);853 mutex_destroy(&mt9m001->mutex);854}855 856static const struct i2c_device_id mt9m001_id[] = {857 { "mt9m001" },858 { }859};860MODULE_DEVICE_TABLE(i2c, mt9m001_id);861 862static const struct dev_pm_ops mt9m001_pm_ops = {863 SET_RUNTIME_PM_OPS(mt9m001_power_off, mt9m001_power_on, NULL)864};865 866static const struct of_device_id mt9m001_of_match[] = {867 { .compatible = "onnn,mt9m001", },868 { /* sentinel */ },869};870MODULE_DEVICE_TABLE(of, mt9m001_of_match);871 872static struct i2c_driver mt9m001_i2c_driver = {873 .driver = {874 .name = "mt9m001",875 .pm = &mt9m001_pm_ops,876 .of_match_table = mt9m001_of_match,877 },878 .probe = mt9m001_probe,879 .remove = mt9m001_remove,880 .id_table = mt9m001_id,881};882 883module_i2c_driver(mt9m001_i2c_driver);884 885MODULE_DESCRIPTION("Micron MT9M001 Camera driver");886MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");887MODULE_LICENSE("GPL v2");888