1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Panel driver for the Samsung S6D27A1 480x800 DPI RGB panel. 4 * Found in the Samsung Galaxy Ace 2 GT-I8160 mobile phone. 5 */ 6 7 #include <drm/drm_mipi_dbi.h> 8 #include <drm/drm_modes.h> 9 #include <drm/drm_panel.h> 10 11 #include <linux/delay.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/init.h> 14 #include <linux/kernel.h> 15 #include <linux/media-bus-format.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/regulator/consumer.h> 19 #include <linux/spi/spi.h> 20 21 #include <video/mipi_display.h> 22 23 #define S6D27A1_PASSWD_L2 0xF0 /* Password Command for Level 2 Control */ 24 #define S6D27A1_RESCTL 0xB3 /* Resolution Select Control */ 25 #define S6D27A1_PANELCTL2 0xB4 /* ASG Signal Control */ 26 #define S6D27A1_READID1 0xDA /* Read panel ID 1 */ 27 #define S6D27A1_READID2 0xDB /* Read panel ID 2 */ 28 #define S6D27A1_READID3 0xDC /* Read panel ID 3 */ 29 #define S6D27A1_DISPCTL 0xF2 /* Display Control */ 30 #define S6D27A1_MANPWR 0xF3 /* Manual Control */ 31 #define S6D27A1_PWRCTL1 0xF4 /* Power Control */ 32 #define S6D27A1_SRCCTL 0xF6 /* Source Control */ 33 #define S6D27A1_PANELCTL 0xF7 /* Panel Control*/ 34 35 static const u8 s6d27a1_dbi_read_commands[] = { 36 S6D27A1_READID1, 37 S6D27A1_READID2, 38 S6D27A1_READID3, 39 0, /* sentinel */ 40 }; 41 42 struct s6d27a1 { 43 struct device *dev; 44 struct mipi_dbi dbi; 45 struct drm_panel panel; 46 struct gpio_desc *reset; 47 struct regulator_bulk_data regulators[2]; 48 }; 49 50 static const struct drm_display_mode s6d27a1_480_800_mode = { 51 /* 52 * The vendor driver states that the S6D27A1 panel 53 * has a pixel clock frequency of 49920000 Hz / 2 = 24960000 Hz. 54 */ 55 .clock = 24960, 56 .hdisplay = 480, 57 .hsync_start = 480 + 63, 58 .hsync_end = 480 + 63 + 2, 59 .htotal = 480 + 63 + 2 + 63, 60 .vdisplay = 800, 61 .vsync_start = 800 + 11, 62 .vsync_end = 800 + 11 + 2, 63 .vtotal = 800 + 11 + 2 + 10, 64 .width_mm = 50, 65 .height_mm = 84, 66 .flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC, 67 }; 68 69 static inline struct s6d27a1 *to_s6d27a1(struct drm_panel *panel) 70 { 71 return container_of(panel, struct s6d27a1, panel); 72 } 73 74 static void s6d27a1_read_mtp_id(struct s6d27a1 *ctx) 75 { 76 struct mipi_dbi *dbi = &ctx->dbi; 77 u8 id1, id2, id3; 78 int ret; 79 80 ret = mipi_dbi_command_read(dbi, S6D27A1_READID1, &id1); 81 if (ret) { 82 dev_err(ctx->dev, "unable to read MTP ID 1\n"); 83 return; 84 } 85 ret = mipi_dbi_command_read(dbi, S6D27A1_READID2, &id2); 86 if (ret) { 87 dev_err(ctx->dev, "unable to read MTP ID 2\n"); 88 return; 89 } 90 ret = mipi_dbi_command_read(dbi, S6D27A1_READID3, &id3); 91 if (ret) { 92 dev_err(ctx->dev, "unable to read MTP ID 3\n"); 93 return; 94 } 95 dev_info(ctx->dev, "MTP ID: %02x %02x %02x\n", id1, id2, id3); 96 } 97 98 static int s6d27a1_power_on(struct s6d27a1 *ctx) 99 { 100 struct mipi_dbi *dbi = &ctx->dbi; 101 int ret; 102 103 /* Power up */ 104 ret = regulator_bulk_enable(ARRAY_SIZE(ctx->regulators), 105 ctx->regulators); 106 if (ret) { 107 dev_err(ctx->dev, "failed to enable regulators: %d\n", ret); 108 return ret; 109 } 110 111 msleep(20); 112 113 /* Assert reset >=1 ms */ 114 gpiod_set_value_cansleep(ctx->reset, 1); 115 usleep_range(1000, 5000); 116 /* De-assert reset */ 117 gpiod_set_value_cansleep(ctx->reset, 0); 118 /* Wait >= 10 ms */ 119 msleep(20); 120 121 /* 122 * Exit sleep mode and initialize display - some hammering is 123 * necessary. 124 */ 125 mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE); 126 mipi_dbi_command(dbi, MIPI_DCS_EXIT_SLEEP_MODE); 127 msleep(120); 128 129 /* Magic to unlock level 2 control of the display */ 130 mipi_dbi_command(dbi, S6D27A1_PASSWD_L2, 0x5A, 0x5A); 131 132 /* Configure resolution to 480RGBx800 */ 133 mipi_dbi_command(dbi, S6D27A1_RESCTL, 0x22); 134 135 mipi_dbi_command(dbi, S6D27A1_PANELCTL2, 0x00, 0x02, 0x03, 0x04, 0x05, 0x08, 0x00, 0x0c); 136 137 mipi_dbi_command(dbi, S6D27A1_MANPWR, 0x01, 0x00, 0x00, 0x08, 0x08, 0x02, 0x00); 138 139 mipi_dbi_command(dbi, S6D27A1_DISPCTL, 0x19, 0x00, 0x08, 0x0D, 0x03, 0x41, 0x3F); 140 141 mipi_dbi_command(dbi, S6D27A1_PWRCTL1, 0x00, 0x00, 0x00, 0x00, 0x55, 142 0x44, 0x05, 0x88, 0x4B, 0x50); 143 144 mipi_dbi_command(dbi, S6D27A1_SRCCTL, 0x03, 0x09, 0x8A, 0x00, 0x01, 0x16); 145 146 mipi_dbi_command(dbi, S6D27A1_PANELCTL, 0x00, 0x05, 0x06, 0x07, 0x08, 147 0x01, 0x09, 0x0D, 0x0A, 0x0E, 148 0x0B, 0x0F, 0x0C, 0x10, 0x01, 149 0x11, 0x12, 0x13, 0x14, 0x05, 150 0x06, 0x07, 0x08, 0x01, 0x09, 151 0x0D, 0x0A, 0x0E, 0x0B, 0x0F, 152 0x0C, 0x10, 0x01, 0x11, 0x12, 153 0x13, 0x14); 154 155 /* lock the level 2 control */ 156 mipi_dbi_command(dbi, S6D27A1_PASSWD_L2, 0xA5, 0xA5); 157 158 s6d27a1_read_mtp_id(ctx); 159 160 return 0; 161 } 162 163 static int s6d27a1_power_off(struct s6d27a1 *ctx) 164 { 165 /* Go into RESET and disable regulators */ 166 gpiod_set_value_cansleep(ctx->reset, 1); 167 return regulator_bulk_disable(ARRAY_SIZE(ctx->regulators), 168 ctx->regulators); 169 } 170 171 static int s6d27a1_unprepare(struct drm_panel *panel) 172 { 173 struct s6d27a1 *ctx = to_s6d27a1(panel); 174 struct mipi_dbi *dbi = &ctx->dbi; 175 176 mipi_dbi_command(dbi, MIPI_DCS_ENTER_SLEEP_MODE); 177 msleep(120); 178 return s6d27a1_power_off(to_s6d27a1(panel)); 179 } 180 181 static int s6d27a1_disable(struct drm_panel *panel) 182 { 183 struct s6d27a1 *ctx = to_s6d27a1(panel); 184 struct mipi_dbi *dbi = &ctx->dbi; 185 186 mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_OFF); 187 msleep(25); 188 189 return 0; 190 } 191 192 static int s6d27a1_prepare(struct drm_panel *panel) 193 { 194 return s6d27a1_power_on(to_s6d27a1(panel)); 195 } 196 197 static int s6d27a1_enable(struct drm_panel *panel) 198 { 199 struct s6d27a1 *ctx = to_s6d27a1(panel); 200 struct mipi_dbi *dbi = &ctx->dbi; 201 202 mipi_dbi_command(dbi, MIPI_DCS_SET_DISPLAY_ON); 203 204 return 0; 205 } 206 207 static int s6d27a1_get_modes(struct drm_panel *panel, 208 struct drm_connector *connector) 209 { 210 struct s6d27a1 *ctx = to_s6d27a1(panel); 211 struct drm_display_mode *mode; 212 static const u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 213 214 mode = drm_mode_duplicate(connector->dev, &s6d27a1_480_800_mode); 215 if (!mode) { 216 dev_err(ctx->dev, "failed to add mode\n"); 217 return -ENOMEM; 218 } 219 220 connector->display_info.bpc = 8; 221 connector->display_info.width_mm = mode->width_mm; 222 connector->display_info.height_mm = mode->height_mm; 223 connector->display_info.bus_flags = 224 DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE; 225 drm_display_info_set_bus_formats(&connector->display_info, 226 &bus_format, 1); 227 228 drm_mode_set_name(mode); 229 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 230 231 drm_mode_probed_add(connector, mode); 232 233 return 1; 234 } 235 236 static const struct drm_panel_funcs s6d27a1_drm_funcs = { 237 .disable = s6d27a1_disable, 238 .unprepare = s6d27a1_unprepare, 239 .prepare = s6d27a1_prepare, 240 .enable = s6d27a1_enable, 241 .get_modes = s6d27a1_get_modes, 242 }; 243 244 static int s6d27a1_probe(struct spi_device *spi) 245 { 246 struct device *dev = &spi->dev; 247 struct s6d27a1 *ctx; 248 int ret; 249 250 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 251 if (!ctx) 252 return -ENOMEM; 253 254 ctx->dev = dev; 255 256 /* 257 * VCI is the analog voltage supply 258 * VCCIO is the digital I/O voltage supply 259 */ 260 ctx->regulators[0].supply = "vci"; 261 ctx->regulators[1].supply = "vccio"; 262 ret = devm_regulator_bulk_get(dev, 263 ARRAY_SIZE(ctx->regulators), 264 ctx->regulators); 265 if (ret) 266 return dev_err_probe(dev, ret, "failed to get regulators\n"); 267 268 ctx->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 269 if (IS_ERR(ctx->reset)) { 270 ret = PTR_ERR(ctx->reset); 271 return dev_err_probe(dev, ret, "no RESET GPIO\n"); 272 } 273 274 ret = mipi_dbi_spi_init(spi, &ctx->dbi, NULL); 275 if (ret) 276 return dev_err_probe(dev, ret, "MIPI DBI init failed\n"); 277 278 ctx->dbi.read_commands = s6d27a1_dbi_read_commands; 279 280 drm_panel_init(&ctx->panel, dev, &s6d27a1_drm_funcs, 281 DRM_MODE_CONNECTOR_DPI); 282 283 ret = drm_panel_of_backlight(&ctx->panel); 284 if (ret) 285 return dev_err_probe(dev, ret, "failed to add backlight\n"); 286 287 spi_set_drvdata(spi, ctx); 288 289 drm_panel_add(&ctx->panel); 290 291 return 0; 292 } 293 294 static void s6d27a1_remove(struct spi_device *spi) 295 { 296 struct s6d27a1 *ctx = spi_get_drvdata(spi); 297 298 drm_panel_remove(&ctx->panel); 299 } 300 301 static const struct of_device_id s6d27a1_match[] = { 302 { .compatible = "samsung,s6d27a1", }, 303 { /* sentinel */ }, 304 }; 305 MODULE_DEVICE_TABLE(of, s6d27a1_match); 306 307 static struct spi_driver s6d27a1_driver = { 308 .probe = s6d27a1_probe, 309 .remove = s6d27a1_remove, 310 .driver = { 311 .name = "s6d27a1-panel", 312 .of_match_table = s6d27a1_match, 313 }, 314 }; 315 module_spi_driver(s6d27a1_driver); 316 317 MODULE_AUTHOR("Markuss Broks <markuss.broks@gmail.com>"); 318 MODULE_DESCRIPTION("Samsung S6D27A1 panel driver"); 319 MODULE_LICENSE("GPL v2"); 320