mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-16 07:24:39 +08:00
a0386bba70
The value returned by an spi driver's remove function is mostly ignored. (Only an error message is printed if the value is non-zero that the error is ignored.) So change the prototype of the remove function to return no value. This way driver authors are not tempted to assume that passing an error to the upper layer is a good idea. All drivers are adapted accordingly. There is no intended change of behaviour, all callbacks were prepared to return 0 before. Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Acked-by: Marc Kleine-Budde <mkl@pengutronix.de> Acked-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Reviewed-by: Geert Uytterhoeven <geert+renesas@glider.be> Acked-by: Jérôme Pouiller <jerome.pouiller@silabs.com> Acked-by: Miquel Raynal <miquel.raynal@bootlin.com> Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com> Acked-by: Claudius Heine <ch@denx.de> Acked-by: Stefan Schmidt <stefan@datenfreihafen.org> Acked-by: Alexandre Belloni <alexandre.belloni@bootlin.com> Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # For MMC Acked-by: Marcus Folkesson <marcus.folkesson@gmail.com> Acked-by: Łukasz Stelmach <l.stelmach@samsung.com> Acked-by: Lee Jones <lee.jones@linaro.org> Link: https://lore.kernel.org/r/20220123175201.34839-6-u.kleine-koenig@pengutronix.de Signed-off-by: Mark Brown <broonie@kernel.org>
570 lines
15 KiB
C
570 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* LCD/Backlight Driver for Sharp Zaurus Handhelds (various models)
|
|
*
|
|
* Copyright (c) 2004-2006 Richard Purdie
|
|
*
|
|
* Based on Sharp's 2.4 Backlight Driver
|
|
*
|
|
* Copyright (c) 2008 Marvell International Ltd.
|
|
* Converted to SPI device based LCD/Backlight device driver
|
|
* by Eric Miao <eric.miao@marvell.com>
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/fb.h>
|
|
#include <linux/lcd.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/spi/corgi_lcd.h>
|
|
#include <linux/slab.h>
|
|
#include <asm/mach/sharpsl_param.h>
|
|
|
|
#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL)
|
|
|
|
/* Register Addresses */
|
|
#define RESCTL_ADRS 0x00
|
|
#define PHACTRL_ADRS 0x01
|
|
#define DUTYCTRL_ADRS 0x02
|
|
#define POWERREG0_ADRS 0x03
|
|
#define POWERREG1_ADRS 0x04
|
|
#define GPOR3_ADRS 0x05
|
|
#define PICTRL_ADRS 0x06
|
|
#define POLCTRL_ADRS 0x07
|
|
|
|
/* Register Bit Definitions */
|
|
#define RESCTL_QVGA 0x01
|
|
#define RESCTL_VGA 0x00
|
|
|
|
#define POWER1_VW_ON 0x01 /* VW Supply FET ON */
|
|
#define POWER1_GVSS_ON 0x02 /* GVSS(-8V) Power Supply ON */
|
|
#define POWER1_VDD_ON 0x04 /* VDD(8V),SVSS(-4V) Power Supply ON */
|
|
|
|
#define POWER1_VW_OFF 0x00 /* VW Supply FET OFF */
|
|
#define POWER1_GVSS_OFF 0x00 /* GVSS(-8V) Power Supply OFF */
|
|
#define POWER1_VDD_OFF 0x00 /* VDD(8V),SVSS(-4V) Power Supply OFF */
|
|
|
|
#define POWER0_COM_DCLK 0x01 /* COM Voltage DC Bias DAC Serial Data Clock */
|
|
#define POWER0_COM_DOUT 0x02 /* COM Voltage DC Bias DAC Serial Data Out */
|
|
#define POWER0_DAC_ON 0x04 /* DAC Power Supply ON */
|
|
#define POWER0_COM_ON 0x08 /* COM Power Supply ON */
|
|
#define POWER0_VCC5_ON 0x10 /* VCC5 Power Supply ON */
|
|
|
|
#define POWER0_DAC_OFF 0x00 /* DAC Power Supply OFF */
|
|
#define POWER0_COM_OFF 0x00 /* COM Power Supply OFF */
|
|
#define POWER0_VCC5_OFF 0x00 /* VCC5 Power Supply OFF */
|
|
|
|
#define PICTRL_INIT_STATE 0x01
|
|
#define PICTRL_INIOFF 0x02
|
|
#define PICTRL_POWER_DOWN 0x04
|
|
#define PICTRL_COM_SIGNAL_OFF 0x08
|
|
#define PICTRL_DAC_SIGNAL_OFF 0x10
|
|
|
|
#define POLCTRL_SYNC_POL_FALL 0x01
|
|
#define POLCTRL_EN_POL_FALL 0x02
|
|
#define POLCTRL_DATA_POL_FALL 0x04
|
|
#define POLCTRL_SYNC_ACT_H 0x08
|
|
#define POLCTRL_EN_ACT_L 0x10
|
|
|
|
#define POLCTRL_SYNC_POL_RISE 0x00
|
|
#define POLCTRL_EN_POL_RISE 0x00
|
|
#define POLCTRL_DATA_POL_RISE 0x00
|
|
#define POLCTRL_SYNC_ACT_L 0x00
|
|
#define POLCTRL_EN_ACT_H 0x00
|
|
|
|
#define PHACTRL_PHASE_MANUAL 0x01
|
|
#define DEFAULT_PHAD_QVGA (9)
|
|
#define DEFAULT_COMADJ (125)
|
|
|
|
struct corgi_lcd {
|
|
struct spi_device *spi_dev;
|
|
struct lcd_device *lcd_dev;
|
|
struct backlight_device *bl_dev;
|
|
|
|
int limit_mask;
|
|
int intensity;
|
|
int power;
|
|
int mode;
|
|
char buf[2];
|
|
|
|
struct gpio_desc *backlight_on;
|
|
struct gpio_desc *backlight_cont;
|
|
|
|
void (*kick_battery)(void);
|
|
};
|
|
|
|
static int corgi_ssp_lcdtg_send(struct corgi_lcd *lcd, int reg, uint8_t val);
|
|
|
|
static struct corgi_lcd *the_corgi_lcd;
|
|
static unsigned long corgibl_flags;
|
|
#define CORGIBL_SUSPENDED 0x01
|
|
#define CORGIBL_BATTLOW 0x02
|
|
|
|
/*
|
|
* This is only a pseudo I2C interface. We can't use the standard kernel
|
|
* routines as the interface is write only. We just assume the data is acked...
|
|
*/
|
|
static void lcdtg_ssp_i2c_send(struct corgi_lcd *lcd, uint8_t data)
|
|
{
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS, data);
|
|
udelay(10);
|
|
}
|
|
|
|
static void lcdtg_i2c_send_bit(struct corgi_lcd *lcd, uint8_t data)
|
|
{
|
|
lcdtg_ssp_i2c_send(lcd, data);
|
|
lcdtg_ssp_i2c_send(lcd, data | POWER0_COM_DCLK);
|
|
lcdtg_ssp_i2c_send(lcd, data);
|
|
}
|
|
|
|
static void lcdtg_i2c_send_start(struct corgi_lcd *lcd, uint8_t base)
|
|
{
|
|
lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK | POWER0_COM_DOUT);
|
|
lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK);
|
|
lcdtg_ssp_i2c_send(lcd, base);
|
|
}
|
|
|
|
static void lcdtg_i2c_send_stop(struct corgi_lcd *lcd, uint8_t base)
|
|
{
|
|
lcdtg_ssp_i2c_send(lcd, base);
|
|
lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK);
|
|
lcdtg_ssp_i2c_send(lcd, base | POWER0_COM_DCLK | POWER0_COM_DOUT);
|
|
}
|
|
|
|
static void lcdtg_i2c_send_byte(struct corgi_lcd *lcd,
|
|
uint8_t base, uint8_t data)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (data & 0x80)
|
|
lcdtg_i2c_send_bit(lcd, base | POWER0_COM_DOUT);
|
|
else
|
|
lcdtg_i2c_send_bit(lcd, base);
|
|
data <<= 1;
|
|
}
|
|
}
|
|
|
|
static void lcdtg_i2c_wait_ack(struct corgi_lcd *lcd, uint8_t base)
|
|
{
|
|
lcdtg_i2c_send_bit(lcd, base);
|
|
}
|
|
|
|
static void lcdtg_set_common_voltage(struct corgi_lcd *lcd,
|
|
uint8_t base_data, uint8_t data)
|
|
{
|
|
/* Set Common Voltage to M62332FP via I2C */
|
|
lcdtg_i2c_send_start(lcd, base_data);
|
|
lcdtg_i2c_send_byte(lcd, base_data, 0x9c);
|
|
lcdtg_i2c_wait_ack(lcd, base_data);
|
|
lcdtg_i2c_send_byte(lcd, base_data, 0x00);
|
|
lcdtg_i2c_wait_ack(lcd, base_data);
|
|
lcdtg_i2c_send_byte(lcd, base_data, data);
|
|
lcdtg_i2c_wait_ack(lcd, base_data);
|
|
lcdtg_i2c_send_stop(lcd, base_data);
|
|
}
|
|
|
|
static int corgi_ssp_lcdtg_send(struct corgi_lcd *lcd, int adrs, uint8_t data)
|
|
{
|
|
struct spi_message msg;
|
|
struct spi_transfer xfer = {
|
|
.len = 1,
|
|
.cs_change = 0,
|
|
.tx_buf = lcd->buf,
|
|
};
|
|
|
|
lcd->buf[0] = ((adrs & 0x07) << 5) | (data & 0x1f);
|
|
spi_message_init(&msg);
|
|
spi_message_add_tail(&xfer, &msg);
|
|
|
|
return spi_sync(lcd->spi_dev, &msg);
|
|
}
|
|
|
|
/* Set Phase Adjust */
|
|
static void lcdtg_set_phadadj(struct corgi_lcd *lcd, int mode)
|
|
{
|
|
int adj;
|
|
|
|
switch (mode) {
|
|
case CORGI_LCD_MODE_VGA:
|
|
/* Setting for VGA */
|
|
adj = sharpsl_param.phadadj;
|
|
adj = (adj < 0) ? PHACTRL_PHASE_MANUAL :
|
|
PHACTRL_PHASE_MANUAL | ((adj & 0xf) << 1);
|
|
break;
|
|
case CORGI_LCD_MODE_QVGA:
|
|
default:
|
|
/* Setting for QVGA */
|
|
adj = (DEFAULT_PHAD_QVGA << 1) | PHACTRL_PHASE_MANUAL;
|
|
break;
|
|
}
|
|
|
|
corgi_ssp_lcdtg_send(lcd, PHACTRL_ADRS, adj);
|
|
}
|
|
|
|
static void corgi_lcd_power_on(struct corgi_lcd *lcd)
|
|
{
|
|
int comadj;
|
|
|
|
/* Initialize Internal Logic & Port */
|
|
corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS,
|
|
PICTRL_POWER_DOWN | PICTRL_INIOFF |
|
|
PICTRL_INIT_STATE | PICTRL_COM_SIGNAL_OFF |
|
|
PICTRL_DAC_SIGNAL_OFF);
|
|
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_OFF |
|
|
POWER0_COM_OFF | POWER0_VCC5_OFF);
|
|
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_OFF);
|
|
|
|
/* VDD(+8V), SVSS(-4V) ON */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_ON);
|
|
mdelay(3);
|
|
|
|
/* DAC ON */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON |
|
|
POWER0_COM_OFF | POWER0_VCC5_OFF);
|
|
|
|
/* INIB = H, INI = L */
|
|
/* PICTL[0] = H , PICTL[1] = PICTL[2] = PICTL[4] = L */
|
|
corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS,
|
|
PICTRL_INIT_STATE | PICTRL_COM_SIGNAL_OFF);
|
|
|
|
/* Set Common Voltage */
|
|
comadj = sharpsl_param.comadj;
|
|
if (comadj < 0)
|
|
comadj = DEFAULT_COMADJ;
|
|
|
|
lcdtg_set_common_voltage(lcd, POWER0_DAC_ON | POWER0_COM_OFF |
|
|
POWER0_VCC5_OFF, comadj);
|
|
|
|
/* VCC5 ON, DAC ON */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON |
|
|
POWER0_COM_OFF | POWER0_VCC5_ON);
|
|
|
|
/* GVSS(-8V) ON, VDD ON */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_OFF | POWER1_GVSS_ON | POWER1_VDD_ON);
|
|
mdelay(2);
|
|
|
|
/* COM SIGNAL ON (PICTL[3] = L) */
|
|
corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS, PICTRL_INIT_STATE);
|
|
|
|
/* COM ON, DAC ON, VCC5_ON */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_COM_DCLK | POWER0_COM_DOUT | POWER0_DAC_ON |
|
|
POWER0_COM_ON | POWER0_VCC5_ON);
|
|
|
|
/* VW ON, GVSS ON, VDD ON */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_ON | POWER1_GVSS_ON | POWER1_VDD_ON);
|
|
|
|
/* Signals output enable */
|
|
corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS, 0);
|
|
|
|
/* Set Phase Adjust */
|
|
lcdtg_set_phadadj(lcd, lcd->mode);
|
|
|
|
/* Initialize for Input Signals from ATI */
|
|
corgi_ssp_lcdtg_send(lcd, POLCTRL_ADRS,
|
|
POLCTRL_SYNC_POL_RISE | POLCTRL_EN_POL_RISE |
|
|
POLCTRL_DATA_POL_RISE | POLCTRL_SYNC_ACT_L |
|
|
POLCTRL_EN_ACT_H);
|
|
udelay(1000);
|
|
|
|
switch (lcd->mode) {
|
|
case CORGI_LCD_MODE_VGA:
|
|
corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_VGA);
|
|
break;
|
|
case CORGI_LCD_MODE_QVGA:
|
|
default:
|
|
corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_QVGA);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void corgi_lcd_power_off(struct corgi_lcd *lcd)
|
|
{
|
|
/* 60Hz x 2 frame = 16.7msec x 2 = 33.4 msec */
|
|
msleep(34);
|
|
|
|
/* (1)VW OFF */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_OFF | POWER1_GVSS_ON | POWER1_VDD_ON);
|
|
|
|
/* (2)COM OFF */
|
|
corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS, PICTRL_COM_SIGNAL_OFF);
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_ON);
|
|
|
|
/* (3)Set Common Voltage Bias 0V */
|
|
lcdtg_set_common_voltage(lcd, POWER0_DAC_ON | POWER0_COM_OFF |
|
|
POWER0_VCC5_ON, 0);
|
|
|
|
/* (4)GVSS OFF */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_ON);
|
|
|
|
/* (5)VCC5 OFF */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_DAC_ON | POWER0_COM_OFF | POWER0_VCC5_OFF);
|
|
|
|
/* (6)Set PDWN, INIOFF, DACOFF */
|
|
corgi_ssp_lcdtg_send(lcd, PICTRL_ADRS,
|
|
PICTRL_INIOFF | PICTRL_DAC_SIGNAL_OFF |
|
|
PICTRL_POWER_DOWN | PICTRL_COM_SIGNAL_OFF);
|
|
|
|
/* (7)DAC OFF */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG0_ADRS,
|
|
POWER0_DAC_OFF | POWER0_COM_OFF | POWER0_VCC5_OFF);
|
|
|
|
/* (8)VDD OFF */
|
|
corgi_ssp_lcdtg_send(lcd, POWERREG1_ADRS,
|
|
POWER1_VW_OFF | POWER1_GVSS_OFF | POWER1_VDD_OFF);
|
|
}
|
|
|
|
static int corgi_lcd_set_mode(struct lcd_device *ld, struct fb_videomode *m)
|
|
{
|
|
struct corgi_lcd *lcd = lcd_get_data(ld);
|
|
int mode = CORGI_LCD_MODE_QVGA;
|
|
|
|
if (m->xres == 640 || m->xres == 480)
|
|
mode = CORGI_LCD_MODE_VGA;
|
|
|
|
if (lcd->mode == mode)
|
|
return 0;
|
|
|
|
lcdtg_set_phadadj(lcd, mode);
|
|
|
|
switch (mode) {
|
|
case CORGI_LCD_MODE_VGA:
|
|
corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_VGA);
|
|
break;
|
|
case CORGI_LCD_MODE_QVGA:
|
|
default:
|
|
corgi_ssp_lcdtg_send(lcd, RESCTL_ADRS, RESCTL_QVGA);
|
|
break;
|
|
}
|
|
|
|
lcd->mode = mode;
|
|
return 0;
|
|
}
|
|
|
|
static int corgi_lcd_set_power(struct lcd_device *ld, int power)
|
|
{
|
|
struct corgi_lcd *lcd = lcd_get_data(ld);
|
|
|
|
if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power))
|
|
corgi_lcd_power_on(lcd);
|
|
|
|
if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power))
|
|
corgi_lcd_power_off(lcd);
|
|
|
|
lcd->power = power;
|
|
return 0;
|
|
}
|
|
|
|
static int corgi_lcd_get_power(struct lcd_device *ld)
|
|
{
|
|
struct corgi_lcd *lcd = lcd_get_data(ld);
|
|
|
|
return lcd->power;
|
|
}
|
|
|
|
static struct lcd_ops corgi_lcd_ops = {
|
|
.get_power = corgi_lcd_get_power,
|
|
.set_power = corgi_lcd_set_power,
|
|
.set_mode = corgi_lcd_set_mode,
|
|
};
|
|
|
|
static int corgi_bl_get_intensity(struct backlight_device *bd)
|
|
{
|
|
struct corgi_lcd *lcd = bl_get_data(bd);
|
|
|
|
return lcd->intensity;
|
|
}
|
|
|
|
static int corgi_bl_set_intensity(struct corgi_lcd *lcd, int intensity)
|
|
{
|
|
int cont;
|
|
|
|
if (intensity > 0x10)
|
|
intensity += 0x10;
|
|
|
|
corgi_ssp_lcdtg_send(lcd, DUTYCTRL_ADRS, intensity);
|
|
|
|
/* Bit 5 via GPIO_BACKLIGHT_CONT */
|
|
cont = !!(intensity & 0x20);
|
|
|
|
if (lcd->backlight_cont)
|
|
gpiod_set_value_cansleep(lcd->backlight_cont, cont);
|
|
|
|
if (lcd->backlight_on)
|
|
gpiod_set_value_cansleep(lcd->backlight_on, intensity);
|
|
|
|
if (lcd->kick_battery)
|
|
lcd->kick_battery();
|
|
|
|
lcd->intensity = intensity;
|
|
return 0;
|
|
}
|
|
|
|
static int corgi_bl_update_status(struct backlight_device *bd)
|
|
{
|
|
struct corgi_lcd *lcd = bl_get_data(bd);
|
|
int intensity = backlight_get_brightness(bd);
|
|
|
|
if (corgibl_flags & CORGIBL_SUSPENDED)
|
|
intensity = 0;
|
|
|
|
if ((corgibl_flags & CORGIBL_BATTLOW) && intensity > lcd->limit_mask)
|
|
intensity = lcd->limit_mask;
|
|
|
|
return corgi_bl_set_intensity(lcd, intensity);
|
|
}
|
|
|
|
void corgi_lcd_limit_intensity(int limit)
|
|
{
|
|
if (limit)
|
|
corgibl_flags |= CORGIBL_BATTLOW;
|
|
else
|
|
corgibl_flags &= ~CORGIBL_BATTLOW;
|
|
|
|
backlight_update_status(the_corgi_lcd->bl_dev);
|
|
}
|
|
EXPORT_SYMBOL(corgi_lcd_limit_intensity);
|
|
|
|
static const struct backlight_ops corgi_bl_ops = {
|
|
.get_brightness = corgi_bl_get_intensity,
|
|
.update_status = corgi_bl_update_status,
|
|
};
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int corgi_lcd_suspend(struct device *dev)
|
|
{
|
|
struct corgi_lcd *lcd = dev_get_drvdata(dev);
|
|
|
|
corgibl_flags |= CORGIBL_SUSPENDED;
|
|
corgi_bl_set_intensity(lcd, 0);
|
|
corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
|
|
return 0;
|
|
}
|
|
|
|
static int corgi_lcd_resume(struct device *dev)
|
|
{
|
|
struct corgi_lcd *lcd = dev_get_drvdata(dev);
|
|
|
|
corgibl_flags &= ~CORGIBL_SUSPENDED;
|
|
corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_UNBLANK);
|
|
backlight_update_status(lcd->bl_dev);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static SIMPLE_DEV_PM_OPS(corgi_lcd_pm_ops, corgi_lcd_suspend, corgi_lcd_resume);
|
|
|
|
static int setup_gpio_backlight(struct corgi_lcd *lcd,
|
|
struct corgi_lcd_platform_data *pdata)
|
|
{
|
|
struct spi_device *spi = lcd->spi_dev;
|
|
|
|
lcd->backlight_on = devm_gpiod_get_optional(&spi->dev,
|
|
"BL_ON", GPIOD_OUT_LOW);
|
|
if (IS_ERR(lcd->backlight_on))
|
|
return PTR_ERR(lcd->backlight_on);
|
|
|
|
lcd->backlight_cont = devm_gpiod_get_optional(&spi->dev, "BL_CONT",
|
|
GPIOD_OUT_LOW);
|
|
if (IS_ERR(lcd->backlight_cont))
|
|
return PTR_ERR(lcd->backlight_cont);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int corgi_lcd_probe(struct spi_device *spi)
|
|
{
|
|
struct backlight_properties props;
|
|
struct corgi_lcd_platform_data *pdata = dev_get_platdata(&spi->dev);
|
|
struct corgi_lcd *lcd;
|
|
int ret = 0;
|
|
|
|
if (pdata == NULL) {
|
|
dev_err(&spi->dev, "platform data not available\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
lcd = devm_kzalloc(&spi->dev, sizeof(struct corgi_lcd), GFP_KERNEL);
|
|
if (!lcd)
|
|
return -ENOMEM;
|
|
|
|
lcd->spi_dev = spi;
|
|
|
|
lcd->lcd_dev = devm_lcd_device_register(&spi->dev, "corgi_lcd",
|
|
&spi->dev, lcd, &corgi_lcd_ops);
|
|
if (IS_ERR(lcd->lcd_dev))
|
|
return PTR_ERR(lcd->lcd_dev);
|
|
|
|
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 = devm_backlight_device_register(&spi->dev, "corgi_bl",
|
|
&spi->dev, lcd, &corgi_bl_ops,
|
|
&props);
|
|
if (IS_ERR(lcd->bl_dev))
|
|
return PTR_ERR(lcd->bl_dev);
|
|
|
|
lcd->bl_dev->props.brightness = pdata->default_intensity;
|
|
lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
|
|
|
|
ret = setup_gpio_backlight(lcd, pdata);
|
|
if (ret)
|
|
return ret;
|
|
|
|
lcd->kick_battery = pdata->kick_battery;
|
|
|
|
spi_set_drvdata(spi, 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;
|
|
}
|
|
|
|
static void corgi_lcd_remove(struct spi_device *spi)
|
|
{
|
|
struct corgi_lcd *lcd = spi_get_drvdata(spi);
|
|
|
|
lcd->bl_dev->props.power = FB_BLANK_UNBLANK;
|
|
lcd->bl_dev->props.brightness = 0;
|
|
backlight_update_status(lcd->bl_dev);
|
|
corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
|
|
}
|
|
|
|
static struct spi_driver corgi_lcd_driver = {
|
|
.driver = {
|
|
.name = "corgi-lcd",
|
|
.pm = &corgi_lcd_pm_ops,
|
|
},
|
|
.probe = corgi_lcd_probe,
|
|
.remove = corgi_lcd_remove,
|
|
};
|
|
|
|
module_spi_driver(corgi_lcd_driver);
|
|
|
|
MODULE_DESCRIPTION("LCD and backlight driver for SHARP C7x0/Cxx00");
|
|
MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("spi:corgi-lcd");
|