1303 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Sony imx412 Camera Sensor Driver4 *5 * Copyright (C) 2021 Intel Corporation6 */7#include <linux/unaligned.h>8 9#include <linux/clk.h>10#include <linux/delay.h>11#include <linux/i2c.h>12#include <linux/module.h>13#include <linux/pm_runtime.h>14#include <linux/regulator/consumer.h>15 16#include <media/v4l2-ctrls.h>17#include <media/v4l2-fwnode.h>18#include <media/v4l2-subdev.h>19 20/* Streaming Mode */21#define IMX412_REG_MODE_SELECT 0x010022#define IMX412_MODE_STANDBY 0x0023#define IMX412_MODE_STREAMING 0x0124 25/* Lines per frame */26#define IMX412_REG_LPFR 0x034027 28/* Chip ID */29#define IMX412_REG_ID 0x001630#define IMX412_ID 0x57731 32/* Exposure control */33#define IMX412_REG_EXPOSURE_CIT 0x020234#define IMX412_EXPOSURE_MIN 835#define IMX412_EXPOSURE_OFFSET 2236#define IMX412_EXPOSURE_STEP 137#define IMX412_EXPOSURE_DEFAULT 0x064838 39/* Analog gain control */40#define IMX412_REG_AGAIN 0x020441#define IMX412_AGAIN_MIN 042#define IMX412_AGAIN_MAX 97843#define IMX412_AGAIN_STEP 144#define IMX412_AGAIN_DEFAULT 045 46/* Group hold register */47#define IMX412_REG_HOLD 0x010448 49/* Input clock rate */50#define IMX412_INCLK_RATE 2400000051 52/* CSI2 HW configuration */53#define IMX412_LINK_FREQ 60000000054#define IMX412_NUM_DATA_LANES 455 56#define IMX412_REG_MIN 0x0057#define IMX412_REG_MAX 0xffff58 59/**60 * struct imx412_reg - imx412 sensor register61 * @address: Register address62 * @val: Register value63 */64struct imx412_reg {65 u16 address;66 u8 val;67};68 69/**70 * struct imx412_reg_list - imx412 sensor register list71 * @num_of_regs: Number of registers in the list72 * @regs: Pointer to register list73 */74struct imx412_reg_list {75 u32 num_of_regs;76 const struct imx412_reg *regs;77};78 79/**80 * struct imx412_mode - imx412 sensor mode structure81 * @width: Frame width82 * @height: Frame height83 * @code: Format code84 * @hblank: Horizontal blanking in lines85 * @vblank: Vertical blanking in lines86 * @vblank_min: Minimum vertical blanking in lines87 * @vblank_max: Maximum vertical blanking in lines88 * @pclk: Sensor pixel clock89 * @link_freq_idx: Link frequency index90 * @reg_list: Register list for sensor mode91 */92struct imx412_mode {93 u32 width;94 u32 height;95 u32 code;96 u32 hblank;97 u32 vblank;98 u32 vblank_min;99 u32 vblank_max;100 u64 pclk;101 u32 link_freq_idx;102 struct imx412_reg_list reg_list;103};104 105static const char * const imx412_supply_names[] = {106 "dovdd", /* Digital I/O power */107 "avdd", /* Analog power */108 "dvdd", /* Digital core power */109};110 111/**112 * struct imx412 - imx412 sensor device structure113 * @dev: Pointer to generic device114 * @client: Pointer to i2c client115 * @sd: V4L2 sub-device116 * @pad: Media pad. Only one pad supported117 * @reset_gpio: Sensor reset gpio118 * @inclk: Sensor input clock119 * @supplies: Regulator supplies120 * @ctrl_handler: V4L2 control handler121 * @link_freq_ctrl: Pointer to link frequency control122 * @pclk_ctrl: Pointer to pixel clock control123 * @hblank_ctrl: Pointer to horizontal blanking control124 * @vblank_ctrl: Pointer to vertical blanking control125 * @exp_ctrl: Pointer to exposure control126 * @again_ctrl: Pointer to analog gain control127 * @vblank: Vertical blanking in lines128 * @cur_mode: Pointer to current selected sensor mode129 * @mutex: Mutex for serializing sensor controls130 */131struct imx412 {132 struct device *dev;133 struct i2c_client *client;134 struct v4l2_subdev sd;135 struct media_pad pad;136 struct gpio_desc *reset_gpio;137 struct clk *inclk;138 struct regulator_bulk_data supplies[ARRAY_SIZE(imx412_supply_names)];139 struct v4l2_ctrl_handler ctrl_handler;140 struct v4l2_ctrl *link_freq_ctrl;141 struct v4l2_ctrl *pclk_ctrl;142 struct v4l2_ctrl *hblank_ctrl;143 struct v4l2_ctrl *vblank_ctrl;144 struct {145 struct v4l2_ctrl *exp_ctrl;146 struct v4l2_ctrl *again_ctrl;147 };148 u32 vblank;149 const struct imx412_mode *cur_mode;150 struct mutex mutex;151};152 153static const s64 link_freq[] = {154 IMX412_LINK_FREQ,155};156 157/* Sensor mode registers */158static const struct imx412_reg mode_4056x3040_regs[] = {159 {0x0136, 0x18},160 {0x0137, 0x00},161 {0x3c7e, 0x08},162 {0x3c7f, 0x02},163 {0x38a8, 0x1f},164 {0x38a9, 0xff},165 {0x38aa, 0x1f},166 {0x38ab, 0xff},167 {0x55d4, 0x00},168 {0x55d5, 0x00},169 {0x55d6, 0x07},170 {0x55d7, 0xff},171 {0x55e8, 0x07},172 {0x55e9, 0xff},173 {0x55ea, 0x00},174 {0x55eb, 0x00},175 {0x575c, 0x07},176 {0x575d, 0xff},177 {0x575e, 0x00},178 {0x575f, 0x00},179 {0x5764, 0x00},180 {0x5765, 0x00},181 {0x5766, 0x07},182 {0x5767, 0xff},183 {0x5974, 0x04},184 {0x5975, 0x01},185 {0x5f10, 0x09},186 {0x5f11, 0x92},187 {0x5f12, 0x32},188 {0x5f13, 0x72},189 {0x5f14, 0x16},190 {0x5f15, 0xba},191 {0x5f17, 0x13},192 {0x5f18, 0x24},193 {0x5f19, 0x60},194 {0x5f1a, 0xe3},195 {0x5f1b, 0xad},196 {0x5f1c, 0x74},197 {0x5f2d, 0x25},198 {0x5f5c, 0xd0},199 {0x6a22, 0x00},200 {0x6a23, 0x1d},201 {0x7ba8, 0x00},202 {0x7ba9, 0x00},203 {0x886b, 0x00},204 {0x9002, 0x0a},205 {0x9004, 0x1a},206 {0x9214, 0x93},207 {0x9215, 0x69},208 {0x9216, 0x93},209 {0x9217, 0x6b},210 {0x9218, 0x93},211 {0x9219, 0x6d},212 {0x921a, 0x57},213 {0x921b, 0x58},214 {0x921c, 0x57},215 {0x921d, 0x59},216 {0x921e, 0x57},217 {0x921f, 0x5a},218 {0x9220, 0x57},219 {0x9221, 0x5b},220 {0x9222, 0x93},221 {0x9223, 0x02},222 {0x9224, 0x93},223 {0x9225, 0x03},224 {0x9226, 0x93},225 {0x9227, 0x04},226 {0x9228, 0x93},227 {0x9229, 0x05},228 {0x922a, 0x98},229 {0x922b, 0x21},230 {0x922c, 0xb2},231 {0x922d, 0xdb},232 {0x922e, 0xb2},233 {0x922f, 0xdc},234 {0x9230, 0xb2},235 {0x9231, 0xdd},236 {0x9232, 0xe2},237 {0x9233, 0xe1},238 {0x9234, 0xb2},239 {0x9235, 0xe2},240 {0x9236, 0xb2},241 {0x9237, 0xe3},242 {0x9238, 0xb7},243 {0x9239, 0xb9},244 {0x923a, 0xb7},245 {0x923b, 0xbb},246 {0x923c, 0xb7},247 {0x923d, 0xbc},248 {0x923e, 0xb7},249 {0x923f, 0xc5},250 {0x9240, 0xb7},251 {0x9241, 0xc7},252 {0x9242, 0xb7},253 {0x9243, 0xc9},254 {0x9244, 0x98},255 {0x9245, 0x56},256 {0x9246, 0x98},257 {0x9247, 0x55},258 {0x9380, 0x00},259 {0x9381, 0x62},260 {0x9382, 0x00},261 {0x9383, 0x56},262 {0x9384, 0x00},263 {0x9385, 0x52},264 {0x9388, 0x00},265 {0x9389, 0x55},266 {0x938a, 0x00},267 {0x938b, 0x55},268 {0x938c, 0x00},269 {0x938d, 0x41},270 {0x5078, 0x01},271 {0x0112, 0x0a},272 {0x0113, 0x0a},273 {0x0114, 0x03},274 {0x0342, 0x11},275 {0x0343, 0xa0},276 {0x0340, 0x0d},277 {0x0341, 0xda},278 {0x3210, 0x00},279 {0x0344, 0x00},280 {0x0345, 0x00},281 {0x0346, 0x00},282 {0x0347, 0x00},283 {0x0348, 0x0f},284 {0x0349, 0xd7},285 {0x034a, 0x0b},286 {0x034b, 0xdf},287 {0x00e3, 0x00},288 {0x00e4, 0x00},289 {0x00e5, 0x01},290 {0x00fc, 0x0a},291 {0x00fd, 0x0a},292 {0x00fe, 0x0a},293 {0x00ff, 0x0a},294 {0xe013, 0x00},295 {0x0220, 0x00},296 {0x0221, 0x11},297 {0x0381, 0x01},298 {0x0383, 0x01},299 {0x0385, 0x01},300 {0x0387, 0x01},301 {0x0900, 0x00},302 {0x0901, 0x11},303 {0x0902, 0x00},304 {0x3140, 0x02},305 {0x3241, 0x11},306 {0x3250, 0x03},307 {0x3e10, 0x00},308 {0x3e11, 0x00},309 {0x3f0d, 0x00},310 {0x3f42, 0x00},311 {0x3f43, 0x00},312 {0x0401, 0x00},313 {0x0404, 0x00},314 {0x0405, 0x10},315 {0x0408, 0x00},316 {0x0409, 0x00},317 {0x040a, 0x00},318 {0x040b, 0x00},319 {0x040c, 0x0f},320 {0x040d, 0xd8},321 {0x040e, 0x0b},322 {0x040f, 0xe0},323 {0x034c, 0x0f},324 {0x034d, 0xd8},325 {0x034e, 0x0b},326 {0x034f, 0xe0},327 {0x0301, 0x05},328 {0x0303, 0x02},329 {0x0305, 0x04},330 {0x0306, 0x00},331 {0x0307, 0xc8},332 {0x0309, 0x0a},333 {0x030b, 0x01},334 {0x030d, 0x02},335 {0x030e, 0x01},336 {0x030f, 0x5e},337 {0x0310, 0x00},338 {0x0820, 0x12},339 {0x0821, 0xc0},340 {0x0822, 0x00},341 {0x0823, 0x00},342 {0x3e20, 0x01},343 {0x3e37, 0x00},344 {0x3f50, 0x00},345 {0x3f56, 0x00},346 {0x3f57, 0xe2},347 {0x3c0a, 0x5a},348 {0x3c0b, 0x55},349 {0x3c0c, 0x28},350 {0x3c0d, 0x07},351 {0x3c0e, 0xff},352 {0x3c0f, 0x00},353 {0x3c10, 0x00},354 {0x3c11, 0x02},355 {0x3c12, 0x00},356 {0x3c13, 0x03},357 {0x3c14, 0x00},358 {0x3c15, 0x00},359 {0x3c16, 0x0c},360 {0x3c17, 0x0c},361 {0x3c18, 0x0c},362 {0x3c19, 0x0a},363 {0x3c1a, 0x0a},364 {0x3c1b, 0x0a},365 {0x3c1c, 0x00},366 {0x3c1d, 0x00},367 {0x3c1e, 0x00},368 {0x3c1f, 0x00},369 {0x3c20, 0x00},370 {0x3c21, 0x00},371 {0x3c22, 0x3f},372 {0x3c23, 0x0a},373 {0x3e35, 0x01},374 {0x3f4a, 0x03},375 {0x3f4b, 0xbf},376 {0x3f26, 0x00},377 {0x0202, 0x0d},378 {0x0203, 0xc4},379 {0x0204, 0x00},380 {0x0205, 0x00},381 {0x020e, 0x01},382 {0x020f, 0x00},383 {0x0210, 0x01},384 {0x0211, 0x00},385 {0x0212, 0x01},386 {0x0213, 0x00},387 {0x0214, 0x01},388 {0x0215, 0x00},389 {0xbcf1, 0x00},390};391 392/* Supported sensor mode configurations */393static const struct imx412_mode supported_mode = {394 .width = 4056,395 .height = 3040,396 .hblank = 456,397 .vblank = 506,398 .vblank_min = 506,399 .vblank_max = 32420,400 .pclk = 480000000,401 .link_freq_idx = 0,402 .code = MEDIA_BUS_FMT_SRGGB10_1X10,403 .reg_list = {404 .num_of_regs = ARRAY_SIZE(mode_4056x3040_regs),405 .regs = mode_4056x3040_regs,406 },407};408 409/**410 * to_imx412() - imx412 V4L2 sub-device to imx412 device.411 * @subdev: pointer to imx412 V4L2 sub-device412 *413 * Return: pointer to imx412 device414 */415static inline struct imx412 *to_imx412(struct v4l2_subdev *subdev)416{417 return container_of(subdev, struct imx412, sd);418}419 420/**421 * imx412_read_reg() - Read registers.422 * @imx412: pointer to imx412 device423 * @reg: register address424 * @len: length of bytes to read. Max supported bytes is 4425 * @val: pointer to register value to be filled.426 *427 * Return: 0 if successful, error code otherwise.428 */429static int imx412_read_reg(struct imx412 *imx412, u16 reg, u32 len, u32 *val)430{431 struct i2c_client *client = v4l2_get_subdevdata(&imx412->sd);432 struct i2c_msg msgs[2] = {0};433 u8 addr_buf[2] = {0};434 u8 data_buf[4] = {0};435 int ret;436 437 if (WARN_ON(len > 4))438 return -EINVAL;439 440 put_unaligned_be16(reg, addr_buf);441 442 /* Write register address */443 msgs[0].addr = client->addr;444 msgs[0].flags = 0;445 msgs[0].len = ARRAY_SIZE(addr_buf);446 msgs[0].buf = addr_buf;447 448 /* Read data from register */449 msgs[1].addr = client->addr;450 msgs[1].flags = I2C_M_RD;451 msgs[1].len = len;452 msgs[1].buf = &data_buf[4 - len];453 454 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));455 if (ret != ARRAY_SIZE(msgs))456 return -EIO;457 458 *val = get_unaligned_be32(data_buf);459 460 return 0;461}462 463/**464 * imx412_write_reg() - Write register465 * @imx412: pointer to imx412 device466 * @reg: register address467 * @len: length of bytes. Max supported bytes is 4468 * @val: register value469 *470 * Return: 0 if successful, error code otherwise.471 */472static int imx412_write_reg(struct imx412 *imx412, u16 reg, u32 len, u32 val)473{474 struct i2c_client *client = v4l2_get_subdevdata(&imx412->sd);475 u8 buf[6] = {0};476 477 if (WARN_ON(len > 4))478 return -EINVAL;479 480 put_unaligned_be16(reg, buf);481 put_unaligned_be32(val << (8 * (4 - len)), buf + 2);482 if (i2c_master_send(client, buf, len + 2) != len + 2)483 return -EIO;484 485 return 0;486}487 488/**489 * imx412_write_regs() - Write a list of registers490 * @imx412: pointer to imx412 device491 * @regs: list of registers to be written492 * @len: length of registers array493 *494 * Return: 0 if successful, error code otherwise.495 */496static int imx412_write_regs(struct imx412 *imx412,497 const struct imx412_reg *regs, u32 len)498{499 unsigned int i;500 int ret;501 502 for (i = 0; i < len; i++) {503 ret = imx412_write_reg(imx412, regs[i].address, 1, regs[i].val);504 if (ret)505 return ret;506 }507 508 return 0;509}510 511/**512 * imx412_update_controls() - Update control ranges based on streaming mode513 * @imx412: pointer to imx412 device514 * @mode: pointer to imx412_mode sensor mode515 *516 * Return: 0 if successful, error code otherwise.517 */518static int imx412_update_controls(struct imx412 *imx412,519 const struct imx412_mode *mode)520{521 int ret;522 523 ret = __v4l2_ctrl_s_ctrl(imx412->link_freq_ctrl, mode->link_freq_idx);524 if (ret)525 return ret;526 527 ret = __v4l2_ctrl_s_ctrl(imx412->hblank_ctrl, mode->hblank);528 if (ret)529 return ret;530 531 return __v4l2_ctrl_modify_range(imx412->vblank_ctrl, mode->vblank_min,532 mode->vblank_max, 1, mode->vblank);533}534 535/**536 * imx412_update_exp_gain() - Set updated exposure and gain537 * @imx412: pointer to imx412 device538 * @exposure: updated exposure value539 * @gain: updated analog gain value540 *541 * Return: 0 if successful, error code otherwise.542 */543static int imx412_update_exp_gain(struct imx412 *imx412, u32 exposure, u32 gain)544{545 u32 lpfr;546 int ret;547 548 lpfr = imx412->vblank + imx412->cur_mode->height;549 550 dev_dbg(imx412->dev, "Set exp %u, analog gain %u, lpfr %u",551 exposure, gain, lpfr);552 553 ret = imx412_write_reg(imx412, IMX412_REG_HOLD, 1, 1);554 if (ret)555 return ret;556 557 ret = imx412_write_reg(imx412, IMX412_REG_LPFR, 2, lpfr);558 if (ret)559 goto error_release_group_hold;560 561 ret = imx412_write_reg(imx412, IMX412_REG_EXPOSURE_CIT, 2, exposure);562 if (ret)563 goto error_release_group_hold;564 565 ret = imx412_write_reg(imx412, IMX412_REG_AGAIN, 2, gain);566 567error_release_group_hold:568 imx412_write_reg(imx412, IMX412_REG_HOLD, 1, 0);569 570 return ret;571}572 573/**574 * imx412_set_ctrl() - Set subdevice control575 * @ctrl: pointer to v4l2_ctrl structure576 *577 * Supported controls:578 * - V4L2_CID_VBLANK579 * - cluster controls:580 * - V4L2_CID_ANALOGUE_GAIN581 * - V4L2_CID_EXPOSURE582 *583 * Return: 0 if successful, error code otherwise.584 */585static int imx412_set_ctrl(struct v4l2_ctrl *ctrl)586{587 struct imx412 *imx412 =588 container_of(ctrl->handler, struct imx412, ctrl_handler);589 u32 analog_gain;590 u32 exposure;591 int ret;592 593 switch (ctrl->id) {594 case V4L2_CID_VBLANK:595 imx412->vblank = imx412->vblank_ctrl->val;596 597 dev_dbg(imx412->dev, "Received vblank %u, new lpfr %u",598 imx412->vblank,599 imx412->vblank + imx412->cur_mode->height);600 601 ret = __v4l2_ctrl_modify_range(imx412->exp_ctrl,602 IMX412_EXPOSURE_MIN,603 imx412->vblank +604 imx412->cur_mode->height -605 IMX412_EXPOSURE_OFFSET,606 1, IMX412_EXPOSURE_DEFAULT);607 break;608 case V4L2_CID_EXPOSURE:609 /* Set controls only if sensor is in power on state */610 if (!pm_runtime_get_if_in_use(imx412->dev))611 return 0;612 613 exposure = ctrl->val;614 analog_gain = imx412->again_ctrl->val;615 616 dev_dbg(imx412->dev, "Received exp %u, analog gain %u",617 exposure, analog_gain);618 619 ret = imx412_update_exp_gain(imx412, exposure, analog_gain);620 621 pm_runtime_put(imx412->dev);622 623 break;624 default:625 dev_err(imx412->dev, "Invalid control %d", ctrl->id);626 ret = -EINVAL;627 }628 629 return ret;630}631 632/* V4l2 subdevice control ops*/633static const struct v4l2_ctrl_ops imx412_ctrl_ops = {634 .s_ctrl = imx412_set_ctrl,635};636 637/**638 * imx412_enum_mbus_code() - Enumerate V4L2 sub-device mbus codes639 * @sd: pointer to imx412 V4L2 sub-device structure640 * @sd_state: V4L2 sub-device configuration641 * @code: V4L2 sub-device code enumeration need to be filled642 *643 * Return: 0 if successful, error code otherwise.644 */645static int imx412_enum_mbus_code(struct v4l2_subdev *sd,646 struct v4l2_subdev_state *sd_state,647 struct v4l2_subdev_mbus_code_enum *code)648{649 if (code->index > 0)650 return -EINVAL;651 652 code->code = supported_mode.code;653 654 return 0;655}656 657/**658 * imx412_enum_frame_size() - Enumerate V4L2 sub-device frame sizes659 * @sd: pointer to imx412 V4L2 sub-device structure660 * @sd_state: V4L2 sub-device configuration661 * @fsize: V4L2 sub-device size enumeration need to be filled662 *663 * Return: 0 if successful, error code otherwise.664 */665static int imx412_enum_frame_size(struct v4l2_subdev *sd,666 struct v4l2_subdev_state *sd_state,667 struct v4l2_subdev_frame_size_enum *fsize)668{669 if (fsize->index > 0)670 return -EINVAL;671 672 if (fsize->code != supported_mode.code)673 return -EINVAL;674 675 fsize->min_width = supported_mode.width;676 fsize->max_width = fsize->min_width;677 fsize->min_height = supported_mode.height;678 fsize->max_height = fsize->min_height;679 680 return 0;681}682 683/**684 * imx412_fill_pad_format() - Fill subdevice pad format685 * from selected sensor mode686 * @imx412: pointer to imx412 device687 * @mode: pointer to imx412_mode sensor mode688 * @fmt: V4L2 sub-device format need to be filled689 */690static void imx412_fill_pad_format(struct imx412 *imx412,691 const struct imx412_mode *mode,692 struct v4l2_subdev_format *fmt)693{694 fmt->format.width = mode->width;695 fmt->format.height = mode->height;696 fmt->format.code = mode->code;697 fmt->format.field = V4L2_FIELD_NONE;698 fmt->format.colorspace = V4L2_COLORSPACE_RAW;699 fmt->format.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;700 fmt->format.quantization = V4L2_QUANTIZATION_DEFAULT;701 fmt->format.xfer_func = V4L2_XFER_FUNC_NONE;702}703 704/**705 * imx412_get_pad_format() - Get subdevice pad format706 * @sd: pointer to imx412 V4L2 sub-device structure707 * @sd_state: V4L2 sub-device configuration708 * @fmt: V4L2 sub-device format need to be set709 *710 * Return: 0 if successful, error code otherwise.711 */712static int imx412_get_pad_format(struct v4l2_subdev *sd,713 struct v4l2_subdev_state *sd_state,714 struct v4l2_subdev_format *fmt)715{716 struct imx412 *imx412 = to_imx412(sd);717 718 mutex_lock(&imx412->mutex);719 720 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {721 struct v4l2_mbus_framefmt *framefmt;722 723 framefmt = v4l2_subdev_state_get_format(sd_state, fmt->pad);724 fmt->format = *framefmt;725 } else {726 imx412_fill_pad_format(imx412, imx412->cur_mode, fmt);727 }728 729 mutex_unlock(&imx412->mutex);730 731 return 0;732}733 734/**735 * imx412_set_pad_format() - Set subdevice pad format736 * @sd: pointer to imx412 V4L2 sub-device structure737 * @sd_state: V4L2 sub-device configuration738 * @fmt: V4L2 sub-device format need to be set739 *740 * Return: 0 if successful, error code otherwise.741 */742static int imx412_set_pad_format(struct v4l2_subdev *sd,743 struct v4l2_subdev_state *sd_state,744 struct v4l2_subdev_format *fmt)745{746 struct imx412 *imx412 = to_imx412(sd);747 const struct imx412_mode *mode;748 int ret = 0;749 750 mutex_lock(&imx412->mutex);751 752 mode = &supported_mode;753 imx412_fill_pad_format(imx412, mode, fmt);754 755 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {756 struct v4l2_mbus_framefmt *framefmt;757 758 framefmt = v4l2_subdev_state_get_format(sd_state, fmt->pad);759 *framefmt = fmt->format;760 } else {761 ret = imx412_update_controls(imx412, mode);762 if (!ret)763 imx412->cur_mode = mode;764 }765 766 mutex_unlock(&imx412->mutex);767 768 return ret;769}770 771/**772 * imx412_init_state() - Initialize sub-device state773 * @sd: pointer to imx412 V4L2 sub-device structure774 * @sd_state: V4L2 sub-device configuration775 *776 * Return: 0 if successful, error code otherwise.777 */778static int imx412_init_state(struct v4l2_subdev *sd,779 struct v4l2_subdev_state *sd_state)780{781 struct imx412 *imx412 = to_imx412(sd);782 struct v4l2_subdev_format fmt = { 0 };783 784 fmt.which = sd_state ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;785 imx412_fill_pad_format(imx412, &supported_mode, &fmt);786 787 return imx412_set_pad_format(sd, sd_state, &fmt);788}789 790/**791 * imx412_start_streaming() - Start sensor stream792 * @imx412: pointer to imx412 device793 *794 * Return: 0 if successful, error code otherwise.795 */796static int imx412_start_streaming(struct imx412 *imx412)797{798 const struct imx412_reg_list *reg_list;799 int ret;800 801 /* Write sensor mode registers */802 reg_list = &imx412->cur_mode->reg_list;803 ret = imx412_write_regs(imx412, reg_list->regs,804 reg_list->num_of_regs);805 if (ret) {806 dev_err(imx412->dev, "fail to write initial registers");807 return ret;808 }809 810 /* Setup handler will write actual exposure and gain */811 ret = __v4l2_ctrl_handler_setup(imx412->sd.ctrl_handler);812 if (ret) {813 dev_err(imx412->dev, "fail to setup handler");814 return ret;815 }816 817 /* Delay is required before streaming*/818 usleep_range(7400, 8000);819 820 /* Start streaming */821 ret = imx412_write_reg(imx412, IMX412_REG_MODE_SELECT,822 1, IMX412_MODE_STREAMING);823 if (ret) {824 dev_err(imx412->dev, "fail to start streaming");825 return ret;826 }827 828 return 0;829}830 831/**832 * imx412_stop_streaming() - Stop sensor stream833 * @imx412: pointer to imx412 device834 *835 * Return: 0 if successful, error code otherwise.836 */837static int imx412_stop_streaming(struct imx412 *imx412)838{839 return imx412_write_reg(imx412, IMX412_REG_MODE_SELECT,840 1, IMX412_MODE_STANDBY);841}842 843/**844 * imx412_set_stream() - Enable sensor streaming845 * @sd: pointer to imx412 subdevice846 * @enable: set to enable sensor streaming847 *848 * Return: 0 if successful, error code otherwise.849 */850static int imx412_set_stream(struct v4l2_subdev *sd, int enable)851{852 struct imx412 *imx412 = to_imx412(sd);853 int ret;854 855 mutex_lock(&imx412->mutex);856 857 if (enable) {858 ret = pm_runtime_resume_and_get(imx412->dev);859 if (ret)860 goto error_unlock;861 862 ret = imx412_start_streaming(imx412);863 if (ret)864 goto error_power_off;865 } else {866 imx412_stop_streaming(imx412);867 pm_runtime_put(imx412->dev);868 }869 870 mutex_unlock(&imx412->mutex);871 872 return 0;873 874error_power_off:875 pm_runtime_put(imx412->dev);876error_unlock:877 mutex_unlock(&imx412->mutex);878 879 return ret;880}881 882/**883 * imx412_detect() - Detect imx412 sensor884 * @imx412: pointer to imx412 device885 *886 * Return: 0 if successful, -EIO if sensor id does not match887 */888static int imx412_detect(struct imx412 *imx412)889{890 int ret;891 u32 val;892 893 ret = imx412_read_reg(imx412, IMX412_REG_ID, 2, &val);894 if (ret)895 return ret;896 897 if (val != IMX412_ID) {898 dev_err(imx412->dev, "chip id mismatch: %x!=%x",899 IMX412_ID, val);900 return -ENXIO;901 }902 903 return 0;904}905 906/**907 * imx412_parse_hw_config() - Parse HW configuration and check if supported908 * @imx412: pointer to imx412 device909 *910 * Return: 0 if successful, error code otherwise.911 */912static int imx412_parse_hw_config(struct imx412 *imx412)913{914 struct fwnode_handle *fwnode = dev_fwnode(imx412->dev);915 struct v4l2_fwnode_endpoint bus_cfg = {916 .bus_type = V4L2_MBUS_CSI2_DPHY917 };918 struct fwnode_handle *ep;919 unsigned long rate;920 unsigned int i;921 int ret;922 923 if (!fwnode)924 return -ENXIO;925 926 /* Request optional reset pin */927 imx412->reset_gpio = devm_gpiod_get_optional(imx412->dev, "reset",928 GPIOD_OUT_LOW);929 if (IS_ERR(imx412->reset_gpio)) {930 dev_err(imx412->dev, "failed to get reset gpio %ld",931 PTR_ERR(imx412->reset_gpio));932 return PTR_ERR(imx412->reset_gpio);933 }934 935 /* Get sensor input clock */936 imx412->inclk = devm_clk_get(imx412->dev, NULL);937 if (IS_ERR(imx412->inclk)) {938 dev_err(imx412->dev, "could not get inclk");939 return PTR_ERR(imx412->inclk);940 }941 942 rate = clk_get_rate(imx412->inclk);943 if (rate != IMX412_INCLK_RATE) {944 dev_err(imx412->dev, "inclk frequency mismatch");945 return -EINVAL;946 }947 948 /* Get optional DT defined regulators */949 for (i = 0; i < ARRAY_SIZE(imx412_supply_names); i++)950 imx412->supplies[i].supply = imx412_supply_names[i];951 952 ret = devm_regulator_bulk_get(imx412->dev,953 ARRAY_SIZE(imx412_supply_names),954 imx412->supplies);955 if (ret)956 return ret;957 958 ep = fwnode_graph_get_next_endpoint(fwnode, NULL);959 if (!ep)960 return -ENXIO;961 962 ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);963 fwnode_handle_put(ep);964 if (ret)965 return ret;966 967 if (bus_cfg.bus.mipi_csi2.num_data_lanes != IMX412_NUM_DATA_LANES) {968 dev_err(imx412->dev,969 "number of CSI2 data lanes %d is not supported",970 bus_cfg.bus.mipi_csi2.num_data_lanes);971 ret = -EINVAL;972 goto done_endpoint_free;973 }974 975 if (!bus_cfg.nr_of_link_frequencies) {976 dev_err(imx412->dev, "no link frequencies defined");977 ret = -EINVAL;978 goto done_endpoint_free;979 }980 981 for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++)982 if (bus_cfg.link_frequencies[i] == IMX412_LINK_FREQ)983 goto done_endpoint_free;984 985 ret = -EINVAL;986 987done_endpoint_free:988 v4l2_fwnode_endpoint_free(&bus_cfg);989 990 return ret;991}992 993/* V4l2 subdevice ops */994static const struct v4l2_subdev_video_ops imx412_video_ops = {995 .s_stream = imx412_set_stream,996};997 998static const struct v4l2_subdev_pad_ops imx412_pad_ops = {999 .enum_mbus_code = imx412_enum_mbus_code,1000 .enum_frame_size = imx412_enum_frame_size,1001 .get_fmt = imx412_get_pad_format,1002 .set_fmt = imx412_set_pad_format,1003};1004 1005static const struct v4l2_subdev_ops imx412_subdev_ops = {1006 .video = &imx412_video_ops,1007 .pad = &imx412_pad_ops,1008};1009 1010static const struct v4l2_subdev_internal_ops imx412_internal_ops = {1011 .init_state = imx412_init_state,1012};1013 1014/**1015 * imx412_power_on() - Sensor power on sequence1016 * @dev: pointer to i2c device1017 *1018 * Return: 0 if successful, error code otherwise.1019 */1020static int imx412_power_on(struct device *dev)1021{1022 struct v4l2_subdev *sd = dev_get_drvdata(dev);1023 struct imx412 *imx412 = to_imx412(sd);1024 int ret;1025 1026 ret = regulator_bulk_enable(ARRAY_SIZE(imx412_supply_names),1027 imx412->supplies);1028 if (ret < 0) {1029 dev_err(dev, "failed to enable regulators\n");1030 return ret;1031 }1032 1033 gpiod_set_value_cansleep(imx412->reset_gpio, 0);1034 1035 ret = clk_prepare_enable(imx412->inclk);1036 if (ret) {1037 dev_err(imx412->dev, "fail to enable inclk");1038 goto error_reset;1039 }1040 1041 usleep_range(1000, 1200);1042 1043 return 0;1044 1045error_reset:1046 gpiod_set_value_cansleep(imx412->reset_gpio, 1);1047 regulator_bulk_disable(ARRAY_SIZE(imx412_supply_names),1048 imx412->supplies);1049 1050 return ret;1051}1052 1053/**1054 * imx412_power_off() - Sensor power off sequence1055 * @dev: pointer to i2c device1056 *1057 * Return: 0 if successful, error code otherwise.1058 */1059static int imx412_power_off(struct device *dev)1060{1061 struct v4l2_subdev *sd = dev_get_drvdata(dev);1062 struct imx412 *imx412 = to_imx412(sd);1063 1064 clk_disable_unprepare(imx412->inclk);1065 1066 gpiod_set_value_cansleep(imx412->reset_gpio, 1);1067 1068 regulator_bulk_disable(ARRAY_SIZE(imx412_supply_names),1069 imx412->supplies);1070 1071 return 0;1072}1073 1074/**1075 * imx412_init_controls() - Initialize sensor subdevice controls1076 * @imx412: pointer to imx412 device1077 *1078 * Return: 0 if successful, error code otherwise.1079 */1080static int imx412_init_controls(struct imx412 *imx412)1081{1082 struct v4l2_ctrl_handler *ctrl_hdlr = &imx412->ctrl_handler;1083 const struct imx412_mode *mode = imx412->cur_mode;1084 u32 lpfr;1085 int ret;1086 1087 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 6);1088 if (ret)1089 return ret;1090 1091 /* Serialize controls with sensor device */1092 ctrl_hdlr->lock = &imx412->mutex;1093 1094 /* Initialize exposure and gain */1095 lpfr = mode->vblank + mode->height;1096 imx412->exp_ctrl = v4l2_ctrl_new_std(ctrl_hdlr,1097 &imx412_ctrl_ops,1098 V4L2_CID_EXPOSURE,1099 IMX412_EXPOSURE_MIN,1100 lpfr - IMX412_EXPOSURE_OFFSET,1101 IMX412_EXPOSURE_STEP,1102 IMX412_EXPOSURE_DEFAULT);1103 1104 imx412->again_ctrl = v4l2_ctrl_new_std(ctrl_hdlr,1105 &imx412_ctrl_ops,1106 V4L2_CID_ANALOGUE_GAIN,1107 IMX412_AGAIN_MIN,1108 IMX412_AGAIN_MAX,1109 IMX412_AGAIN_STEP,1110 IMX412_AGAIN_DEFAULT);1111 1112 v4l2_ctrl_cluster(2, &imx412->exp_ctrl);1113 1114 imx412->vblank_ctrl = v4l2_ctrl_new_std(ctrl_hdlr,1115 &imx412_ctrl_ops,1116 V4L2_CID_VBLANK,1117 mode->vblank_min,1118 mode->vblank_max,1119 1, mode->vblank);1120 1121 /* Read only controls */1122 imx412->pclk_ctrl = v4l2_ctrl_new_std(ctrl_hdlr,1123 &imx412_ctrl_ops,1124 V4L2_CID_PIXEL_RATE,1125 mode->pclk, mode->pclk,1126 1, mode->pclk);1127 1128 imx412->link_freq_ctrl = v4l2_ctrl_new_int_menu(ctrl_hdlr,1129 &imx412_ctrl_ops,1130 V4L2_CID_LINK_FREQ,1131 ARRAY_SIZE(link_freq) -1132 1,1133 mode->link_freq_idx,1134 link_freq);1135 if (imx412->link_freq_ctrl)1136 imx412->link_freq_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;1137 1138 imx412->hblank_ctrl = v4l2_ctrl_new_std(ctrl_hdlr,1139 &imx412_ctrl_ops,1140 V4L2_CID_HBLANK,1141 IMX412_REG_MIN,1142 IMX412_REG_MAX,1143 1, mode->hblank);1144 if (imx412->hblank_ctrl)1145 imx412->hblank_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;1146 1147 if (ctrl_hdlr->error) {1148 dev_err(imx412->dev, "control init failed: %d",1149 ctrl_hdlr->error);1150 v4l2_ctrl_handler_free(ctrl_hdlr);1151 return ctrl_hdlr->error;1152 }1153 1154 imx412->sd.ctrl_handler = ctrl_hdlr;1155 1156 return 0;1157}1158 1159/**1160 * imx412_probe() - I2C client device binding1161 * @client: pointer to i2c client device1162 *1163 * Return: 0 if successful, error code otherwise.1164 */1165static int imx412_probe(struct i2c_client *client)1166{1167 struct imx412 *imx412;1168 const char *name;1169 int ret;1170 1171 imx412 = devm_kzalloc(&client->dev, sizeof(*imx412), GFP_KERNEL);1172 if (!imx412)1173 return -ENOMEM;1174 1175 imx412->dev = &client->dev;1176 name = device_get_match_data(&client->dev);1177 if (!name)1178 return -ENODEV;1179 1180 /* Initialize subdev */1181 v4l2_i2c_subdev_init(&imx412->sd, client, &imx412_subdev_ops);1182 imx412->sd.internal_ops = &imx412_internal_ops;1183 1184 ret = imx412_parse_hw_config(imx412);1185 if (ret) {1186 dev_err(imx412->dev, "HW configuration is not supported");1187 return ret;1188 }1189 1190 mutex_init(&imx412->mutex);1191 1192 ret = imx412_power_on(imx412->dev);1193 if (ret) {1194 dev_err(imx412->dev, "failed to power-on the sensor");1195 goto error_mutex_destroy;1196 }1197 1198 /* Check module identity */1199 ret = imx412_detect(imx412);1200 if (ret) {1201 dev_err(imx412->dev, "failed to find sensor: %d", ret);1202 goto error_power_off;1203 }1204 1205 /* Set default mode to max resolution */1206 imx412->cur_mode = &supported_mode;1207 imx412->vblank = imx412->cur_mode->vblank;1208 1209 ret = imx412_init_controls(imx412);1210 if (ret) {1211 dev_err(imx412->dev, "failed to init controls: %d", ret);1212 goto error_power_off;1213 }1214 1215 /* Initialize subdev */1216 imx412->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;1217 imx412->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;1218 1219 v4l2_i2c_subdev_set_name(&imx412->sd, client, name, NULL);1220 1221 /* Initialize source pad */1222 imx412->pad.flags = MEDIA_PAD_FL_SOURCE;1223 ret = media_entity_pads_init(&imx412->sd.entity, 1, &imx412->pad);1224 if (ret) {1225 dev_err(imx412->dev, "failed to init entity pads: %d", ret);1226 goto error_handler_free;1227 }1228 1229 ret = v4l2_async_register_subdev_sensor(&imx412->sd);1230 if (ret < 0) {1231 dev_err(imx412->dev,1232 "failed to register async subdev: %d", ret);1233 goto error_media_entity;1234 }1235 1236 pm_runtime_set_active(imx412->dev);1237 pm_runtime_enable(imx412->dev);1238 pm_runtime_idle(imx412->dev);1239 1240 return 0;1241 1242error_media_entity:1243 media_entity_cleanup(&imx412->sd.entity);1244error_handler_free:1245 v4l2_ctrl_handler_free(imx412->sd.ctrl_handler);1246error_power_off:1247 imx412_power_off(imx412->dev);1248error_mutex_destroy:1249 mutex_destroy(&imx412->mutex);1250 1251 return ret;1252}1253 1254/**1255 * imx412_remove() - I2C client device unbinding1256 * @client: pointer to I2C client device1257 *1258 * Return: 0 if successful, error code otherwise.1259 */1260static void imx412_remove(struct i2c_client *client)1261{1262 struct v4l2_subdev *sd = i2c_get_clientdata(client);1263 struct imx412 *imx412 = to_imx412(sd);1264 1265 v4l2_async_unregister_subdev(sd);1266 media_entity_cleanup(&sd->entity);1267 v4l2_ctrl_handler_free(sd->ctrl_handler);1268 1269 pm_runtime_disable(&client->dev);1270 if (!pm_runtime_status_suspended(&client->dev))1271 imx412_power_off(&client->dev);1272 pm_runtime_set_suspended(&client->dev);1273 1274 mutex_destroy(&imx412->mutex);1275}1276 1277static const struct dev_pm_ops imx412_pm_ops = {1278 SET_RUNTIME_PM_OPS(imx412_power_off, imx412_power_on, NULL)1279};1280 1281static const struct of_device_id imx412_of_match[] = {1282 { .compatible = "sony,imx412", .data = "imx412" },1283 { .compatible = "sony,imx577", .data = "imx577" },1284 { }1285};1286 1287MODULE_DEVICE_TABLE(of, imx412_of_match);1288 1289static struct i2c_driver imx412_driver = {1290 .probe = imx412_probe,1291 .remove = imx412_remove,1292 .driver = {1293 .name = "imx412",1294 .pm = &imx412_pm_ops,1295 .of_match_table = imx412_of_match,1296 },1297};1298 1299module_i2c_driver(imx412_driver);1300 1301MODULE_DESCRIPTION("Sony imx412 sensor driver");1302MODULE_LICENSE("GPL");1303