Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / system / tracemod / tm_mmi.cc

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: tm_mmi.cc
// Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
// 
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
// 
// The above named program is distributed in the hope that it will be 
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
// 
// You should have received a copy of the GNU General Public
// License along with this work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
// 
// ========== Copyright Header End ============================================
/*
 * Copyright (C) 1991, 2001 Sun Microsystems, Inc.
 * All rights reserved.
 */
#pragma ident "@(#)1.4	01/11/06	tm_mmi.cc"

/*
 * Copyright (c) 1989, Sun Microsystems, Inc. All Rights Reserved. Sun
 * considers its source code as an unpublished, proprietary trade secret, and
 * it is available only under strict license provisions. This copyright
 * notice is placed here only to protect Sun in the event the source is
 * deemed a published work. Disassembly, decompilation, or other means of
 * reducing the object code to human readable form is prohibited by the
 * license agreement under which this code is provided to the user or company
 * in possession of this copy
 * 
 * RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the 
 * Government  is subject to restrictions as set forth in subparagraph 
 * (c) (1) (ii) of the Rights in Technical Data and Computer Software clause
 * at DFARS 52.227-7013 and in similar clauses in the FAR and NASA FAR 
 * Supplement
 */

//
//

#include <sys/types.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <synch.h>
#include <dlfcn.h>
#include <ctype.h>
#include <limits.h>

#include "types.h"
#include "blaze_globals.h"
#include "ui.h"

//#include "cpu.h"
#include "cpu_interface.h"

#include "vtracer.h"
#include "vtracer_async_queue.h"

#include "system.h"
#include "dr.h"


typedef void* TM_OPAQUE_DATA;
#include "tracemod.h"
#include "mmi.h"
#include "mmi-blaze.h"

#include "tm_impl.h"
#include "dev_props.h"

void   ldm_delete_head_spec ();

volatile bool config_is_done;
int bdt_verbose = 0;

/////////////////////////////////////////////////////////////

MmiVarNode *pMmiVarList = NULL;

mmi_dr_s * mmi_dr_list = NULL;
int mmi_dr_list_sz = 0;
int mmi_dr_list_count = 0;

struct property_list *plist = NULL;
uint64_t fkprom_dtinbuf_pa = 0x50;
int fkprom_dtinbuf_offset = 0; // offset at which to write device property data

/////////////////////////////////////////////////////////////

mmi_bool_t   mmi_register_instance_creator (const char * modname, mmi_instance_creator fn)
{
    // In order to register an instance creator, add the module's name
    // into the module list to show it is here.
    // ldm_add_spec ((char *)modname, 0); // for module dependency

    tracemod_t   *tm = TM_self_register_spec (modname, NULL);
    struct ldm_t *pldm;

    if (tm == NULL) {
        return mmi_false;
    }
    pldm = (struct ldm_t *) tm;
    TM_set_mode           (tm, TM_EXT_IO);
    TM_set_type_ext       (tm, TM_TYPE_EXT_DEVICE);
    pldm->create_instance = fn;
    return mmi_true;
} // mmi_register_instance_creator

/////////////////////////////////////////////////////////////

mmi_bool_t   mmi_unregister_instance_creator (mmi_instance_t mod)
{
    Ldm* pldm    = (Ldm *)mod;
    if (!TM_verify (pldm)) {
        return mmi_false;
    }
    TM_invalidate (pldm);
    TM_clean_mod_spec();
    TM_clean_mod();
    return mmi_true;
}

/////////////////////////////////////////////////////////////

int   mmi_register_cb_data (module_t *mod, void *cb_data)
{
    Ldm* pldm    = (Ldm *)mod;
    if (!TM_verify (pldm)) {
        return (-1);
    }
    TM_register_client_data(pldm, cb_data);
    return 0;  
}

mmi_bool_t  mmi_register_asi_cb_data (mmi_instance_t instance, void *cb_data)
{
    Ldm* pldm    = (Ldm *)instance;
    if (!TM_verify (pldm)) {
        return mmi_false;
    }
    TM_register_asi_client_data  (pldm, cb_data);
    return mmi_true;  
}


/////////////////////////////////////////////////////////////

void*   mmi_get_cb_data (module_t *mod)
{
    return mod->client_data;
}

void*   mmi_get_asi_cb_data (module_t *mod)
{
    return mod->asi_client_data;
}

/////////////////////////////////////////////////////////////

