1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * LED Flash class driver for the flash cell of max77693 mfd. 4 * 5 * Copyright (C) 2015, Samsung Electronics Co., Ltd. 6 * 7 * Authors: Jacek Anaszewski <j.anaszewski@samsung.com> 8 * Andrzej Hajda <a.hajda@samsung.com> 9 */ 10 11 #include <linux/led-class-flash.h> 12 #include <linux/mfd/max77693.h> 13 #include <linux/mfd/max77693-common.h> 14 #include <linux/mfd/max77693-private.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/platform_device.h> 18 #include <linux/regmap.h> 19 #include <linux/slab.h> 20 #include <media/v4l2-flash-led-class.h> 21 22 #define MODE_OFF 0 23 #define MODE_FLASH(a) (1 << (a)) 24 #define MODE_TORCH(a) (1 << (2 + (a))) 25 #define MODE_FLASH_EXTERNAL(a) (1 << (4 + (a))) 26 27 #define MODE_FLASH_MASK (MODE_FLASH(FLED1) | MODE_FLASH(FLED2) | \ 28 MODE_FLASH_EXTERNAL(FLED1) | \ 29 MODE_FLASH_EXTERNAL(FLED2)) 30 #define MODE_TORCH_MASK (MODE_TORCH(FLED1) | MODE_TORCH(FLED2)) 31 32 #define FLED1_IOUT (1 << 0) 33 #define FLED2_IOUT (1 << 1) 34 35 enum max77693_fled { 36 FLED1, 37 FLED2, 38 }; 39 40 enum max77693_led_mode { 41 FLASH, 42 TORCH, 43 }; 44 45 struct max77693_led_config_data { 46 const char *label[2]; 47 u32 iout_torch_max[2]; 48 u32 iout_flash_max[2]; 49 u32 flash_timeout_max[2]; 50 u32 num_leds; 51 u32 boost_mode; 52 u32 boost_vout; 53 u32 low_vsys; 54 }; 55 56 struct max77693_sub_led { 57 /* corresponding FLED output identifier */ 58 int fled_id; 59 /* corresponding LED Flash class device */ 60 struct led_classdev_flash fled_cdev; 61 /* V4L2 Flash device */ 62 struct v4l2_flash *v4l2_flash; 63 64 /* brightness cache */ 65 unsigned int torch_brightness; 66 /* flash timeout cache */ 67 unsigned int flash_timeout; 68 /* flash faults that may have occurred */ 69 u32 flash_faults; 70 }; 71 72 struct max77693_led_device { 73 /* parent mfd regmap */ 74 struct regmap *regmap; 75 /* platform device data */ 76 struct platform_device *pdev; 77 /* secures access to the device */ 78 struct mutex lock; 79 80 /* sub led data */ 81 struct max77693_sub_led sub_leds[2]; 82 83 /* maximum torch current values for FLED outputs */ 84 u32 iout_torch_max[2]; 85 /* maximum flash current values for FLED outputs */ 86 u32 iout_flash_max[2]; 87 88 /* current flash timeout cache */ 89 unsigned int current_flash_timeout; 90 /* ITORCH register cache */ 91 u8 torch_iout_reg; 92 /* mode of fled outputs */ 93 unsigned int mode_flags; 94 /* recently strobed fled */ 95 int strobing_sub_led_id; 96 /* bitmask of FLED outputs use state (bit 0. - FLED1, bit 1. - FLED2) */ 97 u8 fled_mask; 98 /* FLED modes that can be set */ 99 u8 allowed_modes; 100 101 /* arrangement of current outputs */ 102 bool iout_joint; 103 }; 104 105 static u8 max77693_led_iout_to_reg(u32 ua) 106 { 107 if (ua < FLASH_IOUT_MIN) 108 ua = FLASH_IOUT_MIN; 109 return (ua - FLASH_IOUT_MIN) / FLASH_IOUT_STEP; 110 } 111 112 static u8 max77693_flash_timeout_to_reg(u32 us) 113 { 114 return (us - FLASH_TIMEOUT_MIN) / FLASH_TIMEOUT_STEP; 115 } 116 117 static inline struct max77693_sub_led *flcdev_to_sub_led( 118 struct led_classdev_flash *fled_cdev) 119 { 120 return container_of(fled_cdev, struct max77693_sub_led, fled_cdev); 121 } 122 123 static inline struct max77693_led_device *sub_led_to_led( 124 struct max77693_sub_led *sub_led) 125 { 126 return container_of(sub_led, struct max77693_led_device, 127 sub_leds[sub_led->fled_id]); 128 } 129 130 static inline u8 max77693_led_vsys_to_reg(u32 mv) 131 { 132 return ((mv - MAX_FLASH1_VSYS_MIN) / MAX_FLASH1_VSYS_STEP) << 2; 133 } 134 135 static inline u8 max77693_led_vout_to_reg(u32 mv) 136 { 137 return (mv - FLASH_VOUT_MIN) / FLASH_VOUT_STEP + FLASH_VOUT_RMIN; 138 } 139 140 static inline bool max77693_fled_used(struct max77693_led_device *led, 141 int fled_id) 142 { 143 u8 fled_bit = (fled_id == FLED1) ? FLED1_IOUT : FLED2_IOUT; 144 145 return led->fled_mask & fled_bit; 146 } 147 148 static int max77693_set_mode_reg(struct max77693_led_device *led, u8 mode) 149 { 150 struct regmap *rmap = led->regmap; 151 int ret, v = 0, i; 152 153 for (i = FLED1; i <= FLED2; ++i) { 154 if (mode & MODE_TORCH(i)) 155 v |= FLASH_EN_ON << TORCH_EN_SHIFT(i); 156 157 if (mode & MODE_FLASH(i)) { 158 v |= FLASH_EN_ON << FLASH_EN_SHIFT(i); 159 } else if (mode & MODE_FLASH_EXTERNAL(i)) { 160 v |= FLASH_EN_FLASH << FLASH_EN_SHIFT(i); 161 /* 162 * Enable hw triggering also for torch mode, as some 163 * camera sensors use torch led to fathom ambient light 164 * conditions before strobing the flash. 165 */ 166 v |= FLASH_EN_TORCH << TORCH_EN_SHIFT(i); 167 } 168 } 169 170 /* Reset the register only prior setting flash modes */ 171 if (mode & ~(MODE_TORCH(FLED1) | MODE_TORCH(FLED2))) { 172 ret = regmap_write(rmap, MAX77693_LED_REG_FLASH_EN, 0); 173 if (ret < 0) 174 return ret; 175 } 176 177 return regmap_write(rmap, MAX77693_LED_REG_FLASH_EN, v); 178 } 179 180 static int max77693_add_mode(struct max77693_led_device *led, u8 mode) 181 { 182 u8 new_mode_flags; 183 int i, ret; 184 185 if (led->iout_joint) 186 /* Span the mode on FLED2 for joint iouts case */ 187 mode |= (mode << 1); 188 189 /* 190 * FLASH_EXTERNAL mode activates FLASHEN and TORCHEN pins in the device. 191 * Corresponding register bit fields interfere with SW triggered modes, 192 * thus clear them to ensure proper device configuration. 193 */ 194 for (i = FLED1; i <= FLED2; ++i) 195 if (mode & MODE_FLASH_EXTERNAL(i)) 196 led->mode_flags &= (~MODE_TORCH(i) & ~MODE_FLASH(i)); 197 198 new_mode_flags = mode | led->mode_flags; 199 new_mode_flags &= led->allowed_modes; 200 201 if (new_mode_flags ^ led->mode_flags) 202 led->mode_flags = new_mode_flags; 203 else 204 return 0; 205 206 ret = max77693_set_mode_reg(led, led->mode_flags); 207 if (ret < 0) 208 return ret; 209 210 /* 211 * Clear flash mode flag after setting the mode to avoid spurious flash 212 * strobing on each subsequent torch mode setting. 213 */ 214 if (mode & MODE_FLASH_MASK) 215 led->mode_flags &= ~mode; 216 217 return ret; 218 } 219 220 static int max77693_clear_mode(struct max77693_led_device *led, 221 u8 mode) 222 { 223 if (led->iout_joint) 224 /* Clear mode also on FLED2 for joint iouts case */ 225 mode |= (mode << 1); 226 227 led->mode_flags &= ~mode; 228 229 return max77693_set_mode_reg(led, led->mode_flags); 230 } 231 232 static void max77693_add_allowed_modes(struct max77693_led_device *led, 233 int fled_id, enum max77693_led_mode mode) 234 { 235 if (mode == FLASH) 236 led->allowed_modes |= (MODE_FLASH(fled_id) | 237 MODE_FLASH_EXTERNAL(fled_id)); 238 else 239 led->allowed_modes |= MODE_TORCH(fled_id); 240 } 241 242 static void max77693_distribute_currents(struct max77693_led_device *led, 243 int fled_id, enum max77693_led_mode mode, 244 u32 micro_amp, u32 iout_max[2], u32 iout[2]) 245 { 246 if (!led->iout_joint) { 247 iout[fled_id] = micro_amp; 248 max77693_add_allowed_modes(led, fled_id, mode); 249 return; 250 } 251 252 iout[FLED1] = min(micro_amp, iout_max[FLED1]); 253 iout[FLED2] = micro_amp - iout[FLED1]; 254 255 if (mode == FLASH) 256 led->allowed_modes &= ~MODE_FLASH_MASK; 257 else 258 led->allowed_modes &= ~MODE_TORCH_MASK; 259 260 max77693_add_allowed_modes(led, FLED1, mode); 261 262 if (iout[FLED2]) 263 max77693_add_allowed_modes(led, FLED2, mode); 264 } 265 266 static int max77693_set_torch_current(struct max77693_led_device *led, 267 int fled_id, u32 micro_amp) 268 { 269 struct regmap *rmap = led->regmap; 270 u8 iout1_reg = 0, iout2_reg = 0; 271 u32 iout[2]; 272 273 max77693_distribute_currents(led, fled_id, TORCH, micro_amp, 274 led->iout_torch_max, iout); 275 276 if (fled_id == FLED1 || led->iout_joint) { 277 iout1_reg = max77693_led_iout_to_reg(iout[FLED1]); 278 led->torch_iout_reg &= TORCH_IOUT_MASK(TORCH_IOUT2_SHIFT); 279 } 280 if (fled_id == FLED2 || led->iout_joint) { 281 iout2_reg = max77693_led_iout_to_reg(iout[FLED2]); 282 led->torch_iout_reg &= TORCH_IOUT_MASK(TORCH_IOUT1_SHIFT); 283 } 284 285 led->torch_iout_reg |= ((iout1_reg << TORCH_IOUT1_SHIFT) | 286 (iout2_reg << TORCH_IOUT2_SHIFT)); 287 288 return regmap_write(rmap, MAX77693_LED_REG_ITORCH, 289 led->torch_iout_reg); 290 } 291 292 static int max77693_set_flash_current(struct max77693_led_device *led, 293 int fled_id, 294 u32 micro_amp) 295 { 296 struct regmap *rmap = led->regmap; 297 u8 iout1_reg, iout2_reg; 298 u32 iout[2]; 299 int ret = -EINVAL; 300 301 max77693_distribute_currents(led, fled_id, FLASH, micro_amp, 302 led->iout_flash_max, iout); 303 304 if (fled_id == FLED1 || led->iout_joint) { 305 iout1_reg = max77693_led_iout_to_reg(iout[FLED1]); 306 ret = regmap_write(rmap, MAX77693_LED_REG_IFLASH1, 307 iout1_reg); 308 if (ret < 0) 309 return ret; 310 } 311 if (fled_id == FLED2 || led->iout_joint) { 312 iout2_reg = max77693_led_iout_to_reg(iout[FLED2]); 313 ret = regmap_write(rmap, MAX77693_LED_REG_IFLASH2, 314 iout2_reg); 315 } 316 317 return ret; 318 } 319 320 static int max77693_set_timeout(struct max77693_led_device *led, u32 microsec) 321 { 322 struct regmap *rmap = led->regmap; 323 u8 v; 324 int ret; 325 326 v = max77693_flash_timeout_to_reg(microsec) | FLASH_TMR_LEVEL; 327 328 ret = regmap_write(rmap, MAX77693_LED_REG_FLASH_TIMER, v); 329 if (ret < 0) 330 return ret; 331 332 led->current_flash_timeout = microsec; 333 334 return 0; 335 } 336 337 static int max77693_get_strobe_status(struct max77693_led_device *led, 338 bool *state) 339 { 340 struct regmap *rmap = led->regmap; 341 unsigned int v; 342 int ret; 343 344 ret = regmap_read(rmap, MAX77693_LED_REG_FLASH_STATUS, &v); 345 if (ret < 0) 346 return ret; 347 348 *state = v & FLASH_STATUS_FLASH_ON; 349 350 return ret; 351 } 352 353 static int max77693_get_flash_faults(struct max77693_sub_led *sub_led) 354 { 355 struct max77693_led_device *led = sub_led_to_led(sub_led); 356 struct regmap *rmap = led->regmap; 357 unsigned int v; 358 u8 fault_open_mask, fault_short_mask; 359 int ret; 360 361 sub_led->flash_faults = 0; 362 363 if (led->iout_joint) { 364 fault_open_mask = FLASH_INT_FLED1_OPEN | FLASH_INT_FLED2_OPEN; 365 fault_short_mask = FLASH_INT_FLED1_SHORT | 366 FLASH_INT_FLED2_SHORT; 367 } else { 368 fault_open_mask = (sub_led->fled_id == FLED1) ? 369 FLASH_INT_FLED1_OPEN : 370 FLASH_INT_FLED2_OPEN; 371 fault_short_mask = (sub_led->fled_id == FLED1) ? 372 FLASH_INT_FLED1_SHORT : 373 FLASH_INT_FLED2_SHORT; 374 } 375 376 ret = regmap_read(rmap, MAX77693_LED_REG_FLASH_INT, &v); 377 if (ret < 0) 378 return ret; 379 380 if (v & fault_open_mask) 381 sub_led->flash_faults |= LED_FAULT_OVER_VOLTAGE; 382 if (v & fault_short_mask) 383 sub_led->flash_faults |= LED_FAULT_SHORT_CIRCUIT; 384 if (v & FLASH_INT_OVER_CURRENT) 385 sub_led->flash_faults |= LED_FAULT_OVER_CURRENT; 386 387 return 0; 388 } 389 390 static int max77693_setup(struct max77693_led_device *led, 391 struct max77693_led_config_data *led_cfg) 392 { 393 struct regmap *rmap = led->regmap; 394 int i, first_led, last_led, ret; 395 u32 max_flash_curr[2]; 396 u8 v; 397 398 /* 399 * Initialize only flash current. Torch current doesn't 400 * require initialization as ITORCH register is written with 401 * new value each time brightness_set op is called. 402 */ 403 if (led->iout_joint) { 404 first_led = FLED1; 405 last_led = FLED1; 406 max_flash_curr[FLED1] = led_cfg->iout_flash_max[FLED1] + 407 led_cfg->iout_flash_max[FLED2]; 408 } else { 409 first_led = max77693_fled_used(led, FLED1) ? FLED1 : FLED2; 410 last_led = max77693_fled_used(led, FLED2) ? FLED2 : FLED1; 411 max_flash_curr[FLED1] = led_cfg->iout_flash_max[FLED1]; 412 max_flash_curr[FLED2] = led_cfg->iout_flash_max[FLED2]; 413 } 414 415 for (i = first_led; i <= last_led; ++i) { 416 ret = max77693_set_flash_current(led, i, 417 max_flash_curr[i]); 418 if (ret < 0) 419 return ret; 420 } 421 422 v = TORCH_TMR_NO_TIMER | MAX77693_LED_TRIG_TYPE_LEVEL; 423 ret = regmap_write(rmap, MAX77693_LED_REG_ITORCHTIMER, v); 424 if (ret < 0) 425 return ret; 426 427 if (led_cfg->low_vsys > 0) 428 v = max77693_led_vsys_to_reg(led_cfg->low_vsys) | 429 MAX_FLASH1_MAX_FL_EN; 430 else 431 v = 0; 432 433 ret = regmap_write(rmap, MAX77693_LED_REG_MAX_FLASH1, v); 434 if (ret < 0) 435 return ret; 436 ret = regmap_write(rmap, MAX77693_LED_REG_MAX_FLASH2, 0); 437 if (ret < 0) 438 return ret; 439 440 if (led_cfg->boost_mode == MAX77693_LED_BOOST_FIXED) 441 v = FLASH_BOOST_FIXED; 442 else 443 v = led_cfg->boost_mode | led_cfg->boost_mode << 1; 444 445 if (max77693_fled_used(led, FLED1) && max77693_fled_used(led, FLED2)) 446 v |= FLASH_BOOST_LEDNUM_2; 447 448 ret = regmap_write(rmap, MAX77693_LED_REG_VOUT_CNTL, v); 449 if (ret < 0) 450 return ret; 451 452 v = max77693_led_vout_to_reg(led_cfg->boost_vout); 453 ret = regmap_write(rmap, MAX77693_LED_REG_VOUT_FLASH1, v); 454 if (ret < 0) 455 return ret; 456 457 return max77693_set_mode_reg(led, MODE_OFF); 458 } 459 460 /* LED subsystem callbacks */ 461 static int max77693_led_brightness_set(struct led_classdev *led_cdev, 462 enum led_brightness value) 463 { 464 struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); 465 struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev); 466 struct max77693_led_device *led = sub_led_to_led(sub_led); 467 int fled_id = sub_led->fled_id, ret; 468 469 mutex_lock(&led->lock); 470 471 if (value == 0) { 472 ret = max77693_clear_mode(led, MODE_TORCH(fled_id)); 473 if (ret < 0) 474 dev_dbg(&led->pdev->dev, 475 "Failed to clear torch mode (%d)\n", 476 ret); 477 goto unlock; 478 } 479 480 ret = max77693_set_torch_current(led, fled_id, value * TORCH_IOUT_STEP); 481 if (ret < 0) { 482 dev_dbg(&led->pdev->dev, 483 "Failed to set torch current (%d)\n", 484 ret); 485 goto unlock; 486 } 487 488 ret = max77693_add_mode(led, MODE_TORCH(fled_id)); 489 if (ret < 0) 490 dev_dbg(&led->pdev->dev, 491 "Failed to set torch mode (%d)\n", 492 ret); 493 unlock: 494 mutex_unlock(&led->lock); 495 496 return ret; 497 } 498 499 static int max77693_led_flash_brightness_set( 500 struct led_classdev_flash *fled_cdev, 501 u32 brightness) 502 { 503 struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev); 504 struct max77693_led_device *led = sub_led_to_led(sub_led); 505 int ret; 506 507 mutex_lock(&led->lock); 508 ret = max77693_set_flash_current(led, sub_led->fled_id, brightness); 509 mutex_unlock(&led->lock); 510 511 return ret; 512 } 513 514 static int max77693_led_flash_strobe_set( 515 struct led_classdev_flash *fled_cdev, 516 bool state) 517 { 518 struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev); 519 struct max77693_led_device *led = sub_led_to_led(sub_led); 520 int fled_id = sub_led->fled_id; 521 int ret; 522 523 mutex_lock(&led->lock); 524 525 if (!state) { 526 ret = max77693_clear_mode(led, MODE_FLASH(fled_id)); 527 goto unlock; 528 } 529 530 if (sub_led->flash_timeout != led->current_flash_timeout) { 531 ret = max77693_set_timeout(led, sub_led->flash_timeout); 532 if (ret < 0) 533 goto unlock; 534 } 535 536 led->strobing_sub_led_id = fled_id; 537 538 ret = max77693_add_mode(led, MODE_FLASH(fled_id)); 539 if (ret < 0) 540 goto unlock; 541 542 ret = max77693_get_flash_faults(sub_led); 543 544 unlock: 545 mutex_unlock(&led->lock); 546 return ret; 547 } 548 549 static int max77693_led_flash_fault_get( 550 struct led_classdev_flash *fled_cdev, 551 u32 *fault) 552 { 553 struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev); 554 555 *fault = sub_led->flash_faults; 556 557 return 0; 558 } 559 560 static int max77693_led_flash_strobe_get( 561 struct led_classdev_flash *fled_cdev, 562 bool *state) 563 { 564 struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev); 565 struct max77693_led_device *led = sub_led_to_led(sub_led); 566 int ret; 567 568 if (!state) 569 return -EINVAL; 570 571 mutex_lock(&led->lock); 572 573 ret = max77693_get_strobe_status(led, state); 574 575 *state = !!(*state && (led->strobing_sub_led_id == sub_led->fled_id)); 576 577 mutex_unlock(&led->lock); 578 579 return ret; 580 } 581 582 static int max77693_led_flash_timeout_set( 583 struct led_classdev_flash *fled_cdev, 584 u32 timeout) 585 { 586 struct max77693_sub_led *sub_led = flcdev_to_sub_led(fled_cdev); 587 struct max77693_led_device *led = sub_led_to_led(sub_led); 588 589 mutex_lock(&led->lock); 590 sub_led->flash_timeout = timeout; 591 mutex_unlock(&led->lock); 592 593 return 0; 594 } 595 596 static int max77693_led_parse_dt(struct max77693_led_device *led, 597 struct max77693_led_config_data *cfg, 598 struct device_node **sub_nodes) 599 { 600 struct device *dev = &led->pdev->dev; 601 struct max77693_sub_led *sub_leds = led->sub_leds; 602 struct device_node *node = dev_of_node(dev), *child_node; 603 struct property *prop; 604 u32 led_sources[2]; 605 int i, ret, fled_id; 606 607 of_property_read_u32(node, "maxim,boost-mode", &cfg->boost_mode); 608 of_property_read_u32(node, "maxim,boost-mvout", &cfg->boost_vout); 609 of_property_read_u32(node, "maxim,mvsys-min", &cfg->low_vsys); 610 611 for_each_available_child_of_node(node, child_node) { 612 prop = of_find_property(child_node, "led-sources", NULL); 613 if (prop) { 614 const __be32 *srcs = NULL; 615 616 for (i = 0; i < ARRAY_SIZE(led_sources); ++i) { 617 srcs = of_prop_next_u32(prop, srcs, 618 &led_sources[i]); 619 if (!srcs) 620 break; 621 } 622 } else { 623 dev_err(dev, 624 "led-sources DT property missing\n"); 625 of_node_put(child_node); 626 return -EINVAL; 627 } 628 629 if (i == 2) { 630 fled_id = FLED1; 631 led->fled_mask = FLED1_IOUT | FLED2_IOUT; 632 } else if (led_sources[0] == FLED1) { 633 fled_id = FLED1; 634 led->fled_mask |= FLED1_IOUT; 635 } else if (led_sources[0] == FLED2) { 636 fled_id = FLED2; 637 led->fled_mask |= FLED2_IOUT; 638 } else { 639 dev_err(dev, 640 "Wrong led-sources DT property value.\n"); 641 of_node_put(child_node); 642 return -EINVAL; 643 } 644 645 if (sub_nodes[fled_id]) { 646 dev_err(dev, 647 "Conflicting \"led-sources\" DT properties\n"); 648 of_node_put(child_node); 649 return -EINVAL; 650 } 651 652 sub_nodes[fled_id] = child_node; 653 sub_leds[fled_id].fled_id = fled_id; 654 655 cfg->label[fled_id] = 656 of_get_property(child_node, "label", NULL) ? : 657 child_node->name; 658 659 ret = of_property_read_u32(child_node, "led-max-microamp", 660 &cfg->iout_torch_max[fled_id]); 661 if (ret < 0) { 662 cfg->iout_torch_max[fled_id] = TORCH_IOUT_MIN; 663 dev_warn(dev, "led-max-microamp DT property missing\n"); 664 } 665 666 ret = of_property_read_u32(child_node, "flash-max-microamp", 667 &cfg->iout_flash_max[fled_id]); 668 if (ret < 0) { 669 cfg->iout_flash_max[fled_id] = FLASH_IOUT_MIN; 670 dev_warn(dev, 671 "flash-max-microamp DT property missing\n"); 672 } 673 674 ret = of_property_read_u32(child_node, "flash-max-timeout-us", 675 &cfg->flash_timeout_max[fled_id]); 676 if (ret < 0) { 677 cfg->flash_timeout_max[fled_id] = FLASH_TIMEOUT_MIN; 678 dev_warn(dev, 679 "flash-max-timeout-us DT property missing\n"); 680 } 681 682 if (++cfg->num_leds == 2 || 683 (max77693_fled_used(led, FLED1) && 684 max77693_fled_used(led, FLED2))) { 685 of_node_put(child_node); 686 break; 687 } 688 } 689 690 if (cfg->num_leds == 0) { 691 dev_err(dev, "No DT child node found for connected LED(s).\n"); 692 return -EINVAL; 693 } 694 695 return 0; 696 } 697 698 static void clamp_align(u32 *v, u32 min, u32 max, u32 step) 699 { 700 *v = clamp_val(*v, min, max); 701 if (step > 1) 702 *v = (*v - min) / step * step + min; 703 } 704 705 static void max77693_align_iout_current(struct max77693_led_device *led, 706 u32 *iout, u32 min, u32 max, u32 step) 707 { 708 int i; 709 710 if (led->iout_joint) { 711 if (iout[FLED1] > min) { 712 iout[FLED1] /= 2; 713 iout[FLED2] = iout[FLED1]; 714 } else { 715 iout[FLED1] = min; 716 iout[FLED2] = 0; 717 return; 718 } 719 } 720 721 for (i = FLED1; i <= FLED2; ++i) 722 if (max77693_fled_used(led, i)) 723 clamp_align(&iout[i], min, max, step); 724 else 725 iout[i] = 0; 726 } 727 728 static void max77693_led_validate_configuration(struct max77693_led_device *led, 729 struct max77693_led_config_data *cfg) 730 { 731 u32 flash_iout_max = cfg->boost_mode ? FLASH_IOUT_MAX_2LEDS : 732 FLASH_IOUT_MAX_1LED; 733 int i; 734 735 if (cfg->num_leds == 1 && 736 max77693_fled_used(led, FLED1) && max77693_fled_used(led, FLED2)) 737 led->iout_joint = true; 738 739 cfg->boost_mode = clamp_val(cfg->boost_mode, MAX77693_LED_BOOST_NONE, 740 MAX77693_LED_BOOST_FIXED); 741 742 /* Boost must be enabled if both current outputs are used */ 743 if ((cfg->boost_mode == MAX77693_LED_BOOST_NONE) && led->iout_joint) 744 cfg->boost_mode = MAX77693_LED_BOOST_FIXED; 745 746 max77693_align_iout_current(led, cfg->iout_torch_max, 747 TORCH_IOUT_MIN, TORCH_IOUT_MAX, TORCH_IOUT_STEP); 748 749 max77693_align_iout_current(led, cfg->iout_flash_max, 750 FLASH_IOUT_MIN, flash_iout_max, FLASH_IOUT_STEP); 751 752 for (i = 0; i < ARRAY_SIZE(cfg->flash_timeout_max); ++i) 753 clamp_align(&cfg->flash_timeout_max[i], FLASH_TIMEOUT_MIN, 754 FLASH_TIMEOUT_MAX, FLASH_TIMEOUT_STEP); 755 756 clamp_align(&cfg->boost_vout, FLASH_VOUT_MIN, FLASH_VOUT_MAX, 757 FLASH_VOUT_STEP); 758 759 if (cfg->low_vsys) 760 clamp_align(&cfg->low_vsys, MAX_FLASH1_VSYS_MIN, 761 MAX_FLASH1_VSYS_MAX, MAX_FLASH1_VSYS_STEP); 762 } 763 764 static int max77693_led_get_configuration(struct max77693_led_device *led, 765 struct max77693_led_config_data *cfg, 766 struct device_node **sub_nodes) 767 { 768 int ret; 769 770 ret = max77693_led_parse_dt(led, cfg, sub_nodes); 771 if (ret < 0) 772 return ret; 773 774 max77693_led_validate_configuration(led, cfg); 775 776 memcpy(led->iout_torch_max, cfg->iout_torch_max, 777 sizeof(led->iout_torch_max)); 778 memcpy(led->iout_flash_max, cfg->iout_flash_max, 779 sizeof(led->iout_flash_max)); 780 781 return 0; 782 } 783 784 static const struct led_flash_ops flash_ops = { 785 .flash_brightness_set = max77693_led_flash_brightness_set, 786 .strobe_set = max77693_led_flash_strobe_set, 787 .strobe_get = max77693_led_flash_strobe_get, 788 .timeout_set = max77693_led_flash_timeout_set, 789 .fault_get = max77693_led_flash_fault_get, 790 }; 791 792 static void max77693_init_flash_settings(struct max77693_sub_led *sub_led, 793 struct max77693_led_config_data *led_cfg) 794 { 795 struct led_classdev_flash *fled_cdev = &sub_led->fled_cdev; 796 struct max77693_led_device *led = sub_led_to_led(sub_led); 797 int fled_id = sub_led->fled_id; 798 struct led_flash_setting *setting; 799 800 /* Init flash intensity setting */ 801 setting = &fled_cdev->brightness; 802 setting->min = FLASH_IOUT_MIN; 803 setting->max = led->iout_joint ? 804 led_cfg->iout_flash_max[FLED1] + 805 led_cfg->iout_flash_max[FLED2] : 806 led_cfg->iout_flash_max[fled_id]; 807 setting->step = FLASH_IOUT_STEP; 808 setting->val = setting->max; 809 810 /* Init flash timeout setting */ 811 setting = &fled_cdev->timeout; 812 setting->min = FLASH_TIMEOUT_MIN; 813 setting->max = led_cfg->flash_timeout_max[fled_id]; 814 setting->step = FLASH_TIMEOUT_STEP; 815 setting->val = setting->max; 816 } 817 818 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) 819 820 static int max77693_led_external_strobe_set( 821 struct v4l2_flash *v4l2_flash, 822 bool enable) 823 { 824 struct max77693_sub_led *sub_led = 825 flcdev_to_sub_led(v4l2_flash->fled_cdev); 826 struct max77693_led_device *led = sub_led_to_led(sub_led); 827 int fled_id = sub_led->fled_id; 828 int ret; 829 830 mutex_lock(&led->lock); 831 832 if (enable) 833 ret = max77693_add_mode(led, MODE_FLASH_EXTERNAL(fled_id)); 834 else 835 ret = max77693_clear_mode(led, MODE_FLASH_EXTERNAL(fled_id)); 836 837 mutex_unlock(&led->lock); 838 839 return ret; 840 } 841 842 static void max77693_init_v4l2_flash_config(struct max77693_sub_led *sub_led, 843 struct max77693_led_config_data *led_cfg, 844 struct v4l2_flash_config *v4l2_sd_cfg) 845 { 846 struct max77693_led_device *led = sub_led_to_led(sub_led); 847 struct device *dev = &led->pdev->dev; 848 struct max77693_dev *iodev = dev_get_drvdata(dev->parent); 849 struct i2c_client *i2c = iodev->i2c; 850 struct led_flash_setting *s; 851 852 snprintf(v4l2_sd_cfg->dev_name, sizeof(v4l2_sd_cfg->dev_name), 853 "%s %d-%04x", sub_led->fled_cdev.led_cdev.name, 854 i2c_adapter_id(i2c->adapter), i2c->addr); 855 856 s = &v4l2_sd_cfg->intensity; 857 s->min = TORCH_IOUT_MIN; 858 s->max = sub_led->fled_cdev.led_cdev.max_brightness * TORCH_IOUT_STEP; 859 s->step = TORCH_IOUT_STEP; 860 s->val = s->max; 861 862 /* Init flash faults config */ 863 v4l2_sd_cfg->flash_faults = LED_FAULT_OVER_VOLTAGE | 864 LED_FAULT_SHORT_CIRCUIT | 865 LED_FAULT_OVER_CURRENT; 866 867 v4l2_sd_cfg->has_external_strobe = true; 868 } 869 870 static const struct v4l2_flash_ops v4l2_flash_ops = { 871 .external_strobe_set = max77693_led_external_strobe_set, 872 }; 873 #else 874 static inline void max77693_init_v4l2_flash_config( 875 struct max77693_sub_led *sub_led, 876 struct max77693_led_config_data *led_cfg, 877 struct v4l2_flash_config *v4l2_sd_cfg) 878 { 879 } 880 static const struct v4l2_flash_ops v4l2_flash_ops; 881 #endif 882 883 static void max77693_init_fled_cdev(struct max77693_sub_led *sub_led, 884 struct max77693_led_config_data *led_cfg) 885 { 886 struct max77693_led_device *led = sub_led_to_led(sub_led); 887 int fled_id = sub_led->fled_id; 888 struct led_classdev_flash *fled_cdev; 889 struct led_classdev *led_cdev; 890 891 /* Initialize LED Flash class device */ 892 fled_cdev = &sub_led->fled_cdev; 893 fled_cdev->ops = &flash_ops; 894 led_cdev = &fled_cdev->led_cdev; 895 896 led_cdev->name = led_cfg->label[fled_id]; 897 898 led_cdev->brightness_set_blocking = max77693_led_brightness_set; 899 led_cdev->max_brightness = (led->iout_joint ? 900 led_cfg->iout_torch_max[FLED1] + 901 led_cfg->iout_torch_max[FLED2] : 902 led_cfg->iout_torch_max[fled_id]) / 903 TORCH_IOUT_STEP; 904 led_cdev->flags |= LED_DEV_CAP_FLASH; 905 906 max77693_init_flash_settings(sub_led, led_cfg); 907 908 /* Init flash timeout cache */ 909 sub_led->flash_timeout = fled_cdev->timeout.val; 910 } 911 912 static int max77693_register_led(struct max77693_sub_led *sub_led, 913 struct max77693_led_config_data *led_cfg, 914 struct device_node *sub_node) 915 { 916 struct max77693_led_device *led = sub_led_to_led(sub_led); 917 struct led_classdev_flash *fled_cdev = &sub_led->fled_cdev; 918 struct device *dev = &led->pdev->dev; 919 struct v4l2_flash_config v4l2_sd_cfg = {}; 920 int ret; 921 922 /* Register in the LED subsystem */ 923 ret = led_classdev_flash_register(dev, fled_cdev); 924 if (ret < 0) 925 return ret; 926 927 max77693_init_v4l2_flash_config(sub_led, led_cfg, &v4l2_sd_cfg); 928 929 /* Register in the V4L2 subsystem. */ 930 sub_led->v4l2_flash = v4l2_flash_init(dev, of_fwnode_handle(sub_node), 931 fled_cdev, &v4l2_flash_ops, 932 &v4l2_sd_cfg); 933 if (IS_ERR(sub_led->v4l2_flash)) { 934 ret = PTR_ERR(sub_led->v4l2_flash); 935 goto err_v4l2_flash_init; 936 } 937 938 return 0; 939 940 err_v4l2_flash_init: 941 led_classdev_flash_unregister(fled_cdev); 942 return ret; 943 } 944 945 static int max77693_led_probe(struct platform_device *pdev) 946 { 947 struct device *dev = &pdev->dev; 948 struct max77693_dev *iodev = dev_get_drvdata(dev->parent); 949 struct max77693_led_device *led; 950 struct max77693_sub_led *sub_leds; 951 struct device_node *sub_nodes[2] = {}; 952 struct max77693_led_config_data led_cfg = {}; 953 int init_fled_cdev[2], i, ret; 954 955 led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL); 956 if (!led) 957 return -ENOMEM; 958 959 led->pdev = pdev; 960 led->regmap = iodev->regmap; 961 led->allowed_modes = MODE_FLASH_MASK; 962 sub_leds = led->sub_leds; 963 964 platform_set_drvdata(pdev, led); 965 ret = max77693_led_get_configuration(led, &led_cfg, sub_nodes); 966 if (ret < 0) 967 return ret; 968 969 ret = max77693_setup(led, &led_cfg); 970 if (ret < 0) 971 return ret; 972 973 mutex_init(&led->lock); 974 975 init_fled_cdev[FLED1] = 976 led->iout_joint || max77693_fled_used(led, FLED1); 977 init_fled_cdev[FLED2] = 978 !led->iout_joint && max77693_fled_used(led, FLED2); 979 980 for (i = FLED1; i <= FLED2; ++i) { 981 if (!init_fled_cdev[i]) 982 continue; 983 984 /* Initialize LED Flash class device */ 985 max77693_init_fled_cdev(&sub_leds[i], &led_cfg); 986 987 /* 988 * Register LED Flash class device and corresponding 989 * V4L2 Flash device. 990 */ 991 ret = max77693_register_led(&sub_leds[i], &led_cfg, 992 sub_nodes[i]); 993 if (ret < 0) { 994 /* 995 * At this moment FLED1 might have been already 996 * registered and it needs to be released. 997 */ 998 if (i == FLED2) 999 goto err_register_led2; 1000 else 1001 goto err_register_led1; 1002 } 1003 } 1004 1005 return 0; 1006 1007 err_register_led2: 1008 /* It is possible than only FLED2 was to be registered */ 1009 if (!init_fled_cdev[FLED1]) 1010 goto err_register_led1; 1011 v4l2_flash_release(sub_leds[FLED1].v4l2_flash); 1012 led_classdev_flash_unregister(&sub_leds[FLED1].fled_cdev); 1013 err_register_led1: 1014 mutex_destroy(&led->lock); 1015 1016 return ret; 1017 } 1018 1019 static int max77693_led_remove(struct platform_device *pdev) 1020 { 1021 struct max77693_led_device *led = platform_get_drvdata(pdev); 1022 struct max77693_sub_led *sub_leds = led->sub_leds; 1023 1024 if (led->iout_joint || max77693_fled_used(led, FLED1)) { 1025 v4l2_flash_release(sub_leds[FLED1].v4l2_flash); 1026 led_classdev_flash_unregister(&sub_leds[FLED1].fled_cdev); 1027 } 1028 1029 if (!led->iout_joint && max77693_fled_used(led, FLED2)) { 1030 v4l2_flash_release(sub_leds[FLED2].v4l2_flash); 1031 led_classdev_flash_unregister(&sub_leds[FLED2].fled_cdev); 1032 } 1033 1034 mutex_destroy(&led->lock); 1035 1036 return 0; 1037 } 1038 1039 static const struct of_device_id max77693_led_dt_match[] = { 1040 { .compatible = "maxim,max77693-led" }, 1041 {}, 1042 }; 1043 MODULE_DEVICE_TABLE(of, max77693_led_dt_match); 1044 1045 static struct platform_driver max77693_led_driver = { 1046 .probe = max77693_led_probe, 1047 .remove = max77693_led_remove, 1048 .driver = { 1049 .name = "max77693-led", 1050 .of_match_table = max77693_led_dt_match, 1051 }, 1052 }; 1053 1054 module_platform_driver(max77693_led_driver); 1055 1056 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>"); 1057 MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>"); 1058 MODULE_DESCRIPTION("Maxim MAX77693 led flash driver"); 1059 MODULE_LICENSE("GPL v2"); 1060