usr/src/lib/libdevice/devctl.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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/nvpair.h>
#include "libdevice.h"

static int _libdevice_debug = 0;
static const char *devctl_minorname = ":devctl";
static const char *nullptr = "<null>";
static const char *devctl_target_raw = "a,raw";

typedef enum { DEVCTL_BUS, DEVCTL_DEVICE, DEVCTL_AP, DEVCTL_CLONE,
    DEVCTL_PM_DEV, DEVCTL_PM_BUS } dc_type_t;

/*
 * devctl_hdl structures are allocated by the devctl_XX_acquire()
 * interfaces and passed to the remaining interfaces in this library.
 */
struct devctl_hdl {
	char		*opath;		/* copy of the original path */
	dc_type_t	hdltype;	/* handle type */
	int		fd;		/* nexus device node */
	char		*nodename;	/* DEVCTL_DEVICE handles only */
	char		*unitaddr;	/* DEVCTL_DEVICE handles only */
};
#define	DCP(x)	((struct devctl_hdl *)(x))

static int dc_cmd(uint_t, uint_t, struct devctl_hdl *, nvlist_t *, void *);
static devctl_hdl_t dc_mkhndl(dc_type_t, char *, uint_t, devctl_hdl_t);


#pragma init(_libdevice_init)
void
_libdevice_init()
{
	_libdevice_debug = getenv("LIBDEVICE_DEBUG") != NULL;
}

/*
 * release a devctl_hdl structure
 */
void
devctl_release(devctl_hdl_t hdl)
{
	if (_libdevice_debug)
		(void) printf("devctl_release: %p\n", (void *)hdl);

	if (hdl == NULL)
		return;

	if (DCP(hdl)->fd != -1)
		(void) close(DCP(hdl)->fd);

	if (DCP(hdl)->opath != NULL)
		free(DCP(hdl)->opath);

	if (DCP(hdl)->nodename != NULL)
		free(DCP(hdl)->nodename);

	if (DCP(hdl)->unitaddr != NULL)
		free(DCP(hdl)->unitaddr);

	free(hdl);
}

/*
 * construct a handle suitable for devctl_bus_*() operations
 */
devctl_hdl_t
devctl_bus_acquire(char *devfs_path, uint_t flags)
{
	uint_t oflags;

	if (_libdevice_debug)
		(void) printf("devctl_bus_acquire: %s (%d)\n",
			((devfs_path != NULL) ? devfs_path : nullptr), flags);

	if ((devfs_path == NULL) || ((flags != 0) && (flags != DC_EXCL))) {
		errno = EINVAL;
		return (NULL);
	}

	oflags = ((flags & DC_EXCL) != 0) ? O_EXCL|O_RDWR : O_RDWR;
	return (dc_mkhndl(DEVCTL_BUS, devfs_path, oflags, NULL));
}


/*
 * construct a handle suitable for devctl_bus_*() and
 * devctl_device_*() operations.
 */
devctl_hdl_t
devctl_device_acquire(char *devfs_path, uint_t flags)
{
	uint_t oflags;

	if (_libdevice_debug)
		(void) printf("devctl_device_acquire: %s (%d)\n",
		    ((devfs_path != NULL) ? devfs_path : nullptr), flags);

	if ((devfs_path == NULL) || ((flags != 0) && (flags != DC_EXCL))) {
		errno = EINVAL;
		return (NULL);
	}

	oflags = ((flags & DC_EXCL) != 0) ? O_EXCL|O_RDWR : O_RDWR;
	return (dc_mkhndl(DEVCTL_DEVICE, devfs_path, oflags, NULL));
}


/*
 * given a devfs (/devices) pathname to an attachment point device,
 * access the device and return a handle to be passed to the
 * devctl_ap_XXX() functions.
 */
