OpenSolaris_b135/lib/libprtdiag_psr/sparc/daktari/common/workfile.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2000, 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* Daktari Platform specific functions.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <libdevinfo.h>
#include <alloca.h>
#include <inttypes.h>
#include <libprtdiag.h>
#include <sys/mc.h>
#define EXIT_MSG(msg, err) \
{ printf("\n%s failed with %d\n", msg, err); exit(err); }
/* we only need the 5 LSB of the portid to calculate the board number */
#define DAK_SAFARI_ID_MASK 0x1F /* 5 bits */
#define DAK_NODE_MASK 0x1F /* 5 bits */
#define DAK_PORTID_NODE_SHIFT 5
#define DAK_MIN_CPU_SAFARI_ID 0 /* 0x00 */
#define DAK_MAX_CPU_SAFARI_ID 23 /* 0x17 */
#define DAK_MIN_IO_SAFARI_ID 24 /* 0x18 */
#define DAK_MAX_IO_SAFARI_ID 31 /* 0x1F */
#define NUM_MBANKS_PER_MC 4
#define DAK_CLK_FREQ_TO_MHZ(x) (((x) + 500000) / 1000000)
/*
* DAK_PORTID_IS_CPU_TYPE
*
* If the portid associated with a CPU board is passed in, TRUE is returned,
* otherwise FALSE.
*/
#define DAK_PORTID_IS_CPU_TYPE(portid) \
(((((portid) & DAK_SAFARI_ID_MASK) >= DAK_MIN_CPU_SAFARI_ID) && \
(((portid) & DAK_SAFARI_ID_MASK) <= DAK_MAX_CPU_SAFARI_ID)) ? \
TRUE: FALSE)
/*
* DAK_CPU_BD_PORTID_TO_BD_NUM
*
* If the portid associated with a CPU board is passed in, the board number
* associated with this portid is returned, otherwise -1.
*/
#define DAK_CPU_BD_PORTID_TO_BD_NUM(portid) \
((DAK_PORTID_IS_CPU_TYPE(portid)) ? \
(((portid) & DAK_SAFARI_ID_MASK) / 4) : (-1))
/*
* DAK_PORTID_IS_IO_TYPE
*
* If the portid associated with an IO board is passed in, TRUE is returned,
* otherwise FALSE.
*/
#define DAK_PORTID_IS_IO_TYPE(portid) \
(((((portid) & DAK_SAFARI_ID_MASK) >= DAK_MIN_IO_SAFARI_ID) && \
(((portid) & DAK_SAFARI_ID_MASK) <= DAK_MAX_IO_SAFARI_ID)) ? \
TRUE: FALSE)
/*
* DAK_IO_BD_PORTID_TO_BD_NUM
*
* If the portid associated with an IO board is passed in, the board number
* associated with this portid is returned, otherwise -1.
*/
#define DAK_IO_BD_PORTID_TO_BD_NUM(portid) \
(DAK_PORTID_IS_IO_TYPE(portid) ? \
(((((portid) & DAK_SAFARI_ID_MASK) - 24) / 2) + 6) : (-1))
/*
* DAK_PORTID_TO_BOARD_NUM
*
* If a valid portid is passed in, this macro returns the board number
* associated with it, otherwise it returns -1.
*/
#define DAK_PORTID_TO_BOARD_NUM(portid) \
((DAK_PORTID_IS_CPU_TYPE(portid)) ? \
(DAK_CPU_BD_PORTID_TO_BD_NUM(portid)) : \
((DAK_PORTID_IS_IO_TYPE(portid)) ? \
DAK_IO_BD_PORTID_TO_BD_NUM(portid) : (-1)))
/* Local Functions */
char *get_node_name(Prom_node *pnode);
char *get_node_type(Prom_node *pnode);
void add_node(Sys_tree *root, Prom_node *pnode);
Prop *find_prop(Prom_node *pnode, char *name);
int do_prominfo(int syserrlog, char *pgname, int log_flag, int prt_flag);
void *get_prop_val(Prop *prop);
char *get_node_type(Prom_node *pnode);
int get_us3_mem_regs(Board_node *bnode);
void fill_pci_card_list(Prom_node *pci_instance,
Prom_node *pci_card_node,
struct io_card *pci_card,
struct io_card **pci_card_list,
char **pci_slot_name_arr);
static Prom_node *next_pci_card(Prom_node *curr_card, int *is_bridge,
int is_pcidev, Prom_node *curr_bridge,
Prom_node * parent_bridge, Prom_node *pci);
static Prom_node *dev_next_node_by_compat(Prom_node *root, char *compat);
static Prom_node *dev_find_node_by_compat(Prom_node *root, char *compat);
static Board_node *daktari_insert_board(Sys_tree *root, int board);
static Board_node *daktari_find_board(Sys_tree *root, int board);
static int32_t find_child_device(picl_nodehdl_t, char *, picl_nodehdl_t *);
static int32_t fill_device_from_id(picl_nodehdl_t, char *, picl_nodehdl_t *);
static int32_t fill_device_array_from_id(picl_nodehdl_t, char *, int32_t *,
picl_nodehdl_t **);
/* Overlaying routines */
/*
* This function searches through the properties of the node passed in
* and returns a pointer to the value of the name property.
*/
char *
get_node_name(Prom_node *pnode)
{
Prop *prop;
if (pnode == NULL)
return (NULL);
prop = pnode->props;
while (prop != NULL) {
if (strcmp("name", (char *)prop->name.val_ptr) == 0)
return (prop->value.val_ptr);
prop = prop->next;
}
return (NULL);
}
/*
* This function searches through the properties of the node passed in
* and returns a pointer to the value of the name property.
*/
char *
get_node_type(Prom_node *pnode)
{
Prop *prop;
if (pnode == NULL) {
return (NULL);
}
prop = pnode->props;
while (prop != NULL) {
if (strcmp("device_type", (char *)prop->name.val_ptr) == 0)
return (prop->value.val_ptr);
prop = prop->next;
}
return (NULL);
}
/*
* add_node
*
* This function adds a board node to the board structure where that
* that node's physical component lives.
*/
void
add_node(Sys_tree *root, Prom_node *pnode)
{
int board = -1;
int portid = -1;
void *value = NULL;
Board_node *bnode = NULL;
Prom_node *p = NULL;
/* Get the board number of this board from the portid prop */
value = get_prop_val(find_prop(pnode, "portid"));
if (value != NULL) {
portid = *(int *)value;
}
board = DAK_PORTID_TO_BOARD_NUM(portid);
/* board = DAK_GETSLOT(portid); */
/* find the board node with the same board number */
if ((bnode = daktari_find_board(root, board)) == NULL) {
bnode = daktari_insert_board(root, board);
}
/* now attach this prom node to the board list */
/* Insert this node at the end of the list */
pnode->sibling = NULL;
if (bnode->nodes == NULL)
bnode->nodes = pnode;
else {
p = bnode->nodes;
while (p->sibling != NULL)
p = p->sibling;
p->sibling = pnode;
}
}
/*
* Search a Prom node and retrieve the property with the correct
* name.
*/
Prop *
find_prop(Prom_node *pnode, char *name)
{
Prop *prop;
if (pnode == NULL)
return (NULL);
if (pnode->props == NULL)
return (NULL);
prop = pnode->props;
if (prop == NULL)
return (NULL);
if (prop->name.val_ptr == NULL)
return (NULL);
while ((prop != NULL) && (strcmp((char *)(prop->name.val_ptr), name))) {
prop = prop->next;
}
return (prop);
}
int
do_prominfo(int syserrlog, char *pgname, int log_flag, int prt_flag)
{
return (do_devinfo(syserrlog, pgname, log_flag, prt_flag));
}
/*
* return the property value for the Prop
* passed in.
*/
void *
get_prop_val(Prop *prop)
{
if (prop == NULL)
return (NULL);
return ((void *)(prop->value.val_ptr));
}
/* Local Routines */
/*
* Start from the current node and return the next node besides
* the current one which has the requested model property.
*/
static Prom_node *
dev_next_node_by_compat(Prom_node *root, char *compat)
{
Prom_node *node;
if (root == NULL)
return (NULL);
/* look at your children first */
if ((node = dev_find_node_by_compat(root->child, compat)) != NULL)
return (node);
/* now look at your siblings */
if ((node = dev_find_node_by_compat(root->sibling, compat)) != NULL)
return (node);
return (NULL); /* not found */
}
/*
* Do a depth-first walk of a device tree and
* return the first node with the matching model.
*/
static Prom_node *
dev_find_node_by_compat(Prom_node *root, char *compat)
{
Prom_node *node;
char *compatible;
char *name;
if (root == NULL)
return (NULL);
if (compat == NULL)
return (NULL);
name = get_node_name(root);
if (name == NULL)
name = "";
compatible = (char *)get_prop_val(find_prop(root, "compatible"));
if (compatible == NULL)
return (NULL);
if ((strcmp(name, "pci") == 0) && (compatible != NULL) &&
(strcmp(compatible, compat) == 0)) {
return (root); /* found a match */
}
/* look at your children first */
if ((node = dev_find_node_by_compat(root->child, compat)) != NULL)
return (node);
/* now look at your siblings */
if ((node = dev_find_node_by_compat(root->sibling, compat)) != NULL)
return (node);
return (NULL); /* not found */
}
/*
* Add a board to the system list in order (sorted by board#).
* Initialize all pointer fields to NULL.
*/
static Board_node *
daktari_insert_board(Sys_tree *root, int board)
{
Board_node *bnode;
Board_node *temp = root->bd_list;
if ((bnode = (Board_node *) malloc(sizeof (Board_node))) == NULL) {
perror("malloc");
exit(1);
}
bnode->nodes = NULL;
bnode->next = NULL;
bnode->board_num = board;
bnode->board_type = UNKNOWN_BOARD;
if (temp == NULL)
root->bd_list = bnode;
else if (temp->board_num > board) {
bnode->next = temp;
root->bd_list = bnode;
} else {
while ((temp->next != NULL) && (board > temp->next->board_num))
temp = temp->next;
bnode->next = temp->next;
temp->next = bnode;
}
root->board_cnt++;
return (bnode);
}
/*
* Find the requested board struct in the system device tree.
*
* This function overrides the functionality of the generic find_board()
* function in libprtdiag, but since we need to pass another parameter,
* we cannot simply overlay the symbol table.
*/
static Board_node *
daktari_find_board(Sys_tree *root, int board)
{
Board_node *bnode = root->bd_list;
while ((bnode != NULL) && (board != bnode->board_num)) {
bnode = bnode->next;
}
return (bnode);
}
int32_t
find_child_device(picl_nodehdl_t parent, char *child_name,
picl_nodehdl_t *child)
{
int32_t err;
char name[PICL_PROPNAMELEN_MAX];
err = picl_get_propval_by_name(parent, PICL_PROP_CHILD, &(*child),
sizeof (picl_nodehdl_t));
switch (err) {
case PICL_SUCCESS:
break;
case PICL_PROPNOTFOUND:
err = PICL_INVALIDHANDLE;
return (err);
default:
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"Failed picl_get_propval_by_name with %s\n"),
picl_strerror(err));
#endif
return (err);
}
err = picl_get_propval_by_name(*child, PICL_PROP_NAME, name,
PICL_PROPNAMELEN_MAX);
#ifdef WORKFILE_DEBUG
if (err != PICL_SUCCESS) {
log_printf(dgettext(TEXT_DOMAIN,
"failed the get name for root\n"), 0);
log_printf(dgettext(TEXT_DOMAIN, "%s\n"),
picl_strerror(err), 0);
}
#endif
if (strcmp(name, child_name) == 0)
return (err);
while (err != PICL_PROPNOTFOUND) {
err = picl_get_propval_by_name(*child, PICL_PROP_PEER,
&(*child), sizeof (picl_nodehdl_t));
switch (err) {
case PICL_SUCCESS:
err = picl_get_propval_by_name(*child, PICL_PROP_NAME,
name, PICL_PROPNAMELEN_MAX);
if (strcmp(name, child_name) == 0)
return (err);
break;
case PICL_PROPNOTFOUND:
break;
default:
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"Failed picl_get_propval_by_name with %s\n"),
picl_strerror(err), 0);
#endif
return (err);
}
}
err = PICL_INVALIDHANDLE;
return (err);
}
int32_t
fill_device_from_id(picl_nodehdl_t device_id, char *assoc_id,
picl_nodehdl_t *device)
{
int32_t err;
picl_prophdl_t tbl_hdl;
picl_prophdl_t reference_property;
err = picl_get_propval_by_name(device_id, assoc_id, &tbl_hdl,
sizeof (picl_prophdl_t));
if (err != PICL_SUCCESS) {
#ifdef WORKFILE_DEBUG
if (err != PICL_INVALIDHANDLE) {
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_from_id failure in "
"picl_get_propval_by_name err is %s\n"),
picl_strerror(err), 0);
}
#endif
return (err);
}
err = picl_get_next_by_row(tbl_hdl, &reference_property);
if (err != PICL_SUCCESS) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_from_id failure in picl_get_next_by_row"
" err is %s\n"), picl_strerror(err), 0);
#endif
return (err);
}
/* get node associated with reference property */
err = picl_get_propval(reference_property, &(*device),
sizeof (picl_nodehdl_t));
#ifdef WORKFILE_DEBUG
if (err != 0) {
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_from_id failure in picl_get_propval"
" err is %s\n"), picl_strerror(err), 0);
}
#endif
return (err);
}
int32_t
fill_device_array_from_id(picl_nodehdl_t device_id, char *assoc_id,
int32_t *number_of_devices, picl_nodehdl_t *device_array[])
{
int32_t err;
int i;
picl_prophdl_t tbl_hdl;
picl_prophdl_t entry;
int devs = 0;
err = picl_get_propval_by_name(device_id, assoc_id, &tbl_hdl,
sizeof (picl_prophdl_t));
if ((err != PICL_SUCCESS) && (err != PICL_INVALIDHANDLE)) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure in "
"picl_get_propval_by_name err is %s\n"),
picl_strerror(err), 0);
#endif
return (err);
}
entry = tbl_hdl;
while (picl_get_next_by_row(entry, &entry) == 0)
++devs;
*device_array = calloc((devs), sizeof (picl_nodehdl_t));
if (*device_array == NULL) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure getting memory"
" for array\n"), 0);
#endif
return (PICL_FAILURE);
}
entry = tbl_hdl;
for (i = 0; i < (devs); i++) {
err = picl_get_next_by_row(entry, &entry);
if (err != 0) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure in "
"picl_get_next_by_row err is %s\n"),
picl_strerror(err), 0);
#endif
return (err);
}
/* get node associated with reference property */
err = picl_get_propval(entry, &((*device_array)[i]),
sizeof (picl_nodehdl_t));
if (err != 0) {
#ifdef WORKFILE_DEBUG
log_printf(dgettext(TEXT_DOMAIN,
"fill_device_array_from_id failure in "
"picl_get_propval err is %s\n"),
picl_strerror(err), 0);
#endif
return (err);
}
}
*number_of_devices = devs;
return (err);
}
/*
* This function provides formatting of the memory config
* information that get_us3_mem_regs() and display_us3_banks() code has
* gathered. It overrides the generic print_us3_memory_line() code
* which prints an error message.
*/
void
print_us3_memory_line(int portid, int bank_id, uint64_t bank_size,
char *bank_status, uint64_t dimm_size, uint32_t intlv, int seg_id)
{
int mcid;
mcid = portid;
log_printf(dgettext(TEXT_DOMAIN,
"\n %-1c %2d %2d %4lldMB %11-s %4lldMB "
" %2d-way %d"),
'A' + DAK_GETSLOT(portid), mcid, (bank_id % 4),
bank_size, bank_status, dimm_size, intlv, seg_id, 0);
}
/*
* Fills in the i/o card list to be displayed later in display_pci();
*/
void
fill_pci_card_list(Prom_node * pci_instance, Prom_node * pci_card_node,
struct io_card *pci_card,
struct io_card **pci_card_list, char **slot_name_arr)
{
Prom_node *pci_bridge_node;
Prom_node *pci_parent_bridge;
int *int_val;
int pci_bridge = FALSE;
int pci_bridge_dev_no = -1;
int portid;
int pci_bus;
char buf[MAXSTRLEN];
char *slot_name = NULL; /* info in "slot-names" prop */
char *child_name;
char *name;
char *type;
void *value;
while (pci_card_node != NULL) {
int is_pci = FALSE;
type = NULL;
name = NULL;
/* If it doesn't have a name, skip it */
name = (char *)get_prop_val(
find_prop(pci_card_node, "name"));
if (name == NULL) {
pci_card_node = pci_card_node->sibling;
continue;
}
/*
* Get the portid of the schizo that this card
* lives under.
*/
portid = -1;
value = get_prop_val(find_prop(pci_instance, "portid"));
if (value != NULL) {
portid = *(int *)value;
}
pci_card->schizo_portid = portid;
/*
* Find out whether this is PCI bus A or B
* using the 'reg' property.
*/
int_val = (int *)get_prop_val(find_prop(pci_instance, "reg"));
if (int_val != NULL) {
int_val++; /* skip over first integer */
pci_bus = ((*int_val) & 0x7f0000);
if (pci_bus == 0x600000)
pci_card->pci_bus = 'A';
else if (pci_bus == 0x700000)
pci_card->pci_bus = 'B';
else
pci_card->pci_bus = '-';
} else {
pci_card->pci_bus = '-';
}
if ((pci_card->schizo_portid == 8) &&
(pci_card->pci_bus == 'A')) {
pci_card_node = pci_card_node->sibling;
continue;
}
/*
* get dev# and func# for this card from the
* 'reg' property.
*/
int_val = (int *)get_prop_val(
find_prop(pci_card_node, "reg"));
if (int_val != NULL) {
pci_card->dev_no = (((*int_val) & 0xF800) >> 11);
pci_card->func_no = (((*int_val) & 0x700) >> 8);
} else {
pci_card->dev_no = -1;
pci_card->func_no = -1;
}
type = (char *)get_prop_val(
find_prop(pci_card_node, "device_type"));
/*
* If this is a pci-bridge, then store its dev#
* as its children nodes need this to get their slot#.
* We set the pci_bridge flag so that we know we are
* looking at a pci-bridge node. This flag gets reset
* every time we enter this while loop.
*/
/*
* Check for a PCI-PCI Bridge for PCI and cPCI
* IO Boards using the name and type properties.
*/
if ((type != NULL) && (strncmp(name, "pci", 3) == 0) &&
(strcmp(type, "pci") == 0)) {
pci_bridge_node = pci_card_node;
is_pci = TRUE;
if (!pci_bridge) {
pci_bridge_dev_no = pci_card->dev_no;
pci_parent_bridge = pci_bridge_node;
pci_bridge = TRUE;
}
}
if ((pci_card->pci_bus == 'B') && (pci_card->dev_no == 1) &&
(!pci_bridge)) {
pci_card_node = pci_card_node->sibling;
continue;
}
/*
* Get slot-names property from slot_names_arr.
* If we are the child of a pci_bridge we use the
* dev# of the pci_bridge as an index to get
* the slot number. We know that we are a child of
* a pci-bridge if our parent is the same as the last
* pci_bridge node found above.
*/
if (pci_card->dev_no != -1) {
/*
* We compare this cards parent node with the
* pci_bridge_node to see if it's a child.
*/
if (pci_card_node->parent != pci_instance &&
pci_bridge) {
/* use dev_no of pci_bridge */
if (pci_card->pci_bus == 'B') {
slot_name =
slot_name_arr[pci_bridge_dev_no -2];
} else {
slot_name =
slot_name_arr[pci_bridge_dev_no -1];
}
} else {
if (pci_card->pci_bus == 'B') {
slot_name =
slot_name_arr[pci_card->dev_no-2];
} else {
slot_name =
slot_name_arr[pci_card->dev_no-1];
}
}
if (slot_name != NULL &&
strlen(slot_name) != 0) {
/* Slot num is last char in string */
(void) snprintf(pci_card->slot_str, MAXSTRLEN,
"%c", slot_name[strlen(slot_name) - 1]);
} else {
(void) snprintf(pci_card->slot_str, MAXSTRLEN,
"-");
}
} else {
(void) snprintf(pci_card->slot_str, MAXSTRLEN,
"%c", '-');
}
/*
* Check for failed status.
*/
if (node_failed(pci_card_node))
strcpy(pci_card->status, "fail");
else
strcpy(pci_card->status, "ok");
/* Get the model of this pci_card */
value = get_prop_val(find_prop(pci_card_node, "model"));
if (value == NULL)
pci_card->model[0] = '\0';
else {
(void) snprintf(pci_card->model, MAXSTRLEN, "%s",
(char *)value);
}
/*
* The card may have a "clock-frequency" but we
* are not interested in that. Instead we get the
* "clock-frequency" of the PCI Bus that the card
* resides on. PCI-A can operate at 33Mhz or 66Mhz
* depending on what card is plugged into the Bus.
* PCI-B always operates at 33Mhz.
*/
int_val = get_prop_val(find_prop(pci_instance,
"clock-frequency"));
if (int_val != NULL) {
pci_card->freq = DAK_CLK_FREQ_TO_MHZ(*int_val);
} else {
pci_card->freq = -1;
}
/*
* Figure out how we want to display the name
*/
value = get_prop_val(find_prop(pci_card_node,
"compatible"));
if (value != NULL) {
/* use 'name'-'compatible' */
(void) snprintf(buf, MAXSTRLEN, "%s-%s", name,
(char *)value);
} else {
/* just use 'name' */
(void) snprintf(buf, MAXSTRLEN, "%s", name);
}
name = buf;
/*
* If this node has children, add the device_type
* of the child to the name value of this pci_card->
*/
child_name = (char *)get_node_name(pci_card_node->child);
if ((pci_card_node->child != NULL) &&
(child_name != NULL)) {
value = get_prop_val(find_prop(pci_card_node->child,
"device_type"));
if (value != NULL) {
/* add device_type of child to name */
(void) snprintf(pci_card->name, MAXSTRLEN,
"%s/%s (%s)", name, child_name,
(char *)value);
} else {
/* just add childs name */
(void) snprintf(pci_card->name, MAXSTRLEN,
"%s/%s", name, child_name);
}
} else {
(void) snprintf(pci_card->name, MAXSTRLEN, "%s",
(char *)name);
}
/*
* If this is a pci-bridge, then add the word
* 'pci-bridge' to its model. If we can't find
* a model, then we just describe what the device
* is based on some properties.
*/
if (pci_bridge) {
if (strlen(pci_card->model) == 0) {
if (pci_card_node->parent == pci_bridge_node)
(void) snprintf(pci_card->model, MAXSTRLEN,
"%s", "device on pci-bridge");
else if (pci_card_node->parent
== pci_parent_bridge)
(void) snprintf(pci_card->model, MAXSTRLEN,
"%s", "pci-bridge/pci-bridge");
else
(void) snprintf(pci_card->model, MAXSTRLEN,
"%s", "PCI-BRIDGE");
}
else
(void) snprintf(pci_card->model, MAXSTRLEN,
"%s/pci-bridge", pci_card->model);
}
/* insert this pci_card in the list to be displayed later */
*pci_card_list = insert_io_card(*pci_card_list, pci_card);
/*
* If we are dealing with a pci-bridge, we need to move
* down to the children of this bridge if there are any.
*
* If we are not, we are either dealing with a regular
* card (in which case we move onto the sibling of this
* card) or we are dealing with a child of a pci-bridge
* (in which case we move onto the child's siblings or
* if there are no more siblings for this child, we
* move onto the parents siblings).
*/
pci_card_node = next_pci_card(pci_card_node, &pci_bridge,
is_pci, pci_bridge_node,
pci_parent_bridge, pci_instance);
} /* end-while */
}
/*
* Helper function for fill_pci_card_list(). Indicates which
* card node to go to next.
* Parameters:
* -----------
* Prom_node * curr_card: pointer to the current card node
*
* int * is_bridge: indicates whether or not the card (is | is on)
* a pci bridge
*
* int is_pcidev: indicates whether or not the current card
* is a pci bridge
*
* Prom_node * curr_bridge: pointer to the current pci bridge. Eg:
* curr_card->parent.
*
* Prom_node * parent_bridge: pointer to the first pci bridge encountered.
* we could have nested pci bridges, this would
* be the first one.
*
* Prom_node * pci: pointer to the pci instance that we are attached to.
* This would be parent_bridge->parent, or
* curr_node->parent, if curr_node is not on a pci bridge.
*/
static Prom_node *
next_pci_card(Prom_node *curr_card, int *is_bridge, int is_pcidev,
Prom_node *curr_bridge, Prom_node *parent_bridge,
Prom_node *pci)
{
Prom_node * curr_node = curr_card;
if (*is_bridge) {
/*
* is_pcidev is used to prevent us from following the
* children of something like a scsi device.
*/
if (curr_node->child != NULL && is_pcidev) {
curr_node = curr_node->child;
} else {
curr_node = curr_node->sibling;
if (curr_node == NULL) {
curr_node = curr_bridge->sibling;
while (curr_node == NULL &&
curr_bridge != parent_bridge &&
curr_bridge != NULL) {
curr_node =
curr_bridge->parent->sibling;
curr_bridge = curr_bridge->parent;
if (curr_node != NULL &&
curr_node->parent == pci) {
break;
}
}
if (curr_bridge == NULL ||
curr_node == NULL ||
curr_node->parent == pci ||
curr_bridge == parent_bridge ||
curr_node == parent_bridge) {
*is_bridge = FALSE;
}
}
}
} else {
curr_node = curr_node->sibling;
}
return (curr_node);
}