drivers/net/tulip/xircom_cb.c

   1 /*
   2  * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
   3  *
   4  * This software is (C) by the respective authors, and licensed under the GPL
   5  * License.
   6  *
   7  * Written by Arjan van de Ven for Red Hat, Inc.
   8  * Based on work by Jeff Garzik, Doug Ledford and Donald Becker
   9  *
  10  *      This software may be used and distributed according to the terms
  11  *      of the GNU General Public License, incorporated herein by reference.
  12  *
  13  *
  14  *      $Id: xircom_cb.c,v 1.33 2001/03/19 14:02:07 arjanv Exp $
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/string.h>
  20 #include <linux/errno.h>
  21 #include <linux/ioport.h>
  22 #include <linux/slab.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/pci.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/etherdevice.h>
  27 #include <linux/skbuff.h>
  28 #include <linux/delay.h>
  29 #include <linux/init.h>
  30 #include <linux/ethtool.h>
  31 #include <linux/bitops.h>
  32
  33 #include <asm/uaccess.h>
  34 #include <asm/io.h>
  35 #ifdef CONFIG_NET_POLL_CONTROLLER
  36 #include <asm/irq.h>
  37 #endif
  38
  39 #ifdef DEBUG
  40 #define enter(x)   printk("Enter: %s, %s line %i\n",x,__FILE__,__LINE__)
  41 #define leave(x)   printk("Leave: %s, %s line %i\n",x,__FILE__,__LINE__)
  42 #else
  43 #define enter(x)   do {} while (0)
  44 #define leave(x)   do {} while (0)
  45 #endif
  46
  47
  48 MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
  49 MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
  50 MODULE_LICENSE("GPL");
  51
  52
  53
  54 /* IO registers on the card, offsets */
  55 #define CSR0    0x00
  56 #define CSR1    0x08
  57 #define CSR2    0x10
  58 #define CSR3    0x18
  59 #define CSR4    0x20
  60 #define CSR5    0x28
  61 #define CSR6    0x30
  62 #define CSR7    0x38
  63 #define CSR8    0x40
  64 #define CSR9    0x48
  65 #define CSR10   0x50
  66 #define CSR11   0x58
  67 #define CSR12   0x60
  68 #define CSR13   0x68
  69 #define CSR14   0x70
  70 #define CSR15   0x78
  71 #define CSR16   0x80
  72
  73 /* PCI registers */
  74 #define PCI_POWERMGMT   0x40
  75
  76 /* Offsets of the buffers within the descriptor pages, in bytes */
  77
  78 #define NUMDESCRIPTORS 4
  79
  80 static int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
  81
  82
  83 struct xircom_private {
  84         /* Send and receive buffers, kernel-addressable and dma addressable forms */
  85
  86         __le32 *rx_buffer;
  87         __le32 *tx_buffer;
  88
  89         dma_addr_t rx_dma_handle;
  90         dma_addr_t tx_dma_handle;
  91
  92         struct sk_buff *tx_skb[4];
  93
  94         unsigned long io_port;
  95         int open;
  96
  97         /* transmit_used is the rotating counter that indicates which transmit
  98            descriptor has to be used next */
  99         int transmit_used;
 100
 101         /* Spinlock to serialize register operations.
 102            It must be helt while manipulating the following registers:
 103            CSR0, CSR6, CSR7, CSR9, CSR10, CSR15
 104          */
 105         spinlock_t lock;
 106
 107
 108         struct pci_dev *pdev;
 109         struct net_device *dev;
 110         struct net_device_stats stats;
 111 };
 112
 113
 114 /* Function prototypes */
 115 static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id);
 116 static void xircom_remove(struct pci_dev *pdev);
 117 static irqreturn_t xircom_interrupt(int irq, void *dev_instance);
 118 static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev);
 119 static int xircom_open(struct net_device *dev);
 120 static int xircom_close(struct net_device *dev);
 121 static void xircom_up(struct xircom_private *card);
 122 static struct net_device_stats *xircom_get_stats(struct net_device *dev);
 123 #ifdef CONFIG_NET_POLL_CONTROLLER
 124 static void xircom_poll_controller(struct net_device *dev);
 125 #endif
 126
 127 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
 128 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset);
 129 static void read_mac_address(struct xircom_private *card);
 130 static void transceiver_voodoo(struct xircom_private *card);
 131 static void initialize_card(struct xircom_private *card);
 132 static void trigger_transmit(struct xircom_private *card);
 133 static void trigger_receive(struct xircom_private *card);
 134 static void setup_descriptors(struct xircom_private *card);
 135 static void remove_descriptors(struct xircom_private *card);
 136 static int link_status_changed(struct xircom_private *card);
 137 static void activate_receiver(struct xircom_private *card);
 138 static void deactivate_receiver(struct xircom_private *card);
 139 static void activate_transmitter(struct xircom_private *card);
 140 static void deactivate_transmitter(struct xircom_private *card);
 141 static void enable_transmit_interrupt(struct xircom_private *card);
 142 static void enable_receive_interrupt(struct xircom_private *card);
 143 static void enable_link_interrupt(struct xircom_private *card);
 144 static void disable_all_interrupts(struct xircom_private *card);
 145 static int link_status(struct xircom_private *card);
 146
 147
 148
 149 static struct pci_device_id xircom_pci_table[] = {
 150         {0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID,},
 151         {0,},
 152 };
 153 MODULE_DEVICE_TABLE(pci, xircom_pci_table);
 154
 155 static struct pci_driver xircom_ops = {
 156         .name           = "xircom_cb",
 157         .id_table       = xircom_pci_table,
 158         .probe          = xircom_probe,
 159         .remove         = xircom_remove,
 160         .suspend =NULL,
 161         .resume =NULL
 162 };
 163
 164
 165 #ifdef DEBUG
 166 static void print_binary(unsigned int number)
 167 {
 168         int i,i2;
 169         char buffer[64];
 170         memset(buffer,0,64);
 171         i2=0;
 172         for (i=31;i>=0;i--) {
 173                 if (number & (1<<i))
 174                         buffer[i2++]='1';
 175                 else
 176                         buffer[i2++]='0';
 177                 if ((i&3)==0)
 178                         buffer[i2++]=' ';
 179         }
 180         printk("%s\n",buffer);
 181 }
 182 #endif
 183
 184 static void netdev_get_drvinfo(struct net_device *dev,
 185                                struct ethtool_drvinfo *info)
 186 {
 187         struct xircom_private *private = netdev_priv(dev);
 188
 189         strcpy(info->driver, "xircom_cb");
 190         strcpy(info->bus_info, pci_name(private->pdev));
 191 }
 192
 193 static const struct ethtool_ops netdev_ethtool_ops = {
 194         .get_drvinfo            = netdev_get_drvinfo,
 195 };
 196
 197 /* xircom_probe is the code that gets called on device insertion.
 198    it sets up the hardware and registers the device to the networklayer.
 199
 200    TODO: Send 1 or 2 "dummy" packets here as the card seems to discard the
 201          first two packets that get send, and pump hates that.
 202
 203  */
 204 static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 205 {
 206         struct net_device *dev = NULL;
 207         struct xircom_private *private;
 208         unsigned long flags;
 209         unsigned short tmp16;
 210         enter("xircom_probe");
 211
 212         /* First do the PCI initialisation */
 213
 214         if (pci_enable_device(pdev))
 215                 return -ENODEV;
 216
 217         /* disable all powermanagement */
 218         pci_write_config_dword(pdev, PCI_POWERMGMT, 0x0000);
 219
 220         pci_set_master(pdev); /* Why isn't this done by pci_enable_device ?*/
 221
 222         /* clear PCI status, if any */
 223         pci_read_config_word (pdev,PCI_STATUS, &tmp16);
 224         pci_write_config_word (pdev, PCI_STATUS,tmp16);
 225
 226         if (!request_region(pci_resource_start(pdev, 0), 128, "xircom_cb")) {
 227                 printk(KERN_ERR "xircom_probe: failed to allocate io-region\n");
 228                 return -ENODEV;
 229         }
 230
 231         /*
 232            Before changing the hardware, allocate the memory.
 233            This way, we can fail gracefully if not enough memory
 234            is available.
 235          */
 236         dev = alloc_etherdev(sizeof(struct xircom_private));
 237         if (!dev) {
 238                 printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
 239                 goto device_fail;
 240         }
 241         private = netdev_priv(dev);
 242
 243         /* Allocate the send/receive buffers */
 244         private->rx_buffer = pci_alloc_consistent(pdev,8192,&private->rx_dma_handle);
 245         if (private->rx_buffer == NULL) {
 246                 printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
 247                 goto rx_buf_fail;
 248         }
 249         private->tx_buffer = pci_alloc_consistent(pdev,8192,&private->tx_dma_handle);
 250         if (private->tx_buffer == NULL) {
 251                 printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
 252                 goto tx_buf_fail;
 253         }
 254
 255         SET_NETDEV_DEV(dev, &pdev->dev);
 256
 257
 258         private->dev = dev;
 259         private->pdev = pdev;
 260         private->io_port = pci_resource_start(pdev, 0);
 261         spin_lock_init(&private->lock);
 262         dev->irq = pdev->irq;
 263         dev->base_addr = private->io_port;
 264
 265         initialize_card(private);
 266         read_mac_address(private);
 267         setup_descriptors(private);
 268
 269         dev->open = &xircom_open;
 270         dev->hard_start_xmit = &xircom_start_xmit;
 271         dev->stop = &xircom_close;
 272         dev->get_stats = &xircom_get_stats;
 273 #ifdef CONFIG_NET_POLL_CONTROLLER
 274         dev->poll_controller = &xircom_poll_controller;
 275 #endif
 276         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 277         pci_set_drvdata(pdev, dev);
 278
 279         if (register_netdev(dev)) {
 280                 printk(KERN_ERR "xircom_probe: netdevice registration failed.\n");
 281                 goto reg_fail;
 282         }
 283
 284         printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, pdev->revision, pdev->irq);
 285         /* start the transmitter to get a heartbeat */
 286         /* TODO: send 2 dummy packets here */
 287         transceiver_voodoo(private);
 288
 289         spin_lock_irqsave(&private->lock,flags);
 290         activate_transmitter(private);
 291         activate_receiver(private);
 292         spin_unlock_irqrestore(&private->lock,flags);
 293
 294         trigger_receive(private);
 295
 296         leave("xircom_probe");
 297         return 0;
 298
 299 reg_fail:
 300         kfree(private->tx_buffer);
 301 tx_buf_fail:
 302         kfree(private->rx_buffer);
 303 rx_buf_fail:
 304         free_netdev(dev);
 305 device_fail:
 306         return -ENODEV;
 307 }
 308
 309
 310 /*
 311  xircom_remove is called on module-unload or on device-eject.
 312  it unregisters the irq, io-region and network device.
 313  Interrupts and such are already stopped in the "ifconfig ethX down"
 314  code.
 315  */
 316 static void __devexit xircom_remove(struct pci_dev *pdev)
 317 {
 318         struct net_device *dev = pci_get_drvdata(pdev);
 319         struct xircom_private *card = netdev_priv(dev);
 320
 321         enter("xircom_remove");
 322         pci_free_consistent(pdev,8192,card->rx_buffer,card->rx_dma_handle);
 323         pci_free_consistent(pdev,8192,card->tx_buffer,card->tx_dma_handle);
 324
 325         release_region(dev->base_addr, 128);
 326         unregister_netdev(dev);
 327         free_netdev(dev);
 328         pci_set_drvdata(pdev, NULL);
 329         leave("xircom_remove");
 330 }
 331
 332 static irqreturn_t xircom_interrupt(int irq, void *dev_instance)
 333 {
 334         struct net_device *dev = (struct net_device *) dev_instance;
 335         struct xircom_private *card = netdev_priv(dev);
 336         unsigned int status;
 337         int i;
 338
 339         enter("xircom_interrupt\n");
 340
 341         spin_lock(&card->lock);
 342         status = inl(card->io_port+CSR5);
 343
 344 #ifdef DEBUG
 345         print_binary(status);
 346         printk("tx status 0x%08x 0x%08x \n",card->tx_buffer[0],card->tx_buffer[4]);
 347         printk("rx status 0x%08x 0x%08x \n",card->rx_buffer[0],card->rx_buffer[4]);
 348 #endif
 349         /* Handle shared irq and hotplug */
 350         if (status == 0 || status == 0xffffffff) {
 351                 spin_unlock(&card->lock);
 352                 return IRQ_NONE;
 353         }
 354
 355         if (link_status_changed(card)) {
 356                 int newlink;
 357                 printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
 358                 newlink = link_status(card);
 359                 printk(KERN_INFO  "xircom_cb: Link is %i mbit \n",newlink);
 360                 if (newlink)
 361                         netif_carrier_on(dev);
 362                 else
 363                         netif_carrier_off(dev);
 364
 365         }
 366
 367         /* Clear all remaining interrupts */
 368         status |= 0xffffffff; /* FIXME: make this clear only the
 369                                         real existing bits */
 370         outl(status,card->io_port+CSR5);
 371
 372
 373         for (i=0;i<NUMDESCRIPTORS;i++)
 374                 investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
 375         for (i=0;i<NUMDESCRIPTORS;i++)
 376                 investigate_read_descriptor(dev,card,i,bufferoffsets[i]);
 377
 378
 379         spin_unlock(&card->lock);
 380         leave("xircom_interrupt");
 381         return IRQ_HANDLED;
 382 }
 383
 384 static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
 385 {
 386         struct xircom_private *card;
 387         unsigned long flags;
 388         int nextdescriptor;
 389         int desc;
 390         enter("xircom_start_xmit");
 391
 392         card = netdev_priv(dev);
 393         spin_lock_irqsave(&card->lock,flags);
 394
 395         /* First see if we can free some descriptors */
 396         for (desc=0;desc<NUMDESCRIPTORS;desc++)
 397                 investigate_write_descriptor(dev,card,desc,bufferoffsets[desc]);
 398
 399
 400         nextdescriptor = (card->transmit_used +1) % (NUMDESCRIPTORS);
 401         desc = card->transmit_used;
 402
 403         /* only send the packet if the descriptor is free */
 404         if (card->tx_buffer[4*desc]==0) {
 405                         /* Copy the packet data; zero the memory first as the card
 406                            sometimes sends more than you ask it to. */
 407
 408                         memset(&card->tx_buffer[bufferoffsets[desc]/4],0,1536);
 409                         skb_copy_from_linear_data(skb,
 410                                   &(card->tx_buffer[bufferoffsets[desc] / 4]),
 411                                                   skb->len);
 412                         /* FIXME: The specification tells us that the length we send HAS to be a multiple of
 413                            4 bytes. */
 414
 415                         card->tx_buffer[4*desc+1] = cpu_to_le32(skb->len);
 416                         if (desc == NUMDESCRIPTORS - 1) /* bit 25: last descriptor of the ring */
 417                                 card->tx_buffer[4*desc+1] |= cpu_to_le32(1<<25);
 418
 419                         card->tx_buffer[4*desc+1] |= cpu_to_le32(0xF0000000);
 420                                                  /* 0xF0... means want interrupts*/
 421                         card->tx_skb[desc] = skb;
 422
 423                         wmb();
 424                         /* This gives the descriptor to the card */
 425                         card->tx_buffer[4*desc] = cpu_to_le32(0x80000000);
 426                         trigger_transmit(card);
 427                         if (card->tx_buffer[nextdescriptor*4] & cpu_to_le32(0x8000000)) {
 428                                 /* next descriptor is occupied... */
 429                                 netif_stop_queue(dev);
 430                         }
 431                         card->transmit_used = nextdescriptor;
 432                         leave("xircom-start_xmit - sent");
 433                         spin_unlock_irqrestore(&card->lock,flags);
 434                         return 0;
 435         }
 436
 437
 438
 439         /* Uh oh... no free descriptor... drop the packet */
 440         netif_stop_queue(dev);
 441         spin_unlock_irqrestore(&card->lock,flags);
 442         trigger_transmit(card);
 443
 444         return NETDEV_TX_BUSY;
 445 }
 446
 447
 448
 449
 450 static int xircom_open(struct net_device *dev)
 451 {
 452         struct xircom_private *xp = netdev_priv(dev);
 453         int retval;
 454         enter("xircom_open");
 455         printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
 456         retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
 457         if (retval) {
 458                 leave("xircom_open - No IRQ");
 459                 return retval;
 460         }
 461
 462         xircom_up(xp);
 463         xp->open = 1;
 464         leave("xircom_open");
 465         return 0;
 466 }
 467
 468 static int xircom_close(struct net_device *dev)
 469 {
 470         struct xircom_private *card;
 471         unsigned long flags;
 472
 473         enter("xircom_close");
 474         card = netdev_priv(dev);
 475         netif_stop_queue(dev); /* we don't want new packets */
 476
 477
 478         spin_lock_irqsave(&card->lock,flags);
 479
 480         disable_all_interrupts(card);
 481 #if 0
 482         /* We can enable this again once we send dummy packets on ifconfig ethX up */
 483         deactivate_receiver(card);
 484         deactivate_transmitter(card);
 485 #endif
 486         remove_descriptors(card);
 487
 488         spin_unlock_irqrestore(&card->lock,flags);
 489
 490         card->open = 0;
 491         free_irq(dev->irq,dev);
 492
 493         leave("xircom_close");
 494
 495         return 0;
 496
 497 }
 498
 499
 500
 501 static struct net_device_stats *xircom_get_stats(struct net_device *dev)
 502 {
 503         struct xircom_private *card = netdev_priv(dev);
 504         return &card->stats;
 505 }
 506
 507
 508 #ifdef CONFIG_NET_POLL_CONTROLLER
 509 static void xircom_poll_controller(struct net_device *dev)
 510 {
 511         disable_irq(dev->irq);
 512         xircom_interrupt(dev->irq, dev);
 513         enable_irq(dev->irq);
 514 }
 515 #endif
 516
 517
 518 static void initialize_card(struct xircom_private *card)
 519 {
 520         unsigned int val;
 521         unsigned long flags;
 522         enter("initialize_card");
 523
 524
 525         spin_lock_irqsave(&card->lock, flags);
 526
 527         /* First: reset the card */
 528         val = inl(card->io_port + CSR0);
 529         val |= 0x01;            /* Software reset */
 530         outl(val, card->io_port + CSR0);
 531
 532         udelay(100);            /* give the card some time to reset */
 533
 534         val = inl(card->io_port + CSR0);
 535         val &= ~0x01;           /* disable Software reset */
 536         outl(val, card->io_port + CSR0);
 537
 538
 539         val = 0;                /* Value 0x00 is a safe and conservative value
 540                                    for the PCI configuration settings */
 541         outl(val, card->io_port + CSR0);
 542
 543
 544         disable_all_interrupts(card);
 545         deactivate_receiver(card);
 546         deactivate_transmitter(card);
 547
 548         spin_unlock_irqrestore(&card->lock, flags);
 549
 550         leave("initialize_card");
 551 }
 552
 553 /*
 554 trigger_transmit causes the card to check for frames to be transmitted.
 555 This is accomplished by writing to the CSR1 port. The documentation
 556 claims that the act of writing is sufficient and that the value is
 557 ignored; I chose zero.
 558 */
 559 static void trigger_transmit(struct xircom_private *card)
 560 {
 561         unsigned int val;
 562         enter("trigger_transmit");
 563
 564         val = 0;
 565         outl(val, card->io_port + CSR1);
 566
 567         leave("trigger_transmit");
 568 }
 569
 570 /*
 571 trigger_receive causes the card to check for empty frames in the
 572 descriptor list in which packets can be received.
 573 This is accomplished by writing to the CSR2 port. The documentation
 574 claims that the act of writing is sufficient and that the value is
 575 ignored; I chose zero.
 576 */
 577 static void trigger_receive(struct xircom_private *card)
 578 {
 579         unsigned int val;
 580         enter("trigger_receive");
 581
 582         val = 0;
 583         outl(val, card->io_port + CSR2);
 584
 585         leave("trigger_receive");
 586 }
 587
 588 /*
 589 setup_descriptors initializes the send and receive buffers to be valid
 590 descriptors and programs the addresses into the card.
 591 */
 592 static void setup_descriptors(struct xircom_private *card)
 593 {
 594         u32 address;
 595         int i;
 596         enter("setup_descriptors");
 597
 598
 599         BUG_ON(card->rx_buffer == NULL);
 600         BUG_ON(card->tx_buffer == NULL);
 601
 602         /* Receive descriptors */
 603         memset(card->rx_buffer, 0, 128);        /* clear the descriptors */
 604         for (i=0;i<NUMDESCRIPTORS;i++ ) {
 605
 606                 /* Rx Descr0: It's empty, let the card own it, no errors -> 0x80000000 */
 607                 card->rx_buffer[i*4 + 0] = cpu_to_le32(0x80000000);
 608                 /* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
 609                 card->rx_buffer[i*4 + 1] = cpu_to_le32(1536);
 610                 if (i == NUMDESCRIPTORS - 1) /* bit 25 is "last descriptor" */
 611                         card->rx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
 612
 613                 /* Rx Descr2: address of the buffer
 614                    we store the buffer at the 2nd half of the page */
 615
 616                 address = card->rx_dma_handle;
 617                 card->rx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
 618                 /* Rx Desc3: address of 2nd buffer -> 0 */
 619                 card->rx_buffer[i*4 + 3] = 0;
 620         }
 621
 622         wmb();
 623         /* Write the receive descriptor ring address to the card */
 624         address = card->rx_dma_handle;
 625         outl(address, card->io_port + CSR3);    /* Receive descr list address */
 626
 627
 628         /* transmit descriptors */
 629         memset(card->tx_buffer, 0, 128);        /* clear the descriptors */
 630
 631         for (i=0;i<NUMDESCRIPTORS;i++ ) {
 632                 /* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
 633                 card->tx_buffer[i*4 + 0] = 0x00000000;
 634                 /* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
 635                 card->tx_buffer[i*4 + 1] = cpu_to_le32(1536);
 636                 if (i == NUMDESCRIPTORS - 1) /* bit 25 is "last descriptor" */
 637                         card->tx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
 638
 639                 /* Tx Descr2: address of the buffer
 640                    we store the buffer at the 2nd half of the page */
 641                 address = card->tx_dma_handle;
 642                 card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
 643                 /* Tx Desc3: address of 2nd buffer -> 0 */
 644                 card->tx_buffer[i*4 + 3] = 0;
 645         }
 646
 647         wmb();
 648         /* wite the transmit descriptor ring to the card */
 649         address = card->tx_dma_handle;
 650         outl(address, card->io_port + CSR4);    /* xmit descr list address */
 651
 652         leave("setup_descriptors");
 653 }
 654
 655 /*
 656 remove_descriptors informs the card the descriptors are no longer
 657 valid by setting the address in the card to 0x00.
 658 */
 659 static void remove_descriptors(struct xircom_private *card)
 660 {
 661         unsigned int val;
 662         enter("remove_descriptors");
 663
 664         val = 0;
 665         outl(val, card->io_port + CSR3);        /* Receive descriptor address */
 666         outl(val, card->io_port + CSR4);        /* Send descriptor address */
 667
 668         leave("remove_descriptors");
 669 }
 670
 671 /*
 672 link_status_changed returns 1 if the card has indicated that
 673 the link status has changed. The new link status has to be read from CSR12.
 674
 675 This function also clears the status-bit.
 676 */
 677 static int link_status_changed(struct xircom_private *card)
 678 {
 679         unsigned int val;
 680         enter("link_status_changed");
 681
 682         val = inl(card->io_port + CSR5);        /* Status register */
 683
 684         if ((val & (1 << 27)) == 0) {   /* no change */
 685                 leave("link_status_changed - nochange");
 686                 return 0;
 687         }
 688
 689         /* clear the event by writing a 1 to the bit in the
 690            status register. */
 691         val = (1 << 27);
 692         outl(val, card->io_port + CSR5);
 693
 694         leave("link_status_changed - changed");
 695         return 1;
 696 }
 697
 698
 699 /*
 700 transmit_active returns 1 if the transmitter on the card is
 701 in a non-stopped state.
 702 */
 703 static int transmit_active(struct xircom_private *card)
 704 {
 705         unsigned int val;
 706         enter("transmit_active");
 707
 708         val = inl(card->io_port + CSR5);        /* Status register */
 709
 710         if ((val & (7 << 20)) == 0) {   /* transmitter disabled */
 711                 leave("transmit_active - inactive");
 712                 return 0;
 713         }
 714
 715         leave("transmit_active - active");
 716         return 1;
 717 }
 718
 719 /*
 720 receive_active returns 1 if the receiver on the card is
 721 in a non-stopped state.
 722 */
 723 static int receive_active(struct xircom_private *card)
 724 {
 725         unsigned int val;
 726         enter("receive_active");
 727
 728
 729         val = inl(card->io_port + CSR5);        /* Status register */
 730
 731         if ((val & (7 << 17)) == 0) {   /* receiver disabled */
 732                 leave("receive_active - inactive");
 733                 return 0;
 734         }
 735
 736         leave("receive_active - active");
 737         return 1;
 738 }
 739
 740 /*
 741 activate_receiver enables the receiver on the card.
 742 Before being allowed to active the receiver, the receiver
 743 must be completely de-activated. To achieve this,
 744 this code actually disables the receiver first; then it waits for the
 745 receiver to become inactive, then it activates the receiver and then
 746 it waits for the receiver to be active.
 747
 748 must be called with the lock held and interrupts disabled.
 749 */
 750 static void activate_receiver(struct xircom_private *card)
 751 {
 752         unsigned int val;
 753         int counter;
 754         enter("activate_receiver");
 755
 756
 757         val = inl(card->io_port + CSR6);        /* Operation mode */
 758
 759         /* If the "active" bit is set and the receiver is already
 760            active, no need to do the expensive thing */
 761         if ((val&2) && (receive_active(card)))
 762                 return;
 763
 764
 765         val = val & ~2;         /* disable the receiver */
 766         outl(val, card->io_port + CSR6);
 767
 768         counter = 10;
 769         while (counter > 0) {
 770                 if (!receive_active(card))
 771                         break;
 772                 /* wait a while */
 773                 udelay(50);
 774                 counter--;
 775                 if (counter <= 0)
 776                         printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
 777         }
 778
 779         /* enable the receiver */
 780         val = inl(card->io_port + CSR6);        /* Operation mode */
 781         val = val | 2;                          /* enable the receiver */
 782         outl(val, card->io_port + CSR6);
 783
 784         /* now wait for the card to activate again */
 785         counter = 10;
 786         while (counter > 0) {
 787                 if (receive_active(card))
 788                         break;
 789                 /* wait a while */
 790                 udelay(50);
 791                 counter--;
 792                 if (counter <= 0)
 793                         printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
 794         }
 795
 796         leave("activate_receiver");
 797 }
 798
 799 /*
 800 deactivate_receiver disables the receiver on the card.
 801 To achieve this this code disables the receiver first;
 802 then it waits for the receiver to become inactive.
 803
 804 must be called with the lock held and interrupts disabled.
 805 */
 806 static void deactivate_receiver(struct xircom_private *card)
 807 {
 808         unsigned int val;
 809         int counter;
 810         enter("deactivate_receiver");
 811
 812         val = inl(card->io_port + CSR6);        /* Operation mode */
 813         val = val & ~2;                         /* disable the receiver */
 814         outl(val, card->io_port + CSR6);
 815
 816         counter = 10;
 817         while (counter > 0) {
 818                 if (!receive_active(card))
 819                         break;
 820                 /* wait a while */
 821                 udelay(50);
 822                 counter--;
 823                 if (counter <= 0)
 824                         printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
 825         }
 826
 827
 828         leave("deactivate_receiver");
 829 }
 830
 831
 832 /*
 833 activate_transmitter enables the transmitter on the card.
 834 Before being allowed to active the transmitter, the transmitter
 835 must be completely de-activated. To achieve this,
 836 this code actually disables the transmitter first; then it waits for the
 837 transmitter to become inactive, then it activates the transmitter and then
 838 it waits for the transmitter to be active again.
 839
 840 must be called with the lock held and interrupts disabled.
 841 */
 842 static void activate_transmitter(struct xircom_private *card)
 843 {
 844         unsigned int val;
 845         int counter;
 846         enter("activate_transmitter");
 847
 848
 849         val = inl(card->io_port + CSR6);        /* Operation mode */
 850
 851         /* If the "active" bit is set and the receiver is already
 852            active, no need to do the expensive thing */
 853         if ((val&(1<<13)) && (transmit_active(card)))
 854                 return;
 855
 856         val = val & ~(1 << 13); /* disable the transmitter */
 857         outl(val, card->io_port + CSR6);
 858
 859         counter = 10;
 860         while (counter > 0) {
 861                 if (!transmit_active(card))
 862                         break;
 863                 /* wait a while */
 864                 udelay(50);
 865                 counter--;
 866                 if (counter <= 0)
 867                         printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
 868         }
 869
 870         /* enable the transmitter */
 871         val = inl(card->io_port + CSR6);        /* Operation mode */
 872         val = val | (1 << 13);  /* enable the transmitter */
 873         outl(val, card->io_port + CSR6);
 874
 875         /* now wait for the card to activate again */
 876         counter = 10;
 877         while (counter > 0) {
 878                 if (transmit_active(card))
 879                         break;
 880                 /* wait a while */
 881                 udelay(50);
 882                 counter--;
 883                 if (counter <= 0)
 884                         printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
 885         }
 886
 887         leave("activate_transmitter");
 888 }
 889
 890 /*
 891 deactivate_transmitter disables the transmitter on the card.
 892 To achieve this this code disables the transmitter first;
 893 then it waits for the transmitter to become inactive.
 894
 895 must be called with the lock held and interrupts disabled.
 896 */
 897 static void deactivate_transmitter(struct xircom_private *card)
 898 {
 899         unsigned int val;
 900         int counter;
 901         enter("deactivate_transmitter");
 902
 903         val = inl(card->io_port + CSR6);        /* Operation mode */
 904         val = val & ~2;         /* disable the transmitter */
 905         outl(val, card->io_port + CSR6);
 906
 907         counter = 20;
 908         while (counter > 0) {
 909                 if (!transmit_active(card))
 910                         break;
 911                 /* wait a while */
 912                 udelay(50);
 913                 counter--;
 914                 if (counter <= 0)
 915                         printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
 916         }
 917
 918
 919         leave("deactivate_transmitter");
 920 }
 921
 922
 923 /*
 924 enable_transmit_interrupt enables the transmit interrupt
 925
 926 must be called with the lock held and interrupts disabled.
 927 */
 928 static void enable_transmit_interrupt(struct xircom_private *card)
 929 {
 930         unsigned int val;
 931         enter("enable_transmit_interrupt");
 932
 933         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
 934         val |= 1;                               /* enable the transmit interrupt */
 935         outl(val, card->io_port + CSR7);
 936
 937         leave("enable_transmit_interrupt");
 938 }
 939
 940
 941 /*
 942 enable_receive_interrupt enables the receive interrupt
 943
 944 must be called with the lock held and interrupts disabled.
 945 */
 946 static void enable_receive_interrupt(struct xircom_private *card)
 947 {
 948         unsigned int val;
 949         enter("enable_receive_interrupt");
 950
 951         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
 952         val = val | (1 << 6);                   /* enable the receive interrupt */
 953         outl(val, card->io_port + CSR7);
 954
 955         leave("enable_receive_interrupt");
 956 }
 957
 958 /*
 959 enable_link_interrupt enables the link status change interrupt
 960
 961 must be called with the lock held and interrupts disabled.
 962 */
 963 static void enable_link_interrupt(struct xircom_private *card)
 964 {
 965         unsigned int val;
 966         enter("enable_link_interrupt");
 967
 968         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
 969         val = val | (1 << 27);                  /* enable the link status chage interrupt */
 970         outl(val, card->io_port + CSR7);
 971
 972         leave("enable_link_interrupt");
 973 }
 974
 975
 976
 977 /*
 978 disable_all_interrupts disables all interrupts
 979
 980 must be called with the lock held and interrupts disabled.
 981 */
 982 static void disable_all_interrupts(struct xircom_private *card)
 983 {
 984         unsigned int val;
 985         enter("enable_all_interrupts");
 986
 987         val = 0;                                /* disable all interrupts */
 988         outl(val, card->io_port + CSR7);
 989
 990         leave("disable_all_interrupts");
 991 }
 992
 993 /*
 994 enable_common_interrupts enables several weird interrupts
 995
 996 must be called with the lock held and interrupts disabled.
 997 */
 998 static void enable_common_interrupts(struct xircom_private *card)
 999 {
1000         unsigned int val;
1001         enter("enable_link_interrupt");
1002
1003         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
1004         val |= (1<<16); /* Normal Interrupt Summary */
1005         val |= (1<<15); /* Abnormal Interrupt Summary */
1006         val |= (1<<13); /* Fatal bus error */
1007         val |= (1<<8);  /* Receive Process Stopped */
1008         val |= (1<<7);  /* Receive Buffer Unavailable */
1009         val |= (1<<5);  /* Transmit Underflow */
1010         val |= (1<<2);  /* Transmit Buffer Unavailable */
1011         val |= (1<<1);  /* Transmit Process Stopped */
1012         outl(val, card->io_port + CSR7);
1013
1014         leave("enable_link_interrupt");
1015 }
1016
1017 /*
1018 enable_promisc starts promisc mode
1019
1020 must be called with the lock held and interrupts disabled.
1021 */
1022 static int enable_promisc(struct xircom_private *card)
1023 {
1024         unsigned int val;
1025         enter("enable_promisc");
1026
1027         val = inl(card->io_port + CSR6);
1028         val = val | (1 << 6);
1029         outl(val, card->io_port + CSR6);
1030
1031         leave("enable_promisc");
1032         return 1;
1033 }
1034
1035
1036
1037
1038 /*
1039 link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
1040
1041 Must be called in locked state with interrupts disabled
1042 */
1043 static int link_status(struct xircom_private *card)
1044 {
1045         unsigned int val;
1046         enter("link_status");
1047
1048         val = inb(card->io_port + CSR12);
1049
1050         if (!(val&(1<<2)))  /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
1051                 return 10;
1052         if (!(val&(1<<1)))  /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
1053                 return 100;
1054
1055         /* If we get here -> no link at all */
1056
1057         leave("link_status");
1058         return 0;
1059 }
1060
1061
1062
1063
1064
1065 /*
1066   read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
1067
1068   This function will take the spinlock itself and can, as a result, not be called with the lock helt.
1069  */
1070 static void read_mac_address(struct xircom_private *card)
1071 {
1072         unsigned char j, tuple, link, data_id, data_count;
1073         unsigned long flags;
1074         int i;
1075
1076         enter("read_mac_address");
1077
1078         spin_lock_irqsave(&card->lock, flags);
1079
1080         outl(1 << 12, card->io_port + CSR9);    /* enable boot rom access */
1081         for (i = 0x100; i < 0x1f7; i += link + 2) {
1082                 outl(i, card->io_port + CSR10);
1083                 tuple = inl(card->io_port + CSR9) & 0xff;
1084                 outl(i + 1, card->io_port + CSR10);
1085                 link = inl(card->io_port + CSR9) & 0xff;
1086                 outl(i + 2, card->io_port + CSR10);
1087                 data_id = inl(card->io_port + CSR9) & 0xff;
1088                 outl(i + 3, card->io_port + CSR10);
1089                 data_count = inl(card->io_port + CSR9) & 0xff;
1090                 if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
1091                         /*
1092                          * This is it.  We have the data we want.
1093                          */
1094                         for (j = 0; j < 6; j++) {
1095                                 outl(i + j + 4, card->io_port + CSR10);
1096                                 card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
1097                         }
1098                         break;
1099                 } else if (link == 0) {
1100                         break;
1101                 }
1102         }
1103         spin_unlock_irqrestore(&card->lock, flags);
1104         pr_debug(" %pM\n", card->dev->dev_addr);
1105         leave("read_mac_address");
1106 }
1107
1108
1109 /*
1110  transceiver_voodoo() enables the external UTP plug thingy.
1111  it's called voodoo as I stole this code and cannot cross-reference
1112  it with the specification.
1113  */
1114 static void transceiver_voodoo(struct xircom_private *card)
1115 {
1116         unsigned long flags;
1117
1118         enter("transceiver_voodoo");
1119
1120         /* disable all powermanagement */
1121         pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1122
1123         setup_descriptors(card);
1124
1125         spin_lock_irqsave(&card->lock, flags);
1126
1127         outl(0x0008, card->io_port + CSR15);
1128         udelay(25);
1129         outl(0xa8050000, card->io_port + CSR15);
1130         udelay(25);
1131         outl(0xa00f0000, card->io_port + CSR15);
1132         udelay(25);
1133
1134         spin_unlock_irqrestore(&card->lock, flags);
1135
1136         netif_start_queue(card->dev);
1137         leave("transceiver_voodoo");
1138 }
1139
1140
1141 static void xircom_up(struct xircom_private *card)
1142 {
1143         unsigned long flags;
1144         int i;
1145
1146         enter("xircom_up");
1147
1148         /* disable all powermanagement */
1149         pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1150
1151         setup_descriptors(card);
1152
1153         spin_lock_irqsave(&card->lock, flags);
1154
1155
1156         enable_link_interrupt(card);
1157         enable_transmit_interrupt(card);
1158         enable_receive_interrupt(card);
1159         enable_common_interrupts(card);
1160         enable_promisc(card);
1161
1162         /* The card can have received packets already, read them away now */
1163         for (i=0;i<NUMDESCRIPTORS;i++)
1164                 investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
1165
1166
1167         spin_unlock_irqrestore(&card->lock, flags);
1168         trigger_receive(card);
1169         trigger_transmit(card);
1170         netif_start_queue(card->dev);
1171         leave("xircom_up");
1172 }
1173
1174 /* Bufferoffset is in BYTES */
1175 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
1176 {
1177                 int status;
1178
1179                 enter("investigate_read_descriptor");
1180                 status = le32_to_cpu(card->rx_buffer[4*descnr]);
1181
1182                 if ((status > 0)) {     /* packet received */
1183
1184                         /* TODO: discard error packets */
1185
1186                         short pkt_len = ((status >> 16) & 0x7ff) - 4;   /* minus 4, we don't want the CRC */
1187                         struct sk_buff *skb;
1188
1189                         if (pkt_len > 1518) {
1190                                 printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
1191                                 pkt_len = 1518;
1192                         }
1193
1194                         skb = dev_alloc_skb(pkt_len + 2);
1195                         if (skb == NULL) {
1196                                 card->stats.rx_dropped++;
1197                                 goto out;
1198                         }
1199                         skb_reserve(skb, 2);
1200                         skb_copy_to_linear_data(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len);
1201                         skb_put(skb, pkt_len);
1202                         skb->protocol = eth_type_trans(skb, dev);
1203                         netif_rx(skb);
1204                         card->stats.rx_packets++;
1205                         card->stats.rx_bytes += pkt_len;
1206
1207                       out:
1208                         /* give the buffer back to the card */
1209                         card->rx_buffer[4*descnr] =  cpu_to_le32(0x80000000);
1210                         trigger_receive(card);
1211                 }
1212
1213                 leave("investigate_read_descriptor");
1214
1215 }
1216
1217
1218 /* Bufferoffset is in BYTES */
1219 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
1220 {
1221                 int status;
1222
1223                 enter("investigate_write_descriptor");
1224
1225                 status = le32_to_cpu(card->tx_buffer[4*descnr]);
1226 #if 0
1227                 if (status & 0x8000) {  /* Major error */
1228                         printk(KERN_ERR "Major transmit error status %x \n", status);
1229                         card->tx_buffer[4*descnr] = 0;
1230                         netif_wake_queue (dev);
1231                 }
1232 #endif
1233                 if (status > 0) {       /* bit 31 is 0 when done */
1234                         if (card->tx_skb[descnr]!=NULL) {
1235                                 card->stats.tx_bytes += card->tx_skb[descnr]->len;
1236                                 dev_kfree_skb_irq(card->tx_skb[descnr]);
1237                         }
1238                         card->tx_skb[descnr] = NULL;
1239                         /* Bit 8 in the status field is 1 if there was a collision */
1240                         if (status&(1<<8))
1241                                 card->stats.collisions++;
1242                         card->tx_buffer[4*descnr] = 0; /* descriptor is free again */
1243                         netif_wake_queue (dev);
1244                         card->stats.tx_packets++;
1245                 }
1246
1247                 leave("investigate_write_descriptor");
1248
1249 }
1250
1251
1252 static int __init xircom_init(void)
1253 {
1254         return pci_register_driver(&xircom_ops);
1255 }
1256
1257 static void __exit xircom_exit(void)
1258 {
1259         pci_unregister_driver(&xircom_ops);
1260 }
1261
1262 module_init(xircom_init)
1263 module_exit(xircom_exit)
1264