devctl_hdl_t
devctl_ap_acquire(char *devfs_path, uint_t flags)
{
	uint_t oflags;

	if (_libdevice_debug)
		(void) printf("devctl_ap_acquire: %s (%d)\n",
		    ((devfs_path != NULL) ? devfs_path : nullptr), flags);

	if ((devfs_path == NULL) ||
	    ((flags != 0) && ((flags & DC_EXCL) != 0) &&
	    ((flags & DC_RDONLY) != 0))) {
		errno = EINVAL;
		return (NULL);
	}

	oflags = ((flags & DC_EXCL) != 0) ? O_EXCL : 0;
	oflags |= ((flags & DC_RDONLY) != 0) ? O_RDONLY : O_RDWR;

	return (dc_mkhndl(DEVCTL_AP, devfs_path, oflags, NULL));
}


/*
 * given a devfs (/devices) pathname access the device and return
 * a handle to be passed to the devctl_pm_XXX() functions.
 * The minor name ":devctl" is appended.
 */
devctl_hdl_t
devctl_pm_bus_acquire(char *devfs_path, uint_t flags)
{
	uint_t oflags;

	if (_libdevice_debug)
		(void) printf("devctl_pm_bus_acquire: %s (%d)\n",
		    ((devfs_path != NULL) ? devfs_path : nullptr), flags);

	if ((devfs_path == NULL) || ((flags != 0) && (flags != DC_EXCL))) {
		errno = EINVAL;
		return (NULL);
	}

	oflags = ((flags & DC_EXCL) != 0) ? (O_EXCL | O_RDWR) : O_RDWR;
	return (dc_mkhndl(DEVCTL_PM_BUS, devfs_path, oflags, NULL));
}


/*
 * given a devfs (/devices) pathname access the device and return
 * a handle to be passed to the devctl_pm_XXX() functions.
 * The minor name is derived from the device name.
 */
devctl_hdl_t
devctl_pm_dev_acquire(char *devfs_path, uint_t flags)
{
	uint_t oflags;

	if (_libdevice_debug)
		(void) printf("devctl_pm_dev_acquire: %s (%d)\n",
		    ((devfs_path != NULL) ? devfs_path : nullptr), flags);

	if ((devfs_path == NULL) || ((flags != 0) && (flags != DC_EXCL))) {
		errno = EINVAL;
		return (NULL);
	}

	oflags = ((flags & DC_EXCL) != 0) ? (O_EXCL | O_RDWR) : O_RDWR;
	return (dc_mkhndl(DEVCTL_PM_DEV, devfs_path, oflags, NULL));
}


/*
 * allocate and initalize the devctl_hdl structure for the
 * particular handle type.
 */
