← Back to branch summary

~ubuntu-branches/ubuntu/raring/mame/raring-proposed

« back to all changes in this revision

Viewing changes to mess/src/mess/drivers/mpz80.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Jordi Mallach, Emmanuel Kasper
  • Date: 2011-12-19 22:56:27 UTC
  • mfrom: (0.1.2)
  • Revision ID: package-import@ubuntu.com-20111219225627-ub5oga1oys4ogqzm
Tags: 0.144-1
http://bugs.debian.org/651538
[ Jordi Mallach ]
* Fix syntax errors in DEP5 copyright file (lintian).
* Use a versioned copyright Format specification field.
* Update Vcs-* URLs.
* Move transitional packages to the new metapackages section, and make
  them priority extra.
* Remove references to GNU/Linux and MESS sources from copyright.
* Add build variables for s390x.
* Use .xz tarballs as it cuts 4MB for the upstream sources.
* Add nplayers.ini as a patch. Update copyright file to add CC-BY-SA-3.0.

[ Emmanuel Kasper ]
* New upstream release. Closes: #651538.
* Add Free Desktop compliant png icons of various sizes taken from
  the hydroxygen iconset
* Mess is now built from a new source package, to avoid possible source
  incompatibilities between mame and the mess overlay.
* Mame-tools are not built from the mame source package anymore, but
  from the mess source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
mess/src/mess/drivers/mpz80.c
1
 
/*
2
 
 
3
 
    Morrow MPZ80 "Decision"
4
 
 
5
 
    Skeleton driver
6
 
 
7
 
*/
8
 
 
9
 
/*
10
 
 
11
 
    TODO:
12
 
 
13
 
    - trap logic
14
 
        - trap stop
15
 
        - trap aux
16
 
        - trap halt
17
 
        - trap int
18
 
        - trap void
19
 
        - in/out trap
20
 
        - read/write trap
21
 
        - exec trap
22
 
    - front panel LEDs
23
 
    - keyboard
24
 
    - I/O
25
 
        - Mult I/O (8259A PIC, 3x 8250 ACE, uPD1990C RTC, 4K ROM/RAM)
26
 
    - floppy
27
 
        - DJ/DMA controller (Z80, 1K RAM, 2/4K ROM, TTL floppy control logic) for 5.25" floppy drives
28
 
        - DJ2D/B controller for 8" floppy drives
29
 
    - hard disk
30
 
        - HDC/DMA controller (Seagate ST-506/Shugart SA1000)
31
 
        - HDCA controller (Shugart SA4000/Fujitsu M2301B/Winchester M2320B)
32
 
    - AM9512 FPU
33
 
    - models
34
 
        - Decision I Desk Top Model D1 (MPZ80, MM65KS, Wunderbus)
35
 
        - Decision I Desk Top Model D2 (MPZ80, MM65KS, Wunderbus, DJDMA, 2x DSDD 5.25")
36
 
        - Decision I Desk Top Model D2A (MPZ80, MM65KS, Wunderbus, DJDMA, 2x DSDD 5.25", HDCDMA, 5 or 16 MB hard disk?)
37
 
        - Decision I Desk Top Model D3A (MPZ80, MM65KS, Wunderbus, DJDMA, 2x DSDD 5.25", HDCDMA, 5 or 16 MB hard disk?)
38
 
        - Decision I Desk Top Model D3C (MPZ80, MM65KS, Wunderbus, DJDMA, 2x DSDD 5.25", HDCDMA, 5 or 16 MB hard disk?)
39
 
 
40
 
*/
41
 
 
42
 
#include "includes/mpz80.h"
43
 
 
44
 
 
45
 
//**************************************************************************
46
 
//  MACROS / CONSTANTS
47
 
//**************************************************************************
48
 
 
49
 
enum
50
 
{
51
 
        NO_ACCESS = 0,
52
 
        READ_ONLY,
53
 
        EXECUTE_ONLY,
54
 
        FULL_ACCESS
55
 
};
56
 
 
57
 
#define TASK0   ((m_task & 0x0f) == 0)
58
 
 
59
 
#define R10     0x04
60
 
 
61
 
 
62
 
// mask register
63
 
#define MASK_STOP_ENBL          0x01
64
 
#define MASK_AUX_ENBL           0x02
65
 
#define MASK_TINT_ENBL          0x04
66
 
#define MASK_RUN_ENBL           0x08
67
 
#define MASK_HALT_ENBL          0x10
68
 
#define MASK_SINT_ENBL          0x20
69
 
#define MASK_IOENBL                     0x40
70
 
#define MASK_ZIO_MODE           0x80
71
 
 
72
 
 
73
 
 
74
 
//**************************************************************************
75
 
//  INTERRUPTS
76
 
//**************************************************************************
77
 
 
78
 
