lastdragon/linux-kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Resguardo inicial

Browse Source
This commit is contained in:
lastdragon
2026-09-06 12:53:21 -06:00
parent 662efe3c2a
commit ad2088d178
94853 changed files with 43200404 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
linux-7.2.3/drivers/gpu/drm/sitronix/Kconfig
+80
View File
@@ -0,0 +1,80 @@
config DRM_ST7571
tristate "DRM support for Sitronix ST7567/ST7571 display panels"
depends on DRM && MMU
select DRM_CLIENT_SELECTION
select DRM_GEM_SHMEM_HELPER
select DRM_KMS_HELPER
select VIDEOMODE_HELPERS
help
Sitronix ST7571 is a driver and controller for 4-level gray
scale and monochrome dot matrix LCD panels.
DRM driver for Sitronix ST7567/ST7571 panels.
This is only the core driver, a driver for the appropriate bus
transport in your chip also must be selected.
if M is selected the module will be called st7571.
config DRM_ST7571_I2C
tristate "DRM support for Sitronix ST7567/ST7571 display panels (I2C)"
depends on DRM_ST7571 && I2C
select REGMAP
help
Sitronix ST7571 is a driver and controller for 4-level gray
scale and monochrome dot matrix LCD panels.
DRM driver for Sitronix ST7565/ST7571 panels connected via I2C bus.
if M is selected the module will be called st7571-i2c.
config DRM_ST7571_SPI
tristate "DRM support for Sitronix ST7567/ST7571 display panels (SPI)"
depends on DRM_ST7571 && SPI
select REGMAP_SPI
help
Sitronix ST7571 is a driver and controller for 4-level gray
scale and monochrome dot matrix LCD panels.
DRM driver for Sitronix ST7565/ST7571 panels connected via SPI bus.
if M is selected the module will be called st7571-spi.
config DRM_ST7586
tristate "DRM support for Sitronix ST7586 display panels"
depends on DRM && SPI
select DRM_CLIENT_SELECTION
select DRM_KMS_HELPER
select DRM_GEM_DMA_HELPER
select DRM_MIPI_DBI
help
DRM driver for the following Sitronix ST7586 panels:
* LEGO MINDSTORMS EV3
If M is selected the module will be called st7586.
config DRM_ST7735R
tristate "DRM support for Sitronix ST7715R/ST7735R display panels"
depends on DRM && SPI
select DRM_CLIENT_SELECTION
select DRM_KMS_HELPER
select DRM_GEM_DMA_HELPER
select DRM_MIPI_DBI
select BACKLIGHT_CLASS_DEVICE
help
DRM driver for Sitronix ST7715R/ST7735R with one of the following
LCDs:
* Jianda JD-T18003-T01 1.8" 128x160 TFT
* Okaya RH128128T 1.44" 128x128 TFT
If M is selected the module will be called st7735r.
config DRM_ST7920
tristate "DRM support for Sitronix ST7920 LCD displays"
depends on DRM && SPI && MMU
select DRM_GEM_SHMEM_HELPER
select DRM_KMS_HELPER
select REGMAP_SPI
help
DRM driver for the ST7920 Sitronix LCD controllers.
If M is selected the module will be called st7920.
linux-7.2.3/drivers/gpu/drm/sitronix/Makefile
+6
View File
@@ -0,0 +1,6 @@
obj-$(CONFIG_DRM_ST7571) += st7571.o
obj-$(CONFIG_DRM_ST7571_I2C) += st7571-i2c.o
obj-$(CONFIG_DRM_ST7571_SPI) += st7571-spi.o
obj-$(CONFIG_DRM_ST7586) += st7586.o
obj-$(CONFIG_DRM_ST7735R) += st7735r.o
obj-$(CONFIG_DRM_ST7920) += st7920.o
linux-7.2.3/drivers/gpu/drm/sitronix/st7571-i2c.c
+158
View File
@@ -0,0 +1,158 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Driver for Sitronix ST7571 connected via I2C bus.
*
* Copyright (C) 2025 Marcus Folkesson <marcus.folkesson@gmail.com>
*/
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include "st7571.h"
struct st7571_i2c_transport {
struct i2c_client *client;
/*
* Depending on the hardware design, the acknowledge signal may be hard to
* recognize as a valid logic "0" level.
* Therefor, ignore NAK if possible to stay compatible with most hardware designs
* and off-the-shelf panels out there.
*
* From section 6.4 MICROPOCESSOR INTERFACE section in the datasheet:
*
* "By connecting SDA_OUT to SDA_IN externally, the SDA line becomes fully
* I2C interface compatible.
* Separating acknowledge-output from serial data
* input is advantageous for chip-on-glass (COG) applications. In COG
* applications, the ITO resistance and the pull-up resistor will form a
* voltage divider, which affects acknowledge-signal level. Larger ITO
* resistance will raise the acknowledged-signal level and system cannot
* recognize this level as a valid logic “0” level. By separating SDA_IN from
* SDA_OUT, the IC can be used in a mode that ignores the acknowledge-bit.
* For applications which check acknowledge-bit, it is necessary to minimize
* the ITO resistance of the SDA_OUT trace to guarantee a valid low level."
*
*/
bool ignore_nak;
};
static int st7571_i2c_regmap_write(void *context, const void *data, size_t count)
{
struct st7571_i2c_transport *t = context;
int ret;
struct i2c_msg msg = {
.addr = t->client->addr,
.flags = t->ignore_nak ? I2C_M_IGNORE_NAK : 0,
.len = count,
.buf = (u8 *)data
};
ret = i2c_transfer(t->client->adapter, &msg, 1);
/*
* Unfortunately, there is no way to check if the transfer failed because of
* a NAK or something else as I2C bus drivers use different return values for NAK.
*
* However, if the transfer fails and ignore_nak is set, we know it is an error.
*/
if (ret < 0 && t->ignore_nak)
return ret;
return 0;
}
/* The st7571 driver does not read registers but regmap expects a .read */
static int st7571_i2c_regmap_read(void *context, const void *reg_buf,
size_t reg_size, void *val_buf, size_t val_size)
{
return -EOPNOTSUPP;
}
static const struct regmap_bus st7571_i2c_regmap_bus = {
.read = st7571_i2c_regmap_read,
.write = st7571_i2c_regmap_write,
};
static const struct regmap_config st7571_i2c_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.use_single_write = true,
};
static int st7571_i2c_probe(struct i2c_client *client)
{
struct st7571_device *st7571;
struct st7571_i2c_transport *t;
struct regmap *regmap;
t = devm_kzalloc(&client->dev, sizeof(*t), GFP_KERNEL);
if (!t)
return -ENOMEM;
t->client = client;
/*
* The hardware design could make it hard to detect a NAK on the I2C bus.
* If the adapter does not support protocol mangling do
* not set the I2C_M_IGNORE_NAK flag at the expense * of possible
* cruft in the logs.
*/
if (i2c_check_functionality(client->adapter, I2C_FUNC_PROTOCOL_MANGLING))
t->ignore_nak = true;
regmap = devm_regmap_init(&client->dev, &st7571_i2c_regmap_bus,
t, &st7571_i2c_regmap_config);
if (IS_ERR(regmap)) {
return dev_err_probe(&client->dev, PTR_ERR(regmap),
"Failed to initialize regmap\n");
}
st7571 = st7571_probe(&client->dev, regmap);
if (IS_ERR(st7571))
return dev_err_probe(&client->dev, PTR_ERR(st7571),
"Failed to initialize regmap\n");
i2c_set_clientdata(client, st7571);
return 0;
}
static void st7571_i2c_remove(struct i2c_client *client)
{
struct st7571_device *st7571 = i2c_get_clientdata(client);
st7571_remove(st7571);
}
static const struct of_device_id st7571_of_match[] = {
{ .compatible = "sitronix,st7567", .data = &st7567_config },
{ .compatible = "sitronix,st7571", .data = &st7571_config },
{},
};
MODULE_DEVICE_TABLE(of, st7571_of_match);
static const struct i2c_device_id st7571_id[] = {
{ "st7567", 0 },
{ "st7571", 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, st7571_id);
static struct i2c_driver st7571_i2c_driver = {
.driver = {
.name = "st7571-i2c",
.of_match_table = st7571_of_match,
},
.probe = st7571_i2c_probe,
.remove = st7571_i2c_remove,
.id_table = st7571_id,
};
module_i2c_driver(st7571_i2c_driver);
MODULE_AUTHOR("Marcus Folkesson <marcus.folkesson@gmail.com>");
MODULE_DESCRIPTION("DRM Driver for Sitronix ST7571 LCD controller (I2C)");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("DRM_ST7571");
linux-7.2.3/drivers/gpu/drm/sitronix/st7571-spi.c
+76
View File
@@ -0,0 +1,76 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Driver for Sitronix ST7571 connected via SPI bus.
*
* Copyright (C) 2025 Marcus Folkesson <marcus.folkesson@gmail.com>
*/
#include <linux/spi/spi.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include "st7571.h"
static const struct regmap_config st7571_spi_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.can_multi_write = true,
};
static int st7571_spi_probe(struct spi_device *spi)
{
struct st7571_device *st7571;
struct regmap *regmap;
regmap = devm_regmap_init_spi(spi, &st7571_spi_regmap_config);
if (IS_ERR(regmap)) {
return dev_err_probe(&spi->dev, PTR_ERR(regmap),
"Failed to initialize regmap\n");
}
st7571 = st7571_probe(&spi->dev, regmap);
if (IS_ERR(st7571))
return dev_err_probe(&spi->dev, PTR_ERR(st7571),
"Failed to initialize regmap\n");
spi_set_drvdata(spi, st7571);
return 0;
}
static void st7571_spi_remove(struct spi_device *spi)
{
struct st7571_device *st7571 = spi_get_drvdata(spi);
st7571_remove(st7571);
}
static const struct of_device_id st7571_of_match[] = {
{ .compatible = "sitronix,st7567", .data = &st7567_config },
{ .compatible = "sitronix,st7571", .data = &st7571_config },
{},
};
MODULE_DEVICE_TABLE(of, st7571_of_match);
static const struct spi_device_id st7571_spi_id[] = {
{ "st7567", 0 },
{ "st7571", 0 },
{ }
};
MODULE_DEVICE_TABLE(spi, st7571_spi_id);
static struct spi_driver st7571_spi_driver = {
.driver = {
.name = "st7571-spi",
.of_match_table = st7571_of_match,
},
.probe = st7571_spi_probe,
.remove = st7571_spi_remove,
.id_table = st7571_spi_id,
};
module_spi_driver(st7571_spi_driver);
MODULE_AUTHOR("Marcus Folkesson <marcus.folkesson@gmail.com>");
MODULE_DESCRIPTION("DRM Driver for Sitronix ST7571 LCD controller (SPI)");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("DRM_ST7571");
linux-7.2.3/drivers/gpu/drm/sitronix/st7571.c
+918
View File
@@ -0,0 +1,918 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Driver for Sitronix ST7571, a 4 level gray scale dot matrix LCD controller
*
* Copyright (C) 2025 Marcus Folkesson <marcus.folkesson@gmail.com>
*/
#include <linux/bitfield.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_connector.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_encoder.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_fbdev_shmem.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_gem_shmem_helper.h>
#include <drm/drm_modeset_helper_vtables.h>
#include <drm/drm_module.h>
#include <drm/drm_plane.h>
#include <drm/drm_probe_helper.h>
#include <video/display_timing.h>
#include <video/of_display_timing.h>
#include "st7571.h"
#define ST7571_COMMAND_MODE (0x00)
#define ST7571_DATA_MODE (0x40)
/* Normal mode command set */
#define ST7571_DISPLAY_OFF (0xae)
#define ST7571_DISPLAY_ON (0xaf)
#define ST7571_OSC_ON (0xab)
#define ST7571_SET_COLUMN_LSB(c) (0x00 | FIELD_PREP(GENMASK(3, 0), (c)))
#define ST7571_SET_COLUMN_MSB(c) (0x10 | FIELD_PREP(GENMASK(2, 0), (c) >> 4))
#define ST7571_SET_COM0_LSB(x) (FIELD_PREP(GENMASK(6, 0), (x)))
#define ST7571_SET_COM0_MSB (0x44)
#define ST7571_SET_COM_SCAN_DIR(d) (0xc0 | FIELD_PREP(GENMASK(3, 3), (d)))
#define ST7571_SET_CONTRAST_LSB(c) (FIELD_PREP(GENMASK(5, 0), (c)))
#define ST7571_SET_CONTRAST_MSB (0x81)
#define ST7571_SET_DISPLAY_DUTY_LSB(d) (FIELD_PREP(GENMASK(7, 0), (d)))
#define ST7571_SET_DISPLAY_DUTY_MSB (0x48)
#define ST7571_SET_ENTIRE_DISPLAY_ON(p) (0xa4 | FIELD_PREP(GENMASK(0, 0), (p)))
#define ST7571_SET_LCD_BIAS(b) (0x50 | FIELD_PREP(GENMASK(2, 0), (b)))
#define ST7571_SET_MODE_LSB(m) (FIELD_PREP(GENMASK(7, 2), (m)))
#define ST7571_SET_MODE_MSB (0x38)
#define ST7571_SET_PAGE(p) (0xb0 | FIELD_PREP(GENMASK(3, 0), (p)))
#define ST7571_SET_POWER(p) (0x28 | FIELD_PREP(GENMASK(2, 0), (p)))
#define ST7571_SET_REGULATOR_REG(r) (0x20 | FIELD_PREP(GENMASK(2, 0), (r)))
#define ST7571_SET_REVERSE(r) (0xa6 | FIELD_PREP(GENMASK(0, 0), (r)))
#define ST7571_SET_SEG_SCAN_DIR(d) (0xa0 | FIELD_PREP(GENMASK(0, 0), (d)))
#define ST7571_SET_START_LINE_LSB(l) (FIELD_PREP(GENMASK(6, 0), (l)))
#define ST7571_SET_START_LINE_MSB (0x40)
/* Extension command set 3 */
#define ST7571_COMMAND_SET_3 (0x7b)
#define ST7571_SET_COLOR_MODE(c) (0x10 | FIELD_PREP(GENMASK(0, 0), (c)))
#define ST7571_COMMAND_SET_NORMAL (0x00)
/* ST7567 commands */
#define ST7567_SET_LCD_BIAS(m) (0xa2 | FIELD_PREP(GENMASK(0, 0), (m)))
#define ST7571_PAGE_HEIGHT 8
#define DRIVER_NAME "st7571"
#define DRIVER_DESC "ST7571 DRM driver"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 0
static inline struct st7571_device *drm_to_st7571(struct drm_device *drm)
{
return container_of(drm, struct st7571_device, drm);
}
static int st7571_send_command_list(struct st7571_device *st7571,
const u8 *cmd_list, size_t len)
{
int ret;
for (int i = 0; i < len; i++) {
ret = regmap_write(st7571->regmap, ST7571_COMMAND_MODE, cmd_list[i]);
if (ret < 0)
return ret;
}
return ret;
}
static inline u8 st7571_transform_xy(const char *p, int x, int y, u8 bpp)
{
int xrest = x % 8;
u8 result = 0;
u8 row_len = 16 * bpp;
/*
* Transforms an (x, y) pixel coordinate into a vertical 8-bit
* column from the framebuffer. It calculates the corresponding byte in the
* framebuffer, extracts the bit at the given x position across 8 consecutive
* rows, and packs those bits into a single byte.
*
* Return an 8-bit value representing a vertical column of pixels.
*/
x = x / 8;
y = (y / 8) * 8;
for (int i = 0; i < 8; i++) {
int row_idx = y + i;
u8 byte = p[row_idx * row_len + x];
u8 bit = (byte >> xrest) & 1;
result |= (bit << i);
}
return result;
}
static int st7571_set_position(struct st7571_device *st7571, int x, int y)
{
u8 cmd_list[] = {
ST7571_SET_COLUMN_LSB(x),
ST7571_SET_COLUMN_MSB(x),
ST7571_SET_PAGE(y / ST7571_PAGE_HEIGHT),
};
return st7571_send_command_list(st7571, cmd_list, ARRAY_SIZE(cmd_list));
}
static int st7571_fb_clear_screen(struct st7571_device *st7571)
{
u32 npixels = st7571->ncols * round_up(st7571->nlines, ST7571_PAGE_HEIGHT) * st7571->bpp;
char pixelvalue = 0x00;
st7571_set_position(st7571, 0, 0);
for (int i = 0; i < npixels; i++)
regmap_bulk_write(st7571->regmap, ST7571_DATA_MODE, &pixelvalue, 1);
return 0;
}
static void st7571_prepare_buffer_monochrome(struct st7571_device *st7571,
const struct iosys_map *vmap,
struct drm_framebuffer *fb,
struct drm_rect *rect,
struct drm_format_conv_state *fmtcnv_state)
{
unsigned int dst_pitch;
struct iosys_map dst;
u32 size;
switch (fb->format->format) {
case DRM_FORMAT_XRGB8888:
dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 8);
iosys_map_set_vaddr(&dst, st7571->hwbuf);
drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);
break;
case DRM_FORMAT_R1:
size = (rect->x2 - rect->x1) * (rect->y2 - rect->y1) / 8;
memcpy(st7571->hwbuf, vmap->vaddr, size);
break;
}
}
static void st7571_prepare_buffer_grayscale(struct st7571_device *st7571,
const struct iosys_map *vmap,
struct drm_framebuffer *fb,
struct drm_rect *rect,
struct drm_format_conv_state *fmtcnv_state)
{
u32 size = (rect->x2 - rect->x1) * (rect->y2 - rect->y1) / 8;
unsigned int dst_pitch;
struct iosys_map dst;
switch (fb->format->format) {
case DRM_FORMAT_XRGB8888:
dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 4);
iosys_map_set_vaddr(&dst, st7571->hwbuf);
drm_fb_xrgb8888_to_gray2(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);
break;
case DRM_FORMAT_R1:
size = (rect->x2 - rect->x1) * (rect->y2 - rect->y1) / 8;
memcpy(st7571->hwbuf, vmap->vaddr, size);
break;
case DRM_FORMAT_R2:
size = (rect->x2 - rect->x1) * (rect->y2 - rect->y1) / 4;
memcpy(st7571->hwbuf, vmap->vaddr, size);
break;
}
}
static int st7571_fb_update_rect_monochrome(struct drm_framebuffer *fb, struct drm_rect *rect)
{
struct st7571_device *st7571 = drm_to_st7571(fb->dev);
char *row = st7571->row;
/* Align y to display page boundaries */
rect->y1 = round_down(rect->y1, ST7571_PAGE_HEIGHT);
rect->y2 = min_t(unsigned int, round_up(rect->y2, ST7571_PAGE_HEIGHT), st7571->nlines);
for (int y = rect->y1; y < rect->y2; y += ST7571_PAGE_HEIGHT) {
for (int x = rect->x1; x < rect->x2; x++)
row[x] = st7571_transform_xy(st7571->hwbuf, x, y, 1);
st7571_set_position(st7571, rect->x1, y);
/* TODO: Investige why we can't write multiple bytes at once */
for (int x = rect->x1; x < rect->x2; x++)
regmap_bulk_write(st7571->regmap, ST7571_DATA_MODE, row + x, 1);
}
return 0;
}
static int st7571_fb_update_rect_grayscale(struct drm_framebuffer *fb, struct drm_rect *rect)
{
struct st7571_device *st7571 = drm_to_st7571(fb->dev);
u32 format = fb->format->format;
char *row = st7571->row;
int x1;
int x2;
/* Align y to display page boundaries */
rect->y1 = round_down(rect->y1, ST7571_PAGE_HEIGHT);
rect->y2 = min_t(unsigned int, round_up(rect->y2, ST7571_PAGE_HEIGHT), st7571->nlines);
switch (format) {
case DRM_FORMAT_R1:
x1 = rect->x1 * 1;
x2 = rect->x2 * 1;
break;
case DRM_FORMAT_R2:
fallthrough;
case DRM_FORMAT_XRGB8888:
x1 = rect->x1 * 2;
x2 = rect->x2 * 2;
break;
}
for (int y = rect->y1; y < rect->y2; y += ST7571_PAGE_HEIGHT) {
for (int x = x1; x < x2; x++)
row[x] = st7571_transform_xy(st7571->hwbuf, x, y, 2);
st7571_set_position(st7571, rect->x1, y);
/* TODO: Investige why we can't write multiple bytes at once */
for (int x = x1; x < x2; x++) {
regmap_bulk_write(st7571->regmap, ST7571_DATA_MODE, row + x, 1);
/*
* As the display supports grayscale, all pixels must be written as two bits
* even if the format is monochrome.
*
* The bit values maps to the following grayscale:
* 0 0 = Black
* 0 1 = Dark gray
* 1 0 = Light gray
* 1 1 = White
*
* For monochrome formats, write the same value twice to get
* either a black or white pixel.
*/
if (format == DRM_FORMAT_R1)
regmap_bulk_write(st7571->regmap, ST7571_DATA_MODE, row + x, 1);
}
}
return 0;
}
static int st7571_connector_get_modes(struct drm_connector *conn)
{
struct st7571_device *st7571 = drm_to_st7571(conn->dev);
return drm_connector_helper_get_modes_fixed(conn, &st7571->mode);
}
static const struct drm_connector_helper_funcs st7571_connector_helper_funcs = {
.get_modes = st7571_connector_get_modes,
};
static const struct st7571_panel_format st7571_monochrome = {
.prepare_buffer = st7571_prepare_buffer_monochrome,
.update_rect = st7571_fb_update_rect_monochrome,
.mode = ST7571_COLOR_MODE_BLACKWHITE,
.formats = {
DRM_FORMAT_XRGB8888,
DRM_FORMAT_R1,
},
.nformats = 2,
};
static const struct st7571_panel_format st7571_grayscale = {
.prepare_buffer = st7571_prepare_buffer_grayscale,
.update_rect = st7571_fb_update_rect_grayscale,
.mode = ST7571_COLOR_MODE_GRAY,
.formats = {
DRM_FORMAT_XRGB8888,
DRM_FORMAT_R1,
DRM_FORMAT_R2,
},
.nformats = 3,
};
static const u64 st7571_primary_plane_fmtmods[] = {
DRM_FORMAT_MOD_LINEAR,
DRM_FORMAT_MOD_INVALID
};
static int st7571_primary_plane_helper_atomic_check(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc *new_crtc = new_plane_state->crtc;
struct drm_crtc_state *new_crtc_state = NULL;
if (new_crtc)
new_crtc_state = drm_atomic_get_new_crtc_state(state, new_crtc);
return drm_atomic_helper_check_plane_state(new_plane_state, new_crtc_state,
DRM_PLANE_NO_SCALING,
DRM_PLANE_NO_SCALING,
false, false);
}
static void st7571_primary_plane_helper_atomic_update(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
struct drm_framebuffer *fb = plane_state->fb;
struct drm_atomic_helper_damage_iter iter;
struct drm_device *drm = plane->dev;
struct drm_rect damage;
struct st7571_device *st7571 = drm_to_st7571(plane->dev);
int ret, idx;
if (!fb)
return; /* no framebuffer; plane is disabled */
ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
if (ret)
return;
if (!drm_dev_enter(drm, &idx))
goto out_drm_gem_fb_end_cpu_access;
drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);
drm_atomic_for_each_plane_damage(&iter, &damage) {
st7571->pformat->prepare_buffer(st7571,
&shadow_plane_state->data[0],
fb, &damage,
&shadow_plane_state->fmtcnv_state);
st7571->pformat->update_rect(fb, &damage);
}
drm_dev_exit(idx);
out_drm_gem_fb_end_cpu_access:
drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
}
static void st7571_primary_plane_helper_atomic_disable(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct st7571_device *st7571 = drm_to_st7571(plane->dev);
int idx;
if (!drm_dev_enter(drm, &idx))
return;
st7571_fb_clear_screen(st7571);
drm_dev_exit(idx);
}
static const struct drm_plane_helper_funcs st7571_primary_plane_helper_funcs = {
DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
.atomic_check = st7571_primary_plane_helper_atomic_check,
.atomic_update = st7571_primary_plane_helper_atomic_update,
.atomic_disable = st7571_primary_plane_helper_atomic_disable,
};
static const struct drm_plane_funcs st7571_primary_plane_funcs = {
.update_plane = drm_atomic_helper_update_plane,
.disable_plane = drm_atomic_helper_disable_plane,
.destroy = drm_plane_cleanup,
DRM_GEM_SHADOW_PLANE_FUNCS,
};
/*
* CRTC
*/
static enum drm_mode_status st7571_crtc_mode_valid(struct drm_crtc *crtc,
const struct drm_display_mode *mode)
{
struct st7571_device *st7571 = drm_to_st7571(crtc->dev);
return drm_crtc_helper_mode_valid_fixed(crtc, mode, &st7571->mode);
}
static const struct drm_crtc_helper_funcs st7571_crtc_helper_funcs = {
.atomic_check = drm_crtc_helper_atomic_check,
.mode_valid = st7571_crtc_mode_valid,
};
static const struct drm_crtc_funcs st7571_crtc_funcs = {
.reset = drm_atomic_helper_crtc_reset,
.destroy = drm_crtc_cleanup,
.set_config = drm_atomic_helper_set_config,
.page_flip = drm_atomic_helper_page_flip,
.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
};
/*
* Encoder
*/
static void st7571_encoder_atomic_enable(struct drm_encoder *encoder,
struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct st7571_device *st7571 = drm_to_st7571(drm);
u8 command = ST7571_DISPLAY_ON;
int ret;
ret = st7571->pdata->init(st7571);
if (ret)
return;
st7571_send_command_list(st7571, &command, 1);
}
static void st7571_encoder_atomic_disable(struct drm_encoder *encoder,
struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct st7571_device *st7571 = drm_to_st7571(drm);
u8 command = ST7571_DISPLAY_OFF;
st7571_send_command_list(st7571, &command, 1);
}
static const struct drm_encoder_funcs st7571_encoder_funcs = {
.destroy = drm_encoder_cleanup,
};
static const struct drm_encoder_helper_funcs st7571_encoder_helper_funcs = {
.atomic_enable = st7571_encoder_atomic_enable,
.atomic_disable = st7571_encoder_atomic_disable,
};
/*
* Connector
*/
static const struct drm_connector_funcs st7571_connector_funcs = {
.reset = drm_atomic_helper_connector_reset,
.fill_modes = drm_helper_probe_single_connector_modes,
.destroy = drm_connector_cleanup,
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};
static const struct drm_mode_config_funcs st7571_mode_config_funcs = {
.fb_create = drm_gem_fb_create_with_dirty,
.atomic_check = drm_atomic_helper_check,
.atomic_commit = drm_atomic_helper_commit,
};
static struct drm_display_mode st7571_mode(struct st7571_device *st7571)
{
struct drm_display_mode mode = {
DRM_SIMPLE_MODE(st7571->ncols, st7571->nlines,
st7571->width_mm, st7571->height_mm),
};
return mode;
}
static int st7571_mode_config_init(struct st7571_device *st7571)
{
struct drm_device *drm = &st7571->drm;
const struct st7571_panel_constraints *constraints = &st7571->pdata->constraints;
int ret;
ret = drmm_mode_config_init(drm);
if (ret)
return ret;
drm->mode_config.min_width = constraints->min_ncols;
drm->mode_config.min_height = constraints->min_nlines;
drm->mode_config.max_width = constraints->max_ncols;
drm->mode_config.max_height = constraints->max_nlines;
drm->mode_config.preferred_depth = 24;
drm->mode_config.funcs = &st7571_mode_config_funcs;
return 0;
}
static int st7571_plane_init(struct st7571_device *st7571,
const struct st7571_panel_format *pformat)
{
struct drm_plane *primary_plane = &st7571->primary_plane;
struct drm_device *drm = &st7571->drm;
int ret;
ret = drm_universal_plane_init(drm, primary_plane, 0,
&st7571_primary_plane_funcs,
pformat->formats,
pformat->nformats,
st7571_primary_plane_fmtmods,
DRM_PLANE_TYPE_PRIMARY, NULL);
if (ret)
return ret;
drm_plane_helper_add(primary_plane, &st7571_primary_plane_helper_funcs);
drm_plane_enable_fb_damage_clips(primary_plane);
return 0;
}
static int st7571_crtc_init(struct st7571_device *st7571)
{
struct drm_plane *primary_plane = &st7571->primary_plane;
struct drm_crtc *crtc = &st7571->crtc;
struct drm_device *drm = &st7571->drm;
int ret;
ret = drm_crtc_init_with_planes(drm, crtc, primary_plane, NULL,
&st7571_crtc_funcs, NULL);
if (ret)
return ret;
drm_crtc_helper_add(crtc, &st7571_crtc_helper_funcs);
return 0;
}
static int st7571_encoder_init(struct st7571_device *st7571)
{
struct drm_encoder *encoder = &st7571->encoder;
struct drm_crtc *crtc = &st7571->crtc;
struct drm_device *drm = &st7571->drm;
int ret;
ret = drm_encoder_init(drm, encoder, &st7571_encoder_funcs, DRM_MODE_ENCODER_NONE, NULL);
if (ret)
return ret;
drm_encoder_helper_add(encoder, &st7571_encoder_helper_funcs);
encoder->possible_crtcs = drm_crtc_mask(crtc);
return 0;
}
static int st7571_connector_init(struct st7571_device *st7571)
{
struct drm_connector *connector = &st7571->connector;
struct drm_encoder *encoder = &st7571->encoder;
struct drm_device *drm = &st7571->drm;
int ret;
ret = drm_connector_init(drm, connector, &st7571_connector_funcs,
DRM_MODE_CONNECTOR_Unknown);
if (ret)
return ret;
drm_connector_helper_add(connector, &st7571_connector_helper_funcs);
return drm_connector_attach_encoder(connector, encoder);
}
DEFINE_DRM_GEM_FOPS(st7571_fops);
static const struct drm_driver st7571_driver = {
.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
.name = DRIVER_NAME,
.desc = DRIVER_DESC,
.major = DRIVER_MAJOR,
.minor = DRIVER_MINOR,
.fops = &st7571_fops,
DRM_GEM_SHMEM_DRIVER_OPS,
DRM_FBDEV_SHMEM_DRIVER_OPS,
};
static int st7571_validate_parameters(struct st7571_device *st7571)
{
struct device *dev = st7571->dev;
const struct st7571_panel_constraints *constraints = &st7571->pdata->constraints;
if (st7571->width_mm == 0) {
dev_err(dev, "Invalid panel width\n");
return -EINVAL;
}
if (st7571->height_mm == 0) {
dev_err(dev, "Invalid panel height\n");
return -EINVAL;
}
if (st7571->nlines < constraints->min_nlines ||
st7571->nlines > constraints->max_nlines) {
dev_err(dev, "Invalid timing configuration.\n");
return -EINVAL;
}
if (st7571->startline + st7571->nlines > constraints->max_nlines) {
dev_err(dev, "Invalid timing configuration.\n");
return -EINVAL;
}
if (st7571->ncols < constraints->min_ncols ||
st7571->ncols > constraints->max_ncols) {
dev_err(dev, "Invalid timing configuration.\n");
return -EINVAL;
}
if (st7571->grayscale && !constraints->support_grayscale) {
dev_err(dev, "Grayscale not supported\n");
return -EINVAL;
}
return 0;
}
static int st7567_parse_dt(struct st7571_device *st7567)
{
struct device *dev = st7567->dev;
struct device_node *np = dev->of_node;
struct display_timing dt;
int ret;
ret = of_get_display_timing(np, "panel-timing", &dt);
if (ret) {
dev_err(dev, "Failed to get display timing from DT\n");
return ret;
}
of_property_read_u32(np, "width-mm", &st7567->width_mm);
of_property_read_u32(np, "height-mm", &st7567->height_mm);
st7567->inverted = of_property_read_bool(np, "sitronix,inverted");
st7567->pformat = &st7571_monochrome;
st7567->bpp = 1;
st7567->startline = dt.vfront_porch.typ;
st7567->nlines = dt.vactive.typ;
st7567->ncols = dt.hactive.typ;
return 0;
}
static int st7571_parse_dt(struct st7571_device *st7571)
{
struct device *dev = st7571->dev;
struct device_node *np = dev->of_node;
struct display_timing dt;
int ret;
ret = of_get_display_timing(np, "panel-timing", &dt);
if (ret) {
dev_err(dev, "Failed to get display timing from DT\n");
return ret;
}
of_property_read_u32(np, "width-mm", &st7571->width_mm);
of_property_read_u32(np, "height-mm", &st7571->height_mm);
st7571->grayscale = of_property_read_bool(np, "sitronix,grayscale");
st7571->inverted = of_property_read_bool(np, "sitronix,inverted");
if (st7571->grayscale) {
st7571->pformat = &st7571_grayscale;
st7571->bpp = 2;
} else {
st7571->pformat = &st7571_monochrome;
st7571->bpp = 1;
}
st7571->startline = dt.vfront_porch.typ;
st7571->nlines = dt.vactive.typ;
st7571->ncols = dt.hactive.typ;
st7571->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
if (IS_ERR(st7571->reset))
return dev_err_probe(dev, PTR_ERR(st7571->reset),
"Failed to get reset gpio\n");
return 0;
}
static void st7571_reset(struct st7571_device *st7571)
{
gpiod_set_value_cansleep(st7571->reset, 1);
fsleep(20);
gpiod_set_value_cansleep(st7571->reset, 0);
}
static int st7567_lcd_init(struct st7571_device *st7567)
{
/*
* Most of the initialization sequence is taken directly from the
* referential initial code in the ST7567 datasheet.
*/
u8 commands[] = {
ST7571_DISPLAY_OFF,
ST7567_SET_LCD_BIAS(1),
ST7571_SET_SEG_SCAN_DIR(0),
ST7571_SET_COM_SCAN_DIR(1),
ST7571_SET_REGULATOR_REG(4),
ST7571_SET_CONTRAST_MSB,
ST7571_SET_CONTRAST_LSB(0x20),
ST7571_SET_START_LINE_MSB,
ST7571_SET_START_LINE_LSB(st7567->startline),
ST7571_SET_POWER(0x4), /* Power Control, VC: ON, VR: OFF, VF: OFF */
ST7571_SET_POWER(0x6), /* Power Control, VC: ON, VR: ON, VF: OFF */
ST7571_SET_POWER(0x7), /* Power Control, VC: ON, VR: ON, VF: ON */
ST7571_SET_REVERSE(st7567->inverted ? 1 : 0),
ST7571_SET_ENTIRE_DISPLAY_ON(0),
};
return st7571_send_command_list(st7567, commands, ARRAY_SIZE(commands));
}
static int st7571_lcd_init(struct st7571_device *st7571)
{
/*
* Most of the initialization sequence is taken directly from the
* referential initial code in the ST7571 datasheet.
*/
u8 commands[] = {
ST7571_DISPLAY_OFF,
ST7571_SET_MODE_MSB,
ST7571_SET_MODE_LSB(0x2e),
ST7571_SET_SEG_SCAN_DIR(0),
ST7571_SET_COM_SCAN_DIR(1),
ST7571_SET_COM0_MSB,
ST7571_SET_COM0_LSB(0x00),
ST7571_SET_START_LINE_MSB,
ST7571_SET_START_LINE_LSB(st7571->startline),
ST7571_OSC_ON,
ST7571_SET_REGULATOR_REG(5),
ST7571_SET_CONTRAST_MSB,
ST7571_SET_CONTRAST_LSB(0x33),
ST7571_SET_LCD_BIAS(0x04),
ST7571_SET_DISPLAY_DUTY_MSB,
ST7571_SET_DISPLAY_DUTY_LSB(st7571->nlines),
ST7571_SET_POWER(0x4), /* Power Control, VC: ON, VR: OFF, VF: OFF */
ST7571_SET_POWER(0x6), /* Power Control, VC: ON, VR: ON, VF: OFF */
ST7571_SET_POWER(0x7), /* Power Control, VC: ON, VR: ON, VF: ON */
ST7571_COMMAND_SET_3,
ST7571_SET_COLOR_MODE(st7571->pformat->mode),
ST7571_COMMAND_SET_NORMAL,
ST7571_SET_REVERSE(st7571->inverted ? 1 : 0),
ST7571_SET_ENTIRE_DISPLAY_ON(0),
};
/* Perform a reset before initializing the controller */
st7571_reset(st7571);
return st7571_send_command_list(st7571, commands, ARRAY_SIZE(commands));
}
struct st7571_device *st7571_probe(struct device *dev,
struct regmap *regmap)
{
struct st7571_device *st7571;
struct drm_device *drm;
int ret;
st7571 = devm_drm_dev_alloc(dev, &st7571_driver,
struct st7571_device, drm);
if (IS_ERR(st7571))
return st7571;
drm = &st7571->drm;
st7571->dev = dev;
st7571->pdata = device_get_match_data(st7571->dev);
ret = st7571->pdata->parse_dt(st7571);
if (ret)
return ERR_PTR(ret);
ret = st7571_validate_parameters(st7571);
if (ret)
return ERR_PTR(ret);
st7571->mode = st7571_mode(st7571);
st7571->regmap = regmap;
st7571->hwbuf = devm_kzalloc(st7571->dev,
(st7571->nlines * st7571->ncols * st7571->bpp) / 8,
GFP_KERNEL);
if (!st7571->hwbuf)
return ERR_PTR(-ENOMEM);
st7571->row = devm_kzalloc(st7571->dev,
(st7571->ncols * st7571->bpp),
GFP_KERNEL);
if (!st7571->row)
return ERR_PTR(-ENOMEM);
ret = st7571_mode_config_init(st7571);
if (ret) {
dev_err(st7571->dev, "Failed to initialize mode config\n");
return ERR_PTR(ret);
}
ret = st7571_plane_init(st7571, st7571->pformat);
if (ret) {
dev_err(st7571->dev, "Failed to initialize primary plane\n");
return ERR_PTR(ret);
}
ret = st7571_crtc_init(st7571);
if (ret < 0) {
dev_err(st7571->dev, "Failed to initialize CRTC\n");
return ERR_PTR(ret);
}
ret = st7571_encoder_init(st7571);
if (ret < 0) {
dev_err(st7571->dev, "Failed to initialize encoder\n");
return ERR_PTR(ret);
}
ret = st7571_connector_init(st7571);
if (ret < 0) {
dev_err(st7571->dev, "Failed to initialize connector\n");
return ERR_PTR(ret);
}
drm_mode_config_reset(drm);
ret = drm_dev_register(drm, 0);
if (ret) {
dev_err(st7571->dev, "Failed to register DRM device\n");
return ERR_PTR(ret);
}
drm_client_setup(drm, NULL);
return st7571;
}
EXPORT_SYMBOL_GPL(st7571_probe);
void st7571_remove(struct st7571_device *st7571)
{
drm_dev_unplug(&st7571->drm);
}
EXPORT_SYMBOL_GPL(st7571_remove);
const struct st7571_panel_data st7567_config = {
.init = st7567_lcd_init,
.parse_dt = st7567_parse_dt,
.constraints = {
.min_nlines = 1,
.max_nlines = 64,
.min_ncols = 128,
.max_ncols = 128,
.support_grayscale = false,
},
};
EXPORT_SYMBOL_NS_GPL(st7567_config, "DRM_ST7571");
const struct st7571_panel_data st7571_config = {
.init = st7571_lcd_init,
.parse_dt = st7571_parse_dt,
.constraints = {
.min_nlines = 1,
.max_nlines = 128,
.min_ncols = 128,
.max_ncols = 128,
.support_grayscale = true,
},
};
EXPORT_SYMBOL_NS_GPL(st7571_config, "DRM_ST7571");
MODULE_AUTHOR("Marcus Folkesson <marcus.folkesson@gmail.com>");
MODULE_DESCRIPTION("DRM Driver for Sitronix ST7571 LCD controller");
MODULE_LICENSE("GPL");
linux-7.2.3/drivers/gpu/drm/sitronix/st7571.h
+91
View File
@@ -0,0 +1,91 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Header file for:
* Driver for Sitronix ST7571, a 4 level gray scale dot matrix LCD controller
*
* Copyright (C) 2025 Marcus Folkesson <marcus.folkesson@gmail.com>
*/
#ifndef __ST7571_H__
#define __ST7571_H__
#include <drm/drm_connector.h>
#include <drm/drm_crtc.h>
#include <drm/drm_drv.h>
#include <drm/drm_encoder.h>
#include <drm/drm_format_helper.h>
#include <linux/regmap.h>
enum st7571_color_mode {
ST7571_COLOR_MODE_GRAY = 0,
ST7571_COLOR_MODE_BLACKWHITE = 1,
};
struct st7571_device;
struct st7571_panel_constraints {
u32 min_nlines;
u32 max_nlines;
u32 min_ncols;
u32 max_ncols;
bool support_grayscale;
};
struct st7571_panel_data {
int (*init)(struct st7571_device *st7571);
int (*parse_dt)(struct st7571_device *st7571);
struct st7571_panel_constraints constraints;
};
struct st7571_panel_format {
void (*prepare_buffer)(struct st7571_device *st7571,
const struct iosys_map *vmap,
struct drm_framebuffer *fb,
struct drm_rect *rect,
struct drm_format_conv_state *fmtcnv_state);
int (*update_rect)(struct drm_framebuffer *fb, struct drm_rect *rect);
enum st7571_color_mode mode;
const u8 nformats;
const u32 formats[];
};
struct st7571_device {
struct drm_device drm;
struct device *dev;
struct drm_plane primary_plane;
struct drm_crtc crtc;
struct drm_encoder encoder;
struct drm_connector connector;
struct drm_display_mode mode;
const struct st7571_panel_format *pformat;
const struct st7571_panel_data *pdata;
struct gpio_desc *reset;
struct regmap *regmap;
bool grayscale;
bool inverted;
u32 height_mm;
u32 width_mm;
u32 startline;
u32 nlines;
u32 ncols;
u32 bpp;
/* Intermediate buffer in LCD friendly format */
u8 *hwbuf;
/* Row of (transformed) pixels ready to be written to the display */
u8 *row;
};
extern const struct st7571_panel_data st7567_config;
extern const struct st7571_panel_data st7571_config;
struct st7571_device *st7571_probe(struct device *dev, struct regmap *regmap);
void st7571_remove(struct st7571_device *st7571);
#endif /* __ST7571_H__ */
linux-7.2.3/drivers/gpu/drm/sitronix/st7586.c
+498
View File
@@ -0,0 +1,498 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* DRM driver for Sitronix ST7586 panels
*
* Copyright 2017 David Lechner <david@lechnology.com>
*/
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/module.h>
#include <linux/property.h>
#include <linux/spi/spi.h>
#include <video/mipi_display.h>
#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_fb_dma_helper.h>
#include <drm/drm_fbdev_dma.h>
#include <drm/drm_format_helper.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_gem_dma_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_managed.h>
#include <drm/drm_mipi_dbi.h>
#include <drm/drm_print.h>
#include <drm/drm_rect.h>
/* controller-specific commands */
#define ST7586_DISP_MODE_GRAY 0x38
#define ST7586_DISP_MODE_MONO 0x39
#define ST7586_ENABLE_DDRAM 0x3a
#define ST7586_SET_DISP_DUTY 0xb0
#define ST7586_SET_PART_DISP 0xb4
#define ST7586_SET_NLINE_INV 0xb5
#define ST7586_SET_VOP 0xc0
#define ST7586_SET_BIAS_SYSTEM 0xc3
#define ST7586_SET_BOOST_LEVEL 0xc4
#define ST7586_SET_VOP_OFFSET 0xc7
#define ST7586_ENABLE_ANALOG 0xd0
#define ST7586_AUTO_READ_CTRL 0xd7
#define ST7586_OTP_RW_CTRL 0xe0
#define ST7586_OTP_CTRL_OUT 0xe1
#define ST7586_OTP_READ 0xe3
#define ST7586_DISP_CTRL_MX BIT(6)
#define ST7586_DISP_CTRL_MY BIT(7)
struct st7586_device {
struct mipi_dbi_dev dbidev;
struct drm_plane plane;
struct drm_crtc crtc;
struct drm_encoder encoder;
struct drm_connector connector;
};
static struct st7586_device *to_st7586_device(struct drm_device *dev)
{
return container_of(drm_to_mipi_dbi_dev(dev), struct st7586_device, dbidev);
}
/*
* The ST7586 controller has an unusual pixel format where 2bpp grayscale is
* packed 3 pixels per byte with the first two pixels using 3 bits and the 3rd
* pixel using only 2 bits.
*
* | D7 | D6 | D5 || | || 2bpp |
* | (D4) | (D3) | (D2) || D1 | D0 || GRAY |
* +------+------+------++------+------++------+
* | 1 | 1 | 1 || 1 | 1 || 0 0 | black
* | 1 | 0 | 0 || 1 | 0 || 0 1 | dark gray
* | 0 | 1 | 0 || 0 | 1 || 1 0 | light gray
* | 0 | 0 | 0 || 0 | 0 || 1 1 | white
*/
static const u8 st7586_lookup[] = { 0x7, 0x4, 0x2, 0x0 };
static void st7586_xrgb8888_to_gray332(u8 *dst, void *vaddr,
struct drm_framebuffer *fb,
struct drm_rect *clip,
struct drm_format_conv_state *fmtcnv_state)
{
size_t len = (clip->x2 - clip->x1) * (clip->y2 - clip->y1);
unsigned int x, y;
u8 *src, *buf, val;
struct iosys_map dst_map, vmap;
buf = kmalloc(len, GFP_KERNEL);
if (!buf)
return;
iosys_map_set_vaddr(&dst_map, buf);
iosys_map_set_vaddr(&vmap, vaddr);
drm_fb_xrgb8888_to_gray8(&dst_map, NULL, &vmap, fb, clip, fmtcnv_state);
src = buf;
for (y = clip->y1; y < clip->y2; y++) {
for (x = clip->x1; x < clip->x2; x += 3) {
val = st7586_lookup[*src++ >> 6] << 5;
val |= st7586_lookup[*src++ >> 6] << 2;
val |= st7586_lookup[*src++ >> 6] >> 1;
*dst++ = val;
}
}
kfree(buf);
}
static int st7586_buf_copy(void *dst, struct iosys_map *src, struct drm_framebuffer *fb,
struct drm_rect *clip, struct drm_format_conv_state *fmtcnv_state)
{
int ret;
ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
if (ret)
return ret;
st7586_xrgb8888_to_gray332(dst, src->vaddr, fb, clip, fmtcnv_state);
drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
return 0;
}
static void st7586_fb_dirty(struct iosys_map *src, struct drm_framebuffer *fb,
struct drm_rect *rect, struct drm_format_conv_state *fmtcnv_state)
{
struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(fb->dev);
struct mipi_dbi *dbi = &dbidev->dbi;
int start, end, ret = 0;
/* 3 pixels per byte, so grow clip to nearest multiple of 3 */
rect->x1 = rounddown(rect->x1, 3);
rect->x2 = roundup(rect->x2, 3);
DRM_DEBUG_KMS("Flushing [FB:%d] " DRM_RECT_FMT "\n", fb->base.id, DRM_RECT_ARG(rect));
ret = st7586_buf_copy(dbidev->tx_buf, src, fb, rect, fmtcnv_state);
if (ret)
goto err_msg;
/* Pixels are packed 3 per byte */
start = rect->x1 / 3;
end = rect->x2 / 3;
mipi_dbi_command(dbi, MIPI_DCS_SET_COLUMN_ADDRESS,
(start >> 8) & 0xFF, start & 0xFF,
(end >> 8) & 0xFF, (end - 1) & 0xFF);
mipi_dbi_command(dbi, MIPI_DCS_SET_PAGE_ADDRESS,
(rect->y1 >> 8) & 0xFF, rect->y1 & 0xFF,
(rect->y2 >> 8) & 0xFF, (rect->y2 - 1) & 0xFF);
ret = mipi_dbi_command_buf(dbi, MIPI_DCS_WRITE_MEMORY_START,
(u8 *)dbidev->tx_buf,
(end - start) * (rect->y2 - rect->y1));
err_msg:
if (ret)
dev_err_once(fb->dev->dev, "Failed to update display %d\n", ret);
}
static const u32 st7586_plane_formats[] = {
DRM_FORMAT_XRGB8888,
};
static const u64 st7586_plane_format_modifiers[] = {
DRM_MIPI_DBI_PLANE_FORMAT_MODIFIERS,
};
static void st7586_plane_helper_atomic_update(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = plane->state;
struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
struct drm_framebuffer *fb = plane_state->fb;
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_rect rect;
int idx;
if (!fb)
return;
if (!drm_dev_enter(plane->dev, &idx))
return;
if (drm_atomic_helper_damage_merged(old_plane_state, plane_state, &rect))
st7586_fb_dirty(&shadow_plane_state->data[0], fb, &rect,
&shadow_plane_state->fmtcnv_state);
drm_dev_exit(idx);
}
static const struct drm_plane_helper_funcs st7586_plane_helper_funcs = {
DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
.atomic_check = drm_mipi_dbi_plane_helper_atomic_check,
.atomic_update = st7586_plane_helper_atomic_update
};
static const struct drm_plane_funcs st7586_plane_funcs = {
DRM_MIPI_DBI_PLANE_FUNCS,
.destroy = drm_plane_cleanup,
};
static void st7586_crtc_helper_atomic_enable(struct drm_crtc *crtc,
struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7586_device *st7586 = to_st7586_device(drm);
struct mipi_dbi_dev *dbidev = &st7586->dbidev;
struct mipi_dbi *dbi = &dbidev->dbi;
int idx, ret;
u8 addr_mode;
if (!drm_dev_enter(drm, &idx))
return;
DRM_DEBUG_KMS("\n");
ret = mipi_dbi_poweron_reset(dbidev);
if (ret)
goto out_exit;
mipi_dbi_command(dbi, ST7586_AUTO_READ_CTRL, 0x9f);
mipi_dbi_command(dbi, ST7586_OTP_RW_CTRL, 0x00);
msleep(10);
mipi_dbi_command(dbi, ST7586_OTP_READ);
msleep(20);
mipi_dbi_command(dbi, ST7586_OTP_CTRL_OUT);
mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_OFF);
msleep(50);
mipi_dbi_command(dbi, ST7586_SET_VOP_OFFSET, 0x00);
mipi_dbi_command(dbi, ST7586_SET_VOP, 0xe3, 0x00);
mipi_dbi_command(dbi, ST7586_SET_BIAS_SYSTEM, 0x02);
mipi_dbi_command(dbi, ST7586_SET_BOOST_LEVEL, 0x04);
mipi_dbi_command(dbi, ST7586_ENABLE_ANALOG, 0x1d);
mipi_dbi_command(dbi, ST7586_SET_NLINE_INV, 0x00);
mipi_dbi_command(dbi, ST7586_DISP_MODE_GRAY);
mipi_dbi_command(dbi, ST7586_ENABLE_DDRAM, 0x02);
switch (dbidev->rotation) {
default:
addr_mode = 0x00;
break;
case 90:
addr_mode = ST7586_DISP_CTRL_MY;
break;
case 180:
addr_mode = ST7586_DISP_CTRL_MX | ST7586_DISP_CTRL_MY;
break;
case 270:
addr_mode = ST7586_DISP_CTRL_MX;
break;
}
mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, addr_mode);
mipi_dbi_command(dbi, ST7586_SET_DISP_DUTY, 0x7f);
mipi_dbi_command(dbi, ST7586_SET_PART_DISP, 0xa0);
mipi_dbi_command(dbi, MIPI_DCS_SET_PARTIAL_ROWS, 0x00, 0x00, 0x00, 0x77);
mipi_dbi_command(dbi, MIPI_DCS_EXIT_INVERT_MODE);
msleep(100);
mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON);
out_exit:
drm_dev_exit(idx);
}
static void st7586_crtc_helper_atomic_disable(struct drm_crtc *crtc,
struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7586_device *st7586 = to_st7586_device(drm);
struct mipi_dbi_dev *dbidev = &st7586->dbidev;
/*
* This callback is not protected by drm_dev_enter/exit since we want to
* turn off the display on regular driver unload. It's highly unlikely
* that the underlying SPI controller is gone should this be called after
* unplug.
*/
DRM_DEBUG_KMS("\n");
mipi_dbi_command(&dbidev->dbi, MIPI_DCS_SET_DISPLAY_OFF);
}
static const struct drm_crtc_helper_funcs st7586_crtc_helper_funcs = {
.mode_valid = drm_mipi_dbi_crtc_helper_mode_valid,
.atomic_check = drm_mipi_dbi_crtc_helper_atomic_check,
.atomic_enable = st7586_crtc_helper_atomic_enable,
.atomic_disable = st7586_crtc_helper_atomic_disable,
};
static const struct drm_crtc_funcs st7586_crtc_funcs = {
DRM_MIPI_DBI_CRTC_FUNCS,
.destroy = drm_crtc_cleanup,
};
static const struct drm_encoder_funcs st7586_encoder_funcs = {
.destroy = drm_encoder_cleanup,
};
static const struct drm_connector_helper_funcs st7586_connector_helper_funcs = {
DRM_MIPI_DBI_CONNECTOR_HELPER_FUNCS,
};
static const struct drm_connector_funcs st7586_connector_funcs = {
DRM_MIPI_DBI_CONNECTOR_FUNCS,
.destroy = drm_connector_cleanup,
};
static const struct drm_mode_config_helper_funcs st7586_mode_config_helper_funcs = {
DRM_MIPI_DBI_MODE_CONFIG_HELPER_FUNCS,
};
static const struct drm_mode_config_funcs st7586_mode_config_funcs = {
DRM_MIPI_DBI_MODE_CONFIG_FUNCS,
};
static const struct drm_display_mode st7586_mode = {
DRM_SIMPLE_MODE(178, 128, 37, 27),
};
DEFINE_DRM_GEM_DMA_FOPS(st7586_fops);
static const struct drm_driver st7586_driver = {
.driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
.fops = &st7586_fops,
DRM_GEM_DMA_DRIVER_OPS_VMAP,
DRM_FBDEV_DMA_DRIVER_OPS,
.debugfs_init = mipi_dbi_debugfs_init,
.name = "st7586",
.desc = "Sitronix ST7586",
.major = 1,
.minor = 0,
};
static const struct of_device_id st7586_of_match[] = {
{ .compatible = "lego,ev3-lcd" },
{},
};
MODULE_DEVICE_TABLE(of, st7586_of_match);
static const struct spi_device_id st7586_id[] = {
{ "ev3-lcd", 0 },
{ },
};
MODULE_DEVICE_TABLE(spi, st7586_id);
static int st7586_probe(struct spi_device *spi)
{
struct device *dev = &spi->dev;
struct st7586_device *st7586;
struct mipi_dbi_dev *dbidev;
struct drm_device *drm;
struct mipi_dbi *dbi;
struct gpio_desc *a0;
struct drm_plane *plane;
struct drm_crtc *crtc;
struct drm_encoder *encoder;
struct drm_connector *connector;
u32 rotation = 0;
size_t bufsize;
int ret;
st7586 = devm_drm_dev_alloc(dev, &st7586_driver, struct st7586_device, dbidev.drm);
if (IS_ERR(st7586))
return PTR_ERR(st7586);
dbidev = &st7586->dbidev;
dbi = &dbidev->dbi;
drm = &dbidev->drm;
bufsize = (st7586_mode.vdisplay + 2) / 3 * st7586_mode.hdisplay;
dbi->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
if (IS_ERR(dbi->reset))
return dev_err_probe(dev, PTR_ERR(dbi->reset), "Failed to get GPIO 'reset'\n");
a0 = devm_gpiod_get(dev, "a0", GPIOD_OUT_LOW);
if (IS_ERR(a0))
return dev_err_probe(dev, PTR_ERR(a0), "Failed to get GPIO 'a0'\n");
device_property_read_u32(dev, "rotation", &rotation);
ret = mipi_dbi_spi_init(spi, dbi, a0);
if (ret)
return ret;
/*
* Override value set by mipi_dbi_spi_init(). This driver is a bit
* non-standard, so best to set it explicitly here.
*/
dbi->write_memory_bpw = 8;
/* Cannot read from this controller via SPI */
dbi->read_commands = NULL;
ret = drm_mipi_dbi_dev_init(dbidev, &st7586_mode, st7586_plane_formats[0],
rotation, bufsize);
if (ret)
return ret;
ret = drmm_mode_config_init(drm);
if (ret)
return ret;
drm->mode_config.min_width = dbidev->mode.hdisplay;
drm->mode_config.max_width = dbidev->mode.hdisplay;
drm->mode_config.min_height = dbidev->mode.vdisplay;
drm->mode_config.max_height = dbidev->mode.vdisplay;
drm->mode_config.funcs = &st7586_mode_config_funcs;
drm->mode_config.preferred_depth = 24;
drm->mode_config.helper_private = &st7586_mode_config_helper_funcs;
plane = &st7586->plane;
ret = drm_universal_plane_init(drm, plane, 0, &st7586_plane_funcs,
st7586_plane_formats, ARRAY_SIZE(st7586_plane_formats),
st7586_plane_format_modifiers,
DRM_PLANE_TYPE_PRIMARY, NULL);
if (ret)
return ret;
drm_plane_helper_add(plane, &st7586_plane_helper_funcs);
drm_plane_enable_fb_damage_clips(plane);
crtc = &st7586->crtc;
ret = drm_crtc_init_with_planes(drm, crtc, plane, NULL, &st7586_crtc_funcs, NULL);
if (ret)
return ret;
drm_crtc_helper_add(crtc, &st7586_crtc_helper_funcs);
encoder = &st7586->encoder;
ret = drm_encoder_init(drm, encoder, &st7586_encoder_funcs, DRM_MODE_ENCODER_NONE, NULL);
if (ret)
return ret;
encoder->possible_crtcs = drm_crtc_mask(crtc);
connector = &st7586->connector;
ret = drm_connector_init(drm, connector, &st7586_connector_funcs,
DRM_MODE_CONNECTOR_SPI);
if (ret)
return ret;
drm_connector_helper_add(connector, &st7586_connector_helper_funcs);
ret = drm_connector_attach_encoder(connector, encoder);
if (ret)
return ret;
drm_mode_config_reset(drm);
ret = drm_dev_register(drm, 0);
if (ret)
return ret;
spi_set_drvdata(spi, drm);
drm_client_setup(drm, NULL);
return 0;
}
static void st7586_remove(struct spi_device *spi)
{
struct drm_device *drm = spi_get_drvdata(spi);
drm_dev_unplug(drm);
drm_atomic_helper_shutdown(drm);
}
static void st7586_shutdown(struct spi_device *spi)
{
drm_atomic_helper_shutdown(spi_get_drvdata(spi));
}
static struct spi_driver st7586_spi_driver = {
.driver = {
.name = "st7586",
.of_match_table = st7586_of_match,
},
.id_table = st7586_id,
.probe = st7586_probe,
.remove = st7586_remove,
.shutdown = st7586_shutdown,
};
module_spi_driver(st7586_spi_driver);
MODULE_DESCRIPTION("Sitronix ST7586 DRM driver");
MODULE_AUTHOR("David Lechner <david@lechnology.com>");
MODULE_LICENSE("GPL");
linux-7.2.3/drivers/gpu/drm/sitronix/st7735r.c
+378
View File
@@ -0,0 +1,378 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* DRM driver for display panels connected to a Sitronix ST7715R or ST7735R
* display controller in SPI mode.
*
* Copyright 2017 David Lechner <david@lechnology.com>
* Copyright (C) 2019 Glider bvba
*/
#include <linux/backlight.h>
#include <linux/delay.h>
#include <linux/dma-buf.h>
#include <linux/gpio/consumer.h>
#include <linux/module.h>
#include <linux/property.h>
#include <linux/spi/spi.h>
#include <video/mipi_display.h>
#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_fbdev_dma.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_gem_dma_helper.h>
#include <drm/drm_managed.h>
#include <drm/drm_mipi_dbi.h>
#include <drm/drm_print.h>
#define ST7735R_FRMCTR1 0xb1
#define ST7735R_FRMCTR2 0xb2
#define ST7735R_FRMCTR3 0xb3
#define ST7735R_INVCTR 0xb4
#define ST7735R_PWCTR1 0xc0
#define ST7735R_PWCTR2 0xc1
#define ST7735R_PWCTR3 0xc2
#define ST7735R_PWCTR4 0xc3
#define ST7735R_PWCTR5 0xc4
#define ST7735R_VMCTR1 0xc5
#define ST7735R_GAMCTRP1 0xe0
#define ST7735R_GAMCTRN1 0xe1
#define ST7735R_MY BIT(7)
#define ST7735R_MX BIT(6)
#define ST7735R_MV BIT(5)
#define ST7735R_RGB BIT(3)
struct st7735r_cfg {
const struct drm_display_mode mode;
unsigned int left_offset;
unsigned int top_offset;
unsigned int write_only:1;
unsigned int rgb:1; /* RGB (vs. BGR) */
};
struct st7735r_device {
struct mipi_dbi_dev dbidev; /* Must be first for .release() */
const struct st7735r_cfg *cfg;
struct drm_plane plane;
struct drm_crtc crtc;
struct drm_encoder encoder;
struct drm_connector connector;
};
static struct st7735r_device *to_st7735r_device(struct drm_device *drm)
{
return container_of(drm_to_mipi_dbi_dev(drm), struct st7735r_device, dbidev);
}
static const u32 st7735r_plane_formats[] = {
DRM_MIPI_DBI_PLANE_FORMATS,
};
static const u64 st7735r_plane_format_modifiers[] = {
DRM_MIPI_DBI_PLANE_FORMAT_MODIFIERS,
};
static const struct drm_plane_helper_funcs st7735r_plane_helper_funcs = {
DRM_MIPI_DBI_PLANE_HELPER_FUNCS,
};
static const struct drm_plane_funcs st7735r_plane_funcs = {
DRM_MIPI_DBI_PLANE_FUNCS,
.destroy = drm_plane_cleanup,
};
static void st7735r_crtc_helper_atomic_enable(struct drm_crtc *crtc,
struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7735r_device *st7735r = to_st7735r_device(drm);
struct mipi_dbi_dev *dbidev = &st7735r->dbidev;
struct mipi_dbi *dbi = &dbidev->dbi;
int ret, idx;
u8 addr_mode;
if (!drm_dev_enter(drm, &idx))
return;
DRM_DEBUG_KMS("\n");
ret = mipi_dbi_poweron_reset(dbidev);
if (ret)
goto out_exit;
msleep(150);
mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
msleep(500);
mipi_dbi_command(dbi, ST7735R_FRMCTR1, 0x01, 0x2c, 0x2d);
mipi_dbi_command(dbi, ST7735R_FRMCTR2, 0x01, 0x2c, 0x2d);
mipi_dbi_command(dbi, ST7735R_FRMCTR3, 0x01, 0x2c, 0x2d, 0x01, 0x2c,
0x2d);
mipi_dbi_command(dbi, ST7735R_INVCTR, 0x07);
mipi_dbi_command(dbi, ST7735R_PWCTR1, 0xa2, 0x02, 0x84);
mipi_dbi_command(dbi, ST7735R_PWCTR2, 0xc5);
mipi_dbi_command(dbi, ST7735R_PWCTR3, 0x0a, 0x00);
mipi_dbi_command(dbi, ST7735R_PWCTR4, 0x8a, 0x2a);
mipi_dbi_command(dbi, ST7735R_PWCTR5, 0x8a, 0xee);
mipi_dbi_command(dbi, ST7735R_VMCTR1, 0x0e);
mipi_dbi_command(dbi, MIPI_DCS_EXIT_INVERT_MODE);
switch (dbidev->rotation) {
default:
addr_mode = ST7735R_MX | ST7735R_MY;
break;
case 90:
addr_mode = ST7735R_MX | ST7735R_MV;
break;
case 180:
addr_mode = 0;
break;
case 270:
addr_mode = ST7735R_MY | ST7735R_MV;
break;
}
if (st7735r->cfg->rgb)
addr_mode |= ST7735R_RGB;
mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, addr_mode);
mipi_dbi_command(dbi, MIPI_DCS_SET_PIXEL_FORMAT,
MIPI_DCS_PIXEL_FMT_16BIT);
mipi_dbi_command(dbi, ST7735R_GAMCTRP1, 0x02, 0x1c, 0x07, 0x12, 0x37,
0x32, 0x29, 0x2d, 0x29, 0x25, 0x2b, 0x39, 0x00, 0x01,
0x03, 0x10);
mipi_dbi_command(dbi, ST7735R_GAMCTRN1, 0x03, 0x1d, 0x07, 0x06, 0x2e,
0x2c, 0x29, 0x2d, 0x2e, 0x2e, 0x37, 0x3f, 0x00, 0x00,
0x02, 0x10);
mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON);
msleep(100);
mipi_dbi_command(dbi, MIPI_DCS_ENTER_NORMAL_MODE);
msleep(20);
backlight_enable(dbidev->backlight);
out_exit:
drm_dev_exit(idx);
}
static const struct drm_crtc_helper_funcs st7735r_crtc_helper_funcs = {
DRM_MIPI_DBI_CRTC_HELPER_FUNCS,
.atomic_enable = st7735r_crtc_helper_atomic_enable,
};
static const struct drm_crtc_funcs st7735r_crtc_funcs = {
DRM_MIPI_DBI_CRTC_FUNCS,
.destroy = drm_crtc_cleanup,
};
static const struct drm_encoder_funcs st7735r_encoder_funcs = {
.destroy = drm_encoder_cleanup,
};
static const struct drm_connector_helper_funcs st7735r_connector_helper_funcs = {
DRM_MIPI_DBI_CONNECTOR_HELPER_FUNCS,
};
static const struct drm_connector_funcs st7735r_connector_funcs = {
DRM_MIPI_DBI_CONNECTOR_FUNCS,
.destroy = drm_connector_cleanup,
};
static const struct drm_mode_config_helper_funcs st7735r_mode_config_helper_funcs = {
DRM_MIPI_DBI_MODE_CONFIG_HELPER_FUNCS,
};
static const struct drm_mode_config_funcs st7735r_mode_config_funcs = {
DRM_MIPI_DBI_MODE_CONFIG_FUNCS,
};
static const struct st7735r_cfg jd_t18003_t01_cfg = {
.mode = { DRM_SIMPLE_MODE(128, 160, 28, 35) },
/* Cannot read from Adafruit 1.8" display via SPI */
.write_only = true,
};
static const struct st7735r_cfg rh128128t_cfg = {
.mode = { DRM_SIMPLE_MODE(128, 128, 25, 26) },
.left_offset = 2,
.top_offset = 3,
.rgb = true,
};
DEFINE_DRM_GEM_DMA_FOPS(st7735r_fops);
static const struct drm_driver st7735r_driver = {
.driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
.fops = &st7735r_fops,
DRM_GEM_DMA_DRIVER_OPS_VMAP,
DRM_FBDEV_DMA_DRIVER_OPS,
.debugfs_init = mipi_dbi_debugfs_init,
.name = "st7735r",
.desc = "Sitronix ST7735R",
.major = 1,
.minor = 0,
};
static const struct of_device_id st7735r_of_match[] = {
{ .compatible = "jianda,jd-t18003-t01", .data = &jd_t18003_t01_cfg },
{ .compatible = "okaya,rh128128t", .data = &rh128128t_cfg },
{ },
};
MODULE_DEVICE_TABLE(of, st7735r_of_match);
static const struct spi_device_id st7735r_id[] = {
{ "jd-t18003-t01", (uintptr_t)&jd_t18003_t01_cfg },
{ "rh128128t", (uintptr_t)&rh128128t_cfg },
{ },
};
MODULE_DEVICE_TABLE(spi, st7735r_id);
static int st7735r_probe(struct spi_device *spi)
{
struct device *dev = &spi->dev;
const struct st7735r_cfg *cfg;
struct mipi_dbi_dev *dbidev;
struct st7735r_device *st7735r;
struct drm_device *drm;
struct mipi_dbi *dbi;
struct gpio_desc *dc;
struct drm_plane *plane;
struct drm_crtc *crtc;
struct drm_encoder *encoder;
struct drm_connector *connector;
u32 rotation = 0;
int ret;
cfg = device_get_match_data(&spi->dev);
if (!cfg)
cfg = (void *)spi_get_device_id(spi)->driver_data;
st7735r = devm_drm_dev_alloc(dev, &st7735r_driver, struct st7735r_device, dbidev.drm);
if (IS_ERR(st7735r))
return PTR_ERR(st7735r);
dbidev = &st7735r->dbidev;
st7735r->cfg = cfg;
dbi = &dbidev->dbi;
drm = &dbidev->drm;
dbi->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
if (IS_ERR(dbi->reset))
return dev_err_probe(dev, PTR_ERR(dbi->reset), "Failed to get GPIO 'reset'\n");
dc = devm_gpiod_get(dev, "dc", GPIOD_OUT_LOW);
if (IS_ERR(dc))
return dev_err_probe(dev, PTR_ERR(dc), "Failed to get GPIO 'dc'\n");
dbidev->backlight = devm_of_find_backlight(dev);
if (IS_ERR(dbidev->backlight))
return PTR_ERR(dbidev->backlight);
device_property_read_u32(dev, "rotation", &rotation);
ret = mipi_dbi_spi_init(spi, dbi, dc);
if (ret)
return ret;
if (cfg->write_only)
dbi->read_commands = NULL;
dbidev->left_offset = cfg->left_offset;
dbidev->top_offset = cfg->top_offset;
ret = drm_mipi_dbi_dev_init(dbidev, &cfg->mode, st7735r_plane_formats[0], rotation, 0);
if (ret)
return ret;
ret = drmm_mode_config_init(drm);
if (ret)
return ret;
drm->mode_config.min_width = dbidev->mode.hdisplay;
drm->mode_config.max_width = dbidev->mode.hdisplay;
drm->mode_config.min_height = dbidev->mode.vdisplay;
drm->mode_config.max_height = dbidev->mode.vdisplay;
drm->mode_config.funcs = &st7735r_mode_config_funcs;
drm->mode_config.preferred_depth = 16;
drm->mode_config.helper_private = &st7735r_mode_config_helper_funcs;
plane = &st7735r->plane;
ret = drm_universal_plane_init(drm, plane, 0, &st7735r_plane_funcs,
st7735r_plane_formats, ARRAY_SIZE(st7735r_plane_formats),
st7735r_plane_format_modifiers,
DRM_PLANE_TYPE_PRIMARY, NULL);
if (ret)
return ret;
drm_plane_helper_add(plane, &st7735r_plane_helper_funcs);
drm_plane_enable_fb_damage_clips(plane);
crtc = &st7735r->crtc;
ret = drm_crtc_init_with_planes(drm, crtc, plane, NULL, &st7735r_crtc_funcs, NULL);
if (ret)
return ret;
drm_crtc_helper_add(crtc, &st7735r_crtc_helper_funcs);
encoder = &st7735r->encoder;
ret = drm_encoder_init(drm, encoder, &st7735r_encoder_funcs, DRM_MODE_ENCODER_NONE, NULL);
if (ret)
return ret;
encoder->possible_crtcs = drm_crtc_mask(crtc);
connector = &st7735r->connector;
ret = drm_connector_init(drm, connector, &st7735r_connector_funcs,
DRM_MODE_CONNECTOR_SPI);
if (ret)
return ret;
drm_connector_helper_add(connector, &st7735r_connector_helper_funcs);
ret = drm_connector_attach_encoder(connector, encoder);
if (ret)
return ret;
drm_mode_config_reset(drm);
ret = drm_dev_register(drm, 0);
if (ret)
return ret;
spi_set_drvdata(spi, drm);
drm_client_setup(drm, NULL);
return 0;
}
static void st7735r_remove(struct spi_device *spi)
{
struct drm_device *drm = spi_get_drvdata(spi);
drm_dev_unplug(drm);
drm_atomic_helper_shutdown(drm);
}
static void st7735r_shutdown(struct spi_device *spi)
{
drm_atomic_helper_shutdown(spi_get_drvdata(spi));
}
static struct spi_driver st7735r_spi_driver = {
.driver = {
.name = "st7735r",
.of_match_table = st7735r_of_match,
},
.id_table = st7735r_id,
.probe = st7735r_probe,
.remove = st7735r_remove,
.shutdown = st7735r_shutdown,
};
module_spi_driver(st7735r_spi_driver);
MODULE_DESCRIPTION("Sitronix ST7735R DRM driver");
MODULE_AUTHOR("David Lechner <david@lechnology.com>");
MODULE_LICENSE("GPL");
linux-7.2.3/drivers/gpu/drm/sitronix/st7920.c
+867
View File
@@ -0,0 +1,867 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* DRM driver for Sitronix ST7920 LCD displays
*
* Copyright 2025 Iker Pedrosa <ikerpedrosam@gmail.com>
*
*/
#include <linux/bitrev.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/spi/spi.h>
#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_fbdev_shmem.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_gem_shmem_helper.h>
#include <drm/drm_plane.h>
#include <drm/drm_print.h>
#include <drm/drm_probe_helper.h>
#define DRIVER_NAME "sitronix_st7920"
#define DRIVER_DESC "DRM driver for Sitronix ST7920 LCD displays"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 0
/* Display organization */
#define ST7920_PITCH 16
#define ST7920_SCANLINES 64
#define BYTES_IN_DISPLAY (ST7920_PITCH * ST7920_SCANLINES)
#define BYTES_IN_SEGMENT 2
#define PIXELS_PER_SEGMENT (BYTES_IN_SEGMENT * 8)
#define ST7920_DEFAULT_WIDTH 128
#define ST7920_DEFAULT_HEIGHT 64
/* Sync sequence */
#define SYNC_BITS 0xF8
#define RW_HIGH 0x04
#define RS_HIGH 0x02
/* Commands */
#define SET_DISPLAY_ON 0x0C
#define SET_DISPLAY_OFF 0x08
#define SET_DISPLAY_CLEAR 0x01
#define SET_BASIC_INSTRUCTION_SET 0x30
#define SET_EXT_INSTRUCTION_SET 0x34
#define SET_GRAPHICS_DISPLAY 0x36
#define SET_GDRAM_ADDRESS 0x80
#define SET_GDRAM_DATA 0xFF /* Driver internal command */
/* Masks */
#define HIGH_DATA_MASK 0xF0
#define LOW_DATA_MASK 0x0F
#define TOP_VERTICAL_ADDRESS 0x80
#define BOTTOM_VERTICAL_ADDRESS 0x60
#define TOP_HORIZONTAL_ADDRESS 0x00
#define BOTTOM_HORIZONTAL_ADDRESS 0x80
#define CMD_SIZE 35
struct spi7920_error {
int errno;
};
struct st7920_device {
struct drm_device drm;
struct drm_display_mode mode;
struct drm_plane primary_plane;
struct drm_crtc crtc;
struct drm_encoder encoder;
struct drm_connector connector;
struct spi_device *spi;
struct regmap *regmap;
struct gpio_desc *reset_gpio;
u32 height;
u32 width;
};
struct st7920_plane_state {
struct drm_shadow_plane_state base;
/* Intermediate buffer to convert pixels from XRGB8888 to HW format */
u8 *buffer;
};
struct st7920_crtc_state {
struct drm_crtc_state base;
/* Buffer to store pixels in HW format and written to the panel */
u8 *data_array;
};
static inline struct st7920_plane_state *to_st7920_plane_state(struct drm_plane_state *state)
{
return container_of(state, struct st7920_plane_state, base.base);
}
static inline struct st7920_crtc_state *to_st7920_crtc_state(struct drm_crtc_state *state)
{
return container_of(state, struct st7920_crtc_state, base);
}
static inline struct st7920_device *drm_to_st7920(struct drm_device *drm)
{
return container_of(drm, struct st7920_device, drm);
}
static int st7920_store_gdram_address(const void *data, u8 *reg)
{
const u8 y_addr = *(const u8 *)data;
bool bottom_screen = (y_addr >= 32);
int i = 0;
reg[i++] = SYNC_BITS;
/* Set vertical address */
if (!bottom_screen)
reg[i++] = TOP_VERTICAL_ADDRESS + (*(uint8_t *)data & HIGH_DATA_MASK);
else
reg[i++] = BOTTOM_VERTICAL_ADDRESS + (*(uint8_t *)data & HIGH_DATA_MASK);
reg[i++] = *(uint8_t *)data << 4;
/* Set horizontal address */
reg[i++] = SET_GDRAM_ADDRESS;
if (!bottom_screen)
reg[i++] = TOP_HORIZONTAL_ADDRESS;
else
reg[i++] = BOTTOM_HORIZONTAL_ADDRESS;
return i;
}
static int st7920_store_gdram_data(const void *data, u8 *reg)
{
const u8 *line_data = data;
int i = 0, j = 0;
reg[i++] = SYNC_BITS | RS_HIGH;
for (j = 0; j < 16; j++) {
reg[i++] = line_data[j] & 0xF0;
reg[i++] = (line_data[j] << 4) & 0xF0;
}
return i;
}
static int st7920_store_others(int cmd, const void *data, u8 *reg)
{
int i = 0;
reg[i++] = SYNC_BITS;
reg[i++] = cmd & HIGH_DATA_MASK;
reg[i++] = (cmd & LOW_DATA_MASK) << 4;
return i;
}
static void st7920_spi_write(struct spi_device *spi, int cmd, const void *data,
int delay_us, struct spi7920_error *err)
{
u8 reg[CMD_SIZE] = {0};
int size = 0;
int ret;
if (err->errno)
return;
/*
* First the sync bits are sent: 11111WS0.
* Where W is the read/write (RW) bit and S is the register/data (RS) bit.
* Then, every 8 bits instruction/data will be separated into 2 groups.
* Higher 4 bits (DB7~DB4) will be placed in the first section followed by
* 4 '0's. And lower 4 bits (DB3~DB0) will be placed in the second section
* followed by 4 '0's.
*/
if (cmd == SET_GDRAM_ADDRESS)
size = st7920_store_gdram_address(data, reg);
else if (cmd == SET_GDRAM_DATA)
size = st7920_store_gdram_data(data, reg);
else
size = st7920_store_others(cmd, data, reg);
ret = spi_write(spi, reg, size);
if (ret) {
err->errno = ret;
return;
}
if (delay_us)
udelay(delay_us);
}
static const struct regmap_config st7920_spi_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
};
static const struct of_device_id st7920_of_match[] = {
/* st7920 family */
{
.compatible = "sitronix,st7920",
},
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, st7920_of_match);
/*
* The SPI core always reports a MODALIAS uevent of the form "spi:<dev>", even
* if the device was registered via OF. This means that the module will not be
* auto loaded, unless it contains an alias that matches the MODALIAS reported.
*
* To workaround this issue, add a SPI device ID table. Even when this should
* not be needed for this driver to match the registered SPI devices.
*/
static const struct spi_device_id st7920_spi_id[] = {
/* st7920 family */
{ "st7920", 0 },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(spi, st7920_spi_id);
static void st7920_power_on(struct st7920_device *st7920,
struct spi7920_error *err)
{
st7920_spi_write(st7920->spi, SET_DISPLAY_ON, NULL, 72, err);
}
static void st7920_power_off(struct st7920_device *st7920,
struct spi7920_error *err)
{
st7920_spi_write(st7920->spi, SET_DISPLAY_CLEAR, NULL, 1600, err);
st7920_spi_write(st7920->spi, SET_DISPLAY_OFF, NULL, 72, err);
}
static void st7920_hw_reset(struct st7920_device *st7920)
{
if (!st7920->reset_gpio)
return;
gpiod_set_value_cansleep(st7920->reset_gpio, 1);
usleep_range(15, 20);
gpiod_set_value_cansleep(st7920->reset_gpio, 0);
msleep(40);
}
static int st7920_init(struct st7920_device *st7920)
{
struct spi7920_error err = {0};
st7920_spi_write(st7920->spi, SET_BASIC_INSTRUCTION_SET, NULL, 72, &err);
st7920_power_on(st7920, &err);
st7920_spi_write(st7920->spi, SET_GRAPHICS_DISPLAY, NULL, 72, &err);
st7920_spi_write(st7920->spi, SET_DISPLAY_CLEAR, NULL, 1600, &err);
return err.errno;
}
static int st7920_update_rect(struct st7920_device *st7920,
struct drm_rect *rect, u8 *buf,
u8 *data_array)
{
struct spi7920_error err = {0};
u32 array_idx = 0;
int i, j;
/*
* The screen is divided in 64(Y)x8(X) segments and each segment is
* further divided in 2 bytes (D15~D0).
*
* Segment 0x0 is in the top-right corner, while segment 63x15 is in the
* bottom-left. They would be displayed in the screen in the following way:
* 0x0 0x1 0x2 ... 0x15
* 1x0 1x1 1x2 ... 1x15
* ...
* 63x0 63x1 63x2 ... 63x15
*
* The data in each byte is big endian.
*/
for (i = 0; i < ST7920_SCANLINES; i++) {
u8 *line_start = buf + (i * ST7920_PITCH);
u8 line_buffer[ST7920_PITCH];
for (j = 0; j < ST7920_PITCH; j++) {
line_buffer[j] = bitrev8(line_start[j]);
data_array[array_idx++] = line_buffer[j];
}
st7920_spi_write(st7920->spi, SET_GDRAM_ADDRESS, &i, 72, &err);
st7920_spi_write(st7920->spi, SET_GDRAM_DATA, line_buffer, 72, &err);
}
return err.errno;
}
static void st7920_clear_screen(struct st7920_device *st7920, u8 *data_array)
{
struct spi7920_error err = {0};
memset(data_array, 0, BYTES_IN_DISPLAY);
st7920_spi_write(st7920->spi, SET_DISPLAY_CLEAR, NULL, 1600, &err);
}
static int st7920_fb_blit_rect(struct drm_framebuffer *fb,
const struct iosys_map *vmap,
struct drm_rect *rect,
u8 *buf, u8 *data_array,
struct drm_format_conv_state *fmtcnv_state)
{
struct st7920_device *st7920 = drm_to_st7920(fb->dev);
struct iosys_map dst;
unsigned int dst_pitch;
int ret;
/* Align y to display page boundaries */
rect->y1 = round_down(rect->y1, PIXELS_PER_SEGMENT);
rect->y2 = min_t(unsigned int, round_up(rect->y2, PIXELS_PER_SEGMENT), st7920->height);
dst_pitch = DIV_ROUND_UP(drm_rect_width(rect), 8);
iosys_map_set_vaddr(&dst, buf);
drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);
ret = st7920_update_rect(st7920, rect, buf, data_array);
return ret;
}
static int st7920_primary_plane_atomic_check(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct st7920_plane_state *st7920_state = to_st7920_plane_state(plane_state);
struct drm_shadow_plane_state *shadow_plane_state = &st7920_state->base;
struct drm_crtc *crtc = plane_state->crtc;
struct drm_crtc_state *crtc_state = NULL;
const struct drm_format_info *fi;
unsigned int pitch;
int ret;
if (crtc)
crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state,
DRM_PLANE_NO_SCALING,
DRM_PLANE_NO_SCALING,
false, false);
if (ret)
return ret;
else if (!plane_state->visible)
return 0;
fi = drm_format_info(DRM_FORMAT_R1);
if (!fi)
return -EINVAL;
pitch = drm_format_info_min_pitch(fi, 0, st7920->width);
if (plane_state->fb->format != fi) {
void *buf;
/* format conversion necessary; reserve buffer */
buf = drm_format_conv_state_reserve(&shadow_plane_state->fmtcnv_state,
pitch, GFP_KERNEL);
if (!buf)
return -ENOMEM;
}
st7920_state->buffer = kcalloc(pitch, st7920->height, GFP_KERNEL);
if (!st7920_state->buffer)
return -ENOMEM;
return 0;
}
static void st7920_primary_plane_atomic_update(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc);
struct st7920_crtc_state *st7920_crtc_state = to_st7920_crtc_state(crtc_state);
struct st7920_plane_state *st7920_plane_state = to_st7920_plane_state(plane_state);
struct drm_framebuffer *fb = plane_state->fb;
struct drm_atomic_helper_damage_iter iter;
struct drm_device *drm = plane->dev;
struct drm_rect dst_clip;
struct drm_rect damage;
int idx;
int ret;
if (!drm_dev_enter(drm, &idx))
return;
if (drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE) == 0) {
drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);
drm_atomic_for_each_plane_damage(&iter, &damage) {
dst_clip = plane_state->dst;
if (!drm_rect_intersect(&dst_clip, &damage))
continue;
ret = st7920_fb_blit_rect(fb, &shadow_plane_state->data[0], &dst_clip,
st7920_plane_state->buffer,
st7920_crtc_state->data_array,
&shadow_plane_state->fmtcnv_state);
if (ret)
drm_err_once(plane->dev, "Failed to write to device: %d.\n", ret);
}
drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
}
drm_dev_exit(idx);
}
static void st7920_primary_plane_atomic_disable(struct drm_plane *plane,
struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc_state *crtc_state;
struct st7920_crtc_state *st7920_crtc_state;
int idx;
if (!plane_state->crtc)
return;
crtc_state = drm_atomic_get_new_crtc_state(state, plane_state->crtc);
st7920_crtc_state = to_st7920_crtc_state(crtc_state);
if (!drm_dev_enter(drm, &idx))
return;
st7920_clear_screen(st7920, st7920_crtc_state->data_array);
drm_dev_exit(idx);
}
/* Called during init to allocate the plane's atomic state. */
static void st7920_primary_plane_reset(struct drm_plane *plane)
{
struct st7920_plane_state *st7920_state;
drm_WARN_ON_ONCE(plane->dev, plane->state);
st7920_state = kzalloc_obj(*st7920_state);
if (!st7920_state)
return;
__drm_gem_reset_shadow_plane(plane, &st7920_state->base);
}
static struct drm_plane_state *st7920_primary_plane_duplicate_state(struct drm_plane *plane)
{
struct drm_shadow_plane_state *new_shadow_plane_state;
struct st7920_plane_state *st7920_state;
if (drm_WARN_ON_ONCE(plane->dev, !plane->state))
return NULL;
st7920_state = kzalloc_obj(*st7920_state);
if (!st7920_state)
return NULL;
new_shadow_plane_state = &st7920_state->base;
__drm_gem_duplicate_shadow_plane_state(plane, new_shadow_plane_state);
return &new_shadow_plane_state->base;
}
static void st7920_primary_plane_destroy_state(struct drm_plane *plane,
struct drm_plane_state *state)
{
struct st7920_plane_state *st7920_state = to_st7920_plane_state(state);
kfree(st7920_state->buffer);
__drm_gem_destroy_shadow_plane_state(&st7920_state->base);
kfree(st7920_state);
}
static const struct drm_plane_helper_funcs st7920_primary_plane_helper_funcs = {
DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
.atomic_check = st7920_primary_plane_atomic_check,
.atomic_update = st7920_primary_plane_atomic_update,
.atomic_disable = st7920_primary_plane_atomic_disable,
};
static const struct drm_plane_funcs st7920_primary_plane_funcs = {
.update_plane = drm_atomic_helper_update_plane,
.disable_plane = drm_atomic_helper_disable_plane,
.reset = st7920_primary_plane_reset,
.atomic_duplicate_state = st7920_primary_plane_duplicate_state,
.atomic_destroy_state = st7920_primary_plane_destroy_state,
.destroy = drm_plane_cleanup,
};
static enum drm_mode_status st7920_crtc_mode_valid(struct drm_crtc *crtc,
const struct drm_display_mode *mode)
{
struct st7920_device *st7920 = drm_to_st7920(crtc->dev);
return drm_crtc_helper_mode_valid_fixed(crtc, mode, &st7920->mode);
}
static int st7920_crtc_atomic_check(struct drm_crtc *crtc,
struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
struct st7920_crtc_state *st7920_state = to_st7920_crtc_state(crtc_state);
int ret;
ret = drm_crtc_helper_atomic_check(crtc, state);
if (ret)
return ret;
st7920_state->data_array = kmalloc(BYTES_IN_DISPLAY, GFP_KERNEL);
if (!st7920_state->data_array)
return -ENOMEM;
return 0;
}
static void st7920_crtc_atomic_enable(struct drm_crtc *crtc,
struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
int idx;
int ret;
if (!drm_dev_enter(drm, &idx))
return;
st7920_hw_reset(st7920);
ret = st7920_init(st7920);
if (ret)
drm_err(drm, "Failed to init hardware: %d\n", ret);
drm_dev_exit(idx);
}
static void st7920_crtc_atomic_disable(struct drm_crtc *crtc,
struct drm_atomic_commit *state)
{
struct spi7920_error err = {0};
struct drm_device *drm = crtc->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
int idx;
drm_dev_enter(drm, &idx);
st7920_power_off(st7920, &err);
drm_dev_exit(idx);
}
/* Called during init to allocate the CRTC's atomic state. */
static void st7920_crtc_reset(struct drm_crtc *crtc)
{
struct st7920_crtc_state *st7920_state;
drm_WARN_ON_ONCE(crtc->dev, crtc->state);
st7920_state = kzalloc_obj(*st7920_state);
if (!st7920_state)
return;
__drm_atomic_helper_crtc_reset(crtc, &st7920_state->base);
}
static struct drm_crtc_state *st7920_crtc_duplicate_state(struct drm_crtc *crtc)
{
struct st7920_crtc_state *st7920_state;
if (drm_WARN_ON_ONCE(crtc->dev, !crtc->state))
return NULL;
st7920_state = kzalloc_obj(*st7920_state);
if (!st7920_state)
return NULL;
__drm_atomic_helper_crtc_duplicate_state(crtc, &st7920_state->base);
return &st7920_state->base;
}
static void st7920_crtc_destroy_state(struct drm_crtc *crtc,
struct drm_crtc_state *state)
{
struct st7920_crtc_state *st7920_state = to_st7920_crtc_state(state);
kfree(st7920_state->data_array);
__drm_atomic_helper_crtc_destroy_state(state);
kfree(st7920_state);
}
/*
* The CRTC is always enabled. Screen updates are performed by
* the primary plane's atomic_update function. Disabling clears
* the screen in the primary plane's atomic_disable function.
*/
static const struct drm_crtc_helper_funcs st7920_crtc_helper_funcs = {
.mode_valid = st7920_crtc_mode_valid,
.atomic_check = st7920_crtc_atomic_check,
.atomic_enable = st7920_crtc_atomic_enable,
.atomic_disable = st7920_crtc_atomic_disable,
};
static const struct drm_crtc_funcs st7920_crtc_funcs = {
.reset = st7920_crtc_reset,
.destroy = drm_crtc_cleanup,
.set_config = drm_atomic_helper_set_config,
.page_flip = drm_atomic_helper_page_flip,
.atomic_duplicate_state = st7920_crtc_duplicate_state,
.atomic_destroy_state = st7920_crtc_destroy_state,
};
static const struct drm_encoder_funcs st7920_encoder_funcs = {
.destroy = drm_encoder_cleanup,
};
static int st7920_connector_get_modes(struct drm_connector *connector)
{
struct st7920_device *st7920 = drm_to_st7920(connector->dev);
return drm_connector_helper_get_modes_fixed(connector, &st7920->mode);
}
static const struct drm_connector_helper_funcs st7920_connector_helper_funcs = {
.get_modes = st7920_connector_get_modes,
};
static const struct drm_connector_funcs st7920_connector_funcs = {
.reset = drm_atomic_helper_connector_reset,
.fill_modes = drm_helper_probe_single_connector_modes,
.destroy = drm_connector_cleanup,
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};
static const struct drm_mode_config_funcs st7920_mode_config_funcs = {
.fb_create = drm_gem_fb_create_with_dirty,
.atomic_check = drm_atomic_helper_check,
.atomic_commit = drm_atomic_helper_commit,
};
static const uint32_t st7920_formats[] = {
DRM_FORMAT_XRGB8888,
};
DEFINE_DRM_GEM_FOPS(st7920_fops);
static const struct drm_driver st7920_drm_driver = {
DRM_GEM_SHMEM_DRIVER_OPS,
DRM_FBDEV_SHMEM_DRIVER_OPS,
.name = DRIVER_NAME,
.desc = DRIVER_DESC,
.major = DRIVER_MAJOR,
.minor = DRIVER_MINOR,
.driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
.fops = &st7920_fops,
};
static int st7920_init_modeset(struct st7920_device *st7920)
{
struct drm_display_mode *mode = &st7920->mode;
struct drm_device *drm = &st7920->drm;
unsigned long max_width, max_height;
struct drm_plane *primary_plane;
struct drm_crtc *crtc;
struct drm_encoder *encoder;
struct drm_connector *connector;
int ret;
/*
* Modesetting
*/
ret = drmm_mode_config_init(drm);
if (ret) {
drm_err(drm, "DRM mode config init failed: %d\n", ret);
return ret;
}
mode->type = DRM_MODE_TYPE_DRIVER;
mode->clock = 30;
mode->hdisplay = st7920->width;
mode->htotal = st7920->width;
mode->hsync_start = st7920->width;
mode->hsync_end = st7920->width;
mode->vdisplay = st7920->height;
mode->vtotal = st7920->height;
mode->vsync_start = st7920->height;
mode->vsync_end = st7920->height;
mode->width_mm = 27;
mode->height_mm = 27;
max_width = max_t(unsigned long, mode->hdisplay, DRM_SHADOW_PLANE_MAX_WIDTH);
max_height = max_t(unsigned long, mode->vdisplay, DRM_SHADOW_PLANE_MAX_HEIGHT);
drm->mode_config.min_width = mode->hdisplay;
drm->mode_config.max_width = max_width;
drm->mode_config.min_height = mode->vdisplay;
drm->mode_config.max_height = max_height;
drm->mode_config.preferred_depth = 24;
drm->mode_config.funcs = &st7920_mode_config_funcs;
/* Primary plane */
primary_plane = &st7920->primary_plane;
ret = drm_universal_plane_init(drm, primary_plane, 0, &st7920_primary_plane_funcs,
st7920_formats, ARRAY_SIZE(st7920_formats),
NULL, DRM_PLANE_TYPE_PRIMARY, NULL);
if (ret) {
drm_err(drm, "DRM primary plane init failed: %d\n", ret);
return ret;
}
drm_plane_helper_add(primary_plane, &st7920_primary_plane_helper_funcs);
drm_plane_enable_fb_damage_clips(primary_plane);
/* CRTC */
crtc = &st7920->crtc;
ret = drm_crtc_init_with_planes(drm, crtc, primary_plane, NULL,
&st7920_crtc_funcs, NULL);
if (ret) {
drm_err(drm, "DRM crtc init failed: %d\n", ret);
return ret;
}
drm_crtc_helper_add(crtc, &st7920_crtc_helper_funcs);
/* Encoder */
encoder = &st7920->encoder;
ret = drm_encoder_init(drm, encoder, &st7920_encoder_funcs,
DRM_MODE_ENCODER_NONE, NULL);
if (ret) {
drm_err(drm, "DRM encoder init failed: %d\n", ret);
return ret;
}
encoder->possible_crtcs = drm_crtc_mask(crtc);
/* Connector */
connector = &st7920->connector;
ret = drm_connector_init(drm, connector, &st7920_connector_funcs,
DRM_MODE_CONNECTOR_Unknown);
if (ret) {
drm_err(drm, "DRM connector init failed: %d\n", ret);
return ret;
}
drm_connector_helper_add(connector, &st7920_connector_helper_funcs);
ret = drm_connector_attach_encoder(connector, encoder);
if (ret) {
drm_err(drm, "DRM attach connector to encoder failed: %d\n", ret);
return ret;
}
drm_mode_config_reset(drm);
return 0;
}
static int st7920_probe(struct spi_device *spi)
{
struct st7920_device *st7920;
struct regmap *regmap;
struct device *dev = &spi->dev;
struct drm_device *drm;
int ret;
regmap = devm_regmap_init_spi(spi, &st7920_spi_regmap_config);
if (IS_ERR(regmap))
return PTR_ERR(regmap);
st7920 = devm_drm_dev_alloc(dev, &st7920_drm_driver,
struct st7920_device, drm);
if (IS_ERR(st7920))
return PTR_ERR(st7920);
drm = &st7920->drm;
st7920->drm.dev = dev;
st7920->regmap = regmap;
st7920->spi = spi;
st7920->width = ST7920_DEFAULT_WIDTH;
st7920->height = ST7920_DEFAULT_HEIGHT;
st7920->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
if (IS_ERR(st7920->reset_gpio)) {
ret = PTR_ERR(st7920->reset_gpio);
return dev_err_probe(dev, ret, "Unable to retrieve reset GPIO\n");
}
spi_set_drvdata(spi, st7920);
ret = st7920_init_modeset(st7920);
if (ret)
return ret;
ret = drm_dev_register(drm, 0);
if (ret)
return dev_err_probe(dev, ret, "DRM device register failed\n");
drm_client_setup(drm, NULL);
return 0;
}
static void st7920_remove(struct spi_device *spi)
{
struct st7920_device *st7920 = spi_get_drvdata(spi);
drm_dev_unplug(&st7920->drm);
drm_atomic_helper_shutdown(&st7920->drm);
}
static void st7920_shutdown(struct spi_device *spi)
{
struct st7920_device *st7920 = spi_get_drvdata(spi);
drm_atomic_helper_shutdown(&st7920->drm);
}
static struct spi_driver st7920_spi_driver = {
.driver = {
.name = DRIVER_NAME,
.of_match_table = st7920_of_match,
},
.id_table = st7920_spi_id,
.probe = st7920_probe,
.remove = st7920_remove,
.shutdown = st7920_shutdown,
};
module_spi_driver(st7920_spi_driver);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Iker Pedrosa <ipedrosam@gmail.com>");
MODULE_LICENSE("GPL");