Lines Matching defs:ssp
95 static int bscv_tryenter(bscv_soft_state_t *ssp);
159 static void bscv_event_process(bscv_soft_state_t *ssp, boolean_t);
206 static void bscv_write_sig(bscv_soft_state_t *ssp, bscv_sig_t s);
209 static void bscv_setup_watchdog(bscv_soft_state_t *ssp);
493 bscv_soft_state_t *ssp;
507 ssp = ddi_get_soft_state(bscv_statep, instance);
508 if (ssp == NULL)
510 *result = (void *) ssp->dip;
602 bscv_soft_state_t *ssp;
616 ssp = ddi_get_soft_state(bscv_statep, instance);
618 ssp->progress = 0;
620 ssp->dip = dip;
621 ssp->instance = instance;
622 ssp->event_waiting = B_FALSE;
623 ssp->status_change = B_FALSE;
624 ssp->nodename_change = B_FALSE;
625 ssp->cap0 = 0;
626 ssp->cap1 = 0;
627 ssp->cap2 = 0;
628 ssp->prog_mode_only = B_FALSE;
629 ssp->programming = B_FALSE;
630 ssp->cssp_prog = B_FALSE;
631 ssp->task_flags = 0;
632 ssp->debug = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
634 ssp->majornum = ddi_driver_major(dip);
635 ssp->minornum = BSCV_INST_TO_MINOR(instance);
637 ssp->last_nodename[0] = '\0';
644 mutex_init(&ssp->cmd_mutex, NULL, MUTEX_DRIVER, NULL);
646 mutex_init(&ssp->task_mu, NULL, MUTEX_DRIVER, NULL);
647 cv_init(&ssp->task_cv, NULL, CV_DRIVER, NULL);
648 cv_init(&ssp->task_evnt_cv, NULL, CV_DRIVER, NULL);
649 mutex_init(&ssp->prog_mu, NULL, MUTEX_DRIVER, NULL);
650 ssp->progress |= BSCV_LOCKS;
652 BSCV_TRACE(ssp, 'A', "bscv_attach",
657 if (bscv_map_regs(ssp) != DDI_SUCCESS) {
658 (void) bscv_cleanup(ssp);
661 ssp->progress |= BSCV_MAPPED_REGS;
665 bscv_map_chan_logical_physical(ssp);
667 bscv_enter(ssp);
669 bscv_leave_programming_mode(ssp, B_FALSE);
671 if (bscv_attach_common(ssp) == DDI_FAILURE) {
672 bscv_exit(ssp);
673 (void) bscv_cleanup(ssp);
686 bscv_exit(ssp);
691 if (ddi_create_minor_node(ssp->dip, "lom", S_IFCHR,
694 (void) bscv_cleanup(ssp);
697 BSCV_TRACE(ssp, 'A', "bscv_attach",
699 ssp->progress |= BSCV_NODES;
701 if (!ssp->prog_mode_only)
702 bscv_start_event_daemon(ssp);
721 ssp->callb_id = callb_add(bscv_panic_callback,
722 (void *)ssp, CB_CL_PANIC, "");
725 (void) bscv_set_watchdog_timer(ssp,
727 bscv_enter(ssp);
728 bscv_setup_watchdog(ssp); /* starts cyclic callback */
729 bscv_exit(ssp);
768 bscv_soft_state_t *ssp;
773 ssp = ddi_get_soft_state(bscv_statep, instance);
774 if (ssp == NULL) {
782 bscv_full_stop(ssp);
808 bscv_soft_state_t *ssp;
812 ssp = ddi_get_soft_state(bscv_statep, instance);
813 if (ssp == NULL) {
816 BSCV_TRACE(ssp, 'O', "bscv_open", "instance 0x%x", instance);
839 bscv_soft_state_t *ssp;
843 ssp = ddi_get_soft_state(bscv_statep, instance);
844 if (ssp == NULL) {
847 BSCV_TRACE(ssp, 'O', "bscv_close", "instance 0x%x", instance);
853 bscv_map_regs(bscv_soft_state_t *ssp)
860 ASSERT(ssp);
862 ssp->nchannels = 0;
868 retval = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, ssp->dip,
877 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "lookup reg returned"
881 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "nelements %d not"
885 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "nelements %d too large"
889 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "nelements %d too small"
895 ssp->nchannels = nelements / LOMBUS_REGSPEC_SIZE;
897 ssp->attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
898 ssp->attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
899 ssp->attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
901 for (i = 0; i < ssp->nchannels; i++) {
902 retval = ddi_regs_map_setup(ssp->dip, i,
903 (caddr_t *)&ssp->channel[i].regs,
904 0, 0, &ssp->attr, &ssp->channel[i].handle);
906 BSCV_TRACE(ssp, 'A', "bscv_map_regs", "map failure"
912 ddi_regs_map_free(&ssp->channel[i].handle);
928 ssp->nchannels = 0;
933 bscv_unmap_regs(bscv_soft_state_t *ssp)
937 ASSERT(ssp);
939 for (i = 0; i < ssp->nchannels; i++) {
940 ddi_regs_map_free(&ssp->channel[i].handle);
948 bscv_map_chan_logical_physical(bscv_soft_state_t *ssp)
950 ASSERT(ssp);
966 if (ssp->nchannels > 2)
968 if (ssp->nchannels > 3)
970 if (ssp->nchannels > 4)
983 bscv_full_stop(bscv_soft_state_t *ssp)
989 BSCV_TRACE(ssp, 'W', "bscv_full_stop",
999 obtained_lock = (bscv_tryenter(ssp) != 0);
1003 bscv_inform_bsc(ssp, BSC_INFORM_PANIC);
1005 bscv_inform_bsc(ssp, BSC_INFORM_OFFLINE);
1010 switch (ssp->serial_reporting) {
1023 bscv_setclear8_volatile(ssp, chan_general,
1028 bscv_exit(ssp);
1130 bscv_enter(bscv_soft_state_t *ssp)
1132 BSCV_TRACE(ssp, '@', "bscv_enter", "");
1133 mutex_enter(&ssp->cmd_mutex);
1134 ssp->had_session_error = B_FALSE;
1138 bscv_tryenter(bscv_soft_state_t *ssp)
1142 BSCV_TRACE(ssp, '@', "bscv_tryenter", "");
1143 if ((rv = mutex_tryenter(&ssp->cmd_mutex)) != 0) {
1144 ssp->had_session_error = B_FALSE;
1150 bscv_exit(bscv_soft_state_t *ssp)
1152 mutex_exit(&ssp->cmd_mutex);
1153 BSCV_TRACE(ssp, '@', "bscv_exit", "");
1158 bscv_held(bscv_soft_state_t *ssp)
1160 return (mutex_owned(&ssp->cmd_mutex));
1165 bscv_put8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t val)
1170 ASSERT(bscv_held(ssp));
1172 if (bscv_faulty(ssp)) {
1176 BSCV_TRACE(ssp, '@', "bscv_put8",
1182 bscv_put8_once(ssp, chan, addr, val);
1183 needretry = bscv_should_retry(ssp);
1188 if (ssp->command_error != 0) {
1189 ssp->had_session_error = B_TRUE;
1197 bscv_set_fault(ssp);
1199 BSCV_TRACE(ssp, 'R', "bscv_put8",
1206 bscv_put16(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint16_t val)
1208 ASSERT(bscv_held(ssp));
1209 BSCV_TRACE(ssp, '@', "bscv_put16",
1211 bscv_put8(ssp, chan, addr, val >> 8);
1212 bscv_put8(ssp, chan, addr + 1, val & 0xff);
1216 bscv_put32(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint32_t val)
1218 ASSERT(bscv_held(ssp));
1219 BSCV_TRACE(ssp, '@', "bscv_put32",
1221 bscv_put8(ssp, chan, addr, (val >> 24) & 0xff);
1222 bscv_put8(ssp, chan, addr + 1, (val >> 16) & 0xff);
1223 bscv_put8(ssp, chan, addr + 2, (val >> 8) & 0xff);
1224 bscv_put8(ssp, chan, addr + 3, val & 0xff);
1228 bscv_get8(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1234 ASSERT(bscv_held(ssp));
1236 if (bscv_faulty(ssp)) {
1243 retval = bscv_get8_once(ssp, chan, addr);
1244 needretry = bscv_should_retry(ssp);
1249 if (ssp->command_error != 0) {
1250 ssp->had_session_error = B_TRUE;
1258 bscv_set_fault(ssp);
1260 BSCV_TRACE(ssp, 'R', "bscv_get8",
1265 BSCV_TRACE(ssp, '@', "bscv_get8",
1271 bscv_get16(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1275 ASSERT(bscv_held(ssp));
1277 retval = bscv_get8(ssp, chan, addr) << 8;
1278 retval |= bscv_get8(ssp, chan, addr + 1);
1280 BSCV_TRACE(ssp, '@', "bscv_get16",
1286 bscv_get32(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1290 ASSERT(bscv_held(ssp));
1292 retval = bscv_get8(ssp, chan, addr) << 24;
1293 retval |= bscv_get8(ssp, chan, addr + 1) << 16;
1294 retval |= bscv_get8(ssp, chan, addr + 2) << 8;
1295 retval |= bscv_get8(ssp, chan, addr + 3);
1297 BSCV_TRACE(ssp, '@', "bscv_get32",
1303 bscv_setclear8(bscv_soft_state_t *ssp, int chan,
1308 ASSERT(bscv_held(ssp));
1311 val = ssp->lom_regs[addr] | set;
1314 BSCV_TRACE(ssp, '@', "bscv_setclear8",
1319 bscv_put8(ssp, chan, addr, val);
1323 bscv_setclear8_volatile(bscv_soft_state_t *ssp, int chan,
1330 ASSERT(bscv_held(ssp));
1333 if (bscv_faulty(ssp)) {
1337 BSCV_TRACE(ssp, '@', "bscv_setclear8_volatile",
1341 val = bscv_get8_cached(ssp, addr);
1347 bscv_put8_once(ssp, chan, addr, val);
1348 if (ssp->command_error == EBUS_ERROR_STALEDATA) {
1350 val = bscv_get8_once(ssp, chan, addr);
1353 needretry = bscv_should_retry(ssp);
1359 if (ssp->command_error != 0) {
1360 ssp->had_session_error = B_TRUE;
1368 if (ssp->command_error != EBUS_ERROR_STALEDATA) {
1369 bscv_set_fault(ssp);
1372 BSCV_TRACE(ssp, 'R', "bscv_setclear8_volatile",
1379 bscv_rep_rw8(bscv_soft_state_t *ssp, int chan, uint8_t *host_addr,
1385 ASSERT(bscv_held(ssp));
1391 bscv_put8(ssp, chan, dev_addr, *host_addr++);
1393 *host_addr++ = bscv_get8(ssp, chan, dev_addr);
1397 bscv_put8_once(ssp, chan,
1400 *host_addr++ = bscv_get8_once(ssp, chan,
1404 if (ssp->command_error != 0) {
1405 ssp->had_session_error = B_TRUE;
1408 if (bscv_faulty(ssp) || bscv_session_error(ssp)) {
1420 bscv_get8_cached(bscv_soft_state_t *ssp, bscv_addr_t addr)
1425 return (ssp->lom_regs[addr]);
1429 bscv_get8_locked(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, int *res)
1434 bscv_enter(ssp);
1435 retval = bscv_get8(ssp, chan, addr);
1436 bscv_locked_result(ssp, res);
1437 bscv_exit(ssp);
1438 BSCV_TRACE(ssp, '@', "bscv_get8_locked",
1444 bscv_rep_get8_locked(bscv_soft_state_t *ssp, int chan, uint8_t *host_addr,
1447 bscv_enter(ssp);
1448 bscv_rep_rw8(ssp, chan, host_addr, dev_addr, repcount,
1450 bscv_locked_result(ssp, res);
1451 bscv_exit(ssp);
1455 bscv_faulty(bscv_soft_state_t *ssp)
1457 ASSERT(bscv_held(ssp));
1458 return (ssp->had_fault);
1462 bscv_clear_fault(bscv_soft_state_t *ssp)
1464 ASSERT(bscv_held(ssp));
1465 BSCV_TRACE(ssp, 'J', "bscv_clear_fault", "clearing fault flag");
1466 ssp->had_fault = B_FALSE;
1467 ssp->had_session_error = B_FALSE;
1471 bscv_set_fault(bscv_soft_state_t *ssp)
1473 ASSERT(bscv_held(ssp));
1474 BSCV_TRACE(ssp, 'J', "bscv_set_fault", "setting fault flag");
1475 ssp->had_fault = B_TRUE;
1479 bscv_session_error(bscv_soft_state_t *ssp)
1481 ASSERT(bscv_held(ssp));
1482 return (ssp->had_session_error);
1486 bscv_retcode(bscv_soft_state_t *ssp)
1488 BSCV_TRACE(ssp, '@', "bscv_retcode",
1489 "code 0x%x", ssp->command_error);
1490 return (ssp->command_error);
1494 bscv_should_retry(bscv_soft_state_t *ssp)
1496 if ((ssp->command_error == EBUS_ERROR_DEVICEFAIL) ||
1497 (ssp->command_error >= LOMBUS_ERR_BASE)) {
1513 bscv_locked_result(bscv_soft_state_t *ssp, int *res)
1515 if (bscv_faulty(ssp) || (bscv_retcode(ssp) != 0)) {
1521 bscv_put8_once(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr, uint8_t val)
1525 ASSERT(bscv_held(ssp));
1527 ssp->command_error = 0;
1529 if (bscv_faulty(ssp)) {
1532 } else if (ssp->nchannels == 0) {
1534 BSCV_TRACE(ssp, '@', "bscv_put8_once",
1540 ddi_put32(ssp->channel[chan].handle,
1541 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0);
1544 ddi_put8(ssp->channel[chan].handle,
1545 &ssp->channel[chan].regs[addr], val);
1546 fault = ddi_get32(ssp->channel[chan].handle,
1547 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG));
1549 ssp->command_error = fault;
1555 ssp->lom_regs[addr] = val;
1563 bscv_resync_comms(ssp, chan);
1573 BSCV_TRACE(ssp, '@', "bscv_put8_once",
1578 bscv_get8_once(bscv_soft_state_t *ssp, int chan, bscv_addr_t addr)
1583 ASSERT(bscv_held(ssp));
1585 ssp->command_error = 0;
1587 if (bscv_faulty(ssp)) {
1590 } else if (ssp->nchannels == 0) {
1592 BSCV_TRACE(ssp, '@', "bscv_get8_once",
1598 ddi_put32(ssp->channel[chan].handle,
1599 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0);
1602 val = ddi_get8(ssp->channel[chan].handle,
1603 &ssp->channel[chan].regs[addr]);
1604 fault = ddi_get32(ssp->channel[chan].handle,
1605 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG));
1606 ssp->command_error = fault;
1614 bscv_resync_comms(ssp, chan);
1630 if (!bscv_faulty(ssp)) {
1633 ssp->lom_regs[addr] = val;
1637 BSCV_TRACE(ssp, '@', "bscv_get8_once",
1643 bscv_probe(bscv_soft_state_t *ssp, int chan, uint32_t *fault)
1647 if (ssp->nchannels == 0) {
1652 BSCV_TRACE(ssp, '@', "bscv_probe",
1659 ddi_put32(ssp->channel[chan].handle,
1660 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_FAULT_REG), 0);
1662 *fault = ddi_get32(ssp->channel[chan].handle,
1663 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_PROBE_REG));
1665 async_reg = ddi_get32(ssp->channel[chan].handle,
1666 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0, LOMBUS_ASYNC_REG));
1668 BSCV_TRACE(ssp, '@', "bscv_probe",
1674 bscv_resync_comms(bscv_soft_state_t *ssp, int chan)
1677 uint32_t command_error = ssp->command_error;
1680 if (ssp->nchannels == 0) {
1685 BSCV_TRACE(ssp, '@', "bscv_resync_comms",
1699 fault = ddi_get32(ssp->channel[chan].handle,
1700 (uint32_t *)BSC_NEXUS_ADDR(ssp, chan, 0,
1714 ssp->bad_resync++;
1718 ssp->bad_resync = 0;
1741 bscv_window_setup(bscv_soft_state_t *ssp)
1743 ASSERT(bscv_held(ssp));
1745 if (ssp->eeinfo_valid) {
1747 return (ssp->eeinfo_valid);
1749 ssp->eeprom_size =
1750 bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) * 1024;
1751 ssp->eventlog_start = bscv_get16(ssp, chan_general,
1759 ssp->eventlog_size = EBUS_LOG_END - ssp->eventlog_start;
1761 BSCV_TRACE(ssp, 'I', "bscv_window_setup", "eeprom size 0x%x log_start"
1762 " 0x%x log_size 0x%x", ssp->eeprom_size, ssp->eventlog_start,
1763 ssp->eventlog_size);
1765 if (bscv_faulty(ssp) || bscv_session_error(ssp)) {
1766 ssp->eeinfo_valid = B_FALSE;
1767 } else if ((ssp->eeprom_size == 0) ||
1768 (ssp->eventlog_start >= ssp->eeprom_size)) {
1772 ssp->eeinfo_valid = B_FALSE;
1774 ssp->eeinfo_valid = B_TRUE;
1777 BSCV_TRACE(ssp, 'I', "bscv_window_setup", "returning eeinfo_valid %s",
1778 ssp->eeinfo_valid ? "true" : "false");
1779 return (ssp->eeinfo_valid);
1790 bscv_eerw(bscv_soft_state_t *ssp, uint32_t eeoffset, uint8_t *buf,
1810 bscv_put8(ssp, chan_eeprom, EBUS_IDX_EEPROM_PAGESEL, this_page);
1812 BSCV_TRACE(ssp, 'M', "lom_eerw",
1817 bscv_rep_rw8(ssp, chan_eeprom,
1821 if (bscv_faulty(ssp) || bscv_session_error(ssp)) {
1835 bscv_is_null_event(bscv_soft_state_t *ssp, lom_event_t *e)
1844 BSCV_TRACE(ssp, 'E', "bscv_is_null_event",
1853 BSCV_TRACE(ssp, 'E', "bscv_is_null_event", "0xffff null event");
1859 BSCV_TRACE(ssp, 'E', "bscv_is_null_event", "returning False");
1923 bscv_soft_state_t *ssp;
1928 ssp = ddi_get_soft_state(bscv_statep, instance);
1929 if (ssp == NULL) {
1968 if (ssp->cssp_prog) {
1970 } else if ((ssp->prog_mode_only || ssp->programming) &&
1997 res = bscv_ioc_dogstate(ssp, arg, mode);
2001 res = bscv_prog(ssp, arg, mode);
2005 res = bscv_ioc_psustate(ssp, arg, mode);
2009 res = bscv_ioc_fanstate(ssp, arg, mode);
2013 res = bscv_ioc_fledstate(ssp, arg, mode);
2017 res = bscv_ioc_ledstate(ssp, arg, mode);
2021 res = bscv_ioc_info(ssp, arg, mode);
2025 res = bscv_ioc_mread(ssp, arg, mode);
2029 res = bscv_ioc_volts(ssp, arg, mode);
2033 res = bscv_ioc_stats(ssp, arg, mode);
2037 res = bscv_ioc_temp(ssp, arg, mode);
2041 res = bscv_ioc_cons(ssp, arg, mode);
2045 res = bscv_ioc_eventlog2(ssp, arg, mode);
2049 res = bscv_ioc_info2(ssp, arg, mode);
2053 res = bscv_ioc_test(ssp, arg, mode);
2057 res = bscv_ioc_mprog2(ssp, arg, mode);
2061 res = bscv_ioc_mread2(ssp, arg, mode);
2065 BSCV_TRACE(ssp, 'I', "bscv_ioctl", "Invalid IOCTL 0x%x", cmd);
2077 bscv_ioc_dogstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2083 dogval = bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_CTRL, &res);
2086 dogstate.dog_timeout = bscv_get8_locked(ssp, chan_general,
2104 bscv_ioc_psustate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2112 psustat = bscv_get8_locked(ssp, chan_general,
2136 bscv_ioc_fanstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2144 numfans = EBUS_CONFIG_NFAN_DEC(bscv_get8_locked(ssp,
2147 if (ssp->fanspeed[i] != LOM_FAN_NOT_PRESENT) {
2149 fandata.speed[i] = ssp->fanspeed[i];
2150 fandata.minspeed[i] = bscv_get8_cached(ssp,
2167 bscv_ioc_fledstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2173 fledstate = bscv_get8_locked(ssp, chan_general, EBUS_IDX_ALARM, &res);
2194 bscv_ioc_ledstate(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2219 fw_led_state = bscv_get8_locked(ssp, chan_general,
2251 ssp->led_names[led_state.index]);
2271 bscv_ioc_info(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2278 info.ser_char = bscv_get8_locked(ssp, chan_general, EBUS_IDX_ESCAPE,
2281 info.fver = bscv_get8_locked(ssp, chan_general, EBUS_IDX_FW_REV, &res);
2282 csum = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_HI, &res)
2284 csum |= bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_LO, &res);
2286 info.prod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV,
2289 info.prod_id[i] = bscv_get8_locked(ssp,
2292 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_ALARM, &res) &
2311 bscv_ioc_mread(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2319 mprog.mod_id[i] = bscv_get8_locked(ssp, chan_general,
2322 mprog.mod_rev = bscv_get8_locked(ssp, chan_general, EBUS_IDX_MODEL_REV,
2324 mprog.config = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG,
2330 mprog.fanhz[i] = bscv_get8_cached(ssp,
2332 mprog.fanmin[i] = bscv_get8_cached(ssp,
2348 bscv_ioc_volts(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2354 supply = (bscv_get8_locked(ssp, chan_general, EBUS_IDX_SUPPLY_HI, &res)
2355 << 8) | bscv_get8_locked(ssp, chan_general, EBUS_IDX_SUPPLY_LO,
2358 for (i = 0; i < ssp->volts.num; i++) {
2359 ssp->volts.status[i] = (supply >> i) & 1;
2363 (ddi_copyout((caddr_t)&ssp->volts, (caddr_t)arg,
2364 sizeof (ssp->volts), mode) < 0)) {
2374 bscv_ioc_stats(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2380 status = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CBREAK_STATUS,
2382 for (i = 0; i < ssp->sflags.num; i++) {
2383 ssp->sflags.status[i] = (int)((status >> i) & 1);
2387 (ddi_copyout((caddr_t)&ssp->sflags, (caddr_t)arg,
2388 sizeof (ssp->sflags), mode) < 0)) {
2398 bscv_ioc_temp(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2408 for (i = 0; i < ssp->temps.num; i++) {
2409 if (ssp->temps.temp[i] != LOM_TEMP_STATE_NOT_PRESENT) {
2410 temps.temp[idx] = ssp->temps.temp[i];
2411 bcopy(ssp->temps.name[i], temps.name[idx],
2413 temps.warning[idx] = ssp->temps.warning[i];
2414 temps.shutdown[idx] = ssp->temps.shutdown[i];
2420 bcopy(ssp->temps.name_ov, temps.name_ov, sizeof (temps.name_ov));
2421 temps.num_ov = ssp->temps.num_ov;
2422 status_ov = bscv_get8_locked(ssp, chan_general, EBUS_IDX_OTEMP_STATUS,
2424 for (i = 0; i < ssp->temps.num_ov; i++) {
2425 ssp->temps.status_ov[i] = (status_ov >> i) & 1;
2440 bscv_ioc_cons(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2452 bscv_rep_get8_locked(ssp, chan_general, (uint8_t *)cbuf.lrbuf,
2470 bscv_ioc_eventlog2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2492 bscv_enter(ssp);
2500 if (!bscv_window_setup(ssp)) {
2502 bscv_exit(ssp);
2511 (void) bscv_get8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS);
2512 next_offset = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_PTR_HI);
2513 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "log_ptr_hi 0x%x",
2526 if (next_offset <= ssp->eventlog_start) {
2528 next_offset = ssp->eventlog_start + ssp->eventlog_size;
2529 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "wrapping"
2535 if (bscv_eerw(ssp, next_offset, (uint8_t *)&event,
2538 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "read"
2544 if (bscv_is_null_event(ssp, &event)) {
2548 BSCV_TRACE(ssp, 'I', "bscv_ioc_eventlog2", "no more"
2572 bscv_build_eventstring(ssp,
2582 bscv_exit(ssp);
2598 bscv_ioc_info2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2607 (void) strncpy(info2.escape_chars, ssp->escape_chars,
2609 info2.serial_events = ssp->reporting_level | ssp->serial_reporting;
2612 info2.fver = bscv_get8_locked(ssp, chan_general, EBUS_IDX_FW_REV, &res);
2613 csum = bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_HI, &res)
2615 csum |= bscv_get8_locked(ssp, chan_general, EBUS_IDX_CHECK_LO, &res);
2617 info2.prod_rev = bscv_get8_locked(ssp, chan_general,
2620 info2.prod_id[i] = bscv_get8_locked(ssp, chan_general,
2623 info2.serial_config = bscv_get8_locked(ssp, chan_general,
2625 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG_MISC, &res) &
2629 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_CONFIG_MISC, &res) &
2633 if (bscv_get8_locked(ssp, chan_general, EBUS_IDX_WDOG_CTRL, &res) &
2637 info2.baud_rate = bscv_get8_locked(ssp, chan_general,
2640 ((int)bscv_get8_locked(ssp, chan_general,
2642 ((int)bscv_get8_locked(ssp, chan_general,
2644 ((int)bscv_get8_locked(ssp, chan_general,
2654 for (i = 0; i < ssp->num_fans; i++) {
2655 (void) strcpy(info2.fan_names[i], ssp->fan_names[i]);
2670 bscv_ioc_test(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2689 BSCV_TRACE(ssp, 'F', "bscv_ioc_test",
2710 bscv_enter(ssp);
2716 bscv_put8(ssp, chan_general,
2718 if (bscv_faulty(ssp)) {
2722 test = bscv_retcode(ssp);
2725 bscv_exit(ssp);
2729 BSCV_TRACE(ssp, 'F', "bscv_ioc_test",
2743 bscv_ioc_mprog2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2764 bscv_enter(ssp);
2770 eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) *
2773 if (bscv_faulty(ssp)) {
2774 bscv_exit(ssp);
2777 BSCV_TRACE(ssp, 'M', "bscv_ioc_mprog2",
2779 bscv_exit(ssp);
2783 bscv_put8(ssp, chan_general, EBUS_IDX_CMD_RES, EBUS_CMD_UNLOCK1);
2784 if (bscv_faulty(ssp)) {
2785 BSCV_TRACE(ssp, 'M', "bscv_ioc_mprog2", "ML1 Write failed");
2786 bscv_exit(ssp);
2790 bscv_put8(ssp, chan_general, EBUS_IDX_CMD_RES, EBUS_CMD_UNLOCK2);
2791 if (bscv_faulty(ssp)) {
2792 BSCV_TRACE(ssp, 'M', "bscv_ioc_mprog2", "ML2 Write failed");
2793 bscv_exit(ssp);
2797 if (bscv_eerw(ssp, base_addr, &mprog2.data[0],
2803 (void) bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA);
2805 if (bscv_faulty(ssp)) {
2808 bscv_exit(ssp);
2817 bscv_ioc_mread2(bscv_soft_state_t *ssp, intptr_t arg, int mode)
2840 bscv_enter(ssp);
2845 eeprom_size = bscv_get8(ssp, chan_general, EBUS_IDX_EEPROM_SIZE_KB) *
2848 if (bscv_faulty(ssp)) {
2849 bscv_exit(ssp);
2852 BSCV_TRACE(ssp, 'M', "bscv_ioc_mread2",
2854 bscv_exit(ssp);
2858 if (bscv_eerw(ssp, base_addr, &mprog2.data[0],
2863 if (bscv_faulty(ssp)) {
2866 bscv_exit(ssp);
2877 bscv_get_state_changes(bscv_soft_state_t *ssp)
2883 ASSERT(bscv_held(ssp));
2885 while (i-- && !ssp->cssp_prog) {
2887 change = bscv_get8(ssp, chan_general, EBUS_IDX_STATE_CHNG);
2893 detail = bscv_get8(ssp, chan_general, EBUS_IDX_EVENT_DETAIL);
2895 bscv_status(ssp, change, detail);
2898 BSCV_TRACE(ssp, 'D', "bscv_get_state_changes",
2899 "loop index %d ssp->cssp_prog 0x%x", i, ssp->cssp_prog);
2917 bscv_soft_state_t *ssp = (void *)arg;
2927 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
2931 mutex_enter(&ssp->task_mu);
2933 ssp->task_flags |= TASK_ALIVE_FLG;
2936 if ((ssp->task_flags & TASK_STOP_FLG) != 0) {
2940 if ((ssp->task_flags & TASK_PAUSE_FLG) == 0) {
2942 mutex_exit(&ssp->task_mu);
2944 bscv_enter(ssp);
2945 async_reg = bscv_probe(ssp, chan_general, &fault);
2946 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
2953 if (ssp->cssp_prog || ssp->prog_mode_only) {
2958 ssp->cssp_prog = B_FALSE;
2959 ssp->prog_mode_only = B_FALSE;
2960 (void) bscv_attach_common(ssp);
2963 bscv_clear_fault(ssp);
2968 } else if (bscv_faulty(ssp)) {
2970 bscv_clear_fault(ssp);
2972 ssp->event_sleep = B_TRUE;
2977 ssp->status_change = B_TRUE;
2978 ssp->event_waiting = B_TRUE;
2980 } else if (ssp->cssp_prog) {
2990 bscv_set_fault(ssp);
3001 ssp->event_sleep = B_TRUE;
3003 if (bscv_faulty(ssp)) {
3018 ssp->event_sleep = B_TRUE;
3020 bscv_exit(ssp);
3021 mutex_enter(&ssp->task_mu);
3031 if (strcmp(ssp->last_nodename, utsname.nodename) != 0) {
3033 BSCV_TRACE(ssp, 'X', "bscv_event_daemon",
3036 ssp->nodename_change = B_TRUE;
3037 (void) strncpy(ssp->last_nodename, utsname.nodename,
3038 sizeof (ssp->last_nodename));
3040 ssp->last_nodename[sizeof (ssp->last_nodename) - 1] =
3045 if (((ssp->task_flags & TASK_PAUSE_FLG) == 0) &&
3046 fault_cnt == 0 && ssp->cssp_prog == B_FALSE &&
3047 (ssp->event_waiting || ssp->status_change ||
3048 ssp->nodename_change || ssp->watchdog_change)) {
3050 do_events = ssp->event_waiting;
3051 ssp->event_waiting = B_FALSE;
3052 ssp->task_flags |= do_events ?
3054 do_status = ssp->status_change;
3055 ssp->status_change = B_FALSE;
3056 do_nodename = ssp->nodename_change;
3057 ssp->nodename_change = B_FALSE;
3058 do_watchdog = ssp->watchdog_change;
3059 if (ssp->watchdog_change) {
3060 ssp->watchdog_change = B_FALSE;
3063 mutex_exit(&ssp->task_mu);
3070 bscv_enter(ssp);
3072 bscv_event_process(ssp, do_events);
3075 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3077 bscv_setup_hostname(ssp);
3080 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3082 bscv_setup_watchdog(ssp);
3092 bscv_get_state_changes(ssp);
3094 if (bscv_session_error(ssp)) {
3102 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3104 ssp->event_sleep = B_TRUE;
3106 bscv_exit(ssp);
3108 mutex_enter(&ssp->task_mu);
3110 if (ssp->task_flags & TASK_EVENT_PENDING_FLG) {
3118 ssp->event_active_count++;
3119 ssp->task_flags &= ~(TASK_EVENT_PENDING_FLG |
3121 cv_broadcast(&ssp->task_evnt_cv);
3125 ssp->event_sleep = B_TRUE;
3128 if (ssp->event_sleep) {
3129 ssp->task_flags |= TASK_SLEEPING_FLG;
3131 (void) cv_reltimedwait(&ssp->task_cv,
3132 &ssp->task_mu, poll_period, TR_CLOCK_TICK);
3133 ssp->task_flags &= ~TASK_SLEEPING_FLG;
3134 ssp->event_sleep = B_FALSE;
3138 if (ssp->task_flags & TASK_EVENT_CONSUMER_FLG) {
3143 ssp->event_active_count += 2;
3144 cv_broadcast(&ssp->task_evnt_cv);
3147 ASSERT(!(ssp->task_flags & TASK_EVENT_PENDING_FLG));
3148 ssp->task_flags &=
3150 mutex_exit(&ssp->task_mu);
3152 BSCV_TRACE(ssp, 'D', "bscv_event_daemon",
3163 bscv_start_event_daemon(bscv_soft_state_t *ssp)
3165 if (ssp->progress & BSCV_THREAD)
3169 (void) thread_create(NULL, 0, (void (*)())bscv_event_daemon, ssp,
3172 ssp->progress |= BSCV_THREAD;
3182 bscv_stop_event_daemon(bscv_soft_state_t *ssp)
3187 mutex_enter(&ssp->task_mu);
3191 ((ssp->task_flags & TASK_ALIVE_FLG) && try < 10);
3194 ssp->task_flags |= TASK_STOP_FLG;
3195 cv_signal(&ssp->task_cv);
3197 mutex_exit(&ssp->task_mu);
3205 mutex_enter(&ssp->task_mu);
3208 if (ssp->task_flags & TASK_ALIVE_FLG) {
3211 mutex_exit(&ssp->task_mu);
3223 bscv_pause_event_daemon(bscv_soft_state_t *ssp)
3227 if (!(ssp->progress & BSCV_THREAD)) {
3232 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3235 mutex_enter(&ssp->task_mu);
3237 ssp->task_flags |= TASK_PAUSE_FLG;
3241 (!(ssp->task_flags & TASK_SLEEPING_FLG) &&
3242 (ssp->task_flags & TASK_ALIVE_FLG) &&
3246 ssp->task_flags |= TASK_PAUSE_FLG;
3247 cv_signal(&ssp->task_cv);
3249 mutex_exit(&ssp->task_mu);
3251 mutex_enter(&ssp->task_mu);
3253 if ((ssp->task_flags & TASK_SLEEPING_FLG) ||
3254 !(ssp->task_flags & TASK_ALIVE_FLG)) {
3255 mutex_exit(&ssp->task_mu);
3256 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3260 mutex_exit(&ssp->task_mu);
3261 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3273 bscv_resume_event_daemon(bscv_soft_state_t *ssp)
3275 if (!(ssp->progress & BSCV_THREAD)) {
3280 mutex_enter(&ssp->task_mu);
3282 ssp->task_flags &= ~TASK_PAUSE_FLG;
3283 cv_signal(&ssp->task_cv);
3284 mutex_exit(&ssp->task_mu);
3286 BSCV_TRACE(ssp, 'D', "bscv_pause_event_daemon",
3297 bscv_event_process(bscv_soft_state_t *ssp, boolean_t do_events)
3313 evcount = bscv_get8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS);
3314 logptr = bscv_get16(ssp, chan_general, EBUS_IDX_LOG_PTR_HI);
3317 count = bscv_event_validate(ssp, logptr, evcount);
3330 ssp->event_sleep = B_TRUE;
3334 if (ssp->event_fault_reported) {
3337 ssp->event_fault_reported = B_FALSE;
3341 currptr = logptr - ssp->eventlog_start;
3342 currptr += ssp->eventlog_size;
3344 currptr %= ssp->eventlog_size;
3345 currptr += ssp->eventlog_start;
3347 BSCV_TRACE(ssp, 'E', "bscv_event_process",
3350 ssp->eventlog_start,
3351 ssp->eventlog_start + ssp->eventlog_size);
3355 if (bscv_eerw(ssp, currptr, (uint8_t *)&event,
3361 bscv_event_process_one(ssp, &event);
3362 bscv_sysevent(ssp, &event);
3365 if (currptr >= ssp->eventlog_start +
3366 ssp->eventlog_size) {
3367 currptr = ssp->eventlog_start;
3384 bscv_put8(ssp, chan_general, EBUS_IDX_UNREAD_EVENTS, evcount);
3386 ssp->oldeeptr = currptr;
3387 ssp->oldeeptr_valid = B_TRUE;
3407 bscv_event_validate(bscv_soft_state_t *ssp, uint32_t newptr, uint8_t unread)
3412 if (!bscv_window_setup(ssp)) {
3418 if ((newptr < ssp->eventlog_start) ||
3419 (newptr >= (ssp->eventlog_start + ssp->eventlog_size))) {
3420 if (!ssp->event_fault_reported) {
3423 ssp->event_fault_reported = B_TRUE;
3427 oldptr = ssp->oldeeptr;
3435 newptr += ssp->eventlog_size;
3437 if (!ssp->oldeeptr_valid) {
3458 BSCV_TRACE(ssp, 'E', "bscv_event_process",
3466 BSCV_TRACE(ssp, 'E', "bscv_event_process",
3491 bscv_event_process_one(bscv_soft_state_t *ssp, lom_event_t *event)
3497 if (bscv_is_null_event(ssp, event)) {
3515 bscv_build_eventstring(ssp, event, eventstr, eventstr +
3518 if (level <= ssp->reporting_level) {
3575 bscv_build_eventstring(bscv_soft_state_t *ssp, lom_event_t *event,
3582 BSCV_TRACE(ssp, 'S', "bscv_build_eventstring", "event %2x%2x%2x%2x",
3585 BSCV_TRACE(ssp, 'S', "bscv_build_eventstring", "time %2x%2x%2x%2x",
3639 ssp->led_names, MAX_LED_ID, event->ev_resource - 1));
3941 bscv_status(bscv_soft_state_t *ssp, uint8_t state_chng, uint8_t dev_no)
3946 ASSERT(bscv_held(ssp));
3948 BSCV_TRACE(ssp, 'D', "bscv_status", "state_chng 0x%x dev_no 0x%x",
3962 ssp->cssp_prog = B_TRUE;
3963 BSCV_TRACE(ssp, 'D', "bscv_status",
3964 "ssp->cssp_prog changed to 0x%x",
3965 ssp->cssp_prog);
3973 BSCV_TRACE(ssp, 'D', "bscv_status",
3979 BSCV_TRACE(ssp, 'D', "bscv_status",
3981 (void) bscv_attach_common(ssp);
3982 BSCV_TRACE(ssp, 'D', "bscv_status",
3989 fanspeed = bscv_get8(ssp, chan_general,
3997 ssp->fanspeed[dev_no - 1] = fanspeed;
4002 (void) bscv_get8(ssp, chan_general,
4007 (void) bscv_get8(ssp, chan_general, EBUS_IDX_GPIP);
4011 (void) bscv_get8(ssp, chan_general, EBUS_IDX_CBREAK_STATUS);
4016 temp = bscv_get8(ssp, chan_general,
4024 ssp->temps.temp[dev_no - 1] = temp;
4029 (void) bscv_get8(ssp, chan_general, EBUS_IDX_SUPPLY_LO);
4030 (void) bscv_get8(ssp, chan_general, EBUS_IDX_SUPPLY_HI);
4048 bscv_generic_sysevent(bscv_soft_state_t *ssp, char *class, char *subclass,
4054 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent", "%s/%s:(%s,%s,%d) %s",
4059 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4064 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4070 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4076 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4082 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4088 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4094 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent",
4100 rv = ddi_log_sysevent(ssp->dip, DDI_VENDOR_SUNW, class,
4104 BSCV_TRACE(ssp, 'E', "bscv_generic_sysevent", "sent sysevent");
4120 bscv_sysevent(bscv_soft_state_t *ssp, lom_event_t *event)
4128 BSCV_TRACE(ssp, 'E', "bscv_sysevent", "processing event");
4141 res_id = bscv_get_label(ssp->temps.name, ssp->temps.num,
4161 res_id = bscv_get_label(ssp->fan_names, ssp->num_fans,
4176 res_id = bscv_get_label(ssp->sflags.name, ssp->sflags.num,
4220 res_id = bscv_get_label(ssp->led_names, MAX_LED_ID,
4253 BSCV_TRACE(ssp, 'E', "bscv_sysevent", "class/subclass NULL");
4257 bscv_generic_sysevent(ssp, class, subclass, fru_id, res_id, fru_state,
4284 bscv_prog(bscv_soft_state_t *ssp, intptr_t arg, int mode)
4301 BSCV_TRACE(ssp, 'U', "bscv_prog",
4304 mutex_enter(&ssp->prog_mu);
4313 prog->data[0] = bscv_get8_cached(ssp,
4321 res = bscv_prog_stop_lom(ssp);
4323 res = bscv_prog_start_lom(ssp);
4328 if (ssp->image == NULL) {
4329 ssp->image = (uint8_t *)kmem_zalloc(
4332 res = bscv_prog_receive_image(ssp, prog,
4333 ssp->image, BSC_IMAGE_MAX_SIZE);
4335 mutex_exit(&ssp->prog_mu);
4342 bscv_check_loader_config(bscv_soft_state_t *ssp, boolean_t is_image2)
4344 BSCV_TRACE(ssp, 'U', "bscv_check_loader_config",
4346 ssp->loader_running, is_image2);
4358 if (ssp->loader_running && !is_image2) {
4364 } else if (!ssp->loader_running && is_image2) {
4375 bscv_get_pagesize(bscv_soft_state_t *ssp)
4379 ASSERT(bscv_held(ssp));
4381 pagesize = bscv_get32(ssp, chan_prog,
4384 BSCV_TRACE(ssp, 'U', "bscv_get_pagesize", "pagesize 0x%x", pagesize);
4393 bscv_set_pagesize(bscv_soft_state_t *ssp, uint32_t pagesize)
4397 ASSERT(bscv_held(ssp));
4399 old_pagesize = bscv_get_pagesize(ssp);
4405 bscv_put32(ssp, chan_prog,
4412 bscv_enter_programming_mode(bscv_soft_state_t *ssp)
4416 ASSERT(bscv_held(ssp));
4418 bscv_put8(ssp, chan_prog,
4422 retval = bscv_get8(ssp, chan_prog, BSCVA(EBUS_CMD_SPACE_PROGRAM,
4429 bscv_leave_programming_mode(bscv_soft_state_t *ssp, boolean_t with_jmp)
4432 ASSERT(bscv_held(ssp));
4436 BSCV_TRACE(ssp, 'U', "bscv_leave_programming_mode",
4440 BSCV_TRACE(ssp, 'U', "bscv_leave_programming_mode",
4444 bscv_put8(ssp, chan_prog,
4450 bscv_set_jump_to_addr(bscv_soft_state_t *ssp, uint32_t loadaddr)
4452 ASSERT(bscv_held(ssp));
4454 bscv_put32(ssp, chan_prog,
4457 BSCV_TRACE(ssp, 'U', "bscv_set_jump_to_addr",
4462 bscv_erase_once(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size)
4466 ASSERT(bscv_held(ssp));
4477 BSCV_TRACE(ssp, 'U', "bscv_erase_once", "sending erase command");
4479 bscv_put32(ssp, chan_prog,
4484 bscv_put32(ssp, chan_prog,
4489 bscv_put8(ssp, chan_prog,
4494 retval = bscv_get8(ssp, chan_prog,
4500 bscv_do_erase(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size,
4507 retval = bscv_erase_once(ssp, loadaddr, image_size);
4522 bscv_set_page(bscv_soft_state_t *ssp, uint32_t addr)
4527 ASSERT(bscv_held(ssp));
4534 bscv_put32(ssp, chan_prog,
4537 retval = bscv_get32(ssp, chan_prog,
4554 bscv_do_page_data_once(bscv_soft_state_t *ssp, uint32_t index,
4563 ASSERT(bscv_held(ssp));
4565 BSCV_TRACE(ssp, 'P', "bscv_do_page_data_once", "index 0x%x", index);
4569 bscv_rep_rw8(ssp, chan_prog, imagep + index,
4574 BSCV_TRACE(ssp, 'P', "bscv_do_page_once",
4578 bscv_rep_rw8(ssp, chan_prog, imagep + index,
4583 bscv_put8(ssp, chan_prog,
4600 bscv_put16(ssp, chan_prog,
4603 bscv_put8(ssp, chan_prog,
4607 retval = bscv_get8(ssp, chan_prog,
4614 static uint8_t bscv_do_page(bscv_soft_state_t *ssp, uint32_t loadaddr,
4622 BSCV_TRACE(ssp, 'P', "bscv_do_page", "index 0x%x", index);
4631 retval = bscv_set_page(ssp, loadaddr + index);
4644 BSCV_TRACE(ssp, 'P', "bscv_do_page", "sending data for page");
4646 retval = bscv_do_page_data_once(ssp, index, image_size,
4657 BSCV_TRACE(ssp, 'U', "bscv_do_page", "Returning 0x%x for index 0x%x,"
4665 bscv_do_pages(bscv_soft_state_t *ssp, uint32_t loadaddr, uint32_t image_size,
4671 BSCV_TRACE(ssp, 'P', "bscv_do_pages", "entered");
4674 retval = bscv_do_page(ssp, loadaddr, index, image_size,
4676 if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) {
4677 BSCV_TRACE(ssp, 'U', "bscv_do_pages",
4687 bscv_prog_image(bscv_soft_state_t *ssp, boolean_t is_image2,
4694 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4698 if (!bscv_check_loader_config(ssp, is_image2))
4705 bscv_enter(ssp);
4707 pagesize = bscv_get_pagesize(ssp);
4709 retval = bscv_enter_programming_mode(ssp);
4710 if (bscv_faulty(ssp) || !PSR_PROG(retval)) {
4716 BSCV_TRACE(ssp, 'U', "bscv_prog_image", "entered programming mode");
4723 retval = bscv_do_erase(ssp, loadaddr, image_size, is_image2);
4724 if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) {
4731 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4737 (void) bscv_set_pagesize(ssp, pagesize);
4739 retval = bscv_do_pages(ssp, loadaddr, image_size, pagesize, imagep,
4741 if (bscv_faulty(ssp) || !PSR_SUCCESS(retval)) {
4742 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4754 bscv_set_jump_to_addr(ssp, loadaddr);
4755 ssp->loader_running = B_TRUE;
4756 bscv_leave_programming_mode(ssp, B_TRUE);
4762 bscv_set_jump_to_addr(ssp, 0);
4765 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4771 BSCV_TRACE(ssp, 'U', "bscv_prog_image",
4775 bscv_leave_programming_mode(ssp, B_FALSE);
4776 ssp->loader_running = B_FALSE;
4779 bscv_exit(ssp);
4786 bscv_prog_receive_image(bscv_soft_state_t *ssp, lom_prog_t *prog,
4794 if ((prog->index & 0x7FFF) != ssp->prog_index) {
4795 BSCV_TRACE(ssp, 'U', "bscv_prog_receive_image",
4797 prog->index & 0x7fff, ssp->prog_index);
4808 ssp->image_ptr = 0;
4811 if ((ssp->image_ptr + prog->size) > max_size) {
4814 (ssp->image_ptr + prog->size), max_size);
4817 bcopy(prog->data, &imagep[ssp->image_ptr], prog->size);
4818 ssp->image_ptr += prog->size;
4820 ssp->prog_index++;
4836 if (size != (ssp->image_ptr - 4)) {
4839 size, (ssp->image_ptr - 1));
4842 res = bscv_prog_image(ssp,
4843 ssp->image2_processing,
4844 imagep + 4, ssp->image_ptr - 4, loadaddr);
4850 ssp->image2_processing = !ssp->image2_processing;
4851 } else if ((ssp->image_ptr < sizeof (*prog_data)) ||
4853 (ssp->image_ptr - sizeof (*prog_data)))) {
4861 res = bscv_prog_image(ssp, B_TRUE,
4865 ssp->image2_processing = B_FALSE;
4868 res = bscv_prog_image(ssp, B_FALSE,
4872 ssp->image2_processing = B_TRUE;
4881 ssp->prog_index = 0;
4882 ssp->image_ptr = 0;
4888 bscv_prog_stop_lom(bscv_soft_state_t *ssp)
4890 if (ssp->programming) {
4898 if (bscv_pause_event_daemon(ssp) == BSCV_FAILURE) {
4899 BSCV_TRACE(ssp, 'Q', "bscv_prog_stop_lom",
4904 bscv_enter(ssp);
4906 ssp->programming = B_TRUE;
4908 bscv_exit(ssp);
4912 ssp->prog_index = 0;
4913 ssp->image2_processing = B_FALSE;
4919 bscv_prog_start_lom(bscv_soft_state_t *ssp)
4923 if (!ssp->programming) {
4928 if (ssp->image != NULL) {
4929 kmem_free((void *)ssp->image, BSC_IMAGE_MAX_SIZE);
4930 ssp->image = NULL;
4938 bscv_enter(ssp);
4941 bscv_clear_fault(ssp);
4943 if (ssp->loader_running) {
4948 bscv_put8(ssp, chan_prog,
4951 bscv_put8(ssp, chan_prog,
4954 ssp->loader_running = B_FALSE;
4959 ssp->prog_mode_only = B_FALSE;
4960 ssp->programming = B_FALSE;
4962 if (bscv_attach_common(ssp) == DDI_FAILURE) {
4963 ssp->prog_mode_only = B_TRUE;
4967 bscv_exit(ssp);
4969 if (!ssp->prog_mode_only) {
4977 bscv_start_event_daemon(ssp);
4978 bscv_resume_event_daemon(ssp);
5006 bscv_attach_common(bscv_soft_state_t *ssp)
5008 ASSERT(bscv_held(ssp));
5010 BSCV_TRACE(ssp, 'A', "bscv_attach_common:", "");
5016 ssp->reporting_level = 2;
5023 ssp->serial_reporting = LOM_SER_EVENTS_DEF;
5026 bscv_setup_capability(ssp);
5028 if (bscv_probe_check(ssp) == DDI_FAILURE) {
5037 bscv_setup_hostname(ssp);
5038 bscv_setup_static_info(ssp);
5039 bscv_setup_events(ssp);
5042 bscv_inform_bsc(ssp, BSC_INFORM_ONLINE);
5050 if (ssp->progress & BSCV_WDOG_CFG)
5051 bscv_setup_watchdog(ssp);
5054 if (ssp->progress & BSCV_SIG_SENT)
5055 bscv_write_sig(ssp, ssp->last_sig);
5074 bscv_cleanup(bscv_soft_state_t *ssp)
5080 instance = ssp->instance;
5082 if (ssp->progress & BSCV_LOCKS) {
5083 bscv_enter(ssp);
5086 if (ssp->progress & BSCV_THREAD) {
5087 if (bscv_stop_event_daemon(ssp) == DDI_FAILURE) {
5089 if (ssp->progress & BSCV_LOCKS) {
5090 bscv_exit(ssp);
5096 if (ssp->progress & BSCV_NODES) {
5097 ddi_remove_minor_node(ssp->dip, NULL);
5100 if (ssp->progress & BSCV_MAPPED_REGS) {
5106 if (ssp->serial_reporting == LOM_SER_EVENTS_ON) {
5108 } else if (ssp->serial_reporting == LOM_SER_EVENTS_OFF) {
5110 } else if (ssp->serial_reporting == LOM_SER_EVENTS_DEF) {
5113 bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM,
5123 BSCV_TRACE(ssp, 'W', "bscv_cleanup",
5125 if (bscv_get8_cached(ssp, EBUS_IDX_WDOG_CTRL) &
5127 bscv_setclear8(ssp, chan_general, EBUS_IDX_WDOG_CTRL,
5136 if (ssp->progress & BSCV_MAPPED_REGS) {
5137 bscv_unmap_regs(ssp);
5145 if (ssp->progress & BSCV_LOCKS) {
5146 bscv_exit(ssp);
5147 cv_destroy(&ssp->task_cv);
5148 cv_destroy(&ssp->task_evnt_cv);
5149 mutex_destroy(&ssp->task_mu);
5150 mutex_destroy(&ssp->prog_mu);
5151 mutex_destroy(&ssp->cmd_mutex);
5154 if (ssp->image != NULL) {
5155 kmem_free((void *)ssp->image, BSC_IMAGE_MAX_SIZE);
5159 bscv_watchdog_cyclic_remove(ssp);
5173 static void bscv_setup_capability(bscv_soft_state_t *ssp)
5175 ASSERT(bscv_held(ssp));
5177 if (ssp->prog_mode_only) {
5179 ssp->cap0 = 0;
5180 ssp->cap1 = 0;
5181 ssp->cap2 = 0;
5185 ssp->cap0 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP0);
5186 ssp->cap1 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP1);
5187 ssp->cap2 = bscv_get8(ssp, chan_general, EBUS_IDX_CAP2);
5188 if (!bscv_faulty(ssp)) {
5189 BSCV_TRACE(ssp, 'A', "bscv_setup_capability",
5191 ssp->cap0, ssp->cap1, ssp->cap2);
5194 ssp->cap0 = 0; ssp->cap1 = 0; ssp->cap2 = 0;
5202 * updates ssp->prog_mode_only.
5207 static int bscv_probe_check(bscv_soft_state_t *ssp)
5212 ASSERT(bscv_held(ssp));
5214 BSCV_TRACE(ssp, 'A', "bscv_probe_check", "");
5216 if (!ssp->prog_mode_only) {
5224 bscv_clear_fault(ssp);
5225 probeval = bscv_get8(ssp, chan_general, EBUS_IDX_PROBEAA);
5226 if (bscv_faulty(ssp)) {
5227 ssp->prog_mode_only = B_TRUE;
5229 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5236 probeval = bscv_get8(ssp, chan_general,
5238 if (bscv_faulty(ssp)) {
5239 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5241 ssp->prog_mode_only = B_TRUE;
5247 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5250 ssp->prog_mode_only = B_TRUE;
5262 if (!ssp->prog_mode_only) {
5263 (void) bscv_get8(ssp, chan_general, EBUS_IDX_STATE_CHNG);
5264 if (bscv_faulty(ssp)) {
5265 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5267 ssp->prog_mode_only = B_TRUE;
5271 if (!ssp->prog_mode_only) {
5283 (void) bscv_get8(ssp, chan_general, i);
5286 if (bscv_faulty(ssp)) {
5287 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5289 ssp->prog_mode_only = B_TRUE;
5300 if (!ssp->prog_mode_only) {
5301 if ((bscv_get8_cached(ssp, EBUS_IDX_PROBE55) != 0x55) ||
5302 (bscv_get8_cached(ssp, EBUS_IDX_PROBEAA) != 0xAA)) {
5304 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5307 BSCV_TRACE(ssp, 'A', "bscv_probe_check",
5310 bscv_get8_cached(ssp, i),
5311 bscv_get8_cached(ssp, i + 1),
5312 bscv_get8_cached(ssp, i + 2),
5313 bscv_get8_cached(ssp, i + 3),
5314 bscv_get8_cached(ssp, i + 4),
5315 bscv_get8_cached(ssp, i + 5),
5316 bscv_get8_cached(ssp, i + 6),
5317 bscv_get8_cached(ssp, i + 7),
5318 bscv_get8_cached(ssp, i + 8),
5319 bscv_get8_cached(ssp, i + 9),
5320 bscv_get8_cached(ssp, i + 10),
5321 bscv_get8_cached(ssp, i + 11),
5322 bscv_get8_cached(ssp, i + 12),
5323 bscv_get8_cached(ssp, i + 13),
5324 bscv_get8_cached(ssp, i + 14),
5325 bscv_get8_cached(ssp, i + 15));
5327 ssp->prog_mode_only = B_TRUE;
5331 return ((ssp->prog_mode_only == B_FALSE) ? DDI_SUCCESS : DDI_FAILURE);
5410 bscv_soft_state_t *ssp;
5412 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5414 if (ssp == NULL) {
5416 cmn_err(CE_WARN, "!blade_nodename_set: cannot get ssp");
5421 mutex_enter(&ssp->task_mu);
5422 ssp->nodename_change = B_TRUE;
5423 cv_signal(&ssp->task_cv);
5424 mutex_exit(&ssp->task_mu);
5438 bscv_soft_state_t *ssp;
5441 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5443 if (ssp == NULL) {
5445 cmn_err(CE_WARN, "!blade_nodename_set: cannot get ssp");
5451 bscv_enter(ssp);
5452 bscv_write_sig(ssp, sig);
5453 bscv_exit(ssp);
5460 bscv_wdog_do_pat(bscv_soft_state_t *ssp)
5468 pat = ssp->pat_seq++;
5483 ddi_put8(ssp->channel[chan_wdogpat].handle,
5484 ssp->channel[chan_wdogpat].regs, pat);
5486 BSCV_TRACE(ssp, 'W', "bscv_wdog_pat", "patted the dog with seq %d",
5505 bscv_soft_state_t *ssp;
5507 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5509 if (ssp == NULL) {
5511 cmn_err(CE_WARN, "!bscv_wdog_pat: cannot get ssp");
5513 } else if (ssp->nchannels == 0) {
5520 bscv_wdog_do_pat(ssp);
5533 bscv_soft_state_t *ssp;
5535 ssp = ddi_get_soft_state(bscv_statep, bscv_idi_mgr.valid_inst);
5537 if (ssp == NULL) {
5539 cmn_err(CE_WARN, "!bscv_wdog_cfg: cannot get ssp");
5541 } else if (ssp->nchannels == 0) {
5549 BSCV_TRACE(ssp, 'W', "bscv_wdog_set", "data passed in is size"
5555 BSCV_TRACE(ssp, 'W', "bscv_wdog_cfg", "enable_wdog %s, "
5560 bscv_write_wdog_cfg(ssp,
5569 bscv_write_wdog_cfg(bscv_soft_state_t *ssp,
5578 * Note that a policy is implemented at the bsc/ssp which bounds
5583 ssp->watchdog_timeout = 1;
5585 ssp->watchdog_timeout = 127;
5587 ssp->watchdog_timeout = wdog_timeout_s;
5601 ssp->watchdog_reset_on_timeout = reset_system_on_timeout;
5603 ddi_put8(ssp->channel[chan_wdogpat].handle,
5604 ssp->channel[chan_wdogpat].regs, cfg);
5607 ssp->watchdog_change = B_TRUE;
5609 BSCV_TRACE(ssp, 'W', "bscv_wdog_cfg",
5619 static void bscv_setup_watchdog(bscv_soft_state_t *ssp)
5627 ASSERT(bscv_held(ssp));
5630 bscv_put8(ssp, chan_general,
5631 EBUS_IDX_WDOG_TIME, ssp->watchdog_timeout);
5634 if (ssp->watchdog_reset_on_timeout) {
5650 bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_WDOG_CTRL,
5655 bscv_watchdog_cyclic_add(ssp);
5657 ssp->progress |= BSCV_WDOG_CFG;
5668 static void bscv_setup_hostname(bscv_soft_state_t *ssp)
5675 ASSERT(bscv_held(ssp));
5685 bscv_read_hostname(ssp, lom_nodename);
5691 hostlen = (size_t)bscv_get8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH);
5697 BSCV_TRACE(ssp, 'A', "bscv_setup_hostname",
5702 bscv_write_hostname(ssp,
5707 ssp->progress |= BSCV_HOSTNAME_DONE;
5718 bscv_read_hostname(bscv_soft_state_t *ssp, char *lom_nodename)
5725 ASSERT(bscv_held(ssp));
5735 bscv_clear_fault(ssp);
5736 length = bscv_get8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH);
5737 if (bscv_faulty(ssp)) {
5742 lom_nodename[i] = bscv_get8_once(ssp,
5745 if (bscv_retcode(ssp) != 0) {
5765 ssp->had_fault = B_TRUE;
5767 BSCV_TRACE(ssp, 'R', "bscv_read_hostname",
5779 bscv_write_hostname(bscv_soft_state_t *ssp,
5786 ASSERT(bscv_held(ssp));
5796 bscv_clear_fault(ssp);
5797 bscv_put8(ssp, chan_general, EBUS_IDX_HNAME_LENGTH, length);
5798 if (bscv_faulty(ssp)) {
5803 bscv_put8_once(ssp, chan_general,
5806 if (bscv_retcode(ssp) != 0) {
5822 ssp->had_fault = B_TRUE;
5824 BSCV_TRACE(ssp, 'R', "bscv_write_hostname",
5837 bscv_setup_static_info(bscv_soft_state_t *ssp)
5846 ASSERT(bscv_held(ssp));
5856 bzero(&ssp->volts, sizeof (lom_volts_t));
5857 ssp->volts.num = EBUS_CONFIG2_NSUPPLY_DEC(
5858 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG2));
5859 if (ssp->volts.num > MAX_VOLTS) {
5863 ssp->volts.num, MAX_VOLTS);
5864 ssp->volts.num = MAX_VOLTS;
5867 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
5868 "num volts %d", ssp->volts.num);
5869 (void) bscv_read_env_name(ssp,
5873 ssp->volts.name,
5874 ssp->volts.num);
5876 mask = bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE2,
5878 mask |= bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE2,
5881 for (i = 0; i < ssp->volts.num; i++) {
5882 ssp->volts.shutdown_enabled[i] =
5891 bcopy(ssp->temps.temp, oldtemps, sizeof (oldtemps));
5893 bzero(&ssp->temps, sizeof (lom_temp_t));
5894 ssp->temps.num = EBUS_CONFIG2_NTEMP_DEC(
5895 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG2));
5896 if (ssp->temps.num > MAX_TEMPS) {
5901 ssp->temps.num, MAX_TEMPS);
5902 ssp->temps.num = MAX_TEMPS;
5904 ssp->temps.num_ov = EBUS_CONFIG3_NOTEMP_DEC(
5905 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG3));
5906 if (ssp->temps.num_ov > MAX_TEMPS) {
5911 ssp->temps.num_ov, MAX_TEMPS);
5912 ssp->temps.num_ov = MAX_TEMPS;
5914 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
5916 ssp->temps.num, ssp->temps.num_ov);
5918 addr_space_ptr = bscv_read_env_name(ssp,
5922 ssp->temps.name,
5923 ssp->temps.num);
5925 for (i = 0; i < ssp->temps.num; i++) {
5926 ssp->temps.warning[i] = (int8_t)bscv_get8(ssp, chan_general,
5933 if ((bscv_get8(ssp, chan_general, BSCVA(EBUS_CMD_SPACE4,
5935 ssp->temps.shutdown[i] = (int8_t)bscv_get8(ssp,
5939 ssp->temps.shutdown[i] = 0;
5943 for (i = 0; i < ssp->temps.num; i++) {
5944 temp = bscv_get8(ssp, chan_general, EBUS_IDX_TEMP1 + i);
5947 ssp->temps.temp[i] = temp;
5950 ssp->temps.temp[i] = oldtemps[i];
5958 if (bscv_get8(ssp, chan_general,
5963 (void) bscv_read_env_name(ssp,
5967 ssp->temps.name_ov,
5968 ssp->temps.num_ov);
5973 bzero(&ssp->sflags, sizeof (lom_sflags_t));
5974 ssp->sflags.num = EBUS_CONFIG3_NBREAKERS_DEC(bscv_get8(ssp,
5976 if (ssp->sflags.num > MAX_STATS) {
5981 ssp->sflags.num, MAX_STATS);
5982 ssp->sflags.num = MAX_STATS;
5984 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
5985 "num sflags %d", ssp->sflags.num);
5987 (void) bscv_read_env_name(ssp,
5991 ssp->sflags.name,
5992 ssp->sflags.num);
5998 ssp->num_fans = EBUS_CONFIG_NFAN_DEC(
5999 bscv_get8(ssp, chan_general, EBUS_IDX_CONFIG));
6000 if (ssp->num_fans > MAX_FANS) {
6005 ssp->num_fans, MAX_FANS);
6006 ssp->num_fans = MAX_FANS;
6009 for (i = 0; i < ssp->num_fans; i++) {
6010 fanspeed = bscv_get8(ssp, chan_general,
6018 ssp->fanspeed[i] = fanspeed;
6022 BSCV_TRACE(ssp, 'A', "bscv_setup_static_info",
6023 "num fans %d", ssp->num_fans);
6025 (void) bscv_read_env_name(ssp,
6029 ssp->fan_names,
6030 ssp->num_fans);
6034 (void) bscv_read_env_name(ssp,
6038 ssp->led_names,
6054 bscv_read_env_name(bscv_soft_state_t *ssp,
6067 ASSERT(bscv_held(ssp));
6069 BSCV_TRACE(ssp, 'A', "bscv_read_env_name",
6084 this_char = bscv_get8(ssp, chan_general,
6136 bscv_setup_events(bscv_soft_state_t *ssp)
6141 ASSERT(bscv_held(ssp));
6149 if (ssp->serial_reporting == LOM_SER_EVENTS_ON) {
6151 } else if (ssp->serial_reporting == LOM_SER_EVENTS_OFF) {
6153 } else if (ssp->serial_reporting == LOM_SER_EVENTS_DEF) {
6156 bscv_setclear8_volatile(ssp, chan_general, EBUS_IDX_ALARM,
6169 bscv_write_sig(bscv_soft_state_t *ssp, bscv_sig_t s)
6171 ASSERT(bscv_held(ssp));
6174 bscv_put32(ssp, chan_cpusig,
6186 bscv_put8(ssp, chan_cpusig,
6200 bscv_put8(ssp, chan_cpusig,
6205 ssp->last_sig = s;
6206 ssp->progress |= BSCV_SIG_SENT;
6220 bscv_inform_bsc(bscv_soft_state_t *ssp, uint32_t state)
6222 ASSERT(bscv_held(ssp));
6224 BSCV_TRACE(ssp, 'X', "bscv_inform_bsc",
6227 bscv_put32(ssp, chan_general,
6229 bscv_put8(ssp, chan_cpusig,
6242 bscv_soft_state_t *ssp = (bscv_soft_state_t *)arg;
6244 bscv_wdog_do_pat(ssp);
6254 bscv_watchdog_cfg_request(bscv_soft_state_t *ssp, uint8_t new_state)
6259 BSCV_TRACE(ssp, 'X', "bscv_watchdog_cfg_request",
6261 bscv_write_wdog_cfg(ssp,
6275 bscv_set_watchdog_timer(bscv_soft_state_t *ssp, uint_t timeoutval)
6277 BSCV_TRACE(ssp, 'X', "bscv_set_watchdog_timer:",
6288 bscv_watchdog_cfg_request(ssp, WDOG_ON);
6304 bscv_clear_watchdog_timer(bscv_soft_state_t *ssp)
6306 BSCV_TRACE(ssp, 'X', "bscv_clear_watchdog_timer", "");
6310 bscv_watchdog_cfg_request(ssp, WDOG_OFF);
6324 bscv_soft_state_t *ssp = (bscv_soft_state_t *)arg;
6326 BSCV_TRACE(ssp, 'X', "bscv_panic_callback",
6329 bscv_clear_watchdog_timer(ssp);
6334 bscv_full_stop(ssp);
6345 bscv_watchdog_cyclic_add(bscv_soft_state_t *ssp)
6347 if (ssp->periodic_id != NULL) {
6351 ssp->periodic_id = ddi_periodic_add(bscv_watchdog_pat_request, ssp,
6354 BSCV_TRACE(ssp, 'X', "bscv_watchdog_cyclic_add:",
6365 bscv_watchdog_cyclic_remove(bscv_soft_state_t *ssp)
6367 if (ssp->periodic_id == NULL) {
6370 ddi_periodic_delete(ssp->periodic_id);
6371 ssp->periodic_id = NULL;
6372 BSCV_TRACE(ssp, 'X', "bscv_watchdog_cyclic_remove:",
6385 bscv_trace(bscv_soft_state_t *ssp, char code, const char *caller,
6392 if (ssp->debug & (1 << (code-'@'))) {
6403 (void) strlog((short)ssp->majornum, (short)ssp->minornum, code,
6412 bscv_trace(bscv_soft_state_t *ssp, char code, const char *caller,