//-------------------------------------------------
79
 
//  check_traps -
80
 
//-------------------------------------------------
81
 
 
82
 
inline void mpz80_state::check_traps()
83
 
{
84
 
        m_pretrap = !(m_trap_int & m_trap_halt & m_trap_stop & m_trap_aux);
85
 
 
86
 
        if (m_pretrap)
87
 
        {
88
 
                // latch trap condition
89
 
                m_status = m_trap_void;
90
 
                m_status |= m_trap_halt << 2;
91
 
                m_status |= m_trap_int << 3;
92
 
                m_status |= m_trap_stop << 4;
93
 
                m_status |= m_trap_aux << 5;
94
 
 
95
 
                // latch trap address
96
 
                m_pretrap_addr = ((m_addr >> 8) & 0xf0) | (m_pretrap_addr >> 4);
97
 
 
98
 
                // set M1 trap region start address
99
 
                m_trap_start = m_addr;
100
 
        }
101
 
}
102
 
 
103
 
 
104
 
//-------------------------------------------------
105
 
//  check_interrupt -
106
 
//-------------------------------------------------
107
 
 
108
 
inline void mpz80_state::check_interrupt()
109
 
{
110
 
        int tint_enbl = (m_mask & MASK_TINT_ENBL) ? 1 : 0;
111
 
        int sint_enbl = (m_mask & MASK_SINT_ENBL) ? 0 : 1;
112
 
 
113
 
        m_int_pend = !(m_nmi & m_pint);
114
 
        m_trap_int = !(m_int_pend & tint_enbl);
115
 
 
116
 
        int z80irq = CLEAR_LINE;
117
 
        int z80nmi = CLEAR_LINE;
118
 
 
119
 
        if (TASK0)
120
 
        {
121
 
                if (!m_pint && !sint_enbl) z80irq = ASSERT_LINE;
122
 
                if (!m_nmi && !sint_enbl) z80nmi = ASSERT_LINE;
123
 
        }
124
 
        else
125
 
        {
126
 
                if (!m_pint && !tint_enbl) z80irq = ASSERT_LINE;
127
 
                if (!m_nmi && !tint_enbl) z80nmi = ASSERT_LINE;
128
 
        }
129
 
 
130
 
        m_maincpu->set_input_line(INPUT_LINE_IRQ0, z80irq);
131
 
        m_maincpu->set_input_line(INPUT_LINE_NMI, z80nmi);
132
 
 
133
 
        check_traps();
134
 
}
135
 
 
136
 
 
137
 
 
138
 
//**************************************************************************
139
 
//  MEMORY MANAGEMENT
140
 
//**************************************************************************
141
 
 
142
 
//-------------------------------------------------
143
 
//  get_address -
144
 
//-------------------------------------------------
145
 
 
146
 
inline offs_t mpz80_state::get_address(offs_t offset)
147
 
{
148
 
        UINT16 map_addr = ((m_task & 0x0f) << 5) | ((offset & 0xf000) >> 11);
149
 
        UINT8 map = m_map_ram[map_addr];
150
 
        //UINT8 attr = m_map_ram[map_addr + 1];
151
 
 
152
 
        //logerror("task %02x map_addr %03x map %02x attr %02x address %06x\n", m_task, map_addr, map, attr, offset);
153
 
 
154
 
        // T7 T6 T5 T4 M7 M6 M5 M4 M3 M2 M1 M0 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0
155
 
        return ((m_task & 0xf0) << 16) | (map << 12) | (offset & 0xfff);
156
 
}
157
 
 
158
 
 
159
 
//-------------------------------------------------
160
 
//  mmu_r -
161
 
//-------------------------------------------------
162
 
 
163
 
READ8_MEMBER( mpz80_state::mmu_r )
164
 