static devctl_hdl_t
dc_mkhndl(dc_type_t type, char *path, uint_t oflags, devctl_hdl_t pc)
{
	struct devctl_hdl *dcp;
	struct stat sb;
	char iocpath[MAXPATHLEN];
	char *nodename, *unitsep, *minorsep, *chop;
	char *minorname;
	size_t strlcpy_size;
	char *iocpath_dup;
	char *tok;

	if ((path == NULL) || (strlen(path) > MAXPATHLEN - 1)) {
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * allocate handle and make a copy of the original path
	 */
	if ((dcp = calloc(1, sizeof (*dcp))) == NULL) {
		errno = ENOMEM;
		return (NULL);
	}
	if ((dcp->opath = strdup(path)) == NULL) {
		devctl_release((devctl_hdl_t)dcp);
		errno = ENOMEM;
		return (NULL);
	}

	(void) strcpy(iocpath, path);
	dcp->hdltype = type;
	dcp->fd = -1;

	/*
	 * break apart the pathname according to the type handle
	 */
	switch (type) {
	case DEVCTL_PM_BUS:
		/*
		 * chop off any minor name and concatenate the
		 * ":devctl" minor node name string.
		 */
		if ((chop = strrchr(iocpath, ':')) != NULL)
			*chop = '\0';

		if (strlcat(iocpath, devctl_minorname, MAXPATHLEN) >=
		    MAXPATHLEN) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		} else if (_libdevice_debug) {
			(void) printf("DEVCTL_PM_BUS: iocpath %s\n", iocpath);
		}
		break;

	case DEVCTL_PM_DEV:
		/*
		 * Chop up the last device component in the pathname.
		 * Concatenate either the device name itself, or the
		 * "a,raw" string, as the minor node name, to the iocpath.
		 */
		if ((iocpath_dup = strdup(iocpath)) == NULL) {
			devctl_release((devctl_hdl_t)dcp);
			errno = ENOMEM;
			return (NULL);
		}
		if ((chop = strrchr(iocpath_dup, '/')) == NULL) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		}
		*chop = '\0';
		nodename = chop + 1;

		/*
		 * remove the "@0,0" string
		 */
		tok = strtok(nodename, "@");
		if ((minorname = malloc(strlen(tok) +1)) == NULL) {
			if (_libdevice_debug)
				(void) printf("DEVCTL_PM_DEV: failed malloc for"
				    " minorname\n");
			devctl_release((devctl_hdl_t)dcp);
			errno = ENOMEM;
			return (NULL);
		}
		(void) strcpy(minorname, tok);
		if (_libdevice_debug) {
			(void) printf("DEVCTL_PM_DEV: minorname %s\n",
			    minorname);
		}

		/*
		 * construct the name of the ioctl device
		 * by concatenating either ":a,raw" or ":"minorname
		 */
		(void) strlcat(iocpath, ":", MAXPATHLEN);
		if (strcmp(minorname, "disk_chan") == 0 ||
		    strcmp(minorname, "disk_wwn") == 0 ||
		    strcmp(minorname, "disk_cdrom") == 0) {
			strlcpy_size = strlcat(iocpath, devctl_target_raw,
			    MAXPATHLEN);
		} else {
			strlcpy_size = strlcat(iocpath, minorname, MAXPATHLEN);
		}
		if (strlcpy_size >= MAXPATHLEN) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		} else if (_libdevice_debug) {
			(void) printf("DEVCTL_PM_DEV: iocpath %s\n",
			    iocpath);
		}
		break;

	case DEVCTL_AP:
		/*
		 * take the pathname as provided.
		 */
		break;

	case DEVCTL_BUS:
		/*
		 * chop off any minor name and concatenate the
		 * ":devctl" minor node name string.
		 */
		if ((chop = strrchr(iocpath, ':')) != NULL)
			*chop = '\0';

		if (strlcat(iocpath, devctl_minorname, MAXPATHLEN) >=
		    MAXPATHLEN) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		}
		break;

	case DEVCTL_CLONE:
		/*
		 * create a device handle for a new device created
		 * from a call to devctl_bus_dev_create()
		 */
		dcp->hdltype = DEVCTL_DEVICE;

		/* FALLTHRU */

	case DEVCTL_DEVICE:

		/*
		 * Chop up the last device component in the pathname.
		 * The componets are passed as nodename and unitaddr
		 * in the IOCTL data for DEVCTL ops on devices.
		 */
		if ((chop = strrchr(iocpath, '/')) == NULL) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		}
		*chop = '\0';

		nodename = chop + 1;
		unitsep = strchr(nodename, '@');
		minorsep = strchr(nodename, ':');

		if (unitsep == NULL) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		}

		/*
		 * copy the nodename and unit address
		 */
		if (((dcp->nodename = malloc(MAXNAMELEN)) == NULL) ||
		    ((dcp->unitaddr = malloc(MAXNAMELEN)) == NULL)) {
			devctl_release((devctl_hdl_t)dcp);
			errno = ENOMEM;
			return (NULL);
		}
		*unitsep = '\0';
		if (minorsep != NULL)
			*minorsep = '\0';
		(void) snprintf(dcp->nodename, MAXNAMELEN, "%s", nodename);
		(void) snprintf(dcp->unitaddr, MAXNAMELEN, "%s", unitsep+1);

		/*
		 * construct the name of the ioctl device
		 */
		if (strlcat(iocpath, devctl_minorname, MAXPATHLEN) >=
		    MAXPATHLEN) {
			devctl_release((devctl_hdl_t)dcp);
			errno = EINVAL;
			return (NULL);
		}
		break;

	default:
		devctl_release((devctl_hdl_t)dcp);
		errno = EINVAL;
		return (NULL);
	}

	if (_libdevice_debug)
		(void) printf("dc_mkhndl: iocpath %s ", iocpath);

	/*
	 * verify the devctl or ap device exists and is a
	 * character device interface.
	 */
	if (stat(iocpath, &sb) == 0) {
		if ((sb.st_mode & S_IFMT) != S_IFCHR) {
			if (_libdevice_debug)
				(void) printf(" - not character device\n");
			errno = ENODEV;
			devctl_release((devctl_hdl_t)dcp);
			return (NULL);
		}
	} else {
		/*
		 * return failure with errno value set by stat
		 */
		if (_libdevice_debug)
			(void) printf(" - stat failed\n");
		devctl_release((devctl_hdl_t)dcp);
		return (NULL);
	}

	/*
	 * if this was a new device, dup the parents handle, otherwise
	 * just open the device.
	 */
	if (type == DEVCTL_CLONE)
		dcp->fd = dup(DCP(pc)->fd);
	else
		dcp->fd = open(iocpath, oflags);

	if (dcp->fd == -1) {
		if (_libdevice_debug)
			(void) printf(" - open/dup failed %d\n", errno);
		/*
		 * leave errno as set by open/dup
		 */
		devctl_release((devctl_hdl_t)dcp);
		return (NULL);
	}

	if (_libdevice_debug)
		(void) printf(" - open success\n");

	return ((devctl_hdl_t)dcp);
}

