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