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