static int appledisplay_bl_update_status(struct backlight_device *bd) { struct appledisplay *pdata = bl_get_data(bd); int retval; pdata->msgdata[0] = 0x10; pdata->msgdata[1] = bd->props.brightness; retval = usb_control_msg( pdata->udev, usb_sndctrlpipe(pdata->udev, 0), USB_REQ_SET_REPORT, USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, ACD_USB_BRIGHTNESS, 0, pdata->msgdata, 2, ACD_USB_TIMEOUT); return retval; }
static int gen_panel_backlight_update_status(struct backlight_device *bd) { struct gen_panel_backlight_info *bl_info = (struct gen_panel_backlight_info *)bl_get_data(bd); int brightness = bd->props.brightness; if (unlikely(!bl_info)) { pr_err("%s, no platform data\n", __func__); return 0; } if (bd->props.power != FB_BLANK_UNBLANK || bd->props.fb_blank != FB_BLANK_UNBLANK || !bl_info->enable) brightness = 0; gen_panel_backlight_set_brightness(bl_info, brightness); return 0; }
static int lp855x_bl_update_status(struct backlight_device *bl) { struct lp855x *lp = bl_get_data(bl); if (bl->props.state & BL_CORE_SUSPENDED) bl->props.brightness = 0; if (lp->mode == PWM_BASED) { int br = bl->props.brightness; int max_br = bl->props.max_brightness; lp855x_pwm_ctrl(lp, br, max_br); } else if (lp->mode == REGISTER_BASED) { u8 val = bl->props.brightness; lp855x_write_byte(lp, lp->cfg->reg_brightness, val); } return 0; }
static int mipid_bl_update_status(struct backlight_device *bl) { u32 buf; int brightness = bl->props.brightness; struct mipi_dsi_info *mipi_dsi = bl_get_data(bl); if (bl->props.power != FB_BLANK_UNBLANK || bl->props.fb_blank != FB_BLANK_UNBLANK) brightness = 0; buf = HX8369_CMD_WRT_DISP_BRIGHT | ((brightness & HX8369BL_MAX_BRIGHT) << 8); mipi_dsi_pkt_write(mipi_dsi, MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM, &buf, 0); hx8369bl_brightness = brightness & HX8369BL_MAX_BRIGHT; dev_dbg(&bl->dev, "mipid backlight bringtness:%d.\n", brightness); return 0; }
void gen_panel_detach_backlight(struct lcd *lcd) { struct gen_panel_backlight_info *bl_info; if (!lcd->bd) { pr_err("%s, no backlight device\n", __func__); return; } bl_info = (struct gen_panel_backlight_info *)bl_get_data(lcd->bd); if (!bl_info) { pr_err("%s, no platform data\n", __func__); return; } mutex_lock(&bl_info->ops_lock); bl_info->ops = NULL; mutex_unlock(&bl_info->ops_lock); return; }
static int backlight_chip_update_status(struct backlight_device *bd) { struct fbtft_par *par = bl_get_data(bd); int brightness = bd->props.brightness; fbtft_par_dbg(DEBUG_BACKLIGHT, par, "%s: brightness=%d, power=%d, fb_blank=%d\n", __func__, bd->props.brightness, bd->props.power, bd->props.fb_blank); if (bd->props.power != FB_BLANK_UNBLANK) brightness = 0; if (bd->props.fb_blank != FB_BLANK_UNBLANK) brightness = 0; write_reg(par, CMD_LCD_LED, brightness); return 0; }
static int appledisplay_bl_get_brightness(struct backlight_device *bd) { struct appledisplay *pdata = bl_get_data(bd); int retval; retval = usb_control_msg( pdata->udev, usb_rcvctrlpipe(pdata->udev, 0), USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, ACD_USB_BRIGHTNESS, 0, pdata->msgdata, 2, ACD_USB_TIMEOUT); if (retval < 0) return retval; else return pdata->msgdata[1]; }
static int adp8860_bl_setup(struct backlight_device *bl) { struct adp8860_bl *data = bl_get_data(bl); struct i2c_client *client = data->client; struct adp8860_backlight_platform_data *pdata = data->pdata; int ret = 0; ret |= adp8860_write(client, ADP8860_BLSEN, ~pdata->bl_led_assign); ret |= adp8860_write(client, ADP8860_BLMX1, pdata->l1_daylight_max); ret |= adp8860_write(client, ADP8860_BLDM1, pdata->l1_daylight_dim); if (data->en_ambl_sens) { data->cached_daylight_max = pdata->l1_daylight_max; ret |= adp8860_write(client, ADP8860_BLMX2, pdata->l2_office_max); ret |= adp8860_write(client, ADP8860_BLDM2, pdata->l2_office_dim); ret |= adp8860_write(client, ADP8860_BLMX3, pdata->l3_dark_max); ret |= adp8860_write(client, ADP8860_BLDM3, pdata->l3_dark_dim); ret |= adp8860_write(client, ADP8860_L2_TRP, pdata->l2_trip); ret |= adp8860_write(client, ADP8860_L2_HYS, pdata->l2_hyst); ret |= adp8860_write(client, ADP8860_L3_TRP, pdata->l3_trip); ret |= adp8860_write(client, ADP8860_L3_HYS, pdata->l3_hyst); ret |= adp8860_write(client, ADP8860_CCFG, L2_EN | L3_EN | ALS_CCFG_VAL(pdata->abml_filt)); } ret |= adp8860_write(client, ADP8860_CFGR, BL_CFGR_VAL(pdata->bl_fade_law, 0)); ret |= adp8860_write(client, ADP8860_BLFR, FADE_VAL(pdata->bl_fade_in, pdata->bl_fade_out)); ret |= adp8860_set_bits(client, ADP8860_MDCR, BLEN | DIM_EN | NSTBY | (data->gdwn_dis ? GDWN_DIS : 0)); return ret; }
static int mdnie_set_brightness(struct backlight_device *bd) { struct mdnie_info *mdnie = bl_get_data(bd); int ret = 0; if (bd->props.brightness < MIN_BRIGHTNESS || bd->props.brightness > bd->props.max_brightness) { dev_err(&bd->dev, "lcd brightness should be %d to %d. now %d\n", MIN_BRIGHTNESS, bd->props.max_brightness, bd->props.brightness); bd->props.brightness = bd->props.max_brightness; } if ((mdnie->enable) && (mdnie->bd_enable)) { ret = update_brightness(mdnie); dev_info(&bd->dev, "brightness=%d\n", bd->props.brightness); if (ret < 0) return -EINVAL; } return ret; }
static int ws2401_dpi_set_brightness(struct backlight_device *bd) { int ret = 0, bl = bd->props.brightness; struct ws2401_dpi *lcd = bl_get_data(bd); if ((bl < MIN_BRIGHTNESS) || (bl > bd->props.max_brightness)) { dev_err(&bd->dev, "lcd brightness should be %d to %d.\n", MIN_BRIGHTNESS, bd->props.max_brightness); return -EINVAL; } if ((lcd->ldi_state) && (lcd->bd_enable) && (lcd->pd->bl_ctrl)) { ret = ws2401_update_brightness(lcd); dev_info(lcd->dev, "brightness=%d, bl=%d\n", bd->props.brightness, lcd->bl); if (ret < 0) dev_err(&bd->dev, "update brightness failed.\n"); } return ret; }
static int nva3_set_intensity(struct backlight_device *bd) { struct nouveau_encoder *nv_encoder = bl_get_data(bd); struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev); struct nvif_object *device = &drm->client.device.object; int or = ffs(nv_encoder->dcb->or) - 1; u32 div, val; div = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or)); val = (bd->props.brightness * div) / 100; if (div) { nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val | NV50_PDISP_SOR_PWM_CTL_NEW | NVA3_PDISP_SOR_PWM_CTL_UNK); return 0; } return -EINVAL; }
static int gmux_update_status(struct backlight_device *bd) { struct apple_gmux_data *gmux_data = bl_get_data(bd); u32 brightness = bd->props.brightness; if (bd->props.state & BL_CORE_SUSPENDED) return 0; /* * Older gmux versions require writing out lower bytes first then * setting the upper byte to 0 to flush the values. Newer versions * accept a single u32 write, but the old method also works, so we * just use the old method for all gmux versions. */ gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS, brightness); gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS + 1, brightness >> 8); gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS + 2, brightness >> 16); gmux_write8(gmux_data, GMUX_PORT_BRIGHTNESS + 3, 0); return 0; }
static int lp855x_bl_get_brightness(struct backlight_device *bl) { struct lp855x *lp = bl_get_data(bl); enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; if (mode == PWM_BASED) { struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; int max_br = bl->props.max_brightness; if (pd->pwm_get_intensity) bl->props.brightness = pd->pwm_get_intensity(max_br); } else if (mode == REGISTER_BASED) { u8 val = 0; lp855x_read_byte(lp, BRIGHTNESS_CTRL, &val); bl->props.brightness = val; } return (bl->props.brightness); }
static int atmel_pwm_bl_set_intensity(struct backlight_device *bd) { struct atmel_pwm_bl *pwmbl = bl_get_data(bd); int intensity = bd->props.brightness; int pwm_duty; if (bd->props.power != FB_BLANK_UNBLANK) intensity = 0; if (bd->props.fb_blank != FB_BLANK_UNBLANK) intensity = 0; if (pwmbl->pdata->pwm_active_low) pwm_duty = pwmbl->pdata->pwm_duty_min + intensity; else pwm_duty = pwmbl->pdata->pwm_duty_max - intensity; if (pwm_duty > pwmbl->pdata->pwm_duty_max) pwm_duty = pwmbl->pdata->pwm_duty_max; if (pwm_duty < pwmbl->pdata->pwm_duty_min) pwm_duty = pwmbl->pdata->pwm_duty_min; if (!intensity) { if (pwmbl->gpio_on != -1) { gpio_set_value(pwmbl->gpio_on, 0 ^ pwmbl->pdata->on_active_low); } pwm_channel_writel(&pwmbl->pwmc, PWM_CUPD, pwm_duty); pwm_channel_disable(&pwmbl->pwmc); } else { pwm_channel_enable(&pwmbl->pwmc); pwm_channel_writel(&pwmbl->pwmc, PWM_CUPD, pwm_duty); if (pwmbl->gpio_on != -1) { gpio_set_value(pwmbl->gpio_on, 1 ^ pwmbl->pdata->on_active_low); } } return 0; }
static int lm3630_bank_b_update_status(struct backlight_device *bl) { int ret; struct lm3630_chip_data *pchip = bl_get_data(bl); enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; if (pwm_ctrl == PWM_CTRL_BANK_B || pwm_ctrl == PWM_CTRL_BANK_ALL) { if (!set_intensity(bl, pchip)) dev_err(pchip->dev, "no pwm control func. in plat-data\n"); } else { ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00); if (ret < 0) goto out; mdelay(1); ret = regmap_write(pchip->regmap, REG_BRT_B, bl->props.brightness - 1); } return bl->props.brightness; out: dev_err(pchip->dev, "i2c failed to access register\n"); return bl->props.brightness; }
static int adp5520_bl_set(struct backlight_device *bl, int brightness) { struct adp5520_bl *data = bl_get_data(bl); struct device *master = data->master; int ret = 0; if (data->pdata->en_ambl_sens) { if ((brightness > 0) && (brightness < ADP5020_MAX_BRIGHTNESS)) { /* Disable Ambient Light auto adjust */ ret |= adp5520_clr_bits(master, ADP5520_BL_CONTROL, ADP5520_BL_AUTO_ADJ); ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX, brightness); } else { /* * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust * restore daylight l3 sysfs brightness */ ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX, data->cached_daylight_max); ret |= adp5520_set_bits(master, ADP5520_BL_CONTROL, ADP5520_BL_AUTO_ADJ); } } else { ret |= adp5520_write(master, ADP5520_DAYLIGHT_MAX, brightness); } if (data->current_brightness && brightness == 0) ret |= adp5520_set_bits(master, ADP5520_MODE_STATUS, ADP5520_DIM_EN); else if (data->current_brightness == 0 && brightness) ret |= adp5520_clr_bits(master, ADP5520_MODE_STATUS, ADP5520_DIM_EN); if (!ret) data->current_brightness = brightness; return ret; }
static int ssd1963_bl_update_status(struct backlight_device *bl) { struct ssd1963_backlight *ssd1963_bl = bl_get_data(bl); struct lcdreg *lcdreg = ssd1963_bl->lcdreg; // struct fbdbi_display *display = bl_get_data(bl); int brightness = bl->props.brightness; if (bl->props.power != FB_BLANK_UNBLANK || bl->props.fb_blank != FB_BLANK_UNBLANK || bl->props.state & BL_CORE_FBBLANK) brightness = 0; dev_info(&bl->dev, "%s(power=%i, fb_blank=%i, state=0x%x): brightness = %i\n", __func__, bl->props.power, bl->props.fb_blank, bl->props.state, brightness); lcdreg_lock(lcdreg); /* * Par1 PWM freq: 06h : PWM signal frequency = PLL clock / (256 * PWMF[7:0]) / 256 * Par2 PWM duty cycle: 0xf0: * Par3 C3=0 => PWM controlled by host * C0=1 => PWM enable * Par4 0xF0 DBC manual brightness * Par5 0x00 DBC minimum brightness * Par6 0x00 Brightness prescaler */ // write_reg(lcdreg, 0xBE, 0x06, 0xf0, 0x01, 0xf0, 0x00, 0x00); // write_reg(lcdreg, 0xBE, ssd1963_bl->pwmf, 0xf0, 0x01, 0xf0); // if (brightness) // write_reg(lcdreg, 0xBE, 0x06, 0xf0, 0x01, 0xf0, 0x00, 0x00); // else // write_reg(lcdreg, 0xBE, 0x06, 0x00, 0x01, 0xf0, 0x00, 0x00); lcdreg_writereg(lcdreg, 0xBE, 0x06, brightness, 0x01); lcdreg_unlock(lcdreg); return 0; }
static int pwm_backlight_update_status(struct backlight_device *bl) { struct pwm_bl_data *pb = bl_get_data(bl); int brightness = bl->props.brightness; int max = bl->props.max_brightness; if (bl->props.power != FB_BLANK_UNBLANK || bl->props.fb_blank != FB_BLANK_UNBLANK || bl->props.state & BL_CORE_FBBLANK) brightness = 0; if (pb->notify) brightness = pb->notify(pb->dev, brightness); if (brightness == 0) { pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } else { int duty_cycle; if (pb->levels) { duty_cycle = pb->levels[brightness]; max = pb->levels[max]; } else { duty_cycle = brightness; } duty_cycle = pb->lth_brightness + (duty_cycle * (pb->period - pb->lth_brightness) / max); pwm_config(pb->pwm, duty_cycle, pb->period); pwm_enable(pb->pwm); } if (pb->notify_after) pb->notify_after(pb->dev, brightness); return 0; }
int mrst_set_brightness(struct backlight_device *bd) { struct drm_device *dev = bl_get_data(psb_backlight_device); struct drm_psb_private *dev_priv = dev->dev_private; int level = bd->props.brightness; u32 blc_pwm_ctl; u32 max_pwm_blc; DRM_DEBUG_DRIVER("backlight level set to %d\n", level); /* Percentage 1-100% being valid */ if (level < 1) level = 1; if (gma_power_begin(dev, 0)) { /* Calculate and set the brightness value */ max_pwm_blc = REG_READ(BLC_PWM_CTL) >> 16; blc_pwm_ctl = level * max_pwm_blc / 100; /* Adjust the backlight level with the percent in * dev_priv->blc_adj1; */ blc_pwm_ctl = blc_pwm_ctl * dev_priv->blc_adj1; blc_pwm_ctl = blc_pwm_ctl / 100; /* Adjust the backlight level with the percent in * dev_priv->blc_adj2; */ blc_pwm_ctl = blc_pwm_ctl * dev_priv->blc_adj2; blc_pwm_ctl = blc_pwm_ctl / 100; if (blc_pol == BLC_POLARITY_INVERSE) blc_pwm_ctl = max_pwm_blc - blc_pwm_ctl; /* force PWM bit on */ REG_WRITE(BLC_PWM_CTL2, (0x80000000 | REG_READ(BLC_PWM_CTL2))); REG_WRITE(BLC_PWM_CTL, (max_pwm_blc << 16) | blc_pwm_ctl); gma_power_end(dev); }
/* update and get brightness */ static int lm3630_bank_a_update_status(struct backlight_device *bl) { int ret; struct lm3630_chip_data *pchip = bl_get_data(bl); enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl; /* brightness 0 means disable */ if (!bl->props.brightness) { ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x04, 0x00); if (ret < 0) goto out; return bl->props.brightness; } /* pwm control */ if (pwm_ctrl == PWM_CTRL_BANK_A || pwm_ctrl == PWM_CTRL_BANK_ALL) { if (!set_intensity(bl, pchip)) dev_err(pchip->dev, "No pwm control func. in plat-data\n"); } else { /* i2c control */ ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00); if (ret < 0) goto out; mdelay(1); ret = regmap_write(pchip->regmap, REG_BRT_A, bl->props.brightness - 1); if (ret < 0) goto out; } return bl->props.brightness; out: dev_err(pchip->dev, "i2c failed to access REG_CTRL\n"); return bl->props.brightness; }
static ssize_t auto_brightness_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int rc; struct backlight_device *bd = to_backlight_device(dev); struct gen_panel_backlight_info *bl_info = (struct gen_panel_backlight_info *)bl_get_data(bd); unsigned long value; rc = kstrtoul(buf, 0, &value); if (rc) return rc; mutex_lock(&bl_info->ops_lock); if (bl_info->auto_brightness != (unsigned int)value) { pr_info("%s, auto_brightness : %u\n", __func__, value); bl_info->auto_brightness = (unsigned int)value; } mutex_unlock(&bl_info->ops_lock); backlight_update_status(bd); return count; }
static int lv5207lp_backlight_update_status(struct backlight_device *backlight) { struct lv5207lp *lv = bl_get_data(backlight); int brightness = backlight->props.brightness; if (backlight->props.power != FB_BLANK_UNBLANK || backlight->props.fb_blank != FB_BLANK_UNBLANK || backlight->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK)) brightness = 0; if (brightness) { lv5207lp_write(lv, LV5207LP_CTRL1, LV5207LP_CPSW | LV5207LP_C10 | LV5207LP_CKSW); lv5207lp_write(lv, LV5207LP_CTRL2, LV5207LP_MSW | LV5207LP_MLED4 | (brightness - 1)); } else { lv5207lp_write(lv, LV5207LP_CTRL1, 0); lv5207lp_write(lv, LV5207LP_CTRL2, 0); } return 0; }
static int ana38401_set_brightness(struct backlight_device *bd) { int ret = 0; int brightness = bd->props.brightness; struct lcd_info *lcd = bl_get_data(bd); if (brightness < MIN_BRIGHTNESS || brightness > bd->props.max_brightness) { dev_err(&bd->dev, "lcd brightness should be %d to %d. now %d\n", MIN_BRIGHTNESS, lcd->bd->props.max_brightness, brightness); return -EINVAL; } if (lcd->ldi_enable) { ret = update_brightness(lcd, 0); if (ret < 0) { dev_err(&lcd->ld->dev, "err in %s\n", __func__); return -EINVAL; } } return ret; }
static int lp855x_bl_update_status(struct backlight_device *bl) { struct lp855x *lp = bl_get_data(bl); enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; if (bl->props.state & BL_CORE_SUSPENDED) bl->props.brightness = 0; if (mode == PWM_BASED) { struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; int br = bl->props.brightness; int max_br = bl->props.max_brightness; if (pd->pwm_set_intensity) pd->pwm_set_intensity(br, max_br); } else if (mode == REGISTER_BASED) { u8 val = bl->props.brightness; lp855x_write_byte(lp, BRIGHTNESS_CTRL, val); } return 0; }
static int s6e3ha2_set_brightness(struct backlight_device *bl_dev) { struct s6e3ha2 *ctx = bl_get_data(bl_dev); unsigned int brightness = bl_dev->props.brightness; int ret; if (brightness < S6E3HA2_MIN_BRIGHTNESS || brightness > bl_dev->props.max_brightness) { dev_err(ctx->dev, "Invalid brightness: %u\n", brightness); return -EINVAL; } if (bl_dev->props.power > FB_BLANK_NORMAL) return -EPERM; s6e3ha2_call_write_func(ret, s6e3ha2_test_key_on_f0(ctx)); s6e3ha2_call_write_func(ret, s6e3ha2_update_gamma(ctx, brightness)); s6e3ha2_call_write_func(ret, s6e3ha2_aor_control(ctx)); s6e3ha2_call_write_func(ret, s6e3ha2_set_vint(ctx)); s6e3ha2_call_write_func(ret, s6e3ha2_test_key_off_f0(ctx)); return 0; }
static int da903x_backlight_set(struct backlight_device *bl, int brightness) { struct da903x_backlight_data *data = bl_get_data(bl); struct device *dev = data->da903x_dev; uint8_t val; int ret = 0; switch (data->id) { case DA9034_ID_WLED: ret = da903x_update(dev, DA9034_WLED_CONTROL1, brightness, 0x7f); if (ret) return ret; if (data->current_brightness && brightness == 0) ret = da903x_clr_bits(dev, DA9034_WLED_CONTROL2, DA9034_WLED_BOOST_EN); if (data->current_brightness == 0 && brightness) ret = da903x_set_bits(dev, DA9034_WLED_CONTROL2, DA9034_WLED_BOOST_EN); break; case DA9030_ID_WLED: val = DA9030_WLED_TRIM(brightness); val |= brightness ? DA9030_WLED_CP_EN : 0; ret = da903x_write(dev, DA9030_WLED_CONTROL, val); break; } if (ret) return ret; data->current_brightness = brightness; return 0; }
static int adp8860_bl_set(struct backlight_device *bl, int brightness) { struct adp8860_bl *data = bl_get_data(bl); struct i2c_client *client = data->client; int ret = 0; if (data->en_ambl_sens) { if ((brightness > 0) && (brightness < ADP8860_MAX_BRIGHTNESS)) { /* Disable Ambient Light auto adjust */ ret |= adp8860_clr_bits(client, ADP8860_MDCR, CMP_AUTOEN); ret |= adp8860_write(client, ADP8860_BLMX1, brightness); } else { /* * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust * restore daylight l1 sysfs brightness */ ret |= adp8860_write(client, ADP8860_BLMX1, data->cached_daylight_max); ret |= adp8860_set_bits(client, ADP8860_MDCR, CMP_AUTOEN); } } else ret |= adp8860_write(client, ADP8860_BLMX1, brightness); if (data->current_brightness && brightness == 0) ret |= adp8860_set_bits(client, ADP8860_MDCR, DIM_EN); else if (data->current_brightness == 0 && brightness) ret |= adp8860_clr_bits(client, ADP8860_MDCR, DIM_EN); if (!ret) data->current_brightness = brightness; return ret; }
static int hva40wv1_set_brightness(struct backlight_device *bd) { int ret = 0; int brightness = bd->props.brightness; struct hva40wv1_lcd *lcd = bl_get_data(bd); dev_dbg(&bd->dev, "lcd set brightness called with %d\n", brightness); if ((brightness < 0) || (brightness > bd->props.max_brightness)) { dev_err(&bd->dev, "lcd brightness should be 0 to %d.\n", bd->props.max_brightness); return -EINVAL; } mutex_lock(&lcd->lock); if (lcd->ddev->power_mode != MCDE_DISPLAY_PM_OFF) { ret = hva40wv1_update_brightness(lcd->ddev, brightness); if (ret) { dev_err(&bd->dev, "lcd brightness setting failed.\n"); return -EIO; } if (lcd->pd->bl_en_gpio != -1) gpio_set_value(lcd->pd->bl_en_gpio, 1); } else if (lcd->pd->bl_en_gpio != -1) { gpio_set_value(lcd->pd->bl_en_gpio, 0); } lcd->current_brightness = brightness; mutex_unlock(&lcd->lock); return ret; }
static int lp855x_bl_update_status(struct backlight_device *bl) { struct lp855x *lp = bl_get_data(bl); enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; int br; static int stored_br; mutex_lock(&lp->xfer_lock); if (bl->props.state & BL_CORE_SUSPENDED) bl->props.brightness = 0; br = bl->props.brightness; if (bl->props.state & BL_CORE_FBBLANK) br = 0; if (!br && stored_br) (void)lp855x_set_slope_filter(lp, false); else if (br && !stored_br) (void)lp855x_set_slope_filter(lp, true); stored_br = br; if (mode == PWM_BASED) { struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; int max_br = bl->props.max_brightness; if (pd->pwm_set_intensity) pd->pwm_set_intensity(br, max_br); } else if (mode == REGISTER_BASED) lp855x_write_byte(lp, BRIGHTNESS_CTRL, br); mutex_unlock(&lp->xfer_lock); return br; }
static int mfld_set_brightness(struct backlight_device *bd) { struct drm_device *dev = bl_get_data(mdfld_backlight_device); struct drm_psb_private *dev_priv = dev->dev_private; int level = bd->props.brightness; /* Percentage 1-100% being valid */ if (level < 1) level = 1; if (gma_power_begin(dev, 0)) { /* Calculate and set the brightness value */ u32 adjusted_level; /* Adjust the backlight level with the percent in * dev_priv->blc_adj2; */ adjusted_level = level * dev_priv->blc_adj2; adjusted_level = adjusted_level / 100; #if 0 #ifndef CONFIG_MDFLD_DSI_DPU if(!(dev_priv->dsr_fb_update & MDFLD_DSR_MIPI_CONTROL) && (dev_priv->dbi_panel_on || dev_priv->dbi_panel_on2)){ mdfld_dsi_dbi_exit_dsr(dev,MDFLD_DSR_MIPI_CONTROL, 0, 0); dev_dbg(dev->dev, "Out of DSR before set brightness to %d.\n",adjusted_level); } #endif mdfld_dsi_brightness_control(dev, 0, adjusted_level); if ((dev_priv->dbi_panel_on2) || (dev_priv->dpi_panel_on2)) mdfld_dsi_brightness_control(dev, 2, adjusted_level); #endif gma_power_end(dev); } mdfld_brightness = level; return 0; }