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; } }