void*   mmi_register_cb_cycle  (mmi_instance_t instance, mmi_event_cycle handler, uint64_t repeat)
{
    void   *cb_data = TM_get_client_data(instance);
    return TM_register_time_intf ((Ldm*)instance, cb_data, handler, repeat);
}

/////////////////////////////////////////////////////////////

void   mmi_unregister_cb_cycle  (mmi_instance_t mod, void * intf)
{
    TM_unregister_time_intf ((Ldm*)mod, intf);
}

/////////////////////////////////////////////////////////////

int  mmi_disable_cb_cycle   (void * intf)
{
    TM_disable_time_intf (intf);
    return 0;
}

/////////////////////////////////////////////////////////////

int  mmi_enable_cb_cycle    (void * intf,  blaze_cycle_t repeat )
{
    TM_enable_time_intf (intf, repeat);
    return 0;
}

/////////////////////////////////////////////////////////////

/* MMI UI command interface */
void mmi_register_module_cmd(mmi_module_t mod, const char * helpstring, mmi_module_cmd_fn fn)
{
  Ldm * pldm = (Ldm *)mod;
  char * modname = strdup(pldm->name);

  TM_ui_register_2(pldm, modname, helpstring, helpstring, fn);

} // void mmi_register_module_cmd(mmi_module_t mod, const char * helpstring, mmi_module_cmd_fn fn)


void mmi_register_instance_cmd(mmi_instance_t instance, const char * helpstring, mmi_instance_cmd_fn fn)
{
  Ldm * pldm = (Ldm *) instance;
  char * instancename = strdup(pldm->name);

  TM_ui_register_2(pldm, instancename, helpstring, helpstring, fn);

} // void mmi_register_instance_cmd(mmi_instance_t instance, const char * helpstring, mmi_instance_cmd_fn fn)



/////////////////////////////////////////////////////////////

extern bool_t add_asi_module (tracemod_t* mod, uint32_t asi, mmi_ld_asi_action ld_handler,
			      mmi_st_asi_action st_handler);

/////////////////////////////////////////////////////////////

void 
mmi_register_asi_action  (mmi_instance_t instance, uint32_t asi,
			    mmi_ld_asi_action ld_handler, mmi_st_asi_action st_handler)
{

    AsiHandlerNode *pnode = AsiHandlerNode::CreateInstance("ASI handler list");
    AsiHandlerT    *ph;
    struct  ldm_t  *pldm = (struct ldm_t *)instance;

    if (pnode == NULL) {
        ui->error("MMI: Unable to create ASI interceptor for ASI = 0x%x\n", asi);
	return;
    }

    ph = pnode->GetData ();
    ph->asi   = asi;
    ph->vaddr = 0;
    ph->mmi_ld_action = ld_handler;
    ph->mmi_st_action = st_handler;

    if (add_asi_module(pldm, asi, ld_handler, st_handler)) {
      AsiHandlerNode::AddHead ((AsiHandlerNode**)&pldm->headAsi, pnode);
    } else {
      ui->error("MMI: unable to register ASI interceptor\n");
    }
}

/////////////////////////////////////////////////////////////
int mmi_argc(mmi_instance_t instance)
{
    return ((module_t *)instance)->argc;
}

char *mmi_argv(mmi_instance_t instance, int index)
{
    module_t * mod = (module_t *) instance;
    if (index < 0 || mod->argc <= index)
	return NULL;
    return mod->argv[index];
}

/////////////////////////////////////////////////////////////
void set_module_args(Ldm *pldm, int argc, char **argv)
{
    int i;
    if (pldm->argv) {
	for (i = 0; i < pldm->argc; i++)
	    free(pldm->argv[i]);
	free(pldm->argv);
    }
    pldm->argc = argc;
    pldm->argv = (char**) calloc (argc, sizeof(char*));
    for (i = 0; i < argc; i++)
	pldm->argv[i] = (char*)strdup(argv[i]);
}

/////////////////////////////////////////////////////////////

static Ldm *load_module(char *modname, char * pathp, char *soname)
{
    Ldm   *pldm = NULL; 


    pldm = ldm_add_spec (modname, soname);
    if (pldm == NULL) {
	return NULL;
    }

    pldm->so_handle = mod_dlopen (pathp, soname, RTLD_LAZY|RTLD_GLOBAL|RTLD_PARENT);

    if (pldm->so_handle == NULL) {
	ldm_delete_head_spec();
	return NULL;
    }

    if (!pldm->valid) {
	TM_clean_mod_spec ();
	return NULL;
    }

    return pldm;
}

/////////////////////////////////////////////////////////////