{
165
 
        m_addr = get_address(offset);
166
 
        UINT8 *rom = machine().region(Z80_TAG)->base();
167
 
        UINT8 data = 0;
168
 
 
169
 
        if (m_pretrap)
170
 
        {
171
 
                m_pretrap = 0;
172
 
                m_trap = 1;
173
 
 
174
 
                // latch trap address
175
 
                m_pretrap_addr = ((m_addr >> 8) & 0xf0) | (m_pretrap_addr >> 4);
176
 
                m_trap_addr = m_pretrap_addr;
177
 
        }
178
 
 
179
 
        if (TASK0 && (offset < 0x1000))
180
 
        {
181
 
                if (offset < 0x400)
182
 
                {
183
 
                        UINT8 *ram = ram_get_ptr(m_ram);
184
 
                        data = ram[offset & 0x3ff];
185
 
                }
186
 
                else if (offset == 0x400)
187
 
                {
188
 
                        data = trap_addr_r(space, 0);
189
 
                }
190
 
                else if (offset == 0x401)
191
 
                {
192
 
                        data = keyboard_r(space, 0);
193
 
                }
194
 
                else if (offset == 0x402)
195
 
                {
196
 
                        data = switch_r(space, 0);
197
 
                }
198
 
                else if (offset == 0x403)
199
 
                {
200
 
                        data = status_r(space, 0);
201
 
                }
202
 
                else if (offset >= 0x600 && offset < 0x800)
203
 
                {
204
 
                        // TODO this might change the map RAM contents
205
 
                }
206
 
                else if (offset < 0xc00)
207
 
                {
208
 
                        UINT16 rom_addr = (m_trap_reset << 10) | (offset & 0x3ff);
209
 
                        data = rom[rom_addr];
210
 
                }
211
 
                else
212
 
                {
213
 
                        logerror("Unmapped LOCAL read at %06x\n", offset);
214
 
                }
215
 
        }
216
 
        else
217
 
        {
218
 
                data = m_s100->smemr_r(space, m_addr);
219
 
        }
220
 
 
221
 
        return data;
222
 
}
223
 
 
224
 
 
225
 
//-------------------------------------------------
226
 
//  mmu_w -
227
 
//-------------------------------------------------
228
 
 
229
 
WRITE8_MEMBER( mpz80_state::mmu_w )
230
 
{
231
 
        m_addr = get_address(offset);
232
 
 
233
 
        if (TASK0 && (offset < 0x1000))
234
 
        {
235
 
                if (offset < 0x400)
236
 
                {
237
 
                        UINT8 *ram = ram_get_ptr(m_ram);
238
 
                        ram[offset & 0x3ff] = data;
239
 
                }
240
 
                else if (offset == 0x400)
241
 
                {
242
 
                        disp_seg_w(space, 0, data);
243
 
                }
244
 
                else if (offset == 0x401)
245
 
                {
246
 
                        disp_col_w(space, 0, data);
247
 
                }
248
 
                else if (offset == 0x402)
249
 
                {
250
 
                        task_w(space, 0, data);
251
 
                }
252
 
                else if (offset == 0x403)
253
 
                {
254
 
                        mask_w(space, 0, data);
255
 
                }
256
 
                else if (offset >= 0x600 && offset < 0x800)
257
 
                {
258
 
                        m_map_ram[offset - 0x600] = data;
259
 
                }
260
 
                else
261
 
                {
262
 
                        logerror("Unmapped LOCAL write at %06x\n", offset);
263
 
                }
264
 
        }
265
 
        else
266
 
        {
267
 
                m_s100->mwrt_w(space, m_addr, data);
268
 
        }
269
 
}
270
 
 
271
 
 
272
 
//-------------------------------------------------
273
 
//  get_io_address -
274
 
//-------------------------------------------------
275
 
 
276
 
inline offs_t mpz80_state::get_io_address(offs_t offset)
277
 
{
278
 
        if (m_mask & MASK_ZIO_MODE)
279
 
        {
280
 
                // echo port address onto upper address lines (8080 emulation)
281
 
                offset = ((offset << 8) & 0xff00) | (offset & 0xff);
282
 
        }
283
 
 
284
 
        return offset;
285
 
}
286
 
 
287
 
 
288
 
//-------------------------------------------------
289
 
//  mmu_io_r -
290
 
//-------------------------------------------------
291
 
 
292
 
READ8_MEMBER( mpz80_state::mmu_io_r )
293
 
{
294
 
        return m_s100->sinp_r(space, get_io_address(offset));
295
 
}
296
 
 
297
 
 
298
 
//-------------------------------------------------
299
 
//  mmu_io_w -
300
 
//-------------------------------------------------
301
 
 
302
 
WRITE8_MEMBER( mpz80_state::mmu_io_w )
303
 
{
304
 
        m_s100->sout_w(space, get_io_address(offset), data);
305
 
}
306
 
 
307
 
 
308
 
//-------------------------------------------------
309
 
//  trap_addr_r - trap address register
310
 
//-------------------------------------------------
311
 
 
312
 
READ8_MEMBER( mpz80_state::trap_addr_r )
313
 
{
314
 
        /*
315
 
 
316
 
        bit     description
317
 
 
318
 
        0       DADDR 12
319
 
        1       DADDR 13
320
 
        2       DADDR 14
321
 
        3       DADDR 15
322
 
        4       I-ADDR 12
323
 
        5       I-ADDR 13
324
 
        6       I-ADDR 14
325
 
        7       I-ADDR 15
326
 
 
327
 
    */
328
 
 
329
 
        return m_trap_addr;
330
 
}
331
 
 
332
 
 
333
 
//-------------------------------------------------
334
 
//  status_r - trap status register
335
 
//-------------------------------------------------
336
 
 
337
 
