1 /* $OpenBSD: rkdrm.c,v 1.13 2022/04/06 18:59:28 naddy Exp $ */ 2 /* $NetBSD: rk_drm.c,v 1.3 2019/12/15 01:00:58 mrg Exp $ */ 3 /*- 4 * Copyright (c) 2019 Jared D. McNeill <jmcneill@invisible.ca> 5 * Copyright (c) 2020 Patrick Wildt <patrick@blueri.se> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 22 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 24 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/param.h> 31 #include <sys/device.h> 32 #include <sys/systm.h> 33 34 #include <machine/bus.h> 35 #include <machine/fdt.h> 36 37 #include <dev/ofw/openfirm.h> 38 #include <dev/ofw/ofw_misc.h> 39 40 #include <drm/drm_atomic_helper.h> 41 #include <drm/drm_drv.h> 42 #include <drm/drm_fb_helper.h> 43 #include <drm/drm_gem.h> 44 45 #include <dev/fdt/rkdrm.h> 46 47 #define RK_DRM_MAX_WIDTH 3840 48 #define RK_DRM_MAX_HEIGHT 2160 49 50 TAILQ_HEAD(, rkdrm_ports) rkdrm_ports = 51 TAILQ_HEAD_INITIALIZER(rkdrm_ports); 52 53 int rkdrm_match(struct device *, void *, void *); 54 void rkdrm_attach(struct device *, struct device *, void *); 55 void rkdrm_attachhook(struct device *); 56 57 #ifdef notyet 58 vmem_t *rkdrm_alloc_cma_pool(struct drm_device *, size_t); 59 #endif 60 61 int rkdrm_load(struct drm_device *, unsigned long); 62 int rkdrm_unload(struct drm_device *); 63 64 struct drm_driver rkdrm_driver = { 65 .driver_features = DRIVER_ATOMIC | DRIVER_MODESET | DRIVER_GEM, 66 67 .dumb_create = drm_gem_cma_dumb_create, 68 .dumb_map_offset = drm_gem_dumb_map_offset, 69 70 .gem_fault = drm_gem_cma_fault, 71 72 .name = DRIVER_NAME, 73 .desc = DRIVER_DESC, 74 .date = DRIVER_DATE, 75 .major = DRIVER_MAJOR, 76 .minor = DRIVER_MINOR, 77 .patchlevel = DRIVER_PATCHLEVEL, 78 }; 79 80 const struct drm_gem_object_funcs rkdrm_gem_object_funcs = { 81 .free = drm_gem_cma_free_object, 82 }; 83 84 const struct cfattach rkdrm_ca = { 85 sizeof (struct rkdrm_softc), rkdrm_match, rkdrm_attach 86 }; 87 88 struct cfdriver rkdrm_cd = { 89 NULL, "rkdrm", DV_DULL 90 }; 91 92 int 93 rkdrm_match(struct device *parent, void *match, void *aux) 94 { 95 struct fdt_attach_args *faa = aux; 96 97 return OF_is_compatible(faa->fa_node, "rockchip,display-subsystem"); 98 } 99 100 void 101 rkdrm_attach(struct device *parent, struct device *self, void *aux) 102 { 103 struct rkdrm_softc *sc = (struct rkdrm_softc *)self; 104 struct fdt_attach_args *faa = aux; 105 106 sc->sc_dmat = faa->fa_dmat; 107 sc->sc_iot = faa->fa_iot; 108 sc->sc_node = faa->fa_node; 109 110 printf("\n"); 111 112 /* 113 * Update our understanding of the console output node if 114 * we're using the framebuffer console. 115 */ 116 if (OF_is_compatible(stdout_node, "simple-framebuffer")) 117 stdout_node = sc->sc_node; 118 119 drm_attach_platform(&rkdrm_driver, faa->fa_iot, faa->fa_dmat, self, 120 &sc->sc_ddev); 121 config_mountroot(self, rkdrm_attachhook); 122 } 123 124 int 125 rkdrm_fb_create_handle(struct drm_framebuffer *fb, 126 struct drm_file *file, unsigned int *handle) 127 { 128 struct rkdrm_framebuffer *sfb = to_rkdrm_framebuffer(fb); 129 130 return drm_gem_handle_create(file, &sfb->obj->base, handle); 131 } 132 133 void 134 rkdrm_fb_destroy(struct drm_framebuffer *fb) 135 { 136 struct rkdrm_framebuffer *sfb = to_rkdrm_framebuffer(fb); 137 138 drm_framebuffer_cleanup(fb); 139 drm_gem_object_put(&sfb->obj->base); 140 free(sfb, M_DRM, sizeof(*sfb)); 141 } 142 143 struct drm_framebuffer_funcs rkdrm_framebuffer_funcs = { 144 .create_handle = rkdrm_fb_create_handle, 145 .destroy = rkdrm_fb_destroy, 146 }; 147 148 struct drm_framebuffer * 149 rkdrm_fb_create(struct drm_device *ddev, struct drm_file *file, 150 const struct drm_mode_fb_cmd2 *cmd) 151 { 152 struct rkdrm_framebuffer *fb; 153 struct drm_gem_object *gem_obj; 154 int error; 155 156 if (cmd->flags) 157 return NULL; 158 159 gem_obj = drm_gem_object_lookup(file, cmd->handles[0]); 160 if (gem_obj == NULL) 161 return NULL; 162 163 fb = malloc(sizeof(*fb), M_DRM, M_ZERO | M_WAITOK); 164 drm_helper_mode_fill_fb_struct(ddev, &fb->base, cmd); 165 fb->base.format = drm_format_info(DRM_FORMAT_ARGB8888); 166 fb->base.obj[0] = gem_obj; 167 fb->obj = to_drm_gem_cma_obj(gem_obj); 168 169 error = drm_framebuffer_init(ddev, &fb->base, &rkdrm_framebuffer_funcs); 170 if (error != 0) 171 goto dealloc; 172 173 return &fb->base; 174 175 dealloc: 176 drm_framebuffer_cleanup(&fb->base); 177 free(fb, M_DRM, sizeof(*fb)); 178 drm_gem_object_put(gem_obj); 179 180 return NULL; 181 } 182 183 struct drm_mode_config_helper_funcs rkdrm_mode_config_helper_funcs = 184 { 185 .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm, 186 }; 187 188 struct drm_mode_config_funcs rkdrm_mode_config_funcs = { 189 .fb_create = rkdrm_fb_create, 190 .atomic_check = drm_atomic_helper_check, 191 .atomic_commit = drm_atomic_helper_commit, 192 }; 193 194 int rkdrm_fb_probe(struct drm_fb_helper *, struct drm_fb_helper_surface_size *); 195 196 struct drm_fb_helper_funcs rkdrm_fb_helper_funcs = { 197 .fb_probe = rkdrm_fb_probe, 198 }; 199 200 int 201 rkdrm_unload(struct drm_device *ddev) 202 { 203 drm_mode_config_cleanup(ddev); 204 205 return 0; 206 } 207 208 void rkdrm_burner(void *, u_int, u_int); 209 int rkdrm_wsioctl(void *, u_long, caddr_t, int, struct proc *); 210 paddr_t rkdrm_wsmmap(void *, off_t, int); 211 int rkdrm_alloc_screen(void *, const struct wsscreen_descr *, 212 void **, int *, int *, uint32_t *); 213 void rkdrm_free_screen(void *, void *); 214 int rkdrm_show_screen(void *, void *, int, 215 void (*)(void *, int, int), void *); 216 void rkdrm_doswitch(void *); 217 void rkdrm_enter_ddb(void *, void *); 218 int rkdrm_get_param(struct wsdisplay_param *); 219 int rkdrm_set_param(struct wsdisplay_param *); 220 221 struct wsscreen_descr rkdrm_stdscreen = { 222 "std", 223 0, 0, 224 0, 225 0, 0, 226 WSSCREEN_UNDERLINE | WSSCREEN_HILIT | 227 WSSCREEN_REVERSE | WSSCREEN_WSCOLORS 228 }; 229 230 const struct wsscreen_descr *rkdrm_scrlist[] = { 231 &rkdrm_stdscreen, 232 }; 233 234 struct wsscreen_list rkdrm_screenlist = { 235 nitems(rkdrm_scrlist), rkdrm_scrlist 236 }; 237 238 struct wsdisplay_accessops rkdrm_accessops = { 239 .ioctl = rkdrm_wsioctl, 240 .mmap = rkdrm_wsmmap, 241 .alloc_screen = rkdrm_alloc_screen, 242 .free_screen = rkdrm_free_screen, 243 .show_screen = rkdrm_show_screen, 244 .enter_ddb = rkdrm_enter_ddb, 245 .getchar = rasops_getchar, 246 .load_font = rasops_load_font, 247 .list_font = rasops_list_font, 248 .scrollback = rasops_scrollback, 249 #ifdef notyet 250 .burn_screen = rkdrm_burner 251 #endif 252 }; 253 254 int 255 rkdrm_wsioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) 256 { 257 struct rasops_info *ri = v; 258 struct rkdrm_softc *sc = ri->ri_hw; 259 struct wsdisplay_param *dp = (struct wsdisplay_param *)data; 260 struct wsdisplay_fbinfo *wdf; 261 262 switch (cmd) { 263 case WSDISPLAYIO_GETPARAM: 264 if (ws_get_param) 265 return ws_get_param(dp); 266 return -1; 267 case WSDISPLAYIO_SETPARAM: 268 if (ws_set_param) 269 return ws_set_param(dp); 270 return -1; 271 case WSDISPLAYIO_GTYPE: 272 *(u_int *)data = WSDISPLAY_TYPE_RKDRM; 273 return 0; 274 case WSDISPLAYIO_GINFO: 275 wdf = (struct wsdisplay_fbinfo *)data; 276 wdf->width = ri->ri_width; 277 wdf->height = ri->ri_height; 278 wdf->depth = ri->ri_depth; 279 wdf->cmsize = 0; 280 return 0; 281 case WSDISPLAYIO_LINEBYTES: 282 *(u_int *)data = ri->ri_stride; 283 return 0; 284 } 285 286 return (-1); 287 } 288 289 paddr_t 290 rkdrm_wsmmap(void *v, off_t off, int prot) 291 { 292 struct rasops_info *ri = v; 293 struct rkdrm_softc *sc = ri->ri_hw; 294 struct drm_fb_helper *helper = &sc->helper; 295 struct rkdrm_framebuffer *sfb = to_rkdrm_framebuffer(helper->fb); 296 uint64_t paddr = (uint64_t)sfb->obj->dmamap->dm_segs[0].ds_addr; 297 size_t size = sfb->obj->dmamap->dm_segs[0].ds_len; 298 299 if (off < 0 || off >= size) 300 return -1; 301 302 return ((paddr + off) | PMAP_NOCACHE); 303 } 304 305 int 306 rkdrm_alloc_screen(void *v, const struct wsscreen_descr *type, 307 void **cookiep, int *curxp, int *curyp, uint32_t *attrp) 308 { 309 return rasops_alloc_screen(v, cookiep, curxp, curyp, attrp); 310 } 311 312 void 313 rkdrm_free_screen(void *v, void *cookie) 314 { 315 return rasops_free_screen(v, cookie); 316 } 317 318 int 319 rkdrm_show_screen(void *v, void *cookie, int waitok, 320 void (*cb)(void *, int, int), void *cbarg) 321 { 322 struct rasops_info *ri = v; 323 struct rkdrm_softc *sc = ri->ri_hw; 324 325 if (cookie == ri->ri_active) 326 return (0); 327 328 sc->switchcb = cb; 329 sc->switchcbarg = cbarg; 330 sc->switchcookie = cookie; 331 if (cb) { 332 task_add(systq, &sc->switchtask); 333 return (EAGAIN); 334 } 335 336 rkdrm_doswitch(v); 337 338 return (0); 339 } 340 341 void 342 rkdrm_doswitch(void *v) 343 { 344 struct rasops_info *ri = v; 345 struct rkdrm_softc *sc = ri->ri_hw; 346 struct rkdrm_crtc *rkdrm_crtc; 347 int i, crtc; 348 349 rasops_show_screen(ri, sc->switchcookie, 0, NULL, NULL); 350 drm_fb_helper_restore_fbdev_mode_unlocked(&sc->helper); 351 352 if (sc->switchcb) 353 (sc->switchcb)(sc->switchcbarg, 0, 0); 354 } 355 356 void 357 rkdrm_enter_ddb(void *v, void *cookie) 358 { 359 struct rasops_info *ri = v; 360 struct rkdrm_softc *sc = ri->ri_hw; 361 struct drm_fb_helper *fb_helper = &sc->helper; 362 363 if (cookie == ri->ri_active) 364 return; 365 366 rasops_show_screen(ri, cookie, 0, NULL, NULL); 367 drm_fb_helper_debug_enter(fb_helper->fbdev); 368 } 369 370 void 371 rkdrm_attachhook(struct device *dev) 372 { 373 struct rkdrm_softc *sc = (struct rkdrm_softc *)dev; 374 struct wsemuldisplaydev_attach_args aa; 375 struct drm_fb_helper *helper = &sc->helper; 376 struct rasops_info *ri = &sc->ro; 377 struct rkdrm_framebuffer *sfb; 378 struct drm_device *ddev; 379 uint32_t *ports; 380 int i, portslen, nports; 381 int console = 0; 382 uint32_t defattr; 383 int error; 384 385 if (sc->sc_node == stdout_node) 386 console = 1; 387 388 portslen = OF_getproplen(sc->sc_node, "ports"); 389 if (portslen < 0) { 390 printf("%s: no display interface ports specified\n", 391 sc->sc_dev.dv_xname); 392 return; 393 } 394 395 drm_mode_config_init(&sc->sc_ddev); 396 sc->sc_ddev.mode_config.min_width = 0; 397 sc->sc_ddev.mode_config.min_height = 0; 398 sc->sc_ddev.mode_config.max_width = RK_DRM_MAX_WIDTH; 399 sc->sc_ddev.mode_config.max_height = RK_DRM_MAX_HEIGHT; 400 sc->sc_ddev.mode_config.funcs = &rkdrm_mode_config_funcs; 401 sc->sc_ddev.mode_config.helper_private = 402 &rkdrm_mode_config_helper_funcs; 403 404 nports = 0; 405 ports = malloc(portslen, M_TEMP, M_WAITOK); 406 OF_getpropintarray(sc->sc_node, "ports", ports, portslen); 407 for (i = 0; i < portslen / sizeof(uint32_t); i++) { 408 error = device_port_activate(ports[i], &sc->sc_ddev); 409 if (error == 0) 410 nports++; 411 } 412 free(ports, M_TEMP, portslen); 413 414 if (nports == 0) { 415 printf("%s: no display interface ports configured\n", 416 sc->sc_dev.dv_xname); 417 drm_mode_config_cleanup(&sc->sc_ddev); 418 return; 419 } 420 421 drm_mode_config_reset(&sc->sc_ddev); 422 423 drm_fb_helper_prepare(&sc->sc_ddev, &sc->helper, &rkdrm_fb_helper_funcs); 424 if (drm_fb_helper_init(&sc->sc_ddev, &sc->helper)) { 425 printf("%s: can't initialize framebuffer helper\n", 426 sc->sc_dev.dv_xname); 427 drm_mode_config_cleanup(&sc->sc_ddev); 428 return; 429 } 430 431 sc->helper.fb = malloc(sizeof(struct rkdrm_framebuffer), 432 M_DRM, M_WAITOK | M_ZERO); 433 434 drm_fb_helper_initial_config(&sc->helper, 32); 435 436 task_set(&sc->switchtask, rkdrm_doswitch, ri); 437 438 drm_fb_helper_restore_fbdev_mode_unlocked(&sc->helper); 439 440 sfb = to_rkdrm_framebuffer(helper->fb); 441 ri->ri_bits = sfb->obj->vaddr; 442 ri->ri_flg = RI_CENTER | RI_VCONS; 443 ri->ri_depth = helper->fb->format->depth; 444 ri->ri_width = helper->fb->width; 445 ri->ri_height = helper->fb->height; 446 ri->ri_stride = ri->ri_width * ri->ri_depth / 8; 447 ri->ri_rnum = 8; /* ARGB8888 */ 448 ri->ri_rpos = 16; 449 ri->ri_gnum = 8; 450 ri->ri_gpos = 8; 451 ri->ri_bnum = 8; 452 ri->ri_bpos = 0; 453 rasops_init(ri, 160, 160); 454 ri->ri_hw = sc; 455 456 rkdrm_stdscreen.capabilities = ri->ri_caps; 457 rkdrm_stdscreen.nrows = ri->ri_rows; 458 rkdrm_stdscreen.ncols = ri->ri_cols; 459 rkdrm_stdscreen.textops = &ri->ri_ops; 460 rkdrm_stdscreen.fontwidth = ri->ri_font->fontwidth; 461 rkdrm_stdscreen.fontheight = ri->ri_font->fontheight; 462 463 if (console) { 464 ri->ri_ops.pack_attr(ri->ri_active, 0, 0, 0, &defattr); 465 wsdisplay_cnattach(&rkdrm_stdscreen, ri->ri_active, 466 ri->ri_ccol, ri->ri_crow, defattr); 467 } 468 469 memset(&aa, 0, sizeof(aa)); 470 aa.scrdata = &rkdrm_screenlist; 471 aa.accessops = &rkdrm_accessops; 472 aa.accesscookie = ri; 473 aa.console = console; 474 475 printf("%s: %dx%d, %dbpp\n", sc->sc_dev.dv_xname, 476 ri->ri_width, ri->ri_height, ri->ri_depth); 477 478 config_found_sm(&sc->sc_dev, &aa, wsemuldisplaydevprint, 479 wsemuldisplaydevsubmatch); 480 481 drm_dev_register(&sc->sc_ddev, 0); 482 } 483 484 int 485 rkdrm_fb_probe(struct drm_fb_helper *helper, struct drm_fb_helper_surface_size *sizes) 486 { 487 struct rkdrm_softc *sc = rkdrm_private(helper->dev); 488 struct drm_device *ddev = helper->dev; 489 struct rkdrm_framebuffer *sfb = to_rkdrm_framebuffer(helper->fb); 490 struct drm_mode_fb_cmd2 mode_cmd = { 0 }; 491 struct drm_framebuffer *fb = helper->fb; 492 struct wsemuldisplaydev_attach_args aa; 493 struct rasops_info *ri = &sc->ro; 494 struct rkdrmfb_attach_args sfa; 495 unsigned int bytes_per_pixel; 496 struct fb_info *info; 497 size_t size; 498 int error; 499 500 bytes_per_pixel = DIV_ROUND_UP(sizes->surface_bpp, 8); 501 502 mode_cmd.width = sizes->surface_width; 503 mode_cmd.height = sizes->surface_height; 504 mode_cmd.pitches[0] = sizes->surface_width * bytes_per_pixel; 505 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp, 506 sizes->surface_depth); 507 508 size = roundup(mode_cmd.pitches[0] * mode_cmd.height, PAGE_SIZE); 509 510 /* FIXME: CMA pool? */ 511 512 sfb->obj = drm_gem_cma_create(ddev, size); 513 if (sfb->obj == NULL) { 514 DRM_ERROR("failed to allocate memory for framebuffer\n"); 515 return -ENOMEM; 516 } 517 518 drm_helper_mode_fill_fb_struct(ddev, fb, &mode_cmd); 519 fb->format = drm_format_info(DRM_FORMAT_ARGB8888); 520 fb->obj[0] = &sfb->obj->base; 521 error = drm_framebuffer_init(ddev, fb, &rkdrm_framebuffer_funcs); 522 if (error != 0) { 523 DRM_ERROR("failed to initialize framebuffer\n"); 524 return error; 525 } 526 527 info = drm_fb_helper_alloc_fbi(helper); 528 if (IS_ERR(info)) { 529 DRM_ERROR("Failed to allocate fb_info\n"); 530 return error; 531 } 532 info->par = helper; 533 return 0; 534 } 535