1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2020 Intel Corporation. 3 4 #include <linux/unaligned.h> 5 #include <linux/acpi.h> 6 #include <linux/clk.h> 7 #include <linux/delay.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/i2c.h> 10 #include <linux/module.h> 11 #include <linux/pm_runtime.h> 12 #include <linux/nvmem-provider.h> 13 #include <linux/regmap.h> 14 #include <linux/regulator/consumer.h> 15 #include <media/v4l2-ctrls.h> 16 #include <media/v4l2-device.h> 17 #include <media/v4l2-fwnode.h> 18 19 #define OV2740_LINK_FREQ_360MHZ 360000000ULL 20 #define OV2740_LINK_FREQ_180MHZ 180000000ULL 21 #define OV2740_SCLK 72000000LL 22 #define OV2740_MCLK 19200000 23 #define OV2740_DATA_LANES 2 24 #define OV2740_RGB_DEPTH 10 25 26 #define OV2740_REG_CHIP_ID 0x300a 27 #define OV2740_CHIP_ID 0x2740 28 29 #define OV2740_REG_MODE_SELECT 0x0100 30 #define OV2740_MODE_STANDBY 0x00 31 #define OV2740_MODE_STREAMING 0x01 32 33 /* vertical-timings from sensor */ 34 #define OV2740_REG_VTS 0x380e 35 36 /* horizontal-timings from sensor */ 37 #define OV2740_REG_HTS 0x380c 38 39 /* Exposure controls from sensor */ 40 #define OV2740_REG_EXPOSURE 0x3500 41 #define OV2740_EXPOSURE_MIN 4 42 #define OV2740_EXPOSURE_MAX_MARGIN 8 43 #define OV2740_EXPOSURE_STEP 1 44 45 /* Analog gain controls from sensor */ 46 #define OV2740_REG_ANALOG_GAIN 0x3508 47 #define OV2740_ANAL_GAIN_MIN 128 48 #define OV2740_ANAL_GAIN_MAX 1983 49 #define OV2740_ANAL_GAIN_STEP 1 50 51 /* Digital gain controls from sensor */ 52 #define OV2740_REG_MWB_R_GAIN 0x500a 53 #define OV2740_REG_MWB_G_GAIN 0x500c 54 #define OV2740_REG_MWB_B_GAIN 0x500e 55 #define OV2740_DGTL_GAIN_MIN 1024 56 #define OV2740_DGTL_GAIN_MAX 4095 57 #define OV2740_DGTL_GAIN_STEP 1 58 #define OV2740_DGTL_GAIN_DEFAULT 1024 59 60 /* Test Pattern Control */ 61 #define OV2740_REG_TEST_PATTERN 0x5040 62 #define OV2740_TEST_PATTERN_ENABLE BIT(7) 63 #define OV2740_TEST_PATTERN_BAR_SHIFT 2 64 65 /* Group Access */ 66 #define OV2740_REG_GROUP_ACCESS 0x3208 67 #define OV2740_GROUP_HOLD_START 0x0 68 #define OV2740_GROUP_HOLD_END 0x10 69 #define OV2740_GROUP_HOLD_LAUNCH 0xa0 70 71 /* ISP CTRL00 */ 72 #define OV2740_REG_ISP_CTRL00 0x5000 73 /* ISP CTRL01 */ 74 #define OV2740_REG_ISP_CTRL01 0x5001 75 /* Customer Addresses: 0x7010 - 0x710F */ 76 #define CUSTOMER_USE_OTP_SIZE 0x100 77 /* OTP registers from sensor */ 78 #define OV2740_REG_OTP_CUSTOMER 0x7010 79 80 static const char * const ov2740_supply_name[] = { 81 "AVDD", 82 "DOVDD", 83 "DVDD", 84 }; 85 86 struct nvm_data { 87 struct nvmem_device *nvmem; 88 struct regmap *regmap; 89 char *nvm_buffer; 90 }; 91 92 enum { 93 OV2740_LINK_FREQ_360MHZ_INDEX, 94 OV2740_LINK_FREQ_180MHZ_INDEX, 95 }; 96 97 struct ov2740_reg { 98 u16 address; 99 u8 val; 100 }; 101 102 struct ov2740_reg_list { 103 u32 num_of_regs; 104 const struct ov2740_reg *regs; 105 }; 106 107 struct ov2740_link_freq_config { 108 const struct ov2740_reg_list reg_list; 109 }; 110 111 struct ov2740_mode { 112 /* Frame width in pixels */ 113 u32 width; 114 115 /* Frame height in pixels */ 116 u32 height; 117 118 /* Horizontal timining size */ 119 u32 hts; 120 121 /* Default vertical timining size */ 122 u32 vts_def; 123 124 /* Min vertical timining size */ 125 u32 vts_min; 126 127 /* Max vertical timining size */ 128 u32 vts_max; 129 130 /* Link frequency needed for this resolution */ 131 u32 link_freq_index; 132 133 /* Sensor register settings for this resolution */ 134 const struct ov2740_reg_list reg_list; 135 }; 136 137 static const struct ov2740_reg mipi_data_rate_720mbps[] = { 138 {0x0302, 0x4b}, 139 {0x030d, 0x4b}, 140 {0x030e, 0x02}, 141 {0x030a, 0x01}, 142 {0x0312, 0x11}, 143 }; 144 145 static const struct ov2740_reg mipi_data_rate_360mbps[] = { 146 {0x0302, 0x4b}, 147 {0x0303, 0x01}, 148 {0x030d, 0x4b}, 149 {0x030e, 0x02}, 150 {0x030a, 0x01}, 151 {0x0312, 0x11}, 152 {0x4837, 0x2c}, 153 }; 154 155 static const struct ov2740_reg mode_1932x1092_regs_360mhz[] = { 156 {0x3000, 0x00}, 157 {0x3018, 0x32}, 158 {0x3031, 0x0a}, 159 {0x3080, 0x08}, 160 {0x3083, 0xB4}, 161 {0x3103, 0x00}, 162 {0x3104, 0x01}, 163 {0x3106, 0x01}, 164 {0x3500, 0x00}, 165 {0x3501, 0x44}, 166 {0x3502, 0x40}, 167 {0x3503, 0x88}, 168 {0x3507, 0x00}, 169 {0x3508, 0x00}, 170 {0x3509, 0x80}, 171 {0x350c, 0x00}, 172 {0x350d, 0x80}, 173 {0x3510, 0x00}, 174 {0x3511, 0x00}, 175 {0x3512, 0x20}, 176 {0x3632, 0x00}, 177 {0x3633, 0x10}, 178 {0x3634, 0x10}, 179 {0x3635, 0x10}, 180 {0x3645, 0x13}, 181 {0x3646, 0x81}, 182 {0x3636, 0x10}, 183 {0x3651, 0x0a}, 184 {0x3656, 0x02}, 185 {0x3659, 0x04}, 186 {0x365a, 0xda}, 187 {0x365b, 0xa2}, 188 {0x365c, 0x04}, 189 {0x365d, 0x1d}, 190 {0x365e, 0x1a}, 191 {0x3662, 0xd7}, 192 {0x3667, 0x78}, 193 {0x3669, 0x0a}, 194 {0x366a, 0x92}, 195 {0x3700, 0x54}, 196 {0x3702, 0x10}, 197 {0x3706, 0x42}, 198 {0x3709, 0x30}, 199 {0x370b, 0xc2}, 200 {0x3714, 0x63}, 201 {0x3715, 0x01}, 202 {0x3716, 0x00}, 203 {0x371a, 0x3e}, 204 {0x3732, 0x0e}, 205 {0x3733, 0x10}, 206 {0x375f, 0x0e}, 207 {0x3768, 0x30}, 208 {0x3769, 0x44}, 209 {0x376a, 0x22}, 210 {0x377b, 0x20}, 211 {0x377c, 0x00}, 212 {0x377d, 0x0c}, 213 {0x3798, 0x00}, 214 {0x37a1, 0x55}, 215 {0x37a8, 0x6d}, 216 {0x37c2, 0x04}, 217 {0x37c5, 0x00}, 218 {0x37c8, 0x00}, 219 {0x3800, 0x00}, 220 {0x3801, 0x00}, 221 {0x3802, 0x00}, 222 {0x3803, 0x00}, 223 {0x3804, 0x07}, 224 {0x3805, 0x8f}, 225 {0x3806, 0x04}, 226 {0x3807, 0x47}, 227 {0x3808, 0x07}, 228 {0x3809, 0x88}, 229 {0x380a, 0x04}, 230 {0x380b, 0x40}, 231 {0x380c, 0x04}, 232 {0x380d, 0x38}, 233 {0x380e, 0x04}, 234 {0x380f, 0x60}, 235 {0x3810, 0x00}, 236 {0x3811, 0x04}, 237 {0x3812, 0x00}, 238 {0x3813, 0x04}, 239 {0x3814, 0x01}, 240 {0x3815, 0x01}, 241 {0x3820, 0x80}, 242 {0x3821, 0x46}, 243 {0x3822, 0x84}, 244 {0x3829, 0x00}, 245 {0x382a, 0x01}, 246 {0x382b, 0x01}, 247 {0x3830, 0x04}, 248 {0x3836, 0x01}, 249 {0x3837, 0x08}, 250 {0x3839, 0x01}, 251 {0x383a, 0x00}, 252 {0x383b, 0x08}, 253 {0x383c, 0x00}, 254 {0x3f0b, 0x00}, 255 {0x4001, 0x20}, 256 {0x4009, 0x07}, 257 {0x4003, 0x10}, 258 {0x4010, 0xe0}, 259 {0x4016, 0x00}, 260 {0x4017, 0x10}, 261 {0x4044, 0x02}, 262 {0x4304, 0x08}, 263 {0x4307, 0x30}, 264 {0x4320, 0x80}, 265 {0x4322, 0x00}, 266 {0x4323, 0x00}, 267 {0x4324, 0x00}, 268 {0x4325, 0x00}, 269 {0x4326, 0x00}, 270 {0x4327, 0x00}, 271 {0x4328, 0x00}, 272 {0x4329, 0x00}, 273 {0x432c, 0x03}, 274 {0x432d, 0x81}, 275 {0x4501, 0x84}, 276 {0x4502, 0x40}, 277 {0x4503, 0x18}, 278 {0x4504, 0x04}, 279 {0x4508, 0x02}, 280 {0x4601, 0x10}, 281 {0x4800, 0x00}, 282 {0x4816, 0x52}, 283 {0x4837, 0x16}, 284 {0x5000, 0x7f}, 285 {0x5001, 0x00}, 286 {0x5005, 0x38}, 287 {0x501e, 0x0d}, 288 {0x5040, 0x00}, 289 {0x5901, 0x00}, 290 {0x3800, 0x00}, 291 {0x3801, 0x00}, 292 {0x3802, 0x00}, 293 {0x3803, 0x00}, 294 {0x3804, 0x07}, 295 {0x3805, 0x8f}, 296 {0x3806, 0x04}, 297 {0x3807, 0x47}, 298 {0x3808, 0x07}, 299 {0x3809, 0x8c}, 300 {0x380a, 0x04}, 301 {0x380b, 0x44}, 302 {0x3810, 0x00}, 303 {0x3811, 0x00}, 304 {0x3812, 0x00}, 305 {0x3813, 0x01}, 306 }; 307 308 static const struct ov2740_reg mode_1932x1092_regs_180mhz[] = { 309 {0x3000, 0x00}, 310 {0x3018, 0x32}, /* 0x32 for 2 lanes, 0x12 for 1 lane */ 311 {0x3031, 0x0a}, 312 {0x3080, 0x08}, 313 {0x3083, 0xB4}, 314 {0x3103, 0x00}, 315 {0x3104, 0x01}, 316 {0x3106, 0x01}, 317 {0x3500, 0x00}, 318 {0x3501, 0x44}, 319 {0x3502, 0x40}, 320 {0x3503, 0x88}, 321 {0x3507, 0x00}, 322 {0x3508, 0x00}, 323 {0x3509, 0x80}, 324 {0x350c, 0x00}, 325 {0x350d, 0x80}, 326 {0x3510, 0x00}, 327 {0x3511, 0x00}, 328 {0x3512, 0x20}, 329 {0x3632, 0x00}, 330 {0x3633, 0x10}, 331 {0x3634, 0x10}, 332 {0x3635, 0x10}, 333 {0x3645, 0x13}, 334 {0x3646, 0x81}, 335 {0x3636, 0x10}, 336 {0x3651, 0x0a}, 337 {0x3656, 0x02}, 338 {0x3659, 0x04}, 339 {0x365a, 0xda}, 340 {0x365b, 0xa2}, 341 {0x365c, 0x04}, 342 {0x365d, 0x1d}, 343 {0x365e, 0x1a}, 344 {0x3662, 0xd7}, 345 {0x3667, 0x78}, 346 {0x3669, 0x0a}, 347 {0x366a, 0x92}, 348 {0x3700, 0x54}, 349 {0x3702, 0x10}, 350 {0x3706, 0x42}, 351 {0x3709, 0x30}, 352 {0x370b, 0xc2}, 353 {0x3714, 0x63}, 354 {0x3715, 0x01}, 355 {0x3716, 0x00}, 356 {0x371a, 0x3e}, 357 {0x3732, 0x0e}, 358 {0x3733, 0x10}, 359 {0x375f, 0x0e}, 360 {0x3768, 0x30}, 361 {0x3769, 0x44}, 362 {0x376a, 0x22}, 363 {0x377b, 0x20}, 364 {0x377c, 0x00}, 365 {0x377d, 0x0c}, 366 {0x3798, 0x00}, 367 {0x37a1, 0x55}, 368 {0x37a8, 0x6d}, 369 {0x37c2, 0x04}, 370 {0x37c5, 0x00}, 371 {0x37c8, 0x00}, 372 {0x3800, 0x00}, 373 {0x3801, 0x00}, 374 {0x3802, 0x00}, 375 {0x3803, 0x00}, 376 {0x3804, 0x07}, 377 {0x3805, 0x8f}, 378 {0x3806, 0x04}, 379 {0x3807, 0x47}, 380 {0x3808, 0x07}, 381 {0x3809, 0x88}, 382 {0x380a, 0x04}, 383 {0x380b, 0x40}, 384 {0x380c, 0x08}, 385 {0x380d, 0x70}, 386 {0x380e, 0x04}, 387 {0x380f, 0x56}, 388 {0x3810, 0x00}, 389 {0x3811, 0x04}, 390 {0x3812, 0x00}, 391 {0x3813, 0x04}, 392 {0x3814, 0x01}, 393 {0x3815, 0x01}, 394 {0x3820, 0x80}, 395 {0x3821, 0x46}, 396 {0x3822, 0x84}, 397 {0x3829, 0x00}, 398 {0x382a, 0x01}, 399 {0x382b, 0x01}, 400 {0x3830, 0x04}, 401 {0x3836, 0x01}, 402 {0x3837, 0x08}, 403 {0x3839, 0x01}, 404 {0x383a, 0x00}, 405 {0x383b, 0x08}, 406 {0x383c, 0x00}, 407 {0x3f0b, 0x00}, 408 {0x4001, 0x20}, 409 {0x4009, 0x07}, 410 {0x4003, 0x10}, 411 {0x4010, 0xe0}, 412 {0x4016, 0x00}, 413 {0x4017, 0x10}, 414 {0x4044, 0x02}, 415 {0x4304, 0x08}, 416 {0x4307, 0x30}, 417 {0x4320, 0x80}, 418 {0x4322, 0x00}, 419 {0x4323, 0x00}, 420 {0x4324, 0x00}, 421 {0x4325, 0x00}, 422 {0x4326, 0x00}, 423 {0x4327, 0x00}, 424 {0x4328, 0x00}, 425 {0x4329, 0x00}, 426 {0x432c, 0x03}, 427 {0x432d, 0x81}, 428 {0x4501, 0x84}, 429 {0x4502, 0x40}, 430 {0x4503, 0x18}, 431 {0x4504, 0x04}, 432 {0x4508, 0x02}, 433 {0x4601, 0x10}, 434 {0x4800, 0x00}, 435 {0x4816, 0x52}, 436 {0x5000, 0x73}, /* 0x7f enable DPC */ 437 {0x5001, 0x00}, 438 {0x5005, 0x38}, 439 {0x501e, 0x0d}, 440 {0x5040, 0x00}, 441 {0x5901, 0x00}, 442 {0x3800, 0x00}, 443 {0x3801, 0x00}, 444 {0x3802, 0x00}, 445 {0x3803, 0x00}, 446 {0x3804, 0x07}, 447 {0x3805, 0x8f}, 448 {0x3806, 0x04}, 449 {0x3807, 0x47}, 450 {0x3808, 0x07}, 451 {0x3809, 0x8c}, 452 {0x380a, 0x04}, 453 {0x380b, 0x44}, 454 {0x3810, 0x00}, 455 {0x3811, 0x00}, 456 {0x3812, 0x00}, 457 {0x3813, 0x01}, 458 {0x4003, 0x40}, /* set Black level to 0x40 */ 459 }; 460 461 static const char * const ov2740_test_pattern_menu[] = { 462 "Disabled", 463 "Color Bar", 464 "Top-Bottom Darker Color Bar", 465 "Right-Left Darker Color Bar", 466 "Bottom-Top Darker Color Bar", 467 }; 468 469 static const s64 link_freq_menu_items[] = { 470 OV2740_LINK_FREQ_360MHZ, 471 OV2740_LINK_FREQ_180MHZ, 472 }; 473 474 static const struct ov2740_link_freq_config link_freq_configs[] = { 475 [OV2740_LINK_FREQ_360MHZ_INDEX] = { 476 .reg_list = { 477 .num_of_regs = ARRAY_SIZE(mipi_data_rate_720mbps), 478 .regs = mipi_data_rate_720mbps, 479 } 480 }, 481 [OV2740_LINK_FREQ_180MHZ_INDEX] = { 482 .reg_list = { 483 .num_of_regs = ARRAY_SIZE(mipi_data_rate_360mbps), 484 .regs = mipi_data_rate_360mbps, 485 } 486 }, 487 }; 488 489 static const struct ov2740_mode supported_modes_360mhz[] = { 490 { 491 .width = 1932, 492 .height = 1092, 493 .hts = 2160, 494 .vts_min = 1120, 495 .vts_def = 2186, 496 .vts_max = 32767, 497 .reg_list = { 498 .num_of_regs = ARRAY_SIZE(mode_1932x1092_regs_360mhz), 499 .regs = mode_1932x1092_regs_360mhz, 500 }, 501 .link_freq_index = OV2740_LINK_FREQ_360MHZ_INDEX, 502 }, 503 }; 504 505 static const struct ov2740_mode supported_modes_180mhz[] = { 506 { 507 .width = 1932, 508 .height = 1092, 509 .hts = 2160, 510 .vts_min = 1110, 511 .vts_def = 1110, 512 .vts_max = 2047, 513 .reg_list = { 514 .num_of_regs = ARRAY_SIZE(mode_1932x1092_regs_180mhz), 515 .regs = mode_1932x1092_regs_180mhz, 516 }, 517 .link_freq_index = OV2740_LINK_FREQ_180MHZ_INDEX, 518 }, 519 }; 520 521 struct ov2740 { 522 struct v4l2_subdev sd; 523 struct media_pad pad; 524 struct v4l2_ctrl_handler ctrl_handler; 525 526 /* V4L2 Controls */ 527 struct v4l2_ctrl *link_freq; 528 struct v4l2_ctrl *pixel_rate; 529 struct v4l2_ctrl *vblank; 530 struct v4l2_ctrl *hblank; 531 struct v4l2_ctrl *exposure; 532 533 /* GPIOs, clocks, regulators */ 534 struct gpio_desc *reset_gpio; 535 struct gpio_desc *powerdown_gpio; 536 struct clk *clk; 537 struct regulator_bulk_data supplies[ARRAY_SIZE(ov2740_supply_name)]; 538 539 /* Current mode */ 540 const struct ov2740_mode *cur_mode; 541 542 /* NVM data information */ 543 struct nvm_data *nvm; 544 545 /* Supported modes */ 546 const struct ov2740_mode *supported_modes; 547 int supported_modes_count; 548 549 /* True if the device has been identified */ 550 bool identified; 551 }; 552 553 static inline struct ov2740 *to_ov2740(struct v4l2_subdev *subdev) 554 { 555 return container_of(subdev, struct ov2740, sd); 556 } 557 558 static u64 to_pixel_rate(u32 f_index) 559 { 560 u64 pixel_rate = link_freq_menu_items[f_index] * 2 * OV2740_DATA_LANES; 561 562 do_div(pixel_rate, OV2740_RGB_DEPTH); 563 564 return pixel_rate; 565 } 566 567 static int ov2740_read_reg(struct ov2740 *ov2740, u16 reg, u16 len, u32 *val) 568 { 569 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 570 struct i2c_msg msgs[2]; 571 u8 addr_buf[2]; 572 u8 data_buf[4] = {0}; 573 int ret; 574 575 if (len > sizeof(data_buf)) 576 return -EINVAL; 577 578 put_unaligned_be16(reg, addr_buf); 579 msgs[0].addr = client->addr; 580 msgs[0].flags = 0; 581 msgs[0].len = sizeof(addr_buf); 582 msgs[0].buf = addr_buf; 583 msgs[1].addr = client->addr; 584 msgs[1].flags = I2C_M_RD; 585 msgs[1].len = len; 586 msgs[1].buf = &data_buf[sizeof(data_buf) - len]; 587 588 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 589 if (ret != ARRAY_SIZE(msgs)) 590 return ret < 0 ? ret : -EIO; 591 592 *val = get_unaligned_be32(data_buf); 593 594 return 0; 595 } 596 597 static int ov2740_write_reg(struct ov2740 *ov2740, u16 reg, u16 len, u32 val) 598 { 599 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 600 u8 buf[6]; 601 int ret; 602 603 if (len > 4) 604 return -EINVAL; 605 606 put_unaligned_be16(reg, buf); 607 put_unaligned_be32(val << 8 * (4 - len), buf + 2); 608 609 ret = i2c_master_send(client, buf, len + 2); 610 if (ret != len + 2) 611 return ret < 0 ? ret : -EIO; 612 613 return 0; 614 } 615 616 static int ov2740_write_reg_list(struct ov2740 *ov2740, 617 const struct ov2740_reg_list *r_list) 618 { 619 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 620 unsigned int i; 621 int ret; 622 623 for (i = 0; i < r_list->num_of_regs; i++) { 624 ret = ov2740_write_reg(ov2740, r_list->regs[i].address, 1, 625 r_list->regs[i].val); 626 if (ret) { 627 dev_err_ratelimited(&client->dev, 628 "write reg 0x%4.4x return err = %d\n", 629 r_list->regs[i].address, ret); 630 return ret; 631 } 632 } 633 634 return 0; 635 } 636 637 static int ov2740_identify_module(struct ov2740 *ov2740) 638 { 639 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 640 int ret; 641 u32 val; 642 643 if (ov2740->identified) 644 return 0; 645 646 ret = ov2740_read_reg(ov2740, OV2740_REG_CHIP_ID, 3, &val); 647 if (ret) 648 return ret; 649 650 if (val != OV2740_CHIP_ID) { 651 dev_err(&client->dev, "chip id mismatch: %x != %x\n", 652 OV2740_CHIP_ID, val); 653 return -ENXIO; 654 } 655 656 dev_dbg(&client->dev, "chip id: 0x%x\n", val); 657 658 ov2740->identified = true; 659 660 return 0; 661 } 662 663 static int ov2740_update_digital_gain(struct ov2740 *ov2740, u32 d_gain) 664 { 665 int ret; 666 667 ret = ov2740_write_reg(ov2740, OV2740_REG_GROUP_ACCESS, 1, 668 OV2740_GROUP_HOLD_START); 669 if (ret) 670 return ret; 671 672 ret = ov2740_write_reg(ov2740, OV2740_REG_MWB_R_GAIN, 2, d_gain); 673 if (ret) 674 return ret; 675 676 ret = ov2740_write_reg(ov2740, OV2740_REG_MWB_G_GAIN, 2, d_gain); 677 if (ret) 678 return ret; 679 680 ret = ov2740_write_reg(ov2740, OV2740_REG_MWB_B_GAIN, 2, d_gain); 681 if (ret) 682 return ret; 683 684 ret = ov2740_write_reg(ov2740, OV2740_REG_GROUP_ACCESS, 1, 685 OV2740_GROUP_HOLD_END); 686 if (ret) 687 return ret; 688 689 ret = ov2740_write_reg(ov2740, OV2740_REG_GROUP_ACCESS, 1, 690 OV2740_GROUP_HOLD_LAUNCH); 691 return ret; 692 } 693 694 static int ov2740_test_pattern(struct ov2740 *ov2740, u32 pattern) 695 { 696 if (pattern) 697 pattern = (pattern - 1) << OV2740_TEST_PATTERN_BAR_SHIFT | 698 OV2740_TEST_PATTERN_ENABLE; 699 700 return ov2740_write_reg(ov2740, OV2740_REG_TEST_PATTERN, 1, pattern); 701 } 702 703 static int ov2740_set_ctrl(struct v4l2_ctrl *ctrl) 704 { 705 struct ov2740 *ov2740 = container_of(ctrl->handler, 706 struct ov2740, ctrl_handler); 707 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 708 s64 exposure_max; 709 int ret; 710 711 /* Propagate change of current control to all related controls */ 712 if (ctrl->id == V4L2_CID_VBLANK) { 713 /* Update max exposure while meeting expected vblanking */ 714 exposure_max = ov2740->cur_mode->height + ctrl->val - 715 OV2740_EXPOSURE_MAX_MARGIN; 716 __v4l2_ctrl_modify_range(ov2740->exposure, 717 ov2740->exposure->minimum, 718 exposure_max, ov2740->exposure->step, 719 exposure_max); 720 } 721 722 /* V4L2 controls values will be applied only when power is already up */ 723 if (!pm_runtime_get_if_in_use(&client->dev)) 724 return 0; 725 726 switch (ctrl->id) { 727 case V4L2_CID_ANALOGUE_GAIN: 728 ret = ov2740_write_reg(ov2740, OV2740_REG_ANALOG_GAIN, 2, 729 ctrl->val); 730 break; 731 732 case V4L2_CID_DIGITAL_GAIN: 733 ret = ov2740_update_digital_gain(ov2740, ctrl->val); 734 break; 735 736 case V4L2_CID_EXPOSURE: 737 /* 4 least significant bits of expsoure are fractional part */ 738 ret = ov2740_write_reg(ov2740, OV2740_REG_EXPOSURE, 3, 739 ctrl->val << 4); 740 break; 741 742 case V4L2_CID_VBLANK: 743 ret = ov2740_write_reg(ov2740, OV2740_REG_VTS, 2, 744 ov2740->cur_mode->height + ctrl->val); 745 break; 746 747 case V4L2_CID_TEST_PATTERN: 748 ret = ov2740_test_pattern(ov2740, ctrl->val); 749 break; 750 751 default: 752 ret = -EINVAL; 753 break; 754 } 755 756 pm_runtime_put(&client->dev); 757 758 return ret; 759 } 760 761 static const struct v4l2_ctrl_ops ov2740_ctrl_ops = { 762 .s_ctrl = ov2740_set_ctrl, 763 }; 764 765 static int ov2740_init_controls(struct ov2740 *ov2740) 766 { 767 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 768 struct v4l2_ctrl_handler *ctrl_hdlr; 769 const struct ov2740_mode *cur_mode; 770 s64 exposure_max, h_blank, pixel_rate; 771 u32 vblank_min, vblank_max, vblank_default; 772 struct v4l2_fwnode_device_properties props; 773 int size; 774 int ret; 775 776 ctrl_hdlr = &ov2740->ctrl_handler; 777 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 10); 778 if (ret) 779 return ret; 780 781 cur_mode = ov2740->cur_mode; 782 size = ARRAY_SIZE(link_freq_menu_items); 783 784 ov2740->link_freq = 785 v4l2_ctrl_new_int_menu(ctrl_hdlr, &ov2740_ctrl_ops, 786 V4L2_CID_LINK_FREQ, size - 1, 787 ov2740->supported_modes->link_freq_index, 788 link_freq_menu_items); 789 if (ov2740->link_freq) 790 ov2740->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; 791 792 pixel_rate = to_pixel_rate(ov2740->supported_modes->link_freq_index); 793 ov2740->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &ov2740_ctrl_ops, 794 V4L2_CID_PIXEL_RATE, 0, 795 pixel_rate, 1, pixel_rate); 796 797 vblank_min = cur_mode->vts_min - cur_mode->height; 798 vblank_max = cur_mode->vts_max - cur_mode->height; 799 vblank_default = cur_mode->vts_def - cur_mode->height; 800 ov2740->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &ov2740_ctrl_ops, 801 V4L2_CID_VBLANK, vblank_min, 802 vblank_max, 1, vblank_default); 803 804 h_blank = cur_mode->hts - cur_mode->width; 805 ov2740->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &ov2740_ctrl_ops, 806 V4L2_CID_HBLANK, h_blank, h_blank, 1, 807 h_blank); 808 if (ov2740->hblank) 809 ov2740->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY; 810 811 v4l2_ctrl_new_std(ctrl_hdlr, &ov2740_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, 812 OV2740_ANAL_GAIN_MIN, OV2740_ANAL_GAIN_MAX, 813 OV2740_ANAL_GAIN_STEP, OV2740_ANAL_GAIN_MIN); 814 v4l2_ctrl_new_std(ctrl_hdlr, &ov2740_ctrl_ops, V4L2_CID_DIGITAL_GAIN, 815 OV2740_DGTL_GAIN_MIN, OV2740_DGTL_GAIN_MAX, 816 OV2740_DGTL_GAIN_STEP, OV2740_DGTL_GAIN_DEFAULT); 817 exposure_max = cur_mode->vts_def - OV2740_EXPOSURE_MAX_MARGIN; 818 ov2740->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &ov2740_ctrl_ops, 819 V4L2_CID_EXPOSURE, 820 OV2740_EXPOSURE_MIN, exposure_max, 821 OV2740_EXPOSURE_STEP, 822 exposure_max); 823 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &ov2740_ctrl_ops, 824 V4L2_CID_TEST_PATTERN, 825 ARRAY_SIZE(ov2740_test_pattern_menu) - 1, 826 0, 0, ov2740_test_pattern_menu); 827 828 ret = v4l2_fwnode_device_parse(&client->dev, &props); 829 if (ret) { 830 v4l2_ctrl_handler_free(ctrl_hdlr); 831 return ret; 832 } 833 834 v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &ov2740_ctrl_ops, &props); 835 836 if (ctrl_hdlr->error) { 837 v4l2_ctrl_handler_free(ctrl_hdlr); 838 return ctrl_hdlr->error; 839 } 840 841 ov2740->sd.ctrl_handler = ctrl_hdlr; 842 843 return 0; 844 } 845 846 static void ov2740_update_pad_format(const struct ov2740_mode *mode, 847 struct v4l2_mbus_framefmt *fmt) 848 { 849 fmt->width = mode->width; 850 fmt->height = mode->height; 851 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10; 852 fmt->field = V4L2_FIELD_NONE; 853 } 854 855 static int ov2740_load_otp_data(struct nvm_data *nvm) 856 { 857 struct device *dev = regmap_get_device(nvm->regmap); 858 struct ov2740 *ov2740 = to_ov2740(dev_get_drvdata(dev)); 859 u32 isp_ctrl00 = 0; 860 u32 isp_ctrl01 = 0; 861 int ret; 862 863 if (nvm->nvm_buffer) 864 return 0; 865 866 nvm->nvm_buffer = kzalloc(CUSTOMER_USE_OTP_SIZE, GFP_KERNEL); 867 if (!nvm->nvm_buffer) 868 return -ENOMEM; 869 870 ret = ov2740_read_reg(ov2740, OV2740_REG_ISP_CTRL00, 1, &isp_ctrl00); 871 if (ret) { 872 dev_err(dev, "failed to read ISP CTRL00\n"); 873 goto err; 874 } 875 876 ret = ov2740_read_reg(ov2740, OV2740_REG_ISP_CTRL01, 1, &isp_ctrl01); 877 if (ret) { 878 dev_err(dev, "failed to read ISP CTRL01\n"); 879 goto err; 880 } 881 882 /* Clear bit 5 of ISP CTRL00 */ 883 ret = ov2740_write_reg(ov2740, OV2740_REG_ISP_CTRL00, 1, 884 isp_ctrl00 & ~BIT(5)); 885 if (ret) { 886 dev_err(dev, "failed to set ISP CTRL00\n"); 887 goto err; 888 } 889 890 /* Clear bit 7 of ISP CTRL01 */ 891 ret = ov2740_write_reg(ov2740, OV2740_REG_ISP_CTRL01, 1, 892 isp_ctrl01 & ~BIT(7)); 893 if (ret) { 894 dev_err(dev, "failed to set ISP CTRL01\n"); 895 goto err; 896 } 897 898 ret = ov2740_write_reg(ov2740, OV2740_REG_MODE_SELECT, 1, 899 OV2740_MODE_STREAMING); 900 if (ret) { 901 dev_err(dev, "failed to set streaming mode\n"); 902 goto err; 903 } 904 905 /* 906 * Users are not allowed to access OTP-related registers and memory 907 * during the 20 ms period after streaming starts (0x100 = 0x01). 908 */ 909 msleep(20); 910 911 ret = regmap_bulk_read(nvm->regmap, OV2740_REG_OTP_CUSTOMER, 912 nvm->nvm_buffer, CUSTOMER_USE_OTP_SIZE); 913 if (ret) { 914 dev_err(dev, "failed to read OTP data, ret %d\n", ret); 915 goto err; 916 } 917 918 ret = ov2740_write_reg(ov2740, OV2740_REG_MODE_SELECT, 1, 919 OV2740_MODE_STANDBY); 920 if (ret) { 921 dev_err(dev, "failed to set streaming mode\n"); 922 goto err; 923 } 924 925 ret = ov2740_write_reg(ov2740, OV2740_REG_ISP_CTRL01, 1, isp_ctrl01); 926 if (ret) { 927 dev_err(dev, "failed to set ISP CTRL01\n"); 928 goto err; 929 } 930 931 ret = ov2740_write_reg(ov2740, OV2740_REG_ISP_CTRL00, 1, isp_ctrl00); 932 if (ret) { 933 dev_err(dev, "failed to set ISP CTRL00\n"); 934 goto err; 935 } 936 937 return 0; 938 err: 939 kfree(nvm->nvm_buffer); 940 nvm->nvm_buffer = NULL; 941 942 return ret; 943 } 944 945 static int ov2740_start_streaming(struct ov2740 *ov2740) 946 { 947 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 948 const struct ov2740_reg_list *reg_list; 949 int link_freq_index; 950 int ret; 951 952 ret = ov2740_identify_module(ov2740); 953 if (ret) 954 return ret; 955 956 if (ov2740->nvm) 957 ov2740_load_otp_data(ov2740->nvm); 958 959 /* Reset the sensor */ 960 ret = ov2740_write_reg(ov2740, 0x0103, 1, 0x01); 961 if (ret) { 962 dev_err(&client->dev, "failed to reset\n"); 963 return ret; 964 } 965 966 usleep_range(10000, 15000); 967 968 link_freq_index = ov2740->cur_mode->link_freq_index; 969 reg_list = &link_freq_configs[link_freq_index].reg_list; 970 ret = ov2740_write_reg_list(ov2740, reg_list); 971 if (ret) { 972 dev_err(&client->dev, "failed to set plls\n"); 973 return ret; 974 } 975 976 reg_list = &ov2740->cur_mode->reg_list; 977 ret = ov2740_write_reg_list(ov2740, reg_list); 978 if (ret) { 979 dev_err(&client->dev, "failed to set mode\n"); 980 return ret; 981 } 982 983 ret = __v4l2_ctrl_handler_setup(ov2740->sd.ctrl_handler); 984 if (ret) 985 return ret; 986 987 ret = ov2740_write_reg(ov2740, OV2740_REG_MODE_SELECT, 1, 988 OV2740_MODE_STREAMING); 989 if (ret) 990 dev_err(&client->dev, "failed to start streaming\n"); 991 992 return ret; 993 } 994 995 static void ov2740_stop_streaming(struct ov2740 *ov2740) 996 { 997 struct i2c_client *client = v4l2_get_subdevdata(&ov2740->sd); 998 999 if (ov2740_write_reg(ov2740, OV2740_REG_MODE_SELECT, 1, 1000 OV2740_MODE_STANDBY)) 1001 dev_err(&client->dev, "failed to stop streaming\n"); 1002 } 1003 1004 static int ov2740_set_stream(struct v4l2_subdev *sd, int enable) 1005 { 1006 struct ov2740 *ov2740 = to_ov2740(sd); 1007 struct i2c_client *client = v4l2_get_subdevdata(sd); 1008 struct v4l2_subdev_state *sd_state; 1009 int ret = 0; 1010 1011 sd_state = v4l2_subdev_lock_and_get_active_state(&ov2740->sd); 1012 1013 if (enable) { 1014 ret = pm_runtime_resume_and_get(&client->dev); 1015 if (ret < 0) 1016 goto out_unlock; 1017 1018 ret = ov2740_start_streaming(ov2740); 1019 if (ret) { 1020 enable = 0; 1021 ov2740_stop_streaming(ov2740); 1022 pm_runtime_put(&client->dev); 1023 } 1024 } else { 1025 ov2740_stop_streaming(ov2740); 1026 pm_runtime_put(&client->dev); 1027 } 1028 1029 out_unlock: 1030 v4l2_subdev_unlock_state(sd_state); 1031 1032 return ret; 1033 } 1034 1035 static int ov2740_set_format(struct v4l2_subdev *sd, 1036 struct v4l2_subdev_state *sd_state, 1037 struct v4l2_subdev_format *fmt) 1038 { 1039 struct ov2740 *ov2740 = to_ov2740(sd); 1040 const struct ov2740_mode *mode; 1041 s32 vblank_def, h_blank; 1042 1043 mode = v4l2_find_nearest_size(ov2740->supported_modes, 1044 ov2740->supported_modes_count, 1045 width, height, 1046 fmt->format.width, fmt->format.height); 1047 1048 ov2740_update_pad_format(mode, &fmt->format); 1049 *v4l2_subdev_state_get_format(sd_state, fmt->pad) = fmt->format; 1050 1051 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) 1052 return 0; 1053 1054 ov2740->cur_mode = mode; 1055 __v4l2_ctrl_s_ctrl(ov2740->link_freq, mode->link_freq_index); 1056 __v4l2_ctrl_s_ctrl_int64(ov2740->pixel_rate, 1057 to_pixel_rate(mode->link_freq_index)); 1058 1059 /* Update limits and set FPS to default */ 1060 vblank_def = mode->vts_def - mode->height; 1061 __v4l2_ctrl_modify_range(ov2740->vblank, 1062 mode->vts_min - mode->height, 1063 mode->vts_max - mode->height, 1, vblank_def); 1064 __v4l2_ctrl_s_ctrl(ov2740->vblank, vblank_def); 1065 h_blank = mode->hts - mode->width; 1066 __v4l2_ctrl_modify_range(ov2740->hblank, h_blank, h_blank, 1, h_blank); 1067 1068 return 0; 1069 } 1070 1071 static int ov2740_enum_mbus_code(struct v4l2_subdev *sd, 1072 struct v4l2_subdev_state *sd_state, 1073 struct v4l2_subdev_mbus_code_enum *code) 1074 { 1075 if (code->index > 0) 1076 return -EINVAL; 1077 1078 code->code = MEDIA_BUS_FMT_SGRBG10_1X10; 1079 1080 return 0; 1081 } 1082 1083 static int ov2740_enum_frame_size(struct v4l2_subdev *sd, 1084 struct v4l2_subdev_state *sd_state, 1085 struct v4l2_subdev_frame_size_enum *fse) 1086 { 1087 struct ov2740 *ov2740 = to_ov2740(sd); 1088 const struct ov2740_mode *supported_modes = ov2740->supported_modes; 1089 1090 if (fse->index >= ov2740->supported_modes_count) 1091 return -EINVAL; 1092 1093 if (fse->code != MEDIA_BUS_FMT_SGRBG10_1X10) 1094 return -EINVAL; 1095 1096 fse->min_width = supported_modes[fse->index].width; 1097 fse->max_width = fse->min_width; 1098 fse->min_height = supported_modes[fse->index].height; 1099 fse->max_height = fse->min_height; 1100 1101 return 0; 1102 } 1103 1104 static int ov2740_init_state(struct v4l2_subdev *sd, 1105 struct v4l2_subdev_state *sd_state) 1106 { 1107 struct ov2740 *ov2740 = to_ov2740(sd); 1108 1109 ov2740_update_pad_format(&ov2740->supported_modes[0], 1110 v4l2_subdev_state_get_format(sd_state, 0)); 1111 return 0; 1112 } 1113 1114 static const struct v4l2_subdev_video_ops ov2740_video_ops = { 1115 .s_stream = ov2740_set_stream, 1116 }; 1117 1118 static const struct v4l2_subdev_pad_ops ov2740_pad_ops = { 1119 .get_fmt = v4l2_subdev_get_fmt, 1120 .set_fmt = ov2740_set_format, 1121 .enum_mbus_code = ov2740_enum_mbus_code, 1122 .enum_frame_size = ov2740_enum_frame_size, 1123 }; 1124 1125 static const struct v4l2_subdev_ops ov2740_subdev_ops = { 1126 .video = &ov2740_video_ops, 1127 .pad = &ov2740_pad_ops, 1128 }; 1129 1130 static const struct v4l2_subdev_internal_ops ov2740_internal_ops = { 1131 .init_state = ov2740_init_state, 1132 }; 1133 1134 static const struct media_entity_operations ov2740_subdev_entity_ops = { 1135 .link_validate = v4l2_subdev_link_validate, 1136 }; 1137 1138 static int ov2740_check_hwcfg(struct device *dev) 1139 { 1140 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1141 struct ov2740 *ov2740 = to_ov2740(sd); 1142 struct fwnode_handle *ep; 1143 struct fwnode_handle *fwnode = dev_fwnode(dev); 1144 struct v4l2_fwnode_endpoint bus_cfg = { 1145 .bus_type = V4L2_MBUS_CSI2_DPHY 1146 }; 1147 u32 mclk; 1148 int ret; 1149 unsigned int i, j; 1150 1151 /* 1152 * Sometimes the fwnode graph is initialized by the bridge driver, 1153 * wait for this. 1154 */ 1155 ep = fwnode_graph_get_next_endpoint(fwnode, NULL); 1156 if (!ep) 1157 return dev_err_probe(dev, -EPROBE_DEFER, 1158 "waiting for fwnode graph endpoint\n"); 1159 1160 ret = fwnode_property_read_u32(fwnode, "clock-frequency", &mclk); 1161 if (ret) { 1162 fwnode_handle_put(ep); 1163 return dev_err_probe(dev, ret, 1164 "reading clock-frequency property\n"); 1165 } 1166 1167 if (mclk != OV2740_MCLK) { 1168 fwnode_handle_put(ep); 1169 return dev_err_probe(dev, -EINVAL, 1170 "external clock %d is not supported\n", 1171 mclk); 1172 } 1173 1174 ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); 1175 fwnode_handle_put(ep); 1176 if (ret) 1177 return dev_err_probe(dev, ret, "parsing endpoint failed\n"); 1178 1179 if (bus_cfg.bus.mipi_csi2.num_data_lanes != OV2740_DATA_LANES) { 1180 ret = dev_err_probe(dev, -EINVAL, 1181 "number of CSI2 data lanes %d is not supported\n", 1182 bus_cfg.bus.mipi_csi2.num_data_lanes); 1183 goto check_hwcfg_error; 1184 } 1185 1186 if (!bus_cfg.nr_of_link_frequencies) { 1187 ret = dev_err_probe(dev, -EINVAL, "no link frequencies defined\n"); 1188 goto check_hwcfg_error; 1189 } 1190 1191 for (i = 0; i < ARRAY_SIZE(link_freq_menu_items); i++) { 1192 for (j = 0; j < bus_cfg.nr_of_link_frequencies; j++) { 1193 if (link_freq_menu_items[i] == 1194 bus_cfg.link_frequencies[j]) 1195 break; 1196 } 1197 1198 if (j == bus_cfg.nr_of_link_frequencies) 1199 continue; 1200 1201 switch (i) { 1202 case OV2740_LINK_FREQ_360MHZ_INDEX: 1203 ov2740->supported_modes = supported_modes_360mhz; 1204 ov2740->supported_modes_count = 1205 ARRAY_SIZE(supported_modes_360mhz); 1206 break; 1207 case OV2740_LINK_FREQ_180MHZ_INDEX: 1208 ov2740->supported_modes = supported_modes_180mhz; 1209 ov2740->supported_modes_count = 1210 ARRAY_SIZE(supported_modes_180mhz); 1211 break; 1212 } 1213 1214 break; /* Prefer modes from first available link-freq */ 1215 } 1216 1217 if (!ov2740->supported_modes) 1218 ret = dev_err_probe(dev, -EINVAL, 1219 "no supported link frequencies\n"); 1220 1221 check_hwcfg_error: 1222 v4l2_fwnode_endpoint_free(&bus_cfg); 1223 1224 return ret; 1225 } 1226 1227 static void ov2740_remove(struct i2c_client *client) 1228 { 1229 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1230 1231 v4l2_async_unregister_subdev(sd); 1232 media_entity_cleanup(&sd->entity); 1233 v4l2_subdev_cleanup(sd); 1234 v4l2_ctrl_handler_free(sd->ctrl_handler); 1235 pm_runtime_disable(&client->dev); 1236 } 1237 1238 static int ov2740_nvmem_read(void *priv, unsigned int off, void *val, 1239 size_t count) 1240 { 1241 struct nvm_data *nvm = priv; 1242 struct device *dev = regmap_get_device(nvm->regmap); 1243 struct ov2740 *ov2740 = to_ov2740(dev_get_drvdata(dev)); 1244 struct v4l2_subdev_state *sd_state; 1245 int ret = 0; 1246 1247 /* Serialise sensor access */ 1248 sd_state = v4l2_subdev_lock_and_get_active_state(&ov2740->sd); 1249 1250 if (nvm->nvm_buffer) { 1251 memcpy(val, nvm->nvm_buffer + off, count); 1252 goto exit; 1253 } 1254 1255 ret = pm_runtime_resume_and_get(dev); 1256 if (ret < 0) { 1257 goto exit; 1258 } 1259 1260 ret = ov2740_load_otp_data(nvm); 1261 if (!ret) 1262 memcpy(val, nvm->nvm_buffer + off, count); 1263 1264 pm_runtime_put(dev); 1265 exit: 1266 v4l2_subdev_unlock_state(sd_state); 1267 return ret; 1268 } 1269 1270 static int ov2740_register_nvmem(struct i2c_client *client, 1271 struct ov2740 *ov2740) 1272 { 1273 struct nvm_data *nvm; 1274 struct regmap_config regmap_config = { }; 1275 struct nvmem_config nvmem_config = { }; 1276 struct regmap *regmap; 1277 struct device *dev = &client->dev; 1278 1279 nvm = devm_kzalloc(dev, sizeof(*nvm), GFP_KERNEL); 1280 if (!nvm) 1281 return -ENOMEM; 1282 1283 regmap_config.val_bits = 8; 1284 regmap_config.reg_bits = 16; 1285 regmap_config.disable_locking = true; 1286 regmap = devm_regmap_init_i2c(client, ®map_config); 1287 if (IS_ERR(regmap)) 1288 return PTR_ERR(regmap); 1289 1290 nvm->regmap = regmap; 1291 1292 nvmem_config.name = dev_name(dev); 1293 nvmem_config.dev = dev; 1294 nvmem_config.read_only = true; 1295 nvmem_config.root_only = true; 1296 nvmem_config.owner = THIS_MODULE; 1297 nvmem_config.compat = true; 1298 nvmem_config.base_dev = dev; 1299 nvmem_config.reg_read = ov2740_nvmem_read; 1300 nvmem_config.reg_write = NULL; 1301 nvmem_config.priv = nvm; 1302 nvmem_config.stride = 1; 1303 nvmem_config.word_size = 1; 1304 nvmem_config.size = CUSTOMER_USE_OTP_SIZE; 1305 1306 nvm->nvmem = devm_nvmem_register(dev, &nvmem_config); 1307 if (IS_ERR(nvm->nvmem)) 1308 return PTR_ERR(nvm->nvmem); 1309 1310 ov2740->nvm = nvm; 1311 return 0; 1312 } 1313 1314 static int ov2740_suspend(struct device *dev) 1315 { 1316 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1317 struct ov2740 *ov2740 = to_ov2740(sd); 1318 1319 gpiod_set_value_cansleep(ov2740->reset_gpio, 1); 1320 gpiod_set_value_cansleep(ov2740->powerdown_gpio, 1); 1321 clk_disable_unprepare(ov2740->clk); 1322 regulator_bulk_disable(ARRAY_SIZE(ov2740_supply_name), 1323 ov2740->supplies); 1324 return 0; 1325 } 1326 1327 static int ov2740_resume(struct device *dev) 1328 { 1329 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1330 struct ov2740 *ov2740 = to_ov2740(sd); 1331 int ret; 1332 1333 ret = regulator_bulk_enable(ARRAY_SIZE(ov2740_supply_name), 1334 ov2740->supplies); 1335 if (ret) 1336 return ret; 1337 1338 ret = clk_prepare_enable(ov2740->clk); 1339 if (ret) { 1340 regulator_bulk_disable(ARRAY_SIZE(ov2740_supply_name), 1341 ov2740->supplies); 1342 return ret; 1343 } 1344 1345 gpiod_set_value_cansleep(ov2740->powerdown_gpio, 0); 1346 gpiod_set_value_cansleep(ov2740->reset_gpio, 0); 1347 msleep(20); 1348 1349 return 0; 1350 } 1351 1352 static int ov2740_probe(struct i2c_client *client) 1353 { 1354 struct device *dev = &client->dev; 1355 struct ov2740 *ov2740; 1356 bool full_power; 1357 unsigned int i; 1358 int ret; 1359 1360 ov2740 = devm_kzalloc(&client->dev, sizeof(*ov2740), GFP_KERNEL); 1361 if (!ov2740) 1362 return -ENOMEM; 1363 1364 v4l2_i2c_subdev_init(&ov2740->sd, client, &ov2740_subdev_ops); 1365 ov2740->sd.internal_ops = &ov2740_internal_ops; 1366 1367 ret = ov2740_check_hwcfg(dev); 1368 if (ret) 1369 return ret; 1370 1371 ov2740->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); 1372 if (IS_ERR(ov2740->reset_gpio)) { 1373 return dev_err_probe(dev, PTR_ERR(ov2740->reset_gpio), 1374 "failed to get reset GPIO\n"); 1375 } 1376 1377 ov2740->powerdown_gpio = devm_gpiod_get_optional(dev, "powerdown", GPIOD_OUT_HIGH); 1378 if (IS_ERR(ov2740->powerdown_gpio)) { 1379 return dev_err_probe(dev, PTR_ERR(ov2740->powerdown_gpio), 1380 "failed to get powerdown GPIO\n"); 1381 } 1382 1383 if (ov2740->reset_gpio || ov2740->powerdown_gpio) { 1384 /* 1385 * Ensure reset/powerdown is asserted for at least 20 ms before 1386 * ov2740_resume() deasserts it. 1387 */ 1388 msleep(20); 1389 } 1390 1391 ov2740->clk = devm_clk_get_optional(dev, "clk"); 1392 if (IS_ERR(ov2740->clk)) 1393 return dev_err_probe(dev, PTR_ERR(ov2740->clk), 1394 "failed to get clock\n"); 1395 1396 for (i = 0; i < ARRAY_SIZE(ov2740_supply_name); i++) 1397 ov2740->supplies[i].supply = ov2740_supply_name[i]; 1398 1399 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ov2740_supply_name), 1400 ov2740->supplies); 1401 if (ret) 1402 return dev_err_probe(dev, ret, "failed to get regulators\n"); 1403 1404 full_power = acpi_dev_state_d0(&client->dev); 1405 if (full_power) { 1406 /* ACPI does not always clear the reset GPIO / enable the clock */ 1407 ret = ov2740_resume(dev); 1408 if (ret) 1409 return dev_err_probe(dev, ret, "failed to power on sensor\n"); 1410 1411 ret = ov2740_identify_module(ov2740); 1412 if (ret) { 1413 dev_err_probe(dev, ret, "failed to find sensor\n"); 1414 goto probe_error_power_off; 1415 } 1416 } 1417 1418 ov2740->cur_mode = &ov2740->supported_modes[0]; 1419 ret = ov2740_init_controls(ov2740); 1420 if (ret) { 1421 dev_err_probe(dev, ret, "failed to init controls\n"); 1422 goto probe_error_v4l2_ctrl_handler_free; 1423 } 1424 1425 ov2740->sd.state_lock = ov2740->ctrl_handler.lock; 1426 ov2740->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1427 ov2740->sd.entity.ops = &ov2740_subdev_entity_ops; 1428 ov2740->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1429 ov2740->pad.flags = MEDIA_PAD_FL_SOURCE; 1430 ret = media_entity_pads_init(&ov2740->sd.entity, 1, &ov2740->pad); 1431 if (ret) { 1432 dev_err_probe(dev, ret, "failed to init entity pads\n"); 1433 goto probe_error_v4l2_ctrl_handler_free; 1434 } 1435 1436 ret = v4l2_subdev_init_finalize(&ov2740->sd); 1437 if (ret) 1438 goto probe_error_media_entity_cleanup; 1439 1440 /* Set the device's state to active if it's in D0 state. */ 1441 if (full_power) 1442 pm_runtime_set_active(&client->dev); 1443 pm_runtime_enable(&client->dev); 1444 pm_runtime_idle(&client->dev); 1445 1446 ret = v4l2_async_register_subdev_sensor(&ov2740->sd); 1447 if (ret < 0) { 1448 dev_err_probe(dev, ret, "failed to register V4L2 subdev\n"); 1449 goto probe_error_v4l2_subdev_cleanup; 1450 } 1451 1452 ret = ov2740_register_nvmem(client, ov2740); 1453 if (ret) 1454 dev_warn(&client->dev, "register nvmem failed, ret %d\n", ret); 1455 1456 return 0; 1457 1458 probe_error_v4l2_subdev_cleanup: 1459 v4l2_subdev_cleanup(&ov2740->sd); 1460 1461 probe_error_media_entity_cleanup: 1462 media_entity_cleanup(&ov2740->sd.entity); 1463 pm_runtime_disable(&client->dev); 1464 pm_runtime_set_suspended(&client->dev); 1465 1466 probe_error_v4l2_ctrl_handler_free: 1467 v4l2_ctrl_handler_free(ov2740->sd.ctrl_handler); 1468 1469 probe_error_power_off: 1470 if (full_power) 1471 ov2740_suspend(dev); 1472 1473 return ret; 1474 } 1475 1476 static DEFINE_RUNTIME_DEV_PM_OPS(ov2740_pm_ops, ov2740_suspend, ov2740_resume, 1477 NULL); 1478 1479 static const struct acpi_device_id ov2740_acpi_ids[] = { 1480 {"INT3474"}, 1481 {} 1482 }; 1483 1484 MODULE_DEVICE_TABLE(acpi, ov2740_acpi_ids); 1485 1486 static struct i2c_driver ov2740_i2c_driver = { 1487 .driver = { 1488 .name = "ov2740", 1489 .acpi_match_table = ov2740_acpi_ids, 1490 .pm = pm_sleep_ptr(&ov2740_pm_ops), 1491 }, 1492 .probe = ov2740_probe, 1493 .remove = ov2740_remove, 1494 .flags = I2C_DRV_ACPI_WAIVE_D0_PROBE, 1495 }; 1496 1497 module_i2c_driver(ov2740_i2c_driver); 1498 1499 MODULE_AUTHOR("Qiu, Tianshu <tian.shu.qiu@intel.com>"); 1500 MODULE_AUTHOR("Shawn Tu"); 1501 MODULE_AUTHOR("Bingbu Cao <bingbu.cao@intel.com>"); 1502 MODULE_DESCRIPTION("OmniVision OV2740 sensor driver"); 1503 MODULE_LICENSE("GPL v2"); 1504