diff --git a/src/mame/drivers/cd32.c b/src/mame/drivers/cd32.c index 9dadcbf850c..f8aa47dfb17 100644 --- a/src/mame/drivers/cd32.c +++ b/src/mame/drivers/cd32.c @@ -126,7 +126,7 @@ static ADDRESS_MAP_START( cd32_map, AS_PROGRAM, 32, cd32_state ) AM_RANGE(0x000000, 0x1fffff) AM_RAMBANK("bank1") AM_SHARE("chip_ram") AM_RANGE(0x800000, 0x800003) AM_READ_PORT("DIPSW1") AM_RANGE(0x800010, 0x800013) AM_READ_PORT("DIPSW2") - AM_RANGE(0xb80000, 0xb8003f) AM_DEVREADWRITE_LEGACY("akiko", amiga_akiko32_r, amiga_akiko32_w) + AM_RANGE(0xb80000, 0xb8003f) AM_DEVREADWRITE("akiko", akiko_device, read, write) AM_RANGE(0xbfa000, 0xbfa003) AM_WRITE(aga_overlay_w) AM_RANGE(0xbfd000, 0xbfefff) AM_READWRITE16(amiga_cia_r, amiga_cia_w, 0xffffffff) AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE16(amiga_custom_r, amiga_custom_w, 0xffffffff) AM_SHARE("custom_regs") diff --git a/src/mame/includes/cd32.h b/src/mame/includes/cd32.h index e97b482f3ba..e40582410f6 100644 --- a/src/mame/includes/cd32.h +++ b/src/mame/includes/cd32.h @@ -53,26 +53,82 @@ public: /*----------- defined in machine/cd32.c -----------*/ -DECLARE_READ32_DEVICE_HANDLER( amiga_akiko32_r ); -DECLARE_WRITE32_DEVICE_HANDLER( amiga_akiko32_w ); - class akiko_device : public device_t { public: akiko_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); - ~akiko_device() { global_free(m_token); } + ~akiko_device() {} - // access to legacy token - void *token() const { assert(m_token != NULL); return m_token; } + DECLARE_READ32_MEMBER( read ); + DECLARE_WRITE32_MEMBER( write ); + protected: // device-level overrides virtual void device_config_complete(); virtual void device_start(); virtual void device_stop(); virtual void device_reset(); + private: // internal state - void *m_token; + address_space *m_space; + + /* chunky to planar converter */ + UINT32 m_c2p_input_buffer[8]; + UINT32 m_c2p_output_buffer[8]; + UINT32 m_c2p_input_index; + UINT32 m_c2p_output_index; + + /* i2c bus */ + int m_i2c_scl_out; + int m_i2c_scl_dir; + int m_i2c_sda_out; + int m_i2c_sda_dir; + + /* cdrom */ + UINT32 m_cdrom_status[2]; + UINT32 m_cdrom_address[2]; + UINT32 m_cdrom_track_index; + UINT32 m_cdrom_lba_start; + UINT32 m_cdrom_lba_end; + UINT32 m_cdrom_lba_cur; + UINT16 m_cdrom_readmask; + UINT16 m_cdrom_readreqmask; + UINT32 m_cdrom_dmacontrol; + UINT32 m_cdrom_numtracks; + UINT8 m_cdrom_speed; + UINT8 m_cdrom_cmd_start; + UINT8 m_cdrom_cmd_end; + UINT8 m_cdrom_cmd_resp; + cdda_device *m_cdda; + cdrom_file *m_cdrom; + UINT8 * m_cdrom_toc; + emu_timer *m_dma_timer; + emu_timer *m_frame_timer; + device_t *m_i2cmem; + + int m_cdrom_is_device; + + void nvram_write(UINT32 data); + UINT32 nvram_read(); + + void c2p_write(UINT32 data); + UINT32 c2p_read(); + + void cdda_stop(); + void cdda_play(UINT32 lba, UINT32 num_blocks); + void cdda_pause(int pause); + UINT8 cdda_getstatus(UINT32 *lba); + void set_cd_status(UINT32 status); + + TIMER_CALLBACK_MEMBER(frame_proc); + TIMER_CALLBACK_MEMBER(dma_proc); + + void start_dma(); + void setup_response( int len, UINT8 *r1 ); + + TIMER_CALLBACK_MEMBER( cd_delayed_cmd ); + void update_cdrom(); }; extern const device_type AKIKO; diff --git a/src/mame/machine/cd32.c b/src/mame/machine/cd32.c index 142c8e51b6d..803a8c4335d 100644 --- a/src/mame/machine/cd32.c +++ b/src/mame/machine/cd32.c @@ -5,7 +5,6 @@ #include "machine/i2cmem.h" #include "imagedev/chd_cd.h" #include "includes/cd32.h" -#include "devlegcy.h" /********************************************************************************* @@ -27,124 +26,143 @@ TODO: Add CDDA support #define CD_SECTOR_TIME (1000/((150*1024)/2048)) /* 1X CDROM sector time in msec (300KBps) */ -class akiko_state +const device_type AKIKO = &device_creator; + +akiko_device::akiko_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : device_t(mconfig, AKIKO, "Akiko", tag, owner, clock, "akiko", __FILE__), + m_c2p_input_index(0), + m_c2p_output_index(0), + m_i2c_scl_out(0), + m_i2c_scl_dir(0), + m_i2c_sda_out(0), + m_i2c_sda_dir(0), + m_cdrom_track_index(0), + m_cdrom_lba_start(0), + m_cdrom_lba_end(0), + m_cdrom_lba_cur(0), + m_cdrom_readmask(0), + m_cdrom_readreqmask(0), + m_cdrom_dmacontrol(0), + m_cdrom_numtracks(0), + m_cdrom_speed(0), + m_cdrom_cmd_start(0), + m_cdrom_cmd_end(0), + m_cdrom_cmd_resp(0), + m_cdda(NULL), + m_cdrom(NULL), + m_cdrom_toc(NULL), + m_dma_timer(NULL), + m_frame_timer(NULL), + m_i2cmem(NULL), + m_cdrom_is_device(0) { -public: - running_machine &machine() const { assert(m_machine != NULL); return *m_machine; } - void set_machine(running_machine &machine) { m_machine = &machine; } - - address_space *m_space; - - /* chunky to planar converter */ - UINT32 m_c2p_input_buffer[8]; - UINT32 m_c2p_output_buffer[8]; - UINT32 m_c2p_input_index; - UINT32 m_c2p_output_index; - - /* i2c bus */ - int m_i2c_scl_out; - int m_i2c_scl_dir; - int m_i2c_sda_out; - int m_i2c_sda_dir; - - /* cdrom */ - UINT32 m_cdrom_status[2]; - UINT32 m_cdrom_address[2]; - UINT32 m_cdrom_track_index; - UINT32 m_cdrom_lba_start; - UINT32 m_cdrom_lba_end; - UINT32 m_cdrom_lba_cur; - UINT16 m_cdrom_readmask; - UINT16 m_cdrom_readreqmask; - UINT32 m_cdrom_dmacontrol; - UINT32 m_cdrom_numtracks; - UINT8 m_cdrom_speed; - UINT8 m_cdrom_cmd_start; - UINT8 m_cdrom_cmd_end; - UINT8 m_cdrom_cmd_resp; - cdda_device *m_cdda; - cdrom_file *m_cdrom; - UINT8 * m_cdrom_toc; - emu_timer *m_dma_timer; - emu_timer *m_frame_timer; - device_t *m_i2cmem; - - int m_cdrom_is_device; - -private: - running_machine *m_machine; -}; - -static TIMER_CALLBACK(akiko_dma_proc); -static TIMER_CALLBACK(akiko_frame_proc); - -INLINE akiko_state *get_safe_token(device_t *device) -{ - assert(device != NULL); - assert(device->type() == AKIKO); - - return (akiko_state *)downcast(device)->token(); -} - -static DEVICE_STOP( akiko ) -{ - akiko_state *state = get_safe_token(device); - if (!state->m_cdrom_is_device) + for (int i = 0; i < 8; i++) { - if( state->m_cdrom ) - { - cdrom_close(state->m_cdrom); - state->m_cdrom = (cdrom_file *)NULL; - } + m_c2p_input_buffer[i] = 0; + m_c2p_output_buffer[i] = 0; + } + + for (int i = 0; i < 2; i++) + { + m_cdrom_status[i] = 0; + m_cdrom_address[i] = 0; } } -static DEVICE_RESET( akiko ) -{ - amiga_state *amiga = device->machine().driver_data(); - running_machine &machine = device->machine(); - akiko_state *state = get_safe_token(device); - state->m_space = amiga->m_maincpu_program_space; +//------------------------------------------------- +// device_config_complete - perform any +// operations now that the configuration is +// complete +//------------------------------------------------- - cdrom_image_device *cddevice = machine.device("cdrom"); +void akiko_device::device_config_complete() +{ +} + +//------------------------------------------------- +// device_start - device-specific startup +//------------------------------------------------- + +void akiko_device::device_start() +{ + m_c2p_input_index = 0; + m_c2p_output_index = 0; + + m_i2c_scl_out = 0; + m_i2c_scl_dir = 0; + m_i2c_sda_out = 0; + m_i2c_sda_dir = 0; + + m_cdrom_status[0] = m_cdrom_status[1] = 0; + m_cdrom_address[0] = m_cdrom_address[1] = 0; + m_cdrom_track_index = 0; + m_cdrom_lba_start = 0; + m_cdrom_lba_end = 0; + m_cdrom_lba_cur = 0; + m_cdrom_readmask = 0; + m_cdrom_readreqmask = 0; + m_cdrom_dmacontrol = 0; + m_cdrom_numtracks = 0; + m_cdrom_speed = 0; + m_cdrom_cmd_start = 0; + m_cdrom_cmd_end = 0; + m_cdrom_cmd_resp = 0; + + m_cdrom_toc = NULL; + m_dma_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(akiko_device::dma_proc), this)); + m_frame_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(akiko_device::frame_proc), this)); + m_i2cmem = machine().device("i2cmem"); + m_cdda = machine().device("cdda"); +} + +//------------------------------------------------- +// device_reset - device-specific reset +//------------------------------------------------- + +void akiko_device::device_reset() +{ + amiga_state *amiga = machine().driver_data(); + m_space = amiga->m_maincpu_program_space; + + cdrom_image_device *cddevice = machine().device("cdrom"); if (cddevice!=NULL) { // MESS case - state->m_cdrom = cddevice->get_cdrom_file(); - state->m_cdrom_is_device = 1; + m_cdrom = cddevice->get_cdrom_file(); + m_cdrom_is_device = 1; } else { // MAME case - state->m_cdrom = cdrom_open(get_disk_handle(machine, ":cdrom")); - state->m_cdrom_is_device = 0; + m_cdrom = cdrom_open(get_disk_handle(machine(), ":cdrom")); + m_cdrom_is_device = 0; } /* create the TOC table */ - if ( state->m_cdrom != NULL && cdrom_get_last_track(state->m_cdrom) ) + if ( m_cdrom != NULL && cdrom_get_last_track(m_cdrom) ) { UINT8 *p; - int i, addrctrl = cdrom_get_adr_control( state->m_cdrom, 0 ); + int i, addrctrl = cdrom_get_adr_control( m_cdrom, 0 ); UINT32 discend; - discend = cdrom_get_track_start(state->m_cdrom,cdrom_get_last_track(state->m_cdrom)-1); - discend += cdrom_get_toc(state->m_cdrom)->tracks[cdrom_get_last_track(state->m_cdrom)-1].frames; + discend = cdrom_get_track_start(m_cdrom,cdrom_get_last_track(m_cdrom)-1); + discend += cdrom_get_toc(m_cdrom)->tracks[cdrom_get_last_track(m_cdrom)-1].frames; discend = lba_to_msf(discend); - state->m_cdrom_numtracks = cdrom_get_last_track(state->m_cdrom)+3; + m_cdrom_numtracks = cdrom_get_last_track(m_cdrom)+3; - state->m_cdrom_toc = auto_alloc_array(machine, UINT8, 13*state->m_cdrom_numtracks); - memset( state->m_cdrom_toc, 0, 13*state->m_cdrom_numtracks); + m_cdrom_toc = auto_alloc_array(machine(), UINT8, 13*m_cdrom_numtracks); + memset( m_cdrom_toc, 0, 13*m_cdrom_numtracks); - p = state->m_cdrom_toc; + p = m_cdrom_toc; p[1] = ((addrctrl & 0x0f) << 4) | ((addrctrl & 0xf0) >> 4); p[3] = 0xa0; /* first track */ p[8] = 1; p += 13; p[1] = 0x01; p[3] = 0xa1; /* last track */ - p[8] = cdrom_get_last_track(state->m_cdrom); + p[8] = cdrom_get_last_track(m_cdrom); p += 13; p[1] = 0x01; p[3] = 0xa2; /* disc end */ @@ -153,12 +171,12 @@ static DEVICE_RESET( akiko ) p[10] = discend & 0xff; p += 13; - for( i = 0; i < cdrom_get_last_track(state->m_cdrom); i++ ) + for( i = 0; i < cdrom_get_last_track(m_cdrom); i++ ) { - UINT32 trackpos = cdrom_get_track_start(state->m_cdrom,i); + UINT32 trackpos = cdrom_get_track_start(m_cdrom,i); trackpos = lba_to_msf(trackpos); - addrctrl = cdrom_get_adr_control( state->m_cdrom, i ); + addrctrl = cdrom_get_adr_control( m_cdrom, i ); p[1] = ((addrctrl & 0x0f) << 4) | ((addrctrl & 0xf0) >> 4); p[3] = dec_2_bcd( i+1 ); @@ -172,77 +190,57 @@ static DEVICE_RESET( akiko ) } -static DEVICE_START( akiko ) +//------------------------------------------------- +// device_stop - device-specific stop +//------------------------------------------------- + +void akiko_device::device_stop() { - running_machine &machine = device->machine(); - akiko_state *state = get_safe_token(device); - - state->set_machine(machine); - state->m_c2p_input_index = 0; - state->m_c2p_output_index = 0; - - state->m_i2c_scl_out = 0; - state->m_i2c_scl_dir = 0; - state->m_i2c_sda_out = 0; - state->m_i2c_sda_dir = 0; - - state->m_cdrom_status[0] = state->m_cdrom_status[1] = 0; - state->m_cdrom_address[0] = state->m_cdrom_address[1] = 0; - state->m_cdrom_track_index = 0; - state->m_cdrom_lba_start = 0; - state->m_cdrom_lba_end = 0; - state->m_cdrom_lba_cur = 0; - state->m_cdrom_readmask = 0; - state->m_cdrom_readreqmask = 0; - state->m_cdrom_dmacontrol = 0; - state->m_cdrom_numtracks = 0; - state->m_cdrom_speed = 0; - state->m_cdrom_cmd_start = 0; - state->m_cdrom_cmd_end = 0; - state->m_cdrom_cmd_resp = 0; - - state->m_cdrom_toc = NULL; - state->m_dma_timer = machine.scheduler().timer_alloc(FUNC(akiko_dma_proc), state); - state->m_frame_timer = machine.scheduler().timer_alloc(FUNC(akiko_frame_proc), state); - state->m_i2cmem = machine.device("i2cmem"); - state->m_cdda = machine.device("cdda"); + if (!m_cdrom_is_device) + { + if( m_cdrom ) + { + cdrom_close(m_cdrom); + m_cdrom = (cdrom_file *)NULL; + } + } } -static void akiko_nvram_write(akiko_state *state, UINT32 data) +void akiko_device::nvram_write(UINT32 data) { - state->m_i2c_scl_out = BIT(data,31); - state->m_i2c_sda_out = BIT(data,30); - state->m_i2c_scl_dir = BIT(data,15); - state->m_i2c_sda_dir = BIT(data,14); + m_i2c_scl_out = BIT(data,31); + m_i2c_sda_out = BIT(data,30); + m_i2c_scl_dir = BIT(data,15); + m_i2c_sda_dir = BIT(data,14); - i2cmem_scl_write( state->m_i2cmem, state->m_i2c_scl_out ); - i2cmem_sda_write( state->m_i2cmem, state->m_i2c_sda_out ); + i2cmem_scl_write( m_i2cmem, m_i2c_scl_out ); + i2cmem_sda_write( m_i2cmem, m_i2c_sda_out ); } -static UINT32 akiko_nvram_read(akiko_state *state) +UINT32 akiko_device::nvram_read() { UINT32 v = 0; - if ( state->m_i2c_scl_dir ) + if ( m_i2c_scl_dir ) { - v |= state->m_i2c_scl_out << 31; + v |= m_i2c_scl_out << 31; } else { v |= 0 << 31; } - if ( state->m_i2c_sda_dir ) + if ( m_i2c_sda_dir ) { - v |= state->m_i2c_sda_out << 30; + v |= m_i2c_sda_out << 30; } else { - v |= i2cmem_sda_read( state->m_i2cmem ) << 30; + v |= i2cmem_sda_read( m_i2cmem ) << 30; } - v |= state->m_i2c_scl_dir << 15; - v |= state->m_i2c_sda_dir << 14; + v |= m_i2c_scl_dir << 15; + v |= m_i2c_sda_dir << 14; return v; } @@ -253,35 +251,35 @@ static UINT32 akiko_nvram_read(akiko_state *state) * ************************************/ -static void akiko_c2p_write(akiko_state *state, UINT32 data) +void akiko_device::c2p_write(UINT32 data) { - state->m_c2p_input_buffer[state->m_c2p_input_index] = data; - state->m_c2p_input_index++; - state->m_c2p_input_index &= 7; - state->m_c2p_output_index = 0; + m_c2p_input_buffer[m_c2p_input_index] = data; + m_c2p_input_index++; + m_c2p_input_index &= 7; + m_c2p_output_index = 0; } -static UINT32 akiko_c2p_read(akiko_state *state) +UINT32 akiko_device::c2p_read() { UINT32 val; - if ( state->m_c2p_output_index == 0 ) + if ( m_c2p_output_index == 0 ) { int i; for ( i = 0; i < 8; i++ ) - state->m_c2p_output_buffer[i] = 0; + m_c2p_output_buffer[i] = 0; for (i = 0; i < 8 * 32; i++) { - if (state->m_c2p_input_buffer[7 - (i >> 5)] & (1 << (i & 31))) - state->m_c2p_output_buffer[i & 7] |= 1 << (i >> 3); + if (m_c2p_input_buffer[7 - (i >> 5)] & (1 << (i & 31))) + m_c2p_output_buffer[i & 7] |= 1 << (i >> 3); } } - state->m_c2p_input_index = 0; - val = state->m_c2p_output_buffer[state->m_c2p_output_index]; - state->m_c2p_output_index++; - state->m_c2p_output_index &= 7; + m_c2p_input_index = 0; + val = m_c2p_output_buffer[m_c2p_output_index]; + m_c2p_output_index++; + m_c2p_output_index &= 7; return val; } @@ -322,55 +320,55 @@ static const char* get_akiko_reg_name(int reg) * ************************************/ -static void akiko_cdda_stop(akiko_state *state) +void akiko_device::cdda_stop() { - if (state->m_cdda != NULL) + if (m_cdda != NULL) { - state->m_cdda->stop_audio(); - state->m_frame_timer->reset( ); + m_cdda->stop_audio(); + m_frame_timer->reset( ); } } -static void akiko_cdda_play(akiko_state *state, UINT32 lba, UINT32 num_blocks) +void akiko_device::cdda_play(UINT32 lba, UINT32 num_blocks) { - if (state->m_cdda != NULL) + if (m_cdda != NULL) { - state->m_cdda->start_audio(lba, num_blocks); - state->m_frame_timer->adjust( attotime::from_hz( 75 ) ); + m_cdda->start_audio(lba, num_blocks); + m_frame_timer->adjust( attotime::from_hz( 75 ) ); } } -static void akiko_cdda_pause(akiko_state *state, int pause) +void akiko_device::cdda_pause(int pause) { - if (state->m_cdda != NULL) + if (m_cdda != NULL) { - if (state->m_cdda->audio_active() && state->m_cdda->audio_paused() != pause ) + if (m_cdda->audio_active() && m_cdda->audio_paused() != pause ) { - state->m_cdda->pause_audio(pause); + m_cdda->pause_audio(pause); if ( pause ) { - state->m_frame_timer->reset( ); + m_frame_timer->reset( ); } else { - state->m_frame_timer->adjust( attotime::from_hz( 75 ) ); + m_frame_timer->adjust( attotime::from_hz( 75 ) ); } } } } -static UINT8 akiko_cdda_getstatus(akiko_state *state, UINT32 *lba) +UINT8 akiko_device::cdda_getstatus(UINT32 *lba) { if ( lba ) *lba = 0; - if (state->m_cdda != NULL) + if (m_cdda != NULL) { - if (state->m_cdda->audio_active()) + if (m_cdda->audio_active()) { - if ( lba ) *lba = state->m_cdda->get_audio_lba(); + if ( lba ) *lba = m_cdda->get_audio_lba(); - if (state->m_cdda->audio_paused()) + if (m_cdda->audio_paused()) { return 0x12; /* audio paused */ } @@ -379,7 +377,7 @@ static UINT8 akiko_cdda_getstatus(akiko_state *state, UINT32 *lba) return 0x11; /* audio in progress */ } } - else if (state->m_cdda->audio_ended()) + else if (m_cdda->audio_ended()) { return 0x13; /* audio ended */ } @@ -388,35 +386,33 @@ static UINT8 akiko_cdda_getstatus(akiko_state *state, UINT32 *lba) return 0x15; /* no audio status */ } -static void akiko_set_cd_status(akiko_state *state, UINT32 status) +void akiko_device::set_cd_status(UINT32 status) { - amiga_state *amiga = state->machine().driver_data(); + amiga_state *amiga = machine().driver_data(); - state->m_cdrom_status[0] |= status; + m_cdrom_status[0] |= status; - if ( state->m_cdrom_status[0] & state->m_cdrom_status[1] ) + if ( m_cdrom_status[0] & m_cdrom_status[1] ) { if (LOG_AKIKO_CD) logerror( "Akiko CD IRQ\n" ); - amiga->amiga_custom_w(*state->m_space, REG_INTREQ, 0x8000 | INTENA_PORTS, 0xffff); + amiga->amiga_custom_w(*m_space, REG_INTREQ, 0x8000 | INTENA_PORTS, 0xffff); } } -static TIMER_CALLBACK(akiko_frame_proc) +TIMER_CALLBACK_MEMBER(akiko_device::frame_proc) { - akiko_state *state = (akiko_state *)ptr; - (void)param; - if (state->m_cdda != NULL) + if (m_cdda != NULL) { - UINT8 s = akiko_cdda_getstatus(state, NULL); + UINT8 s = cdda_getstatus(NULL); if ( s == 0x11 ) { - akiko_set_cd_status(state, 0x80000000); /* subcode ready */ + set_cd_status(0x80000000); /* subcode ready */ } - state->m_frame_timer->adjust( attotime::from_hz( 75 ) ); + m_frame_timer->adjust( attotime::from_hz( 75 ) ); } } @@ -431,32 +427,31 @@ static UINT32 lba_from_triplet( UINT8 *triplet ) return r; } -static TIMER_CALLBACK(akiko_dma_proc) +TIMER_CALLBACK_MEMBER(akiko_device::dma_proc) { - akiko_state *state = (akiko_state *)ptr; UINT8 buf[2352]; int index; - if ( (state->m_cdrom_dmacontrol & 0x04000000) == 0 ) + if ( (m_cdrom_dmacontrol & 0x04000000) == 0 ) return; - if ( state->m_cdrom_readreqmask == 0 ) + if ( m_cdrom_readreqmask == 0 ) return; - index = (state->m_cdrom_lba_cur - state->m_cdrom_lba_start) & 0x0f; + index = (m_cdrom_lba_cur - m_cdrom_lba_start) & 0x0f; - if ( state->m_cdrom_readreqmask & ( 1 << index ) ) + if ( m_cdrom_readreqmask & ( 1 << index ) ) { - amiga_state *amiga = machine.driver_data(); - UINT32 track = cdrom_get_track( state->m_cdrom, state->m_cdrom_lba_cur ); - UINT32 datasize = cdrom_get_toc( state->m_cdrom )->tracks[track].datasize; - UINT32 subsize = cdrom_get_toc( state->m_cdrom )->tracks[track].subsize; + amiga_state *amiga = machine().driver_data(); + UINT32 track = cdrom_get_track( m_cdrom, m_cdrom_lba_cur ); + UINT32 datasize = cdrom_get_toc( m_cdrom )->tracks[track].datasize; + UINT32 subsize = cdrom_get_toc( m_cdrom )->tracks[track].subsize; int i; - UINT32 curmsf = lba_to_msf( state->m_cdrom_lba_cur ); + UINT32 curmsf = lba_to_msf( m_cdrom_lba_cur ); memset( buf, 0, 16 ); - buf[3] = state->m_cdrom_lba_cur - state->m_cdrom_lba_start; + buf[3] = m_cdrom_lba_cur - m_cdrom_lba_start; memset( &buf[4], 0xff, 8 ); buf[12] = (curmsf >> 16) & 0xff; @@ -465,22 +460,22 @@ static TIMER_CALLBACK(akiko_dma_proc) buf[15] = 0x01; /* mode1 */ datasize = 2048; - if ( !cdrom_read_data( state->m_cdrom, state->m_cdrom_lba_cur, &buf[16], CD_TRACK_MODE1 ) ) + if ( !cdrom_read_data( m_cdrom, m_cdrom_lba_cur, &buf[16], CD_TRACK_MODE1 ) ) { - logerror( "AKIKO: Read error trying to read sector %08x!\n", state->m_cdrom_lba_cur ); + logerror( "AKIKO: Read error trying to read sector %08x!\n", m_cdrom_lba_cur ); return; } if ( subsize ) { - if ( !cdrom_read_subcode( state->m_cdrom, state->m_cdrom_lba_cur, &buf[16+datasize] ) ) + if ( !cdrom_read_subcode( m_cdrom, m_cdrom_lba_cur, &buf[16+datasize] ) ) { - logerror( "AKIKO: Read error trying to read subcode for sector %08x!\n", state->m_cdrom_lba_cur ); + logerror( "AKIKO: Read error trying to read subcode for sector %08x!\n", m_cdrom_lba_cur ); return; } } - if (LOG_AKIKO_CD) logerror( "DMA: sector %d - address %08x\n", state->m_cdrom_lba_cur, state->m_cdrom_address[0] + (index*4096) ); + if (LOG_AKIKO_CD) logerror( "DMA: sector %d - address %08x\n", m_cdrom_lba_cur, m_cdrom_address[0] + (index*4096) ); for( i = 0; i < 2352; i += 2 ) { @@ -490,39 +485,39 @@ static TIMER_CALLBACK(akiko_dma_proc) data <<= 8; data |= buf[i+1]; - (*amiga->m_chip_ram_w)( amiga, state->m_cdrom_address[0] + (index*4096) + i, data ); + (*amiga->m_chip_ram_w)( amiga, m_cdrom_address[0] + (index*4096) + i, data ); } - state->m_cdrom_readmask |= ( 1 << index ); - state->m_cdrom_readreqmask &= ~( 1 << index ); - state->m_cdrom_lba_cur++; + m_cdrom_readmask |= ( 1 << index ); + m_cdrom_readreqmask &= ~( 1 << index ); + m_cdrom_lba_cur++; } - if ( state->m_cdrom_readreqmask == 0 ) - akiko_set_cd_status(state, 0x04000000); + if ( m_cdrom_readreqmask == 0 ) + set_cd_status(0x04000000); else - state->m_dma_timer->adjust( attotime::from_usec( CD_SECTOR_TIME / state->m_cdrom_speed ) ); + m_dma_timer->adjust( attotime::from_usec( CD_SECTOR_TIME / m_cdrom_speed ) ); } -static void akiko_start_dma(akiko_state *state) +void akiko_device::start_dma() { - if ( state->m_cdrom_readreqmask == 0 ) + if ( m_cdrom_readreqmask == 0 ) return; - if ( state->m_cdrom_lba_start > state->m_cdrom_lba_end ) + if ( m_cdrom_lba_start > m_cdrom_lba_end ) return; - if ( state->m_cdrom_speed == 0 ) + if ( m_cdrom_speed == 0 ) return; - state->m_cdrom_lba_cur = state->m_cdrom_lba_start; + m_cdrom_lba_cur = m_cdrom_lba_start; - state->m_dma_timer->adjust( attotime::from_usec( CD_SECTOR_TIME / state->m_cdrom_speed ) ); + m_dma_timer->adjust( attotime::from_usec( CD_SECTOR_TIME / m_cdrom_speed ) ); } -static void akiko_setup_response( akiko_state *state, int len, UINT8 *r1 ) +void akiko_device::setup_response( int len, UINT8 *r1 ) { - int resp_addr = state->m_cdrom_address[1]; + int resp_addr = m_cdrom_address[1]; UINT8 resp_csum = 0xff; UINT8 resp_buffer[32]; int i; @@ -539,24 +534,23 @@ static void akiko_setup_response( akiko_state *state, int len, UINT8 *r1 ) for( i = 0; i < len; i++ ) { - state->m_space->write_byte( resp_addr + ((state->m_cdrom_cmd_resp + i) & 0xff), resp_buffer[i] ); + m_space->write_byte( resp_addr + ((m_cdrom_cmd_resp + i) & 0xff), resp_buffer[i] ); } - state->m_cdrom_cmd_resp = (state->m_cdrom_cmd_resp+len) & 0xff; + m_cdrom_cmd_resp = (m_cdrom_cmd_resp+len) & 0xff; - akiko_set_cd_status(state, 0x10000000); /* new data available */ + set_cd_status(0x10000000); /* new data available */ } -static TIMER_CALLBACK( akiko_cd_delayed_cmd ) +TIMER_CALLBACK_MEMBER( akiko_device::cd_delayed_cmd ) { - akiko_state *state = (akiko_state *)ptr; UINT8 resp[32]; UINT8 cddastatus; - if ( state->m_cdrom_status[0] & 0x10000000 ) + if ( m_cdrom_status[0] & 0x10000000 ) return; - cddastatus = akiko_cdda_getstatus(state, NULL); + cddastatus = cdda_getstatus(NULL); if ( cddastatus == 0x11 || cddastatus == 0x12 ) return; @@ -572,34 +566,34 @@ static TIMER_CALLBACK( akiko_cd_delayed_cmd ) resp[0] = 0x06; - if ( state->m_cdrom == NULL || state->m_cdrom_numtracks == 0 ) + if ( m_cdrom == NULL || m_cdrom_numtracks == 0 ) { resp[1] = 0x80; - akiko_setup_response( state, 15, resp ); + setup_response( 15, resp ); } else { resp[1] = 0x00; - memcpy( &resp[2], &state->m_cdrom_toc[13*state->m_cdrom_track_index], 13 ); + memcpy( &resp[2], &m_cdrom_toc[13*m_cdrom_track_index], 13 ); - state->m_cdrom_track_index = ( state->m_cdrom_track_index + 1 ) % state->m_cdrom_numtracks; + m_cdrom_track_index = ( m_cdrom_track_index + 1 ) % m_cdrom_numtracks; - akiko_setup_response( state, 15, resp ); + setup_response( 15, resp ); } } } -static void akiko_update_cdrom(akiko_state *state) +void akiko_device::update_cdrom() { UINT8 resp[32], cmdbuf[32]; - if ( state->m_cdrom_status[0] & 0x10000000 ) + if ( m_cdrom_status[0] & 0x10000000 ) return; - while ( state->m_cdrom_cmd_start != state->m_cdrom_cmd_end ) + while ( m_cdrom_cmd_start != m_cdrom_cmd_end ) { - UINT32 cmd_addr = state->m_cdrom_address[1] + 0x200 + state->m_cdrom_cmd_start; - int cmd = state->m_space->read_byte( cmd_addr ); + UINT32 cmd_addr = m_cdrom_address[1] + 0x200 + m_cdrom_cmd_start; + int cmd = m_space->read_byte( cmd_addr ); memset( resp, 0, sizeof( resp ) ); resp[0] = cmd; @@ -612,27 +606,27 @@ static void akiko_update_cdrom(akiko_state *state) { resp[1] = 0x00; - if ( akiko_cdda_getstatus(state, NULL) == 0x11 ) + if ( cdda_getstatus(NULL) == 0x11 ) resp[1] = 0x08; - akiko_cdda_pause(state, 1); + cdda_pause(1); - state->m_cdrom_cmd_start = (state->m_cdrom_cmd_start+2) & 0xff; + m_cdrom_cmd_start = (m_cdrom_cmd_start+2) & 0xff; - akiko_setup_response( state, 2, resp ); + setup_response( 2, resp ); } else if ( cmd == 0x03 ) /* unpause audio (and check audiocd playing status) */ { resp[1] = 0x00; - if ( akiko_cdda_getstatus(state, NULL) == 0x11 ) + if ( cdda_getstatus(NULL) == 0x11 ) resp[1] = 0x08; - akiko_cdda_pause(state, 0); + cdda_pause(0); - state->m_cdrom_cmd_start = (state->m_cdrom_cmd_start+2) & 0xff; + m_cdrom_cmd_start = (m_cdrom_cmd_start+2) & 0xff; - akiko_setup_response( state, 2, resp ); + setup_response( 2, resp ); } else if ( cmd == 0x04 ) /* seek/read/play cd multi command */ { @@ -641,67 +635,67 @@ static void akiko_update_cdrom(akiko_state *state) for( i = 0; i < 13; i++ ) { - cmdbuf[i] = state->m_space->read_byte( cmd_addr ); + cmdbuf[i] = m_space->read_byte( cmd_addr ); cmd_addr &= 0xffffff00; - cmd_addr += ( state->m_cdrom_cmd_start + i + 1 ) & 0xff; + cmd_addr += ( m_cdrom_cmd_start + i + 1 ) & 0xff; } - state->m_cdrom_cmd_start = (state->m_cdrom_cmd_start+13) & 0xff; + m_cdrom_cmd_start = (m_cdrom_cmd_start+13) & 0xff; - if ( state->m_cdrom == NULL || state->m_cdrom_numtracks == 0 ) + if ( m_cdrom == NULL || m_cdrom_numtracks == 0 ) { resp[1] = 0x80; - akiko_setup_response( state, 2, resp ); + setup_response( 2, resp ); } else { startpos = lba_from_triplet( &cmdbuf[1] ); endpos = lba_from_triplet( &cmdbuf[4] ); - akiko_cdda_stop(state); + cdda_stop(); resp[1] = 0x00; if ( cmdbuf[7] == 0x80 ) { - if (LOG_AKIKO_CD) logerror( "%s:AKIKO CD: Data read - start lba: %08x - end lba: %08x\n", state->machine().describe_context(), startpos, endpos ); - state->m_cdrom_speed = (cmdbuf[8] & 0x40) ? 2 : 1; - state->m_cdrom_lba_start = startpos; - state->m_cdrom_lba_end = endpos; + if (LOG_AKIKO_CD) logerror( "%s:AKIKO CD: Data read - start lba: %08x - end lba: %08x\n", machine().describe_context(), startpos, endpos ); + m_cdrom_speed = (cmdbuf[8] & 0x40) ? 2 : 1; + m_cdrom_lba_start = startpos; + m_cdrom_lba_end = endpos; resp[1] = 0x02; } else if ( cmdbuf[10] & 0x04 ) { logerror( "AKIKO CD: Audio Play - start lba: %08x - end lba: %08x\n", startpos, endpos ); - akiko_cdda_play(state, startpos, endpos - startpos); + cdda_play(startpos, endpos - startpos); resp[1] = 0x08; } else { if (LOG_AKIKO_CD) logerror( "AKIKO CD: Seek - start lba: %08x - end lba: %08x\n", startpos, endpos ); - state->m_cdrom_track_index = 0; + m_cdrom_track_index = 0; - for( i = 0; i < cdrom_get_last_track(state->m_cdrom); i++ ) + for( i = 0; i < cdrom_get_last_track(m_cdrom); i++ ) { - if ( startpos <= cdrom_get_track_start( state->m_cdrom, i ) ) + if ( startpos <= cdrom_get_track_start( m_cdrom, i ) ) { /* reset to 0 */ - state->m_cdrom_track_index = i + 2; - state->m_cdrom_track_index %= state->m_cdrom_numtracks; + m_cdrom_track_index = i + 2; + m_cdrom_track_index %= m_cdrom_numtracks; break; } } } - akiko_setup_response( state, 2, resp ); + setup_response( 2, resp ); } } else if ( cmd == 0x05 ) /* read toc */ { - state->m_cdrom_cmd_start = (state->m_cdrom_cmd_start+3) & 0xff; + m_cdrom_cmd_start = (m_cdrom_cmd_start+3) & 0xff; - state->machine().scheduler().timer_set( attotime::from_msec(1), FUNC(akiko_cd_delayed_cmd ), resp[0], state); + machine().scheduler().timer_set( attotime::from_msec(1), timer_expired_delegate(FUNC(akiko_device::cd_delayed_cmd ), this), resp[0]); break; } @@ -711,7 +705,7 @@ static void akiko_update_cdrom(akiko_state *state) resp[1] = 0x00; - (void)akiko_cdda_getstatus(state, &lba); + (void)cdda_getstatus(&lba); if ( lba > 0 ) { @@ -720,8 +714,8 @@ static void akiko_update_cdrom(akiko_state *state) UINT32 track; int addrctrl; - track = cdrom_get_track(state->m_cdrom, lba); - addrctrl = cdrom_get_adr_control(state->m_cdrom, track); + track = cdrom_get_track(m_cdrom, lba); + addrctrl = cdrom_get_adr_control(m_cdrom, track); resp[2] = 0x00; resp[3] = ((addrctrl & 0x0f) << 4) | ((addrctrl & 0xf0) >> 4); @@ -729,7 +723,7 @@ static void akiko_update_cdrom(akiko_state *state) resp[5] = 0; /* index */ disk_pos = lba_to_msf(lba); - track_pos = lba_to_msf(lba - cdrom_get_track_start(state->m_cdrom, track)); + track_pos = lba_to_msf(lba - cdrom_get_track_start(m_cdrom, track)); /* track position */ resp[6] = (track_pos >> 16) & 0xff; @@ -747,18 +741,18 @@ static void akiko_update_cdrom(akiko_state *state) resp[1] = 0x80; } - akiko_setup_response( state, 15, resp ); + setup_response( 15, resp ); } else if ( cmd == 0x07 ) /* check door status */ { resp[1] = 0x01; - state->m_cdrom_cmd_start = (state->m_cdrom_cmd_start+2) & 0xff; + m_cdrom_cmd_start = (m_cdrom_cmd_start+2) & 0xff; - if ( state->m_cdrom == NULL || state->m_cdrom_numtracks == 0 ) + if ( m_cdrom == NULL || m_cdrom_numtracks == 0 ) resp[1] = 0x80; - akiko_setup_response( state, 20, resp ); + setup_response( 20, resp ); break; } else @@ -768,61 +762,60 @@ static void akiko_update_cdrom(akiko_state *state) } } -READ32_DEVICE_HANDLER( amiga_akiko32_r ) +READ32_MEMBER( akiko_device::read ) { - akiko_state *state = get_safe_token(device); UINT32 retval; if ( LOG_AKIKO && offset < (0x30/4) ) { - logerror( "Reading AKIKO reg %0x [%s] at PC=%06x\n", offset, get_akiko_reg_name(offset), state->m_space->device().safe_pc() ); + logerror( "Reading AKIKO reg %0x [%s] at PC=%06x\n", offset, get_akiko_reg_name(offset), m_space->device().safe_pc() ); } switch( offset ) { case 0x00/4: /* ID */ - if ( state->m_cdrom != NULL ) state->m_cdda->set_cdrom(state->m_cdrom); + if ( m_cdrom != NULL ) m_cdda->set_cdrom(m_cdrom); return 0x0000cafe; case 0x04/4: /* CDROM STATUS 1 */ - return state->m_cdrom_status[0]; + return m_cdrom_status[0]; case 0x08/4: /* CDROM STATUS 2 */ - return state->m_cdrom_status[1]; + return m_cdrom_status[1]; case 0x10/4: /* CDROM ADDRESS 1 */ - return state->m_cdrom_address[0]; + return m_cdrom_address[0]; case 0x14/4: /* CDROM ADDRESS 2 */ - return state->m_cdrom_address[1]; + return m_cdrom_address[1]; case 0x18/4: /* CDROM COMMAND 1 */ - akiko_update_cdrom(state); - retval = state->m_cdrom_cmd_start; + update_cdrom(); + retval = m_cdrom_cmd_start; retval <<= 8; - retval |= state->m_cdrom_cmd_resp; + retval |= m_cdrom_cmd_resp; retval <<= 8; return retval; case 0x1C/4: /* CDROM COMMAND 2 */ - akiko_update_cdrom(state); - retval = state->m_cdrom_cmd_end; + update_cdrom(); + retval = m_cdrom_cmd_end; retval <<= 16; return retval; case 0x20/4: /* CDROM DMA SECTOR READ MASK */ - retval = state->m_cdrom_readmask << 16; + retval = m_cdrom_readmask << 16; return retval; case 0x24/4: /* CDROM DMA ENABLE? */ - retval = state->m_cdrom_dmacontrol; + retval = m_cdrom_dmacontrol; return retval; case 0x30/4: /* NVRAM */ - return akiko_nvram_read(state); + return nvram_read(); case 0x38/4: /* C2P */ - return akiko_c2p_read(state); + return c2p_read(); default: break; @@ -831,124 +824,77 @@ READ32_DEVICE_HANDLER( amiga_akiko32_r ) return 0; } -WRITE32_DEVICE_HANDLER( amiga_akiko32_w ) +WRITE32_MEMBER( akiko_device::write ) { - akiko_state *state = get_safe_token(device); - if ( LOG_AKIKO && offset < (0x30/4) ) { - logerror( "Writing AKIKO reg %0x [%s] with %08x at PC=%06x\n", offset, get_akiko_reg_name(offset), data, state->m_space->device().safe_pc() ); + logerror( "Writing AKIKO reg %0x [%s] with %08x at PC=%06x\n", offset, get_akiko_reg_name(offset), data, m_space->device().safe_pc() ); } switch( offset ) { case 0x04/4: /* CDROM STATUS 1 */ - state->m_cdrom_status[0] = data; + m_cdrom_status[0] = data; break; case 0x08/4: /* CDROM STATUS 2 */ - state->m_cdrom_status[1] = data; - state->m_cdrom_status[0] &= data; + m_cdrom_status[1] = data; + m_cdrom_status[0] &= data; break; case 0x10/4: /* CDROM ADDRESS 1 */ - state->m_cdrom_address[0] = data; + m_cdrom_address[0] = data; break; case 0x14/4: /* CDROM ADDRESS 2 */ - state->m_cdrom_address[1] = data; + m_cdrom_address[1] = data; break; case 0x18/4: /* CDROM COMMAND 1 */ if ( ACCESSING_BITS_16_23 ) - state->m_cdrom_cmd_start = ( data >> 16 ) & 0xff; + m_cdrom_cmd_start = ( data >> 16 ) & 0xff; if ( ACCESSING_BITS_8_15 ) - state->m_cdrom_cmd_resp = ( data >> 8 ) & 0xff; + m_cdrom_cmd_resp = ( data >> 8 ) & 0xff; - akiko_update_cdrom(state); + update_cdrom(); break; case 0x1C/4: /* CDROM COMMAND 2 */ if ( ACCESSING_BITS_16_23 ) - state->m_cdrom_cmd_end = ( data >> 16 ) & 0xff; + m_cdrom_cmd_end = ( data >> 16 ) & 0xff; - akiko_update_cdrom(state); + update_cdrom(); break; case 0x20/4: /* CDROM DMA SECTOR READ REQUEST WRITE */ if (LOG_AKIKO_CD) logerror( "Read Req mask W: data %08x - mem mask %08x\n", data, mem_mask ); if ( ACCESSING_BITS_16_31 ) { - state->m_cdrom_readreqmask = (data >> 16); - state->m_cdrom_readmask = 0; + m_cdrom_readreqmask = (data >> 16); + m_cdrom_readmask = 0; } break; case 0x24/4: /* CDROM DMA ENABLE? */ if (LOG_AKIKO_CD) logerror( "DMA enable W: data %08x - mem mask %08x\n", data, mem_mask ); - if ( ( state->m_cdrom_dmacontrol ^ data ) & 0x04000000 ) + if ( ( m_cdrom_dmacontrol ^ data ) & 0x04000000 ) { if ( data & 0x04000000 ) - akiko_start_dma(state); + start_dma(); } - state->m_cdrom_dmacontrol = data; + m_cdrom_dmacontrol = data; break; case 0x30/4: - akiko_nvram_write(state, data); + nvram_write(data); break; case 0x38/4: - akiko_c2p_write(state, data); + c2p_write(data); break; default: break; } } - -const device_type AKIKO = &device_creator; - -akiko_device::akiko_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) - : device_t(mconfig, AKIKO, "Akiko", tag, owner, clock, "akiko", __FILE__) -{ - m_token = global_alloc_clear(akiko_state); -} - -//------------------------------------------------- -// device_config_complete - perform any -// operations now that the configuration is -// complete -//------------------------------------------------- - -void akiko_device::device_config_complete() -{ -} - -//------------------------------------------------- -// device_start - device-specific startup -//------------------------------------------------- - -void akiko_device::device_start() -{ - DEVICE_START_NAME( akiko )(this); -} - -//------------------------------------------------- -// device_reset - device-specific reset -//------------------------------------------------- - -void akiko_device::device_reset() -{ - DEVICE_RESET_NAME( akiko )(this); -} - -//------------------------------------------------- -// device_stop - device-specific stop -//------------------------------------------------- - -void akiko_device::device_stop() -{ - DEVICE_STOP_NAME( akiko )(this); -}