← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/mame/drivers/igs017.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mame/drivers/igs017.c
34
34
Notes:
35
35
 
36
36
- iqblocka: keep start or test pressed during boot to enter test mode A or B.
37
 
- mgcs, tjsb: press service + stats during test mode for sound test.
 
37
- lhzb2, mgcs, tjsb: press service + stats during test mode for sound test.
38
38
- mgdh: press A + B during test mode for sound test (B1+B2+B3 when using a joystick).
39
39
- mgdh: test mode is accessed by keeping test pressed during boot (as usual), but pressing F2+F3 in MAME
40
40
  does not actually work. It does work if F2 is pressed in the debug window at boot, and held while closing it.
44
44
#include "emu.h"
45
45
#include "cpu/m68000/m68000.h"
46
46
#include "cpu/z180/z180.h"
47
 
#include "machine/8255ppi.h"
 
47
#include "machine/i8255.h"
48
48
#include "sound/2413intf.h"
49
49
#include "sound/okim6295.h"
50
50
 
54
54
public:
55
55
        igs017_state(const machine_config &mconfig, device_type type, const char *tag)
56
56
                : driver_device(mconfig, type, tag),
57
 
                m_maincpu(*this, "maincpu")
58
 
                { }
 
57
                m_input_addr(-1),
 
58
                m_maincpu(*this, "maincpu"),
 
59
                m_spriteram(*this, "spriteram", 0),
 
60
                m_fg_videoram(*this, "fg_videoram", 0),
 
61
                m_bg_videoram(*this, "bg_videoram", 0){ }
 
62
 
 
63
        int m_input_addr;
 
64
        required_device<cpu_device> m_maincpu;
 
65
        optional_shared_ptr<UINT8> m_spriteram;
 
66
        optional_shared_ptr<UINT8> m_fg_videoram;
 
67
        optional_shared_ptr<UINT8> m_bg_videoram;
59
68
 
60
69
        int m_toggle;
61
70
        int m_debug_addr;
62
71
        int m_debug_width;
63
72
        UINT8 m_video_disable;
64
 
        UINT8 *m_fg_videoram;
65
 
        UINT8 *m_bg_videoram;
66
73
        tilemap_t *m_fg_tilemap;
67
74
        tilemap_t *m_bg_tilemap;
68
75
        UINT8 *m_sprites_gfx;
74
81
        UINT16 m_igs_magic[2];
75
82
        UINT8 m_scramble_data;
76
83
        int m_irq1_enable;
 
84
 
 
85
        // lhzb2a protection:
 
86
        UINT16 m_prot_regs[2], m_prot_val, m_prot_word, m_prot_m3, m_prot_mf;
 
87
        UINT8 m_prot2;
 
88
 
77
89
        int m_irq2_enable;
78
 
        UINT8 *m_spriteram;
79
 
 
80
 
        required_device<cpu_device> m_maincpu;
 
90
        DECLARE_WRITE8_MEMBER(video_disable_w);
 
91
        DECLARE_WRITE16_MEMBER(video_disable_lsb_w);
 
92
        DECLARE_WRITE8_MEMBER(fg_w);
 
93
        DECLARE_WRITE8_MEMBER(bg_w);
 
94
        DECLARE_READ16_MEMBER(fg_lsb_r);
 
95
        DECLARE_WRITE16_MEMBER(fg_lsb_w);
 
96
        DECLARE_READ16_MEMBER(bg_lsb_r);
 
97
        DECLARE_WRITE16_MEMBER(bg_lsb_w);
 
98
        DECLARE_READ16_MEMBER(spriteram_lsb_r);
 
99
        DECLARE_WRITE16_MEMBER(spriteram_lsb_w);
 
100
        DECLARE_WRITE8_MEMBER(nmi_enable_w);
 
101
        DECLARE_WRITE8_MEMBER(irq_enable_w);
 
102
        DECLARE_WRITE8_MEMBER(input_select_w);
 
103
        DECLARE_READ8_MEMBER(input_r);
 
104
        DECLARE_WRITE16_MEMBER(mgcs_magic_w);
 
105
        DECLARE_READ16_MEMBER(mgcs_magic_r);
 
106
        DECLARE_WRITE16_MEMBER(irq1_enable_w);
 
107
        DECLARE_WRITE16_MEMBER(irq2_enable_w);
 
108
        DECLARE_WRITE16_MEMBER(mgcs_paletteram_w);
 
109
        DECLARE_WRITE16_MEMBER(sdmg2_paletteram_w);
 
110
        DECLARE_READ8_MEMBER(sdmg2_keys_r);
 
111
        DECLARE_WRITE16_MEMBER(sdmg2_magic_w);
 
112
        DECLARE_READ16_MEMBER(sdmg2_magic_r);
 
113
        DECLARE_READ8_MEMBER(mgdh_keys_r);
 
114
        DECLARE_WRITE16_MEMBER(mgdha_magic_w);
 
115
        DECLARE_READ16_MEMBER(mgdha_magic_r);
 
116
        DECLARE_WRITE8_MEMBER(tjsb_paletteram_w);
 
117
        DECLARE_WRITE8_MEMBER(tjsb_output_w);
 
118
        DECLARE_READ8_MEMBER(tjsb_input_r);
 
119
        DECLARE_WRITE16_MEMBER(lhzb2a_paletteram_w);
 
120
        DECLARE_READ16_MEMBER(lhzb2a_input_r);
 
121
        DECLARE_WRITE16_MEMBER(lhzb2a_input_addr_w);
 
122
        DECLARE_WRITE16_MEMBER(lhzb2a_input_select_w);
 
123
 
 
124
        DECLARE_WRITE16_MEMBER(lhzb2a_prot_w);
 
125
        DECLARE_READ16_MEMBER(lhzb2a_prot_r);
 
126
 
 
127
        DECLARE_WRITE16_MEMBER(lhzb2a_prot2_reset_w);
 
128
        DECLARE_WRITE16_MEMBER(lhzb2a_prot2_inc_w);
 
129
        DECLARE_WRITE16_MEMBER(lhzb2a_prot2_dec_w);
 
130
        DECLARE_READ16_MEMBER(lhzb2a_prot2_r);
 
131
 
 
132
        DECLARE_WRITE16_MEMBER(lhzb2_magic_w);
 
133
        DECLARE_READ16_MEMBER(lhzb2_magic_r);
 
134
        DECLARE_WRITE16_MEMBER(slqz2_paletteram_w);
 
135
        DECLARE_WRITE16_MEMBER(slqz2_magic_w);
 
136
        DECLARE_READ16_MEMBER(slqz2_magic_r);
81
137
};
82
138
 
83
139
 
86
142
                                Video Hardware
87
143
***************************************************************************/
88
144
 
89
 
static WRITE8_HANDLER( video_disable_w )
 
145
WRITE8_MEMBER(igs017_state::video_disable_w)
90
146
{
91
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
92
 
        state->m_video_disable = data & 1;
 
147
        m_video_disable = data & 1;
93
148
        if (data & (~1))
94
 
                logerror("PC %06X: unknown bits of video_disable written = %02x\n",cpu_get_pc(&space->device()),data);
 
149
                logerror("%s: unknown bits of video_disable written = %02x\n", machine().describe_context(), data);
95
150
//  popmessage("VIDEO %02X",data);
96
151
}
97
 
static WRITE16_HANDLER( video_disable_lsb_w )
 
152
WRITE16_MEMBER(igs017_state::video_disable_lsb_w)
98
153
{
99
154
        if (ACCESSING_BITS_0_7)
100
155
                video_disable_w(space,offset,data);
124
179
        SET_TILE_INFO(0, code, COLOR(attr)+8, TILE_FLIPXY( attr >> 5 ));
125
180
}
126
181
 
127
 
static WRITE8_HANDLER( fg_w )
 
182
WRITE8_MEMBER(igs017_state::fg_w)
128
183
{
129
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
130
 
        state->m_fg_videoram[offset] = data;
131
 
        state->m_fg_tilemap->mark_tile_dirty(offset/4);
 
184
        m_fg_videoram[offset] = data;
 
185
        m_fg_tilemap->mark_tile_dirty(offset/4);
132
186
}
133
187
 
134
 
static WRITE8_HANDLER( bg_w )
 
188
WRITE8_MEMBER(igs017_state::bg_w)
135
189
{
136
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
137
 
        state->m_bg_videoram[offset] = data;
138
 
        state->m_bg_tilemap->mark_tile_dirty(offset/4);
 
190
        m_bg_videoram[offset] = data;
 
191
        m_bg_tilemap->mark_tile_dirty(offset/4);
139
192
}
140
193
 
141
194
// 16-bit handlers for an 8-bit chip
142
195
 
143
 
static READ16_HANDLER( fg_lsb_r )
 
196
READ16_MEMBER(igs017_state::fg_lsb_r)
144
197
{
145
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
146
 
        return state->m_fg_videoram[offset];
 
198
        return m_fg_videoram[offset];
147
199
}
148
 
static WRITE16_HANDLER( fg_lsb_w )
 
200
WRITE16_MEMBER(igs017_state::fg_lsb_w)
149
201
{
150
202
        if (ACCESSING_BITS_0_7)
151
203
                fg_w(space,offset,data);
152
204
}
153
205
 
154
 
static READ16_HANDLER( bg_lsb_r )
 
206
READ16_MEMBER(igs017_state::bg_lsb_r)
155
207
{
156
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
157
 
        return state->m_bg_videoram[offset];
 
208
        return m_bg_videoram[offset];
158
209
}
159
 
static WRITE16_HANDLER( bg_lsb_w )
 
210
WRITE16_MEMBER(igs017_state::bg_lsb_w)
160
211
{
161
212
        if (ACCESSING_BITS_0_7)
162
213
                bg_w(space,offset,data);
163
214
}
164
215
 
165
 
static READ16_HANDLER( spriteram_lsb_r )
 
216
READ16_MEMBER(igs017_state::spriteram_lsb_r)
166
217
{
167
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
168
 
        return state->m_spriteram[offset];
 
218
        return m_spriteram[offset];
169
219
}
170
 
static WRITE16_HANDLER( spriteram_lsb_w )
 
220
WRITE16_MEMBER(igs017_state::spriteram_lsb_w)
171
221
{
172
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
173
222
        if (ACCESSING_BITS_0_7)
174
 
                state->m_spriteram[offset] = data;
 
223
                m_spriteram[offset] = data;
175
224
}
176
225
 
177
226
 
178
227
 
179
 
// Eeach 16 bit word in the sprites gfx roms contains three 5 bit pens: x-22222-11111-00000.
 
