/*-
 * Copyright (c) 2014 Imre Vadász <imre@vdsz.com>
 * All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Sascha Wildner <saw@online.de>.
 *
 * Simple font scaling code by Sascha Wildner and Matthew Dillon
 *
 * 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 as
 *    the first lines of this file unmodified.
 * 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 AUTHORS ``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 AUTHORS 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 "opt_syscons.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/thread.h>

#include <machine/console.h>
#include <machine/framebuffer.h>

#include "syscons.h"

#include <bus/isa/isareg.h>

static vr_draw_border_t		kms_draw_border;
static vr_draw_t		kms_draw;
static vr_draw_cursor_t		kms_cursor;
static vr_blink_cursor_t	kms_blink;
#ifndef SC_NO_CUTPASTE
static vr_draw_mouse_t		kms_mouse;
#endif

static void			kms_nop(scr_stat *scp, ...);

static sc_rndr_sw_t kmsrndrsw = {
	kms_draw_border,
	kms_draw,
	(vr_set_cursor_t *)kms_nop,
	kms_cursor,
	kms_blink,
#ifndef SC_NO_CUTPASTE
	kms_mouse,
#else
	(vr_draw_mouse_t *)kms_nop,
#endif
};
RENDERER(kms, V_INFO_MM_TEXT, kmsrndrsw, kms_set);

#ifndef SC_NO_MODE_CHANGE
static sc_rndr_sw_t grrndrsw = {
	(vr_draw_border_t *)kms_nop,
	(vr_draw_t *)kms_nop,
	(vr_set_cursor_t *)kms_nop,
	(vr_draw_cursor_t *)kms_nop,
	(vr_blink_cursor_t *)kms_nop,
	(vr_draw_mouse_t *)kms_nop,
};
RENDERER(kms, V_INFO_MM_OTHER, grrndrsw, kms_set);
#endif /* SC_NO_MODE_CHANGE */

RENDERER_MODULE(kms, kms_set);

static uint32_t colormap24[16] = {
	0x00000000,	/* BLACK */
	0x000000aa,	/* BLUE */
	0x0000aa00,	/* GREEN */
	0x0000aaaa,	/* CYAN */
	0x00aa0000,	/* RED */
	0x00aa00aa,	/* MAGENTA */
	0x00aa5500,	/* BROWN */
	0x00aaaaaa,	/* WHITE */
	0x00555555,	/* HIGHLIGHT BLACK */
	0x005555ff,	/* HIGHLIGHT BLUE */
	0x0055ff55,	/* HIGHLIGHT GREEN */
	0x0055ffff,	/* HIGHLIGHT CYAN */
	0x00ff5555,	/* HIGHLIGHT RED */
	0x00ff55ff,	/* HIGHLIGHT MAGENTA */
	0x00ffff55,	/* HIGHLIGHT BROWN */
	0x00ffffff,	/* HIGHLIGHT WHITE */
};

static uint16_t colormap565[16] = {
	0x0000,	/* BLACK */
	0x0015,	/* BLUE */
	0x0540,	/* GREEN */
	0x0555,	/* CYAN */
	0xA800,	/* RED */
	0xA815,	/* MAGENTA */
	0xAAA0,	/* BROWN */
	0xAD55,	/* WHITE */
	0x52AA,	/* HIGHLIGHT BLACK */
	0x52BF,	/* HIGHLIGHT BLUE */
	0x57EA,	/* HIGHLIGHT GREEN */
	0x57FF,	/* HIGHLIGHT CYAN */
	0xFAAA,	/* HIGHLIGHT RED */
	0xFCBF,	/* HIGHLIGHT MAGENTA */
	0xFFEA,	/* HIGHLIGHT BROWN */
	0xffff,	/* HIGHLIGHT WHITE */
};

#ifndef SC_NO_CUTPASTE
static u_short mouse_and_mask[16] = {
	0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
	0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
};
static u_short mouse_or_mask[16] = {
	0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
	0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
};
#endif

static void
kms_nop(scr_stat *scp, ...)
{
}

static inline int
get_pixel_size(uint16_t depth)
{
	return depth / 8;
}

/*
 * Scaled font rendering.  Simple blit blitter copy operation with bitmap
 * scaling.  Scales the bitmap char_data(sw x sh) to the output bitmap
 * draw_pos(dw x dh).
 *
 * This function does not do fractional scaling.
 *
 * SET	- Sets both the fg and bg pen
 *
 * MASK	- Sets only the fg pen based on the source mask and leaves
 *	  the background untouched.
 */
