/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2016 Toomas Soome <tsoome@me.com>
 */

/*
 * Framebuffer based console support.
 *
 * Missing (no particular order):
 * memory barriers
 * shadow buffering
 * copyin for userspace calls and then polled io split.
 * callbacks for hw blt() and others?
 */
#include <sys/types.h>
#include <sys/visual_io.h>
#include <sys/fbio.h>
#include <sys/ddi.h>
#include <sys/kd.h>
#include <sys/sunddi.h>
#include <sys/rgb.h>
#include <sys/gfx_private.h>
#include "gfxp_fb.h"

#define	MYNAME	"gfxp_bitmap"

static ddi_device_acc_attr_t dev_attr = {
	DDI_DEVICE_ATTR_V0,
	DDI_NEVERSWAP_ACC,
	DDI_MERGING_OK_ACC
};

/* default structure for FBIOGATTR ioctl */
static struct fbgattr bitmap_attr =  {
/*	real_type	owner */
	FBTYPE_MEMCOLOR, 0,
/* fbtype: type		h  w  depth cms  size */
	{ FBTYPE_MEMCOLOR, 0, 0, 0, 0, 0 },
/* fbsattr: flags emu_type	dev_specific */
	{ 0, FBTYPE_MEMCOLOR, { 0 } },
/*	emu_types */
	{ -1 }
};

static struct vis_identifier gfxp_bitmap_ident = { "illumos_fb" };

static void bitmap_copy_fb(struct gfxp_fb_softc *, uint8_t *, uint8_t *);
static int bitmap_kdsetmode(struct gfxp_fb_softc *, int);
static int bitmap_devinit(struct gfxp_fb_softc *, struct vis_devinit *);
static void	bitmap_cons_copy(struct gfxp_fb_softc *, struct vis_conscopy *);
static void	bitmap_cons_display(struct gfxp_fb_softc *,
    struct vis_consdisplay *);
static int	bitmap_cons_clear(struct gfxp_fb_softc *,
    struct vis_consclear *);
static void	bitmap_cons_cursor(struct gfxp_fb_softc *,
    struct vis_conscursor *);
static void	bitmap_polled_copy(struct vis_polledio_arg *,
    struct vis_conscopy *);
static void	bitmap_polled_display(struct vis_polledio_arg *,
    struct vis_consdisplay *);
static void	bitmap_polled_cursor(struct vis_polledio_arg *,
    struct vis_conscursor *);
static int	bitmap_suspend(struct gfxp_fb_softc *softc);
static void	bitmap_resume(struct gfxp_fb_softc *softc);
static int	bitmap_devmap(dev_t dev, devmap_cookie_t dhp, offset_t off,
    size_t len, size_t *maplen, uint_t model, void *ptr);

static struct gfxp_ops gfxp_bitmap_ops = {
	.ident = &gfxp_bitmap_ident,
	.kdsetmode = bitmap_kdsetmode,
	.devinit = bitmap_devinit,
	.cons_copy = bitmap_cons_copy,
	.cons_display = bitmap_cons_display,
	.cons_cursor = bitmap_cons_cursor,
	.cons_clear = bitmap_cons_clear,
	.suspend = bitmap_suspend,
	.resume = bitmap_resume,
	.devmap = bitmap_devmap
};

void
gfxp_bm_register_fbops(gfxp_fb_softc_ptr_t ptr, struct gfxp_blt_ops *ops)
{
	struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)ptr;

	if (softc != NULL) {
		softc->blt_ops.blt = ops->blt;
		softc->blt_ops.copy = ops->copy;
		softc->blt_ops.clear = ops->clear;
		softc->blt_ops.setmode = ops->setmode;
	}
}

