drivers/media/i2c/mt9m001.c

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