/*	$OpenBSD: apldrm.c,v 1.2 2024/01/29 14:52:25 kettenis Exp $	*/
/*
 * Copyright (c) 2023 Mark Kettenis <kettenis@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>

#include <machine/fdt.h>

#include <dev/ofw/openfirm.h>
#include <dev/ofw/fdt.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>

#include <linux/platform_device.h>

#include <drm/drm_drv.h>
#include <drm/drm_framebuffer.h>

struct apldrm_softc {
	struct platform_device	sc_dev;
	struct drm_device	sc_ddev;

	int			sc_node;

	struct rasops_info	sc_ri;
	struct wsscreen_descr	sc_wsd;
	struct wsscreen_list	sc_wsl;
	struct wsscreen_descr	*sc_scrlist[1];

	void			(*sc_switchcb)(void *, int, int);
	void			*sc_switchcbarg;
	void			*sc_switchcookie;
	struct task		sc_switchtask;

	int			sc_burner_fblank;
	struct task		sc_burner_task;
};

#include "apple_drv.c"

int	apldrm_match(struct device *, void *, void *);
void	apldrm_attach(struct device *, struct device *, void *);
int	apldrm_activate(struct device *, int);

const struct cfattach apldrm_ca = {
	sizeof (struct apldrm_softc), apldrm_match, apldrm_attach,
	NULL, apldrm_activate
};

struct cfdriver apldrm_cd = {
	NULL, "apldrm", DV_DULL
};

void	apldrm_attachhook(struct device *);

int
apldrm_match(struct device *parent, void *match, void *aux)
{
	struct fdt_attach_args *faa = aux;

	return OF_is_compatible(faa->fa_node, "apple,display-subsystem");
}

void
apldrm_attach(struct device *parent, struct device *self, void *aux)
{
	struct apldrm_softc *sc = (struct apldrm_softc *)self;
	struct fdt_attach_args *faa = aux;

	sc->sc_node = faa->fa_node;

	printf("\n");

	sc->sc_dev.faa = faa;
	platform_device_register(&sc->sc_dev);

	drm_attach_platform((struct drm_driver *)&apple_drm_driver,
	    faa->fa_iot, faa->fa_dmat, self, &sc->sc_ddev);
	config_mountroot(self, apldrm_attachhook);
}

int
apldrm_activate(struct device *self, int act)
{
	int rv;

	switch (act) {
	case DVACT_QUIESCE:
		rv = config_activate_children(self, act);
		apple_platform_suspend(self);
		break;
	case DVACT_WAKEUP:
		apple_platform_resume(self);
		rv = config_activate_children(self, act);
		break;
	default:
		rv = config_activate_children(self, act);
		break;
	}

	return rv;
}

int
apldrm_wsioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
{
	struct rasops_info *ri = v;
	struct apldrm_softc *sc = ri->ri_hw;
	struct wsdisplay_param *dp = (struct wsdisplay_param *)data;
	struct wsdisplay_fbinfo *wdf;
	struct backlight_device *bd;

	bd = backlight_device_get_by_name("apple-panel-bl");

	switch (cmd) {
	case WSDISPLAYIO_GTYPE:
		*(u_int *)data = WSDISPLAY_TYPE_KMS;
		return 0;
	case WSDISPLAYIO_GINFO:
		wdf = (struct wsdisplay_fbinfo *)data;
		wdf->width = ri->ri_width;
		wdf->height = ri->ri_height;
		wdf->depth = ri->ri_depth;
		wdf->stride = ri->ri_stride;
		wdf->offset = 0; /* XXX */
		wdf->cmsize = 0;
		return 0;
	case WSDISPLAYIO_GETPARAM:
		if (bd == NULL)
			return -1;

		switch (dp->param) {
		case WSDISPLAYIO_PARAM_BRIGHTNESS:
			dp->min = 0;
			dp->max = bd->props.max_brightness;
			dp->curval = bd->props.brightness;
			return (dp->max > dp->min) ? 0 : -1;
		}
		break;
	case WSDISPLAYIO_SETPARAM:
		if (bd == NULL)
			return -1;

		switch (dp->param) {
		case WSDISPLAYIO_PARAM_BRIGHTNESS:
			bd->props.brightness = dp->curval;
			backlight_update_status(bd);
			knote_locked(&sc->sc_ddev.note, NOTE_CHANGE);
			return 0;
		}
		break;
	case WSDISPLAYIO_SVIDEO:
	case WSDISPLAYIO_GVIDEO:
		return 0;
	}

	return (-1);
}

