mirror of
https://github.com/torvalds/linux.git
synced 2024-12-11 05:33:09 +00: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>
565 lines
12 KiB
C
565 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* ams369fg06 AMOLED LCD panel driver.
|
|
*
|
|
* Copyright (c) 2011 Samsung Electronics Co., Ltd.
|
|
* Author: Jingoo Han <jg1.han@samsung.com>
|
|
*
|
|
* Derived from drivers/video/s6e63m0.c
|
|
*/
|
|
|
|
#include <linux/backlight.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/fb.h>
|
|
#include <linux/lcd.h>
|
|
#include <linux/module.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/wait.h>
|
|
|
|
#define SLEEPMSEC 0x1000
|
|
#define ENDDEF 0x2000
|
|
#define DEFMASK 0xFF00
|
|
#define COMMAND_ONLY 0xFE
|
|
#define DATA_ONLY 0xFF
|
|
|
|
#define MAX_GAMMA_LEVEL 5
|
|
#define GAMMA_TABLE_COUNT 21
|
|
|
|
#define MIN_BRIGHTNESS 0
|
|
#define MAX_BRIGHTNESS 255
|
|
#define DEFAULT_BRIGHTNESS 150
|
|
|
|
struct ams369fg06 {
|
|
struct device *dev;
|
|
struct spi_device *spi;
|
|
unsigned int power;
|
|
struct lcd_device *ld;
|
|
struct backlight_device *bd;
|
|
struct lcd_platform_data *lcd_pd;
|
|
};
|
|
|
|
static const unsigned short seq_display_on[] = {
|
|
0x14, 0x03,
|
|
ENDDEF, 0x0000
|
|
};
|
|
|
|
static const unsigned short seq_display_off[] = {
|
|
0x14, 0x00,
|
|
ENDDEF, 0x0000
|
|
};
|
|
|
|
static const unsigned short seq_stand_by_on[] = {
|
|
0x1D, 0xA1,
|
|
SLEEPMSEC, 200,
|
|
ENDDEF, 0x0000
|
|
};
|
|
|
|
static const unsigned short seq_stand_by_off[] = {
|
|
0x1D, 0xA0,
|
|
SLEEPMSEC, 250,
|
|
ENDDEF, 0x0000
|
|
};
|
|
|
|
static const unsigned short seq_setting[] = {
|
|
0x31, 0x08,
|
|
0x32, 0x14,
|
|
0x30, 0x02,
|
|
0x27, 0x01,
|
|
0x12, 0x08,
|
|
0x13, 0x08,
|
|
0x15, 0x00,
|
|
0x16, 0x00,
|
|
|
|
0xef, 0xd0,
|
|
DATA_ONLY, 0xe8,
|
|
|
|
0x39, 0x44,
|
|
0x40, 0x00,
|
|
0x41, 0x3f,
|
|
0x42, 0x2a,
|
|
0x43, 0x27,
|
|
0x44, 0x27,
|
|
0x45, 0x1f,
|
|
0x46, 0x44,
|
|
0x50, 0x00,
|
|
0x51, 0x00,
|
|
0x52, 0x17,
|
|
0x53, 0x24,
|
|
0x54, 0x26,
|
|
0x55, 0x1f,
|
|
0x56, 0x43,
|
|
0x60, 0x00,
|
|
0x61, 0x3f,
|
|
0x62, 0x2a,
|
|
0x63, 0x25,
|
|
0x64, 0x24,
|
|
0x65, 0x1b,
|
|
0x66, 0x5c,
|
|
|
|
0x17, 0x22,
|
|
0x18, 0x33,
|
|
0x19, 0x03,
|
|
0x1a, 0x01,
|
|
0x22, 0xa4,
|
|
0x23, 0x00,
|
|
0x26, 0xa0,
|
|
|
|
0x1d, 0xa0,
|
|
SLEEPMSEC, 300,
|
|
|
|
0x14, 0x03,
|
|
|
|
ENDDEF, 0x0000
|
|
};
|
|
|
|
/* gamma value: 2.2 */
|
|
static const unsigned int ams369fg06_22_250[] = {
|
|
0x00, 0x3f, 0x2a, 0x27, 0x27, 0x1f, 0x44,
|
|
0x00, 0x00, 0x17, 0x24, 0x26, 0x1f, 0x43,
|
|
0x00, 0x3f, 0x2a, 0x25, 0x24, 0x1b, 0x5c,
|
|
};
|
|
|
|
static const unsigned int ams369fg06_22_200[] = {
|
|
0x00, 0x3f, 0x28, 0x29, 0x27, 0x21, 0x3e,
|
|
0x00, 0x00, 0x10, 0x25, 0x27, 0x20, 0x3d,
|
|
0x00, 0x3f, 0x28, 0x27, 0x25, 0x1d, 0x53,
|
|
};
|
|
|
|
static const unsigned int ams369fg06_22_150[] = {
|
|
0x00, 0x3f, 0x2d, 0x29, 0x28, 0x23, 0x37,
|
|
0x00, 0x00, 0x0b, 0x25, 0x28, 0x22, 0x36,
|
|
0x00, 0x3f, 0x2b, 0x28, 0x26, 0x1f, 0x4a,
|
|
};
|
|
|
|
static const unsigned int ams369fg06_22_100[] = {
|
|
0x00, 0x3f, 0x30, 0x2a, 0x2b, 0x24, 0x2f,
|
|
0x00, 0x00, 0x00, 0x25, 0x29, 0x24, 0x2e,
|
|
0x00, 0x3f, 0x2f, 0x29, 0x29, 0x21, 0x3f,
|
|
};
|
|
|
|
static const unsigned int ams369fg06_22_50[] = {
|
|
0x00, 0x3f, 0x3c, 0x2c, 0x2d, 0x27, 0x24,
|
|
0x00, 0x00, 0x00, 0x22, 0x2a, 0x27, 0x23,
|
|
0x00, 0x3f, 0x3b, 0x2c, 0x2b, 0x24, 0x31,
|
|
};
|
|
|
|
struct ams369fg06_gamma {
|
|
unsigned int *gamma_22_table[MAX_GAMMA_LEVEL];
|
|
};
|
|
|
|
static struct ams369fg06_gamma gamma_table = {
|
|
.gamma_22_table[0] = (unsigned int *)&ams369fg06_22_50,
|
|
.gamma_22_table[1] = (unsigned int *)&ams369fg06_22_100,
|
|
.gamma_22_table[2] = (unsigned int *)&ams369fg06_22_150,
|
|
.gamma_22_table[3] = (unsigned int *)&ams369fg06_22_200,
|
|
.gamma_22_table[4] = (unsigned int *)&ams369fg06_22_250,
|
|
};
|
|
|
|
static int ams369fg06_spi_write_byte(struct ams369fg06 *lcd, int addr, int data)
|
|
{
|
|
u16 buf[1];
|
|
struct spi_message msg;
|
|
|
|
struct spi_transfer xfer = {
|
|
.len = 2,
|
|
.tx_buf = buf,
|
|
};
|
|
|
|
buf[0] = (addr << 8) | data;
|
|
|
|
spi_message_init(&msg);
|
|
spi_message_add_tail(&xfer, &msg);
|
|
|
|
return spi_sync(lcd->spi, &msg);
|
|
}
|
|
|
|
static int ams369fg06_spi_write(struct ams369fg06 *lcd, unsigned char address,
|
|
unsigned char command)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (address != DATA_ONLY)
|
|
ret = ams369fg06_spi_write_byte(lcd, 0x70, address);
|
|
if (command != COMMAND_ONLY)
|
|
ret = ams369fg06_spi_write_byte(lcd, 0x72, command);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_panel_send_sequence(struct ams369fg06 *lcd,
|
|
const unsigned short *wbuf)
|
|
{
|
|
int ret = 0, i = 0;
|
|
|
|
while ((wbuf[i] & DEFMASK) != ENDDEF) {
|
|
if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
|
|
ret = ams369fg06_spi_write(lcd, wbuf[i], wbuf[i+1]);
|
|
if (ret)
|
|
break;
|
|
} else {
|
|
msleep(wbuf[i+1]);
|
|
}
|
|
i += 2;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int _ams369fg06_gamma_ctl(struct ams369fg06 *lcd,
|
|
const unsigned int *gamma)
|
|
{
|
|
unsigned int i = 0;
|
|
int ret = 0;
|
|
|
|
for (i = 0 ; i < GAMMA_TABLE_COUNT / 3; i++) {
|
|
ret = ams369fg06_spi_write(lcd, 0x40 + i, gamma[i]);
|
|
ret = ams369fg06_spi_write(lcd, 0x50 + i, gamma[i+7*1]);
|
|
ret = ams369fg06_spi_write(lcd, 0x60 + i, gamma[i+7*2]);
|
|
if (ret) {
|
|
dev_err(lcd->dev, "failed to set gamma table.\n");
|
|
goto gamma_err;
|
|
}
|
|
}
|
|
|
|
gamma_err:
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_gamma_ctl(struct ams369fg06 *lcd, int brightness)
|
|
{
|
|
int ret = 0;
|
|
int gamma = 0;
|
|
|
|
if ((brightness >= 0) && (brightness <= 50))
|
|
gamma = 0;
|
|
else if ((brightness > 50) && (brightness <= 100))
|
|
gamma = 1;
|
|
else if ((brightness > 100) && (brightness <= 150))
|
|
gamma = 2;
|
|
else if ((brightness > 150) && (brightness <= 200))
|
|
gamma = 3;
|
|
else if ((brightness > 200) && (brightness <= 255))
|
|
gamma = 4;
|
|
|
|
ret = _ams369fg06_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_ldi_init(struct ams369fg06 *lcd)
|
|
{
|
|
int ret, i;
|
|
static const unsigned short *init_seq[] = {
|
|
seq_setting,
|
|
seq_stand_by_off,
|
|
};
|
|
|
|
for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
|
|
ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_ldi_enable(struct ams369fg06 *lcd)
|
|
{
|
|
int ret, i;
|
|
static const unsigned short *init_seq[] = {
|
|
seq_stand_by_off,
|
|
seq_display_on,
|
|
};
|
|
|
|
for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
|
|
ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_ldi_disable(struct ams369fg06 *lcd)
|
|
{
|
|
int ret, i;
|
|
|
|
static const unsigned short *init_seq[] = {
|
|
seq_display_off,
|
|
seq_stand_by_on,
|
|
};
|
|
|
|
for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
|
|
ret = ams369fg06_panel_send_sequence(lcd, init_seq[i]);
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_power_is_on(int power)
|
|
{
|
|
return power <= FB_BLANK_NORMAL;
|
|
}
|
|
|
|
static int ams369fg06_power_on(struct ams369fg06 *lcd)
|
|
{
|
|
int ret = 0;
|
|
struct lcd_platform_data *pd;
|
|
struct backlight_device *bd;
|
|
|
|
pd = lcd->lcd_pd;
|
|
bd = lcd->bd;
|
|
|
|
if (pd->power_on) {
|
|
pd->power_on(lcd->ld, 1);
|
|
msleep(pd->power_on_delay);
|
|
}
|
|
|
|
if (!pd->reset) {
|
|
dev_err(lcd->dev, "reset is NULL.\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
pd->reset(lcd->ld);
|
|
msleep(pd->reset_delay);
|
|
|
|
ret = ams369fg06_ldi_init(lcd);
|
|
if (ret) {
|
|
dev_err(lcd->dev, "failed to initialize ldi.\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = ams369fg06_ldi_enable(lcd);
|
|
if (ret) {
|
|
dev_err(lcd->dev, "failed to enable ldi.\n");
|
|
return ret;
|
|
}
|
|
|
|
/* set brightness to current value after power on or resume. */
|
|
ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
|
|
if (ret) {
|
|
dev_err(lcd->dev, "lcd gamma setting failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ams369fg06_power_off(struct ams369fg06 *lcd)
|
|
{
|
|
int ret;
|
|
struct lcd_platform_data *pd;
|
|
|
|
pd = lcd->lcd_pd;
|
|
|
|
ret = ams369fg06_ldi_disable(lcd);
|
|
if (ret) {
|
|
dev_err(lcd->dev, "lcd setting failed.\n");
|
|
return -EIO;
|
|
}
|
|
|
|
msleep(pd->power_off_delay);
|
|
|
|
if (pd->power_on)
|
|
pd->power_on(lcd->ld, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ams369fg06_power(struct ams369fg06 *lcd, int power)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (ams369fg06_power_is_on(power) &&
|
|
!ams369fg06_power_is_on(lcd->power))
|
|
ret = ams369fg06_power_on(lcd);
|
|
else if (!ams369fg06_power_is_on(power) &&
|
|
ams369fg06_power_is_on(lcd->power))
|
|
ret = ams369fg06_power_off(lcd);
|
|
|
|
if (!ret)
|
|
lcd->power = power;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int ams369fg06_get_power(struct lcd_device *ld)
|
|
{
|
|
struct ams369fg06 *lcd = lcd_get_data(ld);
|
|
|
|
return lcd->power;
|
|
}
|
|
|
|
static int ams369fg06_set_power(struct lcd_device *ld, int power)
|
|
{
|
|
struct ams369fg06 *lcd = lcd_get_data(ld);
|
|
|
|
if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
|
|
power != FB_BLANK_NORMAL) {
|
|
dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return ams369fg06_power(lcd, power);
|
|
}
|
|
|
|
static int ams369fg06_set_brightness(struct backlight_device *bd)
|
|
{
|
|
int ret = 0;
|
|
int brightness = bd->props.brightness;
|
|
struct ams369fg06 *lcd = bl_get_data(bd);
|
|
|
|
if (brightness < MIN_BRIGHTNESS ||
|
|
brightness > bd->props.max_brightness) {
|
|
dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
|
|
MIN_BRIGHTNESS, MAX_BRIGHTNESS);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ams369fg06_gamma_ctl(lcd, bd->props.brightness);
|
|
if (ret) {
|
|
dev_err(&bd->dev, "lcd brightness setting failed.\n");
|
|
return -EIO;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct lcd_ops ams369fg06_lcd_ops = {
|
|
.get_power = ams369fg06_get_power,
|
|
.set_power = ams369fg06_set_power,
|
|
};
|
|
|
|
static const struct backlight_ops ams369fg06_backlight_ops = {
|
|
.update_status = ams369fg06_set_brightness,
|
|
};
|
|
|
|
static int ams369fg06_probe(struct spi_device *spi)
|
|
{
|
|
int ret = 0;
|
|
struct ams369fg06 *lcd = NULL;
|
|
struct lcd_device *ld = NULL;
|
|
struct backlight_device *bd = NULL;
|
|
struct backlight_properties props;
|
|
|
|
lcd = devm_kzalloc(&spi->dev, sizeof(struct ams369fg06), GFP_KERNEL);
|
|
if (!lcd)
|
|
return -ENOMEM;
|
|
|
|
/* ams369fg06 lcd panel uses 3-wire 16bits SPI Mode. */
|
|
spi->bits_per_word = 16;
|
|
|
|
ret = spi_setup(spi);
|
|
if (ret < 0) {
|
|
dev_err(&spi->dev, "spi setup failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
lcd->spi = spi;
|
|
lcd->dev = &spi->dev;
|
|
|
|
lcd->lcd_pd = dev_get_platdata(&spi->dev);
|
|
if (!lcd->lcd_pd) {
|
|
dev_err(&spi->dev, "platform data is NULL\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ld = devm_lcd_device_register(&spi->dev, "ams369fg06", &spi->dev, lcd,
|
|
&ams369fg06_lcd_ops);
|
|
if (IS_ERR(ld))
|
|
return PTR_ERR(ld);
|
|
|
|
lcd->ld = ld;
|
|
|
|
memset(&props, 0, sizeof(struct backlight_properties));
|
|
props.type = BACKLIGHT_RAW;
|
|
props.max_brightness = MAX_BRIGHTNESS;
|
|
|
|
bd = devm_backlight_device_register(&spi->dev, "ams369fg06-bl",
|
|
&spi->dev, lcd,
|
|
&ams369fg06_backlight_ops, &props);
|
|
if (IS_ERR(bd))
|
|
return PTR_ERR(bd);
|
|
|
|
bd->props.brightness = DEFAULT_BRIGHTNESS;
|
|
lcd->bd = bd;
|
|
|
|
if (!lcd->lcd_pd->lcd_enabled) {
|
|
/*
|
|
* if lcd panel was off from bootloader then
|
|
* current lcd status is powerdown and then
|
|
* it enables lcd panel.
|
|
*/
|
|
lcd->power = FB_BLANK_POWERDOWN;
|
|
|
|
ams369fg06_power(lcd, FB_BLANK_UNBLANK);
|
|
} else {
|
|
lcd->power = FB_BLANK_UNBLANK;
|
|
}
|
|
|
|
spi_set_drvdata(spi, lcd);
|
|
|
|
dev_info(&spi->dev, "ams369fg06 panel driver has been probed.\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ams369fg06_remove(struct spi_device *spi)
|
|
{
|
|
struct ams369fg06 *lcd = spi_get_drvdata(spi);
|
|
|
|
ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
|
|
}
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int ams369fg06_suspend(struct device *dev)
|
|
{
|
|
struct ams369fg06 *lcd = dev_get_drvdata(dev);
|
|
|
|
dev_dbg(dev, "lcd->power = %d\n", lcd->power);
|
|
|
|
/*
|
|
* when lcd panel is suspend, lcd panel becomes off
|
|
* regardless of status.
|
|
*/
|
|
return ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
|
|
}
|
|
|
|
static int ams369fg06_resume(struct device *dev)
|
|
{
|
|
struct ams369fg06 *lcd = dev_get_drvdata(dev);
|
|
|
|
lcd->power = FB_BLANK_POWERDOWN;
|
|
|
|
return ams369fg06_power(lcd, FB_BLANK_UNBLANK);
|
|
}
|
|
#endif
|
|
|
|
static SIMPLE_DEV_PM_OPS(ams369fg06_pm_ops, ams369fg06_suspend,
|
|
ams369fg06_resume);
|
|
|
|
static void ams369fg06_shutdown(struct spi_device *spi)
|
|
{
|
|
struct ams369fg06 *lcd = spi_get_drvdata(spi);
|
|
|
|
ams369fg06_power(lcd, FB_BLANK_POWERDOWN);
|
|
}
|
|
|
|
static struct spi_driver ams369fg06_driver = {
|
|
.driver = {
|
|
.name = "ams369fg06",
|
|
.pm = &ams369fg06_pm_ops,
|
|
},
|
|
.probe = ams369fg06_probe,
|
|
.remove = ams369fg06_remove,
|
|
.shutdown = ams369fg06_shutdown,
|
|
};
|
|
|
|
module_spi_driver(ams369fg06_driver);
|
|
|
|
MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
|
|
MODULE_DESCRIPTION("ams369fg06 LCD Driver");
|
|
MODULE_LICENSE("GPL");
|