Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Copyright (C) 2021 Intel Corporation
0003 
0004 #include <linux/acpi.h>
0005 #include <linux/delay.h>
0006 #include <linux/i2c.h>
0007 #include <linux/module.h>
0008 #include <linux/pm_runtime.h>
0009 #include <media/v4l2-ctrls.h>
0010 #include <media/v4l2-device.h>
0011 #include <asm/unaligned.h>
0012 
0013 #define IMX208_REG_MODE_SELECT      0x0100
0014 #define IMX208_MODE_STANDBY     0x00
0015 #define IMX208_MODE_STREAMING       0x01
0016 
0017 /* Chip ID */
0018 #define IMX208_REG_CHIP_ID      0x0000
0019 #define IMX208_CHIP_ID          0x0208
0020 
0021 /* V_TIMING internal */
0022 #define IMX208_REG_VTS          0x0340
0023 #define IMX208_VTS_60FPS        0x0472
0024 #define IMX208_VTS_BINNING      0x0239
0025 #define IMX208_VTS_60FPS_MIN        0x0458
0026 #define IMX208_VTS_BINNING_MIN      0x0230
0027 #define IMX208_VTS_MAX          0xffff
0028 
0029 /* HBLANK control - read only */
0030 #define IMX208_PPL_384MHZ       2248
0031 #define IMX208_PPL_96MHZ        2248
0032 
0033 /* Exposure control */
0034 #define IMX208_REG_EXPOSURE     0x0202
0035 #define IMX208_EXPOSURE_MIN     4
0036 #define IMX208_EXPOSURE_STEP        1
0037 #define IMX208_EXPOSURE_DEFAULT     0x190
0038 #define IMX208_EXPOSURE_MAX     65535
0039 
0040 /* Analog gain control */
0041 #define IMX208_REG_ANALOG_GAIN      0x0204
0042 #define IMX208_ANA_GAIN_MIN     0
0043 #define IMX208_ANA_GAIN_MAX     0x00e0
0044 #define IMX208_ANA_GAIN_STEP        1
0045 #define IMX208_ANA_GAIN_DEFAULT     0x0
0046 
0047 /* Digital gain control */
0048 #define IMX208_REG_GR_DIGITAL_GAIN  0x020e
0049 #define IMX208_REG_R_DIGITAL_GAIN   0x0210
0050 #define IMX208_REG_B_DIGITAL_GAIN   0x0212
0051 #define IMX208_REG_GB_DIGITAL_GAIN  0x0214
0052 #define IMX208_DIGITAL_GAIN_SHIFT   8
0053 
0054 /* Orientation */
0055 #define IMX208_REG_ORIENTATION_CONTROL  0x0101
0056 
0057 /* Test Pattern Control */
0058 #define IMX208_REG_TEST_PATTERN_MODE    0x0600
0059 #define IMX208_TEST_PATTERN_DISABLE 0x0
0060 #define IMX208_TEST_PATTERN_SOLID_COLOR 0x1
0061 #define IMX208_TEST_PATTERN_COLOR_BARS  0x2
0062 #define IMX208_TEST_PATTERN_GREY_COLOR  0x3
0063 #define IMX208_TEST_PATTERN_PN9     0x4
0064 #define IMX208_TEST_PATTERN_FIX_1   0x100
0065 #define IMX208_TEST_PATTERN_FIX_2   0x101
0066 #define IMX208_TEST_PATTERN_FIX_3   0x102
0067 #define IMX208_TEST_PATTERN_FIX_4   0x103
0068 #define IMX208_TEST_PATTERN_FIX_5   0x104
0069 #define IMX208_TEST_PATTERN_FIX_6   0x105
0070 
0071 /* OTP Access */
0072 #define IMX208_OTP_BASE         0x3500
0073 #define IMX208_OTP_SIZE         40
0074 
0075 struct imx208_reg {
0076     u16 address;
0077     u8 val;
0078 };
0079 
0080 struct imx208_reg_list {
0081     u32 num_of_regs;
0082     const struct imx208_reg *regs;
0083 };
0084 
0085 /* Link frequency config */
0086 struct imx208_link_freq_config {
0087     u32 pixels_per_line;
0088 
0089     /* PLL registers for this link frequency */
0090     struct imx208_reg_list reg_list;
0091 };
0092 
0093 /* Mode : resolution and related config&values */
0094 struct imx208_mode {
0095     /* Frame width */
0096     u32 width;
0097     /* Frame height */
0098     u32 height;
0099 
0100     /* V-timing */
0101     u32 vts_def;
0102     u32 vts_min;
0103 
0104     /* Index of Link frequency config to be used */
0105     u32 link_freq_index;
0106     /* Default register values */
0107     struct imx208_reg_list reg_list;
0108 };
0109 
0110 static const struct imx208_reg pll_ctrl_reg[] = {
0111     {0x0305, 0x02},
0112     {0x0307, 0x50},
0113     {0x303C, 0x3C},
0114 };
0115 
0116 static const struct imx208_reg mode_1936x1096_60fps_regs[] = {
0117     {0x0340, 0x04},
0118     {0x0341, 0x72},
0119     {0x0342, 0x04},
0120     {0x0343, 0x64},
0121     {0x034C, 0x07},
0122     {0x034D, 0x90},
0123     {0x034E, 0x04},
0124     {0x034F, 0x48},
0125     {0x0381, 0x01},
0126     {0x0383, 0x01},
0127     {0x0385, 0x01},
0128     {0x0387, 0x01},
0129     {0x3048, 0x00},
0130     {0x3050, 0x01},
0131     {0x30D5, 0x00},
0132     {0x3301, 0x00},
0133     {0x3318, 0x62},
0134     {0x0202, 0x01},
0135     {0x0203, 0x90},
0136     {0x0205, 0x00},
0137 };
0138 
0139 static const struct imx208_reg mode_968_548_60fps_regs[] = {
0140     {0x0340, 0x02},
0141     {0x0341, 0x39},
0142     {0x0342, 0x08},
0143     {0x0343, 0xC8},
0144     {0x034C, 0x03},
0145     {0x034D, 0xC8},
0146     {0x034E, 0x02},
0147     {0x034F, 0x24},
0148     {0x0381, 0x01},
0149     {0x0383, 0x03},
0150     {0x0385, 0x01},
0151     {0x0387, 0x03},
0152     {0x3048, 0x01},
0153     {0x3050, 0x02},
0154     {0x30D5, 0x03},
0155     {0x3301, 0x10},
0156     {0x3318, 0x75},
0157     {0x0202, 0x01},
0158     {0x0203, 0x90},
0159     {0x0205, 0x00},
0160 };
0161 
0162 static const s64 imx208_discrete_digital_gain[] = {
0163     1, 2, 4, 8, 16,
0164 };
0165 
0166 static const char * const imx208_test_pattern_menu[] = {
0167     "Disabled",
0168     "Solid Color",
0169     "100% Color Bar",
0170     "Fade to Grey Color Bar",
0171     "PN9",
0172     "Fixed Pattern1",
0173     "Fixed Pattern2",
0174     "Fixed Pattern3",
0175     "Fixed Pattern4",
0176     "Fixed Pattern5",
0177     "Fixed Pattern6"
0178 };
0179 
0180 static const int imx208_test_pattern_val[] = {
0181     IMX208_TEST_PATTERN_DISABLE,
0182     IMX208_TEST_PATTERN_SOLID_COLOR,
0183     IMX208_TEST_PATTERN_COLOR_BARS,
0184     IMX208_TEST_PATTERN_GREY_COLOR,
0185     IMX208_TEST_PATTERN_PN9,
0186     IMX208_TEST_PATTERN_FIX_1,
0187     IMX208_TEST_PATTERN_FIX_2,
0188     IMX208_TEST_PATTERN_FIX_3,
0189     IMX208_TEST_PATTERN_FIX_4,
0190     IMX208_TEST_PATTERN_FIX_5,
0191     IMX208_TEST_PATTERN_FIX_6,
0192 };
0193 
0194 /* Configurations for supported link frequencies */
0195 #define IMX208_MHZ          (1000 * 1000ULL)
0196 #define IMX208_LINK_FREQ_384MHZ     (384ULL * IMX208_MHZ)
0197 #define IMX208_LINK_FREQ_96MHZ      (96ULL * IMX208_MHZ)
0198 
0199 #define IMX208_DATA_RATE_DOUBLE     2
0200 #define IMX208_NUM_OF_LANES     2
0201 #define IMX208_PIXEL_BITS       10
0202 
0203 enum {
0204     IMX208_LINK_FREQ_384MHZ_INDEX,
0205     IMX208_LINK_FREQ_96MHZ_INDEX,
0206 };
0207 
0208 /*
0209  * pixel_rate = link_freq * data-rate * nr_of_lanes / bits_per_sample
0210  * data rate => double data rate; number of lanes => 2; bits per pixel => 10
0211  */
0212 static u64 link_freq_to_pixel_rate(u64 f)
0213 {
0214     f *= IMX208_DATA_RATE_DOUBLE * IMX208_NUM_OF_LANES;
0215     do_div(f, IMX208_PIXEL_BITS);
0216 
0217     return f;
0218 }
0219 
0220 /* Menu items for LINK_FREQ V4L2 control */
0221 static const s64 link_freq_menu_items[] = {
0222     [IMX208_LINK_FREQ_384MHZ_INDEX] = IMX208_LINK_FREQ_384MHZ,
0223     [IMX208_LINK_FREQ_96MHZ_INDEX] = IMX208_LINK_FREQ_96MHZ,
0224 };
0225 
0226 /* Link frequency configs */
0227 static const struct imx208_link_freq_config link_freq_configs[] = {
0228     [IMX208_LINK_FREQ_384MHZ_INDEX] = {
0229         .pixels_per_line = IMX208_PPL_384MHZ,
0230         .reg_list = {
0231             .num_of_regs = ARRAY_SIZE(pll_ctrl_reg),
0232             .regs = pll_ctrl_reg,
0233         }
0234     },
0235     [IMX208_LINK_FREQ_96MHZ_INDEX] = {
0236         .pixels_per_line = IMX208_PPL_96MHZ,
0237         .reg_list = {
0238             .num_of_regs = ARRAY_SIZE(pll_ctrl_reg),
0239             .regs = pll_ctrl_reg,
0240         }
0241     },
0242 };
0243 
0244 /* Mode configs */
0245 static const struct imx208_mode supported_modes[] = {
0246     {
0247         .width = 1936,
0248         .height = 1096,
0249         .vts_def = IMX208_VTS_60FPS,
0250         .vts_min = IMX208_VTS_60FPS_MIN,
0251         .reg_list = {
0252             .num_of_regs = ARRAY_SIZE(mode_1936x1096_60fps_regs),
0253             .regs = mode_1936x1096_60fps_regs,
0254         },
0255         .link_freq_index = IMX208_LINK_FREQ_384MHZ_INDEX,
0256     },
0257     {
0258         .width = 968,
0259         .height = 548,
0260         .vts_def = IMX208_VTS_BINNING,
0261         .vts_min = IMX208_VTS_BINNING_MIN,
0262         .reg_list = {
0263             .num_of_regs = ARRAY_SIZE(mode_968_548_60fps_regs),
0264             .regs = mode_968_548_60fps_regs,
0265         },
0266         .link_freq_index = IMX208_LINK_FREQ_96MHZ_INDEX,
0267     },
0268 };
0269 
0270 struct imx208 {
0271     struct v4l2_subdev sd;
0272     struct media_pad pad;
0273 
0274     struct v4l2_ctrl_handler ctrl_handler;
0275     /* V4L2 Controls */
0276     struct v4l2_ctrl *link_freq;
0277     struct v4l2_ctrl *pixel_rate;
0278     struct v4l2_ctrl *vblank;
0279     struct v4l2_ctrl *hblank;
0280     struct v4l2_ctrl *vflip;
0281     struct v4l2_ctrl *hflip;
0282 
0283     /* Current mode */
0284     const struct imx208_mode *cur_mode;
0285 
0286     /*
0287      * Mutex for serialized access:
0288      * Protect sensor set pad format and start/stop streaming safely.
0289      * Protect access to sensor v4l2 controls.
0290      */
0291     struct mutex imx208_mx;
0292 
0293     /* Streaming on/off */
0294     bool streaming;
0295 
0296     /* OTP data */
0297     bool otp_read;
0298     char otp_data[IMX208_OTP_SIZE];
0299 
0300     /* True if the device has been identified */
0301     bool identified;
0302 };
0303 
0304 static inline struct imx208 *to_imx208(struct v4l2_subdev *_sd)
0305 {
0306     return container_of(_sd, struct imx208, sd);
0307 }
0308 
0309 /* Get bayer order based on flip setting. */
0310 static u32 imx208_get_format_code(struct imx208 *imx208)
0311 {
0312     /*
0313      * Only one bayer order is supported.
0314      * It depends on the flip settings.
0315      */
0316     static const u32 codes[2][2] = {
0317         { MEDIA_BUS_FMT_SRGGB10_1X10, MEDIA_BUS_FMT_SGRBG10_1X10, },
0318         { MEDIA_BUS_FMT_SGBRG10_1X10, MEDIA_BUS_FMT_SBGGR10_1X10, },
0319     };
0320 
0321     return codes[imx208->vflip->val][imx208->hflip->val];
0322 }
0323 
0324 /* Read registers up to 4 at a time */
0325 static int imx208_read_reg(struct imx208 *imx208, u16 reg, u32 len, u32 *val)
0326 {
0327     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0328     struct i2c_msg msgs[2];
0329     u8 addr_buf[2] = { reg >> 8, reg & 0xff };
0330     u8 data_buf[4] = { 0, };
0331     int ret;
0332 
0333     if (len > 4)
0334         return -EINVAL;
0335 
0336     /* Write register address */
0337     msgs[0].addr = client->addr;
0338     msgs[0].flags = 0;
0339     msgs[0].len = ARRAY_SIZE(addr_buf);
0340     msgs[0].buf = addr_buf;
0341 
0342     /* Read data from register */
0343     msgs[1].addr = client->addr;
0344     msgs[1].flags = I2C_M_RD;
0345     msgs[1].len = len;
0346     msgs[1].buf = &data_buf[4 - len];
0347 
0348     ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
0349     if (ret != ARRAY_SIZE(msgs))
0350         return -EIO;
0351 
0352     *val = get_unaligned_be32(data_buf);
0353 
0354     return 0;
0355 }
0356 
0357 /* Write registers up to 4 at a time */
0358 static int imx208_write_reg(struct imx208 *imx208, u16 reg, u32 len, u32 val)
0359 {
0360     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0361     u8 buf[6];
0362 
0363     if (len > 4)
0364         return -EINVAL;
0365 
0366     put_unaligned_be16(reg, buf);
0367     put_unaligned_be32(val << (8 * (4 - len)), buf + 2);
0368     if (i2c_master_send(client, buf, len + 2) != len + 2)
0369         return -EIO;
0370 
0371     return 0;
0372 }
0373 
0374 /* Write a list of registers */
0375 static int imx208_write_regs(struct imx208 *imx208,
0376                  const struct imx208_reg *regs, u32 len)
0377 {
0378     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0379     unsigned int i;
0380     int ret;
0381 
0382     for (i = 0; i < len; i++) {
0383         ret = imx208_write_reg(imx208, regs[i].address, 1,
0384                        regs[i].val);
0385         if (ret) {
0386             dev_err_ratelimited(&client->dev,
0387                         "Failed to write reg 0x%4.4x. error = %d\n",
0388                         regs[i].address, ret);
0389 
0390             return ret;
0391         }
0392     }
0393 
0394     return 0;
0395 }
0396 
0397 /* Open sub-device */
0398 static int imx208_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
0399 {
0400     struct v4l2_mbus_framefmt *try_fmt =
0401         v4l2_subdev_get_try_format(sd, fh->state, 0);
0402 
0403     /* Initialize try_fmt */
0404     try_fmt->width = supported_modes[0].width;
0405     try_fmt->height = supported_modes[0].height;
0406     try_fmt->code = MEDIA_BUS_FMT_SRGGB10_1X10;
0407     try_fmt->field = V4L2_FIELD_NONE;
0408 
0409     return 0;
0410 }
0411 
0412 static int imx208_update_digital_gain(struct imx208 *imx208, u32 len, u32 val)
0413 {
0414     int ret;
0415 
0416     val = imx208_discrete_digital_gain[val] << IMX208_DIGITAL_GAIN_SHIFT;
0417 
0418     ret = imx208_write_reg(imx208, IMX208_REG_GR_DIGITAL_GAIN, 2, val);
0419     if (ret)
0420         return ret;
0421 
0422     ret = imx208_write_reg(imx208, IMX208_REG_GB_DIGITAL_GAIN, 2, val);
0423     if (ret)
0424         return ret;
0425 
0426     ret = imx208_write_reg(imx208, IMX208_REG_R_DIGITAL_GAIN, 2, val);
0427     if (ret)
0428         return ret;
0429 
0430     return imx208_write_reg(imx208, IMX208_REG_B_DIGITAL_GAIN, 2, val);
0431 }
0432 
0433 static int imx208_set_ctrl(struct v4l2_ctrl *ctrl)
0434 {
0435     struct imx208 *imx208 =
0436         container_of(ctrl->handler, struct imx208, ctrl_handler);
0437     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0438     int ret;
0439 
0440     /*
0441      * Applying V4L2 control value only happens
0442      * when power is up for streaming
0443      */
0444     if (!pm_runtime_get_if_in_use(&client->dev))
0445         return 0;
0446 
0447     switch (ctrl->id) {
0448     case V4L2_CID_ANALOGUE_GAIN:
0449         ret = imx208_write_reg(imx208, IMX208_REG_ANALOG_GAIN,
0450                        2, ctrl->val);
0451         break;
0452     case V4L2_CID_EXPOSURE:
0453         ret = imx208_write_reg(imx208, IMX208_REG_EXPOSURE,
0454                        2, ctrl->val);
0455         break;
0456     case V4L2_CID_DIGITAL_GAIN:
0457         ret = imx208_update_digital_gain(imx208, 2, ctrl->val);
0458         break;
0459     case V4L2_CID_VBLANK:
0460         /* Update VTS that meets expected vertical blanking */
0461         ret = imx208_write_reg(imx208, IMX208_REG_VTS, 2,
0462                        imx208->cur_mode->height + ctrl->val);
0463         break;
0464     case V4L2_CID_TEST_PATTERN:
0465         ret = imx208_write_reg(imx208, IMX208_REG_TEST_PATTERN_MODE,
0466                        2, imx208_test_pattern_val[ctrl->val]);
0467         break;
0468     case V4L2_CID_HFLIP:
0469     case V4L2_CID_VFLIP:
0470         ret = imx208_write_reg(imx208, IMX208_REG_ORIENTATION_CONTROL,
0471                        1,
0472                        imx208->hflip->val |
0473                        imx208->vflip->val << 1);
0474         break;
0475     default:
0476         ret = -EINVAL;
0477         dev_err(&client->dev,
0478             "ctrl(id:0x%x,val:0x%x) is not handled\n",
0479             ctrl->id, ctrl->val);
0480         break;
0481     }
0482 
0483     pm_runtime_put(&client->dev);
0484 
0485     return ret;
0486 }
0487 
0488 static const struct v4l2_ctrl_ops imx208_ctrl_ops = {
0489     .s_ctrl = imx208_set_ctrl,
0490 };
0491 
0492 static const struct v4l2_ctrl_config imx208_digital_gain_control = {
0493     .ops = &imx208_ctrl_ops,
0494     .id = V4L2_CID_DIGITAL_GAIN,
0495     .name = "Digital Gain",
0496     .type = V4L2_CTRL_TYPE_INTEGER_MENU,
0497     .min = 0,
0498     .max = ARRAY_SIZE(imx208_discrete_digital_gain) - 1,
0499     .step = 0,
0500     .def = 0,
0501     .menu_skip_mask = 0,
0502     .qmenu_int = imx208_discrete_digital_gain,
0503 };
0504 
0505 static int imx208_enum_mbus_code(struct v4l2_subdev *sd,
0506                  struct v4l2_subdev_state *sd_state,
0507                  struct v4l2_subdev_mbus_code_enum *code)
0508 {
0509     struct imx208 *imx208 = to_imx208(sd);
0510 
0511     if (code->index > 0)
0512         return -EINVAL;
0513 
0514     code->code = imx208_get_format_code(imx208);
0515 
0516     return 0;
0517 }
0518 
0519 static int imx208_enum_frame_size(struct v4l2_subdev *sd,
0520                   struct v4l2_subdev_state *sd_state,
0521                   struct v4l2_subdev_frame_size_enum *fse)
0522 {
0523     struct imx208 *imx208 = to_imx208(sd);
0524 
0525     if (fse->index >= ARRAY_SIZE(supported_modes))
0526         return -EINVAL;
0527 
0528     if (fse->code != imx208_get_format_code(imx208))
0529         return -EINVAL;
0530 
0531     fse->min_width = supported_modes[fse->index].width;
0532     fse->max_width = fse->min_width;
0533     fse->min_height = supported_modes[fse->index].height;
0534     fse->max_height = fse->min_height;
0535 
0536     return 0;
0537 }
0538 
0539 static void imx208_mode_to_pad_format(struct imx208 *imx208,
0540                       const struct imx208_mode *mode,
0541                       struct v4l2_subdev_format *fmt)
0542 {
0543     fmt->format.width = mode->width;
0544     fmt->format.height = mode->height;
0545     fmt->format.code = imx208_get_format_code(imx208);
0546     fmt->format.field = V4L2_FIELD_NONE;
0547 }
0548 
0549 static int __imx208_get_pad_format(struct imx208 *imx208,
0550                    struct v4l2_subdev_state *sd_state,
0551                    struct v4l2_subdev_format *fmt)
0552 {
0553     if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
0554         fmt->format = *v4l2_subdev_get_try_format(&imx208->sd,
0555                               sd_state,
0556                               fmt->pad);
0557     else
0558         imx208_mode_to_pad_format(imx208, imx208->cur_mode, fmt);
0559 
0560     return 0;
0561 }
0562 
0563 static int imx208_get_pad_format(struct v4l2_subdev *sd,
0564                  struct v4l2_subdev_state *sd_state,
0565                  struct v4l2_subdev_format *fmt)
0566 {
0567     struct imx208 *imx208 = to_imx208(sd);
0568     int ret;
0569 
0570     mutex_lock(&imx208->imx208_mx);
0571     ret = __imx208_get_pad_format(imx208, sd_state, fmt);
0572     mutex_unlock(&imx208->imx208_mx);
0573 
0574     return ret;
0575 }
0576 
0577 static int imx208_set_pad_format(struct v4l2_subdev *sd,
0578                  struct v4l2_subdev_state *sd_state,
0579                  struct v4l2_subdev_format *fmt)
0580 {
0581     struct imx208 *imx208 = to_imx208(sd);
0582     const struct imx208_mode *mode;
0583     s32 vblank_def;
0584     s32 vblank_min;
0585     s64 h_blank;
0586     s64 pixel_rate;
0587     s64 link_freq;
0588 
0589     mutex_lock(&imx208->imx208_mx);
0590 
0591     fmt->format.code = imx208_get_format_code(imx208);
0592     mode = v4l2_find_nearest_size(supported_modes,
0593                       ARRAY_SIZE(supported_modes), width, height,
0594                       fmt->format.width, fmt->format.height);
0595     imx208_mode_to_pad_format(imx208, mode, fmt);
0596     if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
0597         *v4l2_subdev_get_try_format(sd, sd_state, fmt->pad) = fmt->format;
0598     } else {
0599         imx208->cur_mode = mode;
0600         __v4l2_ctrl_s_ctrl(imx208->link_freq, mode->link_freq_index);
0601         link_freq = link_freq_menu_items[mode->link_freq_index];
0602         pixel_rate = link_freq_to_pixel_rate(link_freq);
0603         __v4l2_ctrl_s_ctrl_int64(imx208->pixel_rate, pixel_rate);
0604         /* Update limits and set FPS to default */
0605         vblank_def = imx208->cur_mode->vts_def -
0606                  imx208->cur_mode->height;
0607         vblank_min = imx208->cur_mode->vts_min -
0608                  imx208->cur_mode->height;
0609         __v4l2_ctrl_modify_range(imx208->vblank, vblank_min,
0610                      IMX208_VTS_MAX - imx208->cur_mode->height,
0611                      1, vblank_def);
0612         __v4l2_ctrl_s_ctrl(imx208->vblank, vblank_def);
0613         h_blank =
0614             link_freq_configs[mode->link_freq_index].pixels_per_line
0615              - imx208->cur_mode->width;
0616         __v4l2_ctrl_modify_range(imx208->hblank, h_blank,
0617                      h_blank, 1, h_blank);
0618     }
0619 
0620     mutex_unlock(&imx208->imx208_mx);
0621 
0622     return 0;
0623 }
0624 
0625 static int imx208_identify_module(struct imx208 *imx208)
0626 {
0627     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0628     int ret;
0629     u32 val;
0630 
0631     if (imx208->identified)
0632         return 0;
0633 
0634     ret = imx208_read_reg(imx208, IMX208_REG_CHIP_ID,
0635                   2, &val);
0636     if (ret) {
0637         dev_err(&client->dev, "failed to read chip id %x\n",
0638             IMX208_CHIP_ID);
0639         return ret;
0640     }
0641 
0642     if (val != IMX208_CHIP_ID) {
0643         dev_err(&client->dev, "chip id mismatch: %x!=%x\n",
0644             IMX208_CHIP_ID, val);
0645         return -EIO;
0646     }
0647 
0648     imx208->identified = true;
0649 
0650     return 0;
0651 }
0652 
0653 /* Start streaming */
0654 static int imx208_start_streaming(struct imx208 *imx208)
0655 {
0656     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0657     const struct imx208_reg_list *reg_list;
0658     int ret, link_freq_index;
0659 
0660     ret = imx208_identify_module(imx208);
0661     if (ret)
0662         return ret;
0663 
0664     /* Setup PLL */
0665     link_freq_index = imx208->cur_mode->link_freq_index;
0666     reg_list = &link_freq_configs[link_freq_index].reg_list;
0667     ret = imx208_write_regs(imx208, reg_list->regs, reg_list->num_of_regs);
0668     if (ret) {
0669         dev_err(&client->dev, "%s failed to set plls\n", __func__);
0670         return ret;
0671     }
0672 
0673     /* Apply default values of current mode */
0674     reg_list = &imx208->cur_mode->reg_list;
0675     ret = imx208_write_regs(imx208, reg_list->regs, reg_list->num_of_regs);
0676     if (ret) {
0677         dev_err(&client->dev, "%s failed to set mode\n", __func__);
0678         return ret;
0679     }
0680 
0681     /* Apply customized values from user */
0682     ret =  __v4l2_ctrl_handler_setup(imx208->sd.ctrl_handler);
0683     if (ret)
0684         return ret;
0685 
0686     /* set stream on register */
0687     return imx208_write_reg(imx208, IMX208_REG_MODE_SELECT,
0688                 1, IMX208_MODE_STREAMING);
0689 }
0690 
0691 /* Stop streaming */
0692 static int imx208_stop_streaming(struct imx208 *imx208)
0693 {
0694     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0695     int ret;
0696 
0697     /* set stream off register */
0698     ret = imx208_write_reg(imx208, IMX208_REG_MODE_SELECT,
0699                    1, IMX208_MODE_STANDBY);
0700     if (ret)
0701         dev_err(&client->dev, "%s failed to set stream\n", __func__);
0702 
0703     /*
0704      * Return success even if it was an error, as there is nothing the
0705      * caller can do about it.
0706      */
0707     return 0;
0708 }
0709 
0710 static int imx208_set_stream(struct v4l2_subdev *sd, int enable)
0711 {
0712     struct imx208 *imx208 = to_imx208(sd);
0713     struct i2c_client *client = v4l2_get_subdevdata(sd);
0714     int ret = 0;
0715 
0716     mutex_lock(&imx208->imx208_mx);
0717     if (imx208->streaming == enable) {
0718         mutex_unlock(&imx208->imx208_mx);
0719         return 0;
0720     }
0721 
0722     if (enable) {
0723         ret = pm_runtime_get_sync(&client->dev);
0724         if (ret < 0)
0725             goto err_rpm_put;
0726 
0727         /*
0728          * Apply default & customized values
0729          * and then start streaming.
0730          */
0731         ret = imx208_start_streaming(imx208);
0732         if (ret)
0733             goto err_rpm_put;
0734     } else {
0735         imx208_stop_streaming(imx208);
0736         pm_runtime_put(&client->dev);
0737     }
0738 
0739     imx208->streaming = enable;
0740     mutex_unlock(&imx208->imx208_mx);
0741 
0742     /* vflip and hflip cannot change during streaming */
0743     v4l2_ctrl_grab(imx208->vflip, enable);
0744     v4l2_ctrl_grab(imx208->hflip, enable);
0745 
0746     return ret;
0747 
0748 err_rpm_put:
0749     pm_runtime_put(&client->dev);
0750     mutex_unlock(&imx208->imx208_mx);
0751 
0752     return ret;
0753 }
0754 
0755 static int __maybe_unused imx208_suspend(struct device *dev)
0756 {
0757     struct i2c_client *client = to_i2c_client(dev);
0758     struct v4l2_subdev *sd = i2c_get_clientdata(client);
0759     struct imx208 *imx208 = to_imx208(sd);
0760 
0761     if (imx208->streaming)
0762         imx208_stop_streaming(imx208);
0763 
0764     return 0;
0765 }
0766 
0767 static int __maybe_unused imx208_resume(struct device *dev)
0768 {
0769     struct i2c_client *client = to_i2c_client(dev);
0770     struct v4l2_subdev *sd = i2c_get_clientdata(client);
0771     struct imx208 *imx208 = to_imx208(sd);
0772     int ret;
0773 
0774     if (imx208->streaming) {
0775         ret = imx208_start_streaming(imx208);
0776         if (ret)
0777             goto error;
0778     }
0779 
0780     return 0;
0781 
0782 error:
0783     imx208_stop_streaming(imx208);
0784     imx208->streaming = 0;
0785 
0786     return ret;
0787 }
0788 
0789 /* Verify chip ID */
0790 static const struct v4l2_subdev_video_ops imx208_video_ops = {
0791     .s_stream = imx208_set_stream,
0792 };
0793 
0794 static const struct v4l2_subdev_pad_ops imx208_pad_ops = {
0795     .enum_mbus_code = imx208_enum_mbus_code,
0796     .get_fmt = imx208_get_pad_format,
0797     .set_fmt = imx208_set_pad_format,
0798     .enum_frame_size = imx208_enum_frame_size,
0799 };
0800 
0801 static const struct v4l2_subdev_ops imx208_subdev_ops = {
0802     .video = &imx208_video_ops,
0803     .pad = &imx208_pad_ops,
0804 };
0805 
0806 static const struct v4l2_subdev_internal_ops imx208_internal_ops = {
0807     .open = imx208_open,
0808 };
0809 
0810 static int imx208_read_otp(struct imx208 *imx208)
0811 {
0812     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0813     struct i2c_msg msgs[2];
0814     u8 addr_buf[2] = { IMX208_OTP_BASE >> 8, IMX208_OTP_BASE & 0xff };
0815     int ret = 0;
0816 
0817     mutex_lock(&imx208->imx208_mx);
0818 
0819     if (imx208->otp_read)
0820         goto out_unlock;
0821 
0822     ret = pm_runtime_get_sync(&client->dev);
0823     if (ret < 0) {
0824         pm_runtime_put_noidle(&client->dev);
0825         goto out_unlock;
0826     }
0827 
0828     ret = imx208_identify_module(imx208);
0829     if (ret)
0830         goto out_pm_put;
0831 
0832     /* Write register address */
0833     msgs[0].addr = client->addr;
0834     msgs[0].flags = 0;
0835     msgs[0].len = ARRAY_SIZE(addr_buf);
0836     msgs[0].buf = addr_buf;
0837 
0838     /* Read data from registers */
0839     msgs[1].addr = client->addr;
0840     msgs[1].flags = I2C_M_RD;
0841     msgs[1].len = sizeof(imx208->otp_data);
0842     msgs[1].buf = imx208->otp_data;
0843 
0844     ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
0845     if (ret == ARRAY_SIZE(msgs)) {
0846         imx208->otp_read = true;
0847         ret = 0;
0848     }
0849 
0850 out_pm_put:
0851     pm_runtime_put(&client->dev);
0852 
0853 out_unlock:
0854     mutex_unlock(&imx208->imx208_mx);
0855 
0856     return ret;
0857 }
0858 
0859 static ssize_t otp_read(struct file *filp, struct kobject *kobj,
0860             struct bin_attribute *bin_attr,
0861             char *buf, loff_t off, size_t count)
0862 {
0863     struct i2c_client *client = to_i2c_client(kobj_to_dev(kobj));
0864     struct v4l2_subdev *sd = i2c_get_clientdata(client);
0865     struct imx208 *imx208 = to_imx208(sd);
0866     int ret;
0867 
0868     ret = imx208_read_otp(imx208);
0869     if (ret)
0870         return ret;
0871 
0872     memcpy(buf, &imx208->otp_data[off], count);
0873     return count;
0874 }
0875 
0876 static const BIN_ATTR_RO(otp, IMX208_OTP_SIZE);
0877 
0878 /* Initialize control handlers */
0879 static int imx208_init_controls(struct imx208 *imx208)
0880 {
0881     struct i2c_client *client = v4l2_get_subdevdata(&imx208->sd);
0882     struct v4l2_ctrl_handler *ctrl_hdlr = &imx208->ctrl_handler;
0883     s64 exposure_max;
0884     s64 vblank_def;
0885     s64 vblank_min;
0886     s64 pixel_rate_min;
0887     s64 pixel_rate_max;
0888     int ret;
0889 
0890     ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8);
0891     if (ret)
0892         return ret;
0893 
0894     mutex_init(&imx208->imx208_mx);
0895     ctrl_hdlr->lock = &imx208->imx208_mx;
0896     imx208->link_freq =
0897         v4l2_ctrl_new_int_menu(ctrl_hdlr,
0898                        &imx208_ctrl_ops,
0899                        V4L2_CID_LINK_FREQ,
0900                        ARRAY_SIZE(link_freq_menu_items) - 1,
0901                        0, link_freq_menu_items);
0902 
0903     if (imx208->link_freq)
0904         imx208->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
0905 
0906     pixel_rate_max = link_freq_to_pixel_rate(link_freq_menu_items[0]);
0907     pixel_rate_min =
0908         link_freq_to_pixel_rate(link_freq_menu_items[ARRAY_SIZE(link_freq_menu_items) - 1]);
0909     /* By default, PIXEL_RATE is read only */
0910     imx208->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops,
0911                            V4L2_CID_PIXEL_RATE,
0912                            pixel_rate_min, pixel_rate_max,
0913                            1, pixel_rate_max);
0914 
0915     vblank_def = imx208->cur_mode->vts_def - imx208->cur_mode->height;
0916     vblank_min = imx208->cur_mode->vts_min - imx208->cur_mode->height;
0917     imx208->vblank =
0918         v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops, V4L2_CID_VBLANK,
0919                   vblank_min,
0920                   IMX208_VTS_MAX - imx208->cur_mode->height, 1,
0921                   vblank_def);
0922 
0923     imx208->hblank =
0924         v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops, V4L2_CID_HBLANK,
0925                   IMX208_PPL_384MHZ - imx208->cur_mode->width,
0926                   IMX208_PPL_384MHZ - imx208->cur_mode->width,
0927                   1,
0928                   IMX208_PPL_384MHZ - imx208->cur_mode->width);
0929 
0930     if (imx208->hblank)
0931         imx208->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
0932 
0933     exposure_max = imx208->cur_mode->vts_def - 8;
0934     v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops, V4L2_CID_EXPOSURE,
0935               IMX208_EXPOSURE_MIN, exposure_max,
0936               IMX208_EXPOSURE_STEP, IMX208_EXPOSURE_DEFAULT);
0937 
0938     imx208->hflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops,
0939                       V4L2_CID_HFLIP, 0, 1, 1, 0);
0940     imx208->vflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops,
0941                       V4L2_CID_VFLIP, 0, 1, 1, 0);
0942 
0943     v4l2_ctrl_new_std(ctrl_hdlr, &imx208_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
0944               IMX208_ANA_GAIN_MIN, IMX208_ANA_GAIN_MAX,
0945               IMX208_ANA_GAIN_STEP, IMX208_ANA_GAIN_DEFAULT);
0946 
0947     v4l2_ctrl_new_custom(ctrl_hdlr, &imx208_digital_gain_control, NULL);
0948 
0949     v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx208_ctrl_ops,
0950                      V4L2_CID_TEST_PATTERN,
0951                      ARRAY_SIZE(imx208_test_pattern_menu) - 1,
0952                      0, 0, imx208_test_pattern_menu);
0953 
0954     if (ctrl_hdlr->error) {
0955         ret = ctrl_hdlr->error;
0956         dev_err(&client->dev, "%s control init failed (%d)\n",
0957             __func__, ret);
0958         goto error;
0959     }
0960 
0961     imx208->sd.ctrl_handler = ctrl_hdlr;
0962 
0963     return 0;
0964 
0965 error:
0966     v4l2_ctrl_handler_free(ctrl_hdlr);
0967     mutex_destroy(&imx208->imx208_mx);
0968 
0969     return ret;
0970 }
0971 
0972 static void imx208_free_controls(struct imx208 *imx208)
0973 {
0974     v4l2_ctrl_handler_free(imx208->sd.ctrl_handler);
0975 }
0976 
0977 static int imx208_probe(struct i2c_client *client)
0978 {
0979     struct imx208 *imx208;
0980     int ret;
0981     bool full_power;
0982     u32 val = 0;
0983 
0984     device_property_read_u32(&client->dev, "clock-frequency", &val);
0985     if (val != 19200000) {
0986         dev_err(&client->dev,
0987             "Unsupported clock-frequency %u. Expected 19200000.\n",
0988             val);
0989         return -EINVAL;
0990     }
0991 
0992     imx208 = devm_kzalloc(&client->dev, sizeof(*imx208), GFP_KERNEL);
0993     if (!imx208)
0994         return -ENOMEM;
0995 
0996     /* Initialize subdev */
0997     v4l2_i2c_subdev_init(&imx208->sd, client, &imx208_subdev_ops);
0998 
0999     full_power = acpi_dev_state_d0(&client->dev);
1000     if (full_power) {
1001         /* Check module identity */
1002         ret = imx208_identify_module(imx208);
1003         if (ret) {
1004             dev_err(&client->dev, "failed to find sensor: %d", ret);
1005             goto error_probe;
1006         }
1007     }
1008 
1009     /* Set default mode to max resolution */
1010     imx208->cur_mode = &supported_modes[0];
1011 
1012     ret = imx208_init_controls(imx208);
1013     if (ret) {
1014         dev_err(&client->dev, "failed to init controls: %d", ret);
1015         goto error_probe;
1016     }
1017 
1018     /* Initialize subdev */
1019     imx208->sd.internal_ops = &imx208_internal_ops;
1020     imx208->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1021     imx208->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1022 
1023     /* Initialize source pad */
1024     imx208->pad.flags = MEDIA_PAD_FL_SOURCE;
1025     ret = media_entity_pads_init(&imx208->sd.entity, 1, &imx208->pad);
1026     if (ret) {
1027         dev_err(&client->dev, "%s failed:%d\n", __func__, ret);
1028         goto error_handler_free;
1029     }
1030 
1031     ret = v4l2_async_register_subdev_sensor(&imx208->sd);
1032     if (ret < 0)
1033         goto error_media_entity;
1034 
1035     ret = device_create_bin_file(&client->dev, &bin_attr_otp);
1036     if (ret) {
1037         dev_err(&client->dev, "sysfs otp creation failed\n");
1038         goto error_async_subdev;
1039     }
1040 
1041     /* Set the device's state to active if it's in D0 state. */
1042     if (full_power)
1043         pm_runtime_set_active(&client->dev);
1044     pm_runtime_enable(&client->dev);
1045     pm_runtime_idle(&client->dev);
1046 
1047     return 0;
1048 
1049 error_async_subdev:
1050     v4l2_async_unregister_subdev(&imx208->sd);
1051 
1052 error_media_entity:
1053     media_entity_cleanup(&imx208->sd.entity);
1054 
1055 error_handler_free:
1056     imx208_free_controls(imx208);
1057 
1058 error_probe:
1059     mutex_destroy(&imx208->imx208_mx);
1060 
1061     return ret;
1062 }
1063 
1064 static int imx208_remove(struct i2c_client *client)
1065 {
1066     struct v4l2_subdev *sd = i2c_get_clientdata(client);
1067     struct imx208 *imx208 = to_imx208(sd);
1068 
1069     device_remove_bin_file(&client->dev, &bin_attr_otp);
1070     v4l2_async_unregister_subdev(sd);
1071     media_entity_cleanup(&sd->entity);
1072     imx208_free_controls(imx208);
1073 
1074     pm_runtime_disable(&client->dev);
1075     pm_runtime_set_suspended(&client->dev);
1076 
1077     mutex_destroy(&imx208->imx208_mx);
1078 
1079     return 0;
1080 }
1081 
1082 static const struct dev_pm_ops imx208_pm_ops = {
1083     SET_SYSTEM_SLEEP_PM_OPS(imx208_suspend, imx208_resume)
1084 };
1085 
1086 #ifdef CONFIG_ACPI
1087 static const struct acpi_device_id imx208_acpi_ids[] = {
1088     { "INT3478" },
1089     { /* sentinel */ }
1090 };
1091 
1092 MODULE_DEVICE_TABLE(acpi, imx208_acpi_ids);
1093 #endif
1094 
1095 static struct i2c_driver imx208_i2c_driver = {
1096     .driver = {
1097         .name = "imx208",
1098         .pm = &imx208_pm_ops,
1099         .acpi_match_table = ACPI_PTR(imx208_acpi_ids),
1100     },
1101     .probe_new = imx208_probe,
1102     .remove = imx208_remove,
1103     .flags = I2C_DRV_ACPI_WAIVE_D0_PROBE,
1104 };
1105 
1106 module_i2c_driver(imx208_i2c_driver);
1107 
1108 MODULE_AUTHOR("Yeh, Andy <andy.yeh@intel.com>");
1109 MODULE_AUTHOR("Chen, Ping-chung <ping-chung.chen@intel.com>");
1110 MODULE_AUTHOR("Shawn Tu <shawnx.tu@intel.com>");
1111 MODULE_DESCRIPTION("Sony IMX208 sensor driver");
1112 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!