← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/drivers/limenko.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/limenko.c
34
34
{
35
35
public:
36
36
        limenko_state(const machine_config &mconfig, device_type type, const char *tag)
37
 
                : driver_device(mconfig, type, tag) { }
 
37
                : driver_device(mconfig, type, tag) ,
 
38
                m_mainram(*this, "mainram"),
 
39
                m_fg_videoram(*this, "fg_videoram"),
 
40
                m_md_videoram(*this, "md_videoram"),
 
41
                m_bg_videoram(*this, "bg_videoram"),
 
42
                m_spriteram(*this, "spriteram"),
 
43
                m_spriteram2(*this, "spriteram2"),
 
44
                m_videoreg(*this, "videoreg"){ }
38
45
 
39
 
        UINT32 *m_spriteram;
40
 
        UINT32 *m_spriteram2;
41
 
        size_t m_spriteram_size;
 
46
        required_shared_ptr<UINT32> m_mainram;
 
47
        required_shared_ptr<UINT32> m_fg_videoram;
 
48
        required_shared_ptr<UINT32> m_md_videoram;
 
49
        required_shared_ptr<UINT32> m_bg_videoram;
 
50
        required_shared_ptr<UINT32> m_spriteram;
 
51
        required_shared_ptr<UINT32> m_spriteram2;
 
52
        required_shared_ptr<UINT32> m_videoreg;
42
53
        tilemap_t *m_bg_tilemap;
43
54
        tilemap_t *m_md_tilemap;
44
55
        tilemap_t *m_fg_tilemap;
45
 
        UINT32 *m_bg_videoram;
46
 
        UINT32 *m_md_videoram;
47
 
        UINT32 *m_fg_videoram;
48
 
        UINT32 *m_videoreg;
49
 
        UINT32 *m_mainram;
50
56
        int m_spriteram_bit;
51
57
        bitmap_ind16 m_sprites_bitmap;
52
58
        bitmap_ind8 m_sprites_bitmap_pri;
53
59
        int m_prev_sprites_count;
54
60
        UINT8 m_spotty_sound_cmd;
 
61
        DECLARE_WRITE32_MEMBER(limenko_coincounter_w);
 
62
        DECLARE_WRITE32_MEMBER(limenko_paletteram_w);
 
63
        DECLARE_WRITE32_MEMBER(bg_videoram_w);
 
64
        DECLARE_WRITE32_MEMBER(md_videoram_w);
 
65
        DECLARE_WRITE32_MEMBER(fg_videoram_w);
 
66
        DECLARE_WRITE32_MEMBER(spotty_soundlatch_w);
 
67
        DECLARE_WRITE32_MEMBER(spriteram_buffer_w);
 
68
        DECLARE_WRITE8_MEMBER(spotty_sound_cmd_w);
 
69
        DECLARE_READ8_MEMBER(spotty_sound_cmd_r);
 
70
        DECLARE_READ8_MEMBER(spotty_sound_r);
 
71
        DECLARE_READ32_MEMBER(dynabomb_speedup_r);
 
72
        DECLARE_READ32_MEMBER(legendoh_speedup_r);
 
73
        DECLARE_READ32_MEMBER(sb2003_speedup_r);
 
74
        DECLARE_READ32_MEMBER(spotty_speedup_r);
 
75
        DECLARE_CUSTOM_INPUT_MEMBER(spriteram_bit_r);
55
76
};
56
77
 
57
78
 
61
82
  MISC FUNCTIONS
62
83
*****************************************************************************************************/
63
84
 
64
 
static WRITE32_HANDLER( limenko_coincounter_w )
 
85
WRITE32_MEMBER(limenko_state::limenko_coincounter_w)
65
86
{
66
 
        coin_counter_w(space->machine(),0,data & 0x10000);
 
87
        coin_counter_w(machine(),0,data & 0x10000);
67
88
}
68
89
 
69
 
static WRITE32_HANDLER( limenko_paletteram_w )
 
