/*	$NetBSD: grfabs_tt.c,v 1.23 2010/04/13 11:31:11 tsutsui Exp $	*/

/*
 * Copyright (c) 1995 Leo Weppelman.
 * 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 ``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 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/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: grfabs_tt.c,v 1.23 2010/04/13 11:31:11 tsutsui Exp $");

#ifdef TT_VIDEO
/*
 *  atari abstract graphics driver: TT-interface
 */
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/systm.h>

#include <uvm/uvm_extern.h>

#include <machine/iomap.h>
#include <machine/video.h>
#include <machine/mfp.h>
#include <atari/atari/device.h>
#include <atari/atari/stalloc.h>
#include <atari/dev/grfabs_reg.h>
#include <atari/dev/grfabs_tt.h>

/*
 * Function decls
 */
static void       init_view(view_t *, bmap_t *, dmode_t *, box_t *);
static bmap_t	  *alloc_bitmap(u_long, u_long, u_char);
static colormap_t *alloc_colormap(dmode_t *);
static void 	  free_bitmap(bmap_t *);
static void	  tt_display_view(view_t *);
static view_t	  *tt_alloc_view(dmode_t *, dimen_t *, u_char);
static void	  tt_free_view(view_t *);
static void	  tt_remove_view(view_t *);
static void	  tt_save_view(view_t *);
static int	  tt_use_colormap(view_t *, colormap_t *);

/*
 * Our function switch table
 */
struct grfabs_sw tt_vid_sw = {
	tt_display_view,
	tt_alloc_view,
	tt_free_view,
	tt_remove_view,
	tt_save_view,
	tt_use_colormap
};

struct tt_hwregs {
	u_short		tt_reg;	/* video mode-register TT	*/
};
#define vm_reg(dm)	(((struct tt_hwregs*)(dm->data))->tt_reg)

/*
 * Note that the order of this table *must* match the order of
 * the table below!
 */
static struct tt_hwregs tt_hwregs[] = {
	{ RES_STHIGH },
	{ RES_TTHIGH },
	{ RES_STMID  },
	{ RES_STLOW  },
	{ RES_TTMID  },
	{ RES_TTLOW  }
};

static dmode_t vid_modes[] = {
    { { NULL, NULL }, "sthigh", { 640,  400 }, 1, NULL, &tt_vid_sw },
    { { NULL, NULL }, "tthigh", { 1280, 960 }, 1, NULL, &tt_vid_sw },
    { { NULL, NULL }, "stmid",  { 640,  200 }, 2, NULL, &tt_vid_sw },
    { { NULL, NULL }, "stlow",  { 320,  200 }, 4, NULL, &tt_vid_sw },
    { { NULL, NULL }, "ttmid",  { 640,  480 }, 4, NULL, &tt_vid_sw },
    { { NULL, NULL }, "ttlow",  { 320,  480 }, 8, NULL, &tt_vid_sw },
    { { NULL, NULL }, NULL,  }
};

/*
 * XXX: called from ite console init routine.
 * Initialize list of possible video modes.
 */

void
tt_probe_video(MODES *modelp)
{
	dmode_t	*dm;
	int	i;
	int	has_mono;

	/*
	 * First find out what kind of monitor is attached. DMA-sound
	 * should be off because the 'sound-done' and 'monochrome-detect'
	 * are xor-ed together. I think that shutting it down here is the
	 * wrong place.
	 */
	has_mono = (MFP->mf_gpip & IA_MONO) == 0;

	for (i = 0; (dm = &vid_modes[i])->name != NULL; i++) {
		dm->data = (void *)&tt_hwregs[i];
		if (has_mono && (vm_reg(dm) != RES_TTHIGH))
			continue;
		if (!has_mono && (vm_reg(dm) == RES_TTHIGH))
			continue;
		LIST_INSERT_HEAD(modelp, dm, link);
	}

	for (i=0; i < 16; i++)
		VIDEO->vd_tt_rgb[i] = CM_L2TT(gra_def_color16[i]);
}