#define BLIT_SET	0
#define BLIT_MASK	1

static inline void
blit_blk32(scr_stat *scp, u_char *char_data, int sw, int sh,
	   vm_offset_t draw_pos, int dw, int dh,
	   int line_width, uint8_t fgidx, uint8_t bgidx, int how)
{
	vm_offset_t p;
	int pos;
	int x;		/* destination iterator (whole pixels) */
	int y;
	int sx, sx_inc;	/* source iterator (fractional) */
	int sy, sy_inc;
	uint8_t c;
	uint32_t fg = colormap24[fgidx];
	uint32_t bg = colormap24[bgidx];

	/*
	 * Calculate fractional iterator for source
	 */
	if (dw)
		sx_inc = (sw << 16) / dw;
	else
		sx_inc = 0;

	if (dh)
		sy_inc = (sh << 16) / dh;
	else
		sy_inc = 0;

	sy = 0;
	c = 0;

	/*
	 * For each pixel row in the target
	 */
	for (y = 0; y < dh; ++y) {
		sx = 0;
		p = draw_pos;

		/*
		 * Render all pixel columns in the target by calculating
		 * which bit in the source is applicable.
		 */
		switch(how) {
		case BLIT_SET:
			for (x = 0; x < dw; ++x) {
				if ((sx & 0x00070000) == 0)
					c = char_data[sx >> 19];
				pos = ~(sx >> 16) & 7;
				writel(p + x * 4, (c & (1 << pos) ? fg : bg));
				sx += sx_inc;
			}
			break;
		case BLIT_MASK:
			for (x = 0; x < dw; ++x) {
				if ((sx & 0x00070000) == 0)
					c = char_data[sx >> 19];
				pos = ~(sx >> 16) & 7;
				if (c & (1 << pos))
					writel(p + x * 4, fg);
				sx += sx_inc;
			}
			break;
		}
		draw_pos += line_width;
		sy += sy_inc;
		if (sy >= 0x10000) {
			char_data += (sy >> 16) * (sw >> 3);
			sy &= 0x0FFFF;
		}
	}
}

static inline void
blit_blk24(scr_stat *scp, u_char *char_data, int sw, int sh,
	   vm_offset_t draw_pos, int dw, int dh,
	   int line_width, uint8_t fgidx, uint8_t bgidx, int how)
{
	vm_offset_t p;
	int pos;
	int x;		/* destination iterator (whole pixels) */
	int y;
	int sx, sx_inc;	/* source iterator (fractional) */
	int sy, sy_inc;
	uint8_t c;
	uint32_t fg = colormap24[fgidx];
	uint32_t bg = colormap24[bgidx];

	/*
	 * Calculate fractional iterator for source
	 */
	if (dw)
		sx_inc = (sw << 16) / dw;
	else
		sx_inc = 0;

	if (dh)
		sy_inc = (sh << 16) / dh;
	else
		sy_inc = 0;

	sy = 0;
	c = 0;

	/*
	 * For each pixel row in the target
	 */
	for (y = 0; y < dh; ++y) {
		sx = 0;
		p = draw_pos;

		/*
		 * Render all pixel columns in the target by calculating
		 * which bit in the source is applicable.
		 */
		switch(how) {
		case BLIT_SET:
			for (x = 0; x < dw; ++x) {
				if ((sx & 0x00070000) == 0)
					c = char_data[sx >> 19];
				pos = ~(sx >> 16) & 7;
				uint32_t col = c & (1 << pos) ? fg : bg;
				writeb(p, col >> 16);
				writeb(p + 1, col >> 8);
				writeb(p + 2, col >> 0);
				p += 3;
				sx += sx_inc;
			}
			break;
		case BLIT_MASK:
			for (x = 0; x < dw; ++x) {
				if ((sx & 0x00070000) == 0)
					c = char_data[sx >> 19];
				pos = ~(sx >> 16) & 7;
				if (c & (1 << pos)) {
					writeb(p, fg >> 16);
					writeb(p + 1, fg >> 8);
					writeb(p + 2, fg >> 0);
				}
				p += 3;
				sx += sx_inc;
			}
			break;
		}
		draw_pos += line_width;
		sy += sy_inc;
		if (sy >= 0x10000) {
			char_data += (sy >> 16) * (sw >> 3);
			sy &= 0x0FFFF;
		}
	}
}

