static int
ghd_doneq_init(ccc_t *cccp)
{
ddi_iblock_cookie_t iblock;
L2_INIT(&cccp->ccc_doneq);
cccp->ccc_hba_pollmode = TRUE;
if (ddi_add_softintr(cccp->ccc_hba_dip, DDI_SOFTINT_LOW,
&cccp->ccc_doneq_softid, &iblock, NULL,
ghd_doneq_process, (caddr_t)cccp) != DDI_SUCCESS) {
GDBG_ERROR(("ghd_doneq_init: add softintr failed cccp 0x%p\n",
(void *)cccp));
return (FALSE);
}
mutex_init(&cccp->ccc_doneq_mutex, NULL, MUTEX_DRIVER, iblock);
ghd_doneq_pollmode_exit(cccp);
return (TRUE);
}
int
rmc_comm_serdev_init(struct rmc_comm_state *rcs, dev_info_t *dip)
{
cyc_handler_t cychand;
cyc_time_t cyctime;
int err = DDI_SUCCESS;
rcs->sd_state.cycid = CYCLIC_NONE;
/*
* Online the hardware ...
*/
err = rmc_comm_online(rcs, dip);
if (err != 0)
return (-1);
/*
* call ddi_get_soft_iblock_cookie() to retrieve the
* the interrupt block cookie so that the mutexes are initialized
* before adding the interrupt (to avoid a potential race condition).
*/
err = ddi_get_soft_iblock_cookie(dip, DDI_SOFTINT_LOW,
&rcs->dp_state.dp_iblk);
if (err != DDI_SUCCESS)
return (-1);
err = ddi_get_iblock_cookie(dip, 0, &rcs->sd_state.hw_iblk);
if (err != DDI_SUCCESS)
return (-1);
/*
* initialize mutex here before adding hw/sw interrupt handlers
*/
mutex_init(rcs->dp_state.dp_mutex, NULL, MUTEX_DRIVER,
rcs->dp_state.dp_iblk);
mutex_init(rcs->sd_state.hw_mutex, NULL, MUTEX_DRIVER,
rcs->sd_state.hw_iblk);
/*
* Install soft and hard interrupt handler(s)
*
* the soft intr. handler will need the data protocol lock (dp_mutex)
* So, data protocol mutex and iblock cookie are created/initialized
* here
*/
err = ddi_add_softintr(dip, DDI_SOFTINT_LOW, &rcs->sd_state.softid,
&rcs->dp_state.dp_iblk, NULL, rmc_comm_softint, (caddr_t)rcs);
if (err != DDI_SUCCESS) {
mutex_destroy(rcs->dp_state.dp_mutex);
mutex_destroy(rcs->sd_state.hw_mutex);
return (-1);
}
/*
* hardware interrupt
*/
if (rcs->sd_state.sio_handle != NULL) {
err = ddi_add_intr(dip, 0, &rcs->sd_state.hw_iblk, NULL,
rmc_comm_hi_intr, (caddr_t)rcs);
/*
* did we successfully install the h/w interrupt handler?
*/
if (err != DDI_SUCCESS) {
ddi_remove_softintr(rcs->sd_state.softid);
mutex_destroy(rcs->dp_state.dp_mutex);
mutex_destroy(rcs->sd_state.hw_mutex);
return (-1);
}
}
/*
* Start cyclic callbacks
*/
cychand.cyh_func = rmc_comm_cyclic;
cychand.cyh_arg = rcs;
cychand.cyh_level = CY_LOW_LEVEL;
cyctime.cyt_when = 0; /* from the next second */
cyctime.cyt_interval = 5*RMC_COMM_ONE_SEC; /* call at 5s intervals */
mutex_enter(&cpu_lock);
rcs->sd_state.cycid = cyclic_add(&cychand, &cyctime);
mutex_exit(&cpu_lock);
return (0);
}
static int
ntwdt_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int instance;
ntwdt_state_t *ntwdt_ptr = NULL; /* pointer to ntwdt_runstatep */
ntwdt_runstate_t *ntwdt_runstatep = NULL;
cyc_handler_t *hdlr = NULL;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ntwdt_chk_watchdog_support() != 0) {
return (DDI_FAILURE);
}
instance = ddi_get_instance(dip);
ASSERT(instance == 0);
if (ddi_soft_state_zalloc(ntwdt_statep, instance) != DDI_SUCCESS) {
return (DDI_FAILURE);
}
ntwdt_ptr = ddi_get_soft_state(ntwdt_statep, instance);
ASSERT(ntwdt_ptr != NULL);
ntwdt_dip = dip;
ntwdt_ptr->ntwdt_dip = dip;
ntwdt_ptr->ntwdt_cycl_id = CYCLIC_NONE;
mutex_init(&ntwdt_ptr->ntwdt_mutex, NULL,
MUTEX_DRIVER, NULL);
/*
* Initialize the watchdog structure
*/
ntwdt_ptr->ntwdt_run_state =
kmem_zalloc(sizeof (ntwdt_runstate_t), KM_SLEEP);
ntwdt_runstatep = ntwdt_ptr->ntwdt_run_state;
if (ddi_get_soft_iblock_cookie(dip, DDI_SOFTINT_LOW,
&ntwdt_runstatep->ntwdt_runstate_mtx_cookie) != DDI_SUCCESS) {
cmn_err(CE_WARN, "init of iblock cookie failed "
"for ntwdt_runstate_mutex");
goto err1;
} else {
mutex_init(&ntwdt_runstatep->ntwdt_runstate_mutex,
NULL,
MUTEX_DRIVER,
(void *)ntwdt_runstatep->ntwdt_runstate_mtx_cookie);
}
/* Cyclic fires once per second: */
ntwdt_runstatep->ntwdt_cyclic_interval = NTWDT_CYCLIC_INTERVAL;
/* init the Cyclic that drives the NTWDT */
hdlr = &ntwdt_runstatep->ntwdt_cycl_hdlr;
hdlr->cyh_level = CY_LOCK_LEVEL;
hdlr->cyh_func = (cyc_func_t)ntwdt_cyclic_pat;
hdlr->cyh_arg = NULL;
/* Softint that will be triggered by Cyclic that drives NTWDT */
if (ddi_add_softintr(dip, DDI_SOFTINT_LOW, &ntwdt_cyclic_softint_id,
NULL, NULL, ntwdt_cyclic_softint, (caddr_t)ntwdt_ptr)
!= DDI_SUCCESS) {
cmn_err(CE_WARN, "failed to add cyclic softintr");
goto err2;
}
/*
* Create Minor Node as last activity. This prevents
* application from accessing our implementation until it
* is initialized.
*/
if (ddi_create_minor_node(dip, NTWDT_MINOR_NODE, S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE) {
cmn_err(CE_WARN, "failed to create Minor Node: %s",
NTWDT_MINOR_NODE);
goto err3;
}
/* Display our driver info in the banner */
ddi_report_dev(dip);
return (DDI_SUCCESS);
err3:
ddi_remove_softintr(ntwdt_cyclic_softint_id);
err2:
mutex_destroy(&ntwdt_runstatep->ntwdt_runstate_mutex);
err1:
/* clean up the driver stuff here */
kmem_free(ntwdt_runstatep, sizeof (ntwdt_runstate_t));
ntwdt_ptr->ntwdt_run_state = NULL;
mutex_destroy(&ntwdt_ptr->ntwdt_mutex);
ddi_soft_state_free(ntwdt_statep, instance);
ntwdt_dip = NULL;
return (DDI_FAILURE);
}
static int
ds1287_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
struct ds1287 *softsp;
DPRINTF("ds1287_attach\n");
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (instance != -1) {
cmn_err(CE_WARN, "ds1287_attach: Another instance is already "
"attached.");
return (DDI_FAILURE);
}
instance = ddi_get_instance(dip);
if (v_rtc_addr_reg == NULL) {
cmn_err(CE_WARN, "ds1287_attach: v_rtc_addr_reg is NULL");
return (DDI_FAILURE);
}
/*
* Allocate softc information.
*/
if (ddi_soft_state_zalloc(ds1287_state, instance) != DDI_SUCCESS) {
cmn_err(CE_WARN, "ds1287_attach: Failed to allocate "
"soft states.");
return (DDI_FAILURE);
}
softsp = ddi_get_soft_state(ds1287_state, instance);
DPRINTF("ds1287_attach: instance=%d softsp=0x%p\n", instance,
(void *)softsp);
softsp->dip = dip;
if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
"interrupt-priorities", (caddr_t)&ds1287_interrupt_priority,
sizeof (int)) != DDI_PROP_SUCCESS) {
cmn_err(CE_WARN, "ds1287_attach: Failed to create \""
"interrupt-priorities\" property.");
goto error;
}
/* add the softint */
ds1287_lo_iblock = (ddi_iblock_cookie_t)(uintptr_t)
ipltospl(ds1287_softint_priority);
if (ddi_add_softintr(dip, DDI_SOFTINT_FIXED, &ds1287_softintr_id,
&ds1287_lo_iblock, NULL, ds1287_softintr, (caddr_t)softsp) !=
DDI_SUCCESS) {
cmn_err(CE_WARN, "ds1287_attach: Failed to add low interrupt.");
goto error1;
}
/* add the hi interrupt */
if (ddi_add_intr(dip, 0, NULL, (ddi_idevice_cookie_t *)
&ds1287_hi_iblock, ds1287_intr, NULL) != DDI_SUCCESS) {
cmn_err(CE_WARN, "ds1287_attach: Failed to add high "
"interrupt.");
goto error2;
}
/*
* Combination of instance number and clone number 0 is used for
* creating the minor node.
*/
if (ddi_create_minor_node(dip, "power_button", S_IFCHR,
(instance << 8) + 0, "ddi_power_button", NULL) == DDI_FAILURE) {
cmn_err(CE_WARN, "ds1287_attach: Failed to create minor node");
goto error3;
}
ddi_report_dev(dip);
return (DDI_SUCCESS);
error3:
ddi_remove_intr(dip, 0, NULL);
error2:
ddi_remove_softintr(ds1287_softintr_id);
error1:
(void) ddi_prop_remove(DDI_DEV_T_NONE, dip, "interrupt-priorities");
error:
ddi_soft_state_free(ds1287_state, instance);
return (DDI_FAILURE);
}
