summaryrefslogblamecommitdiffstatshomepage
path: root/src/emu/device.c
blob: b4cf54a9e1013f06c39b325e94834bc6276acc52 (plain) (tree)
1
2
3
4
5
6
7
8
9
10

                                

                                                                            
            


                               

                                                                            
                
                           


 


                                                                            
 

                                           


 


                                                                            





                                                                          


                                                                            
 



                                                   
 
                                  






                                                                                                 



                                                                   
                                 
 

 
 
                                                                            
                          


                                                                            


                                            

                                                   
                                                                                                                                                                                
                       


                                        
                                 













                                                                                     



                                          
                                       






                                         
 



                                                                                          
                                       


 
                                                   








                                                   
                                              


                                                   
                                                          




                            

                                                      
                                                                 
 
 

                                                   

















                                                                 


                                                   
                                                      











                                                               



                                                   
                                                    











                                                              


















                                                                                                              
                                     


                                                   
                                

                                      
                                                                                                    
                                                  
 

                                        
 

                                       


 
                                                   


                                                   
 
                                                            
 
                                      
                                                                                                    
                                                      
 
                                         
                                     

 
 
                                                   
                          
                                                   
 
                      
 





                                                                                                    
 


                                                                                              
 

                                                     



                                                                                                    
 
 
 
                                                   
                                                
                  

                                                   
                                               
 

                                                   
                                                                                  
                               
 
 
 
                                                   

                                                 
                                                   
 
                                                 
 

                                                   
                                                                                  
                               
 
 
 
                                                   

                                             
                                                   
 
                                                             
 







                                                                                               


 
                                                   

                                               

                                                   
                                                            
 
                                                                                                                      


 
                                                   

                                                 

                                                   
                                                               
 
                                                                 


 
                                                   

                                               
                                                   
 
                                                                                     
 
                                                                         



                                                   

                                             

                                                   
                                                    
 

                                 

 




                                                   
                                              


                                                                                                   
                                                          

                        

                                                   
                          

                                                   
                      
 
                                                    
                                                            

                                          
                           
                                                                                         














                                                                                                    
                                                                                                   


                                                                                     
                                                                                               











                                                                                                    
                                                                 









                                          



                                                   
                        

                                                   
                     
 











                                                                                                    
                        



                                                                      



                                                   
                                      

                                                   
                            
 





                                                                                                    



                                                   

                                                 

                                                   
                         
 





                                                                                                    



                                                   

                                                  

                                                   
                          
 





                                                                                                    



                                                   

                                                

                                                   
                                     
 





                                                                                                    



                                                   


                                            

                                                   
                                       




                                
                                                   

                                                   

                                                   
                                                                   
 
                                



                                                   

                                                 

                                                   
                                                    
 

                          



                                                   


                                                  

                                                   
                                                                     
 

                          


 
                                                   

                                                  
                                                   
 
                                                       
 

                          


 
                                                   


                                               
                                                   
 
                             
 
                                
 
 
 
                                                   












                                                   

                                                 
                                                   
 
                            
 
                                


 
                                                   


                                                
                                                   
 
                                
 
                                

 
 
                                                   


                                                 
                                                   
 
                                 
 
                                


 
                                                   



                                                
                                                   
 
                                     
 
                                



                                                   

                                                 

                                                   
                                   
 
                                



                                                   

                                                 

                                                   
                                                                                       
 
                                



                                                   
























                                                                                                                                                   
 

                                                 
                                                 
















                                                                                  
 














                                                                            
 



                                              
 

































                                                                                  
                                                                                    













                                                                                                     
                                                           
 
                                                                 





                                                                                  
                                                                                    












                                                                             
                                                              






                                                   

                                                
                                                   
 
                                                                 
 
                           
                                              
                                      
                   


 
 



                                                                            
                                                   
                                  

                                                   

                                                    
                                
 


                                                                                                             



                                                   
                                  

                                                   
                                     
 



                                                   


                                            

                                                   
                                                  

                                


 
                                                   


                                                 
                                                   
 
                                                                              
 
 
 

                                                   

                                           

                                                   
                                            





                                                   

                                           

                                                   
                                             

                                


 
                                                   

                                           

                                                   
                                            





                                                   

                                           
                                                   
 
                                             
 
                                
 


                                                   

                                          

                                                   
                                           
 
                                



                                                   

                                          

                                                   
                                            
 
                                



                                                   


                                                   

                                                   
                                           
 
                                



                                                   


                                                    

                                                   
                                            
 
                                



                                                   



                                                

                                                   
                                                
 
                                



                                                   


                                               

                                                   
                                              
 
                                
 
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************

    device.c

    Device interface functions.