static void
tt_display_view(view_t *v)
{
	dmode_t	*dm = v->mode;
	bmap_t	*bm = v->bitmap;

	if (dm->current_view) {
		/*
		 * Mark current view for this mode as no longer displayed
		 */
		dm->current_view->flags &= ~VF_DISPLAY;
	}
	dm->current_view = v;
	v->flags |= VF_DISPLAY;

	tt_use_colormap(v, v->colormap);

	/* XXX: should use vbl for this	*/
	VIDEO->vd_tt_res = vm_reg(dm);
	VIDEO->vd_raml   =  (u_long)bm->hw_address & 0xff;
	VIDEO->vd_ramm   = ((u_long)bm->hw_address >>  8) & 0xff;
	VIDEO->vd_ramh   = ((u_long)bm->hw_address >> 16) & 0xff;
}

void
tt_remove_view(view_t *v)
{
	dmode_t *mode = v->mode;

	if (mode->current_view == v) {
#if 0
		if (v->flags & VF_DISPLAY)
			panic("Cannot shutdown display"); /* XXX */
#endif
		mode->current_view = NULL;
	}
	v->flags &= ~VF_DISPLAY;
}

void
tt_save_view(view_t *v)
{
}

void
tt_free_view(view_t *v)
{

	if (v) {
		tt_remove_view(v);
		if (v->colormap != &gra_con_cmap)
			free(v->colormap, M_DEVBUF);
		free_bitmap(v->bitmap);
		if (v != &gra_con_view)
			free(v, M_DEVBUF);
	}
}

static int
tt_use_colormap(view_t *v, colormap_t *cm)
{
	dmode_t			*dm;
	volatile u_short	*creg;
	u_long			*src;
	colormap_t		*vcm;
	u_long			*vcreg;
	u_short			ncreg;
	int			i;

	dm  = v->mode;
	vcm = v->colormap;

	/*
	 * I guess it seems reasonable to require the maps to be
	 * of the same type...
	 */
	if (cm->type != vcm->type)
		return(EINVAL);

	/*
	 * First figure out where the actual colormap resides and
	 * howmany colors are in it.
	 */
	switch (vm_reg(dm)) {
		case RES_STLOW:
			creg  = &VIDEO->vd_tt_rgb[0];
			ncreg = 16;
			break;
		case RES_STMID:
			creg  = &VIDEO->vd_tt_rgb[0];
			ncreg = 4;
			break;
		case RES_STHIGH:
			creg  = &VIDEO->vd_tt_rgb[254];
			ncreg = 2;
			break;
		case RES_TTLOW:
			creg  = &VIDEO->vd_tt_rgb[0];
			ncreg = 256;
			break;
		case RES_TTMID:
			creg  = &VIDEO->vd_tt_rgb[0];
			ncreg = 16;
			break;
		case RES_TTHIGH:
			return(0);	/* No colors	*/
		default:
			panic("grf_tt:use_colormap: wrong mode!?");
	}

	/* If first entry specified beyond capabilities -> error */
	if (cm->first >= ncreg)
		return(EINVAL);

	/*
	 * A little tricky, the actual colormap pointer will be NULL
	 * when view is not displaying, valid otherwise.
	 */
	if (v->flags & VF_DISPLAY)
		creg = &creg[cm->first];
	else
		creg = NULL;

	vcreg  = &vcm->entry[cm->first];
	ncreg -= cm->first;
	if (cm->size > ncreg)
		return(EINVAL);
	ncreg = cm->size;

	for (i = 0, src = cm->entry; i < ncreg; i++, vcreg++) {
		*vcreg = *src++;

		/*
		 * If displaying, also update actual color registers.
		 */
		if (creg != NULL)
			*creg++ = CM_L2TT(*vcreg);
	}
	return (0);
}

