A bit further.
[akaros.git] / kern / drivers / net / e1000 / e1000_main.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2008 Intel Corporation.
5
6   Portions Copyright(c) 2010 Marty Connor <mdc@etherboot.org>
7   Portions Copyright(c) 2010 Entity Cyber, Inc.
8
9   This program is free software; you can redistribute it and/or modify it
10   under the terms and conditions of the GNU General Public License,
11   version 2, as published by the Free Software Foundation.
12
13   This program is distributed in the hope it will be useful, but WITHOUT
14   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16   more details.
17
18   You should have received a copy of the GNU General Public License along with
19   this program; if not, write to the Free Software Foundation, Inc.,
20   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21
22   The full GNU General Public License is included in this distribution in
23   the file called "COPYING".
24
25   Contact Information:
26   Linux NICS <linux.nics@intel.com>
27   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
28   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
29
30 *******************************************************************************/
31
32 FILE_LICENCE ( GPL2_ONLY );
33
34 #include "e1000.h"
35
36 /**
37  * e1000_irq_disable - Disable interrupt generation
38  *
39  * @adapter: board private structure
40  **/
41 static void e1000_irq_disable ( struct e1000_adapter *adapter )
42 {
43         E1000_WRITE_REG ( &adapter->hw, E1000_IMC, ~0 );
44         E1000_WRITE_FLUSH ( &adapter->hw );
45 }
46
47 /**
48  * e1000_irq_enable - Enable interrupt generation
49  *
50  * @adapter: board private structure
51  **/
52 static void e1000_irq_enable ( struct e1000_adapter *adapter )
53 {
54         E1000_WRITE_REG(&adapter->hw, E1000_IMS, IMS_ENABLE_MASK);
55         E1000_WRITE_FLUSH(&adapter->hw);
56 }
57
58 /**
59  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
60  * @adapter: board private structure to initialize
61  *
62  * e1000_sw_init initializes the Adapter private data structure.
63  * Fields are initialized based on PCI device information and
64  * OS network device settings (MTU size).
65  **/
66 static int e1000_sw_init(struct e1000_adapter *adapter)
67 {
68         struct e1000_hw *hw = &adapter->hw;
69         struct pci_device  *pdev = adapter->pdev;
70
71         /* PCI config space info */
72
73         hw->vendor_id = pdev->vendor;
74         hw->device_id = pdev->device;
75
76         pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &hw->subsystem_vendor_id);
77         pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &hw->subsystem_device_id);
78
79         pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
80
81         pci_read_config_word(pdev, PCI_COMMAND, &hw->bus.pci_cmd_word);
82
83         adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
84         adapter->max_frame_size = MAXIMUM_ETHERNET_VLAN_SIZE +
85                                   ETH_HLEN + ETH_FCS_LEN;
86         adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
87
88         hw->fc.requested_mode = e1000_fc_none;
89
90         /* Initialize the hardware-specific values */
91         if (e1000_setup_init_funcs(hw, false)) {
92                 DBG ("Hardware Initialization Failure\n");
93                 return -EIO;
94         }
95
96         /* Explicitly disable IRQ since the NIC can be in any state. */
97         e1000_irq_disable ( adapter );
98
99         return 0;
100 }
101
102 int32_t e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
103 {
104     struct e1000_adapter *adapter = hw->back;
105     uint16_t cap_offset;
106
107 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
108     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
109     if (!cap_offset)
110         return -E1000_ERR_CONFIG;
111
112     pci_read_config_word(adapter->pdev, cap_offset + reg, value);
113
114     return 0;
115 }
116
117 void e1000_pci_clear_mwi ( struct e1000_hw *hw )
118 {
119         struct e1000_adapter *adapter = hw->back;
120
121         pci_write_config_word ( adapter->pdev, PCI_COMMAND,
122                                 hw->bus.pci_cmd_word & ~PCI_COMMAND_INVALIDATE );
123 }
124
125 void e1000_pci_set_mwi ( struct e1000_hw *hw )
126 {
127         struct e1000_adapter *adapter = hw->back;
128
129         pci_write_config_word ( adapter->pdev, PCI_COMMAND,
130                                 hw->bus.pci_cmd_word );
131 }
132
133 void e1000_read_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
134 {
135         struct e1000_adapter *adapter = hw->back;
136
137         pci_read_config_word ( adapter->pdev, reg, value );
138 }
139
140 void e1000_write_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
141 {
142         struct e1000_adapter *adapter = hw->back;
143
144         pci_write_config_word ( adapter->pdev, reg, *value );
145 }
146
147 /**
148  * e1000_init_manageability - disable interception of ARP packets
149  *
150  * @v adapter   e1000 private structure
151  **/
152 static void e1000_init_manageability ( struct e1000_adapter *adapter )
153 {
154         if (adapter->en_mng_pt) {
155                 u32 manc = E1000_READ_REG(&adapter->hw, E1000_MANC);
156
157                 /* disable hardware interception of ARP */
158                 manc &= ~(E1000_MANC_ARP_EN);
159
160                 E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
161         }
162 }
163
164 /**
165  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
166  *
167  * @v adapter   e1000 private structure
168  *
169  * @ret rc       Returns 0 on success, negative on failure
170  **/
171 static int e1000_setup_tx_resources ( struct e1000_adapter *adapter )
172 {
173         DBG ( "e1000_setup_tx_resources\n" );
174
175         /* Allocate transmit descriptor ring memory.
176            It must not cross a 64K boundary because of hardware errata #23
177            so we use malloc_dma() requesting a 128 byte block that is
178            128 byte aligned. This should guarantee that the memory
179            allocated will not cross a 64K boundary, because 128 is an
180            even multiple of 65536 ( 65536 / 128 == 512 ), so all possible
181            allocations of 128 bytes on a 128 byte boundary will not
182            cross 64K bytes.
183          */
184
185         adapter->tx_base =
186                 malloc_dma ( adapter->tx_ring_size, adapter->tx_ring_size );
187
188         if ( ! adapter->tx_base ) {
189                 return -ENOMEM;
190         }
191
192         memset ( adapter->tx_base, 0, adapter->tx_ring_size );
193
194         DBG ( "adapter->tx_base = %#08lx\n", virt_to_bus ( adapter->tx_base ) );
195
196         return 0;
197 }
198
199 /**
200  * e1000_process_tx_packets - process transmitted packets
201  *
202  * @v netdev    network interface device structure
203  **/
204 static void e1000_process_tx_packets ( struct net_device *netdev )
205 {
206         struct e1000_adapter *adapter = netdev_priv ( netdev );
207         uint32_t i;
208         uint32_t tx_status;
209         struct e1000_tx_desc *tx_curr_desc;
210
211         /* Check status of transmitted packets
212          */
213         while ( ( i = adapter->tx_head ) != adapter->tx_tail ) {
214
215                 tx_curr_desc = ( void * )  ( adapter->tx_base ) +
216                                            ( i * sizeof ( *adapter->tx_base ) );
217
218                 tx_status = tx_curr_desc->upper.data;
219
220                 /* if the packet at tx_head is not owned by hardware it is for us */
221                 if ( ! ( tx_status & E1000_TXD_STAT_DD ) )
222                         break;
223
224                 DBG ( "Sent packet. tx_head: %d tx_tail: %d tx_status: %#08x\n",
225                       adapter->tx_head, adapter->tx_tail, tx_status );
226
227                 if ( tx_status & ( E1000_TXD_STAT_EC | E1000_TXD_STAT_LC |
228                                    E1000_TXD_STAT_TU ) ) {
229                         netdev_tx_complete_err ( netdev, adapter->tx_iobuf[i], -EINVAL );
230                         DBG ( "Error transmitting packet, tx_status: %#08x\n",
231                               tx_status );
232                 } else {
233                         netdev_tx_complete ( netdev, adapter->tx_iobuf[i] );
234                         DBG ( "Success transmitting packet, tx_status: %#08x\n",
235                               tx_status );
236                 }
237
238                 /* Decrement count of used descriptors, clear this descriptor
239                  */
240                 adapter->tx_fill_ctr--;
241                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
242
243                 adapter->tx_head = ( adapter->tx_head + 1 ) % NUM_TX_DESC;
244         }
245 }
246
247 static void e1000_free_tx_resources ( struct e1000_adapter *adapter )
248 {
249         DBG ( "e1000_free_tx_resources\n" );
250
251         free_dma ( adapter->tx_base, adapter->tx_ring_size );
252 }
253
254 /**
255  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
256  * @adapter: board private structure
257  *
258  * Configure the Tx unit of the MAC after a reset.
259  **/
260 static void e1000_configure_tx ( struct e1000_adapter *adapter )
261 {
262         struct e1000_hw *hw = &adapter->hw;
263         uint32_t tctl;
264
265         DBG ( "e1000_configure_tx\n" );
266
267         E1000_WRITE_REG ( hw, E1000_TDBAH(0), 0 );
268         E1000_WRITE_REG ( hw, E1000_TDBAL(0), virt_to_bus ( adapter->tx_base ) );
269         E1000_WRITE_REG ( hw, E1000_TDLEN(0), adapter->tx_ring_size );
270
271         DBG ( "E1000_TDBAL(0): %#08x\n",  E1000_READ_REG ( hw, E1000_TDBAL(0) ) );
272         DBG ( "E1000_TDLEN(0): %d\n",     E1000_READ_REG ( hw, E1000_TDLEN(0) ) );
273
274         /* Setup the HW Tx Head and Tail descriptor pointers */
275         E1000_WRITE_REG ( hw, E1000_TDH(0), 0 );
276         E1000_WRITE_REG ( hw, E1000_TDT(0), 0 );
277
278         adapter->tx_head = 0;
279         adapter->tx_tail = 0;
280         adapter->tx_fill_ctr = 0;
281
282         /* Setup Transmit Descriptor Settings for eop descriptor */
283         tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
284                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT) |
285                 (E1000_COLLISION_DISTANCE  << E1000_COLD_SHIFT);
286
287         e1000_config_collision_dist ( hw );
288
289         E1000_WRITE_REG ( hw, E1000_TCTL, tctl );
290         E1000_WRITE_FLUSH ( hw );
291 }
292
293 static void e1000_free_rx_resources ( struct e1000_adapter *adapter )
294 {
295         int i;
296
297         DBG ( "e1000_free_rx_resources\n" );
298
299         free_dma ( adapter->rx_base, adapter->rx_ring_size );
300
301         for ( i = 0; i < NUM_RX_DESC; i++ ) {
302                 free_iob ( adapter->rx_iobuf[i] );
303         }
304 }
305
306 /**
307  * e1000_refill_rx_ring - allocate Rx io_buffers
308  *
309  * @v adapter   e1000 private structure
310  *
311  * @ret rc       Returns 0 on success, negative on failure
312  **/
313 static int e1000_refill_rx_ring ( struct e1000_adapter *adapter )
314 {
315         int i, rx_curr;
316         int rc = 0;
317         struct e1000_rx_desc *rx_curr_desc;
318         struct e1000_hw *hw = &adapter->hw;
319         struct io_buffer *iob;
320
321         DBG ("e1000_refill_rx_ring\n");
322
323         for ( i = 0; i < NUM_RX_DESC; i++ ) {
324                 rx_curr = ( ( adapter->rx_curr + i ) % NUM_RX_DESC );
325                 rx_curr_desc = adapter->rx_base + rx_curr;
326
327                 if ( rx_curr_desc->status & E1000_RXD_STAT_DD )
328                         continue;
329
330                 if ( adapter->rx_iobuf[rx_curr] != NULL )
331                         continue;
332
333                 DBG2 ( "Refilling rx desc %d\n", rx_curr );
334
335                 iob = alloc_iob ( MAXIMUM_ETHERNET_VLAN_SIZE );
336                 adapter->rx_iobuf[rx_curr] = iob;
337
338                 if ( ! iob ) {
339                         DBG ( "alloc_iob failed\n" );
340                         rc = -ENOMEM;
341                         break;
342                 } else {
343                         rx_curr_desc->buffer_addr = virt_to_bus ( iob->data );
344
345                         E1000_WRITE_REG ( hw, E1000_RDT(0), rx_curr );
346                 }
347         }
348         return rc;
349 }
350
351 /**
352  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
353  *
354  * @v adapter   e1000 private structure
355  *
356  * @ret rc       Returns 0 on success, negative on failure
357  **/
358 static int e1000_setup_rx_resources ( struct e1000_adapter *adapter )
359 {
360         int i, rc = 0;
361
362         DBG ( "e1000_setup_rx_resources\n" );
363
364         /* Allocate receive descriptor ring memory.
365            It must not cross a 64K boundary because of hardware errata
366          */
367
368         adapter->rx_base =
369                 malloc_dma ( adapter->rx_ring_size, adapter->rx_ring_size );
370
371         if ( ! adapter->rx_base ) {
372                 return -ENOMEM;
373         }
374         memset ( adapter->rx_base, 0, adapter->rx_ring_size );
375
376         for ( i = 0; i < NUM_RX_DESC; i++ ) {
377                 /* let e1000_refill_rx_ring() io_buffer allocations */
378                 adapter->rx_iobuf[i] = NULL;
379         }
380
381         /* allocate io_buffers */
382         rc = e1000_refill_rx_ring ( adapter );
383         if ( rc < 0 )
384                 e1000_free_rx_resources ( adapter );
385
386         return rc;
387 }
388
389 /**
390  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
391  * @adapter: board private structure
392  *
393  * Configure the Rx unit of the MAC after a reset.
394  **/
395 static void e1000_configure_rx ( struct e1000_adapter *adapter )
396 {
397         struct e1000_hw *hw = &adapter->hw;
398         uint32_t rctl;
399
400         DBG ( "e1000_configure_rx\n" );
401
402         /* disable receives while setting up the descriptors */
403         rctl = E1000_READ_REG ( hw, E1000_RCTL );
404         E1000_WRITE_REG ( hw, E1000_RCTL, rctl & ~E1000_RCTL_EN );
405         E1000_WRITE_FLUSH ( hw );
406         mdelay(10);
407
408         adapter->rx_curr = 0;
409
410         /* Setup the HW Rx Head and Tail Descriptor Pointers and
411          * the Base and Length of the Rx Descriptor Ring */
412
413         E1000_WRITE_REG ( hw, E1000_RDBAL(0), virt_to_bus ( adapter->rx_base ) );
414         E1000_WRITE_REG ( hw, E1000_RDBAH(0), 0 );
415         E1000_WRITE_REG ( hw, E1000_RDLEN(0), adapter->rx_ring_size );
416
417         E1000_WRITE_REG ( hw, E1000_RDH(0), 0 );
418         E1000_WRITE_REG ( hw, E1000_RDT(0), NUM_RX_DESC - 1 );
419
420         /* Enable Receives */
421         rctl |=  E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
422                  E1000_RCTL_MPE;
423         E1000_WRITE_REG ( hw, E1000_RCTL, rctl );
424         E1000_WRITE_FLUSH ( hw );
425
426         DBG ( "E1000_RDBAL(0): %#08x\n",  E1000_READ_REG ( hw, E1000_RDBAL(0) ) );
427         DBG ( "E1000_RDLEN(0): %d\n",     E1000_READ_REG ( hw, E1000_RDLEN(0) ) );
428         DBG ( "E1000_RCTL:  %#08x\n",  E1000_READ_REG ( hw, E1000_RCTL ) );
429 }
430
431 /**
432  * e1000_process_rx_packets - process received packets
433  *
434  * @v netdev    network interface device structure
435  **/
436 static void e1000_process_rx_packets ( struct net_device *netdev )
437 {
438         struct e1000_adapter *adapter = netdev_priv ( netdev );
439         uint32_t i;
440         uint32_t rx_status;
441         uint32_t rx_len;
442         uint32_t rx_err;
443         struct e1000_rx_desc *rx_curr_desc;
444
445         /* Process received packets
446          */
447         while ( 1 ) {
448
449                 i = adapter->rx_curr;
450
451                 rx_curr_desc = ( void * )  ( adapter->rx_base ) +
452                                   ( i * sizeof ( *adapter->rx_base ) );
453                 rx_status = rx_curr_desc->status;
454
455                 DBG2 ( "Before DD Check RX_status: %#08x\n", rx_status );
456
457                 if ( ! ( rx_status & E1000_RXD_STAT_DD ) )
458                         break;
459
460                 if ( adapter->rx_iobuf[i] == NULL )
461                         break;
462
463                 DBG ( "E1000_RCTL = %#08x\n", E1000_READ_REG ( &adapter->hw, E1000_RCTL ) );
464
465                 rx_len = rx_curr_desc->length;
466
467                 DBG ( "Received packet, rx_curr: %d  rx_status: %#08x  rx_len: %d\n",
468                       i, rx_status, rx_len );
469
470                 rx_err = rx_curr_desc->errors;
471
472                 iob_put ( adapter->rx_iobuf[i], rx_len );
473
474                 if ( rx_err & E1000_RXD_ERR_FRAME_ERR_MASK ) {
475
476                         netdev_rx_err ( netdev, adapter->rx_iobuf[i], -EINVAL );
477                         DBG ( "e1000_poll: Corrupted packet received!"
478                               " rx_err: %#08x\n", rx_err );
479                 } else {
480                         /* Add this packet to the receive queue. */
481                         netdev_rx ( netdev, adapter->rx_iobuf[i] );
482                 }
483                 adapter->rx_iobuf[i] = NULL;
484
485                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
486
487                 adapter->rx_curr = ( adapter->rx_curr + 1 ) % NUM_RX_DESC;
488         }
489 }
490
491 /**
492  * e1000_reset - Put e1000 NIC in known initial state
493  *
494  * @v adapter   e1000 private structure
495  **/
496 void e1000_reset ( struct e1000_adapter *adapter )
497 {
498         struct e1000_mac_info *mac = &adapter->hw.mac;
499         u32 pba = 0;
500
501         DBG ( "e1000_reset\n" );
502
503         switch (mac->type) {
504         case e1000_82542:
505         case e1000_82543:
506         case e1000_82544:
507         case e1000_82540:
508         case e1000_82541:
509         case e1000_82541_rev_2:
510                 pba = E1000_PBA_48K;
511                 break;
512         case e1000_82545:
513         case e1000_82545_rev_3:
514         case e1000_82546:
515         case e1000_82546_rev_3:
516                 pba = E1000_PBA_48K;
517                 break;
518         case e1000_82547:
519         case e1000_82547_rev_2:
520                 pba = E1000_PBA_30K;
521                 break;
522         case e1000_undefined:
523         case e1000_num_macs:
524                 break;
525         }
526
527         E1000_WRITE_REG ( &adapter->hw, E1000_PBA, pba );
528
529         /* Allow time for pending master requests to run */
530         e1000_reset_hw ( &adapter->hw );
531
532         if ( mac->type >= e1000_82544 )
533                 E1000_WRITE_REG ( &adapter->hw, E1000_WUC, 0 );
534
535         if ( e1000_init_hw ( &adapter->hw ) )
536                 DBG ( "Hardware Error\n" );
537
538         e1000_reset_adaptive ( &adapter->hw );
539         e1000_get_phy_info ( &adapter->hw );
540
541         e1000_init_manageability ( adapter );
542 }
543
544 /** Functions that implement the gPXE driver API **/
545
546 /**
547  * e1000_close - Disables a network interface
548  *
549  * @v netdev    network interface device structure
550  *
551  **/
552 static void e1000_close ( struct net_device *netdev )
553 {
554         struct e1000_adapter *adapter = netdev_priv ( netdev );
555         struct e1000_hw *hw = &adapter->hw;
556         uint32_t rctl;
557         uint32_t icr;
558
559         DBG ( "e1000_close\n" );
560
561         /* Acknowledge interrupts */
562         icr = E1000_READ_REG ( hw, E1000_ICR );
563
564         e1000_irq_disable ( adapter );
565
566         /* disable receives */
567         rctl = E1000_READ_REG ( hw, E1000_RCTL );
568         E1000_WRITE_REG ( hw, E1000_RCTL, rctl & ~E1000_RCTL_EN );
569         E1000_WRITE_FLUSH ( hw );
570
571         e1000_reset_hw ( hw );
572
573         e1000_free_tx_resources ( adapter );
574         e1000_free_rx_resources ( adapter );
575 }
576
577 /**
578  * e1000_transmit - Transmit a packet
579  *
580  * @v netdev    Network device
581  * @v iobuf     I/O buffer
582  *
583  * @ret rc       Returns 0 on success, negative on failure
584  */
585 static int e1000_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
586 {
587         struct e1000_adapter *adapter = netdev_priv( netdev );
588         struct e1000_hw *hw = &adapter->hw;
589         uint32_t tx_curr = adapter->tx_tail;
590         struct e1000_tx_desc *tx_curr_desc;
591
592         DBG ("e1000_transmit\n");
593
594         if ( adapter->tx_fill_ctr == NUM_TX_DESC ) {
595                 DBG ("TX overflow\n");
596                 return -ENOBUFS;
597         }
598
599         /* Save pointer to iobuf we have been given to transmit,
600            netdev_tx_complete() will need it later
601          */
602         adapter->tx_iobuf[tx_curr] = iobuf;
603
604         tx_curr_desc = ( void * ) ( adapter->tx_base ) +
605                        ( tx_curr * sizeof ( *adapter->tx_base ) );
606
607         DBG ( "tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
608         DBG ( "tx_curr_desc + 16 = %#08lx\n", virt_to_bus ( tx_curr_desc ) + 16 );
609         DBG ( "iobuf->data = %#08lx\n", virt_to_bus ( iobuf->data ) );
610
611         /* Add the packet to TX ring
612          */
613         tx_curr_desc->buffer_addr =
614                 virt_to_bus ( iobuf->data );
615         tx_curr_desc->lower.data =
616                 E1000_TXD_CMD_RPS  | E1000_TXD_CMD_EOP |
617                 E1000_TXD_CMD_IFCS | iob_len ( iobuf );
618         tx_curr_desc->upper.data = 0;
619
620         DBG ( "TX fill: %d tx_curr: %d addr: %#08lx len: %zd\n", adapter->tx_fill_ctr,
621               tx_curr, virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
622
623         /* Point to next free descriptor */
624         adapter->tx_tail = ( adapter->tx_tail + 1 ) % NUM_TX_DESC;
625         adapter->tx_fill_ctr++;
626
627         /* Write new tail to NIC, making packet available for transmit
628          */
629         wmb();
630         E1000_WRITE_REG ( hw, E1000_TDT(0), adapter->tx_tail );
631
632         return 0;
633 }
634
635 /**
636  * e1000_poll - Poll for received packets
637  *
638  * @v netdev    Network device
639  */
640 static void e1000_poll ( struct net_device *netdev )
641 {
642         struct e1000_adapter *adapter = netdev_priv( netdev );
643         struct e1000_hw *hw = &adapter->hw;
644
645         uint32_t icr;
646
647         DBGP ( "e1000_poll\n" );
648
649         /* Acknowledge interrupts */
650         icr = E1000_READ_REG ( hw, E1000_ICR );
651         if ( ! icr )
652                 return;
653
654         DBG ( "e1000_poll: intr_status = %#08x\n", icr );
655
656         e1000_process_tx_packets ( netdev );
657
658         e1000_process_rx_packets ( netdev );
659
660         e1000_refill_rx_ring(adapter);
661 }
662
663 /**
664  * e1000_irq - enable or Disable interrupts
665  *
666  * @v adapter   e1000 adapter
667  * @v action    requested interrupt action
668  **/
669 static void e1000_irq ( struct net_device *netdev, int enable )
670 {
671         struct e1000_adapter *adapter = netdev_priv ( netdev );
672
673         DBG ( "e1000_irq\n" );
674
675         if ( enable ) {
676                 e1000_irq_enable ( adapter );
677         } else {
678                 e1000_irq_disable ( adapter );
679         }
680 }
681
682 static struct net_device_operations e1000_operations;
683
684 /**
685  * e1000_probe - Initial configuration of e1000 NIC
686  *
687  * @v pci       PCI device
688  * @v id        PCI IDs
689  *
690  * @ret rc      Return status code
691  **/
692 int e1000_probe ( struct pci_device *pdev,
693               const struct pci_device_id *id __unused )
694 {
695         int i, err;
696         struct net_device *netdev;
697         struct e1000_adapter *adapter;
698         unsigned long mmio_start, mmio_len;
699
700         DBG ( "e1000_probe\n" );
701
702         err = -ENOMEM;
703
704         /* Allocate net device ( also allocates memory for netdev->priv
705            and makes netdev-priv point to it ) */
706         netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
707         if ( ! netdev )
708                 goto err_alloc_etherdev;
709
710         /* Associate e1000-specific network operations operations with
711          * generic network device layer */
712         netdev_init ( netdev, &e1000_operations );
713
714         /* Associate this network device with given PCI device */
715         pci_set_drvdata ( pdev, netdev );
716         netdev->dev = &pdev->dev;
717
718         /* Initialize driver private storage */
719         adapter = netdev_priv ( netdev );
720         memset ( adapter, 0, ( sizeof ( *adapter ) ) );
721
722         adapter->pdev       = pdev;
723
724         adapter->ioaddr     = pdev->ioaddr;
725         adapter->hw.io_base = pdev->ioaddr;
726
727         adapter->irqno      = pdev->irq;
728         adapter->netdev     = netdev;
729         adapter->hw.back    = adapter;
730
731         adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
732         adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
733
734         mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
735         mmio_len   = pci_bar_size  ( pdev, PCI_BASE_ADDRESS_0 );
736
737         DBG ( "mmio_start: %#08lx\n", mmio_start );
738         DBG ( "mmio_len: %#08lx\n", mmio_len );
739
740         /* Fix up PCI device */
741         adjust_pci_device ( pdev );
742
743         err = -EIO;
744
745         adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
746         DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
747
748         if ( ! adapter->hw.hw_addr )
749                 goto err_ioremap;
750
751         /* Hardware features, flags and workarounds */
752         if (adapter->hw.mac.type >= e1000_82540) {
753                 adapter->flags |= E1000_FLAG_HAS_SMBUS;
754                 adapter->flags |= E1000_FLAG_HAS_INTR_MODERATION;
755         }
756
757         if (adapter->hw.mac.type == e1000_82543)
758                 adapter->flags |= E1000_FLAG_BAD_TX_CARRIER_STATS_FD;
759
760         adapter->hw.phy.autoneg_wait_to_complete = true;
761         adapter->hw.mac.adaptive_ifs = true;
762
763         /* setup the private structure */
764         if ( ( err = e1000_sw_init ( adapter ) ) )
765                 goto err_sw_init;
766
767         if ((err = e1000_init_mac_params(&adapter->hw)))
768                 goto err_hw_init;
769
770         if ((err = e1000_init_nvm_params(&adapter->hw)))
771                 goto err_hw_init;
772
773         /* Force auto-negotiated speed and duplex */
774         adapter->hw.mac.autoneg = 1;
775
776         if ((err = e1000_init_phy_params(&adapter->hw)))
777                 goto err_hw_init;
778
779         DBG ( "adapter->hw.mac.type: %#08x\n", adapter->hw.mac.type );
780
781         /* before reading the EEPROM, reset the controller to
782          * put the device in a known good starting state
783          */
784         err = e1000_reset_hw ( &adapter->hw );
785         if ( err < 0 ) {
786                 DBG ( "Hardware Initialization Failed\n" );
787                 goto err_reset;
788         }
789         /* make sure the NVM is good */
790
791         if ( e1000_validate_nvm_checksum(&adapter->hw) < 0 ) {
792                 DBG ( "The NVM Checksum Is Not Valid\n" );
793                 err = -EIO;
794                 goto err_eeprom;
795         }
796
797         /* copy the MAC address out of the EEPROM */
798         if ( e1000_read_mac_addr ( &adapter->hw ) )
799                 DBG ( "EEPROM Read Error\n" );
800
801         memcpy ( netdev->hw_addr, adapter->hw.mac.perm_addr, ETH_ALEN );
802
803         /* reset the hardware with the new settings */
804         e1000_reset ( adapter );
805
806         /* Mark as link up; we don't yet handle link state */
807         netdev_link_up ( netdev );
808
809         if ( ( err = register_netdev ( netdev ) ) != 0)
810                 goto err_register;
811
812         for (i = 0; i < 6; i++)
813                 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
814
815         DBG ( "e1000_probe succeeded!\n" );
816
817         /* No errors, return success */
818         return 0;
819
820 /* Error return paths */
821 err_reset:
822 err_register:
823 err_hw_init:
824 err_eeprom:
825         if (!e1000_check_reset_block(&adapter->hw))
826                 e1000_phy_hw_reset(&adapter->hw);
827         if (adapter->hw.flash_address)
828                 iounmap(adapter->hw.flash_address);
829 err_sw_init:
830         iounmap ( adapter->hw.hw_addr );
831 err_ioremap:
832         netdev_put ( netdev );
833 err_alloc_etherdev:
834         return err;
835 }
836
837 /**
838  * e1000_remove - Device Removal Routine
839  *
840  * @v pdev PCI device information struct
841  *
842  **/
843 void e1000_remove ( struct pci_device *pdev )
844 {
845         struct net_device *netdev = pci_get_drvdata ( pdev );
846         struct e1000_adapter *adapter = netdev_priv ( netdev );
847
848         DBG ( "e1000_remove\n" );
849
850         if ( adapter->hw.flash_address )
851                 iounmap ( adapter->hw.flash_address );
852         if  ( adapter->hw.hw_addr )
853                 iounmap ( adapter->hw.hw_addr );
854
855         unregister_netdev ( netdev );
856         e1000_reset_hw ( &adapter->hw );
857         netdev_nullify ( netdev );
858         netdev_put ( netdev );
859 }
860
861 /**
862  * e1000_open - Called when a network interface is made active
863  *
864  * @v netdev    network interface device structure
865  * @ret rc      Return status code, 0 on success, negative value on failure
866  *
867  **/
868 static int e1000_open ( struct net_device *netdev )
869 {
870         struct e1000_adapter *adapter = netdev_priv(netdev);
871         int err;
872
873         DBG ( "e1000_open\n" );
874
875         /* allocate transmit descriptors */
876         err = e1000_setup_tx_resources ( adapter );
877         if ( err ) {
878                 DBG ( "Error setting up TX resources!\n" );
879                 goto err_setup_tx;
880         }
881
882         /* allocate receive descriptors */
883         err = e1000_setup_rx_resources ( adapter );
884         if ( err ) {
885                 DBG ( "Error setting up RX resources!\n" );
886                 goto err_setup_rx;
887         }
888
889         e1000_configure_tx ( adapter );
890
891         e1000_configure_rx ( adapter );
892
893         DBG ( "E1000_RXDCTL(0): %#08x\n",  E1000_READ_REG ( &adapter->hw, E1000_RXDCTL(0) ) );
894
895         return 0;
896
897 err_setup_rx:
898         e1000_free_tx_resources ( adapter );
899 err_setup_tx:
900         e1000_reset ( adapter );
901
902         return err;
903 }
904
905 /** e1000 net device operations */
906 static struct net_device_operations e1000_operations = {
907         .open           = e1000_open,
908         .close          = e1000_close,
909         .transmit       = e1000_transmit,
910         .poll           = e1000_poll,
911         .irq            = e1000_irq,
912 };