static int genericbl_probe(struct platform_device *pdev)
{
struct backlight_properties props;
struct generic_bl_info *machinfo = dev_get_platdata(&pdev->dev);
const char *name = "generic-bl";
struct backlight_device *bd;
bl_machinfo = machinfo;
if (!machinfo->limit_mask)
machinfo->limit_mask = -1;
if (machinfo->name)
name = machinfo->name;
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_RAW;
props.max_brightness = machinfo->max_intensity;
bd = devm_backlight_device_register(&pdev->dev, name, &pdev->dev,
NULL, &genericbl_ops, &props);
if (IS_ERR(bd))
return PTR_ERR(bd);
platform_set_drvdata(pdev, bd);
bd->props.power = FB_BLANK_UNBLANK;
bd->props.brightness = machinfo->default_intensity;
backlight_update_status(bd);
generic_backlight_device = bd;
dev_info(&pdev->dev, "Generic Backlight Driver Initialized.\n");
return 0;
}
static int pwm_backlight_resume(struct platform_device *pdev)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
backlight_update_status(bl);
return 0;
}
void msm_fb_config_backlight(struct msm_fb_data_type *mfd)
{
struct msm_fb_panel_data *pdata;
struct backlight_device *pbd;
struct fb_info *fbi;
char name[16];
fbi = mfd->fbi;
pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data;
if ((pdata) && (pdata->set_backlight)) {
snprintf(name, sizeof(name), "msmfb_bl%d", mfd->index);
pbd =
backlight_device_register(name, fbi->dev, mfd,
&msm_fb_bl_ops);
if (!IS_ERR(pbd)) {
fbi->bl_dev = pbd;
fb_bl_default_curve(fbi,
0,
mfd->panel_info.bl_min,
mfd->panel_info.bl_max);
pbd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
pbd->props.brightness = FB_BACKLIGHT_LEVELS - 1;
backlight_update_status(pbd);
} else {
fbi->bl_dev = NULL;
printk(KERN_ERR "msm_fb: backlight_device_register failed!\n");
}
}
}
static int __init mxcbl_probe(struct platform_device *pdev)
{
struct backlight_device *bd;
struct mxcbl_dev_data *devdata;
int ret = 0;
devdata = kzalloc(sizeof(struct mxcbl_dev_data), GFP_KERNEL);
if (!devdata)
return -ENOMEM;
fb_id = (int)pdev->dev.platform_data;
bd = backlight_device_register(pdev->dev.bus_id, &pdev->dev, devdata,
&mxcbl_ops);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
goto err0;
}
platform_set_drvdata(pdev, bd);
bd->props.brightness = MXC_DEFAULT_INTENSITY;
bd->props.max_brightness = MXC_MAX_INTENSITY;
bd->props.power = FB_BLANK_UNBLANK;
bd->props.fb_blank = FB_BLANK_UNBLANK;
backlight_update_status(bd);
printk("MXC Backlight Device %s Initialized.\n", pdev->dev.bus_id);
return 0;
err0:
kfree(devdata);
return ret;
}
static int adp5520_bl_resume(struct device *dev)
{
struct backlight_device *bl = dev_get_drvdata(dev);
backlight_update_status(bl);
return 0;
}
static int pandora_backlight_probe(struct platform_device *pdev)
{
struct backlight_properties props;
struct backlight_device *bl;
u8 r;
memset(&props, 0, sizeof(props));
props.max_brightness = MAX_USER_VALUE;
props.type = BACKLIGHT_RAW;
bl = devm_backlight_device_register(&pdev->dev, pdev->name, &pdev->dev,
NULL, &pandora_backlight_ops, &props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
return PTR_ERR(bl);
}
platform_set_drvdata(pdev, bl);
/* 64 cycle period, ON position 0 */
twl_i2c_write_u8(TWL_MODULE_PWM, 0x80, TWL_PWM0_ON);
bl->props.state |= PANDORABL_WAS_OFF;
bl->props.brightness = MAX_USER_VALUE;
backlight_update_status(bl);
/* enable PWM function in pin mux */
twl_i2c_read_u8(TWL4030_MODULE_INTBR, &r, TWL_INTBR_PMBR1);
r &= ~TWL_PMBR1_PWM0_MUXMASK;
r |= TWL_PMBR1_PWM0;
twl_i2c_write_u8(TWL4030_MODULE_INTBR, r, TWL_INTBR_PMBR1);
return 0;
}
static int omapbl_remove(struct platform_device *pdev)
{
u8 c;
struct backlight_device *bd = platform_get_drvdata(pdev);
omapbl_props.power = 0;
omapbl_props.brightness = 0;
backlight_update_status(bd);
/* Disableable PWM1 and PWM1_CLK in GPBR */
twl_i2c_read_u8(TWL4030_MODULE_INTBR, &c, 0x0c);
c &= ~((1 << 3) | (1 << 1));
twl_i2c_write_u8 (TWL4030_MODULE_INTBR, c, 0x0c);
/* Restore default/gpio output in PMBR1 */
twl_i2c_read_u8(TWL4030_MODULE_INTBR, &c, 0x0d);
c &= ~(0x30);
twl_i2c_write_u8 (TWL4030_MODULE_INTBR, c, 0x0d);
backlight_device_unregister(bd);
printk(KERN_INFO "omap-backlight: device unloaded.\n");
return 0;
}
static int oaktrail_backlight_init(void)
{
struct backlight_device *bd;
struct backlight_properties props;
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_PLATFORM;
props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
bd = backlight_device_register(DRIVER_NAME,
&oaktrail_device->dev, NULL,
&oaktrail_bl_ops,
&props);
if (IS_ERR(bd)) {
oaktrail_bl_device = NULL;
pr_warning("Unable to register backlight device\n");
return PTR_ERR(bd);
}
oaktrail_bl_device = bd;
bd->props.brightness = get_backlight_brightness(bd);
bd->props.power = FB_BLANK_UNBLANK;
backlight_update_status(bd);
return 0;
}
static int imanager_backlight_init(struct device *dev,
struct imanager_backlight_data *data)
{
struct backlight_device *bd;
struct backlight_properties props;
memset(&props, 0, sizeof(props));
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38)
props.type = BACKLIGHT_PLATFORM;
#endif
props.max_brightness = BL_MAX_BRIGHTNESS;
bd = backlight_device_register("imanager_backlight", dev, data,
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)
&imanager_bl_ops);
#else
&imanager_bl_ops, &props);
#endif
if (IS_ERR(bd)) {
data->bl = NULL;
dev_err(dev, "Unable to register backlight device\n");
return PTR_ERR(bd);
}
data->bl = bd;
bd->props.brightness = get_brightness(bd);
bd->props.power = FB_BLANK_UNBLANK;
backlight_update_status(bd);
return 0;
}
static int tosa_bl_resume(struct i2c_client *client)
{
struct tosa_bl_data *data = i2c_get_clientdata(client);
backlight_update_status(data->bl);
return 0;
}
static int asus_backlight_init(struct asus_laptop *asus)
{
struct backlight_device *bd;
struct backlight_properties props;
if (acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) ||
acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL))
return 0;
memset(&props, 0, sizeof(struct backlight_properties));
props.max_brightness = 15;
props.type = BACKLIGHT_PLATFORM;
bd = backlight_device_register(ASUS_LAPTOP_FILE,
&asus->platform_device->dev, asus,
&asusbl_ops, &props);
if (IS_ERR(bd)) {
pr_err("Could not register asus backlight device\n");
asus->backlight_device = NULL;
return PTR_ERR(bd);
}
asus->backlight_device = bd;
bd->props.brightness = asus_read_brightness(bd);
bd->props.power = FB_BLANK_UNBLANK;
backlight_update_status(bd);
return 0;
}
static int keyboard_backlight_resume(struct device *pdev)
{
struct backlight_device *bl = dev_get_drvdata(pdev);
backlight_update_status(bl);
return 0;
}
static int __pmac_backlight_set_legacy_brightness(int brightness)
{
int error = -ENXIO;
mutex_lock(&pmac_backlight_mutex);
if (pmac_backlight) {
struct backlight_properties *props;
props = &pmac_backlight->props;
props->brightness = brightness *
(props->max_brightness + 1) /
(OLD_BACKLIGHT_MAX + 1);
if (props->brightness > props->max_brightness)
props->brightness = props->max_brightness;
else if (props->brightness < 0)
props->brightness = 0;
backlight_update_status(pmac_backlight);
error = 0;
}
mutex_unlock(&pmac_backlight_mutex);
return error;
}
static void pmac_backlight_key_worker(struct work_struct *work)
{
if (atomic_read(&kernel_backlight_disabled))
return;
mutex_lock(&pmac_backlight_mutex);
if (pmac_backlight) {
struct backlight_properties *props;
int brightness;
props = &pmac_backlight->props;
brightness = props->brightness +
((pmac_backlight_key_queued?-1:1) *
(props->max_brightness / 15));
if (brightness < 0)
brightness = 0;
else if (brightness > props->max_brightness)
brightness = props->max_brightness;
props->brightness = brightness;
backlight_update_status(pmac_backlight);
}
mutex_unlock(&pmac_backlight_mutex);
}
static int ep93xxbl_resume(struct platform_device *dev)
{
struct backlight_device *bl = platform_get_drvdata(dev);
backlight_update_status(bl);
return 0;
}
static void ktd259b_backlight_earlyresume(struct early_suspend *desc)
{
struct ktd259b_bl_data *ktd259b = container_of(desc, struct ktd259b_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(ktd259b->pdev);
struct timespec ts;
struct rtc_time tm;
#ifdef PWM_BRIGHTNESS
int temp_brightness = 0;
#endif
gpio_set_value(backlight_pwm,1);
#ifdef PWM_BRIGHTNESS
vc_display_bus_write(0,0x51,&temp_brightness,1);
mdelay(100);
lcd_backlight_control(5);
#endif
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
backlight_mode=BACKLIGHT_RESUME;
if(cabc_status)
{
backlight_cabc_on();
}
else
{
backlight_cabc_off();
}
printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlyresume\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
backlight_update_status(bl);
}
static void ktd_backlight_lateresume(struct early_suspend *desc)
{
struct ktd_bl_data *ktd = container_of(desc, struct ktd_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(ktd->pdev);
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
backlight_mode = BACKLIGHT_RESUME;
#if CABC_FEATURE_ON
if (cabc_status)
backlight_cabc_on();
else
backlight_cabc_off();
#endif
BLDBG("[%02d:%02d:%02d.%03lu][BACKLIGHT] late resume\n",
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
if(0 != bl->props.brightness)
backlight_update_status(bl);
}
static int adp5520_bl_probe(struct platform_device *pdev)
{
struct backlight_properties props;
struct backlight_device *bl;
struct adp5520_bl *data;
int ret = 0;
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
if (data == NULL)
return -ENOMEM;
data->master = pdev->dev.parent;
data->pdata = dev_get_platdata(&pdev->dev);
if (data->pdata == NULL) {
dev_err(&pdev->dev, "missing platform data\n");
return -ENODEV;
}
data->id = pdev->id;
data->current_brightness = 0;
mutex_init(&data->lock);
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_RAW;
props.max_brightness = ADP5020_MAX_BRIGHTNESS;
bl = devm_backlight_device_register(&pdev->dev, pdev->name,
data->master, data, &adp5520_bl_ops,
&props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
return PTR_ERR(bl);
}
bl->props.brightness = ADP5020_MAX_BRIGHTNESS;
if (data->pdata->en_ambl_sens)
ret = sysfs_create_group(&bl->dev.kobj,
&adp5520_bl_attr_group);
if (ret) {
dev_err(&pdev->dev, "failed to register sysfs\n");
return ret;
}
platform_set_drvdata(pdev, bl);
ret = adp5520_bl_setup(bl);
if (ret) {
dev_err(&pdev->dev, "failed to setup\n");
if (data->pdata->en_ambl_sens)
sysfs_remove_group(&bl->dev.kobj,
&adp5520_bl_attr_group);
return ret;
}
backlight_update_status(bl);
return 0;
}
static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
{
struct sh_mobile_lcdc_chan *ch;
struct sh_mobile_lcdc_board_cfg *board_cfg;
int k;
/* clean up deferred io and ask board code to disable panel */
for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
ch = &priv->ch[k];
if (!ch->enabled)
continue;
/* deferred io mode:
* flush frame, and wait for frame end interrupt
* clean up deferred io and enable clock
*/
if (ch->info && ch->info->fbdefio) {
ch->frame_end = 0;
schedule_delayed_work(&ch->info->deferred_work, 0);
wait_event(ch->frame_end_wait, ch->frame_end);
fb_deferred_io_cleanup(ch->info);
ch->info->fbdefio = NULL;
sh_mobile_lcdc_clk_on(priv);
}
if (ch->bl) {
ch->bl->props.power = FB_BLANK_POWERDOWN;
backlight_update_status(ch->bl);
}
board_cfg = &ch->cfg.board_cfg;
if (board_cfg->display_off && try_module_get(board_cfg->owner)) {
board_cfg->display_off(board_cfg->board_data);
module_put(board_cfg->owner);
}
/* disable the meram */
if (ch->meram_enabled) {
struct sh_mobile_meram_cfg *cfg;
struct sh_mobile_meram_info *mdev;
cfg = ch->cfg.meram_cfg;
mdev = priv->meram_dev;
mdev->ops->meram_unregister(mdev, cfg);
ch->meram_enabled = 0;
}
}
/* stop the lcdc */
if (priv->started) {
sh_mobile_lcdc_start_stop(priv, 0);
priv->started = 0;
}
/* stop clocks */
for (k = 0; k < ARRAY_SIZE(priv->ch); k++)
if (priv->ch[k].enabled)
sh_mobile_lcdc_clk_off(priv);
}
static void s2c_backlight_earlyresume(struct early_suspend *desc)
{
struct s2c_bl_data *s2c = container_of(desc, struct s2c_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(s2c->pdev);
backlight_update_status(bl);
}
/*
* Called when the battery is low to limit the backlight intensity.
* If limit==0 clear any limit, otherwise limit the intensity
*/
void corgibl_limit_intensity(int limit)
{
if (limit)
corgibl_flags |= CORGIBL_BATTLOW;
else
corgibl_flags &= ~CORGIBL_BATTLOW;
backlight_update_status(corgi_backlight_device);
}
static int corgibl_resume(struct platform_device *pdev)
{
struct backlight_device *bd = platform_get_drvdata(pdev);
corgibl_flags &= ~CORGIBL_SUSPENDED;
backlight_update_status(bd);
return 0;
}
static int corgibl_suspend(struct platform_device *pdev, pm_message_t state)
{
struct backlight_device *bd = platform_get_drvdata(pdev);
corgibl_flags |= CORGIBL_SUSPENDED;
backlight_update_status(bd);
return 0;
}
static int da903x_backlight_resume(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct backlight_device *bl = platform_get_drvdata(pdev);
backlight_update_status(bl);
return 0;
}
static int bd60910_bl_resume(struct i2c_client *client)
{
struct bd60910_bl_data *data = i2c_get_clientdata(client);
TRACE_CALL() ;
backlight_update_status(data->bl);
return 0;
}
static int ktd259b_backlight_resume(struct platform_device *pdev)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
BLDBG("[BACKLIGHT] ktd259b_backlight_resume\n");
backlight_update_status(bl);
return 0;
}
void psb_backlight_exit(void)
{
#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
psb_backlight_device->props.brightness = 0;
backlight_update_status(psb_backlight_device);
backlight_device_unregister(psb_backlight_device);
#endif
return;
}
void corgi_lcd_limit_intensity(int limit)
{
if (limit)
corgibl_flags |= CORGIBL_BATTLOW;
else
corgibl_flags &= ~CORGIBL_BATTLOW;
backlight_update_status(the_corgi_lcd->bl_dev);
}
static int corgi_lcd_resume(struct spi_device *spi)
{
struct corgi_lcd *lcd = dev_get_drvdata(&spi->dev);
corgibl_flags &= ~CORGIBL_SUSPENDED;
corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK);
backlight_update_status(lcd->bl_dev);
return 0;
}
void fbtft_unregister_backlight(struct fbtft_par *par)
{
if (par->info->bl_dev) {
par->info->bl_dev->props.power = FB_BLANK_POWERDOWN;
backlight_update_status(par->info->bl_dev);
backlight_device_unregister(par->info->bl_dev);
par->info->bl_dev = NULL;
}
}
