diff --git a/src/emu/machine/s3c2400.c b/src/emu/machine/s3c2400.c index 2005728338c..4ed4c77a073 100644 --- a/src/emu/machine/s3c2400.c +++ b/src/emu/machine/s3c2400.c @@ -11,7 +11,6 @@ #include "cpu/arm7/arm7core.h" #include "machine/s3c2400.h" #include "sound/dac.h" -#include "devlegcy.h" #define VERBOSE_LEVEL ( 0 ) @@ -29,56 +28,44 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, } #define DEVICE_S3C2400 +#define S3C24_CLASS_NAME s3c2400_device #include "machine/s3c24xx.inc" #undef DEVICE_S3C2400 UINT32 s3c2400_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { - return s3c24xx_video_update( this, screen, bitmap, cliprect); -} - -DEVICE_START( s3c2400 ) -{ - address_space &space = device->machine().device( "maincpu")->memory().space( AS_PROGRAM); - DEVICE_START_CALL(s3c24xx); - space.install_legacy_readwrite_handler( *device, 0x14000000, 0x1400003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w)); - space.install_legacy_readwrite_handler( *device, 0x14200000, 0x1420005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w)); - space.install_legacy_readwrite_handler( *device, 0x14400000, 0x14400017, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w)); - space.install_legacy_readwrite_handler( *device, 0x14600000, 0x1460001b, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w)); - space.install_legacy_readwrite_handler( *device, 0x14600020, 0x1460003b, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w)); - space.install_legacy_readwrite_handler( *device, 0x14600040, 0x1460005b, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w)); - space.install_legacy_readwrite_handler( *device, 0x14600060, 0x1460007b, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w)); - space.install_legacy_readwrite_handler( *device, 0x14800000, 0x14800017, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w)); - space.install_legacy_readwrite_handler( *device, 0x14a00000, 0x14a003ff, FUNC(s3c2400_lcd_r), FUNC(s3c24xx_lcd_w)); - space.install_legacy_readwrite_handler( *device, 0x14a00400, 0x14a007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w)); - space.install_legacy_readwrite_handler( *device, 0x15000000, 0x1500002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w)); - space.install_legacy_readwrite_handler( *device, 0x15004000, 0x1500402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w)); - space.install_legacy_readwrite_handler( *device, 0x15100000, 0x15100043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w)); - space.install_legacy_readwrite_handler( *device, 0x15200140, 0x152001fb, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w)); - space.install_legacy_readwrite_handler( *device, 0x15300000, 0x1530000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w)); - space.install_legacy_readwrite_handler( *device, 0x15400000, 0x1540000f, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w)); - space.install_legacy_readwrite_handler( *device, 0x15508000, 0x15508013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w)); - space.install_legacy_readwrite_handler( *device, 0x15600000, 0x1560005b, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w)); - space.install_legacy_readwrite_handler( *device, 0x15700040, 0x1570008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w)); - space.install_legacy_readwrite_handler( *device, 0x15800000, 0x15800007, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w)); - space.install_legacy_readwrite_handler( *device, 0x15900000, 0x15900017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w)); - space.install_legacy_readwrite_handler( *device, 0x15a00000, 0x15a0003f, FUNC(s3c24xx_mmc_r), FUNC(s3c24xx_mmc_w)); - - s3c24xx_video_start( device, device->machine()); + return s3c24xx_video_update(screen, bitmap, cliprect); } const device_type S3C2400 = &device_creator; s3c2400_device::s3c2400_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : device_t(mconfig, S3C2400, "Samsung S3C2400", tag, owner, clock, "s3c2400", __FILE__), - m_palette(*this) + m_palette(*this), + m_cpu(*this, ":maincpu") { - m_token = global_alloc_clear(s3c24xx_t); + memset(&m_memcon, 0, sizeof(m_memcon)); + memset(&m_usbhost, 0, sizeof(m_usbhost)); + memset(&m_irq, 0, sizeof(m_irq)); + memset(m_dma, 0, sizeof(m_dma)); + memset(&m_clkpow, 0, sizeof(m_clkpow)); + memset(&m_lcd, 0, sizeof(m_lcd)); + memset(&m_lcdpal, 0, sizeof(m_lcdpal)); + memset(m_uart, 0, sizeof(m_uart)); + memset(&m_pwm, 0, sizeof(m_pwm)); + memset(&m_usbdev, 0, sizeof(m_usbdev)); + memset(&m_wdt, 0, sizeof(m_wdt)); + memset(&m_iic, 0, sizeof(m_iic)); + memset(&m_iis, 0, sizeof(m_iis)); + memset(&m_gpio, 0, sizeof(m_gpio)); + memset(&m_rtc, 0, sizeof(m_rtc)); + memset(&m_adc, 0, sizeof(m_adc)); + memset(m_spi, 0, sizeof(m_spi)); + memset(&m_mmc, 0, sizeof(m_mmc)); } s3c2400_device::~s3c2400_device() { - global_free(m_token); } //------------------------------------------------- @@ -99,6 +86,10 @@ void s3c2400_device::static_set_palette_tag(device_t &device, const char *tag) void s3c2400_device::device_config_complete() { + // inherit a copy of the static data + const s3c2400_interface *intf = reinterpret_cast(static_config()); + if (intf != NULL) + *static_cast(this) = *intf; } //------------------------------------------------- @@ -107,9 +98,33 @@ void s3c2400_device::device_config_complete() void s3c2400_device::device_start() { - s3c24xx_t *s3c24xx = get_token(this); - s3c24xx->m_palette = m_palette; - DEVICE_START_NAME( s3c2400 )(this); + s3c24xx_device_start(); + + address_space &space = m_cpu->memory().space( AS_PROGRAM); + space.install_readwrite_handler(0x14000000, 0x1400003b, read32_delegate(FUNC(s3c2400_device::s3c24xx_memcon_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_memcon_w), this)); + space.install_readwrite_handler(0x14200000, 0x1420005b, read32_delegate(FUNC(s3c2400_device::s3c24xx_usb_host_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_usb_host_w), this)); + space.install_readwrite_handler(0x14400000, 0x14400017, read32_delegate(FUNC(s3c2400_device::s3c24xx_irq_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_irq_w), this)); + space.install_readwrite_handler(0x14600000, 0x1460001b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_0_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_0_w), this)); + space.install_readwrite_handler(0x14600020, 0x1460003b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_1_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_1_w), this)); + space.install_readwrite_handler(0x14600040, 0x1460005b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_2_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_2_w), this)); + space.install_readwrite_handler(0x14600060, 0x1460007b, read32_delegate(FUNC(s3c2400_device::s3c24xx_dma_3_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_dma_3_w), this)); + space.install_readwrite_handler(0x14800000, 0x14800017, read32_delegate(FUNC(s3c2400_device::s3c24xx_clkpow_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_clkpow_w), this)); + space.install_readwrite_handler(0x14a00000, 0x14a003ff, read32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_w), this)); + space.install_readwrite_handler(0x14a00400, 0x14a007ff, read32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_palette_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_lcd_palette_w), this)); + space.install_readwrite_handler(0x15000000, 0x1500002b, read32_delegate(FUNC(s3c2400_device::s3c24xx_uart_0_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_uart_0_w), this)); + space.install_readwrite_handler(0x15004000, 0x1500402b, read32_delegate(FUNC(s3c2400_device::s3c24xx_uart_1_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_uart_1_w), this)); + space.install_readwrite_handler(0x15100000, 0x15100043, read32_delegate(FUNC(s3c2400_device::s3c24xx_pwm_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_pwm_w), this)); + space.install_readwrite_handler(0x15200140, 0x152001fb, read32_delegate(FUNC(s3c2400_device::s3c24xx_usb_device_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_usb_device_w), this)); + space.install_readwrite_handler(0x15300000, 0x1530000b, read32_delegate(FUNC(s3c2400_device::s3c24xx_wdt_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_wdt_w), this)); + space.install_readwrite_handler(0x15400000, 0x1540000f, read32_delegate(FUNC(s3c2400_device::s3c24xx_iic_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_iic_w), this)); + space.install_readwrite_handler(0x15508000, 0x15508013, read32_delegate(FUNC(s3c2400_device::s3c24xx_iis_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_iis_w), this)); + space.install_readwrite_handler(0x15600000, 0x1560005b, read32_delegate(FUNC(s3c2400_device::s3c24xx_gpio_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_gpio_w), this)); + space.install_readwrite_handler(0x15700040, 0x1570008b, read32_delegate(FUNC(s3c2400_device::s3c24xx_rtc_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_rtc_w), this)); + space.install_readwrite_handler(0x15800000, 0x15800007, read32_delegate(FUNC(s3c2400_device::s3c24xx_adc_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_adc_w), this)); + space.install_readwrite_handler(0x15900000, 0x15900017, read32_delegate(FUNC(s3c2400_device::s3c24xx_spi_0_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_spi_0_w), this)); + space.install_readwrite_handler(0x15a00000, 0x15a0003f, read32_delegate(FUNC(s3c2400_device::s3c24xx_mmc_r), this), write32_delegate(FUNC(s3c2400_device::s3c24xx_mmc_w), this)); + + s3c24xx_video_start(); } //------------------------------------------------- @@ -118,10 +133,10 @@ void s3c2400_device::device_start() void s3c2400_device::device_reset() { - DEVICE_RESET_NAME( s3c24xx )(this); + s3c24xx_device_reset(); } -void s3c2400_uart_fifo_w( device_t *device, int uart, UINT8 data) +void s3c2400_device::s3c2400_uart_fifo_w(int uart, UINT8 data) { - s3c24xx_uart_fifo_w( device, uart, data); + s3c24xx_uart_fifo_w(uart, data); } diff --git a/src/emu/machine/s3c2400.h b/src/emu/machine/s3c2400.h index cf33e3d2d52..dae01ad1355 100644 --- a/src/emu/machine/s3c2400.h +++ b/src/emu/machine/s3c2400.h @@ -33,32 +33,6 @@ enum S3C2400_GPIO_PORT_G }; -class s3c2400_device : public device_t -{ -public: - s3c2400_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); - ~s3c2400_device(); - - // static configuration - static void static_set_palette_tag(device_t &device, const char *tag); - - // access to legacy token - struct s3c24xx_t *token() const { assert(m_token != NULL); return m_token; } - - // device-level overrides - virtual void device_config_complete(); - virtual void device_start(); - virtual void device_reset(); -private: - // internal state - struct s3c24xx_t *m_token; - required_device m_palette; -public: - UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); -}; - -extern const device_type S3C2400; - /******************************************************************************* TYPE DEFINITIONS *******************************************************************************/ @@ -99,20 +73,14 @@ struct s3c2400_interface_lcd struct s3c2400_interface { - s3c2400_interface_core core; - s3c2400_interface_gpio gpio; - s3c2400_interface_i2c i2c; - s3c2400_interface_adc adc; - s3c2400_interface_i2s i2s; - s3c2400_interface_lcd lcd; + s3c2400_interface_core m_iface_core; + s3c2400_interface_gpio m_iface_gpio; + s3c2400_interface_i2c m_iface_i2c; + s3c2400_interface_adc m_iface_adc; + s3c2400_interface_i2s m_iface_i2s; + s3c2400_interface_lcd m_iface_lcd; }; -/******************************************************************************* - PROTOTYPES -*******************************************************************************/ - -void s3c2400_uart_fifo_w( device_t *device, int uart, UINT8 data); - /******************************************************************************* MACROS & CONSTANTS *******************************************************************************/ @@ -401,363 +369,546 @@ void s3c2400_uart_fifo_w( device_t *device, int uart, UINT8 data); #define S3C24XX_DMA_COUNT 4 #define S3C24XX_SPI_COUNT 1 -/******************************************************************************* - TYPE DEFINITIONS -*******************************************************************************/ - -struct s3c24xx_memcon_regs_t +class s3c2400_device : public device_t, + public s3c2400_interface { - UINT32 data[0x34/4]; +public: + s3c2400_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + ~s3c2400_device(); + + // static configuration + static void static_set_palette_tag(device_t &device, const char *tag); + + // access to legacy token + struct s3c24xx_t *token() const { assert(m_token != NULL); return m_token; } + + // device-level overrides + virtual void device_config_complete(); + virtual void device_start(); + virtual void device_reset(); +private: + // internal state + struct s3c24xx_t *m_token; + required_device m_palette; +public: + UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); + + void s3c24xx_reset(); + inline int iface_core_pin_r(int pin); + void s3c24xx_lcd_reset(); + rgb_t s3c24xx_get_color_tft_16(UINT16 data); + rgb_t s3c24xx_get_color_stn_12(UINT16 data); + rgb_t s3c24xx_get_color_stn_08( UINT8 data); + rgb_t s3c24xx_get_color_stn_01(UINT8 data); + rgb_t s3c24xx_get_color_stn_02(UINT8 data); + rgb_t s3c24xx_get_color_stn_04(UINT8 data); + rgb_t s3c24xx_get_color_tpal(); + void s3c24xx_lcd_dma_reload(); + void s3c24xx_lcd_dma_init(); + UINT32 s3c24xx_lcd_dma_read(); + UINT32 s3c24xx_lcd_dma_read_bits(int count); + void s3c24xx_lcd_render_tpal(); + void s3c24xx_lcd_render_stn_01(); + void s3c24xx_lcd_render_stn_02(); + void s3c24xx_lcd_render_stn_04(); + void s3c24xx_lcd_render_stn_08(); + void s3c24xx_lcd_render_stn_12_p(); + void s3c24xx_lcd_render_stn_12_u(); // not tested + void s3c24xx_lcd_render_tft_01(); + void s3c24xx_lcd_render_tft_02(); + void s3c24xx_lcd_render_tft_04(); + void s3c24xx_lcd_render_tft_08(); + void s3c24xx_lcd_render_tft_16(); + TIMER_CALLBACK_MEMBER( s3c24xx_lcd_timer_exp ); + void s3c24xx_video_start(); + void bitmap_blend( bitmap_rgb32 &bitmap_dst, bitmap_rgb32 &bitmap_src_1, bitmap_rgb32 &bitmap_src_2); + UINT32 s3c24xx_video_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); + READ32_MEMBER( s3c24xx_lcd_r ); + int s3c24xx_lcd_configure_tft(); + int s3c24xx_lcd_configure_stn(); + int s3c24xx_lcd_configure(); + void s3c24xx_lcd_start(); + void s3c24xx_lcd_stop(); + void s3c24xx_lcd_recalc(); + WRITE32_MEMBER( s3c24xx_lcd_w ); + READ32_MEMBER( s3c24xx_lcd_palette_r ); + WRITE32_MEMBER( s3c24xx_lcd_palette_w ); + void s3c24xx_clkpow_reset(); + UINT32 s3c24xx_get_fclk(); + UINT32 s3c24xx_get_hclk(); + UINT32 s3c24xx_get_pclk(); + READ32_MEMBER( s3c24xx_clkpow_r ); + WRITE32_MEMBER( s3c24xx_clkpow_w ); + void s3c24xx_irq_reset(); + void s3c24xx_check_pending_irq(); + void s3c24xx_request_irq(UINT32 int_type); + READ32_MEMBER( s3c24xx_irq_r ); + WRITE32_MEMBER( s3c24xx_irq_w ); + void s3c24xx_pwm_reset(); + UINT16 s3c24xx_pwm_calc_observation(int ch); + READ32_MEMBER( s3c24xx_pwm_r ); + void s3c24xx_pwm_start(int timer); + void s3c24xx_pwm_stop(int timer); + void s3c24xx_pwm_recalc(int timer); + WRITE32_MEMBER( s3c24xx_pwm_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_pwm_timer_exp ); + void s3c24xx_dma_reset(); + void s3c24xx_dma_reload(int ch); + void s3c24xx_dma_trigger(int ch); + void s3c24xx_dma_request_iis(); + void s3c24xx_dma_request_pwm(); + void s3c24xx_dma_start(int ch); + void s3c24xx_dma_stop(int ch); + void s3c24xx_dma_recalc(int ch); + UINT32 s3c24xx_dma_r(UINT32 ch, UINT32 offset); + void s3c24xx_dma_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_dma_0_r ); + READ32_MEMBER( s3c24xx_dma_1_r ); + READ32_MEMBER( s3c24xx_dma_2_r ); + READ32_MEMBER( s3c24xx_dma_3_r ); + WRITE32_MEMBER( s3c24xx_dma_0_w ); + WRITE32_MEMBER( s3c24xx_dma_1_w ); + WRITE32_MEMBER( s3c24xx_dma_2_w ); + WRITE32_MEMBER( s3c24xx_dma_3_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_dma_timer_exp ); + void s3c24xx_gpio_reset(); + inline UINT32 iface_gpio_port_r(int port, UINT32 mask); + inline void iface_gpio_port_w(int port, UINT32 mask, UINT32 data); + UINT16 s3c24xx_gpio_get_mask( UINT32 con, int val); + READ32_MEMBER( s3c24xx_gpio_r ); + WRITE32_MEMBER( s3c24xx_gpio_w ); + void s3c24xx_memcon_reset(); + READ32_MEMBER( s3c24xx_memcon_r ); + WRITE32_MEMBER( s3c24xx_memcon_w ); + void s3c24xx_usb_host_reset(); + READ32_MEMBER( s3c24xx_usb_host_r ); + WRITE32_MEMBER( s3c24xx_usb_host_w ); + void s3c24xx_uart_reset(); + UINT32 s3c24xx_uart_r(UINT32 ch, UINT32 offset); + void s3c24xx_uart_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_uart_0_r ); + READ32_MEMBER( s3c24xx_uart_1_r ); + WRITE32_MEMBER( s3c24xx_uart_0_w ); + WRITE32_MEMBER( s3c24xx_uart_1_w ); + void s3c24xx_uart_fifo_w(int uart, UINT8 data); + void s3c24xx_usb_device_reset(); + READ32_MEMBER( s3c24xx_usb_device_r ); + WRITE32_MEMBER( s3c24xx_usb_device_w ); + void s3c24xx_wdt_reset(); + UINT16 s3c24xx_wdt_calc_current_count(); + READ32_MEMBER( s3c24xx_wdt_r ); + void s3c24xx_wdt_start(); + void s3c24xx_wdt_stop(); + void s3c24xx_wdt_recalc(); + WRITE32_MEMBER( s3c24xx_wdt_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_wdt_timer_exp ); + void s3c24xx_iic_reset(); + inline void iface_i2c_scl_w( int state); + inline void iface_i2c_sda_w(int state); + inline int iface_i2c_sda_r(); + void i2c_send_start(); + void i2c_send_stop(); + UINT8 i2c_receive_byte(int ack); + int i2c_send_byte(UINT8 data); + void iic_start(); + void iic_stop(); + void iic_resume(); + READ32_MEMBER( s3c24xx_iic_r ); + WRITE32_MEMBER( s3c24xx_iic_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_iic_timer_exp ); + void s3c24xx_iis_reset(); + inline void iface_i2s_data_w(int ch, UINT16 data); + void s3c24xx_iis_start(); + void s3c24xx_iis_stop(); + void s3c24xx_iis_recalc(); + READ32_MEMBER( s3c24xx_iis_r ); + WRITE32_MEMBER( s3c24xx_iis_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_iis_timer_exp ); + void s3c24xx_rtc_reset(); + READ32_MEMBER( s3c24xx_rtc_r ); + void s3c24xx_rtc_recalc(); + WRITE32_MEMBER( s3c24xx_rtc_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_rtc_timer_tick_count_exp ); + void s3c24xx_rtc_update(); + void s3c24xx_rtc_check_alarm(); + TIMER_CALLBACK_MEMBER( s3c24xx_rtc_timer_update_exp ); + void s3c24xx_adc_reset(); + UINT32 iface_adc_data_r(int ch); + READ32_MEMBER( s3c24xx_adc_r ); + void s3c24xx_adc_start(); + WRITE32_MEMBER( s3c24xx_adc_w ); + void s3c24xx_spi_reset(); + UINT32 s3c24xx_spi_r(UINT32 ch, UINT32 offset); + void s3c24xx_spi_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_spi_0_r ); + WRITE32_MEMBER( s3c24xx_spi_0_w ); + void s3c24xx_mmc_reset(); + READ32_MEMBER( s3c24xx_mmc_r ); + WRITE32_MEMBER( s3c24xx_mmc_w ); + void s3c24xx_device_reset(); + void s3c24xx_device_start(); + + + void s3c2400_uart_fifo_w(int uart, UINT8 data); + + /******************************************************************************* + TYPE DEFINITIONS + *******************************************************************************/ + + struct s3c24xx_memcon_regs_t + { + UINT32 data[0x34/4]; + }; + + struct s3c24xx_usbhost_regs_t + { + UINT32 data[0x5C/4]; + }; + + struct s3c24xx_irq_regs_t + { + UINT32 srcpnd; + UINT32 intmod; + UINT32 intmsk; + UINT32 priority; + UINT32 intpnd; + UINT32 intoffset; + }; + + struct s3c24xx_dma_regs_t + { + UINT32 disrc; + UINT32 didst; + UINT32 dcon; + UINT32 dstat; + UINT32 dcsrc; + UINT32 dcdst; + UINT32 dmasktrig; + }; + + struct s3c24xx_clkpow_regs_t + { + UINT32 locktime; + UINT32 mpllcon; + UINT32 upllcon; + UINT32 clkcon; + UINT32 clkslow; + UINT32 clkdivn; + }; + + struct s3c24xx_lcd_regs_t + { + UINT32 lcdcon1; + UINT32 lcdcon2; + UINT32 lcdcon3; + UINT32 lcdcon4; + UINT32 lcdcon5; + UINT32 lcdsaddr1; + UINT32 lcdsaddr2; + UINT32 lcdsaddr3; + UINT32 redlut; + UINT32 greenlut; + UINT32 bluelut; + UINT32 reserved[8]; + UINT32 dithmode; + UINT32 tpal; + }; + + struct s3c24xx_lcdpal_regs_t + { + UINT32 data[0x400/4]; + }; + + struct s3c24xx_uart_regs_t + { + UINT32 ulcon; + UINT32 ucon; + UINT32 ufcon; + UINT32 umcon; + UINT32 utrstat; + UINT32 uerstat; + UINT32 ufstat; + UINT32 umstat; + UINT32 utxh; + UINT32 urxh; + UINT32 ubrdiv; + }; + + struct s3c24xx_pwm_regs_t + { + UINT32 tcfg0; + UINT32 tcfg1; + UINT32 tcon; + UINT32 tcntb0; + UINT32 tcmpb0; + UINT32 tcnto0; + UINT32 tcntb1; + UINT32 tcmpb1; + UINT32 tcnto1; + UINT32 tcntb2; + UINT32 tcmpb2; + UINT32 tcnto2; + UINT32 tcntb3; + UINT32 tcmpb3; + UINT32 tcnto3; + UINT32 tcntb4; + UINT32 tcnto4; + }; + + struct s3c24xx_usbdev_regs_t + { + UINT32 data[0xBC/4]; + }; + + struct s3c24xx_wdt_regs_t + { + UINT32 wtcon; + UINT32 wtdat; + UINT32 wtcnt; + }; + + struct s3c24xx_iic_regs_t + { + UINT32 iiccon; + UINT32 iicstat; + UINT32 iicadd; + UINT32 iicds; + }; + + struct s3c24xx_iis_regs_t + { + UINT32 iiscon; + UINT32 iismod; + UINT32 iispsr; + UINT32 iisfcon; + UINT32 iisfifo; + }; + + struct s3c24xx_gpio_regs_t + { + UINT32 gpacon; + UINT32 gpadat; + UINT32 gpbcon; + UINT32 gpbdat; + UINT32 gpbup; + UINT32 gpccon; + UINT32 gpcdat; + UINT32 gpcup; + UINT32 gpdcon; + UINT32 gpddat; + UINT32 gpdup; + UINT32 gpecon; + UINT32 gpedat; + UINT32 gpeup; + UINT32 gpfcon; + UINT32 gpfdat; + UINT32 gpfup; + UINT32 gpgcon; + UINT32 gpgdat; + UINT32 gpgup; + UINT32 opencr; + UINT32 misccr; + UINT32 extint; + }; + + struct s3c24xx_rtc_regs_t + { + UINT32 rtccon; + UINT32 ticnt; + UINT32 reserved[2]; + UINT32 rtcalm; + UINT32 almsec; + UINT32 almmin; + UINT32 almhour; + UINT32 almday; + UINT32 almmon; + UINT32 almyear; + UINT32 rtcrst; + UINT32 bcdsec; + UINT32 bcdmin; + UINT32 bcdhour; + UINT32 bcdday; + UINT32 bcddow; + UINT32 bcdmon; + UINT32 bcdyear; + }; + + struct s3c24xx_adc_regs_t + { + UINT32 adccon; + UINT32 adcdat; + }; + + struct s3c24xx_spi_regs_t + { + UINT32 spcon; + UINT32 spsta; + UINT32 sppin; + UINT32 sppre; + UINT32 sptdat; + UINT32 sprdat; + }; + + struct s3c24xx_mmc_regs_t + { + UINT32 data[0x40/4]; + }; + + struct s3c24xx_memcon_t + { + s3c24xx_memcon_regs_t regs; + }; + + struct s3c24xx_usbhost_t + { + s3c24xx_usbhost_regs_t regs; + }; + + struct s3c24xx_irq_t + { + s3c24xx_irq_regs_t regs; + int line_irq, line_fiq; + }; + + struct s3c24xx_dma_t + { + s3c24xx_dma_regs_t regs; + emu_timer *timer; + }; + + struct s3c24xx_clkpow_t + { + s3c24xx_clkpow_regs_t regs; + }; + + struct s3c24xx_lcd_t + { + s3c24xx_lcd_regs_t regs; + emu_timer *timer; + bitmap_rgb32 *bitmap[2]; + UINT32 vramaddr_cur; + UINT32 vramaddr_max; + UINT32 offsize; + UINT32 pagewidth_cur; + UINT32 pagewidth_max; + UINT32 bppmode; + UINT32 bswp, hwswp; + int vpos, hpos; + double framerate; + UINT32 tpal; + UINT32 hpos_min, hpos_max, vpos_min, vpos_max; + UINT32 dma_data, dma_bits; + }; + + struct s3c24xx_lcdpal_t + { + s3c24xx_lcdpal_regs_t regs; + }; + + struct s3c24xx_uart_t + { + s3c24xx_uart_regs_t regs; + }; + + struct s3c24xx_pwm_t + { + s3c24xx_pwm_regs_t regs; + emu_timer *timer[5]; + UINT32 cnt[5]; + UINT32 cmp[5]; + UINT32 freq[5]; + }; + + struct s3c24xx_usbdev_t + { + s3c24xx_usbdev_regs_t regs; + }; + + struct s3c24xx_wdt_t + { + s3c24xx_wdt_regs_t regs; + emu_timer *timer; + }; + + struct s3c24xx_iic_t + { + s3c24xx_iic_regs_t regs; + emu_timer *timer; + int count; + }; + + struct s3c24xx_iis_t + { + s3c24xx_iis_regs_t regs; + emu_timer *timer; + UINT16 fifo[16/2]; + int fifo_index; + }; + + struct s3c24xx_gpio_t + { + s3c24xx_gpio_regs_t regs; + }; + + struct s3c24xx_rtc_t + { + s3c24xx_rtc_regs_t regs; + emu_timer *timer_tick_count; + emu_timer *timer_update; + }; + + struct s3c24xx_adc_t + { + s3c24xx_adc_regs_t regs; + }; + + struct s3c24xx_spi_t + { + s3c24xx_spi_regs_t regs; + }; + + struct s3c24xx_mmc_t + { + s3c24xx_mmc_regs_t regs; + }; + + + s3c24xx_memcon_t m_memcon; + s3c24xx_usbhost_t m_usbhost; + s3c24xx_irq_t m_irq; + s3c24xx_dma_t m_dma[S3C24XX_DMA_COUNT]; + s3c24xx_clkpow_t m_clkpow; + s3c24xx_lcd_t m_lcd; + s3c24xx_lcdpal_t m_lcdpal; + s3c24xx_uart_t m_uart[S3C24XX_UART_COUNT]; + s3c24xx_pwm_t m_pwm; + s3c24xx_usbdev_t m_usbdev; + s3c24xx_wdt_t m_wdt; + s3c24xx_iic_t m_iic; + s3c24xx_iis_t m_iis; + s3c24xx_gpio_t m_gpio; + s3c24xx_rtc_t m_rtc; + s3c24xx_adc_t m_adc; + s3c24xx_spi_t m_spi[S3C24XX_SPI_COUNT]; + s3c24xx_mmc_t m_mmc; + required_device m_cpu; + devcb_resolved_read32 m_pin_r; + devcb_resolved_write32 m_pin_w; + devcb_resolved_read32 m_port_r; + devcb_resolved_write32 m_port_w; + devcb_resolved_write_line m_scl_w; + devcb_resolved_read_line m_sda_r; + devcb_resolved_write_line m_sda_w; + devcb_resolved_read32 m_adc_data_r; + devcb_resolved_write16 m_i2s_data_w; + devcb_resolved_write8 m_command_w; + devcb_resolved_write8 m_address_w; + devcb_resolved_read8 m_nand_data_r; + devcb_resolved_write8 m_nand_data_w; + }; -struct s3c24xx_usbhost_regs_t -{ - UINT32 data[0x5C/4]; -}; +extern const device_type S3C2400; -struct s3c24xx_irq_regs_t -{ - UINT32 srcpnd; - UINT32 intmod; - UINT32 intmsk; - UINT32 priority; - UINT32 intpnd; - UINT32 intoffset; -}; - -struct s3c24xx_dma_regs_t -{ - UINT32 disrc; - UINT32 didst; - UINT32 dcon; - UINT32 dstat; - UINT32 dcsrc; - UINT32 dcdst; - UINT32 dmasktrig; -}; - -struct s3c24xx_clkpow_regs_t -{ - UINT32 locktime; - UINT32 mpllcon; - UINT32 upllcon; - UINT32 clkcon; - UINT32 clkslow; - UINT32 clkdivn; -}; - -struct s3c24xx_lcd_regs_t -{ - UINT32 lcdcon1; - UINT32 lcdcon2; - UINT32 lcdcon3; - UINT32 lcdcon4; - UINT32 lcdcon5; - UINT32 lcdsaddr1; - UINT32 lcdsaddr2; - UINT32 lcdsaddr3; - UINT32 redlut; - UINT32 greenlut; - UINT32 bluelut; - UINT32 reserved[8]; - UINT32 dithmode; - UINT32 tpal; -}; - -struct s3c24xx_lcdpal_regs_t -{ - UINT32 data[0x400/4]; -}; - -struct s3c24xx_uart_regs_t -{ - UINT32 ulcon; - UINT32 ucon; - UINT32 ufcon; - UINT32 umcon; - UINT32 utrstat; - UINT32 uerstat; - UINT32 ufstat; - UINT32 umstat; - UINT32 utxh; - UINT32 urxh; - UINT32 ubrdiv; -}; - -struct s3c24xx_pwm_regs_t -{ - UINT32 tcfg0; - UINT32 tcfg1; - UINT32 tcon; - UINT32 tcntb0; - UINT32 tcmpb0; - UINT32 tcnto0; - UINT32 tcntb1; - UINT32 tcmpb1; - UINT32 tcnto1; - UINT32 tcntb2; - UINT32 tcmpb2; - UINT32 tcnto2; - UINT32 tcntb3; - UINT32 tcmpb3; - UINT32 tcnto3; - UINT32 tcntb4; - UINT32 tcnto4; -}; - -struct s3c24xx_usbdev_regs_t -{ - UINT32 data[0xBC/4]; -}; - -struct s3c24xx_wdt_regs_t -{ - UINT32 wtcon; - UINT32 wtdat; - UINT32 wtcnt; -}; - -struct s3c24xx_iic_regs_t -{ - UINT32 iiccon; - UINT32 iicstat; - UINT32 iicadd; - UINT32 iicds; -}; - -struct s3c24xx_iis_regs_t -{ - UINT32 iiscon; - UINT32 iismod; - UINT32 iispsr; - UINT32 iisfcon; - UINT32 iisfifo; -}; - -struct s3c24xx_gpio_regs_t -{ - UINT32 gpacon; - UINT32 gpadat; - UINT32 gpbcon; - UINT32 gpbdat; - UINT32 gpbup; - UINT32 gpccon; - UINT32 gpcdat; - UINT32 gpcup; - UINT32 gpdcon; - UINT32 gpddat; - UINT32 gpdup; - UINT32 gpecon; - UINT32 gpedat; - UINT32 gpeup; - UINT32 gpfcon; - UINT32 gpfdat; - UINT32 gpfup; - UINT32 gpgcon; - UINT32 gpgdat; - UINT32 gpgup; - UINT32 opencr; - UINT32 misccr; - UINT32 extint; -}; - -struct s3c24xx_rtc_regs_t -{ - UINT32 rtccon; - UINT32 ticnt; - UINT32 reserved[2]; - UINT32 rtcalm; - UINT32 almsec; - UINT32 almmin; - UINT32 almhour; - UINT32 almday; - UINT32 almmon; - UINT32 almyear; - UINT32 rtcrst; - UINT32 bcdsec; - UINT32 bcdmin; - UINT32 bcdhour; - UINT32 bcdday; - UINT32 bcddow; - UINT32 bcdmon; - UINT32 bcdyear; -}; - -struct s3c24xx_adc_regs_t -{ - UINT32 adccon; - UINT32 adcdat; -}; - -struct s3c24xx_spi_regs_t -{ - UINT32 spcon; - UINT32 spsta; - UINT32 sppin; - UINT32 sppre; - UINT32 sptdat; - UINT32 sprdat; -}; - -struct s3c24xx_mmc_regs_t -{ - UINT32 data[0x40/4]; -}; - -struct s3c24xx_memcon_t -{ - s3c24xx_memcon_regs_t regs; -}; - -struct s3c24xx_usbhost_t -{ - s3c24xx_usbhost_regs_t regs; -}; - -struct s3c24xx_irq_t -{ - s3c24xx_irq_regs_t regs; - int line_irq, line_fiq; -}; - -struct s3c24xx_dma_t -{ - s3c24xx_dma_regs_t regs; - emu_timer *timer; -}; - -struct s3c24xx_clkpow_t -{ - s3c24xx_clkpow_regs_t regs; -}; - -struct s3c24xx_lcd_t -{ - s3c24xx_lcd_regs_t regs; - emu_timer *timer; - bitmap_rgb32 *bitmap[2]; - UINT32 vramaddr_cur; - UINT32 vramaddr_max; - UINT32 offsize; - UINT32 pagewidth_cur; - UINT32 pagewidth_max; - UINT32 bppmode; - UINT32 bswp, hwswp; - int vpos, hpos; - double framerate; - UINT32 tpal; - UINT32 hpos_min, hpos_max, vpos_min, vpos_max; - UINT32 dma_data, dma_bits; -}; - -struct s3c24xx_lcdpal_t -{ - s3c24xx_lcdpal_regs_t regs; -}; - -struct s3c24xx_uart_t -{ - s3c24xx_uart_regs_t regs; -}; - -struct s3c24xx_pwm_t -{ - s3c24xx_pwm_regs_t regs; - emu_timer *timer[5]; - UINT32 cnt[5]; - UINT32 cmp[5]; - UINT32 freq[5]; -}; - -struct s3c24xx_usbdev_t -{ - s3c24xx_usbdev_regs_t regs; -}; - -struct s3c24xx_wdt_t -{ - s3c24xx_wdt_regs_t regs; - emu_timer *timer; -}; - -struct s3c24xx_iic_t -{ - s3c24xx_iic_regs_t regs; - emu_timer *timer; - int count; -}; - -struct s3c24xx_iis_t -{ - s3c24xx_iis_regs_t regs; - emu_timer *timer; - UINT16 fifo[16/2]; - int fifo_index; -}; - -struct s3c24xx_gpio_t -{ - s3c24xx_gpio_regs_t regs; -}; - -struct s3c24xx_rtc_t -{ - s3c24xx_rtc_regs_t regs; - emu_timer *timer_tick_count; - emu_timer *timer_update; -}; - -struct s3c24xx_adc_t -{ - s3c24xx_adc_regs_t regs; -}; - -struct s3c24xx_spi_t -{ - s3c24xx_spi_regs_t regs; -}; - -struct s3c24xx_mmc_t -{ - s3c24xx_mmc_regs_t regs; -}; - -struct s3c24xx_t -{ - const s3c2400_interface *iface; - s3c24xx_memcon_t memcon; - s3c24xx_usbhost_t usbhost; - s3c24xx_irq_t irq; - s3c24xx_dma_t dma[S3C24XX_DMA_COUNT]; - s3c24xx_clkpow_t clkpow; - s3c24xx_lcd_t lcd; - s3c24xx_lcdpal_t lcdpal; - s3c24xx_uart_t uart[S3C24XX_UART_COUNT]; - s3c24xx_pwm_t pwm; - s3c24xx_usbdev_t usbdev; - s3c24xx_wdt_t wdt; - s3c24xx_iic_t iic; - s3c24xx_iis_t iis; - s3c24xx_gpio_t gpio; - s3c24xx_rtc_t rtc; - s3c24xx_adc_t adc; - s3c24xx_spi_t spi[S3C24XX_SPI_COUNT]; - s3c24xx_mmc_t mmc; - device_t *m_cpu; - devcb_resolved_read32 pin_r; - devcb_resolved_write32 pin_w; - devcb_resolved_read32 port_r; - devcb_resolved_write32 port_w; - devcb_resolved_write_line scl_w; - devcb_resolved_read_line sda_r; - devcb_resolved_write_line sda_w; - devcb_resolved_read32 adc_data_r; - devcb_resolved_write16 i2s_data_w; - devcb_resolved_write8 command_w; - devcb_resolved_write8 address_w; - devcb_resolved_read8 nand_data_r; - devcb_resolved_write8 nand_data_w; - palette_device *m_palette; -}; #endif diff --git a/src/emu/machine/s3c2410.c b/src/emu/machine/s3c2410.c index faf1c7f8b9a..0bba6bd3022 100644 --- a/src/emu/machine/s3c2410.c +++ b/src/emu/machine/s3c2410.c @@ -11,7 +11,6 @@ #include "cpu/arm7/arm7core.h" #include "machine/s3c2410.h" #include "sound/dac.h" -#include "devlegcy.h" #define VERBOSE_LEVEL ( 0 ) @@ -29,59 +28,46 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, } #define DEVICE_S3C2410 +#define S3C24_CLASS_NAME s3c2410_device #include "machine/s3c24xx.inc" #undef DEVICE_S3C2410 UINT32 s3c2410_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { - return s3c24xx_video_update( this, screen, bitmap, cliprect); -} - -DEVICE_START( s3c2410 ) -{ - address_space &space = device->machine().device( "maincpu")->memory().space( AS_PROGRAM); - DEVICE_START_CALL(s3c24xx); - space.install_legacy_readwrite_handler( *device, 0x48000000, 0x4800003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w)); - space.install_legacy_readwrite_handler( *device, 0x49000000, 0x4900005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w)); - space.install_legacy_readwrite_handler( *device, 0x4a000000, 0x4a00001f, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w)); - space.install_legacy_readwrite_handler( *device, 0x4b000000, 0x4b000023, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w)); - space.install_legacy_readwrite_handler( *device, 0x4b000040, 0x4b000063, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w)); - space.install_legacy_readwrite_handler( *device, 0x4b000080, 0x4b0000a3, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w)); - space.install_legacy_readwrite_handler( *device, 0x4b0000c0, 0x4b0000e3, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w)); - space.install_legacy_readwrite_handler( *device, 0x4c000000, 0x4c000017, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w)); - space.install_legacy_readwrite_handler( *device, 0x4d000000, 0x4d000063, FUNC(s3c2410_lcd_r), FUNC(s3c24xx_lcd_w)); - space.install_legacy_readwrite_handler( *device, 0x4d000400, 0x4d0007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w)); - space.install_legacy_readwrite_handler( *device, 0x4e000000, 0x4e000017, FUNC(s3c24xx_nand_r), FUNC(s3c24xx_nand_w)); - space.install_legacy_readwrite_handler( *device, 0x50000000, 0x5000002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w)); - space.install_legacy_readwrite_handler( *device, 0x50004000, 0x5000402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w)); - space.install_legacy_readwrite_handler( *device, 0x50008000, 0x5000802b, FUNC(s3c24xx_uart_2_r), FUNC(s3c24xx_uart_2_w)); - space.install_legacy_readwrite_handler( *device, 0x51000000, 0x51000043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w)); - space.install_legacy_readwrite_handler( *device, 0x52000140, 0x5200026f, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w)); - space.install_legacy_readwrite_handler( *device, 0x53000000, 0x5300000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w)); - space.install_legacy_readwrite_handler( *device, 0x54000000, 0x5400000f, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w)); - space.install_legacy_readwrite_handler( *device, 0x55000000, 0x55000013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w)); - space.install_legacy_readwrite_handler( *device, 0x56000000, 0x560000bf, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w)); - space.install_legacy_readwrite_handler( *device, 0x57000040, 0x5700008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w)); - space.install_legacy_readwrite_handler( *device, 0x58000000, 0x58000013, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w)); - space.install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w)); - space.install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w)); - space.install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w)); - - s3c24xx_video_start( device, device->machine()); + return s3c24xx_video_update(screen, bitmap, cliprect); } const device_type S3C2410 = &device_creator; s3c2410_device::s3c2410_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : device_t(mconfig, S3C2410, "Samsung S3C2410", tag, owner, clock, "s3c2410", __FILE__), - m_palette(*this) + m_palette(*this), + m_cpu(*this, ":maincpu") { - m_token = global_alloc_clear(s3c24xx_t); + memset(m_steppingstone, 0, sizeof(m_steppingstone)); + memset(&m_memcon, 0, sizeof(m_memcon)); + memset(&m_usbhost, 0, sizeof(m_usbhost)); + memset(&m_irq, 0, sizeof(m_irq)); + memset(m_dma, 0, sizeof(m_dma)); + memset(&m_clkpow, 0, sizeof(m_clkpow)); + memset(&m_lcd, 0, sizeof(m_lcd)); + memset(&m_lcdpal, 0, sizeof(m_lcdpal)); + memset(&m_nand, 0, sizeof(m_nand)); + memset(m_uart, 0, sizeof(m_uart)); + memset(&m_pwm, 0, sizeof(m_pwm)); + memset(&m_usbdev, 0, sizeof(m_usbdev)); + memset(&m_wdt, 0, sizeof(m_wdt)); + memset(&m_iic, 0, sizeof(m_iic)); + memset(&m_iis, 0, sizeof(m_iis)); + memset(&m_gpio, 0, sizeof(m_gpio)); + memset(&m_rtc, 0, sizeof(m_rtc)); + memset(&m_adc, 0, sizeof(m_adc)); + memset(m_spi, 0, sizeof(m_spi)); + memset(&m_sdi, 0, sizeof(m_sdi)); } s3c2410_device::~s3c2410_device() { - global_free(m_token); } //------------------------------------------------- @@ -102,6 +88,10 @@ void s3c2410_device::static_set_palette_tag(device_t &device, const char *tag) void s3c2410_device::device_config_complete() { + // inherit a copy of the static data + const s3c2410_interface *intf = reinterpret_cast(static_config()); + if (intf != NULL) + *static_cast(this) = *intf; } //------------------------------------------------- @@ -110,9 +100,36 @@ void s3c2410_device::device_config_complete() void s3c2410_device::device_start() { - s3c24xx_t *s3c24xx = get_token(this); - s3c24xx->m_palette = m_palette; - DEVICE_START_NAME( s3c2410 )(this); + s3c24xx_device_start(); + + address_space &space = m_cpu->memory().space( AS_PROGRAM); + space.install_readwrite_handler( 0x48000000, 0x4800003b, read32_delegate(FUNC(s3c2410_device::s3c24xx_memcon_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_memcon_w), this)); + space.install_readwrite_handler( 0x49000000, 0x4900005b, read32_delegate(FUNC(s3c2410_device::s3c24xx_usb_host_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_usb_host_w), this)); + space.install_readwrite_handler( 0x4a000000, 0x4a00001f, read32_delegate(FUNC(s3c2410_device::s3c24xx_irq_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_irq_w), this)); + space.install_readwrite_handler( 0x4b000000, 0x4b000023, read32_delegate(FUNC(s3c2410_device::s3c24xx_dma_0_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_dma_0_w), this)); + space.install_readwrite_handler( 0x4b000040, 0x4b000063, read32_delegate(FUNC(s3c2410_device::s3c24xx_dma_1_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_dma_1_w), this)); + space.install_readwrite_handler( 0x4b000080, 0x4b0000a3, read32_delegate(FUNC(s3c2410_device::s3c24xx_dma_2_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_dma_2_w), this)); + space.install_readwrite_handler( 0x4b0000c0, 0x4b0000e3, read32_delegate(FUNC(s3c2410_device::s3c24xx_dma_3_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_dma_3_w), this)); + space.install_readwrite_handler( 0x4c000000, 0x4c000017, read32_delegate(FUNC(s3c2410_device::s3c24xx_clkpow_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_clkpow_w), this)); + space.install_readwrite_handler( 0x4d000000, 0x4d000063, read32_delegate(FUNC(s3c2410_device::s3c24xx_lcd_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_lcd_w), this)); + space.install_readwrite_handler( 0x4d000400, 0x4d0007ff, read32_delegate(FUNC(s3c2410_device::s3c24xx_lcd_palette_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_lcd_palette_w), this)); + space.install_readwrite_handler( 0x4e000000, 0x4e000017, read32_delegate(FUNC(s3c2410_device::s3c24xx_nand_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_nand_w), this)); + space.install_readwrite_handler( 0x50000000, 0x5000002b, read32_delegate(FUNC(s3c2410_device::s3c24xx_uart_0_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_uart_0_w), this)); + space.install_readwrite_handler( 0x50004000, 0x5000402b, read32_delegate(FUNC(s3c2410_device::s3c24xx_uart_1_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_uart_1_w), this)); + space.install_readwrite_handler( 0x50008000, 0x5000802b, read32_delegate(FUNC(s3c2410_device::s3c24xx_uart_2_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_uart_2_w), this)); + space.install_readwrite_handler( 0x51000000, 0x51000043, read32_delegate(FUNC(s3c2410_device::s3c24xx_pwm_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_pwm_w), this)); + space.install_readwrite_handler( 0x52000140, 0x5200026f, read32_delegate(FUNC(s3c2410_device::s3c24xx_usb_device_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_usb_device_w), this)); + space.install_readwrite_handler( 0x53000000, 0x5300000b, read32_delegate(FUNC(s3c2410_device::s3c24xx_wdt_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_wdt_w), this)); + space.install_readwrite_handler( 0x54000000, 0x5400000f, read32_delegate(FUNC(s3c2410_device::s3c24xx_iic_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_iic_w), this)); + space.install_readwrite_handler( 0x55000000, 0x55000013, read32_delegate(FUNC(s3c2410_device::s3c24xx_iis_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_iis_w), this)); + space.install_readwrite_handler( 0x56000000, 0x560000bf, read32_delegate(FUNC(s3c2410_device::s3c24xx_gpio_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_gpio_w), this)); + space.install_readwrite_handler( 0x57000040, 0x5700008b, read32_delegate(FUNC(s3c2410_device::s3c24xx_rtc_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_rtc_w), this)); + space.install_readwrite_handler( 0x58000000, 0x58000013, read32_delegate(FUNC(s3c2410_device::s3c24xx_adc_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_adc_w), this)); + space.install_readwrite_handler( 0x59000000, 0x59000017, read32_delegate(FUNC(s3c2410_device::s3c24xx_spi_0_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_spi_0_w), this)); + space.install_readwrite_handler( 0x59000020, 0x59000037, read32_delegate(FUNC(s3c2410_device::s3c24xx_spi_1_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_spi_1_w), this)); + space.install_readwrite_handler( 0x5a000000, 0x5a000043, read32_delegate(FUNC(s3c2410_device::s3c24xx_sdi_r), this), write32_delegate(FUNC(s3c2410_device::s3c24xx_sdi_w), this)); + + s3c24xx_video_start(); } //------------------------------------------------- @@ -121,31 +138,31 @@ void s3c2410_device::device_start() void s3c2410_device::device_reset() { - DEVICE_RESET_NAME( s3c24xx )(this); + s3c24xx_device_reset(); } -void s3c2410_uart_fifo_w( device_t *device, int uart, UINT8 data) +void s3c2410_device::s3c2410_uart_fifo_w( int uart, UINT8 data) { - s3c24xx_uart_fifo_w( device, uart, data); + s3c24xx_uart_fifo_w( uart, data); } -void s3c2410_touch_screen( device_t *device, int state) +void s3c2410_device::s3c2410_touch_screen( int state) { - s3c24xx_touch_screen( device, state); + s3c24xx_touch_screen(state); } WRITE_LINE_MEMBER( s3c2410_device::frnb_w ) { - s3c24xx_pin_frnb_w(this, state); + s3c24xx_pin_frnb_w(state); } -void s3c2410_nand_calculate_mecc( UINT8 *data, UINT32 size, UINT8 *mecc) +void s3c2410_device::s3c2410_nand_calculate_mecc( UINT8 *data, UINT32 size, UINT8 *mecc) { mecc[0] = mecc[1] = mecc[2] = mecc[3] = 0xFF; for (int i = 0; i < size; i++) nand_update_mecc( mecc, i, data[i]); } -void s3c2410_request_eint( device_t *device, UINT32 number) +void s3c2410_device::s3c2410_request_eint(UINT32 number) { - s3c24xx_request_eint( device, number); + s3c24xx_request_eint(number); } diff --git a/src/emu/machine/s3c2410.h b/src/emu/machine/s3c2410.h index 4f4ae3894bf..413322f94e3 100644 --- a/src/emu/machine/s3c2410.h +++ b/src/emu/machine/s3c2410.h @@ -41,36 +41,6 @@ enum S3C2410_CORE_PIN_OM1 }; -class s3c2410_device : public device_t -{ -public: - s3c2410_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); - ~s3c2410_device(); - - // static configuration - static void static_set_palette_tag(device_t &device, const char *tag); - - // access to legacy token - struct s3c24xx_t *token() const { assert(m_token != NULL); return m_token; } - - DECLARE_WRITE_LINE_MEMBER( frnb_w ); - - // device-level overrides - virtual void device_config_complete(); - virtual void device_start(); - virtual void device_reset(); -private: - // internal state - struct s3c24xx_t *m_token; - required_device m_palette; -public: - UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); -}; - -extern const device_type S3C2410; - - -DECLARE_READ32_DEVICE_HANDLER( s3c2410_lcd_r ); /******************************************************************************* TYPE DEFINITIONS @@ -120,23 +90,15 @@ struct s3c2410_interface_lcd struct s3c2410_interface { - s3c2410_interface_core core; - s3c2410_interface_gpio gpio; - s3c2410_interface_i2c i2c; - s3c2410_interface_adc adc; - s3c2410_interface_i2s i2s; - s3c2410_interface_nand nand; - s3c2410_interface_lcd lcd; + s3c2410_interface_core m_iface_core; + s3c2410_interface_gpio m_iface_gpio; + s3c2410_interface_i2c m_iface_i2c; + s3c2410_interface_adc m_iface_adc; + s3c2410_interface_i2s m_iface_i2s; + s3c2410_interface_nand m_iface_nand; + s3c2410_interface_lcd m_iface_lcd; }; -/******************************************************************************* - PROTOTYPES -*******************************************************************************/ - -void s3c2410_uart_fifo_w( device_t *device, int uart, UINT8 data); -void s3c2410_touch_screen( device_t *device, int state); -void s3c2410_request_eint( device_t *device, UINT32 number); -void s3c2410_nand_calculate_mecc( UINT8 *data, UINT32 size, UINT8 *mecc); /******************************************************************************* MACROS & CONSTANTS @@ -492,419 +454,630 @@ static const UINT32 MAP_SUBINT_TO_INT[11] = #define S3C24XX_DMA_COUNT 4 #define S3C24XX_SPI_COUNT 2 -/******************************************************************************* - TYPE DEFINITIONS -*******************************************************************************/ - -struct s3c24xx_memcon_regs_t +class s3c2410_device : public device_t, + public s3c2410_interface { - UINT32 data[0x34/4]; +public: + s3c2410_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + ~s3c2410_device(); + + // static configuration + static void static_set_palette_tag(device_t &device, const char *tag); + + // access to legacy token + struct s3c24xx_t *token() const { assert(m_token != NULL); return m_token; } + + DECLARE_WRITE_LINE_MEMBER( frnb_w ); + + // device-level overrides + virtual void device_config_complete(); + virtual void device_start(); + virtual void device_reset(); +private: + // internal state + struct s3c24xx_t *m_token; + required_device m_palette; +public: + UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); + + void s3c24xx_reset(); + inline int iface_core_pin_r(int pin); + void s3c24xx_lcd_reset(); + rgb_t s3c24xx_get_color_tft_16(UINT16 data); + rgb_t s3c24xx_get_color_tft_24(UINT32 data); + rgb_t s3c24xx_get_color_stn_12(UINT16 data); + rgb_t s3c24xx_get_color_stn_08( UINT8 data); + rgb_t s3c24xx_get_color_stn_01(UINT8 data); + rgb_t s3c24xx_get_color_stn_02(UINT8 data); + rgb_t s3c24xx_get_color_stn_04(UINT8 data); + rgb_t s3c24xx_get_color_tpal(); + void s3c24xx_lcd_dma_reload(); + void s3c24xx_lcd_dma_init(); + UINT32 s3c24xx_lcd_dma_read(); + UINT32 s3c24xx_lcd_dma_read_bits(int count); + void s3c24xx_lcd_render_tpal(); + void s3c24xx_lcd_render_stn_01(); + void s3c24xx_lcd_render_stn_02(); + void s3c24xx_lcd_render_stn_04(); + void s3c24xx_lcd_render_stn_08(); + void s3c24xx_lcd_render_stn_12_p(); + void s3c24xx_lcd_render_stn_12_u(); // not tested + void s3c24xx_lcd_render_tft_01(); + void s3c24xx_lcd_render_tft_02(); + void s3c24xx_lcd_render_tft_04(); + void s3c24xx_lcd_render_tft_08(); + void s3c24xx_lcd_render_tft_16(); + TIMER_CALLBACK_MEMBER( s3c24xx_lcd_timer_exp ); + void s3c24xx_video_start(); + void bitmap_blend( bitmap_rgb32 &bitmap_dst, bitmap_rgb32 &bitmap_src_1, bitmap_rgb32 &bitmap_src_2); + UINT32 s3c24xx_video_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); + READ32_MEMBER( s3c24xx_lcd_r ); + int s3c24xx_lcd_configure_tft(); + int s3c24xx_lcd_configure_stn(); + int s3c24xx_lcd_configure(); + void s3c24xx_lcd_start(); + void s3c24xx_lcd_stop(); + void s3c24xx_lcd_recalc(); + WRITE32_MEMBER( s3c24xx_lcd_w ); + READ32_MEMBER( s3c24xx_lcd_palette_r ); + WRITE32_MEMBER( s3c24xx_lcd_palette_w ); + void s3c24xx_clkpow_reset(); + UINT32 s3c24xx_get_fclk(); + UINT32 s3c24xx_get_hclk(); + UINT32 s3c24xx_get_pclk(); + READ32_MEMBER( s3c24xx_clkpow_r ); + WRITE32_MEMBER( s3c24xx_clkpow_w ); + void s3c24xx_irq_reset(); + void s3c24xx_check_pending_irq(); + void s3c24xx_request_irq(UINT32 int_type); + void s3c24xx_check_pending_subirq(); + void s3c24xx_request_subirq( UINT32 int_type); + void s3c24xx_check_pending_eint(); + void s3c24xx_request_eint(UINT32 number); + READ32_MEMBER( s3c24xx_irq_r ); + WRITE32_MEMBER( s3c24xx_irq_w ); + void s3c24xx_pwm_reset(); + UINT16 s3c24xx_pwm_calc_observation(int ch); + READ32_MEMBER( s3c24xx_pwm_r ); + void s3c24xx_pwm_start(int timer); + void s3c24xx_pwm_stop(int timer); + void s3c24xx_pwm_recalc(int timer); + WRITE32_MEMBER( s3c24xx_pwm_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_pwm_timer_exp ); + void s3c24xx_dma_reset(); + void s3c24xx_dma_reload(int ch); + void s3c24xx_dma_trigger(int ch); + void s3c24xx_dma_request_iis(); + void s3c24xx_dma_request_pwm(); + void s3c24xx_dma_start(int ch); + void s3c24xx_dma_stop(int ch); + void s3c24xx_dma_recalc(int ch); + UINT32 s3c24xx_dma_r(UINT32 ch, UINT32 offset); + void s3c24xx_dma_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_dma_0_r ); + READ32_MEMBER( s3c24xx_dma_1_r ); + READ32_MEMBER( s3c24xx_dma_2_r ); + READ32_MEMBER( s3c24xx_dma_3_r ); + WRITE32_MEMBER( s3c24xx_dma_0_w ); + WRITE32_MEMBER( s3c24xx_dma_1_w ); + WRITE32_MEMBER( s3c24xx_dma_2_w ); + WRITE32_MEMBER( s3c24xx_dma_3_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_dma_timer_exp ); + void s3c24xx_gpio_reset(); + inline UINT32 iface_gpio_port_r(int port, UINT32 mask); + inline void iface_gpio_port_w(int port, UINT32 mask, UINT32 data); + UINT16 s3c24xx_gpio_get_mask( UINT32 con, int val); + READ32_MEMBER( s3c24xx_gpio_r ); + WRITE32_MEMBER( s3c24xx_gpio_w ); + void s3c24xx_memcon_reset(); + READ32_MEMBER( s3c24xx_memcon_r ); + WRITE32_MEMBER( s3c24xx_memcon_w ); + void s3c24xx_usb_host_reset(); + READ32_MEMBER( s3c24xx_usb_host_r ); + WRITE32_MEMBER( s3c24xx_usb_host_w ); + void s3c24xx_uart_reset(); + UINT32 s3c24xx_uart_r(UINT32 ch, UINT32 offset); + void s3c24xx_uart_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_uart_0_r ); + READ32_MEMBER( s3c24xx_uart_1_r ); + READ32_MEMBER( s3c24xx_uart_2_r ); + WRITE32_MEMBER( s3c24xx_uart_0_w ); + WRITE32_MEMBER( s3c24xx_uart_1_w ); + WRITE32_MEMBER( s3c24xx_uart_2_w ); + void s3c24xx_uart_fifo_w(int uart, UINT8 data); + void s3c24xx_usb_device_reset(); + READ32_MEMBER( s3c24xx_usb_device_r ); + WRITE32_MEMBER( s3c24xx_usb_device_w ); + void s3c24xx_wdt_reset(); + UINT16 s3c24xx_wdt_calc_current_count(); + READ32_MEMBER( s3c24xx_wdt_r ); + void s3c24xx_wdt_start(); + void s3c24xx_wdt_stop(); + void s3c24xx_wdt_recalc(); + WRITE32_MEMBER( s3c24xx_wdt_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_wdt_timer_exp ); + void s3c24xx_iic_reset(); + inline void iface_i2c_scl_w( int state); + inline void iface_i2c_sda_w(int state); + inline int iface_i2c_sda_r(); + void i2c_send_start(); + void i2c_send_stop(); + UINT8 i2c_receive_byte(int ack); + int i2c_send_byte(UINT8 data); + void iic_start(); + void iic_stop(); + void iic_resume(); + READ32_MEMBER( s3c24xx_iic_r ); + WRITE32_MEMBER( s3c24xx_iic_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_iic_timer_exp ); + void s3c24xx_iis_reset(); + inline void iface_i2s_data_w(int ch, UINT16 data); + void s3c24xx_iis_start(); + void s3c24xx_iis_stop(); + void s3c24xx_iis_recalc(); + READ32_MEMBER( s3c24xx_iis_r ); + WRITE32_MEMBER( s3c24xx_iis_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_iis_timer_exp ); + void s3c24xx_rtc_reset(); + READ32_MEMBER( s3c24xx_rtc_r ); + void s3c24xx_rtc_recalc(); + WRITE32_MEMBER( s3c24xx_rtc_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_rtc_timer_tick_count_exp ); + void s3c24xx_rtc_update(); + void s3c24xx_rtc_check_alarm(); + TIMER_CALLBACK_MEMBER( s3c24xx_rtc_timer_update_exp ); + void s3c24xx_adc_reset(); + UINT32 iface_adc_data_r(int ch); + READ32_MEMBER( s3c24xx_adc_r ); + void s3c24xx_adc_start(); + WRITE32_MEMBER( s3c24xx_adc_w ); + void s3c24xx_touch_screen(int state); + void s3c24xx_spi_reset(); + UINT32 s3c24xx_spi_r(UINT32 ch, UINT32 offset); + void s3c24xx_spi_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_spi_0_r ); + READ32_MEMBER( s3c24xx_spi_1_r ); + WRITE32_MEMBER( s3c24xx_spi_0_w ); + WRITE32_MEMBER( s3c24xx_spi_1_w ); + void s3c24xx_sdi_reset(); + READ32_MEMBER( s3c24xx_sdi_r ); + WRITE32_MEMBER( s3c24xx_sdi_w ); + void s3c24xx_nand_reset(); + inline void iface_nand_command_w(UINT8 data); + inline void iface_nand_address_w(UINT8 data); + inline UINT8 iface_nand_data_r(); + inline void iface_nand_data_w(UINT8 data); + void nand_update_mecc( UINT8 *ecc, int pos, UINT8 data); + void s3c24xx_nand_update_ecc(UINT8 data); + void s3c24xx_nand_command_w(UINT8 data); + void s3c24xx_nand_address_w(UINT8 data); + UINT8 s3c24xx_nand_data_r(); + void s3c24xx_nand_data_w(UINT8 data); + READ32_MEMBER( s3c24xx_nand_r ); + void s3c24xx_nand_init_ecc(); + WRITE32_MEMBER( s3c24xx_nand_w ); + ATTR_UNUSED WRITE_LINE_MEMBER( s3c24xx_pin_frnb_w ); + void s3c24xx_nand_auto_boot(); + void s3c24xx_device_reset(); + void s3c24xx_device_start(); + + void s3c2410_uart_fifo_w( int uart, UINT8 data); + void s3c2410_touch_screen( int state); + void s3c2410_request_eint( UINT32 number); + void s3c2410_nand_calculate_mecc( UINT8 *data, UINT32 size, UINT8 *mecc); + + /******************************************************************************* + TYPE DEFINITIONS + *******************************************************************************/ + + struct s3c24xx_memcon_regs_t + { + UINT32 data[0x34/4]; + }; + + struct s3c24xx_usbhost_regs_t + { + UINT32 data[0x5C/4]; + }; + + struct s3c24xx_irq_regs_t + { + UINT32 srcpnd; + UINT32 intmod; + UINT32 intmsk; + UINT32 priority; + UINT32 intpnd; + UINT32 intoffset; + UINT32 subsrcpnd; + UINT32 intsubmsk; + }; + + struct s3c24xx_dma_regs_t + { + UINT32 disrc; + UINT32 disrcc; + UINT32 didst; + UINT32 didstc; + UINT32 dcon; + UINT32 dstat; + UINT32 dcsrc; + UINT32 dcdst; + UINT32 dmasktrig; + }; + + struct s3c24xx_clkpow_regs_t + { + UINT32 locktime; + UINT32 mpllcon; + UINT32 upllcon; + UINT32 clkcon; + UINT32 clkslow; + UINT32 clkdivn; + }; + + struct s3c24xx_lcd_regs_t + { + UINT32 lcdcon1; + UINT32 lcdcon2; + UINT32 lcdcon3; + UINT32 lcdcon4; + UINT32 lcdcon5; + UINT32 lcdsaddr1; + UINT32 lcdsaddr2; + UINT32 lcdsaddr3; + UINT32 redlut; + UINT32 greenlut; + UINT32 bluelut; + UINT32 reserved[8]; + UINT32 dithmode; + UINT32 tpal; + UINT32 lcdintpnd; + UINT32 lcdsrcpnd; + UINT32 lcdintmsk; + UINT32 lpcsel; + }; + + struct s3c24xx_lcdpal_regs_t + { + UINT32 data[0x400/4]; + }; + + struct s3c24xx_nand_regs_t + { + UINT32 nfconf; + UINT32 nfcmd; + UINT32 nfaddr; + UINT32 nfdata; + UINT32 nfstat; + UINT32 nfecc; + }; + + struct s3c24xx_uart_regs_t + { + UINT32 ulcon; + UINT32 ucon; + UINT32 ufcon; + UINT32 umcon; + UINT32 utrstat; + UINT32 uerstat; + UINT32 ufstat; + UINT32 umstat; + UINT32 utxh; + UINT32 urxh; + UINT32 ubrdiv; + }; + + struct s3c24xx_pwm_regs_t + { + UINT32 tcfg0; + UINT32 tcfg1; + UINT32 tcon; + UINT32 tcntb0; + UINT32 tcmpb0; + UINT32 tcnto0; + UINT32 tcntb1; + UINT32 tcmpb1; + UINT32 tcnto1; + UINT32 tcntb2; + UINT32 tcmpb2; + UINT32 tcnto2; + UINT32 tcntb3; + UINT32 tcmpb3; + UINT32 tcnto3; + UINT32 tcntb4; + UINT32 tcnto4; + }; + + struct s3c24xx_usbdev_regs_t + { + UINT32 data[0x130/4]; + }; + + struct s3c24xx_wdt_regs_t + { + UINT32 wtcon; + UINT32 wtdat; + UINT32 wtcnt; + }; + + struct s3c24xx_iic_regs_t + { + UINT32 iiccon; + UINT32 iicstat; + UINT32 iicadd; + UINT32 iicds; + }; + + struct s3c24xx_iis_regs_t + { + UINT32 iiscon; + UINT32 iismod; + UINT32 iispsr; + UINT32 iisfcon; + UINT32 iisfifo; + }; + + struct s3c24xx_gpio_regs_t + { + UINT32 gpacon; + UINT32 gpadat; + UINT32 pad_08; + UINT32 pad_0c; + UINT32 gpbcon; + UINT32 gpbdat; + UINT32 gpbup; + UINT32 pad_1c; + UINT32 gpccon; + UINT32 gpcdat; + UINT32 gpcup; + UINT32 pad_2c; + UINT32 gpdcon; + UINT32 gpddat; + UINT32 gpdup; + UINT32 pad_3c; + UINT32 gpecon; + UINT32 gpedat; + UINT32 gpeup; + UINT32 pad_4c; + UINT32 gpfcon; + UINT32 gpfdat; + UINT32 gpfup; + UINT32 pad_5c; + UINT32 gpgcon; + UINT32 gpgdat; + UINT32 gpgup; + UINT32 pad_6c; + UINT32 gphcon; + UINT32 gphdat; + UINT32 gphup; + UINT32 pad_7c; + UINT32 misccr; + UINT32 dclkcon; + UINT32 extint0; + UINT32 extint1; + UINT32 extint2; + UINT32 eintflt0; + UINT32 eintflt1; + UINT32 eintflt2; + UINT32 eintflt3; + UINT32 eintmask; + UINT32 eintpend; + UINT32 gstatus0; + UINT32 gstatus1; + UINT32 gstatus2; + UINT32 gstatus3; + UINT32 gstatus4; + }; + + struct s3c24xx_rtc_regs_t + { + UINT32 rtccon; + UINT32 ticnt; + UINT32 reserved[2]; + UINT32 rtcalm; + UINT32 almsec; + UINT32 almmin; + UINT32 almhour; + UINT32 almday; + UINT32 almmon; + UINT32 almyear; + UINT32 rtcrst; + UINT32 bcdsec; + UINT32 bcdmin; + UINT32 bcdhour; + UINT32 bcdday; + UINT32 bcddow; + UINT32 bcdmon; + UINT32 bcdyear; + }; + + struct s3c24xx_adc_regs_t + { + UINT32 adccon; + UINT32 adctsc; + UINT32 adcdly; + UINT32 adcdat0; + UINT32 adcdat1; + }; + + struct s3c24xx_spi_regs_t + { + UINT32 spcon; + UINT32 spsta; + UINT32 sppin; + UINT32 sppre; + UINT32 sptdat; + UINT32 sprdat; + }; + + struct s3c24xx_sdi_regs_t + { + UINT32 data[0x44/4]; + }; + + struct s3c24xx_memcon_t + { + s3c24xx_memcon_regs_t regs; + }; + + struct s3c24xx_usbhost_t + { + s3c24xx_usbhost_regs_t regs; + }; + + struct s3c24xx_irq_t + { + s3c24xx_irq_regs_t regs; + int line_irq, line_fiq; + }; + + struct s3c24xx_dma_t + { + s3c24xx_dma_regs_t regs; + emu_timer *timer; + }; + + struct s3c24xx_clkpow_t + { + s3c24xx_clkpow_regs_t regs; + }; + + struct s3c24xx_lcd_t + { + s3c24xx_lcd_regs_t regs; + emu_timer *timer; + bitmap_rgb32 *bitmap[2]; + UINT32 vramaddr_cur; + UINT32 vramaddr_max; + UINT32 offsize; + UINT32 pagewidth_cur; + UINT32 pagewidth_max; + UINT32 bppmode; + UINT32 bswp, hwswp; + int vpos, hpos; + double framerate; + UINT32 tpal; + UINT32 hpos_min, hpos_max, vpos_min, vpos_max; + UINT32 dma_data, dma_bits; + }; + + struct s3c24xx_lcdpal_t + { + s3c24xx_lcdpal_regs_t regs; + }; + + struct s3c24xx_nand_t + { + s3c24xx_nand_regs_t regs; + UINT8 mecc[3]; + int ecc_pos, data_count; + }; + + struct s3c24xx_uart_t + { + s3c24xx_uart_regs_t regs; + }; + + struct s3c24xx_pwm_t + { + s3c24xx_pwm_regs_t regs; + emu_timer *timer[5]; + UINT32 cnt[5]; + UINT32 cmp[5]; + UINT32 freq[5]; + }; + + struct s3c24xx_usbdev_t + { + s3c24xx_usbdev_regs_t regs; + }; + + struct s3c24xx_wdt_t + { + s3c24xx_wdt_regs_t regs; + emu_timer *timer; + UINT32 freq, cnt; + }; + + struct s3c24xx_iic_t + { + s3c24xx_iic_regs_t regs; + emu_timer *timer; + int count; + }; + + struct s3c24xx_iis_t + { + s3c24xx_iis_regs_t regs; + emu_timer *timer; + UINT16 fifo[16/2]; + int fifo_index; + }; + + struct s3c24xx_gpio_t + { + s3c24xx_gpio_regs_t regs; + }; + + struct s3c24xx_rtc_t + { + s3c24xx_rtc_regs_t regs; + emu_timer *timer_tick_count; + emu_timer *timer_update; + }; + + struct s3c24xx_adc_t + { + s3c24xx_adc_regs_t regs; + }; + + struct s3c24xx_spi_t + { + s3c24xx_spi_regs_t regs; + }; + + struct s3c24xx_sdi_t + { + s3c24xx_sdi_regs_t regs; + }; + + UINT8 m_steppingstone[4*1024]; + s3c24xx_memcon_t m_memcon; + s3c24xx_usbhost_t m_usbhost; + s3c24xx_irq_t m_irq; + s3c24xx_dma_t m_dma[S3C24XX_DMA_COUNT]; + s3c24xx_clkpow_t m_clkpow; + s3c24xx_lcd_t m_lcd; + s3c24xx_lcdpal_t m_lcdpal; + s3c24xx_nand_t m_nand; + s3c24xx_uart_t m_uart[S3C24XX_UART_COUNT]; + s3c24xx_pwm_t m_pwm; + s3c24xx_usbdev_t m_usbdev; + s3c24xx_wdt_t m_wdt; + s3c24xx_iic_t m_iic; + s3c24xx_iis_t m_iis; + s3c24xx_gpio_t m_gpio; + s3c24xx_rtc_t m_rtc; + s3c24xx_adc_t m_adc; + s3c24xx_spi_t m_spi[S3C24XX_SPI_COUNT]; + s3c24xx_sdi_t m_sdi; + required_device m_cpu; + devcb_resolved_read32 m_pin_r; + devcb_resolved_write32 m_pin_w; + devcb_resolved_read32 m_port_r; + devcb_resolved_write32 m_port_w; + devcb_resolved_write_line m_scl_w; + devcb_resolved_read_line m_sda_r; + devcb_resolved_write_line m_sda_w; + devcb_resolved_read32 m_adc_data_r; + devcb_resolved_write16 m_i2s_data_w; + devcb_resolved_write8 m_command_w; + devcb_resolved_write8 m_address_w; + devcb_resolved_read8 m_nand_data_r; + devcb_resolved_write8 m_nand_data_w; }; -struct s3c24xx_usbhost_regs_t -{ - UINT32 data[0x5C/4]; -}; +extern const device_type S3C2410; -struct s3c24xx_irq_regs_t -{ - UINT32 srcpnd; - UINT32 intmod; - UINT32 intmsk; - UINT32 priority; - UINT32 intpnd; - UINT32 intoffset; - UINT32 subsrcpnd; - UINT32 intsubmsk; -}; - -struct s3c24xx_dma_regs_t -{ - UINT32 disrc; - UINT32 disrcc; - UINT32 didst; - UINT32 didstc; - UINT32 dcon; - UINT32 dstat; - UINT32 dcsrc; - UINT32 dcdst; - UINT32 dmasktrig; -}; - -struct s3c24xx_clkpow_regs_t -{ - UINT32 locktime; - UINT32 mpllcon; - UINT32 upllcon; - UINT32 clkcon; - UINT32 clkslow; - UINT32 clkdivn; -}; - -struct s3c24xx_lcd_regs_t -{ - UINT32 lcdcon1; - UINT32 lcdcon2; - UINT32 lcdcon3; - UINT32 lcdcon4; - UINT32 lcdcon5; - UINT32 lcdsaddr1; - UINT32 lcdsaddr2; - UINT32 lcdsaddr3; - UINT32 redlut; - UINT32 greenlut; - UINT32 bluelut; - UINT32 reserved[8]; - UINT32 dithmode; - UINT32 tpal; - UINT32 lcdintpnd; - UINT32 lcdsrcpnd; - UINT32 lcdintmsk; - UINT32 lpcsel; -}; - -struct s3c24xx_lcdpal_regs_t -{ - UINT32 data[0x400/4]; -}; - -struct s3c24xx_nand_regs_t -{ - UINT32 nfconf; - UINT32 nfcmd; - UINT32 nfaddr; - UINT32 nfdata; - UINT32 nfstat; - UINT32 nfecc; -}; - -struct s3c24xx_uart_regs_t -{ - UINT32 ulcon; - UINT32 ucon; - UINT32 ufcon; - UINT32 umcon; - UINT32 utrstat; - UINT32 uerstat; - UINT32 ufstat; - UINT32 umstat; - UINT32 utxh; - UINT32 urxh; - UINT32 ubrdiv; -}; - -struct s3c24xx_pwm_regs_t -{ - UINT32 tcfg0; - UINT32 tcfg1; - UINT32 tcon; - UINT32 tcntb0; - UINT32 tcmpb0; - UINT32 tcnto0; - UINT32 tcntb1; - UINT32 tcmpb1; - UINT32 tcnto1; - UINT32 tcntb2; - UINT32 tcmpb2; - UINT32 tcnto2; - UINT32 tcntb3; - UINT32 tcmpb3; - UINT32 tcnto3; - UINT32 tcntb4; - UINT32 tcnto4; -}; - -struct s3c24xx_usbdev_regs_t -{ - UINT32 data[0x130/4]; -}; - -struct s3c24xx_wdt_regs_t -{ - UINT32 wtcon; - UINT32 wtdat; - UINT32 wtcnt; -}; - -struct s3c24xx_iic_regs_t -{ - UINT32 iiccon; - UINT32 iicstat; - UINT32 iicadd; - UINT32 iicds; -}; - -struct s3c24xx_iis_regs_t -{ - UINT32 iiscon; - UINT32 iismod; - UINT32 iispsr; - UINT32 iisfcon; - UINT32 iisfifo; -}; - -struct s3c24xx_gpio_regs_t -{ - UINT32 gpacon; - UINT32 gpadat; - UINT32 pad_08; - UINT32 pad_0c; - UINT32 gpbcon; - UINT32 gpbdat; - UINT32 gpbup; - UINT32 pad_1c; - UINT32 gpccon; - UINT32 gpcdat; - UINT32 gpcup; - UINT32 pad_2c; - UINT32 gpdcon; - UINT32 gpddat; - UINT32 gpdup; - UINT32 pad_3c; - UINT32 gpecon; - UINT32 gpedat; - UINT32 gpeup; - UINT32 pad_4c; - UINT32 gpfcon; - UINT32 gpfdat; - UINT32 gpfup; - UINT32 pad_5c; - UINT32 gpgcon; - UINT32 gpgdat; - UINT32 gpgup; - UINT32 pad_6c; - UINT32 gphcon; - UINT32 gphdat; - UINT32 gphup; - UINT32 pad_7c; - UINT32 misccr; - UINT32 dclkcon; - UINT32 extint0; - UINT32 extint1; - UINT32 extint2; - UINT32 eintflt0; - UINT32 eintflt1; - UINT32 eintflt2; - UINT32 eintflt3; - UINT32 eintmask; - UINT32 eintpend; - UINT32 gstatus0; - UINT32 gstatus1; - UINT32 gstatus2; - UINT32 gstatus3; - UINT32 gstatus4; -}; - -struct s3c24xx_rtc_regs_t -{ - UINT32 rtccon; - UINT32 ticnt; - UINT32 reserved[2]; - UINT32 rtcalm; - UINT32 almsec; - UINT32 almmin; - UINT32 almhour; - UINT32 almday; - UINT32 almmon; - UINT32 almyear; - UINT32 rtcrst; - UINT32 bcdsec; - UINT32 bcdmin; - UINT32 bcdhour; - UINT32 bcdday; - UINT32 bcddow; - UINT32 bcdmon; - UINT32 bcdyear; -}; - -struct s3c24xx_adc_regs_t -{ - UINT32 adccon; - UINT32 adctsc; - UINT32 adcdly; - UINT32 adcdat0; - UINT32 adcdat1; -}; - -struct s3c24xx_spi_regs_t -{ - UINT32 spcon; - UINT32 spsta; - UINT32 sppin; - UINT32 sppre; - UINT32 sptdat; - UINT32 sprdat; -}; - -struct s3c24xx_sdi_regs_t -{ - UINT32 data[0x44/4]; -}; - -struct s3c24xx_memcon_t -{ - s3c24xx_memcon_regs_t regs; -}; - -struct s3c24xx_usbhost_t -{ - s3c24xx_usbhost_regs_t regs; -}; - -struct s3c24xx_irq_t -{ - s3c24xx_irq_regs_t regs; - int line_irq, line_fiq; -}; - -struct s3c24xx_dma_t -{ - s3c24xx_dma_regs_t regs; - emu_timer *timer; -}; - -struct s3c24xx_clkpow_t -{ - s3c24xx_clkpow_regs_t regs; -}; - -struct s3c24xx_lcd_t -{ - s3c24xx_lcd_regs_t regs; - emu_timer *timer; - bitmap_rgb32 *bitmap[2]; - UINT32 vramaddr_cur; - UINT32 vramaddr_max; - UINT32 offsize; - UINT32 pagewidth_cur; - UINT32 pagewidth_max; - UINT32 bppmode; - UINT32 bswp, hwswp; - int vpos, hpos; - double framerate; - UINT32 tpal; - UINT32 hpos_min, hpos_max, vpos_min, vpos_max; - UINT32 dma_data, dma_bits; -}; - -struct s3c24xx_lcdpal_t -{ - s3c24xx_lcdpal_regs_t regs; -}; - -struct s3c24xx_nand_t -{ - s3c24xx_nand_regs_t regs; - UINT8 mecc[3]; - int ecc_pos, data_count; -}; - -struct s3c24xx_uart_t -{ - s3c24xx_uart_regs_t regs; -}; - -struct s3c24xx_pwm_t -{ - s3c24xx_pwm_regs_t regs; - emu_timer *timer[5]; - UINT32 cnt[5]; - UINT32 cmp[5]; - UINT32 freq[5]; -}; - -struct s3c24xx_usbdev_t -{ - s3c24xx_usbdev_regs_t regs; -}; - -struct s3c24xx_wdt_t -{ - s3c24xx_wdt_regs_t regs; - emu_timer *timer; - UINT32 freq, cnt; -}; - -struct s3c24xx_iic_t -{ - s3c24xx_iic_regs_t regs; - emu_timer *timer; - int count; -}; - -struct s3c24xx_iis_t -{ - s3c24xx_iis_regs_t regs; - emu_timer *timer; - UINT16 fifo[16/2]; - int fifo_index; -}; - -struct s3c24xx_gpio_t -{ - s3c24xx_gpio_regs_t regs; -}; - -struct s3c24xx_rtc_t -{ - s3c24xx_rtc_regs_t regs; - emu_timer *timer_tick_count; - emu_timer *timer_update; -}; - -struct s3c24xx_adc_t -{ - s3c24xx_adc_regs_t regs; -}; - -struct s3c24xx_spi_t -{ - s3c24xx_spi_regs_t regs; -}; - -struct s3c24xx_sdi_t -{ - s3c24xx_sdi_regs_t regs; -}; - -struct s3c24xx_t -{ - const s3c2410_interface *iface; - UINT8 steppingstone[4*1024]; - s3c24xx_memcon_t memcon; - s3c24xx_usbhost_t usbhost; - s3c24xx_irq_t irq; - s3c24xx_dma_t dma[S3C24XX_DMA_COUNT]; - s3c24xx_clkpow_t clkpow; - s3c24xx_lcd_t lcd; - s3c24xx_lcdpal_t lcdpal; - s3c24xx_nand_t nand; - s3c24xx_uart_t uart[S3C24XX_UART_COUNT]; - s3c24xx_pwm_t pwm; - s3c24xx_usbdev_t usbdev; - s3c24xx_wdt_t wdt; - s3c24xx_iic_t iic; - s3c24xx_iis_t iis; - s3c24xx_gpio_t gpio; - s3c24xx_rtc_t rtc; - s3c24xx_adc_t adc; - s3c24xx_spi_t spi[S3C24XX_SPI_COUNT]; - s3c24xx_sdi_t sdi; - device_t *m_cpu; - devcb_resolved_read32 pin_r; - devcb_resolved_write32 pin_w; - devcb_resolved_read32 port_r; - devcb_resolved_write32 port_w; - devcb_resolved_write_line scl_w; - devcb_resolved_read_line sda_r; - devcb_resolved_write_line sda_w; - devcb_resolved_read32 adc_data_r; - devcb_resolved_write16 i2s_data_w; - devcb_resolved_write8 command_w; - devcb_resolved_write8 address_w; - devcb_resolved_read8 nand_data_r; - devcb_resolved_write8 nand_data_w; - palette_device *m_palette; -}; #endif diff --git a/src/emu/machine/s3c2440.c b/src/emu/machine/s3c2440.c index 885d22e7d49..d9482a4fab8 100644 --- a/src/emu/machine/s3c2440.c +++ b/src/emu/machine/s3c2440.c @@ -11,7 +11,6 @@ #include "cpu/arm7/arm7core.h" #include "machine/s3c2440.h" #include "sound/dac.h" -#include "devlegcy.h" #define VERBOSE_LEVEL ( 0 ) @@ -29,61 +28,48 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, } #define DEVICE_S3C2440 +#define S3C24_CLASS_NAME s3c2440_device #include "machine/s3c24xx.inc" #undef DEVICE_S3C2440 UINT32 s3c2440_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { - return s3c24xx_video_update( this, screen, bitmap, cliprect); -} - -DEVICE_START( s3c2440 ) -{ - address_space &space = device->machine().device( "maincpu")->memory().space( AS_PROGRAM); - space.install_legacy_readwrite_handler( *device, 0x48000000, 0x4800003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w)); - space.install_legacy_readwrite_handler( *device, 0x49000000, 0x4900005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w)); - space.install_legacy_readwrite_handler( *device, 0x4a000000, 0x4a00001f, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w)); - space.install_legacy_readwrite_handler( *device, 0x4b000000, 0x4b000023, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w)); - space.install_legacy_readwrite_handler( *device, 0x4b000040, 0x4b000063, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w)); - space.install_legacy_readwrite_handler( *device, 0x4b000080, 0x4b0000a3, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w)); - space.install_legacy_readwrite_handler( *device, 0x4b0000c0, 0x4b0000e3, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w)); - space.install_legacy_readwrite_handler( *device, 0x4c000000, 0x4c00001b, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w)); - space.install_legacy_readwrite_handler( *device, 0x4d000000, 0x4d000063, FUNC(s3c2440_lcd_r), FUNC(s3c24xx_lcd_w)); - space.install_legacy_readwrite_handler( *device, 0x4d000400, 0x4d0007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w)); - space.install_legacy_readwrite_handler( *device, 0x4e000000, 0x4e00003f, FUNC(s3c24xx_nand_r), FUNC(s3c24xx_nand_w)); - space.install_legacy_readwrite_handler( *device, 0x4f000000, 0x4f0000a3, FUNC(s3c24xx_cam_r), FUNC(s3c24xx_cam_w)); - space.install_legacy_readwrite_handler( *device, 0x50000000, 0x5000002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w)); - space.install_legacy_readwrite_handler( *device, 0x50004000, 0x5000402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w)); - space.install_legacy_readwrite_handler( *device, 0x50008000, 0x5000802b, FUNC(s3c24xx_uart_2_r), FUNC(s3c24xx_uart_2_w)); - space.install_legacy_readwrite_handler( *device, 0x51000000, 0x51000043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w)); - space.install_legacy_readwrite_handler( *device, 0x52000140, 0x5200026f, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w)); - space.install_legacy_readwrite_handler( *device, 0x53000000, 0x5300000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w)); - space.install_legacy_readwrite_handler( *device, 0x54000000, 0x54000013, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w)); - space.install_legacy_readwrite_handler( *device, 0x55000000, 0x55000013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w)); - space.install_legacy_readwrite_handler( *device, 0x56000000, 0x560000df, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w)); - space.install_legacy_readwrite_handler( *device, 0x57000040, 0x5700008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w)); - space.install_legacy_readwrite_handler( *device, 0x58000000, 0x58000017, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w)); - space.install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w)); - space.install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w)); - space.install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w)); - space.install_legacy_readwrite_handler( *device, 0x5b000000, 0x5b00001f, FUNC(s3c24xx_ac97_r), FUNC(s3c24xx_ac97_w)); - DEVICE_START_CALL(s3c24xx); - - s3c24xx_video_start( device, device->machine()); + return s3c24xx_video_update( screen, bitmap, cliprect); } const device_type S3C2440 = &device_creator; s3c2440_device::s3c2440_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : device_t(mconfig, S3C2440, "Samsung S3C2440", tag, owner, clock, "s3c2440", __FILE__), - m_palette(*this) + m_palette(*this), + m_cpu(*this, ":maincpu") { - m_token = global_alloc_clear(s3c24xx_t); + memset(m_steppingstone, 0, sizeof(m_steppingstone)); + memset(&m_memcon, 0, sizeof(m_memcon)); + memset(&m_usbhost, 0, sizeof(m_usbhost)); + memset(&m_irq, 0, sizeof(m_irq)); + memset(m_dma, 0, sizeof(m_dma)); + memset(&m_clkpow, 0, sizeof(m_clkpow)); + memset(&m_lcd, 0, sizeof(m_lcd)); + memset(&m_lcdpal, 0, sizeof(m_lcdpal)); + memset(&m_nand, 0, sizeof(m_nand)); + memset(&m_cam, 0, sizeof(m_cam)); + memset(m_uart, 0, sizeof(m_uart)); + memset(&m_pwm, 0, sizeof(m_pwm)); + memset(&m_usbdev, 0, sizeof(m_usbdev)); + memset(&m_wdt, 0, sizeof(m_wdt)); + memset(&m_iic, 0, sizeof(m_iic)); + memset(&m_iis, 0, sizeof(m_iis)); + memset(&m_gpio, 0, sizeof(m_gpio)); + memset(&m_rtc, 0, sizeof(m_rtc)); + memset(&m_adc, 0, sizeof(m_adc)); + memset(m_spi, 0, sizeof(m_spi)); + memset(&m_sdi, 0, sizeof(m_sdi)); + memset(&m_ac97, 0, sizeof(m_ac97)); } s3c2440_device::~s3c2440_device() { - global_free(m_token); } //------------------------------------------------- @@ -105,6 +91,10 @@ void s3c2440_device::static_set_palette_tag(device_t &device, const char *tag) void s3c2440_device::device_config_complete() { + // inherit a copy of the static data + const s3c2440_interface *intf = reinterpret_cast(static_config()); + if (intf != NULL) + *static_cast(this) = *intf; } //------------------------------------------------- @@ -113,9 +103,38 @@ void s3c2440_device::device_config_complete() void s3c2440_device::device_start() { - s3c24xx_t *s3c24xx = get_token(this); - s3c24xx->m_palette = m_palette; - DEVICE_START_NAME( s3c2440 )(this); + address_space &space = m_cpu->memory().space( AS_PROGRAM); + space.install_readwrite_handler(0x48000000, 0x4800003b, read32_delegate(FUNC(s3c2440_device::s3c24xx_memcon_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_memcon_w), this)); + space.install_readwrite_handler(0x49000000, 0x4900005b, read32_delegate(FUNC(s3c2440_device::s3c24xx_usb_host_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_usb_host_w), this)); + space.install_readwrite_handler(0x4a000000, 0x4a00001f, read32_delegate(FUNC(s3c2440_device::s3c24xx_irq_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_irq_w), this)); + space.install_readwrite_handler(0x4b000000, 0x4b000023, read32_delegate(FUNC(s3c2440_device::s3c24xx_dma_0_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_dma_0_w), this)); + space.install_readwrite_handler(0x4b000040, 0x4b000063, read32_delegate(FUNC(s3c2440_device::s3c24xx_dma_1_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_dma_1_w), this)); + space.install_readwrite_handler(0x4b000080, 0x4b0000a3, read32_delegate(FUNC(s3c2440_device::s3c24xx_dma_2_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_dma_2_w), this)); + space.install_readwrite_handler(0x4b0000c0, 0x4b0000e3, read32_delegate(FUNC(s3c2440_device::s3c24xx_dma_3_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_dma_3_w), this)); + space.install_readwrite_handler(0x4c000000, 0x4c00001b, read32_delegate(FUNC(s3c2440_device::s3c24xx_clkpow_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_clkpow_w), this)); + space.install_readwrite_handler(0x4d000000, 0x4d000063, read32_delegate(FUNC(s3c2440_device::s3c24xx_lcd_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_lcd_w), this)); + space.install_readwrite_handler(0x4d000400, 0x4d0007ff, read32_delegate(FUNC(s3c2440_device::s3c24xx_lcd_palette_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_lcd_palette_w), this)); + space.install_readwrite_handler(0x4e000000, 0x4e00003f, read32_delegate(FUNC(s3c2440_device::s3c24xx_nand_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_nand_w), this)); + space.install_readwrite_handler(0x4f000000, 0x4f0000a3, read32_delegate(FUNC(s3c2440_device::s3c24xx_cam_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_cam_w), this)); + space.install_readwrite_handler(0x50000000, 0x5000002b, read32_delegate(FUNC(s3c2440_device::s3c24xx_uart_0_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_uart_0_w), this)); + space.install_readwrite_handler(0x50004000, 0x5000402b, read32_delegate(FUNC(s3c2440_device::s3c24xx_uart_1_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_uart_1_w), this)); + space.install_readwrite_handler(0x50008000, 0x5000802b, read32_delegate(FUNC(s3c2440_device::s3c24xx_uart_2_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_uart_2_w), this)); + space.install_readwrite_handler(0x51000000, 0x51000043, read32_delegate(FUNC(s3c2440_device::s3c24xx_pwm_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_pwm_w), this)); + space.install_readwrite_handler(0x52000140, 0x5200026f, read32_delegate(FUNC(s3c2440_device::s3c24xx_usb_device_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_usb_device_w), this)); + space.install_readwrite_handler(0x53000000, 0x5300000b, read32_delegate(FUNC(s3c2440_device::s3c24xx_wdt_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_wdt_w), this)); + space.install_readwrite_handler(0x54000000, 0x54000013, read32_delegate(FUNC(s3c2440_device::s3c24xx_iic_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_iic_w), this)); + space.install_readwrite_handler(0x55000000, 0x55000013, read32_delegate(FUNC(s3c2440_device::s3c24xx_iis_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_iis_w), this)); + space.install_readwrite_handler(0x56000000, 0x560000df, read32_delegate(FUNC(s3c2440_device::s3c24xx_gpio_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_gpio_w), this)); + space.install_readwrite_handler(0x57000040, 0x5700008b, read32_delegate(FUNC(s3c2440_device::s3c24xx_rtc_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_rtc_w), this)); + space.install_readwrite_handler(0x58000000, 0x58000017, read32_delegate(FUNC(s3c2440_device::s3c24xx_adc_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_adc_w), this)); + space.install_readwrite_handler(0x59000000, 0x59000017, read32_delegate(FUNC(s3c2440_device::s3c24xx_spi_0_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_spi_0_w), this)); + space.install_readwrite_handler(0x59000020, 0x59000037, read32_delegate(FUNC(s3c2440_device::s3c24xx_spi_1_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_spi_1_w), this)); + space.install_readwrite_handler(0x5a000000, 0x5a000043, read32_delegate(FUNC(s3c2440_device::s3c24xx_sdi_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_sdi_w), this)); + space.install_readwrite_handler(0x5b000000, 0x5b00001f, read32_delegate(FUNC(s3c2440_device::s3c24xx_ac97_r), this), write32_delegate(FUNC(s3c2440_device::s3c24xx_ac97_w), this)); + + s3c24xx_device_start(); + + s3c24xx_video_start(); } //------------------------------------------------- @@ -124,31 +143,31 @@ void s3c2440_device::device_start() void s3c2440_device::device_reset() { - DEVICE_RESET_NAME( s3c24xx )(this); + s3c24xx_device_reset(); } -void s3c2440_uart_fifo_w( device_t *device, int uart, UINT8 data) +void s3c2440_device::s3c2440_uart_fifo_w(int uart, UINT8 data) { - s3c24xx_uart_fifo_w( device, uart, data); + s3c24xx_uart_fifo_w( uart, data); } -void s3c2440_touch_screen( device_t *device, int state) +void s3c2440_device::s3c2440_touch_screen(int state) { - s3c24xx_touch_screen( device, state); + s3c24xx_touch_screen( state); } -void s3c2440_request_irq( device_t *device, UINT32 int_type) +void s3c2440_device::s3c2440_request_irq(UINT32 int_type) { - s3c24xx_request_irq( device, int_type); + s3c24xx_request_irq( int_type); } -void s3c2440_request_eint( device_t *device, UINT32 number) +void s3c2440_device::s3c2440_request_eint(UINT32 number) { - s3c24xx_request_eint( device, number); + s3c24xx_request_eint( number); } WRITE_LINE_MEMBER( s3c2440_device::frnb_w ) { - s3c24xx_pin_frnb_w(this, state); + s3c24xx_pin_frnb_w(state); } diff --git a/src/emu/machine/s3c2440.h b/src/emu/machine/s3c2440.h index 1d195832e74..b3e74134ee3 100644 --- a/src/emu/machine/s3c2440.h +++ b/src/emu/machine/s3c2440.h @@ -41,35 +41,6 @@ enum S3C2440_CORE_PIN_OM1 }; -class s3c2440_device : public device_t -{ -public: - s3c2440_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); - ~s3c2440_device(); - - // static configuration - static void static_set_palette_tag(device_t &device, const char *tag); - - // access to legacy token - struct s3c24xx_t *token() const { assert(m_token != NULL); return m_token; } - - DECLARE_WRITE_LINE_MEMBER( frnb_w ); - -protected: - // device-level overrides - virtual void device_config_complete(); - virtual void device_start(); - virtual void device_reset(); -private: - // internal state - struct s3c24xx_t *m_token; - required_device m_palette; -public: - UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); -}; - -extern const device_type S3C2440; - /******************************************************************************* TYPE DEFINITIONS @@ -119,24 +90,15 @@ struct s3c2440_interface_lcd struct s3c2440_interface { - s3c2440_interface_core core; - s3c2440_interface_gpio gpio; - s3c2440_interface_i2c i2c; - s3c2440_interface_adc adc; - s3c2440_interface_i2s i2s; - s3c2440_interface_nand nand; - s3c2440_interface_lcd lcd; + s3c2440_interface_core m_iface_core; + s3c2440_interface_gpio m_iface_gpio; + s3c2440_interface_i2c m_iface_i2c; + s3c2440_interface_adc m_iface_adc; + s3c2440_interface_i2s m_iface_i2s; + s3c2440_interface_nand m_iface_nand; + s3c2440_interface_lcd m_iface_lcd; }; -/******************************************************************************* - PROTOTYPES -*******************************************************************************/ - -void s3c2440_uart_fifo_w( device_t *device, int uart, UINT8 data); -void s3c2440_touch_screen( device_t *device, int state); -void s3c2440_request_irq( device_t *device, UINT32 int_type); -void s3c2440_request_eint( device_t *device, UINT32 number); - /******************************************************************************* MACROS & CONSTANTS @@ -524,461 +486,680 @@ static const UINT32 MAP_SUBINT_TO_INT[15] = #define S3C24XX_DMA_COUNT 4 #define S3C24XX_SPI_COUNT 2 -/******************************************************************************* - TYPE DEFINITIONS -*******************************************************************************/ - -struct s3c24xx_memcon_regs_t +class s3c2440_device : public device_t, + public s3c2440_interface { - UINT32 data[0x34/4]; +public: + s3c2440_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + ~s3c2440_device(); + + // static configuration + static void static_set_palette_tag(device_t &device, const char *tag); + + DECLARE_WRITE_LINE_MEMBER( frnb_w ); + +protected: + // device-level overrides + virtual void device_config_complete(); + virtual void device_start(); + virtual void device_reset(); +private: + // internal state + required_device m_palette; +public: + UINT32 screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); + + void s3c24xx_reset(); + inline int iface_core_pin_r(int pin); + void s3c24xx_lcd_reset(); + rgb_t s3c24xx_get_color_tft_16(UINT16 data); + rgb_t s3c24xx_get_color_tft_24(UINT32 data); + rgb_t s3c24xx_get_color_stn_12(UINT16 data); + rgb_t s3c24xx_get_color_stn_08( UINT8 data); + rgb_t s3c24xx_get_color_stn_01(UINT8 data); + rgb_t s3c24xx_get_color_stn_02(UINT8 data); + rgb_t s3c24xx_get_color_stn_04(UINT8 data); + rgb_t s3c24xx_get_color_tpal(); + void s3c24xx_lcd_dma_reload(); + void s3c24xx_lcd_dma_init(); + UINT32 s3c24xx_lcd_dma_read(); + UINT32 s3c24xx_lcd_dma_read_bits(int count); + void s3c24xx_lcd_render_tpal(); + void s3c24xx_lcd_render_stn_01(); + void s3c24xx_lcd_render_stn_02(); + void s3c24xx_lcd_render_stn_04(); + void s3c24xx_lcd_render_stn_08(); + void s3c24xx_lcd_render_stn_12_p(); + void s3c24xx_lcd_render_stn_12_u(); // not tested + void s3c24xx_lcd_render_tft_01(); + void s3c24xx_lcd_render_tft_02(); + void s3c24xx_lcd_render_tft_04(); + void s3c24xx_lcd_render_tft_08(); + void s3c24xx_lcd_render_tft_16(); + TIMER_CALLBACK_MEMBER( s3c24xx_lcd_timer_exp ); + void s3c24xx_video_start(); + void bitmap_blend( bitmap_rgb32 &bitmap_dst, bitmap_rgb32 &bitmap_src_1, bitmap_rgb32 &bitmap_src_2); + UINT32 s3c24xx_video_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); + READ32_MEMBER( s3c24xx_lcd_r ); + int s3c24xx_lcd_configure_tft(); + int s3c24xx_lcd_configure_stn(); + int s3c24xx_lcd_configure(); + void s3c24xx_lcd_start(); + void s3c24xx_lcd_stop(); + void s3c24xx_lcd_recalc(); + WRITE32_MEMBER( s3c24xx_lcd_w ); + READ32_MEMBER( s3c24xx_lcd_palette_r ); + WRITE32_MEMBER( s3c24xx_lcd_palette_w ); + void s3c24xx_clkpow_reset(); + UINT32 s3c24xx_get_fclk(); + UINT32 s3c24xx_get_hclk(); + UINT32 s3c24xx_get_pclk(); + READ32_MEMBER( s3c24xx_clkpow_r ); + WRITE32_MEMBER( s3c24xx_clkpow_w ); + void s3c24xx_irq_reset(); + void s3c24xx_check_pending_irq(); + void s3c24xx_request_irq(UINT32 int_type); + void s3c24xx_check_pending_subirq(); + void s3c24xx_request_subirq( UINT32 int_type); + void s3c24xx_check_pending_eint(); + void s3c24xx_request_eint(UINT32 number); + READ32_MEMBER( s3c24xx_irq_r ); + WRITE32_MEMBER( s3c24xx_irq_w ); + void s3c24xx_pwm_reset(); + UINT16 s3c24xx_pwm_calc_observation(int ch); + READ32_MEMBER( s3c24xx_pwm_r ); + void s3c24xx_pwm_start(int timer); + void s3c24xx_pwm_stop(int timer); + void s3c24xx_pwm_recalc(int timer); + WRITE32_MEMBER( s3c24xx_pwm_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_pwm_timer_exp ); + void s3c24xx_dma_reset(); + void s3c24xx_dma_reload(int ch); + void s3c24xx_dma_trigger(int ch); + void s3c24xx_dma_request_iis(); + void s3c24xx_dma_request_pwm(); + void s3c24xx_dma_start(int ch); + void s3c24xx_dma_stop(int ch); + void s3c24xx_dma_recalc(int ch); + UINT32 s3c24xx_dma_r(UINT32 ch, UINT32 offset); + void s3c24xx_dma_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_dma_0_r ); + READ32_MEMBER( s3c24xx_dma_1_r ); + READ32_MEMBER( s3c24xx_dma_2_r ); + READ32_MEMBER( s3c24xx_dma_3_r ); + WRITE32_MEMBER( s3c24xx_dma_0_w ); + WRITE32_MEMBER( s3c24xx_dma_1_w ); + WRITE32_MEMBER( s3c24xx_dma_2_w ); + WRITE32_MEMBER( s3c24xx_dma_3_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_dma_timer_exp ); + void s3c24xx_gpio_reset(); + inline UINT32 iface_gpio_port_r(int port, UINT32 mask); + inline void iface_gpio_port_w(int port, UINT32 mask, UINT32 data); + UINT16 s3c24xx_gpio_get_mask( UINT32 con, int val); + READ32_MEMBER( s3c24xx_gpio_r ); + WRITE32_MEMBER( s3c24xx_gpio_w ); + void s3c24xx_memcon_reset(); + READ32_MEMBER( s3c24xx_memcon_r ); + WRITE32_MEMBER( s3c24xx_memcon_w ); + void s3c24xx_usb_host_reset(); + READ32_MEMBER( s3c24xx_usb_host_r ); + WRITE32_MEMBER( s3c24xx_usb_host_w ); + void s3c24xx_uart_reset(); + UINT32 s3c24xx_uart_r(UINT32 ch, UINT32 offset); + void s3c24xx_uart_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_uart_0_r ); + READ32_MEMBER( s3c24xx_uart_1_r ); + READ32_MEMBER( s3c24xx_uart_2_r ); + WRITE32_MEMBER( s3c24xx_uart_0_w ); + WRITE32_MEMBER( s3c24xx_uart_1_w ); + WRITE32_MEMBER( s3c24xx_uart_2_w ); + void s3c24xx_uart_fifo_w(int uart, UINT8 data); + void s3c24xx_usb_device_reset(); + READ32_MEMBER( s3c24xx_usb_device_r ); + WRITE32_MEMBER( s3c24xx_usb_device_w ); + void s3c24xx_wdt_reset(); + UINT16 s3c24xx_wdt_calc_current_count(); + READ32_MEMBER( s3c24xx_wdt_r ); + void s3c24xx_wdt_start(); + void s3c24xx_wdt_stop(); + void s3c24xx_wdt_recalc(); + WRITE32_MEMBER( s3c24xx_wdt_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_wdt_timer_exp ); + void s3c24xx_iic_reset(); + inline void iface_i2c_scl_w( int state); + inline void iface_i2c_sda_w(int state); + inline int iface_i2c_sda_r(); + void i2c_send_start(); + void i2c_send_stop(); + UINT8 i2c_receive_byte(int ack); + int i2c_send_byte(UINT8 data); + void iic_start(); + void iic_stop(); + void iic_resume(); + READ32_MEMBER( s3c24xx_iic_r ); + WRITE32_MEMBER( s3c24xx_iic_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_iic_timer_exp ); + void s3c24xx_iis_reset(); + inline void iface_i2s_data_w(int ch, UINT16 data); + void s3c24xx_iis_start(); + void s3c24xx_iis_stop(); + void s3c24xx_iis_recalc(); + READ32_MEMBER( s3c24xx_iis_r ); + WRITE32_MEMBER( s3c24xx_iis_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_iis_timer_exp ); + void s3c24xx_rtc_reset(); + READ32_MEMBER( s3c24xx_rtc_r ); + void s3c24xx_rtc_recalc(); + WRITE32_MEMBER( s3c24xx_rtc_w ); + TIMER_CALLBACK_MEMBER( s3c24xx_rtc_timer_tick_count_exp ); + void s3c24xx_rtc_update(); + void s3c24xx_rtc_check_alarm(); + TIMER_CALLBACK_MEMBER( s3c24xx_rtc_timer_update_exp ); + void s3c24xx_adc_reset(); + UINT32 iface_adc_data_r(int ch); + READ32_MEMBER( s3c24xx_adc_r ); + void s3c24xx_adc_start(); + WRITE32_MEMBER( s3c24xx_adc_w ); + void s3c24xx_touch_screen(int state); + void s3c24xx_spi_reset(); + UINT32 s3c24xx_spi_r(UINT32 ch, UINT32 offset); + void s3c24xx_spi_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask); + READ32_MEMBER( s3c24xx_spi_0_r ); + READ32_MEMBER( s3c24xx_spi_1_r ); + WRITE32_MEMBER( s3c24xx_spi_0_w ); + WRITE32_MEMBER( s3c24xx_spi_1_w ); + void s3c24xx_sdi_reset(); + READ32_MEMBER( s3c24xx_sdi_r ); + WRITE32_MEMBER( s3c24xx_sdi_w ); + void s3c24xx_nand_reset(); + inline void iface_nand_command_w(UINT8 data); + inline void iface_nand_address_w(UINT8 data); + inline UINT8 iface_nand_data_r(); + inline void iface_nand_data_w(UINT8 data); + void nand_update_mecc( UINT8 *ecc, int pos, UINT8 data); + void nand_update_secc( UINT8 *ecc, int pos, UINT8 data); + void s3c24xx_nand_update_ecc(UINT8 data); + void s3c24xx_nand_command_w(UINT8 data); + void s3c24xx_nand_address_w(UINT8 data); + UINT8 s3c24xx_nand_data_r(); + void s3c24xx_nand_data_w(UINT8 data); + READ32_MEMBER( s3c24xx_nand_r ); + void s3c24xx_nand_init_ecc(); + WRITE32_MEMBER( s3c24xx_nand_w ); + ATTR_UNUSED WRITE_LINE_MEMBER( s3c24xx_pin_frnb_w ); + void s3c24xx_cam_reset(); + READ32_MEMBER( s3c24xx_cam_r ); + WRITE32_MEMBER( s3c24xx_cam_w ); + void s3c24xx_ac97_reset(); + READ32_MEMBER( s3c24xx_ac97_r ); + WRITE32_MEMBER( s3c24xx_ac97_w ); + void s3c24xx_nand_auto_boot(); + void s3c24xx_device_reset(); + void s3c24xx_device_start(); + + + void s3c2440_uart_fifo_w( int uart, UINT8 data); + void s3c2440_touch_screen( int state); + void s3c2440_request_irq( UINT32 int_type); + void s3c2440_request_eint( UINT32 number); + + + /******************************************************************************* + TYPE DEFINITIONS + *******************************************************************************/ + + struct s3c24xx_memcon_regs_t + { + UINT32 data[0x34/4]; + }; + + struct s3c24xx_usbhost_regs_t + { + UINT32 data[0x5C/4]; + }; + + struct s3c24xx_irq_regs_t + { + UINT32 srcpnd; + UINT32 intmod; + UINT32 intmsk; + UINT32 priority; + UINT32 intpnd; + UINT32 intoffset; + UINT32 subsrcpnd; + UINT32 intsubmsk; + }; + + struct s3c24xx_dma_regs_t + { + UINT32 disrc; + UINT32 disrcc; + UINT32 didst; + UINT32 didstc; + UINT32 dcon; + UINT32 dstat; + UINT32 dcsrc; + UINT32 dcdst; + UINT32 dmasktrig; + }; + + struct s3c24xx_clkpow_regs_t + { + UINT32 locktime; + UINT32 mpllcon; + UINT32 upllcon; + UINT32 clkcon; + UINT32 clkslow; + UINT32 clkdivn; + UINT32 camdivn; + }; + + struct s3c24xx_lcd_regs_t + { + UINT32 lcdcon1; + UINT32 lcdcon2; + UINT32 lcdcon3; + UINT32 lcdcon4; + UINT32 lcdcon5; + UINT32 lcdsaddr1; + UINT32 lcdsaddr2; + UINT32 lcdsaddr3; + UINT32 redlut; + UINT32 greenlut; + UINT32 bluelut; + UINT32 reserved[8]; + UINT32 dithmode; + UINT32 tpal; + UINT32 lcdintpnd; + UINT32 lcdsrcpnd; + UINT32 lcdintmsk; + UINT32 tconsel; + }; + + struct s3c24xx_lcdpal_regs_t + { + UINT32 data[0x400/4]; + }; + + struct s3c24xx_nand_regs_t + { + UINT32 nfconf; + UINT32 nfcont; + UINT32 nfcmd; + UINT32 nfaddr; + UINT32 nfdata; + UINT32 nfmeccd0; + UINT32 nfmeccd1; + UINT32 nfseccd; + UINT32 nfstat; + UINT32 nfestat0; + UINT32 nfestat1; + UINT32 nfmecc0; + UINT32 nfmecc1; + UINT32 nfsecc; + UINT32 nfsblk; + UINT32 nfeblk; + }; + + struct s3c24xx_cam_regs_t + { + UINT32 data[0xA4/4]; + }; + + struct s3c24xx_uart_regs_t + { + UINT32 ulcon; + UINT32 ucon; + UINT32 ufcon; + UINT32 umcon; + UINT32 utrstat; + UINT32 uerstat; + UINT32 ufstat; + UINT32 umstat; + UINT32 utxh; + UINT32 urxh; + UINT32 ubrdiv; + }; + + struct s3c24xx_pwm_regs_t + { + UINT32 tcfg0; + UINT32 tcfg1; + UINT32 tcon; + UINT32 tcntb0; + UINT32 tcmpb0; + UINT32 tcnto0; + UINT32 tcntb1; + UINT32 tcmpb1; + UINT32 tcnto1; + UINT32 tcntb2; + UINT32 tcmpb2; + UINT32 tcnto2; + UINT32 tcntb3; + UINT32 tcmpb3; + UINT32 tcnto3; + UINT32 tcntb4; + UINT32 tcnto4; + }; + + struct s3c24xx_usbdev_regs_t + { + UINT32 data[0x130/4]; + }; + + struct s3c24xx_wdt_regs_t + { + UINT32 wtcon; + UINT32 wtdat; + UINT32 wtcnt; + }; + + struct s3c24xx_iic_regs_t + { + UINT32 iiccon; + UINT32 iicstat; + UINT32 iicadd; + UINT32 iicds; + UINT32 iiclc; + }; + + struct s3c24xx_iis_regs_t + { + UINT32 iiscon; + UINT32 iismod; + UINT32 iispsr; + UINT32 iisfcon; + UINT32 iisfifo; + }; + + struct s3c24xx_gpio_regs_t + { + UINT32 gpacon; + UINT32 gpadat; + UINT32 pad_08; + UINT32 pad_0c; + UINT32 gpbcon; + UINT32 gpbdat; + UINT32 gpbup; + UINT32 pad_1c; + UINT32 gpccon; + UINT32 gpcdat; + UINT32 gpcup; + UINT32 pad_2c; + UINT32 gpdcon; + UINT32 gpddat; + UINT32 gpdup; + UINT32 pad_3c; + UINT32 gpecon; + UINT32 gpedat; + UINT32 gpeup; + UINT32 pad_4c; + UINT32 gpfcon; + UINT32 gpfdat; + UINT32 gpfup; + UINT32 pad_5c; + UINT32 gpgcon; + UINT32 gpgdat; + UINT32 gpgup; + UINT32 pad_6c; + UINT32 gphcon; + UINT32 gphdat; + UINT32 gphup; + UINT32 pad_7c; + UINT32 misccr; + UINT32 dclkcon; + UINT32 extint0; + UINT32 extint1; + UINT32 extint2; + UINT32 eintflt0; + UINT32 eintflt1; + UINT32 eintflt2; + UINT32 eintflt3; + UINT32 eintmask; + UINT32 eintpend; + UINT32 gstatus0; + UINT32 gstatus1; + UINT32 gstatus2; + UINT32 gstatus3; + UINT32 gstatus4; + UINT32 pad_c0; + UINT32 pad_c4; + UINT32 pad_c8; + UINT32 mslcon; + UINT32 gpjcon; + UINT32 gpjdat; + UINT32 gpjup; + }; + + struct s3c24xx_rtc_regs_t + { + UINT32 rtccon; + UINT32 ticnt; + UINT32 reserved[2]; + UINT32 rtcalm; + UINT32 almsec; + UINT32 almmin; + UINT32 almhour; + UINT32 almday; + UINT32 almmon; + UINT32 almyear; + UINT32 rtcrst; + UINT32 bcdsec; + UINT32 bcdmin; + UINT32 bcdhour; + UINT32 bcdday; + UINT32 bcddow; + UINT32 bcdmon; + UINT32 bcdyear; + }; + + struct s3c24xx_adc_regs_t + { + UINT32 adccon; + UINT32 adctsc; + UINT32 adcdly; + UINT32 adcdat0; + UINT32 adcdat1; + UINT32 adcupdn; + }; + + struct s3c24xx_spi_regs_t + { + UINT32 spcon; + UINT32 spsta; + UINT32 sppin; + UINT32 sppre; + UINT32 sptdat; + UINT32 sprdat; + }; + + struct s3c24xx_sdi_regs_t + { + UINT32 data[0x44/4]; + }; + + struct s3c24xx_ac97_regs_t + { + UINT32 data[0x20/4]; + }; + + struct s3c24xx_memcon_t + { + s3c24xx_memcon_regs_t regs; + }; + + struct s3c24xx_usbhost_t + { + s3c24xx_usbhost_regs_t regs; + }; + + struct s3c24xx_irq_t + { + s3c24xx_irq_regs_t regs; + int line_irq, line_fiq; + }; + + struct s3c24xx_dma_t + { + s3c24xx_dma_regs_t regs; + emu_timer *timer; + }; + + struct s3c24xx_clkpow_t + { + s3c24xx_clkpow_regs_t regs; + }; + + struct s3c24xx_lcd_t + { + s3c24xx_lcd_regs_t regs; + emu_timer *timer; + bitmap_rgb32 *bitmap[2]; + UINT32 vramaddr_cur; + UINT32 vramaddr_max; + UINT32 offsize; + UINT32 pagewidth_cur; + UINT32 pagewidth_max; + UINT32 bppmode; + UINT32 bswp, hwswp; + int vpos, hpos; + double framerate; + UINT32 tpal; + UINT32 hpos_min, hpos_max, vpos_min, vpos_max; + UINT32 dma_data, dma_bits; + }; + + struct s3c24xx_lcdpal_t + { + s3c24xx_lcdpal_regs_t regs; + }; + + struct s3c24xx_nand_t + { + s3c24xx_nand_regs_t regs; + UINT8 mecc[4]; + UINT8 secc[2]; + int ecc_pos, data_count; + }; + + struct s3c24xx_cam_t + { + s3c24xx_cam_regs_t regs; + }; + + struct s3c24xx_uart_t + { + s3c24xx_uart_regs_t regs; + }; + + struct s3c24xx_pwm_t + { + s3c24xx_pwm_regs_t regs; + emu_timer *timer[5]; + UINT32 cnt[5]; + UINT32 cmp[5]; + UINT32 freq[5]; + }; + + struct s3c24xx_usbdev_t + { + s3c24xx_usbdev_regs_t regs; + }; + + struct s3c24xx_wdt_t + { + s3c24xx_wdt_regs_t regs; + emu_timer *timer; + }; + + struct s3c24xx_iic_t + { + s3c24xx_iic_regs_t regs; + emu_timer *timer; + int count; + }; + + struct s3c24xx_iis_t + { + s3c24xx_iis_regs_t regs; + emu_timer *timer; + UINT16 fifo[16/2]; + int fifo_index; + }; + + struct s3c24xx_gpio_t + { + s3c24xx_gpio_regs_t regs; + }; + + struct s3c24xx_rtc_t + { + s3c24xx_rtc_regs_t regs; + emu_timer *timer_tick_count; + emu_timer *timer_update; + }; + + struct s3c24xx_adc_t + { + s3c24xx_adc_regs_t regs; + }; + + struct s3c24xx_spi_t + { + s3c24xx_spi_regs_t regs; + }; + + struct s3c24xx_sdi_t + { + s3c24xx_sdi_regs_t regs; + }; + + struct s3c24xx_ac97_t + { + s3c24xx_ac97_regs_t regs; + }; + + + UINT8 m_steppingstone[4*1024]; + s3c24xx_memcon_t m_memcon; + s3c24xx_usbhost_t m_usbhost; + s3c24xx_irq_t m_irq; + s3c24xx_dma_t m_dma[S3C24XX_DMA_COUNT]; + s3c24xx_clkpow_t m_clkpow; + s3c24xx_lcd_t m_lcd; + s3c24xx_lcdpal_t m_lcdpal; + s3c24xx_nand_t m_nand; + s3c24xx_cam_t m_cam; + s3c24xx_uart_t m_uart[S3C24XX_UART_COUNT]; + s3c24xx_pwm_t m_pwm; + s3c24xx_usbdev_t m_usbdev; + s3c24xx_wdt_t m_wdt; + s3c24xx_iic_t m_iic; + s3c24xx_iis_t m_iis; + s3c24xx_gpio_t m_gpio; + s3c24xx_rtc_t m_rtc; + s3c24xx_adc_t m_adc; + s3c24xx_spi_t m_spi[S3C24XX_SPI_COUNT]; + s3c24xx_sdi_t m_sdi; + s3c24xx_ac97_t m_ac97; + required_device m_cpu; + devcb_resolved_read32 m_pin_r; + devcb_resolved_write32 m_pin_w; + devcb_resolved_read32 m_port_r; + devcb_resolved_write32 m_port_w; + devcb_resolved_write_line m_scl_w; + devcb_resolved_read_line m_sda_r; + devcb_resolved_write_line m_sda_w; + devcb_resolved_read32 m_adc_data_r; + devcb_resolved_write16 m_i2s_data_w; + devcb_resolved_write8 m_command_w; + devcb_resolved_write8 m_address_w; + devcb_resolved_read8 m_nand_data_r; + devcb_resolved_write8 m_nand_data_w; + }; -struct s3c24xx_usbhost_regs_t -{ - UINT32 data[0x5C/4]; -}; +extern const device_type S3C2440; -struct s3c24xx_irq_regs_t -{ - UINT32 srcpnd; - UINT32 intmod; - UINT32 intmsk; - UINT32 priority; - UINT32 intpnd; - UINT32 intoffset; - UINT32 subsrcpnd; - UINT32 intsubmsk; -}; - -struct s3c24xx_dma_regs_t -{ - UINT32 disrc; - UINT32 disrcc; - UINT32 didst; - UINT32 didstc; - UINT32 dcon; - UINT32 dstat; - UINT32 dcsrc; - UINT32 dcdst; - UINT32 dmasktrig; -}; - -struct s3c24xx_clkpow_regs_t -{ - UINT32 locktime; - UINT32 mpllcon; - UINT32 upllcon; - UINT32 clkcon; - UINT32 clkslow; - UINT32 clkdivn; - UINT32 camdivn; -}; - -struct s3c24xx_lcd_regs_t -{ - UINT32 lcdcon1; - UINT32 lcdcon2; - UINT32 lcdcon3; - UINT32 lcdcon4; - UINT32 lcdcon5; - UINT32 lcdsaddr1; - UINT32 lcdsaddr2; - UINT32 lcdsaddr3; - UINT32 redlut; - UINT32 greenlut; - UINT32 bluelut; - UINT32 reserved[8]; - UINT32 dithmode; - UINT32 tpal; - UINT32 lcdintpnd; - UINT32 lcdsrcpnd; - UINT32 lcdintmsk; - UINT32 tconsel; -}; - -struct s3c24xx_lcdpal_regs_t -{ - UINT32 data[0x400/4]; -}; - -struct s3c24xx_nand_regs_t -{ - UINT32 nfconf; - UINT32 nfcont; - UINT32 nfcmd; - UINT32 nfaddr; - UINT32 nfdata; - UINT32 nfmeccd0; - UINT32 nfmeccd1; - UINT32 nfseccd; - UINT32 nfstat; - UINT32 nfestat0; - UINT32 nfestat1; - UINT32 nfmecc0; - UINT32 nfmecc1; - UINT32 nfsecc; - UINT32 nfsblk; - UINT32 nfeblk; -}; - -struct s3c24xx_cam_regs_t -{ - UINT32 data[0xA4/4]; -}; - -struct s3c24xx_uart_regs_t -{ - UINT32 ulcon; - UINT32 ucon; - UINT32 ufcon; - UINT32 umcon; - UINT32 utrstat; - UINT32 uerstat; - UINT32 ufstat; - UINT32 umstat; - UINT32 utxh; - UINT32 urxh; - UINT32 ubrdiv; -}; - -struct s3c24xx_pwm_regs_t -{ - UINT32 tcfg0; - UINT32 tcfg1; - UINT32 tcon; - UINT32 tcntb0; - UINT32 tcmpb0; - UINT32 tcnto0; - UINT32 tcntb1; - UINT32 tcmpb1; - UINT32 tcnto1; - UINT32 tcntb2; - UINT32 tcmpb2; - UINT32 tcnto2; - UINT32 tcntb3; - UINT32 tcmpb3; - UINT32 tcnto3; - UINT32 tcntb4; - UINT32 tcnto4; -}; - -struct s3c24xx_usbdev_regs_t -{ - UINT32 data[0x130/4]; -}; - -struct s3c24xx_wdt_regs_t -{ - UINT32 wtcon; - UINT32 wtdat; - UINT32 wtcnt; -}; - -struct s3c24xx_iic_regs_t -{ - UINT32 iiccon; - UINT32 iicstat; - UINT32 iicadd; - UINT32 iicds; - UINT32 iiclc; -}; - -struct s3c24xx_iis_regs_t -{ - UINT32 iiscon; - UINT32 iismod; - UINT32 iispsr; - UINT32 iisfcon; - UINT32 iisfifo; -}; - -struct s3c24xx_gpio_regs_t -{ - UINT32 gpacon; - UINT32 gpadat; - UINT32 pad_08; - UINT32 pad_0c; - UINT32 gpbcon; - UINT32 gpbdat; - UINT32 gpbup; - UINT32 pad_1c; - UINT32 gpccon; - UINT32 gpcdat; - UINT32 gpcup; - UINT32 pad_2c; - UINT32 gpdcon; - UINT32 gpddat; - UINT32 gpdup; - UINT32 pad_3c; - UINT32 gpecon; - UINT32 gpedat; - UINT32 gpeup; - UINT32 pad_4c; - UINT32 gpfcon; - UINT32 gpfdat; - UINT32 gpfup; - UINT32 pad_5c; - UINT32 gpgcon; - UINT32 gpgdat; - UINT32 gpgup; - UINT32 pad_6c; - UINT32 gphcon; - UINT32 gphdat; - UINT32 gphup; - UINT32 pad_7c; - UINT32 misccr; - UINT32 dclkcon; - UINT32 extint0; - UINT32 extint1; - UINT32 extint2; - UINT32 eintflt0; - UINT32 eintflt1; - UINT32 eintflt2; - UINT32 eintflt3; - UINT32 eintmask; - UINT32 eintpend; - UINT32 gstatus0; - UINT32 gstatus1; - UINT32 gstatus2; - UINT32 gstatus3; - UINT32 gstatus4; - UINT32 pad_c0; - UINT32 pad_c4; - UINT32 pad_c8; - UINT32 mslcon; - UINT32 gpjcon; - UINT32 gpjdat; - UINT32 gpjup; -}; - -struct s3c24xx_rtc_regs_t -{ - UINT32 rtccon; - UINT32 ticnt; - UINT32 reserved[2]; - UINT32 rtcalm; - UINT32 almsec; - UINT32 almmin; - UINT32 almhour; - UINT32 almday; - UINT32 almmon; - UINT32 almyear; - UINT32 rtcrst; - UINT32 bcdsec; - UINT32 bcdmin; - UINT32 bcdhour; - UINT32 bcdday; - UINT32 bcddow; - UINT32 bcdmon; - UINT32 bcdyear; -}; - -struct s3c24xx_adc_regs_t -{ - UINT32 adccon; - UINT32 adctsc; - UINT32 adcdly; - UINT32 adcdat0; - UINT32 adcdat1; - UINT32 adcupdn; -}; - -struct s3c24xx_spi_regs_t -{ - UINT32 spcon; - UINT32 spsta; - UINT32 sppin; - UINT32 sppre; - UINT32 sptdat; - UINT32 sprdat; -}; - -struct s3c24xx_sdi_regs_t -{ - UINT32 data[0x44/4]; -}; - -struct s3c24xx_ac97_regs_t -{ - UINT32 data[0x20/4]; -}; - -struct s3c24xx_memcon_t -{ - s3c24xx_memcon_regs_t regs; -}; - -struct s3c24xx_usbhost_t -{ - s3c24xx_usbhost_regs_t regs; -}; - -struct s3c24xx_irq_t -{ - s3c24xx_irq_regs_t regs; - int line_irq, line_fiq; -}; - -struct s3c24xx_dma_t -{ - s3c24xx_dma_regs_t regs; - emu_timer *timer; -}; - -struct s3c24xx_clkpow_t -{ - s3c24xx_clkpow_regs_t regs; -}; - -struct s3c24xx_lcd_t -{ - s3c24xx_lcd_regs_t regs; - emu_timer *timer; - bitmap_rgb32 *bitmap[2]; - UINT32 vramaddr_cur; - UINT32 vramaddr_max; - UINT32 offsize; - UINT32 pagewidth_cur; - UINT32 pagewidth_max; - UINT32 bppmode; - UINT32 bswp, hwswp; - int vpos, hpos; - double framerate; - UINT32 tpal; - UINT32 hpos_min, hpos_max, vpos_min, vpos_max; - UINT32 dma_data, dma_bits; -}; - -struct s3c24xx_lcdpal_t -{ - s3c24xx_lcdpal_regs_t regs; -}; - -struct s3c24xx_nand_t -{ - s3c24xx_nand_regs_t regs; - UINT8 mecc[4]; - UINT8 secc[2]; - int ecc_pos, data_count; -}; - -struct s3c24xx_cam_t -{ - s3c24xx_cam_regs_t regs; -}; - -struct s3c24xx_uart_t -{ - s3c24xx_uart_regs_t regs; -}; - -struct s3c24xx_pwm_t -{ - s3c24xx_pwm_regs_t regs; - emu_timer *timer[5]; - UINT32 cnt[5]; - UINT32 cmp[5]; - UINT32 freq[5]; -}; - -struct s3c24xx_usbdev_t -{ - s3c24xx_usbdev_regs_t regs; -}; - -struct s3c24xx_wdt_t -{ - s3c24xx_wdt_regs_t regs; - emu_timer *timer; -}; - -struct s3c24xx_iic_t -{ - s3c24xx_iic_regs_t regs; - emu_timer *timer; - int count; -}; - -struct s3c24xx_iis_t -{ - s3c24xx_iis_regs_t regs; - emu_timer *timer; - UINT16 fifo[16/2]; - int fifo_index; -}; - -struct s3c24xx_gpio_t -{ - s3c24xx_gpio_regs_t regs; -}; - -struct s3c24xx_rtc_t -{ - s3c24xx_rtc_regs_t regs; - emu_timer *timer_tick_count; - emu_timer *timer_update; -}; - -struct s3c24xx_adc_t -{ - s3c24xx_adc_regs_t regs; -}; - -struct s3c24xx_spi_t -{ - s3c24xx_spi_regs_t regs; -}; - -struct s3c24xx_sdi_t -{ - s3c24xx_sdi_regs_t regs; -}; - -struct s3c24xx_ac97_t -{ - s3c24xx_ac97_regs_t regs; -}; - -struct s3c24xx_t -{ - const s3c2440_interface *iface; - UINT8 steppingstone[4*1024]; - s3c24xx_memcon_t memcon; - s3c24xx_usbhost_t usbhost; - s3c24xx_irq_t irq; - s3c24xx_dma_t dma[S3C24XX_DMA_COUNT]; - s3c24xx_clkpow_t clkpow; - s3c24xx_lcd_t lcd; - s3c24xx_lcdpal_t lcdpal; - s3c24xx_nand_t nand; - s3c24xx_cam_t cam; - s3c24xx_uart_t uart[S3C24XX_UART_COUNT]; - s3c24xx_pwm_t pwm; - s3c24xx_usbdev_t usbdev; - s3c24xx_wdt_t wdt; - s3c24xx_iic_t iic; - s3c24xx_iis_t iis; - s3c24xx_gpio_t gpio; - s3c24xx_rtc_t rtc; - s3c24xx_adc_t adc; - s3c24xx_spi_t spi[S3C24XX_SPI_COUNT]; - s3c24xx_sdi_t sdi; - s3c24xx_ac97_t ac97; - device_t *m_cpu; - devcb_resolved_read32 pin_r; - devcb_resolved_write32 pin_w; - devcb_resolved_read32 port_r; - devcb_resolved_write32 port_w; - devcb_resolved_write_line scl_w; - devcb_resolved_read_line sda_r; - devcb_resolved_write_line sda_w; - devcb_resolved_read32 adc_data_r; - devcb_resolved_write16 i2s_data_w; - devcb_resolved_write8 command_w; - devcb_resolved_write8 address_w; - devcb_resolved_read8 nand_data_r; - devcb_resolved_write8 nand_data_w; - palette_device *m_palette; -}; #endif diff --git a/src/emu/machine/s3c24xx.inc b/src/emu/machine/s3c24xx.inc index b041fa80759..5f99ffee5d3 100644 --- a/src/emu/machine/s3c24xx.inc +++ b/src/emu/machine/s3c24xx.inc @@ -7,7 +7,6 @@ #include "emu.h" #include "cpu/arm7/arm7.h" #include "cpu/arm7/arm7core.h" -//#include "includes/s3c24xx.h" #include "coreutil.h" /******************************************************************************* @@ -80,65 +79,24 @@ #endif -/*************************************************************************** - TYPE DEFINITIONS -***************************************************************************/ - -#if defined(DEVICE_S3C2400) -typedef s3c2400_interface s3c24xx_interface; -#elif defined(DEVICE_S3C2410) -typedef s3c2410_interface s3c24xx_interface; -#elif defined(DEVICE_S3C2440) -typedef s3c2440_interface s3c24xx_interface; -#endif - -/*************************************************************************** - PROTOTYPES -***************************************************************************/ - -static UINT32 s3c24xx_get_fclk( device_t *device); -static UINT32 s3c24xx_get_hclk( device_t *device); -static UINT32 s3c24xx_get_pclk( device_t *device); - -static void s3c24xx_dma_request_iis( device_t *device); -static void s3c24xx_dma_request_pwm( device_t *device); - -/*************************************************************************** - INLINE FUNCTIONS -***************************************************************************/ - -INLINE s3c24xx_t *get_token( device_t *device) -{ - assert(device != NULL); -#if defined(DEVICE_S3C2400) - return (s3c24xx_t *)downcast(device)->token(); -#elif defined(DEVICE_S3C2410) - return (s3c24xx_t *)downcast(device)->token(); -#elif defined(DEVICE_S3C2440) - return (s3c24xx_t *)downcast(device)->token(); -#endif -} - /*************************************************************************** IMPLEMENTATION ***************************************************************************/ /* ... */ -static void s3c24xx_reset( device_t *device) -{ - s3c24xx_t *s3c24xx = get_token( device ); - verboselog( device->machine(), 1, "reset\n"); - s3c24xx->m_cpu->reset(); - device->reset(); +void S3C24_CLASS_NAME::s3c24xx_reset() +{ + verboselog( machine(), 1, "reset\n"); + m_cpu->reset(); + this->reset(); } -INLINE int iface_core_pin_r( device_t *device, int pin) +int S3C24_CLASS_NAME::iface_core_pin_r(int pin) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->pin_r.isnull()) + if (!m_pin_r.isnull()) { - return (s3c24xx->pin_r)(pin); + return (m_pin_r)(pin); } else { @@ -148,10 +106,9 @@ INLINE int iface_core_pin_r( device_t *device, int pin) /* LCD Controller */ -static void s3c24xx_lcd_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_lcd_t *lcd = &s3c24xx->lcd; + s3c24xx_lcd_t *lcd = &m_lcd; memset( &lcd->regs, 0, sizeof( lcd->regs)); #if defined(DEVICE_S3C2410) lcd->regs.lcdintmsk = 3; @@ -173,10 +130,9 @@ static void s3c24xx_lcd_reset( device_t *device) lcd->timer->adjust( attotime::never); } -static rgb_t s3c24xx_get_color_tft_16( device_t *device, UINT16 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_tft_16(UINT16 data) { - s3c24xx_t *s3c24xx = get_token( device); - if ((s3c24xx->lcd.regs.lcdcon5 & (1 << 11)) == 0) + if ((m_lcd.regs.lcdcon5 & (1 << 11)) == 0) { UINT8 r, g, b, i; r = (BITS( data, 15, 11) << 3); @@ -197,7 +153,7 @@ static rgb_t s3c24xx_get_color_tft_16( device_t *device, UINT16 data) #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static rgb_t s3c24xx_get_color_tft_24( device_t *device, UINT32 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_tft_24(UINT32 data) { UINT8 r, g, b; r = BITS( data, 23, 16); @@ -208,7 +164,7 @@ static rgb_t s3c24xx_get_color_tft_24( device_t *device, UINT32 data) #endif -static rgb_t s3c24xx_get_color_stn_12( device_t *device, UINT16 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_stn_12(UINT16 data) { UINT8 r, g, b; r = BITS( data, 11, 8) << 4; @@ -217,17 +173,16 @@ static rgb_t s3c24xx_get_color_stn_12( device_t *device, UINT16 data) return rgb_t( r, g, b); } -static rgb_t s3c24xx_get_color_stn_08( device_t *device, UINT8 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_stn_08( UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); UINT8 r, g, b; - r = ((s3c24xx->lcd.regs.redlut >> (BITS( data, 7, 5) << 2)) & 0xF) << 4; - g = ((s3c24xx->lcd.regs.greenlut >> (BITS( data, 4, 2) << 2)) & 0xF) << 4; - b = ((s3c24xx->lcd.regs.bluelut >> (BITS( data, 1, 0) << 2)) & 0xF) << 4; + r = ((m_lcd.regs.redlut >> (BITS( data, 7, 5) << 2)) & 0xF) << 4; + g = ((m_lcd.regs.greenlut >> (BITS( data, 4, 2) << 2)) & 0xF) << 4; + b = ((m_lcd.regs.bluelut >> (BITS( data, 1, 0) << 2)) & 0xF) << 4; return rgb_t( r, g, b); } -static rgb_t s3c24xx_get_color_stn_01( device_t *device, UINT8 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_stn_01(UINT8 data) { if ((data & 1) == 0) { @@ -239,87 +194,82 @@ static rgb_t s3c24xx_get_color_stn_01( device_t *device, UINT8 data) } } -static rgb_t s3c24xx_get_color_stn_02( device_t *device, UINT8 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_stn_02(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); UINT8 r, g, b; - r = g = b = ((s3c24xx->lcd.regs.bluelut >> (BITS( data, 1, 0) << 2)) & 0xF) << 4; + r = g = b = ((m_lcd.regs.bluelut >> (BITS( data, 1, 0) << 2)) & 0xF) << 4; return rgb_t( r, g, b); } -static rgb_t s3c24xx_get_color_stn_04( device_t *device, UINT8 data) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_stn_04(UINT8 data) { UINT8 r, g, b; r = g = b = BITS( data, 3, 0) << 4; return rgb_t( r, g, b); } -static rgb_t s3c24xx_get_color_tpal( device_t *device) +rgb_t S3C24_CLASS_NAME::s3c24xx_get_color_tpal() { - s3c24xx_t *s3c24xx = get_token( device); #if defined(DEVICE_S3C2400) - return s3c24xx_get_color_tft_16( device, S3C24XX_TPAL_GET_TPALVAL( s3c24xx->lcd.tpal)); + return s3c24xx_get_color_tft_16(S3C24XX_TPAL_GET_TPALVAL( m_lcd.tpal)); #else - return s3c24xx_get_color_tft_24( device, S3C24XX_TPAL_GET_TPALVAL( s3c24xx->lcd.tpal)); + return s3c24xx_get_color_tft_24(S3C24XX_TPAL_GET_TPALVAL( m_lcd.tpal)); #endif } -static void s3c24xx_lcd_dma_reload( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_dma_reload() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx->lcd.vramaddr_cur = s3c24xx->lcd.regs.lcdsaddr1 << 1; - s3c24xx->lcd.vramaddr_max = ((s3c24xx->lcd.regs.lcdsaddr1 & 0xFFE00000) | s3c24xx->lcd.regs.lcdsaddr2) << 1; - s3c24xx->lcd.offsize = BITS( s3c24xx->lcd.regs.lcdsaddr3, 21, 11); - s3c24xx->lcd.pagewidth_cur = 0; - s3c24xx->lcd.pagewidth_max = BITS( s3c24xx->lcd.regs.lcdsaddr3, 10, 0); - if (s3c24xx->lcd.pagewidth_max == 0) + m_lcd.vramaddr_cur = m_lcd.regs.lcdsaddr1 << 1; + m_lcd.vramaddr_max = ((m_lcd.regs.lcdsaddr1 & 0xFFE00000) | m_lcd.regs.lcdsaddr2) << 1; + m_lcd.offsize = BITS( m_lcd.regs.lcdsaddr3, 21, 11); + m_lcd.pagewidth_cur = 0; + m_lcd.pagewidth_max = BITS( m_lcd.regs.lcdsaddr3, 10, 0); + if (m_lcd.pagewidth_max == 0) { - if (s3c24xx->lcd.bppmode == S3C24XX_BPPMODE_STN_12_P) + if (m_lcd.bppmode == S3C24XX_BPPMODE_STN_12_P) { - s3c24xx->lcd.pagewidth_max = (s3c24xx->lcd.hpos_max - s3c24xx->lcd.hpos_min + 1) / 16 * 12; + m_lcd.pagewidth_max = (m_lcd.hpos_max - m_lcd.hpos_min + 1) / 16 * 12; } } - verboselog( device->machine(), 3, "LCD - vramaddr %08X %08X offsize %08X pagewidth %08X\n", s3c24xx->lcd.vramaddr_cur, s3c24xx->lcd.vramaddr_max, s3c24xx->lcd.offsize, s3c24xx->lcd.pagewidth_max); - s3c24xx->lcd.dma_data = 0; - s3c24xx->lcd.dma_bits = 0; + verboselog( machine(), 3, "LCD - vramaddr %08X %08X offsize %08X pagewidth %08X\n", m_lcd.vramaddr_cur, m_lcd.vramaddr_max, m_lcd.offsize, m_lcd.pagewidth_max); + m_lcd.dma_data = 0; + m_lcd.dma_bits = 0; } -static void s3c24xx_lcd_dma_init( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_dma_init() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx->lcd.bppmode = BITS( s3c24xx->lcd.regs.lcdcon1, 4, 1); - s3c24xx_lcd_dma_reload( device); - s3c24xx->lcd.bswp = BIT( s3c24xx->lcd.regs.lcdcon5, 1); - s3c24xx->lcd.hwswp = BIT( s3c24xx->lcd.regs.lcdcon5, 0); - s3c24xx->lcd.tpal = s3c24xx->lcd.regs.tpal; - verboselog( device->machine(), 3, "LCD - bppmode %d hwswp %d bswp %d\n", s3c24xx->lcd.bppmode, s3c24xx->lcd.hwswp, s3c24xx->lcd.bswp); - s3c24xx->lcd.dma_data = 0; - s3c24xx->lcd.dma_bits = 0; + m_lcd.bppmode = BITS( m_lcd.regs.lcdcon1, 4, 1); + s3c24xx_lcd_dma_reload(); + m_lcd.bswp = BIT( m_lcd.regs.lcdcon5, 1); + m_lcd.hwswp = BIT( m_lcd.regs.lcdcon5, 0); + m_lcd.tpal = m_lcd.regs.tpal; + verboselog( machine(), 3, "LCD - bppmode %d hwswp %d bswp %d\n", m_lcd.bppmode, m_lcd.hwswp, m_lcd.bswp); + m_lcd.dma_data = 0; + m_lcd.dma_bits = 0; } #if 0 -static UINT32 s3c24xx_lcd_dma_read( device_t *device) +UINT32 S3C24_CLASS_NAME::s3c24xx_lcd_dma_read() { - s3c24xx_t *s3c24xx = get_token( device); address_space& space = m_cpu->memory().space( AS_PROGRAM); UINT8 *vram, data[4]; - vram = (UINT8 *)space.get_read_ptr( s3c24xx->lcd.vramaddr_cur); + vram = (UINT8 *)space.get_read_ptr( m_lcd.vramaddr_cur); for (int i = 0; i < 2; i++) { data[i*2+0] = *vram++; data[i*2+1] = *vram++; - s3c24xx->lcd.vramaddr_cur += 2; - s3c24xx->lcd.pagewidth_cur++; - if (s3c24xx->lcd.pagewidth_cur >= s3c24xx->lcd.pagewidth_max) + m_lcd.vramaddr_cur += 2; + m_lcd.pagewidth_cur++; + if (m_lcd.pagewidth_cur >= m_lcd.pagewidth_max) { - s3c24xx->lcd.vramaddr_cur += s3c24xx->lcd.offsize << 1; - s3c24xx->lcd.pagewidth_cur = 0; - vram = (UINT8 *)space.get_read_ptr( s3c24xx->lcd.vramaddr_cur); + m_lcd.vramaddr_cur += m_lcd.offsize << 1; + m_lcd.pagewidth_cur = 0; + vram = (UINT8 *)space.get_read_ptr( m_lcd.vramaddr_cur); } } - if (s3c24xx->lcd.hwswp == 0) + if (m_lcd.hwswp == 0) { - if (s3c24xx->lcd.bswp == 0) + if (m_lcd.bswp == 0) { return (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | (data[0] << 0); } @@ -330,7 +280,7 @@ static UINT32 s3c24xx_lcd_dma_read( device_t *device) } else { - if (s3c24xx->lcd.bswp == 0) + if (m_lcd.bswp == 0) { return (data[1] << 24) | (data[0] << 16) | (data[3] << 8) | (data[2] << 0); } @@ -342,19 +292,18 @@ static UINT32 s3c24xx_lcd_dma_read( device_t *device) } #endif -static UINT32 s3c24xx_lcd_dma_read( device_t *device) +UINT32 S3C24_CLASS_NAME::s3c24xx_lcd_dma_read() { - s3c24xx_t *s3c24xx = get_token( device); - address_space& space = s3c24xx->m_cpu->memory().space( AS_PROGRAM); + address_space& space = m_cpu->memory().space( AS_PROGRAM); UINT8 *vram, data[4]; - vram = (UINT8 *)space.get_read_ptr( s3c24xx->lcd.vramaddr_cur); + vram = (UINT8 *)space.get_read_ptr( m_lcd.vramaddr_cur); for (int i = 0; i < 2; i++) { - if (s3c24xx->lcd.hwswp == 0) + if (m_lcd.hwswp == 0) { - if (s3c24xx->lcd.bswp == 0) + if (m_lcd.bswp == 0) { - if ((s3c24xx->lcd.vramaddr_cur & 2) == 0) + if ((m_lcd.vramaddr_cur & 2) == 0) { data[i*2+0] = *(vram + 3); data[i*2+1] = *(vram + 2); @@ -373,14 +322,14 @@ static UINT32 s3c24xx_lcd_dma_read( device_t *device) } else { - if (s3c24xx->lcd.bswp == 0) + if (m_lcd.bswp == 0) { data[i*2+0] = *(vram + 1); data[i*2+1] = *(vram + 0); } else { - if ((s3c24xx->lcd.vramaddr_cur & 2) == 0) + if ((m_lcd.vramaddr_cur & 2) == 0) { data[i*2+0] = *(vram + 2); data[i*2+1] = *(vram + 3); @@ -392,20 +341,20 @@ static UINT32 s3c24xx_lcd_dma_read( device_t *device) } } } - s3c24xx->lcd.vramaddr_cur += 2; - s3c24xx->lcd.pagewidth_cur++; - if (s3c24xx->lcd.pagewidth_cur >= s3c24xx->lcd.pagewidth_max) + m_lcd.vramaddr_cur += 2; + m_lcd.pagewidth_cur++; + if (m_lcd.pagewidth_cur >= m_lcd.pagewidth_max) { - s3c24xx->lcd.vramaddr_cur += s3c24xx->lcd.offsize << 1; - s3c24xx->lcd.pagewidth_cur = 0; - vram = (UINT8 *)space.get_read_ptr( s3c24xx->lcd.vramaddr_cur); + m_lcd.vramaddr_cur += m_lcd.offsize << 1; + m_lcd.pagewidth_cur = 0; + vram = (UINT8 *)space.get_read_ptr( m_lcd.vramaddr_cur); } else { vram += 2; } } - if (s3c24xx->iface->lcd.flags & S3C24XX_INTERFACE_LCD_REVERSE) + if (m_iface_lcd.flags & S3C24XX_INTERFACE_LCD_REVERSE) { return (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | (data[0] << 0); } @@ -415,379 +364,363 @@ static UINT32 s3c24xx_lcd_dma_read( device_t *device) } } -static UINT32 s3c24xx_lcd_dma_read_bits( device_t *device, int count) +UINT32 S3C24_CLASS_NAME::s3c24xx_lcd_dma_read_bits(int count) { - s3c24xx_t *s3c24xx = get_token( device); UINT32 data; - if (count <= s3c24xx->lcd.dma_bits) + if (count <= m_lcd.dma_bits) { - s3c24xx->lcd.dma_bits -= count; - data = BITS( s3c24xx->lcd.dma_data, 31, 32 - count); - s3c24xx->lcd.dma_data = s3c24xx->lcd.dma_data << count; + m_lcd.dma_bits -= count; + data = BITS( m_lcd.dma_data, 31, 32 - count); + m_lcd.dma_data = m_lcd.dma_data << count; } else { - if (s3c24xx->lcd.dma_bits == 0) + if (m_lcd.dma_bits == 0) { if (count == 32) { - data = s3c24xx_lcd_dma_read( device); + data = s3c24xx_lcd_dma_read(); } else { - UINT32 temp = s3c24xx_lcd_dma_read( device); + UINT32 temp = s3c24xx_lcd_dma_read(); data = BITS( temp, 31, 32 - count); - s3c24xx->lcd.dma_data = temp << count; - s3c24xx->lcd.dma_bits = 32 - count; + m_lcd.dma_data = temp << count; + m_lcd.dma_bits = 32 - count; } } else { - UINT32 temp = s3c24xx_lcd_dma_read( device); - data = (s3c24xx->lcd.dma_data >> (32 - count)) | BITS( temp, 31, 32 - (count - s3c24xx->lcd.dma_bits)); - s3c24xx->lcd.dma_data = temp << (count - s3c24xx->lcd.dma_bits); - s3c24xx->lcd.dma_bits = 32 - (count - s3c24xx->lcd.dma_bits); + UINT32 temp = s3c24xx_lcd_dma_read(); + data = (m_lcd.dma_data >> (32 - count)) | BITS( temp, 31, 32 - (count - m_lcd.dma_bits)); + m_lcd.dma_data = temp << (count - m_lcd.dma_bits); + m_lcd.dma_bits = 32 - (count - m_lcd.dma_bits); } } return data; } -static void s3c24xx_lcd_render_tpal( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_tpal() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 color = s3c24xx_get_color_tpal( device); - for (int y = s3c24xx->lcd.vpos_min; y <= s3c24xx->lcd.vpos_max; y++) + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 color = s3c24xx_get_color_tpal(); + for (int y = m_lcd.vpos_min; y <= m_lcd.vpos_max; y++) { - UINT32 *scanline = &bitmap.pix32(y, s3c24xx->lcd.hpos_min); - for (int x = s3c24xx->lcd.hpos_min; x <= s3c24xx->lcd.hpos_max; x++) + UINT32 *scanline = &bitmap.pix32(y, m_lcd.hpos_min); + for (int x = m_lcd.hpos_min; x <= m_lcd.hpos_max; x++) { *scanline++ = color; } } } -static void s3c24xx_lcd_render_stn_01( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_stn_01() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 32; j++) { - if (s3c24xx->iface->lcd.flags & S3C24XX_INTERFACE_LCD_REVERSE) + if (m_iface_lcd.flags & S3C24XX_INTERFACE_LCD_REVERSE) { - *scanline++ = s3c24xx_get_color_stn_01( device, data & 0x01); + *scanline++ = s3c24xx_get_color_stn_01( data & 0x01); data = data >> 1; } else { - *scanline++ = s3c24xx_get_color_stn_01( device, (data >> 31) & 0x01); + *scanline++ = s3c24xx_get_color_stn_01((data >> 31) & 0x01); data = data << 1; } - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 4)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 4)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_stn_02( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_stn_02() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 16; j++) { - *scanline++ = s3c24xx_get_color_stn_02( device, (data >> 30) & 0x03); + *scanline++ = s3c24xx_get_color_stn_02((data >> 30) & 0x03); data = data << 2; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 3)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 3)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_stn_04( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_stn_04() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 8; j++) { - *scanline++ = s3c24xx_get_color_stn_04( device, (data >> 28) & 0x0F); + *scanline++ = s3c24xx_get_color_stn_04((data >> 28) & 0x0F); data = data << 4; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 2)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 2)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_stn_08( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_stn_08() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 4; j++) { - *scanline++ = s3c24xx_get_color_stn_08( device, (data >> 24) & 0xFF); + *scanline++ = s3c24xx_get_color_stn_08((data >> 24) & 0xFF); data = data << 8; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 1)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 1)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_stn_12_p( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_stn_12_p() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 16; i++) { - *scanline++ = s3c24xx_get_color_stn_12( device, s3c24xx_lcd_dma_read_bits( device, 12)); - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max * 16 / 12)) + *scanline++ = s3c24xx_get_color_stn_12(s3c24xx_lcd_dma_read_bits(12)); + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max * 16 / 12)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } -static void s3c24xx_lcd_render_stn_12_u( device_t *device) // not tested +void S3C24_CLASS_NAME::s3c24xx_lcd_render_stn_12_u() // not tested { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 2; j++) { - *scanline++ = s3c24xx_get_color_stn_12( device, (data >> 16) & 0x0FFF); + *scanline++ = s3c24xx_get_color_stn_12((data >> 16) & 0x0FFF); data = data << 16; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 0)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 0)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_tft_01( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_tft_01() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 32; j++) { - *scanline++ = s3c24xx->m_palette->pen_color((data >> 31) & 0x01); + *scanline++ = m_palette->pen_color((data >> 31) & 0x01); data = data << 1; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 4)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 4)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_tft_02( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_tft_02() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 16; j++) { - *scanline++ = s3c24xx->m_palette->pen_color((data >> 30) & 0x03); + *scanline++ = m_palette->pen_color((data >> 30) & 0x03); data = data << 2; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 3)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 3)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_tft_04( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_tft_04() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 8; j++) { - *scanline++ = s3c24xx->m_palette->pen_color((data >> 28) & 0x0F); + *scanline++ = m_palette->pen_color((data >> 28) & 0x0F); data = data << 4; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 2)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 2)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_tft_08( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_tft_08() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 4; j++) { - *scanline++ = s3c24xx->m_palette->pen_color((data >> 24) & 0xFF); + *scanline++ = m_palette->pen_color((data >> 24) & 0xFF); data = data << 8; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 1)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 1)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static void s3c24xx_lcd_render_tft_16( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_render_tft_16() { - s3c24xx_t *s3c24xx = get_token( device); - bitmap_rgb32 &bitmap = *s3c24xx->lcd.bitmap[0]; - UINT32 *scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + bitmap_rgb32 &bitmap = *m_lcd.bitmap[0]; + UINT32 *scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); for (int i = 0; i < 4; i++) { - UINT32 data = s3c24xx_lcd_dma_read( device); + UINT32 data = s3c24xx_lcd_dma_read(); for (int j = 0; j < 2; j++) { - *scanline++ = s3c24xx_get_color_tft_16( device, (data >> 16) & 0xFFFF); + *scanline++ = s3c24xx_get_color_tft_16((data >> 16) & 0xFFFF); data = data << 16; - s3c24xx->lcd.hpos++; - if (s3c24xx->lcd.hpos >= s3c24xx->lcd.hpos_min + (s3c24xx->lcd.pagewidth_max << 0)) + m_lcd.hpos++; + if (m_lcd.hpos >= m_lcd.hpos_min + (m_lcd.pagewidth_max << 0)) { - s3c24xx->lcd.vpos++; - if (s3c24xx->lcd.vpos > s3c24xx->lcd.vpos_max) s3c24xx->lcd.vpos = s3c24xx->lcd.vpos_min; - s3c24xx->lcd.hpos = s3c24xx->lcd.hpos_min; - scanline = &bitmap.pix32(s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); + m_lcd.vpos++; + if (m_lcd.vpos > m_lcd.vpos_max) m_lcd.vpos = m_lcd.vpos_min; + m_lcd.hpos = m_lcd.hpos_min; + scanline = &bitmap.pix32(m_lcd.vpos, m_lcd.hpos); } } } } -static TIMER_CALLBACK( s3c24xx_lcd_timer_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_lcd_timer_exp ) { - device_t *device = (device_t *)ptr; - s3c24xx_t *s3c24xx = get_token( device); - screen_device *screen = machine.first_screen(); + screen_device *screen = machine().first_screen(); UINT32 tpalen; - verboselog( machine, 2, "LCD timer callback\n"); - s3c24xx->lcd.vpos = screen->vpos(); - s3c24xx->lcd.hpos = screen->hpos(); - verboselog( machine, 3, "LCD - vpos %d hpos %d\n", s3c24xx->lcd.vpos, s3c24xx->lcd.hpos); - tpalen = S3C24XX_TPAL_GET_TPALEN( s3c24xx->lcd.tpal); + verboselog( machine(), 2, "LCD timer callback\n"); + m_lcd.vpos = screen->vpos(); + m_lcd.hpos = screen->hpos(); + verboselog( machine(), 3, "LCD - vpos %d hpos %d\n", m_lcd.vpos, m_lcd.hpos); + tpalen = S3C24XX_TPAL_GET_TPALEN( m_lcd.tpal); if (tpalen == 0) { - if (s3c24xx->lcd.vramaddr_cur >= s3c24xx->lcd.vramaddr_max) + if (m_lcd.vramaddr_cur >= m_lcd.vramaddr_max) { - s3c24xx_lcd_dma_reload( device); + s3c24xx_lcd_dma_reload(); } - verboselog( machine, 3, "LCD - vramaddr %08X\n", s3c24xx->lcd.vramaddr_cur); - while (s3c24xx->lcd.vramaddr_cur < s3c24xx->lcd.vramaddr_max) + verboselog( machine(), 3, "LCD - vramaddr %08X\n", m_lcd.vramaddr_cur); + while (m_lcd.vramaddr_cur < m_lcd.vramaddr_max) { - switch (s3c24xx->lcd.bppmode) + switch (m_lcd.bppmode) { - case S3C24XX_BPPMODE_STN_01 : s3c24xx_lcd_render_stn_01( device); break; - case S3C24XX_BPPMODE_STN_02 : s3c24xx_lcd_render_stn_02( device); break; - case S3C24XX_BPPMODE_STN_04 : s3c24xx_lcd_render_stn_04( device); break; - case S3C24XX_BPPMODE_STN_08 : s3c24xx_lcd_render_stn_08( device); break; - case S3C24XX_BPPMODE_STN_12_P : s3c24xx_lcd_render_stn_12_p( device); break; - case S3C24XX_BPPMODE_STN_12_U : s3c24xx_lcd_render_stn_12_u( device); break; - case S3C24XX_BPPMODE_TFT_01 : s3c24xx_lcd_render_tft_01( device); break; - case S3C24XX_BPPMODE_TFT_02 : s3c24xx_lcd_render_tft_02( device); break; - case S3C24XX_BPPMODE_TFT_04 : s3c24xx_lcd_render_tft_04( device); break; - case S3C24XX_BPPMODE_TFT_08 : s3c24xx_lcd_render_tft_08( device); break; - case S3C24XX_BPPMODE_TFT_16 : s3c24xx_lcd_render_tft_16( device); break; - default : verboselog( machine, 0, "s3c24xx_lcd_timer_exp: bppmode %d not supported\n", s3c24xx->lcd.bppmode); break; + case S3C24XX_BPPMODE_STN_01 : s3c24xx_lcd_render_stn_01(); break; + case S3C24XX_BPPMODE_STN_02 : s3c24xx_lcd_render_stn_02(); break; + case S3C24XX_BPPMODE_STN_04 : s3c24xx_lcd_render_stn_04(); break; + case S3C24XX_BPPMODE_STN_08 : s3c24xx_lcd_render_stn_08(); break; + case S3C24XX_BPPMODE_STN_12_P : s3c24xx_lcd_render_stn_12_p(); break; + case S3C24XX_BPPMODE_STN_12_U : s3c24xx_lcd_render_stn_12_u(); break; + case S3C24XX_BPPMODE_TFT_01 : s3c24xx_lcd_render_tft_01(); break; + case S3C24XX_BPPMODE_TFT_02 : s3c24xx_lcd_render_tft_02(); break; + case S3C24XX_BPPMODE_TFT_04 : s3c24xx_lcd_render_tft_04(); break; + case S3C24XX_BPPMODE_TFT_08 : s3c24xx_lcd_render_tft_08(); break; + case S3C24XX_BPPMODE_TFT_16 : s3c24xx_lcd_render_tft_16(); break; + default : verboselog( machine(), 0, "s3c24xx_lcd_timer_exp: bppmode %d not supported\n", m_lcd.bppmode); break; } - if ((s3c24xx->lcd.vpos == s3c24xx->lcd.vpos_min) && (s3c24xx->lcd.hpos == s3c24xx->lcd.hpos_min)) break; + if ((m_lcd.vpos == m_lcd.vpos_min) && (m_lcd.hpos == m_lcd.hpos_min)) break; } } else { - s3c24xx_lcd_render_tpal( device); + s3c24xx_lcd_render_tpal(); } - s3c24xx->lcd.timer->adjust( screen->time_until_pos( s3c24xx->lcd.vpos, s3c24xx->lcd.hpos)); + m_lcd.timer->adjust( screen->time_until_pos( m_lcd.vpos, m_lcd.hpos)); } -static void s3c24xx_video_start( device_t *device, running_machine &machine) +void S3C24_CLASS_NAME::s3c24xx_video_start() { - s3c24xx_t *s3c24xx = get_token( device); - screen_device *screen = machine.first_screen(); - s3c24xx->lcd.bitmap[0] = auto_bitmap_rgb32_alloc(machine, screen->width(), screen->height()); - s3c24xx->lcd.bitmap[1] = auto_bitmap_rgb32_alloc(machine, screen->width(), screen->height()); + screen_device *screen = machine().first_screen(); + m_lcd.bitmap[0] = auto_bitmap_rgb32_alloc(machine(), screen->width(), screen->height()); + m_lcd.bitmap[1] = auto_bitmap_rgb32_alloc(machine(), screen->width(), screen->height()); } -static void bitmap_blend( bitmap_rgb32 &bitmap_dst, bitmap_rgb32 &bitmap_src_1, bitmap_rgb32 &bitmap_src_2) +void S3C24_CLASS_NAME::bitmap_blend( bitmap_rgb32 &bitmap_dst, bitmap_rgb32 &bitmap_src_1, bitmap_rgb32 &bitmap_src_2) { for (int y = 0; y < bitmap_dst.height(); y++) { @@ -812,128 +745,119 @@ static void bitmap_blend( bitmap_rgb32 &bitmap_dst, bitmap_rgb32 &bitmap_src_1, } } -static UINT32 s3c24xx_video_update( device_t *device, screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) +UINT32 S3C24_CLASS_NAME::s3c24xx_video_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { - s3c24xx_t *s3c24xx = get_token( device); - if (s3c24xx->lcd.regs.lcdcon1 & (1 << 0)) + if (m_lcd.regs.lcdcon1 & (1 << 0)) { - if (s3c24xx->lcd.framerate >= 1195) + if (m_lcd.framerate >= 1195) { - bitmap_blend( bitmap, *s3c24xx->lcd.bitmap[0], *s3c24xx->lcd.bitmap[1]); - copybitmap( *s3c24xx->lcd.bitmap[1], *s3c24xx->lcd.bitmap[0], 0, 0, 0, 0, cliprect); + bitmap_blend( bitmap, *m_lcd.bitmap[0], *m_lcd.bitmap[1]); + copybitmap( *m_lcd.bitmap[1], *m_lcd.bitmap[0], 0, 0, 0, 0, cliprect); } else { - copybitmap( bitmap, *s3c24xx->lcd.bitmap[0], 0, 0, 0, 0, cliprect); + copybitmap( bitmap, *m_lcd.bitmap[0], 0, 0, 0, 0, cliprect); } - s3c24xx_lcd_dma_init( device); + s3c24xx_lcd_dma_init(); } return 0; } -#if defined(DEVICE_S3C2400) -READ32_DEVICE_HANDLER( s3c2400_lcd_r ) -#elif defined(DEVICE_S3C2410) -READ32_DEVICE_HANDLER( s3c2410_lcd_r ) -#elif defined(DEVICE_S3C2440) -READ32_DEVICE_HANDLER( s3c2440_lcd_r ) -#endif + +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_lcd_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->lcd.regs)[offset]; + UINT32 data = ((UINT32*)&m_lcd.regs)[offset]; switch (offset) { case S3C24XX_LCDCON1 : { // make sure line counter is going - UINT32 vpos = device->machine().first_screen()->vpos(); - if (vpos < s3c24xx->lcd.vpos_min) vpos = s3c24xx->lcd.vpos_min; - if (vpos > s3c24xx->lcd.vpos_max) vpos = s3c24xx->lcd.vpos_max; - data = (data & ~0xFFFC0000) | ((s3c24xx->lcd.vpos_max - vpos) << 18); + UINT32 vpos = machine().first_screen()->vpos(); + if (vpos < m_lcd.vpos_min) vpos = m_lcd.vpos_min; + if (vpos > m_lcd.vpos_max) vpos = m_lcd.vpos_max; + data = (data & ~0xFFFC0000) | ((m_lcd.vpos_max - vpos) << 18); } break; case S3C24XX_LCDCON5 : { - UINT32 vpos = device->machine().first_screen()->vpos(); + UINT32 vpos = machine().first_screen()->vpos(); data = data & ~0x00018000; - if (vpos < s3c24xx->lcd.vpos_min) data = data | 0x00000000; - if (vpos > s3c24xx->lcd.vpos_max) data = data | 0x00018000; + if (vpos < m_lcd.vpos_min) data = data | 0x00000000; + if (vpos > m_lcd.vpos_max) data = data | 0x00018000; // todo: 00 = VSYNC, 01 = BACK Porch, 10 = ACTIVE, 11 = FRONT Porch } break; } - verboselog( device->machine(), 9, "(LCD) %08X -> %08X\n", S3C24XX_BASE_LCD + (offset << 2), data); + verboselog( machine(), 9, "(LCD) %08X -> %08X\n", S3C24XX_BASE_LCD + (offset << 2), data); return data; } -static int s3c24xx_lcd_configure_tft( device_t *device) +int S3C24_CLASS_NAME::s3c24xx_lcd_configure_tft() { - s3c24xx_t *s3c24xx = get_token( device); - screen_device *screen = device->machine().first_screen(); + screen_device *screen = machine().first_screen(); UINT32 vspw, vbpd, lineval, vfpd, hspw, hbpd, hfpd, hozval, clkval, hclk; double framerate, vclk; UINT32 width, height; rectangle visarea; - verboselog( device->machine(), 5, "s3c24xx_lcd_configure_tft\n"); - vspw = BITS( s3c24xx->lcd.regs.lcdcon2, 5, 0); - vbpd = BITS( s3c24xx->lcd.regs.lcdcon2, 31, 24); - lineval = BITS( s3c24xx->lcd.regs.lcdcon2, 23, 14); - vfpd = BITS( s3c24xx->lcd.regs.lcdcon2, 13, 6); - hspw = BITS( s3c24xx->lcd.regs.lcdcon4, 7, 0); - hbpd = BITS( s3c24xx->lcd.regs.lcdcon3, 25, 19); - hfpd = BITS( s3c24xx->lcd.regs.lcdcon3, 7, 0); - hozval = BITS( s3c24xx->lcd.regs.lcdcon3, 18, 8); - clkval = BITS( s3c24xx->lcd.regs.lcdcon1, 17, 8); - hclk = s3c24xx_get_hclk( device); - verboselog( device->machine(), 3, "LCD - vspw %d vbpd %d lineval %d vfpd %d hspw %d hbpd %d hfpd %d hozval %d clkval %d hclk %d\n", vspw, vbpd, lineval, vfpd, hspw, hbpd, hfpd, hozval, clkval, hclk); + verboselog( machine(), 5, "s3c24xx_lcd_configure_tft\n"); + vspw = BITS( m_lcd.regs.lcdcon2, 5, 0); + vbpd = BITS( m_lcd.regs.lcdcon2, 31, 24); + lineval = BITS( m_lcd.regs.lcdcon2, 23, 14); + vfpd = BITS( m_lcd.regs.lcdcon2, 13, 6); + hspw = BITS( m_lcd.regs.lcdcon4, 7, 0); + hbpd = BITS( m_lcd.regs.lcdcon3, 25, 19); + hfpd = BITS( m_lcd.regs.lcdcon3, 7, 0); + hozval = BITS( m_lcd.regs.lcdcon3, 18, 8); + clkval = BITS( m_lcd.regs.lcdcon1, 17, 8); + hclk = s3c24xx_get_hclk(); + verboselog( machine(), 3, "LCD - vspw %d vbpd %d lineval %d vfpd %d hspw %d hbpd %d hfpd %d hozval %d clkval %d hclk %d\n", vspw, vbpd, lineval, vfpd, hspw, hbpd, hfpd, hozval, clkval, hclk); vclk = (double)(hclk / ((clkval + 1) * 2)); - verboselog( device->machine(), 3, "LCD - vclk %f\n", vclk); + verboselog( machine(), 3, "LCD - vclk %f\n", vclk); framerate = vclk / (((vspw + 1) + (vbpd + 1) + (lineval + 1) + (vfpd + 1)) * ((hspw + 1) + (hbpd + 1) + (hozval + 1) + (hfpd + 1))); - verboselog( device->machine(), 3, "LCD - framerate %f\n", framerate); - s3c24xx->lcd.framerate = framerate; + verboselog( machine(), 3, "LCD - framerate %f\n", framerate); + m_lcd.framerate = framerate; width = (hspw + 1) + (hbpd + 1) + (hozval + 1) + (hfpd + 1); height = (vspw + 1) + (vbpd + 1) + (lineval + 1) + (vfpd + 1); visarea.min_x = (hspw + 1) + (hbpd + 1); visarea.min_y = (vspw + 1) + (vbpd + 1); visarea.max_x = visarea.min_x + (hozval + 1) - 1; visarea.max_y = visarea.min_y + (lineval + 1) - 1; - verboselog( device->machine(), 3, "LCD - visarea min_x %d min_y %d max_x %d max_y %d\n", visarea.min_x, visarea.min_y, visarea.max_x, visarea.max_y); - verboselog( device->machine(), 3, "video_screen_configure %d %d %f\n", width, height, s3c24xx->lcd.framerate); - s3c24xx->lcd.hpos_min = (hspw + 1) + (hbpd + 1); - s3c24xx->lcd.hpos_max = s3c24xx->lcd.hpos_min + (hozval + 1) - 1; - s3c24xx->lcd.vpos_min = (vspw + 1) + (vbpd + 1); - s3c24xx->lcd.vpos_max = s3c24xx->lcd.vpos_min + (lineval + 1) - 1; - screen->configure( width, height, visarea, HZ_TO_ATTOSECONDS( s3c24xx->lcd.framerate)); + verboselog( machine(), 3, "LCD - visarea min_x %d min_y %d max_x %d max_y %d\n", visarea.min_x, visarea.min_y, visarea.max_x, visarea.max_y); + verboselog( machine(), 3, "video_screen_configure %d %d %f\n", width, height, m_lcd.framerate); + m_lcd.hpos_min = (hspw + 1) + (hbpd + 1); + m_lcd.hpos_max = m_lcd.hpos_min + (hozval + 1) - 1; + m_lcd.vpos_min = (vspw + 1) + (vbpd + 1); + m_lcd.vpos_max = m_lcd.vpos_min + (lineval + 1) - 1; + screen->configure( width, height, visarea, HZ_TO_ATTOSECONDS( m_lcd.framerate)); return TRUE; } -static int s3c24xx_lcd_configure_stn( device_t *device) +int S3C24_CLASS_NAME::s3c24xx_lcd_configure_stn() { - s3c24xx_t *s3c24xx = get_token( device); - screen_device *screen = device->machine().first_screen(); + screen_device *screen = machine().first_screen(); UINT32 pnrmode, bppmode, clkval, lineval, wdly, hozval, lineblank, wlh, hclk; double vclk, framerate; UINT32 width, height; rectangle visarea; - verboselog( device->machine(), 5, "s3c24xx_lcd_configure_stn\n"); - pnrmode = BITS( s3c24xx->lcd.regs.lcdcon1, 6, 5); - bppmode = BITS( s3c24xx->lcd.regs.lcdcon1, 4, 1); - clkval = BITS( s3c24xx->lcd.regs.lcdcon1, 17, 8); - lineval = BITS( s3c24xx->lcd.regs.lcdcon2, 23, 14); - wdly = BITS( s3c24xx->lcd.regs.lcdcon3, 20, 19); - hozval = BITS( s3c24xx->lcd.regs.lcdcon3, 18, 8); - lineblank = BITS( s3c24xx->lcd.regs.lcdcon3, 7, 0); - wlh = BITS( s3c24xx->lcd.regs.lcdcon4, 1, 0); - hclk = s3c24xx_get_hclk( device); - verboselog( device->machine(), 3, "LCD - pnrmode %d bppmode %d clkval %d lineval %d wdly %d hozval %d lineblank %d wlh %d hclk %d\n", pnrmode, bppmode, clkval, lineval, wdly, hozval, lineblank, wlh, hclk); + verboselog( machine(), 5, "s3c24xx_lcd_configure_stn\n"); + pnrmode = BITS( m_lcd.regs.lcdcon1, 6, 5); + bppmode = BITS( m_lcd.regs.lcdcon1, 4, 1); + clkval = BITS( m_lcd.regs.lcdcon1, 17, 8); + lineval = BITS( m_lcd.regs.lcdcon2, 23, 14); + wdly = BITS( m_lcd.regs.lcdcon3, 20, 19); + hozval = BITS( m_lcd.regs.lcdcon3, 18, 8); + lineblank = BITS( m_lcd.regs.lcdcon3, 7, 0); + wlh = BITS( m_lcd.regs.lcdcon4, 1, 0); + hclk = s3c24xx_get_hclk(); + verboselog( machine(), 3, "LCD - pnrmode %d bppmode %d clkval %d lineval %d wdly %d hozval %d lineblank %d wlh %d hclk %d\n", pnrmode, bppmode, clkval, lineval, wdly, hozval, lineblank, wlh, hclk); if (clkval == 0) { return FALSE; } vclk = (double)(hclk / ((clkval + 0) * 2)); - verboselog( device->machine(), 3, "LCD - vclk %f\n", vclk); + verboselog( machine(), 3, "LCD - vclk %f\n", vclk); framerate = 1 / (((1 / vclk) * (hozval + 1) + (1 / hclk) * ((1 << (4 + wlh)) + (1 << (4 + wdly)) + (lineblank * 8))) * (lineval + 1)); - verboselog( device->machine(), 3, "LCD - framerate %f\n", framerate); + verboselog( machine(), 3, "LCD - framerate %f\n", framerate); switch (pnrmode) { case S3C24XX_PNRMODE_STN_04_SS : width = ((hozval + 1) * 4); break; @@ -942,79 +866,74 @@ static int s3c24xx_lcd_configure_stn( device_t *device) default : width = 0; break; } height = lineval + 1; - s3c24xx->lcd.framerate = framerate; + m_lcd.framerate = framerate; visarea.set(0, width - 1, 0, height - 1); - verboselog( device->machine(), 3, "LCD - visarea min_x %d min_y %d max_x %d max_y %d\n", visarea.min_x, visarea.min_y, visarea.max_x, visarea.max_y); - verboselog( device->machine(), 3, "video_screen_configure %d %d %f\n", width, height, s3c24xx->lcd.framerate); - s3c24xx->lcd.hpos_min = 0; - s3c24xx->lcd.hpos_max = width - 1; - s3c24xx->lcd.vpos_min = 0; - s3c24xx->lcd.vpos_max = height - 1; - screen->configure( width, height, visarea, HZ_TO_ATTOSECONDS( s3c24xx->lcd.framerate)); + verboselog( machine(), 3, "LCD - visarea min_x %d min_y %d max_x %d max_y %d\n", visarea.min_x, visarea.min_y, visarea.max_x, visarea.max_y); + verboselog( machine(), 3, "video_screen_configure %d %d %f\n", width, height, m_lcd.framerate); + m_lcd.hpos_min = 0; + m_lcd.hpos_max = width - 1; + m_lcd.vpos_min = 0; + m_lcd.vpos_max = height - 1; + screen->configure( width, height, visarea, HZ_TO_ATTOSECONDS( m_lcd.framerate)); return TRUE; } -static int s3c24xx_lcd_configure( device_t *device) +int S3C24_CLASS_NAME::s3c24xx_lcd_configure() { - s3c24xx_t *s3c24xx = get_token( device); UINT32 bppmode; - verboselog( device->machine(), 5, "s3c24xx_lcd_configure\n"); - bppmode = BITS( s3c24xx->lcd.regs.lcdcon1, 4, 1); + verboselog( machine(), 5, "s3c24xx_lcd_configure\n"); + bppmode = BITS( m_lcd.regs.lcdcon1, 4, 1); if ((bppmode & (1 << 3)) == 0) { - return s3c24xx_lcd_configure_stn( device); + return s3c24xx_lcd_configure_stn(); } else { - return s3c24xx_lcd_configure_tft( device); + return s3c24xx_lcd_configure_tft(); } } -static void s3c24xx_lcd_start( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_start() { - s3c24xx_t *s3c24xx = get_token( device); - screen_device *screen = device->machine().first_screen(); - verboselog( device->machine(), 1, "LCD start\n"); - if (s3c24xx_lcd_configure( device)) + screen_device *screen = machine().first_screen(); + verboselog( machine(), 1, "LCD start\n"); + if (s3c24xx_lcd_configure()) { - s3c24xx_lcd_dma_init( device); - s3c24xx->lcd.timer->adjust( screen->time_until_pos( s3c24xx->lcd.vpos_min, s3c24xx->lcd.hpos_min)); + s3c24xx_lcd_dma_init(); + m_lcd.timer->adjust( screen->time_until_pos( m_lcd.vpos_min, m_lcd.hpos_min)); } } -static void s3c24xx_lcd_stop( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_stop() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 1, "LCD stop\n"); - s3c24xx->lcd.timer->adjust( attotime::never); + verboselog( machine(), 1, "LCD stop\n"); + m_lcd.timer->adjust( attotime::never); } -static void s3c24xx_lcd_recalc( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_lcd_recalc() { - s3c24xx_t *s3c24xx = get_token( device); - if (s3c24xx->lcd.regs.lcdcon1 & (1 << 0)) + if (m_lcd.regs.lcdcon1 & (1 << 0)) { - s3c24xx_lcd_start( device); + s3c24xx_lcd_start(); } else { - s3c24xx_lcd_stop( device); + s3c24xx_lcd_stop(); } } -static WRITE32_DEVICE_HANDLER( s3c24xx_lcd_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_lcd_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->lcd.regs)[offset]; - verboselog( device->machine(), 9, "(LCD) %08X <- %08X\n", S3C24XX_BASE_LCD + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->lcd.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_lcd.regs)[offset]; + verboselog( machine(), 9, "(LCD) %08X <- %08X\n", S3C24XX_BASE_LCD + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_lcd.regs)[offset]); switch (offset) { case S3C24XX_LCDCON1 : { if ((old_value & (1 << 0)) != (data & (1 << 0))) { - s3c24xx_lcd_recalc( device); + s3c24xx_lcd_recalc(); } } break; @@ -1023,32 +942,29 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_lcd_w ) /* LCD Palette */ -static READ32_DEVICE_HANDLER( s3c24xx_lcd_palette_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_lcd_palette_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->lcdpal.regs.data[offset]; - verboselog( device->machine(), 9, "(LCD) %08X -> %08X\n", S3C24XX_BASE_LCDPAL + (offset << 2), data); + UINT32 data = m_lcdpal.regs.data[offset]; + verboselog( machine(), 9, "(LCD) %08X -> %08X\n", S3C24XX_BASE_LCDPAL + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_lcd_palette_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_lcd_palette_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(LCD) %08X <- %08X\n", S3C24XX_BASE_LCDPAL + (offset << 2), data); - COMBINE_DATA(&s3c24xx->lcdpal.regs.data[offset]); + verboselog( machine(), 9, "(LCD) %08X <- %08X\n", S3C24XX_BASE_LCDPAL + (offset << 2), data); + COMBINE_DATA(&m_lcdpal.regs.data[offset]); if (mem_mask != 0xffffffff) { - verboselog( device->machine(), 0, "s3c24xx_lcd_palette_w: unknown mask %08x\n", mem_mask); + verboselog( machine(), 0, "s3c24xx_lcd_palette_w: unknown mask %08x\n", mem_mask); } - s3c24xx->m_palette->set_pen_color( offset, s3c24xx_get_color_tft_16( device, data & 0xFFFF)); + m_palette->set_pen_color( offset, s3c24xx_get_color_tft_16(data & 0xFFFF)); } /* Clock & Power Management */ -static void s3c24xx_clkpow_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_clkpow_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_clkpow_t *clkpow = &s3c24xx->clkpow; + s3c24xx_clkpow_t *clkpow = &m_clkpow; memset( &clkpow->regs, 0, sizeof( clkpow->regs)); #if defined(DEVICE_S3C2400) clkpow->regs.locktime = 0x00FFFFFF; @@ -1069,23 +985,22 @@ static void s3c24xx_clkpow_reset( device_t *device) clkpow->regs.clkslow = 4; } -static UINT32 s3c24xx_get_fclk( device_t *device) +UINT32 S3C24_CLASS_NAME::s3c24xx_get_fclk() { - s3c24xx_t *s3c24xx = get_token( device); UINT32 mpllcon, clkslow, mdiv, pdiv, sdiv, fclk; double temp1, temp2; - mpllcon = s3c24xx->clkpow.regs.mpllcon; + mpllcon = m_clkpow.regs.mpllcon; mdiv = BITS( mpllcon, 19, 12); pdiv = BITS( mpllcon, 9, 4); sdiv = BITS( mpllcon, 1, 0); #if defined(DEVICE_S3C2400) || defined(DEVICE_S3C2410) - temp1 = 1 * (mdiv + 8) * (double)device->clock(); + temp1 = 1 * (mdiv + 8) * (double)clock(); #else - temp1 = 2 * (mdiv + 8) * (double)device->clock(); + temp1 = 2 * (mdiv + 8) * (double)clock(); #endif temp2 = (double)((pdiv + 2) * (1 << sdiv)); fclk = (UINT32)(temp1 / temp2); - clkslow = s3c24xx->clkpow.regs.clkslow; + clkslow = m_clkpow.regs.clkslow; if (BIT( clkslow, 4) == 1) { UINT32 slow_val = BITS( clkslow, 2, 0); @@ -1097,54 +1012,50 @@ static UINT32 s3c24xx_get_fclk( device_t *device) return fclk; } -static UINT32 s3c24xx_get_hclk( device_t *device) +UINT32 S3C24_CLASS_NAME::s3c24xx_get_hclk() { - s3c24xx_t *s3c24xx = get_token( device); #if defined(DEVICE_S3C2400) || defined(DEVICE_S3C2410) - return s3c24xx_get_fclk( device) / (BIT( s3c24xx->clkpow.regs.clkdivn, 1) + 1); + return s3c24xx_get_fclk() / (BIT( m_clkpow.regs.clkdivn, 1) + 1); #else - switch (BITS( s3c24xx->clkpow.regs.clkdivn, 2, 1)) + switch (BITS( m_clkpow.regs.clkdivn, 2, 1)) { - case 0 : return s3c24xx_get_fclk( device) / 1; - case 1 : return s3c24xx_get_fclk( device) / 2; - case 2 : return s3c24xx_get_fclk( device) / (4 * (BIT( s3c24xx->clkpow.regs.camdivn, 9) + 1)); - case 3 : return s3c24xx_get_fclk( device) / (3 * (BIT( s3c24xx->clkpow.regs.camdivn, 8) + 1)); + case 0 : return s3c24xx_get_fclk() / 1; + case 1 : return s3c24xx_get_fclk() / 2; + case 2 : return s3c24xx_get_fclk() / (4 * (BIT( m_clkpow.regs.camdivn, 9) + 1)); + case 3 : return s3c24xx_get_fclk() / (3 * (BIT( m_clkpow.regs.camdivn, 8) + 1)); } return 0; #endif } -static UINT32 s3c24xx_get_pclk( device_t *device) +UINT32 S3C24_CLASS_NAME::s3c24xx_get_pclk() { - s3c24xx_t *s3c24xx = get_token( device); - return s3c24xx_get_hclk( device) / (1 << BIT( s3c24xx->clkpow.regs.clkdivn, 0)); + return s3c24xx_get_hclk() / (1 << BIT( m_clkpow.regs.clkdivn, 0)); } -static READ32_DEVICE_HANDLER( s3c24xx_clkpow_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_clkpow_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->clkpow.regs)[offset]; - verboselog( device->machine(), 9, "(CLKPOW) %08X -> %08X\n", S3C24XX_BASE_CLKPOW + (offset << 2), data); + UINT32 data = ((UINT32*)&m_clkpow.regs)[offset]; + verboselog(machine(), 9, "(CLKPOW) %08X -> %08X\n", S3C24XX_BASE_CLKPOW + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_clkpow_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_clkpow_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(CLKPOW) %08X <- %08X\n", S3C24XX_BASE_CLKPOW + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->clkpow.regs)[offset]); + verboselog( machine(), 9, "(CLKPOW) %08X <- %08X\n", S3C24XX_BASE_CLKPOW + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_clkpow.regs)[offset]); switch (offset) { case S3C24XX_MPLLCON : { - verboselog( device->machine(), 5, "CLKPOW - fclk %d hclk %d pclk %d\n", s3c24xx_get_fclk( device), s3c24xx_get_hclk( device), s3c24xx_get_pclk( device)); - s3c24xx->m_cpu->set_unscaled_clock(s3c24xx_get_fclk( device) * CLOCK_MULTIPLIER); + verboselog( machine(), 5, "CLKPOW - fclk %d hclk %d pclk %d\n", s3c24xx_get_fclk(), s3c24xx_get_hclk(), s3c24xx_get_pclk()); + m_cpu->set_unscaled_clock(s3c24xx_get_fclk() * CLOCK_MULTIPLIER); } break; case S3C24XX_CLKSLOW : { - verboselog( device->machine(), 5, "CLKPOW - fclk %d hclk %d pclk %d\n", s3c24xx_get_fclk( device), s3c24xx_get_hclk( device), s3c24xx_get_pclk( device)); - s3c24xx->m_cpu->set_unscaled_clock(s3c24xx_get_fclk( device) * CLOCK_MULTIPLIER); + verboselog( machine(), 5, "CLKPOW - fclk %d hclk %d pclk %d\n", s3c24xx_get_fclk(), s3c24xx_get_hclk(), s3c24xx_get_pclk()); + m_cpu->set_unscaled_clock(s3c24xx_get_fclk() * CLOCK_MULTIPLIER); } break; } @@ -1152,10 +1063,9 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_clkpow_w ) /* Interrupt Controller */ -static void s3c24xx_irq_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_irq_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_irq_t *irq = &s3c24xx->irq; + s3c24xx_irq_t *irq = &m_irq; memset( &irq->regs, 0, sizeof( irq->regs)); irq->line_irq = irq->line_fiq = CLEAR_LINE; irq->regs.intmsk = 0xFFFFFFFF; @@ -1167,48 +1077,47 @@ static void s3c24xx_irq_reset( device_t *device) #endif } -static void s3c24xx_check_pending_irq( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_check_pending_irq() { - s3c24xx_t *s3c24xx = get_token( device); UINT32 temp; // normal irq - if ((s3c24xx->irq.regs.intpnd == 0) && (s3c24xx->irq.regs.intoffset == 0)) // without this "touryuu" crashes + if ((m_irq.regs.intpnd == 0) && (m_irq.regs.intoffset == 0)) // without this "touryuu" crashes { - temp = (s3c24xx->irq.regs.srcpnd & ~s3c24xx->irq.regs.intmsk) & ~s3c24xx->irq.regs.intmod; + temp = (m_irq.regs.srcpnd & ~m_irq.regs.intmsk) & ~m_irq.regs.intmod; if (temp != 0) { UINT32 int_type = 0; - verboselog( device->machine(), 5, "srcpnd %08X intmsk %08X intmod %08X\n", s3c24xx->irq.regs.srcpnd, s3c24xx->irq.regs.intmsk, s3c24xx->irq.regs.intmod); + verboselog( machine(), 5, "srcpnd %08X intmsk %08X intmod %08X\n", m_irq.regs.srcpnd, m_irq.regs.intmsk, m_irq.regs.intmod); while ((temp & 1) == 0) { int_type++; temp = temp >> 1; } - verboselog( device->machine(), 5, "intpnd set bit %d\n", int_type); - s3c24xx->irq.regs.intpnd |= (1 << int_type); - s3c24xx->irq.regs.intoffset = int_type; - if (s3c24xx->irq.line_irq != ASSERT_LINE) + verboselog( machine(), 5, "intpnd set bit %d\n", int_type); + m_irq.regs.intpnd |= (1 << int_type); + m_irq.regs.intoffset = int_type; + if (m_irq.line_irq != ASSERT_LINE) { - verboselog( device->machine(), 5, "ARM7_IRQ_LINE -> ASSERT_LINE\n"); - s3c24xx->m_cpu->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE); - s3c24xx->irq.line_irq = ASSERT_LINE; + verboselog( machine(), 5, "ARM7_IRQ_LINE -> ASSERT_LINE\n"); + m_cpu->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE); + m_irq.line_irq = ASSERT_LINE; } } else { - if (s3c24xx->irq.line_irq != CLEAR_LINE) + if (m_irq.line_irq != CLEAR_LINE) { - verboselog( device->machine(), 5, "srcpnd %08X intmsk %08X intmod %08X\n", s3c24xx->irq.regs.srcpnd, s3c24xx->irq.regs.intmsk, s3c24xx->irq.regs.intmod); - verboselog( device->machine(), 5, "ARM7_IRQ_LINE -> CLEAR_LINE\n"); - s3c24xx->m_cpu->execute().set_input_line(ARM7_IRQ_LINE, CLEAR_LINE); - s3c24xx->irq.line_irq = CLEAR_LINE; + verboselog( machine(), 5, "srcpnd %08X intmsk %08X intmod %08X\n", m_irq.regs.srcpnd, m_irq.regs.intmsk, m_irq.regs.intmod); + verboselog( machine(), 5, "ARM7_IRQ_LINE -> CLEAR_LINE\n"); + m_cpu->execute().set_input_line(ARM7_IRQ_LINE, CLEAR_LINE); + m_irq.line_irq = CLEAR_LINE; } } } // fast irq - temp = (s3c24xx->irq.regs.srcpnd & ~s3c24xx->irq.regs.intmsk) & s3c24xx->irq.regs.intmod; + temp = (m_irq.regs.srcpnd & ~m_irq.regs.intmsk) & m_irq.regs.intmod; if (temp != 0) { UINT32 int_type = 0; @@ -1217,38 +1126,36 @@ static void s3c24xx_check_pending_irq( device_t *device) int_type++; temp = temp >> 1; } - if (s3c24xx->irq.line_fiq != ASSERT_LINE) + if (m_irq.line_fiq != ASSERT_LINE) { - verboselog( device->machine(), 5, "ARM7_FIRQ_LINE -> ASSERT_LINE\n"); - s3c24xx->m_cpu->execute().set_input_line(ARM7_FIRQ_LINE, ASSERT_LINE); - s3c24xx->irq.line_fiq = ASSERT_LINE; + verboselog( machine(), 5, "ARM7_FIRQ_LINE -> ASSERT_LINE\n"); + m_cpu->execute().set_input_line(ARM7_FIRQ_LINE, ASSERT_LINE); + m_irq.line_fiq = ASSERT_LINE; } } else { - if (s3c24xx->irq.line_fiq != CLEAR_LINE) + if (m_irq.line_fiq != CLEAR_LINE) { - verboselog( device->machine(), 5, "ARM7_FIRQ_LINE -> CLEAR_LINE\n"); - s3c24xx->m_cpu->execute().set_input_line(ARM7_FIRQ_LINE, CLEAR_LINE); - s3c24xx->irq.line_fiq = CLEAR_LINE; + verboselog( machine(), 5, "ARM7_FIRQ_LINE -> CLEAR_LINE\n"); + m_cpu->execute().set_input_line(ARM7_FIRQ_LINE, CLEAR_LINE); + m_irq.line_fiq = CLEAR_LINE; } } } -static void s3c24xx_request_irq( device_t *device, UINT32 int_type) +void S3C24_CLASS_NAME::s3c24xx_request_irq(UINT32 int_type) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "request irq %d\n", int_type); - s3c24xx->irq.regs.srcpnd |= (1 << int_type); - s3c24xx_check_pending_irq( device); + verboselog( machine(), 5, "request irq %d\n", int_type); + m_irq.regs.srcpnd |= (1 << int_type); + s3c24xx_check_pending_irq(); } #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static void s3c24xx_check_pending_subirq( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_check_pending_subirq() { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 temp = s3c24xx->irq.regs.subsrcpnd & ~s3c24xx->irq.regs.intsubmsk; + UINT32 temp = m_irq.regs.subsrcpnd & ~m_irq.regs.intsubmsk; if (temp != 0) { UINT32 int_type = 0; @@ -1257,22 +1164,20 @@ static void s3c24xx_check_pending_subirq( device_t *device) int_type++; temp = temp >> 1; } - s3c24xx_request_irq( device, MAP_SUBINT_TO_INT[int_type]); + s3c24xx_request_irq( MAP_SUBINT_TO_INT[int_type]); } } -ATTR_UNUSED static void s3c24xx_request_subirq( device_t *device, UINT32 int_type) +ATTR_UNUSED void S3C24_CLASS_NAME::s3c24xx_request_subirq( UINT32 int_type) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "request subirq %d\n", int_type); - s3c24xx->irq.regs.subsrcpnd |= (1 << int_type); - s3c24xx_check_pending_subirq( device); + verboselog( machine(), 5, "request subirq %d\n", int_type); + m_irq.regs.subsrcpnd |= (1 << int_type); + s3c24xx_check_pending_subirq(); } -static void s3c24xx_check_pending_eint( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_check_pending_eint() { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 temp = s3c24xx->gpio.regs.eintpend & ~s3c24xx->gpio.regs.eintmask; + UINT32 temp = m_gpio.regs.eintpend & ~m_gpio.regs.eintmask; if (temp != 0) { UINT32 int_type = 0; @@ -1283,77 +1188,74 @@ static void s3c24xx_check_pending_eint( device_t *device) } if (int_type < 8) { - s3c24xx_request_irq( device, S3C24XX_INT_EINT4_7); + s3c24xx_request_irq(S3C24XX_INT_EINT4_7); } else { - s3c24xx_request_irq( device, S3C24XX_INT_EINT8_23); + s3c24xx_request_irq(S3C24XX_INT_EINT8_23); } } } -ATTR_UNUSED static void s3c24xx_request_eint( device_t *device, UINT32 number) +ATTR_UNUSED void S3C24_CLASS_NAME::s3c24xx_request_eint(UINT32 number) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "request external interrupt %d\n", number); + verboselog( machine(), 5, "request external interrupt %d\n", number); if (number < 4) { - s3c24xx_request_irq( device, S3C24XX_INT_EINT0 + number); + s3c24xx_request_irq( S3C24XX_INT_EINT0 + number); } else { - s3c24xx->gpio.regs.eintpend |= (1 << number); - s3c24xx_check_pending_eint( device); + m_gpio.regs.eintpend |= (1 << number); + s3c24xx_check_pending_eint(); } } #endif -static READ32_DEVICE_HANDLER( s3c24xx_irq_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_irq_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->irq.regs)[offset]; - verboselog( device->machine(), 9, "(IRQ) %08X -> %08X\n", S3C24XX_BASE_INT + (offset << 2), data); + UINT32 data = ((UINT32*)&m_irq.regs)[offset]; + verboselog( machine(), 9, "(IRQ) %08X -> %08X\n", S3C24XX_BASE_INT + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_irq_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_irq_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->irq.regs)[offset]; - verboselog( device->machine(), 9, "(IRQ) %08X <- %08X\n", S3C24XX_BASE_INT + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->irq.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_irq.regs)[offset]; + verboselog( machine(), 9, "(IRQ) %08X <- %08X\n", S3C24XX_BASE_INT + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_irq.regs)[offset]); switch (offset) { case S3C24XX_SRCPND : { - s3c24xx->irq.regs.srcpnd = (old_value & ~data); // clear only the bit positions of SRCPND corresponding to those set to one in the data - s3c24xx->irq.regs.intoffset = 0; // "This bit can be cleared automatically by clearing SRCPND and INTPND." - s3c24xx_check_pending_irq( device); + m_irq.regs.srcpnd = (old_value & ~data); // clear only the bit positions of SRCPND corresponding to those set to one in the data + m_irq.regs.intoffset = 0; // "This bit can be cleared automatically by clearing SRCPND and INTPND." + s3c24xx_check_pending_irq(); } break; case S3C24XX_INTMSK : { - s3c24xx_check_pending_irq( device); + s3c24xx_check_pending_irq(); } break; case S3C24XX_INTPND : { - s3c24xx->irq.regs.intpnd = (old_value & ~data); // clear only the bit positions of INTPND corresponding to those set to one in the data - s3c24xx->irq.regs.intoffset = 0; // "This bit can be cleared automatically by clearing SRCPND and INTPND." - s3c24xx_check_pending_irq( device); + m_irq.regs.intpnd = (old_value & ~data); // clear only the bit positions of INTPND corresponding to those set to one in the data + m_irq.regs.intoffset = 0; // "This bit can be cleared automatically by clearing SRCPND and INTPND." + s3c24xx_check_pending_irq(); } break; #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) case S3C24XX_SUBSRCPND : { - s3c24xx->irq.regs.subsrcpnd = (old_value & ~data); // clear only the bit positions of SRCPND corresponding to those set to one in the data - s3c24xx_check_pending_subirq( device); + m_irq.regs.subsrcpnd = (old_value & ~data); // clear only the bit positions of SRCPND corresponding to those set to one in the data + s3c24xx_check_pending_subirq(); } break; case S3C24XX_INTSUBMSK : { - s3c24xx_check_pending_subirq( device); + s3c24xx_check_pending_subirq(); } break; #endif @@ -1362,10 +1264,9 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_irq_w ) /* PWM Timer */ -static void s3c24xx_pwm_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_pwm_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_pwm_t *pwm = &s3c24xx->pwm; + s3c24xx_pwm_t *pwm = &m_pwm; memset( &pwm->regs, 0, sizeof( pwm->regs)); for (int i = 0; i < 5; i++) { @@ -1373,69 +1274,66 @@ static void s3c24xx_pwm_reset( device_t *device) } } -static UINT16 s3c24xx_pwm_calc_observation( device_t *device, int ch) +UINT16 S3C24_CLASS_NAME::s3c24xx_pwm_calc_observation(int ch) { - s3c24xx_t *s3c24xx = get_token( device); double timeleft, x1, x2; UINT32 cnto; - timeleft = s3c24xx->pwm.timer[ch]->remaining( ).as_double(); -// printf( "timeleft %f freq %d cntb %d cmpb %d\n", timeleft, s3c24xx->pwm.freq[ch], s3c24xx->pwm.cnt[ch], s3c24xx->pwm.cmp[ch]); - x1 = 1 / ((double)s3c24xx->pwm.freq[ch] / (s3c24xx->pwm.cnt[ch]- s3c24xx->pwm.cmp[ch] + 1)); + timeleft = m_pwm.timer[ch]->remaining( ).as_double(); +// printf( "timeleft %f freq %d cntb %d cmpb %d\n", timeleft, m_pwm.freq[ch], m_pwm.cnt[ch], m_pwm.cmp[ch]); + x1 = 1 / ((double)m_pwm.freq[ch] / (m_pwm.cnt[ch]- m_pwm.cmp[ch] + 1)); x2 = x1 / timeleft; // printf( "x1 %f\n", x1); - cnto = s3c24xx->pwm.cmp[ch] + ((s3c24xx->pwm.cnt[ch]- s3c24xx->pwm.cmp[ch]) / x2); + cnto = m_pwm.cmp[ch] + ((m_pwm.cnt[ch]- m_pwm.cmp[ch]) / x2); // printf( "cnto %d\n", cnto); return cnto; } -static READ32_DEVICE_HANDLER( s3c24xx_pwm_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_pwm_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->pwm.regs)[offset]; + UINT32 data = ((UINT32*)&m_pwm.regs)[offset]; switch (offset) { case S3C24XX_TCNTO0 : { - data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( device, 0); + data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( 0); } break; case S3C24XX_TCNTO1 : { - data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( device, 1); + data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( 1); } break; case S3C24XX_TCNTO2 : { - data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( device, 2); + data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( 2); } break; case S3C24XX_TCNTO3 : { - data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( device, 3); + data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( 3); } break; case S3C24XX_TCNTO4 : { - data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( device, 4); + data = (data & ~0x0000FFFF) | s3c24xx_pwm_calc_observation( 4); } break; } - verboselog( device->machine(), 9, "(PWM) %08X -> %08X\n", S3C24XX_BASE_PWM + (offset << 2), data); + verboselog( machine(), 9, "(PWM) %08X -> %08X\n", S3C24XX_BASE_PWM + (offset << 2), data); return data; } -static void s3c24xx_pwm_start( device_t *device, int timer) +void S3C24_CLASS_NAME::s3c24xx_pwm_start(int timer) { - s3c24xx_t *s3c24xx = get_token( device); const int mux_table[] = { 2, 4, 8, 16}; const int prescaler_shift[] = { 0, 0, 8, 8, 8}; const int mux_shift[] = { 0, 4, 8, 12, 16}; UINT32 pclk, prescaler, mux, cnt, cmp, auto_reload; double freq, hz; - verboselog( device->machine(), 1, "PWM %d start\n", timer); - pclk = s3c24xx_get_pclk( device); - prescaler = (s3c24xx->pwm.regs.tcfg0 >> prescaler_shift[timer]) & 0xFF; - mux = (s3c24xx->pwm.regs.tcfg1 >> mux_shift[timer]) & 0x0F; + verboselog( machine(), 1, "PWM %d start\n", timer); + pclk = s3c24xx_get_pclk(); + prescaler = (m_pwm.regs.tcfg0 >> prescaler_shift[timer]) & 0xFF; + mux = (m_pwm.regs.tcfg1 >> mux_shift[timer]) & 0x0F; if (mux < 4) { freq = (double)pclk / (prescaler + 1) / mux_table[mux]; @@ -1449,37 +1347,37 @@ static void s3c24xx_pwm_start( device_t *device, int timer) { case 0 : { - cnt = BITS( s3c24xx->pwm.regs.tcntb0, 15, 0); - cmp = BITS( s3c24xx->pwm.regs.tcmpb0, 15, 0); - auto_reload = BIT( s3c24xx->pwm.regs.tcon, 3); + cnt = BITS( m_pwm.regs.tcntb0, 15, 0); + cmp = BITS( m_pwm.regs.tcmpb0, 15, 0); + auto_reload = BIT( m_pwm.regs.tcon, 3); } break; case 1 : { - cnt = BITS( s3c24xx->pwm.regs.tcntb1, 15, 0); - cmp = BITS( s3c24xx->pwm.regs.tcmpb1, 15, 0); - auto_reload = BIT( s3c24xx->pwm.regs.tcon, 11); + cnt = BITS( m_pwm.regs.tcntb1, 15, 0); + cmp = BITS( m_pwm.regs.tcmpb1, 15, 0); + auto_reload = BIT( m_pwm.regs.tcon, 11); } break; case 2 : { - cnt = BITS( s3c24xx->pwm.regs.tcntb2, 15, 0); - cmp = BITS( s3c24xx->pwm.regs.tcmpb2, 15, 0); - auto_reload = BIT( s3c24xx->pwm.regs.tcon, 15); + cnt = BITS( m_pwm.regs.tcntb2, 15, 0); + cmp = BITS( m_pwm.regs.tcmpb2, 15, 0); + auto_reload = BIT( m_pwm.regs.tcon, 15); } break; case 3 : { - cnt = BITS( s3c24xx->pwm.regs.tcntb3, 15, 0); - cmp = BITS( s3c24xx->pwm.regs.tcmpb3, 15, 0); - auto_reload = BIT( s3c24xx->pwm.regs.tcon, 19); + cnt = BITS( m_pwm.regs.tcntb3, 15, 0); + cmp = BITS( m_pwm.regs.tcmpb3, 15, 0); + auto_reload = BIT( m_pwm.regs.tcon, 19); } break; case 4 : { - cnt = BITS( s3c24xx->pwm.regs.tcntb4, 15, 0); + cnt = BITS( m_pwm.regs.tcntb4, 15, 0); cmp = 0; - auto_reload = BIT( s3c24xx->pwm.regs.tcon, 22); + auto_reload = BIT( m_pwm.regs.tcon, 22); } break; default : @@ -1497,124 +1395,116 @@ static void s3c24xx_pwm_start( device_t *device, int timer) { hz = freq / cnt; } - verboselog( device->machine(), 5, "PWM %d - pclk=%d prescaler=%d div=%d freq=%f cnt=%d cmp=%d auto_reload=%d hz=%f\n", timer, pclk, prescaler, mux_table[mux], freq, cnt, cmp, auto_reload, hz); - s3c24xx->pwm.cnt[timer] = cnt; - s3c24xx->pwm.cmp[timer] = cmp; - s3c24xx->pwm.freq[timer] = freq; + verboselog( machine(), 5, "PWM %d - pclk=%d prescaler=%d div=%d freq=%f cnt=%d cmp=%d auto_reload=%d hz=%f\n", timer, pclk, prescaler, mux_table[mux], freq, cnt, cmp, auto_reload, hz); + m_pwm.cnt[timer] = cnt; + m_pwm.cmp[timer] = cmp; + m_pwm.freq[timer] = freq; if (auto_reload) { - s3c24xx->pwm.timer[timer]->adjust( attotime::from_hz( hz), timer, attotime::from_hz( hz)); + m_pwm.timer[timer]->adjust( attotime::from_hz( hz), timer, attotime::from_hz( hz)); } else { - s3c24xx->pwm.timer[timer]->adjust( attotime::from_hz( hz), timer); + m_pwm.timer[timer]->adjust( attotime::from_hz( hz), timer); } } -static void s3c24xx_pwm_stop( device_t *device, int timer) +void S3C24_CLASS_NAME::s3c24xx_pwm_stop(int timer) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 1, "PWM %d stop\n", timer); - s3c24xx->pwm.timer[timer]->adjust( attotime::never); + verboselog( machine(), 1, "PWM %d stop\n", timer); + m_pwm.timer[timer]->adjust( attotime::never); } -static void s3c24xx_pwm_recalc( device_t *device, int timer) +void S3C24_CLASS_NAME::s3c24xx_pwm_recalc(int timer) { - s3c24xx_t *s3c24xx = get_token( device); const int tcon_shift[] = { 0, 8, 12, 16, 20}; - if (s3c24xx->pwm.regs.tcon & (1 << tcon_shift[timer])) + if (m_pwm.regs.tcon & (1 << tcon_shift[timer])) { - s3c24xx_pwm_start( device, timer); + s3c24xx_pwm_start(timer); } else { - s3c24xx_pwm_stop( device, timer); + s3c24xx_pwm_stop(timer); } } -static WRITE32_DEVICE_HANDLER( s3c24xx_pwm_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_pwm_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->pwm.regs)[offset]; - verboselog( device->machine(), 9, "(PWM) %08X <- %08X\n", S3C24XX_BASE_PWM + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->pwm.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_pwm.regs)[offset]; + verboselog( machine(), 9, "(PWM) %08X <- %08X\n", S3C24XX_BASE_PWM + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_pwm.regs)[offset]); switch (offset) { case S3C24XX_TCON : { if ((data & (1 << 0)) != (old_value & (1 << 0))) { - s3c24xx_pwm_recalc( device, 0); + s3c24xx_pwm_recalc( 0); } if ((data & (1 << 8)) != (old_value & (1 << 8))) { - s3c24xx_pwm_recalc( device, 1); + s3c24xx_pwm_recalc( 1); } if ((data & (1 << 12)) != (old_value & (1 << 12))) { - s3c24xx_pwm_recalc( device, 2); + s3c24xx_pwm_recalc(2); } if ((data & (1 << 16)) != (old_value & (1 << 16))) { - s3c24xx_pwm_recalc( device, 3); + s3c24xx_pwm_recalc(3); } if ((data & (1 << 20)) != (old_value & (1 << 20))) { - s3c24xx_pwm_recalc( device, 4); + s3c24xx_pwm_recalc(4); } } break; } } -static TIMER_CALLBACK( s3c24xx_pwm_timer_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_pwm_timer_exp ) { - device_t *device = (device_t *)ptr; - s3c24xx_t *s3c24xx = get_token( device); int ch = param; const int ch_int[] = { S3C24XX_INT_TIMER0, S3C24XX_INT_TIMER1, S3C24XX_INT_TIMER2, S3C24XX_INT_TIMER3, S3C24XX_INT_TIMER4 }; - verboselog( machine, 2, "PWM %d timer callback\n", ch); - if (BITS( s3c24xx->pwm.regs.tcfg1, 23, 20) == (ch + 1)) + verboselog( machine(), 2, "PWM %d timer callback\n", ch); + if (BITS( m_pwm.regs.tcfg1, 23, 20) == (ch + 1)) { - s3c24xx_dma_request_pwm( device); + s3c24xx_dma_request_pwm(); } else { - s3c24xx_request_irq( device, ch_int[ch]); + s3c24xx_request_irq(ch_int[ch]); } } /* DMA */ -static void s3c24xx_dma_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_dma_reset() { - s3c24xx_t *s3c24xx = get_token( device); for (int i = 0; i < S3C24XX_DMA_COUNT; i++) { - s3c24xx_dma_t *dma = &s3c24xx->dma[i]; + s3c24xx_dma_t *dma = &m_dma[i]; memset( &dma->regs, 0, sizeof( dma->regs)); dma->timer->adjust( attotime::never); } } -static void s3c24xx_dma_reload( device_t *device, int ch) +void S3C24_CLASS_NAME::s3c24xx_dma_reload(int ch) { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_dma_regs_t *regs = &s3c24xx->dma[ch].regs; + s3c24xx_dma_regs_t *regs = &m_dma[ch].regs; regs->dstat = S3C24XX_DSTAT_SET_CURR_TC( regs->dstat, S3C24XX_DCON_GET_TC( regs->dcon)); regs->dcsrc = S3C24XX_DCSRC_SET_CURR_SRC( regs->dcsrc, S3C24XX_DISRC_GET_SADDR( regs->disrc)); regs->dcdst = S3C24XX_DCDST_SET_CURR_DST( regs->dcdst, S3C24XX_DIDST_GET_DADDR( regs->didst)); } -static void s3c24xx_dma_trigger( device_t *device, int ch) +void S3C24_CLASS_NAME::s3c24xx_dma_trigger(int ch) { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_dma_regs_t *regs = &s3c24xx->dma[ch].regs; + s3c24xx_dma_regs_t *regs = &m_dma[ch].regs; UINT32 curr_tc, curr_src, curr_dst; - address_space &space = s3c24xx->m_cpu->memory().space( AS_PROGRAM); + address_space &space = m_cpu->memory().space( AS_PROGRAM); int dsz, inc_src, inc_dst, servmode, tsz; const UINT32 ch_int[] = { S3C24XX_INT_DMA0, S3C24XX_INT_DMA1, S3C24XX_INT_DMA2, S3C24XX_INT_DMA3}; - verboselog( device->machine(), 5, "DMA %d trigger\n", ch); + verboselog( machine(), 5, "DMA %d trigger\n", ch); curr_tc = S3C24XX_DSTAT_GET_CURR_TC( regs->dstat); dsz = S3C24XX_DCON_GET_DSZ( regs->dcon); curr_src = S3C24XX_DCSRC_GET_CURR_SRC( regs->dcsrc); @@ -1628,7 +1518,7 @@ static void s3c24xx_dma_trigger( device_t *device, int ch) inc_src = BIT( regs->disrcc, 0); inc_dst = BIT( regs->didstc, 0); #endif - verboselog( device->machine(), 5, "DMA %d - curr_src %08X curr_dst %08X curr_tc %d dsz %d\n", ch, curr_src, curr_dst, curr_tc, dsz); + verboselog( machine(), 5, "DMA %d - curr_src %08X curr_dst %08X curr_tc %d dsz %d\n", ch, curr_src, curr_dst, curr_tc, dsz); while (curr_tc > 0) { curr_tc--; @@ -1652,7 +1542,7 @@ static void s3c24xx_dma_trigger( device_t *device, int ch) { if (S3C24XX_DCON_GET_RELOAD( regs->dcon) == 0) { - s3c24xx_dma_reload( device, ch); + s3c24xx_dma_reload(ch); } else { @@ -1660,47 +1550,44 @@ static void s3c24xx_dma_trigger( device_t *device, int ch) } if (S3C24XX_DCON_GET_INT( regs->dcon) != 0) { - s3c24xx_request_irq( device, ch_int[ch]); + s3c24xx_request_irq(ch_int[ch]); } } } -static void s3c24xx_dma_request_iis( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_dma_request_iis() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_dma_regs_t *regs = &s3c24xx->dma[2].regs; - verboselog( device->machine(), 5, "s3c24xx_dma_request_iis\n"); + s3c24xx_dma_regs_t *regs = &m_dma[2].regs; + verboselog( machine(), 5, "s3c24xx_dma_request_iis\n"); if ((S3C24XX_DMASKTRIG_GET_ON_OFF( regs->dmasktrig) != 0) && (S3C24XX_DCON_GET_SWHWSEL( regs->dcon) != 0) && (S3C24XX_DCON_GET_HWSRCSEL( regs->dcon) == 0)) { - s3c24xx_dma_trigger( device, 2); + s3c24xx_dma_trigger(2); } } -static void s3c24xx_dma_request_pwm( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_dma_request_pwm() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "s3c24xx_dma_request_pwm\n"); + verboselog( machine(), 5, "s3c24xx_dma_request_pwm\n"); for (int i = 0; i < 4; i++) { if (i != 1) { - s3c24xx_dma_regs_t *regs = &s3c24xx->dma[i].regs; + s3c24xx_dma_regs_t *regs = &m_dma[i].regs; if ((S3C24XX_DMASKTRIG_GET_ON_OFF( regs->dmasktrig) != 0) && (S3C24XX_DCON_GET_SWHWSEL( regs->dcon) != 0) && (S3C24XX_DCON_GET_HWSRCSEL( regs->dcon) == 3)) { - s3c24xx_dma_trigger( device, i); + s3c24xx_dma_trigger(i); } } } } -static void s3c24xx_dma_start( device_t *device, int ch) +void S3C24_CLASS_NAME::s3c24xx_dma_start(int ch) { - s3c24xx_t *s3c24xx = get_token( device); UINT32 addr_src, addr_dst, tc; - s3c24xx_dma_regs_t *regs = &s3c24xx->dma[ch].regs; + s3c24xx_dma_regs_t *regs = &m_dma[ch].regs; UINT32 dsz, tsz, reload; int inc_src, inc_dst, _int, servmode, swhwsel, hwsrcsel; - verboselog( device->machine(), 1, "DMA %d start\n", ch); + verboselog( machine(), 1, "DMA %d start\n", ch); addr_src = S3C24XX_DISRC_GET_SADDR( regs->disrc); addr_dst = S3C24XX_DIDST_GET_DADDR( regs->didst); tc = S3C24XX_DCON_GET_TC( regs->dcon); @@ -1718,44 +1605,41 @@ static void s3c24xx_dma_start( device_t *device, int ch) inc_src = BIT( regs->disrcc, 0); inc_dst = BIT( regs->didstc, 0); #endif - verboselog( device->machine(), 5, "DMA %d - addr_src %08X inc_src %d addr_dst %08X inc_dst %d int %d tsz %d servmode %d hwsrcsel %d swhwsel %d reload %d dsz %d tc %d\n", ch, addr_src, inc_src, addr_dst, inc_dst, _int, tsz, servmode, hwsrcsel, swhwsel, reload, dsz, tc); - verboselog( device->machine(), 5, "DMA %d - copy %08X bytes from %08X (%s) to %08X (%s)\n", ch, (tc << dsz) << (tsz << 1), addr_src, inc_src ? "fix" : "inc", addr_dst, inc_dst ? "fix" : "inc"); - s3c24xx_dma_reload( device, ch); + verboselog( machine(), 5, "DMA %d - addr_src %08X inc_src %d addr_dst %08X inc_dst %d int %d tsz %d servmode %d hwsrcsel %d swhwsel %d reload %d dsz %d tc %d\n", ch, addr_src, inc_src, addr_dst, inc_dst, _int, tsz, servmode, hwsrcsel, swhwsel, reload, dsz, tc); + verboselog( machine(), 5, "DMA %d - copy %08X bytes from %08X (%s) to %08X (%s)\n", ch, (tc << dsz) << (tsz << 1), addr_src, inc_src ? "fix" : "inc", addr_dst, inc_dst ? "fix" : "inc"); + s3c24xx_dma_reload(ch); if (swhwsel == 0) { - s3c24xx_dma_trigger( device, ch); + s3c24xx_dma_trigger(ch); } } -static void s3c24xx_dma_stop( device_t *device, int ch) +void S3C24_CLASS_NAME::s3c24xx_dma_stop(int ch) { - verboselog( device->machine(), 1, "DMA %d stop\n", ch); + verboselog( machine(), 1, "DMA %d stop\n", ch); } -static void s3c24xx_dma_recalc( device_t *device, int ch) +void S3C24_CLASS_NAME::s3c24xx_dma_recalc(int ch) { - s3c24xx_t *s3c24xx = get_token( device); - if ((s3c24xx->dma[ch].regs.dmasktrig & (1 << 1)) != 0) + if ((m_dma[ch].regs.dmasktrig & (1 << 1)) != 0) { - s3c24xx_dma_start( device, ch); + s3c24xx_dma_start(ch); } else { - s3c24xx_dma_stop( device, ch); + s3c24xx_dma_stop(ch); } } -static UINT32 s3c24xx_dma_r( device_t *device, UINT32 ch, UINT32 offset) +UINT32 S3C24_CLASS_NAME::s3c24xx_dma_r(UINT32 ch, UINT32 offset) { - s3c24xx_t *s3c24xx = get_token( device); - return ((UINT32*)&s3c24xx->dma[ch].regs)[offset]; + return ((UINT32*)&m_dma[ch].regs)[offset]; } -static void s3c24xx_dma_w( device_t *device, UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask) +void S3C24_CLASS_NAME::s3c24xx_dma_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->dma[ch].regs)[offset]; - COMBINE_DATA(&((UINT32*)&s3c24xx->dma[ch].regs)[offset]); + UINT32 old_value = ((UINT32*)&m_dma[ch].regs)[offset]; + COMBINE_DATA(&((UINT32*)&m_dma[ch].regs)[offset]); switch (offset) { case S3C24XX_DCON : @@ -1763,7 +1647,7 @@ static void s3c24xx_dma_w( device_t *device, UINT32 ch, UINT32 offset, UINT32 da #if 0 // is this code necessary ??? if ((data & (1 << 22)) != 0) // reload { - s3c24xx_dma_regs_t *regs = &s3c24xx->dma[ch].regs; + s3c24xx_dma_regs_t *regs = &m_dma[ch].regs; regs->dmasktrig &= ~(1 << 1); // clear on/off } #endif @@ -1773,77 +1657,76 @@ static void s3c24xx_dma_w( device_t *device, UINT32 ch, UINT32 offset, UINT32 da { if ((old_value & (1 << 1)) != (data & (1 << 1))) { - s3c24xx_dma_recalc( device, ch); + s3c24xx_dma_recalc(ch); } } break; } } -static READ32_DEVICE_HANDLER( s3c24xx_dma_0_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_0_r ) { - UINT32 data = s3c24xx_dma_r( device, 0, offset); - verboselog( device->machine(), 9, "(DMA 0) %08X -> %08X\n", S3C24XX_BASE_DMA_0 + (offset << 2), data); + UINT32 data = s3c24xx_dma_r( 0, offset); + verboselog( machine(), 9, "(DMA 0) %08X -> %08X\n", S3C24XX_BASE_DMA_0 + (offset << 2), data); return data; } -static READ32_DEVICE_HANDLER( s3c24xx_dma_1_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_1_r ) { - UINT32 data = s3c24xx_dma_r( device, 1, offset); - verboselog( device->machine(), 9, "(DMA 1) %08X -> %08X\n", S3C24XX_BASE_DMA_1 + (offset << 2), data); + UINT32 data = s3c24xx_dma_r( 1, offset); + verboselog( machine(), 9, "(DMA 1) %08X -> %08X\n", S3C24XX_BASE_DMA_1 + (offset << 2), data); return data; } -static READ32_DEVICE_HANDLER( s3c24xx_dma_2_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_2_r ) { - UINT32 data = s3c24xx_dma_r( device, 2, offset); - verboselog( device->machine(), 9, "(DMA 2) %08X -> %08X\n", S3C24XX_BASE_DMA_2 + (offset << 2), data); + UINT32 data = s3c24xx_dma_r( 2, offset); + verboselog( machine(), 9, "(DMA 2) %08X -> %08X\n", S3C24XX_BASE_DMA_2 + (offset << 2), data); return data; } -static READ32_DEVICE_HANDLER( s3c24xx_dma_3_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_3_r ) { - UINT32 data = s3c24xx_dma_r( device, 3, offset); - verboselog( device->machine(), 9, "(DMA 3) %08X -> %08X\n", S3C24XX_BASE_DMA_3 + (offset << 2), data); + UINT32 data = s3c24xx_dma_r( 3, offset); + verboselog( machine(), 9, "(DMA 3) %08X -> %08X\n", S3C24XX_BASE_DMA_3 + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_dma_0_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_0_w ) { - verboselog( device->machine(), 9, "(DMA 0) %08X <- %08X\n", S3C24XX_BASE_DMA_0 + (offset << 2), data); - s3c24xx_dma_w( device, 0, offset, data, mem_mask); + verboselog( machine(), 9, "(DMA 0) %08X <- %08X\n", S3C24XX_BASE_DMA_0 + (offset << 2), data); + s3c24xx_dma_w( 0, offset, data, mem_mask); } -static WRITE32_DEVICE_HANDLER( s3c24xx_dma_1_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_1_w ) { - verboselog( device->machine(), 9, "(DMA 1) %08X <- %08X\n", S3C24XX_BASE_DMA_1 + (offset << 2), data); - s3c24xx_dma_w( device, 1, offset, data, mem_mask); + verboselog( machine(), 9, "(DMA 1) %08X <- %08X\n", S3C24XX_BASE_DMA_1 + (offset << 2), data); + s3c24xx_dma_w( 1, offset, data, mem_mask); } -static WRITE32_DEVICE_HANDLER( s3c24xx_dma_2_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_2_w ) { - verboselog( device->machine(), 9, "(DMA 2) %08X <- %08X\n", S3C24XX_BASE_DMA_2 + (offset << 2), data); - s3c24xx_dma_w( device, 2, offset, data, mem_mask); + verboselog( machine(), 9, "(DMA 2) %08X <- %08X\n", S3C24XX_BASE_DMA_2 + (offset << 2), data); + s3c24xx_dma_w( 2, offset, data, mem_mask); } -static WRITE32_DEVICE_HANDLER( s3c24xx_dma_3_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_3_w ) { - verboselog( device->machine(), 9, "(DMA 3) %08X <- %08X\n", S3C24XX_BASE_DMA_3 + (offset << 2), data); - s3c24xx_dma_w( device, 3, offset, data, mem_mask); + verboselog( machine(), 9, "(DMA 3) %08X <- %08X\n", S3C24XX_BASE_DMA_3 + (offset << 2), data); + s3c24xx_dma_w( 3, offset, data, mem_mask); } -static TIMER_CALLBACK( s3c24xx_dma_timer_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_dma_timer_exp ) { int ch = param; - verboselog( machine, 2, "DMA %d timer callback\n", ch); + verboselog( machine(), 2, "DMA %d timer callback\n", ch); } /* I/O Port */ -static void s3c24xx_gpio_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_gpio_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_gpio_t *gpio = &s3c24xx->gpio; + s3c24xx_gpio_t *gpio = &m_gpio; memset( &gpio->regs, 0, sizeof( gpio->regs)); #if defined(DEVICE_S3C2400) gpio->regs.gpacon = 0x0003FFFF; @@ -1869,12 +1752,11 @@ static void s3c24xx_gpio_reset( device_t *device) #endif } -INLINE UINT32 iface_gpio_port_r( device_t *device, int port, UINT32 mask) +UINT32 S3C24_CLASS_NAME::iface_gpio_port_r(int port, UINT32 mask) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->port_r.isnull()) + if (!m_port_r.isnull()) { - return (s3c24xx->port_r)( port, mask); + return (m_port_r)( port, mask); } else { @@ -1882,16 +1764,15 @@ INLINE UINT32 iface_gpio_port_r( device_t *device, int port, UINT32 mask) } } -INLINE void iface_gpio_port_w( device_t *device, int port, UINT32 mask, UINT32 data) +void S3C24_CLASS_NAME::iface_gpio_port_w(int port, UINT32 mask, UINT32 data) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->port_w.isnull()) + if (!m_port_w.isnull()) { - (s3c24xx->port_w)( port, data, mask ); + (m_port_w)( port, data, mask ); } } -static UINT16 s3c24xx_gpio_get_mask( UINT32 con, int val) +UINT16 S3C24_CLASS_NAME::s3c24xx_gpio_get_mask( UINT32 con, int val) { UINT16 mask = 0; for (int i = 0; i < 16; i++) @@ -1904,140 +1785,138 @@ static UINT16 s3c24xx_gpio_get_mask( UINT32 con, int val) return mask; } -static READ32_DEVICE_HANDLER( s3c24xx_gpio_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_gpio_r ) { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_gpio_t *gpio = &s3c24xx->gpio; - UINT32 data = ((UINT32*)&s3c24xx->gpio.regs)[offset]; + s3c24xx_gpio_t *gpio = &m_gpio; + UINT32 data = ((UINT32*)&m_gpio.regs)[offset]; switch (offset) { case S3C24XX_GPADAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_A, 0) & S3C24XX_GPADAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_A, 0) & S3C24XX_GPADAT_MASK; } break; case S3C24XX_GPBDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_B, s3c24xx_gpio_get_mask( gpio->regs.gpbcon, 0) & S3C24XX_GPBDAT_MASK) & S3C24XX_GPBDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_B, s3c24xx_gpio_get_mask( gpio->regs.gpbcon, 0) & S3C24XX_GPBDAT_MASK) & S3C24XX_GPBDAT_MASK; } break; case S3C24XX_GPCDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_C, s3c24xx_gpio_get_mask( gpio->regs.gpccon, 0) & S3C24XX_GPCDAT_MASK) & S3C24XX_GPCDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_C, s3c24xx_gpio_get_mask( gpio->regs.gpccon, 0) & S3C24XX_GPCDAT_MASK) & S3C24XX_GPCDAT_MASK; } break; case S3C24XX_GPDDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_D, s3c24xx_gpio_get_mask( gpio->regs.gpdcon, 0) & S3C24XX_GPDDAT_MASK) & S3C24XX_GPDDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_D, s3c24xx_gpio_get_mask( gpio->regs.gpdcon, 0) & S3C24XX_GPDDAT_MASK) & S3C24XX_GPDDAT_MASK; } break; case S3C24XX_GPEDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_E, s3c24xx_gpio_get_mask( gpio->regs.gpecon, 0) & S3C24XX_GPEDAT_MASK) & S3C24XX_GPEDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_E, s3c24xx_gpio_get_mask( gpio->regs.gpecon, 0) & S3C24XX_GPEDAT_MASK) & S3C24XX_GPEDAT_MASK; } break; case S3C24XX_GPFDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_F, s3c24xx_gpio_get_mask( gpio->regs.gpfcon, 0) & S3C24XX_GPFDAT_MASK) & S3C24XX_GPFDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_F, s3c24xx_gpio_get_mask( gpio->regs.gpfcon, 0) & S3C24XX_GPFDAT_MASK) & S3C24XX_GPFDAT_MASK; } break; case S3C24XX_GPGDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_G, s3c24xx_gpio_get_mask( gpio->regs.gpgcon, 0) & S3C24XX_GPGDAT_MASK) & S3C24XX_GPGDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_G, s3c24xx_gpio_get_mask( gpio->regs.gpgcon, 0) & S3C24XX_GPGDAT_MASK) & S3C24XX_GPGDAT_MASK; } break; #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) case S3C24XX_GPHDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_H, s3c24xx_gpio_get_mask( gpio->regs.gphcon, 0) & S3C24XX_GPHDAT_MASK) & S3C24XX_GPHDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_H, s3c24xx_gpio_get_mask( gpio->regs.gphcon, 0) & S3C24XX_GPHDAT_MASK) & S3C24XX_GPHDAT_MASK; } break; #endif #if defined(DEVICE_S3C2440) case S3C24XX_GPJDAT : { - data = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_J, s3c24xx_gpio_get_mask( gpio->regs.gpjcon, 0) & S3C24XX_GPJDAT_MASK) & S3C24XX_GPJDAT_MASK; + data = iface_gpio_port_r( S3C24XX_GPIO_PORT_J, s3c24xx_gpio_get_mask( gpio->regs.gpjcon, 0) & S3C24XX_GPJDAT_MASK) & S3C24XX_GPJDAT_MASK; } break; #endif } - verboselog( device->machine(), 9, "(GPIO) %08X -> %08X\n", S3C24XX_BASE_GPIO + (offset << 2), data); + verboselog( machine(), 9, "(GPIO) %08X -> %08X\n", S3C24XX_BASE_GPIO + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_gpio_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_gpio_w ) { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_gpio_t *gpio = &s3c24xx->gpio; + s3c24xx_gpio_t *gpio = &m_gpio; #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - UINT32 old_value = ((UINT32*)&s3c24xx->gpio.regs)[offset]; + UINT32 old_value = ((UINT32*)&m_gpio.regs)[offset]; #endif - verboselog( device->machine(), 9, "(GPIO) %08X <- %08X\n", S3C24XX_BASE_GPIO + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->gpio.regs)[offset]); + verboselog( machine(), 9, "(GPIO) %08X <- %08X\n", S3C24XX_BASE_GPIO + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_gpio.regs)[offset]); switch (offset) { case S3C24XX_GPADAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_A, gpio->regs.gpacon ^ 0xFFFFFFFF, data & S3C24XX_GPADAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_A, gpio->regs.gpacon ^ 0xFFFFFFFF, data & S3C24XX_GPADAT_MASK); } break; case S3C24XX_GPBDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_B, s3c24xx_gpio_get_mask( gpio->regs.gpbcon, 1) & S3C24XX_GPBDAT_MASK, data & S3C24XX_GPBDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_B, s3c24xx_gpio_get_mask( gpio->regs.gpbcon, 1) & S3C24XX_GPBDAT_MASK, data & S3C24XX_GPBDAT_MASK); } break; case S3C24XX_GPCDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_C, s3c24xx_gpio_get_mask( gpio->regs.gpccon, 1) & S3C24XX_GPCDAT_MASK, data & S3C24XX_GPCDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_C, s3c24xx_gpio_get_mask( gpio->regs.gpccon, 1) & S3C24XX_GPCDAT_MASK, data & S3C24XX_GPCDAT_MASK); } break; case S3C24XX_GPDDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_D, s3c24xx_gpio_get_mask( gpio->regs.gpdcon, 1) & S3C24XX_GPDDAT_MASK, data & S3C24XX_GPDDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_D, s3c24xx_gpio_get_mask( gpio->regs.gpdcon, 1) & S3C24XX_GPDDAT_MASK, data & S3C24XX_GPDDAT_MASK); } break; case S3C24XX_GPEDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_E, s3c24xx_gpio_get_mask( gpio->regs.gpecon, 1) & S3C24XX_GPEDAT_MASK, data & S3C24XX_GPEDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_E, s3c24xx_gpio_get_mask( gpio->regs.gpecon, 1) & S3C24XX_GPEDAT_MASK, data & S3C24XX_GPEDAT_MASK); } break; case S3C24XX_GPFDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_F, s3c24xx_gpio_get_mask( gpio->regs.gpfcon, 1) & S3C24XX_GPFDAT_MASK, data & S3C24XX_GPFDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_F, s3c24xx_gpio_get_mask( gpio->regs.gpfcon, 1) & S3C24XX_GPFDAT_MASK, data & S3C24XX_GPFDAT_MASK); } break; case S3C24XX_GPGDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_G, s3c24xx_gpio_get_mask( gpio->regs.gpgcon, 1) & S3C24XX_GPGDAT_MASK, data & S3C24XX_GPGDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_G, s3c24xx_gpio_get_mask( gpio->regs.gpgcon, 1) & S3C24XX_GPGDAT_MASK, data & S3C24XX_GPGDAT_MASK); } break; #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) case S3C24XX_GPHDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_H, s3c24xx_gpio_get_mask( gpio->regs.gphcon, 1) & S3C24XX_GPHDAT_MASK, data & S3C24XX_GPHDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_H, s3c24xx_gpio_get_mask( gpio->regs.gphcon, 1) & S3C24XX_GPHDAT_MASK, data & S3C24XX_GPHDAT_MASK); } break; case S3C24XX_EINTPEND : { - s3c24xx->gpio.regs.eintpend = (old_value & ~data); - s3c24xx_check_pending_eint( device); + m_gpio.regs.eintpend = (old_value & ~data); + s3c24xx_check_pending_eint(); } break; case S3C24XX_EINTMASK : { - s3c24xx_check_pending_eint( device); + s3c24xx_check_pending_eint(); } break; case S3C24XX_GSTATUS2 : { - s3c24xx->gpio.regs.gstatus2 = (old_value & ~data) & 7; // "The setting is cleared by writing '1' to this bit" + m_gpio.regs.gstatus2 = (old_value & ~data) & 7; // "The setting is cleared by writing '1' to this bit" } break; #endif #if defined(DEVICE_S3C2440) case S3C24XX_GPJDAT : { - iface_gpio_port_w( device, S3C24XX_GPIO_PORT_J, s3c24xx_gpio_get_mask( gpio->regs.gpjcon, 1) & S3C24XX_GPJDAT_MASK, data & S3C24XX_GPJDAT_MASK); + iface_gpio_port_w( S3C24XX_GPIO_PORT_J, s3c24xx_gpio_get_mask( gpio->regs.gpjcon, 1) & S3C24XX_GPJDAT_MASK, data & S3C24XX_GPJDAT_MASK); } break; #endif @@ -2046,10 +1925,9 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_gpio_w ) /* Memory Controller */ -static void s3c24xx_memcon_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_memcon_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_memcon_t *memcon = &s3c24xx->memcon; + s3c24xx_memcon_t *memcon = &m_memcon; memset( &memcon->regs, 0, sizeof( memcon->regs)); memcon->regs.data[0x04/4] = 0x00000700; memcon->regs.data[0x08/4] = 0x00000700; @@ -2062,34 +1940,30 @@ static void s3c24xx_memcon_reset( device_t *device) memcon->regs.data[0x24/4] = 0x00AC0000; } -static READ32_DEVICE_HANDLER( s3c24xx_memcon_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_memcon_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->memcon.regs.data[offset]; - verboselog( device->machine(), 9, "(MEMCON) %08X -> %08X\n", S3C24XX_BASE_MEMCON + (offset << 2), data); + UINT32 data = m_memcon.regs.data[offset]; + verboselog( machine(), 9, "(MEMCON) %08X -> %08X\n", S3C24XX_BASE_MEMCON + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_memcon_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_memcon_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(MEMCON) %08X <- %08X\n", S3C24XX_BASE_MEMCON + (offset << 2), data); - COMBINE_DATA(&s3c24xx->memcon.regs.data[offset]); + verboselog( machine(), 9, "(MEMCON) %08X <- %08X\n", S3C24XX_BASE_MEMCON + (offset << 2), data); + COMBINE_DATA(&m_memcon.regs.data[offset]); } /* USB Host Controller */ -static void s3c24xx_usb_host_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_usb_host_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_usbhost_t *usbhost = &s3c24xx->usbhost; + s3c24xx_usbhost_t *usbhost = &m_usbhost; memset( &usbhost->regs, 0, sizeof( usbhost->regs)); } -static READ32_DEVICE_HANDLER( s3c24xx_usb_host_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_usb_host_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->usbhost.regs.data[offset]; + UINT32 data = m_usbhost.regs.data[offset]; switch (offset) { // HcCommandStatus @@ -2120,34 +1994,31 @@ static READ32_DEVICE_HANDLER( s3c24xx_usb_host_r ) } break; } - verboselog( device->machine(), 9, "(USB H) %08X -> %08X\n", S3C24XX_BASE_USBHOST + (offset << 2), data); + verboselog( machine(), 9, "(USB H) %08X -> %08X\n", S3C24XX_BASE_USBHOST + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_usb_host_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_usb_host_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(USB H) %08X <- %08X\n", S3C24XX_BASE_USBHOST + (offset << 2), data); - COMBINE_DATA(&s3c24xx->usbhost.regs.data[offset]); + verboselog( machine(), 9, "(USB H) %08X <- %08X\n", S3C24XX_BASE_USBHOST + (offset << 2), data); + COMBINE_DATA(&m_usbhost.regs.data[offset]); } /* UART */ -static void s3c24xx_uart_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_uart_reset() { - s3c24xx_t *s3c24xx = get_token( device); for (int i = 0; i < S3C24XX_UART_COUNT; i++) { - s3c24xx_uart_t *uart = &s3c24xx->uart[i]; + s3c24xx_uart_t *uart = &m_uart[i]; memset( &uart->regs, 0, sizeof( uart->regs)); uart->regs.utrstat = 6; } } -static UINT32 s3c24xx_uart_r( device_t *device, UINT32 ch, UINT32 offset) +UINT32 S3C24_CLASS_NAME::s3c24xx_uart_r(UINT32 ch, UINT32 offset) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->uart[ch].regs)[offset]; + UINT32 data = ((UINT32*)&m_uart[ch].regs)[offset]; switch (offset) { case S3C24XX_UTRSTAT : @@ -2158,29 +2029,28 @@ static UINT32 s3c24xx_uart_r( device_t *device, UINT32 ch, UINT32 offset) case S3C24XX_URXH : { UINT8 rxdata = data & 0xFF; - verboselog( device->machine(), 5, "UART %d read %02X (%c)\n", ch, rxdata, ((rxdata >= 32) && (rxdata < 128)) ? (char)rxdata : '?'); - s3c24xx->uart[ch].regs.utrstat &= ~1; // [bit 0] Receive buffer data ready + verboselog( machine(), 5, "UART %d read %02X (%c)\n", ch, rxdata, ((rxdata >= 32) && (rxdata < 128)) ? (char)rxdata : '?'); + m_uart[ch].regs.utrstat &= ~1; // [bit 0] Receive buffer data ready } break; } return data; } -static void s3c24xx_uart_w( device_t *device, UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask) +void S3C24_CLASS_NAME::s3c24xx_uart_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask) { - s3c24xx_t *s3c24xx = get_token( device); - COMBINE_DATA(&((UINT32*)&s3c24xx->uart[ch].regs)[offset]); + COMBINE_DATA(&((UINT32*)&m_uart[ch].regs)[offset]); switch (offset) { case S3C24XX_UFCON : { - s3c24xx->uart[ch].regs.ufcon &= ~((1 << 2) | (1 << 1)); // bits 1 and 2 are auto-cleared after resetting FIFO + m_uart[ch].regs.ufcon &= ~((1 << 2) | (1 << 1)); // bits 1 and 2 are auto-cleared after resetting FIFO } break; case S3C24XX_UTXH : { UINT8 txdata = data & 0xFF; - verboselog( device->machine(), 5, "UART %d write %02X (%c)\n", ch, txdata, ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?'); + verboselog( machine(), 5, "UART %d write %02X (%c)\n", ch, txdata, ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?'); #ifdef UART_PRINTF printf( "%c", ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?'); #endif @@ -2189,67 +2059,65 @@ static void s3c24xx_uart_w( device_t *device, UINT32 ch, UINT32 offset, UINT32 d } } -static READ32_DEVICE_HANDLER( s3c24xx_uart_0_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_uart_0_r ) { - UINT32 data = s3c24xx_uart_r( device, 0, offset); -// verboselog( device->machine(), 9, "(UART 0) %08X -> %08X\n", S3C24XX_BASE_UART_0 + (offset << 2), data); + UINT32 data = s3c24xx_uart_r( 0, offset); +// verboselog( machine(), 9, "(UART 0) %08X -> %08X\n", S3C24XX_BASE_UART_0 + (offset << 2), data); return data; } -static READ32_DEVICE_HANDLER( s3c24xx_uart_1_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_uart_1_r ) { - UINT32 data = s3c24xx_uart_r( device, 1, offset); -// verboselog( device->machine(), 9, "(UART 1) %08X -> %08X\n", S3C24XX_BASE_UART_1 + (offset << 2), data); + UINT32 data = s3c24xx_uart_r( 1, offset); +// verboselog( machine(), 9, "(UART 1) %08X -> %08X\n", S3C24XX_BASE_UART_1 + (offset << 2), data); return data; } #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static READ32_DEVICE_HANDLER( s3c24xx_uart_2_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_uart_2_r ) { - UINT32 data = s3c24xx_uart_r( device, 2, offset); -// verboselog( device->machine(), 9, "(UART 2) %08X -> %08X\n", S3C24XX_BASE_UART_2 + (offset << 2), data); + UINT32 data = s3c24xx_uart_r( 2, offset); +// verboselog( machine(), 9, "(UART 2) %08X -> %08X\n", S3C24XX_BASE_UART_2 + (offset << 2), data); return data; } #endif -static WRITE32_DEVICE_HANDLER( s3c24xx_uart_0_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_uart_0_w ) { -// verboselog( device->machine(), 9, "(UART 0) %08X <- %08X\n", S3C24XX_BASE_UART_0 + (offset << 2), data); - s3c24xx_uart_w( device, 0, offset, data, mem_mask); +// verboselog( machine(), 9, "(UART 0) %08X <- %08X\n", S3C24XX_BASE_UART_0 + (offset << 2), data); + s3c24xx_uart_w( 0, offset, data, mem_mask); } -static WRITE32_DEVICE_HANDLER( s3c24xx_uart_1_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_uart_1_w ) { -// verboselog( device->machine(), 9, "(UART 1) %08X <- %08X\n", S3C24XX_BASE_UART_1 + (offset << 2), data); - s3c24xx_uart_w( device, 1, offset, data, mem_mask); +// verboselog( machine(), 9, "(UART 1) %08X <- %08X\n", S3C24XX_BASE_UART_1 + (offset << 2), data); + s3c24xx_uart_w( 1, offset, data, mem_mask); } #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static WRITE32_DEVICE_HANDLER( s3c24xx_uart_2_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_uart_2_w ) { -// verboselog( device->machine(), 9, "(UART 2) %08X <- %08X\n", S3C24XX_BASE_UART_2 + (offset << 2), data); - s3c24xx_uart_w( device, 2, offset, data, mem_mask); +// verboselog( machine(), 9, "(UART 2) %08X <- %08X\n", S3C24XX_BASE_UART_2 + (offset << 2), data); + s3c24xx_uart_w( 2, offset, data, mem_mask); } #endif -static void s3c24xx_uart_fifo_w( device_t *device, int uart, UINT8 data) +void S3C24_CLASS_NAME::s3c24xx_uart_fifo_w(int uart, UINT8 data) { // printf( "s3c24xx_uart_fifo_w (%c)\n", data); - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx->uart[uart].regs.urxh = data; - s3c24xx->uart[uart].regs.utrstat |= 1; // [bit 0] Receive buffer data ready + m_uart[uart].regs.urxh = data; + m_uart[uart].regs.utrstat |= 1; // [bit 0] Receive buffer data ready } /* USB Device */ -static void s3c24xx_usb_device_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_usb_device_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_usbdev_t *usbdev = &s3c24xx->usbdev; + s3c24xx_usbdev_t *usbdev = &m_usbdev; memset( &usbdev->regs, 0, sizeof( usbdev->regs)); #if defined(DEVICE_S3C2400) usbdev->regs.data[0x0C/4] = 0x033F; @@ -2268,27 +2136,24 @@ static void s3c24xx_usb_device_reset( device_t *device) #endif } -static READ32_DEVICE_HANDLER( s3c24xx_usb_device_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_usb_device_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->usbdev.regs.data[offset]; - verboselog( device->machine(), 9, "(USB D) %08X -> %08X\n", S3C24XX_BASE_USBDEV + (offset << 2), data); + UINT32 data = m_usbdev.regs.data[offset]; + verboselog( machine(), 9, "(USB D) %08X -> %08X\n", S3C24XX_BASE_USBDEV + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_usb_device_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_usb_device_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(USB D) %08X <- %08X\n", S3C24XX_BASE_USBDEV + (offset << 2), data); - COMBINE_DATA(&s3c24xx->usbdev.regs.data[offset]); + verboselog( machine(), 9, "(USB D) %08X <- %08X\n", S3C24XX_BASE_USBDEV + (offset << 2), data); + COMBINE_DATA(&m_usbdev.regs.data[offset]); } /* Watchdog Timer */ -static void s3c24xx_wdt_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_wdt_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_wdt_t *wdt = &s3c24xx->wdt; + s3c24xx_wdt_t *wdt = &m_wdt; memset( &wdt->regs, 0, sizeof( wdt->regs)); wdt->regs.wtcon = 0x8021; wdt->regs.wtdat = 0x8000; @@ -2298,166 +2163,154 @@ static void s3c24xx_wdt_reset( device_t *device) #if defined(DEVICE_S3C2410) -static UINT16 s3c24xx_wdt_calc_current_count( device_t *device) +UINT16 S3C24_CLASS_NAME::s3c24xx_wdt_calc_current_count() { - s3c24xx_t *s3c24xx = get_token( device); double timeleft, x1, x2; UINT32 cnt; - timeleft = s3c24xx->wdt.timer->remaining( ).as_double(); -// printf( "timeleft %f freq %d cnt %d\n", timeleft, s3c24xx->wdt.freq, s3c24xx->wdt.cnt); - x1 = 1 / ((double)s3c24xx->wdt.freq / s3c24xx->wdt.cnt); + timeleft = m_wdt.timer->remaining( ).as_double(); +// printf( "timeleft %f freq %d cnt %d\n", timeleft, m_wdt.freq, m_wdt.cnt); + x1 = 1 / ((double)m_wdt.freq / m_wdt.cnt); x2 = x1 / timeleft; // printf( "x1 %f\n", x1); - cnt = s3c24xx->wdt.cnt / x2; + cnt = m_wdt.cnt / x2; // printf( "cnt %d\n", cnt); return cnt; } #else -static UINT16 s3c24xx_wdt_calc_current_count( device_t *device) +UINT16 S3C24_CLASS_NAME::s3c24xx_wdt_calc_current_count() { return 0; } #endif -static READ32_DEVICE_HANDLER( s3c24xx_wdt_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_wdt_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->wdt.regs)[offset]; + UINT32 data = ((UINT32*)&m_wdt.regs)[offset]; switch (offset) { case S3C24XX_WTCNT : { // is wdt active? - if ((s3c24xx->wdt.regs.wtcon & (1 << 5)) != 0) + if ((m_wdt.regs.wtcon & (1 << 5)) != 0) { - data = s3c24xx_wdt_calc_current_count( device); + data = s3c24xx_wdt_calc_current_count(); } } break; } - verboselog( device->machine(), 9, "(WDT) %08X -> %08X\n", S3C24XX_BASE_WDT + (offset << 2), data); + verboselog( machine(), 9, "(WDT) %08X -> %08X\n", S3C24XX_BASE_WDT + (offset << 2), data); return data; } -static void s3c24xx_wdt_start( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_wdt_start() { - s3c24xx_t *s3c24xx = get_token( device); UINT32 pclk, prescaler, clock; double freq, hz; - verboselog( device->machine(), 1, "WDT start\n"); - pclk = s3c24xx_get_pclk( device); - prescaler = BITS( s3c24xx->wdt.regs.wtcon, 15, 8); - clock = 16 << BITS( s3c24xx->wdt.regs.wtcon, 4, 3); + verboselog( machine(), 1, "WDT start\n"); + pclk = s3c24xx_get_pclk(); + prescaler = BITS( m_wdt.regs.wtcon, 15, 8); + clock = 16 << BITS( m_wdt.regs.wtcon, 4, 3); freq = (double)pclk / (prescaler + 1) / clock; - hz = freq / s3c24xx->wdt.regs.wtcnt; - verboselog( device->machine(), 5, "WDT pclk %d prescaler %d clock %d freq %f hz %f\n", pclk, prescaler, clock, freq, hz); - s3c24xx->wdt.timer->adjust( attotime::from_hz( hz), 0, attotime::from_hz( hz)); + hz = freq / m_wdt.regs.wtcnt; + verboselog( machine(), 5, "WDT pclk %d prescaler %d clock %d freq %f hz %f\n", pclk, prescaler, clock, freq, hz); + m_wdt.timer->adjust( attotime::from_hz( hz), 0, attotime::from_hz( hz)); #if defined(DEVICE_S3C2410) - s3c24xx->wdt.freq = freq; - s3c24xx->wdt.cnt = s3c24xx->wdt.regs.wtcnt; + m_wdt.freq = freq; + m_wdt.cnt = m_wdt.regs.wtcnt; #endif } -static void s3c24xx_wdt_stop( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_wdt_stop() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 1, "WDT stop\n"); - s3c24xx->wdt.regs.wtcnt = s3c24xx_wdt_calc_current_count( device); - s3c24xx->wdt.timer->adjust( attotime::never); + verboselog( machine(), 1, "WDT stop\n"); + m_wdt.regs.wtcnt = s3c24xx_wdt_calc_current_count(); + m_wdt.timer->adjust( attotime::never); } -static void s3c24xx_wdt_recalc( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_wdt_recalc() { - s3c24xx_t *s3c24xx = get_token( device); - if ((s3c24xx->wdt.regs.wtcon & (1 << 5)) != 0) + if ((m_wdt.regs.wtcon & (1 << 5)) != 0) { - s3c24xx_wdt_start( device); + s3c24xx_wdt_start(); } else { - s3c24xx_wdt_stop( device); + s3c24xx_wdt_stop(); } } -static WRITE32_DEVICE_HANDLER( s3c24xx_wdt_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_wdt_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->wdt.regs)[offset]; - verboselog( device->machine(), 9, "(WDT) %08X <- %08X\n", S3C24XX_BASE_WDT + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->wdt.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_wdt.regs)[offset]; + verboselog( machine(), 9, "(WDT) %08X <- %08X\n", S3C24XX_BASE_WDT + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_wdt.regs)[offset]); switch (offset) { case S3C24XX_WTCON : { if ((data & (1 << 5)) != (old_value & (1 << 5))) { - s3c24xx_wdt_recalc( device); + s3c24xx_wdt_recalc(); } } break; } } -static TIMER_CALLBACK( s3c24xx_wdt_timer_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_wdt_timer_exp ) { - device_t *device = (device_t *)ptr; - s3c24xx_t *s3c24xx = get_token( device); - verboselog( machine, 2, "WDT timer callback\n"); - if ((s3c24xx->wdt.regs.wtcon & (1 << 2)) != 0) + verboselog( machine(), 2, "WDT timer callback\n"); + if ((m_wdt.regs.wtcon & (1 << 2)) != 0) { #if defined(DEVICE_S3C2400) || defined(DEVICE_S3C2410) - s3c24xx_request_irq( device, S3C24XX_INT_WDT); + s3c24xx_request_irq( S3C24XX_INT_WDT); #else - s3c24xx_request_subirq( device, S3C24XX_SUBINT_WDT); + s3c24xx_request_subirq( S3C24XX_SUBINT_WDT); #endif } - if ((s3c24xx->wdt.regs.wtcon & (1 << 0)) != 0) + if ((m_wdt.regs.wtcon & (1 << 0)) != 0) { - s3c24xx_reset( device); + s3c24xx_reset(); #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - s3c24xx->gpio.regs.gstatus2 = 1 << 2; // Watchdog reset + m_gpio.regs.gstatus2 = 1 << 2; // Watchdog reset #endif } } /* IIC */ -static void s3c24xx_iic_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_iic_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_iic_t *iic = &s3c24xx->iic; + s3c24xx_iic_t *iic = &m_iic; memset( &iic->regs, 0, sizeof( iic->regs)); iic->count = 0; iic->timer->adjust( attotime::never); } -INLINE void iface_i2c_scl_w( device_t *device, int state) +void S3C24_CLASS_NAME::iface_i2c_scl_w( int state) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->scl_w.isnull()) + if (!m_scl_w.isnull()) { - (s3c24xx->scl_w)( state); + (m_scl_w)( state); } } -INLINE void iface_i2c_sda_w( device_t *device, int state) +void S3C24_CLASS_NAME::iface_i2c_sda_w(int state) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->sda_w.isnull()) + if (!m_sda_w.isnull()) { - (s3c24xx->sda_w)(state); + (m_sda_w)(state); } } -INLINE int iface_i2c_sda_r( device_t *device) +int S3C24_CLASS_NAME::iface_i2c_sda_r() { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->sda_r.isnull()) + if (!m_sda_r.isnull()) { - return (s3c24xx->sda_r)(); + return (m_sda_r)(); } else { @@ -2465,104 +2318,100 @@ INLINE int iface_i2c_sda_r( device_t *device) } } -static void i2c_send_start( device_t *device) +void S3C24_CLASS_NAME::i2c_send_start() { - verboselog( device->machine(), 5, "i2c_send_start\n"); - iface_i2c_sda_w( device, 1); - iface_i2c_scl_w( device, 1); - iface_i2c_sda_w( device, 0); - iface_i2c_scl_w( device, 0); + verboselog( machine(), 5, "i2c_send_start\n"); + iface_i2c_sda_w( 1); + iface_i2c_scl_w( 1); + iface_i2c_sda_w( 0); + iface_i2c_scl_w( 0); } -static void i2c_send_stop( device_t *device) +void S3C24_CLASS_NAME::i2c_send_stop() { - verboselog( device->machine(), 5, "i2c_send_stop\n"); - iface_i2c_sda_w( device, 0); - iface_i2c_scl_w( device, 1); - iface_i2c_sda_w( device, 1); - iface_i2c_scl_w( device, 0); + verboselog( machine(), 5, "i2c_send_stop\n"); + iface_i2c_sda_w( 0); + iface_i2c_scl_w( 1); + iface_i2c_sda_w( 1); + iface_i2c_scl_w( 0); } -static UINT8 i2c_receive_byte( device_t *device, int ack) +UINT8 S3C24_CLASS_NAME::i2c_receive_byte(int ack) { UINT8 data = 0; - verboselog( device->machine(), 5, "i2c_receive_byte ...\n"); - iface_i2c_sda_w( device, 1); + verboselog( machine(), 5, "i2c_receive_byte ...\n"); + iface_i2c_sda_w( 1); for (int i = 0; i < 8; i++) { - iface_i2c_scl_w( device, 1); - data = (data << 1) + (iface_i2c_sda_r( device) ? 1 : 0); - iface_i2c_scl_w( device, 0); + iface_i2c_scl_w( 1); + data = (data << 1) + (iface_i2c_sda_r() ? 1 : 0); + iface_i2c_scl_w( 0); } - verboselog( device->machine(), 5, "recv data %02X\n", data); - verboselog( device->machine(), 5, "send ack %d\n", ack); - iface_i2c_sda_w( device, ack ? 0 : 1); - iface_i2c_scl_w( device, 1); - iface_i2c_scl_w( device, 0); + verboselog( machine(), 5, "recv data %02X\n", data); + verboselog( machine(), 5, "send ack %d\n", ack); + iface_i2c_sda_w( ack ? 0 : 1); + iface_i2c_scl_w( 1); + iface_i2c_scl_w( 0); return data; } -static int i2c_send_byte( device_t *device, UINT8 data) +int S3C24_CLASS_NAME::i2c_send_byte(UINT8 data) { int ack; - verboselog( device->machine(), 5, "i2c_send_byte ...\n"); - verboselog( device->machine(), 5, "send data %02X\n", data); + verboselog( machine(), 5, "i2c_send_byte ...\n"); + verboselog( machine(), 5, "send data %02X\n", data); for (int i = 0; i < 8; i++) { - iface_i2c_sda_w( device, (data & 0x80) ? 1 : 0); + iface_i2c_sda_w( (data & 0x80) ? 1 : 0); data = data << 1; - iface_i2c_scl_w( device, 1); - iface_i2c_scl_w( device, 0); + iface_i2c_scl_w( 1); + iface_i2c_scl_w( 0); } - iface_i2c_sda_w( device, 1); // ack bit - iface_i2c_scl_w( device, 1); - ack = iface_i2c_sda_r( device); - verboselog( device->machine(), 5, "recv ack %d\n", ack); - iface_i2c_scl_w( device, 0); + iface_i2c_sda_w( 1); // ack bit + iface_i2c_scl_w( 1); + ack = iface_i2c_sda_r(); + verboselog( machine(), 5, "recv ack %d\n", ack); + iface_i2c_scl_w( 0); return ack; } -static void iic_start( device_t *device) +void S3C24_CLASS_NAME::iic_start() { - s3c24xx_t *s3c24xx = get_token( device); int mode_selection; - verboselog( device->machine(), 1, "IIC start\n"); - i2c_send_start( device); - mode_selection = BITS( s3c24xx->iic.regs.iicstat, 7, 6); + verboselog( machine(), 1, "IIC start\n"); + i2c_send_start(); + mode_selection = BITS( m_iic.regs.iicstat, 7, 6); switch (mode_selection) { - case 2 : i2c_send_byte( device, s3c24xx->iic.regs.iicds | 0x01); break; - case 3 : i2c_send_byte( device, s3c24xx->iic.regs.iicds & 0xFE); break; + case 2 : i2c_send_byte( m_iic.regs.iicds | 0x01); break; + case 3 : i2c_send_byte( m_iic.regs.iicds & 0xFE); break; } - s3c24xx->iic.timer->adjust( attotime::from_usec( 1)); + m_iic.timer->adjust( attotime::from_usec( 1)); } -static void iic_stop( device_t *device) +void S3C24_CLASS_NAME::iic_stop() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 1, "IIC stop\n"); - i2c_send_stop( device); - s3c24xx->iic.timer->adjust( attotime::never); + verboselog( machine(), 1, "IIC stop\n"); + i2c_send_stop(); + m_iic.timer->adjust( attotime::never); } -static void iic_resume( device_t *device) +void S3C24_CLASS_NAME::iic_resume() { - s3c24xx_t *s3c24xx = get_token( device); int mode_selection; - verboselog( device->machine(), 1, "IIC resume\n"); - mode_selection = BITS( s3c24xx->iic.regs.iicstat, 7, 6); + verboselog(machine(), 1, "IIC resume\n"); + mode_selection = BITS( m_iic.regs.iicstat, 7, 6); switch (mode_selection) { - case 2 : s3c24xx->iic.regs.iicds = i2c_receive_byte( device, BIT( s3c24xx->iic.regs.iiccon, 7)); break; - case 3 : i2c_send_byte( device, s3c24xx->iic.regs.iicds & 0xFF); break; + case 2 : m_iic.regs.iicds = i2c_receive_byte( BIT( m_iic.regs.iiccon, 7)); break; + case 3 : i2c_send_byte( m_iic.regs.iicds & 0xFF); break; } - s3c24xx->iic.timer->adjust( attotime::from_usec( 1)); + m_iic.timer->adjust( attotime::from_usec( 1)); } -static READ32_DEVICE_HANDLER( s3c24xx_iic_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_iic_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->iic.regs)[offset]; + UINT32 data = ((UINT32*)&m_iic.regs)[offset]; switch (offset) { case S3C24XX_IICSTAT : @@ -2571,16 +2420,15 @@ static READ32_DEVICE_HANDLER( s3c24xx_iic_r ) } break; } - verboselog( device->machine(), 9, "(IIC) %08X -> %08X\n", S3C24XX_BASE_IIC + (offset << 2), data); + verboselog( machine(), 9, "(IIC) %08X -> %08X\n", S3C24XX_BASE_IIC + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_iic_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_iic_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->iic.regs)[offset]; - verboselog( device->machine(), 9, "(IIC) %08X <- %08X\n", S3C24XX_BASE_IIC + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->iic.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_iic.regs)[offset]; + verboselog( machine(), 9, "(IIC) %08X <- %08X\n", S3C24XX_BASE_IIC + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_iic.regs)[offset]); switch (offset) { case S3C24XX_IICCON : @@ -2593,7 +2441,7 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_iic_w ) transmit_clock_value = (data >> 0) & 0xF; tx_clock_source_selection = (data >> 6) & 1; enable_interrupt = (data >> 5) & 1; - clock = (double)s3c24xx_get_pclk( device) / div_table[tx_clock_source_selection] / (transmit_clock_value + 1); + clock = (double)s3c24xx_get_pclk() / div_table[tx_clock_source_selection] / (transmit_clock_value + 1); #endif interrupt_pending_flag = BIT( old_value, 4); if (interrupt_pending_flag != 0) @@ -2602,22 +2450,22 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_iic_w ) if (interrupt_pending_flag == 0) { int start_stop_condition; - start_stop_condition = BIT( s3c24xx->iic.regs.iicstat, 5); + start_stop_condition = BIT( m_iic.regs.iicstat, 5); if (start_stop_condition != 0) { - if (s3c24xx->iic.count == 0) + if (m_iic.count == 0) { - iic_start( device); + iic_start(); } else { - iic_resume( device); + iic_resume(); } } else { - iic_stop( device); + iic_stop(); } } } @@ -2626,27 +2474,27 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_iic_w ) case S3C24XX_IICSTAT : { int interrupt_pending_flag; - s3c24xx->iic.count = 0; - interrupt_pending_flag = BIT( s3c24xx->iic.regs.iiccon, 4); + m_iic.count = 0; + interrupt_pending_flag = BIT( m_iic.regs.iiccon, 4); if (interrupt_pending_flag == 0) { int start_stop_condition; start_stop_condition = BIT( data, 5); if (start_stop_condition != 0) { - if (s3c24xx->iic.count == 0) + if (m_iic.count == 0) { - iic_start( device); + iic_start(); } else { - iic_resume( device); + iic_resume(); } } else { - iic_stop( device); + iic_stop(); } } } @@ -2654,83 +2502,75 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_iic_w ) } } -static TIMER_CALLBACK( s3c24xx_iic_timer_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_iic_timer_exp ) { - device_t *device = (device_t *)ptr; - s3c24xx_t *s3c24xx = get_token( device); int enable_interrupt; - verboselog( machine, 2, "IIC timer callback\n"); - s3c24xx->iic.count++; - enable_interrupt = BIT( s3c24xx->iic.regs.iiccon, 5); + verboselog( machine(), 2, "IIC timer callback\n"); + m_iic.count++; + enable_interrupt = BIT( m_iic.regs.iiccon, 5); if (enable_interrupt) { - s3c24xx->iic.regs.iiccon |= (1 << 4); // [bit 4] interrupt is pending - s3c24xx_request_irq( device, S3C24XX_INT_IIC); + m_iic.regs.iiccon |= (1 << 4); // [bit 4] interrupt is pending + s3c24xx_request_irq(S3C24XX_INT_IIC); } } /* IIS */ -static void s3c24xx_iis_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_iis_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_iis_t *iis = &s3c24xx->iis; + s3c24xx_iis_t *iis = &m_iis; memset( &iis->regs, 0, sizeof( iis->regs)); iis->fifo_index = 0; iis->regs.iiscon = 0x0100; iis->timer->adjust( attotime::never); } -INLINE void iface_i2s_data_w( device_t *device, int ch, UINT16 data) +void S3C24_CLASS_NAME::iface_i2s_data_w(int ch, UINT16 data) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->i2s_data_w.isnull()) + if (!m_i2s_data_w.isnull()) { - (s3c24xx->i2s_data_w)( ch, data, 0); + (m_i2s_data_w)( ch, data, 0); } } -static void s3c24xx_iis_start( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_iis_start() { - s3c24xx_t *s3c24xx = get_token( device); const UINT32 codeclk_table[] = { 256, 384}; double freq; int pclk, prescaler_enable, prescaler_control_a, prescaler_control_b, codeclk; - verboselog( device->machine(), 1, "IIS start\n"); - prescaler_enable = BIT( s3c24xx->iis.regs.iiscon, 1); - prescaler_control_a = BITS( s3c24xx->iis.regs.iispsr, 9, 5); - prescaler_control_b = BITS( s3c24xx->iis.regs.iispsr, 4, 0); - codeclk = BIT( s3c24xx->iis.regs.iismod, 2); - pclk = s3c24xx_get_pclk( device); + verboselog( machine(), 1, "IIS start\n"); + prescaler_enable = BIT( m_iis.regs.iiscon, 1); + prescaler_control_a = BITS( m_iis.regs.iispsr, 9, 5); + prescaler_control_b = BITS( m_iis.regs.iispsr, 4, 0); + codeclk = BIT( m_iis.regs.iismod, 2); + pclk = s3c24xx_get_pclk(); freq = ((double)pclk / (prescaler_control_a + 1) / codeclk_table[codeclk]) * 2; // why do I have to multiply by two? - verboselog( device->machine(), 5, "IIS - pclk %d psc_enable %d psc_a %d psc_b %d codeclk %d freq %f\n", pclk, prescaler_enable, prescaler_control_a, prescaler_control_b, codeclk_table[codeclk], freq); - s3c24xx->iis.timer->adjust( attotime::from_hz( freq), 0, attotime::from_hz( freq)); + verboselog( machine(), 5, "IIS - pclk %d psc_enable %d psc_a %d psc_b %d codeclk %d freq %f\n", pclk, prescaler_enable, prescaler_control_a, prescaler_control_b, codeclk_table[codeclk], freq); + m_iis.timer->adjust( attotime::from_hz( freq), 0, attotime::from_hz( freq)); } -static void s3c24xx_iis_stop( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_iis_stop() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 1, "IIS stop\n"); - s3c24xx->iis.timer->adjust( attotime::never); + verboselog( machine(), 1, "IIS stop\n"); + m_iis.timer->adjust( attotime::never); } -static void s3c24xx_iis_recalc( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_iis_recalc() { - s3c24xx_t *s3c24xx = get_token( device); - if ((s3c24xx->iis.regs.iiscon & (1 << 0)) != 0) + if ((m_iis.regs.iiscon & (1 << 0)) != 0) { - s3c24xx_iis_start( device); + s3c24xx_iis_start(); } else { - s3c24xx_iis_stop( device); + s3c24xx_iis_stop(); } } -static READ32_DEVICE_HANDLER( s3c24xx_iis_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_iis_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->iis.regs)[offset]; + UINT32 data = ((UINT32*)&m_iis.regs)[offset]; #if 0 switch (offset) { @@ -2741,23 +2581,22 @@ static READ32_DEVICE_HANDLER( s3c24xx_iis_r ) break; } #endif - verboselog( device->machine(), 9, "(IIS) %08X -> %08X\n", S3C24XX_BASE_IIS + (offset << 2), data); + verboselog( machine(), 9, "(IIS) %08X -> %08X\n", S3C24XX_BASE_IIS + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_iis_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_iis_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->iis.regs)[offset]; - verboselog( device->machine(), 9, "(IIS) %08X <- %08X\n", S3C24XX_BASE_IIS + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->iis.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_iis.regs)[offset]; + verboselog( machine(), 9, "(IIS) %08X <- %08X\n", S3C24XX_BASE_IIS + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_iis.regs)[offset]); switch (offset) { case S3C24XX_IISCON : { if ((old_value & (1 << 0)) != (data & (1 << 0))) { - s3c24xx_iis_recalc( device); + s3c24xx_iis_recalc(); } } break; @@ -2765,36 +2604,34 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_iis_w ) { if (ACCESSING_BITS_16_31) { - s3c24xx->iis.fifo[s3c24xx->iis.fifo_index++] = BITS( data, 31, 16); + m_iis.fifo[m_iis.fifo_index++] = BITS( data, 31, 16); } if (ACCESSING_BITS_0_15) { - s3c24xx->iis.fifo[s3c24xx->iis.fifo_index++] = BITS( data, 15, 0); + m_iis.fifo[m_iis.fifo_index++] = BITS( data, 15, 0); } - if (s3c24xx->iis.fifo_index == 2) + if (m_iis.fifo_index == 2) { - s3c24xx->iis.fifo_index = 0; - iface_i2s_data_w( device, 0, s3c24xx->iis.fifo[0]); - iface_i2s_data_w( device, 1, s3c24xx->iis.fifo[1]); + m_iis.fifo_index = 0; + iface_i2s_data_w( 0, m_iis.fifo[0]); + iface_i2s_data_w( 1, m_iis.fifo[1]); } } break; } } -static TIMER_CALLBACK( s3c24xx_iis_timer_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_iis_timer_exp ) { - device_t *device = (device_t *)ptr; - verboselog( machine, 2, "IIS timer callback\n"); - s3c24xx_dma_request_iis( device); + verboselog( machine(), 2, "IIS timer callback\n"); + s3c24xx_dma_request_iis(); } /* RTC */ -static void s3c24xx_rtc_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_rtc_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_rtc_t *rtc = &s3c24xx->rtc; + s3c24xx_rtc_t *rtc = &m_rtc; memset( &rtc->regs, 0, sizeof( rtc->regs)); rtc->regs.almday = 1; rtc->regs.almmon = 1; @@ -2802,133 +2639,125 @@ static void s3c24xx_rtc_reset( device_t *device) rtc->timer_update->adjust( attotime::from_msec( 1000), 0, attotime::from_msec( 1000)); } -static READ32_DEVICE_HANDLER( s3c24xx_rtc_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_rtc_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->rtc.regs)[offset]; - verboselog( device->machine(), 9, "(RTC) %08X -> %08X\n", S3C24XX_BASE_RTC + (offset << 2), data); + UINT32 data = ((UINT32*)&m_rtc.regs)[offset]; + verboselog( machine(), 9, "(RTC) %08X -> %08X\n", S3C24XX_BASE_RTC + (offset << 2), data); return data; } -static void s3c24xx_rtc_recalc( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_rtc_recalc() { - s3c24xx_t *s3c24xx = get_token( device); - if (s3c24xx->rtc.regs.ticnt & (1 << 7)) + if (m_rtc.regs.ticnt & (1 << 7)) { UINT32 ttc; double freq; - ttc = BITS( s3c24xx->rtc.regs.ticnt, 6, 0); + ttc = BITS( m_rtc.regs.ticnt, 6, 0); freq = 128 / (ttc + 1); // printf( "ttc %d freq %f\n", ttc, freq); - s3c24xx->rtc.timer_tick_count->adjust( attotime::from_hz( freq), 0, attotime::from_hz( freq)); + m_rtc.timer_tick_count->adjust( attotime::from_hz( freq), 0, attotime::from_hz( freq)); } else { - s3c24xx->rtc.timer_tick_count->adjust( attotime::never); + m_rtc.timer_tick_count->adjust( attotime::never); } } -static WRITE32_DEVICE_HANDLER( s3c24xx_rtc_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_rtc_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(RTC) %08X <- %08X\n", S3C24XX_BASE_RTC + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->rtc.regs)[offset]); + verboselog( machine(), 9, "(RTC) %08X <- %08X\n", S3C24XX_BASE_RTC + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_rtc.regs)[offset]); switch (offset) { case S3C24XX_TICNT : { - s3c24xx_rtc_recalc( device); + s3c24xx_rtc_recalc(); } break; } } -static TIMER_CALLBACK( s3c24xx_rtc_timer_tick_count_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_rtc_timer_tick_count_exp ) { - device_t *device = (device_t *)ptr; - verboselog( machine, 2, "RTC timer callback (tick count)\n"); - s3c24xx_request_irq( device, S3C24XX_INT_TICK); + verboselog( machine(), 2, "RTC timer callback (tick count)\n"); + s3c24xx_request_irq( S3C24XX_INT_TICK); } -static void s3c24xx_rtc_update( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_rtc_update() { - s3c24xx_t *s3c24xx = get_token( device); UINT32 bcdday_max; // increase second - s3c24xx->rtc.regs.bcdsec = bcd_adjust( s3c24xx->rtc.regs.bcdsec + 1); - if (s3c24xx->rtc.regs.bcdsec >= 0x60) + m_rtc.regs.bcdsec = bcd_adjust( m_rtc.regs.bcdsec + 1); + if (m_rtc.regs.bcdsec >= 0x60) { - s3c24xx->rtc.regs.bcdsec = 0; + m_rtc.regs.bcdsec = 0; // increase minute - s3c24xx->rtc.regs.bcdmin = bcd_adjust( s3c24xx->rtc.regs.bcdmin + 1); - if (s3c24xx->rtc.regs.bcdmin >= 0x60) + m_rtc.regs.bcdmin = bcd_adjust( m_rtc.regs.bcdmin + 1); + if (m_rtc.regs.bcdmin >= 0x60) { - s3c24xx->rtc.regs.bcdmin = 0; + m_rtc.regs.bcdmin = 0; // increase hour - s3c24xx->rtc.regs.bcdhour = bcd_adjust( s3c24xx->rtc.regs.bcdhour + 1); - if (s3c24xx->rtc.regs.bcdhour >= 0x24) + m_rtc.regs.bcdhour = bcd_adjust( m_rtc.regs.bcdhour + 1); + if (m_rtc.regs.bcdhour >= 0x24) { - s3c24xx->rtc.regs.bcdhour = 0; + m_rtc.regs.bcdhour = 0; // increase day-of-week - s3c24xx->rtc.regs.bcddow = (s3c24xx->rtc.regs.bcddow % 7) + 1; + m_rtc.regs.bcddow = (m_rtc.regs.bcddow % 7) + 1; // increase day - s3c24xx->rtc.regs.bcdday = bcd_adjust( s3c24xx->rtc.regs.bcdday + 1); - bcdday_max = dec_2_bcd( gregorian_days_in_month( bcd_2_dec( s3c24xx->rtc.regs.bcdmon), bcd_2_dec( s3c24xx->rtc.regs.bcdyear) + 2000)); - if (s3c24xx->rtc.regs.bcdday > bcdday_max) + m_rtc.regs.bcdday = bcd_adjust( m_rtc.regs.bcdday + 1); + bcdday_max = dec_2_bcd( gregorian_days_in_month( bcd_2_dec( m_rtc.regs.bcdmon), bcd_2_dec( m_rtc.regs.bcdyear) + 2000)); + if (m_rtc.regs.bcdday > bcdday_max) { - s3c24xx->rtc.regs.bcdday = 1; + m_rtc.regs.bcdday = 1; // increase month - s3c24xx->rtc.regs.bcdmon = bcd_adjust( s3c24xx->rtc.regs.bcdmon + 1); - if (s3c24xx->rtc.regs.bcdmon >= 0x12) + m_rtc.regs.bcdmon = bcd_adjust( m_rtc.regs.bcdmon + 1); + if (m_rtc.regs.bcdmon >= 0x12) { - s3c24xx->rtc.regs.bcdmon = 1; + m_rtc.regs.bcdmon = 1; // increase year - s3c24xx->rtc.regs.bcdyear = bcd_adjust( s3c24xx->rtc.regs.bcdyear + 1); - if (s3c24xx->rtc.regs.bcdyear >= 0x100) + m_rtc.regs.bcdyear = bcd_adjust( m_rtc.regs.bcdyear + 1); + if (m_rtc.regs.bcdyear >= 0x100) { - s3c24xx->rtc.regs.bcdyear = 0; + m_rtc.regs.bcdyear = 0; } } } } } } - verboselog( device->machine(), 5, "RTC - %04d/%02d/%02d %02d:%02d:%02d\n", bcd_2_dec( s3c24xx->rtc.regs.bcdyear) + 2000, bcd_2_dec( s3c24xx->rtc.regs.bcdmon), bcd_2_dec( s3c24xx->rtc.regs.bcdday), bcd_2_dec( s3c24xx->rtc.regs.bcdhour), bcd_2_dec( s3c24xx->rtc.regs.bcdmin), bcd_2_dec( s3c24xx->rtc.regs.bcdsec)); + verboselog( machine(), 5, "RTC - %04d/%02d/%02d %02d:%02d:%02d\n", bcd_2_dec( m_rtc.regs.bcdyear) + 2000, bcd_2_dec( m_rtc.regs.bcdmon), bcd_2_dec( m_rtc.regs.bcdday), bcd_2_dec( m_rtc.regs.bcdhour), bcd_2_dec( m_rtc.regs.bcdmin), bcd_2_dec( m_rtc.regs.bcdsec)); } -static void s3c24xx_rtc_check_alarm( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_rtc_check_alarm() { - s3c24xx_t *s3c24xx = get_token( device); - if (s3c24xx->rtc.regs.rtcalm & 0x40) + if (m_rtc.regs.rtcalm & 0x40) { int isalarm = 1; - isalarm = isalarm && (((s3c24xx->rtc.regs.rtcalm & 0x20) == 0) || (s3c24xx->rtc.regs.almyear == s3c24xx->rtc.regs.bcdyear)); - isalarm = isalarm && (((s3c24xx->rtc.regs.rtcalm & 0x10) == 0) || (s3c24xx->rtc.regs.almmon == s3c24xx->rtc.regs.bcdmon)); - isalarm = isalarm && (((s3c24xx->rtc.regs.rtcalm & 0x08) == 0) || (s3c24xx->rtc.regs.almday == s3c24xx->rtc.regs.bcdday)); - isalarm = isalarm && (((s3c24xx->rtc.regs.rtcalm & 0x04) == 0) || (s3c24xx->rtc.regs.almhour == s3c24xx->rtc.regs.bcdhour)); - isalarm = isalarm && (((s3c24xx->rtc.regs.rtcalm & 0x02) == 0) || (s3c24xx->rtc.regs.almmin == s3c24xx->rtc.regs.bcdmin)); - isalarm = isalarm && (((s3c24xx->rtc.regs.rtcalm & 0x01) == 0) || (s3c24xx->rtc.regs.almsec == s3c24xx->rtc.regs.bcdsec)); + isalarm = isalarm && (((m_rtc.regs.rtcalm & 0x20) == 0) || (m_rtc.regs.almyear == m_rtc.regs.bcdyear)); + isalarm = isalarm && (((m_rtc.regs.rtcalm & 0x10) == 0) || (m_rtc.regs.almmon == m_rtc.regs.bcdmon)); + isalarm = isalarm && (((m_rtc.regs.rtcalm & 0x08) == 0) || (m_rtc.regs.almday == m_rtc.regs.bcdday)); + isalarm = isalarm && (((m_rtc.regs.rtcalm & 0x04) == 0) || (m_rtc.regs.almhour == m_rtc.regs.bcdhour)); + isalarm = isalarm && (((m_rtc.regs.rtcalm & 0x02) == 0) || (m_rtc.regs.almmin == m_rtc.regs.bcdmin)); + isalarm = isalarm && (((m_rtc.regs.rtcalm & 0x01) == 0) || (m_rtc.regs.almsec == m_rtc.regs.bcdsec)); if (isalarm != 0) { - s3c24xx_request_irq( device, S3C24XX_INT_RTC); + s3c24xx_request_irq(S3C24XX_INT_RTC); } } } -static TIMER_CALLBACK( s3c24xx_rtc_timer_update_exp ) +TIMER_CALLBACK_MEMBER( S3C24_CLASS_NAME::s3c24xx_rtc_timer_update_exp ) { - device_t *device = (device_t *)ptr; - verboselog( machine, 2, "RTC timer callback (update)\n"); - s3c24xx_rtc_update( device); - s3c24xx_rtc_check_alarm( device); + verboselog( machine(), 2, "RTC timer callback (update)\n"); + s3c24xx_rtc_update(); + s3c24xx_rtc_check_alarm(); } /* A/D Converter */ -static void s3c24xx_adc_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_adc_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_adc_t *adc = &s3c24xx->adc; + s3c24xx_adc_t *adc = &m_adc; memset( &adc->regs, 0, sizeof( adc->regs)); adc->regs.adccon = 0x3FC4; #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) @@ -2937,19 +2766,18 @@ static void s3c24xx_adc_reset( device_t *device) #endif } -static UINT32 iface_adc_data_r( device_t *device, int ch) +UINT32 S3C24_CLASS_NAME::iface_adc_data_r(int ch) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->adc_data_r.isnull()) + if (!m_adc_data_r.isnull()) { int offs = ch; #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - if (BIT( s3c24xx->adc.regs.adctsc, 2) != 0) + if (BIT( m_adc.regs.adctsc, 2) != 0) { offs += 2; } #endif - return (s3c24xx->adc_data_r)(offs, 0); + return (m_adc_data_r)(offs, 0); } else { @@ -2957,59 +2785,56 @@ static UINT32 iface_adc_data_r( device_t *device, int ch) } } -static READ32_DEVICE_HANDLER( s3c24xx_adc_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_adc_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->adc.regs)[offset]; + UINT32 data = ((UINT32*)&m_adc.regs)[offset]; switch (offset) { #if defined(DEVICE_S3C2400) case S3C24XX_ADCDAT : { - data = (data & ~0x3FF) | (iface_adc_data_r( device, 0) & 0x3FF); + data = (data & ~0x3FF) | (iface_adc_data_r( 0) & 0x3FF); } break; #else case S3C24XX_ADCDAT0 : { - data = (data & ~0x3FF) | (iface_adc_data_r( device, 0) & 0x3FF); + data = (data & ~0x3FF) | (iface_adc_data_r( 0) & 0x3FF); } break; case S3C24XX_ADCDAT1 : { - data = (data & ~0x3FF) | (iface_adc_data_r( device, 1) & 0x3FF); + data = (data & ~0x3FF) | (iface_adc_data_r( 1) & 0x3FF); } break; #endif } - verboselog( device->machine(), 9, "(ADC) %08X -> %08X\n", S3C24XX_BASE_ADC + (offset << 2), data); + verboselog( machine(), 9, "(ADC) %08X -> %08X\n", S3C24XX_BASE_ADC + (offset << 2), data); return data; } -static void s3c24xx_adc_start( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_adc_start() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 1, "ADC start\n"); - s3c24xx->adc.regs.adccon &= ~(1 << 0); // A/D conversion is completed - s3c24xx->adc.regs.adccon |= (1 << 15); // End of A/D conversion + verboselog( machine(), 1, "ADC start\n"); + m_adc.regs.adccon &= ~(1 << 0); // A/D conversion is completed + m_adc.regs.adccon |= (1 << 15); // End of A/D conversion #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - s3c24xx_request_subirq( device, S3C24XX_SUBINT_ADC); + s3c24xx_request_subirq( S3C24XX_SUBINT_ADC); #endif } -static WRITE32_DEVICE_HANDLER( s3c24xx_adc_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_adc_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->adc.regs)[offset]; - verboselog( device->machine(), 9, "(ADC) %08X <- %08X\n", S3C24XX_BASE_ADC + (offset << 2), data); - COMBINE_DATA(&((UINT32*)&s3c24xx->adc.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_adc.regs)[offset]; + verboselog( machine(), 9, "(ADC) %08X <- %08X\n", S3C24XX_BASE_ADC + (offset << 2), data); + COMBINE_DATA(&((UINT32*)&m_adc.regs)[offset]); switch (offset) { case S3C24XX_ADCCON : { if (((old_value & (1 << 0)) == 0) && ((data & (1 << 0)) != 0)) { - s3c24xx_adc_start( device); + s3c24xx_adc_start(); } } break; @@ -3018,24 +2843,22 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_adc_w ) #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static void s3c24xx_touch_screen( device_t *device, int state) +void S3C24_CLASS_NAME::s3c24xx_touch_screen(int state) { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx->adc.regs.adcdat0 = ((state ? 0 : 1) << 15); - s3c24xx->adc.regs.adcdat1 = ((state ? 0 : 1) << 15); - s3c24xx_request_subirq( device, S3C24XX_SUBINT_TC); + m_adc.regs.adcdat0 = ((state ? 0 : 1) << 15); + m_adc.regs.adcdat1 = ((state ? 0 : 1) << 15); + s3c24xx_request_subirq( S3C24XX_SUBINT_TC); } #endif /* SPI */ -static void s3c24xx_spi_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_spi_reset() { - s3c24xx_t *s3c24xx = get_token( device); for (int i = 0; i < S3C24XX_SPI_COUNT; i++) { - s3c24xx_spi_t *spi = &s3c24xx->spi[i]; + s3c24xx_spi_t *spi = &m_spi[i]; memset( &spi->regs, 0, sizeof( spi->regs)); spi->regs.spsta = 1; #if defined(DEVICE_S3C2400) || defined(DEVICE_S3C2410) @@ -3044,10 +2867,9 @@ static void s3c24xx_spi_reset( device_t *device) } } -static UINT32 s3c24xx_spi_r( device_t *device, UINT32 ch, UINT32 offset) +UINT32 S3C24_CLASS_NAME::s3c24xx_spi_r(UINT32 ch, UINT32 offset) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->spi[ch].regs)[offset]; + UINT32 data = ((UINT32*)&m_spi[ch].regs)[offset]; switch (offset) { case S3C24XX_SPSTA : @@ -3059,42 +2881,41 @@ static UINT32 s3c24xx_spi_r( device_t *device, UINT32 ch, UINT32 offset) return data; } -static void s3c24xx_spi_w( device_t *device, UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask) +void S3C24_CLASS_NAME::s3c24xx_spi_w(UINT32 ch, UINT32 offset, UINT32 data, UINT32 mem_mask) { - s3c24xx_t *s3c24xx = get_token( device); - COMBINE_DATA(&((UINT32*)&s3c24xx->spi[ch].regs)[offset]); + COMBINE_DATA(&((UINT32*)&m_spi[ch].regs)[offset]); } -static READ32_DEVICE_HANDLER( s3c24xx_spi_0_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_spi_0_r ) { - UINT32 data = s3c24xx_spi_r( device, 0, offset); - verboselog( device->machine(), 9, "(SPI 0) %08X -> %08X\n", S3C24XX_BASE_SPI_0 + (offset << 2), data); + UINT32 data = s3c24xx_spi_r( 0, offset); + verboselog( machine(), 9, "(SPI 0) %08X -> %08X\n", S3C24XX_BASE_SPI_0 + (offset << 2), data); return data; } #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static READ32_DEVICE_HANDLER( s3c24xx_spi_1_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_spi_1_r ) { - UINT32 data = s3c24xx_spi_r( device, 1, offset); - verboselog( device->machine(), 9, "(SPI 1) %08X -> %08X\n", S3C24XX_BASE_SPI_1 + (offset << 2), data); + UINT32 data = s3c24xx_spi_r( 1, offset); + verboselog( machine(), 9, "(SPI 1) %08X -> %08X\n", S3C24XX_BASE_SPI_1 + (offset << 2), data); return data; } #endif -static WRITE32_DEVICE_HANDLER( s3c24xx_spi_0_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_spi_0_w ) { - verboselog( device->machine(), 9, "(SPI 0) %08X <- %08X\n", S3C24XX_BASE_SPI_0 + (offset << 2), data); - s3c24xx_spi_w( device, 0, offset, data, mem_mask); + verboselog( machine(), 9, "(SPI 0) %08X <- %08X\n", S3C24XX_BASE_SPI_0 + (offset << 2), data); + s3c24xx_spi_w( 0, offset, data, mem_mask); } #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static WRITE32_DEVICE_HANDLER( s3c24xx_spi_1_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_spi_1_w ) { - verboselog( device->machine(), 9, "(SPI 1) %08X <- %08X\n", S3C24XX_BASE_SPI_1 + (offset << 2), data); - s3c24xx_spi_w( device, 1, offset, data, mem_mask); + verboselog( machine(), 9, "(SPI 1) %08X <- %08X\n", S3C24XX_BASE_SPI_1 + (offset << 2), data); + s3c24xx_spi_w( 1, offset, data, mem_mask); } #endif @@ -3103,26 +2924,23 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_spi_1_w ) #if defined(DEVICE_S3C2400) -static void s3c24xx_mmc_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_mmc_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_mmc_t *mmc = &s3c24xx->mmc; + s3c24xx_mmc_t *mmc = &m_mmc; memset( &mmc->regs, 0, sizeof( mmc->regs)); } -static READ32_DEVICE_HANDLER( s3c24xx_mmc_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_mmc_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->mmc.regs.data[offset]; - verboselog( device->machine(), 9, "(MMC) %08X -> %08X\n", S3C24XX_BASE_MMC + (offset << 2), data); + UINT32 data = m_mmc.regs.data[offset]; + verboselog( machine(), 9, "(MMC) %08X -> %08X\n", S3C24XX_BASE_MMC + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_mmc_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_mmc_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(MMC) %08X <- %08X\n", S3C24XX_BASE_MMC + (offset << 2), data); - COMBINE_DATA(&s3c24xx->mmc.regs.data[offset]); + verboselog( machine(), 9, "(MMC) %08X <- %08X\n", S3C24XX_BASE_MMC + (offset << 2), data); + COMBINE_DATA(&m_mmc.regs.data[offset]); } #endif @@ -3131,10 +2949,9 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_mmc_w ) #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static void s3c24xx_sdi_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_sdi_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_sdi_t *sdi = &s3c24xx->sdi; + s3c24xx_sdi_t *sdi = &m_sdi; memset( &sdi->regs, 0, sizeof( sdi->regs)); #if defined(DEVICE_S3C2410) sdi->regs.data[0x24/4] = 0x2000; @@ -3144,19 +2961,17 @@ static void s3c24xx_sdi_reset( device_t *device) #endif } -static READ32_DEVICE_HANDLER( s3c24xx_sdi_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_sdi_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->sdi.regs.data[offset]; - verboselog( device->machine(), 9, "(SDI) %08X -> %08X\n", S3C24XX_BASE_SDI + (offset << 2), data); + UINT32 data = m_sdi.regs.data[offset]; + verboselog( machine(), 9, "(SDI) %08X -> %08X\n", S3C24XX_BASE_SDI + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_sdi_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_sdi_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(SDI) %08X <- %08X\n", S3C24XX_BASE_SDI + (offset << 2), data); - COMBINE_DATA(&s3c24xx->sdi.regs.data[offset]); + verboselog( machine(), 9, "(SDI) %08X <- %08X\n", S3C24XX_BASE_SDI + (offset << 2), data); + COMBINE_DATA(&m_sdi.regs.data[offset]); } #endif @@ -3165,10 +2980,9 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_sdi_w ) #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static void s3c24xx_nand_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_nand_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_nand_t *nand = &s3c24xx->nand; + s3c24xx_nand_t *nand = &m_nand; memset( &nand->regs, 0, sizeof( nand->regs)); #if defined(DEVICE_S3C2440) nand->regs.nfconf = 0x1000; @@ -3176,30 +2990,27 @@ static void s3c24xx_nand_reset( device_t *device) #endif } -INLINE void iface_nand_command_w( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::iface_nand_command_w(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->command_w.isnull()) + if (!m_command_w.isnull()) { - (s3c24xx->command_w)( 0, data, 0xff); + (m_command_w)( 0, data, 0xff); } } -INLINE void iface_nand_address_w( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::iface_nand_address_w(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->address_w.isnull()) + if (!m_address_w.isnull()) { - (s3c24xx->address_w)( 0, data, 0xff); + (m_address_w)( 0, data, 0xff); } } -INLINE UINT8 iface_nand_data_r( device_t *device) +UINT8 S3C24_CLASS_NAME::iface_nand_data_r() { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->nand_data_r.isnull()) + if (!m_nand_data_r.isnull()) { - return (s3c24xx->nand_data_r)( 0, 0xff); + return (m_nand_data_r)( 0, 0xff); } else { @@ -3207,16 +3018,15 @@ INLINE UINT8 iface_nand_data_r( device_t *device) } } -INLINE void iface_nand_data_w( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::iface_nand_data_w(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - if (!s3c24xx->nand_data_w.isnull()) + if (!m_nand_data_w.isnull()) { - (s3c24xx->nand_data_w)(0, data, 0xff); + (m_nand_data_w)(0, data, 0xff); } } -static void nand_update_mecc( UINT8 *ecc, int pos, UINT8 data) +void S3C24_CLASS_NAME::nand_update_mecc( UINT8 *ecc, int pos, UINT8 data) { int bit[8]; UINT8 temp; @@ -3252,7 +3062,7 @@ static void nand_update_mecc( UINT8 *ecc, int pos, UINT8 data) #if defined(DEVICE_S3C2440) -static void nand_update_secc( UINT8 *ecc, int pos, UINT8 data) +void S3C24_CLASS_NAME::nand_update_secc( UINT8 *ecc, int pos, UINT8 data) { int bit[8]; UINT8 temp; @@ -3281,17 +3091,16 @@ static void nand_update_secc( UINT8 *ecc, int pos, UINT8 data) #endif -static void s3c24xx_nand_update_ecc( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::s3c24xx_nand_update_ecc(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_nand_t *nand = &s3c24xx->nand; + s3c24xx_nand_t *nand = &m_nand; UINT8 temp[4]; #if defined(DEVICE_S3C2410) temp[0] = nand->mecc[0]; temp[1] = nand->mecc[1]; temp[2] = nand->mecc[2]; nand_update_mecc( nand->mecc, nand->ecc_pos++, data); - verboselog( device->machine(), 5, "NAND - MECC %03X - %02X %02X %02X -> %02X %02X %02X\n", nand->ecc_pos - 1, temp[0], temp[1], temp[2], nand->mecc[0], nand->mecc[1], nand->mecc[2]); + verboselog( machine(), 5, "NAND - MECC %03X - %02X %02X %02X -> %02X %02X %02X\n", nand->ecc_pos - 1, temp[0], temp[1], temp[2], nand->mecc[0], nand->mecc[1], nand->mecc[2]); if (nand->ecc_pos == 512) nand->ecc_pos = 0; #else if ((nand->regs.nfcont & (1 << 5)) == 0) @@ -3301,7 +3110,7 @@ static void s3c24xx_nand_update_ecc( device_t *device, UINT8 data) temp[2] = nand->mecc[2]; temp[3] = nand->mecc[3]; nand_update_mecc( nand->mecc, nand->ecc_pos++, data); - verboselog( device->machine(), 5, "NAND - MECC %03X - %02X %02X %02X %02X -> %02X %02X %02X %02X\n", nand->ecc_pos - 1, temp[0], temp[1], temp[2], temp[3], nand->mecc[0], nand->mecc[1], nand->mecc[2], nand->mecc[3]); + verboselog( machine(), 5, "NAND - MECC %03X - %02X %02X %02X %02X -> %02X %02X %02X %02X\n", nand->ecc_pos - 1, temp[0], temp[1], temp[2], temp[3], nand->mecc[0], nand->mecc[1], nand->mecc[2], nand->mecc[3]); if (nand->ecc_pos == 2048) nand->ecc_pos = 0; } if ((nand->regs.nfcont & (1 << 6)) == 0) @@ -3309,80 +3118,75 @@ static void s3c24xx_nand_update_ecc( device_t *device, UINT8 data) temp[0] = nand->secc[0]; temp[1] = nand->secc[1]; nand_update_secc( nand->secc, nand->ecc_pos++, data); - verboselog( device->machine(), 5, "NAND - SECC %02X - %02X %02X -> %02X %02X\n", nand->ecc_pos - 1, temp[0], temp[1], nand->secc[0], nand->secc[1]); + verboselog( machine(), 5, "NAND - SECC %02X - %02X %02X -> %02X %02X\n", nand->ecc_pos - 1, temp[0], temp[1], nand->secc[0], nand->secc[1]); if (nand->ecc_pos == 16) nand->ecc_pos = 0; } #endif } -static void s3c24xx_nand_command_w( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::s3c24xx_nand_command_w(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "NAND write command %02X\n", data); - s3c24xx->nand.data_count = 0; - iface_nand_command_w( device, data); + verboselog( machine(), 5, "NAND write command %02X\n", data); + m_nand.data_count = 0; + iface_nand_command_w( data); } -static void s3c24xx_nand_address_w( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::s3c24xx_nand_address_w(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "NAND write address %02X\n", data); - s3c24xx->nand.data_count = 0; - iface_nand_address_w( device, data); + verboselog( machine(), 5, "NAND write address %02X\n", data); + m_nand.data_count = 0; + iface_nand_address_w( data); } -static UINT8 s3c24xx_nand_data_r( device_t *device) +UINT8 S3C24_CLASS_NAME::s3c24xx_nand_data_r() { - s3c24xx_t *s3c24xx = get_token( device); - UINT8 data = iface_nand_data_r( device); - verboselog( device->machine(), 5, "NAND read data %02X [%04X]\n", data, s3c24xx->nand.data_count++); - s3c24xx_nand_update_ecc( device, data); + UINT8 data = iface_nand_data_r(); + verboselog( machine(), 5, "NAND read data %02X [%04X]\n", data, m_nand.data_count++); + s3c24xx_nand_update_ecc( data); return data; } -static void s3c24xx_nand_data_w( device_t *device, UINT8 data) +void S3C24_CLASS_NAME::s3c24xx_nand_data_w(UINT8 data) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "NAND write data %02X [%04X]\n", data, s3c24xx->nand.data_count++); - iface_nand_data_w( device, data); - s3c24xx_nand_update_ecc( device, data); + verboselog( machine(), 5, "NAND write data %02X [%04X]\n", data, m_nand.data_count++); + iface_nand_data_w( data); + s3c24xx_nand_update_ecc( data); } -static READ32_DEVICE_HANDLER( s3c24xx_nand_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_nand_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = ((UINT32*)&s3c24xx->nand.regs)[offset]; + UINT32 data = ((UINT32*)&m_nand.regs)[offset]; switch (offset) { case S3C24XX_NFDATA : { data = 0; #if defined(DEVICE_S3C2410) - data = data | s3c24xx_nand_data_r( device); + data = data | s3c24xx_nand_data_r(); #elif defined(DEVICE_S3C2440) - if ((mem_mask & 0x000000FF) != 0) data = data | (s3c24xx_nand_data_r( device) << 0); - if ((mem_mask & 0x0000FF00) != 0) data = data | (s3c24xx_nand_data_r( device) << 8); - if ((mem_mask & 0x00FF0000) != 0) data = data | (s3c24xx_nand_data_r( device) << 16); - if ((mem_mask & 0xFF000000) != 0) data = data | (s3c24xx_nand_data_r( device) << 24); + if ((mem_mask & 0x000000FF) != 0) data = data | (s3c24xx_nand_data_r() << 0); + if ((mem_mask & 0x0000FF00) != 0) data = data | (s3c24xx_nand_data_r() << 8); + if ((mem_mask & 0x00FF0000) != 0) data = data | (s3c24xx_nand_data_r() << 16); + if ((mem_mask & 0xFF000000) != 0) data = data | (s3c24xx_nand_data_r() << 24); #endif } break; #if defined(DEVICE_S3C2410) case S3C24XX_NFECC : { - data = ((s3c24xx->nand.mecc[2] << 16) | (s3c24xx->nand.mecc[1] << 8) | (s3c24xx->nand.mecc[0] << 0)); + data = ((m_nand.mecc[2] << 16) | (m_nand.mecc[1] << 8) | (m_nand.mecc[0] << 0)); } break; #endif #if defined(DEVICE_S3C2440) case S3C24XX_NFMECC0 : { - data = (s3c24xx->nand.mecc[3] << 24) | (s3c24xx->nand.mecc[2] << 16) | (s3c24xx->nand.mecc[1] << 8) | (s3c24xx->nand.mecc[0] << 0); + data = (m_nand.mecc[3] << 24) | (m_nand.mecc[2] << 16) | (m_nand.mecc[1] << 8) | (m_nand.mecc[0] << 0); } break; case S3C24XX_NFSECC : { - data = (s3c24xx->nand.secc[1] << 8) | (s3c24xx->nand.secc[0] << 0); + data = (m_nand.secc[1] << 8) | (m_nand.secc[0] << 0); } break; case S3C24XX_NFESTAT0 : @@ -3397,31 +3201,29 @@ static READ32_DEVICE_HANDLER( s3c24xx_nand_r ) break; #endif } - verboselog( device->machine(), 9, "(NAND) %08X -> %08X (%08X)\n", S3C24XX_BASE_NAND + (offset << 2), data, mem_mask); + verboselog( machine(), 9, "(NAND) %08X -> %08X (%08X)\n", S3C24XX_BASE_NAND + (offset << 2), data, mem_mask); return data; } -static void s3c24xx_nand_init_ecc( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_nand_init_ecc() { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 5, "NAND - init ecc\n"); - s3c24xx->nand.mecc[0] = 0xFF; - s3c24xx->nand.mecc[1] = 0xFF; - s3c24xx->nand.mecc[2] = 0xFF; + verboselog( machine(), 5, "NAND - init ecc\n"); + m_nand.mecc[0] = 0xFF; + m_nand.mecc[1] = 0xFF; + m_nand.mecc[2] = 0xFF; #if defined(DEVICE_S3C2440) - s3c24xx->nand.mecc[3] = 0xFF; - s3c24xx->nand.secc[0] = 0; - s3c24xx->nand.secc[1] = 0; + m_nand.mecc[3] = 0xFF; + m_nand.secc[0] = 0; + m_nand.secc[1] = 0; #endif - s3c24xx->nand.ecc_pos = 0; + m_nand.ecc_pos = 0; } -static WRITE32_DEVICE_HANDLER( s3c24xx_nand_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_nand_w ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 old_value = ((UINT32*)&s3c24xx->nand.regs)[offset]; - verboselog( device->machine(), 9, "(NAND) %08X <- %08X (%08X)\n", S3C24XX_BASE_NAND + (offset << 2), data, mem_mask); - COMBINE_DATA(&((UINT32*)&s3c24xx->nand.regs)[offset]); + UINT32 old_value = ((UINT32*)&m_nand.regs)[offset]; + verboselog( machine(), 9, "(NAND) %08X <- %08X (%08X)\n", S3C24XX_BASE_NAND + (offset << 2), data, mem_mask); + COMBINE_DATA(&((UINT32*)&m_nand.regs)[offset]); switch (offset) { #if defined(DEVICE_S3C2410) @@ -3429,7 +3231,7 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_nand_w ) { if ((data & (1 << 12)) != 0) { - s3c24xx_nand_init_ecc( device); + s3c24xx_nand_init_ecc(); } } break; @@ -3439,68 +3241,67 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_nand_w ) { if ((data & (1 << 4)) != 0) { - s3c24xx_nand_init_ecc( device); + s3c24xx_nand_init_ecc(); } } break; #endif case S3C24XX_NFSTAT : { - s3c24xx->nand.regs.nfstat = (s3c24xx->nand.regs.nfstat & ~0x03) | (old_value & 0x03); // read-only + m_nand.regs.nfstat = (m_nand.regs.nfstat & ~0x03) | (old_value & 0x03); // read-only #if defined(DEVICE_S3C2440) if ((data & (1 << 2)) != 0) { - s3c24xx->nand.regs.nfstat &= ~(1 << 2); // "RnB_TransDetect, to clear this value write 1" + m_nand.regs.nfstat &= ~(1 << 2); // "RnB_TransDetect, to clear this value write 1" } #endif } break; case S3C24XX_NFCMD : { - s3c24xx_nand_command_w( device, data); + s3c24xx_nand_command_w(data); } break; case S3C24XX_NFADDR : { - s3c24xx_nand_address_w( device, data); + s3c24xx_nand_address_w(data); } break; case S3C24XX_NFDATA : { #if defined(DEVICE_S3C2410) - s3c24xx_nand_data_w( device, data & 0xFF); + s3c24xx_nand_data_w(data & 0xFF); #elif defined(DEVICE_S3C2440) - if ((mem_mask & 0x000000FF) != 0) s3c24xx_nand_data_w( device, (data >> 0) & 0xFF); - if ((mem_mask & 0x0000FF00) != 0) s3c24xx_nand_data_w( device, (data >> 8) & 0xFF); - if ((mem_mask & 0x00FF0000) != 0) s3c24xx_nand_data_w( device, (data >> 16) & 0xFF); - if ((mem_mask & 0xFF000000) != 0) s3c24xx_nand_data_w( device, (data >> 24) & 0xFF); + if ((mem_mask & 0x000000FF) != 0) s3c24xx_nand_data_w((data >> 0) & 0xFF); + if ((mem_mask & 0x0000FF00) != 0) s3c24xx_nand_data_w((data >> 8) & 0xFF); + if ((mem_mask & 0x00FF0000) != 0) s3c24xx_nand_data_w((data >> 16) & 0xFF); + if ((mem_mask & 0xFF000000) != 0) s3c24xx_nand_data_w((data >> 24) & 0xFF); #endif } break; } } -ATTR_UNUSED static WRITE_LINE_DEVICE_HANDLER( s3c24xx_pin_frnb_w ) +ATTR_UNUSED WRITE_LINE_MEMBER( S3C24_CLASS_NAME::s3c24xx_pin_frnb_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "s3c24xx_pin_frnb_w (%d)\n", state); + verboselog( machine(), 9, "s3c24xx_pin_frnb_w (%d)\n", state); #if defined(DEVICE_S3C2440) - if ((BIT( s3c24xx->nand.regs.nfstat, 0) == 0) && (state != 0)) + if ((BIT( m_nand.regs.nfstat, 0) == 0) && (state != 0)) { - s3c24xx->nand.regs.nfstat |= (1 << 2); - if (BIT( s3c24xx->nand.regs.nfcont, 9) != 0) + m_nand.regs.nfstat |= (1 << 2); + if (BIT( m_nand.regs.nfcont, 9) != 0) { - s3c24xx_request_irq( device, S3C24XX_INT_NFCON); + s3c24xx_request_irq( S3C24XX_INT_NFCON); } } #endif if (state == 0) { - s3c24xx->nand.regs.nfstat &= ~(1 << 0); + m_nand.regs.nfstat &= ~(1 << 0); } else { - s3c24xx->nand.regs.nfstat |= (1 << 0); + m_nand.regs.nfstat |= (1 << 0); } } @@ -3510,26 +3311,23 @@ ATTR_UNUSED static WRITE_LINE_DEVICE_HANDLER( s3c24xx_pin_frnb_w ) #if defined(DEVICE_S3C2440) -static void s3c24xx_cam_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_cam_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_cam_t *cam = &s3c24xx->cam; + s3c24xx_cam_t *cam = &m_cam; memset( &cam->regs, 0, sizeof( cam->regs)); } -static READ32_DEVICE_HANDLER( s3c24xx_cam_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_cam_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->cam.regs.data[offset]; - verboselog( device->machine(), 9, "(CAM) %08X -> %08X\n", S3C24XX_BASE_CAM + (offset << 2), data); + UINT32 data = m_cam.regs.data[offset]; + verboselog( machine(), 9, "(CAM) %08X -> %08X\n", S3C24XX_BASE_CAM + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_cam_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_cam_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(CAM) %08X <- %08X\n", S3C24XX_BASE_CAM + (offset << 2), data); - COMBINE_DATA(&s3c24xx->cam.regs.data[offset]); + verboselog( machine(), 9, "(CAM) %08X <- %08X\n", S3C24XX_BASE_CAM + (offset << 2), data); + COMBINE_DATA(&m_cam.regs.data[offset]); } #endif @@ -3538,26 +3336,23 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_cam_w ) #if defined(DEVICE_S3C2440) -static void s3c24xx_ac97_reset( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_ac97_reset() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx_ac97_t *ac97 = &s3c24xx->ac97; + s3c24xx_ac97_t *ac97 = &m_ac97; memset( &ac97->regs, 0, sizeof( ac97->regs)); } -static READ32_DEVICE_HANDLER( s3c24xx_ac97_r ) +READ32_MEMBER( S3C24_CLASS_NAME::s3c24xx_ac97_r ) { - s3c24xx_t *s3c24xx = get_token( device); - UINT32 data = s3c24xx->ac97.regs.data[offset]; - verboselog( device->machine(), 9, "(AC97) %08X -> %08X\n", S3C24XX_BASE_AC97 + (offset << 2), data); + UINT32 data = m_ac97.regs.data[offset]; + verboselog( machine(), 9, "(AC97) %08X -> %08X\n", S3C24XX_BASE_AC97 + (offset << 2), data); return data; } -static WRITE32_DEVICE_HANDLER( s3c24xx_ac97_w ) +WRITE32_MEMBER( S3C24_CLASS_NAME::s3c24xx_ac97_w ) { - s3c24xx_t *s3c24xx = get_token( device); - verboselog( device->machine(), 9, "(AC97) %08X <- %08X\n", S3C24XX_BASE_AC97 + (offset << 2), data); - COMBINE_DATA(&s3c24xx->ac97.regs.data[offset]); + verboselog( machine(), 9, "(AC97) %08X <- %08X\n", S3C24XX_BASE_AC97 + (offset << 2), data); + COMBINE_DATA(&m_ac97.regs.data[offset]); } #endif @@ -3566,15 +3361,14 @@ static WRITE32_DEVICE_HANDLER( s3c24xx_ac97_w ) #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) -static void s3c24xx_nand_auto_boot( device_t *device) +void S3C24_CLASS_NAME::s3c24xx_nand_auto_boot() { - int om0 = iface_core_pin_r( device, S3C24XX_CORE_PIN_OM0); - int om1 = iface_core_pin_r( device, S3C24XX_CORE_PIN_OM1); + int om0 = iface_core_pin_r( S3C24XX_CORE_PIN_OM0); + int om1 = iface_core_pin_r( S3C24XX_CORE_PIN_OM1); if ((om0 == 0) && (om1 == 0)) { - s3c24xx_t *s3c24xx = get_token( device); - int ncon = iface_core_pin_r( device, S3C24XX_CORE_PIN_NCON); - UINT8 *ptr = s3c24xx->steppingstone; + int ncon = iface_core_pin_r( S3C24XX_CORE_PIN_NCON); + UINT8 *ptr = m_steppingstone; int page_size, address_cycle; #if defined(DEVICE_S3C2410) page_size = 512; @@ -3587,7 +3381,7 @@ static void s3c24xx_nand_auto_boot( device_t *device) address_cycle = 4; // byte-page-page-page } #elif defined(DEVICE_S3C2440) - UINT32 port_g = iface_gpio_port_r( device, S3C24XX_GPIO_PORT_G, 0); + UINT32 port_g = iface_gpio_port_r( S3C24XX_GPIO_PORT_G, 0); if (ncon == 0) { if (BIT( port_g, 13) == 0) @@ -3615,112 +3409,108 @@ static void s3c24xx_nand_auto_boot( device_t *device) } } #endif - iface_nand_command_w( device, 0xFF); + iface_nand_command_w( 0xFF); for (int page = 0; page < (4 * 1024) / page_size; page++) { - iface_nand_command_w( device, 0x00); - iface_nand_address_w( device, 0x00); + iface_nand_command_w( 0x00); + iface_nand_address_w( 0x00); if (address_cycle > 4) { - iface_nand_address_w( device, 0x00); + iface_nand_address_w( 0x00); } - iface_nand_address_w( device, (page >> 0) & 0xFF); - iface_nand_address_w( device, (page >> 8) & 0xFF); + iface_nand_address_w( (page >> 0) & 0xFF); + iface_nand_address_w( (page >> 8) & 0xFF); if (address_cycle > 3) { - iface_nand_address_w( device, (page >> 16) & 0xFF); + iface_nand_address_w( (page >> 16) & 0xFF); } for (int i = 0; i < page_size; i++) { - *ptr++ = iface_nand_data_r( device); + *ptr++ = iface_nand_data_r(); } } - iface_nand_command_w( device, 0xFF); + iface_nand_command_w( 0xFF); } } #endif -static DEVICE_RESET( s3c24xx ) +void S3C24_CLASS_NAME::s3c24xx_device_reset() { - verboselog( device->machine(), 1, "s3c24xx device reset\n"); - s3c24xx_uart_reset( device); - s3c24xx_pwm_reset( device); - s3c24xx_dma_reset( device); - s3c24xx_iic_reset( device); - s3c24xx_iis_reset( device); - s3c24xx_lcd_reset( device); - s3c24xx_rtc_reset( device); - s3c24xx_wdt_reset( device); - s3c24xx_irq_reset( device); - s3c24xx_gpio_reset( device); - s3c24xx_memcon_reset( device); - s3c24xx_clkpow_reset( device); - s3c24xx_usb_host_reset( device); - s3c24xx_usb_device_reset( device); - s3c24xx_adc_reset( device); - s3c24xx_spi_reset( device); + verboselog( machine(), 1, "s3c24xx device reset\n"); + s3c24xx_uart_reset( ); + s3c24xx_pwm_reset(); + s3c24xx_dma_reset(); + s3c24xx_iic_reset(); + s3c24xx_iis_reset(); + s3c24xx_lcd_reset(); + s3c24xx_rtc_reset(); + s3c24xx_wdt_reset(); + s3c24xx_irq_reset(); + s3c24xx_gpio_reset(); + s3c24xx_memcon_reset(); + s3c24xx_clkpow_reset(); + s3c24xx_usb_host_reset(); + s3c24xx_usb_device_reset(); + s3c24xx_adc_reset(); + s3c24xx_spi_reset(); #if defined(DEVICE_S3C2400) - s3c24xx_mmc_reset( device); + s3c24xx_mmc_reset(); #endif #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - s3c24xx_sdi_reset( device); - s3c24xx_nand_reset( device); + s3c24xx_sdi_reset(); + s3c24xx_nand_reset(); #endif #if defined(DEVICE_S3C2440) - s3c24xx_cam_reset( device); - s3c24xx_ac97_reset( device); + s3c24xx_cam_reset(); + s3c24xx_ac97_reset(); #endif #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - s3c24xx_nand_auto_boot( device); + s3c24xx_nand_auto_boot(); #endif } -static DEVICE_START( s3c24xx ) +void S3C24_CLASS_NAME::s3c24xx_device_start() { - s3c24xx_t *s3c24xx = get_token( device); - s3c24xx->m_cpu = device->machine().device( "maincpu"); - - verboselog( device->machine(), 1, "s3c24xx device start\n"); - s3c24xx->iface = (const s3c24xx_interface *)device->static_config(); - s3c24xx->pin_r.resolve(s3c24xx->iface->core.pin_r, *device); - s3c24xx->pin_w.resolve(s3c24xx->iface->core.pin_w, *device); - s3c24xx->port_r.resolve(s3c24xx->iface->gpio.port_r, *device); - s3c24xx->port_w.resolve(s3c24xx->iface->gpio.port_w, *device); - s3c24xx->scl_w.resolve(s3c24xx->iface->i2c.scl_w, *device); - s3c24xx->sda_r.resolve(s3c24xx->iface->i2c.sda_r, *device); - s3c24xx->sda_w.resolve(s3c24xx->iface->i2c.sda_w, *device); - s3c24xx->adc_data_r.resolve(s3c24xx->iface->adc.data_r, *device); - s3c24xx->i2s_data_w.resolve(s3c24xx->iface->i2s.data_w, *device); + verboselog( machine(), 1, "s3c24xx device start\n"); + m_pin_r.resolve(m_iface_core.pin_r, *this); + m_pin_w.resolve(m_iface_core.pin_w, *this); + m_port_r.resolve(m_iface_gpio.port_r, *this); + m_port_w.resolve(m_iface_gpio.port_w, *this); + m_scl_w.resolve(m_iface_i2c.scl_w, *this); + m_sda_r.resolve(m_iface_i2c.sda_r, *this); + m_sda_w.resolve(m_iface_i2c.sda_w, *this); + m_adc_data_r.resolve(m_iface_adc.data_r, *this); + m_i2s_data_w.resolve(m_iface_i2s.data_w, *this); #if !defined(DEVICE_S3C2400) - s3c24xx->command_w.resolve(s3c24xx->iface->nand.command_w, *device); - s3c24xx->address_w.resolve(s3c24xx->iface->nand.address_w, *device); - s3c24xx->nand_data_r.resolve(s3c24xx->iface->nand.data_r, *device); - s3c24xx->nand_data_w.resolve(s3c24xx->iface->nand.data_w, *device); + m_command_w.resolve(m_iface_nand.command_w, *this); + m_address_w.resolve(m_iface_nand.address_w, *this); + m_nand_data_r.resolve(m_iface_nand.data_r, *this); + m_nand_data_w.resolve(m_iface_nand.data_w, *this); #endif for (int i = 0; i < 5; i++) { - s3c24xx->pwm.timer[i] = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_pwm_timer_exp), (void*)device); + m_pwm.timer[i] = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_pwm_timer_exp), this)); } for (int i = 0; i < S3C24XX_DMA_COUNT; i++) { - s3c24xx->dma[i].timer = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_dma_timer_exp), (void*)device); + m_dma[i].timer = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_dma_timer_exp), this)); } - s3c24xx->iic.timer = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_iic_timer_exp), (void*)device); - s3c24xx->iis.timer = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_iis_timer_exp), (void*)device); - s3c24xx->lcd.timer = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_lcd_timer_exp), (void*)device); - s3c24xx->rtc.timer_tick_count = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_rtc_timer_tick_count_exp), (void*)device); - s3c24xx->rtc.timer_update = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_rtc_timer_update_exp), (void*)device); - s3c24xx->wdt.timer = device->machine().scheduler().timer_alloc( FUNC(s3c24xx_wdt_timer_exp), (void*)device); + m_iic.timer = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_iic_timer_exp), this)); + m_iis.timer = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_iis_timer_exp), this)); + m_lcd.timer = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_lcd_timer_exp), this)); + m_rtc.timer_tick_count = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_rtc_timer_tick_count_exp), this)); + m_rtc.timer_update = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_rtc_timer_update_exp), this)); + m_wdt.timer = machine().scheduler().timer_alloc(timer_expired_delegate( FUNC(S3C24_CLASS_NAME::s3c24xx_wdt_timer_exp), this)); #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) - int om0 = iface_core_pin_r( device, S3C24XX_CORE_PIN_OM0); - int om1 = iface_core_pin_r( device, S3C24XX_CORE_PIN_OM1); + int om0 = iface_core_pin_r( S3C24XX_CORE_PIN_OM0); + int om1 = iface_core_pin_r( S3C24XX_CORE_PIN_OM1); if ((om0 == 0) && (om1 == 0)) { - address_space &space = s3c24xx->m_cpu->memory().space( AS_PROGRAM); - space.install_ram( 0x00000000, 0x00000fff, s3c24xx->steppingstone); - space.install_ram( 0x40000000, 0x40000fff, s3c24xx->steppingstone); + address_space &space = m_cpu->memory().space( AS_PROGRAM); + space.install_ram( 0x00000000, 0x00000fff, m_steppingstone); + space.install_ram( 0x40000000, 0x40000fff, m_steppingstone); } #endif } diff --git a/src/mame/drivers/ghosteo.c b/src/mame/drivers/ghosteo.c index 1dab97bdc24..4c578e6a6a8 100644 --- a/src/mame/drivers/ghosteo.c +++ b/src/mame/drivers/ghosteo.c @@ -344,7 +344,7 @@ READ8_MEMBER(ghosteo_state::s3c2410_nand_data_r ) if ((nand.byte_addr >= 0x200) && (nand.byte_addr < 0x204)) { UINT8 mecc[4]; - s3c2410_nand_calculate_mecc( m_flash + nand.page_addr * 0x200, 0x200, mecc); + m_s3c2410->s3c2410_nand_calculate_mecc( m_flash + nand.page_addr * 0x200, 0x200, mecc); data = mecc[nand.byte_addr-0x200]; } else @@ -579,7 +579,7 @@ static const s3c2410_interface bballoon_s3c2410_intf = READ32_MEMBER(ghosteo_state::bballoon_speedup_r) { - UINT32 ret = s3c2410_lcd_r(m_s3c2410, space, offset+0x10/4, mem_mask); + UINT32 ret = m_s3c2410->s3c24xx_lcd_r(space, offset+0x10/4, mem_mask); int pc = space.device().safe_pc(); diff --git a/src/mess/drivers/gizmondo.c b/src/mess/drivers/gizmondo.c index b57975838e9..a4daa89fe15 100644 --- a/src/mess/drivers/gizmondo.c +++ b/src/mess/drivers/gizmondo.c @@ -45,12 +45,13 @@ class gizmondo_state : public driver_device public: gizmondo_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag) , + m_s3c2440(*this, "s3c2440"), m_maincpu(*this, "maincpu"), m_gf4500(*this, "gf4500") { } UINT32 m_port[9]; - device_t *m_s3c2440; + required_device m_s3c2440; DECLARE_DRIVER_INIT(gizmondo); virtual void machine_start(); virtual void machine_reset(); @@ -129,8 +130,8 @@ WRITE32_MEMBER(gizmondo_state::s3c2440_gpio_port_w) INPUT_CHANGED_MEMBER(gizmondo_state::port_changed) { - s3c2440_request_eint( m_s3c2440, 4); - //s3c2440_request_irq( device, S3C2440_INT_EINT1); + m_s3c2440->s3c2440_request_eint( 4); + //m_s3c2440->s3c2440_request_irq( S3C2440_INT_EINT1); } #if 0 @@ -147,7 +148,6 @@ QUICKLOAD_LOAD_MEMBER( gizmondo_state, gizmondo ) void gizmondo_state::machine_start() { - m_s3c2440 = machine().device( "s3c2440"); m_port[S3C2440_GPIO_PORT_B] = 0x055E; m_port[S3C2440_GPIO_PORT_C] = 0x5F20; m_port[S3C2440_GPIO_PORT_D] = 0x4F60; diff --git a/src/mess/drivers/hp49gp.c b/src/mess/drivers/hp49gp.c index 55599a3184f..6bd3c0fff04 100644 --- a/src/mess/drivers/hp49gp.c +++ b/src/mess/drivers/hp49gp.c @@ -24,11 +24,12 @@ class hp49gp_state : public driver_device public: hp49gp_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), + m_s3c2410(*this, "s3c2410"), m_steppingstone(*this, "steppingstone"), m_maincpu(*this, "maincpu") { } UINT32 m_port[9]; - device_t *m_s3c2410; + required_device m_s3c2410; required_shared_ptr m_steppingstone; lcd_spi_t m_lcd_spi; DECLARE_DRIVER_INIT(hp49gp); @@ -238,14 +239,13 @@ WRITE32_MEMBER(hp49gp_state::s3c2410_gpio_port_w) INPUT_CHANGED_MEMBER(hp49gp_state::port_changed) { - s3c2410_request_eint( m_s3c2410, (FPTR)param + 8); + m_s3c2410->s3c2410_request_eint( (FPTR)param + 8); } // ... void hp49gp_state::machine_start() { - m_s3c2410 = machine().device( "s3c2410"); } void hp49gp_state::machine_reset() diff --git a/src/mess/drivers/mini2440.c b/src/mess/drivers/mini2440.c index 99e9d67af81..c9bff700466 100644 --- a/src/mess/drivers/mini2440.c +++ b/src/mess/drivers/mini2440.c @@ -27,7 +27,7 @@ public: m_peny(*this, "PENY") { } required_device m_maincpu; - required_device m_s3c2440; + required_device m_s3c2440; required_device m_nand; required_device m_dac1; required_device m_dac2; @@ -175,7 +175,7 @@ READ32_MEMBER(mini2440_state::s3c2440_adc_data_r ) INPUT_CHANGED_MEMBER(mini2440_state::mini2440_input_changed) { - s3c2440_touch_screen( m_s3c2440, (newval & 0x01) ? 1 : 0); + m_s3c2440->s3c2440_touch_screen( (newval & 0x01) ? 1 : 0); } // ... diff --git a/src/mess/drivers/palmz22.c b/src/mess/drivers/palmz22.c index 491ff6fad22..d69894acce1 100644 --- a/src/mess/drivers/palmz22.c +++ b/src/mess/drivers/palmz22.c @@ -76,12 +76,13 @@ class palmz22_state : public driver_device public: palmz22_state(const machine_config &mconfig, device_type type, const char *tag) : driver_device(mconfig, type, tag), - m_maincpu(*this, "maincpu") + m_maincpu(*this, "maincpu"), + m_s3c2410(*this, "s3c2410") { } required_device m_maincpu; - device_t *m_s3c2410; + required_device m_s3c2410; nand_device *m_nand; UINT32 m_port[8]; @@ -236,11 +237,11 @@ INPUT_CHANGED_MEMBER(palmz22_state::palmz22_input_changed) { if (param == 0) { - s3c2410_touch_screen( m_s3c2410, (newval & 0x01) ? 1 : 0); + m_s3c2410->s3c2410_touch_screen( (newval & 0x01) ? 1 : 0); } else { - s3c2410_request_eint( m_s3c2410, (FPTR)param - 1); + m_s3c2410->s3c2410_request_eint( (FPTR)param - 1); } } @@ -248,7 +249,6 @@ INPUT_CHANGED_MEMBER(palmz22_state::palmz22_input_changed) void palmz22_state::machine_start() { - m_s3c2410 = machine().device( "s3c2410"); m_nand = machine().device("nand"); m_nand->set_data_ptr( memregion("nand")->base()); }