drivers/gpu/drm/panel/panel-samsung-s6d16d0.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * MIPI-DSI Samsung s6d16d0 panel driver. This is a 864x480
   4  * AMOLED panel with a command-only DSI interface.
   5  */
   6
   7 #include <drm/drm_modes.h>
   8 #include <drm/drm_mipi_dsi.h>
   9 #include <drm/drm_panel.h>
  10
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/regulator/consumer.h>
  13 #include <linux/delay.h>
  14 #include <linux/of_device.h>
  15 #include <linux/module.h>
  16
  17 struct s6d16d0 {
  18         struct device *dev;
  19         struct drm_panel panel;
  20         struct regulator *supply;
  21         struct gpio_desc *reset_gpio;
  22 };
  23
  24 /*
  25  * The timings are not very helpful as the display is used in
  26  * command mode.
  27  */
  28 static const struct drm_display_mode samsung_s6d16d0_mode = {
  29         /* HS clock, (htotal*vtotal*vrefresh)/1000 */
  30         .clock = 420160,
  31         .hdisplay = 864,
  32         .hsync_start = 864 + 154,
  33         .hsync_end = 864 + 154 + 16,
  34         .htotal = 864 + 154 + 16 + 32,
  35         .vdisplay = 480,
  36         .vsync_start = 480 + 1,
  37         .vsync_end = 480 + 1 + 1,
  38         .vtotal = 480 + 1 + 1 + 1,
  39         .width_mm = 84,
  40         .height_mm = 48,
  41 };
  42
  43 static inline struct s6d16d0 *panel_to_s6d16d0(struct drm_panel *panel)
  44 {
  45         return container_of(panel, struct s6d16d0, panel);
  46 }
  47
  48 static int s6d16d0_unprepare(struct drm_panel *panel)
  49 {
  50         struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
  51         struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
  52         int ret;
  53
  54         /* Enter sleep mode */
  55         ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
  56         if (ret) {
  57                 dev_err(s6->dev, "failed to enter sleep mode (%d)\n", ret);
  58                 return ret;
  59         }
  60
  61         /* Assert RESET */
  62         gpiod_set_value_cansleep(s6->reset_gpio, 1);
  63         regulator_disable(s6->supply);
  64
  65         return 0;
  66 }
  67
  68 static int s6d16d0_prepare(struct drm_panel *panel)
  69 {
  70         struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
  71         struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
  72         int ret;
  73
  74         ret = regulator_enable(s6->supply);
  75         if (ret) {
  76                 dev_err(s6->dev, "failed to enable supply (%d)\n", ret);
  77                 return ret;
  78         }
  79
  80         /* Assert RESET */
  81         gpiod_set_value_cansleep(s6->reset_gpio, 1);
  82         udelay(10);
  83         /* De-assert RESET */
  84         gpiod_set_value_cansleep(s6->reset_gpio, 0);
  85         msleep(120);
  86
  87         /* Enabe tearing mode: send TE (tearing effect) at VBLANK */
  88         ret = mipi_dsi_dcs_set_tear_on(dsi,
  89                                        MIPI_DSI_DCS_TEAR_MODE_VBLANK);
  90         if (ret) {
  91                 dev_err(s6->dev, "failed to enable vblank TE (%d)\n", ret);
  92                 return ret;
  93         }
  94         /* Exit sleep mode and power on */
  95         ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
  96         if (ret) {
  97                 dev_err(s6->dev, "failed to exit sleep mode (%d)\n", ret);
  98                 return ret;
  99         }
 100
 101         return 0;
 102 }
 103
 104 static int s6d16d0_enable(struct drm_panel *panel)
 105 {
 106         struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
 107         struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
 108         int ret;
 109
 110         ret = mipi_dsi_dcs_set_display_on(dsi);
 111         if (ret) {
 112                 dev_err(s6->dev, "failed to turn display on (%d)\n", ret);
 113                 return ret;
 114         }
 115
 116         return 0;
 117 }
 118
 119 static int s6d16d0_disable(struct drm_panel *panel)
 120 {
 121         struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
 122         struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
 123         int ret;
 124
 125         ret = mipi_dsi_dcs_set_display_off(dsi);
 126         if (ret) {
 127                 dev_err(s6->dev, "failed to turn display off (%d)\n", ret);
 128                 return ret;
 129         }
 130
 131         return 0;
 132 }
 133
 134 static int s6d16d0_get_modes(struct drm_panel *panel,
 135                              struct drm_connector *connector)
 136 {
 137         struct drm_display_mode *mode;
 138
 139         mode = drm_mode_duplicate(connector->dev, &samsung_s6d16d0_mode);
 140         if (!mode) {
 141                 dev_err(panel->dev, "bad mode or failed to add mode\n");
 142                 return -EINVAL;
 143         }
 144         drm_mode_set_name(mode);
 145         mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 146
 147         connector->display_info.width_mm = mode->width_mm;
 148         connector->display_info.height_mm = mode->height_mm;
 149
 150         drm_mode_probed_add(connector, mode);
 151
 152         return 1; /* Number of modes */
 153 }
 154
 155 static const struct drm_panel_funcs s6d16d0_drm_funcs = {
 156         .disable = s6d16d0_disable,
 157         .unprepare = s6d16d0_unprepare,
 158         .prepare = s6d16d0_prepare,
 159         .enable = s6d16d0_enable,
 160         .get_modes = s6d16d0_get_modes,
 161 };
 162
 163 static int s6d16d0_probe(struct mipi_dsi_device *dsi)
 164 {
 165         struct device *dev = &dsi->dev;
 166         struct s6d16d0 *s6;
 167         int ret;
 168
 169         s6 = devm_kzalloc(dev, sizeof(struct s6d16d0), GFP_KERNEL);
 170         if (!s6)
 171                 return -ENOMEM;
 172
 173         mipi_dsi_set_drvdata(dsi, s6);
 174         s6->dev = dev;
 175
 176         dsi->lanes = 2;
 177         dsi->format = MIPI_DSI_FMT_RGB888;
 178         dsi->hs_rate = 420160000;
 179         dsi->lp_rate = 19200000;
 180         /*
 181          * This display uses command mode so no MIPI_DSI_MODE_VIDEO
 182          * or MIPI_DSI_MODE_VIDEO_SYNC_PULSE
 183          *
 184          * As we only send commands we do not need to be continuously
 185          * clocked.
 186          */
 187         dsi->mode_flags = MIPI_DSI_CLOCK_NON_CONTINUOUS;
 188
 189         s6->supply = devm_regulator_get(dev, "vdd1");
 190         if (IS_ERR(s6->supply))
 191                 return PTR_ERR(s6->supply);
 192
 193         /* This asserts RESET by default */
 194         s6->reset_gpio = devm_gpiod_get_optional(dev, "reset",
 195                                                  GPIOD_OUT_HIGH);
 196         if (IS_ERR(s6->reset_gpio)) {
 197                 ret = PTR_ERR(s6->reset_gpio);
 198                 if (ret != -EPROBE_DEFER)
 199                         dev_err(dev, "failed to request GPIO (%d)\n", ret);
 200                 return ret;
 201         }
 202
 203         drm_panel_init(&s6->panel, dev, &s6d16d0_drm_funcs,
 204                        DRM_MODE_CONNECTOR_DSI);
 205
 206         drm_panel_add(&s6->panel);
 207
 208         ret = mipi_dsi_attach(dsi);
 209         if (ret < 0)
 210                 drm_panel_remove(&s6->panel);
 211
 212         return ret;
 213 }
 214
 215 static int s6d16d0_remove(struct mipi_dsi_device *dsi)
 216 {
 217         struct s6d16d0 *s6 = mipi_dsi_get_drvdata(dsi);
 218
 219         mipi_dsi_detach(dsi);
 220         drm_panel_remove(&s6->panel);
 221
 222         return 0;
 223 }
 224
 225 static const struct of_device_id s6d16d0_of_match[] = {
 226         { .compatible = "samsung,s6d16d0" },
 227         { }
 228 };
 229 MODULE_DEVICE_TABLE(of, s6d16d0_of_match);
 230
 231 static struct mipi_dsi_driver s6d16d0_driver = {
 232         .probe = s6d16d0_probe,
 233         .remove = s6d16d0_remove,
 234         .driver = {
 235                 .name = "panel-samsung-s6d16d0",
 236                 .of_match_table = s6d16d0_of_match,
 237         },
 238 };
 239 module_mipi_dsi_driver(s6d16d0_driver);
 240
 241 MODULE_AUTHOR("Linus Wallei <linus.walleij@linaro.org>");
 242 MODULE_DESCRIPTION("MIPI-DSI s6d16d0 Panel Driver");
 243 MODULE_LICENSE("GPL v2");