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