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); }