From 326b68d7f39461c7d2338e005163e69c59617fdf Mon Sep 17 00:00:00 2001 From: MooglyGuy Date: Tue, 30 Jan 2024 01:40:51 +0100 Subject: [PATCH] sa1110.cpp: Re-worked to use map() instead of switch/case handlers. [Ryan Holtz] (#11981) Co-authored-by: Ryan Holtz --- src/devices/machine/sa1110.cpp | 2849 ++++++++++++++++++-------------- src/devices/machine/sa1110.h | 498 ++++-- src/devices/machine/sa1111.cpp | 20 +- src/devices/sound/uda1344.cpp | 6 +- src/mame/hp/jornada.cpp | 364 ++-- src/mame/sharp/zaurus.cpp | 9 +- 6 files changed, 2219 insertions(+), 1527 deletions(-) diff --git a/src/devices/machine/sa1110.cpp b/src/devices/machine/sa1110.cpp index 2f513abad7f..3e1c2f95f77 100644 --- a/src/devices/machine/sa1110.cpp +++ b/src/devices/machine/sa1110.cpp @@ -35,7 +35,7 @@ DEFINE_DEVICE_TYPE(SA1110_PERIPHERALS, sa1110_periphs_device, "sa1110_periphs", "Intel XScale SA1110 Peripherals") -sa1110_periphs_device::sa1110_periphs_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) +sa1110_periphs_device::sa1110_periphs_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) : device_t(mconfig, SA1110_PERIPHERALS, tag, owner, clock) , device_serial_interface(mconfig, *this) , m_maincpu(*this, finder_base::DUMMY_TAG) @@ -48,6 +48,151 @@ sa1110_periphs_device::sa1110_periphs_device(const machine_config &mconfig, cons { } +void sa1110_periphs_device::map(address_map &map) +{ + map(0x00000000, 0x00000003).rw(FUNC(sa1110_periphs_device::udc_udccr_r), FUNC(sa1110_periphs_device::udc_udccr_w)); + map(0x00000004, 0x00000007).rw(FUNC(sa1110_periphs_device::udc_udcar_r), FUNC(sa1110_periphs_device::udc_udcar_w)); + map(0x00000008, 0x0000000b).rw(FUNC(sa1110_periphs_device::udc_udcomp_r), FUNC(sa1110_periphs_device::udc_udcomp_w)); + map(0x0000000c, 0x0000000f).rw(FUNC(sa1110_periphs_device::udc_udcimp_r), FUNC(sa1110_periphs_device::udc_udcimp_w)); + map(0x00000010, 0x00000013).rw(FUNC(sa1110_periphs_device::udc_udccs0_r), FUNC(sa1110_periphs_device::udc_udccs0_w)); + map(0x00000014, 0x00000017).rw(FUNC(sa1110_periphs_device::udc_udccs1_r), FUNC(sa1110_periphs_device::udc_udccs1_w)); + map(0x00000018, 0x0000001b).rw(FUNC(sa1110_periphs_device::udc_udccs2_r), FUNC(sa1110_periphs_device::udc_udccs2_w)); + map(0x0000001c, 0x0000001f).rw(FUNC(sa1110_periphs_device::udc_udcd0_r), FUNC(sa1110_periphs_device::udc_udcd0_w)); + map(0x00000020, 0x00000023).rw(FUNC(sa1110_periphs_device::udc_udcwc_r), FUNC(sa1110_periphs_device::udc_udcwc_w)); + map(0x00000028, 0x0000002b).rw(FUNC(sa1110_periphs_device::udc_udcdr_r), FUNC(sa1110_periphs_device::udc_udcdr_w)); + map(0x00000030, 0x00000033).rw(FUNC(sa1110_periphs_device::udc_udcsr_r), FUNC(sa1110_periphs_device::udc_udcsr_w)); + + map(0x00030000, 0x00030003).rw(FUNC(sa1110_periphs_device::icp_utcr0_r), FUNC(sa1110_periphs_device::icp_utcr0_w)); + map(0x00030004, 0x00030007).rw(FUNC(sa1110_periphs_device::icp_utcr1_r), FUNC(sa1110_periphs_device::icp_utcr1_w)); + map(0x00030008, 0x0003000b).rw(FUNC(sa1110_periphs_device::icp_utcr2_r), FUNC(sa1110_periphs_device::icp_utcr2_w)); + map(0x0003000c, 0x0003000f).rw(FUNC(sa1110_periphs_device::icp_utcr3_r), FUNC(sa1110_periphs_device::icp_utcr3_w)); + map(0x00030010, 0x00030013).rw(FUNC(sa1110_periphs_device::icp_utcr4_r), FUNC(sa1110_periphs_device::icp_utcr4_w)); + map(0x00030014, 0x00030017).rw(FUNC(sa1110_periphs_device::icp_utdr_r), FUNC(sa1110_periphs_device::icp_utdr_w)); + map(0x0003001c, 0x0003001f).rw(FUNC(sa1110_periphs_device::icp_utcr0_r), FUNC(sa1110_periphs_device::icp_utcr0_w)); + map(0x00030020, 0x00030023).r(FUNC(sa1110_periphs_device::icp_utcr1_r)); + map(0x00030060, 0x00030063).rw(FUNC(sa1110_periphs_device::icp_hscr0_r), FUNC(sa1110_periphs_device::icp_hscr0_w)); + map(0x00030064, 0x00030067).rw(FUNC(sa1110_periphs_device::icp_hscr1_r), FUNC(sa1110_periphs_device::icp_hscr1_w)); + map(0x0003006c, 0x0003006f).rw(FUNC(sa1110_periphs_device::icp_hsdr_r), FUNC(sa1110_periphs_device::icp_hsdr_w)); + map(0x00030074, 0x00030077).rw(FUNC(sa1110_periphs_device::icp_hssr0_r), FUNC(sa1110_periphs_device::icp_hssr0_w)); + map(0x00030078, 0x0003007b).rw(FUNC(sa1110_periphs_device::icp_hssr1_r), FUNC(sa1110_periphs_device::icp_hssr1_w)); + + map(0x00050000, 0x00050003).rw(FUNC(sa1110_periphs_device::uart3_utcr0_r), FUNC(sa1110_periphs_device::uart3_utcr0_w)); + map(0x00050004, 0x00050007).rw(FUNC(sa1110_periphs_device::uart3_utcr1_r), FUNC(sa1110_periphs_device::uart3_utcr1_w)); + map(0x00050008, 0x0005000b).rw(FUNC(sa1110_periphs_device::uart3_utcr2_r), FUNC(sa1110_periphs_device::uart3_utcr2_w)); + map(0x0005000c, 0x0005000f).rw(FUNC(sa1110_periphs_device::uart3_utcr3_r), FUNC(sa1110_periphs_device::uart3_utcr3_w)); + map(0x00050014, 0x00050017).rw(FUNC(sa1110_periphs_device::uart3_utdr_r), FUNC(sa1110_periphs_device::uart3_utdr_w)); + map(0x0005001c, 0x0005001f).r(FUNC(sa1110_periphs_device::uart3_utsr0_r)); + map(0x00050020, 0x00050023).rw(FUNC(sa1110_periphs_device::uart3_utsr1_r), FUNC(sa1110_periphs_device::uart3_utsr1_w)); + + map(0x00060000, 0x00060003).rw(FUNC(sa1110_periphs_device::mcp_mccr0_r), FUNC(sa1110_periphs_device::mcp_mccr0_w)); + map(0x00060008, 0x0006000b).rw(FUNC(sa1110_periphs_device::mcp_mcdr0_r), FUNC(sa1110_periphs_device::mcp_mcdr0_w)); + map(0x0006000c, 0x0006000f).rw(FUNC(sa1110_periphs_device::mcp_mcdr1_r), FUNC(sa1110_periphs_device::mcp_mcdr1_w)); + map(0x00060010, 0x00060013).rw(FUNC(sa1110_periphs_device::mcp_mcdr2_r), FUNC(sa1110_periphs_device::mcp_mcdr2_w)); + map(0x00060018, 0x0006001b).rw(FUNC(sa1110_periphs_device::mcp_mcsr_r), FUNC(sa1110_periphs_device::mcp_mcsr_w)); + + map(0x00070060, 0x00070063).rw(FUNC(sa1110_periphs_device::ssp_sscr0_r), FUNC(sa1110_periphs_device::ssp_sscr0_w)); + map(0x00070064, 0x00070067).rw(FUNC(sa1110_periphs_device::ssp_sscr1_r), FUNC(sa1110_periphs_device::ssp_sscr1_w)); + map(0x0007006c, 0x0007006f).rw(FUNC(sa1110_periphs_device::ssp_ssdr_r), FUNC(sa1110_periphs_device::ssp_ssdr_w)); + map(0x00070074, 0x00070077).rw(FUNC(sa1110_periphs_device::ssp_sssr_r), FUNC(sa1110_periphs_device::ssp_sssr_w)); + + map(0x10000000, 0x10000003).rw(FUNC(sa1110_periphs_device::tmr_osmr0_r), FUNC(sa1110_periphs_device::tmr_osmr0_w)); + map(0x10000004, 0x10000007).rw(FUNC(sa1110_periphs_device::tmr_osmr1_r), FUNC(sa1110_periphs_device::tmr_osmr1_w)); + map(0x10000008, 0x1000000b).rw(FUNC(sa1110_periphs_device::tmr_osmr2_r), FUNC(sa1110_periphs_device::tmr_osmr2_w)); + map(0x1000000c, 0x1000000f).rw(FUNC(sa1110_periphs_device::tmr_osmr3_r), FUNC(sa1110_periphs_device::tmr_osmr3_w)); + map(0x10000010, 0x10000013).rw(FUNC(sa1110_periphs_device::tmr_oscr_r), FUNC(sa1110_periphs_device::tmr_oscr_w)); + map(0x10000014, 0x10000017).rw(FUNC(sa1110_periphs_device::tmr_ossr_r), FUNC(sa1110_periphs_device::tmr_ossr_w)); + map(0x10000018, 0x1000001b).rw(FUNC(sa1110_periphs_device::tmr_ower_r), FUNC(sa1110_periphs_device::tmr_ower_w)); + map(0x1000001c, 0x1000001f).rw(FUNC(sa1110_periphs_device::tmr_oier_r), FUNC(sa1110_periphs_device::tmr_oier_w)); + + map(0x10010000, 0x10010003).rw(FUNC(sa1110_periphs_device::rtc_rtar_r), FUNC(sa1110_periphs_device::rtc_rtar_w)); + map(0x10010004, 0x10010007).rw(FUNC(sa1110_periphs_device::rtc_rcnr_r), FUNC(sa1110_periphs_device::rtc_rcnr_w)); + map(0x10010008, 0x1001000b).rw(FUNC(sa1110_periphs_device::rtc_rttr_r), FUNC(sa1110_periphs_device::rtc_rttr_w)); + map(0x10010010, 0x10010013).rw(FUNC(sa1110_periphs_device::rtc_rtsr_r), FUNC(sa1110_periphs_device::rtc_rtsr_w)); + + map(0x10020000, 0x10020003).rw(FUNC(sa1110_periphs_device::pwr_pmcr_r), FUNC(sa1110_periphs_device::pwr_pmcr_w)); + map(0x10020004, 0x10020007).rw(FUNC(sa1110_periphs_device::pwr_pssr_r), FUNC(sa1110_periphs_device::pwr_pssr_w)); + map(0x10020008, 0x1002000b).rw(FUNC(sa1110_periphs_device::pwr_pspr_r), FUNC(sa1110_periphs_device::pwr_pspr_w)); + map(0x1002000c, 0x1002000f).rw(FUNC(sa1110_periphs_device::pwr_pwer_r), FUNC(sa1110_periphs_device::pwr_pwer_w)); + map(0x10020010, 0x10020013).rw(FUNC(sa1110_periphs_device::pwr_pcfr_r), FUNC(sa1110_periphs_device::pwr_pcfr_w)); + map(0x10020014, 0x10020017).rw(FUNC(sa1110_periphs_device::pwr_ppcr_r), FUNC(sa1110_periphs_device::pwr_ppcr_w)); + map(0x10020018, 0x1002001b).rw(FUNC(sa1110_periphs_device::pwr_pgsr_r), FUNC(sa1110_periphs_device::pwr_pgsr_w)); + map(0x1002001c, 0x1002001f).rw(FUNC(sa1110_periphs_device::pwr_posr_r), FUNC(sa1110_periphs_device::pwr_posr_w)); + + map(0x10030000, 0x10030003).rw(FUNC(sa1110_periphs_device::rst_rsrr_r), FUNC(sa1110_periphs_device::rst_rsrr_w)); + map(0x10030004, 0x10030007).rw(FUNC(sa1110_periphs_device::rst_rcsr_r), FUNC(sa1110_periphs_device::rst_rcsr_w)); + + map(0x10040000, 0x10040003).rw(FUNC(sa1110_periphs_device::gpio_gplr_r), FUNC(sa1110_periphs_device::gpio_gplr_w)); + map(0x10040004, 0x10040007).rw(FUNC(sa1110_periphs_device::gpio_gpdr_r), FUNC(sa1110_periphs_device::gpio_gpdr_w)); + map(0x10040008, 0x1004000b).rw(FUNC(sa1110_periphs_device::gpio_gpsr_r), FUNC(sa1110_periphs_device::gpio_gpsr_w)); + map(0x1004000c, 0x1004000f).rw(FUNC(sa1110_periphs_device::gpio_gpcr_r), FUNC(sa1110_periphs_device::gpio_gpcr_w)); + map(0x10040010, 0x10040013).rw(FUNC(sa1110_periphs_device::gpio_grer_r), FUNC(sa1110_periphs_device::gpio_grer_w)); + map(0x10040014, 0x10040017).rw(FUNC(sa1110_periphs_device::gpio_gfer_r), FUNC(sa1110_periphs_device::gpio_gfer_w)); + map(0x10040018, 0x1004001b).rw(FUNC(sa1110_periphs_device::gpio_gedr_r), FUNC(sa1110_periphs_device::gpio_gedr_w)); + map(0x1004001c, 0x1004001f).rw(FUNC(sa1110_periphs_device::gpio_gafr_r), FUNC(sa1110_periphs_device::gpio_gafr_w)); + + map(0x10050000, 0x10050003).rw(FUNC(sa1110_periphs_device::intc_icip_r), FUNC(sa1110_periphs_device::intc_icip_w)); + map(0x10050004, 0x10050007).rw(FUNC(sa1110_periphs_device::intc_icmr_r), FUNC(sa1110_periphs_device::intc_icmr_w)); + map(0x10050008, 0x1005000b).rw(FUNC(sa1110_periphs_device::intc_iclr_r), FUNC(sa1110_periphs_device::intc_iclr_w)); + map(0x1005000c, 0x1005000f).rw(FUNC(sa1110_periphs_device::intc_iccr_r), FUNC(sa1110_periphs_device::intc_iccr_w)); + map(0x10050010, 0x10050013).rw(FUNC(sa1110_periphs_device::intc_icfp_r), FUNC(sa1110_periphs_device::intc_icfp_w)); + map(0x10050014, 0x10050017).rw(FUNC(sa1110_periphs_device::intc_icpr_r), FUNC(sa1110_periphs_device::intc_icpr_w)); + + map(0x10060000, 0x10060003).rw(FUNC(sa1110_periphs_device::ppc_ppdr_r), FUNC(sa1110_periphs_device::ppc_ppdr_w)); + map(0x10060004, 0x10060007).rw(FUNC(sa1110_periphs_device::ppc_ppsr_r), FUNC(sa1110_periphs_device::ppc_ppsr_w)); + map(0x10060008, 0x1006000b).rw(FUNC(sa1110_periphs_device::ppc_ppar_r), FUNC(sa1110_periphs_device::ppc_ppar_w)); + map(0x1006000c, 0x1006000f).rw(FUNC(sa1110_periphs_device::ppc_psdr_r), FUNC(sa1110_periphs_device::ppc_psdr_w)); + map(0x10060010, 0x10060013).rw(FUNC(sa1110_periphs_device::ppc_ppfr_r), FUNC(sa1110_periphs_device::ppc_ppfr_w)); + + map(0x30000000, 0x30000003).rw(FUNC(sa1110_periphs_device::dma_ddar_r<0>), FUNC(sa1110_periphs_device::dma_ddar_w<0>)); + map(0x30000004, 0x30000007).rw(FUNC(sa1110_periphs_device::dma_dssr_r<0>), FUNC(sa1110_periphs_device::dma_dssr_w<0>)); + map(0x30000008, 0x3000000b).rw(FUNC(sa1110_periphs_device::dma_dcsr_r<0>), FUNC(sa1110_periphs_device::dma_dcsr_w<0>)); + map(0x3000000c, 0x3000000f).rw(FUNC(sa1110_periphs_device::dma_dsr_r<0>), FUNC(sa1110_periphs_device::dma_dsr_w<0>)); + map(0x30000010, 0x30000013).rw(FUNC(sa1110_periphs_device::dma_dbsa_r<0>), FUNC(sa1110_periphs_device::dma_dbsa_w<0>)); + map(0x30000014, 0x30000017).rw(FUNC(sa1110_periphs_device::dma_dbta_r<0>), FUNC(sa1110_periphs_device::dma_dbta_w<0>)); + map(0x30000018, 0x3000001b).rw(FUNC(sa1110_periphs_device::dma_dbsb_r<0>), FUNC(sa1110_periphs_device::dma_dbsb_w<0>)); + map(0x3000001c, 0x3000001f).rw(FUNC(sa1110_periphs_device::dma_dbtb_r<0>), FUNC(sa1110_periphs_device::dma_dbtb_w<0>)); + map(0x30000020, 0x30000023).rw(FUNC(sa1110_periphs_device::dma_ddar_r<1>), FUNC(sa1110_periphs_device::dma_ddar_w<1>)); + map(0x30000024, 0x30000027).rw(FUNC(sa1110_periphs_device::dma_dssr_r<1>), FUNC(sa1110_periphs_device::dma_dssr_w<1>)); + map(0x30000028, 0x3000002b).rw(FUNC(sa1110_periphs_device::dma_dcsr_r<1>), FUNC(sa1110_periphs_device::dma_dcsr_w<1>)); + map(0x3000002c, 0x3000002f).rw(FUNC(sa1110_periphs_device::dma_dsr_r<1>), FUNC(sa1110_periphs_device::dma_dsr_w<1>)); + map(0x30000030, 0x30000033).rw(FUNC(sa1110_periphs_device::dma_dbsa_r<1>), FUNC(sa1110_periphs_device::dma_dbsa_w<1>)); + map(0x30000034, 0x30000037).rw(FUNC(sa1110_periphs_device::dma_dbta_r<1>), FUNC(sa1110_periphs_device::dma_dbta_w<1>)); + map(0x30000038, 0x3000003b).rw(FUNC(sa1110_periphs_device::dma_dbsb_r<1>), FUNC(sa1110_periphs_device::dma_dbsb_w<1>)); + map(0x3000003c, 0x3000003f).rw(FUNC(sa1110_periphs_device::dma_dbtb_r<1>), FUNC(sa1110_periphs_device::dma_dbtb_w<1>)); + map(0x30000040, 0x30000043).rw(FUNC(sa1110_periphs_device::dma_ddar_r<2>), FUNC(sa1110_periphs_device::dma_ddar_w<2>)); + map(0x30000044, 0x30000047).rw(FUNC(sa1110_periphs_device::dma_dssr_r<2>), FUNC(sa1110_periphs_device::dma_dssr_w<2>)); + map(0x30000048, 0x3000004b).rw(FUNC(sa1110_periphs_device::dma_dcsr_r<2>), FUNC(sa1110_periphs_device::dma_dcsr_w<2>)); + map(0x3000004c, 0x3000004f).rw(FUNC(sa1110_periphs_device::dma_dsr_r<2>), FUNC(sa1110_periphs_device::dma_dsr_w<2>)); + map(0x30000050, 0x30000053).rw(FUNC(sa1110_periphs_device::dma_dbsa_r<2>), FUNC(sa1110_periphs_device::dma_dbsa_w<2>)); + map(0x30000054, 0x30000057).rw(FUNC(sa1110_periphs_device::dma_dbta_r<2>), FUNC(sa1110_periphs_device::dma_dbta_w<2>)); + map(0x30000058, 0x3000005b).rw(FUNC(sa1110_periphs_device::dma_dbsb_r<2>), FUNC(sa1110_periphs_device::dma_dbsb_w<2>)); + map(0x3000005c, 0x3000005f).rw(FUNC(sa1110_periphs_device::dma_dbtb_r<2>), FUNC(sa1110_periphs_device::dma_dbtb_w<2>)); + map(0x30000060, 0x30000063).rw(FUNC(sa1110_periphs_device::dma_ddar_r<3>), FUNC(sa1110_periphs_device::dma_ddar_w<3>)); + map(0x30000064, 0x30000067).rw(FUNC(sa1110_periphs_device::dma_dssr_r<3>), FUNC(sa1110_periphs_device::dma_dssr_w<3>)); + map(0x30000068, 0x3000006b).rw(FUNC(sa1110_periphs_device::dma_dcsr_r<3>), FUNC(sa1110_periphs_device::dma_dcsr_w<3>)); + map(0x3000006c, 0x3000006f).rw(FUNC(sa1110_periphs_device::dma_dsr_r<3>), FUNC(sa1110_periphs_device::dma_dsr_w<3>)); + map(0x30000070, 0x30000073).rw(FUNC(sa1110_periphs_device::dma_dbsa_r<3>), FUNC(sa1110_periphs_device::dma_dbsa_w<3>)); + map(0x30000074, 0x30000077).rw(FUNC(sa1110_periphs_device::dma_dbta_r<3>), FUNC(sa1110_periphs_device::dma_dbta_w<3>)); + map(0x30000078, 0x3000007b).rw(FUNC(sa1110_periphs_device::dma_dbsb_r<3>), FUNC(sa1110_periphs_device::dma_dbsb_w<3>)); + map(0x3000007c, 0x3000007f).rw(FUNC(sa1110_periphs_device::dma_dbtb_r<3>), FUNC(sa1110_periphs_device::dma_dbtb_w<3>)); + map(0x30000080, 0x30000083).rw(FUNC(sa1110_periphs_device::dma_ddar_r<4>), FUNC(sa1110_periphs_device::dma_ddar_w<4>)); + map(0x30000084, 0x30000087).rw(FUNC(sa1110_periphs_device::dma_dssr_r<4>), FUNC(sa1110_periphs_device::dma_dssr_w<4>)); + map(0x30000088, 0x3000008b).rw(FUNC(sa1110_periphs_device::dma_dcsr_r<4>), FUNC(sa1110_periphs_device::dma_dcsr_w<4>)); + map(0x3000008c, 0x3000008f).rw(FUNC(sa1110_periphs_device::dma_dsr_r<4>), FUNC(sa1110_periphs_device::dma_dsr_w<4>)); + map(0x30000090, 0x30000093).rw(FUNC(sa1110_periphs_device::dma_dbsa_r<4>), FUNC(sa1110_periphs_device::dma_dbsa_w<4>)); + map(0x30000094, 0x30000097).rw(FUNC(sa1110_periphs_device::dma_dbta_r<4>), FUNC(sa1110_periphs_device::dma_dbta_w<4>)); + map(0x30000098, 0x3000009b).rw(FUNC(sa1110_periphs_device::dma_dbsb_r<4>), FUNC(sa1110_periphs_device::dma_dbsb_w<4>)); + map(0x3000009c, 0x3000009f).rw(FUNC(sa1110_periphs_device::dma_dbtb_r<4>), FUNC(sa1110_periphs_device::dma_dbtb_w<4>)); + map(0x300000a0, 0x300000a3).rw(FUNC(sa1110_periphs_device::dma_ddar_r<5>), FUNC(sa1110_periphs_device::dma_ddar_w<5>)); + map(0x300000a4, 0x300000a7).rw(FUNC(sa1110_periphs_device::dma_dssr_r<5>), FUNC(sa1110_periphs_device::dma_dssr_w<5>)); + map(0x300000a8, 0x300000ab).rw(FUNC(sa1110_periphs_device::dma_dcsr_r<5>), FUNC(sa1110_periphs_device::dma_dcsr_w<5>)); + map(0x300000ac, 0x300000af).rw(FUNC(sa1110_periphs_device::dma_dsr_r<5>), FUNC(sa1110_periphs_device::dma_dsr_w<5>)); + map(0x300000b0, 0x300000b3).rw(FUNC(sa1110_periphs_device::dma_dbsa_r<5>), FUNC(sa1110_periphs_device::dma_dbsa_w<5>)); + map(0x300000b4, 0x300000b7).rw(FUNC(sa1110_periphs_device::dma_dbta_r<5>), FUNC(sa1110_periphs_device::dma_dbta_w<5>)); + map(0x300000b8, 0x300000bb).rw(FUNC(sa1110_periphs_device::dma_dbsb_r<5>), FUNC(sa1110_periphs_device::dma_dbsb_w<5>)); + map(0x300000bc, 0x300000bf).rw(FUNC(sa1110_periphs_device::dma_dbtb_r<5>), FUNC(sa1110_periphs_device::dma_dbtb_w<5>)); +} + /* Intel SA-1110 UDC - USB Device Controller @@ -56,101 +201,147 @@ sa1110_periphs_device::sa1110_periphs_device(const machine_config &mconfig, cons */ -uint32_t sa1110_periphs_device::udc_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::udc_udccr_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_UDCCR: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Control Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udccr, mem_mask); - return m_udc_regs.udccr; - case REG_UDCAR: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Address Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udcar, mem_mask); - return m_udc_regs.udcar; - case REG_UDCOMP: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC OUT Max Packet Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udcomp, mem_mask); - return m_udc_regs.udcomp; - case REG_UDCIMP: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC IN Max Packet Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udcimp, mem_mask); - return m_udc_regs.udcimp; - case REG_UDCCS0: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Endpoint 0 Control/Status Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udccs0, mem_mask); - return m_udc_regs.udccs0; - case REG_UDCCS1: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Endpoint 1 (OUT) Control/Status Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udccs1, mem_mask); - return m_udc_regs.udccs1; - case REG_UDCCS2: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Endpoint 2 (IN) Control/Status Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udccs2, mem_mask); - return m_udc_regs.udccs2; - case REG_UDCD0: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Endpoint 0 Data Register: %08x & %08x\n", machine().describe_context(), 0, mem_mask); - return 0; - case REG_UDCWC: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Endpoint 0 Write Count Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udcwc, mem_mask); - return m_udc_regs.udcwc; - case REG_UDCDR: - //const uint32_t data = udc_rx_fifo_pop(); - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Data Register: %08x & %08x\n", machine().describe_context(), 0, mem_mask); - return 0; - case REG_UDCSR: - LOGMASKED(LOG_UDC, "%s: udc_r: UDC Status/Interrupt Register: %08x & %08x\n", machine().describe_context(), m_udc_regs.udcsr, mem_mask); - return m_udc_regs.udcsr; - default: - LOGMASKED(LOG_UDC | LOG_UNKNOWN, "%s: udc_r: Unknown address: %08x & %08x\n", machine().describe_context(), UDC_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_udc_regs.udccr; + LOGMASKED(LOG_UDC, "%s: udc_udccr_r: UDC Control Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::udc_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::udc_udccr_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_UDCCR: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Control Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udccr); - break; - case REG_UDCAR: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Address Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udcar); - break; - case REG_UDCOMP: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC OUT Max Packet Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udcomp); - break; - case REG_UDCIMP: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC IN Max Packet Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udcimp); - break; - case REG_UDCCS0: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Endpoint 0 Control/Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udccs0); - break; - case REG_UDCCS1: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Endpoint 1 (OUT) Control/Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udccs1); - break; - case REG_UDCCS2: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Endpoint 2 (IN) Control/Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udccs2); - break; - case REG_UDCD0: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Endpoint 0 Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_UDCWC: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Endpoint 0 Write Count Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_udc_regs.udcwc); - break; - case REG_UDCDR: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - return; - case REG_UDCSR: - LOGMASKED(LOG_UDC, "%s: udc_w: UDC Status/Interrupt Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - default: - LOGMASKED(LOG_UDC | LOG_UNKNOWN, "%s: udc_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), UDC_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + LOGMASKED(LOG_UDC, "%s: udc_udccr_w: UDC Control Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udccr); } +u32 sa1110_periphs_device::udc_udcar_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udcar; + LOGMASKED(LOG_UDC, "%s: udc_udcar_r: UDC Address Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcar_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcar_w: UDC Address Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udcar); +} + +u32 sa1110_periphs_device::udc_udcomp_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udcomp; + LOGMASKED(LOG_UDC, "%s: udc_udcomp_r: UDC OUT Max Packet Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcomp_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcomp_w: UDC OUT Max Packet Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udcomp); +} + +u32 sa1110_periphs_device::udc_udcimp_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udcimp; + LOGMASKED(LOG_UDC, "%s: udc_udiomp_r: UDC IN Max Packet Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcimp_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcimp_w: UDC IN Max Packet Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udcimp); +} + +u32 sa1110_periphs_device::udc_udccs0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udccs0; + LOGMASKED(LOG_UDC, "%s: udc_udccs0_r: UDC Endpoint 0 Control/Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udccs0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udccs0_w: UDC Endpoint 0 Control/Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udccs0); +} + +u32 sa1110_periphs_device::udc_udccs1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udccs1; + LOGMASKED(LOG_UDC, "%s: udc_udccs1_r: UDC Endpoint 1 (OUT) Control/Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udccs1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udccs1_w: UDC Endpoint 1 (OUT) Control/Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udccs1); +} + +u32 sa1110_periphs_device::udc_udccs2_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udccs2; + LOGMASKED(LOG_UDC, "%s: udc_udccs2_r: UDC Endpoint 2 (IN) Control/Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udccs2_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udccs2_w: UDC Endpoint 2 (IN) Control/Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udccs2); +} + +u32 sa1110_periphs_device::udc_udcd0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = 0; + LOGMASKED(LOG_UDC, "%s: udc_udcd0_r: UDC Endpoint 0 Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcd0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcd0_w: UDC Endpoint 0 Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::udc_udcwc_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udcwc; + LOGMASKED(LOG_UDC, "%s: udc_udcwc_r: UDC Endpoint 0 Write Count Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcwc_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcwc_w: UDC Endpoint 0 Write Count Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_udc_regs.udcwc); +} + +u32 sa1110_periphs_device::udc_udcdr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = 0; //udc_rx_fifo_pop(); + LOGMASKED(LOG_UDC, "%s: udc_udcdr_r: UDC Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcdr_w: UDC Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::udc_udcsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_udc_regs.udcsr; + LOGMASKED(LOG_UDC, "%s: udc_udcsr_r: UDC Status/Interrupt Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::udc_udcsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UDC, "%s: udc_udcsr_w: UDC Status/Interrupt Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + + /* Intel SA-1110 ICP - Serial Port 2 @@ -191,21 +382,21 @@ void sa1110_periphs_device::icp_uart_set_transmit_irq_enabled(bool enabled) { } -uint8_t sa1110_periphs_device::icp_uart_read_receive_fifo() +u8 sa1110_periphs_device::icp_uart_read_receive_fifo() { return 0; } -void sa1110_periphs_device::icp_uart_write_transmit_fifo(uint8_t data) +void sa1110_periphs_device::icp_uart_write_transmit_fifo(u8 data) { } -uint16_t sa1110_periphs_device::icp_hssp_read_receive_fifo() +u16 sa1110_periphs_device::icp_hssp_read_receive_fifo() { return 0; } -void sa1110_periphs_device::icp_hssp_write_transmit_fifo(uint8_t data) +void sa1110_periphs_device::icp_hssp_write_transmit_fifo(u8 data) { } @@ -221,182 +412,224 @@ void sa1110_periphs_device::icp_uart_end_of_break() { } - -uint32_t sa1110_periphs_device::icp_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::icp_utcr0_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_UTCR0: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Control Register 0: %08x & %08x\n", machine().describe_context(), m_icp_regs.uart.utcr[0], mem_mask); - return m_icp_regs.uart.utcr[0]; - case REG_UTCR1: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Control Register 1: %08x & %08x\n", machine().describe_context(), m_icp_regs.uart.utcr[1], mem_mask); - return m_icp_regs.uart.utcr[1]; - case REG_UTCR2: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Control Register 2: %08x & %08x\n", machine().describe_context(), m_icp_regs.uart.utcr[2], mem_mask); - return m_icp_regs.uart.utcr[2]; - case REG_UTCR3: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Control Register 3: %08x & %08x\n", machine().describe_context(), m_icp_regs.uart.utcr[3], mem_mask); - return m_icp_regs.uart.utcr[3]; - case REG_UTCR4: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Control Register 4: %08x & %08x\n", machine().describe_context(), m_icp_regs.utcr4, mem_mask); - return m_icp_regs.utcr4; - case REG_UTDR: - { - const uint8_t data = icp_uart_read_receive_fifo(); - LOGMASKED(LOG_ICP, "%s: icp_r: UART Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - return data; - } - case REG_UTSR0: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Status Register 0: %08x & %08x\n", machine().describe_context(), m_icp_regs.uart.utsr0, mem_mask); - return m_icp_regs.uart.utsr0; - case REG_UTSR1: - LOGMASKED(LOG_ICP, "%s: icp_r: UART Status Register 1: %08x & %08x\n", machine().describe_context(), m_icp_regs.uart.utsr1, mem_mask); - return m_icp_regs.uart.utsr1; - case REG_HSCR0: - LOGMASKED(LOG_ICP, "%s: icp_r: HSSP Control Register 0: %08x & %08x\n", machine().describe_context(), m_icp_regs.hssp.hscr0, mem_mask); - return m_icp_regs.hssp.hscr0; - case REG_HSCR1: - LOGMASKED(LOG_ICP, "%s: icp_r: HSSP Control Register 1: %08x & %08x\n", machine().describe_context(), m_icp_regs.hssp.hscr1, mem_mask); - return m_icp_regs.hssp.hscr1; - case REG_HSDR: - { - const uint16_t data = icp_hssp_read_receive_fifo(); - LOGMASKED(LOG_ICP, "%s: icp_r: HSSP Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - return data; - } - case REG_HSSR0: - LOGMASKED(LOG_ICP, "%s: icp_r: HSSP Status Register 0: %08x & %08x\n", machine().describe_context(), m_icp_regs.hssp.hssr0, mem_mask); - return m_icp_regs.hssp.hssr0; - case REG_HSSR1: - LOGMASKED(LOG_ICP, "%s: icp_r: HSSP Status Register 1: %08x & %08x\n", machine().describe_context(), m_icp_regs.hssp.hssr1, mem_mask); - return m_icp_regs.hssp.hssr1; - default: - LOGMASKED(LOG_ICP | LOG_UNKNOWN, "%s: icp_r: Unknown address: %08x & %08x\n", machine().describe_context(), ICP_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_icp_regs.uart.utcr[0]; + LOGMASKED(LOG_ICP, "%s: icp_utcr0_r: UART Control Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::icp_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::icp_utcr0_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_UTCR0: - { - LOGMASKED(LOG_ICP, "%s: icp_w: UART Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_ICP, "%s: Parity Enable: %d\n", machine().describe_context(), BIT(data, 0)); - LOGMASKED(LOG_ICP, "%s: Parity Mode: %s\n", machine().describe_context(), BIT(data, 1) ? "Even" : "Odd"); - LOGMASKED(LOG_ICP, "%s: Stop Bits: %d\n", machine().describe_context(), BIT(data, 2) + 1); - LOGMASKED(LOG_ICP, "%s: Data Size: %d\n", machine().describe_context(), BIT(data, 3) ? 8 : 7); - LOGMASKED(LOG_ICP, "%s: Sample Clock: %s\n", machine().describe_context(), BIT(data, 4) ? "External" : "Internal"); - LOGMASKED(LOG_ICP, "%s: Receive Edge: %s\n", machine().describe_context(), BIT(data, 5) ? "Falling" : "Rising"); - LOGMASKED(LOG_ICP, "%s: Transmit Edge: %s\n", machine().describe_context(), BIT(data, 6) ? "Falling" : "Rising"); + LOGMASKED(LOG_ICP, "%s: icp_utcr0_w: UART Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_ICP, "%s: Parity Enable: %d\n", machine().describe_context(), BIT(data, 0)); + LOGMASKED(LOG_ICP, "%s: Parity Mode: %s\n", machine().describe_context(), BIT(data, 1) ? "Even" : "Odd"); + LOGMASKED(LOG_ICP, "%s: Stop Bits: %d\n", machine().describe_context(), BIT(data, 2) + 1); + LOGMASKED(LOG_ICP, "%s: Data Size: %d\n", machine().describe_context(), BIT(data, 3) ? 8 : 7); + LOGMASKED(LOG_ICP, "%s: Sample Clock: %s\n", machine().describe_context(), BIT(data, 4) ? "External" : "Internal"); + LOGMASKED(LOG_ICP, "%s: Receive Edge: %s\n", machine().describe_context(), BIT(data, 5) ? "Falling" : "Rising"); + LOGMASKED(LOG_ICP, "%s: Transmit Edge: %s\n", machine().describe_context(), BIT(data, 6) ? "Falling" : "Rising"); - //stop_bits_t stop_bits = (BIT(data, 2) ? STOP_BITS_2 : STOP_BITS_1); + //stop_bits_t stop_bits = (BIT(data, 2) ? STOP_BITS_2 : STOP_BITS_1); - //parity_t parity = PARITY_NONE; - //if (BIT(data, 0)) - //{ - // parity = (BIT(data, 1) ? PARITY_EVEN : PARITY_ODD); - //} + //parity_t parity = PARITY_NONE; + //if (BIT(data, 0)) + //{ + // parity = (BIT(data, 1) ? PARITY_EVEN : PARITY_ODD); + //} - //set_data_frame(1, BIT(data, 3) ? 8 : 7, parity, stop_bits); - //receive_register_reset(); - //transmit_register_reset(); + //set_data_frame(1, BIT(data, 3) ? 8 : 7, parity, stop_bits); + //receive_register_reset(); + //transmit_register_reset(); - COMBINE_DATA(&m_icp_regs.uart.utcr[0]); - break; - } - case REG_UTCR1: - { - LOGMASKED(LOG_ICP, "%s: icp_w: UART Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_ICP, "%s: Baud Rate Divisor MSB: %02x\n", machine().describe_context(), data & 0x0f); - //const uint8_t old = m_uart_regs.utcr[1] & 0x0f; - COMBINE_DATA(&m_icp_regs.uart.utcr[1]); - //if ((m_uart_regs.utcr[1] & 0x0f) != old) - // icp_uart_recalculate_divisor(); - break; - } - case REG_UTCR2: - { - LOGMASKED(LOG_ICP, "%s: icp_w: UART Control Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_ICP, "%s: Baud Rate Divisor LSB: %02x\n", machine().describe_context(), (uint8_t)data); - //const uint8_t old = m_uart_regs.utcr[2] & 0xff; - COMBINE_DATA(&m_icp_regs.uart.utcr[2]); - //if ((m_uart_regs.utcr[2] & 0xff) != old) - // icp_uart_recalculate_divisor(); - break; - } - case REG_UTCR3: - { - LOGMASKED(LOG_ICP, "%s: icp_w: UART Control Register 3 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_ICP, "%s: Receive Enable: %d\n", machine().describe_context(), BIT(data, 0)); - LOGMASKED(LOG_ICP, "%s: Transmit Enable: %d\n", machine().describe_context(), BIT(data, 1)); - LOGMASKED(LOG_ICP, "%s: Send Break: %d\n", machine().describe_context(), BIT(data, 2)); - LOGMASKED(LOG_ICP, "%s: Receive FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 3)); - LOGMASKED(LOG_ICP, "%s: Transmit FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 4)); - LOGMASKED(LOG_ICP, "%s: Loopback Enable: %d\n", machine().describe_context(), BIT(data, 5)); - const uint32_t old = m_icp_regs.uart.utcr[3]; - COMBINE_DATA(&m_icp_regs.uart.utcr[3]); - const uint32_t changed = old ^ m_icp_regs.uart.utcr[3]; - if (BIT(changed, 0)) - icp_uart_set_receiver_enabled(BIT(data, 0)); - if (BIT(changed, 1)) - icp_uart_set_transmitter_enabled(BIT(data, 1)); - if (BIT(changed, 3)) - icp_uart_set_receive_irq_enabled(BIT(data, 3)); - if (BIT(changed, 4)) - icp_uart_set_transmit_irq_enabled(BIT(data, 4)); - break; - } - case REG_UTCR4: - LOGMASKED(LOG_ICP, "%s: icp_w: UART Control Register 4 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_ICP, "%s: HP-SIR enable: %d\n", machine().describe_context(), BIT(data, UTCR4_HSE_BIT), mem_mask); - LOGMASKED(LOG_ICP, "%s: Low-Power enable: %d\n", machine().describe_context(), BIT(data, UTCR4_LPM_BIT), mem_mask); - COMBINE_DATA(&m_icp_regs.utcr4); - break; - case REG_UTDR: - LOGMASKED(LOG_ICP, "%s: icp_w: UART Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - if (data == 0x0d || data == 0x0a || (data >= 0x20 && data < 0x7f)) - { - printf("%c", (char)data); - } - icp_uart_write_transmit_fifo((uint8_t)data); - break; - case REG_UTSR0: - LOGMASKED(LOG_ICP, "%s: icp_w: UART Status Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_ICP, "%s: Receiver Idle Status: %d\n", machine().describe_context(), BIT(data, 2)); - LOGMASKED(LOG_ICP, "%s: Receiver Begin of Break Status: %d\n", machine().describe_context(), BIT(data, 3)); - LOGMASKED(LOG_ICP, "%s: Receiver End of Break Status: %d\n", machine().describe_context(), BIT(data, 4)); - if (BIT(data, 2)) - icp_uart_set_receiver_idle(); - if (BIT(data, 3)) - icp_uart_begin_of_break(); - if (BIT(data, 4)) - icp_uart_end_of_break(); - break; - case REG_HSCR0: - LOGMASKED(LOG_ICP, "%s: icp_w: HSSP Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_HSCR1: - LOGMASKED(LOG_ICP, "%s: icp_w: HSSP Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_HSDR: - LOGMASKED(LOG_ICP, "%s: icp_w: HSSP Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - icp_hssp_write_transmit_fifo((uint8_t)data); - break; - case REG_HSSR0: - LOGMASKED(LOG_ICP, "%s: icp_w: HSSP Status Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_HSSR1: - LOGMASKED(LOG_ICP, "%s: icp_w: HSSP Status Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - default: - LOGMASKED(LOG_ICP | LOG_UNKNOWN, "%s: icp_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), ICP_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + COMBINE_DATA(&m_icp_regs.uart.utcr[0]); } +u32 sa1110_periphs_device::icp_utcr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.uart.utcr[1]; + LOGMASKED(LOG_ICP, "%s: icp_utcr1_r: UART Control Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_utcr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_utcr1_w: UART Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_ICP, "%s: Baud Rate Divisor MSB: %02x\n", machine().describe_context(), data & 0x0f); + //const u8 old = m_uart_regs.utcr[1] & 0x0f; + COMBINE_DATA(&m_icp_regs.uart.utcr[1]); + //if ((m_uart_regs.utcr[1] & 0x0f) != old) + // icp_uart_recalculate_divisor(); +} + +u32 sa1110_periphs_device::icp_utcr2_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.uart.utcr[2]; + LOGMASKED(LOG_ICP, "%s: icp_utcr2_r: UART Control Register 2: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_utcr2_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_utcr2_w: UART Control Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_ICP, "%s: Baud Rate Divisor LSB: %02x\n", machine().describe_context(), (u8)data); + //const u8 old = m_uart_regs.utcr[2] & 0xff; + COMBINE_DATA(&m_icp_regs.uart.utcr[2]); + //if ((m_uart_regs.utcr[2] & 0xff) != old) + // icp_uart_recalculate_divisor(); +} + +u32 sa1110_periphs_device::icp_utcr3_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.uart.utcr[3]; + LOGMASKED(LOG_ICP, "%s: icp_utcr3_r: UART Control Register 3: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_utcr3_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_utcr3_w: UART Control Register 3 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_ICP, "%s: Receive Enable: %d\n", machine().describe_context(), BIT(data, 0)); + LOGMASKED(LOG_ICP, "%s: Transmit Enable: %d\n", machine().describe_context(), BIT(data, 1)); + LOGMASKED(LOG_ICP, "%s: Send Break: %d\n", machine().describe_context(), BIT(data, 2)); + LOGMASKED(LOG_ICP, "%s: Receive FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 3)); + LOGMASKED(LOG_ICP, "%s: Transmit FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 4)); + LOGMASKED(LOG_ICP, "%s: Loopback Enable: %d\n", machine().describe_context(), BIT(data, 5)); + const u32 old = m_icp_regs.uart.utcr[3]; + COMBINE_DATA(&m_icp_regs.uart.utcr[3]); + const u32 changed = old ^ m_icp_regs.uart.utcr[3]; + if (BIT(changed, 0)) + icp_uart_set_receiver_enabled(BIT(data, 0)); + if (BIT(changed, 1)) + icp_uart_set_transmitter_enabled(BIT(data, 1)); + if (BIT(changed, 3)) + icp_uart_set_receive_irq_enabled(BIT(data, 3)); + if (BIT(changed, 4)) + icp_uart_set_transmit_irq_enabled(BIT(data, 4)); +} + +u32 sa1110_periphs_device::icp_utcr4_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.utcr4; + LOGMASKED(LOG_ICP, "%s: icp_utcr4_r: UART Control Register 4: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_utcr4_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_utcr4_w: UART Control Register 4 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_ICP, "%s: HP-SIR enable: %d\n", machine().describe_context(), BIT(data, UTCR4_HSE_BIT), mem_mask); + LOGMASKED(LOG_ICP, "%s: Low-Power enable: %d\n", machine().describe_context(), BIT(data, UTCR4_LPM_BIT), mem_mask); + COMBINE_DATA(&m_icp_regs.utcr4); +} + +u32 sa1110_periphs_device::icp_utdr_r(offs_t offset, u32 mem_mask) +{ + const u8 data = icp_uart_read_receive_fifo(); + LOGMASKED(LOG_ICP, "%s: icp_utdr_r: UART Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_utdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_utdr_w: UART Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + if (data == 0x0d || data == 0x0a || (data >= 0x20 && data < 0x7f)) + { + osd_printf_debug("%c", (char)data); + } + icp_uart_write_transmit_fifo((u8)data); +} + +u32 sa1110_periphs_device::icp_utsr0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.uart.utsr0; + LOGMASKED(LOG_ICP, "%s: icp_utsr0_r: UART Status Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_utsr0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_utsr0_w: UART Status Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_ICP, "%s: Receiver Idle Status: %d\n", machine().describe_context(), BIT(data, 2)); + LOGMASKED(LOG_ICP, "%s: Receiver Begin of Break Status: %d\n", machine().describe_context(), BIT(data, 3)); + LOGMASKED(LOG_ICP, "%s: Receiver End of Break Status: %d\n", machine().describe_context(), BIT(data, 4)); + if (BIT(data, 2)) + icp_uart_set_receiver_idle(); + if (BIT(data, 3)) + icp_uart_begin_of_break(); + if (BIT(data, 4)) + icp_uart_end_of_break(); +} + +u32 sa1110_periphs_device::icp_utsr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.uart.utsr1; + LOGMASKED(LOG_ICP, "%s: icp_utsr1_r: UART Status Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +u32 sa1110_periphs_device::icp_hscr0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.hssp.hscr0; + LOGMASKED(LOG_ICP, "%s: icp_hscr0_r: HSSP Control Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_hscr0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_hscr0_w: HSSP Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::icp_hscr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.hssp.hscr1; + LOGMASKED(LOG_ICP, "%s: icp_hscr1_r: HSSP Control Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_hscr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_hscr1_w: HSSP Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::icp_hsdr_r(offs_t offset, u32 mem_mask) +{ + const u16 data = icp_hssp_read_receive_fifo(); + LOGMASKED(LOG_ICP, "%s: icp_r: HSSP Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_hsdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_hsdr_w: HSSP Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + icp_hssp_write_transmit_fifo((u8)data); +} + +u32 sa1110_periphs_device::icp_hssr0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.hssp.hssr0; + LOGMASKED(LOG_ICP, "%s: icp_hssr0_r: HSSP Status Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_hssr0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_hssr0_w: HSSP Status Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::icp_hssr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_icp_regs.hssp.hssr1; + LOGMASKED(LOG_ICP, "%s: icp_hssr1_r: HSSP Status Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::icp_hssr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_ICP, "%s: icp_hssr1_w: HSSP Status Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + + /* Intel SA-1110 Serial Port 3 - UART @@ -415,7 +648,7 @@ void sa1110_periphs_device::rcv_complete() { receive_register_extract(); - uint16_t data_and_flags = 0; + u16 data_and_flags = 0; if (is_receive_framing_error()) data_and_flags |= 0x200; if (is_receive_parity_error()) @@ -483,7 +716,7 @@ void sa1110_periphs_device::uart_update_eif_status() } } -void sa1110_periphs_device::uart_write_receive_fifo(uint16_t data_and_flags) +void sa1110_periphs_device::uart_write_receive_fifo(u16 data_and_flags) { if (m_uart_regs.rx_fifo_count >= std::size(m_uart_regs.rx_fifo)) return; @@ -502,16 +735,16 @@ void sa1110_periphs_device::uart_write_receive_fifo(uint16_t data_and_flags) uart_check_rx_fifo_service(); } -uint8_t sa1110_periphs_device::uart_read_receive_fifo() +u8 sa1110_periphs_device::uart_read_receive_fifo() { - const uint8_t data = m_uart_regs.rx_fifo[m_uart_regs.rx_fifo_read_idx]; + const u8 data = m_uart_regs.rx_fifo[m_uart_regs.rx_fifo_read_idx]; if (m_uart_regs.rx_fifo_count) { m_uart_regs.rx_fifo_read_idx = (m_uart_regs.rx_fifo_read_idx + 1) % std::size(m_uart_regs.rx_fifo); m_uart_regs.rx_fifo_count--; if (m_uart_regs.rx_fifo_count) { - const uint16_t fifo_bottom_flags = ((m_uart_regs.rx_fifo[m_uart_regs.rx_fifo_read_idx]) >> 8) & 7; + const u16 fifo_bottom_flags = ((m_uart_regs.rx_fifo[m_uart_regs.rx_fifo_read_idx]) >> 8) & 7; m_uart_regs.utsr1 &= ~((1 << UTSR1_PRE_BIT) | (1 << UTSR1_FRE_BIT) | (1 << UTSR1_ROR_BIT)); m_uart_regs.utsr1 |= fifo_bottom_flags << UTSR1_PRE_BIT; } @@ -543,7 +776,7 @@ void sa1110_periphs_device::uart_check_rx_fifo_service() } } -void sa1110_periphs_device::uart_write_transmit_fifo(uint8_t data) +void sa1110_periphs_device::uart_write_transmit_fifo(u8 data) { if (m_uart_regs.tx_fifo_count >= std::size(m_uart_regs.tx_fifo)) return; @@ -652,138 +885,148 @@ void sa1110_periphs_device::uart_set_transmit_irq_enabled(bool enabled) { } -uint32_t sa1110_periphs_device::uart3_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::uart3_utcr0_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_UTCR0: - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Control Register 0: %08x & %08x\n", machine().describe_context(), m_uart_regs.utcr[0], mem_mask); - return m_uart_regs.utcr[0]; - case REG_UTCR1: - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Control Register 1: %08x & %08x\n", machine().describe_context(), m_uart_regs.utcr[1], mem_mask); - return m_uart_regs.utcr[1]; - case REG_UTCR2: - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Control Register 2: %08x & %08x\n", machine().describe_context(), m_uart_regs.utcr[2], mem_mask); - return m_uart_regs.utcr[2]; - case REG_UTCR3: - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Control Register 3: %08x & %08x\n", machine().describe_context(), m_uart_regs.utcr[3], mem_mask); - return m_uart_regs.utcr[3]; - case REG_UTDR: - { - const uint8_t data = uart_read_receive_fifo(); - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - return data; - } - case REG_UTSR0: - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Status Register 0: %08x & %08x\n", machine().describe_context(), m_uart_regs.utsr0, mem_mask); - return m_uart_regs.utsr0; - case REG_UTSR1: - LOGMASKED(LOG_UART3, "%s: uart3_r: UART Status Register 1: %08x & %08x\n", machine().describe_context(), m_uart_regs.utsr1, mem_mask); - return m_uart_regs.utsr1; - default: - LOGMASKED(LOG_UART3 | LOG_UNKNOWN, "%s: uart3_r: Unknown address: %08x & %08x\n", machine().describe_context(), UART_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_uart_regs.utcr[0]; + LOGMASKED(LOG_UART3, "%s: uart3_utcr0_r: UART Control Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::uart3_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::uart3_utcr0_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_UTCR0: - { - LOGMASKED(LOG_UART3, "%s: uart3_w: UART Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_UART3, "%s: Parity Enable: %d\n", machine().describe_context(), BIT(data, 0)); - LOGMASKED(LOG_UART3, "%s: Parity Mode: %s\n", machine().describe_context(), BIT(data, 1) ? "Even" : "Odd"); - LOGMASKED(LOG_UART3, "%s: Stop Bits: %d\n", machine().describe_context(), BIT(data, 2) + 1); - LOGMASKED(LOG_UART3, "%s: Data Size: %d\n", machine().describe_context(), BIT(data, 3) ? 8 : 7); - LOGMASKED(LOG_UART3, "%s: Sample Clock: %s\n", machine().describe_context(), BIT(data, 4) ? "External" : "Internal"); - LOGMASKED(LOG_UART3, "%s: Receive Edge: %s\n", machine().describe_context(), BIT(data, 5) ? "Falling" : "Rising"); - LOGMASKED(LOG_UART3, "%s: Transmit Edge: %s\n", machine().describe_context(), BIT(data, 6) ? "Falling" : "Rising"); + LOGMASKED(LOG_UART3, "%s: uart3_utcr0_w: UART Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_UART3, "%s: Parity Enable: %d\n", machine().describe_context(), BIT(data, 0)); + LOGMASKED(LOG_UART3, "%s: Parity Mode: %s\n", machine().describe_context(), BIT(data, 1) ? "Even" : "Odd"); + LOGMASKED(LOG_UART3, "%s: Stop Bits: %d\n", machine().describe_context(), BIT(data, 2) + 1); + LOGMASKED(LOG_UART3, "%s: Data Size: %d\n", machine().describe_context(), BIT(data, 3) ? 8 : 7); + LOGMASKED(LOG_UART3, "%s: Sample Clock: %s\n", machine().describe_context(), BIT(data, 4) ? "External" : "Internal"); + LOGMASKED(LOG_UART3, "%s: Receive Edge: %s\n", machine().describe_context(), BIT(data, 5) ? "Falling" : "Rising"); + LOGMASKED(LOG_UART3, "%s: Transmit Edge: %s\n", machine().describe_context(), BIT(data, 6) ? "Falling" : "Rising"); - stop_bits_t stop_bits = (BIT(data, 2) ? STOP_BITS_2 : STOP_BITS_1); + stop_bits_t stop_bits = (BIT(data, 2) ? STOP_BITS_2 : STOP_BITS_1); - parity_t parity = PARITY_NONE; - if (BIT(data, 0)) - { - parity = (BIT(data, 1) ? PARITY_EVEN : PARITY_ODD); - } + parity_t parity = PARITY_NONE; + if (BIT(data, 0)) + { + parity = (BIT(data, 1) ? PARITY_EVEN : PARITY_ODD); + } - set_data_frame(1, BIT(data, 3) ? 8 : 7, parity, stop_bits); - receive_register_reset(); - transmit_register_reset(); + set_data_frame(1, BIT(data, 3) ? 8 : 7, parity, stop_bits); + receive_register_reset(); + transmit_register_reset(); - COMBINE_DATA(&m_uart_regs.utcr[0]); - break; - } - case REG_UTCR1: - { - LOGMASKED(LOG_UART3, "%s: uart3_w: UART Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_UART3, "%s: Baud Rate Divisor MSB: %02x\n", machine().describe_context(), data & 0x0f); - const uint8_t old = m_uart_regs.utcr[1] & 0x0f; - COMBINE_DATA(&m_uart_regs.utcr[1]); - if ((m_uart_regs.utcr[1] & 0x0f) != old) - uart_recalculate_divisor(); - break; - } - case REG_UTCR2: - { - LOGMASKED(LOG_UART3, "%s: uart3_w: UART Control Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_UART3, "%s: Baud Rate Divisor LSB: %02x\n", machine().describe_context(), (uint8_t)data); - const uint8_t old = m_uart_regs.utcr[2] & 0xff; - COMBINE_DATA(&m_uart_regs.utcr[2]); - if ((m_uart_regs.utcr[2] & 0xff) != old) - uart_recalculate_divisor(); - break; - } - case REG_UTCR3: - { - LOGMASKED(LOG_UART3, "%s: uart3_w: UART Control Register 3 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_UART3, "%s: Receive Enable: %d\n", machine().describe_context(), BIT(data, 0)); - LOGMASKED(LOG_UART3, "%s: Transmit Enable: %d\n", machine().describe_context(), BIT(data, 1)); - LOGMASKED(LOG_UART3, "%s: Send Break: %d\n", machine().describe_context(), BIT(data, 2)); - LOGMASKED(LOG_UART3, "%s: Receive FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 3)); - LOGMASKED(LOG_UART3, "%s: Transmit FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 4)); - LOGMASKED(LOG_UART3, "%s: Loopback Enable: %d\n", machine().describe_context(), BIT(data, 5)); - const uint32_t old = m_uart_regs.utcr[3]; - COMBINE_DATA(&m_uart_regs.utcr[3]); - const uint32_t changed = old ^ m_uart_regs.utcr[3]; - if (BIT(changed, 0)) - uart_set_receiver_enabled(BIT(data, 0)); - if (BIT(changed, 1)) - uart_set_transmitter_enabled(BIT(data, 1)); - if (BIT(changed, 3)) - uart_set_receive_irq_enabled(BIT(data, 3)); - if (BIT(changed, 4)) - uart_set_transmit_irq_enabled(BIT(data, 4)); - break; - } - case REG_UTDR: - LOGMASKED(LOG_UART3, "%s: uart3_w: UART Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - if (data == 0x0d || data == 0x0a || (data >= 0x20 && data < 0x7f)) - { - printf("%c", (char)data); - } - uart_write_transmit_fifo((uint8_t)data); - break; - case REG_UTSR0: - LOGMASKED(LOG_UART3, "%s: uart3_w: UART Status Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_UART3, "%s: Receiver Idle Status: %d\n", machine().describe_context(), BIT(data, 2)); - LOGMASKED(LOG_UART3, "%s: Receiver Begin of Break Status: %d\n", machine().describe_context(), BIT(data, 3)); - LOGMASKED(LOG_UART3, "%s: Receiver End of Break Status: %d\n", machine().describe_context(), BIT(data, 4)); - if (BIT(data, 2)) - uart_set_receiver_idle(); - if (BIT(data, 3)) - uart_begin_of_break(); - if (BIT(data, 4)) - uart_end_of_break(); - break; - default: - LOGMASKED(LOG_UART3 | LOG_UNKNOWN, "%s: uart3_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), UART_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + COMBINE_DATA(&m_uart_regs.utcr[0]); } +u32 sa1110_periphs_device::uart3_utcr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_uart_regs.utcr[1]; + LOGMASKED(LOG_UART3, "%s: uart3_utcr1_r: UART Control Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::uart3_utcr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UART3, "%s: uart3_utcr1_w: UART Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_UART3, "%s: Baud Rate Divisor MSB: %02x\n", machine().describe_context(), data & 0x0f); + const u8 old = m_uart_regs.utcr[1] & 0x0f; + COMBINE_DATA(&m_uart_regs.utcr[1]); + if ((m_uart_regs.utcr[1] & 0x0f) != old) + uart_recalculate_divisor(); +} + +u32 sa1110_periphs_device::uart3_utcr2_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_uart_regs.utcr[2]; + LOGMASKED(LOG_UART3, "%s: uart3_utcr2_r: UART Control Register 2: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::uart3_utcr2_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UART3, "%s: uart3_utcr2_w: UART Control Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_UART3, "%s: Baud Rate Divisor LSB: %02x\n", machine().describe_context(), (u8)data); + const u8 old = m_uart_regs.utcr[2] & 0xff; + COMBINE_DATA(&m_uart_regs.utcr[2]); + if ((m_uart_regs.utcr[2] & 0xff) != old) + uart_recalculate_divisor(); +} + +u32 sa1110_periphs_device::uart3_utcr3_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_uart_regs.utcr[3]; + LOGMASKED(LOG_UART3, "%s: uart3_utcr3_r: UART Control Register 3: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::uart3_utcr3_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UART3, "%s: uart3_utcr3_w: UART Control Register 3 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_UART3, "%s: Receive Enable: %d\n", machine().describe_context(), BIT(data, 0)); + LOGMASKED(LOG_UART3, "%s: Transmit Enable: %d\n", machine().describe_context(), BIT(data, 1)); + LOGMASKED(LOG_UART3, "%s: Send Break: %d\n", machine().describe_context(), BIT(data, 2)); + LOGMASKED(LOG_UART3, "%s: Receive FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 3)); + LOGMASKED(LOG_UART3, "%s: Transmit FIFO IRQ Enable: %d\n", machine().describe_context(), BIT(data, 4)); + LOGMASKED(LOG_UART3, "%s: Loopback Enable: %d\n", machine().describe_context(), BIT(data, 5)); + const u32 old = m_uart_regs.utcr[3]; + COMBINE_DATA(&m_uart_regs.utcr[3]); + const u32 changed = old ^ m_uart_regs.utcr[3]; + if (BIT(changed, 0)) + uart_set_receiver_enabled(BIT(data, 0)); + if (BIT(changed, 1)) + uart_set_transmitter_enabled(BIT(data, 1)); + if (BIT(changed, 3)) + uart_set_receive_irq_enabled(BIT(data, 3)); + if (BIT(changed, 4)) + uart_set_transmit_irq_enabled(BIT(data, 4)); +} + +u32 sa1110_periphs_device::uart3_utdr_r(offs_t offset, u32 mem_mask) +{ + const u8 data = uart_read_receive_fifo(); + LOGMASKED(LOG_UART3, "%s: uart3_utdr_r: UART Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::uart3_utdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UART3, "%s: uart3_utdr_w: UART Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + if (data == 0x0d || data == 0x0a || (data >= 0x20 && data < 0x7f)) + { + osd_printf_debug("%c", (char)data); + } + uart_write_transmit_fifo((u8)data); +} + +u32 sa1110_periphs_device::uart3_utsr0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_uart_regs.utsr0; + LOGMASKED(LOG_UART3, "%s: uart3_utsr0_r: UART Status Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::uart3_utsr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_UART3, "%s: uart3_utsr1_w: UART Status Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_UART3, "%s: Receiver Idle Status: %d\n", machine().describe_context(), BIT(data, 2)); + LOGMASKED(LOG_UART3, "%s: Receiver Begin of Break Status: %d\n", machine().describe_context(), BIT(data, 3)); + LOGMASKED(LOG_UART3, "%s: Receiver End of Break Status: %d\n", machine().describe_context(), BIT(data, 4)); + if (BIT(data, 2)) + uart_set_receiver_idle(); + if (BIT(data, 3)) + uart_begin_of_break(); + if (BIT(data, 4)) + uart_end_of_break(); +} + +u32 sa1110_periphs_device::uart3_utsr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_uart_regs.utsr1; + LOGMASKED(LOG_UART3_HF, "%s: uart3_utsr1_r: UART Status Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + + /* Intel SA-1110 MCP - Serial Port 4 @@ -802,7 +1045,7 @@ TIMER_CALLBACK_MEMBER(sa1110_periphs_device::mcp_audio_tx_callback) if (!m_codec) return; - const uint16_t sample = m_mcp_regs.audio_tx_fifo[m_mcp_regs.audio_tx_fifo_read_idx]; + const u16 sample = m_mcp_regs.audio_tx_fifo[m_mcp_regs.audio_tx_fifo_read_idx]; m_codec->audio_sample_in(sample); if (m_mcp_regs.audio_tx_fifo_count) @@ -827,7 +1070,7 @@ TIMER_CALLBACK_MEMBER(sa1110_periphs_device::mcp_telecom_tx_callback) if (!m_codec) return; - const uint16_t sample = m_mcp_regs.telecom_tx_fifo[m_mcp_regs.telecom_tx_fifo_read_idx]; + const u16 sample = m_mcp_regs.telecom_tx_fifo[m_mcp_regs.telecom_tx_fifo_read_idx]; m_codec->telecom_sample_in(sample); if (m_mcp_regs.telecom_tx_fifo_count) @@ -847,9 +1090,9 @@ TIMER_CALLBACK_MEMBER(sa1110_periphs_device::mcp_telecom_tx_callback) m_mcp_regs.mcsr |= (1 << MCSR_TNF_BIT); } -uint16_t sa1110_periphs_device::mcp_read_audio_fifo() +u16 sa1110_periphs_device::mcp_read_audio_fifo() { - const uint16_t data = m_mcp_regs.audio_rx_fifo[m_mcp_regs.audio_rx_fifo_read_idx]; + const u16 data = m_mcp_regs.audio_rx_fifo[m_mcp_regs.audio_rx_fifo_read_idx]; if (m_mcp_regs.audio_rx_fifo_count) { m_mcp_regs.audio_rx_fifo_count--; @@ -872,9 +1115,9 @@ uint16_t sa1110_periphs_device::mcp_read_audio_fifo() return data; } -uint16_t sa1110_periphs_device::mcp_read_telecom_fifo() +u16 sa1110_periphs_device::mcp_read_telecom_fifo() { - const uint16_t data = m_mcp_regs.telecom_rx_fifo[m_mcp_regs.telecom_rx_fifo_read_idx]; + const u16 data = m_mcp_regs.telecom_rx_fifo[m_mcp_regs.telecom_rx_fifo_read_idx]; if (m_mcp_regs.telecom_rx_fifo_count) { m_mcp_regs.telecom_rx_fifo_count--; @@ -899,14 +1142,14 @@ uint16_t sa1110_periphs_device::mcp_read_telecom_fifo() attotime sa1110_periphs_device::mcp_get_audio_frame_rate() { - const uint32_t bit_rate = BIT(m_mcp_regs.mccr1, MCCR1_CFS_BIT) ? 9585000 : 11981000; + const u32 bit_rate = BIT(m_mcp_regs.mccr1, MCCR1_CFS_BIT) ? 9585000 : 11981000; const uint64_t ticks = 32 * ((m_mcp_regs.mccr0 & MCCR0_ASD_MASK) >> MCCR0_ASD_BIT); return attotime::from_ticks(ticks, bit_rate); } attotime sa1110_periphs_device::mcp_get_telecom_frame_rate() { - const uint32_t bit_rate = BIT(m_mcp_regs.mccr1, MCCR1_CFS_BIT) ? 9585000 : 11981000; + const u32 bit_rate = BIT(m_mcp_regs.mccr1, MCCR1_CFS_BIT) ? 9585000 : 11981000; const uint64_t ticks = 32 * ((m_mcp_regs.mccr0 & MCCR0_TSD_MASK) >> MCCR0_TSD_BIT); return attotime::from_ticks(ticks, bit_rate); } @@ -933,7 +1176,7 @@ void sa1110_periphs_device::mcp_set_enabled(bool enabled) } } -void sa1110_periphs_device::mcp_audio_tx_fifo_push(const uint16_t value) +void sa1110_periphs_device::mcp_audio_tx_fifo_push(const u16 value) { if (m_mcp_regs.audio_rx_fifo_count == std::size(m_mcp_regs.audio_tx_fifo)) return; @@ -959,7 +1202,7 @@ void sa1110_periphs_device::mcp_audio_tx_fifo_push(const uint16_t value) } } -void sa1110_periphs_device::mcp_telecom_tx_fifo_push(const uint16_t value) +void sa1110_periphs_device::mcp_telecom_tx_fifo_push(const u16 value) { if (m_mcp_regs.telecom_rx_fifo_count == std::size(m_mcp_regs.telecom_tx_fifo)) return; @@ -990,7 +1233,7 @@ void sa1110_periphs_device::mcp_codec_read(offs_t offset) if (!m_codec) return; - const uint16_t data = m_codec->read(offset); + const u16 data = m_codec->read(offset); m_mcp_regs.mcdr2 &= 0xffff0000; m_mcp_regs.mcdr2 |= data; @@ -998,7 +1241,7 @@ void sa1110_periphs_device::mcp_codec_read(offs_t offset) m_mcp_regs.mcsr &= ~(1 << MCSR_CWC_BIT); } -void sa1110_periphs_device::mcp_codec_write(offs_t offset, uint16_t data) +void sa1110_periphs_device::mcp_codec_write(offs_t offset, u16 data) { if (!m_codec) return; @@ -1008,133 +1251,131 @@ void sa1110_periphs_device::mcp_codec_write(offs_t offset, uint16_t data) m_mcp_regs.mcsr &= ~(1 << MCSR_CRC_BIT); } -uint32_t sa1110_periphs_device::mcp_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::mcp_mccr0_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_MCCR0: - LOGMASKED(LOG_MCP, "%s: mcp_r: MCP Control Register 0: %08x & %08x\n", machine().describe_context(), m_mcp_regs.mccr0, mem_mask); - return m_mcp_regs.mccr0; - case REG_MCDR0: - { - const uint16_t data = mcp_read_audio_fifo() << 4; - LOGMASKED(LOG_MCP, "%s: mcp_r: MCP Data Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); - return data; - } - case REG_MCDR1: - { - const uint16_t data = mcp_read_telecom_fifo() << 4; - LOGMASKED(LOG_MCP, "%s: mcp_r: MCP Data Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); - return data; - } - case REG_MCDR2: - LOGMASKED(LOG_MCP, "%s: mcp_r: MCP Data Register 2: %08x & %08x\n", machine().describe_context(), m_mcp_regs.mcdr2, mem_mask); - LOGMASKED(LOG_MCP, "%s: Value: %04x\n", machine().describe_context(), (uint16_t)m_mcp_regs.mcdr2); - LOGMASKED(LOG_MCP, "%s: Read/Write: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcdr2, 16)); - LOGMASKED(LOG_MCP, "%s: Address: %01x\n", machine().describe_context(), (m_mcp_regs.mcdr2 >> 17) & 0xf); - return m_mcp_regs.mcdr2; - case REG_MCSR: - LOGMASKED(LOG_MCP, "%s: mcp_r: MCP Status Register: %08x & %08x\n", machine().describe_context(), m_mcp_regs.mcsr, mem_mask); - LOGMASKED(LOG_MCP, "%s: Audio Xmit FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 0)); - LOGMASKED(LOG_MCP, "%s: Audio Recv FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 1)); - LOGMASKED(LOG_MCP, "%s: Telecom Xmit FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 2)); - LOGMASKED(LOG_MCP, "%s: Telecom Recv FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 3)); - LOGMASKED(LOG_MCP, "%s: Audio Xmit FIFO Underrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 4)); - LOGMASKED(LOG_MCP, "%s: Audio Recv FIFO Overrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 5)); - LOGMASKED(LOG_MCP, "%s: Telcom Xmit FIFO Underrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 6)); - LOGMASKED(LOG_MCP, "%s: Telcom Recv FIFO Overrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 7)); - LOGMASKED(LOG_MCP, "%s: Audio Xmit FIFO Not Full: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 8)); - LOGMASKED(LOG_MCP, "%s: Audio Recv FIFO Not Empty: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 9)); - LOGMASKED(LOG_MCP, "%s: Telcom Xmit FIFO Not Full: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 10)); - LOGMASKED(LOG_MCP, "%s: Telcom Recv FIFO Not Empty: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 11)); - LOGMASKED(LOG_MCP, "%s: Codec Write Complete: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 12)); - LOGMASKED(LOG_MCP, "%s: Codec Read Complete: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 13)); - LOGMASKED(LOG_MCP, "%s: Audio Codec Enabled: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 14)); - LOGMASKED(LOG_MCP, "%s: Telecom Codec Enabled: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 15)); - return m_mcp_regs.mcsr; - default: - LOGMASKED(LOG_MCP | LOG_UNKNOWN, "%s: ostimer_r: Unknown address: %08x & %08x\n", machine().describe_context(), MCP_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_mcp_regs.mccr0; + LOGMASKED(LOG_MCP, "%s: mcp_mccr0_r: MCP Control Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::mcp_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::mcp_mccr0_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_MCCR0: - { - LOGMASKED(LOG_MCP, "%s: mcp_w: MCP Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_MCP, "%s: Audio Sample Rate Divisor: %02x\n", machine().describe_context(), data & MCCR0_ASD_MASK); - LOGMASKED(LOG_MCP, "%s: Telecom Sample Rate Divisor: %02x\n", machine().describe_context(), (data & MCCR0_TSD_MASK) >> MCCR0_TSD_BIT); - LOGMASKED(LOG_MCP, "%s: MCP Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_MCE_BIT)); - LOGMASKED(LOG_MCP, "%s: Clock Select: %s\n", machine().describe_context(), BIT(data, MCCR0_ECS_BIT) ? "External" : "Internal"); - LOGMASKED(LOG_MCP, "%s: A/D Data Sampling Mode: %s Valid\n", machine().describe_context(), BIT(data, MCCR0_ADM_BIT) ? "First" : "Each"); - LOGMASKED(LOG_MCP, "%s: Telecom Tx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_TTE_BIT)); - LOGMASKED(LOG_MCP, "%s: Telecom Rx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_TRE_BIT)); - LOGMASKED(LOG_MCP, "%s: Audio Tx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_ATE_BIT)); - LOGMASKED(LOG_MCP, "%s: Audio Rx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_ARE_BIT)); - LOGMASKED(LOG_MCP, "%s: Loopback Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_LBM_BIT)); - LOGMASKED(LOG_MCP, "%s: External Clock Prescaler: %d\n", machine().describe_context(), ((data & MCCR0_ECP_MASK) >> MCCR0_ECP_BIT) + 1); - const uint32_t old = m_mcp_regs.mccr0; - COMBINE_DATA(&m_mcp_regs.mccr0); - const uint32_t changed = old ^ m_mcp_regs.mccr0; - if (BIT(m_mcp_regs.mcsr, MCSR_ATS_BIT) && BIT(changed, MCCR0_ATE_BIT)) - m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_ATS_BIT)); - if (BIT(m_mcp_regs.mcsr, MCSR_ARS_BIT) && BIT(changed, MCCR0_ARE_BIT)) - m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_ARS_BIT)); - if (BIT(m_mcp_regs.mcsr, MCSR_TTS_BIT) && BIT(changed, MCCR0_TTE_BIT)) - m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_TTS_BIT)); - if (BIT(m_mcp_regs.mcsr, MCSR_TRS_BIT) && BIT(changed, MCCR0_TRE_BIT)) - m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_TRS_BIT)); - if (BIT(old, MCCR0_MCE_BIT) != BIT(m_mcp_regs.mccr0, MCCR0_MCE_BIT)) - mcp_set_enabled(BIT(m_mcp_regs.mccr0, MCCR0_MCE_BIT)); - break; - } - case REG_MCDR0: - LOGMASKED(LOG_MCP, "%s: mcp_w: MCP Data Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - mcp_audio_tx_fifo_push((uint16_t)data); - break; - case REG_MCDR1: - LOGMASKED(LOG_MCP, "%s: mcp_w: MCP Data Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - mcp_telecom_tx_fifo_push((uint16_t)data); - break; - case REG_MCDR2: - { - const offs_t addr = (data & MCDR2_ADDR_MASK) >> MCDR2_ADDR_BIT; - LOGMASKED(LOG_MCP, "%s: mcp_w: MCP Data Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_mcp_regs.mcdr2); - m_mcp_regs.mcdr2 &= ~(1 << MCDR2_RW_BIT); - - if (BIT(data, MCDR2_RW_BIT)) - mcp_codec_write(addr, (uint16_t)data); - else - mcp_codec_read(addr); - break; - } - case REG_MCSR: - { - LOGMASKED(LOG_MCP, "%s: mcp_w: MCP Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_mcp_regs.mcsr; - const uint32_t sticky_mask = (1 << MCSR_ATU_BIT) | (1 << MCSR_ARO_BIT) | (1 << MCSR_TTU_BIT) | (1 << MCSR_TRO_BIT); - m_mcp_regs.mcsr &= ~(data & mem_mask & sticky_mask); - if (BIT(old, MCSR_ATU_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_ATU_BIT)) - m_mcp_irqs->in_w(0); - if (BIT(old, MCSR_ARO_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_ARO_BIT)) - m_mcp_irqs->in_w(0); - if (BIT(old, MCSR_TTU_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_TTU_BIT)) - m_mcp_irqs->in_w(0); - if (BIT(old, MCSR_TRO_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_TRO_BIT)) - m_mcp_irqs->in_w(0); - break; - } - default: - LOGMASKED(LOG_MCP | LOG_UNKNOWN, "%s: mcp_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), MCP_BASE_ADDR | (offset << 2), - data, mem_mask); - break; - } + LOGMASKED(LOG_MCP, "%s: mcp_mccr0_w: MCP Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_MCP, "%s: Audio Sample Rate Divisor: %02x\n", machine().describe_context(), data & MCCR0_ASD_MASK); + LOGMASKED(LOG_MCP, "%s: Telecom Sample Rate Divisor: %02x\n", machine().describe_context(), (data & MCCR0_TSD_MASK) >> MCCR0_TSD_BIT); + LOGMASKED(LOG_MCP, "%s: MCP Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_MCE_BIT)); + LOGMASKED(LOG_MCP, "%s: Clock Select: %s\n", machine().describe_context(), BIT(data, MCCR0_ECS_BIT) ? "External" : "Internal"); + LOGMASKED(LOG_MCP, "%s: A/D Data Sampling Mode: %s Valid\n", machine().describe_context(), BIT(data, MCCR0_ADM_BIT) ? "First" : "Each"); + LOGMASKED(LOG_MCP, "%s: Telecom Tx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_TTE_BIT)); + LOGMASKED(LOG_MCP, "%s: Telecom Rx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_TRE_BIT)); + LOGMASKED(LOG_MCP, "%s: Audio Tx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_ATE_BIT)); + LOGMASKED(LOG_MCP, "%s: Audio Rx FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_ARE_BIT)); + LOGMASKED(LOG_MCP, "%s: Loopback Enable: %d\n", machine().describe_context(), BIT(data, MCCR0_LBM_BIT)); + LOGMASKED(LOG_MCP, "%s: External Clock Prescaler: %d\n", machine().describe_context(), ((data & MCCR0_ECP_MASK) >> MCCR0_ECP_BIT) + 1); + const u32 old = m_mcp_regs.mccr0; + COMBINE_DATA(&m_mcp_regs.mccr0); + const u32 changed = old ^ m_mcp_regs.mccr0; + if (BIT(m_mcp_regs.mcsr, MCSR_ATS_BIT) && BIT(changed, MCCR0_ATE_BIT)) + m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_ATS_BIT)); + if (BIT(m_mcp_regs.mcsr, MCSR_ARS_BIT) && BIT(changed, MCCR0_ARE_BIT)) + m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_ARS_BIT)); + if (BIT(m_mcp_regs.mcsr, MCSR_TTS_BIT) && BIT(changed, MCCR0_TTE_BIT)) + m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_TTS_BIT)); + if (BIT(m_mcp_regs.mcsr, MCSR_TRS_BIT) && BIT(changed, MCCR0_TRE_BIT)) + m_mcp_irqs->in_w(BIT(m_mcp_regs.mcsr, MCSR_TRS_BIT)); + if (BIT(old, MCCR0_MCE_BIT) != BIT(m_mcp_regs.mccr0, MCCR0_MCE_BIT)) + mcp_set_enabled(BIT(m_mcp_regs.mccr0, MCCR0_MCE_BIT)); } +u32 sa1110_periphs_device::mcp_mcdr0_r(offs_t offset, u32 mem_mask) +{ + const u16 data = mcp_read_audio_fifo() << 4; + LOGMASKED(LOG_MCP, "%s: mcp_mcdr0_r: MCP Data Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::mcp_mcdr0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_MCP, "%s: mcp_mcdr0_w: MCP Data Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + mcp_audio_tx_fifo_push((u16)data); +} + +u32 sa1110_periphs_device::mcp_mcdr1_r(offs_t offset, u32 mem_mask) +{ + const u16 data = mcp_read_telecom_fifo() << 4; + LOGMASKED(LOG_MCP, "%s: mcp_mcdr1_r: MCP Data Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::mcp_mcdr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_MCP, "%s: mcp_mcdr1_w: MCP Data Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + mcp_telecom_tx_fifo_push((u16)data); +} + +u32 sa1110_periphs_device::mcp_mcdr2_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_mcp_regs.mcdr2; + LOGMASKED(LOG_MCP, "%s: mcp_mcdr2_r: MCP Data Register 2: %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_MCP, "%s: Value: %04x\n", machine().describe_context(), (u16)m_mcp_regs.mcdr2); + LOGMASKED(LOG_MCP, "%s: Read/Write: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcdr2, 16)); + LOGMASKED(LOG_MCP, "%s: Address: %01x\n", machine().describe_context(), (m_mcp_regs.mcdr2 >> 17) & 0xf); + return data; +} + +void sa1110_periphs_device::mcp_mcdr2_w(offs_t offset, u32 data, u32 mem_mask) +{ + const offs_t addr = (data & MCDR2_ADDR_MASK) >> MCDR2_ADDR_BIT; + LOGMASKED(LOG_MCP, "%s: mcp_mcdr2_w: MCP Data Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_mcp_regs.mcdr2); + m_mcp_regs.mcdr2 &= ~(1 << MCDR2_RW_BIT); + + if (BIT(data, MCDR2_RW_BIT)) + mcp_codec_write(addr, (u16)data); + else + mcp_codec_read(addr); +} + +u32 sa1110_periphs_device::mcp_mcsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_mcp_regs.mcsr; + LOGMASKED(LOG_MCP, "%s: mcp_mcsr_r: MCP Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_MCP, "%s: Audio Xmit FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 0)); + LOGMASKED(LOG_MCP, "%s: Audio Recv FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 1)); + LOGMASKED(LOG_MCP, "%s: Telecom Xmit FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 2)); + LOGMASKED(LOG_MCP, "%s: Telecom Recv FIFO Service Request: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 3)); + LOGMASKED(LOG_MCP, "%s: Audio Xmit FIFO Underrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 4)); + LOGMASKED(LOG_MCP, "%s: Audio Recv FIFO Overrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 5)); + LOGMASKED(LOG_MCP, "%s: Telcom Xmit FIFO Underrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 6)); + LOGMASKED(LOG_MCP, "%s: Telcom Recv FIFO Overrun: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 7)); + LOGMASKED(LOG_MCP, "%s: Audio Xmit FIFO Not Full: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 8)); + LOGMASKED(LOG_MCP, "%s: Audio Recv FIFO Not Empty: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 9)); + LOGMASKED(LOG_MCP, "%s: Telcom Xmit FIFO Not Full: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 10)); + LOGMASKED(LOG_MCP, "%s: Telcom Recv FIFO Not Empty: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 11)); + LOGMASKED(LOG_MCP, "%s: Codec Write Complete: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 12)); + LOGMASKED(LOG_MCP, "%s: Codec Read Complete: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 13)); + LOGMASKED(LOG_MCP, "%s: Audio Codec Enabled: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 14)); + LOGMASKED(LOG_MCP, "%s: Telecom Codec Enabled: %d\n", machine().describe_context(), BIT(m_mcp_regs.mcsr, 15)); + return data; +} + +void sa1110_periphs_device::mcp_mcsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_MCP, "%s: mcp_w: MCP Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_mcp_regs.mcsr; + const u32 sticky_mask = (1 << MCSR_ATU_BIT) | (1 << MCSR_ARO_BIT) | (1 << MCSR_TTU_BIT) | (1 << MCSR_TRO_BIT); + m_mcp_regs.mcsr &= ~(data & mem_mask & sticky_mask); + if (BIT(old, MCSR_ATU_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_ATU_BIT)) + m_mcp_irqs->in_w(0); + if (BIT(old, MCSR_ARO_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_ARO_BIT)) + m_mcp_irqs->in_w(0); + if (BIT(old, MCSR_TTU_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_TTU_BIT)) + m_mcp_irqs->in_w(0); + if (BIT(old, MCSR_TRO_BIT) && !BIT(m_mcp_regs.mcsr, MCSR_TRO_BIT)) + m_mcp_irqs->in_w(0); +} + + /* Intel SA-1110 SSP - Synchronous Serial Port @@ -1153,14 +1394,20 @@ TIMER_CALLBACK_MEMBER(sa1110_periphs_device::ssp_tx_callback) // TODO: Implement transmitting data serially rather than in bulk. if (m_ssp_regs.tx_fifo_count) { - const uint16_t data = m_ssp_regs.tx_fifo[m_ssp_regs.tx_fifo_read_idx]; + const u16 data = m_ssp_regs.tx_fifo[m_ssp_regs.tx_fifo_read_idx]; m_ssp_out(data); + LOGMASKED(LOG_SSP, "SSP: Transmitting %04x, new Tx FIFO count %d\n", data, m_ssp_regs.tx_fifo_count); m_ssp_regs.tx_fifo_read_idx = (m_ssp_regs.tx_fifo_read_idx + 1) % std::size(m_ssp_regs.tx_fifo); m_ssp_regs.tx_fifo_count--; m_ssp_regs.sssr |= (1 << SSSR_TNF_BIT); + if (m_ssp_regs.tx_fifo_count || m_ssp_regs.rx_fifo_count) + m_ssp_regs.sssr |= (1 << SSSR_BSY_BIT); + else + m_ssp_regs.sssr &= ~(1 << SSSR_BSY_BIT); + ssp_update_tx_level(); } } @@ -1195,7 +1442,7 @@ void sa1110_periphs_device::ssp_update_enable_state() m_ssp_regs.sssr &= ~(1 << SSSR_RFS_BIT); uint64_t bit_count = (m_ssp_regs.sscr0 & SSCR0_DSS_MASK) >> SSCR0_DSS_BIT; - uint32_t clock_rate = 2 * (((m_ssp_regs.sscr0 & SSCR0_SCR_MASK) >> SSCR0_SCR_BIT) + 1); + u32 clock_rate = 2 * (((m_ssp_regs.sscr0 & SSCR0_SCR_MASK) >> SSCR0_SCR_BIT) + 1); attotime packet_rate = attotime::from_ticks(bit_count * clock_rate, 3686400); m_ssp_regs.rx_timer->adjust(packet_rate, 0, packet_rate); m_ssp_regs.tx_timer->adjust(packet_rate, 0, packet_rate); @@ -1225,7 +1472,7 @@ void sa1110_periphs_device::ssp_update_rx_level() m_ssp_regs.sssr &= ~(1 << SSSR_RFS_BIT); } -void sa1110_periphs_device::ssp_rx_fifo_push(const uint16_t data) +void sa1110_periphs_device::ssp_rx_fifo_push(const u16 data) { if (m_ssp_regs.rx_fifo_count < std::size(m_ssp_regs.rx_fifo)) { @@ -1247,7 +1494,7 @@ void sa1110_periphs_device::ssp_update_tx_level() m_ssp_regs.sssr &= ~(1 << SSSR_TFS_BIT); } -void sa1110_periphs_device::ssp_tx_fifo_push(const uint16_t data) +void sa1110_periphs_device::ssp_tx_fifo_push(const u16 data) { if (m_ssp_regs.tx_fifo_count < std::size(m_ssp_regs.tx_fifo)) { @@ -1269,9 +1516,9 @@ void sa1110_periphs_device::ssp_tx_fifo_push(const uint16_t data) m_ssp_regs.sssr &= ~(1 << SSSR_BSY_BIT); } -uint16_t sa1110_periphs_device::ssp_rx_fifo_pop() +u16 sa1110_periphs_device::ssp_rx_fifo_pop() { - uint16_t data = m_ssp_regs.rx_fifo[m_ssp_regs.rx_fifo_read_idx]; + u16 data = m_ssp_regs.rx_fifo[m_ssp_regs.rx_fifo_read_idx]; if (m_ssp_regs.rx_fifo_count) { m_ssp_regs.rx_fifo_read_idx = (m_ssp_regs.rx_fifo_read_idx + 1) % std::size(m_ssp_regs.rx_fifo); @@ -1280,93 +1527,96 @@ uint16_t sa1110_periphs_device::ssp_rx_fifo_pop() if (m_ssp_regs.rx_fifo_count == 0) m_ssp_regs.sssr &= ~(1 << SSSR_RNE_BIT); + if (m_ssp_regs.tx_fifo_count || m_ssp_regs.rx_fifo_count) + m_ssp_regs.sssr |= (1 << SSSR_BSY_BIT); + else + m_ssp_regs.sssr &= ~(1 << SSSR_BSY_BIT); + ssp_update_rx_level(); } return data; } -uint32_t sa1110_periphs_device::ssp_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::ssp_sscr0_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_SSCR0: - LOGMASKED(LOG_SSP, "%s: ssp_r: SSP Control Register 0: %08x & %08x\n", machine().describe_context(), m_ssp_regs.sscr0, mem_mask); - return m_ssp_regs.sscr0; - case REG_SSCR1: - LOGMASKED(LOG_SSP, "%s: ssp_r: SSP Control Register 1: %08x & %08x\n", machine().describe_context(), m_ssp_regs.sscr1, mem_mask); - return m_ssp_regs.sscr1; - case REG_SSDR: - { - const uint32_t data = ssp_rx_fifo_pop(); - LOGMASKED(LOG_SSP, "%s: ssp_r: SSP Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - return data; - } - case REG_SSSR: - LOGMASKED(LOG_SSP, "%s: ssp_r: SSP Status Register: %08x & %08x\n", machine().describe_context(), m_ssp_regs.sssr, mem_mask); - LOGMASKED(LOG_SSP, "%s: Transmit FIFO Not Full: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_TNF_BIT)); - LOGMASKED(LOG_SSP, "%s: Receive FIFO Not Empty: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_RNE_BIT)); - LOGMASKED(LOG_SSP, "%s: SSP Busy: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_BSY_BIT)); - LOGMASKED(LOG_SSP, "%s: Transmit FIFO Service Request: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_TFS_BIT)); - LOGMASKED(LOG_SSP, "%s: Receive FIFO Service Request: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_RFS_BIT)); - LOGMASKED(LOG_SSP, "%s: Receive Overrun: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_ROR_BIT)); - return m_ssp_regs.sssr; - default: - LOGMASKED(LOG_SSP | LOG_UNKNOWN, "%s: ssp_r: Unknown address: %08x & %08x\n", machine().describe_context(), SSP_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_ssp_regs.sscr0; + LOGMASKED(LOG_SSP, "%s: ssp_sscr0_r: SSP Control Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::ssp_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::ssp_sscr0_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) + static const char *const s_dss_sizes[16] = { - case REG_SSCR0: - { - static const char *const s_dss_sizes[16] = - { - "Invalid [1]", "Invalid [2]", "Invalid [3]", "4-bit", - "5-bit", "6-bit", "7-bit", "8-bit", - "9-bit", "10-bit", "11-bit", "12-bit", - "13-bit", "14-bit", "15-bit", "16-bit" - }; - static const char *const s_frf_formats[4] = { "Motorola SPI", "TI Synchronous Serial", "National Microwire", "Reserved" }; - LOGMASKED(LOG_SSP, "%s: ssp_w: SSP Control Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_SSP, "%s: Data Size Select: %s\n", machine().describe_context(), s_dss_sizes[(data & SSCR0_DSS_MASK) >> SSCR0_DSS_BIT]); - LOGMASKED(LOG_SSP, "%s: Frame Format: %s\n", machine().describe_context(), s_frf_formats[(data & SSCR0_FRF_MASK) >> SSCR0_FRF_BIT]); - LOGMASKED(LOG_SSP, "%s: SSP Enable: %d\n", machine().describe_context(), BIT(data, SSCR0_SSE_BIT)); - LOGMASKED(LOG_SSP, "%s: Serial Clock Rate Divisor: %d\n", machine().describe_context(), 2 * (data & SSCR0_DSS_MASK) >> SSCR0_DSS_BIT); - const uint32_t old = m_ssp_regs.sscr0; - COMBINE_DATA(&m_ssp_regs.sscr0); - if (BIT(old ^ m_ssp_regs.sscr0, SSCR0_SSE_BIT)) - ssp_update_enable_state(); - break; - } - case REG_SSCR1: - { - LOGMASKED(LOG_SSP, "%s: ssp_w: SSP Control Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_SSP, "%s: Receive FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, SSCR1_RIE_BIT)); - LOGMASKED(LOG_SSP, "%s: Transmit FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, SSCR1_TIE_BIT)); - LOGMASKED(LOG_SSP, "%s: Loopback Mode Enable: %d\n", machine().describe_context(), BIT(data, SSCR1_LBM_BIT)); - LOGMASKED(LOG_SSP, "%s: Serial Clock Polarity: %d\n", machine().describe_context(), BIT(data, SSCR1_SPO_BIT)); - LOGMASKED(LOG_SSP, "%s: Serial Clock Phase: %d\n", machine().describe_context(), BIT(data, SSCR1_SPH_BIT)); - LOGMASKED(LOG_SSP, "%s: External Clock Select: %d\n", machine().describe_context(), BIT(data, SSCR1_ECS_BIT)); - COMBINE_DATA(&m_ssp_regs.sscr1); - break; - } - case REG_SSDR: - LOGMASKED(LOG_SSP, "%s: ssp_w: SSP Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - ssp_tx_fifo_push((uint16_t)data); - break; - case REG_SSSR: - LOGMASKED(LOG_SSP, "%s: ssp_w: SSP Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - LOGMASKED(LOG_SSP, "%s: Clear Receive Overrun: %d\n", machine().describe_context(), BIT(data, SSSR_ROR_BIT)); - break; - default: - LOGMASKED(LOG_SSP | LOG_UNKNOWN, "%s: ssp_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), SSP_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + "Invalid [1]", "Invalid [2]", "Invalid [3]", "4-bit", + "5-bit", "6-bit", "7-bit", "8-bit", + "9-bit", "10-bit", "11-bit", "12-bit", + "13-bit", "14-bit", "15-bit", "16-bit" + }; + static const char *const s_frf_formats[4] = { "Motorola SPI", "TI Synchronous Serial", "National Microwire", "Reserved" }; + LOGMASKED(LOG_SSP, "%s: ssp_sscr0_w: SSP Control Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_SSP, "%s: Data Size Select: %s\n", machine().describe_context(), s_dss_sizes[(data & SSCR0_DSS_MASK) >> SSCR0_DSS_BIT]); + LOGMASKED(LOG_SSP, "%s: Frame Format: %s\n", machine().describe_context(), s_frf_formats[(data & SSCR0_FRF_MASK) >> SSCR0_FRF_BIT]); + LOGMASKED(LOG_SSP, "%s: SSP Enable: %d\n", machine().describe_context(), BIT(data, SSCR0_SSE_BIT)); + LOGMASKED(LOG_SSP, "%s: Serial Clock Rate Divisor: %d\n", machine().describe_context(), 2 * (data & SSCR0_DSS_MASK) >> SSCR0_DSS_BIT); + const u32 old = m_ssp_regs.sscr0; + COMBINE_DATA(&m_ssp_regs.sscr0); + if (BIT(old ^ m_ssp_regs.sscr0, SSCR0_SSE_BIT)) + ssp_update_enable_state(); } +u32 sa1110_periphs_device::ssp_sscr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ssp_regs.sscr1; + LOGMASKED(LOG_SSP, "%s: ssp_sscr1_r: SSP Control Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::ssp_sscr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_SSP, "%s: ssp_sscr1_w: SSP Control Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_SSP, "%s: Receive FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, SSCR1_RIE_BIT)); + LOGMASKED(LOG_SSP, "%s: Transmit FIFO Interrupt Enable: %d\n", machine().describe_context(), BIT(data, SSCR1_TIE_BIT)); + LOGMASKED(LOG_SSP, "%s: Loopback Mode Enable: %d\n", machine().describe_context(), BIT(data, SSCR1_LBM_BIT)); + LOGMASKED(LOG_SSP, "%s: Serial Clock Polarity: %d\n", machine().describe_context(), BIT(data, SSCR1_SPO_BIT)); + LOGMASKED(LOG_SSP, "%s: Serial Clock Phase: %d\n", machine().describe_context(), BIT(data, SSCR1_SPH_BIT)); + LOGMASKED(LOG_SSP, "%s: External Clock Select: %d\n", machine().describe_context(), BIT(data, SSCR1_ECS_BIT)); + COMBINE_DATA(&m_ssp_regs.sscr1); +} + +u32 sa1110_periphs_device::ssp_ssdr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = ssp_rx_fifo_pop(); + LOGMASKED(LOG_SSP, "%s: ssp_ssdr_r: SSP Data Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::ssp_ssdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_SSP, "%s: ssp_ssdr_w: SSP Data Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + ssp_tx_fifo_push((u16)data); +} + +u32 sa1110_periphs_device::ssp_sssr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ssp_regs.sssr; + LOGMASKED(LOG_SSP, "%s: ssp_r: SSP Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_SSP, "%s: Transmit FIFO Not Full: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_TNF_BIT)); + LOGMASKED(LOG_SSP, "%s: Receive FIFO Not Empty: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_RNE_BIT)); + LOGMASKED(LOG_SSP, "%s: SSP Busy: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_BSY_BIT)); + LOGMASKED(LOG_SSP, "%s: Transmit FIFO Service Request: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_TFS_BIT)); + LOGMASKED(LOG_SSP, "%s: Receive FIFO Service Request: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_RFS_BIT)); + LOGMASKED(LOG_SSP, "%s: Receive Overrun: %d\n", machine().describe_context(), BIT(m_ssp_regs.sssr, SSSR_ROR_BIT)); + return data; +} + +void sa1110_periphs_device::ssp_sssr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_SSP, "%s: ssp_sssr_w: SSP Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + LOGMASKED(LOG_SSP, "%s: Clear Receive Overrun: %d\n", machine().describe_context(), BIT(data, SSSR_ROR_BIT)); +} + + /* Intel SA-1110 Operating System Timer @@ -1393,134 +1643,160 @@ void sa1110_periphs_device::ostimer_update_count() if (ticks_elapsed == 0ULL) // Accrue time until we can tick at least once return; - const uint32_t wrapped_ticks = (uint32_t)ticks_elapsed; + const u32 wrapped_ticks = (u32)ticks_elapsed; m_ostmr_regs.oscr += wrapped_ticks; m_ostmr_regs.last_count_sync = machine().time(); } void sa1110_periphs_device::ostimer_update_match_timer(int channel) { + ostimer_update_count(); uint64_t ticks_remaining = m_ostmr_regs.osmr[channel] - m_ostmr_regs.oscr; if (m_ostmr_regs.oscr >= m_ostmr_regs.osmr[channel]) ticks_remaining += 0x100000000ULL; m_ostmr_regs.timer[channel]->adjust(attotime::from_ticks(ticks_remaining, INTERNAL_OSC), channel); + if (channel != 0) + LOGMASKED(LOG_OSTIMER, "ostimer_update_match_timer: %d ticks at %dHz (%4.fms)\n", ticks_remaining, INTERNAL_OSC, attotime::from_ticks(ticks_remaining, INTERNAL_OSC).as_double() * 1000.0); } -uint32_t sa1110_periphs_device::ostimer_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::tmr_osmr0_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.osmr[0]; + LOGMASKED(LOG_OSTIMER_HF, "%s: tmr_osmr0_r: OS Timer Match Register 0: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_osmr0_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_OSTIMER_HF, "%s: tmr_osmr0_w: OS Timer Match Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ostmr_regs.osmr[0]); + ostimer_update_match_timer(0); +} + +u32 sa1110_periphs_device::tmr_osmr1_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.osmr[1]; + LOGMASKED(LOG_OSTIMER, "%s: tmr_osmr1_r: OS Timer Match Register 1: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_osmr1_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_OSTIMER, "%s: tmr_osmr1_w: OS Timer Match Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ostmr_regs.osmr[1]); + ostimer_update_match_timer(1); +} + +u32 sa1110_periphs_device::tmr_osmr2_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.osmr[2]; + LOGMASKED(LOG_OSTIMER, "%s: tmr_osmr2_r: OS Timer Match Register 2: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_osmr2_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_OSTIMER, "%s: tmr_osmr2_w: OS Timer Match Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ostmr_regs.osmr[2]); + ostimer_update_match_timer(2); +} + +u32 sa1110_periphs_device::tmr_osmr3_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.osmr[3]; + LOGMASKED(LOG_OSTIMER, "%s: tmr_osmr3_r: OS Timer Match Register 3: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_osmr3_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_OSTIMER, "%s: tmr_osmr3_w: OS Timer Match Register 3 = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ostmr_regs.osmr[3]); + ostimer_update_match_timer(3); +} + +u32 sa1110_periphs_device::tmr_oscr_r(offs_t offset, u32 mem_mask) { ostimer_update_count(); - switch (offset) - { - case REG_OSMR0: - LOGMASKED(LOG_OSTIMER_HF, "%s: ostimer_r: OS Timer Match Register 0: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.osmr[0], mem_mask); - return m_ostmr_regs.osmr[0]; - case REG_OSMR1: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_r: OS Timer Match Register 1: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.osmr[1], mem_mask); - return m_ostmr_regs.osmr[1]; - case REG_OSMR2: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_r: OS Timer Match Register 2: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.osmr[2], mem_mask); - return m_ostmr_regs.osmr[2]; - case REG_OSMR3: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_r: OS Timer Match Register 3: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.osmr[3], mem_mask); - return m_ostmr_regs.osmr[3]; - case REG_OSCR: - LOGMASKED(LOG_OSTIMER_HF, "%s: ostimer_r: OS Timer Counter Register: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.oscr, mem_mask); - return m_ostmr_regs.oscr; - case REG_OSSR: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_r: OS Timer Status Register: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.ossr, mem_mask); - return m_ostmr_regs.ossr; - case REG_OWER: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_r: OS Timer Watchdog Enable Register: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.ower, mem_mask); - return m_ostmr_regs.ower; - case REG_OIER: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_r: OS Timer Interrupt Enable Register: %08x & %08x\n", machine().describe_context(), m_ostmr_regs.oier, mem_mask); - return m_ostmr_regs.oier; - default: - LOGMASKED(LOG_OSTIMER | LOG_UNKNOWN, "%s: ostimer_r: Unknown address: %08x & %08x\n", machine().describe_context(), OSTMR_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_ostmr_regs.oscr; + LOGMASKED(LOG_OSTIMER_HF, "%s: tmr_oscr_r: OS Timer Counter Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::ostimer_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::tmr_oscr_w(offs_t offset, u32 data, u32 mem_mask) { - ostimer_update_count(); - - switch (offset) + LOGMASKED(LOG_OSTIMER, "%s: tmr_oscr_w: OS Timer Counter Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ostmr_regs.oscr); + m_ostmr_regs.last_count_sync = machine().time(); + for (int channel = 0; channel < 4; channel++) { - case REG_OSMR0: - LOGMASKED(LOG_OSTIMER_HF, "%s: ostimer_w: OS Timer Match Register 0 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ostmr_regs.osmr[0]); - ostimer_update_match_timer(0); - break; - case REG_OSMR1: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_w: OS Timer Match Register 1 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ostmr_regs.osmr[1]); - ostimer_update_match_timer(1); - break; - case REG_OSMR2: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_w: OS Timer Match Register 2 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ostmr_regs.osmr[2]); - ostimer_update_match_timer(2); - break; - case REG_OSMR3: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_w: OS Timer Match Register 3 = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ostmr_regs.osmr[3]); - ostimer_update_match_timer(3); - break; - case REG_OSCR: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_w: OS Timer Counter Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ostmr_regs.oscr); - m_ostmr_regs.last_count_sync = machine().time(); - for (int channel = 0; channel < 4; channel++) + if (m_ostmr_regs.oscr == m_ostmr_regs.osmr[channel] && BIT(m_ostmr_regs.oier, channel)) { - if (m_ostmr_regs.oscr == m_ostmr_regs.osmr[channel] && BIT(m_ostmr_regs.oier, channel)) + if (!BIT(m_ostmr_regs.ossr, channel)) { - if (!BIT(m_ostmr_regs.ossr, channel)) - { - m_ostmr_regs.ossr |= (1 << channel); - set_irq_line(INT_OSTIMER0 + channel, 1); - } - } - else - { - ostimer_update_match_timer(channel); + m_ostmr_regs.ossr |= (1 << channel); + set_irq_line(INT_OSTIMER0 + channel, 1); } } - break; - case REG_OSSR: - { - LOGMASKED(LOG_OSTIMER_HF, "%s: ostimer_w: OS Timer Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_ostmr_regs.ossr; - m_ostmr_regs.ossr &= ~(data & mem_mask); - if (old != m_ostmr_regs.ossr) + else { - for (int channel = 0; channel < 4; channel++) - { - if (BIT(old, channel)) - set_irq_line(INT_OSTIMER0 + channel, 0); - } + ostimer_update_match_timer(channel); } - break; - } - case REG_OWER: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_w: OS Timer Watchdog Enable Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - if (!m_ostmr_regs.ower) - { - m_ostmr_regs.ower = data & mem_mask & 1; - } - break; - case REG_OIER: - LOGMASKED(LOG_OSTIMER, "%s: ostimer_w: OS Timer Interrupt Enable Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ostmr_regs.oier); - break; - default: - LOGMASKED(LOG_OSTIMER | LOG_UNKNOWN, "%s: ostimer_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), OSTMR_BASE_ADDR | (offset << 2), - data, mem_mask); - break; } } +u32 sa1110_periphs_device::tmr_ossr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.ossr; + LOGMASKED(LOG_OSTIMER, "%s: tmr_ossr_r: OS Timer Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_ossr_w(offs_t offset, u32 data, u32 mem_mask) +{ + if (data != 1) + LOGMASKED(LOG_OSTIMER, "%s: tmr_ossr_w: OS Timer Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_ostmr_regs.ossr; + m_ostmr_regs.ossr &= ~(data & mem_mask); + const u32 cleared = old & ~ m_ostmr_regs.ossr; + for (int channel = 0; channel < 4; channel++) + { + if (BIT(cleared, channel)) + set_irq_line(INT_OSTIMER0 + channel, 0); + } +} + +u32 sa1110_periphs_device::tmr_ower_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.ower; + LOGMASKED(LOG_OSTIMER, "%s: tmr_ower_r: OS Timer Watchdog Enable Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_ower_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_OSTIMER, "%s: tmr_ower_w: OS Timer Watchdog Enable Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + if (!m_ostmr_regs.ower) + { + m_ostmr_regs.ower = data & mem_mask & 1; + } +} + +u32 sa1110_periphs_device::tmr_oier_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ostmr_regs.oier; + LOGMASKED(LOG_OSTIMER, "%s: tmr_oier_r: OS Timer Interrupt Enable Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::tmr_oier_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_OSTIMER, "%s: tmr_oier_w: OS Timer Interrupt Enable Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ostmr_regs.oier); +} + + /* Intel SA-1110 Real-Time Clock @@ -1545,73 +1821,75 @@ TIMER_CALLBACK_MEMBER(sa1110_periphs_device::rtc_tick_cb) set_irq_line(INT_RTC_TICK, 1); } -uint32_t sa1110_periphs_device::rtc_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::rtc_rtar_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_RTAR: - LOGMASKED(LOG_RTC, "%s: rtc_r: RTC Alarm Register: %08x & %08x\n", machine().describe_context(), m_rtc_regs.rtar, mem_mask); - return m_rtc_regs.rtar; - case REG_RCNR: - LOGMASKED(LOG_RTC_HF, "%s: rtc_r: RTC Count Register: %08x & %08x\n", machine().describe_context(), m_rtc_regs.rcnr, mem_mask); - return m_rtc_regs.rcnr; - case REG_RTTR: - LOGMASKED(LOG_RTC, "%s: rtc_r: RTC Timer Trim Register: %08x & %08x\n", machine().describe_context(), m_rtc_regs.rttr, mem_mask); - return m_rtc_regs.rttr; - case REG_RTSR: - LOGMASKED(LOG_RTC, "%s: rtc_r: RTC Status Register: %08x & %08x\n", machine().describe_context(), m_rtc_regs.rtsr, mem_mask); - return m_rtc_regs.rtsr; - default: - LOGMASKED(LOG_RTC | LOG_UNKNOWN, "%s: reset_r: Unknown address: %08x & %08x\n", machine().describe_context(), RTC_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_rtc_regs.rtar; + LOGMASKED(LOG_RTC, "%s: rtc_rtar_r: RTC Alarm Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::rtc_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::rtc_rtar_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_RTAR: - LOGMASKED(LOG_RTC, "%s: rtc_w: RTC Alarm Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_rtc_regs.rtar); - break; - case REG_RCNR: - LOGMASKED(LOG_RTC, "%s: rtc_w: RTC Count Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_rtc_regs.rcnr); - break; - case REG_RTTR: - LOGMASKED(LOG_RTC, "%s: rtc_w: RTC Timer Trim Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_rtc_regs.rttr); - // TODO: Implement timer trimming - break; - case REG_RTSR: - { - LOGMASKED(LOG_RTC, "%s: rtc_w: RTC Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - - const uint32_t old = m_rtc_regs.rtsr; - const bool old_alarm_int = BIT(old, RTSR_AL_MASK) && BIT(m_rtc_regs.rtsr, RTSR_ALE_MASK); - const bool old_tick_int = BIT(old, RTSR_HZ_MASK) && BIT(m_rtc_regs.rtsr, RTSR_HZE_MASK); - - m_rtc_regs.rtsr &= ~(data & (RTSR_AL_MASK | RTSR_HZ_MASK) & mem_mask); - m_rtc_regs.rtsr &= ~(RTSR_ALE_MASK | RTSR_HZE_MASK); - m_rtc_regs.rtsr |= (data & (RTSR_ALE_MASK | RTSR_HZE_MASK) & mem_mask); - - const bool new_alarm_int = BIT(m_rtc_regs.rtsr, RTSR_AL_MASK) && BIT(m_rtc_regs.rtsr, RTSR_ALE_MASK); - const bool new_tick_int = BIT(m_rtc_regs.rtsr, RTSR_HZ_MASK) && BIT(m_rtc_regs.rtsr, RTSR_HZE_MASK); - - if (old_alarm_int != new_alarm_int) - set_irq_line(INT_RTC_ALARM, (int)new_alarm_int); - if (old_tick_int != new_tick_int) - set_irq_line(INT_RTC_TICK, (int)new_tick_int); - break; - } - default: - LOGMASKED(LOG_RTC | LOG_UNKNOWN, "%s: reset_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), RTC_BASE_ADDR | (offset << 2), - data, mem_mask); - break; - } + LOGMASKED(LOG_RTC, "%s: rtc_rtar_w: RTC Alarm Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_rtc_regs.rtar); } +u32 sa1110_periphs_device::rtc_rcnr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_rtc_regs.rcnr; + LOGMASKED(LOG_RTC_HF, "%s: rtc_rcnr_r: RTC Count Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::rtc_rcnr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_RTC, "%s: rtc_rcnr_w: RTC Count Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_rtc_regs.rcnr); +} + +u32 sa1110_periphs_device::rtc_rttr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_rtc_regs.rttr; + LOGMASKED(LOG_RTC, "%s: rtc_rttr_r: RTC Timer Trim Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::rtc_rttr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_RTC, "%s: rtc_rttr_w: RTC Timer Trim Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_rtc_regs.rttr); + // TODO: Implement timer trimming +} + +u32 sa1110_periphs_device::rtc_rtsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_rtc_regs.rtsr; + LOGMASKED(LOG_RTC, "%s: rtc_rtsr_r: RTC Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::rtc_rtsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_RTC, "%s: rtc_w: RTC Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + + const u32 old = m_rtc_regs.rtsr; + const bool old_alarm_int = BIT(old, RTSR_AL_BIT) && BIT(m_rtc_regs.rtsr, RTSR_ALE_BIT); + const bool old_tick_int = BIT(old, RTSR_HZ_BIT) && BIT(m_rtc_regs.rtsr, RTSR_HZE_BIT); + + m_rtc_regs.rtsr &= ~(data & (RTSR_AL_MASK | RTSR_HZ_MASK) & mem_mask); + m_rtc_regs.rtsr &= ~(RTSR_ALE_MASK | RTSR_HZE_MASK); + m_rtc_regs.rtsr |= (data & (RTSR_ALE_MASK | RTSR_HZE_MASK) & mem_mask); + + const bool new_alarm_int = BIT(m_rtc_regs.rtsr, RTSR_AL_BIT) && BIT(m_rtc_regs.rtsr, RTSR_ALE_BIT); + const bool new_tick_int = BIT(m_rtc_regs.rtsr, RTSR_HZ_BIT) && BIT(m_rtc_regs.rtsr, RTSR_HZE_BIT); + + if (old_alarm_int != new_alarm_int) + set_irq_line(INT_RTC_ALARM, (int)new_alarm_int); + if (old_tick_int != new_tick_int) + set_irq_line(INT_RTC_TICK, (int)new_tick_int); +} + + /* Intel SA-1110 Power Controller @@ -1620,82 +1898,110 @@ void sa1110_periphs_device::rtc_w(offs_t offset, uint32_t data, uint32_t mem_mas */ -uint32_t sa1110_periphs_device::power_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::pwr_pmcr_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_PMCR: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager Control Register: %08x & %08x\n", machine().describe_context(), m_power_regs.pmcr, mem_mask); - return m_power_regs.pmcr; - case REG_PSSR: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager Sleep Status Register: %08x & %08x\n", machine().describe_context(), m_power_regs.pssr, mem_mask); - return m_power_regs.pssr; - case REG_PSPR: - LOGMASKED(LOG_POWER_HF, "%s: power_r: Power Manager Scratch Pad Register: %08x & %08x\n", machine().describe_context(), m_power_regs.pspr, mem_mask); - return m_power_regs.pspr; - case REG_PWER: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager Wake-up Enable Register: %08x & %08x\n", machine().describe_context(), m_power_regs.pwer, mem_mask); - return m_power_regs.pwer; - case REG_PCFR: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager General Configuration Register: %08x & %08x\n", machine().describe_context(), m_power_regs.pcfr, mem_mask); - return m_power_regs.pcfr; - case REG_PPCR: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager PLL Configuration Register: %08x & %08x\n", machine().describe_context(), m_power_regs.ppcr, mem_mask); - return m_power_regs.ppcr; - case REG_PGSR: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager GPIO Sleep State Register: %08x & %08x\n", machine().describe_context(), m_power_regs.pgsr, mem_mask); - return m_power_regs.pgsr; - case REG_POSR: - LOGMASKED(LOG_POWER, "%s: power_r: Power Manager Oscillator Status Register: %08x & %08x\n", machine().describe_context(), m_power_regs.posr, mem_mask); - return m_power_regs.posr; - default: - LOGMASKED(LOG_POWER | LOG_UNKNOWN, "%s: power_r: Unknown address: %08x & %08x\n", machine().describe_context(), POWER_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_power_regs.pmcr; + LOGMASKED(LOG_POWER, "%s: pwr_pmcr_r: Power Manager Control Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::power_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::pwr_pmcr_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_PMCR: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager Control Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_power_regs.pmcr); - break; - case REG_PSSR: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager Sleep Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - m_power_regs.pssr &= ~(data & 0x0000001f); - break; - case REG_PSPR: - LOGMASKED(LOG_POWER_HF, "%s: power_w: Power Manager Scratch Pad Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_power_regs.pspr); - break; - case REG_PWER: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager Wake-Up Enable Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_power_regs.pwer); - break; - case REG_PCFR: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager General Configuration Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_power_regs.pcfr); - break; - case REG_PPCR: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager PLL Configuration Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_power_regs.ppcr); - break; - case REG_PGSR: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager GPIO Sleep State Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_power_regs.pgsr); - break; - case REG_POSR: - LOGMASKED(LOG_POWER, "%s: power_w: Power Manager Oscillator Status Register (ignored) = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - default: - LOGMASKED(LOG_POWER | LOG_UNKNOWN, "%s: power_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), POWER_BASE_ADDR | (offset << 2), - data, mem_mask); - break; - } + LOGMASKED(LOG_POWER, "%s: pwr_pmcr_w: Power Manager Control Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_power_regs.pmcr); } +u32 sa1110_periphs_device::pwr_pssr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.pssr; + LOGMASKED(LOG_POWER, "%s: pwr_pssr_r: Power Manager Sleep Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_pssr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER, "%s: pwr_pssr_w: Power Manager Sleep Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + m_power_regs.pssr &= ~(data & 0x0000001f); +} + +u32 sa1110_periphs_device::pwr_pspr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.pspr; + LOGMASKED(LOG_POWER_HF, "%s: pwr_pspr_r: Power Manager Scratch Pad Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_pspr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER_HF, "%s: pwr_pspr_w: Power Manager Scratch Pad Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_power_regs.pspr); +} + +u32 sa1110_periphs_device::pwr_pwer_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.pwer; + LOGMASKED(LOG_POWER, "%s: pwr_pwer_r: Power Manager Wake-up Enable Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_pwer_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER, "%s: pwr_pwer_w: Power Manager Wake-Up Enable Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_power_regs.pwer); +} + +u32 sa1110_periphs_device::pwr_pcfr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.pcfr; + LOGMASKED(LOG_POWER, "%s: pwr_pcfr_r: Power Manager General Configuration Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_pcfr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER, "%s: pwr_pcfr_w: Power Manager General Configuration Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_power_regs.pcfr); +} + +u32 sa1110_periphs_device::pwr_ppcr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.ppcr; + LOGMASKED(LOG_POWER, "%s: pwr_ppcr_r: Power Manager PLL Configuration Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_ppcr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER, "%s: pwr_ppcr_w: Power Manager PLL Configuration Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_power_regs.ppcr); +} + +u32 sa1110_periphs_device::pwr_pgsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.pgsr; + LOGMASKED(LOG_POWER, "%s: pwr_pgsr_r: Power Manager GPIO Sleep State Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_pgsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER, "%s: pwr_pgsr_w: Power Manager GPIO Sleep State Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_power_regs.pgsr); +} + +u32 sa1110_periphs_device::pwr_posr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_power_regs.posr; + LOGMASKED(LOG_POWER, "%s: pwr_posr_r: Power Manager Oscillator Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::pwr_posr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_POWER, "%s: power_w: Power Manager Oscillator Status Register (ignored) = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + + /* Intel SA-1110 Reset Controller @@ -1704,40 +2010,32 @@ void sa1110_periphs_device::power_w(offs_t offset, uint32_t data, uint32_t mem_m */ -uint32_t sa1110_periphs_device::reset_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::rst_rsrr_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_RSRR: - LOGMASKED(LOG_RESET, "%s: reset_r: Reset Controller Software Reset Register: %08x & %08x\n", machine().describe_context(), 0, mem_mask); - return 0; - case REG_RCSR: - LOGMASKED(LOG_RESET, "%s: reset_r: Reset Controller Status Register: %08x & %08x\n", machine().describe_context(), m_rcsr, mem_mask); - return m_rcsr; - default: - LOGMASKED(LOG_RESET | LOG_UNKNOWN, "%s: reset_r: Unknown address: %08x & %08x\n", machine().describe_context(), RESET_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = 0; + LOGMASKED(LOG_RESET, "%s: rst_rsrr_r: Reset Controller Software Reset Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::reset_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::rst_rsrr_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_RSRR: - LOGMASKED(LOG_RESET, "%s: reset_w: Reset Controller Software Reset Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_RCSR: - LOGMASKED(LOG_RESET, "%s: reset_w: Reset Controller Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - m_rcsr &= ~(data & mem_mask); - break; - default: - LOGMASKED(LOG_RESET | LOG_UNKNOWN, "%s: reset_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), RESET_BASE_ADDR | (offset << 2), - data, mem_mask); - break; - } + LOGMASKED(LOG_RESET, "%s: rst_rsrr_w: Reset Controller Software Reset Register (ignored) = %08x & %08x\n", machine().describe_context(), data, mem_mask); } +u32 sa1110_periphs_device::rst_rcsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_rcsr; + LOGMASKED(LOG_RESET, "%s: rst_rcsr_r: Reset Controller Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::rst_rcsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_RESET, "%s: rst_rcsr_w: Reset Controller Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + m_rcsr &= ~(data & mem_mask); +} + + /* Intel SA-1110 GPIO Controller @@ -1746,10 +2044,10 @@ void sa1110_periphs_device::reset_w(offs_t offset, uint32_t data, uint32_t mem_m */ -void sa1110_periphs_device::gpio_in(const uint32_t line, const int state) +void sa1110_periphs_device::gpio_in(const u32 line, const int state) { - const uint32_t mask = (1 << line); - const uint32_t old_latch = m_gpio_regs.input_latch; + const u32 mask = (1 << line); + const u32 old_latch = m_gpio_regs.input_latch; m_gpio_regs.input_latch &= ~mask; m_gpio_regs.input_latch |= (state << line); @@ -1760,7 +2058,7 @@ void sa1110_periphs_device::gpio_in(const uint32_t line, const int state) // If it can also function on outputs, remove the GPDR check below. if (!BIT(m_gpio_regs.gpdr, line) && BIT(m_gpio_regs.any_edge_mask, line)) { - const uint32_t old_edge = m_gpio_regs.gedr; + const u32 old_edge = m_gpio_regs.gedr; if (state && BIT(m_gpio_regs.grer, line)) m_gpio_regs.gedr |= mask; if (!state && BIT(m_gpio_regs.gfer, line)) @@ -1774,10 +2072,10 @@ void sa1110_periphs_device::gpio_in(const uint32_t line, const int state) } } -void sa1110_periphs_device::gpio_update_interrupts(const uint32_t changed_mask) +void sa1110_periphs_device::gpio_update_interrupts(const u32 changed_mask) { - uint32_t remaining_mask = changed_mask; - for (uint32_t line = 0; line < 11; line++) + u32 remaining_mask = changed_mask; + for (u32 line = 0; line < 11; line++) { if (!BIT(remaining_mask, line)) continue; @@ -1792,12 +2090,12 @@ void sa1110_periphs_device::gpio_update_interrupts(const uint32_t changed_mask) set_irq_line(INT_GPIOHI, (m_gpio_regs.gedr & 0x0ffff800) ? 1 : 0); } -void sa1110_periphs_device::gpio_update_direction(const uint32_t old_gpdr) +void sa1110_periphs_device::gpio_update_direction(const u32 old_gpdr) { - const uint32_t new_outputs = ~old_gpdr & m_gpio_regs.gpdr & ~m_gpio_regs.gafr; + const u32 new_outputs = ~old_gpdr & m_gpio_regs.gpdr & ~m_gpio_regs.gafr; if (new_outputs) { - for (uint32_t line = 0; line < 28; line++) + for (u32 line = 0; line < 28; line++) { if (BIT(new_outputs, line)) { @@ -1809,11 +2107,11 @@ void sa1110_periphs_device::gpio_update_direction(const uint32_t old_gpdr) // TODO: Do we need to check rising/falling edges based on the transition from output to input? } -void sa1110_periphs_device::gpio_update_outputs(const uint32_t old_latch, const uint32_t changed) +void sa1110_periphs_device::gpio_update_outputs(const u32 old_latch, const u32 changed) { - uint32_t remaining_changed = changed; + u32 remaining_changed = changed; - for (uint32_t line = 0; line < 28 && remaining_changed != 0; line++) + for (u32 line = 0; line < 28 && remaining_changed != 0; line++) { if (BIT(remaining_changed, line)) { @@ -1823,115 +2121,135 @@ void sa1110_periphs_device::gpio_update_outputs(const uint32_t old_latch, const } } -void sa1110_periphs_device::gpio_update_alternate_pins(const uint32_t changed_mask) +void sa1110_periphs_device::gpio_update_alternate_pins(const u32 changed_mask) { // TODO } -uint32_t sa1110_periphs_device::gpio_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::gpio_gplr_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_GPLR: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Pin-Level Register: %08x & %08x\n", machine().describe_context(), m_gpio_regs.gplr, mem_mask); - return m_gpio_regs.gplr; - case REG_GPDR: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Pin Direction Register: %08x & %08x\n", machine().describe_context(), m_gpio_regs.gpdr, mem_mask); - return m_gpio_regs.gpdr; - case REG_GPSR: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Pin Output Set Register: %08x & %08x\n", machine().describe_context(), 0, mem_mask); - return 0; - case REG_GPCR: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Pin Output Clear Register (ignored): %08x & %08x\n", machine().describe_context(), 0, mem_mask); - return 0; - case REG_GRER: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Rising-Edge Detect Register: %08x & %08x\n", machine().describe_context(), m_gpio_regs.grer, mem_mask); - return m_gpio_regs.grer; - case REG_GFER: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Falling-Edge Detect Register: %08x & %08x\n", machine().describe_context(), m_gpio_regs.gfer, mem_mask); - return m_gpio_regs.gfer; - case REG_GEDR: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Edge Detect Status Register: %08x & %08x\n", machine().describe_context(), m_gpio_regs.gedr, mem_mask); - return m_gpio_regs.gedr; - case REG_GAFR: - LOGMASKED(LOG_GPIO, "%s: gpio_r: GPIO Alternate Function Register: %08x & %08x\n", machine().describe_context(), m_gpio_regs.gafr, mem_mask); - return m_gpio_regs.gafr; - default: - LOGMASKED(LOG_GPIO | LOG_UNKNOWN, "%s: gpio_r: Unknown address: %08x & %08x\n", machine().describe_context(), GPIO_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_gpio_regs.gplr; + LOGMASKED(LOG_GPIO, "%s: gpio_gplr_r: GPIO Pin-Level Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::gpio_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::gpio_gplr_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_GPLR: - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Pin-Level Register (ignored): %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_GPDR: - { - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Pin Direction Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_gpio_regs.gpdr; - COMBINE_DATA(&m_gpio_regs.gpdr); - if (old != m_gpio_regs.gpdr) - gpio_update_direction(old); - break; - } - case REG_GPSR: - { - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Pin Output Set Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_gpio_regs.output_latch; - m_gpio_regs.output_latch |= (data & mem_mask); - const uint32_t changed = ((old ^ m_gpio_regs.output_latch) & m_gpio_regs.gpdr) & ~m_gpio_regs.gafr; - if (changed) - gpio_update_outputs(old, changed); - break; - } - case REG_GPCR: - { - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Pin Output Clear Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_gpio_regs.output_latch; - m_gpio_regs.output_latch &= ~(data & mem_mask); - const uint32_t changed = ((old ^ m_gpio_regs.output_latch) & m_gpio_regs.gpdr) & ~m_gpio_regs.gafr; - if (changed) - gpio_update_outputs(old, changed); - break; - } - case REG_GRER: - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Rising-Edge Detect Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_gpio_regs.grer); - m_gpio_regs.any_edge_mask = m_gpio_regs.grer | m_gpio_regs.gfer; - break; - case REG_GFER: - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Falling-Edge Detect Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_gpio_regs.gfer); - m_gpio_regs.any_edge_mask = m_gpio_regs.grer | m_gpio_regs.gfer; - break; - case REG_GEDR: - { - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Edge Detect Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_gpio_regs.gedr; - m_gpio_regs.gedr &= ~(data & mem_mask); - if (old != m_gpio_regs.gedr) - gpio_update_interrupts(old ^ m_gpio_regs.gedr); - break; - } - case REG_GAFR: - { - LOGMASKED(LOG_GPIO, "%s: gpio_w: GPIO Alternate Function Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_gpio_regs.gafr; - COMBINE_DATA(&m_gpio_regs.gafr); - if (old != m_gpio_regs.gafr) - gpio_update_alternate_pins(old ^ m_gpio_regs.gafr); - break; - } - default: - LOGMASKED(LOG_GPIO | LOG_UNKNOWN, "%s: gpio_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), GPIO_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + LOGMASKED(LOG_GPIO, "%s: gpio_gplr_w: GPIO Pin-Level Register (ignored) = %08x & %08x\n", machine().describe_context(), data, mem_mask); } +u32 sa1110_periphs_device::gpio_gpdr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_gpio_regs.gpdr; + LOGMASKED(LOG_GPIO, "%s: gpio_gpdr_r: GPIO Direction Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_gpdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_gpdr_w: GPIO Pin Direction Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_gpio_regs.gpdr; + COMBINE_DATA(&m_gpio_regs.gpdr); + if (old != m_gpio_regs.gpdr) + gpio_update_direction(old); + } + +u32 sa1110_periphs_device::gpio_gpsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = 0; + LOGMASKED(LOG_GPIO, "%s: gpio_gpsr_r: GPIO Output Set Register (ignored): %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_gpsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_gpsr_w: GPIO Pin Output Set Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_gpio_regs.output_latch; + m_gpio_regs.output_latch |= (data & mem_mask); + const u32 changed = ((old ^ m_gpio_regs.output_latch) & m_gpio_regs.gpdr) & ~m_gpio_regs.gafr; + if (changed) + gpio_update_outputs(old, changed); +} + +u32 sa1110_periphs_device::gpio_gpcr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = 0; + LOGMASKED(LOG_GPIO, "%s: gpio_gpcr_r: GPIO Output Clear Register (ignored): %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_gpcr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_gpcr_w: GPIO Pin Output Clear Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_gpio_regs.output_latch; + m_gpio_regs.output_latch &= ~(data & mem_mask); + const u32 changed = ((old ^ m_gpio_regs.output_latch) & m_gpio_regs.gpdr) & ~m_gpio_regs.gafr; + if (changed) + gpio_update_outputs(old, changed); +} + +u32 sa1110_periphs_device::gpio_grer_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_gpio_regs.grer; + LOGMASKED(LOG_GPIO, "%s: gpio_grer_r: GPIO Rising-Edge Detect Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_grer_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_grer_w: GPIO Rising-Edge Detect Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_gpio_regs.grer); + m_gpio_regs.any_edge_mask = m_gpio_regs.grer | m_gpio_regs.gfer; +} + +u32 sa1110_periphs_device::gpio_gfer_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_gpio_regs.gfer; + LOGMASKED(LOG_GPIO, "%s: gpio_gfer_r: GPIO Falling-Edge Detect Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_gfer_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_gfer_w: GPIO Falling-Edge Detect Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_gpio_regs.gfer); + m_gpio_regs.any_edge_mask = m_gpio_regs.grer | m_gpio_regs.gfer; +} + +u32 sa1110_periphs_device::gpio_gedr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_gpio_regs.gedr; + if (data != 0) + LOGMASKED(LOG_GPIO, "%s: gpio_gedr_r: GPIO Edge Detect Status Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_gedr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_gedr_w: GPIO Edge Detect Status Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_gpio_regs.gedr; + m_gpio_regs.gedr &= ~(data & mem_mask); + if (old != m_gpio_regs.gedr) + gpio_update_interrupts(old ^ m_gpio_regs.gedr); +} + +u32 sa1110_periphs_device::gpio_gafr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_gpio_regs.gafr; + LOGMASKED(LOG_GPIO, "%s: gpio_gafr_r: GPIO Alternate Function Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::gpio_gafr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_GPIO, "%s: gpio_gafr_w: GPIO Alternate Function Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_gpio_regs.gafr; + COMBINE_DATA(&m_gpio_regs.gafr); + if (old != m_gpio_regs.gafr) + gpio_update_alternate_pins(old ^ m_gpio_regs.gafr); +} + + /* Intel SA-1110 Interrupt Controller @@ -1940,10 +2258,20 @@ void sa1110_periphs_device::gpio_w(offs_t offset, uint32_t data, uint32_t mem_ma */ -void sa1110_periphs_device::set_irq_line(uint32_t line, int irq_state) +void sa1110_periphs_device::set_irq_line(u32 line, int irq_state) { - const uint32_t line_mask = (1 << line); - const uint32_t old_status = m_intc_regs.icpr; + if (irq_state == 1 && line != INT_OSTIMER0) + { + static const char *const INT_NAMES[32] = + { + "GPIO0", "GPIO1", "GPIO2", "GPIO3", "GPIO4", "GPIO5", "GPIO6", "GPIO7", "GPIO8", "GPIO9", "GPIO10", "GPIOHI", + "LCD", "UDC", "reserved", "UART1", "UART2", "UART3", "MCP", "SSP", "DMA0", "DMA1", "DMA2", "DMA3", "DMA4", "DMA5", + "OSTIMER0", "OSTIMER1", "OSTIMER2", "OSTIMER3", "RTC_TICK", "RTC_ALARM" + }; + LOGMASKED(LOG_INTC, "Setting interrupt line %s\n", INT_NAMES[line]); + } + const u32 line_mask = (1 << line); + const u32 old_status = m_intc_regs.icpr; m_intc_regs.icpr &= ~line_mask; m_intc_regs.icpr |= irq_state ? line_mask : 0; @@ -1955,14 +2283,14 @@ void sa1110_periphs_device::set_irq_line(uint32_t line, int irq_state) void sa1110_periphs_device::update_interrupts() { - const uint32_t old_fiq = m_intc_regs.icfp; + const u32 old_fiq = m_intc_regs.icfp; m_intc_regs.icfp = (m_intc_regs.icpr & m_intc_regs.icmr) & m_intc_regs.iclr; if (old_fiq != m_intc_regs.icfp) { m_maincpu->set_input_line(ARM7_FIRQ_LINE, m_intc_regs.icfp ? ASSERT_LINE : CLEAR_LINE); } - const uint32_t old_irq = m_intc_regs.icip; + const u32 old_irq = m_intc_regs.icip; m_intc_regs.icip = (m_intc_regs.icpr & m_intc_regs.icmr) & (~m_intc_regs.iclr); if (old_irq != m_intc_regs.icip) { @@ -1970,78 +2298,91 @@ void sa1110_periphs_device::update_interrupts() } } -uint32_t sa1110_periphs_device::intc_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::intc_icip_r(offs_t offset, u32 mem_mask) { - switch (offset) + const u32 data = m_intc_regs.icip; + if (data && data != 0x04000000) { - case REG_ICIP: - if (m_intc_regs.icip != 0x04000000) - { - LOGMASKED(LOG_INTC, "%s: intc_r: Interrupt Controller IRQ Pending Register: %08x & %08x\n", machine().describe_context(), m_intc_regs.icip, mem_mask); - } - return m_intc_regs.icip; - case REG_ICMR: - LOGMASKED(LOG_INTC, "%s: intc_r: Interrupt Controller Mask Register: %08x & %08x\n", machine().describe_context(), m_intc_regs.icmr, mem_mask); - return m_intc_regs.icmr; - case REG_ICLR: - LOGMASKED(LOG_INTC, "%s: intc_r: Interrupt Controller Level Register: %08x & %08x\n", machine().describe_context(), m_intc_regs.iclr, mem_mask); - return m_intc_regs.iclr; - case REG_ICFP: - LOGMASKED(LOG_INTC, "%s: intc_r: Interrupt Controller FIQ Pending Register: %08x & %08x\n", machine().describe_context(), m_intc_regs.icfp, mem_mask); - return m_intc_regs.icfp; - case REG_ICPR: - LOGMASKED(LOG_INTC, "%s: intc_r: Interrupt Controller Pending Register: %08x & %08x\n", machine().describe_context(), m_intc_regs.icpr, mem_mask); - return m_intc_regs.icpr; - case REG_ICCR: - LOGMASKED(LOG_INTC, "%s: intc_r: Interrupt Controller Control Register: %08x & %08x\n", machine().describe_context(), m_intc_regs.iccr, mem_mask); - return m_intc_regs.iccr; - default: - LOGMASKED(LOG_INTC | LOG_UNKNOWN, "%s: intc_r: Unknown address: %08x & %08x\n", machine().describe_context(), INTC_BASE_ADDR | (offset << 2), mem_mask); - return 0; + LOGMASKED(LOG_INTC, "%s: intc_icip_r: Interrupt Controller IRQ Pending Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); } + return data; } -void sa1110_periphs_device::intc_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::intc_icip_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_ICIP: - LOGMASKED(LOG_INTC, "%s: intc_w: (Invalid Write) Interrupt Controller IRQ Pending Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_ICMR: - { - LOGMASKED(LOG_INTC, "%s: intc_w: Interrupt Controller Mask Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_intc_regs.icmr; - COMBINE_DATA(&m_intc_regs.icmr); - if (old != m_intc_regs.icmr) - update_interrupts(); - break; - } - case REG_ICLR: - { - LOGMASKED(LOG_INTC, "%s: intc_w: Interrupt Controller Level Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - const uint32_t old = m_intc_regs.iclr; - COMBINE_DATA(&m_intc_regs.iclr); - if (old != m_intc_regs.iclr) - update_interrupts(); - break; - } - case REG_ICFP: - LOGMASKED(LOG_INTC, "%s: intc_w: (Invalid Write) Interrupt Controller FIQ Pending Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_ICPR: - LOGMASKED(LOG_INTC, "%s: intc_w: (Invalid Write) Interrupt Controller Pending Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - break; - case REG_ICCR: - LOGMASKED(LOG_INTC, "%s: intc_w: Interrupt Controller Control Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - m_intc_regs.iccr = BIT(data, 0); - break; - default: - LOGMASKED(LOG_INTC | LOG_UNKNOWN, "%s: intc_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), INTC_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + LOGMASKED(LOG_INTC, "%s: intc_icip_w: (Invalid Write) Interrupt Controller IRQ Pending Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); } +u32 sa1110_periphs_device::intc_icmr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_intc_regs.icmr; + LOGMASKED(LOG_INTC, "%s: intc_icmr_r: Interrupt Controller Mask Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::intc_icmr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_INTC, "%s: intc_icmr_w: Interrupt Controller Mask Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_intc_regs.icmr; + COMBINE_DATA(&m_intc_regs.icmr); + if (old != m_intc_regs.icmr) + update_interrupts(); +} + +u32 sa1110_periphs_device::intc_iclr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_intc_regs.iclr; + LOGMASKED(LOG_INTC, "%s: intc_iclr_r: Interrupt Controller Level Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::intc_iclr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_INTC, "%s: intc_iclr_w: Interrupt Controller Level Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + const u32 old = m_intc_regs.iclr; + COMBINE_DATA(&m_intc_regs.iclr); + if (old != m_intc_regs.iclr) + update_interrupts(); +} + +u32 sa1110_periphs_device::intc_icfp_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_intc_regs.icfp; + LOGMASKED(LOG_INTC, "%s: intc_icfp_r: Interrupt Controller FIQ Pending Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::intc_icfp_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_INTC, "%s: intc_icfp_w: (Invalid Write) Interrupt Controller FIQ Pending Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::intc_icpr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_intc_regs.icpr; + LOGMASKED(LOG_INTC, "%s: intc_icpr_r: Interrupt Controller Pending Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::intc_icpr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_INTC, "%s: intc_icpr_w: (Invalid Write) Interrupt Controller Pending Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); +} + +u32 sa1110_periphs_device::intc_iccr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_intc_regs.iccr; + LOGMASKED(LOG_INTC, "%s: intc_iccr_r: Interrupt Controller Control Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::intc_iccr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_INTC, "%s: intc_iccr_w: Interrupt Controller Control Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + m_intc_regs.iccr = BIT(data, 0); +} + + /* Intel SA-1110 Peripheral Pin Controller @@ -2050,78 +2391,86 @@ void sa1110_periphs_device::intc_w(offs_t offset, uint32_t data, uint32_t mem_ma */ -uint32_t sa1110_periphs_device::ppc_r(offs_t offset, uint32_t mem_mask) +u32 sa1110_periphs_device::ppc_ppdr_r(offs_t offset, u32 mem_mask) { - switch (offset) - { - case REG_PPDR: - LOGMASKED(LOG_PPC, "%s: ppc_r: PPC Pin Direction Register: %08x & %08x\n", machine().describe_context(), m_ppc_regs.ppdr, mem_mask); - return m_ppc_regs.ppdr; - case REG_PPSR: - LOGMASKED(LOG_PPC, "%s: ppc_r: PPC Pin State Register: %08x & %08x\n", machine().describe_context(), m_ppc_regs.ppsr, mem_mask); - return m_ppc_regs.ppsr; - case REG_PPAR: - LOGMASKED(LOG_PPC, "%s: ppc_r: PPC Pin Assignment Register: %08x & %08x\n", machine().describe_context(), m_ppc_regs.ppar, mem_mask); - return m_ppc_regs.ppar; - case REG_PSDR: - LOGMASKED(LOG_PPC, "%s: ppc_r: PPC Sleep Mode Direction Register: %08x & %08x\n", machine().describe_context(), m_ppc_regs.psdr, mem_mask); - return m_ppc_regs.psdr; - case REG_PPFR: - LOGMASKED(LOG_PPC, "%s: ppc_r: PPC Pin Flag Register: %08x & %08x\n", machine().describe_context(), m_ppc_regs.ppfr, mem_mask); - return m_ppc_regs.ppfr; - default: - LOGMASKED(LOG_PPC | LOG_UNKNOWN, "%s: ppc_r: Unknown address: %08x & %08x\n", machine().describe_context(), PPC_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } + const u32 data = m_ppc_regs.ppdr; + LOGMASKED(LOG_PPC, "%s: ppc_ppdr_r: PPC Pin Direction Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; } -void sa1110_periphs_device::ppc_w(offs_t offset, uint32_t data, uint32_t mem_mask) +void sa1110_periphs_device::ppc_ppdr_w(offs_t offset, u32 data, u32 mem_mask) { - switch (offset) - { - case REG_PPDR: - { - LOGMASKED(LOG_PPC, "%s: ppc_w: PPC Pin Direction Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ppc_regs.ppdr); - //const uint32_t old_ppsr = m_ppc_regs.ppsr; - m_ppc_regs.ppsr = (m_ppc_regs.ppsr_out & m_ppc_regs.ppdr) | (m_ppc_regs.ppsr_in & ~m_ppc_regs.ppdr); - //const uint32_t changed_states = old_ppsr ^ m_ppc_regs.ppsr; - //if (changed_states) - //{ - //} - break; - } - case REG_PPSR: - { - LOGMASKED(LOG_PPC, "%s: ppc_w: PPC Pin State Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); - //const uint32_t old_latch = m_ppc_regs.ppsr_out; - COMBINE_DATA(&m_ppc_regs.ppsr_out); - m_ppc_regs.ppsr = (m_ppc_regs.ppsr_out & m_ppc_regs.ppdr) | (m_ppc_regs.ppsr_in & ~m_ppc_regs.ppdr); - //const uint32_t changed_outputs = (old ^ m_ppc_regs.ppsr_out) & m_ppc_regs.ppdr; - //if (changed_outputs) - //{ - // Do stuff - //} - break; - } - case REG_PPAR: - LOGMASKED(LOG_PPC, "%s: ppc_w: PPC Pin Assignment Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ppc_regs.ppar); - break; - case REG_PSDR: - LOGMASKED(LOG_PPC, "%s: ppc_w: PPC Sleep Mode Direction Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ppc_regs.psdr); - break; - case REG_PPFR: - LOGMASKED(LOG_PPC, "%s: ppc_w: PPC Pin Flag Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); - COMBINE_DATA(&m_ppc_regs.ppfr); - break; - default: - LOGMASKED(LOG_PPC | LOG_UNKNOWN, "%s: ppc_w: Unknown address: %08x = %08x & %08x\n", machine().describe_context(), PPC_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + LOGMASKED(LOG_PPC, "%s: ppc_ppdr_w: PPC Pin Direction Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ppc_regs.ppdr); + //const u32 old_ppsr = m_ppc_regs.ppsr; + m_ppc_regs.ppsr = (m_ppc_regs.ppsr_out & m_ppc_regs.ppdr) | (m_ppc_regs.ppsr_in & ~m_ppc_regs.ppdr); + //const u32 changed_states = old_ppsr ^ m_ppc_regs.ppsr; + //if (changed_states) + //{ + //} } +u32 sa1110_periphs_device::ppc_ppsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ppc_regs.ppsr; + LOGMASKED(LOG_PPC, "%s: ppc_ppsr_r: PPC Pin State Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + //machine().debug_break(); + return data; +} + +void sa1110_periphs_device::ppc_ppsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_PPC, "%s: ppc_ppsr_w: PPC Pin State Register = %08x & %08x\n", machine().describe_context(), data, mem_mask); + //const u32 old_latch = m_ppc_regs.ppsr_out; + COMBINE_DATA(&m_ppc_regs.ppsr_out); + m_ppc_regs.ppsr = (m_ppc_regs.ppsr_out & m_ppc_regs.ppdr) | (m_ppc_regs.ppsr_in & ~m_ppc_regs.ppdr); + //const u32 changed_outputs = (old ^ m_ppc_regs.ppsr_out) & m_ppc_regs.ppdr; + //if (changed_outputs) + //{ + // Do stuff + //} +} + +u32 sa1110_periphs_device::ppc_ppar_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ppc_regs.ppar; + LOGMASKED(LOG_PPC, "%s: ppc_ppar_r: PPC Pin Assignment Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::ppc_ppar_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_PPC, "%s: ppc_ppar_w: PPC Pin Assignment Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ppc_regs.ppar); +} + +u32 sa1110_periphs_device::ppc_psdr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ppc_regs.psdr; + LOGMASKED(LOG_PPC, "%s: ppc_psdr_r: PPC Sleep Mode Direction Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::ppc_psdr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_PPC, "%s: ppc_psdr_w: PPC Sleep Mode Direction Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ppc_regs.psdr); +} + +u32 sa1110_periphs_device::ppc_ppfr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_ppc_regs.ppfr; + LOGMASKED(LOG_PPC, "%s: ppc_ppfr_r: PPC Pin Flag Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + return data; +} + +void sa1110_periphs_device::ppc_ppfr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_PPC, "%s: ppc_ppfr_w: PPC Pin Flag Register: %08x & %08x\n", machine().describe_context(), data, mem_mask); + COMBINE_DATA(&m_ppc_regs.ppfr); +} + + /* Intel SA-1110 Peripheral Pin Controller @@ -2130,16 +2479,16 @@ void sa1110_periphs_device::ppc_w(offs_t offset, uint32_t data, uint32_t mem_mas */ -void sa1110_periphs_device::dma_set_control_bits(int channel, uint32_t bits) +void sa1110_periphs_device::dma_set_control_bits(int channel, u32 bits) { dma_regs ®s = m_dma_regs[channel]; - const uint32_t old = regs.dsr; + const u32 old = regs.dsr; regs.dsr |= bits; - const uint32_t newly_set = ~old & bits; + const u32 newly_set = ~old & bits; if (newly_set == 0) return; - const uint32_t irq_mask = (1 << DSR_ERROR_BIT) | (1 << DSR_DONEA_BIT) | (1 << DSR_DONEB_BIT); + const u32 irq_mask = (1 << DSR_ERROR_BIT) | (1 << DSR_DONEA_BIT) | (1 << DSR_DONEB_BIT); if (BIT(newly_set, DSR_RUN_BIT)) regs.dsr &= ~(1 << DSR_ERROR_BIT); @@ -2148,150 +2497,190 @@ void sa1110_periphs_device::dma_set_control_bits(int channel, uint32_t bits) if (BIT(newly_set, DSR_DONEB_BIT) || BIT(newly_set, DSR_STRTB_BIT)) regs.dsr &= ~(1 << DSR_DONEB_BIT); - if (regs.ddar == 0x81400580 && BIT(regs.dsr, DSR_RUN_BIT)) + if (BIT(regs.dsr, DSR_RUN_BIT)) { - const uint32_t buf = BIT(regs.dsr, DSR_BIU_BIT); - const uint32_t count = regs.dbt[buf]; - if (count) + const u32 buf = BIT(regs.dsr, DSR_BIU_BIT); + const u32 start_mask = (buf ? (1 << DSR_STRTB_BIT) : (1 << DSR_STRTA_BIT)); + const u32 done_mask = (buf ? (1 << DSR_DONEB_BIT) : (1 << DSR_DONEA_BIT)); + if (regs.dsr & start_mask) { - const uint32_t start_mask = (buf ? (1 << DSR_STRTB_BIT) : (1 << DSR_STRTA_BIT)); - const uint32_t done_mask = (buf ? (1 << DSR_DONEB_BIT) : (1 << DSR_DONEA_BIT)); - const uint32_t addr = regs.dbs[buf]; - address_space &space = m_maincpu->space(AS_PROGRAM); - if (regs.dsr & start_mask) + const u32 count = regs.dbt[buf]; + if (count && regs.ddar == 0x81400580) { - for (uint32_t i = 0; i < count; i++) + const u32 addr = regs.dbs[buf]; + address_space &space = m_maincpu->space(AS_PROGRAM); + for (u32 i = 0; i < count; i++) { - const uint8_t value = space.read_byte(addr + i); + const u8 value = space.read_byte(addr + i); if (value == 0x0d || value == 0x0a || (value >= 0x20 && value < 0x7f)) { - printf("%c", (char)value); + osd_printf_debug("%c", (char)value); } } - printf("\n"); - regs.dsr &= ~start_mask; - regs.dsr |= done_mask; - regs.dsr ^= (1 << DSR_BIU_BIT); + osd_printf_debug("\n"); + set_irq_line(INT_DMA0 + channel, (BIT(regs.dsr, DSR_IE_BIT) && (regs.dsr & irq_mask)) ? 1 : 0); } + regs.dsr &= ~(1 << DSR_RUN_BIT); + regs.dsr &= ~start_mask; + regs.dsr |= done_mask; + regs.dsr ^= (1 << DSR_BIU_BIT); } } - - set_irq_line(INT_DMA0 + channel, (BIT(regs.dsr, DSR_IE_BIT) && (regs.dsr & irq_mask)) ? 1 : 0); + //set_irq_line(INT_DMA0 + channel, (BIT(regs.dsr, DSR_IE_BIT) && (regs.dsr & irq_mask)) ? 1 : 0); } -void sa1110_periphs_device::dma_clear_control_bits(int channel, uint32_t bits) +void sa1110_periphs_device::dma_clear_control_bits(int channel, u32 bits) { dma_regs ®s = m_dma_regs[channel]; - const uint32_t irq_mask = (1 << DSR_ERROR_BIT) | (1 << DSR_DONEA_BIT) | (1 << DSR_DONEB_BIT); + const u32 irq_mask = (1 << DSR_ERROR_BIT) | (1 << DSR_DONEA_BIT) | (1 << DSR_DONEB_BIT); regs.dsr &= ~bits; set_irq_line(INT_DMA0 + channel, (BIT(regs.dsr, DSR_IE_BIT) && (regs.dsr & irq_mask)) ? 1 : 0); } -uint32_t sa1110_periphs_device::dma_r(offs_t offset, uint32_t mem_mask) +template +u32 sa1110_periphs_device::dma_ddar_r(offs_t offset, u32 mem_mask) { - uint32_t channel = (offset >> 3) & 7; - if (channel < 6) - { - switch (offset & 7) - { - case REG_DDAR: - LOGMASKED(LOG_DMA, "%s: dma_r: DMA%d Device Address Register: %08x & %08x\n", machine().describe_context(), channel, m_dma_regs[channel].ddar, mem_mask); - return m_dma_regs[channel].ddar; - case REG_DSSR: - case REG_DCSR: - case REG_DSR: - LOGMASKED(LOG_DMA, "%s: dma_r: DMA%d Control/Status Register: %08x & %08x\n", machine().describe_context(), channel, m_dma_regs[channel].dsr, mem_mask); - return m_dma_regs[channel].dsr; - case REG_DBSA: - LOGMASKED(LOG_DMA, "%s: dma_r: DMA%d Buffer A Start Address: %08x & %08x\n", machine().describe_context(), channel, m_dma_regs[channel].dbs[0], mem_mask); - return m_dma_regs[channel].dbs[0]; - case REG_DBTA: - LOGMASKED(LOG_DMA, "%s: dma_r: DMA%d Buffer A Transfer Count: %08x & %08x\n", machine().describe_context(), channel, m_dma_regs[channel].dbt[0], mem_mask); - return m_dma_regs[channel].dbt[0]; - case REG_DBSB: - LOGMASKED(LOG_DMA, "%s: dma_r: DMA%d Buffer B Start Address: %08x & %08x\n", machine().describe_context(), channel, m_dma_regs[channel].dbs[1], mem_mask); - return m_dma_regs[channel].dbs[1]; - case REG_DBTB: - LOGMASKED(LOG_DMA, "%s: dma_r: DMA%d Buffer B Transfer Count: %08x & %08x\n", machine().describe_context(), channel, m_dma_regs[channel].dbt[1], mem_mask); - return m_dma_regs[channel].dbt[1]; - default: - LOGMASKED(LOG_DMA | LOG_UNKNOWN, "%s: dma_r: Unknown address: %08x & %08x\n", machine().describe_context(), DMA_BASE_ADDR | (offset << 2), mem_mask); - return 0; - } - } - return 0; + const u32 data = m_dma_regs[Channel].ddar; + LOGMASKED(LOG_DMA, "%s: dma_ddar_r: DMA%d Device Address Register: %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; } -void sa1110_periphs_device::dma_w(offs_t offset, uint32_t data, uint32_t mem_mask) +template +void sa1110_periphs_device::dma_ddar_w(offs_t offset, u32 data, u32 mem_mask) { - uint32_t channel = (offset >> 3) & 7; - if (channel < 6) + LOGMASKED(LOG_DMA, "%s: dma_ddar_w: DMA%d Device Address Register = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + COMBINE_DATA(&m_dma_regs[Channel].ddar); +} + +template +u32 sa1110_periphs_device::dma_dssr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dsr; + LOGMASKED(LOG_DMA, "%s: dma_dssr_r: DMA%d Control/Status Register (DSSR): %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dssr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dssr_w: DMA%d Control/Status Register (1S) = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + LOGMASKED(LOG_DMA, "%s: Run Set: %d\n", machine().describe_context(), BIT(data, DSR_RUN_BIT)); + LOGMASKED(LOG_DMA, "%s: Interrupt Enable Set: %d\n", machine().describe_context(), BIT(data, DSR_IE_BIT)); + LOGMASKED(LOG_DMA, "%s: Error Set: %d\n", machine().describe_context(), BIT(data, DSR_ERROR_BIT)); + LOGMASKED(LOG_DMA, "%s: Done A Set: %d\n", machine().describe_context(), BIT(data, DSR_DONEA_BIT)); + LOGMASKED(LOG_DMA, "%s: Start A Set: %d\n", machine().describe_context(), BIT(data, DSR_STRTA_BIT)); + LOGMASKED(LOG_DMA, "%s: Done B Set: %d\n", machine().describe_context(), BIT(data, DSR_DONEB_BIT)); + LOGMASKED(LOG_DMA, "%s: Start B Set: %d\n", machine().describe_context(), BIT(data, DSR_STRTB_BIT)); + LOGMASKED(LOG_DMA, "%s: Buffer In Use Set: %d\n", machine().describe_context(), BIT(data, DSR_BIU_BIT)); + dma_set_control_bits(Channel, data & mem_mask); +} + +template +u32 sa1110_periphs_device::dma_dcsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dsr; + LOGMASKED(LOG_DMA, "%s: dma_dcsr_r: DMA%d Control/Status Register (DCSR): %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dcsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dcsr_w: DMA%d Control/Status Register (1C) = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + LOGMASKED(LOG_DMA, "%s: Run Clear: %d\n", machine().describe_context(), BIT(data, DSR_RUN_BIT)); + LOGMASKED(LOG_DMA, "%s: Interrupt Enable Clear: %d\n", machine().describe_context(), BIT(data, DSR_IE_BIT)); + LOGMASKED(LOG_DMA, "%s: Error Clear: %d\n", machine().describe_context(), BIT(data, DSR_ERROR_BIT)); + LOGMASKED(LOG_DMA, "%s: Done A Clear: %d\n", machine().describe_context(), BIT(data, DSR_DONEA_BIT)); + LOGMASKED(LOG_DMA, "%s: Start A Clear: %d\n", machine().describe_context(), BIT(data, DSR_STRTA_BIT)); + LOGMASKED(LOG_DMA, "%s: Done B Clear: %d\n", machine().describe_context(), BIT(data, DSR_DONEB_BIT)); + LOGMASKED(LOG_DMA, "%s: Start B Clear: %d\n", machine().describe_context(), BIT(data, DSR_STRTB_BIT)); + LOGMASKED(LOG_DMA, "%s: Buffer In Use Clear: %d\n", machine().describe_context(), BIT(data, DSR_BIU_BIT)); + dma_clear_control_bits(Channel, data & mem_mask); +} + +template +u32 sa1110_periphs_device::dma_dsr_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dsr; + LOGMASKED(LOG_DMA, "%s: dma_dsr_r: DMA%d Control/Status Register (DSR): %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dsr_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dsr_w: DMA%d Control/Status Register (Read-Only, Ignored) = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); +} + +template +u32 sa1110_periphs_device::dma_dbsa_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dbs[0]; + LOGMASKED(LOG_DMA, "%s: dma_dbsa_r: DMA%d Buffer A Start Address: %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dbsa_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dbsa_w: DMA%d Buffer A Start Address = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + if (!BIT(m_dma_regs[Channel].dsr, DSR_STRTA_BIT)) + COMBINE_DATA(&m_dma_regs[Channel].dbs[0]); +} + +template +u32 sa1110_periphs_device::dma_dbta_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dbt[0]; + LOGMASKED(LOG_DMA, "%s: dma_dbta_r: DMA%d Buffer A Transfer Count: %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dbta_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dbta_w: DMA%d Buffer A Transfer Count = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + if (!BIT(m_dma_regs[Channel].dsr, DSR_STRTA_BIT)) { - switch (offset & 7) - { - case REG_DDAR: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Device Address Register = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - COMBINE_DATA(&m_dma_regs[channel].ddar); - break; - case REG_DSSR: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Control/Status Register (1S) = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - LOGMASKED(LOG_DMA, "%s: Run Set: %d\n", machine().describe_context(), BIT(data, DSR_RUN_BIT)); - LOGMASKED(LOG_DMA, "%s: Interrupt Enable Set: %d\n", machine().describe_context(), BIT(data, DSR_IE_BIT)); - LOGMASKED(LOG_DMA, "%s: Error Set: %d\n", machine().describe_context(), BIT(data, DSR_ERROR_BIT)); - LOGMASKED(LOG_DMA, "%s: Done A Set: %d\n", machine().describe_context(), BIT(data, DSR_DONEA_BIT)); - LOGMASKED(LOG_DMA, "%s: Start A Set: %d\n", machine().describe_context(), BIT(data, DSR_STRTA_BIT)); - LOGMASKED(LOG_DMA, "%s: Done B Set: %d\n", machine().describe_context(), BIT(data, DSR_DONEB_BIT)); - LOGMASKED(LOG_DMA, "%s: Start B Set: %d\n", machine().describe_context(), BIT(data, DSR_STRTB_BIT)); - LOGMASKED(LOG_DMA, "%s: Buffer In Use Set: %d\n", machine().describe_context(), BIT(data, DSR_BIU_BIT)); - dma_set_control_bits(channel, data & mem_mask); - break; - case REG_DCSR: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Control/Status Register (1C) = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - LOGMASKED(LOG_DMA, "%s: Run Clear: %d\n", machine().describe_context(), BIT(data, DSR_RUN_BIT)); - LOGMASKED(LOG_DMA, "%s: Interrupt Enable Clear: %d\n", machine().describe_context(), BIT(data, DSR_IE_BIT)); - LOGMASKED(LOG_DMA, "%s: Error Clear: %d\n", machine().describe_context(), BIT(data, DSR_ERROR_BIT)); - LOGMASKED(LOG_DMA, "%s: Done A Clear: %d\n", machine().describe_context(), BIT(data, DSR_DONEA_BIT)); - LOGMASKED(LOG_DMA, "%s: Start A Clear: %d\n", machine().describe_context(), BIT(data, DSR_STRTA_BIT)); - LOGMASKED(LOG_DMA, "%s: Done B Clear: %d\n", machine().describe_context(), BIT(data, DSR_DONEB_BIT)); - LOGMASKED(LOG_DMA, "%s: Start B Clear: %d\n", machine().describe_context(), BIT(data, DSR_STRTB_BIT)); - LOGMASKED(LOG_DMA, "%s: Buffer In Use Clear: %d\n", machine().describe_context(), BIT(data, DSR_BIU_BIT)); - dma_clear_control_bits(channel, data & mem_mask); - break; - case REG_DSR: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Control/Status Register (RO) = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - break; - case REG_DBSA: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Buffer A Start Address = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - if (!BIT(m_dma_regs[channel].dsr, DSR_STRTA_BIT)) - COMBINE_DATA(&m_dma_regs[channel].dbs[0]); - break; - case REG_DBTA: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Buffer A Transfer Count = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - if (!BIT(m_dma_regs[channel].dsr, DSR_STRTA_BIT)) - { - COMBINE_DATA(&m_dma_regs[channel].dbt[0]); - m_dma_regs[channel].dbt[0] &= DBT_MASK; - } - break; - case REG_DBSB: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Buffer B Start Address = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - if (!BIT(m_dma_regs[channel].dsr, DSR_STRTB_BIT)) - COMBINE_DATA(&m_dma_regs[channel].dbs[1]); - break; - case REG_DBTB: - LOGMASKED(LOG_DMA, "%s: dma_w: DMA%d Buffer B Transfer Count = %08x & %08x\n", machine().describe_context(), channel, data, mem_mask); - if (!BIT(m_dma_regs[channel].dsr, DSR_STRTB_BIT)) - { - COMBINE_DATA(&m_dma_regs[channel].dbt[1]); - m_dma_regs[channel].dbt[1] &= DBT_MASK; - } - break; - default: - LOGMASKED(LOG_DMA | LOG_UNKNOWN, "%s: dma_w: Unknown address %08x = %08x & %08x\n", machine().describe_context(), DMA_BASE_ADDR | (offset << 2), data, mem_mask); - break; - } + COMBINE_DATA(&m_dma_regs[Channel].dbt[0]); + m_dma_regs[Channel].dbt[0] &= DBT_MASK; + } +} + +template +u32 sa1110_periphs_device::dma_dbsb_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dbs[1]; + LOGMASKED(LOG_DMA, "%s: dma_dbsb_r: DMA%d Buffer B Start Address: %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dbsb_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dbsb_w: DMA%d Buffer B Start Address = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + if (!BIT(m_dma_regs[Channel].dsr, DSR_STRTB_BIT)) + COMBINE_DATA(&m_dma_regs[Channel].dbs[1]); +} + +template +u32 sa1110_periphs_device::dma_dbtb_r(offs_t offset, u32 mem_mask) +{ + const u32 data = m_dma_regs[Channel].dbt[1]; + LOGMASKED(LOG_DMA, "%s: dma_dbtb_r: DMA%d Buffer B Transfer Count: %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + return data; +} + +template +void sa1110_periphs_device::dma_dbtb_w(offs_t offset, u32 data, u32 mem_mask) +{ + LOGMASKED(LOG_DMA, "%s: dma_dbtb_w: DMA%d Buffer B Transfer Count = %08x & %08x\n", machine().describe_context(), Channel, data, mem_mask); + if (!BIT(m_dma_regs[Channel].dsr, DSR_STRTB_BIT)) + { + COMBINE_DATA(&m_dma_regs[Channel].dbt[1]); + m_dma_regs[Channel].dbt[1] &= DBT_MASK; } } diff --git a/src/devices/machine/sa1110.h b/src/devices/machine/sa1110.h index 7d3d1ade026..b39c4f28217 100644 --- a/src/devices/machine/sa1110.h +++ b/src/devices/machine/sa1110.h @@ -23,13 +23,13 @@ class sa1110_periphs_device : public device_t, public device_serial_interface { public: template - sa1110_periphs_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock, T &&cpu_tag) + sa1110_periphs_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock, T &&cpu_tag) : sa1110_periphs_device(mconfig, tag, owner, clock) { m_maincpu.set_tag(std::forward(cpu_tag)); } - sa1110_periphs_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); + sa1110_periphs_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); template void set_codec_tag(T &&tag) { m_codec.set_tag(std::forward(tag)); } @@ -41,44 +41,19 @@ public: template void gpio_in(int state) { gpio_in(Line, state); } template auto gpio_out() { return m_gpio_out[Line].bind(); } - void ssp_in(uint16_t data) { ssp_rx_fifo_push(data); } + void ssp_in(u16 data) { ssp_rx_fifo_push(data); } auto ssp_out() { return m_ssp_out.bind(); } auto uart3_tx_out() { return m_uart3_tx_out.bind(); } - uint32_t udc_r(offs_t offset, uint32_t mem_mask = ~0); - void udc_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t icp_r(offs_t offset, uint32_t mem_mask = ~0); - void icp_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t uart3_r(offs_t offset, uint32_t mem_mask = ~0); - void uart3_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t mcp_r(offs_t offset, uint32_t mem_mask = ~0); - void mcp_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t ssp_r(offs_t offset, uint32_t mem_mask = ~0); - void ssp_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t ostimer_r(offs_t offset, uint32_t mem_mask = ~0); - void ostimer_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t rtc_r(offs_t offset, uint32_t mem_mask = ~0); - void rtc_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t power_r(offs_t offset, uint32_t mem_mask = ~0); - void power_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t reset_r(offs_t offset, uint32_t mem_mask = ~0); - void reset_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t gpio_r(offs_t offset, uint32_t mem_mask = ~0); - void gpio_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t intc_r(offs_t offset, uint32_t mem_mask = ~0); - void intc_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t ppc_r(offs_t offset, uint32_t mem_mask = ~0); - void ppc_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); - uint32_t dma_r(offs_t offset, uint32_t mem_mask = ~0); - void dma_w(offs_t offset, uint32_t data, uint32_t mem_mask = ~0); + void map(address_map &map); protected: virtual void device_add_mconfig(machine_config &config) override; virtual void device_start() override; virtual void device_reset() override; - static constexpr uint32_t INTERNAL_OSC = 3686400; + static constexpr u32 INTERNAL_OSC = 3686400; TIMER_CALLBACK_MEMBER(icp_rx_callback); TIMER_CALLBACK_MEMBER(icp_tx_callback); @@ -88,10 +63,10 @@ protected: void icp_uart_set_transmitter_enabled(bool enabled); void icp_uart_set_receive_irq_enabled(bool enabled); void icp_uart_set_transmit_irq_enabled(bool enabled); - uint8_t icp_uart_read_receive_fifo(); - void icp_uart_write_transmit_fifo(uint8_t data); - uint16_t icp_hssp_read_receive_fifo(); - void icp_hssp_write_transmit_fifo(uint8_t data); + u8 icp_uart_read_receive_fifo(); + void icp_uart_write_transmit_fifo(u8 data); + u16 icp_hssp_read_receive_fifo(); + void icp_hssp_write_transmit_fifo(u8 data); void icp_uart_set_receiver_idle(); void icp_uart_begin_of_break(); void icp_uart_end_of_break(); @@ -99,9 +74,9 @@ protected: void uart3_irq_callback(int state); void uart_recalculate_divisor(); void uart_update_eif_status(); - void uart_write_receive_fifo(uint16_t data_and_flags); - uint8_t uart_read_receive_fifo(); - void uart_write_transmit_fifo(uint8_t data); + void uart_write_receive_fifo(u16 data_and_flags); + u8 uart_read_receive_fifo(); + void uart_write_transmit_fifo(u8 data); void uart_check_rx_fifo_service(); void uart_check_tx_fifo_service(); void uart_set_receiver_idle(); @@ -117,23 +92,23 @@ protected: TIMER_CALLBACK_MEMBER(mcp_telecom_tx_callback); void mcp_update_sample_rate(); void mcp_set_enabled(bool enabled); - uint16_t mcp_read_audio_fifo(); - uint16_t mcp_read_telecom_fifo(); + u16 mcp_read_audio_fifo(); + u16 mcp_read_telecom_fifo(); attotime mcp_get_audio_frame_rate(); attotime mcp_get_telecom_frame_rate(); - void mcp_audio_tx_fifo_push(const uint16_t value); - void mcp_telecom_tx_fifo_push(const uint16_t value); + void mcp_audio_tx_fifo_push(const u16 value); + void mcp_telecom_tx_fifo_push(const u16 value); void mcp_codec_read(offs_t offset); - void mcp_codec_write(offs_t offset, uint16_t data); + void mcp_codec_write(offs_t offset, u16 data); TIMER_CALLBACK_MEMBER(ssp_rx_callback); TIMER_CALLBACK_MEMBER(ssp_tx_callback); void ssp_update_enable_state(); void ssp_update_rx_level(); void ssp_update_tx_level(); - void ssp_rx_fifo_push(const uint16_t data); - void ssp_tx_fifo_push(const uint16_t data); - uint16_t ssp_rx_fifo_pop(); + void ssp_rx_fifo_push(const u16 data); + void ssp_tx_fifo_push(const u16 data); + u16 ssp_rx_fifo_pop(); TIMER_CALLBACK_MEMBER(ostimer_tick_cb); void ostimer_update_count(); @@ -141,17 +116,206 @@ protected: TIMER_CALLBACK_MEMBER(rtc_tick_cb); - void gpio_in(const uint32_t line, const int state); - void gpio_update_interrupts(const uint32_t changed_mask); - void gpio_update_direction(const uint32_t old_gpdr); - void gpio_update_outputs(const uint32_t old_latch, const uint32_t changed); - void gpio_update_alternate_pins(const uint32_t changed_mask); + void gpio_in(const u32 line, const int state); + void gpio_update_interrupts(const u32 changed_mask); + void gpio_update_direction(const u32 old_gpdr); + void gpio_update_outputs(const u32 old_latch, const u32 changed); + void gpio_update_alternate_pins(const u32 changed_mask); - void set_irq_line(uint32_t line, int state); + void set_irq_line(u32 line, int state); void update_interrupts(); - void dma_set_control_bits(int channel, uint32_t bits); - void dma_clear_control_bits(int channel, uint32_t bits); + void dma_set_control_bits(int channel, u32 bits); + void dma_clear_control_bits(int channel, u32 bits); + + u32 udc_udccr_r(offs_t offset, u32 mem_mask); + void udc_udccr_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcar_r(offs_t offset, u32 mem_mask); + void udc_udcar_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcomp_r(offs_t offset, u32 mem_mask); + void udc_udcomp_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcimp_r(offs_t offset, u32 mem_mask); + void udc_udcimp_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udccs0_r(offs_t offset, u32 mem_mask); + void udc_udccs0_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udccs1_r(offs_t offset, u32 mem_mask); + void udc_udccs1_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udccs2_r(offs_t offset, u32 mem_mask); + void udc_udccs2_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcd0_r(offs_t offset, u32 mem_mask); + void udc_udcd0_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcwc_r(offs_t offset, u32 mem_mask); + void udc_udcwc_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcdr_r(offs_t offset, u32 mem_mask); + void udc_udcdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 udc_udcsr_r(offs_t offset, u32 mem_mask); + void udc_udcsr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 icp_utcr0_r(offs_t offset, u32 mem_mask); + void icp_utcr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utcr1_r(offs_t offset, u32 mem_mask); + void icp_utcr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utcr2_r(offs_t offset, u32 mem_mask); + void icp_utcr2_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utcr3_r(offs_t offset, u32 mem_mask); + void icp_utcr3_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utcr4_r(offs_t offset, u32 mem_mask); + void icp_utcr4_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utdr_r(offs_t offset, u32 mem_mask); + void icp_utdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utsr0_r(offs_t offset, u32 mem_mask); + void icp_utsr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_utsr1_r(offs_t offset, u32 mem_mask); + u32 icp_hscr0_r(offs_t offset, u32 mem_mask); + void icp_hscr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_hscr1_r(offs_t offset, u32 mem_mask); + void icp_hscr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_hsdr_r(offs_t offset, u32 mem_mask); + void icp_hsdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_hssr0_r(offs_t offset, u32 mem_mask); + void icp_hssr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 icp_hssr1_r(offs_t offset, u32 mem_mask); + void icp_hssr1_w(offs_t offset, u32 data, u32 mem_mask); + + u32 uart3_utcr0_r(offs_t offset, u32 mem_mask); + void uart3_utcr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 uart3_utcr1_r(offs_t offset, u32 mem_mask); + void uart3_utcr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 uart3_utcr2_r(offs_t offset, u32 mem_mask); + void uart3_utcr2_w(offs_t offset, u32 data, u32 mem_mask); + u32 uart3_utcr3_r(offs_t offset, u32 mem_mask); + void uart3_utcr3_w(offs_t offset, u32 data, u32 mem_mask); + u32 uart3_utdr_r(offs_t offset, u32 mem_mask); + void uart3_utdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 uart3_utsr0_r(offs_t offset, u32 mem_mask); + void uart3_utsr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 uart3_utsr1_r(offs_t offset, u32 mem_mask); + + u32 mcp_mccr0_r(offs_t offset, u32 mem_mask); + void mcp_mccr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 mcp_mcdr0_r(offs_t offset, u32 mem_mask); + void mcp_mcdr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 mcp_mcdr1_r(offs_t offset, u32 mem_mask); + void mcp_mcdr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 mcp_mcdr2_r(offs_t offset, u32 mem_mask); + void mcp_mcdr2_w(offs_t offset, u32 data, u32 mem_mask); + u32 mcp_mcsr_r(offs_t offset, u32 mem_mask); + void mcp_mcsr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 ssp_sscr0_r(offs_t offset, u32 mem_mask); + void ssp_sscr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 ssp_sscr1_r(offs_t offset, u32 mem_mask); + void ssp_sscr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 ssp_ssdr_r(offs_t offset, u32 mem_mask); + void ssp_ssdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 ssp_sssr_r(offs_t offset, u32 mem_mask); + void ssp_sssr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 tmr_osmr0_r(offs_t offset, u32 mem_mask); + void tmr_osmr0_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_osmr1_r(offs_t offset, u32 mem_mask); + void tmr_osmr1_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_osmr2_r(offs_t offset, u32 mem_mask); + void tmr_osmr2_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_osmr3_r(offs_t offset, u32 mem_mask); + void tmr_osmr3_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_oscr_r(offs_t offset, u32 mem_mask); + void tmr_oscr_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_ossr_r(offs_t offset, u32 mem_mask); + void tmr_ossr_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_ower_r(offs_t offset, u32 mem_mask); + void tmr_ower_w(offs_t offset, u32 data, u32 mem_mask); + u32 tmr_oier_r(offs_t offset, u32 mem_mask); + void tmr_oier_w(offs_t offset, u32 data, u32 mem_mask); + + u32 rtc_rtar_r(offs_t offset, u32 mem_mask); + void rtc_rtar_w(offs_t offset, u32 data, u32 mem_mask); + u32 rtc_rcnr_r(offs_t offset, u32 mem_mask); + void rtc_rcnr_w(offs_t offset, u32 data, u32 mem_mask); + u32 rtc_rttr_r(offs_t offset, u32 mem_mask); + void rtc_rttr_w(offs_t offset, u32 data, u32 mem_mask); + u32 rtc_rtsr_r(offs_t offset, u32 mem_mask); + void rtc_rtsr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 pwr_pmcr_r(offs_t offset, u32 mem_mask); + void pwr_pmcr_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_pssr_r(offs_t offset, u32 mem_mask); + void pwr_pssr_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_pspr_r(offs_t offset, u32 mem_mask); + void pwr_pspr_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_pwer_r(offs_t offset, u32 mem_mask); + void pwr_pwer_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_pcfr_r(offs_t offset, u32 mem_mask); + void pwr_pcfr_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_ppcr_r(offs_t offset, u32 mem_mask); + void pwr_ppcr_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_pgsr_r(offs_t offset, u32 mem_mask); + void pwr_pgsr_w(offs_t offset, u32 data, u32 mem_mask); + u32 pwr_posr_r(offs_t offset, u32 mem_mask); + void pwr_posr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 rst_rsrr_r(offs_t offset, u32 mem_mask); + void rst_rsrr_w(offs_t offset, u32 data, u32 mem_mask); + u32 rst_rcsr_r(offs_t offset, u32 mem_mask); + void rst_rcsr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 gpio_gplr_r(offs_t offset, u32 mem_mask); + void gpio_gplr_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_gpdr_r(offs_t offset, u32 mem_mask); + void gpio_gpdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_gpsr_r(offs_t offset, u32 mem_mask); + void gpio_gpsr_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_gpcr_r(offs_t offset, u32 mem_mask); + void gpio_gpcr_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_grer_r(offs_t offset, u32 mem_mask); + void gpio_grer_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_gfer_r(offs_t offset, u32 mem_mask); + void gpio_gfer_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_gedr_r(offs_t offset, u32 mem_mask); + void gpio_gedr_w(offs_t offset, u32 data, u32 mem_mask); + u32 gpio_gafr_r(offs_t offset, u32 mem_mask); + void gpio_gafr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 intc_icip_r(offs_t offset, u32 mem_mask); + void intc_icip_w(offs_t offset, u32 data, u32 mem_mask); + u32 intc_icmr_r(offs_t offset, u32 mem_mask); + void intc_icmr_w(offs_t offset, u32 data, u32 mem_mask); + u32 intc_iclr_r(offs_t offset, u32 mem_mask); + void intc_iclr_w(offs_t offset, u32 data, u32 mem_mask); + u32 intc_icfp_r(offs_t offset, u32 mem_mask); + void intc_icfp_w(offs_t offset, u32 data, u32 mem_mask); + u32 intc_icpr_r(offs_t offset, u32 mem_mask); + void intc_icpr_w(offs_t offset, u32 data, u32 mem_mask); + u32 intc_iccr_r(offs_t offset, u32 mem_mask); + void intc_iccr_w(offs_t offset, u32 data, u32 mem_mask); + + u32 ppc_ppdr_r(offs_t offset, u32 mem_mask); + void ppc_ppdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 ppc_ppsr_r(offs_t offset, u32 mem_mask); + void ppc_ppsr_w(offs_t offset, u32 data, u32 mem_mask); + u32 ppc_ppar_r(offs_t offset, u32 mem_mask); + void ppc_ppar_w(offs_t offset, u32 data, u32 mem_mask); + u32 ppc_psdr_r(offs_t offset, u32 mem_mask); + void ppc_psdr_w(offs_t offset, u32 data, u32 mem_mask); + u32 ppc_ppfr_r(offs_t offset, u32 mem_mask); + void ppc_ppfr_w(offs_t offset, u32 data, u32 mem_mask); + + template u32 dma_ddar_r(offs_t offset, u32 mem_mask); + template void dma_ddar_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dssr_r(offs_t offset, u32 mem_mask); + template void dma_dssr_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dcsr_r(offs_t offset, u32 mem_mask); + template void dma_dcsr_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dsr_r(offs_t offset, u32 mem_mask); + template void dma_dsr_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dbsa_r(offs_t offset, u32 mem_mask); + template void dma_dbsa_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dbta_r(offs_t offset, u32 mem_mask); + template void dma_dbta_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dbsb_r(offs_t offset, u32 mem_mask); + template void dma_dbsb_w(offs_t offset, u32 data, u32 mem_mask); + template u32 dma_dbtb_r(offs_t offset, u32 mem_mask); + template void dma_dbtb_w(offs_t offset, u32 data, u32 mem_mask); // register offsets enum @@ -266,7 +430,7 @@ protected: }; // register contents - enum : uint32_t + enum : u32 { UDCCR_UDD_BIT = 0, UDCCR_UDA_BIT = 1, @@ -465,7 +629,7 @@ protected: }; // interrupt bits - enum : uint32_t + enum : u32 { INT_GPIO0 = 0, INT_GPIO1 = 1, @@ -526,193 +690,193 @@ protected: struct udc_regs { - uint32_t udccr; - uint32_t udcar; - uint32_t udcomp; - uint32_t udcimp; - uint32_t udccs0; - uint32_t udccs1; - uint32_t udccs2; - uint32_t udcwc; - uint32_t udcsr; + u32 udccr; + u32 udcar; + u32 udcomp; + u32 udcimp; + u32 udccs0; + u32 udccs1; + u32 udccs2; + u32 udcwc; + u32 udcsr; }; struct uart_regs { - uint32_t utcr[4]; - uint32_t utsr0; - uint32_t utsr1; + u32 utcr[4]; + u32 utsr0; + u32 utsr1; - uint16_t rx_fifo[12]; + u16 rx_fifo[12]; int rx_fifo_read_idx; int rx_fifo_write_idx; int rx_fifo_count; - uint8_t tx_fifo[8]; - int tx_fifo_read_idx; - int tx_fifo_write_idx; - int tx_fifo_count; + u8 tx_fifo[8]; + int tx_fifo_read_idx; + int tx_fifo_write_idx; + int tx_fifo_count; - bool rx_break_interlock; + bool rx_break_interlock; }; struct hssp_regs { - uint32_t hscr0; - uint32_t hscr1; - uint32_t hssr0; - uint32_t hssr1; + u32 hscr0; + u32 hscr1; + u32 hssr0; + u32 hssr1; - uint16_t rx_fifo[8]; - int rx_fifo_read_idx; - int rx_fifo_write_idx; - int rx_fifo_count; + u16 rx_fifo[8]; + int rx_fifo_read_idx; + int rx_fifo_write_idx; + int rx_fifo_count; emu_timer *rx_timer; - uint16_t tx_fifo[8]; - int tx_fifo_read_idx; - int tx_fifo_write_idx; - int tx_fifo_count; + u16 tx_fifo[8]; + int tx_fifo_read_idx; + int tx_fifo_write_idx; + int tx_fifo_count; emu_timer *tx_timer; }; struct icp_regs { - uart_regs uart; - uint32_t utcr4; + uart_regs uart; + u32 utcr4; emu_timer *uart_rx_timer; emu_timer *uart_tx_timer; - hssp_regs hssp; + hssp_regs hssp; }; struct mcp_regs { - uint32_t mccr0; - uint32_t mccr1; - uint32_t mcdr2; - uint32_t mcsr; + u32 mccr0; + u32 mccr1; + u32 mcdr2; + u32 mcsr; - uint16_t audio_rx_fifo[8]; - int audio_rx_fifo_read_idx; - int audio_rx_fifo_write_idx; - int audio_rx_fifo_count; + u16 audio_rx_fifo[8]; + int audio_rx_fifo_read_idx; + int audio_rx_fifo_write_idx; + int audio_rx_fifo_count; - uint16_t audio_tx_fifo[8]; - int audio_tx_fifo_read_idx; - int audio_tx_fifo_write_idx; - int audio_tx_fifo_count; + u16 audio_tx_fifo[8]; + int audio_tx_fifo_read_idx; + int audio_tx_fifo_write_idx; + int audio_tx_fifo_count; emu_timer *audio_tx_timer; - uint16_t telecom_rx_fifo[8]; - int telecom_rx_fifo_read_idx; - int telecom_rx_fifo_write_idx; - int telecom_rx_fifo_count; + u16 telecom_rx_fifo[8]; + int telecom_rx_fifo_read_idx; + int telecom_rx_fifo_write_idx; + int telecom_rx_fifo_count; - uint16_t telecom_tx_fifo[8]; - int telecom_tx_fifo_read_idx; - int telecom_tx_fifo_write_idx; - int telecom_tx_fifo_count; + u16 telecom_tx_fifo[8]; + int telecom_tx_fifo_read_idx; + int telecom_tx_fifo_write_idx; + int telecom_tx_fifo_count; emu_timer *telecom_tx_timer; }; struct ssp_regs { - uint32_t sscr0; - uint32_t sscr1; - uint32_t sssr; + u32 sscr0; + u32 sscr1; + u32 sssr; - uint16_t rx_fifo[8]; - int rx_fifo_read_idx; - int rx_fifo_write_idx; - int rx_fifo_count; + u16 rx_fifo[8]; + int rx_fifo_read_idx; + int rx_fifo_write_idx; + int rx_fifo_count; emu_timer *rx_timer; - uint16_t tx_fifo[8]; - int tx_fifo_read_idx; - int tx_fifo_write_idx; - int tx_fifo_count; + u16 tx_fifo[8]; + int tx_fifo_read_idx; + int tx_fifo_write_idx; + int tx_fifo_count; emu_timer *tx_timer; }; struct ostimer_regs { - uint32_t osmr[4]; - uint32_t oscr; - uint32_t ossr; - uint32_t ower; - uint32_t oier; + u32 osmr[4]; + u32 oscr; + u32 ossr; + u32 ower; + u32 oier; emu_timer *timer[4]; - attotime last_count_sync; + attotime last_count_sync; }; struct rtc_regs { - uint32_t rtar; - uint32_t rcnr; - uint32_t rttr; - uint32_t rtsr; + u32 rtar; + u32 rcnr; + u32 rttr; + u32 rtsr; emu_timer *tick_timer; }; struct power_regs { - uint32_t pmcr; - uint32_t pssr; - uint32_t pspr; - uint32_t pwer; - uint32_t pcfr; - uint32_t ppcr; - uint32_t pgsr; - uint32_t posr; + u32 pmcr; + u32 pssr; + u32 pspr; + u32 pwer; + u32 pcfr; + u32 ppcr; + u32 pgsr; + u32 posr; }; struct gpio_regs { - uint32_t gplr; - uint32_t gpdr; - uint32_t grer; - uint32_t gfer; - uint32_t gedr; - uint32_t gafr; + u32 gplr; + u32 gpdr; + u32 grer; + u32 gfer; + u32 gedr; + u32 gafr; - uint32_t any_edge_mask; + u32 any_edge_mask; - uint32_t output_latch; - uint32_t input_latch; - uint32_t alt_output_latch; - uint32_t alt_input_latch; + u32 output_latch; + u32 input_latch; + u32 alt_output_latch; + u32 alt_input_latch; }; struct intc_regs { - uint32_t icip; - uint32_t icmr; - uint32_t iclr; - uint32_t iccr; - uint32_t icfp; - uint32_t icpr; + u32 icip; + u32 icmr; + u32 iclr; + u32 iccr; + u32 icfp; + u32 icpr; }; struct ppc_regs { - uint32_t ppdr; - uint32_t ppsr_out; - uint32_t ppsr_in; - uint32_t ppsr; - uint32_t ppar; - uint32_t psdr; - uint32_t ppfr; + u32 ppdr; + u32 ppsr_out; + u32 ppsr_in; + u32 ppsr; + u32 ppar; + u32 psdr; + u32 ppfr; }; struct dma_regs { - uint32_t ddar; - uint32_t dsr; - uint32_t dbs[2]; - uint32_t dbt[2]; + u32 ddar; + u32 dsr; + u32 dbs[2]; + u32 dbt[2]; }; udc_regs m_udc_regs; @@ -723,12 +887,12 @@ protected: ostimer_regs m_ostmr_regs; rtc_regs m_rtc_regs; power_regs m_power_regs; - uint32_t m_rcsr; + u32 m_rcsr; gpio_regs m_gpio_regs; intc_regs m_intc_regs; ppc_regs m_ppc_regs; dma_regs m_dma_regs[6]; - uint8_t m_dma_active_mask; + u8 m_dma_active_mask; required_device m_maincpu; required_device m_uart3_irqs; diff --git a/src/devices/machine/sa1111.cpp b/src/devices/machine/sa1111.cpp index ac2b018c864..cc33ccd6892 100644 --- a/src/devices/machine/sa1111.cpp +++ b/src/devices/machine/sa1111.cpp @@ -483,16 +483,12 @@ TIMER_CALLBACK_MEMBER(sa1111_device::audio_tx_dma_callback) return; address_space &space = m_maincpu->space(AS_PROGRAM); - uint32_t count; - for (count = 0; count < remaining && count < avail; count++) - { - const uint32_t data = space.read_dword(m_audio_regs.sadta); - LOGMASKED(LOG_AUDIO_DMA, "audio_tx_dma_callback: read data %08x from %08x, pushing to FIFO\n", data, m_audio_regs.sadta); - audio_tx_fifo_push(data); - m_audio_regs.sadta += 4; - } + const uint32_t data = space.read_dword(m_audio_regs.sadta); + LOGMASKED(LOG_AUDIO_DMA, "audio_tx_dma_callback: read data %08x from %08x, pushing to FIFO\n", data, m_audio_regs.sadta); + audio_tx_fifo_push(data); + m_audio_regs.sadta += 4; - m_audio_regs.sadtcc = (remaining - count) << 2; + m_audio_regs.sadtcc = (remaining - 1) << 2; if (!m_audio_regs.sadtcc) { static constexpr uint32_t s_start_masks[2] = { (1 << SADTCS_TDSTA_BIT), (1 << SADTCS_TDSTB_BIT) }; @@ -723,7 +719,7 @@ void sa1111_device::audio_tx_fifo_push(uint32_t data) { const uint32_t divisor = ((m_sk_regs.skaud & SKAUD_ACD_MASK) >> SKAUD_ACD_BIT) + 1; const uint32_t pll_clock = clock() * 39; - attotime clock_period = attotime::from_ticks(divisor * 256, pll_clock); + attotime clock_period = attotime::from_ticks(divisor * 96, pll_clock); m_audio_regs.tx_timer->adjust(clock_period, 0, clock_period); } } @@ -1094,13 +1090,13 @@ void sa1111_device::sadtcs_w(offs_t offset, uint32_t data, uint32_t mem_mask) if (BIT(data, SADTCS_TDBDA_BIT) || BIT(data, SADTCS_TDSTA_BIT)) { - LOGMASKED(LOG_AUDIO_DMA, "%s: sadtcs_w: Clearing done A bit, lowering AUDTXA IRQ\n"); + LOGMASKED(LOG_AUDIO_DMA, "%s: sadtcs_w: Clearing done A bit, lowering AUDTXA IRQ\n", machine().describe_context()); m_audio_regs.sadtcs &= ~(1 << SADTCS_TDBDA_BIT); set_irq_line(INT_AUDTXA, 0); } if (BIT(data, SADTCS_TDBDB_BIT) || BIT(data, SADTCS_TDSTB_BIT)) { - LOGMASKED(LOG_AUDIO_DMA, "%s: sadtcs_w: Clearing done B bit, lowering AUDTXB IRQ\n"); + LOGMASKED(LOG_AUDIO_DMA, "%s: sadtcs_w: Clearing done B bit, lowering AUDTXB IRQ\n", machine().describe_context()); m_audio_regs.sadtcs &= ~(1 << SADTCS_TDBDB_BIT); set_irq_line(INT_AUDTXB, 0); } diff --git a/src/devices/sound/uda1344.cpp b/src/devices/sound/uda1344.cpp index d2454b57994..f3123371d82 100644 --- a/src/devices/sound/uda1344.cpp +++ b/src/devices/sound/uda1344.cpp @@ -47,6 +47,9 @@ void uda1344_device::device_start() { m_stream = stream_alloc(0, 2, BASE_FREQUENCY); + m_buffer[0].resize(BUFFER_SIZE); + m_buffer[1].resize(BUFFER_SIZE); + save_item(NAME(m_buffer[0])); save_item(NAME(m_buffer[1])); save_item(NAME(m_bufin)); @@ -63,9 +66,6 @@ void uda1344_device::device_start() save_item(NAME(m_power_reg)); save_item(NAME(m_dac_enable)); save_item(NAME(m_adc_enable)); - - m_buffer[0].resize(BUFFER_SIZE); - m_buffer[1].resize(BUFFER_SIZE); } void uda1344_device::device_reset() diff --git a/src/mame/hp/jornada.cpp b/src/mame/hp/jornada.cpp index 9e3d9d17f4f..a58dadb6406 100644 --- a/src/mame/hp/jornada.cpp +++ b/src/mame/hp/jornada.cpp @@ -4,13 +4,6 @@ HP Jornada PDA skeleton driver - To boot: - - Start MAME with the debugger enabled - - Use the following breakpoint command: bp 13E2C,R3==3 && R1==10 - - Close the debugger and allow the machine to run - - When the breakpoint is hit, use the following command: R3=0 - - Close the debugger, booting will proceed - ***************************************************************************/ #include "emu.h" @@ -57,7 +50,7 @@ public: DECLARE_INPUT_CHANGED_MEMBER(key_changed); DECLARE_INPUT_CHANGED_MEMBER(pen_changed); - enum : uint8_t + enum : u8 { MCU_TXDUMMY = 0x11, MCU_TXDUMMY2 = 0x88 @@ -66,28 +59,85 @@ public: enum { - KEY_ON_OFF = 0x7f, + KEY_Q = 0x21, + KEY_W = 0x22, + KEY_E = 0x23, + KEY_R = 0x24, + KEY_T = 0x25, + KEY_Y = 0x26, + KEY_U = 0x27, + KEY_I = 0x28, + KEY_O = 0x29, + KEY_P = 0x2a, + KEY_A = 0x31, KEY_S = 0x32, + KEY_D = 0x33, + KEY_F = 0x34, + KEY_G = 0x35, + KEY_H = 0x36, + KEY_J = 0x37, KEY_K = 0x38, + KEY_L = 0x39, + KEY_Z = 0x41, + KEY_X = 0x42, + KEY_C = 0x43, + KEY_V = 0x44, + KEY_B = 0x45, + KEY_N = 0x46, + KEY_M = 0x47, + + KEY_0 = 0x1a, KEY_1 = 0x11, KEY_2 = 0x12, KEY_3 = 0x13, KEY_4 = 0x14, + KEY_5 = 0x15, + KEY_6 = 0x16, + KEY_7 = 0x17, + KEY_8 = 0x18, KEY_9 = 0x19, - KEY_TAB = 0x51, - KEY_ENTER = 0x4c, - KEY_A = 0x31, - KEY_N = 0x46, - KEY_L = 0x39, - KEY_M = 0x47, - KEY_P = 0x2a, - KEY_C = 0x43, - KEY_B = 0x45, - KEY_ALT = 0x65, - KEY_SPACE = 0x74, + + KEY_QL1 = 0x02, + KEY_QL2 = 0x03, + KEY_QL3 = 0x04, + KEY_QL4 = 0x05, + KEY_QL5 = 0x06, + KEY_QL6 = 0x07, + KEY_QL7 = 0x08, + KEY_QL8 = 0x09, + KEY_QL9 = 0x0a, + KEY_QL10 = 0x0b, + KEY_QL11 = 0x0c, + + KEY_SLASH = 0x78, + KEY_BACKSLASH = 0x2b, + KEY_MINUS = 0x1b, + KEY_EQUALS = 0x1c, + KEY_COMMA = 0x48, + KEY_PERIOD = 0x49, + KEY_QUOTE = 0x4b, + KEY_COLON = 0x3a, + + KEY_ON_OFF = 0x7f, + KEY_WIN = 0x71, + KEY_FN = 0x66, KEY_BACKSPACE = 0x2c, + KEY_CTRL = 0x72, + KEY_ALT = 0x65, KEY_LSHIFT = 0x53, - KEY_RSHIFT = 0x5c + KEY_RSHIFT = 0x5c, + KEY_DEL = 0x79, + KEY_SPACE = 0x74, + KEY_TAB = 0x51, + KEY_ESC = 0x01, + KEY_VOL_UP = 0x0e, + KEY_VOL_DOWN = 0x0d, + KEY_PLAY = 0x0f, + KEY_UP = 0x5a, + KEY_DOWN = 0x6a, + KEY_LEFT = 0x69, + KEY_RIGHT = 0x6b, + KEY_ENTER = 0x4c }; enum @@ -103,13 +153,15 @@ protected: virtual void machine_reset() override; virtual void device_reset_after_children() override; - static constexpr uint32_t SA1110_CLOCK = 206000000; + static constexpr u32 SA1110_CLOCK = 206000000; void main_map(address_map &map); + void cpu_rts_to_mcu(int state); void mcu_assemble_touch_data(); - void mcu_byte_received(uint16_t data); - void eeprom_data_received(uint16_t data); + void mcu_process_byte(u8 value); + void mcu_byte_received(u16 data); + void eeprom_data_received(u16 data); void eeprom_select(int state); enum mcu_state : int @@ -126,7 +178,7 @@ protected: // devices required_device m_maincpu; - required_shared_ptr m_ram; + required_shared_ptr m_ram; required_device m_sa_periphs; required_device m_companion; required_device m_epson; @@ -139,39 +191,32 @@ protected: required_ioport m_pen_button; // MCU-related members + bool m_cpu_to_mcu_rts; int m_mcu_state; - uint8_t m_mcu_key_send_idx; - uint8_t m_mcu_key_codes[2][8]; - uint8_t m_mcu_key_count[2]; - uint8_t m_mcu_key_idx[2]; - uint8_t m_mcu_touch_send_idx; - uint8_t m_mcu_touch_data[2][8]; - uint8_t m_mcu_touch_count[2]; - uint8_t m_mcu_touch_idx[2]; - uint8_t m_mcu_battery_data[3]; - uint8_t m_mcu_battery_idx; + u8 m_mcu_key_send_idx; + u8 m_mcu_key_codes[2][8]; + u8 m_mcu_key_count[2]; + u8 m_mcu_key_idx[2]; + u8 m_mcu_touch_send_idx; + u8 m_mcu_touch_data[2][8]; + u8 m_mcu_touch_count[2]; + u8 m_mcu_touch_idx[2]; + u8 m_mcu_battery_data[3]; + u8 m_mcu_battery_idx; + u8 m_mcu_rx_fifo[8]; + u8 m_mcu_rx_count; }; void jornada_state::main_map(address_map &map) { map(0x00000000, 0x01ffffff).rom().region("firmware", 0); - map(0x1a000000, 0x1a000fff).noprw(); // Debug Attachment Region + //map(0x1a000000, 0x1a000fff).noprw(); // Debug Attachment Region + map(0x1a00013c, 0x1a00013f).noprw(); + map(0x1a000400, 0x1a000403).noprw(); map(0x40000000, 0x40001fff).m(m_companion, FUNC(sa1111_device::map)); map(0x48000000, 0x481fffff).m(m_epson, FUNC(sed1356_device::map)); map(0x48200000, 0x4827ffff).m(m_epson, FUNC(sed1356_device::vram_map)); - map(0x80000000, 0x80000033).rw(m_sa_periphs, FUNC(sa1110_periphs_device::udc_r), FUNC(sa1110_periphs_device::udc_w)); - map(0x80030000, 0x8003007b).rw(m_sa_periphs, FUNC(sa1110_periphs_device::icp_r), FUNC(sa1110_periphs_device::icp_w)); - map(0x80050000, 0x80050023).rw(m_sa_periphs, FUNC(sa1110_periphs_device::uart3_r), FUNC(sa1110_periphs_device::uart3_w)); - map(0x80060000, 0x8006001b).rw(m_sa_periphs, FUNC(sa1110_periphs_device::mcp_r), FUNC(sa1110_periphs_device::mcp_w)); - map(0x80070000, 0x80070077).rw(m_sa_periphs, FUNC(sa1110_periphs_device::ssp_r), FUNC(sa1110_periphs_device::ssp_w)); - map(0x90000000, 0x9000001f).rw(m_sa_periphs, FUNC(sa1110_periphs_device::ostimer_r), FUNC(sa1110_periphs_device::ostimer_w)); - map(0x90010000, 0x9001001f).rw(m_sa_periphs, FUNC(sa1110_periphs_device::rtc_r), FUNC(sa1110_periphs_device::rtc_w)); - map(0x90020000, 0x9002001f).rw(m_sa_periphs, FUNC(sa1110_periphs_device::power_r), FUNC(sa1110_periphs_device::power_w)); - map(0x90030000, 0x90030007).rw(m_sa_periphs, FUNC(sa1110_periphs_device::reset_r), FUNC(sa1110_periphs_device::reset_w)); - map(0x90040000, 0x90040023).rw(m_sa_periphs, FUNC(sa1110_periphs_device::gpio_r), FUNC(sa1110_periphs_device::gpio_w)); - map(0x90050000, 0x90050023).rw(m_sa_periphs, FUNC(sa1110_periphs_device::intc_r), FUNC(sa1110_periphs_device::intc_w)); - map(0x90060000, 0x90060013).rw(m_sa_periphs, FUNC(sa1110_periphs_device::ppc_r), FUNC(sa1110_periphs_device::ppc_w)); - map(0xb0000000, 0xb00000bf).rw(m_sa_periphs, FUNC(sa1110_periphs_device::dma_r), FUNC(sa1110_periphs_device::dma_w)); + map(0x80000000, 0xbfffffff).m(m_sa_periphs, FUNC(sa1110_periphs_device::map)); map(0xc0000000, 0xc1ffffff).ram().share("ram"); map(0xe0000000, 0xe0003fff).noprw(); // Cache-Flush Region 0 map(0xe0100000, 0xe01003ff).noprw(); // Cache-Flush Region 1 @@ -179,33 +224,52 @@ void jornada_state::main_map(address_map &map) void jornada_state::device_reset_after_children() { + driver_device::device_reset_after_children(); + m_sa_periphs->gpio_in<4>(0); // Flag as plugged into AC power - m_sa_periphs->gpio_in<9>(1); // Pen input is active-high + m_sa_periphs->gpio_in<9>(1); // Pen input is active-low m_sa_periphs->gpio_in<26>(0); // Flag as charging } +void jornada_state::cpu_rts_to_mcu(int state) +{ + const bool old = m_cpu_to_mcu_rts; + m_cpu_to_mcu_rts = (bool)state; + if (!old || m_cpu_to_mcu_rts || m_mcu_rx_count == 0) + return; + + for (u8 i = 0; i < m_mcu_rx_count; i++) + { + mcu_process_byte(m_mcu_rx_fifo[i]); + } + m_mcu_rx_count = 0; +} + void jornada_state::mcu_assemble_touch_data() { - const uint16_t pen_x = m_pen_x->read(); - const uint16_t pen_y = m_pen_y->read(); - const uint8_t touch_recv_idx = 1 - m_mcu_touch_send_idx; - m_mcu_touch_data[touch_recv_idx][0] = (uint8_t)pen_x; - m_mcu_touch_data[touch_recv_idx][1] = (uint8_t)pen_x; - m_mcu_touch_data[touch_recv_idx][2] = (uint8_t)pen_x; - m_mcu_touch_data[touch_recv_idx][3] = (uint8_t)pen_y; - m_mcu_touch_data[touch_recv_idx][4] = (uint8_t)pen_y; - m_mcu_touch_data[touch_recv_idx][5] = (uint8_t)pen_y; - m_mcu_touch_data[touch_recv_idx][6] = (uint8_t)((pen_x >> 8) * 0x15); - m_mcu_touch_data[touch_recv_idx][7] = (uint8_t)((pen_y >> 8) * 0x15); + const u16 pen_x = m_pen_x->read(); + const u16 pen_y = m_pen_y->read(); + const u16 x0 = pen_x; + const u16 x1 = (pen_x + 1) & 0x3ff; + const u16 x2 = (pen_x - 1) & 0x3ff; + const u16 y0 = pen_y; + const u16 y1 = (pen_y + 1) & 0x3ff; + const u16 y2 = (pen_y - 1) & 0x3ff; + const u8 touch_recv_idx = 1 - m_mcu_touch_send_idx; + m_mcu_touch_data[touch_recv_idx][0] = (u8)x0; + m_mcu_touch_data[touch_recv_idx][1] = (u8)x1; + m_mcu_touch_data[touch_recv_idx][2] = (u8)x2; + m_mcu_touch_data[touch_recv_idx][3] = (u8)y0; + m_mcu_touch_data[touch_recv_idx][4] = (u8)y1; + m_mcu_touch_data[touch_recv_idx][5] = (u8)y2; + m_mcu_touch_data[touch_recv_idx][6] = (u8)(((x0 >> 8) & 0x03) | ((x1 >> 6) & 0xc0) | ((x2 >> 4) & 0x30)); + m_mcu_touch_data[touch_recv_idx][7] = (u8)(((y0 >> 8) & 0x03) | ((y1 >> 6) & 0xc0) | ((y2 >> 4) & 0x30)); m_mcu_touch_count[touch_recv_idx] = 8; } -void jornada_state::mcu_byte_received(uint16_t data) +void jornada_state::mcu_process_byte(u8 value) { - const uint8_t raw_value = (uint8_t)(data >> 8); - const uint8_t value = bitswap<8>(raw_value, 0, 1, 2, 3, 4, 5, 6, 7); - - uint8_t response = MCU_TXDUMMY; + u8 response = MCU_TXDUMMY; switch (m_mcu_state) { case MCU_IDLE: @@ -287,7 +351,6 @@ void jornada_state::mcu_byte_received(uint16_t data) LOGMASKED(LOG_MCU, "mcu_byte_received in MCU_TOUCH_SEND_DATA: TxDummy, sending touch data %02x and returning to IDLE state\n", response); m_mcu_state = MCU_IDLE; m_mcu_touch_idx[m_mcu_touch_send_idx] = 0; - //machine().debug_break(); } } else @@ -319,10 +382,29 @@ void jornada_state::mcu_byte_received(uint16_t data) LOGMASKED(LOG_MCU, "mcu_byte_received in MCU_KBD_SEND_CODES: Unknown (%02x), sending ErrorCode response and returning to IDLE state\n"); response = 0; } + break; + + default: + LOGMASKED(LOG_MCU, "mcu_byte_received in %08x: %02x\n", m_mcu_state, value); + break; } response = bitswap<8>(response, 0, 1, 2, 3, 4, 5, 6, 7); - m_sa_periphs->ssp_in((uint16_t)response); + m_sa_periphs->ssp_in((u16)response); +} + +void jornada_state::mcu_byte_received(u16 data) +{ + const u8 raw_value = (u8)(data >> 8); + const u8 value = bitswap<8>(raw_value, 0, 1, 2, 3, 4, 5, 6, 7); + + if (m_mcu_rx_count == 0 && !m_cpu_to_mcu_rts) + { + mcu_process_byte(value); + return; + } + + m_mcu_rx_fifo[m_mcu_rx_count++] = value; } void jornada_state::eeprom_select(int state) @@ -330,20 +412,20 @@ void jornada_state::eeprom_select(int state) m_nvram->select_w(!state); } -void jornada_state::eeprom_data_received(uint16_t data) +void jornada_state::eeprom_data_received(u16 data) { - const uint8_t response = m_nvram->access((uint8_t)data); - m_companion->ssp_in((uint16_t)response); + const u8 response = m_nvram->access((u8)data); + m_companion->ssp_in((u16)response); } INPUT_CHANGED_MEMBER(jornada_state::key_changed) { - uint8_t scan_code = (uint8_t)param; + u8 scan_code = (u8)param; m_sa_periphs->gpio_in<0>(1); m_sa_periphs->gpio_in<0>(0); - const uint8_t key_recv_idx = 1 - m_mcu_key_send_idx; + const u8 key_recv_idx = 1 - m_mcu_key_send_idx; if (m_mcu_key_count[key_recv_idx] < 8) { m_mcu_key_codes[key_recv_idx][m_mcu_key_count[key_recv_idx]] = scan_code | (newval ? 0x00 : 0x80); @@ -359,6 +441,7 @@ INPUT_CHANGED_MEMBER(jornada_state::pen_changed) case PEN_Y: if (m_pen_button->read() && m_mcu_state == MCU_IDLE) { + logerror("Pen move, queueing data\n"); mcu_assemble_touch_data(); m_sa_periphs->gpio_in<9>(1); m_sa_periphs->gpio_in<9>(0); @@ -367,11 +450,13 @@ INPUT_CHANGED_MEMBER(jornada_state::pen_changed) case PEN_BUTTON: if (newval) { + logerror("PEN_BUTTON, newval set (assembling touch data)\n"); m_sa_periphs->gpio_in<9>(0); mcu_assemble_touch_data(); } else { + logerror("PEN_BUTTON, newval not set\n"); m_sa_periphs->gpio_in<9>(1); } break; @@ -380,39 +465,94 @@ INPUT_CHANGED_MEMBER(jornada_state::pen_changed) static INPUT_PORTS_START( jornada720 ) PORT_START("KBD0") - PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("On/Off") PORT_CODE(KEYCODE_HOME) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ON_OFF) - PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("S") PORT_CODE(KEYCODE_S) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_S) - PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("K") PORT_CODE(KEYCODE_K) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_K) - PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("1") PORT_CODE(KEYCODE_1) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_1) - PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("2") PORT_CODE(KEYCODE_2) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_2) - PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("3") PORT_CODE(KEYCODE_1) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_3) - PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("4") PORT_CODE(KEYCODE_2) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_4) - PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("9") PORT_CODE(KEYCODE_2) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_9) + PORT_BIT(0x00000001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Q") PORT_CODE(KEYCODE_Q) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_Q) + PORT_BIT(0x00000002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("W") PORT_CODE(KEYCODE_W) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_W) + PORT_BIT(0x00000004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("E") PORT_CODE(KEYCODE_E) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_E) + PORT_BIT(0x00000008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("R") PORT_CODE(KEYCODE_R) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_R) + PORT_BIT(0x00000010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("T") PORT_CODE(KEYCODE_T) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_T) + PORT_BIT(0x00000020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Y") PORT_CODE(KEYCODE_Y) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_Y) + PORT_BIT(0x00000040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("U") PORT_CODE(KEYCODE_U) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_U) + PORT_BIT(0x00000080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("I") PORT_CODE(KEYCODE_I) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_I) + PORT_BIT(0x00000100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("O") PORT_CODE(KEYCODE_O) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_O) + PORT_BIT(0x00000200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("P") PORT_CODE(KEYCODE_P) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_P) + PORT_BIT(0x00000400, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("A") PORT_CODE(KEYCODE_A) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_A) + PORT_BIT(0x00000800, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("S") PORT_CODE(KEYCODE_S) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_S) + PORT_BIT(0x00001000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("D") PORT_CODE(KEYCODE_D) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_D) + PORT_BIT(0x00002000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("F") PORT_CODE(KEYCODE_F) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_F) + PORT_BIT(0x00004000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("G") PORT_CODE(KEYCODE_G) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_G) + PORT_BIT(0x00008000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("H") PORT_CODE(KEYCODE_H) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_H) + PORT_BIT(0x00010000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("J") PORT_CODE(KEYCODE_J) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_J) + PORT_BIT(0x00020000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("K") PORT_CODE(KEYCODE_K) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_K) + PORT_BIT(0x00040000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("L") PORT_CODE(KEYCODE_L) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_L) + PORT_BIT(0x00080000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Z") PORT_CODE(KEYCODE_Z) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_Z) + PORT_BIT(0x00100000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("X") PORT_CODE(KEYCODE_X) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_X) + PORT_BIT(0x00200000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("C") PORT_CODE(KEYCODE_C) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_C) + PORT_BIT(0x00400000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("V") PORT_CODE(KEYCODE_V) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_V) + PORT_BIT(0x00800000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("B") PORT_CODE(KEYCODE_B) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_B) + PORT_BIT(0x01000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("N") PORT_CODE(KEYCODE_N) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_N) + PORT_BIT(0x02000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("M") PORT_CODE(KEYCODE_M) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_M) + PORT_BIT(0xfc000000, IP_ACTIVE_HIGH, IPT_UNUSED) PORT_START("KBD1") - PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Tab") PORT_CODE(KEYCODE_TAB) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_TAB) - PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Enter") PORT_CODE(KEYCODE_ENTER) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ENTER) - PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("A") PORT_CODE(KEYCODE_A) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_A) - PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("N") PORT_CODE(KEYCODE_N) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_N) - PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("L") PORT_CODE(KEYCODE_L) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_L) - PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("M") PORT_CODE(KEYCODE_M) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_M) - PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("P") PORT_CODE(KEYCODE_P) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_P) - PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("C") PORT_CODE(KEYCODE_C) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_C) + PORT_BIT(0x00000001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("0") PORT_CODE(KEYCODE_0) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_0) + PORT_BIT(0x00000002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("1") PORT_CODE(KEYCODE_1) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_1) + PORT_BIT(0x00000004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("2") PORT_CODE(KEYCODE_2) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_2) + PORT_BIT(0x00000008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("3") PORT_CODE(KEYCODE_3) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_3) + PORT_BIT(0x00000010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("4") PORT_CODE(KEYCODE_4) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_4) + PORT_BIT(0x00000020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("5") PORT_CODE(KEYCODE_5) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_5) + PORT_BIT(0x00000040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("6") PORT_CODE(KEYCODE_6) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_6) + PORT_BIT(0x00000080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("7") PORT_CODE(KEYCODE_7) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_7) + PORT_BIT(0x00000100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("8") PORT_CODE(KEYCODE_8) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_8) + PORT_BIT(0x00000200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("9") PORT_CODE(KEYCODE_9) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_9) + PORT_BIT(0x00000400, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("/") PORT_CODE(KEYCODE_SLASH) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_SLASH) + PORT_BIT(0x00000800, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("\\") PORT_CODE(KEYCODE_BACKSLASH) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_BACKSLASH) + PORT_BIT(0x00001000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("-") PORT_CODE(KEYCODE_MINUS) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_MINUS) + PORT_BIT(0x00002000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("=") PORT_CODE(KEYCODE_EQUALS) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_EQUALS) + PORT_BIT(0x00004000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(",") PORT_CODE(KEYCODE_COMMA) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_COMMA) + PORT_BIT(0x00008000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(".") PORT_CODE(KEYCODE_STOP) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_PERIOD) + PORT_BIT(0x00010000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("\'") PORT_CODE(KEYCODE_QUOTE) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QUOTE) + PORT_BIT(0x00020000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(";") PORT_CODE(KEYCODE_COLON) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_COLON) + PORT_BIT(0xfffc0000, IP_ACTIVE_HIGH, IPT_UNUSED) PORT_START("KBD2") - PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("B") PORT_CODE(KEYCODE_B) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_B) - PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Alt") PORT_CODE(KEYCODE_LALT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ALT) - PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Space") PORT_CODE(KEYCODE_SPACE) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_SPACE) - PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Backspace") PORT_CODE(KEYCODE_BACKSPACE) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_BACKSPACE) - PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Left Shift") PORT_CODE(KEYCODE_LSHIFT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_LSHIFT) - PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Right Shift") PORT_CODE(KEYCODE_RSHIFT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_RSHIFT) - PORT_BIT(0xc0, IP_ACTIVE_HIGH, IPT_UNUSED) + PORT_BIT(0x00000001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Power") PORT_CODE(KEYCODE_END) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ON_OFF) + PORT_BIT(0x00000002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Windows Key") PORT_CODE(KEYCODE_LALT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_WIN) + PORT_BIT(0x00000004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Fn") PORT_CODE(KEYCODE_RCONTROL) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_FN) + PORT_BIT(0x00000008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Backspace") PORT_CODE(KEYCODE_BACKSPACE) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_BACKSPACE) + PORT_BIT(0x00000010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Control") PORT_CODE(KEYCODE_LCONTROL) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_CTRL) + PORT_BIT(0x00000020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Alt") PORT_CODE(KEYCODE_RALT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ALT) + PORT_BIT(0x00000040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Left Shift") PORT_CODE(KEYCODE_LSHIFT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_LSHIFT) + PORT_BIT(0x00000080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Right Shift") PORT_CODE(KEYCODE_RSHIFT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_RSHIFT) + PORT_BIT(0x00000100, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Delete") PORT_CODE(KEYCODE_DEL) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_DEL) + PORT_BIT(0x00000200, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Space") PORT_CODE(KEYCODE_SPACE) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_SPACE) + PORT_BIT(0x00000400, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Tab") PORT_CODE(KEYCODE_TAB) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_TAB) + PORT_BIT(0x00000800, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Escape") PORT_CODE(KEYCODE_ESC) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ESC) + PORT_BIT(0x00001000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Volume Up") PORT_CODE(KEYCODE_PGUP) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_VOL_UP) + PORT_BIT(0x00002000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Volume Down") PORT_CODE(KEYCODE_PGDN) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_VOL_DOWN) + PORT_BIT(0x00004000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Play") PORT_CODE(KEYCODE_END) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_PLAY) + PORT_BIT(0x00008000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Up") PORT_CODE(KEYCODE_UP) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_UP) + PORT_BIT(0x00010000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Down") PORT_CODE(KEYCODE_DOWN) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_DOWN) + PORT_BIT(0x00020000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Left") PORT_CODE(KEYCODE_LEFT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_LEFT) + PORT_BIT(0x00040000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Right") PORT_CODE(KEYCODE_RIGHT) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_RIGHT) + PORT_BIT(0x00080000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 1") PORT_CODE(KEYCODE_F1) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL1) + PORT_BIT(0x00100000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 2") PORT_CODE(KEYCODE_F2) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL2) + PORT_BIT(0x00200000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 3") PORT_CODE(KEYCODE_F3) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL3) + PORT_BIT(0x00400000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 4") PORT_CODE(KEYCODE_F4) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL4) + PORT_BIT(0x00800000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 5") PORT_CODE(KEYCODE_F5) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL5) + PORT_BIT(0x01000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 6") PORT_CODE(KEYCODE_F6) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL6) + PORT_BIT(0x02000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 7") PORT_CODE(KEYCODE_F7) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL7) + PORT_BIT(0x04000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 8") PORT_CODE(KEYCODE_F8) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL8) + PORT_BIT(0x08000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 9") PORT_CODE(KEYCODE_F9) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL9) + PORT_BIT(0x10000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 10") PORT_CODE(KEYCODE_F10) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL10) + PORT_BIT(0x20000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Quicklaunch 11") PORT_CODE(KEYCODE_F10) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_QL11) + PORT_BIT(0x40000000, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Enter") PORT_CODE(KEYCODE_ENTER) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, key_changed, jornada_state::KEY_ENTER) + PORT_BIT(0x80000000, IP_ACTIVE_HIGH, IPT_UNUSED) PORT_START("PENX") - PORT_BIT(0x3ff, 590, IPT_LIGHTGUN_X) PORT_NAME("Pen X") PORT_MINMAX(270, 910) PORT_SENSITIVITY(50) PORT_CROSSHAIR(X, 1.0, 0.0, 0) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, pen_changed, jornada_state::PEN_X) + PORT_BIT(0x3ff, 0x1ff, IPT_LIGHTGUN_X) PORT_NAME("Pen X") PORT_MINMAX(0, 1023) PORT_SENSITIVITY(50) PORT_CROSSHAIR(X, 1.0, 0.0, 0) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, pen_changed, jornada_state::PEN_X) PORT_START("PENY") - PORT_BIT(0x3ff, 500, IPT_LIGHTGUN_Y) PORT_NAME("Pen Y") PORT_MINMAX(180, 820) PORT_SENSITIVITY(50) PORT_CROSSHAIR(Y, 1.0, 0.0, 0) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, pen_changed, jornada_state::PEN_Y) + PORT_BIT(0x3ff, 0x1ff, IPT_LIGHTGUN_Y) PORT_NAME("Pen Y") PORT_MINMAX(0, 1023) PORT_SENSITIVITY(50) PORT_CROSSHAIR(Y, 1.0, 0.0, 0) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, pen_changed, jornada_state::PEN_Y) PORT_START("PENZ") PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_BUTTON1) PORT_NAME("Pen Touch") PORT_CODE(MOUSECODE_BUTTON1) PORT_CHANGED_MEMBER(DEVICE_SELF, jornada_state, pen_changed, jornada_state::PEN_BUTTON) @@ -421,6 +561,7 @@ INPUT_PORTS_END void jornada_state::machine_start() { + save_item(NAME(m_cpu_to_mcu_rts)); save_item(NAME(m_mcu_state)); save_item(NAME(m_mcu_key_send_idx)); save_item(NAME(m_mcu_key_codes)); @@ -432,26 +573,34 @@ void jornada_state::machine_start() save_item(NAME(m_mcu_touch_idx)); save_item(NAME(m_mcu_battery_data)); save_item(NAME(m_mcu_battery_idx)); + save_item(NAME(m_mcu_rx_fifo)); + save_item(NAME(m_mcu_rx_count)); } void jornada_state::machine_reset() { m_mcu_state = MCU_IDLE; + m_cpu_to_mcu_rts = false; m_mcu_key_send_idx = 0; - memset(m_mcu_key_codes[0], 0, 8); - memset(m_mcu_key_codes[1], 0, 8); - memset(m_mcu_key_count, 0, 2); - memset(m_mcu_key_idx, 0, 2); + memset(m_mcu_key_codes[0], 0, sizeof(m_mcu_key_codes[0])); + memset(m_mcu_key_codes[1], 0, sizeof(m_mcu_key_codes[1])); + memset(m_mcu_key_count, 0, sizeof(m_mcu_key_count)); + memset(m_mcu_key_idx, 0, sizeof(m_mcu_key_idx)); m_mcu_touch_send_idx = 0; - memset(m_mcu_touch_data[0], 0, 8); - memset(m_mcu_touch_data[1], 0, 8); - memset(m_mcu_touch_count, 0, 2); - memset(m_mcu_touch_idx, 0, 2); + memset(m_mcu_touch_data[0], 0, sizeof(m_mcu_touch_data[0])); + memset(m_mcu_touch_data[1], 0, sizeof(m_mcu_touch_data[1])); + memset(m_mcu_touch_count, 0, sizeof(m_mcu_touch_count)); + memset(m_mcu_touch_idx, 0, sizeof(m_mcu_touch_idx)); - memset(m_mcu_battery_data, 0, 3); + memset(m_mcu_battery_data, 0, sizeof(m_mcu_battery_data)); m_mcu_battery_idx = 0; + + memset(m_mcu_rx_fifo, 0, sizeof(m_mcu_rx_fifo)); + m_mcu_rx_count = 0; + + LOGMASKED(LOG_MCU, "MCU State: %08x\n", m_mcu_state); } void jornada_state::jornada720(machine_config &config) @@ -461,6 +610,7 @@ void jornada_state::jornada720(machine_config &config) SA1110_PERIPHERALS(config, m_sa_periphs, SA1110_CLOCK, m_maincpu); m_sa_periphs->ssp_out().set(FUNC(jornada_state::mcu_byte_received)); + m_sa_periphs->gpio_out<10>().set(FUNC(jornada_state::cpu_rts_to_mcu)); SA1111(config, m_companion, 3.6864_MHz_XTAL, m_maincpu); m_companion->set_audio_codec_tag(m_codec); diff --git a/src/mame/sharp/zaurus.cpp b/src/mame/sharp/zaurus.cpp index 2e75ee639ab..9d1c331f5b6 100644 --- a/src/mame/sharp/zaurus.cpp +++ b/src/mame/sharp/zaurus.cpp @@ -1491,14 +1491,7 @@ void zaurus_sa_state::main_map(address_map &map) map(0x00000000, 0x00ffffff).rom().region("firmware", 0); map(0x40000000, 0x40001fff).rw(m_locomo, FUNC(locomo_device::read), FUNC(locomo_device::write)); map(0x40800000, 0x4080002b).rw(m_scoop, FUNC(scoop_device::read), FUNC(scoop_device::write)); - map(0x80050000, 0x80050023).rw(m_sa_periphs, FUNC(sa1110_periphs_device::uart3_r), FUNC(sa1110_periphs_device::uart3_w)); - map(0x80060000, 0x8006001b).rw(m_sa_periphs, FUNC(sa1110_periphs_device::mcp_r), FUNC(sa1110_periphs_device::mcp_w)); - map(0x90000000, 0x9000001f).rw(m_sa_periphs, FUNC(sa1110_periphs_device::ostimer_r), FUNC(sa1110_periphs_device::ostimer_w)); - map(0x90010000, 0x9001000f).rw(m_sa_periphs, FUNC(sa1110_periphs_device::rtc_r), FUNC(sa1110_periphs_device::rtc_w)); - map(0x90020000, 0x9002001f).rw(m_sa_periphs, FUNC(sa1110_periphs_device::power_r), FUNC(sa1110_periphs_device::power_w)); - map(0x90030000, 0x90030007).rw(m_sa_periphs, FUNC(sa1110_periphs_device::reset_r), FUNC(sa1110_periphs_device::reset_w)); - map(0x90040000, 0x90040023).rw(m_sa_periphs, FUNC(sa1110_periphs_device::gpio_r), FUNC(sa1110_periphs_device::gpio_w)); - map(0x90050000, 0x90050023).rw(m_sa_periphs, FUNC(sa1110_periphs_device::intc_r), FUNC(sa1110_periphs_device::intc_w)); + map(0x80000000, 0xbfffffff).m(m_sa_periphs, FUNC(sa1110_periphs_device::map)); map(0xc0000000, 0xc3ffffff).ram().share("ram"); }