228
// Eeach 16 bit word in the sprites gfx roms contains three 5 bit pens: x-22222-11111-00000 (little endian!).
180
229
// This routine expands each word into three bytes.
181
230
static void expand_sprites(running_machine &machine)
182
231
{
183
232
        igs017_state *state = machine.driver_data<igs017_state>();
184
 
        UINT8 *rom      =       machine.region("sprites")->base();
185
 
        int size        =       machine.region("sprites")->bytes();
 
233
        UINT8 *rom      =       state->memregion("sprites")->base();
 
234
        int size        =       state->memregion("sprites")->bytes();
186
235
        int i;
187
236
 
188
237
        state->m_sprites_gfx_size       =       size / 2 * 3;
316
365
                if (machine.input().code_pressed(KEYCODE_Y))            w -= 8;
317
366
 
318
367
                if (machine.input().code_pressed(KEYCODE_RIGHT))        a += 1;
319
 
                if (machine.input().code_pressed(KEYCODE_LEFT)) a -= 1;
 
368
                if (machine.input().code_pressed(KEYCODE_LEFT))         a -= 1;
320
369
 
321
 
                if (machine.input().code_pressed(KEYCODE_DOWN)) a += w;
 
370
                if (machine.input().code_pressed(KEYCODE_DOWN))         a += w;
322
371
                if (machine.input().code_pressed(KEYCODE_UP))           a -= w;
323
372
 
324
 
                if (machine.input().code_pressed(KEYCODE_PGDN)) a += w * h;
325
 
                if (machine.input().code_pressed(KEYCODE_PGUP)) a -= w * h;
 
373
                if (machine.input().code_pressed(KEYCODE_PGDN))         a += w * h;
 
374
                if (machine.input().code_pressed(KEYCODE_PGUP))         a -= w * h;
326
375
 
327
376
                if (a < 0)              a = 0;
328
377
                if (a > state->m_sprites_gfx_size)      a = state->m_sprites_gfx_size;
334
383
 
335
384
                draw_sprite(machine, bitmap, cliprect, 0,0, w,h, 0,0, 0, a);
336
385
 
337
 
                popmessage("a: %08X w: %03X p: %02X-%02x-%02x",a,w,state->m_sprites_gfx[a/3*3+0],state->m_sprites_gfx[a/3*3+1],state->m_sprites_gfx[a/3*3+2]);
 
386
                popmessage("a: %08X w: %03X p: %02x-%02x-%02x",a,w,state->m_sprites_gfx[a/3*3+0],state->m_sprites_gfx[a/3*3+1],state->m_sprites_gfx[a/3*3+2]);
338
387
                state->m_debug_addr = a;
339
388
                state->m_debug_width = w;
340
389
                osd_sleep(200000);
383
432
 
384
433
static void decrypt_program_rom(running_machine &machine, int mask, int a7, int a6, int a5, int a4, int a3, int a2, int a1, int a0)
385
434
{
386
 
        int length = machine.region("maincpu")->bytes();
387
 
        UINT8 *rom = machine.region("maincpu")->base();
 
435
        int length = machine.root_device().memregion("maincpu")->bytes();
 
436
        UINT8 *rom = machine.root_device().memregion("maincpu")->base();
388
437
        UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
389
438
        int i;
390
439
 
436
485
 
437
486
static void iqblocka_patch_rom(running_machine &machine)
438
487
{
439
 
        UINT8 *rom = machine.region("maincpu")->base();
 
488
        UINT8 *rom = machine.root_device().memregion("maincpu")->base();
440
489
 
441
490
//  rom[0x7b64] = 0xc9;
442
491
 
477
526
 
478
527
static void tjsb_decrypt_sprites(running_machine &machine)
479
528
{
480
 
        int length = machine.region("sprites")->bytes();
481
 
        UINT8 *rom = machine.region("sprites")->base();
 
529
        int length = machine.root_device().memregion("sprites")->bytes();
 
530
        UINT8 *rom = machine.root_device().memregion("sprites")->base();
482
531
        UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
483
532
        int i, addr;
484
533
 
485
 
        // address lines swap (to do: collapse into one bitswap)
486
 
        memcpy(tmp, rom, length);
487
 
        for (i = 0; i < length; i++)
488
 
        {
489
 
                addr = (i & ~0xff) | BITSWAP8(i,7,6,5,4,1,2,3,0);
490
 
                rom[i] = tmp[addr];
491
 
        }
492
 
 
493
 
        memcpy(tmp, rom, length);
494
 
        for (i = 0; i < length; i++)
495
 
        {
496
 
                addr = (i & ~0xff) | BITSWAP8(i,7,6,5,2,4,3,1,0);
497
 
                rom[i] = tmp[addr];
498
 
        }
499
 
 
500
 
        memcpy(tmp, rom, length);
501
 
        for (i = 0; i < length; i++)
502
 
        {
503
 
                addr = (i & ~0xff) | BITSWAP8(i,7,6,5,3,4,2,1,0);
 
534
        // address lines swap
 
535
        memcpy(tmp, rom, length);
 
536
        for (i = 0; i < length; i++)
 
537
        {
 
538
                addr = (i & ~0xff) | BITSWAP8(i,7,6,5,2,1,4,3,0);
504
539
                rom[i] = tmp[addr];
505
540
        }
506
541
 
507
542
        // data lines swap
508
543
        for (i = 0; i < length; i += 2)
509
544
        {
510
 
                // x-22222-11111-00000
511
 
                UINT16 data = (rom[i+1] << 8) | rom[i+0];
 
545
                UINT16 data = (rom[i+1] << 8) | rom[i+0];       // x-22222-11111-00000
512
546
                data = BITSWAP16(data, 15, 14,13,12,11,10, 9,1,7,6,5, 4,3,2,8,0);
 
547
                rom[i+0] = data;
513
548
                rom[i+1] = data >> 8;
514
 
                rom[i+0] = data;
515
549
        }
516
550
}
517
551
 
528
562
static void mgcs_decrypt_program_rom(running_machine &machine)
529
563
{
530
564
        int i;
531
 
        UINT16 *src = (UINT16 *)machine.region("maincpu")->base();
 
565
        UINT16 *src = (UINT16 *)machine.root_device().memregion("maincpu")->base();
532
566
 
533
567
        int rom_size = 0x80000;
534
568
 
577
611
 
578
612
static void mgcs_decrypt_tiles(running_machine &machine)
579
613
{
580
 
        int length = machine.region("tilemaps")->bytes();
581
 
        UINT8 *rom = machine.region("tilemaps")->base();
 
614
        int length = machine.root_device().memregion("tilemaps")->bytes();
 
615
        UINT8 *rom = machine.root_device().memregion("tilemaps")->base();
582
616
        UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
583
617
        int i;
584
618
 
594
628
 
595
629
static void mgcs_flip_sprites(running_machine &machine)
596
630
{
597
 
        int length = machine.region("sprites")->bytes();
598
 
        UINT8 *rom = machine.region("sprites")->base();
 
631
        int length = machine.root_device().memregion("sprites")->bytes();
 
632
        UINT8 *rom = machine.root_device().memregion("sprites")->base();
599
633
        int i;
600
634
 
601
635
        for (i = 0;i < length;i+=2)
615
649
 
616
650
static void mgcs_patch_rom(running_machine &machine)
617
651
{
618
 
        UINT16 *rom = (UINT16 *)machine.region("maincpu")->base();
 
652
        UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
619
653
 
620
654
        rom[0x4e036/2] = 0x6006;
621
655
 
641
675
// decryption is incomplete, the first part of code doesn't seem right.
642
676
static DRIVER_INIT( tarzan )
643
677
{
644
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
678
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
645
679
        int i;
646
680
        int size = 0x40000;
647
681
 
667
701
// by iq_132
668
702
static DRIVER_INIT( tarzana )
669
703
{
670
 
        UINT8 *ROM = machine.region("maincpu")->base();
 
704
        UINT8 *ROM = machine.root_device().memregion("maincpu")->base();
671
705
        int i;
672
706
        int size = 0x80000;
673
707
 
686
720
 
687
721
// starzan
688
722
 
689
 
// decryption is incomplete, data encryption is correct but opcodes are encrypted differently.
 
723
// decryption is incomplete: data decryption is correct but opcodes are encrypted differently.
690
724
 
691
725
static void starzan_decrypt(UINT8 *ROM, int size, bool isOpcode)
692
726
{
740
774
{
741
775
        int size = 0x040000;
742
776
 
743
 
        UINT8 *data = machine.region("maincpu")->base();
 
777
        UINT8 *data = machine.root_device().memregion("maincpu")->base();
744
778
        UINT8 *code = auto_alloc_array(machine, UINT8, size);
745
779
        memcpy(code, data, size);
746
780
 
758
792
static DRIVER_INIT( sdmg2 )
759
793
{
760
794
        int i;
761
 
        UINT16 *src = (UINT16 *)machine.region("maincpu")->base();
 
795
        UINT16 *src = (UINT16 *)machine.root_device().memregion("maincpu")->base();
762
796
 
763
797
        int rom_size = 0x80000;
764
798
 
815
849
static DRIVER_INIT( mgdha )
816
850
{
817
851
        int i;
818
 
        UINT16 *src = (UINT16 *)machine.region("maincpu")->base();
 
852
        UINT16 *src = (UINT16 *)machine.root_device().memregion("maincpu")->base();
819
853
 
820
854
        int rom_size = 0x80000;
821
855
 
850
884
{
851
885
        DRIVER_INIT_CALL( mgdha );
852
886
 
853
 
        UINT16 *rom = (UINT16 *)machine.region("maincpu")->base();
 
887
        UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
854
888
 
855
889
        // additional protection
856
890
        rom[0x4ad50/2] = 0x4e71;
859
893
 
860
894
// lhzb2
861
895
 
 
896
 
 
897
static void lhzb2_patch_rom(running_machine &machine)
 
898
{
 
899
        UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
 
900
 
 
901
        // Prot. checks:
 
902
        rom[0x14786/2] = 0x6044;        // 014786: 6744    beq $147cc
 
903
 
 
904
        // ROM check:
 
905
        rom[0x0b48a/2] = 0x604e;        // 00B48A: 674E    beq $b4da
 
906
}
 
907
 
 
908
static void lhzb2_decrypt_tiles(running_machine &machine)
 
909
{
 
910
        int length = machine.root_device().memregion("tilemaps")->bytes();
 
911
        UINT8 *rom = machine.root_device().memregion("tilemaps")->base();
 
912
        UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
 
913
        int i;
 
914
 
 
915
        int addr;
 
916
        memcpy(tmp, rom, length);
 
917
        for (i = 0; i < length; i++)
 
918
        {
 
919
                addr = (i & ~0xffffff) | BITSWAP24(i,23,22,21,20,19,18,17,1,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,0);
 
920
                rom[i] = tmp[addr];
 
921
        }
 
922
 
 
923
        auto_free(machine, tmp);
 
924
}
 
925
 
 
926
static void lhzb2_decrypt_sprites(running_machine &machine)
 
927
{
 
928
        int length = machine.root_device().memregion("sprites")->bytes();
 
929
        UINT8 *rom = machine.root_device().memregion("sprites")->base();
 
930
        UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
 
931
        int i, addr;
 
932
 
 
933
        // address lines swap
 
934
        memcpy(tmp, rom, length);
 
935
        for (i = 0; i < length; i++)
 
936
        {
 
937
                addr = (i & ~0xffff) | BITSWAP16(i,15,14,13,6,7,10,9,8,11,12,5,4,3,2,1,0);
 
938
                rom[i] = tmp[addr];
 
939
        }
 
940
 
 
941
        // data lines swap
 
942
        for (i = 0;i < length;i+=2)
 
943
        {
 
944
                UINT16 data = (rom[i+1] << 8) | rom[i+0];       // x-22222-11111-00000
 
945
                data = BITSWAP16(data, 15, 7,6,5,4,3, 2,1,0,14,13, 12,11,10,9,8);
 
946
                rom[i+0] = data;
 
947
                rom[i+1] = data >> 8;
 
948
        }
 
949
}
 
950
 
862
951
static DRIVER_INIT( lhzb2 )
863
952
{
864
953
        int i;
865
 
        UINT16 *src = (UINT16 *) (machine.region("maincpu")->base());
 
954
        UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
866
955
 
867
956
        int rom_size = 0x80000;
868
957
 
944
1033
 
945
1034
                src[i] = x;
946
1035
        }
 
1036
 
 
1037
        lhzb2_decrypt_tiles(machine);
 
1038
        lhzb2_decrypt_sprites(machine);
 
1039
        lhzb2_patch_rom(machine);
947
1040
}
948
1041
 
949
1042
 
952
1045
static DRIVER_INIT( lhzb2a )
953
1046
{
954
1047
        int i;
955
 
        UINT16 *src = (UINT16 *) (machine.region("maincpu")->base());
 
1048
        UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
956
1049
 
957
1050
        int rom_size = 0x80000;
958
1051
 
1006
1099
 
1007
1100
                src[i] = x;
1008
1101
        }
 
1102
 
 
1103
        lhzb2_decrypt_tiles(machine);
 
1104
        lhzb2_decrypt_sprites(machine);
1009
1105
}
1010
1106
 
1011
1107
 
1012
1108
//slqz2
1013
1109
 
 
1110
static void slqz2_patch_rom(running_machine &machine)
 
1111
{
 
1112
        UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
 
1113
 
 
1114
        // Prot. checks:
 
1115
        rom[0x1489c/2] = 0x6044;        // 01489C: 6744    beq $148e2
 
1116
 
 
1117
        // ROM check:
 
1118
        rom[0x0b77a/2] = 0x604e;        // 00B77A: 674E    beq $b7ca
 
1119
}
 
1120
 
 
1121
static void slqz2_decrypt_tiles(running_machine &machine)
 
1122
{
 
1123
        int length = machine.root_device().memregion("tilemaps")->bytes();
 
1124
        UINT8 *rom = machine.root_device().memregion("tilemaps")->base();
 
1125
        UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
 
1126
        int i;
 
1127
 
 
1128
        memcpy(tmp,rom,length);
 
1129
        for (i = 0;i < length;i++)
 
1130
        {
 
1131
                int addr = (i & ~0xff) | BITSWAP8(i,7,4,5,6,3,2,1,0);
 
1132
                rom[i] = tmp[addr];
 
1133
        }
 
1134
 
 
1135
        auto_free(machine, tmp);
 
1136
}
 
1137
 
1014
1138
static DRIVER_INIT( slqz2 )
1015
1139
{
1016
1140
        int i;
1017
 
        UINT16 *src = (UINT16 *) (machine.region("maincpu")->base());
 
1141
        UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
1018
1142
 
1019
1143
        int rom_size = 0x80000;
1020
1144
 
1086
1210
 
1087
1211
                src[i] = x;
1088
1212
        }
 
1213
 
 
1214
        slqz2_decrypt_tiles(machine);
 
1215
        lhzb2_decrypt_sprites(machine);
 
1216
        slqz2_patch_rom(machine);
1089
1217
}
1090
1218
 
1091
1219
/***************************************************************************
1092
1220
                                Memory Maps
1093
1221
***************************************************************************/
1094
1222
 
1095
 
static ADDRESS_MAP_START( iqblocka_map, AS_PROGRAM, 8 )
 
1223
 
 
1224
// iqblocka
 
1225
 
 
1226
 
 
1227
static ADDRESS_MAP_START( iqblocka_map, AS_PROGRAM, 8, igs017_state )
1096
1228
        AM_RANGE( 0x00000, 0x0dfff ) AM_ROM
1097
1229
        AM_RANGE( 0x0e000, 0x0efff ) AM_RAM
1098
1230
        AM_RANGE( 0x0f000, 0x0ffff ) AM_RAM
1099
1231
        AM_RANGE( 0x10000, 0x3ffff ) AM_ROM
1100
1232
ADDRESS_MAP_END
1101
1233
 
1102
 
static WRITE8_HANDLER( nmi_enable_w )
1103
 
{
1104
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1105
 
        state->m_nmi_enable = data & 1;
1106
 
        if (data & (~1))
1107
 
                logerror("PC %06X: nmi_enable = %02x\n",cpu_get_pc(&space->device()),data);
1108
 
}
1109
 
 
1110
 
static WRITE8_HANDLER( irq_enable_w )
1111
 
{
1112
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1113
 
        state->m_irq_enable = data & 1;
1114
 
        if (data & (~1))
1115
 
                logerror("PC %06X: irq_enable = %02x\n",cpu_get_pc(&space->device()),data);
1116
 
}
1117
 
 
1118
 
static WRITE8_HANDLER( input_select_w )
1119
 
{
1120
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1121
 
        state->m_input_select = data;
1122
 
}
1123
 
 
1124
 
static READ8_HANDLER( input_r )
1125
 
{
1126
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1127
 
        switch (state->m_input_select)
 
1234
WRITE8_MEMBER(igs017_state::nmi_enable_w)
 
1235
{
 
1236
        m_nmi_enable = data & 1;
 
1237
        if (data & (~1))
 
1238
                logerror("%s: nmi_enable = %02x\n", machine().describe_context(), data);
 
1239
}
 
1240
 
 
1241
WRITE8_MEMBER(igs017_state::irq_enable_w)
 
1242
{
 
1243
        m_irq_enable = data & 1;
 
1244
        if (data & (~1))
 
1245
                logerror("%s: irq_enable = %02x\n", machine().describe_context(), data);
 
1246
}
 
1247
 
 
1248
WRITE8_MEMBER(igs017_state::input_select_w)
 
1249
{
 
1250
        m_input_select = data;
 
1251
}
 
1252
 
 
1253
READ8_MEMBER(igs017_state::input_r)
 
1254
{
 
1255
        switch (m_input_select)
1128
1256
        {
1129
 
                case 0x00:      return input_port_read(space->machine(), "PLAYER1");
1130
 
                case 0x01:      return input_port_read(space->machine(), "PLAYER2");
1131
 
                case 0x02:      return input_port_read(space->machine(), "COINS");
 
1257
                case 0x00:      return ioport("PLAYER1")->read();
 
1258
                case 0x01:      return ioport("PLAYER2")->read();
 
1259
                case 0x02:      return ioport("COINS")->read();
1132
1260
 
1133
1261
                case 0x03:      return 01;
1134
1262
 
1155
1283
                case 0x34:      return 0x32;
1156
1284
 
1157
1285
                default:
1158
 
                        logerror("PC %06X: input %02x read\n",cpu_get_pc(&space->device()),state->m_input_select);
 
1286
                        logerror("%s: input %02x read\n", machine().describe_context(), m_input_select);
1159
1287
                        return 0xff;
1160
1288
        }
1161
1289
}
1162
1290
 
1163
 
static ADDRESS_MAP_START( iqblocka_io, AS_IO, 8 )
 
1291
static ADDRESS_MAP_START( iqblocka_io, AS_IO, 8, igs017_state )
1164
1292
        AM_RANGE( 0x0000, 0x003f ) AM_RAM // internal regs
1165
1293
 
1166
 
        AM_RANGE( 0x1000, 0x17ff ) AM_RAM AM_BASE_MEMBER(igs017_state, m_spriteram)
1167
 
        AM_RANGE( 0x1800, 0x1bff ) AM_RAM_WRITE( paletteram_xRRRRRGGGGGBBBBB_le_w ) AM_BASE_GENERIC(paletteram)
 
1294
        AM_RANGE( 0x1000, 0x17ff ) AM_RAM AM_SHARE("spriteram")
 
1295
        AM_RANGE( 0x1800, 0x1bff ) AM_RAM_WRITE(paletteram_xRRRRRGGGGGBBBBB_byte_le_w ) AM_SHARE("paletteram")
1168
1296
        AM_RANGE( 0x1c00, 0x1fff ) AM_RAM
1169
1297
 
1170
1298
//  AM_RANGE(0x200a, 0x200a) AM_WRITENOP
1171
1299
 
1172
 
        AM_RANGE( 0x2010, 0x2013 ) AM_DEVREAD("ppi8255", ppi8255_r)
1173
 
        AM_RANGE( 0x2012, 0x2012 ) AM_WRITE( video_disable_w )
1174
 
 
1175
 
        AM_RANGE( 0x2014, 0x2014 ) AM_WRITE( nmi_enable_w )
1176
 
        AM_RANGE( 0x2015, 0x2015 ) AM_WRITE( irq_enable_w )
1177
 
 
1178
 
        AM_RANGE( 0x4000, 0x5fff ) AM_RAM_WRITE( fg_w ) AM_BASE_MEMBER(igs017_state, m_fg_videoram )
1179
 
        AM_RANGE( 0x6000, 0x7fff ) AM_RAM_WRITE( bg_w ) AM_BASE_MEMBER(igs017_state, m_bg_videoram )
1180
 
 
1181
 
        AM_RANGE( 0x8000, 0x8000 ) AM_WRITE( input_select_w )
1182
 
        AM_RANGE( 0x8001, 0x8001 ) AM_READ ( input_r )
1183
 
 
1184
 
        AM_RANGE( 0x9000, 0x9000 ) AM_DEVREADWRITE_MODERN("oki", okim6295_device, read, write)
 
1300
        AM_RANGE( 0x2010, 0x2013 ) AM_DEVREAD("ppi8255", i8255_device, read)
 
1301
        AM_RANGE( 0x2012, 0x2012 ) AM_WRITE(video_disable_w )
 
1302
 
 
1303
        AM_RANGE( 0x2014, 0x2014 ) AM_WRITE(nmi_enable_w )
 
1304
        AM_RANGE( 0x2015, 0x2015 ) AM_WRITE(irq_enable_w )
 
1305
 
 
1306
        AM_RANGE( 0x4000, 0x5fff ) AM_RAM_WRITE(fg_w ) AM_SHARE("fg_videoram")
 
1307
        AM_RANGE( 0x6000, 0x7fff ) AM_RAM_WRITE(bg_w ) AM_SHARE("bg_videoram")
 
1308
 
 
1309
        AM_RANGE( 0x8000, 0x8000 ) AM_WRITE(input_select_w )
 
1310
        AM_RANGE( 0x8001, 0x8001 ) AM_READ(input_r )
 
1311
 
 
1312
        AM_RANGE( 0x9000, 0x9000 ) AM_DEVREADWRITE("oki", okim6295_device, read, write)
1185
1313
 
1186
1314
        AM_RANGE( 0xa000, 0xa000 ) AM_READ_PORT( "BUTTONS" )
1187
1315
 
1188
 
        AM_RANGE( 0xb000, 0xb001 ) AM_DEVWRITE( "ymsnd", ym2413_w )
 
1316
        AM_RANGE( 0xb000, 0xb001 ) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w )
1189
1317
ADDRESS_MAP_END
1190
1318
 
1191
1319
 
1192
1320
// mgcs
1193
1321
 
1194
1322
 
1195
 
static WRITE16_HANDLER( mgcs_magic_w )
 
1323
WRITE16_MEMBER(igs017_state::mgcs_magic_w)
1196
1324
{
1197
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1198
 
        COMBINE_DATA(&state->m_igs_magic[offset]);
 
1325
        COMBINE_DATA(&m_igs_magic[offset]);
1199
1326
 
1200
1327
        if (offset == 0)
1201
1328
                return;
1202
1329
 
1203
 
        switch(state->m_igs_magic[0])
 
1330
        switch(m_igs_magic[0])
1204
1331
        {
1205
1332
                case 0x00:
1206
1333
                        if (ACCESSING_BITS_0_7)
1207
1334
                        {
1208
 
                                state->m_input_select = data & 0xff;
 
1335
                                m_input_select = data & 0xff;
1209
1336
                        }
1210
1337
 
1211
 
                        if ( state->m_input_select & ~0xf8 )
1212
 
                                logerror("%06x: warning, unknown bits written in input_select = %02x\n", cpu_get_pc(&space->device()), state->m_input_select);
 
1338
                        if ( m_input_select & ~0xf8 )
 
1339
                                logerror("%s: warning, unknown bits written in input_select = %02x\n", machine().describe_context(), m_input_select);
1213
1340
                        break;
1214
1341
 
1215
1342
                case 0x01:
1216
1343
                        if (ACCESSING_BITS_0_7)
1217
1344
                        {
1218
 
                                state->m_scramble_data = data & 0xff;
 
1345
                                m_scramble_data = data & 0xff;
1219
1346
                        }
1220
1347
                        break;
1221
1348
 
1223
1350
                // case 0x03: ?
1224
1351
 
1225
1352
                default:
1226
 
                        logerror("%06x: warning, writing to igs_magic %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0], data);
 
1353
                        logerror("%s: warning, writing to igs_magic %02x = %02x\n", machine().describe_context(), m_igs_magic[0], data);
1227
1354
        }
1228
1355
}
1229
1356
 
1230
 
static READ16_HANDLER( mgcs_magic_r )
 
1357
READ16_MEMBER(igs017_state::mgcs_magic_r)
1231
1358
{
1232
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1233
 
        switch(state->m_igs_magic[0])
 
1359
        switch(m_igs_magic[0])
1234
1360
        {
1235
1361
                case 0x01:
1236
 
                        return BITSWAP8(state->m_scramble_data, 4,5,6,7, 0,1,2,3);
 
1362
                        return BITSWAP8(m_scramble_data, 4,5,6,7, 0,1,2,3);
1237
1363
 
1238
1364
                default:
1239
 
                        logerror("%06x: warning, reading with igs_magic = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0]);
 
1365
                        logerror("%s: warning, reading with igs_magic = %02x\n", machine().describe_context(), m_igs_magic[0]);
1240
1366
                        break;
1241
1367
        }
1242
1368
 
1246
1372
static READ8_DEVICE_HANDLER( mgcs_keys_r )
1247
1373
{
1248
1374
        igs017_state *state = device->machine().driver_data<igs017_state>();
1249
 
        if (~state->m_input_select & 0x08)      return input_port_read(device->machine(), "KEY0");
1250
 
        if (~state->m_input_select & 0x10)      return input_port_read(device->machine(), "KEY1");
1251
 
        if (~state->m_input_select & 0x20)      return input_port_read(device->machine(), "KEY2");
1252
 
        if (~state->m_input_select & 0x40)      return input_port_read(device->machine(), "KEY3");
1253
 
        if (~state->m_input_select & 0x80)      return input_port_read(device->machine(), "KEY4");
 
1375
        if (~state->m_input_select & 0x08)      return state->ioport("KEY0")->read();
 
1376
        if (~state->m_input_select & 0x10)      return state->ioport("KEY1")->read();
 
1377
        if (~state->m_input_select & 0x20)      return state->ioport("KEY2")->read();
 
1378
        if (~state->m_input_select & 0x40)      return state->ioport("KEY3")->read();
 
1379
        if (~state->m_input_select & 0x80)      return state->ioport("KEY4")->read();
1254
1380
 
1255
1381
        logerror("%s: warning, reading key with input_select = %02x\n", device->machine().describe_context(), state->m_input_select);
1256
1382
        return 0xff;
1257
1383
}
1258
1384
 
1259
 
static WRITE16_HANDLER( irq1_enable_w )
1260
 
{
1261
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1262
 
        if (ACCESSING_BITS_0_7)
1263
 
                state->m_irq1_enable = data & 1;
1264
 
 
1265
 
        if (data != 0 && data != 0xff)
1266
 
                logerror("PC %06X: irq1_enable = %04x\n",cpu_get_pc(&space->device()),data);
1267
 
}
1268
 
 
1269
 
static WRITE16_HANDLER( irq2_enable_w )
1270
 
{
1271
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1272
 
        if (ACCESSING_BITS_0_7)
1273
 
                state->m_irq2_enable = data & 1;
1274
 
 
1275
 
        if (data != 0 && data != 0xff)
1276
 
                logerror("PC %06X: irq2_enable = %04x\n",cpu_get_pc(&space->device()),data);
1277
 
}
1278
 
 
1279
 
static WRITE16_HANDLER( mgcs_paletteram_w )
1280
 
{
1281
 
        COMBINE_DATA(&space->machine().generic.paletteram.u16[offset]);
1282
 
 
1283
 
        int bgr = ((space->machine().generic.paletteram.u16[offset/2*2+0] & 0xff) << 8) | (space->machine().generic.paletteram.u16[offset/2*2+1] & 0xff);
 
1385
WRITE16_MEMBER(igs017_state::irq1_enable_w)
 
1386
{
 
1387
        if (ACCESSING_BITS_0_7)
 
1388
                m_irq1_enable = data & 1;
 
1389
 
 
1390
        if (data != 0 && data != 0xff)
 
1391
                logerror("%s: irq1_enable = %04x\n", machine().describe_context(), data);
 
1392
}
 
1393
 
 
1394
WRITE16_MEMBER(igs017_state::irq2_enable_w)
 
1395
{
 
1396
        if (ACCESSING_BITS_0_7)
 
1397
                m_irq2_enable = data & 1;
 
1398
 
 
1399
        if (data != 0 && data != 0xff)
 
1400
                logerror("%s: irq2_enable = %04x\n", machine().describe_context(), data);
 
1401
}
 
1402
 
 
1403
WRITE16_MEMBER(igs017_state::mgcs_paletteram_w)
 
1404
{
 
1405
        COMBINE_DATA(&m_generic_paletteram_16[offset]);
 
1406
 
 
1407
        int bgr = ((m_generic_paletteram_16[offset/2*2+0] & 0xff) << 8) | (m_generic_paletteram_16[offset/2*2+1] & 0xff);
1284
1408
 
1285
1409
        // bitswap
1286
1410
        bgr = BITSWAP16(bgr, 7,8,9,2,14,3,13,15,12,11,10,0,1,4,5,6);
1287
1411
 
1288
 
        palette_set_color_rgb(space->machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
 
1412
        palette_set_color_rgb(machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
1289
1413
}
1290
1414
 
1291
 
static ADDRESS_MAP_START( mgcs, AS_PROGRAM, 16 )
 
1415
static ADDRESS_MAP_START( mgcs, AS_PROGRAM, 16, igs017_state )
1292
1416
        AM_RANGE( 0x000000, 0x07ffff ) AM_ROM
1293
1417
        AM_RANGE( 0x300000, 0x303fff ) AM_RAM
1294
 
        AM_RANGE( 0x49c000, 0x49c003 ) AM_WRITE( mgcs_magic_w )
1295
 
        AM_RANGE( 0x49c002, 0x49c003 ) AM_READ ( mgcs_magic_r )
1296
 
        AM_RANGE( 0xa02000, 0xa02fff ) AM_READWRITE( spriteram_lsb_r, spriteram_lsb_w ) AM_BASE_MEMBER(igs017_state, m_spriteram)
1297
 
        AM_RANGE( 0xa03000, 0xa037ff ) AM_RAM_WRITE( mgcs_paletteram_w ) AM_BASE_GENERIC( paletteram )
1298
 
        AM_RANGE( 0xa04020, 0xa04027 ) AM_DEVREAD8( "ppi8255", ppi8255_r, 0x00ff )
1299
 
        AM_RANGE( 0xa04024, 0xa04025 ) AM_WRITE( video_disable_lsb_w )
1300
 
        AM_RANGE( 0xa04028, 0xa04029 ) AM_WRITE( irq2_enable_w )
1301
 
        AM_RANGE( 0xa0402a, 0xa0402b ) AM_WRITE( irq1_enable_w )
1302
 
        AM_RANGE( 0xa08000, 0xa0bfff ) AM_READWRITE( fg_lsb_r, fg_lsb_w ) AM_BASE_MEMBER(igs017_state, m_fg_videoram )
1303
 
        AM_RANGE( 0xa0c000, 0xa0ffff ) AM_READWRITE( bg_lsb_r, bg_lsb_w ) AM_BASE_MEMBER(igs017_state, m_bg_videoram )
1304
 
        AM_RANGE( 0xa12000, 0xa12001 ) AM_DEVREADWRITE8_MODERN("oki", okim6295_device, read, write, 0x00ff )
 
1418
        AM_RANGE( 0x49c000, 0x49c003 ) AM_WRITE(mgcs_magic_w )
 
1419
        AM_RANGE( 0x49c002, 0x49c003 ) AM_READ(mgcs_magic_r )
 
1420
        AM_RANGE( 0xa02000, 0xa02fff ) AM_READWRITE(spriteram_lsb_r, spriteram_lsb_w ) AM_SHARE("spriteram")
 
1421
        AM_RANGE( 0xa03000, 0xa037ff ) AM_RAM_WRITE(mgcs_paletteram_w ) AM_SHARE("paletteram")
 
1422
        AM_RANGE( 0xa04020, 0xa04027 ) AM_DEVREAD8("ppi8255", i8255_device, read, 0x00ff)
 
1423
        AM_RANGE( 0xa04024, 0xa04025 ) AM_WRITE(video_disable_lsb_w )
 
1424
        AM_RANGE( 0xa04028, 0xa04029 ) AM_WRITE(irq2_enable_w )
 
1425
        AM_RANGE( 0xa0402a, 0xa0402b ) AM_WRITE(irq1_enable_w )
 
1426
        AM_RANGE( 0xa08000, 0xa0bfff ) AM_READWRITE(fg_lsb_r, fg_lsb_w ) AM_SHARE("fg_videoram")
 
1427
        AM_RANGE( 0xa0c000, 0xa0ffff ) AM_READWRITE(bg_lsb_r, bg_lsb_w ) AM_SHARE("bg_videoram")
 
1428
        AM_RANGE( 0xa12000, 0xa12001 ) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
1305
1429
        // oki banking through protection (code at $1a350)?
1306
1430
ADDRESS_MAP_END
1307
1431
 
1308
1432
 
1309
1433
// sdmg2
1310
1434
 
1311
 
static WRITE16_HANDLER( sdmg2_paletteram_w )
 
1435
 
 
1436
WRITE16_MEMBER(igs017_state::sdmg2_paletteram_w)
1312
1437
{
1313
 
        COMBINE_DATA(&space->machine().generic.paletteram.u16[offset]);
1314
 
 
1315
 
        int bgr = ((space->machine().generic.paletteram.u16[offset/2*2+1] & 0xff) << 8) | (space->machine().generic.paletteram.u16[offset/2*2+0] & 0xff);
1316
 
 
1317
 
        palette_set_color_rgb(space->machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
 
1438
        COMBINE_DATA(&m_generic_paletteram_16[offset]);
 
1439
 
 
1440
        int bgr = ((m_generic_paletteram_16[offset/2*2+1] & 0xff) << 8) | (m_generic_paletteram_16[offset/2*2+0] & 0xff);
 
1441
 
 
1442
        palette_set_color_rgb(machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
1318
1443
}
1319
1444
 
1320
 
static READ8_HANDLER( sdmg2_keys_r )
 
1445
READ8_MEMBER(igs017_state::sdmg2_keys_r)
1321
1446
{
1322
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1323
 
        if (~state->m_input_select & 0x01)      return input_port_read(space->machine(), "KEY0");
1324
 
        if (~state->m_input_select & 0x02)      return input_port_read(space->machine(), "KEY1");
1325
 
        if (~state->m_input_select & 0x04)      return input_port_read(space->machine(), "KEY2");
1326
 
        if (~state->m_input_select & 0x08)      return input_port_read(space->machine(), "KEY3");
1327
 
        if (~state->m_input_select & 0x10)      return input_port_read(space->machine(), "KEY4");
1328
 
 
1329
 
        if (state->m_input_select == 0x1f)      return input_port_read(space->machine(), "KEY0");       // in joystick mode
1330
 
 
1331
 
        logerror("%s: warning, reading key with input_select = %02x\n", space->machine().describe_context(), state->m_input_select);
 
1447
        if (~m_input_select & 0x01)     return ioport("KEY0")->read();
 
1448
        if (~m_input_select & 0x02)     return ioport("KEY1")->read();
 
1449
        if (~m_input_select & 0x04)     return ioport("KEY2")->read();
 
1450
        if (~m_input_select & 0x08)     return ioport("KEY3")->read();
 
1451
        if (~m_input_select & 0x10)     return ioport("KEY4")->read();
 
1452
 
 
1453
        if (m_input_select == 0x1f)     return ioport("KEY0")->read();  // in joystick mode
 
1454
 
 
1455
        logerror("%s: warning, reading key with input_select = %02x\n", machine().describe_context(), m_input_select);
1332
1456
        return 0xff;
1333
1457
}
1334
1458
 
1335
 
static WRITE16_HANDLER( sdmg2_magic_w )
 
1459
WRITE16_MEMBER(igs017_state::sdmg2_magic_w)
1336
1460
{
1337
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1338
 
        COMBINE_DATA(&state->m_igs_magic[offset]);
 
1461
        COMBINE_DATA(&m_igs_magic[offset]);
1339
1462
 
1340
1463
        if (offset == 0)
1341
1464
                return;
1342
1465
 
1343
 
        switch(state->m_igs_magic[0])
 
1466
        switch(m_igs_magic[0])
1344
1467
        {
1345
1468
                // case 0x00: ? 0x80
1346
1469
 
1347
1470
                case 0x01:
1348
1471
                        if (ACCESSING_BITS_0_7)
1349
1472
                        {
1350
 
                                state->m_input_select   =       data & 0x1f;
1351
 
                                coin_counter_w(space->machine(), 0,     data & 0x20);
 
1473
                                m_input_select  =       data & 0x1f;
 
1474
                                coin_counter_w(machine(), 0,    data & 0x20);
1352
1475
                                //  coin out        data & 0x40
1353
 
                                state->m_hopper                 =       data & 0x80;
 
1476
                                m_hopper                        =       data & 0x80;
1354
1477
                        }
1355
1478
                        break;
1356
1479
 
1357
1480
                case 0x02:
1358
1481
                        if (ACCESSING_BITS_0_7)
1359
1482
                        {
1360
 
                                okim6295_device *oki = space->machine().device<okim6295_device>("oki");
 
1483
                                okim6295_device *oki = machine().device<okim6295_device>("oki");
1361
1484
                                oki->set_bank_base((data & 0x80) ? 0x40000 : 0);
1362
1485
                        }
1363
1486
                        break;
1364
1487
 
1365
1488
                default:
1366
 
                        logerror("%06x: warning, writing to igs_magic %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0], data);
 
1489
                        logerror("%s: warning, writing to igs_magic %02x = %02x\n", machine().describe_context(), m_igs_magic[0], data);
1367
1490
        }
1368
1491
}
1369
1492
 
1370
 
static READ16_HANDLER( sdmg2_magic_r )
 
1493
READ16_MEMBER(igs017_state::sdmg2_magic_r)
1371
1494
{
1372
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1373
 
        switch(state->m_igs_magic[0])
 
1495
        switch(m_igs_magic[0])
1374
1496
        {
1375
1497
                case 0x00:
1376
1498
                {
1377
 
                        UINT16 hopper_bit = (state->m_hopper && ((space->machine().primary_screen->frame_number()/10)&1)) ? 0x0000 : 0x0001;
1378
 
                        return input_port_read(space->machine(), "COINS") | hopper_bit;
 
1499
                        UINT16 hopper_bit = (m_hopper && ((machine().primary_screen->frame_number()/10)&1)) ? 0x0000 : 0x0001;
 
1500
                        return ioport("COINS")->read() | hopper_bit;
1379
1501
                }
1380
1502
 
1381
1503
                case 0x02:
1382
1504
                        return sdmg2_keys_r(space, 0);
1383
1505
 
1384
1506
                default:
1385
 
                        logerror("%06x: warning, reading with igs_magic = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0]);
 
1507
                        logerror("%s: warning, reading with igs_magic = %02x\n", machine().describe_context(), m_igs_magic[0]);
1386
1508
                        break;
1387
1509
        }
1388
1510
 
1389
1511
        return 0xffff;
1390
1512
}
1391
1513
 
1392
 
static ADDRESS_MAP_START( sdmg2, AS_PROGRAM, 16 )
 
1514
static ADDRESS_MAP_START( sdmg2, AS_PROGRAM, 16, igs017_state )
1393
1515
        AM_RANGE(0x000000, 0x07ffff) AM_ROM
1394
1516
        AM_RANGE(0x1f0000, 0x1fffff) AM_RAM
1395
 
        AM_RANGE(0x202000, 0x202fff) AM_READWRITE( spriteram_lsb_r, spriteram_lsb_w ) AM_BASE_MEMBER(igs017_state, m_spriteram)
1396
 
        AM_RANGE(0x203000, 0x2037ff) AM_RAM_WRITE( sdmg2_paletteram_w ) AM_BASE_GENERIC( paletteram )
1397
 
        AM_RANGE(0x204020, 0x204027) AM_DEVREAD8( "ppi8255", ppi8255_r, 0x00ff )
1398
 
        AM_RANGE(0x204024, 0x204025) AM_WRITE( video_disable_lsb_w )
1399
 
        AM_RANGE(0x204028, 0x204029) AM_WRITE( irq2_enable_w )
1400
 
        AM_RANGE(0x20402a, 0x20402b) AM_WRITE( irq1_enable_w )
1401
 
        AM_RANGE(0x208000, 0x20bfff) AM_READWRITE( fg_lsb_r, fg_lsb_w ) AM_BASE_MEMBER(igs017_state, m_fg_videoram )
1402
 
        AM_RANGE(0x20c000, 0x20ffff) AM_READWRITE( bg_lsb_r, bg_lsb_w ) AM_BASE_MEMBER(igs017_state, m_bg_videoram )
1403
 
        AM_RANGE(0x210000, 0x210001) AM_DEVREADWRITE8_MODERN("oki", okim6295_device, read, write, 0x00ff )
1404
 
        AM_RANGE(0x300000, 0x300003) AM_WRITE( sdmg2_magic_w )
1405
 
        AM_RANGE(0x300002, 0x300003) AM_READ ( sdmg2_magic_r )
 
1517
        AM_RANGE(0x202000, 0x202fff) AM_READWRITE(spriteram_lsb_r, spriteram_lsb_w ) AM_SHARE("spriteram")
 
1518
        AM_RANGE(0x203000, 0x2037ff) AM_RAM_WRITE(sdmg2_paletteram_w ) AM_SHARE("paletteram")
 
1519
        AM_RANGE(0x204020, 0x204027) AM_DEVREAD8("ppi8255", i8255_device, read, 0x00ff)
 
1520
        AM_RANGE(0x204024, 0x204025) AM_WRITE(video_disable_lsb_w )
 
1521
        AM_RANGE(0x204028, 0x204029) AM_WRITE(irq2_enable_w )
 
1522
        AM_RANGE(0x20402a, 0x20402b) AM_WRITE(irq1_enable_w )
 
1523
        AM_RANGE(0x208000, 0x20bfff) AM_READWRITE(fg_lsb_r, fg_lsb_w ) AM_SHARE("fg_videoram")
 
1524
        AM_RANGE(0x20c000, 0x20ffff) AM_READWRITE(bg_lsb_r, bg_lsb_w ) AM_SHARE("bg_videoram")
 
1525
        AM_RANGE(0x210000, 0x210001) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
 
1526
        AM_RANGE(0x300000, 0x300003) AM_WRITE(sdmg2_magic_w )
 
1527
        AM_RANGE(0x300002, 0x300003) AM_READ(sdmg2_magic_r )
1406
1528
ADDRESS_MAP_END
1407
1529
 
1408
1530
 
1409
1531
// mgdh, mgdha
1410
1532
 
1411
 
static READ8_HANDLER( mgdh_keys_r )
 
1533
 
 
1534
READ8_MEMBER(igs017_state::mgdh_keys_r)
1412
1535
{
1413
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1414
 
        if (~state->m_input_select & 0x04)      return input_port_read(space->machine(), "KEY0");
1415
 
        if (~state->m_input_select & 0x08)      return input_port_read(space->machine(), "KEY1");
1416
 
        if (~state->m_input_select & 0x10)      return input_port_read(space->machine(), "KEY2");
1417
 
        if (~state->m_input_select & 0x20)      return input_port_read(space->machine(), "KEY3");
1418
 
        if (~state->m_input_select & 0x40)      return input_port_read(space->machine(), "KEY4");
1419
 
 
1420
 
        if ((state->m_input_select & 0xfc) == 0xfc)     return input_port_read(space->machine(), "DSW1");
1421
 
 
1422
 
        logerror("%s: warning, reading key with input_select = %02x\n", space->machine().describe_context(), state->m_input_select);
 
1536
        if (~m_input_select & 0x04)     return ioport("KEY0")->read();
 
1537
        if (~m_input_select & 0x08)     return ioport("KEY1")->read();
 
1538
        if (~m_input_select & 0x10)     return ioport("KEY2")->read();
 
1539
        if (~m_input_select & 0x20)     return ioport("KEY3")->read();
 
1540
        if (~m_input_select & 0x40)     return ioport("KEY4")->read();
 
1541
 
 
1542
        if ((m_input_select & 0xfc) == 0xfc)    return ioport("DSW1")->read();
 
1543
 
 
1544
        logerror("%s: warning, reading key with input_select = %02x\n", machine().describe_context(), m_input_select);
1423
1545
        return 0xff;
1424
1546
}
1425
1547
 
1426
 
static WRITE16_HANDLER( mgdha_magic_w )
 
1548
WRITE16_MEMBER(igs017_state::mgdha_magic_w)
1427
1549
{
1428
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1429
 
        COMBINE_DATA(&state->m_igs_magic[offset]);
 
1550
        COMBINE_DATA(&m_igs_magic[offset]);
1430
1551
 
1431
1552
        if (offset == 0)
1432
1553
                return;
1433
1554
 
1434
 
        switch(state->m_igs_magic[0])
 
1555
        switch(m_igs_magic[0])
1435
1556
        {
1436
1557
                case 0x00:
1437
1558
                        if (ACCESSING_BITS_0_7)
1438
1559
                        {
1439
1560
                                //  coin out     data & 0x40
1440
 
                                coin_counter_w(space->machine(), 0, data & 0x80);
 
1561
                                coin_counter_w(machine(), 0, data & 0x80);
1441
1562
                        }
1442
1563
 
1443
1564
                        if ( data & ~0xc0 )
1444
 
                                logerror("%06x: warning, unknown bits written to igs_magic 00 = %02x\n", cpu_get_pc(&space->device()), data);
 
1565
                                logerror("%s: warning, unknown bits written to igs_magic 00 = %02x\n", machine().describe_context(), data);
1445
1566
 
1446
1567
                        break;
1447
1568
 
1448
1569
                case 0x01:
1449
1570
                        if (ACCESSING_BITS_0_7)
1450
1571
                        {
1451
 
                                state->m_input_select = data & 0xff;
1452
 
                                state->m_hopper = data & 0x01;
 
1572
                                m_input_select = data & 0xff;
 
1573
                                m_hopper = data & 0x01;
1453
1574
                        }
1454
1575
 
1455
 
                        if ( state->m_input_select & ~0xfd )
1456
 
                                logerror("%06x: warning, unknown bits written in input_select = %02x\n", cpu_get_pc(&space->device()), state->m_input_select);
 
1576
                        if ( m_input_select & ~0xfd )
 
1577
                                logerror("%s: warning, unknown bits written in input_select = %02x\n", machine().describe_context(), m_input_select);
1457
1578
 
1458
1579
                        break;
1459
1580
 
1461
1582
                        if (ACCESSING_BITS_0_7)
1462
1583
                        {
1463
1584
                                // bit 7?
1464
 
                                okim6295_device *oki = space->machine().device<okim6295_device>("oki");
 
1585
                                okim6295_device *oki = machine().device<okim6295_device>("oki");
1465
1586
                                oki->set_bank_base((data & 0x40) ? 0x40000 : 0);
1466
1587
                        }
1467
1588
                        break;
1478
1599
            04ac10: warning, writing to igs_magic 06 = ff
1479
1600
            04ac20: warning, writing to igs_magic 07 = 3f
1480
1601
*/
1481
 
                        logerror("%06x: warning, writing to igs_magic %02x = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0], data);
 
1602
                        logerror("%s: warning, writing to igs_magic %02x = %02x\n", machine().describe_context(), m_igs_magic[0], data);
1482
1603
        }
1483
1604
}
1484
1605
 
1485
 
static READ16_HANDLER( mgdha_magic_r )
 
1606
READ16_MEMBER(igs017_state::mgdha_magic_r)
1486
1607
{
1487
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1488
 
        switch(state->m_igs_magic[0])
 
1608
        switch(m_igs_magic[0])
1489
1609
        {
1490
1610
                case 0x00:
1491
1611
                        return mgdh_keys_r(space, 0);
1492
1612
 
1493
1613
                case 0x01:
1494
 
                        return input_port_read(space->machine(), "BUTTONS");
 
1614
                        return ioport("BUTTONS")->read();
1495
1615
 
1496
1616
                case 0x02:
1497
 
                        return BITSWAP8(input_port_read(space->machine(), "DSW2"), 0,1,2,3,4,5,6,7);
 
1617
                        return BITSWAP8(ioport("DSW2")->read(), 0,1,2,3,4,5,6,7);
1498
1618
 
1499
1619
                case 0x03:
1500
1620
                {
1501
 
                        UINT16 hopper_bit = (state->m_hopper && ((space->machine().primary_screen->frame_number()/10)&1)) ? 0x0000 : 0x0001;
1502
 
                        return input_port_read(space->machine(), "COINS") | hopper_bit;
 
1621
                        UINT16 hopper_bit = (m_hopper && ((machine().primary_screen->frame_number()/10)&1)) ? 0x0000 : 0x0001;
 
1622
                        return ioport("COINS")->read() | hopper_bit;
1503
1623
                }
1504
1624
 
1505
1625
                default:
1506
 
                        logerror("%06x: warning, reading with igs_magic = %02x\n", cpu_get_pc(&space->device()), state->m_igs_magic[0]);
 
1626
                        logerror("%s: warning, reading with igs_magic = %02x\n", machine().describe_context(), m_igs_magic[0]);
1507
1627
                        break;
1508
1628
        }
1509
1629
 
1510
1630
        return 0xffff;
1511
1631
}
1512
1632
 
1513
 
static ADDRESS_MAP_START( mgdha_map, AS_PROGRAM, 16 )
 
1633
static ADDRESS_MAP_START( mgdha_map, AS_PROGRAM, 16, igs017_state )
1514
1634
        AM_RANGE(0x000000, 0x07ffff) AM_ROM
1515
1635
        AM_RANGE(0x600000, 0x603fff) AM_RAM
1516
 
        AM_RANGE(0x876000, 0x876003) AM_WRITE( mgdha_magic_w )
1517
 
        AM_RANGE(0x876002, 0x876003) AM_READ ( mgdha_magic_r )
1518
 
        AM_RANGE(0xa02000, 0xa02fff) AM_READWRITE( spriteram_lsb_r, spriteram_lsb_w ) AM_BASE_MEMBER(igs017_state, m_spriteram)
1519
 
        AM_RANGE(0xa03000, 0xa037ff) AM_RAM_WRITE( sdmg2_paletteram_w ) AM_BASE_GENERIC( paletteram )
 
1636
        AM_RANGE(0x876000, 0x876003) AM_WRITE(mgdha_magic_w )
 
1637
        AM_RANGE(0x876002, 0x876003) AM_READ(mgdha_magic_r )
 
1638
        AM_RANGE(0xa02000, 0xa02fff) AM_READWRITE(spriteram_lsb_r, spriteram_lsb_w ) AM_SHARE("spriteram")
 
1639
        AM_RANGE(0xa03000, 0xa037ff) AM_RAM_WRITE(sdmg2_paletteram_w ) AM_SHARE("paletteram")
1520
1640
//  AM_RANGE(0xa04014, 0xa04015) // written with FF at boot
1521
 
        AM_RANGE(0xa04020, 0xa04027) AM_DEVREAD8( "ppi8255", ppi8255_r, 0x00ff )
1522
 
        AM_RANGE(0xa04024, 0xa04025) AM_WRITE( video_disable_lsb_w )
1523
 
        AM_RANGE(0xa04028, 0xa04029) AM_WRITE( irq2_enable_w )
1524
 
        AM_RANGE(0xa0402a, 0xa0402b) AM_WRITE( irq1_enable_w )
1525
 
        AM_RANGE(0xa08000, 0xa0bfff) AM_READWRITE( fg_lsb_r, fg_lsb_w ) AM_BASE_MEMBER(igs017_state, m_fg_videoram )
1526
 
        AM_RANGE(0xa0c000, 0xa0ffff) AM_READWRITE( bg_lsb_r, bg_lsb_w ) AM_BASE_MEMBER(igs017_state, m_bg_videoram )
1527
 
        AM_RANGE(0xa10000, 0xa10001) AM_DEVREADWRITE8_MODERN("oki", okim6295_device, read, write, 0x00ff )
 
1641
        AM_RANGE(0xa04020, 0xa04027) AM_DEVREAD8("ppi8255", i8255_device, read, 0x00ff)
 
1642
        AM_RANGE(0xa04024, 0xa04025) AM_WRITE(video_disable_lsb_w )
 
1643
        AM_RANGE(0xa04028, 0xa04029) AM_WRITE(irq2_enable_w )
 
1644
        AM_RANGE(0xa0402a, 0xa0402b) AM_WRITE(irq1_enable_w )
 
1645
        AM_RANGE(0xa08000, 0xa0bfff) AM_READWRITE(fg_lsb_r, fg_lsb_w ) AM_SHARE("fg_videoram")
 
1646
        AM_RANGE(0xa0c000, 0xa0ffff) AM_READWRITE(bg_lsb_r, bg_lsb_w ) AM_SHARE("bg_videoram")
 
1647
        AM_RANGE(0xa10000, 0xa10001) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
1528
1648
ADDRESS_MAP_END
1529
1649
 
1530
1650
 
1531
1651
// tjsb
1532
1652
 
1533
 
static WRITE8_HANDLER( tjsb_paletteram_w )
 
1653
 
 
1654
WRITE8_MEMBER(igs017_state::tjsb_paletteram_w)
1534
1655
{
1535
 
        space->machine().generic.paletteram.u8[offset] = data;
1536
 
        int bgr = (space->machine().generic.paletteram.u8[offset/2*2+1] << 8) | space->machine().generic.paletteram.u8[offset/2*2+0];
 
1656
        m_generic_paletteram_8[offset] = data;
 
1657
        int bgr = (m_generic_paletteram_8[offset/2*2+1] << 8) | m_generic_paletteram_8[offset/2*2+0];
1537
1658
 
1538
1659
        // bitswap
1539
 
        bgr = BITSWAP16(bgr, 15, 12,3,6,10,5, 4,2,9,13,8, 7,11,1,0,14);
 
1660
        bgr = BITSWAP16(bgr, 15,12,3,6,10,5,4,2,9,13,8,7,11,1,0,14);
1540
1661
 
1541
 
        palette_set_color_rgb(space->machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
 
1662
        palette_set_color_rgb(machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
1542
1663
}
1543
1664
 
1544
 
static WRITE8_HANDLER( tjsb_output_w )
 
1665
WRITE8_MEMBER(igs017_state::tjsb_output_w)
1545
1666
{
1546
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1547
 
        switch(state->m_input_select)
 
1667
        switch(m_input_select)
1548
1668
        {
1549
1669
                case 0x00:
1550
 
                        coin_counter_w(space->machine(), 0,     data & 0x80);   // coin in
 
1670
                        coin_counter_w(machine(), 0,    data & 0x80);   // coin in
1551
1671
                        if (!(data & ~0x80))
1552
1672
                                return;
1553
1673
                        break;
1554
1674
 
1555
1675
                case 0x01:
1556
 
                        coin_counter_w(space->machine(), 1,     data & 0x01);   // coin out
 
1676
                        coin_counter_w(machine(), 1,    data & 0x01);   // coin out
1557
1677
                        if (!(data & ~0x01))
1558
1678
                                return;
1559
1679
                        break;
1560
1680
 
1561
1681
                case 0x02:
1562
 
                        space->machine().device<okim6295_device>("oki")->set_bank_base((data & 0x10) ? 0x40000 : 0);    // oki bank (0x20/0x30)
 
1682
                        machine().device<okim6295_device>("oki")->set_bank_base((data & 0x10) ? 0x40000 : 0);   // oki bank (0x20/0x30)
1563
1683
                        if (!(data & ~0x30))
1564
1684
                                return;
1565
1685
                        break;
1566
1686
 
1567
1687
                case 0x03:
1568
 
                        state->m_hopper = data & 0x40;
 
1688
                        m_hopper = data & 0x40;
1569
1689
                        if (!(data & ~0x40))
1570
1690
                                return;
1571
1691
                        break;
1572
1692
        }
1573
 
        logerror("%06x: warning, writing to igs_magic %02x = %02x\n", cpu_get_pc(&space->device()), state->m_input_select, data);
 
1693
        logerror("%s: warning, writing to igs_magic %02x = %02x\n", machine().describe_context(), m_input_select, data);
1574
1694
}
1575
1695
 
1576
 
static READ8_HANDLER( tjsb_input_r )
 
1696
READ8_MEMBER(igs017_state::tjsb_input_r)
1577
1697
{
1578
 
        igs017_state *state = space->machine().driver_data<igs017_state>();
1579
 
        switch (state->m_input_select)
 
1698
        switch (m_input_select)
1580
1699
        {
1581
 
                case 0x00:      return input_port_read(space->machine(), "PLAYER1");
1582
 
                case 0x01:      return input_port_read(space->machine(), "PLAYER2");
1583
 
                case 0x02:      return input_port_read(space->machine(), "COINS");
 
1700
                case 0x00:      return ioport("PLAYER1")->read();
 
1701
                case 0x01:      return ioport("PLAYER2")->read();
 
1702
                case 0x02:      return ioport("COINS")->read();
1584
1703
                case 0x03:
1585
1704
                {
1586
 
                        UINT8 hopper_bit = (state->m_hopper && ((space->machine().primary_screen->frame_number()/10)&1)) ? 0x00 : 0x20;
1587
 
                        return input_port_read(space->machine(), "HOPPER") | hopper_bit;
 
1705
                        UINT8 hopper_bit = (m_hopper && ((machine().primary_screen->frame_number()/10)&1)) ? 0x00 : 0x20;
 
1706
                        return ioport("HOPPER")->read() | hopper_bit;
1588
1707
                }
1589
1708
 
1590
1709
                default:
1591
 
                        logerror("PC %06X: input %02x read\n",cpu_get_pc(&space->device()),state->m_input_select);
 
1710
                        logerror("%s: input %02x read\n", machine().describe_context(), m_input_select);
1592
1711
                        return 0xff;
1593
1712
        }
1594
1713
}
1595
1714
 
1596
 
static ADDRESS_MAP_START( tjsb_map, AS_PROGRAM, 8 )
 
1715
static ADDRESS_MAP_START( tjsb_map, AS_PROGRAM, 8, igs017_state )
1597
1716
        AM_RANGE( 0x00000, 0x0dfff ) AM_ROM
1598
 
        AM_RANGE( 0x0e000, 0x0e000 ) AM_WRITE( input_select_w )
1599
 
        AM_RANGE( 0x0e001, 0x0e001 ) AM_READWRITE( tjsb_input_r, tjsb_output_w )
 
1717
        AM_RANGE( 0x0e000, 0x0e000 ) AM_WRITE(input_select_w )
 
1718
        AM_RANGE( 0x0e001, 0x0e001 ) AM_READWRITE(tjsb_input_r, tjsb_output_w )
1600
1719
        AM_RANGE( 0x0e002, 0x0efff ) AM_RAM
1601
1720
        AM_RANGE( 0x0f000, 0x0ffff ) AM_RAM
1602
1721
        AM_RANGE( 0x10000, 0x3ffff ) AM_ROM
1603
1722
ADDRESS_MAP_END
1604
1723
 
1605
 
static ADDRESS_MAP_START( tjsb_io, AS_IO, 8 )
 
1724
static ADDRESS_MAP_START( tjsb_io, AS_IO, 8, igs017_state )
1606
1725
        AM_RANGE( 0x0000, 0x003f ) AM_RAM // internal regs
1607
1726
 
1608
 
        AM_RANGE( 0x1000, 0x17ff ) AM_RAM AM_BASE_MEMBER(igs017_state, m_spriteram)
1609
 
        AM_RANGE( 0x1800, 0x1bff ) AM_RAM_WRITE( tjsb_paletteram_w ) AM_BASE_GENERIC(paletteram)
 
1727
        AM_RANGE( 0x1000, 0x17ff ) AM_RAM AM_SHARE("spriteram")
 
1728
        AM_RANGE( 0x1800, 0x1bff ) AM_RAM_WRITE(tjsb_paletteram_w ) AM_SHARE("paletteram")
1610
1729
        AM_RANGE( 0x1c00, 0x1fff ) AM_RAM
1611
1730
 
1612
1731
//  AM_RANGE(0x200a, 0x200a) AM_WRITENOP
1613
1732
 
1614
 
        AM_RANGE( 0x2010, 0x2013 ) AM_DEVREAD("ppi8255", ppi8255_r)
1615
 
        AM_RANGE( 0x2012, 0x2012 ) AM_WRITE( video_disable_w )
1616
 
 
1617
 
        AM_RANGE( 0x2014, 0x2014 ) AM_WRITE( nmi_enable_w )
1618
 
        AM_RANGE( 0x2015, 0x2015 ) AM_WRITE( irq_enable_w )
1619
 
 
1620
 
        AM_RANGE( 0x4000, 0x5fff ) AM_RAM_WRITE( fg_w ) AM_BASE_MEMBER(igs017_state, m_fg_videoram )
1621
 
        AM_RANGE( 0x6000, 0x7fff ) AM_RAM_WRITE( bg_w ) AM_BASE_MEMBER(igs017_state, m_bg_videoram )
1622
 
 
1623
 
        AM_RANGE( 0x9000, 0x9000 ) AM_DEVREADWRITE_MODERN("oki", okim6295_device, read, write)
1624
 
 
1625
 
        AM_RANGE( 0xb000, 0xb001 ) AM_DEVWRITE( "ymsnd", ym2413_w )
 
1733
        AM_RANGE( 0x2010, 0x2013 ) AM_DEVREAD("ppi8255", i8255_device, read)
 
1734
        AM_RANGE( 0x2012, 0x2012 ) AM_WRITE(video_disable_w )
 
1735
 
 
1736
        AM_RANGE( 0x2014, 0x2014 ) AM_WRITE(nmi_enable_w )
 
1737
        AM_RANGE( 0x2015, 0x2015 ) AM_WRITE(irq_enable_w )
 
1738
 
 
1739
        AM_RANGE( 0x4000, 0x5fff ) AM_RAM_WRITE(fg_w ) AM_SHARE("fg_videoram")
 
1740
        AM_RANGE( 0x6000, 0x7fff ) AM_RAM_WRITE(bg_w ) AM_SHARE("bg_videoram")
 
1741
 
 
1742
        AM_RANGE( 0x9000, 0x9000 ) AM_DEVREADWRITE("oki", okim6295_device, read, write)
 
1743
 
 
1744
        AM_RANGE( 0xb000, 0xb001 ) AM_DEVWRITE_LEGACY("ymsnd", ym2413_w )
 
1745
ADDRESS_MAP_END
 
1746
 
 
1747
 
 
1748
// lhzb2
 
1749
 
 
1750
 
 
1751
WRITE16_MEMBER(igs017_state::lhzb2_magic_w)
 
1752
{
 
1753
        COMBINE_DATA(&m_igs_magic[offset]);
 
1754
 
 
1755
        if (offset == 0)
 
1756
                return;
 
1757
 
 
1758
        switch(m_igs_magic[0])
 
1759
        {
 
1760
                case 0x00:
 
1761
                        if (ACCESSING_BITS_0_7)
 
1762
                        {
 
1763
                                m_input_select = data & 0xff;
 
1764
                        }
 
1765
 
 
1766
                        if ( m_input_select & ~0x1f )
 
1767
                                logerror("%s: warning, unknown bits written in input_select = %02x\n", machine().describe_context(), m_input_select);
 
1768
                        break;
 
1769
 
 
1770
                case 0x01:
 
1771
                        if (ACCESSING_BITS_0_7)
 
1772
                        {
 
1773
                                okim6295_device *oki = machine().device<okim6295_device>("oki");
 
1774
                                oki->set_bank_base((data & 0x80) ? 0x40000 : 0);
 
1775
 
 
1776
                                if ( data & 0x7f )
 
1777
                                        logerror("%s: warning, unknown bits written in oki bank = %04x\n", machine().describe_context(), data);
 
1778
                        }
 
1779
                        break;
 
1780
 
 
1781
                default:
 
1782
                        logerror("%s: warning, writing to igs_magic %02x = %02x\n", machine().describe_context(), m_igs_magic[0], data);
 
1783
        }
 
1784
}
 
1785
 
 
1786
READ16_MEMBER(igs017_state::lhzb2_magic_r)
 
1787
{
 
1788
        switch(m_igs_magic[0])
 
1789
        {
 
1790
                case 0x01:
 
1791
                {
 
1792
                        if (~m_input_select & 0x01)     return ioport("KEY0")->read();
 
1793
                        if (~m_input_select & 0x02)     return ioport("KEY1")->read();
 
1794
                        if (~m_input_select & 0x04)     return ioport("KEY2")->read();
 
1795
                        if (~m_input_select & 0x08)     return ioport("KEY3")->read();
 
1796
                        if (~m_input_select & 0x10)     return ioport("KEY4")->read();
 
1797
 
 
1798
                        logerror("%s: warning, reading key with input_select = %02x\n", machine().describe_context(), m_input_select);
 
1799
                        return 0xffff;
 
1800
                }
 
1801
 
 
1802
                default:
 
1803
                        logerror("%s: warning, reading with igs_magic = %02x\n", machine().describe_context(), m_igs_magic[0]);
 
1804
                        break;
 
1805
        }
 
1806
 
 
1807
        return 0xffff;
 
1808
}
 
1809
 
 
1810
static ADDRESS_MAP_START( lhzb2, AS_PROGRAM, 16, igs017_state )
 
1811
        AM_RANGE(0x000000, 0x07ffff) AM_ROM
 
1812
        AM_RANGE(0x500000, 0x503fff) AM_RAM
 
1813
        AM_RANGE(0x910000, 0x910003) AM_WRITE( lhzb2_magic_w )
 
1814
        AM_RANGE(0x910002, 0x910003) AM_READ( lhzb2_magic_r )
 
1815
        AM_RANGE(0xb02000, 0xb02fff) AM_READWRITE( spriteram_lsb_r, spriteram_lsb_w ) AM_SHARE("spriteram")
 
1816
        AM_RANGE(0xb03000, 0xb037ff) AM_RAM_WRITE( lhzb2a_paletteram_w ) AM_SHARE("paletteram")
 
1817
        AM_RANGE(0xb04020, 0xb04027) AM_DEVREAD8("ppi8255", i8255_device, read, 0x00ff)
 
1818
        AM_RANGE(0xb04024, 0xb04025) AM_WRITE( video_disable_lsb_w )
 
1819
        AM_RANGE(0xb04028, 0xb04029) AM_WRITE( irq2_enable_w )
 
1820
        AM_RANGE(0xb0402a, 0xb0402b) AM_WRITE( irq1_enable_w )
 
1821
        AM_RANGE(0xb08000, 0xb0bfff) AM_READWRITE( fg_lsb_r, fg_lsb_w ) AM_SHARE("fg_videoram")
 
1822
        AM_RANGE(0xb0c000, 0xb0ffff) AM_READWRITE( bg_lsb_r, bg_lsb_w ) AM_SHARE("bg_videoram")
 
1823
        AM_RANGE(0xb10000, 0xb10001) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
 
1824
ADDRESS_MAP_END
 
1825
 
 
1826
 
 
1827
// lhzb2a
 
1828
// To do: what devices are on this PCB?
 
1829
 
 
1830
/***************************************************************************
 
1831
 
 
1832
    LHZB2A Protection (similar to that found in igs011.c)
 
1833
 
 
1834
    ---- Protection 1 (parametric bitswaps) ----
 
1835
 
 
1836
    An address base register (xx = F0 at reset) determines where this protection device,
 
1837
    as well as game inputs and the address base register itself are mapped in memory:
 
1838
    inputs are mapped at xx8000, protection at xx4000 and base register at xxc000.
 
1839
 
 
1840
    The protection involves an internal 16-bit value (val), two mode registers
 
1841
    (mode_f = 0..f, mode_3 = 0..3) and 8 x 16-bit registers (word).
 
1842
 
 
1843
    The two modes affect the bitswap, and are set by loading the (same) mode-specific value
 
1844
    to all the word registers, and then writing to the mode_f or mode_3 trigger register.
 
1845
 
 
1846
    The bitswap of the internal value is then performed writing to one of 8 trigger registers,
 
1847
    according to the modes, trigger register and value written.
 
1848
 
 
1849
    The result is read through a fixed bitswap of the internal value.
 
1850
 
 
1851
    ---- Protection 2 (simple inc,dec + bitswapped read) ----
 
1852
 
 
1853
    The chip holds an internal 8-bit value. It is manipulated by issuing commands,
 
1854
    where each command is assigned a specific address range, and is triggered
 
1855
    by writing FF to that range. Possible commands:
 
1856
 
 
1857
    - INC:   increment value
 
1858
    - DEC:   decrement value
 
1859
    - RESET: value = 0
 
1860
 
 
1861
    The protection value is read from an additional address range:
 
1862
 
 
1863
    - READ:  read bitswap(value). Only 4 bits are checked.
 
1864
 
 
1865
***************************************************************************/
 
1866
 
 
1867
// Bitswap protection
 
1868
 
 
1869
WRITE16_MEMBER(igs017_state::lhzb2a_prot_w)
 
1870
{
 
1871
        COMBINE_DATA(&m_prot_regs[offset]);
 
1872
 
 
1873
        if (offset == 0)
 
1874
                return;
 
1875
 
 
1876
        switch(m_prot_regs[0])
 
1877
        {
 
1878
                case 0x40:      // prot_word
 
1879
                {
 
1880
                        m_prot_word = (m_prot_word << 8) | (m_prot_regs[1] & 0xff);
 
1881
                        break;
 
1882
                }
 
1883
                case 0x41:
 
1884
                case 0x42:
 
1885
                case 0x43:
 
1886
                case 0x44:
 
1887
                case 0x45:
 
1888
                case 0x46:
 
1889
                case 0x47:
 
1890
                        // same value as reg 0x40
 
1891
                        break;
 
1892
 
 
1893
                case 0x48:      // mode_f
 
1894
                {
 
1895
                        switch (m_prot_word)
 
1896
                        {
 
1897
                                case 0x9a96:    m_prot_mf = 0x0;        break;
 
1898
                                case 0x9a06:    m_prot_mf = 0x1;        break;
 
1899
                                case 0x9a90:    m_prot_mf = 0x2;        break;
 
1900
                                case 0x9a00:    m_prot_mf = 0x3;        break;
 
1901
                                case 0x0a96:    m_prot_mf = 0x4;        break;
 
1902
                                case 0x0a06:    m_prot_mf = 0x5;        break;
 
1903
                                case 0x0a90:    m_prot_mf = 0x6;        break;
 
1904
                                case 0x0a00:    m_prot_mf = 0x7;        break;
 
1905
                                case 0x9096:    m_prot_mf = 0x8;        break;
 
1906
                                case 0x9006:    m_prot_mf = 0x9;        break;
 
1907
                                case 0x9090:    m_prot_mf = 0xa;        break;
 
1908
                                case 0x9000:    m_prot_mf = 0xb;        break;
 
1909
                                case 0x0096:    m_prot_mf = 0xc;        break;
 
1910
                                case 0x0006:    m_prot_mf = 0xd;        break;
 
1911
                                case 0x0090:    m_prot_mf = 0xe;        break;
 
1912
                                case 0x0000:    m_prot_mf = 0xf;        break;
 
1913
                                default:
 
1914
                                        m_prot_mf = 0;
 
1915
                                        logerror("%s: warning, setting mode_f with unknown prot_word = %02x\n", machine().describe_context(), m_prot_word);
 
1916
                                        return;
 
1917
                        }
 
1918
 
 
1919
                        logerror("%s: mode_f = %02x\n", machine().describe_context(), m_prot_mf);
 
1920
                        break;
 
1921
                }
 
1922
 
 
1923
                case 0x50:      // mode_3
 
1924
                {
 
1925
                        switch (m_prot_word & 0xff)
 
1926
                        {
 
1927
                                case 0x53:      m_prot_m3 = 0x0;        break;
 
1928
                                case 0x03:      m_prot_m3 = 0x1;        break;
 
1929
                                case 0x50:      m_prot_m3 = 0x2;        break;
 
1930
                                case 0x00:      m_prot_m3 = 0x3;        break;
 
1931
                                default:
 
1932
                                        m_prot_m3 = 0;
 
1933
                                        logerror("%s: warning, setting mode_3 with unknown prot_word = %02x\n", machine().describe_context(), m_prot_word);
 
1934
                                        return;
 
1935
                        }
 
1936
 
 
1937
                        logerror("%s: mode_3 = %02x\n", machine().describe_context(), m_prot_m3);
 
1938
                        break;
 
1939
                }
 
1940
 
 
1941
                case 0x80:      // do bitswap
 
1942
                case 0x81:
 
1943
                case 0x82:
 
1944
                case 0x83:
 
1945
                case 0x84:
 
1946
                case 0x85:
 
1947
                case 0x86:
 
1948
                case 0x87:
 
1949
                {
 
1950
                        UINT16 x  = m_prot_val;
 
1951
                        UINT16 mf = m_prot_mf;
 
1952
 
 
1953
                        UINT16 bit0 = 0;
 
1954
                        switch (m_prot_m3)
 
1955
                        {
 
1956
                                case 0: bit0 = BIT(~x,12) ^ BIT(~x,15) ^ BIT( x, 8) ^ BIT(~x, 3);       break;
 
1957
                                case 1: bit0 = BIT(~x, 6) ^ BIT(~x,15) ^ BIT(~x, 3) ^ BIT(~x, 9);       break;
 
1958
                                case 2: bit0 = BIT(~x, 3) ^ BIT(~x,15) ^ BIT(~x, 5) ^ BIT( x, 4);       break;
 
1959
                                case 3: bit0 = BIT(~x,15) ^ BIT(~x, 9) ^ BIT( x,12) ^ BIT(~x,11);       break;
 
1960
                        }
 
1961
 
 
1962
                        UINT16 xor0 = BIT(m_prot_regs[1], m_prot_regs[0] - 0x80);
 
1963
                        bit0 ^= xor0;
 
1964
 
 
1965
                        m_prot_val      =       (        BIT( x,14)                                     << 15   ) |
 
1966
                                                        (       (BIT(~x,13) ^ BIT(mf,3))        << 14   ) |
 
1967
                                                        (        BIT( x,12)                                     << 13   ) |
 
1968
                                                        (        BIT(~x,11)                                     << 12   ) |
 
1969
                                                        (       (BIT( x,10) ^ BIT(mf,2))        << 11   ) |
 
1970
                                                        (        BIT( x, 9)                                     << 10   ) |
 
1971
                                                        (        BIT( x, 8)                                     <<  9   ) |
 
1972
                                                        (       (BIT(~x, 7) ^ BIT(mf,1))        <<  8   ) |
 
1973
                                                        (        BIT( x, 6)                                     <<  7   ) |
 
1974
                                                        (        BIT( x, 5)                                     <<  6   ) |
 
1975
                                                        (       (BIT(~x, 4) ^ BIT(mf,0))        <<  5   ) |
 
1976
                                                        (        BIT(~x, 3)                                     <<  4   ) |
 
1977
                                                        (        BIT( x, 2)                                     <<  3   ) |
 
1978
                                                        (        BIT(~x, 1)                                     <<  2   ) |
 
1979
                                                        (        BIT( x, 0)                                     <<  1   ) |
 
1980
                                                        (        bit0                                           <<  0   ) ;
 
1981
 
 
1982
                        logerror("%s: exec bitswap - mode_3 %02x, mode_f %02x, xor0 %x, val %04x -> %04x\n", machine().describe_context(), m_prot_m3, m_prot_mf, xor0, x, m_prot_val);
 
1983
 
 
1984
                        break;
 
1985
                }
 
1986
 
 
1987
                case 0xa0:      // reset
 
1988
                {
 
1989
                        m_prot_val = 0;
 
1990
                        break;
 
1991
                }
 
1992
 
 
1993
                default:
 
1994
                        logerror("%s: warning, writing to prot_reg %02x = %02x\n", machine().describe_context(), m_prot_regs[0], m_prot_regs[1]);
 
1995
        }
 
1996
}
 
1997
 
 
1998
READ16_MEMBER(igs017_state::lhzb2a_prot_r)
 
1999
{
 
2000
        switch(m_prot_regs[0])
 
2001
        {
 
2002
                case 0x03:      // result
 
2003
                {
 
2004
                        UINT16 x = m_prot_val;
 
2005
                        UINT16 res      =       (BIT(x, 5) << 7) |
 
2006
                                                        (BIT(x, 2) << 6) |
 
2007
                                                        (BIT(x, 9) << 5) |
 
2008
                                                        (BIT(x, 7) << 4) |
 
2009
                                                        (BIT(x,10) << 3) |
 
2010
                                                        (BIT(x,13) << 2) |
 
2011
                                                        (BIT(x,12) << 1) |
 
2012
                                                        (BIT(x,15) << 0) ;
 
2013
 
 
2014
                        logerror("%s: read bitswap - val %04x -> %02x\n", machine().describe_context(), m_prot_val, res);
 
2015
                        return res;
 
2016
 
 
2017
                        break;
 
2018
                }
 
2019
 
 
2020
                default:
 
2021
                        logerror("%s: warning, reading with prot_reg = %02x\n", machine().describe_context(), m_prot_regs[0]);
 
2022
                        break;
 
2023
        }
 
2024
 
 
2025
        return 0xffff;
 
2026
}
 
2027
 
 
2028
// Protection 2
 
2029
 
 
2030
WRITE16_MEMBER(igs017_state::lhzb2a_prot2_reset_w)
 
2031
{
 
2032
        m_prot2 = 0x00;
 
2033
        logerror("%s: prot2 reset -> %02x\n", machine().describe_context(), m_prot2);
 
2034
}
 
2035
 
 
2036
WRITE16_MEMBER(igs017_state::lhzb2a_prot2_inc_w)
 
2037
{
 
2038
        m_prot2++;
 
2039
        logerror("%s: prot2 inc -> %02x\n", machine().describe_context(), m_prot2);
 
2040
}
 
2041
 
 
2042
WRITE16_MEMBER(igs017_state::lhzb2a_prot2_dec_w)
 
2043
{
 
2044
        m_prot2--;
 
2045
        logerror("%s: prot2 dec -> %02x\n", machine().describe_context(), m_prot2);
 
2046
}
 
2047
 
 
2048
READ16_MEMBER(igs017_state::lhzb2a_prot2_r)
 
2049
{
 
2050
        UINT8 x         =       m_prot2;
 
2051
        UINT8 res       =       (BIT(x, 0) << 7) |
 
2052
                                        (BIT(x, 3) << 5) |
 
2053
                                        (BIT(x, 2) << 4) |
 
2054
                                        (BIT(x, 1) << 2) ;
 
2055
 
 
2056
        logerror("%s: prot2 read, %02x -> %02x\n", machine().describe_context(), m_prot2, res);
 
2057
        return res;
 
2058
}
 
2059
 
 
2060
 
 
2061
 
 
2062
WRITE16_MEMBER(igs017_state::lhzb2a_paletteram_w)
 
2063
{
 
2064
        COMBINE_DATA(&m_generic_paletteram_16[offset]);
 
2065
 
 
2066
        int bgr = ((m_generic_paletteram_16[offset/2*2+1] & 0xff) << 8) | (m_generic_paletteram_16[offset/2*2+0] & 0xff);
 
2067
 
 
2068
        // bitswap
 
2069
        bgr = BITSWAP16(bgr, 15,9,13,12,11,5,4,8,7,6,0,14,3,2,1,10);
 
2070
 
 
2071
        palette_set_color_rgb(machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
 
2072
}
 
2073
 
 
2074
READ16_MEMBER(igs017_state::lhzb2a_input_r)
 
2075
{
 
2076
        switch (offset*2)
 
2077
        {
 
2078
                case 0x00:      // Keys
 
2079
                {
 
2080
                        if (~m_input_select & 0x01)     return ioport("KEY0")->read() << 8;
 
2081
                        if (~m_input_select & 0x02)     return ioport("KEY1")->read() << 8;
 
2082
                        if (~m_input_select & 0x04)     return ioport("KEY2")->read() << 8;
 
2083
                        if (~m_input_select & 0x08)     return ioport("KEY3")->read() << 8;
 
2084
                        if (~m_input_select & 0x10)     return ioport("KEY4")->read() << 8;
 
2085
 
 
2086
                        logerror("%s: warning, reading key with input_select = %02x\n", machine().describe_context(), m_input_select);
 
2087
                        return 0xffff;
 
2088
                }
 
2089
 
 
2090
                case 0x02:
 
2091
                {
 
2092
                        UINT16 hopper_bit = (m_hopper && ((machine().primary_screen->frame_number()/10)&1)) ? 0x0000 : 0x0002;
 
2093
                        return (ioport("DSW1")->read() << 8) | ioport("COINS")->read() | hopper_bit;
 
2094
                }
 
2095
 
 
2096
                case 0x04:
 
2097
                        return ioport("DSW2")->read();
 
2098
        }
 
2099
 
 
2100
        return 0xffff;
 
2101
}
 
2102
 
 
2103
WRITE16_MEMBER(igs017_state::lhzb2a_input_addr_w)
 
2104
{
 
2105
        // Unmap previous address ranges
 
2106
        if (m_input_addr != -1)
 
2107
        {
 
2108
                space.unmap_readwrite(m_input_addr * 0x10000 + 0x4000, m_input_addr * 0x10000 + 0x4003);
 
2109
                space.unmap_read     (m_input_addr * 0x10000 + 0x8000, m_input_addr * 0x10000 + 0x8005);
 
2110
                space.unmap_write    (m_input_addr * 0x10000 + 0xc000, m_input_addr * 0x10000 + 0xc001);
 
2111
        }
 
2112
 
 
2113
        m_input_addr = data & 0xff;
 
2114
 
 
2115
        // Add new memory ranges
 
2116
        space.install_readwrite_handler (m_input_addr * 0x10000 + 0x4000, m_input_addr * 0x10000 + 0x4003, read16_delegate (FUNC(igs017_state::lhzb2a_prot_r),      this), write16_delegate (FUNC(igs017_state::lhzb2a_prot_w),      this));
 
2117
        space.install_read_handler      (m_input_addr * 0x10000 + 0x8000, m_input_addr * 0x10000 + 0x8005, read16_delegate (FUNC(igs017_state::lhzb2a_input_r),      this));
 
2118
        space.install_write_handler     (m_input_addr * 0x10000 + 0xc000, m_input_addr * 0x10000 + 0xc001, write16_delegate(FUNC(igs017_state::lhzb2a_input_addr_w), this));
 
2119
 
 
2120
        logerror("%s: inputs and protection remapped at %02xxxxx\n", machine().describe_context(), m_input_addr);
 
2121
}
 
2122
 
 
2123
WRITE16_MEMBER(igs017_state::lhzb2a_input_select_w)
 
2124
{
 
2125
        if (ACCESSING_BITS_0_7)
 
2126
        {
 
2127
                m_input_select          =                       data & 0x1f;    // keys
 
2128
                m_hopper                        =                       data & 0x20;    // hopper motor
 
2129
                coin_counter_w(machine(), 1,    data & 0x40);   // coin out counter
 
2130
                coin_counter_w(machine(), 0,    data & 0x80);   // coin in  counter
 
2131
        }
 
2132
        if (ACCESSING_BITS_8_15)
 
2133
        {
 
2134
                okim6295_device *oki = machine().device<okim6295_device>("oki");
 
2135
                oki->set_bank_base((data & 0x0100) ? 0x40000 : 0);
 
2136
 
 
2137
                if ( data & 0x0fe00 )
 
2138
                        logerror("%s: warning, unknown bits written in input_select = %04x\n", machine().describe_context(), data);
 
2139
        }
 
2140
}
 
2141
 
 
2142
static ADDRESS_MAP_START( lhzb2a, AS_PROGRAM, 16, igs017_state )
 
2143
        // prot2
 
2144
        AM_RANGE(0x003200, 0x003201) AM_WRITE( lhzb2a_prot2_reset_w )
 
2145
        AM_RANGE(0x003202, 0x003203) AM_WRITE( lhzb2a_prot2_dec_w )
 
2146
        AM_RANGE(0x003206, 0x003207) AM_WRITE( lhzb2a_prot2_inc_w )
 
2147
        AM_RANGE(0x00320a, 0x00320b) AM_READ( lhzb2a_prot2_r )
 
2148
 
 
2149
        AM_RANGE(0x000000, 0x07ffff) AM_ROM
 
2150
        AM_RANGE(0x500000, 0x503fff) AM_RAM
 
2151
//  AM_RANGE(0x910000, 0x910003) accesses appear to be from leftover code where the final checks were disabled
 
2152
        AM_RANGE(0xb02000, 0xb02fff) AM_READWRITE( spriteram_lsb_r, spriteram_lsb_w ) AM_SHARE("spriteram")
 
2153
        AM_RANGE(0xb03000, 0xb037ff) AM_RAM_WRITE( lhzb2a_paletteram_w ) AM_SHARE("paletteram")
 
2154
        AM_RANGE(0xb04024, 0xb04025) AM_WRITE( video_disable_lsb_w )
 
2155
        AM_RANGE(0xb04028, 0xb04029) AM_WRITE( irq2_enable_w )
 
2156
        AM_RANGE(0xb0402a, 0xb0402b) AM_WRITE( irq1_enable_w )
 
2157
        AM_RANGE(0xb08000, 0xb0bfff) AM_READWRITE( fg_lsb_r, fg_lsb_w ) AM_SHARE("fg_videoram")
 
2158
        AM_RANGE(0xb0c000, 0xb0ffff) AM_READWRITE( bg_lsb_r, bg_lsb_w ) AM_SHARE("bg_videoram")
 
2159
        AM_RANGE(0xb10000, 0xb10001) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
 
2160
        AM_RANGE(0xb12000, 0xb12001) AM_WRITE( lhzb2a_input_select_w )
 
2161
//  Inputs dynamically mapped at xx8000, protection at xx4000 (xx = f0 initially). xx written to xxc000
 
2162
ADDRESS_MAP_END
 
2163
 
 
2164
 
 
2165
// slqz2
 
2166
 
 
2167
 
 
2168
WRITE16_MEMBER(igs017_state::slqz2_paletteram_w)
 
2169
{
 
2170
        COMBINE_DATA(&m_generic_paletteram_16[offset]);
 
2171
 
 
2172
        int bgr = ((m_generic_paletteram_16[offset/2*2+1] & 0xff) << 8) | (m_generic_paletteram_16[offset/2*2+0] & 0xff);
 
2173
 
 
2174
        // bitswap
 
2175
        bgr = BITSWAP16(bgr, 15,14,9,4,11,10,12,3,7,6,5,8,13,2,1,0);
 
2176
 
 
2177
        palette_set_color_rgb(machine(), offset/2, pal5bit(bgr >> 0), pal5bit(bgr >> 5), pal5bit(bgr >> 10));
 
2178
}
 
2179
 
 
2180
WRITE16_MEMBER(igs017_state::slqz2_magic_w)
 
2181
{
 
2182
        COMBINE_DATA(&m_igs_magic[offset]);
 
2183
 
 
2184
        if (offset == 0)
 
2185
                return;
 
2186
 
 
2187
        switch(m_igs_magic[0])
 
2188
        {
 
2189
                case 0x00:
 
2190
                        if (ACCESSING_BITS_0_7)
 
2191
                        {
 
2192
                                okim6295_device *oki = machine().device<okim6295_device>("oki");
 
2193
                                oki->set_bank_base((data & 0x01) ? 0x40000 : 0);
 
2194
 
 
2195
//              m_hopper            =           data & 0x20;    // hopper motor
 
2196
//              coin_counter_w(machine(), 1,    data & 0x40);   // coin out counter
 
2197
                                coin_counter_w(machine(), 0,    data & 0x80);   // coin in  counter
 
2198
 
 
2199
                                if ( data & 0x7e )
 
2200
                                        logerror("%s: warning, unknown bits written in oki bank = %04x\n", machine().describe_context(), data);
 
2201
                        }
 
2202
                        break;
 
2203
 
 
2204
                default:
 
2205
                        logerror("%s: warning, writing to igs_magic %02x = %02x\n", machine().describe_context(), m_igs_magic[0], data);
 
2206
        }
 
2207
}
 
2208
 
 
2209
READ16_MEMBER(igs017_state::slqz2_magic_r)
 
2210
{
 
2211
        switch(m_igs_magic[0])
 
2212
        {
 
2213
                case 0x00:
 
2214
                        return ioport("PLAYER2")->read();
 
2215
                case 0x01:
 
2216
                        return ioport("PLAYER1")->read();
 
2217
                case 0x02:
 
2218
                        return ioport("BUTTONS")->read();
 
2219
 
 
2220
                default:
 
2221
                        logerror("%s: warning, reading with igs_magic = %02x\n", machine().describe_context(), m_igs_magic[0]);
 
2222
                        break;
 
2223
        }
 
2224
 
 
2225
        return 0xffff;
 
2226
}
 
2227
 
 
2228
static ADDRESS_MAP_START( slqz2, AS_PROGRAM, 16, igs017_state )
 
2229
        AM_RANGE(0x000000, 0x07ffff) AM_ROM
 
2230
        AM_RANGE(0x100000, 0x103fff) AM_RAM
 
2231
        AM_RANGE(0x602000, 0x602003) AM_WRITE( slqz2_magic_w )
 
2232
        AM_RANGE(0x602002, 0x602003) AM_READ( slqz2_magic_r )
 
2233
        AM_RANGE(0x902000, 0x902fff) AM_READWRITE( spriteram_lsb_r, spriteram_lsb_w ) AM_SHARE("spriteram")
 
2234
        AM_RANGE(0x903000, 0x9037ff) AM_RAM_WRITE( slqz2_paletteram_w ) AM_SHARE("paletteram")
 
2235
        AM_RANGE(0x904020, 0x904027) AM_DEVREAD8("ppi8255", i8255_device, read, 0x00ff)
 
2236
        AM_RANGE(0x904024, 0x904025) AM_WRITE( video_disable_lsb_w )
 
2237
        AM_RANGE(0x904028, 0x904029) AM_WRITE( irq2_enable_w )
 
2238
        AM_RANGE(0x90402a, 0x90402b) AM_WRITE( irq1_enable_w )
 
2239
        AM_RANGE(0x908000, 0x90bfff) AM_READWRITE( fg_lsb_r, fg_lsb_w ) AM_SHARE("fg_videoram")
 
2240
        AM_RANGE(0x90c000, 0x90ffff) AM_READWRITE( bg_lsb_r, bg_lsb_w ) AM_SHARE("bg_videoram")
 
2241
        AM_RANGE(0x910000, 0x910001) AM_DEVREADWRITE8("oki", okim6295_device, read, write, 0x00ff )
1626
2242
ADDRESS_MAP_END
1627
2243
 
1628
2244
 
1748
2364
 
1749
2365
INPUT_PORTS_END
1750
2366
 
 
2367
static INPUT_PORTS_START( lhzb2 )
 
2368
 
 
2369
        PORT_START("DSW1")
 
2370
        PORT_DIPNAME( 0x03, 0x03, DEF_STR( Coinage ) )
 
2371
        PORT_DIPSETTING(    0x03, DEF_STR( 1C_1C ) )
 
2372
        PORT_DIPSETTING(    0x02, DEF_STR( 1C_2C ) )
 
2373
        PORT_DIPSETTING(    0x01, DEF_STR( 1C_3C ) )
 
2374
        PORT_DIPSETTING(    0x00, DEF_STR( 1C_5C ) )
 
2375
        PORT_DIPNAME( 0x0c, 0x0c, "Credits Per Note" )
 
2376
        PORT_DIPSETTING(    0x0c, "10" )
 
2377
        PORT_DIPSETTING(    0x08, "20" )
 
2378
        PORT_DIPSETTING(    0x04, "50" )
 
2379
        PORT_DIPSETTING(    0x00, "100" )
 
2380
        PORT_DIPNAME( 0x10, 0x10, "Max Note Credits" )
 
2381
        PORT_DIPSETTING(    0x10, "1000" )
 
2382
        PORT_DIPSETTING(    0x00, "2000" )
 
2383
        PORT_DIPNAME( 0x20, 0x20, "Money Type" )
 
2384
        PORT_DIPSETTING(    0x20, "Coins" )
 
2385
        PORT_DIPSETTING(    0x00, "Notes" )
 
2386
        PORT_DIPNAME( 0x40, 0x40, "Pay Out Type" )
 
2387
        PORT_DIPSETTING(    0x40, "Coins" )
 
2388
        PORT_DIPSETTING(    0x00, "Notes" )
 
2389
        PORT_DIPNAME( 0x80, 0x80, DEF_STR( Demo_Sounds ) )
 
2390
        PORT_DIPSETTING(    0x00, DEF_STR( Off ) )
 
2391
        PORT_DIPSETTING(    0x80, DEF_STR( On ) )
 
2392
 
 
2393
        PORT_START("DSW2")
 
2394
        PORT_DIPNAME( 0x03, 0x03, "Min Bet" )
 
2395
        PORT_DIPSETTING(    0x03, "500" )
 
2396
        PORT_DIPSETTING(    0x02, "1000" )
 
2397
        PORT_DIPSETTING(    0x01, "1500" )
 
2398
        PORT_DIPSETTING(    0x00, "2000" )
 
2399
        PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Unknown ) )
 
2400
        PORT_DIPSETTING(    0x0c, "1" )
 
2401
        PORT_DIPSETTING(    0x08, "2" )
 
2402
        PORT_DIPSETTING(    0x04, "3" )
 
2403
        PORT_DIPSETTING(    0x00, "5" )
 
2404
        PORT_DIPNAME( 0x10, 0x10, "Bonus Round" )
 
2405
        PORT_DIPSETTING(    0x00, DEF_STR( No ) )
 
2406
        PORT_DIPSETTING(    0x10, DEF_STR( Yes ) )
 
2407
        PORT_DIPNAME( 0x20, 0x20, "Number Type" )
 
2408
        PORT_DIPSETTING(    0x20, "Number" )
 
2409
        PORT_DIPSETTING(    0x00, "Dice" )
 
2410
        PORT_DIPNAME( 0x40, 0x40, "Symbols" )
 
2411
        PORT_DIPSETTING(    0x40, DEF_STR( Off ) )
 
2412
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )       // pigs, apples
 
2413
        PORT_DIPNAME( 0x80, 0x80, DEF_STR( Unknown ) )
 
2414
        PORT_DIPSETTING(    0x80, DEF_STR( Off ) )
 
2415
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )
 
2416
 
 
2417
        PORT_START("COINS")
 
2418
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SPECIAL   )  // hopper switch (unimplemented)
 
2419
        PORT_SERVICE_NO_TOGGLE( 0x02,   IP_ACTIVE_LOW ) // service mode (keep pressed during boot too)
 
2420
        PORT_BIT( 0x04, IP_ACTIVE_LOW,  IPT_SERVICE1  ) PORT_NAME("Statistics") // press with the above for sound test
 
2421
        PORT_BIT( 0x08, IP_ACTIVE_LOW,  IPT_COIN1     ) PORT_IMPULSE(5) // coin error otherwise
 
2422
        PORT_BIT( 0x10, IP_ACTIVE_LOW,  IPT_OTHER     ) PORT_NAME("Pay Out") PORT_CODE(KEYCODE_O)
 
2423
        PORT_BIT( 0x20, IP_ACTIVE_LOW,  IPT_SERVICE3  ) // ? (shown in service mode)
 
2424
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_UNKNOWN   )
 
2425
        PORT_BIT( 0x80, IP_ACTIVE_LOW,  IPT_UNKNOWN   )
 
2426
 
 
2427
        PORT_START("KEY0")
 
2428
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A )
 
2429
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E )
 
2430
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I )
 
2431
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M )
 
2432
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN )
 
2433
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1 )
 
2434
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2435
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2436
 
 
2437
        PORT_START("KEY1")
 
2438
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B )
 
2439
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F )
 
2440
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J )
 
2441
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N )
 
2442
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH )
 
2443
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_BET )
 
2444
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2445
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2446
 
 
2447
        PORT_START("KEY2")
 
2448
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C )
 
2449
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G )
 
2450
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K )
 
2451
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI )
 
2452
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON )
 
2453
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2454
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2455
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2456
 
 
2457
        PORT_START("KEY3")
 
2458
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D )
 
2459
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H )
 
2460
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L )
 
