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/module.h>
14 #include <linux/kernel.h>
15 #include <linux/init.h>
16 #include <linux/platform_device.h>
18 #include <linux/backlight.h>
19 #include <linux/err.h>
20 #include <linux/pwm.h>
21 #include <linux/pwm_backlight.h>
22 #include <linux/slab.h>
25 struct pwm_device
*pwm
;
28 unsigned int lth_brightness
;
30 int (*notify
)(struct device
*,
32 void (*notify_after
)(struct device
*,
34 int (*check_fb
)(struct device
*, struct fb_info
*);
35 void (*exit
)(struct device
*);
38 static int pwm_backlight_update_status(struct backlight_device
*bl
)
40 struct pwm_bl_data
*pb
= dev_get_drvdata(&bl
->dev
);
41 int brightness
= bl
->props
.brightness
;
42 int max
= bl
->props
.max_brightness
;
44 if (bl
->props
.power
!= FB_BLANK_UNBLANK
)
47 if (bl
->props
.fb_blank
!= FB_BLANK_UNBLANK
)
51 brightness
= pb
->notify(pb
->dev
, brightness
);
53 if (brightness
== 0) {
54 pwm_config(pb
->pwm
, 0, pb
->period
);
58 brightness
= pb
->levels
[brightness
];
59 max
= pb
->levels
[max
];
62 brightness
= pb
->lth_brightness
+
63 (brightness
* (pb
->period
- pb
->lth_brightness
) / max
);
64 pwm_config(pb
->pwm
, brightness
, pb
->period
);
69 pb
->notify_after(pb
->dev
, brightness
);
74 static int pwm_backlight_get_brightness(struct backlight_device
*bl
)
76 return bl
->props
.brightness
;
79 static int pwm_backlight_check_fb(struct backlight_device
*bl
,
82 struct pwm_bl_data
*pb
= dev_get_drvdata(&bl
->dev
);
84 return !pb
->check_fb
|| pb
->check_fb(pb
->dev
, info
);
87 static const struct backlight_ops pwm_backlight_ops
= {
88 .update_status
= pwm_backlight_update_status
,
89 .get_brightness
= pwm_backlight_get_brightness
,
90 .check_fb
= pwm_backlight_check_fb
,
94 static int pwm_backlight_parse_dt(struct device
*dev
,
95 struct platform_pwm_backlight_data
*data
)
97 struct device_node
*node
= dev
->of_node
;
98 struct property
*prop
;
106 memset(data
, 0, sizeof(*data
));
108 /* determine the number of brightness levels */
109 prop
= of_find_property(node
, "brightness-levels", &length
);
113 data
->max_brightness
= length
/ sizeof(u32
);
115 /* read brightness levels from DT property */
116 if (data
->max_brightness
> 0) {
117 size_t size
= sizeof(*data
->levels
) * data
->max_brightness
;
119 data
->levels
= devm_kzalloc(dev
, size
, GFP_KERNEL
);
123 ret
= of_property_read_u32_array(node
, "brightness-levels",
125 data
->max_brightness
);
129 ret
= of_property_read_u32(node
, "default-brightness-level",
134 if (value
>= data
->max_brightness
) {
135 dev_warn(dev
, "invalid default brightness level: %u, using %u\n",
136 value
, data
->max_brightness
- 1);
137 value
= data
->max_brightness
- 1;
140 data
->dft_brightness
= value
;
141 data
->max_brightness
--;
145 * TODO: Most users of this driver use a number of GPIOs to control
146 * backlight power. Support for specifying these needs to be
153 static struct of_device_id pwm_backlight_of_match
[] = {
154 { .compatible
= "pwm-backlight" },
158 MODULE_DEVICE_TABLE(of
, pwm_backlight_of_match
);
160 static int pwm_backlight_parse_dt(struct device
*dev
,
161 struct platform_pwm_backlight_data
*data
)
167 static int pwm_backlight_probe(struct platform_device
*pdev
)
169 struct platform_pwm_backlight_data
*data
= pdev
->dev
.platform_data
;
170 struct platform_pwm_backlight_data defdata
;
171 struct backlight_properties props
;
172 struct backlight_device
*bl
;
173 struct pwm_bl_data
*pb
;
178 ret
= pwm_backlight_parse_dt(&pdev
->dev
, &defdata
);
180 dev_err(&pdev
->dev
, "failed to find platform data\n");
188 ret
= data
->init(&pdev
->dev
);
193 pb
= devm_kzalloc(&pdev
->dev
, sizeof(*pb
), GFP_KERNEL
);
195 dev_err(&pdev
->dev
, "no memory for state\n");
201 max
= data
->levels
[data
->max_brightness
];
202 pb
->levels
= data
->levels
;
204 max
= data
->max_brightness
;
206 pb
->notify
= data
->notify
;
207 pb
->notify_after
= data
->notify_after
;
208 pb
->check_fb
= data
->check_fb
;
209 pb
->exit
= data
->exit
;
210 pb
->dev
= &pdev
->dev
;
212 pb
->pwm
= pwm_get(&pdev
->dev
, NULL
);
213 if (IS_ERR(pb
->pwm
)) {
214 dev_err(&pdev
->dev
, "unable to request PWM, trying legacy API\n");
216 pb
->pwm
= pwm_request(data
->pwm_id
, "pwm-backlight");
217 if (IS_ERR(pb
->pwm
)) {
218 dev_err(&pdev
->dev
, "unable to request legacy PWM\n");
219 ret
= PTR_ERR(pb
->pwm
);
224 dev_dbg(&pdev
->dev
, "got pwm for backlight\n");
227 * The DT case will set the pwm_period_ns field to 0 and store the
228 * period, parsed from the DT, in the PWM device. For the non-DT case,
229 * set the period from platform data.
231 if (data
->pwm_period_ns
> 0)
232 pwm_set_period(pb
->pwm
, data
->pwm_period_ns
);
234 pb
->period
= pwm_get_period(pb
->pwm
);
235 pb
->lth_brightness
= data
->lth_brightness
* (pb
->period
/ max
);
237 memset(&props
, 0, sizeof(struct backlight_properties
));
238 props
.type
= BACKLIGHT_RAW
;
239 props
.max_brightness
= data
->max_brightness
;
240 bl
= backlight_device_register(dev_name(&pdev
->dev
), &pdev
->dev
, pb
,
241 &pwm_backlight_ops
, &props
);
243 dev_err(&pdev
->dev
, "failed to register backlight\n");
248 bl
->props
.brightness
= data
->dft_brightness
;
249 backlight_update_status(bl
);
251 platform_set_drvdata(pdev
, bl
);
258 data
->exit(&pdev
->dev
);
262 static int pwm_backlight_remove(struct platform_device
*pdev
)
264 struct backlight_device
*bl
= platform_get_drvdata(pdev
);
265 struct pwm_bl_data
*pb
= dev_get_drvdata(&bl
->dev
);
267 backlight_device_unregister(bl
);
268 pwm_config(pb
->pwm
, 0, pb
->period
);
269 pwm_disable(pb
->pwm
);
272 pb
->exit(&pdev
->dev
);
277 static int pwm_backlight_suspend(struct device
*dev
)
279 struct backlight_device
*bl
= dev_get_drvdata(dev
);
280 struct pwm_bl_data
*pb
= dev_get_drvdata(&bl
->dev
);
283 pb
->notify(pb
->dev
, 0);
284 pwm_config(pb
->pwm
, 0, pb
->period
);
285 pwm_disable(pb
->pwm
);
286 if (pb
->notify_after
)
287 pb
->notify_after(pb
->dev
, 0);
291 static int pwm_backlight_resume(struct device
*dev
)
293 struct backlight_device
*bl
= dev_get_drvdata(dev
);
295 backlight_update_status(bl
);
299 static SIMPLE_DEV_PM_OPS(pwm_backlight_pm_ops
, pwm_backlight_suspend
,
300 pwm_backlight_resume
);
304 static struct platform_driver pwm_backlight_driver
= {
306 .name
= "pwm-backlight",
307 .owner
= THIS_MODULE
,
309 .pm
= &pwm_backlight_pm_ops
,
311 .of_match_table
= of_match_ptr(pwm_backlight_of_match
),
313 .probe
= pwm_backlight_probe
,
314 .remove
= pwm_backlight_remove
,
317 module_platform_driver(pwm_backlight_driver
);
319 MODULE_DESCRIPTION("PWM based Backlight Driver");
320 MODULE_LICENSE("GPL");
321 MODULE_ALIAS("platform:pwm-backlight");