paddr_t
apldrm_wsmmap(void *v, off_t off, int prot)
{
	return (-1);
}

int
apldrm_alloc_screen(void *v, const struct wsscreen_descr *type,
    void **cookiep, int *curxp, int *curyp, uint32_t *attrp)
{
	return rasops_alloc_screen(v, cookiep, curxp, curyp, attrp);
}

void
apldrm_free_screen(void *v, void *cookie)
{
	return rasops_free_screen(v, cookie);
}

void
apldrm_doswitch(void *v)
{
	struct rasops_info *ri = v;
	struct apldrm_softc *sc = ri->ri_hw;
	struct drm_fb_helper *fb_helper = sc->sc_ddev.fb_helper;

	rasops_show_screen(ri, sc->sc_switchcookie, 0, NULL, NULL);
	drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);

	if (sc->sc_switchcb)
		(sc->sc_switchcb)(sc->sc_switchcbarg, 0, 0);
}

int
apldrm_show_screen(void *v, void *cookie, int waitok,
    void (*cb)(void *, int, int), void *cbarg)
{
	struct rasops_info *ri = v;
	struct apldrm_softc *sc = ri->ri_hw;

	if (cookie == ri->ri_active)
		return (0);

	sc->sc_switchcb = cb;
	sc->sc_switchcbarg = cbarg;
	sc->sc_switchcookie = cookie;
	if (cb) {
		task_add(systq, &sc->sc_switchtask);
		return (EAGAIN);
	}

	apldrm_doswitch(v);

	return (0);
}

void
apldrm_enter_ddb(void *v, void *cookie)
{
	struct rasops_info *ri = v;
	struct apldrm_softc *sc = ri->ri_hw;
	struct drm_fb_helper *fb_helper = sc->sc_ddev.fb_helper;

	if (cookie == ri->ri_active)
		return;

	rasops_show_screen(ri, cookie, 0, NULL, NULL);
	drm_fb_helper_debug_enter(fb_helper->info);
}

void
apldrm_burner(void *v, u_int on, u_int flags)
{
	struct rasops_info *ri = v;
	struct apldrm_softc *sc = ri->ri_hw;

	task_del(systq, &sc->sc_burner_task);

	if (on)
		sc->sc_burner_fblank = FB_BLANK_UNBLANK;
	else {
		if (flags & WSDISPLAY_BURN_VBLANK)
			sc->sc_burner_fblank = FB_BLANK_VSYNC_SUSPEND;
		else
			sc->sc_burner_fblank = FB_BLANK_NORMAL;
	}

	/*
	 * Setting the DPMS mode may sleep while waiting for vblank so
	 * hand things off to a taskq.
	 */
	task_add(systq, &sc->sc_burner_task);
}

void
apldrm_burner_cb(void *arg)
{
	struct apldrm_softc *sc = arg;
	struct drm_fb_helper *fb_helper = sc->sc_ddev.fb_helper;

	drm_fb_helper_blank(sc->sc_burner_fblank, fb_helper->info);
}

struct wsdisplay_accessops apldrm_accessops = {
	.ioctl = apldrm_wsioctl,
	.mmap = apldrm_wsmmap,
	.alloc_screen = apldrm_alloc_screen,
	.free_screen = apldrm_free_screen,
	.show_screen = apldrm_show_screen,
	.enter_ddb = apldrm_enter_ddb,
	.getchar = rasops_getchar,
	.load_font = rasops_load_font,
	.list_font = rasops_list_font,
	.scrollback = rasops_scrollback,
	.burn_screen = apldrm_burner
};