READ8_MEMBER( mpz80_state::status_r )
338
 
{
339
 
        /*
340
 
 
341
 
        bit     description
342
 
 
343
 
        0       _TRAP VOID
344
 
        1       _IORQ
345
 
        2       _TRAP HALT
346
 
        3       _TRAP INT
347
 
        4       _TRAP STOP
348
 
        5       _TRAP AUX
349
 
        6       R10
350
 
        7       _RD STB
351
 
 
352
 
    */
353
 
 
354
 
        return m_status;
355
 
}
356
 
 
357
 
 
358
 
//-------------------------------------------------
359
 
//  task_w - task register
360
 
//-------------------------------------------------
361
 
 
362
 
WRITE8_MEMBER( mpz80_state::task_w )
363
 
{
364
 
        /*
365
 
 
366
 
        bit     description
367
 
 
368
 
        0       T0, A16
369
 
        1       T1, A17
370
 
        2       T2, A18
371
 
        3       T3, A19
372
 
        4       T4, S-100 A20
373
 
        5       T5, S-100 A21
374
 
        6       T6, S-100 A22
375
 
        7       T7, S-100 A23
376
 
 
377
 
    */
378
 
 
379
 
        m_task = data;
380
 
 
381
 
        m_trap_reset = 1;
382
 
        check_traps();
383
 
}
384
 
 
385
 
 
386
 
//-------------------------------------------------
387
 
//  mask_w - mask register
388
 
//-------------------------------------------------
389
 
 
390
 
WRITE8_MEMBER( mpz80_state::mask_w )
391
 
{
392
 
        /*
393
 
 
394
 
        bit     description
395
 
 
396
 
        0       _STOP ENBL
397
 
        1       AUX ENBL
398
 
        2       _TINT ENBL
399
 
        3       RUN ENBL
400
 
        4       _HALT ENBL
401
 
        5       SINT ENBL
402
 
        6       _IOENBL
403
 
        7       _ZIO MODE
404
 
 
405
 
    */
406
 
 
407
 
        m_mask = data;
408
 
}
409
 
 
410
 
 
411
 
 
412
 
//**************************************************************************
413
 
//  FRONT PANEL
414
 
//**************************************************************************
415
 
 
416
 
//-------------------------------------------------
417
 
//  keyboard_r - front panel keyboard
418
 
//-------------------------------------------------
419
 
 
420
 
READ8_MEMBER( mpz80_state::keyboard_r )
421
 
{
422
 
        /*
423
 
 
424
 
        bit     description
425
 
 
426
 
        0
427
 
        1
428
 
        2
429
 
        3
430
 
        4
431
 
        5
432
 
        6
433
 
        7
434
 
 
435
 
    */
436
 
 
437
 
        return 0;
438
 
}
439
 
 
440
 
 
441
 
//-------------------------------------------------
442
 
//  switch_r - switch register
443
 
//-------------------------------------------------
444
 
 
445
 
READ8_MEMBER( mpz80_state::switch_r )
446
 
{
447
 
        /*
448
 
 
449
 
        bit     description
450
 
 
451
 
        0       _TRAP RESET
452
 
        1       INT PEND
453
 
        2       16C S6
454
 
        3       16C S5
455
 
        4       16C S4
456
 
        5       16C S3
457
 
        6       16C S2
458
 
        7       16C S1
459
 
 
460
 
    */
461
 
 
462
 
        UINT8 data = 0;
463
 
 
464
 
        // trap reset
465
 
        data |= m_trap_reset;
466
 
 
467
 
        // interrupt pending
468
 
        data |= m_int_pend << 1;
469
 
 
470
 
        // boot address
471
 
        data |= input_port_read(machine(), "16C") & 0xfc;
472
 
 
473
 
        return data;
474
 
}
475
 
 
476
 
 
477
 
//-------------------------------------------------
478
 
//  disp_seg_w - front panel segment
479
 
//-------------------------------------------------
480
 
 
481
 
WRITE8_MEMBER( mpz80_state::disp_seg_w )
482
 
{
483
 
        /*
484
 
 
485
 
        bit     description
486
 
 
487
 
        0
488
 
        1
489
 
        2
490
 
        3
491
 
        4
492
 
        5
493
 
        6
494
 
        7
495
 
 
496
 
    */
497
 
}
498
 
 
499
 
 
500
 
//-------------------------------------------------
501
 
//  disp_col_w - front panel column
502
 
//-------------------------------------------------
503
 
 
504
 
WRITE8_MEMBER( mpz80_state::disp_col_w )
505
 
{
506
 
        /*
507
 
 
508
 
        bit     description
509
 
 
510
 
        0
511
 
        1
512
 
        2
513
 
        3
514
 
        4
515
 
        5
516
 
        6
517
 
        7
518
 
 
519
 
    */
520
 
}
521
 
 
522
 
 
523
 
 
524
 
