← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/machine/3do.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/3do.c
61
61
 
62
62
 
63
63
 
64
 
READ32_HANDLER( _3do_nvarea_r ) {
65
 
        logerror( "%08X: NVRAM read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset );
 
64
READ32_MEMBER(_3do_state::_3do_nvarea_r){
 
65
        logerror( "%08X: NVRAM read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset );
66
66
        return 0;
67
67
}
68
68
 
69
 
WRITE32_HANDLER( _3do_nvarea_w ) {
70
 
        logerror( "%08X: NVRAM write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset, data, mem_mask );
 
69
WRITE32_MEMBER(_3do_state::_3do_nvarea_w){
 
70
        logerror( "%08X: NVRAM write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset, data, mem_mask );
71
71
}
72
72
 
73
73
 
97
97
3022630
98
98
*/
99
99
 
100
 
READ32_HANDLER( _3do_slow2_r ) {
101
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
 
100
READ32_MEMBER(_3do_state::_3do_slow2_r){
102
101
        UINT32 data = 0;
103
102
 
104
 
        logerror( "%08X: UNK_318 read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset );
 
103
        logerror( "%08X: UNK_318 read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset );
105
104
 
106
105
        switch( offset ) {
107
106
        case 0:         /* Boot ROM checks here and expects to read 1, 0, 1, 0 in the lowest bit */
108
 
                data = state->m_slow2.cg_output & 0x00000001;
109
 
                state->m_slow2.cg_output = state->m_slow2.cg_output >> 1;
110
 
                state->m_slow2.cg_w_count = 0;
 
107
                data = m_slow2.cg_output & 0x00000001;
 
108
                m_slow2.cg_output = m_slow2.cg_output >> 1;
 
109
                m_slow2.cg_w_count = 0;
111
110
        }
112
111
        return data;
113
112
}
114
113
 
115
114
 
116
 
WRITE32_HANDLER( _3do_slow2_w )
 
115
WRITE32_MEMBER(_3do_state::_3do_slow2_w)
117
116
{
118
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
119
 
        logerror( "%08X: UNK_318 write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset, data, mem_mask );
 
117
        logerror( "%08X: UNK_318 write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset, data, mem_mask );
120
118
 
121
119
        switch( offset )
122
120
        {
123
121
                case 0:         /* Boot ROM writes 03180000 here and then starts reading some things */
124
122
                {
125
123
                        /* disable ROM overlay */
126
 
                        memory_set_bank(space->machine(), "bank1", 0);
 
124
                        membank("bank1")->set_entry(0);
127
125
                }
128
 
                state->m_slow2.cg_input = state->m_slow2.cg_input << 1 | ( data & 0x00000001 );
129
 
                state->m_slow2.cg_w_count ++;
130
 
                if ( state->m_slow2.cg_w_count == 16 )
 
126
                m_slow2.cg_input = m_slow2.cg_input << 1 | ( data & 0x00000001 );
 
127
                m_slow2.cg_w_count ++;
 
128
                if ( m_slow2.cg_w_count == 16 )
131
129
                {
132
130
                }
133
131
                break;
143
141
}
144
142
 
145
143
 
146
 
READ32_HANDLER( _3do_svf_r )
 
144
READ32_MEMBER(_3do_state::_3do_svf_r)
147
145
{
148
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
149
146
        UINT32 addr = ( offset & ( 0x07fc / 4 ) ) << 9;
150
 
        UINT32 *p = state->m_vram + addr;
 
147
        UINT32 *p = m_vram + addr;
151
148
 
152
 
        logerror( "%08X: SVF read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4 );
 
149
        logerror( "%08X: SVF read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4 );
153
150
 
154
151
        switch( offset & ( 0xE000 / 4 ) )
155
152
        {
156
153
        case 0x0000/4:          /* SPORT transfer */
157
154
                for ( int i = 0; i < 512; i++ )
158
155
                {
159
 
                        state->m_svf.sport[i] = p[i];
 
156
                        m_svf.sport[i] = p[i];
160
157
                }
161
158
                break;
162
159
        case 0x2000/4:          /* Write to color register */
163
 
                return state->m_svf.color;
 
160
                return m_svf.color;
164
161
        case 0x4000/4:          /* Flash write */
165
162
                break;
166
163
        case 0x6000/4:          /* CAS before RAS refresh/reset (CBR). Used to initialize VRAM mode during boot. */
169
166
        return 0;
170
167
}
171
168
 
172
 
WRITE32_HANDLER( _3do_svf_w )
 
169
WRITE32_MEMBER(_3do_state::_3do_svf_w)
173
170
{
174
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
175
171
        UINT32 addr = ( offset & ( 0x07fc / 4 ) ) << 9;
176
 
        UINT32 *p = state->m_vram + addr;
 
172
        UINT32 *p = m_vram + addr;
177
173
 
178
 
        logerror( "%08X: SVF write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4, data, mem_mask );
 
174
        logerror( "%08X: SVF write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4, data, mem_mask );
179
175
 
180
176
        switch( offset & ( 0xe000 / 4 ) )
181
177
        {
185
181
 
186
182
                        for ( int i = 0; i < 512; i++ )
187
183
                        {
188
 
                                p[i] = ( p[i] & keep_bits ) | ( state->m_svf.sport[i] & data );
 
184
                                p[i] = ( p[i] & keep_bits ) | ( m_svf.sport[i] & data );
189
185
                        }
190
186
                }
191
187
                break;
192
188
        case 0x2000/4:          /* Write to color register */
193
 
                state->m_svf.color = data;
 
189
                m_svf.color = data;
194
190
                break;
195
191
        case 0x4000/4:          /* Flash write */
196
192
                {
197
193
                        UINT32 keep_bits = data ^ 0xffffffff;
198
 
                        UINT32 new_bits = state->m_svf.color & data;
 
194
                        UINT32 new_bits = m_svf.color & data;
199
195
 
200
196
                        for ( int i = 0; i < 512; i++ )
201
197
                        {
210
206
 
211
207
 
212
208
 
213
 
READ32_HANDLER( _3do_madam_r ) {
214
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
215
 
        logerror( "%08X: MADAM read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4 );
 
209
READ32_MEMBER(_3do_state::_3do_madam_r){
 
210
        logerror( "%08X: MADAM read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4 );
216
211
 
217
212
        switch( offset ) {
218
213
        case 0x0000/4:          /* 03300000 - Revision */
219
 
                return state->m_madam.revision;
 
214
                return m_madam.revision;
220
215
        case 0x0004/4:
221
 
                return state->m_madam.msysbits;
 
216
                return m_madam.msysbits;
222
217
        case 0x0008/4:
223
 
                return state->m_madam.mctl;
 
218
                return m_madam.mctl;
224
219
        case 0x000c/4:
225
 
                return state->m_madam.sltime;
 
220
                return m_madam.sltime;
226
221
        case 0x0020/4:
227
 
                return state->m_madam.abortbits;
 
222
                return m_madam.abortbits;
228
223
        case 0x0024/4:
229
 
                return state->m_madam.privbits;
 
224
                return m_madam.privbits;
230
225
        case 0x0028/4:
231
 
                return state->m_madam.statbits;
 
226
                return m_madam.statbits;
232
227
        case 0x0040/4:
233
 
                return state->m_madam.diag;
 
228
                return m_madam.diag;
234
229
        case 0x0110/4:
235
 
                return state->m_madam.ccobctl0;
 
230
                return m_madam.ccobctl0;
236
231
        case 0x0120/4:
237
 
                return state->m_madam.ppmpc;
 
232
                return m_madam.ppmpc;
238
233
        case 0x0130/4:
239
 
                return state->m_madam.regctl0;
 
234
                return m_madam.regctl0;
240
235
        case 0x0134/4:
241
 
                return state->m_madam.regctl1;
 
236
                return m_madam.regctl1;
242
237
        case 0x0138/4:
243
 
                return state->m_madam.regctl2;
 
238
                return m_madam.regctl2;
244
239
        case 0x013c/4:
245
 
                return state->m_madam.regctl3;
 
240
                return m_madam.regctl3;
246
241
        case 0x0140/4:
247
 
                return state->m_madam.xyposh;
 
242
                return m_madam.xyposh;
248
243
        case 0x0144/4:
249
 
                return state->m_madam.xyposl;
 
244
                return m_madam.xyposl;
250
245
        case 0x0148/4:
251
 
                return state->m_madam.linedxyh;
 
246
                return m_madam.linedxyh;
252
247
        case 0x014c/4:
253
 
                return state->m_madam.linedxyl;
 
248
                return m_madam.linedxyl;
254
249
        case 0x0150/4:
255
 
                return state->m_madam.dxyh;
 
250
                return m_madam.dxyh;
256
251
        case 0x0154/4:
257
 
                return state->m_madam.dxyl;
 
252
                return m_madam.dxyl;
258
253
        case 0x0158/4:
259
 
                return state->m_madam.ddxyh;
 
254
                return m_madam.ddxyh;
260
255
        case 0x015c/4:
261
 
                return state->m_madam.ddxyl;
 
256
                return m_madam.ddxyl;
262
257
        case 0x0180/4: case 0x0188/4:
263
258
        case 0x0190/4: case 0x0198/4:
264
259
        case 0x01a0/4: case 0x01a8/4:
267
262
        case 0x01d0/4: case 0x01d8/4:
268
263
        case 0x01e0/4: case 0x01e8/4:
269
264
        case 0x01f0/4: case 0x01f8/4:
270
 
                return state->m_madam.pip[(offset/2) & 0x0f] & 0xffff;
 
265
                return m_madam.pip[(offset/2) & 0x0f] & 0xffff;
271
266
        case 0x0184/4: case 0x018c/4:
272
267
        case 0x0194/4: case 0x019c/4:
273
268
        case 0x01a4/4: case 0x01ac/4:
276
271
        case 0x01d4/4: case 0x01dc/4:
277
272
        case 0x01e4/4: case 0x01ec/4:
278
273
        case 0x01f4/4: case 0x01fc/4:
279
 
                return state->m_madam.pip[(offset/2) & 0x0f] >> 16;
 
274
                return m_madam.pip[(offset/2) & 0x0f] >> 16;
280
275
        case 0x0200/4: case 0x0208/4:
281
276
        case 0x0210/4: case 0x0218/4:
282
277
        case 0x0220/4: case 0x0228/4:
285
280
        case 0x0250/4: case 0x0258/4:
286
281
        case 0x0260/4: case 0x0268/4:
287
282
        case 0x0270/4: case 0x0278/4:
288
 
                return state->m_madam.fence[(offset/2) & 0x0f] & 0xffff;
 
283
                return m_madam.fence[(offset/2) & 0x0f] & 0xffff;
289
284
        case 0x0204/4: case 0x020c/4:
290
285
        case 0x0214/4: case 0x021c/4:
291
286
        case 0x0224/4: case 0x022c/4:
294
289
        case 0x0254/4: case 0x025c/4:
295
290
        case 0x0264/4: case 0x026c/4:
296
291
        case 0x0274/4: case 0x027c/4:
297
 
                return state->m_madam.fence[(offset/2) & 0x0f] >> 16;
 
292
                return m_madam.fence[(offset/2) & 0x0f] >> 16;
298
293
        case 0x0300/4: case 0x0304/4: case 0x0308/4: case 0x030c/4:
299
294
        case 0x0310/4: case 0x0314/4: case 0x0318/4: case 0x031c/4:
300
295
        case 0x0320/4: case 0x0324/4: case 0x0328/4: case 0x032c/4:
311
306
        case 0x03d0/4: case 0x03d4/4: case 0x03d8/4: case 0x03dc/4:
312
307
        case 0x03e0/4: case 0x03e4/4: case 0x03e8/4: case 0x03ec/4:
313
308
        case 0x03f0/4: case 0x03f4/4: case 0x03f8/4: case 0x03fc/4:
314
 
                return state->m_madam.mmu[offset&0x3f];
 
309
                return m_madam.mmu[offset&0x3f];
315
310
        case 0x0400/4: case 0x0404/4: case 0x0408/4: case 0x040c/4:
316
311
        case 0x0410/4: case 0x0414/4: case 0x0418/4: case 0x041c/4:
317
312
        case 0x0420/4: case 0x0424/4: case 0x0428/4: case 0x042c/4:
344
339
        case 0x05d0/4: case 0x05d4/4: case 0x05d8/4: case 0x05dc/4:
345
340
        case 0x05e0/4: case 0x05e4/4: case 0x05e8/4: case 0x05ec/4:
346
341
        case 0x05f0/4: case 0x05f4/4: case 0x05f8/4: case 0x05fc/4:
347
 
                return state->m_madam.dma[(offset/4) & 0x1f][offset & 0x03];
 
342
                return m_madam.dma[(offset/4) & 0x1f][offset & 0x03];
348
343
 
349
344
        /* Hardware multiplier */
350
345
        case 0x0600/4: case 0x0604/4: case 0x0608/4: case 0x060c/4:
357
352
        case 0x0670/4: case 0x0674/4: case 0x0678/4: case 0x067c/4:
358
353
        case 0x0680/4: case 0x0684/4: case 0x0688/4: case 0x068c/4:
359
354
        case 0x0690/4: case 0x0694/4: case 0x0698/4: case 0x069c/4:
360
 
                return state->m_madam.mult[offset & 0x3f];
 
355
                return m_madam.mult[offset & 0x3f];
361
356
        case 0x07f0/4:
362
 
                return state->m_madam.mult_control;
 
357
                return m_madam.mult_control;
363
358
        case 0x07f8/4:
364
 
                return state->m_madam.mult_status;
 
359
                return m_madam.mult_status;
365
360
        default:
366
 
                logerror( "%08X: unhandled MADAM read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4 );
 
361
                logerror( "%08X: unhandled MADAM read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4 );
367
362
                break;
368
363
        }
369
364
        return 0;
370
365
}
371
366
 
372
367
 
373
 
WRITE32_HANDLER( _3do_madam_w ) {
374
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
375
 
        logerror( "%08X: MADAM write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4, data, mem_mask );
 
368
WRITE32_MEMBER(_3do_state::_3do_madam_w){
 
369
        logerror( "%08X: MADAM write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4, data, mem_mask );
376
370
 
377
371
        switch( offset ) {
378
372
        case 0x0000/4:
379
373
                break;
380
374
        case 0x0004/4:  /* 03300004 - Memory configuration 29 = 2MB DRAM, 1MB VRAM */
381
 
                state->m_madam.msysbits = data;
 
375
                m_madam.msysbits = data;
382
376
                break;
383
377
        case 0x0008/4:
384
 
                state->m_madam.mctl = data;
 
378
                m_madam.mctl = data;
385
379
                break;
386
380
        case 0x000c/4:
387
 
                state->m_madam.sltime = data;
 
381
                m_madam.sltime = data;
388
382
                break;
389
383
        case 0x0020/4:
390
 
                state->m_madam.abortbits = data;
 
384
                m_madam.abortbits = data;
391
385
                break;
392
386
        case 0x0024/4:
393
 
                state->m_madam.privbits = data;
 
387
                m_madam.privbits = data;
394
388
                break;
395
389
        case 0x0028/4:
396
 
                state->m_madam.statbits = data;
 
390
                m_madam.statbits = data;
397
391
        case 0x0040/4:
398
 
                state->m_madam.diag = 1;
 
392
                m_madam.diag = 1;
399
393
                break;
400
394
 
401
395
        /* CEL */
405
399
        case 0x010c/4:  /* 0330010c - SPRPAUS - Pause the the CEL engine (W) */
406
400
                break;
407
401
        case 0x0110/4:  /* 03300110 - CCOBCTL0 - CCoB control (RW) */
408
 
                state->m_madam.ccobctl0 = data;
 
402
                m_madam.ccobctl0 = data;
409
403
                break;
410
404
        case 0x0129/4:  /* 03300120 - PPMPC (RW) */
411
 
                state->m_madam.ppmpc = data;
 
405
                m_madam.ppmpc = data;
412
406
                break;
413
407
 
414
408
        /* Regis */
415
409
        case 0x0130/4:
416
 
                state->m_madam.regctl0 = data;
 
410
                m_madam.regctl0 = data;
417
411
                break;
418
412
        case 0x0134/4:
419
 
                state->m_madam.regctl1 = data;
 
413
                m_madam.regctl1 = data;
420
414
                break;
421
415
        case 0x0138/4:
422
 
                state->m_madam.regctl2 = data;
 
416
                m_madam.regctl2 = data;
423
417
                break;
424
418
        case 0x013c/4:
425
 
                state->m_madam.regctl3 = data;
 
419
                m_madam.regctl3 = data;
426
420
                break;
427
421
        case 0x0140/4:
428
 
                state->m_madam.xyposh = data;
 
422
                m_madam.xyposh = data;
429
423
                break;
430
424
        case 0x0144/4:
431
 
                state->m_madam.xyposl = data;
 
425
                m_madam.xyposl = data;
432
426
                break;
433
427
        case 0x0148/4:
434
 
                state->m_madam.linedxyh = data;
 
428
                m_madam.linedxyh = data;
435
429
                break;
436
430
        case 0x014c/4:
437
 
                state->m_madam.linedxyl = data;
 
431
                m_madam.linedxyl = data;
438
432
                break;
439
433
        case 0x0150/4:
440
 
                state->m_madam.dxyh = data;
 
434
                m_madam.dxyh = data;
441
435
                break;
442
436
        case 0x0154/4:
443
 
                state->m_madam.dxyl = data;
 
437
                m_madam.dxyl = data;
444
438
                break;
445
439
        case 0x0158/4:
446
 
                state->m_madam.ddxyh = data;
 
440
                m_madam.ddxyh = data;
447
441
                break;
448
442
        case 0x015c/4:
449
 
                state->m_madam.ddxyl = data;
 
443
                m_madam.ddxyl = data;
450
444
                break;
451
445
 
452
446
        /* Pip */
454
448
        case 0x0190/4: case 0x0194/4: case 0x0198/4: case 0x019c/4:
455
449
        case 0x01a0/4: case 0x01a4/4: case 0x01a8/4: case 0x01ac/4:
456
450
        case 0x01b0/4: case 0x01b4/4: case 0x01b8/4: case 0x01bc/4:
457
 
                state->m_madam.pip[offset & 0x0f] = data;
 
451
                m_madam.pip[offset & 0x0f] = data;
458
452
                break;
459
453
 
460
454
        /* Fence */
462
456
        case 0x0210/4: case 0x0214/4: case 0x0218/4: case 0x021c/4:
463
457
        case 0x0220/4: case 0x0224/4: case 0x0228/4: case 0x022c/4:
464
458
        case 0x0230/4: case 0x0234/4: case 0x0238/4: case 0x023c/4:
465
 
                state->m_madam.fence[offset & 0x0f] = data;
 
459
                m_madam.fence[offset & 0x0f] = data;
466
460
                break;
467
461
 
468
462
        /* MMU */
482
476
        case 0x03d0/4: case 0x03d4/4: case 0x03d8/4: case 0x03dc/4:
483
477
        case 0x03e0/4: case 0x03e4/4: case 0x03e8/4: case 0x03ec/4:
484
478
        case 0x03f0/4: case 0x03f4/4: case 0x03f8/4: case 0x03fc/4:
485
 
                state->m_madam.mmu[offset&0x3f] = data;
 
479
                m_madam.mmu[offset&0x3f] = data;
486
480
                break;
487
481
 
488
482
        /* DMA */
518
512
        case 0x05d0/4: case 0x05d4/4: case 0x05d8/4: case 0x05dc/4:
519
513
        case 0x05e0/4: case 0x05e4/4: case 0x05e8/4: case 0x05ec/4:
520
514
        case 0x05f0/4: case 0x05f4/4: case 0x05f8/4: case 0x05fc/4:
521
 
                state->m_madam.dma[(offset/4) & 0x1f][offset & 0x03] = data;
 
515
                m_madam.dma[(offset/4) & 0x1f][offset & 0x03] = data;
522
516
                return;
523
517
 
524
518
        /* Hardware multiplier */
532
526
        case 0x0670/4: case 0x0674/4: case 0x0678/4: case 0x067c/4:
533
527
        case 0x0680/4: case 0x0684/4: case 0x0688/4: case 0x068c/4:
534
528
        case 0x0690/4: case 0x0694/4: case 0x0698/4: case 0x069c/4:
535
 
                state->m_madam.mult[offset & 0x3f] = data;
 
529
                m_madam.mult[offset & 0x3f] = data;
536
530
        case 0x07f0/4:
537
 
                state->m_madam.mult_control |= data;
 
531
                m_madam.mult_control |= data;
538
532
                break;
539
533
        case 0x07f4/4:
540
 
                state->m_madam.mult_control &= ~data;
 
534
                m_madam.mult_control &= ~data;
541
535
                break;
542
536
        case 0x07fc/4:  /* Start process */
543
537
                break;
544
538
 
545
539
        default:
546
 
                logerror( "%08X: unhandled MADAM write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4, data, mem_mask );
 
540
                logerror( "%08X: unhandled MADAM write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4, data, mem_mask );
547
541
                break;
548
542
        }
549
543
}
558
552
}
559
553
 
560
554
 
561
 
READ32_HANDLER( _3do_clio_r )
 
555
READ32_MEMBER(_3do_state::_3do_clio_r)
562
556
{
563
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
564
 
        logerror( "%08X: CLIO read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset * 4 );
 
557
        logerror( "%08X: CLIO read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset * 4 );
565
558
 
566
559
        switch( offset )
567
560
        {
568
561
        case 0x0000/4:
569
 
                return state->m_clio.revision;
 
562
                return m_clio.revision;
570
563
        case 0x0020/4:
571
 
                return state->m_clio.audin;
 
564
                return m_clio.audin;
572
565
        case 0x0024/4:
573
 
                return state->m_clio.audout;
 
566
                return m_clio.audout;
574
567
        case 0x0028/4:
575
 
                return state->m_clio.cstatbits;
 
568
                return m_clio.cstatbits;
576
569
        case 0x0030/4:
577
 
                return state->m_clio.screen->hpos();
 
570
                return m_clio.screen->hpos();
578
571
        case 0x0034/4:
579
572
                /* This needs to moved to a proper timer callback function */
580
 
                if ( state->m_clio.screen->vpos() == 0 )
 
573
                if ( m_clio.screen->vpos() == 0 )
581
574
                {
582
 
                        state->m_clio.vcnt ^= 0x800;
 
575
                        m_clio.vcnt ^= 0x800;
583
576
                }
584
 
                return ( state->m_clio.vcnt & 0x800 ) | state->m_clio.screen->vpos();
 
577
                return ( m_clio.vcnt & 0x800 ) | m_clio.screen->vpos();
585
578
        case 0x0038/4:
586
 
                return state->m_clio.seed;
 
579
                return m_clio.seed;
587
580
        case 0x003c/4:
588
 
                return state->m_clio.random;
 
581
                return m_clio.random;
589
582
        case 0x0080/4:
590
 
                return state->m_clio.hdelay;
 
583
                return m_clio.hdelay;
591
584
        case 0x0084/4:
592
 
                return state->m_clio.adbio;
 
585
                return m_clio.adbio;
593
586
        case 0x0088/4:
594
 
                return state->m_clio.adbctl;
 
587
                return m_clio.adbctl;
595
588
 
596
589
        case 0x0100/4:
597
 
                return state->m_clio.timer0;
 
590
                return m_clio.timer0;
598
591
        case 0x0104/4:
599
 
                return state->m_clio.timerback0;
 
592
                return m_clio.timerback0;
600
593
        case 0x0108/4:
601
 
                return state->m_clio.timer1;
 
594
                return m_clio.timer1;
602
595
        case 0x010c/4:
603
 
                return state->m_clio.timerback1;
 
596
                return m_clio.timerback1;
604
597
        case 0x0110/4:
605
 
                return state->m_clio.timer2;
 
598
                return m_clio.timer2;
606
599
        case 0x0114/4:
607
 
                return state->m_clio.timerback2;
 
600
                return m_clio.timerback2;
608
601
        case 0x0118/4:
609
 
                return state->m_clio.timer3;
 
602
                return m_clio.timer3;
610
603
        case 0x011c/4:
611
 
                return state->m_clio.timerback3;
 
604
                return m_clio.timerback3;
612
605
        case 0x0120/4:
613
 
                return state->m_clio.timer4;
 
606
                return m_clio.timer4;
614
607
        case 0x0124/4:
615
 
                return state->m_clio.timerback4;
 
608
                return m_clio.timerback4;
616
609
        case 0x0128/4:
617
 
                return state->m_clio.timer5;
 
610
                return m_clio.timer5;
618
611
        case 0x012c/4:
619
 
                return state->m_clio.timerback5;
 
612
                return m_clio.timerback5;
620
613
        case 0x0130/4:
621
 
                return state->m_clio.timer6;
 
614
                return m_clio.timer6;
622
615
        case 0x0134/4:
623
 
                return state->m_clio.timerback6;
 
616
                return m_clio.timerback6;
624
617
        case 0x0138/4:
625
 
                return state->m_clio.timer7;
 
618
                return m_clio.timer7;
626
619
        case 0x013c/4:
627
 
                return state->m_clio.timerback7;
 
620
                return m_clio.timerback7;
628
621
        case 0x0140/4:
629
 
                return state->m_clio.timer8;
 
622
                return m_clio.timer8;
630
623
        case 0x0144/4:
631
 
                return state->m_clio.timerback8;
 
624
                return m_clio.timerback8;
632
625
        case 0x0148/4:
633
 
                return state->m_clio.timer9;
 
626
                return m_clio.timer9;
634
627
        case 0x014c/4:
635
 
                return state->m_clio.timerback9;
 
628
                return m_clio.timerback9;
636
629
        case 0x0150/4:
637
 
                return state->m_clio.timer10;
 
630
                return m_clio.timer10;
638
631
        case 0x0154/4:
639
 
                return state->m_clio.timerback10;
 
632
                return m_clio.timerback10;
640
633
        case 0x0158/4:
641
 
                return state->m_clio.timer11;
 
634
                return m_clio.timer11;
642
635
        case 0x015c/4:
643
 
                return state->m_clio.timerback11;
 
636
                return m_clio.timerback11;
644
637
        case 0x0160/4:
645
 
                return state->m_clio.timer12;
 
638
                return m_clio.timer12;
646
639
        case 0x0164/4:
647
 
                return state->m_clio.timerback12;
 
640
                return m_clio.timerback12;
648
641
        case 0x0168/4:
649
 
                return state->m_clio.timer13;
 
642
                return m_clio.timer13;
650
643
        case 0x016c/4:
651
 
                return state->m_clio.timerback13;
 
644
                return m_clio.timerback13;
652
645
        case 0x0170/4:
653
 
                return state->m_clio.timer14;
 
646
                return m_clio.timer14;
654
647
        case 0x0174/4:
655
 
                return state->m_clio.timerback14;
 
648
                return m_clio.timerback14;
656
649
        case 0x0178/4:
657
 
                return state->m_clio.timer15;
 
650
                return m_clio.timer15;
658
651
        case 0x017c/4:
659
 
                return state->m_clio.timerback15;
 
652
                return m_clio.timerback15;
660
653
 
661
654
        case 0x0200/4:
662
 
                return state->m_clio.settm0;
 
655
                return m_clio.settm0;
663
656
        case 0x0204/4:
664
 
                return state->m_clio.clrtm0;
 
657
                return m_clio.clrtm0;
665
658
        case 0x0208/4:
666
 
                return state->m_clio.settm1;
 
659
                return m_clio.settm1;
667
660
        case 0x020c/4:
668
 
                return state->m_clio.clrtm1;
 
661
                return m_clio.clrtm1;
669
662
 
670
663
        case 0x0220/4:
671
 
                return state->m_clio.slack;
 
664
                return m_clio.slack;
672
665
 
673
666
        case 0x0400/4:
674
667
        case 0x0404/4:
675
 
                return state->m_clio.expctl;
 
668
                return m_clio.expctl;
676
669
        case 0x0410/4:
677
 
                return state->m_clio.dipir1;
 
670
                return m_clio.dipir1;
678
671
        case 0x0414/4:
679
 
                return state->m_clio.dipir2;
 
672
                return m_clio.dipir2;
680
673
 
681
674
        case 0x0500/4: case 0x0504/4: case 0x0508/4: case 0x050c/4:
682
675
        case 0x0510/4: case 0x0514/4: case 0x0518/4: case 0x051c/4:
683
676
        case 0x0520/4: case 0x0524/4: case 0x0528/4: case 0x052c/4:
684
677
        case 0x0530/4: case 0x0534/4: case 0x0538/4: case 0x053c/4:
685
 
                return state->m_clio.sel;
 
678
                return m_clio.sel;
686
679
 
687
680
        case 0x0540/4: case 0x0544/4: case 0x0548/4: case 0x054c/4:
688
681
        case 0x0550/4: case 0x0554/4: case 0x0558/4: case 0x055c/4:
689
682
        case 0x0560/4: case 0x0564/4: case 0x0568/4: case 0x056c/4:
690
683
        case 0x0570/4: case 0x0574/4: case 0x0578/4: case 0x057c/4:
691
 
                return state->m_clio.poll;
 
684
                return m_clio.poll;
692
685
 
693
686
        case 0xc000/4:
694
 
                return state->m_clio.unclerev;
 
687
                return m_clio.unclerev;
695
688
        case 0xc004/4:
696
 
                return state->m_clio.uncle_soft_rev;
 
689
                return m_clio.uncle_soft_rev;
697
690
        case 0xc008/4:
698
 
                return state->m_clio.uncle_addr;
 
691
                return m_clio.uncle_addr;
699
692
        case 0xc00c/4:
700
 
                return state->m_clio.uncle_rom;
 
693
                return m_clio.uncle_rom;
701
694
 
702
695
        default:
703
 
                logerror( "%08X: unhandled CLIO read offset = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset * 4 );
 
696
                logerror( "%08X: unhandled CLIO read offset = %08X\n", cpu_get_pc(machine().device("maincpu")), offset * 4 );
704
697
                break;
705
698
        }
706
699
        return 0;
707
700
}
708
701
 
709
 
WRITE32_HANDLER( _3do_clio_w )
 
702
WRITE32_MEMBER(_3do_state::_3do_clio_w)
710
703
{
711
 
        _3do_state *state = space->machine().driver_data<_3do_state>();
712
 
        logerror( "%08X: CLIO write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4, data, mem_mask );
 
704
        logerror( "%08X: CLIO write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4, data, mem_mask );
713
705
 
714
706
        switch( offset )
715
707
        {
716
708
        case 0x0000/4:
717
709
                break;
718
710
        case 0x0004/4:
719
 
                state->m_clio.csysbits = data;
 
711
                m_clio.csysbits = data;
720
712
                break;
721
713
        case 0x0008/4:
722
 
                state->m_clio.vint0 = data;
 
714
                m_clio.vint0 = data;
723
715
                break;
724
716
        case 0x000c/4:
725
 
                state->m_clio.vint1 = data;
 
717
                m_clio.vint1 = data;
726
718
                break;
727
719
        case 0x0020/4:
728
 
                state->m_clio.audin = data;
 
720
                m_clio.audin = data;
729
721
                break;
730
722
        case 0x0024/4:  /* 03400024 - c0020f0f is written here during boot */
731
 
                state->m_clio.audout = data;
 
723
                m_clio.audout = data;
732
724
                break;
733
725
        case 0x0028/4:  /* 03400028 - bits 0,1, and 6 are tested (reset source) */
734
 
                state->m_clio.cstatbits = data;
 
726
                m_clio.cstatbits = data;
735
727
                break;
736
728
        case 0x002c/4:  /* 0340002C - ?? during boot 0000000B is written here counter reload related?? */
737
 
                state->m_clio.wdog = data;
 
729
                m_clio.wdog = data;
738
730
                break;
739
731
        case 0x0030/4:
740
 
                state->m_clio.hcnt = data;
 
732
                m_clio.hcnt = data;
741
733
                break;
742
734
        case 0x0034/4:
743
 
                state->m_clio.vcnt = data;
 
735
                m_clio.vcnt = data;
744
736
                break;
745
737
        case 0x0038/4:
746
 
                state->m_clio.seed = data;
 
738
                m_clio.seed = data;
747
739
                break;
748
740
        case 0x0040/4:
749
 
                state->m_clio.irq0 |= data;
 
741
                m_clio.irq0 |= data;
750
742
                break;
751
743
        case 0x0044/4:
752
 
                state->m_clio.irq0 &= ~data;
 
744
                m_clio.irq0 &= ~data;
753
745
                break;
754
746
        case 0x0048/4:
755
 
                state->m_clio.irq0_enable |= data;
 
747
                m_clio.irq0_enable |= data;
756
748
                break;
757
749
        case 0x004c/4:
758
 
                state->m_clio.irq0_enable &= ~data;
 
750
                m_clio.irq0_enable &= ~data;
759
751
                break;
760
752
        case 0x0050/4:
761
 
                state->m_clio.mode |= data;
 
753
                m_clio.mode |= data;
762
754
                break;
763
755
        case 0x0054/4:
764
 
                state->m_clio.mode &= ~data;
 
756
                m_clio.mode &= ~data;
765
757
                break;
766
758
        case 0x0058/4:
767
 
                state->m_clio.badbits = data;
 
759
                m_clio.badbits = data;
768
760
                break;
769
761
        case 0x005c/4:
770
 
                state->m_clio.spare = data;
 
762
                m_clio.spare = data;
771
763
                break;
772
764
        case 0x0060/4:
773
 
                state->m_clio.irq1 |= data;
 
765
                m_clio.irq1 |= data;
774
766
                break;
775
767
        case 0x0064/4:
776
 
                state->m_clio.irq1 &= ~data;
 
768
                m_clio.irq1 &= ~data;
777
769
                break;
778
770
        case 0x0068/4:
779
 
                state->m_clio.irq1_enable |= data;
 
771
                m_clio.irq1_enable |= data;
780
772
                break;
781
773
        case 0x006c/4:
782
 
                state->m_clio.irq1_enable &= ~data;
 
774
                m_clio.irq1_enable &= ~data;
783
775
                break;
784
776
        case 0x0080/4:
785
 
                state->m_clio.hdelay = data;
 
777
                m_clio.hdelay = data;
786
778
                break;
787
779
        case 0x0084/4:
788
 
                state->m_clio.adbio = data;
 
780
                m_clio.adbio = data;
789
781
                break;
790
782
        case 0x0088/4:
791
 
                state->m_clio.adbctl = data;
 
783
                m_clio.adbctl = data;
792
784
                break;
793
785
 
794
786
        case 0x0100/4:
795
 
                state->m_clio.timer0 = data & 0x0000ffff;
 
787
                m_clio.timer0 = data & 0x0000ffff;
796
788
                break;
797
789
        case 0x0104/4:
798
 
                state->m_clio.timerback0 = data & 0x0000ffff;
 
790
                m_clio.timerback0 = data & 0x0000ffff;
799
791
                break;
800
792
        case 0x0108/4:
801
 
                state->m_clio.timer1 = data & 0x0000ffff;
 
793
                m_clio.timer1 = data & 0x0000ffff;
802
794
                break;
803
795
        case 0x010c/4:
804
 
                state->m_clio.timerback1 = data & 0x0000ffff;
 
796
                m_clio.timerback1 = data & 0x0000ffff;
805
797
                break;
806
798
        case 0x0110/4:
807
 
                state->m_clio.timer2 = data & 0x0000ffff;
 
799
                m_clio.timer2 = data & 0x0000ffff;
808
800
                break;
809
801
        case 0x0114/4:
810
 
                state->m_clio.timerback2 = data & 0x0000ffff;
 
802
                m_clio.timerback2 = data & 0x0000ffff;
811
803
                break;
812
804
        case 0x0118/4:
813
 
                state->m_clio.timer3 = data & 0x0000ffff;
 
805
                m_clio.timer3 = data & 0x0000ffff;
814
806
                break;
815
807
        case 0x011c/4:
816
 
                state->m_clio.timerback3 = data & 0x0000ffff;
 
808
                m_clio.timerback3 = data & 0x0000ffff;
817
809
                break;
818
810
        case 0x0120/4:
819
 
                state->m_clio.timer4 = data & 0x0000ffff;
 
811
                m_clio.timer4 = data & 0x0000ffff;
820
812
                break;
821
813
        case 0x0124/4:
822
 
                state->m_clio.timerback4 = data & 0x0000ffff;
 
814
                m_clio.timerback4 = data & 0x0000ffff;
823
815
                break;
824
816
        case 0x0128/4:
825
 
                state->m_clio.timer5 = data & 0x0000ffff;
 
817
                m_clio.timer5 = data & 0x0000ffff;
826
818
                break;
827
819
        case 0x012c/4:
828
 
                state->m_clio.timerback5 = data & 0x0000ffff;
 
820
                m_clio.timerback5 = data & 0x0000ffff;
829
821
                break;
830
822
        case 0x0130/4:
831
 
                state->m_clio.timer6 = data & 0x0000ffff;
 
823
                m_clio.timer6 = data & 0x0000ffff;
832
824
                break;
833
825
        case 0x0134/4:
834
 
                state->m_clio.timerback6 = data & 0x0000ffff;
 
826
                m_clio.timerback6 = data & 0x0000ffff;
835
827
                break;
836
828
        case 0x0138/4:
837
 
                state->m_clio.timer7 = data & 0x0000ffff;
 
829
                m_clio.timer7 = data & 0x0000ffff;
838
830
                break;
839
831
        case 0x013c/4:
840
 
                state->m_clio.timerback7 = data & 0x0000ffff;
 
832
                m_clio.timerback7 = data & 0x0000ffff;
841
833
                break;
842
834
        case 0x0140/4:
843
 
                state->m_clio.timer8 = data & 0x0000ffff;
 
835
                m_clio.timer8 = data & 0x0000ffff;
844
836
                break;
845
837
        case 0x0144/4:
846
 
                state->m_clio.timerback8 = data & 0x0000ffff;
 
838
                m_clio.timerback8 = data & 0x0000ffff;
847
839
                break;
848
840
        case 0x0148/4:
849
 
                state->m_clio.timer9 = data & 0x0000ffff;
 
841
                m_clio.timer9 = data & 0x0000ffff;
850
842
                break;
851
843
        case 0x014c/4:
852
 
                state->m_clio.timerback9 = data & 0x0000ffff;
 
844
                m_clio.timerback9 = data & 0x0000ffff;
853
845
                break;
854
846
        case 0x0150/4:
855
 
                state->m_clio.timer10 = data & 0x0000ffff;
 
847
                m_clio.timer10 = data & 0x0000ffff;
856
848
                break;
857
849
        case 0x0154/4:
858
 
                state->m_clio.timerback10 = data & 0x0000ffff;
 
850
                m_clio.timerback10 = data & 0x0000ffff;
859
851
                break;
860
852
        case 0x0158/4:
861
 
                state->m_clio.timer11 = data & 0x0000ffff;
 
853
                m_clio.timer11 = data & 0x0000ffff;
862
854
                break;
863
855
        case 0x015c/4:
864
 
                state->m_clio.timerback11 = data & 0x0000ffff;
 
856
                m_clio.timerback11 = data & 0x0000ffff;
865
857
                break;
866
858
        case 0x0160/4:
867
 
                state->m_clio.timer12 = data & 0x0000ffff;
 
859
                m_clio.timer12 = data & 0x0000ffff;
868
860
                break;
869
861
        case 0x0164/4:
870
 
                state->m_clio.timerback12 = data & 0x0000ffff;
 
862
                m_clio.timerback12 = data & 0x0000ffff;
871
863
                break;
872
864
        case 0x0168/4:
873
 
                state->m_clio.timer13 = data & 0x0000ffff;
 
865
                m_clio.timer13 = data & 0x0000ffff;
874
866
                break;
875
867
        case 0x016c/4:
876
 
                state->m_clio.timerback13 = data & 0x0000ffff;
 
868
                m_clio.timerback13 = data & 0x0000ffff;
877
869
                break;
878
870
        case 0x0170/4:
879
 
                state->m_clio.timer14 = data & 0x0000ffff;
 
871
                m_clio.timer14 = data & 0x0000ffff;
880
872
                break;
881
873
        case 0x0174/4:
882
 
                state->m_clio.timerback14 = data & 0x0000ffff;
 
874
                m_clio.timerback14 = data & 0x0000ffff;
883
875
                break;
884
876
        case 0x0178/4:
885
 
                state->m_clio.timer15 = data & 0x0000ffff;
 
877
                m_clio.timer15 = data & 0x0000ffff;
886
878
                break;
887
879
        case 0x017c/4:
888
 
                state->m_clio.timerback15 = data & 0x0000ffff;
 
880
                m_clio.timerback15 = data & 0x0000ffff;
889
881
                break;
890
882
 
891
883
        case 0x0200/4:
892
 
                state->m_clio.settm0 = data;
 
884
                m_clio.settm0 = data;
893
885
                break;
894
886
        case 0x0204/4:
895
 
                state->m_clio.clrtm0 = data;
 
887
                m_clio.clrtm0 = data;
896
888
                break;
897
889
        case 0x0208/4:
898
 
                state->m_clio.settm0 = data;
 
890
                m_clio.settm0 = data;
899
891
                break;
900
892
        case 0x020c/4:
901
893
                break;
902
894
 
903
895
        case 0x0220/4:
904
 
                state->m_clio.slack = data & 0x000003ff;
 
896
                m_clio.slack = data & 0x000003ff;
905
897
                break;
906
898
 
907
899
        case 0x0308/4:
908
 
                state->m_clio.dmareqdis = data;
 
900
                m_clio.dmareqdis = data;
909
901
                break;
910
902
 
911
903
        case 0x0400/4:
912
 
                state->m_clio.expctl = state->m_clio.expctl | ( data & 0xca00 );
 
904
                m_clio.expctl = m_clio.expctl | ( data & 0xca00 );
913
905
                break;
914
906
        case 0x0404/4:
915
 
                state->m_clio.expctl = state->m_clio.expctl & ~( data & 0xca00 );
 
907
                m_clio.expctl = m_clio.expctl & ~( data & 0xca00 );
916
908
                break;
917
909
        case 0x0408/4:
918
 
                state->m_clio.type0_4 = data;
 
910
                m_clio.type0_4 = data;
919
911
                break;
920
912
 
921
913
        case 0x0500/4: case 0x0504/4: case 0x0508/4: case 0x050c/4:
922
914
        case 0x0510/4: case 0x0514/4: case 0x0518/4: case 0x051c/4:
923
915
        case 0x0520/4: case 0x0524/4: case 0x0528/4: case 0x052c/4:
924
916
        case 0x0530/4: case 0x0534/4: case 0x0538/4: case 0x053c/4:
925
 
                state->m_clio.sel = data & 0xff;
 
917
                m_clio.sel = data & 0xff;
926
918
                /* Start WRSEL cycle */
927
919
 
928
920
                /* Detection of too many devices on the bus */
930
922
                {
931
923
                case 0x8f:
932
924
                        /* Everything is fine, there are not too many devices in the system */
933
 
                        state->m_clio.poll = ( state->m_clio.poll & 0x0f );
 
925
                        m_clio.poll = ( m_clio.poll & 0x0f );
934
926
                        break;
935
927
                default:
936
 
                        state->m_clio.poll = ( state->m_clio.poll & 0x0f ) | 0x90;
 
928
                        m_clio.poll = ( m_clio.poll & 0x0f ) | 0x90;
937
929
                }
938
930
                break;
939
931
 
941
933
        case 0x0550/4: case 0x0554/4: case 0x0558/4: case 0x055c/4:
942
934
        case 0x0560/4: case 0x0564/4: case 0x0568/4: case 0x056c/4:
943
935
        case 0x0570/4: case 0x0574/4: case 0x0578/4: case 0x057c/4:
944
 
                state->m_clio.poll = ( state->m_clio.poll & 0xf8 ) | ( data & 0x07 );
 
936
                m_clio.poll = ( m_clio.poll & 0xf8 ) | ( data & 0x07 );
945
937
                break;
946
938
 
947
939
        case 0xc000/4:
949
941
        case 0xc00c/4:
950
942
                break;
951
943
        case 0xc008/4:
952
 
                state->m_clio.uncle_addr = data;
 
944
                m_clio.uncle_addr = data;
953
945
                break;
954
946
 
955
947
        default:
956
 
                logerror( "%08X: unhandled CLIO write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(space->machine().device("maincpu")), offset*4, data, mem_mask );
 
948
                logerror( "%08X: unhandled CLIO write offset = %08X, data = %08X, mask = %08X\n", cpu_get_pc(machine().device("maincpu")), offset*4, data, mem_mask );
957
949
                break;
958
950
        }
959
951
}