← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/drivers/tapatune.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/tapatune.c
39
39
{
40
40
public:
41
41
        tapatune_state(const machine_config &mconfig, device_type type, const char *tag)
42
 
                : driver_device(mconfig, type, tag) {}
 
42
                : driver_device(mconfig, type, tag),
 
43
                  m_videoram(*this, "videoram") {}
43
44
 
44
45
        UINT8   m_paletteram[0x300];
45
46
        UINT16  m_palette_write_address;
46
47
        rgb_t   m_pens[0x100];
47
48
 
48
 
        UINT16  *m_videoram;
 
49
        required_shared_ptr<UINT16> m_videoram;
49
50
 
50
51
        UINT8   m_controls_mux;
51
52
        UINT8   m_z80_to_68k_index;
55
56
        UINT8   m_68k_to_z80_data;
56
57
 
57
58
        UINT16  m_bsmt_data;
 
59
        DECLARE_WRITE16_MEMBER(palette_w);
 
60
        DECLARE_READ16_MEMBER(read_from_z80);
 
61
        DECLARE_WRITE16_MEMBER(write_to_z80);
 
62
        DECLARE_READ16_MEMBER(irq_ack_r);
 
63
        DECLARE_READ8_MEMBER(sound_irq_clear);
 
64
        DECLARE_WRITE8_MEMBER(controls_mux);
 
65
        DECLARE_READ8_MEMBER(controls_r);
 
66
        DECLARE_WRITE8_MEMBER(write_index_to_68k);
 
67
        DECLARE_WRITE8_MEMBER(write_data_to_68k);
 
68
        DECLARE_READ8_MEMBER(read_index_from_68k);
 
69
        DECLARE_READ8_MEMBER(read_data_from_68k);
 
70
        DECLARE_READ8_MEMBER(bsmt_status_r);
 
71
        DECLARE_WRITE8_MEMBER(bsmt_data_lo_w);
 
72
        DECLARE_WRITE8_MEMBER(bsmt_data_hi_w);
 
73
        DECLARE_WRITE8_MEMBER(bsmt_reg_w);
58
74
};
59
75
 
60
 
static WRITE16_HANDLER(palette_w)
 
76
WRITE16_MEMBER(tapatune_state::palette_w)
61
77
{
62
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
63
78
 
64
79
        //logerror("Palette write: offset = %02x, data = %04x, mask = %04x\n", offset, data, mem_mask );
65
80
        switch(offset)
66
81
        {
67
82
                case 0: // address register
68
 
                        state->m_palette_write_address = ((data >> 8) & 0xff) * 3;
 
83
                        m_palette_write_address = ((data >> 8) & 0xff) * 3;
69
84
                        break;
70
85
                case 1: // palette data
71
 
                        state->m_paletteram[state->m_palette_write_address++] = (data >> 8) & 0xff;
 
86
                        m_paletteram[m_palette_write_address++] = (data >> 8) & 0xff;
72
87
                        break;
73
88
                case 2: // unknown?
74
89
                        break;
75
90
        }
76
91
}
77
92
 
78
 
static READ16_HANDLER(read_from_z80)
 
93
READ16_MEMBER(tapatune_state::read_from_z80)
79
94
{
80
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
81
95
 
82
 
        //logerror("Reading data from Z80: index = %02x, data = %02x\n", state->m_z80_to_68k_index, state->m_z80_to_68k_data );
 
96
        //logerror("Reading data from Z80: index = %02x, data = %02x\n", m_z80_to_68k_index, m_z80_to_68k_data );
83
97
 
84
98
        switch( offset )
85
99
        {
86
100
                case 0:
87
 
                        return ((UINT16)state->m_z80_to_68k_data << 8) | (state->m_z80_to_68k_index);
 
101
                        return ((UINT16)m_z80_to_68k_data << 8) | (m_z80_to_68k_index);
88
102
                default:
89
103
                        return 0;
90
104
        }
91
105
}
92
106
 
93
 
