[igb] Add igb driver
[people/pcmattman/gpxe.git] / src / drivers / net / igb / igb_82575.c
1 /*******************************************************************************
2
3   Intel(R) Gigabit Ethernet Linux driver
4   Copyright(c) 2007-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   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25
26 *******************************************************************************/
27
28 FILE_LICENCE ( GPL2_ONLY );
29
30 /*
31  * 82575EB Gigabit Network Connection
32  * 82575EB Gigabit Backplane Connection
33  * 82575GB Gigabit Network Connection
34  * 82576 Gigabit Network Connection
35  * 82576 Quad Port Gigabit Mezzanine Adapter
36  */
37
38 #include "igb.h"
39
40 static s32  igb_init_phy_params_82575(struct e1000_hw *hw);
41 static s32  igb_init_nvm_params_82575(struct e1000_hw *hw);
42 static s32  igb_init_mac_params_82575(struct e1000_hw *hw);
43 static s32  igb_acquire_phy_82575(struct e1000_hw *hw);
44 static void igb_release_phy_82575(struct e1000_hw *hw);
45 static s32  igb_acquire_nvm_82575(struct e1000_hw *hw);
46 static void igb_release_nvm_82575(struct e1000_hw *hw);
47 static s32  igb_check_for_link_82575(struct e1000_hw *hw);
48 static s32  igb_get_cfg_done_82575(struct e1000_hw *hw);
49 static s32  igb_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
50                                          u16 *duplex);
51 static s32  igb_init_hw_82575(struct e1000_hw *hw);
52 static s32  igb_phy_hw_reset_sgmii_82575(struct e1000_hw *hw);
53 static s32  igb_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
54                                            u16 *data);
55 static s32  igb_reset_hw_82575(struct e1000_hw *hw);
56 static s32  igb_set_d0_lplu_state_82575(struct e1000_hw *hw,
57                                           bool active);
58 static s32  igb_setup_copper_link_82575(struct e1000_hw *hw);
59 static s32  igb_setup_serdes_link_82575(struct e1000_hw *hw);
60 static s32  igb_valid_led_default_82575(struct e1000_hw *hw, u16 *data);
61 static s32  igb_write_phy_reg_sgmii_82575(struct e1000_hw *hw,
62                                             u32 offset, u16 data);
63 static void igb_clear_hw_cntrs_82575(struct e1000_hw *hw);
64 static s32  igb_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
65 static s32  igb_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
66                                                  u16 *speed, u16 *duplex);
67 static s32  igb_get_phy_id_82575(struct e1000_hw *hw);
68 static void igb_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
69 static bool igb_sgmii_active_82575(struct e1000_hw *hw);
70 static s32  igb_reset_init_script_82575(struct e1000_hw *hw);
71 static s32  igb_read_mac_addr_82575(struct e1000_hw *hw);
72 static void igb_power_down_phy_copper_82575(struct e1000_hw *hw);
73 static void igb_shutdown_serdes_link_82575(struct e1000_hw *hw);
74 static s32 igb_set_pcie_completion_timeout(struct e1000_hw *hw);
75
76 /**
77  *  igb_init_phy_params_82575 - Init PHY func ptrs.
78  *  @hw: pointer to the HW structure
79  **/
80 static s32 igb_init_phy_params_82575(struct e1000_hw *hw)
81 {
82         struct e1000_phy_info *phy = &hw->phy;
83         s32 ret_val = E1000_SUCCESS;
84
85         DEBUGFUNC("igb_init_phy_params_82575");
86
87         if (hw->phy.media_type != e1000_media_type_copper) {
88                 phy->type = e1000_phy_none;
89                 goto out;
90         }
91
92         phy->ops.power_up   = igb_power_up_phy_copper;
93         phy->ops.power_down = igb_power_down_phy_copper_82575;
94
95         phy->autoneg_mask           = AUTONEG_ADVERTISE_SPEED_DEFAULT;
96         phy->reset_delay_us         = 100;
97
98         phy->ops.acquire            = igb_acquire_phy_82575;
99         phy->ops.check_reset_block  = igb_check_reset_block_generic;
100         phy->ops.commit             = igb_phy_sw_reset_generic;
101         phy->ops.get_cfg_done       = igb_get_cfg_done_82575;
102         phy->ops.release            = igb_release_phy_82575;
103
104         if (igb_sgmii_active_82575(hw)) {
105                 phy->ops.reset      = igb_phy_hw_reset_sgmii_82575;
106                 phy->ops.read_reg   = igb_read_phy_reg_sgmii_82575;
107                 phy->ops.write_reg  = igb_write_phy_reg_sgmii_82575;
108         } else {
109                 phy->ops.reset      = igb_phy_hw_reset_generic;
110                 phy->ops.read_reg   = igb_read_phy_reg_igp;
111                 phy->ops.write_reg  = igb_write_phy_reg_igp;
112         }
113
114         /* Set phy->phy_addr and phy->id. */
115         ret_val = igb_get_phy_id_82575(hw);
116
117         /* Verify phy id and set remaining function pointers */
118         switch (phy->id) {
119         case M88E1111_I_PHY_ID:
120                 phy->type                   = e1000_phy_m88;
121                 phy->ops.check_polarity     = igb_check_polarity_m88;
122                 phy->ops.get_info           = igb_get_phy_info_m88;
123 #if 0
124                 phy->ops.get_cable_length   = igb_get_cable_length_m88;
125 #endif
126 #if 0
127                 phy->ops.force_speed_duplex = igb_phy_force_speed_duplex_m88;
128 #endif
129                 break;
130         case IGP03E1000_E_PHY_ID:
131         case IGP04E1000_E_PHY_ID:
132                 phy->type                   = e1000_phy_igp_3;
133                 phy->ops.check_polarity     = igb_check_polarity_igp;
134                 phy->ops.get_info           = igb_get_phy_info_igp;
135 #if 0
136                 phy->ops.get_cable_length   = igb_get_cable_length_igp_2;
137 #endif
138 #if 0
139                 phy->ops.force_speed_duplex = igb_phy_force_speed_duplex_igp;
140 #endif
141                 phy->ops.set_d0_lplu_state  = igb_set_d0_lplu_state_82575;
142                 phy->ops.set_d3_lplu_state  = igb_set_d3_lplu_state_generic;
143                 break;
144         default:
145                 ret_val = -E1000_ERR_PHY;
146                 goto out;
147         }
148
149 out:
150         return ret_val;
151 }
152
153 /**
154  *  igb_init_nvm_params_82575 - Init NVM func ptrs.
155  *  @hw: pointer to the HW structure
156  **/
157 static s32 igb_init_nvm_params_82575(struct e1000_hw *hw)
158 {
159         struct e1000_nvm_info *nvm = &hw->nvm;
160         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
161         u16 size;
162
163         DEBUGFUNC("igb_init_nvm_params_82575");
164
165         nvm->opcode_bits        = 8;
166         nvm->delay_usec         = 1;
167         switch (nvm->override) {
168         case e1000_nvm_override_spi_large:
169                 nvm->page_size    = 32;
170                 nvm->address_bits = 16;
171                 break;
172         case e1000_nvm_override_spi_small:
173                 nvm->page_size    = 8;
174                 nvm->address_bits = 8;
175                 break;
176         default:
177                 nvm->page_size    = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;
178                 nvm->address_bits = eecd & E1000_EECD_ADDR_BITS ? 16 : 8;
179                 break;
180         }
181
182         nvm->type              = e1000_nvm_eeprom_spi;
183
184         size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>
185                           E1000_EECD_SIZE_EX_SHIFT);
186
187         /*
188          * Added to a constant, "size" becomes the left-shift value
189          * for setting word_size.
190          */
191         size += NVM_WORD_SIZE_BASE_SHIFT;
192
193         /* EEPROM access above 16k is unsupported */
194         if (size > 14)
195                 size = 14;
196         nvm->word_size = 1 << size;
197
198         /* Function Pointers */
199         nvm->ops.acquire       = igb_acquire_nvm_82575;
200         nvm->ops.read          = igb_read_nvm_eerd;
201         nvm->ops.release       = igb_release_nvm_82575;
202         nvm->ops.update        = igb_update_nvm_checksum_generic;
203         nvm->ops.valid_led_default = igb_valid_led_default_82575;
204         nvm->ops.validate      = igb_validate_nvm_checksum_generic;
205         nvm->ops.write         = igb_write_nvm_spi;
206
207         return E1000_SUCCESS;
208 }
209
210 /**
211  *  igb_init_mac_params_82575 - Init MAC func ptrs.
212  *  @hw: pointer to the HW structure
213  **/
214 static s32 igb_init_mac_params_82575(struct e1000_hw *hw)
215 {
216         struct e1000_mac_info *mac = &hw->mac;
217         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
218         u32 ctrl_ext = 0;
219
220         DEBUGFUNC("igb_init_mac_params_82575");
221
222         /* Set media type */
223         /*
224          * The 82575 uses bits 22:23 for link mode. The mode can be changed
225          * based on the EEPROM. We cannot rely upon device ID. There
226          * is no distinguishable difference between fiber and internal
227          * SerDes mode on the 82575. There can be an external PHY attached
228          * on the SGMII interface. For this, we'll set sgmii_active to true.
229          */
230         hw->phy.media_type = e1000_media_type_copper;
231         dev_spec->sgmii_active = false;
232
233         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
234         switch (ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK) {
235         case E1000_CTRL_EXT_LINK_MODE_SGMII:
236                 dev_spec->sgmii_active = true;
237                 ctrl_ext |= E1000_CTRL_I2C_ENA;
238                 break;
239         case E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES:
240                 hw->phy.media_type = e1000_media_type_internal_serdes;
241                 ctrl_ext |= E1000_CTRL_I2C_ENA;
242                 break;
243         default:
244                 ctrl_ext &= ~E1000_CTRL_I2C_ENA;
245                 break;
246         }
247
248         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
249
250         /* Set mta register count */
251         mac->mta_reg_count = 128;
252         /* Set uta register count */
253         mac->uta_reg_count = (hw->mac.type == e1000_82575) ? 0 : 128;
254         /* Set rar entry count */
255         mac->rar_entry_count = E1000_RAR_ENTRIES_82575;
256         if (mac->type == e1000_82576)
257                 mac->rar_entry_count = E1000_RAR_ENTRIES_82576;
258         /* Set if part includes ASF firmware */
259         mac->asf_firmware_present = true;
260         /* Set if manageability features are enabled. */
261         mac->arc_subsystem_valid =
262                 (E1000_READ_REG(hw, E1000_FWSM) & E1000_FWSM_MODE_MASK)
263                         ? true : false;
264
265         /* Function pointers */
266
267         /* bus type/speed/width */
268         mac->ops.get_bus_info = igb_get_bus_info_pcie_generic;
269         /* reset */
270         mac->ops.reset_hw = igb_reset_hw_82575;
271         /* hw initialization */
272         mac->ops.init_hw = igb_init_hw_82575;
273         /* link setup */
274         mac->ops.setup_link = igb_setup_link_generic;
275         /* physical interface link setup */
276         mac->ops.setup_physical_interface =
277                 (hw->phy.media_type == e1000_media_type_copper)
278                         ? igb_setup_copper_link_82575
279                         : igb_setup_serdes_link_82575;
280         /* physical interface shutdown */
281         mac->ops.shutdown_serdes = igb_shutdown_serdes_link_82575;
282         /* check for link */
283         mac->ops.check_for_link = igb_check_for_link_82575;
284         /* receive address register setting */
285         mac->ops.rar_set = igb_rar_set_generic;
286         /* read mac address */
287         mac->ops.read_mac_addr = igb_read_mac_addr_82575;
288         /* multicast address update */
289         mac->ops.update_mc_addr_list = igb_update_mc_addr_list_generic;
290         /* writing VFTA */
291         mac->ops.write_vfta = igb_write_vfta_generic;
292         /* clearing VFTA */
293         mac->ops.clear_vfta = igb_clear_vfta_generic;
294         /* setting MTA */
295 #if 0
296         mac->ops.mta_set = igb_mta_set_generic;
297         /* ID LED init */
298         mac->ops.id_led_init = igb_id_led_init_generic;
299         /* blink LED */
300         mac->ops.blink_led = igb_blink_led_generic;
301         /* setup LED */
302         mac->ops.setup_led = igb_setup_led_generic;
303         /* cleanup LED */
304         mac->ops.cleanup_led = igb_cleanup_led_generic;
305         /* turn on/off LED */
306         mac->ops.led_on = igb_led_on_generic;
307         mac->ops.led_off = igb_led_off_generic;
308 #endif
309         /* clear hardware counters */
310         mac->ops.clear_hw_cntrs = igb_clear_hw_cntrs_82575;
311         /* link info */
312         mac->ops.get_link_up_info = igb_get_link_up_info_82575;
313
314         /* set lan id for port to determine which phy lock to use */
315         hw->mac.ops.set_lan_id(hw);
316
317         return E1000_SUCCESS;
318 }
319
320 /**
321  *  igb_init_function_pointers_82575 - Init func ptrs.
322  *  @hw: pointer to the HW structure
323  *
324  *  Called to initialize all function pointers and parameters.
325  **/
326 void igb_init_function_pointers_82575(struct e1000_hw *hw)
327 {
328         DEBUGFUNC("igb_init_function_pointers_82575");
329
330         hw->mac.ops.init_params = igb_init_mac_params_82575;
331         hw->nvm.ops.init_params = igb_init_nvm_params_82575;
332         hw->phy.ops.init_params = igb_init_phy_params_82575;
333 #if 0
334         hw->mbx.ops.init_params = igb_init_mbx_params_pf;
335 #endif
336 }
337
338 /**
339  *  igb_acquire_phy_82575 - Acquire rights to access PHY
340  *  @hw: pointer to the HW structure
341  *
342  *  Acquire access rights to the correct PHY.
343  **/
344 static s32 igb_acquire_phy_82575(struct e1000_hw *hw)
345 {
346         u16 mask = E1000_SWFW_PHY0_SM;
347
348         DEBUGFUNC("igb_acquire_phy_82575");
349
350         if (hw->bus.func == E1000_FUNC_1)
351                 mask = E1000_SWFW_PHY1_SM;
352
353         return igb_acquire_swfw_sync_82575(hw, mask);
354 }
355
356 /**
357  *  igb_release_phy_82575 - Release rights to access PHY
358  *  @hw: pointer to the HW structure
359  *
360  *  A wrapper to release access rights to the correct PHY.
361  **/
362 static void igb_release_phy_82575(struct e1000_hw *hw)
363 {
364         u16 mask = E1000_SWFW_PHY0_SM;
365
366         DEBUGFUNC("igb_release_phy_82575");
367
368         if (hw->bus.func == E1000_FUNC_1)
369                 mask = E1000_SWFW_PHY1_SM;
370
371         igb_release_swfw_sync_82575(hw, mask);
372 }
373
374 /**
375  *  igb_read_phy_reg_sgmii_82575 - Read PHY register using sgmii
376  *  @hw: pointer to the HW structure
377  *  @offset: register offset to be read
378  *  @data: pointer to the read data
379  *
380  *  Reads the PHY register at offset using the serial gigabit media independent
381  *  interface and stores the retrieved information in data.
382  **/
383 static s32 igb_read_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
384                                           u16 *data)
385 {
386         s32 ret_val = -E1000_ERR_PARAM;
387
388         DEBUGFUNC("igb_read_phy_reg_sgmii_82575");
389
390         if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
391                 DEBUGOUT1("PHY Address %u is out of range\n", offset);
392                 goto out;
393         }
394
395         ret_val = hw->phy.ops.acquire(hw);
396         if (ret_val)
397                 goto out;
398
399         ret_val = igb_read_phy_reg_i2c(hw, offset, data);
400
401         hw->phy.ops.release(hw);
402
403 out:
404         return ret_val;
405 }
406
407 /**
408  *  igb_write_phy_reg_sgmii_82575 - Write PHY register using sgmii
409  *  @hw: pointer to the HW structure
410  *  @offset: register offset to write to
411  *  @data: data to write at register offset
412  *
413  *  Writes the data to PHY register at the offset using the serial gigabit
414  *  media independent interface.
415  **/
416 static s32 igb_write_phy_reg_sgmii_82575(struct e1000_hw *hw, u32 offset,
417                                            u16 data)
418 {
419         s32 ret_val = -E1000_ERR_PARAM;
420
421         DEBUGFUNC("igb_write_phy_reg_sgmii_82575");
422
423         if (offset > E1000_MAX_SGMII_PHY_REG_ADDR) {
424                 DEBUGOUT1("PHY Address %d is out of range\n", offset);
425                 goto out;
426         }
427
428         ret_val = hw->phy.ops.acquire(hw);
429         if (ret_val)
430                 goto out;
431
432         ret_val = igb_write_phy_reg_i2c(hw, offset, data);
433
434         hw->phy.ops.release(hw);
435
436 out:
437         return ret_val;
438 }
439
440 /**
441  *  igb_get_phy_id_82575 - Retrieve PHY addr and id
442  *  @hw: pointer to the HW structure
443  *
444  *  Retrieves the PHY address and ID for both PHY's which do and do not use
445  *  sgmi interface.
446  **/
447 static s32 igb_get_phy_id_82575(struct e1000_hw *hw)
448 {
449         struct e1000_phy_info *phy = &hw->phy;
450         s32  ret_val = E1000_SUCCESS;
451         u16 phy_id;
452         u32 ctrl_ext;
453
454         DEBUGFUNC("igb_get_phy_id_82575");
455
456         /*
457          * For SGMII PHYs, we try the list of possible addresses until
458          * we find one that works.  For non-SGMII PHYs
459          * (e.g. integrated copper PHYs), an address of 1 should
460          * work.  The result of this function should mean phy->phy_addr
461          * and phy->id are set correctly.
462          */
463         if (!igb_sgmii_active_82575(hw)) {
464                 phy->addr = 1;
465                 ret_val = igb_get_phy_id(hw);
466                 goto out;
467         }
468
469         /* Power on sgmii phy if it is disabled */
470         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
471         E1000_WRITE_REG(hw, E1000_CTRL_EXT,
472                         ctrl_ext & ~E1000_CTRL_EXT_SDP3_DATA);
473         E1000_WRITE_FLUSH(hw);
474         msec_delay(300);
475
476         /*
477          * The address field in the I2CCMD register is 3 bits and 0 is invalid.
478          * Therefore, we need to test 1-7
479          */
480         for (phy->addr = 1; phy->addr < 8; phy->addr++) {
481                 ret_val = igb_read_phy_reg_sgmii_82575(hw, PHY_ID1, &phy_id);
482                 if (ret_val == E1000_SUCCESS) {
483                         DEBUGOUT2("Vendor ID 0x%08X read at address %u\n",
484                                   phy_id,
485                                   phy->addr);
486                         /*
487                          * At the time of this writing, The M88 part is
488                          * the only supported SGMII PHY product.
489                          */
490                         if (phy_id == M88_VENDOR)
491                                 break;
492                 } else {
493                         DEBUGOUT1("PHY address %u was unreadable\n",
494                                   phy->addr);
495                 }
496         }
497
498         /* A valid PHY type couldn't be found. */
499         if (phy->addr == 8) {
500                 phy->addr = 0;
501                 ret_val = -E1000_ERR_PHY;
502         } else {
503                 ret_val = igb_get_phy_id(hw);
504         }
505
506         /* restore previous sfp cage power state */
507         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
508
509 out:
510         return ret_val;
511 }
512
513 /**
514  *  igb_phy_hw_reset_sgmii_82575 - Performs a PHY reset
515  *  @hw: pointer to the HW structure
516  *
517  *  Resets the PHY using the serial gigabit media independent interface.
518  **/
519 static s32 igb_phy_hw_reset_sgmii_82575(struct e1000_hw *hw)
520 {
521         s32 ret_val = E1000_SUCCESS;
522
523         DEBUGFUNC("igb_phy_hw_reset_sgmii_82575");
524
525         /*
526          * This isn't a true "hard" reset, but is the only reset
527          * available to us at this time.
528          */
529
530         DEBUGOUT("Soft resetting SGMII attached PHY...\n");
531
532         if (!(hw->phy.ops.write_reg))
533                 goto out;
534
535         /*
536          * SFP documentation requires the following to configure the SPF module
537          * to work on SGMII.  No further documentation is given.
538          */
539         ret_val = hw->phy.ops.write_reg(hw, 0x1B, 0x8084);
540         if (ret_val)
541                 goto out;
542
543         ret_val = hw->phy.ops.commit(hw);
544
545 out:
546         return ret_val;
547 }
548
549 /**
550  *  igb_set_d0_lplu_state_82575 - Set Low Power Linkup D0 state
551  *  @hw: pointer to the HW structure
552  *  @active: true to enable LPLU, false to disable
553  *
554  *  Sets the LPLU D0 state according to the active flag.  When
555  *  activating LPLU this function also disables smart speed
556  *  and vice versa.  LPLU will not be activated unless the
557  *  device autonegotiation advertisement meets standards of
558  *  either 10 or 10/100 or 10/100/1000 at all duplexes.
559  *  This is a function pointer entry point only called by
560  *  PHY setup routines.
561  **/
562 static s32 igb_set_d0_lplu_state_82575(struct e1000_hw *hw, bool active)
563 {
564         struct e1000_phy_info *phy = &hw->phy;
565         s32 ret_val = E1000_SUCCESS;
566         u16 data;
567
568         DEBUGFUNC("igb_set_d0_lplu_state_82575");
569
570         if (!(hw->phy.ops.read_reg))
571                 goto out;
572
573         ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data);
574         if (ret_val)
575                 goto out;
576
577         if (active) {
578                 data |= IGP02E1000_PM_D0_LPLU;
579                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
580                                              data);
581                 if (ret_val)
582                         goto out;
583
584                 /* When LPLU is enabled, we should disable SmartSpeed */
585                 ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
586                                             &data);
587                 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
588                 ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CONFIG,
589                                              data);
590                 if (ret_val)
591                         goto out;
592         } else {
593                 data &= ~IGP02E1000_PM_D0_LPLU;
594                 ret_val = phy->ops.write_reg(hw, IGP02E1000_PHY_POWER_MGMT,
595                                              data);
596                 /*
597                  * LPLU and SmartSpeed are mutually exclusive.  LPLU is used
598                  * during Dx states where the power conservation is most
599                  * important.  During driver activity we should enable
600                  * SmartSpeed, so performance is maintained.
601                  */
602                 if (phy->smart_speed == e1000_smart_speed_on) {
603                         ret_val = phy->ops.read_reg(hw,
604                                                     IGP01E1000_PHY_PORT_CONFIG,
605                                                     &data);
606                         if (ret_val)
607                                 goto out;
608
609                         data |= IGP01E1000_PSCFR_SMART_SPEED;
610                         ret_val = phy->ops.write_reg(hw,
611                                                      IGP01E1000_PHY_PORT_CONFIG,
612                                                      data);
613                         if (ret_val)
614                                 goto out;
615                 } else if (phy->smart_speed == e1000_smart_speed_off) {
616                         ret_val = phy->ops.read_reg(hw,
617                                                     IGP01E1000_PHY_PORT_CONFIG,
618                                                     &data);
619                         if (ret_val)
620                                 goto out;
621
622                         data &= ~IGP01E1000_PSCFR_SMART_SPEED;
623                         ret_val = phy->ops.write_reg(hw,
624                                                      IGP01E1000_PHY_PORT_CONFIG,
625                                                      data);
626                         if (ret_val)
627                                 goto out;
628                 }
629         }
630
631 out:
632         return ret_val;
633 }
634
635 /**
636  *  igb_acquire_nvm_82575 - Request for access to EEPROM
637  *  @hw: pointer to the HW structure
638  *
639  *  Acquire the necessary semaphores for exclusive access to the EEPROM.
640  *  Set the EEPROM access request bit and wait for EEPROM access grant bit.
641  *  Return successful if access grant bit set, else clear the request for
642  *  EEPROM access and return -E1000_ERR_NVM (-1).
643  **/
644 static s32 igb_acquire_nvm_82575(struct e1000_hw *hw)
645 {
646         s32 ret_val;
647
648         DEBUGFUNC("igb_acquire_nvm_82575");
649
650         ret_val = igb_acquire_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
651         if (ret_val)
652                 goto out;
653
654         ret_val = igb_acquire_nvm_generic(hw);
655
656         if (ret_val)
657                 igb_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
658
659 out:
660         return ret_val;
661 }
662
663 /**
664  *  igb_release_nvm_82575 - Release exclusive access to EEPROM
665  *  @hw: pointer to the HW structure
666  *
667  *  Stop any current commands to the EEPROM and clear the EEPROM request bit,
668  *  then release the semaphores acquired.
669  **/
670 static void igb_release_nvm_82575(struct e1000_hw *hw)
671 {
672         DEBUGFUNC("igb_release_nvm_82575");
673
674         igb_release_nvm_generic(hw);
675         igb_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
676 }
677
678 /**
679  *  igb_acquire_swfw_sync_82575 - Acquire SW/FW semaphore
680  *  @hw: pointer to the HW structure
681  *  @mask: specifies which semaphore to acquire
682  *
683  *  Acquire the SW/FW semaphore to access the PHY or NVM.  The mask
684  *  will also specify which port we're acquiring the lock for.
685  **/
686 static s32 igb_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
687 {
688         u32 swfw_sync;
689         u32 swmask = mask;
690         u32 fwmask = mask << 16;
691         s32 ret_val = E1000_SUCCESS;
692         s32 i = 0, timeout = 200; /* FIXME: find real value to use here */
693
694         DEBUGFUNC("igb_acquire_swfw_sync_82575");
695
696         while (i < timeout) {
697                 if (igb_get_hw_semaphore_generic(hw)) {
698                         ret_val = -E1000_ERR_SWFW_SYNC;
699                         goto out;
700                 }
701
702                 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
703                 if (!(swfw_sync & (fwmask | swmask)))
704                         break;
705
706                 /*
707                  * Firmware currently using resource (fwmask)
708                  * or other software thread using resource (swmask)
709                  */
710                 igb_put_hw_semaphore_generic(hw);
711                 msec_delay_irq(5);
712                 i++;
713         }
714
715         if (i == timeout) {
716                 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
717                 ret_val = -E1000_ERR_SWFW_SYNC;
718                 goto out;
719         }
720
721         swfw_sync |= swmask;
722         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
723
724         igb_put_hw_semaphore_generic(hw);
725
726 out:
727         return ret_val;
728 }
729
730 /**
731  *  igb_release_swfw_sync_82575 - Release SW/FW semaphore
732  *  @hw: pointer to the HW structure
733  *  @mask: specifies which semaphore to acquire
734  *
735  *  Release the SW/FW semaphore used to access the PHY or NVM.  The mask
736  *  will also specify which port we're releasing the lock for.
737  **/
738 static void igb_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
739 {
740         u32 swfw_sync;
741
742         DEBUGFUNC("igb_release_swfw_sync_82575");
743
744         while (igb_get_hw_semaphore_generic(hw) != E1000_SUCCESS);
745         /* Empty */
746
747         swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
748         swfw_sync &= ~mask;
749         E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
750
751         igb_put_hw_semaphore_generic(hw);
752 }
753
754 /**
755  *  igb_get_cfg_done_82575 - Read config done bit
756  *  @hw: pointer to the HW structure
757  *
758  *  Read the management control register for the config done bit for
759  *  completion status.  NOTE: silicon which is EEPROM-less will fail trying
760  *  to read the config done bit, so an error is *ONLY* logged and returns
761  *  E1000_SUCCESS.  If we were to return with error, EEPROM-less silicon
762  *  would not be able to be reset or change link.
763  **/
764 static s32 igb_get_cfg_done_82575(struct e1000_hw *hw)
765 {
766         s32 timeout = PHY_CFG_TIMEOUT;
767         s32 ret_val = E1000_SUCCESS;
768         u32 mask = E1000_NVM_CFG_DONE_PORT_0;
769
770         DEBUGFUNC("igb_get_cfg_done_82575");
771
772         if (hw->bus.func == E1000_FUNC_1)
773                 mask = E1000_NVM_CFG_DONE_PORT_1;
774         while (timeout) {
775                 if (E1000_READ_REG(hw, E1000_EEMNGCTL) & mask)
776                         break;
777                 msec_delay(1);
778                 timeout--;
779         }
780         if (!timeout) {
781                 DEBUGOUT("MNG configuration cycle has not completed.\n");
782         }
783
784         /* If EEPROM is not marked present, init the PHY manually */
785         if (((E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) == 0) &&
786             (hw->phy.type == e1000_phy_igp_3))
787                 igb_phy_init_script_igp3(hw);
788
789         return ret_val;
790 }
791
792 /**
793  *  igb_get_link_up_info_82575 - Get link speed/duplex info
794  *  @hw: pointer to the HW structure
795  *  @speed: stores the current speed
796  *  @duplex: stores the current duplex
797  *
798  *  This is a wrapper function, if using the serial gigabit media independent
799  *  interface, use PCS to retrieve the link speed and duplex information.
800  *  Otherwise, use the generic function to get the link speed and duplex info.
801  **/
802 static s32 igb_get_link_up_info_82575(struct e1000_hw *hw, u16 *speed,
803                                         u16 *duplex)
804 {
805         s32 ret_val;
806
807         DEBUGFUNC("igb_get_link_up_info_82575");
808
809         if (hw->phy.media_type != e1000_media_type_copper)
810                 ret_val = igb_get_pcs_speed_and_duplex_82575(hw, speed,
811                                                                duplex);
812         else
813                 ret_val = igb_get_speed_and_duplex_copper_generic(hw, speed,
814                                                                     duplex);
815
816         return ret_val;
817 }
818
819 /**
820  *  igb_check_for_link_82575 - Check for link
821  *  @hw: pointer to the HW structure
822  *
823  *  If sgmii is enabled, then use the pcs register to determine link, otherwise
824  *  use the generic interface for determining link.
825  **/
826 static s32 igb_check_for_link_82575(struct e1000_hw *hw)
827 {
828         s32 ret_val;
829         u16 speed, duplex;
830
831         DEBUGFUNC("igb_check_for_link_82575");
832
833         if (hw->phy.media_type != e1000_media_type_copper) {
834                 ret_val = igb_get_pcs_speed_and_duplex_82575(hw, &speed,
835                                                                &duplex);
836                 /*
837                  * Use this flag to determine if link needs to be checked or
838                  * not.  If we have link clear the flag so that we do not
839                  * continue to check for link.
840                  */
841                 hw->mac.get_link_status = !hw->mac.serdes_has_link;
842         } else {
843                 ret_val = igb_check_for_copper_link_generic(hw);
844         }
845
846         return ret_val;
847 }
848
849 /**
850  *  igb_get_pcs_speed_and_duplex_82575 - Retrieve current speed/duplex
851  *  @hw: pointer to the HW structure
852  *  @speed: stores the current speed
853  *  @duplex: stores the current duplex
854  *
855  *  Using the physical coding sub-layer (PCS), retrieve the current speed and
856  *  duplex, then store the values in the pointers provided.
857  **/
858 static s32 igb_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
859                                                 u16 *speed, u16 *duplex)
860 {
861         struct e1000_mac_info *mac = &hw->mac;
862         u32 pcs;
863
864         DEBUGFUNC("igb_get_pcs_speed_and_duplex_82575");
865
866         /* Set up defaults for the return values of this function */
867         mac->serdes_has_link = false;
868         *speed = 0;
869         *duplex = 0;
870
871         /*
872          * Read the PCS Status register for link state. For non-copper mode,
873          * the status register is not accurate. The PCS status register is
874          * used instead.
875          */
876         pcs = E1000_READ_REG(hw, E1000_PCS_LSTAT);
877
878         /*
879          * The link up bit determines when link is up on autoneg. The sync ok
880          * gets set once both sides sync up and agree upon link. Stable link
881          * can be determined by checking for both link up and link sync ok
882          */
883         if ((pcs & E1000_PCS_LSTS_LINK_OK) && (pcs & E1000_PCS_LSTS_SYNK_OK)) {
884                 mac->serdes_has_link = true;
885
886                 /* Detect and store PCS speed */
887                 if (pcs & E1000_PCS_LSTS_SPEED_1000) {
888                         *speed = SPEED_1000;
889                 } else if (pcs & E1000_PCS_LSTS_SPEED_100) {
890                         *speed = SPEED_100;
891                 } else {
892                         *speed = SPEED_10;
893                 }
894
895                 /* Detect and store PCS duplex */
896                 if (pcs & E1000_PCS_LSTS_DUPLEX_FULL) {
897                         *duplex = FULL_DUPLEX;
898                 } else {
899                         *duplex = HALF_DUPLEX;
900                 }
901         }
902
903         return E1000_SUCCESS;
904 }
905
906 /**
907  *  igb_shutdown_serdes_link_82575 - Remove link during power down
908  *  @hw: pointer to the HW structure
909  *
910  *  In the case of serdes shut down sfp and PCS on driver unload
911  *  when management pass thru is not enabled.
912  **/
913 void igb_shutdown_serdes_link_82575(struct e1000_hw *hw)
914 {
915 #if 0
916         u32 reg;
917 #endif
918         u16 eeprom_data = 0;
919
920         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
921             !igb_sgmii_active_82575(hw))
922                 return;
923
924         if (hw->bus.func == E1000_FUNC_0)
925                 hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
926         else if (hw->bus.func == E1000_FUNC_1)
927                 hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
928
929         /*
930          * If APM is not enabled in the EEPROM and management interface is
931          * not enabled, then power down.
932          */
933 #if 0
934         if (!(eeprom_data & E1000_NVM_APME_82575) &&
935             !igb_enable_mng_pass_thru(hw)) {
936                 /* Disable PCS to turn off link */
937                 reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
938                 reg &= ~E1000_PCS_CFG_PCS_EN;
939                 E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
940
941                 /* shutdown the laser */
942                 reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
943                 reg |= E1000_CTRL_EXT_SDP3_DATA;
944                 E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
945
946                 /* flush the write to verify completion */
947                 E1000_WRITE_FLUSH(hw);
948                 msec_delay(1);
949         }
950 #endif
951         return;
952 }
953
954 /**
955  *  igb_reset_hw_82575 - Reset hardware
956  *  @hw: pointer to the HW structure
957  *
958  *  This resets the hardware into a known state.
959  **/
960 static s32 igb_reset_hw_82575(struct e1000_hw *hw)
961 {
962         u32 ctrl, icr;
963         s32 ret_val;
964
965         DEBUGFUNC("igb_reset_hw_82575");
966
967         /*
968          * Prevent the PCI-E bus from sticking if there is no TLP connection
969          * on the last TLP read/write transaction when MAC is reset.
970          */
971         ret_val = igb_disable_pcie_master_generic(hw);
972         if (ret_val) {
973                 DEBUGOUT("PCI-E Master disable polling has failed.\n");
974         }
975
976         /* set the completion timeout for interface */
977         ret_val = igb_set_pcie_completion_timeout(hw);
978         if (ret_val) {
979                 DEBUGOUT("PCI-E Set completion timeout has failed.\n");
980         }
981
982         DEBUGOUT("Masking off all interrupts\n");
983         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
984
985         E1000_WRITE_REG(hw, E1000_RCTL, 0);
986         E1000_WRITE_REG(hw, E1000_TCTL, E1000_TCTL_PSP);
987         E1000_WRITE_FLUSH(hw);
988
989         msec_delay(10);
990
991         ctrl = E1000_READ_REG(hw, E1000_CTRL);
992
993         DEBUGOUT("Issuing a global reset to MAC\n");
994         E1000_WRITE_REG(hw, E1000_CTRL, ctrl | E1000_CTRL_RST);
995
996         ret_val = igb_get_auto_rd_done_generic(hw);
997         if (ret_val) {
998                 /*
999                  * When auto config read does not complete, do not
1000                  * return with an error. This can happen in situations
1001                  * where there is no eeprom and prevents getting link.
1002                  */
1003                 DEBUGOUT("Auto Read Done did not complete\n");
1004         }
1005
1006         /* If EEPROM is not present, run manual init scripts */
1007         if ((E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_PRES) == 0)
1008                 igb_reset_init_script_82575(hw);
1009
1010         /* Clear any pending interrupt events. */
1011         E1000_WRITE_REG(hw, E1000_IMC, 0xffffffff);
1012         icr = E1000_READ_REG(hw, E1000_ICR);
1013
1014         /* Install any alternate MAC address into RAR0 */
1015         ret_val = igb_check_alt_mac_addr_generic(hw);
1016
1017         return ret_val;
1018 }
1019
1020 /**
1021  *  igb_init_hw_82575 - Initialize hardware
1022  *  @hw: pointer to the HW structure
1023  *
1024  *  This inits the hardware readying it for operation.
1025  **/
1026 static s32 igb_init_hw_82575(struct e1000_hw *hw)
1027 {
1028         struct e1000_mac_info *mac = &hw->mac;
1029         s32 ret_val;
1030         u16 i, rar_count = mac->rar_entry_count;
1031
1032         DEBUGFUNC("igb_init_hw_82575");
1033
1034         /* Initialize identification LED */
1035         ret_val = mac->ops.id_led_init(hw);
1036         if (ret_val) {
1037                 DEBUGOUT("Error initializing identification LED\n");
1038                 /* This is not fatal and we should not stop init due to this */
1039         }
1040
1041         /* Disabling VLAN filtering */
1042         DEBUGOUT("Initializing the IEEE VLAN\n");
1043         mac->ops.clear_vfta(hw);
1044
1045         /* Setup the receive address */
1046         igb_init_rx_addrs_generic(hw, rar_count);
1047
1048         /* Zero out the Multicast HASH table */
1049         DEBUGOUT("Zeroing the MTA\n");
1050         for (i = 0; i < mac->mta_reg_count; i++)
1051                 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, 0);
1052
1053         /* Zero out the Unicast HASH table */
1054         DEBUGOUT("Zeroing the UTA\n");
1055         for (i = 0; i < mac->uta_reg_count; i++)
1056                 E1000_WRITE_REG_ARRAY(hw, E1000_UTA, i, 0);
1057
1058         /* Setup link and flow control */
1059         ret_val = mac->ops.setup_link(hw);
1060
1061         /*
1062          * Clear all of the statistics registers (clear on read).  It is
1063          * important that we do this after we have tried to establish link
1064          * because the symbol error count will increment wildly if there
1065          * is no link.
1066          */
1067         igb_clear_hw_cntrs_82575(hw);
1068
1069         return ret_val;
1070 }
1071
1072 /**
1073  *  igb_setup_copper_link_82575 - Configure copper link settings
1074  *  @hw: pointer to the HW structure
1075  *
1076  *  Configures the link for auto-neg or forced speed and duplex.  Then we check
1077  *  for link, once link is established calls to configure collision distance
1078  *  and flow control are called.
1079  **/
1080 static s32 igb_setup_copper_link_82575(struct e1000_hw *hw)
1081 {
1082         u32 ctrl;
1083         s32  ret_val;
1084
1085         DEBUGFUNC("igb_setup_copper_link_82575");
1086
1087         ctrl = E1000_READ_REG(hw, E1000_CTRL);
1088         ctrl |= E1000_CTRL_SLU;
1089         ctrl &= ~(E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX);
1090         E1000_WRITE_REG(hw, E1000_CTRL, ctrl);
1091
1092         ret_val = igb_setup_serdes_link_82575(hw);
1093         if (ret_val)
1094                 goto out;
1095
1096         if (igb_sgmii_active_82575(hw) && !hw->phy.reset_disable) {
1097                 ret_val = hw->phy.ops.reset(hw);
1098                 if (ret_val) {
1099                         DEBUGOUT("Error resetting the PHY.\n");
1100                         goto out;
1101                 }
1102         }
1103         switch (hw->phy.type) {
1104         case e1000_phy_m88:
1105                 ret_val = igb_copper_link_setup_m88(hw);
1106                 break;
1107         case e1000_phy_igp_3:
1108                 ret_val = igb_copper_link_setup_igp(hw);
1109                 break;
1110         default:
1111                 ret_val = -E1000_ERR_PHY;
1112                 break;
1113         }
1114
1115         if (ret_val)
1116                 goto out;
1117
1118         ret_val = igb_setup_copper_link_generic(hw);
1119 out:
1120         return ret_val;
1121 }
1122
1123 /**
1124  *  igb_setup_serdes_link_82575 - Setup link for serdes
1125  *  @hw: pointer to the HW structure
1126  *
1127  *  Configure the physical coding sub-layer (PCS) link.  The PCS link is
1128  *  used on copper connections where the serialized gigabit media independent
1129  *  interface (sgmii), or serdes fiber is being used.  Configures the link
1130  *  for auto-negotiation or forces speed/duplex.
1131  **/
1132 static s32 igb_setup_serdes_link_82575(struct e1000_hw *hw)
1133 {
1134         u32 ctrl_reg, reg;
1135
1136         DEBUGFUNC("igb_setup_serdes_link_82575");
1137
1138         if ((hw->phy.media_type != e1000_media_type_internal_serdes) &&
1139             !igb_sgmii_active_82575(hw))
1140                 return E1000_SUCCESS;
1141
1142         /*
1143          * On the 82575, SerDes loopback mode persists until it is
1144          * explicitly turned off or a power cycle is performed.  A read to
1145          * the register does not indicate its status.  Therefore, we ensure
1146          * loopback mode is disabled during initialization.
1147          */
1148         E1000_WRITE_REG(hw, E1000_SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1149
1150         /* power on the sfp cage if present */
1151         reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1152         reg &= ~E1000_CTRL_EXT_SDP3_DATA;
1153         E1000_WRITE_REG(hw, E1000_CTRL_EXT, reg);
1154
1155         ctrl_reg = E1000_READ_REG(hw, E1000_CTRL);
1156         ctrl_reg |= E1000_CTRL_SLU;
1157
1158         if (hw->mac.type == e1000_82575 || hw->mac.type == e1000_82576) {
1159                 /* set both sw defined pins */
1160                 ctrl_reg |= E1000_CTRL_SWDPIN0 | E1000_CTRL_SWDPIN1;
1161
1162                 /* Set switch control to serdes energy detect */
1163                 reg = E1000_READ_REG(hw, E1000_CONNSW);
1164                 reg |= E1000_CONNSW_ENRGSRC;
1165                 E1000_WRITE_REG(hw, E1000_CONNSW, reg);
1166         }
1167
1168         reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1169
1170         if (igb_sgmii_active_82575(hw)) {
1171                 /* allow time for SFP cage to power up phy */
1172                 msec_delay(300);
1173
1174                 /* AN time out should be disabled for SGMII mode */
1175                 reg &= ~(E1000_PCS_LCTL_AN_TIMEOUT);
1176         } else {
1177                 ctrl_reg |= E1000_CTRL_SPD_1000 | E1000_CTRL_FRCSPD |
1178                             E1000_CTRL_FD | E1000_CTRL_FRCDPX;
1179         }
1180
1181         E1000_WRITE_REG(hw, E1000_CTRL, ctrl_reg);
1182
1183         /*
1184          * New SerDes mode allows for forcing speed or autonegotiating speed
1185          * at 1gb. Autoneg should be default set by most drivers. This is the
1186          * mode that will be compatible with older link partners and switches.
1187          * However, both are supported by the hardware and some drivers/tools.
1188          */
1189
1190         reg &= ~(E1000_PCS_LCTL_AN_ENABLE | E1000_PCS_LCTL_FLV_LINK_UP |
1191                  E1000_PCS_LCTL_FSD | E1000_PCS_LCTL_FORCE_LINK);
1192
1193         /*
1194          * We force flow control to prevent the CTRL register values from being
1195          * overwritten by the autonegotiated flow control values
1196          */
1197         reg |= E1000_PCS_LCTL_FORCE_FCTRL;
1198
1199         /*
1200          * we always set sgmii to autoneg since it is the phy that will be
1201          * forcing the link and the serdes is just a go-between
1202          */
1203         if (hw->mac.autoneg || igb_sgmii_active_82575(hw)) {
1204                 /* Set PCS register for autoneg */
1205                 reg |= E1000_PCS_LCTL_FSV_1000 |  /* Force 1000 */
1206                        E1000_PCS_LCTL_FDV_FULL |  /* SerDes Full dplx */
1207                        E1000_PCS_LCTL_AN_ENABLE | /* Enable Autoneg */
1208                        E1000_PCS_LCTL_AN_RESTART; /* Restart autoneg */
1209                 DEBUGOUT1("Configuring Autoneg:PCS_LCTL=0x%08X\n", reg);
1210         } else {
1211                 /* Check for duplex first */
1212                 if (hw->mac.forced_speed_duplex & E1000_ALL_FULL_DUPLEX)
1213                         reg |= E1000_PCS_LCTL_FDV_FULL;
1214
1215                 /* No need to check for 1000/full since the spec states that
1216                  * it requires autoneg to be enabled */
1217                 /* Now set speed */
1218                 if (hw->mac.forced_speed_duplex & E1000_ALL_100_SPEED)
1219                         reg |= E1000_PCS_LCTL_FSV_100;
1220
1221                 /* Force speed and force link */
1222                 reg |= E1000_PCS_LCTL_FSD |
1223                        E1000_PCS_LCTL_FORCE_LINK |
1224                        E1000_PCS_LCTL_FLV_LINK_UP;
1225
1226                 DEBUGOUT1("Configuring Forced Link:PCS_LCTL=0x%08X\n", reg);
1227         }
1228
1229         E1000_WRITE_REG(hw, E1000_PCS_LCTL, reg);
1230
1231         if (!igb_sgmii_active_82575(hw))
1232                 igb_force_mac_fc_generic(hw);
1233
1234         return E1000_SUCCESS;
1235 }
1236
1237 /**
1238  *  igb_valid_led_default_82575 - Verify a valid default LED config
1239  *  @hw: pointer to the HW structure
1240  *  @data: pointer to the NVM (EEPROM)
1241  *
1242  *  Read the EEPROM for the current default LED configuration.  If the
1243  *  LED configuration is not valid, set to a valid LED configuration.
1244  **/
1245 static s32 igb_valid_led_default_82575(struct e1000_hw *hw, u16 *data)
1246 {
1247         s32 ret_val;
1248
1249         DEBUGFUNC("igb_valid_led_default_82575");
1250
1251         ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
1252         if (ret_val) {
1253                 DEBUGOUT("NVM Read Error\n");
1254                 goto out;
1255         }
1256
1257         if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) {
1258                 switch(hw->phy.media_type) {
1259                 case e1000_media_type_internal_serdes:
1260                         *data = ID_LED_DEFAULT_82575_SERDES;
1261                         break;
1262                 case e1000_media_type_copper:
1263                 default:
1264                         *data = ID_LED_DEFAULT;
1265                         break;
1266                 }
1267         }
1268 out:
1269         return ret_val;
1270 }
1271
1272 /**
1273  *  igb_sgmii_active_82575 - Return sgmii state
1274  *  @hw: pointer to the HW structure
1275  *
1276  *  82575 silicon has a serialized gigabit media independent interface (sgmii)
1277  *  which can be enabled for use in the embedded applications.  Simply
1278  *  return the current state of the sgmii interface.
1279  **/
1280 static bool igb_sgmii_active_82575(struct e1000_hw *hw)
1281 {
1282         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
1283         return dev_spec->sgmii_active;
1284 }
1285
1286 /**
1287  *  igb_reset_init_script_82575 - Inits HW defaults after reset
1288  *  @hw: pointer to the HW structure
1289  *
1290  *  Inits recommended HW defaults after a reset when there is no EEPROM
1291  *  detected. This is only for the 82575.
1292  **/
1293 static s32 igb_reset_init_script_82575(struct e1000_hw* hw)
1294 {
1295         DEBUGFUNC("igb_reset_init_script_82575");
1296
1297         if (hw->mac.type == e1000_82575) {
1298                 DEBUGOUT("Running reset init script for 82575\n");
1299                 /* SerDes configuration via SERDESCTRL */
1300                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x00, 0x0C);
1301                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x01, 0x78);
1302                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x1B, 0x23);
1303                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCTL, 0x23, 0x15);
1304
1305                 /* CCM configuration via CCMCTL register */
1306                 igb_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x14, 0x00);
1307                 igb_write_8bit_ctrl_reg_generic(hw, E1000_CCMCTL, 0x10, 0x00);
1308
1309                 /* PCIe lanes configuration */
1310                 igb_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x00, 0xEC);
1311                 igb_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x61, 0xDF);
1312                 igb_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x34, 0x05);
1313                 igb_write_8bit_ctrl_reg_generic(hw, E1000_GIOCTL, 0x2F, 0x81);
1314
1315                 /* PCIe PLL Configuration */
1316                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x02, 0x47);
1317                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x14, 0x00);
1318                 igb_write_8bit_ctrl_reg_generic(hw, E1000_SCCTL, 0x10, 0x00);
1319         }
1320
1321         return E1000_SUCCESS;
1322 }
1323
1324 /**
1325  *  igb_read_mac_addr_82575 - Read device MAC address
1326  *  @hw: pointer to the HW structure
1327  **/
1328 static s32 igb_read_mac_addr_82575(struct e1000_hw *hw)
1329 {
1330         s32 ret_val = E1000_SUCCESS;
1331
1332         DEBUGFUNC("igb_read_mac_addr_82575");
1333
1334         /*
1335          * If there's an alternate MAC address place it in RAR0
1336          * so that it will override the Si installed default perm
1337          * address.
1338          */
1339         ret_val = igb_check_alt_mac_addr_generic(hw);
1340         if (ret_val)
1341                 goto out;
1342
1343         ret_val = igb_read_mac_addr_generic(hw);
1344
1345 out:
1346         return ret_val;
1347 }
1348
1349 /**
1350  * igb_power_down_phy_copper_82575 - Remove link during PHY power down
1351  * @hw: pointer to the HW structure
1352  *
1353  * In the case of a PHY power down to save power, or to turn off link during a
1354  * driver unload, or wake on lan is not enabled, remove the link.
1355  **/
1356 static void igb_power_down_phy_copper_82575(struct e1000_hw *hw)
1357 {
1358         struct e1000_phy_info *phy = &hw->phy;
1359         struct e1000_mac_info *mac = &hw->mac;
1360
1361         if (!(phy->ops.check_reset_block))
1362                 return;
1363
1364         /* If the management interface is not enabled, then power down */
1365         if (!(mac->ops.check_mng_mode(hw) || phy->ops.check_reset_block(hw)))
1366                 igb_power_down_phy_copper(hw);
1367
1368         return;
1369 }
1370
1371 /**
1372  *  igb_clear_hw_cntrs_82575 - Clear device specific hardware counters
1373  *  @hw: pointer to the HW structure
1374  *
1375  *  Clears the hardware counters by reading the counter registers.
1376  **/
1377 static void igb_clear_hw_cntrs_82575(struct e1000_hw *hw)
1378 {
1379         DEBUGFUNC("igb_clear_hw_cntrs_82575");
1380
1381         igb_clear_hw_cntrs_base_generic(hw);
1382
1383         E1000_READ_REG(hw, E1000_PRC64);
1384         E1000_READ_REG(hw, E1000_PRC127);
1385         E1000_READ_REG(hw, E1000_PRC255);
1386         E1000_READ_REG(hw, E1000_PRC511);
1387         E1000_READ_REG(hw, E1000_PRC1023);
1388         E1000_READ_REG(hw, E1000_PRC1522);
1389         E1000_READ_REG(hw, E1000_PTC64);
1390         E1000_READ_REG(hw, E1000_PTC127);
1391         E1000_READ_REG(hw, E1000_PTC255);
1392         E1000_READ_REG(hw, E1000_PTC511);
1393         E1000_READ_REG(hw, E1000_PTC1023);
1394         E1000_READ_REG(hw, E1000_PTC1522);
1395
1396         E1000_READ_REG(hw, E1000_ALGNERRC);
1397         E1000_READ_REG(hw, E1000_RXERRC);
1398         E1000_READ_REG(hw, E1000_TNCRS);
1399         E1000_READ_REG(hw, E1000_CEXTERR);
1400         E1000_READ_REG(hw, E1000_TSCTC);
1401         E1000_READ_REG(hw, E1000_TSCTFC);
1402
1403         E1000_READ_REG(hw, E1000_MGTPRC);
1404         E1000_READ_REG(hw, E1000_MGTPDC);
1405         E1000_READ_REG(hw, E1000_MGTPTC);
1406
1407         E1000_READ_REG(hw, E1000_IAC);
1408         E1000_READ_REG(hw, E1000_ICRXOC);
1409
1410         E1000_READ_REG(hw, E1000_ICRXPTC);
1411         E1000_READ_REG(hw, E1000_ICRXATC);
1412         E1000_READ_REG(hw, E1000_ICTXPTC);
1413         E1000_READ_REG(hw, E1000_ICTXATC);
1414         E1000_READ_REG(hw, E1000_ICTXQEC);
1415         E1000_READ_REG(hw, E1000_ICTXQMTC);
1416         E1000_READ_REG(hw, E1000_ICRXDMTC);
1417
1418         E1000_READ_REG(hw, E1000_CBTMPC);
1419         E1000_READ_REG(hw, E1000_HTDPMC);
1420         E1000_READ_REG(hw, E1000_CBRMPC);
1421         E1000_READ_REG(hw, E1000_RPTHC);
1422         E1000_READ_REG(hw, E1000_HGPTC);
1423         E1000_READ_REG(hw, E1000_HTCBDPC);
1424         E1000_READ_REG(hw, E1000_HGORCL);
1425         E1000_READ_REG(hw, E1000_HGORCH);
1426         E1000_READ_REG(hw, E1000_HGOTCL);
1427         E1000_READ_REG(hw, E1000_HGOTCH);
1428         E1000_READ_REG(hw, E1000_LENERRS);
1429
1430         /* This register should not be read in copper configurations */
1431         if ((hw->phy.media_type == e1000_media_type_internal_serdes) ||
1432             igb_sgmii_active_82575(hw))
1433                 E1000_READ_REG(hw, E1000_SCVPC);
1434 }
1435
1436 /**
1437  *  igb_rx_fifo_flush_82575 - Clean rx fifo after RX enable
1438  *  @hw: pointer to the HW structure
1439  *
1440  *  After rx enable if managability is enabled then there is likely some
1441  *  bad data at the start of the fifo and possibly in the DMA fifo.  This
1442  *  function clears the fifos and flushes any packets that came in as rx was
1443  *  being enabled.
1444  **/
1445 void igb_rx_fifo_flush_82575(struct e1000_hw *hw)
1446 {
1447         u32 rctl, rlpml, rxdctl[4], rfctl, temp_rctl, rx_enabled;
1448         int i, ms_wait;
1449
1450         DEBUGFUNC("igb_rx_fifo_workaround_82575");
1451         if (hw->mac.type != e1000_82575 ||
1452             !(E1000_READ_REG(hw, E1000_MANC) & E1000_MANC_RCV_TCO_EN))
1453                 return;
1454
1455         /* Disable all RX queues */
1456         for (i = 0; i < 4; i++) {
1457                 rxdctl[i] = E1000_READ_REG(hw, E1000_RXDCTL(i));
1458                 E1000_WRITE_REG(hw, E1000_RXDCTL(i),
1459                                 rxdctl[i] & ~E1000_RXDCTL_QUEUE_ENABLE);
1460         }
1461         /* Poll all queues to verify they have shut down */
1462         for (ms_wait = 0; ms_wait < 10; ms_wait++) {
1463                 msec_delay(1);
1464                 rx_enabled = 0;
1465                 for (i = 0; i < 4; i++)
1466                         rx_enabled |= E1000_READ_REG(hw, E1000_RXDCTL(i));
1467                 if (!(rx_enabled & E1000_RXDCTL_QUEUE_ENABLE))
1468                         break;
1469         }
1470
1471         if (ms_wait == 10) {
1472                 DEBUGOUT("Queue disable timed out after 10ms\n");
1473         }
1474         /* Clear RLPML, RCTL.SBP, RFCTL.LEF, and set RCTL.LPE so that all
1475          * incoming packets are rejected.  Set enable and wait 2ms so that
1476          * any packet that was coming in as RCTL.EN was set is flushed
1477          */
1478         rfctl = E1000_READ_REG(hw, E1000_RFCTL);
1479         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl & ~E1000_RFCTL_LEF);
1480
1481         rlpml = E1000_READ_REG(hw, E1000_RLPML);
1482         E1000_WRITE_REG(hw, E1000_RLPML, 0);
1483
1484         rctl = E1000_READ_REG(hw, E1000_RCTL);
1485         temp_rctl = rctl & ~(E1000_RCTL_EN | E1000_RCTL_SBP);
1486         temp_rctl |= E1000_RCTL_LPE;
1487
1488         E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl);
1489         E1000_WRITE_REG(hw, E1000_RCTL, temp_rctl | E1000_RCTL_EN);
1490         E1000_WRITE_FLUSH(hw);
1491         msec_delay(2);
1492
1493         /* Enable RX queues that were previously enabled and restore our
1494          * previous state
1495          */
1496         for (i = 0; i < 4; i++)
1497                 E1000_WRITE_REG(hw, E1000_RXDCTL(i), rxdctl[i]);
1498         E1000_WRITE_REG(hw, E1000_RCTL, rctl);
1499         E1000_WRITE_FLUSH(hw);
1500
1501         E1000_WRITE_REG(hw, E1000_RLPML, rlpml);
1502         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl);
1503
1504         /* Flush receive errors generated by workaround */
1505         E1000_READ_REG(hw, E1000_ROC);
1506         E1000_READ_REG(hw, E1000_RNBC);
1507         E1000_READ_REG(hw, E1000_MPC);
1508 }
1509
1510 /**
1511  *  igb_set_pcie_completion_timeout - set pci-e completion timeout
1512  *  @hw: pointer to the HW structure
1513  *
1514  *  The defaults for 82575 and 82576 should be in the range of 50us to 50ms,
1515  *  however the hardware default for these parts is 500us to 1ms which is less
1516  *  than the 10ms recommended by the pci-e spec.  To address this we need to
1517  *  increase the value to either 10ms to 200ms for capability version 1 config,
1518  *  or 16ms to 55ms for version 2.
1519  **/
1520 static s32 igb_set_pcie_completion_timeout(struct e1000_hw *hw)
1521 {
1522         u32 gcr = E1000_READ_REG(hw, E1000_GCR);
1523         s32 ret_val = E1000_SUCCESS;
1524         u16 pcie_devctl2;
1525
1526         /* only take action if timeout value is defaulted to 0 */
1527         if (gcr & E1000_GCR_CMPL_TMOUT_MASK)
1528                 goto out;
1529
1530         /*
1531          * if capababilities version is type 1 we can write the
1532          * timeout of 10ms to 200ms through the GCR register
1533          */
1534         if (!(gcr & E1000_GCR_CAP_VER2)) {
1535                 gcr |= E1000_GCR_CMPL_TMOUT_10ms;
1536                 goto out;
1537         }
1538
1539         /*
1540          * for version 2 capabilities we need to write the config space
1541          * directly in order to set the completion timeout value for
1542          * 16ms to 55ms
1543          */
1544         ret_val = igb_read_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
1545                                           &pcie_devctl2);
1546         if (ret_val)
1547                 goto out;
1548
1549         pcie_devctl2 |= PCIE_DEVICE_CONTROL2_16ms;
1550
1551         ret_val = igb_write_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
1552                                            &pcie_devctl2);
1553 out:
1554         /* disable completion timeout resend */
1555         gcr &= ~E1000_GCR_CMPL_TMOUT_RESEND;
1556
1557         E1000_WRITE_REG(hw, E1000_GCR, gcr);
1558         return ret_val;
1559 }
1560
1561 /**
1562  *  igb_vmdq_set_loopback_pf - enable or disable vmdq loopback
1563  *  @hw: pointer to the hardware struct
1564  *  @enable: state to enter, either enabled or disabled
1565  *
1566  *  enables/disables L2 switch loopback functionality.
1567  **/
1568 void igb_vmdq_set_loopback_pf(struct e1000_hw *hw, bool enable)
1569 {
1570         u32 dtxswc = E1000_READ_REG(hw, E1000_DTXSWC);
1571
1572         if (enable)
1573                 dtxswc |= E1000_DTXSWC_VMDQ_LOOPBACK_EN;
1574         else
1575                 dtxswc &= ~E1000_DTXSWC_VMDQ_LOOPBACK_EN;
1576
1577         E1000_WRITE_REG(hw, E1000_DTXSWC, dtxswc);
1578 }
1579
1580 /**
1581  *  igb_vmdq_set_replication_pf - enable or disable vmdq replication
1582  *  @hw: pointer to the hardware struct
1583  *  @enable: state to enter, either enabled or disabled
1584  *
1585  *  enables/disables replication of packets across multiple pools.
1586  **/
1587 void igb_vmdq_set_replication_pf(struct e1000_hw *hw, bool enable)
1588 {
1589         u32 vt_ctl = E1000_READ_REG(hw, E1000_VT_CTL);
1590
1591         if (enable)
1592                 vt_ctl |= E1000_VT_CTL_VM_REPL_EN;
1593         else
1594                 vt_ctl &= ~E1000_VT_CTL_VM_REPL_EN;
1595
1596         E1000_WRITE_REG(hw, E1000_VT_CTL, vt_ctl);
1597 }
1598
1599 static struct pci_device_id igb_82575_nics[] = {
1600         PCI_ROM(0x8086, 0x10C9, "E1000_DEV_ID_82576", "E1000_DEV_ID_82576", 0),
1601         PCI_ROM(0x8086, 0x150A, "E1000_DEV_ID_82576_NS", "E1000_DEV_ID_82576_NS", 0),
1602         PCI_ROM(0x8086, 0x1518, "E1000_DEV_ID_82576_NS_SERDES", "E1000_DEV_ID_82576_NS_SERDES", 0),
1603         PCI_ROM(0x8086, 0x10E6, "E1000_DEV_ID_82576_FIBER", "E1000_DEV_ID_82576_FIBER", 0),
1604         PCI_ROM(0x8086, 0x10E7, "E1000_DEV_ID_82576_SERDES", "E1000_DEV_ID_82576_SERDES", 0),
1605         PCI_ROM(0x8086, 0x150D, "E1000_DEV_ID_82576_SERDES_QUAD", "E1000_DEV_ID_82576_SERDES_QUAD", 0),
1606         PCI_ROM(0x8086, 0x10E8, "E1000_DEV_ID_82576_QUAD_COPPER", "E1000_DEV_ID_82576_QUAD_COPPER", 0),
1607         PCI_ROM(0x8086, 0x10A7, "E1000_DEV_ID_82575EB_COPPER", "E1000_DEV_ID_82575EB_COPPER", 0),
1608         PCI_ROM(0x8086, 0x10A9, "E1000_DEV_ID_82575EB_FIBER_SERDES", "E1000_DEV_ID_82575EB_FIBER_SERDES", 0),
1609         PCI_ROM(0x8086, 0x10D6, "E1000_DEV_ID_82575GB_QUAD_COPPER", "E1000_DEV_ID_82575GB_QUAD_COPPER", 0),
1610 };
1611
1612 struct pci_driver igb_82575_driver __pci_driver = {
1613         .ids = igb_82575_nics,
1614         .id_count = (sizeof (igb_82575_nics) / sizeof (igb_82575_nics[0])),
1615         .probe = igb_probe,
1616         .remove = igb_remove,
1617 };