1/*- 2 * Copyright (c) 2015 Michal Meloun 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD: stable/11/sys/arm/nvidia/drm2/tegra_host1x.c 310600 2016-12-26 14:36:05Z mmel $"); 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/bus.h> 33#include <sys/clock.h> 34#include <sys/kernel.h> 35#include <sys/limits.h> 36#include <sys/lock.h> 37 38#include <sys/module.h> 39#include <sys/resource.h> 40#include <sys/sx.h> 41#include <sys/rman.h> 42 43#include <machine/bus.h> 44#include <machine/resource.h> 45 46#include <dev/extres/clk/clk.h> 47#include <dev/extres/hwreset/hwreset.h> 48#include <dev/drm2/drmP.h> 49#include <dev/drm2/drm_crtc_helper.h> 50#include <dev/drm2/drm_fb_helper.h> 51#include <dev/fdt/simplebus.h> 52#include <dev/ofw/ofw_bus.h> 53#include <dev/ofw/ofw_bus_subr.h> 54 55#include <arm/nvidia/drm2/tegra_drm.h> 56 57#include "fb_if.h" 58#include "tegra_drm_if.h" 59 60#define WR4(_sc, _r, _v) bus_rite_4((_sc)->mem_res, (_r), (_v)) 61#define RD4(_sc, _r) bus_read_4((_sc)->mem_res, (_r)) 62 63#define LOCK(_sc) sx_xlock(&(_sc)->lock) 64#define UNLOCK(_sc) sx_xunlock(&(_sc)->lock) 65#define SLEEP(_sc, timeout) sx_sleep(sc, &sc->lock, 0, "host1x", timeout); 66#define LOCK_INIT(_sc) sx_init(&_sc->lock, "host1x") 67#define LOCK_DESTROY(_sc) sx_destroy(&_sc->lock) 68#define ASSERT_LOCKED(_sc) sx_assert(&_sc->lock, SA_LOCKED) 69#define ASSERT_UNLOCKED(_sc) sx_assert(&_sc->lock, SA_UNLOCKED) 70 71static struct ofw_compat_data compat_data[] = { 72 {"nvidia,tegra124-host1x", 1}, 73 {NULL, 0} 74}; 75 76#define DRIVER_NAME "tegra" 77#define DRIVER_DESC "NVIDIA Tegra TK1" 78#define DRIVER_DATE "20151101" 79#define DRIVER_MAJOR 0 80#define DRIVER_MINOR 0 81#define DRIVER_PATCHLEVEL 0 82 83struct client_info; 84TAILQ_HEAD(client_list, client_info); 85typedef struct client_list client_list_t; 86 87struct client_info { 88 TAILQ_ENTRY(client_info) list_e; 89 device_t client; 90 int activated; 91}; 92 93struct host1x_softc { 94 struct simplebus_softc simplebus_sc; /* must be first */ 95 device_t dev; 96 struct sx lock; 97 int attach_done; 98 99 struct resource *mem_res; 100 struct resource *syncpt_irq_res; 101 void *syncpt_irq_h; 102 struct resource *gen_irq_res; 103 void *gen_irq_h; 104 105 clk_t clk; 106 hwreset_t reset; 107 struct intr_config_hook irq_hook; 108 109 int drm_inited; 110 client_list_t clients; 111 112 struct tegra_drm *tegra_drm; 113}; 114 115 116static void 117host1x_output_poll_changed(struct drm_device *drm_dev) 118{ 119 struct tegra_drm *drm; 120 121 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 122 if (drm->fb != NULL) 123 drm_fb_helper_hotplug_event(&drm->fb->fb_helper); 124} 125 126static const struct drm_mode_config_funcs mode_config_funcs = { 127 .fb_create = tegra_drm_fb_create, 128 .output_poll_changed = host1x_output_poll_changed, 129}; 130 131 132static int 133host1x_drm_init(struct host1x_softc *sc) 134{ 135 struct client_info *entry; 136 int rv; 137 138 LOCK(sc); 139 140 TAILQ_FOREACH(entry, &sc->clients, list_e) { 141 if (entry->activated) 142 continue; 143 rv = TEGRA_DRM_INIT_CLIENT(entry->client, sc->dev, 144 sc->tegra_drm); 145 if (rv != 0) { 146 device_printf(sc->dev, 147 "Cannot init DRM client %s: %d\n", 148 device_get_name(entry->client), rv); 149 return (rv); 150 } 151 entry->activated = 1; 152 } 153 UNLOCK(sc); 154 155 return (0); 156} 157 158static int 159host1x_drm_exit(struct host1x_softc *sc) 160{ 161 struct client_info *entry; 162 int rv; 163#ifdef FREEBSD_NOTYET 164 struct drm_device *dev, *tmp; 165#endif 166 LOCK(sc); 167 if (!sc->drm_inited) { 168 UNLOCK(sc); 169 return (0); 170 } 171 TAILQ_FOREACH_REVERSE(entry, &sc->clients, client_list, list_e) { 172 if (!entry->activated) 173 continue; 174 rv = TEGRA_DRM_EXIT_CLIENT(entry->client, sc->dev, 175 sc->tegra_drm); 176 if (rv != 0) { 177 device_printf(sc->dev, 178 "Cannot exit DRM client %s: %d\n", 179 device_get_name(entry->client), rv); 180 } 181 entry->activated = 0; 182 } 183 184#ifdef FREEBSD_NOTYET 185 list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item) 186 drm_put_dev(dev); 187#endif 188 sc->drm_inited = 0; 189 UNLOCK(sc); 190 191 return (0); 192} 193 194static int 195host1x_drm_load(struct drm_device *drm_dev, unsigned long flags) 196{ 197 struct host1x_softc *sc; 198 int rv; 199 200 sc = device_get_softc(drm_dev->dev); 201 202 drm_mode_config_init(drm_dev); 203 drm_dev->mode_config.min_width = 32; 204 drm_dev->mode_config.min_height = 32; 205 drm_dev->mode_config.max_width = 4096; 206 drm_dev->mode_config.max_height = 4096; 207 drm_dev->mode_config.funcs = &mode_config_funcs; 208 209 rv = host1x_drm_init(sc); 210 if (rv != 0) 211 goto fail_host1x; 212 213 drm_dev->irq_enabled = true; 214 drm_dev->max_vblank_count = 0xffffffff; 215 drm_dev->vblank_disable_allowed = true; 216 217 rv = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc); 218 if (rv != 0) 219 goto fail_vblank; 220 221 drm_mode_config_reset(drm_dev); 222 223 rv = tegra_drm_fb_init(drm_dev); 224 if (rv != 0) 225 goto fail_fb; 226 drm_kms_helper_poll_init(drm_dev); 227 228 return (0); 229 230fail_fb: 231 tegra_drm_fb_destroy(drm_dev); 232 drm_vblank_cleanup(drm_dev); 233fail_vblank: 234 host1x_drm_exit(sc); 235fail_host1x: 236 drm_mode_config_cleanup(drm_dev); 237 238 return (rv); 239} 240 241static int 242host1x_drm_unload(struct drm_device *drm_dev) 243{ 244 struct host1x_softc *sc; 245 int rv; 246 247 sc = device_get_softc(drm_dev->dev); 248 249 drm_kms_helper_poll_fini(drm_dev); 250 tegra_drm_fb_destroy(drm_dev); 251 drm_mode_config_cleanup(drm_dev); 252 253 rv = host1x_drm_exit(sc); 254 if (rv < 0) 255 return (rv); 256 return (0); 257} 258 259static int 260host1x_drm_open(struct drm_device *drm_dev, struct drm_file *filp) 261{ 262 263 return (0); 264} 265 266static void 267tegra_drm_preclose(struct drm_device *drm, struct drm_file *file) 268{ 269 struct drm_crtc *crtc; 270 271 list_for_each_entry(crtc, &drm->mode_config.crtc_list, head) 272 tegra_dc_cancel_page_flip(crtc, file); 273} 274 275static void 276host1x_drm_lastclose(struct drm_device *drm_dev) 277{ 278 279 struct tegra_drm *drm; 280 281 drm = container_of(drm_dev, struct tegra_drm, drm_dev); 282 if (drm->fb != NULL) 283 drm_fb_helper_restore_fbdev_mode(&drm->fb->fb_helper); 284} 285 286static int 287host1x_drm_enable_vblank(struct drm_device *drm_dev, int pipe) 288{ 289 struct drm_crtc *crtc; 290 291 list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) { 292 if (pipe == tegra_dc_get_pipe(crtc)) { 293 tegra_dc_enable_vblank(crtc); 294 return (0); 295 } 296 } 297 return (-ENODEV); 298} 299 300static void 301host1x_drm_disable_vblank(struct drm_device *drm_dev, int pipe) 302{ 303 struct drm_crtc *crtc; 304 305 list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) { 306 if (pipe == tegra_dc_get_pipe(crtc)) { 307 tegra_dc_disable_vblank(crtc); 308 return; 309 } 310 } 311} 312 313 314static struct drm_ioctl_desc host1x_drm_ioctls[] = { 315}; 316 317 318struct drm_driver tegra_drm_driver = { 319 .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME, 320 .load = host1x_drm_load, 321 .unload = host1x_drm_unload, 322 .open = host1x_drm_open, 323 .preclose = tegra_drm_preclose, 324 .lastclose = host1x_drm_lastclose, 325 326 .get_vblank_counter = drm_vblank_count, 327 .enable_vblank = host1x_drm_enable_vblank, 328 .disable_vblank = host1x_drm_disable_vblank, 329 330 /* Fields filled by tegra_bo_driver_register() 331 .gem_free_object 332 .gem_pager_ops 333 .dumb_create 334 .dumb_map_offset 335 .dumb_destroy 336 */ 337 .ioctls = host1x_drm_ioctls, 338 .num_ioctls = nitems(host1x_drm_ioctls), 339 340 .name = DRIVER_NAME, 341 .desc = DRIVER_DESC, 342 .date = DRIVER_DATE, 343 .major = DRIVER_MAJOR, 344 .minor = DRIVER_MINOR, 345 .patchlevel = DRIVER_PATCHLEVEL, 346}; 347 348/* 349 * ----------------- Device methods ------------------------- 350 */ 351static void 352host1x_irq_hook(void *arg) 353{ 354 struct host1x_softc *sc; 355 int rv; 356 357 sc = arg; 358 config_intrhook_disestablish(&sc->irq_hook); 359 360 tegra_bo_driver_register(&tegra_drm_driver); 361 rv = drm_get_platform_dev(sc->dev, &sc->tegra_drm->drm_dev, 362 &tegra_drm_driver); 363 if (rv != 0) { 364 device_printf(sc->dev, "drm_get_platform_dev(): %d\n", rv); 365 return; 366 } 367 368 sc->drm_inited = 1; 369} 370 371static struct fb_info * 372host1x_fb_helper_getinfo(device_t dev) 373{ 374 struct host1x_softc *sc; 375 376 sc = device_get_softc(dev); 377 if (sc->tegra_drm == NULL) 378 return (NULL); 379 return (tegra_drm_fb_getinfo(&sc->tegra_drm->drm_dev)); 380} 381 382static int 383host1x_register_client(device_t dev, device_t client) 384{ 385 struct host1x_softc *sc; 386 struct client_info *entry; 387 388 sc = device_get_softc(dev); 389 390 entry = malloc(sizeof(struct client_info), M_DEVBUF, M_WAITOK | M_ZERO); 391 entry->client = client; 392 entry->activated = 0; 393 394 LOCK(sc); 395 TAILQ_INSERT_TAIL(&sc->clients, entry, list_e); 396 UNLOCK(sc); 397 398 return (0); 399} 400 401static int 402host1x_deregister_client(device_t dev, device_t client) 403{ 404 struct host1x_softc *sc; 405 struct client_info *entry; 406 407 sc = device_get_softc(dev); 408 409 LOCK(sc); 410 TAILQ_FOREACH(entry, &sc->clients, list_e) { 411 if (entry->client == client) { 412 if (entry->activated) 413 panic("Tegra DRM: Attempt to deregister " 414 "activated client"); 415 TAILQ_REMOVE(&sc->clients, entry, list_e); 416 free(entry, M_DEVBUF); 417 UNLOCK(sc); 418 return (0); 419 } 420 } 421 UNLOCK(sc); 422 423 return (0); 424} 425 426static void 427host1x_gen_intr(void *arg) 428{ 429 struct host1x_softc *sc; 430 431 sc = (struct host1x_softc *)arg; 432 LOCK(sc); 433 UNLOCK(sc); 434} 435 436static void 437host1x_syncpt_intr(void *arg) 438{ 439 struct host1x_softc *sc; 440 441 sc = (struct host1x_softc *)arg; 442 LOCK(sc); 443 UNLOCK(sc); 444} 445 446static void 447host1x_new_pass(device_t dev) 448{ 449 struct host1x_softc *sc; 450 int rv, rid; 451 phandle_t node; 452 453 /* 454 * We attach during BUS_PASS_BUS (because we must overcome simplebus), 455 * but some of our FDT resources are not ready until BUS_PASS_DEFAULT 456 */ 457 sc = device_get_softc(dev); 458 if (sc->attach_done || bus_current_pass < BUS_PASS_DEFAULT) { 459 bus_generic_new_pass(dev); 460 return; 461 } 462 463 sc->attach_done = 1; 464 node = ofw_bus_get_node(dev); 465 466 /* Allocate our IRQ resource. */ 467 rid = 0; 468 sc->syncpt_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 469 RF_ACTIVE); 470 if (sc->syncpt_irq_res == NULL) { 471 device_printf(dev, "Cannot allocate interrupt.\n"); 472 rv = ENXIO; 473 goto fail; 474 } 475 rid = 1; 476 sc->gen_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 477 RF_ACTIVE); 478 if (sc->gen_irq_res == NULL) { 479 device_printf(dev, "Cannot allocate interrupt.\n"); 480 rv = ENXIO; 481 goto fail; 482 } 483 484 /* FDT resources */ 485 rv = hwreset_get_by_ofw_name(sc->dev, 0, "host1x", &sc->reset); 486 if (rv != 0) { 487 device_printf(dev, "Cannot get fuse reset\n"); 488 goto fail; 489 } 490 rv = clk_get_by_ofw_index(sc->dev, 0, 0, &sc->clk); 491 if (rv != 0) { 492 device_printf(dev, "Cannot get i2c clock: %d\n", rv); 493 goto fail; 494 } 495 496 rv = clk_enable(sc->clk); 497 if (rv != 0) { 498 device_printf(dev, "Cannot enable clock: %d\n", rv); 499 goto fail; 500 } 501 rv = hwreset_deassert(sc->reset); 502 if (rv != 0) { 503 device_printf(sc->dev, "Cannot clear reset\n"); 504 goto fail; 505 } 506 507 /* Setup interrupts */ 508 rv = bus_setup_intr(dev, sc->gen_irq_res, 509 INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_gen_intr, 510 sc, &sc->gen_irq_h); 511 if (rv) { 512 device_printf(dev, "Cannot setup gen interrupt.\n"); 513 goto fail; 514 } 515 516 rv = bus_setup_intr(dev, sc->syncpt_irq_res, 517 INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_syncpt_intr, 518 sc, &sc->syncpt_irq_h); 519 if (rv) { 520 device_printf(dev, "Cannot setup syncpt interrupt.\n"); 521 goto fail; 522 } 523 524 simplebus_init(dev, 0); 525 for (node = OF_child(node); node > 0; node = OF_peer(node)) 526 simplebus_add_device(dev, node, 0, NULL, -1, NULL); 527 528 sc->irq_hook.ich_func = host1x_irq_hook; 529 sc->irq_hook.ich_arg = sc; 530 config_intrhook_establish(&sc->irq_hook); 531 bus_generic_new_pass(dev); 532 return; 533 534fail: 535 device_detach(dev); 536 return; 537} 538 539static int 540host1x_probe(device_t dev) 541{ 542 543 if (!ofw_bus_status_okay(dev)) 544 return (ENXIO); 545 546 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 547 return (ENXIO); 548 549 return (BUS_PROBE_DEFAULT); 550} 551 552static int 553host1x_attach(device_t dev) 554{ 555 int rv, rid; 556 struct host1x_softc *sc; 557 558 sc = device_get_softc(dev); 559 sc->tegra_drm = malloc(sizeof(struct tegra_drm), DRM_MEM_DRIVER, 560 M_WAITOK | M_ZERO); 561 562 /* crosslink together all worlds */ 563 sc->dev = dev; 564 sc->tegra_drm->drm_dev.dev_private = &sc->tegra_drm; 565 sc->tegra_drm->drm_dev.dev = dev; 566 567 TAILQ_INIT(&sc->clients); 568 569 LOCK_INIT(sc); 570 571 /* Get the memory resource for the register mapping. */ 572 rid = 0; 573 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 574 RF_ACTIVE); 575 if (sc->mem_res == NULL) { 576 device_printf(dev, "Cannot map registers.\n"); 577 rv = ENXIO; 578 goto fail; 579 } 580 581 return (bus_generic_attach(dev)); 582 583fail: 584 if (sc->tegra_drm != NULL) 585 free(sc->tegra_drm, DRM_MEM_DRIVER); 586 if (sc->mem_res != NULL) 587 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res); 588 LOCK_DESTROY(sc); 589 return (rv); 590} 591 592static int 593host1x_detach(device_t dev) 594{ 595 struct host1x_softc *sc; 596 597 sc = device_get_softc(dev); 598 599 host1x_drm_exit(sc); 600 601 if (sc->gen_irq_h != NULL) 602 bus_teardown_intr(dev, sc->gen_irq_res, sc->gen_irq_h); 603 if (sc->tegra_drm != NULL) 604 free(sc->tegra_drm, DRM_MEM_DRIVER); 605 if (sc->clk != NULL) 606 clk_release(sc->clk); 607 if (sc->reset != NULL) 608 hwreset_release(sc->reset); 609 if (sc->syncpt_irq_h != NULL) 610 bus_teardown_intr(dev, sc->syncpt_irq_res, sc->syncpt_irq_h); 611 if (sc->gen_irq_res != NULL) 612 bus_release_resource(dev, SYS_RES_IRQ, 1, sc->gen_irq_res); 613 if (sc->syncpt_irq_res != NULL) 614 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->syncpt_irq_res); 615 if (sc->mem_res != NULL) 616 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res); 617 LOCK_DESTROY(sc); 618 return (bus_generic_detach(dev)); 619} 620 621static device_method_t host1x_methods[] = { 622 /* Device interface */ 623 DEVMETHOD(device_probe, host1x_probe), 624 DEVMETHOD(device_attach, host1x_attach), 625 DEVMETHOD(device_detach, host1x_detach), 626 627 /* Bus interface */ 628 DEVMETHOD(bus_new_pass, host1x_new_pass), 629 630 /* Framebuffer service methods */ 631 DEVMETHOD(fb_getinfo, host1x_fb_helper_getinfo), 632 633 /* tegra drm interface */ 634 DEVMETHOD(tegra_drm_register_client, host1x_register_client), 635 DEVMETHOD(tegra_drm_deregister_client, host1x_deregister_client), 636 637 DEVMETHOD_END 638}; 639 640static devclass_t host1x_devclass; 641DEFINE_CLASS_1(host1x, host1x_driver, host1x_methods, 642 sizeof(struct host1x_softc), simplebus_driver); 643EARLY_DRIVER_MODULE(host1x, simplebus, host1x_driver, 644 host1x_devclass, 0, 0, BUS_PASS_BUS); 645 646/* Bindings for fbd device. */ 647extern devclass_t fbd_devclass; 648extern driver_t fbd_driver; 649DRIVER_MODULE(fbd, host1x, fbd_driver, fbd_devclass, 0, 0); 650 651