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_ldc.c
/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: res_ldc.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_ldc.c 1.7 07/06/07 SMI"
#include <stdarg.h>
#include <sys/htypes.h>
#include <traps.h>
#include <mmu.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>
#include <debug.h>
/*
* (re)-configuration code to handle HV LDC resources
*/
static void res_ldc_commit_config(guest_t *gp, ldc_endpoint_t *ldcp);
static void res_ldc_commit_unconfig(guest_t *gp, ldc_endpoint_t *ldcp);
static hvctl_status_t res_ldc_parse_1(bin_md_t *mdp, md_element_t *guest_nodep,
hvctl_res_error_t *fail_codep,
md_element_t **failnodepp, int *fail_res_idp);
static hvctl_status_t res_ldc_parse_2(bin_md_t *mdp, int guest_id,
md_element_t *ldce_nodep,
hvctl_res_error_t *fail_codep, int *fail_res_idp);
static void res_hv_ldc_commit_config(int ch_id);
static void res_hv_ldc_commit_unconfig(int ch_id);
static hvctl_status_t res_hv_ldc_parse_1(bin_md_t *mdp,
md_element_t *hvldc_nodep,
hvctl_res_error_t *fail_codep, int *fail_res_idp);
/*
* LDC support functions
*
* FIXME: This changes when LDC endpoints have their own
* global IDs. This means for now the uniq ID for an endpoints
* is the tuple: (guest_id, channel_id)
*
* We'll fix this later...
*/
void
res_ldc_prep()
{
guest_t *gp;
int i;
gp = config.guests;
for (i = 0; i < NGUESTS; i++, gp++) {
int j;
/*
* If the guest is already unconfigured, then
* we've nothing to potentially unconfigure
* So we could optimise by skipping all the
* channels, but it's pointless because the
* per-guest endpoints are going away.
* So for now we brute force all endpoints.
*/
for (j = 0; j < MAX_LDC_CHANNELS; j++) {
ldc_endpoint_t *ep;
ep = &(gp->ldc_endpoint[j]);
/* unconfigd guest cannot have live channel */
ASSERT(!(gp->state == GUEST_STATE_UNCONFIGURED &&
ep->is_live));
/* if live potentially unconfig it */
ep->pip.res.flags = ep->is_live ?
RESF_Unconfig : RESF_Noop;
}
}
}
hvctl_status_t
res_ldc_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;
hvctl_status_t status;
mdp = (bin_md_t *)config.parse_hvmd;
DBGL(c_printf("\nLDC 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);
}
/*
* FIXME: this multistep process goes away once the top-level
* ldc-endpoints aggregator includes all endpoints.
*/
arc_token = MDARC(MDNAME(fwd));
node_token = MDNODE(MDNAME(guest));
status = HVctl_st_ok;
while (status == HVctl_st_ok &&
NULL != (mdep = md_find_node_by_arc(mdp, mdep, arc_token,
node_token, &guest_nodep))) {
status = res_ldc_parse_1(mdp, guest_nodep, fail_codep,
failnodepp, fail_res_idp);
}
return (status);
}
hvctl_status_t
res_ldc_parse_1(bin_md_t *mdp, md_element_t *guest_nodep,
hvctl_res_error_t *fail_codep,
md_element_t **failnodepp, int *fail_res_idp)
{
md_element_t *elemp;
md_element_t *ldce_nodep;
int dummy;
uint64_t guest_id;
uint64_t arc_token;
uint64_t node_token;
/*
* by now we know its here because we passed the guest parse
* which is higher priority than this parse function.
*/
dummy = md_node_get_val(mdp, guest_nodep, MDNAME(resource_id),
&guest_id);
ASSERT(dummy);
#if defined(lint)
dummy = dummy;
#endif
DBGL(c_printf("\tGuest 0x%x for ldcs:\n", guest_id));
arc_token = MDARC(MDNAME(fwd));
node_token = MDNODE(MDNAME(ldc_endpoint));
/*
* Spin through the "ldc_endpoint" arcs in the
* ldc_endpoints node and config each endpoint !
* FIXME; what if already configured !
*/
elemp = guest_nodep;
while (NULL != (elemp = md_find_node_by_arc(mdp, elemp, arc_token,
node_token, &ldce_nodep))) {
hvctl_status_t status;
status = res_ldc_parse_2(mdp, guest_id, ldce_nodep,
fail_codep, fail_res_idp);
if (status != HVctl_st_ok) {
*failnodepp = ldce_nodep;
return (HVctl_st_badmd);
}
}
return (HVctl_st_ok);
}
hvctl_status_t
res_ldc_parse_2(bin_md_t *mdp, int guest_id, md_element_t *ldce_nodep,
hvctl_res_error_t *fail_codep, int *fail_res_idp)
{
uint64_t endpt_id;
ldc_endpoint_t *ldc_ep;
uint64_t target_type;
uint64_t target_channel;
uint64_t tx_ino;
uint64_t rx_ino;
guest_t *guestp;
bool_t check_guest;
guest_t *target_guestp;
uint64_t pvt_svc;
guestp = config.guests;
guestp = &(guestp[guest_id]);
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(channel),
&endpt_id)) {
DBGL(c_printf("Missing channel (endpoint number) in"
" ldc_endpoint node\n"));
*fail_res_idp = 0;
miss_prop:
*fail_codep = HVctl_e_ldc_missing_prop;
return (HVctl_st_badmd);
}
if (endpt_id >= MAX_LDC_CHANNELS) {
DBGL(c_printf("Illegal channel (endpoint number) in"
" ldc_endpoint node\n"));
*fail_res_idp = 0;
ill_prop:
*fail_codep = HVctl_e_ldc_illegal_prop;
return (HVctl_st_badmd);
}
DBGL(c_printf("\t\tGuest 0x%x endpoint 0x%x\n", guest_id, endpt_id));
ldc_ep = &(guestp->ldc_endpoint[endpt_id]);
ldc_ep->pip.channel = endpt_id;
*fail_res_idp = endpt_id;
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(target_type),
&target_type)) {
DBGL(c_printf("Missing target_type in ldc_endpoint node\n"));
goto miss_prop;
}
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(target_channel),
&target_channel)) {
DBGL(c_printf("Missing target_channel in "
"ldc_endpoint node\n"));
goto ill_prop;
}
ldc_ep->pip.target_type = target_type;
ldc_ep->pip.target_channel = target_channel;
check_guest = false; /* a flag for later change check */
switch (target_type) {
uint64_t target_guest_id;
case LDC_HV_ENDPOINT:
/* nothing more to do */
DBGL(c_printf("\t\tConnected to HV endpoint 0x%x\n",
target_channel));
break;
case LDC_GUEST_ENDPOINT:
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(target_guest),
&target_guest_id)) {
DBGL(c_printf("Missing target_guest in "
"ldc_endpoint node\n"));
goto miss_prop;
}
DBGL(c_printf("\t\t\tConnected to guest 0x%x endpoint 0x%x\n",
target_guest_id, target_channel));
/* This goes away with single target ID */
target_guestp = config.guests;
target_guestp = &(target_guestp[target_guest_id]);
ldc_ep->pip.target_guestp = target_guestp;
check_guest = true;
break;
#ifdef CONFIG_FPGA /* { */
case LDC_SP_ENDPOINT:
DBGL(c_printf("\t\t\tConnected to SP endpoint 0x%x\n",
target_channel));
break;
#endif /* } */
default:
DBGL(c_printf("Invalid target_type in ldc-endpoint node\n"));
goto ill_prop;
}
if (md_node_get_val(mdp, ldce_nodep, MDNAME(private_svc), &pvt_svc)) {
ldc_ep->pip.is_private = 1;
ldc_ep->pip.svc_id = pvt_svc;
switch (ldc_ep->pip.svc_id) {
case LDC_CONSOLE_SVC:
if (target_type == LDC_HV_ENDPOINT) {
DBG(c_printf("Console cannot use HV "
"endpoint\n"));
goto ill_prop;
}
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(rx_ino),
&rx_ino)) {
DBG(c_printf("Missing rx_ino in ldc_endpoint "
"node\n"));
goto miss_prop;
}
ldc_ep->pip.tx_ino = ldc_ep->pip.rx_ino = tx_ino =
rx_ino;
break;
default:
DBG(c_printf("Invalid private service type\n"));
goto ill_prop;
}
} else {
ldc_ep->pip.is_private = 0;
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(tx_ino),
&tx_ino)) {
DBGL(c_printf("Missing tx-ino in ldc_endpoint node\n"));
goto miss_prop;
}
if (!md_node_get_val(mdp, ldce_nodep, MDNAME(rx_ino),
&rx_ino)) {
DBGL(c_printf("Missing rx-ino in ldc_endpoint node\n"));
goto miss_prop;
}
DBGL(c_printf("\t\t\t\ttx-ino 0x%x rx-ino 0x%x\n", tx_ino,
rx_ino));
ldc_ep->pip.tx_ino = tx_ino;
ldc_ep->pip.rx_ino = rx_ino;
}
/*
* OK figure out if something changed, or if this is a
* noop or a config.
*/
if (!ldc_ep->is_live) {
ldc_ep->pip.res.flags = RESF_Config;
DBGL(c_printf("\t\tElected to config LDC endpoint\n"));
} else
if (ldc_ep->target_type != target_type ||
ldc_ep->target_channel != target_channel ||
(!(ldc_ep->pip.is_private) && (ldc_ep->tx_mapreg.ino != tx_ino)) ||
(!(ldc_ep->pip.is_private) && (ldc_ep->rx_mapreg.ino != rx_ino)) ||
(check_guest && (ldc_ep->target_guest != target_guestp))) {
#define E(_e) DBGL(if (_e) c_printf("\t\t\t%s\n", #_e));
E(ldc_ep->target_type != target_type);
E(ldc_ep->target_channel != target_channel);
E(ldc_ep->tx_mapreg.ino != tx_ino);
E(ldc_ep->rx_mapreg.ino != rx_ino);
E((check_guest && (ldc_ep->target_guest != target_guestp)));
#undef E
DBGL(c_printf("\t\tModify not supported on LDC channels\n"));
*fail_codep = HVctl_e_ldc_rebind_na;
return (HVctl_st_badmd);
} else {
DBGL(c_printf("\t\tElected to ignore LDC endpoint\n"));
ldc_ep->pip.res.flags = RESF_Noop;
}
return (HVctl_st_ok);
}
hvctl_status_t
res_ldc_postparse(hvctl_res_error_t *res_error, int *fail_res_id)
{
return (HVctl_st_ok);
}
void
res_ldc_commit(int flag)
{
guest_t *gp;
int i;
gp = config.guests;
for (i = 0; i < NGUESTS; i++, gp++) {
int j;
/*
* FIXME:again can optimise around guest configdness
* and to skip the unsupported flags
*/
for (j = 0; j < MAX_LDC_CHANNELS; j++) {
ldc_endpoint_t *ep;
ep = &(gp->ldc_endpoint[j]);
/* if not this ops turn move on */
if (ep->pip.res.flags != flag) continue;
switch (ep->pip.res.flags) {
case RESF_Noop:
DBG(c_printf("guest 0x%x ldc 0x%x : noop\n",
gp->guestid, j));
ASSERT(0); /* not supported */
break;
case RESF_Unconfig:
res_ldc_commit_unconfig(gp, ep);
break;
case RESF_Config:
res_ldc_commit_config(gp, ep);
break;
case RESF_Rebind:
DBG(c_printf("guest 0x%x ldc 0x%x : rebind\n",
gp->guestid, j));
ASSERT(0); /* not supported */
break;
case RESF_Modify:
DBG(c_printf("guest 0x%x ldc 0x%x : rebind\n",
gp->guestid, j));
ASSERT(0); /* not supported */
break;
default:
ASSERT(0);
}
ep->pip.res.flags = RESF_Noop; /* cleanup */
}
}
}
void
reset_ldc_endpoint(ldc_endpoint_t *ldc_ep)
{
ldc_ep->tx_qbase_ra = 0;
ldc_ep->tx_qhead = 0;
ldc_ep->tx_qtail = 0;
ldc_ep->rx_qbase_ra = 0;
ldc_ep->rx_qhead = 0;
ldc_ep->rx_qtail = 0;
}
void
res_ldc_commit_config(guest_t *guestp, ldc_endpoint_t *ldc_ep)
{
int tx_ino;
int rx_ino;
DBG(c_printf("res_ldc_commit_config guest 0x%x ldce 0x%x\n",
guestp->guestid, ldc_ep - guestp->ldc_endpoint));
ldc_ep->target_type = ldc_ep->pip.target_type;
ldc_ep->target_channel = ldc_ep->pip.target_channel;
ldc_ep->is_private = ldc_ep->pip.is_private;
ldc_ep->svc_id = ldc_ep->pip.svc_id;
switch (ldc_ep->target_type) {
case LDC_HV_ENDPOINT:
DBG(c_printf("\tHV"));
break;
case LDC_GUEST_ENDPOINT:
ldc_ep->target_guest = ldc_ep->pip.target_guestp;
DBG(c_printf("\tguest 0x%x", ldc_ep->target_guest->guestid));
break;
case LDC_SP_ENDPOINT:
DBG(c_printf("\tSP"));
break;
default:
ASSERT(0);
}
DBG(c_printf(" endpoint 0x%x\n", ldc_ep->target_channel));
if (!ldc_ep->is_private) {
tx_ino = ldc_ep->pip.tx_ino;
ldc_ep->tx_mapreg.ino = tx_ino;
guestp->ldc_ino2endpoint[tx_ino].endpointp = ldc_ep;
guestp->ldc_ino2endpoint[tx_ino].mapregp = &(ldc_ep->tx_mapreg);
ASSERT(guestp->cdev_cfghandle != 0);
config_a_guest_device_vino(guestp, tx_ino, DEVOPS_CDEV);
rx_ino = ldc_ep->pip.rx_ino;
ldc_ep->rx_mapreg.ino = rx_ino;
guestp->ldc_ino2endpoint[rx_ino].endpointp = ldc_ep;
guestp->ldc_ino2endpoint[rx_ino].mapregp = &(ldc_ep->rx_mapreg);
config_a_guest_device_vino(guestp, rx_ino, DEVOPS_CDEV);
ldc_ep->tx_qbase_pa = 0;
ldc_ep->tx_qsize = 0;
ldc_ep->rx_qbase_pa = 0;
ldc_ep->rx_qsize = 0;
ldc_ep->rx_updated = 1;
}
reset_ldc_endpoint(ldc_ep);
ldc_ep->is_live = true;
}
void
res_ldc_commit_unconfig(guest_t *guestp, ldc_endpoint_t *ldc_ep)
{
int tx_ino;
int rx_ino;
DBG(c_printf("res_ldc_commit_unconfig guest 0x%x ldce 0x%x\n",
guestp->guestid, ldc_ep - guestp->ldc_endpoint));
ASSERT(ldc_ep->is_live);
/*
* Undo the interrupt back maps
*/
if (ldc_ep->is_private == 0) {
tx_ino = ldc_ep->tx_mapreg.ino;
guestp->ldc_ino2endpoint[tx_ino].endpointp = NULL;
guestp->ldc_ino2endpoint[tx_ino].mapregp = NULL;
unconfig_a_guest_device_vino(guestp, tx_ino, DEVOPS_CDEV);
rx_ino = ldc_ep->rx_mapreg.ino;
guestp->ldc_ino2endpoint[rx_ino].endpointp = NULL;
guestp->ldc_ino2endpoint[rx_ino].mapregp = NULL;
unconfig_a_guest_device_vino(guestp, rx_ino, DEVOPS_CDEV);
}
/* This is about it for an unconfigure */
ldc_ep->is_live = false;
}
/*
* Now the HV LDCs ... which should be vanishing into
* becomming regular LDCs sometime in the very newar future.
*/
void
res_hv_ldc_prep()
{
int i;
for (i = 0; i < MAX_HV_LDC_CHANNELS; i++) {
ldc_endpoint_t *hvep;
hvep = config.hv_ldcs;
hvep = &(hvep[i]);
hvep->pip.res.flags = (!hvep->is_live) ?
RESF_Noop : RESF_Unconfig;
}
}
hvctl_status_t
res_hv_ldc_parse(bin_md_t *mdp, hvctl_res_error_t *fail_codep,
md_element_t **failnodepp, int *fail_res_idp)
{
md_element_t *mdep, *hvldc_nodep, *rootnodep;
uint64_t arc_token;
uint64_t name_token;
mdp = (bin_md_t *)config.parse_hvmd;
DBGHL(c_printf("HV LDC configuration:\n"));
/*
* First find the root node
*/
rootnodep = md_find_node(mdp, NULL, MDNAME(root));
if (rootnodep == NULL) {
DBGHL(c_printf("Missing root node in HVMD\n"));
*failnodepp = NULL;
*fail_res_idp = 0;
return (HVctl_st_badmd);
}
/* if no ldc_endpoints node under root nothing to parse */
if (md_find_node_by_arc(mdp, rootnodep, MDARC(MDNAME(fwd)),
MDNODE(MDNAME(ldc_endpoints)), &mdep) == NULL) {
return (HVctl_st_ok);
}
arc_token = MDARC(MDNAME(fwd));
name_token = MDNODE(MDNAME(ldc_endpoint));
while (NULL != (mdep = md_find_node_by_arc(mdp, mdep, arc_token,
name_token, &hvldc_nodep))) {
hvctl_status_t status;
status = res_hv_ldc_parse_1(mdp, hvldc_nodep, fail_codep,
fail_res_idp);
if (status != HVctl_st_ok) {
*failnodepp = hvldc_nodep;
return (status);
}
}
return (HVctl_st_ok);
}
hvctl_status_t
res_hv_ldc_parse_1(bin_md_t *mdp, md_element_t *hvldc_nodep,
hvctl_res_error_t *fail_codep, int *fail_res_idp)
{
uint64_t chid;
uint64_t type;
uint64_t guestid;
uint64_t svc_id;
uint64_t tchan_id;
ldc_endpoint_t *hvep;
if (!md_node_get_val(mdp, hvldc_nodep, MDNAME(svc_id), &svc_id)) {
/* Not a HV endpoint - skip it */
return (HVctl_st_ok);
}
DBGHL(c_printf("Parse HV LDC endpoints\n"));
if (!md_node_get_val(mdp, hvldc_nodep, MDNAME(channel), &chid)) {
DBGHL(c_printf("Missing channel id in HV LDC node\n"));
*fail_res_idp = 0;
miss_prop:
*fail_codep = HVctl_e_hv_ldc_missing_prop;
return (HVctl_st_badmd);
}
if (chid >= MAX_HV_LDC_CHANNELS) {
DBGHL(c_printf("Invalid channel id 0x%x in HV LDC node\n",
chid));
*fail_res_idp = 0;
ill_prop:
*fail_codep = HVctl_e_hv_ldc_illegal_prop;
return (HVctl_st_badmd);
}
DBGHL(c_printf("\tHV endpoint 0x%x :", chid));
if (!md_node_get_val(mdp, hvldc_nodep, MDNAME(target_type), &type)) {
DBG(c_printf("Missing target_type in HV LDC node\n"));
goto miss_prop;
}
hvep = config.hv_ldcs;
hvep = &(hvep[chid]);
*fail_res_idp = chid;
hvep->pip.target_type = type;
switch (type) {
case LDC_GUEST_ENDPOINT: /* guest<->HV LDC */
if (!md_node_get_val(mdp, hvldc_nodep, MDNAME(target_guest),
&guestid)) {
DBGHL(c_printf("Missing target_guest in HV "
"LDC node\n"));
goto miss_prop;
}
/* point to target guest */
hvep->pip.target_guestp =
&(((guest_t *)config.guests)[guestid]);
DBGHL(c_printf("\tConnected to endpoint in guest 0x%x\n",
guestid));
break;
case LDC_SP_ENDPOINT: /* HV<->SP LDC */
DBGHL(c_printf("\tConnected to SP endpoint\n"));
break;
default:
DBGHL(c_printf("Illegal target_type 0x%x\n", type));
goto ill_prop;
}
if (!md_node_get_val(mdp, hvldc_nodep, MDNAME(target_channel),
&tchan_id)) {
DBGHL(c_printf("Missing target channel id in HV LDC node\n"));
goto miss_prop;
}
if (tchan_id >= MAX_LDC_CHANNELS) {
DBGHL(c_printf("Invalid target channel id 0x%x in HV "
"LDC node\n", tchan_id));
goto ill_prop;
}
DBGHL(c_printf("\t\tTarget channel = 0x%x ", tchan_id));
hvep->pip.target_channel = tchan_id;
hvep->pip.svc_id = svc_id;
switch (svc_id) {
case LDC_HVCTL_SVC:
/*
* We don't yet allow for HVCTL channel between the
* hypervisor and SP. Maybe one day we will have a
* Zeus or Zeus-lite running on the SP and at that
* point we can remove this check.
*/
if (hvep->pip.target_type == LDC_SP_ENDPOINT) {
DBGHL(c_printf("No HVCTL LDC to the SP "
"allowed yet\n"));
goto ill_prop;
}
DBGHL(c_printf(" for HVCTL service\n"));
break;
default:
DBGHL(c_printf("Unknown service type 0x%x\n", svc_id));
goto miss_prop;
}
/*
* Now figure if this is a config or a modify
*/
if (!hvep->is_live) {
hvep->pip.res.flags = RESF_Config;
DBGHL(c_printf("Elected to Configure"));
} else {
if (hvep->pip.target_type != hvep->target_type ||
(hvep->target_type == LDC_GUEST_ENDPOINT &&
hvep->pip.target_guestp != hvep->target_guest) ||
hvep->pip.target_channel != hvep->target_channel) {
DBGHL(c_printf("A HV LDC channel must be unconfiged "
"before it can be re-bound\n"));
*fail_codep = HVctl_e_hv_ldc_rebind_na;
return (HVctl_st_eillegal);
} else {
hvep->pip.res.flags = RESF_Noop;
DBGHL(c_printf("Elected to Ignore"));
}
}
return (HVctl_st_ok);
}
hvctl_status_t
res_hv_ldc_postparse(hvctl_res_error_t *res_error, int *fail_res_id)
{
return (HVctl_st_ok);
}
void
res_hv_ldc_commit(int flag)
{
int i;
for (i = 0; i < MAX_HV_LDC_CHANNELS; i++) {
ldc_endpoint_t *hvep;
hvep = config.hv_ldcs;
hvep = &(hvep[i]);
/* if not this ops turn move on */
if (hvep->pip.res.flags != flag) continue;
switch (hvep->pip.res.flags) {
case RESF_Noop:
DBG(c_printf("hv_ldc 0x%x : noop\n", i));
break;
case RESF_Unconfig:
res_hv_ldc_commit_unconfig(i);
break;
case RESF_Config:
res_hv_ldc_commit_config(i);
break;
case RESF_Rebind:
DBG(c_printf("hv_ldc 0x%x : rebind\n", i));
ASSERT(0); /* not supported */
break;
case RESF_Modify:
DBG(c_printf("hv_ldc 0x%x : modify\n", i));
ASSERT(0); /* not supported */
break;
default:
ASSERT(0);
}
hvep->pip.res.flags = RESF_Noop; /* cleanup */
}
}
void
res_hv_ldc_commit_config(int ch_id)
{
ldc_endpoint_t *hvep;
extern void hvctl_svc_callback(); /* FIXME: in a header */
hvep = config.hv_ldcs;
hvep = &(hvep[ch_id]);
DBGHL(c_printf("\t\tConfig endpoint\n"));
ASSERT(!hvep->is_live);
hvep->target_type = hvep->pip.target_type;
switch (hvep->target_type) {
case LDC_GUEST_ENDPOINT: /* guest<->HV LDC */
hvep->target_guest = hvep->pip.target_guestp;
break;
case LDC_SP_ENDPOINT: /* HV<->SP LDC */
break;
default:
ASSERT(0);
}
hvep->target_channel = hvep->pip.target_channel;
/* svc id determines the callback setup */
switch (hvep->pip.svc_id) {
case LDC_HVCTL_SVC:
/*
* FIXME: Why did we save the endpoint number
* instead of a pointer to the endpoint ?
*/
config.hvctl_ldc = ch_id; /* save the HVCTL channel id */
hvep->rx_cb = (uint64_t)&hvctl_svc_callback;
hvep->rx_cbarg = (uint64_t)&config;
break;
default:
DBG(c_printf("Unknown service type 0x%x\n", hvep->pip.svc_id));
ASSERT(0);
}
/* Mark channel as live */
ASSERT(!hvep->is_live);
hvep->is_live = true;
}
void
res_hv_ldc_commit_unconfig(int ch_id)
{
ldc_endpoint_t *hvep;
hvep = config.hv_ldcs;
hvep = &(hvep[ch_id]);
DBGHL(c_printf("\t\tUnconfig endpoint %d\n", ch_id));
ASSERT(hvep->is_live);
hvep->is_live = false;
}
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.