← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/machine/flstory.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/machine/flstory.c
20
20
 
21
21
***************************************************************************/
22
22
 
23
 
READ8_HANDLER( flstory_68705_port_a_r )
24
 
{
25
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
26
 
 
27
 
        //logerror("%04x: 68705 port A read %02x\n", cpu_get_pc(&space->device()), state->m_port_a_in);
28
 
        return (state->m_port_a_out & state->m_ddr_a) | (state->m_port_a_in & ~state->m_ddr_a);
29
 
}
30
 
 
31
 
WRITE8_HANDLER( flstory_68705_port_a_w )
32
 
{
33
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
34
 
 
35
 
        //logerror("%04x: 68705 port A write %02x\n", cpu_get_pc(&space->device()), data);
36
 
        state->m_port_a_out = data;
37
 
}
38
 
 
39
 
WRITE8_HANDLER( flstory_68705_ddr_a_w )
40
 
{
41
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
42
 
        state->m_ddr_a = data;
 
23
READ8_MEMBER(flstory_state::flstory_68705_port_a_r)
 
24
{
 
25
 
 
26
        //logerror("%04x: 68705 port A read %02x\n", cpu_get_pc(&space.device()), m_port_a_in);
 
27
        return (m_port_a_out & m_ddr_a) | (m_port_a_in & ~m_ddr_a);
 
28
}
 
29
 
 
30
WRITE8_MEMBER(flstory_state::flstory_68705_port_a_w)
 
31
{
 
32
 
 
33
        //logerror("%04x: 68705 port A write %02x\n", cpu_get_pc(&space.device()), data);
 
34
        m_port_a_out = data;
 
35
}
 
36
 
 
37
WRITE8_MEMBER(flstory_state::flstory_68705_ddr_a_w)
 
38
{
 
39
        m_ddr_a = data;
43
40
}
44
41
 
45
42
 
53
50
 *  2   W  when 0->1, copies port A to the latch for the main CPU
54
51
 */
55
52
 
56
 
READ8_HANDLER( flstory_68705_port_b_r )
57
 
{
58
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
59
 
        return (state->m_port_b_out & state->m_ddr_b) | (state->m_port_b_in & ~state->m_ddr_b);
60
 
}
61
 
 
62
 
WRITE8_HANDLER( flstory_68705_port_b_w )
63
 
{
64
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
65
 
        //logerror("%04x: 68705 port B write %02x\n",cpu_get_pc(&space->device()),data);
66
 
 
67
 
        if ((state->m_ddr_b & 0x02) && (~data & 0x02) && (state->m_port_b_out & 0x02))
68
 
        {
69
 
                state->m_port_a_in = state->m_from_main;
70
 
                if (state->m_main_sent)
71
 
                        device_set_input_line(state->m_mcu, 0, CLEAR_LINE);
72
 
                state->m_main_sent = 0;
73
 
                logerror("read command %02x from main cpu\n", state->m_port_a_in);
74
 
        }
75
 
        if ((state->m_ddr_b & 0x04) && (data & 0x04) && (~state->m_port_b_out & 0x04))
76
 
        {
77
 
                logerror("send command %02x to main cpu\n", state->m_port_a_out);
78
 
                state->m_from_mcu = state->m_port_a_out;
79
 
                state->m_mcu_sent = 1;
80
 
        }
81
 
 
82
 
        state->m_port_b_out = data;
83
 
}
84
 
 
85
 
WRITE8_HANDLER( flstory_68705_ddr_b_w )
86
 
{
87
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
88
 
        state->m_ddr_b = data;
89
 
}
90
 
 
91
 
 
92
 
READ8_HANDLER( flstory_68705_port_c_r )
93
 
{
94
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
95
 
 
96
 
        state->m_port_c_in = 0;
97
 
        if (state->m_main_sent)
98
 
                state->m_port_c_in |= 0x01;
99
 
 
100
 
        if (!state->m_mcu_sent)
101
 
                state->m_port_c_in |= 0x02;
102
 
 
103
 
        //logerror("%04x: 68705 port C read %02x\n", cpu_get_pc(&space->device()), port_c_in);
104
 
        return (state->m_port_c_out & state->m_ddr_c) | (state->m_port_c_in & ~state->m_ddr_c);
105
 
}
106
 
 
107
 
WRITE8_HANDLER( flstory_68705_port_c_w )
108
 
{
109
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
110
 
        logerror("%04x: 68705 port C write %02x\n", cpu_get_pc(&space->device()), data);
111
 
        state->m_port_c_out = data;
112
 
}
113
 
 
114
 
WRITE8_HANDLER( flstory_68705_ddr_c_w )
115
 
{
116
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
117
 
        state->m_ddr_c = data;
118
 
}
119
 
 
120
 
WRITE8_HANDLER( flstory_mcu_w )
121
 
{
122
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
123
 
 
124
 
        logerror("%04x: mcu_w %02x\n", cpu_get_pc(&space->device()), data);
125
 
        state->m_from_main = data;
126
 
        state->m_main_sent = 1;
127
 
        device_set_input_line(state->m_mcu, 0, ASSERT_LINE);
128
 
}
129
 
 
130
 
READ8_HANDLER( flstory_mcu_r )
131
 
{
132
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
133
 
 
134
 
        logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space->device()), state->m_from_mcu);
