Subversion Repositories openrisc_me

/* vga.c -- Definition of types and structures for VGA/LCD
 
   Copyright (C) 2001 Marko Mlinar, markom@opencores.org
   Copyright (C) 2008 Embecosm Limited
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 3 of the License, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   more details.
 
   You should have received a copy of the GNU General Public License along
   with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
/* This program is commented throughout in a fashion suitable for processing
   with Doxygen. */
 
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
#include <stdio.h>
 
/* Package includes */
#include "arch.h"
#include "sim-config.h"
#include "abstract.h"
#include "sched.h"
#include "toplevel-support.h"
 
 
#define VGA_CTRL        0x00	/* Control Register */
#define VGA_STAT        0x04	/* Status Register */
#define VGA_HTIM        0x08	/* Horizontal Timing Register */
#define VGA_VTIM        0x0c	/* Vertical Timing Register */
#define VGA_HVLEN       0x10	/* Horizontal and Vertical Length Register */
#define VGA_VBARA       0x14	/* Video Memory Base Address Register A */
#define VGA_VBARB       0x18	/* Video Memory Base Address Register B */
#define VGA_CLUTA       0x800
#define VGA_CLUTB       0xc00
#define VGA_MASK        0xfff
#define VGA_ADDR_SPACE  1024
 
 
/* List of implemented registers; all other are ignored.  */
 
/* Control Register */
#define VGA_CTRL_VEN    0x00000001	/* Video Enable */
#define VGA_CTRL_CD     0x00000300	/* Color Depth */
#define VGA_CTRL_PC     0x00000400	/* Pseudo Color */
 
/* Status Register */
/* Horiz. Timing Register */
/* Vert. Timing Register */
/* Horiz. and Vert. Length Register */
 
/* When this counter reaches config.vgas[].refresh_rate, a screenshot is taken and outputted */
struct vga_state
{
  int enabled;
  int pics;
  unsigned long ctrl, stat, htim, vtim;
  int vbindex;
  unsigned long vbar[2];
  unsigned hlen, vlen;
  int pindex;
  unsigned long palette[2][256];
  oraddr_t baseaddr;
  int refresh_rate;
  int irq;
  char *filename;
};
 
 
/* Write a register */
void
vga_write32 (oraddr_t addr, uint32_t value, void *dat)
{
  struct vga_state *vga = dat;
 
  switch (addr)
    {
    case VGA_CTRL:
      vga->ctrl = value;
      break;
    case VGA_STAT:
      vga->stat = value;
      break;
    case VGA_HTIM:
      vga->htim = value;
      break;
    case VGA_VTIM:
      vga->vtim = value;
      break;
    case VGA_HVLEN:
      vga->hlen = (value >> 16) + 2;
      vga->hlen = (value & 0xffff) + 2;
      break;
    case VGA_VBARA:
      vga->vbar[0] = value;
      break;
    case VGA_VBARB:
      vga->vbar[1] = value;
      break;
    default:
      if (addr >= VGA_CLUTA && addr < VGA_CLUTB)
	{
	  vga->palette[0][addr - VGA_CLUTA] = value & 0x00ffffff;
	}
      else if (addr >= VGA_CLUTB)
	{
	  vga->palette[1][addr - VGA_CLUTB] = value & 0x00ffffff;
	}
      else
	{
	  fprintf (stderr,
		   "vga_write32( 0x%" PRIxADDR ", 0x%08" PRIx32
		   " ): Out of range\n", addr + vga->baseaddr, value);
	  return;
	}
      break;
    }
}
 
/* Read a register */
uint32_t
vga_read32 (oraddr_t addr, void *dat)
{
  struct vga_state *vga = dat;
 
  switch (addr)
    {
    case VGA_CTRL:
      return vga->ctrl;
    case VGA_STAT:
      return vga->stat;
    case VGA_HTIM:
      return vga->htim;
    case VGA_VTIM:
      return vga->vtim;
    case VGA_HVLEN:
      return ((vga->hlen - 2) << 16) | (vga->vlen - 2);
    case VGA_VBARA:
      return vga->vbar[0];
    case VGA_VBARB:
      return vga->vbar[1];
    default:
      if (addr >= VGA_CLUTA && addr < VGA_CLUTB)
	{
	  return vga->palette[0][addr - VGA_CLUTA];
	}
      else if (addr >= VGA_CLUTB)
	{
	  return vga->palette[1][addr - VGA_CLUTB];
	}
      else
	{
	  fprintf (stderr, "vga_read32( 0x%" PRIxADDR " ): Out of range\n",
		   addr);
	  return 0;
	}
      break;
    }
  return 0;
}
 
