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.h>
14 #include <linux/of_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
;
36 unsigned long enable_gpio_flags
;
37 int (*notify
)(struct device
*,
39 void (*notify_after
)(struct device
*,
41 int (*check_fb
)(struct device
*, struct fb_info
*);
42 void (*exit
)(struct device
*);
45 static void pwm_backlight_power_on(struct pwm_bl_data
*pb
, int brightness
,
54 duty_cycle
= pb
->levels
[brightness
];
55 max
= pb
->levels
[max
];
57 duty_cycle
= brightness
;
60 duty_cycle
= (duty_cycle
* (pb
->period
- pb
->lth_brightness
) / max
) +
63 pwm_config(pb
->pwm
, duty_cycle
, pb
->period
);
65 err
= regulator_enable(pb
->power_supply
);
67 dev_err(pb
->dev
, "failed to enable power supply\n");
69 if (gpio_is_valid(pb
->enable_gpio
)) {
70 if (pb
->enable_gpio_flags
& PWM_BACKLIGHT_GPIO_ACTIVE_LOW
)
71 gpio_set_value(pb
->enable_gpio
, 0);
73 gpio_set_value(pb
->enable_gpio
, 1);
80 static void pwm_backlight_power_off(struct pwm_bl_data
*pb
)
85 pwm_config(pb
->pwm
, 0, pb
->period
);
88 if (gpio_is_valid(pb
->enable_gpio
)) {
89 if (pb
->enable_gpio_flags
& PWM_BACKLIGHT_GPIO_ACTIVE_LOW
)
90 gpio_set_value(pb
->enable_gpio
, 1);
92 gpio_set_value(pb
->enable_gpio
, 0);
95 regulator_disable(pb
->power_supply
);
99 static int pwm_backlight_update_status(struct backlight_device
*bl
)
101 struct pwm_bl_data
*pb
= bl_get_data(bl
);
102 int brightness
= bl
->props
.brightness
;
103 int max
= bl
->props
.max_brightness
;
105 if (bl
->props
.power
!= FB_BLANK_UNBLANK
||
106 bl
->props
.fb_blank
!= FB_BLANK_UNBLANK
||
107 bl
->props
.state
& BL_CORE_FBBLANK
)
111 brightness
= pb
->notify(pb
->dev
, brightness
);
114 pwm_backlight_power_on(pb
, brightness
, max
);
116 pwm_backlight_power_off(pb
);
118 if (pb
->notify_after
)
119 pb
->notify_after(pb
->dev
, brightness
);
124 static int pwm_backlight_get_brightness(struct backlight_device
*bl
)
126 return bl
->props
.brightness
;
129 static int pwm_backlight_check_fb(struct backlight_device
*bl
,
130 struct fb_info
*info
)
132 struct pwm_bl_data
*pb
= bl_get_data(bl
);
134 return !pb
->check_fb
|| pb
->check_fb(pb
->dev
, info
);
137 static const struct backlight_ops pwm_backlight_ops
= {
138 .update_status
= pwm_backlight_update_status
,
139 .get_brightness
= pwm_backlight_get_brightness
,
140 .check_fb
= pwm_backlight_check_fb
,
144 static int pwm_backlight_parse_dt(struct device
*dev
,
145 struct platform_pwm_backlight_data
*data
)
147 struct device_node
*node
= dev
->of_node
;
148 enum of_gpio_flags flags
;
149 struct property
*prop
;
157 memset(data
, 0, sizeof(*data
));
159 /* determine the number of brightness levels */
160 prop
= of_find_property(node
, "brightness-levels", &length
);
164 data
->max_brightness
= length
/ sizeof(u32
);
166 /* read brightness levels from DT property */
167 if (data
->max_brightness
> 0) {
168 size_t size
= sizeof(*data
->levels
) * data
->max_brightness
;
170 data
->levels
= devm_kzalloc(dev
, size
, GFP_KERNEL
);
174 ret
= of_property_read_u32_array(node
, "brightness-levels",
176 data
->max_brightness
);
180 ret
= of_property_read_u32(node
, "default-brightness-level",
185 data
->dft_brightness
= value
;
186 data
->max_brightness
--;
189 data
->enable_gpio
= of_get_named_gpio_flags(node
, "enable-gpios", 0,
191 if (data
->enable_gpio
== -EPROBE_DEFER
)
192 return -EPROBE_DEFER
;
194 if (gpio_is_valid(data
->enable_gpio
) && (flags
& OF_GPIO_ACTIVE_LOW
))
195 data
->enable_gpio_flags
|= PWM_BACKLIGHT_GPIO_ACTIVE_LOW
;
200 static struct of_device_id pwm_backlight_of_match
[] = {
201 { .compatible
= "pwm-backlight" },
205 MODULE_DEVICE_TABLE(of
, pwm_backlight_of_match
);
207 static int pwm_backlight_parse_dt(struct device
*dev
,
208 struct platform_pwm_backlight_data
*data
)
214 static int pwm_backlight_probe(struct platform_device
*pdev
)
216 struct platform_pwm_backlight_data
*data
= pdev
->dev
.platform_data
;
217 struct platform_pwm_backlight_data defdata
;
218 struct backlight_properties props
;
219 struct backlight_device
*bl
;
220 struct pwm_bl_data
*pb
;
225 ret
= pwm_backlight_parse_dt(&pdev
->dev
, &defdata
);
227 dev_err(&pdev
->dev
, "failed to find platform data\n");
235 ret
= data
->init(&pdev
->dev
);
240 pb
= devm_kzalloc(&pdev
->dev
, sizeof(*pb
), GFP_KERNEL
);
242 dev_err(&pdev
->dev
, "no memory for state\n");
248 max
= data
->levels
[data
->max_brightness
];
249 pb
->levels
= data
->levels
;
251 max
= data
->max_brightness
;
253 pb
->enable_gpio
= data
->enable_gpio
;
254 pb
->enable_gpio_flags
= data
->enable_gpio_flags
;
255 pb
->notify
= data
->notify
;
256 pb
->notify_after
= data
->notify_after
;
257 pb
->check_fb
= data
->check_fb
;
258 pb
->exit
= data
->exit
;
259 pb
->dev
= &pdev
->dev
;
262 if (gpio_is_valid(pb
->enable_gpio
)) {
265 if (pb
->enable_gpio_flags
& PWM_BACKLIGHT_GPIO_ACTIVE_LOW
)
266 flags
= GPIOF_OUT_INIT_HIGH
;
268 flags
= GPIOF_OUT_INIT_LOW
;
270 ret
= gpio_request_one(pb
->enable_gpio
, flags
, "enable");
272 dev_err(&pdev
->dev
, "failed to request GPIO#%d: %d\n",
273 pb
->enable_gpio
, ret
);
278 pb
->power_supply
= devm_regulator_get(&pdev
->dev
, "power");
279 if (IS_ERR(pb
->power_supply
)) {
280 ret
= PTR_ERR(pb
->power_supply
);
284 pb
->pwm
= devm_pwm_get(&pdev
->dev
, NULL
);
285 if (IS_ERR(pb
->pwm
)) {
286 dev_err(&pdev
->dev
, "unable to request PWM, trying legacy API\n");
288 pb
->pwm
= pwm_request(data
->pwm_id
, "pwm-backlight");
289 if (IS_ERR(pb
->pwm
)) {
290 dev_err(&pdev
->dev
, "unable to request legacy PWM\n");
291 ret
= PTR_ERR(pb
->pwm
);
296 dev_dbg(&pdev
->dev
, "got pwm for backlight\n");
299 * The DT case will set the pwm_period_ns field to 0 and store the
300 * period, parsed from the DT, in the PWM device. For the non-DT case,
301 * set the period from platform data.
303 if (data
->pwm_period_ns
> 0)
304 pwm_set_period(pb
->pwm
, data
->pwm_period_ns
);
306 pb
->period
= pwm_get_period(pb
->pwm
);
307 pb
->lth_brightness
= data
->lth_brightness
* (pb
->period
/ max
);
309 memset(&props
, 0, sizeof(struct backlight_properties
));
310 props
.type
= BACKLIGHT_RAW
;
311 props
.max_brightness
= data
->max_brightness
;
312 bl
= backlight_device_register(dev_name(&pdev
->dev
), &pdev
->dev
, pb
,
313 &pwm_backlight_ops
, &props
);
315 dev_err(&pdev
->dev
, "failed to register backlight\n");
320 if (data
->dft_brightness
> data
->max_brightness
) {
322 "invalid default brightness level: %u, using %u\n",
323 data
->dft_brightness
, data
->max_brightness
);
324 data
->dft_brightness
= data
->max_brightness
;
327 bl
->props
.brightness
= data
->dft_brightness
;
328 backlight_update_status(bl
);
330 platform_set_drvdata(pdev
, bl
);
334 if (gpio_is_valid(pb
->enable_gpio
))
335 gpio_free(pb
->enable_gpio
);
338 data
->exit(&pdev
->dev
);
342 static int pwm_backlight_remove(struct platform_device
*pdev
)
344 struct backlight_device
*bl
= platform_get_drvdata(pdev
);
345 struct pwm_bl_data
*pb
= bl_get_data(bl
);
347 backlight_device_unregister(bl
);
348 pwm_backlight_power_off(pb
);
351 pb
->exit(&pdev
->dev
);
356 #ifdef CONFIG_PM_SLEEP
357 static int pwm_backlight_suspend(struct device
*dev
)
359 struct backlight_device
*bl
= dev_get_drvdata(dev
);
360 struct pwm_bl_data
*pb
= bl_get_data(bl
);
363 pb
->notify(pb
->dev
, 0);
365 pwm_backlight_power_off(pb
);
367 if (pb
->notify_after
)
368 pb
->notify_after(pb
->dev
, 0);
373 static int pwm_backlight_resume(struct device
*dev
)
375 struct backlight_device
*bl
= dev_get_drvdata(dev
);
377 backlight_update_status(bl
);
383 static SIMPLE_DEV_PM_OPS(pwm_backlight_pm_ops
, pwm_backlight_suspend
,
384 pwm_backlight_resume
);
386 static struct platform_driver pwm_backlight_driver
= {
388 .name
= "pwm-backlight",
389 .owner
= THIS_MODULE
,
390 .pm
= &pwm_backlight_pm_ops
,
391 .of_match_table
= of_match_ptr(pwm_backlight_of_match
),
393 .probe
= pwm_backlight_probe
,
394 .remove
= pwm_backlight_remove
,
397 module_platform_driver(pwm_backlight_driver
);
399 MODULE_DESCRIPTION("PWM based Backlight Driver");
400 MODULE_LICENSE("GPL");
401 MODULE_ALIAS("platform:pwm-backlight");