1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Network device driver for Cell Processor-Based Blade and Celleb platform 4 * 5 * (C) Copyright IBM Corp. 2005 6 * (C) Copyright 2006 TOSHIBA CORPORATION 7 * 8 * Authors : Utz Bacher <utz.bacher@de.ibm.com> 9 * Jens Osterkamp <Jens.Osterkamp@de.ibm.com> 10 */ 11 12 #include <linux/compiler.h> 13 #include <linux/crc32.h> 14 #include <linux/delay.h> 15 #include <linux/etherdevice.h> 16 #include <linux/ethtool.h> 17 #include <linux/firmware.h> 18 #include <linux/if_vlan.h> 19 #include <linux/in.h> 20 #include <linux/init.h> 21 #include <linux/interrupt.h> 22 #include <linux/gfp.h> 23 #include <linux/ioport.h> 24 #include <linux/ip.h> 25 #include <linux/kernel.h> 26 #include <linux/mii.h> 27 #include <linux/module.h> 28 #include <linux/netdevice.h> 29 #include <linux/device.h> 30 #include <linux/pci.h> 31 #include <linux/skbuff.h> 32 #include <linux/tcp.h> 33 #include <linux/types.h> 34 #include <linux/vmalloc.h> 35 #include <linux/wait.h> 36 #include <linux/workqueue.h> 37 #include <linux/bitops.h> 38 #include <linux/of.h> 39 #include <net/checksum.h> 40 41 #include "spider_net.h" 42 43 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com> and Jens Osterkamp " \ 44 "<Jens.Osterkamp@de.ibm.com>"); 45 MODULE_DESCRIPTION("Spider Southbridge Gigabit Ethernet driver"); 46 MODULE_LICENSE("GPL"); 47 MODULE_VERSION(VERSION); 48 MODULE_FIRMWARE(SPIDER_NET_FIRMWARE_NAME); 49 50 static int rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_DEFAULT; 51 static int tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_DEFAULT; 52 53 module_param(rx_descriptors, int, 0444); 54 module_param(tx_descriptors, int, 0444); 55 56 MODULE_PARM_DESC(rx_descriptors, "number of descriptors used " \ 57 "in rx chains"); 58 MODULE_PARM_DESC(tx_descriptors, "number of descriptors used " \ 59 "in tx chain"); 60 61 char spider_net_driver_name[] = "spidernet"; 62 63 static const struct pci_device_id spider_net_pci_tbl[] = { 64 { PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_SPIDER_NET, 65 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 66 { 0, } 67 }; 68 69 MODULE_DEVICE_TABLE(pci, spider_net_pci_tbl); 70 71 /** 72 * spider_net_read_reg - reads an SMMIO register of a card 73 * @card: device structure 74 * @reg: register to read from 75 * 76 * returns the content of the specified SMMIO register. 77 */ 78 static inline u32 79 spider_net_read_reg(struct spider_net_card *card, u32 reg) 80 { 81 /* We use the powerpc specific variants instead of readl_be() because 82 * we know spidernet is not a real PCI device and we can thus avoid the 83 * performance hit caused by the PCI workarounds. 84 */ 85 return in_be32(card->regs + reg); 86 } 87 88 /** 89 * spider_net_write_reg - writes to an SMMIO register of a card 90 * @card: device structure 91 * @reg: register to write to 92 * @value: value to write into the specified SMMIO register 93 */ 94 static inline void 95 spider_net_write_reg(struct spider_net_card *card, u32 reg, u32 value) 96 { 97 /* We use the powerpc specific variants instead of writel_be() because 98 * we know spidernet is not a real PCI device and we can thus avoid the 99 * performance hit caused by the PCI workarounds. 100 */ 101 out_be32(card->regs + reg, value); 102 } 103 104 /** 105 * spider_net_write_phy - write to phy register 106 * @netdev: adapter to be written to 107 * @mii_id: id of MII 108 * @reg: PHY register 109 * @val: value to be written to phy register 110 * 111 * spider_net_write_phy_register writes to an arbitrary PHY 112 * register via the spider GPCWOPCMD register. We assume the queue does 113 * not run full (not more than 15 commands outstanding). 114 **/ 115 static void 116 spider_net_write_phy(struct net_device *netdev, int mii_id, 117 int reg, int val) 118 { 119 struct spider_net_card *card = netdev_priv(netdev); 120 u32 writevalue; 121 122 writevalue = ((u32)mii_id << 21) | 123 ((u32)reg << 16) | ((u32)val); 124 125 spider_net_write_reg(card, SPIDER_NET_GPCWOPCMD, writevalue); 126 } 127 128 /** 129 * spider_net_read_phy - read from phy register 130 * @netdev: network device to be read from 131 * @mii_id: id of MII 132 * @reg: PHY register 133 * 134 * Returns value read from PHY register 135 * 136 * spider_net_write_phy reads from an arbitrary PHY 137 * register via the spider GPCROPCMD register 138 **/ 139 static int 140 spider_net_read_phy(struct net_device *netdev, int mii_id, int reg) 141 { 142 struct spider_net_card *card = netdev_priv(netdev); 143 u32 readvalue; 144 145 readvalue = ((u32)mii_id << 21) | ((u32)reg << 16); 146 spider_net_write_reg(card, SPIDER_NET_GPCROPCMD, readvalue); 147 148 /* we don't use semaphores to wait for an SPIDER_NET_GPROPCMPINT 149 * interrupt, as we poll for the completion of the read operation 150 * in spider_net_read_phy. Should take about 50 us 151 */ 152 do { 153 readvalue = spider_net_read_reg(card, SPIDER_NET_GPCROPCMD); 154 } while (readvalue & SPIDER_NET_GPREXEC); 155 156 readvalue &= SPIDER_NET_GPRDAT_MASK; 157 158 return readvalue; 159 } 160 161 /** 162 * spider_net_setup_aneg - initial auto-negotiation setup 163 * @card: device structure 164 **/ 165 static void 166 spider_net_setup_aneg(struct spider_net_card *card) 167 { 168 struct mii_phy *phy = &card->phy; 169 u32 advertise = 0; 170 u16 bmsr, estat; 171 172 bmsr = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR); 173 estat = spider_net_read_phy(card->netdev, phy->mii_id, MII_ESTATUS); 174 175 if (bmsr & BMSR_10HALF) 176 advertise |= ADVERTISED_10baseT_Half; 177 if (bmsr & BMSR_10FULL) 178 advertise |= ADVERTISED_10baseT_Full; 179 if (bmsr & BMSR_100HALF) 180 advertise |= ADVERTISED_100baseT_Half; 181 if (bmsr & BMSR_100FULL) 182 advertise |= ADVERTISED_100baseT_Full; 183 184 if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_TFULL)) 185 advertise |= SUPPORTED_1000baseT_Full; 186 if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_THALF)) 187 advertise |= SUPPORTED_1000baseT_Half; 188 189 sungem_phy_probe(phy, phy->mii_id); 190 phy->def->ops->setup_aneg(phy, advertise); 191 192 } 193 194 /** 195 * spider_net_rx_irq_off - switch off rx irq on this spider card 196 * @card: device structure 197 * 198 * switches off rx irq by masking them out in the GHIINTnMSK register 199 */ 200 static void 201 spider_net_rx_irq_off(struct spider_net_card *card) 202 { 203 u32 regvalue; 204 205 regvalue = SPIDER_NET_INT0_MASK_VALUE & (~SPIDER_NET_RXINT); 206 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, regvalue); 207 } 208 209 /** 210 * spider_net_rx_irq_on - switch on rx irq on this spider card 211 * @card: device structure 212 * 213 * switches on rx irq by enabling them in the GHIINTnMSK register 214 */ 215 static void 216 spider_net_rx_irq_on(struct spider_net_card *card) 217 { 218 u32 regvalue; 219 220 regvalue = SPIDER_NET_INT0_MASK_VALUE | SPIDER_NET_RXINT; 221 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, regvalue); 222 } 223 224 /** 225 * spider_net_set_promisc - sets the unicast address or the promiscuous mode 226 * @card: card structure 227 * 228 * spider_net_set_promisc sets the unicast destination address filter and 229 * thus either allows for non-promisc mode or promisc mode 230 */ 231 static void 232 spider_net_set_promisc(struct spider_net_card *card) 233 { 234 u32 macu, macl; 235 struct net_device *netdev = card->netdev; 236 237 if (netdev->flags & IFF_PROMISC) { 238 /* clear destination entry 0 */ 239 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, 0); 240 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, 0); 241 spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R, 242 SPIDER_NET_PROMISC_VALUE); 243 } else { 244 macu = netdev->dev_addr[0]; 245 macu <<= 8; 246 macu |= netdev->dev_addr[1]; 247 memcpy(&macl, &netdev->dev_addr[2], sizeof(macl)); 248 249 macu |= SPIDER_NET_UA_DESCR_VALUE; 250 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, macu); 251 spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, macl); 252 spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R, 253 SPIDER_NET_NONPROMISC_VALUE); 254 } 255 } 256 257 /** 258 * spider_net_get_descr_status -- returns the status of a descriptor 259 * @hwdescr: descriptor to look at 260 * 261 * returns the status as in the dmac_cmd_status field of the descriptor 262 */ 263 static inline int 264 spider_net_get_descr_status(struct spider_net_hw_descr *hwdescr) 265 { 266 return hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_IND_PROC_MASK; 267 } 268 269 /** 270 * spider_net_free_chain - free descriptor chain 271 * @card: card structure 272 * @chain: address of chain 273 * 274 */ 275 static void 276 spider_net_free_chain(struct spider_net_card *card, 277 struct spider_net_descr_chain *chain) 278 { 279 struct spider_net_descr *descr; 280 281 descr = chain->ring; 282 do { 283 descr->bus_addr = 0; 284 descr->hwdescr->next_descr_addr = 0; 285 descr = descr->next; 286 } while (descr != chain->ring); 287 288 dma_free_coherent(&card->pdev->dev, chain->num_desc * sizeof(struct spider_net_hw_descr), 289 chain->hwring, chain->dma_addr); 290 } 291 292 /** 293 * spider_net_init_chain - alloc and link descriptor chain 294 * @card: card structure 295 * @chain: address of chain 296 * 297 * We manage a circular list that mirrors the hardware structure, 298 * except that the hardware uses bus addresses. 299 * 300 * Returns 0 on success, <0 on failure 301 */ 302 static int 303 spider_net_init_chain(struct spider_net_card *card, 304 struct spider_net_descr_chain *chain) 305 { 306 int i; 307 struct spider_net_descr *descr; 308 struct spider_net_hw_descr *hwdescr; 309 dma_addr_t buf; 310 size_t alloc_size; 311 312 alloc_size = chain->num_desc * sizeof(struct spider_net_hw_descr); 313 314 chain->hwring = dma_alloc_coherent(&card->pdev->dev, alloc_size, 315 &chain->dma_addr, GFP_KERNEL); 316 if (!chain->hwring) 317 return -ENOMEM; 318 319 /* Set up the hardware pointers in each descriptor */ 320 descr = chain->ring; 321 hwdescr = chain->hwring; 322 buf = chain->dma_addr; 323 for (i=0; i < chain->num_desc; i++, descr++, hwdescr++) { 324 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 325 hwdescr->next_descr_addr = 0; 326 327 descr->hwdescr = hwdescr; 328 descr->bus_addr = buf; 329 descr->next = descr + 1; 330 descr->prev = descr - 1; 331 332 buf += sizeof(struct spider_net_hw_descr); 333 } 334 /* do actual circular list */ 335 (descr-1)->next = chain->ring; 336 chain->ring->prev = descr-1; 337 338 spin_lock_init(&chain->lock); 339 chain->head = chain->ring; 340 chain->tail = chain->ring; 341 return 0; 342 } 343 344 /** 345 * spider_net_free_rx_chain_contents - frees descr contents in rx chain 346 * @card: card structure 347 * 348 * returns 0 on success, <0 on failure 349 */ 350 static void 351 spider_net_free_rx_chain_contents(struct spider_net_card *card) 352 { 353 struct spider_net_descr *descr; 354 355 descr = card->rx_chain.head; 356 do { 357 if (descr->skb) { 358 dma_unmap_single(&card->pdev->dev, 359 descr->hwdescr->buf_addr, 360 SPIDER_NET_MAX_FRAME, 361 DMA_BIDIRECTIONAL); 362 dev_kfree_skb(descr->skb); 363 descr->skb = NULL; 364 } 365 descr = descr->next; 366 } while (descr != card->rx_chain.head); 367 } 368 369 /** 370 * spider_net_prepare_rx_descr - Reinitialize RX descriptor 371 * @card: card structure 372 * @descr: descriptor to re-init 373 * 374 * Return 0 on success, <0 on failure. 375 * 376 * Allocates a new rx skb, iommu-maps it and attaches it to the 377 * descriptor. Mark the descriptor as activated, ready-to-use. 378 */ 379 static int 380 spider_net_prepare_rx_descr(struct spider_net_card *card, 381 struct spider_net_descr *descr) 382 { 383 struct spider_net_hw_descr *hwdescr = descr->hwdescr; 384 dma_addr_t buf; 385 int offset; 386 int bufsize; 387 388 /* we need to round up the buffer size to a multiple of 128 */ 389 bufsize = (SPIDER_NET_MAX_FRAME + SPIDER_NET_RXBUF_ALIGN - 1) & 390 (~(SPIDER_NET_RXBUF_ALIGN - 1)); 391 392 /* and we need to have it 128 byte aligned, therefore we allocate a 393 * bit more 394 */ 395 /* allocate an skb */ 396 descr->skb = netdev_alloc_skb(card->netdev, 397 bufsize + SPIDER_NET_RXBUF_ALIGN - 1); 398 if (!descr->skb) { 399 if (netif_msg_rx_err(card) && net_ratelimit()) 400 dev_err(&card->netdev->dev, 401 "Not enough memory to allocate rx buffer\n"); 402 card->spider_stats.alloc_rx_skb_error++; 403 return -ENOMEM; 404 } 405 hwdescr->buf_size = bufsize; 406 hwdescr->result_size = 0; 407 hwdescr->valid_size = 0; 408 hwdescr->data_status = 0; 409 hwdescr->data_error = 0; 410 411 offset = ((unsigned long)descr->skb->data) & 412 (SPIDER_NET_RXBUF_ALIGN - 1); 413 if (offset) 414 skb_reserve(descr->skb, SPIDER_NET_RXBUF_ALIGN - offset); 415 /* iommu-map the skb */ 416 buf = dma_map_single(&card->pdev->dev, descr->skb->data, 417 SPIDER_NET_MAX_FRAME, DMA_FROM_DEVICE); 418 if (dma_mapping_error(&card->pdev->dev, buf)) { 419 dev_kfree_skb_any(descr->skb); 420 descr->skb = NULL; 421 if (netif_msg_rx_err(card) && net_ratelimit()) 422 dev_err(&card->netdev->dev, "Could not iommu-map rx buffer\n"); 423 card->spider_stats.rx_iommu_map_error++; 424 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 425 } else { 426 hwdescr->buf_addr = buf; 427 wmb(); 428 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_CARDOWNED | 429 SPIDER_NET_DMAC_NOINTR_COMPLETE; 430 } 431 432 return 0; 433 } 434 435 /** 436 * spider_net_enable_rxchtails - sets RX dmac chain tail addresses 437 * @card: card structure 438 * 439 * spider_net_enable_rxchtails sets the RX DMAC chain tail addresses in the 440 * chip by writing to the appropriate register. DMA is enabled in 441 * spider_net_enable_rxdmac. 442 */ 443 static inline void 444 spider_net_enable_rxchtails(struct spider_net_card *card) 445 { 446 /* assume chain is aligned correctly */ 447 spider_net_write_reg(card, SPIDER_NET_GDADCHA , 448 card->rx_chain.tail->bus_addr); 449 } 450 451 /** 452 * spider_net_enable_rxdmac - enables a receive DMA controller 453 * @card: card structure 454 * 455 * spider_net_enable_rxdmac enables the DMA controller by setting RX_DMA_EN 456 * in the GDADMACCNTR register 457 */ 458 static inline void 459 spider_net_enable_rxdmac(struct spider_net_card *card) 460 { 461 wmb(); 462 spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR, 463 SPIDER_NET_DMA_RX_VALUE); 464 } 465 466 /** 467 * spider_net_disable_rxdmac - disables the receive DMA controller 468 * @card: card structure 469 * 470 * spider_net_disable_rxdmac terminates processing on the DMA controller 471 * by turing off the DMA controller, with the force-end flag set. 472 */ 473 static inline void 474 spider_net_disable_rxdmac(struct spider_net_card *card) 475 { 476 spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR, 477 SPIDER_NET_DMA_RX_FEND_VALUE); 478 } 479 480 /** 481 * spider_net_refill_rx_chain - refills descriptors/skbs in the rx chains 482 * @card: card structure 483 * 484 * refills descriptors in the rx chain: allocates skbs and iommu-maps them. 485 */ 486 static void 487 spider_net_refill_rx_chain(struct spider_net_card *card) 488 { 489 struct spider_net_descr_chain *chain = &card->rx_chain; 490 unsigned long flags; 491 492 /* one context doing the refill (and a second context seeing that 493 * and omitting it) is ok. If called by NAPI, we'll be called again 494 * as spider_net_decode_one_descr is called several times. If some 495 * interrupt calls us, the NAPI is about to clean up anyway. 496 */ 497 if (!spin_trylock_irqsave(&chain->lock, flags)) 498 return; 499 500 while (spider_net_get_descr_status(chain->head->hwdescr) == 501 SPIDER_NET_DESCR_NOT_IN_USE) { 502 if (spider_net_prepare_rx_descr(card, chain->head)) 503 break; 504 chain->head = chain->head->next; 505 } 506 507 spin_unlock_irqrestore(&chain->lock, flags); 508 } 509 510 /** 511 * spider_net_alloc_rx_skbs - Allocates rx skbs in rx descriptor chains 512 * @card: card structure 513 * 514 * Returns 0 on success, <0 on failure. 515 */ 516 static int 517 spider_net_alloc_rx_skbs(struct spider_net_card *card) 518 { 519 struct spider_net_descr_chain *chain = &card->rx_chain; 520 struct spider_net_descr *start = chain->tail; 521 struct spider_net_descr *descr = start; 522 523 /* Link up the hardware chain pointers */ 524 do { 525 descr->prev->hwdescr->next_descr_addr = descr->bus_addr; 526 descr = descr->next; 527 } while (descr != start); 528 529 /* Put at least one buffer into the chain. if this fails, 530 * we've got a problem. If not, spider_net_refill_rx_chain 531 * will do the rest at the end of this function. 532 */ 533 if (spider_net_prepare_rx_descr(card, chain->head)) 534 goto error; 535 else 536 chain->head = chain->head->next; 537 538 /* This will allocate the rest of the rx buffers; 539 * if not, it's business as usual later on. 540 */ 541 spider_net_refill_rx_chain(card); 542 spider_net_enable_rxdmac(card); 543 return 0; 544 545 error: 546 spider_net_free_rx_chain_contents(card); 547 return -ENOMEM; 548 } 549 550 /** 551 * spider_net_get_multicast_hash - generates hash for multicast filter table 552 * @netdev: interface device structure 553 * @addr: multicast address 554 * 555 * returns the hash value. 556 * 557 * spider_net_get_multicast_hash calculates a hash value for a given multicast 558 * address, that is used to set the multicast filter tables 559 */ 560 static u8 561 spider_net_get_multicast_hash(struct net_device *netdev, __u8 *addr) 562 { 563 u32 crc; 564 u8 hash; 565 char addr_for_crc[ETH_ALEN] = { 0, }; 566 int i, bit; 567 568 for (i = 0; i < ETH_ALEN * 8; i++) { 569 bit = (addr[i / 8] >> (i % 8)) & 1; 570 addr_for_crc[ETH_ALEN - 1 - i / 8] += bit << (7 - (i % 8)); 571 } 572 573 crc = crc32_be(~0, addr_for_crc, netdev->addr_len); 574 575 hash = (crc >> 27); 576 hash <<= 3; 577 hash |= crc & 7; 578 hash &= 0xff; 579 580 return hash; 581 } 582 583 /** 584 * spider_net_set_multi - sets multicast addresses and promisc flags 585 * @netdev: interface device structure 586 * 587 * spider_net_set_multi configures multicast addresses as needed for the 588 * netdev interface. It also sets up multicast, allmulti and promisc 589 * flags appropriately 590 */ 591 static void 592 spider_net_set_multi(struct net_device *netdev) 593 { 594 struct netdev_hw_addr *ha; 595 u8 hash; 596 int i; 597 u32 reg; 598 struct spider_net_card *card = netdev_priv(netdev); 599 DECLARE_BITMAP(bitmask, SPIDER_NET_MULTICAST_HASHES); 600 601 spider_net_set_promisc(card); 602 603 if (netdev->flags & IFF_ALLMULTI) { 604 bitmap_fill(bitmask, SPIDER_NET_MULTICAST_HASHES); 605 goto write_hash; 606 } 607 608 bitmap_zero(bitmask, SPIDER_NET_MULTICAST_HASHES); 609 610 /* well, we know, what the broadcast hash value is: it's xfd 611 hash = spider_net_get_multicast_hash(netdev, netdev->broadcast); */ 612 __set_bit(0xfd, bitmask); 613 614 netdev_for_each_mc_addr(ha, netdev) { 615 hash = spider_net_get_multicast_hash(netdev, ha->addr); 616 __set_bit(hash, bitmask); 617 } 618 619 write_hash: 620 for (i = 0; i < SPIDER_NET_MULTICAST_HASHES / 4; i++) { 621 reg = 0; 622 if (test_bit(i * 4, bitmask)) 623 reg += 0x08; 624 reg <<= 8; 625 if (test_bit(i * 4 + 1, bitmask)) 626 reg += 0x08; 627 reg <<= 8; 628 if (test_bit(i * 4 + 2, bitmask)) 629 reg += 0x08; 630 reg <<= 8; 631 if (test_bit(i * 4 + 3, bitmask)) 632 reg += 0x08; 633 634 spider_net_write_reg(card, SPIDER_NET_GMRMHFILnR + i * 4, reg); 635 } 636 } 637 638 /** 639 * spider_net_prepare_tx_descr - fill tx descriptor with skb data 640 * @card: card structure 641 * @skb: packet to use 642 * 643 * returns 0 on success, <0 on failure. 644 * 645 * fills out the descriptor structure with skb data and len. Copies data, 646 * if needed (32bit DMA!) 647 */ 648 static int 649 spider_net_prepare_tx_descr(struct spider_net_card *card, 650 struct sk_buff *skb) 651 { 652 struct spider_net_descr_chain *chain = &card->tx_chain; 653 struct spider_net_descr *descr; 654 struct spider_net_hw_descr *hwdescr; 655 dma_addr_t buf; 656 unsigned long flags; 657 658 buf = dma_map_single(&card->pdev->dev, skb->data, skb->len, 659 DMA_TO_DEVICE); 660 if (dma_mapping_error(&card->pdev->dev, buf)) { 661 if (netif_msg_tx_err(card) && net_ratelimit()) 662 dev_err(&card->netdev->dev, "could not iommu-map packet (%p, %i). " 663 "Dropping packet\n", skb->data, skb->len); 664 card->spider_stats.tx_iommu_map_error++; 665 return -ENOMEM; 666 } 667 668 spin_lock_irqsave(&chain->lock, flags); 669 descr = card->tx_chain.head; 670 if (descr->next == chain->tail->prev) { 671 spin_unlock_irqrestore(&chain->lock, flags); 672 dma_unmap_single(&card->pdev->dev, buf, skb->len, 673 DMA_TO_DEVICE); 674 return -ENOMEM; 675 } 676 hwdescr = descr->hwdescr; 677 chain->head = descr->next; 678 679 descr->skb = skb; 680 hwdescr->buf_addr = buf; 681 hwdescr->buf_size = skb->len; 682 hwdescr->next_descr_addr = 0; 683 hwdescr->data_status = 0; 684 685 hwdescr->dmac_cmd_status = 686 SPIDER_NET_DESCR_CARDOWNED | SPIDER_NET_DMAC_TXFRMTL; 687 spin_unlock_irqrestore(&chain->lock, flags); 688 689 if (skb->ip_summed == CHECKSUM_PARTIAL) 690 switch (ip_hdr(skb)->protocol) { 691 case IPPROTO_TCP: 692 hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_TCP; 693 break; 694 case IPPROTO_UDP: 695 hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_UDP; 696 break; 697 } 698 699 /* Chain the bus address, so that the DMA engine finds this descr. */ 700 wmb(); 701 descr->prev->hwdescr->next_descr_addr = descr->bus_addr; 702 703 netif_trans_update(card->netdev); /* set netdev watchdog timer */ 704 return 0; 705 } 706 707 static int 708 spider_net_set_low_watermark(struct spider_net_card *card) 709 { 710 struct spider_net_descr *descr = card->tx_chain.tail; 711 struct spider_net_hw_descr *hwdescr; 712 unsigned long flags; 713 int status; 714 int cnt=0; 715 int i; 716 717 /* Measure the length of the queue. Measurement does not 718 * need to be precise -- does not need a lock. 719 */ 720 while (descr != card->tx_chain.head) { 721 status = descr->hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_NOT_IN_USE; 722 if (status == SPIDER_NET_DESCR_NOT_IN_USE) 723 break; 724 descr = descr->next; 725 cnt++; 726 } 727 728 /* If TX queue is short, don't even bother with interrupts */ 729 if (cnt < card->tx_chain.num_desc/4) 730 return cnt; 731 732 /* Set low-watermark 3/4th's of the way into the queue. */ 733 descr = card->tx_chain.tail; 734 cnt = (cnt*3)/4; 735 for (i=0;i<cnt; i++) 736 descr = descr->next; 737 738 /* Set the new watermark, clear the old watermark */ 739 spin_lock_irqsave(&card->tx_chain.lock, flags); 740 descr->hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_TXDESFLG; 741 if (card->low_watermark && card->low_watermark != descr) { 742 hwdescr = card->low_watermark->hwdescr; 743 hwdescr->dmac_cmd_status = 744 hwdescr->dmac_cmd_status & ~SPIDER_NET_DESCR_TXDESFLG; 745 } 746 card->low_watermark = descr; 747 spin_unlock_irqrestore(&card->tx_chain.lock, flags); 748 return cnt; 749 } 750 751 /** 752 * spider_net_release_tx_chain - processes sent tx descriptors 753 * @card: adapter structure 754 * @brutal: if set, don't care about whether descriptor seems to be in use 755 * 756 * returns 0 if the tx ring is empty, otherwise 1. 757 * 758 * spider_net_release_tx_chain releases the tx descriptors that spider has 759 * finished with (if non-brutal) or simply release tx descriptors (if brutal). 760 * If some other context is calling this function, we return 1 so that we're 761 * scheduled again (if we were scheduled) and will not lose initiative. 762 */ 763 static int 764 spider_net_release_tx_chain(struct spider_net_card *card, int brutal) 765 { 766 struct net_device *dev = card->netdev; 767 struct spider_net_descr_chain *chain = &card->tx_chain; 768 struct spider_net_descr *descr; 769 struct spider_net_hw_descr *hwdescr; 770 struct sk_buff *skb; 771 u32 buf_addr; 772 unsigned long flags; 773 int status; 774 775 while (1) { 776 spin_lock_irqsave(&chain->lock, flags); 777 if (chain->tail == chain->head) { 778 spin_unlock_irqrestore(&chain->lock, flags); 779 return 0; 780 } 781 descr = chain->tail; 782 hwdescr = descr->hwdescr; 783 784 status = spider_net_get_descr_status(hwdescr); 785 switch (status) { 786 case SPIDER_NET_DESCR_COMPLETE: 787 dev->stats.tx_packets++; 788 dev->stats.tx_bytes += descr->skb->len; 789 break; 790 791 case SPIDER_NET_DESCR_CARDOWNED: 792 if (!brutal) { 793 spin_unlock_irqrestore(&chain->lock, flags); 794 return 1; 795 } 796 797 /* fallthrough, if we release the descriptors 798 * brutally (then we don't care about 799 * SPIDER_NET_DESCR_CARDOWNED) 800 */ 801 fallthrough; 802 803 case SPIDER_NET_DESCR_RESPONSE_ERROR: 804 case SPIDER_NET_DESCR_PROTECTION_ERROR: 805 case SPIDER_NET_DESCR_FORCE_END: 806 if (netif_msg_tx_err(card)) 807 dev_err(&card->netdev->dev, "forcing end of tx descriptor " 808 "with status x%02x\n", status); 809 dev->stats.tx_errors++; 810 break; 811 812 default: 813 dev->stats.tx_dropped++; 814 if (!brutal) { 815 spin_unlock_irqrestore(&chain->lock, flags); 816 return 1; 817 } 818 } 819 820 chain->tail = descr->next; 821 hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_NOT_IN_USE; 822 skb = descr->skb; 823 descr->skb = NULL; 824 buf_addr = hwdescr->buf_addr; 825 spin_unlock_irqrestore(&chain->lock, flags); 826 827 /* unmap the skb */ 828 if (skb) { 829 dma_unmap_single(&card->pdev->dev, buf_addr, skb->len, 830 DMA_TO_DEVICE); 831 dev_consume_skb_any(skb); 832 } 833 } 834 return 0; 835 } 836 837 /** 838 * spider_net_kick_tx_dma - enables TX DMA processing 839 * @card: card structure 840 * 841 * This routine will start the transmit DMA running if 842 * it is not already running. This routine ned only be 843 * called when queueing a new packet to an empty tx queue. 844 * Writes the current tx chain head as start address 845 * of the tx descriptor chain and enables the transmission 846 * DMA engine. 847 */ 848 static inline void 849 spider_net_kick_tx_dma(struct spider_net_card *card) 850 { 851 struct spider_net_descr *descr; 852 853 if (spider_net_read_reg(card, SPIDER_NET_GDTDMACCNTR) & 854 SPIDER_NET_TX_DMA_EN) 855 goto out; 856 857 descr = card->tx_chain.tail; 858 for (;;) { 859 if (spider_net_get_descr_status(descr->hwdescr) == 860 SPIDER_NET_DESCR_CARDOWNED) { 861 spider_net_write_reg(card, SPIDER_NET_GDTDCHA, 862 descr->bus_addr); 863 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR, 864 SPIDER_NET_DMA_TX_VALUE); 865 break; 866 } 867 if (descr == card->tx_chain.head) 868 break; 869 descr = descr->next; 870 } 871 872 out: 873 mod_timer(&card->tx_timer, jiffies + SPIDER_NET_TX_TIMER); 874 } 875 876 /** 877 * spider_net_xmit - transmits a frame over the device 878 * @skb: packet to send out 879 * @netdev: interface device structure 880 * 881 * returns NETDEV_TX_OK on success, NETDEV_TX_BUSY on failure 882 */ 883 static netdev_tx_t 884 spider_net_xmit(struct sk_buff *skb, struct net_device *netdev) 885 { 886 int cnt; 887 struct spider_net_card *card = netdev_priv(netdev); 888 889 spider_net_release_tx_chain(card, 0); 890 891 if (spider_net_prepare_tx_descr(card, skb) != 0) { 892 netdev->stats.tx_dropped++; 893 netif_stop_queue(netdev); 894 return NETDEV_TX_BUSY; 895 } 896 897 cnt = spider_net_set_low_watermark(card); 898 if (cnt < 5) 899 spider_net_kick_tx_dma(card); 900 return NETDEV_TX_OK; 901 } 902 903 /** 904 * spider_net_cleanup_tx_ring - cleans up the TX ring 905 * @t: timer context used to obtain the pointer to net card data structure 906 * 907 * spider_net_cleanup_tx_ring is called by either the tx_timer 908 * or from the NAPI polling routine. 909 * This routine releases resources associted with transmitted 910 * packets, including updating the queue tail pointer. 911 */ 912 static void 913 spider_net_cleanup_tx_ring(struct timer_list *t) 914 { 915 struct spider_net_card *card = from_timer(card, t, tx_timer); 916 if ((spider_net_release_tx_chain(card, 0) != 0) && 917 (card->netdev->flags & IFF_UP)) { 918 spider_net_kick_tx_dma(card); 919 netif_wake_queue(card->netdev); 920 } 921 } 922 923 /** 924 * spider_net_do_ioctl - called for device ioctls 925 * @netdev: interface device structure 926 * @ifr: request parameter structure for ioctl 927 * @cmd: command code for ioctl 928 * 929 * returns 0 on success, <0 on failure. Currently, we have no special ioctls. 930 * -EOPNOTSUPP is returned, if an unknown ioctl was requested 931 */ 932 static int 933 spider_net_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 934 { 935 switch (cmd) { 936 default: 937 return -EOPNOTSUPP; 938 } 939 } 940 941 /** 942 * spider_net_pass_skb_up - takes an skb from a descriptor and passes it on 943 * @descr: descriptor to process 944 * @card: card structure 945 * 946 * Fills out skb structure and passes the data to the stack. 947 * The descriptor state is not changed. 948 */ 949 static void 950 spider_net_pass_skb_up(struct spider_net_descr *descr, 951 struct spider_net_card *card) 952 { 953 struct spider_net_hw_descr *hwdescr = descr->hwdescr; 954 struct sk_buff *skb = descr->skb; 955 struct net_device *netdev = card->netdev; 956 u32 data_status = hwdescr->data_status; 957 u32 data_error = hwdescr->data_error; 958 959 skb_put(skb, hwdescr->valid_size); 960 961 /* the card seems to add 2 bytes of junk in front 962 * of the ethernet frame 963 */ 964 #define SPIDER_MISALIGN 2 965 skb_pull(skb, SPIDER_MISALIGN); 966 skb->protocol = eth_type_trans(skb, netdev); 967 968 /* checksum offload */ 969 skb_checksum_none_assert(skb); 970 if (netdev->features & NETIF_F_RXCSUM) { 971 if ( ( (data_status & SPIDER_NET_DATA_STATUS_CKSUM_MASK) == 972 SPIDER_NET_DATA_STATUS_CKSUM_MASK) && 973 !(data_error & SPIDER_NET_DATA_ERR_CKSUM_MASK)) 974 skb->ip_summed = CHECKSUM_UNNECESSARY; 975 } 976 977 if (data_status & SPIDER_NET_VLAN_PACKET) { 978 /* further enhancements: HW-accel VLAN */ 979 } 980 981 /* update netdevice statistics */ 982 netdev->stats.rx_packets++; 983 netdev->stats.rx_bytes += skb->len; 984 985 /* pass skb up to stack */ 986 netif_receive_skb(skb); 987 } 988 989 static void show_rx_chain(struct spider_net_card *card) 990 { 991 struct spider_net_descr_chain *chain = &card->rx_chain; 992 struct spider_net_descr *start= chain->tail; 993 struct spider_net_descr *descr= start; 994 struct spider_net_hw_descr *hwd = start->hwdescr; 995 struct device *dev = &card->netdev->dev; 996 u32 curr_desc, next_desc; 997 int status; 998 999 int tot = 0; 1000 int cnt = 0; 1001 int off = start - chain->ring; 1002 int cstat = hwd->dmac_cmd_status; 1003 1004 dev_info(dev, "Total number of descrs=%d\n", 1005 chain->num_desc); 1006 dev_info(dev, "Chain tail located at descr=%d, status=0x%x\n", 1007 off, cstat); 1008 1009 curr_desc = spider_net_read_reg(card, SPIDER_NET_GDACTDPA); 1010 next_desc = spider_net_read_reg(card, SPIDER_NET_GDACNEXTDA); 1011 1012 status = cstat; 1013 do 1014 { 1015 hwd = descr->hwdescr; 1016 off = descr - chain->ring; 1017 status = hwd->dmac_cmd_status; 1018 1019 if (descr == chain->head) 1020 dev_info(dev, "Chain head is at %d, head status=0x%x\n", 1021 off, status); 1022 1023 if (curr_desc == descr->bus_addr) 1024 dev_info(dev, "HW curr desc (GDACTDPA) is at %d, status=0x%x\n", 1025 off, status); 1026 1027 if (next_desc == descr->bus_addr) 1028 dev_info(dev, "HW next desc (GDACNEXTDA) is at %d, status=0x%x\n", 1029 off, status); 1030 1031 if (hwd->next_descr_addr == 0) 1032 dev_info(dev, "chain is cut at %d\n", off); 1033 1034 if (cstat != status) { 1035 int from = (chain->num_desc + off - cnt) % chain->num_desc; 1036 int to = (chain->num_desc + off - 1) % chain->num_desc; 1037 dev_info(dev, "Have %d (from %d to %d) descrs " 1038 "with stat=0x%08x\n", cnt, from, to, cstat); 1039 cstat = status; 1040 cnt = 0; 1041 } 1042 1043 cnt ++; 1044 tot ++; 1045 descr = descr->next; 1046 } while (descr != start); 1047 1048 dev_info(dev, "Last %d descrs with stat=0x%08x " 1049 "for a total of %d descrs\n", cnt, cstat, tot); 1050 1051 #ifdef DEBUG 1052 /* Now dump the whole ring */ 1053 descr = start; 1054 do 1055 { 1056 struct spider_net_hw_descr *hwd = descr->hwdescr; 1057 status = spider_net_get_descr_status(hwd); 1058 cnt = descr - chain->ring; 1059 dev_info(dev, "Descr %d stat=0x%08x skb=%p\n", 1060 cnt, status, descr->skb); 1061 dev_info(dev, "bus addr=%08x buf addr=%08x sz=%d\n", 1062 descr->bus_addr, hwd->buf_addr, hwd->buf_size); 1063 dev_info(dev, "next=%08x result sz=%d valid sz=%d\n", 1064 hwd->next_descr_addr, hwd->result_size, 1065 hwd->valid_size); 1066 dev_info(dev, "dmac=%08x data stat=%08x data err=%08x\n", 1067 hwd->dmac_cmd_status, hwd->data_status, 1068 hwd->data_error); 1069 dev_info(dev, "\n"); 1070 1071 descr = descr->next; 1072 } while (descr != start); 1073 #endif 1074 1075 } 1076 1077 /** 1078 * spider_net_resync_head_ptr - Advance head ptr past empty descrs 1079 * @card: card structure 1080 * 1081 * If the driver fails to keep up and empty the queue, then the 1082 * hardware wil run out of room to put incoming packets. This 1083 * will cause the hardware to skip descrs that are full (instead 1084 * of halting/retrying). Thus, once the driver runs, it wil need 1085 * to "catch up" to where the hardware chain pointer is at. 1086 */ 1087 static void spider_net_resync_head_ptr(struct spider_net_card *card) 1088 { 1089 unsigned long flags; 1090 struct spider_net_descr_chain *chain = &card->rx_chain; 1091 struct spider_net_descr *descr; 1092 int i, status; 1093 1094 /* Advance head pointer past any empty descrs */ 1095 descr = chain->head; 1096 status = spider_net_get_descr_status(descr->hwdescr); 1097 1098 if (status == SPIDER_NET_DESCR_NOT_IN_USE) 1099 return; 1100 1101 spin_lock_irqsave(&chain->lock, flags); 1102 1103 descr = chain->head; 1104 status = spider_net_get_descr_status(descr->hwdescr); 1105 for (i=0; i<chain->num_desc; i++) { 1106 if (status != SPIDER_NET_DESCR_CARDOWNED) break; 1107 descr = descr->next; 1108 status = spider_net_get_descr_status(descr->hwdescr); 1109 } 1110 chain->head = descr; 1111 1112 spin_unlock_irqrestore(&chain->lock, flags); 1113 } 1114 1115 static int spider_net_resync_tail_ptr(struct spider_net_card *card) 1116 { 1117 struct spider_net_descr_chain *chain = &card->rx_chain; 1118 struct spider_net_descr *descr; 1119 int i, status; 1120 1121 /* Advance tail pointer past any empty and reaped descrs */ 1122 descr = chain->tail; 1123 status = spider_net_get_descr_status(descr->hwdescr); 1124 1125 for (i=0; i<chain->num_desc; i++) { 1126 if ((status != SPIDER_NET_DESCR_CARDOWNED) && 1127 (status != SPIDER_NET_DESCR_NOT_IN_USE)) break; 1128 descr = descr->next; 1129 status = spider_net_get_descr_status(descr->hwdescr); 1130 } 1131 chain->tail = descr; 1132 1133 if ((i == chain->num_desc) || (i == 0)) 1134 return 1; 1135 return 0; 1136 } 1137 1138 /** 1139 * spider_net_decode_one_descr - processes an RX descriptor 1140 * @card: card structure 1141 * 1142 * Returns 1 if a packet has been sent to the stack, otherwise 0. 1143 * 1144 * Processes an RX descriptor by iommu-unmapping the data buffer 1145 * and passing the packet up to the stack. This function is called 1146 * in softirq context, e.g. either bottom half from interrupt or 1147 * NAPI polling context. 1148 */ 1149 static int 1150 spider_net_decode_one_descr(struct spider_net_card *card) 1151 { 1152 struct net_device *dev = card->netdev; 1153 struct spider_net_descr_chain *chain = &card->rx_chain; 1154 struct spider_net_descr *descr = chain->tail; 1155 struct spider_net_hw_descr *hwdescr = descr->hwdescr; 1156 u32 hw_buf_addr; 1157 int status; 1158 1159 status = spider_net_get_descr_status(hwdescr); 1160 1161 /* Nothing in the descriptor, or ring must be empty */ 1162 if ((status == SPIDER_NET_DESCR_CARDOWNED) || 1163 (status == SPIDER_NET_DESCR_NOT_IN_USE)) 1164 return 0; 1165 1166 /* descriptor definitively used -- move on tail */ 1167 chain->tail = descr->next; 1168 1169 /* unmap descriptor */ 1170 hw_buf_addr = hwdescr->buf_addr; 1171 hwdescr->buf_addr = 0xffffffff; 1172 dma_unmap_single(&card->pdev->dev, hw_buf_addr, SPIDER_NET_MAX_FRAME, 1173 DMA_FROM_DEVICE); 1174 1175 if ( (status == SPIDER_NET_DESCR_RESPONSE_ERROR) || 1176 (status == SPIDER_NET_DESCR_PROTECTION_ERROR) || 1177 (status == SPIDER_NET_DESCR_FORCE_END) ) { 1178 if (netif_msg_rx_err(card)) 1179 dev_err(&dev->dev, 1180 "dropping RX descriptor with state %d\n", status); 1181 dev->stats.rx_dropped++; 1182 goto bad_desc; 1183 } 1184 1185 if ( (status != SPIDER_NET_DESCR_COMPLETE) && 1186 (status != SPIDER_NET_DESCR_FRAME_END) ) { 1187 if (netif_msg_rx_err(card)) 1188 dev_err(&card->netdev->dev, 1189 "RX descriptor with unknown state %d\n", status); 1190 card->spider_stats.rx_desc_unk_state++; 1191 goto bad_desc; 1192 } 1193 1194 /* The cases we'll throw away the packet immediately */ 1195 if (hwdescr->data_error & SPIDER_NET_DESTROY_RX_FLAGS) { 1196 if (netif_msg_rx_err(card)) 1197 dev_err(&card->netdev->dev, 1198 "error in received descriptor found, " 1199 "data_status=x%08x, data_error=x%08x\n", 1200 hwdescr->data_status, hwdescr->data_error); 1201 goto bad_desc; 1202 } 1203 1204 if (hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_BAD_STATUS) { 1205 dev_err(&card->netdev->dev, "bad status, cmd_status=x%08x\n", 1206 hwdescr->dmac_cmd_status); 1207 pr_err("buf_addr=x%08x\n", hw_buf_addr); 1208 pr_err("buf_size=x%08x\n", hwdescr->buf_size); 1209 pr_err("next_descr_addr=x%08x\n", hwdescr->next_descr_addr); 1210 pr_err("result_size=x%08x\n", hwdescr->result_size); 1211 pr_err("valid_size=x%08x\n", hwdescr->valid_size); 1212 pr_err("data_status=x%08x\n", hwdescr->data_status); 1213 pr_err("data_error=x%08x\n", hwdescr->data_error); 1214 pr_err("which=%ld\n", descr - card->rx_chain.ring); 1215 1216 card->spider_stats.rx_desc_error++; 1217 goto bad_desc; 1218 } 1219 1220 /* Ok, we've got a packet in descr */ 1221 spider_net_pass_skb_up(descr, card); 1222 descr->skb = NULL; 1223 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 1224 return 1; 1225 1226 bad_desc: 1227 if (netif_msg_rx_err(card)) 1228 show_rx_chain(card); 1229 dev_kfree_skb_irq(descr->skb); 1230 descr->skb = NULL; 1231 hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 1232 return 0; 1233 } 1234 1235 /** 1236 * spider_net_poll - NAPI poll function called by the stack to return packets 1237 * @napi: napi device structure 1238 * @budget: number of packets we can pass to the stack at most 1239 * 1240 * returns 0 if no more packets available to the driver/stack. Returns 1, 1241 * if the quota is exceeded, but the driver has still packets. 1242 * 1243 * spider_net_poll returns all packets from the rx descriptors to the stack 1244 * (using netif_receive_skb). If all/enough packets are up, the driver 1245 * reenables interrupts and returns 0. If not, 1 is returned. 1246 */ 1247 static int spider_net_poll(struct napi_struct *napi, int budget) 1248 { 1249 struct spider_net_card *card = container_of(napi, struct spider_net_card, napi); 1250 int packets_done = 0; 1251 1252 while (packets_done < budget) { 1253 if (!spider_net_decode_one_descr(card)) 1254 break; 1255 1256 packets_done++; 1257 } 1258 1259 if ((packets_done == 0) && (card->num_rx_ints != 0)) { 1260 if (!spider_net_resync_tail_ptr(card)) 1261 packets_done = budget; 1262 spider_net_resync_head_ptr(card); 1263 } 1264 card->num_rx_ints = 0; 1265 1266 spider_net_refill_rx_chain(card); 1267 spider_net_enable_rxdmac(card); 1268 1269 spider_net_cleanup_tx_ring(&card->tx_timer); 1270 1271 /* if all packets are in the stack, enable interrupts and return 0 */ 1272 /* if not, return 1 */ 1273 if (packets_done < budget) { 1274 napi_complete_done(napi, packets_done); 1275 spider_net_rx_irq_on(card); 1276 card->ignore_rx_ramfull = 0; 1277 } 1278 1279 return packets_done; 1280 } 1281 1282 /** 1283 * spider_net_set_mac - sets the MAC of an interface 1284 * @netdev: interface device structure 1285 * @p: pointer to new MAC address 1286 * 1287 * Returns 0 on success, <0 on failure. Currently, we don't support this 1288 * and will always return EOPNOTSUPP. 1289 */ 1290 static int 1291 spider_net_set_mac(struct net_device *netdev, void *p) 1292 { 1293 struct spider_net_card *card = netdev_priv(netdev); 1294 u32 macl, macu, regvalue; 1295 struct sockaddr *addr = p; 1296 1297 if (!is_valid_ether_addr(addr->sa_data)) 1298 return -EADDRNOTAVAIL; 1299 1300 eth_hw_addr_set(netdev, addr->sa_data); 1301 1302 /* switch off GMACTPE and GMACRPE */ 1303 regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD); 1304 regvalue &= ~((1 << 5) | (1 << 6)); 1305 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue); 1306 1307 /* write mac */ 1308 macu = (netdev->dev_addr[0]<<24) + (netdev->dev_addr[1]<<16) + 1309 (netdev->dev_addr[2]<<8) + (netdev->dev_addr[3]); 1310 macl = (netdev->dev_addr[4]<<8) + (netdev->dev_addr[5]); 1311 spider_net_write_reg(card, SPIDER_NET_GMACUNIMACU, macu); 1312 spider_net_write_reg(card, SPIDER_NET_GMACUNIMACL, macl); 1313 1314 /* switch GMACTPE and GMACRPE back on */ 1315 regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD); 1316 regvalue |= ((1 << 5) | (1 << 6)); 1317 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue); 1318 1319 spider_net_set_promisc(card); 1320 1321 return 0; 1322 } 1323 1324 /** 1325 * spider_net_link_reset 1326 * @netdev: net device structure 1327 * 1328 * This is called when the PHY_LINK signal is asserted. For the blade this is 1329 * not connected so we should never get here. 1330 * 1331 */ 1332 static void 1333 spider_net_link_reset(struct net_device *netdev) 1334 { 1335 1336 struct spider_net_card *card = netdev_priv(netdev); 1337 1338 del_timer_sync(&card->aneg_timer); 1339 1340 /* clear interrupt, block further interrupts */ 1341 spider_net_write_reg(card, SPIDER_NET_GMACST, 1342 spider_net_read_reg(card, SPIDER_NET_GMACST)); 1343 spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0); 1344 1345 /* reset phy and setup aneg */ 1346 card->aneg_count = 0; 1347 card->medium = BCM54XX_COPPER; 1348 spider_net_setup_aneg(card); 1349 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 1350 1351 } 1352 1353 /** 1354 * spider_net_handle_error_irq - handles errors raised by an interrupt 1355 * @card: card structure 1356 * @status_reg: interrupt status register 0 (GHIINT0STS) 1357 * @error_reg1: interrupt status register 1 (GHIINT1STS) 1358 * @error_reg2: interrupt status register 2 (GHIINT2STS) 1359 * 1360 * spider_net_handle_error_irq treats or ignores all error conditions 1361 * found when an interrupt is presented 1362 */ 1363 static void 1364 spider_net_handle_error_irq(struct spider_net_card *card, u32 status_reg, 1365 u32 error_reg1, u32 error_reg2) 1366 { 1367 u32 i; 1368 int show_error = 1; 1369 1370 /* check GHIINT0STS ************************************/ 1371 if (status_reg) 1372 for (i = 0; i < 32; i++) 1373 if (status_reg & (1<<i)) 1374 switch (i) 1375 { 1376 /* let error_reg1 and error_reg2 evaluation decide, what to do 1377 case SPIDER_NET_PHYINT: 1378 case SPIDER_NET_GMAC2INT: 1379 case SPIDER_NET_GMAC1INT: 1380 case SPIDER_NET_GFIFOINT: 1381 case SPIDER_NET_DMACINT: 1382 case SPIDER_NET_GSYSINT: 1383 break; */ 1384 1385 case SPIDER_NET_GIPSINT: 1386 show_error = 0; 1387 break; 1388 1389 case SPIDER_NET_GPWOPCMPINT: 1390 /* PHY write operation completed */ 1391 show_error = 0; 1392 break; 1393 case SPIDER_NET_GPROPCMPINT: 1394 /* PHY read operation completed */ 1395 /* we don't use semaphores, as we poll for the completion 1396 * of the read operation in spider_net_read_phy. Should take 1397 * about 50 us 1398 */ 1399 show_error = 0; 1400 break; 1401 case SPIDER_NET_GPWFFINT: 1402 /* PHY command queue full */ 1403 if (netif_msg_intr(card)) 1404 dev_err(&card->netdev->dev, "PHY write queue full\n"); 1405 show_error = 0; 1406 break; 1407 1408 /* case SPIDER_NET_GRMDADRINT: not used. print a message */ 1409 /* case SPIDER_NET_GRMARPINT: not used. print a message */ 1410 /* case SPIDER_NET_GRMMPINT: not used. print a message */ 1411 1412 case SPIDER_NET_GDTDEN0INT: 1413 /* someone has set TX_DMA_EN to 0 */ 1414 show_error = 0; 1415 break; 1416 1417 case SPIDER_NET_GDDDEN0INT: 1418 case SPIDER_NET_GDCDEN0INT: 1419 case SPIDER_NET_GDBDEN0INT: 1420 case SPIDER_NET_GDADEN0INT: 1421 /* someone has set RX_DMA_EN to 0 */ 1422 show_error = 0; 1423 break; 1424 1425 /* RX interrupts */ 1426 case SPIDER_NET_GDDFDCINT: 1427 case SPIDER_NET_GDCFDCINT: 1428 case SPIDER_NET_GDBFDCINT: 1429 case SPIDER_NET_GDAFDCINT: 1430 /* case SPIDER_NET_GDNMINT: not used. print a message */ 1431 /* case SPIDER_NET_GCNMINT: not used. print a message */ 1432 /* case SPIDER_NET_GBNMINT: not used. print a message */ 1433 /* case SPIDER_NET_GANMINT: not used. print a message */ 1434 /* case SPIDER_NET_GRFNMINT: not used. print a message */ 1435 show_error = 0; 1436 break; 1437 1438 /* TX interrupts */ 1439 case SPIDER_NET_GDTFDCINT: 1440 show_error = 0; 1441 break; 1442 case SPIDER_NET_GTTEDINT: 1443 show_error = 0; 1444 break; 1445 case SPIDER_NET_GDTDCEINT: 1446 /* chain end. If a descriptor should be sent, kick off 1447 * tx dma 1448 if (card->tx_chain.tail != card->tx_chain.head) 1449 spider_net_kick_tx_dma(card); 1450 */ 1451 show_error = 0; 1452 break; 1453 1454 /* case SPIDER_NET_G1TMCNTINT: not used. print a message */ 1455 /* case SPIDER_NET_GFREECNTINT: not used. print a message */ 1456 } 1457 1458 /* check GHIINT1STS ************************************/ 1459 if (error_reg1) 1460 for (i = 0; i < 32; i++) 1461 if (error_reg1 & (1<<i)) 1462 switch (i) 1463 { 1464 case SPIDER_NET_GTMFLLINT: 1465 /* TX RAM full may happen on a usual case. 1466 * Logging is not needed. 1467 */ 1468 show_error = 0; 1469 break; 1470 case SPIDER_NET_GRFDFLLINT: 1471 case SPIDER_NET_GRFCFLLINT: 1472 case SPIDER_NET_GRFBFLLINT: 1473 case SPIDER_NET_GRFAFLLINT: 1474 case SPIDER_NET_GRMFLLINT: 1475 /* Could happen when rx chain is full */ 1476 if (card->ignore_rx_ramfull == 0) { 1477 card->ignore_rx_ramfull = 1; 1478 spider_net_resync_head_ptr(card); 1479 spider_net_refill_rx_chain(card); 1480 spider_net_enable_rxdmac(card); 1481 card->num_rx_ints ++; 1482 napi_schedule(&card->napi); 1483 } 1484 show_error = 0; 1485 break; 1486 1487 /* case SPIDER_NET_GTMSHTINT: problem, print a message */ 1488 case SPIDER_NET_GDTINVDINT: 1489 /* allrighty. tx from previous descr ok */ 1490 show_error = 0; 1491 break; 1492 1493 /* chain end */ 1494 case SPIDER_NET_GDDDCEINT: 1495 case SPIDER_NET_GDCDCEINT: 1496 case SPIDER_NET_GDBDCEINT: 1497 case SPIDER_NET_GDADCEINT: 1498 spider_net_resync_head_ptr(card); 1499 spider_net_refill_rx_chain(card); 1500 spider_net_enable_rxdmac(card); 1501 card->num_rx_ints ++; 1502 napi_schedule(&card->napi); 1503 show_error = 0; 1504 break; 1505 1506 /* invalid descriptor */ 1507 case SPIDER_NET_GDDINVDINT: 1508 case SPIDER_NET_GDCINVDINT: 1509 case SPIDER_NET_GDBINVDINT: 1510 case SPIDER_NET_GDAINVDINT: 1511 /* Could happen when rx chain is full */ 1512 spider_net_resync_head_ptr(card); 1513 spider_net_refill_rx_chain(card); 1514 spider_net_enable_rxdmac(card); 1515 card->num_rx_ints ++; 1516 napi_schedule(&card->napi); 1517 show_error = 0; 1518 break; 1519 1520 /* case SPIDER_NET_GDTRSERINT: problem, print a message */ 1521 /* case SPIDER_NET_GDDRSERINT: problem, print a message */ 1522 /* case SPIDER_NET_GDCRSERINT: problem, print a message */ 1523 /* case SPIDER_NET_GDBRSERINT: problem, print a message */ 1524 /* case SPIDER_NET_GDARSERINT: problem, print a message */ 1525 /* case SPIDER_NET_GDSERINT: problem, print a message */ 1526 /* case SPIDER_NET_GDTPTERINT: problem, print a message */ 1527 /* case SPIDER_NET_GDDPTERINT: problem, print a message */ 1528 /* case SPIDER_NET_GDCPTERINT: problem, print a message */ 1529 /* case SPIDER_NET_GDBPTERINT: problem, print a message */ 1530 /* case SPIDER_NET_GDAPTERINT: problem, print a message */ 1531 default: 1532 show_error = 1; 1533 break; 1534 } 1535 1536 /* check GHIINT2STS ************************************/ 1537 if (error_reg2) 1538 for (i = 0; i < 32; i++) 1539 if (error_reg2 & (1<<i)) 1540 switch (i) 1541 { 1542 /* there is nothing we can (want to) do at this time. Log a 1543 * message, we can switch on and off the specific values later on 1544 case SPIDER_NET_GPROPERINT: 1545 case SPIDER_NET_GMCTCRSNGINT: 1546 case SPIDER_NET_GMCTLCOLINT: 1547 case SPIDER_NET_GMCTTMOTINT: 1548 case SPIDER_NET_GMCRCAERINT: 1549 case SPIDER_NET_GMCRCALERINT: 1550 case SPIDER_NET_GMCRALNERINT: 1551 case SPIDER_NET_GMCROVRINT: 1552 case SPIDER_NET_GMCRRNTINT: 1553 case SPIDER_NET_GMCRRXERINT: 1554 case SPIDER_NET_GTITCSERINT: 1555 case SPIDER_NET_GTIFMTERINT: 1556 case SPIDER_NET_GTIPKTRVKINT: 1557 case SPIDER_NET_GTISPINGINT: 1558 case SPIDER_NET_GTISADNGINT: 1559 case SPIDER_NET_GTISPDNGINT: 1560 case SPIDER_NET_GRIFMTERINT: 1561 case SPIDER_NET_GRIPKTRVKINT: 1562 case SPIDER_NET_GRISPINGINT: 1563 case SPIDER_NET_GRISADNGINT: 1564 case SPIDER_NET_GRISPDNGINT: 1565 break; 1566 */ 1567 default: 1568 break; 1569 } 1570 1571 if ((show_error) && (netif_msg_intr(card)) && net_ratelimit()) 1572 dev_err(&card->netdev->dev, "Error interrupt, GHIINT0STS = 0x%08x, " 1573 "GHIINT1STS = 0x%08x, GHIINT2STS = 0x%08x\n", 1574 status_reg, error_reg1, error_reg2); 1575 1576 /* clear interrupt sources */ 1577 spider_net_write_reg(card, SPIDER_NET_GHIINT1STS, error_reg1); 1578 spider_net_write_reg(card, SPIDER_NET_GHIINT2STS, error_reg2); 1579 } 1580 1581 /** 1582 * spider_net_interrupt - interrupt handler for spider_net 1583 * @irq: interrupt number 1584 * @ptr: pointer to net_device 1585 * 1586 * returns IRQ_HANDLED, if interrupt was for driver, or IRQ_NONE, if no 1587 * interrupt found raised by card. 1588 * 1589 * This is the interrupt handler, that turns off 1590 * interrupts for this device and makes the stack poll the driver 1591 */ 1592 static irqreturn_t 1593 spider_net_interrupt(int irq, void *ptr) 1594 { 1595 struct net_device *netdev = ptr; 1596 struct spider_net_card *card = netdev_priv(netdev); 1597 u32 status_reg, error_reg1, error_reg2; 1598 1599 status_reg = spider_net_read_reg(card, SPIDER_NET_GHIINT0STS); 1600 error_reg1 = spider_net_read_reg(card, SPIDER_NET_GHIINT1STS); 1601 error_reg2 = spider_net_read_reg(card, SPIDER_NET_GHIINT2STS); 1602 1603 if (!(status_reg & SPIDER_NET_INT0_MASK_VALUE) && 1604 !(error_reg1 & SPIDER_NET_INT1_MASK_VALUE) && 1605 !(error_reg2 & SPIDER_NET_INT2_MASK_VALUE)) 1606 return IRQ_NONE; 1607 1608 if (status_reg & SPIDER_NET_RXINT ) { 1609 spider_net_rx_irq_off(card); 1610 napi_schedule(&card->napi); 1611 card->num_rx_ints ++; 1612 } 1613 if (status_reg & SPIDER_NET_TXINT) 1614 napi_schedule(&card->napi); 1615 1616 if (status_reg & SPIDER_NET_LINKINT) 1617 spider_net_link_reset(netdev); 1618 1619 if (status_reg & SPIDER_NET_ERRINT ) 1620 spider_net_handle_error_irq(card, status_reg, 1621 error_reg1, error_reg2); 1622 1623 /* clear interrupt sources */ 1624 spider_net_write_reg(card, SPIDER_NET_GHIINT0STS, status_reg); 1625 1626 return IRQ_HANDLED; 1627 } 1628 1629 #ifdef CONFIG_NET_POLL_CONTROLLER 1630 /** 1631 * spider_net_poll_controller - artificial interrupt for netconsole etc. 1632 * @netdev: interface device structure 1633 * 1634 * see Documentation/networking/netconsole.rst 1635 */ 1636 static void 1637 spider_net_poll_controller(struct net_device *netdev) 1638 { 1639 disable_irq(netdev->irq); 1640 spider_net_interrupt(netdev->irq, netdev); 1641 enable_irq(netdev->irq); 1642 } 1643 #endif /* CONFIG_NET_POLL_CONTROLLER */ 1644 1645 /** 1646 * spider_net_enable_interrupts - enable interrupts 1647 * @card: card structure 1648 * 1649 * spider_net_enable_interrupt enables several interrupts 1650 */ 1651 static void 1652 spider_net_enable_interrupts(struct spider_net_card *card) 1653 { 1654 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, 1655 SPIDER_NET_INT0_MASK_VALUE); 1656 spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK, 1657 SPIDER_NET_INT1_MASK_VALUE); 1658 spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK, 1659 SPIDER_NET_INT2_MASK_VALUE); 1660 } 1661 1662 /** 1663 * spider_net_disable_interrupts - disable interrupts 1664 * @card: card structure 1665 * 1666 * spider_net_disable_interrupts disables all the interrupts 1667 */ 1668 static void 1669 spider_net_disable_interrupts(struct spider_net_card *card) 1670 { 1671 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, 0); 1672 spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK, 0); 1673 spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK, 0); 1674 spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0); 1675 } 1676 1677 /** 1678 * spider_net_init_card - initializes the card 1679 * @card: card structure 1680 * 1681 * spider_net_init_card initializes the card so that other registers can 1682 * be used 1683 */ 1684 static void 1685 spider_net_init_card(struct spider_net_card *card) 1686 { 1687 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 1688 SPIDER_NET_CKRCTRL_STOP_VALUE); 1689 1690 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 1691 SPIDER_NET_CKRCTRL_RUN_VALUE); 1692 1693 /* trigger ETOMOD signal */ 1694 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, 1695 spider_net_read_reg(card, SPIDER_NET_GMACOPEMD) | 0x4); 1696 1697 spider_net_disable_interrupts(card); 1698 } 1699 1700 /** 1701 * spider_net_enable_card - enables the card by setting all kinds of regs 1702 * @card: card structure 1703 * 1704 * spider_net_enable_card sets a lot of SMMIO registers to enable the device 1705 */ 1706 static void 1707 spider_net_enable_card(struct spider_net_card *card) 1708 { 1709 int i; 1710 /* the following array consists of (register),(value) pairs 1711 * that are set in this function. A register of 0 ends the list 1712 */ 1713 u32 regs[][2] = { 1714 { SPIDER_NET_GRESUMINTNUM, 0 }, 1715 { SPIDER_NET_GREINTNUM, 0 }, 1716 1717 /* set interrupt frame number registers */ 1718 /* clear the single DMA engine registers first */ 1719 { SPIDER_NET_GFAFRMNUM, SPIDER_NET_GFXFRAMES_VALUE }, 1720 { SPIDER_NET_GFBFRMNUM, SPIDER_NET_GFXFRAMES_VALUE }, 1721 { SPIDER_NET_GFCFRMNUM, SPIDER_NET_GFXFRAMES_VALUE }, 1722 { SPIDER_NET_GFDFRMNUM, SPIDER_NET_GFXFRAMES_VALUE }, 1723 /* then set, what we really need */ 1724 { SPIDER_NET_GFFRMNUM, SPIDER_NET_FRAMENUM_VALUE }, 1725 1726 /* timer counter registers and stuff */ 1727 { SPIDER_NET_GFREECNNUM, 0 }, 1728 { SPIDER_NET_GONETIMENUM, 0 }, 1729 { SPIDER_NET_GTOUTFRMNUM, 0 }, 1730 1731 /* RX mode setting */ 1732 { SPIDER_NET_GRXMDSET, SPIDER_NET_RXMODE_VALUE }, 1733 /* TX mode setting */ 1734 { SPIDER_NET_GTXMDSET, SPIDER_NET_TXMODE_VALUE }, 1735 /* IPSEC mode setting */ 1736 { SPIDER_NET_GIPSECINIT, SPIDER_NET_IPSECINIT_VALUE }, 1737 1738 { SPIDER_NET_GFTRESTRT, SPIDER_NET_RESTART_VALUE }, 1739 1740 { SPIDER_NET_GMRWOLCTRL, 0 }, 1741 { SPIDER_NET_GTESTMD, 0x10000000 }, 1742 { SPIDER_NET_GTTQMSK, 0x00400040 }, 1743 1744 { SPIDER_NET_GMACINTEN, 0 }, 1745 1746 /* flow control stuff */ 1747 { SPIDER_NET_GMACAPAUSE, SPIDER_NET_MACAPAUSE_VALUE }, 1748 { SPIDER_NET_GMACTXPAUSE, SPIDER_NET_TXPAUSE_VALUE }, 1749 1750 { SPIDER_NET_GMACBSTLMT, SPIDER_NET_BURSTLMT_VALUE }, 1751 { 0, 0} 1752 }; 1753 1754 i = 0; 1755 while (regs[i][0]) { 1756 spider_net_write_reg(card, regs[i][0], regs[i][1]); 1757 i++; 1758 } 1759 1760 /* clear unicast filter table entries 1 to 14 */ 1761 for (i = 1; i <= 14; i++) { 1762 spider_net_write_reg(card, 1763 SPIDER_NET_GMRUAFILnR + i * 8, 1764 0x00080000); 1765 spider_net_write_reg(card, 1766 SPIDER_NET_GMRUAFILnR + i * 8 + 4, 1767 0x00000000); 1768 } 1769 1770 spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R, 0x08080000); 1771 1772 spider_net_write_reg(card, SPIDER_NET_ECMODE, SPIDER_NET_ECMODE_VALUE); 1773 1774 /* set chain tail address for RX chains and 1775 * enable DMA 1776 */ 1777 spider_net_enable_rxchtails(card); 1778 spider_net_enable_rxdmac(card); 1779 1780 spider_net_write_reg(card, SPIDER_NET_GRXDMAEN, SPIDER_NET_WOL_VALUE); 1781 1782 spider_net_write_reg(card, SPIDER_NET_GMACLENLMT, 1783 SPIDER_NET_LENLMT_VALUE); 1784 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, 1785 SPIDER_NET_OPMODE_VALUE); 1786 1787 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR, 1788 SPIDER_NET_GDTBSTA); 1789 } 1790 1791 /** 1792 * spider_net_download_firmware - loads firmware into the adapter 1793 * @card: card structure 1794 * @firmware_ptr: pointer to firmware data 1795 * 1796 * spider_net_download_firmware loads the firmware data into the 1797 * adapter. It assumes the length etc. to be allright. 1798 */ 1799 static int 1800 spider_net_download_firmware(struct spider_net_card *card, 1801 const void *firmware_ptr) 1802 { 1803 int sequencer, i; 1804 const u32 *fw_ptr = firmware_ptr; 1805 1806 /* stop sequencers */ 1807 spider_net_write_reg(card, SPIDER_NET_GSINIT, 1808 SPIDER_NET_STOP_SEQ_VALUE); 1809 1810 for (sequencer = 0; sequencer < SPIDER_NET_FIRMWARE_SEQS; 1811 sequencer++) { 1812 spider_net_write_reg(card, 1813 SPIDER_NET_GSnPRGADR + sequencer * 8, 0); 1814 for (i = 0; i < SPIDER_NET_FIRMWARE_SEQWORDS; i++) { 1815 spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT + 1816 sequencer * 8, *fw_ptr); 1817 fw_ptr++; 1818 } 1819 } 1820 1821 if (spider_net_read_reg(card, SPIDER_NET_GSINIT)) 1822 return -EIO; 1823 1824 spider_net_write_reg(card, SPIDER_NET_GSINIT, 1825 SPIDER_NET_RUN_SEQ_VALUE); 1826 1827 return 0; 1828 } 1829 1830 /** 1831 * spider_net_init_firmware - reads in firmware parts 1832 * @card: card structure 1833 * 1834 * Returns 0 on success, <0 on failure 1835 * 1836 * spider_net_init_firmware opens the sequencer firmware and does some basic 1837 * checks. This function opens and releases the firmware structure. A call 1838 * to download the firmware is performed before the release. 1839 * 1840 * Firmware format 1841 * =============== 1842 * spider_fw.bin is expected to be a file containing 6*1024*4 bytes, 4k being 1843 * the program for each sequencer. Use the command 1844 * tail -q -n +2 Seq_code1_0x088.txt Seq_code2_0x090.txt \ 1845 * Seq_code3_0x098.txt Seq_code4_0x0A0.txt Seq_code5_0x0A8.txt \ 1846 * Seq_code6_0x0B0.txt | xxd -r -p -c4 > spider_fw.bin 1847 * 1848 * to generate spider_fw.bin, if you have sequencer programs with something 1849 * like the following contents for each sequencer: 1850 * <ONE LINE COMMENT> 1851 * <FIRST 4-BYTES-WORD FOR SEQUENCER> 1852 * <SECOND 4-BYTES-WORD FOR SEQUENCER> 1853 * ... 1854 * <1024th 4-BYTES-WORD FOR SEQUENCER> 1855 */ 1856 static int 1857 spider_net_init_firmware(struct spider_net_card *card) 1858 { 1859 struct firmware *firmware = NULL; 1860 struct device_node *dn; 1861 const u8 *fw_prop = NULL; 1862 int err = -ENOENT; 1863 int fw_size; 1864 1865 if (request_firmware((const struct firmware **)&firmware, 1866 SPIDER_NET_FIRMWARE_NAME, &card->pdev->dev) == 0) { 1867 if ( (firmware->size != SPIDER_NET_FIRMWARE_LEN) && 1868 netif_msg_probe(card) ) { 1869 dev_err(&card->netdev->dev, 1870 "Incorrect size of spidernet firmware in " \ 1871 "filesystem. Looking in host firmware...\n"); 1872 goto try_host_fw; 1873 } 1874 err = spider_net_download_firmware(card, firmware->data); 1875 1876 release_firmware(firmware); 1877 if (err) 1878 goto try_host_fw; 1879 1880 goto done; 1881 } 1882 1883 try_host_fw: 1884 dn = pci_device_to_OF_node(card->pdev); 1885 if (!dn) 1886 goto out_err; 1887 1888 fw_prop = of_get_property(dn, "firmware", &fw_size); 1889 if (!fw_prop) 1890 goto out_err; 1891 1892 if ( (fw_size != SPIDER_NET_FIRMWARE_LEN) && 1893 netif_msg_probe(card) ) { 1894 dev_err(&card->netdev->dev, 1895 "Incorrect size of spidernet firmware in host firmware\n"); 1896 goto done; 1897 } 1898 1899 err = spider_net_download_firmware(card, fw_prop); 1900 1901 done: 1902 return err; 1903 out_err: 1904 if (netif_msg_probe(card)) 1905 dev_err(&card->netdev->dev, 1906 "Couldn't find spidernet firmware in filesystem " \ 1907 "or host firmware\n"); 1908 return err; 1909 } 1910 1911 /** 1912 * spider_net_open - called upon ifonfig up 1913 * @netdev: interface device structure 1914 * 1915 * returns 0 on success, <0 on failure 1916 * 1917 * spider_net_open allocates all the descriptors and memory needed for 1918 * operation, sets up multicast list and enables interrupts 1919 */ 1920 int 1921 spider_net_open(struct net_device *netdev) 1922 { 1923 struct spider_net_card *card = netdev_priv(netdev); 1924 int result; 1925 1926 result = spider_net_init_firmware(card); 1927 if (result) 1928 goto init_firmware_failed; 1929 1930 /* start probing with copper */ 1931 card->aneg_count = 0; 1932 card->medium = BCM54XX_COPPER; 1933 spider_net_setup_aneg(card); 1934 if (card->phy.def->phy_id) 1935 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 1936 1937 result = spider_net_init_chain(card, &card->tx_chain); 1938 if (result) 1939 goto alloc_tx_failed; 1940 card->low_watermark = NULL; 1941 1942 result = spider_net_init_chain(card, &card->rx_chain); 1943 if (result) 1944 goto alloc_rx_failed; 1945 1946 /* Allocate rx skbs */ 1947 result = spider_net_alloc_rx_skbs(card); 1948 if (result) 1949 goto alloc_skbs_failed; 1950 1951 spider_net_set_multi(netdev); 1952 1953 /* further enhancement: setup hw vlan, if needed */ 1954 1955 result = -EBUSY; 1956 if (request_irq(netdev->irq, spider_net_interrupt, 1957 IRQF_SHARED, netdev->name, netdev)) 1958 goto register_int_failed; 1959 1960 spider_net_enable_card(card); 1961 1962 netif_start_queue(netdev); 1963 netif_carrier_on(netdev); 1964 napi_enable(&card->napi); 1965 1966 spider_net_enable_interrupts(card); 1967 1968 return 0; 1969 1970 register_int_failed: 1971 spider_net_free_rx_chain_contents(card); 1972 alloc_skbs_failed: 1973 spider_net_free_chain(card, &card->rx_chain); 1974 alloc_rx_failed: 1975 spider_net_free_chain(card, &card->tx_chain); 1976 alloc_tx_failed: 1977 del_timer_sync(&card->aneg_timer); 1978 init_firmware_failed: 1979 return result; 1980 } 1981 1982 /** 1983 * spider_net_link_phy 1984 * @t: timer context used to obtain the pointer to net card data structure 1985 */ 1986 static void spider_net_link_phy(struct timer_list *t) 1987 { 1988 struct spider_net_card *card = from_timer(card, t, aneg_timer); 1989 struct mii_phy *phy = &card->phy; 1990 1991 /* if link didn't come up after SPIDER_NET_ANEG_TIMEOUT tries, setup phy again */ 1992 if (card->aneg_count > SPIDER_NET_ANEG_TIMEOUT) { 1993 1994 pr_debug("%s: link is down trying to bring it up\n", 1995 card->netdev->name); 1996 1997 switch (card->medium) { 1998 case BCM54XX_COPPER: 1999 /* enable fiber with autonegotiation first */ 2000 if (phy->def->ops->enable_fiber) 2001 phy->def->ops->enable_fiber(phy, 1); 2002 card->medium = BCM54XX_FIBER; 2003 break; 2004 2005 case BCM54XX_FIBER: 2006 /* fiber didn't come up, try to disable fiber autoneg */ 2007 if (phy->def->ops->enable_fiber) 2008 phy->def->ops->enable_fiber(phy, 0); 2009 card->medium = BCM54XX_UNKNOWN; 2010 break; 2011 2012 case BCM54XX_UNKNOWN: 2013 /* copper, fiber with and without failed, 2014 * retry from beginning 2015 */ 2016 spider_net_setup_aneg(card); 2017 card->medium = BCM54XX_COPPER; 2018 break; 2019 } 2020 2021 card->aneg_count = 0; 2022 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 2023 return; 2024 } 2025 2026 /* link still not up, try again later */ 2027 if (!(phy->def->ops->poll_link(phy))) { 2028 card->aneg_count++; 2029 mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 2030 return; 2031 } 2032 2033 /* link came up, get abilities */ 2034 phy->def->ops->read_link(phy); 2035 2036 spider_net_write_reg(card, SPIDER_NET_GMACST, 2037 spider_net_read_reg(card, SPIDER_NET_GMACST)); 2038 spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0x4); 2039 2040 if (phy->speed == 1000) 2041 spider_net_write_reg(card, SPIDER_NET_GMACMODE, 0x00000001); 2042 else 2043 spider_net_write_reg(card, SPIDER_NET_GMACMODE, 0); 2044 2045 card->aneg_count = 0; 2046 2047 pr_info("%s: link up, %i Mbps, %s-duplex %sautoneg.\n", 2048 card->netdev->name, phy->speed, 2049 phy->duplex == 1 ? "Full" : "Half", 2050 phy->autoneg == 1 ? "" : "no "); 2051 } 2052 2053 /** 2054 * spider_net_setup_phy - setup PHY 2055 * @card: card structure 2056 * 2057 * returns 0 on success, <0 on failure 2058 * 2059 * spider_net_setup_phy is used as part of spider_net_probe. 2060 **/ 2061 static int 2062 spider_net_setup_phy(struct spider_net_card *card) 2063 { 2064 struct mii_phy *phy = &card->phy; 2065 2066 spider_net_write_reg(card, SPIDER_NET_GDTDMASEL, 2067 SPIDER_NET_DMASEL_VALUE); 2068 spider_net_write_reg(card, SPIDER_NET_GPCCTRL, 2069 SPIDER_NET_PHY_CTRL_VALUE); 2070 2071 phy->dev = card->netdev; 2072 phy->mdio_read = spider_net_read_phy; 2073 phy->mdio_write = spider_net_write_phy; 2074 2075 for (phy->mii_id = 1; phy->mii_id <= 31; phy->mii_id++) { 2076 unsigned short id; 2077 id = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR); 2078 if (id != 0x0000 && id != 0xffff) { 2079 if (!sungem_phy_probe(phy, phy->mii_id)) { 2080 pr_info("Found %s.\n", phy->def->name); 2081 break; 2082 } 2083 } 2084 } 2085 2086 return 0; 2087 } 2088 2089 /** 2090 * spider_net_workaround_rxramfull - work around firmware bug 2091 * @card: card structure 2092 * 2093 * no return value 2094 **/ 2095 static void 2096 spider_net_workaround_rxramfull(struct spider_net_card *card) 2097 { 2098 int i, sequencer = 0; 2099 2100 /* cancel reset */ 2101 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 2102 SPIDER_NET_CKRCTRL_RUN_VALUE); 2103 2104 /* empty sequencer data */ 2105 for (sequencer = 0; sequencer < SPIDER_NET_FIRMWARE_SEQS; 2106 sequencer++) { 2107 spider_net_write_reg(card, SPIDER_NET_GSnPRGADR + 2108 sequencer * 8, 0x0); 2109 for (i = 0; i < SPIDER_NET_FIRMWARE_SEQWORDS; i++) { 2110 spider_net_write_reg(card, SPIDER_NET_GSnPRGDAT + 2111 sequencer * 8, 0x0); 2112 } 2113 } 2114 2115 /* set sequencer operation */ 2116 spider_net_write_reg(card, SPIDER_NET_GSINIT, 0x000000fe); 2117 2118 /* reset */ 2119 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 2120 SPIDER_NET_CKRCTRL_STOP_VALUE); 2121 } 2122 2123 /** 2124 * spider_net_stop - called upon ifconfig down 2125 * @netdev: interface device structure 2126 * 2127 * always returns 0 2128 */ 2129 int 2130 spider_net_stop(struct net_device *netdev) 2131 { 2132 struct spider_net_card *card = netdev_priv(netdev); 2133 2134 napi_disable(&card->napi); 2135 netif_carrier_off(netdev); 2136 netif_stop_queue(netdev); 2137 del_timer_sync(&card->tx_timer); 2138 del_timer_sync(&card->aneg_timer); 2139 2140 spider_net_disable_interrupts(card); 2141 2142 free_irq(netdev->irq, netdev); 2143 2144 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR, 2145 SPIDER_NET_DMA_TX_FEND_VALUE); 2146 2147 /* turn off DMA, force end */ 2148 spider_net_disable_rxdmac(card); 2149 2150 /* release chains */ 2151 spider_net_release_tx_chain(card, 1); 2152 spider_net_free_rx_chain_contents(card); 2153 2154 spider_net_free_chain(card, &card->tx_chain); 2155 spider_net_free_chain(card, &card->rx_chain); 2156 2157 return 0; 2158 } 2159 2160 /** 2161 * spider_net_tx_timeout_task - task scheduled by the watchdog timeout 2162 * function (to be called not under interrupt status) 2163 * @work: work context used to obtain the pointer to net card data structure 2164 * 2165 * called as task when tx hangs, resets interface (if interface is up) 2166 */ 2167 static void 2168 spider_net_tx_timeout_task(struct work_struct *work) 2169 { 2170 struct spider_net_card *card = 2171 container_of(work, struct spider_net_card, tx_timeout_task); 2172 struct net_device *netdev = card->netdev; 2173 2174 if (!(netdev->flags & IFF_UP)) 2175 goto out; 2176 2177 netif_device_detach(netdev); 2178 spider_net_stop(netdev); 2179 2180 spider_net_workaround_rxramfull(card); 2181 spider_net_init_card(card); 2182 2183 if (spider_net_setup_phy(card)) 2184 goto out; 2185 2186 spider_net_open(netdev); 2187 spider_net_kick_tx_dma(card); 2188 netif_device_attach(netdev); 2189 2190 out: 2191 atomic_dec(&card->tx_timeout_task_counter); 2192 } 2193 2194 /** 2195 * spider_net_tx_timeout - called when the tx timeout watchdog kicks in. 2196 * @netdev: interface device structure 2197 * @txqueue: unused 2198 * 2199 * called, if tx hangs. Schedules a task that resets the interface 2200 */ 2201 static void 2202 spider_net_tx_timeout(struct net_device *netdev, unsigned int txqueue) 2203 { 2204 struct spider_net_card *card; 2205 2206 card = netdev_priv(netdev); 2207 atomic_inc(&card->tx_timeout_task_counter); 2208 if (netdev->flags & IFF_UP) 2209 schedule_work(&card->tx_timeout_task); 2210 else 2211 atomic_dec(&card->tx_timeout_task_counter); 2212 card->spider_stats.tx_timeouts++; 2213 } 2214 2215 static const struct net_device_ops spider_net_ops = { 2216 .ndo_open = spider_net_open, 2217 .ndo_stop = spider_net_stop, 2218 .ndo_start_xmit = spider_net_xmit, 2219 .ndo_set_rx_mode = spider_net_set_multi, 2220 .ndo_set_mac_address = spider_net_set_mac, 2221 .ndo_eth_ioctl = spider_net_do_ioctl, 2222 .ndo_tx_timeout = spider_net_tx_timeout, 2223 .ndo_validate_addr = eth_validate_addr, 2224 /* HW VLAN */ 2225 #ifdef CONFIG_NET_POLL_CONTROLLER 2226 /* poll controller */ 2227 .ndo_poll_controller = spider_net_poll_controller, 2228 #endif /* CONFIG_NET_POLL_CONTROLLER */ 2229 }; 2230 2231 /** 2232 * spider_net_setup_netdev_ops - initialization of net_device operations 2233 * @netdev: net_device structure 2234 * 2235 * fills out function pointers in the net_device structure 2236 */ 2237 static void 2238 spider_net_setup_netdev_ops(struct net_device *netdev) 2239 { 2240 netdev->netdev_ops = &spider_net_ops; 2241 netdev->watchdog_timeo = SPIDER_NET_WATCHDOG_TIMEOUT; 2242 /* ethtool ops */ 2243 netdev->ethtool_ops = &spider_net_ethtool_ops; 2244 } 2245 2246 /** 2247 * spider_net_setup_netdev - initialization of net_device 2248 * @card: card structure 2249 * 2250 * Returns 0 on success or <0 on failure 2251 * 2252 * spider_net_setup_netdev initializes the net_device structure 2253 **/ 2254 static int 2255 spider_net_setup_netdev(struct spider_net_card *card) 2256 { 2257 int result; 2258 struct net_device *netdev = card->netdev; 2259 struct device_node *dn; 2260 struct sockaddr addr; 2261 const u8 *mac; 2262 2263 SET_NETDEV_DEV(netdev, &card->pdev->dev); 2264 2265 pci_set_drvdata(card->pdev, netdev); 2266 2267 timer_setup(&card->tx_timer, spider_net_cleanup_tx_ring, 0); 2268 netdev->irq = card->pdev->irq; 2269 2270 card->aneg_count = 0; 2271 timer_setup(&card->aneg_timer, spider_net_link_phy, 0); 2272 2273 netif_napi_add(netdev, &card->napi, spider_net_poll); 2274 2275 spider_net_setup_netdev_ops(netdev); 2276 2277 netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM; 2278 if (SPIDER_NET_RX_CSUM_DEFAULT) 2279 netdev->features |= NETIF_F_RXCSUM; 2280 netdev->features |= NETIF_F_IP_CSUM | NETIF_F_LLTX; 2281 /* some time: NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX | 2282 * NETIF_F_HW_VLAN_CTAG_FILTER 2283 */ 2284 2285 /* MTU range: 64 - 2294 */ 2286 netdev->min_mtu = SPIDER_NET_MIN_MTU; 2287 netdev->max_mtu = SPIDER_NET_MAX_MTU; 2288 2289 netdev->irq = card->pdev->irq; 2290 card->num_rx_ints = 0; 2291 card->ignore_rx_ramfull = 0; 2292 2293 dn = pci_device_to_OF_node(card->pdev); 2294 if (!dn) 2295 return -EIO; 2296 2297 mac = of_get_property(dn, "local-mac-address", NULL); 2298 if (!mac) 2299 return -EIO; 2300 memcpy(addr.sa_data, mac, ETH_ALEN); 2301 2302 result = spider_net_set_mac(netdev, &addr); 2303 if ((result) && (netif_msg_probe(card))) 2304 dev_err(&card->netdev->dev, 2305 "Failed to set MAC address: %i\n", result); 2306 2307 result = register_netdev(netdev); 2308 if (result) { 2309 if (netif_msg_probe(card)) 2310 dev_err(&card->netdev->dev, 2311 "Couldn't register net_device: %i\n", result); 2312 return result; 2313 } 2314 2315 if (netif_msg_probe(card)) 2316 pr_info("Initialized device %s.\n", netdev->name); 2317 2318 return 0; 2319 } 2320 2321 /** 2322 * spider_net_alloc_card - allocates net_device and card structure 2323 * 2324 * returns the card structure or NULL in case of errors 2325 * 2326 * the card and net_device structures are linked to each other 2327 */ 2328 static struct spider_net_card * 2329 spider_net_alloc_card(void) 2330 { 2331 struct net_device *netdev; 2332 struct spider_net_card *card; 2333 2334 netdev = alloc_etherdev(struct_size(card, darray, 2335 size_add(tx_descriptors, rx_descriptors))); 2336 if (!netdev) 2337 return NULL; 2338 2339 card = netdev_priv(netdev); 2340 card->netdev = netdev; 2341 card->msg_enable = SPIDER_NET_DEFAULT_MSG; 2342 INIT_WORK(&card->tx_timeout_task, spider_net_tx_timeout_task); 2343 init_waitqueue_head(&card->waitq); 2344 atomic_set(&card->tx_timeout_task_counter, 0); 2345 2346 card->rx_chain.num_desc = rx_descriptors; 2347 card->rx_chain.ring = card->darray; 2348 card->tx_chain.num_desc = tx_descriptors; 2349 card->tx_chain.ring = card->darray + rx_descriptors; 2350 2351 return card; 2352 } 2353 2354 /** 2355 * spider_net_undo_pci_setup - releases PCI ressources 2356 * @card: card structure 2357 * 2358 * spider_net_undo_pci_setup releases the mapped regions 2359 */ 2360 static void 2361 spider_net_undo_pci_setup(struct spider_net_card *card) 2362 { 2363 iounmap(card->regs); 2364 pci_release_regions(card->pdev); 2365 } 2366 2367 /** 2368 * spider_net_setup_pci_dev - sets up the device in terms of PCI operations 2369 * @pdev: PCI device 2370 * 2371 * Returns the card structure or NULL if any errors occur 2372 * 2373 * spider_net_setup_pci_dev initializes pdev and together with the 2374 * functions called in spider_net_open configures the device so that 2375 * data can be transferred over it 2376 * The net_device structure is attached to the card structure, if the 2377 * function returns without error. 2378 **/ 2379 static struct spider_net_card * 2380 spider_net_setup_pci_dev(struct pci_dev *pdev) 2381 { 2382 struct spider_net_card *card; 2383 unsigned long mmio_start, mmio_len; 2384 2385 if (pci_enable_device(pdev)) { 2386 dev_err(&pdev->dev, "Couldn't enable PCI device\n"); 2387 return NULL; 2388 } 2389 2390 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 2391 dev_err(&pdev->dev, 2392 "Couldn't find proper PCI device base address.\n"); 2393 goto out_disable_dev; 2394 } 2395 2396 if (pci_request_regions(pdev, spider_net_driver_name)) { 2397 dev_err(&pdev->dev, 2398 "Couldn't obtain PCI resources, aborting.\n"); 2399 goto out_disable_dev; 2400 } 2401 2402 pci_set_master(pdev); 2403 2404 card = spider_net_alloc_card(); 2405 if (!card) { 2406 dev_err(&pdev->dev, 2407 "Couldn't allocate net_device structure, aborting.\n"); 2408 goto out_release_regions; 2409 } 2410 card->pdev = pdev; 2411 2412 /* fetch base address and length of first resource */ 2413 mmio_start = pci_resource_start(pdev, 0); 2414 mmio_len = pci_resource_len(pdev, 0); 2415 2416 card->netdev->mem_start = mmio_start; 2417 card->netdev->mem_end = mmio_start + mmio_len; 2418 card->regs = ioremap(mmio_start, mmio_len); 2419 2420 if (!card->regs) { 2421 dev_err(&pdev->dev, 2422 "Couldn't obtain PCI resources, aborting.\n"); 2423 goto out_release_regions; 2424 } 2425 2426 return card; 2427 2428 out_release_regions: 2429 pci_release_regions(pdev); 2430 out_disable_dev: 2431 pci_disable_device(pdev); 2432 return NULL; 2433 } 2434 2435 /** 2436 * spider_net_probe - initialization of a device 2437 * @pdev: PCI device 2438 * @ent: entry in the device id list 2439 * 2440 * Returns 0 on success, <0 on failure 2441 * 2442 * spider_net_probe initializes pdev and registers a net_device 2443 * structure for it. After that, the device can be ifconfig'ed up 2444 **/ 2445 static int 2446 spider_net_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 2447 { 2448 int err = -EIO; 2449 struct spider_net_card *card; 2450 2451 card = spider_net_setup_pci_dev(pdev); 2452 if (!card) 2453 goto out; 2454 2455 spider_net_workaround_rxramfull(card); 2456 spider_net_init_card(card); 2457 2458 err = spider_net_setup_phy(card); 2459 if (err) 2460 goto out_undo_pci; 2461 2462 err = spider_net_setup_netdev(card); 2463 if (err) 2464 goto out_undo_pci; 2465 2466 return 0; 2467 2468 out_undo_pci: 2469 spider_net_undo_pci_setup(card); 2470 free_netdev(card->netdev); 2471 out: 2472 return err; 2473 } 2474 2475 /** 2476 * spider_net_remove - removal of a device 2477 * @pdev: PCI device 2478 * 2479 * Returns 0 on success, <0 on failure 2480 * 2481 * spider_net_remove is called to remove the device and unregisters the 2482 * net_device 2483 **/ 2484 static void 2485 spider_net_remove(struct pci_dev *pdev) 2486 { 2487 struct net_device *netdev; 2488 struct spider_net_card *card; 2489 2490 netdev = pci_get_drvdata(pdev); 2491 card = netdev_priv(netdev); 2492 2493 wait_event(card->waitq, 2494 atomic_read(&card->tx_timeout_task_counter) == 0); 2495 2496 unregister_netdev(netdev); 2497 2498 /* switch off card */ 2499 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 2500 SPIDER_NET_CKRCTRL_STOP_VALUE); 2501 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 2502 SPIDER_NET_CKRCTRL_RUN_VALUE); 2503 2504 spider_net_undo_pci_setup(card); 2505 free_netdev(netdev); 2506 } 2507 2508 static struct pci_driver spider_net_driver = { 2509 .name = spider_net_driver_name, 2510 .id_table = spider_net_pci_tbl, 2511 .probe = spider_net_probe, 2512 .remove = spider_net_remove 2513 }; 2514 2515 /** 2516 * spider_net_init - init function when the driver is loaded 2517 * 2518 * spider_net_init registers the device driver 2519 */ 2520 static int __init spider_net_init(void) 2521 { 2522 printk(KERN_INFO "Spidernet version %s.\n", VERSION); 2523 2524 if (rx_descriptors < SPIDER_NET_RX_DESCRIPTORS_MIN) { 2525 rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_MIN; 2526 pr_info("adjusting rx descriptors to %i.\n", rx_descriptors); 2527 } 2528 if (rx_descriptors > SPIDER_NET_RX_DESCRIPTORS_MAX) { 2529 rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_MAX; 2530 pr_info("adjusting rx descriptors to %i.\n", rx_descriptors); 2531 } 2532 if (tx_descriptors < SPIDER_NET_TX_DESCRIPTORS_MIN) { 2533 tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_MIN; 2534 pr_info("adjusting tx descriptors to %i.\n", tx_descriptors); 2535 } 2536 if (tx_descriptors > SPIDER_NET_TX_DESCRIPTORS_MAX) { 2537 tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_MAX; 2538 pr_info("adjusting tx descriptors to %i.\n", tx_descriptors); 2539 } 2540 2541 return pci_register_driver(&spider_net_driver); 2542 } 2543 2544 /** 2545 * spider_net_cleanup - exit function when driver is unloaded 2546 * 2547 * spider_net_cleanup unregisters the device driver 2548 */ 2549 static void __exit spider_net_cleanup(void) 2550 { 2551 pci_unregister_driver(&spider_net_driver); 2552 } 2553 2554 module_init(spider_net_init); 2555 module_exit(spider_net_cleanup); 2556