int ldm_cmd_action(int argc, char **argv)
{
    Ldm   *pldm = NULL; 

    // ldm <modname> <instance> [<XX.so>]

    if (argc == 4) { 
	pldm = load_module(argv[1], NULL, argv[3]);
	if (pldm) {
	    set_module_args(pldm, argc, argv);
	    if (pldm->create_instance) {
		pldm->create_instance (argv[1], argv[2]);
	    }
	    else {
		ui->error("LDM: MMI device module - instance creator not found !! \n");
		return 0;
	    }
	}
    }

    else if (argc == 3) {
	// ldm <modname> <instance>
	Ldm *pmod = TM_find_mod_spec (argv[1]);
	if (pmod == NULL) {
	    ui->error("LDM: MMI device module <%s> not found \n", argv[1]);
	    return 0;
	}
	if (pmod->create_instance) {
	    pmod->create_instance (argv[1], argv[2]);
	}
	else {
	    ui->error("LDM: MMI device module - instance creator not found !! \n");
	    return 0;
	}
    }

    return 1;
}

/////////////////////////////////////////////////////////////
int sysconf_usage(const char *msg)
{
    ui->error("sysconf: %s\n", msg);
    ui->error("usage: sysconf [-p <modpath> ] <modname> [ <instance_name> [ args... ] ]\n");
    return -1;
}

/////////////////////////////////////////////////////////////
extern Vcpu * init_cpu ( char *path, int argc, char **argv );


int sysconf_cmd_action(int argc, char **argv)
{
    Ldm *pldm = NULL;
    char modname[64], libname[1024];
    static char path[512] = {"."};

    /* arg to load_module, if null the searchlist */
    /* with $ORIGIN in it is used, if not this explicit path is used */
    char * pathp = NULL;	

    
    // sysconf [-p <modpath> ] <modname> [ <instance_name> [ args... ] ]

    if (argc < 2)
        return sysconf_usage("missing args");

    if (strcmp (argv[1], "-p") == 0) {
	if (argc == 2) 
	    return sysconf_usage("missing args");
	if (argc == 3) {
	    mod_addpath (argv[2]);	/* add to generic search path */
	    return 1;
	}
	/* otherwise, this is a module specific path prefix, handle below */
    }

    // XXX should remove it completely
     if ( (strcmp(argv[1], "done") == 0) && (argc == 2) ) {
    //    complete_initialization();
	 return 1; 
     }

    if ( strcmp ( argv[1], "cpu" ) == 0 )
    {
        // cpu module
         
        // create a new cpu instance;
        // keep a pointer in a global array;
        // skip first two args: "sysconf" and "cpu"; 
        // we really do only pass pathp here, 
	    // the fname is derived from the cpu-type attribute
        Vcpu *vcpu = init_cpu (pathp, argc-2, argv+2);

        // configure cpu params in fakeprom;
        VCPU_Config  &config_info = vcpu->config;

#ifdef V5_FAKEPROM
        // cpu clock frequency
        memwrite64s_nl(mm1, 0x20, config_info.cpufreq);
        
        // system clock frequency
        memwrite64s_nl(mm1, 0x28, the_arch.stick_freq);
        
        // number of cpu's
        memwrite32u_nl(mm1, 0x14, g_nvcpu);
#endif
        // keep a global copy
        // TODO: the_arch maybe soon obsolete
        the_arch.cpu_freq   = config_info.cpufreq;  
        // read stickfreq from conf suplied value 
        config_info.stickfreq = the_arch.stick_freq;
        the_arch.numcpus    = g_nvcpu;           
        
                
        return 1; 
    }


    for (int i = 1; i < argc; i++) {
	if (strcmp(argv[i], "-p") == 0) {
	    if (++i >= argc)
		return sysconf_usage("missing -p <modpath>");
	    strlcpy(path, argv[i], sizeof path);
	    pathp = &path[0];			/* override the searchlist */
	}
	else if (argv[i][0] == '-') {
	    return sysconf_usage(argv[i]);
	}
	else if (!pldm) {
	    strlcpy(modname, argv[i], sizeof modname);
	    sprintf (libname, "%s.so", modname);

	    pldm = TM_find_mod_spec(modname);
	    if (!pldm)
		pldm = load_module (modname, pathp, libname);

	    assert(pldm != NULL);
	    if (!pldm)
		return sysconf_usage("can't load the module");
	}
	else {
	    if (TM_find_mod_spec(argv[i]))
		return sysconf_usage("module instance already exists");
	    mmi_instance_t ins = mmi_register_instance (modname, argv[i], NULL, argv[i]);
	    if (!ins)
		return sysconf_usage("failed to create module instance");
	    set_module_args((module_t *)ins, argc-(i+1), &argv[i+1]);
	    
	    if (pldm->create_instance) {
	      pldm->create_instance (modname, argv[i]);
	    }
	    return 0;
	}
    }

    return 1;
}

