1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Sony imx335 Camera Sensor Driver 4 * 5 * Copyright (C) 2021 Intel Corporation 6 */ 7 #include <asm/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 15 #include <media/v4l2-ctrls.h> 16 #include <media/v4l2-fwnode.h> 17 #include <media/v4l2-subdev.h> 18 19 /* Streaming Mode */ 20 #define IMX335_REG_MODE_SELECT 0x3000 21 #define IMX335_MODE_STANDBY 0x01 22 #define IMX335_MODE_STREAMING 0x00 23 24 /* Lines per frame */ 25 #define IMX335_REG_LPFR 0x3030 26 27 /* Chip ID */ 28 #define IMX335_REG_ID 0x3912 29 #define IMX335_ID 0x00 30 31 /* Exposure control */ 32 #define IMX335_REG_SHUTTER 0x3058 33 #define IMX335_EXPOSURE_MIN 1 34 #define IMX335_EXPOSURE_OFFSET 9 35 #define IMX335_EXPOSURE_STEP 1 36 #define IMX335_EXPOSURE_DEFAULT 0x0648 37 38 /* Analog gain control */ 39 #define IMX335_REG_AGAIN 0x30e8 40 #define IMX335_AGAIN_MIN 0 41 #define IMX335_AGAIN_MAX 240 42 #define IMX335_AGAIN_STEP 1 43 #define IMX335_AGAIN_DEFAULT 0 44 45 /* Group hold register */ 46 #define IMX335_REG_HOLD 0x3001 47 48 /* Test pattern generator */ 49 #define IMX335_REG_TPG 0x329e 50 #define IMX335_TPG_ALL_000 0 51 #define IMX335_TPG_ALL_FFF 1 52 #define IMX335_TPG_ALL_555 2 53 #define IMX335_TPG_ALL_AAA 3 54 #define IMX335_TPG_TOG_555_AAA 4 55 #define IMX335_TPG_TOG_AAA_555 5 56 #define IMX335_TPG_TOG_000_555 6 57 #define IMX335_TPG_TOG_555_000 7 58 #define IMX335_TPG_TOG_000_FFF 8 59 #define IMX335_TPG_TOG_FFF_000 9 60 #define IMX335_TPG_H_COLOR_BARS 10 61 #define IMX335_TPG_V_COLOR_BARS 11 62 63 /* Input clock rate */ 64 #define IMX335_INCLK_RATE 24000000 65 66 /* CSI2 HW configuration */ 67 #define IMX335_LINK_FREQ_594MHz 594000000LL 68 #define IMX335_LINK_FREQ_445MHz 445500000LL 69 70 #define IMX335_NUM_DATA_LANES 4 71 72 #define IMX335_REG_MIN 0x00 73 #define IMX335_REG_MAX 0xfffff 74 75 /* IMX335 native and active pixel array size. */ 76 #define IMX335_NATIVE_WIDTH 2616U 77 #define IMX335_NATIVE_HEIGHT 1964U 78 #define IMX335_PIXEL_ARRAY_LEFT 12U 79 #define IMX335_PIXEL_ARRAY_TOP 12U 80 #define IMX335_PIXEL_ARRAY_WIDTH 2592U 81 #define IMX335_PIXEL_ARRAY_HEIGHT 1944U 82 83 /** 84 * struct imx335_reg - imx335 sensor register 85 * @address: Register address 86 * @val: Register value 87 */ 88 struct imx335_reg { 89 u16 address; 90 u8 val; 91 }; 92 93 /** 94 * struct imx335_reg_list - imx335 sensor register list 95 * @num_of_regs: Number of registers in the list 96 * @regs: Pointer to register list 97 */ 98 struct imx335_reg_list { 99 u32 num_of_regs; 100 const struct imx335_reg *regs; 101 }; 102 103 static const char * const imx335_supply_name[] = { 104 "avdd", /* Analog (2.9V) supply */ 105 "ovdd", /* Digital I/O (1.8V) supply */ 106 "dvdd", /* Digital Core (1.2V) supply */ 107 }; 108 109 /** 110 * struct imx335_mode - imx335 sensor mode structure 111 * @width: Frame width 112 * @height: Frame height 113 * @code: Format code 114 * @hblank: Horizontal blanking in lines 115 * @vblank: Vertical blanking in lines 116 * @vblank_min: Minimum vertical blanking in lines 117 * @vblank_max: Maximum vertical blanking in lines 118 * @pclk: Sensor pixel clock 119 * @reg_list: Register list for sensor mode 120 */ 121 struct imx335_mode { 122 u32 width; 123 u32 height; 124 u32 code; 125 u32 hblank; 126 u32 vblank; 127 u32 vblank_min; 128 u32 vblank_max; 129 u64 pclk; 130 struct imx335_reg_list reg_list; 131 }; 132 133 /** 134 * struct imx335 - imx335 sensor device structure 135 * @dev: Pointer to generic device 136 * @client: Pointer to i2c client 137 * @sd: V4L2 sub-device 138 * @pad: Media pad. Only one pad supported 139 * @reset_gpio: Sensor reset gpio 140 * @supplies: Regulator supplies to handle power control 141 * @inclk: Sensor input clock 142 * @ctrl_handler: V4L2 control handler 143 * @link_freq_ctrl: Pointer to link frequency control 144 * @pclk_ctrl: Pointer to pixel clock control 145 * @hblank_ctrl: Pointer to horizontal blanking control 146 * @vblank_ctrl: Pointer to vertical blanking control 147 * @exp_ctrl: Pointer to exposure control 148 * @again_ctrl: Pointer to analog gain control 149 * @vblank: Vertical blanking in lines 150 * @cur_mode: Pointer to current selected sensor mode 151 * @mutex: Mutex for serializing sensor controls 152 * @link_freq_bitmap: Menu bitmap for link_freq_ctrl 153 * @cur_mbus_code: Currently selected media bus format code 154 */ 155 struct imx335 { 156 struct device *dev; 157 struct i2c_client *client; 158 struct v4l2_subdev sd; 159 struct media_pad pad; 160 struct gpio_desc *reset_gpio; 161 struct regulator_bulk_data supplies[ARRAY_SIZE(imx335_supply_name)]; 162 163 struct clk *inclk; 164 struct v4l2_ctrl_handler ctrl_handler; 165 struct v4l2_ctrl *link_freq_ctrl; 166 struct v4l2_ctrl *pclk_ctrl; 167 struct v4l2_ctrl *hblank_ctrl; 168 struct v4l2_ctrl *vblank_ctrl; 169 struct { 170 struct v4l2_ctrl *exp_ctrl; 171 struct v4l2_ctrl *again_ctrl; 172 }; 173 u32 vblank; 174 const struct imx335_mode *cur_mode; 175 struct mutex mutex; 176 unsigned long link_freq_bitmap; 177 u32 cur_mbus_code; 178 }; 179 180 static const char * const imx335_tpg_menu[] = { 181 "Disabled", 182 "All 000h", 183 "All FFFh", 184 "All 555h", 185 "All AAAh", 186 "Toggle 555/AAAh", 187 "Toggle AAA/555h", 188 "Toggle 000/555h", 189 "Toggle 555/000h", 190 "Toggle 000/FFFh", 191 "Toggle FFF/000h", 192 "Horizontal color bars", 193 "Vertical color bars", 194 }; 195 196 static const int imx335_tpg_val[] = { 197 IMX335_TPG_ALL_000, 198 IMX335_TPG_ALL_000, 199 IMX335_TPG_ALL_FFF, 200 IMX335_TPG_ALL_555, 201 IMX335_TPG_ALL_AAA, 202 IMX335_TPG_TOG_555_AAA, 203 IMX335_TPG_TOG_AAA_555, 204 IMX335_TPG_TOG_000_555, 205 IMX335_TPG_TOG_555_000, 206 IMX335_TPG_TOG_000_FFF, 207 IMX335_TPG_TOG_FFF_000, 208 IMX335_TPG_H_COLOR_BARS, 209 IMX335_TPG_V_COLOR_BARS, 210 }; 211 212 /* Sensor mode registers */ 213 static const struct imx335_reg mode_2592x1940_regs[] = { 214 {0x3000, 0x01}, 215 {0x3002, 0x00}, 216 {0x3018, 0x04}, 217 {0x302c, 0x3c}, 218 {0x302e, 0x20}, 219 {0x3056, 0x94}, 220 {0x3074, 0xc8}, 221 {0x3076, 0x28}, 222 {0x304c, 0x00}, 223 {0x31a1, 0x00}, 224 {0x3288, 0x21}, 225 {0x328a, 0x02}, 226 {0x3414, 0x05}, 227 {0x3416, 0x18}, 228 {0x3648, 0x01}, 229 {0x364a, 0x04}, 230 {0x364c, 0x04}, 231 {0x3678, 0x01}, 232 {0x367c, 0x31}, 233 {0x367e, 0x31}, 234 {0x3706, 0x10}, 235 {0x3708, 0x03}, 236 {0x3714, 0x02}, 237 {0x3715, 0x02}, 238 {0x3716, 0x01}, 239 {0x3717, 0x03}, 240 {0x371c, 0x3d}, 241 {0x371d, 0x3f}, 242 {0x372c, 0x00}, 243 {0x372d, 0x00}, 244 {0x372e, 0x46}, 245 {0x372f, 0x00}, 246 {0x3730, 0x89}, 247 {0x3731, 0x00}, 248 {0x3732, 0x08}, 249 {0x3733, 0x01}, 250 {0x3734, 0xfe}, 251 {0x3735, 0x05}, 252 {0x3740, 0x02}, 253 {0x375d, 0x00}, 254 {0x375e, 0x00}, 255 {0x375f, 0x11}, 256 {0x3760, 0x01}, 257 {0x3768, 0x1b}, 258 {0x3769, 0x1b}, 259 {0x376a, 0x1b}, 260 {0x376b, 0x1b}, 261 {0x376c, 0x1a}, 262 {0x376d, 0x17}, 263 {0x376e, 0x0f}, 264 {0x3776, 0x00}, 265 {0x3777, 0x00}, 266 {0x3778, 0x46}, 267 {0x3779, 0x00}, 268 {0x377a, 0x89}, 269 {0x377b, 0x00}, 270 {0x377c, 0x08}, 271 {0x377d, 0x01}, 272 {0x377e, 0x23}, 273 {0x377f, 0x02}, 274 {0x3780, 0xd9}, 275 {0x3781, 0x03}, 276 {0x3782, 0xf5}, 277 {0x3783, 0x06}, 278 {0x3784, 0xa5}, 279 {0x3788, 0x0f}, 280 {0x378a, 0xd9}, 281 {0x378b, 0x03}, 282 {0x378c, 0xeb}, 283 {0x378d, 0x05}, 284 {0x378e, 0x87}, 285 {0x378f, 0x06}, 286 {0x3790, 0xf5}, 287 {0x3792, 0x43}, 288 {0x3794, 0x7a}, 289 {0x3796, 0xa1}, 290 {0x37b0, 0x36}, 291 {0x3a00, 0x00}, 292 }; 293 294 static const struct imx335_reg raw10_framefmt_regs[] = { 295 {0x3050, 0x00}, 296 {0x319d, 0x00}, 297 {0x341c, 0xff}, 298 {0x341d, 0x01}, 299 }; 300 301 static const struct imx335_reg raw12_framefmt_regs[] = { 302 {0x3050, 0x01}, 303 {0x319d, 0x01}, 304 {0x341c, 0x47}, 305 {0x341d, 0x00}, 306 }; 307 308 static const struct imx335_reg mipi_data_rate_1188Mbps[] = { 309 {0x300c, 0x3b}, 310 {0x300d, 0x2a}, 311 {0x314c, 0xc6}, 312 {0x314d, 0x00}, 313 {0x315a, 0x02}, 314 {0x3168, 0xa0}, 315 {0x316a, 0x7e}, 316 {0x319e, 0x01}, 317 {0x3a18, 0x8f}, 318 {0x3a1a, 0x4f}, 319 {0x3a1c, 0x47}, 320 {0x3a1e, 0x37}, 321 {0x3a1f, 0x01}, 322 {0x3a20, 0x4f}, 323 {0x3a22, 0x87}, 324 {0x3a24, 0x4f}, 325 {0x3a26, 0x7f}, 326 {0x3a28, 0x3f}, 327 }; 328 329 static const struct imx335_reg mipi_data_rate_891Mbps[] = { 330 {0x300c, 0x3b}, 331 {0x300d, 0x2a}, 332 {0x314c, 0x29}, 333 {0x314d, 0x01}, 334 {0x315a, 0x06}, 335 {0x3168, 0xa0}, 336 {0x316a, 0x7e}, 337 {0x319e, 0x02}, 338 {0x3a18, 0x7f}, 339 {0x3a1a, 0x37}, 340 {0x3a1c, 0x37}, 341 {0x3a1e, 0xf7}, 342 {0x3a20, 0x3f}, 343 {0x3a22, 0x6f}, 344 {0x3a24, 0x3f}, 345 {0x3a26, 0x5f}, 346 {0x3a28, 0x2f}, 347 }; 348 349 static const s64 link_freq[] = { 350 /* Corresponds to 1188Mbps data lane rate */ 351 IMX335_LINK_FREQ_594MHz, 352 /* Corresponds to 891Mbps data lane rate */ 353 IMX335_LINK_FREQ_445MHz, 354 }; 355 356 static const struct imx335_reg_list link_freq_reglist[] = { 357 { 358 .num_of_regs = ARRAY_SIZE(mipi_data_rate_1188Mbps), 359 .regs = mipi_data_rate_1188Mbps, 360 }, 361 { 362 .num_of_regs = ARRAY_SIZE(mipi_data_rate_891Mbps), 363 .regs = mipi_data_rate_891Mbps, 364 }, 365 }; 366 367 static const u32 imx335_mbus_codes[] = { 368 MEDIA_BUS_FMT_SRGGB12_1X12, 369 MEDIA_BUS_FMT_SRGGB10_1X10, 370 }; 371 372 /* Supported sensor mode configurations */ 373 static const struct imx335_mode supported_mode = { 374 .width = 2592, 375 .height = 1940, 376 .hblank = 342, 377 .vblank = 2560, 378 .vblank_min = 2560, 379 .vblank_max = 133060, 380 .pclk = 396000000, 381 .reg_list = { 382 .num_of_regs = ARRAY_SIZE(mode_2592x1940_regs), 383 .regs = mode_2592x1940_regs, 384 }, 385 }; 386 387 /** 388 * to_imx335() - imx335 V4L2 sub-device to imx335 device. 389 * @subdev: pointer to imx335 V4L2 sub-device 390 * 391 * Return: pointer to imx335 device 392 */ 393 static inline struct imx335 *to_imx335(struct v4l2_subdev *subdev) 394 { 395 return container_of(subdev, struct imx335, sd); 396 } 397 398 /** 399 * imx335_read_reg() - Read registers. 400 * @imx335: pointer to imx335 device 401 * @reg: register address 402 * @len: length of bytes to read. Max supported bytes is 4 403 * @val: pointer to register value to be filled. 404 * 405 * Big endian register addresses with little endian values. 406 * 407 * Return: 0 if successful, error code otherwise. 408 */ 409 static int imx335_read_reg(struct imx335 *imx335, u16 reg, u32 len, u32 *val) 410 { 411 struct i2c_client *client = v4l2_get_subdevdata(&imx335->sd); 412 struct i2c_msg msgs[2] = {0}; 413 u8 addr_buf[2] = {0}; 414 u8 data_buf[4] = {0}; 415 int ret; 416 417 if (WARN_ON(len > 4)) 418 return -EINVAL; 419 420 put_unaligned_be16(reg, addr_buf); 421 422 /* Write register address */ 423 msgs[0].addr = client->addr; 424 msgs[0].flags = 0; 425 msgs[0].len = ARRAY_SIZE(addr_buf); 426 msgs[0].buf = addr_buf; 427 428 /* Read data from register */ 429 msgs[1].addr = client->addr; 430 msgs[1].flags = I2C_M_RD; 431 msgs[1].len = len; 432 msgs[1].buf = data_buf; 433 434 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 435 if (ret != ARRAY_SIZE(msgs)) 436 return -EIO; 437 438 *val = get_unaligned_le32(data_buf); 439 440 return 0; 441 } 442 443 /** 444 * imx335_write_reg() - Write register 445 * @imx335: pointer to imx335 device 446 * @reg: register address 447 * @len: length of bytes. Max supported bytes is 4 448 * @val: register value 449 * 450 * Big endian register addresses with little endian values. 451 * 452 * Return: 0 if successful, error code otherwise. 453 */ 454 static int imx335_write_reg(struct imx335 *imx335, u16 reg, u32 len, u32 val) 455 { 456 struct i2c_client *client = v4l2_get_subdevdata(&imx335->sd); 457 u8 buf[6] = {0}; 458 459 if (WARN_ON(len > 4)) 460 return -EINVAL; 461 462 put_unaligned_be16(reg, buf); 463 put_unaligned_le32(val, buf + 2); 464 if (i2c_master_send(client, buf, len + 2) != len + 2) 465 return -EIO; 466 467 return 0; 468 } 469 470 /** 471 * imx335_write_regs() - Write a list of registers 472 * @imx335: pointer to imx335 device 473 * @regs: list of registers to be written 474 * @len: length of registers array 475 * 476 * Return: 0 if successful. error code otherwise. 477 */ 478 static int imx335_write_regs(struct imx335 *imx335, 479 const struct imx335_reg *regs, u32 len) 480 { 481 unsigned int i; 482 int ret; 483 484 for (i = 0; i < len; i++) { 485 ret = imx335_write_reg(imx335, regs[i].address, 1, regs[i].val); 486 if (ret) 487 return ret; 488 } 489 490 return 0; 491 } 492 493 /** 494 * imx335_update_controls() - Update control ranges based on streaming mode 495 * @imx335: pointer to imx335 device 496 * @mode: pointer to imx335_mode sensor mode 497 * 498 * Return: 0 if successful, error code otherwise. 499 */ 500 static int imx335_update_controls(struct imx335 *imx335, 501 const struct imx335_mode *mode) 502 { 503 int ret; 504 505 ret = __v4l2_ctrl_s_ctrl(imx335->link_freq_ctrl, 506 __ffs(imx335->link_freq_bitmap)); 507 if (ret) 508 return ret; 509 510 ret = __v4l2_ctrl_s_ctrl(imx335->hblank_ctrl, mode->hblank); 511 if (ret) 512 return ret; 513 514 return __v4l2_ctrl_modify_range(imx335->vblank_ctrl, mode->vblank_min, 515 mode->vblank_max, 1, mode->vblank); 516 } 517 518 /** 519 * imx335_update_exp_gain() - Set updated exposure and gain 520 * @imx335: pointer to imx335 device 521 * @exposure: updated exposure value 522 * @gain: updated analog gain value 523 * 524 * Return: 0 if successful, error code otherwise. 525 */ 526 static int imx335_update_exp_gain(struct imx335 *imx335, u32 exposure, u32 gain) 527 { 528 u32 lpfr, shutter; 529 int ret; 530 531 lpfr = imx335->vblank + imx335->cur_mode->height; 532 shutter = lpfr - exposure; 533 534 dev_dbg(imx335->dev, "Set exp %u, analog gain %u, shutter %u, lpfr %u\n", 535 exposure, gain, shutter, lpfr); 536 537 ret = imx335_write_reg(imx335, IMX335_REG_HOLD, 1, 1); 538 if (ret) 539 return ret; 540 541 ret = imx335_write_reg(imx335, IMX335_REG_LPFR, 3, lpfr); 542 if (ret) 543 goto error_release_group_hold; 544 545 ret = imx335_write_reg(imx335, IMX335_REG_SHUTTER, 3, shutter); 546 if (ret) 547 goto error_release_group_hold; 548 549 ret = imx335_write_reg(imx335, IMX335_REG_AGAIN, 2, gain); 550 551 error_release_group_hold: 552 imx335_write_reg(imx335, IMX335_REG_HOLD, 1, 0); 553 554 return ret; 555 } 556 557 static int imx335_update_test_pattern(struct imx335 *imx335, u32 pattern_index) 558 { 559 int ret; 560 561 if (pattern_index >= ARRAY_SIZE(imx335_tpg_val)) 562 return -EINVAL; 563 564 if (pattern_index) { 565 const struct imx335_reg tpg_enable_regs[] = { 566 { 0x3148, 0x10 }, 567 { 0x3280, 0x00 }, 568 { 0x329c, 0x01 }, 569 { 0x32a0, 0x11 }, 570 { 0x3302, 0x00 }, 571 { 0x3303, 0x00 }, 572 { 0x336c, 0x00 }, 573 }; 574 575 ret = imx335_write_reg(imx335, IMX335_REG_TPG, 1, 576 imx335_tpg_val[pattern_index]); 577 if (ret) 578 return ret; 579 580 ret = imx335_write_regs(imx335, tpg_enable_regs, 581 ARRAY_SIZE(tpg_enable_regs)); 582 } else { 583 const struct imx335_reg tpg_disable_regs[] = { 584 { 0x3148, 0x00 }, 585 { 0x3280, 0x01 }, 586 { 0x329c, 0x00 }, 587 { 0x32a0, 0x10 }, 588 { 0x3302, 0x32 }, 589 { 0x3303, 0x00 }, 590 { 0x336c, 0x01 }, 591 }; 592 593 ret = imx335_write_regs(imx335, tpg_disable_regs, 594 ARRAY_SIZE(tpg_disable_regs)); 595 } 596 597 return ret; 598 } 599 600 /** 601 * imx335_set_ctrl() - Set subdevice control 602 * @ctrl: pointer to v4l2_ctrl structure 603 * 604 * Supported controls: 605 * - V4L2_CID_VBLANK 606 * - cluster controls: 607 * - V4L2_CID_ANALOGUE_GAIN 608 * - V4L2_CID_EXPOSURE 609 * 610 * Return: 0 if successful, error code otherwise. 611 */ 612 static int imx335_set_ctrl(struct v4l2_ctrl *ctrl) 613 { 614 struct imx335 *imx335 = 615 container_of(ctrl->handler, struct imx335, ctrl_handler); 616 u32 analog_gain; 617 u32 exposure; 618 int ret; 619 620 /* Propagate change of current control to all related controls */ 621 if (ctrl->id == V4L2_CID_VBLANK) { 622 imx335->vblank = imx335->vblank_ctrl->val; 623 624 dev_dbg(imx335->dev, "Received vblank %u, new lpfr %u\n", 625 imx335->vblank, 626 imx335->vblank + imx335->cur_mode->height); 627 628 return __v4l2_ctrl_modify_range(imx335->exp_ctrl, 629 IMX335_EXPOSURE_MIN, 630 imx335->vblank + 631 imx335->cur_mode->height - 632 IMX335_EXPOSURE_OFFSET, 633 1, IMX335_EXPOSURE_DEFAULT); 634 } 635 636 /* 637 * Applying V4L2 control value only happens 638 * when power is up for streaming. 639 */ 640 if (pm_runtime_get_if_in_use(imx335->dev) == 0) 641 return 0; 642 643 switch (ctrl->id) { 644 case V4L2_CID_EXPOSURE: 645 exposure = ctrl->val; 646 analog_gain = imx335->again_ctrl->val; 647 648 dev_dbg(imx335->dev, "Received exp %u, analog gain %u\n", 649 exposure, analog_gain); 650 651 ret = imx335_update_exp_gain(imx335, exposure, analog_gain); 652 653 break; 654 case V4L2_CID_TEST_PATTERN: 655 ret = imx335_update_test_pattern(imx335, ctrl->val); 656 657 break; 658 default: 659 dev_err(imx335->dev, "Invalid control %d\n", ctrl->id); 660 ret = -EINVAL; 661 } 662 663 pm_runtime_put(imx335->dev); 664 665 return ret; 666 } 667 668 /* V4l2 subdevice control ops*/ 669 static const struct v4l2_ctrl_ops imx335_ctrl_ops = { 670 .s_ctrl = imx335_set_ctrl, 671 }; 672 673 static int imx335_get_format_code(struct imx335 *imx335, u32 code) 674 { 675 unsigned int i; 676 677 for (i = 0; i < ARRAY_SIZE(imx335_mbus_codes); i++) { 678 if (imx335_mbus_codes[i] == code) 679 return imx335_mbus_codes[i]; 680 } 681 682 return imx335_mbus_codes[0]; 683 } 684 685 /** 686 * imx335_enum_mbus_code() - Enumerate V4L2 sub-device mbus codes 687 * @sd: pointer to imx335 V4L2 sub-device structure 688 * @sd_state: V4L2 sub-device configuration 689 * @code: V4L2 sub-device code enumeration need to be filled 690 * 691 * Return: 0 if successful, error code otherwise. 692 */ 693 static int imx335_enum_mbus_code(struct v4l2_subdev *sd, 694 struct v4l2_subdev_state *sd_state, 695 struct v4l2_subdev_mbus_code_enum *code) 696 { 697 if (code->index >= ARRAY_SIZE(imx335_mbus_codes)) 698 return -EINVAL; 699 700 code->code = imx335_mbus_codes[code->index]; 701 702 return 0; 703 } 704 705 /** 706 * imx335_enum_frame_size() - Enumerate V4L2 sub-device frame sizes 707 * @sd: pointer to imx335 V4L2 sub-device structure 708 * @sd_state: V4L2 sub-device configuration 709 * @fsize: V4L2 sub-device size enumeration need to be filled 710 * 711 * Return: 0 if successful, error code otherwise. 712 */ 713 static int imx335_enum_frame_size(struct v4l2_subdev *sd, 714 struct v4l2_subdev_state *sd_state, 715 struct v4l2_subdev_frame_size_enum *fsize) 716 { 717 struct imx335 *imx335 = to_imx335(sd); 718 u32 code; 719 720 if (fsize->index > ARRAY_SIZE(imx335_mbus_codes)) 721 return -EINVAL; 722 723 code = imx335_get_format_code(imx335, fsize->code); 724 if (fsize->code != code) 725 return -EINVAL; 726 727 fsize->min_width = supported_mode.width; 728 fsize->max_width = fsize->min_width; 729 fsize->min_height = supported_mode.height; 730 fsize->max_height = fsize->min_height; 731 732 return 0; 733 } 734 735 /** 736 * imx335_fill_pad_format() - Fill subdevice pad format 737 * from selected sensor mode 738 * @imx335: pointer to imx335 device 739 * @mode: pointer to imx335_mode sensor mode 740 * @fmt: V4L2 sub-device format need to be filled 741 */ 742 static void imx335_fill_pad_format(struct imx335 *imx335, 743 const struct imx335_mode *mode, 744 struct v4l2_subdev_format *fmt) 745 { 746 fmt->format.width = mode->width; 747 fmt->format.height = mode->height; 748 fmt->format.code = imx335->cur_mbus_code; 749 fmt->format.field = V4L2_FIELD_NONE; 750 fmt->format.colorspace = V4L2_COLORSPACE_RAW; 751 fmt->format.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 752 fmt->format.quantization = V4L2_QUANTIZATION_DEFAULT; 753 fmt->format.xfer_func = V4L2_XFER_FUNC_NONE; 754 } 755 756 /** 757 * imx335_get_pad_format() - Get subdevice pad format 758 * @sd: pointer to imx335 V4L2 sub-device structure 759 * @sd_state: V4L2 sub-device configuration 760 * @fmt: V4L2 sub-device format need to be set 761 * 762 * Return: 0 if successful, error code otherwise. 763 */ 764 static int imx335_get_pad_format(struct v4l2_subdev *sd, 765 struct v4l2_subdev_state *sd_state, 766 struct v4l2_subdev_format *fmt) 767 { 768 struct imx335 *imx335 = to_imx335(sd); 769 770 mutex_lock(&imx335->mutex); 771 772 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 773 struct v4l2_mbus_framefmt *framefmt; 774 775 framefmt = v4l2_subdev_state_get_format(sd_state, fmt->pad); 776 fmt->format = *framefmt; 777 } else { 778 imx335_fill_pad_format(imx335, imx335->cur_mode, fmt); 779 } 780 781 mutex_unlock(&imx335->mutex); 782 783 return 0; 784 } 785 786 /** 787 * imx335_set_pad_format() - Set subdevice pad format 788 * @sd: pointer to imx335 V4L2 sub-device structure 789 * @sd_state: V4L2 sub-device configuration 790 * @fmt: V4L2 sub-device format need to be set 791 * 792 * Return: 0 if successful, error code otherwise. 793 */ 794 static int imx335_set_pad_format(struct v4l2_subdev *sd, 795 struct v4l2_subdev_state *sd_state, 796 struct v4l2_subdev_format *fmt) 797 { 798 struct imx335 *imx335 = to_imx335(sd); 799 const struct imx335_mode *mode; 800 int i, ret = 0; 801 802 mutex_lock(&imx335->mutex); 803 804 mode = &supported_mode; 805 for (i = 0; i < ARRAY_SIZE(imx335_mbus_codes); i++) { 806 if (imx335_mbus_codes[i] == fmt->format.code) 807 imx335->cur_mbus_code = imx335_mbus_codes[i]; 808 } 809 810 imx335_fill_pad_format(imx335, mode, fmt); 811 812 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 813 struct v4l2_mbus_framefmt *framefmt; 814 815 framefmt = v4l2_subdev_state_get_format(sd_state, fmt->pad); 816 *framefmt = fmt->format; 817 } else { 818 ret = imx335_update_controls(imx335, mode); 819 if (!ret) 820 imx335->cur_mode = mode; 821 } 822 823 mutex_unlock(&imx335->mutex); 824 825 return ret; 826 } 827 828 /** 829 * imx335_init_state() - Initialize sub-device state 830 * @sd: pointer to imx335 V4L2 sub-device structure 831 * @sd_state: V4L2 sub-device configuration 832 * 833 * Return: 0 if successful, error code otherwise. 834 */ 835 static int imx335_init_state(struct v4l2_subdev *sd, 836 struct v4l2_subdev_state *sd_state) 837 { 838 struct imx335 *imx335 = to_imx335(sd); 839 struct v4l2_subdev_format fmt = { 0 }; 840 841 fmt.which = sd_state ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE; 842 imx335_fill_pad_format(imx335, &supported_mode, &fmt); 843 844 mutex_lock(&imx335->mutex); 845 __v4l2_ctrl_modify_range(imx335->link_freq_ctrl, 0, 846 __fls(imx335->link_freq_bitmap), 847 ~(imx335->link_freq_bitmap), 848 __ffs(imx335->link_freq_bitmap)); 849 mutex_unlock(&imx335->mutex); 850 851 return imx335_set_pad_format(sd, sd_state, &fmt); 852 } 853 854 /** 855 * imx335_get_selection() - Selection API 856 * @sd: pointer to imx335 V4L2 sub-device structure 857 * @sd_state: V4L2 sub-device configuration 858 * @sel: V4L2 selection info 859 * 860 * Return: 0 if successful, error code otherwise. 861 */ 862 static int imx335_get_selection(struct v4l2_subdev *sd, 863 struct v4l2_subdev_state *sd_state, 864 struct v4l2_subdev_selection *sel) 865 { 866 switch (sel->target) { 867 case V4L2_SEL_TGT_NATIVE_SIZE: 868 sel->r.top = 0; 869 sel->r.left = 0; 870 sel->r.width = IMX335_NATIVE_WIDTH; 871 sel->r.height = IMX335_NATIVE_HEIGHT; 872 873 return 0; 874 875 case V4L2_SEL_TGT_CROP: 876 case V4L2_SEL_TGT_CROP_DEFAULT: 877 case V4L2_SEL_TGT_CROP_BOUNDS: 878 sel->r.top = IMX335_PIXEL_ARRAY_TOP; 879 sel->r.left = IMX335_PIXEL_ARRAY_LEFT; 880 sel->r.width = IMX335_PIXEL_ARRAY_WIDTH; 881 sel->r.height = IMX335_PIXEL_ARRAY_HEIGHT; 882 883 return 0; 884 } 885 886 return -EINVAL; 887 } 888 889 static int imx335_set_framefmt(struct imx335 *imx335) 890 { 891 switch (imx335->cur_mbus_code) { 892 case MEDIA_BUS_FMT_SRGGB10_1X10: 893 return imx335_write_regs(imx335, raw10_framefmt_regs, 894 ARRAY_SIZE(raw10_framefmt_regs)); 895 896 case MEDIA_BUS_FMT_SRGGB12_1X12: 897 return imx335_write_regs(imx335, raw12_framefmt_regs, 898 ARRAY_SIZE(raw12_framefmt_regs)); 899 } 900 901 return -EINVAL; 902 } 903 904 /** 905 * imx335_start_streaming() - Start sensor stream 906 * @imx335: pointer to imx335 device 907 * 908 * Return: 0 if successful, error code otherwise. 909 */ 910 static int imx335_start_streaming(struct imx335 *imx335) 911 { 912 const struct imx335_reg_list *reg_list; 913 int ret; 914 915 /* Setup PLL */ 916 reg_list = &link_freq_reglist[__ffs(imx335->link_freq_bitmap)]; 917 ret = imx335_write_regs(imx335, reg_list->regs, reg_list->num_of_regs); 918 if (ret) { 919 dev_err(imx335->dev, "%s failed to set plls\n", __func__); 920 return ret; 921 } 922 923 /* Write sensor mode registers */ 924 reg_list = &imx335->cur_mode->reg_list; 925 ret = imx335_write_regs(imx335, reg_list->regs, 926 reg_list->num_of_regs); 927 if (ret) { 928 dev_err(imx335->dev, "fail to write initial registers\n"); 929 return ret; 930 } 931 932 ret = imx335_set_framefmt(imx335); 933 if (ret) { 934 dev_err(imx335->dev, "%s failed to set frame format: %d\n", 935 __func__, ret); 936 return ret; 937 } 938 939 /* Setup handler will write actual exposure and gain */ 940 ret = __v4l2_ctrl_handler_setup(imx335->sd.ctrl_handler); 941 if (ret) { 942 dev_err(imx335->dev, "fail to setup handler\n"); 943 return ret; 944 } 945 946 /* Start streaming */ 947 ret = imx335_write_reg(imx335, IMX335_REG_MODE_SELECT, 948 1, IMX335_MODE_STREAMING); 949 if (ret) { 950 dev_err(imx335->dev, "fail to start streaming\n"); 951 return ret; 952 } 953 954 /* Initial regulator stabilization period */ 955 usleep_range(18000, 20000); 956 957 return 0; 958 } 959 960 /** 961 * imx335_stop_streaming() - Stop sensor stream 962 * @imx335: pointer to imx335 device 963 * 964 * Return: 0 if successful, error code otherwise. 965 */ 966 static int imx335_stop_streaming(struct imx335 *imx335) 967 { 968 return imx335_write_reg(imx335, IMX335_REG_MODE_SELECT, 969 1, IMX335_MODE_STANDBY); 970 } 971 972 /** 973 * imx335_set_stream() - Enable sensor streaming 974 * @sd: pointer to imx335 subdevice 975 * @enable: set to enable sensor streaming 976 * 977 * Return: 0 if successful, error code otherwise. 978 */ 979 static int imx335_set_stream(struct v4l2_subdev *sd, int enable) 980 { 981 struct imx335 *imx335 = to_imx335(sd); 982 int ret; 983 984 mutex_lock(&imx335->mutex); 985 986 if (enable) { 987 ret = pm_runtime_resume_and_get(imx335->dev); 988 if (ret) 989 goto error_unlock; 990 991 ret = imx335_start_streaming(imx335); 992 if (ret) 993 goto error_power_off; 994 } else { 995 imx335_stop_streaming(imx335); 996 pm_runtime_put(imx335->dev); 997 } 998 999 mutex_unlock(&imx335->mutex); 1000 1001 return 0; 1002 1003 error_power_off: 1004 pm_runtime_put(imx335->dev); 1005 error_unlock: 1006 mutex_unlock(&imx335->mutex); 1007 1008 return ret; 1009 } 1010 1011 /** 1012 * imx335_detect() - Detect imx335 sensor 1013 * @imx335: pointer to imx335 device 1014 * 1015 * Return: 0 if successful, -EIO if sensor id does not match 1016 */ 1017 static int imx335_detect(struct imx335 *imx335) 1018 { 1019 int ret; 1020 u32 val; 1021 1022 ret = imx335_read_reg(imx335, IMX335_REG_ID, 2, &val); 1023 if (ret) 1024 return ret; 1025 1026 if (val != IMX335_ID) { 1027 dev_err(imx335->dev, "chip id mismatch: %x!=%x\n", 1028 IMX335_ID, val); 1029 return -ENXIO; 1030 } 1031 1032 return 0; 1033 } 1034 1035 /** 1036 * imx335_parse_hw_config() - Parse HW configuration and check if supported 1037 * @imx335: pointer to imx335 device 1038 * 1039 * Return: 0 if successful, error code otherwise. 1040 */ 1041 static int imx335_parse_hw_config(struct imx335 *imx335) 1042 { 1043 struct fwnode_handle *fwnode = dev_fwnode(imx335->dev); 1044 struct v4l2_fwnode_endpoint bus_cfg = { 1045 .bus_type = V4L2_MBUS_CSI2_DPHY 1046 }; 1047 struct fwnode_handle *ep; 1048 unsigned long rate; 1049 unsigned int i; 1050 int ret; 1051 1052 if (!fwnode) 1053 return -ENXIO; 1054 1055 /* Request optional reset pin */ 1056 imx335->reset_gpio = devm_gpiod_get_optional(imx335->dev, "reset", 1057 GPIOD_OUT_LOW); 1058 if (IS_ERR(imx335->reset_gpio)) { 1059 dev_err(imx335->dev, "failed to get reset gpio %ld\n", 1060 PTR_ERR(imx335->reset_gpio)); 1061 return PTR_ERR(imx335->reset_gpio); 1062 } 1063 1064 for (i = 0; i < ARRAY_SIZE(imx335_supply_name); i++) 1065 imx335->supplies[i].supply = imx335_supply_name[i]; 1066 1067 ret = devm_regulator_bulk_get(imx335->dev, 1068 ARRAY_SIZE(imx335_supply_name), 1069 imx335->supplies); 1070 if (ret) { 1071 dev_err(imx335->dev, "Failed to get regulators\n"); 1072 return ret; 1073 } 1074 1075 /* Get sensor input clock */ 1076 imx335->inclk = devm_clk_get(imx335->dev, NULL); 1077 if (IS_ERR(imx335->inclk)) { 1078 dev_err(imx335->dev, "could not get inclk\n"); 1079 return PTR_ERR(imx335->inclk); 1080 } 1081 1082 rate = clk_get_rate(imx335->inclk); 1083 if (rate != IMX335_INCLK_RATE) { 1084 dev_err(imx335->dev, "inclk frequency mismatch\n"); 1085 return -EINVAL; 1086 } 1087 1088 ep = fwnode_graph_get_next_endpoint(fwnode, NULL); 1089 if (!ep) { 1090 dev_err(imx335->dev, "Failed to get next endpoint\n"); 1091 return -ENXIO; 1092 } 1093 1094 ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); 1095 fwnode_handle_put(ep); 1096 if (ret) 1097 return ret; 1098 1099 if (bus_cfg.bus.mipi_csi2.num_data_lanes != IMX335_NUM_DATA_LANES) { 1100 dev_err(imx335->dev, 1101 "number of CSI2 data lanes %d is not supported\n", 1102 bus_cfg.bus.mipi_csi2.num_data_lanes); 1103 ret = -EINVAL; 1104 goto done_endpoint_free; 1105 } 1106 1107 ret = v4l2_link_freq_to_bitmap(imx335->dev, bus_cfg.link_frequencies, 1108 bus_cfg.nr_of_link_frequencies, 1109 link_freq, ARRAY_SIZE(link_freq), 1110 &imx335->link_freq_bitmap); 1111 1112 done_endpoint_free: 1113 v4l2_fwnode_endpoint_free(&bus_cfg); 1114 1115 return ret; 1116 } 1117 1118 /* V4l2 subdevice ops */ 1119 static const struct v4l2_subdev_video_ops imx335_video_ops = { 1120 .s_stream = imx335_set_stream, 1121 }; 1122 1123 static const struct v4l2_subdev_pad_ops imx335_pad_ops = { 1124 .enum_mbus_code = imx335_enum_mbus_code, 1125 .enum_frame_size = imx335_enum_frame_size, 1126 .get_selection = imx335_get_selection, 1127 .set_selection = imx335_get_selection, 1128 .get_fmt = imx335_get_pad_format, 1129 .set_fmt = imx335_set_pad_format, 1130 }; 1131 1132 static const struct v4l2_subdev_ops imx335_subdev_ops = { 1133 .video = &imx335_video_ops, 1134 .pad = &imx335_pad_ops, 1135 }; 1136 1137 static const struct v4l2_subdev_internal_ops imx335_internal_ops = { 1138 .init_state = imx335_init_state, 1139 }; 1140 1141 /** 1142 * imx335_power_on() - Sensor power on sequence 1143 * @dev: pointer to i2c device 1144 * 1145 * Return: 0 if successful, error code otherwise. 1146 */ 1147 static int imx335_power_on(struct device *dev) 1148 { 1149 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1150 struct imx335 *imx335 = to_imx335(sd); 1151 int ret; 1152 1153 ret = regulator_bulk_enable(ARRAY_SIZE(imx335_supply_name), 1154 imx335->supplies); 1155 if (ret) { 1156 dev_err(dev, "%s: failed to enable regulators\n", 1157 __func__); 1158 return ret; 1159 } 1160 1161 usleep_range(500, 550); /* Tlow */ 1162 1163 /* Set XCLR */ 1164 gpiod_set_value_cansleep(imx335->reset_gpio, 1); 1165 1166 ret = clk_prepare_enable(imx335->inclk); 1167 if (ret) { 1168 dev_err(imx335->dev, "fail to enable inclk\n"); 1169 goto error_reset; 1170 } 1171 1172 usleep_range(20, 22); /* T4 */ 1173 1174 return 0; 1175 1176 error_reset: 1177 gpiod_set_value_cansleep(imx335->reset_gpio, 0); 1178 regulator_bulk_disable(ARRAY_SIZE(imx335_supply_name), imx335->supplies); 1179 1180 return ret; 1181 } 1182 1183 /** 1184 * imx335_power_off() - Sensor power off sequence 1185 * @dev: pointer to i2c device 1186 * 1187 * Return: 0 if successful, error code otherwise. 1188 */ 1189 static int imx335_power_off(struct device *dev) 1190 { 1191 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1192 struct imx335 *imx335 = to_imx335(sd); 1193 1194 gpiod_set_value_cansleep(imx335->reset_gpio, 0); 1195 clk_disable_unprepare(imx335->inclk); 1196 regulator_bulk_disable(ARRAY_SIZE(imx335_supply_name), imx335->supplies); 1197 1198 return 0; 1199 } 1200 1201 /** 1202 * imx335_init_controls() - Initialize sensor subdevice controls 1203 * @imx335: pointer to imx335 device 1204 * 1205 * Return: 0 if successful, error code otherwise. 1206 */ 1207 static int imx335_init_controls(struct imx335 *imx335) 1208 { 1209 struct v4l2_ctrl_handler *ctrl_hdlr = &imx335->ctrl_handler; 1210 const struct imx335_mode *mode = imx335->cur_mode; 1211 u32 lpfr; 1212 int ret; 1213 1214 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 7); 1215 if (ret) 1216 return ret; 1217 1218 /* Serialize controls with sensor device */ 1219 ctrl_hdlr->lock = &imx335->mutex; 1220 1221 /* Initialize exposure and gain */ 1222 lpfr = mode->vblank + mode->height; 1223 imx335->exp_ctrl = v4l2_ctrl_new_std(ctrl_hdlr, 1224 &imx335_ctrl_ops, 1225 V4L2_CID_EXPOSURE, 1226 IMX335_EXPOSURE_MIN, 1227 lpfr - IMX335_EXPOSURE_OFFSET, 1228 IMX335_EXPOSURE_STEP, 1229 IMX335_EXPOSURE_DEFAULT); 1230 1231 imx335->again_ctrl = v4l2_ctrl_new_std(ctrl_hdlr, 1232 &imx335_ctrl_ops, 1233 V4L2_CID_ANALOGUE_GAIN, 1234 IMX335_AGAIN_MIN, 1235 IMX335_AGAIN_MAX, 1236 IMX335_AGAIN_STEP, 1237 IMX335_AGAIN_DEFAULT); 1238 1239 v4l2_ctrl_cluster(2, &imx335->exp_ctrl); 1240 1241 imx335->vblank_ctrl = v4l2_ctrl_new_std(ctrl_hdlr, 1242 &imx335_ctrl_ops, 1243 V4L2_CID_VBLANK, 1244 mode->vblank_min, 1245 mode->vblank_max, 1246 1, mode->vblank); 1247 1248 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, 1249 &imx335_ctrl_ops, 1250 V4L2_CID_TEST_PATTERN, 1251 ARRAY_SIZE(imx335_tpg_menu) - 1, 1252 0, 0, imx335_tpg_menu); 1253 1254 /* Read only controls */ 1255 imx335->pclk_ctrl = v4l2_ctrl_new_std(ctrl_hdlr, 1256 &imx335_ctrl_ops, 1257 V4L2_CID_PIXEL_RATE, 1258 mode->pclk, mode->pclk, 1259 1, mode->pclk); 1260 1261 imx335->link_freq_ctrl = v4l2_ctrl_new_int_menu(ctrl_hdlr, 1262 &imx335_ctrl_ops, 1263 V4L2_CID_LINK_FREQ, 1264 __fls(imx335->link_freq_bitmap), 1265 __ffs(imx335->link_freq_bitmap), 1266 link_freq); 1267 if (imx335->link_freq_ctrl) 1268 imx335->link_freq_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 1269 1270 imx335->hblank_ctrl = v4l2_ctrl_new_std(ctrl_hdlr, 1271 &imx335_ctrl_ops, 1272 V4L2_CID_HBLANK, 1273 mode->hblank, 1274 mode->hblank, 1275 1, mode->hblank); 1276 if (imx335->hblank_ctrl) 1277 imx335->hblank_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 1278 1279 if (ctrl_hdlr->error) { 1280 dev_err(imx335->dev, "control init failed: %d\n", 1281 ctrl_hdlr->error); 1282 v4l2_ctrl_handler_free(ctrl_hdlr); 1283 return ctrl_hdlr->error; 1284 } 1285 1286 imx335->sd.ctrl_handler = ctrl_hdlr; 1287 1288 return 0; 1289 } 1290 1291 /** 1292 * imx335_probe() - I2C client device binding 1293 * @client: pointer to i2c client device 1294 * 1295 * Return: 0 if successful, error code otherwise. 1296 */ 1297 static int imx335_probe(struct i2c_client *client) 1298 { 1299 struct imx335 *imx335; 1300 int ret; 1301 1302 imx335 = devm_kzalloc(&client->dev, sizeof(*imx335), GFP_KERNEL); 1303 if (!imx335) 1304 return -ENOMEM; 1305 1306 imx335->dev = &client->dev; 1307 1308 /* Initialize subdev */ 1309 v4l2_i2c_subdev_init(&imx335->sd, client, &imx335_subdev_ops); 1310 imx335->sd.internal_ops = &imx335_internal_ops; 1311 1312 ret = imx335_parse_hw_config(imx335); 1313 if (ret) { 1314 dev_err(imx335->dev, "HW configuration is not supported\n"); 1315 return ret; 1316 } 1317 1318 mutex_init(&imx335->mutex); 1319 1320 ret = imx335_power_on(imx335->dev); 1321 if (ret) { 1322 dev_err(imx335->dev, "failed to power-on the sensor\n"); 1323 goto error_mutex_destroy; 1324 } 1325 1326 /* Check module identity */ 1327 ret = imx335_detect(imx335); 1328 if (ret) { 1329 dev_err(imx335->dev, "failed to find sensor: %d\n", ret); 1330 goto error_power_off; 1331 } 1332 1333 /* Set default mode to max resolution */ 1334 imx335->cur_mode = &supported_mode; 1335 imx335->cur_mbus_code = imx335_mbus_codes[0]; 1336 imx335->vblank = imx335->cur_mode->vblank; 1337 1338 ret = imx335_init_controls(imx335); 1339 if (ret) { 1340 dev_err(imx335->dev, "failed to init controls: %d\n", ret); 1341 goto error_power_off; 1342 } 1343 1344 /* Initialize subdev */ 1345 imx335->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1346 imx335->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1347 1348 /* Initialize source pad */ 1349 imx335->pad.flags = MEDIA_PAD_FL_SOURCE; 1350 ret = media_entity_pads_init(&imx335->sd.entity, 1, &imx335->pad); 1351 if (ret) { 1352 dev_err(imx335->dev, "failed to init entity pads: %d\n", ret); 1353 goto error_handler_free; 1354 } 1355 1356 ret = v4l2_async_register_subdev_sensor(&imx335->sd); 1357 if (ret < 0) { 1358 dev_err(imx335->dev, 1359 "failed to register async subdev: %d\n", ret); 1360 goto error_media_entity; 1361 } 1362 1363 pm_runtime_set_active(imx335->dev); 1364 pm_runtime_enable(imx335->dev); 1365 pm_runtime_idle(imx335->dev); 1366 1367 return 0; 1368 1369 error_media_entity: 1370 media_entity_cleanup(&imx335->sd.entity); 1371 error_handler_free: 1372 v4l2_ctrl_handler_free(imx335->sd.ctrl_handler); 1373 error_power_off: 1374 imx335_power_off(imx335->dev); 1375 error_mutex_destroy: 1376 mutex_destroy(&imx335->mutex); 1377 1378 return ret; 1379 } 1380 1381 /** 1382 * imx335_remove() - I2C client device unbinding 1383 * @client: pointer to I2C client device 1384 * 1385 * Return: 0 if successful, error code otherwise. 1386 */ 1387 static void imx335_remove(struct i2c_client *client) 1388 { 1389 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1390 struct imx335 *imx335 = to_imx335(sd); 1391 1392 v4l2_async_unregister_subdev(sd); 1393 media_entity_cleanup(&sd->entity); 1394 v4l2_ctrl_handler_free(sd->ctrl_handler); 1395 1396 pm_runtime_disable(&client->dev); 1397 if (!pm_runtime_status_suspended(&client->dev)) 1398 imx335_power_off(&client->dev); 1399 pm_runtime_set_suspended(&client->dev); 1400 1401 mutex_destroy(&imx335->mutex); 1402 } 1403 1404 static const struct dev_pm_ops imx335_pm_ops = { 1405 SET_RUNTIME_PM_OPS(imx335_power_off, imx335_power_on, NULL) 1406 }; 1407 1408 static const struct of_device_id imx335_of_match[] = { 1409 { .compatible = "sony,imx335" }, 1410 { } 1411 }; 1412 1413 MODULE_DEVICE_TABLE(of, imx335_of_match); 1414 1415 static struct i2c_driver imx335_driver = { 1416 .probe = imx335_probe, 1417 .remove = imx335_remove, 1418 .driver = { 1419 .name = "imx335", 1420 .pm = &imx335_pm_ops, 1421 .of_match_table = imx335_of_match, 1422 }, 1423 }; 1424 1425 module_i2c_driver(imx335_driver); 1426 1427 MODULE_DESCRIPTION("Sony imx335 sensor driver"); 1428 MODULE_LICENSE("GPL"); 1429