Gitiles
Code Review Sign In
code.illumos.org / illumos-gate / bbb9d5d65bf8372aae4b8821c80e218b8b832846 / . / usr / src / uts / common / io / gen_drv.c
blob: 403415a3e146faa50499779384c6c4fbe6c0a729 [file] [log] [blame]
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* generic character driver
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#define NUMEVENTS 6
#define COMPONENTS 2
#define COMP_0_MAXPWR 3
#define COMP_1_MAXPWR 2
#define MINPWR 0
static int maxpwr[] = { COMP_0_MAXPWR, COMP_1_MAXPWR };
/*
* The state for each generic device.
* NOTE: We save the node_type in the state structure. The node_type string
* (and not a copy) is stashed in a minor node by ddi_create_minor_node(),
* so ddi_remove_minor_node() must occur prior to state free.
*/
typedef struct dstate {
uint_t flag;
dev_info_t *dip; /* my devinfo handle */
char *node_type; /* stable node_type copy */
ddi_callback_id_t gen_cb_ids[NUMEVENTS];
kmutex_t lock;
char *nodename;
int level[COMPONENTS]; /* pm level */
int busy[COMPONENTS]; /* busy state */
} dstate_t;
static void *dstates;
static int gen_debug = 0;
#ifdef DEBUG
#define gen_debug gen_debug_on
static int gen_debug_on = 0;
#define GEN_DEBUG(args) if (gen_debug) cmn_err args
#else
#define GEN_DEBUG(args)
#endif
extern void prom_printf(const char *fmt, ...);
static int gen_open(dev_t *devp, int flag, int otyp, cred_t *cred);
static int gen_close(dev_t devp, int flag, int otyp, cred_t *cred);
static int gen_read(dev_t dev, struct uio *uiop, cred_t *credp);
static int gen_write(dev_t dev, struct uio *uiop, cred_t *credp);
static int gen_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
cred_t *credp, int *rvalp);
static int gen_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int gen_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static void gen_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie,
void *arg, void *impl_data);
static int gen_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
void **result);
static int gen_create_minor_nodes(dev_info_t *, struct dstate *);
static int gen_power(dev_info_t *, int, int);
static struct cb_ops gen_cb_ops = {
gen_open, /* open */
gen_close, /* close */
nodev, /* strategy */
nodev, /* print */
nodev, /* dump */
gen_read, /* read */
gen_write, /* write */
gen_ioctl, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
nochpoll, /* poll */
ddi_prop_op, /* prop_op */
NULL, /* streamtab */
D_NEW | D_MP | D_HOTPLUG, /* flag */
CB_REV, /* cb_rev */
nodev, /* aread */
nodev /* awrite */
};
static struct dev_ops gen_ops = {
DEVO_REV, /* devo_rev */
0, /* refcnt */
gen_info, /* getinfo */
nulldev, /* identify */
nulldev, /* probe */
gen_attach, /* attach */
gen_detach, /* detach */
nodev, /* reset */
&gen_cb_ops, /* driver ops */
(struct bus_ops *)0, /* bus ops */
gen_power, /* power */
ddi_quiesce_not_supported, /* devo_quiesce */
};
/*
* INST_TO_MINOR() gives the starting minor number for a given gen_drv driver
* instance. A shift left by 6 bits allows for each instance to have upto
* 64 (2^6) minor numbers. The maximum minor number allowed by the system
* is L_MAXMIN32 (0x3ffff). This effectively limits the gen_drv instance
* numbers from 0 to 0xfff for a total of 4096 instances.
*/
#define INST_TO_MINOR(i) (i << 6)
#define MINOR_TO_INST(mn) (mn >> 6)
static char *mnodetypes[] = {
"ddi_nt",
"ddi_nt:device_type",
"ddi_nt:device_class:bus_class",
"ddi_nt2",
"ddi_nt2:device_type",
"ddi_nt2:device_type:bus_class",
};
#define N_NTYPES (sizeof (mnodetypes) / sizeof (char *))
static struct modldrv modldrv = {
&mod_driverops,
"generic test driver",
&gen_ops
};
static struct modlinkage modlinkage = {
MODREV_1, &modldrv, NULL
};
/*
* flags
*/
#define OPEN_FLAG 0x001
#define PWR_HAS_CHANGED_ON_RESUME_FLAG 0x002
#define FAIL_SUSPEND_FLAG 0x004
#define PUP_WITH_PWR_HAS_CHANGED_FLAG 0x008
#define POWER_FLAG 0x010
#define LOWER_POWER_FLAG 0x020
#define NO_INVOL_FLAG 0x040
#define PM_SUPPORTED_FLAG 0x080
/*
* ioctl commands (non-devctl ioctl commands)
*/
#define GENDRV_IOCTL ('P' << 8)
#define GENDRV_IOFAULT_SIMULATE (GENDRV_IOCTL | 0)
#define GENDRV_NDI_EVENT_TEST (GENDRV_IOCTL | 1)
int
_init(void)
{
int e;
if ((e = ddi_soft_state_init(&dstates,
sizeof (struct dstate), 0)) != 0) {
return (e);
}
if ((e = mod_install(&modlinkage)) != 0) {
ddi_soft_state_fini(&dstates);
}
return (e);
}
int
_fini(void)
{
int e;
if ((e = mod_remove(&modlinkage)) != 0) {
return (e);
}
ddi_soft_state_fini(&dstates);
return (e);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
static int
gen_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance = ddi_get_instance(devi);
struct dstate *dstatep;
int rval;
int n_devs;
int n_minorcomps;
int isclone;
ddi_eventcookie_t dev_offline_cookie, dev_reset_cookie;
ddi_eventcookie_t bus_reset_cookie, bus_quiesce_cookie;
ddi_eventcookie_t bus_unquiesce_cookie, bus_test_post_cookie;
int i_init = 0;
int level_tmp;
int i;
char *pm_comp[] = {
"NAME=leaf0",
"0=D0",
"1=D1",
"2=D2",
"3=D3",
"NAME=leaf1",
"0=off",
"1=blank",
"2=on"};
char *pm_hw_state = {"needs-suspend-resume"};
switch (cmd) {
case DDI_ATTACH:
if (ddi_soft_state_zalloc(dstates, instance) !=
DDI_SUCCESS) {
cmn_err(CE_CONT, "%s%d: can't allocate state\n",
ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
dstatep = ddi_get_soft_state(dstates, instance);
dstatep->dip = devi;
mutex_init(&dstatep->lock, NULL, MUTEX_DRIVER, NULL);
n_devs = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"ndevs", 1);
isclone = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"isclone", 0);
n_minorcomps = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"ncomps", 1);
GEN_DEBUG((CE_CONT,
"%s%d attaching: n_devs=%d n_minorcomps=%d isclone=%d",
ddi_get_name(devi), ddi_get_instance(devi),
n_devs, n_minorcomps, isclone));
if (isclone) {
if (ddi_create_minor_node(devi, "gen", S_IFCHR,
INST_TO_MINOR(instance), mnodetypes[0],
isclone) != DDI_SUCCESS) {
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(dstates, instance);
cmn_err(CE_WARN, "%s%d: can't create minor "
"node", ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
rval = DDI_SUCCESS;
} else {
rval = gen_create_minor_nodes(devi, dstatep);
if (rval != DDI_SUCCESS) {
ddi_prop_remove_all(devi);
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(dstates, instance);
cmn_err(CE_WARN, "%s%d: can't create minor "
"nodes", ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
}
if (ddi_get_eventcookie(devi, "pshot_dev_offline",
&dev_offline_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, dev_offline_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[0]));
}
if (ddi_get_eventcookie(devi, "pshot_dev_reset",
&dev_reset_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, dev_reset_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[1]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_reset",
&bus_reset_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, bus_reset_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[2]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_quiesce",
&bus_quiesce_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi, bus_quiesce_cookie,
gen_event_cb, NULL, &(dstatep->gen_cb_ids[3]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_unquiesce",
&bus_unquiesce_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi,
bus_unquiesce_cookie, gen_event_cb,
NULL, &(dstatep->gen_cb_ids[4]));
}
if (ddi_get_eventcookie(devi, "pshot_bus_test_post",
&bus_test_post_cookie) == DDI_SUCCESS) {
(void) ddi_add_event_handler(devi,
bus_test_post_cookie, gen_event_cb,
NULL, &(dstatep->gen_cb_ids[5]));
}
/*
* initialize the devices' pm state
*/
mutex_enter(&dstatep->lock);
dstatep->flag &= ~OPEN_FLAG;
dstatep->flag &= ~PWR_HAS_CHANGED_ON_RESUME_FLAG;
dstatep->flag &= ~FAIL_SUSPEND_FLAG;
dstatep->flag &= ~PUP_WITH_PWR_HAS_CHANGED_FLAG;
dstatep->flag |= LOWER_POWER_FLAG;
dstatep->flag &= ~NO_INVOL_FLAG;
dstatep->flag |= PM_SUPPORTED_FLAG;
dstatep->busy[0] = 0;
dstatep->busy[1] = 0;
dstatep->level[0] = -1;
dstatep->level[1] = -1;
mutex_exit(&dstatep->lock);
/*
* stash the nodename
*/
dstatep->nodename = ddi_node_name(devi);
/*
* Check if the no-involuntary-power-cycles property
* was created. Set NO_INVOL_FLAG if so.
*/
if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip,
(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
"no-involuntary-power-cycles") == 1) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_ATTACH:\n\tno-involuntary-power-cycles"
" property was created",
ddi_node_name(devi), ddi_get_instance(devi)));
mutex_enter(&dstatep->lock);
dstatep->flag |= NO_INVOL_FLAG;
mutex_exit(&dstatep->lock);
}
/*
* Check if the dependency-property property
* was created.
*/
if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip,
(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
"dependency-property") == 1) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_ATTACH:\n\tdependency-property"
" property was created",
ddi_node_name(devi), ddi_get_instance(devi)));
}
/*
* create the pm-components property. two comps:
* 4 levels on comp0, 3 on comp 1.
* - skip for a "tape" device, clear PM_SUPPORTED_FLAG
*/
if (strcmp(ddi_node_name(devi), "tape") != 0) {
if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi,
"pm-components", pm_comp, 9) != DDI_PROP_SUCCESS) {
cmn_err(CE_WARN, "%s%d: %s\n",
ddi_node_name(devi),
ddi_get_instance(devi),
"unable to create \"pm-components\" "
" property.");
return (DDI_FAILURE);
}
} else {
mutex_enter(&dstatep->lock);
dstatep->flag &= ~PM_SUPPORTED_FLAG;
mutex_exit(&dstatep->lock);
}
/*
* Check if the pm-components property was created
*/
if (dstatep->flag & PM_SUPPORTED_FLAG) {
if (ddi_prop_exists(DDI_DEV_T_ANY, dstatep->dip,
(DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
"pm-components") != 1) {
cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t%s",
ddi_node_name(devi),
ddi_get_instance(devi),
"\"pm-components\" property does"
" not exist");
return (DDI_FAILURE);
} else {
GEN_DEBUG((CE_CONT, "%s%d: DDI_ATTACH:"
" created pm-components property",
ddi_node_name(devi),
ddi_get_instance(devi)));
}
}
/*
* create the pm-hardware-state property.
* needed to get DDI_SUSPEND and DDI_RESUME calls
*/
if (ddi_prop_update_string(DDI_DEV_T_NONE, devi,
"pm-hardware-state", pm_hw_state) != DDI_PROP_SUCCESS) {
cmn_err(CE_WARN, "%s%d: DDI_ATTACH:\n\t%s\n",
ddi_node_name(devi), ddi_get_instance(devi),
"unable to create \"pm-hardware-state\" "
" property.");
return (DDI_FAILURE);
}
/*
* set power levels to max via pm_raise_power(),
*/
mutex_enter(&dstatep->lock);
i_init = (dstatep->flag & PM_SUPPORTED_FLAG) ? 0 : COMPONENTS;
mutex_exit(&dstatep->lock);
for (i = i_init; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_ATTACH: pm_raise_power comp %d "
"to level %d", ddi_node_name(devi),
ddi_get_instance(devi), i, maxpwr[i]));
if (pm_raise_power(dstatep->dip, i, maxpwr[i]) !=
DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: DDI_ATTACH: pm_raise_power failed\n",
ddi_node_name(devi),
ddi_get_instance(devi));
dstatep->level[i] = -1;
return (DDI_FAILURE);
}
}
if (rval == DDI_SUCCESS) {
ddi_report_dev(devi);
}
return (rval);
case DDI_RESUME:
GEN_DEBUG((CE_CONT, "%s%d: DDI_RESUME", ddi_node_name(devi),
ddi_get_instance(devi)));
dstatep = ddi_get_soft_state(dstates, ddi_get_instance(devi));
if (dstatep == NULL) {
return (DDI_FAILURE);
}
/*
* Call pm_power_has_changed() if flag
* PWR_HAS_CHANGED_ON_RESUME_FLAG is set,
* then clear the flag
*/
mutex_enter(&dstatep->lock);
i_init = (dstatep->flag & PM_SUPPORTED_FLAG) ? 0 : COMPONENTS;
mutex_exit(&dstatep->lock);
if (dstatep->flag & PWR_HAS_CHANGED_ON_RESUME_FLAG) {
for (i = i_init; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_RESUME: pm_power_has_changed "
"comp %d to level %d", ddi_node_name(devi),
ddi_get_instance(devi), i, maxpwr[i]));
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[i];
dstatep->level[i] = maxpwr[i];
if (pm_power_has_changed(dstatep->dip, i,
maxpwr[i]) != DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: DDI_RESUME:\n\t"
" pm_power_has_changed"
" failed: comp %d to level %d\n",
ddi_node_name(devi),
ddi_get_instance(devi),
i, maxpwr[i]);
dstatep->level[i] = level_tmp;
}
mutex_exit(&dstatep->lock);
}
} else {
/*
* Call pm_raise_power() instead
*/
for (i = i_init; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_RESUME: pm_raise_power"
" comp %d to level %d",
ddi_node_name(devi), ddi_get_instance(devi),
i, maxpwr[i]));
if (pm_raise_power(dstatep->dip, i, maxpwr[i])
!= DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: DDI_RESUME:"
"\n\tpm_raise_power"
"failed: comp %d to level %d\n",
ddi_node_name(devi),
ddi_get_instance(devi),
i, maxpwr[i]);
}
}
}
return (DDI_SUCCESS);
default:
GEN_DEBUG((CE_WARN, "attach: default"));
return (DDI_FAILURE);
}
}
static int
gen_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
struct dstate *dstatep;
int instance;
int i;
int rv;
int rm_power;
int level_tmp;
#ifdef DEBUG
int n_devs;
int n_minorcomps;
int isclone;
#endif
switch (cmd) {
case DDI_DETACH:
GEN_DEBUG((CE_CONT, "%s%d: DDI_DETACH", ddi_node_name(devi),
ddi_get_instance(devi)));
instance = ddi_get_instance(devi);
dstatep = ddi_get_soft_state(dstates, instance);
if (dstatep == NULL) {
return (DDI_FAILURE);
}
#ifdef DEBUG
n_devs = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"ndevs", 1);
isclone = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"isclone", 0);
n_minorcomps = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 0,
"ncomps", 1);
#endif /* DEBUG */
/*
* power off component 1.
*/
if (dstatep->flag & PM_SUPPORTED_FLAG) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_DETACH: pm_lower_power comp 1 level %d",
ddi_node_name(devi), ddi_get_instance(devi),
MINPWR));
if (pm_lower_power(dstatep->dip, 1, MINPWR)
!= DDI_SUCCESS) {
cmn_err(CE_WARN, "%s%d: DDI_DETACH:\n\t"
"pm_lower_power failed for comp 1 to"
" level %d\n", ddi_node_name(devi),
ddi_get_instance(devi), MINPWR);
return (DDI_FAILURE);
}
/*
* check power level. Issue pm_power_has_changed
* if not at MINPWR.
*/
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[1];
dstatep->level[1] = MINPWR;
if (dstatep->level[1] != MINPWR) {
GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:"
" power off via pm_power_has_changed"
" instead", ddi_node_name(devi),
ddi_get_instance(devi)));
if (pm_power_has_changed(dstatep->dip,
1, MINPWR) != DDI_SUCCESS) {
GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:"
" pm_power_has_changed failed for"
" comp 1 to level %d",
ddi_node_name(devi),
ddi_get_instance(devi),
MINPWR));
dstatep->level[1] = level_tmp;
mutex_exit(&dstatep->lock);
return (DDI_FAILURE);
}
}
mutex_exit(&dstatep->lock);
}
/*
* If the LOWER_POWER_FLAG flag is not set,
* don't call pm_lowr_power() for comp 0.
* This should be used only for the XXXXX@XX,no_invol
* devices that export the
* no-involuntary-power-cycles property
*/
if (!(dstatep->flag & LOWER_POWER_FLAG) &&
dstatep->flag & PM_SUPPORTED_FLAG) {
cmn_err(CE_NOTE, "%s%d: DDI_DETACH:\n\t"
" NOT CALLING PM_LOWER_POWER():"
" LOWER_POWER_FLAG NOT SET\n",
ddi_node_name(devi), ddi_get_instance(devi));
} else if (dstatep->flag & PM_SUPPORTED_FLAG) {
GEN_DEBUG((CE_CONT,
"%s%d: DDI_DETACH: pm_lower_power comp 0 level %d",
ddi_node_name(devi), ddi_get_instance(devi),
MINPWR));
if (pm_lower_power(dstatep->dip, 0, MINPWR)
!= DDI_SUCCESS) {
cmn_err(CE_WARN, "%s%d: DDI_DETACH:\n\t"
"pm_lower_power failed for comp 0 to"
" level %d\n", ddi_node_name(devi),
ddi_get_instance(devi), MINPWR);
return (DDI_FAILURE);
}
/*
* check power level. Issue pm_power_has_changed
* if not at MINPWR.
*/
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[0];
dstatep->level[0] = MINPWR;
if (dstatep->level[0] != MINPWR) {
GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:"
" power off via pm_power_has_changed"
" instead", ddi_node_name(devi),
ddi_get_instance(devi)));
if (pm_power_has_changed(dstatep->dip,
0, MINPWR) != DDI_SUCCESS) {
GEN_DEBUG((CE_NOTE, "%s%d: DDI_DETACH:"
" pm_power_has_changed failed for"
" comp 0 to level %d",
ddi_node_name(devi),
ddi_get_instance(devi),
MINPWR));
dstatep->level[0] = level_tmp;
mutex_exit(&dstatep->lock);
return (DDI_FAILURE);
}
}
mutex_exit(&dstatep->lock);
}
GEN_DEBUG((CE_CONT,
"%s%d detaching: n_devs=%d n_minorcomps=%d isclone=%d",
ddi_node_name(devi), ddi_get_instance(devi),
n_devs, n_minorcomps, isclone));
for (i = 0; i < NUMEVENTS; i++) {
if (dstatep->gen_cb_ids[i]) {
(void) ddi_remove_event_handler(dstatep->gen_cb_ids[i]);
dstatep->gen_cb_ids[i] = NULL;
}
}
ddi_prop_remove_all(devi);
ddi_remove_minor_node(devi, NULL);
if (dstatep->node_type)
kmem_free(dstatep->node_type,
strlen(dstatep->node_type) + 1);
ddi_soft_state_free(dstates, instance);
return (DDI_SUCCESS);
case DDI_SUSPEND:
GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND",
ddi_node_name(devi), ddi_get_instance(devi)));
instance = ddi_get_instance(devi);
dstatep = ddi_get_soft_state(dstates, instance);
if (dstatep == NULL) {
return (DDI_FAILURE);
}
/*
* fail the suspend if FAIL_SUSPEND_FLAG is set.
* clear the FAIL_SUSPEND_FLAG flag
*/
mutex_enter(&dstatep->lock);
if (dstatep->flag & FAIL_SUSPEND_FLAG) {
GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:"
" FAIL_SUSPEND_FLAG is set,"
" fail suspend",
ddi_node_name(devi), ddi_get_instance(devi)));
dstatep->flag &= ~FAIL_SUSPEND_FLAG;
rv = DDI_FAILURE;
} else {
rv = DDI_SUCCESS;
}
mutex_exit(&dstatep->lock);
/*
* Issue ddi_removing_power() to determine if the suspend
* was initiated by either CPR or DR. If CPR, the system
* will be powered OFF; if this driver has set the
* NO_INVOL_FLAG, then refuse to suspend. If DR, power
* will not be removed, thus allow the suspend.
*/
if (dstatep->flag & NO_INVOL_FLAG &&
dstatep->flag & PM_SUPPORTED_FLAG) {
GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:"
" check via ddi_removing_power()",
ddi_node_name(devi), ddi_get_instance(devi)));
rm_power = ddi_removing_power(dstatep->dip);
if (rm_power < 0) {
cmn_err(CE_WARN, "%s%d: DDI_SUSPEND:"
" ddi_removing_power() failed\n",
ddi_node_name(devi),
ddi_get_instance(devi));
} else if (rm_power == 1) {
/*
* CPR: power will be removed
*/
GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:\n\t"
" CPR: POWER WILL BE REMOVED, THEREFORE"
" REFUSE TO SUSPEND", ddi_node_name(devi),
ddi_get_instance(devi)));
rv = DDI_FAILURE;
} else if (rm_power == 0) {
/*
* DR: power will not be removed
*/
GEN_DEBUG((CE_CONT, "%s%d: DDI_SUSPEND:\n\t"
" DR: POWER WILL NOT BE REMOVED, THEREFORE"
" ALLOW THE SUSPEND", ddi_node_name(devi),
ddi_get_instance(devi)));
rv = DDI_SUCCESS;
}
}
/*
* power OFF via pm_power_has_changed()
*/
mutex_enter(&dstatep->lock);
if (dstatep->flag & PM_SUPPORTED_FLAG &&
!(dstatep->flag & NO_INVOL_FLAG)) {
level_tmp = dstatep->level[0];
dstatep->level[0] = MINPWR;
GEN_DEBUG((CE_CONT,
"%s%d: DDI_SUSPEND: pm_power_has_changed comp 0"
" level %d", ddi_node_name(devi),
ddi_get_instance(devi), MINPWR));
if (pm_power_has_changed(dstatep->dip, 0, MINPWR)
!= DDI_SUCCESS) {
cmn_err(CE_WARN, "%s%d: DDI_SUSPEND:\n\t"
"pm_power_has_changed failed for comp 0 to"
" level %d\n", ddi_node_name(devi),
ddi_get_instance(devi), MINPWR);
dstatep->level[0] = level_tmp;
mutex_exit(&dstatep->lock);
return (DDI_FAILURE);
}
}
mutex_exit(&dstatep->lock);
return (rv);
default:
return (DDI_FAILURE);
}
}
/* ARGSUSED */
static int
gen_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
dev_t dev;
int instance;
if (infocmd != DDI_INFO_DEVT2INSTANCE)
return (DDI_FAILURE);
dev = (dev_t)arg;
instance = MINOR_TO_INST(getminor(dev));
*result = (void *)(uintptr_t)instance;
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
gen_open(dev_t *devp, int flag, int otyp, cred_t *cred)
{
minor_t minor;
struct dstate *dstatep;
if (otyp != OTYP_BLK && otyp != OTYP_CHR)
return (EINVAL);
minor = getminor(*devp);
if ((dstatep = ddi_get_soft_state(dstates,
MINOR_TO_INST(minor))) == NULL)
return (ENXIO);
mutex_enter(&dstatep->lock);
dstatep->flag |= OPEN_FLAG;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT,
"%s%d open",
dstatep->nodename, MINOR_TO_INST(minor)));
return (0);
}
/*ARGSUSED*/
static int
gen_close(dev_t dev, int flag, int otyp, cred_t *cred)
{
struct dstate *dstatep;
minor_t minor = getminor(dev);
if (otyp != OTYP_BLK && otyp != OTYP_CHR)
return (EINVAL);
dstatep = ddi_get_soft_state(dstates, MINOR_TO_INST(minor));
if (dstatep == NULL)
return (ENXIO);
mutex_enter(&dstatep->lock);
dstatep->flag &= ~OPEN_FLAG;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT,
"%s%d close",
dstatep->nodename, MINOR_TO_INST(minor)));
return (0);
}
/*ARGSUSED*/
static int
gen_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
{
struct dstate *dstatep;
ddi_eventcookie_t cookie;
int instance;
int rval = 0;
char *nodename;
int i;
struct devctl_iocdata *dcp;
uint_t state;
int ret;
int level_tmp;
instance = MINOR_TO_INST(getminor(dev));
dstatep = ddi_get_soft_state(dstates, instance);
nodename = dstatep->nodename;
if (dstatep == NULL)
return (ENXIO);
/*
* read devctl ioctl data
*/
if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
return (EFAULT);
switch (cmd) {
case GENDRV_IOFAULT_SIMULATE:
if (ddi_get_eventcookie(dstatep->dip, DDI_DEVI_FAULT_EVENT,
&(cookie)) != NDI_SUCCESS)
return (DDI_FAILURE);
return (ndi_post_event(dstatep->dip, dstatep->dip, cookie,
NULL));
case GENDRV_NDI_EVENT_TEST:
if (ddi_get_eventcookie(dstatep->dip, "pshot_dev_offline",
&cookie) == NDI_SUCCESS) {
(void) ndi_post_event(dstatep->dip, dstatep->dip,
cookie, NULL);
}
if (ddi_get_eventcookie(dstatep->dip, "pshot_dev_reset",
&cookie) == NDI_SUCCESS) {
(void) ndi_post_event(dstatep->dip, dstatep->dip,
cookie, NULL);
}
if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_reset",
&cookie) == NDI_SUCCESS) {
(void) ndi_post_event(dstatep->dip, dstatep->dip,
cookie, NULL);
}
if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_quiesce",
&cookie) == NDI_SUCCESS) {
(void) ndi_post_event(dstatep->dip, dstatep->dip,
cookie, NULL);
}
if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_unquiesce",
&cookie) == NDI_SUCCESS) {
(void) ndi_post_event(dstatep->dip, dstatep->dip,
cookie, NULL);
}
if (ddi_get_eventcookie(dstatep->dip, "pshot_bus_test_post",
&cookie) == NDI_SUCCESS) {
(void) ndi_post_event(dstatep->dip, dstatep->dip,
cookie, NULL);
}
break;
case DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME:
/*
* Issue pm_power_has_changed() call on DDI_RESUME
*/
mutex_enter(&dstatep->lock);
dstatep->flag |= PWR_HAS_CHANGED_ON_RESUME_FLAG;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT, "%s%d:"
" DEVCTL_PM_PWR_HAS_CHANGED_ON_RESUME", nodename,
instance));
break;
case DEVCTL_PM_FAIL_SUSPEND:
/*
* Fail the suspend attempt in DDI_SUSPEND
*/
mutex_enter(&dstatep->lock);
dstatep->flag |= FAIL_SUSPEND_FLAG;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_FAIL_SUSPEND",
nodename, instance));
break;
case DEVCTL_PM_PUP_WITH_PWR_HAS_CHANGED:
/*
* Use pm_power_has_changed() to power up comp 0 when
* enforcing the comp 0 vs comp-not 0 dependency:
* Power up comp 0 first, if request for comp-not-0
* comes in.
* Else, default to pm_raise_power().
*/
mutex_enter(&dstatep->lock);
dstatep->flag |= PUP_WITH_PWR_HAS_CHANGED_FLAG;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_PUP_WITH_PWR_HAS_CHANGED",
nodename, instance));
break;
case DEVCTL_PM_BUSY_COMP:
/*
* mark component 0 busy via a pm_busy_component() call.
* update the busy[] array.
*/
mutex_enter(&dstatep->lock);
++dstatep->busy[0];
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_BUSY_COMP: comp 0:"
" busy=%d", nodename, instance, dstatep->busy[0]));
mutex_exit(&dstatep->lock);
ret = pm_busy_component(dstatep->dip, 0);
ASSERT(ret == DDI_SUCCESS);
break;
case DEVCTL_PM_BUSY_COMP_TEST:
/*
* test busy state on component 0
*/
mutex_enter(&dstatep->lock);
state = dstatep->busy[0];
if (copyout(&state, dcp->cpyout_buf,
sizeof (uint_t)) != 0) {
cmn_err(CE_WARN, "%s%d:"
" DEVCTL_PM_BUSY_COMP_TEST: copyout failed\n",
nodename, instance);
rval = EINVAL;
}
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_BUSY_COMP_TEST:"
" comp 0 busy %d",
nodename, instance, state));
mutex_exit(&dstatep->lock);
break;
case DEVCTL_PM_IDLE_COMP:
/*
* mark component 0 idle via a pm_idle_component() call.
* NOP if dstatep->busy[0] == 0.
*/
mutex_enter(&dstatep->lock);
if (dstatep->busy[0] > 0) {
--dstatep->busy[0];
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_IDLE_COMP:"
" comp 0: busy=%d", nodename, instance,
dstatep->busy[0]));
mutex_exit(&dstatep->lock);
ret = pm_idle_component(dstatep->dip, 0);
ASSERT(ret == DDI_SUCCESS);
} else {
mutex_exit(&dstatep->lock);
}
break;
case DEVCTL_PM_PROM_PRINTF:
(void) prom_printf("%s%d: PROM_PRINTF FROM GEN_DRV\n",
nodename, instance);
break;
case DEVCTL_PM_RAISE_PWR:
/*
* power up both components to MAXPWR via
* pm_raise_power() calls. this ioctl() cmd
* assumes that the current level is 0
*/
for (i = 0; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_RAISE_PWR:"
" comp %d old 0 new %d",
nodename, instance, i, maxpwr[i]));
if (pm_raise_power(dstatep->dip, 0, maxpwr[i])
!= DDI_SUCCESS) {
rval = EINVAL;
}
}
break;
case DEVCTL_PM_CHANGE_PWR_LOW:
/*
* power off both components via pm_power_has_changed() calls
*/
for (i = (COMPONENTS - 1); i >= 0; --i) {
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_CHANGE_PWR_LOW:"
" comp %d new 0",
nodename, instance, i));
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[i];
dstatep->level[i] = 0;
if (pm_power_has_changed(dstatep->dip, i, 0)
!= DDI_SUCCESS) {
dstatep->level[i] = level_tmp;
rval = EINVAL;
}
mutex_exit(&dstatep->lock);
}
break;
case DEVCTL_PM_CHANGE_PWR_HIGH:
/*
* power up both components to MAXPWR via
* pm_power_has_changed() calls
*/
for (i = 0; i < COMPONENTS; i++) {
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_CHANGE_PWR_HIGH:"
" comp %d new %d",
nodename, instance, i, maxpwr[i]));
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[i];
dstatep->level[i] = maxpwr[i];
if (pm_power_has_changed(dstatep->dip, i, maxpwr[i])
!= DDI_SUCCESS) {
dstatep->level[i] = level_tmp;
rval = EINVAL;
}
mutex_exit(&dstatep->lock);
}
break;
case DEVCTL_PM_POWER:
/*
* test if the gen_drv_power() routine has been called,
* then clear
*/
mutex_enter(&dstatep->lock);
state = (dstatep->flag & POWER_FLAG) ? 1 : 0;
if (copyout(&state, dcp->cpyout_buf,
sizeof (uint_t)) != 0) {
cmn_err(CE_WARN, "%s%d: DEVCTL_PM_POWER:"
" copyout failed\n", nodename, instance);
rval = EINVAL;
}
GEN_DEBUG((CE_CONT, "%s%d: %s POWER_FLAG: %d",
nodename, instance, "DEVCTL_PM_POWER", state));
dstatep->flag &= ~POWER_FLAG;
mutex_exit(&dstatep->lock);
break;
case DEVCTL_PM_NO_LOWER_POWER:
/*
* issue to not invoke pm_lower_power() on detach
*/
mutex_enter(&dstatep->lock);
dstatep->flag &= ~LOWER_POWER_FLAG;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT, "%s%d: DEVCTL_PM_NO_LOWER_POWER",
nodename, instance));
break;
default:
return (ENOTTY);
}
return (rval);
}
/*ARGSUSED*/
static int
gen_read(dev_t dev, struct uio *uiop, cred_t *credp)
{
return (0);
}
/*ARGSUSED*/
static int
gen_write(dev_t dev, struct uio *uiop, cred_t *credp)
{
return (0);
}
/*ARGSUSED0*/
static int
gen_power(dev_info_t *dip, int cmpt, int level)
{
struct dstate *dstatep;
int instance = ddi_get_instance(dip);
char *nodename = ddi_node_name(dip);
int level_tmp;
GEN_DEBUG((CE_CONT, "%s%d: power: cmpt %d to level %d",
nodename, instance, cmpt, level));
dstatep = ddi_get_soft_state(dstates, instance);
if (dstatep == NULL) {
return (DDI_FAILURE);
}
/*
* Keep track of the power levels for both components
* in the dstatep->comp[] array.
* Set comp 0 to full level if non-zero comps
* are being set to a higher, non-zero level.
*/
if (cmpt == 0) {
mutex_enter(&dstatep->lock);
dstatep->level[cmpt] = level;
mutex_exit(&dstatep->lock);
} else if (level > dstatep->level[cmpt] && level != 0 &&
dstatep->level[0] != COMP_0_MAXPWR) {
/*
* If component 0 is not at COMP_0_MAXPWR, and component 1
* is being powered ON, invoke pm_raise_power() or
* pm_power_has_changed() based on the
* PUP_WITH_PWR_HAS_CHANGED_FLAG flag.
* PUP_WITH_PWR_HAS_CHANGED_FLAG = FALSE by default, invoking
* pm_raise_power().
*/
if (!(dstatep->flag & PUP_WITH_PWR_HAS_CHANGED_FLAG)) {
/*
* first set comp 0 to level COMP_0_MAXPWR
*/
GEN_DEBUG((CE_CONT, "%s%d: power: "
"pm_raise_power: comp 0 to level %d",
nodename, instance, COMP_0_MAXPWR));
if (pm_raise_power(dip, 0, COMP_0_MAXPWR) !=
DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: power: pm_raise_power() "
"failed: comp 0 to level %d\n",
nodename, instance, COMP_0_MAXPWR);
return (DDI_FAILURE);
} else {
mutex_enter(&dstatep->lock);
dstatep->level[0] = COMP_0_MAXPWR;
/*
* now set the level on the non-zero comp
*/
dstatep->level[cmpt] = level;
mutex_exit(&dstatep->lock);
GEN_DEBUG((CE_CONT, "%s%d: power: "
"comp %d to level %d",
nodename, instance, cmpt, level));
}
} else {
GEN_DEBUG((CE_CONT, "%s%d: power: "
"pm_power_has_changed: comp 0 to level %d",
nodename, instance, COMP_0_MAXPWR));
mutex_enter(&dstatep->lock);
level_tmp = dstatep->level[0];
dstatep->level[0] = COMP_0_MAXPWR;
if (pm_power_has_changed(dip, 0, COMP_0_MAXPWR) !=
DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s%d: power: pm_power_has_changed() "
"failed: comp 0 to level %d\n",
nodename, instance, COMP_0_MAXPWR);
dstatep->level[0] = level_tmp;
} else {
/*
* now set the level on the non-zero comp
*/
GEN_DEBUG((CE_CONT, "%s%d: power:"
" pm_power_has_changed: comp %d"
" to level %d", nodename, instance,
cmpt, level));
dstatep->level[cmpt] = level;
}
mutex_exit(&dstatep->lock);
}
} else {
mutex_enter(&dstatep->lock);
dstatep->level[cmpt] = level;
mutex_exit(&dstatep->lock);
}
return (DDI_SUCCESS);
}
/*
* Create properties of various data types for testing devfs events.
*/
static int
gen_create_properties(dev_info_t *devi)
{
int int_val = 3023;
int int_array[] = { 3, 10, 304, 230, 4};
int64_t int64_val = 20;
int64_t int64_array[] = { 12, 24, 36, 48};
char *string_val = "Dev_node_prop";
char *string_array[] = {"Dev_node_prop:0",
"Dev_node_prop:1", "Dev_node_prop:2", "Dev_node_prop:3"};
uchar_t byte_array[] = { (uchar_t)0xaa, (uchar_t)0x55,
(uchar_t)0x12, (uchar_t)0xcd };
char bytes[] = { (char)0x00, (char)0xef, (char)0xff };
if (ddi_prop_update_int(DDI_DEV_T_NONE, devi, "int", int_val)
!= DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_update_int_array(DDI_DEV_T_NONE, devi, "int-array",
int_array, sizeof (int_array) / sizeof (int)) != DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_update_int64(DDI_DEV_T_NONE, devi, "int64", int64_val)
!= DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_update_int64_array(DDI_DEV_T_NONE, devi, "int64-array",
int64_array, sizeof (int64_array) / sizeof (int64_t))
!= DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_update_string(DDI_DEV_T_NONE, devi, "string", string_val)
!= DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_update_string_array(DDI_DEV_T_NONE, devi, "string-array",
string_array, sizeof (string_array) / sizeof (char *))
!= DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
"boolean", NULL, 0) != DDI_PROP_SUCCESS)
return (DDI_FAILURE);
if (ddi_prop_update_byte_array(DDI_DEV_T_NONE, devi, "byte-array",
byte_array, sizeof (byte_array)) != DDI_PROP_SUCCESS)
return (DDI_FAILURE);
/* untyped property */
if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, "untyped",
(caddr_t)bytes, sizeof (bytes)) != DDI_PROP_SUCCESS)
return (DDI_FAILURE);
return (DDI_SUCCESS);
}
static struct driver_minor_data {
char *name;
minor_t minor;
int type;
} disk_minor_data[] = {
{"a", 0, S_IFBLK},
{"b", 1, S_IFBLK},
{"c", 2, S_IFBLK},
{"d", 3, S_IFBLK},
{"e", 4, S_IFBLK},
{"f", 5, S_IFBLK},
{"g", 6, S_IFBLK},
{"h", 7, S_IFBLK},
{"a,raw", 0, S_IFCHR},
{"b,raw", 1, S_IFCHR},
{"c,raw", 2, S_IFCHR},
{"d,raw", 3, S_IFCHR},
{"e,raw", 4, S_IFCHR},
{"f,raw", 5, S_IFCHR},
{"g,raw", 6, S_IFCHR},
{"h,raw", 7, S_IFCHR},
{0}
};
static struct driver_serial_minor_data {
char *name;
minor_t minor;
int type;
char *node_type;
} serial_minor_data[] = {
{"0", 0, S_IFCHR, "ddi_serial"},
{"1", 1, S_IFCHR, "ddi_serial"},
{"0,cu", 2, S_IFCHR, "ddi_serial:dialout"},
{"1,cu", 3, S_IFCHR, "ddi_serial:dialout"},
{0}
};
static int
gen_create_display(dev_info_t *devi)
{
int instance = ddi_get_instance(devi);
char minor_name[15];
(void) sprintf(minor_name, "cgtwenty%d", instance);
return (ddi_create_minor_node(devi, minor_name, S_IFCHR,
INST_TO_MINOR(instance), DDI_NT_DISPLAY, NULL));
}
static int
gen_create_mn_disk_chan(dev_info_t *devi)
{
struct driver_minor_data *dmdp;
int instance = ddi_get_instance(devi);
if (gen_create_properties(devi) != DDI_SUCCESS)
return (DDI_FAILURE);
for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
DDI_NT_BLOCK_CHAN, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static uint_t
atod(char *s)
{
uint_t val = 0;
uint_t digit;
while (*s) {
if (*s >= '0' && *s <= '9')
digit = *s++ - '0';
else
break;
val = (val * 10) + digit;
}
return (val);
}
static int
gen_create_mn_disk_wwn(dev_info_t *devi)
{
struct driver_minor_data *dmdp;
int instance = ddi_get_instance(devi);
char *address = ddi_get_name_addr(devi);
int target, lun;
if (address[0] >= '0' && address[0] <= '9' &&
strchr(address, ',')) {
target = atod(address);
address = strchr(address, ',');
lun = atod(++address);
} else { /* this hack is for rm_stale_link() testing */
target = 10;
lun = 5;
}
if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
"target", (caddr_t)&target, sizeof (int))
!= DDI_PROP_SUCCESS) {
return (DDI_FAILURE);
}
if (ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
"lun", (caddr_t)&lun, sizeof (int))
!= DDI_PROP_SUCCESS) {
return (DDI_FAILURE);
}
for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
DDI_NT_BLOCK_WWN, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
gen_create_mn_disk_cdrom(dev_info_t *devi)
{
struct driver_minor_data *dmdp;
int instance = ddi_get_instance(devi);
for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
DDI_NT_CD_CHAN, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
gen_create_mn_disk_fd(dev_info_t *devi)
{
struct driver_minor_data *dmdp;
int instance = ddi_get_instance(devi);
for (dmdp = disk_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
DDI_NT_BLOCK_CHAN, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
gen_create_serial(dev_info_t *devi)
{
struct driver_serial_minor_data *dmdp;
int instance = ddi_get_instance(devi);
for (dmdp = serial_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(devi, dmdp->name, dmdp->type,
(INST_TO_MINOR(instance)) | dmdp->minor,
dmdp->node_type, NULL) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
static int
gen_create_net(dev_info_t *devi)
{
int instance = ddi_get_instance(devi);
char minorname[32];
if (gen_create_properties(devi) != DDI_SUCCESS)
return (DDI_FAILURE);
(void) snprintf(minorname, sizeof (minorname), "gen_drv%d", instance);
return (ddi_create_minor_node(devi, minorname, S_IFCHR,
INST_TO_MINOR(instance), DDI_NT_NET, 0));
}
static int
gen_create_minor_nodes(dev_info_t *devi, struct dstate *dstatep)
{
int rval = DDI_SUCCESS;
char *node_name;
node_name = ddi_node_name(devi);
if (strcmp(node_name, "disk_chan") == 0) {
rval = gen_create_mn_disk_chan(devi);
} else if (strcmp(node_name, "disk_wwn") == 0) {
rval = gen_create_mn_disk_wwn(devi);
} else if (strcmp(node_name, "disk_cdrom") == 0) {
rval = gen_create_mn_disk_cdrom(devi);
} else if (strcmp(node_name, "disk_fd") == 0) {
rval = gen_create_mn_disk_fd(devi);
} else if (strcmp(node_name, "cgtwenty") == 0) {
rval = gen_create_display(devi);
} else if (strcmp(node_name, "genzs") == 0) {
rval = gen_create_serial(devi);
} else if (strcmp(node_name, "net") == 0) {
rval = gen_create_net(devi);
} else {
int instance = ddi_get_instance(devi);
char *node_type;
/*
* Solaris may directly hang the node_type off the minor node
* (without making a copy). Since we free the node_type
* property below we need to make a private copy to pass
* to ddi_create_minor_node to avoid devinfo snapshot panics.
* We store a pointer to our copy in dstate and free it in
* gen_detach after the minor nodes have been deleted by
* ddi_remove_minor_node.
*/
if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devi,
DDI_PROP_DONTPASS, "node-type", &node_type) != 0) {
cmn_err(CE_WARN, "couldn't get node-type\n");
return (DDI_FAILURE);
}
if (node_type) {
dstatep->node_type = kmem_alloc(
strlen(node_type) + 1, KM_SLEEP);
(void) strcpy(dstatep->node_type, node_type);
}
ddi_prop_free(node_type);
/* the minor name is the same as the node name */
if (ddi_create_minor_node(devi, node_name, S_IFCHR,
(INST_TO_MINOR(instance)), dstatep->node_type, NULL) !=
DDI_SUCCESS) {
if (dstatep->node_type) {
kmem_free(dstatep->node_type,
strlen(dstatep->node_type) + 1);
dstatep->node_type = NULL;
}
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
if (rval != DDI_SUCCESS) {
ddi_prop_remove_all(devi);
ddi_remove_minor_node(devi, NULL);
}
return (rval);
}
/*ARGSUSED*/
static void
gen_event_cb(dev_info_t *dip, ddi_eventcookie_t cookie, void *arg,
void *impl_data)
{
if (gen_debug)
cmn_err(CE_NOTE, "gen_event_cb invoked");
}