/////////////////////////////////////////////////////////////
void modinfo_list_modules()
{
    Ldm     *pldm;
    LdmNode *pnode;

    for (pnode=head_spec_ldm; pnode!=NULL; pnode = pnode->Next()) {
	pldm = pnode->GetData ();
	if (!pldm->parent)
	    ui->output("<%s>\n",  pldm->name);
    }
    for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
	pldm = pnode->GetData ();
	if (pldm->parent)
	    ui->output("<%s> parent=<%s>\n", pldm->name, pldm->parent->name);
    }
}

void modinfo_print_info(char *name)
{
      Ldm     *pldm;
      LdmNode *pnode;

      if (!name)
	  return;

      for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
	  pldm = pnode->GetData ();
	  if (!strcmp(pldm->name, name)) {
	      if (pldm->modinfo_cb)
		  pldm->modinfo_cb(pldm->client_data);
	      return;
          }
      }
      ui->error("%s is not loaded\n", name);
}

int modinfo_cmd_action(int argc, char **argv)
{
    if (argc < 2) {
/*	modinfo_list_modules();
    }
    else if (!strcmp(argv[1], "all") && argc == 2) { */
	Ldm     *pldm;
	LdmNode *pnode;
	for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
	    pldm = pnode->GetData ();
	    if (pldm->help)
	        ui->output("%s: %s\n", pldm->name, pldm->help);
	    if (pldm->modinfo_cb)
	        pldm->modinfo_cb(pldm->client_data);
        }
    }
    else {
	for (int i = 1; i < argc; i++)
	    modinfo_print_info(argv[i]);
    }
    return 0;
}

/////////////////////////////////////////////////////////////

int mmi_cmd_action (void*, int argc, char **argv)
{
    if (SYSTEM_is_running ()) {
        ui->error("mmi_cmd_action(%s) called while in run state!!!\n", argv[0]);
    }

    if (strcmp (argv[0], "uldm") == NULL) {
      ui->error("uldm has been deprecated. config specifications are not UI commands\n");
    }

    else if (strcmp (argv[0], "ioa") == NULL) {

        if (argc < 4) {
	    ui->error("UI:usage : ioa <instance name> <ADDR1> <ADDR2>\n");
	    return 0;
        }
	uint64_t baddr, eaddr;
	sscanf (argv[2], "%lli", &baddr);
	sscanf (argv[3], "%lli", &eaddr);
	assert(0);
	return false;
    }

    else if (strcmp(argv[0], "ldm") == NULL) {
	return ldm_cmd_action(argc, argv);
    }

    else if (!strcmp(argv[0], "cfg") || !strcmp(argv[0], "sysconf")) {
	return sysconf_cmd_action(argc, argv);
    }

    else if (!strcmp(argv[0], "modinfo")) {
	return modinfo_cmd_action(argc, argv);
    }

    return 1;
}

/////////////////////////////////////////////////////////////

mmi_instance_t   mmi_register_instance  (const char * modname, const char *instance_name, void * instance_data, const char * help)
{
    // parent module must exist
    Ldm *pmod = TM_find_mod_spec ((char*)modname);
    if (pmod == NULL) {
        ui->error("MMI: module <%s> not found \n", modname);
	return NULL;
    }

    // create instance, unless already done
    Ldm *pseudo_mod = TM_find_mod_spec_instance(pmod, (char*)instance_name);

    if (pseudo_mod) {
      pseudo_mod->help = strdup(help);
    }
    else {
	pseudo_mod = TM_self_pseudomod_spec  (pmod, (char*)instance_name, help, NULL);

	if (pseudo_mod) {
	    TM_set_mode     (pseudo_mod, TM_EXT_IO);
	    TM_set_type_ext (pseudo_mod, TM_TYPE_EXT_DEVICE);
	}
    }

    mmi_register_cb_data(pseudo_mod, instance_data);
    return (mmi_instance_t) pseudo_mod;
} // mmi_register_instance()


void * mmi_get_instance_data(mmi_instance_t instance)
{
  return mmi_get_cb_data((module_t *) instance);
}