2461
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON )
 
2462
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2463
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2464
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2465
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2466
 
 
2467
        PORT_START("KEY4")
 
2468
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE )
 
2469
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_SCORE )
 
2470
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_DOUBLE_UP )
 
2471
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2472
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG )
 
2473
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL )
 
2474
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2475
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2476
 
 
2477
INPUT_PORTS_END
 
2478
 
 
2479
static INPUT_PORTS_START( lhzb2a )
 
2480
 
 
2481
        PORT_START("DSW1")
 
2482
        PORT_DIPNAME( 0x03, 0x03, DEF_STR( Coinage ) )
 
2483
        PORT_DIPSETTING(    0x03, DEF_STR( 1C_1C ) )
 
2484
        PORT_DIPSETTING(    0x02, DEF_STR( 1C_2C ) )
 
2485
        PORT_DIPSETTING(    0x01, DEF_STR( 1C_3C ) )
 
2486
        PORT_DIPSETTING(    0x00, DEF_STR( 1C_5C ) )
 
2487
        PORT_DIPNAME( 0x0c, 0x0c, "Credits Per Note" )
 
2488
        PORT_DIPSETTING(    0x0c, "10" )
 
2489
        PORT_DIPSETTING(    0x08, "20" )
 
2490
        PORT_DIPSETTING(    0x04, "50" )
 
