src/emu/cpu/tms0980/tms0980.c
| r0 | r5090 | |
| 1 | /* |
| 2 | |
| 3 | This CPU core has not been thoroughly tested. Several features may still be |
| 4 | incomplete, missing, or broken. [Wilbert Pol] |
| 5 | |
| 6 | |
| 7 | TMS0980 CPU core |
| 8 | |
| 9 | Each instruction takes 12 cycles to execute in 2 phases: a fetch phase and an |
| 10 | execution phase. The execution phase takes place at the same time as the fetch |
| 11 | phase of the next instruction. So, during execution there are both fetch and |
| 12 | execution operations taking place. The operation can be split up as follows: |
| 13 | cycle #0 |
| 14 | - Fetch: |
| 15 | 1. ROM address 0 |
| 16 | - Execute: |
| 17 | 1. Read RAM |
| 18 | 2. Clear ALU inputs |
| 19 | 3. Execute BRANCH/CALL/RETN part #2 |
| 20 | 4. K input valid |
| 21 | cycle #1 |
| 22 | - Fetch: |
| 23 | 1. ROM address 1 |
| 24 | - Execute: |
| 25 | 1. Update ALU inputs |
| 26 | cycle #2 |
| 27 | - Fetch: |
| 28 | 1. nothing/wait(?) |
| 29 | - Execute: |
| 30 | 1. Perform ALU operation |
| 31 | 2. Write RAM |
| 32 | cycle #3 |
| 33 | - Fetch: |
| 34 | 1. Fetch/Update PC/RAM address #1 |
| 35 | - Execute: |
| 36 | 1. Register store part #1 |
| 37 | cycle #4 |
| 38 | - Fetch: |
| 39 | 1. Fetch/Update PC/RAM address #2 |
| 40 | - Execute: |
| 41 | 1. Register store part #2 |
| 42 | cycle #5 |
| 43 | - Fetch: |
| 44 | 1. Instruction decode |
| 45 | - Execute: |
| 46 | 1. Execute BRANCH/CALL/RETN part #1 |
| 47 | |
| 48 | Instructions built from microinstructions: |
| 49 | |
| 50 | ACACC 000111011* CKP, ATN, C8, AUTA |
| 51 | 00111cccc |
| 52 | ACNAA 000111100* CKP, NATN, AUTA |
| 53 | 01100cccc |
| 54 | ALEC 000111110* CIN, CKP, NATN, C8 |
| 55 | 01110cccc |
| 56 | ALEM 000000001 MTP, NATN, CIN, C8 |
| 57 | AMAAC 000010101 ATN, MTP, C8, AUTA |
| 58 | BRANCH 10wwwwwww no microinstructions |
| 59 | CALL 11wwwwwww no microinstructions |
| 60 | CCLA 000010010 AUTA, SSS |
| 61 | CLA 000000110 AUTA |
| 62 | COMX 000000000 no microinstructions |
| 63 | COMX8 010110010 no microinstructions |
| 64 | CPAIZ 000110001 NATN, CIN, C8, AUTA |
| 65 | CTMDYN 000011000 YTP, 15TN, C8, CME, AUTY |
| 66 | DMAN 000000111 MTP, 15TN, C8, AUTA |
| 67 | DMEA 000010000 MTP, DMTP, SSS, AUTA |
| 68 | DNAA 000010001 DMTP, NATN, SSS, AUTA |
| 69 | DYN 000000100 YTP, 15TN, C8, AUTY |
| 70 | IMAC 000110010 MTP, CIN, C8, AUTA |
| 71 | IYC 000000101 YTP, CIN, C8, AUTY |
| 72 | KNEZ 000001110 CKP, NE |
| 73 | LDP 01000cccc no microinstructions |
| 74 | LDX 01001cccc no microinstructions |
| 75 | MNEA 000001001 MTP, ATN, NE |
| 76 | MNEZ 000110011 MTP, NE |
| 77 | NDMEA 000010011 MTN, NDMTP, SSS, AUTA |
| 78 | OFF 010110110 |
| 79 | RBIT 0101001bb no microinstructions |
| 80 | REAC 010110100 no microinstructions |
| 81 | RETN 010111111 no microinstructions |
| 82 | SAL 010110001 no microinstructions |
| 83 | SAMAN 000110000 MTP, NATN, CIN, C8, AUTA |
| 84 | SBIT 0101000bb no microinstructions |
| 85 | SBL 010110011 no microinstructions |
| 86 | SEAC 010110101 no microinstructions |
| 87 | SETR 000001101 YTP, 15TN, AUTY, C8 |
| 88 | TAM 000101111 STO |
| 89 | TAMACS 000111101* STO, ATN, CKP, AUTA, SSE |
| 90 | 01101cccc |
| 91 | TAMDYN 000101100 STO, YTP, 15TN, AUTY, C8 |
| 92 | TAMIYC 000101101 STO, YTP, CIN, C8, AUTY |
| 93 | TAMZA 000101110 STO, AUTA |
| 94 | TAY 000101000 ATN, AUTY |
| 95 | TBIT 0001000bb CKP, CKN, MTP, NE |
| 96 | TCMIY 000111010* CKM, YTP, CIN, AUTY |
| 97 | 00110cccc |
| 98 | TCY 000111000* CKP, AUTY |
| 99 | 00100cccc |
| 100 | TDO 010110000 no microinstructions |
| 101 | TKA 000001000 CKP, AUTA |
| 102 | TKM 000001010 CKM |
| 103 | TMA 000101001 MTP, AUTA |
| 104 | TMY 000101010 MTP, AUTY |
| 105 | TYA 000101011 YTP, AUTA |
| 106 | XDA 000011001 DMTP, AUTA, STO |
| 107 | XMA 000000011 MTP, STO, AUTA |
| 108 | YMCY 000111111* CIN, YTP, CKN, AUTY |
| 109 | 01111cccc |
| 110 | YNEA 000000010 YTP, ATN, NE |
| 111 | YNEC 000111001* YTP, CKN, NE |
| 112 | 00101cccc |
| 113 | * = faked/special decode variant of instruction |
| 114 | |
| 115 | Microinstructions: |
| 116 | 15TN - 15 to -ALU |
| 117 | ATN - ACC to -ALU |
| 118 | AUTA - ALU to ACC |
| 119 | AUTY - ALU to Y |
| 120 | C8 - CARRY8 to STATUS |
| 121 | CIN - Carry In to ALU |
| 122 | CKM - CKB to MEM |
| 123 | CKN - CKB to -ALU |
| 124 | CKP - CKB to +ALU |
| 125 | CME - Conditional Memory Enable |
| 126 | DMTP - DAM to +ALU |
| 127 | MTN - MEM to -ALU |
| 128 | MTP - MEM to +ALU |
| 129 | NATN - ~ACC to -ALU |
| 130 | NDMTP - ~DAM to +ALU |
| 131 | NE - COMP to STATUS |
| 132 | SSE - Special Status Enable |
| 133 | SSS - Special Status Sample |
| 134 | STO - ACC to MEM |
| 135 | YTP - Y to +ALU |
| 136 | |
| 137 | cycle #0: 15TN, ATN, CIN, CKN, CKP, DMTP, MTN, MTP, NATN, NDMTP, YTP |
| 138 | cycle #2: C8(?), CKM, NE(?), STO |
| 139 | cycle #3,#4: AUTA, AUTY |
| 140 | |
| 141 | unknown: CME, SSE, SSS |
| 142 | |
| 143 | */ |
| 144 | |
| 145 | #include "debugger.h" |
| 146 | #include "tms0980.h" |
| 147 | #include "deprecat.h" |
| 148 | |
| 149 | #define LOG 1 |
| 150 | |
| 151 | #define MICRO_MASK 0x80000000 |
| 152 | #define FIXED_INSTRUCTION 0x00000000 |
| 153 | |
| 154 | /* Standard/fixed intructions */ |
| 155 | #define F_ILL 0x00000000 |
| 156 | #define F_BR 0x00000001 |
| 157 | #define F_CALL 0x00000002 |
| 158 | #define F_CLO 0x00000004 |
| 159 | #define F_COMX 0x00000008 |
| 160 | #define F_COMX8 0x00000010 |
| 161 | #define F_LDP 0x00000020 |
| 162 | #define F_LDX 0x00000040 |
| 163 | #define F_OFF 0x00000080 |
| 164 | #define F_RBIT 0x00000100 |
| 165 | #define F_REAC 0x00000200 |
| 166 | #define F_RETN 0x00000400 |
| 167 | #define F_SAL 0x00000800 |
| 168 | #define F_SBIT 0x00001000 |
| 169 | #define F_SBL 0x00002000 |
| 170 | #define F_SEAC 0x00004000 |
| 171 | #define F_SETR 0x00008000 |
| 172 | #define F_TDO 0x00010000 |
| 173 | |
| 174 | /* Microinstructions */ |
| 175 | #define M_15TN 0x00000001 |
| 176 | #define M_ATN 0x00000002 |
| 177 | #define M_AUTA 0x00000004 |
| 178 | #define M_AUTY 0x00000008 |
| 179 | #define M_C8 0x00000010 |
| 180 | #define M_CIN 0x00000020 |
| 181 | #define M_CKM 0x00000040 |
| 182 | #define M_CKN 0x00000080 |
| 183 | #define M_CKP 0x00000100 |
| 184 | #define M_CME 0x00000200 |
| 185 | #define M_DMTP 0x00000400 |
| 186 | #define M_MTN 0x00000800 |
| 187 | #define M_MTP 0x00001000 |
| 188 | #define M_NATN 0x00002000 |
| 189 | #define M_NDMTP 0x00004000 |
| 190 | #define M_NE 0x00008000 |
| 191 | #define M_SSE 0x00010000 |
| 192 | #define M_SSS 0x00020000 |
| 193 | #define M_STO 0x00040000 |
| 194 | #define M_YTP 0x00080000 |
| 195 | |
| 196 | /* instructions built from microinstructions */ |
| 197 | #define I_ACACC ( MICRO_MASK | M_CKP | M_ATN | M_C8 | M_AUTA ) |
| 198 | #define I_ACNAA ( MICRO_MASK | M_CKP | M_NATN | M_AUTA ) |
| 199 | #define I_ALEC ( MICRO_MASK | M_CKP | M_NATN | M_CIN | M_C8 ) |
| 200 | #define I_ALEM ( MICRO_MASK | M_MTP | M_NATN | M_CIN | M_C8 ) |
| 201 | #define I_AMAAC ( MICRO_MASK | M_MTP | M_ATN | M_C8 | M_AUTA ) |
| 202 | #define I_CCLA ( MICRO_MASK | M_AUTA | M_SSS ) |
| 203 | #define I_CLA ( MICRO_MASK | M_AUTA ) |
| 204 | #define I_CPAIZ ( MICRO_MASK | M_NATN | M_CIN | M_C8 | M_AUTA ) |
| 205 | #define I_CTMDYN ( MICRO_MASK | M_YTP | M_15TN | M_C8 | M_AUTY | M_CME ) |
| 206 | #define I_DMAN ( MICRO_MASK | M_MTP | M_15TN | M_C8 | M_AUTA ) |
| 207 | #define I_DMEA ( MICRO_MASK | M_MTP | M_DMTP | M_SSS | M_AUTA ) |
| 208 | #define I_DNAA ( MICRO_MASK | M_DMTP | M_NATN | M_SSS | M_AUTA ) |
| 209 | #define I_DYN ( MICRO_MASK | M_YTP | M_15TN | M_C8 | M_AUTY ) |
| 210 | #define I_IMAC ( MICRO_MASK | M_MTP | M_CIN | M_C8 | M_AUTA ) |
| 211 | #define I_IYC ( MICRO_MASK | M_YTP | M_CIN | M_C8 | M_AUTY ) |
| 212 | #define I_KNEZ ( MICRO_MASK | M_CKP | M_NE ) |
| 213 | #define I_MNEA ( MICRO_MASK | M_MTP | M_ATN | M_NE ) |
| 214 | #define I_MNEZ ( MICRO_MASK | M_MTP | M_NE ) |
| 215 | #define I_M_NDMEA ( MICRO_MASK | M_MTN | M_NDTMP | M_SSS | M_AUTA ) |
| 216 | #define I_SAMAN ( MICRO_MASK | M_MTP | M_NATN | M_CIN | M_C8 | M_AUTA ) |
| 217 | #define I_SETR ( MICRO_MASK | M_YTP | M_15TN | M_AUTY | M_C8 ) |
| 218 | #define I_TAM ( MICRO_MASK | M_STO ) |
| 219 | #define I_TAMACS ( MICRO_MASK | M_STO | M_ATN | M_CKP | M_AUTA | M_SSE ) |
| 220 | #define I_TAMDYN ( MICRO_MASK | M_STO | M_YTP | M_15TN | M_AUTY | M_C8 ) |
| 221 | #define I_TAMIYC ( MICRO_MASK | M_STO | M_YTP | M_CIN | M_C8 | M_AUTY ) |
| 222 | #define I_TAMZA ( MICRO_MASK | M_STO | M_AUTA ) |
| 223 | #define I_TAY ( MICRO_MASK | M_ATN | M_AUTY ) |
| 224 | #define I_TBIT ( MICRO_MASK | M_CKP | M_CKN | M_MTP | M_NE ) |
| 225 | #define I_TCY ( MICRO_MASK | M_CKP | M_AUTY ) |
| 226 | #define I_TCMIY ( MICRO_MASK | M_CKM | M_YTP | M_CIN | M_AUTY ) |
| 227 | #define I_TKA ( MICRO_MASK | M_CKP | M_AUTA ) |
| 228 | #define I_TKM ( MICRO_MASK | M_CKM ) |
| 229 | #define I_TMA ( MICRO_MASK | M_MTP | M_AUTA ) |
| 230 | #define I_TMY ( MICRO_MASK | M_MTP | M_AUTY ) |
| 231 | #define I_TYA ( MICRO_MASK | M_YTP | M_AUTA ) |
| 232 | #define I_XDA ( MICRO_MASK | M_DMTP | M_AUTA | M_STO ) |
| 233 | #define I_XMA ( MICRO_MASK | M_MTP | M_STO | M_AUTA ) |
| 234 | #define I_YMCY ( MICRO_MASK | M_CIN | M_YTP | M_CKN | M_AUTY ) |
| 235 | #define I_YNEA ( MICRO_MASK | M_YTP | M_ATN | M_NE ) |
| 236 | #define I_YNEC ( MICRO_MASK | M_YTP | M_CKN | M_NE ) |
| 237 | |
| 238 | |
| 239 | typedef struct _tms0980_state tms0980_state; |
| 240 | struct _tms0980_state |
| 241 | { |
| 242 | UINT8 prev_pc; /* previous program counter */ |
| 243 | UINT8 prev_pa; /* previous page address register */ |
| 244 | UINT8 pc; /* program counter is a 7 bit register */ |
| 245 | UINT8 pa; /* page address register is a 4 bit register */ |
| 246 | UINT8 sr; /* subroutine return register is a 7 bit register */ |
| 247 | UINT8 pb; /* page buffer register is a 4 bit register */ |
| 248 | UINT8 a; /* Accumulator is a 4 bit register (?) */ |
| 249 | UINT8 x; /* X-register is a 2 bit register */ |
| 250 | UINT8 y; /* Y-register is a 4 bit register */ |
| 251 | UINT8 dam; /* DAM register is a 4 bit register */ |
| 252 | UINT16 r; |
| 253 | UINT8 o; |
| 254 | UINT8 cki_bus; /* CKI bus */ |
| 255 | UINT8 p; /* adder p-input */ |
| 256 | UINT8 n; /* adder n-input */ |
| 257 | UINT8 adder_result; /* adder result */ |
| 258 | UINT8 carry_in; /* carry in */ |
| 259 | UINT8 status; |
| 260 | UINT8 status_latch; |
| 261 | UINT8 special_status; |
| 262 | UINT8 call_latch; |
| 263 | UINT8 add_latch; |
| 264 | UINT8 branch_latch; |
| 265 | read8_device_func read_k; |
| 266 | write8_device_func write_o; |
| 267 | write16_device_func write_r; |
| 268 | int subcycle; |
| 269 | UINT8 ram_address; |
| 270 | UINT16 ram_data; |
| 271 | UINT16 rom_address; |
| 272 | UINT16 opcode; |
| 273 | UINT32 decode; |
| 274 | int icount; |
| 275 | const tms0980_config *config; |
| 276 | const address_space *program; |
| 277 | const address_space *data; |
| 278 | }; |
| 279 | |
| 280 | |
| 281 | static const UINT8 tms0980_c_value[16] = |
| 282 | { |
| 283 | 0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F |
| 284 | }; |
| 285 | static const UINT8 tms0980_bit_value[4] = { 1, 4, 2, 8 }; |
| 286 | static const UINT8 tms0980_nbit_value[4] = { 0x0E, 0x0B, 0x0D, 0x07 }; |
| 287 | |
| 288 | |
| 289 | static const UINT32 tms0980_decode[512] = |
| 290 | { |
| 291 | /* 0x000 */ |
| 292 | F_COMX, I_ALEM, I_YNEA, I_XMA, I_DYN, I_IYC, I_CLA, I_DMAN, |
| 293 | I_TKA, I_MNEA, I_TKM, F_ILL, F_ILL, F_SETR, I_KNEZ, F_ILL, |
| 294 | I_DMEA, I_DNAA, I_CCLA, I_DMEA, F_ILL, I_AMAAC, F_ILL, F_ILL, |
| 295 | I_CTMDYN, I_XDA, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, |
| 296 | I_TBIT, I_TBIT, I_TBIT, I_TBIT, F_ILL, F_ILL, F_ILL, F_ILL, |
| 297 | I_TAY, I_TMA, I_TMY, I_TYA, I_TAMDYN, I_TAMIYC, I_TAMZA, I_TAM, |
| 298 | I_SAMAN, I_CPAIZ, I_IMAC, I_MNEZ, F_ILL, F_ILL, F_ILL, F_ILL, |
| 299 | I_TCY, I_YNEC, I_TCMIY, I_ACACC, I_ACNAA, I_TAMACS, I_ALEC, I_YMCY, |
| 300 | /* 0x040 */ |
| 301 | I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, |
| 302 | I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, I_TCY, |
| 303 | I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, |
| 304 | I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, I_YNEC, |
| 305 | I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, |
| 306 | I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, I_TCMIY, |
| 307 | I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, |
| 308 | I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, I_ACACC, |
| 309 | /* 0x080 */ |
| 310 | F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, |
| 311 | F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, F_LDP, |
| 312 | F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, |
| 313 | F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, F_LDX, |
| 314 | F_SBIT, F_SBIT, F_SBIT, F_SBIT, F_RBIT, F_RBIT, F_RBIT, F_RBIT, |
| 315 | F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, |
| 316 | F_TDO, F_SAL, F_COMX8, F_SBL, F_REAC, F_SEAC, F_OFF, F_ILL, |
| 317 | F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_ILL, F_RETN, |
| 318 | /* 0x0c0 */ |
| 319 | I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, |
| 320 | I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, I_ACNAA, |
| 321 | I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, |
| 322 | I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, I_TAMACS, |
| 323 | I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, |
| 324 | I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, I_ALEC, |
| 325 | I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, |
| 326 | I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, I_YMCY, |
| 327 | /* 0x100 */ |
| 328 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 329 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 330 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 331 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 332 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 333 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 334 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 335 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 336 | /* 0x140 */ |
| 337 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 338 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 339 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 340 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 341 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 342 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 343 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 344 | F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, F_BR, |
| 345 | /* 0x180 */ |
| 346 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 347 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 348 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 349 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 350 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 351 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 352 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 353 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 354 | /* 0x1c0 */ |
| 355 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 356 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 357 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 358 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 359 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 360 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 361 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, |
| 362 | F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL, F_CALL |
| 363 | }; |
| 364 | |
| 365 | |
| 366 | INLINE tms0980_state *get_safe_token(const device_config *device) |
| 367 | { |
| 368 | assert(device != NULL); |
| 369 | assert(device->token != NULL); |
| 370 | assert(device->type == CPU); |
| 371 | assert(cpu_get_type(device) == CPU_TMS0980); |
| 372 | return (tms0980_state *)device->token; |
| 373 | } |
| 374 | |
| 375 | |
| 376 | static ADDRESS_MAP_START(tms0980_internal_rom, ADDRESS_SPACE_PROGRAM, 16) |
| 377 | AM_RANGE( 0x0000, 0x07FF ) AM_ROM |
| 378 | ADDRESS_MAP_END |
| 379 | |
| 380 | |
| 381 | static ADDRESS_MAP_START(tms0980_internal_ram, ADDRESS_SPACE_DATA, 8) |
| 382 | AM_RANGE( 0x0000, 0x0FFF ) AM_RAM |
| 383 | ADDRESS_MAP_END |
| 384 | |
| 385 | |
| 386 | static CPU_INIT( tms0980 ) |
| 387 | { |
| 388 | tms0980_state *cpustate = get_safe_token( device ); |
| 389 | |
| 390 | cpustate->config = (const tms0980_config *) device->static_config; |
| 391 | |
| 392 | cpustate->program = memory_find_address_space( device, ADDRESS_SPACE_PROGRAM ); |
| 393 | cpustate->data = memory_find_address_space( device, ADDRESS_SPACE_DATA ); |
| 394 | |
| 395 | state_save_register_device_item( device, 0, cpustate->prev_pc ); |
| 396 | state_save_register_device_item( device, 0, cpustate->prev_pa ); |
| 397 | state_save_register_device_item( device, 0, cpustate->pc ); |
| 398 | state_save_register_device_item( device, 0, cpustate->pa ); |
| 399 | state_save_register_device_item( device, 0, cpustate->sr ); |
| 400 | state_save_register_device_item( device, 0, cpustate->pb ); |
| 401 | state_save_register_device_item( device, 0, cpustate->a ); |
| 402 | state_save_register_device_item( device, 0, cpustate->x ); |
| 403 | state_save_register_device_item( device, 0, cpustate->y ); |
| 404 | state_save_register_device_item( device, 0, cpustate->dam ); |
| 405 | state_save_register_device_item( device, 0, cpustate->r ); |
| 406 | state_save_register_device_item( device, 0, cpustate->o ); |
| 407 | state_save_register_device_item( device, 0, cpustate->cki_bus ); |
| 408 | state_save_register_device_item( device, 0, cpustate->p ); |
| 409 | state_save_register_device_item( device, 0, cpustate->n ); |
| 410 | state_save_register_device_item( device, 0, cpustate->adder_result ); |
| 411 | state_save_register_device_item( device, 0, cpustate->carry_in ); |
| 412 | state_save_register_device_item( device, 0, cpustate->status ); |
| 413 | state_save_register_device_item( device, 0, cpustate->status_latch ); |
| 414 | state_save_register_device_item( device, 0, cpustate->special_status ); |
| 415 | state_save_register_device_item( device, 0, cpustate->call_latch ); |
| 416 | state_save_register_device_item( device, 0, cpustate->add_latch ); |
| 417 | state_save_register_device_item( device, 0, cpustate->branch_latch ); |
| 418 | state_save_register_device_item( device, 0, cpustate->subcycle ); |
| 419 | state_save_register_device_item( device, 0, cpustate->ram_address ); |
| 420 | state_save_register_device_item( device, 0, cpustate->ram_data ); |
| 421 | state_save_register_device_item( device, 0, cpustate->rom_address ); |
| 422 | state_save_register_device_item( device, 0, cpustate->opcode ); |
| 423 | state_save_register_device_item( device, 0, cpustate->decode ); |
| 424 | } |
| 425 | |
| 426 | |
| 427 | static CPU_RESET( tms0980 ) |
| 428 | { |
| 429 | tms0980_state *cpustate = get_safe_token( device ); |
| 430 | |
| 431 | cpustate->pa = 0x0F; |
| 432 | cpustate->pb = 0x0F; |
| 433 | cpustate->pc = 0; |
| 434 | cpustate->dam = 0; |
| 435 | cpustate->subcycle = 0; |
| 436 | cpustate->status = 1; |
| 437 | cpustate->call_latch = 0; |
| 438 | cpustate->add_latch = 0; |
| 439 | cpustate->branch_latch = 0; |
| 440 | cpustate->r = 0; |
| 441 | cpustate->o = 0; |
| 442 | cpustate->ram_address = 0; |
| 443 | cpustate->decode = 0; |
| 444 | cpustate->opcode = 0; |
| 445 | cpustate->read_k = NULL; |
| 446 | cpustate->write_o = NULL; |
| 447 | cpustate->write_r = NULL; |
| 448 | if ( cpustate->config ) |
| 449 | { |
| 450 | cpustate->read_k = cpustate->config->read_k; |
| 451 | cpustate->write_o = cpustate->config->write_o; |
| 452 | cpustate->write_r = cpustate->config->write_r; |
| 453 | } |
| 454 | } |
| 455 | |
| 456 | |
| 457 | /* emulator for the program counter increment on the tms0980/tmc0980 mcu; |
| 458 | see patent 4064554 figure 19 (on page 13) for an explanation of feedback: |
| 459 | |
| 460 | nand324 = NAND of PC0 thru pc4, i.e. output is true if ((pc&0x1f) != 0x1f) |
| 461 | nand323 = NAND of pc5, pc6 and nand324 |
| 462 | i.e. output is true, if ((pc&0x1f)==0x1f) || pc5 is 0 || pc 6 is 0 |
| 463 | or321 = OR of pc5 and pc6, i.e. output is true if ((pc&0x60) != 0) |
| 464 | nand322 = NAND of pc0 thru pc5 plus /pc6, |
| 465 | i.e. output is true if (pc != 0x3f) |
| 466 | nand325 = nand pf nand323, or321 and nand322 |
| 467 | This one is complex: |
| 468 | / or321 means if pc&0x60 is zero, output MUST be true |
| 469 | \ nand323 means if (pc&0x60=0x60) && (pc&0x1f != 0x1f), output MUST be true |
| 470 | nand322 means if pc = 0x3f, output MUST be true |
| 471 | hence, nand325 is if pc = 0x7f, false. if pc = 0x3f, true. if pc&0x60 is zero OR pc&0x60 is 0x60, true. otherwise, false. |
| 472 | |
| 473 | tms0980_nect_pc below implements an indentical function to this in a somewhat more elegant way. |
| 474 | */ |
| 475 | INLINE UINT8 tms0980_next_pc( UINT8 pc ) |
| 476 | { |
| 477 | UINT8 xor = ( pc & 0x3F ) == 0x3F ? 1 : 0; |
| 478 | UINT8 new_bit = ( ( pc ^ ( pc << 1 ) ) & 0x40 ) ? xor : 1 - xor; |
| 479 | |
| 480 | return ( pc << 1 ) | new_bit; |
| 481 | } |
| 482 | |
| 483 | |
| 484 | static void tms0980_set_cki_bus( const device_config *device ) |
| 485 | { |
| 486 | tms0980_state *cpustate = get_safe_token( device ); |
| 487 | |
| 488 | switch( cpustate->opcode & 0xF8 ) |
| 489 | { |
| 490 | case 0x08: |
| 491 | if ( cpustate->read_k ) |
| 492 | { |
| 493 | cpustate->cki_bus = cpustate->read_k( device, 0 ); |
| 494 | } |
| 495 | else |
| 496 | { |
| 497 | cpustate->cki_bus = 0x0F; |
| 498 | } |
| 499 | break; |
| 500 | case 0x20: case 0x28: |
| 501 | cpustate->cki_bus = 0; |
| 502 | break; |
| 503 | case 0x30: |
| 504 | case 0x38: |
| 505 | cpustate->cki_bus = tms0980_nbit_value[ cpustate->opcode & 0x03 ]; |
| 506 | break; |
| 507 | case 0x00: |
| 508 | case 0x40: case 0x48: |
| 509 | case 0x50: case 0x58: |
| 510 | case 0x60: case 0x68: |
| 511 | case 0x70: case 0x78: |
| 512 | cpustate->cki_bus = tms0980_c_value[ cpustate->opcode & 0x0F ]; |
| 513 | break; |
| 514 | } |
| 515 | cpustate->cki_bus = 0x0F; |
| 516 | /* Case 000001XXX */ |
| 517 | if ( ( cpustate->opcode & 0x1F8 ) == 0x008 ) |
| 518 | { |
| 519 | } |
| 520 | /* Case 00001XXXX */ |
| 521 | if ( ( cpustate->opcode & 0x1F0 ) == 0x010 ) |
| 522 | { |
| 523 | } |
| 524 | /* Case 00100XXXX - TCY */ |
| 525 | if ( ( cpustate->opcode & 0x1F0 ) == 0x040 ) |
| 526 | { |
| 527 | } |
| 528 | /* Case 01XXXXXXX */ |
| 529 | if ( ( cpustate->opcode & 0x180 ) == 0x080 ) |
| 530 | { |
| 531 | } |
| 532 | } |
| 533 | |
| 534 | |
| 535 | static CPU_EXECUTE( tms0980 ) |
| 536 | { |
| 537 | tms0980_state *cpustate = get_safe_token( device ); |
| 538 | |
| 539 | cpustate->icount = cycles; |
| 540 | |
| 541 | do |
| 542 | { |
| 543 | // debugger_instruction_hook( device, ( ( cpustate->pa << 7 ) | cpustate->pc ) << 1 ); |
| 544 | cpustate->icount--; |
| 545 | switch( cpustate->subcycle ) |
| 546 | { |
| 547 | case 0: |
| 548 | /* fetch: rom address 0 */ |
| 549 | /* execute: read ram, alu input, execute br/call, k input valid */ |
| 550 | tms0980_set_cki_bus( device ); |
| 551 | cpustate->ram_data = memory_read_byte_8le( cpustate->data, cpustate->ram_address ); |
| 552 | cpustate->status = 1; |
| 553 | cpustate->p = 0; |
| 554 | cpustate->n = 0; |
| 555 | cpustate->carry_in = 0; |
| 556 | break; |
| 557 | case 1: |
| 558 | /* fetch: rom address 1 */ |
| 559 | cpustate->rom_address = ( cpustate->pa << 7 ) | cpustate->pc; |
| 560 | /* execute: k input valid */ |
| 561 | if ( cpustate->decode & MICRO_MASK ) |
| 562 | { |
| 563 | /* Check N inputs */ |
| 564 | if ( cpustate->decode & ( M_15TN | M_ATN | M_CKN | M_MTN | M_NATN ) ) |
| 565 | { |
| 566 | cpustate->n = 0x0F; |
| 567 | if ( cpustate->decode & M_15TN ) |
| 568 | { |
| 569 | cpustate->n &= 0x0F; |
| 570 | } |
| 571 | if ( cpustate->decode & M_ATN ) |
| 572 | { |
| 573 | cpustate->n &= cpustate->a; |
| 574 | } |
| 575 | if ( cpustate->decode & M_CKN ) |
| 576 | { |
| 577 | cpustate->n &= cpustate->cki_bus; |
| 578 | } |
| 579 | if ( cpustate->decode & M_MTN ) |
| 580 | { |
| 581 | cpustate->n &= cpustate->ram_data; |
| 582 | } |
| 583 | if ( cpustate->decode & M_NATN ) |
| 584 | { |
| 585 | cpustate->n &= ( ( ~cpustate->a ) & 0x0F ); |
| 586 | } |
| 587 | } |
| 588 | |
| 589 | |
| 590 | /* Check P inputs */ |
| 591 | if ( cpustate->decode & ( M_CKP | M_DMTP | M_MTP | M_NDMTP | M_YTP ) ) |
| 592 | { |
| 593 | cpustate->p = 0x0F; |
| 594 | if ( cpustate->decode & M_CKP ) |
| 595 | { |
| 596 | cpustate->p &= cpustate->cki_bus; |
| 597 | } |
| 598 | if ( cpustate->decode & M_DMTP ) |
| 599 | { |
| 600 | cpustate->p &= cpustate->dam; |
| 601 | } |
| 602 | if ( cpustate->decode & M_MTP ) |
| 603 | { |
| 604 | cpustate->p &= cpustate->ram_data; |
| 605 | } |
| 606 | if ( cpustate->decode & M_NDMTP ) |
| 607 | { |
| 608 | cpustate->p &= ( ( ~cpustate->dam ) & 0x0F ); |
| 609 | } |
| 610 | if ( cpustate->decode & M_YTP ) |
| 611 | { |
| 612 | cpustate->p &= cpustate->y; |
| 613 | } |
| 614 | } |
| 615 | |
| 616 | /* Carry In input */ |
| 617 | if ( cpustate->decode & M_CIN ) |
| 618 | { |
| 619 | cpustate->carry_in = 1; |
| 620 | } |
| 621 | } |
| 622 | break; |
| 623 | case 2: |
| 624 | /* fetch: nothing */ |
| 625 | /* execute: write ram */ |
| 626 | /* perform adder logic */ |
| 627 | cpustate->adder_result = cpustate->p + cpustate->n + cpustate->carry_in; |
| 628 | if ( cpustate->decode & MICRO_MASK ) |
| 629 | { |
| 630 | if ( cpustate->decode & M_NE ) |
| 631 | { |
| 632 | if ( cpustate->n == cpustate->p ) |
| 633 | { |
| 634 | cpustate->status = 0; |
| 635 | } |
| 636 | } |
| 637 | if ( cpustate->decode & M_C8 ) |
| 638 | { |
| 639 | cpustate->status = cpustate->adder_result >> 4; |
| 640 | } |
| 641 | if ( cpustate->decode & M_STO ) |
| 642 | { |
| 643 | memory_write_byte_8le( cpustate->data, cpustate->ram_address, cpustate->a ); |
| 644 | } |
| 645 | if ( cpustate->decode & M_CKM ) |
| 646 | { |
| 647 | memory_write_byte_8le( cpustate->data, cpustate->ram_address, cpustate->cki_bus ); |
| 648 | } |
| 649 | } |
| 650 | else |
| 651 | { |
| 652 | if ( cpustate->decode & F_SBIT ) |
| 653 | { |
| 654 | memory_write_byte_8le( cpustate->data, cpustate->ram_address, cpustate->ram_data | tms0980_bit_value[ cpustate->opcode & 0x03 ] ); |
| 655 | } |
| 656 | if ( cpustate->decode & F_RBIT ) |
| 657 | { |
| 658 | memory_write_byte_8le( cpustate->data, cpustate->ram_address, cpustate->ram_data & tms0980_nbit_value[ cpustate->opcode & 0x03 ] ); |
| 659 | } |
| 660 | if ( cpustate->decode & F_SETR ) |
| 661 | { |
| 662 | cpustate->r = cpustate->r | ( 1 << cpustate->y ); |
| 663 | if ( cpustate->write_r ) |
| 664 | { |
| 665 | cpustate->write_r( device, 0, cpustate->r, 0xFFFF ); |
| 666 | } |
| 667 | } |
| 668 | if ( cpustate->decode & F_TDO ) |
| 669 | { |
| 670 | cpustate->o = ( cpustate->status_latch << 4 ) | cpustate->a; |
| 671 | if ( cpustate->write_o ) |
| 672 | { |
| 673 | cpustate->write_o( device, 0, cpustate->o ); |
| 674 | } |
| 675 | } |
| 676 | if ( cpustate->decode & F_CLO ) |
| 677 | { |
| 678 | cpustate->o = 0; |
| 679 | if ( cpustate->write_o ) |
| 680 | { |
| 681 | cpustate->write_o( device, 0, cpustate->o ); |
| 682 | } |
| 683 | } |
| 684 | if ( cpustate->decode & F_LDX ) |
| 685 | { |
| 686 | cpustate->x = tms0980_c_value[ cpustate->opcode & 0x0F ]; |
| 687 | } |
| 688 | if ( cpustate->decode & F_COMX ) |
| 689 | { |
| 690 | cpustate->x = cpustate->x ^ 0x03; |
| 691 | } |
| 692 | if ( cpustate->decode & F_LDP ) |
| 693 | { |
| 694 | cpustate->pb = tms0980_c_value[ cpustate->opcode & 0x0F ]; |
| 695 | } |
| 696 | if ( cpustate->decode & F_REAC ) |
| 697 | { |
| 698 | cpustate->special_status = 0; |
| 699 | } |
| 700 | if ( cpustate->decode & F_SEAC ) |
| 701 | { |
| 702 | cpustate->special_status = 1; |
| 703 | } |
| 704 | if ( cpustate->decode == F_SAL ) |
| 705 | { |
| 706 | cpustate->add_latch = 1; |
| 707 | } |
| 708 | if ( cpustate->decode == F_SBL ) |
| 709 | { |
| 710 | cpustate->branch_latch = 1; |
| 711 | } |
| 712 | } |
| 713 | break; |
| 714 | case 3: |
| 715 | /* fetch: fetch, update pc, ram address */ |
| 716 | cpustate->ram_address = ( cpustate->x << 4 ) | cpustate->y; |
| 717 | /* execute: register store */ |
| 718 | break; |
| 719 | case 4: |
| 720 | /* execute: register store */ |
| 721 | if ( cpustate->decode & ( MICRO_MASK | M_AUTA ) ) |
| 722 | { |
| 723 | cpustate->a = cpustate->adder_result & 0x0F; |
| 724 | } |
| 725 | if ( cpustate->decode & ( MICRO_MASK | M_AUTY ) ) |
| 726 | { |
| 727 | cpustate->y = cpustate->adder_result & 0x0F; |
| 728 | } |
| 729 | // if ( cpustate->decode & ( MICRO_MASK | M_STSL ) ) |
| 730 | // { |
| 731 | // cpustate->status_latch = cpustate->status; |
| 732 | // } |
| 733 | debugger_instruction_hook( device, cpustate->rom_address << 1 ); |
| 734 | /* fetch: fetch, update pc, ram address */ |
| 735 | cpustate->opcode = memory_read_word_16be( cpustate->program, cpustate->rom_address << 1 ); |
| 736 | cpustate->opcode &= 0x1FF; |
| 737 | cpustate->pc = tms0980_next_pc( cpustate->pc ); |
| 738 | if (LOG) |
| 739 | logerror("tms0980: read opcode %04x. Set pc to %04x\n", cpustate->opcode, cpustate->pc ); |
| 740 | break; |
| 741 | case 5: |
| 742 | /* fetch: instruction decode */ |
| 743 | cpustate->decode = tms0980_decode[ cpustate->opcode ]; |
| 744 | /* execute: execute br/call */ |
| 745 | if ( cpustate->status ) |
| 746 | { |
| 747 | if ( cpustate->decode == F_BR ) |
| 748 | { |
| 749 | if ( cpustate->call_latch == 0 ) |
| 750 | { |
| 751 | cpustate->pa = cpustate->pb; |
| 752 | } |
| 753 | cpustate->pc = cpustate->opcode & 0x7F; |
| 754 | } |
| 755 | if ( cpustate->decode == F_CALL ) |
| 756 | { |
| 757 | UINT8 t = cpustate->pa; |
| 758 | if ( cpustate->call_latch == 0 ) |
| 759 | { |
| 760 | cpustate->sr = cpustate->pc; |
| 761 | cpustate->call_latch = 1; |
| 762 | cpustate->pa = cpustate->pb; |
| 763 | } |
| 764 | cpustate->pb = t; |
| 765 | cpustate->pc = cpustate->opcode & 0x7F; |
| 766 | } |
| 767 | } |
| 768 | if ( cpustate->decode == F_RETN ) |
| 769 | { |
| 770 | if ( cpustate->call_latch == 1 ) |
| 771 | { |
| 772 | cpustate->pc = cpustate->sr; |
| 773 | cpustate->call_latch = 0; |
| 774 | } |
| 775 | cpustate->add_latch = 0; |
| 776 | cpustate->pa = cpustate->pb; |
| 777 | } else { |
| 778 | cpustate->branch_latch = 0; |
| 779 | } |
| 780 | break; |
| 781 | } |
| 782 | cpustate->subcycle = ( cpustate->subcycle + 1 ) % 6; |
| 783 | } while( cpustate->icount > 0 ); |
| 784 | |
| 785 | return cycles - cpustate->icount; |
| 786 | } |
| 787 | |
| 788 | |
| 789 | static CPU_SET_INFO( tms0980 ) |
| 790 | { |
| 791 | tms0980_state *cpustate = get_safe_token( device ); |
| 792 | |
| 793 | switch( state ) |
| 794 | { |
| 795 | case CPUINFO_INT_PC: cpustate->pc = ( info->i >> 1 ) & 0x7f; cpustate->pa = info->i >> 8; break; |
| 796 | case CPUINFO_INT_REGISTER + TMS0980_PC: cpustate->pc = info->i; break; |
| 797 | case CPUINFO_INT_REGISTER + TMS0980_SR: cpustate->sr = info->i; break; |
| 798 | case CPUINFO_INT_REGISTER + TMS0980_PA: cpustate->pa = info->i; break; |
| 799 | case CPUINFO_INT_REGISTER + TMS0980_PB: cpustate->pb = info->i; break; |
| 800 | case CPUINFO_INT_REGISTER + TMS0980_A: cpustate->a = info->i; break; |
| 801 | case CPUINFO_INT_REGISTER + TMS0980_X: cpustate->x = info->i; break; |
| 802 | case CPUINFO_INT_REGISTER + TMS0980_Y: cpustate->y = info->i; break; |
| 803 | case CPUINFO_INT_REGISTER + TMS0980_STATUS: cpustate->status = info->i; break; |
| 804 | } |
| 805 | } |
| 806 | |
| 807 | |
| 808 | CPU_GET_INFO( tms0980 ) |
| 809 | { |
| 810 | tms0980_state *cpustate = (device != NULL && device->token != NULL) ? get_safe_token(device) : NULL; |
| 811 | |
| 812 | switch(state) |
| 813 | { |
| 814 | case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(tms0980_state); break; |
| 815 | case CPUINFO_INT_INPUT_LINES: info->i = 1; break; |
| 816 | case CPUINFO_INT_ENDIANNESS: info->i = ENDIANNESS_BIG; break; |
| 817 | case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; |
| 818 | case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; |
| 819 | case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 2; break; |
| 820 | case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 2; break; |
| 821 | case CPUINFO_INT_MIN_CYCLES: info->i = 1; break; |
| 822 | case CPUINFO_INT_MAX_CYCLES: info->i = 6; break; |
| 823 | |
| 824 | case CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 16 /* 9 */; break; |
| 825 | case CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_PROGRAM: info->i = 11; break; |
| 826 | case CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_PROGRAM: info->i = 0; break; |
| 827 | case CPUINFO_INT_DATABUS_WIDTH + ADDRESS_SPACE_DATA: info->i = 8 /* 4 */; break; |
| 828 | case CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_DATA: info->i = 7; break; |
| 829 | case CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_DATA: info->i = 0; break; |
| 830 | |
| 831 | case CPUINFO_INT_PREVIOUSPC: info->i = ( ( cpustate->prev_pa << 7 ) | cpustate->prev_pc ) << 1; break; |
| 832 | case CPUINFO_INT_PC: info->i = ( ( cpustate->pa << 7 ) | cpustate->pc ) << 1; break; |
| 833 | case CPUINFO_INT_SP: info->i = 0xFFFF; break; |
| 834 | case CPUINFO_INT_REGISTER + TMS0980_PC: info->i = cpustate->pc; break; |
| 835 | case CPUINFO_INT_REGISTER + TMS0980_SR: info->i = cpustate->sr; break; |
| 836 | case CPUINFO_INT_REGISTER + TMS0980_PA: info->i = cpustate->pa; break; |
| 837 | case CPUINFO_INT_REGISTER + TMS0980_PB: info->i = cpustate->pb; break; |
| 838 | case CPUINFO_INT_REGISTER + TMS0980_A: info->i = cpustate->a; break; |
| 839 | case CPUINFO_INT_REGISTER + TMS0980_X: info->i = cpustate->x; break; |
| 840 | case CPUINFO_INT_REGISTER + TMS0980_Y: info->i = cpustate->y; break; |
| 841 | case CPUINFO_INT_REGISTER + TMS0980_STATUS: info->i = cpustate->status; break; |
| 842 | |
| 843 | case CPUINFO_PTR_INTERNAL_MEMORY_MAP + ADDRESS_SPACE_PROGRAM: info->internal_map16 = ADDRESS_MAP_NAME( tms0980_internal_rom ); break; |
| 844 | case CPUINFO_PTR_INTERNAL_MEMORY_MAP + ADDRESS_SPACE_DATA: info->internal_map8 = ADDRESS_MAP_NAME( tms0980_internal_ram ); break; |
| 845 | |
| 846 | case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME( tms0980 ); break; |
| 847 | case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME( tms0980 ); break; |
| 848 | case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME( tms0980 ); break; |
| 849 | case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME( tms0980 ); break; |
| 850 | case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME( tms0980 ); break; |
| 851 | case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break; |
| 852 | |
| 853 | case CPUINFO_STR_NAME: strcpy( info->s, "TMS0980" ); break; |
| 854 | case CPUINFO_STR_CORE_FAMILY: strcpy( info->s, "Texas Instruments TMS0980" ); break; |
| 855 | case CPUINFO_STR_CORE_VERSION: strcpy( info->s, "0.1" ); break; |
| 856 | case CPUINFO_STR_CORE_FILE: strcpy( info->s, __FILE__ ); break; |
| 857 | case CPUINFO_STR_CORE_CREDITS: strcpy( info->s, "Copyright the MESS and MAME teams" ); break; |
| 858 | |
| 859 | case CPUINFO_STR_FLAGS: strcpy( info->s, "N/A" ); break; |
| 860 | |
| 861 | case CPUINFO_STR_REGISTER + TMS0980_PC: sprintf( info->s, "PC:%02X", cpustate->pc ); break; |
| 862 | case CPUINFO_STR_REGISTER + TMS0980_SR: sprintf( info->s, "SR:%01X", cpustate->sr ); break; |
| 863 | case CPUINFO_STR_REGISTER + TMS0980_PA: sprintf( info->s, "PA:%01X", cpustate->pa ); break; |
| 864 | case CPUINFO_STR_REGISTER + TMS0980_PB: sprintf( info->s, "PB:%01X", cpustate->pb ); break; |
| 865 | case CPUINFO_STR_REGISTER + TMS0980_A: sprintf( info->s, "A:%01X", cpustate->a ); break; |
| 866 | case CPUINFO_STR_REGISTER + TMS0980_X: sprintf( info->s, "X:%01X", cpustate->x ); break; |
| 867 | case CPUINFO_STR_REGISTER + TMS0980_Y: sprintf( info->s, "Y:%01X", cpustate->y ); break; |
| 868 | case CPUINFO_STR_REGISTER + TMS0980_STATUS: sprintf( info->s, "STATUS:%01X", cpustate->status ); break; |
| 869 | |
| 870 | } |
| 871 | } |
| 872 | |
src/emu/cpu/tms0980/tms0980d.c
| r0 | r5090 | |
| 1 | /******************************************************************* |
| 2 | |
| 3 | tms0980d.c |
| 4 | TMS0980 disassembly |
| 5 | |
| 6 | *******************************************************************/ |
| 7 | |
| 8 | #include "debugger.h" |
| 9 | #include "tms0980.h" |
| 10 | |
| 11 | |
| 12 | #define _OVER DASMFLAG_STEP_OVER |
| 13 | #define _OUT DASMFLAG_STEP_OUT |
| 14 | |
| 15 | |
| 16 | enum e_mnemonics { |
| 17 | zACACC=0, zACNAA, zALEC, zALEM, zAMAAC, zBRANCH, zCALL, zCCLA, |
| 18 | zCLA, zCOMX, zCOMX8, zCPAIZ, zCTMDYN, zDMAN, zDMEA, zDNAA, |
| 19 | zDYN, zIMAC, zIYC, zKNE, zLDP, zLDX, zMNEA, zMNEZ, |
| 20 | zNDMEA, zOFF, zRBIT, zREAC, zRETN, zSAL, zSAMAN, zSBIT, |
| 21 | zSBL, zSEAC, zSETR, zTAM, zTAMACS, zTAMDYN, zTAMIYC, zTAMZA, |
| 22 | zTAY, zTBIT, zTCMIY, zTCY, zTDO, zTKA, zTKM, zTMA, |
| 23 | zTMY, zTYA, zXDA, zXMA, zYMCY, zYNEA, zYNEC, |
| 24 | zILL |
| 25 | }; |
| 26 | |
| 27 | |
| 28 | enum e_addressing { |
| 29 | zB0=0, zB2, zB4, zB7 |
| 30 | }; |
| 31 | |
| 32 | |
| 33 | static const char *s_mnemonic[] = { |
| 34 | "acacc", "acnaa", "alec", "alem", "amaac", "branch", "call", "ccla", |
| 35 | "cla", "comx", "comx8", "cpaiz", "ctmdyn", "dman", "dmea", "dnaa", |
| 36 | "dyn", "imac", "iyc", "kne", "ldp", "ldx", "mnea", "mnez", |
| 37 | "ndmea", "off", "rbit", "reac", "retn", "sal", "saman", "sbit", |
| 38 | "sbl", "seac", "setr", "tam", "tamacs", "tamdyn", "tamiyc", "tamza", |
| 39 | "tay", "tbit", "tcmiy", "tcy", "tdo", "tka", "tkm", "tma", |
| 40 | "tmy", "tya", "xda", "xma", "ymcy", "ynea", "ynec", |
| 41 | "illegal" |
| 42 | }; |
| 43 | |
| 44 | |
| 45 | static const UINT32 s_flags[] = { |
| 46 | 0, 0, 0, 0, 0, 0, _OVER, 0, |
| 47 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 48 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 49 | 0, 0, 0, 0, _OUT, 0, 0, 0, |
| 50 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 51 | 0, 0, 0, 0, 0, 0, 0, 0, |
| 52 | 0, 0, 0, 0, 0, 0, 0, |
| 53 | 0 |
| 54 | }; |
| 55 | |
| 56 | |
| 57 | static const UINT8 s_addressing[] = { |
| 58 | zB4, zB4, zB4, zB0, zB0, zB7, zB7, zB0, |
| 59 | zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, |
| 60 | zB0, zB0, zB0, zB0, zB4, zB4, zB0, zB0, |
| 61 | zB0, zB0, zB0, zB0, zB0, zB0, zB0, zB0, |
| 62 | zB0, zB0, zB2, zB0, zB4, zB0, zB0, zB2, |
| 63 | zB0, zB2, zB4, zB4, zB0, zB0, zB0, zB0, |
| 64 | zB0, zB0, zB0, zB0, zB4, zB0, zB4, |
| 65 | zB0 |
| 66 | }; |
| 67 | |
| 68 | |
| 69 | static const UINT8 tms0980_mnemonic[512] = { |
| 70 | /* 0x000 */ |
| 71 | zCOMX, zALEM, zYNEA, zXMA, zDYN, zIYC, zCLA, zDMAN, |
| 72 | zTKA, zMNEA, zTKM, zILL, zILL, zSETR, zKNE, zILL, |
| 73 | /* 0x010 */ |
| 74 | zDMEA, zDNAA, zCCLA, zNDMEA, zILL, zAMAAC, zILL, zILL, |
| 75 | zCTMDYN, zXDA, zILL, zILL, zILL, zILL, zILL, zILL, |
| 76 | /* 0x020 */ |
| 77 | zTBIT, zTBIT, zTBIT, zTBIT, zILL, zILL, zILL, zILL, |
| 78 | zTAY, zTMA, zTMY, zTYA, zTAMDYN, zTAMIYC, zTAMZA, zTAM, |
| 79 | /* 0x030 */ |
| 80 | zSAMAN, zCPAIZ, zIMAC, zMNEZ, zILL, zILL, zILL, zILL, |
| 81 | zTCY, zYNEC, zTCMIY, zACACC, zACNAA, zTAMACS, zALEC, zYMCY, |
| 82 | /* 0x040 */ |
| 83 | zTCY, zTCY, zTCY, zTCY, zTCY, zTCY, zTCY, zTCY, |
| 84 | zTCY, zTCY, zTCY, zTCY, zTCY, zTCY, zTCY, zTCY, |
| 85 | /* 0x050 */ |
| 86 | zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, |
| 87 | zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, zYNEC, |
| 88 | /* 0x060 */ |
| 89 | zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, |
| 90 | zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, zTCMIY, |
| 91 | /* 0x070 */ |
| 92 | zACACC, zACACC, zACACC, zACACC, zACACC, zACACC, zACACC, zACACC, |
| 93 | zACACC, zACACC, zACACC, zACACC, zACACC, zACACC, zACACC, zACACC, |
| 94 | /* 0x080 */ |
| 95 | zLDP, zLDP, zLDP, zLDP, zLDP, zLDP, zLDP, zLDP, |
| 96 | zLDP, zLDP, zLDP, zLDP, zLDP, zLDP, zLDP, zLDP, |
| 97 | /* 0x090 */ |
| 98 | zLDX, zLDX, zLDX, zLDX, zLDX, zLDX, zLDX, zLDX, |
| 99 | zLDX, zLDX, zLDX, zLDX, zLDX, zLDX, zLDX, zLDX, |
| 100 | /* 0x0A0 */ |
| 101 | zSBIT, zSBIT, zSBIT, zSBIT, zRBIT, zRBIT, zRBIT, zRBIT, |
| 102 | zILL, zILL, zILL, zILL, zILL, zILL, zILL, zILL, |
| 103 | /* 0x0B0 */ |
| 104 | zTDO, zSAL, zCOMX8, zSBL, zREAC, zSEAC, zOFF, zILL, |
| 105 | zILL, zILL, zILL, zILL, zILL, zILL, zILL, zRETN, |
| 106 | /* 0x0C0 */ |
| 107 | zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, |
| 108 | zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, zACNAA, |
| 109 | /* 0x0D0 */ |
| 110 | zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, |
| 111 | zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, zTAMACS, |
| 112 | /* 0x0E0 */ |
| 113 | zALEC, zALEC, zALEC, zALEC, zALEC, zALEC, zALEC, zALEC, |
| 114 | zALEC, zALEC, zALEC, zALEC, zALEC, zALEC, zALEC, zALEC, |
| 115 | /* 0x0F0 */ |
| 116 | zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, |
| 117 | zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, zYMCY, |
| 118 | /* 0x100 */ |
| 119 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 120 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 121 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 122 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 123 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 124 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 125 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 126 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 127 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 128 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 129 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 130 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 131 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 132 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 133 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 134 | zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, zBRANCH, |
| 135 | /* 0x180 */ |
| 136 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 137 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 138 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 139 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 140 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 141 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 142 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 143 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 144 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 145 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 146 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 147 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 148 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 149 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 150 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, |
| 151 | zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL, zCALL |
| 152 | }; |
| 153 | |
| 154 | |
| 155 | CPU_DISASSEMBLE( tms0980 ) { |
| 156 | static const UINT8 tms0980_c_value[16] = |
| 157 | { |
| 158 | 0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F |
| 159 | }; |
| 160 | static const UINT8 tms0980_bit_value[4] = { 1, 4, 2, 8 }; |
| 161 | |
| 162 | char *dst = buffer; |
| 163 | UINT16 op, instr; |
| 164 | int pos = 0; |
| 165 | |
| 166 | op = ( ( oprom[pos] << 8 ) | oprom[pos + 1] ) & 0x01FF; |
| 167 | pos += 2; |
| 168 | |
| 169 | instr = tms0980_mnemonic[op]; |
| 170 | |
| 171 | dst += sprintf( dst, "%-8s ", s_mnemonic[instr] ); |
| 172 | |
| 173 | switch( s_addressing[instr] ) { |
| 174 | case zB0: |
| 175 | break; |
| 176 | case zB2: |
| 177 | dst += sprintf( dst, "#$%d", tms0980_bit_value[ op & 3 ] ); |
| 178 | break; |
| 179 | case zB4: |
| 180 | dst += sprintf( dst, "#$%01X", tms0980_c_value[ op & 0x0F ] ); |
| 181 | break; |
| 182 | case zB7: |
| 183 | dst += sprintf( dst, "#$%02X", op & 0x7F ); |
| 184 | break; |
| 185 | } |
| 186 | |
| 187 | return pos | s_flags[instr] | DASMFLAG_SUPPORTED; |
| 188 | } |
| 189 | |