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