static inline void
blit_blk16(scr_stat *scp, u_char *char_data, int sw, int sh,
	   vm_offset_t draw_pos, int dw, int dh,
	   int line_width, uint8_t fgidx, uint8_t bgidx, int how)
{
	vm_offset_t p;
	int pos;
	int x;		/* destination iterator (whole pixels) */
	int y;
	int sx, sx_inc;	/* source iterator (fractional) */
	int sy, sy_inc;
	uint8_t c;
	uint16_t fg = colormap565[fgidx];
	uint16_t bg = colormap565[bgidx];

	/*
	 * Calculate fractional iterator for source
	 */
	if (dw)
		sx_inc = (sw << 16) / dw;
	else
		sx_inc = 0;

	if (dh)
		sy_inc = (sh << 16) / dh;
	else
		sy_inc = 0;

	sy = 0;
	c = 0;

	/*
	 * For each pixel row in the target
	 */
	for (y = 0; y < dh; ++y) {
		sx = 0;
		p = draw_pos;

		/*
		 * Render all pixel columns in the target by calculating
		 * which bit in the source is applicable.
		 */
		switch(how) {
		case BLIT_SET:
			for (x = 0; x < dw; ++x) {
				if ((sx & 0x00070000) == 0)
					c = char_data[sx >> 19];
				pos = ~(sx >> 16) & 7;
				writew(p + x * 2, (c & (1 << pos) ? fg : bg));
				sx += sx_inc;
			}
			break;
		case BLIT_MASK:
			for (x = 0; x < dw; ++x) {
				if ((sx & 0x00070000) == 0)
					c = char_data[sx >> 19];
				pos = ~(sx >> 16) & 7;
				if (c & (1 << pos))
					writew(p + x * 2, fg);
				sx += sx_inc;
			}
			break;
		}
		draw_pos += line_width;
		sy += sy_inc;
		if (sy >= 0x10000) {
			char_data += (sy >> 16) * (sw >> 3);
			sy &= 0x0FFFF;
		}
	}
}

static inline void
blit_blk(scr_stat *scp, u_char *char_data, int sw, int sh,
	   vm_offset_t draw_pos, int dw, int dh,
	   int line_width, uint8_t fgidx, uint8_t bgidx, int how,
	   int pixel_size)
{
	if (pixel_size == 2) {
		blit_blk16(scp, char_data, sw, sh, draw_pos, dw, dh, line_width,
			   fgidx, bgidx, how);
	} else if (pixel_size == 3) {
		blit_blk24(scp, char_data, sw, sh, draw_pos, dw, dh, line_width,
			   fgidx, bgidx, how);
	} else {
		blit_blk32(scp, char_data, sw, sh, draw_pos, dw, dh, line_width,
			   fgidx, bgidx, how);
	}
}

static void
fill_rect32(scr_stat *scp, vm_offset_t draw_pos, int width, int height,
	    int line_width, uint32_t fg)
{
	int i, j;

	for (i = 0; i < height; i++) {
		for (j = 0; j < width; j++)
			writel(draw_pos + j * 4, fg);
		draw_pos += line_width;
	}
}

static void
fill_rect24(scr_stat *scp, vm_offset_t draw_pos, int width, int height,
	    int line_width, uint32_t fg)
{
	int i, j, d;

	d = line_width - width * 3;
	KKASSERT(d >= 0);

	if ((draw_pos & 0x3) == 0 && (line_width & 0x3) == 0 &&
	    (width & 0x3) == 0) {
		uint32_t fga = fg | (fg << 24);
		uint32_t fgb = (fg << 16) | ((fg >> 8) & 0xffff);
		uint32_t fgc = (fg << 8) | ((fg >> 16) & 0xff);
		for (i = 0; i < height; i++) {
			for (j = 0; j < width; j += 4) {
				writel(draw_pos, fga);
				writel(draw_pos + 4, fgb);
				writel(draw_pos + 8, fgc);
				draw_pos += 12;
			}
			draw_pos += d;
		}
	} else {
		for (i = 0; i < height; i++) {
			for (j = 0; j < width; j++) {
				writeb(draw_pos, fg >> 16);
				writeb(draw_pos + 1, fg >> 8);
				writeb(draw_pos + 2, fg >> 0);
				draw_pos += 3;
			}
			draw_pos += line_width;
		}
	}
}

static void
fill_rect16(scr_stat *scp, vm_offset_t draw_pos, int width, int height,
	    int line_width, uint16_t fg)
{
	int i, j;

	for (i = 0; i < height; i++) {
		for (j = 0; j < width; j++)
			writew(draw_pos + j * 2, fg);
		draw_pos += line_width;
	}
}

