xref: /titanic_41/usr/src/lib/libprtdiag/common/io.c (revision 03831d35f7499c87d51205817c93e9a8d42c4bae)

/*
 * 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 (c) 1999-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <kvm.h>
#include <varargs.h>
#include <errno.h>
#include <time.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/openpromio.h>
#include <sys/systeminfo.h>
#include <kstat.h>
#include <libintl.h>
#include <syslog.h>
#include <sys/dkio.h>
#include "pdevinfo.h"
#include "display.h"
#include "pdevinfo_sun4u.h"
#include "display_sun4u.h"
#include "libprtdiag.h"

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN	"SYS_TEST"
#endif

Prom_node *
find_pci_bus(Prom_node *node, int id, int bus)
{
	Prom_node *pnode;

	/* find the first pci node */
	pnode = dev_find_node(node, "pci");

	while (pnode != NULL) {
		int tmp_id;
		int tmp_bus;

		tmp_id = get_id(pnode);
		tmp_bus = get_pci_bus(pnode);

		if ((tmp_id == id) &&
		    (tmp_bus == bus)) {
			break;
		}

		pnode = dev_next_node(pnode, "pci");
	}
	return (pnode);
}

/*
 * get_pci_bus
 *
 * Determines the PCI bus, either A (0) or B (1). If the function cannot
 * find the bus-ranges property, it returns -1.
 */
int
get_pci_bus(Prom_node *pnode)
{
	int *value;

	/* look up the bus-range property */
	if ((value = (int *)get_prop_val(find_prop(pnode, "bus-range"))) ==
	    NULL) {
		return (-1);
	}

	if (*value == 0) {
		return (1);	/* B bus has a bus-range value = 0 */
	} else {
		return (0);
	}
}



/*
 * Find the PCI device number of this PCI device. If no device number can
 * be determined, then return -1.
 */
int
get_pci_device(Prom_node *pnode)
{
	void *value;

	if ((value = get_prop_val(find_prop(pnode, "assigned-addresses"))) !=
		NULL) {
		return (PCI_DEVICE(*(int *)value));
	} else {
		return (-1);
	}
}

/*
 * Find the PCI device number of this PCI device. If no device number can
 * be determined, then return -1.
 */
int
get_pci_to_pci_device(Prom_node *pnode)
{
	void *value;

	if ((value = get_prop_val(find_prop(pnode, "reg"))) !=
		NULL) {
		return (PCI_DEVICE(*(int *)value));
	} else {
		return (-1);
	}
}

/*
 * free_io_cards
 * Frees the memory allocated for an io card list.
 */
void
free_io_cards(struct io_card *card_list)
{
	/* Free the list */
	if (card_list != NULL) {
		struct io_card *p, *q;

		for (p = card_list, q = NULL; p != NULL; p = q) {
			q = p->next;
			free(p);
		}
	}
}


/*
 * insert_io_card
 * Inserts an io_card structure into the list.  The list is maintained
 * in order based on board number and slot number.  Also, the storage
 * for the "card" argument is assumed to be handled by the caller,
 * so we won't touch it.
 */
struct io_card *
insert_io_card(struct io_card *list, struct io_card *card)
{
	struct io_card *newcard;
	struct io_card *p, *q;

	if (card == NULL)
		return (list);

	/* Copy the card to be added into new storage */
	newcard = (struct io_card *)malloc(sizeof (struct io_card));
	if (newcard == NULL) {
		perror("malloc");
		exit(2);
	}
	(void) memcpy(newcard, card, sizeof (struct io_card));
	newcard->next = NULL;

	if (list == NULL)
	return (newcard);

	/* Find the proper place in the list for the new card */
	for (p = list, q = NULL; p != NULL; q = p, p = p->next) {
		if (newcard->board < p->board)
			break;
		if ((newcard->board == p->board) && (newcard->slot < p->slot))
			break;
	}

	/* Insert the new card into the list */
	if (q == NULL) {
		newcard->next = p;
		return (newcard);
	} else {
		newcard->next = p;
		q->next = newcard;
		return (list);
	}
}