90
WRITE32_MEMBER(limenko_state::limenko_paletteram_w)
70
91
{
71
92
        UINT16 paldata;
72
 
        COMBINE_DATA(&space->machine().generic.paletteram.u32[offset]);
 
93
        COMBINE_DATA(&m_generic_paletteram_32[offset]);
73
94
 
74
95
        if(ACCESSING_BITS_0_15)
75
96
        {
76
 
                paldata = space->machine().generic.paletteram.u32[offset] & 0x7fff;
77
 
                palette_set_color_rgb(space->machine(), offset * 2 + 1, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
 
97
                paldata = m_generic_paletteram_32[offset] & 0x7fff;
 
98
                palette_set_color_rgb(machine(), offset * 2 + 1, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
78
99
        }
79
100
 
80
101
        if(ACCESSING_BITS_16_31)
81
102
        {
82
 
                paldata = (space->machine().generic.paletteram.u32[offset] >> 16) & 0x7fff;
83
 
                palette_set_color_rgb(space->machine(), offset * 2 + 0, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
 
103
                paldata = (m_generic_paletteram_32[offset] >> 16) & 0x7fff;
 
104
                palette_set_color_rgb(machine(), offset * 2 + 0, pal5bit(paldata >> 0), pal5bit(paldata >> 5), pal5bit(paldata >> 10));
84
105
        }
85
106
}
86
107
 
87
 
static WRITE32_HANDLER( bg_videoram_w )
88
 
{
89
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
90
 
        COMBINE_DATA(&state->m_bg_videoram[offset]);
91
 
        state->m_bg_tilemap->mark_tile_dirty(offset);
92
 
}
93
 
 
94
 
static WRITE32_HANDLER( md_videoram_w )
95
 
{
96
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
97
 
        COMBINE_DATA(&state->m_md_videoram[offset]);
98
 
        state->m_md_tilemap->mark_tile_dirty(offset);
99
 
}
100
 
 
101
 
static WRITE32_HANDLER( fg_videoram_w )
102
 
{
103
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
104
 
        COMBINE_DATA(&state->m_fg_videoram[offset]);
105
 
        state->m_fg_tilemap->mark_tile_dirty(offset);
106
 
}
107
 
 
108
 
static WRITE32_HANDLER( spotty_soundlatch_w )
109
 
{
110
 
        soundlatch_w(space, 0, (data >> 16) & 0xff);
111
 
}
112
 
 
113
 
static CUSTOM_INPUT( spriteram_bit_r )
114
 
{
115
 
        limenko_state *state = field.machine().driver_data<limenko_state>();
116
 
        return state->m_spriteram_bit;
117
 
}
118
 
 
119
 
static WRITE32_HANDLER( spriteram_buffer_w )
120
 
{
121
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
 
108
WRITE32_MEMBER(limenko_state::bg_videoram_w)
 
109
{
 
110
        COMBINE_DATA(&m_bg_videoram[offset]);
 
111
        m_bg_tilemap->mark_tile_dirty(offset);
 
112
}
 
113
 
 
114
WRITE32_MEMBER(limenko_state::md_videoram_w)
 
115
{
 
116
        COMBINE_DATA(&m_md_videoram[offset]);
 
117
        m_md_tilemap->mark_tile_dirty(offset);
 
118
}
 
119
 
 
120
WRITE32_MEMBER(limenko_state::fg_videoram_w)
 
121
{
 
122
        COMBINE_DATA(&m_fg_videoram[offset]);
 
123
        m_fg_tilemap->mark_tile_dirty(offset);
 
124
}
 
125
 
 
126
WRITE32_MEMBER(limenko_state::spotty_soundlatch_w)
 
127
{
 
128
        soundlatch_byte_w(space, 0, (data >> 16) & 0xff);
 
129
}
 
130
 
 
131
CUSTOM_INPUT_MEMBER(limenko_state::spriteram_bit_r)
 
132
{
 
133
        return m_spriteram_bit;
 
134
}
 
135
 
 
136
WRITE32_MEMBER(limenko_state::spriteram_buffer_w)
 
137
{
122
138
        rectangle clip(0, 383, 0, 239);
123
139
 
124
 
        state->m_sprites_bitmap_pri.fill(0, clip);
125
 
        state->m_sprites_bitmap.fill(0, clip);
 
140
        m_sprites_bitmap_pri.fill(0, clip);
 
141
        m_sprites_bitmap.fill(0, clip);
126
142
 
127
143
        // toggle spriterams location in the memory map
128
 
        state->m_spriteram_bit ^= 1;
 
144
        m_spriteram_bit ^= 1;
129
145
 
130
 
        if(state->m_spriteram_bit)
 
146
        if(m_spriteram_bit)
131
147
        {
132
148
                // draw the sprites to the frame buffer
133
 
                draw_sprites(space->machine(),state->m_spriteram2,clip,state->m_prev_sprites_count);
 
149
                draw_sprites(machine(),m_spriteram2,clip,m_prev_sprites_count);
134
150
        }
135
151
        else
136
152
        {
137
153
                // draw the sprites to the frame buffer
138
 
                draw_sprites(space->machine(),state->m_spriteram,clip,state->m_prev_sprites_count);
 
154
                draw_sprites(machine(),m_spriteram,clip,m_prev_sprites_count);
139
155
        }
140
156
 
141
157
        // buffer the next number of sprites to draw
142
 
        state->m_prev_sprites_count = (state->m_videoreg[0] & 0x1ff0000) >> 16;
 
158
        m_prev_sprites_count = (m_videoreg[0] & 0x1ff0000) >> 16;
143
159
}
144
160
 
145
161
/*****************************************************************************************************
146
162
  MEMORY MAPS
147
163
*****************************************************************************************************/
148
164
 
149
 
static ADDRESS_MAP_START( limenko_map, AS_PROGRAM, 32 )
150
 
        AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE_MEMBER(limenko_state, m_mainram)
 
165
static ADDRESS_MAP_START( limenko_map, AS_PROGRAM, 32, limenko_state )
 
166
        AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_SHARE("mainram")
151
167
        AM_RANGE(0x40000000, 0x403fffff) AM_ROM AM_REGION("user2",0)
152
 
        AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE(fg_videoram_w) AM_BASE_MEMBER(limenko_state, m_fg_videoram)
153
 
        AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE(md_videoram_w) AM_BASE_MEMBER(limenko_state, m_md_videoram)
154
 
        AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE(bg_videoram_w) AM_BASE_MEMBER(limenko_state, m_bg_videoram)
155
 
        AM_RANGE(0x80018000, 0x80018fff) AM_RAM AM_BASE_SIZE_MEMBER(limenko_state, m_spriteram, m_spriteram_size)
156
 
        AM_RANGE(0x80019000, 0x80019fff) AM_RAM AM_BASE_MEMBER(limenko_state, m_spriteram2)
157
 
        AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE(limenko_paletteram_w) AM_BASE_GENERIC(paletteram)
 
168
        AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE(fg_videoram_w) AM_SHARE("fg_videoram")
 
169
        AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE(md_videoram_w) AM_SHARE("md_videoram")
 
170
        AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE(bg_videoram_w) AM_SHARE("bg_videoram")
 
171
        AM_RANGE(0x80018000, 0x80018fff) AM_RAM AM_SHARE("spriteram")
 
172
        AM_RANGE(0x80019000, 0x80019fff) AM_RAM AM_SHARE("spriteram2")
 
173
        AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE(limenko_paletteram_w) AM_SHARE("paletteram")
158
174
        AM_RANGE(0x8001e000, 0x8001ebff) AM_RAM // ? not used
159
 
        AM_RANGE(0x8001ffec, 0x8001ffff) AM_RAM AM_BASE_MEMBER(limenko_state, m_videoreg)
 
175
        AM_RANGE(0x8001ffec, 0x8001ffff) AM_RAM AM_SHARE("videoreg")
160
176
        AM_RANGE(0x8003e000, 0x8003e003) AM_WRITE(spriteram_buffer_w)
161
177
        AM_RANGE(0xffe00000, 0xffffffff) AM_ROM AM_REGION("user1",0)
162
178
ADDRESS_MAP_END
163
179
 
164
 
static ADDRESS_MAP_START( limenko_io_map, AS_IO, 32 )
 
180
static ADDRESS_MAP_START( limenko_io_map, AS_IO, 32, limenko_state )
165
181
        AM_RANGE(0x0000, 0x0003) AM_READ_PORT("IN0")
166
182
        AM_RANGE(0x0800, 0x0803) AM_READ_PORT("IN1")
167
183
        AM_RANGE(0x1000, 0x1003) AM_READ_PORT("IN2")
173
189
 
174
190
/* Spotty memory map */
175
191
 
176
 
static ADDRESS_MAP_START( spotty_map, AS_PROGRAM, 32 )
177
 
        AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_BASE_MEMBER(limenko_state, m_mainram)
 
192
static ADDRESS_MAP_START( spotty_map, AS_PROGRAM, 32, limenko_state )
 
193
        AM_RANGE(0x00000000, 0x001fffff) AM_RAM AM_SHARE("mainram")
178
194
        AM_RANGE(0x40002000, 0x400024d3) AM_RAM //?
179
 
        AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE(fg_videoram_w) AM_BASE_MEMBER(limenko_state, m_fg_videoram)
180
 
        AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE(md_videoram_w) AM_BASE_MEMBER(limenko_state, m_md_videoram)
181
 
        AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE(bg_videoram_w) AM_BASE_MEMBER(limenko_state, m_bg_videoram)
182
 
        AM_RANGE(0x80018000, 0x80018fff) AM_RAM AM_BASE_SIZE_MEMBER(limenko_state, m_spriteram, m_spriteram_size)
183
 
        AM_RANGE(0x80019000, 0x80019fff) AM_RAM AM_BASE_MEMBER(limenko_state, m_spriteram2)
184
 
        AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE(limenko_paletteram_w) AM_BASE_GENERIC(paletteram)
 
195
        AM_RANGE(0x80000000, 0x80007fff) AM_RAM_WRITE(fg_videoram_w) AM_SHARE("fg_videoram")
 
196
        AM_RANGE(0x80008000, 0x8000ffff) AM_RAM_WRITE(md_videoram_w) AM_SHARE("md_videoram")
 
197
        AM_RANGE(0x80010000, 0x80017fff) AM_RAM_WRITE(bg_videoram_w) AM_SHARE("bg_videoram")
 
198
        AM_RANGE(0x80018000, 0x80018fff) AM_RAM AM_SHARE("spriteram")
 
199
        AM_RANGE(0x80019000, 0x80019fff) AM_RAM AM_SHARE("spriteram2")
 
200
        AM_RANGE(0x8001c000, 0x8001dfff) AM_RAM_WRITE(limenko_paletteram_w) AM_SHARE("paletteram")
185
201
        AM_RANGE(0x8001e000, 0x8001ebff) AM_RAM // ? not used
186
 
        AM_RANGE(0x8001ffec, 0x8001ffff) AM_RAM AM_BASE_MEMBER(limenko_state, m_videoreg)
 
202
        AM_RANGE(0x8001ffec, 0x8001ffff) AM_RAM AM_SHARE("videoreg")
187
203
        AM_RANGE(0x8003e000, 0x8003e003) AM_WRITE(spriteram_buffer_w)
188
204
        AM_RANGE(0xfff00000, 0xffffffff) AM_ROM AM_REGION("user1",0)
189
205
ADDRESS_MAP_END
190
206
 
191
 
static ADDRESS_MAP_START( spotty_io_map, AS_IO, 32 )
 
207
static ADDRESS_MAP_START( spotty_io_map, AS_IO, 32, limenko_state )
192
208
        AM_RANGE(0x0000, 0x0003) AM_READ_PORT("IN0")
193
209
        AM_RANGE(0x0800, 0x0803) AM_READ_PORT("IN1")
194
210
        AM_RANGE(0x0800, 0x0803) AM_WRITENOP // hopper related
197
213
        AM_RANGE(0x5000, 0x5003) AM_WRITE(spotty_soundlatch_w)
198
214
ADDRESS_MAP_END
199
215
 
200
 
static WRITE8_HANDLER( spotty_sound_cmd_w )
 
216
WRITE8_MEMBER(limenko_state::spotty_sound_cmd_w)
201
217
{
202
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
203
 
        state->m_spotty_sound_cmd = data;
 
218
        m_spotty_sound_cmd = data;
204
219
}
205
220
 
206
 
static READ8_HANDLER( spotty_sound_cmd_r )
 
221
READ8_MEMBER(limenko_state::spotty_sound_cmd_r)
207
222
{
208
223
        return 0; //??? some status bit? if set it executes a jump in the code
209
224
}
210
225
 
211
 
static READ8_HANDLER( spotty_sound_r )
 
226
READ8_MEMBER(limenko_state::spotty_sound_r)
212
227
{
213
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
214
 
        // check state->m_spotty_sound_cmd bits...
 
228
        // check m_spotty_sound_cmd bits...
215
229
 
216
 
        if(state->m_spotty_sound_cmd == 0xf7)
217
 
                return soundlatch_r(space,0);
 
230
        if(m_spotty_sound_cmd == 0xf7)
 
231
                return soundlatch_byte_r(space,0);
218
232
        else
219
 
                return space->machine().device<okim6295_device>("oki")->read(*space,0);
 
233
                return machine().device<okim6295_device>("oki")->read(space,0);
220
234
}
221
235
 
222
 
static ADDRESS_MAP_START( spotty_sound_io_map, AS_IO, 8 )
223
 
        AM_RANGE(MCS51_PORT_P1, MCS51_PORT_P1) AM_READ(spotty_sound_r) AM_DEVWRITE_MODERN("oki", okim6295_device, write) //? sound latch and ?
 
236
static ADDRESS_MAP_START( spotty_sound_io_map, AS_IO, 8, limenko_state )
 
237
        AM_RANGE(MCS51_PORT_P1, MCS51_PORT_P1) AM_READ(spotty_sound_r) AM_DEVWRITE("oki", okim6295_device, write) //? sound latch and ?
224
238
        AM_RANGE(MCS51_PORT_P3, MCS51_PORT_P3) AM_READWRITE(spotty_sound_cmd_r, spotty_sound_cmd_w) //not sure about anything...
225
239
ADDRESS_MAP_END
226
240
 
357
371
        limenko_state *state = machine.driver_data<limenko_state>();
358
372
        int i;
359
373
 
360
 
        UINT8 *base_gfx = machine.region("gfx1")->base();
361
 
        UINT8 *gfx_max  = base_gfx + machine.region("gfx1")->bytes();
 
374
        UINT8 *base_gfx = state->memregion("gfx1")->base();
 
375
        UINT8 *gfx_max  = base_gfx + state->memregion("gfx1")->bytes();
362
376
 
363
377
        UINT8 *gfxdata;
364
378
        gfx_element gfx(machine);
537
551
        PORT_DIPNAME( 0x20000000, 0x00000000, "Sound Enable" )
538
552
        PORT_DIPSETTING(          0x20000000, DEF_STR( Off ) )
539
553
        PORT_DIPSETTING(          0x00000000, DEF_STR( On ) )
540
 
        PORT_BIT( 0x80000000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM(spriteram_bit_r, NULL) //changes spriteram location
 
554
        PORT_BIT( 0x80000000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, limenko_state,spriteram_bit_r, NULL) //changes spriteram location
541
555
        PORT_BIT( 0x4000ffff, IP_ACTIVE_LOW, IPT_UNUSED )
542
556
 
543
557
        PORT_START( "EEPROMOUT" )
581
595
        PORT_DIPNAME( 0x20000000, 0x00000000, "Sound Enable" )
582
596
        PORT_DIPSETTING(          0x20000000, DEF_STR( Off ) )
583
597
        PORT_DIPSETTING(          0x00000000, DEF_STR( On ) )
584
 
        PORT_BIT( 0x80000000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM(spriteram_bit_r, NULL) //changes spriteram location
 
598
        PORT_BIT( 0x80000000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, limenko_state,spriteram_bit_r, NULL) //changes spriteram location
585
599
        PORT_BIT( 0x00100000, IP_ACTIVE_LOW, IPT_SERVICE1 ) // checked in dynabomb I/O test, but doesn't work in game
586
600
        PORT_BIT( 0x5f00ffff, IP_ACTIVE_LOW, IPT_UNUSED )
587
601
 
619
633
        PORT_BIT( 0x00010000, IP_ACTIVE_LOW, IPT_START1 )
620
634
        PORT_BIT( 0x00020000, IP_ACTIVE_LOW, IPT_UNUSED )
621
635
        PORT_BIT( 0x00040000, IP_ACTIVE_LOW, IPT_COIN1 )
622
 
        PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM(spriteram_bit_r, NULL) //changes spriteram location
 
636
        PORT_BIT( 0x00080000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_CUSTOM_MEMBER(DEVICE_SELF, limenko_state,spriteram_bit_r, NULL) //changes spriteram location
623
637
        PORT_SERVICE_NO_TOGGLE( 0x00200000, IP_ACTIVE_LOW )
624
638
        PORT_BIT( 0x00400000, IP_ACTIVE_LOW, IPT_SPECIAL ) //security bit
625
639
        PORT_BIT( 0x00800000, IP_ACTIVE_HIGH, IPT_SPECIAL ) PORT_READ_LINE_DEVICE_MEMBER("eeprom", eeprom_device, read_bit)
985
999
 
986
1000
 
987
1001
 
988
 
static READ32_HANDLER( dynabomb_speedup_r )
989
 
{
990
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
991
 
        if(space->machine().firstcpu->pc() == 0xc25b8)
992
 
        {
993
 
                space->machine().firstcpu->eat_cycles(50);
994
 
        }
995
 
 
996
 
        return state->m_mainram[0xe2784/4];
997
 
}
998
 
 
999
 
static READ32_HANDLER( legendoh_speedup_r )
1000
 
{
1001
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
1002
 
        if(space->machine().firstcpu->pc() == 0x23e32)
1003
 
        {
1004
 
                space->machine().firstcpu->eat_cycles(50);
1005
 
        }
1006
 
 
1007
 
        return state->m_mainram[0x32ab0/4];
1008
 
}
1009
 
 
1010
 
static READ32_HANDLER( sb2003_speedup_r )
1011
 
{
1012
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
1013
 
        if(space->machine().firstcpu->pc() == 0x26da4)
1014
 
        {
1015
 
                space->machine().firstcpu->eat_cycles(50);
1016
 
        }
1017
 
 
1018
 
        return state->m_mainram[0x135800/4];
1019
 
}
1020
 
 
1021
 
static READ32_HANDLER( spotty_speedup_r )
1022
 
{
1023
 
        limenko_state *state = space->machine().driver_data<limenko_state>();
1024
 
        if(space->machine().firstcpu->pc() == 0x8560)
1025
 
        {
1026
 
                space->machine().firstcpu->eat_cycles(50);
1027
 
        }
1028
 
 
1029
 
        return state->m_mainram[0x6626c/4];
 
1002
READ32_MEMBER(limenko_state::dynabomb_speedup_r)
 
1003
{
 
1004
        if(machine().firstcpu->pc() == 0xc25b8)
 
1005
        {
 
1006
                machine().firstcpu->eat_cycles(50);
 
1007
        }
 
1008
 
 
1009
        return m_mainram[0xe2784/4];
 
1010
}
 
1011
 
 
1012
READ32_MEMBER(limenko_state::legendoh_speedup_r)
 
1013
{
 
1014
        if(machine().firstcpu->pc() == 0x23e32)
 
1015
        {
 
1016
                machine().firstcpu->eat_cycles(50);
 
1017
        }
 
1018
 
 
1019
        return m_mainram[0x32ab0/4];
 
1020
}
 
1021
 
 
1022
READ32_MEMBER(limenko_state::sb2003_speedup_r)
 
1023
{
 
1024
        if(machine().firstcpu->pc() == 0x26da4)
 
1025
        {
 
1026
                machine().firstcpu->eat_cycles(50);
 
1027
        }
 
1028
 
 
1029
        return m_mainram[0x135800/4];
 
1030
}
 
1031
 
 
1032
READ32_MEMBER(limenko_state::spotty_speedup_r)
 
1033
{
 
1034
        if(machine().firstcpu->pc() == 0x8560)
 
1035
        {
 
1036
                machine().firstcpu->eat_cycles(50);
 
1037
        }
 
1038
 
 
1039
        return m_mainram[0x6626c/4];
1030
1040
}
1031
1041
 
1032
1042
static DRIVER_INIT( dynabomb )
1033
1043
{
1034
1044
        limenko_state *state = machine.driver_data<limenko_state>();
1035
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xe2784, 0xe2787, FUNC(dynabomb_speedup_r) );
 
1045
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0xe2784, 0xe2787, read32_delegate(FUNC(limenko_state::dynabomb_speedup_r), state));
1036
1046
 
1037
1047
        state->m_spriteram_bit = 1;
1038
1048
}
1040
1050
static DRIVER_INIT( legendoh )
1041
1051
{
1042
1052
        limenko_state *state = machine.driver_data<limenko_state>();
1043
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x32ab0, 0x32ab3, FUNC(legendoh_speedup_r) );
 
1053
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x32ab0, 0x32ab3, read32_delegate(FUNC(limenko_state::legendoh_speedup_r), state));
1044
1054
 
1045
1055
        state->m_spriteram_bit = 1;
1046
1056
}
1048
1058
static DRIVER_INIT( sb2003 )
1049
1059
{
1050
1060
        limenko_state *state = machine.driver_data<limenko_state>();
1051
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x135800, 0x135803, FUNC(sb2003_speedup_r) );
 
1061
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x135800, 0x135803, read32_delegate(FUNC(limenko_state::sb2003_speedup_r), state));
1052
1062
 
1053
1063
        state->m_spriteram_bit = 1;
1054
1064
}
1056
1066
static DRIVER_INIT( spotty )
1057
1067
{
1058
1068
        limenko_state *state = machine.driver_data<limenko_state>();
1059
 
        UINT8 *dst    = machine.region("gfx1")->base();
1060
 
        UINT8 *src    = machine.region("user2")->base();
 
1069
        UINT8 *dst    = state->memregion("gfx1")->base();
 
1070
        UINT8 *src    = state->memregion("user2")->base();
1061
1071
        int x;
1062
1072
 
1063
1073
        /* expand 4bpp roms to 8bpp space */
1069
1079
                dst[x+2] = (src[x+1]&0x0f) >> 0;
1070
1080
        }
1071
1081
 
1072
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x6626c, 0x6626f, FUNC(spotty_speedup_r) );
 
1082
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x6626c, 0x6626f, read32_delegate(FUNC(limenko_state::spotty_speedup_r), state));
1073
1083
 
1074
1084
        state->m_spriteram_bit = 1;
1075
1085
}