sys/arm/nvidia/drm2/tegra_host1x.c

   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$");
  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
  71 static 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
  83 struct client_info;
  84 TAILQ_HEAD(client_list, client_info);
  85 typedef struct client_list client_list_t;
  86
  87 struct client_info {
  88         TAILQ_ENTRY(client_info) list_e;
  89         device_t client;
  90         int     activated;
  91 };
  92
  93 struct 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 static void
 116 host1x_output_poll_changed(struct drm_device *drm_dev)
 117 {
 118         struct tegra_drm *drm;
 119
 120         drm = container_of(drm_dev, struct tegra_drm, drm_dev);
 121         if (drm->fb != NULL)
 122                 drm_fb_helper_hotplug_event(&drm->fb->fb_helper);
 123 }
 124
 125 static const struct drm_mode_config_funcs mode_config_funcs = {
 126         .fb_create = tegra_drm_fb_create,
 127         .output_poll_changed = host1x_output_poll_changed,
 128 };
 129
 130 static int
 131 host1x_drm_init(struct host1x_softc *sc)
 132 {
 133         struct client_info *entry;
 134         int rv;
 135
 136         LOCK(sc);
 137
 138         TAILQ_FOREACH(entry, &sc->clients, list_e) {
 139                 if (entry->activated)
 140                         continue;
 141                 rv = TEGRA_DRM_INIT_CLIENT(entry->client, sc->dev,
 142                     sc->tegra_drm);
 143                 if (rv != 0) {
 144                         device_printf(sc->dev,
 145                             "Cannot init DRM client %s: %d\n",
 146                             device_get_name(entry->client), rv);
 147                         return (rv);
 148                 }
 149                 entry->activated = 1;
 150         }
 151         UNLOCK(sc);
 152
 153         return (0);
 154 }
 155
 156 static int
 157 host1x_drm_exit(struct host1x_softc *sc)
 158 {
 159         struct client_info *entry;
 160         int rv;
 161 #ifdef FREEBSD_NOTYET
 162         struct drm_device *dev, *tmp;
 163 #endif
 164         LOCK(sc);
 165         if (!sc->drm_inited) {
 166                 UNLOCK(sc);
 167                 return (0);
 168         }
 169         TAILQ_FOREACH_REVERSE(entry, &sc->clients, client_list, list_e) {
 170                 if (!entry->activated)
 171                         continue;
 172                 rv = TEGRA_DRM_EXIT_CLIENT(entry->client, sc->dev,
 173                     sc->tegra_drm);
 174                 if (rv != 0) {
 175                         device_printf(sc->dev,
 176                             "Cannot exit DRM client %s: %d\n",
 177                             device_get_name(entry->client), rv);
 178                 }
 179                 entry->activated = 0;
 180         }
 181
 182 #ifdef FREEBSD_NOTYET
 183         list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item)
 184                 drm_put_dev(dev);
 185 #endif
 186         sc->drm_inited = 0;
 187         UNLOCK(sc);
 188
 189         return (0);
 190 }
 191
 192 static int
 193 host1x_drm_load(struct drm_device *drm_dev, unsigned long flags)
 194 {
 195         struct host1x_softc *sc;
 196         int rv;
 197
 198         sc = device_get_softc(drm_dev->dev);
 199
 200         drm_mode_config_init(drm_dev);
 201         drm_dev->mode_config.min_width = 32;
 202         drm_dev->mode_config.min_height = 32;
 203         drm_dev->mode_config.max_width = 4096;
 204         drm_dev->mode_config.max_height = 4096;
 205         drm_dev->mode_config.funcs = &mode_config_funcs;
 206
 207         rv = host1x_drm_init(sc);
 208         if (rv != 0)
 209                 goto fail_host1x;
 210
 211         drm_dev->irq_enabled = true;
 212         drm_dev->max_vblank_count = 0xffffffff;
 213         drm_dev->vblank_disable_allowed = true;
 214
 215         rv = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc);
 216         if (rv != 0)
 217                 goto fail_vblank;
 218
 219         drm_mode_config_reset(drm_dev);
 220
 221         rv = tegra_drm_fb_init(drm_dev);
 222         if (rv != 0)
 223                 goto fail_fb;
 224         drm_kms_helper_poll_init(drm_dev);
 225
 226         return (0);
 227
 228 fail_fb:
 229         tegra_drm_fb_destroy(drm_dev);
 230         drm_vblank_cleanup(drm_dev);
 231 fail_vblank:
 232         host1x_drm_exit(sc);
 233 fail_host1x:
 234         drm_mode_config_cleanup(drm_dev);
 235
 236         return (rv);
 237 }
 238
 239 static int
 240 host1x_drm_unload(struct drm_device *drm_dev)
 241 {
 242         struct host1x_softc *sc;
 243         int rv;
 244
 245         sc = device_get_softc(drm_dev->dev);
 246
 247         drm_kms_helper_poll_fini(drm_dev);
 248         tegra_drm_fb_destroy(drm_dev);
 249         drm_mode_config_cleanup(drm_dev);
 250
 251         rv = host1x_drm_exit(sc);
 252         if (rv < 0)
 253                 return (rv);
 254         return (0);
 255 }
 256
 257 static int
 258 host1x_drm_open(struct drm_device *drm_dev, struct drm_file *filp)
 259 {
 260
 261         return (0);
 262 }
 263
 264 static void
 265 tegra_drm_preclose(struct drm_device *drm, struct drm_file *file)
 266 {
 267         struct drm_crtc *crtc;
 268
 269         list_for_each_entry(crtc, &drm->mode_config.crtc_list, head)
 270                 tegra_dc_cancel_page_flip(crtc, file);
 271 }
 272
 273 static void
 274 host1x_drm_lastclose(struct drm_device *drm_dev)
 275 {
 276
 277         struct tegra_drm *drm;
 278
 279         drm = container_of(drm_dev, struct tegra_drm, drm_dev);
 280         if (drm->fb  != NULL)
 281                 drm_fb_helper_restore_fbdev_mode(&drm->fb->fb_helper);
 282 }
 283
 284 static int
 285 host1x_drm_enable_vblank(struct drm_device *drm_dev, int pipe)
 286 {
 287         struct drm_crtc *crtc;
 288
 289         list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) {
 290                 if (pipe == tegra_dc_get_pipe(crtc)) {
 291                         tegra_dc_enable_vblank(crtc);
 292                         return (0);
 293                 }
 294         }
 295         return (-ENODEV);
 296 }
 297
 298 static void
 299 host1x_drm_disable_vblank(struct drm_device *drm_dev, int pipe)
 300 {
 301         struct drm_crtc *crtc;
 302
 303         list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) {
 304                 if (pipe == tegra_dc_get_pipe(crtc)) {
 305                         tegra_dc_disable_vblank(crtc);
 306                         return;
 307                 }
 308         }
 309 }
 310
 311 static struct drm_ioctl_desc host1x_drm_ioctls[] = {
 312 };
 313
 314 struct drm_driver tegra_drm_driver = {
 315         .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
 316         .load = host1x_drm_load,
 317         .unload = host1x_drm_unload,
 318         .open = host1x_drm_open,
 319         .preclose = tegra_drm_preclose,
 320         .lastclose = host1x_drm_lastclose,
 321
 322         .get_vblank_counter = drm_vblank_count,
 323         .enable_vblank = host1x_drm_enable_vblank,
 324         .disable_vblank = host1x_drm_disable_vblank,
 325
 326         /* Fields filled by tegra_bo_driver_register()
 327         .gem_free_object
 328         .gem_pager_ops
 329         .dumb_create
 330         .dumb_map_offset
 331         .dumb_destroy
 332         */
 333         .ioctls = host1x_drm_ioctls,
 334         .num_ioctls = nitems(host1x_drm_ioctls),
 335
 336         .name = DRIVER_NAME,
 337         .desc = DRIVER_DESC,
 338         .date = DRIVER_DATE,
 339         .major = DRIVER_MAJOR,
 340         .minor = DRIVER_MINOR,
 341         .patchlevel = DRIVER_PATCHLEVEL,
 342 };
 343
 344 /*
 345  * ----------------- Device methods -------------------------
 346  */
 347 static void
 348 host1x_irq_hook(void *arg)
 349 {
 350         struct host1x_softc *sc;
 351         int rv;
 352
 353         sc = arg;
 354         config_intrhook_disestablish(&sc->irq_hook);
 355
 356         tegra_bo_driver_register(&tegra_drm_driver);
 357         rv = drm_get_platform_dev(sc->dev, &sc->tegra_drm->drm_dev,
 358             &tegra_drm_driver);
 359         if (rv != 0) {
 360                 device_printf(sc->dev, "drm_get_platform_dev(): %d\n", rv);
 361                 return;
 362         }
 363
 364         sc->drm_inited = 1;
 365 }
 366
 367 static struct fb_info *
 368 host1x_fb_helper_getinfo(device_t dev)
 369 {
 370         struct host1x_softc *sc;
 371
 372         sc = device_get_softc(dev);
 373         if (sc->tegra_drm == NULL)
 374                 return (NULL);
 375         return (tegra_drm_fb_getinfo(&sc->tegra_drm->drm_dev));
 376 }
 377
 378 static int
 379 host1x_register_client(device_t dev, device_t client)
 380 {
 381         struct host1x_softc *sc;
 382         struct client_info *entry;
 383
 384         sc = device_get_softc(dev);
 385
 386         entry = malloc(sizeof(struct client_info), M_DEVBUF, M_WAITOK | M_ZERO);
 387         entry->client = client;
 388         entry->activated = 0;
 389
 390         LOCK(sc);
 391         TAILQ_INSERT_TAIL(&sc->clients, entry, list_e);
 392         UNLOCK(sc);
 393
 394         return (0);
 395 }
 396
 397 static int
 398 host1x_deregister_client(device_t dev, device_t client)
 399 {
 400         struct host1x_softc *sc;
 401         struct client_info *entry;
 402
 403         sc = device_get_softc(dev);
 404
 405         LOCK(sc);
 406         TAILQ_FOREACH(entry, &sc->clients, list_e) {
 407                 if (entry->client == client) {
 408                         if (entry->activated)
 409                                 panic("Tegra DRM: Attempt to deregister "
 410                                     "activated client");
 411                         TAILQ_REMOVE(&sc->clients, entry, list_e);
 412                         free(entry, M_DEVBUF);
 413                         UNLOCK(sc);
 414                         return (0);
 415                 }
 416         }
 417         UNLOCK(sc);
 418
 419         return (0);
 420 }
 421
 422 static void
 423 host1x_gen_intr(void *arg)
 424 {
 425         struct host1x_softc *sc;
 426
 427         sc = (struct host1x_softc *)arg;
 428         LOCK(sc);
 429         UNLOCK(sc);
 430 }
 431
 432 static void
 433 host1x_syncpt_intr(void *arg)
 434 {
 435         struct host1x_softc *sc;
 436
 437         sc = (struct host1x_softc *)arg;
 438         LOCK(sc);
 439         UNLOCK(sc);
 440 }
 441
 442 static void
 443 host1x_new_pass(device_t dev)
 444 {
 445         struct host1x_softc *sc;
 446         int rv, rid;
 447         phandle_t node;
 448
 449         /*
 450          * We attach during BUS_PASS_BUS (because we must overcome simplebus),
 451          * but some of our FDT resources are not ready until BUS_PASS_DEFAULT
 452          */
 453         sc = device_get_softc(dev);
 454         if (sc->attach_done || bus_current_pass < BUS_PASS_DEFAULT) {
 455                 bus_generic_new_pass(dev);
 456                 return;
 457         }
 458
 459         sc->attach_done = 1;
 460         node = ofw_bus_get_node(dev);
 461
 462         /* Allocate our IRQ resource. */
 463         rid = 0;
 464         sc->syncpt_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 465             RF_ACTIVE);
 466         if (sc->syncpt_irq_res == NULL) {
 467                 device_printf(dev, "Cannot allocate interrupt.\n");
 468                 rv = ENXIO;
 469                 goto fail;
 470         }
 471         rid = 1;
 472         sc->gen_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 473             RF_ACTIVE);
 474         if (sc->gen_irq_res == NULL) {
 475                 device_printf(dev, "Cannot allocate interrupt.\n");
 476                 rv = ENXIO;
 477                 goto fail;
 478         }
 479
 480         /* FDT resources */
 481         rv = hwreset_get_by_ofw_name(sc->dev, 0, "host1x", &sc->reset);
 482         if (rv != 0) {
 483                 device_printf(dev, "Cannot get fuse reset\n");
 484                 goto fail;
 485         }
 486         rv = clk_get_by_ofw_index(sc->dev, 0, 0, &sc->clk);
 487         if (rv != 0) {
 488                 device_printf(dev, "Cannot get i2c clock: %d\n", rv);
 489                 goto fail;
 490         }
 491
 492         rv = clk_enable(sc->clk);
 493         if (rv != 0) {
 494                 device_printf(dev, "Cannot enable clock: %d\n", rv);
 495                 goto fail;
 496         }
 497         rv = hwreset_deassert(sc->reset);
 498         if (rv != 0) {
 499                 device_printf(sc->dev, "Cannot clear reset\n");
 500                 goto fail;
 501         }
 502
 503         /* Setup  interrupts */
 504         rv = bus_setup_intr(dev, sc->gen_irq_res,
 505             INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_gen_intr,
 506             sc, &sc->gen_irq_h);
 507         if (rv) {
 508                 device_printf(dev, "Cannot setup gen interrupt.\n");
 509                 goto fail;
 510         }
 511
 512         rv = bus_setup_intr(dev, sc->syncpt_irq_res,
 513             INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_syncpt_intr,
 514             sc, &sc->syncpt_irq_h);
 515         if (rv) {
 516                 device_printf(dev, "Cannot setup syncpt interrupt.\n");
 517                 goto fail;
 518         }
 519
 520         simplebus_init(dev, 0);
 521         for (node = OF_child(node); node > 0; node = OF_peer(node))
 522             simplebus_add_device(dev, node, 0, NULL, -1, NULL);
 523
 524         sc->irq_hook.ich_func = host1x_irq_hook;
 525         sc->irq_hook.ich_arg = sc;
 526         config_intrhook_establish(&sc->irq_hook);
 527         bus_generic_new_pass(dev);
 528         return;
 529
 530 fail:
 531         device_detach(dev);
 532         return;
 533 }
 534
 535 static int
 536 host1x_probe(device_t dev)
 537 {
 538
 539         if (!ofw_bus_status_okay(dev))
 540                 return (ENXIO);
 541
 542         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 543                 return (ENXIO);
 544
 545         return (BUS_PROBE_DEFAULT);
 546 }
 547
 548 static int
 549 host1x_attach(device_t dev)
 550 {
 551         int rv, rid;
 552         struct host1x_softc *sc;
 553
 554         sc = device_get_softc(dev);
 555         sc->tegra_drm = malloc(sizeof(struct tegra_drm), DRM_MEM_DRIVER,
 556             M_WAITOK | M_ZERO);
 557
 558         /* crosslink together all worlds */
 559         sc->dev = dev;
 560         sc->tegra_drm->drm_dev.dev_private = &sc->tegra_drm;
 561         sc->tegra_drm->drm_dev.dev = dev;
 562
 563         TAILQ_INIT(&sc->clients);
 564
 565         LOCK_INIT(sc);
 566
 567         /* Get the memory resource for the register mapping. */
 568         rid = 0;
 569         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 570             RF_ACTIVE);
 571         if (sc->mem_res == NULL) {
 572                 device_printf(dev, "Cannot map registers.\n");
 573                 rv = ENXIO;
 574                 goto fail;
 575         }
 576
 577         return (bus_generic_attach(dev));
 578
 579 fail:
 580         if (sc->tegra_drm != NULL)
 581                 free(sc->tegra_drm, DRM_MEM_DRIVER);
 582         if (sc->mem_res != NULL)
 583                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
 584         LOCK_DESTROY(sc);
 585         return (rv);
 586 }
 587
 588 static int
 589 host1x_detach(device_t dev)
 590 {
 591         struct host1x_softc *sc;
 592
 593         sc = device_get_softc(dev);
 594
 595         host1x_drm_exit(sc);
 596
 597         if (sc->gen_irq_h != NULL)
 598                 bus_teardown_intr(dev, sc->gen_irq_res, sc->gen_irq_h);
 599         if (sc->tegra_drm != NULL)
 600                 free(sc->tegra_drm, DRM_MEM_DRIVER);
 601         if (sc->clk != NULL)
 602                 clk_release(sc->clk);
 603         if (sc->reset != NULL)
 604                 hwreset_release(sc->reset);
 605         if (sc->syncpt_irq_h != NULL)
 606                 bus_teardown_intr(dev, sc->syncpt_irq_res, sc->syncpt_irq_h);
 607         if (sc->gen_irq_res != NULL)
 608                 bus_release_resource(dev, SYS_RES_IRQ, 1, sc->gen_irq_res);
 609         if (sc->syncpt_irq_res != NULL)
 610                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->syncpt_irq_res);
 611         if (sc->mem_res != NULL)
 612                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
 613         LOCK_DESTROY(sc);
 614         return (bus_generic_detach(dev));
 615 }
 616
 617 static device_method_t host1x_methods[] = {
 618         /* Device interface */
 619         DEVMETHOD(device_probe,         host1x_probe),
 620         DEVMETHOD(device_attach,        host1x_attach),
 621         DEVMETHOD(device_detach,        host1x_detach),
 622
 623         /* Bus interface */
 624         DEVMETHOD(bus_new_pass,         host1x_new_pass),
 625
 626         /* Framebuffer service methods */
 627         DEVMETHOD(fb_getinfo,           host1x_fb_helper_getinfo),
 628
 629         /* tegra drm interface */
 630         DEVMETHOD(tegra_drm_register_client,    host1x_register_client),
 631         DEVMETHOD(tegra_drm_deregister_client,  host1x_deregister_client),
 632
 633         DEVMETHOD_END
 634 };
 635
 636 DEFINE_CLASS_1(host1x, host1x_driver, host1x_methods,
 637     sizeof(struct host1x_softc), simplebus_driver);
 638 EARLY_DRIVER_MODULE(host1x, simplebus, host1x_driver, 0, 0, BUS_PASS_BUS);
 639
 640 /* Bindings for fbd device. */
 641 extern driver_t fbd_driver;
 642 DRIVER_MODULE(fbd, host1x, fbd_driver, 0, 0);