tinydrm provides a very simplified view of DRM for displays that has
onboard video memory and is connected through a slow bus like SPI/I2C.
Signed-off-by: Noralf Trønnes <noralf at tronnes.org>
---
drivers/gpu/drm/Kconfig | 2 +
drivers/gpu/drm/Makefile | 1 +
drivers/gpu/drm/tinydrm/Kconfig | 11 +
drivers/gpu/drm/tinydrm/Makefile | 1 +
drivers/gpu/drm/tinydrm/core/Makefile | 8 +
drivers/gpu/drm/tinydrm/core/internal.h | 43 +++
drivers/gpu/drm/tinydrm/core/tinydrm-core.c | 194 ++++++++++++
drivers/gpu/drm/tinydrm/core/tinydrm-crtc.c | 203 ++++++++++++
drivers/gpu/drm/tinydrm/core/tinydrm-deferred.c | 116 +++++++
drivers/gpu/drm/tinydrm/core/tinydrm-fbdev.c | 345 +++++++++++++++++++++
drivers/gpu/drm/tinydrm/core/tinydrm-framebuffer.c | 112 +++++++
drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c | 97 ++++++
drivers/gpu/drm/tinydrm/core/tinydrm-plane.c | 50 +++
include/drm/tinydrm/tinydrm.h | 142 +++++++++
14 files changed, 1325 insertions(+)
create mode 100644 drivers/gpu/drm/tinydrm/Kconfig
create mode 100644 drivers/gpu/drm/tinydrm/Makefile
create mode 100644 drivers/gpu/drm/tinydrm/core/Makefile
create mode 100644 drivers/gpu/drm/tinydrm/core/internal.h
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-core.c
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-crtc.c
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-deferred.c
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-fbdev.c
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-framebuffer.c
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c
create mode 100644 drivers/gpu/drm/tinydrm/core/tinydrm-plane.c
create mode 100644 include/drm/tinydrm/tinydrm.h
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index c4bf9a1..3f8ede0 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -266,3 +266,5 @@ source "drivers/gpu/drm/amd/amdkfd/Kconfig"
source "drivers/gpu/drm/imx/Kconfig"
source "drivers/gpu/drm/vc4/Kconfig"
+
+source "drivers/gpu/drm/tinydrm/Kconfig"
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 1e9ff4c..c7c5c16 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -75,3 +75,4 @@ obj-y += i2c/
obj-y += panel/
obj-y += bridge/
obj-$(CONFIG_DRM_FSL_DCU) += fsl-dcu/
+obj-$(CONFIG_DRM_TINYDRM) += tinydrm/
diff --git a/drivers/gpu/drm/tinydrm/Kconfig b/drivers/gpu/drm/tinydrm/Kconfig
new file mode 100644
index 0000000..f290045
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/Kconfig
@@ -0,0 +1,11 @@
+menuconfig DRM_TINYDRM
+ tristate "Support for small TFT LCD display modules"
+ depends on DRM
+ select DRM_KMS_HELPER
+ select DRM_KMS_CMA_HELPER
+ select DRM_GEM_CMA_HELPER
+ select DRM_PANEL
+ select VIDEOMODE_HELPERS
+ help
+ Choose this option if you have a tinydrm supported display.
+ If M is selected the module will be called tinydrm.
diff --git a/drivers/gpu/drm/tinydrm/Makefile b/drivers/gpu/drm/tinydrm/Makefile
new file mode 100644
index 0000000..7476ed1
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_DRM_TINYDRM) += core/
diff --git a/drivers/gpu/drm/tinydrm/core/Makefile
b/drivers/gpu/drm/tinydrm/core/Makefile
new file mode 100644
index 0000000..03309f4
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/Makefile
@@ -0,0 +1,8 @@
+obj-$(CONFIG_DRM_TINYDRM) += tinydrm.o
+tinydrm-y += tinydrm-core.o
+tinydrm-y += tinydrm-crtc.o
+tinydrm-y += tinydrm-framebuffer.o
+tinydrm-y += tinydrm-plane.o
+tinydrm-y += tinydrm-helpers.o
+tinydrm-y += tinydrm-deferred.o
+tinydrm-$(CONFIG_DRM_KMS_FB_HELPER) += tinydrm-fbdev.o
diff --git a/drivers/gpu/drm/tinydrm/core/internal.h
b/drivers/gpu/drm/tinydrm/core/internal.h
new file mode 100644
index 0000000..a126658
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/internal.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+int tinydrm_crtc_create(struct tinydrm_device *tdev);
+
+static inline bool tinydrm_active(struct tinydrm_device *tdev)
+{
+ struct drm_crtc *crtc;
+
+ drm_for_each_crtc(crtc, tdev->base)
+ return crtc->state && crtc->state->active;
+
+ return false;
+}
+
+void tinydrm_mode_config_init(struct tinydrm_device *tdev);
+
+int tinydrm_plane_init(struct tinydrm_device *tdev);
+
+#ifdef CONFIG_DRM_KMS_FB_HELPER
+int tinydrm_fbdev_init(struct tinydrm_device *tdev);
+void tinydrm_fbdev_fini(struct tinydrm_device *tdev);
+void tinydrm_fbdev_restore_mode(struct tinydrm_fbdev *fbdev);
+#else
+static inline int tinydrm_fbdev_init(struct tinydrm_device *tdev)
+{
+ return 0;
+}
+
+static inline void tinydrm_fbdev_fini(struct tinydrm_device *tdev)
+{
+}
+
+static inline void tinydrm_fbdev_restore_mode(struct tinydrm_fbdev *fbdev)
+{
+}
+#endif
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-core.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-core.c
new file mode 100644
index 0000000..cb3cf71
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-core.c
@@ -0,0 +1,194 @@
+//#define DEBUG
+/*
+ * Copyright (C) 2016 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 <drm/drmP.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/tinydrm/tinydrm.h>
+#include <linux/device.h>
+
+#include "internal.h"
+
+static int tinydrm_load(struct drm_device *ddev, unsigned long flags)
+{
+ struct tinydrm_device *tdev = ddev->dev_private;
+ struct drm_connector *connector;
+ int ret;
+
+ DRM_DEBUG_KMS("\n");
+
+ tinydrm_mode_config_init(tdev);
+
+ ret = tinydrm_plane_init(tdev);
+ if (ret)
+ return ret;
+
+ ret = tinydrm_crtc_create(tdev);
+ if (ret)
+ return ret;
+
+ connector = list_first_entry(&ddev->mode_config.connector_list,
+ typeof(*connector), head);
+ connector->status = connector_status_connected;
+
+ drm_panel_init(&tdev->panel);
+ drm_panel_add(&tdev->panel);
+ drm_panel_attach(&tdev->panel, connector);
+
+ drm_mode_config_reset(ddev);
+
+ ret = tinydrm_fbdev_init(tdev);
+ if (ret)
+ return ret;
+
+ return 0;
+}
+
+static void tinydrm_lastclose(struct drm_device *ddev)
+{
+ struct tinydrm_device *tdev = ddev->dev_private;
+
+ DRM_DEBUG_KMS("\n");
+ tinydrm_fbdev_restore_mode(tdev->fbdev);
+}
+
+static const struct file_operations tinydrm_fops = {
+ .owner = THIS_MODULE,
+ .open = drm_open,
+ .release = drm_release,
+ .unlocked_ioctl = drm_ioctl,
+#ifdef CONFIG_COMPAT
+ .compat_ioctl = drm_compat_ioctl,
+#endif
+ .poll = drm_poll,
+ .read = drm_read,
+ .llseek = no_llseek,
+ .mmap = drm_gem_cma_mmap,
+};
+
+static struct drm_driver tinydrm_driver = {
+ .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME
+ | DRIVER_ATOMIC,
+ .load = tinydrm_load,
+ .lastclose = tinydrm_lastclose,
+// .unload = tinydrm_unload,
+ .get_vblank_counter = drm_vblank_count,
+// .enable_vblank = tinydrm_enable_vblank,
+// .disable_vblank = tinydrm_disable_vblank,
+ .gem_free_object = drm_gem_cma_free_object,
+ .gem_vm_ops = &drm_gem_cma_vm_ops,
+ .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
+ .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
+ .gem_prime_import = drm_gem_prime_import,
+ .gem_prime_export = drm_gem_prime_export,
+ .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
+ .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
+ .gem_prime_vmap = drm_gem_cma_prime_vmap,
+ .gem_prime_vunmap = drm_gem_cma_prime_vunmap,
+ .gem_prime_mmap = drm_gem_cma_prime_mmap,
+ .dumb_create = drm_gem_cma_dumb_create,
+ .dumb_map_offset = drm_gem_cma_dumb_map_offset,
+ .dumb_destroy = drm_gem_dumb_destroy,
+ .fops = &tinydrm_fops,
+ .name = "tinydrm",
+ .desc = "tinydrm",
+ .date = "20150916",
+ .major = 1,
+ .minor = 0,
+};
+
+void tinydrm_release(struct tinydrm_device *tdev)
+{
+ DRM_DEBUG_KMS("\n");
+
+ if (tdev->deferred)
+ cancel_delayed_work_sync(&tdev->deferred->dwork);
+
+ tinydrm_fbdev_fini(tdev);
+
+ drm_panel_detach(&tdev->panel);
+ drm_panel_remove(&tdev->panel);
+
+ drm_mode_config_cleanup(tdev->base);
+ drm_dev_unregister(tdev->base);
+ drm_dev_unref(tdev->base);
+}
+EXPORT_SYMBOL(tinydrm_release);
+
+int tinydrm_register(struct device *dev, struct tinydrm_device *tdev)
+{
+ struct drm_driver *driver = &tinydrm_driver;
+ struct drm_device *ddev;
+ int ret;
+
+ dev_info(dev, "%s\n", __func__);
+
+dev->coherent_dma_mask = DMA_BIT_MASK(32);
+
+ if (WARN_ON(!tdev->dirtyfb))
+ return -EINVAL;
+
+ ddev = drm_dev_alloc(driver, dev);
+ if (!ddev)
+ return -ENOMEM;
+
+ tdev->base = ddev;
+ ddev->dev_private = tdev;
+
+ ret = drm_dev_set_unique(ddev, dev_name(ddev->dev));
+ if (ret)
+ goto err_free;
+
+ ret = drm_dev_register(ddev, 0);
+ if (ret)
+ goto err_free;
+
+ DRM_INFO("Device: %s\n", dev_name(dev));
+ DRM_INFO("Initialized %s %d.%d.%d on minor %d\n",
+ driver->name, driver->major, driver->minor, driver->patchlevel,
+ ddev->primary->index);
+
+ return 0;
+
+err_free:
+ drm_dev_unref(ddev);
+
+ return ret;
+}
+EXPORT_SYMBOL(tinydrm_register);
+
+static void devm_tinydrm_release(struct device *dev, void *res)
+{
+ tinydrm_release(*(struct tinydrm_device **)res);
+}
+
+int devm_tinydrm_register(struct device *dev, struct tinydrm_device *tdev)
+{
+ struct tinydrm_device **ptr;
+ int ret;
+
+ ptr = devres_alloc(devm_tinydrm_release, sizeof(*ptr), GFP_KERNEL);
+ if (!ptr)
+ return -ENOMEM;
+
+ ret = tinydrm_register(dev, tdev);
+ if (ret) {
+ devres_free(ptr);
+ return ret;
+ }
+
+ *ptr = tdev;
+ devres_add(dev, ptr);
+
+ return 0;
+}
+EXPORT_SYMBOL(devm_tinydrm_register);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-crtc.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-crtc.c
new file mode 100644
index 0000000..65b3426
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-crtc.c
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2016 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 <drm/drmP.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_crtc_helper.h>
+#include <drm/tinydrm/tinydrm.h>
+#include <linux/slab.h>
+
+#include "internal.h"
+
+static int tinydrm_connector_get_modes(struct drm_connector *connector)
+{
+ struct tinydrm_device *tdev = connector->dev->dev_private;
+ struct drm_display_mode *mode;
+ int ret;
+
+ DRM_DEBUG_KMS("\n");
+ ret = drm_panel_get_modes(&tdev->panel);
+ if (ret > 0)
+ return ret;
+
+ mode = drm_cvt_mode(connector->dev, tdev->width, tdev->height, 60,
false, false, false);
+ if (!mode)
+ return 0;
+
+ mode->type |= DRM_MODE_TYPE_PREFERRED;
+ drm_mode_probed_add(connector, mode);
+
+ return 1;
+}
+
+static struct drm_encoder *
+tinydrm_connector_best_encoder(struct drm_connector *connector)
+{
+ return drm_encoder_find(connector->dev, connector->encoder_ids[0]);
+}
+
+static const struct drm_connector_helper_funcs tinydrm_connector_helper_funcs
= {
+ .get_modes = tinydrm_connector_get_modes,
+ .best_encoder = tinydrm_connector_best_encoder,
+};
+
+static enum drm_connector_status
+tinydrm_connector_detect(struct drm_connector *connector, bool force)
+{
+ DRM_DEBUG_KMS("status = %d\n", connector->status);
+
+ if (drm_device_is_unplugged(connector->dev))
+ return connector_status_disconnected;
+
+ return connector->status;
+}
+
+static void tinydrm_connector_destroy(struct drm_connector *connector)
+{
+ DRM_DEBUG_KMS("\n");
+ drm_connector_unregister(connector);
+ drm_connector_cleanup(connector);
+ kfree(connector);
+}
+
+static const struct drm_connector_funcs tinydrm_connector_funcs = {
+ .dpms = drm_atomic_helper_connector_dpms,
+ .reset = drm_atomic_helper_connector_reset,
+ .detect = tinydrm_connector_detect,
+ .fill_modes = drm_helper_probe_single_connector_modes,
+ .destroy = tinydrm_connector_destroy,
+ .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
+ .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+};
+
+static void tinydrm_encoder_disable(struct drm_encoder *encoder)
+{
+}
+
+static void tinydrm_encoder_enable(struct drm_encoder *encoder)
+{
+}
+
+static int tinydrm_encoder_atomic_check(struct drm_encoder *encoder,
+ struct drm_crtc_state *crtc_state,
+ struct drm_connector_state *conn_state)
+{
+ return 0;
+}
+
+static const struct drm_encoder_helper_funcs tinydrm_encoder_helper_funcs = {
+ .disable = tinydrm_encoder_disable,
+ .enable = tinydrm_encoder_enable,
+ .atomic_check = tinydrm_encoder_atomic_check,
+};
+
+static void tinydrm_encoder_cleanup(struct drm_encoder *encoder)
+{
+ DRM_DEBUG_KMS("\n");
+ drm_encoder_cleanup(encoder);
+ kfree(encoder);
+}
+
+static const struct drm_encoder_funcs tinydrm_encoder_funcs = {
+ .destroy = tinydrm_encoder_cleanup,
+};
+
+static void tinydrm_crtc_enable(struct drm_crtc *crtc)
+{
+ struct tinydrm_device *tdev = crtc->dev->dev_private;
+
+ DRM_DEBUG_KMS("prepared=%u, enabled=%u\n", tdev->prepared,
tdev->enabled);
+
+ /* The panel must be prepared on the first crtc enable after probe */
+ tinydrm_prepare(tdev);
+ /* The panel is enabled after the first display update */
+}
+
+static void tinydrm_crtc_disable(struct drm_crtc *crtc)
+{
+ struct tinydrm_device *tdev = crtc->dev->dev_private;
+
+ DRM_DEBUG_KMS("prepared=%u, enabled=%u\n", tdev->prepared,
tdev->enabled);
+
+ tinydrm_disable(tdev);
+}
+
+static const struct drm_crtc_helper_funcs tinydrm_crtc_helper_funcs = {
+ .disable = tinydrm_crtc_disable,
+ .enable = tinydrm_crtc_enable,
+};
+
+static void tinydrm_crtc_cleanup(struct drm_crtc *crtc)
+{
+ DRM_DEBUG_KMS("\n");
+ drm_crtc_cleanup(crtc);
+ kfree(crtc);
+}
+
+static const struct drm_crtc_funcs tinydrm_crtc_funcs = {
+ .reset = drm_atomic_helper_crtc_reset,
+ .destroy = tinydrm_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,
+};
+
+int tinydrm_crtc_create(struct tinydrm_device *tdev)
+{
+ struct drm_device *dev = tdev->base;
+ struct drm_connector *connector;
+ struct drm_encoder *encoder;
+ struct drm_crtc *crtc;
+ int ret;
+
+ connector = kzalloc(sizeof(*connector), GFP_KERNEL);
+ encoder = kzalloc(sizeof(*encoder), GFP_KERNEL);
+ crtc = kzalloc(sizeof(*crtc), GFP_KERNEL);
+ if (!connector || !encoder || !crtc) {
+ ret = -ENOMEM;
+ goto error_free;
+ }
+
+ drm_crtc_helper_add(crtc, &tinydrm_crtc_helper_funcs);
+ ret = drm_crtc_init_with_planes(dev, crtc, &tdev->plane, NULL,
+ &tinydrm_crtc_funcs);
+ if (ret)
+ goto error_free;
+
+ encoder->possible_crtcs = 1 << drm_crtc_index(crtc);
+ drm_encoder_helper_add(encoder, &tinydrm_encoder_helper_funcs);
+ ret = drm_encoder_init(dev, encoder, &tinydrm_encoder_funcs,
+ DRM_MODE_ENCODER_NONE);
+ if (ret)
+ goto error_free;
+
+ drm_connector_helper_add(connector, &tinydrm_connector_helper_funcs);
+ ret = drm_connector_init(dev, connector, &tinydrm_connector_funcs,
+ DRM_MODE_CONNECTOR_VIRTUAL);
+ if (ret)
+ goto error_free;
+
+ ret = drm_mode_connector_attach_encoder(connector, encoder);
+ if (ret)
+ goto error_free;
+
+ ret = drm_connector_register(connector);
+ if (ret)
+ goto error_free;
+
+ return 0;
+
+error_free:
+ kfree(crtc);
+ kfree(encoder);
+ kfree(connector);
+
+ return ret;
+}
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-deferred.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-deferred.c
new file mode 100644
index 0000000..16553a6
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-deferred.c
@@ -0,0 +1,116 @@
+#include <drm/tinydrm/tinydrm.h>
+
+#include "internal.h"
+
+bool tinydrm_deferred_begin(struct tinydrm_device *tdev,
+ struct tinydrm_fb_clip *fb_clip)
+{
+ struct tinydrm_deferred *deferred = tdev->deferred;
+
+ spin_lock(&deferred->lock);
+ *fb_clip = deferred->fb_clip;
+ tinydrm_reset_clip(&deferred->fb_clip.clip);
+ deferred->fb_clip.fb = NULL;
+ deferred->fb_clip.vmem = NULL;
+ spin_unlock(&deferred->lock);
+
+ /* The crtc might have been disabled by the time we get here */
+ if (!tinydrm_active(tdev))
+ return false;
+
+ /* On first update make sure to do the entire framebuffer */
+ if (!tdev->enabled) {
+ fb_clip->clip.x1 = 0;
+ fb_clip->clip.x2 = fb_clip->fb->width - 1;
+ fb_clip->clip.y1 = 0;
+ fb_clip->clip.y2 = fb_clip->fb->height - 1;
+ }
+
+ /* TODO: support partial updates */
+ fb_clip->clip.x1 = 0;
+ fb_clip->clip.x2 = fb_clip->fb->width - 1;
+ fb_clip->clip.y1 = 0;
+ fb_clip->clip.y2 = fb_clip->fb->height - 1;
+
+ return true;
+}
+EXPORT_SYMBOL(tinydrm_deferred_begin);
+
+void tinydrm_deferred_end(struct tinydrm_device *tdev)
+{
+ if (tdev->prepared && !tdev->enabled) {
+ drm_panel_enable(&tdev->panel);
+ tdev->enabled = true;
+ }
+}
+EXPORT_SYMBOL(tinydrm_deferred_end);
+
+int tinydrm_dirtyfb(struct drm_framebuffer *fb, void *vmem, unsigned flags,
+ unsigned color, struct drm_clip_rect *clips,
+ unsigned num_clips)
+{
+ struct tinydrm_device *tdev = fb->dev->dev_private;
+
+ struct tinydrm_deferred *deferred = tdev->deferred;
+ struct tinydrm_fb_clip *fb_clip = &tdev->deferred->fb_clip;
+
+ bool no_delay = deferred->no_delay;
+ unsigned long delay;
+
+ dev_dbg(tdev->base->dev, "%s(fb = %p, vmem = %p, clips = %p, num_clips
= %u, no_delay = %u)\n", __func__, fb, vmem, clips, num_clips, no_delay);
+
+ if (!vmem || !fb)
+ return -EINVAL;
+
+ spin_lock(&deferred->lock);
+ fb_clip->fb = fb;
+ fb_clip->vmem = vmem;
+ tinydrm_merge_clips(&fb_clip->clip, clips, num_clips, flags,
+ fb->width, fb->height);
+ if (tinydrm_is_full_clip(&fb_clip->clip, fb->width, fb->height))
+ no_delay = true;
+ spin_unlock(&deferred->lock);
+
+ delay = no_delay ? 0 : msecs_to_jiffies(deferred->defer_ms);
+
+ if (schedule_delayed_work(&deferred->dwork, delay))
+ dev_dbg(tdev->base->dev, "%s: Already scheduled\n", __func__);
+
+ return 0;
+}
+EXPORT_SYMBOL(tinydrm_dirtyfb);
+
+void tinydrm_merge_clips(struct drm_clip_rect *dst,
+ struct drm_clip_rect *clips, unsigned num_clips,
+ unsigned flags, u32 width, u32 height)
+{
+ struct drm_clip_rect full_clip = {
+ .x1 = 0,
+ .x2 = width - 1,
+ .y1 = 0,
+ .y2 = height - 1,
+ };
+ int i;
+
+ if (!clips) {
+ clips = &full_clip;
+ num_clips = 1;
+ }
+
+ for (i = 0; i < num_clips; i++) {
+ dst->x1 = min(dst->x1, clips[i].x1);
+ dst->x2 = max(dst->x2, clips[i].x2);
+ dst->y1 = min(dst->y1, clips[i].y1);
+ dst->y2 = max(dst->y2, clips[i].y2);
+
+ if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY) {
+ i++;
+ dst->x2 = max(dst->x2, clips[i].x2);
+ dst->y2 = max(dst->y2, clips[i].y2);
+ }
+ }
+
+ dst->x2 = min_t(u32, dst->x2, width - 1);
+ dst->y2 = min_t(u32, dst->y2, height - 1);
+}
+EXPORT_SYMBOL(tinydrm_merge_clips);
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-fbdev.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-fbdev.c
new file mode 100644
index 0000000..44b6a95
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-fbdev.c
@@ -0,0 +1,345 @@
+//#define DEBUG
+/*
+ * Copyright (C) 2016 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 <drm/drmP.h>
+#include <drm/drm_crtc_helper.h>
+#include <drm/drm_fb_cma_helper.h>
+#include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/tinydrm/tinydrm.h>
+
+#include "internal.h"
+
+#define DEFAULT_DEFIO_DELAY HZ/30
+
+struct tinydrm_fbdev {
+ struct drm_fb_helper fb_helper;
+ struct drm_framebuffer fb;
+ void *vmem;
+};
+
+static inline struct tinydrm_fbdev *helper_to_fbdev(struct drm_fb_helper
*helper)
+{
+ return container_of(helper, struct tinydrm_fbdev, fb_helper);
+}
+
+static inline struct tinydrm_fbdev *fb_to_fbdev(struct drm_framebuffer *fb)
+{
+ return container_of(fb, struct tinydrm_fbdev, fb);
+}
+
+static void tinydrm_fbdev_dirty(struct fb_info *info,
+ struct drm_clip_rect *clip, bool run_now)
+{
+ struct drm_fb_helper *helper = info->par;
+ struct tinydrm_device *tdev = helper->dev->dev_private;
+ struct drm_framebuffer *fb = helper->fb;
+
+ if (tdev->plane.fb != fb)
+ return;
+
+ if (tdev->deferred)
+ tdev->deferred->no_delay = run_now;
+ tdev->dirtyfb(fb, info->screen_buffer, 0, 0, clip, 1);
+}
+
+static void tinydrm_fbdev_deferred_io(struct fb_info *info,
+ struct list_head *pagelist)
+{
+ unsigned long start, end, next, min, max;
+ struct drm_clip_rect clip;
+ struct page *page;
+int count = 0;
+
+ min = ULONG_MAX;
+ max = 0;
+ next = 0;
+ list_for_each_entry(page, pagelist, lru) {
+ start = page->index << PAGE_SHIFT;
+ end = start + PAGE_SIZE - 1;
+ min = min(min, start);
+ max = max(max, end);
+count++;
+ }
+
+ if (min < max) {
+ clip.x1 = 0;
+ clip.x2 = info->var.xres - 1;
+ clip.y1 = min / info->fix.line_length;
+ clip.y2 = min_t(u32, max / info->fix.line_length,
+ info->var.yres - 1);
+ pr_debug("%s: x1=%u, x2=%u, y1=%u, y2=%u, count=%d\n",
__func__, clip.x1, clip.x2, clip.y1, clip.y2, count);
+ tinydrm_fbdev_dirty(info, &clip, true);
+ }
+}
+
+static void tinydrm_fbdev_fb_fillrect(struct fb_info *info,
+ const struct fb_fillrect *rect)
+{
+ struct drm_clip_rect clip = {
+ .x1 = rect->dx,
+ .x2 = rect->dx + rect->width - 1,
+ .y1 = rect->dy,
+ .y2 = rect->dy + rect->height - 1,
+ };
+
+ dev_dbg(info->dev, "%s: dx=%d, dy=%d, width=%d, height=%d\n",
+ __func__, rect->dx, rect->dy, rect->width, rect->height);
+ sys_fillrect(info, rect);
+ tinydrm_fbdev_dirty(info, &clip, false);
+}
+
+static void tinydrm_fbdev_fb_copyarea(struct fb_info *info,
+ const struct fb_copyarea *area)
+{
+ struct drm_clip_rect clip = {
+ .x1 = area->dx,
+ .x2 = area->dx + area->width - 1,
+ .y1 = area->dy,
+ .y2 = area->dy + area->height - 1,
+ };
+
+ dev_dbg(info->dev, "%s: dx=%d, dy=%d, width=%d, height=%d\n",
+ __func__, area->dx, area->dy, area->width, area->height);
+ sys_copyarea(info, area);
+ tinydrm_fbdev_dirty(info, &clip, false);
+}
+
+static void tinydrm_fbdev_fb_imageblit(struct fb_info *info,
+ const struct fb_image *image)
+{
+ struct drm_clip_rect clip = {
+ .x1 = image->dx,
+ .x2 = image->dx + image->width - 1,
+ .y1 = image->dy,
+ .y2 = image->dy + image->height - 1,
+ };
+
+ dev_dbg(info->dev, "%s: dx=%d, dy=%d, width=%d, height=%d\n",
+ __func__, image->dx, image->dy, image->width, image->height);
+ sys_imageblit(info, image);
+ tinydrm_fbdev_dirty(info, &clip, false);
+}
+
+static ssize_t tinydrm_fbdev_fb_write(struct fb_info *info,
+ const char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct drm_clip_rect clip = {
+ .x1 = 0,
+ .x2 = info->var.xres - 1,
+ .y1 = 0,
+ .y2 = info->var.yres - 1,
+ };
+ ssize_t ret;
+
+ dev_dbg(info->dev, "%s:\n", __func__);
+ ret = fb_sys_write(info, buf, count, ppos);
+ tinydrm_fbdev_dirty(info, &clip, false);
+
+ return ret;
+}
+
+static void tinydrm_fbdev_fb_destroy(struct drm_framebuffer *fb)
+{
+}
+
+static struct drm_framebuffer_funcs tinydrm_fbdev_fb_funcs = {
+ .destroy = tinydrm_fbdev_fb_destroy,
+};
+
+static int tinydrm_fbdev_create(struct drm_fb_helper *helper,
+ struct drm_fb_helper_surface_size *sizes)
+{
+ struct tinydrm_fbdev *fbdev = helper_to_fbdev(helper);
+ struct drm_mode_fb_cmd2 mode_cmd = { 0 };
+ struct drm_device *dev = helper->dev;
+ struct tinydrm_device *tdev = dev->dev_private;
+ struct fb_deferred_io *fbdefio;
+ struct drm_framebuffer *fb;
+ unsigned int bytes_per_pixel = DIV_ROUND_UP(sizes->surface_bpp, 8);
+ struct fb_ops *fbops;
+ struct fb_info *fbi;
+ size_t size;
+ char *screen_buffer;
+ int ret;
+
+ mode_cmd.width = sizes->surface_width;
+ mode_cmd.height = sizes->surface_height;
+ mode_cmd.pitches[0] = sizes->surface_width * bytes_per_pixel;
+ mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
+ sizes->surface_depth);
+ size = mode_cmd.pitches[0] * mode_cmd.height;
+
+ /*
+ * A per device fbops structure is needed because
+ * fb_deferred_io_cleanup() clears fbops.fb_mmap
+ */
+ fbops = devm_kzalloc(dev->dev, sizeof(*fbops), GFP_KERNEL);
+ if (!fbops) {
+ dev_err(dev->dev, "Failed to allocate fbops\n");
+ return -ENOMEM;
+ }
+
+ /* A per device structure is needed for individual delays */
+ fbdefio = devm_kzalloc(dev->dev, sizeof(*fbdefio), GFP_KERNEL);
+ if (!fbdefio) {
+ dev_err(dev->dev, "Could not allocate fbdefio\n");
+ return -ENOMEM;
+ }
+
+ fbi = drm_fb_helper_alloc_fbi(helper);
+ if (IS_ERR(fbi)) {
+ dev_err(dev->dev, "Could not allocate fbi\n");
+ return PTR_ERR(fbi);
+ }
+
+ screen_buffer = vzalloc(size);
+ if (!screen_buffer) {
+ dev_err(dev->dev, "Failed to allocate fbdev screen buffer.\n");
+ ret = -ENOMEM;
+ goto err_fb_info_destroy;
+ }
+
+ fb = &fbdev->fb;
+ helper->fb = fb;
+ drm_helper_mode_fill_fb_struct(fb, &mode_cmd);
+ ret = drm_framebuffer_init(dev, fb, &tinydrm_fbdev_fb_funcs);
+ if (ret) {
+ dev_err(dev->dev, "failed to init framebuffer: %d\n", ret);
+ vfree(screen_buffer);
+ goto err_fb_info_destroy;
+ }
+
+ DRM_DEBUG_KMS("fbdev FB ID: %d, vmem = %p\n", fb->base.id, fbdev->vmem);
+
+ fbi->par = helper;
+ fbi->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
+ strcpy(fbi->fix.id, "tinydrm");
+
+ fbops->owner = THIS_MODULE,
+ fbops->fb_fillrect = tinydrm_fbdev_fb_fillrect,
+ fbops->fb_copyarea = tinydrm_fbdev_fb_copyarea,
+ fbops->fb_imageblit = tinydrm_fbdev_fb_imageblit,
+ fbops->fb_write = tinydrm_fbdev_fb_write,
+ fbops->fb_check_var = drm_fb_helper_check_var,
+ fbops->fb_set_par = drm_fb_helper_set_par,
+ fbops->fb_blank = drm_fb_helper_blank,
+ fbops->fb_setcmap = drm_fb_helper_setcmap,
+ fbi->fbops = fbops;
+
+ drm_fb_helper_fill_fix(fbi, fb->pitches[0], fb->depth);
+ drm_fb_helper_fill_var(fbi, helper, sizes->fb_width, sizes->fb_height);
+
+ fbdev->vmem = screen_buffer;
+ fbi->screen_buffer = screen_buffer;
+ fbi->screen_size = size;
+ fbi->fix.smem_len = size;
+
+ if (tdev->deferred)
+ fbdefio->delay = msecs_to_jiffies(tdev->deferred->defer_ms);
+ else
+ fbdefio->delay = DEFAULT_DEFIO_DELAY;
+ /* delay=0 is turned into delay=HZ, so use 1 as a minimum */
+ if (!fbdefio->delay)
+ fbdefio->delay = 1;
+ fbdefio->deferred_io = tinydrm_fbdev_deferred_io;
+ fbi->fbdefio = fbdefio;
+ fb_deferred_io_init(fbi);
+
+ return 0;
+
+err_fb_info_destroy:
+ drm_fb_helper_release_fbi(helper);
+
+ return ret;
+}
+
+static const struct drm_fb_helper_funcs tinydrm_fb_helper_funcs = {
+ .fb_probe = tinydrm_fbdev_create,
+};
+
+int tinydrm_fbdev_init(struct tinydrm_device *tdev)
+{
+ struct drm_device *dev = tdev->base;
+ struct drm_fb_helper *helper;
+ struct tinydrm_fbdev *fbdev;
+ int ret;
+
+ DRM_DEBUG_KMS("IN\n");
+
+ fbdev = devm_kzalloc(dev->dev, sizeof(*fbdev), GFP_KERNEL);
+ if (!fbdev) {
+ dev_err(dev->dev, "Failed to allocate drm fbdev.\n");
+ return -ENOMEM;
+ }
+
+ helper = &fbdev->fb_helper;
+
+ drm_fb_helper_prepare(dev, helper, &tinydrm_fb_helper_funcs);
+
+ ret = drm_fb_helper_init(dev, helper, 1, 1);
+ if (ret < 0) {
+ dev_err(dev->dev, "Failed to initialize drm fb helper.\n");
+ return ret;
+ }
+
+ ret = drm_fb_helper_single_add_all_connectors(helper);
+ if (ret < 0) {
+ dev_err(dev->dev, "Failed to add connectors.\n");
+ goto err_drm_fb_helper_fini;
+
+ }
+
+ ret = drm_fb_helper_initial_config(helper, 16);
+ if (ret < 0) {
+ dev_err(dev->dev, "Failed to set initial hw configuration.\n");
+ goto err_drm_fb_helper_fini;
+ }
+
+ tdev->fbdev = fbdev;
+ DRM_DEBUG_KMS("OUT\n");
+
+ return 0;
+
+err_drm_fb_helper_fini:
+ drm_fb_helper_fini(helper);
+
+ return ret;
+}
+
+void tinydrm_fbdev_fini(struct tinydrm_device *tdev)
+{
+ struct tinydrm_fbdev *fbdev = tdev->fbdev;
+ struct drm_fb_helper *fb_helper = &fbdev->fb_helper;
+
+ DRM_DEBUG_KMS("IN\n");
+
+ drm_fb_helper_unregister_fbi(fb_helper);
+ fb_deferred_io_cleanup(fb_helper->fbdev);
+ drm_fb_helper_release_fbi(fb_helper);
+ drm_fb_helper_fini(fb_helper);
+
+ drm_framebuffer_unregister_private(&fbdev->fb);
+ drm_framebuffer_cleanup(&fbdev->fb);
+
+ vfree(fbdev->vmem);
+
+ tdev->fbdev = NULL;
+ DRM_DEBUG_KMS("OUT\n");
+}
+
+/* TODO: pass tdev instead ? */
+void tinydrm_fbdev_restore_mode(struct tinydrm_fbdev *fbdev)
+{
+ if (fbdev)
+ drm_fb_helper_restore_fbdev_mode_unlocked(&fbdev->fb_helper);
+}
+EXPORT_SYMBOL(tinydrm_fbdev_restore_mode);
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-framebuffer.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-framebuffer.c
new file mode 100644
index 0000000..1056bc6
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-framebuffer.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2016 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 <drm/drmP.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_crtc_helper.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/tinydrm/tinydrm.h>
+
+static inline struct tinydrm_framebuffer *to_tinydrm_framebuffer(struct
drm_framebuffer *fb)
+{
+ return container_of(fb, struct tinydrm_framebuffer, base);
+}
+
+static void tinydrm_framebuffer_destroy(struct drm_framebuffer *fb)
+{
+ struct tinydrm_framebuffer *tinydrm_fb = to_tinydrm_framebuffer(fb);
+ struct tinydrm_device *tdev = fb->dev->dev_private;
+
+ DRM_DEBUG_KMS("fb = %p, cma_obj = %p\n", fb, tinydrm_fb->cma_obj);
+
+ if (tdev->deferred)
+ flush_delayed_work(&tdev->deferred->dwork);
+
+ if (tinydrm_fb->cma_obj)
+ drm_gem_object_unreference_unlocked(&tinydrm_fb->cma_obj->base);
+
+ drm_framebuffer_cleanup(fb);
+ kfree(tinydrm_fb);
+}
+
+static int tinydrm_framebuffer_dirty(struct drm_framebuffer *fb,
+ struct drm_file *file_priv,
+ unsigned flags, unsigned color,
+ struct drm_clip_rect *clips,
+ unsigned num_clips)
+{
+ struct tinydrm_framebuffer *tfb = to_tinydrm_framebuffer(fb);
+ struct tinydrm_device *tdev = fb->dev->dev_private;
+
+ dev_dbg(fb->dev->dev, "%s\n", __func__);
+
+ return tdev->dirtyfb(fb, tfb->cma_obj->vaddr, flags, color, clips,
num_clips);
+}
+
+static const struct drm_framebuffer_funcs tinydrm_fb_funcs = {
+ .destroy = tinydrm_framebuffer_destroy,
+ .dirty = tinydrm_framebuffer_dirty,
+/* TODO?
+ * .create_handle = tinydrm_framebuffer_create_handle, */
+};
+
+static struct drm_framebuffer *
+tinydrm_fb_create(struct drm_device *ddev, struct drm_file *file_priv,
+ struct drm_mode_fb_cmd2 *mode_cmd)
+{
+ struct tinydrm_framebuffer *tinydrm_fb;
+ struct drm_gem_object *obj;
+ int ret;
+
+ /* TODO? Validate the pixel format, size and pitches */
+ DRM_DEBUG_KMS("pixel_format=%s\n",
drm_get_format_name(mode_cmd->pixel_format));
+ DRM_DEBUG_KMS("width=%u\n", mode_cmd->width);
+ DRM_DEBUG_KMS("height=%u\n", mode_cmd->height);
+ DRM_DEBUG_KMS("pitches[0]=%u\n", mode_cmd->pitches[0]);
+
+ obj = drm_gem_object_lookup(ddev, file_priv, mode_cmd->handles[0]);
+ if (!obj)
+ return NULL;
+
+ tinydrm_fb = kzalloc(sizeof(*tinydrm_fb), GFP_KERNEL);
+ if (!tinydrm_fb)
+ return NULL;
+
+ tinydrm_fb->cma_obj = to_drm_gem_cma_obj(obj);
+
+ ret = drm_framebuffer_init(ddev, &tinydrm_fb->base, &tinydrm_fb_funcs);
+ if (ret) {
+ kfree(tinydrm_fb);
+ drm_gem_object_unreference_unlocked(obj);
+ return NULL;
+ }
+
+ drm_helper_mode_fill_fb_struct(&tinydrm_fb->base, mode_cmd);
+
+ return &tinydrm_fb->base;
+}
+
+static const struct drm_mode_config_funcs tinydrm_mode_config_funcs = {
+ .fb_create = tinydrm_fb_create,
+ .atomic_check = drm_atomic_helper_check,
+ .atomic_commit = drm_atomic_helper_commit,
+};
+
+void tinydrm_mode_config_init(struct tinydrm_device *tdev)
+{
+ struct drm_device *ddev = tdev->base;
+
+ drm_mode_config_init(ddev);
+
+ ddev->mode_config.min_width = tdev->width;
+ ddev->mode_config.min_height = tdev->height;
+ ddev->mode_config.max_width = tdev->width;
+ ddev->mode_config.max_height = tdev->height;
+ ddev->mode_config.funcs = &tinydrm_mode_config_funcs;
+}
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c
new file mode 100644
index 0000000..8ed9a15
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2016 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 <drm/drmP.h>
+#include <drm/tinydrm/tinydrm.h>
+#include <linux/backlight.h>
+#include <linux/spi/spi.h>
+
+#include "internal.h"
+
+struct backlight_device *tinydrm_of_find_backlight(struct device *dev)
+{
+ struct backlight_device *backlight;
+ struct device_node *np;
+
+ np = of_parse_phandle(dev->of_node, "backlight", 0);
+ if (!np)
+ return NULL;
+
+ backlight = of_find_backlight_by_node(np);
+ of_node_put(np);
+
+ if (!backlight)
+ return ERR_PTR(-EPROBE_DEFER);
+
+ return backlight;
+}
+EXPORT_SYMBOL(tinydrm_of_find_backlight);
+
+int tinydrm_panel_enable_backlight(struct drm_panel *panel)
+{
+ struct tinydrm_device *tdev = tinydrm_from_panel(panel);
+
+ if (tdev->backlight) {
+ if (tdev->backlight->props.brightness == 0)
+ tdev->backlight->props.brightness =
+ tdev->backlight->props.max_brightness;
+ tdev->backlight->props.state &= ~BL_CORE_SUSPENDED;
+ backlight_update_status(tdev->backlight);
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(tinydrm_panel_enable_backlight);
+
+int tinydrm_panel_disable_backlight(struct drm_panel *panel)
+{
+ struct tinydrm_device *tdev = tinydrm_from_panel(panel);
+
+ if (tdev->backlight) {
+ tdev->backlight->props.state |= BL_CORE_SUSPENDED;
+ backlight_update_status(tdev->backlight);
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(tinydrm_panel_disable_backlight);
+
+static int __maybe_unused tinydrm_pm_suspend(struct device *dev)
+{
+ struct tinydrm_device *tdev = dev_get_drvdata(dev);
+
+ tinydrm_disable(tdev);
+ tinydrm_unprepare(tdev);
+
+ return 0;
+}
+
+static int __maybe_unused tinydrm_pm_resume(struct device *dev)
+{
+ struct tinydrm_device *tdev = dev_get_drvdata(dev);
+
+ tinydrm_prepare(tdev);
+ /* The panel is enabled after the first display update */
+
+ return 0;
+}
+
+const struct dev_pm_ops tinydrm_simple_pm_ops = {
+ SET_SYSTEM_SLEEP_PM_OPS(tinydrm_pm_suspend, tinydrm_pm_resume)
+};
+EXPORT_SYMBOL(tinydrm_simple_pm_ops);
+
+void tinydrm_spi_shutdown(struct spi_device *spi)
+{
+ struct tinydrm_device *tdev = spi_get_drvdata(spi);
+
+ tinydrm_disable(tdev);
+ tinydrm_unprepare(tdev);
+}
+EXPORT_SYMBOL(tinydrm_spi_shutdown);
diff --git a/drivers/gpu/drm/tinydrm/core/tinydrm-plane.c
b/drivers/gpu/drm/tinydrm/core/tinydrm-plane.c
new file mode 100644
index 0000000..7774e8c
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/core/tinydrm-plane.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2016 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 <drm/drmP.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_plane_helper.h>
+#include <drm/tinydrm/tinydrm.h>
+
+/* TODO: Configurable */
+static const uint32_t tinydrm_formats[] = {
+ DRM_FORMAT_RGB565,
+ DRM_FORMAT_XRGB8888,
+};
+
+static void tinydrm_plane_atomic_update(struct drm_plane *plane,
+ struct drm_plane_state *old_state)
+{
+ DRM_DEBUG("handle 0x%x, crtc %dx%d+%d+%d\n", 0,
+ plane->state->crtc_w, plane->state->crtc_h,
+ plane->state->crtc_x, plane->state->crtc_y);
+}
+
+static const struct drm_plane_helper_funcs tinydrm_plane_helper_funcs = {
+ .atomic_update = tinydrm_plane_atomic_update,
+};
+
+static const struct drm_plane_funcs tinydrm_plane_funcs = {
+ .update_plane = drm_atomic_helper_update_plane,
+ .disable_plane = drm_atomic_helper_disable_plane,
+ .destroy = drm_plane_cleanup,
+ .reset = drm_atomic_helper_plane_reset,
+ .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
+ .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
+};
+
+int tinydrm_plane_init(struct tinydrm_device *tdev)
+{
+ drm_plane_helper_add(&tdev->plane, &tinydrm_plane_helper_funcs);
+ return drm_universal_plane_init(tdev->base, &tdev->plane, 0,
+ &tinydrm_plane_funcs, tinydrm_formats,
+ ARRAY_SIZE(tinydrm_formats),
+ DRM_PLANE_TYPE_PRIMARY);
+}
diff --git a/include/drm/tinydrm/tinydrm.h b/include/drm/tinydrm/tinydrm.h
new file mode 100644
index 0000000..695e483
--- /dev/null
+++ b/include/drm/tinydrm/tinydrm.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2016 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_H
+#define __LINUX_TINYDRM_H
+
+
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_panel.h>
+
+struct tinydrm_deferred;
+struct tinydrm_fbdev;
+struct spi_device;
+struct regulator;
+struct lcdreg;
+
+struct tinydrm_framebuffer {
+ struct drm_framebuffer base;
+ struct drm_gem_cma_object *cma_obj;
+};
+
+struct tinydrm_device {
+ struct drm_device *base;
+ u32 width, height;
+ struct drm_panel panel;
+ struct drm_plane plane;
+ struct tinydrm_fbdev *fbdev;
+ struct tinydrm_deferred *deferred;
+ struct backlight_device *backlight;
+ struct regulator *regulator;
+ struct lcdreg *lcdreg;
+ bool prepared;
+ bool enabled;
+ void *dev_private;
+
+ int (*dirtyfb)(struct drm_framebuffer *fb, void *vmem, unsigned flags,
+ unsigned color, struct drm_clip_rect *clips,
+ unsigned num_clips);
+};
+
+int devm_tinydrm_register(struct device *dev, struct tinydrm_device *tdev);
+int tinydrm_register(struct device *dev, struct tinydrm_device *tdev);
+void tinydrm_release(struct tinydrm_device *tdev);
+
+static inline struct tinydrm_device *tinydrm_from_panel(struct drm_panel
*panel)
+{
+ return panel->connector->dev->dev_private;
+}
+
+static inline void tinydrm_prepare(struct tinydrm_device *tdev)
+{
+ if (!tdev->prepared) {
+ drm_panel_prepare(&tdev->panel);
+ tdev->prepared = true;
+ }
+}
+
+static inline void tinydrm_unprepare(struct tinydrm_device *tdev)
+{
+ if (tdev->prepared) {
+ drm_panel_unprepare(&tdev->panel);
+ tdev->prepared = false;
+ }
+}
+
+static inline void tinydrm_enable(struct tinydrm_device *tdev)
+{
+ if (!tdev->enabled) {
+ drm_panel_enable(&tdev->panel);
+ tdev->enabled = true;
+ }
+}
+
+static inline void tinydrm_disable(struct tinydrm_device *tdev)
+{
+ if (tdev->enabled) {
+ drm_panel_disable(&tdev->panel);
+ tdev->enabled = false;
+ }
+}
+
+struct backlight_device *tinydrm_of_find_backlight(struct device *dev);
+int tinydrm_panel_enable_backlight(struct drm_panel *panel);
+int tinydrm_panel_disable_backlight(struct drm_panel *panel);
+extern const struct dev_pm_ops tinydrm_simple_pm_ops;
+void tinydrm_spi_shutdown(struct spi_device *spi);
+
+struct tinydrm_fb_clip {
+ struct drm_framebuffer *fb;
+ struct drm_clip_rect clip;
+ void *vmem;
+};
+
+struct tinydrm_deferred {
+ struct delayed_work dwork;
+ struct tinydrm_fb_clip fb_clip;
+ unsigned defer_ms;
+ spinlock_t lock;
+ bool no_delay;
+};
+
+static inline struct tinydrm_device *work_to_tinydrm(struct work_struct *work)
+{
+ struct tinydrm_deferred *deferred;
+
+ deferred = container_of(work, struct tinydrm_deferred, dwork.work);
+ return deferred->fb_clip.fb->dev->dev_private;
+}
+
+bool tinydrm_deferred_begin(struct tinydrm_device *tdev,
+ struct tinydrm_fb_clip *fb_clip);
+void tinydrm_deferred_end(struct tinydrm_device *tdev);
+int tinydrm_dirtyfb(struct drm_framebuffer *fb, void *vmem, unsigned flags,
+ unsigned color, struct drm_clip_rect *clips,
+ unsigned num_clips);
+
+static inline bool tinydrm_is_full_clip(struct drm_clip_rect *clip, u32 width,
u32 height)
+{
+ return clip->x1 == 0 && clip->x2 >= (width - 1) &&
+ clip->y1 == 0 && clip->y2 >= (height -1);
+}
+
+static inline void tinydrm_reset_clip(struct drm_clip_rect *clip)
+{
+ clip->x1 = ~0;
+ clip->x2 = 0;
+ clip->y1 = ~0;
+ clip->y2 = 0;
+}
+
+void tinydrm_merge_clips(struct drm_clip_rect *dst,
+ struct drm_clip_rect *clips, unsigned num_clips,
+ unsigned flags, u32 width, u32 height);
+
+#endif /* __LINUX_TINYDRM_H */
--
2.2.2
