1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved. 3 * Copyright(c) 2018 Synopsys, Inc. All rights reserved. 4 */ 5 6 #include "axgbe_ethdev.h" 7 #include "axgbe_common.h" 8 #include "axgbe_phy.h" 9 10 #define AXGBE_PHY_PORT_SPEED_100 BIT(0) 11 #define AXGBE_PHY_PORT_SPEED_1000 BIT(1) 12 #define AXGBE_PHY_PORT_SPEED_2500 BIT(2) 13 #define AXGBE_PHY_PORT_SPEED_10000 BIT(3) 14 15 #define AXGBE_MUTEX_RELEASE 0x80000000 16 17 #define AXGBE_SFP_DIRECT 7 18 19 /* I2C target addresses */ 20 #define AXGBE_SFP_SERIAL_ID_ADDRESS 0x50 21 #define AXGBE_SFP_DIAG_INFO_ADDRESS 0x51 22 #define AXGBE_SFP_PHY_ADDRESS 0x56 23 #define AXGBE_GPIO_ADDRESS_PCA9555 0x20 24 25 /* SFP sideband signal indicators */ 26 #define AXGBE_GPIO_NO_TX_FAULT BIT(0) 27 #define AXGBE_GPIO_NO_RATE_SELECT BIT(1) 28 #define AXGBE_GPIO_NO_MOD_ABSENT BIT(2) 29 #define AXGBE_GPIO_NO_RX_LOS BIT(3) 30 31 /* Rate-change complete wait/retry count */ 32 #define AXGBE_RATECHANGE_COUNT 500 33 34 /* CDR delay values for KR support (in usec) */ 35 #define AXGBE_CDR_DELAY_INIT 10000 36 #define AXGBE_CDR_DELAY_INC 10000 37 #define AXGBE_CDR_DELAY_MAX 100000 38 39 enum axgbe_port_mode { 40 AXGBE_PORT_MODE_RSVD = 0, 41 AXGBE_PORT_MODE_BACKPLANE, 42 AXGBE_PORT_MODE_BACKPLANE_2500, 43 AXGBE_PORT_MODE_1000BASE_T, 44 AXGBE_PORT_MODE_1000BASE_X, 45 AXGBE_PORT_MODE_NBASE_T, 46 AXGBE_PORT_MODE_10GBASE_T, 47 AXGBE_PORT_MODE_10GBASE_R, 48 AXGBE_PORT_MODE_SFP, 49 AXGBE_PORT_MODE_MAX, 50 }; 51 52 enum axgbe_conn_type { 53 AXGBE_CONN_TYPE_NONE = 0, 54 AXGBE_CONN_TYPE_SFP, 55 AXGBE_CONN_TYPE_MDIO, 56 AXGBE_CONN_TYPE_RSVD1, 57 AXGBE_CONN_TYPE_BACKPLANE, 58 AXGBE_CONN_TYPE_MAX, 59 }; 60 61 /* SFP/SFP+ related definitions */ 62 enum axgbe_sfp_comm { 63 AXGBE_SFP_COMM_DIRECT = 0, 64 AXGBE_SFP_COMM_PCA9545, 65 }; 66 67 enum axgbe_sfp_cable { 68 AXGBE_SFP_CABLE_UNKNOWN = 0, 69 AXGBE_SFP_CABLE_ACTIVE, 70 AXGBE_SFP_CABLE_PASSIVE, 71 }; 72 73 enum axgbe_sfp_base { 74 AXGBE_SFP_BASE_UNKNOWN = 0, 75 AXGBE_SFP_BASE_1000_T, 76 AXGBE_SFP_BASE_1000_SX, 77 AXGBE_SFP_BASE_1000_LX, 78 AXGBE_SFP_BASE_1000_CX, 79 AXGBE_SFP_BASE_10000_SR, 80 AXGBE_SFP_BASE_10000_LR, 81 AXGBE_SFP_BASE_10000_LRM, 82 AXGBE_SFP_BASE_10000_ER, 83 AXGBE_SFP_BASE_10000_CR, 84 }; 85 86 enum axgbe_sfp_speed { 87 AXGBE_SFP_SPEED_UNKNOWN = 0, 88 AXGBE_SFP_SPEED_100_1000, 89 AXGBE_SFP_SPEED_1000, 90 AXGBE_SFP_SPEED_10000, 91 }; 92 93 /* SFP Serial ID Base ID values relative to an offset of 0 */ 94 #define AXGBE_SFP_BASE_ID 0 95 #define AXGBE_SFP_ID_SFP 0x03 96 97 #define AXGBE_SFP_BASE_EXT_ID 1 98 #define AXGBE_SFP_EXT_ID_SFP 0x04 99 100 #define AXGBE_SFP_BASE_10GBE_CC 3 101 #define AXGBE_SFP_BASE_10GBE_CC_SR BIT(4) 102 #define AXGBE_SFP_BASE_10GBE_CC_LR BIT(5) 103 #define AXGBE_SFP_BASE_10GBE_CC_LRM BIT(6) 104 #define AXGBE_SFP_BASE_10GBE_CC_ER BIT(7) 105 106 #define AXGBE_SFP_BASE_1GBE_CC 6 107 #define AXGBE_SFP_BASE_1GBE_CC_SX BIT(0) 108 #define AXGBE_SFP_BASE_1GBE_CC_LX BIT(1) 109 #define AXGBE_SFP_BASE_1GBE_CC_CX BIT(2) 110 #define AXGBE_SFP_BASE_1GBE_CC_T BIT(3) 111 112 #define AXGBE_SFP_BASE_CABLE 8 113 #define AXGBE_SFP_BASE_CABLE_PASSIVE BIT(2) 114 #define AXGBE_SFP_BASE_CABLE_ACTIVE BIT(3) 115 116 #define AXGBE_SFP_BASE_BR 12 117 #define AXGBE_SFP_BASE_BR_1GBE_MIN 0x0a 118 #define AXGBE_SFP_BASE_BR_1GBE_MAX 0x0d 119 #define AXGBE_SFP_BASE_BR_10GBE_MIN 0x64 120 #define AXGBE_SFP_BASE_BR_10GBE_MAX 0x68 121 122 #define AXGBE_SFP_BASE_CU_CABLE_LEN 18 123 124 #define AXGBE_SFP_BASE_VENDOR_NAME 20 125 #define AXGBE_SFP_BASE_VENDOR_NAME_LEN 16 126 #define AXGBE_SFP_BASE_VENDOR_PN 40 127 #define AXGBE_SFP_BASE_VENDOR_PN_LEN 16 128 #define AXGBE_SFP_BASE_VENDOR_REV 56 129 #define AXGBE_SFP_BASE_VENDOR_REV_LEN 4 130 131 #define AXGBE_SFP_BASE_CC 63 132 133 /* SFP Serial ID Extended ID values relative to an offset of 64 */ 134 #define AXGBE_SFP_BASE_VENDOR_SN 4 135 #define AXGBE_SFP_BASE_VENDOR_SN_LEN 16 136 137 #define AXGBE_SFP_EXTD_DIAG 28 138 #define AXGBE_SFP_EXTD_DIAG_ADDR_CHANGE BIT(2) 139 140 #define AXGBE_SFP_EXTD_SFF_8472 30 141 142 #define AXGBE_SFP_EXTD_CC 31 143 144 struct axgbe_sfp_eeprom { 145 u8 base[64]; 146 u8 extd[32]; 147 u8 vendor[32]; 148 }; 149 150 #define AXGBE_BEL_FUSE_VENDOR "BEL-FUSE" 151 #define AXGBE_BEL_FUSE_PARTNO "1GBT-SFP06" 152 153 struct axgbe_sfp_ascii { 154 union { 155 char vendor[AXGBE_SFP_BASE_VENDOR_NAME_LEN + 1]; 156 char partno[AXGBE_SFP_BASE_VENDOR_PN_LEN + 1]; 157 char rev[AXGBE_SFP_BASE_VENDOR_REV_LEN + 1]; 158 char serno[AXGBE_SFP_BASE_VENDOR_SN_LEN + 1]; 159 } u; 160 }; 161 162 /* MDIO PHY reset types */ 163 enum axgbe_mdio_reset { 164 AXGBE_MDIO_RESET_NONE = 0, 165 AXGBE_MDIO_RESET_I2C_GPIO, 166 AXGBE_MDIO_RESET_INT_GPIO, 167 AXGBE_MDIO_RESET_MAX, 168 }; 169 170 /* Re-driver related definitions */ 171 enum axgbe_phy_redrv_if { 172 AXGBE_PHY_REDRV_IF_MDIO = 0, 173 AXGBE_PHY_REDRV_IF_I2C, 174 AXGBE_PHY_REDRV_IF_MAX, 175 }; 176 177 enum axgbe_phy_redrv_model { 178 AXGBE_PHY_REDRV_MODEL_4223 = 0, 179 AXGBE_PHY_REDRV_MODEL_4227, 180 AXGBE_PHY_REDRV_MODEL_MAX, 181 }; 182 183 enum axgbe_phy_redrv_mode { 184 AXGBE_PHY_REDRV_MODE_CX = 5, 185 AXGBE_PHY_REDRV_MODE_SR = 9, 186 }; 187 188 #define AXGBE_PHY_REDRV_MODE_REG 0x12b0 189 190 /* PHY related configuration information */ 191 struct axgbe_phy_data { 192 enum axgbe_port_mode port_mode; 193 194 unsigned int port_id; 195 196 unsigned int port_speeds; 197 198 enum axgbe_conn_type conn_type; 199 200 enum axgbe_mode cur_mode; 201 enum axgbe_mode start_mode; 202 203 unsigned int rrc_count; 204 205 unsigned int mdio_addr; 206 207 unsigned int comm_owned; 208 209 /* SFP Support */ 210 enum axgbe_sfp_comm sfp_comm; 211 unsigned int sfp_mux_address; 212 unsigned int sfp_mux_channel; 213 214 unsigned int sfp_gpio_address; 215 unsigned int sfp_gpio_mask; 216 unsigned int sfp_gpio_rx_los; 217 unsigned int sfp_gpio_tx_fault; 218 unsigned int sfp_gpio_mod_absent; 219 unsigned int sfp_gpio_rate_select; 220 221 unsigned int sfp_rx_los; 222 unsigned int sfp_tx_fault; 223 unsigned int sfp_mod_absent; 224 unsigned int sfp_diags; 225 unsigned int sfp_changed; 226 unsigned int sfp_phy_avail; 227 unsigned int sfp_cable_len; 228 enum axgbe_sfp_base sfp_base; 229 enum axgbe_sfp_cable sfp_cable; 230 enum axgbe_sfp_speed sfp_speed; 231 struct axgbe_sfp_eeprom sfp_eeprom; 232 233 /* External PHY support */ 234 enum axgbe_mdio_mode phydev_mode; 235 enum axgbe_mdio_reset mdio_reset; 236 unsigned int mdio_reset_addr; 237 unsigned int mdio_reset_gpio; 238 239 /* Re-driver support */ 240 unsigned int redrv; 241 unsigned int redrv_if; 242 unsigned int redrv_addr; 243 unsigned int redrv_lane; 244 unsigned int redrv_model; 245 246 /* KR AN support */ 247 unsigned int phy_cdr_notrack; 248 unsigned int phy_cdr_delay; 249 }; 250 251 static enum axgbe_an_mode axgbe_phy_an_mode(struct axgbe_port *pdata); 252 253 static int axgbe_phy_i2c_xfer(struct axgbe_port *pdata, 254 struct axgbe_i2c_op *i2c_op) 255 { 256 struct axgbe_phy_data *phy_data = pdata->phy_data; 257 258 /* Be sure we own the bus */ 259 if (!phy_data->comm_owned) 260 return -EIO; 261 262 return pdata->i2c_if.i2c_xfer(pdata, i2c_op); 263 } 264 265 static int axgbe_phy_redrv_write(struct axgbe_port *pdata, unsigned int reg, 266 unsigned int val) 267 { 268 struct axgbe_phy_data *phy_data = pdata->phy_data; 269 struct axgbe_i2c_op i2c_op; 270 uint16_t *redrv_val; 271 u8 redrv_data[5], csum; 272 unsigned int i, retry; 273 int ret; 274 275 /* High byte of register contains read/write indicator */ 276 redrv_data[0] = ((reg >> 8) & 0xff) << 1; 277 redrv_data[1] = reg & 0xff; 278 redrv_val = (uint16_t *)&redrv_data[2]; 279 *redrv_val = rte_cpu_to_be_16(val); 280 281 /* Calculate 1 byte checksum */ 282 csum = 0; 283 for (i = 0; i < 4; i++) { 284 csum += redrv_data[i]; 285 if (redrv_data[i] > csum) 286 csum++; 287 } 288 redrv_data[4] = ~csum; 289 290 retry = 1; 291 again1: 292 i2c_op.cmd = AXGBE_I2C_CMD_WRITE; 293 i2c_op.target = phy_data->redrv_addr; 294 i2c_op.len = sizeof(redrv_data); 295 i2c_op.buf = redrv_data; 296 ret = axgbe_phy_i2c_xfer(pdata, &i2c_op); 297 if (ret) { 298 if ((ret == -EAGAIN) && retry--) 299 goto again1; 300 301 return ret; 302 } 303 304 retry = 1; 305 again2: 306 i2c_op.cmd = AXGBE_I2C_CMD_READ; 307 i2c_op.target = phy_data->redrv_addr; 308 i2c_op.len = 1; 309 i2c_op.buf = redrv_data; 310 ret = axgbe_phy_i2c_xfer(pdata, &i2c_op); 311 if (ret) { 312 if ((ret == -EAGAIN) && retry--) 313 goto again2; 314 315 return ret; 316 } 317 318 if (redrv_data[0] != 0xff) { 319 PMD_DRV_LOG(ERR, "Redriver write checksum error\n"); 320 ret = -EIO; 321 } 322 323 return ret; 324 } 325 326 static int axgbe_phy_i2c_read(struct axgbe_port *pdata, unsigned int target, 327 void *reg, unsigned int reg_len, 328 void *val, unsigned int val_len) 329 { 330 struct axgbe_i2c_op i2c_op; 331 int retry, ret; 332 333 retry = 1; 334 again1: 335 /* Set the specified register to read */ 336 i2c_op.cmd = AXGBE_I2C_CMD_WRITE; 337 i2c_op.target = target; 338 i2c_op.len = reg_len; 339 i2c_op.buf = reg; 340 ret = axgbe_phy_i2c_xfer(pdata, &i2c_op); 341 if (ret) { 342 if ((ret == -EAGAIN) && retry--) 343 goto again1; 344 345 return ret; 346 } 347 348 retry = 1; 349 again2: 350 /* Read the specified register */ 351 i2c_op.cmd = AXGBE_I2C_CMD_READ; 352 i2c_op.target = target; 353 i2c_op.len = val_len; 354 i2c_op.buf = val; 355 ret = axgbe_phy_i2c_xfer(pdata, &i2c_op); 356 if ((ret == -EAGAIN) && retry--) 357 goto again2; 358 359 return ret; 360 } 361 362 static int axgbe_phy_sfp_put_mux(struct axgbe_port *pdata) 363 { 364 struct axgbe_phy_data *phy_data = pdata->phy_data; 365 struct axgbe_i2c_op i2c_op; 366 uint8_t mux_channel; 367 368 if (phy_data->sfp_comm == AXGBE_SFP_COMM_DIRECT) 369 return 0; 370 371 /* Select no mux channels */ 372 mux_channel = 0; 373 i2c_op.cmd = AXGBE_I2C_CMD_WRITE; 374 i2c_op.target = phy_data->sfp_mux_address; 375 i2c_op.len = sizeof(mux_channel); 376 i2c_op.buf = &mux_channel; 377 378 return axgbe_phy_i2c_xfer(pdata, &i2c_op); 379 } 380 381 static int axgbe_phy_sfp_get_mux(struct axgbe_port *pdata) 382 { 383 struct axgbe_phy_data *phy_data = pdata->phy_data; 384 struct axgbe_i2c_op i2c_op; 385 u8 mux_channel; 386 387 if (phy_data->sfp_comm == AXGBE_SFP_COMM_DIRECT) 388 return 0; 389 390 /* Select desired mux channel */ 391 mux_channel = 1 << phy_data->sfp_mux_channel; 392 i2c_op.cmd = AXGBE_I2C_CMD_WRITE; 393 i2c_op.target = phy_data->sfp_mux_address; 394 i2c_op.len = sizeof(mux_channel); 395 i2c_op.buf = &mux_channel; 396 397 return axgbe_phy_i2c_xfer(pdata, &i2c_op); 398 } 399 400 static void axgbe_phy_put_comm_ownership(struct axgbe_port *pdata) 401 { 402 struct axgbe_phy_data *phy_data = pdata->phy_data; 403 404 phy_data->comm_owned = 0; 405 406 pthread_mutex_unlock(&pdata->phy_mutex); 407 } 408 409 static int axgbe_phy_get_comm_ownership(struct axgbe_port *pdata) 410 { 411 struct axgbe_phy_data *phy_data = pdata->phy_data; 412 uint64_t timeout; 413 unsigned int mutex_id; 414 415 /* The I2C and MDIO/GPIO bus is multiplexed between multiple devices, 416 * the driver needs to take the software mutex and then the hardware 417 * mutexes before being able to use the busses. 418 */ 419 pthread_mutex_lock(&pdata->phy_mutex); 420 421 if (phy_data->comm_owned) 422 return 0; 423 424 /* Clear the mutexes */ 425 XP_IOWRITE(pdata, XP_I2C_MUTEX, AXGBE_MUTEX_RELEASE); 426 XP_IOWRITE(pdata, XP_MDIO_MUTEX, AXGBE_MUTEX_RELEASE); 427 428 /* Mutex formats are the same for I2C and MDIO/GPIO */ 429 mutex_id = 0; 430 XP_SET_BITS(mutex_id, XP_I2C_MUTEX, ID, phy_data->port_id); 431 XP_SET_BITS(mutex_id, XP_I2C_MUTEX, ACTIVE, 1); 432 433 timeout = rte_get_timer_cycles() + (rte_get_timer_hz() * 5); 434 while (time_before(rte_get_timer_cycles(), timeout)) { 435 /* Must be all zeroes in order to obtain the mutex */ 436 if (XP_IOREAD(pdata, XP_I2C_MUTEX) || 437 XP_IOREAD(pdata, XP_MDIO_MUTEX)) { 438 rte_delay_us(100); 439 continue; 440 } 441 442 /* Obtain the mutex */ 443 XP_IOWRITE(pdata, XP_I2C_MUTEX, mutex_id); 444 XP_IOWRITE(pdata, XP_MDIO_MUTEX, mutex_id); 445 446 phy_data->comm_owned = 1; 447 return 0; 448 } 449 450 pthread_mutex_unlock(&pdata->phy_mutex); 451 452 PMD_DRV_LOG(ERR, "unable to obtain hardware mutexes\n"); 453 454 return -ETIMEDOUT; 455 } 456 457 static void axgbe_phy_sfp_phy_settings(struct axgbe_port *pdata) 458 { 459 struct axgbe_phy_data *phy_data = pdata->phy_data; 460 461 if (phy_data->sfp_mod_absent) { 462 pdata->phy.speed = SPEED_UNKNOWN; 463 pdata->phy.duplex = DUPLEX_UNKNOWN; 464 pdata->phy.autoneg = AUTONEG_ENABLE; 465 pdata->phy.advertising = pdata->phy.supported; 466 } 467 468 pdata->phy.advertising &= ~ADVERTISED_Autoneg; 469 pdata->phy.advertising &= ~ADVERTISED_TP; 470 pdata->phy.advertising &= ~ADVERTISED_FIBRE; 471 pdata->phy.advertising &= ~ADVERTISED_100baseT_Full; 472 pdata->phy.advertising &= ~ADVERTISED_1000baseT_Full; 473 pdata->phy.advertising &= ~ADVERTISED_10000baseT_Full; 474 pdata->phy.advertising &= ~ADVERTISED_10000baseR_FEC; 475 476 switch (phy_data->sfp_base) { 477 case AXGBE_SFP_BASE_1000_T: 478 case AXGBE_SFP_BASE_1000_SX: 479 case AXGBE_SFP_BASE_1000_LX: 480 case AXGBE_SFP_BASE_1000_CX: 481 pdata->phy.speed = SPEED_UNKNOWN; 482 pdata->phy.duplex = DUPLEX_UNKNOWN; 483 pdata->phy.autoneg = AUTONEG_ENABLE; 484 pdata->phy.advertising |= ADVERTISED_Autoneg; 485 break; 486 case AXGBE_SFP_BASE_10000_SR: 487 case AXGBE_SFP_BASE_10000_LR: 488 case AXGBE_SFP_BASE_10000_LRM: 489 case AXGBE_SFP_BASE_10000_ER: 490 case AXGBE_SFP_BASE_10000_CR: 491 default: 492 pdata->phy.speed = SPEED_10000; 493 pdata->phy.duplex = DUPLEX_FULL; 494 pdata->phy.autoneg = AUTONEG_DISABLE; 495 break; 496 } 497 498 switch (phy_data->sfp_base) { 499 case AXGBE_SFP_BASE_1000_T: 500 case AXGBE_SFP_BASE_1000_CX: 501 case AXGBE_SFP_BASE_10000_CR: 502 pdata->phy.advertising |= ADVERTISED_TP; 503 break; 504 default: 505 pdata->phy.advertising |= ADVERTISED_FIBRE; 506 } 507 508 switch (phy_data->sfp_speed) { 509 case AXGBE_SFP_SPEED_100_1000: 510 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) 511 pdata->phy.advertising |= ADVERTISED_100baseT_Full; 512 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) 513 pdata->phy.advertising |= ADVERTISED_1000baseT_Full; 514 break; 515 case AXGBE_SFP_SPEED_1000: 516 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) 517 pdata->phy.advertising |= ADVERTISED_1000baseT_Full; 518 break; 519 case AXGBE_SFP_SPEED_10000: 520 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) 521 pdata->phy.advertising |= ADVERTISED_10000baseT_Full; 522 break; 523 default: 524 /* Choose the fastest supported speed */ 525 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) 526 pdata->phy.advertising |= ADVERTISED_10000baseT_Full; 527 else if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) 528 pdata->phy.advertising |= ADVERTISED_1000baseT_Full; 529 else if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) 530 pdata->phy.advertising |= ADVERTISED_100baseT_Full; 531 } 532 } 533 534 static bool axgbe_phy_sfp_bit_rate(struct axgbe_sfp_eeprom *sfp_eeprom, 535 enum axgbe_sfp_speed sfp_speed) 536 { 537 u8 *sfp_base, min, max; 538 539 sfp_base = sfp_eeprom->base; 540 541 switch (sfp_speed) { 542 case AXGBE_SFP_SPEED_1000: 543 min = AXGBE_SFP_BASE_BR_1GBE_MIN; 544 max = AXGBE_SFP_BASE_BR_1GBE_MAX; 545 break; 546 case AXGBE_SFP_SPEED_10000: 547 min = AXGBE_SFP_BASE_BR_10GBE_MIN; 548 max = AXGBE_SFP_BASE_BR_10GBE_MAX; 549 break; 550 default: 551 return false; 552 } 553 554 return ((sfp_base[AXGBE_SFP_BASE_BR] >= min) && 555 (sfp_base[AXGBE_SFP_BASE_BR] <= max)); 556 } 557 558 static void axgbe_phy_sfp_external_phy(struct axgbe_port *pdata) 559 { 560 struct axgbe_phy_data *phy_data = pdata->phy_data; 561 562 if (!phy_data->sfp_changed) 563 return; 564 565 phy_data->sfp_phy_avail = 0; 566 567 if (phy_data->sfp_base != AXGBE_SFP_BASE_1000_T) 568 return; 569 } 570 571 static bool axgbe_phy_belfuse_parse_quirks(struct axgbe_port *pdata) 572 { 573 struct axgbe_phy_data *phy_data = pdata->phy_data; 574 struct axgbe_sfp_eeprom *sfp_eeprom = &phy_data->sfp_eeprom; 575 576 if (memcmp(&sfp_eeprom->base[AXGBE_SFP_BASE_VENDOR_NAME], 577 AXGBE_BEL_FUSE_VENDOR, strlen(AXGBE_BEL_FUSE_VENDOR))) 578 return false; 579 580 if (!memcmp(&sfp_eeprom->base[AXGBE_SFP_BASE_VENDOR_PN], 581 AXGBE_BEL_FUSE_PARTNO, strlen(AXGBE_BEL_FUSE_PARTNO))) { 582 phy_data->sfp_base = AXGBE_SFP_BASE_1000_SX; 583 phy_data->sfp_cable = AXGBE_SFP_CABLE_ACTIVE; 584 phy_data->sfp_speed = AXGBE_SFP_SPEED_1000; 585 return true; 586 } 587 588 return false; 589 } 590 591 static bool axgbe_phy_sfp_parse_quirks(struct axgbe_port *pdata) 592 { 593 if (axgbe_phy_belfuse_parse_quirks(pdata)) 594 return true; 595 596 return false; 597 } 598 599 static void axgbe_phy_sfp_parse_eeprom(struct axgbe_port *pdata) 600 { 601 struct axgbe_phy_data *phy_data = pdata->phy_data; 602 struct axgbe_sfp_eeprom *sfp_eeprom = &phy_data->sfp_eeprom; 603 uint8_t *sfp_base; 604 605 sfp_base = sfp_eeprom->base; 606 607 if (sfp_base[AXGBE_SFP_BASE_ID] != AXGBE_SFP_ID_SFP) 608 return; 609 610 if (sfp_base[AXGBE_SFP_BASE_EXT_ID] != AXGBE_SFP_EXT_ID_SFP) 611 return; 612 613 axgbe_phy_sfp_parse_quirks(pdata); 614 615 /* Assume ACTIVE cable unless told it is PASSIVE */ 616 if (sfp_base[AXGBE_SFP_BASE_CABLE] & AXGBE_SFP_BASE_CABLE_PASSIVE) { 617 phy_data->sfp_cable = AXGBE_SFP_CABLE_PASSIVE; 618 phy_data->sfp_cable_len = sfp_base[AXGBE_SFP_BASE_CU_CABLE_LEN]; 619 } else { 620 phy_data->sfp_cable = AXGBE_SFP_CABLE_ACTIVE; 621 } 622 623 /* Determine the type of SFP */ 624 if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & AXGBE_SFP_BASE_10GBE_CC_SR) 625 phy_data->sfp_base = AXGBE_SFP_BASE_10000_SR; 626 else if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & AXGBE_SFP_BASE_10GBE_CC_LR) 627 phy_data->sfp_base = AXGBE_SFP_BASE_10000_LR; 628 else if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & 629 AXGBE_SFP_BASE_10GBE_CC_LRM) 630 phy_data->sfp_base = AXGBE_SFP_BASE_10000_LRM; 631 else if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & AXGBE_SFP_BASE_10GBE_CC_ER) 632 phy_data->sfp_base = AXGBE_SFP_BASE_10000_ER; 633 else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_SX) 634 phy_data->sfp_base = AXGBE_SFP_BASE_1000_SX; 635 else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_LX) 636 phy_data->sfp_base = AXGBE_SFP_BASE_1000_LX; 637 else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_CX) 638 phy_data->sfp_base = AXGBE_SFP_BASE_1000_CX; 639 else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_T) 640 phy_data->sfp_base = AXGBE_SFP_BASE_1000_T; 641 else if ((phy_data->sfp_cable == AXGBE_SFP_CABLE_PASSIVE) && 642 axgbe_phy_sfp_bit_rate(sfp_eeprom, AXGBE_SFP_SPEED_10000)) 643 phy_data->sfp_base = AXGBE_SFP_BASE_10000_CR; 644 645 switch (phy_data->sfp_base) { 646 case AXGBE_SFP_BASE_1000_T: 647 phy_data->sfp_speed = AXGBE_SFP_SPEED_100_1000; 648 break; 649 case AXGBE_SFP_BASE_1000_SX: 650 case AXGBE_SFP_BASE_1000_LX: 651 case AXGBE_SFP_BASE_1000_CX: 652 phy_data->sfp_speed = AXGBE_SFP_SPEED_1000; 653 break; 654 case AXGBE_SFP_BASE_10000_SR: 655 case AXGBE_SFP_BASE_10000_LR: 656 case AXGBE_SFP_BASE_10000_LRM: 657 case AXGBE_SFP_BASE_10000_ER: 658 case AXGBE_SFP_BASE_10000_CR: 659 phy_data->sfp_speed = AXGBE_SFP_SPEED_10000; 660 break; 661 default: 662 break; 663 } 664 } 665 666 static bool axgbe_phy_sfp_verify_eeprom(uint8_t cc_in, uint8_t *buf, 667 unsigned int len) 668 { 669 uint8_t cc; 670 671 for (cc = 0; len; buf++, len--) 672 cc += *buf; 673 674 return (cc == cc_in) ? true : false; 675 } 676 677 static int axgbe_phy_sfp_read_eeprom(struct axgbe_port *pdata) 678 { 679 struct axgbe_phy_data *phy_data = pdata->phy_data; 680 struct axgbe_sfp_eeprom sfp_eeprom; 681 uint8_t eeprom_addr; 682 int ret; 683 684 ret = axgbe_phy_sfp_get_mux(pdata); 685 if (ret) { 686 PMD_DRV_LOG(ERR, "I2C error setting SFP MUX\n"); 687 return ret; 688 } 689 690 /* Read the SFP serial ID eeprom */ 691 eeprom_addr = 0; 692 ret = axgbe_phy_i2c_read(pdata, AXGBE_SFP_SERIAL_ID_ADDRESS, 693 &eeprom_addr, sizeof(eeprom_addr), 694 &sfp_eeprom, sizeof(sfp_eeprom)); 695 if (ret) { 696 PMD_DRV_LOG(ERR, "I2C error reading SFP EEPROM\n"); 697 goto put; 698 } 699 700 /* Validate the contents read */ 701 if (!axgbe_phy_sfp_verify_eeprom(sfp_eeprom.base[AXGBE_SFP_BASE_CC], 702 sfp_eeprom.base, 703 sizeof(sfp_eeprom.base) - 1)) { 704 ret = -EINVAL; 705 goto put; 706 } 707 708 if (!axgbe_phy_sfp_verify_eeprom(sfp_eeprom.extd[AXGBE_SFP_EXTD_CC], 709 sfp_eeprom.extd, 710 sizeof(sfp_eeprom.extd) - 1)) { 711 ret = -EINVAL; 712 goto put; 713 } 714 715 /* Check for an added or changed SFP */ 716 if (memcmp(&phy_data->sfp_eeprom, &sfp_eeprom, sizeof(sfp_eeprom))) { 717 phy_data->sfp_changed = 1; 718 memcpy(&phy_data->sfp_eeprom, &sfp_eeprom, sizeof(sfp_eeprom)); 719 720 if (sfp_eeprom.extd[AXGBE_SFP_EXTD_SFF_8472]) { 721 uint8_t diag_type; 722 diag_type = sfp_eeprom.extd[AXGBE_SFP_EXTD_DIAG]; 723 724 if (!(diag_type & AXGBE_SFP_EXTD_DIAG_ADDR_CHANGE)) 725 phy_data->sfp_diags = 1; 726 } 727 } else { 728 phy_data->sfp_changed = 0; 729 } 730 731 put: 732 axgbe_phy_sfp_put_mux(pdata); 733 734 return ret; 735 } 736 737 static void axgbe_phy_sfp_signals(struct axgbe_port *pdata) 738 { 739 struct axgbe_phy_data *phy_data = pdata->phy_data; 740 unsigned int gpio_input; 741 u8 gpio_reg, gpio_ports[2]; 742 int ret; 743 744 /* Read the input port registers */ 745 gpio_reg = 0; 746 ret = axgbe_phy_i2c_read(pdata, phy_data->sfp_gpio_address, 747 &gpio_reg, sizeof(gpio_reg), 748 gpio_ports, sizeof(gpio_ports)); 749 if (ret) { 750 PMD_DRV_LOG(ERR, "I2C error reading SFP GPIOs\n"); 751 return; 752 } 753 754 gpio_input = (gpio_ports[1] << 8) | gpio_ports[0]; 755 756 if (phy_data->sfp_gpio_mask & AXGBE_GPIO_NO_MOD_ABSENT) { 757 /* No GPIO, just assume the module is present for now */ 758 phy_data->sfp_mod_absent = 0; 759 } else { 760 if (!(gpio_input & (1 << phy_data->sfp_gpio_mod_absent))) 761 phy_data->sfp_mod_absent = 0; 762 } 763 764 if (!(phy_data->sfp_gpio_mask & AXGBE_GPIO_NO_RX_LOS) && 765 (gpio_input & (1 << phy_data->sfp_gpio_rx_los))) 766 phy_data->sfp_rx_los = 1; 767 768 if (!(phy_data->sfp_gpio_mask & AXGBE_GPIO_NO_TX_FAULT) && 769 (gpio_input & (1 << phy_data->sfp_gpio_tx_fault))) 770 phy_data->sfp_tx_fault = 1; 771 } 772 773 static void axgbe_phy_sfp_mod_absent(struct axgbe_port *pdata) 774 { 775 struct axgbe_phy_data *phy_data = pdata->phy_data; 776 777 phy_data->sfp_mod_absent = 1; 778 phy_data->sfp_phy_avail = 0; 779 memset(&phy_data->sfp_eeprom, 0, sizeof(phy_data->sfp_eeprom)); 780 } 781 782 static void axgbe_phy_sfp_reset(struct axgbe_phy_data *phy_data) 783 { 784 phy_data->sfp_rx_los = 0; 785 phy_data->sfp_tx_fault = 0; 786 phy_data->sfp_mod_absent = 1; 787 phy_data->sfp_diags = 0; 788 phy_data->sfp_base = AXGBE_SFP_BASE_UNKNOWN; 789 phy_data->sfp_cable = AXGBE_SFP_CABLE_UNKNOWN; 790 phy_data->sfp_speed = AXGBE_SFP_SPEED_UNKNOWN; 791 } 792 793 static const char *axgbe_base_as_string(enum axgbe_sfp_base sfp_base) 794 { 795 switch (sfp_base) { 796 case AXGBE_SFP_BASE_1000_T: 797 return "1G_T"; 798 case AXGBE_SFP_BASE_1000_SX: 799 return "1G_SX"; 800 case AXGBE_SFP_BASE_1000_LX: 801 return "1G_LX"; 802 case AXGBE_SFP_BASE_1000_CX: 803 return "1G_CX"; 804 case AXGBE_SFP_BASE_10000_SR: 805 return "10G_SR"; 806 case AXGBE_SFP_BASE_10000_LR: 807 return "10G_LR"; 808 case AXGBE_SFP_BASE_10000_LRM: 809 return "10G_LRM"; 810 case AXGBE_SFP_BASE_10000_ER: 811 return "10G_ER"; 812 case AXGBE_SFP_BASE_10000_CR: 813 return "10G_CR"; 814 default: 815 return "Unknown"; 816 } 817 } 818 819 static void axgbe_phy_sfp_detect(struct axgbe_port *pdata) 820 { 821 struct axgbe_phy_data *phy_data = pdata->phy_data; 822 int ret; 823 824 /* Reset the SFP signals and info */ 825 axgbe_phy_sfp_reset(phy_data); 826 827 ret = axgbe_phy_get_comm_ownership(pdata); 828 if (ret) 829 return; 830 831 /* Read the SFP signals and check for module presence */ 832 axgbe_phy_sfp_signals(pdata); 833 if (phy_data->sfp_mod_absent) { 834 axgbe_phy_sfp_mod_absent(pdata); 835 goto put; 836 } 837 838 ret = axgbe_phy_sfp_read_eeprom(pdata); 839 if (ret) { 840 /* Treat any error as if there isn't an SFP plugged in */ 841 axgbe_phy_sfp_reset(phy_data); 842 axgbe_phy_sfp_mod_absent(pdata); 843 goto put; 844 } 845 846 axgbe_phy_sfp_parse_eeprom(pdata); 847 axgbe_phy_sfp_external_phy(pdata); 848 849 PMD_DRV_LOG(DEBUG, "SFP Base: %s\n", 850 axgbe_base_as_string(phy_data->sfp_base)); 851 852 put: 853 axgbe_phy_sfp_phy_settings(pdata); 854 axgbe_phy_put_comm_ownership(pdata); 855 } 856 857 static void axgbe_phy_phydev_flowctrl(struct axgbe_port *pdata) 858 { 859 pdata->phy.tx_pause = 0; 860 pdata->phy.rx_pause = 0; 861 } 862 863 static enum axgbe_mode axgbe_phy_an73_redrv_outcome(struct axgbe_port *pdata) 864 { 865 struct axgbe_phy_data *phy_data = pdata->phy_data; 866 enum axgbe_mode mode; 867 unsigned int ad_reg, lp_reg; 868 869 pdata->phy.lp_advertising |= ADVERTISED_Autoneg; 870 pdata->phy.lp_advertising |= ADVERTISED_Backplane; 871 872 /* Use external PHY to determine flow control */ 873 if (pdata->phy.pause_autoneg) 874 axgbe_phy_phydev_flowctrl(pdata); 875 876 /* Compare Advertisement and Link Partner register 2 */ 877 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1); 878 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1); 879 if (lp_reg & 0x80) 880 pdata->phy.lp_advertising |= ADVERTISED_10000baseKR_Full; 881 if (lp_reg & 0x20) 882 pdata->phy.lp_advertising |= ADVERTISED_1000baseKX_Full; 883 884 ad_reg &= lp_reg; 885 if (ad_reg & 0x80) { 886 switch (phy_data->port_mode) { 887 case AXGBE_PORT_MODE_BACKPLANE: 888 mode = AXGBE_MODE_KR; 889 break; 890 default: 891 mode = AXGBE_MODE_SFI; 892 break; 893 } 894 } else if (ad_reg & 0x20) { 895 switch (phy_data->port_mode) { 896 case AXGBE_PORT_MODE_BACKPLANE: 897 mode = AXGBE_MODE_KX_1000; 898 break; 899 case AXGBE_PORT_MODE_1000BASE_X: 900 mode = AXGBE_MODE_X; 901 break; 902 case AXGBE_PORT_MODE_SFP: 903 switch (phy_data->sfp_base) { 904 case AXGBE_SFP_BASE_1000_T: 905 mode = AXGBE_MODE_SGMII_1000; 906 break; 907 case AXGBE_SFP_BASE_1000_SX: 908 case AXGBE_SFP_BASE_1000_LX: 909 case AXGBE_SFP_BASE_1000_CX: 910 default: 911 mode = AXGBE_MODE_X; 912 break; 913 } 914 break; 915 default: 916 mode = AXGBE_MODE_SGMII_1000; 917 break; 918 } 919 } else { 920 mode = AXGBE_MODE_UNKNOWN; 921 } 922 923 /* Compare Advertisement and Link Partner register 3 */ 924 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2); 925 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2); 926 if (lp_reg & 0xc000) 927 pdata->phy.lp_advertising |= ADVERTISED_10000baseR_FEC; 928 929 return mode; 930 } 931 932 static enum axgbe_mode axgbe_phy_an73_outcome(struct axgbe_port *pdata) 933 { 934 enum axgbe_mode mode; 935 unsigned int ad_reg, lp_reg; 936 937 pdata->phy.lp_advertising |= ADVERTISED_Autoneg; 938 pdata->phy.lp_advertising |= ADVERTISED_Backplane; 939 940 /* Compare Advertisement and Link Partner register 1 */ 941 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE); 942 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA); 943 if (lp_reg & 0x400) 944 pdata->phy.lp_advertising |= ADVERTISED_Pause; 945 if (lp_reg & 0x800) 946 pdata->phy.lp_advertising |= ADVERTISED_Asym_Pause; 947 948 if (pdata->phy.pause_autoneg) { 949 /* Set flow control based on auto-negotiation result */ 950 pdata->phy.tx_pause = 0; 951 pdata->phy.rx_pause = 0; 952 953 if (ad_reg & lp_reg & 0x400) { 954 pdata->phy.tx_pause = 1; 955 pdata->phy.rx_pause = 1; 956 } else if (ad_reg & lp_reg & 0x800) { 957 if (ad_reg & 0x400) 958 pdata->phy.rx_pause = 1; 959 else if (lp_reg & 0x400) 960 pdata->phy.tx_pause = 1; 961 } 962 } 963 964 /* Compare Advertisement and Link Partner register 2 */ 965 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1); 966 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1); 967 if (lp_reg & 0x80) 968 pdata->phy.lp_advertising |= ADVERTISED_10000baseKR_Full; 969 if (lp_reg & 0x20) 970 pdata->phy.lp_advertising |= ADVERTISED_1000baseKX_Full; 971 972 ad_reg &= lp_reg; 973 if (ad_reg & 0x80) 974 mode = AXGBE_MODE_KR; 975 else if (ad_reg & 0x20) 976 mode = AXGBE_MODE_KX_1000; 977 else 978 mode = AXGBE_MODE_UNKNOWN; 979 980 /* Compare Advertisement and Link Partner register 3 */ 981 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2); 982 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2); 983 if (lp_reg & 0xc000) 984 pdata->phy.lp_advertising |= ADVERTISED_10000baseR_FEC; 985 986 return mode; 987 } 988 989 static enum axgbe_mode axgbe_phy_an37_sgmii_outcome(struct axgbe_port *pdata) 990 { 991 enum axgbe_mode mode; 992 993 pdata->phy.lp_advertising |= ADVERTISED_Autoneg; 994 pdata->phy.lp_advertising |= ADVERTISED_1000baseT_Full; 995 996 if (pdata->phy.pause_autoneg) 997 axgbe_phy_phydev_flowctrl(pdata); 998 999 switch (pdata->an_status & AXGBE_SGMII_AN_LINK_SPEED) { 1000 case AXGBE_SGMII_AN_LINK_SPEED_100: 1001 if (pdata->an_status & AXGBE_SGMII_AN_LINK_DUPLEX) { 1002 pdata->phy.lp_advertising |= ADVERTISED_100baseT_Full; 1003 mode = AXGBE_MODE_SGMII_100; 1004 } else { 1005 mode = AXGBE_MODE_UNKNOWN; 1006 } 1007 break; 1008 case AXGBE_SGMII_AN_LINK_SPEED_1000: 1009 if (pdata->an_status & AXGBE_SGMII_AN_LINK_DUPLEX) { 1010 pdata->phy.lp_advertising |= ADVERTISED_1000baseT_Full; 1011 mode = AXGBE_MODE_SGMII_1000; 1012 } else { 1013 /* Half-duplex not supported */ 1014 mode = AXGBE_MODE_UNKNOWN; 1015 } 1016 break; 1017 default: 1018 mode = AXGBE_MODE_UNKNOWN; 1019 break; 1020 } 1021 return mode; 1022 } 1023 1024 static enum axgbe_mode axgbe_phy_an_outcome(struct axgbe_port *pdata) 1025 { 1026 switch (pdata->an_mode) { 1027 case AXGBE_AN_MODE_CL73: 1028 return axgbe_phy_an73_outcome(pdata); 1029 case AXGBE_AN_MODE_CL73_REDRV: 1030 return axgbe_phy_an73_redrv_outcome(pdata); 1031 case AXGBE_AN_MODE_CL37: 1032 case AXGBE_AN_MODE_CL37_SGMII: 1033 return axgbe_phy_an37_sgmii_outcome(pdata); 1034 default: 1035 return AXGBE_MODE_UNKNOWN; 1036 } 1037 } 1038 1039 static unsigned int axgbe_phy_an_advertising(struct axgbe_port *pdata) 1040 { 1041 struct axgbe_phy_data *phy_data = pdata->phy_data; 1042 unsigned int advertising; 1043 1044 /* Without a re-driver, just return current advertising */ 1045 if (!phy_data->redrv) 1046 return pdata->phy.advertising; 1047 1048 /* With the KR re-driver we need to advertise a single speed */ 1049 advertising = pdata->phy.advertising; 1050 advertising &= ~ADVERTISED_1000baseKX_Full; 1051 advertising &= ~ADVERTISED_10000baseKR_Full; 1052 1053 switch (phy_data->port_mode) { 1054 case AXGBE_PORT_MODE_BACKPLANE: 1055 advertising |= ADVERTISED_10000baseKR_Full; 1056 break; 1057 case AXGBE_PORT_MODE_BACKPLANE_2500: 1058 advertising |= ADVERTISED_1000baseKX_Full; 1059 break; 1060 case AXGBE_PORT_MODE_1000BASE_T: 1061 case AXGBE_PORT_MODE_1000BASE_X: 1062 case AXGBE_PORT_MODE_NBASE_T: 1063 advertising |= ADVERTISED_1000baseKX_Full; 1064 break; 1065 case AXGBE_PORT_MODE_10GBASE_T: 1066 PMD_DRV_LOG(ERR, "10GBASE_T mode is not supported\n"); 1067 break; 1068 case AXGBE_PORT_MODE_10GBASE_R: 1069 advertising |= ADVERTISED_10000baseKR_Full; 1070 break; 1071 case AXGBE_PORT_MODE_SFP: 1072 switch (phy_data->sfp_base) { 1073 case AXGBE_SFP_BASE_1000_T: 1074 case AXGBE_SFP_BASE_1000_SX: 1075 case AXGBE_SFP_BASE_1000_LX: 1076 case AXGBE_SFP_BASE_1000_CX: 1077 advertising |= ADVERTISED_1000baseKX_Full; 1078 break; 1079 default: 1080 advertising |= ADVERTISED_10000baseKR_Full; 1081 break; 1082 } 1083 break; 1084 default: 1085 advertising |= ADVERTISED_10000baseKR_Full; 1086 break; 1087 } 1088 1089 return advertising; 1090 } 1091 1092 static int axgbe_phy_an_config(struct axgbe_port *pdata __rte_unused) 1093 { 1094 return 0; 1095 /* Dummy API since there is no case to support 1096 * external phy devices registered through kernel APIs 1097 */ 1098 } 1099 1100 static enum axgbe_an_mode axgbe_phy_an_sfp_mode(struct axgbe_phy_data *phy_data) 1101 { 1102 switch (phy_data->sfp_base) { 1103 case AXGBE_SFP_BASE_1000_T: 1104 return AXGBE_AN_MODE_CL37_SGMII; 1105 case AXGBE_SFP_BASE_1000_SX: 1106 case AXGBE_SFP_BASE_1000_LX: 1107 case AXGBE_SFP_BASE_1000_CX: 1108 return AXGBE_AN_MODE_CL37; 1109 default: 1110 return AXGBE_AN_MODE_NONE; 1111 } 1112 } 1113 1114 static enum axgbe_an_mode axgbe_phy_an_mode(struct axgbe_port *pdata) 1115 { 1116 struct axgbe_phy_data *phy_data = pdata->phy_data; 1117 1118 /* A KR re-driver will always require CL73 AN */ 1119 if (phy_data->redrv) 1120 return AXGBE_AN_MODE_CL73_REDRV; 1121 1122 switch (phy_data->port_mode) { 1123 case AXGBE_PORT_MODE_BACKPLANE: 1124 return AXGBE_AN_MODE_CL73; 1125 case AXGBE_PORT_MODE_BACKPLANE_2500: 1126 return AXGBE_AN_MODE_NONE; 1127 case AXGBE_PORT_MODE_1000BASE_T: 1128 return AXGBE_AN_MODE_CL37_SGMII; 1129 case AXGBE_PORT_MODE_1000BASE_X: 1130 return AXGBE_AN_MODE_CL37; 1131 case AXGBE_PORT_MODE_NBASE_T: 1132 return AXGBE_AN_MODE_CL37_SGMII; 1133 case AXGBE_PORT_MODE_10GBASE_T: 1134 return AXGBE_AN_MODE_CL73; 1135 case AXGBE_PORT_MODE_10GBASE_R: 1136 return AXGBE_AN_MODE_NONE; 1137 case AXGBE_PORT_MODE_SFP: 1138 return axgbe_phy_an_sfp_mode(phy_data); 1139 default: 1140 return AXGBE_AN_MODE_NONE; 1141 } 1142 } 1143 1144 static int axgbe_phy_set_redrv_mode_mdio(struct axgbe_port *pdata, 1145 enum axgbe_phy_redrv_mode mode) 1146 { 1147 struct axgbe_phy_data *phy_data = pdata->phy_data; 1148 u16 redrv_reg, redrv_val; 1149 1150 redrv_reg = AXGBE_PHY_REDRV_MODE_REG + (phy_data->redrv_lane * 0x1000); 1151 redrv_val = (u16)mode; 1152 1153 return pdata->hw_if.write_ext_mii_regs(pdata, phy_data->redrv_addr, 1154 redrv_reg, redrv_val); 1155 } 1156 1157 static int axgbe_phy_set_redrv_mode_i2c(struct axgbe_port *pdata, 1158 enum axgbe_phy_redrv_mode mode) 1159 { 1160 struct axgbe_phy_data *phy_data = pdata->phy_data; 1161 unsigned int redrv_reg; 1162 int ret; 1163 1164 /* Calculate the register to write */ 1165 redrv_reg = AXGBE_PHY_REDRV_MODE_REG + (phy_data->redrv_lane * 0x1000); 1166 1167 ret = axgbe_phy_redrv_write(pdata, redrv_reg, mode); 1168 1169 return ret; 1170 } 1171 1172 static void axgbe_phy_set_redrv_mode(struct axgbe_port *pdata) 1173 { 1174 struct axgbe_phy_data *phy_data = pdata->phy_data; 1175 enum axgbe_phy_redrv_mode mode; 1176 int ret; 1177 1178 if (!phy_data->redrv) 1179 return; 1180 1181 mode = AXGBE_PHY_REDRV_MODE_CX; 1182 if ((phy_data->port_mode == AXGBE_PORT_MODE_SFP) && 1183 (phy_data->sfp_base != AXGBE_SFP_BASE_1000_CX) && 1184 (phy_data->sfp_base != AXGBE_SFP_BASE_10000_CR)) 1185 mode = AXGBE_PHY_REDRV_MODE_SR; 1186 1187 ret = axgbe_phy_get_comm_ownership(pdata); 1188 if (ret) 1189 return; 1190 1191 if (phy_data->redrv_if) 1192 axgbe_phy_set_redrv_mode_i2c(pdata, mode); 1193 else 1194 axgbe_phy_set_redrv_mode_mdio(pdata, mode); 1195 1196 axgbe_phy_put_comm_ownership(pdata); 1197 } 1198 1199 static void axgbe_phy_pll_ctrl(struct axgbe_port *pdata, bool enable) 1200 { 1201 XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_MISC_CTRL0, 1202 XGBE_PMA_PLL_CTRL_MASK, 1203 enable ? XGBE_PMA_PLL_CTRL_SET 1204 : XGBE_PMA_PLL_CTRL_CLEAR); 1205 1206 /* Wait for command to complete */ 1207 rte_delay_us(150); 1208 } 1209 1210 static void axgbe_phy_start_ratechange(struct axgbe_port *pdata) 1211 { 1212 /* Clear the PLL so that it helps in power down sequence */ 1213 axgbe_phy_pll_ctrl(pdata, false); 1214 1215 /* Log if a previous command did not complete */ 1216 if (XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS)) 1217 PMD_DRV_LOG(NOTICE, "firmware mailbox not ready for command\n"); 1218 else 1219 return; 1220 } 1221 1222 static void axgbe_phy_complete_ratechange(struct axgbe_port *pdata) 1223 { 1224 unsigned int wait; 1225 1226 /* Wait for command to complete */ 1227 wait = AXGBE_RATECHANGE_COUNT; 1228 while (wait--) { 1229 if (!XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS)) 1230 goto reenable_pll; 1231 rte_delay_us(1500); 1232 } 1233 1234 reenable_pll: 1235 /* Re-enable the PLL control */ 1236 axgbe_phy_pll_ctrl(pdata, true); 1237 1238 PMD_DRV_LOG(NOTICE, "firmware mailbox command did not complete\n"); 1239 } 1240 1241 static void axgbe_phy_rrc(struct axgbe_port *pdata) 1242 { 1243 unsigned int s0; 1244 1245 axgbe_phy_start_ratechange(pdata); 1246 1247 /* Receiver Reset Cycle */ 1248 s0 = 0; 1249 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 5); 1250 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0); 1251 1252 /* Call FW to make the change */ 1253 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0); 1254 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0); 1255 XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1); 1256 1257 axgbe_phy_complete_ratechange(pdata); 1258 1259 PMD_DRV_LOG(DEBUG, "receiver reset complete\n"); 1260 } 1261 1262 static void axgbe_phy_power_off(struct axgbe_port *pdata) 1263 { 1264 struct axgbe_phy_data *phy_data = pdata->phy_data; 1265 1266 axgbe_phy_start_ratechange(pdata); 1267 1268 /* Call FW to make the change */ 1269 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, 0); 1270 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0); 1271 XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1); 1272 axgbe_phy_complete_ratechange(pdata); 1273 phy_data->cur_mode = AXGBE_MODE_UNKNOWN; 1274 1275 PMD_DRV_LOG(DEBUG, "phy powered off\n"); 1276 } 1277 1278 static void axgbe_phy_sfi_mode(struct axgbe_port *pdata) 1279 { 1280 struct axgbe_phy_data *phy_data = pdata->phy_data; 1281 unsigned int s0; 1282 1283 axgbe_phy_set_redrv_mode(pdata); 1284 1285 axgbe_phy_start_ratechange(pdata); 1286 1287 /* 10G/SFI */ 1288 s0 = 0; 1289 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 3); 1290 if (phy_data->sfp_cable != AXGBE_SFP_CABLE_PASSIVE) { 1291 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0); 1292 } else { 1293 if (phy_data->sfp_cable_len <= 1) 1294 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 1); 1295 else if (phy_data->sfp_cable_len <= 3) 1296 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 2); 1297 else 1298 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 3); 1299 } 1300 1301 /* Call FW to make the change */ 1302 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0); 1303 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0); 1304 XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1); 1305 axgbe_phy_complete_ratechange(pdata); 1306 phy_data->cur_mode = AXGBE_MODE_SFI; 1307 1308 PMD_DRV_LOG(DEBUG, "10GbE SFI mode set\n"); 1309 } 1310 1311 static void axgbe_phy_kr_mode(struct axgbe_port *pdata) 1312 { 1313 struct axgbe_phy_data *phy_data = pdata->phy_data; 1314 unsigned int s0; 1315 1316 axgbe_phy_set_redrv_mode(pdata); 1317 1318 axgbe_phy_start_ratechange(pdata); 1319 1320 /* 10G/KR */ 1321 s0 = 0; 1322 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 4); 1323 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0); 1324 1325 /* Call FW to make the change */ 1326 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0); 1327 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0); 1328 XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1); 1329 axgbe_phy_complete_ratechange(pdata); 1330 phy_data->cur_mode = AXGBE_MODE_KR; 1331 1332 PMD_DRV_LOG(DEBUG, "10GbE KR mode set\n"); 1333 } 1334 1335 static void axgbe_phy_kx_2500_mode(struct axgbe_port *pdata) 1336 { 1337 struct axgbe_phy_data *phy_data = pdata->phy_data; 1338 unsigned int s0; 1339 1340 axgbe_phy_set_redrv_mode(pdata); 1341 /* 2.5G/KX */ 1342 axgbe_phy_start_ratechange(pdata); 1343 s0 = 0; 1344 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 2); 1345 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0); 1346 1347 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0); 1348 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0); 1349 1350 XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1); 1351 1352 phy_data->cur_mode = AXGBE_MODE_KX_2500; 1353 } 1354 1355 static void axgbe_phy_sgmii_1000_mode(struct axgbe_port *pdata) 1356 { 1357 struct axgbe_phy_data *phy_data = pdata->phy_data; 1358 unsigned int s0; 1359 1360 axgbe_phy_set_redrv_mode(pdata); 1361 1362 /* 1G/SGMII */ 1363 axgbe_phy_start_ratechange(pdata); 1364 s0 = 0; 1365 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 1); 1366 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 2); 1367 1368 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0); 1369 XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0); 1370 1371 XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1); 1372 1373 phy_data->cur_mode = AXGBE_MODE_SGMII_1000; 1374 } 1375 1376 static enum axgbe_mode axgbe_phy_cur_mode(struct axgbe_port *pdata) 1377 { 1378 struct axgbe_phy_data *phy_data = pdata->phy_data; 1379 1380 return phy_data->cur_mode; 1381 } 1382 1383 static enum axgbe_mode axgbe_phy_switch_baset_mode(struct axgbe_port *pdata) 1384 { 1385 struct axgbe_phy_data *phy_data = pdata->phy_data; 1386 1387 /* No switching if not 10GBase-T */ 1388 if (phy_data->port_mode != AXGBE_PORT_MODE_10GBASE_T) 1389 return axgbe_phy_cur_mode(pdata); 1390 1391 switch (axgbe_phy_cur_mode(pdata)) { 1392 case AXGBE_MODE_SGMII_100: 1393 case AXGBE_MODE_SGMII_1000: 1394 return AXGBE_MODE_KR; 1395 case AXGBE_MODE_KR: 1396 default: 1397 return AXGBE_MODE_SGMII_1000; 1398 } 1399 } 1400 1401 static enum axgbe_mode axgbe_phy_switch_bp_2500_mode(struct axgbe_port *pdata 1402 __rte_unused) 1403 { 1404 return AXGBE_MODE_KX_2500; 1405 } 1406 1407 static enum axgbe_mode axgbe_phy_switch_bp_mode(struct axgbe_port *pdata) 1408 { 1409 /* If we are in KR switch to KX, and vice-versa */ 1410 switch (axgbe_phy_cur_mode(pdata)) { 1411 case AXGBE_MODE_KX_1000: 1412 return AXGBE_MODE_KR; 1413 case AXGBE_MODE_KR: 1414 default: 1415 return AXGBE_MODE_KX_1000; 1416 } 1417 } 1418 1419 static enum axgbe_mode axgbe_phy_switch_mode(struct axgbe_port *pdata) 1420 { 1421 struct axgbe_phy_data *phy_data = pdata->phy_data; 1422 1423 switch (phy_data->port_mode) { 1424 case AXGBE_PORT_MODE_BACKPLANE: 1425 return axgbe_phy_switch_bp_mode(pdata); 1426 case AXGBE_PORT_MODE_BACKPLANE_2500: 1427 return axgbe_phy_switch_bp_2500_mode(pdata); 1428 case AXGBE_PORT_MODE_1000BASE_T: 1429 case AXGBE_PORT_MODE_NBASE_T: 1430 case AXGBE_PORT_MODE_10GBASE_T: 1431 return axgbe_phy_switch_baset_mode(pdata); 1432 case AXGBE_PORT_MODE_1000BASE_X: 1433 case AXGBE_PORT_MODE_10GBASE_R: 1434 case AXGBE_PORT_MODE_SFP: 1435 /* No switching, so just return current mode */ 1436 return axgbe_phy_cur_mode(pdata); 1437 default: 1438 return AXGBE_MODE_UNKNOWN; 1439 } 1440 } 1441 1442 static enum axgbe_mode axgbe_phy_get_basex_mode(struct axgbe_phy_data *phy_data 1443 __rte_unused, 1444 int speed) 1445 { 1446 switch (speed) { 1447 case SPEED_1000: 1448 return AXGBE_MODE_X; 1449 case SPEED_10000: 1450 return AXGBE_MODE_KR; 1451 default: 1452 return AXGBE_MODE_UNKNOWN; 1453 } 1454 } 1455 1456 static enum axgbe_mode axgbe_phy_get_baset_mode(struct axgbe_phy_data *phy_data 1457 __rte_unused, 1458 int speed) 1459 { 1460 switch (speed) { 1461 case SPEED_100: 1462 return AXGBE_MODE_SGMII_100; 1463 case SPEED_1000: 1464 return AXGBE_MODE_SGMII_1000; 1465 case SPEED_10000: 1466 return AXGBE_MODE_KR; 1467 default: 1468 return AXGBE_MODE_UNKNOWN; 1469 } 1470 } 1471 1472 static enum axgbe_mode axgbe_phy_get_sfp_mode(struct axgbe_phy_data *phy_data, 1473 int speed) 1474 { 1475 switch (speed) { 1476 case SPEED_100: 1477 return AXGBE_MODE_SGMII_100; 1478 case SPEED_1000: 1479 if (phy_data->sfp_base == AXGBE_SFP_BASE_1000_T) 1480 return AXGBE_MODE_SGMII_1000; 1481 else 1482 return AXGBE_MODE_X; 1483 case SPEED_10000: 1484 case SPEED_UNKNOWN: 1485 return AXGBE_MODE_SFI; 1486 default: 1487 return AXGBE_MODE_UNKNOWN; 1488 } 1489 } 1490 1491 static enum axgbe_mode axgbe_phy_get_bp_2500_mode(int speed) 1492 { 1493 switch (speed) { 1494 case SPEED_2500: 1495 return AXGBE_MODE_KX_2500; 1496 default: 1497 return AXGBE_MODE_UNKNOWN; 1498 } 1499 } 1500 1501 static enum axgbe_mode axgbe_phy_get_bp_mode(int speed) 1502 { 1503 switch (speed) { 1504 case SPEED_1000: 1505 return AXGBE_MODE_KX_1000; 1506 case SPEED_10000: 1507 return AXGBE_MODE_KR; 1508 default: 1509 return AXGBE_MODE_UNKNOWN; 1510 } 1511 } 1512 1513 static enum axgbe_mode axgbe_phy_get_mode(struct axgbe_port *pdata, 1514 int speed) 1515 { 1516 struct axgbe_phy_data *phy_data = pdata->phy_data; 1517 1518 switch (phy_data->port_mode) { 1519 case AXGBE_PORT_MODE_BACKPLANE: 1520 return axgbe_phy_get_bp_mode(speed); 1521 case AXGBE_PORT_MODE_BACKPLANE_2500: 1522 return axgbe_phy_get_bp_2500_mode(speed); 1523 case AXGBE_PORT_MODE_1000BASE_T: 1524 case AXGBE_PORT_MODE_NBASE_T: 1525 case AXGBE_PORT_MODE_10GBASE_T: 1526 return axgbe_phy_get_baset_mode(phy_data, speed); 1527 case AXGBE_PORT_MODE_1000BASE_X: 1528 case AXGBE_PORT_MODE_10GBASE_R: 1529 return axgbe_phy_get_basex_mode(phy_data, speed); 1530 case AXGBE_PORT_MODE_SFP: 1531 return axgbe_phy_get_sfp_mode(phy_data, speed); 1532 default: 1533 return AXGBE_MODE_UNKNOWN; 1534 } 1535 } 1536 1537 static void axgbe_phy_set_mode(struct axgbe_port *pdata, enum axgbe_mode mode) 1538 { 1539 switch (mode) { 1540 case AXGBE_MODE_KR: 1541 axgbe_phy_kr_mode(pdata); 1542 break; 1543 case AXGBE_MODE_SFI: 1544 axgbe_phy_sfi_mode(pdata); 1545 break; 1546 case AXGBE_MODE_KX_2500: 1547 axgbe_phy_kx_2500_mode(pdata); 1548 break; 1549 case AXGBE_MODE_SGMII_1000: 1550 axgbe_phy_sgmii_1000_mode(pdata); 1551 break; 1552 default: 1553 break; 1554 } 1555 } 1556 1557 static bool axgbe_phy_check_mode(struct axgbe_port *pdata, 1558 enum axgbe_mode mode, u32 advert) 1559 { 1560 if (pdata->phy.autoneg == AUTONEG_ENABLE) { 1561 if (pdata->phy.advertising & advert) 1562 return true; 1563 } else { 1564 enum axgbe_mode cur_mode; 1565 1566 cur_mode = axgbe_phy_get_mode(pdata, pdata->phy.speed); 1567 if (cur_mode == mode) 1568 return true; 1569 } 1570 1571 return false; 1572 } 1573 1574 static bool axgbe_phy_use_basex_mode(struct axgbe_port *pdata, 1575 enum axgbe_mode mode) 1576 { 1577 switch (mode) { 1578 case AXGBE_MODE_X: 1579 return axgbe_phy_check_mode(pdata, mode, 1580 ADVERTISED_1000baseT_Full); 1581 case AXGBE_MODE_KR: 1582 return axgbe_phy_check_mode(pdata, mode, 1583 ADVERTISED_10000baseT_Full); 1584 default: 1585 return false; 1586 } 1587 } 1588 1589 static bool axgbe_phy_use_baset_mode(struct axgbe_port *pdata, 1590 enum axgbe_mode mode) 1591 { 1592 switch (mode) { 1593 case AXGBE_MODE_SGMII_100: 1594 return axgbe_phy_check_mode(pdata, mode, 1595 ADVERTISED_100baseT_Full); 1596 case AXGBE_MODE_SGMII_1000: 1597 return axgbe_phy_check_mode(pdata, mode, 1598 ADVERTISED_1000baseT_Full); 1599 case AXGBE_MODE_KR: 1600 return axgbe_phy_check_mode(pdata, mode, 1601 ADVERTISED_10000baseT_Full); 1602 default: 1603 return false; 1604 } 1605 } 1606 1607 static bool axgbe_phy_use_sfp_mode(struct axgbe_port *pdata, 1608 enum axgbe_mode mode) 1609 { 1610 struct axgbe_phy_data *phy_data = pdata->phy_data; 1611 1612 switch (mode) { 1613 case AXGBE_MODE_X: 1614 if (phy_data->sfp_base == AXGBE_SFP_BASE_1000_T) 1615 return false; 1616 return axgbe_phy_check_mode(pdata, mode, 1617 ADVERTISED_1000baseT_Full); 1618 case AXGBE_MODE_SGMII_100: 1619 if (phy_data->sfp_base != AXGBE_SFP_BASE_1000_T) 1620 return false; 1621 return axgbe_phy_check_mode(pdata, mode, 1622 ADVERTISED_100baseT_Full); 1623 case AXGBE_MODE_SGMII_1000: 1624 if (phy_data->sfp_base != AXGBE_SFP_BASE_1000_T) 1625 return false; 1626 return axgbe_phy_check_mode(pdata, mode, 1627 ADVERTISED_1000baseT_Full); 1628 case AXGBE_MODE_SFI: 1629 return axgbe_phy_check_mode(pdata, mode, 1630 ADVERTISED_10000baseT_Full); 1631 default: 1632 return false; 1633 } 1634 } 1635 1636 static bool axgbe_phy_use_bp_2500_mode(struct axgbe_port *pdata, 1637 enum axgbe_mode mode) 1638 { 1639 switch (mode) { 1640 case AXGBE_MODE_KX_2500: 1641 return axgbe_phy_check_mode(pdata, mode, 1642 ADVERTISED_2500baseX_Full); 1643 default: 1644 return false; 1645 } 1646 } 1647 1648 static bool axgbe_phy_use_bp_mode(struct axgbe_port *pdata, 1649 enum axgbe_mode mode) 1650 { 1651 switch (mode) { 1652 case AXGBE_MODE_KX_1000: 1653 return axgbe_phy_check_mode(pdata, mode, 1654 ADVERTISED_1000baseKX_Full); 1655 case AXGBE_MODE_KR: 1656 return axgbe_phy_check_mode(pdata, mode, 1657 ADVERTISED_10000baseKR_Full); 1658 default: 1659 return false; 1660 } 1661 } 1662 1663 static bool axgbe_phy_use_mode(struct axgbe_port *pdata, enum axgbe_mode mode) 1664 { 1665 struct axgbe_phy_data *phy_data = pdata->phy_data; 1666 1667 switch (phy_data->port_mode) { 1668 case AXGBE_PORT_MODE_BACKPLANE: 1669 return axgbe_phy_use_bp_mode(pdata, mode); 1670 case AXGBE_PORT_MODE_BACKPLANE_2500: 1671 return axgbe_phy_use_bp_2500_mode(pdata, mode); 1672 case AXGBE_PORT_MODE_1000BASE_T: 1673 case AXGBE_PORT_MODE_NBASE_T: 1674 case AXGBE_PORT_MODE_10GBASE_T: 1675 return axgbe_phy_use_baset_mode(pdata, mode); 1676 case AXGBE_PORT_MODE_1000BASE_X: 1677 case AXGBE_PORT_MODE_10GBASE_R: 1678 return axgbe_phy_use_basex_mode(pdata, mode); 1679 case AXGBE_PORT_MODE_SFP: 1680 return axgbe_phy_use_sfp_mode(pdata, mode); 1681 default: 1682 return false; 1683 } 1684 } 1685 1686 static int axgbe_phy_link_status(struct axgbe_port *pdata, int *an_restart) 1687 { 1688 struct axgbe_phy_data *phy_data = pdata->phy_data; 1689 unsigned int reg; 1690 1691 *an_restart = 0; 1692 1693 if (phy_data->port_mode == AXGBE_PORT_MODE_SFP) { 1694 /* Check SFP signals */ 1695 axgbe_phy_sfp_detect(pdata); 1696 1697 if (phy_data->sfp_changed) { 1698 *an_restart = 1; 1699 return 0; 1700 } 1701 1702 if (phy_data->sfp_mod_absent || phy_data->sfp_rx_los) 1703 return 0; 1704 } 1705 1706 /* Link status is latched low, so read once to clear 1707 * and then read again to get current state 1708 */ 1709 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1); 1710 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1); 1711 if (reg & MDIO_STAT1_LSTATUS) 1712 return 1; 1713 1714 /* No link, attempt a receiver reset cycle */ 1715 if (phy_data->rrc_count++) { 1716 phy_data->rrc_count = 0; 1717 axgbe_phy_rrc(pdata); 1718 } 1719 1720 return 0; 1721 } 1722 1723 static void axgbe_phy_sfp_gpio_setup(struct axgbe_port *pdata) 1724 { 1725 struct axgbe_phy_data *phy_data = pdata->phy_data; 1726 unsigned int reg; 1727 1728 reg = XP_IOREAD(pdata, XP_PROP_3); 1729 1730 phy_data->sfp_gpio_address = AXGBE_GPIO_ADDRESS_PCA9555 + 1731 XP_GET_BITS(reg, XP_PROP_3, GPIO_ADDR); 1732 1733 phy_data->sfp_gpio_mask = XP_GET_BITS(reg, XP_PROP_3, GPIO_MASK); 1734 1735 phy_data->sfp_gpio_rx_los = XP_GET_BITS(reg, XP_PROP_3, 1736 GPIO_RX_LOS); 1737 phy_data->sfp_gpio_tx_fault = XP_GET_BITS(reg, XP_PROP_3, 1738 GPIO_TX_FAULT); 1739 phy_data->sfp_gpio_mod_absent = XP_GET_BITS(reg, XP_PROP_3, 1740 GPIO_MOD_ABS); 1741 phy_data->sfp_gpio_rate_select = XP_GET_BITS(reg, XP_PROP_3, 1742 GPIO_RATE_SELECT); 1743 } 1744 1745 static void axgbe_phy_sfp_comm_setup(struct axgbe_port *pdata) 1746 { 1747 struct axgbe_phy_data *phy_data = pdata->phy_data; 1748 unsigned int reg, mux_addr_hi, mux_addr_lo; 1749 1750 reg = XP_IOREAD(pdata, XP_PROP_4); 1751 1752 mux_addr_hi = XP_GET_BITS(reg, XP_PROP_4, MUX_ADDR_HI); 1753 mux_addr_lo = XP_GET_BITS(reg, XP_PROP_4, MUX_ADDR_LO); 1754 if (mux_addr_lo == AXGBE_SFP_DIRECT) 1755 return; 1756 1757 phy_data->sfp_comm = AXGBE_SFP_COMM_PCA9545; 1758 phy_data->sfp_mux_address = (mux_addr_hi << 2) + mux_addr_lo; 1759 phy_data->sfp_mux_channel = XP_GET_BITS(reg, XP_PROP_4, MUX_CHAN); 1760 } 1761 1762 static void axgbe_phy_sfp_setup(struct axgbe_port *pdata) 1763 { 1764 axgbe_phy_sfp_comm_setup(pdata); 1765 axgbe_phy_sfp_gpio_setup(pdata); 1766 } 1767 1768 static bool axgbe_phy_redrv_error(struct axgbe_phy_data *phy_data) 1769 { 1770 if (!phy_data->redrv) 1771 return false; 1772 1773 if (phy_data->redrv_if >= AXGBE_PHY_REDRV_IF_MAX) 1774 return true; 1775 1776 switch (phy_data->redrv_model) { 1777 case AXGBE_PHY_REDRV_MODEL_4223: 1778 if (phy_data->redrv_lane > 3) 1779 return true; 1780 break; 1781 case AXGBE_PHY_REDRV_MODEL_4227: 1782 if (phy_data->redrv_lane > 1) 1783 return true; 1784 break; 1785 default: 1786 return true; 1787 } 1788 1789 return false; 1790 } 1791 1792 static int axgbe_phy_mdio_reset_setup(struct axgbe_port *pdata) 1793 { 1794 struct axgbe_phy_data *phy_data = pdata->phy_data; 1795 unsigned int reg; 1796 1797 if (phy_data->conn_type != AXGBE_CONN_TYPE_MDIO) 1798 return 0; 1799 reg = XP_IOREAD(pdata, XP_PROP_3); 1800 phy_data->mdio_reset = XP_GET_BITS(reg, XP_PROP_3, MDIO_RESET); 1801 switch (phy_data->mdio_reset) { 1802 case AXGBE_MDIO_RESET_NONE: 1803 case AXGBE_MDIO_RESET_I2C_GPIO: 1804 case AXGBE_MDIO_RESET_INT_GPIO: 1805 break; 1806 default: 1807 PMD_DRV_LOG(ERR, "unsupported MDIO reset (%#x)\n", 1808 phy_data->mdio_reset); 1809 return -EINVAL; 1810 } 1811 if (phy_data->mdio_reset == AXGBE_MDIO_RESET_I2C_GPIO) { 1812 phy_data->mdio_reset_addr = AXGBE_GPIO_ADDRESS_PCA9555 + 1813 XP_GET_BITS(reg, XP_PROP_3, 1814 MDIO_RESET_I2C_ADDR); 1815 phy_data->mdio_reset_gpio = XP_GET_BITS(reg, XP_PROP_3, 1816 MDIO_RESET_I2C_GPIO); 1817 } else if (phy_data->mdio_reset == AXGBE_MDIO_RESET_INT_GPIO) { 1818 phy_data->mdio_reset_gpio = XP_GET_BITS(reg, XP_PROP_3, 1819 MDIO_RESET_INT_GPIO); 1820 } 1821 1822 return 0; 1823 } 1824 1825 static bool axgbe_phy_port_mode_mismatch(struct axgbe_port *pdata) 1826 { 1827 struct axgbe_phy_data *phy_data = pdata->phy_data; 1828 1829 switch (phy_data->port_mode) { 1830 case AXGBE_PORT_MODE_BACKPLANE: 1831 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) || 1832 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000)) 1833 return false; 1834 break; 1835 case AXGBE_PORT_MODE_BACKPLANE_2500: 1836 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_2500) 1837 return false; 1838 break; 1839 case AXGBE_PORT_MODE_1000BASE_T: 1840 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) || 1841 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000)) 1842 return false; 1843 break; 1844 case AXGBE_PORT_MODE_1000BASE_X: 1845 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) 1846 return false; 1847 break; 1848 case AXGBE_PORT_MODE_NBASE_T: 1849 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) || 1850 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) || 1851 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_2500)) 1852 return false; 1853 break; 1854 case AXGBE_PORT_MODE_10GBASE_T: 1855 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) || 1856 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) || 1857 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000)) 1858 return false; 1859 break; 1860 case AXGBE_PORT_MODE_10GBASE_R: 1861 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) 1862 return false; 1863 break; 1864 case AXGBE_PORT_MODE_SFP: 1865 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) || 1866 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) || 1867 (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000)) 1868 return false; 1869 break; 1870 default: 1871 break; 1872 } 1873 1874 return true; 1875 } 1876 1877 static bool axgbe_phy_conn_type_mismatch(struct axgbe_port *pdata) 1878 { 1879 struct axgbe_phy_data *phy_data = pdata->phy_data; 1880 1881 switch (phy_data->port_mode) { 1882 case AXGBE_PORT_MODE_BACKPLANE: 1883 case AXGBE_PORT_MODE_BACKPLANE_2500: 1884 if (phy_data->conn_type == AXGBE_CONN_TYPE_BACKPLANE) 1885 return false; 1886 break; 1887 case AXGBE_PORT_MODE_1000BASE_T: 1888 case AXGBE_PORT_MODE_1000BASE_X: 1889 case AXGBE_PORT_MODE_NBASE_T: 1890 case AXGBE_PORT_MODE_10GBASE_T: 1891 case AXGBE_PORT_MODE_10GBASE_R: 1892 if (phy_data->conn_type == AXGBE_CONN_TYPE_MDIO) 1893 return false; 1894 break; 1895 case AXGBE_PORT_MODE_SFP: 1896 if (phy_data->conn_type == AXGBE_CONN_TYPE_SFP) 1897 return false; 1898 break; 1899 default: 1900 break; 1901 } 1902 1903 return true; 1904 } 1905 1906 static bool axgbe_phy_port_enabled(struct axgbe_port *pdata) 1907 { 1908 unsigned int reg; 1909 1910 reg = XP_IOREAD(pdata, XP_PROP_0); 1911 if (!XP_GET_BITS(reg, XP_PROP_0, PORT_SPEEDS)) 1912 return false; 1913 if (!XP_GET_BITS(reg, XP_PROP_0, CONN_TYPE)) 1914 return false; 1915 1916 return true; 1917 } 1918 1919 static void axgbe_phy_cdr_track(struct axgbe_port *pdata) 1920 { 1921 struct axgbe_phy_data *phy_data = pdata->phy_data; 1922 1923 if (!pdata->vdata->an_cdr_workaround) 1924 return; 1925 1926 if (!phy_data->phy_cdr_notrack) 1927 return; 1928 1929 rte_delay_us(phy_data->phy_cdr_delay + 400); 1930 1931 XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_CDR_CONTROL, 1932 AXGBE_PMA_CDR_TRACK_EN_MASK, 1933 AXGBE_PMA_CDR_TRACK_EN_ON); 1934 1935 phy_data->phy_cdr_notrack = 0; 1936 } 1937 1938 static void axgbe_phy_cdr_notrack(struct axgbe_port *pdata) 1939 { 1940 struct axgbe_phy_data *phy_data = pdata->phy_data; 1941 1942 if (!pdata->vdata->an_cdr_workaround) 1943 return; 1944 1945 if (phy_data->phy_cdr_notrack) 1946 return; 1947 1948 XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_CDR_CONTROL, 1949 AXGBE_PMA_CDR_TRACK_EN_MASK, 1950 AXGBE_PMA_CDR_TRACK_EN_OFF); 1951 1952 axgbe_phy_rrc(pdata); 1953 1954 phy_data->phy_cdr_notrack = 1; 1955 } 1956 1957 static void axgbe_phy_kr_training_post(struct axgbe_port *pdata) 1958 { 1959 if (!pdata->cdr_track_early) 1960 axgbe_phy_cdr_track(pdata); 1961 } 1962 1963 static void axgbe_phy_kr_training_pre(struct axgbe_port *pdata) 1964 { 1965 if (pdata->cdr_track_early) 1966 axgbe_phy_cdr_track(pdata); 1967 } 1968 1969 static void axgbe_phy_an_post(struct axgbe_port *pdata) 1970 { 1971 struct axgbe_phy_data *phy_data = pdata->phy_data; 1972 1973 switch (pdata->an_mode) { 1974 case AXGBE_AN_MODE_CL73: 1975 case AXGBE_AN_MODE_CL73_REDRV: 1976 if (phy_data->cur_mode != AXGBE_MODE_KR) 1977 break; 1978 1979 axgbe_phy_cdr_track(pdata); 1980 1981 switch (pdata->an_result) { 1982 case AXGBE_AN_READY: 1983 case AXGBE_AN_COMPLETE: 1984 break; 1985 default: 1986 if (phy_data->phy_cdr_delay < AXGBE_CDR_DELAY_MAX) 1987 phy_data->phy_cdr_delay += AXGBE_CDR_DELAY_INC; 1988 break; 1989 } 1990 break; 1991 default: 1992 break; 1993 } 1994 } 1995 1996 static void axgbe_phy_an_pre(struct axgbe_port *pdata) 1997 { 1998 struct axgbe_phy_data *phy_data = pdata->phy_data; 1999 2000 switch (pdata->an_mode) { 2001 case AXGBE_AN_MODE_CL73: 2002 case AXGBE_AN_MODE_CL73_REDRV: 2003 if (phy_data->cur_mode != AXGBE_MODE_KR) 2004 break; 2005 2006 axgbe_phy_cdr_notrack(pdata); 2007 break; 2008 default: 2009 break; 2010 } 2011 } 2012 2013 static void axgbe_phy_stop(struct axgbe_port *pdata) 2014 { 2015 struct axgbe_phy_data *phy_data = pdata->phy_data; 2016 2017 /* Reset SFP data */ 2018 axgbe_phy_sfp_reset(phy_data); 2019 axgbe_phy_sfp_mod_absent(pdata); 2020 2021 /* Reset CDR support */ 2022 axgbe_phy_cdr_track(pdata); 2023 2024 /* Power off the PHY */ 2025 axgbe_phy_power_off(pdata); 2026 2027 /* Stop the I2C controller */ 2028 pdata->i2c_if.i2c_stop(pdata); 2029 } 2030 2031 static int axgbe_phy_start(struct axgbe_port *pdata) 2032 { 2033 struct axgbe_phy_data *phy_data = pdata->phy_data; 2034 int ret; 2035 2036 /* Start the I2C controller */ 2037 ret = pdata->i2c_if.i2c_start(pdata); 2038 if (ret) 2039 return ret; 2040 2041 /* Start in highest supported mode */ 2042 axgbe_phy_set_mode(pdata, phy_data->start_mode); 2043 2044 /* Reset CDR support */ 2045 axgbe_phy_cdr_track(pdata); 2046 2047 /* After starting the I2C controller, we can check for an SFP */ 2048 switch (phy_data->port_mode) { 2049 case AXGBE_PORT_MODE_SFP: 2050 axgbe_phy_sfp_detect(pdata); 2051 break; 2052 default: 2053 break; 2054 } 2055 pdata->phy.advertising &= axgbe_phy_an_advertising(pdata); 2056 2057 return ret; 2058 } 2059 2060 static int axgbe_phy_reset(struct axgbe_port *pdata) 2061 { 2062 struct axgbe_phy_data *phy_data = pdata->phy_data; 2063 enum axgbe_mode cur_mode; 2064 2065 /* Reset by power cycling the PHY */ 2066 cur_mode = phy_data->cur_mode; 2067 axgbe_phy_power_off(pdata); 2068 /* First time reset is done with passed unknown mode*/ 2069 axgbe_phy_set_mode(pdata, cur_mode); 2070 return 0; 2071 } 2072 2073 static int axgbe_phy_init(struct axgbe_port *pdata) 2074 { 2075 struct axgbe_phy_data *phy_data; 2076 unsigned int reg; 2077 int ret; 2078 2079 /* Check if enabled */ 2080 if (!axgbe_phy_port_enabled(pdata)) { 2081 PMD_DRV_LOG(ERR, "device is not enabled\n"); 2082 return -ENODEV; 2083 } 2084 2085 /* Initialize the I2C controller */ 2086 ret = pdata->i2c_if.i2c_init(pdata); 2087 if (ret) 2088 return ret; 2089 2090 phy_data = rte_zmalloc("phy_data memory", sizeof(*phy_data), 0); 2091 if (!phy_data) { 2092 PMD_DRV_LOG(ERR, "phy_data allocation failed\n"); 2093 return -ENOMEM; 2094 } 2095 pdata->phy_data = phy_data; 2096 2097 reg = XP_IOREAD(pdata, XP_PROP_0); 2098 phy_data->port_mode = XP_GET_BITS(reg, XP_PROP_0, PORT_MODE); 2099 phy_data->port_id = XP_GET_BITS(reg, XP_PROP_0, PORT_ID); 2100 phy_data->port_speeds = XP_GET_BITS(reg, XP_PROP_0, PORT_SPEEDS); 2101 phy_data->conn_type = XP_GET_BITS(reg, XP_PROP_0, CONN_TYPE); 2102 phy_data->mdio_addr = XP_GET_BITS(reg, XP_PROP_0, MDIO_ADDR); 2103 2104 reg = XP_IOREAD(pdata, XP_PROP_4); 2105 phy_data->redrv = XP_GET_BITS(reg, XP_PROP_4, REDRV_PRESENT); 2106 phy_data->redrv_if = XP_GET_BITS(reg, XP_PROP_4, REDRV_IF); 2107 phy_data->redrv_addr = XP_GET_BITS(reg, XP_PROP_4, REDRV_ADDR); 2108 phy_data->redrv_lane = XP_GET_BITS(reg, XP_PROP_4, REDRV_LANE); 2109 phy_data->redrv_model = XP_GET_BITS(reg, XP_PROP_4, REDRV_MODEL); 2110 2111 /* Validate the connection requested */ 2112 if (axgbe_phy_conn_type_mismatch(pdata)) { 2113 PMD_DRV_LOG(ERR, "phy mode/connection mismatch (%#x/%#x)\n", 2114 phy_data->port_mode, phy_data->conn_type); 2115 return -EINVAL; 2116 } 2117 2118 /* Validate the mode requested */ 2119 if (axgbe_phy_port_mode_mismatch(pdata)) { 2120 PMD_DRV_LOG(ERR, "phy mode/speed mismatch (%#x/%#x)\n", 2121 phy_data->port_mode, phy_data->port_speeds); 2122 return -EINVAL; 2123 } 2124 2125 /* Check for and validate MDIO reset support */ 2126 ret = axgbe_phy_mdio_reset_setup(pdata); 2127 if (ret) 2128 return ret; 2129 2130 /* Validate the re-driver information */ 2131 if (axgbe_phy_redrv_error(phy_data)) { 2132 PMD_DRV_LOG(ERR, "phy re-driver settings error\n"); 2133 return -EINVAL; 2134 } 2135 pdata->kr_redrv = phy_data->redrv; 2136 2137 /* Indicate current mode is unknown */ 2138 phy_data->cur_mode = AXGBE_MODE_UNKNOWN; 2139 2140 /* Initialize supported features */ 2141 pdata->phy.supported = 0; 2142 2143 switch (phy_data->port_mode) { 2144 /* Backplane support */ 2145 case AXGBE_PORT_MODE_BACKPLANE: 2146 pdata->phy.supported |= SUPPORTED_Autoneg; 2147 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2148 pdata->phy.supported |= SUPPORTED_Backplane; 2149 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) { 2150 pdata->phy.supported |= SUPPORTED_1000baseKX_Full; 2151 phy_data->start_mode = AXGBE_MODE_KX_1000; 2152 } 2153 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) { 2154 pdata->phy.supported |= SUPPORTED_10000baseKR_Full; 2155 if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE) 2156 pdata->phy.supported |= 2157 SUPPORTED_10000baseR_FEC; 2158 phy_data->start_mode = AXGBE_MODE_KR; 2159 } 2160 2161 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE; 2162 break; 2163 case AXGBE_PORT_MODE_BACKPLANE_2500: 2164 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2165 pdata->phy.supported |= SUPPORTED_Backplane; 2166 pdata->phy.supported |= SUPPORTED_2500baseX_Full; 2167 phy_data->start_mode = AXGBE_MODE_KX_2500; 2168 2169 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE; 2170 break; 2171 2172 /* MDIO 1GBase-T support */ 2173 case AXGBE_PORT_MODE_1000BASE_T: 2174 pdata->phy.supported |= SUPPORTED_Autoneg; 2175 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2176 pdata->phy.supported |= SUPPORTED_TP; 2177 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) { 2178 pdata->phy.supported |= SUPPORTED_100baseT_Full; 2179 phy_data->start_mode = AXGBE_MODE_SGMII_100; 2180 } 2181 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) { 2182 pdata->phy.supported |= SUPPORTED_1000baseT_Full; 2183 phy_data->start_mode = AXGBE_MODE_SGMII_1000; 2184 } 2185 2186 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL22; 2187 break; 2188 2189 /* MDIO Base-X support */ 2190 case AXGBE_PORT_MODE_1000BASE_X: 2191 pdata->phy.supported |= SUPPORTED_Autoneg; 2192 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2193 pdata->phy.supported |= SUPPORTED_FIBRE; 2194 pdata->phy.supported |= SUPPORTED_1000baseT_Full; 2195 phy_data->start_mode = AXGBE_MODE_X; 2196 2197 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL22; 2198 break; 2199 2200 /* MDIO NBase-T support */ 2201 case AXGBE_PORT_MODE_NBASE_T: 2202 pdata->phy.supported |= SUPPORTED_Autoneg; 2203 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2204 pdata->phy.supported |= SUPPORTED_TP; 2205 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) { 2206 pdata->phy.supported |= SUPPORTED_100baseT_Full; 2207 phy_data->start_mode = AXGBE_MODE_SGMII_100; 2208 } 2209 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) { 2210 pdata->phy.supported |= SUPPORTED_1000baseT_Full; 2211 phy_data->start_mode = AXGBE_MODE_SGMII_1000; 2212 } 2213 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_2500) { 2214 pdata->phy.supported |= SUPPORTED_2500baseX_Full; 2215 phy_data->start_mode = AXGBE_MODE_KX_2500; 2216 } 2217 2218 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL45; 2219 break; 2220 2221 /* 10GBase-T support */ 2222 case AXGBE_PORT_MODE_10GBASE_T: 2223 pdata->phy.supported |= SUPPORTED_Autoneg; 2224 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2225 pdata->phy.supported |= SUPPORTED_TP; 2226 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) { 2227 pdata->phy.supported |= SUPPORTED_100baseT_Full; 2228 phy_data->start_mode = AXGBE_MODE_SGMII_100; 2229 } 2230 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) { 2231 pdata->phy.supported |= SUPPORTED_1000baseT_Full; 2232 phy_data->start_mode = AXGBE_MODE_SGMII_1000; 2233 } 2234 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) { 2235 pdata->phy.supported |= SUPPORTED_10000baseT_Full; 2236 phy_data->start_mode = AXGBE_MODE_KR; 2237 } 2238 2239 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE; 2240 break; 2241 2242 /* 10GBase-R support */ 2243 case AXGBE_PORT_MODE_10GBASE_R: 2244 pdata->phy.supported |= SUPPORTED_Autoneg; 2245 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2246 pdata->phy.supported |= SUPPORTED_TP; 2247 pdata->phy.supported |= SUPPORTED_10000baseT_Full; 2248 if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE) 2249 pdata->phy.supported |= SUPPORTED_10000baseR_FEC; 2250 phy_data->start_mode = AXGBE_MODE_SFI; 2251 2252 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE; 2253 break; 2254 2255 /* SFP support */ 2256 case AXGBE_PORT_MODE_SFP: 2257 pdata->phy.supported |= SUPPORTED_Autoneg; 2258 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause; 2259 pdata->phy.supported |= SUPPORTED_TP; 2260 pdata->phy.supported |= SUPPORTED_FIBRE; 2261 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) { 2262 pdata->phy.supported |= SUPPORTED_100baseT_Full; 2263 phy_data->start_mode = AXGBE_MODE_SGMII_100; 2264 } 2265 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) { 2266 pdata->phy.supported |= SUPPORTED_1000baseT_Full; 2267 phy_data->start_mode = AXGBE_MODE_SGMII_1000; 2268 } 2269 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) { 2270 pdata->phy.supported |= SUPPORTED_10000baseT_Full; 2271 phy_data->start_mode = AXGBE_MODE_SFI; 2272 if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE) 2273 pdata->phy.supported |= 2274 SUPPORTED_10000baseR_FEC; 2275 } 2276 2277 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL22; 2278 2279 axgbe_phy_sfp_setup(pdata); 2280 break; 2281 default: 2282 return -EINVAL; 2283 } 2284 2285 if ((phy_data->conn_type & AXGBE_CONN_TYPE_MDIO) && 2286 (phy_data->phydev_mode != AXGBE_MDIO_MODE_NONE)) { 2287 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->mdio_addr, 2288 phy_data->phydev_mode); 2289 if (ret) { 2290 PMD_DRV_LOG(ERR, "mdio port/clause not compatible (%d/%u)\n", 2291 phy_data->mdio_addr, phy_data->phydev_mode); 2292 return -EINVAL; 2293 } 2294 } 2295 2296 if (phy_data->redrv && !phy_data->redrv_if) { 2297 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->redrv_addr, 2298 AXGBE_MDIO_MODE_CL22); 2299 if (ret) { 2300 PMD_DRV_LOG(ERR, "redriver mdio port not compatible (%u)\n", 2301 phy_data->redrv_addr); 2302 return -EINVAL; 2303 } 2304 } 2305 2306 phy_data->phy_cdr_delay = AXGBE_CDR_DELAY_INIT; 2307 return 0; 2308 } 2309 void axgbe_init_function_ptrs_phy_v2(struct axgbe_phy_if *phy_if) 2310 { 2311 struct axgbe_phy_impl_if *phy_impl = &phy_if->phy_impl; 2312 2313 phy_impl->init = axgbe_phy_init; 2314 phy_impl->reset = axgbe_phy_reset; 2315 phy_impl->start = axgbe_phy_start; 2316 phy_impl->stop = axgbe_phy_stop; 2317 phy_impl->link_status = axgbe_phy_link_status; 2318 phy_impl->use_mode = axgbe_phy_use_mode; 2319 phy_impl->set_mode = axgbe_phy_set_mode; 2320 phy_impl->get_mode = axgbe_phy_get_mode; 2321 phy_impl->switch_mode = axgbe_phy_switch_mode; 2322 phy_impl->cur_mode = axgbe_phy_cur_mode; 2323 phy_impl->an_mode = axgbe_phy_an_mode; 2324 phy_impl->an_config = axgbe_phy_an_config; 2325 phy_impl->an_advertising = axgbe_phy_an_advertising; 2326 phy_impl->an_outcome = axgbe_phy_an_outcome; 2327 2328 phy_impl->an_pre = axgbe_phy_an_pre; 2329 phy_impl->an_post = axgbe_phy_an_post; 2330 2331 phy_impl->kr_training_pre = axgbe_phy_kr_training_pre; 2332 phy_impl->kr_training_post = axgbe_phy_kr_training_post; 2333 } 2334