static int __devinit adp8870_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct backlight_device *bl; struct adp8870_bl *data; struct adp8870_backlight_platform_data *pdata = client->dev.platform_data; uint8_t reg_val; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); return -EIO; } if (!pdata) { dev_err(&client->dev, "no platform data?\n"); return -EINVAL; } ret = adp8870_read(client, ADP8870_MFDVID, ®_val); if (ret < 0) return -EIO; if (ADP8870_MANID(reg_val) != ADP8870_MANUFID) { dev_err(&client->dev, "failed to probe\n"); return -ENODEV; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; data->revid = ADP8870_DEVID(reg_val); data->client = client; data->pdata = pdata; data->id = id->driver_data; data->current_brightness = 0; i2c_set_clientdata(client, data); mutex_init(&data->lock); bl = backlight_device_register(dev_driver_string(&client->dev), &client->dev, data, &adp8870_bl_ops); if (IS_ERR(bl)) { dev_err(&client->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); goto out2; } bl->props.max_brightness = bl->props.brightness = ADP8870_MAX_BRIGHTNESS; data->bl = bl; if (pdata->en_ambl_sens) ret = sysfs_create_group(&bl->dev.kobj, &adp8870_bl_attr_group); if (ret) { dev_err(&client->dev, "failed to register sysfs\n"); goto out1; } ret = adp8870_bl_setup(bl); if (ret) { ret = -EIO; goto out; } dev_info(&client->dev, "Rev.%d Backlight\n", data->revid); if (pdata->num_leds) adp8870_led_probe(client); return 0; out: if (data->pdata->en_ambl_sens) sysfs_remove_group(&data->bl->dev.kobj, &adp8870_bl_attr_group); out1: backlight_device_unregister(bl); out2: i2c_set_clientdata(client, NULL); kfree(data); return ret; }
void psb_intel_panel_destroy_backlight(struct drm_device *dev) { struct drm_psb_private *dev_priv = dev->dev_private; if (dev_priv->backlight) backlight_device_unregister(dev_priv->backlight); }
static int __init atmel_pwm_bl_probe(struct platform_device *pdev) { struct backlight_properties props; const struct atmel_pwm_bl_platform_data *pdata; struct backlight_device *bldev; struct atmel_pwm_bl *pwmbl; int retval; pwmbl = devm_kzalloc(&pdev->dev, sizeof(struct atmel_pwm_bl), GFP_KERNEL); if (!pwmbl) return -ENOMEM; pwmbl->pdev = pdev; pdata = pdev->dev.platform_data; if (!pdata) { retval = -ENODEV; goto err_free_mem; } if (pdata->pwm_compare_max < pdata->pwm_duty_max || pdata->pwm_duty_min > pdata->pwm_duty_max || pdata->pwm_frequency == 0) { retval = -EINVAL; goto err_free_mem; } pwmbl->pdata = pdata; pwmbl->gpio_on = pdata->gpio_on; retval = pwm_channel_alloc(pdata->pwm_channel, &pwmbl->pwmc); if (retval) goto err_free_mem; if (pwmbl->gpio_on != -1) { retval = devm_gpio_request(&pdev->dev, pwmbl->gpio_on, "gpio_atmel_pwm_bl"); if (retval) { pwmbl->gpio_on = -1; goto err_free_pwm; } /* Turn display off by default. */ retval = gpio_direction_output(pwmbl->gpio_on, 0 ^ pdata->on_active_low); if (retval) goto err_free_pwm; } memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min; bldev = backlight_device_register("atmel-pwm-bl", &pdev->dev, pwmbl, &atmel_pwm_bl_ops, &props); if (IS_ERR(bldev)) { retval = PTR_ERR(bldev); goto err_free_pwm; } pwmbl->bldev = bldev; platform_set_drvdata(pdev, pwmbl); /* Power up the backlight by default at middle intesity. */ bldev->props.power = FB_BLANK_UNBLANK; bldev->props.brightness = bldev->props.max_brightness / 2; retval = atmel_pwm_bl_init_pwm(pwmbl); if (retval) goto err_free_bl_dev; atmel_pwm_bl_set_intensity(bldev); return 0; err_free_bl_dev: platform_set_drvdata(pdev, NULL); backlight_device_unregister(bldev); err_free_pwm: pwm_channel_free(&pwmbl->pwmc); err_free_mem: return retval; }
static int __init msi_init(void) { int ret; if (acpi_disabled) return -ENODEV; dmi_check_system(msi_dmi_table); if (!quirks) /* quirks may be NULL if no match in DMI table */ quirks = &quirk_load_scm_model; if (force) quirks = &quirk_old_ec_model; if (!quirks->old_ec_model) get_threeg_exists(); if (auto_brightness < 0 || auto_brightness > 2) return -EINVAL; /* Register backlight stuff */ if (!quirks->old_ec_model || acpi_video_backlight_support()) { pr_info("Brightness ignored, must be controlled by ACPI video driver\n"); } else { struct backlight_properties props; memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_PLATFORM; props.max_brightness = MSI_LCD_LEVEL_MAX - 1; msibl_device = backlight_device_register("msi-laptop-bl", NULL, NULL, &msibl_ops, &props); if (IS_ERR(msibl_device)) return PTR_ERR(msibl_device); } ret = platform_driver_register(&msipf_driver); if (ret) goto fail_backlight; /* Register platform stuff */ msipf_device = platform_device_alloc("msi-laptop-pf", -1); if (!msipf_device) { ret = -ENOMEM; goto fail_platform_driver; } ret = platform_device_add(msipf_device); if (ret) goto fail_platform_device1; if (quirks->load_scm_model && (load_scm_model_init(msipf_device) < 0)) { ret = -EINVAL; goto fail_platform_device1; } ret = sysfs_create_group(&msipf_device->dev.kobj, &msipf_attribute_group); if (ret) goto fail_platform_device2; if (!quirks->old_ec_model) { if (threeg_exists) ret = device_create_file(&msipf_device->dev, &dev_attr_threeg); if (ret) goto fail_platform_device2; } else { ret = sysfs_create_group(&msipf_device->dev.kobj, &msipf_old_attribute_group); if (ret) goto fail_platform_device2; /* Disable automatic brightness control by default because * this module was probably loaded to do brightness control in * software. */ if (auto_brightness != 2) set_auto_brightness(auto_brightness); } pr_info("driver " MSI_DRIVER_VERSION " successfully loaded\n"); return 0; fail_platform_device2: if (quirks->load_scm_model) { i8042_remove_filter(msi_laptop_i8042_filter); cancel_delayed_work_sync(&msi_rfkill_dwork); cancel_work_sync(&msi_rfkill_work); rfkill_cleanup(); } platform_device_del(msipf_device); fail_platform_device1: platform_device_put(msipf_device); fail_platform_driver: platform_driver_unregister(&msipf_driver); fail_backlight: backlight_device_unregister(msibl_device); return ret; }
static int cr_backlight_probe(struct platform_device *pdev) { struct backlight_properties props; struct backlight_device *bdp; struct lcd_device *ldp; struct cr_panel *crp; u8 dev_en; lpc_dev = pci_get_device(PCI_VENDOR_ID_INTEL, CRVML_DEVICE_LPC, NULL); if (!lpc_dev) { pr_err("INTEL CARILLO RANCH LPC not found.\n"); return -ENODEV; } pci_read_config_byte(lpc_dev, CRVML_REG_GPIOEN, &dev_en); if (!(dev_en & CRVML_GPIOEN_BIT)) { pr_err("Carillo Ranch GPIO device was not enabled.\n"); pci_dev_put(lpc_dev); return -ENODEV; } memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; bdp = backlight_device_register("cr-backlight", &pdev->dev, NULL, &cr_backlight_ops, &props); if (IS_ERR(bdp)) { pci_dev_put(lpc_dev); return PTR_ERR(bdp); } ldp = lcd_device_register("cr-lcd", &pdev->dev, NULL, &cr_lcd_ops); if (IS_ERR(ldp)) { backlight_device_unregister(bdp); pci_dev_put(lpc_dev); return PTR_ERR(ldp); } pci_read_config_dword(lpc_dev, CRVML_REG_GPIOBAR, &gpio_bar); gpio_bar &= ~0x3F; crp = devm_kzalloc(&pdev->dev, sizeof(*crp), GFP_KERNEL); if (!crp) { lcd_device_unregister(ldp); backlight_device_unregister(bdp); pci_dev_put(lpc_dev); return -ENOMEM; } crp->cr_backlight_device = bdp; crp->cr_lcd_device = ldp; crp->cr_backlight_device->props.power = FB_BLANK_UNBLANK; crp->cr_backlight_device->props.brightness = 0; cr_backlight_set_intensity(crp->cr_backlight_device); cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_UNBLANK); platform_set_drvdata(pdev, crp); return 0; }
static void asus_backlight_exit(struct asus_laptop *asus) { if (asus->backlight_device) backlight_device_unregister(asus->backlight_device); asus->backlight_device = NULL; }
static void oaktrail_backlight_exit(void) { backlight_device_unregister(oaktrail_bl_device); }
static int pm860x_backlight_probe(struct platform_device *pdev) { struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent); struct pm860x_platform_data *pm860x_pdata; struct pm860x_backlight_pdata *pdata = NULL; struct pm860x_backlight_data *data; struct backlight_device *bl; struct resource *res; struct backlight_properties props; unsigned char value; char name[MFD_NAME_SIZE]; int ret; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource!\n"); return -EINVAL; } if (pdev->dev.parent->platform_data) { pm860x_pdata = pdev->dev.parent->platform_data; pdata = pm860x_pdata->backlight; } if (pdata == NULL) { dev_err(&pdev->dev, "platform data isn't assigned to " "backlight\n"); return -EINVAL; } data = kzalloc(sizeof(struct pm860x_backlight_data), GFP_KERNEL); if (data == NULL) return -ENOMEM; strncpy(name, res->name, MFD_NAME_SIZE); data->chip = chip; data->i2c = (chip->id == CHIP_PM8606) ? chip->client \ : chip->companion; data->current_brightness = MAX_BRIGHTNESS; data->pwm = pdata->pwm; data->iset = pdata->iset; data->port = __check_device(pdata, name); if (data->port < 0) { dev_err(&pdev->dev, "wrong platform data is assigned"); kfree(data); return -EINVAL; } memset(&props, 0, sizeof(struct backlight_properties)); props.max_brightness = MAX_BRIGHTNESS; bl = backlight_device_register(name, &pdev->dev, data, &pm860x_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); kfree(data); return PTR_ERR(bl); } bl->props.brightness = MAX_BRIGHTNESS; platform_set_drvdata(pdev, bl); /* Enable reference VSYS */ ret = pm860x_reg_read(data->i2c, PM8606_VSYS); if (ret < 0) goto out; if ((ret & PM8606_VSYS_EN) == 0) { value = ret | PM8606_VSYS_EN; ret = pm860x_reg_write(data->i2c, PM8606_VSYS, value); if (ret < 0) goto out; } /* Enable reference OSC */ ret = pm860x_reg_read(data->i2c, PM8606_MISC); if (ret < 0) goto out; if ((ret & PM8606_MISC_OSC_EN) == 0) { value = ret | PM8606_MISC_OSC_EN; ret = pm860x_reg_write(data->i2c, PM8606_MISC, value); if (ret < 0) goto out; } /* read current backlight */ ret = pm860x_backlight_get_brightness(bl); if (ret < 0) goto out; backlight_update_status(bl); return 0; out: backlight_device_unregister(bl); kfree(data); return ret; }
static void lp855x_backlight_unregister(struct lp855x *lp) { if (lp->bl) backlight_device_unregister(lp->bl); }
static int __devinit max8925_backlight_probe(struct platform_device *pdev) { struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent); struct max8925_platform_data *max8925_pdata; struct max8925_backlight_pdata *pdata = NULL; struct max8925_backlight_data *data; struct backlight_device *bl; struct backlight_properties props; struct resource *res; char name[MAX8925_NAME_SIZE]; unsigned char value; int ret; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource!\n"); return -EINVAL; } if (pdev->dev.parent->platform_data) { max8925_pdata = pdev->dev.parent->platform_data; pdata = max8925_pdata->backlight; } if (!pdata) { dev_err(&pdev->dev, "platform data isn't assigned to " "backlight\n"); return -EINVAL; } data = kzalloc(sizeof(struct max8925_backlight_data), GFP_KERNEL); if (data == NULL) return -ENOMEM; strncpy(name, res->name, MAX8925_NAME_SIZE); data->chip = chip; data->current_brightness = 0; memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = MAX_BRIGHTNESS; bl = backlight_device_register(name, &pdev->dev, data, &max8925_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); kfree(data); return PTR_ERR(bl); } bl->props.brightness = MAX_BRIGHTNESS; platform_set_drvdata(pdev, bl); value = 0; if (pdata->lxw_scl) value |= (1 << 7); if (pdata->lxw_freq) value |= (LWX_FREQ(pdata->lxw_freq) << 4); if (pdata->dual_string) value |= (1 << 1); ret = max8925_set_bits(chip->i2c, MAX8925_WLED_MODE_CNTL, 0xfe, value); if (ret < 0) goto out; backlight_update_status(bl); return 0; out: backlight_device_unregister(bl); kfree(data); return ret; }
static int pm860x_backlight_probe(struct platform_device *pdev) { struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent); struct pm860x_backlight_pdata *pdata = NULL; struct pm860x_backlight_data *data; struct backlight_device *bl; struct resource *res; struct backlight_properties props; char name[MFD_NAME_SIZE]; int ret; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource!\n"); return -EINVAL; } pdata = pdev->dev.platform_data; if (pdata == NULL) { dev_err(&pdev->dev, "platform data isn't assigned to " "backlight\n"); return -EINVAL; } data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_backlight_data), GFP_KERNEL); if (data == NULL) return -ENOMEM; strncpy(name, res->name, MFD_NAME_SIZE); data->chip = chip; data->i2c = (chip->id == CHIP_PM8606) ? chip->client \ : chip->companion; data->current_brightness = MAX_BRIGHTNESS; data->pwm = pdata->pwm; data->iset = pdata->iset; data->port = pdata->flags; if (data->port < 0) { dev_err(&pdev->dev, "wrong platform data is assigned"); return -EINVAL; } memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = MAX_BRIGHTNESS; bl = backlight_device_register(name, &pdev->dev, data, &pm860x_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); return PTR_ERR(bl); } bl->props.brightness = MAX_BRIGHTNESS; platform_set_drvdata(pdev, bl); ret = pm860x_backlight_get_brightness(bl); if (ret < 0) goto out; backlight_update_status(bl); return 0; out: backlight_device_unregister(bl); return ret; }
static int acx565akm_probe(struct spi_device *spi) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; struct backlight_device *bldev; int max_brightness, brightness; struct backlight_properties props; int r; dev_dbg(&spi->dev, "%s\n", __func__); spi->mode = SPI_MODE_3; ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); if (ddata == NULL) return -ENOMEM; dev_set_drvdata(&spi->dev, ddata); ddata->spi = spi; mutex_init(&ddata->mutex); if (dev_get_platdata(&spi->dev)) { r = acx565akm_probe_pdata(spi); if (r) return r; } else if (spi->dev.of_node) { r = acx565akm_probe_of(spi); if (r) return r; } else { dev_err(&spi->dev, "platform data missing!\n"); return -ENODEV; } if (gpio_is_valid(ddata->reset_gpio)) { r = devm_gpio_request_one(&spi->dev, ddata->reset_gpio, GPIOF_OUT_INIT_LOW, "lcd reset"); if (r) goto err_gpio; } if (gpio_is_valid(ddata->reset_gpio)) gpio_set_value(ddata->reset_gpio, 1); /* * After reset we have to wait 5 msec before the first * command can be sent. */ usleep_range(5000, 10000); ddata->enabled = panel_enabled(ddata); r = panel_detect(ddata); if (!ddata->enabled && gpio_is_valid(ddata->reset_gpio)) gpio_set_value(ddata->reset_gpio, 0); if (r) { dev_err(&spi->dev, "%s panel detect error\n", __func__); goto err_detect; } memset(&props, 0, sizeof(props)); props.fb_blank = FB_BLANK_UNBLANK; props.power = FB_BLANK_UNBLANK; props.type = BACKLIGHT_RAW; bldev = backlight_device_register("acx565akm", &ddata->spi->dev, ddata, &acx565akm_bl_ops, &props); if (IS_ERR(bldev)) { r = PTR_ERR(bldev); goto err_reg_bl; } ddata->bl_dev = bldev; if (ddata->has_cabc) { r = sysfs_create_group(&bldev->dev.kobj, &bldev_attr_group); if (r) { dev_err(&bldev->dev, "%s failed to create sysfs files\n", __func__); goto err_sysfs; } ddata->cabc_mode = get_hw_cabc_mode(ddata); } max_brightness = 255; if (ddata->has_bc) brightness = acx565akm_get_actual_brightness(ddata); else brightness = 0; bldev->props.max_brightness = max_brightness; bldev->props.brightness = brightness; acx565akm_bl_update_status(bldev); ddata->videomode = acx565akm_panel_timings; dssdev = &ddata->dssdev; dssdev->dev = &spi->dev; dssdev->driver = &acx565akm_ops; dssdev->type = OMAP_DISPLAY_TYPE_SDI; dssdev->owner = THIS_MODULE; dssdev->panel.timings = ddata->videomode; r = omapdss_register_display(dssdev); if (r) { dev_err(&spi->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: sysfs_remove_group(&bldev->dev.kobj, &bldev_attr_group); err_sysfs: backlight_device_unregister(bldev); err_reg_bl: err_detect: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int __devinit ws2401_dpi_mcde_panel_probe( struct mcde_display_device *ddev) { int ret = 0; struct ws2401_dpi *lcd = NULL; struct backlight_device *bd = NULL; struct ssg_dpi_display_platform_data *pdata = ddev->dev.platform_data; dev_dbg(&ddev->dev, "Invoked %s\n", __func__); if (pdata == NULL) { dev_err(&ddev->dev, "%s:Platform data missing\n", __func__); ret = -EINVAL; goto no_pdata; } if (ddev->port->type != MCDE_PORTTYPE_DPI) { dev_err(&ddev->dev, "%s:Invalid port type %d\n", __func__, ddev->port->type); ret = -EINVAL; goto invalid_port_type; } ddev->prepare_for_update = NULL; ddev->try_video_mode = try_video_mode; ddev->set_video_mode = set_video_mode; lcd = kzalloc(sizeof(struct ws2401_dpi), GFP_KERNEL); if (!lcd) return -ENOMEM; mutex_init(&lcd->lock); dev_set_drvdata(&ddev->dev, lcd); lcd->mdd = ddev; lcd->dev = &ddev->dev; lcd->pd = pdata; #ifdef CONFIG_LCD_CLASS_DEVICE lcd->ld = lcd_device_register("panel", &ddev->dev, lcd, &ws2401_dpi_lcd_ops); if (IS_ERR(lcd->ld)) { ret = PTR_ERR(lcd->ld); goto out_free_lcd; } else { ret = device_create_file(&(lcd->ld->dev), &dev_attr_panel_type); if (ret < 0) dev_err(&(lcd->ld->dev), "failed to add panel_type sysfs entries\n"); ret = device_create_file(&(lcd->ld->dev), &dev_attr_panel_id); if (ret < 0) dev_err(&(lcd->ld->dev), "failed to add panel_id sysfs entries\n"); } #endif mutex_init(&lcd->lock); if (pdata->bl_ctrl) { bd = backlight_device_register("pwm-backlight", &ddev->dev, lcd, &ws2401_dpi_backlight_ops, NULL); if (IS_ERR(bd)) { ret = PTR_ERR(bd); goto out_backlight_unregister; } lcd->bd = bd; lcd->bd_enable = TRUE; lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; } ret = device_create_file(&(ddev->dev), &dev_attr_lcd_power); if (ret < 0) dev_err(&(ddev->dev), "failed to add lcd_power sysfs entries\n"); lcd->spi_drv.driver.name = "pri_lcd_spi"; lcd->spi_drv.driver.bus = &spi_bus_type; lcd->spi_drv.driver.owner = THIS_MODULE; lcd->spi_drv.probe = ws2401_dpi_spi_probe; ret = spi_register_driver(&lcd->spi_drv); if (ret < 0) { dev_err(&(ddev->dev), "Failed to register SPI driver"); goto out_backlight_unregister; } #ifdef CONFIG_HAS_EARLYSUSPEND lcd->earlysuspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; lcd->earlysuspend.suspend = ws2401_dpi_mcde_panel_early_suspend; lcd->earlysuspend.resume = ws2401_dpi_mcde_panel_late_resume; register_early_suspend(&lcd->earlysuspend); #endif ws2401_update_brightness(lcd); if (prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "codina_lcd_dpi", 100)) { pr_info("pcrm_qos_add APE failed\n"); } dev_dbg(&ddev->dev, "DPI display probed\n"); goto out; out_backlight_unregister: if (pdata->bl_ctrl) backlight_device_unregister(bd); out_free_lcd: mutex_destroy(&lcd->lock); kfree(lcd); invalid_port_type: no_pdata: out: return ret; }
static int __devinit lm3530_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *id) { struct backlight_platform_data *pdata; struct lm3530_device *dev; struct backlight_device *bl_dev; struct backlight_properties props; int err = 0; pdata = i2c_dev->dev.platform_data; if (!pdata) return -ENODEV; dev = kzalloc(sizeof(struct lm3530_device), GFP_KERNEL); if (!dev) { dev_err(&i2c_dev->dev, "out of memory\n"); return -ENOMEM; } memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = pdata->max_brightness; bl_dev = backlight_device_register(I2C_BL_NAME, &i2c_dev->dev, NULL, &lm3530_bl_ops, &props); if (IS_ERR(bl_dev)) { dev_err(&i2c_dev->dev, "failed to register backlight\n"); err = PTR_ERR(bl_dev); goto err_backlight_device_register; } bl_dev->props.max_brightness = pdata->max_brightness; bl_dev->props.brightness = pdata->default_brightness; bl_dev->props.power = FB_BLANK_UNBLANK; dev->bl_dev = bl_dev; dev->client = i2c_dev; dev->gpio = pdata->gpio; dev->max_current = pdata->max_current; dev->min_brightness = pdata->min_brightness; dev->max_brightness = pdata->max_brightness; dev->default_brightness = pdata->default_brightness; dev->blmap = pdata->blmap; dev->blmap_size = pdata->blmap_size; i2c_set_clientdata(i2c_dev, dev); br_mode = 1; min_br = dev->min_brightness; max_br = dev->max_brightness; if (gpio_is_valid(dev->gpio)) { err = gpio_request(dev->gpio, "lm3530 reset"); if (err < 0) { dev_err(&i2c_dev->dev, "failed to request gpio\n"); goto err_gpio_request; } } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3530_level); if (err < 0) { dev_err(&i2c_dev->dev, "failed to create 1st sysfs\n"); goto err_device_create_file_1; } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3530_backlight_on_off); if (err < 0) { dev_err(&i2c_dev->dev, "failed to create 2nd sysfs\n"); goto err_device_create_file_2; } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3530_pwm); if (err < 0) { dev_err(&i2c_dev->dev, "failed to create 3rd sysfs\n"); goto err_device_create_file_3; } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3530_min_br); if (err < 0) { dev_err(&i2c_dev->dev, "failed to create 3nd sysfs\n"); goto err_device_create_file_4; } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3530_max_br); if (err < 0) { dev_err(&i2c_dev->dev, "failed to create 4nd sysfs\n"); goto err_device_create_file_5; } err = device_create_file(&i2c_dev->dev, &dev_attr_lm3530_br_mode); if (err < 0) { dev_err(&i2c_dev->dev, "failed to create 5nd sysfs\n"); goto err_device_create_file_6; } lm3530_i2c_client = i2c_dev; pr_info("lm3530 probed\n"); return 0; err_device_create_file_6: device_remove_file(&i2c_dev->dev, &dev_attr_lm3530_max_br); err_device_create_file_5: device_remove_file(&i2c_dev->dev, &dev_attr_lm3530_min_br); err_device_create_file_4: device_remove_file(&i2c_dev->dev, &dev_attr_lm3530_pwm); err_device_create_file_3: device_remove_file(&i2c_dev->dev, &dev_attr_lm3530_backlight_on_off); err_device_create_file_2: device_remove_file(&i2c_dev->dev, &dev_attr_lm3530_level); err_device_create_file_1: if (gpio_is_valid(dev->gpio)) gpio_free(dev->gpio); err_gpio_request: backlight_device_unregister(bl_dev); err_backlight_device_register: kfree(dev); return err; }
static int lm3639_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct lm3639_chip_data *pchip; struct lm3639_platform_data *pdata = client->dev.platform_data; struct backlight_properties props; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "i2c functionality check fail.\n"); return -EOPNOTSUPP; } if (pdata == NULL) { dev_err(&client->dev, "Needs Platform Data.\n"); return -ENODATA; } pchip = devm_kzalloc(&client->dev, sizeof(struct lm3639_chip_data), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->pdata = pdata; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail : allocate register map: %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); /* chip initialize */ ret = lm3639_chip_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail : chip init\n"); goto err_out; } /* backlight */ props.type = BACKLIGHT_RAW; props.brightness = pdata->init_brt_led; props.max_brightness = pdata->max_brt_led; pchip->bled = backlight_device_register("lm3639_bled", pchip->dev, pchip, &lm3639_bled_ops, &props); if (IS_ERR(pchip->bled)) { dev_err(&client->dev, "fail : backlight register\n"); ret = -EIO; goto err_out; } ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode); if (ret < 0) { dev_err(&client->dev, "failed : add sysfs entries\n"); ret = -EIO; goto err_bled_mode; } /* flash */ pchip->cdev_flash.name = "lm3639_flash"; pchip->cdev_flash.max_brightness = 16; pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_flash); if (ret < 0) { dev_err(&client->dev, "fail : flash register\n"); ret = -EIO; goto err_flash; } /* torch */ pchip->cdev_torch.name = "lm3639_torch"; pchip->cdev_torch.max_brightness = 8; pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set; ret = led_classdev_register((struct device *) &client->dev, &pchip->cdev_torch); if (ret < 0) { dev_err(&client->dev, "fail : torch register\n"); ret = -EIO; goto err_torch; } return 0; err_torch: led_classdev_unregister(&pchip->cdev_flash); err_flash: device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode); err_bled_mode: backlight_device_unregister(pchip->bled); err_out: return ret; }
static int __devinit adp8860_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct backlight_device *bl; struct adp8860_bl *data; struct adp8860_backlight_platform_data *pdata = client->dev.platform_data; struct backlight_properties props; uint8_t reg_val; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); return -EIO; } if (!pdata) { dev_err(&client->dev, "no platform data?\n"); return -EINVAL; } data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; ret = adp8860_read(client, ADP8860_MFDVID, ®_val); if (ret < 0) return ret; switch (ADP8860_MANID(reg_val)) { case ADP8863_MANUFID: data->gdwn_dis = !!pdata->gdwn_dis; case ADP8860_MANUFID: data->en_ambl_sens = !!pdata->en_ambl_sens; break; case ADP8861_MANUFID: data->gdwn_dis = !!pdata->gdwn_dis; break; default: dev_err(&client->dev, "failed to probe\n"); return -ENODEV; } /* It's confirmed that the DEVID field is actually a REVID */ data->revid = ADP8860_DEVID(reg_val); data->client = client; data->pdata = pdata; data->id = id->driver_data; data->current_brightness = 0; i2c_set_clientdata(client, data); memset(&props, 0, sizeof(props)); props.type = BACKLIGHT_RAW; props.max_brightness = ADP8860_MAX_BRIGHTNESS; mutex_init(&data->lock); bl = backlight_device_register(dev_driver_string(&client->dev), &client->dev, data, &adp8860_bl_ops, &props); if (IS_ERR(bl)) { dev_err(&client->dev, "failed to register backlight\n"); return PTR_ERR(bl); } bl->props.brightness = ADP8860_MAX_BRIGHTNESS; data->bl = bl; if (data->en_ambl_sens) ret = sysfs_create_group(&bl->dev.kobj, &adp8860_bl_attr_group); if (ret) { dev_err(&client->dev, "failed to register sysfs\n"); goto out1; } ret = adp8860_bl_setup(bl); if (ret) { ret = -EIO; goto out; } backlight_update_status(bl); dev_info(&client->dev, "%s Rev.%d Backlight\n", client->name, data->revid); if (pdata->num_leds) adp8860_led_probe(client); return 0; out: if (data->en_ambl_sens) sysfs_remove_group(&data->bl->dev.kobj, &adp8860_bl_attr_group); out1: backlight_device_unregister(bl); return ret; }
static int __devinit ws2401_probe(struct mcde_display_device *ddev) { int ret = 0; struct ws2401_platform_data *pdata = ddev->dev.platform_data; struct backlight_device *bd = NULL; struct ws2401_lcd *lcd = NULL; dev_dbg(&ddev->dev, "%s function entered\n", __func__); if (pdata == NULL) { dev_err(&ddev->dev, "%s:Platform data missing\n", __func__); return -EINVAL; } if (ddev->port->type != MCDE_PORTTYPE_DSI) { dev_err(&ddev->dev, "%s:Invalid port type %d\n", __func__, ddev->port->type); return -EINVAL; } ddev->prepare_for_update = NULL; ddev->update = ws2401_update; ddev->try_video_mode = ws2401_try_video_mode; ddev->set_video_mode = ws2401_set_video_mode; if (pdata->reset_gpio) { ret = gpio_request(pdata->reset_gpio, "LCD Reset"); if (ret) { dev_warn(&ddev->dev, "%s:Failed to request gpio %d\n", __func__, pdata->reset_gpio); goto request_reset_gpio_failed; } gpio_direction_output(pdata->reset_gpio, !pdata->reset_high); } if (pdata->power_on_gpio) { ret = gpio_request(pdata->power_on_gpio, "LCD LDO EN"); if (ret) { dev_warn(&ddev->dev, "%s:Failed to request gpio %d\n", __func__, pdata->power_on_gpio); goto request_power_on_gpio_failed; } gpio_direction_output(pdata->power_on_gpio, pdata->power_on_high); } ddev->platform_enable = ws2401_platform_enable, ddev->platform_disable = ws2401_platform_disable, ddev->set_power_mode = ws2401_set_power_mode; ddev->native_x_res = VMODE_XRES; ddev->native_y_res = VMODE_YRES; lcd = kzalloc(sizeof(struct ws2401_lcd), GFP_KERNEL); if (!lcd) return -ENOMEM; dev_set_drvdata(&ddev->dev, lcd); lcd->mdd = ddev; lcd->dev = &ddev->dev; lcd->pd = pdata; lcd->opp_is_requested = false; if (ddev->port->mode == MCDE_PORTMODE_CMD) { INIT_DELAYED_WORK_DEFERRABLE( &lcd->opp_timeout_work, ws2401_work_opp_timeout_function); } #ifdef CONFIG_LCD_CLASS_DEVICE lcd->ld = lcd_device_register("ws2401", &ddev->dev, lcd, &ws2401_lcd_ops); if (IS_ERR(lcd->ld)) { ret = PTR_ERR(lcd->ld); goto out_free_lcd; } #endif mutex_init(&lcd->lock); if (pdata->no_bl_ctrl) { lcd->bd = NULL; } else { if (gpio_is_valid(pdata->bl_en_gpio)) { gpio_request(pdata->bl_en_gpio, "LCD BL Ctrl"); gpio_direction_output(pdata->bl_en_gpio, 1); } bd = backlight_device_register("pwm-backlight", &ddev->dev, lcd, &ws2401_backlight_ops, &ws2401_backlight_props); if (IS_ERR(bd)) { ret = PTR_ERR(bd); goto out_backlight_unregister; } lcd->bd = bd; } goto out; out_backlight_unregister: backlight_device_unregister(bd); #ifdef CONFIG_LCD_CLASS_DEVICE out_free_lcd: #endif kfree(lcd); request_power_on_gpio_failed: if (pdata->reset_gpio) gpio_free(pdata->reset_gpio); request_reset_gpio_failed: out: return ret; }
static void exit_backlight(struct atmel_lcdfb_info *sinfo) { if (sinfo->backlight) backlight_device_unregister(sinfo->backlight); }
/* * ubicom32bl_probe */ static int ubicom32bl_probe(struct platform_device *pdev) { const struct ubicom32bl_platform_data *pdata = pdev->dev.platform_data; struct ubicom32bl_data *ud; struct backlight_device *bldev; struct backlight_properties props; int retval; /* * Check to see if we have any platform data, if we don't then the backlight is not * configured on this device. */ if (!pdata) { return -ENODEV; } /* * Allocate our private data */ ud = kzalloc(sizeof(struct ubicom32bl_data), GFP_KERNEL); if (!ud) { return -ENOMEM; } ud->pdata = pdata; /* * Check to see that the platform data is valid for this driver */ switch (pdata->type) { case UBICOM32BL_TYPE_PWM: { /* * Make sure we have a PWM peripheral */ if ((ubicom32_get_chip_id() != 0x00030001) && (ubicom32_get_chip_id() != 0x00040000)) { printk(KERN_WARNING DRIVER_NAME ": no PWM support on this chip\n"); retval = -ENODEV; goto fail; } if (pdata->pwm_channel > UBICOM32BL_NUM_PWM_CHANNELS) { printk(KERN_WARNING DRIVER_NAME ": PWM channel %d does not exist\n", pdata->pwm_channel); retval = -ENODEV; goto fail; } if (pdata->pwm_prescale > 16) { printk(KERN_WARNING DRIVER_NAME ": PWM prescale must be < 16\n"); retval = -EINVAL; goto fail; } ud->init_fn = ubicom32bl_init_hw_pwm; ud->set_intensity_fn = ubicom32bl_set_intensity_hw; printk(KERN_INFO DRIVER_NAME ": HW PWM\n"); break; } case UBICOM32BL_TYPE_PWM_HRT: // For now, PWM HRT devices are treated as binary lights. case UBICOM32BL_TYPE_BINARY: ud->init_fn = ubicom32bl_init_gpio; ud->set_intensity_fn = ubicom32bl_set_intensity_gpio; printk(KERN_INFO DRIVER_NAME ": Binary backlight\n"); break; } /* * Register our backlight device */ memset(&props, 0, sizeof(struct backlight_properties)); props.max_brightness = UBICOM32BL_MAX_BRIGHTNESS; bldev = backlight_device_register(DRIVER_NAME, &pdev->dev, ud, &ubicom32bl_ops, &props); if (IS_ERR(bldev)) { retval = PTR_ERR(bldev); goto fail; } ud->bldev = bldev; ud->cur_intensity = pdata->default_intensity; platform_set_drvdata(pdev, ud); /* * Start up the backlight at the prescribed default intensity */ bldev->props.power = FB_BLANK_UNBLANK; bldev->props.max_brightness = UBICOM32BL_MAX_BRIGHTNESS; bldev->props.brightness = pdata->default_intensity; if (ud->init_fn) { if (ud->init_fn(ud) != 0) { retval = -ENODEV; backlight_device_unregister(ud->bldev); goto fail; } } ubicom32bl_set_intensity(bldev); printk(KERN_INFO DRIVER_NAME ": Backlight driver started ch=%d brightness=%d/%d\n", pdata->pwm_channel, bldev->props.brightness, bldev->props.max_brightness); return 0; fail: platform_set_drvdata(pdev, NULL); kfree(ud); return retval; }
static int __init compal_init(void) { int ret; if (acpi_disabled) return -ENODEV; if (!force && !dmi_check_system(compal_dmi_table)) return -ENODEV; if (!acpi_video_backlight_support()) { compalbl_device = backlight_device_register("compal-laptop", NULL, NULL, &compalbl_ops); if (IS_ERR(compalbl_device)) return PTR_ERR(compalbl_device); compalbl_device->props.max_brightness = COMPAL_LCD_LEVEL_MAX-1; } ret = platform_driver_register(&compal_driver); if (ret) goto fail_backlight; compal_device = platform_device_alloc("compal-laptop", -1); if (!compal_device) { ret = -ENOMEM; goto fail_platform_driver; } ret = platform_device_add(compal_device); if (ret) goto fail_platform_device1; ret = sysfs_create_group(&compal_device->dev.kobj, &compal_attribute_group); if (ret) goto fail_platform_device2; printk(KERN_INFO "compal-laptop: driver "COMPAL_DRIVER_VERSION " successfully loaded.\n"); return 0; fail_platform_device2: platform_device_del(compal_device); fail_platform_device1: platform_device_put(compal_device); fail_platform_driver: platform_driver_unregister(&compal_driver); fail_backlight: backlight_device_unregister(compalbl_device); return ret; }
static int __devinit tl2796_probe(struct spi_device *spi) { struct s5p_lcd *lcd; int ret; lcd = kzalloc(sizeof(*lcd), GFP_KERNEL); if (!lcd) { pr_err("failed to allocate for lcd\n"); ret = -ENOMEM; goto err_alloc; } mutex_init(&lcd->lock); spi->bits_per_word = 8; if (spi_setup(spi)) { pr_err("failed to setup spi\n"); ret = -EINVAL; goto err_setup; } lcd->g_spi = spi; lcd->dev = &spi->dev; lcd->bl = 255; if (!spi->dev.platform_data) { dev_err(lcd->dev, "failed to get platform data\n"); ret = -EINVAL; goto err_setup; } // lcd->data = (struct s5p_panel_data *)spi->dev.platform_data; //determinate of LCD type lcd->lcd_type = get_lcdtype(); ret = gpio_request(GPIO_LCD_BL_PWM, "lcd_bl_pwm"); if (ret < 0) { dev_err(lcd->dev, "unable to request gpio for backlight\n"); return ret; } s3c_gpio_cfgpin(GPIO_LCD_BL_PWM, (0x2 << 0)); lcd->backlight_pwm_dev = pwm_request(0, "backlight-pwm"); if (IS_ERR(lcd->backlight_pwm_dev)) { dev_err(lcd->dev, "unable to request PWM for backlight\n"); } else dev_err(lcd->dev, "got pwm for backlight\n"); pwm_config(lcd->backlight_pwm_dev, (bl_freq_count*70)/100, bl_freq_count); pwm_enable(lcd->backlight_pwm_dev); lcd->bl_dev = backlight_device_register("s5p_bl", &spi->dev, lcd, &s5p_bl_ops, NULL); if (!lcd->bl_dev) { dev_err(lcd->dev, "failed to register backlight\n"); ret = -EINVAL; goto err_setup; } lcd->bl_dev->props.max_brightness = 255; lcd->lcd_dev = lcd_device_register("s5p_lcd", &spi->dev, lcd, &s5p_lcd_ops); if (!lcd->lcd_dev) { dev_err(lcd->dev, "failed to register lcd\n"); ret = -EINVAL; goto err_setup_lcd; } // Class and device file creation printk(KERN_ERR "ldi_class create\n"); lcd->ldi_class = class_create(THIS_MODULE, "ldi_class"); if (IS_ERR(lcd->ldi_class)) pr_err("Failed to create class(ldi_class)!\n"); lcd->ldi_dev = device_create(lcd->ldi_class, &spi->dev, 0, lcd, "ldi_dev"); if (IS_ERR(lcd->ldi_dev)) pr_err("Failed to create device(ldi_dev)!\n"); if (!lcd->ldi_dev) { dev_err(lcd->dev, "failed to register device(ldi_dev)\n"); ret = -EINVAL; goto err_setup_ldi; } if (device_create_file(lcd->ldi_dev, &dev_attr_update_brightness_cmd) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_update_brightness_cmd.attr.name); spi_set_drvdata(spi, lcd); tl2796_ldi_enable(lcd); #ifdef CONFIG_FB_S3C_MDNIE init_mdnie_class(); //set mDNIe UI mode, Outdoormode #endif #ifdef CONFIG_HAS_EARLYSUSPEND lcd->early_suspend.suspend = tl2796_early_suspend; lcd->early_suspend.resume = tl2796_late_resume; lcd->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; register_early_suspend(&lcd->early_suspend); #endif gprintk("tl2796_probe successfully probed\n", __func__); return 0; err_setup_ldi: lcd_device_unregister(lcd->lcd_dev); err_setup_lcd: backlight_device_unregister(lcd->bl_dev); err_setup: mutex_destroy(&lcd->lock); kfree(lcd); err_alloc: return ret; }
static int appledisplay_probe(struct usb_interface *iface, const struct usb_device_id *id) { struct backlight_properties props; struct appledisplay *pdata; struct usb_device *udev = interface_to_usbdev(iface); struct usb_host_interface *iface_desc; struct usb_endpoint_descriptor *endpoint; int int_in_endpointAddr = 0; int i, retval = -ENOMEM, brightness; char bl_name[20]; /* set up the endpoint information */ /* use only the first interrupt-in endpoint */ iface_desc = iface->cur_altsetting; for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) { endpoint = &iface_desc->endpoint[i].desc; if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) { /* we found an interrupt in endpoint */ int_in_endpointAddr = endpoint->bEndpointAddress; break; } } if (!int_in_endpointAddr) { dev_err(&iface->dev, "Could not find int-in endpoint\n"); return -EIO; } /* allocate memory for our device state and initialize it */ pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL); if (!pdata) { retval = -ENOMEM; dev_err(&iface->dev, "Out of memory\n"); goto error; } pdata->udev = udev; spin_lock_init(&pdata->lock); INIT_DELAYED_WORK(&pdata->work, appledisplay_work); /* Allocate buffer for control messages */ pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL); if (!pdata->msgdata) { retval = -ENOMEM; dev_err(&iface->dev, "Allocating buffer for control messages failed\n"); goto error; } /* Allocate interrupt URB */ pdata->urb = usb_alloc_urb(0, GFP_KERNEL); if (!pdata->urb) { retval = -ENOMEM; dev_err(&iface->dev, "Allocating URB failed\n"); goto error; } /* Allocate buffer for interrupt data */ pdata->urbdata = usb_alloc_coherent(pdata->udev, ACD_URB_BUFFER_LEN, GFP_KERNEL, &pdata->urb->transfer_dma); if (!pdata->urbdata) { retval = -ENOMEM; dev_err(&iface->dev, "Allocating URB buffer failed\n"); goto error; } /* Configure interrupt URB */ usb_fill_int_urb(pdata->urb, udev, usb_rcvintpipe(udev, int_in_endpointAddr), pdata->urbdata, ACD_URB_BUFFER_LEN, appledisplay_complete, pdata, 1); if (usb_submit_urb(pdata->urb, GFP_KERNEL)) { retval = -EIO; dev_err(&iface->dev, "Submitting URB failed\n"); goto error; } /* Register backlight device */ snprintf(bl_name, sizeof(bl_name), "appledisplay%d", atomic_inc_return(&count_displays) - 1); memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = 0xff; pdata->bd = backlight_device_register(bl_name, NULL, pdata, &appledisplay_bl_data, &props); if (IS_ERR(pdata->bd)) { dev_err(&iface->dev, "Backlight registration failed\n"); retval = PTR_ERR(pdata->bd); goto error; } /* Try to get brightness */ brightness = appledisplay_bl_get_brightness(pdata->bd); if (brightness < 0) { retval = brightness; dev_err(&iface->dev, "Error while getting initial brightness: %d\n", retval); goto error; } /* Set brightness in backlight device */ pdata->bd->props.brightness = brightness; /* save our data pointer in the interface device */ usb_set_intfdata(iface, pdata); printk(KERN_INFO "appledisplay: Apple Cinema Display connected\n"); return 0; error: if (pdata) { if (pdata->urb) { usb_kill_urb(pdata->urb); if (pdata->urbdata) usb_free_coherent(pdata->udev, ACD_URB_BUFFER_LEN, pdata->urbdata, pdata->urb->transfer_dma); usb_free_urb(pdata->urb); } if (pdata->bd && !IS_ERR(pdata->bd)) backlight_device_unregister(pdata->bd); kfree(pdata->msgdata); } usb_set_intfdata(iface, NULL); kfree(pdata); return retval; }
static int lm3533_bl_probe(struct platform_device *pdev) { struct lm3533 *lm3533; struct lm3533_bl_platform_data *pdata; struct lm3533_bl *bl; struct backlight_device *bd; struct backlight_properties props; int ret; dev_dbg(&pdev->dev, "%s\n", __func__); lm3533 = dev_get_drvdata(pdev->dev.parent); if (!lm3533) return -EINVAL; pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "no platform data\n"); return -EINVAL; } if (pdev->id < 0 || pdev->id >= LM3533_HVCTRLBANK_COUNT) { dev_err(&pdev->dev, "illegal backlight id %d\n", pdev->id); return -EINVAL; } bl = devm_kzalloc(&pdev->dev, sizeof(*bl), GFP_KERNEL); if (!bl) { dev_err(&pdev->dev, "failed to allocate memory for backlight\n"); return -ENOMEM; } bl->lm3533 = lm3533; bl->id = pdev->id; bl->cb.lm3533 = lm3533; bl->cb.id = lm3533_bl_get_ctrlbank_id(bl); bl->cb.dev = NULL; /* until registered */ memset(&props, 0, sizeof(props)); props.type = BACKLIGHT_RAW; props.max_brightness = LM3533_BL_MAX_BRIGHTNESS; props.brightness = pdata->default_brightness; bd = backlight_device_register(pdata->name, pdev->dev.parent, bl, &lm3533_bl_ops, &props); if (IS_ERR(bd)) { dev_err(&pdev->dev, "failed to register backlight device\n"); return PTR_ERR(bd); } bl->bd = bd; bl->cb.dev = &bl->bd->dev; platform_set_drvdata(pdev, bl); ret = sysfs_create_group(&bd->dev.kobj, &lm3533_bl_attribute_group); if (ret < 0) { dev_err(&pdev->dev, "failed to create sysfs attributes\n"); goto err_unregister; } backlight_update_status(bd); ret = lm3533_bl_setup(bl, pdata); if (ret) goto err_sysfs_remove; ret = lm3533_ctrlbank_enable(&bl->cb); if (ret) goto err_sysfs_remove; return 0; err_sysfs_remove: sysfs_remove_group(&bd->dev.kobj, &lm3533_bl_attribute_group); err_unregister: backlight_device_unregister(bd); return ret; }