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