Add support for displays that can be operated using a simple vtable. Geared towards controllers that can represent it's registers using regmap.
Signed-off-by: Noralf Trønnes noralf@tronnes.org --- Documentation/gpu/tinydrm.rst | 12 + drivers/gpu/drm/tinydrm/Kconfig | 1 + drivers/gpu/drm/tinydrm/core/Makefile | 2 +- drivers/gpu/drm/tinydrm/core/tinydrm-panel.c | 532 +++++++++++++++++++++++++++ include/drm/tinydrm/tinydrm-panel.h | 153 ++++++++ 5 files changed, 699 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-panel.c create mode 100644 include/drm/tinydrm/tinydrm-panel.h
diff --git a/Documentation/gpu/tinydrm.rst b/Documentation/gpu/tinydrm.rst index a913644..bb78433 100644 --- a/Documentation/gpu/tinydrm.rst +++ b/Documentation/gpu/tinydrm.rst @@ -20,6 +20,18 @@ Core functionality .. kernel-doc:: drivers/gpu/drm/tinydrm/core/tinydrm-pipe.c :export:
+Panel +===== + +.. kernel-doc:: drivers/gpu/drm/tinydrm/core/tinydrm-panel.c + :doc: overview + +.. kernel-doc:: include/drm/tinydrm/tinydrm-panel.h + :internal: + +.. kernel-doc:: drivers/gpu/drm/tinydrm/core/tinydrm-panel.c + :export: + Additional helpers ==================
diff --git a/drivers/gpu/drm/tinydrm/Kconfig b/drivers/gpu/drm/tinydrm/Kconfig index 3504c53..4ea0fbc 100644 --- a/drivers/gpu/drm/tinydrm/Kconfig +++ b/drivers/gpu/drm/tinydrm/Kconfig @@ -1,6 +1,7 @@ menuconfig DRM_TINYDRM tristate "Support for simple displays" depends on DRM + select REGMAP select DRM_KMS_HELPER select DRM_KMS_CMA_HELPER select BACKLIGHT_LCD_SUPPORT diff --git a/drivers/gpu/drm/tinydrm/core/Makefile b/drivers/gpu/drm/tinydrm/core/Makefile index fb221e6..213b479 100644 --- a/drivers/gpu/drm/tinydrm/core/Makefile +++ b/drivers/gpu/drm/tinydrm/core/Makefile @@ -1,3 +1,3 @@ -tinydrm-y := tinydrm-core.o tinydrm-pipe.o tinydrm-helpers.o +tinydrm-y := tinydrm-core.o tinydrm-pipe.o tinydrm-panel.o tinydrm-helpers.o
obj-$(CONFIG_DRM_TINYDRM) += tinydrm.o diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-panel.c b/drivers/gpu/drm/tinydrm/core/tinydrm-panel.c new file mode 100644 index 0000000..f3e5fb1 --- /dev/null +++ b/drivers/gpu/drm/tinydrm/core/tinydrm-panel.c @@ -0,0 +1,532 @@ +/* + * Copyright 2017 Noralf Trønnes + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include <linux/debugfs.h> +#include <linux/device.h> +#include <linux/i2c.h> +#include <linux/platform_device.h> +#include <linux/regmap.h> +#include <linux/regulator/consumer.h> +#include <linux/spi/spi.h> + +#include <drm/drm_gem_cma_helper.h> +#include <drm/drm_fb_cma_helper.h> +#include <drm/drm_fourcc.h> +#include <drm/tinydrm/tinydrm-helpers.h> +#include <drm/tinydrm/tinydrm-panel.h> + +/** + * DOC: overview + * + * This library provides helpers for displays/panels that can be operated + * using a simple vtable. + * + * Many controllers are operated through a register making ®map a useful + * abstraction for the register interface code. This helper is geared towards + * such controllers. Often controllers also support more than one bus, and + * should for instance a controller be connected in a non-standard way + * (e.g. memory mapped), then only the regmap needs to be changed. + */ + +static int tinydrm_panel_prepare(struct tinydrm_panel *panel) +{ + if (panel->funcs && panel->funcs->prepare) + return panel->funcs->prepare(panel); + + if (panel->regulator) + return regulator_enable(panel->regulator); + + return 0; +} + +static int tinydrm_panel_enable(struct tinydrm_panel *panel) +{ + if (panel->funcs && panel->funcs->enable) + return panel->funcs->enable(panel); + + return tinydrm_enable_backlight(panel->backlight); +} + +static int tinydrm_panel_disable(struct tinydrm_panel *panel) +{ + if (panel->funcs && panel->funcs->disable) + return panel->funcs->disable(panel); + + return tinydrm_disable_backlight(panel->backlight); +} + +static int tinydrm_panel_unprepare(struct tinydrm_panel *panel) +{ + if (panel->funcs && panel->funcs->unprepare) + return panel->funcs->unprepare(panel); + + if (panel->regulator) + return regulator_disable(panel->regulator); + + return 0; +} + +static void tinydrm_panel_pipe_enable(struct drm_simple_display_pipe *pipe, + struct drm_crtc_state *crtc_state) +{ + struct tinydrm_device *tdev = pipe_to_tinydrm(pipe); + struct tinydrm_panel *panel = tinydrm_to_panel(tdev); + struct drm_framebuffer *fb = pipe->plane.fb; + + panel->enabled = true; + fb->funcs->dirty(fb, NULL, 0, 0, NULL, 0); + tinydrm_panel_enable(panel); +} + +static void tinydrm_panel_pipe_disable(struct drm_simple_display_pipe *pipe) +{ + struct tinydrm_device *tdev = pipe_to_tinydrm(pipe); + struct tinydrm_panel *panel = tinydrm_to_panel(tdev); + + panel->enabled = false; + tinydrm_panel_disable(panel); +} + +static void tinydrm_panel_pipe_update(struct drm_simple_display_pipe *pipe, + struct drm_plane_state *old_state) +{ + struct tinydrm_device *tdev = pipe_to_tinydrm(pipe); + struct tinydrm_panel *panel = tinydrm_to_panel(tdev); + struct drm_framebuffer *fb = pipe->plane.state->fb; + + /* fb is set (not changed) */ + if (fb && !old_state->fb) + tinydrm_panel_prepare(panel); + + tinydrm_display_pipe_update(pipe, old_state); + + /* fb is unset */ + if (!fb) + tinydrm_panel_unprepare(panel); +} + +static const struct drm_simple_display_pipe_funcs tinydrm_panel_pipe_funcs = { + .enable = tinydrm_panel_pipe_enable, + .disable = tinydrm_panel_pipe_disable, + .update = tinydrm_panel_pipe_update, + .prepare_fb = tinydrm_display_pipe_prepare_fb, +}; + +static int tinydrm_panel_fb_dirty(struct drm_framebuffer *fb, + struct drm_file *file_priv, + unsigned int flags, unsigned int color, + struct drm_clip_rect *clips, + unsigned int num_clips) +{ + struct tinydrm_device *tdev = fb->dev->dev_private; + struct tinydrm_panel *panel = tinydrm_to_panel(tdev); + struct drm_clip_rect rect; + int ret = 0; + + if (!panel->funcs || !panel->funcs->flush) + return 0; + + mutex_lock(&tdev->dirty_lock); + + if (!panel->enabled) + goto out_unlock; + + /* fbdev can flush even when we're not interested */ + if (tdev->pipe.plane.fb != fb) + goto out_unlock; + + tinydrm_merge_clips(&rect, clips, num_clips, flags, + fb->width, fb->height); + + ret = panel->funcs->flush(panel, fb, &rect); + +out_unlock: + mutex_unlock(&tdev->dirty_lock); + + if (ret) + dev_err_once(fb->dev->dev, "Failed to update display %d\n", + ret); + + return ret; +} + +static const struct drm_framebuffer_funcs tinydrm_panel_fb_funcs = { + .destroy = drm_fb_cma_destroy, + .create_handle = drm_fb_cma_create_handle, + .dirty = tinydrm_panel_fb_dirty, +}; + +/** + * tinydrm_panel_init - Initialize &tinydrm_panel + * @dev: Parent device + * @panel: &tinydrm_panel structure to initialize + * @funcs: Callbacks for the panel (optional) + * @formats: Array of supported formats (DRM_FORMAT_*). The first format is + * considered the default format and &tinydrm_panel->tx_buf is + * allocated a buffer that can hold a framebuffer with that format. + * @format_count: Number of elements in @formats + * @driver: DRM driver + * @mode: Display mode + * @rotation: Initial rotation in degrees Counter Clock Wise + * + * This function initializes a &tinydrm_panel structure and it's underlying + * @tinydrm_device. It also sets up the display pipeline. + * + * Objects created by this function will be automatically freed on driver + * detach (devres). + * + * Returns: + * Zero on success, negative error code on failure. + */ +int tinydrm_panel_init(struct device *dev, struct tinydrm_panel *panel, + const struct tinydrm_panel_funcs *funcs, + const uint32_t *formats, unsigned int format_count, + struct drm_driver *driver, + const struct drm_display_mode *mode, + unsigned int rotation) +{ + struct tinydrm_device *tdev = &panel->tinydrm; + const struct drm_format_info *format_info; + size_t bufsize; + int ret; + + format_info = drm_format_info(formats[0]); + bufsize = mode->vdisplay * mode->hdisplay * format_info->cpp[0]; + + panel->tx_buf = devm_kmalloc(dev, bufsize, GFP_KERNEL); + if (!panel->tx_buf) + return -ENOMEM; + + ret = devm_tinydrm_init(dev, tdev, &tinydrm_panel_fb_funcs, driver); + if (ret) + return ret; + + ret = tinydrm_display_pipe_init(tdev, &tinydrm_panel_pipe_funcs, + DRM_MODE_CONNECTOR_VIRTUAL, + formats, format_count, mode, + rotation); + if (ret) + return ret; + + tdev->drm->mode_config.preferred_depth = format_info->depth; + + panel->rotation = rotation; + panel->funcs = funcs; + + drm_mode_config_reset(tdev->drm); + + DRM_DEBUG_KMS("preferred_depth=%u, rotation = %u\n", + tdev->drm->mode_config.preferred_depth, rotation); + + return 0; +} +EXPORT_SYMBOL(tinydrm_panel_init); + +/** + * tinydrm_panel_rgb565_buf - Return RGB565 buffer to scanout + * @panel: tinydrm panel + * @fb: DRM framebuffer + * @rect: Clip rectangle area to scanout + * + * This function returns the RGB565 framebuffer rectangle to scanout. + * It converts XRGB8888 to RGB565 if necessary. + * If copying isn't necessary (RGB565 full rect, no swap), then the backing + * CMA buffer is returned. + * + * Returns: + * Buffer to scanout on success, ERR_PTR on failure. + */ +void *tinydrm_panel_rgb565_buf(struct tinydrm_panel *panel, + struct drm_framebuffer *fb, + struct drm_clip_rect *rect) +{ + struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0); + bool swap = panel->swap_bytes; + bool full; + void *buf; + int ret; + + full = (rect->x2 - rect->x1) == fb->width && + (rect->y2 - rect->y1) == fb->height; + + if (panel->always_tx_buf || swap || !full || + fb->format->format == DRM_FORMAT_XRGB8888) { + buf = panel->tx_buf; + ret = tinydrm_rgb565_buf_copy(buf, fb, rect, swap); + if (ret) + return ERR_PTR(ret); + } else { + buf = cma_obj->vaddr; + } + + return buf; +} +EXPORT_SYMBOL(tinydrm_panel_rgb565_buf); + +/** + * tinydrm_panel_pm_suspend - tinydrm_panel PM suspend helper + * @dev: Device + * + * tinydrm_panel drivers can use this in their &device_driver->pm operations. + * Use dev_set_drvdata() or similar to set &tinydrm_panel as driver data. + */ +int tinydrm_panel_pm_suspend(struct device *dev) +{ + struct tinydrm_panel *panel = dev_get_drvdata(dev); + int ret; + + ret = tinydrm_suspend(&panel->tinydrm); + if (ret) + return ret; + + /* fb isn't set to NULL by suspend, do .unprepare() explicitly */ + tinydrm_panel_unprepare(panel); + + return 0; +} +EXPORT_SYMBOL(tinydrm_panel_pm_suspend); + +/** + * tinydrm_panel_pm_resume - tinydrm_panel PM resume helper + * @dev: Device + * + * tinydrm_panel drivers can use this in their &device_driver->pm operations. + * Use dev_set_drvdata() or similar to set &tinydrm_panel as driver data. + */ +int tinydrm_panel_pm_resume(struct device *dev) +{ + struct tinydrm_panel *panel = dev_get_drvdata(dev); + + /* fb is NULL on resume, .prepare() will be called in pipe_update */ + + return tinydrm_resume(&panel->tinydrm); +} +EXPORT_SYMBOL(tinydrm_panel_pm_resume); + +/** + * tinydrm_panel_spi_shutdown - tinydrm_panel SPI shutdown helper + * @spi: SPI device + * + * tinydrm_panel drivers can use this as their shutdown callback to turn off + * the display on machine shutdown and reboot. Use spi_set_drvdata() or + * similar to set &tinydrm_panel as driver data. + */ +void tinydrm_panel_spi_shutdown(struct spi_device *spi) +{ + struct tinydrm_panel *panel = spi_get_drvdata(spi); + + tinydrm_shutdown(&panel->tinydrm); +} +EXPORT_SYMBOL(tinydrm_panel_spi_shutdown); + +/** + * tinydrm_panel_i2c_shutdown - tinydrm_panel I2C shutdown helper + * @i2c: I2C client device + * + * tinydrm_panel drivers can use this as their shutdown callback to turn off + * the display on machine shutdown and reboot. Use i2c_set_clientdata() or + * similar to set &tinydrm_panel as driver data. + */ +void tinydrm_panel_i2c_shutdown(struct i2c_client *i2c) +{ + struct tinydrm_panel *panel = i2c_get_clientdata(i2c); + + tinydrm_shutdown(&panel->tinydrm); +} +EXPORT_SYMBOL(tinydrm_panel_i2c_shutdown); + +/** + * tinydrm_panel_platform_shutdown - tinydrm_panel platform driver shutdown + * helper + * @pdev: Platform device + * + * tinydrm_panel drivers can use this as their shutdown callback to turn off + * the display on machine shutdown and reboot. Use platform_set_drvdata() or + * similar to set &tinydrm_panel as driver data. + */ +void tinydrm_panel_platform_shutdown(struct platform_device *pdev) +{ + struct tinydrm_panel *panel = platform_get_drvdata(pdev); + + tinydrm_shutdown(&panel->tinydrm); +} +EXPORT_SYMBOL(tinydrm_panel_platform_shutdown); + +/** + * tinydrm_regmap_raw_swap_bytes - Does a raw write require swapping bytes? + * @reg: Regmap + * + * If the bus doesn't support the full regwidth, it has to break up the word. + * Additionally if the bus and machine doesn't match endian wise, this requires + * byteswapping the buffer when using regmap_raw_write(). + * + * Returns: + * True if byte swapping is needed, otherwise false + */ +bool tinydrm_regmap_raw_swap_bytes(struct regmap *reg) +{ + int val_bytes = regmap_get_val_bytes(reg); + unsigned int bus_val; + u16 val16 = 0x00ff; + + if (val_bytes == 1) + return false; + + if (WARN_ON_ONCE(val_bytes != 2)) + return false; + + regmap_parse_val(reg, &val16, &bus_val); + + return val16 != bus_val; +} +EXPORT_SYMBOL(tinydrm_regmap_raw_swap_bytes); + +#ifdef CONFIG_DEBUG_FS + +static int +tinydrm_kstrtoul_array_from_user(const char __user *s, size_t count, + unsigned int base, + unsigned long *vals, size_t num_vals) +{ + char *buf, *pos, *token; + int ret, i = 0; + + buf = memdup_user_nul(s, count); + if (IS_ERR(buf)) + return PTR_ERR(buf); + + pos = buf; + while (pos) { + if (i == num_vals) { + ret = -E2BIG; + goto err_free; + } + + token = strsep(&pos, " "); + if (!token) { + ret = -EINVAL; + goto err_free; + } + + ret = kstrtoul(token, base, vals++); + if (ret < 0) + goto err_free; + i++; + } + +err_free: + kfree(buf); + + return ret ? ret : i; +} + +static ssize_t tinydrm_regmap_debugfs_reg_write(struct file *file, + const char __user *user_buf, + size_t count, loff_t *ppos) +{ + struct seq_file *m = file->private_data; + struct regmap *reg = m->private; + unsigned long vals[2]; + int ret; + + ret = tinydrm_kstrtoul_array_from_user(user_buf, count, 16, vals, 2); + if (ret <= 0) + return ret; + + if (ret != 2) + return -EINVAL; + + ret = regmap_write(reg, vals[0], vals[1]); + + return ret < 0 ? ret : count; +} + +static int tinydrm_regmap_debugfs_reg_show(struct seq_file *m, void *d) +{ + struct regmap *reg = m->private; + int max_reg = regmap_get_max_register(reg); + int val_bytes = regmap_get_val_bytes(reg); + unsigned int val; + int regnr, ret; + + for (regnr = 0; regnr < max_reg; regnr++) { + seq_printf(m, "%.*x: ", val_bytes * 2, regnr); + ret = regmap_read(reg, regnr, &val); + if (ret) + seq_puts(m, "XX\n"); + else + seq_printf(m, "%.*x\n", val_bytes * 2, val); + } + + return 0; +} + +static int tinydrm_regmap_debugfs_reg_open(struct inode *inode, + struct file *file) +{ + return single_open(file, tinydrm_regmap_debugfs_reg_show, + inode->i_private); +} + +static const struct file_operations tinydrm_regmap_debugfs_reg_fops = { + .owner = THIS_MODULE, + .open = tinydrm_regmap_debugfs_reg_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .write = tinydrm_regmap_debugfs_reg_write, +}; + +static int +tinydrm_regmap_debugfs_init(struct regmap *reg, struct dentry *parent) +{ + umode_t mode = 0200; + + if (regmap_get_max_register(reg)) + mode |= 0444; + + debugfs_create_file("registers", mode, parent, reg, + &tinydrm_regmap_debugfs_reg_fops); + return 0; +} + +static const struct drm_info_list tinydrm_panel_debugfslist[] = { + { "fb", drm_fb_cma_debugfs_show, 0 }, +}; + +/** + * tinydrm_panel_debugfs_init - Create tinydrm panel debugfs entries + * @minor: DRM minor + * + * &tinydrm_panel drivers can use this as their + * &drm_driver->debugfs_init callback. + * + * Returns: + * Zero on success, negative error code on failure. + */ +int tinydrm_panel_debugfs_init(struct drm_minor *minor) +{ + struct tinydrm_device *tdev = minor->dev->dev_private; + struct tinydrm_panel *panel = tinydrm_to_panel(tdev); + struct regmap *reg = panel->reg; + int ret; + + if (reg) { + ret = tinydrm_regmap_debugfs_init(reg, minor->debugfs_root); + if (ret) + return ret; + } + + return drm_debugfs_create_files(tinydrm_panel_debugfslist, + ARRAY_SIZE(tinydrm_panel_debugfslist), + minor->debugfs_root, minor); +} +EXPORT_SYMBOL(tinydrm_panel_debugfs_init); + +#endif diff --git a/include/drm/tinydrm/tinydrm-panel.h b/include/drm/tinydrm/tinydrm-panel.h new file mode 100644 index 0000000..fc4348d --- /dev/null +++ b/include/drm/tinydrm/tinydrm-panel.h @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2017 Noralf Trønnes + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#ifndef __LINUX_TINYDRM_PANEL_H +#define __LINUX_TINYDRM_PANEL_H + +#include <drm/tinydrm/tinydrm.h> + +struct backlight_device; +struct platform_device; +struct tinydrm_panel; +struct spi_device; +struct regulator; +struct gpio_desc; +struct regmap; + +/** + * struct tinydrm_panel_funcs - tinydrm panel functions + * + * All functions are optional. + */ +struct tinydrm_panel_funcs { + /** + * @prepare: + * + * Prepare controller/display. + * + * This function is called before framebuffer flushing starts. + * Drivers can use this callback to power on and configure the + * controller/display. + * If this is not set and &tinydrm_panel->regulator is set, + * the regulator is enabled. + */ + int (*prepare)(struct tinydrm_panel *panel); + + /** + * @enable: + * + * Enable display. + * + * This function is called when the display pipeline is enabled. + * Drivers can use this callback to turn on the display. + * If this is not set and &tinydrm_panel->backlight is set, + * the backlight is turned on. + */ + int (*enable)(struct tinydrm_panel *panel); + + /** + * @disable: + * + * Disable display. + * + * This function is called when the display pipeline is disabled. + * Drivers can use this callback to turn off the display. + * If this is not set and &tinydrm_panel->backlight is set, + * the backlight is turned off. + */ + int (*disable)(struct tinydrm_panel *panel); + + /** + * @unprepare: + * + * Unprepare controller/display. + * + * This function is called when framebuffer is unset on the plane. + * Drivers can use this callback to power down the controller/display. + * If this is not set and &tinydrm_panel->regulator is set, + * the regulator is disabled. + */ + int (*unprepare)(struct tinydrm_panel *panel); + + /** + * @flush: + * + * Flush framebuffer to controller/display. + * + * This function is called when the framebuffer is flushed. This + * happens when userspace calls ioctl DRM_IOCTL_MODE_DIRTYFB, when the + * framebuffer is changed on the plane and when the pipeline is + * enabled. If multiple clip rectangles are passed in, they are merged + * into one rectangle and passed to @flush. No flushing happens + * during the time the pipeline is disabled. + */ + int (*flush)(struct tinydrm_panel *panel, struct drm_framebuffer *fb, + struct drm_clip_rect *rect); +}; + +/** + * struct tinydrm_panel - tinydrm panel device + * @tinydrm: Base &tinydrm_device + * @funcs: tinydrm panel functions (optional) + * @reg: Register map (optional) + * @enabled: Pipeline is enabled + * @tx_buf: Transmit buffer + * @swap_bytes: Swap pixel data bytes + * @always_tx_buf: Always use @tx_buf + * @rotation: Rotation in degrees Counter Clock Wise + * @reset: Optional reset gpio + * @backlight: Optional backlight device + * @regulator: Optional regulator + */ +struct tinydrm_panel { + struct tinydrm_device tinydrm; + const struct tinydrm_panel_funcs *funcs; + struct regmap *reg; + bool enabled; + void *tx_buf; + bool swap_bytes; + bool always_tx_buf; + unsigned int rotation; + struct gpio_desc *reset; + struct backlight_device *backlight; + struct regulator *regulator; +}; + +static inline struct tinydrm_panel * +tinydrm_to_panel(struct tinydrm_device *tdev) +{ + return container_of(tdev, struct tinydrm_panel, tinydrm); +} + +int tinydrm_panel_init(struct device *dev, struct tinydrm_panel *panel, + const struct tinydrm_panel_funcs *funcs, + const uint32_t *formats, unsigned int format_count, + struct drm_driver *driver, + const struct drm_display_mode *mode, + unsigned int rotation); + +void *tinydrm_panel_rgb565_buf(struct tinydrm_panel *panel, + struct drm_framebuffer *fb, + struct drm_clip_rect *rect); + +int tinydrm_panel_pm_suspend(struct device *dev); +int tinydrm_panel_pm_resume(struct device *dev); +void tinydrm_panel_spi_shutdown(struct spi_device *spi); +void tinydrm_panel_i2c_shutdown(struct i2c_client *i2c); +void tinydrm_panel_platform_shutdown(struct platform_device *pdev); + +bool tinydrm_regmap_raw_swap_bytes(struct regmap *reg); + +#ifdef CONFIG_DEBUG_FS +int tinydrm_panel_debugfs_init(struct drm_minor *minor); +#else +#define tinydrm_panel_debugfs_init NULL +#endif + +#endif /* __LINUX_TINYDRM_PANEL_H */