char *
fmt_manf_id(unsigned int encoded_id, char *outbuf)
{
	union manuf manuf;

	/*
	 * Format the manufacturer's info.  Note a small inconsistency we
	 * have to work around - Brooktree has it's part number in decimal,
	 * while Mitsubishi has it's part number in hex.
	 */
	manuf.encoded_id = encoded_id;
	switch (manuf.fld.manf) {
	case MANF_BROOKTREE:
		(void) sprintf(outbuf, "%s %d, version %d", "Brooktree",
			manuf.fld.partno, manuf.fld.version);
		break;

	case MANF_MITSUBISHI:
		(void) sprintf(outbuf, "%s %x, version %d", "Mitsubishi",
			manuf.fld.partno, manuf.fld.version);
		break;

	default:
		(void) sprintf(outbuf, "JED code %d, Part num 0x%x, version %d",
			manuf.fld.manf, manuf.fld.partno, manuf.fld.version);
	}
	return (outbuf);
}


/*
 * Find the sbus slot number of this Sbus device. If no slot number can
 * be determined, then return -1.
 */
int
get_sbus_slot(Prom_node *pnode)
{
	void *value;

	if ((value = get_prop_val(find_prop(pnode, "reg"))) != NULL) {
		return (*(int *)value);
	} else {
		return (-1);
	}
}


/*
 * This routine is the generic link into displaying system IO
 * configuration. It displays the table header, then displays
 * all the SBus cards, then displays all fo the PCI IO cards.
 */
void
display_io_devices(Sys_tree *tree)
{
	Board_node *bnode;

	/*
	 * TRANSLATION_NOTE
	 * Following string is used as a table header.
	 * Please maintain the current alignment in
	 * translation.
	 */
	log_printf("\n", 0);
	log_printf("=========================", 0);
	log_printf(dgettext(TEXT_DOMAIN, " IO Cards "), 0);
	log_printf("=========================", 0);
	log_printf("\n", 0);
	log_printf("\n", 0);
	bnode = tree->bd_list;
	while (bnode != NULL) {
		display_sbus(bnode);
		display_pci(bnode);
		display_ffb(bnode, 1);
		bnode = bnode->next;
	}
}

void
display_pci(Board_node *bnode)
{
#ifdef  lint
	bnode = bnode;
#endif
	/*
	 * This function is intentionally empty
	 */
}


/*
 * Print out all the io cards in the list.  Also print the column
 * headers if told to do so.
 */
void
display_io_cards(struct io_card *list)
{
	static int banner = 0; /* Have we printed the column headings? */
	struct io_card *p;

	if (list == NULL)
		return;

	if (banner == 0) {
		log_printf("     Bus   Freq\n", 0);
		log_printf("Brd  Type  MHz   Slot        "
			"Name                          "
			"Model", 0);
		log_printf("\n", 0);
		log_printf("---  ----  ----  ----------  "
			"----------------------------  "
			"--------------------", 0);
		log_printf("\n", 0);
		banner = 1;
	}

	for (p = list; p != NULL; p = p -> next) {
		log_printf("%2d   ", p->board, 0);
		log_printf("%-4s  ", p->bus_type, 0);
		log_printf("%3d   ", p->freq, 0);
		/*
		 * We check to see if it's an int or
		 * a char string to display for slot.
		 */
		if (p->slot == PCI_SLOT_IS_STRING)
			log_printf("%10s  ", p->slot_str, 0);
		else
			log_printf("%10d  ", p->slot, 0);

		log_printf("%-28.28s", p->name, 0);
		if (strlen(p->name) > 28)
			log_printf("+ ", 0);
		else
			log_printf("  ", 0);
		log_printf("%-19.19s", p->model, 0);
		if (strlen(p->model) > 19)
			log_printf("+", 0);
		log_printf("\n", 0);
	}
}

/*
 * Display all FFBs on this board.  It can either be in tabular format,
 * or a more verbose format.
 */
