1 /*******************************************************************************
3 Copyright (c) 2001-2004, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
32 *******************************************************************************/
37 * Shared functions for accessing and configuring the adapter
40 #include <dev/ixgb/ixgb_hw.h>
41 #include <dev/ixgb/ixgb_ids.h>
43 /* Local function prototypes */
45 static uint32_t ixgb_hash_mc_addr(struct ixgb_hw *hw,
48 static void ixgb_mta_set(struct ixgb_hw *hw,
51 static void ixgb_get_bus_info(struct ixgb_hw *hw);
53 static boolean_t ixgb_link_reset(struct ixgb_hw *hw);
55 static void ixgb_optics_reset(struct ixgb_hw *hw);
57 static ixgb_phy_type ixgb_identify_phy(struct ixgb_hw *hw);
59 uint32_t ixgb_mac_reset (struct ixgb_hw* hw);
61 uint32_t ixgb_mac_reset (struct ixgb_hw* hw)
65 /* Setup up hardware to known state with RESET.
66 * SWDPIN settings as per Kemano EPS.
68 ctrl_reg = IXGB_CTRL0_RST |
69 IXGB_CTRL0_SDP3_DIR | /* All pins are Output=1 */
73 IXGB_CTRL0_SDP3 | /* Initial value 1101 */
78 /* Workaround for 82597EX reset errata */
79 IXGB_WRITE_REG_IO(hw, CTRL0, ctrl_reg);
81 IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
84 /* Delay a few ms just to allow the reset to complete */
85 msec_delay(IXGB_DELAY_AFTER_RESET);
86 ctrl_reg = IXGB_READ_REG(hw, CTRL0);
88 /* Make sure the self-clearing global reset bit did self clear */
89 ASSERT(!(ctrl_reg & IXGB_CTRL0_RST));
92 if (hw->phy_type == ixgb_phy_type_txn17401) {
93 /* Now reset the optics. This reset is required to ensure link with
94 * the Kemano 003 optical module (TXN17401), as per instructions from
97 ixgb_optics_reset(hw);
104 /******************************************************************************
105 * Reset the transmit and receive units; mask and clear all interrupts.
107 * hw - Struct containing variables accessed by shared code
108 *****************************************************************************/
110 ixgb_adapter_stop(struct ixgb_hw *hw)
115 DEBUGFUNC("ixgb_adapter_stop");
117 /* If we are stopped or resetting exit gracefully and wait to be
118 * started again before accessing the hardware.
120 if(hw->adapter_stopped) {
121 DEBUGOUT("Exiting because the adapter is already stopped!!!\n");
125 /* Set the Adapter Stopped flag so other driver functions stop
126 * touching the Hardware.
128 hw->adapter_stopped = TRUE;
130 /* Clear interrupt mask to stop board from generating interrupts */
131 DEBUGOUT("Masking off all interrupts\n");
132 IXGB_WRITE_REG(hw, IMC, 0xFFFFFFFF);
134 /* Disable the Transmit and Receive units. Then delay to allow
135 * any pending transactions to complete before we hit the MAC with
138 IXGB_WRITE_REG(hw, RCTL, IXGB_READ_REG(hw, RCTL) & ~IXGB_RCTL_RXEN);
139 IXGB_WRITE_REG(hw, TCTL, IXGB_READ_REG(hw, TCTL) & ~IXGB_TCTL_TXEN);
140 msec_delay(IXGB_DELAY_BEFORE_RESET);
142 /* Issue a global reset to the MAC. This will reset the chip's
143 * transmit, receive, DMA, and link units. It will not effect
144 * the current PCI configuration. The global reset bit is self-
145 * clearing, and should clear within a microsecond.
147 DEBUGOUT("Issuing a global reset to MAC\n");
149 ctrl_reg = ixgb_mac_reset(hw);
151 /* Clear interrupt mask to stop board from generating interrupts */
152 DEBUGOUT("Masking off all interrupts\n");
153 IXGB_WRITE_REG(hw, IMC, 0xffffffff);
155 /* Clear any pending interrupt events. */
156 icr_reg = IXGB_READ_REG(hw, ICR);
158 return (ctrl_reg & IXGB_CTRL0_RST);
162 /******************************************************************************
163 * Identifies the vendor of the optics module on the adapter. The SR adapters
164 * support two different types of XPAK optics, so it is necessary to determine
165 * which optics are present before applying any optics-specific workarounds.
167 * hw - Struct containing variables accessed by shared code.
169 * Returns: the vendor of the XPAK optics module.
170 *****************************************************************************/
171 static ixgb_xpak_vendor
172 ixgb_identify_xpak_vendor(struct ixgb_hw *hw)
175 uint16_t vendor_name[5];
176 ixgb_xpak_vendor xpak_vendor;
178 DEBUGFUNC("ixgb_identify_xpak_vendor");
180 /* Read the first few bytes of the vendor string from the XPAK NVR
181 * registers. These are standard XENPAK/XPAK registers, so all XPAK
182 * devices should implement them. */
183 for (i = 0; i < 5; i++) {
184 vendor_name[i] = ixgb_read_phy_reg( hw,
185 MDIO_PMA_PMD_XPAK_VENDOR_NAME + i,
190 /* Determine the actual vendor */
191 if (vendor_name[0] == 'I' &&
192 vendor_name[1] == 'N' &&
193 vendor_name[2] == 'T' &&
194 vendor_name[3] == 'E' &&
195 vendor_name[4] == 'L') {
196 xpak_vendor = ixgb_xpak_vendor_intel;
199 xpak_vendor = ixgb_xpak_vendor_infineon;
202 return (xpak_vendor);
206 /******************************************************************************
207 * Determine the physical layer module on the adapter.
209 * hw - Struct containing variables accessed by shared code. The device_id
210 * field must be (correctly) populated before calling this routine.
212 * Returns: the phy type of the adapter.
213 *****************************************************************************/
215 ixgb_identify_phy(struct ixgb_hw *hw)
217 ixgb_phy_type phy_type;
218 ixgb_xpak_vendor xpak_vendor;
220 DEBUGFUNC("ixgb_identify_phy");
222 /* Infer the transceiver/phy type from the device id */
223 switch (hw->device_id) {
224 case IXGB_DEVICE_ID_82597EX:
225 DEBUGOUT("Identified TXN17401 optics\n");
226 phy_type = ixgb_phy_type_txn17401;
229 case IXGB_DEVICE_ID_82597EX_SR:
230 /* The SR adapters carry two different types of XPAK optics
231 * modules; read the vendor identifier to determine the exact
233 xpak_vendor = ixgb_identify_xpak_vendor(hw);
234 if (xpak_vendor == ixgb_xpak_vendor_intel) {
235 DEBUGOUT("Identified TXN17201 optics\n");
236 phy_type = ixgb_phy_type_txn17201;
239 DEBUGOUT("Identified G6005 optics\n");
240 phy_type = ixgb_phy_type_g6005;
246 DEBUGOUT("Unknown physical layer module\n");
247 phy_type = ixgb_phy_type_unknown;
254 /******************************************************************************
255 * Performs basic configuration of the adapter.
257 * hw - Struct containing variables accessed by shared code
259 * Resets the controller.
260 * Reads and validates the EEPROM.
261 * Initializes the receive address registers.
262 * Initializes the multicast table.
263 * Clears all on-chip counters.
264 * Calls routine to setup flow control settings.
265 * Leaves the transmit and receive units disabled and uninitialized.
268 * TRUE if successful,
269 * FALSE if unrecoverable problems were encountered.
270 *****************************************************************************/
272 ixgb_init_hw(struct ixgb_hw *hw)
278 DEBUGFUNC("ixgb_init_hw");
280 /* Issue a global reset to the MAC. This will reset the chip's
281 * transmit, receive, DMA, and link units. It will not effect
282 * the current PCI configuration. The global reset bit is self-
283 * clearing, and should clear within a microsecond.
285 DEBUGOUT("Issuing a global reset to MAC\n");
287 ctrl_reg = ixgb_mac_reset(hw);
289 DEBUGOUT("Issuing an EE reset to MAC\n");
291 /* Workaround for 82597EX reset errata */
292 IXGB_WRITE_REG_IO(hw, CTRL1, IXGB_CTRL1_EE_RST);
294 IXGB_WRITE_REG(hw, CTRL1, IXGB_CTRL1_EE_RST);
297 /* Delay a few ms just to allow the reset to complete */
298 msec_delay(IXGB_DELAY_AFTER_EE_RESET);
300 if (ixgb_get_eeprom_data(hw) == FALSE) {
304 /* Use the device id to determine the type of phy/transceiver. */
305 hw->device_id = ixgb_get_ee_device_id(hw);
306 hw->phy_type = ixgb_identify_phy(hw);
308 /* Setup the receive addresses.
309 * Receive Address Registers (RARs 0 - 15).
311 ixgb_init_rx_addrs(hw);
314 * Check that a valid MAC address has been set.
315 * If it is not valid, we fail hardware init.
317 if (!mac_addr_valid(hw->curr_mac_addr)) {
318 DEBUGOUT("MAC address invalid after ixgb_init_rx_addrs\n");
322 /* tell the routines in this file they can access hardware again */
323 hw->adapter_stopped = FALSE;
325 /* Fill in the bus_info structure */
326 ixgb_get_bus_info(hw);
328 /* Zero out the Multicast HASH table */
329 DEBUGOUT("Zeroing the MTA\n");
330 for(i = 0; i < IXGB_MC_TBL_SIZE; i++)
331 IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
333 /* Zero out the VLAN Filter Table Array */
336 /* Zero all of the hardware counters */
337 ixgb_clear_hw_cntrs(hw);
339 /* Call a subroutine to setup flow control. */
340 status = ixgb_setup_fc(hw);
342 /* 82597EX errata: Call check-for-link in case lane deskew is locked */
343 ixgb_check_for_link(hw);
348 /******************************************************************************
349 * Initializes receive address filters.
351 * hw - Struct containing variables accessed by shared code
353 * Places the MAC address in receive address register 0 and clears the rest
354 * of the receive addresss registers. Clears the multicast table. Assumes
355 * the receiver is in reset when the routine is called.
356 *****************************************************************************/
358 ixgb_init_rx_addrs(struct ixgb_hw *hw)
362 DEBUGFUNC("ixgb_init_rx_addrs");
365 * If the current mac address is valid, assume it is a software override
366 * to the permanent address.
367 * Otherwise, use the permanent address from the eeprom.
369 if (!mac_addr_valid(hw->curr_mac_addr)) {
371 /* Get the MAC address from the eeprom for later reference */
372 ixgb_get_ee_mac_addr(hw, hw->curr_mac_addr);
374 DEBUGOUT3(" Keeping Permanent MAC Addr =%.2X %.2X %.2X ",
375 hw->curr_mac_addr[0],
376 hw->curr_mac_addr[1],
377 hw->curr_mac_addr[2]);
378 DEBUGOUT3("%.2X %.2X %.2X\n",
379 hw->curr_mac_addr[3],
380 hw->curr_mac_addr[4],
381 hw->curr_mac_addr[5]);
384 /* Setup the receive address. */
385 DEBUGOUT("Overriding MAC Address in RAR[0]\n");
386 DEBUGOUT3(" New MAC Addr =%.2X %.2X %.2X ",
387 hw->curr_mac_addr[0],
388 hw->curr_mac_addr[1],
389 hw->curr_mac_addr[2]);
390 DEBUGOUT3("%.2X %.2X %.2X\n",
391 hw->curr_mac_addr[3],
392 hw->curr_mac_addr[4],
393 hw->curr_mac_addr[5]);
396 ixgb_rar_set(hw, hw->curr_mac_addr, 0);
399 /* Zero out the other 15 receive addresses. */
400 DEBUGOUT("Clearing RAR[1-15]\n");
401 for(i = 1; i < IXGB_RAR_ENTRIES; i++) {
402 IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
403 IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
409 /******************************************************************************
410 * Updates the MAC's list of multicast addresses.
412 * hw - Struct containing variables accessed by shared code
413 * mc_addr_list - the list of new multicast addresses
414 * mc_addr_count - number of addresses
415 * pad - number of bytes between addresses in the list
417 * The given list replaces any existing list. Clears the last 15 receive
418 * address registers and the multicast table. Uses receive address registers
419 * for the first 15 multicast addresses, and hashes the rest into the
421 *****************************************************************************/
423 ixgb_mc_addr_list_update(struct ixgb_hw *hw,
424 uint8_t *mc_addr_list,
425 uint32_t mc_addr_count,
430 uint32_t rar_used_count = 1; /* RAR[0] is used for our MAC address */
432 DEBUGFUNC("ixgb_mc_addr_list_update");
434 /* Set the new number of MC addresses that we are being requested to use. */
435 hw->num_mc_addrs = mc_addr_count;
437 /* Clear RAR[1-15] */
438 DEBUGOUT(" Clearing RAR[1-15]\n");
439 for(i = rar_used_count; i < IXGB_RAR_ENTRIES; i++) {
440 IXGB_WRITE_REG_ARRAY(hw, RA, (i << 1), 0);
441 IXGB_WRITE_REG_ARRAY(hw, RA, ((i << 1) + 1), 0);
445 DEBUGOUT(" Clearing MTA\n");
446 for(i = 0; i < IXGB_MC_TBL_SIZE; i++) {
447 IXGB_WRITE_REG_ARRAY(hw, MTA, i, 0);
450 /* Add the new addresses */
451 for(i = 0; i < mc_addr_count; i++) {
452 DEBUGOUT(" Adding the multicast addresses:\n");
453 DEBUGOUT7(" MC Addr #%d =%.2X %.2X %.2X %.2X %.2X %.2X\n", i,
454 mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)],
455 mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 1],
456 mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 2],
457 mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 3],
458 mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 4],
459 mc_addr_list[i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad) + 5]);
461 /* Place this multicast address in the RAR if there is room, *
462 * else put it in the MTA
464 if(rar_used_count < IXGB_RAR_ENTRIES) {
466 mc_addr_list + (i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)),
468 DEBUGOUT1("Added a multicast address to RAR[%d]\n", i);
471 hash_value = ixgb_hash_mc_addr(hw,
473 (i * (IXGB_ETH_LENGTH_OF_ADDRESS + pad)));
475 DEBUGOUT1(" Hash value = 0x%03X\n", hash_value);
477 ixgb_mta_set(hw, hash_value);
481 DEBUGOUT("MC Update Complete\n");
485 /******************************************************************************
486 * Hashes an address to determine its location in the multicast table
488 * hw - Struct containing variables accessed by shared code
489 * mc_addr - the multicast address to hash
493 *****************************************************************************/
495 ixgb_hash_mc_addr(struct ixgb_hw *hw,
498 uint32_t hash_value = 0;
500 DEBUGFUNC("ixgb_hash_mc_addr");
502 /* The portion of the address that is used for the hash table is
503 * determined by the mc_filter_type setting.
505 switch (hw->mc_filter_type) {
506 /* [0] [1] [2] [3] [4] [5]
508 * LSB MSB - According to H/W docs */
510 /* [47:36] i.e. 0x563 for above example address */
511 hash_value = ((mc_addr[4] >> 4) | (((uint16_t) mc_addr[5]) << 4));
513 case 1: /* [46:35] i.e. 0xAC6 for above example address */
514 hash_value = ((mc_addr[4] >> 3) | (((uint16_t) mc_addr[5]) << 5));
516 case 2: /* [45:34] i.e. 0x5D8 for above example address */
517 hash_value = ((mc_addr[4] >> 2) | (((uint16_t) mc_addr[5]) << 6));
519 case 3: /* [43:32] i.e. 0x634 for above example address */
520 hash_value = ((mc_addr[4]) | (((uint16_t) mc_addr[5]) << 8));
523 /* Invalid mc_filter_type, what should we do? */
524 DEBUGOUT("MC filter type param set incorrectly\n");
533 /******************************************************************************
534 * Sets the bit in the multicast table corresponding to the hash value.
536 * hw - Struct containing variables accessed by shared code
537 * hash_value - Multicast address hash value
538 *****************************************************************************/
540 ixgb_mta_set(struct ixgb_hw *hw,
543 uint32_t hash_bit, hash_reg;
546 /* The MTA is a register array of 128 32-bit registers.
547 * It is treated like an array of 4096 bits. We want to set
548 * bit BitArray[hash_value]. So we figure out what register
549 * the bit is in, read it, OR in the new bit, then write
550 * back the new value. The register is determined by the
551 * upper 7 bits of the hash value and the bit within that
552 * register are determined by the lower 5 bits of the value.
554 hash_reg = (hash_value >> 5) & 0x7F;
555 hash_bit = hash_value & 0x1F;
557 mta_reg = IXGB_READ_REG_ARRAY(hw, MTA, hash_reg);
559 mta_reg |= (1 << hash_bit);
561 IXGB_WRITE_REG_ARRAY(hw, MTA, hash_reg, mta_reg);
566 /******************************************************************************
567 * Puts an ethernet address into a receive address register.
569 * hw - Struct containing variables accessed by shared code
570 * addr - Address to put into receive address register
571 * index - Receive address register to write
572 *****************************************************************************/
574 ixgb_rar_set(struct ixgb_hw *hw,
578 uint32_t rar_low, rar_high;
580 DEBUGFUNC("ixgb_rar_set");
582 /* HW expects these in little endian so we reverse the byte order
583 * from network order (big endian) to little endian
585 rar_low = ((uint32_t) addr[0] |
586 ((uint32_t) addr[1] << 8) |
587 ((uint32_t) addr[2] << 16) |
588 ((uint32_t) addr[3] << 24));
590 rar_high = ((uint32_t) addr[4] |
591 ((uint32_t) addr[5] << 8) |
594 IXGB_WRITE_REG_ARRAY(hw, RA, (index << 1), rar_low);
595 IXGB_WRITE_REG_ARRAY(hw, RA, ((index << 1) + 1), rar_high);
599 /******************************************************************************
600 * Writes a value to the specified offset in the VLAN filter table.
602 * hw - Struct containing variables accessed by shared code
603 * offset - Offset in VLAN filer table to write
604 * value - Value to write into VLAN filter table
605 *****************************************************************************/
607 ixgb_write_vfta(struct ixgb_hw *hw,
611 IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, value);
615 /******************************************************************************
616 * Clears the VLAN filer table
618 * hw - Struct containing variables accessed by shared code
619 *****************************************************************************/
621 ixgb_clear_vfta(struct ixgb_hw *hw)
625 for(offset = 0; offset < IXGB_VLAN_FILTER_TBL_SIZE; offset++)
626 IXGB_WRITE_REG_ARRAY(hw, VFTA, offset, 0);
630 /******************************************************************************
631 * Configures the flow control settings based on SW configuration.
633 * hw - Struct containing variables accessed by shared code
634 *****************************************************************************/
637 ixgb_setup_fc(struct ixgb_hw *hw)
640 uint32_t pap_reg = 0; /* by default, assume no pause time */
641 boolean_t status = TRUE;
643 DEBUGFUNC("ixgb_setup_fc");
645 /* Get the current control reg 0 settings */
646 ctrl_reg = IXGB_READ_REG(hw, CTRL0);
648 /* Clear the Receive Pause Enable and Transmit Pause Enable bits */
649 ctrl_reg &= ~(IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
651 /* The possible values of the "flow_control" parameter are:
652 * 0: Flow control is completely disabled
653 * 1: Rx flow control is enabled (we can receive pause frames
654 * but not send pause frames).
655 * 2: Tx flow control is enabled (we can send pause frames
656 * but we do not support receiving pause frames).
657 * 3: Both Rx and TX flow control (symmetric) are enabled.
660 switch (hw->fc.type) {
661 case ixgb_fc_none: /* 0 */
662 /* Set CMDC bit to disable Rx Flow control*/
663 ctrl_reg |= (IXGB_CTRL0_CMDC);
665 case ixgb_fc_rx_pause: /* 1 */
666 /* RX Flow control is enabled, and TX Flow control is
669 ctrl_reg |= (IXGB_CTRL0_RPE);
671 case ixgb_fc_tx_pause: /* 2 */
672 /* TX Flow control is enabled, and RX Flow control is
673 * disabled, by a software over-ride.
675 ctrl_reg |= (IXGB_CTRL0_TPE);
676 pap_reg = hw->fc.pause_time;
678 case ixgb_fc_full: /* 3 */
679 /* Flow control (both RX and TX) is enabled by a software
682 ctrl_reg |= (IXGB_CTRL0_RPE | IXGB_CTRL0_TPE);
683 pap_reg = hw->fc.pause_time;
686 /* We should never get here. The value should be 0-3. */
687 DEBUGOUT("Flow control param set incorrectly\n");
692 /* Write the new settings */
693 IXGB_WRITE_REG(hw, CTRL0, ctrl_reg);
696 IXGB_WRITE_REG(hw, PAP, pap_reg);
699 /* Set the flow control receive threshold registers. Normally,
700 * these registers will be set to a default threshold that may be
701 * adjusted later by the driver's runtime code. However, if the
702 * ability to transmit pause frames in not enabled, then these
703 * registers will be set to 0.
705 if(!(hw->fc.type & ixgb_fc_tx_pause)) {
706 IXGB_WRITE_REG(hw, FCRTL, 0);
707 IXGB_WRITE_REG(hw, FCRTH, 0);
709 /* We need to set up the Receive Threshold high and low water
710 * marks as well as (optionally) enabling the transmission of XON frames.
712 if(hw->fc.send_xon) {
713 IXGB_WRITE_REG(hw, FCRTL,
714 (hw->fc.low_water | IXGB_FCRTL_XONE));
716 IXGB_WRITE_REG(hw, FCRTL, hw->fc.low_water);
718 IXGB_WRITE_REG(hw, FCRTH, hw->fc.high_water);
723 /******************************************************************************
724 * Reads a word from a device over the Management Data Interface (MDI) bus.
725 * This interface is used to manage Physical layer devices.
727 * hw - Struct containing variables accessed by hw code
728 * reg_address - Offset of device register being read.
729 * phy_address - Address of device on MDI.
731 * Returns: Data word (16 bits) from MDI device.
733 * The 82597EX has support for several MDI access methods. This routine
734 * uses the new protocol MDI Single Command and Address Operation.
735 * This requires that first an address cycle command is sent, followed by a
737 *****************************************************************************/
739 ixgb_read_phy_reg(struct ixgb_hw *hw,
740 uint32_t reg_address,
741 uint32_t phy_address,
742 uint32_t device_type)
746 uint32_t command = 0;
748 ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
749 ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
750 ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
752 /* Setup and write the address cycle command */
753 command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
754 (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
755 (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
756 (IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
758 IXGB_WRITE_REG(hw, MSCA, command);
760 /**************************************************************
761 ** Check every 10 usec to see if the address cycle completed
762 ** The COMMAND bit will clear when the operation is complete.
763 ** This may take as long as 64 usecs (we'll wait 100 usecs max)
764 ** from the CPU Write to the Ready bit assertion.
765 **************************************************************/
767 for (i = 0; i < 10; i++)
771 command = IXGB_READ_REG(hw, MSCA);
773 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
777 ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
779 /* Address cycle complete, setup and write the read command */
780 command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
781 (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
782 (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
783 (IXGB_MSCA_READ | IXGB_MSCA_MDI_COMMAND));
785 IXGB_WRITE_REG(hw, MSCA, command);
787 /**************************************************************
788 ** Check every 10 usec to see if the read command completed
789 ** The COMMAND bit will clear when the operation is complete.
790 ** The read may take as long as 64 usecs (we'll wait 100 usecs max)
791 ** from the CPU Write to the Ready bit assertion.
792 **************************************************************/
794 for (i = 0; i < 10; i++)
798 command = IXGB_READ_REG(hw, MSCA);
800 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
804 ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
806 /* Operation is complete, get the data from the MDIO Read/Write Data
807 * register and return.
809 data = IXGB_READ_REG(hw, MSRWD);
810 data >>= IXGB_MSRWD_READ_DATA_SHIFT;
811 return((uint16_t) data);
814 /******************************************************************************
815 * Writes a word to a device over the Management Data Interface (MDI) bus.
816 * This interface is used to manage Physical layer devices.
818 * hw - Struct containing variables accessed by hw code
819 * reg_address - Offset of device register being read.
820 * phy_address - Address of device on MDI.
821 * device_type - Also known as the Device ID or DID.
822 * data - 16-bit value to be written
826 * The 82597EX has support for several MDI access methods. This routine
827 * uses the new protocol MDI Single Command and Address Operation.
828 * This requires that first an address cycle command is sent, followed by a
830 *****************************************************************************/
832 ixgb_write_phy_reg(struct ixgb_hw *hw,
833 uint32_t reg_address,
834 uint32_t phy_address,
835 uint32_t device_type,
839 uint32_t command = 0;
841 ASSERT(reg_address <= IXGB_MAX_PHY_REG_ADDRESS);
842 ASSERT(phy_address <= IXGB_MAX_PHY_ADDRESS);
843 ASSERT(device_type <= IXGB_MAX_PHY_DEV_TYPE);
845 /* Put the data in the MDIO Read/Write Data register */
846 IXGB_WRITE_REG(hw, MSRWD, (uint32_t)data);
848 /* Setup and write the address cycle command */
849 command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
850 (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
851 (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
852 (IXGB_MSCA_ADDR_CYCLE | IXGB_MSCA_MDI_COMMAND));
854 IXGB_WRITE_REG(hw, MSCA, command);
856 /**************************************************************
857 ** Check every 10 usec to see if the address cycle completed
858 ** The COMMAND bit will clear when the operation is complete.
859 ** This may take as long as 64 usecs (we'll wait 100 usecs max)
860 ** from the CPU Write to the Ready bit assertion.
861 **************************************************************/
863 for (i = 0; i < 10; i++)
867 command = IXGB_READ_REG(hw, MSCA);
869 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
873 ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
875 /* Address cycle complete, setup and write the write command */
876 command = ((reg_address << IXGB_MSCA_NP_ADDR_SHIFT) |
877 (device_type << IXGB_MSCA_DEV_TYPE_SHIFT) |
878 (phy_address << IXGB_MSCA_PHY_ADDR_SHIFT) |
879 (IXGB_MSCA_WRITE | IXGB_MSCA_MDI_COMMAND));
881 IXGB_WRITE_REG(hw, MSCA, command);
883 /**************************************************************
884 ** Check every 10 usec to see if the read command completed
885 ** The COMMAND bit will clear when the operation is complete.
886 ** The write may take as long as 64 usecs (we'll wait 100 usecs max)
887 ** from the CPU Write to the Ready bit assertion.
888 **************************************************************/
890 for (i = 0; i < 10; i++)
894 command = IXGB_READ_REG(hw, MSCA);
896 if ((command & IXGB_MSCA_MDI_COMMAND) == 0)
900 ASSERT((command & IXGB_MSCA_MDI_COMMAND) == 0);
902 /* Operation is complete, return. */
906 /******************************************************************************
907 * Checks to see if the link status of the hardware has changed.
909 * hw - Struct containing variables accessed by hw code
911 * Called by any function that needs to check the link status of the adapter.
912 *****************************************************************************/
914 ixgb_check_for_link(struct ixgb_hw *hw)
919 DEBUGFUNC("ixgb_check_for_link");
921 xpcss_reg = IXGB_READ_REG(hw, XPCSS);
922 status_reg = IXGB_READ_REG(hw, STATUS);
924 if ((xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
925 (status_reg & IXGB_STATUS_LU)) {
927 } else if (!(xpcss_reg & IXGB_XPCSS_ALIGN_STATUS) &&
928 (status_reg & IXGB_STATUS_LU)) {
929 DEBUGOUT("XPCSS Not Aligned while Status:LU is set.\n");
930 hw->link_up = ixgb_link_reset(hw);
933 * 82597EX errata. Since the lane deskew problem may prevent
934 * link, reset the link before reporting link down.
936 hw->link_up = ixgb_link_reset(hw);
938 /* Anything else for 10 Gig?? */
941 /******************************************************************************
942 * Check for a bad link condition that may have occured.
943 * The indication is that the RFC / LFC registers may be incrementing
944 * continually. A full adapter reset is required to recover.
946 * hw - Struct containing variables accessed by hw code
948 * Called by any function that needs to check the link status of the adapter.
949 *****************************************************************************/
950 boolean_t ixgb_check_for_bad_link(struct ixgb_hw *hw)
952 uint32_t newLFC, newRFC;
953 boolean_t bad_link_returncode = FALSE;
955 if (hw->phy_type == ixgb_phy_type_txn17401) {
956 newLFC = IXGB_READ_REG(hw, LFC);
957 newRFC = IXGB_READ_REG(hw, RFC);
958 if ((hw->lastLFC + 250 < newLFC) || (hw->lastRFC + 250 < newRFC)) {
959 DEBUGOUT("BAD LINK! too many LFC/RFC since last check\n");
960 bad_link_returncode = TRUE;
962 hw->lastLFC = newLFC;
963 hw->lastRFC = newRFC;
966 return bad_link_returncode;
970 /******************************************************************************
971 * Clears all hardware statistics counters.
973 * hw - Struct containing variables accessed by shared code
974 *****************************************************************************/
976 ixgb_clear_hw_cntrs(struct ixgb_hw *hw)
978 volatile uint32_t temp_reg;
980 DEBUGFUNC("ixgb_clear_hw_cntrs");
982 /* if we are stopped or resetting exit gracefully */
983 if(hw->adapter_stopped) {
984 DEBUGOUT("Exiting because the adapter is stopped!!!\n");
988 temp_reg = IXGB_READ_REG(hw, TPRL);
989 temp_reg = IXGB_READ_REG(hw, TPRH);
990 temp_reg = IXGB_READ_REG(hw, GPRCL);
991 temp_reg = IXGB_READ_REG(hw, GPRCH);
992 temp_reg = IXGB_READ_REG(hw, BPRCL);
993 temp_reg = IXGB_READ_REG(hw, BPRCH);
994 temp_reg = IXGB_READ_REG(hw, MPRCL);
995 temp_reg = IXGB_READ_REG(hw, MPRCH);
996 temp_reg = IXGB_READ_REG(hw, UPRCL);
997 temp_reg = IXGB_READ_REG(hw, UPRCH);
998 temp_reg = IXGB_READ_REG(hw, VPRCL);
999 temp_reg = IXGB_READ_REG(hw, VPRCH);
1000 temp_reg = IXGB_READ_REG(hw, JPRCL);
1001 temp_reg = IXGB_READ_REG(hw, JPRCH);
1002 temp_reg = IXGB_READ_REG(hw, GORCL);
1003 temp_reg = IXGB_READ_REG(hw, GORCH);
1004 temp_reg = IXGB_READ_REG(hw, TORL);
1005 temp_reg = IXGB_READ_REG(hw, TORH);
1006 temp_reg = IXGB_READ_REG(hw, RNBC);
1007 temp_reg = IXGB_READ_REG(hw, RUC);
1008 temp_reg = IXGB_READ_REG(hw, ROC);
1009 temp_reg = IXGB_READ_REG(hw, RLEC);
1010 temp_reg = IXGB_READ_REG(hw, CRCERRS);
1011 temp_reg = IXGB_READ_REG(hw, ICBC);
1012 temp_reg = IXGB_READ_REG(hw, ECBC);
1013 temp_reg = IXGB_READ_REG(hw, MPC);
1014 temp_reg = IXGB_READ_REG(hw, TPTL);
1015 temp_reg = IXGB_READ_REG(hw, TPTH);
1016 temp_reg = IXGB_READ_REG(hw, GPTCL);
1017 temp_reg = IXGB_READ_REG(hw, GPTCH);
1018 temp_reg = IXGB_READ_REG(hw, BPTCL);
1019 temp_reg = IXGB_READ_REG(hw, BPTCH);
1020 temp_reg = IXGB_READ_REG(hw, MPTCL);
1021 temp_reg = IXGB_READ_REG(hw, MPTCH);
1022 temp_reg = IXGB_READ_REG(hw, UPTCL);
1023 temp_reg = IXGB_READ_REG(hw, UPTCH);
1024 temp_reg = IXGB_READ_REG(hw, VPTCL);
1025 temp_reg = IXGB_READ_REG(hw, VPTCH);
1026 temp_reg = IXGB_READ_REG(hw, JPTCL);
1027 temp_reg = IXGB_READ_REG(hw, JPTCH);
1028 temp_reg = IXGB_READ_REG(hw, GOTCL);
1029 temp_reg = IXGB_READ_REG(hw, GOTCH);
1030 temp_reg = IXGB_READ_REG(hw, TOTL);
1031 temp_reg = IXGB_READ_REG(hw, TOTH);
1032 temp_reg = IXGB_READ_REG(hw, DC);
1033 temp_reg = IXGB_READ_REG(hw, PLT64C);
1034 temp_reg = IXGB_READ_REG(hw, TSCTC);
1035 temp_reg = IXGB_READ_REG(hw, TSCTFC);
1036 temp_reg = IXGB_READ_REG(hw, IBIC);
1037 temp_reg = IXGB_READ_REG(hw, RFC);
1038 temp_reg = IXGB_READ_REG(hw, LFC);
1039 temp_reg = IXGB_READ_REG(hw, PFRC);
1040 temp_reg = IXGB_READ_REG(hw, PFTC);
1041 temp_reg = IXGB_READ_REG(hw, MCFRC);
1042 temp_reg = IXGB_READ_REG(hw, MCFTC);
1043 temp_reg = IXGB_READ_REG(hw, XONRXC);
1044 temp_reg = IXGB_READ_REG(hw, XONTXC);
1045 temp_reg = IXGB_READ_REG(hw, XOFFRXC);
1046 temp_reg = IXGB_READ_REG(hw, XOFFTXC);
1047 temp_reg = IXGB_READ_REG(hw, RJC);
1052 /******************************************************************************
1053 * Turns on the software controllable LED
1055 * hw - Struct containing variables accessed by shared code
1056 *****************************************************************************/
1058 ixgb_led_on(struct ixgb_hw *hw)
1060 uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
1062 /* To turn on the LED, clear software-definable pin 0 (SDP0). */
1063 ctrl0_reg &= ~IXGB_CTRL0_SDP0;
1064 IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
1068 /******************************************************************************
1069 * Turns off the software controllable LED
1071 * hw - Struct containing variables accessed by shared code
1072 *****************************************************************************/
1074 ixgb_led_off(struct ixgb_hw *hw)
1076 uint32_t ctrl0_reg = IXGB_READ_REG(hw, CTRL0);
1078 /* To turn off the LED, set software-definable pin 0 (SDP0). */
1079 ctrl0_reg |= IXGB_CTRL0_SDP0;
1080 IXGB_WRITE_REG(hw, CTRL0, ctrl0_reg);
1085 /******************************************************************************
1086 * Gets the current PCI bus type, speed, and width of the hardware
1088 * hw - Struct containing variables accessed by shared code
1089 *****************************************************************************/
1091 ixgb_get_bus_info(struct ixgb_hw *hw)
1093 uint32_t status_reg;
1095 status_reg = IXGB_READ_REG(hw, STATUS);
1097 hw->bus.type = (status_reg & IXGB_STATUS_PCIX_MODE) ?
1098 ixgb_bus_type_pcix : ixgb_bus_type_pci;
1100 if (hw->bus.type == ixgb_bus_type_pci) {
1101 hw->bus.speed = (status_reg & IXGB_STATUS_PCI_SPD) ?
1102 ixgb_bus_speed_66 : ixgb_bus_speed_33;
1104 switch (status_reg & IXGB_STATUS_PCIX_SPD_MASK) {
1105 case IXGB_STATUS_PCIX_SPD_66:
1106 hw->bus.speed = ixgb_bus_speed_66;
1108 case IXGB_STATUS_PCIX_SPD_100:
1109 hw->bus.speed = ixgb_bus_speed_100;
1111 case IXGB_STATUS_PCIX_SPD_133:
1112 hw->bus.speed = ixgb_bus_speed_133;
1115 hw->bus.speed = ixgb_bus_speed_reserved;
1120 hw->bus.width = (status_reg & IXGB_STATUS_BUS64) ?
1121 ixgb_bus_width_64 : ixgb_bus_width_32;
1128 /******************************************************************************
1129 * Tests a MAC address to ensure it is a valid Individual Address
1131 * mac_addr - pointer to MAC address.
1133 *****************************************************************************/
1135 mac_addr_valid(uint8_t *mac_addr)
1137 boolean_t is_valid = TRUE;
1138 DEBUGFUNC("mac_addr_valid");
1141 /* Make sure it is not a multicast address */
1142 if (IS_MULTICAST(mac_addr)) {
1143 DEBUGOUT("MAC address is multicast\n");
1146 /* Not a broadcast address */
1147 else if (IS_BROADCAST(mac_addr)) {
1148 DEBUGOUT("MAC address is broadcast\n");
1151 /* Reject the zero address */
1152 else if (mac_addr[0] == 0 &&
1158 DEBUGOUT("MAC address is all zeros\n");
1164 /******************************************************************************
1165 * Resets the 10GbE link. Waits the settle time and returns the state of
1168 * hw - Struct containing variables accessed by shared code
1169 *****************************************************************************/
1171 ixgb_link_reset(struct ixgb_hw *hw)
1173 boolean_t link_status = FALSE;
1174 uint8_t wait_retries = MAX_RESET_ITERATIONS;
1175 uint8_t lrst_retries = MAX_RESET_ITERATIONS;
1179 /* Reset the link */
1180 IXGB_WRITE_REG(hw, CTRL0, IXGB_READ_REG(hw, CTRL0) | IXGB_CTRL0_LRST);
1182 /* Wait for link-up and lane re-alignment */
1184 usec_delay(IXGB_DELAY_USECS_AFTER_LINK_RESET);
1185 link_status = ((IXGB_READ_REG(hw, STATUS) & IXGB_STATUS_LU) &&
1186 (IXGB_READ_REG(hw, XPCSS) & IXGB_XPCSS_ALIGN_STATUS)) ?
1188 } while (!link_status && -- wait_retries);
1190 } while (!link_status && --lrst_retries);
1197 /******************************************************************************
1198 * Resets the 10GbE optics module.
1200 * hw - Struct containing variables accessed by shared code
1201 *****************************************************************************/
1203 ixgb_optics_reset(struct ixgb_hw *hw)
1205 if (hw->phy_type == ixgb_phy_type_txn17401) {
1208 ixgb_write_phy_reg( hw,
1212 MDIO_PMA_PMD_CR1_RESET);
1214 mdio_reg = ixgb_read_phy_reg( hw,