void
gfxp_bm_getfb_info(gfxp_fb_softc_ptr_t ptr, struct gfxp_bm_fb_info *fbip)
{
	struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)ptr;

	switch (softc->fb_type) {
	case GFXP_BITMAP:
		fbip->xres = softc->console->fb.screen.x;
		fbip->yres = softc->console->fb.screen.y;
		fbip->bpp = softc->console->fb.bpp;
		fbip->depth = softc->console->fb.depth;
		break;
	case GFXP_VGATEXT:
		/*
		 * By current knowledge, DRM can not cope with text mode
		 * and the VGA is disabled. The proper approach here
		 * is to set all values to 0. See the drm_getfb_size() and
		 * the i915_gem_init() how the size is used.
		 */
		fbip->xres = 0;
		fbip->yres = 0;
		fbip->bpp = 0;
		fbip->depth = 0;
		break;
	}
}

int
gfxp_bm_attach(dev_info_t *devi __unused, struct gfxp_fb_softc *softc)
{
	softc->polledio.display = bitmap_polled_display;
	softc->polledio.copy = bitmap_polled_copy;
	softc->polledio.cursor = bitmap_polled_cursor;
	softc->gfxp_ops = &gfxp_bitmap_ops;
	softc->fbgattr = &bitmap_attr;
	softc->silent = 0;

	return (DDI_SUCCESS);
}

int
gfxp_bm_detach(dev_info_t *devi __unused, struct gfxp_fb_softc *softc)
{
	if (softc == NULL || softc->console == NULL)
		return (DDI_SUCCESS);

	if (softc->console->fb.fb_size != 0) {
		gfxp_unmap_kernel_space((gfxp_kva_t)softc->console->fb.fb,
		    softc->console->fb.fb_size);
		fb_info.fb = NULL;
		kmem_free(softc->console->fb.shadow_fb,
		    softc->console->fb.fb_size);
		softc->console->fb.shadow_fb = NULL;
	}
	return (DDI_SUCCESS);
}

static void
bitmap_kdsettext(struct gfxp_fb_softc *softc)
{
	bitmap_copy_fb(softc, softc->console->fb.shadow_fb,
	    softc->console->fb.fb);
}

static void
bitmap_kdsetgraphics(struct gfxp_fb_softc *softc __unused)
{
	/* we have the copy of fb content in shadow_fb */
}

static int
bitmap_suspend(struct gfxp_fb_softc *softc __unused)
{
	/* we have the copy of fb content in shadow_fb */
	return (DDI_SUCCESS);
}

static void
bitmap_resume(struct gfxp_fb_softc *softc)
{
	bitmap_kdsettext(softc);
}

static int
bitmap_kdsetmode(struct gfxp_fb_softc *softc, int mode)
{
	switch (mode) {
	case KD_TEXT:
		if (softc->blt_ops.setmode != NULL)
			if (softc->blt_ops.setmode(KD_TEXT) != 0)
				return (EIO);

		bitmap_kdsettext(softc);
		break;
	case KD_GRAPHICS:
		bitmap_kdsetgraphics(softc);
		if (softc->blt_ops.setmode != NULL)
			if (softc->blt_ops.setmode(KD_GRAPHICS) != 0) {
				bitmap_kdsettext(softc);
				return (EIO);
			}
		break;
	case KD_RESETTEXT:
		/*
		 * In order to avoid racing with a starting X server,
		 * this needs to be a test and set that is performed in
		 * a single (softc->lock protected) ioctl into this driver.
		 */
		if (softc->mode == KD_TEXT && softc->silent == 1) {
			bitmap_kdsettext(softc);
		}
		mode = KD_TEXT;
		break;
	default:
		return (EINVAL);
	}

	softc->mode = mode;
	return (0);
}

/*
 * Copy fb_info from early boot and set up the FB
 */
