1 /* 2 * linux/drivers/video/backlight/pwm_bl.c 3 * 4 * simple PWM based backlight control, board code has to setup 5 * 1) pin configuration so PWM waveforms can output 6 * 2) platform_data being correctly configured 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/gpio/consumer.h> 14 #include <linux/gpio.h> 15 #include <linux/module.h> 16 #include <linux/kernel.h> 17 #include <linux/init.h> 18 #include <linux/platform_device.h> 19 #include <linux/fb.h> 20 #include <linux/backlight.h> 21 #include <linux/err.h> 22 #include <linux/pwm.h> 23 #include <linux/pwm_backlight.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/slab.h> 26 27 struct pwm_bl_data { 28 struct pwm_device *pwm; 29 struct device *dev; 30 unsigned int period; 31 unsigned int lth_brightness; 32 unsigned int *levels; 33 bool enabled; 34 struct regulator *power_supply; 35 struct gpio_desc *enable_gpio; 36 unsigned int scale; 37 bool legacy; 38 int (*notify)(struct device *, 39 int brightness); 40 void (*notify_after)(struct device *, 41 int brightness); 42 int (*check_fb)(struct device *, struct fb_info *); 43 void (*exit)(struct device *); 44 }; 45 46 static void pwm_backlight_power_on(struct pwm_bl_data *pb, int brightness) 47 { 48 int err; 49 50 if (pb->enabled) 51 return; 52 53 err = regulator_enable(pb->power_supply); 54 if (err < 0) 55 dev_err(pb->dev, "failed to enable power supply\n"); 56 57 if (pb->enable_gpio) 58 gpiod_set_value(pb->enable_gpio, 1); 59 60 pwm_enable(pb->pwm); 61 pb->enabled = true; 62 } 63 64 static void pwm_backlight_power_off(struct pwm_bl_data *pb) 65 { 66 if (!pb->enabled) 67 return; 68 69 pwm_config(pb->pwm, 0, pb->period); 70 pwm_disable(pb->pwm); 71 72 if (pb->enable_gpio) 73 gpiod_set_value(pb->enable_gpio, 0); 74 75 regulator_disable(pb->power_supply); 76 pb->enabled = false; 77 } 78 79 static int compute_duty_cycle(struct pwm_bl_data *pb, int brightness) 80 { 81 unsigned int lth = pb->lth_brightness; 82 int duty_cycle; 83 84 if (pb->levels) 85 duty_cycle = pb->levels[brightness]; 86 else 87 duty_cycle = brightness; 88 89 return (duty_cycle * (pb->period - lth) / pb->scale) + lth; 90 } 91 92 static int pwm_backlight_update_status(struct backlight_device *bl) 93 { 94 struct pwm_bl_data *pb = bl_get_data(bl); 95 int brightness = bl->props.brightness; 96 int duty_cycle; 97 98 if (bl->props.power != FB_BLANK_UNBLANK || 99 bl->props.fb_blank != FB_BLANK_UNBLANK || 100 bl->props.state & BL_CORE_FBBLANK) 101 brightness = 0; 102 103 if (pb->notify) 104 brightness = pb->notify(pb->dev, brightness); 105 106 if (brightness > 0) { 107 duty_cycle = compute_duty_cycle(pb, brightness); 108 pwm_config(pb->pwm, duty_cycle, pb->period); 109 pwm_backlight_power_on(pb, brightness); 110 } else 111 pwm_backlight_power_off(pb); 112 113 if (pb->notify_after) 114 pb->notify_after(pb->dev, brightness); 115 116 return 0; 117 } 118 119 static int pwm_backlight_check_fb(struct backlight_device *bl, 120 struct fb_info *info) 121 { 122 struct pwm_bl_data *pb = bl_get_data(bl); 123 124 return !pb->check_fb || pb->check_fb(pb->dev, info); 125 } 126 127 static const struct backlight_ops pwm_backlight_ops = { 128 .update_status = pwm_backlight_update_status, 129 .check_fb = pwm_backlight_check_fb, 130 }; 131 132 #ifdef CONFIG_OF 133 static int pwm_backlight_parse_dt(struct device *dev, 134 struct platform_pwm_backlight_data *data) 135 { 136 struct device_node *node = dev->of_node; 137 struct property *prop; 138 int length; 139 u32 value; 140 int ret; 141 142 if (!node) 143 return -ENODEV; 144 145 memset(data, 0, sizeof(*data)); 146 147 /* determine the number of brightness levels */ 148 prop = of_find_property(node, "brightness-levels", &length); 149 if (!prop) 150 return -EINVAL; 151 152 data->max_brightness = length / sizeof(u32); 153 154 /* read brightness levels from DT property */ 155 if (data->max_brightness > 0) { 156 size_t size = sizeof(*data->levels) * data->max_brightness; 157 158 data->levels = devm_kzalloc(dev, size, GFP_KERNEL); 159 if (!data->levels) 160 return -ENOMEM; 161 162 ret = of_property_read_u32_array(node, "brightness-levels", 163 data->levels, 164 data->max_brightness); 165 if (ret < 0) 166 return ret; 167 168 ret = of_property_read_u32(node, "default-brightness-level", 169 &value); 170 if (ret < 0) 171 return ret; 172 173 data->dft_brightness = value; 174 data->max_brightness--; 175 } 176 177 data->enable_gpio = -EINVAL; 178 return 0; 179 } 180 181 static struct of_device_id pwm_backlight_of_match[] = { 182 { .compatible = "pwm-backlight" }, 183 { } 184 }; 185 186 MODULE_DEVICE_TABLE(of, pwm_backlight_of_match); 187 #else 188 static int pwm_backlight_parse_dt(struct device *dev, 189 struct platform_pwm_backlight_data *data) 190 { 191 return -ENODEV; 192 } 193 #endif 194 195 static int pwm_backlight_probe(struct platform_device *pdev) 196 { 197 struct platform_pwm_backlight_data *data = dev_get_platdata(&pdev->dev); 198 struct platform_pwm_backlight_data defdata; 199 struct backlight_properties props; 200 struct backlight_device *bl; 201 struct device_node *node = pdev->dev.of_node; 202 struct pwm_bl_data *pb; 203 int initial_blank = FB_BLANK_UNBLANK; 204 struct pwm_args pargs; 205 int ret; 206 207 if (!data) { 208 ret = pwm_backlight_parse_dt(&pdev->dev, &defdata); 209 if (ret < 0) { 210 dev_err(&pdev->dev, "failed to find platform data\n"); 211 return ret; 212 } 213 214 data = &defdata; 215 } 216 217 if (data->init) { 218 ret = data->init(&pdev->dev); 219 if (ret < 0) 220 return ret; 221 } 222 223 pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL); 224 if (!pb) { 225 ret = -ENOMEM; 226 goto err_alloc; 227 } 228 229 if (data->levels) { 230 unsigned int i; 231 232 for (i = 0; i <= data->max_brightness; i++) 233 if (data->levels[i] > pb->scale) 234 pb->scale = data->levels[i]; 235 236 pb->levels = data->levels; 237 } else 238 pb->scale = data->max_brightness; 239 240 pb->notify = data->notify; 241 pb->notify_after = data->notify_after; 242 pb->check_fb = data->check_fb; 243 pb->exit = data->exit; 244 pb->dev = &pdev->dev; 245 pb->enabled = false; 246 247 pb->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable", 248 GPIOD_ASIS); 249 if (IS_ERR(pb->enable_gpio)) { 250 ret = PTR_ERR(pb->enable_gpio); 251 goto err_alloc; 252 } 253 254 /* 255 * Compatibility fallback for drivers still using the integer GPIO 256 * platform data. Must go away soon. 257 */ 258 if (!pb->enable_gpio && gpio_is_valid(data->enable_gpio)) { 259 ret = devm_gpio_request_one(&pdev->dev, data->enable_gpio, 260 GPIOF_OUT_INIT_HIGH, "enable"); 261 if (ret < 0) { 262 dev_err(&pdev->dev, "failed to request GPIO#%d: %d\n", 263 data->enable_gpio, ret); 264 goto err_alloc; 265 } 266 267 pb->enable_gpio = gpio_to_desc(data->enable_gpio); 268 } 269 270 if (pb->enable_gpio) { 271 /* 272 * If the driver is probed from the device tree and there is a 273 * phandle link pointing to the backlight node, it is safe to 274 * assume that another driver will enable the backlight at the 275 * appropriate time. Therefore, if it is disabled, keep it so. 276 */ 277 if (node && node->phandle && 278 gpiod_get_direction(pb->enable_gpio) == GPIOF_DIR_OUT && 279 gpiod_get_value(pb->enable_gpio) == 0) 280 initial_blank = FB_BLANK_POWERDOWN; 281 else 282 gpiod_direction_output(pb->enable_gpio, 1); 283 } 284 285 pb->power_supply = devm_regulator_get(&pdev->dev, "power"); 286 if (IS_ERR(pb->power_supply)) { 287 ret = PTR_ERR(pb->power_supply); 288 goto err_alloc; 289 } 290 291 if (node && node->phandle && !regulator_is_enabled(pb->power_supply)) 292 initial_blank = FB_BLANK_POWERDOWN; 293 294 pb->pwm = devm_pwm_get(&pdev->dev, NULL); 295 if (IS_ERR(pb->pwm) && PTR_ERR(pb->pwm) != -EPROBE_DEFER && !node) { 296 dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n"); 297 pb->legacy = true; 298 pb->pwm = pwm_request(data->pwm_id, "pwm-backlight"); 299 } 300 301 if (IS_ERR(pb->pwm)) { 302 ret = PTR_ERR(pb->pwm); 303 if (ret != -EPROBE_DEFER) 304 dev_err(&pdev->dev, "unable to request PWM\n"); 305 goto err_alloc; 306 } 307 308 dev_dbg(&pdev->dev, "got pwm for backlight\n"); 309 310 /* 311 * FIXME: pwm_apply_args() should be removed when switching to 312 * the atomic PWM API. 313 */ 314 pwm_apply_args(pb->pwm); 315 316 /* 317 * The DT case will set the pwm_period_ns field to 0 and store the 318 * period, parsed from the DT, in the PWM device. For the non-DT case, 319 * set the period from platform data if it has not already been set 320 * via the PWM lookup table. 321 */ 322 pwm_get_args(pb->pwm, &pargs); 323 pb->period = pargs.period; 324 if (!pb->period && (data->pwm_period_ns > 0)) 325 pb->period = data->pwm_period_ns; 326 327 pb->lth_brightness = data->lth_brightness * (pb->period / pb->scale); 328 329 memset(&props, 0, sizeof(struct backlight_properties)); 330 props.type = BACKLIGHT_RAW; 331 props.max_brightness = data->max_brightness; 332 bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb, 333 &pwm_backlight_ops, &props); 334 if (IS_ERR(bl)) { 335 dev_err(&pdev->dev, "failed to register backlight\n"); 336 ret = PTR_ERR(bl); 337 if (pb->legacy) 338 pwm_free(pb->pwm); 339 goto err_alloc; 340 } 341 342 if (data->dft_brightness > data->max_brightness) { 343 dev_warn(&pdev->dev, 344 "invalid default brightness level: %u, using %u\n", 345 data->dft_brightness, data->max_brightness); 346 data->dft_brightness = data->max_brightness; 347 } 348 349 bl->props.brightness = data->dft_brightness; 350 bl->props.power = initial_blank; 351 backlight_update_status(bl); 352 353 platform_set_drvdata(pdev, bl); 354 return 0; 355 356 err_alloc: 357 if (data->exit) 358 data->exit(&pdev->dev); 359 return ret; 360 } 361 362 static int pwm_backlight_remove(struct platform_device *pdev) 363 { 364 struct backlight_device *bl = platform_get_drvdata(pdev); 365 struct pwm_bl_data *pb = bl_get_data(bl); 366 367 backlight_device_unregister(bl); 368 pwm_backlight_power_off(pb); 369 370 if (pb->exit) 371 pb->exit(&pdev->dev); 372 if (pb->legacy) 373 pwm_free(pb->pwm); 374 375 return 0; 376 } 377 378 static void pwm_backlight_shutdown(struct platform_device *pdev) 379 { 380 struct backlight_device *bl = platform_get_drvdata(pdev); 381 struct pwm_bl_data *pb = bl_get_data(bl); 382 383 pwm_backlight_power_off(pb); 384 } 385 386 #ifdef CONFIG_PM_SLEEP 387 static int pwm_backlight_suspend(struct device *dev) 388 { 389 struct backlight_device *bl = dev_get_drvdata(dev); 390 struct pwm_bl_data *pb = bl_get_data(bl); 391 392 if (pb->notify) 393 pb->notify(pb->dev, 0); 394 395 pwm_backlight_power_off(pb); 396 397 if (pb->notify_after) 398 pb->notify_after(pb->dev, 0); 399 400 return 0; 401 } 402 403 static int pwm_backlight_resume(struct device *dev) 404 { 405 struct backlight_device *bl = dev_get_drvdata(dev); 406 407 backlight_update_status(bl); 408 409 return 0; 410 } 411 #endif 412 413 static const struct dev_pm_ops pwm_backlight_pm_ops = { 414 #ifdef CONFIG_PM_SLEEP 415 .suspend = pwm_backlight_suspend, 416 .resume = pwm_backlight_resume, 417 .poweroff = pwm_backlight_suspend, 418 .restore = pwm_backlight_resume, 419 #endif 420 }; 421 422 static struct platform_driver pwm_backlight_driver = { 423 .driver = { 424 .name = "pwm-backlight", 425 .pm = &pwm_backlight_pm_ops, 426 .of_match_table = of_match_ptr(pwm_backlight_of_match), 427 }, 428 .probe = pwm_backlight_probe, 429 .remove = pwm_backlight_remove, 430 .shutdown = pwm_backlight_shutdown, 431 }; 432 433 module_platform_driver(pwm_backlight_driver); 434 435 MODULE_DESCRIPTION("PWM based Backlight Driver"); 436 MODULE_LICENSE("GPL"); 437 MODULE_ALIAS("platform:pwm-backlight"); 438