void
display_ffb(Board_node *board, int table)
{
	Prom_node *fb;
	void *value;
	struct io_card *card_list = NULL;
	struct io_card card;
	char *type;
	char *label;

	if (board == NULL)
		return;

	/* Fill in common information */
	card.display = 1;
	card.board = board->board_num;
	(void) sprintf(card.bus_type, BUS_TYPE);
	card.freq = sys_clk;

	for (fb = dev_find_node_by_type(board->nodes, "device_type", "display");
	    fb != NULL;
	    fb = dev_next_node_by_type(fb, "device_type", "display")) {
		value = get_prop_val(find_prop(fb, "name"));
		if (value != NULL) {
			if ((strcmp(FFB_NAME, value)) == 0) {
				type = FFB_NAME;
				label = "FFB";
			} else if ((strcmp(AFB_NAME, value)) == 0) {
				type = AFB_NAME;
				label = "AFB";
			} else
				continue;
		} else
			continue;
		if (table == 1) {
			/* Print out in table format */

			/* XXX - Get the slot number (hack) */
			card.slot = get_id(fb);

			/* Find out if it's single or double buffered */
			(void) sprintf(card.name, "%s", label);
			value = get_prop_val(find_prop(fb, "board_type"));
			if (value != NULL)
				if ((*(int *)value) & FFB_B_BUFF)
					(void) sprintf(card.name,
						"%s, Double Buffered", label);
				else
					(void) sprintf(card.name,
						"%s, Single Buffered", label);

			/*
			 * Print model number only if board_type bit 2
			 * is not set and it is not SUNW,XXX-XXXX.
			 */
			card.model[0] = '\0';

			if (strcmp(type, AFB_NAME) == 0) {
				if (((*(int *)value) & 0x4) != 0x4) {
					value = get_prop_val(find_prop(fb,
						    "model"));
					if ((value != NULL) &&
					    (strcmp(value,
					    "SUNW,XXX-XXXX") != 0)) {
						(void) sprintf(card.model, "%s",
						    (char *)value);
					}
				}
			} else {
				value = get_prop_val(find_prop(fb, "model"));
				if (value != NULL)
					(void) sprintf(card.model, "%s",
					    (char *)value);
			}

			card_list = insert_io_card(card_list, &card);
		} else {
			/* print in long format */
			char device[MAXSTRLEN];
			int fd = -1;
			struct dirent *direntp;
			DIR *dirp;
			union strap_un strap;
			struct ffb_sys_info fsi;

			/* Find the device node using upa-portid/portid */
			value = get_prop_val(find_prop(fb, "upa-portid"));
			if (value == NULL)
				value = get_prop_val(find_prop(fb, "portid"));

			if (value == NULL)
			    continue;

			(void) sprintf(device, "%s@%x", type,
				*(int *)value);
			if ((dirp = opendir("/devices")) == NULL)
				continue;

			while ((direntp = readdir(dirp)) != NULL) {
				if (strstr(direntp->d_name, device) != NULL) {
					(void) sprintf(device, "/devices/%s",
						direntp->d_name);
					fd = open(device, O_RDWR, 0666);
					break;
				}
			}
			(void) closedir(dirp);

			if (fd == -1)
				continue;

			if (ioctl(fd, FFB_SYS_INFO, &fsi) < 0)
				continue;

			log_printf("%s Hardware Configuration:\n", label, 0);
			log_printf("-----------------------------------\n", 0);

			strap.ffb_strap_bits = fsi.ffb_strap_bits;
			log_printf("\tBoard rev: %d\n",
				(int)strap.fld.board_rev, 0);
			log_printf("\tFBC version: 0x%x\n", fsi.fbc_version, 0);
			log_printf("\tDAC: %s\n",
				fmt_manf_id(fsi.dac_version, device), 0);
			log_printf("\t3DRAM: %s\n",
				fmt_manf_id(fsi.fbram_version, device), 0);
			log_printf("\n", 0);
		}

	}
	display_io_cards(card_list);
	free_io_cards(card_list);
}


/*
 * Display all the SBus IO cards on this board.
 */
