2 * linux/drivers/video/backlight/pwm_bl.c
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
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.
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>
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>
28 struct pwm_device
*pwm
;
31 unsigned int lth_brightness
;
34 struct regulator
*power_supply
;
35 struct gpio_desc
*enable_gpio
;
38 int (*notify
)(struct device
*,
40 void (*notify_after
)(struct device
*,
42 int (*check_fb
)(struct device
*, struct fb_info
*);
43 void (*exit
)(struct device
*);
46 static void pwm_backlight_power_on(struct pwm_bl_data
*pb
, int brightness
)
53 err
= regulator_enable(pb
->power_supply
);
55 dev_err(pb
->dev
, "failed to enable power supply\n");
58 gpiod_set_value_cansleep(pb
->enable_gpio
, 1);
64 static void pwm_backlight_power_off(struct pwm_bl_data
*pb
)
69 pwm_config(pb
->pwm
, 0, pb
->period
);
73 gpiod_set_value_cansleep(pb
->enable_gpio
, 0);
75 regulator_disable(pb
->power_supply
);
79 static int compute_duty_cycle(struct pwm_bl_data
*pb
, int brightness
)
81 unsigned int lth
= pb
->lth_brightness
;
85 duty_cycle
= pb
->levels
[brightness
];
87 duty_cycle
= brightness
;
89 return (duty_cycle
* (pb
->period
- lth
) / pb
->scale
) + lth
;
92 static int pwm_backlight_update_status(struct backlight_device
*bl
)
94 struct pwm_bl_data
*pb
= bl_get_data(bl
);
95 int brightness
= bl
->props
.brightness
;
98 if (bl
->props
.power
!= FB_BLANK_UNBLANK
||
99 bl
->props
.fb_blank
!= FB_BLANK_UNBLANK
||
100 bl
->props
.state
& BL_CORE_FBBLANK
)
104 brightness
= pb
->notify(pb
->dev
, brightness
);
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
);
111 pwm_backlight_power_off(pb
);
113 if (pb
->notify_after
)
114 pb
->notify_after(pb
->dev
, brightness
);
119 static int pwm_backlight_check_fb(struct backlight_device
*bl
,
120 struct fb_info
*info
)
122 struct pwm_bl_data
*pb
= bl_get_data(bl
);
124 return !pb
->check_fb
|| pb
->check_fb(pb
->dev
, info
);
127 static const struct backlight_ops pwm_backlight_ops
= {
128 .update_status
= pwm_backlight_update_status
,
129 .check_fb
= pwm_backlight_check_fb
,
133 static int pwm_backlight_parse_dt(struct device
*dev
,
134 struct platform_pwm_backlight_data
*data
)
136 struct device_node
*node
= dev
->of_node
;
137 struct property
*prop
;
145 memset(data
, 0, sizeof(*data
));
147 /* determine the number of brightness levels */
148 prop
= of_find_property(node
, "brightness-levels", &length
);
152 data
->max_brightness
= length
/ sizeof(u32
);
154 /* read brightness levels from DT property */
155 if (data
->max_brightness
> 0) {
156 size_t size
= sizeof(*data
->levels
) * data
->max_brightness
;
158 data
->levels
= devm_kzalloc(dev
, size
, GFP_KERNEL
);
162 ret
= of_property_read_u32_array(node
, "brightness-levels",
164 data
->max_brightness
);
168 ret
= of_property_read_u32(node
, "default-brightness-level",
173 data
->dft_brightness
= value
;
174 data
->max_brightness
--;
177 data
->enable_gpio
= -EINVAL
;
181 static struct of_device_id pwm_backlight_of_match
[] = {
182 { .compatible
= "pwm-backlight" },
186 MODULE_DEVICE_TABLE(of
, pwm_backlight_of_match
);
188 static int pwm_backlight_parse_dt(struct device
*dev
,
189 struct platform_pwm_backlight_data
*data
)
195 static int pwm_backlight_initial_power_state(const struct pwm_bl_data
*pb
)
197 struct device_node
*node
= pb
->dev
->of_node
;
199 /* Not booted with device tree or no phandle link to the node */
200 if (!node
|| !node
->phandle
)
201 return FB_BLANK_UNBLANK
;
204 * If the driver is probed from the device tree and there is a
205 * phandle link pointing to the backlight node, it is safe to
206 * assume that another driver will enable the backlight at the
207 * appropriate time. Therefore, if it is disabled, keep it so.
210 /* if the enable GPIO is disabled, do not enable the backlight */
211 if (pb
->enable_gpio
&& gpiod_get_value(pb
->enable_gpio
) == 0)
212 return FB_BLANK_POWERDOWN
;
214 /* The regulator is disabled, do not enable the backlight */
215 if (!regulator_is_enabled(pb
->power_supply
))
216 return FB_BLANK_POWERDOWN
;
218 /* The PWM is disabled, keep it like this */
219 if (!pwm_is_enabled(pb
->pwm
))
220 return FB_BLANK_POWERDOWN
;
222 return FB_BLANK_UNBLANK
;
225 static int pwm_backlight_probe(struct platform_device
*pdev
)
227 struct platform_pwm_backlight_data
*data
= dev_get_platdata(&pdev
->dev
);
228 struct platform_pwm_backlight_data defdata
;
229 struct backlight_properties props
;
230 struct backlight_device
*bl
;
231 struct device_node
*node
= pdev
->dev
.of_node
;
232 struct pwm_bl_data
*pb
;
233 struct pwm_args pargs
;
237 ret
= pwm_backlight_parse_dt(&pdev
->dev
, &defdata
);
239 dev_err(&pdev
->dev
, "failed to find platform data\n");
247 ret
= data
->init(&pdev
->dev
);
252 pb
= devm_kzalloc(&pdev
->dev
, sizeof(*pb
), GFP_KERNEL
);
261 for (i
= 0; i
<= data
->max_brightness
; i
++)
262 if (data
->levels
[i
] > pb
->scale
)
263 pb
->scale
= data
->levels
[i
];
265 pb
->levels
= data
->levels
;
267 pb
->scale
= data
->max_brightness
;
269 pb
->notify
= data
->notify
;
270 pb
->notify_after
= data
->notify_after
;
271 pb
->check_fb
= data
->check_fb
;
272 pb
->exit
= data
->exit
;
273 pb
->dev
= &pdev
->dev
;
276 pb
->enable_gpio
= devm_gpiod_get_optional(&pdev
->dev
, "enable",
278 if (IS_ERR(pb
->enable_gpio
)) {
279 ret
= PTR_ERR(pb
->enable_gpio
);
284 * Compatibility fallback for drivers still using the integer GPIO
285 * platform data. Must go away soon.
287 if (!pb
->enable_gpio
&& gpio_is_valid(data
->enable_gpio
)) {
288 ret
= devm_gpio_request_one(&pdev
->dev
, data
->enable_gpio
,
289 GPIOF_OUT_INIT_HIGH
, "enable");
291 dev_err(&pdev
->dev
, "failed to request GPIO#%d: %d\n",
292 data
->enable_gpio
, ret
);
296 pb
->enable_gpio
= gpio_to_desc(data
->enable_gpio
);
300 * If the GPIO is configured as input, change the direction to output
301 * and set the GPIO as active.
302 * Do not force the GPIO to active when it was already output as it
303 * could cause backlight flickering or we would enable the backlight too
304 * early. Leave the decision of the initial backlight state for later.
306 if (pb
->enable_gpio
&&
307 gpiod_get_direction(pb
->enable_gpio
) == GPIOF_DIR_IN
)
308 gpiod_direction_output(pb
->enable_gpio
, 1);
310 pb
->power_supply
= devm_regulator_get(&pdev
->dev
, "power");
311 if (IS_ERR(pb
->power_supply
)) {
312 ret
= PTR_ERR(pb
->power_supply
);
316 pb
->pwm
= devm_pwm_get(&pdev
->dev
, NULL
);
317 if (IS_ERR(pb
->pwm
) && PTR_ERR(pb
->pwm
) != -EPROBE_DEFER
&& !node
) {
318 dev_err(&pdev
->dev
, "unable to request PWM, trying legacy API\n");
320 pb
->pwm
= pwm_request(data
->pwm_id
, "pwm-backlight");
323 if (IS_ERR(pb
->pwm
)) {
324 ret
= PTR_ERR(pb
->pwm
);
325 if (ret
!= -EPROBE_DEFER
)
326 dev_err(&pdev
->dev
, "unable to request PWM\n");
330 dev_dbg(&pdev
->dev
, "got pwm for backlight\n");
333 * FIXME: pwm_apply_args() should be removed when switching to
334 * the atomic PWM API.
336 pwm_apply_args(pb
->pwm
);
339 * The DT case will set the pwm_period_ns field to 0 and store the
340 * period, parsed from the DT, in the PWM device. For the non-DT case,
341 * set the period from platform data if it has not already been set
342 * via the PWM lookup table.
344 pwm_get_args(pb
->pwm
, &pargs
);
345 pb
->period
= pargs
.period
;
346 if (!pb
->period
&& (data
->pwm_period_ns
> 0))
347 pb
->period
= data
->pwm_period_ns
;
349 pb
->lth_brightness
= data
->lth_brightness
* (pb
->period
/ pb
->scale
);
351 memset(&props
, 0, sizeof(struct backlight_properties
));
352 props
.type
= BACKLIGHT_RAW
;
353 props
.max_brightness
= data
->max_brightness
;
354 bl
= backlight_device_register(dev_name(&pdev
->dev
), &pdev
->dev
, pb
,
355 &pwm_backlight_ops
, &props
);
357 dev_err(&pdev
->dev
, "failed to register backlight\n");
364 if (data
->dft_brightness
> data
->max_brightness
) {
366 "invalid default brightness level: %u, using %u\n",
367 data
->dft_brightness
, data
->max_brightness
);
368 data
->dft_brightness
= data
->max_brightness
;
371 bl
->props
.brightness
= data
->dft_brightness
;
372 bl
->props
.power
= pwm_backlight_initial_power_state(pb
);
373 backlight_update_status(bl
);
375 platform_set_drvdata(pdev
, bl
);
380 data
->exit(&pdev
->dev
);
384 static int pwm_backlight_remove(struct platform_device
*pdev
)
386 struct backlight_device
*bl
= platform_get_drvdata(pdev
);
387 struct pwm_bl_data
*pb
= bl_get_data(bl
);
389 backlight_device_unregister(bl
);
390 pwm_backlight_power_off(pb
);
393 pb
->exit(&pdev
->dev
);
400 static void pwm_backlight_shutdown(struct platform_device
*pdev
)
402 struct backlight_device
*bl
= platform_get_drvdata(pdev
);
403 struct pwm_bl_data
*pb
= bl_get_data(bl
);
405 pwm_backlight_power_off(pb
);
408 #ifdef CONFIG_PM_SLEEP
409 static int pwm_backlight_suspend(struct device
*dev
)
411 struct backlight_device
*bl
= dev_get_drvdata(dev
);
412 struct pwm_bl_data
*pb
= bl_get_data(bl
);
415 pb
->notify(pb
->dev
, 0);
417 pwm_backlight_power_off(pb
);
419 if (pb
->notify_after
)
420 pb
->notify_after(pb
->dev
, 0);
425 static int pwm_backlight_resume(struct device
*dev
)
427 struct backlight_device
*bl
= dev_get_drvdata(dev
);
429 backlight_update_status(bl
);
435 static const struct dev_pm_ops pwm_backlight_pm_ops
= {
436 #ifdef CONFIG_PM_SLEEP
437 .suspend
= pwm_backlight_suspend
,
438 .resume
= pwm_backlight_resume
,
439 .poweroff
= pwm_backlight_suspend
,
440 .restore
= pwm_backlight_resume
,
444 static struct platform_driver pwm_backlight_driver
= {
446 .name
= "pwm-backlight",
447 .pm
= &pwm_backlight_pm_ops
,
448 .of_match_table
= of_match_ptr(pwm_backlight_of_match
),
450 .probe
= pwm_backlight_probe
,
451 .remove
= pwm_backlight_remove
,
452 .shutdown
= pwm_backlight_shutdown
,
455 module_platform_driver(pwm_backlight_driver
);
457 MODULE_DESCRIPTION("PWM based Backlight Driver");
458 MODULE_LICENSE("GPL");
459 MODULE_ALIAS("platform:pwm-backlight");