1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * LED driver for Richtek RT8515 flash/torch white LEDs 4 * found on some Samsung mobile phones. 5 * 6 * This is a 1.5A Boost dual channel driver produced around 2011. 7 * 8 * The component lacks a datasheet, but in the schematic picture 9 * from the LG P970 service manual you can see the connections 10 * from the RT8515 to the LED, with two resistors connected 11 * from the pins "RFS" and "RTS" to ground. 12 * 13 * On the LG P970: 14 * RFS (resistance flash setting?) is 20 kOhm 15 * RTS (resistance torch setting?) is 39 kOhm 16 * 17 * Some sleuthing finds us the RT9387A which we have a datasheet for: 18 * https://static5.arrow.com/pdfs/2014/7/27/8/21/12/794/rtt_/manual/94download_ds.jspprt9387a.jspprt9387a.pdf 19 * This apparently works the same way so in theory this driver 20 * should cover RT9387A as well. This has not been tested, please 21 * update the compatibles if you add RT9387A support. 22 * 23 * Linus Walleij <linus.walleij@linaro.org> 24 */ 25 #include <linux/delay.h> 26 #include <linux/err.h> 27 #include <linux/gpio/consumer.h> 28 #include <linux/led-class-flash.h> 29 #include <linux/mod_devicetable.h> 30 #include <linux/module.h> 31 #include <linux/platform_device.h> 32 #include <linux/property.h> 33 #include <linux/regulator/consumer.h> 34 35 #include <media/v4l2-flash-led-class.h> 36 37 /* We can provide 15-700 mA out to the LED */ 38 #define RT8515_MIN_IOUT_MA 15 39 #define RT8515_MAX_IOUT_MA 700 40 /* The maximum intensity is 1-16 for flash and 1-100 for torch */ 41 #define RT8515_FLASH_MAX 16 42 #define RT8515_TORCH_MAX 100 43 44 #define RT8515_TIMEOUT_US 250000U 45 #define RT8515_MAX_TIMEOUT_US 300000U 46 47 struct rt8515 { 48 struct led_classdev_flash fled; 49 struct device *dev; 50 struct v4l2_flash *v4l2_flash; 51 struct mutex lock; 52 struct regulator *reg; 53 struct gpio_desc *enable_torch; 54 struct gpio_desc *enable_flash; 55 struct timer_list powerdown_timer; 56 u32 max_timeout; /* Flash max timeout */ 57 int flash_max_intensity; 58 int torch_max_intensity; 59 }; 60 61 static struct rt8515 *to_rt8515(struct led_classdev_flash *fled) 62 { 63 return container_of(fled, struct rt8515, fled); 64 } 65 66 static void rt8515_gpio_led_off(struct rt8515 *rt) 67 { 68 gpiod_set_value(rt->enable_flash, 0); 69 gpiod_set_value(rt->enable_torch, 0); 70 } 71 72 static void rt8515_gpio_brightness_commit(struct gpio_desc *gpiod, 73 int brightness) 74 { 75 int i; 76 77 /* 78 * Toggling a GPIO line with a small delay increases the 79 * brightness one step at a time. 80 */ 81 for (i = 0; i < brightness; i++) { 82 gpiod_set_value(gpiod, 0); 83 udelay(1); 84 gpiod_set_value(gpiod, 1); 85 udelay(1); 86 } 87 } 88 89 /* This is setting the torch light level */ 90 static int rt8515_led_brightness_set(struct led_classdev *led, 91 enum led_brightness brightness) 92 { 93 struct led_classdev_flash *fled = lcdev_to_flcdev(led); 94 struct rt8515 *rt = to_rt8515(fled); 95 96 mutex_lock(&rt->lock); 97 98 if (brightness == LED_OFF) { 99 /* Off */ 100 rt8515_gpio_led_off(rt); 101 } else if (brightness < RT8515_TORCH_MAX) { 102 /* Step it up to movie mode brightness using the flash pin */ 103 rt8515_gpio_brightness_commit(rt->enable_torch, brightness); 104 } else { 105 /* Max torch brightness requested */ 106 gpiod_set_value(rt->enable_torch, 1); 107 } 108 109 mutex_unlock(&rt->lock); 110 111 return 0; 112 } 113 114 static int rt8515_led_flash_strobe_set(struct led_classdev_flash *fled, 115 bool state) 116 { 117 struct rt8515 *rt = to_rt8515(fled); 118 struct led_flash_setting *timeout = &fled->timeout; 119 int brightness = rt->flash_max_intensity; 120 121 mutex_lock(&rt->lock); 122 123 if (state) { 124 /* Enable LED flash mode and set brightness */ 125 rt8515_gpio_brightness_commit(rt->enable_flash, brightness); 126 /* Set timeout */ 127 mod_timer(&rt->powerdown_timer, 128 jiffies + usecs_to_jiffies(timeout->val)); 129 } else { 130 del_timer_sync(&rt->powerdown_timer); 131 /* Turn the LED off */ 132 rt8515_gpio_led_off(rt); 133 } 134 135 fled->led_cdev.brightness = LED_OFF; 136 /* After this the torch LED will be disabled */ 137 138 mutex_unlock(&rt->lock); 139 140 return 0; 141 } 142 143 static int rt8515_led_flash_strobe_get(struct led_classdev_flash *fled, 144 bool *state) 145 { 146 struct rt8515 *rt = to_rt8515(fled); 147 148 *state = timer_pending(&rt->powerdown_timer); 149 150 return 0; 151 } 152 153 static int rt8515_led_flash_timeout_set(struct led_classdev_flash *fled, 154 u32 timeout) 155 { 156 /* The timeout is stored in the led-class-flash core */ 157 return 0; 158 } 159 160 static const struct led_flash_ops rt8515_flash_ops = { 161 .strobe_set = rt8515_led_flash_strobe_set, 162 .strobe_get = rt8515_led_flash_strobe_get, 163 .timeout_set = rt8515_led_flash_timeout_set, 164 }; 165 166 static void rt8515_powerdown_timer(struct timer_list *t) 167 { 168 struct rt8515 *rt = from_timer(rt, t, powerdown_timer); 169 170 /* Turn the LED off */ 171 rt8515_gpio_led_off(rt); 172 } 173 174 static void rt8515_init_flash_timeout(struct rt8515 *rt) 175 { 176 struct led_classdev_flash *fled = &rt->fled; 177 struct led_flash_setting *s; 178 179 /* Init flash timeout setting */ 180 s = &fled->timeout; 181 s->min = 1; 182 s->max = rt->max_timeout; 183 s->step = 1; 184 /* 185 * Set default timeout to RT8515_TIMEOUT_US except if 186 * max_timeout from DT is lower. 187 */ 188 s->val = min(rt->max_timeout, RT8515_TIMEOUT_US); 189 } 190 191 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) 192 /* Configure the V2L2 flash subdevice */ 193 static void rt8515_init_v4l2_flash_config(struct rt8515 *rt, 194 struct v4l2_flash_config *v4l2_sd_cfg) 195 { 196 struct led_classdev *led = &rt->fled.led_cdev; 197 struct led_flash_setting *s; 198 199 strscpy(v4l2_sd_cfg->dev_name, led->dev->kobj.name, 200 sizeof(v4l2_sd_cfg->dev_name)); 201 202 /* 203 * Init flash intensity setting: this is a linear scale 204 * capped from the device tree max intensity setting 205 * 1..flash_max_intensity 206 */ 207 s = &v4l2_sd_cfg->intensity; 208 s->min = 1; 209 s->max = rt->flash_max_intensity; 210 s->step = 1; 211 s->val = s->max; 212 } 213 214 static void rt8515_v4l2_flash_release(struct rt8515 *rt) 215 { 216 v4l2_flash_release(rt->v4l2_flash); 217 } 218 219 #else 220 static void rt8515_init_v4l2_flash_config(struct rt8515 *rt, 221 struct v4l2_flash_config *v4l2_sd_cfg) 222 { 223 } 224 225 static void rt8515_v4l2_flash_release(struct rt8515 *rt) 226 { 227 } 228 #endif 229 230 static void rt8515_determine_max_intensity(struct rt8515 *rt, 231 struct fwnode_handle *led, 232 const char *resistance, 233 const char *max_ua_prop, int hw_max, 234 int *max_intensity_setting) 235 { 236 u32 res = 0; /* Can't be 0 so 0 is undefined */ 237 u32 ua; 238 u32 max_ma; 239 int max_intensity; 240 int ret; 241 242 fwnode_property_read_u32(rt->dev->fwnode, resistance, &res); 243 ret = fwnode_property_read_u32(led, max_ua_prop, &ua); 244 245 /* Missing info in DT, OK go with hardware maxima */ 246 if (ret || res == 0) { 247 dev_err(rt->dev, 248 "either %s or %s missing from DT, using HW max\n", 249 resistance, max_ua_prop); 250 max_ma = RT8515_MAX_IOUT_MA; 251 max_intensity = hw_max; 252 goto out_assign_max; 253 } 254 255 /* 256 * Formula from the datasheet, this is the maximum current 257 * defined by the hardware. 258 */ 259 max_ma = (5500 * 1000) / res; 260 /* 261 * Calculate max intensity (linear scaling) 262 * Formula is ((ua / 1000) / max_ma) * 100, then simplified 263 */ 264 max_intensity = (ua / 10) / max_ma; 265 266 dev_info(rt->dev, 267 "current restricted from %u to %u mA, max intensity %d/100\n", 268 max_ma, (ua / 1000), max_intensity); 269 270 out_assign_max: 271 dev_info(rt->dev, "max intensity %d/%d = %d mA\n", 272 max_intensity, hw_max, max_ma); 273 *max_intensity_setting = max_intensity; 274 } 275 276 static int rt8515_probe(struct platform_device *pdev) 277 { 278 struct device *dev = &pdev->dev; 279 struct fwnode_handle *child; 280 struct rt8515 *rt; 281 struct led_classdev *led; 282 struct led_classdev_flash *fled; 283 struct led_init_data init_data = {}; 284 struct v4l2_flash_config v4l2_sd_cfg = {}; 285 int ret; 286 287 rt = devm_kzalloc(dev, sizeof(*rt), GFP_KERNEL); 288 if (!rt) 289 return -ENOMEM; 290 291 rt->dev = dev; 292 fled = &rt->fled; 293 led = &fled->led_cdev; 294 295 /* ENF - Enable Flash line */ 296 rt->enable_flash = devm_gpiod_get(dev, "enf", GPIOD_OUT_LOW); 297 if (IS_ERR(rt->enable_flash)) 298 return dev_err_probe(dev, PTR_ERR(rt->enable_flash), 299 "cannot get ENF (enable flash) GPIO\n"); 300 301 /* ENT - Enable Torch line */ 302 rt->enable_torch = devm_gpiod_get(dev, "ent", GPIOD_OUT_LOW); 303 if (IS_ERR(rt->enable_torch)) 304 return dev_err_probe(dev, PTR_ERR(rt->enable_torch), 305 "cannot get ENT (enable torch) GPIO\n"); 306 307 child = fwnode_get_next_available_child_node(dev->fwnode, NULL); 308 if (!child) { 309 dev_err(dev, 310 "No fwnode child node found for connected LED.\n"); 311 return -EINVAL; 312 } 313 init_data.fwnode = child; 314 315 rt8515_determine_max_intensity(rt, child, "richtek,rfs-ohms", 316 "flash-max-microamp", 317 RT8515_FLASH_MAX, 318 &rt->flash_max_intensity); 319 rt8515_determine_max_intensity(rt, child, "richtek,rts-ohms", 320 "led-max-microamp", 321 RT8515_TORCH_MAX, 322 &rt->torch_max_intensity); 323 324 ret = fwnode_property_read_u32(child, "flash-max-timeout-us", 325 &rt->max_timeout); 326 if (ret) { 327 rt->max_timeout = RT8515_MAX_TIMEOUT_US; 328 dev_warn(dev, 329 "flash-max-timeout-us property missing\n"); 330 } 331 timer_setup(&rt->powerdown_timer, rt8515_powerdown_timer, 0); 332 rt8515_init_flash_timeout(rt); 333 334 fled->ops = &rt8515_flash_ops; 335 336 led->max_brightness = rt->torch_max_intensity; 337 led->brightness_set_blocking = rt8515_led_brightness_set; 338 led->flags |= LED_CORE_SUSPENDRESUME | LED_DEV_CAP_FLASH; 339 340 mutex_init(&rt->lock); 341 342 platform_set_drvdata(pdev, rt); 343 344 ret = devm_led_classdev_flash_register_ext(dev, fled, &init_data); 345 if (ret) { 346 dev_err(dev, "can't register LED %s\n", led->name); 347 mutex_destroy(&rt->lock); 348 return ret; 349 } 350 351 rt8515_init_v4l2_flash_config(rt, &v4l2_sd_cfg); 352 353 /* Create a V4L2 Flash device if V4L2 flash is enabled */ 354 rt->v4l2_flash = v4l2_flash_init(dev, child, fled, NULL, &v4l2_sd_cfg); 355 if (IS_ERR(rt->v4l2_flash)) { 356 ret = PTR_ERR(rt->v4l2_flash); 357 dev_err(dev, "failed to register V4L2 flash device (%d)\n", 358 ret); 359 /* 360 * Continue without the V4L2 flash 361 * (we still have the classdev) 362 */ 363 } 364 365 return 0; 366 } 367 368 static int rt8515_remove(struct platform_device *pdev) 369 { 370 struct rt8515 *rt = platform_get_drvdata(pdev); 371 372 rt8515_v4l2_flash_release(rt); 373 del_timer_sync(&rt->powerdown_timer); 374 mutex_destroy(&rt->lock); 375 376 return 0; 377 } 378 379 static const struct of_device_id rt8515_match[] = { 380 { .compatible = "richtek,rt8515", }, 381 { /* sentinel */ } 382 }; 383 MODULE_DEVICE_TABLE(of, rt8515_match); 384 385 static struct platform_driver rt8515_driver = { 386 .driver = { 387 .name = "rt8515", 388 .of_match_table = rt8515_match, 389 }, 390 .probe = rt8515_probe, 391 .remove = rt8515_remove, 392 }; 393 module_platform_driver(rt8515_driver); 394 395 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>"); 396 MODULE_DESCRIPTION("Richtek RT8515 LED driver"); 397 MODULE_LICENSE("GPL"); 398