Subversion Repositories scarts

/* SCARTS programmer module code for the GNU simulator.

   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003

   Free Software Foundation, Inc.

   Contributed by Martin Walter <mwalter@opencores.org>

   This file is part of the GNU simulators.

   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/>.  */

#include <assert.h>

#include "programmer.h"

/* Macros for machine type. */

#if defined __SCARTS_16__

  #include "scarts_16-codemem.h"

  #include "scarts_16-datamem.h"

  #define SCARTS_ADDR_CTYPE  uint16_t

#elif defined __SCARTS_32__

  #include "scarts_32-codemem.h"

  #include "scarts_32-datamem.h"

  #define SCARTS_ADDR_CTYPE  uint32_t

#else

  #error "Unsupported target machine type"

#endif

/* Macros for accessing the memory. */

#define GET_ADDRESS()   (mem.regfile.ADDRESS_LO | (mem.regfile.ADDRESS_HI << 8) | (mem.regfile.ADDRESS_3RD << 16) | (mem.regfile.ADDRESS_4TH << 24))

#define GET_DATA()      (mem.regfile.DATA_LO | (mem.regfile.DATA_HI << 8))

/* Macros for bit manipulations. */

#define read_bit(regfile, bitpos) (((regfile) >> (bitpos)) & 1)

#define write_bit(regfile, bitpos, value) (void)((value) ? ((regfile) |= (1 << (bitpos))) : ((regfile) &= ~(1 << (bitpos))))

static programmer_mem_t             mem;

static scarts_codemem_read_fptr_t  codemem_read;

static scarts_codemem_write_fptr_t codemem_write;

static scarts_datamem_read_fptr_t  datamem_read;

static scarts_datamem_write_fptr_t datamem_write;

uint8_t*

get_mem (void)

{

  return mem.raw;

}

void

get_mem_map (SCARTS_ADDR_CTYPE* start, SCARTS_ADDR_CTYPE* size)

{

  *start = PROGRAMMER_BADDR;

  *size  = PROGRAMMER_SIZE;

}

uint8_t*

get_status (void)

{

  return &mem.regfile.STATUS;

}

int

mem_read (SCARTS_ADDR_CTYPE offset, uint8_t *value)

{

  if (offset >= PROGRAMMER_SIZE)

    return 0;

  *value = mem.raw[offset];

  return 1;

}

int

mem_write (SCARTS_ADDR_CTYPE offset, uint8_t value)

{

  if (offset >= PROGRAMMER_SIZE)

    return 0;

  mem.raw[offset] = value;

  return 1;

}

void

reset (void)

{

  write_bit (mem.regfile.CONFIG_C, PROGRAMMER_CONFIG_C_CLR, 0);

}

void

set_codemem_read_fptr (scarts_codemem_read_fptr_t codemem_read_fptr)

{

  codemem_read = codemem_read_fptr;

}

void

set_codemem_write_fptr (scarts_codemem_write_fptr_t codemem_write_fptr)

{

  codemem_write = codemem_write_fptr;

}

void

set_datamem_read_fptr (scarts_datamem_read_fptr_t datamem_read_fptr)

{

  datamem_read = datamem_read_fptr;

}

void

set_datamem_write_fptr (scarts_datamem_write_fptr_t datamem_write_fptr)

{

  datamem_write = datamem_write_fptr;

}

void

tick (SCARTS_ADDR_CTYPE pc)

{

  uint16_t data, temp;

  SCARTS_ADDR_CTYPE addr;

  /* Check if a soft-reset was triggered. */

  if (read_bit (mem.regfile.CONFIG_C, PROGRAMMER_CONFIG_C_CLR))

    return;

  /* Check if the programmer execution bit is set. */

  if (read_bit (mem.regfile.CONFIG_C, PROGRAMMER_CONFIG_C_PREXE))

  {

    addr = GET_ADDRESS ();

    data = GET_DATA ();

    /* Check if the content of the data register

     * shall be written to the code memory. */

    if (!read_bit (mem.regfile.CONFIG_C, PROGRAMMER_CONFIG_C_MEM))

    {

      codemem_write (addr, data);

      codemem_read (addr, &temp);

      assert (data == temp);

    }

    else

    {

      datamem_write (addr, (uint8_t) data);

      datamem_read (addr, (uint8_t*) &temp);

      assert ((uint8_t) data == (uint8_t) temp);

    }

    /* Unset the programmer execution bit. */

    write_bit (mem.regfile.CONFIG_C, PROGRAMMER_CONFIG_C_PREXE, 0);

  }

}