From nobody Mon Feb  9 01:16:44 2026
Received: from mail-pj1-f51.google.com (mail-pj1-f51.google.com
 [209.85.216.51])
	(using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits))
	(No client certificate requested)
	by smtp.subspace.kernel.org (Postfix) with ESMTPS id B4AE1155C88;
	Fri, 31 Jan 2025 06:44:35 +0000 (UTC)
Authentication-Results: smtp.subspace.kernel.org;
 arc=none smtp.client-ip=209.85.216.51
ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116;
	t=1738305878; cv=none;
 b=naqDc9FLtLqHALD8emocNRiC51GVBFPPY8QCGgtYKLPO8WnNUOsIfD6xHuAL1twjaMdFU99W5OKRdi1iuD5IX8U4LfdlqT+q2Im8RFVc6+7mvML0EmpljIsCf/JjVPybbkVRUHIdObkRtXz2M3J8WuB9PsIrLGqbNFtYNJVvymo=
ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org;
	s=arc-20240116; t=1738305878; c=relaxed/simple;
	bh=+QQ0uk9cQsUCxAtzHDM5AHEM7sGxz3Nr/ajhp5LqL4A=;
	h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References:
	 MIME-Version;
 b=knPVxA0bK4XE1avcTrrnHCe58a5ECSNMf13ynwhNHWzriMJ5TrpJccV172PRli7OgO3/MOh2zKZ/8vDLSKCLuAUCXVxTG3r9me9xQwUKY0EBXduKOnW79dls3TJnaRJEkKojHEJSml8qtruUkepVnSY/5wsAbbdeWcRaDgF5p1I=
ARC-Authentication-Results: i=1; smtp.subspace.kernel.org;
 dmarc=pass (p=none dis=none) header.from=gmail.com;
 spf=pass smtp.mailfrom=gmail.com;
 dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com
 header.b=Qj2ZSdlJ; arc=none smtp.client-ip=209.85.216.51
Authentication-Results: smtp.subspace.kernel.org;
 dmarc=pass (p=none dis=none) header.from=gmail.com
Authentication-Results: smtp.subspace.kernel.org;
 spf=pass smtp.mailfrom=gmail.com
Authentication-Results: smtp.subspace.kernel.org;
	dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com
 header.b="Qj2ZSdlJ"
Received: by mail-pj1-f51.google.com with SMTP id
 98e67ed59e1d1-2ef87d24c2dso2204266a91.1;
        Thu, 30 Jan 2025 22:44:35 -0800 (PST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=gmail.com; s=20230601; t=1738305875; x=1738910675;
 darn=vger.kernel.org;
        h=content-transfer-encoding:mime-version:references:in-reply-to
         :message-id:date:subject:cc:to:from:from:to:cc:subject:date
         :message-id:reply-to;
        bh=Uxt7XgylM0RNNQeFvYOcAUiv7nVUhdc6VDeUfR75H2A=;
        b=Qj2ZSdlJFXA08V3KWomsJaPKGRZPIYjqL7tfBarZtzwCtsIr3MAoUDTB2b8hNPMYmv
         mMBQaMRgsf7Omdtm2IbQcl0Q73n1GiTPF4/1Gr/Z5OJeWeVeIRsNJHBqWsjSOo9jhy88
         9HjJjuBk0mafa+nCwC/cjqlXVo9gKAjoHNCDIprq9hN26r4cb+wZDW8Zr5UeM2wbtPJ/
         R5NWNyZe2ccUoh+cmZ4yWH7n2Oh9EdZQf3EjJvAzrY5mMliXLDS2kqkt4s1Cug8nhIBp
         Eb2153Djp4+TehISLQ5X9ULfZc4ViB6ukIayKUKpKUJFk9iLXgWVUSQmthcv/aZ3a3cS
         QozQ==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20230601; t=1738305875; x=1738910675;
        h=content-transfer-encoding:mime-version:references:in-reply-to
         :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc
         :subject:date:message-id:reply-to;
        bh=Uxt7XgylM0RNNQeFvYOcAUiv7nVUhdc6VDeUfR75H2A=;
        b=jEBEtdW1kSq3HTXUcQ5mdGEGEXiOGD9TXXyvGZorvfBuZ1j1vAT1sc9m8o5O+3ljBv
         DzXhE31/UWiMac6cwNGBU/ukXDA+56Maia/+H4c4Hc2cDx4zAK/ZMsiFUd77Tt/NnX87
         HtkJXHdlFFZt727sYNgh/p51bccQjy+n9cstMYCDv8FeMul4mWVN7lCEy1Ax4mIpPfD3
         BGdIOIAzXYgzoBL9WthRURH8TNS8dKYnFzxfGIEdJQ1012DQhQJquz7//Rd920zx8uv1
         AnZ5UhYDMowmTlIVs+jF3BLnoyS2bD7NDqYvDvj49p/piWl0+DHPlUHk8VnBKLMVYzGj
         +0nQ==
X-Forwarded-Encrypted: i=1;
 AJvYcCUK40MRY90lo6ALncOnIy6RDINZWlYh9iJGoOqfAbkcl1uDNlqErA3drop4oftEVz+FnDoLotAmAbO9@vger.kernel.org
X-Gm-Message-State: AOJu0Yx7kpzn2jqFn7WZgR5+zFL6N32ZcLHxWqGSNuEOF+R4OkCIQaQz
	X6S8TwsBRCuYunSQNeYWBQXt2h/mEF8ASgZ7xok9iD4CdfrsSHR32nGODpEX
X-Gm-Gg: ASbGncsw+WlWJtKuwt7ZVPCtFhJjpuxrj6C+F2Ukcjc0+DOIAXshSAxJlYtUVtpA+xE
	vaLyXvxbKns3E8UpebLS7Jnt87TcdniC7k+EHvl4hQaIayFPWYO6MUjnOxd/vCLvFnwCny2peqZ
	cbgqNnVMNMvaJ0yReRGvG8ppNREteqrb7Azih8KKJhGVcyBaU3m8lq2e6MRrK/Vk07GQ6jzYz+2
	qzDna7u8IGTG3zKpU7hGgKBswYbuENrC0aM8PQFOsqZvVsD15x8mleSW/HllTgTBAB7Oc7JpJ0V
	hj9pamZQwPjYN16vYs4On4FMl0k=
X-Google-Smtp-Source: 
 AGHT+IHCCGvbadTzQSXOFZiCDedmOYIDDA+dHN78B+HXrjLu5qnI/+PnMm+dRI48nV23T9Oqber2XA==
X-Received: by 2002:a17:90b:1f86:b0:2ee:aed2:c15c with SMTP id
 98e67ed59e1d1-2f83ac8c3famr14496578a91.28.1738305874754;
        Thu, 30 Jan 2025 22:44:34 -0800 (PST)
Received: from noel.flets-west.jp ([2405:6586:4480:a10:167:9818:d778:5c14])
        by smtp.gmail.com with ESMTPSA id
 98e67ed59e1d1-2f83bfc0ddbsm5098947a91.45.2025.01.30.22.44.30
        (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);
        Thu, 30 Jan 2025 22:44:34 -0800 (PST)
From: Hironori KIKUCHI <kikuchan98@gmail.com>
To: linux-kernel@vger.kernel.org
Cc: Hironori KIKUCHI <kikuchan98@gmail.com>,
	Neil Armstrong <neil.armstrong@linaro.org>,
	Jessica Zhang <quic_jesszhan@quicinc.com>,
	David Airlie <airlied@gmail.com>,
	Simona Vetter <simona@ffwll.ch>,
	Maarten Lankhorst <maarten.lankhorst@linux.intel.com>,
	Maxime Ripard <mripard@kernel.org>,
	Thomas Zimmermann <tzimmermann@suse.de>,
	Rob Herring <robh@kernel.org>,
	Krzysztof Kozlowski <krzk+dt@kernel.org>,
	Conor Dooley <conor+dt@kernel.org>,
	dri-devel@lists.freedesktop.org,
	devicetree@vger.kernel.org
Subject: [PATCH 2/2] drm: panel: Add a driver for Generic MIPI-DSI/DPI(+SPI)
 panels
Date: Fri, 31 Jan 2025 15:43:54 +0900
Message-ID: <20250131064354.4163579-3-kikuchan98@gmail.com>
X-Mailer: git-send-email 2.48.1
In-Reply-To: <20250131064354.4163579-1-kikuchan98@gmail.com>
References: <20250131064354.4163579-1-kikuchan98@gmail.com>
Precedence: bulk
X-Mailing-List: linux-kernel@vger.kernel.org
List-Id: <linux-kernel.vger.kernel.org>
List-Subscribe: <mailto:linux-kernel+subscribe@vger.kernel.org>
List-Unsubscribe: <mailto:linux-kernel+unsubscribe@vger.kernel.org>
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain; charset="utf-8"

Although the MIPI specifications define how to communicate with a panel
to display an image, some panels still require a panel-specific
initialization sequence to be sent.

This is a driver for such generic MIPI-DSI/DPI panels that require
initialization with a simple command sequence before use.

Its fundamental approach is similar to `panel-mipi-dbi` driver,
which sends an initialization sequence stored in a firmware file.

Moreover, this driver allows display modes, timings, and panel
configuration parameters to be stored in the same file or in DT.

Signed-off-by: Hironori KIKUCHI <kikuchan98@gmail.com>
---
 drivers/gpu/drm/panel/Kconfig      |   10 +
 drivers/gpu/drm/panel/Makefile     |    1 +
 drivers/gpu/drm/panel/panel-mipi.c | 1355 ++++++++++++++++++++++++++++
 3 files changed, 1366 insertions(+)
 create mode 100644 drivers/gpu/drm/panel/panel-mipi.c

diff --git a/drivers/gpu/drm/panel/Kconfig b/drivers/gpu/drm/panel/Kconfig
index d7469c565d1..46eea1974a0 100644
--- a/drivers/gpu/drm/panel/Kconfig
+++ b/drivers/gpu/drm/panel/Kconfig
@@ -408,6 +408,16 @@ config DRM_PANEL_MANTIX_MLAF057WE51
 	  has a resolution of 720x1440 pixels, a built in backlight and touch
 	  controller.
=20
+config DRM_PANEL_MIPI
+	tristate "Generic MIPI-DSI/DPI(+SPI) panel"
+	depends on OF
+	depends on SPI || DRM_MIPI_DSI
+	select DRM_MIPI_DBI if SPI
+	depends on BACKLIGHT_CLASS_DEVICE
+	help
+	  Say Y here if you want to enable support for Generic MIPI-DSI /
+	  MIPI-DPI(+SPI) panels.
+
 config DRM_PANEL_NEC_NL8048HL11
 	tristate "NEC NL8048HL11 RGB panel"
 	depends on GPIOLIB && OF && SPI
diff --git a/drivers/gpu/drm/panel/Makefile b/drivers/gpu/drm/panel/Makefile
index 7dcf72646ca..22276255a7b 100644
--- a/drivers/gpu/drm/panel/Makefile
+++ b/drivers/gpu/drm/panel/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_DRM_PANEL_LG_LB035Q02) +=3D panel-lg-lb035q0=
2.o
 obj-$(CONFIG_DRM_PANEL_LG_LG4573) +=3D panel-lg-lg4573.o
 obj-$(CONFIG_DRM_PANEL_LG_SW43408) +=3D panel-lg-sw43408.o
 obj-$(CONFIG_DRM_PANEL_MAGNACHIP_D53E6EA8966) +=3D panel-magnachip-d53e6ea=
