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