4 Copyright 2008-2012 Michel Pollet <buserror@gmail.com>
6 This file is part of simavr.
8 simavr is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 simavr is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with simavr. If not, see <http://www.gnu.org/licenses/>.
30 #include "sim_interrupts.h"
31 #include "sim_cycle_timers.h"
33 typedef uint32_t avr_flashaddr_t;
36 typedef uint8_t (*avr_io_read_t)(
40 typedef void (*avr_io_write_t)(
48 S_C = 0,S_Z,S_N,S_V,S_S,S_H,S_T,S_I,
50 // 16 bits register pairs
51 R_XL = 0x1a, R_XH,R_YL,R_YH,R_ZL,R_ZH,
53 R_SPL = 32+0x3d, R_SPH,
57 // maximum number of IO registers, on normal AVRs
58 MAX_IOs = 279, // Bigger AVRs need more than 256-32 (mega1280)
61 #define AVR_DATA_TO_IO(v) ((v) - 32)
62 #define AVR_IO_TO_DATA(v) ((v) + 32)
65 * Logging macros and associated log levels.
66 * The current log level is kept in avr->log.
73 typedef void (*logger_t)(struct avr_t* avr, const int level, const char * format, ... );
74 extern logger_t global_logger;
76 #define AVR_LOG(avr, level, ...) \
78 global_logger(avr, level, __VA_ARGS__); \
86 cpu_Limbo = 0, // before initialization is finished
87 cpu_Stopped, // all is stopped, timers included
89 cpu_Running, // we're free running
91 cpu_Sleeping, // we're now sleeping until an interrupt
93 cpu_Step, // run ONE instruction, then...
94 cpu_StepDone, // tell gdb it's all OK, and give it registers
95 cpu_Done, // avr software stopped gracefully
96 cpu_Crashed, // avr software crashed (watchdog fired)
99 // this is only ever used if CONFIG_SIMAVR_TRACE is defined
100 struct avr_trace_data_t {
101 struct avr_symbol_t ** codeline;
104 * this keeps track of "jumps" ie, call,jmp,ret,reti and so on
105 * allows dumping of a meaningful data even if the stack is
108 #define OLD_PC_SIZE 32
112 } old[OLD_PC_SIZE]; // catches reset..
116 #define STACK_FRAME_SIZE 32
117 // this records the call/ret pairs, to try to catch
118 // code that munches the stack -under- their own frame
122 } stack_frame[STACK_FRAME_SIZE];
123 int stack_frame_index;
127 // keeps track of which registers gets touched by instructions
128 // reset before each new instructions. Allows meaningful traces
129 uint32_t touched[256 / 32]; // debug
133 * Main AVR instance. Some of these fields are set by the AVR "Core" definition files
134 * the rest is runtime data (as little as possible)
136 typedef struct avr_t {
137 const char * mmcu; // name of the AVR
138 // these are filled by sim_core_declare from constants in /usr/lib/avr/include/avr/io*.h
143 uint8_t signature[3];
145 avr_io_addr_t rampz; // optional, only for ELPM/SPM on >64Kb cores
146 avr_io_addr_t eind; // optional, only for EIJMP/EICALL on >64Kb cores
148 // filled by the ELF data, this allow tracking of invalid jumps
151 int state; // stopped, running, sleeping
152 uint32_t frequency; // frequency we are running at
153 // mostly used by the ADC for now
154 uint32_t vcc,avcc,aref; // (optional) voltages in millivolts
156 // cycles gets incremented when sleeping and when running; it corresponds
157 // not only to "cycles that runs" but also "cycles that might have run"
159 avr_cycle_count_t cycle; // current cycle
162 * Sleep requests are accumulated in sleep_usec until the minimum sleep value
163 * is reached, at which point sleep_usec is cleared and the sleep request
164 * is passed on to the operating system.
168 // called at init time
169 void (*init)(struct avr_t * avr);
170 // called at init time (for special purposes like using a memory mapped file as flash see: simduino)
171 void (*special_init)(struct avr_t * avr);
172 // called at termination time ( to clean special initializations)
173 void (*special_deinit)(struct avr_t * avr);
174 // called at reset time
175 void (*reset)(struct avr_t * avr);
178 * Default AVR core run function.
179 * Two modes are available, a "raw" run that goes as fast as
180 * it can, and a "gdb" mode that also watchouts for gdb events
181 * and is a little bit slower.
183 void (*run)(struct avr_t * avr);
186 * Sleep default behaviour.
187 * In "raw" mode, it calls usleep, in gdb mode, it waits
188 * for howLong for gdb command on it's sockets.
190 void (*sleep)(struct avr_t * avr, avr_cycle_count_t howLong);
193 * Every IRQs will be stored in this pool. It is not
194 * mandatory (yet) but will allow listing IRQs and their connections
196 avr_irq_pool_t irq_pool;
198 // Mirror of the SREG register, to facilitate the access to bits
199 // in the opcode decoder.
200 // This array is re-synthesized back/forth when SREG changes
202 uint8_t i_shadow; // used to detect edges on I flag
206 * Note that the PC is representing /bytes/ while the AVR value is
207 * assumed to be "words". This is in line with what GDB does...
208 * this is why you will see >>1 and <<1 in the decoder to handle jumps.
209 * It CAN be a little confusing, so concentrate, young grasshopper.
214 * callback when specific IO registers are read/written.
215 * There is one drawback here, there is in way of knowing what is the
216 * "beginning of useful sram" on a core, so there is no way to deduce
217 * what is the maximum IO register for a core, and thus, we can't
218 * allocate this table dynamically.
219 * If you wanted to emulate the BIG AVRs, and XMegas, this would need
223 struct avr_irq_t * irq; // optional, used only if asked for with avr_iomem_getirq()
235 * This block allows sharing of the IO write/read on addresses between
236 * multiple callbacks. In 99% of case it's not needed, however on the tiny*
237 * (tiny85 at last) some registers have bits that are used by different
239 * If this case is detected, a special "dispatch" callback is installed that
240 * will handle this particular case, without impacting the performance of the
241 * other, normal cases...
243 int io_shared_io_count;
252 // flash memory (initialized to 0xff, and code loaded into it)
254 // this is the general purpose registers, IO registers, and SRAM
257 // queue of io modules
258 struct avr_io_t *io_port;
260 // cycle timers tracking & delivery
261 avr_cycle_timer_pool_t cycle_timers;
262 // interrupt vectors and delivery fifo
263 avr_int_table_t interrupts;
265 // DEBUG ONLY -- value ignored if CONFIG_SIMAVR_TRACE = 0
267 log : 2; // log level, default to 1
269 // Only used if CONFIG_SIMAVR_TRACE is defined
270 struct avr_trace_data_t *trace_data;
272 // VALUE CHANGE DUMP file (waveforms)
273 // this is the VCD file that gets allocated if the
274 // firmware that is loaded explicitly asks for a trace
275 // to be generated, and allocates it's own symbols
276 // using AVR_MMCU_TAG_VCD_TRACE (see avr_mcu_section.h)
277 struct avr_vcd_t * vcd;
279 // gdb hooking structure. Only present when gdb server is active
280 struct avr_gdb_t * gdb;
282 // if non-zero, the gdb server will be started when the core
283 // crashed even if not activated at startup
284 // if zero, the simulator will just exit() in case of a crash
289 // this is a static constructor for each of the AVR devices
290 typedef struct avr_kind_t {
291 const char * names[4]; // name aliases
295 // a symbol loaded from the .elf file
296 typedef struct avr_symbol_t {
301 // locate the maker for mcu "name" and allocates a new avr instance
303 avr_make_mcu_by_name(
305 // initializes a new AVR instance. Will call the IO registers init(), and then reset()
309 // Used by the cores, allocated a mutable avr_t from the const global
315 // resets the AVR, and the IO modules
319 // run one cycle of the AVR, sleep if necessary
323 // finish any pending operations
328 // set an IO register to receive commands from the AVR firmware
329 // it's optional, and uses the ELF tags
331 avr_set_command_register(
335 // specify the "console register" -- output sent to this register
336 // is printed on the simulator console, without using a UART
338 avr_set_console_register(
342 // load code in the "flash"
348 avr_flashaddr_t address);
351 * These are accessors for avr->data but allows watchpoints to be set for gdb
352 * IO modules use that to set values to registers, and the AVR core decoder uses
353 * that to register "public" read by instructions.
356 avr_core_watch_write(
365 // called when the core has detected a crash somehow.
366 // this might activate gdb server
374 * These are callbacks for the two 'main' behaviour in simavr
376 void avr_callback_sleep_gdb(avr_t * avr, avr_cycle_count_t howLong);
377 void avr_callback_run_gdb(avr_t * avr);
378 void avr_callback_sleep_raw(avr_t * avr, avr_cycle_count_t howLong);
379 void avr_callback_run_raw(avr_t * avr);
386 #include "sim_regbit.h"
388 #endif /*__SIM_AVR_H__*/