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