/*
 * Power up component 0, to level MAXPWR, via a pm_raise_power() call
 */
int
devctl_pm_raisepower(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_RAISE_PWR, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_raisepower: %d\n", rv);

	return (rv);
}

/*
 * Power up component 0, to level MAXPWR, via a power_has_changed() call
 */
int
devctl_pm_changepowerhigh(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_CHANGE_PWR_HIGH, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_changepowerhigh: %d\n", rv);

	return (rv);
}

/*
 * Power down component 0, to level 0, via a pm_change_power() call
 */
int
devctl_pm_changepowerlow(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_CHANGE_PWR_LOW, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_changepowerlow: %d\n", rv);

	return (rv);
}

/*
 * mark component 0 idle
 */
int
devctl_pm_idlecomponent(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_IDLE_COMP, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_idlecomponent: %d\n", rv);

	return (rv);
}

/*
 * mark component 0 busy
 */
int
devctl_pm_busycomponent(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_BUSY_COMP, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_busycomponent: %d\n", rv);

	return (rv);
}

/*
 * test pm busy state
 */
int
devctl_pm_testbusy(devctl_hdl_t dcp, uint_t *busystate)
{
	int  rv;
	uint_t	busy_state = 0;

	if (busystate == NULL) {
		errno = EINVAL;
		return (-1);
	}

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_BUSY_COMP_TEST, 0, DCP(dcp), NULL,
	    (void *)&busy_state);

	if (rv == -1)
		*busystate = 0;
	else
		*busystate = busy_state;

	if (_libdevice_debug)
		(void) printf("devctl_pm_bus_testbusy: rv %d busystate %x\n",
		    rv, *busystate);

	return (rv);
}

/*
 * set flag to fail DDI_SUSPEND
 */
int
devctl_pm_failsuspend(devctl_hdl_t dcp)
{
	int rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_FAIL_SUSPEND, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_failsuspend: %d\n", rv);
	return (rv);
}

int
devctl_pm_bus_teststrict(devctl_hdl_t dcp, uint_t *strict)
{
	int  rv;
	uint_t	strict_state;

	if (strict == NULL) {
		errno = EINVAL;
		return (-1);
	}

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_BUS_STRICT_TEST, 0, DCP(dcp), NULL,
	    (void *)&strict_state);

	if (rv == -1)
		*strict = 0;
	else
		*strict = strict_state;

	if (_libdevice_debug)
		(void) printf("devctl_pm_bus_teststrict: rv %d strict %x\n",
		    rv, *strict);

	return (rv);
}

/*
 * issue prom_printf() call
 */