***************************************************************************/

#include "emu.h"
#include "debug/debugcpu.h"



//**************************************************************************
//  CONSTANTS
//**************************************************************************

#define TEMP_STRING_POOL_ENTRIES        16
#define MAX_STRING_LENGTH               256



//**************************************************************************
//  GLOBAL VARIABLES
//**************************************************************************

static char temp_string_pool[TEMP_STRING_POOL_ENTRIES][MAX_STRING_LENGTH];
static int temp_string_pool_index;



//**************************************************************************
//  INLINE FUNCTIONS
//**************************************************************************

//-------------------------------------------------
//  get_temp_string_buffer - return a pointer to
//  a temporary string buffer
//-------------------------------------------------

char *get_temp_string_buffer(void)
{
	char *string = &temp_string_pool[temp_string_pool_index++ % TEMP_STRING_POOL_ENTRIES][0];
	string[0] = 0;
	return string;
}


resource_pool &machine_get_pool(running_machine &machine)
{
	// temporary to get around include dependencies, until CPUs
	// get a proper device class
	return machine.respool();
}



//**************************************************************************
//  LIVE DEVICE MANAGEMENT
//**************************************************************************

//-------------------------------------------------
//  device_t - constructor for a new
//  running device; initial state is derived
//  from the provided config
//-------------------------------------------------

