drivers/gpu/drm/panel/panel-jdi-fhd-r63452.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2021 Raffaele Tranquillini <raffaele.tranquillini@gmail.com>
   4  *
   5  * Generated using linux-mdss-dsi-panel-driver-generator from Lineage OS device tree:
   6  * https://github.com/LineageOS/android_kernel_xiaomi_msm8996/blob/lineage-18.1/arch/arm/boot/dts/qcom/a1-msm8996-mtp.dtsi
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/module.h>
  12 #include <linux/of.h>
  13
  14 #include <video/mipi_display.h>
  15
  16 #include <drm/drm_mipi_dsi.h>
  17 #include <drm/drm_modes.h>
  18 #include <drm/drm_panel.h>
  19
  20 struct jdi_fhd_r63452 {
  21         struct drm_panel panel;
  22         struct mipi_dsi_device *dsi;
  23         struct gpio_desc *reset_gpio;
  24         bool prepared;
  25 };
  26
  27 static inline struct jdi_fhd_r63452 *to_jdi_fhd_r63452(struct drm_panel *panel)
  28 {
  29         return container_of(panel, struct jdi_fhd_r63452, panel);
  30 }
  31
  32 #define dsi_generic_write_seq(dsi, seq...) do {                         \
  33                 static const u8 d[] = { seq };                          \
  34                 int ret;                                                \
  35                 ret = mipi_dsi_generic_write(dsi, d, ARRAY_SIZE(d));    \
  36                 if (ret < 0)                                            \
  37                         return ret;                                     \
  38         } while (0)
  39
  40 #define dsi_dcs_write_seq(dsi, seq...) do {                             \
  41                 static const u8 d[] = { seq };                          \
  42                 int ret;                                                \
  43                 ret = mipi_dsi_dcs_write_buffer(dsi, d, ARRAY_SIZE(d)); \
  44                 if (ret < 0)                                            \
  45                         return ret;                                     \
  46         } while (0)
  47
  48 static void jdi_fhd_r63452_reset(struct jdi_fhd_r63452 *ctx)
  49 {
  50         gpiod_set_value_cansleep(ctx->reset_gpio, 0);
  51         usleep_range(10000, 11000);
  52         gpiod_set_value_cansleep(ctx->reset_gpio, 1);
  53         usleep_range(1000, 2000);
  54         gpiod_set_value_cansleep(ctx->reset_gpio, 0);
  55         usleep_range(10000, 11000);
  56 }
  57
  58 static int jdi_fhd_r63452_on(struct jdi_fhd_r63452 *ctx)
  59 {
  60         struct mipi_dsi_device *dsi = ctx->dsi;
  61         struct device *dev = &dsi->dev;
  62         int ret;
  63
  64         dsi->mode_flags |= MIPI_DSI_MODE_LPM;
  65
  66         dsi_generic_write_seq(dsi, 0xb0, 0x00);
  67         dsi_generic_write_seq(dsi, 0xd6, 0x01);
  68         dsi_generic_write_seq(dsi, 0xec,
  69                               0x64, 0xdc, 0xec, 0x3b, 0x52, 0x00, 0x0b, 0x0b,
  70                               0x13, 0x15, 0x68, 0x0b, 0xb5);
  71         dsi_generic_write_seq(dsi, 0xb0, 0x03);
  72
  73         ret = mipi_dsi_dcs_set_tear_on(dsi, MIPI_DSI_DCS_TEAR_MODE_VBLANK);
  74         if (ret < 0) {
  75                 dev_err(dev, "Failed to set tear on: %d\n", ret);
  76                 return ret;
  77         }
  78
  79         dsi_dcs_write_seq(dsi, MIPI_DCS_SET_ADDRESS_MODE, 0x00);
  80
  81         ret = mipi_dsi_dcs_set_pixel_format(dsi, 0x77);
  82         if (ret < 0) {
  83                 dev_err(dev, "Failed to set pixel format: %d\n", ret);
  84                 return ret;
  85         }
  86
  87         ret = mipi_dsi_dcs_set_column_address(dsi, 0x0000, 0x0437);
  88         if (ret < 0) {
  89                 dev_err(dev, "Failed to set column address: %d\n", ret);
  90                 return ret;
  91         }
  92
  93         ret = mipi_dsi_dcs_set_page_address(dsi, 0x0000, 0x077f);
  94         if (ret < 0) {
  95                 dev_err(dev, "Failed to set page address: %d\n", ret);
  96                 return ret;
  97         }
  98
  99         ret = mipi_dsi_dcs_set_tear_scanline(dsi, 0x0000);
 100         if (ret < 0) {
 101                 dev_err(dev, "Failed to set tear scanline: %d\n", ret);
 102                 return ret;
 103         }
 104
 105         ret = mipi_dsi_dcs_set_display_brightness(dsi, 0x00ff);
 106         if (ret < 0) {
 107                 dev_err(dev, "Failed to set display brightness: %d\n", ret);
 108                 return ret;
 109         }
 110
 111         dsi_dcs_write_seq(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY, 0x24);
 112         dsi_dcs_write_seq(dsi, MIPI_DCS_WRITE_POWER_SAVE, 0x00);
 113         dsi_dcs_write_seq(dsi, MIPI_DCS_SET_CABC_MIN_BRIGHTNESS, 0x00);
 114         dsi_dcs_write_seq(dsi, 0x84, 0x00);
 115
 116         ret = mipi_dsi_dcs_set_display_on(dsi);
 117         if (ret < 0) {
 118                 dev_err(dev, "Failed to set display on: %d\n", ret);
 119                 return ret;
 120         }
 121         msleep(20);
 122
 123         ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
 124         if (ret < 0) {
 125                 dev_err(dev, "Failed to exit sleep mode: %d\n", ret);
 126                 return ret;
 127         }
 128         msleep(80);
 129
 130         dsi_generic_write_seq(dsi, 0xb0, 0x04);
 131         dsi_dcs_write_seq(dsi, 0x84, 0x00);
 132         dsi_generic_write_seq(dsi, 0xc8, 0x11);
 133         dsi_generic_write_seq(dsi, 0xb0, 0x03);
 134
 135         return 0;
 136 }
 137
 138 static int jdi_fhd_r63452_off(struct jdi_fhd_r63452 *ctx)
 139 {
 140         struct mipi_dsi_device *dsi = ctx->dsi;
 141         struct device *dev = &dsi->dev;
 142         int ret;
 143
 144         dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
 145
 146         dsi_generic_write_seq(dsi, 0xb0, 0x00);
 147         dsi_generic_write_seq(dsi, 0xd6, 0x01);
 148         dsi_generic_write_seq(dsi, 0xec,
 149                               0x64, 0xdc, 0xec, 0x3b, 0x52, 0x00, 0x0b, 0x0b,
 150                               0x13, 0x15, 0x68, 0x0b, 0x95);
 151         dsi_generic_write_seq(dsi, 0xb0, 0x03);
 152
 153         ret = mipi_dsi_dcs_set_display_off(dsi);
 154         if (ret < 0) {
 155                 dev_err(dev, "Failed to set display off: %d\n", ret);
 156                 return ret;
 157         }
 158         usleep_range(2000, 3000);
 159
 160         ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
 161         if (ret < 0) {
 162                 dev_err(dev, "Failed to enter sleep mode: %d\n", ret);
 163                 return ret;
 164         }
 165         msleep(120);
 166
 167         return 0;
 168 }
 169
 170 static int jdi_fhd_r63452_prepare(struct drm_panel *panel)
 171 {
 172         struct jdi_fhd_r63452 *ctx = to_jdi_fhd_r63452(panel);
 173         struct device *dev = &ctx->dsi->dev;
 174         int ret;
 175
 176         if (ctx->prepared)
 177                 return 0;
 178
 179         jdi_fhd_r63452_reset(ctx);
 180
 181         ret = jdi_fhd_r63452_on(ctx);
 182         if (ret < 0) {
 183                 dev_err(dev, "Failed to initialize panel: %d\n", ret);
 184                 gpiod_set_value_cansleep(ctx->reset_gpio, 1);
 185                 return ret;
 186         }
 187
 188         ctx->prepared = true;
 189         return 0;
 190 }
 191
 192 static int jdi_fhd_r63452_unprepare(struct drm_panel *panel)
 193 {
 194         struct jdi_fhd_r63452 *ctx = to_jdi_fhd_r63452(panel);
 195         struct device *dev = &ctx->dsi->dev;
 196         int ret;
 197
 198         if (!ctx->prepared)
 199                 return 0;
 200
 201         ret = jdi_fhd_r63452_off(ctx);
 202         if (ret < 0)
 203                 dev_err(dev, "Failed to un-initialize panel: %d\n", ret);
 204
 205         gpiod_set_value_cansleep(ctx->reset_gpio, 1);
 206
 207         ctx->prepared = false;
 208         return 0;
 209 }
 210
 211 static const struct drm_display_mode jdi_fhd_r63452_mode = {
 212         .clock = (1080 + 120 + 16 + 40) * (1920 + 4 + 2 + 4) * 60 / 1000,
 213         .hdisplay = 1080,
 214         .hsync_start = 1080 + 120,
 215         .hsync_end = 1080 + 120 + 16,
 216         .htotal = 1080 + 120 + 16 + 40,
 217         .vdisplay = 1920,
 218         .vsync_start = 1920 + 4,
 219         .vsync_end = 1920 + 4 + 2,
 220         .vtotal = 1920 + 4 + 2 + 4,
 221         .width_mm = 64,
 222         .height_mm = 114,
 223 };
 224
 225 static int jdi_fhd_r63452_get_modes(struct drm_panel *panel,
 226                                     struct drm_connector *connector)
 227 {
 228         struct drm_display_mode *mode;
 229
 230         mode = drm_mode_duplicate(connector->dev, &jdi_fhd_r63452_mode);
 231         if (!mode)
 232                 return -ENOMEM;
 233
 234         drm_mode_set_name(mode);
 235
 236         mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 237         connector->display_info.width_mm = mode->width_mm;
 238         connector->display_info.height_mm = mode->height_mm;
 239         drm_mode_probed_add(connector, mode);
 240
 241         return 1;
 242 }
 243
 244 static const struct drm_panel_funcs jdi_fhd_r63452_panel_funcs = {
 245         .prepare = jdi_fhd_r63452_prepare,
 246         .unprepare = jdi_fhd_r63452_unprepare,
 247         .get_modes = jdi_fhd_r63452_get_modes,
 248 };
 249
 250 static int jdi_fhd_r63452_probe(struct mipi_dsi_device *dsi)
 251 {
 252         struct device *dev = &dsi->dev;
 253         struct jdi_fhd_r63452 *ctx;
 254         int ret;
 255
 256         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
 257         if (!ctx)
 258                 return -ENOMEM;
 259
 260         ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
 261         if (IS_ERR(ctx->reset_gpio))
 262                 return dev_err_probe(dev, PTR_ERR(ctx->reset_gpio),
 263                                      "Failed to get reset-gpios\n");
 264
 265         ctx->dsi = dsi;
 266         mipi_dsi_set_drvdata(dsi, ctx);
 267
 268         dsi->lanes = 4;
 269         dsi->format = MIPI_DSI_FMT_RGB888;
 270         dsi->mode_flags = MIPI_DSI_MODE_VIDEO_BURST |
 271                           MIPI_DSI_CLOCK_NON_CONTINUOUS;
 272
 273         drm_panel_init(&ctx->panel, dev, &jdi_fhd_r63452_panel_funcs,
 274                        DRM_MODE_CONNECTOR_DSI);
 275
 276         ret = drm_panel_of_backlight(&ctx->panel);
 277         if (ret)
 278                 return dev_err_probe(dev, ret, "Failed to get backlight\n");
 279
 280         drm_panel_add(&ctx->panel);
 281
 282         ret = mipi_dsi_attach(dsi);
 283         if (ret < 0) {
 284                 dev_err(dev, "Failed to attach to DSI host: %d\n", ret);
 285                 return ret;
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int jdi_fhd_r63452_remove(struct mipi_dsi_device *dsi)
 292 {
 293         struct jdi_fhd_r63452 *ctx = mipi_dsi_get_drvdata(dsi);
 294         int ret;
 295
 296         ret = mipi_dsi_detach(dsi);
 297         if (ret < 0)
 298                 dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret);
 299
 300         drm_panel_remove(&ctx->panel);
 301
 302         return 0;
 303 }
 304
 305 static const struct of_device_id jdi_fhd_r63452_of_match[] = {
 306         { .compatible = "jdi,fhd-r63452" },
 307         { /* sentinel */ }
 308 };
 309 MODULE_DEVICE_TABLE(of, jdi_fhd_r63452_of_match);
 310
 311 static struct mipi_dsi_driver jdi_fhd_r63452_driver = {
 312         .probe = jdi_fhd_r63452_probe,
 313         .remove = jdi_fhd_r63452_remove,
 314         .driver = {
 315                 .name = "panel-jdi-fhd-r63452",
 316                 .of_match_table = jdi_fhd_r63452_of_match,
 317         },
 318 };
 319 module_mipi_dsi_driver(jdi_fhd_r63452_driver);
 320
 321 MODULE_AUTHOR("Raffaele Tranquillini <raffaele.tranquillini@gmail.com>");
 322 MODULE_DESCRIPTION("DRM driver for JDI FHD R63452 DSI panel, command mode");
 323 MODULE_LICENSE("GPL v2");