/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <stdarg.h>
#include <errno.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <sys/openpromio.h>
#include <libintl.h>
#include "pdevinfo.h"
#include "display.h"
#include "pdevinfo_sun4u.h"

/*
 * For machines that support the openprom, fetch and print the list
 * of devices that the kernel has fetched from the prom or conjured up.
 *
 */


static int prom_fd;
extern char *progname;
extern char *promdev;
extern void getppdata();
extern void printppdata();

/*
 * Define DPRINT for run-time debugging printf's...
 * #define DPRINT	1
 */

#ifdef	DPRINT
static	char    vdebug_flag = 1;
#define	dprintf	if (vdebug_flag) printf
static void dprint_dev_info(caddr_t, dev_info_t *);
#endif	/* DPRINT */

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

/*VARARGS1*/
int
_error(char *fmt, ...)
{
	int saved_errno;
	va_list ap;
	extern int errno;
	saved_errno = errno;

	if (progname)
		(void) fprintf(stderr, "%s: ", progname);

	va_start(ap, fmt);

	(void) vfprintf(stderr, fmt, ap);

	va_end(ap);

	(void) fprintf(stderr, ": ");
	errno = saved_errno;
	perror("");

	return (2);
}

int
is_openprom(void)
{
	Oppbuf	oppbuf;
	register struct openpromio *opp = &(oppbuf.opp);
	register unsigned int i;

	opp->oprom_size = MAXVALSIZE;
	if (ioctl(prom_fd, OPROMGETCONS, opp) < 0)
		exit(_error("OPROMGETCONS"));

	i = (unsigned int)((unsigned char)opp->oprom_array[0]);
	return ((i & OPROMCONS_OPENPROM) == OPROMCONS_OPENPROM);
}

/*
 * Read all properties and values from nodes.
 * Copy the properties read into the prom_node passsed in.
 */
void
dump_node(Prom_node *node)
{
	Oppbuf oppbuf;
	register struct openpromio *opp = &oppbuf.opp;
	Prop *prop = NULL;	/* tail of properties list */
	StaticProp *temp;

	/* clear out pointers in pnode */
	node->props = NULL;

	/* get first prop by asking for null string */
	(void) memset((void *) oppbuf.buf, 0, BUFSIZE);

	/* allocate space for the property */
	if ((temp = malloc(sizeof (StaticProp))) == NULL) {
		perror("malloc");
		exit(1);
	}

	opp->oprom_size = MAXPROPSIZE;
	while (opp->oprom_size != 0) {
		Prop *new;
		int i;
		char *tempp, *newp;

		/*
		 * get property
		 */
		opp->oprom_size = MAXPROPSIZE;

		if (ioctl(prom_fd, OPROMNXTPROP, opp) < 0)
			exit(_error("OPROMNXTPROP"));

		if (opp->oprom_size != 0) {
			temp->name.opp.oprom_size = opp->oprom_size;
			(void) strcpy(temp->name.opp.oprom_array,
				opp->oprom_array);

			(void) strcpy(temp->value.opp.oprom_array,
				temp->name.opp.oprom_array);
			getpropval(&temp->value.opp);
			temp->size = temp->value.opp.oprom_size;

			/* Now copy over temp's data to new. */
			if ((new = malloc(sizeof (Prop))) == NULL) {
				perror("malloc");
				exit(1);
			}

			/*
			 * First copy over temp->name's data. The
			 * temp->name.opp.opio_u union always contains char[]
			 * (as opposed to an int or int []).
			 */
			new->name.opp.oprom_size = temp->name.opp.oprom_size;

			if ((new->name.opp.oprom_array =
			    malloc(new->name.opp.oprom_size)) == NULL) {
				perror("malloc");
				exit(1);
			}
			(void) strcpy(new->name.opp.oprom_array,
			    temp->name.opp.oprom_array);

			new->name.opp.holds_array = 1;

			/*
			 * Then copy over temp->value's data.
			 * temp->value.opp.opio_u could contain char[], int or
			 * int []. If *(temp->value.opp.oprom_array) is '\0',
			 * this indicates int or int []. int is the norm, but
			 * to be safe we assume int [] and copy over
			 * OPROM_NODE_SIZE int elements.
			 */
			new->value.opp.oprom_size = temp->value.opp.oprom_size;

			if (*(temp->value.opp.oprom_array) == '\0') {
				for (i = 0; i < OPROM_NODE_SIZE; i++)
					new->value.opp.oprom_node[i] =
					    *(&temp->value.opp.oprom_node+i);

				new->value.opp.holds_array = 0;
			} else {
				if ((new->value.opp.oprom_array =
				    malloc(new->value.opp.oprom_size))
				    == NULL) {
					perror("malloc");
					exit(1);
				}

				/*
				 * temp->value.opp.oprom_array can contain one
				 * or more embedded NULLs. These trip-up the
				 * standard string copying functions, so we do
				 * the copy by hand. temp->value.opp.oprom_array
				 * will be NULL-terminated. oprom_size includes
				 * this terminating NULL.
				 */
				newp = new->value.opp.oprom_array;
				tempp = temp->value.opp.oprom_array;
				for (i = new->value.opp.oprom_size; i > 0; i--)
					*newp++ = *tempp++;

				new->value.opp.holds_array = 1;
			}

			new->size = temp->size;

			/* everything worked so link the property list */
			if (node->props == NULL)
				node->props = new;
			else if (prop != NULL)
				prop->next = new;
			prop = new;
			prop->next = NULL;
		}
	}
	free(temp);
}

