Return to mem68k.h CVS log

Up to [Generator SEGA Genesis emulator] / generator / hdr

Annotation of generator/hdr/mem68k.h, revision 1.1.1.2

1.1       root        1: typedef enum {
                      2:   mem_byte, mem_word, mem_long
                      3: } t_memtype;
                      4: 
                      5: typedef struct {
                      6:   uint16 start;
                      7:   uint16 end;
                      8:   uint8 *(*memptr)(uint32 addr);
                      9:   uint8 (*fetch_byte)(uint32 addr);
                     10:   uint16 (*fetch_word)(uint32 addr);
                     11:   uint32 (*fetch_long)(uint32 addr);
                     12:   void (*store_byte)(uint32 addr, uint8 data);
                     13:   void (*store_word)(uint32 addr, uint16 data);
                     14:   void (*store_long)(uint32 addr, uint32 data);
                     15: } t_mem68k_def;
                     16: 
1.1.1.2 ! root       17: typedef struct {
        !            18:   unsigned int a;
        !            19:   unsigned int b;
        !            20:   unsigned int c;
        !            21:   unsigned int up;
        !            22:   unsigned int down;
        !            23:   unsigned int left;
        !            24:   unsigned int right;
        !            25:   unsigned int start;
        !            26: } t_keys;
        !            27: 
1.1       root       28: extern t_mem68k_def mem68k_def[];
1.1.1.2 ! root       29: extern t_keys mem68k_cont[2];
1.1       root       30: 
                     31: int mem68k_init(void);
                     32: 
                     33: extern uint8 *(*mem68k_memptr[0x1000])(uint32 addr);
                     34: extern uint8 (*mem68k_fetch_byte[0x1000])(uint32 addr);
                     35: extern uint16 (*mem68k_fetch_word[0x1000])(uint32 addr);
                     36: extern uint32 (*mem68k_fetch_long[0x1000])(uint32 addr);
                     37: extern void (*mem68k_store_byte[0x1000])(uint32 addr, uint8 data);
                     38: extern void (*mem68k_store_word[0x1000])(uint32 addr, uint16 data);
                     39: extern void (*mem68k_store_long[0x1000])(uint32 addr, uint32 data);
                     40: 
                     41: #define fetchbyte(addr) mem68k_fetch_byte[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF)
                     42: #define fetchword(addr) mem68k_fetch_word[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF)
                     43: #define fetchlong(addr) mem68k_fetch_long[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF)
                     44: 
1.1.1.2 ! root       45: /* XXX BUG: these direct routines do not check for over-run of the 64k
        !            46:    cpu68k_ram block - so writing a long at $FFFF corrupts 3 bytes of data -
        !            47:    this is compensated for in the malloc() but is bad nonetheless. */
        !            48: 
        !            49: #ifdef DIRECTRAM
        !            50: 
        !            51: /* chances are a store is to RAM - optimise for this case */
        !            52: 
        !            53: static __inline__ void storebyte(uint32 addr, uint8 data)
        !            54: {
        !            55:   if ((addr & 0xE00000) == 0xE00000) {
        !            56:     addr&= 0xffff;
        !            57:     *(uint8 *)(cpu68k_ram + addr) = data;
        !            58:   } else {
        !            59:     mem68k_store_byte[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF,data);
        !            60:   }
        !            61: }
        !            62: 
        !            63: static __inline__ void storeword(uint32 addr, uint16 data)
        !            64: {
        !            65:   /* in an ideal world we'd check bit 0 of addr, but speed is everything */
        !            66:   if ((addr & 0xE00000) == 0xE00000) {
        !            67:     addr&= 0xffff;
        !            68:     *(uint16 *)(cpu68k_ram + addr) = LOCENDIAN16(data);
        !            69:   } else {
        !            70:     mem68k_store_word[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF,data);
        !            71:   }
        !            72: }
        !            73: 
        !            74: static __inline__ void storelong(uint32 addr, uint32 data)
        !            75: {
        !            76:   /* in an ideal world we'd check bit 0 of addr, but speed is everything */
        !            77:   if ((addr & 0xE00000) == 0xE00000) {
        !            78:     addr&= 0xffff;
        !            79: #ifdef ALIGNLONGS
        !            80:     *(uint16 *)(cpu68k_ram + addr) = LOCENDIAN16((uint16)(data >> 16));
        !            81:     *(uint16 *)(cpu68k_ram + addr + 2) = LOCENDIAN16((uint16)(data));
        !            82: #else
        !            83:     *(uint32 *)(cpu68k_ram + addr) = LOCENDIAN32(data);
        !            84: #endif
        !            85:   } else {
        !            86:     mem68k_store_long[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF,data);
        !            87:   }
        !            88: }
        !            89: 
        !            90: #else
        !            91: 
1.1       root       92: #define storebyte(addr,data) mem68k_store_byte[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF,data)
                     93: #define storeword(addr,data) mem68k_store_word[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF,data)
                     94: #define storelong(addr,data) mem68k_store_long[((addr) & 0xFFFFFF)>>12]((addr) & 0xFFFFFF,data)
1.1.1.2 ! root       95: 
        !            96: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.