device_t::device_t(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	: m_type(type),
		m_name(name),
		m_shortname(shortname),
		m_searchpath(shortname),
		m_source(source),
		m_owner(owner),
		m_next(NULL),

		m_interface_list(NULL),
		m_execute(NULL),
		m_memory(NULL),
		m_state(NULL),

		m_configured_clock(clock),
		m_unscaled_clock(clock),
		m_clock(clock),
		m_clock_scale(1.0),
		m_attoseconds_per_clock((clock == 0) ? 0 : HZ_TO_ATTOSECONDS(clock)),

		m_region(NULL),
		m_machine_config(mconfig),
		m_static_config(NULL),
		m_input_defaults(NULL),
		m_default_bios_tag(""),

		m_machine(NULL),
		m_save(NULL),
		m_basetag(tag),
		m_config_complete(false),
		m_started(false),
		m_auto_finder_list(NULL)
{
	if (owner != NULL)
		m_tag.cpy((owner->owner() == NULL) ? "" : owner->tag()).cat(":").cat(tag);
	else
		m_tag.cpy(":");
	static_set_clock(*this, clock);
}


//-------------------------------------------------
//  ~device_t - destructor for a device_t
//-------------------------------------------------

device_t::~device_t()
{
}


//-------------------------------------------------
//  memregion - return a pointer to the region
//  info for a given region
//-------------------------------------------------

memory_region *device_t::memregion(const char *_tag) const
{
	// safety first
	if (this == NULL)
		return NULL;

	// build a fully-qualified name and look it up
	astring fullpath;
	return machine().memory().region(subtag(fullpath, _tag));
}


//-------------------------------------------------
//  memshare - return a pointer to the memory share
//  info for a given share
//-------------------------------------------------

memory_share *device_t::memshare(const char *_tag) const
{
	// safety first
	if (this == NULL)
		return NULL;

	// build a fully-qualified name and look it up
	astring fullpath;
	return machine().memory().shared(subtag(fullpath, _tag));
}


//-------------------------------------------------
//  membank - return a pointer to the memory
//  bank info for a given bank
//-------------------------------------------------

memory_bank *device_t::membank(const char *_tag) const
{
	// safety first
	if (this == NULL)
		return NULL;

	// build a fully-qualified name and look it up
	astring fullpath;
	return machine().memory().bank(subtag(fullpath, _tag));
}


//-------------------------------------------------
//  ioport - return a pointer to the I/O port
//  object for a given port name
//-------------------------------------------------

ioport_port *device_t::ioport(const char *tag) const
{
	// safety first
	if (this == NULL)
		return NULL;

	// build a fully-qualified name and look it up
	astring fullpath;
	return machine().ioport().port(subtag(fullpath, tag));
}


//-------------------------------------------------
//  static_set_clock - set/change the clock on
//  a device
//-------------------------------------------------

void device_t::static_set_clock(device_t &device, UINT32 clock)
{
	// derive the clock from our owner if requested
	if ((clock & 0xff000000) == 0xff000000)
	{
		assert(device.m_owner != NULL);
		clock = device.m_owner->m_configured_clock * ((clock >> 12) & 0xfff) / ((clock >> 0) & 0xfff);
	}

	device.m_clock = device.m_unscaled_clock = device.m_configured_clock = clock;
	device.m_attoseconds_per_clock = (clock == 0) ? 0 : HZ_TO_ATTOSECONDS(clock);
}


//-------------------------------------------------
//  config_complete - called when the
//  configuration of a device is complete
//-------------------------------------------------

void device_t::config_complete()
{
	// first notify the interfaces
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_config_complete();

	// then notify the device itself
	device_config_complete();

	// then mark ourselves complete
	m_config_complete = true;
}


//-------------------------------------------------
//  validity_check - validate a device after the
//  configuration has been constructed
//-------------------------------------------------

void device_t::validity_check(validity_checker &valid) const
{
	// validate via the interfaces
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_validity_check(valid);

	// let the device itself validate
	device_validity_check(valid);
}


//-------------------------------------------------
//  reset - reset a device
//-------------------------------------------------

void device_t::reset()
{
	// let the interfaces do their pre-work
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_pre_reset();

	// reset the device
	device_reset();

	// reset all child devices
	for (device_t *child = m_subdevice_list.first(); child != NULL; child = child->next())
		child->reset();

	// now allow for some post-child reset action
	device_reset_after_children();

	// let the interfaces do their post-work
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_post_reset();
}


//-------------------------------------------------
//  set_unscaled_clock - sets the given device's
//  unscaled clock
//-------------------------------------------------

void device_t::set_unscaled_clock(UINT32 clock)
{
	m_unscaled_clock = clock;
	m_clock = m_unscaled_clock * m_clock_scale;
	m_attoseconds_per_clock = (m_clock == 0) ? 0 : HZ_TO_ATTOSECONDS(m_clock);
	notify_clock_changed();
}


//-------------------------------------------------
//  set_clock_scale - sets a scale factor for the
//  device's clock
//-------------------------------------------------

void device_t::set_clock_scale(double clockscale)
{
	m_clock_scale = clockscale;
	m_clock = m_unscaled_clock * m_clock_scale;
	m_attoseconds_per_clock = (m_clock == 0) ? 0 : HZ_TO_ATTOSECONDS(m_clock);
	notify_clock_changed();
}


//-------------------------------------------------
//  clocks_to_attotime - converts a number of
//  clock ticks to an attotime
//-------------------------------------------------

attotime device_t::clocks_to_attotime(UINT64 numclocks) const
{
	if (numclocks < m_clock)
		return attotime(0, numclocks * m_attoseconds_per_clock);
	else
	{
		UINT32 remainder;
		UINT32 quotient = divu_64x32_rem(numclocks, m_clock, &remainder);
		return attotime(quotient, (UINT64)remainder * (UINT64)m_attoseconds_per_clock);
	}
}


//-------------------------------------------------
//  attotime_to_clocks - converts a duration as
//  attotime to CPU clock ticks
//-------------------------------------------------

UINT64 device_t::attotime_to_clocks(attotime duration) const
{
	return mulu_32x32(duration.seconds, m_clock) + (UINT64)duration.attoseconds / (UINT64)m_attoseconds_per_clock;
}


//-------------------------------------------------
//  timer_alloc - allocate a timer for our device
//  callback
//-------------------------------------------------

emu_timer *device_t::timer_alloc(device_timer_id id, void *ptr)
{
	return machine().scheduler().timer_alloc(*this, id, ptr);
}


//-------------------------------------------------
//  timer_set - set a temporary timer that will
//  call our device callback
//-------------------------------------------------

void device_t::timer_set(attotime duration, device_timer_id id, int param, void *ptr)
{
	machine().scheduler().timer_set(duration, *this, id, param, ptr);
}


//-------------------------------------------------
//  set_machine - notify that the machine now
//  exists
//-------------------------------------------------

void device_t::set_machine(running_machine &machine)
{
	m_machine = &machine;
	m_save = &machine.save();
}

//-------------------------------------------------
//  findit - seach for all objects in auto finder
//  list and return status
//-------------------------------------------------

bool device_t::findit(bool isvalidation) const
{
	bool allfound = true;
	for (finder_base *autodev = m_auto_finder_list; autodev != NULL; autodev = autodev->m_next)
		allfound &= autodev->findit(isvalidation);
	return allfound;
}

//-------------------------------------------------
//  start - start a device
//-------------------------------------------------

void device_t::start()
{
	// populate the machine and the region field
	m_region = machine().root_device().memregion(tag());

	// find all the registered devices
	if (!findit(false))
		throw emu_fatalerror("Missing some required objects, unable to proceed");

	// let the interfaces do their pre-work
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_pre_start();

	// remember the number of state registrations
	int state_registrations = machine().save().registration_count();

	// start the device
	device_start();

	// complain if nothing was registered by the device
	state_registrations = machine().save().registration_count() - state_registrations;
	device_execute_interface *exec;
	device_sound_interface *sound;
	if (state_registrations == 0 && (interface(exec) || interface(sound)) && type() != SPEAKER)
	{
		logerror("Device '%s' did not register any state to save!\n", tag());
		if ((machine().system().flags & GAME_SUPPORTS_SAVE) != 0)
			fatalerror("Device '%s' did not register any state to save!\n", tag());
	}

	// let the interfaces do their post-work
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_post_start();

	// force an update of the clock
	notify_clock_changed();

	// if we're debugging, create a device_debug object
	if ((machine().debug_flags & DEBUG_FLAG_ENABLED) != 0)
	{
		m_debug.reset(global_alloc(device_debug(*this)));
		debug_setup();
	}

	// register our save states
	save_item(NAME(m_clock));
	save_item(NAME(m_unscaled_clock));
	save_item(NAME(m_clock_scale));

	// we're now officially started
	m_started = true;
}


//-------------------------------------------------
//  stop - stop a device
//-------------------------------------------------

void device_t::stop()
{
	// let the interfaces do their pre-work
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_pre_stop();

	// stop the device
	device_stop();

	// let the interfaces do their post-work
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_post_stop();

	// free any debugging info
	m_debug.reset();

	// we're now officially stopped, and the machine is off-limits
	m_started = false;
	m_machine = NULL;
}


//-------------------------------------------------
//  debug_setup - set up for debugging
//-------------------------------------------------

void device_t::debug_setup()
{
	// notify the interface
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_debug_setup();

	// notify the device
	device_debug_setup();
}


//-------------------------------------------------
//  pre_save - tell the device and its interfaces
//  that we are about to save
//-------------------------------------------------

void device_t::pre_save()
{
	// notify the interface
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_pre_save();

	// notify the device
	device_pre_save();
}


//-------------------------------------------------
//  post_load - tell the device and its interfaces
//  that we just completed a load
//-------------------------------------------------

void device_t::post_load()
{
	// notify the interface
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_post_load();

	// notify the device
	device_post_load();
}


//-------------------------------------------------
//  notify_clock_changed - notify all interfaces
//  that the clock has changed
//-------------------------------------------------

void device_t::notify_clock_changed()
{
	// first notify interfaces
	for (device_interface *intf = m_interface_list; intf != NULL; intf = intf->interface_next())
		intf->interface_clock_changed();

	// then notify the device
	device_clock_changed();
}


//-------------------------------------------------
//  device_config_complete - perform any
//  operations now that the configuration is
//  complete
//-------------------------------------------------

void device_t::device_config_complete()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_validity_check - validate a device after
//  the configuration has been constructed
//-------------------------------------------------

void device_t::device_validity_check(validity_checker &valid) const
{
	// do nothing by default
}


//-------------------------------------------------
//  rom_region - return a pointer to the implicit
//  rom region description for this device
//-------------------------------------------------

const rom_entry *device_t::device_rom_region() const
{
	// none by default
	return NULL;
}


//-------------------------------------------------
//  machine_config - return a pointer to a machine
//  config constructor describing sub-devices for
//  this device
//-------------------------------------------------

machine_config_constructor device_t::device_mconfig_additions() const
{
	// none by default
	return NULL;
}


//-------------------------------------------------
//  input_ports - return a pointer to the implicit
//  input ports description for this device
//-------------------------------------------------

ioport_constructor device_t::device_input_ports() const
{
	// none by default
	return NULL;
}


//-------------------------------------------------
//  device_reset - actually handle resetting of
//  a device; designed to be overriden by the
//  actual device implementation
//-------------------------------------------------

void device_t::device_reset()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_reset_after_children - hook to do
//  reset logic that must happen after the children
//  are reset; designed to be overriden by the
//  actual device implementation
//-------------------------------------------------

void device_t::device_reset_after_children()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_stop - clean up anything that needs to
//  happen before the running_machine goes away
//-------------------------------------------------

void device_t::device_stop()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_pre_save - called prior to saving the
//  state, so that registered variables can be
//  properly normalized
//-------------------------------------------------

void device_t::device_pre_save()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_post_load - called after the loading a
//  saved state, so that registered variables can
//  be expaneded as necessary
//-------------------------------------------------

void device_t::device_post_load()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_clock_changed - called when the
//  device clock is altered in any way; designed
//  to be overridden by the actual device
//  implementation
//-------------------------------------------------

void device_t::device_clock_changed()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_debug_setup - called when the debugger
//  is active to allow for device-specific setup
//-------------------------------------------------

void device_t::device_debug_setup()
{
	// do nothing by default
}


//-------------------------------------------------
//  device_timer - called whenever a device timer
//  fires
//-------------------------------------------------

void device_t::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
	// do nothing by default
}