int
promopen(int oflag)
{
	/*CONSTCOND*/
	while (1)  {
		if ((prom_fd = open(promdev, oflag)) < 0)  {
			if (errno == EAGAIN)   {
				(void) sleep(5);
				continue;
			}
			if (errno == ENXIO)
				return (-1);
			exit(_error(dgettext(TEXT_DOMAIN, "cannot open %s"),
				promdev));
		} else
			return (0);
	}
	/*NOTREACHED*/
}

void
promclose(void)
{
	if (close(prom_fd) < 0)
		exit(_error(dgettext(TEXT_DOMAIN, "close error on %s"),
			promdev));
}

/*
 * Read the value of the property from the PROM device tree
 */
void
getpropval(struct openpromio *opp)
{
	opp->oprom_size = MAXVALSIZE;

	if (ioctl(prom_fd, OPROMGETPROP, opp) < 0)
		exit(_error("OPROMGETPROP"));
}

int
next(int id)
{
	Oppbuf	oppbuf;
	register struct openpromio *opp = &(oppbuf.opp);
	/* LINTED */
	int *ip = (int *)(opp->oprom_array);

	(void) memset((void *) oppbuf.buf, 0, BUFSIZE);

	opp->oprom_size = MAXVALSIZE;
	*ip = id;
	if (ioctl(prom_fd, OPROMNEXT, opp) < 0)
		return (_error("OPROMNEXT"));
	/* LINTED */
	return (*(int *)opp->oprom_array);
}

int
child(int id)
{
	Oppbuf	oppbuf;
	register struct openpromio *opp = &(oppbuf.opp);
	/* LINTED */
	int *ip = (int *)(opp->oprom_array);

	(void) memset((void *) oppbuf.buf, 0, BUFSIZE);
	opp->oprom_size = MAXVALSIZE;
	*ip = id;
	if (ioctl(prom_fd, OPROMCHILD, opp) < 0)
		return (_error("OPROMCHILD"));
	/* LINTED */
	return (*(int *)opp->oprom_array);
}

/*
 * Check if the Prom node passed in contains a property called
 * "board#".
 */
int
has_board_num(Prom_node *node)
{
	Prop *prop = node->props;

	/*
	 * walk thru all properties in this PROM node and look for
	 * board# prop
	 */
	while (prop != NULL) {
		if (strcmp(prop->name.opp.oprom_array, "board#") == 0)
		    return (1);

		prop = prop->next;
	}

	return (0);
}	/* end of has_board_num() */

/*
 * Retrieve the value of the board number property from this Prom
 * node. It has the type of int.
 */
int
get_board_num(Prom_node *node)
{
	Prop *prop = node->props;

	/*
	 * walk thru all properties in this PROM node and look for
	 * board# prop
	 */
	while (prop != NULL) {
		if (strcmp(prop->name.opp.oprom_array, "board#") == 0)
			return (prop->value.opp.oprom_node[0]);

		prop = prop->next;
	}

	return (-1);
}	/* end of get_board_num() */

/*
 * Find the requested board struct in the system device tree.
 */
Board_node *
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);
}	/* end of find_board() */

/*
 * Add a board to the system list in order. Initialize all pointer
 * fields to NULL.
 */
Board_node *
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;

	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);
}	/* end of insert_board() */