2491
        PORT_DIPSETTING(    0x00, "100" )
 
2492
        PORT_DIPNAME( 0x10, 0x10, "Max Note Credits" )
 
2493
        PORT_DIPSETTING(    0x10, "1000" )
 
2494
        PORT_DIPSETTING(    0x00, "2000" )
 
2495
        PORT_DIPNAME( 0x20, 0x20, "Money Type" )
 
2496
        PORT_DIPSETTING(    0x20, "Coins" )
 
2497
        PORT_DIPSETTING(    0x00, "Notes" )
 
2498
        PORT_DIPNAME( 0x40, 0x40, "Pay Out Type" )
 
2499
        PORT_DIPSETTING(    0x40, "Coins" )
 
2500
        PORT_DIPSETTING(    0x00, "Notes" )
 
2501
        PORT_DIPNAME( 0x80, 0x80, DEF_STR( Demo_Sounds ) )
 
2502
        PORT_DIPSETTING(    0x00, DEF_STR( Off ) )
 
2503
        PORT_DIPSETTING(    0x80, DEF_STR( On ) )
 
2504
 
 
2505
        PORT_START("DSW2")
 
2506
        PORT_DIPNAME( 0x03, 0x03, "Min Bet" )
 
2507
        PORT_DIPSETTING(    0x03, "500" )
 
