← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/emu/cpu/m68000/m68kcpu.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/emu/cpu/m68000/m68kcpu.c
5
5
#if 0
6
6
static const char copyright_notice[] =
7
7
"MUSASHI\n"
8
 
"Version 4.90 (2011-09-22)\n"
 
8
"Version 4.95 (2012-02-19)\n"
9
9
"A portable Motorola M68xxx/CPU32/ColdFire processor emulation engine.\n"
10
10
"Copyright Karl Stenerud.  All rights reserved.\n"
11
11
"\n"
17
17
"(Karl Stenerud).\n"
18
18
"\n"
19
19
"The latest version of this code can be obtained at:\n"
20
 
"http://kstenerud.cjb.net or http://mamedev.org\n"
 
20
"http://kstenerud.cjb.net or http://mamedev.org/\n"
21
21
;
22
22
#endif
23
23
 
639
639
#define MASK_040_OR_LATER                       (CPU_TYPE_040 | CPU_TYPE_EC040)
640
640
 
641
641
 
642
 
INLINE m68ki_cpu_core *get_safe_token(device_t *device)
643
 
{
644
 
        assert(device != NULL);
645
 
        assert(device->type() == M68000 ||
646
 
                   device->type() == M68008 ||
647
 
                   device->type() == M68008PLCC ||
648
 
                   device->type() == M68010 ||
649
 
                   device->type() == M68EC020 ||
650
 
                   device->type() == M68020 ||
651
 
                   device->type() == M68020HMMU ||
652
 
                   device->type() == M68020PMMU ||
653
 
                   device->type() == M68EC030 ||
654
 
                   device->type() == M68030 ||
655
 
                   device->type() == M68EC040 ||
656
 
                   device->type() == M68040 ||
657
 
                   device->type() == SCC68070 ||
658
 
                   device->type() == MCF5206E ||
659
 
                   device->type() == M68340);
660
 
        return (m68ki_cpu_core *)downcast<legacy_cpu_device *>(device)->token();
661
 
}
662
642
 