static WRITE16_HANDLER(write_to_z80)
 
107
WRITE16_MEMBER(tapatune_state::write_to_z80)
94
108
{
95
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
96
109
 
97
110
        switch( offset )
98
111
        {
99
112
                case 0:
100
113
                        //if ( (data >> 8) & 0xff )
101
114
                        //  logerror("Command to Z80: %04x\n", data);
102
 
                        state->m_68k_to_z80_index = data & 0xff;
103
 
                        state->m_68k_to_z80_data = (data >> 8) & 0xff;
104
 
                        cputag_set_input_line(space->machine(), "maincpu", 3, CLEAR_LINE);
 
115
                        m_68k_to_z80_index = data & 0xff;
 
116
                        m_68k_to_z80_data = (data >> 8) & 0xff;
 
117
                        cputag_set_input_line(machine(), "maincpu", 3, CLEAR_LINE);
105
118
                        break;
106
119
                case 1:
107
120
                        break;
108
121
        }
109
122
}
110
123
 
111
 
static READ16_HANDLER(irq_ack_r)
 
124
READ16_MEMBER(tapatune_state::irq_ack_r)
112
125
{
113
 
        cputag_set_input_line(space->machine(), "maincpu", 2, CLEAR_LINE);
 
126
        cputag_set_input_line(machine(), "maincpu", 2, CLEAR_LINE);
114
127
        return 0;
115
128
}
116
129
 
117
 
static ADDRESS_MAP_START( tapatune_map, AS_PROGRAM, 16 )
 
130
static ADDRESS_MAP_START( tapatune_map, AS_PROGRAM, 16, tapatune_state )
118
131
        AM_RANGE(0x000000, 0x2fffff) AM_ROM // program rom and graphics roms
119
 
        AM_RANGE(0x300000, 0x31ffff) AM_RAM AM_BASE_MEMBER(tapatune_state, m_videoram) // hardware video buffer
 
132
        AM_RANGE(0x300000, 0x31ffff) AM_RAM AM_SHARE("videoram") // hardware video buffer
120
133
        AM_RANGE(0x320000, 0x327fff) AM_RAM // workram
121
134
        AM_RANGE(0x328000, 0x32ffff) AM_RAM
122
135
        AM_RANGE(0x330000, 0x337fff) AM_RAM // ram used as system video buffer
124
137
        AM_RANGE(0x400000, 0x400003) AM_READWRITE(read_from_z80, write_to_z80)
125
138
        AM_RANGE(0x400010, 0x400011) AM_READ(irq_ack_r)
126
139
        AM_RANGE(0x600000, 0x600005) AM_WRITE(palette_w)
127
 
        AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8_MODERN("crtc", mc6845_device, address_w, 0xff00)
128
 
        AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, register_r, register_w, 0xff00)
 
140
        AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8("crtc", mc6845_device, address_w, 0xff00)
 
141
        AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
129
142
ADDRESS_MAP_END
130
143
 
131
 
static READ8_HANDLER(sound_irq_clear)
 
144
READ8_MEMBER(tapatune_state::sound_irq_clear)
132
145
{
133
 
        cputag_set_input_line(space->machine(), "soundcpu", 0, CLEAR_LINE);
 
146
        cputag_set_input_line(machine(), "soundcpu", 0, CLEAR_LINE);
134
147
        return 0;
135
148
}
136
149
 
137
 
static WRITE8_HANDLER(controls_mux)
 
150
WRITE8_MEMBER(tapatune_state::controls_mux)
138
151
{
139
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
140
152
        //logerror("Controls mux written with %02x\n", data);
141
 
        state->m_controls_mux = data;
 
153
        m_controls_mux = data;
142
154
}
143
155
 
144
 
static READ8_HANDLER(controls_r)
 
