[e1000e] Add e1000e driver
[people/pcmattman/gpxe.git] / src / drivers / net / e1000e / e1000e_mac.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2009 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 FILE_LICENCE ( GPL2_OR_LATER );
30
31 #include "e1000e.h"
32
33 static u32 e1000e_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr);
34 static s32 e1000e_set_default_fc_generic(struct e1000_hw *hw);
35 static s32 e1000e_commit_fc_settings_generic(struct e1000_hw *hw);
36 static s32 e1000e_poll_fiber_serdes_link_generic(struct e1000_hw *hw);
37 static s32 e1000e_validate_mdi_setting_generic(struct e1000_hw *hw);
38 static void e1000e_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
39
40 /**
41  *  e1000e_init_mac_ops_generic - Initialize MAC function pointers
42  *  @hw: pointer to the HW structure
43  *
44  *  Setups up the function pointers to no-op functions
45  **/
46 void e1000e_init_mac_ops_generic(struct e1000_hw *hw)
47 {
48         struct e1000_mac_info *mac = &hw->mac;
49         /* General Setup */
50         mac->ops.set_lan_id = e1000e_set_lan_id_multi_port_pcie;
51         mac->ops.read_mac_addr = e1000e_read_mac_addr_generic;
52         mac->ops.config_collision_dist = e1000e_config_collision_dist;
53         /* LINK */
54         mac->ops.wait_autoneg = e1000e_wait_autoneg;
55         /* Management */
56 #if 0
57         mac->ops.mng_host_if_write = e1000e_mng_host_if_write_generic;
58         mac->ops.mng_write_cmd_header = e1000e_mng_write_cmd_header_generic;
59         mac->ops.mng_enable_host_if = e1000e_mng_enable_host_if_generic;
60 #endif
61         /* VLAN, MC, etc. */
62         mac->ops.rar_set = e1000e_rar_set;
63         mac->ops.validate_mdi_setting = e1000e_validate_mdi_setting_generic;
64 }
65
66 /**
67  *  e1000e_get_bus_info_pcie - Get PCIe bus information
68  *  @hw: pointer to the HW structure
69  *
70  *  Determines and stores the system bus information for a particular
71  *  network interface.  The following bus information is determined and stored:
72  *  bus speed, bus width, type (PCIe), and PCIe function.
73  **/
74 s32 e1000e_get_bus_info_pcie(struct e1000_hw *hw)
75 {
76         struct e1000_mac_info *mac = &hw->mac;
77         struct e1000_bus_info *bus = &hw->bus;
78
79         s32 ret_val;
80         u16 pcie_link_status;
81
82         bus->type = e1000_bus_type_pci_express;
83         bus->speed = e1000_bus_speed_2500;
84
85         ret_val = e1000e_read_pcie_cap_reg(hw,
86                                           PCIE_LINK_STATUS,
87                                           &pcie_link_status);
88         if (ret_val)
89                 bus->width = e1000_bus_width_unknown;
90         else
91                 bus->width = (enum e1000_bus_width)((pcie_link_status &
92                                                 PCIE_LINK_WIDTH_MASK) >>
93                                                PCIE_LINK_WIDTH_SHIFT);
94
95         mac->ops.set_lan_id(hw);
96
97         return E1000_SUCCESS;
98 }
99
100 /**
101  *  e1000e_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices
102  *
103  *  @hw: pointer to the HW structure
104  *
105  *  Determines the LAN function id by reading memory-mapped registers
106  *  and swaps the port value if requested.
107  **/
108 static void e1000e_set_lan_id_multi_port_pcie(struct e1000_hw *hw)
109 {
110         struct e1000_bus_info *bus = &hw->bus;
111         u32 reg;
112
113         /*
114          * The status register reports the correct function number
115          * for the device regardless of function swap state.
116          */
117         reg = er32(STATUS);
118         bus->func = (reg & E1000_STATUS_FUNC_MASK) >> E1000_STATUS_FUNC_SHIFT;
119 }
120
121 /**
122  *  e1000e_set_lan_id_single_port - Set LAN id for a single port device
123  *  @hw: pointer to the HW structure
124  *
125  *  Sets the LAN function id to zero for a single port device.
126  **/
127 void e1000e_set_lan_id_single_port(struct e1000_hw *hw)
128 {
129         struct e1000_bus_info *bus = &hw->bus;
130
131         bus->func = 0;
132 }
133
134 /**
135  *  e1000e_clear_vfta_generic - Clear VLAN filter table
136  *  @hw: pointer to the HW structure
137  *
138  *  Clears the register array which contains the VLAN filter table by
139  *  setting all the values to 0.
140  **/
141 void e1000e_clear_vfta_generic(struct e1000_hw *hw)
142 {
143         u32 offset;
144
145         for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
146                 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);
147                 e1e_flush();
148         }
149 }
150
151 /**
152  *  e1000e_write_vfta_generic - Write value to VLAN filter table
153  *  @hw: pointer to the HW structure
154  *  @offset: register offset in VLAN filter table
155  *  @value: register value written to VLAN filter table
156  *
157  *  Writes value at the given offset in the register array which stores
158  *  the VLAN filter table.
159  **/
160 void e1000e_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)
161 {
162         E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);
163         e1e_flush();
164 }
165
166 /**
167  *  e1000e_init_rx_addrs - Initialize receive address's
168  *  @hw: pointer to the HW structure
169  *  @rar_count: receive address registers
170  *
171  *  Setups the receive address registers by setting the base receive address
172  *  register to the devices MAC address and clearing all the other receive
173  *  address registers to 0.
174  **/
175 void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)
176 {
177         u32 i;
178         u8 mac_addr[ETH_ADDR_LEN] = {0};
179
180         /* Setup the receive address */
181         e_dbg("Programming MAC Address into RAR[0]\n");
182
183         hw->mac.ops.rar_set(hw, hw->mac.addr, 0);
184
185         /* Zero out the other (rar_entry_count - 1) receive addresses */
186         e_dbg("Clearing RAR[1-%u]\n", rar_count-1);
187         for (i = 1; i < rar_count; i++)
188                 hw->mac.ops.rar_set(hw, mac_addr, i);
189 }
190
191 /**
192  *  e1000e_check_alt_mac_addr_generic - Check for alternate MAC addr
193  *  @hw: pointer to the HW structure
194  *
195  *  Checks the nvm for an alternate MAC address.  An alternate MAC address
196  *  can be setup by pre-boot software and must be treated like a permanent
197  *  address and must override the actual permanent MAC address. If an
198  *  alternate MAC address is found it is programmed into RAR0, replacing
199  *  the permanent address that was installed into RAR0 by the Si on reset.
200  *  This function will return SUCCESS unless it encounters an error while
201  *  reading the EEPROM.
202  **/
203 s32 e1000e_check_alt_mac_addr_generic(struct e1000_hw *hw)
204 {
205         u32 i;
206         s32 ret_val = E1000_SUCCESS;
207         u16 offset, nvm_alt_mac_addr_offset, nvm_data;
208         u8 alt_mac_addr[ETH_ADDR_LEN];
209
210         ret_val = e1000e_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
211                                  &nvm_alt_mac_addr_offset);
212         if (ret_val) {
213                 e_dbg("NVM Read Error\n");
214                 goto out;
215         }
216
217         if (nvm_alt_mac_addr_offset == 0xFFFF) {
218                 /* There is no Alternate MAC Address */
219                 goto out;
220         }
221
222         if (hw->bus.func == E1000_FUNC_1)
223                 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;
224         for (i = 0; i < ETH_ADDR_LEN; i += 2) {
225                 offset = nvm_alt_mac_addr_offset + (i >> 1);
226                 ret_val = e1000e_read_nvm(hw, offset, 1, &nvm_data);
227                 if (ret_val) {
228                         e_dbg("NVM Read Error\n");
229                         goto out;
230                 }
231
232                 alt_mac_addr[i] = (u8)(nvm_data & 0xFF);
233                 alt_mac_addr[i + 1] = (u8)(nvm_data >> 8);
234         }
235
236         /* if multicast bit is set, the alternate address will not be used */
237         if (alt_mac_addr[0] & 0x01) {
238                 e_dbg("Ignoring Alternate Mac Address with MC bit set\n");
239                 goto out;
240         }
241
242         /*
243          * We have a valid alternate MAC address, and we want to treat it the
244          * same as the normal permanent MAC address stored by the HW into the
245          * RAR. Do this by mapping this address into RAR0.
246          */
247         hw->mac.ops.rar_set(hw, alt_mac_addr, 0);
248
249 out:
250         return ret_val;
251 }
252
253 /**
254  *  e1000e_rar_set - Set receive address register
255  *  @hw: pointer to the HW structure
256  *  @addr: pointer to the receive address
257  *  @index: receive address array register
258  *
259  *  Sets the receive address array register at index to the address passed
260  *  in by addr.
261  **/
262 void e1000e_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)
263 {
264         u32 rar_low, rar_high;
265
266         /*
267          * HW expects these in little endian so we reverse the byte order
268          * from network order (big endian) to little endian
269          */
270         rar_low = ((u32) addr[0] |
271                    ((u32) addr[1] << 8) |
272                    ((u32) addr[2] << 16) | ((u32) addr[3] << 24));
273
274         rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));
275
276         /* If MAC address zero, no need to set the AV bit */
277         if (rar_low || rar_high)
278                 rar_high |= E1000_RAH_AV;
279
280         /*
281          * Some bridges will combine consecutive 32-bit writes into
282          * a single burst write, which will malfunction on some parts.
283          * The flushes avoid this.
284          */
285         ew32(RAL(index), rar_low);
286         e1e_flush();
287         ew32(RAH(index), rar_high);
288         e1e_flush();
289 }
290
291 /**
292  *  e1000e_mta_set_generic - Set multicast filter table address
293  *  @hw: pointer to the HW structure
294  *  @hash_value: determines the MTA register and bit to set
295  *
296  *  The multicast table address is a register array of 32-bit registers.
297  *  The hash_value is used to determine what register the bit is in, the
298  *  current value is read, the new bit is OR'd in and the new value is
299  *  written back into the register.
300  **/
301 void e1000e_mta_set_generic(struct e1000_hw *hw, u32 hash_value)
302 {
303         u32 hash_bit, hash_reg, mta;
304
305         /*
306          * The MTA is a register array of 32-bit registers. It is
307          * treated like an array of (32*mta_reg_count) bits.  We want to
308          * set bit BitArray[hash_value]. So we figure out what register
309          * the bit is in, read it, OR in the new bit, then write
310          * back the new value.  The (hw->mac.mta_reg_count - 1) serves as a
311          * mask to bits 31:5 of the hash value which gives us the
312          * register we're modifying.  The hash bit within that register
313          * is determined by the lower 5 bits of the hash value.
314          */
315         hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
316         hash_bit = hash_value & 0x1F;
317
318         mta = E1000_READ_REG_ARRAY(hw, E1000_MTA, hash_reg);
319
320         mta |= (1 << hash_bit);
321
322         E1000_WRITE_REG_ARRAY(hw, E1000_MTA, hash_reg, mta);
323         e1e_flush();
324 }
325
326 /**
327  *  e1000e_update_mc_addr_list_generic - Update Multicast addresses
328  *  @hw: pointer to the HW structure
329  *  @mc_addr_list: array of multicast addresses to program
330  *  @mc_addr_count: number of multicast addresses to program
331  *
332  *  Updates entire Multicast Table Array.
333  *  The caller must have a packed mc_addr_list of multicast addresses.
334  **/
335 void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
336                                        u8 *mc_addr_list, u32 mc_addr_count)
337 {
338         u32 hash_value, hash_bit, hash_reg;
339         int i;
340
341         /* clear mta_shadow */
342         memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
343
344         /* update mta_shadow from mc_addr_list */
345         for (i = 0; (u32) i < mc_addr_count; i++) {
346                 hash_value = e1000e_hash_mc_addr_generic(hw, mc_addr_list);
347
348                 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
349                 hash_bit = hash_value & 0x1F;
350
351                 hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);
352                 mc_addr_list += (ETH_ADDR_LEN);
353         }
354
355         /* replace the entire MTA table */
356         for (i = hw->mac.mta_reg_count - 1; i >= 0; i--)
357                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, hw->mac.mta_shadow[i]);
358         e1e_flush();
359 }
360
361 /**
362  *  e1000e_hash_mc_addr_generic - Generate a multicast hash value
363  *  @hw: pointer to the HW structure
364  *  @mc_addr: pointer to a multicast address
365  *
366  *  Generates a multicast address hash value which is used to determine
367  *  the multicast filter table array address and new table value.  See
368  *  e1000e_mta_set_generic()
369  **/
370 static u32 e1000e_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr)
371 {
372         u32 hash_value, hash_mask;
373         u8 bit_shift = 0;
374
375         /* Register count multiplied by bits per register */
376         hash_mask = (hw->mac.mta_reg_count * 32) - 1;
377
378         /*
379          * For a mc_filter_type of 0, bit_shift is the number of left-shifts
380          * where 0xFF would still fall within the hash mask.
381          */
382         while (hash_mask >> bit_shift != 0xFF)
383                 bit_shift++;
384
385         /*
386          * The portion of the address that is used for the hash table
387          * is determined by the mc_filter_type setting.
388          * The algorithm is such that there is a total of 8 bits of shifting.
389          * The bit_shift for a mc_filter_type of 0 represents the number of
390          * left-shifts where the MSB of mc_addr[5] would still fall within
391          * the hash_mask.  Case 0 does this exactly.  Since there are a total
392          * of 8 bits of shifting, then mc_addr[4] will shift right the
393          * remaining number of bits. Thus 8 - bit_shift.  The rest of the
394          * cases are a variation of this algorithm...essentially raising the
395          * number of bits to shift mc_addr[5] left, while still keeping the
396          * 8-bit shifting total.
397          *
398          * For example, given the following Destination MAC Address and an
399          * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask),
400          * we can see that the bit_shift for case 0 is 4.  These are the hash
401          * values resulting from each mc_filter_type...
402          * [0] [1] [2] [3] [4] [5]
403          * 01  AA  00  12  34  56
404          * LSB                 MSB
405          *
406          * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563
407          * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6
408          * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163
409          * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634
410          */
411         switch (hw->mac.mc_filter_type) {
412         default:
413         case 0:
414                 break;
415         case 1:
416                 bit_shift += 1;
417                 break;
418         case 2:
419                 bit_shift += 2;
420                 break;
421         case 3:
422                 bit_shift += 4;
423                 break;
424         }
425
426         hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |
427                                   (((u16) mc_addr[5]) << bit_shift)));
428
429         return hash_value;
430 }
431
432 /**
433  *  e1000e_clear_hw_cntrs_base - Clear base hardware counters
434  *  @hw: pointer to the HW structure
435  *
436  *  Clears the base hardware counters by reading the counter registers.
437  **/
438 void e1000e_clear_hw_cntrs_base(struct e1000_hw *hw __unused)
439 {
440 #if 0
441         er32(CRCERRS);
442         er32(SYMERRS);
443         er32(MPC);
444         er32(SCC);
445         er32(ECOL);
446         er32(MCC);
447         er32(LATECOL);
448         er32(COLC);
449         er32(DC);
450         er32(SEC);
451         er32(RLEC);
452         er32(XONRXC);
453         er32(XONTXC);
454         er32(XOFFRXC);
455         er32(XOFFTXC);
456         er32(FCRUC);
457         er32(GPRC);
458         er32(BPRC);
459         er32(MPRC);
460         er32(GPTC);
461         er32(GORCL);
462         er32(GORCH);
463         er32(GOTCL);
464         er32(GOTCH);
465         er32(RNBC);
466         er32(RUC);
467         er32(RFC);
468         er32(ROC);
469         er32(RJC);
470         er32(TORL);
471         er32(TORH);
472         er32(TOTL);
473         er32(TOTH);
474         er32(TPR);
475         er32(TPT);
476         er32(MPTC);
477         er32(BPTC);
478 #endif
479 }
480
481 /**
482  *  e1000e_check_for_copper_link - Check for link (Copper)
483  *  @hw: pointer to the HW structure
484  *
485  *  Checks to see of the link status of the hardware has changed.  If a
486  *  change in link status has been detected, then we read the PHY registers
487  *  to get the current speed/duplex if link exists.
488  **/
489 s32 e1000e_check_for_copper_link(struct e1000_hw *hw)
490 {
491         struct e1000_mac_info *mac = &hw->mac;
492         s32 ret_val;
493         bool link;
494
495         /*
496          * We only want to go out to the PHY registers to see if Auto-Neg
497          * has completed and/or if our link status has changed.  The
498          * get_link_status flag is set upon receiving a Link Status
499          * Change or Rx Sequence Error interrupt.
500          */
501         if (!mac->get_link_status) {
502                 ret_val = E1000_SUCCESS;
503                 goto out;
504         }
505
506         /*
507          * First we want to see if the MII Status Register reports
508          * link.  If so, then we want to get the current speed/duplex
509          * of the PHY.
510          */
511         ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);
512         if (ret_val)
513                 goto out;
514
515         if (!link)
516                 goto out; /* No link detected */
517
518         mac->get_link_status = false;
519
520         /*
521          * Check if there was DownShift, must be checked
522          * immediately after link-up
523          */
524         e1000e_check_downshift(hw);
525
526         /*
527          * If we are forcing speed/duplex, then we simply return since
528          * we have already determined whether we have link or not.
529          */
530         if (!mac->autoneg) {
531                 ret_val = -E1000_ERR_CONFIG;
532                 goto out;
533         }
534
535         /*
536          * Auto-Neg is enabled.  Auto Speed Detection takes care
537          * of MAC speed/duplex configuration.  So we only need to
538          * configure Collision Distance in the MAC.
539          */
540         e1000e_config_collision_dist(hw);
541
542         /*
543          * Configure Flow Control now that Auto-Neg has completed.
544          * First, we need to restore the desired flow control
545          * settings because we may have had to re-autoneg with a
546          * different link partner.
547          */
548         ret_val = e1000e_config_fc_after_link_up(hw);
549         if (ret_val)
550                 e_dbg("Error configuring flow control\n");
551
552 out:
553         return ret_val;
554 }
555
556 /**
557  *  e1000e_check_for_fiber_link - Check for link (Fiber)
558  *  @hw: pointer to the HW structure
559  *
560  *  Checks for link up on the hardware.  If link is not up and we have
561  *  a signal, then we need to force link up.
562  **/
563 s32 e1000e_check_for_fiber_link(struct e1000_hw *hw)
564 {
565         struct e1000_mac_info *mac = &hw->mac;
566         u32 rxcw;
567         u32 ctrl;
568         u32 status;
569         s32 ret_val = E1000_SUCCESS;
570
571         ctrl = er32(CTRL);
572         status = er32(STATUS);
573         rxcw = er32(RXCW);
574
575         /*
576          * If we don't have link (auto-negotiation failed or link partner
577          * cannot auto-negotiate), the cable is plugged in (we have signal),
578          * and our link partner is not trying to auto-negotiate with us (we
579          * are receiving idles or data), we need to force link up. We also
580          * need to give auto-negotiation time to complete, in case the cable
581          * was just plugged in. The autoneg_failed flag does this.
582          */
583         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
584         if ((ctrl & E1000_CTRL_SWDPIN1) && (!(status & E1000_STATUS_LU)) &&
585             (!(rxcw & E1000_RXCW_C))) {
586                 if (mac->autoneg_failed == 0) {
587                         mac->autoneg_failed = 1;
588                         goto out;
589                 }
590                 e_dbg("NOT RXing /C/, disable AutoNeg and force link.\n");
591
592                 /* Disable auto-negotiation in the TXCW register */
593                 ew32(TXCW, (mac->txcw & ~E1000_TXCW_ANE));
594
595                 /* Force link-up and also force full-duplex. */
596                 ctrl = er32(CTRL);
597                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
598                 ew32(CTRL, ctrl);
599
600                 /* Configure Flow Control after forcing link up. */
601                 ret_val = e1000e_config_fc_after_link_up(hw);
602                 if (ret_val) {
603                         e_dbg("Error configuring flow control\n");
604                         goto out;
605                 }
606         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
607                 /*
608                  * If we are forcing link and we are receiving /C/ ordered
609                  * sets, re-enable auto-negotiation in the TXCW register
610                  * and disable forced link in the Device Control register
611                  * in an attempt to auto-negotiate with our link partner.
612                  */
613                 e_dbg("RXing /C/, enable AutoNeg and stop forcing link.\n");
614                 ew32(TXCW, mac->txcw);
615                 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
616
617                 mac->serdes_has_link = true;
618         }
619
620 out:
621         return ret_val;
622 }
623
624 /**
625  *  e1000e_check_for_serdes_link - Check for link (Serdes)
626  *  @hw: pointer to the HW structure
627  *
628  *  Checks for link up on the hardware.  If link is not up and we have
629  *  a signal, then we need to force link up.
630  **/
631 s32 e1000e_check_for_serdes_link(struct e1000_hw *hw)
632 {
633         struct e1000_mac_info *mac = &hw->mac;
634         u32 rxcw;
635         u32 ctrl;
636         u32 status;
637         s32 ret_val = E1000_SUCCESS;
638
639         ctrl = er32(CTRL);
640         status = er32(STATUS);
641         rxcw = er32(RXCW);
642
643         /*
644          * If we don't have link (auto-negotiation failed or link partner
645          * cannot auto-negotiate), and our link partner is not trying to
646          * auto-negotiate with us (we are receiving idles or data),
647          * we need to force link up. We also need to give auto-negotiation
648          * time to complete.
649          */
650         /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */
651         if ((!(status & E1000_STATUS_LU)) && (!(rxcw & E1000_RXCW_C))) {
652                 if (mac->autoneg_failed == 0) {
653                         mac->autoneg_failed = 1;
654                         goto out;
655                 }
656                 e_dbg("NOT RXing /C/, disable AutoNeg and force link.\n");
657
658                 /* Disable auto-negotiation in the TXCW register */
659                 ew32(TXCW, (mac->txcw & ~E1000_TXCW_ANE));
660
661                 /* Force link-up and also force full-duplex. */
662                 ctrl = er32(CTRL);
663                 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
664                 ew32(CTRL, ctrl);
665
666                 /* Configure Flow Control after forcing link up. */
667                 ret_val = e1000e_config_fc_after_link_up(hw);
668                 if (ret_val) {
669                         e_dbg("Error configuring flow control\n");
670                         goto out;
671                 }
672         } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) {
673                 /*
674                  * If we are forcing link and we are receiving /C/ ordered
675                  * sets, re-enable auto-negotiation in the TXCW register
676                  * and disable forced link in the Device Control register
677                  * in an attempt to auto-negotiate with our link partner.
678                  */
679                 e_dbg("RXing /C/, enable AutoNeg and stop forcing link.\n");
680                 ew32(TXCW, mac->txcw);
681                 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
682
683                 mac->serdes_has_link = true;
684         } else if (!(E1000_TXCW_ANE & er32(TXCW))) {
685                 /*
686                  * If we force link for non-auto-negotiation switch, check
687                  * link status based on MAC synchronization for internal
688                  * serdes media type.
689                  */
690                 /* SYNCH bit and IV bit are sticky. */
691                 udelay(10);
692                 rxcw = er32(RXCW);
693                 if (rxcw & E1000_RXCW_SYNCH) {
694                         if (!(rxcw & E1000_RXCW_IV)) {
695                                 mac->serdes_has_link = true;
696                                 e_dbg("SERDES: Link up - forced.\n");
697                         }
698                 } else {
699                         mac->serdes_has_link = false;
700                         e_dbg("SERDES: Link down - force failed.\n");
701                 }
702         }
703
704         if (E1000_TXCW_ANE & er32(TXCW)) {
705                 status = er32(STATUS);
706                 if (status & E1000_STATUS_LU) {
707                         /* SYNCH bit and IV bit are sticky, so reread rxcw. */
708                         udelay(10);
709                         rxcw = er32(RXCW);
710                         if (rxcw & E1000_RXCW_SYNCH) {
711                                 if (!(rxcw & E1000_RXCW_IV)) {
712                                         mac->serdes_has_link = true;
713                                         e_dbg("SERDES: Link up - autoneg "
714                                            "completed sucessfully.\n");
715                                 } else {
716                                         mac->serdes_has_link = false;
717                                         e_dbg("SERDES: Link down - invalid"
718                                            "codewords detected in autoneg.\n");
719                                 }
720                         } else {
721                                 mac->serdes_has_link = false;
722                                 e_dbg("SERDES: Link down - no sync.\n");
723                         }
724                 } else {
725                         mac->serdes_has_link = false;
726                         e_dbg("SERDES: Link down - autoneg failed\n");
727                 }
728         }
729
730 out:
731         return ret_val;
732 }
733
734 /**
735  *  e1000e_setup_link - Setup flow control and link settings
736  *  @hw: pointer to the HW structure
737  *
738  *  Determines which flow control settings to use, then configures flow
739  *  control.  Calls the appropriate media-specific link configuration
740  *  function.  Assuming the adapter has a valid link partner, a valid link
741  *  should be established.  Assumes the hardware has previously been reset
742  *  and the transmitter and receiver are not enabled.
743  **/
744 s32 e1000e_setup_link(struct e1000_hw *hw)
745 {
746         s32 ret_val = E1000_SUCCESS;
747
748         /*
749          * In the case of the phy reset being blocked, we already have a link.
750          * We do not need to set it up again.
751          */
752         if (hw->phy.ops.check_reset_block)
753                 if (e1000e_check_reset_block(hw))
754                         goto out;
755
756         /*
757          * If requested flow control is set to default, set flow control
758          * based on the EEPROM flow control settings.
759          */
760         if (hw->fc.requested_mode == e1000_fc_default) {
761                 ret_val = e1000e_set_default_fc_generic(hw);
762                 if (ret_val)
763                         goto out;
764         }
765
766         /*
767          * Save off the requested flow control mode for use later.  Depending
768          * on the link partner's capabilities, we may or may not use this mode.
769          */
770         hw->fc.current_mode = hw->fc.requested_mode;
771
772         e_dbg("After fix-ups FlowControl is now = %x\n",
773                 hw->fc.current_mode);
774
775         /* Call the necessary media_type subroutine to configure the link. */
776         ret_val = hw->mac.ops.setup_physical_interface(hw);
777         if (ret_val)
778                 goto out;
779
780         /*
781          * Initialize the flow control address, type, and PAUSE timer
782          * registers to their default values.  This is done even if flow
783          * control is disabled, because it does not hurt anything to
784          * initialize these registers.
785          */
786         e_dbg("Initializing the Flow Control address, type and timer regs\n");
787         ew32(FCT, FLOW_CONTROL_TYPE);
788         ew32(FCAH, FLOW_CONTROL_ADDRESS_HIGH);
789         ew32(FCAL, FLOW_CONTROL_ADDRESS_LOW);
790
791         ew32(FCTTV, hw->fc.pause_time);
792
793         ret_val = e1000e_set_fc_watermarks(hw);
794
795 out:
796         return ret_val;
797 }
798
799 /**
800  *  e1000e_setup_fiber_serdes_link - Setup link for fiber/serdes
801  *  @hw: pointer to the HW structure
802  *
803  *  Configures collision distance and flow control for fiber and serdes
804  *  links.  Upon successful setup, poll for link.
805  **/
806 s32 e1000e_setup_fiber_serdes_link(struct e1000_hw *hw)
807 {
808         u32 ctrl;
809         s32 ret_val = E1000_SUCCESS;
810
811         ctrl = er32(CTRL);
812
813         /* Take the link out of reset */
814         ctrl &= ~E1000_CTRL_LRST;
815
816         e1000e_config_collision_dist(hw);
817
818         ret_val = e1000e_commit_fc_settings_generic(hw);
819         if (ret_val)
820                 goto out;
821
822         /*
823          * Since auto-negotiation is enabled, take the link out of reset (the
824          * link will be in reset, because we previously reset the chip). This
825          * will restart auto-negotiation.  If auto-negotiation is successful
826          * then the link-up status bit will be set and the flow control enable
827          * bits (RFCE and TFCE) will be set according to their negotiated value.
828          */
829         e_dbg("Auto-negotiation enabled\n");
830
831         ew32(CTRL, ctrl);
832         e1e_flush();
833         msleep(1);
834
835         /*
836          * For these adapters, the SW definable pin 1 is set when the optics
837          * detect a signal.  If we have a signal, then poll for a "Link-Up"
838          * indication.
839          */
840         if (hw->phy.media_type == e1000_media_type_internal_serdes ||
841             (er32(CTRL) & E1000_CTRL_SWDPIN1)) {
842                 ret_val = e1000e_poll_fiber_serdes_link_generic(hw);
843         } else {
844                 e_dbg("No signal detected\n");
845         }
846
847 out:
848         return ret_val;
849 }
850
851 /**
852  *  e1000e_config_collision_dist - Configure collision distance
853  *  @hw: pointer to the HW structure
854  *
855  *  Configures the collision distance to the default value and is used
856  *  during link setup. Currently no func pointer exists and all
857  *  implementations are handled in the generic version of this function.
858  **/
859 void e1000e_config_collision_dist(struct e1000_hw *hw)
860 {
861         u32 tctl;
862
863         tctl = er32(TCTL);
864
865         tctl &= ~E1000_TCTL_COLD;
866         tctl |= E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT;
867
868         ew32(TCTL, tctl);
869         e1e_flush();
870 }
871
872 /**
873  *  e1000e_poll_fiber_serdes_link_generic - Poll for link up
874  *  @hw: pointer to the HW structure
875  *
876  *  Polls for link up by reading the status register, if link fails to come
877  *  up with auto-negotiation, then the link is forced if a signal is detected.
878  **/
879 static s32 e1000e_poll_fiber_serdes_link_generic(struct e1000_hw *hw)
880 {
881         struct e1000_mac_info *mac = &hw->mac;
882         u32 i, status;
883         s32 ret_val = E1000_SUCCESS;
884
885         /*
886          * If we have a signal (the cable is plugged in, or assumed true for
887          * serdes media) then poll for a "Link-Up" indication in the Device
888          * Status Register.  Time-out if a link isn't seen in 500 milliseconds
889          * seconds (Auto-negotiation should complete in less than 500
890          * milliseconds even if the other end is doing it in SW).
891          */
892         for (i = 0; i < FIBER_LINK_UP_LIMIT; i++) {
893                 msleep(10);
894                 status = er32(STATUS);
895                 if (status & E1000_STATUS_LU)
896                         break;
897         }
898         if (i == FIBER_LINK_UP_LIMIT) {
899                 e_dbg("Never got a valid link from auto-neg!!!\n");
900                 mac->autoneg_failed = 1;
901                 /*
902                  * AutoNeg failed to achieve a link, so we'll call
903                  * mac->check_for_link. This routine will force the
904                  * link up if we detect a signal. This will allow us to
905                  * communicate with non-autonegotiating link partners.
906                  */
907                 ret_val = hw->mac.ops.check_for_link(hw);
908                 if (ret_val) {
909                         e_dbg("Error while checking for link\n");
910                         goto out;
911                 }
912                 mac->autoneg_failed = 0;
913         } else {
914                 mac->autoneg_failed = 0;
915                 e_dbg("Valid Link Found\n");
916         }
917
918 out:
919         return ret_val;
920 }
921
922 /**
923  *  e1000e_commit_fc_settings_generic - Configure flow control
924  *  @hw: pointer to the HW structure
925  *
926  *  Write the flow control settings to the Transmit Config Word Register (TXCW)
927  *  base on the flow control settings in e1000_mac_info.
928  **/
929 static s32 e1000e_commit_fc_settings_generic(struct e1000_hw *hw)
930 {
931         struct e1000_mac_info *mac = &hw->mac;
932         u32 txcw;
933         s32 ret_val = E1000_SUCCESS;
934
935         /*
936          * Check for a software override of the flow control settings, and
937          * setup the device accordingly.  If auto-negotiation is enabled, then
938          * software will have to set the "PAUSE" bits to the correct value in
939          * the Transmit Config Word Register (TXCW) and re-start auto-
940          * negotiation.  However, if auto-negotiation is disabled, then
941          * software will have to manually configure the two flow control enable
942          * bits in the CTRL register.
943          *
944          * The possible values of the "fc" parameter are:
945          *      0:  Flow control is completely disabled
946          *      1:  Rx flow control is enabled (we can receive pause frames,
947          *          but not send pause frames).
948          *      2:  Tx flow control is enabled (we can send pause frames but we
949          *          do not support receiving pause frames).
950          *      3:  Both Rx and Tx flow control (symmetric) are enabled.
951          */
952         switch (hw->fc.current_mode) {
953         case e1000_fc_none:
954                 /* Flow control completely disabled by a software over-ride. */
955                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD);
956                 break;
957         case e1000_fc_rx_pause:
958                 /*
959                  * Rx Flow control is enabled and Tx Flow control is disabled
960                  * by a software over-ride. Since there really isn't a way to
961                  * advertise that we are capable of Rx Pause ONLY, we will
962                  * advertise that we support both symmetric and asymmetric RX
963                  * PAUSE.  Later, we will disable the adapter's ability to send
964                  * PAUSE frames.
965                  */
966                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
967                 break;
968         case e1000_fc_tx_pause:
969                 /*
970                  * Tx Flow control is enabled, and Rx Flow control is disabled,
971                  * by a software over-ride.
972                  */
973                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR);
974                 break;
975         case e1000_fc_full:
976                 /*
977                  * Flow control (both Rx and Tx) is enabled by a software
978                  * over-ride.
979                  */
980                 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK);
981                 break;
982         default:
983                 e_dbg("Flow control param set incorrectly\n");
984                 ret_val = -E1000_ERR_CONFIG;
985                 goto out;
986                 break;
987         }
988
989         ew32(TXCW, txcw);
990         mac->txcw = txcw;
991
992 out:
993         return ret_val;
994 }
995
996 /**
997  *  e1000e_set_fc_watermarks - Set flow control high/low watermarks
998  *  @hw: pointer to the HW structure
999  *
1000  *  Sets the flow control high/low threshold (watermark) registers.  If
1001  *  flow control XON frame transmission is enabled, then set XON frame
1002  *  transmission as well.
1003  **/
1004 s32 e1000e_set_fc_watermarks(struct e1000_hw *hw)
1005 {
1006         s32 ret_val = E1000_SUCCESS;
1007         u32 fcrtl = 0, fcrth = 0;
1008
1009         /*
1010          * Set the flow control receive threshold registers.  Normally,
1011          * these registers will be set to a default threshold that may be
1012          * adjusted later by the driver's runtime code.  However, if the
1013          * ability to transmit pause frames is not enabled, then these
1014          * registers will be set to 0.
1015          */
1016         if (hw->fc.current_mode & e1000_fc_tx_pause) {
1017                 /*
1018                  * We need to set up the Receive Threshold high and low water
1019                  * marks as well as (optionally) enabling the transmission of
1020                  * XON frames.
1021                  */
1022                 fcrtl = hw->fc.low_water;
1023                 if (hw->fc.send_xon)
1024                         fcrtl |= E1000_FCRTL_XONE;
1025
1026                 fcrth = hw->fc.high_water;
1027         }
1028         ew32(FCRTL, fcrtl);
1029         ew32(FCRTH, fcrth);
1030
1031         return ret_val;
1032 }
1033
1034 /**
1035  *  e1000e_set_default_fc_generic - Set flow control default values
1036  *  @hw: pointer to the HW structure
1037  *
1038  *  Read the EEPROM for the default values for flow control and store the
1039  *  values.
1040  **/
1041 static s32 e1000e_set_default_fc_generic(struct e1000_hw *hw)
1042 {
1043         s32 ret_val = E1000_SUCCESS;
1044         u16 nvm_data;
1045
1046         /*
1047          * Read and store word 0x0F of the EEPROM. This word contains bits
1048          * that determine the hardware's default PAUSE (flow control) mode,
1049          * a bit that determines whether the HW defaults to enabling or
1050          * disabling auto-negotiation, and the direction of the
1051          * SW defined pins. If there is no SW over-ride of the flow
1052          * control setting, then the variable hw->fc will
1053          * be initialized based on a value in the EEPROM.
1054          */
1055         ret_val = e1000e_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &nvm_data);
1056
1057         if (ret_val) {
1058                 e_dbg("NVM Read Error\n");
1059                 goto out;
1060         }
1061
1062         if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == 0)
1063                 hw->fc.requested_mode = e1000_fc_none;
1064         else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) ==
1065                  NVM_WORD0F_ASM_DIR)
1066                 hw->fc.requested_mode = e1000_fc_tx_pause;
1067         else
1068                 hw->fc.requested_mode = e1000_fc_full;
1069
1070 out:
1071         return ret_val;
1072 }
1073
1074 /**
1075  *  e1000e_force_mac_fc - Force the MAC's flow control settings
1076  *  @hw: pointer to the HW structure
1077  *
1078  *  Force the MAC's flow control settings.  Sets the TFCE and RFCE bits in the
1079  *  device control register to reflect the adapter settings.  TFCE and RFCE
1080  *  need to be explicitly set by software when a copper PHY is used because
1081  *  autonegotiation is managed by the PHY rather than the MAC.  Software must
1082  *  also configure these bits when link is forced on a fiber connection.
1083  **/
1084 s32 e1000e_force_mac_fc(struct e1000_hw *hw)
1085 {
1086         u32 ctrl;
1087         s32 ret_val = E1000_SUCCESS;
1088
1089         ctrl = er32(CTRL);
1090
1091         /*
1092          * Because we didn't get link via the internal auto-negotiation
1093          * mechanism (we either forced link or we got link via PHY
1094          * auto-neg), we have to manually enable/disable transmit an
1095          * receive flow control.
1096          *
1097          * The "Case" statement below enables/disable flow control
1098          * according to the "hw->fc.current_mode" parameter.
1099          *
1100          * The possible values of the "fc" parameter are:
1101          *      0:  Flow control is completely disabled
1102          *      1:  Rx flow control is enabled (we can receive pause
1103          *          frames but not send pause frames).
1104          *      2:  Tx flow control is enabled (we can send pause frames
1105          *          frames but we do not receive pause frames).
1106          *      3:  Both Rx and Tx flow control (symmetric) is enabled.
1107          *  other:  No other values should be possible at this point.
1108          */
1109         e_dbg("hw->fc.current_mode = %u\n", hw->fc.current_mode);
1110
1111         switch (hw->fc.current_mode) {
1112         case e1000_fc_none:
1113                 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
1114                 break;
1115         case e1000_fc_rx_pause:
1116                 ctrl &= (~E1000_CTRL_TFCE);
1117                 ctrl |= E1000_CTRL_RFCE;
1118                 break;
1119         case e1000_fc_tx_pause:
1120                 ctrl &= (~E1000_CTRL_RFCE);
1121                 ctrl |= E1000_CTRL_TFCE;
1122                 break;
1123         case e1000_fc_full:
1124                 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE);
1125                 break;
1126         default:
1127                 e_dbg("Flow control param set incorrectly\n");
1128                 ret_val = -E1000_ERR_CONFIG;
1129                 goto out;
1130         }
1131
1132         ew32(CTRL, ctrl);
1133
1134 out:
1135         return ret_val;
1136 }
1137
1138 /**
1139  *  e1000e_config_fc_after_link_up - Configures flow control after link
1140  *  @hw: pointer to the HW structure
1141  *
1142  *  Checks the status of auto-negotiation after link up to ensure that the
1143  *  speed and duplex were not forced.  If the link needed to be forced, then
1144  *  flow control needs to be forced also.  If auto-negotiation is enabled
1145  *  and did not fail, then we configure flow control based on our link
1146  *  partner.
1147  **/
1148 s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw)
1149 {
1150         struct e1000_mac_info *mac = &hw->mac;
1151         s32 ret_val = E1000_SUCCESS;
1152         u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg;
1153         u16 speed, duplex;
1154
1155         /*
1156          * Check for the case where we have fiber media and auto-neg failed
1157          * so we had to force link.  In this case, we need to force the
1158          * configuration of the MAC to match the "fc" parameter.
1159          */
1160         if (mac->autoneg_failed) {
1161                 if (hw->phy.media_type == e1000_media_type_fiber ||
1162                     hw->phy.media_type == e1000_media_type_internal_serdes)
1163                         ret_val = e1000e_force_mac_fc(hw);
1164         } else {
1165                 if (hw->phy.media_type == e1000_media_type_copper)
1166                         ret_val = e1000e_force_mac_fc(hw);
1167         }
1168
1169         if (ret_val) {
1170                 e_dbg("Error forcing flow control settings\n");
1171                 goto out;
1172         }
1173
1174         /*
1175          * Check for the case where we have copper media and auto-neg is
1176          * enabled.  In this case, we need to check and see if Auto-Neg
1177          * has completed, and if so, how the PHY and link partner has
1178          * flow control configured.
1179          */
1180         if ((hw->phy.media_type == e1000_media_type_copper) && mac->autoneg) {
1181                 /*
1182                  * Read the MII Status Register and check to see if AutoNeg
1183                  * has completed.  We read this twice because this reg has
1184                  * some "sticky" (latched) bits.
1185                  */
1186                 ret_val = e1e_rphy(hw, PHY_STATUS, &mii_status_reg);
1187                 if (ret_val)
1188                         goto out;
1189                 ret_val = e1e_rphy(hw, PHY_STATUS, &mii_status_reg);
1190                 if (ret_val)
1191                         goto out;
1192
1193                 if (!(mii_status_reg & MII_SR_AUTONEG_COMPLETE)) {
1194                         e_dbg("Copper PHY and Auto Neg "
1195                                  "has not completed.\n");
1196                         goto out;
1197                 }
1198
1199                 /*
1200                  * The AutoNeg process has completed, so we now need to
1201                  * read both the Auto Negotiation Advertisement
1202                  * Register (Address 4) and the Auto_Negotiation Base
1203                  * Page Ability Register (Address 5) to determine how
1204                  * flow control was negotiated.
1205                  */
1206                 ret_val = e1e_rphy(hw, PHY_AUTONEG_ADV,
1207                                              &mii_nway_adv_reg);
1208                 if (ret_val)
1209                         goto out;
1210                 ret_val = e1e_rphy(hw, PHY_LP_ABILITY,
1211                                              &mii_nway_lp_ability_reg);
1212                 if (ret_val)
1213                         goto out;
1214
1215                 /*
1216                  * Two bits in the Auto Negotiation Advertisement Register
1217                  * (Address 4) and two bits in the Auto Negotiation Base
1218                  * Page Ability Register (Address 5) determine flow control
1219                  * for both the PHY and the link partner.  The following
1220                  * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1221                  * 1999, describes these PAUSE resolution bits and how flow
1222                  * control is determined based upon these settings.
1223                  * NOTE:  DC = Don't Care
1224                  *
1225                  *   LOCAL DEVICE  |   LINK PARTNER
1226                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1227                  *-------|---------|-------|---------|--------------------
1228                  *   0   |    0    |  DC   |   DC    | e1000_fc_none
1229                  *   0   |    1    |   0   |   DC    | e1000_fc_none
1230                  *   0   |    1    |   1   |    0    | e1000_fc_none
1231                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1232                  *   1   |    0    |   0   |   DC    | e1000_fc_none
1233                  *   1   |   DC    |   1   |   DC    | e1000_fc_full
1234                  *   1   |    1    |   0   |    0    | e1000_fc_none
1235                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1236                  *
1237                  * Are both PAUSE bits set to 1?  If so, this implies
1238                  * Symmetric Flow Control is enabled at both ends.  The
1239                  * ASM_DIR bits are irrelevant per the spec.
1240                  *
1241                  * For Symmetric Flow Control:
1242                  *
1243                  *   LOCAL DEVICE  |   LINK PARTNER
1244                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1245                  *-------|---------|-------|---------|--------------------
1246                  *   1   |   DC    |   1   |   DC    | E1000_fc_full
1247                  *
1248                  */
1249                 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1250                     (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {
1251                         /*
1252                          * Now we need to check if the user selected Rx ONLY
1253                          * of pause frames.  In this case, we had to advertise
1254                          * FULL flow control because we could not advertise RX
1255                          * ONLY. Hence, we must now check to see if we need to
1256                          * turn OFF  the TRANSMISSION of PAUSE frames.
1257                          */
1258                         if (hw->fc.requested_mode == e1000_fc_full) {
1259                                 hw->fc.current_mode = e1000_fc_full;
1260                                 e_dbg("Flow Control = FULL.\r\n");
1261                         } else {
1262                                 hw->fc.current_mode = e1000_fc_rx_pause;
1263                                 e_dbg("Flow Control = "
1264                                          "RX PAUSE frames only.\r\n");
1265                         }
1266                 }
1267                 /*
1268                  * For receiving PAUSE frames ONLY.
1269                  *
1270                  *   LOCAL DEVICE  |   LINK PARTNER
1271                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1272                  *-------|---------|-------|---------|--------------------
1273                  *   0   |    1    |   1   |    1    | e1000_fc_tx_pause
1274                  */
1275                 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1276                           (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1277                           (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1278                           (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1279                         hw->fc.current_mode = e1000_fc_tx_pause;
1280                         e_dbg("Flow Control = TX PAUSE frames only.\r\n");
1281                 }
1282                 /*
1283                  * For transmitting PAUSE frames ONLY.
1284                  *
1285                  *   LOCAL DEVICE  |   LINK PARTNER
1286                  * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1287                  *-------|---------|-------|---------|--------------------
1288                  *   1   |    1    |   0   |    1    | e1000_fc_rx_pause
1289                  */
1290                 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) &&
1291                          (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
1292                          !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
1293                          (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
1294                         hw->fc.current_mode = e1000_fc_rx_pause;
1295                         e_dbg("Flow Control = RX PAUSE frames only.\r\n");
1296                 } else {
1297                         /*
1298                          * Per the IEEE spec, at this point flow control
1299                          * should be disabled.
1300                          */
1301                         hw->fc.current_mode = e1000_fc_none;
1302                         e_dbg("Flow Control = NONE.\r\n");
1303                 }
1304
1305                 /*
1306                  * Now we need to do one last check...  If we auto-
1307                  * negotiated to HALF DUPLEX, flow control should not be
1308                  * enabled per IEEE 802.3 spec.
1309                  */
1310                 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex);
1311                 if (ret_val) {
1312                         e_dbg("Error getting link speed and duplex\n");
1313                         goto out;
1314                 }
1315
1316                 if (duplex == HALF_DUPLEX)
1317                         hw->fc.current_mode = e1000_fc_none;
1318
1319                 /*
1320                  * Now we call a subroutine to actually force the MAC
1321                  * controller to use the correct flow control settings.
1322                  */
1323                 ret_val = e1000e_force_mac_fc(hw);
1324                 if (ret_val) {
1325                         e_dbg("Error forcing flow control settings\n");
1326                         goto out;
1327                 }
1328         }
1329
1330 out:
1331         return ret_val;
1332 }
1333
1334 /**
1335  *  e1000e_get_speed_and_duplex_copper - Retrieve current speed/duplex
1336  *  @hw: pointer to the HW structure
1337  *  @speed: stores the current speed
1338  *  @duplex: stores the current duplex
1339  *
1340  *  Read the status register for the current speed/duplex and store the current
1341  *  speed and duplex for copper connections.
1342  **/
1343 s32 e1000e_get_speed_and_duplex_copper(struct e1000_hw *hw, u16 *speed,
1344                                               u16 *duplex)
1345 {
1346         u32 status;
1347
1348         status = er32(STATUS);
1349         if (status & E1000_STATUS_SPEED_1000) {
1350                 *speed = SPEED_1000;
1351                 e_dbg("1000 Mbs, ");
1352         } else if (status & E1000_STATUS_SPEED_100) {
1353                 *speed = SPEED_100;
1354                 e_dbg("100 Mbs, ");
1355         } else {
1356                 *speed = SPEED_10;
1357                 e_dbg("10 Mbs, ");
1358         }
1359
1360         if (status & E1000_STATUS_FD) {
1361                 *duplex = FULL_DUPLEX;
1362                 e_dbg("Full Duplex\n");
1363         } else {
1364                 *duplex = HALF_DUPLEX;
1365                 e_dbg("Half Duplex\n");
1366         }
1367
1368         return E1000_SUCCESS;
1369 }
1370
1371 /**
1372  *  e1000e_get_speed_and_duplex_fiber_generic - Retrieve current speed/duplex
1373  *  @hw: pointer to the HW structure
1374  *  @speed: stores the current speed
1375  *  @duplex: stores the current duplex
1376  *
1377  *  Sets the speed and duplex to gigabit full duplex (the only possible option)
1378  *  for fiber/serdes links.
1379  **/
1380 s32 e1000e_get_speed_and_duplex_fiber_serdes(struct e1000_hw *hw __unused,
1381                                                     u16 *speed, u16 *duplex)
1382 {
1383         *speed = SPEED_1000;
1384         *duplex = FULL_DUPLEX;
1385
1386         return E1000_SUCCESS;
1387 }
1388
1389 /**
1390  *  e1000e_get_hw_semaphore - Acquire hardware semaphore
1391  *  @hw: pointer to the HW structure
1392  *
1393  *  Acquire the HW semaphore to access the PHY or NVM
1394  **/
1395 s32 e1000e_get_hw_semaphore(struct e1000_hw *hw)
1396 {
1397         u32 swsm;
1398         s32 ret_val = E1000_SUCCESS;
1399         s32 timeout = hw->nvm.word_size + 1;
1400         s32 i = 0;
1401
1402         /* Get the SW semaphore */
1403         while (i < timeout) {
1404                 swsm = er32(SWSM);
1405                 if (!(swsm & E1000_SWSM_SMBI))
1406                         break;
1407
1408                 udelay(50);
1409                 i++;
1410         }
1411
1412         if (i == timeout) {
1413                 e_dbg("Driver can't access device - SMBI bit is set.\n");
1414                 ret_val = -E1000_ERR_NVM;
1415                 goto out;
1416         }
1417
1418         /* Get the FW semaphore. */
1419         for (i = 0; i < timeout; i++) {
1420                 swsm = er32(SWSM);
1421                 ew32(SWSM, swsm | E1000_SWSM_SWESMBI);
1422
1423                 /* Semaphore acquired if bit latched */
1424                 if (er32(SWSM) & E1000_SWSM_SWESMBI)
1425                         break;
1426
1427                 udelay(50);
1428         }
1429
1430         if (i == timeout) {
1431                 /* Release semaphores */
1432                 e1000e_put_hw_semaphore(hw);
1433                 e_dbg("Driver can't access the NVM\n");
1434                 ret_val = -E1000_ERR_NVM;
1435                 goto out;
1436         }
1437
1438 out:
1439         return ret_val;
1440 }
1441
1442 /**
1443  *  e1000e_put_hw_semaphore - Release hardware semaphore
1444  *  @hw: pointer to the HW structure
1445  *
1446  *  Release hardware semaphore used to access the PHY or NVM
1447  **/
1448 void e1000e_put_hw_semaphore(struct e1000_hw *hw)
1449 {
1450         u32 swsm;
1451
1452         swsm = er32(SWSM);
1453         swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI);
1454         ew32(SWSM, swsm);
1455 }
1456 /**
1457  *  e1000e_get_auto_rd_done - Check for auto read completion
1458  *  @hw: pointer to the HW structure
1459  *
1460  *  Check EEPROM for Auto Read done bit.
1461  **/
1462 s32 e1000e_get_auto_rd_done(struct e1000_hw *hw)
1463 {
1464         s32 i = 0;
1465         s32 ret_val = E1000_SUCCESS;
1466
1467         while (i < AUTO_READ_DONE_TIMEOUT) {
1468                 if (er32(EECD) & E1000_EECD_AUTO_RD)
1469                         break;
1470                 msleep(1);
1471                 i++;
1472         }
1473
1474         if (i == AUTO_READ_DONE_TIMEOUT) {
1475                 e_dbg("Auto read by HW from NVM has not completed.\n");
1476                 ret_val = -E1000_ERR_RESET;
1477                 goto out;
1478         }
1479
1480 out:
1481         return ret_val;
1482 }
1483
1484 /**
1485  *  e1000e_valid_led_default - Verify a valid default LED config
1486  *  @hw: pointer to the HW structure
1487  *  @data: pointer to the NVM (EEPROM)
1488  *
1489  *  Read the EEPROM for the current default LED configuration.  If the
1490  *  LED configuration is not valid, set to a valid LED configuration.
1491  **/
1492 s32 e1000e_valid_led_default(struct e1000_hw *hw, u16 *data)
1493 {
1494         s32 ret_val;
1495
1496         ret_val = e1000e_read_nvm(hw, NVM_ID_LED_SETTINGS, 1, data);
1497         if (ret_val) {
1498                 e_dbg("NVM Read Error\n");
1499                 goto out;
1500         }
1501
1502         if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF)
1503                 *data = ID_LED_DEFAULT;
1504
1505 out:
1506         return ret_val;
1507 }
1508
1509 /**
1510  *  e1000e_id_led_init -
1511  *  @hw: pointer to the HW structure
1512  *
1513  **/
1514 s32 e1000e_id_led_init(struct e1000_hw *hw __unused)
1515 {
1516 #if 0
1517         struct e1000_mac_info *mac = &hw->mac;
1518         s32 ret_val;
1519         const u32 ledctl_mask = 0x000000FF;
1520         const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON;
1521         const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF;
1522         u16 data, i, temp;
1523         const u16 led_mask = 0x0F;
1524
1525         ret_val = hw->nvm.ops.valid_led_default(hw, &data);
1526         if (ret_val)
1527                 goto out;
1528
1529         mac->ledctl_default = er32(LEDCTL);
1530         mac->ledctl_mode1 = mac->ledctl_default;
1531         mac->ledctl_mode2 = mac->ledctl_default;
1532
1533         for (i = 0; i < 4; i++) {
1534                 temp = (data >> (i << 2)) & led_mask;
1535                 switch (temp) {
1536                 case ID_LED_ON1_DEF2:
1537                 case ID_LED_ON1_ON2:
1538                 case ID_LED_ON1_OFF2:
1539                         mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1540                         mac->ledctl_mode1 |= ledctl_on << (i << 3);
1541                         break;
1542                 case ID_LED_OFF1_DEF2:
1543                 case ID_LED_OFF1_ON2:
1544                 case ID_LED_OFF1_OFF2:
1545                         mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3));
1546                         mac->ledctl_mode1 |= ledctl_off << (i << 3);
1547                         break;
1548                 default:
1549                         /* Do nothing */
1550                         break;
1551                 }
1552                 switch (temp) {
1553                 case ID_LED_DEF1_ON2:
1554                 case ID_LED_ON1_ON2:
1555                 case ID_LED_OFF1_ON2:
1556                         mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1557                         mac->ledctl_mode2 |= ledctl_on << (i << 3);
1558                         break;
1559                 case ID_LED_DEF1_OFF2:
1560                 case ID_LED_ON1_OFF2:
1561                 case ID_LED_OFF1_OFF2:
1562                         mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3));
1563                         mac->ledctl_mode2 |= ledctl_off << (i << 3);
1564                         break;
1565                 default:
1566                         /* Do nothing */
1567                         break;
1568                 }
1569         }
1570
1571 out:
1572         return ret_val;
1573 #endif
1574         return E1000_SUCCESS;
1575 }
1576
1577 /**
1578  *  e1000e_setup_led_generic - Configures SW controllable LED
1579  *  @hw: pointer to the HW structure
1580  *
1581  *  This prepares the SW controllable LED for use and saves the current state
1582  *  of the LED so it can be later restored.
1583  **/
1584 s32 e1000e_setup_led_generic(struct e1000_hw *hw __unused)
1585 {
1586 #if 0
1587         u32 ledctl;
1588         s32 ret_val = E1000_SUCCESS;
1589
1590         if (hw->mac.ops.setup_led != e1000e_setup_led_generic) {
1591                 ret_val = -E1000_ERR_CONFIG;
1592                 goto out;
1593         }
1594
1595         if (hw->phy.media_type == e1000_media_type_fiber) {
1596                 ledctl = er32(LEDCTL);
1597                 hw->mac.ledctl_default = ledctl;
1598                 /* Turn off LED0 */
1599                 ledctl &= ~(E1000_LEDCTL_LED0_IVRT |
1600                             E1000_LEDCTL_LED0_BLINK |
1601                             E1000_LEDCTL_LED0_MODE_MASK);
1602                 ledctl |= (E1000_LEDCTL_MODE_LED_OFF <<
1603                            E1000_LEDCTL_LED0_MODE_SHIFT);
1604                 ew32(LEDCTL, ledctl);
1605         } else if (hw->phy.media_type == e1000_media_type_copper) {
1606                 ew32(LEDCTL, hw->mac.ledctl_mode1);
1607         }
1608
1609 out:
1610         return ret_val;
1611 #endif
1612         return E1000_SUCCESS;
1613 }
1614
1615 /**
1616  *  e1000e_cleanup_led_generic - Set LED config to default operation
1617  *  @hw: pointer to the HW structure
1618  *
1619  *  Remove the current LED configuration and set the LED configuration
1620  *  to the default value, saved from the EEPROM.
1621  **/
1622 s32 e1000e_cleanup_led_generic(struct e1000_hw *hw __unused)
1623 {
1624 #if 0
1625         s32 ret_val = E1000_SUCCESS;
1626
1627         if (hw->mac.ops.cleanup_led != e1000e_cleanup_led_generic) {
1628                 ret_val = -E1000_ERR_CONFIG;
1629                 goto out;
1630         }
1631
1632         ew32(LEDCTL, hw->mac.ledctl_default);
1633
1634 out:
1635         return ret_val;
1636 #endif
1637         return E1000_SUCCESS;
1638 }
1639
1640 /**
1641  *  e1000e_blink_led - Blink LED
1642  *  @hw: pointer to the HW structure
1643  *
1644  *  Blink the LEDs which are set to be on.
1645  **/
1646 s32 e1000e_blink_led(struct e1000_hw *hw __unused)
1647 {
1648 #if 0
1649         u32 ledctl_blink = 0;
1650         u32 i;
1651
1652         if (hw->phy.media_type == e1000_media_type_fiber) {
1653                 /* always blink LED0 for PCI-E fiber */
1654                 ledctl_blink = E1000_LEDCTL_LED0_BLINK |
1655                      (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
1656         } else {
1657                 /*
1658                  * set the blink bit for each LED that's "on" (0x0E)
1659                  * in ledctl_mode2
1660                  */
1661                 ledctl_blink = hw->mac.ledctl_mode2;
1662                 for (i = 0; i < 4; i++)
1663                         if (((hw->mac.ledctl_mode2 >> (i * 8)) & 0xFF) ==
1664                             E1000_LEDCTL_MODE_LED_ON)
1665                                 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK <<
1666                                                  (i * 8));
1667         }
1668
1669         ew32(LEDCTL, ledctl_blink);
1670 #endif
1671         return E1000_SUCCESS;
1672 }
1673
1674 /**
1675  *  e1000e_led_on_generic - Turn LED on
1676  *  @hw: pointer to the HW structure
1677  *
1678  *  Turn LED on.
1679  **/
1680 s32 e1000e_led_on_generic(struct e1000_hw *hw __unused)
1681 {
1682 #if 0
1683         u32 ctrl;
1684
1685         switch (hw->phy.media_type) {
1686         case e1000_media_type_fiber:
1687                 ctrl = er32(CTRL);
1688                 ctrl &= ~E1000_CTRL_SWDPIN0;
1689                 ctrl |= E1000_CTRL_SWDPIO0;
1690                 ew32(CTRL, ctrl);
1691                 break;
1692         case e1000_media_type_copper:
1693                 ew32(LEDCTL, hw->mac.ledctl_mode2);
1694                 break;
1695         default:
1696                 break;
1697         }
1698 #endif
1699         return E1000_SUCCESS;
1700 }
1701
1702 /**
1703  *  e1000e_led_off_generic - Turn LED off
1704  *  @hw: pointer to the HW structure
1705  *
1706  *  Turn LED off.
1707  **/
1708 s32 e1000e_led_off_generic(struct e1000_hw *hw __unused)
1709 {
1710 #if 0
1711         u32 ctrl;
1712
1713         switch (hw->phy.media_type) {
1714         case e1000_media_type_fiber:
1715                 ctrl = er32(CTRL);
1716                 ctrl |= E1000_CTRL_SWDPIN0;
1717                 ctrl |= E1000_CTRL_SWDPIO0;
1718                 ew32(CTRL, ctrl);
1719                 break;
1720         case e1000_media_type_copper:
1721                 ew32(LEDCTL, hw->mac.ledctl_mode1);
1722                 break;
1723         default:
1724                 break;
1725         }
1726 #endif
1727         return E1000_SUCCESS;
1728 }
1729
1730 /**
1731  *  e1000e_set_pcie_no_snoop - Set PCI-express capabilities
1732  *  @hw: pointer to the HW structure
1733  *  @no_snoop: bitmap of snoop events
1734  *
1735  *  Set the PCI-express register to snoop for events enabled in 'no_snoop'.
1736  **/
1737 void e1000e_set_pcie_no_snoop(struct e1000_hw *hw, u32 no_snoop)
1738 {
1739         u32 gcr;
1740
1741         if (hw->bus.type != e1000_bus_type_pci_express)
1742                 goto out;
1743
1744         if (no_snoop) {
1745                 gcr = er32(GCR);
1746                 gcr &= ~(PCIE_NO_SNOOP_ALL);
1747                 gcr |= no_snoop;
1748                 ew32(GCR, gcr);
1749         }
1750 out:
1751         return;
1752 }
1753
1754 /**
1755  *  e1000e_disable_pcie_master - Disables PCI-express master access
1756  *  @hw: pointer to the HW structure
1757  *
1758  *  Returns 0 (E1000_SUCCESS) if successful, else returns -10
1759  *  (-E1000_ERR_MASTER_REQUESTS_PENDING) if master disable bit has not caused
1760  *  the master requests to be disabled.
1761  *
1762  *  Disables PCI-Express master access and verifies there are no pending
1763  *  requests.
1764  **/
1765 s32 e1000e_disable_pcie_master(struct e1000_hw *hw)
1766 {
1767         u32 ctrl;
1768         s32 timeout = MASTER_DISABLE_TIMEOUT;
1769         s32 ret_val = E1000_SUCCESS;
1770
1771         if (hw->bus.type != e1000_bus_type_pci_express)
1772                 goto out;
1773
1774         ctrl = er32(CTRL);
1775         ctrl |= E1000_CTRL_GIO_MASTER_DISABLE;
1776         ew32(CTRL, ctrl);
1777
1778         while (timeout) {
1779                 if (!(er32(STATUS) &
1780                       E1000_STATUS_GIO_MASTER_ENABLE))
1781                         break;
1782                 udelay(100);
1783                 timeout--;
1784         }
1785
1786         if (!timeout) {
1787                 e_dbg("Master requests are pending.\n");
1788                 ret_val = -E1000_ERR_MASTER_REQUESTS_PENDING;
1789                 goto out;
1790         }
1791
1792 out:
1793         return ret_val;
1794 }
1795
1796 /**
1797  *  e1000e_reset_adaptive - Reset Adaptive Interframe Spacing
1798  *  @hw: pointer to the HW structure
1799  *
1800  *  Reset the Adaptive Interframe Spacing throttle to default values.
1801  **/
1802 void e1000e_reset_adaptive(struct e1000_hw *hw)
1803 {
1804         struct e1000_mac_info *mac = &hw->mac;
1805
1806         if (!mac->adaptive_ifs) {
1807                 e_dbg("Not in Adaptive IFS mode!\n");
1808                 goto out;
1809         }
1810
1811         mac->current_ifs_val = 0;
1812         mac->ifs_min_val = IFS_MIN;
1813         mac->ifs_max_val = IFS_MAX;
1814         mac->ifs_step_size = IFS_STEP;
1815         mac->ifs_ratio = IFS_RATIO;
1816
1817         mac->in_ifs_mode = false;
1818         ew32(AIT, 0);
1819 out:
1820         return;
1821 }
1822
1823 /**
1824  *  e1000e_update_adaptive - Update Adaptive Interframe Spacing
1825  *  @hw: pointer to the HW structure
1826  *
1827  *  Update the Adaptive Interframe Spacing Throttle value based on the
1828  *  time between transmitted packets and time between collisions.
1829  **/
1830 void e1000e_update_adaptive(struct e1000_hw *hw)
1831 {
1832         struct e1000_mac_info *mac = &hw->mac;
1833
1834         if (!mac->adaptive_ifs) {
1835                 e_dbg("Not in Adaptive IFS mode!\n");
1836                 goto out;
1837         }
1838
1839         if ((mac->collision_delta * mac->ifs_ratio) > mac->tx_packet_delta) {
1840                 if (mac->tx_packet_delta > MIN_NUM_XMITS) {
1841                         mac->in_ifs_mode = true;
1842                         if (mac->current_ifs_val < mac->ifs_max_val) {
1843                                 if (!mac->current_ifs_val)
1844                                         mac->current_ifs_val = mac->ifs_min_val;
1845                                 else
1846                                         mac->current_ifs_val +=
1847                                                 mac->ifs_step_size;
1848                                 ew32(AIT, mac->current_ifs_val);
1849                         }
1850                 }
1851         } else {
1852                 if (mac->in_ifs_mode &&
1853                     (mac->tx_packet_delta <= MIN_NUM_XMITS)) {
1854                         mac->current_ifs_val = 0;
1855                         mac->in_ifs_mode = false;
1856                         ew32(AIT, 0);
1857                 }
1858         }
1859 out:
1860         return;
1861 }
1862
1863 /**
1864  *  e1000e_validate_mdi_setting_generic - Verify MDI/MDIx settings
1865  *  @hw: pointer to the HW structure
1866  *
1867  *  Verify that when not using auto-negotiation that MDI/MDIx is correctly
1868  *  set, which is forced to MDI mode only.
1869  **/
1870 static s32 e1000e_validate_mdi_setting_generic(struct e1000_hw *hw)
1871 {
1872         s32 ret_val = E1000_SUCCESS;
1873
1874         if (!hw->mac.autoneg && (hw->phy.mdix == 0 || hw->phy.mdix == 3)) {
1875                 e_dbg("Invalid MDI setting detected\n");
1876                 hw->phy.mdix = 1;
1877                 ret_val = -E1000_ERR_CONFIG;
1878                 goto out;
1879         }
1880
1881 out:
1882         return ret_val;
1883 }