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 &regmap 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 */
