static int __init aat2862_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *id) { struct aat2862_device *dev; struct backlight_device *bl_dev; struct backlight_properties props; // hjpark 20110427 int err; printk(KERN_INFO"%s: i2c probe start\n", __func__); // 20100810 [email protected] GPIO Initialization [START_LGE] omap_mux_init_gpio(MY_LCD_CP_EN, OMAP_PIN_OUTPUT); err = gpio_request(MY_LCD_CP_EN, "lcd_cp_en"); if(err < 0) { printk("can't get hub lcd cp enable GPIO\n"); kzfree(dev); return -ENOSYS; } err = gpio_direction_output(MY_LCD_CP_EN, 1); gpio_set_value(MY_LCD_CP_EN, 1); omap_mux_init_gpio(MY_TOUCH_I2C2_SW, OMAP_PIN_OUTPUT); err = gpio_request(MY_TOUCH_I2C2_SW, "touch_i2c2_sw"); if(err < 0) { printk("can't get hub touch i2c2 sw enable GPIO\n"); kzfree(dev); return -ENOSYS; } err = gpio_direction_output(MY_TOUCH_I2C2_SW, 0); gpio_set_value(MY_TOUCH_I2C2_SW, 0); aat2862_touch_ldo_enable(i2c_dev, 1); // 20100810 [email protected] GPIO Initialization [END_LGE] aat2862_i2c_client = i2c_dev; dev = kzalloc(sizeof(struct aat2862_device), GFP_KERNEL); if(dev == NULL) { dev_err(&i2c_dev->dev,"fail alloc for aat2862_device\n"); return 0; } main_aat2862_dev = dev; #if 0 // froyo k32 origin bl_dev = backlight_device_register(HUB_I2C_BL_NAME, &i2c_dev->dev, NULL, &hub_bl_ops); #else bl_dev = backlight_device_register(HUB_I2C_BL_NAME, &i2c_dev->dev, NULL, &hub_bl_ops, &props); #endif bl_dev->props.max_brightness = MAX_BRIGHTNESS; bl_dev->props.brightness = DEFAULT_BRIGHTNESS; bl_dev->props.power = FB_BLANK_UNBLANK; dev->bl_dev = bl_dev; dev->client = i2c_dev; i2c_set_clientdata(i2c_dev, dev); /* LGE_CHANGE_S [[email protected]] 2010-03-16, for prevent display flicker*/ //aat2862_init(i2c_dev); /* LGE_CHANGE_S [[email protected]] 2010-03-16, for prevent display flicker*/ led_classdev_register(&i2c_dev->dev, &lcd_backlight); aat2862_set_main_current_level(i2c_dev, DEFAULT_BRIGHTNESS); err = device_create_file(&i2c_dev->dev, &dev_attr_level); err = device_create_file(&i2c_dev->dev, &dev_attr_backlight_on_off);//20100825 [email protected] for test_mode //20100709 [email protected] early_suspend [START_LGE] #ifdef CONFIG_HAS_EARLYSUSPEND dev->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; dev->early_suspend.suspend = aat2862_early_suspend; dev->early_suspend.resume = aat2862_late_resume; register_early_suspend(&dev->early_suspend); #endif //20100709 [email protected] early_suspend [END_LGE] return 0; }
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 = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; ret = adp8860_read(client, ADP8860_MFDVID, ®_val); if (ret < 0) goto out2; 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"); ret = -ENODEV; goto out2; } /* 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"); ret = PTR_ERR(bl); goto out2; } 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); out2: kfree(data); return ret; }
static int mdnie_probe(struct platform_device *pdev) { #if defined(CONFIG_FB_MDNIE_PWM) struct platform_mdnie_data *pdata = pdev->dev.platform_data; #endif struct mdnie_info *mdnie; int ret = 0; mdnie_class = class_create(THIS_MODULE, dev_name(&pdev->dev)); if (IS_ERR_OR_NULL(mdnie_class)) { pr_err("failed to create mdnie class\n"); ret = -EINVAL; goto error0; } mdnie_class->dev_attrs = mdnie_attributes; mdnie = kzalloc(sizeof(struct mdnie_info), GFP_KERNEL); if (IS_ERR_OR_NULL(mdnie)) { pr_err("failed to allocate mdnie\n"); ret = -EINVAL; goto error1; } mdnie->dev = device_create(mdnie_class, &pdev->dev, 0, &mdnie, "mdnie"); if (IS_ERR_OR_NULL(mdnie->dev)) { pr_err("failed to create mdnie device\n"); ret = -EINVAL; goto error2; } #if defined(CONFIG_FB_MDNIE_PWM) mdnie->bd = backlight_device_register("panel", mdnie->dev, mdnie, &mdnie_backlight_ops, NULL); mdnie->bd->props.max_brightness = MAX_BRIGHTNESS_LEVEL; mdnie->bd->props.brightness = DEFAULT_BRIGHTNESS; mdnie->bd_enable = TRUE; mdnie->lcd_pd = pdata->lcd_pd; #endif mdnie->scenario = UI_MODE; mdnie->mode = STANDARD; mdnie->tone = TONE_NORMAL; mdnie->outdoor = OUTDOOR_OFF; #if defined(CONFIG_FB_MDNIE_PWM) mdnie->cabc = CABC_ON; #else mdnie->cabc = CABC_OFF; #endif mdnie->enable = TRUE; mdnie->tunning = FALSE; mdnie->negative = NEGATIVE_OFF; mutex_init(&mdnie->lock); mutex_init(&mdnie->dev_lock); platform_set_drvdata(pdev, mdnie); dev_set_drvdata(mdnie->dev, mdnie); #ifdef CONFIG_HAS_WAKELOCK #ifdef CONFIG_HAS_EARLYSUSPEND mdnie->early_suspend.suspend = mdnie_early_suspend; mdnie->early_suspend.resume = mdnie_late_resume; mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; register_early_suspend(&mdnie->early_suspend); #endif #endif #if defined(CONFIG_FB_S5P_S6F1202A) if (pdata->display_type == 0) { memcpy(tunning_table, tunning_table_hy, sizeof(tunning_table)); memcpy(etc_table, etc_table_hy, sizeof(etc_table)); tune_camera_outdoor = tune_camera_outdoor_hy; } else if (pdata->display_type == 1) { memcpy(tunning_table, tunning_table_sec, sizeof(tunning_table)); memcpy(etc_table, etc_table_sec, sizeof(etc_table)); tune_camera_outdoor = tune_camera_outdoor_sec; } else if (pdata->display_type == 2) { memcpy(tunning_table, tunning_table_bo, sizeof(tunning_table)); memcpy(etc_table, etc_table_bo, sizeof(etc_table)); tune_camera_outdoor = tune_camera_outdoor_bo; } #endif g_mdnie = mdnie; set_mdnie_value(mdnie); dev_info(mdnie->dev, "registered successfully\n"); return 0; error2: kfree(mdnie); error1: class_destroy(mdnie_class); error0: 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 pwm_backlight_probe(struct platform_device *pdev) { struct backlight_properties props; struct platform_pwm_backlight_data *data = pdev->dev.platform_data; struct backlight_device *bl; struct pwm_bl_data *pb; int ret; if (!data) { dev_err(&pdev->dev, "failed to find platform data\n"); return -EINVAL; } if (data->init) { ret = data->init(&pdev->dev); if (ret < 0) return ret; } pb = kzalloc(sizeof(*pb), GFP_KERNEL); if (!pb) { dev_err(&pdev->dev, "no memory for state\n"); ret = -ENOMEM; goto err_alloc; } pb->period = data->pwm_period_ns; pb->notify = data->notify; pb->check_fb = data->check_fb; pb->lth_brightness = data->lth_brightness * (data->pwm_period_ns / data->max_brightness); pb->dev = &pdev->dev; pb->pwm = pwm_request(data->pwm_id, "backlight"); if (IS_ERR(pb->pwm)) { dev_err(&pdev->dev, "unable to request PWM for backlight\n"); ret = PTR_ERR(pb->pwm); goto err_pwm; } else dev_dbg(&pdev->dev, "got pwm for backlight\n"); memset(&props, 0, sizeof(struct backlight_properties)); props.max_brightness = data->max_brightness; bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb, &pwm_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); goto err_bl; } bl_p = bl; bl->props.brightness = data->dft_brightness; backlight_update_status(bl); platform_set_drvdata(pdev, bl); return 0; err_bl: pwm_free(pb->pwm); err_pwm: kfree(pb); err_alloc: if (data->exit) data->exit(&pdev->dev); return ret; }
static int s6evr02_probe(struct device *dev) { int ret = 0, i; struct lcd_info *lcd; #ifdef SMART_DIMMING u8 mtp_data[LDI_MTP_LENGTH] = {0,}; #endif lcd = kzalloc(sizeof(struct lcd_info), GFP_KERNEL); if (!lcd) { pr_err("failed to allocate for lcd\n"); ret = -ENOMEM; goto err_alloc; } g_lcd = lcd; lcd->ld = lcd_device_register("panel", dev, lcd, &s6evr02_lcd_ops); if (IS_ERR(lcd->ld)) { pr_err("failed to register lcd device\n"); ret = PTR_ERR(lcd->ld); goto out_free_lcd; } lcd->bd = backlight_device_register("panel", dev, lcd, &s6evr02_backlight_ops, NULL); if (IS_ERR(lcd->bd)) { pr_err("failed to register backlight device\n"); ret = PTR_ERR(lcd->bd); goto out_free_backlight; } lcd->dev = dev; lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = DEFAULT_GAMMA_LEVEL; lcd->current_bl = lcd->bl; lcd->acl_enable = 0; lcd->current_acl = 0; lcd->power = FB_BLANK_UNBLANK; lcd->ldi_enable = 1; lcd->connected = 1; lcd->auto_brightness = 0; ret = device_create_file(&lcd->ld->dev, &dev_attr_power_reduce); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_lcd_type); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_window_type); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_gamma_table); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->bd->dev, &dev_attr_auto_brightness); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); dev_set_drvdata(dev, lcd); mutex_init(&lcd->lock); mutex_init(&lcd->bl_lock); s6evr02_read_id(lcd, lcd->id); dev_info(&lcd->ld->dev, "ID: %x, %x, %x\n", lcd->id[0], lcd->id[1], lcd->id[2]); dev_info(&lcd->ld->dev, "%s lcd panel driver has been probed.\n", dev_name(dev)); #ifdef SMART_DIMMING for (i = 0; i < LDI_ID_LEN; i++) { lcd->smart.panelid[i] = lcd->id[i]; } init_table_info(&lcd->smart); ret = s6evr02_read_mtp(lcd, mtp_data); /* for (i = 0; i < LDI_MTP_LENGTH ; i++) printk(" %dth mtp value is %x\n", i, mtp_data[i]); */ if (!ret) { printk(KERN_ERR "[LCD:ERROR] : %s read mtp failed\n", __func__); /*return -EPERM;*/ } calc_voltage_table(&lcd->smart, mtp_data); ret = init_elvss_table(lcd); ret += init_gamma_table(lcd, mtp_data); ret += init_aid_dimming_table(lcd); if (ret) printk(KERN_ERR "gamma table generation is failed\n"); update_brightness(lcd, 1); #endif #if defined(GPIO_ERR_FG) if (lcd->connected) { INIT_DELAYED_WORK(&lcd->err_fg_detection, err_fg_detection_work); lcd->irq = gpio_to_irq(GPIO_ERR_FG); irq_set_irq_type(lcd->irq, IRQ_TYPE_EDGE_RISING); s3c_gpio_cfgpin(GPIO_ERR_FG, S3C_GPIO_SFN(0xf)); s3c_gpio_setpull(GPIO_ERR_FG, S3C_GPIO_PULL_NONE); if (request_irq(lcd->irq, err_fg_detection_int, IRQF_TRIGGER_RISING, "err_fg_detection", lcd)) pr_err("failed to reqeust irq. %d\n", lcd->irq); } #endif #if defined(GPIO_OLED_DET) if (lcd->connected) { INIT_DELAYED_WORK(&lcd->oled_detection, oled_detection_work); s3c_gpio_cfgpin(GPIO_OLED_DET, S3C_GPIO_SFN(0xf)); s3c_gpio_setpull(GPIO_OLED_DET, S3C_GPIO_PULL_NONE); if (request_irq(gpio_to_irq(GPIO_OLED_DET), oled_detection_int, IRQF_TRIGGER_FALLING, "oled_detection", lcd)) pr_err("failed to reqeust irq. %d\n", gpio_to_irq(GPIO_OLED_DET)); } #endif lcd_early_suspend = s6evr02_early_suspend; lcd_late_resume = s6evr02_late_resume; return 0; out_free_backlight: lcd_device_unregister(lcd->ld); kfree(lcd); return ret; out_free_lcd: kfree(lcd); return ret; err_alloc: return ret; }
static int s6d6aa1_probe(struct device *dev) { int ret = 0; struct lcd_info *lcd; lcd = kzalloc(sizeof(struct lcd_info), GFP_KERNEL); if (!lcd) { pr_err("failed to allocate for lcd\n"); ret = -ENOMEM; goto err_alloc; } g_lcd = lcd; lcd->ld = lcd_device_register("panel", dev, lcd, &panel_lcd_ops); if (IS_ERR(lcd->ld)) { pr_err("failed to register lcd device\n"); ret = PTR_ERR(lcd->ld); goto out_free_lcd; } lcd->bd = backlight_device_register("panel", dev, lcd, &panel_backlight_ops, NULL); if (IS_ERR(lcd->bd)) { pr_err("failed to register backlight device\n"); ret = PTR_ERR(lcd->bd); goto out_free_backlight; } lcd->dev = dev; lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = 0; lcd->current_bl = lcd->bl; lcd->power = FB_BLANK_UNBLANK; lcd->ldi_enable = 1; lcd->connected = 1; ret = device_create_file(&lcd->ld->dev, &dev_attr_lcd_type); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->bd->dev, &dev_attr_auto_brightness); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); dev_set_drvdata(dev, lcd); mutex_init(&lcd->lock); mutex_init(&lcd->bl_lock); dev_info(&lcd->ld->dev, "s6e8aa0 lcd panel driver has been probed.\n"); #if defined(GPIO_OLED_DET) if (lcd->connected) { INIT_DELAYED_WORK(&lcd->oled_detection, oled_detection_work); lcd->irq = gpio_to_irq(GPIO_OLED_DET); s3c_gpio_cfgpin(GPIO_OLED_DET, S3C_GPIO_SFN(0xf)); s3c_gpio_setpull(GPIO_OLED_DET, S3C_GPIO_PULL_NONE); if (request_irq(lcd->irq, oled_detection_int, IRQF_TRIGGER_FALLING, "oled_detection", lcd)) pr_err("failed to reqeust irq. %d\n", lcd->irq); } #endif lcd_early_suspend = s6d6aa1_early_suspend; lcd_late_resume = s6d6aa1_late_resume; return 0; out_free_backlight: lcd_device_unregister(lcd->ld); kfree(lcd); return ret; out_free_lcd: kfree(lcd); return ret; err_alloc: return ret; }
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev) { int ret; struct platform_device *msm_fb_added_dev; #if defined(CONFIG_LCD_CLASS_DEVICE) struct lcd_device *lcd_device; #endif #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) struct backlight_device *bd = NULL; #endif msd.dstat.acl_on = false; if (pdev->id == 0) { msd.mipi_samsung_disp_pdata = pdev->dev.platform_data; #ifdef CONFIG_SAMSUNG_CMC624 if (samsung_has_cmc624()) { printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is there!!!!"); samsung_cmc624_init(); first_on = false; } else { printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is not there!!!!"); first_on = false; } #else first_on = false; #endif return 0; } msm_fb_added_dev = msm_fb_add_device(pdev); #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE) msd.msm_pdev = msm_fb_added_dev; #endif #if defined(CONFIG_HAS_EARLYSUSPEND) msd.early_suspend.suspend = mipi_samsung_disp_early_suspend; msd.early_suspend.resume = mipi_samsung_disp_late_resume; msd.early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 10; register_early_suspend(&msd.early_suspend); #endif #if defined(CONFIG_LCD_CLASS_DEVICE) lcd_device = lcd_device_register("panel", &pdev->dev, NULL, &mipi_samsung_disp_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } #ifdef WA_FOR_FACTORY_MODE sysfs_remove_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_power.attr.name); } #endif ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_gamma_mode.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_gamma_mode.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_power_reduce.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_power_reduce.attr.name); } #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) bd = backlight_device_register("panel", &lcd_device->dev, NULL, NULL, NULL); if (IS_ERR(bd)) { ret = PTR_ERR(bd); pr_info("backlight : failed to register device\n"); return ret; } ret = sysfs_create_file(&bd->dev.kobj, &dev_attr_auto_brightness.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_auto_brightness.attr.name); } #endif #endif #if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT) \ || defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT) \ || defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_QHD_PT) \ || defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_WVGA_PT) /* mdnie sysfs create */ init_mdnie_class(); #elif defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT) if (samsung_has_cmc624()) { ret = cmc624_sysfs_init(); if (ret < 0) pr_debug("CMC624 sysfs initialize FAILED\n"); } else init_mdnie_class(); #endif #ifdef READ_REGISTER_ESD msd.mpd->esd_workqueue = create_singlethread_workqueue("esd_workqueue"); if (!msd.mpd->esd_workqueue) { pr_info("esd_workqueue create fail\n"); return -ENOMEM; } INIT_DELAYED_WORK(&(msd.mpd->esd_work), esd_test_work_func); wake_lock_init(&(msd.mpd->esd_wake_lock), WAKE_LOCK_SUSPEND, "esd_workqueue_lock"); #endif return 0; }
static int s6e8ax0_probe(struct device *dev) { int ret = 0; struct lcd_info *lcd; #ifdef SMART_DIMMING u8 mtp_data[LDI_MTP_LENGTH] = {0,}; #endif lcd = kzalloc(sizeof(struct lcd_info), GFP_KERNEL); if (!lcd) { pr_err("failed to allocate for lcd\n"); ret = -ENOMEM; goto err_alloc; } g_lcd = lcd; lcd->ld = lcd_device_register("panel", dev, lcd, &s6e8ax0_lcd_ops); if (IS_ERR(lcd->ld)) { pr_err("failed to register lcd device\n"); ret = PTR_ERR(lcd->ld); goto out_free_lcd; } lcd->bd = backlight_device_register("panel", dev, lcd, &s6e8ax0_backlight_ops, NULL); if (IS_ERR(lcd->bd)) { pr_err("failed to register backlight device\n"); ret = PTR_ERR(lcd->bd); goto out_free_backlight; } lcd->dev = dev; lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); lcd->bd->props.max_brightness = MAX_BRIGHTNESS; lcd->bd->props.brightness = DEFAULT_BRIGHTNESS; lcd->bl = DEFAULT_GAMMA_LEVEL; lcd->current_bl = lcd->bl; lcd->acl_enable = 0; lcd->siop_enable = 0; lcd->current_acl = 0; lcd->power = FB_BLANK_UNBLANK; lcd->ldi_enable = 1; lcd->connected = 1; lcd->auto_brightness = 0; ret = device_create_file(&lcd->ld->dev, &dev_attr_power_reduce); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_siop_enable); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_lcd_type); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_gamma_table); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->ld->dev, &dev_attr_read_acl); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); ret = device_create_file(&lcd->bd->dev, &dev_attr_auto_brightness); if (ret < 0) dev_err(&lcd->ld->dev, "failed to add sysfs entries, %d\n", __LINE__); dev_set_drvdata(dev, lcd); mutex_init(&lcd->lock); mutex_init(&lcd->bl_lock); s6e8ax0_read_id(lcd, lcd->id); dev_info(&lcd->ld->dev, "ID: %x, %x, %x\n", lcd->id[0], lcd->id[1], lcd->id[2]); dev_info(&lcd->ld->dev, "s6e8aa0 lcd panel driver has been probed.\n"); #ifdef SMART_DIMMING s6e8aa0_check_id(lcd, lcd->id); init_table_info(&lcd->smart); ret = s6e8ax0_read_mtp(lcd, mtp_data); if (!ret) { printk(KERN_ERR "[LCD:ERROR] : %s read mtp failed\n", __func__); /*return -EPERM;*/ } calc_voltage_table(&lcd->smart, mtp_data); if (lcd->support_elvss) ret = init_elvss_table(lcd); else { lcd->elvss_table = (unsigned char **)ELVSS_TABLE; ret = 0; } ret += init_gamma_table(lcd); #ifdef CONFIG_AID_DIMMING if (lcd->id[1] == 0x20 || lcd->id[1] == 0x40 || lcd->id[1] == 0x60) { printk(KERN_INFO "AID Dimming is started. %d\n", lcd->id[1]); lcd->support_aid = 1; ret += init_aid_dimming_table(lcd); } #endif if (ret) { printk(KERN_ERR "gamma table generation is failed\n"); lcd->gamma_table = (unsigned char **)gamma22_table; lcd->elvss_table = (unsigned char **)ELVSS_TABLE; } update_brightness(lcd, 1); #endif #if defined(GPIO_OLED_DET) if (lcd->connected) { INIT_DELAYED_WORK(&lcd->oled_detection, oled_detection_work); lcd->irq = gpio_to_irq(GPIO_OLED_DET); s3c_gpio_cfgpin(GPIO_OLED_DET, S3C_GPIO_SFN(0xf)); s3c_gpio_setpull(GPIO_OLED_DET, S3C_GPIO_PULL_NONE); if (request_irq(lcd->irq, oled_detection_int, IRQF_TRIGGER_FALLING, "oled_detection", lcd)) pr_err("failed to reqeust irq. %d\n", lcd->irq); } #endif lcd_early_suspend = s6e8ax0_early_suspend; lcd_late_resume = s6e8ax0_late_resume; return 0; out_free_backlight: lcd_device_unregister(lcd->ld); kfree(lcd); return ret; out_free_lcd: kfree(lcd); return ret; err_alloc: return ret; }
static int appledisplay_probe(struct usb_interface *iface, const struct usb_device_id *id) { 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) { err("Could not find int-in endpoint"); return -EIO; } /* allocate memory for our device state and initialize it */ pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL); if (!pdata) { retval = -ENOMEM; err("Out of memory"); 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; err("appledisplay: Allocating buffer for control messages " "failed"); goto error; } /* Allocate interrupt URB */ pdata->urb = usb_alloc_urb(0, GFP_KERNEL); if (!pdata->urb) { retval = -ENOMEM; err("appledisplay: Allocating URB failed"); goto error; } /* Allocate buffer for interrupt data */ pdata->urbdata = usb_buffer_alloc(pdata->udev, ACD_URB_BUFFER_LEN, GFP_KERNEL, &pdata->urb->transfer_dma); if (!pdata->urbdata) { retval = -ENOMEM; err("appledisplay: Allocating URB buffer failed"); 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; err("appledisplay: Submitting URB failed"); goto error; } /* Register backlight device */ snprintf(bl_name, sizeof(bl_name), "appledisplay%d", atomic_inc_return(&count_displays) - 1); pdata->bd = backlight_device_register(bl_name, NULL, pdata, &appledisplay_bl_data); if (IS_ERR(pdata->bd)) { err("appledisplay: Backlight registration failed"); goto error; } pdata->bd->props.max_brightness = 0xff; /* Try to get brightness */ brightness = appledisplay_bl_get_brightness(pdata->bd); if (brightness < 0) { retval = brightness; err("appledisplay: Error while getting initial brightness: %d", 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_buffer_free(pdata->udev, ACD_URB_BUFFER_LEN, pdata->urbdata, pdata->urb->transfer_dma); usb_free_urb(pdata->urb); } if (pdata->bd) backlight_device_unregister(pdata->bd); kfree(pdata->msgdata); } usb_set_intfdata(iface, NULL); kfree(pdata); return retval; }
static int __devinit gmux_probe(struct pnp_dev *pnp, const struct pnp_device_id *id) { struct apple_gmux_data *gmux_data; struct resource *res; struct backlight_properties props; struct backlight_device *bdev; u8 ver_major, ver_minor, ver_release; int ret = -ENXIO; gmux_data = kzalloc(sizeof(*gmux_data), GFP_KERNEL); if (!gmux_data) return -ENOMEM; pnp_set_drvdata(pnp, gmux_data); res = pnp_get_resource(pnp, IORESOURCE_IO, 0); if (!res) { pr_err("Failed to find gmux I/O resource\n"); goto err_free; } gmux_data->iostart = res->start; gmux_data->iolen = res->end - res->start; if (gmux_data->iolen < GMUX_MIN_IO_LEN) { pr_err("gmux I/O region too small (%lu < %u)\n", gmux_data->iolen, GMUX_MIN_IO_LEN); goto err_free; } if (!request_region(gmux_data->iostart, gmux_data->iolen, "Apple gmux")) { pr_err("gmux I/O already in use\n"); goto err_free; } /* * On some machines the gmux is in ACPI even thought the machine * doesn't really have a gmux. Check for invalid version information * to detect this. */ ver_major = gmux_read8(gmux_data, GMUX_PORT_VERSION_MAJOR); ver_minor = gmux_read8(gmux_data, GMUX_PORT_VERSION_MINOR); ver_release = gmux_read8(gmux_data, GMUX_PORT_VERSION_RELEASE); if (ver_major == 0xff && ver_minor == 0xff && ver_release == 0xff) { pr_info("gmux device not present\n"); ret = -ENODEV; goto err_release; } pr_info("Found gmux version %d.%d.%d\n", ver_major, ver_minor, ver_release); memset(&props, 0, sizeof(props)); props.type = BACKLIGHT_PLATFORM; props.max_brightness = gmux_read32(gmux_data, GMUX_PORT_MAX_BRIGHTNESS); /* * Currently it's assumed that the maximum brightness is less than * 2^24 for compatibility with old gmux versions. Cap the max * brightness at this value, but print a warning if the hardware * reports something higher so that it can be fixed. */ if (WARN_ON(props.max_brightness > GMUX_MAX_BRIGHTNESS)) props.max_brightness = GMUX_MAX_BRIGHTNESS; bdev = backlight_device_register("gmux_backlight", &pnp->dev, gmux_data, &gmux_bl_ops, &props); if (IS_ERR(bdev)) { ret = PTR_ERR(bdev); goto err_release; } gmux_data->bdev = bdev; bdev->props.brightness = gmux_get_brightness(bdev); backlight_update_status(bdev); /* * The backlight situation on Macs is complicated. If the gmux is * present it's the best choice, because it always works for * backlight control and supports more levels than other options. * Disable the other backlight choices. */ acpi_video_unregister(); apple_bl_unregister(); return 0; err_release: release_region(gmux_data->iostart, gmux_data->iolen); err_free: kfree(gmux_data); return ret; }
static int __init msi_init(void) { int ret; if (acpi_disabled) return -ENODEV; if (!force && !dmi_check_system(msi_dmi_table)) return -ENODEV; if (auto_brightness < 0 || auto_brightness > 2) return -EINVAL; /* Register backlight stuff */ msibl_device = backlight_device_register("msi-laptop-bl", NULL, NULL, &msibl_ops); if (IS_ERR(msibl_device)) return PTR_ERR(msibl_device); msibl_device->props.max_brightness = MSI_LCD_LEVEL_MAX-1, 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; ret = sysfs_create_group(&msipf_device->dev.kobj, &msipf_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); printk(KERN_INFO "msi-laptop: driver "MSI_DRIVER_VERSION" successfully loaded.\n"); return 0; fail_platform_device2: 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 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]; 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)) { int_in_endpointAddr = endpoint->bEndpointAddress; break; } } if (!int_in_endpointAddr) { dev_err(&iface->dev, "Could not find int-in endpoint\n"); return -EIO; } 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); 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; } pdata->urb = usb_alloc_urb(0, GFP_KERNEL); if (!pdata->urb) { retval = -ENOMEM; dev_err(&iface->dev, "Allocating URB failed\n"); goto error; } 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; } 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; } 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; } 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; } pdata->bd->props.brightness = brightness; 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 rt9396_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *i2c_dev_id) { struct lge_backlight_platform_data *pdata; struct rt9396_driver_data *drvdata; struct backlight_device *bd; int err; rt9396_powerstate = NORMAL_STATE; dprintk("start, client addr=0x%x\n", i2c_dev->addr); pdata = i2c_dev->dev.platform_data; if(!pdata) return -EINVAL; drvdata = kzalloc(sizeof(struct rt9396_driver_data), GFP_KERNEL); if (!drvdata) { dev_err(&i2c_dev->dev, "failed to allocate memory\n"); return -ENOMEM; } if (pdata && pdata->platform_init) pdata->platform_init(); drvdata->client = i2c_dev; drvdata->gpio = pdata->gpio; drvdata->max_intensity = LCD_LED_MAX; if (pdata->max_current > 0) drvdata->max_intensity = pdata->max_current; drvdata->intensity = LCD_LED_MIN; drvdata->mode = NORMAL_MODE; drvdata->state = UNINIT_STATE; drvdata->version = pdata->version; if(rt9396_setup_version(drvdata) != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } if (drvdata->gpio && gpio_request(drvdata->gpio, "rt9396_en") != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } gpio_tlmm_config(GPIO_CFG(drvdata->gpio, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); bd = backlight_device_register("rt9396-bl", &i2c_dev->dev, NULL, &rt9396_ops, NULL); if (bd == NULL) { eprintk("entering rt9396 probe function error \n"); kfree(drvdata); return -1; } bd->props.power = FB_BLANK_UNBLANK; bd->props.brightness = drvdata->intensity; bd->props.max_brightness = drvdata->max_intensity; drvdata->bd = bd; if (led_classdev_register(&i2c_dev->dev, &rt9396_led_dev) == 0) { eprintk("Registering led class dev successfully.\n"); drvdata->led = &rt9396_led_dev; err = device_create_file(drvdata->led->dev, &dev_attr_alc); err = device_create_file(drvdata->led->dev, &dev_attr_reg); err = device_create_file(drvdata->led->dev, &dev_attr_drvstat); err = device_create_file(drvdata->led->dev, &dev_attr_chargerlogo); } // [Caio99BR][[email protected]] Workaround for bug of screen still awake after lock #ifndef CONFIG_MACH_LGE_2ND_GEN_KK_WORKAROUD if (led_classdev_register(&i2c_dev->dev, &rt9396_keyled_dev) == 0) { eprintk("Registering led class dev successfully.\n"); drvdata->led = &rt9396_keyled_dev; } #endif i2c_set_clientdata(i2c_dev, drvdata); i2c_set_adapdata(i2c_dev->adapter, i2c_dev); rt9396_device_init(drvdata); rt9396_send_intensity(drvdata, RT9396BL_DEFAULT_BRIGHTNESS); #ifdef CONFIG_HAS_EARLYSUSPEND drvdata->early_suspend.suspend = rt9396_early_suspend; drvdata->early_suspend.resume = rt9396_late_resume; drvdata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40; register_early_suspend(&drvdata->early_suspend); #endif rt9396_ref = drvdata; eprintk("done\n"); return 0; }
static int atmel_pwm_bl_probe(struct platform_device *pdev) { const struct atmel_pwm_bl_platform_data *pdata; struct backlight_device *bldev; struct atmel_pwm_bl *pwmbl; int retval; pwmbl = kzalloc(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 = gpio_request(pwmbl->gpio_on, "gpio_atmel_pwm_bl"); if (retval) { pwmbl->gpio_on = -1; goto err_free_pwm; } retval = gpio_direction_output(pwmbl->gpio_on, 0 ^ pdata->on_active_low); if (retval) goto err_free_gpio; } bldev = backlight_device_register("atmel-pwm-bl", &pdev->dev, pwmbl, &atmel_pwm_bl_ops); if (IS_ERR(bldev)) { retval = PTR_ERR(bldev); goto err_free_gpio; } pwmbl->bldev = bldev; platform_set_drvdata(pdev, pwmbl); bldev->props.power = FB_BLANK_UNBLANK; bldev->props.max_brightness = pdata->pwm_duty_max - pdata->pwm_duty_min; 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_gpio: if (pwmbl->gpio_on != -1) gpio_free(pwmbl->gpio_on); err_free_pwm: pwm_channel_free(&pwmbl->pwmc); err_free_mem: kfree(pwmbl); return retval; }
static int __devinit corgi_lcd_probe(struct spi_device *spi) { struct backlight_properties props; struct corgi_lcd_platform_data *pdata = spi->dev.platform_data; struct corgi_lcd *lcd; int ret = 0; if (pdata == NULL) { dev_err(&spi->dev, "platform data not available\n"); return -EINVAL; } lcd = kzalloc(sizeof(struct corgi_lcd), GFP_KERNEL); if (!lcd) { dev_err(&spi->dev, "failed to allocate memory\n"); return -ENOMEM; } lcd->spi_dev = spi; lcd->lcd_dev = lcd_device_register("corgi_lcd", &spi->dev, lcd, &corgi_lcd_ops); if (IS_ERR(lcd->lcd_dev)) { ret = PTR_ERR(lcd->lcd_dev); goto err_free_lcd; } lcd->power = FB_BLANK_POWERDOWN; lcd->mode = (pdata) ? pdata->init_mode : CORGI_LCD_MODE_VGA; memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = pdata->max_intensity; lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev, lcd, &corgi_bl_ops, &props); if (IS_ERR(lcd->bl_dev)) { ret = PTR_ERR(lcd->bl_dev); goto err_unregister_lcd; } lcd->bl_dev->props.brightness = pdata->default_intensity; lcd->bl_dev->props.power = FB_BLANK_UNBLANK; ret = setup_gpio_backlight(lcd, pdata); if (ret) goto err_unregister_bl; lcd->kick_battery = pdata->kick_battery; dev_set_drvdata(&spi->dev, lcd); corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK); backlight_update_status(lcd->bl_dev); lcd->limit_mask = pdata->limit_mask; the_corgi_lcd = lcd; return 0; err_unregister_bl: backlight_device_unregister(lcd->bl_dev); err_unregister_lcd: lcd_device_unregister(lcd->lcd_dev); err_free_lcd: kfree(lcd); 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_endpoint_descriptor *endpoint; int int_in_endpointAddr = 0; int retval, brightness; char bl_name[20]; /* set up the endpoint information */ /* use only the first interrupt-in endpoint */ retval = usb_find_int_in_endpoint(iface->cur_altsetting, &endpoint); if (retval) { dev_err(&iface->dev, "Could not find int-in endpoint\n"); return retval; } int_in_endpointAddr = endpoint->bEndpointAddress; /* allocate memory for our device state and initialize it */ pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL); if (!pdata) { retval = -ENOMEM; goto error; } pdata->udev = udev; INIT_DELAYED_WORK(&pdata->work, appledisplay_work); mutex_init(&pdata->sysfslock); /* Allocate buffer for control messages */ pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL); if (!pdata->msgdata) { retval = -ENOMEM; goto error; } /* Allocate interrupt URB */ pdata->urb = usb_alloc_urb(0, GFP_KERNEL); if (!pdata->urb) { retval = -ENOMEM; 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); pdata->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 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 (!IS_ERR(pdata->bd)) backlight_device_unregister(pdata->bd); kfree(pdata->msgdata); } usb_set_intfdata(iface, NULL); kfree(pdata); return retval; }
static int __init lm3530_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *i2c_dev_id) { struct lge_backlight_platform_data *pdata; struct lm3530_driver_data *drvdata; struct backlight_device *bd; int err; dprintk("start, client addr=0x%x\n", i2c_dev->addr); pdata = i2c_dev->dev.platform_data; if(!pdata) return -EINVAL; drvdata = kzalloc(sizeof(struct lm3530_driver_data), GFP_KERNEL); if (!drvdata) { dev_err(&i2c_dev->dev, "failed to allocate memory\n"); return -ENOMEM; } if (pdata && pdata->platform_init) pdata->platform_init(); drvdata->client = i2c_dev; drvdata->gpio = pdata->gpio; drvdata->max_intensity = MAX_BRIGHTNESS_LEVEL/*LCD_LED_MAX*/; if (pdata->max_current > 0) drvdata->max_intensity = pdata->max_current; drvdata->intensity = DEFAULT_BRIGHTNESS_LEVEL/*LCD_LED_MIN*/; drvdata->mode = NORMAL_MODE; drvdata->state = UNINIT_STATE; drvdata->version = pdata->version; if(lm3530_setup_version(drvdata) != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } if (drvdata->gpio && gpio_request(drvdata->gpio, "lm3530_en") != 0) { eprintk("Error while requesting gpio %d\n", drvdata->gpio); kfree(drvdata); return -ENODEV; } bd = backlight_device_register("lm3530-bl", &i2c_dev->dev, NULL, &lm3530_ops , NULL); if (bd == NULL) { eprintk("entering lm3530 probe function error \n"); if (gpio_is_valid(drvdata->gpio)) gpio_free(drvdata->gpio); kfree(drvdata); return -1; } bd->props.power = FB_BLANK_UNBLANK; bd->props.brightness = drvdata->intensity; bd->props.max_brightness = drvdata->max_intensity; drvdata->bd = bd; #ifdef CONFIG_BACKLIGHT_LEDS_CLASS if (led_classdev_register(&i2c_dev->dev, &lm3530_led_dev) == 0) { eprintk("Registering led class dev successfully.\n"); drvdata->led = &lm3530_led_dev; err = device_create_file(drvdata->led->dev, &dev_attr_alc); err = device_create_file(drvdata->led->dev, &dev_attr_reg); err = device_create_file(drvdata->led->dev, &dev_attr_drvstat); } #endif i2c_set_clientdata(i2c_dev, drvdata); i2c_set_adapdata(i2c_dev->adapter, i2c_dev); lm3530_device_init(drvdata); lm3530_send_intensity(drvdata, DEFAULT_BRIGHTNESS); #ifdef CONFIG_HAS_EARLYSUSPEND drvdata->early_suspend.suspend = lm3530_early_suspend; drvdata->early_suspend.resume = lm3530_late_resume; drvdata->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40; register_early_suspend(&drvdata->early_suspend); #endif eprintk("done\n"); return 0; }
static int wm831x_backlight_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *wm831x_pdata; struct wm831x_backlight_pdata *pdata; struct wm831x_backlight_data *data; struct backlight_device *bl; struct backlight_properties props; int ret, i, max_isel, isink_reg, dcdc_cfg; if (pdev->dev.parent->platform_data) { wm831x_pdata = pdev->dev.parent->platform_data; pdata = wm831x_pdata->backlight; } else { pdata = NULL; } if (!pdata) { dev_err(&pdev->dev, "No platform data supplied\n"); return -EINVAL; } for (i = 0; i < WM831X_ISINK_MAX_ISEL; i++) { if (wm831x_isinkv_values[i] > pdata->max_uA) break; } if (i == 0) { dev_err(&pdev->dev, "Invalid max_uA: %duA\n", pdata->max_uA); return -EINVAL; } max_isel = i - 1; if (pdata->max_uA != wm831x_isinkv_values[max_isel]) dev_warn(&pdev->dev, "Maximum current is %duA not %duA as requested\n", wm831x_isinkv_values[max_isel], pdata->max_uA); switch (pdata->isink) { case 1: isink_reg = WM831X_CURRENT_SINK_1; dcdc_cfg = 0; break; case 2: isink_reg = WM831X_CURRENT_SINK_2; dcdc_cfg = WM831X_DC4_FBSRC; break; default: dev_err(&pdev->dev, "Invalid ISINK %d\n", pdata->isink); return -EINVAL; } ret = wm831x_reg_unlock(wm831x); if (ret < 0) return ret; ret = wm831x_set_bits(wm831x, WM831X_DC4_CONTROL, WM831X_DC4_FBSRC, dcdc_cfg); wm831x_reg_lock(wm831x); if (ret < 0) return ret; data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; data->wm831x = wm831x; data->current_brightness = 0; data->isink_reg = isink_reg; props.type = BACKLIGHT_RAW; props.max_brightness = max_isel; bl = backlight_device_register("wm831x", &pdev->dev, data, &wm831x_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); return PTR_ERR(bl); } bl->props.brightness = max_isel; platform_set_drvdata(pdev, bl); wm831x_set_bits(wm831x, WM831X_DCDC_ENABLE, WM831X_DC4_ENA, 0); backlight_update_status(bl); return 0; }
static int mdnie_probe(struct platform_device *pdev) { #if defined(CONFIG_FB_MDNIE_PWM) struct platform_mdnie_data *pdata = pdev->dev.platform_data; #endif struct mdnie_info *mdnie; int ret = 0; mdnie_class = class_create(THIS_MODULE, dev_name(&pdev->dev)); if (IS_ERR_OR_NULL(mdnie_class)) { pr_err("failed to create mdnie class\n"); ret = -EINVAL; goto error0; } mdnie_class->dev_attrs = mdnie_attributes; mdnie = kzalloc(sizeof(struct mdnie_info), GFP_KERNEL); if (!mdnie) { pr_err("failed to allocate mdnie\n"); ret = -ENOMEM; goto error1; } mdnie->dev = device_create(mdnie_class, &pdev->dev, 0, &mdnie, "mdnie"); if (IS_ERR_OR_NULL(mdnie->dev)) { pr_err("failed to create mdnie device\n"); ret = -EINVAL; goto error2; } #if defined(CONFIG_FB_MDNIE_PWM) if (!pdata) { pr_err("no platform data specified\n"); ret = -EINVAL; goto error2; } mdnie->bd = backlight_device_register("panel", mdnie->dev, mdnie, &mdnie_backlight_ops, NULL); mdnie->bd->props.max_brightness = MAX_BRIGHTNESS_LEVEL; mdnie->bd->props.brightness = DEFAULT_BRIGHTNESS; mdnie->bd_enable = TRUE; mdnie->lcd_pd = pdata->lcd_pd; ret = device_create_file(&mdnie->bd->dev, &dev_attr_auto_brightness); if (ret < 0) dev_err(&mdnie->bd->dev, "failed to add sysfs entries, %d\n", __LINE__); #endif mdnie->scenario = UI_MODE; mdnie->mode = STANDARD; mdnie->tone = TONE_NORMAL; mdnie->outdoor = OUTDOOR_OFF; #if defined(CONFIG_FB_MDNIE_PWM) mdnie->cabc = CABC_ON; mdnie->power_lut_idx = LUT_LEVEL_MANUAL_AND_INDOOR; mdnie->auto_brightness = 0; #else mdnie->cabc = CABC_OFF; #endif #if defined(CONFIG_FB_S5P_S6C1372) mdnie->cabc = CABC_OFF; #endif mdnie->enable = TRUE; mdnie->tunning = FALSE; mdnie->negative = NEGATIVE_OFF; mutex_init(&mdnie->lock); mutex_init(&mdnie->dev_lock); platform_set_drvdata(pdev, mdnie); dev_set_drvdata(mdnie->dev, mdnie); #ifdef CONFIG_HAS_WAKELOCK #ifdef CONFIG_HAS_EARLYSUSPEND mdnie->early_suspend.suspend = mdnie_early_suspend; mdnie->early_suspend.resume = mdnie_late_resume; mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; register_early_suspend(&mdnie->early_suspend); #endif #endif #if defined(CONFIG_FB_S5P_S6C1372) check_lcd_type(); dev_info(mdnie->dev, "lcdtype = %d\n", pdata->display_type); if (pdata->display_type == 1) { b_value.max = 1441; b_value.mid = 784; b_value.low = 16; b_value.dim = 16; } else { b_value.max = 1216; /* 76% */ b_value.mid = 679; /* 39% */ b_value.low = 16; /* 1% */ b_value.dim = 16; /* 1% */ } #endif #if defined(CONFIG_FB_S5P_S6F1202A) if (pdata->display_type == 0) { memcpy(tunning_table, tunning_table_hydis, sizeof(tunning_table)); memcpy(etc_table, etc_table_hydis, sizeof(etc_table)); memcpy(camera_table, camera_table_hydis, sizeof(camera_table)); } else if (pdata->display_type == 1) { memcpy(tunning_table, tunning_table_sec, sizeof(tunning_table)); memcpy(etc_table, etc_table_sec, sizeof(etc_table)); memcpy(camera_table, camera_table_sec, sizeof(camera_table)); } else if (pdata->display_type == 2) { memcpy(tunning_table, tunning_table_boe, sizeof(tunning_table)); memcpy(etc_table, etc_table_boe, sizeof(etc_table)); memcpy(camera_table, camera_table_boe, sizeof(camera_table)); } #endif g_mdnie = mdnie; set_mdnie_value(mdnie, 0); dev_info(mdnie->dev, "registered successfully\n"); return 0; error2: kfree(mdnie); error1: class_destroy(mdnie_class); error0: return ret; }
static int pwm_backlight_probe(struct platform_device *pdev) { struct platform_pwm_backlight_data *data = dev_get_platdata(&pdev->dev); struct platform_pwm_backlight_data defdata; struct backlight_properties props; struct backlight_device *bl; struct device_node *node = pdev->dev.of_node; struct pwm_bl_data *pb; struct pwm_state state; unsigned int i; int ret; if (!data) { ret = pwm_backlight_parse_dt(&pdev->dev, &defdata); if (ret < 0) { dev_err(&pdev->dev, "failed to find platform data\n"); return ret; } data = &defdata; } if (data->init) { ret = data->init(&pdev->dev); if (ret < 0) return ret; } pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL); if (!pb) { ret = -ENOMEM; goto err_alloc; } pb->notify = data->notify; pb->notify_after = data->notify_after; pb->check_fb = data->check_fb; pb->exit = data->exit; pb->dev = &pdev->dev; pb->enabled = false; pb->post_pwm_on_delay = data->post_pwm_on_delay; pb->pwm_off_delay = data->pwm_off_delay; pb->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable", GPIOD_ASIS); if (IS_ERR(pb->enable_gpio)) { ret = PTR_ERR(pb->enable_gpio); goto err_alloc; } /* * Compatibility fallback for drivers still using the integer GPIO * platform data. Must go away soon. */ if (!pb->enable_gpio && gpio_is_valid(data->enable_gpio)) { ret = devm_gpio_request_one(&pdev->dev, data->enable_gpio, GPIOF_OUT_INIT_HIGH, "enable"); if (ret < 0) { dev_err(&pdev->dev, "failed to request GPIO#%d: %d\n", data->enable_gpio, ret); goto err_alloc; } pb->enable_gpio = gpio_to_desc(data->enable_gpio); } /* * If the GPIO is not known to be already configured as output, that * is, if gpiod_get_direction returns either 1 or -EINVAL, change the * direction to output and set the GPIO as active. * Do not force the GPIO to active when it was already output as it * could cause backlight flickering or we would enable the backlight too * early. Leave the decision of the initial backlight state for later. */ if (pb->enable_gpio && gpiod_get_direction(pb->enable_gpio) != 0) gpiod_direction_output(pb->enable_gpio, 1); pb->power_supply = devm_regulator_get(&pdev->dev, "power"); if (IS_ERR(pb->power_supply)) { ret = PTR_ERR(pb->power_supply); goto err_alloc; } pb->pwm = devm_pwm_get(&pdev->dev, NULL); if (IS_ERR(pb->pwm) && PTR_ERR(pb->pwm) != -EPROBE_DEFER && !node) { dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n"); pb->legacy = true; pb->pwm = pwm_request(data->pwm_id, "pwm-backlight"); } if (IS_ERR(pb->pwm)) { ret = PTR_ERR(pb->pwm); if (ret != -EPROBE_DEFER) dev_err(&pdev->dev, "unable to request PWM\n"); goto err_alloc; } dev_dbg(&pdev->dev, "got pwm for backlight\n"); /* Sync up PWM state. */ pwm_init_state(pb->pwm, &state); /* * The DT case will set the pwm_period_ns field to 0 and store the * period, parsed from the DT, in the PWM device. For the non-DT case, * set the period from platform data if it has not already been set * via the PWM lookup table. */ if (!state.period && (data->pwm_period_ns > 0)) state.period = data->pwm_period_ns; ret = pwm_apply_state(pb->pwm, &state); if (ret) { dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n", ret); goto err_alloc; } if (data->levels) { /* * For the DT case, only when brightness levels is defined * data->levels is filled. For the non-DT case, data->levels * can come from platform data, however is not usual. */ for (i = 0; i <= data->max_brightness; i++) { if (data->levels[i] > pb->scale) pb->scale = data->levels[i]; pb->levels = data->levels; } } else if (!data->max_brightness) { /* * If no brightness levels are provided and max_brightness is * not set, use the default brightness table. For the DT case, * max_brightness is set to 0 when brightness levels is not * specified. For the non-DT case, max_brightness is usually * set to some value. */ /* Get the PWM period (in nanoseconds) */ pwm_get_state(pb->pwm, &state); ret = pwm_backlight_brightness_default(&pdev->dev, data, state.period); if (ret < 0) { dev_err(&pdev->dev, "failed to setup default brightness table\n"); goto err_alloc; } for (i = 0; i <= data->max_brightness; i++) { if (data->levels[i] > pb->scale) pb->scale = data->levels[i]; pb->levels = data->levels; } } else { /* * That only happens for the non-DT case, where platform data * sets the max_brightness value. */ pb->scale = data->max_brightness; } pb->lth_brightness = data->lth_brightness * (state.period / pb->scale); memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = data->max_brightness; bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb, &pwm_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); if (pb->legacy) pwm_free(pb->pwm); goto err_alloc; } if (data->dft_brightness > data->max_brightness) { dev_warn(&pdev->dev, "invalid default brightness level: %u, using %u\n", data->dft_brightness, data->max_brightness); data->dft_brightness = data->max_brightness; } bl->props.brightness = data->dft_brightness; bl->props.power = pwm_backlight_initial_power_state(pb); backlight_update_status(bl); platform_set_drvdata(pdev, bl); return 0; err_alloc: if (data->exit) data->exit(&pdev->dev); return ret; }
static int ltn101al03_panel_probe(struct omap_dss_device *dssdev) { int ret = 0; struct ltn101al03 *lcd = NULL; struct backlight_properties props = { .brightness = BRIGHTNESS_DEFAULT, .max_brightness = 255, .type = BACKLIGHT_RAW, }; pr_info("(%s): called (@%d)\n", __func__, __LINE__); dev_dbg(&dssdev->dev, "ltn101al03_probe\n"); lcd = kzalloc(sizeof(*lcd), GFP_KERNEL); if (!lcd) return -ENOMEM; if (dssdev->data == NULL) { dev_err(&dssdev->dev, "no platform data!\n"); ret = -EINVAL; goto err_no_platform_data; } dssdev->panel.config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS /*| OMAP_DSS_LCD_IEO */ | OMAP_DSS_LCD_IPC | OMAP_DSS_LCD_IHS | OMAP_DSS_LCD_ONOFF; dssdev->panel.acb = 0; dssdev->panel.timings = ltn101al03_panel_timings; lcd->dssdev = dssdev; lcd->pdata = dssdev->data; lcd->bl = get_gamma_value_from_bl(props.brightness); ret = gpio_request(lcd->pdata->lvds_nshdn_gpio, "lvds_nshdn"); if (ret < 0) { dev_err(&dssdev->dev, "gpio_request %d failed!\n", lcd->pdata->lvds_nshdn_gpio); goto err_no_platform_data; } gpio_direction_output(lcd->pdata->lvds_nshdn_gpio, 1); ret = gpio_request(lcd->pdata->led_backlight_reset_gpio, "led_backlight_reset"); if (ret < 0) { dev_err(&dssdev->dev, "gpio_request %d failed!\n", lcd->pdata->led_backlight_reset_gpio); goto err_backlight_reset_gpio_request; } gpio_direction_output(lcd->pdata->led_backlight_reset_gpio, 1); mutex_init(&lcd->lock); dev_set_drvdata(&dssdev->dev, lcd); /* Register DSI backlight control */ lcd->bd = backlight_device_register("panel", &dssdev->dev, dssdev, <n101al03_backlight_ops, &props); if (IS_ERR(lcd->bd)) { ret = PTR_ERR(lcd->bd); goto err_backlight_device_register; } lcd->lcd_class = class_create(THIS_MODULE, "lcd"); if (IS_ERR(lcd->lcd_class)) { pr_err("Failed to create lcd_class!"); goto err_class_create; } lcd->dev = device_create(lcd->lcd_class, NULL, 0, NULL, "panel"); if (IS_ERR(lcd->dev)) { pr_err("Failed to create device(panel)!\n"); goto err_device_create; } dev_set_drvdata(lcd->dev, &dssdev->dev); ret = device_create_file(lcd->dev, &dev_attr_lcd_type); if (ret < 0) { dev_err(&dssdev->dev, "failed to add 'lcd_type' sysfs entries\n"); goto err_lcd_device; } ret = device_create_file(lcd->dev, &dev_attr_lcd_power); if (ret < 0) { dev_err(&dssdev->dev, "failed to add 'lcd_power' sysfs entries\n"); goto err_lcd_type; } ret = backlight_gptimer_init(dssdev); if (ret < 0) { dev_err(&dssdev->dev, "backlight_gptimer_init failed!\n"); goto err_gptimer_init; } /* * if lcd panel was on from bootloader like u-boot then * do not lcd on. */ if (dssdev->skip_init) lcd->enabled = 1; update_brightness(dssdev); dev_dbg(&dssdev->dev, "%s\n", __func__); return ret; err_gptimer_init: device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_power); err_lcd_type: device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_type); err_lcd_device: device_destroy(lcd->lcd_class, 0); err_device_create: class_destroy(lcd->lcd_class); err_class_create: backlight_device_unregister(lcd->bd); err_backlight_device_register: mutex_destroy(&lcd->lock); gpio_free(lcd->pdata->led_backlight_reset_gpio); err_backlight_reset_gpio_request: gpio_free(lcd->pdata->lvds_nshdn_gpio); err_no_platform_data: kfree(lcd); return ret; } static void ltn101al03_panel_remove(struct omap_dss_device *dssdev) { struct ltn101al03 *lcd = dev_get_drvdata(&dssdev->dev); device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_power); device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_type); device_destroy(lcd->lcd_class, 0); class_destroy(lcd->lcd_class); backlight_device_unregister(lcd->bd); mutex_destroy(&lcd->lock); gpio_free(lcd->pdata->led_backlight_reset_gpio); gpio_free(lcd->pdata->lvds_nshdn_gpio); kfree(lcd); } static int ltn101al03_start(struct omap_dss_device *dssdev) { int r = 0; r = ltn101al03_power_on(dssdev); if (r) { dev_dbg(&dssdev->dev, "enable failed\n"); dssdev->state = OMAP_DSS_DISPLAY_DISABLED; } else { dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; dssdev->manager->enable(dssdev->manager); } return r; }
static int lm3630_probe(struct i2c_client *i2c_dev, const struct i2c_device_id *id) { struct backlight_platform_data *pdata; struct lm3630_device *dev; struct backlight_device *bl_dev; struct backlight_properties props; int err; pr_info("[LCD][DEBUG] %s: i2c probe start\n", __func__); #ifdef CONFIG_OF if (&i2c_dev->dev.of_node) { pdata = devm_kzalloc(&i2c_dev->dev, sizeof(struct backlight_platform_data), GFP_KERNEL); if (!pdata) { pr_err("%s: Failed to allocate memory\n", __func__); return -ENOMEM; } err = lm3630_parse_dt(&i2c_dev->dev, pdata); if (err != 0) return err; } else { pdata = i2c_dev->dev.platform_data; } #else pdata = i2c_dev->dev.platform_data; #endif pr_debug("[LCD][DEBUG] %s: gpio = %d\n", __func__,pdata->gpio); if (pdata->gpio && gpio_request(pdata->gpio, "lm3630 reset") != 0) { return -ENODEV; } lm3630_i2c_client = i2c_dev; dev = kzalloc(sizeof(struct lm3630_device), GFP_KERNEL); if (dev == NULL) { dev_err(&i2c_dev->dev, "fail alloc for lm3630_device\n"); return 0; } main_lm3630_dev = dev; memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = MAX_BRIGHTNESS_LM3630; bl_dev = backlight_device_register(I2C_BL_NAME, &i2c_dev->dev, NULL, &lm3630_bl_ops, &props); bl_dev->props.max_brightness = MAX_BRIGHTNESS_LM3630; bl_dev->props.brightness = 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->default_brightness = pdata->default_brightness; dev->max_brightness = pdata->max_brightness; dev->blmap_size = pdata->blmap_size; if (dev->blmap_size) { dev->blmap = kzalloc(sizeof(char) * dev->blmap_size, GFP_KERNEL); if (!dev->blmap) { pr_err("%s: Failed to allocate memory\n", __func__); return -ENOMEM; } memcpy(dev->blmap, pdata->blmap, dev->blmap_size); } else { dev->blmap = NULL; } if (gpio_get_value(dev->gpio)) backlight_status = BL_ON; else backlight_status = BL_OFF; i2c_set_clientdata(i2c_dev, dev); mutex_init(&dev->bl_mutex); err = device_create_file(&i2c_dev->dev, &dev_attr_lm3630_level); err = device_create_file(&i2c_dev->dev, &dev_attr_lm3630_backlight_on_off); err = device_create_file(&i2c_dev->dev, &dev_attr_lm3630_exp_min_value); #if defined(CONFIG_BACKLIGHT_CABC_DEBUG_ENABLE) err = device_create_file(&i2c_dev->dev, &dev_attr_lm3630_pwm); #endif #if defined(CONFIG_MACH_LGE) && !defined(CONFIG_MACH_MSM8974_VU3_KR) && !defined(CONFIG_MACH_MSM8974_Z_KR) && !defined(CONFIG_MACH_MSM8974_Z_US) && !defined(CONFIG_OLED_SUPPORT) if (!lge_get_cont_splash_enabled()) lm3630_lcd_backlight_set_level(0); #endif return 0; }
static int wm831x_backlight_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *wm831x_pdata; struct wm831x_backlight_pdata *pdata; struct wm831x_backlight_data *data; struct backlight_device *bl; struct backlight_properties props; int ret, i, max_isel, isink_reg, dcdc_cfg; /* We need platform data */ if (pdev->dev.parent->platform_data) { wm831x_pdata = pdev->dev.parent->platform_data; pdata = wm831x_pdata->backlight; } else { pdata = NULL; } if (!pdata) { dev_err(&pdev->dev, "No platform data supplied\n"); return -EINVAL; } /* Figure out the maximum current we can use */ for (i = 0; i < WM831X_ISINK_MAX_ISEL; i++) { if (wm831x_isinkv_values[i] > pdata->max_uA) break; } if (i == 0) { dev_err(&pdev->dev, "Invalid max_uA: %duA\n", pdata->max_uA); return -EINVAL; } max_isel = i - 1; max_tp = max_isel; if (pdata->max_uA != wm831x_isinkv_values[max_isel]) dev_warn(&pdev->dev, "Maximum current is %duA not %duA as requested\n", wm831x_isinkv_values[max_isel], pdata->max_uA); switch (pdata->isink) { case 1: isink_reg = WM831X_CURRENT_SINK_1; dcdc_cfg = 0; break; case 2: isink_reg = WM831X_CURRENT_SINK_2; dcdc_cfg = WM831X_DC4_FBSRC; break; default: dev_err(&pdev->dev, "Invalid ISINK %d\n", pdata->isink); return -EINVAL; } /* Configure the ISINK to use for feedback */ ret = wm831x_reg_unlock(wm831x); if (ret < 0) return ret; ret = wm831x_set_bits(wm831x, WM831X_DC4_CONTROL, WM831X_DC4_FBSRC, dcdc_cfg); wm831x_reg_lock(wm831x); if (ret < 0) return ret; data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; data->wm831x = wm831x; data->current_brightness = 0; data->isink_reg = isink_reg; props.max_brightness = max_isel; bl = backlight_device_register("wm831x", &pdev->dev, data, &wm831x_backlight_ops); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); kfree(data); return PTR_ERR(bl); } bl->props.brightness = BL_INIT_VALUE; bl->props.max_brightness= BL_SET; platform_set_drvdata(pdev, bl); #ifdef CONFIG_HAS_EARLYSUSPEND data->early_suspend.level = ~0x0; data->early_suspend.suspend = wm831x_bl_suspend; data->early_suspend.resume = wm831x_bl_resume; register_early_suspend(&data->early_suspend); INIT_DELAYED_WORK(&data->work, wm831x_bl_work); gwm831x_bl = bl; gwm831x_data = data; #endif /* Disable the DCDC if it was started so we can bootstrap */ wm831x_set_bits(wm831x, WM831X_DCDC_ENABLE, WM831X_DC4_ENA, 0); //backlight_update_status(bl); schedule_delayed_work(&data->work, msecs_to_jiffies(100)); return 0; }
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) { printk("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)) { printk(KERN_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 = kzalloc(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 int gen_panel_backlight_probe(struct platform_device *pdev) { struct backlight_device *bd; struct backlight_properties props; struct gen_panel_backlight_info *bl_info; int ret; bool outdoor_mode_en; pr_info("called %s\n", __func__); bl_info = devm_kzalloc(&pdev->dev, sizeof(*bl_info), GFP_KERNEL); if (unlikely(!bl_info)) return -ENOMEM; if (IS_ENABLED(CONFIG_OF)) { struct device_node *np = pdev->dev.of_node; int arr[MAX_BRT_VALUE_IDX * 2], i; ret = of_property_read_string(np, "gen-panel-backlight-name", &bl_info->name); outdoor_mode_en = of_property_read_bool(np, "gen-panel-outdoor-mode-en"); if (outdoor_mode_en) { ret = of_property_read_u32_array(np, "backlight-brt-outdoor",arr, 2); bl_info->outdoor_value.brightness = arr[0]; bl_info->outdoor_value.tune_level = arr[1]; } ret = of_property_read_u32_array(np, "gen-panel-backlight-brt-range", arr, MAX_BRT_VALUE_IDX * 2); for (i = 0; i < MAX_BRT_VALUE_IDX; i++) { bl_info->range[i].brightness = arr[i * 2]; bl_info->range[i].tune_level = arr[i * 2 + 1]; } pr_info("backlight device : %s\n", bl_info->name); pr_info("[BRT_VALUE_OFF] brightness(%d), tune_level(%d)\n", bl_info->range[BRT_VALUE_OFF].brightness, bl_info->range[BRT_VALUE_OFF].tune_level); pr_info("[BRT_VALUE_MIN] brightness(%d), tune_level(%d)\n", bl_info->range[BRT_VALUE_MIN].brightness, bl_info->range[BRT_VALUE_MIN].tune_level); pr_info("[BRT_VALUE_DIM] brightness(%d), tune_level(%d)\n", bl_info->range[BRT_VALUE_DIM].brightness, bl_info->range[BRT_VALUE_DIM].tune_level); pr_info("[BRT_VALUE_DEF] brightness(%d), tune_level(%d)\n", bl_info->range[BRT_VALUE_DEF].brightness, bl_info->range[BRT_VALUE_DEF].tune_level); pr_info("[BRT_VALUE_MAX] brightness(%d), tune_level(%d)\n", bl_info->range[BRT_VALUE_MAX].brightness, bl_info->range[BRT_VALUE_MAX].tune_level); } else { if (unlikely(pdev->dev.platform_data == NULL)) { dev_err(&pdev->dev, "no platform data!\n"); ret = -EINVAL; } } memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = bl_info->range[BRT_VALUE_MAX].brightness; props.brightness = (u8)bl_info->range[BRT_VALUE_DEF].brightness; bl_info->current_brightness = (u8)bl_info->range[BRT_VALUE_DEF].brightness; bd = backlight_device_register(bl_info->name, &pdev->dev, bl_info, &gen_panel_backlight_ops, &props); if (IS_ERR(bd)) { dev_err(&pdev->dev, "failed to register backlight\n"); ret = PTR_ERR(bd); } bl_dev = bd; mutex_init(&bl_info->ops_lock); if (outdoor_mode_en) { ret = device_create_file(&bd->dev, &dev_attr_auto_brightness); if (unlikely(ret < 0)) { pr_err("Failed to create device file(%s)!\n", dev_attr_auto_brightness.attr.name); } } bl_info->enable = true; pm_runtime_enable(&pdev->dev); platform_set_drvdata(pdev, bd); pm_runtime_get_sync(&pdev->dev); return 0; }
static int acx_panel_probe(struct omap_dss_device *dssdev) { int r; struct acx565akm_device *md = &acx_dev; struct backlight_device *bldev; int max_brightness, brightness; struct backlight_properties props; dev_dbg(&dssdev->dev, "%s\n", __func__); dssdev->panel.config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS | OMAP_DSS_LCD_IHS; /* */ dssdev->panel.timings = acx_panel_timings; if (dssdev->platform_enable) dssdev->platform_enable(dssdev); /* */ msleep(5); md->enabled = panel_enabled(md); r = panel_detect(md); if (r) { dev_err(&dssdev->dev, "%s panel detect error\n", __func__); if (!md->enabled && dssdev->platform_disable) dssdev->platform_disable(dssdev); return r; } mutex_lock(&acx_dev.mutex); acx_dev.dssdev = dssdev; mutex_unlock(&acx_dev.mutex); if (!md->enabled) { if (dssdev->platform_disable) dssdev->platform_disable(dssdev); } /* */ props.fb_blank = FB_BLANK_UNBLANK; props.power = FB_BLANK_UNBLANK; props.type = BACKLIGHT_RAW; bldev = backlight_device_register("acx565akm", &md->spi->dev, md, &acx565akm_bl_ops, &props); md->bl_dev = bldev; if (md->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__); backlight_device_unregister(bldev); return r; } md->cabc_mode = get_hw_cabc_mode(md); } if (md->has_bc) max_brightness = 255; else max_brightness = dssdev->max_backlight_level; if (md->has_bc) brightness = acx565akm_get_actual_brightness(md); else if (dssdev->get_backlight) brightness = dssdev->get_backlight(dssdev); else brightness = 0; bldev->props.max_brightness = max_brightness; bldev->props.brightness = brightness; acx565akm_bl_update_status(bldev); return 0; }
static int sgm3727_backlight_probe(struct platform_device *pdev) { struct backlight_properties props; struct platform_sgm3727_backlight_data *data = NULL; struct backlight_device *bl; struct sgm_bl_data *pb; int ret; int bl_delay_on = 0; if (pdev->dev.platform_data) data = pdev->dev.platform_data; else if (pdev->dev.of_node) { u32 val; data = kzalloc(sizeof(struct platform_sgm3727_backlight_data), GFP_KERNEL); if (!data) return -ENOMEM; if (of_property_read_u32(pdev->dev.of_node, "backlight-gpio", &val)) { ret = -EINVAL; goto err_read; } data->bl_gpio = val; if (of_property_read_u32(pdev->dev.of_node, "max-brightness", &val)) { ret = -EINVAL; goto err_read; } data->max_brightness = val; if (of_property_read_u32(pdev->dev.of_node, "dft-brightness", &val)) { ret = -EINVAL; goto err_read; } data->dft_brightness = val; if (of_property_read_u32(pdev->dev.of_node, "shutdown-time", &val)) { ret = -EINVAL; goto err_read; } data->shutdown_time = val; if (of_property_read_u32(pdev->dev.of_node, "ready-time", &val)) { ret = -EINVAL; goto err_read; } data->ready_time = val; if (of_property_read_u32(pdev->dev.of_node, "interval-time", &val)) { ret = -EINVAL; goto err_read; } data->interval_time = val; if (of_property_read_u32(pdev->dev.of_node, "bl-on-delay", &val)) { bl_delay_on = 0; } else bl_delay_on = val; pdev->dev.platform_data = data; } if (!data) { dev_err(&pdev->dev, "failed to find platform data\n"); return -EINVAL; } if (data->init) { ret = data->init(&pdev->dev); if (ret < 0) return ret; } pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL); if (!pb) { dev_err(&pdev->dev, "no memory for state\n"); ret = -ENOMEM; goto err_alloc; } pb->bl_gpio = data->bl_gpio; pb->max_brightness = data->max_brightness; pb->dft_brightness = data->dft_brightness; pb->shutdown_time = data->shutdown_time; pb->ready_time = data->ready_time; pb->interval_time = data->interval_time; pb->notify = data->notify; pb->notify_after = data->notify_after; pb->check_fb = data->check_fb; pb->dev = &pdev->dev; ret = gpio_request(pb->bl_gpio, "gpio_bl"); if (ret < 0) { dev_err(&pdev->dev, "failed to request gpio %d\n", pb->bl_gpio); goto err_alloc; } spin_lock_init(&pb->sgm_spin_lock); memset(&props, 0, sizeof(struct backlight_properties)); props.type = BACKLIGHT_RAW; props.max_brightness = data->max_brightness; bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb, &sgm3727_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); goto err_bl; } bl->props.brightness = data->dft_brightness; pb->last_brightness = 0; pr_info("sgm3727_backlight_probe bl-delay-on %d\r\n", bl_delay_on); if (bl_delay_on == 0) backlight_update_status(bl); else { INIT_DELAYED_WORK(&(pb->bl_delay_on_work), bl_delay_on_func); schedule_delayed_work(&(pb->bl_delay_on_work), msecs_to_jiffies(bl_delay_on)); } platform_set_drvdata(pdev, bl); #ifdef CONFIG_HAS_EARLYSUSPEND pb->bd_early_suspend.suspend = backlight_driver_early_suspend; pb->bd_early_suspend.resume = backlight_driver_late_resume; pb->bd_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; register_early_suspend(&pb->bd_early_suspend); #endif return 0; err_bl: gpio_free(pb->bl_gpio); err_alloc: if (data->exit) data->exit(&pdev->dev); err_read: if (pdev->dev.of_node) kfree(data); return ret; }
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev) { int ret, rc; struct platform_device *msm_fb_added_dev; struct lcd_device *lcd_device; struct backlight_device *bd = NULL; printk(KERN_INFO "[lcd] mipi_samsung_disp_probe start\n"); if (pdev->id == 0) { msd.mipi_samsung_disp_pdata = pdev->dev.platform_data; printk(KERN_INFO "[lcd] pdev->id =%d, pdev-name = %s\n", pdev->id, pdev->name); sec_debug_mdp_init(); printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end since pdev-id is 0\n"); return 0; } printk(KERN_INFO "[lcd] msm_fb_add_device : %s\n", pdev->name); msm_fb_added_dev = msm_fb_add_device(pdev); mutex_init(&dsi_tx_mutex); #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE) msd.msm_pdev = msm_fb_added_dev; #endif pm_gpio8 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_ERR_FG); rc = gpio_request(pm_gpio8, "err_fg"); if (rc) { pr_err("request gpio err_fg failed, rc=%d\n", rc); return -ENODEV; } rc = pm8xxx_gpio_config(pm_gpio8, &gpio_get_param); if (rc) { pr_err("gpio_config mlcd_rst failed (3), rc=%d\n", rc); return -EINVAL; } #if defined(CONFIG_HAS_EARLYSUSPEND) msd.early_suspend.suspend = mipi_samsung_disp_early_suspend; msd.early_suspend.resume = mipi_samsung_disp_late_resume; msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; register_early_suspend(&msd.early_suspend); #endif #if defined(CONFIG_LCD_CLASS_DEVICE) printk(KERN_INFO "[lcd] lcd_device_register for panel start\n"); lcd_device = lcd_device_register("panel", &pdev->dev, NULL, &mipi_samsung_disp_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } sysfs_remove_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_power.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_window_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_window_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_power_reduce.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_power_reduce.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_siop_enable.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_siop_enable.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_backlight.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_backlight.attr.name); } #if defined(RUMTIME_MIPI_CLK_CHANGE) ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_fps_change.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_fps_change.attr.name); } #endif ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_temperature.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_temperature.attr.name); } printk(KERN_INFO "[lcd] backlight_device_register for panel start\n"); bd = backlight_device_register("panel", &lcd_device->dev, NULL, NULL, NULL); if (IS_ERR(bd)) { ret = PTR_ERR(bd); pr_info("backlight : failed to register device\n"); return ret; } ret = sysfs_create_file(&bd->dev.kobj, &dev_attr_auto_brightness.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_auto_brightness.attr.name); } #endif #if defined(CONFIG_MDNIE_LITE_TUNING) pr_info("[%s] CONFIG_MDNIE_LITE_TUNING ok ! init class called!\n", __func__); mdnie_lite_tuning_init(); #endif #if defined(DDI_VIDEO_ENHANCE_TUNING) ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_tuning.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_tuning.attr.name); } #endif printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end\n"); return 0; }
void radeonfb_bl_init(struct radeonfb_info *rinfo) { struct backlight_device *bd; struct radeon_bl_privdata *pdata; char name[12]; if (rinfo->mon1_type != MT_LCD) return; #ifdef CONFIG_PMAC_BACKLIGHT if (!pmac_has_backlight_type("ati") && !pmac_has_backlight_type("mnca")) return; #endif pdata = kmalloc(sizeof(struct radeon_bl_privdata), GFP_KERNEL); if (!pdata) { printk("radeonfb: Memory allocation failed\n"); goto error; } snprintf(name, sizeof(name), "radeonbl%d", rinfo->info->node); bd = backlight_device_register(name, rinfo->info->dev, pdata, &radeon_bl_data); if (IS_ERR(bd)) { rinfo->info->bl_dev = NULL; printk("radeonfb: Backlight registration failed\n"); goto error; } pdata->rinfo = rinfo; /* Pardon me for that hack... maybe some day we can figure out in what * direction backlight should work on a given panel? */ pdata->negative = (rinfo->family != CHIP_FAMILY_RV200 && rinfo->family != CHIP_FAMILY_RV250 && rinfo->family != CHIP_FAMILY_RV280 && rinfo->family != CHIP_FAMILY_RV350); #ifdef CONFIG_PMAC_BACKLIGHT pdata->negative = pdata->negative || of_machine_is_compatible("PowerBook4,3") || of_machine_is_compatible("PowerBook6,3") || of_machine_is_compatible("PowerBook6,5"); #endif rinfo->info->bl_dev = bd; fb_bl_default_curve(rinfo->info, 0, 63 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL, 217 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL); bd->props.max_brightness = FB_BACKLIGHT_LEVELS - 1; bd->props.brightness = bd->props.max_brightness; bd->props.power = FB_BLANK_UNBLANK; backlight_update_status(bd); printk("radeonfb: Backlight initialized (%s)\n", name); return; error: kfree(pdata); return; }