void
display_sbus(Board_node *board)
{
	struct io_card card;
	struct io_card *card_list = NULL;
	int freq;
	int card_num;
	void *value;
	Prom_node *sbus;
	Prom_node *card_node;

	if (board == NULL)
		return;

	for (sbus = dev_find_node(board->nodes, SBUS_NAME); sbus != NULL;
	    sbus = dev_next_node(sbus, SBUS_NAME)) {

		/* Skip failed nodes for now */
		if (node_failed(sbus))
			continue;

		/* Calculate SBus frequency in MHz */
		value = get_prop_val(find_prop(sbus, "clock-frequency"));
		if (value != NULL)
			freq = ((*(int *)value) + 500000) / 1000000;
		else
			freq = -1;

		for (card_node = sbus->child; card_node != NULL;
		    card_node = card_node->sibling) {
			char *model;
			char *name;
			char *child_name;

			card_num = get_sbus_slot(card_node);
			if (card_num == -1)
				continue;

			/* Fill in card information */
			card.display = 1;
			card.freq = freq;
			card.board = board->board_num;
			(void) sprintf(card.bus_type, "SBus");
			card.slot = card_num;
			card.status[0] = '\0';

			/* Try and get card status */
			value = get_prop_val(find_prop(card_node, "status"));
			if (value != NULL)
				(void) strncpy(card.status, (char *)value,
					MAXSTRLEN);

			/* XXX - For now, don't display failed cards */
			if (strstr(card.status, "fail") != NULL)
				continue;

			/* Now gather all of the node names for that card */
			model = (char *)get_prop_val(find_prop(card_node,
				"model"));
			name = get_node_name(card_node);

			if (name == NULL)
				continue;

			card.name[0] = '\0';
			card.model[0] = '\0';

			/* Figure out how we want to display the name */
			child_name = get_node_name(card_node->child);
			if ((card_node->child != NULL) &&
			    (child_name != NULL)) {
				value = get_prop_val(find_prop(card_node->child,
					"device_type"));
				if (value != NULL)
					(void) sprintf(card.name, "%s/%s (%s)",
						name, child_name,
						(char *)value);
				else
					(void) sprintf(card.name, "%s/%s", name,
						child_name);
			} else {
				(void) strncpy(card.name, name, MAXSTRLEN);
			}

			if (model != NULL)
				(void) strncpy(card.model, model, MAXSTRLEN);

			card_list = insert_io_card(card_list, &card);
		}
	}

	/* We're all done gathering card info, now print it out */
	display_io_cards(card_list);
	free_io_cards(card_list);
}


/*
 * Get slot-names properties from parent node and
 * store them in an array.
 */
int
populate_slot_name_arr(Prom_node *pci, int *slot_name_bits,
			char **slot_name_arr, int num_slots)
{
	int	i, j, bit_mask;
	char	*value;

	value = (char *)get_prop_val(find_prop(pci, "slot-names"));
	D_PRINTF("\n populate_slot_name_arr: value = [0x%x]\n", value);

	if (value != NULL) {
		char	*strings_arr[MAX_SLOTS_PER_IO_BD];
		bit_mask = *slot_name_bits = *(int *)value;
		D_PRINTF("\nslot_names 1st integer = [0x%x]", *slot_name_bits);

		/* array starts after first int */
		strings_arr[0] = value + sizeof (int);

		/*
		 * break the array out into num_slots number of strings
		 */
		for (i = 1; i < num_slots; i++) {
			strings_arr[i] = (char *)strings_arr[i - 1]
			    + strlen(strings_arr[i - 1]) + 1;
		}

		/*
		 * process array of slot_names to remove blanks
		 */
		j = 0;
		for (i = 0; i < num_slots; i++) {
			if ((bit_mask >> i) & 0x1)
				slot_name_arr[i] = strings_arr[j++];
			else
				slot_name_arr[i] = "";

			D_PRINTF("\nslot_name_arr[%d] = [%s]", i,
				slot_name_arr[i]);
		}
		return (0);
	} else {
		D_PRINTF("\n populate_slot_name_arr: - psycho with no "
		    "slot-names\n");
		return (0);
	}
}

