static int
zc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
zc_state_t *zcs;
int instance;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
instance = ddi_get_instance(dip);
if (ddi_soft_state_zalloc(zc_soft_state, instance) != DDI_SUCCESS)
return (DDI_FAILURE);
/*
* Create the master and slave minor nodes.
*/
if ((ddi_create_minor_node(dip, ZCONS_SLAVE_NAME, S_IFCHR,
instance << 1 | ZC_SLAVE_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE) ||
(ddi_create_minor_node(dip, ZCONS_MASTER_NAME, S_IFCHR,
instance << 1 | ZC_MASTER_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE)) {
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(zc_soft_state, instance);
return (DDI_FAILURE);
}
VERIFY((zcs = ddi_get_soft_state(zc_soft_state, instance)) != NULL);
zcs->zc_devinfo = dip;
return (DDI_SUCCESS);
}
/* ARGSUSED */
static int
log_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (ddi_create_minor_node(devi, "conslog", S_IFCHR,
LOG_CONSMIN, DDI_PSEUDO, NULL) == DDI_FAILURE ||
ddi_create_minor_node(devi, "log", S_IFCHR,
LOG_LOGMIN, DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
log_devi = devi;
log_msgid = ddi_getprop(DDI_DEV_T_ANY, log_devi,
DDI_PROP_CANSLEEP, "msgid", 1);
return (DDI_SUCCESS);
}
static int
xpv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, ddi_get_name(dip), S_IFCHR,
ddi_get_instance(dip), DDI_PSEUDO, 0) != DDI_SUCCESS)
return (DDI_FAILURE);
xpv_dip = dip;
if (xpv_drv_init() != 0)
return (DDI_FAILURE);
ddi_report_dev(dip);
/*
* If the memscrubber attempts to scrub the pages we hand to Xen,
* the domain will panic.
*/
memscrub_disable();
/*
* Report our version to dom0.
*/
if (xenbus_printf(XBT_NULL, "guest/xpv", "version", "%d",
HVMPV_XPV_VERS))
cmn_err(CE_WARN, "xpv: couldn't write version\n");
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
tcli_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance = ddi_get_instance(devi);
struct dstate *dstatep;
int rval;
if (cmd != DDI_ATTACH)
return (DDI_SUCCESS);
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;
rval = ddi_create_minor_node(devi, "client", S_IFCHR,
(INST_TO_MINOR(instance)), DDI_PSEUDO, NULL);
if (rval == DDI_FAILURE) {
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);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
sdt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
#pragma unused(cmd)
sdt_provider_t *prov;
if (ddi_create_minor_node(devi, "sdt", S_IFCHR,
0, DDI_PSEUDO, 0) == DDI_FAILURE) {
cmn_err(CE_NOTE, "/dev/sdt couldn't create minor node");
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
sdt_devi = devi;
if (sdt_probetab_size == 0)
sdt_probetab_size = SDT_PROBETAB_SIZE;
sdt_probetab_mask = sdt_probetab_size - 1;
sdt_probetab =
kmem_zalloc(sdt_probetab_size * sizeof (sdt_probe_t *), KM_SLEEP);
dtrace_invop_add(sdt_invop);
for (prov = sdt_providers; prov->sdtp_name != NULL; prov++) {
if (dtrace_register(prov->sdtp_name, prov->sdtp_attr,
DTRACE_PRIV_KERNEL, NULL,
&sdt_pops, prov, &prov->sdtp_id) != 0) {
cmn_err(CE_WARN, "failed to register sdt provider %s",
prov->sdtp_name);
}
}
return (DDI_SUCCESS);
}
static int
nsmb_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
/*
* We only support only one "instance". Note that
* "instances" are different from minor units.
* We get one (unique) minor unit per open.
*/
if (ddi_get_instance(dip) > 0)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, "nsmb", S_IFCHR, 0, DDI_PSEUDO,
NULL) == DDI_FAILURE) {
cmn_err(CE_WARN, "nsmb_attach: create minor");
return (DDI_FAILURE);
}
/*
* We need the major number a couple places,
* i.e. in smb_dev2share()
*/
nsmb_major = ddi_name_to_major(NSMB_NAME);
nsmb_dip = dip;
ddi_report_dev(dip);
return (DDI_SUCCESS);
}
static int
pppt_drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH) {
return (DDI_FAILURE);
}
if (ddi_get_instance(dip) != 0) {
/* we only allow instance 0 to attach */
return (DDI_FAILURE);
}
/* create the minor node */
if (ddi_create_minor_node(dip, PPPT_MODNAME, S_IFCHR, 0,
DDI_PSEUDO, 0) != DDI_SUCCESS) {
cmn_err(CE_WARN, "pppt_drv_attach: "
"failed creating minor node");
return (DDI_FAILURE);
}
pppt_global.global_svc_state = PSS_DISABLED;
pppt_global.global_dip = dip;
return (DDI_SUCCESS);
}
static int
fbt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (fbt_probetab_size == 0)
fbt_probetab_size = FBT_PROBETAB_SIZE;
fbt_probetab_mask = fbt_probetab_size - 1;
fbt_probetab =
kmem_zalloc(fbt_probetab_size * sizeof (fbt_probe_t *), KM_SLEEP);
dtrace_invop_add(fbt_invop);
if (ddi_create_minor_node(devi, "fbt", S_IFCHR, 0,
DDI_PSEUDO, 0) == DDI_FAILURE ||
dtrace_register("fbt", &fbt_attr, DTRACE_PRIV_KERNEL, NULL,
&fbt_pops, NULL, &fbt_id) != 0) {
fbt_cleanup(devi);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
fbt_devi = devi;
return (DDI_SUCCESS);
}
static int
systrace_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
systrace_probe = (void (*)())dtrace_probe;
membar_enter();
if (ddi_create_minor_node(devi, "systrace", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE ||
dtrace_register("syscall", &systrace_attr, DTRACE_PRIV_USER, NULL,
&systrace_pops, NULL, &systrace_id) != 0) {
systrace_probe = systrace_stub;
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
systrace_devi = devi;
return (DDI_SUCCESS);
}
static int
profile_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ddi_create_minor_node(devi, "profile", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE ||
dtrace_register("profile", &profile_attr,
DTRACE_PRIV_KERNEL | DTRACE_PRIV_USER, NULL,
&profile_pops, NULL, &profile_id) != 0) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
profile_max = ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
"profile-max-probes", PROFILE_MAX_DEFAULT);
ddi_report_dev(devi);
profile_devi = devi;
return (DDI_SUCCESS);
}
static int
opattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
switch (cmd) {
case DDI_ATTACH:
if (prom_is_openprom()) {
options_nodeid = prom_optionsnode();
} else {
options_nodeid = OBP_BADNODE;
}
opdip = dip;
if (ddi_create_minor_node(dip, "openprom", S_IFCHR,
0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
sckm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
SCKM_DEBUG1(D_ATTACH, "in sckm_attach, cmd=%d", cmd);
switch (cmd) {
case DDI_ATTACH:
SCKM_DEBUG0(D_ATTACH, "sckm_attach: DDI_ATTACH");
if (ddi_create_minor_node(devi, "sckmdrv", S_IFCHR,
0, NULL, NULL) == DDI_FAILURE) {
cmn_err(CE_WARN, "ddi_create_minor_node failed");
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
sckm_devi = devi;
break;
case DDI_SUSPEND:
SCKM_DEBUG0(D_ATTACH, "sckm_attach: DDI_SUSPEND");
break;
default:
cmn_err(CE_WARN, "sckm_attach: bad cmd %d\n", cmd);
return (DDI_FAILURE);
}
SCKM_DEBUG0(D_ATTACH, "out sckm_attach (DDI_SUCCESS)");
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
pseudonex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance;
pseudonex_state_t *pnx_state;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/*
* Save the devi for this instance in the soft_state data.
*/
instance = ddi_get_instance(devi);
if (ddi_soft_state_zalloc(pseudonex_state, instance) != DDI_SUCCESS)
return (DDI_FAILURE);
pnx_state = ddi_get_soft_state(pseudonex_state, instance);
pnx_state->pnx_devi = devi;
if (ddi_create_minor_node(devi, "devctl", S_IFCHR, instance,
DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(pseudonex_state, instance);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
}
static int
lockstat_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ddi_create_minor_node(devi, "lockstat", S_IFCHR, 0,
DDI_PSEUDO, 0) == DDI_FAILURE ||
dtrace_register("lockstat", &lockstat_attr, DTRACE_PRIV_KERNEL,
NULL, &lockstat_pops, NULL, &lockstat_id) != 0) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
lockstat_probe = dtrace_probe;
membar_producer();
ddi_report_dev(devi);
lockstat_devi = devi;
return (DDI_SUCCESS);
}
/*
* devo_attach: attach(9e)
*/
static int
drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
ASSERT(ddi_get_instance(dip) == 0);
drv_init();
drv_set_opt(dip);
/*
* Create control node. DLPI provider nodes will be created on demand.
*/
if (ddi_create_minor_node(dip, DLD_CONTROL_MINOR_NAME, S_IFCHR,
DLD_CONTROL_MINOR, DDI_PSEUDO, 0) != DDI_SUCCESS)
return (DDI_FAILURE);
dld_dip = dip;
/*
* Log the fact that the driver is now attached.
*/
ddi_report_dev(dip);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static void
ppb_init_hotplug(ppb_devstate_t *ppb)
{
ppb->hotplug_capable = B_FALSE;
if (ddi_prop_exists(DDI_DEV_T_ANY, ppb->dip, DDI_PROP_DONTPASS,
"hotplug-capable")) {
(void) modload("misc", "pcihp");
if (pcihp_init(ppb->dip) != DDI_SUCCESS) {
cmn_err(CE_WARN,
"%s #%d: Failed setting hotplug framework",
ddi_driver_name(ppb->dip),
ddi_get_instance(ppb->dip));
} else
ppb->hotplug_capable = B_TRUE;
}
if (ppb->hotplug_capable == B_FALSE) {
/*
* create minor node for devctl interfaces
*/
if (ddi_create_minor_node(ppb->dip, "devctl", S_IFCHR,
PCI_MINOR_NUM(ddi_get_instance(ppb->dip), PCI_DEVCTL_MINOR),
DDI_NT_NEXUS, 0) != DDI_SUCCESS)
cmn_err(CE_WARN,
"%s #%d: Failed to create a minor node",
ddi_driver_name(ppb->dip),
ddi_get_instance(ppb->dip));
}
}
static int
sdt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
sdt_provider_t *prov;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ddi_create_minor_node(devi, "sdt", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
sdt_devi = devi;
for (prov = sdt_providers; prov->sdtp_name != NULL; prov++) {
if (dtrace_register(prov->sdtp_name, prov->sdtp_attr,
DTRACE_PRIV_KERNEL, NULL,
&sdt_pops, prov, &prov->sdtp_id) != 0) {
cmn_err(CE_WARN, "failed to register sdt provider %s",
prov->sdtp_name);
}
}
return (DDI_SUCCESS);
}
static int
lx_ptm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int err;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, LX_PTM_MINOR_NODE, S_IFCHR,
ddi_get_instance(dip), DDI_PSEUDO, 0) != DDI_SUCCESS)
return (DDI_FAILURE);
err = ldi_ident_from_dip(dip, &lps.lps_li);
if (err != 0) {
ddi_remove_minor_node(dip, ddi_get_name(dip));
return (DDI_FAILURE);
}
lps.lps_dip = dip;
lps.lps_pts_major = ddi_name_to_major(LP_PTS_DRV_NAME);
rw_init(&lps.lps_lh_rwlock, NULL, RW_DRIVER, NULL);
lps.lps_lh_count = 0;
lps.lps_lh_array = NULL;
return (DDI_SUCCESS);
}
/*
* xpvtap_attach()
*/
static int
xpvtap_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
blk_ringinit_args_t args;
xpvtap_state_t *state;
int instance;
int e;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/* initialize our state info */
instance = ddi_get_instance(dip);
state = xpvtap_drv_init(instance);
if (state == NULL) {
return (DDI_FAILURE);
}
state->bt_dip = dip;
/* Initialize the guest ring */
args.ar_dip = state->bt_dip;
args.ar_intr = xpvtap_intr;
args.ar_intr_arg = (caddr_t)state;
args.ar_ringup = xpvtap_user_thread_start;
args.ar_ringup_arg = (caddr_t)state;
args.ar_ringdown = xpvtap_user_app_stop;
args.ar_ringdown_arg = (caddr_t)state;
e = blk_ring_init(&args, &state->bt_guest_ring);
if (e != DDI_SUCCESS) {
goto attachfail_ringinit;
}
/* create the minor node (for ioctl/mmap) */
e = ddi_create_minor_node(dip, "xpvtap", S_IFCHR, instance,
DDI_PSEUDO, 0);
if (e != DDI_SUCCESS) {
goto attachfail_minor_node;
}
/* Report that driver was loaded */
ddi_report_dev(dip);
return (DDI_SUCCESS);
attachfail_minor_node:
blk_ring_fini(&state->bt_guest_ring);
attachfail_ringinit:
xpvtap_drv_fini(state);
return (DDI_FAILURE);
}
static int
kcpc_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
kcpc_devi = devi;
return (ddi_create_minor_node(devi, "shared", S_IFCHR,
KCPC_MINOR_SHARED, DDI_PSEUDO, 0));
}
/*ARGSUSED*/
static int
logiattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int unit;
struct driver_minor_data *dmdp;
struct strmseinfo *logiptr = 0;
#ifdef LOGI_DEBUG
if (logi_debug) {
PRF("logiattach entry\n");
}
#endif
switch (cmd) {
case DDI_ATTACH:
unit = ddi_get_instance(dip);
for (dmdp = logi_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(dip, dmdp->name, dmdp->type,
dmdp->minor, DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
ddi_prop_remove_all(dip);
#ifdef LOGI_DEBUG
if (logi_debug)
PRF("logiattach: "
"ddi_create_minor_node failed\n");
#endif
return (DDI_FAILURE);
}
}
logiunits[unit] = dip;
/* allocate and initialize state structure */
logiptr = kmem_zalloc(sizeof (struct strmseinfo), KM_SLEEP);
logiptr->state = 0; /* not opened */
ddi_set_driver_private(dip, logiptr);
if (ddi_add_intr(dip, (uint_t)0, &logiptr->iblock,
(ddi_idevice_cookie_t *)0, logiintr,
(caddr_t)logiptr) != DDI_SUCCESS) {
#ifdef LOGI_DEBUG
if (logi_debug)
PRF("logiattach: ddi_add_intr failed\n");
#endif
cmn_err(CE_WARN, "logi: cannot add intr\n");
return (DDI_FAILURE);
}
mutex_init(&logiptr->lock, NULL, MUTEX_DRIVER,
(void *)logiptr->iblock);
ddi_report_dev(dip);
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
cpuid_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
cpuid_devi = devi;
return (ddi_create_minor_node(devi, CPUID_DRIVER_SELF_NODE, S_IFCHR,
CPUID_SELF_CPUID_MINOR, DDI_PSEUDO, 0));
}
static int
rdsv3_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int ret;
RDSV3_DPRINTF2("rdsv3_attach", "Enter (dip: %p)", dip);
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (rdsv3_dev_info != NULL) {
RDSV3_DPRINTF2("rdsv3_attach", "Multiple RDS instances are"
" not supported (rdsv3_dev_info: 0x%p)", rdsv3_dev_info);
return (DDI_FAILURE);
}
rdsv3_dev_info = dip;
mutex_init(&rdsv3_rdma_listen_id_lock, NULL, MUTEX_DRIVER, NULL);
rdsv3_rdma_listen_id = NULL;
rdsv3_af_init(dip);
rdsv3_trans_init();
ret = rdsv3_init();
if (ret) {
RDSV3_DPRINTF2("rdsv3_attach", "rdsv3_init failed: %d", ret);
rdsv3_trans_exit();
mutex_destroy(&rdsv3_rdma_listen_id_lock);
rdsv3_dev_info = NULL;
return (DDI_FAILURE);
}
ret = rdsv3_sock_init();
if (ret) {
rdsv3_exit();
rdsv3_trans_exit();
mutex_destroy(&rdsv3_rdma_listen_id_lock);
rdsv3_dev_info = NULL;
return (DDI_FAILURE);
}
ret = ddi_create_minor_node(dip, "rdsv3", S_IFCHR, 0, DDI_PSEUDO, 0);
if (ret != DDI_SUCCESS) {
cmn_err(CE_CONT, "ddi_create_minor_node failed: %d", ret);
rdsv3_sock_exit();
rdsv3_exit();
rdsv3_trans_exit();
mutex_destroy(&rdsv3_rdma_listen_id_lock);
rdsv3_dev_info = NULL;
return (DDI_FAILURE);
}
RDSV3_DPRINTF2("rdsv3_attach", "Return");
return (DDI_SUCCESS);
}
static int
ipmi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
/* this driver only supports one device instance */
if (ddi_get_instance(dip) != 0) {
cmn_err(CE_WARN,
"!not attaching to non-zero device instance %d",
ddi_get_instance(dip));
return (DDI_FAILURE);
}
if (get_smbios_ipmi_info() == DDI_FAILURE)
return (DDI_FAILURE);
/*
* Support for the other types (SMIC, SSIF) should be added here.
*/
switch (sc->ipmi_io_type) {
case SMB_IPMI_T_KCS:
if (ipmi_kcs_attach(sc) != 0)
return (DDI_FAILURE);
break;
default:
return (DDI_FAILURE);
}
ipmi_found = B_TRUE;
if (ddi_create_minor_node(dip, "ipmi", S_IFCHR, 0, DDI_PSEUDO,
0) == DDI_FAILURE) {
cmn_err(CE_WARN, "!attach could not create minor node");
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
ipmi_dip = dip;
list_create(&dev_list, sizeof (ipmi_device_t),
offsetof(ipmi_device_t, ipmi_node));
/* Create ID space for open devs. ID 0 is reserved. */
minor_ids = id_space_create("ipmi_id_space", 1, 128);
if (ipmi_startup(sc) != B_TRUE) {
ipmi_cleanup(dip);
return (DDI_FAILURE);
}
ipmi_attached = B_TRUE;
return (DDI_SUCCESS);
}
static int
rnd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, "random", S_IFCHR, DEVRANDOM,
DDI_PSEUDO, 0) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
if (ddi_create_minor_node(dip, "urandom", S_IFCHR, DEVURANDOM,
DDI_PSEUDO, 0) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
rnd_dip = dip;
return (DDI_SUCCESS);
}
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
evtchndrv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int error;
int unit = ddi_get_instance(dip);
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
cmn_err(CE_WARN, "evtchn_attach: unknown cmd 0x%x\n", cmd);
return (DDI_FAILURE);
}
/* DDI_ATTACH */
/*
* only one instance - but we clone using the open routine
*/
if (ddi_get_instance(dip) > 0)
return (DDI_FAILURE);
mutex_init(&evtchndrv_clone_tab_mutex, NULL, MUTEX_DRIVER,
NULL);
error = ddi_create_minor_node(dip, "evtchn", S_IFCHR, unit,
DDI_PSEUDO, NULL);
if (error != DDI_SUCCESS)
goto fail;
/*
* save dip for getinfo
*/
evtchndrv_dip = dip;
ddi_report_dev(dip);
mutex_init(&port_user_lock, NULL, MUTEX_DRIVER, NULL);
(void) memset(port_user, 0, sizeof (port_user));
ec_dev_irq = ec_dev_alloc_irq();
(void) add_avintr(NULL, IPL_EVTCHN, (avfunc)evtchn_device_upcall,
"evtchn_driver", ec_dev_irq, NULL, NULL, NULL, dip);
return (DDI_SUCCESS);
fail:
(void) evtchndrv_detach(dip, DDI_DETACH);
return (error);
}
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
dump_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(devi, "dump", S_IFCHR, 0, DDI_PSEUDO, NULL) ==
DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
dump_devi = devi;
return (DDI_SUCCESS);
}
static int
tsalarm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int inst;
struct tsalarm_softc *softc = NULL;
switch (cmd) {
case DDI_ATTACH:
inst = ddi_get_instance(dip);
/*
* Allocate a soft state structure for this instance.
*/
if (ddi_soft_state_zalloc(statep, inst) != DDI_SUCCESS)
goto attach_failed;
softc = getsoftc(inst);
softc->dip = dip;
mutex_init(&softc->mutex, NULL, MUTEX_DRIVER, NULL);
/*
* Create minor node. The minor device number, inst, has no
* meaning. The model number above, which will be added to
* the device's softc, is used to direct peculiar behavior.
*/
if (ddi_create_minor_node(dip, "lom", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE)
goto attach_failed;
ddi_report_dev(dip);
return (DDI_SUCCESS);
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
attach_failed:
/* Free soft state, if allocated. remove minor node if added earlier */
if (softc) {
mutex_destroy(&softc->mutex);
ddi_soft_state_free(statep, inst);
}
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}