int
devctl_pm_device_promprintf(devctl_hdl_t dcp)
{
	int rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_PROM_PRINTF, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_device_promprintf: %d\n", rv);
	return (rv);
}

/*
 * set flag to power up the device via
 * pm_power_has_changed() calls vs.
 * pm_raise_power(), during DDI_RESUME
 */
int
devctl_pm_device_changeonresume(devctl_hdl_t dcp)
{
	int rv;

	if (dcp == NULL || (DCP(dcp)->hdltype != DEVCTL_PM_DEV &&
	    DCP(dcp)->hdltype != DEVCTL_PM_BUS)) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME, 0,
	    DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_device_changeonresume: %d\n", rv);
	return (rv);
}

/*
 * issue DEVCTL_PM_NO_LOWER_POWER to clear the LOWER_POWER_FLAG
 * flag: pm_lower_power() will not be called on device detach
 */
int
devctl_pm_device_no_lower_power(devctl_hdl_t dcp)
{
	int rv;

	if (dcp == NULL || DCP(dcp)->hdltype != DEVCTL_PM_DEV) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_NO_LOWER_POWER, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_device_no_lower_power: %d\n", rv);
	return (rv);
}

/*
 * issue DEVCTL_PM_BUS_NO_INVOL ioctl to set the NO_INVOL_FLAG
 * flag: parent driver will mark itself idle twice in
 * DDI_CTLOPS_DETACH(POST)
 */
int
devctl_pm_bus_no_invol(devctl_hdl_t dcp)
{
	int rv;

	if (dcp == NULL || DCP(dcp)->hdltype != DEVCTL_PM_BUS) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_PM_BUS_NO_INVOL, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_pm_bus_no_invol: %d\n", rv);
	return (rv);
}

/*
 * Place the device ONLINE
 */
int
devctl_device_online(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || DCP(dcp)->hdltype != DEVCTL_DEVICE) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_DEVICE_ONLINE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_device_online: %d\n", rv);

	return (rv);
}

/*
 * take device OFFLINE
 */
int
devctl_device_offline(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || DCP(dcp)->hdltype != DEVCTL_DEVICE) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_DEVICE_OFFLINE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_device_offline: %d\n", rv);

	return (rv);
}

/*
 * take the device OFFLINE and remove its dev_info node
 */
int
devctl_device_remove(devctl_hdl_t dcp)
{
	int  rv;

	if (dcp == NULL || DCP(dcp)->hdltype != DEVCTL_DEVICE) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_DEVICE_REMOVE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_device_remove: %d\n", rv);

	return (rv);
}


/*
 * QUIESCE the bus
 */
int
devctl_bus_quiesce(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_BUS_QUIESCE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_bus_quiesce: %d\n", rv);

	return (rv);
}

int
devctl_bus_unquiesce(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_BUS_UNQUIESCE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_bus_unquiesce: %d\n", rv);

	return (rv);
}

int
devctl_bus_reset(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_BUS_RESET, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_bus_reset: %d\n", rv);

	return (rv);
}

int
devctl_bus_resetall(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_BUS_RESETALL, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_bus_resetall: %d\n", rv);

	return (rv);
}

int
devctl_device_reset(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_DEVICE_RESET, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_device_reset: %d\n", rv);

	return (rv);
}

int
devctl_device_getstate(devctl_hdl_t dcp, uint_t *devstate)
{
	int  rv;
	uint_t device_state;

	if (devstate == NULL) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_DEVICE_GETSTATE, 0, DCP(dcp), NULL,
	    (void *)&device_state);

	if (rv == -1)
		*devstate = 0;
	else
		*devstate = device_state;

	if (_libdevice_debug)
		(void) printf("devctl_device_getstate: rv %d state %x\n",
		    rv, *devstate);

	return (rv);
}