/* This code will only work on little endian machines */
#ifdef __BIG_ENDIAN__
#warning Image dump not supported on big endian machines
 
static int
vga_dump_image (char *filename, struct vga_start *vga)
{
  return 1;
}
 
#else
 
typedef struct
{
  unsigned short int type;	/* Magic identifier            */
  unsigned int size;		/* File size in bytes          */
  unsigned short int reserved1, reserved2;
  unsigned int offset;		/* Offset to image data, bytes */
} BMP_HEADER;
 
typedef struct
{
  unsigned int size;		/* Header size in bytes      */
  int width, height;		/* Width and height of image */
  unsigned short int planes;	/* Number of colour planes   */
  unsigned short int bits;	/* Bits per pixel            */
  unsigned int compression;	/* Compression type          */
  unsigned int imagesize;	/* Image size in bytes       */
  int xresolution, yresolution;	/* Pixels per meter          */
  unsigned int ncolours;	/* Number of colours         */
  unsigned int importantcolours;	/* Important colours         */
} INFOHEADER;
 
 
/* Dumps a bmp file, based on current image */
static int
vga_dump_image (char *filename, struct vga_state *vga)
{
  int sx = vga->hlen;
  int sy = vga->vlen;
  int i, x = 0, y = 0;
  int pc = vga->ctrl & VGA_CTRL_PC;
  int rbpp = vga->ctrl & VGA_CTRL_CD;
  int bpp = rbpp >> 8;
 
  BMP_HEADER bh;
  INFOHEADER ih;
  FILE *fo;
 
  if (!sx || !sy)
    return 1;
 
  /* 16bpp and 32 bpp will be converted to 24bpp */
  if (bpp == 1 || bpp == 3)
    bpp = 2;
 
  bh.type = 19778;		/* BM */
  bh.size =
    sizeof (BMP_HEADER) + sizeof (INFOHEADER) + sx * sy * (bpp * 4 + 4) +
    (pc ? 1024 : 0);
  bh.reserved1 = bh.reserved2 = 0;
  bh.offset = sizeof (BMP_HEADER) + sizeof (INFOHEADER) + (pc ? 1024 : 0);
 
  ih.size = sizeof (INFOHEADER);
  ih.width = sx;
  ih.height = sy;
  ih.planes = 1;
  ih.bits = bpp * 4 + 4;
  ih.compression = 0;
  ih.imagesize = x * y * (bpp * 4 + 4);
  ih.xresolution = ih.yresolution = 0;
  ih.ncolours = 0;		/* should be generated */
  ih.importantcolours = 0;	/* all are important */
 
  fo = fopen (filename, "wb+");
  if (!fwrite (&bh, sizeof (BMP_HEADER), 1, fo))
    return 1;
  if (!fwrite (&ih, sizeof (INFOHEADER), 1, fo))
    return 1;
 
  if (pc)
    {				/* Write palette? */
      for (i = 0; i < 256; i++)
	{
	  unsigned long val, d;
	  d = vga->palette[vga->pindex][i];
	  val = (d >> 0) & 0xff;	/* Blue */
	  val |= (d >> 8) & 0xff;	/* Green */
	  val |= (d >> 16) & 0xff;	/* Red */
	  if (!fwrite (&val, sizeof (val), 1, fo))
	    return 1;
	}
    }
 
  /* Data is stored upside down */
  for (y = sy - 1; y >= 0; y--)
    {
      int align = 4 - ((bpp + 1) * sx) % 4;
      int zero = 0;
      for (x = 0; x < sx; x++)
	{
	  unsigned long pixel =
	    eval_direct32 (vga->vbar[vga->vbindex] + (y * sx + x) * (bpp + 1),
			   0, 0);
	  if (!fwrite (&pixel, sizeof (pixel), 1, fo))
	    return 1;
	}
      if (!fwrite (&zero, align, 1, fo))
	return 1;
    }
 
  fclose (fo);
  return 0;
}
#endif /* !__BIG_ENDIAN__ */
 
void
vga_job (void *dat)
{
  struct vga_state *vga = dat;
  /* dump the image? */
  char temp[STR_SIZE];
  sprintf (temp, "%s%04i.bmp", vga->filename, vga->pics++);
  vga_dump_image (temp, vga);
 
  SCHED_ADD (vga_job, dat, vga->refresh_rate);
}
 
