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