mz80/mz80.h

   1 /* Multi-Z80 32 Bit emulator */
   2
   3 /* Copyright 1996, Neil Bradley, All rights reserved
   4  *
   5  * License agreement:
   6  *
   7  * The mZ80 emulator may be distributed in unmodified form to any medium.
   8  *
   9  * mZ80 May not be sold, or sold as a part of a commercial package without
  10  * the express written permission of Neil Bradley (neil@synthcom.com). This
  11  * includes shareware.
  12  *
  13  * Modified versions of mZ80 may not be publicly redistributed without author
  14  * approval (neil@synthcom.com). This includes distributing via a publicly
  15  * accessible LAN. You may make your own source modifications and distribute
  16  * mZ80 in object only form.
  17  *
  18  * mZ80 Licensing for commercial applications is available. Please email
  19  * neil@synthcom.com for details.
  20  *
  21  * Synthcom Systems, Inc, and Neil Bradley will not be held responsible for
  22  * any damage done by the use of mZ80. It is purely "as-is".
  23  *
  24  * If you use mZ80 in a freeware application, credit in the following text:
  25  *
  26  * "Multi-Z80 CPU emulator by Neil Bradley (neil@synthcom.com)"
  27  *
  28  * must accompany the freeware application within the application itself or
  29  * in the documentation.
  30  *
  31  * Legal stuff aside:
  32  *
  33  * If you find problems with mZ80, please email the author so they can get
  34  * resolved. If you find a bug and fix it, please also email the author so
  35  * that those bug fixes can be propogated to the installed base of mZ80
  36  * users. If you find performance improvements or problems with mZ80, please
  37  * email the author with your changes/suggestions and they will be rolled in
  38  * with subsequent releases of mZ80.
  39  *
  40  * The whole idea of this emulator is to have the fastest available 32 bit
  41  * Multi-z80 emulator for the PC, giving maximum performance.
  42  */
  43
  44 /* General z80 based defines */
  45
  46 #ifndef _MZ80_H_
  47 #define _MZ80_H_
  48
  49 #include <stdint.h>
  50
  51 #ifndef UINT32
  52 #define UINT32  uint32_t
  53 #endif
  54
  55 #ifndef UINT16
  56 #define UINT16  uint16_t
  57 #endif
  58
  59 #ifndef UINT8
  60 #define UINT8   uint8_t
  61 #endif
  62
  63 #ifndef INT32
  64 #define INT32  int32_t
  65 #endif
  66
  67 #ifndef INT16
  68 #define INT16  int16_t
  69 #endif
  70
  71 #ifndef INT8
  72 #define INT8   int8_t
  73 #endif
  74
  75 #ifndef UINTPTR
  76 #define UINTPTR uintptr_t
  77 #endif
  78
  79 #ifdef __cplusplus
  80 extern "C" {
  81 #endif
  82
  83 #ifndef _MEMORYREADWRITEBYTE_
  84 #define _MEMORYREADWRITEBYTE_
  85
  86 struct MemoryWriteByte
  87 {
  88         UINT32 lowAddr;
  89         UINT32 highAddr;
  90         void (*memoryCall)(UINT32, UINT8, struct MemoryWriteByte *);
  91         void *pUserArea;
  92 };
  93
  94 struct MemoryReadByte
  95 {
  96         UINT32 lowAddr;
  97         UINT32 highAddr;
  98         UINT8 (*memoryCall)(UINT32, struct MemoryReadByte *);
  99         void *pUserArea;
 100 };
 101
 102 #endif // _MEMORYREADWRITEBYTE_
 103
 104 struct z80PortWrite
 105 {
 106         UINT16 lowIoAddr;
 107         UINT16 highIoAddr;
 108         void (*IOCall)(UINT16, UINT8, struct z80PortWrite *);
 109         void *pUserArea;
 110 };
 111
 112 struct z80PortRead
 113 {
 114         UINT16 lowIoAddr;
 115         UINT16 highIoAddr;
 116         UINT16 (*IOCall)(UINT16, struct z80PortRead *);
 117         void *pUserArea;
 118 };
 119
 120 struct z80TrapRec
 121 {
 122         UINT16 trapAddr;
 123         UINT8  skipCnt;
 124         UINT8  origIns;
 125 };
 126
 127 typedef union
 128 {
 129         UINT32 af;
 130
 131         struct
 132         {
 133 #ifdef WORDS_BIGENDIAN
 134                 UINT16 wFiller;
 135                 UINT8 a;
 136                 UINT8 f;
 137 #else
 138                 UINT8 f;
 139                 UINT8 a;
 140                 UINT16 wFiller;
 141 #endif
 142         } half;
 143 } reg_af;
 144
 145 #define z80AF   z80af.af
 146 #define z80A    z80af.half.a
 147 #define z80F    z80af.half.f
 148
 149 typedef union
 150 {
 151         UINT32 bc;
 152
 153         struct
 154         {
 155 #ifdef WORDS_BIGENDIAN
 156                 UINT16 wFiller;
 157                 UINT8 b;
 158                 UINT8 c;
 159 #else
 160                 UINT8 c;
 161                 UINT8 b;
 162                 UINT16 wFiller;
 163 #endif
 164         } half;
 165 } reg_bc;
 166
 167 #define z80BC   z80bc.bc
 168 #define z80B    z80bc.half.b
 169 #define z80C    z80bc.half.c
 170
 171 typedef union
 172 {
 173         UINT32 de;
 174
 175         struct
 176         {
 177 #ifdef WORDS_BIGENDIAN
 178                 UINT16 wFiller;
 179                 UINT8 d;
 180                 UINT8 e;
 181 #else
 182                 UINT8 e;
 183                 UINT8 d;
 184                 UINT16 wFiller;
 185 #endif
 186         } half;
 187 } reg_de;
 188
 189 #define z80DE   z80de.de
 190 #define z80D    z80de.half.d
 191 #define z80E    z80de.half.e
 192
 193 typedef union
 194 {
 195         UINT32 hl;
 196
 197         struct
 198         {
 199 #ifdef WORDS_BIGENDIAN
 200                 UINT16 wFiller;
 201                 UINT8 h;
 202                 UINT8 l;
 203 #else
 204                 UINT8 l;
 205                 UINT8 h;
 206                 UINT16 wFiller;
 207 #endif
 208         } half;
 209 } reg_hl;
 210
 211 #define z80HL   z80hl.hl
 212 #define z80H    z80hl.half.h
 213 #define z80L    z80hl.half.l
 214
 215 #define z80SP   z80sp.sp
 216
 217 typedef union
 218 {
 219         UINT32 ix;
 220
 221         struct
 222         {
 223 #ifdef WORDS_BIGENDIAN
 224                 UINT16 wFiller;
 225                 UINT8 xh;
 226                 UINT8 xl;
 227 #else
 228                 UINT8 xl;
 229                 UINT8 xh;
 230                 UINT16 wFiller;
 231 #endif
 232         } half;
 233 } reg_ix;
 234
 235 #define z80IX   z80ix.ix
 236 #define z80XH   z80ix.half.xh
 237 #define z80XL   z80ix.half.xl
 238
 239 typedef union
 240 {
 241         UINT32 iy;
 242
 243         struct
 244         {
 245 #ifdef WORDS_BIGENDIAN
 246                 UINT16 wFiller;
 247                 UINT8 yh;
 248                 UINT8 yl;
 249 #else
 250                 UINT8 yl;
 251                 UINT8 yh;
 252                 UINT16 wFiller;
 253 #endif
 254         } half;
 255 } reg_iy;
 256
 257 #define z80IY   z80iy.iy
 258 #define z80YH   z80iy.half.yh
 259 #define z80YL   z80iy.half.yl
 260
 261 struct mz80context
 262 {
 263         UINT8 *z80Base;
 264         struct MemoryReadByte *z80MemRead;
 265         struct MemoryWriteByte *z80MemWrite;
 266         struct z80PortRead *z80IoRead;
 267         struct z80PortWrite *z80IoWrite;
 268         UINT32 z80clockticks;
 269         UINT32 z80iff;
 270         UINT32 z80interruptMode;
 271         UINT32 z80halted;
 272
 273         reg_af z80af;
 274         reg_bc z80bc;
 275         reg_de z80de;
 276         reg_hl z80hl;
 277         UINT32 z80afprime;
 278         UINT32 z80bcprime;
 279         UINT32 z80deprime;
 280         UINT32 z80hlprime;
 281         reg_ix z80ix;
 282         reg_iy z80iy;
 283         UINT32 z80sp;
 284         UINT32 z80pc;
 285         UINT32 z80nmiAddr;
 286         UINT32 z80intAddr;
 287         UINT32 z80rCounter;
 288         UINT8 z80i;
 289         UINT8 z80r;
 290         UINT8 z80intPending;
 291 };
 292
 293 // These are the enumerations used for register access. DO NOT ALTER THEIR
 294 // ORDER! It must match the same order as in the mz80.c/mz80.asm files!
 295
 296 enum
 297 {
 298 #ifndef CPUREG_PC
 299         CPUREG_PC = 0,
 300 #endif
 301         CPUREG_Z80_AF = 1,
 302         CPUREG_Z80_BC,
 303         CPUREG_Z80_DE,
 304         CPUREG_Z80_HL,
 305         CPUREG_Z80_AFPRIME,
 306         CPUREG_Z80_BCPRIME,
 307         CPUREG_Z80_DEPRIME,
 308         CPUREG_Z80_HLPRIME,
 309         CPUREG_Z80_IX,
 310         CPUREG_Z80_IY,
 311         CPUREG_Z80_SP,
 312         CPUREG_Z80_I,
 313         CPUREG_Z80_R,
 314         CPUREG_Z80_A,
 315         CPUREG_Z80_B,
 316         CPUREG_Z80_C,
 317         CPUREG_Z80_D,
 318         CPUREG_Z80_E,
 319         CPUREG_Z80_H,
 320         CPUREG_Z80_L,
 321         CPUREG_Z80_F,
 322         CPUREG_Z80_CARRY,
 323         CPUREG_Z80_NEGATIVE,
 324         CPUREG_Z80_PARITY,
 325         CPUREG_Z80_OVERFLOW,
 326         CPUREG_Z80_HALFCARRY,
 327         CPUREG_Z80_ZERO,
 328         CPUREG_Z80_SIGN,
 329         CPUREG_Z80_IFF1,
 330         CPUREG_Z80_IFF2,
 331
 332         // Leave this here!
 333
 334         CPUREG_Z80_MAX_INDEX
 335 };
 336
 337 extern UINT32 mz80exec(UINT32);
 338 extern UINT32 mz80GetContextSize(void);
 339 extern UINT32 mz80GetElapsedTicks(UINT32);
 340 extern void mz80ReleaseTimeslice(void);
 341 extern void mz80GetContext(void *);
 342 extern void mz80SetContext(void *);
 343 extern void mz80reset(void);
 344 extern void mz80ClearPendingInterrupt(void);
 345 extern UINT32 mz80int(UINT32);
 346 extern UINT32 mz80nmi(void);
 347 extern void mz80init(void);
 348 extern UINT32 z80intAddr;
 349 extern UINT32 z80nmiAddr;
 350
 351 // Debugger useful routines
 352
 353 extern UINT8 mz80SetRegisterValue(void *, UINT32, UINT32);
 354 extern UINT32 mz80GetRegisterValue(void *, UINT32);
 355 extern UINT32 mz80GetRegisterTextValue(void *, UINT32, UINT8 *);
 356 extern UINT8 *mz80GetRegisterName(UINT32);
 357
 358 // Memory/IO read/write commands
 359
 360 #ifndef VALUE_BYTE
 361 #define VALUE_BYTE      0
 362 #endif
 363
 364 #ifndef VALUE_WORD
 365 #define VALUE_WORD      1
 366 #endif
 367
 368 #ifndef VALUE_DWORD
 369 #define VALUE_DWORD     2
 370 #endif
 371
 372 #ifndef VALUE_IO
 373 #define VALUE_IO        3
 374 #endif
 375
 376 extern void mz80WriteValue(UINT8 bWhat, UINT32 dwAddr, UINT32 dwData);
 377 extern UINT32 mz80ReadValue(UINT8 bWhat, UINT32 dwAddr);
 378
 379 // Flag definitions
 380
 381 #define Z80_FLAG_CARRY                                  0x01
 382 #define Z80_FLAG_NEGATIVE                               0x02
 383 #define Z80_FLAG_OVERFLOW_PARITY        0x04
 384 #define Z80_FLAG_UNDEFINED1                     0x08
 385 #define Z80_FLAG_HALF_CARRY                     0x10
 386 #define Z80_FLAG_UNDEFINED2                     0x20
 387 #define Z80_FLAG_ZERO                                   0x40
 388 #define Z80_FLAG_SIGN                                   0x80
 389
 390 #define IFF1                    0x01
 391 #define IFF2                    0x02
 392
 393 typedef struct mz80context CONTEXTMZ80;
 394
 395 #ifdef __cplusplus
 396 }
 397 #endif
 398
 399 #endif  // _MZ80_H_