xref: /freebsd/sys/arm/nvidia/drm2/tegra_host1x.c (revision 18250ec6c089c0c50cbd9fd87d78e03ff89916df)

/*-
 * Copyright (c) 2015 Michal Meloun
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/clock.h>
#include <sys/kernel.h>
#include <sys/limits.h>
#include <sys/lock.h>

#include <sys/module.h>
#include <sys/resource.h>
#include <sys/sx.h>
#include <sys/rman.h>

#include <machine/bus.h>
#include <machine/resource.h>

#include <dev/clk/clk.h>
#include <dev/hwreset/hwreset.h>
#include <dev/drm2/drmP.h>
#include <dev/drm2/drm_crtc_helper.h>
#include <dev/drm2/drm_fb_helper.h>
#include <dev/fdt/simplebus.h>
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>

#include <arm/nvidia/drm2/tegra_drm.h>

#include "fb_if.h"
#include "tegra_drm_if.h"

#define	WR4(_sc, _r, _v)	bus_rite_4((_sc)->mem_res, (_r), (_v))
#define	RD4(_sc, _r)		bus_read_4((_sc)->mem_res, (_r))

#define	LOCK(_sc)		sx_xlock(&(_sc)->lock)
#define	UNLOCK(_sc)		sx_xunlock(&(_sc)->lock)
#define	SLEEP(_sc, timeout)	sx_sleep(sc, &sc->lock, 0, "host1x", timeout);
#define	LOCK_INIT(_sc)		sx_init(&_sc->lock, "host1x")
#define	LOCK_DESTROY(_sc)	sx_destroy(&_sc->lock)
#define	ASSERT_LOCKED(_sc)	sx_assert(&_sc->lock, SA_LOCKED)
#define	ASSERT_UNLOCKED(_sc)	sx_assert(&_sc->lock, SA_UNLOCKED)

static struct ofw_compat_data compat_data[] = {
	{"nvidia,tegra124-host1x",	1},
	{NULL,				0}
};

#define DRIVER_NAME "tegra"
#define DRIVER_DESC "NVIDIA Tegra TK1"
#define DRIVER_DATE "20151101"
#define DRIVER_MAJOR 0
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0

struct client_info;
TAILQ_HEAD(client_list, client_info);
typedef struct client_list client_list_t;

struct client_info {
	TAILQ_ENTRY(client_info) list_e;
	device_t client;
	int 	activated;
};

struct host1x_softc {
	struct simplebus_softc	simplebus_sc;	/* must be first */
	device_t		dev;
	struct sx		lock;
	int 			attach_done;

	struct resource		*mem_res;
	struct resource		*syncpt_irq_res;
	void			*syncpt_irq_h;
	struct resource		*gen_irq_res;
	void			*gen_irq_h;

	clk_t			clk;
	hwreset_t			reset;
	struct intr_config_hook	irq_hook;

	int			drm_inited;
	client_list_t		clients;

	struct tegra_drm 	*tegra_drm;
};

static void
host1x_output_poll_changed(struct drm_device *drm_dev)
{
	struct tegra_drm *drm;

	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
	if (drm->fb != NULL)
		drm_fb_helper_hotplug_event(&drm->fb->fb_helper);
}

static const struct drm_mode_config_funcs mode_config_funcs = {
	.fb_create = tegra_drm_fb_create,
	.output_poll_changed = host1x_output_poll_changed,
};

static int
host1x_drm_init(struct host1x_softc *sc)
{
	struct client_info *entry;
	int rv;

	LOCK(sc);

	TAILQ_FOREACH(entry, &sc->clients, list_e) {
		if (entry->activated)
			continue;
		rv = TEGRA_DRM_INIT_CLIENT(entry->client, sc->dev,
		    sc->tegra_drm);
		if (rv != 0) {
			device_printf(sc->dev,
			    "Cannot init DRM client %s: %d\n",
			    device_get_name(entry->client), rv);
			return (rv);
		}
		entry->activated = 1;
	}
	UNLOCK(sc);

	return (0);
}

static int
host1x_drm_exit(struct host1x_softc *sc)
{
	struct client_info *entry;
	int rv;
#ifdef FREEBSD_NOTYET
	struct drm_device *dev, *tmp;
#endif
	LOCK(sc);
	if (!sc->drm_inited) {
		UNLOCK(sc);
		return (0);
	}
	TAILQ_FOREACH_REVERSE(entry, &sc->clients, client_list, list_e) {
		if (!entry->activated)
			continue;
		rv = TEGRA_DRM_EXIT_CLIENT(entry->client, sc->dev,
		    sc->tegra_drm);
		if (rv != 0) {
			device_printf(sc->dev,
			    "Cannot exit DRM client %s: %d\n",
			    device_get_name(entry->client), rv);
		}
		entry->activated = 0;
	}

#ifdef FREEBSD_NOTYET
	list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item)
		drm_put_dev(dev);
