1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2022, 2024 Qualcomm Innovation Center, Inc. All rights reserved. 4 */ 5 6 #include <linux/bitfield.h> 7 #include <linux/bits.h> 8 #include <linux/leds.h> 9 #include <linux/led-class-flash.h> 10 #include <linux/module.h> 11 #include <linux/platform_device.h> 12 #include <linux/property.h> 13 #include <linux/regmap.h> 14 #include <media/v4l2-flash-led-class.h> 15 16 /* registers definitions */ 17 #define FLASH_REVISION_REG 0x00 18 #define FLASH_4CH_REVISION_V0P1 0x01 19 20 #define FLASH_TYPE_REG 0x04 21 #define FLASH_TYPE_VAL 0x18 22 23 #define FLASH_SUBTYPE_REG 0x05 24 #define FLASH_SUBTYPE_3CH_PM8150_VAL 0x04 25 #define FLASH_SUBTYPE_3CH_PMI8998_VAL 0x03 26 #define FLASH_SUBTYPE_4CH_VAL 0x07 27 28 #define FLASH_STS_3CH_OTST1 BIT(0) 29 #define FLASH_STS_3CH_OTST2 BIT(1) 30 #define FLASH_STS_3CH_OTST3 BIT(2) 31 #define FLASH_STS_3CH_BOB_THM_OVERLOAD BIT(3) 32 #define FLASH_STS_3CH_VPH_DROOP BIT(4) 33 #define FLASH_STS_3CH_BOB_ILIM_S1 BIT(5) 34 #define FLASH_STS_3CH_BOB_ILIM_S2 BIT(6) 35 #define FLASH_STS_3CH_BCL_IBAT BIT(7) 36 37 #define FLASH_STS_4CH_VPH_LOW BIT(0) 38 #define FLASH_STS_4CH_BCL_IBAT BIT(1) 39 #define FLASH_STS_4CH_BOB_ILIM_S1 BIT(2) 40 #define FLASH_STS_4CH_BOB_ILIM_S2 BIT(3) 41 #define FLASH_STS_4CH_OTST2 BIT(4) 42 #define FLASH_STS_4CH_OTST1 BIT(5) 43 #define FLASH_STS_4CHG_BOB_THM_OVERLOAD BIT(6) 44 45 #define FLASH_TIMER_EN_BIT BIT(7) 46 #define FLASH_TIMER_VAL_MASK GENMASK(6, 0) 47 #define FLASH_TIMER_STEP_MS 10 48 49 #define FLASH_STROBE_HW_SW_SEL_BIT BIT(2) 50 #define SW_STROBE_VAL 0 51 #define HW_STROBE_VAL 1 52 #define FLASH_HW_STROBE_TRIGGER_SEL_BIT BIT(1) 53 #define STROBE_LEVEL_TRIGGER_VAL 0 54 #define STROBE_EDGE_TRIGGER_VAL 1 55 #define FLASH_STROBE_POLARITY_BIT BIT(0) 56 #define STROBE_ACTIVE_HIGH_VAL 1 57 58 #define FLASH_IRES_MASK_4CH BIT(0) 59 #define FLASH_IRES_MASK_3CH GENMASK(1, 0) 60 #define FLASH_IRES_12P5MA_VAL 0 61 #define FLASH_IRES_5MA_VAL_4CH 1 62 #define FLASH_IRES_5MA_VAL_3CH 3 63 64 /* constants */ 65 #define FLASH_CURRENT_MAX_UA 1500000 66 #define TORCH_CURRENT_MAX_UA 500000 67 #define FLASH_TOTAL_CURRENT_MAX_UA 2000000 68 #define FLASH_CURRENT_DEFAULT_UA 1000000 69 #define TORCH_CURRENT_DEFAULT_UA 200000 70 71 #define TORCH_IRES_UA 5000 72 #define FLASH_IRES_UA 12500 73 74 #define FLASH_TIMEOUT_MAX_US 1280000 75 #define FLASH_TIMEOUT_STEP_US 10000 76 77 #define UA_PER_MA 1000 78 79 /* thermal threshold constants */ 80 #define OTST_3CH_MIN_VAL 3 81 #define OTST1_4CH_MIN_VAL 0 82 #define OTST1_4CH_V0P1_MIN_VAL 3 83 #define OTST2_4CH_MIN_VAL 0 84 85 #define OTST1_MAX_CURRENT_MA 1000 86 #define OTST2_MAX_CURRENT_MA 500 87 #define OTST3_MAX_CURRENT_MA 200 88 89 enum hw_type { 90 QCOM_MVFLASH_3CH, 91 QCOM_MVFLASH_4CH, 92 }; 93 94 enum led_mode { 95 FLASH_MODE, 96 TORCH_MODE, 97 }; 98 99 enum led_strobe { 100 SW_STROBE, 101 HW_STROBE, 102 }; 103 104 enum { 105 REG_STATUS1, 106 REG_STATUS2, 107 REG_STATUS3, 108 REG_CHAN_TIMER, 109 REG_ITARGET, 110 REG_MODULE_EN, 111 REG_IRESOLUTION, 112 REG_CHAN_STROBE, 113 REG_CHAN_EN, 114 REG_THERM_THRSH1, 115 REG_THERM_THRSH2, 116 REG_THERM_THRSH3, 117 REG_MAX_COUNT, 118 }; 119 120 static struct reg_field mvflash_3ch_regs[REG_MAX_COUNT] = { 121 REG_FIELD(0x08, 0, 7), /* status1 */ 122 REG_FIELD(0x09, 0, 7), /* status2 */ 123 REG_FIELD(0x0a, 0, 7), /* status3 */ 124 REG_FIELD_ID(0x40, 0, 7, 3, 1), /* chan_timer */ 125 REG_FIELD_ID(0x43, 0, 6, 3, 1), /* itarget */ 126 REG_FIELD(0x46, 7, 7), /* module_en */ 127 REG_FIELD(0x47, 0, 5), /* iresolution */ 128 REG_FIELD_ID(0x49, 0, 2, 3, 1), /* chan_strobe */ 129 REG_FIELD(0x4c, 0, 2), /* chan_en */ 130 REG_FIELD(0x56, 0, 2), /* therm_thrsh1 */ 131 REG_FIELD(0x57, 0, 2), /* therm_thrsh2 */ 132 REG_FIELD(0x58, 0, 2), /* therm_thrsh3 */ 133 }; 134 135 static struct reg_field mvflash_4ch_regs[REG_MAX_COUNT] = { 136 REG_FIELD(0x06, 0, 7), /* status1 */ 137 REG_FIELD(0x07, 0, 6), /* status2 */ 138 REG_FIELD(0x09, 0, 7), /* status3 */ 139 REG_FIELD_ID(0x3e, 0, 7, 4, 1), /* chan_timer */ 140 REG_FIELD_ID(0x42, 0, 6, 4, 1), /* itarget */ 141 REG_FIELD(0x46, 7, 7), /* module_en */ 142 REG_FIELD(0x49, 0, 3), /* iresolution */ 143 REG_FIELD_ID(0x4a, 0, 6, 4, 1), /* chan_strobe */ 144 REG_FIELD(0x4e, 0, 3), /* chan_en */ 145 REG_FIELD(0x7a, 0, 2), /* therm_thrsh1 */ 146 REG_FIELD(0x78, 0, 2), /* therm_thrsh2 */ 147 }; 148 149 struct qcom_flash_data { 150 struct v4l2_flash **v4l2_flash; 151 struct regmap_field *r_fields[REG_MAX_COUNT]; 152 struct mutex lock; 153 enum hw_type hw_type; 154 u32 total_ma; 155 u8 leds_count; 156 u8 max_channels; 157 u8 chan_en_bits; 158 u8 revision; 159 }; 160 161 struct qcom_flash_led { 162 struct qcom_flash_data *flash_data; 163 struct led_classdev_flash flash; 164 u32 max_flash_current_ma; 165 u32 max_torch_current_ma; 166 u32 max_timeout_ms; 167 u32 flash_current_ma; 168 u32 flash_timeout_ms; 169 u32 current_in_use_ma; 170 u8 *chan_id; 171 u8 chan_count; 172 bool enabled; 173 }; 174 175 static int set_flash_module_en(struct qcom_flash_led *led, bool en) 176 { 177 struct qcom_flash_data *flash_data = led->flash_data; 178 u8 led_mask = 0, enable; 179 int i, rc; 180 181 for (i = 0; i < led->chan_count; i++) 182 led_mask |= BIT(led->chan_id[i]); 183 184 mutex_lock(&flash_data->lock); 185 if (en) 186 flash_data->chan_en_bits |= led_mask; 187 else 188 flash_data->chan_en_bits &= ~led_mask; 189 190 enable = !!flash_data->chan_en_bits; 191 rc = regmap_field_write(flash_data->r_fields[REG_MODULE_EN], enable); 192 if (rc) 193 dev_err(led->flash.led_cdev.dev, "write module_en failed, rc=%d\n", rc); 194 mutex_unlock(&flash_data->lock); 195 196 return rc; 197 } 198 199 static int update_allowed_flash_current(struct qcom_flash_led *led, u32 *current_ma, bool strobe) 200 { 201 struct qcom_flash_data *flash_data = led->flash_data; 202 u32 therm_ma, avail_ma, thrsh[3], min_thrsh, sts; 203 int rc = 0; 204 205 mutex_lock(&flash_data->lock); 206 /* 207 * Put previously allocated current into allowed budget in either of these two cases: 208 * 1) LED is disabled; 209 * 2) LED is enabled repeatedly 210 */ 211 if (!strobe || led->current_in_use_ma != 0) { 212 if (flash_data->total_ma >= led->current_in_use_ma) 213 flash_data->total_ma -= led->current_in_use_ma; 214 else 215 flash_data->total_ma = 0; 216 217 led->current_in_use_ma = 0; 218 if (!strobe) 219 goto unlock; 220 } 221 222 /* 223 * Cache the default thermal threshold settings, and set them to the lowest levels before 224 * reading over-temp real time status. If over-temp has been triggered at the lowest 225 * threshold, it's very likely that it would be triggered at a higher (default) threshold 226 * when more flash current is requested. Prevent device from triggering over-temp condition 227 * by limiting the flash current for the new request. 228 */ 229 rc = regmap_field_read(flash_data->r_fields[REG_THERM_THRSH1], &thrsh[0]); 230 if (rc < 0) 231 goto unlock; 232 233 rc = regmap_field_read(flash_data->r_fields[REG_THERM_THRSH2], &thrsh[1]); 234 if (rc < 0) 235 goto unlock; 236 237 if (flash_data->hw_type == QCOM_MVFLASH_3CH) { 238 rc = regmap_field_read(flash_data->r_fields[REG_THERM_THRSH3], &thrsh[2]); 239 if (rc < 0) 240 goto unlock; 241 } 242 243 min_thrsh = OTST_3CH_MIN_VAL; 244 if (flash_data->hw_type == QCOM_MVFLASH_4CH) 245 min_thrsh = (flash_data->revision == FLASH_4CH_REVISION_V0P1) ? 246 OTST1_4CH_V0P1_MIN_VAL : OTST1_4CH_MIN_VAL; 247 248 rc = regmap_field_write(flash_data->r_fields[REG_THERM_THRSH1], min_thrsh); 249 if (rc < 0) 250 goto unlock; 251 252 if (flash_data->hw_type == QCOM_MVFLASH_4CH) 253 min_thrsh = OTST2_4CH_MIN_VAL; 254 255 /* 256 * The default thermal threshold settings have been updated hence 257 * restore them if any fault happens starting from here. 258 */ 259 rc = regmap_field_write(flash_data->r_fields[REG_THERM_THRSH2], min_thrsh); 260 if (rc < 0) 261 goto restore; 262 263 if (flash_data->hw_type == QCOM_MVFLASH_3CH) { 264 rc = regmap_field_write(flash_data->r_fields[REG_THERM_THRSH3], min_thrsh); 265 if (rc < 0) 266 goto restore; 267 } 268 269 /* Read thermal level status to get corresponding derating flash current */ 270 rc = regmap_field_read(flash_data->r_fields[REG_STATUS2], &sts); 271 if (rc) 272 goto restore; 273 274 therm_ma = FLASH_TOTAL_CURRENT_MAX_UA / 1000; 275 if (flash_data->hw_type == QCOM_MVFLASH_3CH) { 276 if (sts & FLASH_STS_3CH_OTST3) 277 therm_ma = OTST3_MAX_CURRENT_MA; 278 else if (sts & FLASH_STS_3CH_OTST2) 279 therm_ma = OTST2_MAX_CURRENT_MA; 280 else if (sts & FLASH_STS_3CH_OTST1) 281 therm_ma = OTST1_MAX_CURRENT_MA; 282 } else { 283 if (sts & FLASH_STS_4CH_OTST2) 284 therm_ma = OTST2_MAX_CURRENT_MA; 285 else if (sts & FLASH_STS_4CH_OTST1) 286 therm_ma = OTST1_MAX_CURRENT_MA; 287 } 288 289 /* Calculate the allowed flash current for the request */ 290 if (therm_ma <= flash_data->total_ma) 291 avail_ma = 0; 292 else 293 avail_ma = therm_ma - flash_data->total_ma; 294 295 *current_ma = min_t(u32, *current_ma, avail_ma); 296 led->current_in_use_ma = *current_ma; 297 flash_data->total_ma += led->current_in_use_ma; 298 299 dev_dbg(led->flash.led_cdev.dev, "allowed flash current: %dmA, total current: %dmA\n", 300 led->current_in_use_ma, flash_data->total_ma); 301 302 restore: 303 /* Restore to default thermal threshold settings */ 304 rc = regmap_field_write(flash_data->r_fields[REG_THERM_THRSH1], thrsh[0]); 305 if (rc < 0) 306 goto unlock; 307 308 rc = regmap_field_write(flash_data->r_fields[REG_THERM_THRSH2], thrsh[1]); 309 if (rc < 0) 310 goto unlock; 311 312 if (flash_data->hw_type == QCOM_MVFLASH_3CH) 313 rc = regmap_field_write(flash_data->r_fields[REG_THERM_THRSH3], thrsh[2]); 314 315 unlock: 316 mutex_unlock(&flash_data->lock); 317 return rc; 318 } 319 320 static int set_flash_current(struct qcom_flash_led *led, u32 current_ma, enum led_mode mode) 321 { 322 struct qcom_flash_data *flash_data = led->flash_data; 323 u32 itarg_ua, ires_ua; 324 u8 shift, ires_mask = 0, ires_val = 0, chan_id; 325 int i, rc; 326 327 /* 328 * Split the current across the channels and set the 329 * IRESOLUTION and ITARGET registers accordingly. 330 */ 331 itarg_ua = (current_ma * UA_PER_MA) / led->chan_count + 1; 332 ires_ua = (mode == FLASH_MODE) ? FLASH_IRES_UA : TORCH_IRES_UA; 333 334 for (i = 0; i < led->chan_count; i++) { 335 u8 itarget = 0; 336 337 if (itarg_ua > ires_ua) 338 itarget = itarg_ua / ires_ua - 1; 339 340 chan_id = led->chan_id[i]; 341 342 rc = regmap_fields_write(flash_data->r_fields[REG_ITARGET], chan_id, itarget); 343 if (rc) 344 return rc; 345 346 if (flash_data->hw_type == QCOM_MVFLASH_3CH) { 347 shift = chan_id * 2; 348 ires_mask |= FLASH_IRES_MASK_3CH << shift; 349 ires_val |= ((mode == FLASH_MODE) ? 350 (FLASH_IRES_12P5MA_VAL << shift) : 351 (FLASH_IRES_5MA_VAL_3CH << shift)); 352 } else if (flash_data->hw_type == QCOM_MVFLASH_4CH) { 353 shift = chan_id; 354 ires_mask |= FLASH_IRES_MASK_4CH << shift; 355 ires_val |= ((mode == FLASH_MODE) ? 356 (FLASH_IRES_12P5MA_VAL << shift) : 357 (FLASH_IRES_5MA_VAL_4CH << shift)); 358 } else { 359 dev_err(led->flash.led_cdev.dev, 360 "HW type %d is not supported\n", flash_data->hw_type); 361 return -EOPNOTSUPP; 362 } 363 } 364 365 return regmap_field_update_bits(flash_data->r_fields[REG_IRESOLUTION], ires_mask, ires_val); 366 } 367 368 static int set_flash_timeout(struct qcom_flash_led *led, u32 timeout_ms) 369 { 370 struct qcom_flash_data *flash_data = led->flash_data; 371 u8 timer, chan_id; 372 int rc, i; 373 374 /* set SAFETY_TIMER for all the channels connected to the same LED */ 375 timeout_ms = min_t(u32, timeout_ms, led->max_timeout_ms); 376 377 for (i = 0; i < led->chan_count; i++) { 378 chan_id = led->chan_id[i]; 379 380 timer = timeout_ms / FLASH_TIMER_STEP_MS; 381 timer = clamp_t(u8, timer, 0, FLASH_TIMER_VAL_MASK); 382 383 if (timeout_ms) 384 timer |= FLASH_TIMER_EN_BIT; 385 386 rc = regmap_fields_write(flash_data->r_fields[REG_CHAN_TIMER], chan_id, timer); 387 if (rc) 388 return rc; 389 } 390 391 return 0; 392 } 393 394 static int set_flash_strobe(struct qcom_flash_led *led, enum led_strobe strobe, bool state) 395 { 396 struct qcom_flash_data *flash_data = led->flash_data; 397 u8 strobe_sel, chan_en, chan_id, chan_mask = 0; 398 int rc, i; 399 400 /* Set SW strobe config for all channels connected to the LED */ 401 for (i = 0; i < led->chan_count; i++) { 402 chan_id = led->chan_id[i]; 403 404 if (strobe == SW_STROBE) 405 strobe_sel = FIELD_PREP(FLASH_STROBE_HW_SW_SEL_BIT, SW_STROBE_VAL); 406 else 407 strobe_sel = FIELD_PREP(FLASH_STROBE_HW_SW_SEL_BIT, HW_STROBE_VAL); 408 409 strobe_sel |= 410 FIELD_PREP(FLASH_HW_STROBE_TRIGGER_SEL_BIT, STROBE_LEVEL_TRIGGER_VAL) | 411 FIELD_PREP(FLASH_STROBE_POLARITY_BIT, STROBE_ACTIVE_HIGH_VAL); 412 413 rc = regmap_fields_write( 414 flash_data->r_fields[REG_CHAN_STROBE], chan_id, strobe_sel); 415 if (rc) 416 return rc; 417 418 chan_mask |= BIT(chan_id); 419 } 420 421 /* Enable/disable flash channels */ 422 chan_en = state ? chan_mask : 0; 423 rc = regmap_field_update_bits(flash_data->r_fields[REG_CHAN_EN], chan_mask, chan_en); 424 if (rc) 425 return rc; 426 427 led->enabled = state; 428 return 0; 429 } 430 431 static inline struct qcom_flash_led *flcdev_to_qcom_fled(struct led_classdev_flash *flcdev) 432 { 433 return container_of(flcdev, struct qcom_flash_led, flash); 434 } 435 436 static int qcom_flash_brightness_set(struct led_classdev_flash *fled_cdev, u32 brightness) 437 { 438 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 439 440 led->flash_current_ma = min_t(u32, led->max_flash_current_ma, brightness / UA_PER_MA); 441 return 0; 442 } 443 444 static int qcom_flash_timeout_set(struct led_classdev_flash *fled_cdev, u32 timeout) 445 { 446 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 447 448 led->flash_timeout_ms = timeout / USEC_PER_MSEC; 449 return 0; 450 } 451 452 static int qcom_flash_strobe_set(struct led_classdev_flash *fled_cdev, bool state) 453 { 454 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 455 int rc; 456 457 rc = set_flash_strobe(led, SW_STROBE, false); 458 if (rc) 459 return rc; 460 461 rc = update_allowed_flash_current(led, &led->flash_current_ma, state); 462 if (rc < 0) 463 return rc; 464 465 rc = set_flash_current(led, led->flash_current_ma, FLASH_MODE); 466 if (rc) 467 return rc; 468 469 rc = set_flash_timeout(led, led->flash_timeout_ms); 470 if (rc) 471 return rc; 472 473 rc = set_flash_module_en(led, state); 474 if (rc) 475 return rc; 476 477 return set_flash_strobe(led, SW_STROBE, state); 478 } 479 480 static int qcom_flash_strobe_get(struct led_classdev_flash *fled_cdev, bool *state) 481 { 482 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 483 484 *state = led->enabled; 485 return 0; 486 } 487 488 static int qcom_flash_fault_get(struct led_classdev_flash *fled_cdev, u32 *fault) 489 { 490 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 491 struct qcom_flash_data *flash_data = led->flash_data; 492 u8 shift, chan_id, chan_mask = 0; 493 u8 ot_mask = 0, oc_mask = 0, uv_mask = 0; 494 u32 val, fault_sts = 0; 495 int i, rc; 496 497 rc = regmap_field_read(flash_data->r_fields[REG_STATUS1], &val); 498 if (rc) 499 return rc; 500 501 for (i = 0; i < led->chan_count; i++) { 502 chan_id = led->chan_id[i]; 503 shift = chan_id * 2; 504 505 if (val & BIT(shift)) 506 fault_sts |= LED_FAULT_SHORT_CIRCUIT; 507 508 chan_mask |= BIT(chan_id); 509 } 510 511 rc = regmap_field_read(flash_data->r_fields[REG_STATUS2], &val); 512 if (rc) 513 return rc; 514 515 if (flash_data->hw_type == QCOM_MVFLASH_3CH) { 516 ot_mask = FLASH_STS_3CH_OTST1 | 517 FLASH_STS_3CH_OTST2 | 518 FLASH_STS_3CH_OTST3 | 519 FLASH_STS_3CH_BOB_THM_OVERLOAD; 520 oc_mask = FLASH_STS_3CH_BOB_ILIM_S1 | 521 FLASH_STS_3CH_BOB_ILIM_S2 | 522 FLASH_STS_3CH_BCL_IBAT; 523 uv_mask = FLASH_STS_3CH_VPH_DROOP; 524 } else if (flash_data->hw_type == QCOM_MVFLASH_4CH) { 525 ot_mask = FLASH_STS_4CH_OTST2 | 526 FLASH_STS_4CH_OTST1 | 527 FLASH_STS_4CHG_BOB_THM_OVERLOAD; 528 oc_mask = FLASH_STS_4CH_BCL_IBAT | 529 FLASH_STS_4CH_BOB_ILIM_S1 | 530 FLASH_STS_4CH_BOB_ILIM_S2; 531 uv_mask = FLASH_STS_4CH_VPH_LOW; 532 } 533 534 if (val & ot_mask) 535 fault_sts |= LED_FAULT_OVER_TEMPERATURE; 536 537 if (val & oc_mask) 538 fault_sts |= LED_FAULT_OVER_CURRENT; 539 540 if (val & uv_mask) 541 fault_sts |= LED_FAULT_INPUT_VOLTAGE; 542 543 rc = regmap_field_read(flash_data->r_fields[REG_STATUS3], &val); 544 if (rc) 545 return rc; 546 547 if (flash_data->hw_type == QCOM_MVFLASH_3CH) { 548 if (val & chan_mask) 549 fault_sts |= LED_FAULT_TIMEOUT; 550 } else if (flash_data->hw_type == QCOM_MVFLASH_4CH) { 551 for (i = 0; i < led->chan_count; i++) { 552 chan_id = led->chan_id[i]; 553 shift = chan_id * 2; 554 555 if (val & BIT(shift)) 556 fault_sts |= LED_FAULT_TIMEOUT; 557 } 558 } 559 560 *fault = fault_sts; 561 return 0; 562 } 563 564 static int qcom_flash_led_brightness_set(struct led_classdev *led_cdev, 565 enum led_brightness brightness) 566 { 567 struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); 568 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 569 u32 current_ma = brightness * led->max_torch_current_ma / LED_FULL; 570 bool enable = !!brightness; 571 int rc; 572 573 rc = set_flash_strobe(led, SW_STROBE, false); 574 if (rc) 575 return rc; 576 577 rc = set_flash_module_en(led, false); 578 if (rc) 579 return rc; 580 581 rc = update_allowed_flash_current(led, ¤t_ma, enable); 582 if (rc < 0) 583 return rc; 584 585 rc = set_flash_current(led, current_ma, TORCH_MODE); 586 if (rc) 587 return rc; 588 589 /* Disable flash timeout for torch LED */ 590 rc = set_flash_timeout(led, 0); 591 if (rc) 592 return rc; 593 594 rc = set_flash_module_en(led, enable); 595 if (rc) 596 return rc; 597 598 return set_flash_strobe(led, SW_STROBE, enable); 599 } 600 601 static const struct led_flash_ops qcom_flash_ops = { 602 .flash_brightness_set = qcom_flash_brightness_set, 603 .strobe_set = qcom_flash_strobe_set, 604 .strobe_get = qcom_flash_strobe_get, 605 .timeout_set = qcom_flash_timeout_set, 606 .fault_get = qcom_flash_fault_get, 607 }; 608 609 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) 610 static int qcom_flash_external_strobe_set(struct v4l2_flash *v4l2_flash, bool enable) 611 { 612 struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev; 613 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 614 int rc; 615 616 rc = set_flash_module_en(led, enable); 617 if (rc) 618 return rc; 619 620 if (enable) 621 return set_flash_strobe(led, HW_STROBE, true); 622 else 623 return set_flash_strobe(led, SW_STROBE, false); 624 } 625 626 static enum led_brightness 627 qcom_flash_intensity_to_led_brightness(struct v4l2_flash *v4l2_flash, s32 intensity) 628 { 629 struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev; 630 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 631 u32 current_ma = intensity / UA_PER_MA; 632 633 current_ma = min_t(u32, current_ma, led->max_torch_current_ma); 634 if (!current_ma) 635 return LED_OFF; 636 637 return (current_ma * LED_FULL) / led->max_torch_current_ma; 638 } 639 640 static s32 qcom_flash_brightness_to_led_intensity(struct v4l2_flash *v4l2_flash, 641 enum led_brightness brightness) 642 { 643 struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev; 644 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev); 645 646 return (brightness * led->max_torch_current_ma * UA_PER_MA) / LED_FULL; 647 } 648 649 static const struct v4l2_flash_ops qcom_v4l2_flash_ops = { 650 .external_strobe_set = qcom_flash_external_strobe_set, 651 .intensity_to_led_brightness = qcom_flash_intensity_to_led_brightness, 652 .led_brightness_to_intensity = qcom_flash_brightness_to_led_intensity, 653 }; 654 655 static int 656 qcom_flash_v4l2_init(struct device *dev, struct qcom_flash_led *led, struct fwnode_handle *fwnode) 657 { 658 struct qcom_flash_data *flash_data = led->flash_data; 659 struct v4l2_flash_config v4l2_cfg = { 0 }; 660 struct led_flash_setting *intensity = &v4l2_cfg.intensity; 661 struct v4l2_flash *v4l2_flash; 662 663 if (!(led->flash.led_cdev.flags & LED_DEV_CAP_FLASH)) 664 return 0; 665 666 intensity->min = intensity->step = TORCH_IRES_UA * led->chan_count; 667 intensity->max = led->max_torch_current_ma * UA_PER_MA; 668 intensity->val = min_t(u32, intensity->max, TORCH_CURRENT_DEFAULT_UA); 669 670 strscpy(v4l2_cfg.dev_name, led->flash.led_cdev.dev->kobj.name, 671 sizeof(v4l2_cfg.dev_name)); 672 673 v4l2_cfg.has_external_strobe = true; 674 v4l2_cfg.flash_faults = LED_FAULT_INPUT_VOLTAGE | 675 LED_FAULT_OVER_CURRENT | 676 LED_FAULT_SHORT_CIRCUIT | 677 LED_FAULT_OVER_TEMPERATURE | 678 LED_FAULT_TIMEOUT; 679 680 v4l2_flash = v4l2_flash_init(dev, fwnode, &led->flash, &qcom_v4l2_flash_ops, &v4l2_cfg); 681 if (IS_ERR(v4l2_flash)) 682 return PTR_ERR(v4l2_flash); 683 684 flash_data->v4l2_flash[flash_data->leds_count] = v4l2_flash; 685 return 0; 686 } 687 # else 688 static int 689 qcom_flash_v4l2_init(struct device *dev, struct qcom_flash_led *led, struct fwnode_handle *fwnode) 690 { 691 return 0; 692 } 693 #endif 694 695 static int qcom_flash_register_led_device(struct device *dev, 696 struct fwnode_handle *node, struct qcom_flash_led *led) 697 { 698 struct qcom_flash_data *flash_data = led->flash_data; 699 struct led_init_data init_data; 700 struct led_classdev_flash *flash = &led->flash; 701 struct led_flash_setting *brightness, *timeout; 702 u32 current_ua, timeout_us; 703 u32 channels[4]; 704 int i, rc, count; 705 706 count = fwnode_property_count_u32(node, "led-sources"); 707 if (count <= 0) { 708 dev_err(dev, "No led-sources specified\n"); 709 return -ENODEV; 710 } 711 712 if (count > flash_data->max_channels) { 713 dev_err(dev, "led-sources count %u exceeds maximum channel count %u\n", 714 count, flash_data->max_channels); 715 return -EINVAL; 716 } 717 718 rc = fwnode_property_read_u32_array(node, "led-sources", channels, count); 719 if (rc < 0) { 720 dev_err(dev, "Failed to read led-sources property, rc=%d\n", rc); 721 return rc; 722 } 723 724 led->chan_count = count; 725 led->chan_id = devm_kcalloc(dev, count, sizeof(u8), GFP_KERNEL); 726 if (!led->chan_id) 727 return -ENOMEM; 728 729 for (i = 0; i < count; i++) { 730 if ((channels[i] == 0) || (channels[i] > flash_data->max_channels)) { 731 dev_err(dev, "led-source out of HW support range [1-%u]\n", 732 flash_data->max_channels); 733 return -EINVAL; 734 } 735 736 /* Make chan_id indexing from 0 */ 737 led->chan_id[i] = channels[i] - 1; 738 } 739 740 rc = fwnode_property_read_u32(node, "led-max-microamp", ¤t_ua); 741 if (rc < 0) { 742 dev_err(dev, "Failed to read led-max-microamp property, rc=%d\n", rc); 743 return rc; 744 } 745 746 if (current_ua == 0) { 747 dev_err(dev, "led-max-microamp shouldn't be 0\n"); 748 return -EINVAL; 749 } 750 751 current_ua = min_t(u32, current_ua, TORCH_CURRENT_MAX_UA * led->chan_count); 752 led->max_torch_current_ma = current_ua / UA_PER_MA; 753 754 if (fwnode_property_present(node, "flash-max-microamp")) { 755 flash->led_cdev.flags |= LED_DEV_CAP_FLASH; 756 757 rc = fwnode_property_read_u32(node, "flash-max-microamp", ¤t_ua); 758 if (rc < 0) { 759 dev_err(dev, "Failed to read flash-max-microamp property, rc=%d\n", 760 rc); 761 return rc; 762 } 763 764 current_ua = min_t(u32, current_ua, FLASH_CURRENT_MAX_UA * led->chan_count); 765 current_ua = min_t(u32, current_ua, FLASH_TOTAL_CURRENT_MAX_UA); 766 767 /* Initialize flash class LED device brightness settings */ 768 brightness = &flash->brightness; 769 brightness->min = brightness->step = FLASH_IRES_UA * led->chan_count; 770 brightness->max = current_ua; 771 brightness->val = min_t(u32, current_ua, FLASH_CURRENT_DEFAULT_UA); 772 773 led->max_flash_current_ma = current_ua / UA_PER_MA; 774 led->flash_current_ma = brightness->val / UA_PER_MA; 775 776 rc = fwnode_property_read_u32(node, "flash-max-timeout-us", &timeout_us); 777 if (rc < 0) { 778 dev_err(dev, "Failed to read flash-max-timeout-us property, rc=%d\n", 779 rc); 780 return rc; 781 } 782 783 timeout_us = min_t(u32, timeout_us, FLASH_TIMEOUT_MAX_US); 784 785 /* Initialize flash class LED device timeout settings */ 786 timeout = &flash->timeout; 787 timeout->min = timeout->step = FLASH_TIMEOUT_STEP_US; 788 timeout->val = timeout->max = timeout_us; 789 790 led->max_timeout_ms = led->flash_timeout_ms = timeout_us / USEC_PER_MSEC; 791 792 flash->ops = &qcom_flash_ops; 793 } 794 795 flash->led_cdev.brightness_set_blocking = qcom_flash_led_brightness_set; 796 797 init_data.fwnode = node; 798 init_data.devicename = NULL; 799 init_data.default_label = NULL; 800 init_data.devname_mandatory = false; 801 802 rc = devm_led_classdev_flash_register_ext(dev, flash, &init_data); 803 if (rc < 0) { 804 dev_err(dev, "Register flash LED classdev failed, rc=%d\n", rc); 805 return rc; 806 } 807 808 return qcom_flash_v4l2_init(dev, led, node); 809 } 810 811 static int qcom_flash_led_probe(struct platform_device *pdev) 812 { 813 struct qcom_flash_data *flash_data; 814 struct qcom_flash_led *led; 815 struct device *dev = &pdev->dev; 816 struct regmap *regmap; 817 struct reg_field *regs; 818 int count, i, rc; 819 u32 val, reg_base; 820 821 flash_data = devm_kzalloc(dev, sizeof(*flash_data), GFP_KERNEL); 822 if (!flash_data) 823 return -ENOMEM; 824 825 regmap = dev_get_regmap(dev->parent, NULL); 826 if (!regmap) { 827 dev_err(dev, "Failed to get parent regmap\n"); 828 return -EINVAL; 829 } 830 831 rc = fwnode_property_read_u32(dev->fwnode, "reg", ®_base); 832 if (rc < 0) { 833 dev_err(dev, "Failed to get register base address, rc=%d\n", rc); 834 return rc; 835 } 836 837 rc = regmap_read(regmap, reg_base + FLASH_TYPE_REG, &val); 838 if (rc < 0) { 839 dev_err(dev, "Read flash LED module type failed, rc=%d\n", rc); 840 return rc; 841 } 842 843 if (val != FLASH_TYPE_VAL) { 844 dev_err(dev, "type %#x is not a flash LED module\n", val); 845 return -ENODEV; 846 } 847 848 rc = regmap_read(regmap, reg_base + FLASH_SUBTYPE_REG, &val); 849 if (rc < 0) { 850 dev_err(dev, "Read flash LED module subtype failed, rc=%d\n", rc); 851 return rc; 852 } 853 854 if (val == FLASH_SUBTYPE_3CH_PM8150_VAL || val == FLASH_SUBTYPE_3CH_PMI8998_VAL) { 855 flash_data->hw_type = QCOM_MVFLASH_3CH; 856 flash_data->max_channels = 3; 857 regs = mvflash_3ch_regs; 858 } else if (val == FLASH_SUBTYPE_4CH_VAL) { 859 flash_data->hw_type = QCOM_MVFLASH_4CH; 860 flash_data->max_channels = 4; 861 regs = mvflash_4ch_regs; 862 863 rc = regmap_read(regmap, reg_base + FLASH_REVISION_REG, &val); 864 if (rc < 0) { 865 dev_err(dev, "Failed to read flash LED module revision, rc=%d\n", rc); 866 return rc; 867 } 868 869 flash_data->revision = val; 870 } else { 871 dev_err(dev, "flash LED subtype %#x is not yet supported\n", val); 872 return -ENODEV; 873 } 874 875 for (i = 0; i < REG_MAX_COUNT; i++) 876 regs[i].reg += reg_base; 877 878 rc = devm_regmap_field_bulk_alloc(dev, regmap, flash_data->r_fields, regs, REG_MAX_COUNT); 879 if (rc < 0) { 880 dev_err(dev, "Failed to allocate regmap field, rc=%d\n", rc); 881 return rc; 882 } 883 884 platform_set_drvdata(pdev, flash_data); 885 mutex_init(&flash_data->lock); 886 887 count = device_get_child_node_count(dev); 888 if (count == 0 || count > flash_data->max_channels) { 889 dev_err(dev, "No child or child count exceeds %d\n", flash_data->max_channels); 890 return -EINVAL; 891 } 892 893 flash_data->v4l2_flash = devm_kcalloc(dev, count, 894 sizeof(*flash_data->v4l2_flash), GFP_KERNEL); 895 if (!flash_data->v4l2_flash) 896 return -ENOMEM; 897 898 device_for_each_child_node_scoped(dev, child) { 899 led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL); 900 if (!led) { 901 rc = -ENOMEM; 902 goto release; 903 } 904 905 led->flash_data = flash_data; 906 rc = qcom_flash_register_led_device(dev, child, led); 907 if (rc < 0) 908 goto release; 909 910 flash_data->leds_count++; 911 } 912 913 return 0; 914 915 release: 916 while (flash_data->v4l2_flash[flash_data->leds_count] && flash_data->leds_count) 917 v4l2_flash_release(flash_data->v4l2_flash[flash_data->leds_count--]); 918 return rc; 919 } 920 921 static void qcom_flash_led_remove(struct platform_device *pdev) 922 { 923 struct qcom_flash_data *flash_data = platform_get_drvdata(pdev); 924 925 while (flash_data->v4l2_flash[flash_data->leds_count] && flash_data->leds_count) 926 v4l2_flash_release(flash_data->v4l2_flash[flash_data->leds_count--]); 927 928 mutex_destroy(&flash_data->lock); 929 } 930 931 static const struct of_device_id qcom_flash_led_match_table[] = { 932 { .compatible = "qcom,spmi-flash-led" }, 933 { } 934 }; 935 936 MODULE_DEVICE_TABLE(of, qcom_flash_led_match_table); 937 static struct platform_driver qcom_flash_led_driver = { 938 .driver = { 939 .name = "leds-qcom-flash", 940 .of_match_table = qcom_flash_led_match_table, 941 }, 942 .probe = qcom_flash_led_probe, 943 .remove = qcom_flash_led_remove, 944 }; 945 946 module_platform_driver(qcom_flash_led_driver); 947 948 MODULE_DESCRIPTION("QCOM Flash LED driver"); 949 MODULE_LICENSE("GPL"); 950