//-------------------------------------------------
//  subdevice_slow - perform a slow name lookup,
//  caching the results
//-------------------------------------------------

device_t *device_t::subdevice_slow(const char *tag) const
{
	// resolve the full path
	astring fulltag;
	subtag(fulltag, tag);

	// we presume the result is a rooted path; also doubled colons mess up our
	// tree walk, so catch them early
	assert(fulltag[0] == ':');
	assert(fulltag.find("::") == -1);

	// walk the device list to the final path
	device_t *curdevice = &mconfig().root_device();
	if (fulltag.len() > 1)
		for (int start = 1, end = fulltag.chr(start, ':'); start != 0 && curdevice != NULL; start = end + 1, end = fulltag.chr(start, ':'))
		{
			astring part(fulltag, start, (end == -1) ? -1 : end - start);
			for (curdevice = curdevice->m_subdevice_list.first(); curdevice != NULL; curdevice = curdevice->next())
				if (part == curdevice->m_basetag)
					break;
		}

	// if we got a match, add to the fast map
	if (curdevice != NULL)
		m_device_map.add(tag, curdevice);
	return curdevice;
}


//-------------------------------------------------
//  subtag - create a fully resolved path relative
//  to our device based on the provided tag
//-------------------------------------------------

astring &device_t::subtag(astring &result, const char *tag) const
{
	// if the tag begins with a colon, ignore our path and start from the root
	if (*tag == ':')
	{
		tag++;
		result.cpy(":");
	}

	// otherwise, start with our path
	else
	{
		result.cpy(m_tag);
		if (result != ":")
			result.cat(":");
	}

	// iterate over the tag, look for special path characters to resolve
	const char *caret;
	while ((caret = strchr(tag, '^')) != NULL)
	{
		// copy everything up to there
		result.cat(tag, caret - tag);
		tag = caret + 1;

		// strip trailing colons
		int len = result.len();
		while (result[--len] == ':')
			result.substr(0, len);

		// remove the last path part, leaving the last colon
		if (result != ":")
		{
			int lastcolon = result.rchr(0, ':');
			if (lastcolon != -1)
				result.substr(0, lastcolon + 1);
		}
	}

	// copy everything else
	result.cat(tag);

	// strip trailing colons up to the root
	int len = result.len();
	while (len > 1 && result[--len] == ':')
		result.substr(0, len);
	return result;
}


