* [PATCH v2 1/4] console: replace set_active by open/close
2017-02-28 14:31 [PATCH v2 0/4] Prepare consoles, add fb flush and Solomon SSD1307 OLED controller support Bastian Stender
@ 2017-02-28 14:31 ` Bastian Stender
2017-02-28 14:31 ` [PATCH v2 2/4] console: expose consoles in devfs Bastian Stender
` (3 subsequent siblings)
4 siblings, 0 replies; 8+ messages in thread
From: Bastian Stender @ 2017-02-28 14:31 UTC (permalink / raw)
To: barebox; +Cc: Bastian Stender
Opening and closing consoles should be independent from setting them
active. This way it is possible to open e.g. a framebuffer console and
display text on it without showing stdout/stderr.
Signed-off-by: Bastian Stender <bst@pengutronix.de>
---
common/console.c | 46 ++++++++++++++++++++++++++++++++++++++++++++--
drivers/video/fbconsole.c | 28 ++++++++++++++++++----------
include/console.h | 7 ++++++-
net/netconsole.c | 27 +++++++++++++++++----------
4 files changed, 85 insertions(+), 23 deletions(-)
diff --git a/common/console.c b/common/console.c
index 74ccfcfc3e..eccbeed0ca 100644
--- a/common/console.c
+++ b/common/console.c
@@ -59,6 +59,39 @@ static struct kfifo __console_output_fifo;
static struct kfifo *console_input_fifo = &__console_input_fifo;
static struct kfifo *console_output_fifo = &__console_output_fifo;
+int console_open(struct console_device *cdev)
+{
+ int ret;
+
+ if (cdev->open && !cdev->open_count) {
+ ret = cdev->open(cdev);
+ if (ret)
+ return ret;
+ }
+
+ cdev->open_count++;
+
+ return 0;
+}
+
+int console_close(struct console_device *cdev)
+{
+ int ret;
+
+ if (!cdev->open_count)
+ return -EBADFD;
+
+ cdev->open_count--;
+
+ if (cdev->close && !cdev->open_count) {
+ ret = cdev->close(cdev);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
int console_set_active(struct console_device *cdev, unsigned flag)
{
int ret, i;
@@ -71,8 +104,15 @@ int console_set_active(struct console_device *cdev, unsigned flag)
if (!flag && cdev->f_active && cdev->flush)
cdev->flush(cdev);
- if (cdev->set_active) {
- ret = cdev->set_active(cdev, flag);
+ if (flag == cdev->f_active)
+ return 0;
+
+ if (!flag) {
+ ret = console_close(cdev);
+ if (ret)
+ return ret;
+ } else {
+ ret = console_open(cdev);
if (ret)
return ret;
}
@@ -264,6 +304,8 @@ int console_register(struct console_device *newcdev)
if (newcdev->putc && !newcdev->puts)
newcdev->puts = __console_puts;
+ newcdev->open_count = 0;
+
dev_add_param(dev, "active", console_active_set, console_active_get, 0);
if (IS_ENABLED(CONFIG_CONSOLE_ACTIVATE_FIRST)) {
diff --git a/drivers/video/fbconsole.c b/drivers/video/fbconsole.c
index 693c21f547..64f7d7364e 100644
--- a/drivers/video/fbconsole.c
+++ b/drivers/video/fbconsole.c
@@ -365,21 +365,13 @@ static int setup_font(struct fbc_priv *priv)
return 0;
}
-static int fbc_set_active(struct console_device *cdev, unsigned flags)
+static int fbc_open(struct console_device *cdev)
{
struct fbc_priv *priv = container_of(cdev,
struct fbc_priv, cdev);
struct fb_info *fb = priv->fb;
int ret;
- if (priv->active) {
- fb_close(priv->sc);
- priv->active = false;
- }
-
- if (!(flags & (CONSOLE_STDOUT | CONSOLE_STDERR)))
- return 0;
-
ret = setup_font(priv);
if (ret)
return ret;
@@ -400,6 +392,21 @@ static int fbc_set_active(struct console_device *cdev, unsigned flags)
return 0;
}
+static int fbc_close(struct console_device *cdev)
+{
+ struct fbc_priv *priv = container_of(cdev,
+ struct fbc_priv, cdev);
+
+ if (priv->active) {
+ fb_close(priv->sc);
+ priv->active = false;
+
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
static int set_font(struct param_d *p, void *vpriv)
{
struct fbc_priv *priv = vpriv;
@@ -434,7 +441,8 @@ int register_fbconsole(struct fb_info *fb)
cdev->getc = fbc_getc;
cdev->devname = "fbconsole";
cdev->devid = DEVICE_ID_DYNAMIC;
- cdev->set_active = fbc_set_active;
+ cdev->open = fbc_open;
+ cdev->close = fbc_close;
ret = console_register(cdev);
if (ret) {
diff --git a/include/console.h b/include/console.h
index 4b2f134a4c..a1ebc8581b 100644
--- a/include/console.h
+++ b/include/console.h
@@ -44,7 +44,8 @@ struct console_device {
int (*setbrg)(struct console_device *cdev, int baudrate);
void (*flush)(struct console_device *cdev);
int (*set_mode)(struct console_device *cdev, enum console_mode mode);
- int (*set_active)(struct console_device *cdev, unsigned active);
+ int (*open)(struct console_device *cdev);
+ int (*close)(struct console_device *cdev);
char *devname;
int devid;
@@ -54,6 +55,8 @@ struct console_device {
unsigned char f_active;
char active[4];
+ unsigned int open_count;
+
unsigned int baudrate;
unsigned int baudrate_param;
@@ -75,6 +78,8 @@ extern int barebox_loglevel;
struct console_device *console_get_first_active(void);
+int console_open(struct console_device *cdev);
+int console_close(struct console_device *cdev);
int console_set_active(struct console_device *cdev, unsigned active);
unsigned console_get_active(struct console_device *cdev);
int console_set_baudrate(struct console_device *cdev, unsigned baudrate);
diff --git a/net/netconsole.c b/net/netconsole.c
index ce3c418798..ef8b1856b6 100644
--- a/net/netconsole.c
+++ b/net/netconsole.c
@@ -105,19 +105,11 @@ static void nc_putc(struct console_device *cdev, char c)
priv->busy = 0;
}
-static int nc_set_active(struct console_device *cdev, unsigned flags)
+static int nc_open(struct console_device *cdev)
{
struct nc_priv *priv = container_of(cdev,
struct nc_priv, cdev);
- if (priv->con) {
- net_unregister(priv->con);
- priv->con = NULL;
- }
-
- if (!flags)
- return 0;
-
if (!priv->port) {
pr_err("port not set\n");
return -EINVAL;
@@ -142,6 +134,20 @@ static int nc_set_active(struct console_device *cdev, unsigned flags)
return 0;
}
+static int nc_close(struct console_device *cdev)
+{
+ struct nc_priv *priv = container_of(cdev,
+ struct nc_priv, cdev);
+
+ if (priv->con) {
+ net_unregister(priv->con);
+ priv->con = NULL;
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
static int netconsole_init(void)
{
struct nc_priv *priv;
@@ -155,7 +161,8 @@ static int netconsole_init(void)
cdev->getc = nc_getc;
cdev->devname = "netconsole";
cdev->devid = DEVICE_ID_SINGLE;
- cdev->set_active = nc_set_active;
+ cdev->open = nc_open;
+ cdev->close = nc_close;
g_priv = priv;
--
2.11.0
_______________________________________________
barebox mailing list
barebox@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/barebox
^ permalink raw reply [flat|nested] 8+ messages in thread* [PATCH v2 3/4] fb: introduce flush for virtual framebuffer
2017-02-28 14:31 [PATCH v2 0/4] Prepare consoles, add fb flush and Solomon SSD1307 OLED controller support Bastian Stender
2017-02-28 14:31 ` [PATCH v2 1/4] console: replace set_active by open/close Bastian Stender
2017-02-28 14:31 ` [PATCH v2 2/4] console: expose consoles in devfs Bastian Stender
@ 2017-02-28 14:31 ` Bastian Stender
2017-02-28 14:31 ` [PATCH v2 4/4] video: add support for Solomon SSD1307 OLED controller family Bastian Stender
2017-03-01 7:03 ` [PATCH v2 0/4] Prepare consoles, add fb flush and Solomon SSD1307 OLED controller support Sascha Hauer
4 siblings, 0 replies; 8+ messages in thread
From: Bastian Stender @ 2017-02-28 14:31 UTC (permalink / raw)
To: barebox; +Cc: Bastian Stender
Some drivers need an explicit sync method to flush the virtual
framebuffer to the display. It is called fb_flush().
fb_flush() gets called on fbc_putc, on fb_close and in the pattern cycle
in the fbtest command.
Signed-off-by: Bastian Stender <bst@pengutronix.de>
---
commands/fbtest.c | 1 +
drivers/video/fb.c | 26 ++++++++++++++++++++++++++
drivers/video/fbconsole.c | 3 +++
include/fb.h | 2 ++
4 files changed, 32 insertions(+)
diff --git a/commands/fbtest.c b/commands/fbtest.c
index bd0e140d07..ca6ec21991 100644
--- a/commands/fbtest.c
+++ b/commands/fbtest.c
@@ -169,6 +169,7 @@ static int do_fbtest(int argc, char *argv[])
pattern = patterns[i++ % ARRAY_SIZE(patterns)].func;
pattern(sc, color);
gu_screen_blit(sc);
+ fb_flush(sc->info);
start = get_time_ns();
while (!is_timeout(start, 2 * SECOND))
diff --git a/drivers/video/fb.c b/drivers/video/fb.c
index 4d2d3aa650..6b88f2df97 100644
--- a/drivers/video/fb.c
+++ b/drivers/video/fb.c
@@ -31,6 +31,30 @@ static int fb_ioctl(struct cdev* cdev, int req, void *data)
return 0;
}
+static int fb_close(struct cdev *cdev)
+{
+ struct fb_info *info = cdev->priv;
+
+ if (info->fbops->fb_flush)
+ info->fbops->fb_flush(info);
+ return 0;
+}
+
+static int fb_op_flush(struct cdev *cdev)
+{
+ struct fb_info *info = cdev->priv;
+
+ if (info->fbops->fb_flush)
+ info->fbops->fb_flush(info);
+ return 0;
+}
+
+void fb_flush(struct fb_info *info)
+{
+ if (info->fbops->fb_flush)
+ info->fbops->fb_flush(info);
+}
+
static void fb_release_shadowfb(struct fb_info *info)
{
free(info->screen_base_shadow);
@@ -199,6 +223,8 @@ static struct file_operations fb_ops = {
.memmap = generic_memmap_rw,
.lseek = dev_lseek_default,
.ioctl = fb_ioctl,
+ .close = fb_close,
+ .flush = fb_op_flush,
};
static void fb_print_mode(struct fb_videomode *mode)
diff --git a/drivers/video/fbconsole.c b/drivers/video/fbconsole.c
index 64f7d7364e..4cf8338ed8 100644
--- a/drivers/video/fbconsole.c
+++ b/drivers/video/fbconsole.c
@@ -292,6 +292,7 @@ static void fbc_putc(struct console_device *cdev, char c)
{
struct fbc_priv *priv = container_of(cdev,
struct fbc_priv, cdev);
+ struct fb_info *fb = priv->fb;
if (priv->in_console)
return;
@@ -345,6 +346,8 @@ static void fbc_putc(struct console_device *cdev, char c)
break;
}
priv->in_console = 0;
+
+ fb_flush(fb);
}
static int setup_font(struct fbc_priv *priv)
diff --git a/include/fb.h b/include/fb.h
index b2a9c7152b..271b939968 100644
--- a/include/fb.h
+++ b/include/fb.h
@@ -86,6 +86,7 @@ struct fb_ops {
void (*fb_enable)(struct fb_info *info);
void (*fb_disable)(struct fb_info *info);
int (*fb_activate_var)(struct fb_info *info);
+ void (*fb_flush)(struct fb_info *info);
};
/*
@@ -152,6 +153,7 @@ int register_framebuffer(struct fb_info *info);
int fb_enable(struct fb_info *info);
int fb_disable(struct fb_info *info);
+void fb_flush(struct fb_info *info);
#define FBIOGET_SCREENINFO _IOR('F', 1, loff_t)
#define FBIO_ENABLE _IO('F', 2)
--
2.11.0
_______________________________________________
barebox mailing list
barebox@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/barebox
^ permalink raw reply [flat|nested] 8+ messages in thread* [PATCH v2 4/4] video: add support for Solomon SSD1307 OLED controller family
2017-02-28 14:31 [PATCH v2 0/4] Prepare consoles, add fb flush and Solomon SSD1307 OLED controller support Bastian Stender
` (2 preceding siblings ...)
2017-02-28 14:31 ` [PATCH v2 3/4] fb: introduce flush for virtual framebuffer Bastian Stender
@ 2017-02-28 14:31 ` Bastian Stender
2017-03-03 9:06 ` [PATCH] fixup! " Uwe Kleine-König
2017-03-01 7:03 ` [PATCH v2 0/4] Prepare consoles, add fb flush and Solomon SSD1307 OLED controller support Sascha Hauer
4 siblings, 1 reply; 8+ messages in thread
From: Bastian Stender @ 2017-02-28 14:31 UTC (permalink / raw)
To: barebox; +Cc: Bastian Stender
It was ported from linux v4.10. Like the kernel driver only
communication via I2C is supported.
It has only been tested with a SSD1306 and a 96x16 OLED display:
&i2c0 {
status = "okay";
ssd1306: oled@3c {
compatible = "solomon,ssd1306fb-i2c";
reg = <0x3c>;
reset-gpios = <&gpio1 1 0>;
solomon,height = <16>;
solomon,width = <96>;
solomon,page-offset = <0>;
solomon,com-invdir;
solomon,com-seq;
};
Signed-off-by: Bastian Stender <bst@pengutronix.de>
---
drivers/video/Kconfig | 4 +
drivers/video/Makefile | 1 +
drivers/video/ssd1307fb.c | 566 ++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 571 insertions(+)
create mode 100644 drivers/video/ssd1307fb.c
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 8f31f5af74..39ed9bde9a 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -12,6 +12,10 @@ config FRAMEBUFFER_CONSOLE
select FONTS
prompt "framebuffer console support"
+config DRIVER_VIDEO_FB_SSD1307
+ bool "Solomon SSD1307 framebuffer support"
+ depends on I2C && GPIOLIB
+
config VIDEO_VPL
depends on OFTREE
bool
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 1bf2e1f3ca..e23c9c37b6 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -21,3 +21,4 @@ obj-$(CONFIG_DRIVER_VIDEO_OMAP) += omap.o
obj-$(CONFIG_DRIVER_VIDEO_BCM283X) += bcm2835.o
obj-$(CONFIG_DRIVER_VIDEO_SIMPLEFB) += simplefb.o
obj-$(CONFIG_DRIVER_VIDEO_IMX_IPUV3) += imx-ipu-v3/
+obj-$(CONFIG_DRIVER_VIDEO_FB_SSD1307) += ssd1307fb.o
diff --git a/drivers/video/ssd1307fb.c b/drivers/video/ssd1307fb.c
new file mode 100644
index 0000000000..ff4af2cdf4
--- /dev/null
+++ b/drivers/video/ssd1307fb.c
@@ -0,0 +1,566 @@
+/*
+ * Driver for the Solomon SSD1307 OLED controller family
+ *
+ * Supports:
+ * - SSD1305 (untested)
+ * - SSD1306
+ * - SSD1309 (untested)
+ *
+ * The SSD1307 controller is currently unsupported as the PWM parts were not
+ * ported.
+ *
+ * Copyright 2012 Maxime Ripard <maxime.ripard@free-electrons.com>, Free Electrons
+ *
+ * Ported to barebox from linux v4.10
+ * Copyright (C) 2017 Pengutronix, Bastian Stender <kernel@pengutronix.de>
+ *
+ * Licensed under the GPLv2 or later.
+ */
+
+#include <common.h>
+#include <init.h>
+#include <fb.h>
+#include <i2c/i2c.h>
+#include <of_device.h>
+#include <gpio.h>
+#include <of_gpio.h>
+
+#define SSD1307FB_DATA 0x40
+#define SSD1307FB_COMMAND 0x80
+
+#define SSD1307FB_SET_ADDRESS_MODE 0x20
+#define SSD1307FB_SET_ADDRESS_MODE_HORIZONTAL (0x00)
+#define SSD1307FB_SET_ADDRESS_MODE_VERTICAL (0x01)
+#define SSD1307FB_SET_ADDRESS_MODE_PAGE (0x02)
+#define SSD1307FB_SET_COL_RANGE 0x21
+#define SSD1307FB_SET_PAGE_RANGE 0x22
+#define SSD1307FB_CONTRAST 0x81
+#define SSD1307FB_CHARGE_PUMP 0x8d
+#define SSD1307FB_SEG_REMAP_ON 0xa1
+#define SSD1307FB_DISPLAY_OFF 0xae
+#define SSD1307FB_SET_MULTIPLEX_RATIO 0xa8
+#define SSD1307FB_DISPLAY_ON 0xaf
+#define SSD1307FB_START_PAGE_ADDRESS 0xb0
+#define SSD1307FB_SET_DISPLAY_OFFSET 0xd3
+#define SSD1307FB_SET_CLOCK_FREQ 0xd5
+#define SSD1307FB_SET_PRECHARGE_PERIOD 0xd9
+#define SSD1307FB_SET_COM_PINS_CONFIG 0xda
+#define SSD1307FB_SET_VCOMH 0xdb
+
+struct ssd1307fb_deviceinfo {
+ u32 default_vcomh;
+ u32 default_dclk_div;
+ u32 default_dclk_frq;
+ int need_chargepump;
+};
+
+struct ssd1307fb_par {
+ u32 com_invdir;
+ u32 com_lrremap;
+ u32 com_offset;
+ u32 com_seq;
+ u32 contrast;
+ u32 dclk_div;
+ u32 dclk_frq;
+ const struct ssd1307fb_deviceinfo *device_info;
+ struct i2c_client *client;
+ u32 height;
+ struct fb_info *info;
+ u32 page_offset;
+ u32 prechargep1;
+ u32 prechargep2;
+ int reset;
+ u32 seg_remap;
+ u32 vcomh;
+ u32 width;
+};
+
+struct ssd1307fb_array {
+ u8 type;
+ u8 data[0];
+};
+
+static struct ssd1307fb_array *ssd1307fb_alloc_array(u32 len, u8 type)
+{
+ struct ssd1307fb_array *array;
+
+ array = kzalloc(sizeof(struct ssd1307fb_array) + len, GFP_KERNEL);
+ if (!array)
+ return NULL;
+
+ array->type = type;
+
+ return array;
+}
+
+static int ssd1307fb_write_array(struct i2c_client *client,
+ struct ssd1307fb_array *array, u32 len)
+{
+ int ret;
+
+ len += sizeof(struct ssd1307fb_array);
+
+ ret = i2c_master_send(client, (u8 *)array, len);
+ if (ret != len) {
+ dev_err(&client->dev, "Couldn't send I2C command.\n");
+ return ret;
+ }
+
+ return 0;
+}
+
+static inline int ssd1307fb_write_cmd(struct i2c_client *client, u8 cmd)
+{
+ struct ssd1307fb_array *array;
+ int ret;
+
+ array = ssd1307fb_alloc_array(1, SSD1307FB_COMMAND);
+ if (!array)
+ return -ENOMEM;
+
+ array->data[0] = cmd;
+
+ ret = ssd1307fb_write_array(client, array, 1);
+ kfree(array);
+
+ return ret;
+}
+
+static void ssd1307fb_update_display(struct ssd1307fb_par *par)
+{
+ struct ssd1307fb_array *array;
+ u8 *vmem = par->info->screen_base;
+ int i, j, k;
+
+ array = ssd1307fb_alloc_array(par->width * par->height / 8,
+ SSD1307FB_DATA);
+ if (!array)
+ return;
+
+ /*
+ * The screen is divided in pages, each having a height of 8
+ * pixels, and the width of the screen. When sending a byte of
+ * data to the controller, it gives the 8 bits for the current
+ * column. I.e, the first byte are the 8 bits of the first
+ * column, then the 8 bits for the second column, etc.
+ *
+ *
+ * Representation of the screen, assuming it is 5 bits
+ * wide. Each letter-number combination is a bit that controls
+ * one pixel.
+ *
+ * A0 A1 A2 A3 A4
+ * B0 B1 B2 B3 B4
+ * C0 C1 C2 C3 C4
+ * D0 D1 D2 D3 D4
+ * E0 E1 E2 E3 E4
+ * F0 F1 F2 F3 F4
+ * G0 G1 G2 G3 G4
+ * H0 H1 H2 H3 H4
+ *
+ * If you want to update this screen, you need to send 5 bytes:
+ * (1) A0 B0 C0 D0 E0 F0 G0 H0
+ * (2) A1 B1 C1 D1 E1 F1 G1 H1
+ * (3) A2 B2 C2 D2 E2 F2 G2 H2
+ * (4) A3 B3 C3 D3 E3 F3 G3 H3
+ * (5) A4 B4 C4 D4 E4 F4 G4 H4
+ */
+
+ for (i = 0; i < (par->height / 8); i++) {
+ for (j = 0; j < par->width; j++) {
+ u32 array_idx = i * par->width + j;
+ array->data[array_idx] = 0;
+ for (k = 0; k < 8; k++) {
+ u32 page_length = par->width * i * 8;
+ u32 index = page_length + (par->width * k + j);
+ u8 byte = *(vmem + index);
+ /* convert to 1 bit per pixel */
+ u8 bit = byte > 0;
+ array->data[array_idx] |= bit << k;
+ }
+ }
+ }
+
+ ssd1307fb_write_array(par->client, array, par->width * par->height / 8);
+ kfree(array);
+}
+
+static void ssd1307fb_enable(struct fb_info *info)
+{
+ struct ssd1307fb_par *par = info->priv;
+ ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_ON);
+}
+
+static void ssd1307fb_disable(struct fb_info *info)
+{
+ struct ssd1307fb_par *par = info->priv;
+ ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_OFF);
+}
+
+static void ssd1307fb_flush(struct fb_info *info)
+{
+ struct ssd1307fb_par *par = info->priv;
+ ssd1307fb_update_display(par);
+}
+
+static struct fb_ops ssd1307fb_ops = {
+ .fb_enable = ssd1307fb_enable,
+ .fb_disable = ssd1307fb_disable,
+ .fb_flush = ssd1307fb_flush,
+};
+
+static int ssd1307fb_init(struct ssd1307fb_par *par)
+{
+ int ret;
+ u32 precharge, dclk, com_invdir, compins;
+
+ /* Set initial contrast */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CONTRAST);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, par->contrast);
+ if (ret < 0)
+ return ret;
+
+ /* Set segment re-map */
+ if (par->seg_remap) {
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SEG_REMAP_ON);
+ if (ret < 0)
+ return ret;
+ };
+
+ /* Set COM direction */
+ com_invdir = 0xc0 | (par->com_invdir & 0x1) << 3;
+ ret = ssd1307fb_write_cmd(par->client, com_invdir);
+ if (ret < 0)
+ return ret;
+
+ /* Set multiplex ratio value */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_MULTIPLEX_RATIO);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, par->height - 1);
+ if (ret < 0)
+ return ret;
+
+ /* set display offset value */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_DISPLAY_OFFSET);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, par->com_offset);
+ if (ret < 0)
+ return ret;
+
+ /* Set clock frequency */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_CLOCK_FREQ);
+ if (ret < 0)
+ return ret;
+
+ dclk = ((par->dclk_div - 1) & 0xf) | (par->dclk_frq & 0xf) << 4;
+ ret = ssd1307fb_write_cmd(par->client, dclk);
+ if (ret < 0)
+ return ret;
+
+ /* Set precharge period in number of ticks from the internal clock */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_PRECHARGE_PERIOD);
+ if (ret < 0)
+ return ret;
+
+ precharge = (par->prechargep1 & 0xf) | (par->prechargep2 & 0xf) << 4;
+ ret = ssd1307fb_write_cmd(par->client, precharge);
+ if (ret < 0)
+ return ret;
+
+ /* Set COM pins configuration */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_COM_PINS_CONFIG);
+ if (ret < 0)
+ return ret;
+
+ compins = 0x02 | !(par->com_seq & 0x1) << 4
+ | (par->com_lrremap & 0x1) << 5;
+ ret = ssd1307fb_write_cmd(par->client, compins);
+ if (ret < 0)
+ return ret;
+
+ /* Set VCOMH */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_VCOMH);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, par->vcomh);
+ if (ret < 0)
+ return ret;
+
+ /* Turn on the DC-DC Charge Pump */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_CHARGE_PUMP);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client,
+ BIT(4) | (par->device_info->need_chargepump ? BIT(2) : 0));
+ if (ret < 0)
+ return ret;
+
+ /* Switch to horizontal addressing mode */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_ADDRESS_MODE);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client,
+ SSD1307FB_SET_ADDRESS_MODE_HORIZONTAL);
+ if (ret < 0)
+ return ret;
+
+ /* Set column range */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_COL_RANGE);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, 0x0);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, par->width - 1);
+ if (ret < 0)
+ return ret;
+
+ /* Set page range */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_SET_PAGE_RANGE);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client, 0x0);
+ if (ret < 0)
+ return ret;
+
+ ret = ssd1307fb_write_cmd(par->client,
+ par->page_offset + (par->height / 8) - 1);
+ if (ret < 0)
+ return ret;
+
+ /* Turn on the display */
+ ret = ssd1307fb_write_cmd(par->client, SSD1307FB_DISPLAY_ON);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
+static struct ssd1307fb_deviceinfo ssd1307fb_ssd1305_deviceinfo = {
+ .default_vcomh = 0x34,
+ .default_dclk_div = 1,
+ .default_dclk_frq = 7,
+};
+
+static struct ssd1307fb_deviceinfo ssd1307fb_ssd1306_deviceinfo = {
+ .default_vcomh = 0x20,
+ .default_dclk_div = 1,
+ .default_dclk_frq = 8,
+ .need_chargepump = 1,
+};
+
+static struct ssd1307fb_deviceinfo ssd1307fb_ssd1309_deviceinfo = {
+ .default_vcomh = 0x34,
+ .default_dclk_div = 1,
+ .default_dclk_frq = 10,
+};
+
+static const struct of_device_id ssd1307fb_of_match[] = {
+ {
+ .compatible = "solomon,ssd1305fb-i2c",
+ .data = (void *)&ssd1307fb_ssd1305_deviceinfo,
+ },
+ {
+ .compatible = "solomon,ssd1306fb-i2c",
+ .data = (void *)&ssd1307fb_ssd1306_deviceinfo,
+ },
+ {
+ .compatible = "solomon,ssd1309fb-i2c",
+ .data = (void *)&ssd1307fb_ssd1309_deviceinfo,
+ },
+ {},
+};
+
+static int ssd1307fb_probe(struct device_d *dev)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct fb_info *info;
+ struct device_node *node = dev->device_node;
+ const struct of_device_id *match =
+ of_match_node(ssd1307fb_of_match, dev->device_node);
+ u32 vmem_size;
+ struct ssd1307fb_par *par;
+ struct ssd1307fb_array *array;
+ u8 *vmem;
+ int ret;
+ int i, j;
+
+ if (!node) {
+ dev_err(&client->dev, "No device tree data found!\n");
+ return -EINVAL;
+ }
+
+ info = xzalloc(sizeof(struct fb_info));
+
+ par = info->priv;
+ par->info = info;
+ par->client = client;
+
+ par->device_info = (struct ssd1307fb_deviceinfo *)match->data;
+
+ par->reset = of_get_named_gpio(node,
+ "reset-gpios", 0);
+ if (!gpio_is_valid(par->reset)) {
+ ret = par->reset;
+ dev_err(&client->dev,
+ "Couldn't get named gpio 'reset-gpios': %s.\n",
+ strerror(-ret));
+ goto fb_alloc_error;
+ }
+
+ ret = of_property_read_u32(node, "solomon,width", &par->width);
+ if (ret) {
+ dev_err(&client->dev,
+ "Couldn't find 'solomon,width' in device tree.\n");
+ goto panel_init_error;
+ }
+
+ ret = of_property_read_u32(node, "solomon,height", &par->height);
+ if (ret) {
+ dev_err(&client->dev,
+ "Couldn't find 'solomon,height' in device tree.\n");
+ goto panel_init_error;
+ }
+
+ ret = of_property_read_u32(node, "solomon,page-offset",
+ &par->page_offset);
+ if (ret) {
+ dev_err(&client->dev,
+ "Couldn't find 'solomon,page_offset' in device tree.\n");
+ goto panel_init_error;
+ }
+
+ if (of_property_read_u32(node, "solomon,com-offset", &par->com_offset))
+ par->com_offset = 0;
+
+ if (of_property_read_u32(node, "solomon,prechargep1",
+ &par->prechargep1))
+ par->prechargep1 = 2;
+
+ if (of_property_read_u32(node, "solomon,prechargep2",
+ &par->prechargep2))
+ par->prechargep2 = 2;
+
+ par->seg_remap = !of_property_read_bool(node,
+ "solomon,segment-no-remap");
+ par->com_seq = of_property_read_bool(node, "solomon,com-seq");
+ par->com_lrremap = of_property_read_bool(node, "solomon,com-lrremap");
+ par->com_invdir = of_property_read_bool(node, "solomon,com-invdir");
+
+ par->contrast = 127;
+ par->vcomh = par->device_info->default_vcomh;
+
+ /* Setup display timing */
+ par->dclk_div = par->device_info->default_dclk_div;
+ par->dclk_frq = par->device_info->default_dclk_frq;
+
+ vmem_size = par->width * par->height;
+
+ vmem = malloc(vmem_size);
+ if (!vmem) {
+ dev_err(&client->dev, "Couldn't allocate graphical memory.\n");
+ ret = -ENOMEM;
+ goto fb_alloc_error;
+ }
+
+ info->fbops = &ssd1307fb_ops;
+ info->line_length = par->width;
+
+ info->xres = par->width;
+ info->yres = par->height;
+
+ /* emulate 8 bit per pixel */
+ info->bits_per_pixel = 8;
+
+ info->red.length = 3;
+ info->red.offset = 0;
+ info->green.length = 3;
+ info->green.offset = 0;
+ info->blue.length = 2;
+ info->blue.offset = 0;
+
+ info->screen_base = (u8 __force __iomem *)vmem;
+
+ ret = gpio_request_one(par->reset,
+ GPIOF_OUT_INIT_HIGH,
+ "oled-reset");
+ if (ret) {
+ dev_err(&client->dev,
+ "failed to request gpio %d: %d\n",
+ par->reset, ret);
+ goto reset_oled_error;
+ }
+
+ i2c_set_clientdata(client, info);
+
+ /* Reset the screen */
+ gpio_set_value(par->reset, 0);
+ udelay(4);
+ gpio_set_value(par->reset, 1);
+ udelay(4);
+
+ ret = ssd1307fb_init(par);
+ if (ret)
+ goto reset_oled_error;
+
+ ret = register_framebuffer(info);
+ if (ret) {
+ dev_err(&client->dev, "Couldn't register the framebuffer\n");
+ goto panel_init_error;
+ }
+
+ /* clear display */
+ array = ssd1307fb_alloc_array(par->width * par->height / 8,
+ SSD1307FB_DATA);
+ if (!array)
+ return -ENOMEM;
+
+ for (i = 0; i < (par->height / 8); i++) {
+ for (j = 0; j < par->width; j++) {
+ u32 array_idx = i * par->width + j;
+ array->data[array_idx] = 0;
+ }
+ }
+
+ ssd1307fb_write_array(par->client, array, par->width * par->height / 8);
+ kfree(array);
+
+ dev_info(&client->dev,
+ "ssd1307 framebuffer device registered, using %d bytes of video memory\n",
+ vmem_size);
+
+ return 0;
+
+panel_init_error:
+reset_oled_error:
+fb_alloc_error:
+ free(info);
+ return ret;
+}
+
+static struct driver_d ssd1307fb_driver = {
+ .name = "ssd1307fb",
+ .probe = ssd1307fb_probe,
+ .of_compatible = DRV_OF_COMPAT(ssd1307fb_of_match),
+};
+
+static int ssd1307_init(void)
+{
+ i2c_driver_register(&ssd1307fb_driver);
+ return 0;
+}
+
+device_initcall(ssd1307_init);
--
2.11.0
_______________________________________________
barebox mailing list
barebox@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/barebox
^ permalink raw reply [flat|nested] 8+ messages in thread