156
READ8_MEMBER(tapatune_state::controls_r)
145
157
{
146
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
147
 
        switch( state->m_controls_mux )
 
158
        switch( m_controls_mux )
148
159
        {
149
 
                case 0x07: return input_port_read(space->machine(), "DSW1");
150
 
                case 0x08: return input_port_read(space->machine(), "DSW2");
151
 
                case 0x09: return input_port_read(space->machine(), "IN0");
 
160
                case 0x07: return ioport("DSW1")->read();
 
161
                case 0x08: return ioport("DSW2")->read();
 
162
                case 0x09: return ioport("IN0")->read();
152
163
                default: return 0xff;
153
164
        }
154
165
}
155
166
 
156
 
static WRITE8_HANDLER(write_index_to_68k)
157
 
{
158
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
159
 
        state->m_z80_to_68k_index = data;
160
 
}
161
 
 
162
 
static WRITE8_HANDLER(write_data_to_68k)
163
 
{
164
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
165
 
        state->m_z80_to_68k_data = data;
166
 
        //logerror("Writing data from Z80: index = %02x, data = %02x\n", state->m_z80_to_68k_index, state->m_z80_to_68k_data );
167
 
        cputag_set_input_line(space->machine(), "maincpu", 3, ASSERT_LINE);
168
 
}
169
 
 
170
 
static READ8_HANDLER(read_index_from_68k)
171
 
{
172
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
173
 
        return state->m_68k_to_z80_index;
174
 
}
175
 
 
176
 
static READ8_HANDLER(read_data_from_68k)
177
 
{
178
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
179
 
        //if ( state->m_68k_to_z80_data != 0 )
180
 
        //  logerror("Load command from 68K: %02x %02x\n", state->m_68k_to_z80_index, state->m_68k_to_z80_data);
181
 
        return state->m_68k_to_z80_data;
182
 
}
183
 
 
184
 
static READ8_HANDLER(bsmt_status_r)
185
 
{
186
 
        bsmt2000_device *bsmt = space->machine().device<bsmt2000_device>("bsmt");
 
167
WRITE8_MEMBER(tapatune_state::write_index_to_68k)
 
168
{
 
169
        m_z80_to_68k_index = data;
 
170
}
 
171
 
 
172
WRITE8_MEMBER(tapatune_state::write_data_to_68k)
 
173
{
 
174
        m_z80_to_68k_data = data;
 
175
        //logerror("Writing data from Z80: index = %02x, data = %02x\n", m_z80_to_68k_index, m_z80_to_68k_data );
 
176
        cputag_set_input_line(machine(), "maincpu", 3, ASSERT_LINE);
 
177
}
 
178
 
 
179
READ8_MEMBER(tapatune_state::read_index_from_68k)
 
180
{
 
181
        return m_68k_to_z80_index;
 
182
}
 
183
 
 
184
READ8_MEMBER(tapatune_state::read_data_from_68k)
 
185
{
 
186
        //if ( m_68k_to_z80_data != 0 )
 
187
        //  logerror("Load command from 68K: %02x %02x\n", m_68k_to_z80_index, m_68k_to_z80_data);
 
188
        return m_68k_to_z80_data;
 
189
}
 
190
 
 
191
READ8_MEMBER(tapatune_state::bsmt_status_r)
 
192
{
 
193
        bsmt2000_device *bsmt = machine().device<bsmt2000_device>("bsmt");
187
194
        return (bsmt->read_status() << 7) ^ 0x80;
188
195
}
189
196
 
190
 
static WRITE8_HANDLER(bsmt_data_lo_w)
191
 
{
192
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
193
 
        state->m_bsmt_data = (state->m_bsmt_data & 0xff00) | data;
194
 
}
195
 
 
196
 
static WRITE8_HANDLER(bsmt_data_hi_w)
197
 
{
198
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
199
 
        state->m_bsmt_data = (state->m_bsmt_data & 0x00ff) | (data << 8);
200
 
}
201
 
 
202
 
static WRITE8_HANDLER(bsmt_reg_w)
203
 
{
204
 
        bsmt2000_device *bsmt = space->machine().device<bsmt2000_device>("bsmt");
205
 
        tapatune_state *state = space->machine().driver_data<tapatune_state>();
206
 
 
207
 
        //logerror("Writing BSMT reg: %02X data: %04X\n", data, state->m_bsmt_data);
 
197
WRITE8_MEMBER(tapatune_state::bsmt_data_lo_w)
 
198
{
 
199
        m_bsmt_data = (m_bsmt_data & 0xff00) | data;
 
200
}
 
201
 
 
202
WRITE8_MEMBER(tapatune_state::bsmt_data_hi_w)
 
203
{
 
204
        m_bsmt_data = (m_bsmt_data & 0x00ff) | (data << 8);
 
205
}
 
206
 
 
207
WRITE8_MEMBER(tapatune_state::bsmt_reg_w)
 
208
{
 
209
        bsmt2000_device *bsmt = machine().device<bsmt2000_device>("bsmt");
 
210
 
 
211
 
 
212
        //logerror("Writing BSMT reg: %02X data: %04X\n", data, m_bsmt_data);
208
213
        bsmt->write_reg(data);
209
 
        bsmt->write_data(state->m_bsmt_data);
 
214
        bsmt->write_data(m_bsmt_data);
210
215
}
211
216
 
212
 
static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 8 )
 
217
static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 8, tapatune_state )
213
218
        AM_RANGE(0x0000, 0x7fff) AM_ROM AM_WRITENOP
