Merge branch 'drm-next' of git://people.freedesktop.org/~airlied/linux

Pull drm updates from Dave Airlie:
 "Highlights:

   - AMD KFD driver merge

     This is the AMD HSA interface for exposing a lowlevel interface for
     GPGPU use.  They have an open source userspace built on top of this
     interface, and the code looks as good as it was going to get out of
     tree.

   - Initial atomic modesetting work

     The need for an atomic modesetting interface to allow userspace to
     try and send a complete set of modesetting state to the driver has
     arisen, and been suffering from neglect this past year.  No more,
     the start of the common code and changes for msm driver to use it
     are in this tree.  Ongoing work to get the userspace ioctl finished
     and the code clean will probably wait until next kernel.

   - DisplayID 1.3 and tiled monitor exposed to userspace.

     Tiled monitor property is now exposed for userspace to make use of.

   - Rockchip drm driver merged.

   - imx gpu driver moved out of staging

  Other stuff:

   - core:
        panel - MIPI DSI + new panels.
        expose suggested x/y properties for virtual GPUs

   - i915:
        Initial Skylake (SKL) support
        gen3/4 reset work
        start of dri1/ums removal
        infoframe tracking
        fixes for lots of things.

   - nouveau:
        tegra k1 voltage support
        GM204 modesetting support
        GT21x memory reclocking work

   - radeon:
        CI dpm fixes
        GPUVM improvements
        Initial DPM fan control

   - rcar-du:
        HDMI support added
        removed some support for old boards
        slave encoder driver for Analog Devices adv7511

   - exynos:
        Exynos4415 SoC support

   - msm:
        a4xx gpu support
        atomic helper conversion

   - tegra:
        iommu support
        universal plane support
        ganged-mode DSI support

   - sti:
        HDMI i2c improvements

   - vmwgfx:
        some late fixes.

   - qxl:
        use suggested x/y properties"

* 'drm-next' of git://people.freedesktop.org/~airlied/linux: (969 commits)
  drm: sti: fix module compilation issue
  drm/i915: save/restore GMBUS freq across suspend/resume on gen4
  drm: sti: correctly cleanup CRTC and planes
  drm: sti: add HQVDP plane
  drm: sti: add cursor plane
  drm: sti: enable auxiliary CRTC
  drm: sti: fix delay in VTG programming
  drm: sti: prepare sti_tvout to support auxiliary crtc
  drm: sti: use drm_crtc_vblank_{on/off} instead of drm_vblank_{on/off}
  drm: sti: fix hdmi avi infoframe
  drm: sti: remove event lock while disabling vblank
  drm: sti: simplify gdp code
  drm: sti: clear all mixer control
  drm: sti: remove gpio for HDMI hot plug detection
  drm: sti: allow to change hdmi ddc i2c adapter
  drm/doc: Document drm_add_modes_noedid() usage
  drm/i915: Remove '& 0xffff' from the mask given to WA_REG()
  drm/i915: Invert the mask and val arguments in wa_add() and WA_REG()
  drm: Zero out DRM object memory upon cleanup
  drm/i915/bdw: Fix the write setting up the WIZ hashing mode
  ...

6 files changed, 605 insertions, 49 deletions

diff --git a/drivers/gpu/drm/panel/Kconfig b/drivers/gpu/drm/panel/Kconfig
index bee9f72b3a93..024e98ef8e4d 100644
--- a/drivers/gpu/drm/panel/Kconfig
+++ b/drivers/gpu/drm/panel/Kconfig
@@ -27,4 +27,17 @@ config DRM_PANEL_S6E8AA0
         select DRM_MIPI_DSI
         select VIDEOMODE_HELPERS
 
+config DRM_PANEL_SHARP_LQ101R1SX01
+        tristate "Sharp LQ101R1SX01 panel"
+        depends on OF
+        depends on DRM_MIPI_DSI
+        help
+          Say Y here if you want to enable support for Sharp LQ101R1SX01
+          TFT-LCD modules. The panel has a 2560x1600 resolution and uses
+          24 bit RGB per pixel. It provides a dual MIPI DSI interface to
+          the host and has a built-in LED backlight.
+
+          To compile this driver as a module, choose M here: the module
+          will be called panel-sharp-lq101r1sx01.
+
 endmenu