#endif
	sc->drm_inited = 0;
	UNLOCK(sc);

	return (0);
}

static int
host1x_drm_load(struct drm_device *drm_dev, unsigned long flags)
{
	struct host1x_softc *sc;
	int rv;

	sc = device_get_softc(drm_dev->dev);

	drm_mode_config_init(drm_dev);
	drm_dev->mode_config.min_width = 32;
	drm_dev->mode_config.min_height = 32;
	drm_dev->mode_config.max_width = 4096;
	drm_dev->mode_config.max_height = 4096;
	drm_dev->mode_config.funcs = &mode_config_funcs;

	rv = host1x_drm_init(sc);
	if (rv != 0)
		goto fail_host1x;

	drm_dev->irq_enabled = true;
	drm_dev->max_vblank_count = 0xffffffff;
	drm_dev->vblank_disable_allowed = true;

	rv = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc);
	if (rv != 0)
		goto fail_vblank;

	drm_mode_config_reset(drm_dev);

	rv = tegra_drm_fb_init(drm_dev);
	if (rv != 0)
		goto fail_fb;
	drm_kms_helper_poll_init(drm_dev);

	return (0);

fail_fb:
	tegra_drm_fb_destroy(drm_dev);
	drm_vblank_cleanup(drm_dev);
fail_vblank:
	host1x_drm_exit(sc);
fail_host1x:
	drm_mode_config_cleanup(drm_dev);

	return (rv);
}

static int
host1x_drm_unload(struct drm_device *drm_dev)
{
	struct host1x_softc *sc;
	int rv;

	sc = device_get_softc(drm_dev->dev);

	drm_kms_helper_poll_fini(drm_dev);
	tegra_drm_fb_destroy(drm_dev);
	drm_mode_config_cleanup(drm_dev);

	rv = host1x_drm_exit(sc);
	if (rv < 0)
		return (rv);
	return (0);
}

static int
host1x_drm_open(struct drm_device *drm_dev, struct drm_file *filp)
{

	return (0);
}

static void
tegra_drm_preclose(struct drm_device *drm, struct drm_file *file)
{
	struct drm_crtc *crtc;

	list_for_each_entry(crtc, &drm->mode_config.crtc_list, head)
		tegra_dc_cancel_page_flip(crtc, file);
}

static void
host1x_drm_lastclose(struct drm_device *drm_dev)
{

	struct tegra_drm *drm;

	drm = container_of(drm_dev, struct tegra_drm, drm_dev);
	if (drm->fb  != NULL)
		drm_fb_helper_restore_fbdev_mode(&drm->fb->fb_helper);
}

static int
host1x_drm_enable_vblank(struct drm_device *drm_dev, int pipe)
{
	struct drm_crtc *crtc;

	list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) {
		if (pipe == tegra_dc_get_pipe(crtc)) {
			tegra_dc_enable_vblank(crtc);
			return (0);
		}
	}
	return (-ENODEV);
}

static void
host1x_drm_disable_vblank(struct drm_device *drm_dev, int pipe)
{
	struct drm_crtc *crtc;

	list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) {
		if (pipe == tegra_dc_get_pipe(crtc)) {
			tegra_dc_disable_vblank(crtc);
			return;
		}
	}
}

static struct drm_ioctl_desc host1x_drm_ioctls[] = {
};

struct drm_driver tegra_drm_driver = {
	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
	.load = host1x_drm_load,
	.unload = host1x_drm_unload,
	.open = host1x_drm_open,
	.preclose = tegra_drm_preclose,
	.lastclose = host1x_drm_lastclose,

	.get_vblank_counter = drm_vblank_count,
	.enable_vblank = host1x_drm_enable_vblank,
	.disable_vblank = host1x_drm_disable_vblank,

	/* Fields filled by tegra_bo_driver_register()
	.gem_free_object
	.gem_pager_ops
	.dumb_create
	.dumb_map_offset
	.dumb_destroy
	*/
	.ioctls = host1x_drm_ioctls,
	.num_ioctls = nitems(host1x_drm_ioctls),

	.name = DRIVER_NAME,
	.desc = DRIVER_DESC,
	.date = DRIVER_DATE,
	.major = DRIVER_MAJOR,
	.minor = DRIVER_MINOR,
	.patchlevel = DRIVER_PATCHLEVEL,
};