//-------------------------------------------------
//  add_subdevice - create a new device and add it
//  as a subdevice
//-------------------------------------------------

device_t *device_t::add_subdevice(device_type type, const char *tag, UINT32 clock)
{
	// allocate the device and append to our list
	device_t *device = (*type)(mconfig(), tag, this, clock);
	m_subdevice_list.append(*device);

	// apply any machine configuration owned by the device now
	machine_config_constructor additions = device->machine_config_additions();
	if (additions != NULL)
		(*additions)(const_cast<machine_config &>(mconfig()), device, NULL);
	return device;
}


//-------------------------------------------------
//  add_subdevice - create a new device and use it
//  to replace an existing subdevice
//-------------------------------------------------

device_t *device_t::replace_subdevice(device_t &old, device_type type, const char *tag, UINT32 clock)
{
	// iterate over all devices and remove any references to the old device
	device_iterator iter(mconfig().root_device());
	for (device_t *scan = iter.first(); scan != NULL; scan = iter.next())
		scan->m_device_map.reset(); //remove(&old);

	// create a new device, and substitute it for the old one
	device_t *device = (*type)(mconfig(), tag, this, clock);
	m_subdevice_list.replace_and_remove(*device, old);

	// apply any machine configuration owned by the device now
	machine_config_constructor additions = device->machine_config_additions();
	if (additions != NULL)
		(*additions)(const_cast<machine_config &>(mconfig()), device, NULL);
	return device;
}