2508
        PORT_DIPSETTING(    0x02, "1000" )
 
2509
        PORT_DIPSETTING(    0x01, "1500" )
 
2510
        PORT_DIPSETTING(    0x00, "2000" )
 
2511
        PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Unknown ) )
 
2512
        PORT_DIPSETTING(    0x0c, "1" )
 
2513
        PORT_DIPSETTING(    0x08, "2" )
 
2514
        PORT_DIPSETTING(    0x04, "3" )
 
2515
        PORT_DIPSETTING(    0x00, "5" )
 
2516
        PORT_DIPNAME( 0x10, 0x10, "Bonus Round" )
 
2517
        PORT_DIPSETTING(    0x00, DEF_STR( No ) )
 
2518
        PORT_DIPSETTING(    0x10, DEF_STR( Yes ) )
 
2519
        PORT_DIPNAME( 0x20, 0x20, "Number Type" )
 
2520
        PORT_DIPSETTING(    0x20, "Number" )
 
2521
        PORT_DIPSETTING(    0x00, "Dice" )
 
2522
        PORT_DIPNAME( 0x40, 0x40, "Symbols" )
 
2523
        PORT_DIPSETTING(    0x40, DEF_STR( Off ) )
 
2524
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )       // pigs, apples
 
2525
        PORT_DIPNAME( 0x80, 0x80, DEF_STR( Unknown ) )
 
