1 /* 2 * (C) Copyright 2008-2017 Fuzhou Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <asm/unaligned.h> 8 #include <config.h> 9 #include <common.h> 10 #include <errno.h> 11 #include <libfdt.h> 12 #include <fdtdec.h> 13 #include <fdt_support.h> 14 #include <linux/list.h> 15 #include <linux/compat.h> 16 #include <linux/media-bus-format.h> 17 #include <malloc.h> 18 #include <video.h> 19 #include <video_rockchip.h> 20 #include <dm/device.h> 21 #include <dm/uclass-internal.h> 22 #include <asm/arch-rockchip/resource_img.h> 23 24 #include "bmp_helper.h" 25 #include "rockchip_display.h" 26 #include "rockchip_crtc.h" 27 #include "rockchip_connector.h" 28 #include "rockchip_phy.h" 29 #include "rockchip_panel.h" 30 #include <dm.h> 31 #include <dm/of_access.h> 32 #include <dm/ofnode.h> 33 34 #define DRIVER_VERSION "v1.0.0" 35 36 /*********************************************************************** 37 * Rockchip UBOOT DRM driver version 38 * 39 * v1.0.0 : add basic version for rockchip drm driver(hjc) 40 * 41 **********************************************************************/ 42 43 #define RK_BLK_SIZE 512 44 45 DECLARE_GLOBAL_DATA_PTR; 46 static LIST_HEAD(rockchip_display_list); 47 static LIST_HEAD(logo_cache_list); 48 49 static unsigned long memory_start; 50 static unsigned long memory_end; 51 52 static void init_display_buffer(ulong base) 53 { 54 memory_start = base + DRM_ROCKCHIP_FB_SIZE; 55 memory_end = memory_start; 56 } 57 58 static void *get_display_buffer(int size) 59 { 60 unsigned long roundup_memory = roundup(memory_end, PAGE_SIZE); 61 void *buf; 62 63 if (roundup_memory + size > memory_start + MEMORY_POOL_SIZE) { 64 printf("failed to alloc %dbyte memory to display\n", size); 65 return NULL; 66 } 67 buf = (void *)roundup_memory; 68 69 memory_end = roundup_memory + size; 70 71 return buf; 72 } 73 74 static unsigned long get_display_size(void) 75 { 76 return memory_end - memory_start; 77 } 78 79 static bool can_direct_logo(int bpp) 80 { 81 return bpp == 24 || bpp == 32; 82 } 83 84 85 static struct udevice *get_panel_device(struct display_state *state, ofnode conn_node) 86 { 87 struct panel_state *panel_state = &state->panel_state; 88 struct udevice *dev; 89 struct connector_state *conn_state = &state->conn_state; 90 ofnode node, ports_node, port_node; 91 struct device_node *port, *panel, *ep; 92 int ph; 93 int ret; 94 95 node = dev_read_subnode(conn_state->dev, "panel"); 96 if (ofnode_valid(node) && 97 of_device_is_available(ofnode_to_np(node))) { 98 ret = uclass_get_device_by_ofnode(UCLASS_PANEL, node, &dev); 99 if (!ret) { 100 panel_state->node = node; 101 return dev; 102 } 103 } 104 105 /* TODO: this path not tested */ 106 ports_node = dev_read_subnode(conn_state->dev, "ports"); 107 if (!ofnode_valid(ports_node)) 108 return NULL; 109 110 ofnode_for_each_subnode(port_node, ports_node) { 111 ofnode_for_each_subnode(node, port_node) { 112 ph = ofnode_read_u32_default(node, "remote-endpoint", -1); 113 if (!ph) 114 continue; 115 ep = of_find_node_by_phandle(ph); 116 if (!ofnode_valid(np_to_ofnode(ep))) { 117 printf("Warn: can't find endpoint from phdl\n"); 118 continue; 119 } 120 port = of_get_parent(ep); 121 if (!ofnode_valid(np_to_ofnode(port))) { 122 printf("Warn: can't find port node\n"); 123 continue; 124 } 125 panel = of_get_parent(port); 126 if (!ofnode_valid(np_to_ofnode(panel))) { 127 printf("Warn: can't find panel node\n"); 128 continue; 129 } 130 ret = uclass_get_device_by_ofnode(UCLASS_PANEL, 131 np_to_ofnode(panel), 132 &dev); 133 if (!ret) { 134 panel_state->node = np_to_ofnode(panel); 135 return dev; 136 } 137 } 138 } 139 140 return NULL; 141 } 142 143 static int connector_phy_init(struct display_state *state) 144 { 145 struct connector_state *conn_state = &state->conn_state; 146 const struct rockchip_phy *phy; 147 struct udevice *dev; 148 int ret; 149 150 ret = uclass_get_device_by_phandle(UCLASS_PHY, conn_state->dev, "phys", 151 &dev); 152 if (ret) { 153 debug("Warn: can't find phy driver\n"); 154 return 0; 155 } 156 157 phy = (const struct rockchip_phy *)dev_get_driver_data(dev); 158 if (!phy) { 159 printf("failed to find phy driver\n"); 160 return 0; 161 } 162 163 conn_state->phy_dev = dev; 164 conn_state->phy_node = dev->node; 165 166 if (!phy->funcs || !phy->funcs->init || 167 phy->funcs->init(state)) { 168 printf("failed to init phy driver\n"); 169 return -EINVAL; 170 } 171 172 conn_state->phy = phy; 173 return 0; 174 } 175 176 static int connector_panel_init(struct display_state *state) 177 { 178 struct connector_state *conn_state = &state->conn_state; 179 struct panel_state *panel_state = &state->panel_state; 180 struct udevice *dev; 181 ofnode conn_node = conn_state->node; 182 const struct rockchip_panel *panel; 183 ofnode dsp_lut_node; 184 int ret, len; 185 186 dm_scan_fdt_dev(conn_state->dev); 187 188 dev = get_panel_device(state, conn_node); 189 if (!dev) { 190 return 0; 191 } 192 193 panel = (const struct rockchip_panel *)dev_get_driver_data(dev); 194 if (!panel) { 195 printf("failed to find panel driver\n"); 196 return 0; 197 } 198 199 panel_state->dev = dev; 200 panel_state->panel = panel; 201 202 if (panel->funcs && panel->funcs->init) { 203 ret = panel->funcs->init(state); 204 if (ret) { 205 printf("failed to init panel driver\n"); 206 return ret; 207 } 208 } 209 210 dsp_lut_node = dev_read_subnode(dev, "dsp-lut"); 211 if (!ofnode_valid(dsp_lut_node)) { 212 debug("%s can not find dsp-lut node\n", __func__); 213 return 0; 214 } 215 216 ofnode_get_property(dsp_lut_node, "gamma-lut", &len); 217 if (len > 0) { 218 conn_state->gamma.size = len / sizeof(u32); 219 conn_state->gamma.lut = malloc(len); 220 if (!conn_state->gamma.lut) { 221 printf("malloc gamma lut failed\n"); 222 return -ENOMEM; 223 } 224 ret = ofnode_read_u32_array(dsp_lut_node, "gamma-lut", 225 conn_state->gamma.lut, 226 conn_state->gamma.size); 227 if (ret) { 228 printf("Cannot decode gamma_lut\n"); 229 conn_state->gamma.lut = NULL; 230 return -EINVAL; 231 } 232 panel_state->dsp_lut_node = dsp_lut_node; 233 } 234 235 return 0; 236 } 237 238 int drm_mode_vrefresh(const struct drm_display_mode *mode) 239 { 240 int refresh = 0; 241 unsigned int calc_val; 242 243 if (mode->vrefresh > 0) { 244 refresh = mode->vrefresh; 245 } else if (mode->htotal > 0 && mode->vtotal > 0) { 246 int vtotal; 247 248 vtotal = mode->vtotal; 249 /* work out vrefresh the value will be x1000 */ 250 calc_val = (mode->clock * 1000); 251 calc_val /= mode->htotal; 252 refresh = (calc_val + vtotal / 2) / vtotal; 253 254 if (mode->flags & DRM_MODE_FLAG_INTERLACE) 255 refresh *= 2; 256 if (mode->flags & DRM_MODE_FLAG_DBLSCAN) 257 refresh /= 2; 258 if (mode->vscan > 1) 259 refresh /= mode->vscan; 260 } 261 return refresh; 262 } 263 264 static int display_get_timing_from_dts(struct panel_state *panel_state, 265 struct drm_display_mode *mode) 266 { 267 int phandle; 268 int hactive, vactive, pixelclock; 269 int hfront_porch, hback_porch, hsync_len; 270 int vfront_porch, vback_porch, vsync_len; 271 int val, flags = 0; 272 ofnode timing, native_mode; 273 274 timing = dev_read_subnode(panel_state->dev, "display-timings"); 275 if (!ofnode_valid(timing)) 276 return -ENODEV; 277 278 native_mode = ofnode_find_subnode(timing, "timing"); 279 if (!ofnode_valid(native_mode)) { 280 phandle = ofnode_read_u32_default(timing, "native-mode", -1); 281 native_mode = np_to_ofnode(of_find_node_by_phandle(phandle)); 282 if (!ofnode_valid(native_mode)) { 283 printf("failed to get display timings from DT\n"); 284 return -ENXIO; 285 } 286 } 287 288 #define FDT_GET_INT(val, name) \ 289 val = ofnode_read_s32_default(native_mode, name, -1); \ 290 if (val < 0) { \ 291 printf("Can't get %s\n", name); \ 292 return -ENXIO; \ 293 } 294 295 FDT_GET_INT(hactive, "hactive"); 296 FDT_GET_INT(vactive, "vactive"); 297 FDT_GET_INT(pixelclock, "clock-frequency"); 298 FDT_GET_INT(hsync_len, "hsync-len"); 299 FDT_GET_INT(hfront_porch, "hfront-porch"); 300 FDT_GET_INT(hback_porch, "hback-porch"); 301 FDT_GET_INT(vsync_len, "vsync-len"); 302 FDT_GET_INT(vfront_porch, "vfront-porch"); 303 FDT_GET_INT(vback_porch, "vback-porch"); 304 FDT_GET_INT(val, "hsync-active"); 305 flags |= val ? DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC; 306 FDT_GET_INT(val, "vsync-active"); 307 flags |= val ? DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC; 308 FDT_GET_INT(val, "pixelclk-active"); 309 flags |= val ? DRM_MODE_FLAG_PPIXDATA : 0; 310 311 mode->hdisplay = hactive; 312 mode->hsync_start = mode->hdisplay + hfront_porch; 313 mode->hsync_end = mode->hsync_start + hsync_len; 314 mode->htotal = mode->hsync_end + hback_porch; 315 316 mode->vdisplay = vactive; 317 mode->vsync_start = mode->vdisplay + vfront_porch; 318 mode->vsync_end = mode->vsync_start + vsync_len; 319 mode->vtotal = mode->vsync_end + vback_porch; 320 321 mode->clock = pixelclock / 1000; 322 mode->flags = flags; 323 324 return 0; 325 } 326 327 /** 328 * drm_mode_set_crtcinfo - set CRTC modesetting timing parameters 329 * @p: mode 330 * @adjust_flags: a combination of adjustment flags 331 * 332 * Setup the CRTC modesetting timing parameters for @p, adjusting if necessary. 333 * 334 * - The CRTC_INTERLACE_HALVE_V flag can be used to halve vertical timings of 335 * interlaced modes. 336 * - The CRTC_STEREO_DOUBLE flag can be used to compute the timings for 337 * buffers containing two eyes (only adjust the timings when needed, eg. for 338 * "frame packing" or "side by side full"). 339 * - The CRTC_NO_DBLSCAN and CRTC_NO_VSCAN flags request that adjustment *not* 340 * be performed for doublescan and vscan > 1 modes respectively. 341 */ 342 void drm_mode_set_crtcinfo(struct drm_display_mode *p, int adjust_flags) 343 { 344 if ((p == NULL) || ((p->type & DRM_MODE_TYPE_CRTC_C) == DRM_MODE_TYPE_BUILTIN)) 345 return; 346 347 if (p->flags & DRM_MODE_FLAG_DBLCLK) 348 p->crtc_clock = 2 * p->clock; 349 else 350 p->crtc_clock = p->clock; 351 p->crtc_hdisplay = p->hdisplay; 352 p->crtc_hsync_start = p->hsync_start; 353 p->crtc_hsync_end = p->hsync_end; 354 p->crtc_htotal = p->htotal; 355 p->crtc_hskew = p->hskew; 356 p->crtc_vdisplay = p->vdisplay; 357 p->crtc_vsync_start = p->vsync_start; 358 p->crtc_vsync_end = p->vsync_end; 359 p->crtc_vtotal = p->vtotal; 360 361 if (p->flags & DRM_MODE_FLAG_INTERLACE) { 362 if (adjust_flags & CRTC_INTERLACE_HALVE_V) { 363 p->crtc_vdisplay /= 2; 364 p->crtc_vsync_start /= 2; 365 p->crtc_vsync_end /= 2; 366 p->crtc_vtotal /= 2; 367 } 368 } 369 370 if (!(adjust_flags & CRTC_NO_DBLSCAN)) { 371 if (p->flags & DRM_MODE_FLAG_DBLSCAN) { 372 p->crtc_vdisplay *= 2; 373 p->crtc_vsync_start *= 2; 374 p->crtc_vsync_end *= 2; 375 p->crtc_vtotal *= 2; 376 } 377 } 378 379 if (!(adjust_flags & CRTC_NO_VSCAN)) { 380 if (p->vscan > 1) { 381 p->crtc_vdisplay *= p->vscan; 382 p->crtc_vsync_start *= p->vscan; 383 p->crtc_vsync_end *= p->vscan; 384 p->crtc_vtotal *= p->vscan; 385 } 386 } 387 388 if (adjust_flags & CRTC_STEREO_DOUBLE) { 389 unsigned int layout = p->flags & DRM_MODE_FLAG_3D_MASK; 390 391 switch (layout) { 392 case DRM_MODE_FLAG_3D_FRAME_PACKING: 393 p->crtc_clock *= 2; 394 p->crtc_vdisplay += p->crtc_vtotal; 395 p->crtc_vsync_start += p->crtc_vtotal; 396 p->crtc_vsync_end += p->crtc_vtotal; 397 p->crtc_vtotal += p->crtc_vtotal; 398 break; 399 } 400 } 401 402 p->crtc_vblank_start = min(p->crtc_vsync_start, p->crtc_vdisplay); 403 p->crtc_vblank_end = max(p->crtc_vsync_end, p->crtc_vtotal); 404 p->crtc_hblank_start = min(p->crtc_hsync_start, p->crtc_hdisplay); 405 p->crtc_hblank_end = max(p->crtc_hsync_end, p->crtc_htotal); 406 } 407 408 static int display_get_timing(struct display_state *state) 409 { 410 struct connector_state *conn_state = &state->conn_state; 411 const struct rockchip_connector *conn = conn_state->connector; 412 const struct rockchip_connector_funcs *conn_funcs = conn->funcs; 413 struct drm_display_mode *mode = &conn_state->mode; 414 const struct drm_display_mode *m; 415 struct panel_state *panel_state = &state->panel_state; 416 const struct rockchip_panel *panel = panel_state->panel; 417 const struct rockchip_panel_funcs *panel_funcs = panel->funcs; 418 ofnode panel_node = panel_state->node; 419 int ret; 420 421 if (ofnode_valid(panel_node) && !display_get_timing_from_dts(panel_state, mode)) { 422 printf("Using display timing dts\n"); 423 goto done; 424 } 425 426 if (panel->data) { 427 m = (const struct drm_display_mode *)panel->data; 428 memcpy(mode, m, sizeof(*m)); 429 printf("Using display timing from compatible panel driver\n"); 430 goto done; 431 } 432 433 if (conn_funcs->get_edid && !conn_funcs->get_edid(state)) { 434 int panel_bits_per_colourp; 435 436 /* In order to read EDID, the panel needs to be powered on */ 437 if (panel_funcs->prepare) { 438 ret = panel_funcs->prepare(state); 439 if (ret) { 440 printf("failed to prepare panel\n"); 441 return ret; 442 } 443 } 444 445 if (!edid_get_drm_mode((void *)&conn_state->edid, 446 sizeof(conn_state->edid), mode, 447 &panel_bits_per_colourp)) { 448 printf("Using display timing from edid\n"); 449 edid_print_info((void *)&conn_state->edid); 450 goto done; 451 } else { 452 if (panel_funcs->unprepare) 453 panel_funcs->unprepare(state); 454 } 455 } 456 457 printf("failed to find display timing\n"); 458 return -ENODEV; 459 done: 460 printf("Detailed mode clock %u kHz, flags[%x]\n" 461 " H: %04d %04d %04d %04d\n" 462 " V: %04d %04d %04d %04d\n" 463 "bus_format: %x\n", 464 mode->clock, mode->flags, 465 mode->hdisplay, mode->hsync_start, 466 mode->hsync_end, mode->htotal, 467 mode->vdisplay, mode->vsync_start, 468 mode->vsync_end, mode->vtotal, 469 conn_state->bus_format); 470 471 return 0; 472 } 473 474 static int display_init(struct display_state *state) 475 { 476 struct connector_state *conn_state = &state->conn_state; 477 const struct rockchip_connector *conn = conn_state->connector; 478 const struct rockchip_connector_funcs *conn_funcs = conn->funcs; 479 struct crtc_state *crtc_state = &state->crtc_state; 480 const struct rockchip_crtc *crtc = crtc_state->crtc; 481 const struct rockchip_crtc_funcs *crtc_funcs = crtc->funcs; 482 struct drm_display_mode *mode = &conn_state->mode; 483 int ret = 0; 484 static bool __print_once = false; 485 486 if (!__print_once) { 487 __print_once = true; 488 printf("Rockchip UBOOT DRM driver version: %s\n", DRIVER_VERSION); 489 } 490 491 if (state->is_init) 492 return 0; 493 494 if (!conn_funcs || !crtc_funcs) { 495 printf("failed to find connector or crtc functions\n"); 496 return -ENXIO; 497 } 498 499 if (conn_funcs->init) { 500 ret = conn_funcs->init(state); 501 if (ret) 502 goto deinit; 503 } 504 /* 505 * support hotplug, but not connect; 506 */ 507 if (conn_funcs->detect) { 508 ret = conn_funcs->detect(state); 509 if (!ret) 510 goto deinit; 511 } 512 513 if (conn_funcs->get_timing) { 514 ret = conn_funcs->get_timing(state); 515 if (ret) 516 goto deinit; 517 } else { 518 ret = display_get_timing(state); 519 if (ret) 520 goto deinit; 521 } 522 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 523 524 if (crtc_funcs->init) { 525 ret = crtc_funcs->init(state); 526 if (ret) 527 goto deinit; 528 } 529 530 state->is_init = 1; 531 532 return 0; 533 534 deinit: 535 if (conn_funcs->deinit) 536 conn_funcs->deinit(state); 537 return ret; 538 } 539 540 static int display_set_plane(struct display_state *state) 541 { 542 struct crtc_state *crtc_state = &state->crtc_state; 543 const struct rockchip_crtc *crtc = crtc_state->crtc; 544 const struct rockchip_crtc_funcs *crtc_funcs = crtc->funcs; 545 int ret; 546 547 if (!state->is_init) 548 return -EINVAL; 549 550 if (crtc_funcs->set_plane) { 551 ret = crtc_funcs->set_plane(state); 552 if (ret) 553 return ret; 554 } 555 556 return 0; 557 } 558 559 static int display_enable(struct display_state *state) 560 { 561 struct connector_state *conn_state = &state->conn_state; 562 const struct rockchip_connector *conn = conn_state->connector; 563 const struct rockchip_connector_funcs *conn_funcs = conn->funcs; 564 struct crtc_state *crtc_state = &state->crtc_state; 565 const struct rockchip_crtc *crtc = crtc_state->crtc; 566 const struct rockchip_crtc_funcs *crtc_funcs = crtc->funcs; 567 struct panel_state *panel_state = &state->panel_state; 568 const struct rockchip_panel *panel = panel_state->panel; 569 const struct rockchip_panel_funcs *panel_funcs = panel->funcs; 570 int ret = 0; 571 572 display_init(state); 573 574 if (!state->is_init) 575 return -EINVAL; 576 577 if (state->is_enable) 578 return 0; 579 580 if (crtc_funcs->prepare) { 581 ret = crtc_funcs->prepare(state); 582 if (ret) 583 return ret; 584 } 585 586 if (conn_funcs->prepare) { 587 ret = conn_funcs->prepare(state); 588 if (ret) 589 goto unprepare_crtc; 590 } 591 592 if (panel_funcs->prepare) { 593 ret = panel_funcs->prepare(state); 594 if (ret) { 595 printf("failed to prepare panel\n"); 596 goto unprepare_conn; 597 } 598 } 599 600 if (crtc_funcs->enable) { 601 ret = crtc_funcs->enable(state); 602 if (ret) 603 goto unprepare_panel; 604 } 605 606 if (conn_funcs->enable) { 607 ret = conn_funcs->enable(state); 608 if (ret) 609 goto disable_crtc; 610 } 611 612 if (panel_funcs->enable) { 613 ret = panel_funcs->enable(state); 614 if (ret) { 615 printf("failed to enable panel\n"); 616 goto disable_conn; 617 } 618 } 619 620 state->is_enable = true; 621 622 return 0; 623 624 disable_conn: 625 if (conn_funcs->unprepare) 626 conn_funcs->unprepare(state); 627 disable_crtc: 628 if (crtc_funcs->disable) 629 crtc_funcs->disable(state); 630 unprepare_crtc: 631 if (crtc_funcs->unprepare) 632 crtc_funcs->unprepare(state); 633 unprepare_panel: 634 if (panel_funcs->unprepare) 635 panel_funcs->unprepare(state); 636 unprepare_conn: 637 if (conn_funcs->unprepare) 638 conn_funcs->unprepare(state); 639 return ret; 640 } 641 642 static int display_disable(struct display_state *state) 643 { 644 struct connector_state *conn_state = &state->conn_state; 645 const struct rockchip_connector *conn = conn_state->connector; 646 const struct rockchip_connector_funcs *conn_funcs = conn->funcs; 647 struct crtc_state *crtc_state = &state->crtc_state; 648 const struct rockchip_crtc *crtc = crtc_state->crtc; 649 const struct rockchip_crtc_funcs *crtc_funcs = crtc->funcs; 650 struct panel_state *panel_state = &state->panel_state; 651 const struct rockchip_panel *panel = panel_state->panel; 652 const struct rockchip_panel_funcs *panel_funcs = panel->funcs; 653 654 if (!state->is_init) 655 return 0; 656 657 if (!state->is_enable) 658 return 0; 659 660 if (panel_funcs->disable) 661 panel_funcs->disable(state); 662 663 if (crtc_funcs->disable) 664 crtc_funcs->disable(state); 665 666 if (conn_funcs->disable) 667 conn_funcs->disable(state); 668 669 if (panel_funcs->unprepare) 670 panel_funcs->unprepare(state); 671 672 if (conn_funcs->unprepare) 673 conn_funcs->unprepare(state); 674 675 state->is_enable = 0; 676 state->is_init = 0; 677 678 return 0; 679 } 680 681 static int display_logo(struct display_state *state) 682 { 683 struct crtc_state *crtc_state = &state->crtc_state; 684 struct connector_state *conn_state = &state->conn_state; 685 struct logo_info *logo = &state->logo; 686 int hdisplay, vdisplay; 687 688 display_init(state); 689 if (!state->is_init) 690 return -ENODEV; 691 692 switch (logo->bpp) { 693 case 16: 694 crtc_state->format = ROCKCHIP_FMT_RGB565; 695 break; 696 case 24: 697 crtc_state->format = ROCKCHIP_FMT_RGB888; 698 break; 699 case 32: 700 crtc_state->format = ROCKCHIP_FMT_ARGB8888; 701 break; 702 default: 703 printf("can't support bmp bits[%d]\n", logo->bpp); 704 return -EINVAL; 705 } 706 crtc_state->rb_swap = logo->bpp != 32; 707 hdisplay = conn_state->mode.hdisplay; 708 vdisplay = conn_state->mode.vdisplay; 709 crtc_state->src_w = logo->width; 710 crtc_state->src_h = logo->height; 711 crtc_state->src_x = 0; 712 crtc_state->src_y = 0; 713 crtc_state->ymirror = logo->ymirror; 714 715 crtc_state->dma_addr = (u32)(unsigned long)logo->mem + logo->offset; 716 crtc_state->xvir = ALIGN(crtc_state->src_w * logo->bpp, 32) >> 5; 717 718 if (logo->mode == ROCKCHIP_DISPLAY_FULLSCREEN) { 719 crtc_state->crtc_x = 0; 720 crtc_state->crtc_y = 0; 721 crtc_state->crtc_w = hdisplay; 722 crtc_state->crtc_h = vdisplay; 723 } else { 724 if (crtc_state->src_w >= hdisplay) { 725 crtc_state->crtc_x = 0; 726 crtc_state->crtc_w = hdisplay; 727 } else { 728 crtc_state->crtc_x = (hdisplay - crtc_state->src_w) / 2; 729 crtc_state->crtc_w = crtc_state->src_w; 730 } 731 732 if (crtc_state->src_h >= vdisplay) { 733 crtc_state->crtc_y = 0; 734 crtc_state->crtc_h = vdisplay; 735 } else { 736 crtc_state->crtc_y = (vdisplay - crtc_state->src_h) / 2; 737 crtc_state->crtc_h = crtc_state->src_h; 738 } 739 } 740 741 display_set_plane(state); 742 display_enable(state); 743 744 return 0; 745 } 746 747 static int get_crtc_id(ofnode connect) 748 { 749 int phandle; 750 struct device_node *remote; 751 int val; 752 753 phandle = ofnode_read_u32_default(connect, "remote-endpoint", -1); 754 if (phandle < 0) 755 goto err; 756 remote = of_find_node_by_phandle(phandle); 757 val = ofnode_read_u32_default(np_to_ofnode(remote), "reg", -1); 758 if (val < 0) 759 goto err; 760 761 return val; 762 err: 763 printf("Can't get crtc id, default set to id = 0\n"); 764 return 0; 765 } 766 767 struct rockchip_logo_cache *find_or_alloc_logo_cache(const char *bmp) 768 { 769 struct rockchip_logo_cache *tmp, *logo_cache = NULL; 770 771 list_for_each_entry(tmp, &logo_cache_list, head) { 772 if (!strcmp(tmp->name, bmp)) { 773 logo_cache = tmp; 774 break; 775 } 776 } 777 778 if (!logo_cache) { 779 logo_cache = malloc(sizeof(*logo_cache)); 780 if (!logo_cache) { 781 printf("failed to alloc memory for logo cache\n"); 782 return NULL; 783 } 784 memset(logo_cache, 0, sizeof(*logo_cache)); 785 strcpy(logo_cache->name, bmp); 786 INIT_LIST_HEAD(&logo_cache->head); 787 list_add_tail(&logo_cache->head, &logo_cache_list); 788 } 789 790 return logo_cache; 791 } 792 793 /* Note: used only for rkfb kernel driver */ 794 static int load_kernel_bmp_logo(struct logo_info *logo, const char *bmp_name) 795 { 796 #ifdef CONFIG_ROCKCHIP_RESOURCE_IMAGE 797 void *dst = NULL; 798 int len, size; 799 struct bmp_header *header; 800 801 if (!logo || !bmp_name) 802 return -EINVAL; 803 804 header = malloc(RK_BLK_SIZE); 805 if (!header) 806 return -ENOMEM; 807 808 len = rockchip_read_resource_file(header, bmp_name, 0, RK_BLK_SIZE); 809 if (len != RK_BLK_SIZE) { 810 free(header); 811 return -EINVAL; 812 } 813 size = get_unaligned_le32(&header->file_size); 814 dst = (void *)(memory_start + MEMORY_POOL_SIZE / 2); 815 len = rockchip_read_resource_file(dst, bmp_name, 0, size); 816 if (len != size) { 817 printf("failed to load bmp %s\n", bmp_name); 818 free(header); 819 return -ENOENT; 820 } 821 822 logo->mem = dst; 823 824 return 0; 825 #endif 826 } 827 828 static int load_bmp_logo(struct logo_info *logo, const char *bmp_name) 829 { 830 #ifdef CONFIG_ROCKCHIP_RESOURCE_IMAGE 831 struct rockchip_logo_cache *logo_cache; 832 struct bmp_header *header; 833 void *dst = NULL, *pdst; 834 int size, len; 835 int ret = 0; 836 837 if (!logo || !bmp_name) 838 return -EINVAL; 839 logo_cache = find_or_alloc_logo_cache(bmp_name); 840 if (!logo_cache) 841 return -ENOMEM; 842 843 if (logo_cache->logo.mem) { 844 memcpy(logo, &logo_cache->logo, sizeof(*logo)); 845 return 0; 846 } 847 848 header = malloc(RK_BLK_SIZE); 849 if (!header) 850 return -ENOMEM; 851 852 len = rockchip_read_resource_file(header, bmp_name, 0, RK_BLK_SIZE); 853 if (len != RK_BLK_SIZE) { 854 ret = -EINVAL; 855 goto free_header; 856 } 857 858 logo->bpp = get_unaligned_le16(&header->bit_count); 859 logo->width = get_unaligned_le32(&header->width); 860 logo->height = get_unaligned_le32(&header->height); 861 size = get_unaligned_le32(&header->file_size); 862 if (!can_direct_logo(logo->bpp)) { 863 if (size > MEMORY_POOL_SIZE) { 864 printf("failed to use boot buf as temp bmp buffer\n"); 865 ret = -ENOMEM; 866 goto free_header; 867 } 868 pdst = get_display_buffer(size); 869 870 } else { 871 pdst = get_display_buffer(size); 872 dst = pdst; 873 } 874 875 len = rockchip_read_resource_file(pdst, bmp_name, 0, size); 876 if (len != size) { 877 printf("failed to load bmp %s\n", bmp_name); 878 ret = -ENOENT; 879 goto free_header; 880 } 881 882 if (!can_direct_logo(logo->bpp)) { 883 int dst_size; 884 /* 885 * TODO: force use 16bpp if bpp less than 16; 886 */ 887 logo->bpp = (logo->bpp <= 16) ? 16 : logo->bpp; 888 dst_size = logo->width * logo->height * logo->bpp >> 3; 889 890 dst = get_display_buffer(dst_size); 891 if (!dst) { 892 ret = -ENOMEM; 893 goto free_header; 894 } 895 if (bmpdecoder(pdst, dst, logo->bpp)) { 896 printf("failed to decode bmp %s\n", bmp_name); 897 ret = -EINVAL; 898 goto free_header; 899 } 900 flush_dcache_range((ulong)dst, 901 ALIGN((ulong)dst + dst_size, 902 CONFIG_SYS_CACHELINE_SIZE)); 903 904 logo->offset = 0; 905 logo->ymirror = 0; 906 } else { 907 logo->offset = get_unaligned_le32(&header->data_offset); 908 logo->ymirror = 1; 909 } 910 logo->mem = dst; 911 912 memcpy(&logo_cache->logo, logo, sizeof(*logo)); 913 914 free_header: 915 916 free(header); 917 918 return ret; 919 #else 920 return -EINVAL; 921 #endif 922 } 923 924 void rockchip_show_fbbase(ulong fbbase) 925 { 926 struct display_state *s; 927 928 list_for_each_entry(s, &rockchip_display_list, head) { 929 s->logo.mode = ROCKCHIP_DISPLAY_FULLSCREEN; 930 s->logo.mem = (char *)fbbase; 931 s->logo.width = DRM_ROCKCHIP_FB_WIDTH; 932 s->logo.height = DRM_ROCKCHIP_FB_HEIGHT; 933 s->logo.bpp = 32; 934 s->logo.ymirror = 0; 935 936 display_logo(s); 937 } 938 } 939 940 void rockchip_show_bmp(const char *bmp) 941 { 942 struct display_state *s; 943 944 if (!bmp) { 945 list_for_each_entry(s, &rockchip_display_list, head) 946 display_disable(s); 947 return; 948 } 949 950 list_for_each_entry(s, &rockchip_display_list, head) { 951 s->logo.mode = s->charge_logo_mode; 952 if (load_bmp_logo(&s->logo, bmp)) 953 continue; 954 display_logo(s); 955 } 956 } 957 958 void rockchip_show_logo(void) 959 { 960 struct display_state *s; 961 962 list_for_each_entry(s, &rockchip_display_list, head) { 963 s->logo.mode = s->logo_mode; 964 if (load_bmp_logo(&s->logo, s->ulogo_name)) 965 printf("failed to display uboot logo\n"); 966 else 967 display_logo(s); 968 969 /* Load kernel bmp in rockchip_display_fixup() later */ 970 } 971 } 972 973 static int rockchip_display_probe(struct udevice *dev) 974 { 975 struct video_priv *uc_priv = dev_get_uclass_priv(dev); 976 struct video_uc_platdata *plat = dev_get_uclass_platdata(dev); 977 const void *blob = gd->fdt_blob; 978 int phandle; 979 struct udevice *crtc_dev, *conn_dev; 980 const struct rockchip_crtc *crtc; 981 const struct rockchip_connector *conn; 982 struct display_state *s; 983 const char *name; 984 int ret; 985 ofnode node, route_node; 986 struct device_node *port_node, *vop_node, *ep_node; 987 struct device_node *cnt_node, *p; 988 989 /* Before relocation we don't need to do anything */ 990 if (!(gd->flags & GD_FLG_RELOC)) 991 return 0; 992 init_display_buffer(plat->base); 993 994 route_node = dev_read_subnode(dev, "route"); 995 if (!ofnode_valid(route_node)) 996 return -ENODEV; 997 998 ofnode_for_each_subnode(node, route_node) { 999 if (!ofnode_is_available(node)) 1000 continue; 1001 phandle = ofnode_read_u32_default(node, "connect", -1); 1002 if (phandle < 0) { 1003 printf("Warn: can't find connect node's handle\n"); 1004 continue; 1005 } 1006 ep_node = of_find_node_by_phandle(phandle); 1007 if (!ofnode_valid(np_to_ofnode(ep_node))) { 1008 printf("Warn: can't find endpoint node from phandle\n"); 1009 continue; 1010 } 1011 port_node = of_get_parent(ep_node); 1012 if (!ofnode_valid(np_to_ofnode(port_node))) { 1013 printf("Warn: can't find port node from phandle\n"); 1014 continue; 1015 } 1016 vop_node = of_get_parent(port_node); 1017 if (!ofnode_valid(np_to_ofnode(vop_node))) { 1018 printf("Warn: can't find crtc node from phandle\n"); 1019 continue; 1020 } 1021 ret = uclass_get_device_by_ofnode(UCLASS_VIDEO_CRTC, 1022 np_to_ofnode(vop_node), 1023 &crtc_dev); 1024 if (ret) { 1025 printf("Warn: can't find crtc driver %d\n", ret); 1026 continue; 1027 } 1028 crtc = (const struct rockchip_crtc *)dev_get_driver_data(crtc_dev); 1029 1030 phandle = ofnode_read_u32_default(np_to_ofnode(ep_node), 1031 "remote-endpoint", -1); 1032 cnt_node = of_find_node_by_phandle(phandle); 1033 if (phandle < 0) { 1034 printf("Warn: can't find remote-endpoint's handle\n"); 1035 continue; 1036 } 1037 while (cnt_node->parent){ 1038 p = of_get_parent(cnt_node); 1039 if (!strcmp(p->full_name, "/")) 1040 break; 1041 cnt_node = p; 1042 } 1043 if (!of_device_is_available(cnt_node)) 1044 continue; 1045 ret = uclass_get_device_by_ofnode(UCLASS_DISPLAY, 1046 np_to_ofnode(cnt_node), 1047 &conn_dev); 1048 if (ret) { 1049 printf("Warn: can't find connect driver\n"); 1050 continue; 1051 } 1052 conn = (const struct rockchip_connector *)dev_get_driver_data(conn_dev); 1053 1054 s = malloc(sizeof(*s)); 1055 if (!s) 1056 continue; 1057 1058 memset(s, 0, sizeof(*s)); 1059 1060 INIT_LIST_HEAD(&s->head); 1061 ret = ofnode_read_string_index(node, "logo,uboot", 0, &s->ulogo_name); 1062 ret = ofnode_read_string_index(node, "logo,kernel", 0, &s->klogo_name); 1063 ret = ofnode_read_string_index(node, "logo,mode", 0, &name); 1064 if (!strcmp(name, "fullscreen")) 1065 s->logo_mode = ROCKCHIP_DISPLAY_FULLSCREEN; 1066 else 1067 s->logo_mode = ROCKCHIP_DISPLAY_CENTER; 1068 ret = ofnode_read_string_index(node, "charge_logo,mode", 0, &name); 1069 if (!strcmp(name, "fullscreen")) 1070 s->charge_logo_mode = ROCKCHIP_DISPLAY_FULLSCREEN; 1071 else 1072 s->charge_logo_mode = ROCKCHIP_DISPLAY_CENTER; 1073 1074 s->blob = blob; 1075 s->conn_state.node = np_to_ofnode(cnt_node); 1076 s->conn_state.dev = conn_dev; 1077 s->conn_state.connector = conn; 1078 s->conn_state.overscan.left_margin = 100; 1079 s->conn_state.overscan.right_margin = 100; 1080 s->conn_state.overscan.top_margin = 100; 1081 s->conn_state.overscan.bottom_margin = 100; 1082 s->crtc_state.node = np_to_ofnode(vop_node); 1083 s->crtc_state.dev = crtc_dev; 1084 s->crtc_state.crtc = crtc; 1085 s->crtc_state.crtc_id = get_crtc_id(np_to_ofnode(ep_node)); 1086 s->node = node; 1087 1088 if (connector_panel_init(s)) { 1089 printf("Warn: Failed to init panel drivers\n"); 1090 free(s); 1091 continue; 1092 } 1093 1094 if (connector_phy_init(s)) { 1095 printf("Warn: Failed to init phy drivers\n"); 1096 free(s); 1097 continue; 1098 } 1099 list_add_tail(&s->head, &rockchip_display_list); 1100 1101 } 1102 1103 if (list_empty(&rockchip_display_list)) { 1104 printf("Failed to found available display route\n"); 1105 return -ENODEV; 1106 } 1107 1108 uc_priv->xsize = DRM_ROCKCHIP_FB_WIDTH; 1109 uc_priv->ysize = DRM_ROCKCHIP_FB_HEIGHT; 1110 uc_priv->bpix = VIDEO_BPP32; 1111 1112 #ifdef CONFIG_DRM_ROCKCHIP_VIDEO_FRAMEBUFFER 1113 rockchip_show_fbbase(plat->base); 1114 video_set_flush_dcache(dev, true); 1115 #endif 1116 1117 return 0; 1118 } 1119 1120 void rockchip_display_fixup(void *blob) 1121 { 1122 const struct rockchip_connector_funcs *conn_funcs; 1123 const struct rockchip_crtc_funcs *crtc_funcs; 1124 const struct rockchip_connector *conn; 1125 const struct rockchip_crtc *crtc; 1126 struct display_state *s; 1127 int offset; 1128 const struct device_node *np; 1129 const char *path; 1130 1131 if (!get_display_size()) 1132 return; 1133 1134 if (fdt_node_offset_by_compatible(blob, 0, "rockchip,drm-logo") >= 0) { 1135 list_for_each_entry(s, &rockchip_display_list, head) 1136 load_bmp_logo(&s->logo, s->klogo_name); 1137 offset = fdt_update_reserved_memory(blob, "rockchip,drm-logo", 1138 (u64)memory_start, 1139 (u64)get_display_size()); 1140 if (offset < 0) 1141 printf("failed to reserve drm-loader-logo memory\n"); 1142 } else { 1143 printf("can't found rockchip,drm-logo, use rockchip,fb-logo\n"); 1144 /* Compatible with rkfb display, only need reserve memory */ 1145 offset = fdt_update_reserved_memory(blob, "rockchip,fb-logo", 1146 (u64)memory_start, 1147 MEMORY_POOL_SIZE); 1148 if (offset < 0) 1149 printf("failed to reserve fb-loader-logo memory\n"); 1150 else 1151 list_for_each_entry(s, &rockchip_display_list, head) 1152 load_kernel_bmp_logo(&s->logo, s->klogo_name); 1153 return; 1154 } 1155 1156 list_for_each_entry(s, &rockchip_display_list, head) { 1157 conn = s->conn_state.connector; 1158 if (!conn) 1159 continue; 1160 conn_funcs = conn->funcs; 1161 if (!conn_funcs) { 1162 printf("failed to get exist connector\n"); 1163 continue; 1164 } 1165 1166 crtc = s->crtc_state.crtc; 1167 if (!crtc) 1168 continue; 1169 1170 crtc_funcs = crtc->funcs; 1171 if (!crtc_funcs) { 1172 printf("failed to get exist crtc\n"); 1173 continue; 1174 } 1175 1176 if (crtc_funcs->fixup_dts) 1177 crtc_funcs->fixup_dts(s, blob); 1178 1179 if (conn_funcs->fixup_dts) 1180 conn_funcs->fixup_dts(s, blob); 1181 1182 np = ofnode_to_np(s->node); 1183 path = np->full_name; 1184 fdt_increase_size(blob, 0x400); 1185 #define FDT_SET_U32(name, val) \ 1186 do_fixup_by_path_u32(blob, path, name, val, 1); 1187 1188 offset = s->logo.offset + (u32)(unsigned long)s->logo.mem 1189 - memory_start; 1190 FDT_SET_U32("logo,offset", offset); 1191 FDT_SET_U32("logo,width", s->logo.width); 1192 FDT_SET_U32("logo,height", s->logo.height); 1193 FDT_SET_U32("logo,bpp", s->logo.bpp); 1194 FDT_SET_U32("logo,ymirror", s->logo.ymirror); 1195 FDT_SET_U32("video,hdisplay", s->conn_state.mode.hdisplay); 1196 FDT_SET_U32("video,vdisplay", s->conn_state.mode.vdisplay); 1197 FDT_SET_U32("video,crtc_hsync_end", s->conn_state.mode.crtc_hsync_end); 1198 FDT_SET_U32("video,crtc_vsync_end", s->conn_state.mode.crtc_vsync_end); 1199 FDT_SET_U32("video,vrefresh", 1200 drm_mode_vrefresh(&s->conn_state.mode)); 1201 FDT_SET_U32("video,flags", s->conn_state.mode.flags); 1202 FDT_SET_U32("overscan,left_margin", s->conn_state.overscan.left_margin); 1203 FDT_SET_U32("overscan,right_margin", s->conn_state.overscan.right_margin); 1204 FDT_SET_U32("overscan,top_margin", s->conn_state.overscan.top_margin); 1205 FDT_SET_U32("overscan,bottom_margin", s->conn_state.overscan.bottom_margin); 1206 #undef FDT_SET_U32 1207 } 1208 } 1209 1210 int rockchip_display_bind(struct udevice *dev) 1211 { 1212 struct video_uc_platdata *plat = dev_get_uclass_platdata(dev); 1213 1214 plat->size = DRM_ROCKCHIP_FB_SIZE + MEMORY_POOL_SIZE; 1215 1216 return 0; 1217 } 1218 1219 static const struct udevice_id rockchip_display_ids[] = { 1220 { .compatible = "rockchip,display-subsystem" }, 1221 { } 1222 }; 1223 1224 U_BOOT_DRIVER(rockchip_display) = { 1225 .name = "rockchip_display", 1226 .id = UCLASS_VIDEO, 1227 .of_match = rockchip_display_ids, 1228 .bind = rockchip_display_bind, 1229 .probe = rockchip_display_probe, 1230 }; 1231 1232 static int do_rockchip_logo_show(cmd_tbl_t *cmdtp, int flag, int argc, 1233 char *const argv[]) 1234 { 1235 if (argc != 1) 1236 return CMD_RET_USAGE; 1237 1238 rockchip_show_logo(); 1239 1240 return 0; 1241 } 1242 1243 static int do_rockchip_show_bmp(cmd_tbl_t *cmdtp, int flag, int argc, 1244 char *const argv[]) 1245 { 1246 if (argc != 2) 1247 return CMD_RET_USAGE; 1248 1249 rockchip_show_bmp(argv[1]); 1250 1251 return 0; 1252 } 1253 1254 U_BOOT_CMD( 1255 rockchip_show_logo, 1, 1, do_rockchip_logo_show, 1256 "load and display log from resource partition", 1257 NULL 1258 ); 1259 1260 U_BOOT_CMD( 1261 rockchip_show_bmp, 2, 1, do_rockchip_show_bmp, 1262 "load and display bmp from resource partition", 1263 " <bmp_name>" 1264 ); 1265