/////////////////////////////////////////////////////////////
void TM_module_init()
{
    Ldm     *pldm;
    LdmNode *pnode;

    for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
	pldm = pnode->GetData ();
	if (pldm->config_cb)
	    (pldm->config_cb)(pldm->client_data, pldm, pldm->name, MMI_CONFIG_INIT_DONE);
    }

    // register the atexit function
    atexit(TM_run_atexit_cb);

    config_is_done = true;
}

/////////////////////////////////////////////////////////////
// call the config_cb callback of each registered module with 
// the event MMI_CONFIG_DELETE_MODULE. The modules checks to see 
// if the deleted module is itself, in which case it calls delete 
// on itself
void TM_run_atexit_cb(){
    Ldm     *pldm;
    LdmNode *pnode;

    for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
    	pldm = pnode->GetData ();
	    if (pldm->config_cb)
            (pldm->config_cb)(pldm->client_data, pldm, pldm->name, MMI_CONFIG_DELETE_MODULE);
    }
}
/////////////////////////////////////////////////////////////


void TM_run_config_cb (tracemod_t *mod, int ev)
{
    Ldm     *pldm;
    LdmNode *pnode;

    // tell other mods first
    for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
	pldm = pnode->GetData ();
	if (pldm->config_cb && pldm != mod)
	    (pldm->config_cb)(pldm->client_data, mod, mod->name, (mmi_config_t)ev);
    }

    // run this mod last, in case it is going away
    if (mod->config_cb)
	(mod->config_cb)(mod->client_data, mod, mod->name, (mmi_config_t)ev);
}

/////////////////////////////////////////////////////////////

int   mmi_unregister_module    (module_t *mod)
{
    Ldm* pldm    = (Ldm *)mod;

    if (!TM_verify (pldm)) {
        return (-1);
    }

    // clean out timer callbacks
    TM_unregister_time_intf(pldm, NULL);

    if (pldm->so_handle) {	// delete instances first
	Ldm* instance;
	while ((instance = TM_find_mod_spec_instance(pldm, NULL)) != NULL)
	    mmi_unregister_module(instance);
    }
    TM_run_config_cb (mod, MMI_CONFIG_DELETE_MODULE);
    TM_invalidate (pldm);
    TM_clean_mod_spec();
    TM_clean_mod();
    return 0;  
}

/////////////////////////////////////////////////////////////

module_t   *mmi_get_instance_pointer (const char *modname, const char *instance_name)
{
      Ldm * pldm = TM_find_mod_spec ((char*)modname);

      if (instance_name == NULL) {
	  return (module_t*)pldm;
      }

      if (pldm == NULL)
	  return NULL;
      pldm = TM_find_mod_spec_instance (pldm, (char*)instance_name);
      return (module_t*)pldm;
}

/////////////////////////////////////////////////////////////

module_t   *mmi_get_module (const char *modname)
{
  char * s = strdup(modname);
  module_t * module = TM_find_mod_spec(s);
  free(s);
  return module;
}


mmi_instance_t mmi_get_instance(const char * instancename)
{
  char * s = strdup(instancename);
  mmi_instance_t instance = TM_find_mod_spec(s);
  free(s);
  return instance;
}

/////////////////////////////////////////////////////////////

mmi_bool_t mmi_register_interface_cb (mmi_instance_t instance, mmi_interface_cb fn)
{
  module_t * mod = (module_t *) instance;
    if (!TM_verify (mod))
        return mmi_false;
    mod->interface_cb = fn;	
    return mmi_true;
}

/////////////////////////////////////////////////////////////

mmi_bool_t mmi_register_modinfo_cb (mmi_instance_t instance, mmi_modinfo_cb fn)
{
  module_t * mod = (module_t *) instance;
    if (!TM_verify (mod))
        return mmi_false;
    mod->modinfo_cb = fn;	
    return mmi_true;
}

/////////////////////////////////////////////////////////////

mmi_bool_t
mmi_register_config_cb (mmi_instance_t instance, mmi_config_cb fn)
{
  module_t *mod = (module_t *) instance;
    if (!TM_verify (mod))
        return mmi_false;

    mod->config_cb = fn;

    // report the modules that exist
    {
	Ldm     *pldm;
	LdmNode *pnode;

	for (pnode=head_spec_ldm; pnode!=NULL; pnode=pnode->Next()) {
	    pldm = pnode->GetData ();
	    fn(mod->client_data, pldm, pldm->name, MMI_CONFIG_NEW_MODULE);
	}
    }

    // report this module to the others that exist
    TM_run_config_cb(mod, MMI_CONFIG_NEW_MODULE);

    return mmi_true;
}

