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