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