//**************************************************************************
525
 
//  ADDRESS MAPS
526
 
//**************************************************************************
527
 
 
528
 
//-------------------------------------------------
529
 
//  ADDRESS_MAP( mpz80_mem )
530
 
//-------------------------------------------------
531
 
 
532
 
static ADDRESS_MAP_START( mpz80_mem, AS_PROGRAM, 8, mpz80_state )
533
 
        AM_RANGE(0x0000, 0xffff) AM_READWRITE(mmu_r, mmu_w)
534
 
/*
535
 
    Task 0 Segment 0 map:
536
 
 
537
 
    AM_RANGE(0x0000, 0x03ff) AM_RAM
538
 
    AM_RANGE(0x0400, 0x0400) AM_READWRITE(trap_addr_r, disp_seg_w)
539
 
    AM_RANGE(0x0401, 0x0401) AM_READWRITE(keyboard_r, disp_col_w)
540
 
    AM_RANGE(0x0402, 0x0402) AM_READWRITE(switch_r, task_w)
541
 
    AM_RANGE(0x0403, 0x0403) AM_READWRITE(status_r, mask_w)
542
 
    AM_RANGE(0x0600, 0x07ff) AM_RAM AM_BASE(m_map_ram)
543
 
    AM_RANGE(0x0800, 0x0bff) AM_ROM AM_REGION(Z80_TAG, 0)
544
 
    AM_RANGE(0x0c00, 0x0c00) AM_DEVREADWRITE(AM9512_TAG, am9512_device, read, write)
545
 
*/
546
 
ADDRESS_MAP_END
547
 
 
548
 
 
549
 
//-------------------------------------------------
550
 
//  ADDRESS_MAP( mpz80_io )
551
 
//-------------------------------------------------
552
 
 
553
 
static ADDRESS_MAP_START( mpz80_io, AS_IO, 8, mpz80_state )
554
 
        AM_RANGE(0x0000, 0xffff) AM_READWRITE(mmu_io_r, mmu_io_w)
555
 
ADDRESS_MAP_END
556
 
 
557
 
 
558
 
 
559
 
//**************************************************************************
560
 
//  INPUT PORTS
561
 
//**************************************************************************
562
 
 
563
 
//-------------------------------------------------
564
 
//  INPUT_PORTS( mpz80 )
565
 
//-------------------------------------------------
566
 
 
567
 
static INPUT_PORTS_START( mpz80 )
568
 
        PORT_START("16C")
569
 
        PORT_DIPNAME( 0xf8, 0xf8, "Power-On-Jump Address" ) PORT_DIPLOCATION("16C:1,2,3,4,5") PORT_CONDITION("12C", 0x02, PORTCOND_EQUALS, 0x02)
570
 
        PORT_DIPSETTING(    0xf8, "F800H" )
571
 
        PORT_DIPSETTING(    0xf0, "F000H" )
572
 
        PORT_DIPSETTING(    0xe8, "E800H" )
573
 
        PORT_DIPSETTING(    0xe0, "E000H" )
574
 
        PORT_DIPSETTING(    0xd8, "D800H" )
575
 
        PORT_DIPSETTING(    0xd0, "D000H" )
576
 
        PORT_DIPSETTING(    0xc8, "C800H" )
577
 
        PORT_DIPSETTING(    0xc0, "C000H" )
578
 
        PORT_DIPSETTING(    0xb8, "B800H" )
579
 
        PORT_DIPSETTING(    0xb0, "B000H" )
580
 
        PORT_DIPSETTING(    0xa8, "A800H" )
581
 
        PORT_DIPSETTING(    0xa0, "A000H" )
582
 
        PORT_DIPSETTING(    0x98, "9800H" )
583
 
        PORT_DIPSETTING(    0x90, "9000H" )
584
 
        PORT_DIPSETTING(    0x88, "8800H" )
585
 
        PORT_DIPSETTING(    0x80, "8000H" )
586
 
        PORT_DIPSETTING(    0x78, "7800H" )
587
 
        PORT_DIPSETTING(    0x70, "7000H" )
588
 
        PORT_DIPSETTING(    0x68, "6800H" )
589
 
        PORT_DIPSETTING(    0x60, "6000H" )
590
 
        PORT_DIPSETTING(    0x58, "5800H" )
591
 
        PORT_DIPSETTING(    0x50, "5000H" )
592
 
        PORT_DIPSETTING(    0x48, "4800H" )
593
 
        PORT_DIPSETTING(    0x40, "4000H" )
594
 
        PORT_DIPSETTING(    0x38, "3800H" )
595
 
        PORT_DIPSETTING(    0x30, "3000H" )