diff --git a/drivers/gpu/drm/panel/Makefile b/drivers/gpu/drm/panel/Makefile
index 8b929212fad7..4b2a0430804b 100644
--- a/drivers/gpu/drm/panel/Makefile
+++ b/drivers/gpu/drm/panel/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_DRM_PANEL_SIMPLE) += panel-simple.o
 obj-$(CONFIG_DRM_PANEL_LD9040) += panel-ld9040.o
 obj-$(CONFIG_DRM_PANEL_S6E8AA0) += panel-s6e8aa0.o
+obj-$(CONFIG_DRM_PANEL_SHARP_LQ101R1SX01) += panel-sharp-lq101r1sx01.o
diff --git a/drivers/gpu/drm/panel/panel-ld9040.c b/drivers/gpu/drm/panel/panel-ld9040.c
index 42ac67b21e9f..08cf2c588c3d 100644
--- a/drivers/gpu/drm/panel/panel-ld9040.c
+++ b/drivers/gpu/drm/panel/panel-ld9040.c
@@ -145,7 +145,7 @@ static void ld9040_dcs_write(struct ld9040 *ctx, const u8 *data, size_t len)
         if (ctx->error < 0 || len == 0)
                 return;
 
-        dev_dbg(ctx->dev, "writing dcs seq: %*ph\n", len, data);
+        dev_dbg(ctx->dev, "writing dcs seq: %*ph\n", (int)len, data);
         ret = ld9040_spi_write_word(ctx, *data);
 
         while (!ret && --len) {
@@ -154,8 +154,8 @@ static void ld9040_dcs_write(struct ld9040 *ctx, const u8 *data, size_t len)
         }
 
         if (ret) {
-                dev_err(ctx->dev, "error %d writing dcs seq: %*ph\n", ret, len,
-                        data);
+                dev_err(ctx->dev, "error %d writing dcs seq: %*ph\n", ret,
+                        (int)len, data);
                 ctx->error = ret;
         }
 
@@ -336,17 +336,12 @@ static int ld9040_probe(struct spi_device *spi)
         if (ret < 0)
                 return ret;
 
-        ctx->reset_gpio = devm_gpiod_get(dev, "reset");
+        ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
         if (IS_ERR(ctx->reset_gpio)) {
                 dev_err(dev, "cannot get reset-gpios %ld\n",
                         PTR_ERR(ctx->reset_gpio));
                 return PTR_ERR(ctx->reset_gpio);
         }
-        ret = gpiod_direction_output(ctx->reset_gpio, 1);
-        if (ret < 0) {
-                dev_err(dev, "cannot configure reset-gpios %d\n", ret);
-                return ret;
-        }
 
         spi->bits_per_word = 9;
         ret = spi_setup(spi);
diff --git a/drivers/gpu/drm/panel/panel-s6e8aa0.c b/drivers/gpu/drm/panel/panel-s6e8aa0.c
index b5217fe37f02..144b2733e3d7 100644
--- a/drivers/gpu/drm/panel/panel-s6e8aa0.c
+++ b/drivers/gpu/drm/panel/panel-s6e8aa0.c
@@ -141,10 +141,10 @@ static void s6e8aa0_dcs_write(struct s6e8aa0 *ctx, const void *data, size_t len)
         if (ctx->error < 0)
                 return;
 
-        ret = mipi_dsi_dcs_write(dsi, data, len);
+        ret = mipi_dsi_dcs_write_buffer(dsi, data, len);
         if (ret < 0) {
-                dev_err(ctx->dev, "error %zd writing dcs seq: %*ph\n", ret, len,
-                        data);
+                dev_err(ctx->dev, "error %zd writing dcs seq: %*ph\n", ret,
+                        (int)len, data);
                 ctx->error = ret;
         }
 }