static view_t *
tt_alloc_view(dmode_t *mode, dimen_t *dim, u_char depth)
{
	view_t *v;
	bmap_t *bm;

	if (!atari_realconfig)
		v = &gra_con_view;
	else
		v = malloc(sizeof(*v), M_DEVBUF, M_NOWAIT);
	if (v == NULL)
		return (NULL);
	
	bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth);
	if (bm) {
		box_t   box;

		v->colormap = alloc_colormap(mode);
		if (v->colormap) {
			INIT_BOX(&box,0,0,mode->size.width,mode->size.height);
			init_view(v, bm, mode, &box);
			return (v);
		}
		free_bitmap(bm);
	}
	if (v != &gra_con_view)
		free(v, M_DEVBUF);
	return (NULL);
}

static void
init_view(view_t *v, bmap_t *bm, dmode_t *mode, box_t *dbox)
{
	v->bitmap = bm;
	v->mode   = mode;
	v->flags  = 0;
	memcpy(&v->display, dbox, sizeof(box_t));
}

/* bitmap functions */

static bmap_t *
alloc_bitmap(u_long width, u_long height, u_char depth)
{
	u_long  total_size, bm_size;
	void	*hw_address;
	bmap_t	*bm;

	/*
	 * Sigh, it seems for mapping to work we need the bitplane data to
	 *  1: be aligned on a page boundry.
	 *  2: be n pages large.
	 * 
	 * why? because the user gets a page aligned address, if this is before
	 * your allocation, too bad.  Also it seems that the mapping routines
	 * do not watch to closely to the allowable length. so if you go over
	 * n pages by less than another page, the user gets to write all over
	 * the entire page. Since you did not allocate up to a page boundry
	 * (or more) the user writes into someone elses memory. -ch
	 */
	bm_size    = m68k_round_page((width * height * depth) / NBBY);
	total_size = bm_size + sizeof(bmap_t) + PAGE_SIZE;

	if ((bm = (bmap_t*)alloc_stmem(total_size, &hw_address)) == NULL)
		return(NULL);

	bm->plane         = (u_char*)bm + sizeof(bmap_t);
	bm->plane         = (u_char*)m68k_round_page(bm->plane);
	bm->hw_address    = (u_char*)hw_address + sizeof(bmap_t);
	bm->hw_address    = (u_char*)m68k_round_page(bm->hw_address);
	bm->bytes_per_row = (width * depth) / NBBY;
	bm->rows          = height;
	bm->depth         = depth;
	bm->regs          = NULL;
	bm->hw_regs       = NULL;
	bm->reg_size      = 0;
	bm->phys_mappable = (depth * width * height) / NBBY;
	bm->lin_base      = 0;
	bm->vga_address   = NULL;
	bm->vga_mappable  = 0;
	bm->vga_base      = 0;

	memset(bm->plane, 0, bm_size);
	return (bm);
}

static void
free_bitmap(bmap_t *bm)
{
	if (bm)
		free_stmem(bm);
}

static colormap_t *
alloc_colormap(dmode_t *dm)
{
	int		nentries, i;
	colormap_t	*cm;
	u_char		type = CM_COLOR;

	switch (vm_reg(dm)) {
		case RES_STLOW:
		case RES_TTMID:
			nentries = 16;
			break;
		case RES_STMID:
			nentries = 4;
			break;
		case RES_STHIGH:
			nentries = 2;
			break;
		case RES_TTLOW:
			nentries = 256;
			break;
		case RES_TTHIGH:
			type     = CM_MONO;
			nentries = 0;
			break;
		default:
			panic("grf_tt:alloc_colormap: wrong mode!?");
	}
	if (!atari_realconfig) {
		cm = &gra_con_cmap;
		cm->entry = gra_con_colors;
	} else {
		int size;

		size = sizeof(*cm) + (nentries * sizeof(cm->entry[0]));
		cm   = malloc(size, M_DEVBUF, M_NOWAIT);
		if (cm == NULL)
			return (NULL);
		cm->entry = (long *)&cm[1];

	}
	if ((cm->type = type) == CM_COLOR)
		cm->red_mask = cm->green_mask = cm->blue_mask = 0xf;
	cm->first = 0;
	cm->size  = nentries;

	for (i = 0; i < nentries; i++)
		cm->entry[i] = gra_def_color16[i % 16];
	return (cm);
}
#endif /* TT_VIDEO */