596
 
        PORT_DIPSETTING(    0x28, "2800H" )
597
 
        PORT_DIPSETTING(    0x20, "2000H" )
598
 
        PORT_DIPSETTING(    0x18, "1800H" )
599
 
        PORT_DIPSETTING(    0x10, "Boot DJ/DMA" )
600
 
        PORT_DIPSETTING(    0x08, "Boot HD/DMA" )
601
 
        PORT_DIPSETTING(    0x00, "Boot HDCA" )
602
 
        PORT_DIPNAME( 0x70, 0x00, "Diagnostics" ) PORT_DIPLOCATION("16C:2,3,4") PORT_CONDITION("12C", 0x02, PORTCOND_EQUALS, 0x00)
603
 
        PORT_DIPSETTING(    0x00, "Read Registers" )
604
 
        PORT_DIPSETTING(    0x10, "Write Registers" )
605
 
        PORT_DIPSETTING(    0x20, "Write Map RAMs" )
606
 
        PORT_DIPSETTING(    0x30, "Write R/W RAMs" )
607
 
        PORT_DIPSETTING(    0x40, "R/W FPP" )
608
 
        PORT_DIPSETTING(    0x50, "R/W S-100 Bus (High/Low)" )
609
 
        PORT_DIPSETTING(    0x60, "R/W S-100 Bus (Alternating)" )
610
 
        PORT_DIPSETTING(    0x70, "Read Switches" )
611
 
        PORT_DIPNAME( 0x04, 0x00, "Power Up" ) PORT_DIPLOCATION("16C:6")
612
 
        PORT_DIPSETTING(    0x04, "Boot Address" )
613
 
        PORT_DIPSETTING(    0x00, "Monitor" )
614
 
        PORT_DIPNAME( 0x02, 0x02, DEF_STR( Unused ) ) PORT_DIPLOCATION("16C:7")
615
 
        PORT_DIPSETTING(    0x02, DEF_STR( Off ) )
616
 
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )
617
 
        PORT_DIPNAME( 0x01, 0x00, "S-100 MWRITE" ) PORT_DIPLOCATION("16C:8")
618
 
        PORT_DIPSETTING(    0x01, "Disabled" )
619
 
        PORT_DIPSETTING(    0x00, "Enabled" )
620
 
 
621
 
        PORT_START("12C")
622
 
        PORT_DIPNAME( 0x02, 0x02, "Operation Mode" )
623
 
        PORT_DIPSETTING(    0x02, "Monitor" )
624
 
        PORT_DIPSETTING(    0x00, "Diagnostic" )
625
 
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN )
626
 
INPUT_PORTS_END
627
 
 
628
 
 
629
 
 
630
 
//**************************************************************************
631
 
//  DEVICE CONFIGURATION
632
 
//**************************************************************************
633
 
 
634
 
//-------------------------------------------------
635
 
//  floppy_interface floppy_intf
636
 
//-------------------------------------------------
637
 
 
638
 
static const floppy_interface floppy_intf =
639
 
{
640
 
    DEVCB_NULL,
641
 
    DEVCB_NULL,
642
 
    DEVCB_NULL,
643
 
    DEVCB_NULL,
644
 
    DEVCB_NULL,
645
 
    FLOPPY_STANDARD_8_DSDD,
646
 
    FLOPPY_OPTIONS_NAME(default),
647
 
    "floppy_8",
648
 
        NULL
649
 
};
650
 
 
651
 
//-------------------------------------------------
652
 
//  GENERIC_TERMINAL_INTERFACE( terminal_intf )
653
 
//-------------------------------------------------
654
 
 
655
 
static GENERIC_TERMINAL_INTERFACE( terminal_intf )
656
 
{
657
 
        DEVCB_DEVICE_MEMBER(S100_TAG, s100_device, terminal_receive_w)
658
 
};
659
 
 
660
 
 
661
 
//-------------------------------------------------
662
 
//  S100_INTERFACE( s100_intf )
663
 
//-------------------------------------------------
664
 
 
665
 
WRITE_LINE_MEMBER( mpz80_state::s100_pint_w )
666
 
{
667
 
        m_pint = (state == ASSERT_LINE) ? 0 : 1;
668
 
 
669
 
        check_interrupt();
670
 
}
671
 
 
672
 
WRITE_LINE_MEMBER( mpz80_state::s100_nmi_w )
673
 
{
674
 
        if (state == ASSERT_LINE)
675
 
        {
676
 
                m_nmi = 0;
677
 
        }
678
 
 
679
 
        check_interrupt();
680
 
}
681
 
 
682
 
static S100_INTERFACE( s100_intf )
683
 