@@ -800,27 +800,15 @@ static void s6e8aa0_panel_init(struct s6e8aa0 *ctx)
 }
 
 static void s6e8aa0_set_maximum_return_packet_size(struct s6e8aa0 *ctx,
-                                                   int size)
+                                                   u16 size)
 {
         struct mipi_dsi_device *dsi = to_mipi_dsi_device(ctx->dev);
-        const struct mipi_dsi_host_ops *ops = dsi->host->ops;
-        u8 buf[] = {size, 0};
-        struct mipi_dsi_msg msg = {
-                .channel = dsi->channel,
-                .type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
-                .tx_len = sizeof(buf),
-                .tx_buf = buf
-        };
         int ret;
 
         if (ctx->error < 0)
                 return;
 
-        if (!ops || !ops->transfer)
-                ret = -EIO;
-        else
-                ret = ops->transfer(dsi->host, &msg);
-
+        ret = mipi_dsi_set_maximum_return_packet_size(dsi, size);
         if (ret < 0) {
                 dev_err(ctx->dev,
                         "error %d setting maximum return packet size to %d\n",
@@ -1019,17 +1007,12 @@ static int s6e8aa0_probe(struct mipi_dsi_device *dsi)
                 return ret;
         }
 
-        ctx->reset_gpio = devm_gpiod_get(dev, "reset");
+        ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
         if (IS_ERR(ctx->reset_gpio)) {
                 dev_err(dev, "cannot get reset-gpios %ld\n",
                         PTR_ERR(ctx->reset_gpio));
                 return PTR_ERR(ctx->reset_gpio);
         }
-        ret = gpiod_direction_output(ctx->reset_gpio, 1);
-        if (ret < 0) {
-                dev_err(dev, "cannot configure reset-gpios %d\n", ret);
-                return ret;
-        }
 
         ctx->brightness = GAMMA_LEVEL_NUM - 1;
 
@@ -1069,7 +1052,6 @@ static struct mipi_dsi_driver s6e8aa0_driver = {
         .remove = s6e8aa0_remove,
         .driver = {
                 .name = "panel_s6e8aa0",
-                .owner = THIS_MODULE,
                 .of_match_table = s6e8aa0_of_match,
         },
 };
diff --git a/drivers/gpu/drm/panel/panel-sharp-lq101r1sx01.c b/drivers/gpu/drm/panel/panel-sharp-lq101r1sx01.c
new file mode 100644
index 000000000000..9d81759d82fc
--- /dev/null
+++ b/drivers/gpu/drm/panel/panel-sharp-lq101r1sx01.c
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2014 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/backlight.h>
+#include <linux/gpio/consumer.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/regulator/consumer.h>
+
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_mipi_dsi.h>
+#include <drm/drm_panel.h>
+
+#include <video/mipi_display.h>
+
+#include <linux/host1x.h>
+
+struct sharp_panel {
+        struct drm_panel base;
+        /* the datasheet refers to them as DSI-LINK1 and DSI-LINK2 */
+        struct mipi_dsi_device *link1;
+        struct mipi_dsi_device *link2;
+
+        struct backlight_device *backlight;
+        struct regulator *supply;
+
+        bool prepared;
+        bool enabled;
+
+        const struct drm_display_mode *mode;
+};
+
+static inline struct sharp_panel *to_sharp_panel(struct drm_panel *panel)
+{
+        return container_of(panel, struct sharp_panel, base);
+}
+
+static int sharp_panel_write(struct sharp_panel *sharp, u16 offset, u8 value)
+{
+        u8 payload[3] = { offset >> 8, offset & 0xff, value };
+        struct mipi_dsi_device *dsi = sharp->link1;
+        ssize_t err;
+
+        err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
+        if (err < 0) {
+                dev_err(&dsi->dev, "failed to write %02x to %04x: %zd\n",
+                        value, offset, err);
+                return err;
+        }
+
+        err = mipi_dsi_dcs_nop(dsi);
+        if (err < 0) {
+                dev_err(&dsi->dev, "failed to send DCS nop: %zd\n", err);
+                return err;
+        }
+
+        usleep_range(10, 20);
+
+        return 0;
+}
+
+static __maybe_unused int sharp_panel_read(struct sharp_panel *sharp,
+                                           u16 offset, u8 *value)
+{
+        ssize_t err;
+
+        cpu_to_be16s(&offset);
+
+        err = mipi_dsi_generic_read(sharp->link1, &offset, sizeof(offset),
+                                    value, sizeof(*value));
+        if (err < 0)
+                dev_err(&sharp->link1->dev, "failed to read from %04x: %zd\n",
+                        offset, err);
+
+        return err;
+}
+
+static int sharp_panel_disable(struct drm_panel *panel)
+{
+        struct sharp_panel *sharp = to_sharp_panel(panel);
+
+        if (!sharp->enabled)
+                return 0;
+
+        if (sharp->backlight) {
+                sharp->backlight->props.power = FB_BLANK_POWERDOWN;
+                backlight_update_status(sharp->backlight);
+        }
+
+        sharp->enabled = false;
+
+        return 0;
+}
+
+static int sharp_panel_unprepare(struct drm_panel *panel)
+{
+        struct sharp_panel *sharp = to_sharp_panel(panel);
+        int err;
+
+        if (!sharp->prepared)
+                return 0;
+
+        err = mipi_dsi_dcs_set_display_off(sharp->link1);
+        if (err < 0)
+                dev_err(panel->dev, "failed to set display off: %d\n", err);
+
+        err = mipi_dsi_dcs_enter_sleep_mode(sharp->link1);
+        if (err < 0)
+                dev_err(panel->dev, "failed to enter sleep mode: %d\n", err);
+
+        msleep(120);
+
+        regulator_disable(sharp->supply);
+
+        sharp->prepared = false;
+
+        return 0;
+}
+
+static int sharp_setup_symmetrical_split(struct mipi_dsi_device *left,
+                                         struct mipi_dsi_device *right,
+                                         const struct drm_display_mode *mode)
+{
+        int err;
+
+        err = mipi_dsi_dcs_set_column_address(left, 0, mode->hdisplay / 2 - 1);
+        if (err < 0) {
+                dev_err(&left->dev, "failed to set column address: %d\n", err);
+                return err;
+        }
+
+        err = mipi_dsi_dcs_set_page_address(left, 0, mode->vdisplay - 1);
+        if (err < 0) {
+                dev_err(&left->dev, "failed to set page address: %d\n", err);
+                return err;
+        }
+
+        err = mipi_dsi_dcs_set_column_address(right, mode->hdisplay / 2,
+                                              mode->hdisplay - 1);
+        if (err < 0) {
+                dev_err(&right->dev, "failed to set column address: %d\n", err);
+                return err;
+        }
+
+        err = mipi_dsi_dcs_set_page_address(right, 0, mode->vdisplay - 1);
+        if (err < 0) {
+                dev_err(&right->dev, "failed to set page address: %d\n", err);
+                return err;
+        }
+
+        return 0;
+}
+
+static int sharp_panel_prepare(struct drm_panel *panel)
+{
+        struct sharp_panel *sharp = to_sharp_panel(panel);
+        u8 format = MIPI_DCS_PIXEL_FMT_24BIT;
+        int err;
+
+        if (sharp->prepared)
+                return 0;
+
+        err = regulator_enable(sharp->supply);
+        if (err < 0)
+                return err;
+
+        usleep_range(10000, 20000);
+
+        err = mipi_dsi_dcs_soft_reset(sharp->link1);
+        if (err < 0) {
+                dev_err(panel->dev, "soft reset failed: %d\n", err);
+                goto poweroff;
+        }
+
+        msleep(120);
+
+        err = mipi_dsi_dcs_exit_sleep_mode(sharp->link1);
+        if (err < 0) {
+                dev_err(panel->dev, "failed to exit sleep mode: %d\n", err);
+                goto poweroff;
+        }
+
+        /*
+         * The MIPI DCS specification mandates this delay only between the
+         * exit_sleep_mode and enter_sleep_mode commands, so it isn't strictly
+         * necessary here.
+         */
+        /*
+        msleep(120);
+        */
+
+        /* set left-right mode */
+        err = sharp_panel_write(sharp, 0x1000, 0x2a);
+        if (err < 0) {
+                dev_err(panel->dev, "failed to set left-right mode: %d\n", err);
+                goto poweroff;
+        }
+
+        /* enable command mode */
+        err = sharp_panel_write(sharp, 0x1001, 0x01);
+        if (err < 0) {
+                dev_err(panel->dev, "failed to enable command mode: %d\n", err);
+                goto poweroff;
+        }
+
+        err = mipi_dsi_dcs_set_pixel_format(sharp->link1, format);
+        if (err < 0) {
+                dev_err(panel->dev, "failed to set pixel format: %d\n", err);
+                goto poweroff;
+        }
+
+        /*
+         * TODO: The device supports both left-right and even-odd split
+         * configurations, but this driver currently supports only the left-
+         * right split. To support a different mode a mechanism needs to be
+         * put in place to communicate the configuration back to the DSI host
+         * controller.
+         */
+        err = sharp_setup_symmetrical_split(sharp->link1, sharp->link2,
+                                            sharp->mode);
+        if (err < 0) {
+                dev_err(panel->dev, "failed to set up symmetrical split: %d\n",
+                        err);
+                goto poweroff;
+        }
+
+        err = mipi_dsi_dcs_set_display_on(sharp->link1);
+        if (err < 0) {
+                dev_err(panel->dev, "failed to set display on: %d\n", err);
+                goto poweroff;
+        }
+
+        sharp->prepared = true;
+
+        return 0;
+
+poweroff:
+        regulator_disable(sharp->supply);
+        return err;
+}
+
+static int sharp_panel_enable(struct drm_panel *panel)
+{
+        struct sharp_panel *sharp = to_sharp_panel(panel);
+
+        if (sharp->enabled)
+                return 0;
+
+        if (sharp->backlight) {
+                sharp->backlight->props.power = FB_BLANK_UNBLANK;
+                backlight_update_status(sharp->backlight);
+        }
+
+        sharp->enabled = true;
+
+        return 0;
+}
+
+static const struct drm_display_mode default_mode = {
+        .clock = 278000,
+        .hdisplay = 2560,
+        .hsync_start = 2560 + 128,
+        .hsync_end = 2560 + 128 + 64,
+        .htotal = 2560 + 128 + 64 + 64,
+        .vdisplay = 1600,
+        .vsync_start = 1600 + 4,
+        .vsync_end = 1600 + 4 + 8,
+        .vtotal = 1600 + 4 + 8 + 32,
+        .vrefresh = 60,
+};
+
+static int sharp_panel_get_modes(struct drm_panel *panel)
+{
+        struct drm_display_mode *mode;
+
+        mode = drm_mode_duplicate(panel->drm, &default_mode);
+        if (!mode) {
+                dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+                        default_mode.hdisplay, default_mode.vdisplay,
+                        default_mode.vrefresh);
+                return -ENOMEM;
+        }
+
+        drm_mode_set_name(mode);
+
+        drm_mode_probed_add(panel->connector, mode);
+
+        panel->connector->display_info.width_mm = 217;
+        panel->connector->display_info.height_mm = 136;
+
+        return 1;
+}
+
+static const struct drm_panel_funcs sharp_panel_funcs = {
+        .disable = sharp_panel_disable,
+        .unprepare = sharp_panel_unprepare,
+        .prepare = sharp_panel_prepare,
+        .enable = sharp_panel_enable,
+        .get_modes = sharp_panel_get_modes,
+};
+
+static const struct of_device_id sharp_of_match[] = {
+        { .compatible = "sharp,lq101r1sx01", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, sharp_of_match);
+
+static int sharp_panel_add(struct sharp_panel *sharp)
+{
+        struct device_node *np;
+        int err;
+
+        sharp->mode = &default_mode;
+
+        sharp->supply = devm_regulator_get(&sharp->link1->dev, "power");
+        if (IS_ERR(sharp->supply))
+                return PTR_ERR(sharp->supply);
+
+        np = of_parse_phandle(sharp->link1->dev.of_node, "backlight", 0);
+        if (np) {
+                sharp->backlight = of_find_backlight_by_node(np);
+                of_node_put(np);
+
+                if (!sharp->backlight)
+                        return -EPROBE_DEFER;
+        }
+
+        drm_panel_init(&sharp->base);
+        sharp->base.funcs = &sharp_panel_funcs;
+        sharp->base.dev = &sharp->link1->dev;
+
+        err = drm_panel_add(&sharp->base);
+        if (err < 0)
+                goto put_backlight;
+
+        return 0;
+
+put_backlight:
+        if (sharp->backlight)
+                put_device(&sharp->backlight->dev);
+
+        return err;
+}
+
+static void sharp_panel_del(struct sharp_panel *sharp)
+{
+        if (sharp->base.dev)
+                drm_panel_remove(&sharp->base);
+
+        if (sharp->backlight)
+                put_device(&sharp->backlight->dev);
+
+        if (sharp->link2)
+                put_device(&sharp->link2->dev);
+}
+
+static int sharp_panel_probe(struct mipi_dsi_device *dsi)
+{
+        struct mipi_dsi_device *secondary = NULL;
+        struct sharp_panel *sharp;
+        struct device_node *np;
+        int err;
+
+        dsi->lanes = 4;
+        dsi->format = MIPI_DSI_FMT_RGB888;
+        dsi->mode_flags = MIPI_DSI_MODE_LPM;
+
+        /* Find DSI-LINK1 */
+        np = of_parse_phandle(dsi->dev.of_node, "link2", 0);
+        if (np) {
+                secondary = of_find_mipi_dsi_device_by_node(np);
+                of_node_put(np);
+
+                if (!secondary)
+                        return -EPROBE_DEFER;
+        }
+
+        /* register a panel for only the DSI-LINK1 interface */
+        if (secondary) {
+                sharp = devm_kzalloc(&dsi->dev, sizeof(*sharp), GFP_KERNEL);
+                if (!sharp) {
+                        put_device(&secondary->dev);
+                        return -ENOMEM;
+                }
+
+                mipi_dsi_set_drvdata(dsi, sharp);
+
+                sharp->link2 = secondary;
+                sharp->link1 = dsi;
+
+                err = sharp_panel_add(sharp);
+                if (err < 0) {
+                        put_device(&secondary->dev);
+                        return err;
+                }
+        }
+
+        err = mipi_dsi_attach(dsi);
+        if (err < 0) {
+                if (secondary)
+                        sharp_panel_del(sharp);
+
+                return err;
+        }
+
+        return 0;
+}
+
+static int sharp_panel_remove(struct mipi_dsi_device *dsi)
+{
+        struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
+        int err;
+
+        /* only detach from host for the DSI-LINK2 interface */
+        if (!sharp) {
+                mipi_dsi_detach(dsi);
+                return 0;
+        }
+
+        err = sharp_panel_disable(&sharp->base);
+        if (err < 0)
+                dev_err(&dsi->dev, "failed to disable panel: %d\n", err);
+
+        err = mipi_dsi_detach(dsi);
+        if (err < 0)
+                dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err);
+
+        drm_panel_detach(&sharp->base);
+        sharp_panel_del(sharp);
+
+        return 0;
+}
+
+static void sharp_panel_shutdown(struct mipi_dsi_device *dsi)
+{
+        struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
+
+        /* nothing to do for DSI-LINK2 */
+        if (!sharp)
+                return;
+
+        sharp_panel_disable(&sharp->base);
+}
+
+static struct mipi_dsi_driver sharp_panel_driver = {
+        .driver = {
+                .name = "panel-sharp-lq101r1sx01",
+                .of_match_table = sharp_of_match,
+        },
+        .probe = sharp_panel_probe,
+        .remove = sharp_panel_remove,
+        .shutdown = sharp_panel_shutdown,
+};
+module_mipi_dsi_driver(sharp_panel_driver);
+
+MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
+MODULE_DESCRIPTION("Sharp LQ101R1SX01 panel driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/gpu/drm/panel/panel-simple.c b/drivers/gpu/drm/panel/panel-simple.c
index 12bc8a0ab1cf..e95385bf8356 100644
--- a/drivers/gpu/drm/panel/panel-simple.c
+++ b/drivers/gpu/drm/panel/panel-simple.c
@@ -247,21 +247,14 @@ static int panel_simple_probe(struct device *dev, const struct panel_desc *desc)
         if (IS_ERR(panel->supply))
                 return PTR_ERR(panel->supply);
 
-        panel->enable_gpio = devm_gpiod_get_optional(dev, "enable");
+        panel->enable_gpio = devm_gpiod_get_optional(dev, "enable",
+                                                     GPIOD_OUT_LOW);
         if (IS_ERR(panel->enable_gpio)) {
                 err = PTR_ERR(panel->enable_gpio);
                 dev_err(dev, "failed to request GPIO: %d\n", err);
                 return err;
         }
 
-        if (panel->enable_gpio) {
-                err = gpiod_direction_output(panel->enable_gpio, 0);
-                if (err < 0) {
-                        dev_err(dev, "failed to setup GPIO: %d\n", err);
-                        return err;
-                }
-        }
-
         backlight = of_parse_phandle(dev->of_node, "backlight", 0);
         if (backlight) {
                 panel->backlight = of_find_backlight_by_node(backlight);
@@ -376,6 +369,29 @@ static const struct panel_desc auo_b101xtn01 = {
         },
 };
 
+static const struct drm_display_mode auo_b116xw03_mode = {
+        .clock = 70589,
+        .hdisplay = 1366,
+        .hsync_start = 1366 + 40,
+        .hsync_end = 1366 + 40 + 40,
+        .htotal = 1366 + 40 + 40 + 32,
+        .vdisplay = 768,
+        .vsync_start = 768 + 10,
+        .vsync_end = 768 + 10 + 12,
+        .vtotal = 768 + 10 + 12 + 6,
+        .vrefresh = 60,
+};
+
+static const struct panel_desc auo_b116xw03 = {
+        .modes = &auo_b116xw03_mode,
+        .num_modes = 1,
+        .bpc = 6,
+        .size = {
+                .width = 256,
+                .height = 144,
+        },
+};
+
 static const struct drm_display_mode auo_b133xtn01_mode = {
         .clock = 69500,
         .hdisplay = 1366,
@@ -415,6 +431,7 @@ static const struct drm_display_mode auo_b133htn01_mode = {
 static const struct panel_desc auo_b133htn01 = {
         .modes = &auo_b133htn01_mode,
         .num_modes = 1,
+        .bpc = 6,
         .size = {
                 .width = 293,
                 .height = 165,
@@ -536,22 +553,92 @@ static const struct drm_display_mode foxlink_fl500wvr00_a0t_mode = {
 static const struct panel_desc foxlink_fl500wvr00_a0t = {
         .modes = &foxlink_fl500wvr00_a0t_mode,
         .num_modes = 1,
+        .bpc = 8,
         .size = {
                 .width = 108,
                 .height = 65,
         },
 };
 
-static const struct drm_display_mode innolux_n116bge_mode = {
+static const struct drm_display_mode hannstar_hsd070pww1_mode = {
+        .clock = 71100,
+        .hdisplay = 1280,
+        .hsync_start = 1280 + 1,
+        .hsync_end = 1280 + 1 + 158,
+        .htotal = 1280 + 1 + 158 + 1,
+        .vdisplay = 800,
+        .vsync_start = 800 + 1,
+        .vsync_end = 800 + 1 + 21,
+        .vtotal = 800 + 1 + 21 + 1,
+        .vrefresh = 60,
+};
+
+static const struct panel_desc hannstar_hsd070pww1 = {
+        .modes = &hannstar_hsd070pww1_mode,
+        .num_modes = 1,
+        .bpc = 6,
+        .size = {
+                .width = 151,
+                .height = 94,
+        },
+};
+
+static const struct drm_display_mode hitachi_tx23d38vm0caa_mode = {
+        .clock = 33333,
+        .hdisplay = 800,
+        .hsync_start = 800 + 85,
+        .hsync_end = 800 + 85 + 86,
+        .htotal = 800 + 85 + 86 + 85,
+        .vdisplay = 480,
+        .vsync_start = 480 + 16,
+        .vsync_end = 480 + 16 + 13,
+        .vtotal = 480 + 16 + 13 + 16,
+        .vrefresh = 60,
+};
+
+static const struct panel_desc hitachi_tx23d38vm0caa = {
+        .modes = &hitachi_tx23d38vm0caa_mode,
+        .num_modes = 1,
+        .bpc = 6,
+        .size = {
+                .width = 195,
+                .height = 117,
+        },
+};
+
+static const struct drm_display_mode innolux_g121i1_l01_mode = {
         .clock = 71000,
+        .hdisplay = 1280,
+        .hsync_start = 1280 + 64,
+        .hsync_end = 1280 + 64 + 32,
+        .htotal = 1280 + 64 + 32 + 64,
+        .vdisplay = 800,
+        .vsync_start = 800 + 9,
+        .vsync_end = 800 + 9 + 6,
+        .vtotal = 800 + 9 + 6 + 9,
+        .vrefresh = 60,
+};
+
+static const struct panel_desc innolux_g121i1_l01 = {
+        .modes = &innolux_g121i1_l01_mode,
+        .num_modes = 1,
+        .bpc = 6,
+        .size = {
+                .width = 261,
+                .height = 163,
+        },
+};
+
+static const struct drm_display_mode innolux_n116bge_mode = {
+        .clock = 76420,
         .hdisplay = 1366,
-        .hsync_start = 1366 + 64,
-        .hsync_end = 1366 + 64 + 6,
-        .htotal = 1366 + 64 + 6 + 64,
+        .hsync_start = 1366 + 136,
+        .hsync_end = 1366 + 136 + 30,
+        .htotal = 1366 + 136 + 30 + 60,
         .vdisplay = 768,
         .vsync_start = 768 + 8,
-        .vsync_end = 768 + 8 + 4,
-        .vtotal = 768 + 8 + 4 + 8,
+        .vsync_end = 768 + 8 + 12,
+        .vtotal = 768 + 8 + 12 + 12,
         .vrefresh = 60,
         .flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
 };
@@ -643,6 +730,9 @@ static const struct of_device_id platform_of_match[] = {
                 .compatible = "auo,b101xtn01",
                 .data = &auo_b101xtn01,
         }, {
+                .compatible = "auo,b116xw03",
+                .data = &auo_b116xw03,
+        }, {
                 .compatible = "auo,b133htn01",
                 .data = &auo_b133htn01,
         }, {
@@ -667,6 +757,15 @@ static const struct of_device_id platform_of_match[] = {
                 .compatible = "foxlink,fl500wvr00-a0t",
                 .data = &foxlink_fl500wvr00_a0t,
         }, {
+                .compatible = "hannstar,hsd070pww1",
+                .data = &hannstar_hsd070pww1,
+        }, {
+                .compatible = "hit,tx23d38vm0caa",
+                .data = &hitachi_tx23d38vm0caa
+        }, {
+                .compatible ="innolux,g121i1-l01",
+                .data = &innolux_g121i1_l01
+        }, {
                 .compatible = "innolux,n116bge",
                 .data = &innolux_n116bge,
         }, {
@@ -740,6 +839,7 @@ static const struct panel_desc_dsi lg_ld070wx3_sl01 = {
         .desc = {
                 .modes = &lg_ld070wx3_sl01_mode,
                 .num_modes = 1,
+                .bpc = 8,
                 .size = {
                         .width = 94,
                         .height = 151,
@@ -767,6 +867,7 @@ static const struct panel_desc_dsi lg_lh500wx1_sd03 = {
         .desc = {
                 .modes = &lg_lh500wx1_sd03_mode,
                 .num_modes = 1,
+                .bpc = 8,
                 .size = {
                         .width = 62,
                         .height = 110,
@@ -794,6 +895,7 @@ static const struct panel_desc_dsi panasonic_vvx10f004b00 = {
         .desc = {
                 .modes = &panasonic_vvx10f004b00_mode,
                 .num_modes = 1,
+                .bpc = 8,
                 .size = {
                         .width = 217,
                         .height = 136,
@@ -863,7 +965,6 @@ static void panel_simple_dsi_shutdown(struct mipi_dsi_device *dsi)
 static struct mipi_dsi_driver panel_simple_dsi_driver = {
         .driver = {
                 .name = "panel-simple-dsi",
-                .owner = THIS_MODULE,
                 .of_match_table = dsi_of_match,
         },
         .probe = panel_simple_dsi_probe,