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