8966.o
+obj-$(CONFIG_DRM_PANEL_MIPI) +=3D panel-mipi.o
 obj-$(CONFIG_DRM_PANEL_NEC_NL8048HL11) +=3D panel-nec-nl8048hl11.o
 obj-$(CONFIG_DRM_PANEL_NEWVISION_NV3051D) +=3D panel-newvision-nv3051d.o
 obj-$(CONFIG_DRM_PANEL_NEWVISION_NV3052C) +=3D panel-newvision-nv3052c.o
diff --git a/drivers/gpu/drm/panel/panel-mipi.c b/drivers/gpu/drm/panel/pan=
el-mipi.c
new file mode 100644
index 00000000000..bcbaa15b62a
--- /dev/null
+++ b/drivers/gpu/drm/panel/panel-mipi.c
@@ -0,0 +1,1355 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Generic MIPI-DSI/DPI(+SPI) Panel Driver
+ *
+ * Supported panels:
+ * - A generic MIPI-DSI panel which implements basic DCS
+ * - A generic MIPI-DPI panel which implements basic DCS over SPI
+ *
+ * Copyright (C) 2025, Hironori KIKUCHI <kikuchan98@gmail.com>
+ */
+
+#include <drm/drm_mipi_dbi.h>
+#include <drm/drm_mipi_dsi.h>
+#include <drm/drm_modes.h>
+#include <drm/drm_panel.h>
+#include <linux/backlight.h>
+#include <linux/bitfield.h>
+#include <linux/debugfs.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/firmware.h>
+#include <linux/gpio/consumer.h>
+#include <linux/media-bus-format.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/spi/spi.h>
+#include <video/display_timing.h>
+#include <video/mipi_display.h>
+#include <video/of_display_timing.h>
+#include <video/videomode.h>
+
+/*
+ * The display panel configuration can be stored in a firmware file,
+ * under the firmware directory of the system.
+ *
+ * The name of the file is `panels/<firmware-name>.panel`, where the
+ * 'firmware-name' should be defined as the property of the device
+ * in the Device Tree, otherwise the first `compatible` string is used.
+ *
+ * File Layout:
+ *     A binary file composed with the following data:
+ *         <header>
+ *         <config>
+ *         <timings>
+ *         <init-sequence>
+ *
+ * The 'header':
+ *     A `struct panel_firmware_header`.
+ *     The `file_format_version` must be `1`.
+ *
+ * The 'config':
+ *     A `struct panel_firmware_config`.
+ *     The values are in big-endian.
+ *
+ * The 'timings':
+ *     An array of `struct panel_firmware_panel_timing`.
+ *     Its length is `num_timings` in the config.
+ *     The values are in big-endian.
+ *
+ * The 'init-sequence':
+ *     MIPI commands to execute when the display pipeline is enabled.
+ *     This is used to configure the display controller, and it may
+ *     contains panel specific parameters as well.
+ *
+ *     The commands are encoded and stored in a byte array:
+ *
+ *         0x00             : sleep 10 ms
+ *         0x01 <M>         : MIPI command <M> with no arguments
+ *         0x02 <M> <a>     : MIPI command <M> with 1 argument <a>
+ *         0x03 <M> <a> <b> : MIPI command <M> with 2 arguments <a> <b>
+ *                :
+ *         0x7f <M> <...>   : MIPI command <M> with 126 arguments <...>
+ *         0x80             : sleep 100 ms
+ *         0x81 - 0xff      : reserved
+ *
+ *     Example:
+ *         command 0x11
+ *         sleep 10ms
+ *         command 0xb1 arguments 0x01 0x2c 0x2d
+ *         command 0x29
+ *         sleep 130ms
+ *
+ *     Byte sequence:
+ *         0x01 0x11
+ *         0x00
+ *         0x04 0xb1 0x01 0x2c 0x2d
+ *         0x01 0x29
+ *         0x80 0x00 0x00 0x00
+ *
+ */
+static const u8 panel_firmware_magic[15] =3D {
+	0x50, 0x41, 0x4e, 0x45, 0x4c, 0x2d, 0x46, 0x49,
+	0x52, 0x4d, 0x57, 0x41, 0x52, 0x45, 0x00,
+};
+
+struct panel_firmware_header {
+	u8 magic[15];
+	u8 file_format_version; /* must be 1 */
+} __packed;
+
+struct panel_firmware_config {
+	u16 width_mm, height_mm;
+	u16 rotation;
+	u8 _reserved_1[2];
+	u8 _reserved_2[8];
+
+	u16 reset_delay; /* delay after the reset command, in ms */
+	u16 init_delay; /* delay for sending the initial command sequence, in ms =
*/
+	u16 sleep_delay; /* delay after the sleep command, in ms */
+	u16 backlight_delay; /* delay for enabling the backlight, in ms */
+	u16 _reserved_3[4];
+
+	u16 dsi_lanes; /* unsigned int */
+	u16 dsi_format; /* enum mipi_dsi_pixel_format */
+	u32 dsi_mode_flags; /* unsigned long */
+	u32 bus_flags; /* struct drm_bus_flags */
+	u8 _reserved_4[2];
+	u8 preferred_timing;
+	u8 num_timings;
+} __packed;
+
+struct panel_firmware_panel_timing {
+	u16 hactive;
+	u16 hfp;
+	u16 hslen;
+	u16 hbp;
+
+	u16 vactive;
+	u16 vfp;
+	u16 vslen;
+	u16 vbp;
+
+	u32 dclk; /* in kHz */
+	u32 flags; /* include/drm/drm_modes.h DRM_MODE_FLAG_* */
+
+	u8 _reserved_1[8];
+} __packed;
+
+struct panel_commands {
+	const u8 *data;
+	size_t size;
+};
+
+struct panel_firmware {
+	const struct firmware *blob;
+	const struct panel_firmware_config *config;
+	const struct panel_firmware_panel_timing *timings;
+	struct panel_commands commands;
+};
+
+struct panel_mipi {
+	struct drm_panel panel;
+	struct mipi_dsi_device *dsi;
+	struct mipi_dbi dbi;
+
+	struct mutex lock;
+
+	struct regulator_bulk_data supplies[2];
+	struct gpio_desc *reset;
+
+	unsigned int reset_delay;
+	unsigned int init_delay;
+	unsigned int sleep_delay;
+	unsigned int backlight_delay;
+
+	unsigned int dsi_lanes;
+	enum mipi_dsi_pixel_format dsi_format;
+
+	/* Panel info */
+	u32 width_mm, height_mm;
+	u32 bus_format, bus_flags;
+	enum drm_panel_orientation orientation;
+
+	struct list_head mode_list;
+
+	struct panel_firmware *firmware;
+	struct panel_commands commands;
+
+	int (*write_command)(struct panel_mipi *mipi, const u8 *buf,
+			     size_t len);
+	int (*read_command)(struct panel_mipi *mipi, u8 cmd, u8 *buf,
+			    size_t len);
+
+	/* DMA-able buffer */
+	u8 initial_display_id[3];
+	u8 display_id[3];
+
+	/* debugfs */
+	struct dentry *debugfs;
+	u8 recvbuf[1024];
+	size_t recvlen;
+};
+
+static inline struct panel_mipi *to_panel_mipi(struct drm_panel *panel)
+{
+	return container_of(panel, struct panel_mipi, panel);
+}
+
+static int panel_mipi_dsi_write(struct panel_mipi *mipi, const u8 *buf,
+				size_t len)
+{
+	int ret;
+
+	ret =3D mipi_dsi_dcs_write_buffer(mipi->dsi, buf, len);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int panel_mipi_dbi_write(struct panel_mipi *mipi, const u8 *buf,
+				size_t len)
+{
+	return mipi_dbi_command_stackbuf(&mipi->dbi, buf[0], buf + 1, len - 1);
+}
+
+#define panel_mipi_write(mipi, ...)                                \
+	({                                                         \
+		u8 _buf[] =3D { __VA_ARGS__ };                       \
+		mipi->write_command(mipi, _buf, ARRAY_SIZE(_buf)); \
+	})
+
+static int panel_mipi_dsi_read(struct panel_mipi *mipi, u8 cmd, u8 *buf,
+			       size_t len)
+{
+	return mipi_dsi_dcs_read(mipi->dsi, cmd, buf, len);
+}
+
+static int panel_mipi_dbi_read(struct panel_mipi *mipi, u8 cmd, u8 *buf,
+			       size_t len)
+{
+	return mipi_dbi_command_buf(&mipi->dbi, cmd, buf, len);
+}
+
+#define panel_mipi_read(mipi, cmd, buf, len) \
+	(mipi)->read_command((mipi), (cmd), (buf), (len))
+
+static unsigned long panel_mipi_dsi_set_mode_flags(struct panel_mipi *mipi,
+						   unsigned long new_flags)
+{
+	unsigned long old_flags;
+
+	if (!mipi->dsi)
+		return 0;
+
+	old_flags =3D mipi->dsi->mode_flags;
+
+	mipi->dsi->mode_flags =3D new_flags;
+
+	return old_flags;
+}
+
+static bool panel_mipi_dsi_set_lpm(struct panel_mipi *mipi, bool set)
+{
+	unsigned long old_flags;
+
+	if (!mipi->dsi)
+		return false;
+
+	old_flags =3D panel_mipi_dsi_set_mode_flags(
+		mipi, set ? mipi->dsi->mode_flags | MIPI_DSI_MODE_LPM :
+			    mipi->dsi->mode_flags & ~MIPI_DSI_MODE_LPM);
+
+	return old_flags & MIPI_DSI_MODE_LPM ? true : false;
+}
+
+#define PANEL_MIPI_TRANSACTION(mipi, stmt)   \
+	do {                                 \
+		mutex_lock(&(mipi)->lock);   \
+		do {                         \
+			stmt;                \
+		} while (0);                 \
+		mutex_unlock(&(mipi)->lock); \
+	} while (0)
+
+#define PANEL_MIPI_TRANSACTION_LPM(mipi, lpm, stmt)                       \
+	PANEL_MIPI_TRANSACTION(                                           \
+		mipi,                                                     \
+		bool _lpm_backup =3D panel_mipi_dsi_set_lpm((mipi), (lpm)); \
+		do { stmt; } while (0);                                   \
+		panel_mipi_dsi_set_lpm((mipi), _lpm_backup))
+
+static int panel_mipi_validate_commands(struct panel_mipi *mipi, const u8 =
*data,
+					size_t size, size_t *valid_len)
+{
+	size_t i =3D 0;
+
+	/* sanity check */
+	while (i < size) {
+		u8 inst =3D data[i];
+		bool ext =3D (inst & 0x80) ? true : false;
+		u8 len =3D inst & 0x7f;
+
+		if (ext && len > 0)
+			return -EINVAL; /* reserved */
+
+		if (i + 1 + len > size)
+			break;
+
+		i +=3D 1 + len;
+	}
+
+	*valid_len =3D i;
+
+	return 0;
+}
+
+static int panel_mipi_load_commands(struct panel_mipi *mipi, const u8 *dat=
a,
+				    size_t size)
+{
+	int err;
+	size_t valid_len;
+
+	err =3D panel_mipi_validate_commands(mipi, data, size, &valid_len);
+	if (err)
+		return err;
+
+	if (valid_len !=3D size)
+		return -EINVAL;
+
+	mipi->commands.data =3D data;
+	mipi->commands.size =3D size;
+
+	return 0;
+}
+
+static int panel_mipi_write_commands(struct panel_mipi *mipi, const u8 *da=
ta,
+				     size_t size)
+{
+	const u8 *read_commands;
+	unsigned int write_memory_bpw;
+	size_t i =3D 0;
+	int err =3D 0;
+
+	if (!data)
+		return 0;
+
+	/*
+	 * Disable interpretation for special commands for DBI
+	 *
+	 * This is required because the vendor specific custom commands
+	 * may change its command set to the other.
+	 */
+	read_commands =3D mipi->dbi.read_commands;
+	write_memory_bpw =3D mipi->dbi.write_memory_bpw;
+	mipi->dbi.read_commands =3D NULL;
+	mipi->dbi.write_memory_bpw =3D 8;
+
+	while (i < size) {
+		u8 inst =3D data[i++];
+		bool ext =3D (inst & 0x80) ? true : false;
+		u8 len =3D inst & 0x7f;
+
+		if (len =3D=3D 0x00) {
+			msleep(ext ? 100 : 10);
+			continue;
+		}
+
+		err =3D mipi->write_command(mipi, data + i, len);
+
+		if (err)
+			break;
+
+		i +=3D len;
+	}
+
+	/* restore */
+	mipi->dbi.read_commands =3D read_commands;
+	mipi->dbi.write_memory_bpw =3D write_memory_bpw;
+
+	return err;
+}
+
+static int panel_mipi_read_firmware(const struct device *dev,
+				    struct panel_mipi *mipi,
+				    const struct panel_firmware *firmware)
+{
+	int rotation;
+	int err;
+
+	if (!firmware)
+		return 0;
+
+	err =3D panel_mipi_load_commands(mipi, firmware->commands.data,
+				       firmware->commands.size);
+	if (err) {
+		dev_err(dev, "firmware: Malformed command sequence\n");
+		return err;
+	}
+
+	mipi->width_mm =3D be16_to_cpu(firmware->config->width_mm);
+	mipi->height_mm =3D be16_to_cpu(firmware->config->height_mm);
+
+	rotation =3D be16_to_cpu(firmware->config->rotation);
+	if (rotation =3D=3D 0)
+		mipi->orientation =3D DRM_MODE_PANEL_ORIENTATION_NORMAL;
+	else if (rotation =3D=3D 90)
+		mipi->orientation =3D DRM_MODE_PANEL_ORIENTATION_RIGHT_UP;
+	else if (rotation =3D=3D 180)
+		mipi->orientation =3D DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP;
+	else if (rotation =3D=3D 270)
+		mipi->orientation =3D DRM_MODE_PANEL_ORIENTATION_LEFT_UP;
+	else {
+		dev_err(dev, "firmware: Invalid rotation %u\n", rotation);
+		return -EINVAL;
+	}
+
+	if (firmware->config->reset_delay)
+		mipi->reset_delay =3D be16_to_cpu(firmware->config->reset_delay);
+	if (firmware->config->init_delay)
+		mipi->init_delay =3D be16_to_cpu(firmware->config->init_delay);
+	if (firmware->config->sleep_delay)
+		mipi->sleep_delay =3D be16_to_cpu(firmware->config->sleep_delay);
+	if (firmware->config->backlight_delay)
+		mipi->backlight_delay =3D
+			be16_to_cpu(firmware->config->backlight_delay);
+
+	if (firmware->config->bus_flags)
+		mipi->bus_flags =3D be32_to_cpu(firmware->config->bus_flags);
+
+	return 0;
+}
+
+static struct panel_firmware *panel_mipi_load_firmware(struct device *dev)
+{
+	const struct firmware *blob;
+	const struct panel_firmware_header *hdr;
+	const struct panel_firmware_config *config;
+	const struct panel_firmware_panel_timing *timings;
+	struct panel_firmware *firmware;
+	const char *firmware_name;
+	size_t command_offset;
+	char filename[128];
+	int err;
+
+	err =3D of_property_read_string_index(dev->of_node, "compatible", 0,
+					    &firmware_name);
+	if (err)
+		return NULL;
+
+	/* Use firmware-name instead if any */
+	of_property_read_string(dev->of_node, "firmware-name", &firmware_name);
+
+	snprintf(filename, sizeof(filename), "panels/%s.panel", firmware_name);
+	err =3D firmware_request_nowarn(&blob, filename, dev);
+	if (err)
+		return NULL;
+
+	hdr =3D (const struct panel_firmware_header *)blob->data;
+
+	if (blob->size < sizeof(*hdr)) {
+		dev_err(dev, "firmware: %s: file size %zu is too small\n",
+			filename, blob->size);
+		err =3D -EINVAL;
+		goto err;
+	}
+
+	if (memcmp(hdr->magic, panel_firmware_magic, sizeof(hdr->magic))) {
+		dev_err(dev, "firmware: %s: Bad magic %15ph\n", filename,
+			hdr->magic);
+		err =3D -EINVAL;
+		goto err;
+	}
+
+	if (hdr->file_format_version !=3D 1) {
+		dev_err(dev, "firmware: %s: version %u is not supported\n",
+			filename, hdr->file_format_version);
+		err =3D -EINVAL;
+		goto err;
+	}
+
+	config =3D (struct panel_firmware_config *)(blob->data + sizeof(*hdr));
+	timings =3D (struct panel_firmware_panel_timing *)(blob->data +
+							 sizeof(*hdr) +
+							 sizeof(*config));
+	command_offset =3D sizeof(*hdr) + sizeof(*config) +
+			 config->num_timings * sizeof(*timings);
+	if (blob->size < command_offset) {
+		dev_err(dev, "firmware: %s: file size %zu is too small\n",
+			filename, blob->size);
+		err =3D -EINVAL;
+		goto err;
+	}
+
+	firmware =3D devm_kzalloc(dev, sizeof(*firmware), GFP_KERNEL);
+	if (!firmware) {
+		err =3D -ENOMEM;
+		goto err;
+	}
+
+	firmware->blob =3D blob;
+	firmware->config =3D config;
+	firmware->timings =3D timings;
+	firmware->commands.data =3D blob->data + command_offset;
+	firmware->commands.size =3D blob->size - command_offset;
+
+	dev_info(dev, "firmware: %s: loaded successfully\n", filename);
+
+	return firmware;
+
+err:
+	release_firmware(blob);
+
+	return ERR_PTR(err);
+}
+
+static int panel_mipi_read_display_id(struct panel_mipi *mipi, u8 *dest)
+{
+	return panel_mipi_read(mipi, MIPI_DCS_GET_DISPLAY_ID, dest, 3);
+}
+
+static int panel_mipi_enable(struct drm_panel *panel)
+{
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+	int err;
+
+	PANEL_MIPI_TRANSACTION(mipi, {
+		err =3D panel_mipi_write(mipi, MIPI_DCS_SET_DISPLAY_ON);
+	});
+	if (err)
+		return err;
+
+	if (panel->backlight) {
+		/* Wait for the picture to be ready before enabling backlight */
+		msleep(mipi->backlight_delay);
+	}
+
+	return 0;
+}
+
+static int panel_mipi_disable(struct drm_panel *panel)
+{
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+	int err =3D 0;
+
+	PANEL_MIPI_TRANSACTION(mipi, {
+		err =3D panel_mipi_write(mipi, MIPI_DCS_SET_DISPLAY_OFF);
+	});
+
+	return err;
+}
+
+static int panel_mipi_prepare(struct drm_panel *panel)
+{
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+	int err;
+
+	err =3D regulator_bulk_enable(ARRAY_SIZE(mipi->supplies), mipi->supplies);
+	if (err)
+		return err;
+
+	PANEL_MIPI_TRANSACTION(mipi, {
+		/* Reset the chip */
+		if (mipi->reset) {
+			gpiod_set_value_cansleep(mipi->reset, 1);
+			msleep(mipi->reset_delay);
+			gpiod_set_value_cansleep(mipi->reset, 0);
+		}
+
+		msleep(mipi->init_delay);
+
+		/* Read the Display ID */
+		if (!panel_mipi_read_display_id(mipi,
+						mipi->initial_display_id)) {
+			dev_info(panel->dev, "MIPI Display ID: %3phN\n",
+				 mipi->initial_display_id);
+		}
+
+		/* Write the init-sequence */
+		err =3D panel_mipi_write_commands(mipi, mipi->commands.data,
+						mipi->commands.size);
+		if (err)
+			break;
+
+		/* Ensure to exit from a sleep mode */
+		err =3D panel_mipi_write(mipi, MIPI_DCS_EXIT_SLEEP_MODE);
+		if (err)
+			break;
+		msleep(mipi->sleep_delay);
+
+		/*
+		 * Read the Display ID again,
+		 * because the init-sequence might have changed the ID.
+		 */
+		if (!panel_mipi_read_display_id(mipi, mipi->display_id) &&
+		    memcmp(mipi->initial_display_id, mipi->display_id,
+			   sizeof(mipi->display_id))) {
+			dev_info(panel->dev,
+				 "MIPI Display ID: %3phN (changed)\n",
+				 mipi->display_id);
+		}
+	});
+
+	if (err) {
+		regulator_bulk_disable(ARRAY_SIZE(mipi->supplies),
+				       mipi->supplies);
+		return err;
+	}
+
+	return 0;
+}
+
+static int panel_mipi_unprepare(struct drm_panel *panel)
+{
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+	int err;
+
+	PANEL_MIPI_TRANSACTION(mipi, {
+		err =3D panel_mipi_write(mipi, MIPI_DCS_ENTER_SLEEP_MODE);
+		if (err)
+			dev_warn(panel->dev, "Failed to enter a sleep mode\n");
+		msleep(mipi->sleep_delay);
+	});
+
+	if (mipi->reset) {
+		gpiod_set_value_cansleep(mipi->reset, 1);
+		msleep(mipi->reset_delay);
+	}
+
+	regulator_bulk_disable(ARRAY_SIZE(mipi->supplies), mipi->supplies);
+
+	return 0;
+}
+
+static int panel_mipi_get_modes(struct drm_panel *panel,
+				struct drm_connector *connector)
+{
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+	struct drm_display_mode *mode;
+	unsigned int count =3D 0;
+
+	list_for_each_entry(mode, &mipi->mode_list, head) {
+		struct drm_display_mode *dmode;
+
+		dmode =3D drm_mode_duplicate(connector->dev, mode);
+		if (!dmode)
+			return -EINVAL;
+
+		drm_mode_probed_add(connector, dmode);
+		count++;
+	}
+
+	connector->display_info.bpc =3D 8;
+	connector->display_info.width_mm =3D mipi->width_mm;
+	connector->display_info.height_mm =3D mipi->height_mm;
+	connector->display_info.bus_flags =3D mipi->bus_flags;
+	drm_display_info_set_bus_formats(&connector->display_info,
+					 &mipi->bus_format, 1);
+
+	/*
+	 * TODO: Remove once all drm drivers call
+	 * drm_connector_set_orientation_from_panel()
+	 */
+	drm_connector_set_panel_orientation(connector, mipi->orientation);
+
+	return count;
+}
+
+static enum drm_panel_orientation
+panel_mipi_get_orientation(struct drm_panel *panel)
+{
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+
+	return mipi->orientation;
+}
+
+#ifdef CONFIG_DEBUG_FS
+
+static int display_id_show(struct seq_file *s, void *data)
+{
+	struct drm_panel *panel =3D s->private;
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+	int err =3D 0;
+
+	PANEL_MIPI_TRANSACTION(mipi, {
+		err =3D panel_mipi_read_display_id(mipi, mipi->display_id);
+		if (err)
+			break;
+
+		seq_printf(s, "%3phN\n", mipi->display_id);
+	});
+
+	return err;
+}
+DEFINE_SHOW_ATTRIBUTE(display_id);
+
+static int initial_display_id_show(struct seq_file *s, void *data)
+{
+	struct drm_panel *panel =3D s->private;
+	struct panel_mipi *mipi =3D to_panel_mipi(panel);
+
+	seq_printf(s, "%3phN\n", mipi->initial_display_id);
+
+	return 0;
+}
+
+DEFINE_SHOW_ATTRIBUTE(initial_display_id);
+
+static int commands_open(struct inode *inode, struct file *file)
+{
+	struct panel_mipi *mipi =3D inode->i_private;
+
+	mipi->recvlen =3D 0;
+	file->private_data =3D mipi;
+
+	return 0;
+}
+
+static ssize_t commands_write(struct file *file, const char __user *data,
+			      size_t size, loff_t *pos)
+{
+	struct panel_mipi *mipi =3D file->private_data;
+	ssize_t s =3D min_t(u64, sizeof(mipi->recvbuf) - mipi->recvlen, size);
+	size_t valid_len;
+	int err;
+
+	if (!s || !mipi)
+		return -EINVAL;
+
+	if (copy_from_user(mipi->recvbuf + mipi->recvlen, data, s))
+		return -EINVAL;
+
+	mipi->recvlen +=3D s;
+
+	err =3D panel_mipi_validate_commands(mipi, mipi->recvbuf, mipi->recvlen,
+					   &valid_len);
+	if (err)
+		return err;
+
+	if (valid_len > 0) {
+		PANEL_MIPI_TRANSACTION(mipi, {
+			err =3D panel_mipi_write_commands(mipi, mipi->recvbuf,
+							valid_len);
+		});
+		if (err)
+			return err;
+
+		mipi->recvlen -=3D valid_len;
+		if (mipi->recvlen)
+			memmove(mipi->recvbuf, mipi->recvbuf + valid_len,
+				mipi->recvlen);
+	}
+
+	return s;
+}
+
+static int commands_release(struct inode *inode, struct file *file)
+{
+	struct panel_mipi *mipi =3D inode->i_private;
+
+	if (mipi->recvlen) {
+		dev_err(mipi->panel.dev, "Premature end of commands\n");
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static const struct file_operations commands_fops =3D {
+	.owner =3D THIS_MODULE,
+	.open =3D commands_open,
+	.write =3D commands_write,
+	.release =3D commands_release,
+};
+
+#endif
+
+static void panel_mipi_debugfs_init(struct device *dev, struct panel_mipi =
*mipi)
+{
+#ifdef CONFIG_DEBUG_FS
+	struct dentry *dir;
+
+	mipi->debugfs =3D debugfs_lookup("panel-mipi", NULL);
+	if (!mipi->debugfs)
+		mipi->debugfs =3D debugfs_create_dir("panel-mipi", NULL);
+
+	dir =3D debugfs_create_dir(dev_name(dev), mipi->debugfs);
+	debugfs_create_file("display-id", 0600, dir, mipi, &display_id_fops);
+	debugfs_create_file("initial-display-id", 0600, dir, mipi,
+			    &initial_display_id_fops);
+	debugfs_create_file("commands", 0600, dir, mipi, &commands_fops);
+#endif
+}
+
+static void panel_mipi_debugfs_remove(struct panel_mipi *mipi)
+{
+#ifdef CONFIG_DEBUG_FS
+	debugfs_remove_recursive(mipi->debugfs);
+	mipi->debugfs =3D NULL;
+#endif
+}
+
+static const struct drm_panel_funcs panel_mipi_funcs =3D {
+	.prepare =3D panel_mipi_prepare,
+	.unprepare =3D panel_mipi_unprepare,
+	.enable =3D panel_mipi_enable,
+	.disable =3D panel_mipi_disable,
+	.get_modes =3D panel_mipi_get_modes,
+	.get_orientation =3D panel_mipi_get_orientation,
+};
+
+static int panel_mipi_add_mode(struct device *dev, struct panel_mipi *mipi,
+			       const struct drm_display_mode *src_mode,
+			       const char *source)
+{
+	struct drm_display_mode *mode;
+
+	mode =3D devm_kzalloc(dev, sizeof(*mode), GFP_KERNEL);
+	if (!mode)
+		return -ENOMEM;
+
+	drm_mode_copy(mode, src_mode);
+
+	if (!mode->clock)
+		mode->clock =3D mode->htotal * mode->vtotal * 60 / 1000;
+
+	mode->type |=3D DRM_MODE_TYPE_DRIVER;
+
+	dev_info(dev, "Modeline " DRM_MODE_FMT " added by %s\n",
+		 DRM_MODE_ARG(mode), source);
+
+	list_add_tail(&mode->head, &mipi->mode_list);
+
+	return 0;
+}
+
+static int panel_mipi_firmware_read_modes(const struct panel_firmware *fir=
mware,
+					  struct drm_display_mode *mode,
+					  u32 *bus_flags, unsigned int i)
+{
+	const struct panel_firmware_panel_timing *timings =3D
+		&firmware->timings[i];
+
+	if (!firmware || i >=3D firmware->config->num_timings)
+		return -ENOENT;
+
+	if (!timings->hactive || !timings->vactive)
+		return -ENOENT;
+
+	memset(mode, 0, sizeof(*mode));
+
+	mode->clock =3D be32_to_cpu(timings->dclk);
+
+	mode->hdisplay =3D be16_to_cpu(timings->hactive);
+	mode->hsync_start =3D mode->hdisplay + be16_to_cpu(timings->hfp);
+	mode->hsync_end =3D mode->hsync_start + be16_to_cpu(timings->hslen);
+	mode->htotal =3D mode->hsync_end + be16_to_cpu(timings->hbp);
+
+	mode->vdisplay =3D be16_to_cpu(timings->vactive);
+	mode->vsync_start =3D mode->vdisplay + be16_to_cpu(timings->vfp);
+	mode->vsync_end =3D mode->vsync_start + be16_to_cpu(timings->vslen);
+	mode->vtotal =3D mode->vsync_end + be16_to_cpu(timings->vbp);
+
+	mode->flags =3D be32_to_cpu(timings->flags);
+
+	drm_mode_set_name(mode);
+
+	if (bus_flags && firmware->config->bus_flags)
+		*bus_flags =3D be32_to_cpu(firmware->config->bus_flags);
+
+	return 0;
+}
+
+static void drm_display_mode_from_timing(const struct display_timing *timi=
ng,
+					 struct drm_display_mode *dmode,
+					 u32 *bus_flags)
+{
+	struct videomode vm;
+
+	videomode_from_timing(timing, &vm);
+
+	memset(dmode, 0, sizeof(*dmode));
+	drm_display_mode_from_videomode(&vm, dmode);
+
+	if (bus_flags)
+		drm_bus_flags_from_videomode(&vm, bus_flags);
+}
+
+static int panel_mipi_read_of_display_timings(struct device *dev,
+					      struct panel_mipi *mipi)
+{
+	struct device_node *np =3D dev->of_node;
+	struct device_node *timings_np;
+	struct display_timings *timings;
+	struct drm_display_mode mode =3D {};
+	u32 bus_flags;
+	unsigned int i;
+	int err;
+
+	/* To avoid the not found error message */
+	timings_np =3D of_get_child_by_name(np, "display-timings");
+	if (!timings_np)
+		return 0;
+	of_node_put(timings_np);
+
+	/* Then, load timings as usual */
+	timings =3D of_get_display_timings(np);
+	if (!timings)
+		return dev_err_probe(dev, -EINVAL,
+				     "%pOF: Failed to get 'display-timings'\n",
+				     dev->of_node);
+
+	for (i =3D 0; i < timings->num_timings; i++) {
+		drm_display_mode_from_timing(timings->timings[i], &mode,
+					     &bus_flags);
+
+		if (timings->native_mode =3D=3D i)
+			mode.type |=3D DRM_MODE_TYPE_PREFERRED;
+
+		err =3D panel_mipi_add_mode(dev, mipi, &mode, "display-timings");
+		if (err)
+			return err;
+		if (bus_flags)
+			mipi->bus_flags =3D bus_flags;
+	}
+
+	display_timings_release(timings);
+
+	return 0;
+}
+
+static int panel_mipi_probe_modes(struct device *dev, struct panel_mipi *m=
ipi)
+{
+	unsigned int i =3D 0;
+	u32 bus_flags =3D 0;
+	struct drm_display_mode mode =3D {};
+	struct display_timing timing =3D {};
+	int err;
+
+	INIT_LIST_HEAD(&mipi->mode_list);
+
+	/* Read firmware first */
+	for (i =3D 0; mipi->firmware && i < mipi->firmware->config->num_timings;
+	     i++) {
+		if (!panel_mipi_firmware_read_modes(mipi->firmware, &mode,
+						    &bus_flags, i)) {
+			if (mipi->firmware->config->preferred_timing =3D=3D i)
+				mode.type |=3D DRM_MODE_TYPE_PREFERRED;
+
+			err =3D panel_mipi_add_mode(dev, mipi, &mode, "firmware");
+			if (err)
+				return err;
+			if (bus_flags)
+				mipi->bus_flags =3D bus_flags;
+		}
+	}
+
+	/* Read `display-timings` and append if any */
+	err =3D panel_mipi_read_of_display_timings(dev, mipi);
+	if (err)
+		return err;
+
+	/* Read `panel-timing` and append if any */
+	err =3D of_get_display_timing(dev->of_node, "panel-timing", &timing);
+	if (err && err !=3D -ENOENT)
+		return err;
+	else if (!err) {
+		drm_display_mode_from_timing(&timing, &mode, &bus_flags);
+		err =3D panel_mipi_add_mode(dev, mipi, &mode, "panel-timing");
+		if (err)
+			return err;
+		if (bus_flags)
+			mipi->bus_flags =3D bus_flags;
+	}
+
+	if (list_empty(&mipi->mode_list))
+		return dev_err_probe(dev, -EINVAL, "No modes defined\n");
+
+	return 0;
+}
+
+static void panel_mipi_cleanup(void *data)
+{
+	struct panel_mipi *mipi =3D (struct panel_mipi *)data;
+
+	panel_mipi_debugfs_remove(mipi);
+
+	drm_panel_remove(&mipi->panel);
+	drm_panel_disable(&mipi->panel);
+	drm_panel_unprepare(&mipi->panel);
+
+	if (mipi->firmware)
+		release_firmware(mipi->firmware->blob);
+}
+
+static int
+panel_mipi_backlight_update_status(struct backlight_device *backlight)
+{
+	struct panel_mipi *mipi =3D dev_get_drvdata(&backlight->dev);
+	int level =3D backlight_get_brightness(backlight);
+	int err;
+
+	PANEL_MIPI_TRANSACTION_LPM(mipi, false, {
+		err =3D panel_mipi_write(mipi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
+				       level, level);
+	});
+
+	return err;
+}
+
+static int
+panel_mipi_backlight_get_brightness(struct backlight_device *backlight)
+{
+	return backlight_get_brightness(backlight);
+}
+
+static const struct backlight_ops panel_mipi_backlight_ops =3D {
+	.get_brightness =3D panel_mipi_backlight_get_brightness,
+	.update_status =3D panel_mipi_backlight_update_status,
+};
+
+static int panel_mipi_set_backlight(struct drm_panel *panel, struct device=
 *dev,
+				    struct panel_mipi *mipi)
+{
+	int err;
+
+	err =3D drm_panel_of_backlight(panel);
+	if (err)
+		return err;
+
+	if (!panel->backlight) {
+		struct backlight_device *backlight =3D NULL;
+		struct backlight_properties props =3D {
+			.max_brightness =3D 255,
+			.type =3D BACKLIGHT_RAW,
+		};
+
+		backlight =3D devm_backlight_device_register(
+			dev, dev_name(dev), dev, mipi,
+			&panel_mipi_backlight_ops, &props);
+		if (IS_ERR(backlight))
+			return PTR_ERR(backlight);
+
+		panel->backlight =3D backlight;
+	}
+
+	return 0;
+}
+
+static int panel_mipi_probe(struct device *dev, int connector_type)
+{
+	struct panel_mipi *mipi;
+	int err;
+
+	mipi =3D devm_kzalloc(dev, sizeof(*mipi), GFP_KERNEL);
+	if (!mipi)
+		return -ENOMEM;
+
+	mutex_init(&mipi->lock);
+
+	/* Get `power-supply` and `io-supply` (if any) */
+	mipi->supplies[0].supply =3D "power";
+	mipi->supplies[1].supply =3D "io";
+	err =3D devm_regulator_bulk_get(dev, ARRAY_SIZE(mipi->supplies),
+				      mipi->supplies);
+	if (err < 0) {
+		return dev_err_probe(dev, err,
+				     "%pOF: Failed to get regulators\n",
+				     dev->of_node);
+	}
+
+	/* GPIO for /RESET */
+	mipi->reset =3D devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
+	if (IS_ERR(mipi->reset))
+		return dev_err_probe(dev, PTR_ERR(mipi->reset),
+				     "%pOF: Failed to get GPIO for RESET\n",
+				     dev->of_node);
+
+	/* Default values */
+	mipi->bus_format =3D MEDIA_BUS_FMT_RGB888_1X24;
+	mipi->reset_delay =3D 1;
+	mipi->init_delay =3D 10;
+	mipi->sleep_delay =3D 120;
+	mipi->backlight_delay =3D 120;
+
+	/* Load from the firmware */
+	mipi->firmware =3D panel_mipi_load_firmware(dev);
+	if (IS_ERR(mipi->firmware))
+		return dev_err_probe(dev, PTR_ERR(mipi->firmware),
+				     "Failed to load a firmware\n");
+	err =3D panel_mipi_read_firmware(dev, mipi, mipi->firmware);
+	if (err)
+		return err;
+
+	/* Load panel modes */
+	err =3D panel_mipi_probe_modes(dev, mipi);
+	if (err)
+		return err;
+
+	/* Load overrides from the DT */
+	const struct property *prop =3D
+		of_find_property(dev->of_node, "init-sequence", NULL);
+	if (prop && prop->value && prop->length > 0) {
+		err =3D panel_mipi_load_commands(mipi, prop->value, prop->length);
+		if (err)
+			return dev_err_probe(
+				dev, err, "%pOF: Malformed command sequence\n",
+				dev->of_node);
+	}
+	of_property_read_u32(dev->of_node, "width-mm", &mipi->width_mm);
+	of_property_read_u32(dev->of_node, "height-mm", &mipi->height_mm);
+	of_property_read_u32(dev->of_node, "reset-delay", &mipi->reset_delay);
+	of_property_read_u32(dev->of_node, "init-delay", &mipi->init_delay);
+	of_property_read_u32(dev->of_node, "sleep-delay", &mipi->sleep_delay);
+	of_property_read_u32(dev->of_node, "backlight-delay",
+			     &mipi->backlight_delay);
+	if (of_find_property(dev->of_node, "rotation", NULL)) {
+		err =3D of_drm_get_panel_orientation(dev->of_node,
+						   &mipi->orientation);
+		if (err)
+			return dev_err_probe(dev, err,
+					     "%pOF: Invalid rotation\n",
+					     dev->of_node);
+	}
+
+	/* DRM panel setup */
+	drm_panel_init(&mipi->panel, dev, &panel_mipi_funcs, connector_type);
+
+	err =3D panel_mipi_set_backlight(&mipi->panel, dev, mipi);
+	if (err)
+		return dev_err_probe(dev, err, "Failed to set backlight\n");
+
+	drm_panel_add(&mipi->panel);
+
+	dev_set_drvdata(dev, mipi);
+
+	panel_mipi_debugfs_init(dev, mipi);
+
+	return devm_add_action_or_reset(dev, panel_mipi_cleanup, mipi);
+}
+
+static unsigned long panel_mipi_read_dsi_mode_props(struct device_node *np)
+{
+	unsigned long mode =3D 0;
+
+	mode |=3D of_property_read_bool(np, "dsi-mode-video") ?
+			MIPI_DSI_MODE_VIDEO :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-burst") ?
+			MIPI_DSI_MODE_VIDEO_BURST :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-sync-pulse") ?
+			MIPI_DSI_MODE_VIDEO_SYNC_PULSE :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-auto-vert") ?
+			MIPI_DSI_MODE_VIDEO_AUTO_VERT :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-hse") ?
+			MIPI_DSI_MODE_VIDEO_HSE :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-no-hfp") ?
+			MIPI_DSI_MODE_VIDEO_NO_HFP :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-no-hbp") ?
+			MIPI_DSI_MODE_VIDEO_NO_HBP :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-video-no-hsa") ?
+			MIPI_DSI_MODE_VIDEO_NO_HSA :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-vsync-flush") ?
+			MIPI_DSI_MODE_VSYNC_FLUSH :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-no-eot-packet") ?
+			MIPI_DSI_MODE_NO_EOT_PACKET :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-clock-non-continuous") ?
+			MIPI_DSI_CLOCK_NON_CONTINUOUS :
+			0;
+	mode |=3D of_property_read_bool(np, "dsi-mode-lpm") ? MIPI_DSI_MODE_LPM :
+							    0;
+	mode |=3D of_property_read_bool(np, "dsi-hs-pkt-end-aligned") ?
+			MIPI_DSI_HS_PKT_END_ALIGNED :
+			0;
+
+	return mode;
+}
+
+static int panel_mipi_dsi_probe(struct mipi_dsi_device *dsi)
+{
+	struct panel_mipi *mipi;
+	const char *format;
+	int err;
+
+	err =3D panel_mipi_probe(&dsi->dev, DRM_MODE_CONNECTOR_DSI);
+	if (err)
+		return err;
+
+	mipi =3D dev_get_drvdata(&dsi->dev);
+	mipi->dsi =3D dsi;
+	mipi->write_command =3D panel_mipi_dsi_write;
+	mipi->read_command =3D panel_mipi_dsi_read;
+
+	/* Default values */
+	dsi->lanes =3D 1;
+	dsi->format =3D MIPI_DSI_FMT_RGB888;
+	dsi->mode_flags =3D 0;
+
+	/* Read from the firmware */
+	if (mipi->firmware) {
+		dsi->lanes =3D be16_to_cpu(mipi->firmware->config->dsi_lanes);
+		dsi->format =3D be16_to_cpu(mipi->firmware->config->dsi_format);
+		dsi->mode_flags =3D
+			be32_to_cpu(mipi->firmware->config->dsi_mode_flags);
+	}
+
+	/* Load from the DT */
+	of_property_read_u32(dsi->dev.of_node, "dsi-lanes", &dsi->lanes);
+	if (!of_property_read_string(dsi->dev.of_node, "dsi-format", &format)) {
+		if (!strcmp(format, "rgb888"))
+			dsi->format =3D MIPI_DSI_FMT_RGB888;
+		else if (!strcmp(format, "rgb666"))
+			dsi->format =3D MIPI_DSI_FMT_RGB666;
+		else if (!strcmp(format, "rgb666-packed"))
+			dsi->format =3D MIPI_DSI_FMT_RGB666_PACKED;
+		else if (!strcmp(format, "rgb565"))
+			dsi->format =3D MIPI_DSI_FMT_RGB565;
+		else
+			return dev_err_probe(&dsi->dev, -EINVAL,
+					     "%pOF: Unknown dsi-format '%s'\n",
+					     dsi->dev.of_node, format);
+	}
+	dsi->mode_flags |=3D panel_mipi_read_dsi_mode_props(dsi->dev.of_node);
+
+	if (!dsi->lanes)
+		return dev_err_probe(&dsi->dev, -EINVAL,
+				     "dsi-lanes =3D=3D 0 for DSI panel\n");
+
+	/* Adjust bus_format */
+	switch (dsi->format) {
+	case MIPI_DSI_FMT_RGB888:
+		mipi->bus_format =3D MEDIA_BUS_FMT_RGB888_1X24;
+		break;
+	case MIPI_DSI_FMT_RGB666:
+		mipi->bus_format =3D MEDIA_BUS_FMT_RGB666_1X24_CPADHI;
+		break;
+	case MIPI_DSI_FMT_RGB666_PACKED:
+		mipi->bus_format =3D MEDIA_BUS_FMT_RGB666_1X18;
+		break;
+	case MIPI_DSI_FMT_RGB565:
+		mipi->bus_format =3D MEDIA_BUS_FMT_RGB565_1X16;
+		break;
+	}
+
+	err =3D mipi_dsi_attach(dsi);
+	if (err)
+		return dev_err_probe(&dsi->dev, err, "Failed to init DSI\n");
+
+	return 0;
+}
+
+static int panel_mipi_spi_probe(struct spi_device *spi)
+{
+	struct panel_mipi *mipi;
+	struct gpio_desc *dc;
+	int err;
+
+	err =3D panel_mipi_probe(&spi->dev, DRM_MODE_CONNECTOR_DPI);
+	if (err)
+		return err;
+
+	mipi =3D dev_get_drvdata(&spi->dev);
+	mipi->write_command =3D panel_mipi_dbi_write;
+	mipi->read_command =3D panel_mipi_dbi_read;
+
+	dc =3D devm_gpiod_get_optional(&spi->dev, "dc", GPIOD_OUT_LOW);
+	if (IS_ERR(dc))
+		return dev_err_probe(&spi->dev, PTR_ERR(dc),
+				     "Failed to get GPIO for D/CX\n");
+
+	err =3D mipi_dbi_spi_init(spi, &mipi->dbi, dc);
+	if (err)
+		return dev_err_probe(&spi->dev, err, "Failed to init SPI\n");
+
+	return 0;
+}
+
+static void panel_mipi_dsi_remove(struct mipi_dsi_device *dsi)
+{
+	mipi_dsi_detach(dsi);
+}
+
+static const struct of_device_id panel_mipi_dsi_of_match[] =3D {
+	{ .compatible =3D "panel-mipi-dsi" },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, panel_mipi_dsi_of_match);
+
+static const struct of_device_id panel_mipi_spi_of_match[] =3D {
+	{ .compatible =3D "panel-mipi-dpi-spi" },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, panel_mipi_spi_of_match);
+
+static const struct spi_device_id panel_mipi_spi_ids[] =3D {
+	{ "panel-mipi-dpi-spi" },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(spi, panel_mipi_spi_ids);
+
+static struct mipi_dsi_driver panel_mipi_dsi_driver =3D {
+	.probe		=3D panel_mipi_dsi_probe,
+	.remove		=3D panel_mipi_dsi_remove,
+	.driver =3D {
+		.name		=3D "panel-mipi",
+		.of_match_table	=3D panel_mipi_dsi_of_match,
+	},
+};
+
+static struct spi_driver panel_mipi_spi_driver =3D {
+	.probe		=3D panel_mipi_spi_probe,
+	.id_table	=3D panel_mipi_spi_ids,
+	.driver =3D {
+		.name		=3D "panel-mipi",
+		.of_match_table	=3D panel_mipi_spi_of_match,
+	},
+};
+
+static int __init panel_mipi_driver_init(void)
+{
+	int err;
+
+	if (IS_ENABLED(CONFIG_SPI)) {
+		err =3D spi_register_driver(&panel_mipi_spi_driver);
+		if (err)
+			return err;
+	}
+
+	if (IS_ENABLED(CONFIG_DRM_MIPI_DSI)) {
+		err =3D mipi_dsi_driver_register(&panel_mipi_dsi_driver);
+		if (err) {
+			if (IS_ENABLED(CONFIG_SPI))
+				spi_unregister_driver(&panel_mipi_spi_driver);
+			return err;
+		}
+	}
+
+	return 0;
+}
+module_init(panel_mipi_driver_init);
+
+static void __exit panel_mipi_driver_exit(void)
+{
+	if (IS_ENABLED(CONFIG_DRM_MIPI_DSI))
+		mipi_dsi_driver_unregister(&panel_mipi_dsi_driver);
+
+	if (IS_ENABLED(CONFIG_SPI))
+		spi_unregister_driver(&panel_mipi_spi_driver);
+}
+module_exit(panel_mipi_driver_exit);
+
+MODULE_DESCRIPTION("Generic MIPI-DSI/DPI(+SPI) Panel Driver");
+MODULE_AUTHOR("Hironori KIKUCHI <kikuchan98@gmail.com>");
+MODULE_LICENSE("GPL v2");
--=20
2.48.1