From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <linux-kernel-owner@vger.kernel.org>
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
        id S1751441AbdBKSul (ORCPT <rfc822;w@1wt.eu>);
        Sat, 11 Feb 2017 13:50:41 -0500
Received: from smtp.domeneshop.no ([194.63.252.55]:33907 "EHLO
        smtp.domeneshop.no" rhost-flags-OK-OK-OK-OK) by vger.kernel.org
        with ESMTP id S1750779AbdBKStK (ORCPT
        <rfc822;linux-kernel@vger.kernel.org>);
        Sat, 11 Feb 2017 13:49:10 -0500
From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
To: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org
Cc: robh@kernel.org, thomas.petazzoni@free-electrons.com,
        linux-kernel@vger.kernel.org,
        =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
Subject: [PATCH v4 3/7] drm/tinydrm: Add MIPI DBI support
Date: Sat, 11 Feb 2017 19:48:54 +0100
Message-Id: <20170211184858.26421-4-noralf@tronnes.org>
X-Mailer: git-send-email 2.10.2
In-Reply-To: <20170211184858.26421-1-noralf@tronnes.org>
References: <20170211184858.26421-1-noralf@tronnes.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Sender: linux-kernel-owner@vger.kernel.org
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

Add support for MIPI DBI compatible controllers.
Interface type C option 1 and 3 are supported (SPI).

Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
Acked-by: Thierry Reding <treding@nvidia.com>
---

Changes since version 3:
- Use #if IS_ENABLED(CONFIG_SPI) instead of #ifdef to handle tristate

 Documentation/gpu/tinydrm.rst      |   12 +
 drivers/gpu/drm/tinydrm/Kconfig    |    3 +
 drivers/gpu/drm/tinydrm/Makefile   |    3 +
 drivers/gpu/drm/tinydrm/mipi-dbi.c | 1005 ++++++++++++++++++++++++++++++++++++
 include/drm/tinydrm/mipi-dbi.h     |  107 ++++
 5 files changed, 1130 insertions(+)
 create mode 100644 drivers/gpu/drm/tinydrm/mipi-dbi.c
 create mode 100644 include/drm/tinydrm/mipi-dbi.h

diff --git a/Documentation/gpu/tinydrm.rst b/Documentation/gpu/tinydrm.rst
index fb256d2..a913644 100644
--- a/Documentation/gpu/tinydrm.rst
+++ b/Documentation/gpu/tinydrm.rst
@@ -28,3 +28,15 @@ Additional helpers

 .. kernel-doc:: drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c
    :export:
+
+MIPI DBI Compatible Controllers
+===============================
+
+.. kernel-doc:: drivers/gpu/drm/tinydrm/mipi-dbi.c
+   :doc: overview
+
+.. kernel-doc:: include/drm/tinydrm/mipi-dbi.h
+   :internal:
+
+.. kernel-doc:: drivers/gpu/drm/tinydrm/mipi-dbi.c
+   :export:
diff --git a/drivers/gpu/drm/tinydrm/Kconfig b/drivers/gpu/drm/tinydrm/Kconfig
index adf3626..e00bcfc 100644
--- a/drivers/gpu/drm/tinydrm/Kconfig
+++ b/drivers/gpu/drm/tinydrm/Kconfig
@@ -8,3 +8,6 @@ menuconfig DRM_TINYDRM
 	help
 	  Choose this option if you have a tinydrm supported display.
 	  If M is selected the module will be called tinydrm.
+
+config TINYDRM_MIPI_DBI
+	tristate
diff --git a/drivers/gpu/drm/tinydrm/Makefile b/drivers/gpu/drm/tinydrm/Makefile
index 7476ed1..fe5d4c6 100644
--- a/drivers/gpu/drm/tinydrm/Makefile
+++ b/drivers/gpu/drm/tinydrm/Makefile
@@ -1 +1,4 @@
 obj-$(CONFIG_DRM_TINYDRM)		+= core/
+
+# Controllers
+obj-$(CONFIG_TINYDRM_MIPI_DBI)		+= mipi-dbi.o
diff --git a/drivers/gpu/drm/tinydrm/mipi-dbi.c b/drivers/gpu/drm/tinydrm/mipi-dbi.c
new file mode 100644
index 0000000..07d49ba
--- /dev/null
+++ b/drivers/gpu/drm/tinydrm/mipi-dbi.c
@@ -0,0 +1,1005 @@
+/*
+ * MIPI Display Bus Interface (DBI) LCD controller support
+ *
+ * Copyright 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/tinydrm/mipi-dbi.h>
+#include <drm/tinydrm/tinydrm-helpers.h>
+#include <linux/debugfs.h>
+#include <linux/dma-buf.h>
+#include <linux/gpio/consumer.h>
+#include <linux/module.h>
+#include <linux/regulator/consumer.h>
+#include <linux/spi/spi.h>
+#include <video/mipi_display.h>
+
+#define MIPI_DBI_MAX_SPI_READ_SPEED 2000000 /* 2MHz */
+
+#define DCS_POWER_MODE_DISPLAY			BIT(2)
+#define DCS_POWER_MODE_DISPLAY_NORMAL_MODE	BIT(3)
+#define DCS_POWER_MODE_SLEEP_MODE		BIT(4)
+#define DCS_POWER_MODE_PARTIAL_MODE		BIT(5)
+#define DCS_POWER_MODE_IDLE_MODE		BIT(6)
+#define DCS_POWER_MODE_RESERVED_MASK		(BIT(0) | BIT(1) | BIT(7))
+
+/**
+ * DOC: overview
+ *
+ * This library provides helpers for MIPI Display Bus Interface (DBI)
+ * compatible display controllers.
+ *
+ * Many controllers for tiny lcd displays are MIPI compliant and can use this
+ * library. If a controller uses registers 0x2A and 0x2B to set the area to
+ * update and uses register 0x2C to write to frame memory, it is most likely
+ * MIPI compliant.
+ *
+ * Only MIPI Type 1 displays are supported since a full frame memory is needed.
+ *
+ * There are 3 MIPI DBI implementation types:
+ *
+ * A. Motorola 6800 type parallel bus
+ *
+ * B. Intel 8080 type parallel bus
+ *
+ * C. SPI type with 3 options:
+ *
+ *    1. 9-bit with the Data/Command signal as the ninth bit
+ *    2. Same as above except it's sent as 16 bits
+ *    3. 8-bit with the Data/Command signal as a separate D/CX pin
+ *
+ * Currently mipi_dbi only supports Type C options 1 and 3 with
+ * mipi_dbi_spi_init().
+ */
+
+#define MIPI_DBI_DEBUG_COMMAND(cmd, data, len) \
+({ \
+	if (!len) \
+		DRM_DEBUG_DRIVER("cmd=%02x\n", cmd); \
+	else if (len <= 32) \
+		DRM_DEBUG_DRIVER("cmd=%02x, par=%*ph\n", cmd, len, data); \
+	else \
+		DRM_DEBUG_DRIVER("cmd=%02x, len=%zu\n", cmd, len); \
+})
+
+static const u8 mipi_dbi_dcs_read_commands[] = {
+	MIPI_DCS_GET_DISPLAY_ID,
+	MIPI_DCS_GET_RED_CHANNEL,
+	MIPI_DCS_GET_GREEN_CHANNEL,
+	MIPI_DCS_GET_BLUE_CHANNEL,
+	MIPI_DCS_GET_DISPLAY_STATUS,
+	MIPI_DCS_GET_POWER_MODE,
+	MIPI_DCS_GET_ADDRESS_MODE,
+	MIPI_DCS_GET_PIXEL_FORMAT,
+	MIPI_DCS_GET_DISPLAY_MODE,
+	MIPI_DCS_GET_SIGNAL_MODE,
+	MIPI_DCS_GET_DIAGNOSTIC_RESULT,
+	MIPI_DCS_READ_MEMORY_START,
+	MIPI_DCS_READ_MEMORY_CONTINUE,
+	MIPI_DCS_GET_SCANLINE,
+	MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
+	MIPI_DCS_GET_CONTROL_DISPLAY,
+	MIPI_DCS_GET_POWER_SAVE,
+	MIPI_DCS_GET_CABC_MIN_BRIGHTNESS,
+	MIPI_DCS_READ_DDB_START,
+	MIPI_DCS_READ_DDB_CONTINUE,
+	0, /* sentinel */
+};
+
+static bool mipi_dbi_command_is_read(struct mipi_dbi *mipi, u8 cmd)
+{
+	unsigned int i;
+
+	if (!mipi->read_commands)
+		return false;
+
+	for (i = 0; i < 0xff; i++) {
+		if (!mipi->read_commands[i])
+			return false;
+		if (cmd == mipi->read_commands[i])
+			return true;
+	}
+
+	return false;
+}
+
+/**
+ * mipi_dbi_command_read - MIPI DCS read command
+ * @mipi: MIPI structure
+ * @cmd: Command
+ * @val: Value read
+ *
+ * Send MIPI DCS read command to the controller.
+ *
+ * Returns:
+ * Zero on success, negative error code on failure.
+ */
+int mipi_dbi_command_read(struct mipi_dbi *mipi, u8 cmd, u8 *val)
+{
+	if (!mipi->read_commands)
+		return -EACCES;
+
+	if (!mipi_dbi_command_is_read(mipi, cmd))
+		return -EINVAL;
+
+	return mipi_dbi_command_buf(mipi, cmd, val, 1);
+}
+EXPORT_SYMBOL(mipi_dbi_command_read);
+
+/**
+ * mipi_dbi_command_buf - MIPI DCS command with parameter(s) in an array
+ * @mipi: MIPI structure
+ * @cmd: Command
+ * @data: Parameter buffer
+ * @len: Buffer length
+ *
+ * Returns:
+ * Zero on success, negative error code on failure.
+ */
+int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len)
+{
+	int ret;
+
+	mutex_lock(&mipi->cmdlock);
+	ret = mipi->command(mipi, cmd, data, len);
+	mutex_unlock(&mipi->cmdlock);
+
+	return ret;
+}
+EXPORT_SYMBOL(mipi_dbi_command_buf);
+
+static int mipi_dbi_buf_copy(void *dst, struct drm_framebuffer *fb,
+				struct drm_clip_rect *clip, bool swap)
+{
+	struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
+	struct dma_buf_attachment *import_attach = cma_obj->base.import_attach;
+	struct drm_format_name_buf format_name;
+	void *src = cma_obj->vaddr;
+	int ret = 0;
+
+	if (import_attach) {
+		ret = dma_buf_begin_cpu_access(import_attach->dmabuf,
+					       DMA_FROM_DEVICE);
+		if (ret)
+			return ret;
+	}
+
+	switch (fb->format->format) {
+	case DRM_FORMAT_RGB565:
+		if (swap)
+			tinydrm_swab16(dst, src, fb, clip);
+		else
+			tinydrm_memcpy(dst, src, fb, clip);
+		break;
+	case DRM_FORMAT_XRGB8888:
+		tinydrm_xrgb8888_to_rgb565(dst, src, fb, clip, swap);
+		break;
+	default:
+		dev_err_once(fb->dev->dev, "Format is not supported: %s\n",
+			     drm_get_format_name(fb->format->format,
+						 &format_name));
+		return -EINVAL;
+	}
+
+	if (import_attach)
+		ret = dma_buf_end_cpu_access(import_attach->dmabuf,
+					     DMA_FROM_DEVICE);
+	return ret;
+}
+
+static int mipi_dbi_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 drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
+	struct tinydrm_device *tdev = fb->dev->dev_private;
+	struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
+	bool swap = mipi->swap_bytes;
+	struct drm_clip_rect clip;
+	int ret = 0;
+	bool full;
+	void *tr;
+
+	mutex_lock(&tdev->dirty_lock);
+
+	if (!mipi->enabled)
+		goto out_unlock;
+
+	/* fbdev can flush even when we're not interested */
+	if (tdev->pipe.plane.fb != fb)
+		goto out_unlock;
+
+	full = tinydrm_merge_clips(&clip, clips, num_clips, flags,
+				   fb->width, fb->height);
+
+	DRM_DEBUG("Flushing [FB:%d] x1=%u, x2=%u, y1=%u, y2=%u\n", fb->base.id,
+		  clip.x1, clip.x2, clip.y1, clip.y2);
+
+	if (!mipi->dc || !full || swap ||
+	    fb->format->format == DRM_FORMAT_XRGB8888) {
+		tr = mipi->tx_buf;
+		ret = mipi_dbi_buf_copy(mipi->tx_buf, fb, &clip, swap);
+		if (ret)
+			goto out_unlock;
+	} else {
+		tr = cma_obj->vaddr;
+	}
+
+	mipi_dbi_command(mipi, MIPI_DCS_SET_COLUMN_ADDRESS,
+			 (clip.x1 >> 8) & 0xFF, clip.x1 & 0xFF,
+			 (clip.x2 >> 8) & 0xFF, (clip.x2 - 1) & 0xFF);
+	mipi_dbi_command(mipi, MIPI_DCS_SET_PAGE_ADDRESS,
+			 (clip.y1 >> 8) & 0xFF, clip.y1 & 0xFF,
+			 (clip.y2 >> 8) & 0xFF, (clip.y2 - 1) & 0xFF);
+
+	ret = mipi_dbi_command_buf(mipi, MIPI_DCS_WRITE_MEMORY_START, tr,
+				(clip.x2 - clip.x1) * (clip.y2 - clip.y1) * 2);
+
+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 mipi_dbi_fb_funcs = {
+	.destroy	= drm_fb_cma_destroy,
+	.create_handle	= drm_fb_cma_create_handle,
+	.dirty		= mipi_dbi_fb_dirty,
+};
+
+/**
+ * mipi_dbi_pipe_enable - MIPI DBI pipe enable helper
+ * @pipe: Display pipe
+ * @crtc_state: CRTC state
+ *
+ * This function enables backlight. Drivers can use this as their
+ * &drm_simple_display_pipe_funcs->enable callback.
+ */
+void mipi_dbi_pipe_enable(struct drm_simple_display_pipe *pipe,
+			  struct drm_crtc_state *crtc_state)
+{
+	struct tinydrm_device *tdev = pipe_to_tinydrm(pipe);
+	struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
+	struct drm_framebuffer *fb = pipe->plane.fb;
+
+	DRM_DEBUG_KMS("\n");
+
+	mipi->enabled = true;
+	if (fb)
+		fb->funcs->dirty(fb, NULL, 0, 0, NULL, 0);
+
+	tinydrm_enable_backlight(mipi->backlight);
+}
+EXPORT_SYMBOL(mipi_dbi_pipe_enable);
+
+static void mipi_dbi_blank(struct mipi_dbi *mipi)
+{
+	struct drm_device *drm = mipi->tinydrm.drm;
+	u16 height = drm->mode_config.min_height;
+	u16 width = drm->mode_config.min_width;
+	size_t len = width * height * 2;
+
+	memset(mipi->tx_buf, 0, len);
+
+	mipi_dbi_command(mipi, MIPI_DCS_SET_COLUMN_ADDRESS, 0, 0,
+			 (width >> 8) & 0xFF, (width - 1) & 0xFF);
+	mipi_dbi_command(mipi, MIPI_DCS_SET_PAGE_ADDRESS, 0, 0,
+			 (height >> 8) & 0xFF, (height - 1) & 0xFF);
+	mipi_dbi_command_buf(mipi, MIPI_DCS_WRITE_MEMORY_START,
+			     (u8 *)mipi->tx_buf, len);
+}
+
+/**
+ * mipi_dbi_pipe_disable - MIPI DBI pipe disable helper
+ * @pipe: Display pipe
+ *
+ * This function disables backlight if present or if not the
+ * display memory is blanked. Drivers can use this as their
+ * &drm_simple_display_pipe_funcs->disable callback.
+ */
+void mipi_dbi_pipe_disable(struct drm_simple_display_pipe *pipe)
+{
+	struct tinydrm_device *tdev = pipe_to_tinydrm(pipe);
+	struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
+
+	DRM_DEBUG_KMS("\n");
+
+	mipi->enabled = false;
+
+	if (mipi->backlight)
+		tinydrm_disable_backlight(mipi->backlight);
+	else
+		mipi_dbi_blank(mipi);
+}
+EXPORT_SYMBOL(mipi_dbi_pipe_disable);
+
+static const uint32_t mipi_dbi_formats[] = {
+	DRM_FORMAT_RGB565,
+	DRM_FORMAT_XRGB8888,
+};
+
+/**
+ * mipi_dbi_init - MIPI DBI initialization
+ * @dev: Parent device
+ * @mipi: &mipi_dbi structure to initialize
+ * @pipe_funcs: Display pipe functions
+ * @driver: DRM driver
+ * @mode: Display mode
+ * @rotation: Initial rotation in degrees Counter Clock Wise
+ *
+ * This function initializes a &mipi_dbi structure and it's underlying
+ * @tinydrm_device. It also sets up the display pipeline.
+ *
+ * Supported formats: Native RGB565 and emulated XRGB8888.
+ *
+ * Objects created by this function will be automatically freed on driver
+ * detach (devres).
+ *
+ * Returns:
+ * Zero on success, negative error code on failure.
+ */
+int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi,
+		  const struct drm_simple_display_pipe_funcs *pipe_funcs,
+		  struct drm_driver *driver,
+		  const struct drm_display_mode *mode, unsigned int rotation)
+{
+	size_t bufsize = mode->vdisplay * mode->hdisplay * sizeof(u16);
+	struct tinydrm_device *tdev = &mipi->tinydrm;
+	int ret;
+
+	if (!mipi->command)
+		return -EINVAL;
+
+	mutex_init(&mipi->cmdlock);
+
+	mipi->tx_buf = devm_kmalloc(dev, bufsize, GFP_KERNEL);
+	if (!mipi->tx_buf)
+		return -ENOMEM;
+
+	ret = devm_tinydrm_init(dev, tdev, &mipi_dbi_fb_funcs, driver);
+	if (ret)
+		return ret;
+
+	/* TODO: Maybe add DRM_MODE_CONNECTOR_SPI */
+	ret = tinydrm_display_pipe_init(tdev, pipe_funcs,
+					DRM_MODE_CONNECTOR_VIRTUAL,
+					mipi_dbi_formats,
+					ARRAY_SIZE(mipi_dbi_formats), mode,
+					rotation);
+	if (ret)
+		return ret;
+
+	tdev->drm->mode_config.preferred_depth = 16;
+	mipi->rotation = rotation;
+
+	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(mipi_dbi_init);
+
+/**
+ * mipi_dbi_hw_reset - Hardware reset of controller
+ * @mipi: MIPI DBI structure
+ *
+ * Reset controller if the &mipi_dbi->reset gpio is set.
+ */
+void mipi_dbi_hw_reset(struct mipi_dbi *mipi)
+{
+	if (!mipi->reset)
+		return;
+
+	gpiod_set_value_cansleep(mipi->reset, 0);
+	msleep(20);
+	gpiod_set_value_cansleep(mipi->reset, 1);
+	msleep(120);
+}
+EXPORT_SYMBOL(mipi_dbi_hw_reset);
+
+/**
+ * mipi_dbi_display_is_on - Check if display is on
+ * @mipi: MIPI DBI structure
+ *
+ * This function checks the Power Mode register (if readable) to see if
+ * display output is turned on. This can be used to see if the bootloader
+ * has already turned on the display avoiding flicker when the pipeline is
+ * enabled.
+ *
+ * Returns:
+ * true if the display can be verified to be on, false otherwise.
+ */
+bool mipi_dbi_display_is_on(struct mipi_dbi *mipi)
+{
+	u8 val;
+
+	if (mipi_dbi_command_read(mipi, MIPI_DCS_GET_POWER_MODE, &val))
+		return false;
+
+	val &= ~DCS_POWER_MODE_RESERVED_MASK;
+
+	if (val != (DCS_POWER_MODE_DISPLAY |
+	    DCS_POWER_MODE_DISPLAY_NORMAL_MODE | DCS_POWER_MODE_SLEEP_MODE))
+		return false;
+
+	DRM_DEBUG_DRIVER("Display is ON\n");
+
+	return true;
+}
+EXPORT_SYMBOL(mipi_dbi_display_is_on);
+
+#if IS_ENABLED(CONFIG_SPI)
+
+/*
+ * Many controllers have a max speed of 10MHz, but can be pushed way beyond
+ * that. Increase reliability by running pixel data at max speed and the rest
+ * at 10MHz, preventing transfer glitches from messing up the init settings.
+ */
+static u32 mipi_dbi_spi_cmd_max_speed(struct spi_device *spi, size_t len)
+{
+	if (len > 64)
+		return 0; /* use default */
+
+	return min_t(u32, 10000000, spi->max_speed_hz);
+}
+
+/*
+ * MIPI DBI Type C Option 1
+ *
+ * If the SPI controller doesn't have 9 bits per word support,
+ * use blocks of 9 bytes to send 8x 9-bit words using a 8-bit SPI transfer.
+ * Pad partial blocks with MIPI_DCS_NOP (zero).
+ * This is how the D/C bit (x) is added:
+ *     x7654321
+ *     0x765432
+ *     10x76543
+ *     210x7654
+ *     3210x765
+ *     43210x76
+ *     543210x7
+ *     6543210x
+ *     76543210
+ */
+
+static int mipi_dbi_spi1e_transfer(struct mipi_dbi *mipi, int dc,
+				   const void *buf, size_t len,
+				   unsigned int bpw)
+{
+	bool swap_bytes = (bpw == 16 && tinydrm_machine_little_endian());
+	size_t chunk, max_chunk = mipi->tx_buf9_len;
+	struct spi_device *spi = mipi->spi;
+	struct spi_transfer tr = {
+		.tx_buf = mipi->tx_buf9,
+		.bits_per_word = 8,
+	};
+	struct spi_message m;
+	const u8 *src = buf;
+	int i, ret;
+	u8 *dst;
+
+	if (drm_debug & DRM_UT_DRIVER)
+		pr_debug("[drm:%s] dc=%d, max_chunk=%zu, transfers:\n",
+			 __func__, dc, max_chunk);
+
+	tr.speed_hz = mipi_dbi_spi_cmd_max_speed(spi, len);
+	spi_message_init_with_transfers(&m, &tr, 1);
+
+	if (!dc) {
+		if (WARN_ON_ONCE(len != 1))
+			return -EINVAL;
+
+		/* Command: pad no-op's (zeroes) at beginning of block */
+		dst = mipi->tx_buf9;
+		memset(dst, 0, 9);
+		dst[8] = *src;
+		tr.len = 9;
+
+		tinydrm_dbg_spi_message(spi, &m);
+
+		return spi_sync(spi, &m);
+	}
+
+	/* max with room for adding one bit per byte */
+	max_chunk = max_chunk / 9 * 8;
+	/* but no bigger than len */
+	max_chunk = min(max_chunk, len);
+	/* 8 byte blocks */
+	max_chunk = max_t(size_t, 8, max_chunk & ~0x7);
+
+	while (len) {
+		size_t added = 0;
+
+		chunk = min(len, max_chunk);
+		len -= chunk;
+		dst = mipi->tx_buf9;
+
+		if (chunk < 8) {
+			u8 val, carry = 0;
+
+			/* Data: pad no-op's (zeroes) at end of block */
+			memset(dst, 0, 9);
+
+			if (swap_bytes) {
+				for (i = 1; i < (chunk + 1); i++) {
+					val = src[1];
+					*dst++ = carry | BIT(8 - i) | (val >> i);
+					carry = val << (8 - i);
+					i++;
+					val = src[0];
+					*dst++ = carry | BIT(8 - i) | (val >> i);
+					carry = val << (8 - i);
+					src += 2;
+				}
+				*dst++ = carry;
+			} else {
+				for (i = 1; i < (chunk + 1); i++) {
+					val = *src++;
+					*dst++ = carry | BIT(8 - i) | (val >> i);
+					carry = val << (8 - i);
+				}
+				*dst++ = carry;
+			}
+
+			chunk = 8;
+			added = 1;
+		} else {
+			for (i = 0; i < chunk; i += 8) {
+				if (swap_bytes) {
+					*dst++ =                 BIT(7) | (src[1] >> 1);
+					*dst++ = (src[1] << 7) | BIT(6) | (src[0] >> 2);
+					*dst++ = (src[0] << 6) | BIT(5) | (src[3] >> 3);
+					*dst++ = (src[3] << 5) | BIT(4) | (src[2] >> 4);
+					*dst++ = (src[2] << 4) | BIT(3) | (src[5] >> 5);
+					*dst++ = (src[5] << 3) | BIT(2) | (src[4] >> 6);
+					*dst++ = (src[4] << 2) | BIT(1) | (src[7] >> 7);
+					*dst++ = (src[7] << 1) | BIT(0);
+					*dst++ = src[6];
+				} else {
+					*dst++ =                 BIT(7) | (src[0] >> 1);
+					*dst++ = (src[0] << 7) | BIT(6) | (src[1] >> 2);
+					*dst++ = (src[1] << 6) | BIT(5) | (src[2] >> 3);
+					*dst++ = (src[2] << 5) | BIT(4) | (src[3] >> 4);
+					*dst++ = (src[3] << 4) | BIT(3) | (src[4] >> 5);
+					*dst++ = (src[4] << 3) | BIT(2) | (src[5] >> 6);
+					*dst++ = (src[5] << 2) | BIT(1) | (src[6] >> 7);
+					*dst++ = (src[6] << 1) | BIT(0);
+					*dst++ = src[7];
+				}
+
+				src += 8;
+				added++;
+			}
+		}
+
+		tr.len = chunk + added;
+
+		tinydrm_dbg_spi_message(spi, &m);
+		ret = spi_sync(spi, &m);
+		if (ret)
+			return ret;
+	};
+
+	return 0;
+}
+
+static int mipi_dbi_spi1_transfer(struct mipi_dbi *mipi, int dc,
+				  const void *buf, size_t len,
+				  unsigned int bpw)
+{
+	struct spi_device *spi = mipi->spi;
+	struct spi_transfer tr = {
+		.bits_per_word = 9,
+	};
+	const u16 *src16 = buf;
+	const u8 *src8 = buf;
+	struct spi_message m;
+	size_t max_chunk;
+	u16 *dst16;
+	int ret;
+
+	if (!tinydrm_spi_bpw_supported(spi, 9))
+		return mipi_dbi_spi1e_transfer(mipi, dc, buf, len, bpw);
+
+	tr.speed_hz = mipi_dbi_spi_cmd_max_speed(spi, len);
+	max_chunk = mipi->tx_buf9_len;
+	dst16 = mipi->tx_buf9;
+
+	if (drm_debug & DRM_UT_DRIVER)
+		pr_debug("[drm:%s] dc=%d, max_chunk=%zu, transfers:\n",
+			 __func__, dc, max_chunk);
+
+	max_chunk = min(max_chunk / 2, len);
+
+	spi_message_init_with_transfers(&m, &tr, 1);
+	tr.tx_buf = dst16;
+
+	while (len) {
+		size_t chunk = min(len, max_chunk);
+		unsigned int i;
+
+		if (bpw == 16 && tinydrm_machine_little_endian()) {
+			for (i = 0; i < (chunk * 2); i += 2) {
+				dst16[i]     = *src16 >> 8;
+				dst16[i + 1] = *src16++ & 0xFF;
+				if (dc) {
+					dst16[i]     |= 0x0100;
+					dst16[i + 1] |= 0x0100;
+				}
+			}
+		} else {
+			for (i = 0; i < chunk; i++) {
+				dst16[i] = *src8++;
+				if (dc)
+					dst16[i] |= 0x0100;
+			}
+		}
+
+		tr.len = chunk;
+		len -= chunk;
+
+		tinydrm_dbg_spi_message(spi, &m);
+		ret = spi_sync(spi, &m);
+		if (ret)
+			return ret;
+	};
+
+	return 0;
+}
+
+static int mipi_dbi_typec1_command(struct mipi_dbi *mipi, u8 cmd,
+				   u8 *parameters, size_t num)
+{
+	unsigned int bpw = (cmd == MIPI_DCS_WRITE_MEMORY_START) ? 16 : 8;
+	int ret;
+
+	if (mipi_dbi_command_is_read(mipi, cmd))
+		return -ENOTSUPP;
+
+	MIPI_DBI_DEBUG_COMMAND(cmd, parameters, num);
+
+	ret = mipi_dbi_spi1_transfer(mipi, 0, &cmd, 1, 8);
+	if (ret || !num)
+		return ret;
+
+	return mipi_dbi_spi1_transfer(mipi, 1, parameters, num, bpw);
+}
+
+/* MIPI DBI Type C Option 3 */
+
+static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 cmd,
+					u8 *data, size_t len)
+{
+	struct spi_device *spi = mipi->spi;
+	u32 speed_hz = min_t(u32, MIPI_DBI_MAX_SPI_READ_SPEED,
+			     spi->max_speed_hz / 2);
+	struct spi_transfer tr[2] = {
+		{
+			.speed_hz = speed_hz,
+			.tx_buf = &cmd,
+			.len = 1,
+		}, {
+			.speed_hz = speed_hz,
+			.len = len,
+		},
+	};
+	struct spi_message m;
+	u8 *buf;
+	int ret;
+
+	if (!len)
+		return -EINVAL;
+
+	/*
+	 * Support non-standard 24-bit and 32-bit Nokia read commands which
+	 * start with a dummy clock, so we need to read an extra byte.
+	 */
+	if (cmd == MIPI_DCS_GET_DISPLAY_ID ||
+	    cmd == MIPI_DCS_GET_DISPLAY_STATUS) {
+		if (!(len == 3 || len == 4))
+			return -EINVAL;
+
+		tr[1].len = len + 1;
+	}
+
+	buf = kmalloc(tr[1].len, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	tr[1].rx_buf = buf;
+	gpiod_set_value_cansleep(mipi->dc, 0);
+
+	spi_message_init_with_transfers(&m, tr, ARRAY_SIZE(tr));
+	ret = spi_sync(spi, &m);
+	if (ret)
+		goto err_free;
+
+	tinydrm_dbg_spi_message(spi, &m);
+
+	if (tr[1].len == len) {
+		memcpy(data, buf, len);
+	} else {
+		unsigned int i;
+
+		for (i = 0; i < len; i++)
+			data[i] = (buf[i] << 1) | !!(buf[i + 1] & BIT(7));
+	}
+
+	MIPI_DBI_DEBUG_COMMAND(cmd, data, len);
+
+err_free:
+	kfree(buf);
+
+	return ret;
+}
+
+static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd,
+				   u8 *par, size_t num)
+{
+	struct spi_device *spi = mipi->spi;
+	unsigned int bpw = 8;
+	u32 speed_hz;
+	int ret;
+
+	if (mipi_dbi_command_is_read(mipi, cmd))
+		return mipi_dbi_typec3_command_read(mipi, cmd, par, num);
+
+	MIPI_DBI_DEBUG_COMMAND(cmd, par, num);
+
+	gpiod_set_value_cansleep(mipi->dc, 0);
+	speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1);
+	ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1);
+	if (ret || !num)
+		return ret;
+
+	if (cmd == MIPI_DCS_WRITE_MEMORY_START && !mipi->swap_bytes)
+		bpw = 16;
+
+	gpiod_set_value_cansleep(mipi->dc, 1);
+	speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num);
+
+	return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, num);
+}
+
+/**
+ * mipi_dbi_spi_init - Initialize MIPI DBI SPI interfaced controller
+ * @spi: SPI device
+ * @dc: D/C gpio (optional)
+ * @mipi: &mipi_dbi structure to initialize
+ * @pipe_funcs: Display pipe functions
+ * @driver: DRM driver
+ * @mode: Display mode
+ * @rotation: Initial rotation in degrees Counter Clock Wise
+ *
+ * This function sets &mipi_dbi->command, enables &mipi->read_commands for the
+ * usual read commands and initializes @mipi using mipi_dbi_init().
+ *
+ * If @dc is set, a Type C Option 3 interface is assumed, if not
+ * Type C Option 1.
+ *
+ * If the SPI master driver doesn't support the necessary bits per word,
+ * the following transformation is used:
+ *
+ * - 9-bit: reorder buffer as 9x 8-bit words, padded with no-op command.
+ * - 16-bit: if big endian send as 8-bit, if little endian swap bytes
+ *
+ * Returns:
+ * Zero on success, negative error code on failure.
+ */
+int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi,
+		      struct gpio_desc *dc,
+		      const struct drm_simple_display_pipe_funcs *pipe_funcs,
+		      struct drm_driver *driver,
+		      const struct drm_display_mode *mode,
+		      unsigned int rotation)
+{
+	size_t tx_size = tinydrm_spi_max_transfer_size(spi, 0);
+	struct device *dev = &spi->dev;
+	int ret;
+
+	if (tx_size < 16) {
+		DRM_ERROR("SPI transmit buffer too small: %zu\n", tx_size);
+		return -EINVAL;
+	}
+
+	/*
+	 * Even though it's not the SPI device that does DMA (the master does),
+	 * the dma mask is necessary for the dma_alloc_wc() in
+	 * drm_gem_cma_create(). The dma_addr returned will be a physical
+	 * adddress which might be different from the bus address, but this is
+	 * not a problem since the address will not be used.
+	 * The virtual address is used in the transfer and the SPI core
+	 * re-maps it on the SPI master device using the DMA streaming API
+	 * (spi_map_buf()).
+	 */
+	if (!dev->coherent_dma_mask) {
+		ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+		if (ret) {
+			dev_warn(dev, "Failed to set dma mask %d\n", ret);
+			return ret;
+		}
+	}
+
+	mipi->spi = spi;
+	mipi->read_commands = mipi_dbi_dcs_read_commands;
+
+	if (dc) {
+		mipi->command = mipi_dbi_typec3_command;
+		mipi->dc = dc;
+		if (tinydrm_machine_little_endian() &&
+		    !tinydrm_spi_bpw_supported(spi, 16))
+			mipi->swap_bytes = true;
+	} else {
+		mipi->command = mipi_dbi_typec1_command;
+		mipi->tx_buf9_len = tx_size;
+		mipi->tx_buf9 = devm_kmalloc(dev, tx_size, GFP_KERNEL);
+		if (!mipi->tx_buf9)
+			return -ENOMEM;
+	}
+
+	return mipi_dbi_init(dev, mipi, pipe_funcs, driver, mode, rotation);
+}
+EXPORT_SYMBOL(mipi_dbi_spi_init);
+
+#endif /* CONFIG_SPI */
+
+#ifdef CONFIG_DEBUG_FS
+
+static ssize_t mipi_dbi_debugfs_command_write(struct file *file,
+					      const char __user *ubuf,
+					      size_t count, loff_t *ppos)
+{
+	struct seq_file *m = file->private_data;
+	struct mipi_dbi *mipi = m->private;
+	u8 val, cmd, parameters[64];
+	char *buf, *pos, *token;
+	unsigned int i;
+	int ret;
+
+	buf = memdup_user_nul(ubuf, count);
+	if (IS_ERR(buf))
+		return PTR_ERR(buf);
+
+	/* strip trailing whitespace */
+	for (i = count - 1; i > 0; i--)
+		if (isspace(buf[i]))
+			buf[i] = '\0';
+		else
+			break;
+	i = 0;
+	pos = buf;
+	while (pos) {
+		token = strsep(&pos, " ");
+		if (!token) {
+			ret = -EINVAL;
+			goto err_free;
+		}
+
+		ret = kstrtou8(token, 16, &val);
+		if (ret < 0)
+			goto err_free;
+
+		if (token == buf)
+			cmd = val;
+		else
+			parameters[i++] = val;
+
+		if (i == 64) {
+			ret = -E2BIG;
+			goto err_free;
+		}
+	}
+
+	ret = mipi_dbi_command_buf(mipi, cmd, parameters, i);
+
+err_free:
+	kfree(buf);
+
+	return ret < 0 ? ret : count;
+}
+
+static int mipi_dbi_debugfs_command_show(struct seq_file *m, void *unused)
+{
+	struct mipi_dbi *mipi = m->private;
+	u8 cmd, val[4];
+	size_t len, i;
+	int ret;
+
+	for (cmd = 0; cmd < 255; cmd++) {
+		if (!mipi_dbi_command_is_read(mipi, cmd))
+			continue;
+
+		switch (cmd) {
+		case MIPI_DCS_READ_MEMORY_START:
+		case MIPI_DCS_READ_MEMORY_CONTINUE:
+			len = 2;
+			break;
+		case MIPI_DCS_GET_DISPLAY_ID:
+			len = 3;
+			break;
+		case MIPI_DCS_GET_DISPLAY_STATUS:
+			len = 4;
+			break;
+		default:
+			len = 1;
+			break;
+		}
+
+		seq_printf(m, "%02x: ", cmd);
+		ret = mipi_dbi_command_buf(mipi, cmd, val, len);
+		if (ret) {
+			seq_puts(m, "XX\n");
+			continue;
+		}
+
+		for (i = 0; i < len; i++)
+			seq_printf(m, "%02x", val[i]);
+		seq_puts(m, "\n");
+	}
+
+	return 0;
+}
+
+static int mipi_dbi_debugfs_command_open(struct inode *inode,
+					 struct file *file)
+{
+	return single_open(file, mipi_dbi_debugfs_command_show,
+			   inode->i_private);
+}
+
+static const struct file_operations mipi_dbi_debugfs_command_fops = {
+	.owner = THIS_MODULE,
+	.open = mipi_dbi_debugfs_command_open,
+	.read = seq_read,
+	.llseek = seq_lseek,
+	.release = single_release,
+	.write = mipi_dbi_debugfs_command_write,
+};
+
+static const struct drm_info_list mipi_dbi_debugfs_list[] = {
+	{ "fb",   drm_fb_cma_debugfs_show, 0 },
+};
+
+/**
+ * mipi_dbi_debugfs_init - Create debugfs entries
+ * @minor: DRM minor
+ *
+ * This function creates a 'command' debugfs file for sending commands to the
+ * controller or getting the read command values.
+ * Drivers can use this as their &drm_driver->debugfs_init callback.
+ *
+ * Returns:
+ * Zero on success, negative error code on failure.
+ */
+int mipi_dbi_debugfs_init(struct drm_minor *minor)
+{
+	struct tinydrm_device *tdev = minor->dev->dev_private;
+	struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
+	umode_t mode = S_IFREG | S_IWUSR;
+
+	if (mipi->read_commands)
+		mode |= S_IRUGO;
+	debugfs_create_file("command", mode, minor->debugfs_root, mipi,
+			    &mipi_dbi_debugfs_command_fops);
+
+	return drm_debugfs_create_files(mipi_dbi_debugfs_list,
+					ARRAY_SIZE(mipi_dbi_debugfs_list),
+					minor->debugfs_root, minor);
+}
+EXPORT_SYMBOL(mipi_dbi_debugfs_init);
+
+#endif
+
+MODULE_LICENSE("GPL");
diff --git a/include/drm/tinydrm/mipi-dbi.h b/include/drm/tinydrm/mipi-dbi.h
new file mode 100644
index 0000000..d137b16
--- /dev/null
+++ b/include/drm/tinydrm/mipi-dbi.h
@@ -0,0 +1,107 @@
+/*
+ * MIPI Display Bus Interface (DBI) LCD controller support
+ *
+ * Copyright 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_MIPI_DBI_H
+#define __LINUX_MIPI_DBI_H
+
+#include <drm/tinydrm/tinydrm.h>
+
+struct spi_device;
+struct gpio_desc;
+struct regulator;
+
+/**
+ * struct mipi_dbi - MIPI DBI controller
+ * @tinydrm: tinydrm base
+ * @spi: SPI device
+ * @enabled: Pipeline is enabled
+ * @cmdlock: Command lock
+ * @command: Bus specific callback executing commands.
+ * @read_commands: Array of read commands terminated by a zero entry.
+ *                 Reading is disabled if this is NULL.
+ * @dc: Optional D/C gpio.
+ * @tx_buf: Buffer used for transfer (copy clip rect area)
+ * @tx_buf9: Buffer used for Option 1 9-bit conversion
+ * @tx_buf9_len: Size of tx_buf9.
+ * @swap_bytes: Swap bytes in buffer before transfer
+ * @reset: Optional reset gpio
+ * @rotation: initial rotation in degrees Counter Clock Wise
+ * @backlight: backlight device (optional)
+ * @regulator: power regulator (optional)
+ */
+struct mipi_dbi {
+	struct tinydrm_device tinydrm;
+	struct spi_device *spi;
+	bool enabled;
+	struct mutex cmdlock;
+	int (*command)(struct mipi_dbi *mipi, u8 cmd, u8 *param, size_t num);
+	const u8 *read_commands;
+	struct gpio_desc *dc;
+	u16 *tx_buf;
+	void *tx_buf9;
+	size_t tx_buf9_len;
+	bool swap_bytes;
+	struct gpio_desc *reset;
+	unsigned int rotation;
+	struct backlight_device *backlight;
+	struct regulator *regulator;
+};
+
+static inline struct mipi_dbi *
+mipi_dbi_from_tinydrm(struct tinydrm_device *tdev)
+{
+	return container_of(tdev, struct mipi_dbi, tinydrm);
+}
+
+int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi,
+		      struct gpio_desc *dc,
+		      const struct drm_simple_display_pipe_funcs *pipe_funcs,
+		      struct drm_driver *driver,
+		      const struct drm_display_mode *mode,
+		      unsigned int rotation);
+int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi,
+		  const struct drm_simple_display_pipe_funcs *pipe_funcs,
+		  struct drm_driver *driver,
+		  const struct drm_display_mode *mode, unsigned int rotation);
+void mipi_dbi_pipe_enable(struct drm_simple_display_pipe *pipe,
+			  struct drm_crtc_state *crtc_state);
+void mipi_dbi_pipe_disable(struct drm_simple_display_pipe *pipe);
+void mipi_dbi_hw_reset(struct mipi_dbi *mipi);
+bool mipi_dbi_display_is_on(struct mipi_dbi *mipi);
+
+int mipi_dbi_command_read(struct mipi_dbi *mipi, u8 cmd, u8 *val);
+int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len);
+
+/**
+ * mipi_dbi_command - MIPI DCS command with optional parameter(s)
+ * @mipi: MIPI structure
+ * @cmd: Command
+ * @seq...: Optional parameter(s)
+ *
+ * Send MIPI DCS command to the controller. Use mipi_dbi_command_read() for
+ * get/read.
+ *
+ * Returns:
+ * Zero on success, negative error code on failure.
+ */
+#define mipi_dbi_command(mipi, cmd, seq...) \
+({ \
+	u8 d[] = { seq }; \
+	mipi_dbi_command_buf(mipi, cmd, d, ARRAY_SIZE(d)); \
+})
+
+#ifdef CONFIG_DEBUG_FS
+int mipi_dbi_debugfs_init(struct drm_minor *minor);
+#else
+#define mipi_dbi_debugfs_init		NULL
+#endif
+
+#endif /* __LINUX_MIPI_DBI_H */
--
2.10.2

From mboxrd@z Thu Jan  1 00:00:00 1970
From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
Subject: [PATCH v4 3/7] drm/tinydrm: Add MIPI DBI support
Date: Sat, 11 Feb 2017 19:48:54 +0100
Message-ID: <20170211184858.26421-4-noralf@tronnes.org>
References: <20170211184858.26421-1-noralf@tronnes.org>
Mime-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Return-path: <dri-devel-bounces@lists.freedesktop.org>
In-Reply-To: <20170211184858.26421-1-noralf@tronnes.org>
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
To: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org
Cc: thomas.petazzoni@free-electrons.com, linux-kernel@vger.kernel.org
List-Id: devicetree@vger.kernel.org
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