int
get_card_frequency(Prom_node *pci)
{
	char	*value = get_prop_val(find_prop(pci, "clock-frequency"));

	if (value == NULL)
		return (-1);
	else
		return (int)(((*(int *)value) + 500000) / 1000000);

}

void
get_dev_func_num(Prom_node *card_node, int *dev_no, int *func_no)
{

	void	*value = get_prop_val(find_prop(card_node, "reg"));

	if (value != NULL) {
		int int_val = *(int *)value;
		*dev_no = PCI_REG_TO_DEV(int_val);
		*func_no = PCI_REG_TO_FUNC(int_val);
	} else {
		*dev_no = -1;
		*func_no = -1;
	}
}

void
get_pci_class_codes(Prom_node *card_node, int *class_code, int *subclass_code)
{
	int	class_code_reg = get_pci_class_code_reg(card_node);

	*class_code = CLASS_REG_TO_CLASS(class_code_reg);
	*subclass_code = CLASS_REG_TO_SUBCLASS(class_code_reg);
}

int
is_pci_bridge(Prom_node *card_node, char *name)
{
	int class_code, subclass_code;

	if (card_node == NULL)
		return (FALSE);

	get_pci_class_codes(card_node, &class_code, &subclass_code);

	if ((strncmp(name, "pci", 3) == 0) &&
	    (class_code == PCI_BRIDGE_CLASS) &&
	    (subclass_code == PCI_PCI_BRIDGE_SUBCLASS))
		return (TRUE);
	else
		return (FALSE);
}

int
is_pci_bridge_other(Prom_node *card_node, char *name)
{
	int class_code, subclass_code;

	if (card_node == NULL)
		return (FALSE);

	get_pci_class_codes(card_node, &class_code, &subclass_code);

	if ((strncmp(name, "pci", 3) == 0) &&
	    (class_code == PCI_BRIDGE_CLASS) &&
	    (subclass_code == PCI_SUBCLASS_OTHER))
		return (TRUE);
	else
		return (FALSE);
}
void
get_pci_card_model(Prom_node *card_node, char *model)
{
	char	*name = get_prop_val(find_prop(card_node, "name"));
	char	*value = get_prop_val(find_prop(card_node, "model"));
	int 	pci_bridge = is_pci_bridge(card_node, name);

	if (value == NULL)
		model[0] = '\0';
	else
		(void) sprintf(model, "%s",
			(char *)value);

	if (pci_bridge) {
		if (strlen(model) == 0)
			(void) sprintf(model,
				"%s", "pci-bridge");
		else
			(void) sprintf(model,
				"%s/pci-bridge", model);
	}
}

void
create_io_card_name(Prom_node *card_node, char *name, char *card_name)
{
	char	*value = get_prop_val(find_prop(card_node, "compatible"));
	char	*child_name;
	char	buf[MAXSTRLEN];

	if (value != NULL) {
		(void) sprintf(buf, "%s-%s", name,
			(char *)value);
	} else
		(void) sprintf(buf, "%s", name);

	name = buf;

	child_name = (char *)get_node_name(card_node->child);

	if ((card_node->child != NULL) &&
	    (child_name != NULL)) {
		value = get_prop_val(find_prop(card_node->child,
			"device_type"));
		if (value != NULL)
			(void) sprintf(card_name, "%s/%s (%s)",
				name, child_name,
				(char *)value);
		else
			(void) sprintf(card_name, "%s/%s", name,
				child_name);
	} else {
		(void) sprintf(card_name, "%s", (char *)name);
	}
}


/*
 * Desktop display_psycho_pci
 * Display all the psycho based PCI IO cards on this board.
 */

