Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / legion / src / devices / mmi / mmi.c

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: mmi.c
* 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)mmi.c	1.4	06/07/22 SMI"

/*
 * This file contains the Legion implementation of the MMI APIs. 
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <string.h>

#include "basics.h"
#include "allocate.h"
#include "lexer.h"
#include "simcore.h"
#include "config.h"
#include "dumpinfo.h"
#include "fatal.h"
#include "device.h"
#include "mmi.h"
#include "sam_dev.h"


mmi_bool_t mmi_register_instance_creator (const char * modname, mmi_instance_creator create_instance)
{
	sam_device_t	*sam_devp;
	uint8_t		instance;
	char		instance_name[BUFSIZ];
	

	if (create_instance) {
		sam_devp = sam_get_instance(modname, &instance);
		ASSERT(sam_devp);
		if (sam_devp->mmi_datap->instance_name == NULL) {
			sprintf(instance_name, "%s%d",
			    sam_devp->mmi_datap->modname, instance);
			sam_devp->mmi_datap->instance_name =
			    strdup(instance_name);
		}
		create_instance(sam_devp->mmi_datap->modname,
		    sam_devp->mmi_datap->instance_name);
		sam_devp->mmi_datap->create_instance = create_instance;
		return mmi_true;
	}

	return mmi_false;
}

void mmi_register_instance_cmd (mmi_instance_t instance, const char * helpstring, mmi_instance_cmd_fn fn)
{
        DBGDEV(lprintf(-1, "Warning: mmi_register_instance_cmd is not supported\n"););
}

mmi_instance_t mmi_register_instance(const char * modname, const char *instance_name, 
				     void * instance_data, const char * help)
{
	sam_device_t *sam_devp = sam_find_device(instance_name);
	
	if (!sam_devp) {
		printf("mmi_register_instance: failed to register instance <%s>\n",
		       instance_name);
		return NULL;
	}

	sam_devp->mmi_datap->cb_data = instance_data;

	return (mmi_instance_t) (sam_devp->mmi_datap);
}


mmi_bool_t mmi_register_config_cb(mmi_instance_t instance, mmi_config_cb fn)
{
	mmi_data_t	*mmi_datap = (mmi_data_t *)instance;	
	sam_device_t 	*sam_devp;
	sam_device_t 	*osam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_register_config_cb: invalid instance = 0x%llx\n", instance);
		return mmi_false;
	}

	sam_devp->mmi_datap->config_cb = fn;
        osam_devp = sam_dev_list_head;

        while (osam_devp) {
		fn(sam_devp->mmi_datap->cb_data, (mmi_instance_t) (osam_devp->mmi_datap),
		    osam_devp->mmi_datap->instance_name, MMI_CONFIG_NEW_MODULE);
                osam_devp = osam_devp->next;
        }
        osam_devp = sam_dev_list_head;
        while (osam_devp) {
		if (osam_devp->mmi_datap->config_cb && (osam_devp != sam_devp)) {
			osam_devp->mmi_datap->config_cb(osam_devp->mmi_datap->cb_data, instance,
			    sam_devp->mmi_datap->instance_name, MMI_CONFIG_NEW_MODULE);
		}
                osam_devp = osam_devp->next;
        }
	fn(sam_devp->mmi_datap->cb_data, instance, sam_devp->mmi_datap->instance_name, MMI_CONFIG_NEW_MODULE);

	return mmi_true;
}


mmi_bool_t mmi_register_interface_cb(mmi_instance_t instance, mmi_interface_cb fn)
{
	mmi_data_t	*mmi_datap = (mmi_data_t *)instance;	
	sam_device_t 	*sam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_register_interface_cb: invalid instance = 0x%llx\n", instance);
		return mmi_false;
	}

	sam_devp->mmi_datap->interface_cb = fn;

	return mmi_true;
}


mmi_instance_t mmi_get_instance(const char * instance_name)
{
	sam_device_t *sam_devp = sam_find_device(instance_name);
	
	if (!sam_devp) {
		printf("mmi_get_instance: failed to get instance <%s>\n",
		       instance_name);
		return NULL;
	}

	return (mmi_instance_t) (sam_devp->mmi_datap);
}


void * mmi_get_instance_data(mmi_instance_t instance)
{
	mmi_data_t	*mmi_datap = (mmi_data_t *)instance;
	sam_device_t 	*sam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_get_instance_data: invalid instance = 0x%llx\n", instance);
		return NULL;
	}

	return (sam_devp->mmi_datap->cb_data);
}


int mmi_argc(mmi_instance_t instance)
{	
	mmi_data_t	*mmi_datap = (mmi_data_t *)(instance);	
	sam_device_t 	*sam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_argc: invalid instance = 0x%llx\n", instance);
		return (0);
	}

	return sam_devp->mmi_datap->argc;	
}


char *mmi_argv(mmi_instance_t instance, int index)
{
	sam_device_t 	*sam_devp;
	mmi_data_t	*mmi_datap = (mmi_data_t *)instance;	

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_argv: invalid instance = 0x%llx\n", instance);
		return NULL;
	}

	if (index < 0 || sam_devp->mmi_datap->argc <= index)
		return NULL;

	return sam_devp->mmi_datap->argv[index];	
}


void mmi_memread(uint64_t paddr, uint8_t *data, uint64_t size)
{	
	sam_mem_access(paddr, data, size, DA_Load);
}


void mmi_memwrite(uint64_t paddr, uint8_t *data, uint64_t size)
{	
	sam_mem_access(paddr, data, size, DA_Store);
}


int mmi_map_physio(uint64_t base, uint64_t size, void *obj, mmi_access access)
{
	mmi_iomap_t	*iomap;

	iomap = Xcalloc(1, mmi_iomap_t);
	iomap->obj = obj;
	iomap->access = access;
	iomap->base = base;
	iomap->size = size;
	iomap->end = base + size;

	sam_register_iomap(iomap);

	/*
	 * SAM MMI expects a zero value upon successful completion
	 */
	return mmi_false;
}


