static int __devinit crd080ti01_40nm01_remove(struct platform_device *pdev)
{
struct crd080ti01_40nm01_data *dev = dev_get_drvdata(&pdev->dev);
lcd_device_unregister(dev->lcd);
crd080ti01_40nm01_off(dev);
regulator_put(dev->lcd_vcc_reg);
if (dev->pdata->gpio_lr)
gpio_free(dev->pdata->gpio_lr);
if (dev->pdata->gpio_ud)
gpio_free(dev->pdata->gpio_ud);
if (dev->pdata->gpio_selb)
gpio_free(dev->pdata->gpio_selb);
if (dev->pdata->gpio_stbyb)
gpio_free(dev->pdata->gpio_stbyb);
if (dev->pdata->gpio_rest)
gpio_free(dev->pdata->gpio_rest);
dev_set_drvdata(&pdev->dev, NULL);
kfree(dev);
return 0;
}
static int hx8357_remove(struct spi_device *spi)
{
struct lcd_device *lcdev = spi_get_drvdata(spi);
lcd_device_unregister(lcdev);
return 0;
}
static void s5p_dp_shutdown(struct platform_device *pdev)
{
struct s5p_dp_device *dp = platform_get_drvdata(pdev);
struct s5p_dp_platdata *pdata = dp->dev->platform_data;
#ifdef CONFIG_S5P_DP_PSR
mutex_lock(&dp->lock);
dp->user_disabled = true;
fb_unregister_client(&dp->notifier);
mutex_unlock(&dp->lock);
#endif
lcd_device_unregister(dp->lcd);
if (pdata->backlight_off)
pdata->backlight_off();
if (pdata->lcd_off)
pdata->lcd_off();
s5p_dp_disable(dp);
free_irq(dp->irq, dp);
iounmap(dp->reg_base);
clk_put(dp->clock);
release_mem_region(dp->res->start, resource_size(dp->res));
pm_runtime_disable(dp->dev);
kfree(dp);
}
static int __devexit lcd_pwrctrl_remove(struct platform_device *pdev)
{
struct lcd_pwrctrl *lp = platform_get_drvdata(pdev);
lcd_device_unregister(lp->lcd);
gpio_free(lp->pdata->gpio);
return 0;
}
static int s5p_dp_shutdown(struct platform_device *pdev)
{
struct s5p_dp_device *dp = platform_get_drvdata(pdev);
struct s5p_dp_platdata *pdata = dp->dev->platform_data;
lcd_device_unregister(dp->lcd);
if (pdata->backlight_off)
pdata->backlight_off();
if (pdata->lcd_off)
pdata->lcd_off();
s5p_dp_disable(dp);
free_irq(dp->irq, dp);
iounmap(dp->reg_base);
clk_put(dp->clock);
release_mem_region(dp->res->start, resource_size(dp->res));
pm_runtime_disable(dp->dev);
kfree(dp);
return 0;
}
static int __devexit s5p_dp_remove(struct platform_device *pdev)
{
struct s5p_dp_device *dp = platform_get_drvdata(pdev);
#ifdef CONFIG_S5P_DP_PSR
mutex_lock(&dp->lock);
fb_unregister_client(&dp->notifier);
mutex_unlock(&dp->lock);
#endif
free_irq(dp->irq, dp);
lcd_device_unregister(dp->lcd);
s5p_dp_disable(dp);
iounmap(dp->reg_base);
clk_put(dp->clock);
release_mem_region(dp->res->start, resource_size(dp->res));
pm_runtime_disable(dp->dev);
kfree(dp);
return 0;
}
static int __devinit corgi_lcd_probe(struct spi_device *spi)
{
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;
lcd->bl_dev = backlight_device_register("corgi_bl", &spi->dev,
lcd, &corgi_bl_ops);
if (IS_ERR(lcd->bl_dev)) {
ret = PTR_ERR(lcd->bl_dev);
goto err_unregister_lcd;
}
lcd->bl_dev->props.max_brightness = pdata->max_intensity;
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 void s5p_dp_shutdown(struct platform_device *pdev)
{
struct s5p_dp_device *dp = platform_get_drvdata(pdev);
struct s5p_dp_platdata *pdata = dp->dev->platform_data;
lcd_device_unregister(dp->lcd);
if (pdata->backlight_off)
pdata->backlight_off();
if (pdata->lcd_off)
pdata->lcd_off();
s5p_dp_disable(dp);
#if !defined(CONFIG_SOC_EXYNOS5260)
free_irq(dp->irq, dp);
#endif
iounmap(dp->reg_base);
clk_put(dp->clock);
release_mem_region(dp->res->start, resource_size(dp->res));
pm_runtime_disable(dp->dev);
kfree(dp);
}
void picolcd_exit_lcd(struct picolcd_data *data)
{
struct lcd_device *ldev = data->lcd;
data->lcd = NULL;
if (ldev)
lcd_device_unregister(ldev);
}
static int ili922x_remove(struct spi_device *spi)
{
struct ili922x *ili = spi_get_drvdata(spi);
ili922x_poweroff(spi);
lcd_device_unregister(ili->ld);
return 0;
}
static int aximx5_lcd_remove(struct platform_device *dev)
{
debug_func ("\n");
lcd_device_unregister (mqfb_lcd_device);
return 0;
}
static int lms283gf05_remove(struct spi_device *spi)
{
struct lms283gf05_state *st = dev_get_drvdata(&spi->dev);
lcd_device_unregister(st->ld);
return 0;
}
static int jornada_lcd_remove(struct platform_device *pdev)
{
struct lcd_device *lcd_device = platform_get_drvdata(pdev);
lcd_device_unregister(lcd_device);
return 0;
}
static int roverp5p_fp_remove (struct device *dev)
{
debug_func ("\n");
backlight_device_unregister (mqfb_backlight_device);
lcd_device_unregister (mqfb_lcd_device);
return 0;
}
static int __devexit platform_lcd_remove(struct platform_device *pdev)
{
struct platform_lcd *plcd = platform_get_drvdata(pdev);
lcd_device_unregister(plcd->lcd);
kfree(plcd);
return 0;
}
static int h3600_lcd_remove (struct platform_device *pdev)
{
h3600_lcd_set_power(h3600_lcd_device, 4);
lcd_device_unregister (h3600_lcd_device);
sa1100fb_lcd_power = NULL;
return 0;
}
int __devexit ili9320_remove(struct ili9320 *ili)
{
ili9320_power(ili, FB_BLANK_POWERDOWN);
lcd_device_unregister(ili->lcd);
kfree(ili);
return 0;
}
static int __devexit s6c1372_remove(struct platform_device *pdev)
{
struct s6c1372_lcd *lcd = dev_get_drvdata(&pdev->dev);
lcd_device_unregister(lcd->ld);
kfree(lcd);
return 0;
}
/*
* ubicom32lcdpower_remove
*/
static int __exit ubicom32lcdpower_remove(struct platform_device *pdev)
{
struct ubicom32lcdpower_data *ud = platform_get_drvdata(pdev);
lcd_device_unregister(ud->lcddev);
platform_set_drvdata(pdev, NULL);
kfree(ud);
return 0;
}
static int __devexit ea8061_remove(struct device *dev)
{
struct lcd_info *lcd = dev_get_drvdata(dev);
ea8061_power(lcd, FB_BLANK_POWERDOWN);
lcd_device_unregister(lcd->ld);
backlight_device_unregister(lcd->bd);
kfree(lcd);
return 0;
}
static int truly_tft240240_remove(struct platform_device *pdev)
{
struct truly_tft240240_data *dev = dev_get_drvdata(&pdev->dev);
if (dev->lcd_power)
dev->ctrl->power_on(dev->lcd, 0);
regulator_put(dev->lcd_vcc_reg);
lcd_device_unregister(dev->lcd);
dev_set_drvdata(&pdev->dev, NULL);
kfree(dev);
return 0;
}
static int __devexit l4f00242t03_remove(struct spi_device *spi)
{
struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
lcd_device_unregister(priv->ld);
dev_set_drvdata(&spi->dev, NULL);
regulator_put(priv->io_reg);
regulator_put(priv->core_reg);
return 0;
}
static int corgi_lcd_remove(struct spi_device *spi)
{
struct corgi_lcd *lcd = dev_get_drvdata(&spi->dev);
lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
lcd->bl_dev->props.brightness = 0;
backlight_update_status(lcd->bl_dev);
backlight_device_unregister(lcd->bl_dev);
corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
lcd_device_unregister(lcd->lcd_dev);
return 0;
}
static int __devexit lms283gf05_remove(struct spi_device *spi)
{
struct lms283gf05_state *st = dev_get_drvdata(&spi->dev);
struct lms283gf05_pdata *pdata = st->spi->dev.platform_data;
lcd_device_unregister(st->ld);
if (pdata != NULL)
gpio_free(pdata->reset_gpio);
kfree(st);
return 0;
}
static int cr_backlight_remove(struct platform_device *pdev)
{
struct cr_panel *crp = platform_get_drvdata(pdev);
crp->cr_backlight_device->props.power = FB_BLANK_POWERDOWN;
crp->cr_backlight_device->props.brightness = 0;
crp->cr_backlight_device->props.max_brightness = 0;
cr_backlight_set_intensity(crp->cr_backlight_device);
cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_POWERDOWN);
backlight_device_unregister(crp->cr_backlight_device);
lcd_device_unregister(crp->cr_lcd_device);
pci_dev_put(lpc_dev);
return 0;
}
static int __devexit s6e8ax0_remove(struct device *dev)
{
struct lcd_info *lcd = dev_get_drvdata(dev);
#ifdef CONFIG_FB_S5P_PREVENTESD
mutex_lock(&s3cfb_lock);
#endif
s6e8ax0_power(lcd, FB_BLANK_POWERDOWN);
lcd_device_unregister(lcd->ld);
backlight_device_unregister(lcd->bd);
kfree(lcd);
#ifdef CONFIG_FB_S5P_PREVENTESD
mutex_unlock(&s3cfb_lock);
#endif
return 0;
}
static int
aximx3_lcd_init (void)
{
if (! machine_is_aximx3 ())
return -ENODEV;
set_pxa_fb_info(&aximx3_fb_info);
pxafb_lcd_device = lcd_device_register("pxafb", NULL, &aximx3_lcd_properties);
if (IS_ERR (pxafb_lcd_device))
return PTR_ERR (pxafb_lcd_device);
pxafb_backlight_device = backlight_device_register("pxafb", NULL,
&aximx3_backlight_properties);
if (IS_ERR (pxafb_backlight_device)) {
lcd_device_unregister (pxafb_lcd_device);
return PTR_ERR (pxafb_backlight_device);
}
return 0;
}
static int __devexit l4f00242t03_remove(struct spi_device *spi)
{
struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;
l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
lcd_device_unregister(priv->ld);
dev_set_drvdata(&spi->dev, NULL);
gpio_free(pdata->data_enable_gpio);
gpio_free(pdata->reset_gpio);
regulator_put(priv->io_reg);
regulator_put(priv->core_reg);
kfree(priv);
return 0;
}
static int __devexit corgi_lcd_remove(struct spi_device *spi)
{
struct corgi_lcd *lcd = dev_get_drvdata(&spi->dev);
lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
lcd->bl_dev->props.brightness = 0;
backlight_update_status(lcd->bl_dev);
backlight_device_unregister(lcd->bl_dev);
if (gpio_is_valid(lcd->gpio_backlight_on))
gpio_free(lcd->gpio_backlight_on);
if (gpio_is_valid(lcd->gpio_backlight_cont))
gpio_free(lcd->gpio_backlight_cont);
corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
lcd_device_unregister(lcd->lcd_dev);
kfree(lcd);
return 0;
}
static int __devexit s5p_dp_remove(struct platform_device *pdev)
{
struct s5p_dp_device *dp = platform_get_drvdata(pdev);
free_irq(dp->irq, dp);
lcd_device_unregister(dp->lcd);
s5p_dp_disable(dp);
iounmap(dp->reg_base);
clk_put(dp->clock);
release_mem_region(dp->res->start, resource_size(dp->res));
pm_runtime_disable(dp->dev);
kfree(dp);
return 0;
}
