1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2014 NVIDIA Corporation 4 */ 5 6 #include <linux/delay.h> 7 #include <linux/gpio/consumer.h> 8 #include <linux/module.h> 9 #include <linux/of.h> 10 #include <linux/regulator/consumer.h> 11 12 #include <video/mipi_display.h> 13 14 #include <drm/drm_crtc.h> 15 #include <drm/drm_device.h> 16 #include <drm/drm_mipi_dsi.h> 17 #include <drm/drm_panel.h> 18 19 struct sharp_panel { 20 struct drm_panel base; 21 /* the datasheet refers to them as DSI-LINK1 and DSI-LINK2 */ 22 struct mipi_dsi_device *link1; 23 struct mipi_dsi_device *link2; 24 25 struct regulator *supply; 26 27 bool prepared; 28 bool enabled; 29 30 const struct drm_display_mode *mode; 31 }; 32 33 static inline struct sharp_panel *to_sharp_panel(struct drm_panel *panel) 34 { 35 return container_of(panel, struct sharp_panel, base); 36 } 37 38 static void sharp_wait_frames(struct sharp_panel *sharp, unsigned int frames) 39 { 40 unsigned int refresh = drm_mode_vrefresh(sharp->mode); 41 42 if (WARN_ON(frames > refresh)) 43 return; 44 45 msleep(1000 / (refresh / frames)); 46 } 47 48 static int sharp_panel_write(struct sharp_panel *sharp, u16 offset, u8 value) 49 { 50 u8 payload[3] = { offset >> 8, offset & 0xff, value }; 51 struct mipi_dsi_device *dsi = sharp->link1; 52 ssize_t err; 53 54 err = mipi_dsi_generic_write(dsi, payload, sizeof(payload)); 55 if (err < 0) { 56 dev_err(&dsi->dev, "failed to write %02x to %04x: %zd\n", 57 value, offset, err); 58 return err; 59 } 60 61 err = mipi_dsi_dcs_nop(dsi); 62 if (err < 0) { 63 dev_err(&dsi->dev, "failed to send DCS nop: %zd\n", err); 64 return err; 65 } 66 67 usleep_range(10, 20); 68 69 return 0; 70 } 71 72 static __maybe_unused int sharp_panel_read(struct sharp_panel *sharp, 73 u16 offset, u8 *value) 74 { 75 ssize_t err; 76 77 cpu_to_be16s(&offset); 78 79 err = mipi_dsi_generic_read(sharp->link1, &offset, sizeof(offset), 80 value, sizeof(*value)); 81 if (err < 0) 82 dev_err(&sharp->link1->dev, "failed to read from %04x: %zd\n", 83 offset, err); 84 85 return err; 86 } 87 88 static int sharp_panel_disable(struct drm_panel *panel) 89 { 90 struct sharp_panel *sharp = to_sharp_panel(panel); 91 92 if (!sharp->enabled) 93 return 0; 94 95 sharp->enabled = false; 96 97 return 0; 98 } 99 100 static int sharp_panel_unprepare(struct drm_panel *panel) 101 { 102 struct sharp_panel *sharp = to_sharp_panel(panel); 103 int err; 104 105 if (!sharp->prepared) 106 return 0; 107 108 sharp_wait_frames(sharp, 4); 109 110 err = mipi_dsi_dcs_set_display_off(sharp->link1); 111 if (err < 0) 112 dev_err(panel->dev, "failed to set display off: %d\n", err); 113 114 err = mipi_dsi_dcs_enter_sleep_mode(sharp->link1); 115 if (err < 0) 116 dev_err(panel->dev, "failed to enter sleep mode: %d\n", err); 117 118 msleep(120); 119 120 regulator_disable(sharp->supply); 121 122 sharp->prepared = false; 123 124 return 0; 125 } 126 127 static int sharp_setup_symmetrical_split(struct mipi_dsi_device *left, 128 struct mipi_dsi_device *right, 129 const struct drm_display_mode *mode) 130 { 131 int err; 132 133 err = mipi_dsi_dcs_set_column_address(left, 0, mode->hdisplay / 2 - 1); 134 if (err < 0) { 135 dev_err(&left->dev, "failed to set column address: %d\n", err); 136 return err; 137 } 138 139 err = mipi_dsi_dcs_set_page_address(left, 0, mode->vdisplay - 1); 140 if (err < 0) { 141 dev_err(&left->dev, "failed to set page address: %d\n", err); 142 return err; 143 } 144 145 err = mipi_dsi_dcs_set_column_address(right, mode->hdisplay / 2, 146 mode->hdisplay - 1); 147 if (err < 0) { 148 dev_err(&right->dev, "failed to set column address: %d\n", err); 149 return err; 150 } 151 152 err = mipi_dsi_dcs_set_page_address(right, 0, mode->vdisplay - 1); 153 if (err < 0) { 154 dev_err(&right->dev, "failed to set page address: %d\n", err); 155 return err; 156 } 157 158 return 0; 159 } 160 161 static int sharp_panel_prepare(struct drm_panel *panel) 162 { 163 struct sharp_panel *sharp = to_sharp_panel(panel); 164 u8 format = MIPI_DCS_PIXEL_FMT_24BIT; 165 int err; 166 167 if (sharp->prepared) 168 return 0; 169 170 err = regulator_enable(sharp->supply); 171 if (err < 0) 172 return err; 173 174 /* 175 * According to the datasheet, the panel needs around 10 ms to fully 176 * power up. At least another 120 ms is required before exiting sleep 177 * mode to make sure the panel is ready. Throw in another 20 ms for 178 * good measure. 179 */ 180 msleep(150); 181 182 err = mipi_dsi_dcs_exit_sleep_mode(sharp->link1); 183 if (err < 0) { 184 dev_err(panel->dev, "failed to exit sleep mode: %d\n", err); 185 goto poweroff; 186 } 187 188 /* 189 * The MIPI DCS specification mandates this delay only between the 190 * exit_sleep_mode and enter_sleep_mode commands, so it isn't strictly 191 * necessary here. 192 */ 193 /* 194 msleep(120); 195 */ 196 197 /* set left-right mode */ 198 err = sharp_panel_write(sharp, 0x1000, 0x2a); 199 if (err < 0) { 200 dev_err(panel->dev, "failed to set left-right mode: %d\n", err); 201 goto poweroff; 202 } 203 204 /* enable command mode */ 205 err = sharp_panel_write(sharp, 0x1001, 0x01); 206 if (err < 0) { 207 dev_err(panel->dev, "failed to enable command mode: %d\n", err); 208 goto poweroff; 209 } 210 211 err = mipi_dsi_dcs_set_pixel_format(sharp->link1, format); 212 if (err < 0) { 213 dev_err(panel->dev, "failed to set pixel format: %d\n", err); 214 goto poweroff; 215 } 216 217 /* 218 * TODO: The device supports both left-right and even-odd split 219 * configurations, but this driver currently supports only the left- 220 * right split. To support a different mode a mechanism needs to be 221 * put in place to communicate the configuration back to the DSI host 222 * controller. 223 */ 224 err = sharp_setup_symmetrical_split(sharp->link1, sharp->link2, 225 sharp->mode); 226 if (err < 0) { 227 dev_err(panel->dev, "failed to set up symmetrical split: %d\n", 228 err); 229 goto poweroff; 230 } 231 232 err = mipi_dsi_dcs_set_display_on(sharp->link1); 233 if (err < 0) { 234 dev_err(panel->dev, "failed to set display on: %d\n", err); 235 goto poweroff; 236 } 237 238 sharp->prepared = true; 239 240 /* wait for 6 frames before continuing */ 241 sharp_wait_frames(sharp, 6); 242 243 return 0; 244 245 poweroff: 246 regulator_disable(sharp->supply); 247 return err; 248 } 249 250 static int sharp_panel_enable(struct drm_panel *panel) 251 { 252 struct sharp_panel *sharp = to_sharp_panel(panel); 253 254 if (sharp->enabled) 255 return 0; 256 257 sharp->enabled = true; 258 259 return 0; 260 } 261 262 static const struct drm_display_mode default_mode = { 263 .clock = 278000, 264 .hdisplay = 2560, 265 .hsync_start = 2560 + 128, 266 .hsync_end = 2560 + 128 + 64, 267 .htotal = 2560 + 128 + 64 + 64, 268 .vdisplay = 1600, 269 .vsync_start = 1600 + 4, 270 .vsync_end = 1600 + 4 + 8, 271 .vtotal = 1600 + 4 + 8 + 32, 272 .vrefresh = 60, 273 }; 274 275 static int sharp_panel_get_modes(struct drm_panel *panel, 276 struct drm_connector *connector) 277 { 278 struct drm_display_mode *mode; 279 280 mode = drm_mode_duplicate(connector->dev, &default_mode); 281 if (!mode) { 282 dev_err(panel->dev, "failed to add mode %ux%ux@%u\n", 283 default_mode.hdisplay, default_mode.vdisplay, 284 default_mode.vrefresh); 285 return -ENOMEM; 286 } 287 288 drm_mode_set_name(mode); 289 290 drm_mode_probed_add(connector, mode); 291 292 connector->display_info.width_mm = 217; 293 connector->display_info.height_mm = 136; 294 295 return 1; 296 } 297 298 static const struct drm_panel_funcs sharp_panel_funcs = { 299 .disable = sharp_panel_disable, 300 .unprepare = sharp_panel_unprepare, 301 .prepare = sharp_panel_prepare, 302 .enable = sharp_panel_enable, 303 .get_modes = sharp_panel_get_modes, 304 }; 305 306 static const struct of_device_id sharp_of_match[] = { 307 { .compatible = "sharp,lq101r1sx01", }, 308 { } 309 }; 310 MODULE_DEVICE_TABLE(of, sharp_of_match); 311 312 static int sharp_panel_add(struct sharp_panel *sharp) 313 { 314 int ret; 315 316 sharp->mode = &default_mode; 317 318 sharp->supply = devm_regulator_get(&sharp->link1->dev, "power"); 319 if (IS_ERR(sharp->supply)) 320 return PTR_ERR(sharp->supply); 321 322 drm_panel_init(&sharp->base, &sharp->link1->dev, &sharp_panel_funcs, 323 DRM_MODE_CONNECTOR_DSI); 324 325 ret = drm_panel_of_backlight(&sharp->base); 326 if (ret) 327 return ret; 328 329 return drm_panel_add(&sharp->base); 330 } 331 332 static void sharp_panel_del(struct sharp_panel *sharp) 333 { 334 if (sharp->base.dev) 335 drm_panel_remove(&sharp->base); 336 337 if (sharp->link2) 338 put_device(&sharp->link2->dev); 339 } 340 341 static int sharp_panel_probe(struct mipi_dsi_device *dsi) 342 { 343 struct mipi_dsi_device *secondary = NULL; 344 struct sharp_panel *sharp; 345 struct device_node *np; 346 int err; 347 348 dsi->lanes = 4; 349 dsi->format = MIPI_DSI_FMT_RGB888; 350 dsi->mode_flags = MIPI_DSI_MODE_LPM; 351 352 /* Find DSI-LINK1 */ 353 np = of_parse_phandle(dsi->dev.of_node, "link2", 0); 354 if (np) { 355 secondary = of_find_mipi_dsi_device_by_node(np); 356 of_node_put(np); 357 358 if (!secondary) 359 return -EPROBE_DEFER; 360 } 361 362 /* register a panel for only the DSI-LINK1 interface */ 363 if (secondary) { 364 sharp = devm_kzalloc(&dsi->dev, sizeof(*sharp), GFP_KERNEL); 365 if (!sharp) { 366 put_device(&secondary->dev); 367 return -ENOMEM; 368 } 369 370 mipi_dsi_set_drvdata(dsi, sharp); 371 372 sharp->link2 = secondary; 373 sharp->link1 = dsi; 374 375 err = sharp_panel_add(sharp); 376 if (err < 0) { 377 put_device(&secondary->dev); 378 return err; 379 } 380 } 381 382 err = mipi_dsi_attach(dsi); 383 if (err < 0) { 384 if (secondary) 385 sharp_panel_del(sharp); 386 387 return err; 388 } 389 390 return 0; 391 } 392 393 static int sharp_panel_remove(struct mipi_dsi_device *dsi) 394 { 395 struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi); 396 int err; 397 398 /* only detach from host for the DSI-LINK2 interface */ 399 if (!sharp) { 400 mipi_dsi_detach(dsi); 401 return 0; 402 } 403 404 err = drm_panel_disable(&sharp->base); 405 if (err < 0) 406 dev_err(&dsi->dev, "failed to disable panel: %d\n", err); 407 408 err = mipi_dsi_detach(dsi); 409 if (err < 0) 410 dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err); 411 412 sharp_panel_del(sharp); 413 414 return 0; 415 } 416 417 static void sharp_panel_shutdown(struct mipi_dsi_device *dsi) 418 { 419 struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi); 420 421 /* nothing to do for DSI-LINK2 */ 422 if (!sharp) 423 return; 424 425 drm_panel_disable(&sharp->base); 426 } 427 428 static struct mipi_dsi_driver sharp_panel_driver = { 429 .driver = { 430 .name = "panel-sharp-lq101r1sx01", 431 .of_match_table = sharp_of_match, 432 }, 433 .probe = sharp_panel_probe, 434 .remove = sharp_panel_remove, 435 .shutdown = sharp_panel_shutdown, 436 }; 437 module_mipi_dsi_driver(sharp_panel_driver); 438 439 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>"); 440 MODULE_DESCRIPTION("Sharp LQ101R1SX01 panel driver"); 441 MODULE_LICENSE("GPL v2"); 442