//-------------------------------------------------
//  remove_subdevice - remove a given subdevice
//-------------------------------------------------

void device_t::remove_subdevice(device_t &device)
{
	// iterate over all devices and remove any references
	device_iterator iter(mconfig().root_device());
	for (device_t *scan = iter.first(); scan != NULL; scan = iter.next())
		scan->m_device_map.reset(); //remove(&device);

	// remove from our list
	m_subdevice_list.remove(device);
}


//-------------------------------------------------
//  register_auto_finder - add a new item to the
//  list of stuff to find after we go live
//-------------------------------------------------

finder_base *device_t::register_auto_finder(finder_base &autodev)
{
	// add to this list
	finder_base *old = m_auto_finder_list;
	m_auto_finder_list = &autodev;
	return old;
}



//**************************************************************************
//  LIVE DEVICE INTERFACES
//**************************************************************************

//-------------------------------------------------
//  device_interface - constructor
//-------------------------------------------------

device_interface::device_interface(device_t &device)
	: m_interface_next(NULL),
		m_device(device)
{
	device_interface **tailptr;
	for (tailptr = &device.m_interface_list; *tailptr != NULL; tailptr = &(*tailptr)->m_interface_next) ;
	*tailptr = this;
}


//-------------------------------------------------
//  ~device_interface - destructor
//-------------------------------------------------

device_interface::~device_interface()
{
}


//-------------------------------------------------
//  interface_config_complete - perform any
//  operations now that the configuration is
//  complete
//-------------------------------------------------

void device_interface::interface_config_complete()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_validity_check - default validation
//  for a device after the configuration has been
//  constructed
//-------------------------------------------------

void device_interface::interface_validity_check(validity_checker &valid) const
{
}


//-------------------------------------------------
//  interface_pre_start - called before the
//  device's own start function
//-------------------------------------------------

void device_interface::interface_pre_start()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_post_start - called after the
//  device's own start function
//-------------------------------------------------

void device_interface::interface_post_start()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_pre_reset - called before the
//  device's own reset function
//-------------------------------------------------

void device_interface::interface_pre_reset()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_post_reset - called after the
//  device's own reset function
//-------------------------------------------------

void device_interface::interface_post_reset()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_pre_stop - called before the
//  device's own stop function
//-------------------------------------------------

void device_interface::interface_pre_stop()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_post_stop - called after the
//  device's own stop function
//-------------------------------------------------

void device_interface::interface_post_stop()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_pre_save - called prior to saving the
//  state, so that registered variables can be
//  properly normalized
//-------------------------------------------------

void device_interface::interface_pre_save()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_post_load - called after the loading a
//  saved state, so that registered variables can
//  be expaneded as necessary
//-------------------------------------------------

void device_interface::interface_post_load()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_clock_changed - called when the
//  device clock is altered in any way; designed
//  to be overridden by the actual device
//  implementation
//-------------------------------------------------

void device_interface::interface_clock_changed()
{
	// do nothing by default
}


//-------------------------------------------------
//  interface_debug_setup - called to allow
//  interfaces to set up any debugging for this
//  device
//-------------------------------------------------

void device_interface::interface_debug_setup()
{
	// do nothing by default
}