Previous 15994 Revisions Next

r5090 Friday 26th June, 2009 at 17:52:45 UTC by Wilbert Pol
Added TMS0980 cpu core.
Added skeleton for 'Stop the Thief'.
[src/emu/cpu]cpu.mak
[src/emu/cpu/tms0980]tms0980.c* tms0980.h* tms0980d.c*
[src/mess]mess.mak messdriv.c
[src/mess/drivers]stopthie.c*
[src/mess/layout]stopthie.lay*

src/emu/cpu/tms0980/tms0980.c
r0r5090
1/*
2
3This CPU core has not been thoroughly tested. Several features may still be
4incomplete, missing, or broken.  [Wilbert Pol]
5
6
7TMS0980 CPU core
8
9Each instruction takes 12 cycles to execute in 2 phases: a fetch phase and an
10execution phase. The execution phase takes place at the same time as the fetch
11phase of the next instruction. So, during execution there are both fetch and
12execution operations taking place. The operation can be split up as follows:
13cycle #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
21cycle #1
22   - Fetch:
23      1. ROM address 1
24   - Execute:
25      1. Update ALU inputs
26cycle #2
27   - Fetch:
28      1. nothing/wait(?)
29   - Execute:
30      1. Perform ALU operation
31      2. Write RAM
32cycle #3
33   - Fetch:
34      1. Fetch/Update PC/RAM address #1
35   - Execute:
36      1. Register store part #1
37cycle #4
38   - Fetch:
39      1. Fetch/Update PC/RAM address #2
40   - Execute:
41      1. Register store part #2
42cycle #5
43   - Fetch:
44      1. Instruction decode
45   - Execute:
46      1. Execute BRANCH/CALL/RETN part #1
47
48Instructions built from microinstructions:
49
50ACACC   000111011*  CKP, ATN, C8, AUTA
51        00111cccc
52ACNAA   000111100*  CKP, NATN, AUTA
53        01100cccc
54ALEC    000111110*  CIN, CKP, NATN, C8
55        01110cccc
56ALEM    000000001   MTP, NATN, CIN, C8
57AMAAC   000010101   ATN, MTP, C8, AUTA
58BRANCH  10wwwwwww   no microinstructions
59CALL    11wwwwwww   no microinstructions
60CCLA    000010010   AUTA, SSS
61CLA     000000110   AUTA
62COMX    000000000   no microinstructions
63COMX8   010110010   no microinstructions
64CPAIZ   000110001   NATN, CIN, C8, AUTA
65CTMDYN  000011000   YTP, 15TN, C8, CME, AUTY
66DMAN    000000111   MTP, 15TN, C8, AUTA
67DMEA    000010000   MTP, DMTP, SSS, AUTA
68DNAA    000010001   DMTP, NATN, SSS, AUTA
69DYN     000000100   YTP, 15TN, C8, AUTY
70IMAC    000110010   MTP, CIN, C8, AUTA
71IYC     000000101   YTP, CIN, C8, AUTY
72KNEZ    000001110   CKP, NE
73LDP     01000cccc   no microinstructions
74LDX     01001cccc   no microinstructions
75MNEA    000001001   MTP, ATN, NE
76MNEZ    000110011   MTP, NE
77NDMEA   000010011   MTN, NDMTP, SSS, AUTA
78OFF     010110110
79RBIT    0101001bb   no microinstructions
80REAC    010110100   no microinstructions
81RETN    010111111   no microinstructions
82SAL     010110001   no microinstructions
83SAMAN   000110000   MTP, NATN, CIN, C8, AUTA
84SBIT    0101000bb   no microinstructions
85SBL     010110011   no microinstructions
86SEAC    010110101   no microinstructions
87SETR    000001101   YTP, 15TN, AUTY, C8
88TAM     000101111   STO
89TAMACS  000111101*  STO, ATN, CKP, AUTA, SSE
90        01101cccc
91TAMDYN  000101100   STO, YTP, 15TN, AUTY, C8
92TAMIYC  000101101   STO, YTP, CIN, C8, AUTY
93TAMZA   000101110   STO, AUTA
94TAY     000101000   ATN, AUTY
95TBIT    0001000bb   CKP, CKN, MTP, NE
96TCMIY   000111010*  CKM, YTP, CIN, AUTY
97        00110cccc
98TCY     000111000*  CKP, AUTY
99        00100cccc
100TDO     010110000   no microinstructions
101TKA     000001000   CKP, AUTA
102TKM     000001010   CKM
103TMA     000101001   MTP, AUTA
104TMY     000101010   MTP, AUTY
105TYA     000101011   YTP, AUTA
106XDA     000011001   DMTP, AUTA, STO
107XMA     000000011   MTP, STO, AUTA
108YMCY    000111111*  CIN, YTP, CKN, AUTY
109        01111cccc
110YNEA    000000010   YTP, ATN, NE
111YNEC    000111001*  YTP, CKN, NE
112        00101cccc
113* = faked/special decode variant of instruction
114
115Microinstructions:
11615TN  - 15 to -ALU
117ATN   - ACC to -ALU
118AUTA  - ALU to ACC
119AUTY  - ALU to Y
120C8    - CARRY8 to STATUS
121CIN   - Carry In to ALU
122CKM   - CKB to MEM
123CKN   - CKB to -ALU
124CKP   - CKB to +ALU
125CME   - Conditional Memory Enable
126DMTP  - DAM to +ALU
127MTN   - MEM to -ALU
128MTP   - MEM to +ALU
129NATN  - ~ACC to -ALU
130NDMTP - ~DAM to +ALU
131NE    - COMP to STATUS
132SSE   - Special Status Enable
133SSS   - Special Status Sample
134STO   - ACC to MEM
135YTP   - Y to +ALU
136
137cycle #0: 15TN, ATN, CIN, CKN, CKP, DMTP, MTN, MTP, NATN, NDMTP, YTP
138cycle #2: C8(?), CKM, NE(?), STO
139cycle #3,#4: AUTA, AUTY
140
141unknown: 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
239typedef struct _tms0980_state tms0980_state;
240struct _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
281static 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};
285static const UINT8 tms0980_bit_value[4] = { 1, 4, 2, 8 };
286static const UINT8 tms0980_nbit_value[4] = { 0x0E, 0x0B, 0x0D, 0x07 };
287
288
289static 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
366INLINE 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
376static ADDRESS_MAP_START(tms0980_internal_rom, ADDRESS_SPACE_PROGRAM, 16)
377   AM_RANGE( 0x0000, 0x07FF ) AM_ROM
378ADDRESS_MAP_END
379
380
381static ADDRESS_MAP_START(tms0980_internal_ram, ADDRESS_SPACE_DATA, 8)
382   AM_RANGE( 0x0000, 0x0FFF ) AM_RAM
383ADDRESS_MAP_END
384
385
386static 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
427static 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*/
475INLINE 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
484static 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
535static 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
789static 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
808CPU_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
r0r5090
1/*******************************************************************
2
3tms0980d.c
4TMS0980 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
16enum 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
28enum e_addressing {
29   zB0=0, zB2, zB4, zB7
30};
31
32
33static 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
45static 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
57static 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
69static 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
155CPU_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
src/emu/cpu/tms0980/tms0980.h
r0r5090
1#ifndef _TMS0980_H_
2#define _TMS0980_H_
3
4#include "cpuintrf.h"
5
6/* Registers */
7enum {
8   TMS0980_PC=1, TMS0980_SR, TMS0980_PA, TMS0980_PB,
9   TMS0980_A, TMS0980_X, TMS0980_Y, TMS0980_STATUS
10};
11
12
13typedef struct _tms0980_config tms0980_config;
14struct _tms0980_config {
15   read8_device_func   read_k;
16   write8_device_func   write_o;
17   write16_device_func   write_r;
18};
19
20
21#define CPU_TMS0980 CPU_GET_INFO_NAME( tms0980 )
22
23extern CPU_GET_INFO( tms0980 );
24extern CPU_DISASSEMBLE( tms0980 );
25
26#endif /* _TMS0980_H_ */
27
src/emu/cpu/cpu.mak
r5089r5090
12721272
12731273
12741274#-------------------------------------------------
1275# Texas Instruments TMS0980
1276#-------------------------------------------------
1277
1278ifneq ($(filter TMS0980,$(CPUS)),)
1279OBJDIRS += $(CPUOBJ)/tms0980
1280CPUOBJS += $(CPUOBJ)/tms0980/tms0980.o
1281DBGOBJS += $(CPUOBJ)/tms0980/tms0980d.o
1282endif
1283
1284$(CPUOBJ)/tms0980/tms0980.o:   $(CPUSRC)/tms0980/tms0980.h \
1285                        $(CPUSRC)/tms0980/tms0980.c
1286
1287$(CPUOBJ)/tms0980/tms0980d.o:   $(CPUSRC)/tms0980/tms0980.h \
1288                        $(CPUSRC)/tms0980/tms0980d.c
1289
1290
1291
1292#-------------------------------------------------
12751293# Texas Instruments TMS7000 series
12761294#-------------------------------------------------
12771295
src/mess/messdriv.c
r5089r5090
14131413    DRIVER( mmd1 )
14141414    DRIVER( mmd2 )
14151415    DRIVER( mpf1p )
1416   DRIVER( stopthie )
14161417
14171418#endif /* DRIVER_RECURSIVE */
14181419
src/mess/mess.mak
r5089r5090
121121CPUS += MINX
122122CPUS += SSEM
123123CPUS += AVR8
124CPUS += TMS0980
124125
125126
126127
r5089r5090
14571458   $(MESS_DRIVERS)/z9001.o \
14581459   $(MESS_DRIVERS)/cat.o \
14591460   $(MESS_DRIVERS)/mmd1.o \
1461   $(MESS_DRIVERS)/stopthie.o \
14601462   
14611463#-------------------------------------------------
14621464# layout dependencies
r5089r5090
14941496$(MESS_DRIVERS)/pokemini.o:   $(MESS_LAYOUT)/pokemini.lh
14951497$(MESS_DRIVERS)/px4.o:      $(MESS_LAYOUT)/px4.lh
14961498$(MESS_DRIVERS)/socrates.o:   $(MESS_LAYOUT)/socrates.lh
1499$(MESS_DRIVERS)/stopthie.o:   $(MESS_LAYOUT)/stopthie.lh
14971500$(MESS_DRIVERS)/super80.o:   $(MESS_LAYOUT)/super80.lh
14981501$(MESS_DRIVERS)/svi318.o:   $(MESS_LAYOUT)/sv328806.lh
14991502$(MESS_DRIVERS)/svision.o:   $(MESS_LAYOUT)/svision.lh
src/mess/layout/stopthie.lay
r0r5090
1<?xml version="1.0"?>
2<mamelayout version="2">
3   <element name="background">
4      <rect>
5         <bounds left="0" top="0" right="1" bottom="1" />
6         <color red="0.0" green="0.0" blue="0.0" />
7      </rect>
8   </element>
9
10   <view name="Default">
11
12      <!-- Black background -->
13      <bezel element="background">
14         <bounds left="0" top="0" right="200" bottom="200" />
15      </bezel>
16
17   </view>
18</mamelayout>
src/mess/drivers/stopthie.c
r0r5090
1#include "driver.h"
2#include "cpu/tms0980/tms0980.h"
3
4/* Layout */
5#include "stopthie.lh"
6
7
8static MACHINE_DRIVER_START( stopthie )
9   MDRV_CPU_ADD( "maincpu", TMS0980, 5000000 )   /* Clock is wrong */
10
11   MDRV_DEFAULT_LAYOUT(layout_stopthie)
12MACHINE_DRIVER_END
13
14ROM_START( stopthie )
15   ROM_REGION( 0x1000, "maincpu", 0 )
16   /* Taken from patent 4341385, might have made mistakes when creating this rom */
17   ROM_LOAD16_WORD( "stopthie.bin", 0x0000, 0x1000, BAD_DUMP CRC(49ef83ad) SHA1(407151f707aa4a62b7e034a1bcb957c42ea36707) )
18ROM_END
19
20/***************************************************************************
21
22  Game driver(s)
23
24***************************************************************************/
25
26/*    YEAR  NAME        PARENT  COMPAT  MACHINE     INPUT   INIT    CONFIG  COMPANY            FULLNAME      FLAGS */
27CONS( 1979, stopthie,   0,      0,      stopthie,   0,      0,      0,      "Parker Brothers", "Stop the Thief", GAME_NOT_WORKING )
28

Previous 15994 Revisions Next


© 1998-2018 The MESS Team