?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make gpxe build.
[gpxe/hramrach.git] / src / drivers / net / e1000 / e1000_main.c
blob0511d88f164a2d170f42d06f53d6ed731040c9ff
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
558 DBG ( "e1000_close\n" );
559
560 /* Acknowledge interrupts */
561 E1000_READ_REG ( hw, E1000_ICR );
562
563 e1000_irq_disable ( adapter );
564
565 /* disable receives */
566 rctl = E1000_READ_REG ( hw, E1000_RCTL );
567 E1000_WRITE_REG ( hw, E1000_RCTL, rctl & ~E1000_RCTL_EN );
568 E1000_WRITE_FLUSH ( hw );
569
570 e1000_reset_hw ( hw );
571
572 e1000_free_tx_resources ( adapter );
573 e1000_free_rx_resources ( adapter );
574 }
575
576 /**
577 * e1000_transmit - Transmit a packet
578 *
579 * @v netdev Network device
580 * @v iobuf I/O buffer
581 *
582 * @ret rc Returns 0 on success, negative on failure
583 */
584 static int e1000_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
585 {
586 struct e1000_adapter *adapter = netdev_priv( netdev );
587 struct e1000_hw *hw = &adapter->hw;
588 uint32_t tx_curr = adapter->tx_tail;
589 struct e1000_tx_desc *tx_curr_desc;
590
591 DBG ("e1000_transmit\n");
592
593 if ( adapter->tx_fill_ctr == NUM_TX_DESC ) {
594 DBG ("TX overflow\n");
595 return -ENOBUFS;
596 }
597
598 /* Save pointer to iobuf we have been given to transmit,
599 netdev_tx_complete() will need it later
600 */
601 adapter->tx_iobuf[tx_curr] = iobuf;
602
603 tx_curr_desc = ( void * ) ( adapter->tx_base ) +
604 ( tx_curr * sizeof ( *adapter->tx_base ) );
605
606 DBG ( "tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
607 DBG ( "tx_curr_desc + 16 = %#08lx\n", virt_to_bus ( tx_curr_desc ) + 16 );
608 DBG ( "iobuf->data = %#08lx\n", virt_to_bus ( iobuf->data ) );
609
610 /* Add the packet to TX ring
611 */
612 tx_curr_desc->buffer_addr =
613 virt_to_bus ( iobuf->data );
614 tx_curr_desc->lower.data =
615 E1000_TXD_CMD_RPS | E1000_TXD_CMD_EOP |
616 E1000_TXD_CMD_IFCS | iob_len ( iobuf );
617 tx_curr_desc->upper.data = 0;
618
619 DBG ( "TX fill: %d tx_curr: %d addr: %#08lx len: %zd\n", adapter->tx_fill_ctr,
620 tx_curr, virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
621
622 /* Point to next free descriptor */
623 adapter->tx_tail = ( adapter->tx_tail + 1 ) % NUM_TX_DESC;
624 adapter->tx_fill_ctr++;
625
626 /* Write new tail to NIC, making packet available for transmit
627 */
628 wmb();
629 E1000_WRITE_REG ( hw, E1000_TDT(0), adapter->tx_tail );
630
631 return 0;
632 }
633
634 /**
635 * e1000_poll - Poll for received packets
636 *
637 * @v netdev Network device
638 */
639 static void e1000_poll ( struct net_device *netdev )
640 {
641 struct e1000_adapter *adapter = netdev_priv( netdev );
642 struct e1000_hw *hw = &adapter->hw;
643
644 uint32_t icr;
645
646 DBGP ( "e1000_poll\n" );
647
648 /* Acknowledge interrupts */
649 icr = E1000_READ_REG ( hw, E1000_ICR );
650 if ( ! icr )
651 return;
652
653 DBG ( "e1000_poll: intr_status = %#08x\n", icr );
654
655 e1000_process_tx_packets ( netdev );
656
657 e1000_process_rx_packets ( netdev );
658
659 e1000_refill_rx_ring(adapter);
660 }
661
662 /**
663 * e1000_irq - enable or Disable interrupts
664 *
665 * @v adapter e1000 adapter
666 * @v action requested interrupt action
667 **/
668 static void e1000_irq ( struct net_device *netdev, int enable )
669 {
670 struct e1000_adapter *adapter = netdev_priv ( netdev );
671
672 DBG ( "e1000_irq\n" );
673
674 if ( enable ) {
675 e1000_irq_enable ( adapter );
676 } else {
677 e1000_irq_disable ( adapter );
678 }
679 }
680
681 static struct net_device_operations e1000_operations;
682
683 /**
684 * e1000_probe - Initial configuration of e1000 NIC
685 *
686 * @v pci PCI device
687 * @v id PCI IDs
688 *
689 * @ret rc Return status code
690 **/
691 int e1000_probe ( struct pci_device *pdev,
692 const struct pci_device_id *id __unused )
693 {
694 int i, err;
695 struct net_device *netdev;
696 struct e1000_adapter *adapter;
697 unsigned long mmio_start, mmio_len;
698
699 DBG ( "e1000_probe\n" );
700
701 err = -ENOMEM;
702
703 /* Allocate net device ( also allocates memory for netdev->priv
704 and makes netdev-priv point to it ) */
705 netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
706 if ( ! netdev )
707 goto err_alloc_etherdev;
708
709 /* Associate e1000-specific network operations operations with
710 * generic network device layer */
711 netdev_init ( netdev, &e1000_operations );
712
713 /* Associate this network device with given PCI device */
714 pci_set_drvdata ( pdev, netdev );
715 netdev->dev = &pdev->dev;
716
717 /* Initialize driver private storage */
718 adapter = netdev_priv ( netdev );
719 memset ( adapter, 0, ( sizeof ( *adapter ) ) );
720
721 adapter->pdev = pdev;
722
723 adapter->ioaddr = pdev->ioaddr;
724 adapter->hw.io_base = pdev->ioaddr;
725
726 adapter->irqno = pdev->irq;
727 adapter->netdev = netdev;
728 adapter->hw.back = adapter;
729
730 adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
731 adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
732
733 mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
734 mmio_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_0 );
735
736 DBG ( "mmio_start: %#08lx\n", mmio_start );
737 DBG ( "mmio_len: %#08lx\n", mmio_len );
738
739 /* Fix up PCI device */
740 adjust_pci_device ( pdev );
741
742 err = -EIO;
743
744 adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
745 DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
746
747 if ( ! adapter->hw.hw_addr )
748 goto err_ioremap;
749
750 /* Hardware features, flags and workarounds */
751 if (adapter->hw.mac.type >= e1000_82540) {
752 adapter->flags |= E1000_FLAG_HAS_SMBUS;
753 adapter->flags |= E1000_FLAG_HAS_INTR_MODERATION;
754 }
755
756 if (adapter->hw.mac.type == e1000_82543)
757 adapter->flags |= E1000_FLAG_BAD_TX_CARRIER_STATS_FD;
758
759 adapter->hw.phy.autoneg_wait_to_complete = true;
760 adapter->hw.mac.adaptive_ifs = true;
761
762 /* setup the private structure */
763 if ( ( err = e1000_sw_init ( adapter ) ) )
764 goto err_sw_init;
765
766 if ((err = e1000_init_mac_params(&adapter->hw)))
767 goto err_hw_init;
768
769 if ((err = e1000_init_nvm_params(&adapter->hw)))
770 goto err_hw_init;
771
772 /* Force auto-negotiated speed and duplex */
773 adapter->hw.mac.autoneg = 1;
774
775 if ((err = e1000_init_phy_params(&adapter->hw)))
776 goto err_hw_init;
777
778 DBG ( "adapter->hw.mac.type: %#08x\n", adapter->hw.mac.type );
779
780 /* before reading the EEPROM, reset the controller to
781 * put the device in a known good starting state
782 */
783 err = e1000_reset_hw ( &adapter->hw );
784 if ( err < 0 ) {
785 DBG ( "Hardware Initialization Failed\n" );
786 goto err_reset;
787 }
788 /* make sure the NVM is good */
789
790 if ( e1000_validate_nvm_checksum(&adapter->hw) < 0 ) {
791 DBG ( "The NVM Checksum Is Not Valid\n" );
792 err = -EIO;
793 goto err_eeprom;
794 }
795
796 /* copy the MAC address out of the EEPROM */
797 if ( e1000_read_mac_addr ( &adapter->hw ) )
798 DBG ( "EEPROM Read Error\n" );
799
800 memcpy ( netdev->hw_addr, adapter->hw.mac.perm_addr, ETH_ALEN );
801
802 /* reset the hardware with the new settings */
803 e1000_reset ( adapter );
804
805 /* Mark as link up; we don't yet handle link state */
806 netdev_link_up ( netdev );
807
808 if ( ( err = register_netdev ( netdev ) ) != 0)
809 goto err_register;
810
811 for (i = 0; i < 6; i++)
812 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
813
814 DBG ( "e1000_probe succeeded!\n" );
815
816 /* No errors, return success */
817 return 0;
818
819 /* Error return paths */
820 err_reset:
821 err_register:
822 err_hw_init:
823 err_eeprom:
824 if (!e1000_check_reset_block(&adapter->hw))
825 e1000_phy_hw_reset(&adapter->hw);
826 if (adapter->hw.flash_address)
827 iounmap(adapter->hw.flash_address);
828 err_sw_init:
829 iounmap ( adapter->hw.hw_addr );
830 err_ioremap:
831 netdev_put ( netdev );
832 err_alloc_etherdev:
833 return err;
834 }
835
836 /**
837 * e1000_remove - Device Removal Routine
838 *
839 * @v pdev PCI device information struct
840 *
841 **/
842 void e1000_remove ( struct pci_device *pdev )
843 {
844 struct net_device *netdev = pci_get_drvdata ( pdev );
845 struct e1000_adapter *adapter = netdev_priv ( netdev );
846
847 DBG ( "e1000_remove\n" );
848
849 if ( adapter->hw.flash_address )
850 iounmap ( adapter->hw.flash_address );
851 if ( adapter->hw.hw_addr )
852 iounmap ( adapter->hw.hw_addr );
853
854 unregister_netdev ( netdev );
855 e1000_reset_hw ( &adapter->hw );
856 netdev_nullify ( netdev );
857 netdev_put ( netdev );
858 }
859
860 /**
861 * e1000_open - Called when a network interface is made active
862 *
863 * @v netdev network interface device structure
864 * @ret rc Return status code, 0 on success, negative value on failure
865 *
866 **/
867 static int e1000_open ( struct net_device *netdev )
868 {
869 struct e1000_adapter *adapter = netdev_priv(netdev);
870 int err;
871
872 DBG ( "e1000_open\n" );
873
874 /* allocate transmit descriptors */
875 err = e1000_setup_tx_resources ( adapter );
876 if ( err ) {
877 DBG ( "Error setting up TX resources!\n" );
878 goto err_setup_tx;
879 }
880
881 /* allocate receive descriptors */
882 err = e1000_setup_rx_resources ( adapter );
883 if ( err ) {
884 DBG ( "Error setting up RX resources!\n" );
885 goto err_setup_rx;
886 }
887
888 e1000_configure_tx ( adapter );
889
890 e1000_configure_rx ( adapter );
891
892 DBG ( "E1000_RXDCTL(0): %#08x\n", E1000_READ_REG ( &adapter->hw, E1000_RXDCTL(0) ) );
893
894 return 0;
895
896 err_setup_rx:
897 e1000_free_tx_resources ( adapter );
898 err_setup_tx:
899 e1000_reset ( adapter );
900
901 return err;
902 }
903
904 /** e1000 net device operations */
905 static struct net_device_operations e1000_operations = {
906 .open = e1000_open,
907 .close = e1000_close,
908 .transmit = e1000_transmit,
909 .poll = e1000_poll,
910 .irq = e1000_irq,
911 };