projects / OpenSPARC-T2-SAM / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / hypervisor / src / common / src / res_guest.c
/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: res_guest.c
*
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
*
* - Do no alter or remove copyright notices
*
* - Redistribution and use of this software in source and binary forms, with
* or without modification, are permitted provided that the following
* conditions are met:
*
* - Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or maintenance of
* any nuclear facility.
*
* ========== Copyright Header End ============================================
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "@(#)res_guest.c 1.6 07/06/07 SMI"
#include <stdarg.h>
#include <sys/htypes.h>
#include <traps.h>
#include <cache.h>
#include <mmu.h>
#include <sun4v/asi.h>
#include <vdev_intr.h>
#include <ncs.h>
#include <cyclic.h>
#include <support.h>
#include <strand.h>
#include <vcpu.h>
#include <guest.h>
#include <pcie.h>
#include <vdev_ops.h>
#include <fpga.h>
#include <ldc.h>
#include <config.h>
#include <offsets.h>
#include <hvctl.h>
#include <md.h>
#include <abort.h>
#include <hypervisor.h>
#include <proto.h>
/*
* (re)-configuration code to handle HV guest resources
*/
static hvctl_status_t res_guest_parse_1(bin_md_t *mdp, md_element_t *guestnodep,
hvctl_res_error_t *fail_codep, int *fail_res_idp);
static void res_guest_commit_config(guest_t *guestp);
static void res_guest_commit_unconfig(guest_t *guestp);
static void res_guest_commit_modify(guest_t *guestp);
void config_a_guest_device_vino(guest_t *guestp, int ino, uint8_t type);
void unconfig_a_guest_device_vino(guest_t *guestp, int ino, uint8_t type);
void config_guest_virtual_device(guest_t *guestp, uint64_t cfg_handle);
void unconfig_guest_virtual_device(guest_t *guestp);
void config_guest_channel_device(guest_t *guestp, uint64_t cfg_handle);
void unconfig_guest_channel_device(guest_t *guestp);
void
init_guest(int i)
{
guest_t *gp;
hvctl_msg_t *asmsg;
int j;
gp = (guest_t *)config.guests;
gp = &(gp[i]);
/* clear out everything ! */
c_bzero(gp, sizeof (*gp));
gp->guestid = i;
gp->state = GUEST_STATE_UNCONFIGURED;
/* FIXME: remove the configp pointer */
gp->configp = &config;
gp->pip.vdev_cfghandle = INVALID_CFGHANDLE;
gp->pip.cdev_cfghandle = INVALID_CFGHANDLE;
for (j = 0; j < NUM_RA2PA_SEGMENTS; j++) {
init_ra2pa_segment(&(gp->ra2pa_segment[j]));
}
asmsg = (hvctl_msg_t *)gp->async_buf;
asmsg->hdr.op = HVctl_op_new_res_stat;
/* Everything else gets whacked when we (re)config the guest */
}
/*
* Guest MD support functions.
*/
void
res_guest_prep()
{
guest_t *gp;
int i;
gp = config.guests;
for (i = 0; i < NGUESTS; i++, gp++) {
gp->pip.res.flags = (gp->state == GUEST_STATE_UNCONFIGURED) ?
RESF_Noop : RESF_Unconfig;
}
}
hvctl_status_t
res_guest_parse(bin_md_t *mdp, hvctl_res_error_t *fail_codep,
md_element_t **failnodepp, int *fail_res_idp)
{
md_element_t *mdep;
uint64_t arc_token;
uint64_t node_token;
md_element_t *guest_nodep;
mdp = (bin_md_t *)config.parse_hvmd;
DBG(c_printf("\nGuest configuration:\n"));
mdep = md_find_node(mdp, NULL, MDNAME(guests));
if (mdep == NULL) {
DBG(c_printf("Missing guests node in HVMD\n"));
*failnodepp = NULL;
*fail_res_idp = 0;
return (HVctl_st_badmd);
}
arc_token = MDARC(MDNAME(fwd));
node_token = MDNODE(MDNAME(guest));
while (NULL != (mdep = md_find_node_by_arc(mdp, mdep, arc_token,
node_token, &guest_nodep))) {
hvctl_status_t status;
status = res_guest_parse_1(mdp, guest_nodep, fail_codep,
fail_res_idp);
if (status != HVctl_st_ok) {
*failnodepp = guest_nodep;
return (status);
}
}
return (HVctl_st_ok);
}
hvctl_status_t
res_guest_parse_1(bin_md_t *mdp, md_element_t *guest_nodep,
hvctl_res_error_t *fail_codep, int *fail_res_idp)
{
uint64_t resource_id, unbind, cfg_handle, base_memsize;
uint64_t arc_token, node_token;
guest_t *guestp;
md_element_t *mblock_nodep, *mdep, *base_mblock;
md_element_t *devices_nodep;
DBG(c_printf("res_guest_parse_1\n"));
DBG(md_dump_node(mdp, guest_nodep));
if (!md_node_get_val(mdp, guest_nodep, MDNAME(resource_id),
&resource_id)) {
DBG(c_printf("Missing resource_id in guest node\n"));
*fail_codep = HVctl_e_guest_missing_id;
*fail_res_idp = 0;
return (HVctl_st_badmd);
}
if (resource_id >= NGUESTS) {
DBG(c_printf("Invalid resource_id in guest node\n"));
*fail_codep = HVctl_e_guest_invalid_id;
*fail_res_idp = 0;
return (HVctl_st_badmd);
}
guestp = config.guests;
guestp = &(guestp[resource_id]);
DBG(c_printf("Guest 0x%x @ 0x%x\n", resource_id, (uint64_t)guestp));
*fail_res_idp = resource_id;
/*
* If guest is being unbound check that it is stopped.
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(unbind), &unbind))
unbind = 0;
if (unbind != 0) {
if (guestp->state != GUEST_STATE_STOPPED) {
*fail_codep = HVctl_e_guest_active;
return (HVctl_st_eillegal);
}
}
/*
* Now fill in basic properties for this guest ...
*
* FIXME: These should be available is the guest is
* live yes ?
*/
#define GET_PROPERTY(_g_val, _md_name) \
do { \
uint64_t _x; \
if (!md_node_get_val(mdp, guest_nodep, \
MDNAME(_md_name), &_x)) { \
DBG(c_printf("Missing "#_md_name" in " \
"guest node\n")); \
goto missing_prop; \
} \
_g_val = _x; \
} while (0)
/* A guest can't change ID, so just push it in */
GET_PROPERTY(guestp->guestid, resource_id);
GET_PROPERTY(guestp->pip.rom_base, rombase);
GET_PROPERTY(guestp->pip.rom_size, romsize);
GET_PROPERTY(guestp->pip.md_pa, mdpa);
#ifdef CONFIG_CN_UART
if (!md_node_get_val(mdp, guest_nodep, MDNAME(uartbase),
&guestp->pip.uartbase)) {
guestp->pip.uartbase = -1LL;
}
#endif
#ifdef CONFIG_DISK
if (!md_node_get_val(mdp, guest_nodep, MDNAME(diskpa),
&guestp->pip.diskpa)) {
guestp->pip.diskpa = -1LL;
}
#endif
/*
* Check for a reset-reason property
*
* FIXME: How sensible is this in an LDoms world?
* This is fine unless master start gets called somehow as
* part of the guest reconfig - so dont do that unless
* you really mean it !
*
* FIXME: Again - why re-do if guest configured already
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(reset_reason),
&guestp->pip.reset_reason)) {
guestp->pip.reset_reason = RESET_REASON_POR;
}
/*
* Determine guest realbase.
*/
guestp->pip.real_base = UINT64_MAX;
guestp->pip.real_limit = 0;
guestp->pip.mem_offset = 0;
arc_token = MDARC(MDNAME(fwd));
node_token = MDNODE(MDNAME(mblock));
base_mblock = NULL;
mdep = guest_nodep;
while (NULL != (mdep = md_find_node_by_arc(mdp, mdep,
arc_token, node_token, &mblock_nodep))) {
uint64_t realbase, membase;
if (!md_node_get_val(mdp, mblock_nodep, MDNAME(realbase),
&realbase)) {
DBG(c_printf("Missing realbase in mblock node\n"));
goto missing_prop;
}
/*
* Initialise guest real_base, real_limit and mem_offset
* Note: real_limit/mem_offset are required for N2 MMu HWTW
* FIXME: real_limit will not work for segmented memory
*/
if (realbase < guestp->pip.real_base) {
guestp->pip.real_base = realbase;
base_mblock = mblock_nodep;
if (!md_node_get_val(mdp, mblock_nodep, MDNAME(membase),
&membase)) {
membase = guestp->pip.real_base;
}
guestp->pip.mem_offset = membase -
guestp->pip.real_base;
}
if (!md_node_get_val(mdp, base_mblock, MDNAME(memsize),
&base_memsize)) {
base_memsize = 0;
}
if (guestp->pip.real_limit < (realbase + base_memsize))
guestp->pip.real_limit = (realbase + base_memsize);
}
if (base_mblock == NULL) {
DBG(c_printf("Missing mblock node in guest node\n"));
goto missing_prop;
}
if (!md_node_get_val(mdp, base_mblock, MDNAME(memsize),
&base_memsize)) {
DBG(c_printf("Missing memsize in mblock node\n"));
goto missing_prop;
}
if (guestp->pip.rom_size > base_memsize) {
*fail_codep = HVctl_e_guest_base_mblock_too_small;
return (HVctl_st_badmd);
}
#undef GET_PROPERTY
/*
* Look for the "perfctraccess" property. This property
* must be present and set to a non-zero value for the
* guest to have access to the JBUS/DRAM perf counters
*/
/*
* FIXME; These probably need to be their own resource !
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(perfctraccess),
&guestp->pip.perfreg_accessible)) {
guestp->pip.perfreg_accessible = 0;
}
/*
* Look for "diagpriv" property. This property enables
* the guest to execute arbitrary hyperprivileged code.
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(diagpriv),
&guestp->pip.diagpriv)) {
#ifdef CONFIG_BRINGUP
guestp->pip.diagpriv = -1;
#else
guestp->pip.diagpriv = 0;
#endif
}
/*
* Look for "rngctlaccessible" property. This property enables
* the guest to access the N2 RNG if available.
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(rngctlaccessible),
&guestp->rng_ctl_accessible)) {
guestp->rng_ctl_accessible = 0;
}
/*
* Look for "perfctrhtaccess" property. This property enables
* the guest to access the N2 hyper-privileged events if available.
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(perfctrhtaccess),
&guestp->perfreght_accessible)) {
guestp->perfreght_accessible = 0;
}
/*
* Per guest TOD offset ...
* FIXME:
* This property doesn't trigger a modify op if the guest is already
* live. So changes are only visible after a reconfig when the
* domain is stopped.
*/
if (!md_node_get_val(mdp, guest_nodep, MDNAME(todoffset),
&guestp->pip.tod_offset)) {
guestp->pip.tod_offset = 0;
}
/*
* Now look for the guest devices ...
* FIXME: Needs updating so devices can be DR'd in.
*/
if (NULL != md_find_node_by_arc(mdp, guest_nodep, MDARC(MDNAME(fwd)),
MDNODE(MDNAME(virtual_devices)), &devices_nodep)) {
if (!md_node_get_val(mdp, devices_nodep, MDNAME(cfghandle),
&cfg_handle)) {
DBG(c_printf("Missing cfg_handle in device node\n"));
goto missing_prop;
}
DBG(md_dump_node(mdp, devices_nodep));
guestp->pip.vdev_cfghandle = cfg_handle;
}
if (NULL != md_find_node_by_arc(mdp, guest_nodep, MDARC(MDNAME(fwd)),
MDNODE(MDNAME(channel_devices)), &devices_nodep)) {
if (!md_node_get_val(mdp, devices_nodep, MDNAME(cfghandle),
&cfg_handle)) {
DBG(c_printf("Missing cfg_handle in device node\n"));
goto missing_prop;
}
DBG(md_dump_node(mdp, devices_nodep));
guestp->pip.cdev_cfghandle = cfg_handle;
}
DBG(c_printf("End of guest parse 1\n"));
/*
* Now we go and figureout what we need to do to the
* guest to update or configure its state.
*
* Memory was dealt with earlier.
*/
if (guestp->state == GUEST_STATE_UNCONFIGURED) {
DBG(c_printf("\t\tElected to config guest\n"));
guestp->pip.res.flags = RESF_Config;
} else {
/*
* what kind of a re-configure is this ?
* Since guest structures dont really bind to anything, stuff
* binds to them, this is a modify IMHO, but only if stuff
* actually got modified ..
*
* Note: it is implicit in this test that an MD update
* *requires* that the mdpa changes. Since the prospect of
* and MD update inplace while the guest is running is
* frightening and likely to break the guest this is a
* suffient condion. If Zeus updates the MD in place we
* have really big problems on our hands .. not sure we
* can detect this easily.
*
* We ignore dynamic updates of uartbase and diskpa
* since they should be detected above and denied if the
* the domain is running.
*/
if (guestp->pip.rom_base != guestp->rom_base ||
guestp->pip.rom_size != guestp->rom_size ||
guestp->pip.md_pa != guestp->md_pa ||
guestp->pip.reset_reason != guestp->reset_reason ||
guestp->pip.perfreg_accessible !=
guestp->perfreg_accessible ||
guestp->pip.diagpriv != guestp->diagpriv ||
((guestp->pip.vdev_cfghandle != INVALID_CFGHANDLE) &&
(guestp->pip.vdev_cfghandle != guestp->vdev_cfghandle)) ||
((guestp->pip.cdev_cfghandle != INVALID_CFGHANDLE) &&
(guestp->pip.cdev_cfghandle != guestp->cdev_cfghandle)) ||
guestp->pip.tod_offset != guestp->tod_offset) {
DBG(c_printf("\t\tElected to modify guest\n"));
guestp->pip.res.flags = RESF_Modify;
} else {
guestp->pip.res.flags = RESF_Noop;
DBG(c_printf("\t\tElected to ignore guest\n"));
}
}
return (HVctl_st_ok);
missing_prop:;
*fail_codep = HVctl_e_guest_missing_property;
return (HVctl_st_badmd);
}
/*
* Simple suite of checks based on the flags for this resource
*/
hvctl_status_t
res_guest_postparse(hvctl_res_error_t *fail_codep, int *fail_res_idp)
{
guest_t *gp;
int i;
gp = config.guests;
for (i = 0; i < NGUESTS; i++, gp++) {
switch (gp->pip.res.flags) {
case RESF_Noop:
break;
case RESF_Unconfig:
if (gp->state != GUEST_STATE_STOPPED) {
*fail_codep = HVctl_e_guest_active;
goto fail;
}
break;
case RESF_Config:
break;
case RESF_Rebind:
ASSERT(0); /* not supported */
break;
case RESF_Modify:
break;
default:
ASSERT(0);
}
}
return (HVctl_st_ok);
fail:
*fail_res_idp = i;
return (HVctl_st_badmd);
}
void
res_guest_commit(int flag)
{
guest_t *gp;
int i;
gp = config.guests;
for (i = 0; i < NGUESTS; i++, gp++) {
/* if not this ops turn move on */
if (gp->pip.res.flags != flag) continue;
switch (gp->pip.res.flags) {
case RESF_Noop:
DBG(c_printf("guest 0x%x : noop\n", i));
break;
case RESF_Unconfig:
res_guest_commit_unconfig(gp);
break;
case RESF_Config:
res_guest_commit_config(gp);
break;
case RESF_Rebind:
DBG(c_printf("guest 0x%x : rebind\n", i));
ASSERT(0); /* not supported */
break;
case RESF_Modify:
res_guest_commit_modify(gp);
break;
default:
ASSERT(0);
}
gp->pip.res.flags = RESF_Noop; /* cleanup */
}
}
void
reset_guest_state(guest_t *guestp)
{
ASSERT(guestp->state == GUEST_STATE_STOPPED);
reset_api_hcall_table(guestp);
DBG(c_printf("\tguest hcall table @ 0x%x\n", guestp->hcall_table));
reset_guest_perm_mappings(guestp);
reset_guest_ldc_mapins(guestp);
}
/*
* reconfigure common path - also shared with commit
*/
void
res_guest_commit_modify(guest_t *guestp)
{
DBG(c_printf("modify guest 0x%x\n", guestp->guestid));
ASSERT(guestp->state != GUEST_STATE_UNCONFIGURED);
guestp->rom_base = guestp->pip.rom_base;
guestp->rom_size = guestp->pip.rom_size;
guestp->real_base = guestp->pip.real_base;
guestp->real_limit = guestp->pip.real_limit;
guestp->mem_offset = guestp->pip.mem_offset;
guestp->md_pa = guestp->pip.md_pa;
/*
* Compute the Guests MD size
*/
config_guest_md(guestp);
#ifdef CONFIG_DISK
guestp->disk.size = 0LL;
guestp->disk.pa = guestp->pip.diskpa;
#endif
#ifdef T1_FPGA_SNET
guestp->snet.ino = guestp->pip.snet_ino;
guestp->snet.pa = guestp->pip.snet_pa;
#endif
/*
* Look for the "perfctraccess" property. This property
* must be present and set to a non-zero value for the
* guest to have access to the JBUS/DRAM perf counters
*/
guestp->perfreg_accessible = guestp->pip.perfreg_accessible;
/*
* Look for "diagpriv" property. This property enables
* the guest to execute arbitrary hyperprivileged code.
*/
guestp->diagpriv = guestp->pip.diagpriv;
/*
* Assume entry point is at base of real memory
*/
guestp->entry = guestp->real_base;
guestp->reset_reason = guestp->pip.reset_reason;
/*
* Modify devops.
*/
unconfig_guest_virtual_device(guestp);
unconfig_guest_channel_device(guestp);
config_guest_virtual_device(guestp, guestp->pip.vdev_cfghandle);
config_guest_channel_device(guestp, guestp->pip.cdev_cfghandle);
}
void
res_guest_commit_config(guest_t *guestp)
{
int x;
DBG(c_printf("commit config guest 0x%x : config\n", guestp->guestid));
ASSERT(guestp->state == GUEST_STATE_UNCONFIGURED);
/*
* Now fill in basic properties for this guest ...
*
* FIXME: These should be available if the guest is
* live yes ?
*/
guestp->ldc_mapin_basera = LDC_MAPIN_BASERA;
guestp->ldc_mapin_size = LDC_MAPIN_RASIZE;
guestp->state = GUEST_STATE_STOPPED;
res_guest_commit_modify(guestp);
/*
* TOD is configured once at the begining of time.
* we don't allow external modifies as that would warp
* the time value each time the guest gets and update
* after the guest had modified itself.
*/
guestp->tod_offset = guestp->pip.tod_offset;
/*
* At the time of first guest config mark all INO2LDC
* mappings as NULL
*/
for (x = 0; x < MAX_LDC_INOS; x++) {
guestp->ldc_ino2endpoint[x].endpointp = NULL;
guestp->ldc_ino2endpoint[x].mapregp = NULL;
}
/*
* FIXME: Should we really care to track this - why not
* just use the constant; MAX_LDC_CHANNELS
*/
guestp->ldc_max_channel_idx = MAX_LDC_CHANNELS;
/* we might check that all the LDC endpoints are !live */
/* kind of pointless since we are moving them to a global */
/*
* clear out the devops table.
*/
for (int y = 0; y < NVINOS; y++) {
guestp->vino2inst.vino[y] = DEVOPS_RESERVED;
}
for (int x = 0; x < NDEVIDS; x++) {
guestp->dev2inst[x] = DEVOPS_RESERVED;
}
config_guest_virtual_device(guestp, guestp->pip.vdev_cfghandle);
config_guest_channel_device(guestp, guestp->pip.cdev_cfghandle);
/* until we boot it ... */
ASSERT(guestp->state == GUEST_STATE_STOPPED);
reset_guest_state(guestp);
DBG(c_printf("End of guest setup\n"));
}
void
res_guest_commit_unconfig(guest_t *guestp)
{
/* preserve the guest ID ... err thats about it */
DBG(c_printf("guest 0x%x : unconfig\n", guestp->guestid));
ASSERT(guestp->state == GUEST_STATE_STOPPED);
unconfig_guest_virtual_device(guestp);
unconfig_guest_channel_device(guestp);
/*
* clear out the devops table.
*/
for (int y = 0; y < NVINOS; y++) {
guestp->vino2inst.vino[y] = DEVOPS_RESERVED;
}
for (int x = 0; x < NDEVIDS; x++) {
guestp->dev2inst[x] = DEVOPS_RESERVED;
}
init_guest(guestp->guestid);
/* Just incase we add more phases */
guestp->pip.res.flags = RESF_Noop;
}
void
config_a_guest_device_vino(guest_t *guestp, int ino, uint8_t type)
{
uint64_t cfg_handle = INVALID_CFGHANDLE;
switch (type) {
case DEVOPS_VDEV:
cfg_handle = guestp->vdev_cfghandle;
break;
case DEVOPS_CDEV:
cfg_handle = guestp->cdev_cfghandle;
break;
default:
break;
};
DBG(c_printf("guest device:\n\tcfg handle 0x%x 0x%x\n",
cfg_handle, ino));
ASSERT(cfg_handle != INVALID_CFGHANDLE);
guestp->vino2inst.vino[cfg_handle + ino] = type;
}
void
unconfig_a_guest_device_vino(guest_t *guestp, int ino, uint8_t type)
{
uint64_t cfg_handle = INVALID_CFGHANDLE;
switch (type) {
case DEVOPS_VDEV:
cfg_handle = guestp->vdev_cfghandle;
break;
case DEVOPS_CDEV:
cfg_handle = guestp->cdev_cfghandle;
break;
default:
break;
};
ASSERT(cfg_handle != INVALID_CFGHANDLE);
guestp->vino2inst.vino[cfg_handle + ino] = DEVOPS_RESERVED;
}
void
config_guest_virtual_device(guest_t *guestp, uint64_t cfg_handle)
{
uint8_t devid;
ASSERT(cfg_handle != INVALID_CFGHANDLE);
if (cfg_handle == INVALID_CFGHANDLE)
return;
guestp->vdev_cfghandle = cfg_handle;
devid = guestp->vdev_cfghandle >> DEVCFGPA_SHIFT;
guestp->dev2inst[devid] = DEVOPS_VDEV;
}
void
unconfig_guest_virtual_device(guest_t *guestp)
{
uint8_t devid;
devid = guestp->vdev_cfghandle >> DEVCFGPA_SHIFT;
guestp->dev2inst[devid] = DEVOPS_RESERVED;
guestp->vdev_cfghandle = INVALID_CFGHANDLE;
}
void
config_guest_channel_device(guest_t *guestp, uint64_t cfg_handle)
{
uint8_t devid, edevid;
int x;
ASSERT(cfg_handle != INVALID_CFGHANDLE);
if (cfg_handle == INVALID_CFGHANDLE)
return;
guestp->cdev_cfghandle = cfg_handle;
devid = guestp->cdev_cfghandle >> DEVCFGPA_SHIFT;
edevid = (guestp->cdev_cfghandle + MAX_LDC_INOS) >> DEVCFGPA_SHIFT;
for (x = devid; x < edevid; x++)
guestp->dev2inst[x] = DEVOPS_CDEV;
}
void
unconfig_guest_channel_device(guest_t *guestp)
{
uint8_t devid, edevid;
int x;
devid = guestp->cdev_cfghandle >> DEVCFGPA_SHIFT;
edevid = (guestp->cdev_cfghandle + MAX_LDC_INOS) >> DEVCFGPA_SHIFT;
for (x = devid; x < edevid; x++)
guestp->dev2inst[x] = DEVOPS_RESERVED;
guestp->cdev_cfghandle = INVALID_CFGHANDLE;
}
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.