/* KMS renderer */

static void
kms_draw_border(scr_stat *scp, int color)
{
	sc_softc_t *sc = scp->sc;
	int line_width, pixel_size;
	int rightpixel, bottompixel;
	vm_offset_t draw_pos;

	if (sc->fbi->vaddr == 0)
		return;

	line_width = sc->fbi->stride;
	pixel_size = get_pixel_size(sc->fbi->depth);
	rightpixel = sc->fbi->width - scp->xsize * scp->blk_width;
	bottompixel = sc->fbi->height - scp->ysize * scp->blk_height;

	draw_pos = sc->fbi->vaddr + scp->blk_width * pixel_size * scp->xsize;
	if (pixel_size == 2) {
		fill_rect16(scp, draw_pos, rightpixel,
		    scp->blk_height * scp->ysize, line_width,
		    colormap565[color]);
	} else if (pixel_size == 3) {
		fill_rect24(scp, draw_pos, rightpixel,
		    scp->blk_height * scp->ysize, line_width,
		    colormap24[color]);
	} else {
		fill_rect32(scp, draw_pos, rightpixel,
		    scp->blk_height * scp->ysize, line_width,
		    colormap24[color]);
	}

	draw_pos = sc->fbi->vaddr + scp->blk_height * scp->ysize * line_width;
	if (pixel_size == 2) {
		fill_rect16(scp, draw_pos, sc->fbi->width,
		    sc->fbi->height - scp->blk_height * scp->ysize, line_width,
		    colormap565[color]);
	} else if (pixel_size == 3) {
		fill_rect24(scp, draw_pos, sc->fbi->width,
		    sc->fbi->height - scp->blk_height * scp->ysize, line_width,
		    colormap24[color]);
	} else {
		fill_rect32(scp, draw_pos, sc->fbi->width,
		    sc->fbi->height - scp->blk_height * scp->ysize, line_width,
		    colormap24[color]);
	}
}

static void
kms_draw(scr_stat *scp, int from, int count, int flip)
{
	sc_softc_t *sc = scp->sc;
	u_char *char_data;
	int a, i;
	uint8_t fgidx, bgidx;
	vm_offset_t draw_pos, p;
	int line_width, pixel_size;

	if (sc->fbi->vaddr == 0)
		return;

	line_width = sc->fbi->stride;
	pixel_size = get_pixel_size(sc->fbi->depth);

	draw_pos = sc->fbi->vaddr +
	    scp->blk_height * line_width * (from / scp->xsize);

	if (from + count > scp->xsize * scp->ysize)
		count = scp->xsize * scp->ysize - from;

	p = draw_pos + scp->blk_width * pixel_size * (from % scp->xsize);
	for (i = from; count-- > 0; i++) {
		char_data = &(scp->font[sc_vtb_getc(&scp->vtb, i) *
					scp->font_height]);

		a = sc_vtb_geta(&scp->vtb, i);
		if (flip) {
			fgidx = ((a & 0xf000) >> 4) >> 8;
			bgidx = (a & 0x0f00) >> 8;
		} else {
			fgidx = (a & 0x0f00) >> 8;
			bgidx = ((a & 0xf000) >> 4) >> 8;
		}
		blit_blk(scp, char_data, scp->font_width, scp->font_height,
			 p, scp->blk_width, scp->blk_height, line_width,
			 fgidx, bgidx, BLIT_SET, pixel_size);

		p += scp->blk_width * pixel_size;
		if ((i % scp->xsize) == scp->xsize - 1) {
			draw_pos += scp->blk_height * line_width;
			p = draw_pos;
		}
	}
}

