?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[uri] Special case NULL in churi()
[gpxe.git] / src / drivers / net / e1000 / e1000_main.c
blob3421ca1b006f679bc5cd87b7cbd6e996d43fe678
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 };
gPXE - free pxe roms