static int
bitmap_setup_fb(struct gfxp_fb_softc *softc)
{
	size_t size;
	struct gfxfb_info *gfxfb_info;

	softc->console = (union gfx_console *)&fb_info;
	size = ptob(btopr(fb_info.fb_size));
	softc->console->fb.fb_size = size;
	softc->console->fb.fb = (uint8_t *)gfxp_map_kernel_space(fb_info.paddr,
	    size, GFXP_MEMORY_WRITECOMBINED);
	if (softc->console->fb.fb == NULL)
		return (DDI_FAILURE);

	softc->console->fb.shadow_fb = kmem_zalloc(size, KM_SLEEP);

	bitmap_attr.fbtype.fb_height = fb_info.screen.y;
	bitmap_attr.fbtype.fb_width = fb_info.screen.x;
	bitmap_attr.fbtype.fb_depth = fb_info.depth;
	bitmap_attr.fbtype.fb_size = size;
	if (fb_info.depth == 32)
		bitmap_attr.fbtype.fb_cmsize = 1 << 24;
	else
		bitmap_attr.fbtype.fb_cmsize = 1 << fb_info.depth;

	gfxfb_info = (struct gfxfb_info *)bitmap_attr.sattr.dev_specific;
	gfxfb_info->terminal_origin_x = fb_info.terminal_origin.x;
	gfxfb_info->terminal_origin_y = fb_info.terminal_origin.y;
	gfxfb_info->pitch = fb_info.pitch;
	gfxfb_info->font_width = fb_info.font_width;
	gfxfb_info->font_height = fb_info.font_height;
	gfxfb_info->red_mask_size = fb_info.rgb.red.size;
	gfxfb_info->red_field_position = fb_info.rgb.red.pos;
	gfxfb_info->green_mask_size = fb_info.rgb.green.size;
	gfxfb_info->green_field_position = fb_info.rgb.green.pos;
	gfxfb_info->blue_mask_size = fb_info.rgb.blue.size;
	gfxfb_info->blue_field_position = fb_info.rgb.blue.pos;

	return (DDI_SUCCESS);
}

static int
bitmap_devinit(struct gfxp_fb_softc *softc, struct vis_devinit *data)
{
	union gfx_console *console;

	if (bitmap_setup_fb(softc) == DDI_FAILURE)
		return (1);

	console = softc->console;

	/* make sure we have current state of the screen */
	bitmap_copy_fb(softc, console->fb.fb, console->fb.shadow_fb);

	/* initialize console instance */
	data->version = VIS_CONS_REV;
	data->width = console->fb.screen.x;
	data->height = console->fb.screen.y;
	data->linebytes = console->fb.pitch;
	data->color_map = boot_color_map;
	data->depth = console->fb.depth;
	data->mode = VIS_PIXEL;
	data->polledio = &softc->polledio;
#if 0
	data->modechg_cb;
	data->modechg_arg;
#endif
	return (0);
}

/* Buffer to Buffer copy */
static void
bitmap_copy_fb(struct gfxp_fb_softc *softc, uint8_t *src, uint8_t *dst)
{
	uint32_t i, pitch, height;

	pitch = softc->console->fb.pitch;
	height = softc->console->fb.screen.y;

	for (i = 0; i < height; i++) {
		(void) memmove(dst + i * pitch, src + i * pitch, pitch);
	}
}

static void
bitmap_cons_copy(struct gfxp_fb_softc *softc, struct vis_conscopy *ma)
{
	union gfx_console *console;
	uint32_t soffset, toffset;
	uint32_t width, height, pitch;
	uint8_t *src, *dst, *sdst;
	int i;

	console = softc->console;
	soffset = ma->s_col * console->fb.bpp + ma->s_row * console->fb.pitch;
	toffset = ma->t_col * console->fb.bpp + ma->t_row * console->fb.pitch;
	src = console->fb.shadow_fb + soffset;
	dst = console->fb.fb + toffset;
	sdst = console->fb.shadow_fb + toffset;
	width = (ma->e_col - ma->s_col + 1) * console->fb.bpp;
	height = ma->e_row - ma->s_row + 1;
	pitch = console->fb.pitch;

	if (toffset <= soffset) {
		for (i = 0; i < height; i++) {
			uint32_t increment = i * pitch;
			if (softc->mode == KD_TEXT) {
				(void) memmove(dst + increment,
				    src + increment, width);
			}
			(void) memmove(sdst + increment, src + increment,
			    width);
		}
	} else {
		for (i = height - 1; i >= 0; i--) {
			uint32_t increment = i * pitch;
			if (softc->mode == KD_TEXT) {
				(void) memmove(dst + increment,
				    src + increment, width);
			}
			(void) memmove(sdst + increment, src + increment,
			    width);
		}
	}
}