/* Reset all VGAs */
void
vga_reset (void *dat)
{
  struct vga_state *vga = dat;
 
  int i;
 
  /* Init palette */
  for (i = 0; i < 256; i++)
    vga->palette[0][i] = vga->palette[1][i] = 0;
 
  vga->ctrl = vga->stat = vga->htim = vga->vtim = 0;
  vga->hlen = vga->vlen = 0;
  vga->vbar[0] = vga->vbar[1] = 0;
 
  /* Init screen dumping machine */
  vga->pics = 0;
 
  vga->pindex = 0;
  vga->vbindex = 0;
 
  SCHED_ADD (vga_job, dat, vga->refresh_rate);
}
 
/*----------------------------------------------------[ VGA Configuration ]---*/
static void
vga_enabled (union param_val val, void *dat)
{
  struct vga_state *vga = dat;
  vga->enabled = val.int_val;
}
 
static void
vga_baseaddr (union param_val val, void *dat)
{
  struct vga_state *vga = dat;
  vga->baseaddr = val.addr_val;
}
 
static void
vga_irq (union param_val val, void *dat)
{
  struct vga_state *vga = dat;
  vga->irq = val.int_val;
}
 
static void
vga_refresh_rate (union param_val val, void *dat)
{
  struct vga_state *vga = dat;
  vga->refresh_rate = val.int_val;
}
 
/*---------------------------------------------------------------------------*/
/*!Set the VGA output file
 
   Free any previously allocated value.
 
   @param[in] val  The value to use
   @param[in] dat  The config data structure                                 */
/*---------------------------------------------------------------------------*/
static void
vga_filename (union param_val  val,
	      void            *dat)
{
  struct vga_state *vga = dat;
 
  if (NULL != vga->filename)
    {
      free (vga->filename);
      vga->filename = NULL;
    }
 
  if (NULL == (vga->filename = strdup (val.str_val)))
    {
      fprintf (stderr, "ERROR: Out of memory\n");
      exit (-1);
    }
 
}	/* vga_filename() */
 
 
/*---------------------------------------------------------------------------*/
/*!Initialize a new VGA configuration
 
   ALL parameters are set explicitly to default values.                      */
/*---------------------------------------------------------------------------*/
static void *
vga_sec_start ()
{
  struct vga_state *new = malloc (sizeof (struct vga_state));
 
  if (!new)
    {
      fprintf (stderr, "Peripheral VGA: Run out of memory\n");
      exit (-1);
    }
 
  new->enabled      = 1;
  new->baseaddr     = 0;
  new->irq          = 0;
  new->refresh_rate = 1000000000000ULL / 50ULL / config.sim.clkcycle_ps;
  new->filename     = strdup ("vga_out");
 
  return new;
 
}	/* vga_sec_start() */
 
 
static void
vga_sec_end (void *dat)
{
  struct vga_state *vga = dat;
  struct mem_ops ops;
  if (!vga->enabled)
    {
      free (vga->filename);
      free (vga);
      return;
    }
 
  memset (&ops, 0, sizeof (struct mem_ops));
  ops.readfunc32 = vga_read32;
  ops.writefunc32 = vga_write32;
  ops.write_dat32 = dat;
  ops.read_dat32 = dat;
  /* FIXME: Correct delay? */
  ops.delayr = 2;
  ops.delayw = 2;
  reg_mem_area (vga->baseaddr, VGA_ADDR_SPACE, 0, &ops);
  reg_sim_reset (vga_reset, dat);
}
 
 
/*---------------------------------------------------------------------------*/
/*!Create a new VGA configuration
 
   ALL parameters are set explicitly to default values. Alternative naming for
   file parameter supported.                                                 */
/*---------------------------------------------------------------------------*/
void
reg_vga_sec ()
{
  struct config_section *sec =
    reg_config_sec ("vga", vga_sec_start, vga_sec_end);
 
  reg_config_param (sec, "baseaddr", paramt_addr, vga_baseaddr);
  reg_config_param (sec, "enabled", paramt_int, vga_enabled);
  reg_config_param (sec, "irq", paramt_int, vga_irq);
  reg_config_param (sec, "refresh_rate", paramt_int, vga_refresh_rate);
  reg_config_param (sec, "txfile", paramt_str, vga_filename);
  reg_config_param (sec, "filename", paramt_str, vga_filename);
 
}	/* reg_vga_sec() */