void
apldrm_attachhook(struct device *self)
{
	struct apldrm_softc *sc = (struct apldrm_softc *)self;
	struct drm_fb_helper *fb_helper;
	struct rasops_info *ri = &sc->sc_ri;
	struct wsemuldisplaydev_attach_args waa;
	int idx, len, console = 0;
	uint32_t defattr;
	int error;

	error = apple_platform_probe(&sc->sc_dev);
	if (error)
		return;

	/*
	 * If no display coprocessors were registered with the
	 * component framework, the call above will succeed without
	 * setting up a framebuffer.  Bail if we don't have one.
	 */
	fb_helper = sc->sc_ddev.fb_helper;
	if (fb_helper == NULL)
		return;

	/* Claim framebuffer to prevent attaching other drivers. */
	len = OF_getproplen(sc->sc_node, "memory-region");
	idx = OF_getindex(sc->sc_node, "framebuffer", "memory-region-names");
	if (idx >= 0 && idx < len / sizeof(uint32_t)) {
		uint32_t *phandles;
		uint64_t reg[2];
		int node;

		phandles = malloc(len, M_TEMP, M_WAITOK | M_ZERO);
		OF_getpropintarray(sc->sc_node, "memory-region",
		    phandles, len);
		node = OF_getnodebyphandle(phandles[idx]);
		if (node) {
			if (OF_getpropint64array(node, "reg", reg,
			    sizeof(reg)) == sizeof(reg))
				rasops_claim_framebuffer(reg[0], reg[1], self);
		}
		free(phandles, M_TEMP, len);
	}

	/*
	 * Update our understanding of the console output node if
	 * we're using the framebuffer console.
	 */
	if (OF_is_compatible(stdout_node, "simple-framebuffer"))
		stdout_node = sc->sc_node;

	if (sc->sc_node == stdout_node)
		console = 1;

	ri->ri_hw = sc;
	ri->ri_bits = fb_helper->info->screen_buffer;
	ri->ri_flg = RI_CENTER | RI_VCONS | RI_WRONLY;
	ri->ri_depth = fb_helper->fb->format->cpp[0] * 8;
	ri->ri_stride = fb_helper->fb->pitches[0];
	ri->ri_width = fb_helper->info->var.xres;
	ri->ri_height = fb_helper->info->var.yres;

	switch (fb_helper->fb->format->format) {
	case DRM_FORMAT_XRGB8888:
	case DRM_FORMAT_ARGB8888:
		ri->ri_rnum = 8;
		ri->ri_rpos = 16;
		ri->ri_gnum = 8;
		ri->ri_gpos = 8;
		ri->ri_bnum = 8;
		ri->ri_bpos = 0;
		break;
	case DRM_FORMAT_XRGB2101010:
		ri->ri_rnum = 10;
		ri->ri_rpos = 20;
		ri->ri_gnum = 10;
		ri->ri_gpos = 10;
		ri->ri_bnum = 10;
		ri->ri_bpos = 0;
		break;
	}

	rasops_init(ri, 160, 160);

	strlcpy(sc->sc_wsd.name, "std", sizeof(sc->sc_wsd.name));
	sc->sc_wsd.capabilities = ri->ri_caps;
	sc->sc_wsd.nrows = ri->ri_rows;
	sc->sc_wsd.ncols = ri->ri_cols;
	sc->sc_wsd.textops = &ri->ri_ops;
	sc->sc_wsd.fontwidth = ri->ri_font->fontwidth;
	sc->sc_wsd.fontheight = ri->ri_font->fontheight;

	sc->sc_scrlist[0] = &sc->sc_wsd;
	sc->sc_wsl.nscreens = 1;
	sc->sc_wsl.screens = (const struct wsscreen_descr **)sc->sc_scrlist;

	task_set(&sc->sc_switchtask, apldrm_doswitch, ri);
	task_set(&sc->sc_burner_task, apldrm_burner_cb, sc);

	if (console) {
		ri->ri_ops.pack_attr(ri->ri_active, 0, 0, 0, &defattr);
		wsdisplay_cnattach(&sc->sc_wsd, ri->ri_active,
		    ri->ri_ccol, ri->ri_crow, defattr);
	}

	memset(&waa, 0, sizeof(waa));
	waa.scrdata = &sc->sc_wsl;
	waa.accessops = &apldrm_accessops;
	waa.accesscookie = ri;
	waa.console = console;

	printf("%s: %dx%d, %dbpp\n", sc->sc_dev.dev.dv_xname,
	    ri->ri_width, ri->ri_height, ri->ri_depth);

	config_found_sm(self, &waa, wsemuldisplaydevprint,
	    wsemuldisplaydevsubmatch);
}