/*
 * Implements alpha blending for RGBA data, could use pixels for arguments,
 * but byte stream seems more generic.
 * The generic alpha blending is:
 * blend = alpha * fg + (1.0 - alpha) * bg.
 * Since our alpha is not from range [0..1], we scale appropriately.
 */
static uint8_t
alpha_blend(uint8_t fg, uint8_t bg, uint8_t alpha)
{
	uint16_t blend, h, l;

	/* trivial corner cases */
	if (alpha == 0)
		return (bg);
	if (alpha == 0xFF)
		return (fg);
	blend = (alpha * fg + (0xFF - alpha) * bg);
	/* Division by 0xFF */
	h = blend >> 8;
	l = blend & 0xFF;
	if (h + l >= 0xFF)
		h++;
	return (h);
}

/* Copy memory to framebuffer or to memory. */
static void
bitmap_cpy(uint8_t *dst, uint8_t *src, uint32_t len, int bpp)
{
	uint32_t i;
	uint8_t a;

	switch (bpp) {
	case 4:
		for (i = 0; i < len; i += bpp) {
			a = src[i+3];
			dst[i] = alpha_blend(src[i], dst[i], a);
			dst[i+1] = alpha_blend(src[i+1], dst[i+1], a);
			dst[i+2] = alpha_blend(src[i+2], dst[i+2], a);
			dst[i+3] = a;
		}
		break;
	default:
		(void) memcpy(dst, src, len);
		break;
	}
}

static void
bitmap_cons_display(struct gfxp_fb_softc *softc, struct vis_consdisplay *da)
{
	union gfx_console *console;
	uint32_t size;		/* write size per scanline */
	uint8_t *fbp, *sfbp;	/* fb + calculated offset */
	int i;

	console = softc->console;
	/* make sure we will not write past FB */
	if (da->col >= console->fb.screen.x ||
	    da->row >= console->fb.screen.y ||
	    da->col + da->width > console->fb.screen.x ||
	    da->row + da->height > console->fb.screen.y)
		return;

	size = da->width * console->fb.bpp;
	fbp = console->fb.fb + da->col * console->fb.bpp +
	    da->row * console->fb.pitch;
	sfbp = console->fb.shadow_fb + da->col * console->fb.bpp +
	    da->row * console->fb.pitch;

	/* write all scanlines in rectangle */
	for (i = 0; i < da->height; i++) {
		uint8_t *dest = sfbp + i * console->fb.pitch;
		uint8_t *src = da->data + i * size;

		/* alpha blend bitmap to shadow fb. */
		bitmap_cpy(dest, src, size, console->fb.bpp);
		if (softc->mode == KD_TEXT) {
			/* Copy from shadow to fb. */
			src = dest;
			dest = fbp + i * console->fb.pitch;
			(void) memcpy(dest, src, size);
		}
	}
}

