drivers/net/ethernet/intel/ixgb/ixgb_hw.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2008 Intel Corporation. */
   3
   4 /* ixgb_hw.c
   5  * Shared functions for accessing and configuring the adapter
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/pci_ids.h>
  11 #include "ixgb_hw.h"
  12 #include "ixgb_ids.h"
  13
  14 #include <linux/etherdevice.h>
  15
  16 /*  Local function prototypes */
  17
  18 static u32 ixgb_hash_mc_addr(struct ixgb_hw *hw, u8 * mc_addr);
  19
  20 static void ixgb_mta_set(struct ixgb_hw *hw, u32 hash_value);
  21
  22 static void ixgb_get_bus_info(struct ixgb_hw *hw);
  23
  24 static bool ixgb_link_reset(struct ixgb_hw *hw);
  25
  26 static void ixgb_optics_reset(struct ixgb_hw *hw);
  27
  28 static void ixgb_optics_reset_bcm(struct ixgb_hw *hw);
  29
  30 static ixgb_phy_type ixgb_identify_phy(struct ixgb_hw *hw);
  31
  32 static void ixgb_clear_hw_cntrs(struct ixgb_hw *hw);
  33
  34 static void ixgb_clear_vfta(struct ixgb_hw *hw);
  35
  36 static void ixgb_init_rx_addrs(struct ixgb_hw *hw);
  37
  38 static u16 ixgb_read_phy_reg(struct ixgb_hw *hw,
  39                                   u32 reg_address,
  40                                   u32 phy_address,
  41                                   u32 device_type);
  42
  43 static bool ixgb_setup_fc(struct ixgb_hw *hw);
  44
  45 static bool mac_addr_valid(u8 *mac_addr);
  46
  47 static u32 ixgb_mac_reset(struct ixgb_hw *hw)
  48 {
  49         u32 ctrl_reg;
  50
  51         ctrl_reg =  IXGB_CTRL0_RST |
  52                                 IXGB_CTRL0_SDP3_DIR |   /* All pins are Output=1 */
  53                                 IXGB_CTRL0_SDP2_DIR |
  54                                 IXGB_CTRL0_SDP1_DIR |
  55                                 IXGB_CTRL0_SDP0_DIR |
  56                                 IXGB_CTRL0_SDP3  |   /* Initial value 1101   */
  57                                 IXGB_CTRL0_SDP2  |
  58                                 IXGB_CTRL0_SDP0;
  59
  60 #ifdef HP_ZX1
  61         /* Workaround for 82597EX reset errata */
  62         IXGB_WRITE_REG_IO(hw, CTRL0, ctrl_reg);
  63 #else
  64         IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
  65 #endif
  66
  67         /* Delay a few ms just to allow the reset to complete */
  68         msleep(IXGB_DELAY_AFTER_RESET);
  69         ctrl_reg = IXGB_READ_REG(hw, CTRL0);
  70 #ifdef DBG
  71         /* Make sure the self-clearing global reset bit did self clear */
  72         ASSERT(!(ctrl_reg & IXGB_CTRL0_RST));
  73 #endif
  74
  75         if (hw->subsystem_vendor_id == PCI_VENDOR_ID_SUN) {
  76                 ctrl_reg =  /* Enable interrupt from XFP and SerDes */
  77                            IXGB_CTRL1_GPI0_EN |
  78                            IXGB_CTRL1_SDP6_DIR |
  79                            IXGB_CTRL1_SDP7_DIR |
  80                            IXGB_CTRL1_SDP6 |
  81                            IXGB_CTRL1_SDP7;
  82                 IXGB_WRITE_REG(hw, CTRL1, ctrl_reg);
  83                 ixgb_optics_reset_bcm(hw);
  84         }
  85
  86         if (hw->phy_type == ixgb_phy_type_txn17401)
  87                 ixgb_optics_reset(hw);
  88
  89         return ctrl_reg;
  90 }
  91
  92 /******************************************************************************
  93  * Reset the transmit and receive units; mask and clear all interrupts.
  94  *
  95  * hw - Struct containing variables accessed by shared code
  96  *****************************************************************************/
  97 bool
  98 ixgb_adapter_stop(struct ixgb_hw *hw)
  99 {
 100         u32 ctrl_reg;
 101         u32 icr_reg;
 102
 103         ENTER();
 104
 105         /* If we are stopped or resetting exit gracefully and wait to be
 106          * started again before accessing the hardware.
 107          */
 108         if (hw->adapter_stopped) {
 109                 pr_debug("Exiting because the adapter is already stopped!!!\n");
 110                 return false;
 111         }
 112
 113         /* Set the Adapter Stopped flag so other driver functions stop
 114          * touching the Hardware.
 115          */
 116         hw->adapter_stopped = true;
 117
 118         /* Clear interrupt mask to stop board from generating interrupts */
 119         pr_debug("Masking off all interrupts\n");
 120         IXGB_WRITE_REG(hw, IMC, 0xFFFFFFFF);
 121
 122         /* Disable the Transmit and Receive units.  Then delay to allow
 123          * any pending transactions to complete before we hit the MAC with
 124          * the global reset.
 125          */
 126         IXGB_WRITE_REG(hw, RCTL, IXGB_READ_REG(hw, RCTL) & ~IXGB_RCTL_RXEN);
 127         IXGB_WRITE_REG(hw, TCTL, IXGB_READ_REG(hw, TCTL) & ~IXGB_TCTL_TXEN);
 128         IXGB_WRITE_FLUSH(hw);
 129         msleep(IXGB_DELAY_BEFORE_RESET);
 130
 131         /* Issue a global reset to the MAC.  This will reset the chip's
 132          * transmit, receive, DMA, and link units.  It will not effect
 133          * the current PCI configuration.  The global reset bit is self-
 134          * clearing, and should clear within a microsecond.
 135          */
 136         pr_debug("Issuing a global reset to MAC\n");
 137
 138         ctrl_reg = ixgb_mac_reset(hw);
 139
 140         /* Clear interrupt mask to stop board from generating interrupts */
 141         pr_debug("Masking off all interrupts\n");
 142         IXGB_WRITE_REG(hw, IMC, 0xffffffff);
 143
 144         /* Clear any pending interrupt events. */
 145         icr_reg = IXGB_READ_REG(hw, ICR);
 146
 147         return ctrl_reg & IXGB_CTRL0_RST;
 148 }
 149
 150
 151 /******************************************************************************
 152  * Identifies the vendor of the optics module on the adapter.  The SR adapters
 153  * support two different types of XPAK optics, so it is necessary to determine
 154  * which optics are present before applying any optics-specific workarounds.
 155  *
 156  * hw - Struct containing variables accessed by shared code.
 157  *
 158  * Returns: the vendor of the XPAK optics module.
 159  *****************************************************************************/
 160 static ixgb_xpak_vendor
 161 ixgb_identify_xpak_vendor(struct ixgb_hw *hw)
 162 {
 163         u32 i;
 164         u16 vendor_name[5];
 165         ixgb_xpak_vendor xpak_vendor;
 166
 167         ENTER();
 168
 169         /* Read the first few bytes of the vendor string from the XPAK NVR
 170          * registers.  These are standard XENPAK/XPAK registers, so all XPAK
 171          * devices should implement them. */
 172         for (i = 0; i < 5; i++) {
 173                 vendor_name[i] = ixgb_read_phy_reg(hw,
 174                                                    MDIO_PMA_PMD_XPAK_VENDOR_NAME
 175                                                    + i, IXGB_PHY_ADDRESS,
 176                                                    MDIO_MMD_PMAPMD);
 177         }
 178
 179         /* Determine the actual vendor */
 180         if (vendor_name[0] == 'I' &&
 181             vendor_name[1] == 'N' &&
 182             vendor_name[2] == 'T' &&
 183             vendor_name[3] == 'E' && vendor_name[4] == 'L') {
 184                 xpak_vendor = ixgb_xpak_vendor_intel;
 185         } else {
 186                 xpak_vendor = ixgb_xpak_vendor_infineon;
 187         }
 188
 189         return xpak_vendor;
 190 }
 191
 192 /******************************************************************************
 193  * Determine the physical layer module on the adapter.
 194  *
 195  * hw - Struct containing variables accessed by shared code.  The device_id
 196  *      field must be (correctly) populated before calling this routine.
 197  *
 198  * Returns: the phy type of the adapter.
 199  *****************************************************************************/
 200 static ixgb_phy_type
 201 ixgb_identify_phy(struct ixgb_hw *hw)
 202 {
 203         ixgb_phy_type phy_type;
 204         ixgb_xpak_vendor xpak_vendor;
 205
 206         ENTER();
 207
 208         /* Infer the transceiver/phy type from the device id */
 209         switch (hw->device_id) {
 210         case IXGB_DEVICE_ID_82597EX:
 211                 pr_debug("Identified TXN17401 optics\n");
 212                 phy_type = ixgb_phy_type_txn17401;
 213                 break;
 214
 215         case IXGB_DEVICE_ID_82597EX_SR:
 216                 /* The SR adapters carry two different types of XPAK optics
 217                  * modules; read the vendor identifier to determine the exact
 218                  * type of optics. */
 219                 xpak_vendor = ixgb_identify_xpak_vendor(hw);
 220                 if (xpak_vendor == ixgb_xpak_vendor_intel) {
 221                         pr_debug("Identified TXN17201 optics\n");
 222                         phy_type = ixgb_phy_type_txn17201;
 223                 } else {
 224                         pr_debug("Identified G6005 optics\n");
 225                         phy_type = ixgb_phy_type_g6005;
 226                 }
 227                 break;
 228         case IXGB_DEVICE_ID_82597EX_LR:
 229                 pr_debug("Identified G6104 optics\n");
 230                 phy_type = ixgb_phy_type_g6104;
 231                 break;
 232         case IXGB_DEVICE_ID_82597EX_CX4:
 233                 pr_debug("Identified CX4\n");
 234                 xpak_vendor = ixgb_identify_xpak_vendor(hw);
 235                 if (xpak_vendor == ixgb_xpak_vendor_intel) {
 236                         pr_debug("Identified TXN17201 optics\n");
 237                         phy_type = ixgb_phy_type_txn17201;
 238                 } else {
 239                         pr_debug("Identified G6005 optics\n");
 240                         phy_type = ixgb_phy_type_g6005;
 241                 }
 242                 break;
 243         default:
 244                 pr_debug("Unknown physical layer module\n");
 245                 phy_type = ixgb_phy_type_unknown;
 246                 break;
 247         }
 248
 249         /* update phy type for sun specific board */
 250         if (hw->subsystem_vendor_id == PCI_VENDOR_ID_SUN)
 251                 phy_type = ixgb_phy_type_bcm;
 252
 253         return phy_type;
 254 }
 255
 256 /******************************************************************************
 257  * Performs basic configuration of the adapter.
 258  *
 259  * hw - Struct containing variables accessed by shared code
 260  *
 261  * Resets the controller.
 262  * Reads and validates the EEPROM.
 263  * Initializes the receive address registers.
 264  * Initializes the multicast table.
 265  * Clears all on-chip counters.
 266  * Calls routine to setup flow control settings.
 267  * Leaves the transmit and receive units disabled and uninitialized.
 268  *
 269  * Returns:
 270  *      true if successful,
 271  *      false if unrecoverable problems were encountered.
 272  *****************************************************************************/
 273 bool
 274 ixgb_init_hw(struct ixgb_hw *hw)
 275 {
 276         u32 i;
 277         u32 ctrl_reg;
 278         bool status;
 279
 280         ENTER();
 281
 282         /* Issue a global reset to the MAC.  This will reset the chip's
 283          * transmit, receive, DMA, and link units.  It will not effect
 284          * the current PCI configuration.  The global reset bit is self-
 285          * clearing, and should clear within a microsecond.
 286          */
 287         pr_debug("Issuing a global reset to MAC\n");
 288
 289         ctrl_reg = ixgb_mac_reset(hw);
 290
 291         pr_debug("Issuing an EE reset to MAC\n");
 292 #ifdef HP_ZX1
 293         /* Workaround for 82597EX reset errata */
 294         IXGB_WRITE_REG_IO(hw, CTRL1, IXGB_CTRL1_EE_RST);
 295 #else
 296         IXGB_WRITE_REG(hw, CTRL1, IXGB_CTRL1_EE_RST);
 297 #endif
 298
 299         /* Delay a few ms just to allow the reset to complete */
 300         msleep(IXGB_DELAY_AFTER_EE_RESET);
 301
 302         if (!ixgb_get_eeprom_data(hw))
 303                 return false;
 304
 305         /* Use the device id to determine the type of phy/transceiver. */
 306         hw->device_id = ixgb_get_ee_device_id(hw);
 307         hw->phy_type = ixgb_identify_phy(hw);
 308
 309         /* Setup the receive addresses.
 310          * Receive Address Registers (RARs 0 - 15).
 311          */
 312         ixgb_init_rx_addrs(hw);
 313
 314         /*
 315          * Check that a valid MAC address has been set.
 316          * If it is not valid, we fail hardware init.
 317          */
 318         if (!mac_addr_valid(hw->curr_mac_addr)) {
 319                 pr_debug("MAC address invalid after ixgb_init_rx_addrs\n");
 320                 return(false);
 321         }
 322
 323         /* tell the routines in this file they can access hardware again */
 324         hw->adapter_stopped = false;
 325
 326         /* Fill in the bus_info structure */
 327         ixgb_get_bus_info(hw);
 328
 329         /* Zero out the Multicast HASH table */
 330         pr_debug("Zeroing the MTA\n");
 331         for (i = 0; i < IXGB_MC_TBL_SIZE; i++)
 332                 IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
 333
 334         /* Zero out the VLAN Filter Table Array */
 335         ixgb_clear_vfta(hw);
 336
 337         /* Zero all of the hardware counters */
 338         ixgb_clear_hw_cntrs(hw);
 339
 340         /* Call a subroutine to setup flow control. */
 341         status = ixgb_setup_fc(hw);
 342
 343         /* 82597EX errata: Call check-for-link in case lane deskew is locked */
 344         ixgb_check_for_link(hw);
 345
 346         return status;
 347 }
 348
 349 /******************************************************************************
 350  * Initializes receive address filters.
 351  *
 352  * hw - Struct containing variables accessed by shared code
 353  *
 354  * Places the MAC address in receive address register 0 and clears the rest
 355  * of the receive address registers. Clears the multicast table. Assumes
 356  * the receiver is in reset when the routine is called.
 357  *****************************************************************************/
 358 static void
 359 ixgb_init_rx_addrs(struct ixgb_hw *hw)
 360 {
 361         u32 i;
 362
 363         ENTER();
 364
 365         /*
 366          * If the current mac address is valid, assume it is a software override
 367          * to the permanent address.
 368          * Otherwise, use the permanent address from the eeprom.
 369          */
 370         if (!mac_addr_valid(hw->curr_mac_addr)) {
 371
 372                 /* Get the MAC address from the eeprom for later reference */
 373                 ixgb_get_ee_mac_addr(hw, hw->curr_mac_addr);
 374
 375                 pr_debug("Keeping Permanent MAC Addr = %pM\n",
 376                          hw->curr_mac_addr);
 377         } else {
 378
 379                 /* Setup the receive address. */
 380                 pr_debug("Overriding MAC Address in RAR[0]\n");
 381                 pr_debug("New MAC Addr = %pM\n", hw->curr_mac_addr);
 382
 383                 ixgb_rar_set(hw, hw->curr_mac_addr, 0);
 384         }
 385
 386         /* Zero out the other 15 receive addresses. */
 387         pr_debug("Clearing RAR[1-15]\n");
 388         for (i = 1; i < IXGB_RAR_ENTRIES; i++) {
 389                 /* Write high reg first to disable the AV bit first */
 390                 IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
 391                 IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
 392         }
 393 }
 394
 395 /******************************************************************************
 396  * Updates the MAC's list of multicast addresses.
 397  *
 398  * hw - Struct containing variables accessed by shared code
 399  * mc_addr_list - the list of new multicast addresses
 400  * mc_addr_count - number of addresses
 401  * pad - number of bytes between addresses in the list
 402  *
 403  * The given list replaces any existing list. Clears the last 15 receive
 404  * address registers and the multicast table. Uses receive address registers
 405  * for the first 15 multicast addresses, and hashes the rest into the
 406  * multicast table.
 407  *****************************************************************************/
 408 void
 409 ixgb_mc_addr_list_update(struct ixgb_hw *hw,
 410                           u8 *mc_addr_list,
 411                           u32 mc_addr_count,
 412                           u32 pad)
 413 {
 414         u32 hash_value;
 415         u32 i;
 416         u32 rar_used_count = 1;         /* RAR[0] is used for our MAC address */
 417         u8 *mca;
 418
 419         ENTER();
 420
 421         /* Set the new number of MC addresses that we are being requested to use. */
 422         hw->num_mc_addrs = mc_addr_count;
 423
 424         /* Clear RAR[1-15] */
 425         pr_debug("Clearing RAR[1-15]\n");
 426         for (i = rar_used_count; i < IXGB_RAR_ENTRIES; i++) {
 427                 IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
 428                 IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
 429         }
 430
 431         /* Clear the MTA */
 432         pr_debug("Clearing MTA\n");
 433         for (i = 0; i < IXGB_MC_TBL_SIZE; i++)
 434                 IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
 435
 436         /* Add the new addresses */
 437         mca = mc_addr_list;
 438         for (i = 0; i < mc_addr_count; i++) {
 439                 pr_debug("Adding the multicast addresses:\n");
 440                 pr_debug("MC Addr #%d = %pM\n", i, mca);
 441
 442                 /* Place this multicast address in the RAR if there is room, *
 443                  * else put it in the MTA
 444                  */
 445                 if (rar_used_count < IXGB_RAR_ENTRIES) {
 446                         ixgb_rar_set(hw, mca, rar_used_count);
 447                         pr_debug("Added a multicast address to RAR[%d]\n", i);
 448                         rar_used_count++;
 449                 } else {
 450                         hash_value = ixgb_hash_mc_addr(hw, mca);
 451
 452                         pr_debug("Hash value = 0x%03X\n", hash_value);
 453
 454                         ixgb_mta_set(hw, hash_value);
 455                 }
 456
 457                 mca += ETH_ALEN + pad;
 458         }
 459
 460         pr_debug("MC Update Complete\n");
 461 }
 462
 463 /******************************************************************************
 464  * Hashes an address to determine its location in the multicast table
 465  *
 466  * hw - Struct containing variables accessed by shared code
 467  * mc_addr - the multicast address to hash
 468  *
 469  * Returns:
 470  *      The hash value
 471  *****************************************************************************/
 472 static u32
 473 ixgb_hash_mc_addr(struct ixgb_hw *hw,
 474                    u8 *mc_addr)
 475 {
 476         u32 hash_value = 0;
 477
 478         ENTER();
 479
 480         /* The portion of the address that is used for the hash table is
 481          * determined by the mc_filter_type setting.
 482          */
 483         switch (hw->mc_filter_type) {
 484                 /* [0] [1] [2] [3] [4] [5]
 485                  * 01  AA  00  12  34  56
 486                  * LSB                 MSB - According to H/W docs */
 487         case 0:
 488                 /* [47:36] i.e. 0x563 for above example address */
 489                 hash_value =
 490                     ((mc_addr[4] >> 4) | (((u16) mc_addr[5]) << 4));
 491                 break;
 492         case 1:         /* [46:35] i.e. 0xAC6 for above example address */
 493                 hash_value =
 494                     ((mc_addr[4] >> 3) | (((u16) mc_addr[5]) << 5));
 495                 break;
 496         case 2:         /* [45:34] i.e. 0x5D8 for above example address */
 497                 hash_value =
 498                     ((mc_addr[4] >> 2) | (((u16) mc_addr[5]) << 6));
 499                 break;
 500         case 3:         /* [43:32] i.e. 0x634 for above example address */
 501                 hash_value = ((mc_addr[4]) | (((u16) mc_addr[5]) << 8));
 502                 break;
 503         default:
 504                 /* Invalid mc_filter_type, what should we do? */
 505                 pr_debug("MC filter type param set incorrectly\n");
 506                 ASSERT(0);
 507                 break;
 508         }
 509
 510         hash_value &= 0xFFF;
 511         return hash_value;
 512 }
 513
 514 /******************************************************************************
 515  * Sets the bit in the multicast table corresponding to the hash value.
 516  *
 517  * hw - Struct containing variables accessed by shared code
 518  * hash_value - Multicast address hash value
 519  *****************************************************************************/
 520 static void
 521 ixgb_mta_set(struct ixgb_hw *hw,
 522                   u32 hash_value)
 523 {
 524         u32 hash_bit, hash_reg;
 525         u32 mta_reg;
 526
 527         /* The MTA is a register array of 128 32-bit registers.
 528          * It is treated like an array of 4096 bits.  We want to set
 529          * bit BitArray[hash_value]. So we figure out what register
 530          * the bit is in, read it, OR in the new bit, then write
 531          * back the new value.  The register is determined by the
 532          * upper 7 bits of the hash value and the bit within that
 533          * register are determined by the lower 5 bits of the value.
 534          */
 535         hash_reg = (hash_value >> 5) & 0x7F;
 536         hash_bit = hash_value & 0x1F;
 537
 538         mta_reg = IXGB_READ_REG_ARRAY(hw, MTA, hash_reg);
 539
 540         mta_reg |= (1 << hash_bit);
 541
 542         IXGB_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta_reg);
 543 }
 544
 545 /******************************************************************************
 546  * Puts an ethernet address into a receive address register.
 547  *
 548  * hw - Struct containing variables accessed by shared code
 549  * addr - Address to put into receive address register
 550  * index - Receive address register to write
 551  *****************************************************************************/
 552 void
 553 ixgb_rar_set(struct ixgb_hw *hw,
 554                   u8 *addr,
 555                   u32 index)
 556 {
 557         u32 rar_low, rar_high;
 558
 559         ENTER();
 560
 561         /* HW expects these in little endian so we reverse the byte order
 562          * from network order (big endian) to little endian
 563          */
 564         rar_low = ((u32) addr[0] |
 565                    ((u32)addr[1] << 8) |
 566                    ((u32)addr[2] << 16) |
 567                    ((u32)addr[3] << 24));
 568
 569         rar_high = ((u32) addr[4] |
 570                         ((u32)addr[5] << 8) |
 571                         IXGB_RAH_AV);
 572
 573         IXGB_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
 574         IXGB_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
 575 }
 576
 577 /******************************************************************************
 578  * Writes a value to the specified offset in the VLAN filter table.
 579  *
 580  * hw - Struct containing variables accessed by shared code
 581  * offset - Offset in VLAN filer table to write
 582  * value - Value to write into VLAN filter table
 583  *****************************************************************************/
 584 void
 585 ixgb_write_vfta(struct ixgb_hw *hw,
 586                  u32 offset,
 587                  u32 value)
 588 {
 589         IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, value);
 590 }
 591
 592 /******************************************************************************
 593  * Clears the VLAN filer table
 594  *
 595  * hw - Struct containing variables accessed by shared code
 596  *****************************************************************************/
 597 static void
 598 ixgb_clear_vfta(struct ixgb_hw *hw)
 599 {
 600         u32 offset;
 601
 602         for (offset = 0; offset < IXGB_VLAN_FILTER_TBL_SIZE; offset++)
 603                 IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, 0);
 604 }
 605
 606 /******************************************************************************
 607  * Configures the flow control settings based on SW configuration.
 608  *
 609  * hw - Struct containing variables accessed by shared code
 610  *****************************************************************************/
 611
 612 static bool
 613 ixgb_setup_fc(struct ixgb_hw *hw)
 614 {
 615         u32 ctrl_reg;
 616         u32 pap_reg = 0;   /* by default, assume no pause time */
 617         bool status = true;
 618
 619         ENTER();
 620
 621         /* Get the current control reg 0 settings */
 622         ctrl_reg = IXGB_READ_REG(hw, CTRL0);
 623
 624         /* Clear the Receive Pause Enable and Transmit Pause Enable bits */
 625         ctrl_reg &= ~(IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
 626
 627         /* The possible values of the "flow_control" parameter are:
 628          *      0:  Flow control is completely disabled
 629          *      1:  Rx flow control is enabled (we can receive pause frames
 630          *          but not send pause frames).
 631          *      2:  Tx flow control is enabled (we can send pause frames
 632          *          but we do not support receiving pause frames).
 633          *      3:  Both Rx and TX flow control (symmetric) are enabled.
 634          *  other:  Invalid.
 635          */
 636         switch (hw->fc.type) {
 637         case ixgb_fc_none:      /* 0 */
 638                 /* Set CMDC bit to disable Rx Flow control */
 639                 ctrl_reg |= (IXGB_CTRL0_CMDC);
 640                 break;
 641         case ixgb_fc_rx_pause:  /* 1 */
 642                 /* RX Flow control is enabled, and TX Flow control is
 643                  * disabled.
 644                  */
 645                 ctrl_reg |= (IXGB_CTRL0_RPE);
 646                 break;
 647         case ixgb_fc_tx_pause:  /* 2 */
 648                 /* TX Flow control is enabled, and RX Flow control is
 649                  * disabled, by a software over-ride.
 650                  */
 651                 ctrl_reg |= (IXGB_CTRL0_TPE);
 652                 pap_reg = hw->fc.pause_time;
 653                 break;
 654         case ixgb_fc_full:      /* 3 */
 655                 /* Flow control (both RX and TX) is enabled by a software
 656                  * over-ride.
 657                  */
 658                 ctrl_reg |= (IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
 659                 pap_reg = hw->fc.pause_time;
 660                 break;
 661         default:
 662                 /* We should never get here.  The value should be 0-3. */
 663                 pr_debug("Flow control param set incorrectly\n");
 664                 ASSERT(0);
 665                 break;
 666         }
 667
 668         /* Write the new settings */
 669         IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
 670
 671         if (pap_reg != 0)
 672                 IXGB_WRITE_REG(hw, PAP, pap_reg);
 673
 674         /* Set the flow control receive threshold registers.  Normally,
 675          * these registers will be set to a default threshold that may be
 676          * adjusted later by the driver's runtime code.  However, if the
 677          * ability to transmit pause frames in not enabled, then these
 678          * registers will be set to 0.
 679          */
 680         if (!(hw->fc.type & ixgb_fc_tx_pause)) {
 681                 IXGB_WRITE_REG(hw, FCRTL, 0);
 682                 IXGB_WRITE_REG(hw, FCRTH, 0);
 683         } else {
 684            /* We need to set up the Receive Threshold high and low water
 685             * marks as well as (optionally) enabling the transmission of XON
 686             * frames. */
 687                 if (hw->fc.send_xon) {
 688                         IXGB_WRITE_REG(hw, FCRTL,
 689                                 (hw->fc.low_water | IXGB_FCRTL_XONE));
 690                 } else {
 691                         IXGB_WRITE_REG(hw, FCRTL, hw->fc.low_water);
 692                 }
 693                 IXGB_WRITE_REG(hw, FCRTH, hw->fc.high_water);
 694         }
 695         return status;
 696 }
 697
 698 /******************************************************************************
 699  * Reads a word from a device over the Management Data Interface (MDI) bus.
 700  * This interface is used to manage Physical layer devices.
 701  *
 702  * hw          - Struct containing variables accessed by hw code
 703  * reg_address - Offset of device register being read.
 704  * phy_address - Address of device on MDI.
 705  *
 706  * Returns:  Data word (16 bits) from MDI device.
 707  *
 708  * The 82597EX has support for several MDI access methods.  This routine
 709  * uses the new protocol MDI Single Command and Address Operation.
 710  * This requires that first an address cycle command is sent, followed by a
 711  * read command.
 712  *****************************************************************************/
 713 static u16
 714 ixgb_read_phy_reg(struct ixgb_hw *hw,
 715                 u32 reg_address,
 716                 u32 phy_address,
 717                 u32 device_type)
 718 {
 719         u32 i;
 720         u32 data;
 721         u32 command = 0;
 722
 723         ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
 724         ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
 725         ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
 726
 727         /* Setup and write the address cycle command */
 728         command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
 729                    (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
 730                    (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
 731                    (IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
 732
 733         IXGB_WRITE_REG(hw, MSCA, command);
 734
 735     /**************************************************************
 736     ** Check every 10 usec to see if the address cycle completed
 737     ** The COMMAND bit will clear when the operation is complete.
 738     ** This may take as long as 64 usecs (we'll wait 100 usecs max)
 739     ** from the CPU Write to the Ready bit assertion.
 740     **************************************************************/
 741
 742         for (i = 0; i < 10; i++)
 743         {
 744                 udelay(10);
 745
 746                 command = IXGB_READ_REG(hw, MSCA);
 747
 748                 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
 749                         break;
 750         }
 751
 752         ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
 753
 754         /* Address cycle complete, setup and write the read command */
 755         command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
 756                    (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
 757                    (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
 758                    (IXGB_MSCA_READ | IXGB_MSCA_MDI_COMMAND));
 759
 760         IXGB_WRITE_REG(hw, MSCA, command);
 761
 762     /**************************************************************
 763     ** Check every 10 usec to see if the read command completed
 764     ** The COMMAND bit will clear when the operation is complete.
 765     ** The read may take as long as 64 usecs (we'll wait 100 usecs max)
 766     ** from the CPU Write to the Ready bit assertion.
 767     **************************************************************/
 768
 769         for (i = 0; i < 10; i++)
 770         {
 771                 udelay(10);
 772
 773                 command = IXGB_READ_REG(hw, MSCA);
 774
 775                 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
 776                         break;
 777         }
 778
 779         ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
 780
 781         /* Operation is complete, get the data from the MDIO Read/Write Data
 782          * register and return.
 783          */
 784         data = IXGB_READ_REG(hw, MSRWD);
 785         data >>= IXGB_MSRWD_READ_DATA_SHIFT;
 786         return((u16) data);
 787 }
 788
 789 /******************************************************************************
 790  * Writes a word to a device over the Management Data Interface (MDI) bus.
 791  * This interface is used to manage Physical layer devices.
 792  *
 793  * hw          - Struct containing variables accessed by hw code
 794  * reg_address - Offset of device register being read.
 795  * phy_address - Address of device on MDI.
 796  * device_type - Also known as the Device ID or DID.
 797  * data        - 16-bit value to be written
 798  *
 799  * Returns:  void.
 800  *
 801  * The 82597EX has support for several MDI access methods.  This routine
 802  * uses the new protocol MDI Single Command and Address Operation.
 803  * This requires that first an address cycle command is sent, followed by a
 804  * write command.
 805  *****************************************************************************/
 806 static void
 807 ixgb_write_phy_reg(struct ixgb_hw *hw,
 808                         u32 reg_address,
 809                         u32 phy_address,
 810                         u32 device_type,
 811                         u16 data)
 812 {
 813         u32 i;
 814         u32 command = 0;
 815
 816         ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
 817         ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
 818         ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
 819
 820         /* Put the data in the MDIO Read/Write Data register */
 821         IXGB_WRITE_REG(hw, MSRWD, (u32)data);
 822
 823         /* Setup and write the address cycle command */
 824         command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT)  |
 825                            (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
 826                            (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
 827                            (IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
 828
 829         IXGB_WRITE_REG(hw, MSCA, command);
 830
 831         /**************************************************************
 832         ** Check every 10 usec to see if the address cycle completed
 833         ** The COMMAND bit will clear when the operation is complete.
 834         ** This may take as long as 64 usecs (we'll wait 100 usecs max)
 835         ** from the CPU Write to the Ready bit assertion.
 836         **************************************************************/
 837
 838         for (i = 0; i < 10; i++)
 839         {
 840                 udelay(10);
 841
 842                 command = IXGB_READ_REG(hw, MSCA);
 843
 844                 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
 845                         break;
 846         }
 847
 848         ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
 849
 850         /* Address cycle complete, setup and write the write command */
 851         command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT)  |
 852                            (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
 853                            (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
 854                            (IXGB_MSCA_WRITE | IXGB_MSCA_MDI_COMMAND));
 855
 856         IXGB_WRITE_REG(hw, MSCA, command);
 857
 858         /**************************************************************
 859         ** Check every 10 usec to see if the read command completed
 860         ** The COMMAND bit will clear when the operation is complete.
 861         ** The write may take as long as 64 usecs (we'll wait 100 usecs max)
 862         ** from the CPU Write to the Ready bit assertion.
 863         **************************************************************/
 864
 865         for (i = 0; i < 10; i++)
 866         {
 867                 udelay(10);
 868
 869                 command = IXGB_READ_REG(hw, MSCA);
 870
 871                 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
 872                         break;
 873         }
 874
 875         ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
 876
 877         /* Operation is complete, return. */
 878 }
 879
 880 /******************************************************************************
 881  * Checks to see if the link status of the hardware has changed.
 882  *
 883  * hw - Struct containing variables accessed by hw code
 884  *
 885  * Called by any function that needs to check the link status of the adapter.
 886  *****************************************************************************/
 887 void
 888 ixgb_check_for_link(struct ixgb_hw *hw)
 889 {
 890         u32 status_reg;
 891         u32 xpcss_reg;
 892
 893         ENTER();
 894
 895         xpcss_reg = IXGB_READ_REG(hw, XPCSS);
 896         status_reg = IXGB_READ_REG(hw, STATUS);
 897
 898         if ((xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
 899             (status_reg & IXGB_STATUS_LU)) {
 900                 hw->link_up = true;
 901         } else if (!(xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
 902                    (status_reg & IXGB_STATUS_LU)) {
 903                 pr_debug("XPCSS Not Aligned while Status:LU is set\n");
 904                 hw->link_up = ixgb_link_reset(hw);
 905         } else {
 906                 /*
 907                  * 82597EX errata.  Since the lane deskew problem may prevent
 908                  * link, reset the link before reporting link down.
 909                  */
 910                 hw->link_up = ixgb_link_reset(hw);
 911         }
 912         /*  Anything else for 10 Gig?? */
 913 }
 914
 915 /******************************************************************************
 916  * Check for a bad link condition that may have occurred.
 917  * The indication is that the RFC / LFC registers may be incrementing
 918  * continually.  A full adapter reset is required to recover.
 919  *
 920  * hw - Struct containing variables accessed by hw code
 921  *
 922  * Called by any function that needs to check the link status of the adapter.
 923  *****************************************************************************/
 924 bool ixgb_check_for_bad_link(struct ixgb_hw *hw)
 925 {
 926         u32 newLFC, newRFC;
 927         bool bad_link_returncode = false;
 928
 929         if (hw->phy_type == ixgb_phy_type_txn17401) {
 930                 newLFC = IXGB_READ_REG(hw, LFC);
 931                 newRFC = IXGB_READ_REG(hw, RFC);
 932                 if ((hw->lastLFC + 250 < newLFC)
 933                     || (hw->lastRFC + 250 < newRFC)) {
 934                         pr_debug("BAD LINK! too many LFC/RFC since last check\n");
 935                         bad_link_returncode = true;
 936                 }
 937                 hw->lastLFC = newLFC;
 938                 hw->lastRFC = newRFC;
 939         }
 940
 941         return bad_link_returncode;
 942 }
 943
 944 /******************************************************************************
 945  * Clears all hardware statistics counters.
 946  *
 947  * hw - Struct containing variables accessed by shared code
 948  *****************************************************************************/
 949 static void
 950 ixgb_clear_hw_cntrs(struct ixgb_hw *hw)
 951 {
 952         volatile u32 temp_reg;
 953
 954         ENTER();
 955
 956         /* if we are stopped or resetting exit gracefully */
 957         if (hw->adapter_stopped) {
 958                 pr_debug("Exiting because the adapter is stopped!!!\n");
 959                 return;
 960         }
 961
 962         temp_reg = IXGB_READ_REG(hw, TPRL);
 963         temp_reg = IXGB_READ_REG(hw, TPRH);
 964         temp_reg = IXGB_READ_REG(hw, GPRCL);
 965         temp_reg = IXGB_READ_REG(hw, GPRCH);
 966         temp_reg = IXGB_READ_REG(hw, BPRCL);
 967         temp_reg = IXGB_READ_REG(hw, BPRCH);
 968         temp_reg = IXGB_READ_REG(hw, MPRCL);
 969         temp_reg = IXGB_READ_REG(hw, MPRCH);
 970         temp_reg = IXGB_READ_REG(hw, UPRCL);
 971         temp_reg = IXGB_READ_REG(hw, UPRCH);
 972         temp_reg = IXGB_READ_REG(hw, VPRCL);
 973         temp_reg = IXGB_READ_REG(hw, VPRCH);
 974         temp_reg = IXGB_READ_REG(hw, JPRCL);
 975         temp_reg = IXGB_READ_REG(hw, JPRCH);
 976         temp_reg = IXGB_READ_REG(hw, GORCL);
 977         temp_reg = IXGB_READ_REG(hw, GORCH);
 978         temp_reg = IXGB_READ_REG(hw, TORL);
 979         temp_reg = IXGB_READ_REG(hw, TORH);
 980         temp_reg = IXGB_READ_REG(hw, RNBC);
 981         temp_reg = IXGB_READ_REG(hw, RUC);
 982         temp_reg = IXGB_READ_REG(hw, ROC);
 983         temp_reg = IXGB_READ_REG(hw, RLEC);
 984         temp_reg = IXGB_READ_REG(hw, CRCERRS);
 985         temp_reg = IXGB_READ_REG(hw, ICBC);
 986         temp_reg = IXGB_READ_REG(hw, ECBC);
 987         temp_reg = IXGB_READ_REG(hw, MPC);
 988         temp_reg = IXGB_READ_REG(hw, TPTL);
 989         temp_reg = IXGB_READ_REG(hw, TPTH);
 990         temp_reg = IXGB_READ_REG(hw, GPTCL);
 991         temp_reg = IXGB_READ_REG(hw, GPTCH);
 992         temp_reg = IXGB_READ_REG(hw, BPTCL);
 993         temp_reg = IXGB_READ_REG(hw, BPTCH);
 994         temp_reg = IXGB_READ_REG(hw, MPTCL);
 995         temp_reg = IXGB_READ_REG(hw, MPTCH);
 996         temp_reg = IXGB_READ_REG(hw, UPTCL);
 997         temp_reg = IXGB_READ_REG(hw, UPTCH);
 998         temp_reg = IXGB_READ_REG(hw, VPTCL);
 999         temp_reg = IXGB_READ_REG(hw, VPTCH);
1000         temp_reg = IXGB_READ_REG(hw, JPTCL);
1001         temp_reg = IXGB_READ_REG(hw, JPTCH);
1002         temp_reg = IXGB_READ_REG(hw, GOTCL);
1003         temp_reg = IXGB_READ_REG(hw, GOTCH);
1004         temp_reg = IXGB_READ_REG(hw, TOTL);
1005         temp_reg = IXGB_READ_REG(hw, TOTH);
1006         temp_reg = IXGB_READ_REG(hw, DC);
1007         temp_reg = IXGB_READ_REG(hw, PLT64C);
1008         temp_reg = IXGB_READ_REG(hw, TSCTC);
1009         temp_reg = IXGB_READ_REG(hw, TSCTFC);
1010         temp_reg = IXGB_READ_REG(hw, IBIC);
1011         temp_reg = IXGB_READ_REG(hw, RFC);
1012         temp_reg = IXGB_READ_REG(hw, LFC);
1013         temp_reg = IXGB_READ_REG(hw, PFRC);
1014         temp_reg = IXGB_READ_REG(hw, PFTC);
1015         temp_reg = IXGB_READ_REG(hw, MCFRC);
1016         temp_reg = IXGB_READ_REG(hw, MCFTC);
1017         temp_reg = IXGB_READ_REG(hw, XONRXC);
1018         temp_reg = IXGB_READ_REG(hw, XONTXC);
1019         temp_reg = IXGB_READ_REG(hw, XOFFRXC);
1020         temp_reg = IXGB_READ_REG(hw, XOFFTXC);
1021         temp_reg = IXGB_READ_REG(hw, RJC);
1022 }
1023
1024 /******************************************************************************
1025  * Turns on the software controllable LED
1026  *
1027  * hw - Struct containing variables accessed by shared code
1028  *****************************************************************************/
1029 void
1030 ixgb_led_on(struct ixgb_hw *hw)
1031 {
1032         u32 ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
1033
1034         /* To turn on the LED, clear software-definable pin 0 (SDP0). */
1035         ctrl0_reg &= ~IXGB_CTRL0_SDP0;
1036         IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
1037 }
1038
1039 /******************************************************************************
1040  * Turns off the software controllable LED
1041  *
1042  * hw - Struct containing variables accessed by shared code
1043  *****************************************************************************/
1044 void
1045 ixgb_led_off(struct ixgb_hw *hw)
1046 {
1047         u32 ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
1048
1049         /* To turn off the LED, set software-definable pin 0 (SDP0). */
1050         ctrl0_reg |= IXGB_CTRL0_SDP0;
1051         IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
1052 }
1053
1054 /******************************************************************************
1055  * Gets the current PCI bus type, speed, and width of the hardware
1056  *
1057  * hw - Struct containing variables accessed by shared code
1058  *****************************************************************************/
1059 static void
1060 ixgb_get_bus_info(struct ixgb_hw *hw)
1061 {
1062         u32 status_reg;
1063
1064         status_reg = IXGB_READ_REG(hw, STATUS);
1065
1066         hw->bus.type = (status_reg & IXGB_STATUS_PCIX_MODE) ?
1067                 ixgb_bus_type_pcix : ixgb_bus_type_pci;
1068
1069         if (hw->bus.type == ixgb_bus_type_pci) {
1070                 hw->bus.speed = (status_reg & IXGB_STATUS_PCI_SPD) ?
1071                         ixgb_bus_speed_66 : ixgb_bus_speed_33;
1072         } else {
1073                 switch (status_reg & IXGB_STATUS_PCIX_SPD_MASK) {
1074                 case IXGB_STATUS_PCIX_SPD_66:
1075                         hw->bus.speed = ixgb_bus_speed_66;
1076                         break;
1077                 case IXGB_STATUS_PCIX_SPD_100:
1078                         hw->bus.speed = ixgb_bus_speed_100;
1079                         break;
1080                 case IXGB_STATUS_PCIX_SPD_133:
1081                         hw->bus.speed = ixgb_bus_speed_133;
1082                         break;
1083                 default:
1084                         hw->bus.speed = ixgb_bus_speed_reserved;
1085                         break;
1086                 }
1087         }
1088
1089         hw->bus.width = (status_reg & IXGB_STATUS_BUS64) ?
1090                 ixgb_bus_width_64 : ixgb_bus_width_32;
1091 }
1092
1093 /******************************************************************************
1094  * Tests a MAC address to ensure it is a valid Individual Address
1095  *
1096  * mac_addr - pointer to MAC address.
1097  *
1098  *****************************************************************************/
1099 static bool
1100 mac_addr_valid(u8 *mac_addr)
1101 {
1102         bool is_valid = true;
1103         ENTER();
1104
1105         /* Make sure it is not a multicast address */
1106         if (is_multicast_ether_addr(mac_addr)) {
1107                 pr_debug("MAC address is multicast\n");
1108                 is_valid = false;
1109         }
1110         /* Not a broadcast address */
1111         else if (is_broadcast_ether_addr(mac_addr)) {
1112                 pr_debug("MAC address is broadcast\n");
1113                 is_valid = false;
1114         }
1115         /* Reject the zero address */
1116         else if (is_zero_ether_addr(mac_addr)) {
1117                 pr_debug("MAC address is all zeros\n");
1118                 is_valid = false;
1119         }
1120         return is_valid;
1121 }
1122
1123 /******************************************************************************
1124  * Resets the 10GbE link.  Waits the settle time and returns the state of
1125  * the link.
1126  *
1127  * hw - Struct containing variables accessed by shared code
1128  *****************************************************************************/
1129 static bool
1130 ixgb_link_reset(struct ixgb_hw *hw)
1131 {
1132         bool link_status = false;
1133         u8 wait_retries = MAX_RESET_ITERATIONS;
1134         u8 lrst_retries = MAX_RESET_ITERATIONS;
1135
1136         do {
1137                 /* Reset the link */
1138                 IXGB_WRITE_REG(hw, CTRL0,
1139                                IXGB_READ_REG(hw, CTRL0) | IXGB_CTRL0_LRST);
1140
1141                 /* Wait for link-up and lane re-alignment */
1142                 do {
1143                         udelay(IXGB_DELAY_USECS_AFTER_LINK_RESET);
1144                         link_status =
1145                             ((IXGB_READ_REG(hw, STATUS) & IXGB_STATUS_LU)
1146                              && (IXGB_READ_REG(hw, XPCSS) &
1147                                  IXGB_XPCSS_ALIGN_STATUS)) ? true : false;
1148                 } while (!link_status && --wait_retries);
1149
1150         } while (!link_status && --lrst_retries);
1151
1152         return link_status;
1153 }
1154
1155 /******************************************************************************
1156  * Resets the 10GbE optics module.
1157  *
1158  * hw - Struct containing variables accessed by shared code
1159  *****************************************************************************/
1160 static void
1161 ixgb_optics_reset(struct ixgb_hw *hw)
1162 {
1163         if (hw->phy_type == ixgb_phy_type_txn17401) {
1164                 u16 mdio_reg;
1165
1166                 ixgb_write_phy_reg(hw,
1167                                    MDIO_CTRL1,
1168                                    IXGB_PHY_ADDRESS,
1169                                    MDIO_MMD_PMAPMD,
1170                                    MDIO_CTRL1_RESET);
1171
1172                 mdio_reg = ixgb_read_phy_reg(hw,
1173                                              MDIO_CTRL1,
1174                                              IXGB_PHY_ADDRESS,
1175                                              MDIO_MMD_PMAPMD);
1176         }
1177 }
1178
1179 /******************************************************************************
1180  * Resets the 10GbE optics module for Sun variant NIC.
1181  *
1182  * hw - Struct containing variables accessed by shared code
1183  *****************************************************************************/
1184
1185 #define   IXGB_BCM8704_USER_PMD_TX_CTRL_REG         0xC803
1186 #define   IXGB_BCM8704_USER_PMD_TX_CTRL_REG_VAL     0x0164
1187 #define   IXGB_BCM8704_USER_CTRL_REG                0xC800
1188 #define   IXGB_BCM8704_USER_CTRL_REG_VAL            0x7FBF
1189 #define   IXGB_BCM8704_USER_DEV3_ADDR               0x0003
1190 #define   IXGB_SUN_PHY_ADDRESS                      0x0000
1191 #define   IXGB_SUN_PHY_RESET_DELAY                     305
1192
1193 static void
1194 ixgb_optics_reset_bcm(struct ixgb_hw *hw)
1195 {
1196         u32 ctrl = IXGB_READ_REG(hw, CTRL0);
1197         ctrl &= ~IXGB_CTRL0_SDP2;
1198         ctrl |= IXGB_CTRL0_SDP3;
1199         IXGB_WRITE_REG(hw, CTRL0, ctrl);
1200         IXGB_WRITE_FLUSH(hw);
1201
1202         /* SerDes needs extra delay */
1203         msleep(IXGB_SUN_PHY_RESET_DELAY);
1204
1205         /* Broadcom 7408L configuration */
1206         /* Reference clock config */
1207         ixgb_write_phy_reg(hw,
1208                            IXGB_BCM8704_USER_PMD_TX_CTRL_REG,
1209                            IXGB_SUN_PHY_ADDRESS,
1210                            IXGB_BCM8704_USER_DEV3_ADDR,
1211                            IXGB_BCM8704_USER_PMD_TX_CTRL_REG_VAL);
1212         /*  we must read the registers twice */
1213         ixgb_read_phy_reg(hw,
1214                           IXGB_BCM8704_USER_PMD_TX_CTRL_REG,
1215                           IXGB_SUN_PHY_ADDRESS,
1216                           IXGB_BCM8704_USER_DEV3_ADDR);
1217         ixgb_read_phy_reg(hw,
1218                           IXGB_BCM8704_USER_PMD_TX_CTRL_REG,
1219                           IXGB_SUN_PHY_ADDRESS,
1220                           IXGB_BCM8704_USER_DEV3_ADDR);
1221
1222         ixgb_write_phy_reg(hw,
1223                            IXGB_BCM8704_USER_CTRL_REG,
1224                            IXGB_SUN_PHY_ADDRESS,
1225                            IXGB_BCM8704_USER_DEV3_ADDR,
1226                            IXGB_BCM8704_USER_CTRL_REG_VAL);
1227         ixgb_read_phy_reg(hw,
1228                           IXGB_BCM8704_USER_CTRL_REG,
1229                           IXGB_SUN_PHY_ADDRESS,
1230                           IXGB_BCM8704_USER_DEV3_ADDR);
1231         ixgb_read_phy_reg(hw,
1232                           IXGB_BCM8704_USER_CTRL_REG,
1233                           IXGB_SUN_PHY_ADDRESS,
1234                           IXGB_BCM8704_USER_DEV3_ADDR);
1235
1236         /* SerDes needs extra delay */
1237         msleep(IXGB_SUN_PHY_RESET_DELAY);
1238 }