2526
        PORT_DIPSETTING(    0x80, DEF_STR( Off ) )
 
2527
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )
 
2528
 
 
2529
        PORT_START("COINS")
 
2530
        PORT_BIT( 0x01, IP_ACTIVE_LOW,  IPT_UNKNOWN   )
 
2531
        PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_SPECIAL   ) // hopper switch
 
2532
        PORT_SERVICE_NO_TOGGLE( 0x04,   IP_ACTIVE_LOW ) // keep pressed while booting
 
2533
        PORT_BIT( 0x08, IP_ACTIVE_LOW,  IPT_SERVICE1  ) PORT_NAME("Statistics") // press with the above for sound test
 
2534
        PORT_BIT( 0x10, IP_ACTIVE_LOW,  IPT_COIN1     ) PORT_IMPULSE(2)
 
2535
        PORT_BIT( 0x20, IP_ACTIVE_LOW,  IPT_OTHER     ) PORT_NAME("Pay Out") PORT_CODE(KEYCODE_O)
 
2536
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_SERVICE3  ) // shown in test mode
 
2537
        PORT_BIT( 0x80, IP_ACTIVE_LOW,  IPT_UNKNOWN   )
 
2538
 
 
2539
        PORT_START("KEY0")
 
2540
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A )
 
2541
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E )
 
