b6af86fc7c5037e0066c6b89d2371cc2ff83946a
[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         E1000_WRITE_REG ( hw, TDT, adapter->tx_tail );
592
593         return 0;
594 }
595
596 /** 
597  * e1000_poll - Poll for received packets
598  *
599  * @v netdev    Network device
600  */
601 static void
602 e1000_poll ( struct net_device *netdev )
603 {
604         struct e1000_adapter *adapter = netdev_priv( netdev );
605         struct e1000_hw *hw = &adapter->hw;
606
607         uint32_t icr;
608         uint32_t tx_status;
609         uint32_t rx_status;
610         uint32_t rx_len;
611         uint32_t rx_err;
612         struct io_buffer *rx_iob;
613         struct e1000_tx_desc *tx_curr_desc;
614         struct e1000_rx_desc *rx_curr_desc;
615         uint32_t i;
616         uint64_t tmp_buffer_addr;
617         
618         DBGP ( "e1000_poll\n" );
619
620         /* Acknowledge interrupts */
621         icr = E1000_READ_REG ( hw, ICR );
622         if ( ! icr )
623                 return;
624                 
625         DBG ( "e1000_poll: intr_status = %#08x\n", icr );
626
627         /* Check status of transmitted packets
628          */
629         while ( ( i = adapter->tx_head ) != adapter->tx_tail ) {
630                         
631                 tx_curr_desc = ( void * )  ( adapter->tx_base ) + 
632                                            ( i * sizeof ( *adapter->tx_base ) ); 
633                                                         
634                 tx_status = tx_curr_desc->upper.data;
635
636                 /* if the packet at tx_head is not owned by hardware it is for us */
637                 if ( ! ( tx_status & E1000_TXD_STAT_DD ) )
638                         break;
639                 
640                 DBG ( "Sent packet. tx_head: %d tx_tail: %d tx_status: %#08x\n",
641                       adapter->tx_head, adapter->tx_tail, tx_status );
642
643                 if ( tx_status & ( E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | 
644                                    E1000_TXD_STAT_TU ) ) {
645                         netdev_tx_complete_err ( netdev, adapter->tx_iobuf[i], -EINVAL );
646                         DBG ( "Error transmitting packet, tx_status: %#08x\n",
647                               tx_status );
648                 } else {
649                         netdev_tx_complete ( netdev, adapter->tx_iobuf[i] );
650                         DBG ( "Success transmitting packet, tx_status: %#08x\n",
651                               tx_status );
652                 }
653
654                 /* Decrement count of used descriptors, clear this descriptor 
655                  */
656                 adapter->tx_fill_ctr--;
657                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
658                 
659                 adapter->tx_head = ( adapter->tx_head + 1 ) % NUM_TX_DESC;              
660         }
661         
662         /* Process received packets 
663          */
664         while ( 1 ) {
665         
666                 i = adapter->rx_curr;
667                 
668                 rx_curr_desc = ( void * )  ( adapter->rx_base ) + 
669                                   ( i * sizeof ( *adapter->rx_base ) ); 
670                 rx_status = rx_curr_desc->status;
671                 
672                 DBG2 ( "Before DD Check RX_status: %#08x\n", rx_status );
673         
674                 if ( ! ( rx_status & E1000_RXD_STAT_DD ) )
675                         break;
676
677                 DBG ( "RCTL = %#08x\n", E1000_READ_REG ( &adapter->hw, RCTL ) );
678         
679                 rx_len = rx_curr_desc->length;
680
681                 DBG ( "Received packet, rx_curr: %d  rx_status: %#08x  rx_len: %d\n",
682                       i, rx_status, rx_len );
683                 
684                 rx_err = rx_curr_desc->errors;
685                 
686                 if ( rx_err & E1000_RXD_ERR_FRAME_ERR_MASK ) {
687                 
688                         netdev_rx_err ( netdev, NULL, -EINVAL );
689                         DBG ( "e1000_poll: Corrupted packet received!"
690                               " rx_err: %#08x\n", rx_err );
691                 } else  {
692                 
693                         /* If unable allocate space for this packet,
694                          *  try again next poll
695                          */
696                         rx_iob = alloc_iob ( rx_len );
697                         if ( ! rx_iob ) 
698                                 break;
699                                 
700                         memcpy ( iob_put ( rx_iob, rx_len ), 
701                                 adapter->rx_iobuf[i]->data, rx_len );
702                                 
703                         /* Add this packet to the receive queue. 
704                          */
705                         netdev_rx ( netdev, rx_iob );
706                 }
707
708                 tmp_buffer_addr = rx_curr_desc->buffer_addr;
709                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
710                 rx_curr_desc->buffer_addr = tmp_buffer_addr;
711
712                 E1000_WRITE_REG ( hw, RDT, adapter->rx_curr );
713
714                 adapter->rx_curr = ( adapter->rx_curr + 1 ) % NUM_RX_DESC;
715         }
716 }                               
717
718 /**
719  * e1000_irq - enable or Disable interrupts
720  *
721  * @v adapter   e1000 adapter
722  * @v action    requested interrupt action
723  **/
724 static void 
725 e1000_irq ( struct net_device *netdev, int enable )
726 {
727         struct e1000_adapter *adapter = netdev_priv(netdev);
728
729         DBG ( "e1000_irq\n" );
730         
731         switch ( enable ) {
732         case 0 :
733                 e1000_irq_disable ( adapter );
734                 break;
735         case 1 :
736                 e1000_irq_enable ( adapter );
737                 break;
738         case 2 :
739                 e1000_irq_force ( adapter );
740                 break;
741         }
742 }
743
744 static struct net_device_operations e1000_operations;
745
746 /**
747  * e1000_probe - Initial configuration of e1000 NIC
748  *
749  * @v pci       PCI device
750  * @v id        PCI IDs
751  *
752  * @ret rc      Return status code
753  **/
754 static int 
755 e1000_probe ( struct pci_device *pdev,
756               const struct pci_device_id *id __unused )
757 {
758         int i, err;
759         struct net_device *netdev;
760         struct e1000_adapter *adapter;
761         unsigned long mmio_start, mmio_len;
762         unsigned long flash_start, flash_len;
763
764         DBG ( "e1000_probe\n" );
765         
766         err = -ENOMEM;
767
768         /* Allocate net device ( also allocates memory for netdev->priv
769            and makes netdev-priv point to it ) */
770         netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
771         if ( ! netdev ) 
772                 goto err_alloc_etherdev;
773                 
774         /* Associate e1000-specific network operations operations with
775          * generic network device layer */
776         netdev_init ( netdev, &e1000_operations );
777         
778         /* Associate this network device with given PCI device */
779         pci_set_drvdata ( pdev, netdev );
780         netdev->dev = &pdev->dev;
781         
782         /* Initialize driver private storage */         
783         adapter = netdev_priv ( netdev );
784         memset ( adapter, 0, ( sizeof ( *adapter ) ) );
785         
786         adapter->hw.io_base = pdev->ioaddr;
787         adapter->ioaddr     = pdev->ioaddr;
788         adapter->irqno      = pdev->irq;
789         adapter->netdev     = netdev;
790         adapter->pdev       = pdev;
791         adapter->hw.back    = adapter;
792
793         adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
794         adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
795
796         mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
797         mmio_len   = pci_bar_size  ( pdev, PCI_BASE_ADDRESS_0 );
798
799         DBG ( "mmio_start: %#08lx\n", mmio_start );
800         DBG ( "mmio_len: %#08lx\n", mmio_len );
801         
802         /* Fix up PCI device */
803         adjust_pci_device ( pdev );
804
805         err = -EIO;
806
807         adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
808         DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
809         
810         if ( ! adapter->hw.hw_addr )
811                 goto err_ioremap;
812
813         /* setup the private structure */
814         if ( ( err = e1000_sw_init ( adapter ) ) )
815                 goto err_sw_init;
816
817         DBG ( "adapter->hw.mac_type: %#08x\n", adapter->hw.mac_type );
818
819         /* Flash BAR mapping must happen after e1000_sw_init
820          * because it depends on mac_type 
821          */
822         if ( ( adapter->hw.mac_type == e1000_ich8lan ) && ( pdev->ioaddr ) ) {
823                 flash_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_1 );
824                 flash_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_1 );
825                 adapter->hw.flash_address = ioremap ( flash_start, flash_len );
826                 if ( ! adapter->hw.flash_address )
827                         goto err_flashmap;
828         }
829
830         /* initialize eeprom parameters */
831         if ( e1000_init_eeprom_params ( &adapter->hw ) ) {
832                 DBG ( "EEPROM initialization failed\n" );
833                 goto err_eeprom;
834         }
835
836         /* before reading the EEPROM, reset the controller to
837          * put the device in a known good starting state 
838          */
839         err = e1000_reset_hw ( &adapter->hw );
840         if ( err < 0 ) {
841                 DBG ( "Hardware Initialization Failed\n" );
842                 goto err_reset;
843         }
844
845         /* make sure the EEPROM is good */
846         if ( e1000_validate_eeprom_checksum( &adapter->hw ) < 0 ) {
847                 DBG ( "The EEPROM Checksum Is Not Valid\n" );
848                 goto err_eeprom;
849         }
850
851         /* copy the MAC address out of the EEPROM */
852         if ( e1000_read_mac_addr ( &adapter->hw ) )
853                 DBG ( "EEPROM Read Error\n" );
854
855         memcpy ( netdev->ll_addr, adapter->hw.mac_addr, ETH_ALEN );
856
857         /* print bus type/speed/width info */
858         {
859         struct e1000_hw *hw = &adapter->hw;
860         DBG ( "(PCI%s:%s:%s) ",
861               ((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
862                (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
863               ((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
864                (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
865                (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
866                (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
867                (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
868               ((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
869                (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
870                (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
871                "32-bit"));
872         }
873         for (i = 0; i < 6; i++)
874                 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
875         
876         /* reset the hardware with the new settings */
877         e1000_reset ( adapter );
878         
879         e1000_get_hw_control ( adapter );
880
881         /* Mark as link up; we don't yet handle link state */
882         netdev_link_up ( netdev );
883
884         if ( ( err = register_netdev ( netdev ) ) != 0)
885                 goto err_register;
886                 
887         DBG ( "e1000_probe succeeded!\n" );     
888
889         /* No errors, return success */
890         return 0;
891
892 /* Error return paths */
893 err_reset:
894 err_register:
895 err_eeprom:
896         if ( ! e1000_check_phy_reset_block ( &adapter->hw ) )
897                 e1000_phy_hw_reset ( &adapter->hw );
898         if ( adapter->hw.flash_address )
899                 iounmap ( adapter->hw.flash_address );
900 err_flashmap:
901 err_sw_init:
902         iounmap ( adapter->hw.hw_addr );
903 err_ioremap:
904         netdev_put ( netdev );
905 err_alloc_etherdev:
906         return err;
907 }
908
909 /**
910  * e1000_remove - Device Removal Routine
911  *
912  * @v pdev PCI device information struct
913  *
914  **/
915 static void
916 e1000_remove ( struct pci_device *pdev )
917 {
918         struct net_device *netdev = pci_get_drvdata ( pdev );
919         struct e1000_adapter *adapter = netdev_priv ( netdev );
920         
921         DBG ( "e1000_remove\n" );
922
923         if ( adapter->hw.flash_address )
924                 iounmap ( adapter->hw.flash_address );
925         if  ( adapter->hw.hw_addr )
926                 iounmap ( adapter->hw.hw_addr );
927
928         unregister_netdev ( netdev );
929         e1000_reset_hw ( &adapter->hw );
930         netdev_nullify ( netdev );
931         netdev_put ( netdev );
932 }
933
934 /**
935  * e1000_open - Called when a network interface is made active
936  *
937  * @v netdev    network interface device structure
938  * @ret rc      Return status code, 0 on success, negative value on failure
939  *
940  **/
941 static int
942 e1000_open ( struct net_device *netdev )
943 {
944         struct e1000_adapter *adapter = netdev_priv(netdev);
945         int err;
946         
947         DBG ( "e1000_open\n" ); 
948
949         /* allocate transmit descriptors */
950         err = e1000_setup_tx_resources ( adapter );
951         if ( err ) {
952                 DBG ( "Error setting up TX resources!\n" );
953                 goto err_setup_tx;
954         }
955
956         /* allocate receive descriptors */
957         err = e1000_setup_rx_resources ( adapter );
958         if ( err ) {
959                 DBG ( "Error setting up RX resources!\n" );
960                 goto err_setup_rx;
961         }
962
963         e1000_configure_tx ( adapter );
964
965         e1000_configure_rx ( adapter );
966         
967         DBG ( "RXDCTL: %#08x\n",  E1000_READ_REG ( &adapter->hw, RXDCTL ) );
968
969         return 0;
970
971 err_setup_rx:
972         e1000_free_tx_resources ( adapter );
973 err_setup_tx:
974         e1000_reset ( adapter );
975
976         return err;
977 }
978
979 /** e1000 net device operations */
980 static struct net_device_operations e1000_operations = {
981         .open           = e1000_open,
982         .close          = e1000_close,
983         .transmit       = e1000_transmit,
984         .poll           = e1000_poll,
985         .irq            = e1000_irq,
986 };
987
988 int32_t
989 e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
990 {
991     struct e1000_adapter *adapter = hw->back;
992     uint16_t cap_offset;
993
994 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
995     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
996     if (!cap_offset)
997         return -E1000_ERR_CONFIG;
998
999     pci_read_config_word(adapter->pdev, cap_offset + reg, value);
1000
1001     return 0;
1002 }
1003
1004 void
1005 e1000_pci_clear_mwi ( struct e1000_hw *hw )
1006 {
1007         struct e1000_adapter *adapter = hw->back;
1008
1009         pci_write_config_word ( adapter->pdev, PCI_COMMAND,
1010                                 hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE );
1011 }
1012
1013 void
1014 e1000_pci_set_mwi ( struct e1000_hw *hw )
1015 {
1016         struct e1000_adapter *adapter = hw->back;
1017
1018         pci_write_config_word ( adapter->pdev, PCI_COMMAND, hw->pci_cmd_word );
1019 }
1020
1021 void
1022 e1000_read_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1023 {
1024         struct e1000_adapter *adapter = hw->back;
1025
1026         pci_read_config_word ( adapter->pdev, reg, value );
1027 }
1028
1029 void
1030 e1000_write_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1031 {
1032         struct e1000_adapter *adapter = hw->back;
1033
1034         pci_write_config_word ( adapter->pdev, reg, *value );
1035 }
1036
1037 void
1038 e1000_io_write ( struct e1000_hw *hw  __unused, unsigned long port, uint32_t value )
1039 {
1040         outl ( value, port );
1041 }
1042
1043 static struct pci_device_id e1000_nics[] = {
1044         PCI_ROM(0x8086, 0x1000, "e1000-0x1000", "e1000-0x1000", 0),
1045         PCI_ROM(0x8086, 0x1001, "e1000-0x1001", "e1000-0x1001", 0),
1046         PCI_ROM(0x8086, 0x1004, "e1000-0x1004", "e1000-0x1004", 0),
1047         PCI_ROM(0x8086, 0x1008, "e1000-0x1008", "e1000-0x1008", 0),
1048         PCI_ROM(0x8086, 0x1009, "e1000-0x1009", "e1000-0x1009", 0),
1049         PCI_ROM(0x8086, 0x100c, "e1000-0x100c", "e1000-0x100c", 0),
1050         PCI_ROM(0x8086, 0x100d, "e1000-0x100d", "e1000-0x100d", 0),
1051         PCI_ROM(0x8086, 0x100e, "e1000-0x100e", "e1000-0x100e", 0),
1052         PCI_ROM(0x8086, 0x100f, "e1000-0x100f", "e1000-0x100f", 0),
1053         PCI_ROM(0x8086, 0x1010, "e1000-0x1010", "e1000-0x1010", 0),
1054         PCI_ROM(0x8086, 0x1011, "e1000-0x1011", "e1000-0x1011", 0),
1055         PCI_ROM(0x8086, 0x1012, "e1000-0x1012", "e1000-0x1012", 0),
1056         PCI_ROM(0x8086, 0x1013, "e1000-0x1013", "e1000-0x1013", 0),
1057         PCI_ROM(0x8086, 0x1014, "e1000-0x1014", "e1000-0x1014", 0),
1058         PCI_ROM(0x8086, 0x1015, "e1000-0x1015", "e1000-0x1015", 0),
1059         PCI_ROM(0x8086, 0x1016, "e1000-0x1016", "e1000-0x1016", 0),
1060         PCI_ROM(0x8086, 0x1017, "e1000-0x1017", "e1000-0x1017", 0),
1061         PCI_ROM(0x8086, 0x1018, "e1000-0x1018", "e1000-0x1018", 0),
1062         PCI_ROM(0x8086, 0x1019, "e1000-0x1019", "e1000-0x1019", 0),
1063         PCI_ROM(0x8086, 0x101a, "e1000-0x101a", "e1000-0x101a", 0),
1064         PCI_ROM(0x8086, 0x101d, "e1000-0x101d", "e1000-0x101d", 0),
1065         PCI_ROM(0x8086, 0x101e, "e1000-0x101e", "e1000-0x101e", 0),
1066         PCI_ROM(0x8086, 0x1026, "e1000-0x1026", "e1000-0x1026", 0),
1067         PCI_ROM(0x8086, 0x1027, "e1000-0x1027", "e1000-0x1027", 0),
1068         PCI_ROM(0x8086, 0x1028, "e1000-0x1028", "e1000-0x1028", 0),
1069         PCI_ROM(0x8086, 0x1049, "e1000-0x1049", "e1000-0x1049", 0),
1070         PCI_ROM(0x8086, 0x104a, "e1000-0x104a", "e1000-0x104a", 0),
1071         PCI_ROM(0x8086, 0x104b, "e1000-0x104b", "e1000-0x104b", 0),
1072         PCI_ROM(0x8086, 0x104c, "e1000-0x104c", "e1000-0x104c", 0),
1073         PCI_ROM(0x8086, 0x104d, "e1000-0x104d", "e1000-0x104d", 0),
1074         PCI_ROM(0x8086, 0x105e, "e1000-0x105e", "e1000-0x105e", 0),
1075         PCI_ROM(0x8086, 0x105f, "e1000-0x105f", "e1000-0x105f", 0),
1076         PCI_ROM(0x8086, 0x1060, "e1000-0x1060", "e1000-0x1060", 0),
1077         PCI_ROM(0x8086, 0x1075, "e1000-0x1075", "e1000-0x1075", 0),
1078         PCI_ROM(0x8086, 0x1076, "e1000-0x1076", "e1000-0x1076", 0),
1079         PCI_ROM(0x8086, 0x1077, "e1000-0x1077", "e1000-0x1077", 0),
1080         PCI_ROM(0x8086, 0x1078, "e1000-0x1078", "e1000-0x1078", 0),
1081         PCI_ROM(0x8086, 0x1079, "e1000-0x1079", "e1000-0x1079", 0),
1082         PCI_ROM(0x8086, 0x107a, "e1000-0x107a", "e1000-0x107a", 0),
1083         PCI_ROM(0x8086, 0x107b, "e1000-0x107b", "e1000-0x107b", 0),
1084         PCI_ROM(0x8086, 0x107c, "e1000-0x107c", "e1000-0x107c", 0),
1085         PCI_ROM(0x8086, 0x107d, "e1000-0x107d", "e1000-0x107d", 0),
1086         PCI_ROM(0x8086, 0x107e, "e1000-0x107e", "e1000-0x107e", 0),
1087         PCI_ROM(0x8086, 0x107f, "e1000-0x107f", "e1000-0x107f", 0),
1088         PCI_ROM(0x8086, 0x108a, "e1000-0x108a", "e1000-0x108a", 0),
1089         PCI_ROM(0x8086, 0x108b, "e1000-0x108b", "e1000-0x108b", 0),
1090         PCI_ROM(0x8086, 0x108c, "e1000-0x108c", "e1000-0x108c", 0),
1091         PCI_ROM(0x8086, 0x1096, "e1000-0x1096", "e1000-0x1096", 0),
1092         PCI_ROM(0x8086, 0x1098, "e1000-0x1098", "e1000-0x1098", 0),
1093         PCI_ROM(0x8086, 0x1099, "e1000-0x1099", "e1000-0x1099", 0),
1094         PCI_ROM(0x8086, 0x109a, "e1000-0x109a", "e1000-0x109a", 0),
1095         PCI_ROM(0x8086, 0x10a4, "e1000-0x10a4", "e1000-0x10a4", 0),
1096         PCI_ROM(0x8086, 0x10a5, "e1000-0x10a5", "e1000-0x10a5", 0),
1097         PCI_ROM(0x8086, 0x10b5, "e1000-0x10b5", "e1000-0x10b5", 0),
1098         PCI_ROM(0x8086, 0x10b9, "e1000-0x10b9", "e1000-0x10b9", 0),
1099         PCI_ROM(0x8086, 0x10ba, "e1000-0x10ba", "e1000-0x10ba", 0),
1100         PCI_ROM(0x8086, 0x10bb, "e1000-0x10bb", "e1000-0x10bb", 0),
1101         PCI_ROM(0x8086, 0x10bc, "e1000-0x10bc", "e1000-0x10bc", 0),
1102         PCI_ROM(0x8086, 0x10c4, "e1000-0x10c4", "e1000-0x10c4", 0),
1103         PCI_ROM(0x8086, 0x10c5, "e1000-0x10c5", "e1000-0x10c5", 0),
1104         PCI_ROM(0x8086, 0x10d9, "e1000-0x10d9", "e1000-0x10d9", 0),
1105         PCI_ROM(0x8086, 0x10da, "e1000-0x10da", "e1000-0x10da", 0),
1106 };
1107
1108 struct pci_driver e1000_driver __pci_driver = {
1109         .ids = e1000_nics,
1110         .id_count = (sizeof (e1000_nics) / sizeof (e1000_nics[0])),
1111         .probe = e1000_probe,
1112         .remove = e1000_remove,
1113 };
1114
1115 /*
1116  * Local variables:
1117  *  c-basic-offset: 8
1118  *  c-indent-level: 8
1119  *  tab-width: 8
1120  * End:
1121  */