sim_avr.h

Go to the documentation of this file.

/*
 * sim_avr.h
 * 
 * Copyright 2008-2012 Michel Pollet <buserror@gmail.com>
 * 
 * This file is part of simavr.
 * 
 * simavr 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.
 * 
 * simavr 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 simavr.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef __SIM_AVR_H__
#define __SIM_AVR_H__

#ifdef __cplusplus
extern "C"
{
#endif

#include "sim_irq.h"
#include "sim_interrupts.h"
#include "sim_cycle_timers.h"

  enum
    {
      LOG_OUTPUT = 0,
      LOG_ERROR,
      LOG_WARNING,
      LOG_TRACE,
    };

#ifndef AVR_LOG
#define AVR_LOG(avr, level, ...) \
  do {                                          \
    avr_global_logger(avr, level, __VA_ARGS__); \
  } while(0)
#endif

#define AVR_TRACE(avr, ... ) \
  AVR_LOG(avr, LOG_TRACE, __VA_ARGS__)
  
  typedef uint32_t avr_flashaddr_t;

  struct avr_t;

  typedef uint8_t (*avr_io_read_t) (struct avr_t * avr, avr_io_addr_t addr, void *param);
  typedef void (*avr_io_write_t) (struct avr_t * avr, avr_io_addr_t addr, uint8_t v, void *param);

#define IO_START_ADDRESS 0x20
#define AVR_IO_TO_DATA(v) ((v) + IO_START_ADDRESS)
#define AVR_DATA_TO_IO(v) ((v) - IO_START_ADDRESS)
  
  enum
    {
      S_C = 0, S_Z, S_N, S_V, S_S, S_H, S_T, S_I,
      
      R_XL = 0x1a, R_XH, R_YL, R_YH, R_ZL, R_ZH,
      R_SPL = AVR_IO_TO_DATA(0x3d), R_SPH,
      R_SREG = AVR_IO_TO_DATA(0x3f),
      
      // maximum number of IO registers, on normal AVRs
      MAX_IOs = 280,   
    };

  enum
    {
      cpu_Limbo = 0,   
      cpu_Stopped,   
      cpu_Running,   
      cpu_Sleeping,   
      cpu_Step,   
      cpu_StepDone,   
      cpu_Done,   
      cpu_Crashed,   
    };

  struct avr_trace_data_t
  {
    struct avr_symbol_t **codeline;

#define OLD_PC_SIZE 32
    struct
    {
      uint32_t pc;
      uint16_t sp;
    } old[OLD_PC_SIZE];   
    int old_pci;

#if AVR_STACK_WATCH
#define STACK_FRAME_SIZE 32
    struct
    {
      uint32_t pc;
      uint16_t sp;
    } stack_frame[STACK_FRAME_SIZE];
    int stack_frame_index;
#endif

    // The touched structure map each register to a bit in a 32-bit array.
    uint32_t touched[256 / 32];   
  };

  typedef void (*avr_run_t) (struct avr_t * avr);

  typedef struct avr_t
  {
    const char *mmcu;   
    // these are filled by sim_core_declare from constants in /usr/lib/avr/include/avr/io*.h
    uint16_t ramend;
    uint32_t flashend;
    uint32_t e2end;
    uint8_t vector_size;
    uint8_t signature[3];
    uint8_t fuse[4];
    avr_io_addr_t rampz;   
    avr_io_addr_t eind;   
    uint8_t address_size;   

    uint32_t codeend;   

    int state;   
    uint32_t frequency;   
    // mostly used by the ADC for now
    uint32_t vcc, avcc, aref;   

    // Cycles gets incremented when sleeping and when running; it corresponds not only to "cycles
    // that runs" but also "cycles that might have run" like, sleeping.
    avr_cycle_count_t cycle;   

    // These next two allow the core to freely run between cycle timers and also allows for a
    // maximum run cycle limit... run_cycle_count is set during cycle timer processing.
    avr_cycle_count_t run_cycle_count;   
    avr_cycle_count_t run_cycle_limit;   

    uint32_t sleep_usec;

    void (*init) (struct avr_t * avr);
    void (*special_init) (struct avr_t * avr, void *data);
    void (*special_deinit) (struct avr_t * avr, void *data);
    void *special_data;
    void (*reset) (struct avr_t * avr);

    avr_run_t run;

    void (*sleep) (struct avr_t * avr, avr_cycle_count_t howLong);

    avr_irq_pool_t irq_pool;

    uint8_t sreg[8];

    int8_t interrupt_state;   

    avr_flashaddr_t pc;

    struct
    {
      struct avr_irq_t *irq;   
      struct
      {
        void *param;
        avr_io_read_t c;
      } r;
      struct
      {
        void *param;
        avr_io_write_t c;
      } w;
    } io[MAX_IOs];

    int io_shared_io_count;
    struct
    {
      int used;
      struct
      {
        void *param;
        void *c;
      } io[4];
    } io_shared_io[4];

    uint8_t *flash;
    uint8_t *data;

    struct avr_io_t *io_port;

    avr_cycle_timer_pool_t cycle_timers;
    avr_int_table_t interrupts;

    uint8_t trace:1, log:2;   

    struct avr_trace_data_t *trace_data;

    struct avr_vcd_t *vcd;

    struct avr_gdb_t *gdb;

    int gdb_port;
  } avr_t;

  typedef struct avr_kind_t
  {
    const char *names[4];   
    avr_t *(*make) (void);
  } avr_kind_t;

  typedef struct avr_symbol_t
  {
    uint32_t addr;
    const char symbol[0];
  } avr_symbol_t;

  avr_t *avr_make_mcu_by_name (const char *name);
  int avr_init (avr_t * avr);
  avr_t *avr_core_allocate (const avr_t * core, uint32_t coreLen);

  void avr_reset (avr_t * avr);
  int avr_run (avr_t * avr);
  void avr_terminate (avr_t * avr);

  void avr_set_command_register (avr_t * avr, avr_io_addr_t addr);

  void avr_set_console_register (avr_t * avr, avr_io_addr_t addr);

  void avr_loadcode (avr_t * avr, uint8_t * code, uint32_t size, avr_flashaddr_t address);

  void avr_core_watch_write (avr_t * avr, uint16_t addr, uint8_t v);
  uint8_t avr_core_watch_read (avr_t * avr, uint16_t addr);

  void avr_sadly_crashed (avr_t * avr, uint8_t signal);

  void avr_global_logger (struct avr_t *avr, const int level, const char *format, ...);

#ifndef AVR_CORE
#include <stdarg.h>
  typedef void (*avr_logger_p) (struct avr_t * avr, const int level, const char *format, va_list ap);

  void avr_global_logger_set (avr_logger_p logger);
  avr_logger_p avr_global_logger_get (void);
#endif

  void avr_callback_sleep_gdb (avr_t * avr, avr_cycle_count_t howLong);
  void avr_callback_run_gdb (avr_t * avr);
  void avr_callback_sleep_raw (avr_t * avr, avr_cycle_count_t howLong);
  void avr_callback_run_raw (avr_t * avr);

  uint32_t avr_pending_sleep_usec (avr_t * avr, avr_cycle_count_t howLong);

#ifdef __cplusplus
};
#endif

/**************************************************************************************************/

#include "sim_io.h"
#include "sim_regbit.h"

/**************************************************************************************************/

#ifdef __GNUC__

#ifndef likely
#define likely(x) __builtin_expect(!!(x), 1)
#endif

#ifndef unlikely
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif

#else /* ! __GNUC__ */

#ifndef likely
#define likely(x) x
#endif

#ifndef unlikely
#define unlikely(x) x
#endif

#endif /* __GNUC__ */

/**************************************************************************************************/

#endif /*__SIM_AVR_H__*/