/*
 * 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", prop->name.opp.oprom_array) == 0)
			return (prop->value.opp.oprom_array);
		prop = prop->next;
	}
	return (NULL);
}	/* end of get_node_name() */

/*
 * 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", prop->name.opp.oprom_array) == 0)
			return (prop->value.opp.oprom_array);
		prop = prop->next;
	}
	return (NULL);
}	/* end of get_node_type() */

/*
 * Do a depth-first walk of a device tree and
 * return the first node with the name matching.
 */

Prom_node *
dev_find_node(Prom_node *root, char *name)
{
	Prom_node *node;

	node = dev_find_node_by_type(root, "name", name);

	return (node);
}

Prom_node *
dev_next_node(Prom_node *root, char *name)
{
	Prom_node *node;

	node = dev_next_node_by_type(root, "name", name);

	return (node);
}

/*
 * Search for and return a node of the required type. If no node is found,
 * then return NULL.
 */
Prom_node *
dev_find_type(Prom_node *root, char *type)
{
	Prom_node *node;

	node = dev_find_node_by_type(root, "device_type", type);

	return (node);  /* not found */
}

/*
 * Start from the current node and return the next node besides the
 * current one which has the requested type property.
 */
Prom_node *
dev_next_type(Prom_node *root, char *type)
{
	Prom_node *node;

	node = dev_next_node_by_type(root, "device_type", type);

	return (node);  /* not found */
}

/*
 * Search a device tree and return the first failed node that is found.
 * (has a 'status' property)
 */
Prom_node *
find_failed_node(Prom_node * root)
{
	Prom_node *pnode;

	if (root == NULL)
		return (NULL);

	if (node_failed(root)) {
		return (root);
	}

	/* search the child */
	if ((pnode = find_failed_node(root->child)) != NULL)
		return (pnode);

	/* search the siblings */
	if ((pnode = find_failed_node(root->sibling)) != NULL)
		return (pnode);

	return (NULL);
}	/* end of find_failed_node() */

/*
 * Start from the current node and return the next node besides
 * the current one which is failed. (has a 'status' property)
 */
Prom_node *
next_failed_node(Prom_node * root)
{
	Prom_node *pnode;
	Prom_node *parent;

	if (root == NULL)
		return (NULL);

	/* search the child */
	if ((pnode = find_failed_node(root->child)) != NULL) {
		return (pnode);
	}

	/* search the siblings */
	if ((pnode = find_failed_node(root->sibling)) != NULL) {
		return (pnode);
	}

	/* backtracking the search up through parents' siblings */
	parent = root->parent;
	while (parent != NULL) {
		if ((pnode = find_failed_node(parent->sibling)) != NULL)
			return (pnode);
		else
			parent = parent->parent;
	}

	return (NULL);
}	/* end of find_failed_node() */

/*
 * node_failed
 *
 * This function determines if the current Prom node is failed. This
 * is defined by having a status property containing the token 'fail'.
 */
int
node_failed(Prom_node *node)
{
	return (node_status(node, "fail"));
}

int
node_status(Prom_node *node, char *status)
{
	void *value;

	if (status == NULL)
		return (0);

	/* search the local node */
	if ((value = get_prop_val(find_prop(node, "status"))) != NULL) {
		if ((value != NULL) && strstr((char *)value, status))
			return (1);
	}
	return (0);
}

/*
 * Get a property's value. Must be void * since the property can
 * be any data type. Caller must know the *PROPER* way to use this
 * data.
 */
void *
get_prop_val(Prop *prop)
{
	if (prop == NULL)
		return (NULL);

	if (prop->value.opp.holds_array)
		return ((void *)(prop->value.opp.oprom_array));
	else
		return ((void *)(&prop->value.opp.oprom_node[0]));
}	/* end of get_prop_val() */

/*
 * 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) {
		(void) printf("%s", dgettext(TEXT_DOMAIN, "Prom node has "
			"no properties\n"));
		return (NULL);
	}

	prop = pnode->props;
	while ((prop != NULL) && (strcmp(prop->name.opp.oprom_array, name)))
		prop = prop->next;

	return (prop);
}

/*
 * 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;
	Board_node *bnode;
	Prom_node *p;

	/* add this node to the Board list of the appropriate board */
	if ((board = get_board_num(pnode)) == -1) {
		/* board is 0 if not on Sunfire */
		board = 0;
	}

	/* find the node with the same board number */
	if ((bnode = find_board(root, board)) == NULL) {
		bnode = insert_board(root, board);
		bnode->board_type = UNKNOWN_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;
	}

}

