Lines Matching defs:pptr
628 pmcs_phy_t *pptr;
632 pptr = pwp->root_phys + phynum;
633 if (pptr == NULL) {
640 pmcs_lock_phy(pptr);
643 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
645 pmcs_unlock_phy(pptr);
646 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nowrk, __func__);
655 pmcs_unlock_phy(pptr);
657 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nomsg, __func__);
679 pptr->state.prog_min_rate = (lowbit((ulong_t)speed) - 1);
680 pptr->state.prog_max_rate = (highbit((ulong_t)speed) - 1);
681 pptr->state.hw_min_rate = PMCS_HW_MIN_LINK_RATE;
682 pptr->state.hw_max_rate = PMCS_HW_MAX_LINK_RATE;
684 pmcs_unlock_phy(pptr);
689 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL, pmcs_timeo, __func__);
735 pmcs_reset_phy(pmcs_hw_t *pwp, pmcs_phy_t *pptr, uint8_t type)
749 ASSERT(mutex_owned(&pptr->phy_lock));
752 phynum = pptr->phynum;
753 level = pptr->level;
755 pdevid = pptr->parent->device_id;
756 } else if ((level == 0) && (pptr->dtype == EXPANDER)) {
757 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, pptr->target,
758 "%s: Not resetting HBA PHY @ %s", __func__, pptr->path);
762 if (!pptr->iport || !pptr->valid_device_id) {
763 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, pptr->target,
764 "%s: Can't reach PHY %s", __func__, pptr->path);
768 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
771 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nowrk, __func__);
805 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
807 __func__, mbar, pptr->parent->path, pptr->phynum);
825 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
826 "%s: sending %s to %s", __func__, mbar, pptr->path);
835 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nomsg, __func__);
841 pmcs_hold_iport(pptr->iport);
842 iport = pptr->iport;
846 pmcs_unlock_phy(pptr);
851 pmcs_lock_phy(pptr);
853 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL, pmcs_timeo, __func__);
855 if (pmcs_abort(pwp, pptr, htag, 0, 0)) {
856 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
860 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
876 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
878 pptr->path);
893 pmcs_phy_t *pptr;
897 pptr = pwp->root_phys + phynum;
898 if (pptr == NULL) {
905 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
908 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL,
919 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL,
936 pptr, NULL, pmcs_timeo, __func__);
942 pptr->configured = 0;
1166 pmcs_phy_t *pptr, *pnext, *pnext_uplevel[PMCS_MAX_XPND];
1173 pptr = pwp->root_phys;
1176 while (pptr) {
1181 pmcs_lock_phy(pptr);
1182 if (pptr->need_rl_ext) {
1183 ASSERT(pptr->dtype == SATA);
1187 r = pmcs_sata_abort_ncq(pwp, pptr);
1193 r = pmcs_reset_phy(pwp, pptr,
1199 pptr->abort_pending = 1;
1200 pptr->abort_sent = 0;
1203 if (pptr->abort_pending == 0 || pptr->abort_sent) {
1206 pptr->abort_pending = 0;
1207 if (pmcs_abort(pwp, pptr, pptr->device_id, 1, 1) == ENOMEM) {
1208 pptr->abort_pending = 1;
1211 pptr->abort_sent = 1;
1216 if ((pptr->iport == NULL) ||
1217 (pptr->iport->ua_state != UA_ACTIVE)) {
1218 tgt = pptr->target;
1220 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, tgt,
1230 if (pptr->children) {
1231 pnext = pptr->children;
1232 pnext_uplevel[level++] = pptr->sibling;
1234 pnext = pptr->sibling;
1240 pmcs_unlock_phy(pptr);
1241 pptr = pnext;
1252 pmcs_register_device(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
1264 (pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr)) == NULL) {
1271 pwrk->dtype = pptr->dtype;
1276 (pptr->link_rate << PMCS_DEVREG_LINK_RATE_SHIFT);
1277 if (IS_ROOT_PHY(pptr)) {
1278 msg[2] = LE_32(pptr->portid |
1279 (pptr->phynum << PMCS_PHYID_SHIFT));
1281 msg[2] = LE_32(pptr->portid);
1283 if (pptr->dtype == SATA) {
1284 if (IS_ROOT_PHY(pptr)) {
1294 (void) memcpy(&msg[5], pptr->sas_address, 8);
1300 pmcs_unlock_phy(pptr);
1303 pmcs_lock_phy(pptr);
1306 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL, pmcs_timeo, __func__);
1316 if (pmcs_validate_devid(pwp->root_phys, pptr, tmp) == B_FALSE) {
1321 pmcs_prt(pwp, PMCS_PRT_INFO, pptr, NULL,
1323 __func__, pptr->path, tmp);
1327 pmcs_prt(pwp, PMCS_PRT_INFO, pptr, NULL,
1329 __func__, pptr->path, tmp);
1334 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
1336 __func__, status, pptr->path);
1340 pptr->device_id = tmp;
1341 pptr->valid_device_id = 1;
1342 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL, "Phy %s/" SAS_ADDR_FMT
1343 " registered with device_id 0x%x (portid %d)", pptr->path,
1344 SAS_ADDR_PRT(pptr->sas_address), tmp, pptr->portid);
1354 pmcs_deregister_device(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
1361 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
1367 pwrk->dtype = pptr->dtype;
1378 msg[2] = LE_32(pptr->device_id);
1383 pmcs_unlock_phy(pptr);
1386 pmcs_lock_phy(pptr);
1389 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL, pmcs_timeo, __func__);
1394 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
1396 __func__, status, pptr->path);
1398 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
1399 "%s: device %s deregistered", __func__, pptr->path);
1402 pptr->device_id = PMCS_INVALID_DEVICE_ID;
1403 pptr->configured = 0;
1404 pptr->deregister_wait = 0;
1405 pptr->valid_device_id = 0;
1439 pmcs_phy_t *pptr;
1758 for (pptr = pwp->root_phys; pptr; pptr = pptr->sibling) {
1759 pmcs_lock_phy(pptr);
1760 pmcs_clear_phy(pwp, pptr);
1761 pptr->target = NULL;
1762 pmcs_unlock_phy(pptr);
1900 pmcs_reset_dev(pmcs_hw_t *pwp, pmcs_phy_t *pptr, uint64_t lun)
1904 if (pptr == NULL) {
1908 pmcs_lock_phy(pptr);
1909 if (pptr->dtype == SAS) {
1924 rval = pmcs_ssp_tmf(pwp, pptr, SAS_LOGICAL_UNIT_RESET, 0, lun,
1926 } else if (pptr->dtype == SATA) {
1928 pmcs_unlock_phy(pptr);
1931 rval = pmcs_reset_phy(pwp, pptr, PMCS_PHYOP_LINK_RESET);
1933 pmcs_unlock_phy(pptr);
1934 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
1936 __func__, pptr->path);
1948 if (pmcs_abort(pwp, pptr, 0, 1, 0)) {
1949 pptr->abort_pending = 1;
1953 pmcs_unlock_phy(pptr);
1961 pmcs_get_device_handle(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
1963 if (pptr->valid_device_id == 0) {
1964 int result = pmcs_register_device(pwp, pptr);
1969 if (pptr->changed) {
1979 PHY_CHANGED(pwp, pptr);
1989 if (ddi_get_lbolt() < pptr->config_stop) {
1990 PHY_CHANGED(pwp, pptr);
1993 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
1995 __func__, pptr->path);
1996 pptr->config_stop = 0;
1997 pmcs_kill_changed(pwp, pptr, 0);
2005 if (result || pptr->valid_device_id == 0) {
2006 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
2008 pptr->path);
2073 iport->pptr = NULL;
2094 pmcs_phy_t *pptr;
2118 pptr = pwp->root_phys + phynum;
2119 ASSERT(pptr);
2120 pmcs_lock_phy(pptr);
2121 ASSERT(pptr->phynum == phynum);
2126 pptr->iport = iport;
2132 if (!pptr->subsidiary) {
2133 iport->pptr = pptr;
2134 iport->portid = pptr->portid;
2140 pmcs_unlock_phy(pptr);
2141 pmcs_add_phy_to_iport(iport, pptr);
2143 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL, "%s: found "
2145 (void *)pptr, inst, iport->refcnt);
2180 * Return the iport that pptr is associated with, or NULL.
2215 pmcs_phy_t *pptr, *child;
2224 for (pptr = pwp->root_phys; pptr; pptr = pptr->sibling) {
2225 if ((pptr->portid == portid) && (pptr != prev_primary)) {
2226 mutex_enter(&pptr->phy_lock);
2231 if (pptr == NULL) {
2238 iport->pptr = pptr;
2243 pptr->children = prev_primary->children;
2244 child = pptr->children;
2246 child->parent = pptr;
2249 pptr->ncphy = prev_primary->ncphy;
2250 pptr->width = prev_primary->width;
2251 pptr->dtype = prev_primary->dtype;
2252 pptr->pend_dtype = prev_primary->pend_dtype;
2253 pptr->tolerates_sas2 = prev_primary->tolerates_sas2;
2254 pptr->atdt = prev_primary->atdt;
2255 pptr->portid = prev_primary->portid;
2256 pptr->link_rate = prev_primary->link_rate;
2257 pptr->configured = prev_primary->configured;
2258 pptr->iport = prev_primary->iport;
2259 pptr->target = prev_primary->target;
2260 if (pptr->target) {
2261 pptr->target->phy = pptr;
2266 pmcs_update_phy_pm_props(pptr, pptr->att_port_pm_tmp,
2267 pptr->tgt_port_pm_tmp, B_FALSE);
2269 pmcs_update_phy_pm_props(pptr, prev_primary->att_port_pm_tmp,
2272 pmcs_update_phy_pm_props(pptr, prev_primary->att_port_pm,
2278 pptr->subsidiary = 0;
2283 pptr->device_id = prev_primary->device_id;
2284 pptr->valid_device_id = prev_primary->valid_device_id;
2288 * We call pmcs_unlock_phy() on pptr because it now contains the
2291 pmcs_unlock_phy(pptr);
2293 return (pptr);
2424 pmcs_phy_t *pptr;
2540 for (pptr = pwp->root_phys; pptr; pptr = pptr->sibling) {
2546 pmcs_lock_phy(pptr);
2547 pmcs_clear_expander(pwp, pptr, 0);
2548 pmcs_unlock_phy(pptr);
2609 pptr = pmcs_find_phy_needing_work(pwp, pwp->root_phys);
2610 if (pptr != NULL) {
2612 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
2614 "but no work scheduled", pptr->path, pptr->dead,
2615 pptr->changed, pptr->configured);
2617 pmcs_unlock_phy(pptr);
2639 pmcs_find_phy_needing_work(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
2643 while (pptr) {
2644 pmcs_lock_phy(pptr);
2646 if (pptr->changed || (pptr->dead && pptr->valid_device_id)) {
2647 return (pptr);
2650 pnext = pptr->sibling;
2652 if (pptr->children) {
2653 cphyp = pptr->children;
2654 pmcs_unlock_phy(pptr);
2660 pmcs_unlock_phy(pptr);
2663 pptr = pnext;
2755 pmcs_phy_t *pptr;
2762 pptr = pwp->root_phys;
2764 while (pptr) {
2765 pmcs_lock_phy(pptr);
2770 if ((pptr->dtype == NOTHING) || pptr->dead) {
2771 pmcs_unlock_phy(pptr);
2772 pptr = pptr->sibling;
2776 if (pptr->changed) {
2777 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
2779 __func__, pptr->path);
2780 pmcs_unlock_phy(pptr);
2788 wwn = pmcs_barray2wwn(pptr->sas_address);
2789 pmcs_unlock_phy(pptr);
2795 pptr = pptr->sibling;
2799 pmcs_lock_phy(pptr);
2802 pwp, iport, pptr) == B_FALSE) {
2804 pmcs_unlock_phy(pptr);
2809 pmcs_unlock_phy(pptr);
2810 pptr = pptr->sibling;
2847 pptr = iport->pptr;
2849 if (pptr == NULL) {
2858 pmcs_lock_phy(pptr);
2859 wwn = pmcs_barray2wwn(pptr->sas_address);
2861 pmcs_unlock_phy(pptr);
2974 * NOTE: pptr passed in by the caller will be a root PHY
2977 pmcs_configure_new_devices(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
2981 pmcs_phy_t *pnext, *orig_pptr = pptr, *root_phy, *pchild;
2987 while (pptr) {
2988 pmcs_lock_phy(pptr);
2989 pnext = pptr->sibling;
2994 if ((pptr->pend_dtype != NEW) &&
2995 (pptr->pend_dtype != pptr->dtype)) {
2996 pptr->dtype = pptr->pend_dtype;
2999 if (pptr->changed == 0 || pptr->dead || pptr->configured) {
3004 root_phy = pmcs_get_root_phy(pptr);
3006 pmcs_unlock_phy(pptr);
3014 pmcs_lock_phy(pptr);
3018 pmcs_lock_phy(pptr);
3019 switch (pptr->dtype) {
3021 pptr->changed = 0;
3025 pptr->iport = iport;
3026 pmcs_new_tport(pwp, pptr);
3029 pmcs_configure_expander(pwp, pptr, iport);
3043 pmcs_unlock_phy(pptr);
3044 pptr = pnext;
3055 pptr = orig_pptr;
3056 while (pptr) {
3057 pmcs_lock_phy(pptr);
3058 pnext = pptr->sibling;
3059 pchild = pptr->children;
3060 pmcs_unlock_phy(pptr);
3069 pptr = pnext;
3085 pmcs_phy_t *pptr;
3101 pptr = parent;
3102 while (pptr) {
3104 PHY_CHANGED(pwp, pptr);
3106 pptr->changed = 0;
3108 if (pptr->dtype == EXPANDER && pptr->level) {
3109 pptr->width = 1;
3111 if (pptr->children) {
3112 pmcs_set_changed(pwp, pptr->children, changed,
3115 pptr = pptr->sibling;
3129 pmcs_phy_t *pptr = parent;
3131 while (pptr) {
3132 pptr->link_rate = 0;
3133 pptr->abort_sent = 0;
3134 pptr->abort_pending = 1;
3136 pptr->need_rl_ext = 0;
3138 if (pptr->dead == 0) {
3139 PHY_CHANGED(pwp, pptr);
3143 pptr->dead = 1;
3145 if (pptr->children) {
3146 pmcs_kill_changed(pwp, pptr->children, level + 1);
3156 pptr = pptr->sibling;
3164 pmcs_clear_phys(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
3168 phyp = pptr;
3196 pmcs_clear_phy(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
3198 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL, "%s: %s",
3199 __func__, pptr->path);
3200 ASSERT(mutex_owned(&pptr->phy_lock));
3204 pptr->device_id = PMCS_INVALID_DEVICE_ID;
3206 pptr->ncphy = 0;
3208 pptr->width = 0;
3209 pptr->ds_recovery_retries = 0;
3210 pptr->ds_prev_good_recoveries = 0;
3211 pptr->last_good_recovery = 0;
3212 pptr->prev_recovery = 0;
3215 pptr->config_stop = 0;
3216 pptr->spinup_hold = 0;
3217 pptr->atdt = 0;
3219 pptr->link_rate = 0;
3220 pptr->valid_device_id = 0;
3221 pptr->abort_sent = 0;
3222 pptr->abort_pending = 0;
3223 pptr->need_rl_ext = 0;
3224 pptr->subsidiary = 0;
3225 pptr->configured = 0;
3226 pptr->deregister_wait = 0;
3227 pptr->reenumerate = 0;
3230 if (!IS_ROOT_PHY(pptr) && (pptr->dtype != NOTHING))
3231 pptr->dead = 1;
3232 pptr->changed = 0;
3237 if (!IS_ROOT_PHY(pptr)) {
3238 pptr->last_iport = pptr->iport;
3239 pptr->iport = NULL;
3252 pmcs_new_tport(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
3254 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL, "%s: phy 0x%p @ %s",
3255 __func__, (void *)pptr, pptr->path);
3257 if (pmcs_configure_phy(pwp, pptr) == B_FALSE) {
3261 PHY_CHANGED(pwp, pptr);
3262 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3264 (void *)pptr);
3269 pptr->changed = 0;
3280 if (pptr->target == NULL) {
3281 if (IS_ROOT_PHY(pptr)) {
3285 if (rphy == pptr) {
3291 if ((rphy->iport == pptr->iport) &&
3294 pptr->target = rphy->target;
3296 pptr->target->phy = pptr;
3297 /* The target is now on pptr */
3298 mutex_exit(&pptr->target->statlock);
3301 pptr, pptr->target,
3303 __func__, rphy->path, pptr->path);
3311 pmcs_reap_dead_phy(pptr);
3323 if (pptr->target) {
3324 mutex_enter(&pptr->target->statlock);
3325 if (pmcs_phy_target_match(pptr) == B_FALSE) {
3326 mutex_exit(&pptr->target->statlock);
3327 if (!IS_ROOT_PHY(pptr)) {
3328 pmcs_dec_phy_ref_count(pptr);
3330 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
3332 "(WWN mismatch)", __func__, (void *)pptr->target,
3333 (void *)pptr);
3334 pptr->target = NULL;
3338 if (!pmcs_assign_device(pwp, pptr->target)) {
3339 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, pptr->target,
3341 __func__, (void *)pptr->target);
3343 mutex_exit(&pptr->target->statlock);
3351 pmcs_configure_phy(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
3355 ASSERT(mutex_owned(&pptr->phy_lock));
3360 pptr->changed = 0;
3365 if (pmcs_get_device_handle(pwp, pptr)) {
3369 pptr->configured = 1;
3371 switch (pptr->dtype) {
3385 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL, "config_dev: %s "
3386 "dev %s " SAS_ADDR_FMT " dev id 0x%x lr 0x%x", dtype, pptr->path,
3387 SAS_ADDR_PRT(pptr->sas_address), pptr->device_id, pptr->link_rate);
3396 pmcs_configure_expander(pmcs_hw_t *pwp, pmcs_phy_t *pptr, pmcs_iport_t *iport)
3411 if (IS_ROOT_PHY(pptr) && pptr->changed) {
3412 pptr->config_stop = ddi_get_lbolt() +
3415 pptr->changed = 0;
3420 if (pptr->level == PMCS_MAX_XPND-1) {
3421 pmcs_prt(pwp, PMCS_PRT_WARN, pptr, NULL,
3435 if (!IS_ROOT_PHY(pptr)) {
3443 ctmp = pptr->parent->children;
3451 * If we've checked all PHYs up to pptr, we stop. Otherwise,
3453 * number than pptr, which will never happen. The primary
3457 if (ctmp == pptr) {
3462 * If pptr and ctmp are root PHYs, just grab the mutex on
3473 memcmp(ctmp->sas_address, pptr->sas_address, 8) == 0) {
3481 pptr->parent->sas_address, 8) == 0) {
3489 pptr->subsidiary = 1;
3497 pptr->att_port_pm_tmp,
3498 pptr->tgt_port_pm_tmp, B_TRUE);
3500 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3502 "(now %d wide)", __func__, pptr->path,
3522 pptr->subsidiary = 0;
3523 pptr->iport = iport;
3524 if (pmcs_get_device_handle(pwp, pptr)) {
3527 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL, "Config expander %s "
3528 SAS_ADDR_FMT " dev id 0x%x lr 0x%x", pptr->path,
3529 SAS_ADDR_PRT(pptr->sas_address), pptr->device_id, pptr->link_rate);
3534 nphy = pmcs_expander_get_nphy(pwp, pptr);
3536 if (nphy == 0 && ddi_get_lbolt() < pptr->config_stop) {
3537 PHY_CHANGED(pwp, pptr);
3540 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3542 pptr->path);
3543 pptr->config_stop = 0;
3544 pmcs_kill_changed(pwp, pptr, 0);
3585 ctmp->parent = pptr;
3587 ctmp->level = pptr->level+1;
3588 ctmp->portid = pptr->portid;
3604 result = pmcs_expander_content_discover(pwp, pptr, ctmp);
3606 if (ddi_get_lbolt() < pptr->config_stop) {
3607 PHY_CHANGED(pwp, pptr);
3610 pptr->config_stop = 0;
3611 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3613 __func__, pptr->path);
3614 pmcs_kill_changed(pwp, pptr, 0);
3632 if (pptr->children != NULL) {
3633 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
3635 __func__, pptr->path);
3636 pmcs_add_dead_phys(pwp, pptr->children);
3642 pptr->children = clist;
3644 pptr->ncphy = nphy;
3645 pptr->configured = 1;
3650 if (pptr->level) {
3651 pptr->width = 1;
3657 pptr->iport = iport;
3658 pmcs_new_tport(pwp, pptr);
3681 * Called with PHY (pptr) locked.
3685 pmcs_check_expander(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
3691 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3692 "%s: check %s", __func__, pptr->path);
3698 pptr->changed = 0;
3705 pptr->config_stop = ddi_get_lbolt() +
3714 nphy = pmcs_expander_get_nphy(pwp, pptr);
3716 if ((nphy == 0) && (ddi_get_lbolt() < pptr->config_stop)) {
3717 PHY_CHANGED(pwp, pptr);
3720 pptr->config_stop = 0;
3721 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3723 pptr->path);
3724 pmcs_kill_changed(pwp, pptr, 0);
3732 if (nphy != pptr->ncphy) {
3733 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3735 __func__, pptr->path, pptr->ncphy, nphy);
3740 pmcs_kill_changed(pwp, pptr, 0);
3748 if (pptr->level == PMCS_MAX_XPND-1) {
3757 ctmp = pptr->children;
3760 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3762 pptr->path);
3788 result = pmcs_expander_content_discover(pwp, pptr, local);
3791 if (ddi_get_lbolt() < pptr->config_stop) {
3792 PHY_CHANGED(pwp, pptr);
3795 pptr->config_stop = 0;
3796 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
3798 __func__, pptr->path);
3799 pmcs_kill_changed(pwp, pptr, 0);
3825 ctmp = pptr->children;
4003 pmcs_check_expanders(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
4007 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4008 "%s: %s", __func__, pptr->path);
4013 phyp = pptr;
4031 phyp = pptr;
4050 pmcs_clear_expander(pmcs_hw_t *pwp, pmcs_phy_t *pptr, int level)
4055 ASSERT(mutex_owned(&pptr->phy_lock));
4056 ASSERT(pptr->level < PMCS_MAX_XPND - 1);
4058 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4059 "%s: checking %s", __func__, pptr->path);
4061 ctmp = pptr->children;
4066 if (pptr->dead) {
4078 if (!pptr->dead) {
4085 if (pptr->children) {
4086 pmcs_add_dead_phys(pwp, pptr->children);
4089 pptr->children = NULL;
4096 if (!IS_ROOT_PHY(pptr)) {
4098 mutex_enter(&pptr->parent->phy_lock);
4100 ctmp = pptr->parent->children;
4102 mutex_exit(&pptr->parent->phy_lock);
4109 if (ctmp == pptr) {
4122 memcmp(ctmp->sas_address, pptr->sas_address,
4139 pmcs_clear_phy(pwp, pptr);
4152 pmcs_expander_get_nphy(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
4166 if (!pptr->iport || !pptr->valid_device_id) {
4167 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, pptr->target,
4168 "%s: Can't reach PHY %s", __func__, pptr->path);
4172 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
4178 pwrk->dtype = pptr->dtype;
4179 pwrk->xp = pptr->target;
4185 pmcs_prt(pwp, PMCS_PRT_DEBUG2, pptr, NULL,
4193 msg[2] = LE_32(pptr->device_id);
4213 pmcs_hold_iport(pptr->iport);
4214 iport = pptr->iport;
4219 pmcs_unlock_phy(pptr);
4224 pmcs_lock_phy(pptr);
4227 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4229 if (pmcs_abort(pwp, pptr, htag, 0, 1)) {
4230 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4251 pmcs_prt(pwp, PMCS_PRT_DEBUG_UNDERFLOW, pptr, NULL,
4287 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4289 __func__, pptr->path, nag);
4298 pmcs_xscsi_t *xp = pptr->target;
4300 pmcs_prt(pwp, PMCS_PRT_DEBUG_DEV_STATE, pptr, xp,
4302 __func__, pptr->path);
4313 pmcs_start_dev_state_recovery(xp, pptr);
4326 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4331 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4343 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4348 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4352 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4354 __func__, pptr->path);
4359 pptr->tolerates_sas2 = 1;
4364 bcopy(srgr, &pptr->rg_resp, sizeof (smp_report_general_resp_t));
4365 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4366 "%s has %d phys and %s SAS2", pptr->path, result,
4367 pptr->tolerates_sas2? "tolerates" : "does not tolerate");
4374 * Called with expander locked (and thus, pptr) as well as all PHYs up to
4383 pmcs_phy_t *pptr)
4428 msg[6] = BE_32((pptr->phynum << 16));
4460 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4462 if (pmcs_abort(pwp, pptr, htag, 0, 1)) {
4463 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4491 pmcs_prt(pwp, PMCS_PRT_DEBUG_UNDERFLOW, pptr, NULL,
4520 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4522 __func__, pptr->path, nag);
4531 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4537 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4554 bcopy(sdr, &pptr->disc_resp, sizeof (smp_discover_resp_t));
4569 pptr->virtual = sdr->sdr_virtual_phy;
4574 pptr->routing_attr = sdr->sdr_routing_attr;
4578 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4581 pptr->path,
4592 pptr->dtype = SATA;
4594 pptr->dtype = SAS;
4596 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4598 __func__, pptr->path, tgt_support, ini_support);
4601 switch (pptr->routing_attr) {
4605 pptr->routing_method = SMP_ROUTING_DIRECT;
4608 pptr->routing_method = 0xff; /* Invalid method */
4611 pmcs_update_phy_pm_props(pptr, (1ULL << pptr->phynum),
4616 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4619 pptr->path,
4636 pmcs_prt(pwp, PMCS_PRT_DEBUG3, pptr, NULL,
4638 "expander (%s)", __func__, pptr->path);
4639 pptr->dtype = NOTHING;
4642 pptr->dtype = EXPANDER;
4645 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4647 pptr->path, tgt_support, ini_support);
4648 pptr->dtype = EXPANDER;
4650 if (pptr->routing_attr == SMP_ROUTING_DIRECT) {
4651 pptr->routing_method = 0xff; /* Invalid method */
4653 pptr->routing_method = pptr->routing_attr;
4655 pmcs_update_phy_pm_props(pptr, (1ULL << pptr->phynum),
4659 pptr->dtype = NOTHING;
4662 if (pptr->dtype != NOTHING) {
4671 if (expander->tolerates_sas2 && pptr->dtype == SATA &&
4673 (void) memcpy(pptr->sas_address,
4676 (void) memcpy(pptr->sas_address, att_sas_address, 8);
4678 pptr->atdt = (sdr->sdr_attached_device_type);
4686 pmcs_prt(pwp, PMCS_PRT_DEBUG_CONFIG, pptr, NULL,
4688 "to %s being slower", pptr->path,
4696 pptr->link_rate = sdr->sdr_negotiated_logical_link_rate;
4697 pptr->state.prog_min_rate = sdr->sdr_prog_min_phys_link_rate;
4698 pptr->state.hw_min_rate = sdr->sdr_hw_min_phys_link_rate;
4699 pptr->state.prog_max_rate = sdr->sdr_prog_max_phys_link_rate;
4700 pptr->state.hw_max_rate = sdr->sdr_hw_max_phys_link_rate;
4701 PHY_CHANGED(pwp, pptr);
4703 pmcs_clear_phy(pwp, pptr);
4871 pmcs_abort(pmcs_hw_t *pwp, pmcs_phy_t *pptr, uint32_t tag, int all_cmds,
4880 if (pptr->abort_all_start) {
4881 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL, "%s: ABORT_ALL for "
4882 "(%s) already in progress.", __func__, pptr->path);
4886 switch (pptr->dtype) {
4901 pptr);
4904 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nowrk, __func__);
4908 pwrk->dtype = pptr->dtype;
4909 pwrk->xp = pptr->target;
4914 if (pptr->valid_device_id == 0) {
4916 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4922 msg[2] = LE_32(pptr->device_id);
4928 pptr->abort_all_start = gethrtime();
4939 pptr->abort_all_start = 0;
4940 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nomsg, __func__);
4946 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4948 __func__, pmcs_get_typename(pptr->dtype), pptr->path,
4951 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
4953 __func__, tag, pmcs_get_typename(pptr->dtype), pptr->path,
4965 pmcs_unlock_phy(pptr);
4968 pmcs_lock_phy(pptr);
4969 tgt = pptr->target;
4972 pptr->abort_all_start = 0;
4973 cv_signal(&pptr->abort_all_cv);
4978 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
4981 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
4990 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
4994 PMCS_DEVICE_STATE_IN_RECOVERY, pptr, tgt);
5015 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
5018 PHY_CHANGED(pwp, pptr);
5030 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
5034 PMCS_DEVICE_STATE_OPERATIONAL, pptr, tgt);
5049 pmcs_ssp_tmf(pmcs_hw_t *pwp, pmcs_phy_t *pptr, uint8_t tmf, uint32_t tag,
5062 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
5064 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nowrk, __func__);
5076 msg[2] = LE_32(pptr->device_id);
5092 pmcs_prt(pwp, PMCS_PRT_ERR, pptr, NULL, pmcs_nomsg, __func__);
5097 pwrk->dtype = pptr->dtype;
5098 xp = pptr->target;
5107 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp, "%s: Not "
5116 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5118 pmcs_tmf2str(tmf), pptr->path, (unsigned long long) lun, tag);
5122 pmcs_unlock_phy(pptr);
5130 pmcs_lock_phy(pptr);
5131 xp = pptr->target;
5139 pmcs_start_dev_state_recovery(xp, pptr);
5146 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5149 pptr->path, (unsigned long long) lun);
5168 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5174 pptr, xp);
5184 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5190 pptr, xp);
5196 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5204 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5227 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5232 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5237 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5242 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5247 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5252 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5257 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5263 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, xp,
5275 pmcs_sata_abort_ncq(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
5285 pwrk = pmcs_gwork(pwp, PMCS_TAG_TYPE_WAIT, pptr);
5293 msg[2] = LE_32(pptr->device_id);
5308 pwrk->dtype = pptr->dtype;
5309 pwrk->xp = pptr->target;
5322 pmcs_unlock_phy(pptr);
5325 pmcs_lock_phy(pptr);
5327 tgt = pptr->target;
5329 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt, pmcs_timeo, __func__);
5335 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
5337 "dev state recovery", __func__, (void *)pptr);
5352 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt, "%s: Trying "
5355 (void) pmcs_send_err_recovery_cmd(pwp, ds, pptr, tgt);
5367 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
5370 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, tgt,
5374 pptr->need_rl_ext = 0;
5703 pmcs_phy_name(pmcs_hw_t *pwp, pmcs_phy_t *pptr, char *obuf, size_t olen)
5705 if (pptr->parent) {
5706 pmcs_phy_name(pwp, pptr->parent, obuf, olen);
5707 (void) snprintf(obuf, olen, "%s.%02x", obuf, pptr->phynum);
5709 (void) snprintf(obuf, olen, "pp%02x", pptr->phynum);
5720 pmcs_phy_t *pptr, *pchild;
5723 pptr = parent;
5725 while (pptr) {
5726 if (pptr->valid_device_id && (pptr != phyp) &&
5727 (pptr->device_id == device_id)) {
5736 if ((phyp->parent == pptr->parent) &&
5738 pptr->sas_address, 8) == 0) && (phyp->width > 1)) {
5743 pmcs_lock_phy(pptr);
5744 phyp->children = pptr->children;
5751 phyp->ncphy = pptr->ncphy;
5756 pptr->children = NULL;
5757 pptr->subsidiary = 1;
5758 pptr->ncphy = 0;
5759 pmcs_unlock_phy(pptr);
5760 pmcs_prt(pptr->pwp, PMCS_PRT_DEBUG, pptr, NULL,
5762 __func__, device_id, pptr->path,
5766 pmcs_prt(pptr->pwp, PMCS_PRT_DEBUG, pptr, NULL,
5769 pptr->path, device_id);
5773 if (pptr->children) {
5774 rval = pmcs_validate_devid(pptr->children, phyp,
5781 pptr = pptr->sibling;
5838 pmcs_phy_t *pptr, *matched_phy;
5842 pptr = pwp->root_phys;
5843 while (pptr) {
5844 matched_phy = pmcs_find_phy_by_wwn_impl(pptr, ebstr);
5850 pptr = pptr->sibling;
5870 pmcs_phy_t *pptr, *pnext, *pchild;
5873 pptr = pwp->root_phys;
5875 pptr = root;
5878 while (pptr) {
5879 pmcs_lock_phy(pptr);
5884 if ((pptr->dead) || (!pptr->valid_device_id)) {
5888 if (pptr->iport != iport) {
5892 wwn = pmcs_barray2wwn(pptr->sas_address);
5895 return (pptr);
5898 if (pptr->children) {
5899 pchild = pptr->children;
5900 pmcs_unlock_phy(pptr);
5906 pmcs_lock_phy(pptr);
5910 pnext = pptr->sibling;
5911 pmcs_unlock_phy(pptr);
5912 pptr = pnext;
6106 pmcs_kill_device(pmcs_hw_t *pwp, pmcs_phy_t *pptr)
6110 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL, "kill %s device @ %s",
6111 pmcs_get_typename(pptr->dtype), pptr->path);
6120 if (pptr->abort_all_start) {
6121 while (pptr->abort_all_start) {
6122 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
6124 __func__, (void *)pptr);
6125 cv_wait(&pptr->abort_all_cv, &pptr->phy_lock);
6127 } else if (pptr->abort_pending) {
6128 rval = pmcs_abort(pwp, pptr, pptr->device_id, 1, 1);
6130 pmcs_prt(pwp, PMCS_PRT_DEBUG, pptr, NULL,
6132 "PHY 0x%p", __func__, rval, (void *)pptr);
6135 pptr->abort_pending = 0;
6138 if (pptr->valid_device_id) {
6139 pmcs_deregister_device(pwp, pptr);
6142 PHY_CHANGED(pwp, pptr);
6144 pptr->valid_device_id = 0;
6157 pmcs_phy_t *pptr;
6159 for (pptr = pwp->root_phys; pptr; pptr = pptr->sibling) {
6160 pmcs_lock_phy(pptr);
6161 if (pptr->hw_event_ack == 0) {
6162 pmcs_unlock_phy(pptr);
6171 pmcs_unlock_phy(pptr);
6179 msg[2] = LE_32(pptr->hw_event_ack);
6182 pwrk->dtype = pptr->dtype;
6183 pptr->hw_event_ack = 0;
6186 pmcs_unlock_phy(pptr);
7121 pmcs_phy_t *pptr = NULL;
7141 pptr = pwrk->phy;
7145 if ((pwrk->abt_htag == PMCS_ABT_HTAG_ALL) && (pptr != NULL)) {
7146 mutex_enter(&pptr->phy_lock);
7147 if (pptr->abort_all_start) {
7148 pptr->abort_all_start = 0;
7149 cv_signal(&pptr->abort_all_cv);
7151 mutex_exit(&pptr->phy_lock);
7917 pmcs_phy_t *pptr, *next_pptr;
7925 for (pptr = list_head(&iport->phys); pptr != NULL;
7926 pptr = next_pptr) {
7927 next_pptr = list_next(&iport->phys, pptr);
7928 mutex_enter(&pptr->phy_lock);
7929 if (pptr->phy_stats != NULL) {
7930 kstat_delete(pptr->phy_stats);
7931 pptr->phy_stats = NULL;
7933 pptr->iport = NULL;
7934 pmcs_update_phy_pm_props(pptr, pptr->att_port_pm_tmp,
7935 pptr->tgt_port_pm_tmp, B_FALSE);
7936 mutex_exit(&pptr->phy_lock);
7938 list_remove(&iport->phys, pptr);
8137 pmcs_phy_t *pptr;
8139 for (pptr = pwp->root_phys; pptr; pptr = pptr->sibling) {
8140 pmcs_lock_phy(pptr);
8141 if (pptr->deregister_wait) {
8142 pmcs_deregister_device(pwp, pptr);
8144 pmcs_unlock_phy(pptr);