/* ARGSUSED */
void
display_psycho_pci(Board_node *board)
{
	struct io_card	*card_list = NULL;
	struct io_card	card;
	void		*value;

	Prom_node	*pci, *card_node, *pci_bridge_node = NULL;
	char		*name;
	int		slot_name_bits, pci_bridge_dev_no,
			class_code, subclass_code,
			pci_pci_bridge;
	char		*slot_name_arr[MAX_SLOTS_PER_IO_BD];

	if (board == NULL)
		return;

	/* Initialize all the common information */
	card.display = 1;
	card.board = board->board_num;
	(void) sprintf(card.bus_type, "PCI");

	for (pci = dev_find_node_by_type(board->nodes, "model", "SUNW,psycho");
	    pci != NULL;
	    pci = dev_next_node_by_type(pci, "model", "SUNW,psycho")) {

		/*
		 * If we have reached a pci-to-pci bridge node,
		 * we are one level below the 'pci' nodes level
		 * in the device tree. To get back to that level,
		 * the search should continue with the sibling of
		 * the parent or else the remaining 'pci' cards
		 * will not show up in the output.
		 */
		if (find_prop(pci, "upa-portid") == NULL) {
			if ((pci->parent->sibling != NULL) &&
				(strcmp(get_prop_val(
				find_prop(pci->parent->sibling,
				"name")), PCI_NAME) == 0))
				pci = pci->parent->sibling;
			else {
				pci = pci->parent->sibling;
				continue;
			}
		}

		D_PRINTF("\n\n------->Looking at device [%s][%d] - [%s]\n",
		    PCI_NAME, *((int *)get_prop_val(find_prop(
			pci, "upa-portid"))),
			get_prop_val(find_prop(pci, "model")));

		/* Skip all failed nodes for now */
		if (node_failed(pci))
			continue;

		/* Fill in frequency */
		card.freq = get_card_frequency(pci);

		/*
		 * Each PSYCHO device has a slot-names property that can be
		 * used to determine the slot-name string for each IO
		 * device under this node. We get this array now and use
		 * it later when looking at the children of this PSYCHO.
		 */
		if ((populate_slot_name_arr(pci, &slot_name_bits,
		    (char **)&slot_name_arr, MAX_SLOTS_PER_IO_BD)) != 0)
			goto next_card;

		/* Walk through the PSYCHO children */
		card_node = pci->child;
		while (card_node != NULL) {

			pci_pci_bridge = FALSE;

			/* If it doesn't have a name, skip it */
			name = (char *)get_prop_val(
				find_prop(card_node, "name"));
			if (name == NULL)
				goto next_card;

			/* get dev# and func# for this card. */
			get_dev_func_num(card_node, &card.dev_no,
			    &card.func_no);

			/* get class/subclass code for this card. */
			get_pci_class_codes(card_node, &class_code,
			    &subclass_code);

			D_PRINTF("\nName [%s] - ", name);
			D_PRINTF("device no [%d] - ", card.dev_no);
			D_PRINTF("class_code [%d] subclass_code [%d] - ",
			    class_code, subclass_code);

			/*
			 * Weed out PCI Bridge, subclass 'other' and
			 * ebus nodes.
			 */
			if (((class_code == PCI_BRIDGE_CLASS) &&
			    (subclass_code == PCI_SUBCLASS_OTHER)) ||
			    (strstr(name, "ebus"))) {
				D_PRINTF("\nSkip ebus/class-other nodes [%s]",
				    name);
				goto next_card;
			}

			/*
			 * If this is a PCI bridge, then we store it's dev_no
			 * so that it's children can use it for getting at
			 * the slot_name.
			 */
			if (is_pci_bridge(card_node, name)) {
				pci_bridge_dev_no = card.dev_no;
				pci_bridge_node = card_node;
				pci_pci_bridge = TRUE;
				D_PRINTF("\nPCI Bridge detected\n");
			}

			/*
			 * 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 (card_node->parent == pci_bridge_node)
				card.dev_no = pci_bridge_dev_no;

			/* Get slot-names property from slot_names_arr. */
			get_slot_number_str(&card, (char **)slot_name_arr,
			    slot_name_bits);

			if (slot_name_bits)
				D_PRINTF("\nIO Card [%s] dev_no [%d] SlotStr "
				    "[%s] slot [%s]", name, card.dev_no,
				    slot_name_arr[card.dev_no],
				    card.slot_str);

			/* XXX - Don't know how to get status for PCI cards */
			card.status[0] = '\0';

			/* Get the model of this card */
			get_pci_card_model(card_node, (char *)&card.model);

			/*
			 * If we haven't figured out the frequency yet,
			 * try and get it from the card.
			 */
			value = get_prop_val(find_prop(pci, "clock-frequency"));
			if (value != NULL && card.freq == -1)
				card.freq = ((*(int *)value) + 500000)
					/ 1000000;


			/* Figure out how we want to display the name */
			create_io_card_name(card_node, name,
				(char *)&card.name);

			if (card.freq != -1)
				card_list = insert_io_card(card_list, &card);

next_card:
			/*
			 * If we are done with the children of the pci bridge,
			 * we must continue with the remaining siblings of
			 * the pci-to-pci bridge - otherwise we move onto our
			 * own sibling.
			 */
			if (pci_pci_bridge) {
				if (card_node->child != NULL)
					card_node = card_node->child;
				else
					card_node = card_node->sibling;
			} else {
				if ((card_node->parent == pci_bridge_node) &&
				    (card_node->sibling == NULL))
					card_node = pci_bridge_node->sibling;
				else
					card_node = card_node->sibling;
			}
		} /* end-while */
	} /* end-for */

	D_PRINTF("\n\n");

	display_io_cards(card_list);
	free_io_cards(card_list);
}