/*
 * Find the device on the current board with the requested device ID
 * and name. If this rountine is passed a NULL pointer, it simply returns
 * NULL.
 */
Prom_node *
find_device(Board_node *board, int id, char *name)
{
	Prom_node *pnode;
	int mask;

	/* find the first cpu node */
	pnode = dev_find_node(board->nodes, name);

	mask = 0x1F;
	while (pnode != NULL) {
		if ((get_id(pnode) & mask) == id)
			return (pnode);

		pnode = dev_next_node(pnode, name);
	}
	return (NULL);
}

Prom_node *
dev_find_node_by_type(Prom_node *root, char *type, char *property)
{
	Prom_node *node;
	char *type_prop;

	if (root == NULL || property == NULL)
		return (NULL);

	type_prop = (char *)get_prop_val(find_prop(root, type));

	if (type_prop != NULL) {
		if (strcmp(type_prop, property) == 0) {
			return (root);
		}
	}

	/* look at your children first */
	if ((node = dev_find_node_by_type(root->child, type,
	    property)) != NULL)
		return (node);

	/* now look at your siblings */
	if ((node = dev_find_node_by_type(root->sibling, type,
	    property)) != NULL)
		return (node);

	return (NULL);	/* not found */
}

Prom_node *
dev_next_node_by_type(Prom_node *root, char *type, char *property)
{
	Prom_node *node;

	if (root == NULL || property == NULL)
		return (NULL);

	/* look at your children first */
	if ((node = dev_find_node_by_type(root->child, type,
	    property)) != NULL)
		return (node);

	/* now look at your siblings */
	if ((node = dev_find_node_by_type(root->sibling, type,
	    property)) != NULL)
		return (node);

	/* now look at papa's siblings */
	if ((node = dev_find_node_by_type(root->parent->sibling,
	    type, property)) != NULL)
		return (node);

	return (NULL);  /* not found */
}

/*
 * Do a depth-first walk of a device tree and
 * return the first node with the matching compatible.
 */
Prom_node *
dev_find_node_by_compatible(Prom_node *root, char *compatible)
{
	Prom_node *node;
	Prop	*prop;
	char	*compatible_array;
	int	size, nbytes;

	if (root == NULL || compatible == NULL)
		return (NULL);

	if ((prop = find_prop(root, "compatible")) != NULL &&
	    (compatible_array = (char *)get_prop_val(prop)) != NULL) {
		/*
		 * The Prop structure returned by find_prop() is supposed
		 * to contain an indication of how big the value of the
		 * compatible property is.  Since it is an array of strings
		 * this is our only means of determining just how many
		 * strings might be in this property.  However, this size
		 * is often left as zero even though there is at least one
		 * string present.  When this is the case, all we can do
		 * is examine the first string in the compatible property.
		 */

		for (size = prop->size; size >= 0; size -= nbytes) {
			if (strcmp(compatible_array, compatible) == 0)
				return (root);		/* found a match */

			nbytes = strlen(compatible_array) + 1;
			compatible_array += nbytes;
		}
	}

	node = dev_find_node_by_compatible(root->child, compatible);
	if (node != NULL)
		return (node);

	/*
	 * Note the very deliberate use of tail recursion here.	 A good
	 * compiler (such as Sun's) will recognize this and generate code
	 * that does not allocate another stack frame.	Instead, it will
	 * overlay the existing stack frame with the new one, the only change
	 * having been to replace the original root with its sibling.
	 * This has the potential to create some confusion for anyone
	 * trying to debug this code from a core dump, since the stack
	 * trace will not reveal recursion on siblings, only on children.
	 */

	return (dev_find_node_by_compatible(root->sibling, compatible));
}

/*
 * Start from the current node and return the next node besides
 * the current one which has the requested compatible property.
 */
Prom_node *
dev_next_node_by_compatible(Prom_node *root, char *compatible)
{
	Prom_node *node;

	if (root == NULL || compatible == NULL)
		return (NULL);

	node = dev_find_node_by_compatible(root->child, compatible);
	if (node != NULL)
		return (node);

	/*
	 * More tail recursion.	 Even though it is a different function,
	 * this will overlay the current stack frame.  Caveat exterminator.
	 */

	node = dev_find_node_by_compatible(root->sibling, compatible);
	if (node != NULL)
		return (node);

	return (dev_find_node_by_compatible(root->parent->sibling, compatible));
}