/*
 * ----------------- Device methods -------------------------
 */
static void
host1x_irq_hook(void *arg)
{
	struct host1x_softc *sc;
	int rv;

	sc = arg;
	config_intrhook_disestablish(&sc->irq_hook);

	tegra_bo_driver_register(&tegra_drm_driver);
	rv = drm_get_platform_dev(sc->dev, &sc->tegra_drm->drm_dev,
	    &tegra_drm_driver);
	if (rv != 0) {
		device_printf(sc->dev, "drm_get_platform_dev(): %d\n", rv);
		return;
	}

	sc->drm_inited = 1;
}

static struct fb_info *
host1x_fb_helper_getinfo(device_t dev)
{
	struct host1x_softc *sc;

	sc = device_get_softc(dev);
	if (sc->tegra_drm == NULL)
		return (NULL);
	return (tegra_drm_fb_getinfo(&sc->tegra_drm->drm_dev));
}

static int
host1x_register_client(device_t dev, device_t client)
{
	struct host1x_softc *sc;
	struct client_info *entry;

	sc = device_get_softc(dev);

	entry = malloc(sizeof(struct client_info), M_DEVBUF, M_WAITOK | M_ZERO);
	entry->client = client;
	entry->activated = 0;

	LOCK(sc);
	TAILQ_INSERT_TAIL(&sc->clients, entry, list_e);
	UNLOCK(sc);

	return (0);
}

static int
host1x_deregister_client(device_t dev, device_t client)
{
	struct host1x_softc *sc;
	struct client_info *entry;

	sc = device_get_softc(dev);

	LOCK(sc);
	TAILQ_FOREACH(entry, &sc->clients, list_e) {
		if (entry->client == client) {
			if (entry->activated)
				panic("Tegra DRM: Attempt to deregister "
				    "activated client");
			TAILQ_REMOVE(&sc->clients, entry, list_e);
			free(entry, M_DEVBUF);
			UNLOCK(sc);
			return (0);
		}
	}
	UNLOCK(sc);

	return (0);
}

static void
host1x_gen_intr(void *arg)
{
	struct host1x_softc *sc;

	sc = (struct host1x_softc *)arg;
	LOCK(sc);
	UNLOCK(sc);
}

static void
host1x_syncpt_intr(void *arg)
{
	struct host1x_softc *sc;

	sc = (struct host1x_softc *)arg;
	LOCK(sc);
	UNLOCK(sc);
}

static void
host1x_new_pass(device_t dev)
{
	struct host1x_softc *sc;
	int rv, rid;
	phandle_t node;

	/*
	 * We attach during BUS_PASS_BUS (because we must overcome simplebus),
	 * but some of our FDT resources are not ready until BUS_PASS_DEFAULT
	 */
	sc = device_get_softc(dev);
	if (sc->attach_done || bus_get_pass() < BUS_PASS_DEFAULT) {
		bus_generic_new_pass(dev);
		return;
	}

	sc->attach_done = 1;
	node = ofw_bus_get_node(dev);

	/* Allocate our IRQ resource. */
	rid = 0;
	sc->syncpt_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
	    RF_ACTIVE);
	if (sc->syncpt_irq_res == NULL) {
		device_printf(dev, "Cannot allocate interrupt.\n");
		rv = ENXIO;
		goto fail;
	}
	rid = 1;
	sc->gen_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
	    RF_ACTIVE);
	if (sc->gen_irq_res == NULL) {
		device_printf(dev, "Cannot allocate interrupt.\n");
		rv = ENXIO;
		goto fail;
	}

	/* FDT resources */
	rv = hwreset_get_by_ofw_name(sc->dev, 0, "host1x", &sc->reset);
	if (rv != 0) {
		device_printf(dev, "Cannot get fuse reset\n");
		goto fail;
	}
	rv = clk_get_by_ofw_index(sc->dev, 0, 0, &sc->clk);
	if (rv != 0) {
		device_printf(dev, "Cannot get i2c clock: %d\n", rv);
		goto fail;
	}

	rv = clk_enable(sc->clk);
	if (rv != 0) {
		device_printf(dev, "Cannot enable clock: %d\n", rv);
		goto fail;
	}
	rv = hwreset_deassert(sc->reset);
	if (rv != 0) {
		device_printf(sc->dev, "Cannot clear reset\n");
		goto fail;
	}

	/* Setup  interrupts */
	rv = bus_setup_intr(dev, sc->gen_irq_res,
	    INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_gen_intr,
	    sc, &sc->gen_irq_h);
	if (rv) {
		device_printf(dev, "Cannot setup gen interrupt.\n");
		goto fail;
	}

	rv = bus_setup_intr(dev, sc->syncpt_irq_res,
	    INTR_TYPE_MISC | INTR_MPSAFE, NULL, host1x_syncpt_intr,
	    sc, &sc->syncpt_irq_h);
	if (rv) {
		device_printf(dev, "Cannot setup syncpt interrupt.\n");
		goto fail;
	}

	simplebus_init(dev, 0);
	for (node = OF_child(node); node > 0; node = OF_peer(node))
	    simplebus_add_device(dev, node, 0, NULL, -1, NULL);

	sc->irq_hook.ich_func = host1x_irq_hook;
	sc->irq_hook.ich_arg = sc;
	config_intrhook_establish(&sc->irq_hook);
	bus_generic_new_pass(dev);
	return;