{
684
 
        DEVCB_DRIVER_LINE_MEMBER(mpz80_state, s100_pint_w),
685
 
        DEVCB_DRIVER_LINE_MEMBER(mpz80_state, s100_nmi_w),
686
 
        DEVCB_NULL,
687
 
        DEVCB_NULL,
688
 
        DEVCB_NULL,
689
 
        DEVCB_NULL,
690
 
        DEVCB_NULL,
691
 
        DEVCB_NULL,
692
 
        DEVCB_NULL,
693
 
        DEVCB_NULL,
694
 
        DEVCB_NULL,
695
 
        DEVCB_NULL,
696
 
        DEVCB_NULL,
697
 
        DEVCB_NULL,
698
 
        DEVCB_NULL,
699
 
        DEVCB_NULL,
700
 
        DEVCB_NULL,
701
 
        DEVCB_DEVICE_HANDLER(TERMINAL_TAG, terminal_write)
702
 
};
703
 
 
704
 
static SLOT_INTERFACE_START( mpz80_s100_cards )
705
 
        SLOT_INTERFACE("mm65k16s", S100_MM65K16S)
706
 
        SLOT_INTERFACE("wunderbus", S100_WUNDERBUS)
707
 
        SLOT_INTERFACE("dj2db", S100_DJ2DB)
708
 
        SLOT_INTERFACE("djdma", S100_DJDMA)
709
 
//  SLOT_INTERFACE("multio", S100_MULTIO)
710
 
//  SLOT_INTERFACE("hdcdma", S100_HDCDMA)
711
 
//  SLOT_INTERFACE("hdca", S100_HDCA)
712
 
SLOT_INTERFACE_END
713
 
 
714
 
 
715
 
 
716
 
//**************************************************************************
717
 
//  MACHINE INITIALIZATION
718
 
//**************************************************************************
719
 
 
720
 
//-------------------------------------------------
721
 
//  MACHINE_START( mpz80 )
722
 
//-------------------------------------------------
723
 
 
724
 
void mpz80_state::machine_start()
725
 
{
726
 
        m_map_ram = auto_alloc_array_clear(machine(), UINT8, 0x200);
727
 
}
728
 
 
729
 
 
730
 
//-------------------------------------------------
731
 
//  MACHINE_RESET( mpz80 )
732
 
//-------------------------------------------------
733
 
 
734
 
void mpz80_state::machine_reset()
735
 
{
736
 
        m_trap_reset = 0;
737
 
        m_trap = 1;
738
 
        m_trap_start = 0;
739
 
 
740
 
        m_nmi = 1;
741
 
 
742
 
        check_interrupt();
743
 
}
744
 
 
745
 
 
746
 
 
747
 
//**************************************************************************
748
 
//  MACHINE DRIVERS
749
 
//**************************************************************************
750
 
 
751
 
//-------------------------------------------------
752
 
//  MACHINE_CONFIG( mpz80 )
753
 
//-------------------------------------------------
754
 
 
755
 
static MACHINE_CONFIG_START( mpz80, mpz80_state )
756
 
        // basic machine hardware
757
 
        MCFG_CPU_ADD(Z80_TAG, Z80, XTAL_4MHz)
758
 
        MCFG_CPU_PROGRAM_MAP(mpz80_mem)
759
 
        MCFG_CPU_IO_MAP(mpz80_io)
760
 
 
761
 
        // video hardware
762
 
        MCFG_FRAGMENT_ADD( generic_terminal )
763
 
 
764
 
        // S-100
765
 
        MCFG_S100_BUS_ADD(Z80_TAG, s100_intf)
766
 
        MCFG_S100_SLOT_ADD( 1,  "s100_1", mpz80_s100_cards, "mm65k16s")
767
 
        MCFG_S100_SLOT_ADD( 2,  "s100_2", mpz80_s100_cards, "wunderbus")
768
 
        MCFG_S100_SLOT_ADD( 3,  "s100_3", mpz80_s100_cards, "dj2db")
769
 
        MCFG_S100_SLOT_ADD( 4,  "s100_4", mpz80_s100_cards, NULL)//"hdcdma")
770
 
        MCFG_S100_SLOT_ADD( 5,  "s100_5", mpz80_s100_cards, NULL)
771
 
        MCFG_S100_SLOT_ADD( 6,  "s100_6", mpz80_s100_cards, NULL)
772
 
        MCFG_S100_SLOT_ADD( 7,  "s100_7", mpz80_s100_cards, NULL)
773
 
        MCFG_S100_SLOT_ADD( 8,  "s100_8", mpz80_s100_cards, NULL)
774
 
        MCFG_S100_SLOT_ADD( 9,  "s100_9", mpz80_s100_cards, NULL)
775
 
        MCFG_S100_SLOT_ADD(10, "s100_10", mpz80_s100_cards, NULL)
776
 
        MCFG_S100_SLOT_ADD(11, "s100_11", mpz80_s100_cards, NULL)
