qemu/roms/ipxe/src/drivers/net/pcnet32.c

   1 /*
   2  * Copyright (c) 2010 Andrei Faur <da3drus@gmail.com>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  */
  20
  21 FILE_LICENCE ( GPL2_OR_LATER );
  22
  23 #include <stdint.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <assert.h>
  29 #include <byteswap.h>
  30 #include <errno.h>
  31 #include <ipxe/ethernet.h>
  32 #include <ipxe/if_ether.h>
  33 #include <ipxe/io.h>
  34 #include <ipxe/iobuf.h>
  35 #include <ipxe/malloc.h>
  36 #include <ipxe/netdevice.h>
  37 #include <ipxe/pci.h>
  38 #include <ipxe/timer.h>
  39 #include <mii.h>
  40 #include "pcnet32.h"
  41
  42 static u16 pcnet32_wio_read_csr ( unsigned long addr, int index )
  43 {
  44         outw ( index, addr + PCNET32_WIO_RAP );
  45         return inw ( addr + PCNET32_WIO_RDP );
  46 }
  47
  48 static void pcnet32_wio_write_csr ( unsigned long addr, int index, u16 val )
  49 {
  50         outw ( index, addr + PCNET32_WIO_RAP );
  51         outw ( val, addr + PCNET32_WIO_RDP );
  52 }
  53
  54 static u16 pcnet32_wio_read_bcr ( unsigned long addr, int index )
  55 {
  56         outw ( index, addr + PCNET32_WIO_RAP );
  57         return inw ( addr + PCNET32_WIO_BDP );
  58 }
  59
  60 static void pcnet32_wio_write_bcr ( unsigned long addr, int index, u16 val )
  61 {
  62         outw ( index, addr + PCNET32_WIO_RAP );
  63         outw ( val, addr + PCNET32_WIO_BDP );
  64 }
  65
  66 static u16 pcnet32_wio_read_rap ( unsigned long addr )
  67 {
  68         return inw ( addr + PCNET32_WIO_RAP );
  69 }
  70
  71 static void pcnet32_wio_write_rap ( unsigned long addr , u16 val )
  72 {
  73         outw ( val, addr + PCNET32_WIO_RAP );
  74 }
  75
  76 static void pcnet32_wio_reset ( unsigned long addr )
  77 {
  78         inw ( addr + PCNET32_WIO_RESET );
  79 }
  80
  81 static int pcnet32_wio_check ( unsigned long addr )
  82 {
  83         outw ( 88, addr + PCNET32_WIO_RAP );
  84         return ( inw ( addr + PCNET32_WIO_RAP ) == 88 );
  85 }
  86
  87 static struct pcnet32_access pcnet32_wio = {
  88         .read_csr       = pcnet32_wio_read_csr,
  89         .write_csr      = pcnet32_wio_write_csr,
  90         .read_bcr       = pcnet32_wio_read_bcr,
  91         .write_bcr      = pcnet32_wio_write_bcr,
  92         .read_rap       = pcnet32_wio_read_rap,
  93         .write_rap      = pcnet32_wio_write_rap,
  94         .reset          = pcnet32_wio_reset,
  95 };
  96
  97 static u16 pcnet32_dwio_read_csr ( unsigned long addr, int index )
  98 {
  99         outl ( index, addr + PCNET32_DWIO_RAP );
 100         return ( inl ( addr + PCNET32_DWIO_RDP ) & 0xffff );
 101 }
 102
 103 static void pcnet32_dwio_write_csr ( unsigned long addr, int index, u16 val )
 104 {
 105         outl ( index, addr + PCNET32_DWIO_RAP );
 106         outl ( val, addr + PCNET32_DWIO_RDP );
 107 }
 108
 109 static u16 pcnet32_dwio_read_bcr ( unsigned long addr, int index )
 110 {
 111         outl ( index, addr + PCNET32_DWIO_RAP );
 112         return ( inl ( addr + PCNET32_DWIO_BDP ) & 0xffff );
 113 }
 114
 115 static void pcnet32_dwio_write_bcr ( unsigned long addr, int index, u16 val )
 116 {
 117         outl ( index, addr + PCNET32_DWIO_RAP );
 118         outl ( val, addr + PCNET32_DWIO_BDP );
 119 }
 120
 121 static u16 pcnet32_dwio_read_rap ( unsigned long addr )
 122 {
 123         return ( inl ( addr + PCNET32_DWIO_RAP ) & 0xffff );
 124 }
 125
 126 static void pcnet32_dwio_write_rap ( unsigned long addr , u16 val )
 127 {
 128         outl ( val, addr + PCNET32_DWIO_RAP );
 129 }
 130
 131 static void pcnet32_dwio_reset ( unsigned long addr )
 132 {
 133         inl ( addr + PCNET32_DWIO_RESET );
 134 }
 135
 136 static int pcnet32_dwio_check ( unsigned long addr )
 137 {
 138         outl ( 88, addr + PCNET32_DWIO_RAP );
 139         return ( ( inl ( addr + PCNET32_DWIO_RAP ) & 0xffff ) == 88 );
 140 }
 141
 142
 143 static struct pcnet32_access pcnet32_dwio = {
 144         .read_csr       = pcnet32_dwio_read_csr,
 145         .write_csr      = pcnet32_dwio_write_csr,
 146         .read_bcr       = pcnet32_dwio_read_bcr,
 147         .write_bcr      = pcnet32_dwio_write_bcr,
 148         .read_rap       = pcnet32_dwio_read_rap,
 149         .write_rap      = pcnet32_dwio_write_rap,
 150         .reset          = pcnet32_dwio_reset,
 151 };
 152
 153 static int
 154 pcnet32_mdio_read ( struct net_device *netdev, int phy, int reg )
 155 {
 156         struct pcnet32_private *priv = netdev->priv;
 157         unsigned long ioaddr = priv->pci_dev->ioaddr;
 158         u16 val_out;
 159
 160         if ( ! priv->mii )
 161                 return 0;
 162
 163         /* First, select PHY chip and the register we want to read */
 164         priv->a->write_bcr ( ioaddr, 33,
 165                 ( ( phy & 0x1f ) << 5 ) | ( reg & 0x1f ) );
 166
 167         /* Read the selected register's value */
 168         val_out = priv->a->read_bcr ( ioaddr, 34 );
 169
 170         return val_out;
 171 }
 172
 173 static void
 174 __unused pcnet32_mdio_write ( struct net_device *netdev, int phy, int reg, int val )
 175 {
 176         struct pcnet32_private *priv = netdev->priv;
 177         unsigned long ioaddr = priv->pci_dev->ioaddr;
 178
 179         if ( ! priv->mii )
 180                 return;
 181
 182         /* First, select PHY chip and the register we want to write to */
 183         priv->a->write_bcr ( ioaddr, 33,
 184                 ( ( phy & 0x1f ) << 5 ) | ( reg & 0x1f ) );
 185
 186         /* Write val to the selected register */
 187         priv->a->write_bcr ( ioaddr, 34, val );
 188 }
 189
 190
 191 /**
 192  * pcnet32_refill_rx_ring - Allocates iobufs for every Rx descriptor
 193  * that doesn't have one and isn't in use by the hardware
 194  *
 195  * @v priv      Driver private structure
 196  */
 197 static void
 198 pcnet32_refill_rx_ring ( struct pcnet32_private *priv )
 199 {
 200         struct pcnet32_rx_desc *rx_curr_desc;
 201         u16 status;
 202         int i;
 203
 204         DBGP ( "pcnet32_refill_rx_ring\n" );
 205
 206         for ( i = 0; i < RX_RING_SIZE; i++ ) {
 207                 rx_curr_desc = priv->rx_base + i;
 208
 209                 status = le16_to_cpu ( rx_curr_desc->status );
 210
 211                 /* Don't touch descriptors owned by the hardware */
 212                 if ( status & DescOwn )
 213                         continue;
 214
 215                 /* Descriptors with iobufs still need to be processed */
 216                 if ( priv->rx_iobuf[i] != NULL )
 217                         continue;
 218
 219                 /* If alloc_iob fails, try again later (next poll) */
 220                 if ( ! ( priv->rx_iobuf[i] = alloc_iob ( PKT_BUF_SIZE ) ) ) {
 221                         DBG ( "Refill rx ring failed\n" );
 222                         break;
 223                 }
 224
 225                 rx_curr_desc->base =
 226                         cpu_to_le32 ( virt_to_bus ( priv->rx_iobuf[i]->data ) );
 227                 rx_curr_desc->buf_length = cpu_to_le16 ( -PKT_BUF_SIZE );
 228                 rx_curr_desc->msg_length = rx_curr_desc->reserved = 0;
 229
 230                 /* Owner changes after the other status fields are set */
 231                 wmb();
 232                 rx_curr_desc->status = cpu_to_le16 ( DescOwn );
 233         }
 234
 235 }
 236
 237 /**
 238  * pcnet32_setup_rx_resources - allocate Rx resources (Descriptors)
 239  *
 240  * @v priv      Driver private structure
 241  *
 242  * @ret rc      Returns 0 on success, negative on failure
 243  */
 244 static int
 245 pcnet32_setup_rx_resources ( struct pcnet32_private *priv )
 246 {
 247         DBGP ( "pcnet32_setup_rx_resources\n" );
 248
 249         priv->rx_base = malloc_dma ( RX_RING_BYTES, RX_RING_ALIGN );
 250
 251         DBG ( "priv->rx_base = %#08lx\n", virt_to_bus ( priv->rx_base ) );
 252
 253         if ( ! priv->rx_base ) {
 254                 return -ENOMEM;
 255         }
 256
 257         memset ( priv->rx_base, 0, RX_RING_BYTES );
 258
 259         pcnet32_refill_rx_ring ( priv );
 260
 261         priv->rx_curr = 0;
 262
 263         return 0;
 264 }
 265
 266 static void
 267 pcnet32_free_rx_resources ( struct pcnet32_private *priv )
 268 {
 269         int i;
 270
 271         DBGP ( "pcnet32_free_rx_resources\n" );
 272
 273         free_dma ( priv->rx_base, RX_RING_BYTES );
 274
 275         for ( i = 0; i < RX_RING_SIZE; i++ ) {
 276                 free_iob ( priv->rx_iobuf[i] );
 277                 priv->rx_iobuf[i] = NULL;
 278         }
 279 }
 280
 281 /**
 282  * pcnet32_setup_tx_resources - allocate Tx resources (Descriptors)
 283  *
 284  * @v priv      Driver private structure
 285  *
 286  * @ret rc      Returns 0 on success, negative on failure
 287  */
 288 static int
 289 pcnet32_setup_tx_resources ( struct pcnet32_private *priv )
 290 {
 291         DBGP ( "pcnet32_setup_tx_resources\n" );
 292
 293         priv->tx_base = malloc_dma ( TX_RING_BYTES, TX_RING_ALIGN );
 294
 295         if ( ! priv->tx_base ) {
 296                 return -ENOMEM;
 297         }
 298
 299         memset ( priv->tx_base, 0, TX_RING_BYTES );
 300
 301         DBG ( "priv->tx_base = %#08lx\n", virt_to_bus ( priv->tx_base ) );
 302
 303         priv->tx_curr = 0;
 304         priv->tx_fill_ctr = 0;
 305         priv->tx_tail = 0;
 306
 307         return 0;
 308 }
 309
 310 static void
 311 pcnet32_free_tx_resources ( struct pcnet32_private *priv )
 312 {
 313         DBGP ( "pcnet32_free_tx_resources\n" );
 314
 315         free_dma ( priv->tx_base, TX_RING_BYTES );
 316 }
 317
 318 static int
 319 pcnet32_chip_detect ( struct pcnet32_private *priv )
 320 {
 321         int fdx, mii, fset;
 322         int media;
 323         int rc;
 324         unsigned long ioaddr;
 325         struct pcnet32_access *a;
 326         int chip_version;
 327         char *chipname;
 328
 329         ioaddr = priv->pci_dev->ioaddr;
 330         a = priv->a;
 331
 332         chip_version = a->read_csr ( ioaddr, 88 )
 333                 | ( a->read_csr ( ioaddr, 89 ) << 16 );
 334
 335         rc = -ENODEV;
 336
 337         DBG ( "PCnet chip version is 0x%X\n", chip_version );
 338         if ( ( chip_version & 0xfff ) != 0x003 )
 339                 goto err_unsupported;
 340
 341         fdx = mii = fset = 0;
 342         chip_version = ( chip_version >> 12 ) & 0xffff;
 343
 344         switch (chip_version) {
 345         case 0x2420:
 346                 chipname = "PCnet/PCI 79C970";
 347                 break;
 348         case 0x2430:
 349                 /* 970 gives the wrong chip id back */
 350                 chipname = "PCnet/PCI 79C970";
 351                 break;
 352         case 0x2621:
 353                 chipname = "PCnet/PCI II 79C970A";
 354                 fdx = 1;
 355                 break;
 356         case 0x2623:
 357                 chipname = "PCnet/FAST 79C971";
 358                 fdx = 1;
 359                 mii = 1;
 360                 fset = 1;
 361                 break;
 362         case 0x2624:
 363                 chipname = "PCnet/FAST+ 79C972";
 364                 fdx = 1;
 365                 mii = 1;
 366                 fset = 1;
 367                 break;
 368         case 0x2625:
 369                 chipname = "PCnet/FAST III 79C973";
 370                 fdx = 1;
 371                 mii = 1;
 372                 break;
 373         case 0x2626:
 374                 chipname = "PCnet/Home 79C978";
 375                 fdx = 1;
 376                 /*
 377                  * This is based on specs published at www.amd.com. This section
 378                  * assumes that a NIC with a 79C978 wants to go into 1Mb HomePNA
 379                  * mode. The 79C978 can also go into standard ethernet, and
 380                  * there probably should be some sort of module option to select
 381                  * the mode by which the card should operate
 382                  */
 383                 /* switch to home wiring mode */
 384                 media = a->read_bcr(ioaddr, 49);
 385
 386                 DBG ( "media reset to %#x.\n", media );
 387                 a->write_bcr(ioaddr, 49, media);
 388                 break;
 389         case 0x2627:
 390                 chipname = "PCnet/FAST III 79C975";
 391                 fdx = 1;
 392                 mii = 1;
 393                 break;
 394         case 0x2628:
 395                 chipname = "PCnet/PRO 79C976";
 396                 fdx = 1;
 397                 mii = 1;
 398                 break;
 399         default:
 400                 chipname = "UNKNOWN";
 401                 DBG ( "PCnet version %#x, no PCnet32 chip.\n", chip_version );
 402                 goto err_unsupported;
 403         }
 404
 405         DBG ( "PCnet chipname %s\n", chipname );
 406
 407         /*
 408          * On selected chips turn on the BCR18:NOUFLO bit. This stops transmit
 409          * starting until the packet is loaded. Strike one for reliability, lose
 410          * one for latency - although on PCI this isn't a big loss. Older chips
 411          * have FIFO's smaller than a packet, so you can't do this.
 412          * Turn on BCR18:BurstRdEn and BCR18:BurstWrEn.
 413          */
 414         if (fset) {
 415                 a->write_bcr ( ioaddr, 18,
 416                         ( a->read_bcr ( ioaddr, 18 ) | 0x0860 ) );
 417                 a->write_csr ( ioaddr, 80,
 418                         ( a->read_csr ( ioaddr, 80 ) & 0x0C00) | 0x0C00 );
 419         }
 420
 421         priv->full_duplex = fdx;
 422         priv->mii = mii;
 423
 424         return 0;
 425
 426 err_unsupported:
 427         return rc;
 428 }
 429
 430 /**
 431  * pcnet32_set_ops - Determines the ops used to access the registers
 432  *
 433  * @v priv      Driver private structure
 434  *
 435  * @ret rc      Returns 0 on success, negative on failure
 436  */
 437 static int
 438 pcnet32_set_ops ( struct pcnet32_private *priv )
 439 {
 440         int rc;
 441         unsigned long ioaddr;
 442
 443         ioaddr = priv->pci_dev->ioaddr;
 444
 445         /* Check if CSR0 has its default value and perform a write / read
 446            in the RAP register to see if it works. Based on these results
 447            determine what mode the NIC is in (WIO / DWIO)
 448          */
 449         rc = -ENODEV;
 450
 451         if ( pcnet32_wio_read_csr ( ioaddr, 0 ) == 4 &&
 452              pcnet32_wio_check ( ioaddr ) ) {
 453                 priv->a = &pcnet32_wio;
 454         } else {
 455                 pcnet32_dwio_reset ( ioaddr );
 456                 if ( pcnet32_dwio_read_csr ( ioaddr, 0 ) == 4 &&
 457                      pcnet32_dwio_check ( ioaddr ) ) {
 458                         priv->a = &pcnet32_dwio;
 459                 } else {
 460                         goto err_unsupported;
 461                 }
 462         }
 463
 464         return 0;
 465
 466 err_unsupported:
 467         return rc;
 468 }
 469
 470 /**
 471  * pcnet32_setup_init_block - setup the NICs initialization block
 472  *
 473  * @v priv      Driver private structure
 474  *
 475  * @ret rc      Returns 0 on success, negative on failure
 476  */
 477 static void
 478 pcnet32_setup_init_block ( struct pcnet32_private *priv )
 479 {
 480         int i;
 481
 482         /* Configure the network port based on what we've established so far */
 483         priv->init_block.mode =
 484                 cpu_to_le16 ( ( priv->options & PCNET32_PORT_PORTSEL ) << 7 );
 485
 486         /* Setup RLEN and TLEN fields */
 487         priv->init_block.tlen_rlen =
 488                 cpu_to_le16 ( ( PCNET32_LOG_RX_BUFFERS << 4 ) |
 489                               ( PCNET32_LOG_TX_BUFFERS << 12 ) );
 490
 491         /* Fill in physical address */
 492         for ( i = 0; i < ETH_ALEN; i++)
 493                 priv->init_block.phys_addr[i] = priv->netdev->hw_addr[i];
 494
 495         /* No multicasting scheme, accept everything */
 496         priv->init_block.filter[0] = 0xffffffff;
 497         priv->init_block.filter[1] = 0xffffffff;
 498
 499         priv->init_block.rx_ring =
 500                 cpu_to_le32 ( virt_to_bus ( priv->rx_base ) );
 501         priv->init_block.tx_ring =
 502                 cpu_to_le32 ( virt_to_bus ( priv->tx_base ) );
 503
 504         /* Make sure all changes are visible */
 505         wmb();
 506 }
 507
 508 /**
 509  * pcnet32_setup_probe_phy - go through all PHYs and see which one is present
 510  *
 511  * @v priv      Driver private structure
 512  */
 513 static void
 514 pcnet32_setup_probe_phy ( struct pcnet32_private *priv )
 515 {
 516         unsigned long ioaddr = priv->pci_dev->ioaddr;
 517         unsigned int phycount = 0;
 518         int phy_id;
 519         int i;
 520
 521         if ( priv->mii ) {
 522                 phy_id = ( ( priv->a->read_bcr ( ioaddr, 33 ) ) >> 5 ) & 0x1f;
 523                 for ( i = 0; i < PCNET32_MAX_PHYS; i++ ) {
 524                         unsigned short id1, id2;
 525                         id1 = pcnet32_mdio_read ( priv->netdev, i, MII_PHYSID1 );
 526                         if ( id1 == 0xffff )
 527                                 continue;
 528                         id2 = pcnet32_mdio_read ( priv->netdev, i, MII_PHYSID2 );
 529                         if ( id2 == 0xffff )
 530                                 continue;
 531                         if ( i == 31 && ( ( priv->chip_version + 1 ) & 0xfffe ) == 0x2624 )
 532                                 continue;
 533
 534                         phycount++;
 535                         phy_id = i;
 536                 }
 537                 priv->a->write_bcr ( ioaddr, 33, phy_id << 5 );
 538                 if ( phycount > 1 )
 539                         priv->options |= PCNET32_PORT_MII;
 540         }
 541 }
 542
 543 /**
 544  * pcnet32_setup_mac_addr - check for inconsistency between CSR12-14
 545  * and PROM addresses
 546  *
 547  * @v priv      Driver private structure
 548  */
 549 static int
 550 pcnet32_setup_mac_addr ( struct pcnet32_private *priv )
 551 {
 552         int i;
 553         u8 promaddr[ETH_ALEN];
 554         unsigned long ioaddr = priv->pci_dev->ioaddr;
 555
 556         /* In most chips, after a chip reset, the ethernet address is read from
 557          * the station address PROM at the base address and programmed into the
 558          * "Physical Address Registers" CSR12-14.
 559          * As a precautionary measure, we read the PROM values and complain if
 560          * they disagree with the CSRs.  If they miscompare, and the PROM addr
 561          * is valid, then the PROM addr is used.
 562          */
 563         for ( i = 0; i < 3; i++ ) {
 564                 unsigned int val;
 565                 val = priv->a->read_csr ( ioaddr, i + 12 ) & 0x0ffff;
 566                 /* There may be endianness issues here. */
 567                 priv->netdev->hw_addr[2 * i] = val & 0x0ff;
 568                 priv->netdev->hw_addr[2 * i + 1] = ( val >> 8 ) & 0x0ff;
 569         }
 570
 571         for ( i = 0; i < ETH_ALEN; i++ )
 572                 promaddr[i] = inb ( ioaddr + i );
 573
 574         if ( memcmp ( promaddr, priv->netdev->hw_addr, ETH_ALEN ) ||
 575              ! is_valid_ether_addr ( priv->netdev->hw_addr ) ) {
 576                 if ( is_valid_ether_addr ( promaddr ) ) {
 577                         DBG ( "CSR address is invalid, using PROM addr\n" );
 578                         memcpy ( priv->netdev->hw_addr, promaddr, ETH_ALEN );
 579                 }
 580         }
 581
 582         /* If ethernet address is not valid, return error */
 583         if ( ! is_valid_ether_addr ( priv->netdev->hw_addr ) )
 584                 return -EADDRNOTAVAIL;
 585
 586         return 0;
 587 }
 588
 589 /**
 590  * pcnet32_setup_if_duplex - Sets the NICs used interface and duplex mode
 591  *
 592  * @v priv      Driver private structure
 593  */
 594 static void
 595 pcnet32_setup_if_duplex ( struct pcnet32_private *priv )
 596 {
 597         unsigned long ioaddr = priv->pci_dev->ioaddr;
 598         u16 val;
 599
 600         /* Set/Reset autoselect bit */
 601         val = priv->a->read_bcr ( ioaddr, 2 ) & ~2;
 602         if ( priv->options & PCNET32_PORT_ASEL )
 603                 val |= 2;
 604         priv->a->write_bcr ( ioaddr, 2, val );
 605
 606         /* Handle full duplex setting */
 607         if ( priv->full_duplex ) {
 608                 val = priv->a->read_bcr ( ioaddr, 9 ) & ~3;
 609                 if ( priv->options & PCNET32_PORT_FD ) {
 610                         val |= 1;
 611                         if ( priv->options == ( PCNET32_PORT_FD | PCNET32_PORT_AUI ) )
 612                                 val |= 2;
 613                 } else if ( priv->options & PCNET32_PORT_ASEL ) {
 614                         /* Workaround of xSeries 250, on for 79C975 only */
 615                         if ( priv->chip_version == 0x2627 )
 616                                 val |= 3;
 617                 }
 618                 priv->a->write_bcr ( ioaddr, 9, val );
 619         }
 620
 621         /* Set/Reset GPSI bit in test register */
 622         val = priv->a->read_csr ( ioaddr, 124 ) & ~0x10;
 623         if ( ( priv->options & PCNET32_PORT_PORTSEL ) == PCNET32_PORT_GPSI )
 624                 val |= 0x10;
 625         priv->a->write_bcr ( ioaddr, 124, val );
 626
 627         /* Allied Telesyn AT are 100Mbit only and do not negotiate */
 628         u16 subsys_vend_id, subsys_dev_id;
 629         pci_read_config_word ( priv->pci_dev,
 630                                PCI_SUBSYSTEM_VENDOR_ID,
 631                                &subsys_vend_id );
 632         pci_read_config_word ( priv->pci_dev,
 633                                PCI_SUBSYSTEM_ID,
 634                                &subsys_dev_id );
 635         if ( subsys_vend_id == PCI_VENDOR_ID_AT &&
 636              ( ( subsys_dev_id == PCI_SUBDEVICE_ID_AT_2700FX ) ||
 637                ( subsys_dev_id == PCI_SUBDEVICE_ID_AT_2701FX ) ) ) {
 638                 priv->options = PCNET32_PORT_FD | PCNET32_PORT_100;
 639         }
 640
 641         if ( priv->mii && ! ( priv->options & PCNET32_PORT_ASEL ) ) {
 642                 /* Disable Auto Negotiation, set 10Mbps, HD */
 643                 val = priv->a->read_bcr ( ioaddr, 32 ) & ~0x38;
 644                 if ( priv->options & PCNET32_PORT_FD )
 645                         val |= 0x10;
 646                 if ( priv->options & PCNET32_PORT_100 )
 647                         val |= 0x08;
 648                 priv->a->write_bcr ( ioaddr, 32, val );
 649         } else if ( priv->options & PCNET32_PORT_ASEL ) {
 650                 /* 79C970 chips do not have the BCR32 register */
 651                 if ( ( priv->chip_version != 0x2420 ) &&
 652                      ( priv->chip_version != 0x2621 ) ) {
 653                         /* Enable Auto Negotiation, setup, disable FD */
 654                         val = priv->a->read_bcr ( ioaddr, 32 ) & ~0x98;
 655                         val |= 0x20;
 656                         priv->a->write_bcr ( ioaddr, 32, val );
 657                 }
 658         }
 659 }
 660
 661 /**
 662  * pcnet32_hw_start - Starts up the NIC
 663  *
 664  * @v priv      Driver private structure
 665  */
 666 static void
 667 pcnet32_hw_start ( struct pcnet32_private *priv )
 668 {
 669         unsigned long ioaddr = priv->pci_dev->ioaddr;
 670         int i;
 671
 672         /* Begin initialization procedure */
 673         priv->a->write_csr ( ioaddr, 0, Init );
 674
 675         /* Wait for the initialization to be done */
 676         i = 0;
 677         while ( i++ < 100 )
 678                 if ( priv->a->read_csr ( ioaddr, 0 ) & InitDone )
 679                         break;
 680
 681         /* Start the chip */
 682         priv->a->write_csr ( ioaddr, 0, Strt );
 683 }
 684
 685 /**
 686  * open - Called when a network interface is made active
 687  *
 688  * @v netdev    Network device
 689  * @ret rc      Return status code, 0 on success, negative value on failure
 690  **/
 691 static int
 692 pcnet32_open ( struct net_device *netdev )
 693 {
 694         struct pcnet32_private *priv = netdev_priv ( netdev );
 695         unsigned long ioaddr = priv->pci_dev->ioaddr;
 696         int rc;
 697         u16 val;
 698
 699         /* Setup TX and RX descriptors */
 700         if ( ( rc = pcnet32_setup_tx_resources ( priv ) ) != 0 ) {
 701                 DBG ( "Error setting up TX resources\n" );
 702                 goto err_setup_tx;
 703         }
 704
 705         if ( ( rc = pcnet32_setup_rx_resources ( priv ) ) != 0 ) {
 706                 DBG ( "Error setting up RX resources\n" );
 707                 goto err_setup_rx;
 708         }
 709
 710         /* Reset the chip */
 711         priv->a->reset ( ioaddr );
 712
 713         /* Switch pcnet32 to 32bit mode */
 714         priv->a->write_bcr ( ioaddr, 20, PCNET32_SWSTYLE_PCNET32 );
 715
 716         /* Setup the interface and duplex mode */
 717         pcnet32_setup_if_duplex ( priv );
 718
 719         /* Disable interrupts */
 720         val = priv->a->read_csr ( ioaddr, 3 );
 721         val |= BablMask | MissFrameMask | RxIntMask | TxIntMask | InitDoneMask;
 722         priv->a->write_csr ( ioaddr, 3, val );
 723
 724         /* Setup initialization block */
 725         pcnet32_setup_init_block ( priv );
 726
 727         /* Fill in the address of the initialization block */
 728         priv->a->write_csr ( ioaddr, 1,
 729                 ( virt_to_bus ( &priv->init_block ) ) & 0xffff );
 730         priv->a->write_csr ( ioaddr, 2,
 731                 ( virt_to_bus ( &priv->init_block ) ) >> 16 );
 732
 733         /* Enable Auto-Pad, disable interrupts */
 734         priv->a->write_csr ( ioaddr, 4, 0x0915 );
 735
 736         pcnet32_hw_start ( priv );
 737
 738         return 0;
 739
 740 err_setup_rx:
 741         pcnet32_free_tx_resources ( priv );
 742 err_setup_tx:
 743         priv->a->reset( priv->pci_dev->ioaddr );
 744         return rc;
 745 }
 746
 747 /**
 748  * transmit - Transmit a packet
 749  *
 750  * @v netdev    Network device
 751  * @v iobuf     I/O buffer
 752  *
 753  * @ret rc      Returns 0 on success, negative on failure
 754  */
 755 static int
 756 pcnet32_transmit ( struct net_device *netdev, struct io_buffer *iobuf )
 757 {
 758         struct pcnet32_private *priv = netdev_priv ( netdev );
 759         unsigned long ioaddr = priv->pci_dev->ioaddr;
 760         uint32_t tx_len = iob_len ( iobuf );
 761         struct pcnet32_tx_desc *tx_curr_desc;
 762
 763         DBGP ( "pcnet32_transmit\n" );
 764
 765         if ( priv->tx_fill_ctr == TX_RING_SIZE ) {
 766                 DBG ( "Tx overflow\n" );
 767                 return -ENOTSUP;
 768         }
 769
 770         priv->tx_iobuf[priv->tx_curr] = iobuf;
 771
 772         tx_curr_desc = priv->tx_base + priv->tx_curr;
 773
 774         /* Configure current descriptor to transmit packet */
 775         tx_curr_desc->length = cpu_to_le16 ( -tx_len );
 776         tx_curr_desc->misc = 0x00000000;
 777         tx_curr_desc->base = cpu_to_le32 ( virt_to_bus ( iobuf->data ) );
 778
 779         /* Owner changes after the other status fields are set */
 780         wmb();
 781         tx_curr_desc->status =
 782                 cpu_to_le16 ( DescOwn | StartOfPacket | EndOfPacket );
 783
 784         /* Trigger an immediate send poll */
 785         priv->a->write_csr ( ioaddr, 0,
 786                 ( priv->irq_enabled ? IntEnable : 0 ) | TxDemand );
 787
 788         /* Point to the next free descriptor */
 789         priv->tx_curr = ( priv->tx_curr + 1 ) % TX_RING_SIZE;
 790
 791         /* Increment number of tx descriptors in use */
 792         priv->tx_fill_ctr++;
 793
 794         return 0;
 795 }
 796
 797 /**
 798  * pcnet32_process_tx_packets - Checks for successfully sent packets,
 799  * reports them to iPXE with netdev_tx_complete()
 800  *
 801  * @v netdev    Network device
 802  */
 803 static void
 804 pcnet32_process_tx_packets ( struct net_device *netdev )
 805 {
 806         struct pcnet32_private *priv = netdev_priv ( netdev );
 807         struct pcnet32_tx_desc *tx_curr_desc;
 808
 809         DBGP ( "pcnet32_process_tx_packets\n" );
 810
 811         while ( priv->tx_tail != priv->tx_curr ) {
 812                 tx_curr_desc = priv->tx_base + priv->tx_tail;
 813
 814                 u16 status = le16_to_cpu ( tx_curr_desc->status );
 815
 816                 DBG ( "Before OWN bit check, status: %#08x\n", status );
 817
 818                 /* Skip this descriptor if hardware still owns it */
 819                 if ( status & DescOwn )
 820                         break;
 821
 822                 DBG ( "Transmitted packet.\n" );
 823                 DBG ( "priv->tx_fill_ctr= %d\n", priv->tx_fill_ctr );
 824                 DBG ( "priv->tx_tail    = %d\n", priv->tx_tail );
 825                 DBG ( "priv->tx_curr    = %d\n", priv->tx_curr );
 826                 DBG ( "tx_curr_desc     = %#08lx\n", virt_to_bus ( tx_curr_desc ) );
 827
 828                 /* This packet is ready for completion */
 829                 netdev_tx_complete ( netdev, priv->tx_iobuf[priv->tx_tail]);
 830
 831                 /* Clear the descriptor */
 832                 memset ( tx_curr_desc, 0, sizeof(*tx_curr_desc) );
 833
 834                 /* Reduce the number of tx descriptors in use */
 835                 priv->tx_fill_ctr--;
 836
 837                 /* Go to next available descriptor */
 838                 priv->tx_tail = ( priv->tx_tail + 1 ) % TX_RING_SIZE;
 839         }
 840 }
 841
 842 /**
 843  * pcnet32_process_rx_packets - Checks for received packets, reports them
 844  * to iPXE with netdev_rx() or netdev_rx_err() if there was an error receiving
 845  * the packet
 846  *
 847  * @v netdev    Network device
 848  */
 849 static void
 850 pcnet32_process_rx_packets ( struct net_device *netdev )
 851 {
 852         struct pcnet32_private *priv = netdev_priv ( netdev );
 853         struct pcnet32_rx_desc *rx_curr_desc;
 854         u16 status;
 855         u32 len;
 856         int i;
 857
 858         DBGP ( "pcnet32_process_rx_packets\n" );
 859
 860         for ( i = 0; i < RX_RING_SIZE; i++ ) {
 861                 rx_curr_desc = priv->rx_base + priv->rx_curr;
 862
 863                 status = le16_to_cpu ( rx_curr_desc->status );
 864                 rmb();
 865
 866                 DBG ( "Before OWN bit check, status: %#08x\n", status );
 867
 868                 /* Skip this descriptor if hardware still owns it */
 869                 if ( status & DescOwn )
 870                         break;
 871
 872                 /* We own the descriptor, but it has not been refilled yet */
 873                 if ( priv->rx_iobuf[priv->rx_curr] == NULL )
 874                         break;
 875
 876                 DBG ( "Received packet.\n" );
 877                 DBG ( "priv->rx_curr    = %d\n", priv->rx_curr );
 878                 DBG ( "rx_len           = %d\n",
 879                       ( le32_to_cpu ( rx_curr_desc->msg_length ) & 0xfff ) - 4 );
 880                 DBG ( "rx_curr_desc     = %#08lx\n",
 881                       virt_to_bus ( rx_curr_desc ) );
 882
 883                 /* Check ERR bit */
 884                 if ( status & 0x4000 ) {
 885                         netdev_rx_err ( netdev, priv->rx_iobuf[priv->rx_curr],
 886                                         -EINVAL );
 887                         DBG ( "Corrupted packet received!\n");
 888                 } else {
 889                         /* Adjust size of the iobuf to reflect received data */
 890                         len = ( le32_to_cpu ( rx_curr_desc->msg_length ) & 0xfff ) - 4;
 891                         iob_put ( priv->rx_iobuf[priv->rx_curr], len );
 892
 893                         /* Add this packet to the receive queue */
 894                         netdev_rx ( netdev, priv->rx_iobuf[priv->rx_curr] );
 895                 }
 896
 897                 /* Invalidate iobuf and descriptor */
 898                 priv->rx_iobuf[priv->rx_curr] = NULL;
 899                 memset ( rx_curr_desc, 0, sizeof(*rx_curr_desc) );
 900
 901                 /* Point to the next free descriptor */
 902                 priv->rx_curr = ( priv->rx_curr + 1 ) % RX_RING_SIZE;
 903         }
 904
 905         /* Allocate new iobufs where needed */
 906         pcnet32_refill_rx_ring ( priv );
 907 }
 908
 909 /**
 910  * poll - Poll for received packets
 911  *
 912  * @v netdev    Network device
 913  */
 914 static void
 915 pcnet32_poll ( struct net_device *netdev )
 916 {
 917         struct pcnet32_private *priv = netdev_priv ( netdev );
 918         unsigned long ioaddr = priv->pci_dev->ioaddr;
 919         u16 status;
 920
 921         DBGP ( "pcnet32_poll\n" );
 922
 923         status = priv->a->read_csr ( ioaddr, 0 );
 924
 925         /* Clear interrupts */
 926         priv->a->write_csr ( ioaddr, 0, status );
 927
 928         DBG ( "pcnet32_poll: mask = %#04x, status = %#04x\n",
 929                 priv->a->read_csr ( ioaddr, 3 ), status );
 930
 931         /* Return when RINT or TINT are not set */
 932         if ( ( status & 0x0500 ) == 0x0000 )
 933                 return;
 934
 935         /* Process transmitted packets */
 936         pcnet32_process_tx_packets ( netdev );
 937
 938         /* Process received packets */
 939         pcnet32_process_rx_packets ( netdev );
 940 }
 941
 942 /**
 943  * close - Disable network interface
 944  *
 945  * @v netdev    network interface device structure
 946  **/
 947 static void
 948 pcnet32_close ( struct net_device *netdev )
 949 {
 950         struct pcnet32_private *priv = netdev_priv ( netdev );
 951         unsigned long ioaddr = priv->pci_dev->ioaddr;
 952
 953         DBGP ( "pcnet32_close\n" );
 954
 955         /* Reset the chip */
 956         pcnet32_wio_reset ( ioaddr );
 957
 958         /* Stop the PCNET32 - it occasionally polls memory if we don't */
 959         priv->a->write_csr ( ioaddr, 0, Stop );
 960
 961         /* Switch back to 16bit mode to avoid problems with dumb
 962          * DOS packet driver after a warm reboot */
 963         priv->a->write_bcr ( ioaddr, 20, PCNET32_SWSTYLE_LANCE );
 964
 965         pcnet32_free_rx_resources ( priv );
 966         pcnet32_free_tx_resources ( priv );
 967 }
 968
 969 static void pcnet32_irq_enable ( struct pcnet32_private *priv )
 970 {
 971         unsigned long ioaddr = priv->pci_dev->ioaddr;
 972         u16 val;
 973
 974         DBGP ( "pcnet32_irq_enable\n" );
 975
 976         /* Enable TINT and RINT masks */
 977         val = priv->a->read_csr ( ioaddr, 3 );
 978         val &= ~( RxIntMask | TxIntMask );
 979         priv->a->write_csr ( ioaddr, 3, val );
 980
 981         /* Enable interrupts */
 982         priv->a->write_csr ( ioaddr, 0, IntEnable );
 983
 984         priv->irq_enabled = 1;
 985 }
 986
 987 static void pcnet32_irq_disable ( struct pcnet32_private *priv )
 988 {
 989         unsigned long ioaddr = priv->pci_dev->ioaddr;
 990
 991         DBGP ( "pcnet32_irq_disable\n" );
 992
 993         priv->a->write_csr ( ioaddr, 0, 0x0000 );
 994
 995         priv->irq_enabled = 0;
 996 }
 997
 998 /**
 999  * irq - enable or disable interrupts
1000  *
1001  * @v netdev    network adapter
1002  * @v action    requested interrupt action
1003  **/
1004 static void
1005 pcnet32_irq ( struct net_device *netdev, int action )
1006 {
1007         struct pcnet32_private *priv = netdev_priv ( netdev );
1008
1009         DBGP ( "pcnet32_irq\n" );
1010
1011         switch ( action ) {
1012         case 0:
1013                 pcnet32_irq_disable ( priv );
1014                 break;
1015         default:
1016                 pcnet32_irq_enable ( priv );
1017                 break;
1018         }
1019 }
1020
1021 static struct net_device_operations pcnet32_operations = {
1022         .open           = pcnet32_open,
1023         .transmit       = pcnet32_transmit,
1024         .poll           = pcnet32_poll,
1025         .close          = pcnet32_close,
1026         .irq            = pcnet32_irq,
1027 };
1028
1029 /**
1030  * probe - Initial configuration of NIC
1031  *
1032  * @v pdev      PCI device
1033  * @v ent       PCI IDs
1034  *
1035  * @ret rc      Return status code
1036  **/
1037 static int
1038 pcnet32_probe ( struct pci_device *pdev )
1039 {
1040         struct net_device *netdev;
1041         struct pcnet32_private *priv;
1042         unsigned long ioaddr;
1043         int rc;
1044
1045         DBGP ( "pcnet32_probe\n" );
1046
1047         DBG ( "Found %s, vendor = %#04x, device = %#04x\n",
1048                 pdev->id->name, pdev->id->vendor, pdev->id->device );
1049
1050         /* Allocate our private data */
1051         netdev = alloc_etherdev ( sizeof ( *priv ) );
1052         if ( ! netdev ) {
1053                 rc = -ENOMEM;
1054                 goto err_alloc_etherdev;
1055         }
1056
1057         /* Link our operations to the netdev struct */
1058         netdev_init ( netdev, &pcnet32_operations );
1059
1060         /* Link the PCI device to the netdev struct */
1061         pci_set_drvdata ( pdev, netdev );
1062         netdev->dev = &pdev->dev;
1063
1064         /* Get a reference to our private data */
1065         priv = netdev_priv ( netdev );
1066
1067         /* We'll need these set up for the rest of the routines */
1068         priv->pci_dev = pdev;
1069         priv->netdev = netdev;
1070
1071         ioaddr = pdev->ioaddr;
1072
1073         /* Only use irqs under UNDI */
1074         priv->irq_enabled = 0;
1075
1076         /* Reset the chip */
1077         pcnet32_wio_reset ( ioaddr );
1078
1079         if ( ( rc = pcnet32_set_ops ( priv ) ) != 0 ) {
1080                 DBG ( "Setting driver operations failed\n");
1081                 goto err_set_ops;
1082         }
1083
1084         if ( ( rc = pcnet32_chip_detect ( priv ) ) != 0 ) {
1085                 DBG ( "pcnet32_chip_detect failed\n" );
1086                 goto err_chip_detect;
1087         }
1088
1089         /* Enter bus mastering mode */
1090         adjust_pci_device ( pdev );
1091
1092         /* Verify and get MAC address */
1093         if ( ( rc = pcnet32_setup_mac_addr ( priv ) ) != 0 ) {
1094                 DBG ( "Setting MAC address failed\n" );
1095                 goto err_mac_addr;
1096         }
1097
1098         DBG ( "IO Addr 0x%lX, MAC Addr %s\n", ioaddr,
1099                 eth_ntoa ( netdev->hw_addr ) );
1100
1101         priv->options = PCNET32_PORT_ASEL;
1102
1103         /* Detect special T1/E1 WAN card by checking for MAC address */
1104         if ( netdev->hw_addr[0] == 0x00 &&
1105              netdev->hw_addr[1] == 0xE0 &&
1106              netdev->hw_addr[2] == 0x75 )
1107                 priv->options = PCNET32_PORT_FD | PCNET32_PORT_GPSI;
1108
1109         /* Probe the PHY so we can check link state and speed */
1110         pcnet32_setup_probe_phy ( priv );
1111
1112         if ( ( rc = register_netdev ( netdev ) ) != 0 ) {
1113                 DBG ( "Error registering netdev\n" );
1114                 goto err_register;
1115         }
1116
1117         netdev_link_up ( netdev );
1118
1119         return 0;
1120
1121 err_register:
1122         netdev_put ( netdev );
1123 err_chip_detect:
1124 err_set_ops:
1125 err_alloc_etherdev:
1126 err_mac_addr:
1127         return rc;
1128 }
1129
1130 /**
1131  * remove - Device Removal Routine
1132  *
1133  * @v pdev PCI device information struct
1134  **/
1135 static void
1136 pcnet32_remove ( struct pci_device *pdev )
1137 {
1138         struct net_device *netdev = pci_get_drvdata ( pdev );
1139         unsigned long ioaddr = pdev->ioaddr;
1140
1141         DBGP ( "pcnet32_remove\n" );
1142
1143         /* Reset the chip */
1144         pcnet32_wio_reset ( ioaddr );
1145
1146         unregister_netdev ( netdev );
1147         netdev_nullify ( netdev );
1148         netdev_put ( netdev );
1149 }
1150
1151 static struct pci_device_id pcnet32_nics[] = {
1152         PCI_ROM(0x1022, 0x2000, "pcnet32", "AMD PCnet/PCI", 0),
1153         PCI_ROM(0x1022, 0x2625, "pcnetfastiii", "AMD PCNet FAST III", 0),
1154         PCI_ROM(0x1022, 0x2001, "amdhomepna", "AMD PCnet/HomePNA", 0),
1155 };
1156
1157 struct pci_driver pcnet32_driver __pci_driver = {
1158         .ids            = pcnet32_nics,
1159         .id_count       = ARRAY_SIZE ( pcnet32_nics ),
1160         .probe          = pcnet32_probe,
1161         .remove         = pcnet32_remove,
1162 };