Lines Matching defs:sbp
93 int sbd_dealloc_instance(sbd_board_t *sbp, int max_boards);
368 static int sbd_check_transition(sbd_board_t *sbp,
372 sbd_board_t *sbp,
379 static int sbd_init_devlists(sbd_board_t *sbp);
383 static void sbd_init_mem_devlists(sbd_board_t *sbp);
384 static void sbd_init_cpu_unit(sbd_board_t *sbp, int unit);
385 static void sbd_board_discovery(sbd_board_t *sbp);
386 static void sbd_board_init(sbd_board_t *sbp,
389 static void sbd_board_destroy(sbd_board_t *sbp);
390 static int sbd_check_unit_attached(sbd_board_t *sbp,
692 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
720 mutex_enter(&sbp->sb_slock);
723 mutex_exit(&sbp->sb_slock);
768 hdp = sbd_get_sbdp_handle(sbp, hp);
796 sbd_board_t *sbp = hp ? SBDH2BD(hp->h_sbd) : NULL;
805 bstate = sbp ? SBD_BOARD_STATE(sbp) : SBD_STATE_EMPTY;
816 devlist = sbp->sb_devlist[NIX(SBD_COMP_MEM)];
821 devlist = sbp->sb_devlist[NIX(SBD_COMP_CPU)];
826 devlist = sbp->sb_devlist[NIX(SBD_COMP_IO)];
857 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
861 hdp = sbd_get_sbdp_handle(sbp, hp);
931 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
939 hdp = sbd_get_sbdp_handle(sbp, hp);
941 sbp->sb_busy = 1;
984 sbp->sb_busy = 0;
1003 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
1010 hdp = sbd_get_sbdp_handle(sbp, hp);
1112 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
1127 hdp = sbd_get_sbdp_handle(sbp, hp);
1141 ASSERT(sbp->sb_cpupath[unit] != NULL);
1142 pathname = sbp->sb_cpupath[unit];
1191 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
1198 hdp = sbd_get_sbdp_handle(sbp, hp);
1209 SBD_SET_ERRSTR(ep, sbp->sb_cpupath[unit]);
1231 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
1235 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit);
1251 mutex_enter(&sbp->sb_slock);
1254 mutex_exit(&sbp->sb_slock);
1343 sbd_dealloc_instance(sbd_board_t *sbp, int max_boards)
1346 sbd_board_t *list = sbp;
1351 if (sbp == NULL) {
1356 sbd_board_destroy(sbp++);
1444 sbd_board_t *sbp = softsp->sbd_boardlist;
1449 sbp += board;
1462 hp->h_sbd = (void *) sbp;
1469 shp->sh_next = sbp->sb_handle;
1470 sbp->sb_handle = shp;
1510 sbd_board_t *sbp;
1516 sbp = SBDH2BD(hp->h_sbd);
1524 for (shpp = &sbp->sb_handle; (*shpp) && ((*shpp) != shp);
1531 f, sbp->sb_num);
1546 sbd_get_sbdp_handle(sbd_board_t *sbp, sbd_handle_t *hp)
1552 if (sbp == NULL) {
1556 hdp->h_board = sbp->sb_num;
1557 hdp->h_wnode = sbp->sb_wnode;
1759 sbd_check_transition(sbd_board_t *sbp, sbd_devset_t *devsetp,
1785 s = (int)SBD_DEVICE_STATE(sbp, SBD_COMP_MEM, ut);
1798 s = (int)SBD_DEVICE_STATE(sbp, SBD_COMP_CPU, ut);
1811 s = (int)SBD_DEVICE_STATE(sbp, SBD_COMP_IO, ut);
1843 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
1920 state_err = sbd_check_transition(sbp, &devset, transp);
1984 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
1993 sbp->sb_time = gethrestime_sec();
2027 sbd_board_t *sbp;
2031 sbp = SBDH2BD(hp->h_sbd);
2033 ASSERT(sbp != NULL);
2034 PR_ALL("%s for board %d", f, sbp->sb_num);
2037 hdp = sbd_get_sbdp_handle(sbp, hp);
2049 mutex_enter(&sbp->sb_flags_mutex);
2050 sbp->sb_flags &= ~SBD_BOARD_STATUS_CACHED;
2051 mutex_exit(&sbp->sb_flags_mutex);
2066 sbd_board_t *sbp;
2071 sbp = SBDH2BD(hp->h_sbd);
2073 hdp = sbd_get_sbdp_handle(sbp, hp);
2081 mutex_enter(&sbp->sb_flags_mutex);
2082 sbp->sb_flags &= ~SBD_BOARD_STATUS_CACHED;
2083 mutex_exit(&sbp->sb_flags_mutex);
2120 get_node_type(sbd_board_t *sbp, dev_info_t *dip, int *unitp)
2128 ASSERT(sbp);
2133 hp = MACHBD2HD(sbp);
2135 hdp = sbd_get_sbdp_handle(sbp, hp);
2136 if (sbdp_get_board_num(hdp, dip) != sbp->sb_num) {
2185 sbd_board_t *sbp;
2198 sbd_board_t *sbp;
2211 sbp = wp->sbp;
2213 nodetype = get_node_type(sbp, dip, &unit);
2218 pathname = sbp->sb_cpupath[unit];
2222 pathname = sbp->sb_mempath[unit];
2226 pathname = sbp->sb_iopath[unit];
2249 devlist = sbp->sb_devlist[NIX(nodetype)];
2262 if (!SBD_DEV_IS_PRESENT(sbp, nodetype, unit)) {
2263 sbp->sb_ndev++;
2264 SBD_DEV_SET_PRESENT(sbp, nodetype, unit);
2268 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit);
2292 sbd_init_mem_devlists(sbd_board_t *sbp)
2300 sbd_handle_t *hp = MACHBD2HD(sbp);
2302 devlist = sbp->sb_devlist[NIX(SBD_COMP_MEM)];
2304 mp = SBD_GET_BOARD_MEMUNIT(sbp, 0);
2310 hdp = sbd_get_sbdp_handle(sbp, hp);
2327 if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, 0)) {
2328 ASSERT(sbp->sb_ndev != 0);
2329 SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_MEM, 0);
2330 sbp->sb_ndev--;
2360 sbp->sb_num, i);
2403 sbd_init_devlists(sbd_board_t *sbp)
2412 PR_ALL("%s (board = %d)...\n", f, sbp->sb_num);
2416 SBD_DEVS_DISCONNECT(sbp, (uint_t)-1);
2423 sbp->sb_devlist[NIX(SBD_COMP_MEM)][i] = NULL;
2424 dp = (sbd_dev_unit_t *)SBD_GET_BOARD_MEMUNIT(sbp, i);
2425 dp->u_common.sbdev_sbp = sbp;
2430 mp = SBD_GET_BOARD_MEMUNIT(sbp, 0);
2437 sbp->sb_devlist[NIX(SBD_COMP_CPU)][i] = NULL;
2438 dp = (sbd_dev_unit_t *)SBD_GET_BOARD_CPUUNIT(sbp, i);
2439 dp->u_common.sbdev_sbp = sbp;
2444 sbp->sb_devlist[NIX(SBD_COMP_IO)][i] = NULL;
2445 dp = (sbd_dev_unit_t *)SBD_GET_BOARD_IOUNIT(sbp, i);
2446 dp->u_common.sbdev_sbp = sbp;
2451 wp->sbp = sbp;
2453 sbp->sb_ndev = 0;
2458 pdip = ddi_get_parent(sbp->sb_topdip);
2463 ddi_walk_devs(sbp->sb_topdip, sbd_setup_devlists, (void *) wp);
2473 if (sbp->sb_ndev == 0) {
2474 sbp->sb_memaccess_ok = 0;
2475 return (sbp->sb_ndev);
2482 sbp->sb_memaccess_ok = 1;
2484 if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, i)) {
2485 sbd_init_cpu_unit(sbp, i);
2486 if (sbd_connect_cpu(sbp, i)) {
2487 SBD_SET_ERR(HD2MACHERR(MACHBD2HD(sbp)),
2494 if (sbp->sb_memaccess_ok) {
2495 sbd_init_mem_devlists(sbp);
2498 sbp->sb_num);
2501 return (sbp->sb_ndev);
2505 sbd_init_cpu_unit(sbd_board_t *sbp, int unit)
2512 sbd_handle_t *hp = MACHBD2HD(sbp);
2515 if (SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_CPU, unit)) {
2517 } else if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, unit)) {
2523 dip = sbp->sb_devlist[NIX(SBD_COMP_CPU)][unit];
2525 cp = SBD_GET_BOARD_CPUUNIT(sbp, unit);
2527 hdp = sbd_get_sbdp_handle(sbp, hp);
2555 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, unit, new_state);
2565 sbd_board_t *sbp;
2569 sbp = SBDH2BD(hp->h_sbd);
2571 PR_ALL("%s board %d\n", f, sbp->sb_num);
2575 if (SBD_DEVS_PRESENT(sbp)) {
2580 f, SBD_DEVS_PRESENT(sbp));
2585 if (sbd_init_devlists(sbp) == 0) {
2587 f, sbp->sb_num);
2597 if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, i))
2598 sbd_init_mem_unit(sbp, i, SBD_HD2ERR(hp));
2604 if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_IO, i))
2605 sbd_init_io_unit(sbp, i);
2607 SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONNECTED);
2608 sbp->sb_rstate = SBD_STAT_CONNECTED;
2609 sbp->sb_ostate = SBD_STAT_UNCONFIGURED;
2610 (void) drv_getparm(TIME, (void *)&sbp->sb_time);
2621 sbd_board_t *sbp;
2626 sbp = SBDH2BD(hp->h_sbd);
2632 devset = HD2MACHHD(hp)->sh_devset & SBD_DEVS_PRESENT(sbp) &
2633 SBD_DEVS_UNATTACHED(sbp);
2635 ASSERT((SBD_DEVS_ATTACHED(sbp) & devset) == 0);
2644 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, i,
2646 SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_MEM, i);
2653 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, i,
2655 SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_CPU, i);
2662 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_IO, i,
2664 SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_IO, i);
2673 if (SBD_DEVS_PRESENT(sbp) == 0) {
2674 SBD_BOARD_TRANSITION(sbp, SBD_STATE_OCCUPIED);
2675 sbp->sb_rstate = SBD_STAT_DISCONNECTED;
2676 sbp->sb_ostate = SBD_STAT_UNCONFIGURED;
2677 (void) drv_getparm(TIME, (void *)&sbp->sb_time);
2683 f, sbp->sb_num);
2691 sbd_board_t *sbp;
2694 sbp = SBDH2BD(hp->h_sbd);
2696 PR_ALL("sbd_test_board: board %d\n", sbp->sb_num);
2699 hdp = sbd_get_sbdp_handle(sbp, hp);
2716 sbd_board_t *sbp;
2719 sbp = SBDH2BD(hp->h_sbd);
2721 PR_ALL("sbd_assign_board: board %d\n", sbp->sb_num);
2723 hdp = sbd_get_sbdp_handle(sbp, hp);
2740 sbd_board_t *sbp;
2743 sbp = SBDH2BD(hp->h_sbd);
2745 PR_ALL("sbd_unassign_board: board %d\n", sbp->sb_num);
2747 hdp = sbd_get_sbdp_handle(sbp, hp);
2764 sbd_board_t *sbp;
2767 sbp = SBDH2BD(hp->h_sbd);
2769 PR_ALL("sbd_poweron_board: %d\n", sbp->sb_num);
2771 hdp = sbd_get_sbdp_handle(sbp, hp);
2788 sbd_board_t *sbp;
2791 sbp = SBDH2BD(hp->h_sbd);
2793 PR_ALL("sbd_poweroff_board: %d\n", sbp->sb_num);
2795 hdp = sbd_get_sbdp_handle(sbp, hp);
2816 sbd_get_devlist(sbd_handle_t *hp, sbd_board_t *sbp, sbd_comp_type_t nodetype,
2826 devlist = sbp->sb_devlist[NIX(nodetype)];
2839 hdp = sbd_get_sbdp_handle(sbp, hp);
2884 is_present = SBD_DEV_IS_PRESENT(sbp, nodetype, ut) ?
2886 is_attached = SBD_DEV_IS_ATTACHED(sbp, nodetype, ut) ?
2909 sbd_board_t *sbp;
2918 sbp = SBDH2BD(hp->h_sbd);
2944 attach_devlist = sbd_get_devlist(hp, sbp, SBD_COMP_CPU,
2965 attach_devlist = sbd_get_devlist(hp, sbp, SBD_COMP_MEM,
2988 attach_devlist = sbd_get_devlist(hp, sbp, SBD_COMP_IO,
3076 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
3080 sbp = SBDH2BD(hp->h_sbd);
3086 hdp = sbd_get_sbdp_handle(sbp, hp);
3134 unit = sbd_check_unit_attached(sbp, dip, unit, nodetype, ep);
3138 f, sbd_ct_str[(int)nodetype], sbp->sb_num, i);
3142 SBD_DEV_SET_ATTACHED(sbp, nodetype, unit);
3143 SBD_DEVICE_TRANSITION(sbp, nodetype, unit,
3154 devs_present = SBD_DEVS_PRESENT(sbp);
3155 devs_unattached = SBD_DEVS_UNATTACHED(sbp);
3157 switch (SBD_BOARD_STATE(sbp)) {
3166 SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONFIGURED);
3167 sbp->sb_rstate = SBD_STAT_CONNECTED;
3168 sbp->sb_ostate = SBD_STAT_CONFIGURED;
3173 SBD_BOARD_TRANSITION(sbp, SBD_STATE_PARTIAL);
3174 sbp->sb_rstate = SBD_STAT_CONNECTED;
3175 sbp->sb_ostate = SBD_STAT_UNCONFIGURED;
3177 (void) drv_getparm(TIME, (void *)&sbp->sb_time);
3186 SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONFIGURED);
3187 sbp->sb_rstate = SBD_STAT_CONNECTED;
3188 sbp->sb_ostate = SBD_STAT_CONFIGURED;
3189 (void) drv_getparm(TIME, (void *)&sbp->sb_time);
3224 sbd_board_t *sbp;
3233 sbp = SBDH2BD(hp->h_sbd);
3259 release_devlist = sbd_get_devlist(hp, sbp,
3282 release_devlist = sbd_get_devlist(hp, sbp,
3306 release_devlist = sbd_get_devlist(hp, sbp,
3342 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
3361 if (SBD_DEV_IS_ATTACHED(sbp, SBD_COMP_MEM, i)) {
3369 SBD_SET_ERRSTR(ep, sbp->sb_mempath[i]);
3424 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
3469 hdp = sbd_get_sbdp_handle(sbp, hp);
3515 sbd_release_dev_done(sbd_board_t *sbp, sbd_comp_type_t nodetype, int unit)
3517 SBD_DEV_SET_UNREFERENCED(sbp, nodetype, unit);
3518 SBD_DEVICE_TRANSITION(sbp, nodetype, unit, SBD_STATE_UNREFERENCED);
3525 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
3532 hdp = sbd_get_sbdp_handle(sbp, hp);
3556 sbd_release_dev_done(sbp, nodetype, unit);
3564 if (SBD_DEVS_RELEASED(sbp) == SBD_DEVS_UNREFERENCED(sbp)) {
3565 SBD_BOARD_TRANSITION(sbp, SBD_STATE_UNREFERENCED);
3566 (void) drv_getparm(TIME, (void *)&sbp->sb_time);
3573 sbd_board_t *sbp;
3582 sbp = SBDH2BD(hp->h_sbd);
3608 detach_devlist = sbd_get_devlist(hp, sbp,
3630 detach_devlist = sbd_get_devlist(hp, sbp,
3653 detach_devlist = sbd_get_devlist(hp, sbp,
3717 sbd_board_t *sbp;
3722 sbp = SBDH2BD(hp->h_sbd);
3725 hdp = sbd_get_sbdp_handle(sbp, hp);
3778 if (sbd_check_unit_attached(sbp, dip, unit, nodetype,
3785 f, sbd_ct_str[(int)nodetype], sbp->sb_num,
3790 SBD_DEV_CLR_ATTACHED(sbp, nodetype, unit);
3791 SBD_DEV_CLR_RELEASED(sbp, nodetype, unit);
3792 SBD_DEV_CLR_UNREFERENCED(sbp, nodetype, unit);
3793 SBD_DEVICE_TRANSITION(sbp, nodetype, unit,
3798 bstate = SBD_BOARD_STATE(sbp);
3800 if (SBD_DEVS_PRESENT(sbp) == SBD_DEVS_UNATTACHED(sbp)) {
3804 SBD_BOARD_TRANSITION(sbp, SBD_STATE_UNCONFIGURED);
3805 } else if ((SBD_BOARD_STATE(sbp) != SBD_STATE_PARTIAL) &&
3806 SBD_DEVS_ATTACHED(sbp)) {
3810 SBD_BOARD_TRANSITION(sbp, SBD_STATE_PARTIAL);
3841 sbd_check_unit_attached(sbd_board_t *sbp, dev_info_t *dip, int unit,
3850 sbd_handle_t *hp = MACHBD2HD(sbp);
3853 hdp = sbd_get_sbdp_handle(sbp, hp);
3903 pdip = ddi_get_parent(sbp->sb_topdip);
3908 ddi_walk_devs(sbp->sb_topdip, sbd_check_io_attached,
3947 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
3955 hdp = sbd_get_sbdp_handle(sbp, hp);
3965 mp = SBD_GET_BOARD_MEMUNIT(sbp, unit);
3972 SBD_SET_ERRSTR(SBD_HD2ERR(hp), sbp->sb_mempath[unit]);
3983 sbd_board_t *sbp;
3985 sbp = SBDH2BD(hp->h_sbd);
3990 devset &= SBD_DEVS_PRESENT(sbp);
4009 if ((sbp->sb_devlist[NIX(SBD_COMP_CMP)][c] == NULL) &&
4010 (sbp->sb_devlist[NIX(SBD_COMP_CMP)][c1] == NULL))
4023 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
4028 devset &= SBD_DEVS_PRESENT(sbp);
4037 dip = sbp->sb_devlist[NIX(SBD_COMP_MEM)][i];
4058 sbd_board_t *sbp;
4065 sbp = SBDH2BD(hp->h_sbd);
4072 mutex_enter(&sbp->sb_slock);
4077 devset &= SBD_DEVS_PRESENT(sbp);
4090 if (SBD_DEVICE_STATE(sbp, SBD_COMP_MEM, m) == SBD_STATE_EMPTY)
4093 dip = sbp->sb_devlist[NIX(SBD_COMP_MEM)][m];
4097 mp = SBD_GET_BOARD_MEMUNIT(sbp, m);
4123 sbp, SBD_COMP_MEM, m));
4191 mutex_exit(&sbp->sb_slock);
4201 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
4211 devset = HD2MACHHD(hp)->sh_devset & SBD_DEVS_UNREFERENCED(sbp);
4221 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, i,
4224 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU, i,
4232 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_IO, i,
4240 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, i,
4243 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM, i,
4250 SBD_DEVS_CANCEL(sbp, devset);
4252 if (SBD_DEVS_UNREFERENCED(sbp) == 0) {
4258 if (SBD_DEVS_ATTACHED(sbp) == SBD_DEVS_PRESENT(sbp))
4262 if (SBD_BOARD_STATE(sbp) != new_state) {
4263 SBD_BOARD_TRANSITION(sbp, new_state);
4265 sbp->sb_ostate = SBD_STAT_CONFIGURED;
4266 (void) drv_getparm(TIME, (void *)&sbp->sb_time);
4297 sbd_board_t *sbp = SBDH2BD(hp->h_sbd);
4313 devset &= SBD_DEVS_PRESENT(sbp);
4399 mutex_enter(&sbp->sb_flags_mutex);
4400 switch (sbp->sb_state) {
4405 if (sbp->sb_flags & SBD_BOARD_STATUS_CACHED) {
4406 bcopy(&sbp->sb_stat, dstatp, sizeof (sbd_stat_t));
4407 dstatp->s_rstate = rstate_cvt(sbp->sb_state);
4408 dstatp->s_ostate = ostate_cvt(sbp->sb_state);
4409 dstatp->s_busy = sbp->sb_busy;
4410 dstatp->s_time = sbp->sb_time;
4411 dstatp->s_cond = sbp->sb_cond;
4417 sbp->sb_flags &= ~SBD_BOARD_STATUS_CACHED;
4418 dstatp->s_board = sbp->sb_num;
4419 dstatp->s_ostate = ostate_cvt(sbp->sb_state);
4420 dstatp->s_time = sbp->sb_time;
4422 hdp = sbd_get_sbdp_handle(sbp, hp);
4432 mutex_exit(&sbp->sb_flags_mutex);
4441 dstatp->s_busy = sbp->sb_busy;
4442 sbp->sb_cond = (sbd_cond_t)dstatp->s_cond;
4443 bcopy(dstatp, &sbp->sb_stat,
4445 sbp->sb_flags |= SBD_BOARD_STATUS_CACHED;
4450 mutex_exit(&sbp->sb_flags_mutex);
4622 "for board %d", f, sbp->sb_num);
4631 f, sbp->sb_num);
4647 sbd_board_discovery(sbd_board_t *sbp)
4656 sbd_handle_t *hp = MACHBD2HD(sbp);
4658 if (SBD_DEVS_PRESENT(sbp) == 0) {
4660 f, sbp->sb_num);
4671 hdp = sbd_get_sbdp_handle(sbp, hp);
4676 if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_CPU, i))
4679 dip = sbp->sb_devlist[NIX(SBD_COMP_CPU)][i];
4692 SBD_DEV_SET_ATTACHED(sbp, SBD_COMP_CPU, i);
4695 f, sbp->sb_num, cpuid);
4698 sbd_init_cpu_unit(sbp, i);
4710 if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, i))
4713 dip = sbp->sb_devlist[NIX(SBD_COMP_MEM)][i];
4719 if (SBD_DEV_IS_PRESENT(sbp, SBD_COMP_MEM, i)) {
4720 ASSERT(sbp->sb_ndev != 0);
4721 SBD_DEV_CLR_PRESENT(sbp, SBD_COMP_MEM, i);
4722 sbp->sb_ndev--;
4724 sbp->sb_devlist[NIX(SBD_COMP_MEM)][i] = NULL;
4752 SBD_DEV_SET_ATTACHED(sbp, SBD_COMP_MEM, i);
4755 f, sbp->sb_num, i);
4757 sbd_init_mem_unit(sbp, i, ep);
4773 if (!SBD_DEV_IS_PRESENT(sbp, SBD_COMP_IO, i))
4776 dip = sbp->sb_devlist[NIX(SBD_COMP_IO)][i];
4791 SBD_DEV_SET_ATTACHED(sbp, SBD_COMP_IO, i);
4794 f, sbp->sb_num, i);
4796 sbd_init_io_unit(sbp, i);
4799 SBD_DEVS_CONFIGURE(sbp, devs_attached);
4800 if (devs_attached && ((devs_lost = SBD_DEVS_UNATTACHED(sbp)) != 0)) {
4814 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_CPU,
4820 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_MEM,
4826 SBD_DEVICE_TRANSITION(sbp, SBD_COMP_IO,
4839 switch (get_node_type(wp->sbp, rdip, NULL)) {
4875 sbd_board_init(sbd_board_t *sbp, sbd_softstate_t *softsp,
4883 mutex_init(&sbp->sb_mutex, NULL, MUTEX_DRIVER, NULL);
4884 mutex_init(&sbp->sb_flags_mutex, NULL, MUTEX_DRIVER, NULL);
4885 mutex_init(&sbp->sb_slock, NULL, MUTEX_DRIVER, NULL);
4887 sbp->sb_ref = 0;
4888 sbp->sb_num = bd;
4889 sbp->sb_time = gethrestime_sec();
4892 * sbp i.e. sbd_board_t will be destroyed in sbd_teardown_instance()
4896 sbp->sb_topdip = top_dip;
4897 sbp->sb_cpuid = -1;
4898 sbp->sb_softsp = (void *) softsp;
4899 sbp->sb_cond = SBD_COND_UNKNOWN;
4900 sbp->sb_wnode = wnode;
4901 sbp->sb_memaccess_ok = 1;
4910 sbp->sb_devlist[NIX(SBD_COMP_CPU)] = GETSTRUCT(dev_info_t *,
4916 sbp->sb_devlist[NIX(SBD_COMP_MEM)] = GETSTRUCT(dev_info_t *,
4922 sbp->sb_devlist[NIX(SBD_COMP_IO)] = GETSTRUCT(dev_info_t *,
4926 sbp->sb_dev[NIX(SBD_COMP_CPU)] = GETSTRUCT(sbd_dev_unit_t,
4929 sbp->sb_dev[NIX(SBD_COMP_MEM)] = GETSTRUCT(sbd_dev_unit_t,
4932 sbp->sb_dev[NIX(SBD_COMP_IO)] = GETSTRUCT(sbd_dev_unit_t,
4936 sbp->sb_cpupath[i] = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
4940 sbp->sb_mempath[i] = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
4944 sbp->sb_iopath[i] = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
4951 ASSERT(sbp->sb_topdip);
4952 pdip = ddi_get_parent(sbp->sb_topdip);
4955 walk.sbp = sbp;
4957 ddi_walk_devs(sbp->sb_topdip, hold_rele_branch, (void *)&walk);
4964 if (sbd_init_devlists(sbp) == 0) {
4965 SBD_BOARD_TRANSITION(sbp, SBD_STATE_EMPTY);
4971 ASSERT(SBD_DEVS_PRESENT(sbp) != 0);
4976 sbd_board_discovery(sbp);
4978 if (SBD_DEVS_UNATTACHED(sbp) == 0) {
4983 SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONFIGURED);
4984 sbp->sb_cond = SBD_COND_OK;
4985 } else if (SBD_DEVS_ATTACHED(sbp)) {
4986 SBD_BOARD_TRANSITION(sbp, SBD_STATE_PARTIAL);
4988 SBD_BOARD_TRANSITION(sbp, SBD_STATE_CONNECTED);
4994 sbd_board_destroy(sbd_board_t *sbp)
5001 SBD_BOARD_TRANSITION(sbp, SBD_STATE_EMPTY);
5007 mp = SBD_GET_BOARD_MEMUNIT(sbp, i);
5015 FREESTRUCT(sbp->sb_dev[NIX(SBD_COMP_MEM)],
5017 sbp->sb_dev[NIX(SBD_COMP_MEM)] = NULL;
5022 FREESTRUCT(sbp->sb_dev[NIX(SBD_COMP_CPU)],
5024 sbp->sb_dev[NIX(SBD_COMP_CPU)] = NULL;
5029 FREESTRUCT(sbp->sb_dev[NIX(SBD_COMP_IO)],
5031 sbp->sb_dev[NIX(SBD_COMP_IO)] = NULL;
5038 kmem_free((caddr_t)sbp->sb_cpupath[i], MAXPATHLEN);
5040 FREESTRUCT(sbp->sb_devlist[NIX(SBD_COMP_CPU)], dev_info_t *,
5042 sbp->sb_devlist[NIX(SBD_COMP_CPU)] = NULL;
5048 kmem_free((caddr_t)sbp->sb_mempath[i], MAXPATHLEN);
5050 FREESTRUCT(sbp->sb_devlist[NIX(SBD_COMP_MEM)], dev_info_t *,
5052 sbp->sb_devlist[NIX(SBD_COMP_MEM)] = NULL;
5058 kmem_free((caddr_t)sbp->sb_iopath[i], MAXPATHLEN);
5060 FREESTRUCT(sbp->sb_devlist[NIX(SBD_COMP_IO)], dev_info_t *,
5062 sbp->sb_devlist[NIX(SBD_COMP_IO)] = NULL;
5067 ASSERT(sbp->sb_topdip);
5068 pdip = ddi_get_parent(sbp->sb_topdip);
5071 walk.sbp = sbp;
5073 ddi_walk_devs(sbp->sb_topdip, hold_rele_branch, (void *)&walk);
5077 mutex_destroy(&sbp->sb_slock);
5078 mutex_destroy(&sbp->sb_flags_mutex);
5079 mutex_destroy(&sbp->sb_mutex);