drivers/net/sfc/base/efx_phy.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2007-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include "efx.h"
   8 #include "efx_impl.h"
   9
  10
  11 #if EFSYS_OPT_SIENA
  12 static const efx_phy_ops_t      __efx_phy_siena_ops = {
  13         siena_phy_power,                /* epo_power */
  14         NULL,                           /* epo_reset */
  15         siena_phy_reconfigure,          /* epo_reconfigure */
  16         siena_phy_verify,               /* epo_verify */
  17         siena_phy_oui_get,              /* epo_oui_get */
  18         NULL,                           /* epo_fec_type_get */
  19 #if EFSYS_OPT_PHY_STATS
  20         siena_phy_stats_update,         /* epo_stats_update */
  21 #endif  /* EFSYS_OPT_PHY_STATS */
  22 #if EFSYS_OPT_BIST
  23         NULL,                           /* epo_bist_enable_offline */
  24         siena_phy_bist_start,           /* epo_bist_start */
  25         siena_phy_bist_poll,            /* epo_bist_poll */
  26         siena_phy_bist_stop,            /* epo_bist_stop */
  27 #endif  /* EFSYS_OPT_BIST */
  28 };
  29 #endif  /* EFSYS_OPT_SIENA */
  30
  31 #if EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
  32 static const efx_phy_ops_t      __efx_phy_ef10_ops = {
  33         ef10_phy_power,                 /* epo_power */
  34         NULL,                           /* epo_reset */
  35         ef10_phy_reconfigure,           /* epo_reconfigure */
  36         ef10_phy_verify,                /* epo_verify */
  37         ef10_phy_oui_get,               /* epo_oui_get */
  38         ef10_phy_fec_type_get,          /* epo_fec_type_get */
  39 #if EFSYS_OPT_PHY_STATS
  40         ef10_phy_stats_update,          /* epo_stats_update */
  41 #endif  /* EFSYS_OPT_PHY_STATS */
  42 #if EFSYS_OPT_BIST
  43         ef10_bist_enable_offline,       /* epo_bist_enable_offline */
  44         ef10_bist_start,                /* epo_bist_start */
  45         ef10_bist_poll,                 /* epo_bist_poll */
  46         ef10_bist_stop,                 /* epo_bist_stop */
  47 #endif  /* EFSYS_OPT_BIST */
  48 };
  49 #endif  /* EFSYS_OPT_HUNTINGTON || EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */
  50
  51         __checkReturn   efx_rc_t
  52 efx_phy_probe(
  53         __in            efx_nic_t *enp)
  54 {
  55         efx_port_t *epp = &(enp->en_port);
  56         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
  57         const efx_phy_ops_t *epop;
  58         efx_rc_t rc;
  59
  60         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
  61
  62         epp->ep_port = encp->enc_port;
  63         epp->ep_phy_type = encp->enc_phy_type;
  64
  65         /* Hook in operations structure */
  66         switch (enp->en_family) {
  67 #if EFSYS_OPT_SIENA
  68         case EFX_FAMILY_SIENA:
  69                 epop = &__efx_phy_siena_ops;
  70                 break;
  71 #endif  /* EFSYS_OPT_SIENA */
  72
  73 #if EFSYS_OPT_HUNTINGTON
  74         case EFX_FAMILY_HUNTINGTON:
  75                 epop = &__efx_phy_ef10_ops;
  76                 break;
  77 #endif  /* EFSYS_OPT_HUNTINGTON */
  78
  79 #if EFSYS_OPT_MEDFORD
  80         case EFX_FAMILY_MEDFORD:
  81                 epop = &__efx_phy_ef10_ops;
  82                 break;
  83 #endif  /* EFSYS_OPT_MEDFORD */
  84
  85 #if EFSYS_OPT_MEDFORD2
  86         case EFX_FAMILY_MEDFORD2:
  87                 epop = &__efx_phy_ef10_ops;
  88                 break;
  89 #endif  /* EFSYS_OPT_MEDFORD2 */
  90
  91         default:
  92                 rc = ENOTSUP;
  93                 goto fail1;
  94         }
  95
  96         epp->ep_epop = epop;
  97
  98         return (0);
  99
 100 fail1:
 101         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 102
 103         epp->ep_port = 0;
 104         epp->ep_phy_type = 0;
 105
 106         return (rc);
 107 }
 108
 109         __checkReturn   efx_rc_t
 110 efx_phy_verify(
 111         __in            efx_nic_t *enp)
 112 {
 113         efx_port_t *epp = &(enp->en_port);
 114         const efx_phy_ops_t *epop = epp->ep_epop;
 115
 116         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 117         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 118
 119         return (epop->epo_verify(enp));
 120 }
 121
 122 #if EFSYS_OPT_PHY_LED_CONTROL
 123
 124         __checkReturn   efx_rc_t
 125 efx_phy_led_set(
 126         __in            efx_nic_t *enp,
 127         __in            efx_phy_led_mode_t mode)
 128 {
 129         efx_nic_cfg_t *encp = (&enp->en_nic_cfg);
 130         efx_port_t *epp = &(enp->en_port);
 131         const efx_phy_ops_t *epop = epp->ep_epop;
 132         uint32_t mask;
 133         efx_rc_t rc;
 134
 135         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 136         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 137
 138         if (epp->ep_phy_led_mode == mode)
 139                 goto done;
 140
 141         mask = (1 << EFX_PHY_LED_DEFAULT);
 142         mask |= encp->enc_led_mask;
 143
 144         if (!((1 << mode) & mask)) {
 145                 rc = ENOTSUP;
 146                 goto fail1;
 147         }
 148
 149         EFSYS_ASSERT3U(mode, <, EFX_PHY_LED_NMODES);
 150         epp->ep_phy_led_mode = mode;
 151
 152         if ((rc = epop->epo_reconfigure(enp)) != 0)
 153                 goto fail2;
 154
 155 done:
 156         return (0);
 157
 158 fail2:
 159         EFSYS_PROBE(fail2);
 160 fail1:
 161         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 162
 163         return (rc);
 164 }
 165 #endif  /* EFSYS_OPT_PHY_LED_CONTROL */
 166
 167                         void
 168 efx_phy_adv_cap_get(
 169         __in            efx_nic_t *enp,
 170         __in            uint32_t flag,
 171         __out           uint32_t *maskp)
 172 {
 173         efx_port_t *epp = &(enp->en_port);
 174
 175         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 176         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
 177
 178         switch (flag) {
 179         case EFX_PHY_CAP_CURRENT:
 180                 *maskp = epp->ep_adv_cap_mask;
 181                 break;
 182         case EFX_PHY_CAP_DEFAULT:
 183                 *maskp = epp->ep_default_adv_cap_mask;
 184                 break;
 185         case EFX_PHY_CAP_PERM:
 186                 *maskp = epp->ep_phy_cap_mask;
 187                 break;
 188         default:
 189                 EFSYS_ASSERT(B_FALSE);
 190                 *maskp = 0;
 191                 break;
 192         }
 193 }
 194
 195         __checkReturn   efx_rc_t
 196 efx_phy_adv_cap_set(
 197         __in            efx_nic_t *enp,
 198         __in            uint32_t mask)
 199 {
 200         efx_port_t *epp = &(enp->en_port);
 201         const efx_phy_ops_t *epop = epp->ep_epop;
 202         uint32_t old_mask;
 203         efx_rc_t rc;
 204
 205         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 206         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 207
 208         if ((mask & ~epp->ep_phy_cap_mask) != 0) {
 209                 rc = ENOTSUP;
 210                 goto fail1;
 211         }
 212
 213         if (epp->ep_adv_cap_mask == mask)
 214                 goto done;
 215
 216         old_mask = epp->ep_adv_cap_mask;
 217         epp->ep_adv_cap_mask = mask;
 218
 219         if ((rc = epop->epo_reconfigure(enp)) != 0)
 220                 goto fail2;
 221
 222 done:
 223         return (0);
 224
 225 fail2:
 226         EFSYS_PROBE(fail2);
 227
 228         epp->ep_adv_cap_mask = old_mask;
 229         /* Reconfigure for robustness */
 230         if (epop->epo_reconfigure(enp) != 0) {
 231                 /*
 232                  * We may have an inconsistent view of our advertised speed
 233                  * capabilities.
 234                  */
 235                 EFSYS_ASSERT(0);
 236         }
 237
 238 fail1:
 239         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 240
 241         return (rc);
 242 }
 243
 244         void
 245 efx_phy_lp_cap_get(
 246         __in            efx_nic_t *enp,
 247         __out           uint32_t *maskp)
 248 {
 249         efx_port_t *epp = &(enp->en_port);
 250
 251         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 252         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 253
 254         *maskp = epp->ep_lp_cap_mask;
 255 }
 256
 257         __checkReturn   efx_rc_t
 258 efx_phy_oui_get(
 259         __in            efx_nic_t *enp,
 260         __out           uint32_t *ouip)
 261 {
 262         efx_port_t *epp = &(enp->en_port);
 263         const efx_phy_ops_t *epop = epp->ep_epop;
 264
 265         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 266         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 267
 268         return (epop->epo_oui_get(enp, ouip));
 269 }
 270
 271                         void
 272 efx_phy_media_type_get(
 273         __in            efx_nic_t *enp,
 274         __out           efx_phy_media_type_t *typep)
 275 {
 276         efx_port_t *epp = &(enp->en_port);
 277
 278         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 279         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 280
 281         if (epp->ep_module_type != EFX_PHY_MEDIA_INVALID)
 282                 *typep = epp->ep_module_type;
 283         else
 284                 *typep = epp->ep_fixed_port_type;
 285 }
 286
 287         __checkReturn           efx_rc_t
 288 efx_phy_module_get_info(
 289         __in                    efx_nic_t *enp,
 290         __in                    uint8_t dev_addr,
 291         __in                    size_t offset,
 292         __in                    size_t len,
 293         __out_bcount(len)       uint8_t *data)
 294 {
 295         efx_rc_t rc;
 296
 297         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 298         EFSYS_ASSERT(data != NULL);
 299
 300         if ((offset > EFX_PHY_MEDIA_INFO_MAX_OFFSET) ||
 301             ((offset + len) > EFX_PHY_MEDIA_INFO_MAX_OFFSET)) {
 302                 rc = EINVAL;
 303                 goto fail1;
 304         }
 305
 306         if ((rc = efx_mcdi_phy_module_get_info(enp, dev_addr,
 307             offset, len, data)) != 0)
 308                 goto fail2;
 309
 310         return (0);
 311
 312 fail2:
 313         EFSYS_PROBE(fail2);
 314 fail1:
 315         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 316
 317         return (rc);
 318 }
 319
 320         __checkReturn           efx_rc_t
 321 efx_phy_fec_type_get(
 322         __in            efx_nic_t *enp,
 323         __out           efx_phy_fec_type_t *typep)
 324 {
 325         efx_port_t *epp = &(enp->en_port);
 326         const efx_phy_ops_t *epop = epp->ep_epop;
 327         efx_rc_t rc;
 328
 329         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 330
 331         if (epop->epo_fec_type_get == NULL) {
 332                 rc = ENOTSUP;
 333                 goto fail1;
 334         }
 335
 336         if ((rc = epop->epo_fec_type_get(enp, typep)) != 0)
 337                 goto fail2;
 338
 339         return (0);
 340
 341 fail2:
 342         EFSYS_PROBE(fail2);
 343 fail1:
 344         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 345
 346         return (rc);
 347 }
 348
 349 #if EFSYS_OPT_PHY_STATS
 350
 351 #if EFSYS_OPT_NAMES
 352
 353 /* START MKCONFIG GENERATED PhyStatNamesBlock af9ffa24da3bc100 */
 354 static const char * const __efx_phy_stat_name[] = {
 355         "oui",
 356         "pma_pmd_link_up",
 357         "pma_pmd_rx_fault",
 358         "pma_pmd_tx_fault",
 359         "pma_pmd_rev_a",
 360         "pma_pmd_rev_b",
 361         "pma_pmd_rev_c",
 362         "pma_pmd_rev_d",
 363         "pcs_link_up",
 364         "pcs_rx_fault",
 365         "pcs_tx_fault",
 366         "pcs_ber",
 367         "pcs_block_errors",
 368         "phy_xs_link_up",
 369         "phy_xs_rx_fault",
 370         "phy_xs_tx_fault",
 371         "phy_xs_align",
 372         "phy_xs_sync_a",
 373         "phy_xs_sync_b",
 374         "phy_xs_sync_c",
 375         "phy_xs_sync_d",
 376         "an_link_up",
 377         "an_master",
 378         "an_local_rx_ok",
 379         "an_remote_rx_ok",
 380         "cl22ext_link_up",
 381         "snr_a",
 382         "snr_b",
 383         "snr_c",
 384         "snr_d",
 385         "pma_pmd_signal_a",
 386         "pma_pmd_signal_b",
 387         "pma_pmd_signal_c",
 388         "pma_pmd_signal_d",
 389         "an_complete",
 390         "pma_pmd_rev_major",
 391         "pma_pmd_rev_minor",
 392         "pma_pmd_rev_micro",
 393         "pcs_fw_version_0",
 394         "pcs_fw_version_1",
 395         "pcs_fw_version_2",
 396         "pcs_fw_version_3",
 397         "pcs_fw_build_yy",
 398         "pcs_fw_build_mm",
 399         "pcs_fw_build_dd",
 400         "pcs_op_mode",
 401 };
 402
 403 /* END MKCONFIG GENERATED PhyStatNamesBlock */
 404
 405                                         const char *
 406 efx_phy_stat_name(
 407         __in                            efx_nic_t *enp,
 408         __in                            efx_phy_stat_t type)
 409 {
 410         _NOTE(ARGUNUSED(enp))
 411         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 412         EFSYS_ASSERT3U(type, <, EFX_PHY_NSTATS);
 413
 414         return (__efx_phy_stat_name[type]);
 415 }
 416
 417 #endif  /* EFSYS_OPT_NAMES */
 418
 419         __checkReturn                   efx_rc_t
 420 efx_phy_stats_update(
 421         __in                            efx_nic_t *enp,
 422         __in                            efsys_mem_t *esmp,
 423         __inout_ecount(EFX_PHY_NSTATS)  uint32_t *stat)
 424 {
 425         efx_port_t *epp = &(enp->en_port);
 426         const efx_phy_ops_t *epop = epp->ep_epop;
 427
 428         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 429         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PORT);
 430
 431         return (epop->epo_stats_update(enp, esmp, stat));
 432 }
 433
 434 #endif  /* EFSYS_OPT_PHY_STATS */
 435
 436
 437 #if EFSYS_OPT_BIST
 438
 439         __checkReturn           efx_rc_t
 440 efx_bist_enable_offline(
 441         __in                    efx_nic_t *enp)
 442 {
 443         efx_port_t *epp = &(enp->en_port);
 444         const efx_phy_ops_t *epop = epp->ep_epop;
 445         efx_rc_t rc;
 446
 447         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 448
 449         if (epop->epo_bist_enable_offline == NULL) {
 450                 rc = ENOTSUP;
 451                 goto fail1;
 452         }
 453
 454         if ((rc = epop->epo_bist_enable_offline(enp)) != 0)
 455                 goto fail2;
 456
 457         return (0);
 458
 459 fail2:
 460         EFSYS_PROBE(fail2);
 461 fail1:
 462         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 463
 464         return (rc);
 465
 466 }
 467
 468         __checkReturn           efx_rc_t
 469 efx_bist_start(
 470         __in                    efx_nic_t *enp,
 471         __in                    efx_bist_type_t type)
 472 {
 473         efx_port_t *epp = &(enp->en_port);
 474         const efx_phy_ops_t *epop = epp->ep_epop;
 475         efx_rc_t rc;
 476
 477         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 478
 479         EFSYS_ASSERT3U(type, !=, EFX_BIST_TYPE_UNKNOWN);
 480         EFSYS_ASSERT3U(type, <, EFX_BIST_TYPE_NTYPES);
 481         EFSYS_ASSERT3U(epp->ep_current_bist, ==, EFX_BIST_TYPE_UNKNOWN);
 482
 483         if (epop->epo_bist_start == NULL) {
 484                 rc = ENOTSUP;
 485                 goto fail1;
 486         }
 487
 488         if ((rc = epop->epo_bist_start(enp, type)) != 0)
 489                 goto fail2;
 490
 491         epp->ep_current_bist = type;
 492
 493         return (0);
 494
 495 fail2:
 496         EFSYS_PROBE(fail2);
 497 fail1:
 498         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 499
 500         return (rc);
 501 }
 502
 503         __checkReturn           efx_rc_t
 504 efx_bist_poll(
 505         __in                    efx_nic_t *enp,
 506         __in                    efx_bist_type_t type,
 507         __out                   efx_bist_result_t *resultp,
 508         __out_opt               uint32_t *value_maskp,
 509         __out_ecount_opt(count) unsigned long *valuesp,
 510         __in                    size_t count)
 511 {
 512         efx_port_t *epp = &(enp->en_port);
 513         const efx_phy_ops_t *epop = epp->ep_epop;
 514         efx_rc_t rc;
 515
 516         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 517
 518         EFSYS_ASSERT3U(type, !=, EFX_BIST_TYPE_UNKNOWN);
 519         EFSYS_ASSERT3U(type, <, EFX_BIST_TYPE_NTYPES);
 520         EFSYS_ASSERT3U(epp->ep_current_bist, ==, type);
 521
 522         EFSYS_ASSERT(epop->epo_bist_poll != NULL);
 523         if (epop->epo_bist_poll == NULL) {
 524                 rc = ENOTSUP;
 525                 goto fail1;
 526         }
 527
 528         if ((rc = epop->epo_bist_poll(enp, type, resultp, value_maskp,
 529             valuesp, count)) != 0)
 530                 goto fail2;
 531
 532         return (0);
 533
 534 fail2:
 535         EFSYS_PROBE(fail2);
 536 fail1:
 537         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 538
 539         return (rc);
 540 }
 541
 542                         void
 543 efx_bist_stop(
 544         __in            efx_nic_t *enp,
 545         __in            efx_bist_type_t type)
 546 {
 547         efx_port_t *epp = &(enp->en_port);
 548         const efx_phy_ops_t *epop = epp->ep_epop;
 549
 550         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 551
 552         EFSYS_ASSERT3U(type, !=, EFX_BIST_TYPE_UNKNOWN);
 553         EFSYS_ASSERT3U(type, <, EFX_BIST_TYPE_NTYPES);
 554         EFSYS_ASSERT3U(epp->ep_current_bist, ==, type);
 555
 556         EFSYS_ASSERT(epop->epo_bist_stop != NULL);
 557
 558         if (epop->epo_bist_stop != NULL)
 559                 epop->epo_bist_stop(enp, type);
 560
 561         epp->ep_current_bist = EFX_BIST_TYPE_UNKNOWN;
 562 }
 563
 564 #endif  /* EFSYS_OPT_BIST */
 565                         void
 566 efx_phy_unprobe(
 567         __in    efx_nic_t *enp)
 568 {
 569         efx_port_t *epp = &(enp->en_port);
 570
 571         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
 572
 573         epp->ep_epop = NULL;
 574
 575         epp->ep_adv_cap_mask = 0;
 576
 577         epp->ep_port = 0;
 578         epp->ep_phy_type = 0;
 579 }