317861d6df64da12b1b0dbde76534bb6dba0ecb3
[people/pravin/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 static void
294 e1000_free_rx_resources ( struct e1000_adapter *adapter )
295 {
296         int i;
297
298         DBG ( "e1000_free_rx_resources\n" );
299
300         free_dma ( adapter->rx_base, adapter->rx_ring_size );
301
302         for ( i = 0; i < NUM_RX_DESC; i++ ) {
303                 free_iob ( adapter->rx_iobuf[i] );
304         }
305 }
306
307 /**
308  * e1000_refill_rx_ring - allocate Rx io_buffers
309  *
310  * @v adapter   e1000 private structure
311  *
312  * @ret rc       Returns 0 on success, negative on failure
313  **/
314 int e1000_refill_rx_ring ( struct e1000_adapter *adapter )
315 {
316         int i, rx_curr;
317         int rc = 0;
318         struct e1000_rx_desc *rx_curr_desc;
319         struct e1000_hw *hw = &adapter->hw;
320         struct io_buffer *iob;
321
322         DBG ("e1000_refill_rx_ring\n");
323
324         for ( i = 0; i < NUM_RX_DESC; i++ ) {
325                 rx_curr = ( ( adapter->rx_curr + i ) % NUM_RX_DESC );
326                 rx_curr_desc = adapter->rx_base + rx_curr;
327
328                 if ( rx_curr_desc->status & E1000_RXD_STAT_DD )
329                         continue;
330
331                 if ( adapter->rx_iobuf[rx_curr] != NULL )
332                         continue;
333
334                 DBG2 ( "Refilling rx desc %d\n", rx_curr );
335
336                 iob = alloc_iob ( MAXIMUM_ETHERNET_VLAN_SIZE );
337                 adapter->rx_iobuf[rx_curr] = iob;
338
339                 if ( ! iob ) {
340                         DBG ( "alloc_iob failed\n" );
341                         rc = -ENOMEM;
342                         break;
343                 } else {
344                         rx_curr_desc->buffer_addr = virt_to_bus ( iob->data );
345
346                         E1000_WRITE_REG ( hw, RDT, rx_curr );
347                 }
348         }
349         return rc;
350 }
351
352 /**
353  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
354  *
355  * @v adapter   e1000 private structure
356  *
357  * @ret rc       Returns 0 on success, negative on failure
358  **/
359 static int
360 e1000_setup_rx_resources ( struct e1000_adapter *adapter )
361 {
362         int i, rc = 0;
363         
364         DBG ( "e1000_setup_rx_resources\n" );
365         
366         /* Allocate receive descriptor ring memory.
367            It must not cross a 64K boundary because of hardware errata
368          */
369
370         adapter->rx_base = 
371                 malloc_dma ( adapter->rx_ring_size, adapter->rx_ring_size );
372
373         if ( ! adapter->rx_base ) {
374                 return -ENOMEM;
375         }
376         memset ( adapter->rx_base, 0, adapter->rx_ring_size );
377
378         for ( i = 0; i < NUM_RX_DESC; i++ ) {
379                 /* let e1000_refill_rx_ring() io_buffer allocations */
380                 adapter->rx_iobuf[i] = NULL;
381         }
382
383         /* allocate io_buffers */
384         rc = e1000_refill_rx_ring ( adapter );
385         if ( rc < 0 )
386                 e1000_free_rx_resources ( adapter );
387
388         return rc;
389 }
390
391 /**
392  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
393  * @adapter: board private structure
394  *
395  * Configure the Rx unit of the MAC after a reset.
396  **/
397 static void
398 e1000_configure_rx ( struct e1000_adapter *adapter )
399 {
400         struct e1000_hw *hw = &adapter->hw;
401         uint32_t rctl, rxdctl, mrqc, rxcsum;
402
403         DBG ( "e1000_configure_rx\n" );
404
405         /* disable receives while setting up the descriptors */
406         rctl = E1000_READ_REG ( hw, RCTL );
407         E1000_WRITE_REG ( hw, RCTL, rctl & ~E1000_RCTL_EN );
408         E1000_WRITE_FLUSH ( hw );
409         mdelay(10);
410
411         adapter->rx_curr = 0;
412
413         /* Setup the HW Rx Head and Tail Descriptor Pointers and
414          * the Base and Length of the Rx Descriptor Ring */      
415
416         E1000_WRITE_REG ( hw, RDBAL, virt_to_bus ( adapter->rx_base ) );
417         E1000_WRITE_REG ( hw, RDBAH, 0 );
418         E1000_WRITE_REG ( hw, RDLEN, adapter->rx_ring_size );
419
420         E1000_WRITE_REG ( hw, RDH, 0 );
421         if (hw->mac_type == e1000_82576)
422                 E1000_WRITE_REG ( hw, RDT, 0 );
423         else
424                 E1000_WRITE_REG ( hw, RDT, NUM_RX_DESC - 1 );
425
426         /* This doesn't seem to  be necessary for correct operation,
427          * but it seems as well to be implicit
428          */
429         if (hw->mac_type == e1000_82576) {
430                 rxdctl = E1000_READ_REG ( hw, RXDCTL );
431                 rxdctl |= E1000_RXDCTL_QUEUE_ENABLE;
432                 rxdctl &= 0xFFF00000;
433                 rxdctl |= IGB_RX_PTHRESH;
434                 rxdctl |= IGB_RX_HTHRESH << 8;
435                 rxdctl |= IGB_RX_WTHRESH << 16;
436                 E1000_WRITE_REG ( hw, RXDCTL, rxdctl );
437                 E1000_WRITE_FLUSH ( hw );
438
439                 rxcsum = E1000_READ_REG(hw, RXCSUM);
440                 rxcsum &= ~( E1000_RXCSUM_TUOFL | E1000_RXCSUM_IPPCSE );
441                 E1000_WRITE_REG ( hw, RXCSUM, 0 );
442
443                 /* The initial value for MRQC disables multiple receive
444                  * queues, however this setting is not recommended.
445                  * - IntelĀ® 82576 Gigabit Ethernet Controller Datasheet r2.41
446                  *   Section 8.10.9 Multiple Queues Command Register - MRQC
447                  */
448                 mrqc = E1000_MRQC_ENABLE_VMDQ;
449                 E1000_WRITE_REG ( hw, MRQC, mrqc );
450         }
451
452         /* Enable Receives */
453         rctl |=  E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
454                  E1000_RCTL_MPE;
455         E1000_WRITE_REG ( hw, RCTL, rctl );
456         E1000_WRITE_FLUSH ( hw );
457
458         /* On the 82576, RDT([0]) must not be "bumped" before
459          * the enable bit of RXDCTL([0]) is set.
460          * - IntelĀ® 82576 Gigabit Ethernet Controller Datasheet r2.41
461          *   Section 4.5.9 receive Initialization
462          *
463          * By observation I have found to occur when the enable bit of
464          * RCTL is set. The datasheet recommends polling for this bit,
465          * however as I see no evidence of this in the Linux igb driver
466          * I have omitted that step.
467          * - Simon Horman, May 2009
468          */
469         if (hw->mac_type == e1000_82576)
470                 E1000_WRITE_REG ( hw, RDT, NUM_RX_DESC - 1 );
471
472         DBG ( "RDBAL: %#08x\n",  E1000_READ_REG ( hw, RDBAL ) );
473         DBG ( "RDLEN: %d\n",     E1000_READ_REG ( hw, RDLEN ) );
474         DBG ( "RCTL:  %#08x\n",  E1000_READ_REG ( hw, RCTL ) );
475 }
476
477 /**
478  * e1000_reset - Put e1000 NIC in known initial state
479  *
480  * @v adapter   e1000 private structure
481  **/
482 static void
483 e1000_reset ( struct e1000_adapter *adapter )
484 {
485         uint32_t pba = 0;
486         uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
487
488         DBG ( "e1000_reset\n" );
489
490         switch (adapter->hw.mac_type) {
491         case e1000_82542_rev2_0:
492         case e1000_82542_rev2_1:
493         case e1000_82543:
494         case e1000_82544:
495         case e1000_82540:
496         case e1000_82541:
497         case e1000_82541_rev_2:
498                 pba = E1000_PBA_48K;
499                 break;
500         case e1000_82545:
501         case e1000_82545_rev_3:
502         case e1000_82546:
503         case e1000_82546_rev_3:
504                 pba = E1000_PBA_48K;
505                 break;
506         case e1000_82547:
507         case e1000_82547_rev_2:
508                 pba = E1000_PBA_30K;
509                 break;
510         case e1000_82571:
511         case e1000_82572:
512         case e1000_80003es2lan:
513                 pba = E1000_PBA_38K;
514                 break;
515         case e1000_82573:
516                 pba = E1000_PBA_20K;
517                 break;
518         case e1000_82576:
519                 pba = E1000_PBA_64K;
520                 break;
521         case e1000_ich8lan:
522                 pba = E1000_PBA_8K;
523         case e1000_undefined:
524         case e1000_num_macs:
525                 break;
526         }
527
528         E1000_WRITE_REG ( &adapter->hw, PBA, pba );
529         
530         /* flow control settings */
531         /* Set the FC high water mark to 90% of the FIFO size.
532          * Required to clear last 3 LSB */
533         fc_high_water_mark = ((pba * 9216)/10) & 0xFFF8;
534
535         /* We can't use 90% on small FIFOs because the remainder
536          * would be less than 1 full frame.  In this case, we size
537          * it to allow at least a full frame above the high water
538          *  mark. */
539         if (pba < E1000_PBA_16K)
540                 fc_high_water_mark = (pba * 1024) - 1600;
541
542         /* This actually applies to < e1000_82575, one revision less than
543          * e1000_82576, but e1000_82575 isn't currently defined in the code */
544         if (adapter->hw.mac_type < e1000_82576) {
545                 /* 8-byte granularity */
546                 adapter->hw.fc_high_water = fc_high_water_mark & 0xFFF8;
547                 adapter->hw.fc_low_water = adapter->hw.fc_high_water - 8;
548         } else {
549                 /* 16-byte granularity */
550                 adapter->hw.fc_high_water = fc_high_water_mark & 0xFFF0;
551                 adapter->hw.fc_low_water = adapter->hw.fc_high_water - 16;
552         }
553
554         if (adapter->hw.mac_type == e1000_80003es2lan ||
555             adapter->hw.mac_type == e1000_82576)
556                 adapter->hw.fc_pause_time = 0xFFFF;
557         else
558                 adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
559         adapter->hw.fc_send_xon = 1;
560         adapter->hw.fc = adapter->hw.original_fc;
561         /* Allow time for pending master requests to run */
562
563         e1000_reset_hw ( &adapter->hw );
564
565         if ( adapter->hw.mac_type >= e1000_82544 )
566                 E1000_WRITE_REG ( &adapter->hw, WUC, 0 );
567
568         if ( e1000_init_hw ( &adapter->hw ) )
569                 DBG ( "Hardware Error\n" );
570
571         /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
572         if (adapter->hw.mac_type >= e1000_82544 &&
573             adapter->hw.mac_type <= e1000_82547_rev_2 &&
574             adapter->hw.autoneg == 1 &&
575             adapter->hw.autoneg_advertised == ADVERTISE_1000_FULL) {
576                 uint32_t ctrl = E1000_READ_REG(&adapter->hw, CTRL);
577                 /* clear phy power management bit if we are in gig only mode,
578                  * which if enabled will attempt negotiation to 100Mb, which
579                  * can cause a loss of link at power off or driver unload */
580                 ctrl &= ~E1000_CTRL_SWDPIN3;
581                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
582         }
583
584         e1000_phy_get_info ( &adapter->hw, &adapter->phy_info );
585
586         if (!adapter->smart_power_down &&
587             (adapter->hw.mac_type == e1000_82571 ||
588              adapter->hw.mac_type == e1000_82572)) {
589                 uint16_t phy_data = 0;
590                 /* speed up time to link by disabling smart power down, ignore
591                  * the return value of this function because there is nothing
592                  * different we would do if it failed */
593                 e1000_read_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
594                                    &phy_data);
595                 phy_data &= ~IGP02E1000_PM_SPD;
596                 e1000_write_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
597                                     phy_data);
598         }
599 }
600
601 /** Functions that implement the gPXE driver API **/
602
603 /**
604  * e1000_close - Disables a network interface
605  *
606  * @v netdev    network interface device structure
607  *
608  **/
609 static void
610 e1000_close ( struct net_device *netdev )
611 {
612         struct e1000_adapter *adapter = netdev_priv ( netdev );
613         struct e1000_hw *hw = &adapter->hw;
614         uint32_t rctl;
615         uint32_t icr;
616
617         DBG ( "e1000_close\n" );
618         
619         /* Acknowledge interrupts */
620         icr = E1000_READ_REG ( hw, ICR );
621
622         e1000_irq_disable ( adapter );
623
624         /* disable receives */
625         rctl = E1000_READ_REG ( hw, RCTL );
626         E1000_WRITE_REG ( hw, RCTL, rctl & ~E1000_RCTL_EN );
627         E1000_WRITE_FLUSH ( hw );
628
629         e1000_reset_hw ( hw );
630
631         e1000_free_tx_resources ( adapter );
632         e1000_free_rx_resources ( adapter );
633 }
634
635 /** 
636  * e1000_transmit - Transmit a packet
637  *
638  * @v netdev    Network device
639  * @v iobuf     I/O buffer
640  *
641  * @ret rc       Returns 0 on success, negative on failure
642  */
643 static int
644 e1000_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
645 {
646         struct e1000_adapter *adapter = netdev_priv( netdev );
647         struct e1000_hw *hw = &adapter->hw;
648         uint32_t tx_curr = adapter->tx_tail;
649         struct e1000_tx_desc *tx_curr_desc;
650
651         DBG ("e1000_transmit\n");
652         
653         if ( adapter->tx_fill_ctr == NUM_TX_DESC ) {
654                 DBG ("TX overflow\n");
655                 return -ENOBUFS;
656         }
657
658         /* Save pointer to iobuf we have been given to transmit,
659            netdev_tx_complete() will need it later
660          */
661         adapter->tx_iobuf[tx_curr] = iobuf;
662
663         tx_curr_desc = ( void * ) ( adapter->tx_base ) + 
664                        ( tx_curr * sizeof ( *adapter->tx_base ) ); 
665
666         DBG ( "tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
667         DBG ( "tx_curr_desc + 16 = %#08lx\n", virt_to_bus ( tx_curr_desc ) + 16 );
668         DBG ( "iobuf->data = %#08lx\n", virt_to_bus ( iobuf->data ) );
669
670         /* Add the packet to TX ring
671          */
672         tx_curr_desc->buffer_addr = 
673                 virt_to_bus ( iobuf->data );
674         tx_curr_desc->lower.data = 
675                 E1000_TXD_CMD_RPS  | E1000_TXD_CMD_EOP |
676                 E1000_TXD_CMD_IFCS | iob_len ( iobuf );
677         tx_curr_desc->upper.data = 0;
678         
679         DBG ( "TX fill: %d tx_curr: %d addr: %#08lx len: %zd\n", adapter->tx_fill_ctr, 
680               tx_curr, virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
681               
682         /* Point to next free descriptor */
683         adapter->tx_tail = ( adapter->tx_tail + 1 ) % NUM_TX_DESC;
684         adapter->tx_fill_ctr++;
685
686         /* Write new tail to NIC, making packet available for transmit
687          */
688         wmb();
689         E1000_WRITE_REG ( hw, TDT, adapter->tx_tail );
690
691         return 0;
692 }
693
694 /** 
695  * e1000_poll - Poll for received packets
696  *
697  * @v netdev    Network device
698  */
699 static void
700 e1000_poll ( struct net_device *netdev )
701 {
702         struct e1000_adapter *adapter = netdev_priv( netdev );
703         struct e1000_hw *hw = &adapter->hw;
704
705         uint32_t icr;
706         uint32_t tx_status;
707         uint32_t rx_status;
708         uint32_t rx_len;
709         uint32_t rx_err;
710         struct e1000_tx_desc *tx_curr_desc;
711         struct e1000_rx_desc *rx_curr_desc;
712         uint32_t i;
713
714         DBGP ( "e1000_poll\n" );
715
716         /* Acknowledge interrupts */
717         icr = E1000_READ_REG ( hw, ICR );
718         if ( ! icr )
719                 return;
720                 
721         DBG ( "e1000_poll: intr_status = %#08x\n", icr );
722
723         /* Check status of transmitted packets
724          */
725         while ( ( i = adapter->tx_head ) != adapter->tx_tail ) {
726                         
727                 tx_curr_desc = ( void * )  ( adapter->tx_base ) + 
728                                            ( i * sizeof ( *adapter->tx_base ) ); 
729                                                         
730                 tx_status = tx_curr_desc->upper.data;
731
732                 /* if the packet at tx_head is not owned by hardware it is for us */
733                 if ( ! ( tx_status & E1000_TXD_STAT_DD ) )
734                         break;
735                 
736                 DBG ( "Sent packet. tx_head: %d tx_tail: %d tx_status: %#08x\n",
737                       adapter->tx_head, adapter->tx_tail, tx_status );
738
739                 if ( tx_status & ( E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | 
740                                    E1000_TXD_STAT_TU ) ) {
741                         netdev_tx_complete_err ( netdev, adapter->tx_iobuf[i], -EINVAL );
742                         DBG ( "Error transmitting packet, tx_status: %#08x\n",
743                               tx_status );
744                 } else {
745                         netdev_tx_complete ( netdev, adapter->tx_iobuf[i] );
746                         DBG ( "Success transmitting packet, tx_status: %#08x\n",
747                               tx_status );
748                 }
749
750                 /* Decrement count of used descriptors, clear this descriptor 
751                  */
752                 adapter->tx_fill_ctr--;
753                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
754                 
755                 adapter->tx_head = ( adapter->tx_head + 1 ) % NUM_TX_DESC;              
756         }
757         
758         /* Process received packets 
759          */
760         while ( 1 ) {
761         
762                 i = adapter->rx_curr;
763                 
764                 rx_curr_desc = ( void * )  ( adapter->rx_base ) + 
765                                   ( i * sizeof ( *adapter->rx_base ) ); 
766                 rx_status = rx_curr_desc->status;
767                 
768                 DBG2 ( "Before DD Check RX_status: %#08x\n", rx_status );
769         
770                 if ( ! ( rx_status & E1000_RXD_STAT_DD ) )
771                         break;
772
773                 if ( adapter->rx_iobuf[i] == NULL )
774                         break;
775
776                 DBG ( "RCTL = %#08x\n", E1000_READ_REG ( &adapter->hw, RCTL ) );
777         
778                 rx_len = rx_curr_desc->length;
779
780                 DBG ( "Received packet, rx_curr: %d  rx_status: %#08x  rx_len: %d\n",
781                       i, rx_status, rx_len );
782
783                 rx_err = rx_curr_desc->errors;
784
785                 iob_put ( adapter->rx_iobuf[i], rx_len );
786
787                 if ( rx_err & E1000_RXD_ERR_FRAME_ERR_MASK ) {
788                 
789                         netdev_rx_err ( netdev, adapter->rx_iobuf[i], -EINVAL );
790                         DBG ( "e1000_poll: Corrupted packet received!"
791                               " rx_err: %#08x\n", rx_err );
792                 } else  {
793                         /* Add this packet to the receive queue. */
794                         netdev_rx ( netdev, adapter->rx_iobuf[i] );
795                 }
796                 adapter->rx_iobuf[i] = NULL;
797
798                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
799
800                 adapter->rx_curr = ( adapter->rx_curr + 1 ) % NUM_RX_DESC;
801         }
802         e1000_refill_rx_ring(adapter);
803 }
804
805 /**
806  * e1000_irq - enable or Disable interrupts
807  *
808  * @v adapter   e1000 adapter
809  * @v action    requested interrupt action
810  **/
811 static void 
812 e1000_irq ( struct net_device *netdev, int enable )
813 {
814         struct e1000_adapter *adapter = netdev_priv(netdev);
815
816         DBG ( "e1000_irq\n" );
817         
818         switch ( enable ) {
819         case 0 :
820                 e1000_irq_disable ( adapter );
821                 break;
822         case 1 :
823                 e1000_irq_enable ( adapter );
824                 break;
825         case 2 :
826                 e1000_irq_force ( adapter );
827                 break;
828         }
829 }
830
831 static struct net_device_operations e1000_operations;
832
833 /**
834  * e1000_probe - Initial configuration of e1000 NIC
835  *
836  * @v pci       PCI device
837  * @v id        PCI IDs
838  *
839  * @ret rc      Return status code
840  **/
841 static int 
842 e1000_probe ( struct pci_device *pdev,
843               const struct pci_device_id *id __unused )
844 {
845         int i, err;
846         struct net_device *netdev;
847         struct e1000_adapter *adapter;
848         unsigned long mmio_start, mmio_len;
849         unsigned long flash_start, flash_len;
850
851         DBG ( "e1000_probe\n" );
852         
853         err = -ENOMEM;
854
855         /* Allocate net device ( also allocates memory for netdev->priv
856            and makes netdev-priv point to it ) */
857         netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
858         if ( ! netdev ) 
859                 goto err_alloc_etherdev;
860                 
861         /* Associate e1000-specific network operations operations with
862          * generic network device layer */
863         netdev_init ( netdev, &e1000_operations );
864         
865         /* Associate this network device with given PCI device */
866         pci_set_drvdata ( pdev, netdev );
867         netdev->dev = &pdev->dev;
868         
869         /* Initialize driver private storage */         
870         adapter = netdev_priv ( netdev );
871         memset ( adapter, 0, ( sizeof ( *adapter ) ) );
872         
873         adapter->hw.io_base = pdev->ioaddr;
874         adapter->ioaddr     = pdev->ioaddr;
875         adapter->irqno      = pdev->irq;
876         adapter->netdev     = netdev;
877         adapter->pdev       = pdev;
878         adapter->hw.back    = adapter;
879
880         adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
881         adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
882
883         mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
884         mmio_len   = pci_bar_size  ( pdev, PCI_BASE_ADDRESS_0 );
885
886         DBG ( "mmio_start: %#08lx\n", mmio_start );
887         DBG ( "mmio_len: %#08lx\n", mmio_len );
888         
889         /* Fix up PCI device */
890         adjust_pci_device ( pdev );
891
892         err = -EIO;
893
894         adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
895         DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
896         
897         if ( ! adapter->hw.hw_addr )
898                 goto err_ioremap;
899
900         /* setup the private structure */
901         if ( ( err = e1000_sw_init ( adapter ) ) )
902                 goto err_sw_init;
903
904         DBG ( "adapter->hw.mac_type: %#08x\n", adapter->hw.mac_type );
905
906         /* Flash BAR mapping must happen after e1000_sw_init
907          * because it depends on mac_type 
908          */
909         if ( ( adapter->hw.mac_type == e1000_ich8lan ) && ( pdev->ioaddr ) ) {
910                 flash_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_1 );
911                 flash_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_1 );
912                 adapter->hw.flash_address = ioremap ( flash_start, flash_len );
913                 if ( ! adapter->hw.flash_address )
914                         goto err_flashmap;
915         }
916
917         /* initialize eeprom parameters */
918         if ( e1000_init_eeprom_params ( &adapter->hw ) ) {
919                 DBG ( "EEPROM initialization failed\n" );
920                 goto err_eeprom;
921         }
922
923         /* before reading the EEPROM, reset the controller to
924          * put the device in a known good starting state 
925          */
926         err = e1000_reset_hw ( &adapter->hw );
927         if ( err < 0 ) {
928                 DBG ( "Hardware Initialization Failed\n" );
929                 goto err_reset;
930         }
931
932         /* make sure the EEPROM is good */
933         if ( e1000_validate_eeprom_checksum( &adapter->hw ) < 0 ) {
934                 DBG ( "The EEPROM Checksum Is Not Valid\n" );
935                 goto err_eeprom;
936         }
937
938         /* copy the MAC address out of the EEPROM */
939         if ( e1000_read_mac_addr ( &adapter->hw ) )
940                 DBG ( "EEPROM Read Error\n" );
941
942         memcpy ( netdev->hw_addr, adapter->hw.mac_addr, ETH_ALEN );
943
944         /* print bus type/speed/width info */
945         {
946         struct e1000_hw *hw = &adapter->hw;
947         DBG ( "(PCI%s:%s:%s) ",
948               ((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
949                (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
950               ((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
951                (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
952                (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
953                (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
954                (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
955               ((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
956                (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
957                (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
958                "32-bit"));
959         }
960         for (i = 0; i < 6; i++)
961                 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
962         
963         /* reset the hardware with the new settings */
964         e1000_reset ( adapter );
965         
966         e1000_get_hw_control ( adapter );
967
968         /* Mark as link up; we don't yet handle link state */
969         netdev_link_up ( netdev );
970
971         if ( ( err = register_netdev ( netdev ) ) != 0)
972                 goto err_register;
973                 
974         DBG ( "e1000_probe succeeded!\n" );     
975
976         /* No errors, return success */
977         return 0;
978
979 /* Error return paths */
980 err_reset:
981 err_register:
982 err_eeprom:
983         if ( ! e1000_check_phy_reset_block ( &adapter->hw ) )
984                 e1000_phy_hw_reset ( &adapter->hw );
985         if ( adapter->hw.flash_address )
986                 iounmap ( adapter->hw.flash_address );
987 err_flashmap:
988 err_sw_init:
989         iounmap ( adapter->hw.hw_addr );
990 err_ioremap:
991         netdev_put ( netdev );
992 err_alloc_etherdev:
993         return err;
994 }
995
996 /**
997  * e1000_remove - Device Removal Routine
998  *
999  * @v pdev PCI device information struct
1000  *
1001  **/
1002 static void
1003 e1000_remove ( struct pci_device *pdev )
1004 {
1005         struct net_device *netdev = pci_get_drvdata ( pdev );
1006         struct e1000_adapter *adapter = netdev_priv ( netdev );
1007         
1008         DBG ( "e1000_remove\n" );
1009
1010         if ( adapter->hw.flash_address )
1011                 iounmap ( adapter->hw.flash_address );
1012         if  ( adapter->hw.hw_addr )
1013                 iounmap ( adapter->hw.hw_addr );
1014
1015         unregister_netdev ( netdev );
1016         e1000_reset_hw ( &adapter->hw );
1017         netdev_nullify ( netdev );
1018         netdev_put ( netdev );
1019 }
1020
1021 /**
1022  * e1000_open - Called when a network interface is made active
1023  *
1024  * @v netdev    network interface device structure
1025  * @ret rc      Return status code, 0 on success, negative value on failure
1026  *
1027  **/
1028 static int
1029 e1000_open ( struct net_device *netdev )
1030 {
1031         struct e1000_adapter *adapter = netdev_priv(netdev);
1032         int err;
1033         
1034         DBG ( "e1000_open\n" ); 
1035
1036         /* allocate transmit descriptors */
1037         err = e1000_setup_tx_resources ( adapter );
1038         if ( err ) {
1039                 DBG ( "Error setting up TX resources!\n" );
1040                 goto err_setup_tx;
1041         }
1042
1043         /* allocate receive descriptors */
1044         err = e1000_setup_rx_resources ( adapter );
1045         if ( err ) {
1046                 DBG ( "Error setting up RX resources!\n" );
1047                 goto err_setup_rx;
1048         }
1049
1050         e1000_configure_tx ( adapter );
1051
1052         e1000_configure_rx ( adapter );
1053         
1054         DBG ( "RXDCTL: %#08x\n",  E1000_READ_REG ( &adapter->hw, RXDCTL ) );
1055
1056         return 0;
1057
1058 err_setup_rx:
1059         e1000_free_tx_resources ( adapter );
1060 err_setup_tx:
1061         e1000_reset ( adapter );
1062
1063         return err;
1064 }
1065
1066 /** e1000 net device operations */
1067 static struct net_device_operations e1000_operations = {
1068         .open           = e1000_open,
1069         .close          = e1000_close,
1070         .transmit       = e1000_transmit,
1071         .poll           = e1000_poll,
1072         .irq            = e1000_irq,
1073 };
1074
1075 int32_t
1076 e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
1077 {
1078     struct e1000_adapter *adapter = hw->back;
1079     uint16_t cap_offset;
1080
1081 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
1082     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
1083     if (!cap_offset)
1084         return -E1000_ERR_CONFIG;
1085
1086     pci_read_config_word(adapter->pdev, cap_offset + reg, value);
1087
1088     return 0;
1089 }
1090
1091 void
1092 e1000_pci_clear_mwi ( struct e1000_hw *hw )
1093 {
1094         struct e1000_adapter *adapter = hw->back;
1095
1096         pci_write_config_word ( adapter->pdev, PCI_COMMAND,
1097                                 hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE );
1098 }
1099
1100 void
1101 e1000_pci_set_mwi ( struct e1000_hw *hw )
1102 {
1103         struct e1000_adapter *adapter = hw->back;
1104
1105         pci_write_config_word ( adapter->pdev, PCI_COMMAND, hw->pci_cmd_word );
1106 }
1107
1108 void
1109 e1000_read_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1110 {
1111         struct e1000_adapter *adapter = hw->back;
1112
1113         pci_read_config_word ( adapter->pdev, reg, value );
1114 }
1115
1116 void
1117 e1000_write_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1118 {
1119         struct e1000_adapter *adapter = hw->back;
1120
1121         pci_write_config_word ( adapter->pdev, reg, *value );
1122 }
1123
1124 void
1125 e1000_io_write ( struct e1000_hw *hw  __unused, unsigned long port, uint32_t value )
1126 {
1127         outl ( value, port );
1128 }
1129
1130 static struct pci_device_id e1000_nics[] = {
1131         PCI_ROM(0x8086, 0x1000, "e1000-0x1000", "e1000-0x1000", 0),
1132         PCI_ROM(0x8086, 0x1001, "e1000-0x1001", "e1000-0x1001", 0),
1133         PCI_ROM(0x8086, 0x1004, "e1000-0x1004", "e1000-0x1004", 0),
1134         PCI_ROM(0x8086, 0x1008, "e1000-0x1008", "e1000-0x1008", 0),
1135         PCI_ROM(0x8086, 0x1009, "e1000-0x1009", "e1000-0x1009", 0),
1136         PCI_ROM(0x8086, 0x100c, "e1000-0x100c", "e1000-0x100c", 0),
1137         PCI_ROM(0x8086, 0x100d, "e1000-0x100d", "e1000-0x100d", 0),
1138         PCI_ROM(0x8086, 0x100e, "e1000-0x100e", "e1000-0x100e", 0),
1139         PCI_ROM(0x8086, 0x100f, "e1000-0x100f", "e1000-0x100f", 0),
1140         PCI_ROM(0x8086, 0x1010, "e1000-0x1010", "e1000-0x1010", 0),
1141         PCI_ROM(0x8086, 0x1011, "e1000-0x1011", "e1000-0x1011", 0),
1142         PCI_ROM(0x8086, 0x1012, "e1000-0x1012", "e1000-0x1012", 0),
1143         PCI_ROM(0x8086, 0x1013, "e1000-0x1013", "e1000-0x1013", 0),
1144         PCI_ROM(0x8086, 0x1014, "e1000-0x1014", "e1000-0x1014", 0),
1145         PCI_ROM(0x8086, 0x1015, "e1000-0x1015", "e1000-0x1015", 0),
1146         PCI_ROM(0x8086, 0x1016, "e1000-0x1016", "e1000-0x1016", 0),
1147         PCI_ROM(0x8086, 0x1017, "e1000-0x1017", "e1000-0x1017", 0),
1148         PCI_ROM(0x8086, 0x1018, "e1000-0x1018", "e1000-0x1018", 0),
1149         PCI_ROM(0x8086, 0x1019, "e1000-0x1019", "e1000-0x1019", 0),
1150         PCI_ROM(0x8086, 0x101a, "e1000-0x101a", "e1000-0x101a", 0),
1151         PCI_ROM(0x8086, 0x101d, "e1000-0x101d", "e1000-0x101d", 0),
1152         PCI_ROM(0x8086, 0x101e, "e1000-0x101e", "e1000-0x101e", 0),
1153         PCI_ROM(0x8086, 0x1026, "e1000-0x1026", "e1000-0x1026", 0),
1154         PCI_ROM(0x8086, 0x1027, "e1000-0x1027", "e1000-0x1027", 0),
1155         PCI_ROM(0x8086, 0x1028, "e1000-0x1028", "e1000-0x1028", 0),
1156         PCI_ROM(0x8086, 0x1049, "e1000-0x1049", "e1000-0x1049", 0),
1157         PCI_ROM(0x8086, 0x104a, "e1000-0x104a", "e1000-0x104a", 0),
1158         PCI_ROM(0x8086, 0x104b, "e1000-0x104b", "e1000-0x104b", 0),
1159         PCI_ROM(0x8086, 0x104c, "e1000-0x104c", "e1000-0x104c", 0),
1160         PCI_ROM(0x8086, 0x104d, "e1000-0x104d", "e1000-0x104d", 0),
1161         PCI_ROM(0x8086, 0x105e, "e1000-0x105e", "e1000-0x105e", 0),
1162         PCI_ROM(0x8086, 0x105f, "e1000-0x105f", "e1000-0x105f", 0),
1163         PCI_ROM(0x8086, 0x1060, "e1000-0x1060", "e1000-0x1060", 0),
1164         PCI_ROM(0x8086, 0x1075, "e1000-0x1075", "e1000-0x1075", 0),
1165         PCI_ROM(0x8086, 0x1076, "e1000-0x1076", "e1000-0x1076", 0),
1166         PCI_ROM(0x8086, 0x1077, "e1000-0x1077", "e1000-0x1077", 0),
1167         PCI_ROM(0x8086, 0x1078, "e1000-0x1078", "e1000-0x1078", 0),
1168         PCI_ROM(0x8086, 0x1079, "e1000-0x1079", "e1000-0x1079", 0),
1169         PCI_ROM(0x8086, 0x107a, "e1000-0x107a", "e1000-0x107a", 0),
1170         PCI_ROM(0x8086, 0x107b, "e1000-0x107b", "e1000-0x107b", 0),
1171         PCI_ROM(0x8086, 0x107c, "e1000-0x107c", "e1000-0x107c", 0),
1172         PCI_ROM(0x8086, 0x107d, "e1000-0x107d", "e1000-0x107d", 0),
1173         PCI_ROM(0x8086, 0x107e, "e1000-0x107e", "e1000-0x107e", 0),
1174         PCI_ROM(0x8086, 0x107f, "e1000-0x107f", "e1000-0x107f", 0),
1175         PCI_ROM(0x8086, 0x108a, "e1000-0x108a", "e1000-0x108a", 0),
1176         PCI_ROM(0x8086, 0x108b, "e1000-0x108b", "e1000-0x108b", 0),
1177         PCI_ROM(0x8086, 0x108c, "e1000-0x108c", "e1000-0x108c", 0),
1178         PCI_ROM(0x8086, 0x1096, "e1000-0x1096", "e1000-0x1096", 0),
1179         PCI_ROM(0x8086, 0x1098, "e1000-0x1098", "e1000-0x1098", 0),
1180         PCI_ROM(0x8086, 0x1099, "e1000-0x1099", "e1000-0x1099", 0),
1181         PCI_ROM(0x8086, 0x109a, "e1000-0x109a", "e1000-0x109a", 0),
1182         PCI_ROM(0x8086, 0x10a4, "e1000-0x10a4", "e1000-0x10a4", 0),
1183         PCI_ROM(0x8086, 0x10a5, "e1000-0x10a5", "e1000-0x10a5", 0),
1184         PCI_ROM(0x8086, 0x10b5, "e1000-0x10b5", "e1000-0x10b5", 0),
1185         PCI_ROM(0x8086, 0x10b9, "e1000-0x10b9", "e1000-0x10b9", 0),
1186         PCI_ROM(0x8086, 0x10ba, "e1000-0x10ba", "e1000-0x10ba", 0),
1187         PCI_ROM(0x8086, 0x10bb, "e1000-0x10bb", "e1000-0x10bb", 0),
1188         PCI_ROM(0x8086, 0x10bc, "e1000-0x10bc", "e1000-0x10bc", 0),
1189         PCI_ROM(0x8086, 0x10c4, "e1000-0x10c4", "e1000-0x10c4", 0),
1190         PCI_ROM(0x8086, 0x10c5, "e1000-0x10c5", "e1000-0x10c5", 0),
1191         PCI_ROM(0x8086, 0x10c9, "e1000-0x10c9", "e1000-0x10c9", 0),
1192         PCI_ROM(0x8086, 0x10d9, "e1000-0x10d9", "e1000-0x10d9", 0),
1193         PCI_ROM(0x8086, 0x10da, "e1000-0x10da", "e1000-0x10da", 0),
1194 };
1195
1196 struct pci_driver e1000_driver __pci_driver = {
1197         .ids = e1000_nics,
1198         .id_count = (sizeof (e1000_nics) / sizeof (e1000_nics[0])),
1199         .probe = e1000_probe,
1200         .remove = e1000_remove,
1201 };
1202
1203 /*
1204  * Local variables:
1205  *  c-basic-offset: 8
1206  *  c-indent-level: 8
1207  *  tab-width: 8
1208  * End:
1209  */