1 /* SPDX-License-Identifier: BSD-3-Clause 2 * 3 * Copyright(c) 2019-2020 Xilinx, Inc. 4 * Copyright(c) 2012-2019 Solarflare Communications Inc. 5 */ 6 7 #include "efx.h" 8 #include "efx_impl.h" 9 10 #if EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10() 11 12 static void 13 mcdi_phy_decode_cap( 14 __in uint32_t mcdi_cap, 15 __out uint32_t *maskp) 16 { 17 uint32_t mask; 18 19 #define CHECK_CAP(_cap) \ 20 EFX_STATIC_ASSERT(EFX_PHY_CAP_##_cap == MC_CMD_PHY_CAP_##_cap##_LBN) 21 22 CHECK_CAP(10HDX); 23 CHECK_CAP(10FDX); 24 CHECK_CAP(100HDX); 25 CHECK_CAP(100FDX); 26 CHECK_CAP(1000HDX); 27 CHECK_CAP(1000FDX); 28 CHECK_CAP(10000FDX); 29 CHECK_CAP(25000FDX); 30 CHECK_CAP(40000FDX); 31 CHECK_CAP(50000FDX); 32 CHECK_CAP(100000FDX); 33 CHECK_CAP(PAUSE); 34 CHECK_CAP(ASYM); 35 CHECK_CAP(AN); 36 CHECK_CAP(DDM); 37 CHECK_CAP(BASER_FEC); 38 CHECK_CAP(BASER_FEC_REQUESTED); 39 CHECK_CAP(RS_FEC); 40 CHECK_CAP(RS_FEC_REQUESTED); 41 CHECK_CAP(25G_BASER_FEC); 42 CHECK_CAP(25G_BASER_FEC_REQUESTED); 43 #undef CHECK_CAP 44 45 mask = 0; 46 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_10HDX_LBN)) 47 mask |= (1 << EFX_PHY_CAP_10HDX); 48 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_10FDX_LBN)) 49 mask |= (1 << EFX_PHY_CAP_10FDX); 50 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_100HDX_LBN)) 51 mask |= (1 << EFX_PHY_CAP_100HDX); 52 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_100FDX_LBN)) 53 mask |= (1 << EFX_PHY_CAP_100FDX); 54 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_1000HDX_LBN)) 55 mask |= (1 << EFX_PHY_CAP_1000HDX); 56 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_1000FDX_LBN)) 57 mask |= (1 << EFX_PHY_CAP_1000FDX); 58 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_10000FDX_LBN)) 59 mask |= (1 << EFX_PHY_CAP_10000FDX); 60 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_25000FDX_LBN)) 61 mask |= (1 << EFX_PHY_CAP_25000FDX); 62 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_40000FDX_LBN)) 63 mask |= (1 << EFX_PHY_CAP_40000FDX); 64 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_50000FDX_LBN)) 65 mask |= (1 << EFX_PHY_CAP_50000FDX); 66 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_100000FDX_LBN)) 67 mask |= (1 << EFX_PHY_CAP_100000FDX); 68 69 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_PAUSE_LBN)) 70 mask |= (1 << EFX_PHY_CAP_PAUSE); 71 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_ASYM_LBN)) 72 mask |= (1 << EFX_PHY_CAP_ASYM); 73 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_AN_LBN)) 74 mask |= (1 << EFX_PHY_CAP_AN); 75 76 /* FEC caps (supported on Medford2 and later) */ 77 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_BASER_FEC_LBN)) 78 mask |= (1 << EFX_PHY_CAP_BASER_FEC); 79 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_BASER_FEC_REQUESTED_LBN)) 80 mask |= (1 << EFX_PHY_CAP_BASER_FEC_REQUESTED); 81 82 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_RS_FEC_LBN)) 83 mask |= (1 << EFX_PHY_CAP_RS_FEC); 84 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_RS_FEC_REQUESTED_LBN)) 85 mask |= (1 << EFX_PHY_CAP_RS_FEC_REQUESTED); 86 87 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_25G_BASER_FEC_LBN)) 88 mask |= (1 << EFX_PHY_CAP_25G_BASER_FEC); 89 if (mcdi_cap & (1 << MC_CMD_PHY_CAP_25G_BASER_FEC_REQUESTED_LBN)) 90 mask |= (1 << EFX_PHY_CAP_25G_BASER_FEC_REQUESTED); 91 92 *maskp = mask; 93 } 94 95 static void 96 mcdi_phy_decode_link_mode( 97 __in efx_nic_t *enp, 98 __in uint32_t link_flags, 99 __in unsigned int speed, 100 __in unsigned int fcntl, 101 __in uint32_t fec, 102 __out efx_link_mode_t *link_modep, 103 __out unsigned int *fcntlp, 104 __out efx_phy_fec_type_t *fecp) 105 { 106 boolean_t fd = !!(link_flags & 107 (1 << MC_CMD_GET_LINK_OUT_FULL_DUPLEX_LBN)); 108 boolean_t up = !!(link_flags & 109 (1 << MC_CMD_GET_LINK_OUT_LINK_UP_LBN)); 110 111 _NOTE(ARGUNUSED(enp)) 112 113 if (!up) 114 *link_modep = EFX_LINK_DOWN; 115 else if (speed == 100000 && fd) 116 *link_modep = EFX_LINK_100000FDX; 117 else if (speed == 50000 && fd) 118 *link_modep = EFX_LINK_50000FDX; 119 else if (speed == 40000 && fd) 120 *link_modep = EFX_LINK_40000FDX; 121 else if (speed == 25000 && fd) 122 *link_modep = EFX_LINK_25000FDX; 123 else if (speed == 10000 && fd) 124 *link_modep = EFX_LINK_10000FDX; 125 else if (speed == 1000) 126 *link_modep = fd ? EFX_LINK_1000FDX : EFX_LINK_1000HDX; 127 else if (speed == 100) 128 *link_modep = fd ? EFX_LINK_100FDX : EFX_LINK_100HDX; 129 else if (speed == 10) 130 *link_modep = fd ? EFX_LINK_10FDX : EFX_LINK_10HDX; 131 else 132 *link_modep = EFX_LINK_UNKNOWN; 133 134 if (fcntl == MC_CMD_FCNTL_OFF) 135 *fcntlp = 0; 136 else if (fcntl == MC_CMD_FCNTL_RESPOND) 137 *fcntlp = EFX_FCNTL_RESPOND; 138 else if (fcntl == MC_CMD_FCNTL_GENERATE) 139 *fcntlp = EFX_FCNTL_GENERATE; 140 else if (fcntl == MC_CMD_FCNTL_BIDIR) 141 *fcntlp = EFX_FCNTL_RESPOND | EFX_FCNTL_GENERATE; 142 else { 143 EFSYS_PROBE1(mc_pcol_error, int, fcntl); 144 *fcntlp = 0; 145 } 146 147 switch (fec) { 148 case MC_CMD_FEC_NONE: 149 *fecp = EFX_PHY_FEC_NONE; 150 break; 151 case MC_CMD_FEC_BASER: 152 *fecp = EFX_PHY_FEC_BASER; 153 break; 154 case MC_CMD_FEC_RS: 155 *fecp = EFX_PHY_FEC_RS; 156 break; 157 default: 158 EFSYS_PROBE1(mc_pcol_error, int, fec); 159 *fecp = EFX_PHY_FEC_NONE; 160 break; 161 } 162 } 163 164 165 void 166 ef10_phy_link_ev( 167 __in efx_nic_t *enp, 168 __in efx_qword_t *eqp, 169 __out efx_link_mode_t *link_modep) 170 { 171 efx_port_t *epp = &(enp->en_port); 172 unsigned int link_flags; 173 unsigned int speed; 174 unsigned int fcntl; 175 efx_phy_fec_type_t fec = MC_CMD_FEC_NONE; 176 efx_link_mode_t link_mode; 177 uint32_t lp_cap_mask; 178 179 /* 180 * Convert the LINKCHANGE speed enumeration into mbit/s, in the 181 * same way as GET_LINK encodes the speed 182 */ 183 switch (MCDI_EV_FIELD(eqp, LINKCHANGE_SPEED)) { 184 case MCDI_EVENT_LINKCHANGE_SPEED_100M: 185 speed = 100; 186 break; 187 case MCDI_EVENT_LINKCHANGE_SPEED_1G: 188 speed = 1000; 189 break; 190 case MCDI_EVENT_LINKCHANGE_SPEED_10G: 191 speed = 10000; 192 break; 193 case MCDI_EVENT_LINKCHANGE_SPEED_25G: 194 speed = 25000; 195 break; 196 case MCDI_EVENT_LINKCHANGE_SPEED_40G: 197 speed = 40000; 198 break; 199 case MCDI_EVENT_LINKCHANGE_SPEED_50G: 200 speed = 50000; 201 break; 202 case MCDI_EVENT_LINKCHANGE_SPEED_100G: 203 speed = 100000; 204 break; 205 default: 206 speed = 0; 207 break; 208 } 209 210 link_flags = MCDI_EV_FIELD(eqp, LINKCHANGE_LINK_FLAGS); 211 mcdi_phy_decode_link_mode(enp, link_flags, speed, 212 MCDI_EV_FIELD(eqp, LINKCHANGE_FCNTL), 213 MC_CMD_FEC_NONE, &link_mode, 214 &fcntl, &fec); 215 mcdi_phy_decode_cap(MCDI_EV_FIELD(eqp, LINKCHANGE_LP_CAP), 216 &lp_cap_mask); 217 218 /* 219 * It's safe to update ep_lp_cap_mask without the driver's port lock 220 * because presumably any concurrently running efx_port_poll() is 221 * only going to arrive at the same value. 222 * 223 * ep_fcntl has two meanings. It's either the link common fcntl 224 * (if the PHY supports AN), or it's the forced link state. If 225 * the former, it's safe to update the value for the same reason as 226 * for ep_lp_cap_mask. If the latter, then just ignore the value, 227 * because we can race with efx_mac_fcntl_set(). 228 */ 229 epp->ep_lp_cap_mask = lp_cap_mask; 230 epp->ep_fcntl = fcntl; 231 232 *link_modep = link_mode; 233 } 234 235 __checkReturn efx_rc_t 236 ef10_phy_power( 237 __in efx_nic_t *enp, 238 __in boolean_t power) 239 { 240 efx_rc_t rc; 241 242 if (!power) 243 return (0); 244 245 /* Check if the PHY is a zombie */ 246 if ((rc = ef10_phy_verify(enp)) != 0) 247 goto fail1; 248 249 enp->en_reset_flags |= EFX_RESET_PHY; 250 251 return (0); 252 253 fail1: 254 EFSYS_PROBE1(fail1, efx_rc_t, rc); 255 256 return (rc); 257 } 258 259 __checkReturn efx_rc_t 260 ef10_phy_get_link( 261 __in efx_nic_t *enp, 262 __out ef10_link_state_t *elsp) 263 { 264 efx_mcdi_req_t req; 265 uint32_t fec; 266 EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_LINK_IN_LEN, 267 MC_CMD_GET_LINK_OUT_V2_LEN); 268 efx_rc_t rc; 269 270 req.emr_cmd = MC_CMD_GET_LINK; 271 req.emr_in_buf = payload; 272 req.emr_in_length = MC_CMD_GET_LINK_IN_LEN; 273 req.emr_out_buf = payload; 274 req.emr_out_length = MC_CMD_GET_LINK_OUT_V2_LEN; 275 276 efx_mcdi_execute(enp, &req); 277 278 if (req.emr_rc != 0) { 279 rc = req.emr_rc; 280 goto fail1; 281 } 282 283 if (req.emr_out_length_used < MC_CMD_GET_LINK_OUT_LEN) { 284 rc = EMSGSIZE; 285 goto fail2; 286 } 287 288 mcdi_phy_decode_cap(MCDI_OUT_DWORD(req, GET_LINK_OUT_CAP), 289 &elsp->epls.epls_adv_cap_mask); 290 mcdi_phy_decode_cap(MCDI_OUT_DWORD(req, GET_LINK_OUT_LP_CAP), 291 &elsp->epls.epls_lp_cap_mask); 292 293 if (req.emr_out_length_used < MC_CMD_GET_LINK_OUT_V2_LEN) 294 fec = MC_CMD_FEC_NONE; 295 else 296 fec = MCDI_OUT_DWORD(req, GET_LINK_OUT_V2_FEC_TYPE); 297 298 mcdi_phy_decode_link_mode(enp, MCDI_OUT_DWORD(req, GET_LINK_OUT_FLAGS), 299 MCDI_OUT_DWORD(req, GET_LINK_OUT_LINK_SPEED), 300 MCDI_OUT_DWORD(req, GET_LINK_OUT_FCNTL), 301 fec, &elsp->epls.epls_link_mode, 302 &elsp->epls.epls_fcntl, &elsp->epls.epls_fec); 303 304 if (req.emr_out_length_used < MC_CMD_GET_LINK_OUT_V2_LEN) { 305 elsp->epls.epls_ld_cap_mask = 0; 306 } else { 307 mcdi_phy_decode_cap(MCDI_OUT_DWORD(req, GET_LINK_OUT_V2_LD_CAP), 308 &elsp->epls.epls_ld_cap_mask); 309 } 310 311 312 #if EFSYS_OPT_LOOPBACK 313 /* 314 * MC_CMD_LOOPBACK and EFX_LOOPBACK names are equivalent, so use the 315 * MCDI value directly. Agreement is checked in efx_loopback_mask(). 316 */ 317 elsp->els_loopback = MCDI_OUT_DWORD(req, GET_LINK_OUT_LOOPBACK_MODE); 318 #endif /* EFSYS_OPT_LOOPBACK */ 319 320 elsp->els_mac_up = MCDI_OUT_DWORD(req, GET_LINK_OUT_MAC_FAULT) == 0; 321 322 return (0); 323 324 fail2: 325 EFSYS_PROBE(fail2); 326 fail1: 327 EFSYS_PROBE1(fail1, efx_rc_t, rc); 328 329 return (rc); 330 } 331 332 static __checkReturn efx_rc_t 333 efx_mcdi_phy_set_link( 334 __in efx_nic_t *enp, 335 __in uint32_t cap_mask, 336 __in efx_loopback_type_t loopback_type, 337 __in efx_link_mode_t loopback_link_mode, 338 __in uint32_t phy_flags) 339 { 340 efx_mcdi_req_t req; 341 EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_LINK_IN_LEN, 342 MC_CMD_SET_LINK_OUT_LEN); 343 unsigned int speed; 344 efx_rc_t rc; 345 346 req.emr_cmd = MC_CMD_SET_LINK; 347 req.emr_in_buf = payload; 348 req.emr_in_length = MC_CMD_SET_LINK_IN_LEN; 349 req.emr_out_buf = payload; 350 req.emr_out_length = MC_CMD_SET_LINK_OUT_LEN; 351 352 MCDI_IN_POPULATE_DWORD_10(req, SET_LINK_IN_CAP, 353 PHY_CAP_10HDX, (cap_mask >> EFX_PHY_CAP_10HDX) & 0x1, 354 PHY_CAP_10FDX, (cap_mask >> EFX_PHY_CAP_10FDX) & 0x1, 355 PHY_CAP_100HDX, (cap_mask >> EFX_PHY_CAP_100HDX) & 0x1, 356 PHY_CAP_100FDX, (cap_mask >> EFX_PHY_CAP_100FDX) & 0x1, 357 PHY_CAP_1000HDX, (cap_mask >> EFX_PHY_CAP_1000HDX) & 0x1, 358 PHY_CAP_1000FDX, (cap_mask >> EFX_PHY_CAP_1000FDX) & 0x1, 359 PHY_CAP_10000FDX, (cap_mask >> EFX_PHY_CAP_10000FDX) & 0x1, 360 PHY_CAP_PAUSE, (cap_mask >> EFX_PHY_CAP_PAUSE) & 0x1, 361 PHY_CAP_ASYM, (cap_mask >> EFX_PHY_CAP_ASYM) & 0x1, 362 PHY_CAP_AN, (cap_mask >> EFX_PHY_CAP_AN) & 0x1); 363 /* Too many fields for for POPULATE macros, so insert this afterwards */ 364 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 365 PHY_CAP_25000FDX, (cap_mask >> EFX_PHY_CAP_25000FDX) & 0x1); 366 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 367 PHY_CAP_40000FDX, (cap_mask >> EFX_PHY_CAP_40000FDX) & 0x1); 368 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 369 PHY_CAP_50000FDX, (cap_mask >> EFX_PHY_CAP_50000FDX) & 0x1); 370 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 371 PHY_CAP_100000FDX, (cap_mask >> EFX_PHY_CAP_100000FDX) & 0x1); 372 373 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 374 PHY_CAP_BASER_FEC, (cap_mask >> EFX_PHY_CAP_BASER_FEC) & 0x1); 375 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 376 PHY_CAP_BASER_FEC_REQUESTED, 377 (cap_mask >> EFX_PHY_CAP_BASER_FEC_REQUESTED) & 0x1); 378 379 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 380 PHY_CAP_RS_FEC, (cap_mask >> EFX_PHY_CAP_RS_FEC) & 0x1); 381 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 382 PHY_CAP_RS_FEC_REQUESTED, 383 (cap_mask >> EFX_PHY_CAP_RS_FEC_REQUESTED) & 0x1); 384 385 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 386 PHY_CAP_25G_BASER_FEC, 387 (cap_mask >> EFX_PHY_CAP_25G_BASER_FEC) & 0x1); 388 MCDI_IN_SET_DWORD_FIELD(req, SET_LINK_IN_CAP, 389 PHY_CAP_25G_BASER_FEC_REQUESTED, 390 (cap_mask >> EFX_PHY_CAP_25G_BASER_FEC_REQUESTED) & 0x1); 391 392 MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_MODE, loopback_type); 393 394 switch (loopback_link_mode) { 395 case EFX_LINK_100FDX: 396 speed = 100; 397 break; 398 case EFX_LINK_1000FDX: 399 speed = 1000; 400 break; 401 case EFX_LINK_10000FDX: 402 speed = 10000; 403 break; 404 case EFX_LINK_25000FDX: 405 speed = 25000; 406 break; 407 case EFX_LINK_40000FDX: 408 speed = 40000; 409 break; 410 case EFX_LINK_50000FDX: 411 speed = 50000; 412 break; 413 case EFX_LINK_100000FDX: 414 speed = 100000; 415 break; 416 default: 417 speed = 0; 418 break; 419 } 420 MCDI_IN_SET_DWORD(req, SET_LINK_IN_LOOPBACK_SPEED, speed); 421 422 MCDI_IN_SET_DWORD(req, SET_LINK_IN_FLAGS, phy_flags); 423 424 efx_mcdi_execute(enp, &req); 425 426 if (req.emr_rc != 0) { 427 rc = req.emr_rc; 428 goto fail1; 429 } 430 431 return (0); 432 433 fail1: 434 EFSYS_PROBE1(fail1, efx_rc_t, rc); 435 436 return (rc); 437 } 438 439 static __checkReturn efx_rc_t 440 efx_mcdi_phy_set_led( 441 __in efx_nic_t *enp, 442 __in efx_phy_led_mode_t phy_led_mode) 443 { 444 efx_mcdi_req_t req; 445 EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SET_ID_LED_IN_LEN, 446 MC_CMD_SET_ID_LED_OUT_LEN); 447 unsigned int led_mode; 448 efx_rc_t rc; 449 450 req.emr_cmd = MC_CMD_SET_ID_LED; 451 req.emr_in_buf = payload; 452 req.emr_in_length = MC_CMD_SET_ID_LED_IN_LEN; 453 req.emr_out_buf = payload; 454 req.emr_out_length = MC_CMD_SET_ID_LED_OUT_LEN; 455 456 switch (phy_led_mode) { 457 case EFX_PHY_LED_DEFAULT: 458 led_mode = MC_CMD_LED_DEFAULT; 459 break; 460 case EFX_PHY_LED_OFF: 461 led_mode = MC_CMD_LED_OFF; 462 break; 463 case EFX_PHY_LED_ON: 464 led_mode = MC_CMD_LED_ON; 465 break; 466 default: 467 EFSYS_ASSERT(0); 468 led_mode = MC_CMD_LED_DEFAULT; 469 break; 470 } 471 472 MCDI_IN_SET_DWORD(req, SET_ID_LED_IN_STATE, led_mode); 473 474 efx_mcdi_execute(enp, &req); 475 476 if (req.emr_rc != 0) { 477 rc = req.emr_rc; 478 goto fail1; 479 } 480 481 return (0); 482 483 fail1: 484 EFSYS_PROBE1(fail1, efx_rc_t, rc); 485 486 return (rc); 487 } 488 489 __checkReturn efx_rc_t 490 ef10_phy_reconfigure( 491 __in efx_nic_t *enp) 492 { 493 efx_port_t *epp = &(enp->en_port); 494 efx_loopback_type_t loopback_type; 495 efx_link_mode_t loopback_link_mode; 496 uint32_t phy_flags; 497 efx_phy_led_mode_t phy_led_mode; 498 boolean_t supported; 499 efx_rc_t rc; 500 501 if ((rc = efx_mcdi_link_control_supported(enp, &supported)) != 0) 502 goto fail1; 503 if (supported == B_FALSE) 504 goto out; 505 506 #if EFSYS_OPT_LOOPBACK 507 loopback_type = epp->ep_loopback_type; 508 loopback_link_mode = epp->ep_loopback_link_mode; 509 #else 510 loopback_type = EFX_LOOPBACK_OFF; 511 loopback_link_mode = EFX_LINK_UNKNOWN; 512 #endif 513 #if EFSYS_OPT_PHY_FLAGS 514 phy_flags = epp->ep_phy_flags; 515 #else 516 phy_flags = 0; 517 #endif 518 519 rc = efx_mcdi_phy_set_link(enp, epp->ep_adv_cap_mask, 520 loopback_type, loopback_link_mode, phy_flags); 521 if (rc != 0) 522 goto fail2; 523 524 /* And set the blink mode */ 525 526 #if EFSYS_OPT_PHY_LED_CONTROL 527 phy_led_mode = epp->ep_phy_led_mode; 528 #else 529 phy_led_mode = EFX_PHY_LED_DEFAULT; 530 #endif 531 532 rc = efx_mcdi_phy_set_led(enp, phy_led_mode); 533 if (rc != 0) 534 goto fail3; 535 536 out: 537 return (0); 538 539 fail3: 540 EFSYS_PROBE(fail3); 541 fail2: 542 EFSYS_PROBE(fail2); 543 fail1: 544 EFSYS_PROBE1(fail1, efx_rc_t, rc); 545 546 return (rc); 547 } 548 549 __checkReturn efx_rc_t 550 ef10_phy_verify( 551 __in efx_nic_t *enp) 552 { 553 efx_mcdi_req_t req; 554 EFX_MCDI_DECLARE_BUF(payload, MC_CMD_GET_PHY_STATE_IN_LEN, 555 MC_CMD_GET_PHY_STATE_OUT_LEN); 556 uint32_t state; 557 efx_rc_t rc; 558 559 req.emr_cmd = MC_CMD_GET_PHY_STATE; 560 req.emr_in_buf = payload; 561 req.emr_in_length = MC_CMD_GET_PHY_STATE_IN_LEN; 562 req.emr_out_buf = payload; 563 req.emr_out_length = MC_CMD_GET_PHY_STATE_OUT_LEN; 564 565 efx_mcdi_execute(enp, &req); 566 567 if (req.emr_rc != 0) { 568 rc = req.emr_rc; 569 goto fail1; 570 } 571 572 if (req.emr_out_length_used < MC_CMD_GET_PHY_STATE_OUT_LEN) { 573 rc = EMSGSIZE; 574 goto fail2; 575 } 576 577 state = MCDI_OUT_DWORD(req, GET_PHY_STATE_OUT_STATE); 578 if (state != MC_CMD_PHY_STATE_OK) { 579 if (state != MC_CMD_PHY_STATE_ZOMBIE) 580 EFSYS_PROBE1(mc_pcol_error, int, state); 581 rc = ENOTACTIVE; 582 goto fail3; 583 } 584 585 return (0); 586 587 fail3: 588 EFSYS_PROBE(fail3); 589 fail2: 590 EFSYS_PROBE(fail2); 591 fail1: 592 EFSYS_PROBE1(fail1, efx_rc_t, rc); 593 594 return (rc); 595 } 596 597 __checkReturn efx_rc_t 598 ef10_phy_oui_get( 599 __in efx_nic_t *enp, 600 __out uint32_t *ouip) 601 { 602 _NOTE(ARGUNUSED(enp, ouip)) 603 604 return (ENOTSUP); 605 } 606 607 __checkReturn efx_rc_t 608 ef10_phy_link_state_get( 609 __in efx_nic_t *enp, 610 __out efx_phy_link_state_t *eplsp) 611 { 612 efx_rc_t rc; 613 ef10_link_state_t els; 614 615 /* Obtain the active link state */ 616 if ((rc = ef10_phy_get_link(enp, &els)) != 0) 617 goto fail1; 618 619 *eplsp = els.epls; 620 621 return (0); 622 623 fail1: 624 EFSYS_PROBE1(fail1, efx_rc_t, rc); 625 626 return (rc); 627 } 628 629 630 #if EFSYS_OPT_PHY_STATS 631 632 __checkReturn efx_rc_t 633 ef10_phy_stats_update( 634 __in efx_nic_t *enp, 635 __in efsys_mem_t *esmp, 636 __inout_ecount(EFX_PHY_NSTATS) uint32_t *stat) 637 { 638 /* TBD: no stats support in firmware yet */ 639 _NOTE(ARGUNUSED(enp, esmp)) 640 memset(stat, 0, EFX_PHY_NSTATS * sizeof (*stat)); 641 642 return (0); 643 } 644 645 #endif /* EFSYS_OPT_PHY_STATS */ 646 647 #if EFSYS_OPT_BIST 648 649 __checkReturn efx_rc_t 650 ef10_bist_enable_offline( 651 __in efx_nic_t *enp) 652 { 653 efx_rc_t rc; 654 655 if ((rc = efx_mcdi_bist_enable_offline(enp)) != 0) 656 goto fail1; 657 658 return (0); 659 660 fail1: 661 EFSYS_PROBE1(fail1, efx_rc_t, rc); 662 663 return (rc); 664 } 665 666 __checkReturn efx_rc_t 667 ef10_bist_start( 668 __in efx_nic_t *enp, 669 __in efx_bist_type_t type) 670 { 671 efx_rc_t rc; 672 673 if ((rc = efx_mcdi_bist_start(enp, type)) != 0) 674 goto fail1; 675 676 return (0); 677 678 fail1: 679 EFSYS_PROBE1(fail1, efx_rc_t, rc); 680 681 return (rc); 682 } 683 684 __checkReturn efx_rc_t 685 ef10_bist_poll( 686 __in efx_nic_t *enp, 687 __in efx_bist_type_t type, 688 __out efx_bist_result_t *resultp, 689 __out_opt __drv_when(count > 0, __notnull) 690 uint32_t *value_maskp, 691 __out_ecount_opt(count) __drv_when(count > 0, __notnull) 692 unsigned long *valuesp, 693 __in size_t count) 694 { 695 /* 696 * MCDI_CTL_SDU_LEN_MAX_V1 is large enough cover all BIST results, 697 * whilst not wasting stack. 698 */ 699 EFX_MCDI_DECLARE_BUF(payload, MC_CMD_POLL_BIST_IN_LEN, 700 MCDI_CTL_SDU_LEN_MAX_V1); 701 efx_nic_cfg_t *encp = &(enp->en_nic_cfg); 702 efx_mcdi_req_t req; 703 uint32_t value_mask = 0; 704 uint32_t result; 705 efx_rc_t rc; 706 707 EFX_STATIC_ASSERT(MC_CMD_POLL_BIST_OUT_LEN <= 708 MCDI_CTL_SDU_LEN_MAX_V1); 709 EFX_STATIC_ASSERT(MC_CMD_POLL_BIST_OUT_SFT9001_LEN <= 710 MCDI_CTL_SDU_LEN_MAX_V1); 711 EFX_STATIC_ASSERT(MC_CMD_POLL_BIST_OUT_MRSFP_LEN <= 712 MCDI_CTL_SDU_LEN_MAX_V1); 713 EFX_STATIC_ASSERT(MC_CMD_POLL_BIST_OUT_MEM_LEN <= 714 MCDI_CTL_SDU_LEN_MAX_V1); 715 716 _NOTE(ARGUNUSED(type)) 717 718 req.emr_cmd = MC_CMD_POLL_BIST; 719 req.emr_in_buf = payload; 720 req.emr_in_length = MC_CMD_POLL_BIST_IN_LEN; 721 req.emr_out_buf = payload; 722 req.emr_out_length = MCDI_CTL_SDU_LEN_MAX_V1; 723 724 efx_mcdi_execute(enp, &req); 725 726 if (req.emr_rc != 0) { 727 rc = req.emr_rc; 728 goto fail1; 729 } 730 731 if (req.emr_out_length_used < MC_CMD_POLL_BIST_OUT_RESULT_OFST + 4) { 732 rc = EMSGSIZE; 733 goto fail2; 734 } 735 736 if (count > 0) 737 (void) memset(valuesp, '\0', count * sizeof (unsigned long)); 738 739 result = MCDI_OUT_DWORD(req, POLL_BIST_OUT_RESULT); 740 741 if (result == MC_CMD_POLL_BIST_FAILED && 742 req.emr_out_length >= MC_CMD_POLL_BIST_OUT_MEM_LEN && 743 count > EFX_BIST_MEM_ECC_FATAL) { 744 if (valuesp != NULL) { 745 valuesp[EFX_BIST_MEM_TEST] = 746 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_TEST); 747 valuesp[EFX_BIST_MEM_ADDR] = 748 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ADDR); 749 valuesp[EFX_BIST_MEM_BUS] = 750 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_BUS); 751 valuesp[EFX_BIST_MEM_EXPECT] = 752 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_EXPECT); 753 valuesp[EFX_BIST_MEM_ACTUAL] = 754 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ACTUAL); 755 valuesp[EFX_BIST_MEM_ECC] = 756 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC); 757 valuesp[EFX_BIST_MEM_ECC_PARITY] = 758 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC_PARITY); 759 valuesp[EFX_BIST_MEM_ECC_FATAL] = 760 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MEM_ECC_FATAL); 761 } 762 value_mask |= (1 << EFX_BIST_MEM_TEST) | 763 (1 << EFX_BIST_MEM_ADDR) | 764 (1 << EFX_BIST_MEM_BUS) | 765 (1 << EFX_BIST_MEM_EXPECT) | 766 (1 << EFX_BIST_MEM_ACTUAL) | 767 (1 << EFX_BIST_MEM_ECC) | 768 (1 << EFX_BIST_MEM_ECC_PARITY) | 769 (1 << EFX_BIST_MEM_ECC_FATAL); 770 } else if (result == MC_CMD_POLL_BIST_FAILED && 771 encp->enc_phy_type == EFX_PHY_XFI_FARMI && 772 req.emr_out_length >= MC_CMD_POLL_BIST_OUT_MRSFP_LEN && 773 count > EFX_BIST_FAULT_CODE) { 774 if (valuesp != NULL) 775 valuesp[EFX_BIST_FAULT_CODE] = 776 MCDI_OUT_DWORD(req, POLL_BIST_OUT_MRSFP_TEST); 777 value_mask |= 1 << EFX_BIST_FAULT_CODE; 778 } 779 780 if (value_maskp != NULL) 781 *value_maskp = value_mask; 782 783 EFSYS_ASSERT(resultp != NULL); 784 if (result == MC_CMD_POLL_BIST_RUNNING) 785 *resultp = EFX_BIST_RESULT_RUNNING; 786 else if (result == MC_CMD_POLL_BIST_PASSED) 787 *resultp = EFX_BIST_RESULT_PASSED; 788 else 789 *resultp = EFX_BIST_RESULT_FAILED; 790 791 return (0); 792 793 fail2: 794 EFSYS_PROBE(fail2); 795 fail1: 796 EFSYS_PROBE1(fail1, efx_rc_t, rc); 797 798 return (rc); 799 } 800 801 void 802 ef10_bist_stop( 803 __in efx_nic_t *enp, 804 __in efx_bist_type_t type) 805 { 806 /* There is no way to stop BIST on EF10. */ 807 _NOTE(ARGUNUSED(enp, type)) 808 } 809 810 #endif /* EFSYS_OPT_BIST */ 811 812 #endif /* EFSYS_OPT_RIVERHEAD || EFX_OPTS_EF10() */ 813