777
 
        MCFG_S100_SLOT_ADD(12, "s100_12", mpz80_s100_cards, NULL)
778
 
        MCFG_S100_SLOT_ADD(13, "s100_13", mpz80_s100_cards, NULL)
779
 
        MCFG_S100_SLOT_ADD(14, "s100_14", mpz80_s100_cards, NULL)
780
 
 
781
 
        // devices
782
 
        MCFG_FLOPPY_2_DRIVES_ADD(floppy_intf)
783
 
        MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, terminal_intf)
784
 
 
785
 
        // internal ram
786
 
        MCFG_RAM_ADD(RAM_TAG)
787
 
        MCFG_RAM_DEFAULT_SIZE("65K")
788
 
 
789
 
        // software list
790
 
        MCFG_SOFTWARE_LIST_ADD("flop_list", "mpz80")
791
 
MACHINE_CONFIG_END
792
 
 
793
 
 
794
 
 
795
 
//**************************************************************************
796
 
//  ROMS
797
 
//**************************************************************************
798
 
 
799
 
//-------------------------------------------------
800
 
//  ROM( mpz80 )
801
 
//-------------------------------------------------
802
 
 
803
 
ROM_START( mpz80 )
804
 
        ROM_REGION( 0x1000, Z80_TAG, 0 )
805
 
        ROM_DEFAULT_BIOS("447")
806
 
        ROM_SYSTEM_BIOS( 0, "373", "3.73" )
807
 
        ROMX_LOAD( "mpz80 mon3.73 fb34.17c", 0x0000, 0x1000, CRC(0bbffaec) SHA1(005ba726fc071f06cb1c969d170960438a3fc1a8), ROM_BIOS(1) )
808
 
        ROM_SYSTEM_BIOS( 1, "375", "3.75" )
809
 
        ROMX_LOAD( "mpz80 mon3.75 0706.17c", 0x0000, 0x1000, CRC(1118a592) SHA1(d70f94c09602cd0bdc4fbaeb14989e8cc1540960), ROM_BIOS(2) )
810
 
        ROM_SYSTEM_BIOS( 2, "447", "4.47" )
811
 
        ROMX_LOAD( "mon 4.47 f4f6.17c", 0x0000, 0x1000, CRC(b99c5d7f) SHA1(11181432ee524c7e5a68ead0671fc945256f5d1b), ROM_BIOS(3) )
812
 
 
813
 
        ROM_REGION( 0x20, "proms", 0 )
814
 
        ROM_LOAD( "z80-2 15a.15a", 0x00, 0x20, CRC(8a84249d) SHA1(dfbc49c5944f110f48419fd893fa84f4f0e113b8) ) // this is actually the 6331 PROM?
815
 
 
816
 
        ROM_REGION( 0x20, "plds", 0 )
817
 
        ROM_LOAD( "z80-2 5c.5c", 0x00, 0x20, NO_DUMP )
818
 
ROM_END
819
 
 
820
 
 
821
 
 
822
 
//**************************************************************************
823
 
//  DRIVER INITIALIZATION
824
 
//**************************************************************************
825
 
 
826
 
//-------------------------------------------------
827
 
//  DRIVER_INIT( abc800c )
828
 
//-------------------------------------------------
829
 
 
830
 
DIRECT_UPDATE_HANDLER( mpz80_direct_update_handler )
831
 
{
832
 
        mpz80_state *state = machine.driver_data<mpz80_state>();
833
 
 
834
 
        if (state->m_trap && address >= state->m_trap_start && address <= state->m_trap_start + 0xf)
835
 
        {
836
 
                direct.explicit_configure(state->m_trap_start, state->m_trap_start + 0xf, 0xf, machine.region(Z80_TAG)->base() + ((state->m_trap_reset << 10) | 0x3f0));
837
 
                return ~0;
838
 
        }
839
 
 
840
 
        return address;
841
 
}
842
 
 
843
 
static DRIVER_INIT( mpz80 )
844
 
{
845
 
        address_space *program = machine.device<cpu_device>(Z80_TAG)->space(AS_PROGRAM);
846
 
        program->set_direct_update_handler(direct_update_delegate(FUNC(mpz80_direct_update_handler), &machine));
847
 
}
848
 
 
849
 
 
850
 
 
851
 
//**************************************************************************
852
 
//  SYSTEM DRIVERS
853
 
//**************************************************************************
854
 
 
855
 
//    YEAR  NAME     PARENT  COMPAT  MACHINE  INPUT    INIT    COMPANY                          FULLNAME        FLAGS
856
 
COMP( 1980, mpz80,  0,      0,      mpz80,  mpz80,  mpz80,      "Morrow Designs",       "MPZ80",        GAME_NOT_WORKING | GAME_NO_SOUND_HW )