drivers/gpu/drm/panel/panel-widechips-ws2401.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Panel driver for the WideChips WS2401 480x800 DPI RGB panel, used in
   4  * the Samsung Mobile Display (SMD) LMS380KF01.
   5  * Found in the Samsung Galaxy Ace 2 GT-I8160 mobile phone.
   6  * Linus Walleij <[email protected]>
   7  * Inspired by code and know-how in the vendor driver by Gareth Phillips.
   8  */
   9 #include <drm/drm_mipi_dbi.h>
  10 #include <drm/drm_modes.h>
  11 #include <drm/drm_panel.h>
  12
  13 #include <linux/backlight.h>
  14 #include <linux/delay.h>
  15 #include <linux/gpio/consumer.h>
  16 #include <linux/init.h>
  17 #include <linux/kernel.h>
  18 #include <linux/media-bus-format.h>
  19 #include <linux/module.h>
  20 #include <linux/regulator/consumer.h>
  21 #include <linux/spi/spi.h>
  22
  23 #include <video/mipi_display.h>
  24
  25 #define WS2401_RESCTL                   0xb8 /* Resolution select control */
  26 #define WS2401_PSMPS                    0xbd /* SMPS positive control */
  27 #define WS2401_NSMPS                    0xbe /* SMPS negative control */
  28 #define WS2401_SMPS                     0xbf
  29 #define WS2401_BCMODE                   0xc1 /* Backlight control mode */
  30 #define WS2401_WRBLCTL                  0xc3 /* Backlight control */
  31 #define WS2401_WRDISBV                  0xc4 /* Write manual brightness */
  32 #define WS2401_WRCTRLD                  0xc6 /* Write BL control */
  33 #define WS2401_WRMIE                    0xc7 /* Write MIE mode */
  34 #define WS2401_READ_ID1                 0xda /* Read panel ID 1 */
  35 #define WS2401_READ_ID2                 0xdb /* Read panel ID 2 */
  36 #define WS2401_READ_ID3                 0xdc /* Read panel ID 3 */
  37 #define WS2401_GAMMA_R1                 0xe7 /* Gamma red 1 */
  38 #define WS2401_GAMMA_G1                 0xe8 /* Gamma green 1 */
  39 #define WS2401_GAMMA_B1                 0xe9 /* Gamma blue 1 */
  40 #define WS2401_GAMMA_R2                 0xea /* Gamma red 2 */
  41 #define WS2401_GAMMA_G2                 0xeb /* Gamma green 2 */
  42 #define WS2401_GAMMA_B2                 0xec /* Gamma blue 2 */
  43 #define WS2401_PASSWD1                  0xf0 /* Password command for level 2 */
  44 #define WS2401_DISCTL                   0xf2 /* Display control */
  45 #define WS2401_PWRCTL                   0xf3 /* Power control */
  46 #define WS2401_VCOMCTL                  0xf4 /* VCOM control */
  47 #define WS2401_SRCCTL                   0xf5 /* Source control */
  48 #define WS2401_PANELCTL                 0xf6 /* Panel control */
  49
  50 static const u8 ws2401_dbi_read_commands[] = {
  51         WS2401_READ_ID1,
  52         WS2401_READ_ID2,
  53         WS2401_READ_ID3,
  54         0, /* sentinel */
  55 };
  56
  57 /**
  58  * struct ws2401 - state container for a panel controlled by the WS2401
  59  * controller
  60  */
  61 struct ws2401 {
  62         /** @dev: the container device */
  63         struct device *dev;
  64         /** @dbi: the DBI bus abstraction handle */
  65         struct mipi_dbi dbi;
  66         /** @panel: the DRM panel instance for this device */
  67         struct drm_panel panel;
  68         /** @width: the width of this panel in mm */
  69         u32 width;
  70         /** @height: the height of this panel in mm */
  71         u32 height;
  72         /** @reset: reset GPIO line */
  73         struct gpio_desc *reset;
  74         /** @regulators: VCCIO and VIO supply regulators */
  75         struct regulator_bulk_data regulators[2];
  76         /** @internal_bl: If using internal backlight */
  77         bool internal_bl;
  78 };
  79
  80 static const struct drm_display_mode lms380kf01_480_800_mode = {
  81         /*
  82          * The vendor driver states that the "SMD panel" has a clock
  83          * frequency of 49920000 Hz / 2 = 24960000 Hz.
  84          */
  85         .clock = 24960,
  86         .hdisplay = 480,
  87         .hsync_start = 480 + 8,
  88         .hsync_end = 480 + 8 + 10,
  89         .htotal = 480 + 8 + 10 + 8,
  90         .vdisplay = 800,
  91         .vsync_start = 800 + 8,
  92         .vsync_end = 800 + 8 + 2,
  93         .vtotal = 800 + 8 + 2 + 18,
  94         .width_mm = 50,
  95         .height_mm = 84,
  96         .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC,
  97 };
  98
  99 static inline struct ws2401 *to_ws2401(struct drm_panel *panel)
 100 {
 101         return container_of(panel, struct ws2401, panel);
 102 }
 103
 104 static void ws2401_read_mtp_id(struct ws2401 *ws)
 105 {
 106         struct mipi_dbi *dbi = &ws->dbi;
 107         u8 id1, id2, id3;
 108         int ret;
 109
 110         ret = mipi_dbi_command_read(dbi, WS2401_READ_ID1, &id1);
 111         if (ret) {
 112                 dev_err(ws->dev, "unable to read MTP ID 1\n");
 113                 return;
 114         }
 115         ret = mipi_dbi_command_read(dbi, WS2401_READ_ID2, &id2);
 116         if (ret) {
 117                 dev_err(ws->dev, "unable to read MTP ID 2\n");
 118                 return;
 119         }
 120         ret = mipi_dbi_command_read(dbi, WS2401_READ_ID3, &id3);
 121         if (ret) {
 122                 dev_err(ws->dev, "unable to read MTP ID 3\n");
 123                 return;
 124         }
 125         dev_info(ws->dev, "MTP ID: %02x %02x %02x\n", id1, id2, id3);
 126 }
 127
 128 static int ws2401_power_on(struct ws2401 *ws)
 129 {
 130         struct mipi_dbi *dbi = &ws->dbi;
 131         int ret;
 132
 133         /* Power up */
 134         ret = regulator_bulk_enable(ARRAY_SIZE(ws->regulators),
 135                                     ws->regulators);
 136         if (ret) {
 137                 dev_err(ws->dev, "failed to enable regulators: %d\n", ret);
 138                 return ret;
 139         }
 140         msleep(10);
 141
 142         /* Assert reset >=1 ms */
 143         gpiod_set_value_cansleep(ws->reset, 1);
 144         usleep_range(1000, 5000);
 145         /* De-assert reset */
 146         gpiod_set_value_cansleep(ws->reset, 0);
 147         /* Wait >= 10 ms */
 148         msleep(10);
 149         dev_dbg(ws->dev, "de-asserted RESET\n");
 150
 151         /*
 152          * Exit sleep mode and initialize display - some hammering is
 153          * necessary.
 154          */
 155         mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
 156         mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE);
 157         msleep(50);
 158
 159         /* Magic to unlock level 2 control of the display */
 160         mipi_dbi_command(dbi, WS2401_PASSWD1, 0x5a, 0x5a);
 161         /* Configure resolution to 480RGBx800 */
 162         mipi_dbi_command(dbi, WS2401_RESCTL, 0x12);
 163         /* Set addressing mode Flip V(d0), Flip H(d1) RGB/BGR(d3) */
 164         mipi_dbi_command(dbi, MIPI_DCS_SET_ADDRESS_MODE, 0x01);
 165         /* Set pixel format: 24 bpp */
 166         mipi_dbi_command(dbi, MIPI_DCS_SET_PIXEL_FORMAT, 0x70);
 167         mipi_dbi_command(dbi, WS2401_SMPS, 0x00, 0x0f);
 168         mipi_dbi_command(dbi, WS2401_PSMPS, 0x06, 0x03, /* DDVDH: 4.6v */
 169                          0x7e, 0x03, 0x12, 0x37);
 170         mipi_dbi_command(dbi, WS2401_NSMPS, 0x06, 0x03, /* DDVDH: -4.6v */
 171                          0x7e, 0x02, 0x15, 0x37);
 172         mipi_dbi_command(dbi, WS2401_SMPS, 0x02, 0x0f);
 173         mipi_dbi_command(dbi, WS2401_PWRCTL, 0x10, 0xA9, 0x00, 0x01, 0x44,
 174                          0xb4,  /* VGH:16.1v, VGL:-13.8v */
 175                          0x50,  /* GREFP:4.2v (default) */
 176                          0x50,  /* GREFN:-4.2v (default) */
 177                          0x00,
 178                          0x44); /* VOUTL:-10v (default) */
 179         mipi_dbi_command(dbi, WS2401_DISCTL, 0x01, 0x00, 0x00, 0x00, 0x14,
 180                          0x16);
 181         mipi_dbi_command(dbi, WS2401_VCOMCTL, 0x30, 0x53, 0x53);
 182         mipi_dbi_command(dbi, WS2401_SRCCTL, 0x03, 0x0C, 0x00, 0x00, 0x00,
 183                          0x01,  /* 2 dot inversion */
 184                          0x01, 0x06, 0x03);
 185         mipi_dbi_command(dbi, WS2401_PANELCTL, 0x14, 0x00, 0x80, 0x00);
 186         mipi_dbi_command(dbi, WS2401_WRMIE, 0x01);
 187
 188         /* Set up gamma, probably these are P-gamma and N-gamma for each color */
 189         mipi_dbi_command(dbi, WS2401_GAMMA_R1, 0x00,
 190                          0x5b, 0x42, 0x41, 0x3f, 0x42, 0x3d, 0x38, 0x2e,
 191                          0x2b, 0x2a, 0x27, 0x22, 0x27, 0x0f, 0x00, 0x00);
 192         mipi_dbi_command(dbi, WS2401_GAMMA_R2, 0x00,
 193                          0x5b, 0x42, 0x41, 0x3f, 0x42, 0x3d, 0x38, 0x2e,
 194                          0x2b, 0x2a, 0x27, 0x22, 0x27, 0x0f, 0x00, 0x00);
 195         mipi_dbi_command(dbi, WS2401_GAMMA_G1, 0x00,
 196                          0x59, 0x40, 0x3f, 0x3e, 0x41, 0x3d, 0x39, 0x2f,
 197                          0x2c, 0x2b, 0x29, 0x25, 0x29, 0x19, 0x08, 0x00);
 198         mipi_dbi_command(dbi, WS2401_GAMMA_G2, 0x00,
 199                          0x59, 0x40, 0x3f, 0x3e, 0x41, 0x3d, 0x39, 0x2f,
 200                          0x2c, 0x2b, 0x29, 0x25, 0x29, 0x19, 0x08, 0x00);
 201         mipi_dbi_command(dbi, WS2401_GAMMA_B1, 0x00,
 202                          0x57, 0x3b, 0x3a, 0x3b, 0x3f, 0x3b, 0x38, 0x27,
 203                          0x38, 0x2a, 0x26, 0x22, 0x34, 0x0c, 0x09, 0x00);
 204         mipi_dbi_command(dbi, WS2401_GAMMA_B2, 0x00,
 205                          0x57, 0x3b, 0x3a, 0x3b, 0x3f, 0x3b, 0x38, 0x27,
 206                          0x38, 0x2a, 0x26, 0x22, 0x34, 0x0c, 0x09, 0x00);
 207
 208         if (ws->internal_bl) {
 209                 mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x2c);
 210         } else {
 211                 mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x00);
 212                 /*
 213                  * When not using internal backlight we do not need any further
 214                  * L2 accesses to the panel so we close the door on our way out.
 215                  * Otherwise we need to leave the L2 door open.
 216                  */
 217                 mipi_dbi_command(dbi, WS2401_PASSWD1, 0xa5, 0xa5);
 218         }
 219
 220         return 0;
 221 }
 222
 223 static int ws2401_power_off(struct ws2401 *ws)
 224 {
 225         /* Go into RESET and disable regulators */
 226         gpiod_set_value_cansleep(ws->reset, 1);
 227         return regulator_bulk_disable(ARRAY_SIZE(ws->regulators),
 228                                       ws->regulators);
 229 }
 230
 231 static int ws2401_unprepare(struct drm_panel *panel)
 232 {
 233         struct ws2401 *ws = to_ws2401(panel);
 234         struct mipi_dbi *dbi = &ws->dbi;
 235
 236         /* Make sure we disable backlight, if any */
 237         if (ws->internal_bl)
 238                 mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x00);
 239         mipi_dbi_command(dbi, MIPI_DCS_ENTER_SLEEP_MODE);
 240         msleep(120);
 241         return ws2401_power_off(to_ws2401(panel));
 242 }
 243
 244 static int ws2401_disable(struct drm_panel *panel)
 245 {
 246         struct ws2401 *ws = to_ws2401(panel);
 247         struct mipi_dbi *dbi = &ws->dbi;
 248
 249         mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_OFF);
 250         msleep(25);
 251
 252         return 0;
 253 }
 254
 255 static int ws2401_prepare(struct drm_panel *panel)
 256 {
 257         return ws2401_power_on(to_ws2401(panel));
 258 }
 259
 260 static int ws2401_enable(struct drm_panel *panel)
 261 {
 262         struct ws2401 *ws = to_ws2401(panel);
 263         struct mipi_dbi *dbi = &ws->dbi;
 264
 265         mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON);
 266
 267         return 0;
 268 }
 269
 270 /**
 271  * ws2401_get_modes() - return the mode
 272  * @panel: the panel to get the mode for
 273  * @connector: reference to the central DRM connector control structure
 274  */
 275 static int ws2401_get_modes(struct drm_panel *panel,
 276                             struct drm_connector *connector)
 277 {
 278         struct ws2401 *ws = to_ws2401(panel);
 279         struct drm_display_mode *mode;
 280         static const u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
 281
 282         /*
 283          * We just support the LMS380KF01 so far, if we implement more panels
 284          * this mode, the following connector display_info settings and
 285          * probably the custom DCS sequences needs to selected based on what
 286          * the target panel needs.
 287          */
 288         mode = drm_mode_duplicate(connector->dev, &lms380kf01_480_800_mode);
 289         if (!mode) {
 290                 dev_err(ws->dev, "failed to add mode\n");
 291                 return -ENOMEM;
 292         }
 293
 294         connector->display_info.bpc = 8;
 295         connector->display_info.width_mm = mode->width_mm;
 296         connector->display_info.height_mm = mode->height_mm;
 297         connector->display_info.bus_flags =
 298                 DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE;
 299         drm_display_info_set_bus_formats(&connector->display_info,
 300                                          &bus_format, 1);
 301
 302         drm_mode_set_name(mode);
 303         mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 304
 305         drm_mode_probed_add(connector, mode);
 306
 307         return 1;
 308 }
 309
 310 static const struct drm_panel_funcs ws2401_drm_funcs = {
 311         .disable = ws2401_disable,
 312         .unprepare = ws2401_unprepare,
 313         .prepare = ws2401_prepare,
 314         .enable = ws2401_enable,
 315         .get_modes = ws2401_get_modes,
 316 };
 317
 318 static int ws2401_set_brightness(struct backlight_device *bl)
 319 {
 320         struct ws2401 *ws = bl_get_data(bl);
 321         struct mipi_dbi *dbi = &ws->dbi;
 322         u8 brightness = backlight_get_brightness(bl);
 323
 324         if (backlight_is_blank(bl)) {
 325                 mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x00);
 326         } else {
 327                 mipi_dbi_command(dbi, WS2401_WRCTRLD, 0x2c);
 328                 mipi_dbi_command(dbi, WS2401_WRDISBV, brightness);
 329         }
 330
 331         return 0;
 332 }
 333
 334 static const struct backlight_ops ws2401_bl_ops = {
 335         .update_status = ws2401_set_brightness,
 336 };
 337
 338 static const struct backlight_properties ws2401_bl_props = {
 339         .type = BACKLIGHT_PLATFORM,
 340         .brightness = 120,
 341         .max_brightness = U8_MAX,
 342 };
 343
 344 static int ws2401_probe(struct spi_device *spi)
 345 {
 346         struct device *dev = &spi->dev;
 347         struct ws2401 *ws;
 348         int ret;
 349
 350         ws = devm_kzalloc(dev, sizeof(*ws), GFP_KERNEL);
 351         if (!ws)
 352                 return -ENOMEM;
 353         ws->dev = dev;
 354
 355         /*
 356          * VCI   is the analog voltage supply
 357          * VCCIO is the digital I/O voltage supply
 358          */
 359         ws->regulators[0].supply = "vci";
 360         ws->regulators[1].supply = "vccio";
 361         ret = devm_regulator_bulk_get(dev,
 362                                       ARRAY_SIZE(ws->regulators),
 363                                       ws->regulators);
 364         if (ret)
 365                 return dev_err_probe(dev, ret, "failed to get regulators\n");
 366
 367         ws->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
 368         if (IS_ERR(ws->reset)) {
 369                 ret = PTR_ERR(ws->reset);
 370                 return dev_err_probe(dev, ret, "no RESET GPIO\n");
 371         }
 372
 373         ret = mipi_dbi_spi_init(spi, &ws->dbi, NULL);
 374         if (ret)
 375                 return dev_err_probe(dev, ret, "MIPI DBI init failed\n");
 376         ws->dbi.read_commands = ws2401_dbi_read_commands;
 377
 378         ws2401_power_on(ws);
 379         ws2401_read_mtp_id(ws);
 380         ws2401_power_off(ws);
 381
 382         drm_panel_init(&ws->panel, dev, &ws2401_drm_funcs,
 383                        DRM_MODE_CONNECTOR_DPI);
 384
 385         ret = drm_panel_of_backlight(&ws->panel);
 386         if (ret)
 387                 return dev_err_probe(dev, ret,
 388                                 "failed to get external backlight device\n");
 389
 390         if (!ws->panel.backlight) {
 391                 dev_dbg(dev, "no external backlight, using internal backlight\n");
 392                 ws->panel.backlight =
 393                         devm_backlight_device_register(dev, "ws2401", dev, ws,
 394                                 &ws2401_bl_ops, &ws2401_bl_props);
 395                 if (IS_ERR(ws->panel.backlight))
 396                         return dev_err_probe(dev, PTR_ERR(ws->panel.backlight),
 397                                 "failed to register backlight device\n");
 398         } else {
 399                 dev_dbg(dev, "using external backlight\n");
 400         }
 401
 402         spi_set_drvdata(spi, ws);
 403
 404         drm_panel_add(&ws->panel);
 405         dev_dbg(dev, "added panel\n");
 406
 407         return 0;
 408 }
 409
 410 static void ws2401_remove(struct spi_device *spi)
 411 {
 412         struct ws2401 *ws = spi_get_drvdata(spi);
 413
 414         drm_panel_remove(&ws->panel);
 415 }
 416
 417 /*
 418  * Samsung LMS380KF01 is the one instance of this display controller that we
 419  * know about, but if more are found, the controller can be parameterized
 420  * here and used for other configurations.
 421  */
 422 static const struct of_device_id ws2401_match[] = {
 423         { .compatible = "samsung,lms380kf01", },
 424         {},
 425 };
 426 MODULE_DEVICE_TABLE(of, ws2401_match);
 427
 428 static const struct spi_device_id ws2401_ids[] = {
 429         { "lms380kf01" },
 430         { },
 431 };
 432 MODULE_DEVICE_TABLE(spi, ws2401_ids);
 433
 434 static struct spi_driver ws2401_driver = {
 435         .probe          = ws2401_probe,
 436         .remove         = ws2401_remove,
 437         .id_table       = ws2401_ids,
 438         .driver         = {
 439                 .name   = "ws2401-panel",
 440                 .of_match_table = ws2401_match,
 441         },
 442 };
 443 module_spi_driver(ws2401_driver);
 444
 445 MODULE_AUTHOR("Linus Walleij <[email protected]>");
 446 MODULE_DESCRIPTION("Samsung WS2401 panel driver");
 447 MODULE_LICENSE("GPL v2");