1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2018, The Linux Foundation. All rights reserved. 4 */ 5 6 #include <linux/backlight.h> 7 #include <linux/delay.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/module.h> 10 #include <linux/of_device.h> 11 #include <linux/of_graph.h> 12 #include <linux/pinctrl/consumer.h> 13 #include <linux/regulator/consumer.h> 14 15 #include <video/mipi_display.h> 16 17 #include <drm/drm_mipi_dsi.h> 18 #include <drm/drm_modes.h> 19 #include <drm/drm_panel.h> 20 #include <drm/drm_print.h> 21 22 static const char * const regulator_names[] = { 23 "vdda", 24 "vdispp", 25 "vdispn", 26 }; 27 28 static unsigned long const regulator_enable_loads[] = { 29 62000, 30 100000, 31 100000, 32 }; 33 34 static unsigned long const regulator_disable_loads[] = { 35 80, 36 100, 37 100, 38 }; 39 40 struct cmd_set { 41 u8 commands[4]; 42 u8 size; 43 }; 44 45 struct nt35597_config { 46 u32 width_mm; 47 u32 height_mm; 48 const char *panel_name; 49 const struct cmd_set *panel_on_cmds; 50 u32 num_on_cmds; 51 const struct drm_display_mode *dm; 52 }; 53 54 struct truly_nt35597 { 55 struct device *dev; 56 struct drm_panel panel; 57 58 struct regulator_bulk_data supplies[ARRAY_SIZE(regulator_names)]; 59 60 struct gpio_desc *reset_gpio; 61 struct gpio_desc *mode_gpio; 62 63 struct backlight_device *backlight; 64 65 struct mipi_dsi_device *dsi[2]; 66 67 const struct nt35597_config *config; 68 bool prepared; 69 bool enabled; 70 }; 71 72 static inline struct truly_nt35597 *panel_to_ctx(struct drm_panel *panel) 73 { 74 return container_of(panel, struct truly_nt35597, panel); 75 } 76 77 static const struct cmd_set qcom_2k_panel_magic_cmds[] = { 78 /* CMD2_P0 */ 79 { { 0xff, 0x20 }, 2 }, 80 { { 0xfb, 0x01 }, 2 }, 81 { { 0x00, 0x01 }, 2 }, 82 { { 0x01, 0x55 }, 2 }, 83 { { 0x02, 0x45 }, 2 }, 84 { { 0x05, 0x40 }, 2 }, 85 { { 0x06, 0x19 }, 2 }, 86 { { 0x07, 0x1e }, 2 }, 87 { { 0x0b, 0x73 }, 2 }, 88 { { 0x0c, 0x73 }, 2 }, 89 { { 0x0e, 0xb0 }, 2 }, 90 { { 0x0f, 0xae }, 2 }, 91 { { 0x11, 0xb8 }, 2 }, 92 { { 0x13, 0x00 }, 2 }, 93 { { 0x58, 0x80 }, 2 }, 94 { { 0x59, 0x01 }, 2 }, 95 { { 0x5a, 0x00 }, 2 }, 96 { { 0x5b, 0x01 }, 2 }, 97 { { 0x5c, 0x80 }, 2 }, 98 { { 0x5d, 0x81 }, 2 }, 99 { { 0x5e, 0x00 }, 2 }, 100 { { 0x5f, 0x01 }, 2 }, 101 { { 0x72, 0x11 }, 2 }, 102 { { 0x68, 0x03 }, 2 }, 103 /* CMD2_P4 */ 104 { { 0xFF, 0x24 }, 2 }, 105 { { 0xFB, 0x01 }, 2 }, 106 { { 0x00, 0x1C }, 2 }, 107 { { 0x01, 0x0B }, 2 }, 108 { { 0x02, 0x0C }, 2 }, 109 { { 0x03, 0x01 }, 2 }, 110 { { 0x04, 0x0F }, 2 }, 111 { { 0x05, 0x10 }, 2 }, 112 { { 0x06, 0x10 }, 2 }, 113 { { 0x07, 0x10 }, 2 }, 114 { { 0x08, 0x89 }, 2 }, 115 { { 0x09, 0x8A }, 2 }, 116 { { 0x0A, 0x13 }, 2 }, 117 { { 0x0B, 0x13 }, 2 }, 118 { { 0x0C, 0x15 }, 2 }, 119 { { 0x0D, 0x15 }, 2 }, 120 { { 0x0E, 0x17 }, 2 }, 121 { { 0x0F, 0x17 }, 2 }, 122 { { 0x10, 0x1C }, 2 }, 123 { { 0x11, 0x0B }, 2 }, 124 { { 0x12, 0x0C }, 2 }, 125 { { 0x13, 0x01 }, 2 }, 126 { { 0x14, 0x0F }, 2 }, 127 { { 0x15, 0x10 }, 2 }, 128 { { 0x16, 0x10 }, 2 }, 129 { { 0x17, 0x10 }, 2 }, 130 { { 0x18, 0x89 }, 2 }, 131 { { 0x19, 0x8A }, 2 }, 132 { { 0x1A, 0x13 }, 2 }, 133 { { 0x1B, 0x13 }, 2 }, 134 { { 0x1C, 0x15 }, 2 }, 135 { { 0x1D, 0x15 }, 2 }, 136 { { 0x1E, 0x17 }, 2 }, 137 { { 0x1F, 0x17 }, 2 }, 138 /* STV */ 139 { { 0x20, 0x40 }, 2 }, 140 { { 0x21, 0x01 }, 2 }, 141 { { 0x22, 0x00 }, 2 }, 142 { { 0x23, 0x40 }, 2 }, 143 { { 0x24, 0x40 }, 2 }, 144 { { 0x25, 0x6D }, 2 }, 145 { { 0x26, 0x40 }, 2 }, 146 { { 0x27, 0x40 }, 2 }, 147 /* Vend */ 148 { { 0xE0, 0x00 }, 2 }, 149 { { 0xDC, 0x21 }, 2 }, 150 { { 0xDD, 0x22 }, 2 }, 151 { { 0xDE, 0x07 }, 2 }, 152 { { 0xDF, 0x07 }, 2 }, 153 { { 0xE3, 0x6D }, 2 }, 154 { { 0xE1, 0x07 }, 2 }, 155 { { 0xE2, 0x07 }, 2 }, 156 /* UD */ 157 { { 0x29, 0xD8 }, 2 }, 158 { { 0x2A, 0x2A }, 2 }, 159 /* CLK */ 160 { { 0x4B, 0x03 }, 2 }, 161 { { 0x4C, 0x11 }, 2 }, 162 { { 0x4D, 0x10 }, 2 }, 163 { { 0x4E, 0x01 }, 2 }, 164 { { 0x4F, 0x01 }, 2 }, 165 { { 0x50, 0x10 }, 2 }, 166 { { 0x51, 0x00 }, 2 }, 167 { { 0x52, 0x80 }, 2 }, 168 { { 0x53, 0x00 }, 2 }, 169 { { 0x56, 0x00 }, 2 }, 170 { { 0x54, 0x07 }, 2 }, 171 { { 0x58, 0x07 }, 2 }, 172 { { 0x55, 0x25 }, 2 }, 173 /* Reset XDONB */ 174 { { 0x5B, 0x43 }, 2 }, 175 { { 0x5C, 0x00 }, 2 }, 176 { { 0x5F, 0x73 }, 2 }, 177 { { 0x60, 0x73 }, 2 }, 178 { { 0x63, 0x22 }, 2 }, 179 { { 0x64, 0x00 }, 2 }, 180 { { 0x67, 0x08 }, 2 }, 181 { { 0x68, 0x04 }, 2 }, 182 /* Resolution:1440x2560 */ 183 { { 0x72, 0x02 }, 2 }, 184 /* mux */ 185 { { 0x7A, 0x80 }, 2 }, 186 { { 0x7B, 0x91 }, 2 }, 187 { { 0x7C, 0xD8 }, 2 }, 188 { { 0x7D, 0x60 }, 2 }, 189 { { 0x7F, 0x15 }, 2 }, 190 { { 0x75, 0x15 }, 2 }, 191 /* ABOFF */ 192 { { 0xB3, 0xC0 }, 2 }, 193 { { 0xB4, 0x00 }, 2 }, 194 { { 0xB5, 0x00 }, 2 }, 195 /* Source EQ */ 196 { { 0x78, 0x00 }, 2 }, 197 { { 0x79, 0x00 }, 2 }, 198 { { 0x80, 0x00 }, 2 }, 199 { { 0x83, 0x00 }, 2 }, 200 /* FP BP */ 201 { { 0x93, 0x0A }, 2 }, 202 { { 0x94, 0x0A }, 2 }, 203 /* Inversion Type */ 204 { { 0x8A, 0x00 }, 2 }, 205 { { 0x9B, 0xFF }, 2 }, 206 /* IMGSWAP =1 @PortSwap=1 */ 207 { { 0x9D, 0xB0 }, 2 }, 208 { { 0x9F, 0x63 }, 2 }, 209 { { 0x98, 0x10 }, 2 }, 210 /* FRM */ 211 { { 0xEC, 0x00 }, 2 }, 212 /* CMD1 */ 213 { { 0xFF, 0x10 }, 2 }, 214 /* VBP+VSA=,VFP = 10H */ 215 { { 0x3B, 0x03, 0x0A, 0x0A }, 4 }, 216 /* FTE on */ 217 { { 0x35, 0x00 }, 2 }, 218 /* EN_BK =1(auto black) */ 219 { { 0xE5, 0x01 }, 2 }, 220 /* CMD mode(10) VDO mode(03) */ 221 { { 0xBB, 0x03 }, 2 }, 222 /* Non Reload MTP */ 223 { { 0xFB, 0x01 }, 2 }, 224 }; 225 226 static int truly_dcs_write(struct drm_panel *panel, u32 command) 227 { 228 struct truly_nt35597 *ctx = panel_to_ctx(panel); 229 int i, ret; 230 231 for (i = 0; i < ARRAY_SIZE(ctx->dsi); i++) { 232 ret = mipi_dsi_dcs_write(ctx->dsi[i], command, NULL, 0); 233 if (ret < 0) { 234 DRM_DEV_ERROR(ctx->dev, 235 "cmd 0x%x failed for dsi = %d\n", 236 command, i); 237 } 238 } 239 240 return ret; 241 } 242 243 static int truly_dcs_write_buf(struct drm_panel *panel, 244 u32 size, const u8 *buf) 245 { 246 struct truly_nt35597 *ctx = panel_to_ctx(panel); 247 int ret = 0; 248 int i; 249 250 for (i = 0; i < ARRAY_SIZE(ctx->dsi); i++) { 251 ret = mipi_dsi_dcs_write_buffer(ctx->dsi[i], buf, size); 252 if (ret < 0) { 253 DRM_DEV_ERROR(ctx->dev, 254 "failed to tx cmd [%d], err: %d\n", i, ret); 255 return ret; 256 } 257 } 258 259 return ret; 260 } 261 262 static int truly_35597_power_on(struct truly_nt35597 *ctx) 263 { 264 int ret, i; 265 266 for (i = 0; i < ARRAY_SIZE(ctx->supplies); i++) { 267 ret = regulator_set_load(ctx->supplies[i].consumer, 268 regulator_enable_loads[i]); 269 if (ret) 270 return ret; 271 } 272 273 ret = regulator_bulk_enable(ARRAY_SIZE(ctx->supplies), ctx->supplies); 274 if (ret < 0) 275 return ret; 276 277 /* 278 * Reset sequence of truly panel requires the panel to be 279 * out of reset for 10ms, followed by being held in reset 280 * for 10ms and then out again 281 */ 282 gpiod_set_value(ctx->reset_gpio, 0); 283 usleep_range(10000, 20000); 284 gpiod_set_value(ctx->reset_gpio, 1); 285 usleep_range(10000, 20000); 286 gpiod_set_value(ctx->reset_gpio, 0); 287 288 return 0; 289 } 290 291 static int truly_nt35597_power_off(struct truly_nt35597 *ctx) 292 { 293 int ret = 0; 294 int i; 295 296 gpiod_set_value(ctx->reset_gpio, 1); 297 298 for (i = 0; i < ARRAY_SIZE(ctx->supplies); i++) { 299 ret = regulator_set_load(ctx->supplies[i].consumer, 300 regulator_disable_loads[i]); 301 if (ret) { 302 DRM_DEV_ERROR(ctx->dev, 303 "regulator_set_load failed %d\n", ret); 304 return ret; 305 } 306 } 307 308 ret = regulator_bulk_disable(ARRAY_SIZE(ctx->supplies), ctx->supplies); 309 if (ret) { 310 DRM_DEV_ERROR(ctx->dev, 311 "regulator_bulk_disable failed %d\n", ret); 312 } 313 return ret; 314 } 315 316 static int truly_nt35597_disable(struct drm_panel *panel) 317 { 318 struct truly_nt35597 *ctx = panel_to_ctx(panel); 319 int ret; 320 321 if (!ctx->enabled) 322 return 0; 323 324 if (ctx->backlight) { 325 ret = backlight_disable(ctx->backlight); 326 if (ret < 0) 327 DRM_DEV_ERROR(ctx->dev, "backlight disable failed %d\n", 328 ret); 329 } 330 331 ctx->enabled = false; 332 return 0; 333 } 334 335 static int truly_nt35597_unprepare(struct drm_panel *panel) 336 { 337 struct truly_nt35597 *ctx = panel_to_ctx(panel); 338 int ret = 0; 339 340 if (!ctx->prepared) 341 return 0; 342 343 ctx->dsi[0]->mode_flags = 0; 344 ctx->dsi[1]->mode_flags = 0; 345 346 ret = truly_dcs_write(panel, MIPI_DCS_SET_DISPLAY_OFF); 347 if (ret < 0) { 348 DRM_DEV_ERROR(ctx->dev, 349 "set_display_off cmd failed ret = %d\n", 350 ret); 351 } 352 353 /* 120ms delay required here as per DCS spec */ 354 msleep(120); 355 356 ret = truly_dcs_write(panel, MIPI_DCS_ENTER_SLEEP_MODE); 357 if (ret < 0) { 358 DRM_DEV_ERROR(ctx->dev, 359 "enter_sleep cmd failed ret = %d\n", ret); 360 } 361 362 ret = truly_nt35597_power_off(ctx); 363 if (ret < 0) 364 DRM_DEV_ERROR(ctx->dev, "power_off failed ret = %d\n", ret); 365 366 ctx->prepared = false; 367 return ret; 368 } 369 370 static int truly_nt35597_prepare(struct drm_panel *panel) 371 { 372 struct truly_nt35597 *ctx = panel_to_ctx(panel); 373 int ret; 374 int i; 375 const struct cmd_set *panel_on_cmds; 376 const struct nt35597_config *config; 377 u32 num_cmds; 378 379 if (ctx->prepared) 380 return 0; 381 382 ret = truly_35597_power_on(ctx); 383 if (ret < 0) 384 return ret; 385 386 ctx->dsi[0]->mode_flags |= MIPI_DSI_MODE_LPM; 387 ctx->dsi[1]->mode_flags |= MIPI_DSI_MODE_LPM; 388 389 config = ctx->config; 390 panel_on_cmds = config->panel_on_cmds; 391 num_cmds = config->num_on_cmds; 392 393 for (i = 0; i < num_cmds; i++) { 394 ret = truly_dcs_write_buf(panel, 395 panel_on_cmds[i].size, 396 panel_on_cmds[i].commands); 397 if (ret < 0) { 398 DRM_DEV_ERROR(ctx->dev, 399 "cmd set tx failed i = %d ret = %d\n", 400 i, ret); 401 goto power_off; 402 } 403 } 404 405 ret = truly_dcs_write(panel, MIPI_DCS_EXIT_SLEEP_MODE); 406 if (ret < 0) { 407 DRM_DEV_ERROR(ctx->dev, 408 "exit_sleep_mode cmd failed ret = %d\n", 409 ret); 410 goto power_off; 411 } 412 413 /* Per DSI spec wait 120ms after sending exit sleep DCS command */ 414 msleep(120); 415 416 ret = truly_dcs_write(panel, MIPI_DCS_SET_DISPLAY_ON); 417 if (ret < 0) { 418 DRM_DEV_ERROR(ctx->dev, 419 "set_display_on cmd failed ret = %d\n", ret); 420 goto power_off; 421 } 422 423 /* Per DSI spec wait 120ms after sending set_display_on DCS command */ 424 msleep(120); 425 426 ctx->prepared = true; 427 428 return 0; 429 430 power_off: 431 if (truly_nt35597_power_off(ctx)) 432 DRM_DEV_ERROR(ctx->dev, "power_off failed\n"); 433 return ret; 434 } 435 436 static int truly_nt35597_enable(struct drm_panel *panel) 437 { 438 struct truly_nt35597 *ctx = panel_to_ctx(panel); 439 int ret; 440 441 if (ctx->enabled) 442 return 0; 443 444 if (ctx->backlight) { 445 ret = backlight_enable(ctx->backlight); 446 if (ret < 0) 447 DRM_DEV_ERROR(ctx->dev, "backlight enable failed %d\n", 448 ret); 449 } 450 451 ctx->enabled = true; 452 453 return 0; 454 } 455 456 static int truly_nt35597_get_modes(struct drm_panel *panel) 457 { 458 struct drm_connector *connector = panel->connector; 459 struct truly_nt35597 *ctx = panel_to_ctx(panel); 460 struct drm_display_mode *mode; 461 const struct nt35597_config *config; 462 463 config = ctx->config; 464 mode = drm_mode_create(connector->dev); 465 if (!mode) { 466 DRM_DEV_ERROR(ctx->dev, 467 "failed to create a new display mode\n"); 468 return 0; 469 } 470 471 connector->display_info.width_mm = config->width_mm; 472 connector->display_info.height_mm = config->height_mm; 473 drm_mode_copy(mode, config->dm); 474 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; 475 drm_mode_probed_add(connector, mode); 476 477 return 1; 478 } 479 480 static const struct drm_panel_funcs truly_nt35597_drm_funcs = { 481 .disable = truly_nt35597_disable, 482 .unprepare = truly_nt35597_unprepare, 483 .prepare = truly_nt35597_prepare, 484 .enable = truly_nt35597_enable, 485 .get_modes = truly_nt35597_get_modes, 486 }; 487 488 static int truly_nt35597_panel_add(struct truly_nt35597 *ctx) 489 { 490 struct device *dev = ctx->dev; 491 int ret, i; 492 const struct nt35597_config *config; 493 494 config = ctx->config; 495 for (i = 0; i < ARRAY_SIZE(ctx->supplies); i++) 496 ctx->supplies[i].supply = regulator_names[i]; 497 498 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ctx->supplies), 499 ctx->supplies); 500 if (ret < 0) 501 return ret; 502 503 ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW); 504 if (IS_ERR(ctx->reset_gpio)) { 505 DRM_DEV_ERROR(dev, "cannot get reset gpio %ld\n", 506 PTR_ERR(ctx->reset_gpio)); 507 return PTR_ERR(ctx->reset_gpio); 508 } 509 510 ctx->mode_gpio = devm_gpiod_get(dev, "mode", GPIOD_OUT_LOW); 511 if (IS_ERR(ctx->mode_gpio)) { 512 DRM_DEV_ERROR(dev, "cannot get mode gpio %ld\n", 513 PTR_ERR(ctx->mode_gpio)); 514 return PTR_ERR(ctx->mode_gpio); 515 } 516 517 /* dual port */ 518 gpiod_set_value(ctx->mode_gpio, 0); 519 520 drm_panel_init(&ctx->panel); 521 ctx->panel.dev = dev; 522 ctx->panel.funcs = &truly_nt35597_drm_funcs; 523 drm_panel_add(&ctx->panel); 524 525 return 0; 526 } 527 528 static const struct drm_display_mode qcom_sdm845_mtp_2k_mode = { 529 .name = "1440x2560", 530 .clock = 268316, 531 .hdisplay = 1440, 532 .hsync_start = 1440 + 200, 533 .hsync_end = 1440 + 200 + 32, 534 .htotal = 1440 + 200 + 32 + 64, 535 .vdisplay = 2560, 536 .vsync_start = 2560 + 8, 537 .vsync_end = 2560 + 8 + 1, 538 .vtotal = 2560 + 8 + 1 + 7, 539 .vrefresh = 60, 540 .flags = 0, 541 }; 542 543 static const struct nt35597_config nt35597_dir = { 544 .width_mm = 74, 545 .height_mm = 131, 546 .panel_name = "qcom_sdm845_mtp_2k_panel", 547 .dm = &qcom_sdm845_mtp_2k_mode, 548 .panel_on_cmds = qcom_2k_panel_magic_cmds, 549 .num_on_cmds = ARRAY_SIZE(qcom_2k_panel_magic_cmds), 550 }; 551 552 static int truly_nt35597_probe(struct mipi_dsi_device *dsi) 553 { 554 struct device *dev = &dsi->dev; 555 struct truly_nt35597 *ctx; 556 struct mipi_dsi_device *dsi1_device; 557 struct device_node *dsi1; 558 struct mipi_dsi_host *dsi1_host; 559 struct mipi_dsi_device *dsi_dev; 560 int ret = 0; 561 int i; 562 563 const struct mipi_dsi_device_info info = { 564 .type = "trulynt35597", 565 .channel = 0, 566 .node = NULL, 567 }; 568 569 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 570 571 if (!ctx) 572 return -ENOMEM; 573 574 /* 575 * This device represents itself as one with two input ports which are 576 * fed by the output ports of the two DSI controllers . The DSI0 is 577 * the master controller and has most of the panel related info in its 578 * child node. 579 */ 580 581 ctx->config = of_device_get_match_data(dev); 582 583 if (!ctx->config) { 584 dev_err(dev, "missing device configuration\n"); 585 return -ENODEV; 586 } 587 588 dsi1 = of_graph_get_remote_node(dsi->dev.of_node, 1, -1); 589 if (!dsi1) { 590 DRM_DEV_ERROR(dev, 591 "failed to get remote node for dsi1_device\n"); 592 return -ENODEV; 593 } 594 595 dsi1_host = of_find_mipi_dsi_host_by_node(dsi1); 596 of_node_put(dsi1); 597 if (!dsi1_host) { 598 DRM_DEV_ERROR(dev, "failed to find dsi host\n"); 599 return -EPROBE_DEFER; 600 } 601 602 /* register the second DSI device */ 603 dsi1_device = mipi_dsi_device_register_full(dsi1_host, &info); 604 if (IS_ERR(dsi1_device)) { 605 DRM_DEV_ERROR(dev, "failed to create dsi device\n"); 606 return PTR_ERR(dsi1_device); 607 } 608 609 mipi_dsi_set_drvdata(dsi, ctx); 610 611 ctx->dev = dev; 612 ctx->dsi[0] = dsi; 613 ctx->dsi[1] = dsi1_device; 614 615 ret = truly_nt35597_panel_add(ctx); 616 if (ret) { 617 DRM_DEV_ERROR(dev, "failed to add panel\n"); 618 goto err_panel_add; 619 } 620 621 for (i = 0; i < ARRAY_SIZE(ctx->dsi); i++) { 622 dsi_dev = ctx->dsi[i]; 623 dsi_dev->lanes = 4; 624 dsi_dev->format = MIPI_DSI_FMT_RGB888; 625 dsi_dev->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_LPM | 626 MIPI_DSI_CLOCK_NON_CONTINUOUS; 627 ret = mipi_dsi_attach(dsi_dev); 628 if (ret < 0) { 629 DRM_DEV_ERROR(dev, 630 "dsi attach failed i = %d\n", i); 631 goto err_dsi_attach; 632 } 633 } 634 635 return 0; 636 637 err_dsi_attach: 638 drm_panel_remove(&ctx->panel); 639 err_panel_add: 640 mipi_dsi_device_unregister(dsi1_device); 641 return ret; 642 } 643 644 static int truly_nt35597_remove(struct mipi_dsi_device *dsi) 645 { 646 struct truly_nt35597 *ctx = mipi_dsi_get_drvdata(dsi); 647 648 if (ctx->dsi[0]) 649 mipi_dsi_detach(ctx->dsi[0]); 650 if (ctx->dsi[1]) { 651 mipi_dsi_detach(ctx->dsi[1]); 652 mipi_dsi_device_unregister(ctx->dsi[1]); 653 } 654 655 drm_panel_remove(&ctx->panel); 656 return 0; 657 } 658 659 static const struct of_device_id truly_nt35597_of_match[] = { 660 { 661 .compatible = "truly,nt35597-2K-display", 662 .data = &nt35597_dir, 663 }, 664 { } 665 }; 666 MODULE_DEVICE_TABLE(of, truly_nt35597_of_match); 667 668 static struct mipi_dsi_driver truly_nt35597_driver = { 669 .driver = { 670 .name = "panel-truly-nt35597", 671 .of_match_table = truly_nt35597_of_match, 672 }, 673 .probe = truly_nt35597_probe, 674 .remove = truly_nt35597_remove, 675 }; 676 module_mipi_dsi_driver(truly_nt35597_driver); 677 678 MODULE_DESCRIPTION("Truly NT35597 DSI Panel Driver"); 679 MODULE_LICENSE("GPL v2"); 680