[e1000] Add 82576 support
[people/cooldavid/gpxe.git] / src / drivers / net / e1000 / e1000.c
1 /*
2  * gPXE driver for Intel eepro1000 ethernet cards
3  *
4  * Written by Marty Connor
5  *
6  * Copyright Entity Cyber, Inc. 2007
7  *
8  * This software may be used and distributed according to the terms of
9  * the GNU General Public License (GPL), incorporated herein by
10  * reference.  Drivers based on or derived from this code fall under
11  * the GPL and must retain the authorship, copyright and license
12  * notice.
13  *
14  */
15
16 /*******************************************************************************
17
18   Intel PRO/1000 Linux driver
19   Copyright(c) 1999 - 2006 Intel Corporation.
20
21   This program is free software; you can redistribute it and/or modify it
22   under the terms and conditions of the GNU General Public License,
23   version 2, as published by the Free Software Foundation.
24
25   This program is distributed in the hope it will be useful, but WITHOUT
26   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
27   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
28   more details.
29
30   You should have received a copy of the GNU General Public License along with
31   this program; if not, write to the Free Software Foundation, Inc.,
32   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
33
34   The full GNU General Public License is included in this distribution in
35   the file called "COPYING".
36
37   Contact Information:
38   Linux NICS <linux.nics@intel.com>
39   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
40   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
41
42 *******************************************************************************/
43
44 FILE_LICENCE ( GPL2_ONLY );
45
46 #include "e1000.h"
47
48 /**
49  * e1000_get_hw_control - get control of the h/w from f/w
50  *
51  * @v adapter   e1000 private structure
52  *
53  * e1000_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
54  * For ASF and Pass Through versions of f/w this means that
55  * the driver is loaded. For AMT version (only with 82573)
56  * of the f/w this means that the network i/f is open.
57  *
58  **/
59 static void
60 e1000_get_hw_control ( struct e1000_adapter *adapter )
61 {
62         uint32_t ctrl_ext;
63         uint32_t swsm;
64         
65         DBG ( "e1000_get_hw_control\n" );
66
67         /* Let firmware know the driver has taken over */
68         switch (adapter->hw.mac_type) {
69         case e1000_82573:
70                 swsm = E1000_READ_REG(&adapter->hw, SWSM);
71                 E1000_WRITE_REG(&adapter->hw, SWSM,
72                                 swsm | E1000_SWSM_DRV_LOAD);
73                 break;
74         case e1000_82571:
75         case e1000_82572:
76         case e1000_82576:
77         case e1000_80003es2lan:
78         case e1000_ich8lan:
79                 ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
80                 E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
81                                 ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
82                 break;
83         default:
84                 break;
85         }
86 }
87
88 /**
89  * e1000_irq_enable - Enable default interrupt generation settings
90  *
91  * @v adapter   e1000 private structure
92  **/
93 static void
94 e1000_irq_enable ( struct e1000_adapter *adapter )
95 {
96         E1000_WRITE_REG ( &adapter->hw, IMS, E1000_IMS_RXDMT0 |
97                                              E1000_IMS_RXSEQ );
98         E1000_WRITE_FLUSH ( &adapter->hw );
99 }
100
101 /**
102  * e1000_irq_disable - Mask off interrupt generation on the NIC
103  *
104  * @v adapter   e1000 private structure
105  **/
106 static void
107 e1000_irq_disable ( struct e1000_adapter *adapter )
108 {
109         E1000_WRITE_REG ( &adapter->hw, IMC, ~0 );
110         E1000_WRITE_FLUSH ( &adapter->hw );
111 }
112
113 /**
114  * e1000_irq_force - trigger interrupt
115  *
116  * @v adapter   e1000 private structure
117  **/
118 static void
119 e1000_irq_force ( struct e1000_adapter *adapter )
120 {
121         E1000_WRITE_REG ( &adapter->hw, ICS, E1000_ICS_RXDMT0 );
122         E1000_WRITE_FLUSH ( &adapter->hw );
123 }
124
125 /**
126  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
127  *
128  * @v adapter   e1000 private structure
129  *
130  * e1000_sw_init initializes the Adapter private data structure.
131  * Fields are initialized based on PCI device information and
132  * OS network device settings (MTU size).
133  **/
134 static int
135 e1000_sw_init ( struct e1000_adapter *adapter )
136 {
137         struct e1000_hw *hw = &adapter->hw;
138         struct pci_device *pdev = adapter->pdev;
139
140         /* PCI config space info */
141
142         hw->vendor_id = pdev->vendor;
143         hw->device_id = pdev->device;
144
145         pci_read_config_word ( pdev, PCI_COMMAND, &hw->pci_cmd_word );
146
147         /* Disable Flow Control */
148         hw->fc = E1000_FC_NONE;
149
150         adapter->eeprom_wol = 0;
151         adapter->wol = adapter->eeprom_wol;
152         adapter->en_mng_pt  = 0;
153         adapter->rx_int_delay = 0;
154         adapter->rx_abs_int_delay = 0;
155
156         adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
157         adapter->rx_ps_bsize0 = E1000_RXBUFFER_128;
158         hw->max_frame_size = MAXIMUM_ETHERNET_VLAN_SIZE +
159                 ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
160         hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
161
162         /* identify the MAC */
163
164         if ( e1000_set_mac_type ( hw ) ) {
165                 DBG ( "Unknown MAC Type\n" );
166                 return -EIO;
167         }
168
169         switch ( hw->mac_type ) {
170         default:
171                 break;
172         case e1000_82541:
173         case e1000_82547:
174         case e1000_82541_rev_2:
175         case e1000_82547_rev_2:
176                 hw->phy_init_script = 1;
177                 break;
178         }
179
180         e1000_set_media_type ( hw );
181
182         hw->autoneg = TRUE;
183         hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
184         hw->wait_autoneg_complete = TRUE;
185
186         hw->tbi_compatibility_en = TRUE;
187         hw->adaptive_ifs = TRUE;
188
189         /* Copper options */
190
191         if ( hw->media_type == e1000_media_type_copper ) {
192                 hw->mdix = AUTO_ALL_MODES;
193                 hw->disable_polarity_correction = FALSE;
194                 hw->master_slave = E1000_MASTER_SLAVE;
195         }
196
197         e1000_irq_disable ( adapter );
198
199         return 0;
200 }
201
202 /**
203  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
204  *
205  * @v adapter   e1000 private structure
206  *
207  * @ret rc       Returns 0 on success, negative on failure
208  **/
209 static int
210 e1000_setup_tx_resources ( struct e1000_adapter *adapter )
211 {
212         DBG ( "e1000_setup_tx_resources\n" );
213         
214         /* Allocate transmit descriptor ring memory.
215            It must not cross a 64K boundary because of hardware errata #23
216            so we use malloc_dma() requesting a 128 byte block that is
217            128 byte aligned. This should guarantee that the memory
218            allocated will not cross a 64K boundary, because 128 is an
219            even multiple of 65536 ( 65536 / 128 == 512 ), so all possible
220            allocations of 128 bytes on a 128 byte boundary will not
221            cross 64K bytes.
222          */
223
224         adapter->tx_base = 
225                 malloc_dma ( adapter->tx_ring_size, adapter->tx_ring_size );
226                                                      
227         if ( ! adapter->tx_base ) {
228                 return -ENOMEM;
229         }
230         
231         memset ( adapter->tx_base, 0, adapter->tx_ring_size );
232         
233         DBG ( "adapter->tx_base = %#08lx\n", virt_to_bus ( adapter->tx_base ) );
234
235         return 0;
236 }
237
238 static void
239 e1000_free_tx_resources ( struct e1000_adapter *adapter )
240 {
241         DBG ( "e1000_free_tx_resources\n" );
242
243         free_dma ( adapter->tx_base, adapter->tx_ring_size );
244 }
245
246 /**
247  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
248  * @adapter: board private structure
249  *
250  * Configure the Tx unit of the MAC after a reset.
251  **/
252 static void
253 e1000_configure_tx ( struct e1000_adapter *adapter )
254 {
255         struct e1000_hw *hw = &adapter->hw;
256         uint32_t tctl;
257         uint32_t txdctl;
258
259         DBG ( "e1000_configure_tx\n" );
260
261         E1000_WRITE_REG ( hw, TDBAH, 0 );
262         E1000_WRITE_REG ( hw, TDBAL, virt_to_bus ( adapter->tx_base ) );
263         E1000_WRITE_REG ( hw, TDLEN, adapter->tx_ring_size );
264                           
265         DBG ( "TDBAL: %#08x\n",  E1000_READ_REG ( hw, TDBAL ) );
266         DBG ( "TDLEN: %d\n",     E1000_READ_REG ( hw, TDLEN ) );
267
268         /* Setup the HW Tx Head and Tail descriptor pointers */
269         E1000_WRITE_REG ( hw, TDH, 0 );
270         E1000_WRITE_REG ( hw, TDT, 0 );
271
272         adapter->tx_head = 0;
273         adapter->tx_tail = 0;
274         adapter->tx_fill_ctr = 0;
275
276         if (hw->mac_type == e1000_82576) {
277                 txdctl = E1000_READ_REG ( hw, TXDCTL );
278                 txdctl |= E1000_TXDCTL_QUEUE_ENABLE;
279                 E1000_WRITE_REG ( hw, TXDCTL, txdctl );
280         }
281
282         /* Setup Transmit Descriptor Settings for eop descriptor */
283         tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
284                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT) | 
285                 (E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
286
287         e1000_config_collision_dist ( hw );
288
289         E1000_WRITE_REG ( hw, TCTL, tctl );
290         E1000_WRITE_FLUSH ( hw );
291 }
292
293 /**
294  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
295  *
296  * @v adapter   e1000 private structure
297  *
298  * @ret rc       Returns 0 on success, negative on failure
299  **/
300 static int
301 e1000_setup_rx_resources ( struct e1000_adapter *adapter )
302 {
303         int i, j;
304         struct e1000_rx_desc *rx_curr_desc;
305         
306         DBG ( "e1000_setup_rx_resources\n" );
307         
308         /* Allocate receive descriptor ring memory.
309            It must not cross a 64K boundary because of hardware errata
310          */
311
312         adapter->rx_base = 
313                 malloc_dma ( adapter->rx_ring_size, adapter->rx_ring_size );
314                              
315         if ( ! adapter->rx_base ) {
316                 return -ENOMEM;
317         }
318         memset ( adapter->rx_base, 0, adapter->rx_ring_size );
319
320         for ( i = 0; i < NUM_RX_DESC; i++ ) {
321         
322                 adapter->rx_iobuf[i] = alloc_iob ( MAXIMUM_ETHERNET_VLAN_SIZE );
323                 
324                 /* If unable to allocate all iobufs, free any that
325                  * were successfully allocated, and return an error 
326                  */
327                 if ( ! adapter->rx_iobuf[i] ) {
328                         for ( j = 0; j < i; j++ ) {
329                                 free_iob ( adapter->rx_iobuf[j] );
330                         }
331                         return -ENOMEM;
332                 }
333
334                 rx_curr_desc = ( void * ) ( adapter->rx_base ) + 
335                                           ( i * sizeof ( *adapter->rx_base ) ); 
336                         
337                 rx_curr_desc->buffer_addr = virt_to_bus ( adapter->rx_iobuf[i]->data ); 
338
339                 DBG ( "i = %d  rx_curr_desc->buffer_addr = %#16llx\n", 
340                       i, rx_curr_desc->buffer_addr );
341                 
342         }       
343         return 0;
344 }
345
346 static void
347 e1000_free_rx_resources ( struct e1000_adapter *adapter )
348 {
349         int i;
350         
351         DBG ( "e1000_free_rx_resources\n" );
352
353         free_dma ( adapter->rx_base, adapter->rx_ring_size );
354
355         for ( i = 0; i < NUM_RX_DESC; i++ ) {
356                 free_iob ( adapter->rx_iobuf[i] );
357         }
358 }
359
360 /**
361  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
362  * @adapter: board private structure
363  *
364  * Configure the Rx unit of the MAC after a reset.
365  **/
366 static void
367 e1000_configure_rx ( struct e1000_adapter *adapter )
368 {
369         struct e1000_hw *hw = &adapter->hw;
370         uint32_t rctl, rxdctl, mrqc, rxcsum;
371
372         DBG ( "e1000_configure_rx\n" );
373
374         /* disable receives while setting up the descriptors */
375         rctl = E1000_READ_REG ( hw, RCTL );
376         E1000_WRITE_REG ( hw, RCTL, rctl & ~E1000_RCTL_EN );
377         E1000_WRITE_FLUSH ( hw );
378         mdelay(10);
379
380         adapter->rx_curr = 0;
381
382         /* Setup the HW Rx Head and Tail Descriptor Pointers and
383          * the Base and Length of the Rx Descriptor Ring */      
384
385         E1000_WRITE_REG ( hw, RDBAL, virt_to_bus ( adapter->rx_base ) );
386         E1000_WRITE_REG ( hw, RDBAH, 0 );
387         E1000_WRITE_REG ( hw, RDLEN, adapter->rx_ring_size );
388
389         E1000_WRITE_REG ( hw, RDH, 0 );
390         if (hw->mac_type == e1000_82576)
391                 E1000_WRITE_REG ( hw, RDT, 0 );
392         else
393                 E1000_WRITE_REG ( hw, RDT, NUM_RX_DESC - 1 );
394
395         /* This doesn't seem to  be necessary for correct operation,
396          * but it seems as well to be implicit
397          */
398         if (hw->mac_type == e1000_82576) {
399                 rxdctl = E1000_READ_REG ( hw, RXDCTL );
400                 rxdctl |= E1000_RXDCTL_QUEUE_ENABLE;
401                 rxdctl &= 0xFFF00000;
402                 rxdctl |= IGB_RX_PTHRESH;
403                 rxdctl |= IGB_RX_HTHRESH << 8;
404                 rxdctl |= IGB_RX_WTHRESH << 16;
405                 E1000_WRITE_REG ( hw, RXDCTL, rxdctl );
406                 E1000_WRITE_FLUSH ( hw );
407
408                 rxcsum = E1000_READ_REG(hw, RXCSUM);
409                 rxcsum &= ~( E1000_RXCSUM_TUOFL | E1000_RXCSUM_IPPCSE );
410                 E1000_WRITE_REG ( hw, RXCSUM, 0 );
411
412                 /* The initial value for MRQC disables multiple receive
413                  * queues, however this setting is not recommended.
414                  * - IntelĀ® 82576 Gigabit Ethernet Controller Datasheet r2.41
415                  *   Section 8.10.9 Multiple Queues Command Register - MRQC
416                  */
417                 mrqc = E1000_MRQC_ENABLE_VMDQ;
418                 E1000_WRITE_REG ( hw, MRQC, mrqc );
419         }
420
421         /* Enable Receives */
422         rctl |=  E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
423                  E1000_RCTL_MPE;
424         E1000_WRITE_REG ( hw, RCTL, rctl );
425         E1000_WRITE_FLUSH ( hw );
426
427         /* On the 82576, RDT([0]) must not be "bumped" before
428          * the enable bit of RXDCTL([0]) is set.
429          * - IntelĀ® 82576 Gigabit Ethernet Controller Datasheet r2.41
430          *   Section 4.5.9 receive Initialization
431          *
432          * By observation I have found to occur when the enable bit of
433          * RCTL is set. The datasheet recommends polling for this bit,
434          * however as I see no evidence of this in the Linux igb driver
435          * I have omitted that step.
436          * - Simon Horman, May 2009
437          */
438         if (hw->mac_type == e1000_82576)
439                 E1000_WRITE_REG ( hw, RDT, NUM_RX_DESC - 1 );
440
441         DBG ( "RDBAL: %#08x\n",  E1000_READ_REG ( hw, RDBAL ) );
442         DBG ( "RDLEN: %d\n",     E1000_READ_REG ( hw, RDLEN ) );
443         DBG ( "RCTL:  %#08x\n",  E1000_READ_REG ( hw, RCTL ) );
444 }
445
446 /**
447  * e1000_reset - Put e1000 NIC in known initial state
448  *
449  * @v adapter   e1000 private structure
450  **/
451 static void
452 e1000_reset ( struct e1000_adapter *adapter )
453 {
454         uint32_t pba = 0;
455         uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
456
457         DBG ( "e1000_reset\n" );
458
459         switch (adapter->hw.mac_type) {
460         case e1000_82542_rev2_0:
461         case e1000_82542_rev2_1:
462         case e1000_82543:
463         case e1000_82544:
464         case e1000_82540:
465         case e1000_82541:
466         case e1000_82541_rev_2:
467                 pba = E1000_PBA_48K;
468                 break;
469         case e1000_82545:
470         case e1000_82545_rev_3:
471         case e1000_82546:
472         case e1000_82546_rev_3:
473                 pba = E1000_PBA_48K;
474                 break;
475         case e1000_82547:
476         case e1000_82547_rev_2:
477                 pba = E1000_PBA_30K;
478                 break;
479         case e1000_82571:
480         case e1000_82572:
481         case e1000_80003es2lan:
482                 pba = E1000_PBA_38K;
483                 break;
484         case e1000_82573:
485                 pba = E1000_PBA_20K;
486                 break;
487         case e1000_82576:
488                 pba = E1000_PBA_64K;
489                 break;
490         case e1000_ich8lan:
491                 pba = E1000_PBA_8K;
492         case e1000_undefined:
493         case e1000_num_macs:
494                 break;
495         }
496
497         E1000_WRITE_REG ( &adapter->hw, PBA, pba );
498         
499         /* flow control settings */
500         /* Set the FC high water mark to 90% of the FIFO size.
501          * Required to clear last 3 LSB */
502         fc_high_water_mark = ((pba * 9216)/10) & 0xFFF8;
503
504         /* We can't use 90% on small FIFOs because the remainder
505          * would be less than 1 full frame.  In this case, we size
506          * it to allow at least a full frame above the high water
507          *  mark. */
508         if (pba < E1000_PBA_16K)
509                 fc_high_water_mark = (pba * 1024) - 1600;
510
511         /* This actually applies to < e1000_82575, one revision less than
512          * e1000_82576, but e1000_82575 isn't currently defined in the code */
513         if (adapter->hw.mac_type < e1000_82576) {
514                 /* 8-byte granularity */
515                 adapter->hw.fc_high_water = fc_high_water_mark & 0xFFF8;
516                 adapter->hw.fc_low_water = adapter->hw.fc_high_water - 8;
517         } else {
518                 /* 16-byte granularity */
519                 adapter->hw.fc_high_water = fc_high_water_mark & 0xFFF0;
520                 adapter->hw.fc_low_water = adapter->hw.fc_high_water - 16;
521         }
522
523         if (adapter->hw.mac_type == e1000_80003es2lan ||
524             adapter->hw.mac_type == e1000_82576)
525                 adapter->hw.fc_pause_time = 0xFFFF;
526         else
527                 adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
528         adapter->hw.fc_send_xon = 1;
529         adapter->hw.fc = adapter->hw.original_fc;
530         /* Allow time for pending master requests to run */
531
532         e1000_reset_hw ( &adapter->hw );
533
534         if ( adapter->hw.mac_type >= e1000_82544 )
535                 E1000_WRITE_REG ( &adapter->hw, WUC, 0 );
536
537         if ( e1000_init_hw ( &adapter->hw ) )
538                 DBG ( "Hardware Error\n" );
539
540         /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
541         if (adapter->hw.mac_type >= e1000_82544 &&
542             adapter->hw.mac_type <= e1000_82547_rev_2 &&
543             adapter->hw.autoneg == 1 &&
544             adapter->hw.autoneg_advertised == ADVERTISE_1000_FULL) {
545                 uint32_t ctrl = E1000_READ_REG(&adapter->hw, CTRL);
546                 /* clear phy power management bit if we are in gig only mode,
547                  * which if enabled will attempt negotiation to 100Mb, which
548                  * can cause a loss of link at power off or driver unload */
549                 ctrl &= ~E1000_CTRL_SWDPIN3;
550                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
551         }
552
553         e1000_phy_get_info ( &adapter->hw, &adapter->phy_info );
554
555         if (!adapter->smart_power_down &&
556             (adapter->hw.mac_type == e1000_82571 ||
557              adapter->hw.mac_type == e1000_82572)) {
558                 uint16_t phy_data = 0;
559                 /* speed up time to link by disabling smart power down, ignore
560                  * the return value of this function because there is nothing
561                  * different we would do if it failed */
562                 e1000_read_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
563                                    &phy_data);
564                 phy_data &= ~IGP02E1000_PM_SPD;
565                 e1000_write_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
566                                     phy_data);
567         }
568 }
569
570 /** Functions that implement the gPXE driver API **/
571
572 /**
573  * e1000_close - Disables a network interface
574  *
575  * @v netdev    network interface device structure
576  *
577  **/
578 static void
579 e1000_close ( struct net_device *netdev )
580 {
581         struct e1000_adapter *adapter = netdev_priv ( netdev );
582         struct e1000_hw *hw = &adapter->hw;
583         uint32_t rctl;
584         uint32_t icr;
585
586         DBG ( "e1000_close\n" );
587         
588         /* Acknowledge interrupts */
589         icr = E1000_READ_REG ( hw, ICR );
590
591         e1000_irq_disable ( adapter );
592
593         /* disable receives */
594         rctl = E1000_READ_REG ( hw, RCTL );
595         E1000_WRITE_REG ( hw, RCTL, rctl & ~E1000_RCTL_EN );
596         E1000_WRITE_FLUSH ( hw );
597
598         e1000_reset_hw ( hw );
599
600         e1000_free_tx_resources ( adapter );
601         e1000_free_rx_resources ( adapter );
602 }
603
604 /** 
605  * e1000_transmit - Transmit a packet
606  *
607  * @v netdev    Network device
608  * @v iobuf     I/O buffer
609  *
610  * @ret rc       Returns 0 on success, negative on failure
611  */
612 static int
613 e1000_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
614 {
615         struct e1000_adapter *adapter = netdev_priv( netdev );
616         struct e1000_hw *hw = &adapter->hw;
617         uint32_t tx_curr = adapter->tx_tail;
618         struct e1000_tx_desc *tx_curr_desc;
619
620         DBG ("e1000_transmit\n");
621         
622         if ( adapter->tx_fill_ctr == NUM_TX_DESC ) {
623                 DBG ("TX overflow\n");
624                 return -ENOBUFS;
625         }
626
627         /* Save pointer to iobuf we have been given to transmit,
628            netdev_tx_complete() will need it later
629          */
630         adapter->tx_iobuf[tx_curr] = iobuf;
631
632         tx_curr_desc = ( void * ) ( adapter->tx_base ) + 
633                        ( tx_curr * sizeof ( *adapter->tx_base ) ); 
634
635         DBG ( "tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
636         DBG ( "tx_curr_desc + 16 = %#08lx\n", virt_to_bus ( tx_curr_desc ) + 16 );
637         DBG ( "iobuf->data = %#08lx\n", virt_to_bus ( iobuf->data ) );
638
639         /* Add the packet to TX ring
640          */
641         tx_curr_desc->buffer_addr = 
642                 virt_to_bus ( iobuf->data );
643         tx_curr_desc->lower.data = 
644                 E1000_TXD_CMD_RPS  | E1000_TXD_CMD_EOP |
645                 E1000_TXD_CMD_IFCS | iob_len ( iobuf );
646         tx_curr_desc->upper.data = 0;
647         
648         DBG ( "TX fill: %d tx_curr: %d addr: %#08lx len: %zd\n", adapter->tx_fill_ctr, 
649               tx_curr, virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
650               
651         /* Point to next free descriptor */
652         adapter->tx_tail = ( adapter->tx_tail + 1 ) % NUM_TX_DESC;
653         adapter->tx_fill_ctr++;
654
655         /* Write new tail to NIC, making packet available for transmit
656          */
657         wmb();
658         E1000_WRITE_REG ( hw, TDT, adapter->tx_tail );
659
660         return 0;
661 }
662
663 /** 
664  * e1000_poll - Poll for received packets
665  *
666  * @v netdev    Network device
667  */
668 static void
669 e1000_poll ( struct net_device *netdev )
670 {
671         struct e1000_adapter *adapter = netdev_priv( netdev );
672         struct e1000_hw *hw = &adapter->hw;
673
674         uint32_t icr;
675         uint32_t tx_status;
676         uint32_t rx_status;
677         uint32_t rx_len;
678         uint32_t rx_err;
679         struct io_buffer *rx_iob;
680         struct e1000_tx_desc *tx_curr_desc;
681         struct e1000_rx_desc *rx_curr_desc;
682         uint32_t i;
683         uint64_t tmp_buffer_addr;
684         
685         DBGP ( "e1000_poll\n" );
686
687         /* Acknowledge interrupts */
688         icr = E1000_READ_REG ( hw, ICR );
689         if ( ! icr )
690                 return;
691                 
692         DBG ( "e1000_poll: intr_status = %#08x\n", icr );
693
694         /* Check status of transmitted packets
695          */
696         while ( ( i = adapter->tx_head ) != adapter->tx_tail ) {
697                         
698                 tx_curr_desc = ( void * )  ( adapter->tx_base ) + 
699                                            ( i * sizeof ( *adapter->tx_base ) ); 
700                                                         
701                 tx_status = tx_curr_desc->upper.data;
702
703                 /* if the packet at tx_head is not owned by hardware it is for us */
704                 if ( ! ( tx_status & E1000_TXD_STAT_DD ) )
705                         break;
706                 
707                 DBG ( "Sent packet. tx_head: %d tx_tail: %d tx_status: %#08x\n",
708                       adapter->tx_head, adapter->tx_tail, tx_status );
709
710                 if ( tx_status & ( E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | 
711                                    E1000_TXD_STAT_TU ) ) {
712                         netdev_tx_complete_err ( netdev, adapter->tx_iobuf[i], -EINVAL );
713                         DBG ( "Error transmitting packet, tx_status: %#08x\n",
714                               tx_status );
715                 } else {
716                         netdev_tx_complete ( netdev, adapter->tx_iobuf[i] );
717                         DBG ( "Success transmitting packet, tx_status: %#08x\n",
718                               tx_status );
719                 }
720
721                 /* Decrement count of used descriptors, clear this descriptor 
722                  */
723                 adapter->tx_fill_ctr--;
724                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
725                 
726                 adapter->tx_head = ( adapter->tx_head + 1 ) % NUM_TX_DESC;              
727         }
728         
729         /* Process received packets 
730          */
731         while ( 1 ) {
732         
733                 i = adapter->rx_curr;
734                 
735                 rx_curr_desc = ( void * )  ( adapter->rx_base ) + 
736                                   ( i * sizeof ( *adapter->rx_base ) ); 
737                 rx_status = rx_curr_desc->status;
738                 
739                 DBG2 ( "Before DD Check RX_status: %#08x\n", rx_status );
740         
741                 if ( ! ( rx_status & E1000_RXD_STAT_DD ) )
742                         break;
743
744                 DBG ( "RCTL = %#08x\n", E1000_READ_REG ( &adapter->hw, RCTL ) );
745         
746                 rx_len = rx_curr_desc->length;
747
748                 DBG ( "Received packet, rx_curr: %d  rx_status: %#08x  rx_len: %d\n",
749                       i, rx_status, rx_len );
750                 
751                 rx_err = rx_curr_desc->errors;
752                 
753                 if ( rx_err & E1000_RXD_ERR_FRAME_ERR_MASK ) {
754                 
755                         netdev_rx_err ( netdev, NULL, -EINVAL );
756                         DBG ( "e1000_poll: Corrupted packet received!"
757                               " rx_err: %#08x\n", rx_err );
758                 } else  {
759                 
760                         /* If unable allocate space for this packet,
761                          *  try again next poll
762                          */
763                         rx_iob = alloc_iob ( rx_len );
764                         if ( ! rx_iob ) 
765                                 break;
766                                 
767                         memcpy ( iob_put ( rx_iob, rx_len ), 
768                                 adapter->rx_iobuf[i]->data, rx_len );
769                                 
770                         /* Add this packet to the receive queue. 
771                          */
772                         netdev_rx ( netdev, rx_iob );
773                 }
774
775                 tmp_buffer_addr = rx_curr_desc->buffer_addr;
776                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
777                 rx_curr_desc->buffer_addr = tmp_buffer_addr;
778
779                 E1000_WRITE_REG ( hw, RDT, adapter->rx_curr );
780
781                 adapter->rx_curr = ( adapter->rx_curr + 1 ) % NUM_RX_DESC;
782         }
783 }                               
784
785 /**
786  * e1000_irq - enable or Disable interrupts
787  *
788  * @v adapter   e1000 adapter
789  * @v action    requested interrupt action
790  **/
791 static void 
792 e1000_irq ( struct net_device *netdev, int enable )
793 {
794         struct e1000_adapter *adapter = netdev_priv(netdev);
795
796         DBG ( "e1000_irq\n" );
797         
798         switch ( enable ) {
799         case 0 :
800                 e1000_irq_disable ( adapter );
801                 break;
802         case 1 :
803                 e1000_irq_enable ( adapter );
804                 break;
805         case 2 :
806                 e1000_irq_force ( adapter );
807                 break;
808         }
809 }
810
811 static struct net_device_operations e1000_operations;
812
813 /**
814  * e1000_probe - Initial configuration of e1000 NIC
815  *
816  * @v pci       PCI device
817  * @v id        PCI IDs
818  *
819  * @ret rc      Return status code
820  **/
821 static int 
822 e1000_probe ( struct pci_device *pdev,
823               const struct pci_device_id *id __unused )
824 {
825         int i, err;
826         struct net_device *netdev;
827         struct e1000_adapter *adapter;
828         unsigned long mmio_start, mmio_len;
829         unsigned long flash_start, flash_len;
830
831         DBG ( "e1000_probe\n" );
832         
833         err = -ENOMEM;
834
835         /* Allocate net device ( also allocates memory for netdev->priv
836            and makes netdev-priv point to it ) */
837         netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
838         if ( ! netdev ) 
839                 goto err_alloc_etherdev;
840                 
841         /* Associate e1000-specific network operations operations with
842          * generic network device layer */
843         netdev_init ( netdev, &e1000_operations );
844         
845         /* Associate this network device with given PCI device */
846         pci_set_drvdata ( pdev, netdev );
847         netdev->dev = &pdev->dev;
848         
849         /* Initialize driver private storage */         
850         adapter = netdev_priv ( netdev );
851         memset ( adapter, 0, ( sizeof ( *adapter ) ) );
852         
853         adapter->hw.io_base = pdev->ioaddr;
854         adapter->ioaddr     = pdev->ioaddr;
855         adapter->irqno      = pdev->irq;
856         adapter->netdev     = netdev;
857         adapter->pdev       = pdev;
858         adapter->hw.back    = adapter;
859
860         adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
861         adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
862
863         mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
864         mmio_len   = pci_bar_size  ( pdev, PCI_BASE_ADDRESS_0 );
865
866         DBG ( "mmio_start: %#08lx\n", mmio_start );
867         DBG ( "mmio_len: %#08lx\n", mmio_len );
868         
869         /* Fix up PCI device */
870         adjust_pci_device ( pdev );
871
872         err = -EIO;
873
874         adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
875         DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
876         
877         if ( ! adapter->hw.hw_addr )
878                 goto err_ioremap;
879
880         /* setup the private structure */
881         if ( ( err = e1000_sw_init ( adapter ) ) )
882                 goto err_sw_init;
883
884         DBG ( "adapter->hw.mac_type: %#08x\n", adapter->hw.mac_type );
885
886         /* Flash BAR mapping must happen after e1000_sw_init
887          * because it depends on mac_type 
888          */
889         if ( ( adapter->hw.mac_type == e1000_ich8lan ) && ( pdev->ioaddr ) ) {
890                 flash_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_1 );
891                 flash_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_1 );
892                 adapter->hw.flash_address = ioremap ( flash_start, flash_len );
893                 if ( ! adapter->hw.flash_address )
894                         goto err_flashmap;
895         }
896
897         /* initialize eeprom parameters */
898         if ( e1000_init_eeprom_params ( &adapter->hw ) ) {
899                 DBG ( "EEPROM initialization failed\n" );
900                 goto err_eeprom;
901         }
902
903         /* before reading the EEPROM, reset the controller to
904          * put the device in a known good starting state 
905          */
906         err = e1000_reset_hw ( &adapter->hw );
907         if ( err < 0 ) {
908                 DBG ( "Hardware Initialization Failed\n" );
909                 goto err_reset;
910         }
911
912         /* make sure the EEPROM is good */
913         if ( e1000_validate_eeprom_checksum( &adapter->hw ) < 0 ) {
914                 DBG ( "The EEPROM Checksum Is Not Valid\n" );
915                 goto err_eeprom;
916         }
917
918         /* copy the MAC address out of the EEPROM */
919         if ( e1000_read_mac_addr ( &adapter->hw ) )
920                 DBG ( "EEPROM Read Error\n" );
921
922         memcpy ( netdev->hw_addr, adapter->hw.mac_addr, ETH_ALEN );
923
924         /* print bus type/speed/width info */
925         {
926         struct e1000_hw *hw = &adapter->hw;
927         DBG ( "(PCI%s:%s:%s) ",
928               ((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
929                (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
930               ((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
931                (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
932                (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
933                (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
934                (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
935               ((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
936                (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
937                (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
938                "32-bit"));
939         }
940         for (i = 0; i < 6; i++)
941                 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
942         
943         /* reset the hardware with the new settings */
944         e1000_reset ( adapter );
945         
946         e1000_get_hw_control ( adapter );
947
948         /* Mark as link up; we don't yet handle link state */
949         netdev_link_up ( netdev );
950
951         if ( ( err = register_netdev ( netdev ) ) != 0)
952                 goto err_register;
953                 
954         DBG ( "e1000_probe succeeded!\n" );     
955
956         /* No errors, return success */
957         return 0;
958
959 /* Error return paths */
960 err_reset:
961 err_register:
962 err_eeprom:
963         if ( ! e1000_check_phy_reset_block ( &adapter->hw ) )
964                 e1000_phy_hw_reset ( &adapter->hw );
965         if ( adapter->hw.flash_address )
966                 iounmap ( adapter->hw.flash_address );
967 err_flashmap:
968 err_sw_init:
969         iounmap ( adapter->hw.hw_addr );
970 err_ioremap:
971         netdev_put ( netdev );
972 err_alloc_etherdev:
973         return err;
974 }
975
976 /**
977  * e1000_remove - Device Removal Routine
978  *
979  * @v pdev PCI device information struct
980  *
981  **/
982 static void
983 e1000_remove ( struct pci_device *pdev )
984 {
985         struct net_device *netdev = pci_get_drvdata ( pdev );
986         struct e1000_adapter *adapter = netdev_priv ( netdev );
987         
988         DBG ( "e1000_remove\n" );
989
990         if ( adapter->hw.flash_address )
991                 iounmap ( adapter->hw.flash_address );
992         if  ( adapter->hw.hw_addr )
993                 iounmap ( adapter->hw.hw_addr );
994
995         unregister_netdev ( netdev );
996         e1000_reset_hw ( &adapter->hw );
997         netdev_nullify ( netdev );
998         netdev_put ( netdev );
999 }
1000
1001 /**
1002  * e1000_open - Called when a network interface is made active
1003  *
1004  * @v netdev    network interface device structure
1005  * @ret rc      Return status code, 0 on success, negative value on failure
1006  *
1007  **/
1008 static int
1009 e1000_open ( struct net_device *netdev )
1010 {
1011         struct e1000_adapter *adapter = netdev_priv(netdev);
1012         int err;
1013         
1014         DBG ( "e1000_open\n" ); 
1015
1016         /* allocate transmit descriptors */
1017         err = e1000_setup_tx_resources ( adapter );
1018         if ( err ) {
1019                 DBG ( "Error setting up TX resources!\n" );
1020                 goto err_setup_tx;
1021         }
1022
1023         /* allocate receive descriptors */
1024         err = e1000_setup_rx_resources ( adapter );
1025         if ( err ) {
1026                 DBG ( "Error setting up RX resources!\n" );
1027                 goto err_setup_rx;
1028         }
1029
1030         e1000_configure_tx ( adapter );
1031
1032         e1000_configure_rx ( adapter );
1033         
1034         DBG ( "RXDCTL: %#08x\n",  E1000_READ_REG ( &adapter->hw, RXDCTL ) );
1035
1036         return 0;
1037
1038 err_setup_rx:
1039         e1000_free_tx_resources ( adapter );
1040 err_setup_tx:
1041         e1000_reset ( adapter );
1042
1043         return err;
1044 }
1045
1046 /** e1000 net device operations */
1047 static struct net_device_operations e1000_operations = {
1048         .open           = e1000_open,
1049         .close          = e1000_close,
1050         .transmit       = e1000_transmit,
1051         .poll           = e1000_poll,
1052         .irq            = e1000_irq,
1053 };
1054
1055 int32_t
1056 e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
1057 {
1058     struct e1000_adapter *adapter = hw->back;
1059     uint16_t cap_offset;
1060
1061 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
1062     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
1063     if (!cap_offset)
1064         return -E1000_ERR_CONFIG;
1065
1066     pci_read_config_word(adapter->pdev, cap_offset + reg, value);
1067
1068     return 0;
1069 }
1070
1071 void
1072 e1000_pci_clear_mwi ( struct e1000_hw *hw )
1073 {
1074         struct e1000_adapter *adapter = hw->back;
1075
1076         pci_write_config_word ( adapter->pdev, PCI_COMMAND,
1077                                 hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE );
1078 }
1079
1080 void
1081 e1000_pci_set_mwi ( struct e1000_hw *hw )
1082 {
1083         struct e1000_adapter *adapter = hw->back;
1084
1085         pci_write_config_word ( adapter->pdev, PCI_COMMAND, hw->pci_cmd_word );
1086 }
1087
1088 void
1089 e1000_read_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1090 {
1091         struct e1000_adapter *adapter = hw->back;
1092
1093         pci_read_config_word ( adapter->pdev, reg, value );
1094 }
1095
1096 void
1097 e1000_write_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1098 {
1099         struct e1000_adapter *adapter = hw->back;
1100
1101         pci_write_config_word ( adapter->pdev, reg, *value );
1102 }
1103
1104 void
1105 e1000_io_write ( struct e1000_hw *hw  __unused, unsigned long port, uint32_t value )
1106 {
1107         outl ( value, port );
1108 }
1109
1110 static struct pci_device_id e1000_nics[] = {
1111         PCI_ROM(0x8086, 0x1000, "e1000-0x1000", "e1000-0x1000", 0),
1112         PCI_ROM(0x8086, 0x1001, "e1000-0x1001", "e1000-0x1001", 0),
1113         PCI_ROM(0x8086, 0x1004, "e1000-0x1004", "e1000-0x1004", 0),
1114         PCI_ROM(0x8086, 0x1008, "e1000-0x1008", "e1000-0x1008", 0),
1115         PCI_ROM(0x8086, 0x1009, "e1000-0x1009", "e1000-0x1009", 0),
1116         PCI_ROM(0x8086, 0x100c, "e1000-0x100c", "e1000-0x100c", 0),
1117         PCI_ROM(0x8086, 0x100d, "e1000-0x100d", "e1000-0x100d", 0),
1118         PCI_ROM(0x8086, 0x100e, "e1000-0x100e", "e1000-0x100e", 0),
1119         PCI_ROM(0x8086, 0x100f, "e1000-0x100f", "e1000-0x100f", 0),
1120         PCI_ROM(0x8086, 0x1010, "e1000-0x1010", "e1000-0x1010", 0),
1121         PCI_ROM(0x8086, 0x1011, "e1000-0x1011", "e1000-0x1011", 0),
1122         PCI_ROM(0x8086, 0x1012, "e1000-0x1012", "e1000-0x1012", 0),
1123         PCI_ROM(0x8086, 0x1013, "e1000-0x1013", "e1000-0x1013", 0),
1124         PCI_ROM(0x8086, 0x1014, "e1000-0x1014", "e1000-0x1014", 0),
1125         PCI_ROM(0x8086, 0x1015, "e1000-0x1015", "e1000-0x1015", 0),
1126         PCI_ROM(0x8086, 0x1016, "e1000-0x1016", "e1000-0x1016", 0),
1127         PCI_ROM(0x8086, 0x1017, "e1000-0x1017", "e1000-0x1017", 0),
1128         PCI_ROM(0x8086, 0x1018, "e1000-0x1018", "e1000-0x1018", 0),
1129         PCI_ROM(0x8086, 0x1019, "e1000-0x1019", "e1000-0x1019", 0),
1130         PCI_ROM(0x8086, 0x101a, "e1000-0x101a", "e1000-0x101a", 0),
1131         PCI_ROM(0x8086, 0x101d, "e1000-0x101d", "e1000-0x101d", 0),
1132         PCI_ROM(0x8086, 0x101e, "e1000-0x101e", "e1000-0x101e", 0),
1133         PCI_ROM(0x8086, 0x1026, "e1000-0x1026", "e1000-0x1026", 0),
1134         PCI_ROM(0x8086, 0x1027, "e1000-0x1027", "e1000-0x1027", 0),
1135         PCI_ROM(0x8086, 0x1028, "e1000-0x1028", "e1000-0x1028", 0),
1136         PCI_ROM(0x8086, 0x1049, "e1000-0x1049", "e1000-0x1049", 0),
1137         PCI_ROM(0x8086, 0x104a, "e1000-0x104a", "e1000-0x104a", 0),
1138         PCI_ROM(0x8086, 0x104b, "e1000-0x104b", "e1000-0x104b", 0),
1139         PCI_ROM(0x8086, 0x104c, "e1000-0x104c", "e1000-0x104c", 0),
1140         PCI_ROM(0x8086, 0x104d, "e1000-0x104d", "e1000-0x104d", 0),
1141         PCI_ROM(0x8086, 0x105e, "e1000-0x105e", "e1000-0x105e", 0),
1142         PCI_ROM(0x8086, 0x105f, "e1000-0x105f", "e1000-0x105f", 0),
1143         PCI_ROM(0x8086, 0x1060, "e1000-0x1060", "e1000-0x1060", 0),
1144         PCI_ROM(0x8086, 0x1075, "e1000-0x1075", "e1000-0x1075", 0),
1145         PCI_ROM(0x8086, 0x1076, "e1000-0x1076", "e1000-0x1076", 0),
1146         PCI_ROM(0x8086, 0x1077, "e1000-0x1077", "e1000-0x1077", 0),
1147         PCI_ROM(0x8086, 0x1078, "e1000-0x1078", "e1000-0x1078", 0),
1148         PCI_ROM(0x8086, 0x1079, "e1000-0x1079", "e1000-0x1079", 0),
1149         PCI_ROM(0x8086, 0x107a, "e1000-0x107a", "e1000-0x107a", 0),
1150         PCI_ROM(0x8086, 0x107b, "e1000-0x107b", "e1000-0x107b", 0),
1151         PCI_ROM(0x8086, 0x107c, "e1000-0x107c", "e1000-0x107c", 0),
1152         PCI_ROM(0x8086, 0x107d, "e1000-0x107d", "e1000-0x107d", 0),
1153         PCI_ROM(0x8086, 0x107e, "e1000-0x107e", "e1000-0x107e", 0),
1154         PCI_ROM(0x8086, 0x107f, "e1000-0x107f", "e1000-0x107f", 0),
1155         PCI_ROM(0x8086, 0x108a, "e1000-0x108a", "e1000-0x108a", 0),
1156         PCI_ROM(0x8086, 0x108b, "e1000-0x108b", "e1000-0x108b", 0),
1157         PCI_ROM(0x8086, 0x108c, "e1000-0x108c", "e1000-0x108c", 0),
1158         PCI_ROM(0x8086, 0x1096, "e1000-0x1096", "e1000-0x1096", 0),
1159         PCI_ROM(0x8086, 0x1098, "e1000-0x1098", "e1000-0x1098", 0),
1160         PCI_ROM(0x8086, 0x1099, "e1000-0x1099", "e1000-0x1099", 0),
1161         PCI_ROM(0x8086, 0x109a, "e1000-0x109a", "e1000-0x109a", 0),
1162         PCI_ROM(0x8086, 0x10a4, "e1000-0x10a4", "e1000-0x10a4", 0),
1163         PCI_ROM(0x8086, 0x10a5, "e1000-0x10a5", "e1000-0x10a5", 0),
1164         PCI_ROM(0x8086, 0x10b5, "e1000-0x10b5", "e1000-0x10b5", 0),
1165         PCI_ROM(0x8086, 0x10b9, "e1000-0x10b9", "e1000-0x10b9", 0),
1166         PCI_ROM(0x8086, 0x10ba, "e1000-0x10ba", "e1000-0x10ba", 0),
1167         PCI_ROM(0x8086, 0x10bb, "e1000-0x10bb", "e1000-0x10bb", 0),
1168         PCI_ROM(0x8086, 0x10bc, "e1000-0x10bc", "e1000-0x10bc", 0),
1169         PCI_ROM(0x8086, 0x10c4, "e1000-0x10c4", "e1000-0x10c4", 0),
1170         PCI_ROM(0x8086, 0x10c5, "e1000-0x10c5", "e1000-0x10c5", 0),
1171         PCI_ROM(0x8086, 0x10c9, "e1000-0x10c9", "e1000-0x10c9", 0),
1172         PCI_ROM(0x8086, 0x10d9, "e1000-0x10d9", "e1000-0x10d9", 0),
1173         PCI_ROM(0x8086, 0x10da, "e1000-0x10da", "e1000-0x10da", 0),
1174 };
1175
1176 struct pci_driver e1000_driver __pci_driver = {
1177         .ids = e1000_nics,
1178         .id_count = (sizeof (e1000_nics) / sizeof (e1000_nics[0])),
1179         .probe = e1000_probe,
1180         .remove = e1000_remove,
1181 };
1182
1183 /*
1184  * Local variables:
1185  *  c-basic-offset: 8
1186  *  c-indent-level: 8
1187  *  tab-width: 8
1188  * End:
1189  */