static int
bitmap_cons_clear(struct gfxp_fb_softc *softc, struct vis_consclear *ca)
{
	union gfx_console *console;
	uint8_t *fb, *sfb;
	uint16_t *fb16, *sfb16;
	uint32_t data, *fb32, *sfb32;
	int i, j, pitch;

	console = softc->console;
	pitch = console->fb.pitch;

	switch (console->fb.depth) {
	case 8:
		data = ca->bg_color.eight;
		for (i = 0; i < console->fb.screen.y; i++) {
			if (softc->mode == KD_TEXT) {
				fb = console->fb.fb + i * pitch;
				(void) memset(fb, data, pitch);
			}
			fb = console->fb.shadow_fb + i * pitch;
			(void) memset(fb, data, pitch);
		}
		break;
	case 15:
	case 16:
		data = (ca->bg_color.sixteen[0] << 8) |
		    ca->bg_color.sixteen[1];
		for (i = 0; i < console->fb.screen.y; i++) {
			fb16 = (uint16_t *)(console->fb.fb + i * pitch);
			sfb16 = (uint16_t *)(console->fb.shadow_fb + i * pitch);
			for (j = 0; j < console->fb.screen.x; j++) {
				if (softc->mode == KD_TEXT)
					fb16[j] = (uint16_t)data & 0xffff;
				sfb16[j] = (uint16_t)data & 0xffff;
			}
		}
		break;
	case 24:
		data = ca->bg_color.twentyfour[0] << 16;
		data |= ca->bg_color.twentyfour[1] << 8;
		data |= ca->bg_color.twentyfour[2];
		for (i = 0; i < console->fb.screen.y; i++) {
			fb = console->fb.fb + i * pitch;
			sfb = console->fb.shadow_fb + i * pitch;
			for (j = 0; j < pitch; j += 3) {
				if (softc->mode == KD_TEXT) {
					fb[j] = (data >> 16) & 0xff;
					fb[j+1] = (data >> 8) & 0xff;
					fb[j+2] = data & 0xff;
				}

				sfb[j] = (data >> 16) & 0xff;
				sfb[j+1] = (data >> 8) & 0xff;
				sfb[j+2] = data & 0xff;
			}
		}
		break;
	case 32:
		data = *(uint32_t *)&ca->bg_color;
		for (i = 0; i < console->fb.screen.y; i++) {
			fb32 = (uint32_t *)(console->fb.fb + i * pitch);
			sfb32 = (uint32_t *)(console->fb.shadow_fb + i * pitch);
			for (j = 0; j < console->fb.screen.x; j++) {
				if (softc->mode == KD_TEXT)
					fb32[j] = data;
				sfb32[j] = data;
			}
		}
		break;
	}

	return (0);
}

static void
bitmap_display_cursor(struct gfxp_fb_softc *softc, struct vis_conscursor *ca)
{
	union gfx_console *console;
	uint32_t fg, bg, offset, size;
	uint32_t *fb32, *sfb32;
	uint16_t *fb16, *sfb16;
	uint8_t *fb8, *sfb8;
	int i, j, bpp, pitch;

	console = softc->console;
	pitch = console->fb.pitch;
	bpp = console->fb.bpp;
	size = ca->width * bpp;

	/*
	 * Build cursor image. We are building mirror image of data on
	 * frame buffer by (D xor FG) xor BG.
	 */
	offset = ca->col * bpp + ca->row * pitch;
	switch (console->fb.depth) {
	case 8:
		fg = ca->fg_color.eight;
		bg = ca->bg_color.eight;
		for (i = 0; i < ca->height; i++) {
			fb8 = console->fb.fb + offset + i * pitch;
			sfb8 = console->fb.shadow_fb + offset + i * pitch;
			for (j = 0; j < size; j += 1) {
				sfb8[j] = (sfb8[j] ^ (fg & 0xff)) ^ (bg & 0xff);
				if (softc->mode == KD_TEXT) {
					fb8[j] = sfb8[j];
				}
			}
		}
		break;
	case 15:
	case 16:
		fg = ca->fg_color.sixteen[0] << 8;
		fg |= ca->fg_color.sixteen[1];
		bg = ca->bg_color.sixteen[0] << 8;
		bg |= ca->bg_color.sixteen[1];
		for (i = 0; i < ca->height; i++) {
			fb16 = (uint16_t *)
			    (console->fb.fb + offset + i * pitch);
			sfb16 = (uint16_t *)
			    (console->fb.shadow_fb + offset + i * pitch);
			for (j = 0; j < ca->width; j++) {
				sfb16[j] = (sfb16[j] ^ (fg & 0xffff)) ^
				    (bg & 0xffff);
				if (softc->mode == KD_TEXT) {
					fb16[j] = sfb16[j];
				}
			}
		}
		break;
	case 24:
		fg = ca->fg_color.twentyfour[0] << 16;
		fg |= ca->fg_color.twentyfour[1] << 8;
		fg |= ca->fg_color.twentyfour[2];
		bg = ca->bg_color.twentyfour[0] << 16;
		bg |= ca->bg_color.twentyfour[1] << 8;
		bg |= ca->bg_color.twentyfour[2];
		for (i = 0; i < ca->height; i++) {
			fb8 = console->fb.fb + offset + i * pitch;
			sfb8 = console->fb.shadow_fb + offset + i * pitch;
			for (j = 0; j < size; j += 3) {
				sfb8[j] = (sfb8[j] ^ ((fg >> 16) & 0xff)) ^
				    ((bg >> 16) & 0xff);
				sfb8[j+1] = (sfb8[j+1] ^ ((fg >> 8) & 0xff)) ^
				    ((bg >> 8) & 0xff);
				sfb8[j+2] = (sfb8[j+2] ^ (fg & 0xff)) ^
				    (bg & 0xff);
				if (softc->mode == KD_TEXT) {
					fb8[j] = sfb8[j];
					fb8[j+1] = sfb8[j+1];
					fb8[j+2] = sfb8[j+2];
				}
			}
		}
		break;
	case 32:
		fg = *(uint32_t *)&ca->fg_color;
		bg = *(uint32_t *)&ca->bg_color;
		for (i = 0; i < ca->height; i++) {
			fb32 = (uint32_t *)
			    (console->fb.fb + offset + i * pitch);
			sfb32 = (uint32_t *)
			    (console->fb.shadow_fb + offset + i * pitch);
			for (j = 0; j < ca->width; j++) {
				sfb32[j] = (sfb32[j] ^ fg) ^ bg;
				if (softc->mode == KD_TEXT)
					fb32[j] = sfb32[j];
			}
		}
		break;
	}
}