int
devctl_bus_getstate(devctl_hdl_t dcp, uint_t *devstate)
{
	int  rv;
	uint_t device_state;

	if (devstate == NULL) {
		errno = EINVAL;
		return (-1);
	}

	rv = dc_cmd(DEVCTL_BUS_GETSTATE, 0, DCP(dcp), NULL,
	    (void *)&device_state);

	if (rv == -1)
		*devstate = 0;
	else
		*devstate = device_state;

	if (_libdevice_debug)
		(void) printf("devctl_bus_getstate: rv %d, state %x\n",
		    rv, *devstate);

	return (rv);
}

int
devctl_bus_configure(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_BUS_CONFIGURE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_bus_configure: %d\n", rv);

	return (rv);
}

int
devctl_bus_unconfigure(devctl_hdl_t dcp)
{
	int  rv;

	rv = dc_cmd(DEVCTL_BUS_UNCONFIGURE, 0, DCP(dcp), NULL, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_bus_unconfigure: %d\n", rv);

	return (rv);
}

/*
 * devctl_bus_dev_create() - create a new child device
 * Attempt to construct and attach a new child device below a
 * bus nexus (dcp).  The device is defined using the devctl_ddef_*()
 * routines to specify the set of bus-specific properties required
 * to initalize and attach the device.
 */
int
devctl_bus_dev_create(devctl_hdl_t dcp, devctl_ddef_t ddef_hdl,
    uint_t flags, devctl_hdl_t *new_dcp)
{
	char devname[MAXNAMELEN];
	char devpath[MAXPATHLEN];
	int  rv = 0;

	if (dcp == NULL || ddef_hdl == NULL) {
		errno = EINVAL;
		return (-1);
	}

	(void) memset(devname, 0, sizeof (devname));
	rv = dc_cmd(DEVCTL_BUS_DEV_CREATE, flags, DCP(dcp),
	    (nvlist_t *)ddef_hdl, devname);

	/*
	 * construct a device handle for the new device
	 */
	if ((rv == 0) && (new_dcp != NULL)) {
		char *minorname, *lastslash;

		(void) memset(devpath, 0, sizeof (devpath));
		(void) strcat(devpath, DCP(dcp)->opath);

		/*
		 * Take the pathname of the parent device, chop off
		 * any minor name info, and append the name@addr of
		 * the new child device.
		 * Call dc_mkhndl() with this constructed path and
		 * the CLONE handle type to create a new handle which
		 * references the new child device.
		 */
		lastslash = strrchr(devpath, '/');
		if (*(lastslash + 1) == '\0') {
			*lastslash = '\0';
		} else {
			if ((minorname = strchr(lastslash, ':')) != NULL)
				*minorname = '\0';
		}
		(void) strcat(devpath, "/");
		(void) strlcat(devpath, devname, MAXPATHLEN);
		*new_dcp = dc_mkhndl(DEVCTL_CLONE, devpath, 0, dcp);
		if (*new_dcp == NULL)
			rv = -1;
	}

	return (rv);
}

int
devctl_ap_connect(devctl_hdl_t dcp, nvlist_t *ap_data)
{
	int  rv;

	rv = dc_cmd(DEVCTL_AP_CONNECT, 0, DCP(dcp), ap_data, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_ap_connect: %d\n", rv);

	return (rv);
}

int
devctl_ap_disconnect(devctl_hdl_t dcp, nvlist_t *ap_data)
{
	int  rv;

	rv = dc_cmd(DEVCTL_AP_DISCONNECT, 0, DCP(dcp), ap_data, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_ap_disconnect: %d\n", rv);

	return (rv);
}

int
devctl_ap_insert(devctl_hdl_t dcp, nvlist_t *ap_data)
{
	int  rv;

	rv = dc_cmd(DEVCTL_AP_INSERT, 0, DCP(dcp), ap_data, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_ap_insert: %d\n", rv);

	return (rv);
}

int
devctl_ap_remove(devctl_hdl_t dcp, nvlist_t *ap_data)
{
	int  rv;

	rv = dc_cmd(DEVCTL_AP_REMOVE, 0, DCP(dcp), ap_data, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_ap_remove: %d\n", rv);

	return (rv);
}

int
devctl_ap_configure(devctl_hdl_t dcp, nvlist_t *ap_data)
{
	int  rv;

	rv = dc_cmd(DEVCTL_AP_CONFIGURE, 0, DCP(dcp), ap_data, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_ap_configure: %d\n", rv);

	return (rv);
}

int
devctl_ap_unconfigure(devctl_hdl_t dcp, nvlist_t *ap_data)
{
	int  rv;

	rv = dc_cmd(DEVCTL_AP_UNCONFIGURE, 0, DCP(dcp), ap_data, NULL);

	if (_libdevice_debug)
		(void) printf("devctl_ap_unconfigure: %d\n", rv);

	return (rv);
}

int
devctl_ap_getstate(devctl_hdl_t dcp, nvlist_t *ap_data,
    devctl_ap_state_t *apstate)
{
	int  rv;
	devctl_ap_state_t ap_state;

	rv = dc_cmd(DEVCTL_AP_GETSTATE, 0, DCP(dcp), ap_data,
	    (void *)&ap_state);

	if (rv == -1)
		(void) memset(apstate, 0, sizeof (struct devctl_ap_state));
	else
		*apstate = ap_state;

	if (_libdevice_debug)
		(void) printf("devctl_ap_getstate: %d\n", rv);

	return (rv);
}

/*
 * Allocate a device 'definition' handle, in reality a list of
 * nvpair data.
 */
/* ARGSUSED */
devctl_ddef_t
devctl_ddef_alloc(char *nodename, int flags)
{

	nvlist_t *nvlp;

	if ((nodename == NULL) || *nodename == '\0') {
		errno = EINVAL;
		return (NULL);
	}

	/*
	 * allocate nvlist structure which is returned as an
	 * opaque handle to the caller.  If this fails, return
	 * NULL with errno left set to the value
	 */
	if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME_TYPE, 0) != 0) {
		errno = ENOMEM;
		return (NULL);
	}

	/*
	 * add the nodename of the new device to the list
	 */
	if (nvlist_add_string(nvlp, DC_DEVI_NODENAME, nodename) != 0) {
		nvlist_free(nvlp);
		errno = ENOMEM;
		return (NULL);
	}

	if (_libdevice_debug)
		(void) printf("devctl_ddef_alloc: node %s nvp %p\n", nodename,
		    (void *)nvlp);

	return ((devctl_ddef_t)nvlp);
}

/*
 * free the definition handle
 */
void
devctl_ddef_free(devctl_ddef_t ddef_hdl)
{
	if (_libdevice_debug)
		(void) printf("devctl_ddef_free: nvp %p\n", (void *)ddef_hdl);

	if (ddef_hdl != NULL) {
		nvlist_free((nvlist_t *)ddef_hdl);
	}
}

/*
 * define an integer property
 */
int
devctl_ddef_int(devctl_ddef_t ddef_hdl, char *name, int32_t value)
{

	int rv;

	if (ddef_hdl == NULL || name == NULL || *name == '\0') {
		errno = EINVAL;
		return (-1);
	}

	rv = nvlist_add_int32((nvlist_t *)ddef_hdl, name, value);

	if (_libdevice_debug)
		(void) printf("devctl_ddef_int: rv %d nvp %p name %s val %d\n",
		    rv, (void *)ddef_hdl, name, value);

	return (rv);
}

/*
 * define an integer array property
 */
int
devctl_ddef_int_array(devctl_ddef_t ddef_hdl, char *name, int nelements,
    int32_t *value)
{
	int rv, i;

	if (ddef_hdl == NULL || name == NULL || *name == '\0') {
		errno = EINVAL;
		return (-1);
	}

	rv = nvlist_add_int32_array((nvlist_t *)ddef_hdl, name, value,
	    nelements);

	if (_libdevice_debug) {
		(void) printf("devctl_ddef_int_array: rv %d nvp %p name %s: ",
		    rv, (void *)ddef_hdl, name);
		for (i = 0; i < nelements; i++)
			(void) printf("0x%x ", value[i]);
		(void) printf("\n");
	}

	return (rv);
}

/*
 * define a string property
 */
int
devctl_ddef_string(devctl_ddef_t ddef_hdl, char *name, char *value)
{
	int rv;

	if (ddef_hdl == NULL || name == NULL || *name == '\0') {
		errno = EINVAL;
		return (-1);
	}

	rv = nvlist_add_string((nvlist_t *)ddef_hdl, name, value);

	if (_libdevice_debug)
		(void) printf("devctl_ddef_string: rv %d nvp %p %s=\"%s\"\n",
		    rv, (void *)ddef_hdl, name, value);

	return (rv);
}

/*
 * define a string array property
 */
int
devctl_ddef_string_array(devctl_ddef_t ddef_hdl, char *name, int nelements,
    char **value)
{
	int rv, i;

	if (ddef_hdl == NULL || name == NULL || *name == '\0') {
		errno = EINVAL;
		return (-1);
	}

	rv = nvlist_add_string_array((nvlist_t *)ddef_hdl, name,
	    value, nelements);

	if (_libdevice_debug) {
		(void) printf("devctl_ddef_string_array: rv %d nvp %p "
		    "name %s:\n", rv, (void *)ddef_hdl, name);
		for (i = 0; i < nelements; i++)
			(void) printf("\t%d: \"%s\"\n", i, value[i]);
	}
	return (rv);
}

/*
 * define a byte array property
 */
int
devctl_ddef_byte_array(devctl_ddef_t ddef_hdl, char *name, int nelements,
    uchar_t *value)
{
	int rv;

	if (ddef_hdl == NULL || name == NULL || *name == '\0') {
		errno = EINVAL;
		return (-1);
	}

	rv = nvlist_add_byte_array((nvlist_t *)ddef_hdl, name, value,
	    nelements);

	return (rv);
}

/*
 * return the pathname which was used to acquire the handle
 */
char *
devctl_get_pathname(devctl_hdl_t dcp, char *pathbuf, size_t bufsz)
{
	if (dcp == NULL || pathbuf == NULL || bufsz == 0) {
		errno = EINVAL;
		return (NULL);
	}

	(void) snprintf(pathbuf, bufsz, "%s", DCP(dcp)->opath);
	return (pathbuf);
}


/*
 * execute the IOCTL request
 */
static int
dc_cmd(uint_t cmd, uint_t flags, struct devctl_hdl *dcp, nvlist_t *ulp,
    void *retinfo)
{
	struct devctl_iocdata iocdata;
	int  rv = 0;

	if (_libdevice_debug)
		(void) printf("dc_cmd: %x dcp %p ulp %p flags %x rv %p\n", cmd,
		    (void *)dcp, (void *)ulp, flags, retinfo);

	if ((dcp == NULL) || (DCP(dcp)->fd == -1)) {
		errno = EINVAL;
		return (-1);
	}

	(void) memset(&iocdata, 0, sizeof (struct devctl_iocdata));

	/*
	 * if there was any user supplied data in the form of a nvlist,
	 * pack the list prior to copyin.
	 */
	if (ulp != NULL) {
		if (rv = nvlist_pack(ulp, (char **)&iocdata.nvl_user,
		    &iocdata.nvl_usersz, NV_ENCODE_NATIVE, 0)) {
			/*
			 * exit with errno set by nvlist_pack()
			 */
			goto exit;
		}
	} else {
		iocdata.nvl_user = NULL;
		iocdata.nvl_usersz = 0;
	}

	/*
	 * finish initalizing the request and execute the IOCTL
	 */
	iocdata.cmd = cmd;
	iocdata.flags = flags;
	iocdata.c_nodename = dcp->nodename;
	iocdata.c_unitaddr = dcp->unitaddr;
	iocdata.cpyout_buf = retinfo;
	rv = ioctl(dcp->fd, cmd, &iocdata);
	if (rv < 0 && _libdevice_debug) {
		(void) printf("dc_cmd: exited with rv %d, errno(%d):%s\n",
		    rv, errno, strerror(errno));
	}

exit:
	if (iocdata.nvl_user != NULL)
		free(iocdata.nvl_user);

	return (rv);
}