src/drivers/net/3c90x.c

   1 /*
   2  * 3c90x.c -- This file implements a gPXE API 3c90x driver
   3  *
   4  * Originally written for etherboot by:
   5  *   Greg Beeley, Greg.Beeley@LightSys.org
   6  * Modified by Steve Smith,
   7  *   Steve.Smith@Juno.Com. Alignment bug fix Neil Newell (nn@icenoir.net).
   8  * Almost totally Rewritten to use gPXE API, implementation of tx/rx ring support
   9  *   by Thomas Miletich, thomas.miletich@gmail.com
  10  *   Thanks to Marty Connor and Stefan Hajnoczi for their help and feedback,
  11  *   and to Daniel Verkamp for his help with testing.
  12  *
  13  * Copyright (c) 2009 Thomas Miletich
  14  *
  15  * Copyright (c) 1999 LightSys Technology Services, Inc.
  16  * Portions Copyright (c) 1999 Steve Smith
  17  *
  18  * This program may be re-distributed in source or binary form, modified,
  19  * sold, or copied for any purpose, provided that the above copyright message
  20  * and this text are included with all source copies or derivative works, and
  21  * provided that the above copyright message and this text are included in the
  22  * documentation of any binary-only distributions.  This program is distributed
  23  * WITHOUT ANY WARRANTY, without even the warranty of FITNESS FOR A PARTICULAR
  24  * PURPOSE or MERCHANTABILITY.  Please read the associated documentation
  25  * "3c90x.txt" before compiling and using this driver.
  26  *
  27  * [ --mdc 20090313 The 3c90x.txt file is now at:
  28  *   http://etherboot.org/wiki/appnotes/3c90x_issues ]
  29  *
  30  * This program was written with the assistance of the 3com documentation for
  31  * the 3c905B-TX card, as well as with some assistance from the 3c59x
  32  * driver Donald Becker wrote for the Linux kernel, and with some assistance
  33  * from the remainder of the Etherboot distribution.
  34  *
  35  * Indented with unix 'indent' command:
  36  *   $ indent -kr -i8 3c90x.c
  37  */
  38
  39 #include <stdint.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <stddef.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <assert.h>
  46 #include <byteswap.h>
  47 #include <errno.h>
  48 #include <gpxe/ethernet.h>
  49 #include <gpxe/if_ether.h>
  50 #include <gpxe/io.h>
  51 #include <gpxe/iobuf.h>
  52 #include <gpxe/malloc.h>
  53 #include <gpxe/netdevice.h>
  54 #include <gpxe/pci.h>
  55 #include <gpxe/timer.h>
  56 #include <gpxe/nvs.h>
  57
  58 #include "3c90x.h"
  59
  60 /**
  61  * a3c90x_internal_IssueCommand: sends a command to the 3c90x card
  62  * and waits for it's completion
  63  *
  64  * @v ioaddr    IOAddress of the NIC
  65  * @v cmd       Command to be issued
  66  * @v param     Command parameter
  67  */
  68 static void a3c90x_internal_IssueCommand(int ioaddr, int cmd, int param)
  69 {
  70         unsigned int val = (cmd << 11) | param;
  71         int cnt = 0;
  72
  73         DBGP("a3c90x_internal_IssueCommand\n");
  74
  75         /* Send the cmd to the cmd register */
  76         outw(val, ioaddr + regCommandIntStatus_w);
  77
  78         /* Wait for the cmd to complete */
  79         for (cnt = 0; cnt < 100000; cnt++) {
  80                 if (inw(ioaddr + regCommandIntStatus_w) & INT_CMDINPROGRESS) {
  81                         continue;
  82                 } else {
  83                         DBG2("Command 0x%04X finished in time. cnt = %d.\n", cmd, cnt);
  84                         return;
  85                 }
  86         }
  87
  88         DBG("Command 0x%04X DID NOT finish in time. cnt = %d.\n", cmd, cnt);
  89 }
  90
  91 /**
  92  * a3c90x_internal_SetWindow: selects a register window set.
  93  *
  94  * @v inf_3c90x private NIC data
  95  * @v window    window to be selected
  96  */
  97 static void a3c90x_internal_SetWindow(struct INF_3C90X *inf_3c90x, int window)
  98 {
  99         DBGP("a3c90x_internal_SetWindow\n");
 100         /* Window already as set? */
 101         if (inf_3c90x->CurrentWindow == window)
 102                 return;
 103
 104         /* Issue the window command. */
 105         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 106                                      cmdSelectRegisterWindow, window);
 107         inf_3c90x->CurrentWindow = window;
 108
 109         return;
 110 }
 111
 112 static void a3c90x_internal_WaitForEeprom(struct INF_3C90X *inf_3c90x)
 113 {
 114         int cnt = 0;
 115
 116         DBGP("a3c90x_internal_WaitForEeprom\n");
 117
 118         while (eepromBusy & inw(inf_3c90x->IOAddr + regEepromCommand_0_w)) {
 119                 if (cnt == EEPROM_TIMEOUT) {
 120                         DBG("Read from eeprom failed: timeout\n");
 121                         return;
 122                 }
 123                 udelay(1);
 124                 cnt++;
 125         }
 126 }
 127
 128 /**
 129  * a3c90x_internal_ReadEeprom - nvs routine to read eeprom data
 130  * We only support reading one word(2 byte). The nvs subsystem will make sure
 131  * that the routine will never be called with len != 2.
 132  *
 133  * @v nvs       nvs data.
 134  * @v address   eeprom address to read data from.
 135  * @v data      data is put here.
 136  * @v len       number of bytes to read.
 137  */
 138 static int
 139 a3c90x_internal_ReadEeprom(struct nvs_device *nvs, unsigned int address, void *data, size_t len)
 140 {
 141         unsigned short *dest = (unsigned short *) data;
 142         struct INF_3C90X *inf_3c90x =
 143             container_of(nvs, struct INF_3C90X, nvs);
 144
 145         DBGP("a3c90x_internal_ReadEeprom\n");
 146
 147         /* we support reading 2 bytes only */
 148         assert(len == 2);
 149
 150         /* Select correct window */
 151         a3c90x_internal_SetWindow(inf_3c90x, winEepromBios0);
 152
 153         /* set eepromRead bits in command sent to NIC */
 154         address += (inf_3c90x->is3c556 ? eepromRead_556 : eepromRead);
 155
 156         a3c90x_internal_WaitForEeprom(inf_3c90x);
 157         /* send address to NIC */
 158         outw(address, inf_3c90x->IOAddr + regEepromCommand_0_w);
 159         a3c90x_internal_WaitForEeprom(inf_3c90x);
 160
 161         /* read value */
 162         *dest = inw(inf_3c90x->IOAddr + regEepromData_0_w);
 163
 164         return 0;
 165 }
 166
 167 /**
 168  * a3c90x_internal_WriteEeprom - nvs routine to write eeprom data
 169  * currently not implemented
 170  *
 171  * @v nvs       nvs data.
 172  * @v address   eeprom address to read data from.
 173  * @v data      data is put here.
 174  * @v len       number of bytes to read.
 175  */
 176 static int
 177 a3c90x_internal_WriteEeprom(struct nvs_device *nvs __unused,
 178                             unsigned int address __unused,
 179                             const void *data __unused, size_t len __unused)
 180 {
 181         return -ENOTSUP;
 182 }
 183
 184 static void a3c90x_internal_ReadEepromContents(struct INF_3C90X *inf_3c90x)
 185 {
 186         int eeprom_size = (inf_3c90x->isBrev ? 0x20 : 0x17) * 2;
 187
 188         DBGP("a3c90x_internal_ReadEepromContents\n");
 189
 190         nvs_read(&inf_3c90x->nvs, 0, inf_3c90x->eeprom, eeprom_size);
 191 }
 192
 193 /**
 194  * a3c90x_reset: exported function that resets the card to its default
 195  * state.  This is so the Linux driver can re-set the card up the way
 196  * it wants to.  If CFG_3C90X_PRESERVE_XCVR is defined, then the reset will
 197  * not alter the selected transceiver that we used to download the boot
 198  * image.
 199  *
 200  * @v inf_3c90x Private NIC data
 201  */
 202 static void a3c90x_reset(struct INF_3C90X *inf_3c90x)
 203 {
 204         DBGP("a3c90x_reset\n");
 205         /* Send the reset command to the card */
 206         DBG("3c90x: Issuing RESET\n");
 207         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdGlobalReset, 0);
 208
 209         /* global reset command resets station mask, non-B revision cards
 210          * require explicit reset of values
 211          */
 212         a3c90x_internal_SetWindow(inf_3c90x, winAddressing2);
 213         outw(0, inf_3c90x->IOAddr + regStationMask_2_3w + 0);
 214         outw(0, inf_3c90x->IOAddr + regStationMask_2_3w + 2);
 215         outw(0, inf_3c90x->IOAddr + regStationMask_2_3w + 4);
 216
 217         /* Issue transmit reset, wait for command completion */
 218         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdTxReset, 0);
 219
 220         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdTxEnable, 0);
 221
 222         /*
 223          * reset of the receiver on B-revision cards re-negotiates the link
 224          * takes several seconds (a computer eternity)
 225          */
 226         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdRxReset,
 227                                      inf_3c90x->isBrev ? 0x04 : 0x00);
 228
 229         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdRxEnable, 0);
 230
 231         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 232                                      cmdSetInterruptEnable, 0);
 233         /* enable rxComplete and txComplete */
 234         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 235                                      cmdSetIndicationEnable,
 236                                      INT_TXCOMPLETE | INT_UPCOMPLETE);
 237         /* acknowledge any pending status flags */
 238         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 239                                      cmdAcknowledgeInterrupt, 0x661);
 240
 241         return;
 242 }
 243
 244 /**
 245  * a3c90x_setup_tx_ring - Allocates TX ring, initialize tx_desc values
 246  *
 247  * @v p Private NIC data
 248  *
 249  * @ret Returns 0 on success, negative on failure
 250  */
 251 static int a3c90x_setup_tx_ring(struct INF_3C90X *p)
 252 {
 253         DBGP("a3c90x_setup_tx_ring\n");
 254         p->tx_ring =
 255             malloc_dma(TX_RING_SIZE * sizeof(struct TXD), TX_RING_ALIGN);
 256
 257         if (!p->tx_ring) {
 258                 DBG("Could not allocate TX-ring\n");
 259                 return -ENOMEM;
 260         }
 261
 262         memset(p->tx_ring, 0, TX_RING_SIZE * sizeof(struct TXD));
 263         p->tx_cur = 0;
 264         p->tx_cnt = 0;
 265         p->tx_tail = 0;
 266
 267         return 0;
 268 }
 269
 270 /**
 271  * a3c90x_process_tx_packets - Checks for successfully sent packets,
 272  * reports them to gPXE with netdev_tx_complete();
 273  *
 274  * @v netdev    Network device info
 275  */
 276 static void a3c90x_process_tx_packets(struct net_device *netdev)
 277 {
 278         struct INF_3C90X *p = netdev_priv(netdev);
 279         unsigned int downlist_ptr;
 280
 281         DBGP("a3c90x_process_tx_packets\n");
 282
 283         DBG("    tx_cnt: %d\n", p->tx_cnt);
 284
 285         while (p->tx_tail != p->tx_cur) {
 286
 287                 downlist_ptr = inl(p->IOAddr + regDnListPtr_l);
 288
 289                 DBG("    downlist_ptr: %#08x\n", downlist_ptr);
 290                 DBG("    tx_tail: %d tx_cur: %d\n", p->tx_tail, p->tx_cur);
 291
 292                 /* NIC is currently working on this tx desc */
 293                 if(downlist_ptr == virt_to_bus(p->tx_ring + p->tx_tail))
 294                         return;
 295
 296                 netdev_tx_complete(netdev, p->tx_iobuf[p->tx_tail]);
 297
 298                 DBG("transmitted packet\n");
 299                 DBG("    size: %d\n", iob_len(p->tx_iobuf[p->tx_tail]));
 300
 301                 p->tx_tail = (p->tx_tail + 1) % TX_RING_SIZE;
 302                 p->tx_cnt--;
 303         }
 304 }
 305
 306 static void a3c90x_free_tx_ring(struct INF_3C90X *p)
 307 {
 308         DBGP("a3c90x_free_tx_ring\n");
 309
 310         free_dma(p->tx_ring, TX_RING_SIZE * sizeof(struct TXD));
 311         p->tx_ring = NULL;
 312         /* io_buffers are free()ed by netdev_tx_complete[,_err]() */
 313 }
 314
 315 /**
 316  * a3c90x_transmit - Transmits a packet.
 317  *
 318  * @v netdev    Network device info
 319  * @v iob               io_buffer containing the data to be send
 320  *
 321  * @ret Returns 0 on success, negative on failure
 322  */
 323 static int a3c90x_transmit(struct net_device *netdev,
 324                            struct io_buffer *iob)
 325 {
 326         struct INF_3C90X *inf_3c90x = netdev_priv(netdev);
 327         struct TXD *tx_cur_desc;
 328         struct TXD *tx_prev_desc;
 329
 330         unsigned int len;
 331         unsigned int downlist_ptr;
 332
 333         DBGP("a3c90x_transmit\n");
 334
 335         if (inf_3c90x->tx_cnt == TX_RING_SIZE) {
 336                 DBG("TX-Ring overflow\n");
 337                 return -ENOBUFS;
 338         }
 339
 340         inf_3c90x->tx_iobuf[inf_3c90x->tx_cur] = iob;
 341         tx_cur_desc = inf_3c90x->tx_ring + inf_3c90x->tx_cur;
 342
 343         tx_prev_desc = inf_3c90x->tx_ring +
 344             (((inf_3c90x->tx_cur + TX_RING_SIZE) - 1) % TX_RING_SIZE);
 345
 346         len = iob_len(iob);
 347
 348         /* Setup the DPD (download descriptor) */
 349         tx_cur_desc->DnNextPtr = 0;
 350
 351         /* FrameStartHeader differs in 90x and >= 90xB
 352          * It contains length in 90x and a round up boundary and packet ID for
 353          * 90xB and 90xC. We can leave this to 0 for 90xB and 90xC.
 354          */
 355         tx_cur_desc->FrameStartHeader =
 356             fshTxIndicate | (inf_3c90x->isBrev ? 0x00 : len);
 357
 358         tx_cur_desc->DataAddr = virt_to_bus(iob->data);
 359         tx_cur_desc->DataLength = len | downLastFrag;
 360
 361         /* We have to stall the download engine, so the NIC won't access the
 362          * tx descriptor while we modify it. There is a way around this
 363          * from revision B and upwards. To stay compatible with older revisions
 364          * we don't use it here.
 365          */
 366         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdStallCtl,
 367                                      dnStall);
 368
 369         tx_prev_desc->DnNextPtr = virt_to_bus(tx_cur_desc);
 370
 371         downlist_ptr = inl(inf_3c90x->IOAddr + regDnListPtr_l);
 372         if (downlist_ptr == 0) {
 373                 /* currently no DownList, sending a new one */
 374                 outl(virt_to_bus(tx_cur_desc),
 375                      inf_3c90x->IOAddr + regDnListPtr_l);
 376         }
 377
 378         /* End Stall */
 379         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdStallCtl,
 380                                      dnUnStall);
 381
 382         inf_3c90x->tx_cur = (inf_3c90x->tx_cur + 1) % TX_RING_SIZE;
 383         inf_3c90x->tx_cnt++;
 384
 385         return 0;
 386 }
 387
 388 /**
 389  * a3c90x_prepare_rx_desc - fills the rx desc with initial data
 390  *
 391  * @v p         NIC private data
 392  * @v index     Index for rx_iobuf and rx_ring array
 393  */
 394
 395 static void a3c90x_prepare_rx_desc(struct INF_3C90X *p, unsigned int index)
 396 {
 397         DBGP("a3c90x_prepare_rx_desc\n");
 398         DBG("Populating rx_desc %d\n", index);
 399
 400         /* We have to stall the upload engine, so the NIC won't access the
 401          * rx descriptor while we modify it. There is a way around this
 402          * from revision B and upwards. To stay compatible with older revisions
 403          * we don't use it here.
 404          */
 405         a3c90x_internal_IssueCommand(p->IOAddr, cmdStallCtl, upStall);
 406
 407         p->rx_ring[index].DataAddr = virt_to_bus(p->rx_iobuf[index]->data);
 408         p->rx_ring[index].DataLength = RX_BUF_SIZE | upLastFrag;
 409         p->rx_ring[index].UpPktStatus = 0;
 410
 411         /* unstall upload engine */
 412         a3c90x_internal_IssueCommand(p->IOAddr, cmdStallCtl, upUnStall);
 413 }
 414
 415 /**
 416  * a3c90x_refill_rx_ring -checks every entry in the rx ring and reallocates
 417  * them as necessary. Then it calls a3c90x_prepare_rx_desc to fill the rx desc
 418  * with initial data.
 419  *
 420  * @v p         NIC private data
 421  */
 422 static void a3c90x_refill_rx_ring(struct INF_3C90X *p)
 423 {
 424         int i;
 425         unsigned int status;
 426         struct RXD *rx_cur_desc;
 427
 428         DBGP("a3c90x_refill_rx_ring\n");
 429
 430         for (i = 0; i < RX_RING_SIZE; i++) {
 431                 rx_cur_desc = p->rx_ring + i;
 432                 status = rx_cur_desc->UpPktStatus;
 433
 434                 /* only refill used descriptor */
 435                 if (!(status & upComplete))
 436                         continue;
 437
 438                 /* we still need to process this descriptor */
 439                 if (p->rx_iobuf[i] != NULL)
 440                         continue;
 441
 442                 p->rx_iobuf[i] = alloc_iob(RX_BUF_SIZE);
 443                 if (p->rx_iobuf[i] == NULL) {
 444                         DBG("alloc_iob() failed\n");
 445                         break;
 446                 }
 447
 448                 a3c90x_prepare_rx_desc(p, i);
 449         }
 450 }
 451
 452 /**
 453  * a3c90x_setup_rx_ring - Allocates RX ring, initialize rx_desc values
 454  *
 455  * @v p Private NIC data
 456  *
 457  * @ret Returns 0 on success, negative on failure
 458  */
 459 static int a3c90x_setup_rx_ring(struct INF_3C90X *p)
 460 {
 461         int i;
 462
 463         DBGP("a3c90x_setup_rx_ring\n");
 464
 465         p->rx_ring =
 466             malloc_dma(RX_RING_SIZE * sizeof(struct RXD), RX_RING_ALIGN);
 467
 468         if (!p->rx_ring) {
 469                 DBG("Could not allocate RX-ring\n");
 470                 return -ENOMEM;
 471         }
 472
 473         p->rx_cur = 0;
 474
 475         for (i = 0; i < RX_RING_SIZE; i++) {
 476                 p->rx_ring[i].UpNextPtr =
 477                     virt_to_bus(p->rx_ring + (i + 1));
 478
 479                 /* these are needed so refill_rx_ring initializes the ring */
 480                 p->rx_ring[i].UpPktStatus = upComplete;
 481                 p->rx_iobuf[i] = NULL;
 482         }
 483
 484         /* Loop the ring */
 485         p->rx_ring[i - 1].UpNextPtr = virt_to_bus(p->rx_ring);
 486
 487         a3c90x_refill_rx_ring(p);
 488
 489         return 0;
 490 }
 491
 492 static void a3c90x_free_rx_ring(struct INF_3C90X *p)
 493 {
 494         DBGP("a3c90x_free_rx_ring\n");
 495
 496         free_dma(p->rx_ring, RX_RING_SIZE * sizeof(struct RXD));
 497         p->rx_ring = NULL;
 498 }
 499
 500 static void a3c90x_free_rx_iobuf(struct INF_3C90X *p)
 501 {
 502         int i;
 503
 504         DBGP("a3c90x_free_rx_iobuf\n");
 505
 506         for (i = 0; i < RX_RING_SIZE; i++) {
 507                 free_iob(p->rx_iobuf[i]);
 508                 p->rx_iobuf[i] = NULL;
 509         }
 510 }
 511
 512 /**
 513  * a3c90x_process_rx_packets - Checks for received packets,
 514  * reports them to gPXE with netdev_rx() or netdev_rx_err() if there was an
 515  * error while receiving the packet
 516  *
 517  * @v netdev    Network device info
 518  */
 519 static void a3c90x_process_rx_packets(struct net_device *netdev)
 520 {
 521         int i;
 522         unsigned int rx_status;
 523         struct INF_3C90X *p = netdev_priv(netdev);
 524         struct RXD *rx_cur_desc;
 525
 526         DBGP("a3c90x_process_rx_packets\n");
 527
 528         for (i = 0; i < RX_RING_SIZE; i++) {
 529                 rx_cur_desc = p->rx_ring + p->rx_cur;
 530                 rx_status = rx_cur_desc->UpPktStatus;
 531
 532                 if (!(rx_status & upComplete) && !(rx_status & upError))
 533                         break;
 534
 535                 if (p->rx_iobuf[p->rx_cur] == NULL)
 536                         break;
 537
 538                 if (rx_status & upError) {
 539                         DBG("Corrupted packet received\n");
 540                         netdev_rx_err(netdev, p->rx_iobuf[p->rx_cur],
 541                                       -EINVAL);
 542                 } else {
 543                         /* if we're here, we've got good packet */
 544                         int packet_len;
 545
 546                         packet_len = rx_status & 0x1FFF;
 547                         iob_put(p->rx_iobuf[p->rx_cur], packet_len);
 548
 549                         DBG("received packet\n");
 550                         DBG("    size: %d\n", packet_len);
 551
 552                         netdev_rx(netdev, p->rx_iobuf[p->rx_cur]);
 553                 }
 554
 555                 p->rx_iobuf[p->rx_cur] = NULL;  /* invalidate rx desc */
 556                 p->rx_cur = (p->rx_cur + 1) % RX_RING_SIZE;
 557         }
 558         a3c90x_refill_rx_ring(p);
 559
 560 }
 561
 562 /**
 563  * a3c90x_poll - Routine that gets called periodically.
 564  * Here we hanle transmitted and received packets.
 565  * We could also check the link status from time to time, which we
 566  * currently don't do.
 567  *
 568  * @v netdev    Network device info
 569  */
 570 static void a3c90x_poll(struct net_device *netdev)
 571 {
 572         struct INF_3C90X *p = netdev_priv(netdev);
 573         uint16_t raw_status, int_status;
 574
 575         DBGP("a3c90x_poll\n");
 576
 577         raw_status = inw(p->IOAddr + regCommandIntStatus_w);
 578         int_status = (raw_status & 0x0FFF);
 579
 580         if ( int_status == 0 )
 581                 return;
 582
 583         a3c90x_internal_IssueCommand(p->IOAddr, cmdAcknowledgeInterrupt,
 584                                      int_status);
 585
 586         if (int_status & INT_TXCOMPLETE)
 587                 outb(0x00, p->IOAddr + regTxStatus_b);
 588
 589         DBG("poll: status = %#04x\n", raw_status);
 590
 591         a3c90x_process_tx_packets(netdev);
 592
 593         a3c90x_process_rx_packets(netdev);
 594 }
 595
 596
 597
 598 static void a3c90x_free_resources(struct INF_3C90X *p)
 599 {
 600         DBGP("a3c90x_free_resources\n");
 601
 602         a3c90x_free_tx_ring(p);
 603         a3c90x_free_rx_ring(p);
 604         a3c90x_free_rx_iobuf(p);
 605 }
 606
 607 /**
 608  * a3c90x_remove - Routine to remove the card. Unregisters
 609  * the NIC from gPXE, disables RX/TX and resets the card.
 610  *
 611  * @v pci       PCI device info
 612  */
 613 static void a3c90x_remove(struct pci_device *pci)
 614 {
 615         struct net_device *netdev = pci_get_drvdata(pci);
 616         struct INF_3C90X *inf_3c90x = netdev_priv(netdev);
 617
 618         DBGP("a3c90x_remove\n");
 619
 620         unregister_netdev(netdev);
 621
 622         /* Disable the receiver and transmitter. */
 623         outw(cmdRxDisable, inf_3c90x->IOAddr + regCommandIntStatus_w);
 624         outw(cmdTxDisable, inf_3c90x->IOAddr + regCommandIntStatus_w);
 625
 626         a3c90x_reset(inf_3c90x);
 627         netdev_nullify(netdev);
 628         netdev_put(netdev);
 629 }
 630
 631 static void a3c90x_irq(struct net_device *netdev, int enable)
 632 {
 633         struct INF_3C90X *p = netdev_priv(netdev);
 634
 635         DBGP("a3c90x_irq\n");
 636
 637         if (enable == 0) {
 638                 /* disable interrupts */
 639                 a3c90x_internal_IssueCommand(p->IOAddr,
 640                                              cmdSetInterruptEnable, 0);
 641         } else {
 642                 a3c90x_internal_IssueCommand(p->IOAddr,
 643                                              cmdSetInterruptEnable,
 644                                              INT_TXCOMPLETE |
 645                                              INT_UPCOMPLETE);
 646                 a3c90x_internal_IssueCommand(p->IOAddr,
 647                                              cmdAcknowledgeInterrupt,
 648                                              0x661);
 649         }
 650 }
 651
 652 /**
 653  * a3c90x_hw_start - Initialize hardware, copy MAC address
 654  * to NIC registers, set default receiver
 655  */
 656 static void a3c90x_hw_start(struct net_device *netdev)
 657 {
 658         int i, c;
 659         unsigned int cfg;
 660         unsigned int mopt;
 661         unsigned short linktype;
 662         struct INF_3C90X *inf_3c90x = netdev_priv(netdev);
 663
 664         DBGP("a3c90x_hw_start\n");
 665
 666         /* 3C556: Invert MII power */
 667         if (inf_3c90x->is3c556) {
 668                 unsigned int tmp;
 669                 a3c90x_internal_SetWindow(inf_3c90x, winAddressing2);
 670                 tmp = inw(inf_3c90x->IOAddr + regResetOptions_2_w);
 671                 tmp |= 0x4000;
 672                 outw(tmp, inf_3c90x->IOAddr + regResetOptions_2_w);
 673         }
 674
 675         /* Copy MAC address into the NIC registers */
 676         a3c90x_internal_SetWindow(inf_3c90x, winAddressing2);
 677         for (i = 0; i < ETH_ALEN; i++)
 678                 outb(netdev->ll_addr[i],
 679                      inf_3c90x->IOAddr + regStationAddress_2_3w + i);
 680         for (i = 0; i < ETH_ALEN; i++)
 681                 outb(0, inf_3c90x->IOAddr + regStationMask_2_3w + i);
 682
 683         /* Read the media options register, print a message and set default
 684         * xcvr.
 685         *
 686         * Uses Media Option command on B revision, Reset Option on non-B
 687         * revision cards -- same register address
 688         */
 689         a3c90x_internal_SetWindow(inf_3c90x, winTxRxOptions3);
 690         mopt = inw(inf_3c90x->IOAddr + regResetMediaOptions_3_w);
 691
 692         /* mask out VCO bit that is defined as 10baseFL bit on B-rev cards */
 693         if (!inf_3c90x->isBrev) {
 694                 mopt &= 0x7F;
 695         }
 696
 697         DBG("Connectors present: ");
 698         c = 0;
 699         linktype = 0x0008;
 700         if (mopt & 0x01) {
 701                 DBG("%s100Base-T4", (c++) ? ", " : "");
 702                 linktype = linkMII;
 703         }
 704         if (mopt & 0x04) {
 705                 DBG("%s100Base-FX", (c++) ? ", " : "");
 706                 linktype = link100BaseFX;
 707         }
 708         if (mopt & 0x10) {
 709                 DBG("%s10Base-2", (c++) ? ", " : "");
 710                 linktype = link10Base2;
 711         }
 712         if (mopt & 0x20) {
 713                 DBG("%sAUI", (c++) ? ", " : "");
 714                 linktype = linkAUI;
 715         }
 716         if (mopt & 0x40) {
 717                 DBG("%sMII", (c++) ? ", " : "");
 718                 linktype = linkMII;
 719         }
 720         if ((mopt & 0xA) == 0xA) {
 721                 DBG("%s10Base-T / 100Base-TX", (c++) ? ", " : "");
 722                 linktype = linkAutoneg;
 723         } else if ((mopt & 0xA) == 0x2) {
 724                 DBG("%s100Base-TX", (c++) ? ", " : "");
 725                 linktype = linkAutoneg;
 726         } else if ((mopt & 0xA) == 0x8) {
 727                 DBG("%s10Base-T", (c++) ? ", " : "");
 728                 linktype = linkAutoneg;
 729         }
 730         DBG(".\n");
 731
 732         /* Determine transceiver type to use, depending on value stored in
 733         * eeprom 0x16
 734         */
 735         if (inf_3c90x->isBrev) {
 736                 if ((inf_3c90x->eeprom[0x16] & 0xFF00) == XCVR_MAGIC) {
 737                         /* User-defined */
 738                         linktype = inf_3c90x->eeprom[0x16] & 0x000F;
 739                 }
 740         } else {
 741                 /* I don't know what MII MAC only mode is!!! */
 742                 if (linktype == linkExternalMII) {
 743                         if (inf_3c90x->isBrev)
 744                                 DBG("WARNING: MII External MAC Mode only supported on B-revision " "cards!!!!\nFalling Back to MII Mode\n");
 745                         linktype = linkMII;
 746                 }
 747         }
 748
 749         /* enable DC converter for 10-Base-T */
 750         if (linktype == link10Base2) {
 751                 a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 752                                              cmdEnableDcConverter, 0);
 753         }
 754
 755         /* Set the link to the type we just determined. */
 756         a3c90x_internal_SetWindow(inf_3c90x, winTxRxOptions3);
 757         cfg = inl(inf_3c90x->IOAddr + regInternalConfig_3_l);
 758         cfg &= ~(0xF << 20);
 759         cfg |= (linktype << 20);
 760
 761         DBG("Setting internal cfg register: 0x%08X (linktype: 0x%02X)\n",
 762             cfg, linktype);
 763
 764         outl(cfg, inf_3c90x->IOAddr + regInternalConfig_3_l);
 765
 766         /* Now that we set the xcvr type, reset the Tx and Rx */
 767         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdTxReset, 0x00);
 768
 769         if (!inf_3c90x->isBrev)
 770                 outb(0x01, inf_3c90x->IOAddr + regTxFreeThresh_b);
 771
 772         /* Set the RX filter = receive only individual pkts & multicast & bcast. */
 773         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdSetRxFilter,
 774                                      0x01 + 0x02 + 0x04);
 775
 776
 777         /*
 778         * set Indication and Interrupt flags , acknowledge any IRQ's
 779         */
 780         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 781                                      cmdSetInterruptEnable,
 782          INT_TXCOMPLETE | INT_UPCOMPLETE);
 783         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 784                                      cmdSetIndicationEnable,
 785          INT_TXCOMPLETE | INT_UPCOMPLETE);
 786         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr,
 787                                      cmdAcknowledgeInterrupt, 0x661);
 788 }
 789
 790 /**
 791  * a3c90x_open - Routine to initialize the card. Initialize hardware,
 792  * allocate TX and RX ring, send RX ring address to the NIC.
 793  *
 794  * @v netdev    Network device info
 795  *
 796  * @ret Returns 0 on success, negative on failure
 797  */
 798 static int a3c90x_open(struct net_device *netdev)
 799 {
 800         int rc;
 801         struct INF_3C90X *inf_3c90x = netdev_priv(netdev);
 802
 803         DBGP("a3c90x_open\n");
 804
 805         a3c90x_hw_start(netdev);
 806
 807         rc = a3c90x_setup_tx_ring(inf_3c90x);
 808         if (rc != 0) {
 809                 DBG("Error setting up TX Ring\n");
 810                 goto error;
 811         }
 812
 813         rc = a3c90x_setup_rx_ring(inf_3c90x);
 814         if (rc != 0) {
 815                 DBG("Error setting up RX Ring\n");
 816                 goto error;
 817         }
 818
 819         /* send rx_ring address to NIC */
 820         outl(virt_to_bus(inf_3c90x->rx_ring),
 821              inf_3c90x->IOAddr + regUpListPtr_l);
 822
 823         /* enable packet transmission and reception */
 824         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdTxEnable, 0);
 825         a3c90x_internal_IssueCommand(inf_3c90x->IOAddr, cmdRxEnable, 0);
 826
 827         return 0;
 828
 829       error:
 830         a3c90x_free_resources(inf_3c90x);
 831         a3c90x_reset(inf_3c90x);
 832         return rc;
 833 }
 834
 835 /**
 836  * a3c90x_close - free()s TX and RX ring, disablex RX/TX, resets NIC
 837  *
 838  * @v netdev    Network device info
 839  */
 840 static void a3c90x_close(struct net_device *netdev)
 841 {
 842         struct INF_3C90X *inf_3c90x = netdev_priv(netdev);
 843
 844         DBGP("a3c90x_close\n");
 845
 846         outw(cmdRxDisable, inf_3c90x->IOAddr + regCommandIntStatus_w);
 847         outw(cmdTxDisable, inf_3c90x->IOAddr + regCommandIntStatus_w);
 848         a3c90x_reset(inf_3c90x);
 849         a3c90x_free_resources(inf_3c90x);
 850 }
 851
 852 static struct net_device_operations a3c90x_operations = {
 853         .open = a3c90x_open,
 854         .close = a3c90x_close,
 855         .poll = a3c90x_poll,
 856         .transmit = a3c90x_transmit,
 857         .irq = a3c90x_irq,
 858 };
 859
 860 /**
 861  * a3c90x_probe: exported routine to probe for the 3c905 card.
 862  * If this routine is called, the pci functions did find the
 863  * card.  We read the eeprom here and get the MAC address.
 864  * Initialization is done in a3c90x_open().
 865  *
 866  * @v pci       PCI device info
 867  * @ pci_id     PCI device IDs
 868  *
 869  * @ret rc      Returns 0 on success, negative on failure
 870  */
 871 static int a3c90x_probe(struct pci_device *pci,
 872                         const struct pci_device_id *pci_id __unused)
 873 {
 874
 875         struct net_device *netdev;
 876         struct INF_3C90X *inf_3c90x;
 877         unsigned char *HWAddr;
 878         int rc;
 879
 880         DBGP("a3c90x_probe\n");
 881
 882         if (pci->ioaddr == 0)
 883                 return -EINVAL;
 884
 885         netdev = alloc_etherdev(sizeof(*inf_3c90x));
 886         if (!netdev)
 887                 return -ENOMEM;
 888
 889         netdev_init(netdev, &a3c90x_operations);
 890         pci_set_drvdata(pci, netdev);
 891         netdev->dev = &pci->dev;
 892
 893         inf_3c90x = netdev_priv(netdev);
 894         memset(inf_3c90x, 0, sizeof(*inf_3c90x));
 895
 896         adjust_pci_device(pci);
 897
 898         inf_3c90x->is3c556 = (pci->device == 0x6055);
 899         inf_3c90x->IOAddr = pci->ioaddr;
 900         inf_3c90x->CurrentWindow = winNone;
 901
 902         inf_3c90x->isBrev = 1;
 903         switch (pci->device) {
 904         case 0x9000:            /* 10 Base TPO             */
 905         case 0x9001:            /* 10/100 T4               */
 906         case 0x9050:            /* 10/100 TPO              */
 907         case 0x9051:            /* 10 Base Combo           */
 908                 inf_3c90x->isBrev = 0;
 909                 break;
 910         }
 911
 912         DBG("[3c90x]: found NIC(0x%04X, 0x%04X), isBrev=%d, is3c556=%d\n",
 913             pci->vendor, pci->device, inf_3c90x->isBrev,
 914             inf_3c90x->is3c556);
 915
 916         /* initialize nvs device */
 917         inf_3c90x->nvs.word_len_log2 = 1;       /* word */
 918         inf_3c90x->nvs.size = (inf_3c90x->isBrev ? 0x20 : 0x17);
 919         inf_3c90x->nvs.block_size = 1;
 920         inf_3c90x->nvs.read = a3c90x_internal_ReadEeprom;
 921         inf_3c90x->nvs.write = a3c90x_internal_WriteEeprom;
 922
 923         /* reset NIC before accessing any data from it */
 924         a3c90x_reset(inf_3c90x);
 925
 926         /* load eeprom contents to inf_3c90x->eeprom */
 927         a3c90x_internal_ReadEepromContents(inf_3c90x);
 928
 929         HWAddr = netdev->ll_addr;
 930
 931         /* Retrieve the Hardware address */
 932         HWAddr[0] = inf_3c90x->eeprom[eepromHwAddrOffset + 0] >> 8;
 933         HWAddr[1] = inf_3c90x->eeprom[eepromHwAddrOffset + 0] & 0xFF;
 934         HWAddr[2] = inf_3c90x->eeprom[eepromHwAddrOffset + 1] >> 8;
 935         HWAddr[3] = inf_3c90x->eeprom[eepromHwAddrOffset + 1] & 0xFF;
 936         HWAddr[4] = inf_3c90x->eeprom[eepromHwAddrOffset + 2] >> 8;
 937         HWAddr[5] = inf_3c90x->eeprom[eepromHwAddrOffset + 2] & 0xFF;
 938
 939         /* we don't handle linkstates yet, so we're always up */
 940         netdev_link_up(netdev);
 941
 942         if ((rc = register_netdev(netdev)) != 0) {
 943                 DBG("3c90x: register_netdev() failed\n");
 944                 netdev_put(netdev);
 945                 return rc;
 946         }
 947
 948         return 0;
 949 }
 950
 951 static struct pci_device_id a3c90x_nics[] = {
 952 /* Original 90x revisions: */
 953         PCI_ROM(0x10b7, 0x6055, "3c556", "3C556"),      /* Huricane */
 954         PCI_ROM(0x10b7, 0x9000, "3c905-tpo", "3Com900-TPO"),    /* 10 Base TPO */
 955         PCI_ROM(0x10b7, 0x9001, "3c905-t4", "3Com900-Combo"),   /* 10/100 T4 */
 956         PCI_ROM(0x10b7, 0x9050, "3c905-tpo100", "3Com905-TX"),  /* 100 Base TX / 10/100 TPO */
 957         PCI_ROM(0x10b7, 0x9051, "3c905-combo", "3Com905-T4"),   /* 100 Base T4 / 10 Base Combo */
 958 /* Newer 90xB revisions: */
 959         PCI_ROM(0x10b7, 0x9004, "3c905b-tpo", "3Com900B-TPO"),  /* 10 Base TPO */
 960         PCI_ROM(0x10b7, 0x9005, "3c905b-combo", "3Com900B-Combo"),      /* 10 Base Combo */
 961         PCI_ROM(0x10b7, 0x9006, "3c905b-tpb2", "3Com900B-2/T"), /* 10 Base TP and Base2 */
 962         PCI_ROM(0x10b7, 0x900a, "3c905b-fl", "3Com900B-FL"),    /* 10 Base FL */
 963         PCI_ROM(0x10b7, 0x9055, "3c905b-tpo100", "3Com905B-TX"),        /* 10/100 TPO */
 964         PCI_ROM(0x10b7, 0x9056, "3c905b-t4", "3Com905B-T4"),    /* 10/100 T4 */
 965         PCI_ROM(0x10b7, 0x9058, "3c905b-9058", "3Com905B-9058"),        /* Cyclone 10/100/BNC */
 966         PCI_ROM(0x10b7, 0x905a, "3c905b-fx", "3Com905B-FL"),    /* 100 Base FX / 10 Base FX */
 967 /* Newer 90xC revision: */
 968         PCI_ROM(0x10b7, 0x9200, "3c905c-tpo", "3Com905C-TXM"),  /* 10/100 TPO (3C905C-TXM) */
 969         PCI_ROM(0x10b7, 0x9202, "3c920b-emb-ati", "3c920B-EMB-WNM (ATI Radeon 9100 IGP)"),      /* 3c920B-EMB-WNM (ATI Radeon 9100 IGP) */
 970         PCI_ROM(0x10b7, 0x9210, "3c920b-emb-wnm", "3Com20B-EMB WNM"),
 971         PCI_ROM(0x10b7, 0x9800, "3c980", "3Com980-Cyclone"),    /* Cyclone */
 972         PCI_ROM(0x10b7, 0x9805, "3c9805", "3Com9805"),  /* Dual Port Server Cyclone */
 973         PCI_ROM(0x10b7, 0x7646, "3csoho100-tx", "3CSOHO100-TX"),        /* Hurricane */
 974         PCI_ROM(0x10b7, 0x4500, "3c450", "3Com450 HomePNA Tornado"),
 975         PCI_ROM(0x10b7, 0x1201, "3c982a", "3Com982A"),
 976         PCI_ROM(0x10b7, 0x1202, "3c982b", "3Com982B"),
 977 };
 978
 979 struct pci_driver a3c90x_driver __pci_driver = {
 980         .ids = a3c90x_nics,
 981         .id_count = (sizeof(a3c90x_nics) / sizeof(a3c90x_nics[0])),
 982         .probe = a3c90x_probe,
 983         .remove = a3c90x_remove,
 984 };
 985
 986 /*
 987  * Local variables:
 988  *  c-basic-offset: 8
 989  *  c-indent-level: 8
 990  *  tab-width: 8
 991  * End:
 992  */