int mmi_interrupt_vector(int dest_cpuid, void *src, int src_iscpu, uint32_t vnum, int traptype)
{
	sam_device_t 	*sam_devp = NULL;
	mmi_data_t	*mmi_datap = (mmi_data_t *)src;	

	if (src) {
		sam_devp = sam_find_device(mmi_datap->instance_name);	
	}
	sam_internal_intr(dest_cpuid, sam_devp, src_iscpu, vnum, traptype);
	return true;
} 


int mmi_interrupt_packet(int dest_cpuid, void *src, int src_iscpu, uint64_t *idata)
{
        DBGDEV(lprintf(-1, "Warning: mmi_interrupt_packet is not supported\n"););

	sam_mondo_intr(dest_cpuid, src, src_iscpu, idata);

	return true;
}


void mmi_unmap_physio(uint64_t base, uint64_t size, void* obj)
{
	sam_unregister_iomap(base, size, obj);
}


void *mmi_get_interface(mmi_instance_t instance, const char * interface_name)
{
	mmi_data_t	*mmi_datap = (mmi_data_t *)instance;
	sam_device_t 	*sam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	

	if (!sam_devp) {
		printf("mmi_get_interface: invalid instance = 0x%llx\n", instance);
		return NULL;
	}

	if (sam_devp->mmi_datap->interface_cb) {
		return sam_devp->mmi_datap->interface_cb(sam_devp->mmi_datap->cb_data, interface_name);
	}
}

mmi_bool_t mmi_register_modinfo_cb(mmi_instance_t this_instance, mmi_modinfo_cb modinfo_fn)
{
        DBGDEV(lprintf(-1, "Warning: mmi_register_modinfo_cb not supported\n"););
	return mmi_true;
}

