1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2015, Sony Mobile Communications, AB. 3 */ 4 5 #include <linux/delay.h> 6 #include <linux/interrupt.h> 7 #include <linux/ktime.h> 8 #include <linux/kernel.h> 9 #include <linux/backlight.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/of_address.h> 13 #include <linux/platform_device.h> 14 #include <linux/regmap.h> 15 16 /* From DT binding */ 17 #define WLED_MAX_STRINGS 4 18 #define MOD_A 0 19 #define MOD_B 1 20 21 #define WLED_DEFAULT_BRIGHTNESS 2048 22 #define WLED_SOFT_START_DLY_US 10000 23 #define WLED3_SINK_REG_BRIGHT_MAX 0xFFF 24 #define WLED5_SINK_REG_BRIGHT_MAX_12B 0xFFF 25 #define WLED5_SINK_REG_BRIGHT_MAX_15B 0x7FFF 26 27 /* WLED3/WLED4 control registers */ 28 #define WLED3_CTRL_REG_FAULT_STATUS 0x08 29 #define WLED3_CTRL_REG_ILIM_FAULT_BIT BIT(0) 30 #define WLED3_CTRL_REG_OVP_FAULT_BIT BIT(1) 31 #define WLED4_CTRL_REG_SC_FAULT_BIT BIT(2) 32 #define WLED5_CTRL_REG_OVP_PRE_ALARM_BIT BIT(4) 33 34 #define WLED3_CTRL_REG_INT_RT_STS 0x10 35 #define WLED3_CTRL_REG_OVP_FAULT_STATUS BIT(1) 36 37 #define WLED3_CTRL_REG_MOD_EN 0x46 38 #define WLED3_CTRL_REG_MOD_EN_MASK BIT(7) 39 #define WLED3_CTRL_REG_MOD_EN_SHIFT 7 40 41 #define WLED3_CTRL_REG_FEEDBACK_CONTROL 0x48 42 43 #define WLED3_CTRL_REG_FREQ 0x4c 44 #define WLED3_CTRL_REG_FREQ_MASK GENMASK(3, 0) 45 46 #define WLED3_CTRL_REG_OVP 0x4d 47 #define WLED3_CTRL_REG_OVP_MASK GENMASK(1, 0) 48 #define WLED5_CTRL_REG_OVP_MASK GENMASK(3, 0) 49 50 #define WLED3_CTRL_REG_ILIMIT 0x4e 51 #define WLED3_CTRL_REG_ILIMIT_MASK GENMASK(2, 0) 52 53 /* WLED3/WLED4 sink registers */ 54 #define WLED3_SINK_REG_SYNC 0x47 55 #define WLED3_SINK_REG_SYNC_CLEAR 0x00 56 57 #define WLED3_SINK_REG_CURR_SINK 0x4f 58 #define WLED3_SINK_REG_CURR_SINK_MASK GENMASK(7, 5) 59 #define WLED3_SINK_REG_CURR_SINK_SHFT 5 60 61 /* WLED3 specific per-'string' registers below */ 62 #define WLED3_SINK_REG_BRIGHT(n) (0x40 + n) 63 64 #define WLED3_SINK_REG_STR_MOD_EN(n) (0x60 + (n * 0x10)) 65 #define WLED3_SINK_REG_STR_MOD_MASK BIT(7) 66 67 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR(n) (0x62 + (n * 0x10)) 68 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(4, 0) 69 70 #define WLED3_SINK_REG_STR_MOD_SRC(n) (0x63 + (n * 0x10)) 71 #define WLED3_SINK_REG_STR_MOD_SRC_MASK BIT(0) 72 #define WLED3_SINK_REG_STR_MOD_SRC_INT 0x00 73 #define WLED3_SINK_REG_STR_MOD_SRC_EXT 0x01 74 75 #define WLED3_SINK_REG_STR_CABC(n) (0x66 + (n * 0x10)) 76 #define WLED3_SINK_REG_STR_CABC_MASK BIT(7) 77 78 /* WLED4 specific control registers */ 79 #define WLED4_CTRL_REG_SHORT_PROTECT 0x5e 80 #define WLED4_CTRL_REG_SHORT_EN_MASK BIT(7) 81 82 #define WLED4_CTRL_REG_SEC_ACCESS 0xd0 83 #define WLED4_CTRL_REG_SEC_UNLOCK 0xa5 84 85 #define WLED4_CTRL_REG_TEST1 0xe2 86 #define WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2 0x09 87 88 /* WLED4 specific sink registers */ 89 #define WLED4_SINK_REG_CURR_SINK 0x46 90 #define WLED4_SINK_REG_CURR_SINK_MASK GENMASK(7, 4) 91 #define WLED4_SINK_REG_CURR_SINK_SHFT 4 92 93 /* WLED4 specific per-'string' registers below */ 94 #define WLED4_SINK_REG_STR_MOD_EN(n) (0x50 + (n * 0x10)) 95 #define WLED4_SINK_REG_STR_MOD_MASK BIT(7) 96 97 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR(n) (0x52 + (n * 0x10)) 98 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(3, 0) 99 100 #define WLED4_SINK_REG_STR_MOD_SRC(n) (0x53 + (n * 0x10)) 101 #define WLED4_SINK_REG_STR_MOD_SRC_MASK BIT(0) 102 #define WLED4_SINK_REG_STR_MOD_SRC_INT 0x00 103 #define WLED4_SINK_REG_STR_MOD_SRC_EXT 0x01 104 105 #define WLED4_SINK_REG_STR_CABC(n) (0x56 + (n * 0x10)) 106 #define WLED4_SINK_REG_STR_CABC_MASK BIT(7) 107 108 #define WLED4_SINK_REG_BRIGHT(n) (0x57 + (n * 0x10)) 109 110 /* WLED5 specific control registers */ 111 #define WLED5_CTRL_REG_OVP_INT_CTL 0x5f 112 #define WLED5_CTRL_REG_OVP_INT_TIMER_MASK GENMASK(2, 0) 113 114 /* WLED5 specific sink registers */ 115 #define WLED5_SINK_REG_MOD_A_EN 0x50 116 #define WLED5_SINK_REG_MOD_B_EN 0x60 117 #define WLED5_SINK_REG_MOD_EN_MASK BIT(7) 118 119 #define WLED5_SINK_REG_MOD_A_SRC_SEL 0x51 120 #define WLED5_SINK_REG_MOD_B_SRC_SEL 0x61 121 #define WLED5_SINK_REG_MOD_SRC_SEL_HIGH 0 122 #define WLED5_SINK_REG_MOD_SRC_SEL_EXT 0x03 123 #define WLED5_SINK_REG_MOD_SRC_SEL_MASK GENMASK(1, 0) 124 125 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL 0x52 126 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL 0x62 127 #define WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B 0 128 #define WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B 1 129 130 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB 0x53 131 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_MSB 0x54 132 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB 0x63 133 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_MSB 0x64 134 135 #define WLED5_SINK_REG_MOD_SYNC_BIT 0x65 136 #define WLED5_SINK_REG_SYNC_MOD_A_BIT BIT(0) 137 #define WLED5_SINK_REG_SYNC_MOD_B_BIT BIT(1) 138 #define WLED5_SINK_REG_SYNC_MASK GENMASK(1, 0) 139 140 /* WLED5 specific per-'string' registers below */ 141 #define WLED5_SINK_REG_STR_FULL_SCALE_CURR(n) (0x72 + (n * 0x10)) 142 143 #define WLED5_SINK_REG_STR_SRC_SEL(n) (0x73 + (n * 0x10)) 144 #define WLED5_SINK_REG_SRC_SEL_MOD_A 0 145 #define WLED5_SINK_REG_SRC_SEL_MOD_B 1 146 #define WLED5_SINK_REG_SRC_SEL_MASK GENMASK(1, 0) 147 148 struct wled_var_cfg { 149 const u32 *values; 150 u32 (*fn)(u32); 151 int size; 152 }; 153 154 struct wled_u32_opts { 155 const char *name; 156 u32 *val_ptr; 157 const struct wled_var_cfg *cfg; 158 }; 159 160 struct wled_bool_opts { 161 const char *name; 162 bool *val_ptr; 163 }; 164 165 struct wled_config { 166 u32 boost_i_limit; 167 u32 ovp; 168 u32 switch_freq; 169 u32 num_strings; 170 u32 string_i_limit; 171 u32 enabled_strings[WLED_MAX_STRINGS]; 172 u32 mod_sel; 173 u32 cabc_sel; 174 bool cs_out_en; 175 bool ext_gen; 176 bool cabc; 177 bool external_pfet; 178 bool auto_detection_enabled; 179 }; 180 181 struct wled { 182 const char *name; 183 struct device *dev; 184 struct regmap *regmap; 185 struct mutex lock; /* Lock to avoid race from thread irq handler */ 186 ktime_t last_short_event; 187 ktime_t start_ovp_fault_time; 188 u16 ctrl_addr; 189 u16 sink_addr; 190 u16 max_string_count; 191 u16 auto_detection_ovp_count; 192 u32 brightness; 193 u32 max_brightness; 194 u32 short_count; 195 u32 auto_detect_count; 196 u32 version; 197 bool disabled_by_short; 198 bool has_short_detect; 199 bool cabc_disabled; 200 int short_irq; 201 int ovp_irq; 202 203 struct wled_config cfg; 204 struct delayed_work ovp_work; 205 206 /* Configures the brightness. Applicable for wled3, wled4 and wled5 */ 207 int (*wled_set_brightness)(struct wled *wled, u16 brightness); 208 209 /* Configures the cabc register. Applicable for wled4 and wled5 */ 210 int (*wled_cabc_config)(struct wled *wled, bool enable); 211 212 /* 213 * Toggles the sync bit for the brightness update to take place. 214 * Applicable for WLED3, WLED4 and WLED5. 215 */ 216 int (*wled_sync_toggle)(struct wled *wled); 217 218 /* 219 * Time to wait before checking the OVP status after wled module enable. 220 * Applicable for WLED4 and WLED5. 221 */ 222 int (*wled_ovp_delay)(struct wled *wled); 223 224 /* 225 * Determines if the auto string detection is required. 226 * Applicable for WLED4 and WLED5 227 */ 228 bool (*wled_auto_detection_required)(struct wled *wled); 229 }; 230 231 static int wled3_set_brightness(struct wled *wled, u16 brightness) 232 { 233 int rc, i; 234 __le16 v; 235 236 v = cpu_to_le16(brightness & WLED3_SINK_REG_BRIGHT_MAX); 237 238 for (i = 0; i < wled->cfg.num_strings; ++i) { 239 rc = regmap_bulk_write(wled->regmap, wled->ctrl_addr + 240 WLED3_SINK_REG_BRIGHT(wled->cfg.enabled_strings[i]), 241 &v, sizeof(v)); 242 if (rc < 0) 243 return rc; 244 } 245 246 return 0; 247 } 248 249 static int wled4_set_brightness(struct wled *wled, u16 brightness) 250 { 251 int rc, i; 252 u16 low_limit = wled->max_brightness * 4 / 1000; 253 __le16 v; 254 255 /* WLED4's lower limit of operation is 0.4% */ 256 if (brightness > 0 && brightness < low_limit) 257 brightness = low_limit; 258 259 v = cpu_to_le16(brightness & WLED3_SINK_REG_BRIGHT_MAX); 260 261 for (i = 0; i < wled->cfg.num_strings; ++i) { 262 rc = regmap_bulk_write(wled->regmap, wled->sink_addr + 263 WLED4_SINK_REG_BRIGHT(wled->cfg.enabled_strings[i]), 264 &v, sizeof(v)); 265 if (rc < 0) 266 return rc; 267 } 268 269 return 0; 270 } 271 272 static int wled5_set_brightness(struct wled *wled, u16 brightness) 273 { 274 int rc, offset; 275 u16 low_limit = wled->max_brightness * 1 / 1000; 276 __le16 v; 277 278 /* WLED5's lower limit is 0.1% */ 279 if (brightness < low_limit) 280 brightness = low_limit; 281 282 v = cpu_to_le16(brightness & WLED5_SINK_REG_BRIGHT_MAX_15B); 283 284 offset = (wled->cfg.mod_sel == MOD_A) ? 285 WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB : 286 WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB; 287 288 rc = regmap_bulk_write(wled->regmap, wled->sink_addr + offset, 289 &v, sizeof(v)); 290 return rc; 291 } 292 293 static void wled_ovp_work(struct work_struct *work) 294 { 295 struct wled *wled = container_of(work, 296 struct wled, ovp_work.work); 297 enable_irq(wled->ovp_irq); 298 } 299 300 static int wled_module_enable(struct wled *wled, int val) 301 { 302 int rc; 303 304 if (wled->disabled_by_short) 305 return -ENXIO; 306 307 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr + 308 WLED3_CTRL_REG_MOD_EN, 309 WLED3_CTRL_REG_MOD_EN_MASK, 310 val << WLED3_CTRL_REG_MOD_EN_SHIFT); 311 if (rc < 0) 312 return rc; 313 314 if (wled->ovp_irq > 0) { 315 if (val) { 316 /* 317 * The hardware generates a storm of spurious OVP 318 * interrupts during soft start operations. So defer 319 * enabling the IRQ for 10ms to ensure that the 320 * soft start is complete. 321 */ 322 schedule_delayed_work(&wled->ovp_work, HZ / 100); 323 } else { 324 if (!cancel_delayed_work_sync(&wled->ovp_work)) 325 disable_irq(wled->ovp_irq); 326 } 327 } 328 329 return 0; 330 } 331 332 static int wled3_sync_toggle(struct wled *wled) 333 { 334 int rc; 335 unsigned int mask = GENMASK(wled->max_string_count - 1, 0); 336 337 rc = regmap_update_bits(wled->regmap, 338 wled->sink_addr + WLED3_SINK_REG_SYNC, 339 mask, WLED3_SINK_REG_SYNC_CLEAR); 340 if (rc < 0) 341 return rc; 342 343 rc = regmap_update_bits(wled->regmap, 344 wled->sink_addr + WLED3_SINK_REG_SYNC, 345 mask, mask); 346 347 return rc; 348 } 349 350 static int wled5_mod_sync_toggle(struct wled *wled) 351 { 352 int rc; 353 u8 val; 354 355 rc = regmap_update_bits(wled->regmap, 356 wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT, 357 WLED5_SINK_REG_SYNC_MASK, 0); 358 if (rc < 0) 359 return rc; 360 361 val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_SYNC_MOD_A_BIT : 362 WLED5_SINK_REG_SYNC_MOD_B_BIT; 363 return regmap_update_bits(wled->regmap, 364 wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT, 365 WLED5_SINK_REG_SYNC_MASK, val); 366 } 367 368 static int wled_ovp_fault_status(struct wled *wled, bool *fault_set) 369 { 370 int rc; 371 u32 int_rt_sts, fault_sts; 372 373 *fault_set = false; 374 rc = regmap_read(wled->regmap, 375 wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS, 376 &int_rt_sts); 377 if (rc < 0) { 378 dev_err(wled->dev, "Failed to read INT_RT_STS rc=%d\n", rc); 379 return rc; 380 } 381 382 rc = regmap_read(wled->regmap, 383 wled->ctrl_addr + WLED3_CTRL_REG_FAULT_STATUS, 384 &fault_sts); 385 if (rc < 0) { 386 dev_err(wled->dev, "Failed to read FAULT_STATUS rc=%d\n", rc); 387 return rc; 388 } 389 390 if (int_rt_sts & WLED3_CTRL_REG_OVP_FAULT_STATUS) 391 *fault_set = true; 392 393 if (wled->version == 4 && (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT)) 394 *fault_set = true; 395 396 if (wled->version == 5 && (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT | 397 WLED5_CTRL_REG_OVP_PRE_ALARM_BIT))) 398 *fault_set = true; 399 400 if (*fault_set) 401 dev_dbg(wled->dev, "WLED OVP fault detected, int_rt_sts=0x%x fault_sts=0x%x\n", 402 int_rt_sts, fault_sts); 403 404 return rc; 405 } 406 407 static int wled4_ovp_delay(struct wled *wled) 408 { 409 return WLED_SOFT_START_DLY_US; 410 } 411 412 static int wled5_ovp_delay(struct wled *wled) 413 { 414 int rc, delay_us; 415 u32 val; 416 u8 ovp_timer_ms[8] = {1, 2, 4, 8, 12, 16, 20, 24}; 417 418 /* For WLED5, get the delay based on OVP timer */ 419 rc = regmap_read(wled->regmap, wled->ctrl_addr + 420 WLED5_CTRL_REG_OVP_INT_CTL, &val); 421 if (rc < 0) 422 delay_us = 423 ovp_timer_ms[val & WLED5_CTRL_REG_OVP_INT_TIMER_MASK] * 1000; 424 else 425 delay_us = 2 * WLED_SOFT_START_DLY_US; 426 427 dev_dbg(wled->dev, "delay_time_us: %d\n", delay_us); 428 429 return delay_us; 430 } 431 432 static int wled_update_status(struct backlight_device *bl) 433 { 434 struct wled *wled = bl_get_data(bl); 435 u16 brightness = backlight_get_brightness(bl); 436 int rc = 0; 437 438 mutex_lock(&wled->lock); 439 if (brightness) { 440 rc = wled->wled_set_brightness(wled, brightness); 441 if (rc < 0) { 442 dev_err(wled->dev, "wled failed to set brightness rc:%d\n", 443 rc); 444 goto unlock_mutex; 445 } 446 447 if (wled->version < 5) { 448 rc = wled->wled_sync_toggle(wled); 449 if (rc < 0) { 450 dev_err(wled->dev, "wled sync failed rc:%d\n", rc); 451 goto unlock_mutex; 452 } 453 } else { 454 /* 455 * For WLED5 toggling the MOD_SYNC_BIT updates the 456 * brightness 457 */ 458 rc = wled5_mod_sync_toggle(wled); 459 if (rc < 0) { 460 dev_err(wled->dev, "wled mod sync failed rc:%d\n", 461 rc); 462 goto unlock_mutex; 463 } 464 } 465 } 466 467 if (!!brightness != !!wled->brightness) { 468 rc = wled_module_enable(wled, !!brightness); 469 if (rc < 0) { 470 dev_err(wled->dev, "wled enable failed rc:%d\n", rc); 471 goto unlock_mutex; 472 } 473 } 474 475 wled->brightness = brightness; 476 477 unlock_mutex: 478 mutex_unlock(&wled->lock); 479 480 return rc; 481 } 482 483 static int wled4_cabc_config(struct wled *wled, bool enable) 484 { 485 int i, j, rc; 486 u8 val; 487 488 for (i = 0; i < wled->cfg.num_strings; i++) { 489 j = wled->cfg.enabled_strings[i]; 490 491 val = enable ? WLED4_SINK_REG_STR_CABC_MASK : 0; 492 rc = regmap_update_bits(wled->regmap, wled->sink_addr + 493 WLED4_SINK_REG_STR_CABC(j), 494 WLED4_SINK_REG_STR_CABC_MASK, val); 495 if (rc < 0) 496 return rc; 497 } 498 499 return 0; 500 } 501 502 static int wled5_cabc_config(struct wled *wled, bool enable) 503 { 504 int rc, offset; 505 u8 reg; 506 507 if (wled->cabc_disabled) 508 return 0; 509 510 reg = enable ? wled->cfg.cabc_sel : 0; 511 offset = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_A_SRC_SEL : 512 WLED5_SINK_REG_MOD_B_SRC_SEL; 513 514 rc = regmap_update_bits(wled->regmap, wled->sink_addr + offset, 515 WLED5_SINK_REG_MOD_SRC_SEL_MASK, reg); 516 if (rc < 0) { 517 pr_err("Error in configuring CABC rc=%d\n", rc); 518 return rc; 519 } 520 521 if (!wled->cfg.cabc_sel) 522 wled->cabc_disabled = true; 523 524 return 0; 525 } 526 527 #define WLED_SHORT_DLY_MS 20 528 #define WLED_SHORT_CNT_MAX 5 529 #define WLED_SHORT_RESET_CNT_DLY_US USEC_PER_SEC 530 531 static irqreturn_t wled_short_irq_handler(int irq, void *_wled) 532 { 533 struct wled *wled = _wled; 534 int rc; 535 s64 elapsed_time; 536 537 wled->short_count++; 538 mutex_lock(&wled->lock); 539 rc = wled_module_enable(wled, false); 540 if (rc < 0) { 541 dev_err(wled->dev, "wled disable failed rc:%d\n", rc); 542 goto unlock_mutex; 543 } 544 545 elapsed_time = ktime_us_delta(ktime_get(), 546 wled->last_short_event); 547 if (elapsed_time > WLED_SHORT_RESET_CNT_DLY_US) 548 wled->short_count = 1; 549 550 if (wled->short_count > WLED_SHORT_CNT_MAX) { 551 dev_err(wled->dev, "Short triggered %d times, disabling WLED forever!\n", 552 wled->short_count); 553 wled->disabled_by_short = true; 554 goto unlock_mutex; 555 } 556 557 wled->last_short_event = ktime_get(); 558 559 msleep(WLED_SHORT_DLY_MS); 560 rc = wled_module_enable(wled, true); 561 if (rc < 0) 562 dev_err(wled->dev, "wled enable failed rc:%d\n", rc); 563 564 unlock_mutex: 565 mutex_unlock(&wled->lock); 566 567 return IRQ_HANDLED; 568 } 569 570 #define AUTO_DETECT_BRIGHTNESS 200 571 572 static void wled_auto_string_detection(struct wled *wled) 573 { 574 int rc = 0, i, j, delay_time_us; 575 u32 sink_config = 0; 576 u8 sink_test = 0, sink_valid = 0, val; 577 bool fault_set; 578 579 /* Read configured sink configuration */ 580 rc = regmap_read(wled->regmap, wled->sink_addr + 581 WLED4_SINK_REG_CURR_SINK, &sink_config); 582 if (rc < 0) { 583 dev_err(wled->dev, "Failed to read SINK configuration rc=%d\n", 584 rc); 585 goto failed_detect; 586 } 587 588 /* Disable the module before starting detection */ 589 rc = regmap_update_bits(wled->regmap, 590 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN, 591 WLED3_CTRL_REG_MOD_EN_MASK, 0); 592 if (rc < 0) { 593 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n", rc); 594 goto failed_detect; 595 } 596 597 /* Set low brightness across all sinks */ 598 rc = wled4_set_brightness(wled, AUTO_DETECT_BRIGHTNESS); 599 if (rc < 0) { 600 dev_err(wled->dev, "Failed to set brightness for auto detection rc=%d\n", 601 rc); 602 goto failed_detect; 603 } 604 605 if (wled->cfg.cabc) { 606 rc = wled->wled_cabc_config(wled, false); 607 if (rc < 0) 608 goto failed_detect; 609 } 610 611 /* Disable all sinks */ 612 rc = regmap_write(wled->regmap, 613 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 0); 614 if (rc < 0) { 615 dev_err(wled->dev, "Failed to disable all sinks rc=%d\n", rc); 616 goto failed_detect; 617 } 618 619 /* Iterate through the strings one by one */ 620 for (i = 0; i < wled->cfg.num_strings; i++) { 621 j = wled->cfg.enabled_strings[i]; 622 sink_test = BIT((WLED4_SINK_REG_CURR_SINK_SHFT + j)); 623 624 /* Enable feedback control */ 625 rc = regmap_write(wled->regmap, wled->ctrl_addr + 626 WLED3_CTRL_REG_FEEDBACK_CONTROL, j + 1); 627 if (rc < 0) { 628 dev_err(wled->dev, "Failed to enable feedback for SINK %d rc = %d\n", 629 j + 1, rc); 630 goto failed_detect; 631 } 632 633 /* Enable the sink */ 634 rc = regmap_write(wled->regmap, wled->sink_addr + 635 WLED4_SINK_REG_CURR_SINK, sink_test); 636 if (rc < 0) { 637 dev_err(wled->dev, "Failed to configure SINK %d rc=%d\n", 638 j + 1, rc); 639 goto failed_detect; 640 } 641 642 /* Enable the module */ 643 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr + 644 WLED3_CTRL_REG_MOD_EN, 645 WLED3_CTRL_REG_MOD_EN_MASK, 646 WLED3_CTRL_REG_MOD_EN_MASK); 647 if (rc < 0) { 648 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n", 649 rc); 650 goto failed_detect; 651 } 652 653 delay_time_us = wled->wled_ovp_delay(wled); 654 usleep_range(delay_time_us, delay_time_us + 1000); 655 656 rc = wled_ovp_fault_status(wled, &fault_set); 657 if (rc < 0) { 658 dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n", 659 rc); 660 goto failed_detect; 661 } 662 663 if (fault_set) 664 dev_dbg(wled->dev, "WLED OVP fault detected with SINK %d\n", 665 j + 1); 666 else 667 sink_valid |= sink_test; 668 669 /* Disable the module */ 670 rc = regmap_update_bits(wled->regmap, 671 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN, 672 WLED3_CTRL_REG_MOD_EN_MASK, 0); 673 if (rc < 0) { 674 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n", 675 rc); 676 goto failed_detect; 677 } 678 } 679 680 if (!sink_valid) { 681 dev_err(wled->dev, "No valid WLED sinks found\n"); 682 wled->disabled_by_short = true; 683 goto failed_detect; 684 } 685 686 if (sink_valid != sink_config) { 687 dev_warn(wled->dev, "%x is not a valid sink configuration - using %x instead\n", 688 sink_config, sink_valid); 689 sink_config = sink_valid; 690 } 691 692 /* Write the new sink configuration */ 693 rc = regmap_write(wled->regmap, 694 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 695 sink_config); 696 if (rc < 0) { 697 dev_err(wled->dev, "Failed to reconfigure the default sink rc=%d\n", 698 rc); 699 goto failed_detect; 700 } 701 702 /* Enable valid sinks */ 703 if (wled->version == 4) { 704 for (i = 0; i < wled->cfg.num_strings; i++) { 705 j = wled->cfg.enabled_strings[i]; 706 if (sink_config & 707 BIT(WLED4_SINK_REG_CURR_SINK_SHFT + j)) 708 val = WLED4_SINK_REG_STR_MOD_MASK; 709 else 710 /* Disable modulator_en for unused sink */ 711 val = 0; 712 713 rc = regmap_write(wled->regmap, wled->sink_addr + 714 WLED4_SINK_REG_STR_MOD_EN(j), val); 715 if (rc < 0) { 716 dev_err(wled->dev, "Failed to configure MODULATOR_EN rc=%d\n", 717 rc); 718 goto failed_detect; 719 } 720 } 721 } 722 723 /* Enable CABC */ 724 rc = wled->wled_cabc_config(wled, true); 725 if (rc < 0) 726 goto failed_detect; 727 728 /* Restore the feedback setting */ 729 rc = regmap_write(wled->regmap, 730 wled->ctrl_addr + WLED3_CTRL_REG_FEEDBACK_CONTROL, 0); 731 if (rc < 0) { 732 dev_err(wled->dev, "Failed to restore feedback setting rc=%d\n", 733 rc); 734 goto failed_detect; 735 } 736 737 /* Restore brightness */ 738 rc = wled4_set_brightness(wled, wled->brightness); 739 if (rc < 0) { 740 dev_err(wled->dev, "Failed to set brightness after auto detection rc=%d\n", 741 rc); 742 goto failed_detect; 743 } 744 745 rc = regmap_update_bits(wled->regmap, 746 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN, 747 WLED3_CTRL_REG_MOD_EN_MASK, 748 WLED3_CTRL_REG_MOD_EN_MASK); 749 if (rc < 0) { 750 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n", rc); 751 goto failed_detect; 752 } 753 754 failed_detect: 755 return; 756 } 757 758 #define WLED_AUTO_DETECT_OVP_COUNT 5 759 #define WLED_AUTO_DETECT_CNT_DLY_US USEC_PER_SEC 760 761 static bool wled4_auto_detection_required(struct wled *wled) 762 { 763 s64 elapsed_time_us; 764 765 if (!wled->cfg.auto_detection_enabled) 766 return false; 767 768 /* 769 * Check if the OVP fault was an occasional one 770 * or if it's firing continuously, the latter qualifies 771 * for an auto-detection check. 772 */ 773 if (!wled->auto_detection_ovp_count) { 774 wled->start_ovp_fault_time = ktime_get(); 775 wled->auto_detection_ovp_count++; 776 } else { 777 elapsed_time_us = ktime_us_delta(ktime_get(), 778 wled->start_ovp_fault_time); 779 if (elapsed_time_us > WLED_AUTO_DETECT_CNT_DLY_US) 780 wled->auto_detection_ovp_count = 0; 781 else 782 wled->auto_detection_ovp_count++; 783 784 if (wled->auto_detection_ovp_count >= 785 WLED_AUTO_DETECT_OVP_COUNT) { 786 wled->auto_detection_ovp_count = 0; 787 return true; 788 } 789 } 790 791 return false; 792 } 793 794 static bool wled5_auto_detection_required(struct wled *wled) 795 { 796 if (!wled->cfg.auto_detection_enabled) 797 return false; 798 799 /* 800 * Unlike WLED4, WLED5 has OVP fault density interrupt configuration 801 * i.e. to count the number of OVP alarms for a certain duration before 802 * triggering OVP fault interrupt. By default, number of OVP fault 803 * events counted before an interrupt is fired is 32 and the time 804 * interval is 12 ms. If we see one OVP fault interrupt, then that 805 * should qualify for a real OVP fault condition to run auto detection 806 * algorithm. 807 */ 808 return true; 809 } 810 811 static int wled_auto_detection_at_init(struct wled *wled) 812 { 813 int rc; 814 bool fault_set; 815 816 if (!wled->cfg.auto_detection_enabled) 817 return 0; 818 819 rc = wled_ovp_fault_status(wled, &fault_set); 820 if (rc < 0) { 821 dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n", 822 rc); 823 return rc; 824 } 825 826 if (fault_set) { 827 mutex_lock(&wled->lock); 828 wled_auto_string_detection(wled); 829 mutex_unlock(&wled->lock); 830 } 831 832 return rc; 833 } 834 835 static irqreturn_t wled_ovp_irq_handler(int irq, void *_wled) 836 { 837 struct wled *wled = _wled; 838 int rc; 839 u32 int_sts, fault_sts; 840 841 rc = regmap_read(wled->regmap, 842 wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS, &int_sts); 843 if (rc < 0) { 844 dev_err(wled->dev, "Error in reading WLED3_INT_RT_STS rc=%d\n", 845 rc); 846 return IRQ_HANDLED; 847 } 848 849 rc = regmap_read(wled->regmap, wled->ctrl_addr + 850 WLED3_CTRL_REG_FAULT_STATUS, &fault_sts); 851 if (rc < 0) { 852 dev_err(wled->dev, "Error in reading WLED_FAULT_STATUS rc=%d\n", 853 rc); 854 return IRQ_HANDLED; 855 } 856 857 if (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT | 858 WLED3_CTRL_REG_ILIM_FAULT_BIT)) 859 dev_dbg(wled->dev, "WLED OVP fault detected, int_sts=%x fault_sts= %x\n", 860 int_sts, fault_sts); 861 862 if (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT) { 863 if (wled->wled_auto_detection_required(wled)) { 864 mutex_lock(&wled->lock); 865 wled_auto_string_detection(wled); 866 mutex_unlock(&wled->lock); 867 } 868 } 869 870 return IRQ_HANDLED; 871 } 872 873 static int wled3_setup(struct wled *wled) 874 { 875 u16 addr; 876 u8 sink_en = 0; 877 int rc, i, j; 878 879 rc = regmap_update_bits(wled->regmap, 880 wled->ctrl_addr + WLED3_CTRL_REG_OVP, 881 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp); 882 if (rc) 883 return rc; 884 885 rc = regmap_update_bits(wled->regmap, 886 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT, 887 WLED3_CTRL_REG_ILIMIT_MASK, 888 wled->cfg.boost_i_limit); 889 if (rc) 890 return rc; 891 892 rc = regmap_update_bits(wled->regmap, 893 wled->ctrl_addr + WLED3_CTRL_REG_FREQ, 894 WLED3_CTRL_REG_FREQ_MASK, 895 wled->cfg.switch_freq); 896 if (rc) 897 return rc; 898 899 for (i = 0; i < wled->cfg.num_strings; ++i) { 900 j = wled->cfg.enabled_strings[i]; 901 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_EN(j); 902 rc = regmap_update_bits(wled->regmap, addr, 903 WLED3_SINK_REG_STR_MOD_MASK, 904 WLED3_SINK_REG_STR_MOD_MASK); 905 if (rc) 906 return rc; 907 908 if (wled->cfg.ext_gen) { 909 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_SRC(j); 910 rc = regmap_update_bits(wled->regmap, addr, 911 WLED3_SINK_REG_STR_MOD_SRC_MASK, 912 WLED3_SINK_REG_STR_MOD_SRC_EXT); 913 if (rc) 914 return rc; 915 } 916 917 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_FULL_SCALE_CURR(j); 918 rc = regmap_update_bits(wled->regmap, addr, 919 WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK, 920 wled->cfg.string_i_limit); 921 if (rc) 922 return rc; 923 924 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_CABC(j); 925 rc = regmap_update_bits(wled->regmap, addr, 926 WLED3_SINK_REG_STR_CABC_MASK, 927 wled->cfg.cabc ? 928 WLED3_SINK_REG_STR_CABC_MASK : 0); 929 if (rc) 930 return rc; 931 932 sink_en |= BIT(j + WLED3_SINK_REG_CURR_SINK_SHFT); 933 } 934 935 rc = regmap_update_bits(wled->regmap, 936 wled->ctrl_addr + WLED3_SINK_REG_CURR_SINK, 937 WLED3_SINK_REG_CURR_SINK_MASK, sink_en); 938 if (rc) 939 return rc; 940 941 return 0; 942 } 943 944 static const struct wled_config wled3_config_defaults = { 945 .boost_i_limit = 3, 946 .string_i_limit = 20, 947 .ovp = 2, 948 .num_strings = 3, 949 .switch_freq = 5, 950 .cs_out_en = false, 951 .ext_gen = false, 952 .cabc = false, 953 .enabled_strings = {0, 1, 2}, 954 }; 955 956 static int wled4_setup(struct wled *wled) 957 { 958 int rc, temp, i, j; 959 u16 addr; 960 u8 sink_en = 0; 961 u32 sink_cfg; 962 963 rc = regmap_update_bits(wled->regmap, 964 wled->ctrl_addr + WLED3_CTRL_REG_OVP, 965 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp); 966 if (rc < 0) 967 return rc; 968 969 rc = regmap_update_bits(wled->regmap, 970 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT, 971 WLED3_CTRL_REG_ILIMIT_MASK, 972 wled->cfg.boost_i_limit); 973 if (rc < 0) 974 return rc; 975 976 rc = regmap_update_bits(wled->regmap, 977 wled->ctrl_addr + WLED3_CTRL_REG_FREQ, 978 WLED3_CTRL_REG_FREQ_MASK, 979 wled->cfg.switch_freq); 980 if (rc < 0) 981 return rc; 982 983 if (wled->cfg.external_pfet) { 984 /* Unlock the secure register access */ 985 rc = regmap_write(wled->regmap, wled->ctrl_addr + 986 WLED4_CTRL_REG_SEC_ACCESS, 987 WLED4_CTRL_REG_SEC_UNLOCK); 988 if (rc < 0) 989 return rc; 990 991 rc = regmap_write(wled->regmap, 992 wled->ctrl_addr + WLED4_CTRL_REG_TEST1, 993 WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2); 994 if (rc < 0) 995 return rc; 996 } 997 998 rc = regmap_read(wled->regmap, wled->sink_addr + 999 WLED4_SINK_REG_CURR_SINK, &sink_cfg); 1000 if (rc < 0) 1001 return rc; 1002 1003 for (i = 0; i < wled->cfg.num_strings; i++) { 1004 j = wled->cfg.enabled_strings[i]; 1005 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT; 1006 sink_en |= 1 << temp; 1007 } 1008 1009 if (sink_cfg == sink_en) { 1010 rc = wled_auto_detection_at_init(wled); 1011 return rc; 1012 } 1013 1014 rc = regmap_update_bits(wled->regmap, 1015 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 1016 WLED4_SINK_REG_CURR_SINK_MASK, 0); 1017 if (rc < 0) 1018 return rc; 1019 1020 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr + 1021 WLED3_CTRL_REG_MOD_EN, 1022 WLED3_CTRL_REG_MOD_EN_MASK, 0); 1023 if (rc < 0) 1024 return rc; 1025 1026 /* Per sink/string configuration */ 1027 for (i = 0; i < wled->cfg.num_strings; i++) { 1028 j = wled->cfg.enabled_strings[i]; 1029 1030 addr = wled->sink_addr + 1031 WLED4_SINK_REG_STR_MOD_EN(j); 1032 rc = regmap_update_bits(wled->regmap, addr, 1033 WLED4_SINK_REG_STR_MOD_MASK, 1034 WLED4_SINK_REG_STR_MOD_MASK); 1035 if (rc < 0) 1036 return rc; 1037 1038 addr = wled->sink_addr + 1039 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j); 1040 rc = regmap_update_bits(wled->regmap, addr, 1041 WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK, 1042 wled->cfg.string_i_limit); 1043 if (rc < 0) 1044 return rc; 1045 } 1046 1047 rc = wled4_cabc_config(wled, wled->cfg.cabc); 1048 if (rc < 0) 1049 return rc; 1050 1051 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr + 1052 WLED3_CTRL_REG_MOD_EN, 1053 WLED3_CTRL_REG_MOD_EN_MASK, 1054 WLED3_CTRL_REG_MOD_EN_MASK); 1055 if (rc < 0) 1056 return rc; 1057 1058 rc = regmap_update_bits(wled->regmap, 1059 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 1060 WLED4_SINK_REG_CURR_SINK_MASK, sink_en); 1061 if (rc < 0) 1062 return rc; 1063 1064 rc = wled->wled_sync_toggle(wled); 1065 if (rc < 0) { 1066 dev_err(wled->dev, "Failed to toggle sync reg rc:%d\n", rc); 1067 return rc; 1068 } 1069 1070 rc = wled_auto_detection_at_init(wled); 1071 1072 return rc; 1073 } 1074 1075 static const struct wled_config wled4_config_defaults = { 1076 .boost_i_limit = 4, 1077 .string_i_limit = 10, 1078 .ovp = 1, 1079 .num_strings = 4, 1080 .switch_freq = 11, 1081 .cabc = false, 1082 .external_pfet = false, 1083 .auto_detection_enabled = false, 1084 .enabled_strings = {0, 1, 2, 3}, 1085 }; 1086 1087 static int wled5_setup(struct wled *wled) 1088 { 1089 int rc, temp, i, j, offset; 1090 u8 sink_en = 0; 1091 u16 addr; 1092 u32 val; 1093 1094 rc = regmap_update_bits(wled->regmap, 1095 wled->ctrl_addr + WLED3_CTRL_REG_OVP, 1096 WLED5_CTRL_REG_OVP_MASK, wled->cfg.ovp); 1097 if (rc < 0) 1098 return rc; 1099 1100 rc = regmap_update_bits(wled->regmap, 1101 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT, 1102 WLED3_CTRL_REG_ILIMIT_MASK, 1103 wled->cfg.boost_i_limit); 1104 if (rc < 0) 1105 return rc; 1106 1107 rc = regmap_update_bits(wled->regmap, 1108 wled->ctrl_addr + WLED3_CTRL_REG_FREQ, 1109 WLED3_CTRL_REG_FREQ_MASK, 1110 wled->cfg.switch_freq); 1111 if (rc < 0) 1112 return rc; 1113 1114 /* Per sink/string configuration */ 1115 for (i = 0; i < wled->cfg.num_strings; ++i) { 1116 j = wled->cfg.enabled_strings[i]; 1117 addr = wled->sink_addr + 1118 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j); 1119 rc = regmap_update_bits(wled->regmap, addr, 1120 WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK, 1121 wled->cfg.string_i_limit); 1122 if (rc < 0) 1123 return rc; 1124 1125 addr = wled->sink_addr + WLED5_SINK_REG_STR_SRC_SEL(j); 1126 rc = regmap_update_bits(wled->regmap, addr, 1127 WLED5_SINK_REG_SRC_SEL_MASK, 1128 wled->cfg.mod_sel == MOD_A ? 1129 WLED5_SINK_REG_SRC_SEL_MOD_A : 1130 WLED5_SINK_REG_SRC_SEL_MOD_B); 1131 1132 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT; 1133 sink_en |= 1 << temp; 1134 } 1135 1136 rc = wled5_cabc_config(wled, wled->cfg.cabc_sel ? true : false); 1137 if (rc < 0) 1138 return rc; 1139 1140 /* Enable one of the modulators A or B based on mod_sel */ 1141 addr = wled->sink_addr + WLED5_SINK_REG_MOD_A_EN; 1142 val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_EN_MASK : 0; 1143 rc = regmap_update_bits(wled->regmap, addr, 1144 WLED5_SINK_REG_MOD_EN_MASK, val); 1145 if (rc < 0) 1146 return rc; 1147 1148 addr = wled->sink_addr + WLED5_SINK_REG_MOD_B_EN; 1149 val = (wled->cfg.mod_sel == MOD_B) ? WLED5_SINK_REG_MOD_EN_MASK : 0; 1150 rc = regmap_update_bits(wled->regmap, addr, 1151 WLED5_SINK_REG_MOD_EN_MASK, val); 1152 if (rc < 0) 1153 return rc; 1154 1155 offset = (wled->cfg.mod_sel == MOD_A) ? 1156 WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL : 1157 WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL; 1158 1159 addr = wled->sink_addr + offset; 1160 val = (wled->max_brightness == WLED5_SINK_REG_BRIGHT_MAX_15B) ? 1161 WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B : 1162 WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B; 1163 rc = regmap_write(wled->regmap, addr, val); 1164 if (rc < 0) 1165 return rc; 1166 1167 rc = regmap_update_bits(wled->regmap, 1168 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 1169 WLED4_SINK_REG_CURR_SINK_MASK, sink_en); 1170 if (rc < 0) 1171 return rc; 1172 1173 /* This updates only FSC configuration in WLED5 */ 1174 rc = wled->wled_sync_toggle(wled); 1175 if (rc < 0) { 1176 pr_err("Failed to toggle sync reg rc:%d\n", rc); 1177 return rc; 1178 } 1179 1180 rc = wled_auto_detection_at_init(wled); 1181 if (rc < 0) 1182 return rc; 1183 1184 return 0; 1185 } 1186 1187 static const struct wled_config wled5_config_defaults = { 1188 .boost_i_limit = 5, 1189 .string_i_limit = 10, 1190 .ovp = 4, 1191 .num_strings = 4, 1192 .switch_freq = 11, 1193 .mod_sel = 0, 1194 .cabc_sel = 0, 1195 .cabc = false, 1196 .external_pfet = false, 1197 .auto_detection_enabled = false, 1198 .enabled_strings = {0, 1, 2, 3}, 1199 }; 1200 1201 static const u32 wled3_boost_i_limit_values[] = { 1202 105, 385, 525, 805, 980, 1260, 1400, 1680, 1203 }; 1204 1205 static const struct wled_var_cfg wled3_boost_i_limit_cfg = { 1206 .values = wled3_boost_i_limit_values, 1207 .size = ARRAY_SIZE(wled3_boost_i_limit_values), 1208 }; 1209 1210 static const u32 wled4_boost_i_limit_values[] = { 1211 105, 280, 450, 620, 970, 1150, 1300, 1500, 1212 }; 1213 1214 static const struct wled_var_cfg wled4_boost_i_limit_cfg = { 1215 .values = wled4_boost_i_limit_values, 1216 .size = ARRAY_SIZE(wled4_boost_i_limit_values), 1217 }; 1218 1219 static inline u32 wled5_boost_i_limit_values_fn(u32 idx) 1220 { 1221 return 525 + (idx * 175); 1222 } 1223 1224 static const struct wled_var_cfg wled5_boost_i_limit_cfg = { 1225 .fn = wled5_boost_i_limit_values_fn, 1226 .size = 8, 1227 }; 1228 1229 static const u32 wled3_ovp_values[] = { 1230 35, 32, 29, 27, 1231 }; 1232 1233 static const struct wled_var_cfg wled3_ovp_cfg = { 1234 .values = wled3_ovp_values, 1235 .size = ARRAY_SIZE(wled3_ovp_values), 1236 }; 1237 1238 static const u32 wled4_ovp_values[] = { 1239 31100, 29600, 19600, 18100, 1240 }; 1241 1242 static const struct wled_var_cfg wled4_ovp_cfg = { 1243 .values = wled4_ovp_values, 1244 .size = ARRAY_SIZE(wled4_ovp_values), 1245 }; 1246 1247 static const u32 pmi8994_wled_ovp_values[] = { 1248 31000, 29500, 19400, 17800, 1249 }; 1250 1251 static const struct wled_var_cfg pmi8994_wled_ovp_cfg = { 1252 .values = pmi8994_wled_ovp_values, 1253 .size = ARRAY_SIZE(pmi8994_wled_ovp_values), 1254 }; 1255 1256 static inline u32 wled5_ovp_values_fn(u32 idx) 1257 { 1258 /* 1259 * 0000 - 38.5 V 1260 * 0001 - 37 V .. 1261 * 1111 - 16 V 1262 */ 1263 return 38500 - (idx * 1500); 1264 } 1265 1266 static const struct wled_var_cfg wled5_ovp_cfg = { 1267 .fn = wled5_ovp_values_fn, 1268 .size = 16, 1269 }; 1270 1271 static u32 wled3_switch_freq_values_fn(u32 idx) 1272 { 1273 return 19200 / (2 * (1 + idx)); 1274 } 1275 1276 static const struct wled_var_cfg wled3_switch_freq_cfg = { 1277 .fn = wled3_switch_freq_values_fn, 1278 .size = 16, 1279 }; 1280 1281 static const struct wled_var_cfg wled3_string_i_limit_cfg = { 1282 .size = 26, 1283 }; 1284 1285 static const u32 wled4_string_i_limit_values[] = { 1286 0, 2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000, 1287 22500, 25000, 27500, 30000, 1288 }; 1289 1290 static const struct wled_var_cfg wled4_string_i_limit_cfg = { 1291 .values = wled4_string_i_limit_values, 1292 .size = ARRAY_SIZE(wled4_string_i_limit_values), 1293 }; 1294 1295 static const struct wled_var_cfg wled5_mod_sel_cfg = { 1296 .size = 2, 1297 }; 1298 1299 static const struct wled_var_cfg wled5_cabc_sel_cfg = { 1300 .size = 4, 1301 }; 1302 1303 static u32 wled_values(const struct wled_var_cfg *cfg, u32 idx) 1304 { 1305 if (idx >= cfg->size) 1306 return UINT_MAX; 1307 if (cfg->fn) 1308 return cfg->fn(idx); 1309 if (cfg->values) 1310 return cfg->values[idx]; 1311 return idx; 1312 } 1313 1314 static int wled_configure(struct wled *wled) 1315 { 1316 struct wled_config *cfg = &wled->cfg; 1317 struct device *dev = wled->dev; 1318 const __be32 *prop_addr; 1319 u32 size, val, c; 1320 int rc, i, j, string_len; 1321 1322 const struct wled_u32_opts *u32_opts = NULL; 1323 const struct wled_u32_opts wled3_opts[] = { 1324 { 1325 .name = "qcom,current-boost-limit", 1326 .val_ptr = &cfg->boost_i_limit, 1327 .cfg = &wled3_boost_i_limit_cfg, 1328 }, 1329 { 1330 .name = "qcom,current-limit", 1331 .val_ptr = &cfg->string_i_limit, 1332 .cfg = &wled3_string_i_limit_cfg, 1333 }, 1334 { 1335 .name = "qcom,ovp", 1336 .val_ptr = &cfg->ovp, 1337 .cfg = &wled3_ovp_cfg, 1338 }, 1339 { 1340 .name = "qcom,switching-freq", 1341 .val_ptr = &cfg->switch_freq, 1342 .cfg = &wled3_switch_freq_cfg, 1343 }, 1344 }; 1345 1346 const struct wled_u32_opts wled4_opts[] = { 1347 { 1348 .name = "qcom,current-boost-limit", 1349 .val_ptr = &cfg->boost_i_limit, 1350 .cfg = &wled4_boost_i_limit_cfg, 1351 }, 1352 { 1353 .name = "qcom,current-limit-microamp", 1354 .val_ptr = &cfg->string_i_limit, 1355 .cfg = &wled4_string_i_limit_cfg, 1356 }, 1357 { 1358 .name = "qcom,ovp-millivolt", 1359 .val_ptr = &cfg->ovp, 1360 .cfg = &wled4_ovp_cfg, 1361 }, 1362 { 1363 .name = "qcom,switching-freq", 1364 .val_ptr = &cfg->switch_freq, 1365 .cfg = &wled3_switch_freq_cfg, 1366 }, 1367 }; 1368 1369 const struct wled_u32_opts pmi8994_wled_opts[] = { 1370 { 1371 .name = "qcom,current-boost-limit", 1372 .val_ptr = &cfg->boost_i_limit, 1373 .cfg = &wled4_boost_i_limit_cfg, 1374 }, 1375 { 1376 .name = "qcom,current-limit-microamp", 1377 .val_ptr = &cfg->string_i_limit, 1378 .cfg = &wled4_string_i_limit_cfg, 1379 }, 1380 { 1381 .name = "qcom,ovp-millivolt", 1382 .val_ptr = &cfg->ovp, 1383 .cfg = &pmi8994_wled_ovp_cfg, 1384 }, 1385 { 1386 .name = "qcom,switching-freq", 1387 .val_ptr = &cfg->switch_freq, 1388 .cfg = &wled3_switch_freq_cfg, 1389 }, 1390 }; 1391 1392 const struct wled_u32_opts wled5_opts[] = { 1393 { 1394 .name = "qcom,current-boost-limit", 1395 .val_ptr = &cfg->boost_i_limit, 1396 .cfg = &wled5_boost_i_limit_cfg, 1397 }, 1398 { 1399 .name = "qcom,current-limit-microamp", 1400 .val_ptr = &cfg->string_i_limit, 1401 .cfg = &wled4_string_i_limit_cfg, 1402 }, 1403 { 1404 .name = "qcom,ovp-millivolt", 1405 .val_ptr = &cfg->ovp, 1406 .cfg = &wled5_ovp_cfg, 1407 }, 1408 { 1409 .name = "qcom,switching-freq", 1410 .val_ptr = &cfg->switch_freq, 1411 .cfg = &wled3_switch_freq_cfg, 1412 }, 1413 { 1414 .name = "qcom,modulator-sel", 1415 .val_ptr = &cfg->mod_sel, 1416 .cfg = &wled5_mod_sel_cfg, 1417 }, 1418 { 1419 .name = "qcom,cabc-sel", 1420 .val_ptr = &cfg->cabc_sel, 1421 .cfg = &wled5_cabc_sel_cfg, 1422 }, 1423 }; 1424 1425 const struct wled_bool_opts bool_opts[] = { 1426 { "qcom,cs-out", &cfg->cs_out_en, }, 1427 { "qcom,ext-gen", &cfg->ext_gen, }, 1428 { "qcom,cabc", &cfg->cabc, }, 1429 { "qcom,external-pfet", &cfg->external_pfet, }, 1430 { "qcom,auto-string-detection", &cfg->auto_detection_enabled, }, 1431 }; 1432 1433 prop_addr = of_get_address(dev->of_node, 0, NULL, NULL); 1434 if (!prop_addr) { 1435 dev_err(wled->dev, "invalid IO resources\n"); 1436 return -EINVAL; 1437 } 1438 wled->ctrl_addr = be32_to_cpu(*prop_addr); 1439 1440 rc = of_property_read_string(dev->of_node, "label", &wled->name); 1441 if (rc) { 1442 wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node); 1443 if (!wled->name) 1444 return -ENOMEM; 1445 } 1446 switch (wled->version) { 1447 case 3: 1448 u32_opts = wled3_opts; 1449 size = ARRAY_SIZE(wled3_opts); 1450 *cfg = wled3_config_defaults; 1451 wled->wled_set_brightness = wled3_set_brightness; 1452 wled->wled_sync_toggle = wled3_sync_toggle; 1453 wled->max_string_count = 3; 1454 wled->sink_addr = wled->ctrl_addr; 1455 break; 1456 1457 case 4: 1458 if (of_device_is_compatible(dev->of_node, "qcom,pmi8950-wled") || 1459 of_device_is_compatible(dev->of_node, "qcom,pmi8994-wled")) { 1460 u32_opts = pmi8994_wled_opts; 1461 size = ARRAY_SIZE(pmi8994_wled_opts); 1462 } else { 1463 u32_opts = wled4_opts; 1464 size = ARRAY_SIZE(wled4_opts); 1465 } 1466 *cfg = wled4_config_defaults; 1467 wled->wled_set_brightness = wled4_set_brightness; 1468 wled->wled_sync_toggle = wled3_sync_toggle; 1469 wled->wled_cabc_config = wled4_cabc_config; 1470 wled->wled_ovp_delay = wled4_ovp_delay; 1471 wled->wled_auto_detection_required = 1472 wled4_auto_detection_required; 1473 wled->max_string_count = 4; 1474 1475 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL); 1476 if (!prop_addr) { 1477 dev_err(wled->dev, "invalid IO resources\n"); 1478 return -EINVAL; 1479 } 1480 wled->sink_addr = be32_to_cpu(*prop_addr); 1481 break; 1482 1483 case 5: 1484 u32_opts = wled5_opts; 1485 size = ARRAY_SIZE(wled5_opts); 1486 *cfg = wled5_config_defaults; 1487 wled->wled_set_brightness = wled5_set_brightness; 1488 wled->wled_sync_toggle = wled3_sync_toggle; 1489 wled->wled_cabc_config = wled5_cabc_config; 1490 wled->wled_ovp_delay = wled5_ovp_delay; 1491 wled->wled_auto_detection_required = 1492 wled5_auto_detection_required; 1493 wled->max_string_count = 4; 1494 1495 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL); 1496 if (!prop_addr) { 1497 dev_err(wled->dev, "invalid IO resources\n"); 1498 return -EINVAL; 1499 } 1500 wled->sink_addr = be32_to_cpu(*prop_addr); 1501 break; 1502 1503 default: 1504 dev_err(wled->dev, "Invalid WLED version\n"); 1505 return -EINVAL; 1506 } 1507 1508 for (i = 0; i < size; ++i) { 1509 rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val); 1510 if (rc == -EINVAL) { 1511 continue; 1512 } else if (rc) { 1513 dev_err(dev, "error reading '%s'\n", u32_opts[i].name); 1514 return rc; 1515 } 1516 1517 c = UINT_MAX; 1518 for (j = 0; c != val; j++) { 1519 c = wled_values(u32_opts[i].cfg, j); 1520 if (c == UINT_MAX) { 1521 dev_err(dev, "invalid value for '%s'\n", 1522 u32_opts[i].name); 1523 return -EINVAL; 1524 } 1525 1526 if (c == val) 1527 break; 1528 } 1529 1530 dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c); 1531 *u32_opts[i].val_ptr = j; 1532 } 1533 1534 for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) { 1535 if (of_property_read_bool(dev->of_node, bool_opts[i].name)) 1536 *bool_opts[i].val_ptr = true; 1537 } 1538 1539 string_len = of_property_count_elems_of_size(dev->of_node, 1540 "qcom,enabled-strings", 1541 sizeof(u32)); 1542 if (string_len > 0) { 1543 if (string_len > wled->max_string_count) { 1544 dev_err(dev, "Cannot have more than %d strings\n", 1545 wled->max_string_count); 1546 return -EINVAL; 1547 } 1548 1549 rc = of_property_read_u32_array(dev->of_node, 1550 "qcom,enabled-strings", 1551 wled->cfg.enabled_strings, 1552 string_len); 1553 if (rc) { 1554 dev_err(dev, "Failed to read %d elements from qcom,enabled-strings: %d\n", 1555 string_len, rc); 1556 return rc; 1557 } 1558 1559 for (i = 0; i < string_len; ++i) { 1560 if (wled->cfg.enabled_strings[i] >= wled->max_string_count) { 1561 dev_err(dev, 1562 "qcom,enabled-strings index %d at %d is out of bounds\n", 1563 wled->cfg.enabled_strings[i], i); 1564 return -EINVAL; 1565 } 1566 } 1567 1568 cfg->num_strings = string_len; 1569 } 1570 1571 rc = of_property_read_u32(dev->of_node, "qcom,num-strings", &val); 1572 if (!rc) { 1573 if (val < 1 || val > wled->max_string_count) { 1574 dev_err(dev, "qcom,num-strings must be between 1 and %d\n", 1575 wled->max_string_count); 1576 return -EINVAL; 1577 } 1578 1579 if (string_len > 0) { 1580 dev_warn(dev, "Only one of qcom,num-strings or qcom,enabled-strings" 1581 " should be set\n"); 1582 if (val > string_len) { 1583 dev_err(dev, "qcom,num-strings exceeds qcom,enabled-strings\n"); 1584 return -EINVAL; 1585 } 1586 } 1587 1588 cfg->num_strings = val; 1589 } 1590 1591 return 0; 1592 } 1593 1594 static int wled_configure_short_irq(struct wled *wled, 1595 struct platform_device *pdev) 1596 { 1597 int rc; 1598 1599 if (!wled->has_short_detect) 1600 return 0; 1601 1602 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr + 1603 WLED4_CTRL_REG_SHORT_PROTECT, 1604 WLED4_CTRL_REG_SHORT_EN_MASK, 1605 WLED4_CTRL_REG_SHORT_EN_MASK); 1606 if (rc < 0) 1607 return rc; 1608 1609 wled->short_irq = platform_get_irq_byname(pdev, "short"); 1610 if (wled->short_irq < 0) { 1611 dev_dbg(&pdev->dev, "short irq is not used\n"); 1612 return 0; 1613 } 1614 1615 rc = devm_request_threaded_irq(wled->dev, wled->short_irq, 1616 NULL, wled_short_irq_handler, 1617 IRQF_ONESHOT, 1618 "wled_short_irq", wled); 1619 if (rc < 0) 1620 dev_err(wled->dev, "Unable to request short_irq (err:%d)\n", 1621 rc); 1622 1623 return rc; 1624 } 1625 1626 static int wled_configure_ovp_irq(struct wled *wled, 1627 struct platform_device *pdev) 1628 { 1629 int rc; 1630 u32 val; 1631 1632 wled->ovp_irq = platform_get_irq_byname(pdev, "ovp"); 1633 if (wled->ovp_irq < 0) { 1634 dev_dbg(&pdev->dev, "OVP IRQ not found - disabling automatic string detection\n"); 1635 return 0; 1636 } 1637 1638 rc = devm_request_threaded_irq(wled->dev, wled->ovp_irq, NULL, 1639 wled_ovp_irq_handler, IRQF_ONESHOT, 1640 "wled_ovp_irq", wled); 1641 if (rc < 0) { 1642 dev_err(wled->dev, "Unable to request ovp_irq (err:%d)\n", 1643 rc); 1644 wled->ovp_irq = 0; 1645 return 0; 1646 } 1647 1648 rc = regmap_read(wled->regmap, wled->ctrl_addr + 1649 WLED3_CTRL_REG_MOD_EN, &val); 1650 if (rc < 0) 1651 return rc; 1652 1653 /* Keep OVP irq disabled until module is enabled */ 1654 if (!(val & WLED3_CTRL_REG_MOD_EN_MASK)) 1655 disable_irq(wled->ovp_irq); 1656 1657 return 0; 1658 } 1659 1660 static const struct backlight_ops wled_ops = { 1661 .update_status = wled_update_status, 1662 }; 1663 1664 static int wled_probe(struct platform_device *pdev) 1665 { 1666 struct backlight_properties props; 1667 struct backlight_device *bl; 1668 struct wled *wled; 1669 struct regmap *regmap; 1670 u32 val; 1671 int rc; 1672 1673 regmap = dev_get_regmap(pdev->dev.parent, NULL); 1674 if (!regmap) { 1675 dev_err(&pdev->dev, "Unable to get regmap\n"); 1676 return -EINVAL; 1677 } 1678 1679 wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL); 1680 if (!wled) 1681 return -ENOMEM; 1682 1683 wled->regmap = regmap; 1684 wled->dev = &pdev->dev; 1685 1686 wled->version = (uintptr_t)of_device_get_match_data(&pdev->dev); 1687 if (!wled->version) { 1688 dev_err(&pdev->dev, "Unknown device version\n"); 1689 return -ENODEV; 1690 } 1691 1692 mutex_init(&wled->lock); 1693 rc = wled_configure(wled); 1694 if (rc) 1695 return rc; 1696 1697 val = WLED3_SINK_REG_BRIGHT_MAX; 1698 of_property_read_u32(pdev->dev.of_node, "max-brightness", &val); 1699 wled->max_brightness = val; 1700 1701 switch (wled->version) { 1702 case 3: 1703 wled->cfg.auto_detection_enabled = false; 1704 rc = wled3_setup(wled); 1705 if (rc) { 1706 dev_err(&pdev->dev, "wled3_setup failed\n"); 1707 return rc; 1708 } 1709 break; 1710 1711 case 4: 1712 wled->has_short_detect = true; 1713 rc = wled4_setup(wled); 1714 if (rc) { 1715 dev_err(&pdev->dev, "wled4_setup failed\n"); 1716 return rc; 1717 } 1718 break; 1719 1720 case 5: 1721 wled->has_short_detect = true; 1722 if (wled->cfg.cabc_sel) 1723 wled->max_brightness = WLED5_SINK_REG_BRIGHT_MAX_12B; 1724 1725 rc = wled5_setup(wled); 1726 if (rc) { 1727 dev_err(&pdev->dev, "wled5_setup failed\n"); 1728 return rc; 1729 } 1730 break; 1731 1732 default: 1733 dev_err(wled->dev, "Invalid WLED version\n"); 1734 break; 1735 } 1736 1737 INIT_DELAYED_WORK(&wled->ovp_work, wled_ovp_work); 1738 1739 rc = wled_configure_short_irq(wled, pdev); 1740 if (rc < 0) 1741 return rc; 1742 1743 rc = wled_configure_ovp_irq(wled, pdev); 1744 if (rc < 0) 1745 return rc; 1746 1747 val = WLED_DEFAULT_BRIGHTNESS; 1748 of_property_read_u32(pdev->dev.of_node, "default-brightness", &val); 1749 1750 memset(&props, 0, sizeof(struct backlight_properties)); 1751 props.type = BACKLIGHT_RAW; 1752 props.brightness = val; 1753 props.max_brightness = wled->max_brightness; 1754 bl = devm_backlight_device_register(&pdev->dev, wled->name, 1755 &pdev->dev, wled, 1756 &wled_ops, &props); 1757 return PTR_ERR_OR_ZERO(bl); 1758 }; 1759 1760 static void wled_remove(struct platform_device *pdev) 1761 { 1762 struct wled *wled = platform_get_drvdata(pdev); 1763 1764 mutex_destroy(&wled->lock); 1765 cancel_delayed_work_sync(&wled->ovp_work); 1766 disable_irq(wled->short_irq); 1767 disable_irq(wled->ovp_irq); 1768 } 1769 1770 static const struct of_device_id wled_match_table[] = { 1771 { .compatible = "qcom,pm8941-wled", .data = (void *)3 }, 1772 { .compatible = "qcom,pmi8950-wled", .data = (void *)4 }, 1773 { .compatible = "qcom,pmi8994-wled", .data = (void *)4 }, 1774 { .compatible = "qcom,pmi8998-wled", .data = (void *)4 }, 1775 { .compatible = "qcom,pm660l-wled", .data = (void *)4 }, 1776 { .compatible = "qcom,pm6150l-wled", .data = (void *)5 }, 1777 { .compatible = "qcom,pm8150l-wled", .data = (void *)5 }, 1778 {} 1779 }; 1780 MODULE_DEVICE_TABLE(of, wled_match_table); 1781 1782 static struct platform_driver wled_driver = { 1783 .probe = wled_probe, 1784 .remove = wled_remove, 1785 .driver = { 1786 .name = "qcom,wled", 1787 .of_match_table = wled_match_table, 1788 }, 1789 }; 1790 1791 module_platform_driver(wled_driver); 1792 1793 MODULE_DESCRIPTION("Qualcomm WLED driver"); 1794 MODULE_LICENSE("GPL v2"); 1795