/////////////////////////////////////////////////////////////

void *
mmi_get_interface (mmi_instance_t instance, const char *name)
{
  module_t *mod = (module_t *) instance;
    if (!TM_verify (mod))
        return NULL;
    if (mod->interface_cb)
	return mod->interface_cb(mod->client_data, name);
    if (mod->parent && mod->parent->interface_cb)
	return mod->parent->interface_cb(mod->client_data, name);
    return NULL;
}

/////////////////////////////////////////////////////////////
void mmi_memread(uint64_t paddr, uint8_t * data, uint64_t size,SAM_DeviceId sam_id)
{   
  assert((size>>32) == 0); // FIXME: need to fix this in Memory::block_read(). 2007.10.23
  mm1->block_read(paddr,data,(int)size);
  TRACE_DMA(/*is_write?*/ 0, size, paddr, sam_id);
} // void mmi_memread(uint64_t paddr, uint8_t * data, uint64_t size, SAM_DeviceId sam_id)
  
  
    
/////////////////////////////////////////////////////////////
void mmi_memwrite(uint64_t paddr, const uint8_t * data, uint64_t size,SAM_DeviceId sam_id)
{   

  assert((size>>32) == 0); // FIXME: need to fix this in Memory::block_write(). 2007.10.23
  mm1->block_write(paddr,data,(int)size);
  TRACE_DMA(/*is_write?*/ 1, size, paddr, sam_id);
} // void mmi_memwrite(uint64_t paddr, const uint8_t * data, uint64_t size, SAM_DeviceId sam_id)
    
    
/////////////////////////////////////////////////////////////
void mmi_register_start_stop(mmi_start_stop_cb start_action, mmi_start_stop_cb stop_action, void * userdata)
{ 
  SYSTEM_ss_register((ss_action)stop_action, (ss_action) start_action, userdata);
} // void mmi_register_start_stop(mmi_start_stop_cb start_action, mmi_start_stop_cb stop_action, void * userdata)
  
/////////////////////////////////////////////////////////////
bool_t tm_mmi_dump(DR_OPAQUE drh) {
  int i; char file_name[PATH_MAX];
  for (i=0; i<mmi_dr_list_count; i++) {
    ui->output("Dumping <%s> ...\n", mmi_dr_list[i].name);
    snprintf(file_name, PATH_MAX, "%s/%s.dmp", DR_get_dir(), mmi_dr_list[i].name);
    if (! mmi_dr_list[i].dump_fn(mmi_dr_list[i].userdata, file_name)) {
      ui->error("dump failed\n");
      return FALSE;
    }
    ui->output("done\n");
  }
  return TRUE;
} // mmi_dump()

/////////////////////////////////////////////////////////////
bool_t tm_mmi_restore(DR_OPAQUE drh) {
  int i; char file_name[PATH_MAX];

  for (i=0; i<mmi_dr_list_count; i++) {
    ui->output("Restoring <%s> ...", mmi_dr_list[i].name);
    snprintf(file_name, PATH_MAX, "%s/%s.dmp", DR_get_rdir(drh), mmi_dr_list[i].name);
    if (!mmi_dr_list[i].restore_fn(mmi_dr_list[i].userdata, file_name)) {
      ui->error("restore failed\n");
      return FALSE;
    }
    ui->output("done\n");
  }
  return TRUE;
} // mmi_restore()

/////////////////////////////////////////////////////////////
mmi_bool_t mmi_register_dump_restore(const char *name, mmi_dump_cb dump_fn, mmi_restore_cb restore_fn, void *userdata)
{
  if (mmi_dr_list == NULL) {
    mmi_dr_list_sz = 32;
    mmi_dr_list = new mmi_dr_s [mmi_dr_list_sz];
    mmi_dr_list_count = 0;

    DR_register("MMI:DR", tm_mmi_dump, tm_mmi_restore, NULL);
  }
  if (mmi_dr_list_count == mmi_dr_list_sz) {
    int newsz = 2*mmi_dr_list_sz;
    mmi_dr_s * newlist = new mmi_dr_s[newsz];
    size_t nbytes = mmi_dr_list_sz*sizeof(mmi_dr_s);
    memcpy(newlist, mmi_dr_list, nbytes);
    memset(newlist + mmi_dr_list_sz, 0, nbytes);

    delete [] mmi_dr_list;

    mmi_dr_list = newlist;
    mmi_dr_list_sz = newsz;
  }

  mmi_dr_list[mmi_dr_list_count].userdata = userdata;
  mmi_dr_list[mmi_dr_list_count].name = strdup(name);
  mmi_dr_list[mmi_dr_list_count].dump_fn = dump_fn;
  mmi_dr_list[mmi_dr_list_count].restore_fn = restore_fn;
  mmi_dr_list_count++;

  return mmi_true;
} // mmi_bool_t mmi_register_dump_restore(void * userdata, mmi_dump_cb dump_fn, mmi_restore_cb restore_fn)


