src/drivers/net/e1000/e1000.c

   1 /*
   2  * gPXE driver for Intel eepro1000 ethernet cards
   3  *
   4  * Written by Marty Connor
   5  *
   6  * Copyright Entity Cyber, Inc. 2007
   7  *
   8  * This software may be used and distributed according to the terms of
   9  * the GNU General Public License (GPL), incorporated herein by
  10  * reference.  Drivers based on or derived from this code fall under
  11  * the GPL and must retain the authorship, copyright and license
  12  * notice.
  13  *
  14  */
  15
  16 /*******************************************************************************
  17
  18   Intel PRO/1000 Linux driver
  19   Copyright(c) 1999 - 2006 Intel Corporation.
  20
  21   This program is free software; you can redistribute it and/or modify it
  22   under the terms and conditions of the GNU General Public License,
  23   version 2, as published by the Free Software Foundation.
  24
  25   This program is distributed in the hope it will be useful, but WITHOUT
  26   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  27   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  28   more details.
  29
  30   You should have received a copy of the GNU General Public License along with
  31   this program; if not, write to the Free Software Foundation, Inc.,
  32   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  33
  34   The full GNU General Public License is included in this distribution in
  35   the file called "COPYING".
  36
  37   Contact Information:
  38   Linux NICS <linux.nics@intel.com>
  39   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  40   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  41
  42 *******************************************************************************/
  43
  44 FILE_LICENCE ( GPL2_ONLY );
  45
  46 #include "e1000.h"
  47
  48 /**
  49  * e1000_get_hw_control - get control of the h/w from f/w
  50  *
  51  * @v adapter   e1000 private structure
  52  *
  53  * e1000_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
  54  * For ASF and Pass Through versions of f/w this means that
  55  * the driver is loaded. For AMT version (only with 82573)
  56  * of the f/w this means that the network i/f is open.
  57  *
  58  **/
  59 static void
  60 e1000_get_hw_control ( struct e1000_adapter *adapter )
  61 {
  62         uint32_t ctrl_ext;
  63         uint32_t swsm;
  64
  65         DBG ( "e1000_get_hw_control\n" );
  66
  67         /* Let firmware know the driver has taken over */
  68         switch (adapter->hw.mac_type) {
  69         case e1000_82573:
  70                 swsm = E1000_READ_REG(&adapter->hw, SWSM);
  71                 E1000_WRITE_REG(&adapter->hw, SWSM,
  72                                 swsm | E1000_SWSM_DRV_LOAD);
  73                 break;
  74         case e1000_82571:
  75         case e1000_82572:
  76         case e1000_80003es2lan:
  77         case e1000_ich8lan:
  78                 ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
  79                 E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
  80                                 ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
  81                 break;
  82         default:
  83                 break;
  84         }
  85 }
  86
  87 /**
  88  * e1000_irq_enable - Enable default interrupt generation settings
  89  *
  90  * @v adapter   e1000 private structure
  91  **/
  92 static void
  93 e1000_irq_enable ( struct e1000_adapter *adapter )
  94 {
  95         E1000_WRITE_REG ( &adapter->hw, IMS, E1000_IMS_RXDMT0 |
  96                                              E1000_IMS_RXSEQ );
  97         E1000_WRITE_FLUSH ( &adapter->hw );
  98 }
  99
 100 /**
 101  * e1000_irq_disable - Mask off interrupt generation on the NIC
 102  *
 103  * @v adapter   e1000 private structure
 104  **/
 105 static void
 106 e1000_irq_disable ( struct e1000_adapter *adapter )
 107 {
 108         E1000_WRITE_REG ( &adapter->hw, IMC, ~0 );
 109         E1000_WRITE_FLUSH ( &adapter->hw );
 110 }
 111
 112 /**
 113  * e1000_irq_force - trigger interrupt
 114  *
 115  * @v adapter   e1000 private structure
 116  **/
 117 static void
 118 e1000_irq_force ( struct e1000_adapter *adapter )
 119 {
 120         E1000_WRITE_REG ( &adapter->hw, ICS, E1000_ICS_RXDMT0 );
 121         E1000_WRITE_FLUSH ( &adapter->hw );
 122 }
 123
 124 /**
 125  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
 126  *
 127  * @v adapter   e1000 private structure
 128  *
 129  * e1000_sw_init initializes the Adapter private data structure.
 130  * Fields are initialized based on PCI device information and
 131  * OS network device settings (MTU size).
 132  **/
 133 static int
 134 e1000_sw_init ( struct e1000_adapter *adapter )
 135 {
 136         struct e1000_hw *hw = &adapter->hw;
 137         struct pci_device *pdev = adapter->pdev;
 138
 139         /* PCI config space info */
 140
 141         hw->vendor_id = pdev->vendor;
 142         hw->device_id = pdev->device;
 143
 144         pci_read_config_word ( pdev, PCI_COMMAND, &hw->pci_cmd_word );
 145
 146         /* Disable Flow Control */
 147         hw->fc = E1000_FC_NONE;
 148
 149         adapter->eeprom_wol = 0;
 150         adapter->wol = adapter->eeprom_wol;
 151         adapter->en_mng_pt  = 0;
 152         adapter->rx_int_delay = 0;
 153         adapter->rx_abs_int_delay = 0;
 154
 155         adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
 156         adapter->rx_ps_bsize0 = E1000_RXBUFFER_128;
 157         hw->max_frame_size = MAXIMUM_ETHERNET_VLAN_SIZE +
 158                 ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
 159         hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
 160
 161         /* identify the MAC */
 162
 163         if ( e1000_set_mac_type ( hw ) ) {
 164                 DBG ( "Unknown MAC Type\n" );
 165                 return -EIO;
 166         }
 167
 168         switch ( hw->mac_type ) {
 169         default:
 170                 break;
 171         case e1000_82541:
 172         case e1000_82547:
 173         case e1000_82541_rev_2:
 174         case e1000_82547_rev_2:
 175                 hw->phy_init_script = 1;
 176                 break;
 177         }
 178
 179         e1000_set_media_type ( hw );
 180
 181         hw->autoneg = TRUE;
 182         hw->autoneg_advertised = AUTONEG_ADVERTISE_SPEED_DEFAULT;
 183         hw->wait_autoneg_complete = TRUE;
 184
 185         hw->tbi_compatibility_en = TRUE;
 186         hw->adaptive_ifs = TRUE;
 187
 188         /* Copper options */
 189
 190         if ( hw->media_type == e1000_media_type_copper ) {
 191                 hw->mdix = AUTO_ALL_MODES;
 192                 hw->disable_polarity_correction = FALSE;
 193                 hw->master_slave = E1000_MASTER_SLAVE;
 194         }
 195
 196         e1000_irq_disable ( adapter );
 197
 198         return 0;
 199 }
 200
 201 /**
 202  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
 203  *
 204  * @v adapter   e1000 private structure
 205  *
 206  * @ret rc       Returns 0 on success, negative on failure
 207  **/
 208 static int
 209 e1000_setup_tx_resources ( struct e1000_adapter *adapter )
 210 {
 211         DBG ( "e1000_setup_tx_resources\n" );
 212
 213         /* Allocate transmit descriptor ring memory.
 214            It must not cross a 64K boundary because of hardware errata #23
 215            so we use malloc_dma() requesting a 128 byte block that is
 216            128 byte aligned. This should guarantee that the memory
 217            allocated will not cross a 64K boundary, because 128 is an
 218            even multiple of 65536 ( 65536 / 128 == 512 ), so all possible
 219            allocations of 128 bytes on a 128 byte boundary will not
 220            cross 64K bytes.
 221          */
 222
 223         adapter->tx_base =
 224                 malloc_dma ( adapter->tx_ring_size, adapter->tx_ring_size );
 225
 226         if ( ! adapter->tx_base ) {
 227                 return -ENOMEM;
 228         }
 229
 230         memset ( adapter->tx_base, 0, adapter->tx_ring_size );
 231
 232         DBG ( "adapter->tx_base = %#08lx\n", virt_to_bus ( adapter->tx_base ) );
 233
 234         return 0;
 235 }
 236
 237 static void
 238 e1000_free_tx_resources ( struct e1000_adapter *adapter )
 239 {
 240         DBG ( "e1000_free_tx_resources\n" );
 241
 242         free_dma ( adapter->tx_base, adapter->tx_ring_size );
 243 }
 244
 245 /**
 246  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
 247  * @adapter: board private structure
 248  *
 249  * Configure the Tx unit of the MAC after a reset.
 250  **/
 251 static void
 252 e1000_configure_tx ( struct e1000_adapter *adapter )
 253 {
 254         struct e1000_hw *hw = &adapter->hw;
 255         uint32_t tctl;
 256
 257         DBG ( "e1000_configure_tx\n" );
 258
 259         E1000_WRITE_REG ( hw, TDBAH, 0 );
 260         E1000_WRITE_REG ( hw, TDBAL, virt_to_bus ( adapter->tx_base ) );
 261         E1000_WRITE_REG ( hw, TDLEN, adapter->tx_ring_size );
 262
 263         DBG ( "TDBAL: %#08x\n",  E1000_READ_REG ( hw, TDBAL ) );
 264         DBG ( "TDLEN: %d\n",     E1000_READ_REG ( hw, TDLEN ) );
 265
 266         /* Setup the HW Tx Head and Tail descriptor pointers */
 267         E1000_WRITE_REG ( hw, TDH, 0 );
 268         E1000_WRITE_REG ( hw, TDT, 0 );
 269
 270         adapter->tx_head = 0;
 271         adapter->tx_tail = 0;
 272         adapter->tx_fill_ctr = 0;
 273
 274         /* Setup Transmit Descriptor Settings for eop descriptor */
 275         tctl = E1000_TCTL_PSP | E1000_TCTL_EN |
 276                 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT) |
 277                 (E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
 278
 279         e1000_config_collision_dist ( hw );
 280
 281         E1000_WRITE_REG ( hw, TCTL, tctl );
 282         E1000_WRITE_FLUSH ( hw );
 283 }
 284
 285 /**
 286  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
 287  *
 288  * @v adapter   e1000 private structure
 289  *
 290  * @ret rc       Returns 0 on success, negative on failure
 291  **/
 292 static int
 293 e1000_setup_rx_resources ( struct e1000_adapter *adapter )
 294 {
 295         int i, j;
 296         struct e1000_rx_desc *rx_curr_desc;
 297
 298         DBG ( "e1000_setup_rx_resources\n" );
 299
 300         /* Allocate receive descriptor ring memory.
 301            It must not cross a 64K boundary because of hardware errata
 302          */
 303
 304         adapter->rx_base =
 305                 malloc_dma ( adapter->rx_ring_size, adapter->rx_ring_size );
 306
 307         if ( ! adapter->rx_base ) {
 308                 return -ENOMEM;
 309         }
 310         memset ( adapter->rx_base, 0, adapter->rx_ring_size );
 311
 312         for ( i = 0; i < NUM_RX_DESC; i++ ) {
 313
 314                 adapter->rx_iobuf[i] = alloc_iob ( MAXIMUM_ETHERNET_VLAN_SIZE );
 315
 316                 /* If unable to allocate all iobufs, free any that
 317                  * were successfully allocated, and return an error
 318                  */
 319                 if ( ! adapter->rx_iobuf[i] ) {
 320                         for ( j = 0; j < i; j++ ) {
 321                                 free_iob ( adapter->rx_iobuf[j] );
 322                         }
 323                         return -ENOMEM;
 324                 }
 325
 326                 rx_curr_desc = ( void * ) ( adapter->rx_base ) +
 327                                           ( i * sizeof ( *adapter->rx_base ) );
 328
 329                 rx_curr_desc->buffer_addr = virt_to_bus ( adapter->rx_iobuf[i]->data );
 330
 331                 DBG ( "i = %d  rx_curr_desc->buffer_addr = %#16llx\n",
 332                       i, rx_curr_desc->buffer_addr );
 333
 334         }
 335         return 0;
 336 }
 337
 338 static void
 339 e1000_free_rx_resources ( struct e1000_adapter *adapter )
 340 {
 341         int i;
 342
 343         DBG ( "e1000_free_rx_resources\n" );
 344
 345         free_dma ( adapter->rx_base, adapter->rx_ring_size );
 346
 347         for ( i = 0; i < NUM_RX_DESC; i++ ) {
 348                 free_iob ( adapter->rx_iobuf[i] );
 349         }
 350 }
 351
 352 /**
 353  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
 354  * @adapter: board private structure
 355  *
 356  * Configure the Rx unit of the MAC after a reset.
 357  **/
 358 static void
 359 e1000_configure_rx ( struct e1000_adapter *adapter )
 360 {
 361         struct e1000_hw *hw = &adapter->hw;
 362         uint32_t rctl;
 363
 364         DBG ( "e1000_configure_rx\n" );
 365
 366         /* disable receives while setting up the descriptors */
 367         rctl = E1000_READ_REG ( hw, RCTL );
 368         E1000_WRITE_REG ( hw, RCTL, rctl & ~E1000_RCTL_EN );
 369
 370         adapter->rx_curr = 0;
 371
 372         /* Setup the HW Rx Head and Tail Descriptor Pointers and
 373          * the Base and Length of the Rx Descriptor Ring */
 374
 375         E1000_WRITE_REG ( hw, RDBAL, virt_to_bus ( adapter->rx_base ) );
 376         E1000_WRITE_REG ( hw, RDBAH, 0 );
 377         E1000_WRITE_REG ( hw, RDLEN, adapter->rx_ring_size );
 378
 379         E1000_WRITE_REG ( hw, RDH, 0 );
 380         E1000_WRITE_REG ( hw, RDT, NUM_RX_DESC - 1 );
 381
 382         /* Enable Receives */
 383         rctl = ( E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
 384                  E1000_RCTL_MPE
 385                 );
 386
 387         E1000_WRITE_REG ( hw, RCTL, rctl );
 388         E1000_WRITE_FLUSH ( hw );
 389
 390         DBG ( "RDBAL: %#08x\n",  E1000_READ_REG ( hw, RDBAL ) );
 391         DBG ( "RDLEN: %d\n",     E1000_READ_REG ( hw, RDLEN ) );
 392         DBG ( "RCTL:  %#08x\n",  E1000_READ_REG ( hw, RCTL ) );
 393 }
 394
 395 /**
 396  * e1000_reset - Put e1000 NIC in known initial state
 397  *
 398  * @v adapter   e1000 private structure
 399  **/
 400 static void
 401 e1000_reset ( struct e1000_adapter *adapter )
 402 {
 403         uint32_t pba = 0;
 404         uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
 405
 406         DBG ( "e1000_reset\n" );
 407
 408         switch (adapter->hw.mac_type) {
 409         case e1000_82542_rev2_0:
 410         case e1000_82542_rev2_1:
 411         case e1000_82543:
 412         case e1000_82544:
 413         case e1000_82540:
 414         case e1000_82541:
 415         case e1000_82541_rev_2:
 416                 pba = E1000_PBA_48K;
 417                 break;
 418         case e1000_82545:
 419         case e1000_82545_rev_3:
 420         case e1000_82546:
 421         case e1000_82546_rev_3:
 422                 pba = E1000_PBA_48K;
 423                 break;
 424         case e1000_82547:
 425         case e1000_82547_rev_2:
 426                 pba = E1000_PBA_30K;
 427                 break;
 428         case e1000_82571:
 429         case e1000_82572:
 430         case e1000_80003es2lan:
 431                 pba = E1000_PBA_38K;
 432                 break;
 433         case e1000_82573:
 434                 pba = E1000_PBA_20K;
 435                 break;
 436         case e1000_ich8lan:
 437                 pba = E1000_PBA_8K;
 438         case e1000_undefined:
 439         case e1000_num_macs:
 440                 break;
 441         }
 442
 443         E1000_WRITE_REG ( &adapter->hw, PBA, pba );
 444
 445         /* flow control settings */
 446         /* Set the FC high water mark to 90% of the FIFO size.
 447          * Required to clear last 3 LSB */
 448         fc_high_water_mark = ((pba * 9216)/10) & 0xFFF8;
 449         /* We can't use 90% on small FIFOs because the remainder
 450          * would be less than 1 full frame.  In this case, we size
 451          * it to allow at least a full frame above the high water
 452          *  mark. */
 453         if (pba < E1000_PBA_16K)
 454                 fc_high_water_mark = (pba * 1024) - 1600;
 455
 456         adapter->hw.fc_high_water = fc_high_water_mark;
 457         adapter->hw.fc_low_water = fc_high_water_mark - 8;
 458         if (adapter->hw.mac_type == e1000_80003es2lan)
 459                 adapter->hw.fc_pause_time = 0xFFFF;
 460         else
 461                 adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
 462         adapter->hw.fc_send_xon = 1;
 463         adapter->hw.fc = adapter->hw.original_fc;
 464         /* Allow time for pending master requests to run */
 465
 466         e1000_reset_hw ( &adapter->hw );
 467
 468         if ( adapter->hw.mac_type >= e1000_82544 )
 469                 E1000_WRITE_REG ( &adapter->hw, WUC, 0 );
 470
 471         if ( e1000_init_hw ( &adapter->hw ) )
 472                 DBG ( "Hardware Error\n" );
 473
 474         /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
 475         if (adapter->hw.mac_type >= e1000_82544 &&
 476             adapter->hw.mac_type <= e1000_82547_rev_2 &&
 477             adapter->hw.autoneg == 1 &&
 478             adapter->hw.autoneg_advertised == ADVERTISE_1000_FULL) {
 479                 uint32_t ctrl = E1000_READ_REG(&adapter->hw, CTRL);
 480                 /* clear phy power management bit if we are in gig only mode,
 481                  * which if enabled will attempt negotiation to 100Mb, which
 482                  * can cause a loss of link at power off or driver unload */
 483                 ctrl &= ~E1000_CTRL_SWDPIN3;
 484                 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
 485         }
 486
 487         e1000_phy_get_info ( &adapter->hw, &adapter->phy_info );
 488
 489         if (!adapter->smart_power_down &&
 490             (adapter->hw.mac_type == e1000_82571 ||
 491              adapter->hw.mac_type == e1000_82572)) {
 492                 uint16_t phy_data = 0;
 493                 /* speed up time to link by disabling smart power down, ignore
 494                  * the return value of this function because there is nothing
 495                  * different we would do if it failed */
 496                 e1000_read_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
 497                                    &phy_data);
 498                 phy_data &= ~IGP02E1000_PM_SPD;
 499                 e1000_write_phy_reg(&adapter->hw, IGP02E1000_PHY_POWER_MGMT,
 500                                     phy_data);
 501         }
 502 }
 503
 504 /** Functions that implement the gPXE driver API **/
 505
 506 /**
 507  * e1000_close - Disables a network interface
 508  *
 509  * @v netdev    network interface device structure
 510  *
 511  **/
 512 static void
 513 e1000_close ( struct net_device *netdev )
 514 {
 515         struct e1000_adapter *adapter = netdev_priv ( netdev );
 516         struct e1000_hw *hw = &adapter->hw;
 517         uint32_t rctl;
 518         uint32_t icr;
 519
 520         DBG ( "e1000_close\n" );
 521
 522         /* Acknowledge interrupts */
 523         icr = E1000_READ_REG ( hw, ICR );
 524
 525         e1000_irq_disable ( adapter );
 526
 527         /* disable receives */
 528         rctl = E1000_READ_REG ( hw, RCTL );
 529         E1000_WRITE_REG ( hw, RCTL, rctl & ~E1000_RCTL_EN );
 530         E1000_WRITE_FLUSH ( hw );
 531
 532         e1000_reset_hw ( hw );
 533
 534         e1000_free_tx_resources ( adapter );
 535         e1000_free_rx_resources ( adapter );
 536 }
 537
 538 /**
 539  * e1000_transmit - Transmit a packet
 540  *
 541  * @v netdev    Network device
 542  * @v iobuf     I/O buffer
 543  *
 544  * @ret rc       Returns 0 on success, negative on failure
 545  */
 546 static int
 547 e1000_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
 548 {
 549         struct e1000_adapter *adapter = netdev_priv( netdev );
 550         struct e1000_hw *hw = &adapter->hw;
 551         uint32_t tx_curr = adapter->tx_tail;
 552         struct e1000_tx_desc *tx_curr_desc;
 553
 554         DBG ("e1000_transmit\n");
 555
 556         if ( adapter->tx_fill_ctr == NUM_TX_DESC ) {
 557                 DBG ("TX overflow\n");
 558                 return -ENOBUFS;
 559         }
 560
 561         /* Save pointer to iobuf we have been given to transmit,
 562            netdev_tx_complete() will need it later
 563          */
 564         adapter->tx_iobuf[tx_curr] = iobuf;
 565
 566         tx_curr_desc = ( void * ) ( adapter->tx_base ) +
 567                        ( tx_curr * sizeof ( *adapter->tx_base ) );
 568
 569         DBG ( "tx_curr_desc = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
 570         DBG ( "tx_curr_desc + 16 = %#08lx\n", virt_to_bus ( tx_curr_desc ) + 16 );
 571         DBG ( "iobuf->data = %#08lx\n", virt_to_bus ( iobuf->data ) );
 572
 573         /* Add the packet to TX ring
 574          */
 575         tx_curr_desc->buffer_addr =
 576                 virt_to_bus ( iobuf->data );
 577         tx_curr_desc->lower.data =
 578                 E1000_TXD_CMD_RPS  | E1000_TXD_CMD_EOP |
 579                 E1000_TXD_CMD_IFCS | iob_len ( iobuf );
 580         tx_curr_desc->upper.data = 0;
 581
 582         DBG ( "TX fill: %d tx_curr: %d addr: %#08lx len: %zd\n", adapter->tx_fill_ctr,
 583               tx_curr, virt_to_bus ( iobuf->data ), iob_len ( iobuf ) );
 584
 585         /* Point to next free descriptor */
 586         adapter->tx_tail = ( adapter->tx_tail + 1 ) % NUM_TX_DESC;
 587         adapter->tx_fill_ctr++;
 588
 589         /* Write new tail to NIC, making packet available for transmit
 590          */
 591         wmb();
 592         E1000_WRITE_REG ( hw, TDT, adapter->tx_tail );
 593
 594         return 0;
 595 }
 596
 597 /**
 598  * e1000_poll - Poll for received packets
 599  *
 600  * @v netdev    Network device
 601  */
 602 static void
 603 e1000_poll ( struct net_device *netdev )
 604 {
 605         struct e1000_adapter *adapter = netdev_priv( netdev );
 606         struct e1000_hw *hw = &adapter->hw;
 607
 608         uint32_t icr;
 609         uint32_t tx_status;
 610         uint32_t rx_status;
 611         uint32_t rx_len;
 612         uint32_t rx_err;
 613         struct io_buffer *rx_iob;
 614         struct e1000_tx_desc *tx_curr_desc;
 615         struct e1000_rx_desc *rx_curr_desc;
 616         uint32_t i;
 617         uint64_t tmp_buffer_addr;
 618
 619         DBGP ( "e1000_poll\n" );
 620
 621         /* Acknowledge interrupts */
 622         icr = E1000_READ_REG ( hw, ICR );
 623         if ( ! icr )
 624                 return;
 625
 626         DBG ( "e1000_poll: intr_status = %#08x\n", icr );
 627
 628         /* Check status of transmitted packets
 629          */
 630         while ( ( i = adapter->tx_head ) != adapter->tx_tail ) {
 631
 632                 tx_curr_desc = ( void * )  ( adapter->tx_base ) +
 633                                            ( i * sizeof ( *adapter->tx_base ) );
 634
 635                 tx_status = tx_curr_desc->upper.data;
 636
 637                 /* if the packet at tx_head is not owned by hardware it is for us */
 638                 if ( ! ( tx_status & E1000_TXD_STAT_DD ) )
 639                         break;
 640
 641                 DBG ( "Sent packet. tx_head: %d tx_tail: %d tx_status: %#08x\n",
 642                       adapter->tx_head, adapter->tx_tail, tx_status );
 643
 644                 if ( tx_status & ( E1000_TXD_STAT_EC | E1000_TXD_STAT_LC |
 645                                    E1000_TXD_STAT_TU ) ) {
 646                         netdev_tx_complete_err ( netdev, adapter->tx_iobuf[i], -EINVAL );
 647                         DBG ( "Error transmitting packet, tx_status: %#08x\n",
 648                               tx_status );
 649                 } else {
 650                         netdev_tx_complete ( netdev, adapter->tx_iobuf[i] );
 651                         DBG ( "Success transmitting packet, tx_status: %#08x\n",
 652                               tx_status );
 653                 }
 654
 655                 /* Decrement count of used descriptors, clear this descriptor
 656                  */
 657                 adapter->tx_fill_ctr--;
 658                 memset ( tx_curr_desc, 0, sizeof ( *tx_curr_desc ) );
 659
 660                 adapter->tx_head = ( adapter->tx_head + 1 ) % NUM_TX_DESC;
 661         }
 662
 663         /* Process received packets
 664          */
 665         while ( 1 ) {
 666
 667                 i = adapter->rx_curr;
 668
 669                 rx_curr_desc = ( void * )  ( adapter->rx_base ) +
 670                                   ( i * sizeof ( *adapter->rx_base ) );
 671                 rx_status = rx_curr_desc->status;
 672
 673                 DBG2 ( "Before DD Check RX_status: %#08x\n", rx_status );
 674
 675                 if ( ! ( rx_status & E1000_RXD_STAT_DD ) )
 676                         break;
 677
 678                 DBG ( "RCTL = %#08x\n", E1000_READ_REG ( &adapter->hw, RCTL ) );
 679
 680                 rx_len = rx_curr_desc->length;
 681
 682                 DBG ( "Received packet, rx_curr: %d  rx_status: %#08x  rx_len: %d\n",
 683                       i, rx_status, rx_len );
 684
 685                 rx_err = rx_curr_desc->errors;
 686
 687                 if ( rx_err & E1000_RXD_ERR_FRAME_ERR_MASK ) {
 688
 689                         netdev_rx_err ( netdev, NULL, -EINVAL );
 690                         DBG ( "e1000_poll: Corrupted packet received!"
 691                               " rx_err: %#08x\n", rx_err );
 692                 } else  {
 693
 694                         /* If unable allocate space for this packet,
 695                          *  try again next poll
 696                          */
 697                         rx_iob = alloc_iob ( rx_len );
 698                         if ( ! rx_iob )
 699                                 break;
 700
 701                         memcpy ( iob_put ( rx_iob, rx_len ),
 702                                 adapter->rx_iobuf[i]->data, rx_len );
 703
 704                         /* Add this packet to the receive queue.
 705                          */
 706                         netdev_rx ( netdev, rx_iob );
 707                 }
 708
 709                 tmp_buffer_addr = rx_curr_desc->buffer_addr;
 710                 memset ( rx_curr_desc, 0, sizeof ( *rx_curr_desc ) );
 711                 rx_curr_desc->buffer_addr = tmp_buffer_addr;
 712
 713                 E1000_WRITE_REG ( hw, RDT, adapter->rx_curr );
 714
 715                 adapter->rx_curr = ( adapter->rx_curr + 1 ) % NUM_RX_DESC;
 716         }
 717 }
 718
 719 /**
 720  * e1000_irq - enable or Disable interrupts
 721  *
 722  * @v adapter   e1000 adapter
 723  * @v action    requested interrupt action
 724  **/
 725 static void
 726 e1000_irq ( struct net_device *netdev, int enable )
 727 {
 728         struct e1000_adapter *adapter = netdev_priv(netdev);
 729
 730         DBG ( "e1000_irq\n" );
 731
 732         switch ( enable ) {
 733         case 0 :
 734                 e1000_irq_disable ( adapter );
 735                 break;
 736         case 1 :
 737                 e1000_irq_enable ( adapter );
 738                 break;
 739         case 2 :
 740                 e1000_irq_force ( adapter );
 741                 break;
 742         }
 743 }
 744
 745 static struct net_device_operations e1000_operations;
 746
 747 /**
 748  * e1000_probe - Initial configuration of e1000 NIC
 749  *
 750  * @v pci       PCI device
 751  * @v id        PCI IDs
 752  *
 753  * @ret rc      Return status code
 754  **/
 755 static int
 756 e1000_probe ( struct pci_device *pdev,
 757               const struct pci_device_id *id __unused )
 758 {
 759         int i, err;
 760         struct net_device *netdev;
 761         struct e1000_adapter *adapter;
 762         unsigned long mmio_start, mmio_len;
 763         unsigned long flash_start, flash_len;
 764
 765         DBG ( "e1000_probe\n" );
 766
 767         err = -ENOMEM;
 768
 769         /* Allocate net device ( also allocates memory for netdev->priv
 770            and makes netdev-priv point to it ) */
 771         netdev = alloc_etherdev ( sizeof ( struct e1000_adapter ) );
 772         if ( ! netdev )
 773                 goto err_alloc_etherdev;
 774
 775         /* Associate e1000-specific network operations operations with
 776          * generic network device layer */
 777         netdev_init ( netdev, &e1000_operations );
 778
 779         /* Associate this network device with given PCI device */
 780         pci_set_drvdata ( pdev, netdev );
 781         netdev->dev = &pdev->dev;
 782
 783         /* Initialize driver private storage */
 784         adapter = netdev_priv ( netdev );
 785         memset ( adapter, 0, ( sizeof ( *adapter ) ) );
 786
 787         adapter->hw.io_base = pdev->ioaddr;
 788         adapter->ioaddr     = pdev->ioaddr;
 789         adapter->irqno      = pdev->irq;
 790         adapter->netdev     = netdev;
 791         adapter->pdev       = pdev;
 792         adapter->hw.back    = adapter;
 793
 794         adapter->tx_ring_size = sizeof ( *adapter->tx_base ) * NUM_TX_DESC;
 795         adapter->rx_ring_size = sizeof ( *adapter->rx_base ) * NUM_RX_DESC;
 796
 797         mmio_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_0 );
 798         mmio_len   = pci_bar_size  ( pdev, PCI_BASE_ADDRESS_0 );
 799
 800         DBG ( "mmio_start: %#08lx\n", mmio_start );
 801         DBG ( "mmio_len: %#08lx\n", mmio_len );
 802
 803         /* Fix up PCI device */
 804         adjust_pci_device ( pdev );
 805
 806         err = -EIO;
 807
 808         adapter->hw.hw_addr = ioremap ( mmio_start, mmio_len );
 809         DBG ( "adapter->hw.hw_addr: %p\n", adapter->hw.hw_addr );
 810
 811         if ( ! adapter->hw.hw_addr )
 812                 goto err_ioremap;
 813
 814         /* setup the private structure */
 815         if ( ( err = e1000_sw_init ( adapter ) ) )
 816                 goto err_sw_init;
 817
 818         DBG ( "adapter->hw.mac_type: %#08x\n", adapter->hw.mac_type );
 819
 820         /* Flash BAR mapping must happen after e1000_sw_init
 821          * because it depends on mac_type
 822          */
 823         if ( ( adapter->hw.mac_type == e1000_ich8lan ) && ( pdev->ioaddr ) ) {
 824                 flash_start = pci_bar_start ( pdev, PCI_BASE_ADDRESS_1 );
 825                 flash_len = pci_bar_size ( pdev, PCI_BASE_ADDRESS_1 );
 826                 adapter->hw.flash_address = ioremap ( flash_start, flash_len );
 827                 if ( ! adapter->hw.flash_address )
 828                         goto err_flashmap;
 829         }
 830
 831         /* initialize eeprom parameters */
 832         if ( e1000_init_eeprom_params ( &adapter->hw ) ) {
 833                 DBG ( "EEPROM initialization failed\n" );
 834                 goto err_eeprom;
 835         }
 836
 837         /* before reading the EEPROM, reset the controller to
 838          * put the device in a known good starting state
 839          */
 840         err = e1000_reset_hw ( &adapter->hw );
 841         if ( err < 0 ) {
 842                 DBG ( "Hardware Initialization Failed\n" );
 843                 goto err_reset;
 844         }
 845
 846         /* make sure the EEPROM is good */
 847         if ( e1000_validate_eeprom_checksum( &adapter->hw ) < 0 ) {
 848                 DBG ( "The EEPROM Checksum Is Not Valid\n" );
 849                 goto err_eeprom;
 850         }
 851
 852         /* copy the MAC address out of the EEPROM */
 853         if ( e1000_read_mac_addr ( &adapter->hw ) )
 854                 DBG ( "EEPROM Read Error\n" );
 855
 856         memcpy ( netdev->hw_addr, adapter->hw.mac_addr, ETH_ALEN );
 857
 858         /* print bus type/speed/width info */
 859         {
 860         struct e1000_hw *hw = &adapter->hw;
 861         DBG ( "(PCI%s:%s:%s) ",
 862               ((hw->bus_type == e1000_bus_type_pcix) ? "-X" :
 863                (hw->bus_type == e1000_bus_type_pci_express ? " Express":"")),
 864               ((hw->bus_speed == e1000_bus_speed_2500) ? "2.5Gb/s" :
 865                (hw->bus_speed == e1000_bus_speed_133) ? "133MHz" :
 866                (hw->bus_speed == e1000_bus_speed_120) ? "120MHz" :
 867                (hw->bus_speed == e1000_bus_speed_100) ? "100MHz" :
 868                (hw->bus_speed == e1000_bus_speed_66) ? "66MHz" : "33MHz"),
 869               ((hw->bus_width == e1000_bus_width_64) ? "64-bit" :
 870                (hw->bus_width == e1000_bus_width_pciex_4) ? "Width x4" :
 871                (hw->bus_width == e1000_bus_width_pciex_1) ? "Width x1" :
 872                "32-bit"));
 873         }
 874         for (i = 0; i < 6; i++)
 875                 DBG ("%02x%s", netdev->ll_addr[i], i == 5 ? "\n" : ":");
 876
 877         /* reset the hardware with the new settings */
 878         e1000_reset ( adapter );
 879
 880         e1000_get_hw_control ( adapter );
 881
 882         /* Mark as link up; we don't yet handle link state */
 883         netdev_link_up ( netdev );
 884
 885         if ( ( err = register_netdev ( netdev ) ) != 0)
 886                 goto err_register;
 887
 888         DBG ( "e1000_probe succeeded!\n" );
 889
 890         /* No errors, return success */
 891         return 0;
 892
 893 /* Error return paths */
 894 err_reset:
 895 err_register:
 896 err_eeprom:
 897         if ( ! e1000_check_phy_reset_block ( &adapter->hw ) )
 898                 e1000_phy_hw_reset ( &adapter->hw );
 899         if ( adapter->hw.flash_address )
 900                 iounmap ( adapter->hw.flash_address );
 901 err_flashmap:
 902 err_sw_init:
 903         iounmap ( adapter->hw.hw_addr );
 904 err_ioremap:
 905         netdev_put ( netdev );
 906 err_alloc_etherdev:
 907         return err;
 908 }
 909
 910 /**
 911  * e1000_remove - Device Removal Routine
 912  *
 913  * @v pdev PCI device information struct
 914  *
 915  **/
 916 static void
 917 e1000_remove ( struct pci_device *pdev )
 918 {
 919         struct net_device *netdev = pci_get_drvdata ( pdev );
 920         struct e1000_adapter *adapter = netdev_priv ( netdev );
 921
 922         DBG ( "e1000_remove\n" );
 923
 924         if ( adapter->hw.flash_address )
 925                 iounmap ( adapter->hw.flash_address );
 926         if  ( adapter->hw.hw_addr )
 927                 iounmap ( adapter->hw.hw_addr );
 928
 929         unregister_netdev ( netdev );
 930         e1000_reset_hw ( &adapter->hw );
 931         netdev_nullify ( netdev );
 932         netdev_put ( netdev );
 933 }
 934
 935 /**
 936  * e1000_open - Called when a network interface is made active
 937  *
 938  * @v netdev    network interface device structure
 939  * @ret rc      Return status code, 0 on success, negative value on failure
 940  *
 941  **/
 942 static int
 943 e1000_open ( struct net_device *netdev )
 944 {
 945         struct e1000_adapter *adapter = netdev_priv(netdev);
 946         int err;
 947
 948         DBG ( "e1000_open\n" );
 949
 950         /* allocate transmit descriptors */
 951         err = e1000_setup_tx_resources ( adapter );
 952         if ( err ) {
 953                 DBG ( "Error setting up TX resources!\n" );
 954                 goto err_setup_tx;
 955         }
 956
 957         /* allocate receive descriptors */
 958         err = e1000_setup_rx_resources ( adapter );
 959         if ( err ) {
 960                 DBG ( "Error setting up RX resources!\n" );
 961                 goto err_setup_rx;
 962         }
 963
 964         e1000_configure_tx ( adapter );
 965
 966         e1000_configure_rx ( adapter );
 967
 968         DBG ( "RXDCTL: %#08x\n",  E1000_READ_REG ( &adapter->hw, RXDCTL ) );
 969
 970         return 0;
 971
 972 err_setup_rx:
 973         e1000_free_tx_resources ( adapter );
 974 err_setup_tx:
 975         e1000_reset ( adapter );
 976
 977         return err;
 978 }
 979
 980 /** e1000 net device operations */
 981 static struct net_device_operations e1000_operations = {
 982         .open           = e1000_open,
 983         .close          = e1000_close,
 984         .transmit       = e1000_transmit,
 985         .poll           = e1000_poll,
 986         .irq            = e1000_irq,
 987 };
 988
 989 int32_t
 990 e1000_read_pcie_cap_reg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
 991 {
 992     struct e1000_adapter *adapter = hw->back;
 993     uint16_t cap_offset;
 994
 995 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
 996     cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
 997     if (!cap_offset)
 998         return -E1000_ERR_CONFIG;
 999
1000     pci_read_config_word(adapter->pdev, cap_offset + reg, value);
1001
1002     return 0;
1003 }
1004
1005 void
1006 e1000_pci_clear_mwi ( struct e1000_hw *hw )
1007 {
1008         struct e1000_adapter *adapter = hw->back;
1009
1010         pci_write_config_word ( adapter->pdev, PCI_COMMAND,
1011                                 hw->pci_cmd_word & ~PCI_COMMAND_INVALIDATE );
1012 }
1013
1014 void
1015 e1000_pci_set_mwi ( struct e1000_hw *hw )
1016 {
1017         struct e1000_adapter *adapter = hw->back;
1018
1019         pci_write_config_word ( adapter->pdev, PCI_COMMAND, hw->pci_cmd_word );
1020 }
1021
1022 void
1023 e1000_read_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1024 {
1025         struct e1000_adapter *adapter = hw->back;
1026
1027         pci_read_config_word ( adapter->pdev, reg, value );
1028 }
1029
1030 void
1031 e1000_write_pci_cfg ( struct e1000_hw *hw, uint32_t reg, uint16_t *value )
1032 {
1033         struct e1000_adapter *adapter = hw->back;
1034
1035         pci_write_config_word ( adapter->pdev, reg, *value );
1036 }
1037
1038 void
1039 e1000_io_write ( struct e1000_hw *hw  __unused, unsigned long port, uint32_t value )
1040 {
1041         outl ( value, port );
1042 }
1043
1044 static struct pci_device_id e1000_nics[] = {
1045         PCI_ROM(0x8086, 0x1000, "e1000-0x1000", "e1000-0x1000", 0),
1046         PCI_ROM(0x8086, 0x1001, "e1000-0x1001", "e1000-0x1001", 0),
1047         PCI_ROM(0x8086, 0x1004, "e1000-0x1004", "e1000-0x1004", 0),
1048         PCI_ROM(0x8086, 0x1008, "e1000-0x1008", "e1000-0x1008", 0),
1049         PCI_ROM(0x8086, 0x1009, "e1000-0x1009", "e1000-0x1009", 0),
1050         PCI_ROM(0x8086, 0x100c, "e1000-0x100c", "e1000-0x100c", 0),
1051         PCI_ROM(0x8086, 0x100d, "e1000-0x100d", "e1000-0x100d", 0),
1052         PCI_ROM(0x8086, 0x100e, "e1000-0x100e", "e1000-0x100e", 0),
1053         PCI_ROM(0x8086, 0x100f, "e1000-0x100f", "e1000-0x100f", 0),
1054         PCI_ROM(0x8086, 0x1010, "e1000-0x1010", "e1000-0x1010", 0),
1055         PCI_ROM(0x8086, 0x1011, "e1000-0x1011", "e1000-0x1011", 0),
1056         PCI_ROM(0x8086, 0x1012, "e1000-0x1012", "e1000-0x1012", 0),
1057         PCI_ROM(0x8086, 0x1013, "e1000-0x1013", "e1000-0x1013", 0),
1058         PCI_ROM(0x8086, 0x1014, "e1000-0x1014", "e1000-0x1014", 0),
1059         PCI_ROM(0x8086, 0x1015, "e1000-0x1015", "e1000-0x1015", 0),
1060         PCI_ROM(0x8086, 0x1016, "e1000-0x1016", "e1000-0x1016", 0),
1061         PCI_ROM(0x8086, 0x1017, "e1000-0x1017", "e1000-0x1017", 0),
1062         PCI_ROM(0x8086, 0x1018, "e1000-0x1018", "e1000-0x1018", 0),
1063         PCI_ROM(0x8086, 0x1019, "e1000-0x1019", "e1000-0x1019", 0),
1064         PCI_ROM(0x8086, 0x101a, "e1000-0x101a", "e1000-0x101a", 0),
1065         PCI_ROM(0x8086, 0x101d, "e1000-0x101d", "e1000-0x101d", 0),
1066         PCI_ROM(0x8086, 0x101e, "e1000-0x101e", "e1000-0x101e", 0),
1067         PCI_ROM(0x8086, 0x1026, "e1000-0x1026", "e1000-0x1026", 0),
1068         PCI_ROM(0x8086, 0x1027, "e1000-0x1027", "e1000-0x1027", 0),
1069         PCI_ROM(0x8086, 0x1028, "e1000-0x1028", "e1000-0x1028", 0),
1070         PCI_ROM(0x8086, 0x1049, "e1000-0x1049", "e1000-0x1049", 0),
1071         PCI_ROM(0x8086, 0x104a, "e1000-0x104a", "e1000-0x104a", 0),
1072         PCI_ROM(0x8086, 0x104b, "e1000-0x104b", "e1000-0x104b", 0),
1073         PCI_ROM(0x8086, 0x104c, "e1000-0x104c", "e1000-0x104c", 0),
1074         PCI_ROM(0x8086, 0x104d, "e1000-0x104d", "e1000-0x104d", 0),
1075         PCI_ROM(0x8086, 0x105e, "e1000-0x105e", "e1000-0x105e", 0),
1076         PCI_ROM(0x8086, 0x105f, "e1000-0x105f", "e1000-0x105f", 0),
1077         PCI_ROM(0x8086, 0x1060, "e1000-0x1060", "e1000-0x1060", 0),
1078         PCI_ROM(0x8086, 0x1075, "e1000-0x1075", "e1000-0x1075", 0),
1079         PCI_ROM(0x8086, 0x1076, "e1000-0x1076", "e1000-0x1076", 0),
1080         PCI_ROM(0x8086, 0x1077, "e1000-0x1077", "e1000-0x1077", 0),
1081         PCI_ROM(0x8086, 0x1078, "e1000-0x1078", "e1000-0x1078", 0),
1082         PCI_ROM(0x8086, 0x1079, "e1000-0x1079", "e1000-0x1079", 0),
1083         PCI_ROM(0x8086, 0x107a, "e1000-0x107a", "e1000-0x107a", 0),
1084         PCI_ROM(0x8086, 0x107b, "e1000-0x107b", "e1000-0x107b", 0),
1085         PCI_ROM(0x8086, 0x107c, "e1000-0x107c", "e1000-0x107c", 0),
1086         PCI_ROM(0x8086, 0x107d, "e1000-0x107d", "e1000-0x107d", 0),
1087         PCI_ROM(0x8086, 0x107e, "e1000-0x107e", "e1000-0x107e", 0),
1088         PCI_ROM(0x8086, 0x107f, "e1000-0x107f", "e1000-0x107f", 0),
1089         PCI_ROM(0x8086, 0x108a, "e1000-0x108a", "e1000-0x108a", 0),
1090         PCI_ROM(0x8086, 0x108b, "e1000-0x108b", "e1000-0x108b", 0),
1091         PCI_ROM(0x8086, 0x108c, "e1000-0x108c", "e1000-0x108c", 0),
1092         PCI_ROM(0x8086, 0x1096, "e1000-0x1096", "e1000-0x1096", 0),
1093         PCI_ROM(0x8086, 0x1098, "e1000-0x1098", "e1000-0x1098", 0),
1094         PCI_ROM(0x8086, 0x1099, "e1000-0x1099", "e1000-0x1099", 0),
1095         PCI_ROM(0x8086, 0x109a, "e1000-0x109a", "e1000-0x109a", 0),
1096         PCI_ROM(0x8086, 0x10a4, "e1000-0x10a4", "e1000-0x10a4", 0),
1097         PCI_ROM(0x8086, 0x10a5, "e1000-0x10a5", "e1000-0x10a5", 0),
1098         PCI_ROM(0x8086, 0x10b5, "e1000-0x10b5", "e1000-0x10b5", 0),
1099         PCI_ROM(0x8086, 0x10b9, "e1000-0x10b9", "e1000-0x10b9", 0),
1100         PCI_ROM(0x8086, 0x10ba, "e1000-0x10ba", "e1000-0x10ba", 0),
1101         PCI_ROM(0x8086, 0x10bb, "e1000-0x10bb", "e1000-0x10bb", 0),
1102         PCI_ROM(0x8086, 0x10bc, "e1000-0x10bc", "e1000-0x10bc", 0),
1103         PCI_ROM(0x8086, 0x10c4, "e1000-0x10c4", "e1000-0x10c4", 0),
1104         PCI_ROM(0x8086, 0x10c5, "e1000-0x10c5", "e1000-0x10c5", 0),
1105         PCI_ROM(0x8086, 0x10d9, "e1000-0x10d9", "e1000-0x10d9", 0),
1106         PCI_ROM(0x8086, 0x10da, "e1000-0x10da", "e1000-0x10da", 0),
1107 };
1108
1109 struct pci_driver e1000_driver __pci_driver = {
1110         .ids = e1000_nics,
1111         .id_count = (sizeof (e1000_nics) / sizeof (e1000_nics[0])),
1112         .probe = e1000_probe,
1113         .remove = e1000_remove,
1114 };
1115
1116 /*
1117  * Local variables:
1118  *  c-basic-offset: 8
1119  *  c-indent-level: 8
1120  *  tab-width: 8
1121  * End:
1122  */