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 <linus.walleij@linaro.org> 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 <linus.walleij@linaro.org>"); 446 MODULE_DESCRIPTION("Samsung WS2401 panel driver"); 447 MODULE_LICENSE("GPL v2"); 448