fail:
	device_detach(dev);
	return;
}

static int
host1x_probe(device_t dev)
{

	if (!ofw_bus_status_okay(dev))
		return (ENXIO);

	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
		return (ENXIO);

	return (BUS_PROBE_DEFAULT);
}

static int
host1x_attach(device_t dev)
{
	int rv, rid;
	struct host1x_softc *sc;

	sc = device_get_softc(dev);
	sc->tegra_drm = malloc(sizeof(struct tegra_drm), DRM_MEM_DRIVER,
	    M_WAITOK | M_ZERO);

	/* crosslink together all worlds */
	sc->dev = dev;
	sc->tegra_drm->drm_dev.dev_private = &sc->tegra_drm;
	sc->tegra_drm->drm_dev.dev = dev;

	TAILQ_INIT(&sc->clients);

	LOCK_INIT(sc);

	/* Get the memory resource for the register mapping. */
	rid = 0;
	sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
	    RF_ACTIVE);
	if (sc->mem_res == NULL) {
		device_printf(dev, "Cannot map registers.\n");
		rv = ENXIO;
		goto fail;
	}

	bus_attach_children(dev);
	return (0);

fail:
	if (sc->tegra_drm != NULL)
		free(sc->tegra_drm, DRM_MEM_DRIVER);
	if (sc->mem_res != NULL)
		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
	LOCK_DESTROY(sc);
	return (rv);
}

static int
host1x_detach(device_t dev)
{
	struct host1x_softc *sc;
	int error;

	error = bus_generic_detach(dev);
	if (error != 0)
		return (error);

	sc = device_get_softc(dev);

	host1x_drm_exit(sc);

	if (sc->gen_irq_h != NULL)
		bus_teardown_intr(dev, sc->gen_irq_res, sc->gen_irq_h);
	if (sc->tegra_drm != NULL)
		free(sc->tegra_drm, DRM_MEM_DRIVER);
	if (sc->clk != NULL)
		clk_release(sc->clk);
	if (sc->reset != NULL)
		hwreset_release(sc->reset);
	if (sc->syncpt_irq_h != NULL)
		bus_teardown_intr(dev, sc->syncpt_irq_res, sc->syncpt_irq_h);
	if (sc->gen_irq_res != NULL)
		bus_release_resource(dev, SYS_RES_IRQ, 1, sc->gen_irq_res);
	if (sc->syncpt_irq_res != NULL)
		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->syncpt_irq_res);
	if (sc->mem_res != NULL)
		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
	LOCK_DESTROY(sc);
	return (0);
}

static device_method_t host1x_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe,		host1x_probe),
	DEVMETHOD(device_attach,	host1x_attach),
	DEVMETHOD(device_detach,	host1x_detach),

	/* Bus interface */
	DEVMETHOD(bus_new_pass,		host1x_new_pass),

	/* Framebuffer service methods */
	DEVMETHOD(fb_getinfo,           host1x_fb_helper_getinfo),

	/* tegra drm interface */
	DEVMETHOD(tegra_drm_register_client,	host1x_register_client),
	DEVMETHOD(tegra_drm_deregister_client,	host1x_deregister_client),

	DEVMETHOD_END
};

DEFINE_CLASS_1(host1x, host1x_driver, host1x_methods,
    sizeof(struct host1x_softc), simplebus_driver);
EARLY_DRIVER_MODULE(host1x, simplebus, host1x_driver, 0, 0, BUS_PASS_BUS);

/* Bindings for fbd device. */
extern driver_t fbd_driver;
DRIVER_MODULE(fbd, host1x, fbd_driver, 0, 0);