[igb] Add igb driver
[people/pcmattman/gpxe.git] / src / drivers / net / igb / igb_main.c
1 /*******************************************************************************
2
3   Intel(R) Gigabit Ethernet Linux driver
4   Copyright(c) 2007-2009 Intel Corporation.
5
6   Portions Copyright(c) 2010 Marty Connor <mdc@etherboot.org>
7   Portions Copyright(c) 2010 Entity Cyber, Inc.
8
9   This program is free software; you can redistribute it and/or modify it
10   under the terms and conditions of the GNU General Public License,
11   version 2, as published by the Free Software Foundation.
12
13   This program is distributed in the hope it will be useful, but WITHOUT
14   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16   more details.
17
18   You should have received a copy of the GNU General Public License along with
19   this program; if not, write to the Free Software Foundation, Inc.,
20   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21
22   The full GNU General Public License is included in this distribution in
23   the file called "COPYING".
24
25   Contact Information:
26   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
27   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
28
29 *******************************************************************************/
30
31 FILE_LICENCE ( GPL2_ONLY );
32
33 #include "igb.h"
34
35 /* Low-level support routines */
36
37 /**
38  * igb_read_pcie_cap_reg - retrieve PCIe capability register contents
39  * @hw: address of board private structure
40  * @reg: PCIe capability register requested
41  * @value: where to store requested value
42  **/
43 int32_t igb_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
44 {
45     struct igb_adapter *adapter = hw->back;
46     uint16_t cap_offset;
47
48 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
49     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
50     if (!cap_offset)
51         return -E1000_ERR_CONFIG;
52
53     pci_read_config_word(adapter->pdev, cap_offset + reg, value);
54
55     return E1000_SUCCESS;
56 }
57
58 /**
59  * igb_write_pcie_cap_reg - write value to PCIe capability register
60  * @hw: address of board private structure
61  * @reg: PCIe capability register to write to
62  * @value: value to store in given register
63  **/
64 int32_t igb_write_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
65 {
66         struct igb_adapter *adapter = hw->back;
67         u16 cap_offset;
68
69         cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
70         if (!cap_offset)
71                 return -E1000_ERR_CONFIG;
72
73         pci_write_config_word(adapter->pdev, cap_offset + reg, *value);
74
75         return E1000_SUCCESS;
76 }
77
78 /**
79  * igb_irq_disable - Mask off interrupt generation on the NIC
80  * @adapter: board private structure
81  **/
82 static void igb_irq_disable(struct igb_adapter *adapter)
83 {
84         struct e1000_hw *hw = &adapter->hw;
85
86         E1000_WRITE_REG(hw, E1000_IAM, 0);
87         E1000_WRITE_REG(hw, E1000_IMC, ~0);
88         E1000_WRITE_FLUSH(hw);
89 }
90
91 /**
92  * igb_irq_enable - Enable default interrupt generation settings
93  * @adapter: board private structure
94  **/
95 static void igb_irq_enable(struct igb_adapter *adapter)
96 {
97         struct e1000_hw *hw = &adapter->hw;
98
99         E1000_WRITE_REG(hw, E1000_IMS, IMS_ENABLE_MASK);
100         E1000_WRITE_REG(hw, E1000_IAM, IMS_ENABLE_MASK);
101         E1000_WRITE_FLUSH(hw);
102 }
103
104 /**
105  * igb_get_hw_control - get control of the h/w from f/w
106  * @adapter: address of board private structure
107  *
108  * igb_get_hw_control sets CTRL_EXT:DRV_LOAD bit.
109  * For ASF and Pass Through versions of f/w this means that
110  * the driver is loaded.
111  *
112  **/
113 void igb_get_hw_control(struct igb_adapter *adapter)
114 {
115         struct e1000_hw *hw = &adapter->hw;
116         u32 ctrl_ext;
117
118         /* Let firmware know the driver has taken over */
119         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
120         E1000_WRITE_REG(hw, E1000_CTRL_EXT,
121                         ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
122 }
123
124 /**
125  * igb_reset - put adapter in known initial state
126  * @adapter: board private structure
127  **/
128 void igb_reset(struct igb_adapter *adapter)
129 {
130         struct e1000_hw *hw = &adapter->hw;
131
132         struct e1000_mac_info *mac = &hw->mac;
133         struct e1000_fc_info *fc = &hw->fc;
134         u32 pba = 0;
135         u16 hwm;
136
137         /* Repartition Pba for greater than 9k mtu
138          * To take effect CTRL.RST is required.
139          */
140         switch (mac->type) {
141         case e1000_82576:
142                 pba = E1000_READ_REG(hw, E1000_RXPBS);
143                 pba &= E1000_RXPBS_SIZE_MASK_82576;
144                 break;
145         case e1000_82575:
146         default:
147                 pba = E1000_PBA_34K;
148                 break;
149         }
150
151         /* flow control settings */
152         /* The high water mark must be low enough to fit one full frame
153          * (or the size used for early receive) above it in the Rx FIFO.
154          * Set it to the lower of:
155          * - 90% of the Rx FIFO size, or
156          * - the full Rx FIFO size minus one full frame */
157 #define min(a,b) (((a)<(b))?(a):(b))
158         hwm = min(((pba << 10) * 9 / 10),
159                         ((pba << 10) - 2 * adapter->max_frame_size));
160
161         if (mac->type < e1000_82576) {
162                 fc->high_water = hwm & 0xFFF8;  /* 8-byte granularity */
163                 fc->low_water = fc->high_water - 8;
164         } else {
165                 fc->high_water = hwm & 0xFFF0;  /* 16-byte granularity */
166                 fc->low_water = fc->high_water - 16;
167         }
168         fc->pause_time = 0xFFFF;
169         fc->send_xon = 1;
170         fc->current_mode = fc->requested_mode;
171
172         /* Allow time for pending master requests to run */
173         igb_reset_hw(hw);
174         E1000_WRITE_REG(hw, E1000_WUC, 0);
175
176         if (igb_init_hw(hw)) {
177                 DBG ("Hardware Error\n");
178         }
179
180         igb_get_phy_info(hw);
181 }
182
183 /**
184  * igb_sw_init - Initialize general software structures (struct igb_adapter)
185  * @adapter: board private structure to initialize
186  **/
187 int igb_sw_init(struct igb_adapter *adapter)
188 {
189         struct e1000_hw *hw = &adapter->hw;
190         struct pci_device *pdev = adapter->pdev;
191
192         /* PCI config space info */
193
194         hw->vendor_id = pdev->vendor;
195         hw->device_id = pdev->device;
196
197         pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
198
199         pci_read_config_word(pdev, PCI_COMMAND, &hw->bus.pci_cmd_word);
200
201         adapter->max_frame_size = MAXIMUM_ETHERNET_VLAN_SIZE + ETH_HLEN + ETH_FCS_LEN;
202         adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
203
204         /* Initialize the hardware-specific values */
205         if (igb_setup_init_funcs(hw, TRUE)) {
206                 DBG ("Hardware Initialization Failure\n");
207                 return -EIO;
208         }
209
210         /* Explicitly disable IRQ since the NIC can be in any state. */
211         igb_irq_disable(adapter);
212
213         return 0;
214 }
215
216 /* TX support routines */
217
218 /**
219  * igb_setup_tx_resources - allocate Tx resources (Descriptors)
220  *
221  * @v adapter   e1000 private structure
222  *
223  * @ret rc       Returns 0 on success, negative on failure
224  **/
225 static int igb_setup_tx_resources ( struct igb_adapter *adapter )
226 {
227         DBG ( "igb_setup_tx_resources\n" );
228
229         /* Allocate transmit descriptor ring memory.
230            It must not cross a 64K boundary because of hardware errata #23
231            so we use malloc_dma() requesting a 128 byte block that is
232            128 byte aligned. This should guarantee that the memory
233            allocated will not cross a 64K boundary, because 128 is an
234            even multiple of 65536 ( 65536 / 128 == 512 ), so all possible
235            allocations of 128 bytes on a 128 byte boundary will not
236            cross 64K bytes.
237          */
238
239         adapter->tx_base =
240                 malloc_dma ( adapter->tx_ring_size, adapter->tx_ring_size );
241
242         if ( ! adapter->tx_base ) {
243                 return -ENOMEM;
244         }
245
246         memset ( adapter->tx_base, 0, adapter->tx_ring_size );
247
248         DBG ( "adapter->tx_base = %#08lx\n", virt_to_bus ( adapter->tx_base ) );
249
250         return 0;
251 }
252
253 /**
254  * igb_process_tx_packets - process transmitted packets
255  *
256  * @v netdev    network interface device structure
257  **/
258 static void igb_process_tx_packets ( struct net_device *netdev )
259 {
260         struct igb_adapter *adapter = netdev_priv ( netdev );
261         uint32_t i;
262         uint32_t tx_status;
263         struct e1000_tx_desc *tx_curr_desc;
264
265         /* Check status of transmitted packets
266          */
267         DBG ( "process_tx_packets: tx_head = %d, tx_tail = %d\n", adapter->tx_head,
268               adapter->tx_tail );
269
270         while ( ( i = adapter->tx_head ) != adapter->tx_tail ) {
271
272                 tx_curr_desc = ( void * )  ( adapter->tx_base ) +
273                                            ( i * sizeof ( *adapter->tx_base ) );
274
275                 tx_status = tx_curr_desc->upper.data;
276
277                 DBG ( "  tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
278                 DBG ( "  tx_status = %#08x\n", tx_status );
279
280                 /* if the packet at tx_head is not owned by hardware it is for us */
281                 if ( ! ( tx_status & E1000_TXD_STAT_DD ) )
282                         break;
283
284                 DBG ( "Sent packet. tx_head: %d tx_tail: %d tx_status: %#08x\n",
285                       adapter->tx_head, adapter->tx_tail, tx_status );
286
287                 if ( tx_status & ( E1000_TXD_STAT_EC | E1000_TXD_STAT_LC |
288                                    E1000_TXD_STAT_TU ) ) {
289                         netdev_tx_complete_err ( netdev, adapter->tx_iobuf[i], -EINVAL );
290                         DBG ( "Error transmitting packet, tx_status: %#08x\n",
291                               tx_status );
292                 } else {
293                         netdev_tx_complete ( netdev, adapter->tx_iobuf[i] );
294                         DBG ( "Success transmitting packet, tx_status: %#08x\n",
295                               tx_status );
296                 }
297
298                 /* Decrement count of used descriptors, clear this descriptor
299                  */
300                 adapter->tx_fill_ctr--;
301                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
302
303                 adapter->tx_head = ( adapter->tx_head + 1 ) % NUM_TX_DESC;
304         }
305 }
306
307 static void igb_free_tx_resources ( struct igb_adapter *adapter )
308 {
309         DBG ( "igb_free_tx_resources\n" );
310
311         free_dma ( adapter->tx_base, adapter->tx_ring_size );
312 }
313
314 /**
315  * igb_configure_tx - Configure 8254x Transmit Unit after Reset
316  * @adapter: board private structure
317  *
318  * Configure the Tx unit of the MAC after a reset.
319  **/
320 static void igb_configure_tx ( struct igb_adapter *adapter )
321 {
322         struct e1000_hw *hw = &adapter->hw;
323         u32 tctl, txdctl;
324
325         DBG ( "igb_configure_tx\n" );
326
327         /* disable transmits while setting up the descriptors */
328         tctl = E1000_READ_REG ( hw, E1000_TCTL );
329         E1000_WRITE_REG ( hw, E1000_TCTL, tctl & ~E1000_TCTL_EN );
330         E1000_WRITE_FLUSH(hw);
331         mdelay(10);
332
333         E1000_WRITE_REG ( hw, E1000_TDBAH(0), 0 );
334         E1000_WRITE_REG ( hw, E1000_TDBAL(0), virt_to_bus ( adapter->tx_base ) );
335         E1000_WRITE_REG ( hw, E1000_TDLEN(0), adapter->tx_ring_size );
336
337         DBG ( "E1000_TDBAL(0): %#08x\n",  E1000_READ_REG ( hw, E1000_TDBAL(0) ) );
338         DBG ( "E1000_TDLEN(0): %d\n",     E1000_READ_REG ( hw, E1000_TDLEN(0) ) );
339
340         /* Setup the HW Tx Head and Tail descriptor pointers */
341         E1000_WRITE_REG ( hw, E1000_TDH(0), 0 );
342         E1000_WRITE_REG ( hw, E1000_TDT(0), 0 );
343
344         adapter->tx_head = 0;
345         adapter->tx_tail = 0;
346         adapter->tx_fill_ctr = 0;
347
348         txdctl = E1000_READ_REG ( hw, E1000_TXDCTL(0) );
349         txdctl |= E1000_TXDCTL_QUEUE_ENABLE;
350         E1000_WRITE_REG ( hw, E1000_TXDCTL(0), txdctl );
351
352         /* Setup Transmit Descriptor Settings for eop descriptor */
353         adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;
354
355         /* enable Report Status bit */
356         adapter->txd_cmd |= E1000_TXD_CMD_RS;
357
358         /* Program the Transmit Control Register */
359         tctl &= ~E1000_TCTL_CT;
360         tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
361                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
362
363         igb_config_collision_dist(hw);
364
365         /* Enable transmits */
366         tctl |= E1000_TCTL_EN;
367         E1000_WRITE_REG(hw, E1000_TCTL, tctl);
368         E1000_WRITE_FLUSH(hw);
369 }
370
371 /* RX support routines */
372
373 static void igb_free_rx_resources ( struct igb_adapter *adapter )
374 {
375         int i;
376
377         DBG ( "igb_free_rx_resources\n" );
378
379         free_dma ( adapter->rx_base, adapter->rx_ring_size );
380
381         for ( i = 0; i < NUM_RX_DESC; i++ ) {
382                 free_iob ( adapter->rx_iobuf[i] );
383         }
384 }
385
386 /**
387  * igb_refill_rx_ring - allocate Rx io_buffers
388  *
389  * @v adapter   e1000 private structure
390  *
391  * @ret rc       Returns 0 on success, negative on failure
392  **/
393 static int igb_refill_rx_ring ( struct igb_adapter *adapter )
394 {
395         int i, rx_curr;
396         int rc = 0;
397         struct e1000_rx_desc *rx_curr_desc;
398         struct e1000_hw *hw = &adapter->hw;
399         struct io_buffer *iob;
400
401         DBGP ("igb_refill_rx_ring\n");
402
403         for ( i = 0; i < NUM_RX_DESC; i++ ) {
404                 rx_curr = ( ( adapter->rx_curr + i ) % NUM_RX_DESC );
405                 rx_curr_desc = adapter->rx_base + rx_curr;
406
407                 if ( rx_curr_desc->status & E1000_RXD_STAT_DD )
408                         continue;
409
410                 if ( adapter->rx_iobuf[rx_curr] != NULL )
411                         continue;
412
413                 DBG2 ( "Refilling rx desc %d\n", rx_curr );
414
415                 iob = alloc_iob ( MAXIMUM_ETHERNET_VLAN_SIZE );
416                 adapter->rx_iobuf[rx_curr] = iob;
417
418                 if ( ! iob ) {
419                         DBG ( "alloc_iob failed\n" );
420                         rc = -ENOMEM;
421                         break;
422                 } else {
423                         rx_curr_desc->buffer_addr = virt_to_bus ( iob->data );
424
425                         E1000_WRITE_REG ( hw, E1000_RDT(0), rx_curr );
426                 }
427         }
428         return rc;
429 }
430
431 /**
432  * igb_setup_rx_resources - allocate Rx resources (Descriptors)
433  *
434  * @v adapter   e1000 private structure
435  *
436  * @ret rc       Returns 0 on success, negative on failure
437  **/
438 static int igb_setup_rx_resources ( struct igb_adapter *adapter )
439 {
440         int i, rc = 0;
441
442         DBGP ( "igb_setup_rx_resources\n" );
443
444         /* Allocate receive descriptor ring memory.
445            It must not cross a 64K boundary because of hardware errata
446          */
447
448         adapter->rx_base =
449                 malloc_dma ( adapter->rx_ring_size, adapter->rx_ring_size );
450
451         if ( ! adapter->rx_base ) {
452                 return -ENOMEM;
453         }
454         memset ( adapter->rx_base, 0, adapter->rx_ring_size );
455
456         for ( i = 0; i < NUM_RX_DESC; i++ ) {
457                 /* let igb_refill_rx_ring() io_buffer allocations */
458                 adapter->rx_iobuf[i] = NULL;
459         }
460
461         /* allocate io_buffers */
462         rc = igb_refill_rx_ring ( adapter );
463         if ( rc < 0 )
464                 igb_free_rx_resources ( adapter );
465
466         return rc;
467 }
468
469 /**
470  * igb_configure_rx - Configure 8254x Receive Unit after Reset
471  * @adapter: board private structure
472  *
473  * Configure the Rx unit of the MAC after a reset.
474  **/
475 static void igb_configure_rx ( struct igb_adapter *adapter )
476 {
477         struct e1000_hw *hw = &adapter->hw;
478         uint32_t rctl, rxdctl, rxcsum, mrqc;
479
480         DBGP ( "igb_configure_rx\n" );
481
482         /* disable receives while setting up the descriptors */
483         rctl = E1000_READ_REG ( hw, E1000_RCTL );
484         E1000_WRITE_REG ( hw, E1000_RCTL, rctl & ~E1000_RCTL_EN );
485         E1000_WRITE_FLUSH(hw);
486         mdelay(10);
487
488         adapter->rx_curr = 0;
489
490         /* Setup the HW Rx Head and Tail Descriptor Pointers and
491          * the Base and Length of the Rx Descriptor Ring */
492
493         E1000_WRITE_REG ( hw, E1000_RDBAL(0), virt_to_bus ( adapter->rx_base ) );
494         E1000_WRITE_REG ( hw, E1000_RDBAH(0), 0 );
495         E1000_WRITE_REG ( hw, E1000_RDLEN(0), adapter->rx_ring_size );
496
497         E1000_WRITE_REG ( hw, E1000_RDH(0), 0 );
498         E1000_WRITE_REG ( hw, E1000_RDT(0), 0 );
499
500         DBG ( "E1000_RDBAL(0): %#08x\n",  E1000_READ_REG ( hw, E1000_RDBAL(0) ) );
501         DBG ( "E1000_RDLEN(0): %d\n",     E1000_READ_REG ( hw, E1000_RDLEN(0) ) );
502         DBG ( "E1000_RCTL:  %#08x\n",     E1000_READ_REG ( hw, E1000_RCTL ) );
503
504         rxdctl = E1000_READ_REG ( hw, E1000_RXDCTL(0) );
505         rxdctl |= E1000_RXDCTL_QUEUE_ENABLE;
506         rxdctl &= 0xFFF00000;
507         rxdctl |= IGB_RX_PTHRESH;
508         rxdctl |= IGB_RX_HTHRESH << 8;
509         rxdctl |= IGB_RX_WTHRESH << 16;
510         E1000_WRITE_REG ( hw, E1000_RXDCTL(0), rxdctl );
511         E1000_WRITE_FLUSH ( hw );
512
513         rxcsum = E1000_READ_REG(hw, E1000_RXCSUM);
514         rxcsum &= ~( E1000_RXCSUM_TUOFL | E1000_RXCSUM_IPPCSE );
515         E1000_WRITE_REG ( hw, E1000_RXCSUM, 0 );
516
517         /* The initial value for MRQC disables multiple receive
518          * queues, however this setting is not recommended.
519          * - IntelĀ® 82576 Gigabit Ethernet Controller Datasheet r2.41
520          *   Section 8.10.9 Multiple Queues Command Register - MRQC
521          */
522         mrqc = E1000_MRQC_ENABLE_VMDQ;
523         E1000_WRITE_REG ( hw, E1000_MRQC, mrqc );
524
525         /* Turn off loopback modes */
526         rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
527
528         /* set maximum packet size */
529         rctl |=  E1000_RCTL_SZ_2048;
530
531         /* Broadcast enable, multicast promisc, unicast promisc */
532         rctl |=  E1000_RCTL_BAM | E1000_RCTL_MPE | E1000_RCTL_UPE;
533
534         /* Store bad packets */
535         rctl |=  E1000_RCTL_SBP;
536
537         /* enable LPE to prevent packets larger than max_frame_size */
538         rctl |= E1000_RCTL_LPE;
539
540         /* enable stripping of CRC. */
541         rctl |= E1000_RCTL_SECRC;
542
543         /* enable receive control register */
544         rctl |= E1000_RCTL_EN;
545         E1000_WRITE_REG(hw, E1000_RCTL, rctl);
546         E1000_WRITE_FLUSH(hw);
547
548         /* On the 82576, RDT([0]) must not be "bumped" before
549          * the enable bit of RXDCTL([0]) is set.
550          * - IntelĀ® 82576 Gigabit Ethernet Controller Datasheet r2.41
551          *   Section 4.5.9 receive Initialization
552          *
553          * By observation I have found this to occur when the enable bit of
554          * RCTL is set. The datasheet recommends polling for this bit,
555          * however as I see no evidence of this in the Linux igb driver
556          * I have omitted that step.
557          * - Simon Horman, May 2009
558          */
559         E1000_WRITE_REG ( hw, E1000_RDT(0), NUM_RX_DESC - 1 );
560
561         DBG ( "RDBAH: %#08x\n",  E1000_READ_REG ( hw, E1000_RDBAH(0) ) );
562         DBG ( "RDBAL: %#08x\n",  E1000_READ_REG ( hw, E1000_RDBAL(0) ) );
563         DBG ( "RDLEN: %d\n",     E1000_READ_REG ( hw, E1000_RDLEN(0) ) );
564         DBG ( "RCTL:  %#08x\n",  E1000_READ_REG ( hw, E1000_RCTL ) );
565 }
566
567 /**
568  * igb_process_rx_packets - process received packets
569  *
570  * @v netdev    network interface device structure
571  **/
572 static void igb_process_rx_packets ( struct net_device *netdev )
573 {
574         struct igb_adapter *adapter = netdev_priv ( netdev );
575         uint32_t i;
576         uint32_t rx_status;
577         uint32_t rx_len;
578         uint32_t rx_err;
579         struct e1000_rx_desc *rx_curr_desc;
580
581         DBGP ( "igb_process_rx_packets\n" );
582
583         /* Process received packets
584          */
585         while ( 1 ) {
586
587                 i = adapter->rx_curr;
588
589                 rx_curr_desc = ( void * )  ( adapter->rx_base ) +
590                                   ( i * sizeof ( *adapter->rx_base ) );
591                 rx_status = rx_curr_desc->status;
592
593                 DBG2 ( "Before DD Check RX_status: %#08x\n", rx_status );
594
595                 if ( ! ( rx_status & E1000_RXD_STAT_DD ) )
596                         break;
597
598                 if ( adapter->rx_iobuf[i] == NULL )
599                         break;
600
601                 DBG ( "E1000_RCTL = %#08x\n", E1000_READ_REG ( &adapter->hw, E1000_RCTL ) );
602
603                 rx_len = rx_curr_desc->length;
604
605                 DBG ( "Received packet, rx_curr: %d  rx_status: %#08x  rx_len: %d\n",
606                       i, rx_status, rx_len );
607
608                 rx_err = rx_curr_desc->errors;
609
610                 iob_put ( adapter->rx_iobuf[i], rx_len );
611
612                 if ( rx_err & E1000_RXD_ERR_FRAME_ERR_MASK ) {
613
614                         netdev_rx_err ( netdev, adapter->rx_iobuf[i], -EINVAL );
615                         DBG ( "igb_process_rx_packets: Corrupted packet received!"
616                               " rx_err: %#08x\n", rx_err );
617                 } else  {
618                         /* Add this packet to the receive queue. */
619                         netdev_rx ( netdev, adapter->rx_iobuf[i] );
620                 }
621                 adapter->rx_iobuf[i] = NULL;
622
623                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
624
625                 adapter->rx_curr = ( adapter->rx_curr + 1 ) % NUM_RX_DESC;
626         }
627 }
628
629 /** Functions that implement the gPXE driver API **/
630
631 /**
632  * igb_close - Disables a network interface
633  *
634  * @v netdev    network interface device structure
635  *
636  **/
637 static void igb_close ( struct net_device *netdev )
638 {
639         struct igb_adapter *adapter = netdev_priv ( netdev );
640         struct e1000_hw *hw = &adapter->hw;
641         uint32_t rctl;
642         uint32_t icr;
643
644         DBGP ( "igb_close\n" );
645
646         /* Acknowledge interrupts */
647         icr = E1000_READ_REG ( hw, E1000_ICR );
648
649         igb_irq_disable ( adapter );
650
651         /* disable receives */
652         rctl = E1000_READ_REG ( hw, E1000_RCTL );
653         E1000_WRITE_REG ( hw, E1000_RCTL, rctl & ~E1000_RCTL_EN );
654         E1000_WRITE_FLUSH(hw);
655
656         igb_reset ( adapter );
657
658         igb_free_tx_resources ( adapter );
659         igb_free_rx_resources ( adapter );
660 }
661
662 /**
663  * igb_transmit - Transmit a packet
664  *
665  * @v netdev    Network device
666  * @v iobuf     I/O buffer
667  *
668  * @ret rc       Returns 0 on success, negative on failure
669  */
670 static int igb_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
671 {
672         struct igb_adapter *adapter = netdev_priv( netdev );
673         struct e1000_hw *hw = &adapter->hw;
674         uint32_t tx_curr = adapter->tx_tail;
675         struct e1000_tx_desc *tx_curr_desc;
676
677         DBGP ("igb_transmit\n");
678
679         if ( adapter->tx_fill_ctr == NUM_TX_DESC ) {
680                 DBG ("TX overflow\n");
681                 return -ENOBUFS;
682         }
683
684         /* Save pointer to iobuf we have been given to transmit,
685            netdev_tx_complete() will need it later
686          */
687         adapter->tx_iobuf[tx_curr] = iobuf;
688
689         tx_curr_desc = ( void * ) ( adapter->tx_base ) +
690                        ( tx_curr * sizeof ( *adapter->tx_base ) );
691
692         DBG ( "tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
693         DBG ( "tx_curr_desc + 16 = %#08lx\n", virt_to_bus ( tx_curr_desc ) + 16 );
694         DBG ( "iobuf->data = %#08lx\n", virt_to_bus ( iobuf->data ) );
695
696         /* Add the packet to TX ring
697          */
698         tx_curr_desc->buffer_addr = virt_to_bus ( iobuf->data );
699         tx_curr_desc->upper.data = 0;
700         tx_curr_desc->lower.data = adapter->txd_cmd | iob_len ( iobuf );
701
702         DBG ( "TX fill: %d tx_curr: %d addr: %#08lx len: %zd\n", adapter->tx_fill_ctr,
703               tx_curr, virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
704
705         /* Point to next free descriptor */
706         adapter->tx_tail = ( adapter->tx_tail + 1 ) % NUM_TX_DESC;
707         adapter->tx_fill_ctr++;
708
709         /* Write new tail to NIC, making packet available for transmit
710          */
711         E1000_WRITE_REG ( hw, E1000_TDT(0), adapter->tx_tail );
712         E1000_WRITE_FLUSH(hw);
713
714         return 0;
715 }
716
717 /**
718  * igb_poll - Poll for received packets
719  *
720  * @v netdev    Network device
721  */
722 static void igb_poll ( struct net_device *netdev )
723 {
724         struct igb_adapter *adapter = netdev_priv( netdev );
725         struct e1000_hw *hw = &adapter->hw;
726
727         uint32_t icr;
728
729         DBGP ( "igb_poll\n" );
730
731         /* Acknowledge interrupts */
732         icr = E1000_READ_REG ( hw, E1000_ICR );
733         if ( ! icr )
734                 return;
735
736         DBG ( "igb_poll: intr_status = %#08x\n", icr );
737
738         igb_process_tx_packets ( netdev );
739
740         igb_process_rx_packets ( netdev );
741
742         igb_refill_rx_ring(adapter);
743 }
744
745 /**
746  * igb_irq - enable or Disable interrupts
747  *
748  * @v adapter   e1000 adapter
749  * @v action    requested interrupt action
750  **/
751 static void igb_irq ( struct net_device *netdev, int enable )
752 {
753         struct igb_adapter *adapter = netdev_priv ( netdev );
754
755         DBGP ( "igb_irq\n" );
756
757         if ( enable ) {
758                 igb_irq_enable ( adapter );
759         } else {
760                 igb_irq_disable ( adapter );
761         }
762 }
763
764 static struct net_device_operations igb_operations;
765
766 /**
767  * igb_probe - Initial configuration of NIC
768  *
769  * @v pci       PCI device
770  * @v id        PCI IDs
771  *
772  * @ret rc      Return status code
773  **/
774 int igb_probe ( struct pci_device *pdev,
775               const struct pci_device_id *ent __unused)
776 {
777         int i, err;
778         struct net_device *netdev;
779         struct igb_adapter *adapter;
780         unsigned long mmio_start, mmio_len;
781         struct e1000_hw *hw;
782
783         DBGP ( "igb_probe\n" );
784
785         err = -ENOMEM;
786
787         /* Allocate net device ( also allocates memory for netdev->priv
788            and makes netdev-priv point to it ) */
789         netdev = alloc_etherdev ( sizeof ( struct igb_adapter ) );
790         if ( ! netdev ) {
791                 DBG ( "err_alloc_etherdev\n" );
792                 goto err_alloc_etherdev;
793         }
794
795         /* Associate igb-specific network operations operations with
796          * generic network device layer */
797         netdev_init ( netdev, &igb_operations );
798
799         /* Associate this network device with given PCI device */
800         pci_set_drvdata ( pdev, netdev );
801         netdev->dev = &pdev->dev;
802
803         /* Initialize driver private storage */
804         adapter = netdev_priv ( netdev );
805         memset ( adapter, 0, ( sizeof ( *adapter ) ) );
806
807         adapter->pdev       = pdev;
808
809         adapter->ioaddr     = pdev->ioaddr;
810         adapter->hw.io_base = pdev->ioaddr;
811
812         hw                  = &adapter->hw;
813         hw->vendor_id       = pdev->vendor;
814         hw->device_id       = pdev->device;
815
816         adapter->irqno      = pdev->irq;
817         adapter->netdev     = netdev;
818         adapter->hw.back    = adapter;
819
820         adapter->min_frame_size    = ETH_ZLEN + ETH_FCS_LEN;
821         adapter->max_hw_frame_size = ETH_FRAME_LEN + ETH_FCS_LEN;
822
823         adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
824         adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
825
826         /* Fix up PCI device */
827         adjust_pci_device ( pdev );
828
829         err = -EIO;
830
831         mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
832         mmio_len   = pci_bar_size  ( pdev, PCI_BASE_ADDRESS_0 );
833
834         DBG ( "mmio_start: %#08lx\n", mmio_start );
835         DBG ( "mmio_len: %#08lx\n", mmio_len );
836
837         adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
838         DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
839
840         if ( ! adapter->hw.hw_addr ) {
841                 DBG ( "err_ioremap\n" );
842                 goto err_ioremap;
843         }
844
845         /* setup adapter struct */
846         err = igb_sw_init ( adapter );
847         if (err) {
848                 DBG ( "err_sw_init\n" );
849                 goto err_sw_init;
850         }
851
852         igb_get_bus_info(hw);
853
854         /* Copper options */
855         if (adapter->hw.phy.media_type == e1000_media_type_copper) {
856                 adapter->hw.phy.mdix = AUTO_ALL_MODES;
857                 adapter->hw.phy.disable_polarity_correction = 0;
858                 adapter->hw.phy.ms_type = e1000_ms_hw_default;
859         }
860
861         DBG ( "adapter->hw.mac.type: %#08x\n", adapter->hw.mac.type );
862
863         /* Force auto-negotiation */
864         adapter->hw.mac.autoneg = 1;
865         adapter->fc_autoneg = 1;
866         adapter->hw.phy.autoneg_wait_to_complete = true;
867         adapter->hw.mac.adaptive_ifs = true;
868         adapter->hw.fc.requested_mode = e1000_fc_default;
869         adapter->hw.fc.current_mode = e1000_fc_default;
870
871         igb_validate_mdi_setting(hw);
872
873         /*
874          * before reading the NVM, reset the controller to
875          * put the device in a known good starting state
876          */
877         igb_reset_hw(hw);
878
879         /*
880          * systems with ASPM and others may see the checksum fail on the first
881          * attempt. Let's give it a few tries
882          */
883         for (i = 0;; i++) {
884                 if (igb_validate_nvm_checksum(&adapter->hw) >= 0)
885                         break;
886                 if (i == 2) {
887                         err = -EIO;
888                         DBG ( "The NVM Checksum Is Not Valid\n" );
889                         DBG ( "err_eeprom\n" );
890                         goto err_eeprom;
891                 }
892         }
893
894         /* copy the MAC address out of the EEPROM */
895         if ( igb_read_mac_addr ( &adapter->hw ) ) {
896                 DBG ( "EEPROM Read Error\n" );
897         }
898
899         memcpy ( netdev->hw_addr, adapter->hw.mac.perm_addr, ETH_ALEN );
900
901         /* reset the hardware with the new settings */
902         igb_reset ( adapter );
903
904         /* let the f/w know that the h/w is now under the control of the
905          * driver. */
906         igb_get_hw_control(adapter);
907
908         /* Mark as link up; we don't yet handle link state */
909         netdev_link_up ( netdev );
910
911         if ( ( err = register_netdev ( netdev ) ) != 0) {
912                 DBG ( "err_register\n" );
913                 goto err_register;
914         }
915
916         for (i = 0; i < 6; i++) {
917                 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
918         }
919
920         DBG ( "igb_probe succeeded!\n" );
921
922         /* No errors, return success */
923         return 0;
924
925 /* Error return paths */
926 err_register:
927 err_eeprom:
928 err_sw_init:
929         iounmap ( adapter->hw.hw_addr );
930 err_ioremap:
931         netdev_put ( netdev );
932 err_alloc_etherdev:
933         return err;
934 }
935
936 /**
937  * igb_remove - Device Removal Routine
938  *
939  * @v pdev PCI device information struct
940  *
941  **/
942 void igb_remove ( struct pci_device *pdev )
943 {
944         struct net_device *netdev = pci_get_drvdata ( pdev );
945         struct igb_adapter *adapter = netdev_priv ( netdev );
946
947         DBGP ( "igb_remove\n" );
948
949         if ( adapter->hw.flash_address )
950                 iounmap ( adapter->hw.flash_address );
951         if  ( adapter->hw.hw_addr )
952                 iounmap ( adapter->hw.hw_addr );
953
954         unregister_netdev ( netdev );
955         igb_reset  ( adapter );
956         netdev_nullify ( netdev );
957         netdev_put ( netdev );
958 }
959
960 /**
961  * igb_open - Called when a network interface is made active
962  *
963  * @v netdev    network interface device structure
964  * @ret rc      Return status code, 0 on success, negative value on failure
965  *
966  **/
967 static int igb_open ( struct net_device *netdev )
968 {
969         struct igb_adapter *adapter = netdev_priv(netdev);
970         int err;
971
972         DBGP ( "igb_open\n" );
973
974         /* allocate transmit descriptors */
975         err = igb_setup_tx_resources ( adapter );
976         if ( err ) {
977                 DBG ( "Error setting up TX resources!\n" );
978                 goto err_setup_tx;
979         }
980
981         /* allocate receive descriptors */
982         err = igb_setup_rx_resources ( adapter );
983         if ( err ) {
984                 DBG ( "Error setting up RX resources!\n" );
985                 goto err_setup_rx;
986         }
987
988         igb_configure_tx ( adapter );
989
990         igb_configure_rx ( adapter );
991
992         DBG ( "E1000_RXDCTL(0): %#08x\n",  E1000_READ_REG ( &adapter->hw, E1000_RXDCTL(0) ) );
993
994         return 0;
995
996 err_setup_rx:
997         DBG ( "err_setup_rx\n" );
998         igb_free_tx_resources ( adapter );
999 err_setup_tx:
1000         DBG ( "err_setup_tx\n" );
1001         igb_reset ( adapter );
1002
1003         return err;
1004 }
1005
1006 /** igb net device operations */
1007 static struct net_device_operations igb_operations = {
1008         .open           = igb_open,
1009         .close          = igb_close,
1010         .transmit       = igb_transmit,
1011         .poll           = igb_poll,
1012         .irq            = igb_irq,
1013 };