michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: display: ssd16xx: use gpio_dt_spec

Browse source 
Simplify driver implementation by using gpio_dt_spec. To simplify
migration, all internal functions now take a device reference instead of
device data. As a result, the redundant config pointer in data has been
removed.

Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
This commit is contained in:
Gerard Marull-Paretas 2022-01-31 13:10:33 +01:00 • committed by Anas Nashif
commit db00924764
1 changed files with 81 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

183
drivers/display/ssd16xx.c
View file

@ -25,16 +25,6 @@ LOG_MODULE_REGISTER(ssd16xx);
* SSD1673, SSD1608, SSD1681, ILI3897 compatible EPD controller driver. * SSD1673, SSD1608, SSD1681, ILI3897 compatible EPD controller driver.
*/ */
#define SSD16XX_DC_PIN DT_INST_GPIO_PIN(0, dc_gpios)
#define SSD16XX_DC_FLAGS DT_INST_GPIO_FLAGS(0, dc_gpios)
#define SSD16XX_DC_CNTRL DT_INST_GPIO_LABEL(0, dc_gpios)
#define SSD16XX_BUSY_PIN DT_INST_GPIO_PIN(0, busy_gpios)
#define SSD16XX_BUSY_CNTRL DT_INST_GPIO_LABEL(0, busy_gpios)
#define SSD16XX_BUSY_FLAGS DT_INST_GPIO_FLAGS(0, busy_gpios)
#define SSD16XX_RESET_PIN DT_INST_GPIO_PIN(0, reset_gpios)
#define SSD16XX_RESET_CNTRL DT_INST_GPIO_LABEL(0, reset_gpios)
#define SSD16XX_RESET_FLAGS DT_INST_GPIO_FLAGS(0, reset_gpios)
#define EPD_PANEL_WIDTH DT_INST_PROP(0, width) #define EPD_PANEL_WIDTH DT_INST_PROP(0, width)
#define EPD_PANEL_HEIGHT DT_INST_PROP(0, height) #define EPD_PANEL_HEIGHT DT_INST_PROP(0, height)
#define EPD_PANEL_NUMOF_COLUMS EPD_PANEL_WIDTH #define EPD_PANEL_NUMOF_COLUMS EPD_PANEL_WIDTH
@ -52,16 +42,15 @@ LOG_MODULE_REGISTER(ssd16xx);
#define SSD16XX_TR_SCALE_FACTOR 256U #define SSD16XX_TR_SCALE_FACTOR 256U
struct ssd16xx_data { struct ssd16xx_data {
const struct device *reset;
const struct device *dc;
const struct device *busy;
const struct ssd16xx_config *config;
uint8_t scan_mode; uint8_t scan_mode;
uint8_t update_cmd; uint8_t update_cmd;
}; };
struct ssd16xx_config { struct ssd16xx_config {
struct spi_dt_spec bus; struct spi_dt_spec bus;
struct gpio_dt_spec dc_gpio;
struct gpio_dt_spec busy_gpio;
struct gpio_dt_spec reset_gpio;
}; };
#if DT_INST_NODE_HAS_PROP(0, lut_initial) #if DT_INST_NODE_HAS_PROP(0, lut_initial)
@ -76,15 +65,16 @@ static uint8_t ssd16xx_softstart[] = DT_INST_PROP(0, softstart);
static uint8_t ssd16xx_gdv[] = DT_INST_PROP(0, gdv); static uint8_t ssd16xx_gdv[] = DT_INST_PROP(0, gdv);
static uint8_t ssd16xx_sdv[] = DT_INST_PROP(0, sdv); static uint8_t ssd16xx_sdv[] = DT_INST_PROP(0, sdv);
static inline int ssd16xx_write_cmd(struct ssd16xx_data *driver, static inline int ssd16xx_write_cmd(const struct device *dev, uint8_t cmd,
uint8_t cmd, uint8_t *data, size_t len) uint8_t *data, size_t len)
{ {
const struct ssd16xx_config *config = dev->config;
int err; int err;
struct spi_buf buf = {.buf = &cmd, .len = sizeof(cmd)}; struct spi_buf buf = {.buf = &cmd, .len = sizeof(cmd)};
struct spi_buf_set buf_set = {.buffers = &buf, .count = 1}; struct spi_buf_set buf_set = {.buffers = &buf, .count = 1};
gpio_pin_set(driver->dc, SSD16XX_DC_PIN, 1); gpio_pin_set_dt(&config->dc_gpio, 1);
err = spi_write_dt(&driver->config->bus, &buf_set); err = spi_write_dt(&config->bus, &buf_set);
if (err < 0) { if (err < 0) {
return err; return err;
} }
@ -92,8 +82,8 @@ static inline int ssd16xx_write_cmd(struct ssd16xx_data *driver,
if (data != NULL) { if (data != NULL) {
buf.buf = data; buf.buf = data;
buf.len = len; buf.len = len;
gpio_pin_set(driver->dc, SSD16XX_DC_PIN, 0); gpio_pin_set_dt(&config->dc_gpio, 0);
err = spi_write_dt(&driver->config->bus, &buf_set); err = spi_write_dt(&config->bus, &buf_set);
if (err < 0) { if (err < 0) {
return err; return err;
} }
@ -102,14 +92,15 @@ static inline int ssd16xx_write_cmd(struct ssd16xx_data *driver,
return 0; return 0;
} }
static inline void ssd16xx_busy_wait(struct ssd16xx_data *driver) static inline void ssd16xx_busy_wait(const struct device *dev)
{ {
int pin = gpio_pin_get(driver->busy, SSD16XX_BUSY_PIN); const struct ssd16xx_config *config = dev->config;
int pin = gpio_pin_get_dt(&config->busy_gpio);
while (pin > 0) { while (pin > 0) {
__ASSERT(pin >= 0, "Failed to get pin level"); __ASSERT(pin >= 0, "Failed to get pin level");
k_msleep(SSD16XX_BUSY_DELAY); k_msleep(SSD16XX_BUSY_DELAY);
pin = gpio_pin_get(driver->busy, SSD16XX_BUSY_PIN); pin = gpio_pin_get_dt(&config->busy_gpio);
} }
} }
@ -140,7 +131,7 @@ static inline size_t push_y_param(uint8_t *data, uint16_t y)
} }
static inline int ssd16xx_set_ram_param(struct ssd16xx_data *driver, static inline int ssd16xx_set_ram_param(const struct device *dev,
uint16_t sx, uint16_t ex, uint16_t sy, uint16_t ey) uint16_t sx, uint16_t ex, uint16_t sy, uint16_t ey)
{ {
int err; int err;
@ -149,14 +140,14 @@ static inline int ssd16xx_set_ram_param(struct ssd16xx_data *driver,
len = push_x_param(tmp, sx); len = push_x_param(tmp, sx);
len += push_x_param(tmp + len, ex); len += push_x_param(tmp + len, ex);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_RAM_XPOS_CTRL, tmp, len); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_RAM_XPOS_CTRL, tmp, len);
if (err < 0) { if (err < 0) {
return err; return err;
} }
len = push_y_param(tmp, sy); len = push_y_param(tmp, sy);
len += push_y_param(tmp + len, ey); len += push_y_param(tmp + len, ey);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_RAM_YPOS_CTRL, tmp, len); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_RAM_YPOS_CTRL, tmp, len);
if (err < 0) { if (err < 0) {
return err; return err;
} }
@ -164,21 +155,21 @@ static inline int ssd16xx_set_ram_param(struct ssd16xx_data *driver,
return 0; return 0;
} }
static inline int ssd16xx_set_ram_ptr(struct ssd16xx_data *driver, static inline int ssd16xx_set_ram_ptr(const struct device *dev, uint16_t x,
uint16_t x, uint16_t y) uint16_t y)
{ {
int err; int err;
uint8_t tmp[2]; uint8_t tmp[2];
size_t len; size_t len;
len = push_x_param(tmp, x); len = push_x_param(tmp, x);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_RAM_XPOS_CNTR, tmp, len); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_RAM_XPOS_CNTR, tmp, len);
if (err < 0) { if (err < 0) {
return err; return err;
} }
len = push_y_param(tmp, y); len = push_y_param(tmp, y);
return ssd16xx_write_cmd(driver, SSD16XX_CMD_RAM_YPOS_CNTR, tmp, len); return ssd16xx_write_cmd(dev, SSD16XX_CMD_RAM_YPOS_CNTR, tmp, len);
} }
static void ssd16xx_set_orientation_internall(struct ssd16xx_data *driver) static void ssd16xx_set_orientation_internall(struct ssd16xx_data *driver)
@ -206,14 +197,13 @@ static int ssd16xx_update_display(const struct device *dev)
struct ssd16xx_data *driver = dev->data; struct ssd16xx_data *driver = dev->data;
int err; int err;
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_UPDATE_CTRL2, err = ssd16xx_write_cmd(dev, SSD16XX_CMD_UPDATE_CTRL2,
&driver->update_cmd, 1); &driver->update_cmd, 1);
if (err < 0) { if (err < 0) {
return err; return err;
} }
return ssd16xx_write_cmd(driver, SSD16XX_CMD_MASTER_ACTIVATION, return ssd16xx_write_cmd(dev, SSD16XX_CMD_MASTER_ACTIVATION, NULL, 0);
NULL, 0);
} }
static int ssd16xx_write(const struct device *dev, const uint16_t x, static int ssd16xx_write(const struct device *dev, const uint16_t x,
@ -288,25 +278,25 @@ static int ssd16xx_write(const struct device *dev, const uint16_t x,
return -EINVAL; return -EINVAL;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_ENTRY_MODE, err = ssd16xx_write_cmd(dev, SSD16XX_CMD_ENTRY_MODE,
&driver->scan_mode, sizeof(driver->scan_mode)); &driver->scan_mode, sizeof(driver->scan_mode));
if (err < 0) { if (err < 0) {
return err; return err;
} }
err = ssd16xx_set_ram_param(driver, x_start, x_end, y_start, y_end); err = ssd16xx_set_ram_param(dev, x_start, x_end, y_start, y_end);
if (err < 0) { if (err < 0) {
return err; return err;
} }
err = ssd16xx_set_ram_ptr(driver, x_start, y_start); err = ssd16xx_set_ram_ptr(dev, x_start, y_start);
if (err < 0) { if (err < 0) {
return err; return err;
} }
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_WRITE_RAM, (uint8_t *)buf, err = ssd16xx_write_cmd(dev, SSD16XX_CMD_WRITE_RAM, (uint8_t *)buf,
buf_len); buf_len);
if (err < 0) { if (err < 0) {
return err; return err;
@ -380,7 +370,6 @@ static int ssd16xx_set_pixel_format(const struct device *dev,
static int ssd16xx_clear_cntlr_mem(const struct device *dev, uint8_t ram_cmd, static int ssd16xx_clear_cntlr_mem(const struct device *dev, uint8_t ram_cmd,
bool update) bool update)
{ {
struct ssd16xx_data *driver = dev->data;
uint8_t clear_page[EPD_PANEL_WIDTH]; uint8_t clear_page[EPD_PANEL_WIDTH];
uint16_t panel_h = EPD_PANEL_HEIGHT / uint16_t panel_h = EPD_PANEL_HEIGHT /
EPD_PANEL_NUMOF_ROWS_PER_PAGE; EPD_PANEL_NUMOF_ROWS_PER_PAGE;
@ -394,18 +383,18 @@ static int ssd16xx_clear_cntlr_mem(const struct device *dev, uint8_t ram_cmd,
panel_h += 1; panel_h += 1;
} }
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_ENTRY_MODE, &scan_mode, 1)) { if (ssd16xx_write_cmd(dev, SSD16XX_CMD_ENTRY_MODE, &scan_mode, 1)) {
return -EIO; return -EIO;
} }
if (ssd16xx_set_ram_param(driver, SSD16XX_PANEL_FIRST_PAGE, if (ssd16xx_set_ram_param(dev, SSD16XX_PANEL_FIRST_PAGE,
panel_h - 1, panel_h - 1,
SSD16XX_PANEL_LAST_GATE, SSD16XX_PANEL_LAST_GATE,
SSD16XX_PANEL_FIRST_GATE)) { SSD16XX_PANEL_FIRST_GATE)) {
return -EIO; return -EIO;
} }
if (ssd16xx_set_ram_ptr(driver, SSD16XX_PANEL_FIRST_PAGE, if (ssd16xx_set_ram_ptr(dev, SSD16XX_PANEL_FIRST_PAGE,
SSD16XX_PANEL_LAST_GATE)) { SSD16XX_PANEL_LAST_GATE)) {
return -EIO; return -EIO;
} }
@ -413,7 +402,7 @@ static int ssd16xx_clear_cntlr_mem(const struct device *dev, uint8_t ram_cmd,
memset(clear_page, 0xff, sizeof(clear_page)); memset(clear_page, 0xff, sizeof(clear_page));
for (int i = 0; i < panel_h; i++) { for (int i = 0; i < panel_h; i++) {
if (ssd16xx_write_cmd(driver, ram_cmd, clear_page, if (ssd16xx_write_cmd(dev, ram_cmd, clear_page,
sizeof(clear_page))) { sizeof(clear_page))) {
return -EIO; return -EIO;
} }
@ -439,7 +428,7 @@ static inline int ssd16xx_load_ws_from_otp(const struct device *dev)
LOG_INF("Select and load WS from OTP"); LOG_INF("Select and load WS from OTP");
tmp[0] = DT_INST_PROP(0, tssv); tmp[0] = DT_INST_PROP(0, tssv);
if (ssd16xx_write_cmd(driver, if (ssd16xx_write_cmd(dev,
SSD16XX_CMD_TSENSOR_SELECTION, SSD16XX_CMD_TSENSOR_SELECTION,
tmp, 1)) { tmp, 1)) {
return -EIO; return -EIO;
@ -455,37 +444,37 @@ static inline int ssd16xx_load_ws_from_otp(const struct device *dev)
LOG_INF("Load default WS (25 degrees Celsius) from OTP"); LOG_INF("Load default WS (25 degrees Celsius) from OTP");
tmp[0] = SSD16XX_CTRL2_ENABLE_CLK; tmp[0] = SSD16XX_CTRL2_ENABLE_CLK;
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_UPDATE_CTRL2, if (ssd16xx_write_cmd(dev, SSD16XX_CMD_UPDATE_CTRL2,
tmp, 1)) { tmp, 1)) {
return -EIO; return -EIO;
} }
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_MASTER_ACTIVATION, if (ssd16xx_write_cmd(dev, SSD16XX_CMD_MASTER_ACTIVATION,
NULL, 0)) { NULL, 0)) {
return -EIO; return -EIO;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
/* Load temperature value */ /* Load temperature value */
sys_put_be16(t, tmp); sys_put_be16(t, tmp);
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_TSENS_CTRL, if (ssd16xx_write_cmd(dev, SSD16XX_CMD_TSENS_CTRL,
tmp, 2)) { tmp, 2)) {
return -EIO; return -EIO;
} }
tmp[0] = SSD16XX_CTRL2_DISABLE_CLK; tmp[0] = SSD16XX_CTRL2_DISABLE_CLK;
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_UPDATE_CTRL2, if (ssd16xx_write_cmd(dev, SSD16XX_CMD_UPDATE_CTRL2,
tmp, 1)) { tmp, 1)) {
return -EIO; return -EIO;
} }
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_MASTER_ACTIVATION, if (ssd16xx_write_cmd(dev, SSD16XX_CMD_MASTER_ACTIVATION,
NULL, 0)) { NULL, 0)) {
return -EIO; return -EIO;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
driver->update_cmd |= SSD16XX_CTRL2_LOAD_LUT; driver->update_cmd |= SSD16XX_CTRL2_LOAD_LUT;
@ -496,15 +485,13 @@ static inline int ssd16xx_load_ws_from_otp(const struct device *dev)
static int ssd16xx_load_ws_initial(const struct device *dev) static int ssd16xx_load_ws_initial(const struct device *dev)
{ {
#if DT_INST_NODE_HAS_PROP(0, lut_initial) #if DT_INST_NODE_HAS_PROP(0, lut_initial)
struct ssd16xx_data *driver = dev->data; if (ssd16xx_write_cmd(dev, SSD16XX_CMD_UPDATE_LUT,
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_UPDATE_LUT,
ssd16xx_lut_initial, ssd16xx_lut_initial,
sizeof(ssd16xx_lut_initial))) { sizeof(ssd16xx_lut_initial))) {
return -EIO; return -EIO;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
#else #else
ssd16xx_load_ws_from_otp(dev); ssd16xx_load_ws_from_otp(dev);
#endif #endif
@ -515,15 +502,13 @@ static int ssd16xx_load_ws_initial(const struct device *dev)
static int ssd16xx_load_ws_default(const struct device *dev) static int ssd16xx_load_ws_default(const struct device *dev)
{ {
#if DT_INST_NODE_HAS_PROP(0, lut_default) #if DT_INST_NODE_HAS_PROP(0, lut_default)
struct ssd16xx_data *driver = dev->data; if (ssd16xx_write_cmd(dev, SSD16XX_CMD_UPDATE_LUT,
if (ssd16xx_write_cmd(driver, SSD16XX_CMD_UPDATE_LUT,
ssd16xx_lut_default, ssd16xx_lut_default,
sizeof(ssd16xx_lut_default))) { sizeof(ssd16xx_lut_default))) {
return -EIO; return -EIO;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
#endif #endif
return 0; return 0;
@ -531,6 +516,7 @@ static int ssd16xx_load_ws_default(const struct device *dev)
static int ssd16xx_controller_init(const struct device *dev) static int ssd16xx_controller_init(const struct device *dev)
{ {
const struct ssd16xx_config *config = dev->config;
int err; int err;
uint8_t tmp[3]; uint8_t tmp[3];
size_t len; size_t len;
@ -538,65 +524,65 @@ static int ssd16xx_controller_init(const struct device *dev)
LOG_DBG(""); LOG_DBG("");
gpio_pin_set(driver->reset, SSD16XX_RESET_PIN, 1); gpio_pin_set_dt(&config->reset_gpio, 1);
k_msleep(SSD16XX_RESET_DELAY); k_msleep(SSD16XX_RESET_DELAY);
gpio_pin_set(driver->reset, SSD16XX_RESET_PIN, 0); gpio_pin_set_dt(&config->reset_gpio, 0);
k_msleep(SSD16XX_RESET_DELAY); k_msleep(SSD16XX_RESET_DELAY);
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_SW_RESET, NULL, 0); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_SW_RESET, NULL, 0);
if (err < 0) { if (err < 0) {
return err; return err;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
len = push_y_param(tmp, SSD16XX_PANEL_LAST_GATE); len = push_y_param(tmp, SSD16XX_PANEL_LAST_GATE);
tmp[len++] = 0U; tmp[len++] = 0U;
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_GDO_CTRL, tmp, len); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_GDO_CTRL, tmp, len);
if (err < 0) { if (err < 0) {
return err; return err;
} }
#if DT_INST_NODE_HAS_PROP(0, softstart) #if DT_INST_NODE_HAS_PROP(0, softstart)
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_SOFTSTART, err = ssd16xx_write_cmd(dev, SSD16XX_CMD_SOFTSTART,
ssd16xx_softstart, sizeof(ssd16xx_softstart)); ssd16xx_softstart, sizeof(ssd16xx_softstart));
if (err < 0) { if (err < 0) {
return err; return err;
} }
#endif #endif
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_GDV_CTRL, ssd16xx_gdv, err = ssd16xx_write_cmd(dev, SSD16XX_CMD_GDV_CTRL, ssd16xx_gdv,
sizeof(ssd16xx_gdv)); sizeof(ssd16xx_gdv));
if (err < 0) { if (err < 0) {
return err; return err;
} }
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_SDV_CTRL, ssd16xx_sdv, err = ssd16xx_write_cmd(dev, SSD16XX_CMD_SDV_CTRL, ssd16xx_sdv,
sizeof(ssd16xx_sdv)); sizeof(ssd16xx_sdv));
if (err < 0) { if (err < 0) {
return err; return err;
} }
tmp[0] = DT_INST_PROP(0, vcom); tmp[0] = DT_INST_PROP(0, vcom);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_VCOM_VOLTAGE, tmp, 1); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_VCOM_VOLTAGE, tmp, 1);
if (err < 0) { if (err < 0) {
return err; return err;
} }
tmp[0] = SSD16XX_VAL_DUMMY_LINE; tmp[0] = SSD16XX_VAL_DUMMY_LINE;
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_DUMMY_LINE, tmp, 1); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_DUMMY_LINE, tmp, 1);
if (err < 0) { if (err < 0) {
return err; return err;
} }
tmp[0] = SSD16XX_VAL_GATE_LWIDTH; tmp[0] = SSD16XX_VAL_GATE_LWIDTH;
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_GATE_LINE_WIDTH, tmp, 1); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_GATE_LINE_WIDTH, tmp, 1);
if (err < 0) { if (err < 0) {
return err; return err;
} }
tmp[0] = DT_INST_PROP(0, border_waveform); tmp[0] = DT_INST_PROP(0, border_waveform);
err = ssd16xx_write_cmd(driver, SSD16XX_CMD_BWF_CTRL, tmp, 1); err = ssd16xx_write_cmd(dev, SSD16XX_CMD_BWF_CTRL, tmp, 1);
if (err < 0) { if (err < 0) {
return err; return err;
} }
@ -617,7 +603,7 @@ static int ssd16xx_controller_init(const struct device *dev)
return err; return err;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
err = ssd16xx_clear_cntlr_mem(dev, SSD16XX_CMD_WRITE_RED_RAM, err = ssd16xx_clear_cntlr_mem(dev, SSD16XX_CMD_WRITE_RED_RAM,
false); false);
@ -625,7 +611,7 @@ static int ssd16xx_controller_init(const struct device *dev)
return err; return err;
} }
ssd16xx_busy_wait(driver); ssd16xx_busy_wait(dev);
if (ssd16xx_load_ws_default(dev)) { if (ssd16xx_load_ws_default(dev)) {
return -EIO; return -EIO;
@ -636,8 +622,7 @@ static int ssd16xx_controller_init(const struct device *dev)
static int ssd16xx_init(const struct device *dev) static int ssd16xx_init(const struct device *dev)
{ {
struct ssd16xx_data *driver = dev->data; const struct ssd16xx_config *config = dev->config;
const struct ssd16xx_config *config = driver->config;
LOG_DBG(""); LOG_DBG("");
@ -646,44 +631,39 @@ static int ssd16xx_init(const struct device *dev)
return -ENODEV; return -ENODEV;
} }
driver->reset = device_get_binding(SSD16XX_RESET_CNTRL); if (!device_is_ready(config->reset_gpio.port)) {
if (driver->reset == NULL) { LOG_ERR("Reset GPIO device not ready");
LOG_ERR("Could not get GPIO port for SSD16XX reset"); return -ENODEV;
return -EIO;
} }
gpio_pin_configure(driver->reset, SSD16XX_RESET_PIN, gpio_pin_configure_dt(&config->reset_gpio, GPIO_OUTPUT_INACTIVE);
GPIO_OUTPUT_INACTIVE | SSD16XX_RESET_FLAGS);
driver->dc = device_get_binding(SSD16XX_DC_CNTRL); if (!device_is_ready(config->dc_gpio.port)) {
if (driver->dc == NULL) { LOG_ERR("DC GPIO device not ready");
LOG_ERR("Could not get GPIO port for SSD16XX DC signal"); return -ENODEV;
return -EIO;
} }
gpio_pin_configure(driver->dc, SSD16XX_DC_PIN, gpio_pin_configure_dt(&config->dc_gpio, GPIO_OUTPUT_INACTIVE);
GPIO_OUTPUT_INACTIVE | SSD16XX_DC_FLAGS);
driver->busy = device_get_binding(SSD16XX_BUSY_CNTRL); if (!device_is_ready(config->busy_gpio.port)) {
if (driver->busy == NULL) { LOG_ERR("Busy GPIO device not ready");
LOG_ERR("Could not get GPIO port for SSD16XX busy signal"); return -ENODEV;
return -EIO;
} }
gpio_pin_configure(driver->busy, SSD16XX_BUSY_PIN, gpio_pin_configure_dt(&config->busy_gpio, GPIO_INPUT);
GPIO_INPUT | SSD16XX_BUSY_FLAGS);
return ssd16xx_controller_init(dev); return ssd16xx_controller_init(dev);
} }
static const struct ssd16xx_config ssd16xx_config = { static const struct ssd16xx_config ssd16xx_config = {
.bus = SPI_DT_SPEC_INST_GET( .bus = SPI_DT_SPEC_INST_GET(
0, SPI_OP_MODE_MASTER | SPI_WORD_SET(8), 0) 0, SPI_OP_MODE_MASTER | SPI_WORD_SET(8), 0),
.reset_gpio = GPIO_DT_SPEC_INST_GET(0, reset_gpios),
.dc_gpio = GPIO_DT_SPEC_INST_GET(0, dc_gpios),
.busy_gpio = GPIO_DT_SPEC_INST_GET(0, busy_gpios),
}; };
static struct ssd16xx_data ssd16xx_driver = { static struct ssd16xx_data ssd16xx_driver;
.config = &ssd16xx_config
};
static struct display_driver_api ssd16xx_driver_api = { static struct display_driver_api ssd16xx_driver_api = {
.blanking_on = ssd16xx_blanking_on, .blanking_on = ssd16xx_blanking_on,
@ -699,7 +679,6 @@ static struct display_driver_api ssd16xx_driver_api = {
}; };
DEVICE_DT_INST_DEFINE(0, ssd16xx_init, NULL, DEVICE_DT_INST_DEFINE(0, ssd16xx_init, NULL, &ssd16xx_driver, &ssd16xx_config,
&ssd16xx_driver, NULL, POST_KERNEL, CONFIG_DISPLAY_INIT_PRIORITY,
POST_KERNEL, CONFIG_DISPLAY_INIT_PRIORITY, &ssd16xx_driver_api);
&ssd16xx_driver_api);