663
643
/* ======================================================================== */
664
644
/* ================================= API ================================== */
731
711
/* translate logical to physical addresses */
732
712
static CPU_TRANSLATE( m68k )
733
713
{
734
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
714
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
735
715
 
736
716
        /* only applies to the program address space and only does something if the MMU's enabled */
737
717
        if (m68k)
741
721
                {
742
722
                        // FIXME: mmu_tmp_sr will be overwritten in pmmu_translate_addr_with_fc
743
723
                        UINT16 mmu_tmp_sr = m68k->mmu_tmp_sr;
 
724
                        int mode = m68k->s_flag ? FUNCTION_CODE_SUPERVISOR_PROGRAM : FUNCTION_CODE_USER_PROGRAM;
744
725
//          UINT32 va=*address;
745
726
 
746
727
                        if (CPU_TYPE_IS_040_PLUS(m68k->cpu_type))
747
728
                        {
748
 
                                *address = pmmu_translate_addr_with_fc_040(m68k, *address, FUNCTION_CODE_SUPERVISOR_PROGRAM, 1);
 
729
                                *address = pmmu_translate_addr_with_fc_040(m68k, *address, mode, 1);
749
730
                        }
750
731
                        else
751
732
                        {
752
 
                                *address = pmmu_translate_addr_with_fc(m68k, *address, FUNCTION_CODE_SUPERVISOR_PROGRAM, 1);
 
733
                                *address = pmmu_translate_addr_with_fc(m68k, *address, mode, 1);
753
734
                        }
754
735
 
755
736
                        if ((m68k->mmu_tmp_sr & M68K_MMU_SR_INVALID) != 0) {
766
747
/* translate logical to physical addresses for Apple HMMU */
767
748
static CPU_TRANSLATE( m68khmmu )
768
749
{
769
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
750
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
770
751
 
771
752
        /* only applies to the program address space and only does something if the MMU's enabled */
772
753
        if (m68k)
782
763
/* Execute some instructions until we use up cycles clock cycles */
783
764
static CPU_EXECUTE( m68k )
784
765
{
785
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
766
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
786
767
 
787
768
        m68k->initial_cycles = m68k->remaining_cycles;
788
769
 
801
782
        /* Make sure we're not stopped */
802
783
        if(!m68k->stopped)
803
784
        {
804
 
                /* Return point if we had an address error */
 
785
        /* Return point if we had an address error */
805
786
                m68ki_set_address_error_trap(m68k); /* auto-disable (see m68kcpu.h) */
806
787
 
807
788
                /* Main loop.  Keep going until we run out of clock cycles */
877
858
                                                /* Note: This is implemented for 68000 only! */
878
859
                                                m68ki_stack_frame_buserr(m68k, sr);
879
860
                                        }
880
 
                                        else if (m68k->mmu_tmp_buserror_address == REG_PPC(m68k))
881
 
                                        {
882
 
                                                m68ki_stack_frame_1010(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC(m68k), m68k->mmu_tmp_buserror_address);
 
861
                                        else if(!CPU_TYPE_IS_040_PLUS(m68k->cpu_type)) {
 
862
                                                if (m68k->mmu_tmp_buserror_address == REG_PPC(m68k))
 
863
                                                {
 
864
                                                        m68ki_stack_frame_1010(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC(m68k), m68k->mmu_tmp_buserror_address);
 
865
                                                }
 
866
                                                else
 
867
                                                {
 
868
                                                        m68ki_stack_frame_1011(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC(m68k), m68k->mmu_tmp_buserror_address);
 
869
                                                }
883
870
                                        }
884
871
                                        else
885
872
                                        {
886
 
                                                m68ki_stack_frame_1011(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC(m68k), m68k->mmu_tmp_buserror_address);
 
873
                                                m68ki_stack_frame_0111(m68k, sr, EXCEPTION_BUS_ERROR, REG_PPC(m68k), m68k->mmu_tmp_buserror_address, true);
887
874
                                        }
888
875
 
889
876
                                        m68ki_jump_vector(m68k, EXCEPTION_BUS_ERROR);
908
895
static CPU_INIT( m68k )
909
896
{
910
897
        static UINT32 emulation_initialized = 0;
911
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
898
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
912
899
 
913
900
        m68k->device = device;
914
901
        m68k->program = device->space(AS_PROGRAM);
952
939
/* Pulse the RESET line on the CPU */
953
940
static CPU_RESET( m68k )
954
941
{
955
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
942
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
956
943
 
957
944
        /* Disable the PMMU/HMMU on reset, if any */
958
945
        m68k->pmmu_enabled = 0;
1006
993
 
1007
994
        // disable instruction hook
1008
995
        m68k->instruction_hook = NULL;
 
996
 
 
997
        if (m68k->m68307SIM) m68k->m68307SIM->reset();
 
998
        if (m68k->m68307MBUS) m68k->m68307MBUS->reset();
 
999
        if (m68k->m68307SERIAL) m68k->m68307SERIAL->reset();
 
1000
        if (m68k->m68307TIMER) m68k->m68307TIMER->reset();
 
1001
 
 
1002
        m68k->m68307_base = 0xbfff;
 
1003
        m68k->m68307_scrhigh = 0x0007;
 
1004
        m68k->m68307_scrlow = 0xf010;
 
1005
 
 
1006
 
1009
1007
}
1010
1008
 
1011
1009
static CPU_DISASSEMBLE( m68k )
1012
1010
{
1013
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1011
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1014
1012
        return m68k_disassemble_raw(buffer, pc, oprom, opram, m68k->dasm_type);
1015
1013
}
1016
1014
 
1022
1020
 
1023
1021
static CPU_IMPORT_STATE( m68k )
1024
1022
{
1025
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1023
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1026
1024
 
1027
1025
        switch (entry.index())
1028
1026
        {
1061
1059
 
1062
1060
static CPU_EXPORT_STATE( m68k )
1063
1061
{
1064
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1062
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1065
1063
 
1066
1064
        switch (entry.index())
1067
1065
        {
1100
1098
 
1101
1099
static CPU_SET_INFO( m68k )
1102
1100
{
1103
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1101
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1104
1102
        switch (state)
1105
1103
        {
1106
1104
                /* --- the following bits of info are set as 64-bit signed integers --- */
1127
1125
 
1128
1126
static CPU_EXPORT_STRING( m68k )
1129
1127
{
1130
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1128
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1131
1129
        UINT16 sr;
1132
1130
 
1133
1131
        switch (entry.index())
1189
1187
 
1190
1188
static CPU_GET_INFO( m68k )
1191
1189
{
1192
 
        m68ki_cpu_core *m68k = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL;
 
1190
        m68ki_cpu_core *m68k = (device != NULL && device->token() != NULL) ? m68k_get_safe_token(device) : NULL;
1193
1191
 
1194
1192
        switch (state)
1195
1193
        {
1235
1233
                /* --- the following bits of info are returned as NULL-terminated strings --- */
1236
1234
                case DEVINFO_STR_NAME:                                                  /* set per-core */                                              break;
1237
1235
                case DEVINFO_STR_FAMILY:                                        strcpy(info->s, "Motorola 68K");                break;
1238
 
                case DEVINFO_STR_VERSION:                                       strcpy(info->s, "4.90");                                break;
 
1236
                case DEVINFO_STR_VERSION:                                       strcpy(info->s, "4.95");                                break;
1239
1237
                case DEVINFO_STR_SOURCE_FILE:                                           strcpy(info->s, __FILE__);                              break;
1240
 
                case DEVINFO_STR_CREDITS:                                       strcpy(info->s, "Copyright Karl Stenerud. All rights reserved. (2.1 fixes HJB, FPU+MMU by RB+HO)"); break;
 
1238
                case DEVINFO_STR_CREDITS:                                       strcpy(info->s, "Copyright Karl Stenerud. All rights reserved. (2.1 fixes HJB, FPU+MMU by RB+HO+OG)"); break;
1241
1239
        }
1242
1240
}
1243
1241
 
1246
1244
 
1247
1245
void m68k_set_encrypted_opcode_range(device_t *device, offs_t start, offs_t end)
1248
1246
{
1249
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1247
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1250
1248
        m68k->encrypted_start = start;
1251
1249
        m68k->encrypted_end = end;
1252
1250
}
1253
1251
 
1254
1252
void m68k_set_hmmu_enable(device_t *device, int enable)
1255
1253
{
1256
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1254
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1257
1255
 
1258
1256
        m68k->hmmu_enabled = enable;
1259
1257
}
1260
1258
 
 
1259
void m68k_set_instruction_hook(device_t *device, instruction_hook_t ihook)
 
1260
{
 
1261
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
 
1262
 
 
1263
    m68k->instruction_hook = ihook;
 
1264
}
 
1265
 
1261
1266
/****************************************************************************
1262
1267
 * 8-bit data memory interface
1263
1268
 ****************************************************************************/
1271
1276
{
1272
1277
        m_space = &space;
1273
1278
        m_direct = &space.direct();
1274
 
        m_cpustate = get_safe_token(&space.device());
 
1279
        m_cpustate = m68k_get_safe_token(&space.device());
1275
1280
        opcode_xor = 0;
1276
1281
 
1277
1282
        readimm16 = m68k_readimm16_delegate(FUNC(m68k_memory_interface::m68008_read_immediate_16), this);
1301
1306
{
1302
1307
        m_space = &space;
1303
1308
        m_direct = &space.direct();
1304
 
        m_cpustate = get_safe_token(&space.device());
 
1309
        m_cpustate = m68k_get_safe_token(&space.device());
1305
1310
        opcode_xor = 0;
1306
1311
 
1307
1312
        readimm16 = m68k_readimm16_delegate(FUNC(m68k_memory_interface::simple_read_immediate_16), this);
1313
1318
        write32 = m68k_write32_delegate(FUNC(address_space::write_dword), &space);
1314
1319
}
1315
1320
 
 
1321
/* todo: is it possible to calculate the address map based on CS when they change
 
1322
   and install handlers?  Going through this logic for every memory access is
 
1323
   very slow */
 
1324
 
 
1325
int m68307_calc_cs(m68ki_cpu_core *m68k, offs_t address)
 
1326
{
 
1327
        m68307_sim* sim = m68k->m68307SIM;
 
1328
 
 
1329
        for (int i=0;i<4;i++)
 
1330
        {
 
1331
                int br,amask,bra;
 
1332
                br = sim->m_br[i] & 1;
 
1333
                amask = ((sim->m_or[i]&0x1ffc)<<11);
 
1334
                bra = ((sim->m_br[i] & 0x1ffc)<<11);
 
1335
                if ((br) && ((address & amask) == bra)) return i+1;
 
1336
        }
 
1337
        return 0;
 
1338
}
 
1339
 
 
1340
/* see note above */
 
1341
 
 
1342
int m68340_calc_cs(m68ki_cpu_core *m68k, offs_t address)
 
1343
{
 
1344
        m68340_sim* sim = m68k->m68340SIM;
 
1345
 
 
1346
        if ( !(sim->m_ba[0] & 1) ) return 1;
 
1347
 
 
1348
        for (int i=0;i<4;i++)
 
1349
        {
 
1350
                if (sim->m_ba[i] & 1)
 
1351
                {
 
1352
                        int mask = ((sim->m_am[i]&0xffffff00) | 0xff);
 
1353
                        int base = sim->m_ba[i] & 0xffffff00;
 
1354
                        int fcmask = (sim->m_am[i] & 0xf0);
 
1355
                        int fcbase = (sim->m_ba[i] & 0xf0) & ~(sim->m_am[i] & 0xf0);
 
1356
                        int fc = m68k->mmu_tmp_fc;
 
1357
 
 
1358
                        if ((address & ~mask) == base && ((fc << 4) & ~fcmask ) == fcbase ) return i+1;
 
1359
                }
 
1360
        }
 
1361
 
 
1362
        return 0;
 
1363
}
 
1364
 
 
1365
 
 
1366
 
 
1367
 
 
1368
UINT16 m68k_memory_interface::simple_read_immediate_16_m68307(offs_t address)
 
1369
{
 
1370
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1371
        return m_direct->read_decrypted_word(address);
 
1372
}
 
1373
 
 
1374
UINT8 m68k_memory_interface::read_byte_m68307(offs_t address)
 
1375
{
 
1376
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1377
        return m_space->read_byte(address);
 
1378
}
 
1379
 
 
1380
UINT16 m68k_memory_interface::read_word_m68307(offs_t address)
 
1381
{
 
1382
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1383
        return m_space->read_word(address);
 
1384
}
 
1385
 
 
1386
UINT32 m68k_memory_interface::read_dword_m68307(offs_t address)
 
1387
{
 
1388
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1389
        return m_space->read_dword(address);
 
1390
}
 
1391
 
 
1392
void m68k_memory_interface::write_byte_m68307(offs_t address, UINT8 data)
 
1393
{
 
1394
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1395
        m_space->write_byte(address, data);
 
1396
}
 
1397
 
 
1398
void m68k_memory_interface::write_word_m68307(offs_t address, UINT16 data)
 
1399
{
 
1400
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1401
        m_space->write_word(address, data);
 
1402
}
 
1403
 
 
1404
void m68k_memory_interface::write_dword_m68307(offs_t address, UINT32 data)
 
1405
{
 
1406
//  m_cpustate->m68307_currentcs = m68307_calc_cs(m_cpustate, address);
 
1407
        m_space->write_dword(address, data);
 
1408
}
 
1409
 
 
1410
 
 
1411
 
 
1412
 
 
1413
void m68k_memory_interface::init16_m68307(address_space &space)
 
1414
{
 
1415
        m_space = &space;
 
1416
        m_direct = &space.direct();
 
1417
        m_cpustate = m68k_get_safe_token(&space.device());
 
1418
        opcode_xor = 0;
 
1419
 
 
1420
        readimm16 = m68k_readimm16_delegate(FUNC(m68k_memory_interface::simple_read_immediate_16_m68307), this);
 
1421
        read8 = m68k_read8_delegate(FUNC(m68k_memory_interface::read_byte_m68307), this);
 
1422
        read16 = m68k_read16_delegate(FUNC(m68k_memory_interface::read_word_m68307), this);
 
1423
        read32 = m68k_read32_delegate(FUNC(m68k_memory_interface::read_dword_m68307), this);
 
1424
        write8 = m68k_write8_delegate(FUNC(m68k_memory_interface::write_byte_m68307), this);
 
1425
        write16 = m68k_write16_delegate(FUNC(m68k_memory_interface::write_word_m68307), this);
 
1426
        write32 = m68k_write32_delegate(FUNC(m68k_memory_interface::write_dword_m68307), this);
 
1427
}
 
1428
 
1316
1429
/****************************************************************************
1317
1430
 * 32-bit data memory interface
1318
1431
 ****************************************************************************/
1322
1435
{
1323
1436
        m_space = &space;
1324
1437
        m_direct = &space.direct();
1325
 
        m_cpustate = get_safe_token(&space.device());
 
1438
        m_cpustate = m68k_get_safe_token(&space.device());
1326
1439
        opcode_xor = WORD_XOR_BE(0);
1327
1440
 
1328
1441
        readimm16 = m68k_readimm16_delegate(FUNC(m68k_memory_interface::read_immediate_16), this);
1540
1653
{
1541
1654
        m_space = &space;
1542
1655
        m_direct = &space.direct();
1543
 
        m_cpustate = get_safe_token(&space.device());
 
1656
        m_cpustate = m68k_get_safe_token(&space.device());
1544
1657
        opcode_xor = WORD_XOR_BE(0);
1545
1658
 
1546
1659
        readimm16 = m68k_readimm16_delegate(FUNC(m68k_memory_interface::read_immediate_16_mmu), this);
1667
1780
{
1668
1781
        m_space = &space;
1669
1782
        m_direct = &space.direct();
1670
 
        m_cpustate = get_safe_token(&space.device());
 
1783
        m_cpustate = m68k_get_safe_token(&space.device());
1671
1784
        opcode_xor = WORD_XOR_BE(0);
1672
1785
 
1673
1786
        readimm16 = m68k_readimm16_delegate(FUNC(m68k_memory_interface::read_immediate_16_hmmu), this);
1681
1794
 
1682
1795
void m68k_set_reset_callback(device_t *device, m68k_reset_func callback)
1683
1796
{
1684
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1797
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1685
1798
        m68k->reset_instr_callback = callback;
1686
1799
}
1687
1800
 
1688
1801
void m68k_set_cmpild_callback(device_t *device, m68k_cmpild_func callback)
1689
1802
{
1690
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1803
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1691
1804
        m68k->cmpild_instr_callback = callback;
1692
1805
}
1693
1806
 
1694
1807
void m68k_set_rte_callback(device_t *device, m68k_rte_func callback)
1695
1808
{
1696
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1809
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1697
1810
        m68k->rte_instr_callback = callback;
1698
1811
}
1699
1812
 
1700
1813
void m68k_set_tas_callback(device_t *device, m68k_tas_func callback)
1701
1814
{
1702
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1815
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1703
1816
        m68k->tas_instr_callback = callback;
1704
1817
}
1705
1818
 
1706
1819
UINT16 m68k_get_fc(device_t *device)
1707
1820
{
1708
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1821
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1709
1822
        return m68k->mmu_tmp_fc;
1710
1823
}
1711
1824
 
 
1825
void m68307_set_port_callbacks(device_t *device, m68307_porta_read_callback porta_r, m68307_porta_write_callback porta_w, m68307_portb_read_callback portb_r, m68307_portb_write_callback portb_w)
 
1826
{
 
1827
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
 
1828
        m68k->m_m68307_porta_r = porta_r;
 
1829
        m68k->m_m68307_porta_w = porta_w;
 
1830
        m68k->m_m68307_portb_r = portb_r;
 
1831
        m68k->m_m68307_portb_w = portb_w;
 
1832
}
 
1833
 
 
1834
void m68307_set_duart68681(device_t* cpudev, device_t* duart68681)
 
1835
{
 
1836
        m68ki_cpu_core *m68k = m68k_get_safe_token(cpudev);
 
1837
        if (m68k->m68307SERIAL)
 
1838
                m68k->m68307SERIAL->m68307ser_set_duart68681(duart68681);
 
1839
}
 
1840
 
 
1841
 
 
1842
 
 
1843
 
 
1844
UINT16 m68307_get_cs(device_t *device, offs_t address)
 
1845
{
 
1846
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
 
1847
 
 
1848
        m68k->m68307_currentcs = m68307_calc_cs(m68k, address);
 
1849
 
 
1850
        return m68k->m68307_currentcs;
 
1851
}
 
1852
 
 
1853
UINT16 m68340_get_cs(device_t *device, offs_t address)
 
1854
{
 
1855
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
 
1856
 
 
1857
        m68k->m68307_currentcs = m68340_calc_cs(m68k, address);
 
1858
 
 
1859
        return m68k->m68307_currentcs;
 
1860
}
1712
1861
 
1713
1862
/****************************************************************************
1714
1863
 * State definition
1716
1865
 
1717
1866
static void define_state(device_t *device)
1718
1867
{
1719
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1868
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1720
1869
        UINT32 addrmask = (m68k->cpu_type & MASK_24BIT_SPACE) ? 0xffffff : 0xffffffff;
1721
1870
 
1722
1871
        device_state_interface *state;
1771
1920
 
1772
1921
static CPU_INIT( m68000 )
1773
1922
{
1774
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
1923
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1775
1924
 
1776
1925
        CPU_INIT_CALL(m68k);
1777
1926
 
1816
1965
        }
1817
1966
}
1818
1967
 
 
1968
static CPU_INIT( m68301 )
 
1969
{
 
1970
//  m68ki_cpu_core *m68k = m68k_get_safe_token(device);
 
1971
 
 
1972
        CPU_INIT_CALL(m68000);
 
1973
 
 
1974
        /* there is a basic implementation of this in emu/machine/tmp68301.c but it should be moved here */
 
1975
 
 
1976
}
 
1977
 
 
1978
CPU_GET_INFO( m68301 )
 
1979
{
 
1980
        switch (state)
 
1981
        {
 
1982
                /* --- the following bits of info are returned as pointers to data or functions --- */
 
1983
                case CPUINFO_FCT_INIT:                                          info->init = CPU_INIT_NAME(m68301);                             break;
 
1984
 
 
1985
                /* --- the following bits of info are returned as NULL-terminated strings --- */
 
1986
                case DEVINFO_STR_NAME:                                          strcpy(info->s, "68301");                                               break;
 
1987
 
 
1988
                default:                                                                        CPU_GET_INFO_CALL(m68k);                                                break;
 
1989
        }
 
1990
}
 
1991
 
 
1992
 
 
1993
 
 
1994
 
 
1995
void m68307_set_interrupt(device_t *device, int level, int vector)
 
1996
{
 
1997
        device_set_input_line_and_vector(device, level, HOLD_LINE, vector);
 
1998
}
 
1999
 
 
2000
void m68307_timer0_interrupt(legacy_cpu_device *cpudev)
 
2001
{
 
2002
        m68ki_cpu_core* m68k = m68k_get_safe_token(cpudev);
 
2003
        int prioritylevel = (m68k->m68307SIM->m_picr & 0x7000)>>12;
 
2004
        int vector        = (m68k->m68307SIM->m_pivr & 0x00f0) | 0xa;
 
2005
        m68307_set_interrupt(cpudev, prioritylevel, vector);
 
2006
}
 
2007
 
 
2008
void m68307_timer1_interrupt(legacy_cpu_device *cpudev)
 
2009
{
 
2010
        m68ki_cpu_core* m68k = m68k_get_safe_token(cpudev);
 
2011
        int prioritylevel = (m68k->m68307SIM->m_picr & 0x0700)>>8;
 
2012
        int vector        = (m68k->m68307SIM->m_pivr & 0x00f0) | 0xb;
 
2013
        m68307_set_interrupt(cpudev, prioritylevel, vector);
 
2014
}
 
2015
 
 
2016
void m68307_serial_interrupt(legacy_cpu_device *cpudev, int vector)
 
2017
{
 
2018
        m68ki_cpu_core* m68k = m68k_get_safe_token(cpudev);
 
2019
        int prioritylevel = (m68k->m68307SIM->m_picr & 0x0070)>>4;
 
2020
        m68307_set_interrupt(cpudev, prioritylevel, vector);
 
2021
}
 
2022
 
 
2023
void m68307_mbus_interrupt(legacy_cpu_device *cpudev)
 
2024
{
 
2025
        m68ki_cpu_core* m68k = m68k_get_safe_token(cpudev);
 
2026
        int prioritylevel = (m68k->m68307SIM->m_picr & 0x0007)>>0;
 
2027
        int vector        = (m68k->m68307SIM->m_pivr & 0x00f0) | 0xd;
 
2028
        m68307_set_interrupt(cpudev, prioritylevel, vector);
 
2029
}
 
2030
 
 
2031
void m68307_licr2_interrupt(legacy_cpu_device *cpudev)
 
2032
{
 
2033
        m68ki_cpu_core* m68k = m68k_get_safe_token(cpudev);
 
2034
        int prioritylevel = (m68k->m68307SIM->m_licr2 & 0x0007)>>0;
 
2035
        int vector        = (m68k->m68307SIM->m_pivr & 0x00f0) | 0x9;
 
2036
        m68k->m68307SIM->m_licr2 |= 0x8;
 
2037
 
 
2038
 
 
2039
        m68307_set_interrupt(cpudev, prioritylevel, vector);
 
2040
}
 
2041
 
 
2042
 
 
2043
 
 
2044
static CPU_INIT( m68307 )
 
2045
{
 
2046
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
 
2047
 
 
2048
        CPU_INIT_CALL(m68000);
 
2049
 
 
2050
        /* basic CS logic, timers, mbus, serial logic
 
2051
       set via remappable register
 
2052
    */
 
2053
        new(&m68k->memory) m68k_memory_interface;
 
2054
        m68k->memory.init16_m68307(*m68k->program);
 
2055
 
 
2056
        m68k->m68307SIM    = new m68307_sim();
 
2057
        m68k->m68307MBUS   = new m68307_mbus();
 
2058
        m68k->m68307SERIAL = new m68307_serial();
 
2059
        m68k->m68307TIMER  = new m68307_timer();
 
2060
 
 
2061
        m68k->m68307TIMER->init(device);
 
2062
 
 
2063
        m68k->m68307SIM->reset();
 
2064
        m68k->m68307MBUS->reset();
 
2065
        m68k->m68307SERIAL->reset();
 
2066
        m68k->m68307TIMER->reset();
 
2067
 
 
2068
        m68k->internal = device->space(AS_PROGRAM);
 
2069
        m68k->m68307_base = 0xbfff;
 
2070
        m68k->m68307_scrhigh = 0x0007;
 
2071
        m68k->m68307_scrlow = 0xf010;
 
2072
 
 
2073
        m68307_set_port_callbacks(device, 0,0,0,0);
 
2074
}
 
2075
 
 
2076
static READ16_HANDLER( m68307_internal_base_r )
 
2077
{
 
2078
        m68ki_cpu_core *m68k = m68k_get_safe_token(&space->device());
 
2079
 
 
2080
        int pc = cpu_get_pc(&space->device());
 
2081
        logerror("%08x m68307_internal_base_r %08x, (%04x)\n", pc, offset*2,mem_mask);
 
2082
 
 
2083
        switch (offset<<1)
 
2084
        {
 
2085
                case 0x2: return m68k->m68307_base;
 
2086
                case 0x4: return m68k->m68307_scrhigh;
 
2087
                case 0x6: return m68k->m68307_scrlow;
 
2088
        }
 
2089
 
 
2090
        logerror("(read was illegal?)\n");
 
2091
 
 
2092
        return 0x0000;
 
2093
}
 
2094
 
 
2095
static WRITE16_HANDLER( m68307_internal_base_w )
 
2096
{
 
2097
        m68ki_cpu_core *m68k = m68k_get_safe_token(&space->device());
 
2098
 
 
2099
        int pc = cpu_get_pc(&space->device());
 
2100
        logerror("%08x m68307_internal_base_w %08x, %04x (%04x)\n", pc, offset*2,data,mem_mask);
 
2101
        int base = 0;
 
2102
        //int mask = 0;
 
2103
 
 
2104
        switch (offset<<1)
 
2105
        {
 
2106
                case 0x2:
 
2107
                        /* remove old internal handler */
 
2108
                        base = (m68k->m68307_base & 0x0fff) << 12;
 
2109
                        //mask = (m68k->m68307_base & 0xe000) >> 13;
 
2110
                        //if ( m68k->m68307_base & 0x1000 ) mask |= 7;
 
2111
                m68k->internal->unmap_readwrite(base+0x000, base+0x04f);
 
2112
                m68k->internal->unmap_readwrite(base+0x100, base+0x11f);
 
2113
                m68k->internal->unmap_readwrite(base+0x120, base+0x13f);
 
2114
                m68k->internal->unmap_readwrite(base+0x140, base+0x149);
 
2115
 
 
2116
                        /* store new base address */
 
2117
                        COMBINE_DATA(&m68k->m68307_base);
 
2118
 
 
2119
                        /* install new internal handler */
 
2120
                        base = (m68k->m68307_base & 0x0fff) << 12;
 
2121
                        //mask = (m68k->m68307_base & 0xe000) >> 13;
 
2122
                        //if ( m68k->m68307_base & 0x1000 ) mask |= 7;
 
2123
                        m68k->internal->install_legacy_readwrite_handler(base + 0x000, base + 0x04f, FUNC(m68307_internal_sim_r),    FUNC(m68307_internal_sim_w));
 
2124
                        m68k->internal->install_legacy_readwrite_handler(base + 0x100, base + 0x11f, FUNC(m68307_internal_serial_r), FUNC(m68307_internal_serial_w), 0xffff);
 
2125
                        m68k->internal->install_legacy_readwrite_handler(base + 0x120, base + 0x13f, FUNC(m68307_internal_timer_r),  FUNC(m68307_internal_timer_w));
 
2126
                        m68k->internal->install_legacy_readwrite_handler(base + 0x140, base + 0x149, FUNC(m68307_internal_mbus_r),   FUNC(m68307_internal_mbus_w), 0xffff);
 
2127
 
 
2128
                        break;
 
2129
 
 
2130
                case 0x4:
 
2131
                        COMBINE_DATA(&m68k->m68307_scrhigh);
 
2132
                        break;
 
2133
 
 
2134
                case 0x6:
 
2135
                        COMBINE_DATA(&m68k->m68307_scrlow);
 
2136
                        break;
 
2137
 
 
2138
                default:
 
2139
                        logerror("(write was illegal?)\n");
 
2140
                        break;
 
2141
        }
 
2142
}
 
2143
 
 
2144
static ADDRESS_MAP_START( m68307_internal_map, AS_PROGRAM, 16, legacy_cpu_device )
 
2145
        AM_RANGE(0x000000f0, 0x000000ff) AM_READWRITE_LEGACY(m68307_internal_base_r, m68307_internal_base_w)
 
2146
ADDRESS_MAP_END
 
2147
 
 
2148
CPU_GET_INFO( m68307 )
 
2149
{
 
2150
        switch (state)
 
2151
        {
 
2152
                case DEVINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM:    info->i = 24;                                                   break;
 
2153
 
 
2154
                /* --- the following bits of info are returned as pointers to data or functions --- */
 
2155
                case CPUINFO_FCT_INIT:                                          info->init = CPU_INIT_NAME(m68307);                             break;
 
2156
 
 
2157
                /* --- the following bits of info are returned as NULL-terminated strings --- */
 
2158
                case DEVINFO_STR_NAME:                                          strcpy(info->s, "68307");                                               break;
 
2159
 
 
2160
                case DEVINFO_PTR_INTERNAL_MEMORY_MAP + AS_PROGRAM: info->internal_map16 = ADDRESS_MAP_NAME(m68307_internal_map); break;
 
2161
 
 
2162
 
 
2163
                default:                                                                        CPU_GET_INFO_CALL(m68k);                                                break;
 
2164
        }
 
2165
}
 
2166
 
1819
2167
 
1820
2168
/****************************************************************************
1821
2169
 * M68008 section
1823
2171
 
1824
2172
static CPU_INIT( m68008 )
1825
2173
{
1826
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2174
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1827
2175
 
1828
2176
        CPU_INIT_CALL(m68k);
1829
2177
 
1896
2244
 
1897
2245
static CPU_INIT( m68010 )
1898
2246
{
1899
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2247
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1900
2248
 
1901
2249
        CPU_INIT_CALL(m68k);
1902
2250
 
1947
2295
 
1948
2296
static CPU_INIT( m68020 )
1949
2297
{
1950
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2298
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
1951
2299
 
1952
2300
        CPU_INIT_CALL(m68k);
1953
2301
 
2000
2348
// 68020 with 68851 PMMU
2001
2349
static CPU_INIT( m68020pmmu )
2002
2350
{
2003
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2351
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2004
2352
 
2005
2353
        CPU_INIT_CALL(m68020);
2006
2354
 
2031
2379
// 68020 with Apple HMMU & 68881 FPU
2032
2380
static CPU_INIT( m68020hmmu )
2033
2381
{
2034
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2382
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2035
2383
 
2036
2384
        CPU_INIT_CALL(m68020);
2037
2385
 
2065
2413
 
2066
2414
static CPU_INIT( m68ec020 )
2067
2415
{
2068
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2416
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2069
2417
 
2070
2418
        CPU_INIT_CALL(m68k);
2071
2419
 
2118
2466
 
2119
2467
static CPU_INIT( m68030 )
2120
2468
{
2121
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2469
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2122
2470
 
2123
2471
        CPU_INIT_CALL(m68k);
2124
2472
 
2177
2525
 
2178
2526
static CPU_INIT( m68ec030 )
2179
2527
{
2180
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2528
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2181
2529
 
2182
2530
        CPU_INIT_CALL(m68k);
2183
2531
 
2227
2575
 
2228
2576
static CPU_INIT( m68040 )
2229
2577
{
2230
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2578
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2231
2579
 
2232
2580
        CPU_INIT_CALL(m68k);
2233
2581
 
2285
2633
 
2286
2634
static CPU_INIT( m68ec040 )
2287
2635
{
2288
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2636
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2289
2637
 
2290
2638
        CPU_INIT_CALL(m68k);
2291
2639
 
2335
2683
 
2336
2684
static CPU_INIT( m68lc040 )
2337
2685
{
2338
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2686
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2339
2687
 
2340
2688
        CPU_INIT_CALL(m68k);
2341
2689
 
2385
2733
 
2386
2734
static CPU_INIT( scc68070 )
2387
2735
{
2388
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2736
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2389
2737
 
2390
2738
        CPU_INIT_CALL(m68010);
2391
2739
 
2413
2761
 * Freescale M68340 section
2414
2762
 ****************************************************************************/
2415
2763
 
 
2764
static READ32_HANDLER( m68340_internal_base_r )
 
2765
{
 
2766
        m68ki_cpu_core *m68k = m68k_get_safe_token(&space->device());
 
2767
        int pc = cpu_get_pc(&space->device());
 
2768
        logerror("%08x m68340_internal_base_r %08x, (%08x)\n", pc, offset*4,mem_mask);
 
2769
        return m68k->m68340_base;
 
2770
}
 
2771
 
 
2772
static WRITE32_HANDLER( m68340_internal_base_w )
 
2773
{
 
2774
        m68ki_cpu_core *m68k = m68k_get_safe_token(&space->device());
 
2775
 
 
2776
        int pc = cpu_get_pc(&space->device());
 
2777
        logerror("%08x m68340_internal_base_w %08x, %08x (%08x)\n", pc, offset*4,data,mem_mask);
 
2778
 
 
2779
        // other conditions?
 
2780
        if (m68k->dfc==0x7)
 
2781
        {
 
2782
                // unmap old modules
 
2783
                if (m68k->m68340_base&1)
 
2784
                {
 
2785
                        int base = m68k->m68340_base & 0xfffff000;
 
2786
 
 
2787
                        m68k->internal->unmap_readwrite(base + 0x000, base + 0x05f);
 
2788
                        m68k->internal->unmap_readwrite(base + 0x600, base + 0x67f);
 
2789
                        m68k->internal->unmap_readwrite(base + 0x700, base + 0x723);
 
2790
                        m68k->internal->unmap_readwrite(base + 0x780, base + 0x7bf);
 
2791
 
 
2792
                }
 
2793
 
 
2794
                COMBINE_DATA(&m68k->m68340_base);
 
2795
                logerror("%08x m68340_internal_base_w %08x, %08x (%08x) (m68340_base write)\n", pc, offset*4,data,mem_mask);
 
2796
 
 
2797
                // map new modules
 
2798
                if (m68k->m68340_base&1)
 
2799
                {
 
2800
                        int base = m68k->m68340_base & 0xfffff000;
 
2801
 
 
2802
                        m68k->internal->install_legacy_readwrite_handler(base + 0x000, base + 0x03f, FUNC(m68340_internal_sim_r),    FUNC(m68340_internal_sim_w),0xffffffff);
 
2803
                        m68k->internal->install_legacy_readwrite_handler(base + 0x010, base + 0x01f, FUNC(m68340_internal_sim_ports_r), FUNC(m68340_internal_sim_ports_w),0xffffffff);
 
2804
                        m68k->internal->install_legacy_readwrite_handler(base + 0x040, base + 0x05f, FUNC(m68340_internal_sim_cs_r), FUNC(m68340_internal_sim_cs_w));
 
2805
                        m68k->internal->install_legacy_readwrite_handler(base + 0x600, base + 0x67f, FUNC(m68340_internal_timer_r),  FUNC(m68340_internal_timer_w));
 
2806
                        m68k->internal->install_legacy_readwrite_handler(base + 0x700, base + 0x723, FUNC(m68340_internal_serial_r), FUNC(m68340_internal_serial_w));
 
2807
                        m68k->internal->install_legacy_readwrite_handler(base + 0x780, base + 0x7bf, FUNC(m68340_internal_dma_r),    FUNC(m68340_internal_dma_w));
 
2808
 
 
2809
                }
 
2810
 
 
2811
        }
 
2812
        else
 
2813
        {
 
2814
                logerror("%08x m68340_internal_base_w %08x, %04x (%04x) (should fall through?)\n", pc, offset*4,data,mem_mask);
 
2815
        }
 
2816
 
 
2817
 
 
2818
 
 
2819
}
 
2820
 
 
2821
 
 
2822
static ADDRESS_MAP_START( m68340_internal_map, AS_PROGRAM, 32, legacy_cpu_device )
 
2823
        AM_RANGE(0x0003ff00, 0x0003ff03) AM_READWRITE_LEGACY( m68340_internal_base_r, m68340_internal_base_w)
 
2824
ADDRESS_MAP_END
2416
2825
 
2417
2826
static CPU_INIT( m68340 )
2418
2827
{
2419
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2828
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2420
2829
 
2421
2830
        CPU_INIT_CALL(m68k);
2422
2831
 
2441
2850
        m68k->cyc_shift        = 0;
2442
2851
        m68k->cyc_reset        = 518;
2443
2852
 
 
2853
        m68k->m68340SIM    = new m68340_sim();
 
2854
        m68k->m68340DMA    = new m68340_dma();
 
2855
        m68k->m68340SERIAL = new m68340_serial();
 
2856
        m68k->m68340TIMER  = new m68340_timer();
 
2857
 
 
2858
        m68k->m68340SIM->reset();
 
2859
        m68k->m68340DMA->reset();
 
2860
        m68k->m68340SERIAL->reset();
 
2861
        m68k->m68340TIMER->reset();
 
2862
 
 
2863
        m68k->m68340_base = 0x00000000;
 
2864
 
 
2865
        m68k->internal = device->space(AS_PROGRAM);
 
2866
 
2444
2867
        define_state(device);
2445
2868
}
2446
2869
 
2456
2879
                case DEVINFO_INT_DATABUS_WIDTH + AS_PROGRAM:                    info->i = 32;                                                   break;
2457
2880
                case DEVINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM:            info->i = 32;                                                   break;
2458
2881
 
 
2882
                case DEVINFO_PTR_INTERNAL_MEMORY_MAP + AS_PROGRAM: info->internal_map32 = ADDRESS_MAP_NAME(m68340_internal_map); break;
 
2883
 
2459
2884
                /* --- the following bits of info are returned as pointers to data or functions --- */
2460
2885
                case CPUINFO_FCT_INIT:                  info->init = CPU_INIT_NAME(m68340);                                             break;
2461
2886
 
2473
2898
 
2474
2899
static CPU_INIT( coldfire )
2475
2900
{
2476
 
        m68ki_cpu_core *m68k = get_safe_token(device);
 
2901
        m68ki_cpu_core *m68k = m68k_get_safe_token(device);
2477
2902
 
2478
2903
        CPU_INIT_CALL(m68k);
2479
2904
 
2524
2949
}
2525
2950
 
2526
2951
DEFINE_LEGACY_CPU_DEVICE(M68000, m68000);
 
2952
DEFINE_LEGACY_CPU_DEVICE(M68301, m68301);
 
2953
DEFINE_LEGACY_CPU_DEVICE(M68307, m68307);
2527
2954
DEFINE_LEGACY_CPU_DEVICE(M68008, m68008);
2528
2955
DEFINE_LEGACY_CPU_DEVICE(M68008PLCC, m68008plcc);
2529
2956
DEFINE_LEGACY_CPU_DEVICE(M68010, m68010);