mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 18:14:07 +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>
441 lines
13 KiB
C
441 lines
13 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Panel driver for the WideChips WS2401 480x800 DPI RGB panel, used in
|
|
* the Samsung Mobile Display (SMD) LMS380KF01.
|
|
* Found in the Samsung Galaxy Ace 2 GT-I8160 mobile phone.
|
|
* Linus Walleij <linus.walleij@linaro.org>
|
|
* Inspired by code and know-how in the vendor driver by Gareth Phillips.
|
|
*/
|
|
#include <drm/drm_mipi_dbi.h>
|
|
#include <drm/drm_modes.h>
|
|
#include <drm/drm_panel.h>
|
|
|
|
#include <linux/backlight.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/media-bus-format.h>
|
|
#include <linux/module.h>
|
|
#include <linux/regulator/consumer.h>
|
|
#include <linux/spi/spi.h>
|
|
|
|
#include <video/mipi_display.h>
|
|
|
|
#define WS2401_RESCTL 0xb8 /* Resolution select control */
|
|
#define WS2401_PSMPS 0xbd /* SMPS positive control */
|
|
#define WS2401_NSMPS 0xbe /* SMPS negative control */
|
|
#define WS2401_SMPS 0xbf
|
|
#define WS2401_BCMODE 0xc1 /* Backlight control mode */
|
|
#define WS2401_WRBLCTL 0xc3 /* Backlight control */
|
|
#define WS2401_WRDISBV 0xc4 /* Write manual brightness */
|
|
#define WS2401_WRCTRLD 0xc6 /* Write BL control */
|
|
#define WS2401_WRMIE 0xc7 /* Write MIE mode */
|
|
#define WS2401_READ_ID1 0xda /* Read panel ID 1 */
|
|
#define WS2401_READ_ID2 0xdb /* Read panel ID 2 */
|
|
#define WS2401_READ_ID3 0xdc /* Read panel ID 3 */
|
|
#define WS2401_GAMMA_R1 0xe7 /* Gamma red 1 */
|
|
#define WS2401_GAMMA_G1 0xe8 /* Gamma green 1 */
|
|
#define WS2401_GAMMA_B1 0xe9 /* Gamma blue 1 */
|
|
#define WS2401_GAMMA_R2 0xea /* Gamma red 2 */
|
|
#define WS2401_GAMMA_G2 0xeb /* Gamma green 2 */
|
|
#define WS2401_GAMMA_B2 0xec /* Gamma blue 2 */
|
|
#define WS2401_PASSWD1 0xf0 /* Password command for level 2 */
|
|
#define WS2401_DISCTL 0xf2 /* Display control */
|
|
#define WS2401_PWRCTL 0xf3 /* Power control */
|
|
#define WS2401_VCOMCTL 0xf4 /* VCOM control */
|
|
#define WS2401_SRCCTL 0xf5 /* Source control */
|
|
#define WS2401_PANELCTL 0xf6 /* Panel control */
|
|
|
|
static const u8 ws2401_dbi_read_commands[] = {
|
|
WS2401_READ_ID1,
|
|
WS2401_READ_ID2,
|
|
WS2401_READ_ID3,
|
|
0, /* sentinel */
|
|
};
|
|
|
|
/**
|
|
* struct ws2401 - state container for a panel controlled by the WS2401
|
|
* controller
|
|
*/
|
|
struct ws2401 {
|
|
/** @dev: the container device */
|
|
struct device *dev;
|
|
/** @dbi: the DBI bus abstraction handle */
|
|
struct mipi_dbi dbi;
|
|
/** @panel: the DRM panel instance for this device */
|
|
struct drm_panel panel;
|
|
/** @width: the width of this panel in mm */
|
|
u32 width;
|
|
/** @height: the height of this panel in mm */
|
|
u32 height;
|
|
/** @reset: reset GPIO line */
|
|
struct gpio_desc *reset;
|
|
/** @regulators: VCCIO and VIO supply regulators */
|
|
struct regulator_bulk_data regulators[2];
|
|
/** @internal_bl: If using internal backlight */
|
|
bool internal_bl;
|
|
};
|
|
|
|
static const struct drm_display_mode lms380kf01_480_800_mode = {
|
|
/*
|
|
* The vendor driver states that the "SMD panel" has a clock
|
|
* frequency of 49920000 Hz / 2 = 24960000 Hz.
|
|
*/
|
|
.clock = 24960,
|
|
.hdisplay = 480,
|
|
.hsync_start = 480 + 8,
|
|
.hsync_end = 480 + 8 + 10,
|
|
.htotal = 480 + 8 + 10 + 8,
|
|
.vdisplay = 800,
|
|
.vsync_start = 800 + 8,
|
|
.vsync_end = 800 + 8 + 2,
|
|
.vtotal = 800 + 8 + 2 + 18,
|
|
.width_mm = 50,
|
|
.height_mm = 84,
|
|
.flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC,
|
|
};
|
|
|
|
static inline struct ws2401 *to_ws2401(struct drm_panel *panel)
|
|
{
|
|
return container_of(panel, struct ws2401, panel);
|
|
}
|
|
|
|
static void ws2401_read_mtp_id(struct ws2401 *ws)
|
|
{
|
|
struct mipi_dbi *dbi = &ws->dbi;
|
|
u8 id1, id2, id3;
|
|
int ret;
|
|
|
|
ret = mipi_dbi_command_read(dbi, WS2401_READ_ID1, &id1);
|
|
if (ret) {
|
|
dev_err(ws->dev, "unable to read MTP ID 1\n");
|
|
return;
|
|
}
|
|
ret = mipi_dbi_command_read(dbi, WS2401_READ_ID2, &id2);
|
|
if (ret) {
|
|
dev_err(ws->dev, "unable to read MTP ID 2\n");
|
|
return;
|
|
}
|
|
ret = mipi_dbi_command_read(dbi, WS2401_READ_ID3, &id3);
|
|
if (ret) {
|
|
dev_err(ws->dev, "unable to read MTP ID 3\n");
|
|
return;
|
|
}
|
|
dev_info(ws->dev, "MTP ID: %02x %02x %02x\n", id1, id2, id3);
|
|
}
|
|
|
|
static int ws2401_power_on(struct ws2401 *ws)
|
|
{
|
|
struct mipi_dbi *dbi = &ws->dbi;
|
|
int ret;
|
|
|
|
/* Power up */
|
|
ret = regulator_bulk_enable(ARRAY_SIZE(ws->regulators),
|
|
ws->regulators);
|
|
if (ret) {
|
|
dev_err(ws->dev, "failed to enable regulators: %d\n", ret);
|
|
return ret;
|
|
}
|
|
msleep(10);
|
|
|
|
/* Assert reset >=1 ms */
|
|
gpiod_set_value_cansleep(ws->reset, 1);
|
|
usleep_range(1000, 5000);
|
|
/* De-assert reset */
|
|
gpiod_set_value_cansleep(ws->reset, 0);
|
|
/* Wait >= 10 ms */
|
|
msleep(10);
|
|
dev_dbg(ws->dev, "de-asserted RESET\n");
|
|
|
|
/*
|
|
* Exit sleep mode and initialize display - some hammering is
|
|
* necessary.
|
|
*/
|
|
mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
|
|
mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
|
|
msleep(50);
|
|
|
|
/* Magic to unlock level 2 control of the display */
|
|
mipi_dbi_command(dbi, WS2401_PASSWD1, 0x5a, 0x5a);
|
|
/* Configure resolution to 480RGBx800 */
|
|
mipi_dbi_command(dbi, WS2401_RESCTL, 0x12);
|
|
/* Set addressing mode Flip V(d0), Flip H(d1) RGB/BGR(d3) */
|
|
mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, 0x01);
|
|
/* Set pixel format: 24 bpp */
|
|
mipi_dbi_command(dbi, MIPI_DCS_SET_PIXEL_FORMAT, 0x70);
|
|
mipi_dbi_command(dbi, WS2401_SMPS, 0x00, 0x0f);
|
|
mipi_dbi_command(dbi, WS2401_PSMPS, 0x06, 0x03, /* DDVDH: 4.6v */
|
|
0x7e, 0x03, 0x12, 0x37);
|
|
mipi_dbi_command(dbi, WS2401_NSMPS, 0x06, 0x03, /* DDVDH: -4.6v */
|
|
0x7e, 0x02, 0x15, 0x37);
|
|
mipi_dbi_command(dbi, WS2401_SMPS, 0x02, 0x0f);
|
|
mipi_dbi_command(dbi, WS2401_PWRCTL, 0x10, 0xA9, 0x00, 0x01, 0x44,
|
|
0xb4, /* VGH:16.1v, VGL:-13.8v */
|
|
0x50, /* GREFP:4.2v (default) */
|
|
0x50, /* GREFN:-4.2v (default) */
|
|
0x00,
|
|
0x44); /* VOUTL:-10v (default) */
|
|
mipi_dbi_command(dbi, WS2401_DISCTL, 0x01, 0x00, 0x00, 0x00, 0x14,
|
|
0x16);
|
|
mipi_dbi_command(dbi, WS2401_VCOMCTL, 0x30, 0x53, 0x53);
|
|
mipi_dbi_command(dbi, WS2401_SRCCTL, 0x03, 0x0C, 0x00, 0x00, 0x00,
|
|
0x01, /* 2 dot inversion */
|
|
0x01, 0x06, 0x03);
|
|
mipi_dbi_command(dbi, WS2401_PANELCTL, 0x14, 0x00, 0x80, 0x00);
|
|
mipi_dbi_command(dbi, WS2401_WRMIE, 0x01);
|
|
|
|
/* Set up gamma, probably these are P-gamma and N-gamma for each color */
|
|
mipi_dbi_command(dbi, WS2401_GAMMA_R1, 0x00,
|
|
0x5b, 0x42, 0x41, 0x3f, 0x42, 0x3d, 0x38, 0x2e,
|
|
0x2b, 0x2a, 0x27, 0x22, 0x27, 0x0f, 0x00, 0x00);
|
|
mipi_dbi_command(dbi, WS2401_GAMMA_R2, 0x00,
|
|
0x5b, 0x42, 0x41, 0x3f, 0x42, 0x3d, 0x38, 0x2e,
|
|
0x2b, 0x2a, 0x27, 0x22, 0x27, 0x0f, 0x00, 0x00);
|
|
mipi_dbi_command(dbi, WS2401_GAMMA_G1, 0x00,
|
|
0x59, 0x40, 0x3f, 0x3e, 0x41, 0x3d, 0x39, 0x2f,
|
|
0x2c, 0x2b, 0x29, 0x25, 0x29, 0x19, 0x08, 0x00);
|
|
mipi_dbi_command(dbi, WS2401_GAMMA_G2, 0x00,
|
|
0x59, 0x40, 0x3f, 0x3e, 0x41, 0x3d, 0x39, 0x2f,
|
|
0x2c, 0x2b, 0x29, 0x25, 0x29, 0x19, 0x08, 0x00);
|
|
mipi_dbi_command(dbi, WS2401_GAMMA_B1, 0x00,
|
|
0x57, 0x3b, 0x3a, 0x3b, 0x3f, 0x3b, 0x38, 0x27,
|
|
0x38, 0x2a, 0x26, 0x22, 0x34, 0x0c, 0x09, 0x00);
|
|
mipi_dbi_command(dbi, WS2401_GAMMA_B2, 0x00,
|
|
0x57, 0x3b, 0x3a, 0x3b, 0x3f, 0x3b, 0x38, 0x27,
|
|
0x38, 0x2a, 0x26, 0x22, 0x34, 0x0c, 0x09, 0x00);
|
|
|
|
if (ws->internal_bl) {
|
|
mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x2c);
|
|
} else {
|
|
mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x00);
|
|
/*
|
|
* When not using internal backlight we do not need any further
|
|
* L2 accesses to the panel so we close the door on our way out.
|
|
* Otherwise we need to leave the L2 door open.
|
|
*/
|
|
mipi_dbi_command(dbi, WS2401_PASSWD1, 0xa5, 0xa5);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ws2401_power_off(struct ws2401 *ws)
|
|
{
|
|
/* Go into RESET and disable regulators */
|
|
gpiod_set_value_cansleep(ws->reset, 1);
|
|
return regulator_bulk_disable(ARRAY_SIZE(ws->regulators),
|
|
ws->regulators);
|
|
}
|
|
|
|
static int ws2401_unprepare(struct drm_panel *panel)
|
|
{
|
|
struct ws2401 *ws = to_ws2401(panel);
|
|
struct mipi_dbi *dbi = &ws->dbi;
|
|
|
|
/* Make sure we disable backlight, if any */
|
|
if (ws->internal_bl)
|
|
mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x00);
|
|
mipi_dbi_command(dbi, MIPI_DCS_ENTER_SLEEP_MODE);
|
|
msleep(120);
|
|
return ws2401_power_off(to_ws2401(panel));
|
|
}
|
|
|
|
static int ws2401_disable(struct drm_panel *panel)
|
|
{
|
|
struct ws2401 *ws = to_ws2401(panel);
|
|
struct mipi_dbi *dbi = &ws->dbi;
|
|
|
|
mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_OFF);
|
|
msleep(25);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ws2401_prepare(struct drm_panel *panel)
|
|
{
|
|
return ws2401_power_on(to_ws2401(panel));
|
|
}
|
|
|
|
static int ws2401_enable(struct drm_panel *panel)
|
|
{
|
|
struct ws2401 *ws = to_ws2401(panel);
|
|
struct mipi_dbi *dbi = &ws->dbi;
|
|
|
|
mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ws2401_get_modes() - return the mode
|
|
* @panel: the panel to get the mode for
|
|
* @connector: reference to the central DRM connector control structure
|
|
*/
|
|
static int ws2401_get_modes(struct drm_panel *panel,
|
|
struct drm_connector *connector)
|
|
{
|
|
struct ws2401 *ws = to_ws2401(panel);
|
|
struct drm_display_mode *mode;
|
|
static const u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
|
|
|
|
/*
|
|
* We just support the LMS380KF01 so far, if we implement more panels
|
|
* this mode, the following connector display_info settings and
|
|
* probably the custom DCS sequences needs to selected based on what
|
|
* the target panel needs.
|
|
*/
|
|
mode = drm_mode_duplicate(connector->dev, &lms380kf01_480_800_mode);
|
|
if (!mode) {
|
|
dev_err(ws->dev, "failed to add mode\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
connector->display_info.bpc = 8;
|
|
connector->display_info.width_mm = mode->width_mm;
|
|
connector->display_info.height_mm = mode->height_mm;
|
|
connector->display_info.bus_flags =
|
|
DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE;
|
|
drm_display_info_set_bus_formats(&connector->display_info,
|
|
&bus_format, 1);
|
|
|
|
drm_mode_set_name(mode);
|
|
mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
|
|
|
|
drm_mode_probed_add(connector, mode);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static const struct drm_panel_funcs ws2401_drm_funcs = {
|
|
.disable = ws2401_disable,
|
|
.unprepare = ws2401_unprepare,
|
|
.prepare = ws2401_prepare,
|
|
.enable = ws2401_enable,
|
|
.get_modes = ws2401_get_modes,
|
|
};
|
|
|
|
static int ws2401_set_brightness(struct backlight_device *bl)
|
|
{
|
|
struct ws2401 *ws = bl_get_data(bl);
|
|
struct mipi_dbi *dbi = &ws->dbi;
|
|
u8 brightness = backlight_get_brightness(bl);
|
|
|
|
if (backlight_is_blank(bl)) {
|
|
mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x00);
|
|
} else {
|
|
mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x2c);
|
|
mipi_dbi_command(dbi, WS2401_WRDISBV, brightness);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct backlight_ops ws2401_bl_ops = {
|
|
.update_status = ws2401_set_brightness,
|
|
};
|
|
|
|
static const struct backlight_properties ws2401_bl_props = {
|
|
.type = BACKLIGHT_PLATFORM,
|
|
.brightness = 120,
|
|
.max_brightness = U8_MAX,
|
|
};
|
|
|
|
static int ws2401_probe(struct spi_device *spi)
|
|
{
|
|
struct device *dev = &spi->dev;
|
|
struct ws2401 *ws;
|
|
int ret;
|
|
|
|
ws = devm_kzalloc(dev, sizeof(*ws), GFP_KERNEL);
|
|
if (!ws)
|
|
return -ENOMEM;
|
|
ws->dev = dev;
|
|
|
|
/*
|
|
* VCI is the analog voltage supply
|
|
* VCCIO is the digital I/O voltage supply
|
|
*/
|
|
ws->regulators[0].supply = "vci";
|
|
ws->regulators[1].supply = "vccio";
|
|
ret = devm_regulator_bulk_get(dev,
|
|
ARRAY_SIZE(ws->regulators),
|
|
ws->regulators);
|
|
if (ret)
|
|
return dev_err_probe(dev, ret, "failed to get regulators\n");
|
|
|
|
ws->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
|
|
if (IS_ERR(ws->reset)) {
|
|
ret = PTR_ERR(ws->reset);
|
|
return dev_err_probe(dev, ret, "no RESET GPIO\n");
|
|
}
|
|
|
|
ret = mipi_dbi_spi_init(spi, &ws->dbi, NULL);
|
|
if (ret)
|
|
return dev_err_probe(dev, ret, "MIPI DBI init failed\n");
|
|
ws->dbi.read_commands = ws2401_dbi_read_commands;
|
|
|
|
ws2401_power_on(ws);
|
|
ws2401_read_mtp_id(ws);
|
|
ws2401_power_off(ws);
|
|
|
|
drm_panel_init(&ws->panel, dev, &ws2401_drm_funcs,
|
|
DRM_MODE_CONNECTOR_DPI);
|
|
|
|
ret = drm_panel_of_backlight(&ws->panel);
|
|
if (ret)
|
|
return dev_err_probe(dev, ret,
|
|
"failed to get external backlight device\n");
|
|
|
|
if (!ws->panel.backlight) {
|
|
dev_dbg(dev, "no external backlight, using internal backlight\n");
|
|
ws->panel.backlight =
|
|
devm_backlight_device_register(dev, "ws2401", dev, ws,
|
|
&ws2401_bl_ops, &ws2401_bl_props);
|
|
if (IS_ERR(ws->panel.backlight))
|
|
return dev_err_probe(dev, PTR_ERR(ws->panel.backlight),
|
|
"failed to register backlight device\n");
|
|
} else {
|
|
dev_dbg(dev, "using external backlight\n");
|
|
}
|
|
|
|
spi_set_drvdata(spi, ws);
|
|
|
|
drm_panel_add(&ws->panel);
|
|
dev_dbg(dev, "added panel\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ws2401_remove(struct spi_device *spi)
|
|
{
|
|
struct ws2401 *ws = spi_get_drvdata(spi);
|
|
|
|
drm_panel_remove(&ws->panel);
|
|
}
|
|
|
|
/*
|
|
* Samsung LMS380KF01 is the one instance of this display controller that we
|
|
* know about, but if more are found, the controller can be parameterized
|
|
* here and used for other configurations.
|
|
*/
|
|
static const struct of_device_id ws2401_match[] = {
|
|
{ .compatible = "samsung,lms380kf01", },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, ws2401_match);
|
|
|
|
static struct spi_driver ws2401_driver = {
|
|
.probe = ws2401_probe,
|
|
.remove = ws2401_remove,
|
|
.driver = {
|
|
.name = "ws2401-panel",
|
|
.of_match_table = ws2401_match,
|
|
},
|
|
};
|
|
module_spi_driver(ws2401_driver);
|
|
|
|
MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
|
|
MODULE_DESCRIPTION("Samsung WS2401 panel driver");
|
|
MODULE_LICENSE("GPL v2");
|