void
get_slot_number_str(struct io_card *card, char **slot_name_arr,
	int slot_name_bits)
{
	if (card->dev_no != -1) {
		char	*slot;
		/*
		 * slot_name_bits is a mask of the plug-in slots so if our
		 * dev_no does not appear in this mask we must be an
		 * on_board device so set the slot to 'On-Board'
		 */
		if (slot_name_bits & (1 << card->dev_no)) {
			/* we are a plug-in card */
			slot = slot_name_arr[card->dev_no];
			if (strlen(slot) != 0) {
				(void) sprintf(card->slot_str, "%s",
				    slot);
			} else
				(void) sprintf(card->slot_str, "-");
		} else {
			/* this is an on-board dev. */
			sprintf(card->slot_str, "On-Board");
		}

	} else {
		(void) sprintf(card->slot_str, "%c", '-');
	}

	/* Informs display_io_cards to print slot_str instead of slot */
	card->slot = PCI_SLOT_IS_STRING;
}


/*
 * The output of a number of I/O cards are identical so we need to
 * differentiate between them.
 *
 * This function is called by the platform specific code and it decides
 * if the card needs further processing.
 *
 * It can be extended in the future if card types other than QLC have
 * the same problems.
 */
void
distinguish_identical_io_cards(char *name, Prom_node *node,
				struct io_card *card)
{
	if ((name == NULL) || (node == NULL))
		return;

	if (strcmp(name, "SUNW,qlc") == 0)
		decode_qlc_card_model_prop(node, card);
}


/*
 * The name/model properties for a number of the QLC FCAL PCI cards are
 * identical (*), so we need to distinguish them using the subsystem-id
 * and modify the model string to be more informative.
 *
 * (*) Currently the problem cards are:
 *	Amber
 *	Crystal+
 */
void
decode_qlc_card_model_prop(Prom_node *card_node, struct io_card *card)
{
	void	*value = NULL;

	if (card_node == NULL)
		return;

	value = get_prop_val(find_prop(card_node, "subsystem-id"));
	if (value != NULL) {
		int	id = *(int *)value;

		switch (id) {
		case AMBER_SUBSYSTEM_ID:
			(void) snprintf(card->model, MAX_QLC_MODEL_LEN, "%s",
				AMBER_CARD_NAME);
			break;

		case CRYSTAL_SUBSYSTEM_ID:
			(void) snprintf(card->model, MAX_QLC_MODEL_LEN, "%s",
				CRYSTAL_CARD_NAME);
			break;

		default:
			/*
			 * If information has been saved into the model field
			 * before this function was called we will keep it as
			 * it probably will be more meaningful that the
			 * subsystem-id, otherwise we save the subsystem-id in
			 * the hope that it will distinguish the cards.
			 */
			if (strcmp(card->model, "") == 0) {
				(void) snprintf(card->model, MAX_QLC_MODEL_LEN,
					"0x%x", id);
			}
			break;
		}
	}
}