static void
bitmap_cons_cursor(struct gfxp_fb_softc *softc, struct vis_conscursor *ca)
{
	union gfx_console *console = softc->console;

	switch (ca->action) {
	case VIS_HIDE_CURSOR:
		bitmap_display_cursor(softc, ca);
		console->fb.cursor.visible = B_FALSE;
		break;
	case VIS_DISPLAY_CURSOR:
		/* keep track of cursor position for polled mode */
		console->fb.cursor.pos.x =
		    (ca->col - console->fb.terminal_origin.x) /
		    console->fb.font_width;
		console->fb.cursor.pos.y =
		    (ca->row - console->fb.terminal_origin.y) /
		    console->fb.font_height;
		console->fb.cursor.origin.x = ca->col;
		console->fb.cursor.origin.y = ca->row;

		bitmap_display_cursor(softc, ca);
		console->fb.cursor.visible = B_TRUE;
		break;
	case VIS_GET_CURSOR:
		ca->row = console->fb.cursor.origin.y;
		ca->col = console->fb.cursor.origin.x;
		break;
	}
}

static void
bitmap_polled_copy(struct vis_polledio_arg *arg, struct vis_conscopy *ca)
{
	struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)arg;
	bitmap_cons_copy(softc, ca);
}

static void
bitmap_polled_display(struct vis_polledio_arg *arg, struct vis_consdisplay *da)
{
	struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)arg;
	bitmap_cons_display(softc, da);
}

static void
bitmap_polled_cursor(struct vis_polledio_arg *arg, struct vis_conscursor *ca)
{
	struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)arg;
	bitmap_cons_cursor(softc, ca);
}

/*
 * Device mapping support. Should be possible to mmmap frame buffer
 * to user space. Currently not working, mmap will receive -1 as pointer.
 */
/*ARGSUSED*/
static int
bitmap_devmap(dev_t dev, devmap_cookie_t dhp, offset_t off,
    size_t len, size_t *maplen, uint_t model, void *ptr)
{
	struct gfxp_fb_softc *softc = (struct gfxp_fb_softc *)ptr;
	union gfx_console *console;
	size_t length;

	if (softc == NULL) {
		cmn_err(CE_WARN, "bitmap: Can't find softstate");
		return (ENXIO);
	}

	console = softc->console;

	if (off >= console->fb.fb_size) {
		cmn_err(CE_WARN, "bitmap: Can't map offset 0x%llx", off);
		return (ENXIO);
	}

	if (off + len > console->fb.fb_size)
		length = console->fb.fb_size - off;
	else
		length = len;

	gfxp_map_devmem(dhp, console->fb.paddr, length, &dev_attr);

	*maplen = length;

	return (0);
}