214
219
        AM_RANGE(0xe000, 0xefff) AM_RAM
215
220
        AM_RANGE(0xf000, 0xffff) AM_RAM
216
221
ADDRESS_MAP_END
217
222
 
218
 
static ADDRESS_MAP_START ( sound_io_map, AS_IO, 8)
 
223
static ADDRESS_MAP_START ( sound_io_map, AS_IO, 8, tapatune_state )
219
224
        ADDRESS_MAP_GLOBAL_MASK(0xff)
220
225
        AM_RANGE(0x00, 0x00) AM_WRITE(bsmt_data_lo_w)
221
226
        AM_RANGE(0x08, 0x08) AM_WRITE(bsmt_data_hi_w)
281
286
        PORT_START("COINS")
282
287
        PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_COIN1 ) PORT_IMPULSE(1)
283
288
        PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_COIN2 ) PORT_IMPULSE(1)
284
 
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SPECIAL ) PORT_READ_LINE_DEVICE("ticket", ticket_dispenser_line_r)
 
289
        PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SPECIAL ) PORT_READ_LINE_DEVICE_MEMBER("ticket", ticket_dispenser_device, line_r)
285
290
        PORT_BIT( 0xf8, IP_ACTIVE_LOW, IPT_UNUSED )
286
291
 
287
292
        PORT_START("BUTTONS")
337
342
 
338
343
        offs_t offs = (ma*2 + ra*0x40)*4;
339
344
 
 
345
        UINT8 *videoram = reinterpret_cast<UINT8 *>(state->m_videoram.target());
340
346
        for (x = 0; x < x_count*4; x++)
341
347
        {
342
 
                UINT8 pix = ((UINT8*)state->m_videoram)[BYTE_XOR_BE(offs + x)];
 
348
                UINT8 pix = videoram[BYTE_XOR_BE(offs + x)];
343
349
                dest[2*x] = pens[((pix >> 4) & 0x0f)];
344
350
                dest[2*x + 1] = pens[(pix & 0x0f)];
345
351
        }
393
399
 
394
400
        MCFG_MC6845_ADD("crtc", H46505, 24000000/16, h46505_intf)       /* H46505 */
395
401
 
396
 
        MCFG_TICKET_DISPENSER_ADD("ticket", 100, TICKET_MOTOR_ACTIVE_LOW, TICKET_STATUS_ACTIVE_LOW)
 
402
        MCFG_TICKET_DISPENSER_ADD("ticket", attotime::from_msec(100), TICKET_MOTOR_ACTIVE_LOW, TICKET_STATUS_ACTIVE_LOW)
397
403
 
398
404
        /* sound hardware */
399
405
        MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")