/////////////////////////////////////////////////////////////



int64_t mmi_get_time() 		// simulated microseconds, since boot
{
  return SYSTEM_get_time(TW_CURRENT);
}

				// event-queue based internal synchonization
mmi_bool_t mmi_register_event (int64_t when, 
		mmi_event_cb event_fn, void * userdata1, void * userdata2)
{
  SYSTEM_register_event (when, (EventFunc_T*)event_fn, userdata1, userdata2,
			       (UnloadFunc_T*)NULL, "mmi-unknown");
  return mmi_true;
}



/////////////////////////////////////////////////////////////

int  mmi_register_cb_instr (module_t *mod, fn_event_cpu handler)
{
  ui->error("SAM MMI: mmi_register_cb_instr no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int   mmi_register_cb_memop (module_t *mod, fn_event_cpu handler)
{
  ui->error("SAM MMI: mmi_register_cb_memop no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int   mmi_register_cb_trap (module_t *mod, fn_event_cpu handler)
{
  ui->error("SAM MMI: mmi_register_cb_trap no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int   mmi_register_cb_trapexit (module_t *mod, fn_event_cpu handler)
{
  ui->error("SAM MMI: mmi_register_cb_trapexit no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int   mmi_register_cb_tlb (module_t *mod, fn_event_cpu handler)
{
  ui->error("SAM MMI: mmi_register_cb_tlb no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int   mmi_register_cb_cpustate (module_t *mod, fn_event_cpu handler)
{
  ui->error("SAM MMI: mmi_register_cb_cpustate no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int mmi_register_cb_dma (module_t *mod, fn_event_dma handler)
{
  ui->error("SAM MMI: mmi_register_cb_dma no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

int   mmi_set_cb_mask     (module_t *mod, uint32_t mask)
{
  ui->error("SAM MMI: mmi_set_cb_mask no longer supported (called from module %s)\n", mod->name);
  return -1;
}

/////////////////////////////////////////////////////////////

/*OBSOLETE*/
int mmi_register_io_action (module_t *mod, mmi_io_action ld_handler, mmi_io_action st_handler)
{
    if ((mod == 0) || (ld_handler == 0) || (st_handler == 0))
        return (-1);

    TM_register_io_mmi_action ((tracemod_t*)mod, (fn_misc)ld_handler, (fn_misc)st_handler);
    return 0;
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////


mem_t* mmi_get_memobj (cpu_t *)
{
    return mm1; //memobj ();
}

/////////////////////////////////////////////////////////////

//
// TODO : Might be a subject of MODULE REDIRECTION itself 
//

int    mmi_iommu_va2pa (module_t *, int is_read, uint64_t va, uint64_t *)
{

  uint64_t local_pa;
  assert(0);
    return local_pa ? 0 : (-1);
}


/////////////////////////////////////////////////////////////
//
// review of Sun4u Mondo interrupts:
//		sender			receiver
//		------			--------
//
//  cpu-to-cpu:
//		data      => IDDR	
//	(tgt_AgentID<<14) => IDCR--->---IRSR => bits-<5:0> = src_AgentID
//					IRDR => data
//  schizo-to-cpu:
//	(tgt_AgentID<<26 | src_AgentID<<6 | dev_INO) =>...
//			...=> INR--->---IRSR => bits-<5:0> = src_AgentID
// (*)					IRDR => bits-<10:0> = (AID<<6) | INO
//  *
//  *-> idata[0] must be supplied by schizo HW _!!!_
//
int mmi_interrupt_packet (int dst_aid, int src_aid, uint64_t *idata)
{
    intrT intr;    // recently typedef'ed to "cpu_lib_intf.h"/InterruptRequest

    intr.isid    = src_aid;
    intr.itid    = dst_aid;
    intr.data[0] = idata[0];
    intr.data[1] = idata[1];
    intr.data[2] = idata[2];	// data[3..7] not part of original mondo spec
				// and never referenced by solaris :-!.

    SYSTEM_interrupt_by_sid (dst_aid, src_aid, &intr);

    return 0;
}

/////////////////////////////////////////////////////////////
//
// Sun4v ??? interrupt
//
int mmi_interrupt_vector (int dest_cpuid, void *src, int src_iscpu, uint32_t vnum, int traptype)
{

    intrT intr;
  
    intr.isid    = 0xF00 | traptype; // Patch - to distinguish between 
    intr.itid    = dest_cpuid;
    intr.data[0] = vnum;

    SYSTEM_interrupt_by_sid (dest_cpuid, 0, &intr);
    return 0;

}

/////////////////////////////////////////////////////////////

int mmi_reset            (cpu_t *, void *, resettype_t )
{
    ui->error("MMI: RESET is not implemented yet \n");
    return (-1);
}

/////////////////////////////////////////////////////////////

int mmi_get_ncpu      ()
{
    return SYSTEM_get_ncpu ();
}



int mmi_get_cpu_sid     (cpu_t *sp)
{
    return sp->id();
}

cpu_t *mmi_get_cpuptr_by_sid (int id) 
{
    return get_vcpu(id);
}
uint64_t mmi_get_cpufreq ()
{
    return SYSTEM_get_cpufreq();
}

char *mmi_get_comment_string (void *, objtype_t )
{
    return (char*)strdup("unimplemented");
}

int mmi_complete_delayed_load (cpu_t *, uint64_t )
{
    ui->error("MMI: complete delayed load is not implemented yet \n");
    return -1;
}

int   mmi_delay_execution       (cpu_t *sp, blaze_cycle_t delay)
{
    SYSTEM_cycle_delay (sp->id(), (uint32_t)delay);
    return 0;
}


//////////////////////////////////////////////////

int mmi_register_ui_variable (module_t *module,  const char *varname, 
			      vartype_t vartype, void *varptr, int writable, fn_setvar writer)

{

    MmiVar      *pvar;
    MmiVarNode  *pnode = MmiVarNode::CreateInstance ("MMI Varlist");

    if (pnode == NULL) {
        ui->error("MMI:Unable to register UI VARIABLE <%s>\n", varname);
        return -1;
    }
    if (module == 0) {
        return -1;
    }
    
    switch (vartype) {
      case VAR_INT:
      case VAR_LONG_INT:
      case VAR_STRING:
      case VAR_BOOL:
         break;
      default :
        ui->error("MMI: Uknown variable type  <%d> \n", vartype);
        return -1;
	
    }

    
    pvar            = pnode->GetData ();
    pvar->name      = (const char*)strdup(varname);      
    pvar->vtype     = vartype;
    pvar->writable  = writable;
    pvar->action    = writer;
    pvar->module    = module;
    pvar->varptr    = varptr;

    MmiVarNode::AddHead (&pMmiVarList, pnode);
    return 0;
}

//////////////////////////////////////////////////

int mmi_set_ui_variable      (module_t *module, const char *varname,  void *val)
{

    MmiVar      *pvar;
    MmiVarNode  *pnode = pMmiVarList;
    char       **pq;

    for (;pnode; pnode = pnode->Next()) {
        pvar  = pnode->GetData ();
        if (strcmp (varname, pvar->name) == NULL) {
	    if (module == pvar->module) {
	        if (pvar->writable && pvar->action) {
		    void   *cb_data = TM_get_client_data  ((void *)module);
		    pvar->action(cb_data, val);
		    return 0;
                }
		else if (pvar->writable) {
		    switch (pvar->vtype) {
		      case VAR_INT:
                         *((uint32_t*) pvar->varptr) = *( (uint32_t*) val);
			 break;
 		      case VAR_LONG_INT:
                         *((uint64_t*) pvar->varptr) = *( (uint64_t*) val);
			 break;
		      case VAR_STRING:
			 pq = (char**)&(pvar->varptr);
		         *pq = (char*)strdup((char*)val);
			 break;
		      case VAR_BOOL:
                         *((uint8_t*) pvar->varptr) = *( (uint8_t*) val);
			 break;
		      default :
		         return -1;
		    }
                    return 0;
                }
            }
	}
    }

    return -1;
}

//////////////////////////////////////////////////

/////////////////////////////////
// FlexConfig-related additions
/////////////////////////////////

char *ldm_get_instanceof(char *modname) {
  Ldm* pldm;
  LdmNode *pnode = head_spec_ldm;
  while(pnode) {
    pldm = pnode->GetData();
    if ( strstr(pldm->name, modname) )
      return pldm->name;
    pnode = pnode->Next();
  }
  return NULL;
}