2542
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I )
 
2543
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M )
 
2544
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN )
 
2545
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1 )
 
2546
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2547
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2548
 
 
2549
        PORT_START("KEY1")
 
2550
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B )
 
2551
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F )
 
2552
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J )
 
2553
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N )
 
2554
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH )
 
2555
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_BET )
 
2556
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2557
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2558
 
 
2559
        PORT_START("KEY2")
 
2560
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C )
 
2561
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G )
 
2562
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K )
 
2563
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI )
 
2564
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON )
 
2565
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2566
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2567
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2568
 
 
2569
        PORT_START("KEY3")
 
2570
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D )
 
2571
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H )
 
2572
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L )
 
2573
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON )
 
2574
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2575
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2576
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2577
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2578
 
 
2579
        PORT_START("KEY4")
 
2580
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE )
 
2581
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_SCORE )
 
2582
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_DOUBLE_UP )
 
2583
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2584
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG )
 
2585
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL )
 
2586
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2587
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN )
 
2588
 
 
2589
INPUT_PORTS_END
 
2590
 
1751
2591
static INPUT_PORTS_START( mgcs )
1752
2592
 
1753
2593
        // DSWs don't work: they are read through a protection device (IGS029? see code at 1CF16)
1921
2761
        PORT_BIT( 0x20, IP_ACTIVE_LOW,  IPT_OTHER     ) PORT_NAME("Pay Out") PORT_CODE(KEYCODE_O)
1922
2762
 
1923
2763
        // Keyboard mode:
1924
 
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_SERVICE3  ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)        // shown in test mode
 
2764
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_SERVICE3  ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40) // shown in test mode
1925
2765
        // Joystick mode:
1926
 
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_BUTTON3   ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
 
2766
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_BUTTON3   ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
1927
2767
 
1928
2768
        PORT_BIT( 0x80, IP_ACTIVE_LOW,  IPT_UNKNOWN   )
1929
2769
 
1930
2770
        PORT_START("KEY0")
1931
2771
        // Keyboard mode:
1932
 
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A         ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1933
 
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E         ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1934
 
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I         ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1935
 
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M         ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1936
 
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN       ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1937
 
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1938
 
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
1939
 
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x40)
 
2772
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A         ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2773
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E         ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2774
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I         ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2775
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M         ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2776
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN       ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2777
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2778
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
 
2779
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x40,EQUALS,0x40)
1940
2780
        // Joystick mode:
1941
 
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1942
 
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP       ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1943
 
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN     ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1944
 
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT     ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1945
 
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT    ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1946
 
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1           ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1947
 
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_BUTTON2           ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
1948
 
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x40,PORTCOND_EQUALS,0x00)
 
2781
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2782
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP       ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2783
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN     ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2784
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT     ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2785
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT    ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2786
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1           ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2787
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_BUTTON2           ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
 
2788
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x40,EQUALS,0x00)
1949
2789
 
1950
2790
        PORT_START("KEY1")
1951
2791
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B )
2052
2892
 
2053
2893
        PORT_START("KEY0")
2054
2894
        // Keyboard mode:
2055
 
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A         ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2056
 
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E         ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2057
 
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I         ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2058
 
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M         ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2059
 
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN       ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2060
 
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2061
 
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
2062
 
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x02)
 
2895
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A         ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2896
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E         ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2897
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I         ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2898
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M         ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2899
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN       ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2900
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2901
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
 
2902
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,EQUALS,0x02)
2063
2903
        // Joystick mode:
2064
 
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2065
 
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP       ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2066
 
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN     ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2067
 
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT     ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2068
 
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT    ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2069
 
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1           ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2070
 
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
2071
 
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,PORTCOND_EQUALS,0x00)
 
2904
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START1            ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2905
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP       ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2906
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN     ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2907
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT     ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2908
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT    ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2909
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1           ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2910
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
 
2911
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN           ) PORT_CONDITION("DSW2",0x02,EQUALS,0x00)
2072
2912
 
2073
2913
        PORT_START("KEY1")
2074
2914
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B )
2122
2962
 
2123
2963
INPUT_PORTS_END
2124
2964
 
 
2965
static INPUT_PORTS_START( slqz2 )
 
2966
 
 
2967
        PORT_START("DSW1")
 
2968
        PORT_DIPNAME( 0x03, 0x03, DEF_STR( Coinage ) )
 
2969
        PORT_DIPSETTING(    0x03, DEF_STR( 1C_1C ) )
 
2970
        PORT_DIPSETTING(    0x02, DEF_STR( 1C_2C ) )
 
2971
        PORT_DIPSETTING(    0x01, DEF_STR( 1C_3C ) )
 
2972
        PORT_DIPSETTING(    0x00, DEF_STR( 1C_5C ) )
 
2973
        PORT_DIPNAME( 0x0c, 0x0c, "Credits Per Note" )
 
2974
        PORT_DIPSETTING(    0x0c, "10" )
 
2975
        PORT_DIPSETTING(    0x08, "20" )
 
2976
        PORT_DIPSETTING(    0x04, "50" )
 
2977
        PORT_DIPSETTING(    0x00, "100" )
 
2978
        PORT_DIPNAME( 0x10, 0x10, "Max Note Credits" )
 
2979
        PORT_DIPSETTING(    0x10, "1000" )
 
2980
        PORT_DIPSETTING(    0x00, "2000" )
 
2981
        PORT_DIPNAME( 0x20, 0x20, "Money Type" )
 
2982
        PORT_DIPSETTING(    0x20, "Coins" )
 
2983
        PORT_DIPSETTING(    0x00, "Notes" )
 
2984
        PORT_DIPNAME( 0x40, 0x40, "Pay Out Type" )
 
2985
        PORT_DIPSETTING(    0x40, "Coins" )
 
2986
        PORT_DIPSETTING(    0x00, "Notes" )
 
2987
        PORT_DIPNAME( 0x80, 0x80, DEF_STR( Demo_Sounds ) )
 
2988
        PORT_DIPSETTING(    0x00, DEF_STR( Off ) )
 
2989
        PORT_DIPSETTING(    0x80, DEF_STR( On ) )
 
2990
 
 
2991
        PORT_START("DSW2")
 
2992
        PORT_DIPNAME( 0x03, 0x03, "Min Bet" )
 
2993
        PORT_DIPSETTING(    0x03, "500" )
 
2994
        PORT_DIPSETTING(    0x02, "1000" )
 
2995
        PORT_DIPSETTING(    0x01, "1500" )
 
2996
        PORT_DIPSETTING(    0x00, "2000" )
 
2997
        PORT_DIPNAME( 0x0c, 0x0c, DEF_STR( Unknown ) )
 
2998
        PORT_DIPSETTING(    0x0c, "1" )
 
2999
        PORT_DIPSETTING(    0x08, "2" )
 
3000
        PORT_DIPSETTING(    0x04, "3" )
 
3001
        PORT_DIPSETTING(    0x00, "5" )
 
3002
        PORT_DIPNAME( 0x10, 0x10, "Bonus Round" )
 
3003
        PORT_DIPSETTING(    0x00, DEF_STR( No ) )
 
3004
        PORT_DIPSETTING(    0x10, DEF_STR( Yes ) )
 
3005
        PORT_DIPNAME( 0x20, 0x20, "Number Type" )
 
3006
        PORT_DIPSETTING(    0x20, "Number" )
 
3007
        PORT_DIPSETTING(    0x00, "Dice" )
 
3008
        PORT_DIPNAME( 0x40, 0x40, "Symbols" )
 
3009
        PORT_DIPSETTING(    0x40, DEF_STR( Off ) )
 
3010
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )       // pigs, apples
 
3011
        PORT_DIPNAME( 0x80, 0x80, DEF_STR( Unknown ) )
 
3012
        PORT_DIPSETTING(    0x80, DEF_STR( Off ) )
 
3013
        PORT_DIPSETTING(    0x00, DEF_STR( On ) )
 
3014
 
 
3015
        PORT_START("COINS")
 
3016
        PORT_BIT( 0x01, IP_ACTIVE_LOW,  IPT_SPECIAL   ) // hopper switch (unimplemented)
 
3017
        PORT_SERVICE_NO_TOGGLE( 0x02,   IP_ACTIVE_LOW ) // service mode (keep pressed during boot too)
 
3018
        PORT_BIT( 0x04, IP_ACTIVE_LOW,  IPT_SERVICE1  ) PORT_NAME("Statistics") // press with the above for sound test
 
3019
        PORT_BIT( 0x08, IP_ACTIVE_LOW,  IPT_COIN1     ) PORT_IMPULSE(5) // coin error otherwise
 
3020
        PORT_BIT( 0x10, IP_ACTIVE_LOW,  IPT_OTHER     ) PORT_NAME("Pay Out") PORT_CODE(KEYCODE_O)
 
3021
        PORT_BIT( 0x20, IP_ACTIVE_LOW,  IPT_UNKNOWN   )
 
3022
        PORT_BIT( 0x40, IP_ACTIVE_LOW,  IPT_BUTTON2   )
 
3023
        PORT_BIT( 0x80, IP_ACTIVE_LOW,  IPT_BUTTON3   )
 
3024
 
 
3025
        PORT_START("PLAYER1")
 
3026
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START1         )     PORT_NAME("Start / Don Den")
 
3027
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP    )
 
3028
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN  )
 
3029
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT  )
 
3030
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT )
 
3031
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1        ) PORT_NAME( "Help / Big" )
 
3032
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN        )
 
3033
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN        )
 
3034
 
 
3035
        PORT_START("PLAYER2")
 
3036
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_START2         )     PORT_NAME( "Bet" )
 
3037
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_JOYSTICK_UP    ) PORT_PLAYER(2)
 
3038
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_JOYSTICK_DOWN  ) PORT_PLAYER(2)
 
3039
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_JOYSTICK_LEFT  ) PORT_PLAYER(2)
 
3040
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_JOYSTICK_RIGHT ) PORT_PLAYER(2)
 
3041
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_BUTTON1        ) PORT_PLAYER(2)
 
3042
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_BUTTON2        ) PORT_PLAYER(2)
 
3043
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_BUTTON3        ) PORT_PLAYER(2)
 
3044
 
 
3045
        PORT_START("BUTTONS")
 
3046
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_1_PAD)
 
3047
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_2_PAD)
 
3048
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_3_PAD)
 
3049
        PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_4_PAD)
 
3050
        PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_5_PAD)
 
3051
        PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_6_PAD)
 
3052
        PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_7_PAD)
 
3053
        PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_OTHER ) PORT_NAME("0") PORT_CODE(KEYCODE_8_PAD)
 
3054
 
 
3055
INPUT_PORTS_END
 
3056
 
2125
3057
static INPUT_PORTS_START( tjsb )
2126
3058
 
2127
3059
        PORT_START("DSW1")
2288
3220
 
2289
3221
 
2290
3222
// Dips are read through the 8255
2291
 
static const ppi8255_interface iqblocka_ppi8255_intf =
 
3223
static I8255A_INTERFACE( iqblocka_ppi8255_intf )
2292
3224
{
2293
 
        DEVCB_INPUT_PORT("DSW1"),       // Port A read
2294
 
        DEVCB_INPUT_PORT("DSW2"),       // Port B read
2295
 
        DEVCB_INPUT_PORT("DSW3"),       // Port C read
2296
 
 
2297
 
        DEVCB_NULL,                                     // Port A write
2298
 
        DEVCB_NULL,                                     // Port B write
2299
 
        DEVCB_NULL                                      // Port C write
 
3225
        DEVCB_INPUT_PORT("DSW1"),                       /* Port A read */
 
3226
        DEVCB_NULL,                                                     /* Port A write */
 
3227
        DEVCB_INPUT_PORT("DSW2"),                       /* Port B read */
 
3228
        DEVCB_NULL,                                                     /* Port B write */
 
3229
        DEVCB_INPUT_PORT("DSW3"),                       /* Port C read */
 
3230
        DEVCB_NULL                                                      /* Port C write */
2300
3231
};
2301
3232
 
 
3233
 
2302
3234
static MACHINE_RESET( iqblocka )
2303
3235
{
2304
3236
        igs017_state *state = machine.driver_data<igs017_state>();
2313
3245
        MCFG_CPU_IO_MAP(iqblocka_io)
2314
3246
        MCFG_TIMER_ADD_SCANLINE("scantimer", irqblocka_interrupt, "screen", 0, 1)
2315
3247
 
2316
 
        MCFG_PPI8255_ADD( "ppi8255", iqblocka_ppi8255_intf )
 
3248
        MCFG_I8255A_ADD( "ppi8255", iqblocka_ppi8255_intf )
2317
3249
 
2318
3250
        MCFG_MACHINE_RESET(iqblocka)
2319
3251
 
2366
3298
        memset(state->m_igs_magic, 0, sizeof(state->m_igs_magic));
2367
3299
}
2368
3300
 
2369
 
static const ppi8255_interface mgcs_ppi8255_intf =
 
3301
static I8255A_INTERFACE( mgcs_ppi8255_intf )
2370
3302
{
2371
 
        DEVCB_INPUT_PORT("COINS"),      // Port A read
2372
 
        DEVCB_HANDLER(mgcs_keys_r),     // Port B read
2373
 
        DEVCB_NULL,                                     // Port C read (see code at 1C83A)
2374
 
 
2375
 
        DEVCB_NULL,                                     // Port A write
2376
 
        DEVCB_NULL,                                     // Port B write
2377
 
        DEVCB_NULL                                      // Port C write
 
3303
        DEVCB_INPUT_PORT("COINS"),                      /* Port A read */
 
3304
        DEVCB_NULL,                                                     /* Port A write */
 
3305
        DEVCB_HANDLER(mgcs_keys_r),                     /* Port B read */
 
3306
        DEVCB_NULL,                                                     /* Port B write */
 
3307
        DEVCB_NULL,                                                     /* Port C read */
 
3308
        DEVCB_NULL                                                      /* Port C write */
2378
3309
};
2379
3310
 
2380
3311
static MACHINE_CONFIG_START( mgcs, igs017_state )
2384
3315
 
2385
3316
        MCFG_MACHINE_RESET(mgcs)
2386
3317
 
2387
 
        MCFG_PPI8255_ADD( "ppi8255", mgcs_ppi8255_intf )
 
3318
        MCFG_I8255A_ADD( "ppi8255", mgcs_ppi8255_intf )
2388
3319
 
2389
3320
        /* video hardware */
2390
3321
        MCFG_SCREEN_ADD("screen", RASTER)
2408
3339
 
2409
3340
 
2410
3341
 
 
3342
// lhzb2
 
3343
static I8255A_INTERFACE( lhzb2_ppi8255_intf )
 
3344
{
 
3345
        DEVCB_INPUT_PORT("COINS"),                      /* Port A read */
 
3346
        DEVCB_NULL,                                                     /* Port A write */
 
3347
        DEVCB_INPUT_PORT("DSW1"),                       /* Port B read */
 
3348
        DEVCB_NULL,                                                     /* Port B write */
 
3349
        DEVCB_INPUT_PORT("DSW2"),                       /* Port C read */
 
3350
        DEVCB_NULL                                                      /* Port C write */
 
3351
};
 
3352
 
 
3353
static MACHINE_CONFIG_START( lhzb2, igs017_state )
 
3354
        MCFG_CPU_ADD("maincpu", M68000, XTAL_22MHz / 2)
 
3355
        MCFG_CPU_PROGRAM_MAP(lhzb2)
 
3356
        MCFG_TIMER_ADD_SCANLINE("scantimer", mgcs_interrupt, "screen", 0, 1)
 
3357
 
 
3358
        MCFG_MACHINE_RESET(mgcs)
 
3359
 
 
3360
        MCFG_I8255A_ADD( "ppi8255", lhzb2_ppi8255_intf )
 
3361
 
 
3362
        /* video hardware */
 
3363
        MCFG_SCREEN_ADD("screen", RASTER)
 
3364
        MCFG_SCREEN_REFRESH_RATE(60)
 
3365
        MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
 
3366
        MCFG_SCREEN_SIZE(512, 256)
 
3367
        MCFG_SCREEN_VISIBLE_AREA(0, 512-1, 0, 240-1)
 
3368
        MCFG_SCREEN_UPDATE_STATIC(igs017)
 
3369
 
 
3370
        MCFG_GFXDECODE(igs017_swapped)
 
3371
        MCFG_PALETTE_LENGTH(0x100*2)
 
3372
 
 
3373
        MCFG_VIDEO_START(igs017)
 
3374
        MCFG_VIDEO_RESET(igs017)
 
3375
 
 
3376
        /* sound hardware */
 
3377
        MCFG_SPEAKER_STANDARD_MONO("mono")
 
3378
        MCFG_OKIM6295_ADD("oki", XTAL_8MHz / 8, OKIM6295_PIN7_HIGH)
 
3379
        MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.5)
 
3380
MACHINE_CONFIG_END
 
3381
 
 
3382
 
 
3383
 
 
3384
// lhzb2a
 
3385
 
 
3386
static MACHINE_RESET( lhzb2a )
 
