Return to bmap.c CVS log

Up to [Previous NeXT emulator] / previous / src

Annotation of previous/src/bmap.c, revision 1.1.1.1

1.1       root        1: #include "main.h"
                      2: #include "configuration.h"
                      3: #include "m68000.h"
                      4: #include "sysdeps.h"
                      5: #include "bmap.h"
                      6: 
                      7: 
                      8: /* NeXT bmap chip emulation */
                      9: 
                     10: 
                     11: uae_u32  NEXTbmap[16];
                     12: 
                     13: uae_u32 bmap_get(uae_u32 addr);
                     14: void bmap_put(uae_u32 addr, uae_u32 val);
                     15: 
                     16: 
                     17: #define BMAP_DATA_RW    0xD
                     18: 
                     19: #define BMAP_TP         0x90000000
                     20: 
                     21: uae_u32 bmap_lget(uaecptr addr) {
                     22:     if (addr%4) {
                     23:         Log_Printf(LOG_WARN, "[BMAP] Unaligned access.");
                     24:         abort();
                     25:     }
                     26: 
                     27:     return bmap_get(addr/4);
                     28: }
                     29: 
                     30: uae_u32 bmap_wget(uaecptr addr) {
                     31:     uae_u32 w = 0;
                     32:     uae_u32 val = bmap_get(addr/4);
                     33:     
                     34:     switch (addr%4) {
                     35:         case 0:
                     36:             w = val>>16;
                     37:             break;
                     38:         case 2:
                     39:             w = val;
                     40:             break;
                     41:         default:
                     42:             Log_Printf(LOG_WARN, "[BMAP] Unaligned access.");
                     43:             abort();
                     44:             break;
                     45:     }
                     46:     
                     47:     return w;
                     48: }
                     49: 
                     50: uae_u32 bmap_bget(uaecptr addr) {
                     51:     uae_u32 b = 0;
                     52:     uae_u32 val = bmap_get(addr/4);
                     53:     
                     54:     switch (addr%4) {
                     55:         case 0:
                     56:             b = val>>24;
                     57:             break;
                     58:         case 1:
                     59:             b = val>>16;
                     60:             break;
                     61:         case 2:
                     62:             b = val>>8;
                     63:             break;
                     64:         case 3:
                     65:             b = val;
                     66:             break;
                     67:         default:
                     68:             break;
                     69:     }
                     70:     
                     71:     return b;
                     72: }
                     73: 
                     74: void bmap_lput(uaecptr addr, uae_u32 l) {
                     75:     if (addr%4) {
                     76:         Log_Printf(LOG_WARN, "[BMAP] Unaligned access.");
                     77:         abort();
                     78:     }
                     79:         bmap_put(addr/4, l);
                     80: }
                     81: 
                     82: void bmap_wput(uaecptr addr, uae_u32 w) {
                     83:     uae_u32 val;
                     84:     
                     85:     switch (addr%4) {
                     86:         case 0:
                     87:             val = w<<16;
                     88:             break;
                     89:         case 2:
                     90:             val = w;
                     91:             break;
                     92:         default:
                     93:             Log_Printf(LOG_WARN, "[BMAP] Unaligned access.");
                     94:             abort();
                     95:             break;
                     96:     }
                     97:     
                     98:     bmap_put(addr/4, val);
                     99: }
                    100: 
                    101: void bmap_bput(uaecptr addr, uae_u32 b) {
                    102:     uae_u32 val = 0;
                    103:     
                    104:     switch (addr%4) {
                    105:         case 0:
                    106:             val = b<<24;
                    107:             break;
                    108:         case 1:
                    109:             val = b<<16;
                    110:             break;
                    111:         case 2:
                    112:             val = b<<8;
                    113:             break;
                    114:         case 3:
                    115:             val = b;
                    116:             break;
                    117:         default:
                    118:             break;
                    119:     }
                    120:     
                    121:     bmap_put(addr/4, val);
                    122: }
                    123: 
                    124: 
                    125: uae_u32 bmap_get(uae_u32 bmap_reg) {
                    126:     uae_u32 val;
                    127:     
                    128:     switch (bmap_reg) {
                    129:         case BMAP_DATA_RW:
                    130:             /* This is for detecing thin wire ethernet.
                    131:              * It prevents from switching ethernet
                    132:              * transceiver to loopback mode.
                    133:              */
                    134:             val = NEXTbmap[BMAP_DATA_RW]|0x20000000;
                    135:             break;
                    136:             
                    137:         default:
                    138:             val = NEXTbmap[bmap_reg];
                    139:             break;
                    140:     }
                    141:     
                    142:     return val;
                    143: }
                    144: 
                    145: void bmap_put(uae_u32 bmap_reg, uae_u32 val) {
                    146:     switch (bmap_reg) {
                    147:         case BMAP_DATA_RW:
                    148:             if ((val&BMAP_TP) != (NEXTbmap[bmap_reg]&BMAP_TP)) {
                    149:                 if ((val&BMAP_TP)==BMAP_TP) {
                    150:                     Log_Printf(LOG_WARN, "[BMAP] Switching to twisted pair ethernet.");
                    151:                 } else if ((val&BMAP_TP)==0) {
                    152:                     Log_Printf(LOG_WARN, "[BMAP] Switching to thin ethernet.");
                    153:                 }
                    154:             }
                    155:             break;
                    156:             
                    157:         default:
                    158:             break;
                    159:     }
                    160:     
                    161:     NEXTbmap[bmap_reg] = val;
                    162: }

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