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         unsigned int *rx_buffer;
  87         unsigned int *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] = skb->len;
 416                         if (desc == NUMDESCRIPTORS-1)
 417                                 card->tx_buffer[4*desc+1] |= (1<<25);  /* bit 25: last descriptor of the ring */
 418
 419                         card->tx_buffer[4*desc+1] |= 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] = 0x80000000;
 426                         trigger_transmit(card);
 427                         if (((int)card->tx_buffer[nextdescriptor*4])<0) {       /* next descriptor is occupied... */
 428                                 netif_stop_queue(dev);
 429                         }
 430                         card->transmit_used = nextdescriptor;
 431                         leave("xircom-start_xmit - sent");
 432                         spin_unlock_irqrestore(&card->lock,flags);
 433                         return 0;
 434         }
 435
 436
 437
 438         /* Uh oh... no free descriptor... drop the packet */
 439         netif_stop_queue(dev);
 440         spin_unlock_irqrestore(&card->lock,flags);
 441         trigger_transmit(card);
 442
 443         return -EIO;
 444 }
 445
 446
 447
 448
 449 static int xircom_open(struct net_device *dev)
 450 {
 451         struct xircom_private *xp = netdev_priv(dev);
 452         int retval;
 453         enter("xircom_open");
 454         printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
 455         retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
 456         if (retval) {
 457                 leave("xircom_open - No IRQ");
 458                 return retval;
 459         }
 460
 461         xircom_up(xp);
 462         xp->open = 1;
 463         leave("xircom_open");
 464         return 0;
 465 }
 466
 467 static int xircom_close(struct net_device *dev)
 468 {
 469         struct xircom_private *card;
 470         unsigned long flags;
 471
 472         enter("xircom_close");
 473         card = netdev_priv(dev);
 474         netif_stop_queue(dev); /* we don't want new packets */
 475
 476
 477         spin_lock_irqsave(&card->lock,flags);
 478
 479         disable_all_interrupts(card);
 480 #if 0
 481         /* We can enable this again once we send dummy packets on ifconfig ethX up */
 482         deactivate_receiver(card);
 483         deactivate_transmitter(card);
 484 #endif
 485         remove_descriptors(card);
 486
 487         spin_unlock_irqrestore(&card->lock,flags);
 488
 489         card->open = 0;
 490         free_irq(dev->irq,dev);
 491
 492         leave("xircom_close");
 493
 494         return 0;
 495
 496 }
 497
 498
 499
 500 static struct net_device_stats *xircom_get_stats(struct net_device *dev)
 501 {
 502         struct xircom_private *card = netdev_priv(dev);
 503         return &card->stats;
 504 }
 505
 506
 507 #ifdef CONFIG_NET_POLL_CONTROLLER
 508 static void xircom_poll_controller(struct net_device *dev)
 509 {
 510         disable_irq(dev->irq);
 511         xircom_interrupt(dev->irq, dev);
 512         enable_irq(dev->irq);
 513 }
 514 #endif
 515
 516
 517 static void initialize_card(struct xircom_private *card)
 518 {
 519         unsigned int val;
 520         unsigned long flags;
 521         enter("initialize_card");
 522
 523
 524         spin_lock_irqsave(&card->lock, flags);
 525
 526         /* First: reset the card */
 527         val = inl(card->io_port + CSR0);
 528         val |= 0x01;            /* Software reset */
 529         outl(val, card->io_port + CSR0);
 530
 531         udelay(100);            /* give the card some time to reset */
 532
 533         val = inl(card->io_port + CSR0);
 534         val &= ~0x01;           /* disable Software reset */
 535         outl(val, card->io_port + CSR0);
 536
 537
 538         val = 0;                /* Value 0x00 is a safe and conservative value
 539                                    for the PCI configuration settings */
 540         outl(val, card->io_port + CSR0);
 541
 542
 543         disable_all_interrupts(card);
 544         deactivate_receiver(card);
 545         deactivate_transmitter(card);
 546
 547         spin_unlock_irqrestore(&card->lock, flags);
 548
 549         leave("initialize_card");
 550 }
 551
 552 /*
 553 trigger_transmit causes the card to check for frames to be transmitted.
 554 This is accomplished by writing to the CSR1 port. The documentation
 555 claims that the act of writing is sufficient and that the value is
 556 ignored; I chose zero.
 557 */
 558 static void trigger_transmit(struct xircom_private *card)
 559 {
 560         unsigned int val;
 561         enter("trigger_transmit");
 562
 563         val = 0;
 564         outl(val, card->io_port + CSR1);
 565
 566         leave("trigger_transmit");
 567 }
 568
 569 /*
 570 trigger_receive causes the card to check for empty frames in the
 571 descriptor list in which packets can be received.
 572 This is accomplished by writing to the CSR2 port. The documentation
 573 claims that the act of writing is sufficient and that the value is
 574 ignored; I chose zero.
 575 */
 576 static void trigger_receive(struct xircom_private *card)
 577 {
 578         unsigned int val;
 579         enter("trigger_receive");
 580
 581         val = 0;
 582         outl(val, card->io_port + CSR2);
 583
 584         leave("trigger_receive");
 585 }
 586
 587 /*
 588 setup_descriptors initializes the send and receive buffers to be valid
 589 descriptors and programs the addresses into the card.
 590 */
 591 static void setup_descriptors(struct xircom_private *card)
 592 {
 593         unsigned int val;
 594         unsigned int 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] = 0x80000000;
 608                 /* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
 609                 card->rx_buffer[i*4 + 1] = 1536;
 610                 if (i==NUMDESCRIPTORS-1)
 611                         card->rx_buffer[i*4 + 1] |= (1 << 25); /* bit 25 is "last descriptor" */
 612
 613                 /* Rx Descr2: address of the buffer
 614                    we store the buffer at the 2nd half of the page */
 615
 616                 address = (unsigned long) 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 = (unsigned long) card->rx_dma_handle;
 625         val = cpu_to_le32(address);
 626         outl(val, card->io_port + CSR3);        /* Receive descr list address */
 627
 628
 629         /* transmit descriptors */
 630         memset(card->tx_buffer, 0, 128);        /* clear the descriptors */
 631
 632         for (i=0;i<NUMDESCRIPTORS;i++ ) {
 633                 /* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
 634                 card->tx_buffer[i*4 + 0] = 0x00000000;
 635                 /* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
 636                 card->tx_buffer[i*4 + 1] = 1536;
 637                 if (i==NUMDESCRIPTORS-1)
 638                         card->tx_buffer[i*4 + 1] |= (1 << 25); /* bit 25 is "last descriptor" */
 639
 640                 /* Tx Descr2: address of the buffer
 641                    we store the buffer at the 2nd half of the page */
 642                 address = (unsigned long) card->tx_dma_handle;
 643                 card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
 644                 /* Tx Desc3: address of 2nd buffer -> 0 */
 645                 card->tx_buffer[i*4 + 3] = 0;
 646         }
 647
 648         wmb();
 649         /* wite the transmit descriptor ring to the card */
 650         address = (unsigned long) card->tx_dma_handle;
 651         val =cpu_to_le32(address);
 652         outl(val, card->io_port + CSR4);        /* xmit descr list address */
 653
 654         leave("setup_descriptors");
 655 }
 656
 657 /*
 658 remove_descriptors informs the card the descriptors are no longer
 659 valid by setting the address in the card to 0x00.
 660 */
 661 static void remove_descriptors(struct xircom_private *card)
 662 {
 663         unsigned int val;
 664         enter("remove_descriptors");
 665
 666         val = 0;
 667         outl(val, card->io_port + CSR3);        /* Receive descriptor address */
 668         outl(val, card->io_port + CSR4);        /* Send descriptor address */
 669
 670         leave("remove_descriptors");
 671 }
 672
 673 /*
 674 link_status_changed returns 1 if the card has indicated that
 675 the link status has changed. The new link status has to be read from CSR12.
 676
 677 This function also clears the status-bit.
 678 */
 679 static int link_status_changed(struct xircom_private *card)
 680 {
 681         unsigned int val;
 682         enter("link_status_changed");
 683
 684         val = inl(card->io_port + CSR5);        /* Status register */
 685
 686         if ((val & (1 << 27)) == 0) {   /* no change */
 687                 leave("link_status_changed - nochange");
 688                 return 0;
 689         }
 690
 691         /* clear the event by writing a 1 to the bit in the
 692            status register. */
 693         val = (1 << 27);
 694         outl(val, card->io_port + CSR5);
 695
 696         leave("link_status_changed - changed");
 697         return 1;
 698 }
 699
 700
 701 /*
 702 transmit_active returns 1 if the transmitter on the card is
 703 in a non-stopped state.
 704 */
 705 static int transmit_active(struct xircom_private *card)
 706 {
 707         unsigned int val;
 708         enter("transmit_active");
 709
 710         val = inl(card->io_port + CSR5);        /* Status register */
 711
 712         if ((val & (7 << 20)) == 0) {   /* transmitter disabled */
 713                 leave("transmit_active - inactive");
 714                 return 0;
 715         }
 716
 717         leave("transmit_active - active");
 718         return 1;
 719 }
 720
 721 /*
 722 receive_active returns 1 if the receiver on the card is
 723 in a non-stopped state.
 724 */
 725 static int receive_active(struct xircom_private *card)
 726 {
 727         unsigned int val;
 728         enter("receive_active");
 729
 730
 731         val = inl(card->io_port + CSR5);        /* Status register */
 732
 733         if ((val & (7 << 17)) == 0) {   /* receiver disabled */
 734                 leave("receive_active - inactive");
 735                 return 0;
 736         }
 737
 738         leave("receive_active - active");
 739         return 1;
 740 }
 741
 742 /*
 743 activate_receiver enables the receiver on the card.
 744 Before being allowed to active the receiver, the receiver
 745 must be completely de-activated. To achieve this,
 746 this code actually disables the receiver first; then it waits for the
 747 receiver to become inactive, then it activates the receiver and then
 748 it waits for the receiver to be active.
 749
 750 must be called with the lock held and interrupts disabled.
 751 */
 752 static void activate_receiver(struct xircom_private *card)
 753 {
 754         unsigned int val;
 755         int counter;
 756         enter("activate_receiver");
 757
 758
 759         val = inl(card->io_port + CSR6);        /* Operation mode */
 760
 761         /* If the "active" bit is set and the receiver is already
 762            active, no need to do the expensive thing */
 763         if ((val&2) && (receive_active(card)))
 764                 return;
 765
 766
 767         val = val & ~2;         /* disable the receiver */
 768         outl(val, card->io_port + CSR6);
 769
 770         counter = 10;
 771         while (counter > 0) {
 772                 if (!receive_active(card))
 773                         break;
 774                 /* wait a while */
 775                 udelay(50);
 776                 counter--;
 777                 if (counter <= 0)
 778                         printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
 779         }
 780
 781         /* enable the receiver */
 782         val = inl(card->io_port + CSR6);        /* Operation mode */
 783         val = val | 2;                          /* enable the receiver */
 784         outl(val, card->io_port + CSR6);
 785
 786         /* now wait for the card to activate again */
 787         counter = 10;
 788         while (counter > 0) {
 789                 if (receive_active(card))
 790                         break;
 791                 /* wait a while */
 792                 udelay(50);
 793                 counter--;
 794                 if (counter <= 0)
 795                         printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
 796         }
 797
 798         leave("activate_receiver");
 799 }
 800
 801 /*
 802 deactivate_receiver disables the receiver on the card.
 803 To achieve this this code disables the receiver first;
 804 then it waits for the receiver to become inactive.
 805
 806 must be called with the lock held and interrupts disabled.
 807 */
 808 static void deactivate_receiver(struct xircom_private *card)
 809 {
 810         unsigned int val;
 811         int counter;
 812         enter("deactivate_receiver");
 813
 814         val = inl(card->io_port + CSR6);        /* Operation mode */
 815         val = val & ~2;                         /* disable the receiver */
 816         outl(val, card->io_port + CSR6);
 817
 818         counter = 10;
 819         while (counter > 0) {
 820                 if (!receive_active(card))
 821                         break;
 822                 /* wait a while */
 823                 udelay(50);
 824                 counter--;
 825                 if (counter <= 0)
 826                         printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
 827         }
 828
 829
 830         leave("deactivate_receiver");
 831 }
 832
 833
 834 /*
 835 activate_transmitter enables the transmitter on the card.
 836 Before being allowed to active the transmitter, the transmitter
 837 must be completely de-activated. To achieve this,
 838 this code actually disables the transmitter first; then it waits for the
 839 transmitter to become inactive, then it activates the transmitter and then
 840 it waits for the transmitter to be active again.
 841
 842 must be called with the lock held and interrupts disabled.
 843 */
 844 static void activate_transmitter(struct xircom_private *card)
 845 {
 846         unsigned int val;
 847         int counter;
 848         enter("activate_transmitter");
 849
 850
 851         val = inl(card->io_port + CSR6);        /* Operation mode */
 852
 853         /* If the "active" bit is set and the receiver is already
 854            active, no need to do the expensive thing */
 855         if ((val&(1<<13)) && (transmit_active(card)))
 856                 return;
 857
 858         val = val & ~(1 << 13); /* disable the transmitter */
 859         outl(val, card->io_port + CSR6);
 860
 861         counter = 10;
 862         while (counter > 0) {
 863                 if (!transmit_active(card))
 864                         break;
 865                 /* wait a while */
 866                 udelay(50);
 867                 counter--;
 868                 if (counter <= 0)
 869                         printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
 870         }
 871
 872         /* enable the transmitter */
 873         val = inl(card->io_port + CSR6);        /* Operation mode */
 874         val = val | (1 << 13);  /* enable the transmitter */
 875         outl(val, card->io_port + CSR6);
 876
 877         /* now wait for the card to activate again */
 878         counter = 10;
 879         while (counter > 0) {
 880                 if (transmit_active(card))
 881                         break;
 882                 /* wait a while */
 883                 udelay(50);
 884                 counter--;
 885                 if (counter <= 0)
 886                         printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
 887         }
 888
 889         leave("activate_transmitter");
 890 }
 891
 892 /*
 893 deactivate_transmitter disables the transmitter on the card.
 894 To achieve this this code disables the transmitter first;
 895 then it waits for the transmitter to become inactive.
 896
 897 must be called with the lock held and interrupts disabled.
 898 */
 899 static void deactivate_transmitter(struct xircom_private *card)
 900 {
 901         unsigned int val;
 902         int counter;
 903         enter("deactivate_transmitter");
 904
 905         val = inl(card->io_port + CSR6);        /* Operation mode */
 906         val = val & ~2;         /* disable the transmitter */
 907         outl(val, card->io_port + CSR6);
 908
 909         counter = 20;
 910         while (counter > 0) {
 911                 if (!transmit_active(card))
 912                         break;
 913                 /* wait a while */
 914                 udelay(50);
 915                 counter--;
 916                 if (counter <= 0)
 917                         printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
 918         }
 919
 920
 921         leave("deactivate_transmitter");
 922 }
 923
 924
 925 /*
 926 enable_transmit_interrupt enables the transmit interrupt
 927
 928 must be called with the lock held and interrupts disabled.
 929 */
 930 static void enable_transmit_interrupt(struct xircom_private *card)
 931 {
 932         unsigned int val;
 933         enter("enable_transmit_interrupt");
 934
 935         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
 936         val |= 1;                               /* enable the transmit interrupt */
 937         outl(val, card->io_port + CSR7);
 938
 939         leave("enable_transmit_interrupt");
 940 }
 941
 942
 943 /*
 944 enable_receive_interrupt enables the receive interrupt
 945
 946 must be called with the lock held and interrupts disabled.
 947 */
 948 static void enable_receive_interrupt(struct xircom_private *card)
 949 {
 950         unsigned int val;
 951         enter("enable_receive_interrupt");
 952
 953         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
 954         val = val | (1 << 6);                   /* enable the receive interrupt */
 955         outl(val, card->io_port + CSR7);
 956
 957         leave("enable_receive_interrupt");
 958 }
 959
 960 /*
 961 enable_link_interrupt enables the link status change interrupt
 962
 963 must be called with the lock held and interrupts disabled.
 964 */
 965 static void enable_link_interrupt(struct xircom_private *card)
 966 {
 967         unsigned int val;
 968         enter("enable_link_interrupt");
 969
 970         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
 971         val = val | (1 << 27);                  /* enable the link status chage interrupt */
 972         outl(val, card->io_port + CSR7);
 973
 974         leave("enable_link_interrupt");
 975 }
 976
 977
 978
 979 /*
 980 disable_all_interrupts disables all interrupts
 981
 982 must be called with the lock held and interrupts disabled.
 983 */
 984 static void disable_all_interrupts(struct xircom_private *card)
 985 {
 986         unsigned int val;
 987         enter("enable_all_interrupts");
 988
 989         val = 0;                                /* disable all interrupts */
 990         outl(val, card->io_port + CSR7);
 991
 992         leave("disable_all_interrupts");
 993 }
 994
 995 /*
 996 enable_common_interrupts enables several weird interrupts
 997
 998 must be called with the lock held and interrupts disabled.
 999 */