3387
{
 
3388
        igs017_state *state = machine.driver_data<igs017_state>();
 
3389
        MACHINE_RESET_CALL( mgcs );
 
3390
        state->lhzb2a_input_addr_w(*state->m_maincpu->memory().space(AS_PROGRAM), 0, 0xf0);
 
3391
}
 
3392
 
 
3393
static MACHINE_CONFIG_START( lhzb2a, igs017_state )
 
3394
        MCFG_CPU_ADD("maincpu", M68000, XTAL_22MHz/2)
 
3395
        MCFG_CPU_PROGRAM_MAP(lhzb2a)
 
3396
        MCFG_TIMER_ADD_SCANLINE("scantimer", mgcs_interrupt, "screen", 0, 1)
 
3397
 
 
3398
        MCFG_MACHINE_RESET(lhzb2a)
 
3399
 
 
3400
//  MCFG_I8255A_ADD( "ppi8255", sdmg2_ppi8255_intf )
 
3401
 
 
3402
        /* video hardware */
 
3403
        MCFG_SCREEN_ADD("screen", RASTER)
 
3404
        MCFG_SCREEN_REFRESH_RATE(60)    // VSync 60Hz, HSync 15.3kHz
 
3405
        MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
 
3406
        MCFG_SCREEN_SIZE(512, 256)
 
3407
        MCFG_SCREEN_VISIBLE_AREA(0, 512-1, 0, 256-16-1)
 
3408
        MCFG_SCREEN_UPDATE_STATIC(igs017)
 
3409
 
 
3410
        MCFG_GFXDECODE(igs017_swapped)
 
3411
        MCFG_PALETTE_LENGTH(0x100*2)
 
3412
 
 
3413
        MCFG_VIDEO_START(igs017)
 
3414
        MCFG_VIDEO_RESET(igs017)
 
3415
 
 
3416
        /* sound hardware */
 
3417
        MCFG_SPEAKER_STANDARD_MONO("mono")
 
3418
        MCFG_OKIM6295_ADD("oki", XTAL_22MHz / 22, OKIM6295_PIN7_HIGH)
 
3419
        MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.5)
 
3420
MACHINE_CONFIG_END
 
3421
 
 
3422
 
 
3423
 
 
3424
// slqz2
 
3425
 
 
3426
static MACHINE_CONFIG_START( slqz2, igs017_state )
 
3427
        MCFG_CPU_ADD("maincpu", M68000, XTAL_22MHz / 2)
 
3428
        MCFG_CPU_PROGRAM_MAP(slqz2)
 
3429
        MCFG_TIMER_ADD_SCANLINE("scantimer", mgcs_interrupt, "screen", 0, 1)
 
3430
 
 
3431
        MCFG_MACHINE_RESET(mgcs)
 
3432
 
 
3433
        MCFG_I8255A_ADD( "ppi8255", lhzb2_ppi8255_intf )
 
3434
 
 
3435
        /* video hardware */
 
3436
        MCFG_SCREEN_ADD("screen", RASTER)
 
3437
        MCFG_SCREEN_REFRESH_RATE(60)
 
3438
        MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(0))
 
3439
        MCFG_SCREEN_SIZE(512, 256)
 
3440
        MCFG_SCREEN_VISIBLE_AREA(0, 512-1, 0, 240-1)
 
3441
        MCFG_SCREEN_UPDATE_STATIC(igs017)
 
3442
 
 
3443
        MCFG_GFXDECODE(igs017)
 
3444
        MCFG_PALETTE_LENGTH(0x100*2)
 
3445
 
 
3446
        MCFG_VIDEO_START(igs017)
 
3447
        MCFG_VIDEO_RESET(igs017)
 
3448
 
 
3449
        /* sound hardware */
 
3450
        MCFG_SPEAKER_STANDARD_MONO("mono")
 
3451
        MCFG_OKIM6295_ADD("oki", XTAL_8MHz / 8, OKIM6295_PIN7_HIGH)
 
3452
        MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.5)
 
3453
MACHINE_CONFIG_END
 
3454
 
 
3455
 
 
3456
 
2411
3457
// sdmg2
2412
 
 
2413
 
static const ppi8255_interface sdmg2_ppi8255_intf =
 
3458
static I8255A_INTERFACE( sdmg2_ppi8255_intf )
2414
3459
{
2415
 
        DEVCB_INPUT_PORT("DSW1"),       // Port A read
2416
 
        DEVCB_INPUT_PORT("DSW2"),       // Port B read
2417
 
        DEVCB_NULL,                                     // Port C read
2418
 
 
2419
 
        DEVCB_NULL,                                     // Port A write
2420
 
        DEVCB_NULL,                                     // Port B write
2421
 
        DEVCB_NULL                                      // Port C write
 
3460
        DEVCB_INPUT_PORT("DSW1"),                       /* Port A read */
 
3461
        DEVCB_NULL,                                                     /* Port A write */
 
3462
        DEVCB_INPUT_PORT("DSW2"),                       /* Port B read */
 
3463
        DEVCB_NULL,                                                     /* Port B write */
 
3464
        DEVCB_NULL,                                                     /* Port C read */
 
3465
        DEVCB_NULL                                                      /* Port C write */
2422
3466
};
2423
3467
 
2424
3468
static MACHINE_CONFIG_START( sdmg2, igs017_state )
2428
3472
 
2429
3473
        MCFG_MACHINE_RESET(mgcs)
2430
3474
 
2431
 
        MCFG_PPI8255_ADD( "ppi8255", sdmg2_ppi8255_intf )
 
3475
        MCFG_I8255A_ADD( "ppi8255", sdmg2_ppi8255_intf )
2432
3476
 
2433
3477
        /* video hardware */
2434
3478
        MCFG_SCREEN_ADD("screen", RASTER)
2465
3509
                device_set_input_line(state->m_maincpu, 3, HOLD_LINE); // lev 3 instead of 2
2466
3510
}
2467
3511
 
2468
 
static const ppi8255_interface mgdh_ppi8255_intf =
 
3512
static I8255A_INTERFACE( mgdh_ppi8255_intf )
2469
3513
{
2470
 
        DEVCB_INPUT_PORT("DSW1"),       // Port A read
2471
 
        DEVCB_NULL,                                     // Port B read
2472
 
        DEVCB_NULL,                                     // Port C read
2473
 
 
2474
 
        DEVCB_NULL,                                     // Port A write
2475
 
        DEVCB_NULL,                                     // Port B write
2476
 
        DEVCB_NULL                                      // Port C write
 
3514
        DEVCB_INPUT_PORT("DSW1"),                       /* Port A read */
 
3515
        DEVCB_NULL,                                                     /* Port A write */
 
3516
        DEVCB_NULL,                                                     /* Port B read */
 
3517
        DEVCB_NULL,                                                     /* Port B write */
 
3518
        DEVCB_NULL,                                                     /* Port C read */
 
3519
        DEVCB_NULL                                                      /* Port C write */
2477
3520
};
2478
3521
 
2479
3522
static MACHINE_CONFIG_START( mgdha, igs017_state )
2483
3526
 
2484
3527
        MCFG_MACHINE_RESET(mgcs)
2485
3528
 
2486
 
        MCFG_PPI8255_ADD( "ppi8255", mgdh_ppi8255_intf )
 
3529
        MCFG_I8255A_ADD( "ppi8255", mgdh_ppi8255_intf )
2487
3530
 
2488
3531
        /* video hardware */
2489
3532
        MCFG_SCREEN_ADD("screen", RASTER)
2514
3557
        MCFG_CPU_IO_MAP(tjsb_io)
2515
3558
        MCFG_TIMER_ADD_SCANLINE("scantimer", irqblocka_interrupt, "screen", 0, 1)
2516
3559
 
2517
 
        MCFG_PPI8255_ADD( "ppi8255", iqblocka_ppi8255_intf )
 
3560
        MCFG_I8255A_ADD( "ppi8255", iqblocka_ppi8255_intf )
2518
3561
 
2519
3562
        MCFG_MACHINE_RESET(iqblocka)
2520
3563
 
2787
3830
        ROM_LOAD16_WORD_SWAP( "p0900.u25", 0x00000, 0x80000,CRC(43366f51) SHA1(48dd965dceff7de15b43c2140226a8b17a792dbc) )
2788
3831
 
2789
3832
        ROM_REGION( 0x280000, "sprites", 0 )
2790
 
        ROM_LOAD( "m0901.u5", 0x000000, 0x200000, CRC(9699db24) SHA1(50fc2f173c20b48d10595f01f1e9545f1b13a61b) )
2791
 
        ROM_LOAD( "m0902.u4", 0x200000, 0x080000, CRC(3298b13b) SHA1(13b21ddeed368b7f4fea1408c8fc511244342faf) )
 
3833
        ROM_LOAD( "m0901.u5", 0x000000, 0x200000, CRC(9699db24) SHA1(50fc2f173c20b48d10595f01f1e9545f1b13a61b) )        // FIXED BITS (xxxxxxxx0xxxxxxx)
 
3834
        ROM_LOAD( "m0902.u4", 0x200000, 0x080000, CRC(3298b13b) SHA1(13b21ddeed368b7f4fea1408c8fc511244342faf) )        // FIXED BITS (xxxxxxxx0xxxxxxx)
2792
3835
 
2793
3836
        ROM_REGION( 0x20000, "tilemaps", 0 )
2794
3837
        ROM_LOAD( "text.u6", 0x000000, 0x020000, CRC(cb34cbc0) SHA1(ceedbdda085fd1acc9a575502bdf7cf998f54f05) )
2847
3890
        ROM_REGION( 0x10000, "igs022", 0 )      // INTERNATIONAL GAMES SYSTEM CO.,LTD
2848
3891
        ROM_LOAD( "m1104.u11",0x0000, 0x10000, CRC(794d0276) SHA1(ac903d2faa3fb315438dc8da22c5337611a8790d) )
2849
3892
 
2850
 
        ROM_REGION( 0x200000, "sprites", 0 )    // adddress scrambling
2851
 
        ROM_LOAD16_WORD_SWAP( "m1101.u6", 0x000000, 0x200000, CRC(fed09cd6) SHA1(0658a97983f8ba408126e79889cc58323f2d99ba) )
 
3893
        ROM_REGION( 0x400000, "sprites", 0 )    // adddress scrambling
 
3894
        ROM_LOAD16_WORD_SWAP( "m1101.u6", 0x000000, 0x400000, CRC(0114e9d1) SHA1(5b16170d3cd8b8e1662c949b7234fbdd2ca927f7) )    // FIXED BITS (0xxxxxxxxxxxxxxx)
2852
3895
 
2853
 
        ROM_REGION( 0x40000, "tilemaps", 0 )    // adddress scrambling
2854
 
        ROM_LOAD( "m1103.u8", 0x00000, 0x40000, CRC(89d0b81c) SHA1(b8d294a143e5cc9466b544cb70e43a7ce3450ace) )
 
3896
        ROM_REGION( 0x80000, "tilemaps", 0 )    // adddress scrambling
 
3897
        ROM_LOAD( "m1103.u8", 0x00000, 0x80000, CRC(4d3776b4) SHA1(fa9b311b1a6ad56e136b66d090bc62ed5003b2f2) )
2855
3898
 
2856
3899
        ROM_REGION( 0x80000, "oki", 0 )
2857
3900
        ROM_LOAD( "s1102.u23", 0x00000, 0x80000, CRC(51ffe245) SHA1(849011b186096add657ab20d49d260ec23363ef3) )
2863
3906
        ROM_REGION( 0x80000, "maincpu", 0 )
2864
3907
        ROM_LOAD16_WORD_SWAP( "p-4096", 0x00000, 0x80000, CRC(41293f32) SHA1(df4e993f4a458729ade13981e58f32d8116c0082) )
2865
3908
 
2866
 
        ROM_REGION( 0x200000, "sprites", 0 )    // adddress scrambling
2867
 
        ROM_LOAD16_WORD_SWAP( "m1101.u6", 0x000000, 0x200000, CRC(fed09cd6) SHA1(0658a97983f8ba408126e79889cc58323f2d99ba) )
 
3909
        ROM_REGION( 0x400000, "sprites", 0 )    // adddress scrambling
 
3910
        ROM_LOAD16_WORD_SWAP( "m1101.u6", 0x000000, 0x400000, CRC(0114e9d1) SHA1(5b16170d3cd8b8e1662c949b7234fbdd2ca927f7) )    // FIXED BITS (0xxxxxxxxxxxxxxx)
2868
3911
 
2869
3912
        ROM_REGION( 0x80000, "tilemaps", 0 )    // adddress scrambling
2870
 
        ROM_LOAD( "m1103", 0x000000, 0x080000, CRC(4d3776b4) SHA1(fa9b311b1a6ad56e136b66d090bc62ed5003b2f2) )
 
3913
        ROM_LOAD( "m1103.u8", 0x00000, 0x80000, CRC(4d3776b4) SHA1(fa9b311b1a6ad56e136b66d090bc62ed5003b2f2) )
2871
3914
 
2872
3915
        ROM_REGION( 0x80000, "oki", 0 )
2873
3916
        ROM_LOAD( "s1102.u23", 0x00000, 0x80000, CRC(51ffe245) SHA1(849011b186096add657ab20d49d260ec23363ef3) )
2922
3965
        ROM_REGION( 0x10000, "igs022", 0 )      // INTERNATIONAL GAMES SYSTEM CO.,LTD
2923
3966
        ROM_LOAD( "m1103.u12", 0x00000, 0x10000, CRC(9f3b8d65) SHA1(5ee1ad025474399c2826f21d970e76f25d0fa1fd) )
2924
3967
 
2925
 
        ROM_REGION( 0x200000, "sprites", 0 )    // adddress scrambling
2926
 
        ROM_LOAD16_WORD_SWAP( "m1101.u4", 0x000000, 0x200000, CRC(fed09cd6) SHA1(0658a97983f8ba408126e79889cc58323f2d99ba) ) // = m1101.u6 Mahjong Long Hu Zheng Ba 2
 
3968
        ROM_REGION( 0x400000, "sprites", 0 )    // adddress scrambling
 
3969
        ROM_LOAD16_WORD_SWAP( "m1101.u4", 0x000000, 0x400000, CRC(0114e9d1) SHA1(5b16170d3cd8b8e1662c949b7234fbdd2ca927f7) )    // FIXED BITS (0xxxxxxxxxxxxxxx)
2927
3970
 
2928
3971
        ROM_REGION( 0x80000, "tilemaps", 0 )    // light adddress scrambling
2929
3972
        ROM_LOAD( "text.u6", 0x00000, 0x80000, CRC(40d21adf) SHA1(18b202d6330ac89026bec2c9c8224b52540dd48d) )
3126
4169
 
3127
4170
GAME( 1996,  iqblocka, iqblock, iqblocka, iqblocka, iqblocka, ROT0, "IGS",              "Shu Zi Le Yuan (V127M)",                      GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
3128
4171
GAME( 1996,  iqblockf, iqblock, iqblocka, iqblocka, iqblockf, ROT0, "IGS",              "Shu Zi Le Yuan (V113FR)",                     GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
3129
 
GAME( 1997,  tjsb,     0,       tjsb,     tjsb,     tjsb,     ROT0, "IGS",              "Mahjong Tian Jiang Shen Bing (V137C)",        GAME_UNEMULATED_PROTECTION )
3130
 
GAME( 1997,  sdmg2,    0,       sdmg2,    sdmg2,    sdmg2,    ROT0, "IGS",              "Mahjong Super Da Man Guan II (China, V754C)", 0 )
3131
4172
GAME( 1997,  mgdh,     0,       mgdha,    mgdh,     mgdh,     ROT0, "IGS",              "Mahjong Man Guan Da Heng (Taiwan, V125T1)",   0 )
3132
4173
GAME( 1997,  mgdha,    mgdh,    mgdha,    mgdh ,    mgdha,    ROT0, "IGS",              "Mahjong Man Guan Da Heng (Taiwan, V123T1)",   0 )
 
4174
GAME( 1997,  sdmg2,    0,       sdmg2,    sdmg2,    sdmg2,    ROT0, "IGS",              "Mahjong Super Da Man Guan II (China, V754C)", 0 )
 
4175
GAME( 1997,  tjsb,     0,       tjsb,     tjsb,     tjsb,     ROT0, "IGS",              "Mahjong Tian Jiang Shen Bing (V137C)",        GAME_UNEMULATED_PROTECTION )
3133
4176
GAME( 1998,  mgcs,     0,       mgcs,     mgcs,     mgcs,     ROT0, "IGS",              "Mahjong Man Guan Cai Shen (V103CS)",          GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION | GAME_IMPERFECT_SOUND )
3134
 
GAME( 1998,  lhzb2,    0,       sdmg2,    sdmg2,    lhzb2,    ROT0, "IGS",              "Mahjong Long Hu Zheng Ba 2 (set 1)",          GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
3135
 
GAME( 1998,  lhzb2a,   lhzb2,   sdmg2,    sdmg2,    lhzb2a,   ROT0, "IGS",              "Mahjong Long Hu Zheng Ba 2 (set 2)",          GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
3136
 
GAME( 1998,  slqz2,    0,       sdmg2,    sdmg2,    slqz2,    ROT0, "IGS",              "Mahjong Shuang Long Qiang Zhu 2",             GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
 
4177
GAME( 1998,  lhzb2,    0,       lhzb2,    lhzb2,     lhzb2,   ROT0, "IGS",              "Mahjong Long Hu Zheng Ba 2 (set 1)",          GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
 
4178
GAME( 1998,  lhzb2a,   lhzb2,   lhzb2a,   lhzb2a,    lhzb2a,  ROT0, "IGS",              "Mahjong Long Hu Zheng Ba 2 (VS221M)",         GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
 
4179
GAME( 1998,  slqz2,    0,       slqz2,    slqz2,    slqz2,    ROT0, "IGS",              "Mahjong Shuang Long Qiang Zhu 2 (VS203J)",    GAME_NOT_WORKING | GAME_UNEMULATED_PROTECTION )
3137
4180
GAME( 1999?, tarzan,   0,       iqblocka, iqblocka, tarzan,   ROT0, "IGS",              "Tarzan (V109C)",                              GAME_NOT_WORKING )
3138
4181
GAME( 1999?, tarzana,  tarzan,  iqblocka, iqblocka, tarzana,  ROT0, "IGS",              "Tarzan (V107)",                               GAME_NOT_WORKING )
3139
4182
GAME( 2000?, starzan,  0,       iqblocka, iqblocka, starzan,  ROT0, "IGS / G.F. Gioca", "Super Tarzan (Italy, V100I)",                 GAME_NOT_WORKING )