135
 
        state->m_mcu_sent = 0;
136
 
        return state->m_from_mcu;
137
 
}
138
 
 
139
 
READ8_HANDLER( flstory_mcu_status_r )
140
 
{
141
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
 
53
READ8_MEMBER(flstory_state::flstory_68705_port_b_r)
 
54
{
 
55
        return (m_port_b_out & m_ddr_b) | (m_port_b_in & ~m_ddr_b);
 
56
}
 
57
 
 
58
WRITE8_MEMBER(flstory_state::flstory_68705_port_b_w)
 
59
{
 
60
        //logerror("%04x: 68705 port B write %02x\n",cpu_get_pc(&space.device()),data);
 
61
 
 
62
        if ((m_ddr_b & 0x02) && (~data & 0x02) && (m_port_b_out & 0x02))
 
63
        {
 
64
                m_port_a_in = m_from_main;
 
65
                if (m_main_sent)
 
66
                        device_set_input_line(m_mcu, 0, CLEAR_LINE);
 
67
                m_main_sent = 0;
 
68
                logerror("read command %02x from main cpu\n", m_port_a_in);
 
69
        }
 
70
        if ((m_ddr_b & 0x04) && (data & 0x04) && (~m_port_b_out & 0x04))
 
71
        {
 
72
                logerror("send command %02x to main cpu\n", m_port_a_out);
 
73
                m_from_mcu = m_port_a_out;
 
74
                m_mcu_sent = 1;
 
75
        }
 
76
 
 
77
        m_port_b_out = data;
 
78
}
 
79
 
 
80
WRITE8_MEMBER(flstory_state::flstory_68705_ddr_b_w)
 
81
{
 
82
        m_ddr_b = data;
 
83
}
 
84
 
 
85
 
 
86
READ8_MEMBER(flstory_state::flstory_68705_port_c_r)
 
87
{
 
88
 
 
89
        m_port_c_in = 0;
 
90
        if (m_main_sent)
 
91
                m_port_c_in |= 0x01;
 
92
 
 
93
        if (!m_mcu_sent)
 
94
                m_port_c_in |= 0x02;
 
95
 
 
96
        //logerror("%04x: 68705 port C read %02x\n", cpu_get_pc(&space.device()), port_c_in);
 
97
        return (m_port_c_out & m_ddr_c) | (m_port_c_in & ~m_ddr_c);
 
98
}
 
99
 
 
100
WRITE8_MEMBER(flstory_state::flstory_68705_port_c_w)
 
101
{
 
102
        logerror("%04x: 68705 port C write %02x\n", cpu_get_pc(&space.device()), data);
 
103
        m_port_c_out = data;
 
104
}
 
105
 
 
106
WRITE8_MEMBER(flstory_state::flstory_68705_ddr_c_w)
 
107
{
 
108
        m_ddr_c = data;
 
109
}
 
110
 
 
111
WRITE8_MEMBER(flstory_state::flstory_mcu_w)
 
112
{
 
113
 
 
114
        logerror("%04x: mcu_w %02x\n", cpu_get_pc(&space.device()), data);
 
115
        m_from_main = data;
 
116
        m_main_sent = 1;
 
117
        device_set_input_line(m_mcu, 0, ASSERT_LINE);
 
118
}
 
119
 
 
120
READ8_MEMBER(flstory_state::flstory_mcu_r)
 
121
{
 
122
 
 
123
        logerror("%04x: mcu_r %02x\n",cpu_get_pc(&space.device()), m_from_mcu);
 
124
        m_mcu_sent = 0;
 
125
        return m_from_mcu;
 
126
}
 
127
 
 
128
READ8_MEMBER(flstory_state::flstory_mcu_status_r)
 
129
{
142
130
        int res = 0;
143
131
 
144
132
        /* bit 0 = when 1, mcu is ready to receive data from main cpu */
145
133
        /* bit 1 = when 1, mcu has sent data to the main cpu */
146
 
        //logerror("%04x: mcu_status_r\n", cpu_get_pc(&space->device()));
147
 
        if (!state->m_main_sent)
 
134
        //logerror("%04x: mcu_status_r\n", cpu_get_pc(&space.device()));
 
135
        if (!m_main_sent)
148
136
                res |= 0x01;
149
 
        if (state->m_mcu_sent)
 
137
        if (m_mcu_sent)
150
138
                res |= 0x02;
151
139
 
152
140
        return res;
153
141
}
154
142
 
155
 
WRITE8_HANDLER( onna34ro_mcu_w )
 
143
WRITE8_MEMBER(flstory_state::onna34ro_mcu_w)
156
144
{
157
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
158
 
        UINT16 score_adr = state->m_workram[0x29e] * 0x100 + state->m_workram[0x29d];
 
145
        UINT16 score_adr = m_workram[0x29e] * 0x100 + m_workram[0x29d];
159
146
 
160
147
        switch (data)
161
148
        {
162
149
                case 0x0e:
163
 
                        state->m_from_mcu = 0xff;
 
150
                        m_from_mcu = 0xff;
164
151
                        break;
165
152
                case 0x01:
166
 
                        state->m_from_mcu = 0x6a;
 
153
                        m_from_mcu = 0x6a;
167
154
                        break;
168
155
                case 0x40:
169
156
                        if(score_adr >= 0xe000 && score_adr < 0xe800)
170
 
                                state->m_from_mcu = state->m_workram[score_adr - 0xe000];                       /* score l*/
 
157
                                m_from_mcu = m_workram[score_adr - 0xe000];                     /* score l*/
171
158
                        break;
172
159
                case 0x41:
173
160
                        if(score_adr >= 0xe000 && score_adr < 0xe800)
174
 
                                state->m_from_mcu = state->m_workram[(score_adr + 1) - 0xe000];         /* score m*/
 
161
                                m_from_mcu = m_workram[(score_adr + 1) - 0xe000];               /* score m*/
175
162
                        break;
176
163
                case 0x42:
177
164
                        if(score_adr >= 0xe000 && score_adr < 0xe800)
178
 
                                state->m_from_mcu = state->m_workram[(score_adr + 2) - 0xe000] & 0x0f;  /* score h*/
 
165
                                m_from_mcu = m_workram[(score_adr + 2) - 0xe000] & 0x0f;        /* score h*/
179
166
                        break;
180
167
                default:
181
 
                        state->m_from_mcu = 0x80;
 
168
                        m_from_mcu = 0x80;
182
169
        }
183
170
}
184
171
 
185
 
READ8_HANDLER( onna34ro_mcu_r )
 
172
READ8_MEMBER(flstory_state::onna34ro_mcu_r)
186
173
{
187
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
188
 
        return state->m_from_mcu;
 
174
        return m_from_mcu;
189
175
}
190
176
 
191
 
READ8_HANDLER( onna34ro_mcu_status_r )
 
177
READ8_MEMBER(flstory_state::onna34ro_mcu_status_r)
192
178
{
193
179
        int res = 3;
194
180
 
196
182
}
197
183
 
198
184
 
199
 
#define VICTNINE_MCU_SEED       (state->m_workram[0x685])
 
185
#define VICTNINE_MCU_SEED       (m_workram[0x685])
200
186
 
201
187
static const UINT8 victnine_mcu_data[0x100] =
202
188
{
234
220
        0x06, 0x07, 0x02, 0x03, 0x15, 0x17, 0x11, 0x13
235
221
};
236
222
 
237
 
WRITE8_HANDLER( victnine_mcu_w )
 
223
WRITE8_MEMBER(flstory_state::victnine_mcu_w)
238
224
{
239
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
240
225
        UINT8 seed = VICTNINE_MCU_SEED;
241
226
 
242
227
        if (!seed && (data & 0x37) == 0x37)
243
228
        {
244
 
                state->m_from_mcu = 0xa6;
 
229
                m_from_mcu = 0xa6;
245
230
                logerror("mcu initialize (%02x)\n", data);
246
231
        }
247
232
        else
250
235
 
251
236
                if ((data & ~0x1f) == 0xa0)
252
237
                {
253
 
                        state->m_mcu_select = data & 0x1f;
254
 
                        //logerror("mcu select: 0x%02x\n", state->m_mcu_select);
 
238
                        m_mcu_select = data & 0x1f;
 
239
                        //logerror("mcu select: 0x%02x\n", m_mcu_select);
255
240
                }
256
241
                else if (data < 0x20)
257
242
                {
258
 
                        int offset = state->m_mcu_select * 8 + data;
 
243
                        int offset = m_mcu_select * 8 + data;
259
244
 
260
245
                        //logerror("mcu fetch: 0x%02x\n", offset);
261
 
                        state->m_from_mcu = victnine_mcu_data[offset];
 
246
                        m_from_mcu = victnine_mcu_data[offset];
262
247
                }
263
248
                else if (data >= 0x38 && data <= 0x3a)
264
249
                {
265
 
                        state->m_from_mcu = state->m_workram[0x691 - 0x38 + data];
 
250
                        m_from_mcu = m_workram[0x691 - 0x38 + data];
266
251
                }
267
252
                else
268
253
                {
271
256
        }
272
257
}
273
258
 
274
 
READ8_HANDLER( victnine_mcu_r )
 
259
READ8_MEMBER(flstory_state::victnine_mcu_r)
275
260
{
276
 
        flstory_state *state = space->machine().driver_data<flstory_state>();
277
 
        //logerror("%04x: mcu read (0x%02x)\n", cpu_get_previouspc(&space->device()), state->m_from_mcu);
 
261
        //logerror("%04x: mcu read (0x%02x)\n", cpu_get_previouspc(&space.device()), m_from_mcu);
278
262
 
279
 
        return state->m_from_mcu - VICTNINE_MCU_SEED;
 
263
        return m_from_mcu - VICTNINE_MCU_SEED;
280
264
}
281
265
 
282
 
READ8_HANDLER( victnine_mcu_status_r )
 
266
READ8_MEMBER(flstory_state::victnine_mcu_status_r)
283
267
{
284
268
        int res = 3;
285
269