1000 static void enable_common_interrupts(struct xircom_private *card)
1001 {
1002         unsigned int val;
1003         enter("enable_link_interrupt");
1004
1005         val = inl(card->io_port + CSR7);        /* Interrupt enable register */
1006         val |= (1<<16); /* Normal Interrupt Summary */
1007         val |= (1<<15); /* Abnormal Interrupt Summary */
1008         val |= (1<<13); /* Fatal bus error */
1009         val |= (1<<8);  /* Receive Process Stopped */
1010         val |= (1<<7);  /* Receive Buffer Unavailable */
1011         val |= (1<<5);  /* Transmit Underflow */
1012         val |= (1<<2);  /* Transmit Buffer Unavailable */
1013         val |= (1<<1);  /* Transmit Process Stopped */
1014         outl(val, card->io_port + CSR7);
1015
1016         leave("enable_link_interrupt");
1017 }
1018
1019 /*
1020 enable_promisc starts promisc mode
1021
1022 must be called with the lock held and interrupts disabled.
1023 */
1024 static int enable_promisc(struct xircom_private *card)
1025 {
1026         unsigned int val;
1027         enter("enable_promisc");
1028
1029         val = inl(card->io_port + CSR6);
1030         val = val | (1 << 6);
1031         outl(val, card->io_port + CSR6);
1032
1033         leave("enable_promisc");
1034         return 1;
1035 }
1036
1037
1038
1039
1040 /*
1041 link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
1042
1043 Must be called in locked state with interrupts disabled
1044 */
1045 static int link_status(struct xircom_private *card)
1046 {
1047         unsigned int val;
1048         enter("link_status");
1049
1050         val = inb(card->io_port + CSR12);
1051
1052         if (!(val&(1<<2)))  /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
1053                 return 10;
1054         if (!(val&(1<<1)))  /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
1055                 return 100;
1056
1057         /* If we get here -> no link at all */
1058
1059         leave("link_status");
1060         return 0;
1061 }
1062
1063
1064
1065
1066
1067 /*
1068   read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
1069
1070   This function will take the spinlock itself and can, as a result, not be called with the lock helt.
1071  */
1072 static void read_mac_address(struct xircom_private *card)
1073 {
1074         unsigned char j, tuple, link, data_id, data_count;
1075         unsigned long flags;
1076         int i;
1077         DECLARE_MAC_BUF(mac);
1078
1079         enter("read_mac_address");
1080
1081         spin_lock_irqsave(&card->lock, flags);
1082
1083         outl(1 << 12, card->io_port + CSR9);    /* enable boot rom access */
1084         for (i = 0x100; i < 0x1f7; i += link + 2) {
1085                 outl(i, card->io_port + CSR10);
1086                 tuple = inl(card->io_port + CSR9) & 0xff;
1087                 outl(i + 1, card->io_port + CSR10);
1088                 link = inl(card->io_port + CSR9) & 0xff;
1089                 outl(i + 2, card->io_port + CSR10);
1090                 data_id = inl(card->io_port + CSR9) & 0xff;
1091                 outl(i + 3, card->io_port + CSR10);
1092                 data_count = inl(card->io_port + CSR9) & 0xff;
1093                 if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
1094                         /*
1095                          * This is it.  We have the data we want.
1096                          */
1097                         for (j = 0; j < 6; j++) {
1098                                 outl(i + j + 4, card->io_port + CSR10);
1099                                 card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
1100                         }
1101                         break;
1102                 } else if (link == 0) {
1103                         break;
1104                 }
1105         }
1106         spin_unlock_irqrestore(&card->lock, flags);
1107         pr_debug(" %s\n", print_mac(mac, card->dev->dev_addr));
1108         leave("read_mac_address");
1109 }
1110
1111
1112 /*
1113  transceiver_voodoo() enables the external UTP plug thingy.
1114  it's called voodoo as I stole this code and cannot cross-reference
1115  it with the specification.
1116  */
1117 static void transceiver_voodoo(struct xircom_private *card)
1118 {
1119         unsigned long flags;
1120
1121         enter("transceiver_voodoo");
1122
1123         /* disable all powermanagement */
1124         pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1125
1126         setup_descriptors(card);
1127
1128         spin_lock_irqsave(&card->lock, flags);
1129
1130         outl(0x0008, card->io_port + CSR15);
1131         udelay(25);
1132         outl(0xa8050000, card->io_port + CSR15);
1133         udelay(25);
1134         outl(0xa00f0000, card->io_port + CSR15);
1135         udelay(25);
1136
1137         spin_unlock_irqrestore(&card->lock, flags);
1138
1139         netif_start_queue(card->dev);
1140         leave("transceiver_voodoo");
1141 }
1142
1143
1144 static void xircom_up(struct xircom_private *card)
1145 {
1146         unsigned long flags;
1147         int i;
1148
1149         enter("xircom_up");
1150
1151         /* disable all powermanagement */
1152         pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1153
1154         setup_descriptors(card);
1155
1156         spin_lock_irqsave(&card->lock, flags);
1157
1158
1159         enable_link_interrupt(card);
1160         enable_transmit_interrupt(card);
1161         enable_receive_interrupt(card);
1162         enable_common_interrupts(card);
1163         enable_promisc(card);
1164
1165         /* The card can have received packets already, read them away now */
1166         for (i=0;i<NUMDESCRIPTORS;i++)
1167                 investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
1168
1169
1170         spin_unlock_irqrestore(&card->lock, flags);
1171         trigger_receive(card);
1172         trigger_transmit(card);
1173         netif_start_queue(card->dev);
1174         leave("xircom_up");
1175 }
1176
1177 /* Bufferoffset is in BYTES */
1178 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
1179 {
1180                 int status;
1181
1182                 enter("investigate_read_descriptor");
1183                 status = card->rx_buffer[4*descnr];
1184
1185                 if ((status > 0)) {     /* packet received */
1186
1187                         /* TODO: discard error packets */
1188
1189                         short pkt_len = ((status >> 16) & 0x7ff) - 4;   /* minus 4, we don't want the CRC */
1190                         struct sk_buff *skb;
1191
1192                         if (pkt_len > 1518) {
1193                                 printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
1194                                 pkt_len = 1518;
1195                         }
1196
1197                         skb = dev_alloc_skb(pkt_len + 2);
1198                         if (skb == NULL) {
1199                                 card->stats.rx_dropped++;
1200                                 goto out;
1201                         }
1202                         skb_reserve(skb, 2);
1203                         skb_copy_to_linear_data(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len);
1204                         skb_put(skb, pkt_len);
1205                         skb->protocol = eth_type_trans(skb, dev);
1206                         netif_rx(skb);
1207                         dev->last_rx = jiffies;
1208                         card->stats.rx_packets++;
1209                         card->stats.rx_bytes += pkt_len;
1210
1211                       out:
1212                         /* give the buffer back to the card */
1213                         card->rx_buffer[4*descnr] =  0x80000000;
1214                         trigger_receive(card);
1215                 }
1216
1217                 leave("investigate_read_descriptor");
1218
1219 }
1220
1221
1222 /* Bufferoffset is in BYTES */
1223 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
1224 {
1225                 int status;
1226
1227                 enter("investigate_write_descriptor");
1228
1229                 status = card->tx_buffer[4*descnr];
1230 #if 0
1231                 if (status & 0x8000) {  /* Major error */
1232                         printk(KERN_ERR "Major transmit error status %x \n", status);
1233                         card->tx_buffer[4*descnr] = 0;
1234                         netif_wake_queue (dev);
1235                 }
1236 #endif
1237                 if (status > 0) {       /* bit 31 is 0 when done */
1238                         if (card->tx_skb[descnr]!=NULL) {
1239                                 card->stats.tx_bytes += card->tx_skb[descnr]->len;
1240                                 dev_kfree_skb_irq(card->tx_skb[descnr]);
1241                         }
1242                         card->tx_skb[descnr] = NULL;
1243                         /* Bit 8 in the status field is 1 if there was a collision */
1244                         if (status&(1<<8))
1245                                 card->stats.collisions++;
1246                         card->tx_buffer[4*descnr] = 0; /* descriptor is free again */
1247                         netif_wake_queue (dev);
1248                         card->stats.tx_packets++;
1249                 }
1250
1251                 leave("investigate_write_descriptor");
1252
1253 }
1254
1255
1256 static int __init xircom_init(void)
1257 {
1258         return pci_register_driver(&xircom_ops);
1259 }
1260
1261 static void __exit xircom_exit(void)
1262 {
1263         pci_unregister_driver(&xircom_ops);
1264 }
1265
1266 module_init(xircom_init)
1267 module_exit(xircom_exit)
1268