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