static void
draw_kmscursor(scr_stat *scp, int at, int on, int flip)
{
	sc_softc_t *sc = scp->sc;
	int line_width, pixel_size;
	int cursor_base;
	int blk_base;
	int a;
	uint8_t fgidx, bgidx;
	unsigned char *char_data;
	vm_offset_t draw_pos;

	if (sc->fbi->vaddr == 0)
		return;

	line_width = sc->fbi->stride;
	pixel_size = get_pixel_size(sc->fbi->depth);
	cursor_base = /* scp->font_height - */ scp->cursor_base;
	blk_base = scp->blk_height * cursor_base / scp->font_height;

	draw_pos = sc->fbi->vaddr +
	    scp->blk_width * pixel_size * (at % scp->xsize) +
	    scp->blk_height * line_width * (at / scp->xsize) +
	    blk_base * line_width;

	a = sc_vtb_geta(&scp->vtb, at);
	if (flip) {
		fgidx = ((on) ? (a & 0x0f00) : ((a & 0xf000) >> 4)) >> 8;
		bgidx = ((on) ? ((a & 0xf000) >> 4) : (a & 0x0f00)) >> 8;
	} else {
		fgidx = ((on) ? ((a & 0xf000) >> 4) : (a & 0x0f00)) >> 8;
		bgidx = ((on) ? (a & 0x0f00) : ((a & 0xf000) >> 4)) >> 8;
	}

	char_data = &scp->font[sc_vtb_getc(&scp->vtb, at) * scp->font_height];
	char_data += cursor_base;

	blit_blk(scp, char_data,
		 scp->font_width, scp->font_height - cursor_base,
		 draw_pos, scp->blk_width, scp->blk_height - blk_base,
		 line_width, fgidx, bgidx, BLIT_SET, pixel_size);
}

static int pxlblinkrate = 0;

static void
kms_cursor(scr_stat *scp, int at, int blink, int on, int flip)
{
	if (scp->cursor_height <= 0)	/* the text cursor is disabled */
		return;

	if (on) {
		if (!blink) {
			scp->status |= VR_CURSOR_ON;
			draw_kmscursor(scp, at, on, flip);
		} else if (++pxlblinkrate & 4) {
			pxlblinkrate = 0;
			scp->status ^= VR_CURSOR_ON;
			draw_kmscursor(scp, at,
			    scp->status & VR_CURSOR_ON, flip);
		}
	} else {
		if (scp->status & VR_CURSOR_ON)
			draw_kmscursor(scp, at, on, flip);
		scp->status &= ~VR_CURSOR_ON;
	}
	if (blink)
		scp->status |= VR_CURSOR_BLINK;
	else
		scp->status &= ~VR_CURSOR_BLINK;
}

static void
kms_blink(scr_stat *scp, int at, int flip)
{
	if (!(scp->status & VR_CURSOR_BLINK))
		return;
	if (!(++pxlblinkrate & 4))
		return;
	pxlblinkrate = 0;
	scp->status ^= VR_CURSOR_ON;
	draw_kmscursor(scp, at, scp->status & VR_CURSOR_ON, flip);
}

#ifndef SC_NO_CUTPASTE

static void
draw_kmsmouse(scr_stat *scp, int x, int y)
{
	sc_softc_t *sc = scp->sc;
	int line_width, pixel_size;
	int blk_width, blk_height;
	vm_offset_t draw_pos;

	if (sc->fbi->vaddr == 0)
		return;

	line_width = sc->fbi->stride;
	pixel_size = get_pixel_size(sc->fbi->depth);

	if (x + scp->font_width < scp->font_width * scp->xsize)
		blk_width = scp->blk_width;
	else
		blk_width = scp->font_width * scp->xsize - x;

	if (y + scp->font_height < scp->font_height * scp->ysize)
		blk_height = scp->blk_height;
	else
		blk_height = scp->font_height * scp->ysize - y;

	draw_pos = sc->fbi->vaddr + y * scp->blk_height / scp->font_height *
		   line_width +
		   x * scp->blk_width / scp->font_width * pixel_size;
	blit_blk(scp, (unsigned char *)mouse_and_mask, 16, 16,
		 draw_pos, blk_width, blk_height, line_width,
		 0, 0, BLIT_MASK, pixel_size);
	blit_blk(scp, (unsigned char *)mouse_or_mask, 16, 16,
		 draw_pos, blk_width, blk_height, line_width,
		 15, 0, BLIT_MASK, pixel_size);
}

static void
remove_kmsmouse(scr_stat *scp, int x, int y)
{
	int col, row;
	int pos;
	int i;

	/* erase the mouse cursor image */
	col = x / scp->font_width - scp->xoff;
	row = y / scp->font_height - scp->yoff;
	pos = row * scp->xsize + col;
	i = (col < scp->xsize - 1) ? 2 : 1;
	(*scp->rndr->draw)(scp, pos, i, FALSE);
	if (row < scp->ysize - 1)
		(*scp->rndr->draw)(scp, pos + scp->xsize, i, FALSE);
}

static void
kms_mouse(scr_stat *scp, int x, int y, int on)
{
	if (on)
		draw_kmsmouse(scp, x, y);
	else
		remove_kmsmouse(scp, x, y);
}

#endif /* SC_NO_CUTPASTE */