Subversion Repositories openrisc_me

/* upcall-basic.c. Test of Or1ksim basic handling of upcalls
 
   Copyright (C) 2010 Embecosm Limited
 
   Contributors various OpenCores participants
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of 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 code is commented throughout for use with Doxygen.
   --------------------------------------------------------------------------*/
 
#include "support.h"
#include "spr-defs.h"
#include "board.h"
 
 
/*!Alignment exception handler defined here. */
unsigned long excpt_align;
 
 
/* --------------------------------------------------------------------------*/
/*!Write a memory mapped byte register
 
   @param[in] addr   Memory mapped address
   @param[in] value  Value to set                                            */
/* --------------------------------------------------------------------------*/
static void
setreg8 (unsigned long int  addr,
	 unsigned char      value)
{
  *((volatile unsigned char *) addr) = value;
  printf ("Wrote byte at 0x%08lx = 0x%02x.\n", addr, value);
 
}	/* setreg8 () */
 
 
/* --------------------------------------------------------------------------*/
/*!Write a memory mapped half word register
 
   @param[in] addr   Memory mapped address
   @param[in] value  Value to set                                            */
/* --------------------------------------------------------------------------*/
static void
setreg16 (unsigned long int   addr,
	  unsigned short int  value)
{
  *((volatile unsigned short int *) addr) = value;
  printf ("Wrote half word at 0x%08lx = 0x%04x.\n", addr, value);
 
}	/* setreg16 () */
 
 
/* --------------------------------------------------------------------------*/
/*!Write a memory mapped full word register
 
   @param[in] addr   Memory mapped address
   @param[in] value  Value to set                                            */
/* --------------------------------------------------------------------------*/
static void
setreg32 (unsigned long int  addr,
	  unsigned long int  value)
{
  *((volatile unsigned long int *) addr) = value;
  printf ("Wrote full word at 0x%08lx = 0x%08lx.\n", addr, value);
 
}	/* setreg32 () */
 
 
/* --------------------------------------------------------------------------*/
/*!Read a memory mapped byte register
 
   @param[in] addr   Memory mapped address
 
   @return  Value read                                                       */
/* --------------------------------------------------------------------------*/
unsigned char
getreg8 (unsigned long int  addr)
{
  unsigned char  res = *((volatile unsigned char *) addr);
  printf ("Read byte at 0x%08lx = 0x%02x.\n", addr, res);
  return  res;
 
}	/* getreg8 () */
 
 
/* --------------------------------------------------------------------------*/
/*!Read a memory mapped half word register
 
   @param[in] addr   Memory mapped address
 
   @return  Value read                                                       */
/* --------------------------------------------------------------------------*/
unsigned short int
getreg16 (unsigned long int  addr)
{
  unsigned short int  res = *((volatile unsigned short int *) addr);
  printf ("Read half word at 0x%08lx = 0x%04x.\n", addr, res);
  return  res;
 
}	/* getreg16 () */
 
 
/* --------------------------------------------------------------------------*/
/*!Read a memory mapped full word register
 
   @param[in] addr   Memory mapped address
 
   @return  Value read                                                       */
/* --------------------------------------------------------------------------*/
unsigned long int
getreg32 (unsigned long int  addr)
{
  unsigned long int  res = *((volatile unsigned long int *) addr);
  printf ("Read full word at 0x%08lx = 0x%08lx.\n", addr, res);
  return  res;
 
}	/* getreg32 () */
 
 
/* --------------------------------------------------------------------------*/
/*! Exception handler for misalignment.
 
  Notes what has happened.                                                   */
/* --------------------------------------------------------------------------*/
void align_handler (void)
{
  printf ("Misaligned access.\n");
 
}	/* align_handler () */
 
 
/* --------------------------------------------------------------------------*/
/*!Main program to read and write memory mapped registers
 
   All these calls should be correctly aligned, but we set an handler, just in
   case.
 
   @return  The return code from the program (always zero).                  */
/* --------------------------------------------------------------------------*/
int
main ()
{
  /* Set the exception handler */
  printf ("Setting alignment exception handler.\n");
  excpt_align = (unsigned long)align_handler;
 
  /* Write some registers */
  printf ("Writing registers.\n");
 
  /* Byte aligned */
  setreg8 (GENERIC_BASE,     0xde);
  setreg8 (GENERIC_BASE + 1, 0xad);
  setreg8 (GENERIC_BASE + 2, 0xbe);
  setreg8 (GENERIC_BASE + 3, 0xef);
 
  /* Half word aligned */
  setreg16 (GENERIC_BASE + 4, 0xbaad);
  setreg16 (GENERIC_BASE + 6, 0xf00d);
 
  /* Full word aligned */
  setreg32 (GENERIC_BASE + 8, 0xcafebabe);
 
  /* Read some registers, but mix up which size from where. */
  printf ("Reading registers.\n");
 
  /* Full word aligned */
  (void)getreg32 (GENERIC_BASE + 0);
 
  /* Byte aligned */
  (void)getreg8 (GENERIC_BASE + 4);
  (void)getreg8 (GENERIC_BASE + 5);
  (void)getreg8 (GENERIC_BASE + 6);
  (void)getreg8 (GENERIC_BASE + 7);
 
  /* Half word aligned */
  (void)getreg16 (GENERIC_BASE +  8);
  (void)getreg16 (GENERIC_BASE + 10);
 
  /* All done */
  printf ("All done.\n");
  report (0xdeaddead);
  return 0;
 
}	/* main () */