void mmi_register_start_stop(mmi_start_stop_cb start_action, mmi_start_stop_cb stop_action, void * userdata)
{
        DBGDEV(lprintf(-1, "Warning: mmi_register_start_stop not supported\n"););
}

mmi_bool_t mmi_register_dump_restore(void * userdata, mmi_dump_cb dump_fn, mmi_restore_cb restore_fn)
{
        DBGDEV(lprintf(-1, "Warning: mmi_register_dump_restore not supported\n"););
	return mmi_true;
}

void *mmi_register_cb_cycle(mmi_instance_t instance, mmi_event_cycle handler, uint64_t repeat)
{
        mmi_data_t      *mmi_datap = (mmi_data_t *)instance;
        sam_device_t    *sam_devp;
        sam_cycle_t     *sam_cycle;

        sam_devp = sam_find_device(mmi_datap->instance_name);
        if (!sam_devp) {
                printf("mmi_register_cb_cycle: invalid instance = 0x%llx\n", instance);
                return NULL;
        }
        sam_cycle = Xcalloc(1, sam_cycle_t);
        sam_cycle->handler = handler;
        sam_cycle->repeat = repeat;
        sam_cycle->enable = 1;
        sam_cycle->cb_data = sam_devp->mmi_datap->cb_data;
	sam_register_cb_cycle(sam_cycle);
	if (pthread_create(&sam_devp->tid, NULL, sam_start_dma, NULL)) {
                printf("mmi_register_cb_cycle: failed creating thread \n");
                return NULL;
	}
		
        return(sam_cycle);
}

mmi_bool_t   mmi_register_asi_cb_data (mmi_instance_t instance, void *cb_data)
{
	mmi_data_t	*mmi_datap = (mmi_data_t *)instance;	
	sam_device_t 	*sam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_register_asi_cb_data: invalid instance = 0x%llx\n",
		    instance);
		return mmi_false;
	}
	sam_devp->mmi_datap->asi_cb_data = cb_data;
	return mmi_true;
}

void mmi_register_asi_action (mmi_instance_t instance, uint32_t asi, mmi_ld_asi_action ld_handler, mmi_st_asi_action st_handler)
{
	mmi_data_t	*mmi_datap = (mmi_data_t *)(instance);	
	sam_device_t 	*sam_devp;

	sam_devp = sam_find_device(mmi_datap->instance_name);	
	if (!sam_devp) {
		printf("mmi_register_asi_action: invalid instance = 0x%llx\n",
		    instance);
		return;
	}
	if (ld_handler) {
		mmi_datap->asi_ld_handler = ld_handler;
	}
	if (st_handler) {
		mmi_datap->asi_st_handler = st_handler;
	}
	LIST_ADD_PTR (sam_asi_dev_list, sam_device_t, sam_devp);
}

void    mmi_unregister_cb_cycle(mmi_instance_t instance, void * intf)
{
	sam_unregister_cb_cycle(intf);
}

uint64_t mmi_get_cpufreq()
{
        DBGDEV(lprintf(-1, "Warning: mmi_get_cpufreq is not supported\n"););
        return (0);
}

int        mmi_disable_cb_cycle   (void * intf)
{
	sam_cycle_t	*cb_cycle;

	cb_cycle = sam_find_cb_cycle(intf);
	if (!cb_cycle) {
		printf("mmi_disable_cb_cycle: invalid intf = 0x%llx\n", intf);
		return false;
	}
	cb_cycle->enable = 0;	
        return (true);
}
int        mmi_enable_cb_cycle    (void * intf, uint64_t repeat)
{
	sam_cycle_t	*cb_cycle;

	cb_cycle = sam_find_cb_cycle(intf);
	if (!cb_cycle) {
		printf("mmi_enable_cb_cycle: invalid intf = 0x%llx\n", intf);
		return false;
	}
	cb_cycle->enable = 1;
        return (true);
}